go/opentelemetry-go
go/opentelemetry-go
1
0
Fork 0
mirror of https://github.com/open-telemetry/opentelemetry-go.git synced 2025-04-17 11:46:27 +02:00
Code Issues Releases Activity

Rename metric instruments to match feature-freeze API specification (#2202)

Browse Source 
* s/ValueRecorder/Histogram/g

* s/ValueObserver/GaugeObserver/g

* s/UpDownSumObserver/UpDownCounterObserver/g

* s/SumObserver/CounterObserver/g

* changelog

* pr num

* unstable->experimental

* Apply suggestions from code review

Co-authored-by: Tyler Yahn <MrAlias@users.noreply.github.com>

* Apply suggestions from code review

* apply feedback from @evantorrie by hand

* Apply suggestions from code review

Thanks

Co-authored-by: ET <evantorrie@users.noreply.github.com>

* Update sdk/export/metric/metric.go

* Apply suggestions from code review

Thank you @evantorrie !

Co-authored-by: ET <evantorrie@users.noreply.github.com>

* revert getting-started fix let tyler's update remove this text

* more variable name fixes

* test repair

Co-authored-by: Tyler Yahn <MrAlias@users.noreply.github.com>
Co-authored-by: ET <evantorrie@users.noreply.github.com>
Co-authored-by: Anthony Mirabella <a9@aneurysm9.com>
This commit is contained in:
Joshua MacDonald 2021-09-01 13:38:37 -07:00 committed by GitHub
parent 1f527a52ab
commit a7b9d02167
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
42 changed files with 543 additions and 537 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
CHANGELOG.md
View File

@ -17,6 +17,12 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
### Changed ### Changed
- Metric instruments have been renamed to match the (feature-frozen) metric API specification:
- ValueRecorder becomes Histogram
- ValueObserver becomes Gauge
- SumObserver becomes CounterObserver
- UpDownSumObserver becomes UpDownCounterObserver
The API exported from this project is still considered experimental. (#2202)
- Metric SDK/API implementation type `InstrumentKind` moves into `sdkapi` sub-package. (#2091) - Metric SDK/API implementation type `InstrumentKind` moves into `sdkapi` sub-package. (#2091)
- The Metrics SDK export record no longer contains a Resource pointer, the SDK `"go.opentelemetry.io/otel/sdk/trace/export/metric".Exporter.Export()` function for push-based exporters now takes a single Resource argument, pull-based exporters use `"go.opentelemetry.io/otel/sdk/metric/controller/basic".Controller.Resource()`. (#2120) - The Metrics SDK export record no longer contains a Resource pointer, the SDK `"go.opentelemetry.io/otel/sdk/trace/export/metric".Exporter.Export()` function for push-based exporters now takes a single Resource argument, pull-based exporters use `"go.opentelemetry.io/otel/sdk/metric/controller/basic".Controller.Resource()`. (#2120)
- The JSON output of the `go.opentelemetry.io/otel/exporters/stdout/stdouttrace` is harmonized now such that the output is "plain" JSON objects after each other of the form `{ ... } { ... } { ... }`. Earlier the JSON objects describing a span were wrapped in a slice for each `Exporter.ExportSpans` call, like `[ { ... } ][ { ... } { ... } ]`. Outputting JSON object directly after each other is consistent with JSON loggers, and a bit easier to parse and read. (#2196) - The JSON output of the `go.opentelemetry.io/otel/exporters/stdout/stdouttrace` is harmonized now such that the output is "plain" JSON objects after each other of the form `{ ... } { ... } { ... }`. Earlier the JSON objects describing a span were wrapped in a slice for each `Exporter.ExportSpans` call, like `[ { ... } ][ { ... } { ... } ]`. Outputting JSON object directly after each other is consistent with JSON loggers, and a bit easier to parse and read. (#2196)

8
bridge/opencensus/exporter.go
View File

@ -142,16 +142,16 @@ func convertDescriptor(ocDescriptor metricdata.Descriptor) (metric.Descriptor, e
switch ocDescriptor.Type { switch ocDescriptor.Type {
case metricdata.TypeGaugeInt64: case metricdata.TypeGaugeInt64:
nkind = number.Int64Kind nkind = number.Int64Kind
ikind = sdkapi.ValueObserverInstrumentKind ikind = sdkapi.GaugeObserverInstrumentKind
case metricdata.TypeGaugeFloat64: case metricdata.TypeGaugeFloat64:
nkind = number.Float64Kind nkind = number.Float64Kind
ikind = sdkapi.ValueObserverInstrumentKind ikind = sdkapi.GaugeObserverInstrumentKind
case metricdata.TypeCumulativeInt64: case metricdata.TypeCumulativeInt64:
nkind = number.Int64Kind nkind = number.Int64Kind
ikind = sdkapi.SumObserverInstrumentKind ikind = sdkapi.CounterObserverInstrumentKind
case metricdata.TypeCumulativeFloat64: case metricdata.TypeCumulativeFloat64:
nkind = number.Float64Kind nkind = number.Float64Kind
ikind = sdkapi.SumObserverInstrumentKind ikind = sdkapi.CounterObserverInstrumentKind
default: default:
// Includes TypeGaugeDistribution, TypeCumulativeDistribution, TypeSummary // Includes TypeGaugeDistribution, TypeCumulativeDistribution, TypeSummary
return metric.Descriptor{}, fmt.Errorf("%w; descriptor type: %v", errConversion, ocDescriptor.Type) return metric.Descriptor{}, fmt.Errorf("%w; descriptor type: %v", errConversion, ocDescriptor.Type)

12
bridge/opencensus/exporter_test.go
View File

@ -73,7 +73,7 @@ func TestExportMetrics(t *testing.T) {
now := time.Now() now := time.Now()
basicDesc := metric.NewDescriptor( basicDesc := metric.NewDescriptor(
"", "",
sdkapi.ValueObserverInstrumentKind, sdkapi.GaugeObserverInstrumentKind,
number.Int64Kind, number.Int64Kind,
metric.WithInstrumentationName("OpenCensus Bridge"), metric.WithInstrumentationName("OpenCensus Bridge"),
) )
@ -395,7 +395,7 @@ func TestConvertDescriptor(t *testing.T) {
desc: "empty descriptor", desc: "empty descriptor",
expected: metric.NewDescriptor( expected: metric.NewDescriptor(
"", "",
sdkapi.ValueObserverInstrumentKind, sdkapi.GaugeObserverInstrumentKind,
number.Int64Kind, number.Int64Kind,
metric.WithInstrumentationName("OpenCensus Bridge"), metric.WithInstrumentationName("OpenCensus Bridge"),
), ),
@ -410,7 +410,7 @@ func TestConvertDescriptor(t *testing.T) {
}, },
expected: metric.NewDescriptor( expected: metric.NewDescriptor(
"foo", "foo",
sdkapi.ValueObserverInstrumentKind, sdkapi.GaugeObserverInstrumentKind,
number.Int64Kind, number.Int64Kind,
metric.WithInstrumentationName("OpenCensus Bridge"), metric.WithInstrumentationName("OpenCensus Bridge"),
metric.WithDescription("bar"), metric.WithDescription("bar"),
@ -427,7 +427,7 @@ func TestConvertDescriptor(t *testing.T) {
}, },
expected: metric.NewDescriptor( expected: metric.NewDescriptor(
"foo", "foo",
sdkapi.ValueObserverInstrumentKind, sdkapi.GaugeObserverInstrumentKind,
number.Float64Kind, number.Float64Kind,
metric.WithInstrumentationName("OpenCensus Bridge"), metric.WithInstrumentationName("OpenCensus Bridge"),
metric.WithDescription("bar"), metric.WithDescription("bar"),
@ -444,7 +444,7 @@ func TestConvertDescriptor(t *testing.T) {
}, },
expected: metric.NewDescriptor( expected: metric.NewDescriptor(
"foo", "foo",
sdkapi.SumObserverInstrumentKind, sdkapi.CounterObserverInstrumentKind,
number.Int64Kind, number.Int64Kind,
metric.WithInstrumentationName("OpenCensus Bridge"), metric.WithInstrumentationName("OpenCensus Bridge"),
metric.WithDescription("bar"), metric.WithDescription("bar"),
@ -461,7 +461,7 @@ func TestConvertDescriptor(t *testing.T) {
}, },
expected: metric.NewDescriptor( expected: metric.NewDescriptor(
"foo", "foo",
sdkapi.SumObserverInstrumentKind, sdkapi.CounterObserverInstrumentKind,
number.Float64Kind, number.Float64Kind,
metric.WithInstrumentationName("OpenCensus Bridge"), metric.WithInstrumentationName("OpenCensus Bridge"),
metric.WithDescription("bar"), metric.WithDescription("bar"),

12
example/prometheus/main.go
View File

@ -76,11 +76,11 @@ func main() {
(*observerLock).RUnlock() (*observerLock).RUnlock()
result.Observe(value, labels...) result.Observe(value, labels...)
} }
_ = metric.Must(meter).NewFloat64ValueObserver("ex.com.one", cb, _ = metric.Must(meter).NewFloat64GaugeObserver("ex.com.one", cb,
metric.WithDescription("A ValueObserver set to 1.0"), metric.WithDescription("A GaugeObserver set to 1.0"),
) )
valuerecorder := metric.Must(meter).NewFloat64ValueRecorder("ex.com.two") histogram := metric.Must(meter).NewFloat64Histogram("ex.com.two")
counter := metric.Must(meter).NewFloat64Counter("ex.com.three") counter := metric.Must(meter).NewFloat64Counter("ex.com.three")
commonLabels := []attribute.KeyValue{lemonsKey.Int(10), attribute.String("A", "1"), attribute.String("B", "2"), attribute.String("C", "3")} commonLabels := []attribute.KeyValue{lemonsKey.Int(10), attribute.String("A", "1"), attribute.String("B", "2"), attribute.String("C", "3")}
@ -95,7 +95,7 @@ func main() {
meter.RecordBatch( meter.RecordBatch(
ctx, ctx,
commonLabels, commonLabels,
valuerecorder.Measurement(2.0), histogram.Measurement(2.0),
counter.Measurement(12.0), counter.Measurement(12.0),
) )
@ -108,7 +108,7 @@ func main() {
meter.RecordBatch( meter.RecordBatch(
ctx, ctx,
notSoCommonLabels, notSoCommonLabels,
valuerecorder.Measurement(2.0), histogram.Measurement(2.0),
counter.Measurement(22.0), counter.Measurement(22.0),
) )
@ -121,7 +121,7 @@ func main() {
meter.RecordBatch( meter.RecordBatch(
ctx, ctx,
commonLabels, commonLabels,
valuerecorder.Measurement(12.0), histogram.Measurement(12.0),
counter.Measurement(13.0), counter.Measurement(13.0),
) )

12
exporters/otlp/otlpmetric/exporter_test.go
View File

@ -212,10 +212,10 @@ func TestNoGroupingExport(t *testing.T) {
) )
} }
func TestValuerecorderMetricGroupingExport(t *testing.T) { func TestHistogramMetricGroupingExport(t *testing.T) {
r := record{ r := record{
"valuerecorder", "histogram",
sdkapi.ValueRecorderInstrumentKind, sdkapi.HistogramInstrumentKind,
number.Int64Kind, number.Int64Kind,
nil, nil,
append(baseKeyValues, cpuKey.Int(1)), append(baseKeyValues, cpuKey.Int(1)),
@ -227,7 +227,7 @@ func TestValuerecorderMetricGroupingExport(t *testing.T) {
{ {
Metrics: []*metricpb.Metric{ Metrics: []*metricpb.Metric{
{ {
Name: "valuerecorder", Name: "histogram",
Data: &metricpb.Metric_Histogram{ Data: &metricpb.Metric_Histogram{
Histogram: &metricpb.Histogram{ Histogram: &metricpb.Histogram{
AggregationTemporality: metricpb.AggregationTemporality_AGGREGATION_TEMPORALITY_CUMULATIVE, AggregationTemporality: metricpb.AggregationTemporality_AGGREGATION_TEMPORALITY_CUMULATIVE,
@ -606,8 +606,8 @@ func TestStatelessExportKind(t *testing.T) {
for _, k := range []testcase{ for _, k := range []testcase{
{"counter", sdkapi.CounterInstrumentKind, metricpb.AggregationTemporality_AGGREGATION_TEMPORALITY_DELTA, true}, {"counter", sdkapi.CounterInstrumentKind, metricpb.AggregationTemporality_AGGREGATION_TEMPORALITY_DELTA, true},
{"updowncounter", sdkapi.UpDownCounterInstrumentKind, metricpb.AggregationTemporality_AGGREGATION_TEMPORALITY_DELTA, false}, {"updowncounter", sdkapi.UpDownCounterInstrumentKind, metricpb.AggregationTemporality_AGGREGATION_TEMPORALITY_DELTA, false},
{"sumobserver", sdkapi.SumObserverInstrumentKind, metricpb.AggregationTemporality_AGGREGATION_TEMPORALITY_CUMULATIVE, true}, {"counterobserver", sdkapi.CounterObserverInstrumentKind, metricpb.AggregationTemporality_AGGREGATION_TEMPORALITY_CUMULATIVE, true},
{"updownsumobserver", sdkapi.UpDownSumObserverInstrumentKind, metricpb.AggregationTemporality_AGGREGATION_TEMPORALITY_CUMULATIVE, false}, {"updowncounterobserver", sdkapi.UpDownCounterObserverInstrumentKind, metricpb.AggregationTemporality_AGGREGATION_TEMPORALITY_CUMULATIVE, false},
} { } {
t.Run(k.name, func(t *testing.T) { t.Run(k.name, func(t *testing.T) {
runMetricExportTests( runMetricExportTests(

14
exporters/otlp/otlpmetric/internal/metrictransform/metric_test.go
View File

@ -122,7 +122,7 @@ func TestMinMaxSumCountValue(t *testing.T) {
} }
func TestMinMaxSumCountDatapoints(t *testing.T) { func TestMinMaxSumCountDatapoints(t *testing.T) {
desc := metric.NewDescriptor("", sdkapi.ValueRecorderInstrumentKind, number.Int64Kind) desc := metric.NewDescriptor("", sdkapi.HistogramInstrumentKind, number.Int64Kind)
labels := attribute.NewSet(attribute.String("one", "1")) labels := attribute.NewSet(attribute.String("one", "1"))
mmscs := minmaxsumcount.New(2, &metric.Descriptor{}) mmscs := minmaxsumcount.New(2, &metric.Descriptor{})
mmsc, ckpt := &mmscs[0], &mmscs[1] mmsc, ckpt := &mmscs[0], &mmscs[1]
@ -178,7 +178,7 @@ func TestMinMaxSumCountPropagatesErrors(t *testing.T) {
} }
func TestSumIntDataPoints(t *testing.T) { func TestSumIntDataPoints(t *testing.T) {
desc := metric.NewDescriptor("", sdkapi.ValueRecorderInstrumentKind, number.Int64Kind) desc := metric.NewDescriptor("", sdkapi.HistogramInstrumentKind, number.Int64Kind)
labels := attribute.NewSet(attribute.String("one", "1")) labels := attribute.NewSet(attribute.String("one", "1"))
sums := sumAgg.New(2) sums := sumAgg.New(2)
s, ckpt := &sums[0], &sums[1] s, ckpt := &sums[0], &sums[1]
@ -218,7 +218,7 @@ func TestSumIntDataPoints(t *testing.T) {
} }
func TestSumFloatDataPoints(t *testing.T) { func TestSumFloatDataPoints(t *testing.T) {
desc := metric.NewDescriptor("", sdkapi.ValueRecorderInstrumentKind, number.Float64Kind) desc := metric.NewDescriptor("", sdkapi.HistogramInstrumentKind, number.Float64Kind)
labels := attribute.NewSet(attribute.String("one", "1")) labels := attribute.NewSet(attribute.String("one", "1"))
sums := sumAgg.New(2) sums := sumAgg.New(2)
s, ckpt := &sums[0], &sums[1] s, ckpt := &sums[0], &sums[1]
@ -256,7 +256,7 @@ func TestSumFloatDataPoints(t *testing.T) {
} }
func TestLastValueIntDataPoints(t *testing.T) { func TestLastValueIntDataPoints(t *testing.T) {
desc := metric.NewDescriptor("", sdkapi.ValueRecorderInstrumentKind, number.Int64Kind) desc := metric.NewDescriptor("", sdkapi.HistogramInstrumentKind, number.Int64Kind)
labels := attribute.NewSet(attribute.String("one", "1")) labels := attribute.NewSet(attribute.String("one", "1"))
lvs := lvAgg.New(2) lvs := lvAgg.New(2)
lv, ckpt := &lvs[0], &lvs[1] lv, ckpt := &lvs[0], &lvs[1]
@ -291,7 +291,7 @@ func TestLastValueIntDataPoints(t *testing.T) {
} }
func TestExactIntDataPoints(t *testing.T) { func TestExactIntDataPoints(t *testing.T) {
desc := metric.NewDescriptor("", sdkapi.ValueRecorderInstrumentKind, number.Int64Kind) desc := metric.NewDescriptor("", sdkapi.HistogramInstrumentKind, number.Int64Kind)
labels := attribute.NewSet(attribute.String("one", "1")) labels := attribute.NewSet(attribute.String("one", "1"))
arrs := arrAgg.New(2) arrs := arrAgg.New(2)
e, ckpt := &arrs[0], &arrs[1] e, ckpt := &arrs[0], &arrs[1]
@ -326,7 +326,7 @@ func TestExactIntDataPoints(t *testing.T) {
} }
func TestExactFloatDataPoints(t *testing.T) { func TestExactFloatDataPoints(t *testing.T) {
desc := metric.NewDescriptor("", sdkapi.ValueRecorderInstrumentKind, number.Float64Kind) desc := metric.NewDescriptor("", sdkapi.HistogramInstrumentKind, number.Float64Kind)
labels := attribute.NewSet(attribute.String("one", "1")) labels := attribute.NewSet(attribute.String("one", "1"))
arrs := arrAgg.New(2) arrs := arrAgg.New(2)
e, ckpt := &arrs[0], &arrs[1] e, ckpt := &arrs[0], &arrs[1]
@ -360,7 +360,7 @@ func TestExactFloatDataPoints(t *testing.T) {
} }
func TestSumErrUnknownValueType(t *testing.T) { func TestSumErrUnknownValueType(t *testing.T) {
desc := metric.NewDescriptor("", sdkapi.ValueRecorderInstrumentKind, number.Kind(-1)) desc := metric.NewDescriptor("", sdkapi.HistogramInstrumentKind, number.Kind(-1))
labels := attribute.NewSet() labels := attribute.NewSet()
s := &sumAgg.New(1)[0] s := &sumAgg.New(1)[0]
record := export.NewRecord(&desc, &labels, s, intervalStart, intervalEnd) record := export.NewRecord(&desc, &labels, s, intervalStart, intervalEnd)

26
exporters/otlp/otlpmetric/internal/otlpmetrictest/otlptest.go
View File

@ -55,10 +55,10 @@ func RunEndToEndTest(ctx context.Context, t *testing.T, exp *otlpmetric.Exporter
instruments := map[string]data{ instruments := map[string]data{
"test-int64-counter": {sdkapi.CounterInstrumentKind, number.Int64Kind, 1}, "test-int64-counter": {sdkapi.CounterInstrumentKind, number.Int64Kind, 1},
"test-float64-counter": {sdkapi.CounterInstrumentKind, number.Float64Kind, 1}, "test-float64-counter": {sdkapi.CounterInstrumentKind, number.Float64Kind, 1},
"test-int64-valuerecorder": {sdkapi.ValueRecorderInstrumentKind, number.Int64Kind, 2}, "test-int64-histogram": {sdkapi.HistogramInstrumentKind, number.Int64Kind, 2},
"test-float64-valuerecorder": {sdkapi.ValueRecorderInstrumentKind, number.Float64Kind, 2}, "test-float64-histogram": {sdkapi.HistogramInstrumentKind, number.Float64Kind, 2},
"test-int64-valueobserver": {sdkapi.ValueObserverInstrumentKind, number.Int64Kind, 3}, "test-int64-gaugeobserver": {sdkapi.GaugeObserverInstrumentKind, number.Int64Kind, 3},
"test-float64-valueobserver": {sdkapi.ValueObserverInstrumentKind, number.Float64Kind, 3}, "test-float64-gaugeobserver": {sdkapi.GaugeObserverInstrumentKind, number.Float64Kind, 3},
} }
for name, data := range instruments { for name, data := range instruments {
data := data data := data
@ -72,19 +72,19 @@ func RunEndToEndTest(ctx context.Context, t *testing.T, exp *otlpmetric.Exporter
default: default:
assert.Failf(t, "unsupported number testing kind", data.nKind.String()) assert.Failf(t, "unsupported number testing kind", data.nKind.String())
} }
case sdkapi.ValueRecorderInstrumentKind: case sdkapi.HistogramInstrumentKind:
switch data.nKind { switch data.nKind {
case number.Int64Kind: case number.Int64Kind:
metric.Must(meter).NewInt64ValueRecorder(name).Record(ctx, data.val, labels...) metric.Must(meter).NewInt64Histogram(name).Record(ctx, data.val, labels...)
case number.Float64Kind: case number.Float64Kind:
metric.Must(meter).NewFloat64ValueRecorder(name).Record(ctx, float64(data.val), labels...) metric.Must(meter).NewFloat64Histogram(name).Record(ctx, float64(data.val), labels...)
default: default:
assert.Failf(t, "unsupported number testing kind", data.nKind.String()) assert.Failf(t, "unsupported number testing kind", data.nKind.String())
} }
case sdkapi.ValueObserverInstrumentKind: case sdkapi.GaugeObserverInstrumentKind:
switch data.nKind { switch data.nKind {
case number.Int64Kind: case number.Int64Kind:
metric.Must(meter).NewInt64ValueObserver(name, metric.Must(meter).NewInt64GaugeObserver(name,
func(_ context.Context, result metric.Int64ObserverResult) { func(_ context.Context, result metric.Int64ObserverResult) {
result.Observe(data.val, labels...) result.Observe(data.val, labels...)
}, },
@ -93,7 +93,7 @@ func RunEndToEndTest(ctx context.Context, t *testing.T, exp *otlpmetric.Exporter
callback := func(v float64) metric.Float64ObserverFunc { callback := func(v float64) metric.Float64ObserverFunc {
return metric.Float64ObserverFunc(func(_ context.Context, result metric.Float64ObserverResult) { result.Observe(v, labels...) }) return metric.Float64ObserverFunc(func(_ context.Context, result metric.Float64ObserverResult) { result.Observe(v, labels...) })
}(float64(data.val)) }(float64(data.val))
metric.Must(meter).NewFloat64ValueObserver(name, callback) metric.Must(meter).NewFloat64GaugeObserver(name, callback)
default: default:
assert.Failf(t, "unsupported number testing kind", data.nKind.String()) assert.Failf(t, "unsupported number testing kind", data.nKind.String())
} }
@ -131,13 +131,13 @@ func RunEndToEndTest(ctx context.Context, t *testing.T, exp *otlpmetric.Exporter
seen[m.Name] = struct{}{} seen[m.Name] = struct{}{}
switch data.iKind { switch data.iKind {
case sdkapi.CounterInstrumentKind, sdkapi.ValueObserverInstrumentKind: case sdkapi.CounterInstrumentKind, sdkapi.GaugeObserverInstrumentKind:
var dp []*metricpb.NumberDataPoint var dp []*metricpb.NumberDataPoint
switch data.iKind { switch data.iKind {
case sdkapi.CounterInstrumentKind: case sdkapi.CounterInstrumentKind:
require.NotNil(t, m.GetSum()) require.NotNil(t, m.GetSum())
dp = m.GetSum().GetDataPoints() dp = m.GetSum().GetDataPoints()
case sdkapi.ValueObserverInstrumentKind: case sdkapi.GaugeObserverInstrumentKind:
require.NotNil(t, m.GetGauge()) require.NotNil(t, m.GetGauge())
dp = m.GetGauge().GetDataPoints() dp = m.GetGauge().GetDataPoints()
} }
@ -151,7 +151,7 @@ func RunEndToEndTest(ctx context.Context, t *testing.T, exp *otlpmetric.Exporter
assert.Equal(t, v, dp[0].Value, "invalid value for %q", m.Name) assert.Equal(t, v, dp[0].Value, "invalid value for %q", m.Name)
} }
} }
case sdkapi.ValueRecorderInstrumentKind: case sdkapi.HistogramInstrumentKind:
require.NotNil(t, m.GetSummary()) require.NotNil(t, m.GetSummary())
if dp := m.GetSummary().DataPoints; assert.Len(t, dp, 1) { if dp := m.GetSummary().DataPoints; assert.Len(t, dp, 1) {
count := dp[0].Count count := dp[0].Count

24
exporters/prometheus/prometheus_test.go
View File

@ -109,7 +109,7 @@ func TestPrometheusExporter(t *testing.T) {
meter := exporter.MeterProvider().Meter("test") meter := exporter.MeterProvider().Meter("test")
upDownCounter := metric.Must(meter).NewFloat64UpDownCounter("updowncounter") upDownCounter := metric.Must(meter).NewFloat64UpDownCounter("updowncounter")
counter := metric.Must(meter).NewFloat64Counter("counter") counter := metric.Must(meter).NewFloat64Counter("counter")
valuerecorder := metric.Must(meter).NewFloat64ValueRecorder("valuerecorder") histogram := metric.Must(meter).NewFloat64Histogram("histogram")
labels := []attribute.KeyValue{ labels := []attribute.KeyValue{
attribute.Key("A").String("B"), attribute.Key("A").String("B"),
@ -124,23 +124,23 @@ func TestPrometheusExporter(t *testing.T) {
expected = append(expected, expectCounter("counter", `counter{A="B",C="D",R="V"} 15.3`)) expected = append(expected, expectCounter("counter", `counter{A="B",C="D",R="V"} 15.3`))
_ = metric.Must(meter).NewInt64ValueObserver("intobserver", func(_ context.Context, result metric.Int64ObserverResult) { _ = metric.Must(meter).NewInt64GaugeObserver("intobserver", func(_ context.Context, result metric.Int64ObserverResult) {
result.Observe(1, labels...) result.Observe(1, labels...)
}) })
expected = append(expected, expectGauge("intobserver", `intobserver{A="B",C="D",R="V"} 1`)) expected = append(expected, expectGauge("intobserver", `intobserver{A="B",C="D",R="V"} 1`))
valuerecorder.Record(ctx, -0.6, labels...) histogram.Record(ctx, -0.6, labels...)
valuerecorder.Record(ctx, -0.4, labels...) histogram.Record(ctx, -0.4, labels...)
valuerecorder.Record(ctx, 0.6, labels...) histogram.Record(ctx, 0.6, labels...)
valuerecorder.Record(ctx, 20, labels...) histogram.Record(ctx, 20, labels...)
expected = append(expected, expectHistogram("valuerecorder", expected = append(expected, expectHistogram("histogram",
`valuerecorder_bucket{A="B",C="D",R="V",le="-0.5"} 1`, `histogram_bucket{A="B",C="D",R="V",le="-0.5"} 1`,
`valuerecorder_bucket{A="B",C="D",R="V",le="1"} 3`, `histogram_bucket{A="B",C="D",R="V",le="1"} 3`,
`valuerecorder_bucket{A="B",C="D",R="V",le="+Inf"} 4`, `histogram_bucket{A="B",C="D",R="V",le="+Inf"} 4`,
`valuerecorder_sum{A="B",C="D",R="V"} 19.6`, `histogram_sum{A="B",C="D",R="V"} 19.6`,
`valuerecorder_count{A="B",C="D",R="V"} 4`, `histogram_count{A="B",C="D",R="V"} 4`,
)) ))
upDownCounter.Add(ctx, 10, labels...) upDownCounter.Add(ctx, 10, labels...)

2
exporters/stdout/stdoutmetric/example_test.go
View File

@ -40,7 +40,7 @@ var (
) )
loopCounter = metric.Must(meter).NewInt64Counter("function.loops") loopCounter = metric.Must(meter).NewInt64Counter("function.loops")
paramValue = metric.Must(meter).NewInt64ValueRecorder("function.param") paramValue = metric.Must(meter).NewInt64Histogram("function.param")
nameKey = attribute.Key("function.name") nameKey = attribute.Key("function.name")
) )

4
exporters/stdout/stdoutmetric/metric_test.go
View File

@ -169,10 +169,10 @@ func TestStdoutMinMaxSumCount(t *testing.T) {
require.Equal(t, `[{"Name":"name.minmaxsumcount{R=V,instrumentation.name=test,A=B,C=D}","Min":123.456,"Max":876.543,"Sum":999.999,"Count":2}]`, fix.Output()) require.Equal(t, `[{"Name":"name.minmaxsumcount{R=V,instrumentation.name=test,A=B,C=D}","Min":123.456,"Max":876.543,"Sum":999.999,"Count":2}]`, fix.Output())
} }
func TestStdoutValueRecorderFormat(t *testing.T) { func TestStdoutHistogramFormat(t *testing.T) {
fix := newFixture(t, stdoutmetric.WithPrettyPrint()) fix := newFixture(t, stdoutmetric.WithPrettyPrint())
inst := metric.Must(fix.meter).NewFloat64ValueRecorder("name.histogram") inst := metric.Must(fix.meter).NewFloat64Histogram("name.histogram")
for i := 0; i < 1000; i++ { for i := 0; i < 1000; i++ {
inst.Record(fix.ctx, float64(i)+0.5, attribute.String("A", "B"), attribute.String("C", "D")) inst.Record(fix.ctx, float64(i)+0.5, attribute.String("A", "B"), attribute.String("C", "D"))

42
internal/metric/global/meter_test.go
View File

@ -48,21 +48,21 @@ func TestDirect(t *testing.T) {
counter.Add(ctx, 1, labels1...) counter.Add(ctx, 1, labels1...)
counter.Add(ctx, 1, labels1...) counter.Add(ctx, 1, labels1...)
valuerecorder := Must(meter1).NewFloat64ValueRecorder("test.valuerecorder") histogram := Must(meter1).NewFloat64Histogram("test.histogram")
valuerecorder.Record(ctx, 1, labels1...) histogram.Record(ctx, 1, labels1...)
valuerecorder.Record(ctx, 2, labels1...) histogram.Record(ctx, 2, labels1...)
_ = Must(meter1).NewFloat64ValueObserver("test.valueobserver.float", func(_ context.Context, result metric.Float64ObserverResult) { _ = Must(meter1).NewFloat64GaugeObserver("test.gauge.float", func(_ context.Context, result metric.Float64ObserverResult) {
result.Observe(1., labels1...) result.Observe(1., labels1...)
result.Observe(2., labels2...) result.Observe(2., labels2...)
}) })
_ = Must(meter1).NewInt64ValueObserver("test.valueobserver.int", func(_ context.Context, result metric.Int64ObserverResult) { _ = Must(meter1).NewInt64GaugeObserver("test.gauge.int", func(_ context.Context, result metric.Int64ObserverResult) {
result.Observe(1, labels1...) result.Observe(1, labels1...)
result.Observe(2, labels2...) result.Observe(2, labels2...)
}) })
second := Must(meter2).NewFloat64ValueRecorder("test.second") second := Must(meter2).NewFloat64Histogram("test.second")
second.Record(ctx, 1, labels3...) second.Record(ctx, 1, labels3...)
second.Record(ctx, 2, labels3...) second.Record(ctx, 2, labels3...)
@ -70,7 +70,7 @@ func TestDirect(t *testing.T) {
metricglobal.SetMeterProvider(provider) metricglobal.SetMeterProvider(provider)
counter.Add(ctx, 1, labels1...) counter.Add(ctx, 1, labels1...)
valuerecorder.Record(ctx, 3, labels1...) histogram.Record(ctx, 3, labels1...)
second.Record(ctx, 3, labels3...) second.Record(ctx, 3, labels3...)
mock.RunAsyncInstruments() mock.RunAsyncInstruments()
@ -87,7 +87,7 @@ func TestDirect(t *testing.T) {
Number: asInt(1), Number: asInt(1),
}, },
{ {
Name: "test.valuerecorder", Name: "test.histogram",
InstrumentationName: "test1", InstrumentationName: "test1",
InstrumentationVersion: "semver:v1.0.0", InstrumentationVersion: "semver:v1.0.0",
Labels: metrictest.LabelsToMap(labels1...), Labels: metrictest.LabelsToMap(labels1...),
@ -100,28 +100,28 @@ func TestDirect(t *testing.T) {
Number: asFloat(3), Number: asFloat(3),
}, },
{ {
Name: "test.valueobserver.float", Name: "test.gauge.float",
InstrumentationName: "test1", InstrumentationName: "test1",
InstrumentationVersion: "semver:v1.0.0", InstrumentationVersion: "semver:v1.0.0",
Labels: metrictest.LabelsToMap(labels1...), Labels: metrictest.LabelsToMap(labels1...),
Number: asFloat(1), Number: asFloat(1),
}, },
{ {
Name: "test.valueobserver.float", Name: "test.gauge.float",
InstrumentationName: "test1", InstrumentationName: "test1",
InstrumentationVersion: "semver:v1.0.0", InstrumentationVersion: "semver:v1.0.0",
Labels: metrictest.LabelsToMap(labels2...), Labels: metrictest.LabelsToMap(labels2...),
Number: asFloat(2), Number: asFloat(2),
}, },
{ {
Name: "test.valueobserver.int", Name: "test.gauge.int",
InstrumentationName: "test1", InstrumentationName: "test1",
InstrumentationVersion: "semver:v1.0.0", InstrumentationVersion: "semver:v1.0.0",
Labels: metrictest.LabelsToMap(labels1...), Labels: metrictest.LabelsToMap(labels1...),
Number: asInt(1), Number: asInt(1),
}, },
{ {
Name: "test.valueobserver.int", Name: "test.gauge.int",
InstrumentationName: "test1", InstrumentationName: "test1",
InstrumentationVersion: "semver:v1.0.0", InstrumentationVersion: "semver:v1.0.0",
Labels: metrictest.LabelsToMap(labels2...), Labels: metrictest.LabelsToMap(labels2...),
@ -146,8 +146,8 @@ func TestBound(t *testing.T) {
boundC.Add(ctx, 1) boundC.Add(ctx, 1)
boundC.Add(ctx, 1) boundC.Add(ctx, 1)
valuerecorder := Must(glob).NewInt64ValueRecorder("test.valuerecorder") histogram := Must(glob).NewInt64Histogram("test.histogram")
boundM := valuerecorder.Bind(labels1...) boundM := histogram.Bind(labels1...)
boundM.Record(ctx, 1) boundM.Record(ctx, 1)
boundM.Record(ctx, 2) boundM.Record(ctx, 2)
@ -166,7 +166,7 @@ func TestBound(t *testing.T) {
Number: asFloat(1), Number: asFloat(1),
}, },
{ {
Name: "test.valuerecorder", Name: "test.histogram",
InstrumentationName: "test", InstrumentationName: "test",
Labels: metrictest.LabelsToMap(labels1...), Labels: metrictest.LabelsToMap(labels1...),
Number: asInt(3), Number: asInt(3),
@ -188,8 +188,8 @@ func TestUnbind(t *testing.T) {
counter := Must(glob).NewFloat64Counter("test.counter") counter := Must(glob).NewFloat64Counter("test.counter")
boundC := counter.Bind(labels1...) boundC := counter.Bind(labels1...)
valuerecorder := Must(glob).NewInt64ValueRecorder("test.valuerecorder") histogram := Must(glob).NewInt64Histogram("test.histogram")
boundM := valuerecorder.Bind(labels1...) boundM := histogram.Bind(labels1...)
boundC.Unbind() boundC.Unbind()
boundM.Unbind() boundM.Unbind()
@ -268,12 +268,12 @@ func TestImplementationIndirection(t *testing.T) {
require.False(t, ok) require.False(t, ok)
// Async: no SDK yet // Async: no SDK yet
valueobserver := Must(meter1).NewFloat64ValueObserver( gauge := Must(meter1).NewFloat64GaugeObserver(
"interface.valueobserver", "interface.gauge",
func(_ context.Context, result metric.Float64ObserverResult) {}, func(_ context.Context, result metric.Float64ObserverResult) {},
) )
ival = valueobserver.AsyncImpl().Implementation() ival = gauge.AsyncImpl().Implementation()
require.NotNil(t, ival) require.NotNil(t, ival)
_, ok = ival.(*metrictest.Async) _, ok = ival.(*metrictest.Async)
@ -293,7 +293,7 @@ func TestImplementationIndirection(t *testing.T) {
require.True(t, ok) require.True(t, ok)
// Async // Async
ival = valueobserver.AsyncImpl().Implementation() ival = gauge.AsyncImpl().Implementation()
require.NotNil(t, ival) require.NotNil(t, ival)
_, ok = ival.(*metrictest.Async) _, ok = ival.(*metrictest.Async)

16
internal/metric/global/registry_test.go
View File

@ -37,17 +37,17 @@ var (
"counter.float64": func(name, libraryName string) (metric.InstrumentImpl, error) { "counter.float64": func(name, libraryName string) (metric.InstrumentImpl, error) {
return unwrap(MeterProvider().Meter(libraryName).NewFloat64Counter(name)) return unwrap(MeterProvider().Meter(libraryName).NewFloat64Counter(name))
}, },
"valuerecorder.int64": func(name, libraryName string) (metric.InstrumentImpl, error) { "histogram.int64": func(name, libraryName string) (metric.InstrumentImpl, error) {
return unwrap(MeterProvider().Meter(libraryName).NewInt64ValueRecorder(name)) return unwrap(MeterProvider().Meter(libraryName).NewInt64Histogram(name))
}, },
"valuerecorder.float64": func(name, libraryName string) (metric.InstrumentImpl, error) { "histogram.float64": func(name, libraryName string) (metric.InstrumentImpl, error) {
return unwrap(MeterProvider().Meter(libraryName).NewFloat64ValueRecorder(name)) return unwrap(MeterProvider().Meter(libraryName).NewFloat64Histogram(name))
}, },
"valueobserver.int64": func(name, libraryName string) (metric.InstrumentImpl, error) { "gauge.int64": func(name, libraryName string) (metric.InstrumentImpl, error) {
return unwrap(MeterProvider().Meter(libraryName).NewInt64ValueObserver(name, func(context.Context, metric.Int64ObserverResult) {})) return unwrap(MeterProvider().Meter(libraryName).NewInt64GaugeObserver(name, func(context.Context, metric.Int64ObserverResult) {}))
}, },
"valueobserver.float64": func(name, libraryName string) (metric.InstrumentImpl, error) { "gauge.float64": func(name, libraryName string) (metric.InstrumentImpl, error) {
return unwrap(MeterProvider().Meter(libraryName).NewFloat64ValueObserver(name, func(context.Context, metric.Float64ObserverResult) {})) return unwrap(MeterProvider().Meter(libraryName).NewFloat64GaugeObserver(name, func(context.Context, metric.Float64ObserverResult) {}))
}, },
} }
) )

16
metric/doc.go
View File

@ -31,23 +31,23 @@ part of a system is being measured.
Instruments are categorized as Synchronous or Asynchronous and independently Instruments are categorized as Synchronous or Asynchronous and independently
as Adding or Grouping. Synchronous instruments are called by the user with a as Adding or Grouping. Synchronous instruments are called by the user with a
Context. Asynchronous instruments are called by the SDK during collection. Context. Asynchronous instruments are called by the SDK during collection.
Additive instruments are semantically intended for capturing a sum. Grouping Adding instruments are semantically intended for capturing a sum. Grouping
instruments are intended for capturing a distribution. instruments are intended for capturing a distribution.
Additive instruments may be monotonic, in which case they are non-decreasing Adding instruments may be monotonic, in which case they are non-decreasing
and naturally define a rate. and naturally define a rate.
The synchronous instrument names are: The synchronous instrument names are:
Counter: additive, monotonic Counter: adding, monotonic
UpDownCounter: additive UpDownCounter: adding
ValueRecorder: grouping Histogram: grouping
and the asynchronous instruments are: and the asynchronous instruments are:
SumObserver: additive, monotonic CounterObserver: adding, monotonic
UpDownSumObserver: additive UpDownCounterObserver: adding
ValueObserver: grouping GaugeObserver: grouping
All instruments are provided with support for either float64 or int64 input All instruments are provided with support for either float64 or int64 input
values. values.

220
metric/metric.go
View File

@ -95,174 +95,174 @@ func (m Meter) NewFloat64UpDownCounter(name string, options ...InstrumentOption)
m.newSync(name, sdkapi.UpDownCounterInstrumentKind, number.Float64Kind, options)) m.newSync(name, sdkapi.UpDownCounterInstrumentKind, number.Float64Kind, options))
} }
// NewInt64ValueRecorder creates a new integer ValueRecorder instrument with the // NewInt64Histogram creates a new integer Histogram instrument with the
// given name, customized with options. May return an error if the // given name, customized with options. May return an error if the
// name is invalid (e.g., empty) or improperly registered (e.g., // name is invalid (e.g., empty) or improperly registered (e.g.,
// duplicate registration). // duplicate registration).
func (m Meter) NewInt64ValueRecorder(name string, opts ...InstrumentOption) (Int64ValueRecorder, error) { func (m Meter) NewInt64Histogram(name string, opts ...InstrumentOption) (Int64Histogram, error) {
return wrapInt64ValueRecorderInstrument( return wrapInt64HistogramInstrument(
m.newSync(name, sdkapi.ValueRecorderInstrumentKind, number.Int64Kind, opts)) m.newSync(name, sdkapi.HistogramInstrumentKind, number.Int64Kind, opts))
} }
// NewFloat64ValueRecorder creates a new floating point ValueRecorder with the // NewFloat64Histogram creates a new floating point Histogram with the
// given name, customized with options. May return an error if the // given name, customized with options. May return an error if the
// name is invalid (e.g., empty) or improperly registered (e.g., // name is invalid (e.g., empty) or improperly registered (e.g.,
// duplicate registration). // duplicate registration).
func (m Meter) NewFloat64ValueRecorder(name string, opts ...InstrumentOption) (Float64ValueRecorder, error) { func (m Meter) NewFloat64Histogram(name string, opts ...InstrumentOption) (Float64Histogram, error) {
return wrapFloat64ValueRecorderInstrument( return wrapFloat64HistogramInstrument(
m.newSync(name, sdkapi.ValueRecorderInstrumentKind, number.Float64Kind, opts)) m.newSync(name, sdkapi.HistogramInstrumentKind, number.Float64Kind, opts))
} }
// NewInt64ValueObserver creates a new integer ValueObserver instrument // NewInt64GaugeObserver creates a new integer GaugeObserver instrument
// with the given name, running a given callback, and customized with // with the given name, running a given callback, and customized with
// options. May return an error if the name is invalid (e.g., empty) // options. May return an error if the name is invalid (e.g., empty)
// or improperly registered (e.g., duplicate registration). // or improperly registered (e.g., duplicate registration).
func (m Meter) NewInt64ValueObserver(name string, callback Int64ObserverFunc, opts ...InstrumentOption) (Int64ValueObserver, error) { func (m Meter) NewInt64GaugeObserver(name string, callback Int64ObserverFunc, opts ...InstrumentOption) (Int64GaugeObserver, error) {
if callback == nil { if callback == nil {
return wrapInt64ValueObserverInstrument(NoopAsync{}, nil) return wrapInt64GaugeObserverInstrument(NoopAsync{}, nil)
} }
return wrapInt64ValueObserverInstrument( return wrapInt64GaugeObserverInstrument(
m.newAsync(name, sdkapi.ValueObserverInstrumentKind, number.Int64Kind, opts, m.newAsync(name, sdkapi.GaugeObserverInstrumentKind, number.Int64Kind, opts,
newInt64AsyncRunner(callback))) newInt64AsyncRunner(callback)))
} }
// NewFloat64ValueObserver creates a new floating point ValueObserver with // NewFloat64GaugeObserver creates a new floating point GaugeObserver with
// the given name, running a given callback, and customized with // the given name, running a given callback, and customized with
// options. May return an error if the name is invalid (e.g., empty) // options. May return an error if the name is invalid (e.g., empty)
// or improperly registered (e.g., duplicate registration). // or improperly registered (e.g., duplicate registration).
func (m Meter) NewFloat64ValueObserver(name string, callback Float64ObserverFunc, opts ...InstrumentOption) (Float64ValueObserver, error) { func (m Meter) NewFloat64GaugeObserver(name string, callback Float64ObserverFunc, opts ...InstrumentOption) (Float64GaugeObserver, error) {
if callback == nil { if callback == nil {
return wrapFloat64ValueObserverInstrument(NoopAsync{}, nil) return wrapFloat64GaugeObserverInstrument(NoopAsync{}, nil)
} }
return wrapFloat64ValueObserverInstrument( return wrapFloat64GaugeObserverInstrument(
m.newAsync(name, sdkapi.ValueObserverInstrumentKind, number.Float64Kind, opts, m.newAsync(name, sdkapi.GaugeObserverInstrumentKind, number.Float64Kind, opts,
newFloat64AsyncRunner(callback))) newFloat64AsyncRunner(callback)))
} }
// NewInt64SumObserver creates a new integer SumObserver instrument // NewInt64CounterObserver creates a new integer CounterObserver instrument
// with the given name, running a given callback, and customized with // with the given name, running a given callback, and customized with
// options. May return an error if the name is invalid (e.g., empty) // options. May return an error if the name is invalid (e.g., empty)
// or improperly registered (e.g., duplicate registration). // or improperly registered (e.g., duplicate registration).
func (m Meter) NewInt64SumObserver(name string, callback Int64ObserverFunc, opts ...InstrumentOption) (Int64SumObserver, error) { func (m Meter) NewInt64CounterObserver(name string, callback Int64ObserverFunc, opts ...InstrumentOption) (Int64CounterObserver, error) {
if callback == nil { if callback == nil {
return wrapInt64SumObserverInstrument(NoopAsync{}, nil) return wrapInt64CounterObserverInstrument(NoopAsync{}, nil)
} }
return wrapInt64SumObserverInstrument( return wrapInt64CounterObserverInstrument(
m.newAsync(name, sdkapi.SumObserverInstrumentKind, number.Int64Kind, opts, m.newAsync(name, sdkapi.CounterObserverInstrumentKind, number.Int64Kind, opts,
newInt64AsyncRunner(callback))) newInt64AsyncRunner(callback)))
} }
// NewFloat64SumObserver creates a new floating point SumObserver with // NewFloat64CounterObserver creates a new floating point CounterObserver with
// the given name, running a given callback, and customized with // the given name, running a given callback, and customized with
// options. May return an error if the name is invalid (e.g., empty) // options. May return an error if the name is invalid (e.g., empty)
// or improperly registered (e.g., duplicate registration). // or improperly registered (e.g., duplicate registration).
func (m Meter) NewFloat64SumObserver(name string, callback Float64ObserverFunc, opts ...InstrumentOption) (Float64SumObserver, error) { func (m Meter) NewFloat64CounterObserver(name string, callback Float64ObserverFunc, opts ...InstrumentOption) (Float64CounterObserver, error) {
if callback == nil { if callback == nil {
return wrapFloat64SumObserverInstrument(NoopAsync{}, nil) return wrapFloat64CounterObserverInstrument(NoopAsync{}, nil)
} }
return wrapFloat64SumObserverInstrument( return wrapFloat64CounterObserverInstrument(
m.newAsync(name, sdkapi.SumObserverInstrumentKind, number.Float64Kind, opts, m.newAsync(name, sdkapi.CounterObserverInstrumentKind, number.Float64Kind, opts,
newFloat64AsyncRunner(callback))) newFloat64AsyncRunner(callback)))
} }
// NewInt64UpDownSumObserver creates a new integer UpDownSumObserver instrument // NewInt64UpDownCounterObserver creates a new integer UpDownCounterObserver instrument
// with the given name, running a given callback, and customized with // with the given name, running a given callback, and customized with
// options. May return an error if the name is invalid (e.g., empty) // options. May return an error if the name is invalid (e.g., empty)
// or improperly registered (e.g., duplicate registration). // or improperly registered (e.g., duplicate registration).
func (m Meter) NewInt64UpDownSumObserver(name string, callback Int64ObserverFunc, opts ...InstrumentOption) (Int64UpDownSumObserver, error) { func (m Meter) NewInt64UpDownCounterObserver(name string, callback Int64ObserverFunc, opts ...InstrumentOption) (Int64UpDownCounterObserver, error) {
if callback == nil { if callback == nil {
return wrapInt64UpDownSumObserverInstrument(NoopAsync{}, nil) return wrapInt64UpDownCounterObserverInstrument(NoopAsync{}, nil)
} }
return wrapInt64UpDownSumObserverInstrument( return wrapInt64UpDownCounterObserverInstrument(
m.newAsync(name, sdkapi.UpDownSumObserverInstrumentKind, number.Int64Kind, opts, m.newAsync(name, sdkapi.UpDownCounterObserverInstrumentKind, number.Int64Kind, opts,
newInt64AsyncRunner(callback))) newInt64AsyncRunner(callback)))
} }
// NewFloat64UpDownSumObserver creates a new floating point UpDownSumObserver with // NewFloat64UpDownCounterObserver creates a new floating point UpDownCounterObserver with
// the given name, running a given callback, and customized with // the given name, running a given callback, and customized with
// options. May return an error if the name is invalid (e.g., empty) // options. May return an error if the name is invalid (e.g., empty)
// or improperly registered (e.g., duplicate registration). // or improperly registered (e.g., duplicate registration).
func (m Meter) NewFloat64UpDownSumObserver(name string, callback Float64ObserverFunc, opts ...InstrumentOption) (Float64UpDownSumObserver, error) { func (m Meter) NewFloat64UpDownCounterObserver(name string, callback Float64ObserverFunc, opts ...InstrumentOption) (Float64UpDownCounterObserver, error) {
if callback == nil { if callback == nil {
return wrapFloat64UpDownSumObserverInstrument(NoopAsync{}, nil) return wrapFloat64UpDownCounterObserverInstrument(NoopAsync{}, nil)
} }
return wrapFloat64UpDownSumObserverInstrument( return wrapFloat64UpDownCounterObserverInstrument(
m.newAsync(name, sdkapi.UpDownSumObserverInstrumentKind, number.Float64Kind, opts, m.newAsync(name, sdkapi.UpDownCounterObserverInstrumentKind, number.Float64Kind, opts,
newFloat64AsyncRunner(callback))) newFloat64AsyncRunner(callback)))
} }
// NewInt64ValueObserver creates a new integer ValueObserver instrument // NewInt64GaugeObserver creates a new integer GaugeObserver instrument
// with the given name, running in a batch callback, and customized with // with the given name, running in a batch callback, and customized with
// options. May return an error if the name is invalid (e.g., empty) // options. May return an error if the name is invalid (e.g., empty)
// or improperly registered (e.g., duplicate registration). // or improperly registered (e.g., duplicate registration).
func (b BatchObserver) NewInt64ValueObserver(name string, opts ...InstrumentOption) (Int64ValueObserver, error) { func (b BatchObserver) NewInt64GaugeObserver(name string, opts ...InstrumentOption) (Int64GaugeObserver, error) {
if b.runner == nil { if b.runner == nil {
return wrapInt64ValueObserverInstrument(NoopAsync{}, nil) return wrapInt64GaugeObserverInstrument(NoopAsync{}, nil)
} }
return wrapInt64ValueObserverInstrument( return wrapInt64GaugeObserverInstrument(
b.meter.newAsync(name, sdkapi.ValueObserverInstrumentKind, number.Int64Kind, opts, b.runner)) b.meter.newAsync(name, sdkapi.GaugeObserverInstrumentKind, number.Int64Kind, opts, b.runner))
} }
// NewFloat64ValueObserver creates a new floating point ValueObserver with // NewFloat64GaugeObserver creates a new floating point GaugeObserver with
// the given name, running in a batch callback, and customized with // the given name, running in a batch callback, and customized with
// options. May return an error if the name is invalid (e.g., empty) // options. May return an error if the name is invalid (e.g., empty)
// or improperly registered (e.g., duplicate registration). // or improperly registered (e.g., duplicate registration).
func (b BatchObserver) NewFloat64ValueObserver(name string, opts ...InstrumentOption) (Float64ValueObserver, error) { func (b BatchObserver) NewFloat64GaugeObserver(name string, opts ...InstrumentOption) (Float64GaugeObserver, error) {
if b.runner == nil { if b.runner == nil {
return wrapFloat64ValueObserverInstrument(NoopAsync{}, nil) return wrapFloat64GaugeObserverInstrument(NoopAsync{}, nil)
} }
return wrapFloat64ValueObserverInstrument( return wrapFloat64GaugeObserverInstrument(
b.meter.newAsync(name, sdkapi.ValueObserverInstrumentKind, number.Float64Kind, opts, b.meter.newAsync(name, sdkapi.GaugeObserverInstrumentKind, number.Float64Kind, opts,
b.runner)) b.runner))
} }
// NewInt64SumObserver creates a new integer SumObserver instrument // NewInt64CounterObserver creates a new integer CounterObserver instrument
// with the given name, running in a batch callback, and customized with // with the given name, running in a batch callback, and customized with
// options. May return an error if the name is invalid (e.g., empty) // options. May return an error if the name is invalid (e.g., empty)
// or improperly registered (e.g., duplicate registration). // or improperly registered (e.g., duplicate registration).
func (b BatchObserver) NewInt64SumObserver(name string, opts ...InstrumentOption) (Int64SumObserver, error) { func (b BatchObserver) NewInt64CounterObserver(name string, opts ...InstrumentOption) (Int64CounterObserver, error) {
if b.runner == nil { if b.runner == nil {
return wrapInt64SumObserverInstrument(NoopAsync{}, nil) return wrapInt64CounterObserverInstrument(NoopAsync{}, nil)
} }
return wrapInt64SumObserverInstrument( return wrapInt64CounterObserverInstrument(
b.meter.newAsync(name, sdkapi.SumObserverInstrumentKind, number.Int64Kind, opts, b.runner)) b.meter.newAsync(name, sdkapi.CounterObserverInstrumentKind, number.Int64Kind, opts, b.runner))
} }
// NewFloat64SumObserver creates a new floating point SumObserver with // NewFloat64CounterObserver creates a new floating point CounterObserver with
// the given name, running in a batch callback, and customized with // the given name, running in a batch callback, and customized with
// options. May return an error if the name is invalid (e.g., empty) // options. May return an error if the name is invalid (e.g., empty)
// or improperly registered (e.g., duplicate registration). // or improperly registered (e.g., duplicate registration).
func (b BatchObserver) NewFloat64SumObserver(name string, opts ...InstrumentOption) (Float64SumObserver, error) { func (b BatchObserver) NewFloat64CounterObserver(name string, opts ...InstrumentOption) (Float64CounterObserver, error) {
if b.runner == nil { if b.runner == nil {
return wrapFloat64SumObserverInstrument(NoopAsync{}, nil) return wrapFloat64CounterObserverInstrument(NoopAsync{}, nil)
} }
return wrapFloat64SumObserverInstrument( return wrapFloat64CounterObserverInstrument(
b.meter.newAsync(name, sdkapi.SumObserverInstrumentKind, number.Float64Kind, opts, b.meter.newAsync(name, sdkapi.CounterObserverInstrumentKind, number.Float64Kind, opts,
b.runner)) b.runner))
} }
// NewInt64UpDownSumObserver creates a new integer UpDownSumObserver instrument // NewInt64UpDownCounterObserver creates a new integer UpDownCounterObserver instrument
// with the given name, running in a batch callback, and customized with // with the given name, running in a batch callback, and customized with
// options. May return an error if the name is invalid (e.g., empty) // options. May return an error if the name is invalid (e.g., empty)
// or improperly registered (e.g., duplicate registration). // or improperly registered (e.g., duplicate registration).
func (b BatchObserver) NewInt64UpDownSumObserver(name string, opts ...InstrumentOption) (Int64UpDownSumObserver, error) { func (b BatchObserver) NewInt64UpDownCounterObserver(name string, opts ...InstrumentOption) (Int64UpDownCounterObserver, error) {
if b.runner == nil { if b.runner == nil {
return wrapInt64UpDownSumObserverInstrument(NoopAsync{}, nil) return wrapInt64UpDownCounterObserverInstrument(NoopAsync{}, nil)
} }
return wrapInt64UpDownSumObserverInstrument( return wrapInt64UpDownCounterObserverInstrument(
b.meter.newAsync(name, sdkapi.UpDownSumObserverInstrumentKind, number.Int64Kind, opts, b.runner)) b.meter.newAsync(name, sdkapi.UpDownCounterObserverInstrumentKind, number.Int64Kind, opts, b.runner))
} }
// NewFloat64UpDownSumObserver creates a new floating point UpDownSumObserver with // NewFloat64UpDownCounterObserver creates a new floating point UpDownCounterObserver with
// the given name, running in a batch callback, and customized with // the given name, running in a batch callback, and customized with
// options. May return an error if the name is invalid (e.g., empty) // options. May return an error if the name is invalid (e.g., empty)
// or improperly registered (e.g., duplicate registration). // or improperly registered (e.g., duplicate registration).
func (b BatchObserver) NewFloat64UpDownSumObserver(name string, opts ...InstrumentOption) (Float64UpDownSumObserver, error) { func (b BatchObserver) NewFloat64UpDownCounterObserver(name string, opts ...InstrumentOption) (Float64UpDownCounterObserver, error) {
if b.runner == nil { if b.runner == nil {
return wrapFloat64UpDownSumObserverInstrument(NoopAsync{}, nil) return wrapFloat64UpDownCounterObserverInstrument(NoopAsync{}, nil)
} }
return wrapFloat64UpDownSumObserverInstrument( return wrapFloat64UpDownCounterObserverInstrument(
b.meter.newAsync(name, sdkapi.UpDownSumObserverInstrumentKind, number.Float64Kind, opts, b.meter.newAsync(name, sdkapi.UpDownCounterObserverInstrumentKind, number.Float64Kind, opts,
b.runner)) b.runner))
} }
@ -369,80 +369,80 @@ func (mm MeterMust) NewFloat64UpDownCounter(name string, cos ...InstrumentOption
} }
} }
// NewInt64ValueRecorder calls `Meter.NewInt64ValueRecorder` and returns the // NewInt64Histogram calls `Meter.NewInt64Histogram` and returns the
// instrument, panicking if it encounters an error. // instrument, panicking if it encounters an error.
func (mm MeterMust) NewInt64ValueRecorder(name string, mos ...InstrumentOption) Int64ValueRecorder { func (mm MeterMust) NewInt64Histogram(name string, mos ...InstrumentOption) Int64Histogram {
if inst, err := mm.meter.NewInt64ValueRecorder(name, mos...); err != nil { if inst, err := mm.meter.NewInt64Histogram(name, mos...); err != nil {
panic(err) panic(err)
} else { } else {
return inst return inst
} }
} }
// NewFloat64ValueRecorder calls `Meter.NewFloat64ValueRecorder` and returns the // NewFloat64Histogram calls `Meter.NewFloat64Histogram` and returns the
// instrument, panicking if it encounters an error. // instrument, panicking if it encounters an error.
func (mm MeterMust) NewFloat64ValueRecorder(name string, mos ...InstrumentOption) Float64ValueRecorder { func (mm MeterMust) NewFloat64Histogram(name string, mos ...InstrumentOption) Float64Histogram {
if inst, err := mm.meter.NewFloat64ValueRecorder(name, mos...); err != nil { if inst, err := mm.meter.NewFloat64Histogram(name, mos...); err != nil {
panic(err) panic(err)
} else { } else {
return inst return inst
} }
} }
// NewInt64ValueObserver calls `Meter.NewInt64ValueObserver` and // NewInt64GaugeObserver calls `Meter.NewInt64GaugeObserver` and
// returns the instrument, panicking if it encounters an error. // returns the instrument, panicking if it encounters an error.
func (mm MeterMust) NewInt64ValueObserver(name string, callback Int64ObserverFunc, oos ...InstrumentOption) Int64ValueObserver { func (mm MeterMust) NewInt64GaugeObserver(name string, callback Int64ObserverFunc, oos ...InstrumentOption) Int64GaugeObserver {
if inst, err := mm.meter.NewInt64ValueObserver(name, callback, oos...); err != nil { if inst, err := mm.meter.NewInt64GaugeObserver(name, callback, oos...); err != nil {
panic(err) panic(err)
} else { } else {
return inst return inst
} }
} }
// NewFloat64ValueObserver calls `Meter.NewFloat64ValueObserver` and // NewFloat64GaugeObserver calls `Meter.NewFloat64GaugeObserver` and
// returns the instrument, panicking if it encounters an error. // returns the instrument, panicking if it encounters an error.
func (mm MeterMust) NewFloat64ValueObserver(name string, callback Float64ObserverFunc, oos ...InstrumentOption) Float64ValueObserver { func (mm MeterMust) NewFloat64GaugeObserver(name string, callback Float64ObserverFunc, oos ...InstrumentOption) Float64GaugeObserver {
if inst, err := mm.meter.NewFloat64ValueObserver(name, callback, oos...); err != nil { if inst, err := mm.meter.NewFloat64GaugeObserver(name, callback, oos...); err != nil {
panic(err) panic(err)
} else { } else {
return inst return inst
} }
} }
// NewInt64SumObserver calls `Meter.NewInt64SumObserver` and // NewInt64CounterObserver calls `Meter.NewInt64CounterObserver` and
// returns the instrument, panicking if it encounters an error. // returns the instrument, panicking if it encounters an error.
func (mm MeterMust) NewInt64SumObserver(name string, callback Int64ObserverFunc, oos ...InstrumentOption) Int64SumObserver { func (mm MeterMust) NewInt64CounterObserver(name string, callback Int64ObserverFunc, oos ...InstrumentOption) Int64CounterObserver {
if inst, err := mm.meter.NewInt64SumObserver(name, callback, oos...); err != nil { if inst, err := mm.meter.NewInt64CounterObserver(name, callback, oos...); err != nil {
panic(err) panic(err)
} else { } else {
return inst return inst
} }
} }
// NewFloat64SumObserver calls `Meter.NewFloat64SumObserver` and // NewFloat64CounterObserver calls `Meter.NewFloat64CounterObserver` and
// returns the instrument, panicking if it encounters an error. // returns the instrument, panicking if it encounters an error.
func (mm MeterMust) NewFloat64SumObserver(name string, callback Float64ObserverFunc, oos ...InstrumentOption) Float64SumObserver { func (mm MeterMust) NewFloat64CounterObserver(name string, callback Float64ObserverFunc, oos ...InstrumentOption) Float64CounterObserver {
if inst, err := mm.meter.NewFloat64SumObserver(name, callback, oos...); err != nil { if inst, err := mm.meter.NewFloat64CounterObserver(name, callback, oos...); err != nil {
panic(err) panic(err)
} else { } else {
return inst return inst
} }
} }
// NewInt64UpDownSumObserver calls `Meter.NewInt64UpDownSumObserver` and // NewInt64UpDownCounterObserver calls `Meter.NewInt64UpDownCounterObserver` and
// returns the instrument, panicking if it encounters an error. // returns the instrument, panicking if it encounters an error.
func (mm MeterMust) NewInt64UpDownSumObserver(name string, callback Int64ObserverFunc, oos ...InstrumentOption) Int64UpDownSumObserver { func (mm MeterMust) NewInt64UpDownCounterObserver(name string, callback Int64ObserverFunc, oos ...InstrumentOption) Int64UpDownCounterObserver {
if inst, err := mm.meter.NewInt64UpDownSumObserver(name, callback, oos...); err != nil { if inst, err := mm.meter.NewInt64UpDownCounterObserver(name, callback, oos...); err != nil {
panic(err) panic(err)
} else { } else {
return inst return inst
} }
} }
// NewFloat64UpDownSumObserver calls `Meter.NewFloat64UpDownSumObserver` and // NewFloat64UpDownCounterObserver calls `Meter.NewFloat64UpDownCounterObserver` and
// returns the instrument, panicking if it encounters an error. // returns the instrument, panicking if it encounters an error.
func (mm MeterMust) NewFloat64UpDownSumObserver(name string, callback Float64ObserverFunc, oos ...InstrumentOption) Float64UpDownSumObserver { func (mm MeterMust) NewFloat64UpDownCounterObserver(name string, callback Float64ObserverFunc, oos ...InstrumentOption) Float64UpDownCounterObserver {
if inst, err := mm.meter.NewFloat64UpDownSumObserver(name, callback, oos...); err != nil { if inst, err := mm.meter.NewFloat64UpDownCounterObserver(name, callback, oos...); err != nil {
panic(err) panic(err)
} else { } else {
return inst return inst
@ -457,60 +457,60 @@ func (mm MeterMust) NewBatchObserver(callback BatchObserverFunc) BatchObserverMu
} }
} }
// NewInt64ValueObserver calls `BatchObserver.NewInt64ValueObserver` and // NewInt64GaugeObserver calls `BatchObserver.NewInt64GaugeObserver` and
// returns the instrument, panicking if it encounters an error. // returns the instrument, panicking if it encounters an error.
func (bm BatchObserverMust) NewInt64ValueObserver(name string, oos ...InstrumentOption) Int64ValueObserver { func (bm BatchObserverMust) NewInt64GaugeObserver(name string, oos ...InstrumentOption) Int64GaugeObserver {
if inst, err := bm.batch.NewInt64ValueObserver(name, oos...); err != nil { if inst, err := bm.batch.NewInt64GaugeObserver(name, oos...); err != nil {
panic(err) panic(err)
} else { } else {
return inst return inst
} }
} }
// NewFloat64ValueObserver calls `BatchObserver.NewFloat64ValueObserver` and // NewFloat64GaugeObserver calls `BatchObserver.NewFloat64GaugeObserver` and
// returns the instrument, panicking if it encounters an error. // returns the instrument, panicking if it encounters an error.
func (bm BatchObserverMust) NewFloat64ValueObserver(name string, oos ...InstrumentOption) Float64ValueObserver { func (bm BatchObserverMust) NewFloat64GaugeObserver(name string, oos ...InstrumentOption) Float64GaugeObserver {
if inst, err := bm.batch.NewFloat64ValueObserver(name, oos...); err != nil { if inst, err := bm.batch.NewFloat64GaugeObserver(name, oos...); err != nil {
panic(err) panic(err)
} else { } else {
return inst return inst
} }
} }
// NewInt64SumObserver calls `BatchObserver.NewInt64SumObserver` and // NewInt64CounterObserver calls `BatchObserver.NewInt64CounterObserver` and
// returns the instrument, panicking if it encounters an error. // returns the instrument, panicking if it encounters an error.
func (bm BatchObserverMust) NewInt64SumObserver(name string, oos ...InstrumentOption) Int64SumObserver { func (bm BatchObserverMust) NewInt64CounterObserver(name string, oos ...InstrumentOption) Int64CounterObserver {
if inst, err := bm.batch.NewInt64SumObserver(name, oos...); err != nil { if inst, err := bm.batch.NewInt64CounterObserver(name, oos...); err != nil {
panic(err) panic(err)
} else { } else {
return inst return inst
} }
} }
// NewFloat64SumObserver calls `BatchObserver.NewFloat64SumObserver` and // NewFloat64CounterObserver calls `BatchObserver.NewFloat64CounterObserver` and
// returns the instrument, panicking if it encounters an error. // returns the instrument, panicking if it encounters an error.
func (bm BatchObserverMust) NewFloat64SumObserver(name string, oos ...InstrumentOption) Float64SumObserver { func (bm BatchObserverMust) NewFloat64CounterObserver(name string, oos ...InstrumentOption) Float64CounterObserver {
if inst, err := bm.batch.NewFloat64SumObserver(name, oos...); err != nil { if inst, err := bm.batch.NewFloat64CounterObserver(name, oos...); err != nil {
panic(err) panic(err)
} else { } else {
return inst return inst
} }
} }
// NewInt64UpDownSumObserver calls `BatchObserver.NewInt64UpDownSumObserver` and // NewInt64UpDownCounterObserver calls `BatchObserver.NewInt64UpDownCounterObserver` and
// returns the instrument, panicking if it encounters an error. // returns the instrument, panicking if it encounters an error.
func (bm BatchObserverMust) NewInt64UpDownSumObserver(name string, oos ...InstrumentOption) Int64UpDownSumObserver { func (bm BatchObserverMust) NewInt64UpDownCounterObserver(name string, oos ...InstrumentOption) Int64UpDownCounterObserver {
if inst, err := bm.batch.NewInt64UpDownSumObserver(name, oos...); err != nil { if inst, err := bm.batch.NewInt64UpDownCounterObserver(name, oos...); err != nil {
panic(err) panic(err)
} else { } else {
return inst return inst
} }
} }
// NewFloat64UpDownSumObserver calls `BatchObserver.NewFloat64UpDownSumObserver` and // NewFloat64UpDownCounterObserver calls `BatchObserver.NewFloat64UpDownCounterObserver` and
// returns the instrument, panicking if it encounters an error. // returns the instrument, panicking if it encounters an error.
func (bm BatchObserverMust) NewFloat64UpDownSumObserver(name string, oos ...InstrumentOption) Float64UpDownSumObserver { func (bm BatchObserverMust) NewFloat64UpDownCounterObserver(name string, oos ...InstrumentOption) Float64UpDownCounterObserver {
if inst, err := bm.batch.NewFloat64UpDownSumObserver(name, oos...); err != nil { if inst, err := bm.batch.NewFloat64UpDownCounterObserver(name, oos...); err != nil {
panic(err) panic(err)
} else { } else {
return inst return inst

134
metric/metric_instrument.go
View File

@ -27,7 +27,7 @@ var ErrSDKReturnedNilImpl = errors.New("SDK returned a nil implementation")
// Observation is used for reporting an asynchronous batch of metric // Observation is used for reporting an asynchronous batch of metric
// values. Instances of this type should be created by asynchronous // values. Instances of this type should be created by asynchronous
// instruments (e.g., Int64ValueObserver.Observation()). // instruments (e.g., Int64GaugeObserver.Observation()).
type Observation struct { type Observation struct {
// number needs to be aligned for 64-bit atomic operations. // number needs to be aligned for 64-bit atomic operations.
number number.Number number number.Number
@ -174,40 +174,40 @@ func (b *BatchObserverFunc) Run(ctx context.Context, function func([]attribute.K
}) })
} }
// wrapInt64ValueObserverInstrument converts an AsyncImpl into Int64ValueObserver. // wrapInt64GaugeObserverInstrument converts an AsyncImpl into Int64GaugeObserver.
func wrapInt64ValueObserverInstrument(asyncInst AsyncImpl, err error) (Int64ValueObserver, error) { func wrapInt64GaugeObserverInstrument(asyncInst AsyncImpl, err error) (Int64GaugeObserver, error) {
common, err := checkNewAsync(asyncInst, err) common, err := checkNewAsync(asyncInst, err)
return Int64ValueObserver{asyncInstrument: common}, err return Int64GaugeObserver{asyncInstrument: common}, err
} }
// wrapFloat64ValueObserverInstrument converts an AsyncImpl into Float64ValueObserver. // wrapFloat64GaugeObserverInstrument converts an AsyncImpl into Float64GaugeObserver.
func wrapFloat64ValueObserverInstrument(asyncInst AsyncImpl, err error) (Float64ValueObserver, error) { func wrapFloat64GaugeObserverInstrument(asyncInst AsyncImpl, err error) (Float64GaugeObserver, error) {
common, err := checkNewAsync(asyncInst, err) common, err := checkNewAsync(asyncInst, err)
return Float64ValueObserver{asyncInstrument: common}, err return Float64GaugeObserver{asyncInstrument: common}, err
} }
// wrapInt64SumObserverInstrument converts an AsyncImpl into Int64SumObserver. // wrapInt64CounterObserverInstrument converts an AsyncImpl into Int64CounterObserver.
func wrapInt64SumObserverInstrument(asyncInst AsyncImpl, err error) (Int64SumObserver, error) { func wrapInt64CounterObserverInstrument(asyncInst AsyncImpl, err error) (Int64CounterObserver, error) {
common, err := checkNewAsync(asyncInst, err) common, err := checkNewAsync(asyncInst, err)
return Int64SumObserver{asyncInstrument: common}, err return Int64CounterObserver{asyncInstrument: common}, err
} }
// wrapFloat64SumObserverInstrument converts an AsyncImpl into Float64SumObserver. // wrapFloat64CounterObserverInstrument converts an AsyncImpl into Float64CounterObserver.
func wrapFloat64SumObserverInstrument(asyncInst AsyncImpl, err error) (Float64SumObserver, error) { func wrapFloat64CounterObserverInstrument(asyncInst AsyncImpl, err error) (Float64CounterObserver, error) {
common, err := checkNewAsync(asyncInst, err) common, err := checkNewAsync(asyncInst, err)
return Float64SumObserver{asyncInstrument: common}, err return Float64CounterObserver{asyncInstrument: common}, err
} }
// wrapInt64UpDownSumObserverInstrument converts an AsyncImpl into Int64UpDownSumObserver. // wrapInt64UpDownCounterObserverInstrument converts an AsyncImpl into Int64UpDownCounterObserver.
func wrapInt64UpDownSumObserverInstrument(asyncInst AsyncImpl, err error) (Int64UpDownSumObserver, error) { func wrapInt64UpDownCounterObserverInstrument(asyncInst AsyncImpl, err error) (Int64UpDownCounterObserver, error) {
common, err := checkNewAsync(asyncInst, err) common, err := checkNewAsync(asyncInst, err)
return Int64UpDownSumObserver{asyncInstrument: common}, err return Int64UpDownCounterObserver{asyncInstrument: common}, err
} }
// wrapFloat64UpDownSumObserverInstrument converts an AsyncImpl into Float64UpDownSumObserver. // wrapFloat64UpDownCounterObserverInstrument converts an AsyncImpl into Float64UpDownCounterObserver.
func wrapFloat64UpDownSumObserverInstrument(asyncInst AsyncImpl, err error) (Float64UpDownSumObserver, error) { func wrapFloat64UpDownCounterObserverInstrument(asyncInst AsyncImpl, err error) (Float64UpDownCounterObserver, error) {
common, err := checkNewAsync(asyncInst, err) common, err := checkNewAsync(asyncInst, err)
return Float64UpDownSumObserver{asyncInstrument: common}, err return Float64UpDownCounterObserver{asyncInstrument: common}, err
} }
// BatchObserver represents an Observer callback that can report // BatchObserver represents an Observer callback that can report
@ -217,39 +217,39 @@ type BatchObserver struct {
runner AsyncBatchRunner runner AsyncBatchRunner
} }
// Int64ValueObserver is a metric that captures a set of int64 values at a // Int64GaugeObserver is a metric that captures a set of int64 values at a
// point in time. // point in time.
type Int64ValueObserver struct { type Int64GaugeObserver struct {
asyncInstrument asyncInstrument
} }
// Float64ValueObserver is a metric that captures a set of float64 values // Float64GaugeObserver is a metric that captures a set of float64 values
// at a point in time. // at a point in time.
type Float64ValueObserver struct { type Float64GaugeObserver struct {
asyncInstrument asyncInstrument
} }
// Int64SumObserver is a metric that captures a precomputed sum of // Int64CounterObserver is a metric that captures a precomputed sum of
// int64 values at a point in time. // int64 values at a point in time.
type Int64SumObserver struct { type Int64CounterObserver struct {
asyncInstrument asyncInstrument
} }
// Float64SumObserver is a metric that captures a precomputed sum of // Float64CounterObserver is a metric that captures a precomputed sum of
// float64 values at a point in time. // float64 values at a point in time.
type Float64SumObserver struct { type Float64CounterObserver struct {
asyncInstrument asyncInstrument
} }
// Int64UpDownSumObserver is a metric that captures a precomputed sum of // Int64UpDownCounterObserver is a metric that captures a precomputed sum of
// int64 values at a point in time. // int64 values at a point in time.
type Int64UpDownSumObserver struct { type Int64UpDownCounterObserver struct {
asyncInstrument asyncInstrument
} }
// Float64UpDownSumObserver is a metric that captures a precomputed sum of // Float64UpDownCounterObserver is a metric that captures a precomputed sum of
// float64 values at a point in time. // float64 values at a point in time.
type Float64UpDownSumObserver struct { type Float64UpDownCounterObserver struct {
asyncInstrument asyncInstrument
} }
@ -257,7 +257,7 @@ type Float64UpDownSumObserver struct {
// argument, for an asynchronous integer instrument. // argument, for an asynchronous integer instrument.
// This returns an implementation-level object for use by the SDK, // This returns an implementation-level object for use by the SDK,
// users should not refer to this. // users should not refer to this.
func (i Int64ValueObserver) Observation(v int64) Observation { func (i Int64GaugeObserver) Observation(v int64) Observation {
return Observation{ return Observation{
number: number.NewInt64Number(v), number: number.NewInt64Number(v),
instrument: i.instrument, instrument: i.instrument,
@ -268,7 +268,7 @@ func (i Int64ValueObserver) Observation(v int64) Observation {
// argument, for an asynchronous integer instrument. // argument, for an asynchronous integer instrument.
// This returns an implementation-level object for use by the SDK, // This returns an implementation-level object for use by the SDK,
// users should not refer to this. // users should not refer to this.
func (f Float64ValueObserver) Observation(v float64) Observation { func (f Float64GaugeObserver) Observation(v float64) Observation {
return Observation{ return Observation{
number: number.NewFloat64Number(v), number: number.NewFloat64Number(v),
instrument: f.instrument, instrument: f.instrument,
@ -279,7 +279,7 @@ func (f Float64ValueObserver) Observation(v float64) Observation {
// argument, for an asynchronous integer instrument. // argument, for an asynchronous integer instrument.
// This returns an implementation-level object for use by the SDK, // This returns an implementation-level object for use by the SDK,
// users should not refer to this. // users should not refer to this.
func (i Int64SumObserver) Observation(v int64) Observation { func (i Int64CounterObserver) Observation(v int64) Observation {
return Observation{ return Observation{
number: number.NewInt64Number(v), number: number.NewInt64Number(v),
instrument: i.instrument, instrument: i.instrument,
@ -290,7 +290,7 @@ func (i Int64SumObserver) Observation(v int64) Observation {
// argument, for an asynchronous integer instrument. // argument, for an asynchronous integer instrument.
// This returns an implementation-level object for use by the SDK, // This returns an implementation-level object for use by the SDK,
// users should not refer to this. // users should not refer to this.
func (f Float64SumObserver) Observation(v float64) Observation { func (f Float64CounterObserver) Observation(v float64) Observation {
return Observation{ return Observation{
number: number.NewFloat64Number(v), number: number.NewFloat64Number(v),
instrument: f.instrument, instrument: f.instrument,
@ -301,7 +301,7 @@ func (f Float64SumObserver) Observation(v float64) Observation {
// argument, for an asynchronous integer instrument. // argument, for an asynchronous integer instrument.
// This returns an implementation-level object for use by the SDK, // This returns an implementation-level object for use by the SDK,
// users should not refer to this. // users should not refer to this.
func (i Int64UpDownSumObserver) Observation(v int64) Observation { func (i Int64UpDownCounterObserver) Observation(v int64) Observation {
return Observation{ return Observation{
number: number.NewInt64Number(v), number: number.NewInt64Number(v),
instrument: i.instrument, instrument: i.instrument,
@ -312,7 +312,7 @@ func (i Int64UpDownSumObserver) Observation(v int64) Observation {
// argument, for an asynchronous integer instrument. // argument, for an asynchronous integer instrument.
// This returns an implementation-level object for use by the SDK, // This returns an implementation-level object for use by the SDK,
// users should not refer to this. // users should not refer to this.
func (f Float64UpDownSumObserver) Observation(v float64) Observation { func (f Float64UpDownCounterObserver) Observation(v float64) Observation {
return Observation{ return Observation{
number: number.NewFloat64Number(v), number: number.NewFloat64Number(v),
instrument: f.instrument, instrument: f.instrument,
@ -474,16 +474,16 @@ func wrapFloat64UpDownCounterInstrument(syncInst SyncImpl, err error) (Float64Up
return Float64UpDownCounter{syncInstrument: common}, err return Float64UpDownCounter{syncInstrument: common}, err
} }
// wrapInt64ValueRecorderInstrument converts a SyncImpl into Int64ValueRecorder. // wrapInt64HistogramInstrument converts a SyncImpl into Int64Histogram.
func wrapInt64ValueRecorderInstrument(syncInst SyncImpl, err error) (Int64ValueRecorder, error) { func wrapInt64HistogramInstrument(syncInst SyncImpl, err error) (Int64Histogram, error) {
common, err := checkNewSync(syncInst, err) common, err := checkNewSync(syncInst, err)
return Int64ValueRecorder{syncInstrument: common}, err return Int64Histogram{syncInstrument: common}, err
} }
// wrapFloat64ValueRecorderInstrument converts a SyncImpl into Float64ValueRecorder. // wrapFloat64HistogramInstrument converts a SyncImpl into Float64Histogram.
func wrapFloat64ValueRecorderInstrument(syncInst SyncImpl, err error) (Float64ValueRecorder, error) { func wrapFloat64HistogramInstrument(syncInst SyncImpl, err error) (Float64Histogram, error) {
common, err := checkNewSync(syncInst, err) common, err := checkNewSync(syncInst, err)
return Float64ValueRecorder{syncInstrument: common}, err return Float64Histogram{syncInstrument: common}, err
} }
// Float64Counter is a metric that accumulates float64 values. // Float64Counter is a metric that accumulates float64 values.
@ -635,78 +635,78 @@ func (b BoundInt64UpDownCounter) Add(ctx context.Context, value int64) {
b.directRecord(ctx, number.NewInt64Number(value)) b.directRecord(ctx, number.NewInt64Number(value))
} }
// Float64ValueRecorder is a metric that records float64 values. // Float64Histogram is a metric that records float64 values.
type Float64ValueRecorder struct { type Float64Histogram struct {
syncInstrument syncInstrument
} }
// Int64ValueRecorder is a metric that records int64 values. // Int64Histogram is a metric that records int64 values.
type Int64ValueRecorder struct { type Int64Histogram struct {
syncInstrument syncInstrument
} }
// BoundFloat64ValueRecorder is a bound instrument for Float64ValueRecorder. // BoundFloat64Histogram is a bound instrument for Float64Histogram.
// //
// It inherits the Unbind function from syncBoundInstrument. // It inherits the Unbind function from syncBoundInstrument.
type BoundFloat64ValueRecorder struct { type BoundFloat64Histogram struct {
syncBoundInstrument syncBoundInstrument
} }
// BoundInt64ValueRecorder is a bound instrument for Int64ValueRecorder. // BoundInt64Histogram is a bound instrument for Int64Histogram.
// //
// It inherits the Unbind function from syncBoundInstrument. // It inherits the Unbind function from syncBoundInstrument.
type BoundInt64ValueRecorder struct { type BoundInt64Histogram struct {
syncBoundInstrument syncBoundInstrument
} }
// Bind creates a bound instrument for this ValueRecorder. The labels are // Bind creates a bound instrument for this Histogram. The labels are
// associated with values recorded via subsequent calls to Record. // associated with values recorded via subsequent calls to Record.
func (c Float64ValueRecorder) Bind(labels ...attribute.KeyValue) (h BoundFloat64ValueRecorder) { func (c Float64Histogram) Bind(labels ...attribute.KeyValue) (h BoundFloat64Histogram) {
h.syncBoundInstrument = c.bind(labels) h.syncBoundInstrument = c.bind(labels)
return return
} }
// Bind creates a bound instrument for this ValueRecorder. The labels are // Bind creates a bound instrument for this Histogram. The labels are
// associated with values recorded via subsequent calls to Record. // associated with values recorded via subsequent calls to Record.
func (c Int64ValueRecorder) Bind(labels ...attribute.KeyValue) (h BoundInt64ValueRecorder) { func (c Int64Histogram) Bind(labels ...attribute.KeyValue) (h BoundInt64Histogram) {
h.syncBoundInstrument = c.bind(labels) h.syncBoundInstrument = c.bind(labels)
return return
} }
// Measurement creates a Measurement object to use with batch // Measurement creates a Measurement object to use with batch
// recording. // recording.
func (c Float64ValueRecorder) Measurement(value float64) Measurement { func (c Float64Histogram) Measurement(value float64) Measurement {
return c.float64Measurement(value) return c.float64Measurement(value)
} }
// Measurement creates a Measurement object to use with batch // Measurement creates a Measurement object to use with batch
// recording. // recording.
func (c Int64ValueRecorder) Measurement(value int64) Measurement { func (c Int64Histogram) Measurement(value int64) Measurement {
return c.int64Measurement(value) return c.int64Measurement(value)
} }
// Record adds a new value to the list of ValueRecorder's records. The // Record adds a new value to the list of Histogram's records. The
// labels should contain the keys and values to be associated with // labels should contain the keys and values to be associated with
// this value. // this value.
func (c Float64ValueRecorder) Record(ctx context.Context, value float64, labels ...attribute.KeyValue) { func (c Float64Histogram) Record(ctx context.Context, value float64, labels ...attribute.KeyValue) {
c.directRecord(ctx, number.NewFloat64Number(value), labels) c.directRecord(ctx, number.NewFloat64Number(value), labels)
} }
// Record adds a new value to the ValueRecorder's distribution. The // Record adds a new value to the Histogram's distribution. The
// labels should contain the keys and values to be associated with // labels should contain the keys and values to be associated with
// this value. // this value.
func (c Int64ValueRecorder) Record(ctx context.Context, value int64, labels ...attribute.KeyValue) { func (c Int64Histogram) Record(ctx context.Context, value int64, labels ...attribute.KeyValue) {
c.directRecord(ctx, number.NewInt64Number(value), labels) c.directRecord(ctx, number.NewInt64Number(value), labels)
} }
// Record adds a new value to the ValueRecorder's distribution using the labels // Record adds a new value to the Histogram's distribution using the labels
// previously bound to the ValueRecorder via Bind(). // previously bound to the Histogram via Bind().
func (b BoundFloat64ValueRecorder) Record(ctx context.Context, value float64) { func (b BoundFloat64Histogram) Record(ctx context.Context, value float64) {
b.directRecord(ctx, number.NewFloat64Number(value)) b.directRecord(ctx, number.NewFloat64Number(value))
} }
// Record adds a new value to the ValueRecorder's distribution using the labels // Record adds a new value to the Histogram's distribution using the labels
// previously bound to the ValueRecorder via Bind(). // previously bound to the Histogram via Bind().
func (b BoundInt64ValueRecorder) Record(ctx context.Context, value int64) { func (b BoundInt64Histogram) Record(ctx context.Context, value int64) {
b.directRecord(ctx, number.NewInt64Number(value)) b.directRecord(ctx, number.NewInt64Number(value))
} }

2
metric/metric_sdkapi.go
View File

@ -54,7 +54,7 @@ type InstrumentImpl interface {
} }
// SyncImpl is the implementation-level interface to a generic // SyncImpl is the implementation-level interface to a generic
// synchronous instrument (e.g., ValueRecorder and Counter instruments). // synchronous instrument (e.g., Histogram and Counter instruments).
type SyncImpl interface { type SyncImpl interface {
InstrumentImpl InstrumentImpl

98
metric/metric_test.go
View File

@ -35,48 +35,48 @@ var Must = metric.Must
var ( var (
syncKinds = []sdkapi.InstrumentKind{ syncKinds = []sdkapi.InstrumentKind{
sdkapi.ValueRecorderInstrumentKind, sdkapi.HistogramInstrumentKind,
sdkapi.CounterInstrumentKind, sdkapi.CounterInstrumentKind,
sdkapi.UpDownCounterInstrumentKind, sdkapi.UpDownCounterInstrumentKind,
} }
asyncKinds = []sdkapi.InstrumentKind{ asyncKinds = []sdkapi.InstrumentKind{
sdkapi.ValueObserverInstrumentKind, sdkapi.GaugeObserverInstrumentKind,
sdkapi.SumObserverInstrumentKind, sdkapi.CounterObserverInstrumentKind,
sdkapi.UpDownSumObserverInstrumentKind, sdkapi.UpDownCounterObserverInstrumentKind,
} }
addingKinds = []sdkapi.InstrumentKind{ addingKinds = []sdkapi.InstrumentKind{
sdkapi.CounterInstrumentKind, sdkapi.CounterInstrumentKind,
sdkapi.UpDownCounterInstrumentKind, sdkapi.UpDownCounterInstrumentKind,
sdkapi.SumObserverInstrumentKind, sdkapi.CounterObserverInstrumentKind,
sdkapi.UpDownSumObserverInstrumentKind, sdkapi.UpDownCounterObserverInstrumentKind,
} }
groupingKinds = []sdkapi.InstrumentKind{ groupingKinds = []sdkapi.InstrumentKind{
sdkapi.ValueRecorderInstrumentKind, sdkapi.HistogramInstrumentKind,
sdkapi.ValueObserverInstrumentKind, sdkapi.GaugeObserverInstrumentKind,
} }
monotonicKinds = []sdkapi.InstrumentKind{ monotonicKinds = []sdkapi.InstrumentKind{
sdkapi.CounterInstrumentKind, sdkapi.CounterInstrumentKind,
sdkapi.SumObserverInstrumentKind, sdkapi.CounterObserverInstrumentKind,
} }
nonMonotonicKinds = []sdkapi.InstrumentKind{ nonMonotonicKinds = []sdkapi.InstrumentKind{
sdkapi.UpDownCounterInstrumentKind, sdkapi.UpDownCounterInstrumentKind,
sdkapi.UpDownSumObserverInstrumentKind, sdkapi.UpDownCounterObserverInstrumentKind,
sdkapi.ValueRecorderInstrumentKind, sdkapi.HistogramInstrumentKind,
sdkapi.ValueObserverInstrumentKind, sdkapi.GaugeObserverInstrumentKind,
} }
precomputedSumKinds = []sdkapi.InstrumentKind{ precomputedSumKinds = []sdkapi.InstrumentKind{
sdkapi.SumObserverInstrumentKind, sdkapi.CounterObserverInstrumentKind,
sdkapi.UpDownSumObserverInstrumentKind, sdkapi.UpDownCounterObserverInstrumentKind,
} }
nonPrecomputedSumKinds = []sdkapi.InstrumentKind{ nonPrecomputedSumKinds = []sdkapi.InstrumentKind{
sdkapi.CounterInstrumentKind, sdkapi.CounterInstrumentKind,
sdkapi.UpDownCounterInstrumentKind, sdkapi.UpDownCounterInstrumentKind,
sdkapi.ValueRecorderInstrumentKind, sdkapi.HistogramInstrumentKind,
sdkapi.ValueObserverInstrumentKind, sdkapi.GaugeObserverInstrumentKind,
} }
) )
@ -363,99 +363,99 @@ func TestCounter(t *testing.T) {
}) })
} }
func TestValueRecorder(t *testing.T) { func TestHistogram(t *testing.T) {
t.Run("float64 valuerecorder", func(t *testing.T) { t.Run("float64 histogram", func(t *testing.T) {
mockSDK, meter := metrictest.NewMeter() mockSDK, meter := metrictest.NewMeter()
m := Must(meter).NewFloat64ValueRecorder("test.valuerecorder.float") m := Must(meter).NewFloat64Histogram("test.histogram.float")
ctx := context.Background() ctx := context.Background()
labels := []attribute.KeyValue{} labels := []attribute.KeyValue{}
m.Record(ctx, 42, labels...) m.Record(ctx, 42, labels...)
boundInstrument := m.Bind(labels...) boundInstrument := m.Bind(labels...)
boundInstrument.Record(ctx, 0) boundInstrument.Record(ctx, 0)
meter.RecordBatch(ctx, labels, m.Measurement(-100.5)) meter.RecordBatch(ctx, labels, m.Measurement(-100.5))
checkSyncBatches(ctx, t, labels, mockSDK, number.Float64Kind, sdkapi.ValueRecorderInstrumentKind, m.SyncImpl(), checkSyncBatches(ctx, t, labels, mockSDK, number.Float64Kind, sdkapi.HistogramInstrumentKind, m.SyncImpl(),
42, 0, -100.5, 42, 0, -100.5,
) )
}) })
t.Run("int64 valuerecorder", func(t *testing.T) { t.Run("int64 histogram", func(t *testing.T) {
mockSDK, meter := metrictest.NewMeter() mockSDK, meter := metrictest.NewMeter()
m := Must(meter).NewInt64ValueRecorder("test.valuerecorder.int") m := Must(meter).NewInt64Histogram("test.histogram.int")
ctx := context.Background() ctx := context.Background()
labels := []attribute.KeyValue{attribute.Int("I", 1)} labels := []attribute.KeyValue{attribute.Int("I", 1)}
m.Record(ctx, 173, labels...) m.Record(ctx, 173, labels...)
boundInstrument := m.Bind(labels...) boundInstrument := m.Bind(labels...)
boundInstrument.Record(ctx, 80) boundInstrument.Record(ctx, 80)
meter.RecordBatch(ctx, labels, m.Measurement(0)) meter.RecordBatch(ctx, labels, m.Measurement(0))
checkSyncBatches(ctx, t, labels, mockSDK, number.Int64Kind, sdkapi.ValueRecorderInstrumentKind, m.SyncImpl(), checkSyncBatches(ctx, t, labels, mockSDK, number.Int64Kind, sdkapi.HistogramInstrumentKind, m.SyncImpl(),
173, 80, 0, 173, 80, 0,
) )
}) })
} }
func TestObserverInstruments(t *testing.T) { func TestObserverInstruments(t *testing.T) {
t.Run("float valueobserver", func(t *testing.T) { t.Run("float gauge", func(t *testing.T) {
labels := []attribute.KeyValue{attribute.String("O", "P")} labels := []attribute.KeyValue{attribute.String("O", "P")}
mockSDK, meter := metrictest.NewMeter() mockSDK, meter := metrictest.NewMeter()
o := Must(meter).NewFloat64ValueObserver("test.valueobserver.float", func(_ context.Context, result metric.Float64ObserverResult) { o := Must(meter).NewFloat64GaugeObserver("test.gauge.float", func(_ context.Context, result metric.Float64ObserverResult) {
result.Observe(42.1, labels...) result.Observe(42.1, labels...)
}) })
mockSDK.RunAsyncInstruments() mockSDK.RunAsyncInstruments()
checkObserverBatch(t, labels, mockSDK, number.Float64Kind, sdkapi.ValueObserverInstrumentKind, o.AsyncImpl(), checkObserverBatch(t, labels, mockSDK, number.Float64Kind, sdkapi.GaugeObserverInstrumentKind, o.AsyncImpl(),
42.1, 42.1,
) )
}) })
t.Run("int valueobserver", func(t *testing.T) { t.Run("int gauge", func(t *testing.T) {
labels := []attribute.KeyValue{} labels := []attribute.KeyValue{}
mockSDK, meter := metrictest.NewMeter() mockSDK, meter := metrictest.NewMeter()
o := Must(meter).NewInt64ValueObserver("test.observer.int", func(_ context.Context, result metric.Int64ObserverResult) { o := Must(meter).NewInt64GaugeObserver("test.observer.int", func(_ context.Context, result metric.Int64ObserverResult) {
result.Observe(-142, labels...) result.Observe(-142, labels...)
}) })
mockSDK.RunAsyncInstruments() mockSDK.RunAsyncInstruments()
checkObserverBatch(t, labels, mockSDK, number.Int64Kind, sdkapi.ValueObserverInstrumentKind, o.AsyncImpl(), checkObserverBatch(t, labels, mockSDK, number.Int64Kind, sdkapi.GaugeObserverInstrumentKind, o.AsyncImpl(),
-142, -142,
) )
}) })
t.Run("float sumobserver", func(t *testing.T) { t.Run("float counterobserver", func(t *testing.T) {
labels := []attribute.KeyValue{attribute.String("O", "P")} labels := []attribute.KeyValue{attribute.String("O", "P")}
mockSDK, meter := metrictest.NewMeter() mockSDK, meter := metrictest.NewMeter()
o := Must(meter).NewFloat64SumObserver("test.sumobserver.float", func(_ context.Context, result metric.Float64ObserverResult) { o := Must(meter).NewFloat64CounterObserver("test.counterobserver.float", func(_ context.Context, result metric.Float64ObserverResult) {
result.Observe(42.1, labels...) result.Observe(42.1, labels...)
}) })
mockSDK.RunAsyncInstruments() mockSDK.RunAsyncInstruments()
checkObserverBatch(t, labels, mockSDK, number.Float64Kind, sdkapi.SumObserverInstrumentKind, o.AsyncImpl(), checkObserverBatch(t, labels, mockSDK, number.Float64Kind, sdkapi.CounterObserverInstrumentKind, o.AsyncImpl(),
42.1, 42.1,
) )
}) })
t.Run("int sumobserver", func(t *testing.T) { t.Run("int counterobserver", func(t *testing.T) {
labels := []attribute.KeyValue{} labels := []attribute.KeyValue{}
mockSDK, meter := metrictest.NewMeter() mockSDK, meter := metrictest.NewMeter()
o := Must(meter).NewInt64SumObserver("test.observer.int", func(_ context.Context, result metric.Int64ObserverResult) { o := Must(meter).NewInt64CounterObserver("test.observer.int", func(_ context.Context, result metric.Int64ObserverResult) {
result.Observe(-142, labels...) result.Observe(-142, labels...)
}) })
mockSDK.RunAsyncInstruments() mockSDK.RunAsyncInstruments()
checkObserverBatch(t, labels, mockSDK, number.Int64Kind, sdkapi.SumObserverInstrumentKind, o.AsyncImpl(), checkObserverBatch(t, labels, mockSDK, number.Int64Kind, sdkapi.CounterObserverInstrumentKind, o.AsyncImpl(),
-142, -142,
) )
}) })
t.Run("float updownsumobserver", func(t *testing.T) { t.Run("float updowncounterobserver", func(t *testing.T) {
labels := []attribute.KeyValue{attribute.String("O", "P")} labels := []attribute.KeyValue{attribute.String("O", "P")}
mockSDK, meter := metrictest.NewMeter() mockSDK, meter := metrictest.NewMeter()
o := Must(meter).NewFloat64UpDownSumObserver("test.updownsumobserver.float", func(_ context.Context, result metric.Float64ObserverResult) { o := Must(meter).NewFloat64UpDownCounterObserver("test.updowncounterobserver.float", func(_ context.Context, result metric.Float64ObserverResult) {
result.Observe(42.1, labels...) result.Observe(42.1, labels...)
}) })
mockSDK.RunAsyncInstruments() mockSDK.RunAsyncInstruments()
checkObserverBatch(t, labels, mockSDK, number.Float64Kind, sdkapi.UpDownSumObserverInstrumentKind, o.AsyncImpl(), checkObserverBatch(t, labels, mockSDK, number.Float64Kind, sdkapi.UpDownCounterObserverInstrumentKind, o.AsyncImpl(),
42.1, 42.1,
) )
}) })
t.Run("int updownsumobserver", func(t *testing.T) { t.Run("int updowncounterobserver", func(t *testing.T) {
labels := []attribute.KeyValue{} labels := []attribute.KeyValue{}
mockSDK, meter := metrictest.NewMeter() mockSDK, meter := metrictest.NewMeter()
o := Must(meter).NewInt64UpDownSumObserver("test.observer.int", func(_ context.Context, result metric.Int64ObserverResult) { o := Must(meter).NewInt64UpDownCounterObserver("test.observer.int", func(_ context.Context, result metric.Int64ObserverResult) {
result.Observe(-142, labels...) result.Observe(-142, labels...)
}) })
mockSDK.RunAsyncInstruments() mockSDK.RunAsyncInstruments()
checkObserverBatch(t, labels, mockSDK, number.Int64Kind, sdkapi.UpDownSumObserverInstrumentKind, o.AsyncImpl(), checkObserverBatch(t, labels, mockSDK, number.Int64Kind, sdkapi.UpDownCounterObserverInstrumentKind, o.AsyncImpl(),
-142, -142,
) )
}) })
@ -464,8 +464,8 @@ func TestObserverInstruments(t *testing.T) {
func TestBatchObserverInstruments(t *testing.T) { func TestBatchObserverInstruments(t *testing.T) {
mockSDK, meter := metrictest.NewMeter() mockSDK, meter := metrictest.NewMeter()
var obs1 metric.Int64ValueObserver var obs1 metric.Int64GaugeObserver
var obs2 metric.Float64ValueObserver var obs2 metric.Float64GaugeObserver
labels := []attribute.KeyValue{ labels := []attribute.KeyValue{
attribute.String("A", "B"), attribute.String("A", "B"),
@ -480,8 +480,8 @@ func TestBatchObserverInstruments(t *testing.T) {
) )
}, },
) )
obs1 = cb.NewInt64ValueObserver("test.observer.int") obs1 = cb.NewInt64GaugeObserver("test.observer.int")
obs2 = cb.NewFloat64ValueObserver("test.observer.float") obs2 = cb.NewFloat64GaugeObserver("test.observer.float")
mockSDK.RunAsyncInstruments() mockSDK.RunAsyncInstruments()
@ -549,12 +549,12 @@ func TestWrappedInstrumentError(t *testing.T) {
impl := &testWrappedMeter{} impl := &testWrappedMeter{}
meter := metric.WrapMeterImpl(impl, "test") meter := metric.WrapMeterImpl(impl, "test")
valuerecorder, err := meter.NewInt64ValueRecorder("test.valuerecorder") histogram, err := meter.NewInt64Histogram("test.histogram")
require.Equal(t, err, metric.ErrSDKReturnedNilImpl) require.Equal(t, err, metric.ErrSDKReturnedNilImpl)
require.NotNil(t, valuerecorder.SyncImpl()) require.NotNil(t, histogram.SyncImpl())
observer, err := meter.NewInt64ValueObserver("test.observer", func(_ context.Context, result metric.Int64ObserverResult) {}) observer, err := meter.NewInt64GaugeObserver("test.observer", func(_ context.Context, result metric.Int64ObserverResult) {})
require.NotNil(t, err) require.NotNil(t, err)
require.NotNil(t, observer.AsyncImpl()) require.NotNil(t, observer.AsyncImpl())
@ -564,7 +564,7 @@ func TestNilCallbackObserverNoop(t *testing.T) {
// Tests that a nil callback yields a no-op observer without error. // Tests that a nil callback yields a no-op observer without error.
_, meter := metrictest.NewMeter() _, meter := metrictest.NewMeter()
observer := Must(meter).NewInt64ValueObserver("test.observer", nil) observer := Must(meter).NewInt64GaugeObserver("test.observer", nil)
_, ok := observer.AsyncImpl().(metric.NoopAsync) _, ok := observer.AsyncImpl().(metric.NoopAsync)
require.True(t, ok) require.True(t, ok)

16
metric/registry/registry_test.go
View File

@ -38,17 +38,17 @@ var (
"counter.float64": func(m metric.Meter, name string) (metric.InstrumentImpl, error) { "counter.float64": func(m metric.Meter, name string) (metric.InstrumentImpl, error) {
return unwrap(m.NewFloat64Counter(name)) return unwrap(m.NewFloat64Counter(name))
}, },
"valuerecorder.int64": func(m metric.Meter, name string) (metric.InstrumentImpl, error) { "histogram.int64": func(m metric.Meter, name string) (metric.InstrumentImpl, error) {
return unwrap(m.NewInt64ValueRecorder(name)) return unwrap(m.NewInt64Histogram(name))
}, },
"valuerecorder.float64": func(m metric.Meter, name string) (metric.InstrumentImpl, error) { "histogram.float64": func(m metric.Meter, name string) (metric.InstrumentImpl, error) {
return unwrap(m.NewFloat64ValueRecorder(name)) return unwrap(m.NewFloat64Histogram(name))
}, },
"valueobserver.int64": func(m metric.Meter, name string) (metric.InstrumentImpl, error) { "gaugeobserver.int64": func(m metric.Meter, name string) (metric.InstrumentImpl, error) {
return unwrap(m.NewInt64ValueObserver(name, func(context.Context, metric.Int64ObserverResult) {})) return unwrap(m.NewInt64GaugeObserver(name, func(context.Context, metric.Int64ObserverResult) {}))
}, },
"valueobserver.float64": func(m metric.Meter, name string) (metric.InstrumentImpl, error) { "gaugeobserver.float64": func(m metric.Meter, name string) (metric.InstrumentImpl, error) {
return unwrap(m.NewFloat64ValueObserver(name, func(context.Context, metric.Float64ObserverResult) {})) return unwrap(m.NewFloat64GaugeObserver(name, func(context.Context, metric.Float64ObserverResult) {}))
}, },
} }
) )

22
metric/sdkapi/instrumentkind.go
View File

@ -20,27 +20,27 @@ package sdkapi // import "go.opentelemetry.io/otel/metric/sdkapi"
type InstrumentKind int8 type InstrumentKind int8
const ( const (
// ValueRecorderInstrumentKind indicates a ValueRecorder instrument. // HistogramInstrumentKind indicates a Histogram instrument.
ValueRecorderInstrumentKind InstrumentKind = iota HistogramInstrumentKind InstrumentKind = iota
// ValueObserverInstrumentKind indicates an ValueObserver instrument. // GaugeObserverInstrumentKind indicates an GaugeObserver instrument.
ValueObserverInstrumentKind GaugeObserverInstrumentKind
// CounterInstrumentKind indicates a Counter instrument. // CounterInstrumentKind indicates a Counter instrument.
CounterInstrumentKind CounterInstrumentKind
// UpDownCounterInstrumentKind indicates a UpDownCounter instrument. // UpDownCounterInstrumentKind indicates a UpDownCounter instrument.
UpDownCounterInstrumentKind UpDownCounterInstrumentKind
// SumObserverInstrumentKind indicates a SumObserver instrument. // CounterObserverInstrumentKind indicates a CounterObserver instrument.
SumObserverInstrumentKind CounterObserverInstrumentKind
// UpDownSumObserverInstrumentKind indicates a UpDownSumObserver // UpDownCounterObserverInstrumentKind indicates a UpDownCounterObserver
// instrument. // instrument.
UpDownSumObserverInstrumentKind UpDownCounterObserverInstrumentKind
) )
// Synchronous returns whether this is a synchronous kind of instrument. // Synchronous returns whether this is a synchronous kind of instrument.
func (k InstrumentKind) Synchronous() bool { func (k InstrumentKind) Synchronous() bool {
switch k { switch k {
case CounterInstrumentKind, UpDownCounterInstrumentKind, ValueRecorderInstrumentKind: case CounterInstrumentKind, UpDownCounterInstrumentKind, HistogramInstrumentKind:
return true return true
} }
return false return false
@ -54,7 +54,7 @@ func (k InstrumentKind) Asynchronous() bool {
// Adding returns whether this kind of instrument adds its inputs (as opposed to Grouping). // Adding returns whether this kind of instrument adds its inputs (as opposed to Grouping).
func (k InstrumentKind) Adding() bool { func (k InstrumentKind) Adding() bool {
switch k { switch k {
case CounterInstrumentKind, UpDownCounterInstrumentKind, SumObserverInstrumentKind, UpDownSumObserverInstrumentKind: case CounterInstrumentKind, UpDownCounterInstrumentKind, CounterObserverInstrumentKind, UpDownCounterObserverInstrumentKind:
return true return true
} }
return false return false
@ -68,7 +68,7 @@ func (k InstrumentKind) Grouping() bool {
// Monotonic returns whether this kind of instrument exposes a non-decreasing sum. // Monotonic returns whether this kind of instrument exposes a non-decreasing sum.
func (k InstrumentKind) Monotonic() bool { func (k InstrumentKind) Monotonic() bool {
switch k { switch k {
case CounterInstrumentKind, SumObserverInstrumentKind: case CounterInstrumentKind, CounterObserverInstrumentKind:
return true return true
} }
return false return false

12
metric/sdkapi/instrumentkind_string.go
View File

@ -8,17 +8,17 @@ func _() {
// An "invalid array index" compiler error signifies that the constant values have changed. // An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again. // Re-run the stringer command to generate them again.
var x [1]struct{} var x [1]struct{}
_ = x[ValueRecorderInstrumentKind-0] _ = x[HistogramInstrumentKind-0]
_ = x[ValueObserverInstrumentKind-1] _ = x[GaugeObserverInstrumentKind-1]
_ = x[CounterInstrumentKind-2] _ = x[CounterInstrumentKind-2]
_ = x[UpDownCounterInstrumentKind-3] _ = x[UpDownCounterInstrumentKind-3]
_ = x[SumObserverInstrumentKind-4] _ = x[CounterObserverInstrumentKind-4]
_ = x[UpDownSumObserverInstrumentKind-5] _ = x[UpDownCounterObserverInstrumentKind-5]
} }
const _InstrumentKind_name = "ValueRecorderInstrumentKindValueObserverInstrumentKindCounterInstrumentKindUpDownCounterInstrumentKindSumObserverInstrumentKindUpDownSumObserverInstrumentKind" const _InstrumentKind_name = "HistogramInstrumentKindGaugeObserverInstrumentKindCounterInstrumentKindUpDownCounterInstrumentKindCounterObserverInstrumentKindUpDownCounterObserverInstrumentKind"
var _InstrumentKind_index = [...]uint8{0, 27, 54, 75, 102, 127, 158} var _InstrumentKind_index = [...]uint8{0, 23, 50, 71, 98, 127, 162}
func (i InstrumentKind) String() string { func (i InstrumentKind) String() string {
if i < 0 || i >= InstrumentKind(len(_InstrumentKind_index)-1) { if i < 0 || i >= InstrumentKind(len(_InstrumentKind_index)-1) {

8
metric/sdkapi/instrumentkind_test.go
View File

@ -23,10 +23,10 @@ import (
) )
func TestInstrumentKinds(t *testing.T) { func TestInstrumentKinds(t *testing.T) {
require.Equal(t, sdkapi.ValueRecorderInstrumentKind.String(), "ValueRecorderInstrumentKind") require.Equal(t, sdkapi.HistogramInstrumentKind.String(), "HistogramInstrumentKind")
require.Equal(t, sdkapi.ValueObserverInstrumentKind.String(), "ValueObserverInstrumentKind") require.Equal(t, sdkapi.GaugeObserverInstrumentKind.String(), "GaugeObserverInstrumentKind")
require.Equal(t, sdkapi.CounterInstrumentKind.String(), "CounterInstrumentKind") require.Equal(t, sdkapi.CounterInstrumentKind.String(), "CounterInstrumentKind")
require.Equal(t, sdkapi.UpDownCounterInstrumentKind.String(), "UpDownCounterInstrumentKind") require.Equal(t, sdkapi.UpDownCounterInstrumentKind.String(), "UpDownCounterInstrumentKind")
require.Equal(t, sdkapi.SumObserverInstrumentKind.String(), "SumObserverInstrumentKind") require.Equal(t, sdkapi.CounterObserverInstrumentKind.String(), "CounterObserverInstrumentKind")
require.Equal(t, sdkapi.UpDownSumObserverInstrumentKind.String(), "UpDownSumObserverInstrumentKind") require.Equal(t, sdkapi.UpDownCounterObserverInstrumentKind.String(), "UpDownCounterObserverInstrumentKind")
} }

8
sdk/export/metric/exportkind_test.go
View File

@ -31,13 +31,13 @@ func TestExportKindIncludes(t *testing.T) {
} }
var deltaMemoryKinds = []sdkapi.InstrumentKind{ var deltaMemoryKinds = []sdkapi.InstrumentKind{
sdkapi.SumObserverInstrumentKind, sdkapi.CounterObserverInstrumentKind,
sdkapi.UpDownSumObserverInstrumentKind, sdkapi.UpDownCounterObserverInstrumentKind,
} }
var cumulativeMemoryKinds = []sdkapi.InstrumentKind{ var cumulativeMemoryKinds = []sdkapi.InstrumentKind{
sdkapi.ValueRecorderInstrumentKind, sdkapi.HistogramInstrumentKind,
sdkapi.ValueObserverInstrumentKind, sdkapi.GaugeObserverInstrumentKind,
sdkapi.CounterInstrumentKind, sdkapi.CounterInstrumentKind,
sdkapi.UpDownCounterInstrumentKind, sdkapi.UpDownCounterInstrumentKind,
} }

14
sdk/export/metric/metric.go
View File

@ -127,15 +127,15 @@ type Checkpointer interface {
} }
// Aggregator implements a specific aggregation behavior, e.g., a // Aggregator implements a specific aggregation behavior, e.g., a
// behavior to track a sequence of updates to an instrument. Sum-only // behavior to track a sequence of updates to an instrument. Counter
// instruments commonly use a simple Sum aggregator, but for the // instruments commonly use a simple Sum aggregator, but for the
// distribution instruments (ValueRecorder, ValueObserver) there are a // distribution instruments (Histogram, GaugeObserver) there are a
// number of possible aggregators with different cost and accuracy // number of possible aggregators with different cost and accuracy
// tradeoffs. // tradeoffs.
// //
// Note that any Aggregator may be attached to any instrument--this is // Note that any Aggregator may be attached to any instrument--this is
// the result of the OpenTelemetry API/SDK separation. It is possible // the result of the OpenTelemetry API/SDK separation. It is possible
// to attach a Sum aggregator to a ValueRecorder instrument or a // to attach a Sum aggregator to a Histogram instrument or a
// MinMaxSumCount aggregator to a Counter instrument. // MinMaxSumCount aggregator to a Counter instrument.
type Aggregator interface { type Aggregator interface {
// Aggregation returns an Aggregation interface to access the // Aggregation returns an Aggregation interface to access the
@ -191,8 +191,8 @@ type Aggregator interface {
// Subtractor is an optional interface implemented by some // Subtractor is an optional interface implemented by some
// Aggregators. An Aggregator must support `Subtract()` in order to // Aggregators. An Aggregator must support `Subtract()` in order to
// be configured for a Precomputed-Sum instrument (SumObserver, // be configured for a Precomputed-Sum instrument (CounterObserver,
// UpDownSumObserver) using a DeltaExporter. // UpDownCounterObserver) using a DeltaExporter.
type Subtractor interface { type Subtractor interface {
// Subtract subtracts the `operand` from this Aggregator and // Subtract subtracts the `operand` from this Aggregator and
// outputs the value in `result`. // outputs the value in `result`.
@ -374,12 +374,12 @@ func (kind ExportKind) Includes(has ExportKind) bool {
// memory to export correctly. // memory to export correctly.
func (kind ExportKind) MemoryRequired(mkind sdkapi.InstrumentKind) bool { func (kind ExportKind) MemoryRequired(mkind sdkapi.InstrumentKind) bool {
switch mkind { switch mkind {
case sdkapi.ValueRecorderInstrumentKind, sdkapi.ValueObserverInstrumentKind, case sdkapi.HistogramInstrumentKind, sdkapi.GaugeObserverInstrumentKind,
sdkapi.CounterInstrumentKind, sdkapi.UpDownCounterInstrumentKind: sdkapi.CounterInstrumentKind, sdkapi.UpDownCounterInstrumentKind:
// Delta-oriented instruments: // Delta-oriented instruments:
return kind.Includes(CumulativeExportKind) return kind.Includes(CumulativeExportKind)
case sdkapi.SumObserverInstrumentKind, sdkapi.UpDownSumObserverInstrumentKind: case sdkapi.CounterObserverInstrumentKind, sdkapi.UpDownCounterObserverInstrumentKind:
// Cumulative-oriented instruments: // Cumulative-oriented instruments:
return kind.Includes(DeltaExportKind) return kind.Includes(DeltaExportKind)
} }

4
sdk/metric/aggregator/aggregator.go
View File

@ -35,7 +35,7 @@ func NewInconsistentAggregatorError(a1, a2 export.Aggregator) error {
// RangeTest is a common routine for testing for valid input values. // RangeTest is a common routine for testing for valid input values.
// This rejects NaN values. This rejects negative values when the // This rejects NaN values. This rejects negative values when the
// metric instrument does not support negative values, including // metric instrument does not support negative values, including
// monotonic counter metrics and absolute ValueRecorder metrics. // monotonic counter metrics and absolute Histogram metrics.
func RangeTest(num number.Number, descriptor *metric.Descriptor) error { func RangeTest(num number.Number, descriptor *metric.Descriptor) error {
numberKind := descriptor.NumberKind() numberKind := descriptor.NumberKind()
@ -44,7 +44,7 @@ func RangeTest(num number.Number, descriptor *metric.Descriptor) error {
} }
switch descriptor.InstrumentKind() { switch descriptor.InstrumentKind() {
case sdkapi.CounterInstrumentKind, sdkapi.SumObserverInstrumentKind: case sdkapi.CounterInstrumentKind, sdkapi.CounterObserverInstrumentKind:
if num.IsNegative(numberKind) { if num.IsNegative(numberKind) {
return aggregation.ErrNegativeInput return aggregation.ErrNegativeInput
} }

4
sdk/metric/aggregator/aggregator_test.go
View File

@ -89,8 +89,8 @@ func TestNaNTest(t *testing.T) {
t.Run(nkind.String(), func(t *testing.T) { t.Run(nkind.String(), func(t *testing.T) {
for _, mkind := range []sdkapi.InstrumentKind{ for _, mkind := range []sdkapi.InstrumentKind{
sdkapi.CounterInstrumentKind, sdkapi.CounterInstrumentKind,
sdkapi.ValueRecorderInstrumentKind, sdkapi.HistogramInstrumentKind,
sdkapi.ValueObserverInstrumentKind, sdkapi.GaugeObserverInstrumentKind,
} { } {
desc := metric.NewDescriptor( desc := metric.NewDescriptor(
"name", "name",

12
sdk/metric/aggregator/exact/exact_test.go
View File

@ -67,7 +67,7 @@ func sumOf(samples []aggregation.Point, k number.Kind) number.Number {
} }
func (ut *updateTest) run(t *testing.T, profile aggregatortest.Profile) { func (ut *updateTest) run(t *testing.T, profile aggregatortest.Profile) {
descriptor := aggregatortest.NewAggregatorTest(sdkapi.ValueRecorderInstrumentKind, profile.NumberKind) descriptor := aggregatortest.NewAggregatorTest(sdkapi.HistogramInstrumentKind, profile.NumberKind)
agg, ckpt := new2() agg, ckpt := new2()
all := aggregatortest.NewNumbers(profile.NumberKind) all := aggregatortest.NewNumbers(profile.NumberKind)
@ -129,7 +129,7 @@ func advance() {
} }
func (mt *mergeTest) run(t *testing.T, profile aggregatortest.Profile) { func (mt *mergeTest) run(t *testing.T, profile aggregatortest.Profile) {
descriptor := aggregatortest.NewAggregatorTest(sdkapi.ValueRecorderInstrumentKind, profile.NumberKind) descriptor := aggregatortest.NewAggregatorTest(sdkapi.HistogramInstrumentKind, profile.NumberKind)
agg1, agg2, ckpt1, ckpt2 := new4() agg1, agg2, ckpt1, ckpt2 := new4()
all := aggregatortest.NewNumbers(profile.NumberKind) all := aggregatortest.NewNumbers(profile.NumberKind)
@ -215,7 +215,7 @@ func TestExactErrors(t *testing.T) {
aggregatortest.RunProfiles(t, func(t *testing.T, profile aggregatortest.Profile) { aggregatortest.RunProfiles(t, func(t *testing.T, profile aggregatortest.Profile) {
agg, ckpt := new2() agg, ckpt := new2()
descriptor := aggregatortest.NewAggregatorTest(sdkapi.ValueRecorderInstrumentKind, profile.NumberKind) descriptor := aggregatortest.NewAggregatorTest(sdkapi.HistogramInstrumentKind, profile.NumberKind)
advance() advance()
aggregatortest.CheckedUpdate(t, agg, number.Number(0), descriptor) aggregatortest.CheckedUpdate(t, agg, number.Number(0), descriptor)
@ -233,7 +233,7 @@ func TestExactErrors(t *testing.T) {
} }
func TestExactFloat64(t *testing.T) { func TestExactFloat64(t *testing.T) {
descriptor := aggregatortest.NewAggregatorTest(sdkapi.ValueRecorderInstrumentKind, number.Float64Kind) descriptor := aggregatortest.NewAggregatorTest(sdkapi.HistogramInstrumentKind, number.Float64Kind)
fpsf := func(sign int) []float64 { fpsf := func(sign int) []float64 {
// Check behavior of a bunch of odd floating // Check behavior of a bunch of odd floating
@ -311,7 +311,7 @@ func TestExactFloat64(t *testing.T) {
func TestSynchronizedMoveReset(t *testing.T) { func TestSynchronizedMoveReset(t *testing.T) {
aggregatortest.SynchronizedMoveResetTest( aggregatortest.SynchronizedMoveResetTest(
t, t,
sdkapi.ValueRecorderInstrumentKind, sdkapi.HistogramInstrumentKind,
func(desc *metric.Descriptor) export.Aggregator { func(desc *metric.Descriptor) export.Aggregator {
return &New(1)[0] return &New(1)[0]
}, },
@ -322,7 +322,7 @@ func TestMergeBehavior(t *testing.T) {
aggregatortest.RunProfiles(t, func(t *testing.T, profile aggregatortest.Profile) { aggregatortest.RunProfiles(t, func(t *testing.T, profile aggregatortest.Profile) {
for _, forward := range []bool{false, true} { for _, forward := range []bool{false, true} {
t.Run(fmt.Sprint("Forward=", forward), func(t *testing.T) { t.Run(fmt.Sprint("Forward=", forward), func(t *testing.T) {
descriptor := aggregatortest.NewAggregatorTest(sdkapi.ValueRecorderInstrumentKind, profile.NumberKind) descriptor := aggregatortest.NewAggregatorTest(sdkapi.HistogramInstrumentKind, profile.NumberKind)
agg1, agg2, ckpt, _ := new4() agg1, agg2, ckpt, _ := new4()
all := aggregatortest.NewNumbers(profile.NumberKind) all := aggregatortest.NewNumbers(profile.NumberKind)

4
sdk/metric/aggregator/histogram/benchmark_test.go
View File

@ -38,7 +38,7 @@ func benchmarkHistogramSearchFloat64(b *testing.B, size int) {
for i := range values { for i := range values {
values[i] = rand.Float64() * inputRange values[i] = rand.Float64() * inputRange
} }
desc := aggregatortest.NewAggregatorTest(sdkapi.ValueRecorderInstrumentKind, number.Float64Kind) desc := aggregatortest.NewAggregatorTest(sdkapi.HistogramInstrumentKind, number.Float64Kind)
agg := &histogram.New(1, desc, histogram.WithExplicitBoundaries(boundaries))[0] agg := &histogram.New(1, desc, histogram.WithExplicitBoundaries(boundaries))[0]
ctx := context.Background() ctx := context.Background()
@ -89,7 +89,7 @@ func benchmarkHistogramSearchInt64(b *testing.B, size int) {
for i := range values { for i := range values {
values[i] = int64(rand.Float64() * inputRange) values[i] = int64(rand.Float64() * inputRange)
} }
desc := aggregatortest.NewAggregatorTest(sdkapi.ValueRecorderInstrumentKind, number.Int64Kind) desc := aggregatortest.NewAggregatorTest(sdkapi.HistogramInstrumentKind, number.Int64Kind)
agg := &histogram.New(1, desc, histogram.WithExplicitBoundaries(boundaries))[0] agg := &histogram.New(1, desc, histogram.WithExplicitBoundaries(boundaries))[0]
ctx := context.Background() ctx := context.Background()

12
sdk/metric/aggregator/histogram/histogram_test.go
View File

@ -112,7 +112,7 @@ func TestHistogramPositiveAndNegative(t *testing.T) {
// Validates count, sum and buckets for a given profile and policy // Validates count, sum and buckets for a given profile and policy
func testHistogram(t *testing.T, profile aggregatortest.Profile, policy policy) { func testHistogram(t *testing.T, profile aggregatortest.Profile, policy policy) {
descriptor := aggregatortest.NewAggregatorTest(sdkapi.ValueRecorderInstrumentKind, profile.NumberKind) descriptor := aggregatortest.NewAggregatorTest(sdkapi.HistogramInstrumentKind, profile.NumberKind)
agg, ckpt := new2(descriptor, histogram.WithExplicitBoundaries(testBoundaries)) agg, ckpt := new2(descriptor, histogram.WithExplicitBoundaries(testBoundaries))
@ -138,7 +138,7 @@ func testHistogram(t *testing.T, profile aggregatortest.Profile, policy policy)
func TestHistogramInitial(t *testing.T) { func TestHistogramInitial(t *testing.T) {
aggregatortest.RunProfiles(t, func(t *testing.T, profile aggregatortest.Profile) { aggregatortest.RunProfiles(t, func(t *testing.T, profile aggregatortest.Profile) {
descriptor := aggregatortest.NewAggregatorTest(sdkapi.ValueRecorderInstrumentKind, profile.NumberKind) descriptor := aggregatortest.NewAggregatorTest(sdkapi.HistogramInstrumentKind, profile.NumberKind)
agg := &histogram.New(1, descriptor, histogram.WithExplicitBoundaries(testBoundaries))[0] agg := &histogram.New(1, descriptor, histogram.WithExplicitBoundaries(testBoundaries))[0]
buckets, err := agg.Histogram() buckets, err := agg.Histogram()
@ -151,7 +151,7 @@ func TestHistogramInitial(t *testing.T) {
func TestHistogramMerge(t *testing.T) { func TestHistogramMerge(t *testing.T) {
aggregatortest.RunProfiles(t, func(t *testing.T, profile aggregatortest.Profile) { aggregatortest.RunProfiles(t, func(t *testing.T, profile aggregatortest.Profile) {
descriptor := aggregatortest.NewAggregatorTest(sdkapi.ValueRecorderInstrumentKind, profile.NumberKind) descriptor := aggregatortest.NewAggregatorTest(sdkapi.HistogramInstrumentKind, profile.NumberKind)
agg1, agg2, ckpt1, ckpt2 := new4(descriptor, histogram.WithExplicitBoundaries(testBoundaries)) agg1, agg2, ckpt1, ckpt2 := new4(descriptor, histogram.WithExplicitBoundaries(testBoundaries))
@ -179,7 +179,7 @@ func TestHistogramMerge(t *testing.T) {
func TestHistogramNotSet(t *testing.T) { func TestHistogramNotSet(t *testing.T) {
aggregatortest.RunProfiles(t, func(t *testing.T, profile aggregatortest.Profile) { aggregatortest.RunProfiles(t, func(t *testing.T, profile aggregatortest.Profile) {
descriptor := aggregatortest.NewAggregatorTest(sdkapi.ValueRecorderInstrumentKind, profile.NumberKind) descriptor := aggregatortest.NewAggregatorTest(sdkapi.HistogramInstrumentKind, profile.NumberKind)
agg, ckpt := new2(descriptor, histogram.WithExplicitBoundaries(testBoundaries)) agg, ckpt := new2(descriptor, histogram.WithExplicitBoundaries(testBoundaries))
@ -240,7 +240,7 @@ func checkHistogram(t *testing.T, all aggregatortest.Numbers, profile aggregator
func TestSynchronizedMoveReset(t *testing.T) { func TestSynchronizedMoveReset(t *testing.T) {
aggregatortest.SynchronizedMoveResetTest( aggregatortest.SynchronizedMoveResetTest(
t, t,
sdkapi.ValueRecorderInstrumentKind, sdkapi.HistogramInstrumentKind,
func(desc *metric.Descriptor) export.Aggregator { func(desc *metric.Descriptor) export.Aggregator {
return &histogram.New(1, desc, histogram.WithExplicitBoundaries(testBoundaries))[0] return &histogram.New(1, desc, histogram.WithExplicitBoundaries(testBoundaries))[0]
}, },
@ -250,7 +250,7 @@ func TestSynchronizedMoveReset(t *testing.T) {
func TestHistogramDefaultBoundaries(t *testing.T) { func TestHistogramDefaultBoundaries(t *testing.T) {
aggregatortest.RunProfiles(t, func(t *testing.T, profile aggregatortest.Profile) { aggregatortest.RunProfiles(t, func(t *testing.T, profile aggregatortest.Profile) {
ctx := context.Background() ctx := context.Background()
descriptor := aggregatortest.NewAggregatorTest(sdkapi.ValueRecorderInstrumentKind, profile.NumberKind) descriptor := aggregatortest.NewAggregatorTest(sdkapi.HistogramInstrumentKind, profile.NumberKind)
agg, ckpt := new2(descriptor) agg, ckpt := new2(descriptor)

8
sdk/metric/aggregator/lastvalue/lastvalue_test.go
View File

@ -73,7 +73,7 @@ func TestLastValueUpdate(t *testing.T) {
aggregatortest.RunProfiles(t, func(t *testing.T, profile aggregatortest.Profile) { aggregatortest.RunProfiles(t, func(t *testing.T, profile aggregatortest.Profile) {
agg, ckpt := new2() agg, ckpt := new2()
record := aggregatortest.NewAggregatorTest(sdkapi.ValueObserverInstrumentKind, profile.NumberKind) record := aggregatortest.NewAggregatorTest(sdkapi.GaugeObserverInstrumentKind, profile.NumberKind)
var last number.Number var last number.Number
for i := 0; i < count; i++ { for i := 0; i < count; i++ {
@ -95,7 +95,7 @@ func TestLastValueMerge(t *testing.T) {
aggregatortest.RunProfiles(t, func(t *testing.T, profile aggregatortest.Profile) { aggregatortest.RunProfiles(t, func(t *testing.T, profile aggregatortest.Profile) {
agg1, agg2, ckpt1, ckpt2 := new4() agg1, agg2, ckpt1, ckpt2 := new4()
descriptor := aggregatortest.NewAggregatorTest(sdkapi.ValueObserverInstrumentKind, profile.NumberKind) descriptor := aggregatortest.NewAggregatorTest(sdkapi.GaugeObserverInstrumentKind, profile.NumberKind)
first1 := profile.Random(+1) first1 := profile.Random(+1)
first2 := profile.Random(+1) first2 := profile.Random(+1)
@ -128,7 +128,7 @@ func TestLastValueMerge(t *testing.T) {
} }
func TestLastValueNotSet(t *testing.T) { func TestLastValueNotSet(t *testing.T) {
descriptor := aggregatortest.NewAggregatorTest(sdkapi.ValueObserverInstrumentKind, number.Int64Kind) descriptor := aggregatortest.NewAggregatorTest(sdkapi.GaugeObserverInstrumentKind, number.Int64Kind)
g, ckpt := new2() g, ckpt := new2()
require.NoError(t, g.SynchronizedMove(ckpt, descriptor)) require.NoError(t, g.SynchronizedMove(ckpt, descriptor))
@ -139,7 +139,7 @@ func TestLastValueNotSet(t *testing.T) {
func TestSynchronizedMoveReset(t *testing.T) { func TestSynchronizedMoveReset(t *testing.T) {
aggregatortest.SynchronizedMoveResetTest( aggregatortest.SynchronizedMoveResetTest(
t, t,
sdkapi.ValueObserverInstrumentKind, sdkapi.GaugeObserverInstrumentKind,
func(desc *metric.Descriptor) export.Aggregator { func(desc *metric.Descriptor) export.Aggregator {
return &New(1)[0] return &New(1)[0]
}, },

8
sdk/metric/aggregator/minmaxsumcount/mmsc_test.go
View File

@ -111,7 +111,7 @@ func checkZero(t *testing.T, agg *Aggregator, desc *metric.Descriptor) {
// Validates min, max, sum and count for a given profile and policy // Validates min, max, sum and count for a given profile and policy
func minMaxSumCount(t *testing.T, profile aggregatortest.Profile, policy policy) { func minMaxSumCount(t *testing.T, profile aggregatortest.Profile, policy policy) {
descriptor := aggregatortest.NewAggregatorTest(sdkapi.ValueRecorderInstrumentKind, profile.NumberKind) descriptor := aggregatortest.NewAggregatorTest(sdkapi.HistogramInstrumentKind, profile.NumberKind)
agg, ckpt := new2(descriptor) agg, ckpt := new2(descriptor)
@ -159,7 +159,7 @@ func minMaxSumCount(t *testing.T, profile aggregatortest.Profile, policy policy)
func TestMinMaxSumCountMerge(t *testing.T) { func TestMinMaxSumCountMerge(t *testing.T) {
aggregatortest.RunProfiles(t, func(t *testing.T, profile aggregatortest.Profile) { aggregatortest.RunProfiles(t, func(t *testing.T, profile aggregatortest.Profile) {
descriptor := aggregatortest.NewAggregatorTest(sdkapi.ValueRecorderInstrumentKind, profile.NumberKind) descriptor := aggregatortest.NewAggregatorTest(sdkapi.HistogramInstrumentKind, profile.NumberKind)
agg1, agg2, ckpt1, ckpt2 := new4(descriptor) agg1, agg2, ckpt1, ckpt2 := new4(descriptor)
@ -217,7 +217,7 @@ func TestMinMaxSumCountMerge(t *testing.T) {
func TestMaxSumCountNotSet(t *testing.T) { func TestMaxSumCountNotSet(t *testing.T) {
aggregatortest.RunProfiles(t, func(t *testing.T, profile aggregatortest.Profile) { aggregatortest.RunProfiles(t, func(t *testing.T, profile aggregatortest.Profile) {
descriptor := aggregatortest.NewAggregatorTest(sdkapi.ValueRecorderInstrumentKind, profile.NumberKind) descriptor := aggregatortest.NewAggregatorTest(sdkapi.HistogramInstrumentKind, profile.NumberKind)
alloc := New(2, descriptor) alloc := New(2, descriptor)
agg, ckpt := &alloc[0], &alloc[1] agg, ckpt := &alloc[0], &alloc[1]
@ -241,7 +241,7 @@ func TestMaxSumCountNotSet(t *testing.T) {
func TestSynchronizedMoveReset(t *testing.T) { func TestSynchronizedMoveReset(t *testing.T) {
aggregatortest.SynchronizedMoveResetTest( aggregatortest.SynchronizedMoveResetTest(
t, t,
sdkapi.ValueRecorderInstrumentKind, sdkapi.HistogramInstrumentKind,
func(desc *metric.Descriptor) export.Aggregator { func(desc *metric.Descriptor) export.Aggregator {
return &New(1, desc)[0] return &New(1, desc)[0]
}, },

6
sdk/metric/aggregator/sum/sum_test.go
View File

@ -88,11 +88,11 @@ func TestCounterSum(t *testing.T) {
}) })
} }
func TestValueRecorderSum(t *testing.T) { func TestHistogramSum(t *testing.T) {
aggregatortest.RunProfiles(t, func(t *testing.T, profile aggregatortest.Profile) { aggregatortest.RunProfiles(t, func(t *testing.T, profile aggregatortest.Profile) {
agg, ckpt := new2() agg, ckpt := new2()
descriptor := aggregatortest.NewAggregatorTest(sdkapi.ValueRecorderInstrumentKind, profile.NumberKind) descriptor := aggregatortest.NewAggregatorTest(sdkapi.HistogramInstrumentKind, profile.NumberKind)
sum := number.Number(0) sum := number.Number(0)
@ -147,7 +147,7 @@ func TestCounterMerge(t *testing.T) {
func TestSynchronizedMoveReset(t *testing.T) { func TestSynchronizedMoveReset(t *testing.T) {
aggregatortest.SynchronizedMoveResetTest( aggregatortest.SynchronizedMoveResetTest(
t, t,
sdkapi.SumObserverInstrumentKind, sdkapi.CounterObserverInstrumentKind,
func(desc *metric.Descriptor) export.Aggregator { func(desc *metric.Descriptor) export.Aggregator {
return &New(1)[0] return &New(1)[0]
}, },

52
sdk/metric/benchmark_test.go
View File

@ -287,7 +287,7 @@ func BenchmarkInt64LastValueAdd(b *testing.B) {
ctx := context.Background() ctx := context.Background()
fix := newFixture(b) fix := newFixture(b)
labs := makeLabels(1) labs := makeLabels(1)
mea := fix.meterMust().NewInt64ValueRecorder("int64.lastvalue") mea := fix.meterMust().NewInt64Histogram("int64.lastvalue")
b.ResetTimer() b.ResetTimer()
@ -300,7 +300,7 @@ func BenchmarkInt64LastValueHandleAdd(b *testing.B) {
ctx := context.Background() ctx := context.Background()
fix := newFixture(b) fix := newFixture(b)
labs := makeLabels(1) labs := makeLabels(1)
mea := fix.meterMust().NewInt64ValueRecorder("int64.lastvalue") mea := fix.meterMust().NewInt64Histogram("int64.lastvalue")
handle := mea.Bind(labs...) handle := mea.Bind(labs...)
b.ResetTimer() b.ResetTimer()
@ -314,7 +314,7 @@ func BenchmarkFloat64LastValueAdd(b *testing.B) {
ctx := context.Background() ctx := context.Background()
fix := newFixture(b) fix := newFixture(b)
labs := makeLabels(1) labs := makeLabels(1)
mea := fix.meterMust().NewFloat64ValueRecorder("float64.lastvalue") mea := fix.meterMust().NewFloat64Histogram("float64.lastvalue")
b.ResetTimer() b.ResetTimer()
@ -327,7 +327,7 @@ func BenchmarkFloat64LastValueHandleAdd(b *testing.B) {
ctx := context.Background() ctx := context.Background()
fix := newFixture(b) fix := newFixture(b)
labs := makeLabels(1) labs := makeLabels(1)
mea := fix.meterMust().NewFloat64ValueRecorder("float64.lastvalue") mea := fix.meterMust().NewFloat64Histogram("float64.lastvalue")
handle := mea.Bind(labs...) handle := mea.Bind(labs...)
b.ResetTimer() b.ResetTimer()
@ -337,13 +337,13 @@ func BenchmarkFloat64LastValueHandleAdd(b *testing.B) {
} }
} }
// ValueRecorders // Histograms
func benchmarkInt64ValueRecorderAdd(b *testing.B, name string) { func benchmarkInt64HistogramAdd(b *testing.B, name string) {
ctx := context.Background() ctx := context.Background()
fix := newFixture(b) fix := newFixture(b)
labs := makeLabels(1) labs := makeLabels(1)
mea := fix.meterMust().NewInt64ValueRecorder(name) mea := fix.meterMust().NewInt64Histogram(name)
b.ResetTimer() b.ResetTimer()
@ -352,11 +352,11 @@ func benchmarkInt64ValueRecorderAdd(b *testing.B, name string) {
} }
} }
func benchmarkInt64ValueRecorderHandleAdd(b *testing.B, name string) { func benchmarkInt64HistogramHandleAdd(b *testing.B, name string) {
ctx := context.Background() ctx := context.Background()
fix := newFixture(b) fix := newFixture(b)
labs := makeLabels(1) labs := makeLabels(1)
mea := fix.meterMust().NewInt64ValueRecorder(name) mea := fix.meterMust().NewInt64Histogram(name)
handle := mea.Bind(labs...) handle := mea.Bind(labs...)
b.ResetTimer() b.ResetTimer()
@ -366,11 +366,11 @@ func benchmarkInt64ValueRecorderHandleAdd(b *testing.B, name string) {
} }
} }
func benchmarkFloat64ValueRecorderAdd(b *testing.B, name string) { func benchmarkFloat64HistogramAdd(b *testing.B, name string) {
ctx := context.Background() ctx := context.Background()
fix := newFixture(b) fix := newFixture(b)
labs := makeLabels(1) labs := makeLabels(1)
mea := fix.meterMust().NewFloat64ValueRecorder(name) mea := fix.meterMust().NewFloat64Histogram(name)
b.ResetTimer() b.ResetTimer()
@ -379,11 +379,11 @@ func benchmarkFloat64ValueRecorderAdd(b *testing.B, name string) {
} }
} }
func benchmarkFloat64ValueRecorderHandleAdd(b *testing.B, name string) { func benchmarkFloat64HistogramHandleAdd(b *testing.B, name string) {
ctx := context.Background() ctx := context.Background()
fix := newFixture(b) fix := newFixture(b)
labs := makeLabels(1) labs := makeLabels(1)
mea := fix.meterMust().NewFloat64ValueRecorder(name) mea := fix.meterMust().NewFloat64Histogram(name)
handle := mea.Bind(labs...) handle := mea.Bind(labs...)
b.ResetTimer() b.ResetTimer()
@ -406,15 +406,15 @@ func BenchmarkObserverRegistration(b *testing.B) {
b.ResetTimer() b.ResetTimer()
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
fix.meterMust().NewInt64ValueObserver(names[i], cb) fix.meterMust().NewInt64GaugeObserver(names[i], cb)
} }
} }
func BenchmarkValueObserverObservationInt64(b *testing.B) { func BenchmarkGaugeObserverObservationInt64(b *testing.B) {
ctx := context.Background() ctx := context.Background()
fix := newFixture(b) fix := newFixture(b)
labs := makeLabels(1) labs := makeLabels(1)
_ = fix.meterMust().NewInt64ValueObserver("test.lastvalue", func(_ context.Context, result metric.Int64ObserverResult) { _ = fix.meterMust().NewInt64GaugeObserver("test.lastvalue", func(_ context.Context, result metric.Int64ObserverResult) {
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
result.Observe((int64)(i), labs...) result.Observe((int64)(i), labs...)
} }
@ -425,11 +425,11 @@ func BenchmarkValueObserverObservationInt64(b *testing.B) {
fix.accumulator.Collect(ctx) fix.accumulator.Collect(ctx)
} }
func BenchmarkValueObserverObservationFloat64(b *testing.B) { func BenchmarkGaugeObserverObservationFloat64(b *testing.B) {
ctx := context.Background() ctx := context.Background()
fix := newFixture(b) fix := newFixture(b)
labs := makeLabels(1) labs := makeLabels(1)
_ = fix.meterMust().NewFloat64ValueObserver("test.lastvalue", func(_ context.Context, result metric.Float64ObserverResult) { _ = fix.meterMust().NewFloat64GaugeObserver("test.lastvalue", func(_ context.Context, result metric.Float64ObserverResult) {
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
result.Observe((float64)(i), labs...) result.Observe((float64)(i), labs...)
} }
@ -443,37 +443,37 @@ func BenchmarkValueObserverObservationFloat64(b *testing.B) {
// MaxSumCount // MaxSumCount
func BenchmarkInt64MaxSumCountAdd(b *testing.B) { func BenchmarkInt64MaxSumCountAdd(b *testing.B) {
benchmarkInt64ValueRecorderAdd(b, "int64.minmaxsumcount") benchmarkInt64HistogramAdd(b, "int64.minmaxsumcount")
} }
func BenchmarkInt64MaxSumCountHandleAdd(b *testing.B) { func BenchmarkInt64MaxSumCountHandleAdd(b *testing.B) {
benchmarkInt64ValueRecorderHandleAdd(b, "int64.minmaxsumcount") benchmarkInt64HistogramHandleAdd(b, "int64.minmaxsumcount")
} }
func BenchmarkFloat64MaxSumCountAdd(b *testing.B) { func BenchmarkFloat64MaxSumCountAdd(b *testing.B) {
benchmarkFloat64ValueRecorderAdd(b, "float64.minmaxsumcount") benchmarkFloat64HistogramAdd(b, "float64.minmaxsumcount")
} }
func BenchmarkFloat64MaxSumCountHandleAdd(b *testing.B) { func BenchmarkFloat64MaxSumCountHandleAdd(b *testing.B) {
benchmarkFloat64ValueRecorderHandleAdd(b, "float64.minmaxsumcount") benchmarkFloat64HistogramHandleAdd(b, "float64.minmaxsumcount")
} }
// Exact // Exact
func BenchmarkInt64ExactAdd(b *testing.B) { func BenchmarkInt64ExactAdd(b *testing.B) {
benchmarkInt64ValueRecorderAdd(b, "int64.exact") benchmarkInt64HistogramAdd(b, "int64.exact")
} }
func BenchmarkInt64ExactHandleAdd(b *testing.B) { func BenchmarkInt64ExactHandleAdd(b *testing.B) {
benchmarkInt64ValueRecorderHandleAdd(b, "int64.exact") benchmarkInt64HistogramHandleAdd(b, "int64.exact")
} }
func BenchmarkFloat64ExactAdd(b *testing.B) { func BenchmarkFloat64ExactAdd(b *testing.B) {
benchmarkFloat64ValueRecorderAdd(b, "float64.exact") benchmarkFloat64HistogramAdd(b, "float64.exact")
} }
func BenchmarkFloat64ExactHandleAdd(b *testing.B) { func BenchmarkFloat64ExactHandleAdd(b *testing.B) {
benchmarkFloat64ValueRecorderHandleAdd(b, "float64.exact") benchmarkFloat64HistogramHandleAdd(b, "float64.exact")
} }
// BatchRecord // BatchRecord

10
sdk/metric/controller/basic/controller_test.go
View File

@ -152,7 +152,7 @@ func TestStartNoExporter(t *testing.T) {
prov := cont.MeterProvider() prov := cont.MeterProvider()
calls := int64(0) calls := int64(0)
_ = metric.Must(prov.Meter("named")).NewInt64SumObserver("calls.lastvalue", _ = metric.Must(prov.Meter("named")).NewInt64CounterObserver("calls.lastvalue",
func(ctx context.Context, result metric.Int64ObserverResult) { func(ctx context.Context, result metric.Int64ObserverResult) {
calls++ calls++
checkTestContext(t, ctx) checkTestContext(t, ctx)
@ -221,7 +221,7 @@ func TestObserverCanceled(t *testing.T) {
prov := cont.MeterProvider() prov := cont.MeterProvider()
calls := int64(0) calls := int64(0)
_ = metric.Must(prov.Meter("named")).NewInt64SumObserver("done.lastvalue", _ = metric.Must(prov.Meter("named")).NewInt64CounterObserver("done.lastvalue",
func(ctx context.Context, result metric.Int64ObserverResult) { func(ctx context.Context, result metric.Int64ObserverResult) {
<-ctx.Done() <-ctx.Done()
calls++ calls++
@ -252,7 +252,7 @@ func TestObserverContext(t *testing.T) {
prov := cont.MeterProvider() prov := cont.MeterProvider()
_ = metric.Must(prov.Meter("named")).NewInt64SumObserver("done.lastvalue", _ = metric.Must(prov.Meter("named")).NewInt64CounterObserver("done.lastvalue",
func(ctx context.Context, result metric.Int64ObserverResult) { func(ctx context.Context, result metric.Int64ObserverResult) {
time.Sleep(10 * time.Millisecond) time.Sleep(10 * time.Millisecond)
checkTestContext(t, ctx) checkTestContext(t, ctx)
@ -321,7 +321,7 @@ func TestExportTimeout(t *testing.T) {
prov := cont.MeterProvider() prov := cont.MeterProvider()
calls := int64(0) calls := int64(0)
_ = metric.Must(prov.Meter("named")).NewInt64SumObserver("one.lastvalue", _ = metric.Must(prov.Meter("named")).NewInt64CounterObserver("one.lastvalue",
func(ctx context.Context, result metric.Int64ObserverResult) { func(ctx context.Context, result metric.Int64ObserverResult) {
calls++ calls++
result.Observe(calls) result.Observe(calls)
@ -377,7 +377,7 @@ func TestCollectAfterStopThenStartAgain(t *testing.T) {
prov := cont.MeterProvider() prov := cont.MeterProvider()
calls := 0 calls := 0
_ = metric.Must(prov.Meter("named")).NewInt64SumObserver("one.lastvalue", _ = metric.Must(prov.Meter("named")).NewInt64CounterObserver("one.lastvalue",
func(ctx context.Context, result metric.Int64ObserverResult) { func(ctx context.Context, result metric.Int64ObserverResult) {
calls++ calls++
result.Observe(int64(calls)) result.Observe(int64(calls))

152
sdk/metric/correct_test.go
View File

@ -131,20 +131,20 @@ func TestInputRangeUpDownCounter(t *testing.T) {
require.Nil(t, testHandler.Flush()) require.Nil(t, testHandler.Flush())
} }
func TestInputRangeValueRecorder(t *testing.T) { func TestInputRangeHistogram(t *testing.T) {
ctx := context.Background() ctx := context.Background()
meter, sdk, _, processor := newSDK(t) meter, sdk, _, processor := newSDK(t)
valuerecorder := Must(meter).NewFloat64ValueRecorder("name.exact") histogram := Must(meter).NewFloat64Histogram("name.exact")
valuerecorder.Record(ctx, math.NaN()) histogram.Record(ctx, math.NaN())
require.Equal(t, aggregation.ErrNaNInput, testHandler.Flush()) require.Equal(t, aggregation.ErrNaNInput, testHandler.Flush())
checkpointed := sdk.Collect(ctx) checkpointed := sdk.Collect(ctx)
require.Equal(t, 0, checkpointed) require.Equal(t, 0, checkpointed)
valuerecorder.Record(ctx, 1) histogram.Record(ctx, 1)
valuerecorder.Record(ctx, 2) histogram.Record(ctx, 2)
processor.Reset() processor.Reset()
checkpointed = sdk.Collect(ctx) checkpointed = sdk.Collect(ctx)
@ -160,9 +160,9 @@ func TestDisabledInstrument(t *testing.T) {
ctx := context.Background() ctx := context.Background()
meter, sdk, _, processor := newSDK(t) meter, sdk, _, processor := newSDK(t)
valuerecorder := Must(meter).NewFloat64ValueRecorder("name.disabled") histogram := Must(meter).NewFloat64Histogram("name.disabled")
valuerecorder.Record(ctx, -1) histogram.Record(ctx, -1)
checkpointed := sdk.Collect(ctx) checkpointed := sdk.Collect(ctx)
require.Equal(t, 0, checkpointed) require.Equal(t, 0, checkpointed)
@ -275,13 +275,13 @@ func TestObserverCollection(t *testing.T) {
meter, sdk, _, processor := newSDK(t) meter, sdk, _, processor := newSDK(t)
mult := 1 mult := 1
_ = Must(meter).NewFloat64ValueObserver("float.valueobserver.lastvalue", func(_ context.Context, result metric.Float64ObserverResult) { _ = Must(meter).NewFloat64GaugeObserver("float.gauge.lastvalue", func(_ context.Context, result metric.Float64ObserverResult) {
result.Observe(float64(mult), attribute.String("A", "B")) result.Observe(float64(mult), attribute.String("A", "B"))
// last value wins // last value wins
result.Observe(float64(-mult), attribute.String("A", "B")) result.Observe(float64(-mult), attribute.String("A", "B"))
result.Observe(float64(-mult), attribute.String("C", "D")) result.Observe(float64(-mult), attribute.String("C", "D"))
}) })
_ = Must(meter).NewInt64ValueObserver("int.valueobserver.lastvalue", func(_ context.Context, result metric.Int64ObserverResult) { _ = Must(meter).NewInt64GaugeObserver("int.gauge.lastvalue", func(_ context.Context, result metric.Int64ObserverResult) {
result.Observe(int64(-mult), attribute.String("A", "B")) result.Observe(int64(-mult), attribute.String("A", "B"))
result.Observe(int64(mult)) result.Observe(int64(mult))
// last value wins // last value wins
@ -289,12 +289,12 @@ func TestObserverCollection(t *testing.T) {
result.Observe(int64(mult)) result.Observe(int64(mult))
}) })
_ = Must(meter).NewFloat64SumObserver("float.sumobserver.sum", func(_ context.Context, result metric.Float64ObserverResult) { _ = Must(meter).NewFloat64CounterObserver("float.counterobserver.sum", func(_ context.Context, result metric.Float64ObserverResult) {
result.Observe(float64(mult), attribute.String("A", "B")) result.Observe(float64(mult), attribute.String("A", "B"))
result.Observe(float64(2*mult), attribute.String("A", "B")) result.Observe(float64(2*mult), attribute.String("A", "B"))
result.Observe(float64(mult), attribute.String("C", "D")) result.Observe(float64(mult), attribute.String("C", "D"))
}) })
_ = Must(meter).NewInt64SumObserver("int.sumobserver.sum", func(_ context.Context, result metric.Int64ObserverResult) { _ = Must(meter).NewInt64CounterObserver("int.counterobserver.sum", func(_ context.Context, result metric.Int64ObserverResult) {
result.Observe(int64(2*mult), attribute.String("A", "B")) result.Observe(int64(2*mult), attribute.String("A", "B"))
result.Observe(int64(mult)) result.Observe(int64(mult))
// last value wins // last value wins
@ -302,12 +302,12 @@ func TestObserverCollection(t *testing.T) {
result.Observe(int64(mult)) result.Observe(int64(mult))
}) })
_ = Must(meter).NewFloat64UpDownSumObserver("float.updownsumobserver.sum", func(_ context.Context, result metric.Float64ObserverResult) { _ = Must(meter).NewFloat64UpDownCounterObserver("float.updowncounterobserver.sum", func(_ context.Context, result metric.Float64ObserverResult) {
result.Observe(float64(mult), attribute.String("A", "B")) result.Observe(float64(mult), attribute.String("A", "B"))
result.Observe(float64(-2*mult), attribute.String("A", "B")) result.Observe(float64(-2*mult), attribute.String("A", "B"))
result.Observe(float64(mult), attribute.String("C", "D")) result.Observe(float64(mult), attribute.String("C", "D"))
}) })
_ = Must(meter).NewInt64UpDownSumObserver("int.updownsumobserver.sum", func(_ context.Context, result metric.Int64ObserverResult) { _ = Must(meter).NewInt64UpDownCounterObserver("int.updowncounterobserver.sum", func(_ context.Context, result metric.Int64ObserverResult) {
result.Observe(int64(2*mult), attribute.String("A", "B")) result.Observe(int64(2*mult), attribute.String("A", "B"))
result.Observe(int64(mult)) result.Observe(int64(mult))
// last value wins // last value wins
@ -315,7 +315,7 @@ func TestObserverCollection(t *testing.T) {
result.Observe(int64(-mult)) result.Observe(int64(-mult))
}) })
_ = Must(meter).NewInt64ValueObserver("empty.valueobserver.sum", func(_ context.Context, result metric.Int64ObserverResult) { _ = Must(meter).NewInt64GaugeObserver("empty.gauge.sum", func(_ context.Context, result metric.Int64ObserverResult) {
}) })
for mult = 0; mult < 3; mult++ { for mult = 0; mult < 3; mult++ {
@ -326,36 +326,36 @@ func TestObserverCollection(t *testing.T) {
mult := float64(mult) mult := float64(mult)
require.EqualValues(t, map[string]float64{ require.EqualValues(t, map[string]float64{
"float.valueobserver.lastvalue/A=B/": -mult, "float.gauge.lastvalue/A=B/": -mult,
"float.valueobserver.lastvalue/C=D/": -mult, "float.gauge.lastvalue/C=D/": -mult,
"int.valueobserver.lastvalue//": mult, "int.gauge.lastvalue//": mult,
"int.valueobserver.lastvalue/A=B/": mult, "int.gauge.lastvalue/A=B/": mult,
"float.sumobserver.sum/A=B/": 2 * mult, "float.counterobserver.sum/A=B/": 2 * mult,
"float.sumobserver.sum/C=D/": mult, "float.counterobserver.sum/C=D/": mult,
"int.sumobserver.sum//": mult, "int.counterobserver.sum//": mult,
"int.sumobserver.sum/A=B/": mult, "int.counterobserver.sum/A=B/": mult,
"float.updownsumobserver.sum/A=B/": -2 * mult, "float.updowncounterobserver.sum/A=B/": -2 * mult,
"float.updownsumobserver.sum/C=D/": mult, "float.updowncounterobserver.sum/C=D/": mult,
"int.updownsumobserver.sum//": -mult, "int.updowncounterobserver.sum//": -mult,
"int.updownsumobserver.sum/A=B/": mult, "int.updowncounterobserver.sum/A=B/": mult,
}, processor.Values()) }, processor.Values())
} }
} }
func TestSumObserverInputRange(t *testing.T) { func TestCounterObserverInputRange(t *testing.T) {
ctx := context.Background() ctx := context.Background()
meter, sdk, _, processor := newSDK(t) meter, sdk, _, processor := newSDK(t)
// TODO: these tests are testing for negative values, not for _descending values_. Fix. // TODO: these tests are testing for negative values, not for _descending values_. Fix.
_ = Must(meter).NewFloat64SumObserver("float.sumobserver.sum", func(_ context.Context, result metric.Float64ObserverResult) { _ = Must(meter).NewFloat64CounterObserver("float.counterobserver.sum", func(_ context.Context, result metric.Float64ObserverResult) {
result.Observe(-2, attribute.String("A", "B")) result.Observe(-2, attribute.String("A", "B"))
require.Equal(t, aggregation.ErrNegativeInput, testHandler.Flush()) require.Equal(t, aggregation.ErrNegativeInput, testHandler.Flush())
result.Observe(-1, attribute.String("C", "D")) result.Observe(-1, attribute.String("C", "D"))
require.Equal(t, aggregation.ErrNegativeInput, testHandler.Flush()) require.Equal(t, aggregation.ErrNegativeInput, testHandler.Flush())
}) })
_ = Must(meter).NewInt64SumObserver("int.sumobserver.sum", func(_ context.Context, result metric.Int64ObserverResult) { _ = Must(meter).NewInt64CounterObserver("int.counterobserver.sum", func(_ context.Context, result metric.Int64ObserverResult) {
result.Observe(-1, attribute.String("A", "B")) result.Observe(-1, attribute.String("A", "B"))
require.Equal(t, aggregation.ErrNegativeInput, testHandler.Flush()) require.Equal(t, aggregation.ErrNegativeInput, testHandler.Flush())
result.Observe(-1) result.Observe(-1)
@ -375,12 +375,12 @@ func TestObserverBatch(t *testing.T) {
ctx := context.Background() ctx := context.Background()
meter, sdk, _, processor := newSDK(t) meter, sdk, _, processor := newSDK(t)
var floatValueObs metric.Float64ValueObserver var floatGaugeObs metric.Float64GaugeObserver
var intValueObs metric.Int64ValueObserver var intGaugeObs metric.Int64GaugeObserver
var floatSumObs metric.Float64SumObserver var floatCounterObs metric.Float64CounterObserver
var intSumObs metric.Int64SumObserver var intCounterObs metric.Int64CounterObserver
var floatUpDownSumObs metric.Float64UpDownSumObserver var floatUpDownCounterObs metric.Float64UpDownCounterObserver
var intUpDownSumObs metric.Int64UpDownSumObserver var intUpDownCounterObs metric.Int64UpDownCounterObserver
var batch = Must(meter).NewBatchObserver( var batch = Must(meter).NewBatchObserver(
func(_ context.Context, result metric.BatchObserverResult) { func(_ context.Context, result metric.BatchObserverResult) {
@ -388,58 +388,58 @@ func TestObserverBatch(t *testing.T) {
[]attribute.KeyValue{ []attribute.KeyValue{
attribute.String("A", "B"), attribute.String("A", "B"),
}, },
floatValueObs.Observation(1), floatGaugeObs.Observation(1),
floatValueObs.Observation(-1), floatGaugeObs.Observation(-1),
intValueObs.Observation(-1), intGaugeObs.Observation(-1),
intValueObs.Observation(1), intGaugeObs.Observation(1),
floatSumObs.Observation(1000), floatCounterObs.Observation(1000),
intSumObs.Observation(100), intCounterObs.Observation(100),
floatUpDownSumObs.Observation(-1000), floatUpDownCounterObs.Observation(-1000),
intUpDownSumObs.Observation(-100), intUpDownCounterObs.Observation(-100),
) )
result.Observe( result.Observe(
[]attribute.KeyValue{ []attribute.KeyValue{
attribute.String("C", "D"), attribute.String("C", "D"),
}, },
floatValueObs.Observation(-1), floatGaugeObs.Observation(-1),
floatSumObs.Observation(-1), floatCounterObs.Observation(-1),
floatUpDownSumObs.Observation(-1), floatUpDownCounterObs.Observation(-1),
) )
result.Observe( result.Observe(
nil, nil,
intValueObs.Observation(1), intGaugeObs.Observation(1),
intValueObs.Observation(1), intGaugeObs.Observation(1),
intSumObs.Observation(10), intCounterObs.Observation(10),
floatSumObs.Observation(1.1), floatCounterObs.Observation(1.1),
intUpDownSumObs.Observation(10), intUpDownCounterObs.Observation(10),
) )
}) })
floatValueObs = batch.NewFloat64ValueObserver("float.valueobserver.lastvalue") floatGaugeObs = batch.NewFloat64GaugeObserver("float.gauge.lastvalue")
intValueObs = batch.NewInt64ValueObserver("int.valueobserver.lastvalue") intGaugeObs = batch.NewInt64GaugeObserver("int.gauge.lastvalue")
floatSumObs = batch.NewFloat64SumObserver("float.sumobserver.sum") floatCounterObs = batch.NewFloat64CounterObserver("float.counterobserver.sum")
intSumObs = batch.NewInt64SumObserver("int.sumobserver.sum") intCounterObs = batch.NewInt64CounterObserver("int.counterobserver.sum")
floatUpDownSumObs = batch.NewFloat64UpDownSumObserver("float.updownsumobserver.sum") floatUpDownCounterObs = batch.NewFloat64UpDownCounterObserver("float.updowncounterobserver.sum")
intUpDownSumObs = batch.NewInt64UpDownSumObserver("int.updownsumobserver.sum") intUpDownCounterObs = batch.NewInt64UpDownCounterObserver("int.updowncounterobserver.sum")
collected := sdk.Collect(ctx) collected := sdk.Collect(ctx)
require.Equal(t, collected, len(processor.Values())) require.Equal(t, collected, len(processor.Values()))
require.EqualValues(t, map[string]float64{ require.EqualValues(t, map[string]float64{
"float.sumobserver.sum//": 1.1, "float.counterobserver.sum//": 1.1,
"float.sumobserver.sum/A=B/": 1000, "float.counterobserver.sum/A=B/": 1000,
"int.sumobserver.sum//": 10, "int.counterobserver.sum//": 10,
"int.sumobserver.sum/A=B/": 100, "int.counterobserver.sum/A=B/": 100,
"int.updownsumobserver.sum/A=B/": -100, "int.updowncounterobserver.sum/A=B/": -100,
"float.updownsumobserver.sum/A=B/": -1000, "float.updowncounterobserver.sum/A=B/": -1000,
"int.updownsumobserver.sum//": 10, "int.updowncounterobserver.sum//": 10,
"float.updownsumobserver.sum/C=D/": -1, "float.updowncounterobserver.sum/C=D/": -1,
"float.valueobserver.lastvalue/A=B/": -1, "float.gauge.lastvalue/A=B/": -1,
"float.valueobserver.lastvalue/C=D/": -1, "float.gauge.lastvalue/C=D/": -1,
"int.valueobserver.lastvalue//": 1, "int.gauge.lastvalue//": 1,
"int.valueobserver.lastvalue/A=B/": 1, "int.gauge.lastvalue/A=B/": 1,
}, processor.Values()) }, processor.Values())
} }
@ -449,8 +449,8 @@ func TestRecordBatch(t *testing.T) {
counter1 := Must(meter).NewInt64Counter("int64.sum") counter1 := Must(meter).NewInt64Counter("int64.sum")
counter2 := Must(meter).NewFloat64Counter("float64.sum") counter2 := Must(meter).NewFloat64Counter("float64.sum")
valuerecorder1 := Must(meter).NewInt64ValueRecorder("int64.exact") histogram1 := Must(meter).NewInt64Histogram("int64.exact")
valuerecorder2 := Must(meter).NewFloat64ValueRecorder("float64.exact") histogram2 := Must(meter).NewFloat64Histogram("float64.exact")
sdk.RecordBatch( sdk.RecordBatch(
ctx, ctx,
@ -460,8 +460,8 @@ func TestRecordBatch(t *testing.T) {
}, },
counter1.Measurement(1), counter1.Measurement(1),
counter2.Measurement(2), counter2.Measurement(2),
valuerecorder1.Measurement(3), histogram1.Measurement(3),
valuerecorder2.Measurement(4), histogram2.Measurement(4),
) )
sdk.Collect(ctx) sdk.Collect(ctx)
@ -498,7 +498,7 @@ func TestIncorrectInstruments(t *testing.T) {
// The Batch observe/record APIs are susceptible to // The Batch observe/record APIs are susceptible to
// uninitialized instruments. // uninitialized instruments.
var counter metric.Int64Counter var counter metric.Int64Counter
var observer metric.Int64ValueObserver var observer metric.Int64GaugeObserver
ctx := context.Background() ctx := context.Background()
meter, sdk, _, processor := newSDK(t) meter, sdk, _, processor := newSDK(t)
@ -518,7 +518,7 @@ func TestIncorrectInstruments(t *testing.T) {
counter = metric.Must(noopMeter).NewInt64Counter("name.sum") counter = metric.Must(noopMeter).NewInt64Counter("name.sum")
observer = metric.Must(noopMeter).NewBatchObserver( observer = metric.Must(noopMeter).NewBatchObserver(
func(context.Context, metric.BatchObserverResult) {}, func(context.Context, metric.BatchObserverResult) {},
).NewInt64ValueObserver("observer") ).NewInt64GaugeObserver("observer")
meter.RecordBatch(ctx, nil, counter.Measurement(1)) meter.RecordBatch(ctx, nil, counter.Measurement(1))
meter.NewBatchObserver(func(_ context.Context, result metric.BatchObserverResult) { meter.NewBatchObserver(func(_ context.Context, result metric.BatchObserverResult) {
@ -536,7 +536,7 @@ func TestSyncInAsync(t *testing.T) {
meter, sdk, _, processor := newSDK(t) meter, sdk, _, processor := newSDK(t)
counter := Must(meter).NewFloat64Counter("counter.sum") counter := Must(meter).NewFloat64Counter("counter.sum")
_ = Must(meter).NewInt64ValueObserver("observer.lastvalue", _ = Must(meter).NewInt64GaugeObserver("observer.lastvalue",
func(ctx context.Context, result metric.Int64ObserverResult) { func(ctx context.Context, result metric.Int64ObserverResult) {
result.Observe(10) result.Observe(10)
counter.Add(ctx, 100) counter.Add(ctx, 100)

2
sdk/metric/histogram_stress_test.go
View File

@ -29,7 +29,7 @@ import (
) )
func TestStressInt64Histogram(t *testing.T) { func TestStressInt64Histogram(t *testing.T) {
desc := metric.NewDescriptor("some_metric", sdkapi.ValueRecorderInstrumentKind, number.Int64Kind) desc := metric.NewDescriptor("some_metric", sdkapi.HistogramInstrumentKind, number.Int64Kind)
alloc := histogram.New(2, &desc, histogram.WithExplicitBoundaries([]float64{25, 50, 75})) alloc := histogram.New(2, &desc, histogram.WithExplicitBoundaries([]float64{25, 50, 75}))
h, ckpt := &alloc[0], &alloc[1] h, ckpt := &alloc[0], &alloc[1]

2
sdk/metric/minmaxsumcount_stress_test.go
View File

@ -27,7 +27,7 @@ import (
) )
func TestStressInt64MinMaxSumCount(t *testing.T) { func TestStressInt64MinMaxSumCount(t *testing.T) {
desc := metric.NewDescriptor("some_metric", sdkapi.ValueRecorderInstrumentKind, number.Int64Kind) desc := metric.NewDescriptor("some_metric", sdkapi.HistogramInstrumentKind, number.Int64Kind)
alloc := minmaxsumcount.New(2, &desc) alloc := minmaxsumcount.New(2, &desc)
mmsc, ckpt := &alloc[0], &alloc[1] mmsc, ckpt := &alloc[0], &alloc[1]

16
sdk/metric/processor/basic/basic_test.go
View File

@ -65,10 +65,10 @@ func TestProcessor(t *testing.T) {
for _, ic := range []instrumentCase{ for _, ic := range []instrumentCase{
{kind: sdkapi.CounterInstrumentKind}, {kind: sdkapi.CounterInstrumentKind},
{kind: sdkapi.UpDownCounterInstrumentKind}, {kind: sdkapi.UpDownCounterInstrumentKind},
{kind: sdkapi.ValueRecorderInstrumentKind}, {kind: sdkapi.HistogramInstrumentKind},
{kind: sdkapi.SumObserverInstrumentKind}, {kind: sdkapi.CounterObserverInstrumentKind},
{kind: sdkapi.UpDownSumObserverInstrumentKind}, {kind: sdkapi.UpDownCounterObserverInstrumentKind},
{kind: sdkapi.ValueObserverInstrumentKind}, {kind: sdkapi.GaugeObserverInstrumentKind},
} { } {
t.Run(ic.kind.String(), func(t *testing.T) { t.Run(ic.kind.String(), func(t *testing.T) {
for _, nc := range []numberCase{ for _, nc := range []numberCase{
@ -403,7 +403,7 @@ func TestStatefulNoMemoryCumulative(t *testing.T) {
func TestStatefulNoMemoryDelta(t *testing.T) { func TestStatefulNoMemoryDelta(t *testing.T) {
ekindSel := export.DeltaExportKindSelector() ekindSel := export.DeltaExportKindSelector()
desc := metric.NewDescriptor("inst.sum", sdkapi.SumObserverInstrumentKind, number.Int64Kind) desc := metric.NewDescriptor("inst.sum", sdkapi.CounterObserverInstrumentKind, number.Int64Kind)
selector := processorTest.AggregatorSelector() selector := processorTest.AggregatorSelector()
processor := basic.New(selector, ekindSel, basic.WithMemory(false)) processor := basic.New(selector, ekindSel, basic.WithMemory(false))
@ -439,7 +439,7 @@ func TestMultiObserverSum(t *testing.T) {
export.DeltaExportKindSelector(), export.DeltaExportKindSelector(),
} { } {
desc := metric.NewDescriptor("observe.sum", sdkapi.SumObserverInstrumentKind, number.Int64Kind) desc := metric.NewDescriptor("observe.sum", sdkapi.CounterObserverInstrumentKind, number.Int64Kind)
selector := processorTest.AggregatorSelector() selector := processorTest.AggregatorSelector()
processor := basic.New(selector, ekindSel, basic.WithMemory(false)) processor := basic.New(selector, ekindSel, basic.WithMemory(false))
@ -469,7 +469,7 @@ func TestMultiObserverSum(t *testing.T) {
} }
} }
func TestSumObserverEndToEnd(t *testing.T) { func TestCounterObserverEndToEnd(t *testing.T) {
ctx := context.Background() ctx := context.Background()
eselector := export.CumulativeExportKindSelector() eselector := export.CumulativeExportKindSelector()
proc := basic.New( proc := basic.New(
@ -480,7 +480,7 @@ func TestSumObserverEndToEnd(t *testing.T) {
meter := metric.WrapMeterImpl(accum, "testing") meter := metric.WrapMeterImpl(accum, "testing")
var calls int64 var calls int64
metric.Must(meter).NewInt64SumObserver("observer.sum", metric.Must(meter).NewInt64CounterObserver("observer.sum",
func(_ context.Context, result metric.Int64ObserverResult) { func(_ context.Context, result metric.Int64ObserverResult) {
calls++ calls++
result.Observe(calls) result.Observe(calls)

2
sdk/metric/processor/processortest/test_test.go
View File

@ -35,7 +35,7 @@ func generateTestData(proc export.Processor) {
counter := metric.Must(meter).NewFloat64Counter("counter.sum") counter := metric.Must(meter).NewFloat64Counter("counter.sum")
_ = metric.Must(meter).NewInt64SumObserver("observer.sum", _ = metric.Must(meter).NewInt64CounterObserver("observer.sum",
func(_ context.Context, result metric.Int64ObserverResult) { func(_ context.Context, result metric.Int64ObserverResult) {
result.Observe(10, attribute.String("K1", "V1")) result.Observe(10, attribute.String("K1", "V1"))
result.Observe(11, attribute.String("K1", "V2")) result.Observe(11, attribute.String("K1", "V2"))

2
sdk/metric/processor/reducer/reducer_test.go
View File

@ -57,7 +57,7 @@ func generateData(impl metric.MeterImpl) {
counter := metric.Must(meter).NewFloat64Counter("counter.sum") counter := metric.Must(meter).NewFloat64Counter("counter.sum")
_ = metric.Must(meter).NewInt64SumObserver("observer.sum", _ = metric.Must(meter).NewInt64CounterObserver("observer.sum",
func(_ context.Context, result metric.Int64ObserverResult) { func(_ context.Context, result metric.Int64ObserverResult) {
result.Observe(10, kvs1...) result.Observe(10, kvs1...)
result.Observe(10, kvs2...) result.Observe(10, kvs2...)

18
sdk/metric/selector/simple/simple.go
View File

@ -40,7 +40,7 @@ var (
) )
// NewWithInexpensiveDistribution returns a simple aggregator selector // NewWithInexpensiveDistribution returns a simple aggregator selector
// that uses minmaxsumcount aggregators for `ValueRecorder` // that uses minmaxsumcount aggregators for `Histogram`
// instruments. This selector is faster and uses less memory than the // instruments. This selector is faster and uses less memory than the
// others in this package because minmaxsumcount aggregators maintain // others in this package because minmaxsumcount aggregators maintain
// the least information about the distribution among these choices. // the least information about the distribution among these choices.
@ -49,7 +49,7 @@ func NewWithInexpensiveDistribution() export.AggregatorSelector {
} }
// NewWithExactDistribution returns a simple aggregator selector that // NewWithExactDistribution returns a simple aggregator selector that
// uses exact aggregators for `ValueRecorder` instruments. This // uses exact aggregators for `Histogram` instruments. This
// selector uses more memory than the others in this package because // selector uses more memory than the others in this package because
// exact aggregators maintain the most information about the // exact aggregators maintain the most information about the
// distribution among these choices. // distribution among these choices.
@ -58,7 +58,7 @@ func NewWithExactDistribution() export.AggregatorSelector {
} }
// NewWithHistogramDistribution returns a simple aggregator selector // NewWithHistogramDistribution returns a simple aggregator selector
// that uses histogram aggregators for `ValueRecorder` instruments. // that uses histogram aggregators for `Histogram` instruments.
// This selector is a good default choice for most metric exporters. // This selector is a good default choice for most metric exporters.
func NewWithHistogramDistribution(options ...histogram.Option) export.AggregatorSelector { func NewWithHistogramDistribution(options ...histogram.Option) export.AggregatorSelector {
return selectorHistogram{options: options} return selectorHistogram{options: options}
@ -80,9 +80,9 @@ func lastValueAggs(aggPtrs []*export.Aggregator) {
func (selectorInexpensive) AggregatorFor(descriptor *metric.Descriptor, aggPtrs ...*export.Aggregator) { func (selectorInexpensive) AggregatorFor(descriptor *metric.Descriptor, aggPtrs ...*export.Aggregator) {
switch descriptor.InstrumentKind() { switch descriptor.InstrumentKind() {
case sdkapi.ValueObserverInstrumentKind: case sdkapi.GaugeObserverInstrumentKind:
lastValueAggs(aggPtrs) lastValueAggs(aggPtrs)
case sdkapi.ValueRecorderInstrumentKind: case sdkapi.HistogramInstrumentKind:
aggs := minmaxsumcount.New(len(aggPtrs), descriptor) aggs := minmaxsumcount.New(len(aggPtrs), descriptor)
for i := range aggPtrs { for i := range aggPtrs {
*aggPtrs[i] = &aggs[i] *aggPtrs[i] = &aggs[i]
@ -94,9 +94,9 @@ func (selectorInexpensive) AggregatorFor(descriptor *metric.Descriptor, aggPtrs
func (selectorExact) AggregatorFor(descriptor *metric.Descriptor, aggPtrs ...*export.Aggregator) { func (selectorExact) AggregatorFor(descriptor *metric.Descriptor, aggPtrs ...*export.Aggregator) {
switch descriptor.InstrumentKind() { switch descriptor.InstrumentKind() {
case sdkapi.ValueObserverInstrumentKind: case sdkapi.GaugeObserverInstrumentKind:
lastValueAggs(aggPtrs) lastValueAggs(aggPtrs)
case sdkapi.ValueRecorderInstrumentKind: case sdkapi.HistogramInstrumentKind:
aggs := exact.New(len(aggPtrs)) aggs := exact.New(len(aggPtrs))
for i := range aggPtrs { for i := range aggPtrs {
*aggPtrs[i] = &aggs[i] *aggPtrs[i] = &aggs[i]
@ -108,9 +108,9 @@ func (selectorExact) AggregatorFor(descriptor *metric.Descriptor, aggPtrs ...*ex
func (s selectorHistogram) AggregatorFor(descriptor *metric.Descriptor, aggPtrs ...*export.Aggregator) { func (s selectorHistogram) AggregatorFor(descriptor *metric.Descriptor, aggPtrs ...*export.Aggregator) {
switch descriptor.InstrumentKind() { switch descriptor.InstrumentKind() {
case sdkapi.ValueObserverInstrumentKind: case sdkapi.GaugeObserverInstrumentKind:
lastValueAggs(aggPtrs) lastValueAggs(aggPtrs)
case sdkapi.ValueRecorderInstrumentKind: case sdkapi.HistogramInstrumentKind:
aggs := histogram.New(len(aggPtrs), descriptor, s.options...) aggs := histogram.New(len(aggPtrs), descriptor, s.options...)
for i := range aggPtrs { for i := range aggPtrs {
*aggPtrs[i] = &aggs[i] *aggPtrs[i] = &aggs[i]

24
sdk/metric/selector/simple/simple_test.go
View File

@ -32,12 +32,12 @@ import (
) )
var ( var (
testCounterDesc = metric.NewDescriptor("counter", sdkapi.CounterInstrumentKind, number.Int64Kind) testCounterDesc = metric.NewDescriptor("counter", sdkapi.CounterInstrumentKind, number.Int64Kind)
testUpDownCounterDesc = metric.NewDescriptor("updowncounter", sdkapi.UpDownCounterInstrumentKind, number.Int64Kind) testUpDownCounterDesc = metric.NewDescriptor("updowncounter", sdkapi.UpDownCounterInstrumentKind, number.Int64Kind)
testSumObserverDesc = metric.NewDescriptor("sumobserver", sdkapi.SumObserverInstrumentKind, number.Int64Kind) testCounterObserverDesc = metric.NewDescriptor("counterobserver", sdkapi.CounterObserverInstrumentKind, number.Int64Kind)
testUpDownSumObserverDesc = metric.NewDescriptor("updownsumobserver", sdkapi.UpDownSumObserverInstrumentKind, number.Int64Kind) testUpDownCounterObserverDesc = metric.NewDescriptor("updowncounterobserver", sdkapi.UpDownCounterObserverInstrumentKind, number.Int64Kind)
testValueRecorderDesc = metric.NewDescriptor("valuerecorder", sdkapi.ValueRecorderInstrumentKind, number.Int64Kind) testHistogramDesc = metric.NewDescriptor("histogram", sdkapi.HistogramInstrumentKind, number.Int64Kind)
testValueObserverDesc = metric.NewDescriptor("valueobserver", sdkapi.ValueObserverInstrumentKind, number.Int64Kind) testGaugeObserverDesc = metric.NewDescriptor("gauge", sdkapi.GaugeObserverInstrumentKind, number.Int64Kind)
) )
func oneAgg(sel export.AggregatorSelector, desc *metric.Descriptor) export.Aggregator { func oneAgg(sel export.AggregatorSelector, desc *metric.Descriptor) export.Aggregator {
@ -47,27 +47,27 @@ func oneAgg(sel export.AggregatorSelector, desc *metric.Descriptor) export.Aggre
} }
func testFixedSelectors(t *testing.T, sel export.AggregatorSelector) { func testFixedSelectors(t *testing.T, sel export.AggregatorSelector) {
require.IsType(t, (*lastvalue.Aggregator)(nil), oneAgg(sel, &testValueObserverDesc)) require.IsType(t, (*lastvalue.Aggregator)(nil), oneAgg(sel, &testGaugeObserverDesc))
require.IsType(t, (*sum.Aggregator)(nil), oneAgg(sel, &testCounterDesc)) require.IsType(t, (*sum.Aggregator)(nil), oneAgg(sel, &testCounterDesc))
require.IsType(t, (*sum.Aggregator)(nil), oneAgg(sel, &testUpDownCounterDesc)) require.IsType(t, (*sum.Aggregator)(nil), oneAgg(sel, &testUpDownCounterDesc))
require.IsType(t, (*sum.Aggregator)(nil), oneAgg(sel, &testSumObserverDesc)) require.IsType(t, (*sum.Aggregator)(nil), oneAgg(sel, &testCounterObserverDesc))
require.IsType(t, (*sum.Aggregator)(nil), oneAgg(sel, &testUpDownSumObserverDesc)) require.IsType(t, (*sum.Aggregator)(nil), oneAgg(sel, &testUpDownCounterObserverDesc))
} }
func TestInexpensiveDistribution(t *testing.T) { func TestInexpensiveDistribution(t *testing.T) {
inex := simple.NewWithInexpensiveDistribution() inex := simple.NewWithInexpensiveDistribution()
require.IsType(t, (*minmaxsumcount.Aggregator)(nil), oneAgg(inex, &testValueRecorderDesc)) require.IsType(t, (*minmaxsumcount.Aggregator)(nil), oneAgg(inex, &testHistogramDesc))
testFixedSelectors(t, inex) testFixedSelectors(t, inex)
} }
func TestExactDistribution(t *testing.T) { func TestExactDistribution(t *testing.T) {
ex := simple.NewWithExactDistribution() ex := simple.NewWithExactDistribution()
require.IsType(t, (*exact.Aggregator)(nil), oneAgg(ex, &testValueRecorderDesc)) require.IsType(t, (*exact.Aggregator)(nil), oneAgg(ex, &testHistogramDesc))
testFixedSelectors(t, ex) testFixedSelectors(t, ex)
} }
func TestHistogramDistribution(t *testing.T) { func TestHistogramDistribution(t *testing.T) {
hist := simple.NewWithHistogramDistribution() hist := simple.NewWithHistogramDistribution()
require.IsType(t, (*histogram.Aggregator)(nil), oneAgg(hist, &testValueRecorderDesc)) require.IsType(t, (*histogram.Aggregator)(nil), oneAgg(hist, &testHistogramDesc))
testFixedSelectors(t, hist) testFixedSelectors(t, hist)
} }

14
sdk/metric/stress_test.go
View File

@ -272,7 +272,7 @@ func (f *testFixture) Process(accumulation export.Accumulation) error {
f.T.Fatal("Sum error: ", err) f.T.Fatal("Sum error: ", err)
} }
f.impl.storeCollect(actual, sum, time.Time{}) f.impl.storeCollect(actual, sum, time.Time{})
case sdkapi.ValueRecorderInstrumentKind: case sdkapi.HistogramInstrumentKind:
lv, ts, err := agg.(aggregation.LastValue).LastValue() lv, ts, err := agg.(aggregation.LastValue).LastValue()
if err != nil && err != aggregation.ErrNoData { if err != nil && err != aggregation.ErrNoData {
f.T.Fatal("Last value error: ", err) f.T.Fatal("Last value error: ", err)
@ -420,15 +420,15 @@ func TestStressFloat64Counter(t *testing.T) {
func intLastValueTestImpl() testImpl { func intLastValueTestImpl() testImpl {
return testImpl{ return testImpl{
newInstrument: func(meter metric.Meter, name string) SyncImpler { newInstrument: func(meter metric.Meter, name string) SyncImpler {
return Must(meter).NewInt64ValueRecorder(name + ".lastvalue") return Must(meter).NewInt64Histogram(name + ".lastvalue")
}, },
getUpdateValue: func() number.Number { getUpdateValue: func() number.Number {
r1 := rand.Int63() r1 := rand.Int63()
return number.NewInt64Number(rand.Int63() - r1) return number.NewInt64Number(rand.Int63() - r1)
}, },
operate: func(inst interface{}, ctx context.Context, value number.Number, labels []attribute.KeyValue) { operate: func(inst interface{}, ctx context.Context, value number.Number, labels []attribute.KeyValue) {
valuerecorder := inst.(metric.Int64ValueRecorder) histogram := inst.(metric.Int64Histogram)
valuerecorder.Record(ctx, value.AsInt64(), labels...) histogram.Record(ctx, value.AsInt64(), labels...)
}, },
newStore: func() interface{} { newStore: func() interface{} {
return &lastValueState{ return &lastValueState{
@ -462,14 +462,14 @@ func TestStressInt64LastValue(t *testing.T) {
func floatLastValueTestImpl() testImpl { func floatLastValueTestImpl() testImpl {
return testImpl{ return testImpl{
newInstrument: func(meter metric.Meter, name string) SyncImpler { newInstrument: func(meter metric.Meter, name string) SyncImpler {
return Must(meter).NewFloat64ValueRecorder(name + ".lastvalue") return Must(meter).NewFloat64Histogram(name + ".lastvalue")
}, },
getUpdateValue: func() number.Number { getUpdateValue: func() number.Number {
return number.NewFloat64Number((-0.5 + rand.Float64()) * 100000) return number.NewFloat64Number((-0.5 + rand.Float64()) * 100000)
}, },
operate: func(inst interface{}, ctx context.Context, value number.Number, labels []attribute.KeyValue) { operate: func(inst interface{}, ctx context.Context, value number.Number, labels []attribute.KeyValue) {
valuerecorder := inst.(metric.Float64ValueRecorder) histogram := inst.(metric.Float64Histogram)
valuerecorder.Record(ctx, value.AsFloat64(), labels...) histogram.Record(ctx, value.AsFloat64(), labels...)
}, },
newStore: func() interface{} { newStore: func() interface{} {
return &lastValueState{ return &lastValueState{