From 2d0d4a533964bc9e1813b29f34ee1813b5fbbc50 Mon Sep 17 00:00:00 2001 From: Alex Boten <223565+codeboten@users.noreply.github.com> Date: Tue, 3 Dec 2024 16:12:52 -0800 Subject: [PATCH 1/6] add experimental Enabled interface Opening this to get feedback on whether or not I'm headed in the right direction based on the details listed in https://github.com/open-telemetry/opentelemetry-go/issues/6002. This is a replacement for https://github.com/open-telemetry/opentelemetry-go/pull/5768 Fixes #6002 There are still some tests I would add, but overall I'm mostly looking to reviewers to let me know if this is the correct approach (defining an interface in `x` and using that interface in the SDK) Signed-off-by: Alex Boten <223565+codeboten@users.noreply.github.com> --- CHANGELOG.md | 2 + sdk/metric/instrument.go | 11 ++++ sdk/metric/internal/x/README.md | 19 ++++++ sdk/metric/internal/x/x.go | 11 ++++ sdk/metric/meter_test.go | 113 ++++++++++++++++++++++++++++++++ 5 files changed, 156 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 566829ae1e2..9140f8558c3 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,6 +11,8 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm ### Added - Add `Reset` method to `SpanRecorder` in `go.opentelemetry.io/otel/sdk/trace/tracetest`. (#5994) +- Experimental `EnabledInstrument` interface added to the metric SDK. + See [metric documentation](./sdk/metric/internal/x/README.md#instrument-enabled) for more information about this feature and how to use it. (#) ### Changed diff --git a/sdk/metric/instrument.go b/sdk/metric/instrument.go index 48b723a7b3b..680113890d5 100644 --- a/sdk/metric/instrument.go +++ b/sdk/metric/instrument.go @@ -16,6 +16,7 @@ import ( "go.opentelemetry.io/otel/metric/embedded" "go.opentelemetry.io/otel/sdk/instrumentation" "go.opentelemetry.io/otel/sdk/metric/internal/aggregate" + "go.opentelemetry.io/otel/sdk/metric/internal/x" ) var zeroScope instrumentation.Scope @@ -183,6 +184,7 @@ type int64Inst struct { embedded.Int64UpDownCounter embedded.Int64Histogram embedded.Int64Gauge + x.EnabledInstrument } var ( @@ -202,6 +204,10 @@ func (i *int64Inst) Record(ctx context.Context, val int64, opts ...metric.Record i.aggregate(ctx, val, c.Attributes()) } +func (i *int64Inst) Enabled() bool { + return len(i.measures) != 0 +} + func (i *int64Inst) aggregate(ctx context.Context, val int64, s attribute.Set) { // nolint:revive // okay to shadow pkg with method. for _, in := range i.measures { in(ctx, val, s) @@ -215,6 +221,7 @@ type float64Inst struct { embedded.Float64UpDownCounter embedded.Float64Histogram embedded.Float64Gauge + x.EnabledInstrument } var ( @@ -234,6 +241,10 @@ func (i *float64Inst) Record(ctx context.Context, val float64, opts ...metric.Re i.aggregate(ctx, val, c.Attributes()) } +func (i *float64Inst) Enabled() bool { + return len(i.measures) != 0 +} + func (i *float64Inst) aggregate(ctx context.Context, val float64, s attribute.Set) { for _, in := range i.measures { in(ctx, val, s) diff --git a/sdk/metric/internal/x/README.md b/sdk/metric/internal/x/README.md index aba69d65471..8bc7841d9a2 100644 --- a/sdk/metric/internal/x/README.md +++ b/sdk/metric/internal/x/README.md @@ -10,6 +10,7 @@ See the [Compatibility and Stability](#compatibility-and-stability) section for - [Cardinality Limit](#cardinality-limit) - [Exemplars](#exemplars) +- [Instrument Enabled](#instrument-enabled) ### Cardinality Limit @@ -102,6 +103,24 @@ Revert to the default exemplar filter (`"trace_based"`) unset OTEL_METRICS_EXEMPLAR_FILTER ``` +### Instrument Enabled + +To help users avoid performing computationally expensive operations when recording measurements, synchronous instruments provide an `Enabled` method. + +#### Examples + +The following code shows an example of how to check if an instrument implements the `EnabledInstrument` interface before using the `Enabled` function to avoid doing an expensive computation: + +```go +type enabledInstrument interface { Enabled() bool } + +ctr, err := m.Int64Counter("expensive-counter") +c, ok := ctr.(enabledInstrument) +if c.Enabled() { + c.Add(expensiveComputation()) +} +``` + ## Compatibility and Stability Experimental features do not fall within the scope of the OpenTelemetry Go versioning and stability [policy](../../../../VERSIONING.md). diff --git a/sdk/metric/internal/x/x.go b/sdk/metric/internal/x/x.go index 08919937068..b62681d5583 100644 --- a/sdk/metric/internal/x/x.go +++ b/sdk/metric/internal/x/x.go @@ -67,3 +67,14 @@ func (f Feature[T]) Enabled() bool { _, ok := f.Lookup() return ok } + +// EnabledInstrument provides the interface for synchronous +// instruments to returned whether or not they are enabled. +type EnabledInstrument interface { + // Enabled returns whether the instrument has any measurements + // associated with it. + // + // This function can be used in places where measuring an instrument + // would result in computationally expensive operations. + Enabled() bool +} diff --git a/sdk/metric/meter_test.go b/sdk/metric/meter_test.go index 189d66de3e0..b2a23c4f286 100644 --- a/sdk/metric/meter_test.go +++ b/sdk/metric/meter_test.go @@ -24,6 +24,7 @@ import ( "go.opentelemetry.io/otel/metric" "go.opentelemetry.io/otel/sdk/instrumentation" "go.opentelemetry.io/otel/sdk/metric/exemplar" + "go.opentelemetry.io/otel/sdk/metric/internal/x" "go.opentelemetry.io/otel/sdk/metric/metricdata" "go.opentelemetry.io/otel/sdk/metric/metricdata/metricdatatest" "go.opentelemetry.io/otel/sdk/resource" @@ -388,6 +389,9 @@ func TestMeterCreatesInstruments(t *testing.T) { ctr, err := m.Int64Counter("sint") assert.NoError(t, err) + c, ok := ctr.(x.EnabledInstrument) + assert.True(t, ok) + assert.True(t, c.Enabled()) ctr.Add(ctx, 3) }, want: metricdata.Metrics{ @@ -407,6 +411,9 @@ func TestMeterCreatesInstruments(t *testing.T) { ctr, err := m.Int64UpDownCounter("sint") assert.NoError(t, err) + c, ok := ctr.(x.EnabledInstrument) + assert.True(t, ok) + assert.True(t, c.Enabled()) ctr.Add(ctx, 11) }, want: metricdata.Metrics{ @@ -452,6 +459,9 @@ func TestMeterCreatesInstruments(t *testing.T) { ctr, err := m.Float64Counter("sfloat") assert.NoError(t, err) + c, ok := ctr.(x.EnabledInstrument) + assert.True(t, ok) + assert.True(t, c.Enabled()) ctr.Add(ctx, 3) }, want: metricdata.Metrics{ @@ -471,6 +481,9 @@ func TestMeterCreatesInstruments(t *testing.T) { ctr, err := m.Float64UpDownCounter("sfloat") assert.NoError(t, err) + c, ok := ctr.(x.EnabledInstrument) + assert.True(t, ok) + assert.True(t, c.Enabled()) ctr.Add(ctx, 11) }, want: metricdata.Metrics{ @@ -532,6 +545,106 @@ func TestMeterCreatesInstruments(t *testing.T) { } } +func TestMeterWithDropView(t *testing.T) { + testCases := []struct { + name string + fn func(*testing.T, metric.Meter) + }{ + { + name: "SyncInt64Count", + fn: func(t *testing.T, m metric.Meter) { + ctr, err := m.Int64Counter("sint") + assert.NoError(t, err) + c, ok := ctr.(x.EnabledInstrument) + assert.True(t, ok) + assert.False(t, c.Enabled()) + }, + }, + { + name: "SyncInt64UpDownCount", + fn: func(t *testing.T, m metric.Meter) { + ctr, err := m.Int64UpDownCounter("sint") + assert.NoError(t, err) + c, ok := ctr.(x.EnabledInstrument) + assert.True(t, ok) + assert.False(t, c.Enabled()) + }, + }, + { + name: "SyncInt64Gauge", + fn: func(t *testing.T, m metric.Meter) { + gauge, err := m.Int64Gauge("sint") + assert.NoError(t, err) + g, ok := gauge.(x.EnabledInstrument) + assert.True(t, ok) + assert.False(t, g.Enabled()) + }, + }, + { + name: "SyncInt64Histogram", + fn: func(t *testing.T, m metric.Meter) { + histo, err := m.Int64Histogram("histogram") + assert.NoError(t, err) + h, ok := histo.(x.EnabledInstrument) + assert.True(t, ok) + assert.False(t, h.Enabled()) + }, + }, + { + name: "SyncFloat64Count", + fn: func(t *testing.T, m metric.Meter) { + ctr, err := m.Float64Counter("sfloat") + assert.NoError(t, err) + c, ok := ctr.(x.EnabledInstrument) + assert.True(t, ok) + assert.False(t, c.Enabled()) + }, + }, + { + name: "SyncFloat64UpDownCount", + fn: func(t *testing.T, m metric.Meter) { + ctr, err := m.Float64UpDownCounter("sfloat") + assert.NoError(t, err) + c, ok := ctr.(x.EnabledInstrument) + assert.True(t, ok) + assert.False(t, c.Enabled()) + }, + }, + { + name: "SyncFloat64Gauge", + fn: func(t *testing.T, m metric.Meter) { + gauge, err := m.Float64Gauge("sfloat") + assert.NoError(t, err) + g, ok := gauge.(x.EnabledInstrument) + assert.True(t, ok) + assert.False(t, g.Enabled()) + }, + }, + { + name: "SyncFloat64Histogram", + fn: func(t *testing.T, m metric.Meter) { + histo, err := m.Float64Histogram("histogram") + assert.NoError(t, err) + h, ok := histo.(x.EnabledInstrument) + assert.True(t, ok) + assert.False(t, h.Enabled()) + }, + }, + } + + for _, tt := range testCases { + t.Run(tt.name, func(t *testing.T) { + rdr := NewManualReader() + dropView := NewView( + Instrument{Name: "*"}, + Stream{Aggregation: AggregationDrop{}}, + ) + m := NewMeterProvider(WithReader(rdr), WithView(dropView)).Meter("testInstruments") + tt.fn(t, m) + }) + } +} + func TestMeterCreatesInstrumentsValidations(t *testing.T) { testCases := []struct { name string From 4280aa472761b144611b0a2614fa51682753f3f0 Mon Sep 17 00:00:00 2001 From: Alex Boten <223565+codeboten@users.noreply.github.com> Date: Wed, 4 Dec 2024 08:12:24 -0800 Subject: [PATCH 2/6] Apply suggestions from code review MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Robert Pająk --- sdk/metric/internal/x/x.go | 8 ++++---- sdk/metric/meter_test.go | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/sdk/metric/internal/x/x.go b/sdk/metric/internal/x/x.go index b62681d5583..cccff0015b1 100644 --- a/sdk/metric/internal/x/x.go +++ b/sdk/metric/internal/x/x.go @@ -68,11 +68,11 @@ func (f Feature[T]) Enabled() bool { return ok } -// EnabledInstrument provides the interface for synchronous -// instruments to returned whether or not they are enabled. +// EnabledInstrument informs whether the instrument is enabled. +// +// EnabledInstrument interface is implemented by synchronous instruments. type EnabledInstrument interface { - // Enabled returns whether the instrument has any measurements - // associated with it. + // Enabled returns whether the instrument will process measurements for the given context. // // This function can be used in places where measuring an instrument // would result in computationally expensive operations. diff --git a/sdk/metric/meter_test.go b/sdk/metric/meter_test.go index b2a23c4f286..7f11833df46 100644 --- a/sdk/metric/meter_test.go +++ b/sdk/metric/meter_test.go @@ -556,7 +556,7 @@ func TestMeterWithDropView(t *testing.T) { ctr, err := m.Int64Counter("sint") assert.NoError(t, err) c, ok := ctr.(x.EnabledInstrument) - assert.True(t, ok) + require.True(t, ok) assert.False(t, c.Enabled()) }, }, From 7661cd6aaf5451502b4d8913a64881bf1fd56f88 Mon Sep 17 00:00:00 2001 From: Alex Boten <223565+codeboten@users.noreply.github.com> Date: Wed, 4 Dec 2024 14:45:23 -0800 Subject: [PATCH 3/6] update test to use require, add context param, validate interface Signed-off-by: Alex Boten <223565+codeboten@users.noreply.github.com> --- sdk/metric/instrument.go | 8 +++---- sdk/metric/internal/x/x.go | 3 ++- sdk/metric/meter_test.go | 46 +++++++++++++++++++------------------- 3 files changed, 29 insertions(+), 28 deletions(-) diff --git a/sdk/metric/instrument.go b/sdk/metric/instrument.go index 680113890d5..c33e1a28cb4 100644 --- a/sdk/metric/instrument.go +++ b/sdk/metric/instrument.go @@ -184,7 +184,6 @@ type int64Inst struct { embedded.Int64UpDownCounter embedded.Int64Histogram embedded.Int64Gauge - x.EnabledInstrument } var ( @@ -192,6 +191,7 @@ var ( _ metric.Int64UpDownCounter = (*int64Inst)(nil) _ metric.Int64Histogram = (*int64Inst)(nil) _ metric.Int64Gauge = (*int64Inst)(nil) + _ x.EnabledInstrument = (*int64Inst)(nil) ) func (i *int64Inst) Add(ctx context.Context, val int64, opts ...metric.AddOption) { @@ -204,7 +204,7 @@ func (i *int64Inst) Record(ctx context.Context, val int64, opts ...metric.Record i.aggregate(ctx, val, c.Attributes()) } -func (i *int64Inst) Enabled() bool { +func (i *int64Inst) Enabled(_ context.Context) bool { return len(i.measures) != 0 } @@ -221,7 +221,6 @@ type float64Inst struct { embedded.Float64UpDownCounter embedded.Float64Histogram embedded.Float64Gauge - x.EnabledInstrument } var ( @@ -229,6 +228,7 @@ var ( _ metric.Float64UpDownCounter = (*float64Inst)(nil) _ metric.Float64Histogram = (*float64Inst)(nil) _ metric.Float64Gauge = (*float64Inst)(nil) + _ x.EnabledInstrument = (*float64Inst)(nil) ) func (i *float64Inst) Add(ctx context.Context, val float64, opts ...metric.AddOption) { @@ -241,7 +241,7 @@ func (i *float64Inst) Record(ctx context.Context, val float64, opts ...metric.Re i.aggregate(ctx, val, c.Attributes()) } -func (i *float64Inst) Enabled() bool { +func (i *float64Inst) Enabled(_ context.Context) bool { return len(i.measures) != 0 } diff --git a/sdk/metric/internal/x/x.go b/sdk/metric/internal/x/x.go index cccff0015b1..a98606238ad 100644 --- a/sdk/metric/internal/x/x.go +++ b/sdk/metric/internal/x/x.go @@ -8,6 +8,7 @@ package x // import "go.opentelemetry.io/otel/sdk/metric/internal/x" import ( + "context" "os" "strconv" ) @@ -76,5 +77,5 @@ type EnabledInstrument interface { // // This function can be used in places where measuring an instrument // would result in computationally expensive operations. - Enabled() bool + Enabled(context.Context) bool } diff --git a/sdk/metric/meter_test.go b/sdk/metric/meter_test.go index 7f11833df46..46d600d10a4 100644 --- a/sdk/metric/meter_test.go +++ b/sdk/metric/meter_test.go @@ -390,8 +390,8 @@ func TestMeterCreatesInstruments(t *testing.T) { assert.NoError(t, err) c, ok := ctr.(x.EnabledInstrument) - assert.True(t, ok) - assert.True(t, c.Enabled()) + require.True(t, ok) + assert.True(t, c.Enabled(context.Background())) ctr.Add(ctx, 3) }, want: metricdata.Metrics{ @@ -412,8 +412,8 @@ func TestMeterCreatesInstruments(t *testing.T) { assert.NoError(t, err) c, ok := ctr.(x.EnabledInstrument) - assert.True(t, ok) - assert.True(t, c.Enabled()) + require.True(t, ok) + assert.True(t, c.Enabled(context.Background())) ctr.Add(ctx, 11) }, want: metricdata.Metrics{ @@ -460,8 +460,8 @@ func TestMeterCreatesInstruments(t *testing.T) { assert.NoError(t, err) c, ok := ctr.(x.EnabledInstrument) - assert.True(t, ok) - assert.True(t, c.Enabled()) + require.True(t, ok) + assert.True(t, c.Enabled(context.Background())) ctr.Add(ctx, 3) }, want: metricdata.Metrics{ @@ -482,8 +482,8 @@ func TestMeterCreatesInstruments(t *testing.T) { assert.NoError(t, err) c, ok := ctr.(x.EnabledInstrument) - assert.True(t, ok) - assert.True(t, c.Enabled()) + require.True(t, ok) + assert.True(t, c.Enabled(context.Background())) ctr.Add(ctx, 11) }, want: metricdata.Metrics{ @@ -557,7 +557,7 @@ func TestMeterWithDropView(t *testing.T) { assert.NoError(t, err) c, ok := ctr.(x.EnabledInstrument) require.True(t, ok) - assert.False(t, c.Enabled()) + assert.False(t, c.Enabled(context.Background())) }, }, { @@ -566,8 +566,8 @@ func TestMeterWithDropView(t *testing.T) { ctr, err := m.Int64UpDownCounter("sint") assert.NoError(t, err) c, ok := ctr.(x.EnabledInstrument) - assert.True(t, ok) - assert.False(t, c.Enabled()) + require.True(t, ok) + assert.False(t, c.Enabled(context.Background())) }, }, { @@ -576,8 +576,8 @@ func TestMeterWithDropView(t *testing.T) { gauge, err := m.Int64Gauge("sint") assert.NoError(t, err) g, ok := gauge.(x.EnabledInstrument) - assert.True(t, ok) - assert.False(t, g.Enabled()) + require.True(t, ok) + assert.False(t, g.Enabled(context.Background())) }, }, { @@ -586,8 +586,8 @@ func TestMeterWithDropView(t *testing.T) { histo, err := m.Int64Histogram("histogram") assert.NoError(t, err) h, ok := histo.(x.EnabledInstrument) - assert.True(t, ok) - assert.False(t, h.Enabled()) + require.True(t, ok) + assert.False(t, h.Enabled(context.Background())) }, }, { @@ -596,8 +596,8 @@ func TestMeterWithDropView(t *testing.T) { ctr, err := m.Float64Counter("sfloat") assert.NoError(t, err) c, ok := ctr.(x.EnabledInstrument) - assert.True(t, ok) - assert.False(t, c.Enabled()) + require.True(t, ok) + assert.False(t, c.Enabled(context.Background())) }, }, { @@ -606,8 +606,8 @@ func TestMeterWithDropView(t *testing.T) { ctr, err := m.Float64UpDownCounter("sfloat") assert.NoError(t, err) c, ok := ctr.(x.EnabledInstrument) - assert.True(t, ok) - assert.False(t, c.Enabled()) + require.True(t, ok) + assert.False(t, c.Enabled(context.Background())) }, }, { @@ -616,8 +616,8 @@ func TestMeterWithDropView(t *testing.T) { gauge, err := m.Float64Gauge("sfloat") assert.NoError(t, err) g, ok := gauge.(x.EnabledInstrument) - assert.True(t, ok) - assert.False(t, g.Enabled()) + require.True(t, ok) + assert.False(t, g.Enabled(context.Background())) }, }, { @@ -626,8 +626,8 @@ func TestMeterWithDropView(t *testing.T) { histo, err := m.Float64Histogram("histogram") assert.NoError(t, err) h, ok := histo.(x.EnabledInstrument) - assert.True(t, ok) - assert.False(t, h.Enabled()) + require.True(t, ok) + assert.False(t, h.Enabled(context.Background())) }, }, } From b4eb4353438398d1065d67cdeb1b7c262d9bb1fe Mon Sep 17 00:00:00 2001 From: Alex Boten <223565+codeboten@users.noreply.github.com> Date: Wed, 4 Dec 2024 14:47:05 -0800 Subject: [PATCH 4/6] update readme Signed-off-by: Alex Boten <223565+codeboten@users.noreply.github.com> --- sdk/metric/internal/x/README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/sdk/metric/internal/x/README.md b/sdk/metric/internal/x/README.md index 8bc7841d9a2..59f736b733f 100644 --- a/sdk/metric/internal/x/README.md +++ b/sdk/metric/internal/x/README.md @@ -112,11 +112,11 @@ To help users avoid performing computationally expensive operations when recordi The following code shows an example of how to check if an instrument implements the `EnabledInstrument` interface before using the `Enabled` function to avoid doing an expensive computation: ```go -type enabledInstrument interface { Enabled() bool } +type enabledInstrument interface { Enabled(context.Context) bool } ctr, err := m.Int64Counter("expensive-counter") c, ok := ctr.(enabledInstrument) -if c.Enabled() { +if !ok || c.Enabled(context.Background()) { c.Add(expensiveComputation()) } ``` From 28eabb3eb08597814b362395fdea30d76da7b602 Mon Sep 17 00:00:00 2001 From: Alex Boten <223565+codeboten@users.noreply.github.com> Date: Wed, 4 Dec 2024 14:49:46 -0800 Subject: [PATCH 5/6] Update CHANGELOG.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Robert Pająk --- CHANGELOG.md | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 9140f8558c3..14ca27bd9bc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,8 +11,10 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm ### Added - Add `Reset` method to `SpanRecorder` in `go.opentelemetry.io/otel/sdk/trace/tracetest`. (#5994) -- Experimental `EnabledInstrument` interface added to the metric SDK. - See [metric documentation](./sdk/metric/internal/x/README.md#instrument-enabled) for more information about this feature and how to use it. (#) +- Add `EnabledInstrument` interface in `go.opentelemetry.io/otel/sdk/metric/internal/x`. + This is an experimental interface that is implemented by synchronous instruments provided by `go.opentelemetry.io/otel/sdk/metric`. + Users can use it to avoid performing computationally expensive operations when recording measurements. + It does not fall within the scope of the OpenTelemetry Go versioning and stability [policy](./VERSIONING.md) and it may be changed in backwards incompatible ways or removed in feature releases. (#6016) ### Changed From 554ab272ffea74461ec13b313fada309c2b41057 Mon Sep 17 00:00:00 2001 From: Alex Boten <223565+codeboten@users.noreply.github.com> Date: Thu, 5 Dec 2024 13:11:51 -0800 Subject: [PATCH 6/6] apply feedback refactor Signed-off-by: Alex Boten <223565+codeboten@users.noreply.github.com> --- sdk/metric/meter_test.go | 100 ++++++++++++++------------------------- 1 file changed, 36 insertions(+), 64 deletions(-) diff --git a/sdk/metric/meter_test.go b/sdk/metric/meter_test.go index 9e598b9d956..10f473a4ca6 100644 --- a/sdk/metric/meter_test.go +++ b/sdk/metric/meter_test.go @@ -546,101 +546,73 @@ func TestMeterCreatesInstruments(t *testing.T) { } func TestMeterWithDropView(t *testing.T) { + dropView := NewView( + Instrument{Name: "*"}, + Stream{Aggregation: AggregationDrop{}}, + ) + m := NewMeterProvider(WithView(dropView)).Meter(t.Name()) + testCases := []struct { name string - fn func(*testing.T, metric.Meter) + fn func(*testing.T) (any, error) }{ { - name: "SyncInt64Count", - fn: func(t *testing.T, m metric.Meter) { - ctr, err := m.Int64Counter("sint") - assert.NoError(t, err) - c, ok := ctr.(x.EnabledInstrument) - require.True(t, ok) - assert.False(t, c.Enabled(context.Background())) + name: "Int64Counter", + fn: func(*testing.T) (any, error) { + return m.Int64Counter("sint") }, }, { - name: "SyncInt64UpDownCount", - fn: func(t *testing.T, m metric.Meter) { - ctr, err := m.Int64UpDownCounter("sint") - assert.NoError(t, err) - c, ok := ctr.(x.EnabledInstrument) - require.True(t, ok) - assert.False(t, c.Enabled(context.Background())) + name: "Int64UpDownCounter", + fn: func(*testing.T) (any, error) { + return m.Int64UpDownCounter("sint") }, }, { - name: "SyncInt64Gauge", - fn: func(t *testing.T, m metric.Meter) { - gauge, err := m.Int64Gauge("sint") - assert.NoError(t, err) - g, ok := gauge.(x.EnabledInstrument) - require.True(t, ok) - assert.False(t, g.Enabled(context.Background())) + name: "Int64Gauge", + fn: func(*testing.T) (any, error) { + return m.Int64Gauge("sint") }, }, { - name: "SyncInt64Histogram", - fn: func(t *testing.T, m metric.Meter) { - histo, err := m.Int64Histogram("histogram") - assert.NoError(t, err) - h, ok := histo.(x.EnabledInstrument) - require.True(t, ok) - assert.False(t, h.Enabled(context.Background())) + name: "Int64Histogram", + fn: func(*testing.T) (any, error) { + return m.Int64Histogram("histogram") }, }, { - name: "SyncFloat64Count", - fn: func(t *testing.T, m metric.Meter) { - ctr, err := m.Float64Counter("sfloat") - assert.NoError(t, err) - c, ok := ctr.(x.EnabledInstrument) - require.True(t, ok) - assert.False(t, c.Enabled(context.Background())) + name: "Float64Counter", + fn: func(*testing.T) (any, error) { + return m.Float64Counter("sfloat") }, }, { - name: "SyncFloat64UpDownCount", - fn: func(t *testing.T, m metric.Meter) { - ctr, err := m.Float64UpDownCounter("sfloat") - assert.NoError(t, err) - c, ok := ctr.(x.EnabledInstrument) - require.True(t, ok) - assert.False(t, c.Enabled(context.Background())) + name: "Float64UpDownCounter", + fn: func(*testing.T) (any, error) { + return m.Float64UpDownCounter("sfloat") }, }, { - name: "SyncFloat64Gauge", - fn: func(t *testing.T, m metric.Meter) { - gauge, err := m.Float64Gauge("sfloat") - assert.NoError(t, err) - g, ok := gauge.(x.EnabledInstrument) - require.True(t, ok) - assert.False(t, g.Enabled(context.Background())) + name: "Float64Gauge", + fn: func(*testing.T) (any, error) { + return m.Float64Gauge("sfloat") }, }, { - name: "SyncFloat64Histogram", - fn: func(t *testing.T, m metric.Meter) { - histo, err := m.Float64Histogram("histogram") - assert.NoError(t, err) - h, ok := histo.(x.EnabledInstrument) - require.True(t, ok) - assert.False(t, h.Enabled(context.Background())) + name: "Float64Histogram", + fn: func(*testing.T) (any, error) { + return m.Float64Histogram("histogram") }, }, } for _, tt := range testCases { t.Run(tt.name, func(t *testing.T) { - rdr := NewManualReader() - dropView := NewView( - Instrument{Name: "*"}, - Stream{Aggregation: AggregationDrop{}}, - ) - m := NewMeterProvider(WithReader(rdr), WithView(dropView)).Meter("testInstruments") - tt.fn(t, m) + got, err := tt.fn(t) + require.NoError(t, err) + c, ok := got.(x.EnabledInstrument) + require.True(t, ok) + assert.False(t, c.Enabled(context.Background())) }) } }