go/opentelemetry-go
go/opentelemetry-go
1
0
Fork 0
mirror of https://github.com/open-telemetry/opentelemetry-go.git synced 2025-02-05 13:15:41 +02:00
Code Issues Releases Activity

Eliminate Uint64NumberKind from API (#864)

Browse Source 
fixes #851

This includes all of the associated methods, such as
  AsUint64, AsUint64Atomic, AsUint64Ptr, CoerceToUint64, SetUint64
  SetUint64Atomic, SwapUint64, SwapUint64Atomic, AddUint64,
  AddUint64Atomic, CompamreAndSwapUint64, CompareUint64

Only significant change as a result was converting the histogram
aggregator's `count` state field into an int64 from a `metric.Number`.

Co-authored-by: Tyler Yahn <MrAlias@users.noreply.github.com>
This commit is contained in:
ET 2020-06-23 16:28:04 -07:00 committed by GitHub
parent 665c0de552
commit a8faf8cacc
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 8 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

123
api/metric/number.go
View File

@ -32,9 +32,6 @@ const (
Int64NumberKind NumberKind = iota
// Float64NumberKind means that the Number stores float64.
Float64NumberKind
// Uint64NumberKind means that the Number stores uint64.
// TODO: This can be removed, it's not used.
Uint64NumberKind
)
// Zero returns a zero value for a given NumberKind
@ -44,8 +41,6 @@ func (k NumberKind) Zero() Number {
return NewInt64Number(0)
case Float64NumberKind:
return NewFloat64Number(0.)
case Uint64NumberKind:
return NewUint64Number(0)
default:
return Number(0)
}
@ -59,8 +54,6 @@ func (k NumberKind) Minimum() Number {
return NewInt64Number(math.MinInt64)
case Float64NumberKind:
return NewFloat64Number(-1. * math.MaxFloat64)
case Uint64NumberKind:
return NewUint64Number(0)
default:
return Number(0)
}
@ -74,8 +67,6 @@ func (k NumberKind) Maximum() Number {
return NewInt64Number(math.MaxInt64)
case Float64NumberKind:
return NewFloat64Number(math.MaxFloat64)
case Uint64NumberKind:
return NewUint64Number(math.MaxUint64)
default:
return Number(0)
}
@ -103,11 +94,6 @@ func NewFloat64Number(f float64) Number {
return NewNumberFromRaw(internal.Float64ToRaw(f))
}
// NewInt64Number creates an integral Number.
func NewUint64Number(u uint64) Number {
return NewNumberFromRaw(internal.Uint64ToRaw(u))
}
// NewNumberSignChange returns a number with the same magnitude and
// the opposite sign. `kind` must describe the kind of number in `nn`.
//
@ -147,12 +133,6 @@ func (n *Number) AsFloat64() float64 {
return internal.RawToFloat64(n.AsRaw())
}
// AsUint64 assumes that the value contains an uint64 and returns it
// as such.
func (n *Number) AsUint64() uint64 {
return internal.RawToUint64(n.AsRaw())
}
// - as x atomic
// AsNumberAtomic gets the Number atomically.
@ -178,12 +158,6 @@ func (n *Number) AsFloat64Atomic() float64 {
return internal.RawToFloat64(n.AsRawAtomic())
}
// AsUint64Atomic assumes that the number contains a uint64 and
// returns it as such atomically.
func (n *Number) AsUint64Atomic() uint64 {
return atomic.LoadUint64(n.AsUint64Ptr())
}
// - as x ptr
// AsRawPtr gets the pointer to the raw, uninterpreted raw
@ -204,12 +178,6 @@ func (n *Number) AsFloat64Ptr() *float64 {
return internal.RawPtrToFloat64Ptr(n.AsRawPtr())
}
// AsUint64Ptr assumes that the number contains a uint64 and returns a
// pointer to it.
func (n *Number) AsUint64Ptr() *uint64 {
return internal.RawPtrToUint64Ptr(n.AsRawPtr())
}
// - coerce
// CoerceToInt64 casts the number to int64. May result in
@ -220,8 +188,6 @@ func (n *Number) CoerceToInt64(kind NumberKind) int64 {
return n.AsInt64()
case Float64NumberKind:
return int64(n.AsFloat64())
case Uint64NumberKind:
return int64(n.AsUint64())
default:
// you get what you deserve
return 0
@ -236,24 +202,6 @@ func (n *Number) CoerceToFloat64(kind NumberKind) float64 {
return float64(n.AsInt64())
case Float64NumberKind:
return n.AsFloat64()
case Uint64NumberKind:
return float64(n.AsUint64())
default:
// you get what you deserve
return 0
}
}
// CoerceToUint64 casts the number to uint64. May result in
// data/precision loss.
func (n *Number) CoerceToUint64(kind NumberKind) uint64 {
switch kind {
case Int64NumberKind:
return uint64(n.AsInt64())
case Float64NumberKind:
return uint64(n.AsFloat64())
case Uint64NumberKind:
return n.AsUint64()
default:
// you get what you deserve
return 0
@ -286,12 +234,6 @@ func (n *Number) SetFloat64(f float64) {
*n.AsFloat64Ptr() = f
}
// SetUint64 assumes that the number contains a uint64 and sets it to
// the passed value.
func (n *Number) SetUint64(u uint64) {
*n.AsUint64Ptr() = u
}
// - set atomic
// SetNumberAtomic sets the number to the passed number
@ -319,12 +261,6 @@ func (n *Number) SetFloat64Atomic(f float64) {
atomic.StoreUint64(n.AsRawPtr(), internal.Float64ToRaw(f))
}
// SetUint64Atomic assumes that the number contains a uint64 and sets
// it to the passed value atomically.
func (n *Number) SetUint64Atomic(u uint64) {
atomic.StoreUint64(n.AsUint64Ptr(), u)
}
// - swap
// SwapNumber sets the number to the passed number and returns the old
@ -361,14 +297,6 @@ func (n *Number) SwapFloat64(f float64) float64 {
return old
}
// SwapUint64 assumes that the number contains an uint64, sets it to
// the passed value and returns the old uint64 value.
func (n *Number) SwapUint64(u uint64) uint64 {
old := n.AsUint64()
n.SetUint64(u)
return old
}
// - swap atomic
// SwapNumberAtomic sets the number to the passed number and returns
@ -398,12 +326,6 @@ func (n *Number) SwapFloat64Atomic(f float64) float64 {
return internal.RawToFloat64(atomic.SwapUint64(n.AsRawPtr(), internal.Float64ToRaw(f)))
}
// SwapUint64Atomic assumes that the number contains an uint64, sets
// it to the passed value and returns the old uint64 value atomically.
func (n *Number) SwapUint64Atomic(u uint64) uint64 {
return atomic.SwapUint64(n.AsUint64Ptr(), u)
}
// - add
// AddNumber assumes that this and the passed number are of the passed
@ -414,8 +336,6 @@ func (n *Number) AddNumber(kind NumberKind, nn Number) {
n.AddInt64(nn.AsInt64())
case Float64NumberKind:
n.AddFloat64(nn.AsFloat64())
case Uint64NumberKind:
n.AddUint64(nn.AsUint64())
}
}
@ -437,12 +357,6 @@ func (n *Number) AddFloat64(f float64) {
*n.AsFloat64Ptr() += f
}
// AddUint64 assumes that the number contains a uint64 and adds the
// passed uint64 to it.
func (n *Number) AddUint64(u uint64) {
*n.AsUint64Ptr() += u
}
// - add atomic
// AddNumberAtomic assumes that this and the passed number are of the
@ -453,8 +367,6 @@ func (n *Number) AddNumberAtomic(kind NumberKind, nn Number) {
n.AddInt64Atomic(nn.AsInt64())
case Float64NumberKind:
n.AddFloat64Atomic(nn.AsFloat64())
case Uint64NumberKind:
n.AddUint64Atomic(nn.AsUint64())
}
}
@ -482,12 +394,6 @@ func (n *Number) AddFloat64Atomic(f float64) {
}
}
// AddUint64Atomic assumes that the number contains a uint64 and
// atomically adds the passed uint64 to it.
func (n *Number) AddUint64Atomic(u uint64) {
atomic.AddUint64(n.AsUint64Ptr(), u)
}
// - compare and swap (atomic only)
// CompareAndSwapNumber does the atomic CAS operation on this
@ -516,12 +422,6 @@ func (n *Number) CompareAndSwapFloat64(of, nf float64) bool {
return atomic.CompareAndSwapUint64(n.AsRawPtr(), internal.Float64ToRaw(of), internal.Float64ToRaw(nf))
}
// CompareAndSwapUint64 assumes that this number contains a uint64 and
// does the atomic CAS operation on it.
func (n *Number) CompareAndSwapUint64(ou, nu uint64) bool {
return atomic.CompareAndSwapUint64(n.AsUint64Ptr(), ou, nu)
}
// - compare
// CompareNumber compares two Numbers given their kind. Both numbers
@ -535,8 +435,6 @@ func (n *Number) CompareNumber(kind NumberKind, nn Number) int {
return n.CompareInt64(nn.AsInt64())
case Float64NumberKind:
return n.CompareFloat64(nn.AsFloat64())
case Uint64NumberKind:
return n.CompareUint64(nn.AsUint64())
default:
// you get what you deserve
return 0
@ -581,21 +479,6 @@ func (n *Number) CompareFloat64(f float64) int {
return 0
}
// CompareUint64 assumes that the Number contains an uint64 and performs
// a comparison between the value and the other value. It returns the
// typical result of the compare function: -1 if the value is less
// than the other, 0 if both are equal, 1 if the value is greater than
// the other.
func (n *Number) CompareUint64(u uint64) int {
this := n.AsUint64()
if this < u {
return -1
} else if this > u {
return 1
}
return 0
}
// - relations to zero
// IsPositive returns true if the actual value is greater than zero.
@ -624,8 +507,6 @@ func (n *Number) Emit(kind NumberKind) string {
return fmt.Sprintf("%d", n.AsInt64())
case Float64NumberKind:
return fmt.Sprintf("%f", n.AsFloat64())
case Uint64NumberKind:
return fmt.Sprintf("%d", n.AsUint64())
default:
return ""
}
@ -639,8 +520,6 @@ func (n *Number) AsInterface(kind NumberKind) interface{} {
return n.AsInt64()
case Float64NumberKind:
return n.AsFloat64()
case Uint64NumberKind:
return n.AsUint64()
default:
return math.NaN()
}
@ -654,8 +533,6 @@ func (n *Number) compareWithZero(kind NumberKind) int {
return n.CompareInt64(0)
case Float64NumberKind:
return n.CompareFloat64(0.)
case Uint64NumberKind:
return n.CompareUint64(0)
default:
// you get what you deserve
return 0

5
api/metric/number_test.go
View File

@ -156,9 +156,8 @@ func TestNumberZero(t *testing.T) {
zero := Number(0)
zerof := NewFloat64Number(0)
zeroi := NewInt64Number(0)
zerou := NewUint64Number(0)
if zero != zerof || zero != zeroi || zero != zerou {
if zero != zerof || zero != zeroi {
t.Errorf("Invalid zero representations")
}
}
@ -166,10 +165,8 @@ func TestNumberZero(t *testing.T) {
func TestNumberAsInterface(t *testing.T) {
i64 := NewInt64Number(10)
f64 := NewFloat64Number(11.11)
u64 := NewUint64Number(100)
require.Equal(t, int64(10), (&i64).AsInterface(Int64NumberKind).(int64))
require.Equal(t, 11.11, (&f64).AsInterface(Float64NumberKind).(float64))
require.Equal(t, uint64(100), (&u64).AsInterface(Uint64NumberKind).(uint64))
}
func TestNumberSignChange(t *testing.T) {

5
api/metric/numberkind_string.go
View File

@ -10,12 +10,11 @@ func _() {
var x [1]struct{}
_ = x[Int64NumberKind-0]
_ = x[Float64NumberKind-1]
_ = x[Uint64NumberKind-2]
}
const _NumberKind_name = "Int64NumberKindFloat64NumberKindUint64NumberKind"
const _NumberKind_name = "Int64NumberKindFloat64NumberKind"
var _NumberKind_index = [...]uint8{0, 15, 32, 48}
var _NumberKind_index = [...]uint8{0, 15, 32}
func (i NumberKind) String() string {
if i < 0 || i >= NumberKind(len(_NumberKind_index)-1) {

2
exporters/otlp/internal/transform/metric.go
View File

@ -263,7 +263,7 @@ func sum(record export.Record, a aggregation.Sum) (*metricpb.Metric, error) {
}
switch n := desc.NumberKind(); n {
case metric.Int64NumberKind, metric.Uint64NumberKind:
case metric.Int64NumberKind:
m.MetricDescriptor.Type = metricpb.MetricDescriptor_COUNTER_INT64
m.Int64DataPoints = []*metricpb.Int64DataPoint{
{

59
exporters/otlp/otlp_metric_test.go
View File

@ -283,8 +283,6 @@ func TestValuerecorderMetricGroupingExport(t *testing.T) {
}
runMetricExportTests(t, []record{r, r}, expected)
//changing the number kind should make no difference.
r.nKind = metric.Uint64NumberKind
runMetricExportTests(t, []record{r, r}, expected)
r.nKind = metric.Float64NumberKind
runMetricExportTests(t, []record{r, r}, expected)
}
@ -330,60 +328,6 @@ func TestCountInt64MetricGroupingExport(t *testing.T) {
)
}
func TestCountUint64MetricGroupingExport(t *testing.T) {
r := record{
"uint64-count",
metric.CounterKind,
metric.Uint64NumberKind,
nil,
nil,
append(baseKeyValues, cpuKey.Int(1)),
}
runMetricExportTests(
t,
[]record{r, r},
[]metricpb.ResourceMetrics{
{
Resource: nil,
InstrumentationLibraryMetrics: []*metricpb.InstrumentationLibraryMetrics{
{
Metrics: []*metricpb.Metric{
{
MetricDescriptor: &metricpb.MetricDescriptor{
Name: "uint64-count",
Type: metricpb.MetricDescriptor_COUNTER_INT64,
Labels: []*commonpb.StringKeyValue{
{
Key: "CPU",
Value: "1",
},
{
Key: "host",
Value: "test.com",
},
},
},
Int64DataPoints: []*metricpb.Int64DataPoint{
{
Value: 11,
StartTimeUnixNano: startTime(),
TimeUnixNano: pointTime(),
},
{
Value: 11,
StartTimeUnixNano: startTime(),
TimeUnixNano: pointTime(),
},
},
},
},
},
},
},
},
)
}
func TestCountFloat64MetricGroupingExport(t *testing.T) {
r := record{
"float64-count",
@ -729,9 +673,6 @@ func runMetricExportTest(t *testing.T, exp *Exporter, rs []record, expected []me
ctx := context.Background()
switch r.nKind {
case metric.Uint64NumberKind:
require.NoError(t, agg.Update(ctx, metric.NewUint64Number(1), &desc))
require.NoError(t, agg.Update(ctx, metric.NewUint64Number(10), &desc))
case metric.Int64NumberKind:
require.NoError(t, agg.Update(ctx, metric.NewInt64Number(1), &desc))
require.NoError(t, agg.Update(ctx, metric.NewInt64Number(10), &desc))

8
sdk/metric/aggregator/histogram/histogram.go
View File

@ -45,8 +45,8 @@ type (
// the less than equal bucket count for the pre-determined boundaries.
state struct {
bucketCounts []float64
count metric.Number
sum metric.Number
count int64
}
)
@ -100,7 +100,7 @@ func (c *Aggregator) Sum() (metric.Number, error) {
// Count returns the number of values in the checkpoint.
func (c *Aggregator) Count() (int64, error) {
return int64(c.state.count), nil
return c.state.count, nil
}
// Histogram returns the count of events in pre-determined buckets.
@ -160,7 +160,7 @@ func (c *Aggregator) Update(_ context.Context, number metric.Number, desc *metri
c.lock.Lock()
defer c.lock.Unlock()
c.state.count.AddInt64(1)
c.state.count++
c.state.sum.AddNumber(kind, number)
c.state.bucketCounts[bucketID]++
@ -175,7 +175,7 @@ func (c *Aggregator) Merge(oa export.Aggregator, desc *metric.Descriptor) error
}
c.state.sum.AddNumber(desc.NumberKind(), o.state.sum)
c.state.count.AddNumber(metric.Uint64NumberKind, o.state.count)
c.state.count += o.state.count
for i := 0; i < len(c.state.bucketCounts); i++ {
c.state.bucketCounts[i] += o.state.bucketCounts[i]