From b6ed797292c9178711d0ceb2896aa11556c5140e Mon Sep 17 00:00:00 2001 From: Bogdan Drutu Date: Tue, 3 Sep 2024 11:34:15 -0700 Subject: [PATCH] Add Instrument.IsEnabled per specs Signed-off-by: Bogdan Drutu --- internal/global/instruments.go | 56 +++++++++++ internal/global/instruments_test.go | 8 ++ metric/instrument.go | 6 ++ metric/noop/noop.go | 40 ++++++++ metric/syncfloat64.go | 28 ++++++ metric/syncint64.go | 28 ++++++ sdk/metric/instrument.go | 8 ++ sdk/metric/meter_test.go | 138 +++++++++++++++++++++++++++- 8 files changed, 308 insertions(+), 4 deletions(-) diff --git a/internal/global/instruments.go b/internal/global/instruments.go index 3a0cc42f6a4..50c4a9fbfdd 100644 --- a/internal/global/instruments.go +++ b/internal/global/instruments.go @@ -229,6 +229,13 @@ func (i *sfCounter) Add(ctx context.Context, incr float64, opts ...metric.AddOpt } } +func (i *sfCounter) IsEnabled(ctx context.Context, opts ...metric.EnabledOption) bool { + if ctr := i.delegate.Load(); ctr != nil { + ctr.(metric.Float64Counter).IsEnabled(ctx, opts...) + } + return false +} + type sfUpDownCounter struct { embedded.Float64UpDownCounter @@ -255,6 +262,13 @@ func (i *sfUpDownCounter) Add(ctx context.Context, incr float64, opts ...metric. } } +func (i *sfUpDownCounter) IsEnabled(ctx context.Context, opts ...metric.EnabledOption) bool { + if ctr := i.delegate.Load(); ctr != nil { + ctr.(metric.Float64UpDownCounter).IsEnabled(ctx, opts...) + } + return false +} + type sfHistogram struct { embedded.Float64Histogram @@ -281,6 +295,13 @@ func (i *sfHistogram) Record(ctx context.Context, x float64, opts ...metric.Reco } } +func (i *sfHistogram) IsEnabled(ctx context.Context, opts ...metric.EnabledOption) bool { + if ctr := i.delegate.Load(); ctr != nil { + ctr.(metric.Float64Histogram).IsEnabled(ctx, opts...) + } + return false +} + type sfGauge struct { embedded.Float64Gauge @@ -307,6 +328,13 @@ func (i *sfGauge) Record(ctx context.Context, x float64, opts ...metric.RecordOp } } +func (i *sfGauge) IsEnabled(ctx context.Context, opts ...metric.EnabledOption) bool { + if ctr := i.delegate.Load(); ctr != nil { + ctr.(metric.Float64Gauge).IsEnabled(ctx, opts...) + } + return false +} + type siCounter struct { embedded.Int64Counter @@ -333,6 +361,13 @@ func (i *siCounter) Add(ctx context.Context, x int64, opts ...metric.AddOption) } } +func (i *siCounter) IsEnabled(ctx context.Context, opts ...metric.EnabledOption) bool { + if ctr := i.delegate.Load(); ctr != nil { + ctr.(metric.Int64Counter).IsEnabled(ctx, opts...) + } + return false +} + type siUpDownCounter struct { embedded.Int64UpDownCounter @@ -359,6 +394,13 @@ func (i *siUpDownCounter) Add(ctx context.Context, x int64, opts ...metric.AddOp } } +func (i *siUpDownCounter) IsEnabled(ctx context.Context, opts ...metric.EnabledOption) bool { + if ctr := i.delegate.Load(); ctr != nil { + ctr.(metric.Int64UpDownCounter).IsEnabled(ctx, opts...) + } + return false +} + type siHistogram struct { embedded.Int64Histogram @@ -385,6 +427,13 @@ func (i *siHistogram) Record(ctx context.Context, x int64, opts ...metric.Record } } +func (i *siHistogram) IsEnabled(ctx context.Context, opts ...metric.EnabledOption) bool { + if ctr := i.delegate.Load(); ctr != nil { + ctr.(metric.Int64Histogram).IsEnabled(ctx, opts...) + } + return false +} + type siGauge struct { embedded.Int64Gauge @@ -410,3 +459,10 @@ func (i *siGauge) Record(ctx context.Context, x int64, opts ...metric.RecordOpti ctr.(metric.Int64Gauge).Record(ctx, x, opts...) } } + +func (i *siGauge) IsEnabled(ctx context.Context, opts ...metric.EnabledOption) bool { + if ctr := i.delegate.Load(); ctr != nil { + ctr.(metric.Int64Gauge).IsEnabled(ctx, opts...) + } + return false +} diff --git a/internal/global/instruments_test.go b/internal/global/instruments_test.go index 48c772e3b8a..c988c5cf7c1 100644 --- a/internal/global/instruments_test.go +++ b/internal/global/instruments_test.go @@ -179,6 +179,10 @@ func (i *testCountingFloatInstrument) Record(context.Context, float64, ...metric i.count++ } +func (i *testCountingFloatInstrument) IsEnabled(context.Context, ...metric.EnabledOption) bool { + return true +} + type testCountingIntInstrument struct { count int @@ -203,3 +207,7 @@ func (i *testCountingIntInstrument) Add(context.Context, int64, ...metric.AddOpt func (i *testCountingIntInstrument) Record(context.Context, int64, ...metric.RecordOption) { i.count++ } + +func (i *testCountingIntInstrument) IsEnabled(context.Context, ...metric.EnabledOption) bool { + return true +} diff --git a/metric/instrument.go b/metric/instrument.go index ea52e402331..13aa911aadf 100644 --- a/metric/instrument.go +++ b/metric/instrument.go @@ -366,3 +366,9 @@ func WithAttributes(attributes ...attribute.KeyValue) MeasurementOption { copy(cp, attributes) return attrOpt{set: attribute.NewSet(cp...)} } + +// EnabledOption applies options to IsEnabled func. +type EnabledOption interface { + // Extend this to support EnabledOptionConfig when needed. + applyEnabledOption() +} diff --git a/metric/noop/noop.go b/metric/noop/noop.go index ca6fcbdc099..c9265a0dd4f 100644 --- a/metric/noop/noop.go +++ b/metric/noop/noop.go @@ -176,6 +176,11 @@ type Int64Counter struct{ embedded.Int64Counter } // Add performs no operation. func (Int64Counter) Add(context.Context, int64, ...metric.AddOption) {} +// IsEnabled returns false always. +func (Int64Counter) IsEnabled(ctx context.Context, opts ...metric.EnabledOption) bool { + return false +} + // Float64Counter is an OpenTelemetry Counter used to record float64 // measurements. It produces no telemetry. type Float64Counter struct{ embedded.Float64Counter } @@ -183,6 +188,11 @@ type Float64Counter struct{ embedded.Float64Counter } // Add performs no operation. func (Float64Counter) Add(context.Context, float64, ...metric.AddOption) {} +// IsEnabled returns false always. +func (Float64Counter) IsEnabled(ctx context.Context, opts ...metric.EnabledOption) bool { + return false +} + // Int64UpDownCounter is an OpenTelemetry UpDownCounter used to record int64 // measurements. It produces no telemetry. type Int64UpDownCounter struct{ embedded.Int64UpDownCounter } @@ -190,6 +200,11 @@ type Int64UpDownCounter struct{ embedded.Int64UpDownCounter } // Add performs no operation. func (Int64UpDownCounter) Add(context.Context, int64, ...metric.AddOption) {} +// IsEnabled returns false always. +func (Int64UpDownCounter) IsEnabled(ctx context.Context, opts ...metric.EnabledOption) bool { + return false +} + // Float64UpDownCounter is an OpenTelemetry UpDownCounter used to record // float64 measurements. It produces no telemetry. type Float64UpDownCounter struct{ embedded.Float64UpDownCounter } @@ -197,6 +212,11 @@ type Float64UpDownCounter struct{ embedded.Float64UpDownCounter } // Add performs no operation. func (Float64UpDownCounter) Add(context.Context, float64, ...metric.AddOption) {} +// IsEnabled returns false always. +func (Float64UpDownCounter) IsEnabled(ctx context.Context, opts ...metric.EnabledOption) bool { + return false +} + // Int64Histogram is an OpenTelemetry Histogram used to record int64 // measurements. It produces no telemetry. type Int64Histogram struct{ embedded.Int64Histogram } @@ -204,6 +224,11 @@ type Int64Histogram struct{ embedded.Int64Histogram } // Record performs no operation. func (Int64Histogram) Record(context.Context, int64, ...metric.RecordOption) {} +// IsEnabled returns false always. +func (Int64Histogram) IsEnabled(ctx context.Context, opts ...metric.EnabledOption) bool { + return false +} + // Float64Histogram is an OpenTelemetry Histogram used to record float64 // measurements. It produces no telemetry. type Float64Histogram struct{ embedded.Float64Histogram } @@ -211,6 +236,11 @@ type Float64Histogram struct{ embedded.Float64Histogram } // Record performs no operation. func (Float64Histogram) Record(context.Context, float64, ...metric.RecordOption) {} +// IsEnabled returns false always. +func (Float64Histogram) IsEnabled(ctx context.Context, opts ...metric.EnabledOption) bool { + return false +} + // Int64Gauge is an OpenTelemetry Gauge used to record instantaneous int64 // measurements. It produces no telemetry. type Int64Gauge struct{ embedded.Int64Gauge } @@ -218,6 +248,11 @@ type Int64Gauge struct{ embedded.Int64Gauge } // Record performs no operation. func (Int64Gauge) Record(context.Context, int64, ...metric.RecordOption) {} +// IsEnabled returns false always. +func (Int64Gauge) IsEnabled(ctx context.Context, opts ...metric.EnabledOption) bool { + return false +} + // Float64Gauge is an OpenTelemetry Gauge used to record instantaneous float64 // measurements. It produces no telemetry. type Float64Gauge struct{ embedded.Float64Gauge } @@ -225,6 +260,11 @@ type Float64Gauge struct{ embedded.Float64Gauge } // Record performs no operation. func (Float64Gauge) Record(context.Context, float64, ...metric.RecordOption) {} +// IsEnabled returns false always. +func (Float64Gauge) IsEnabled(ctx context.Context, opts ...metric.EnabledOption) bool { + return false +} + // Int64ObservableCounter is an OpenTelemetry ObservableCounter used to record // int64 measurements. It produces no telemetry. type Int64ObservableCounter struct { diff --git a/metric/syncfloat64.go b/metric/syncfloat64.go index 8403a4bad2d..809807f8bc5 100644 --- a/metric/syncfloat64.go +++ b/metric/syncfloat64.go @@ -25,6 +25,13 @@ type Float64Counter interface { // Use the WithAttributeSet (or, if performance is not a concern, // the WithAttributes) option to include measurement attributes. Add(ctx context.Context, incr float64, options ...AddOption) + + // IsEnabled returns true if this instrument is enabled. + // + // This helps users avoid performing computationally expensive operations when + // recording measurements. The returned value cannot be cached since it + // may change over time. + IsEnabled(ctx context.Context, options ...EnabledOption) bool } // Float64CounterConfig contains options for synchronous counter instruments that @@ -78,6 +85,13 @@ type Float64UpDownCounter interface { // Use the WithAttributeSet (or, if performance is not a concern, // the WithAttributes) option to include measurement attributes. Add(ctx context.Context, incr float64, options ...AddOption) + + // IsEnabled returns true if this instrument is enabled. + // + // This helps users avoid performing computationally expensive operations when + // recording measurements. The returned value cannot be cached since it + // may change over time. + IsEnabled(ctx context.Context, options ...EnabledOption) bool } // Float64UpDownCounterConfig contains options for synchronous counter @@ -131,6 +145,13 @@ type Float64Histogram interface { // Use the WithAttributeSet (or, if performance is not a concern, // the WithAttributes) option to include measurement attributes. Record(ctx context.Context, incr float64, options ...RecordOption) + + // IsEnabled returns true if this instrument is enabled. + // + // This helps users avoid performing computationally expensive operations when + // recording measurements. The returned value cannot be cached since it + // may change over time. + IsEnabled(ctx context.Context, options ...EnabledOption) bool } // Float64HistogramConfig contains options for synchronous histogram @@ -189,6 +210,13 @@ type Float64Gauge interface { // Use the WithAttributeSet (or, if performance is not a concern, // the WithAttributes) option to include measurement attributes. Record(ctx context.Context, value float64, options ...RecordOption) + + // IsEnabled returns true if this instrument is enabled. + // + // This helps users avoid performing computationally expensive operations when + // recording measurements. The returned value cannot be cached since it + // may change over time. + IsEnabled(ctx context.Context, options ...EnabledOption) bool } // Float64GaugeConfig contains options for synchronous gauge instruments that diff --git a/metric/syncint64.go b/metric/syncint64.go index 783fdfba773..2700a9de982 100644 --- a/metric/syncint64.go +++ b/metric/syncint64.go @@ -25,6 +25,13 @@ type Int64Counter interface { // Use the WithAttributeSet (or, if performance is not a concern, // the WithAttributes) option to include measurement attributes. Add(ctx context.Context, incr int64, options ...AddOption) + + // IsEnabled returns true if this instrument is enabled. + // + // This helps users avoid performing computationally expensive operations when + // recording measurements. The returned value cannot be cached since it + // may change over time. + IsEnabled(ctx context.Context, options ...EnabledOption) bool } // Int64CounterConfig contains options for synchronous counter instruments that @@ -78,6 +85,13 @@ type Int64UpDownCounter interface { // Use the WithAttributeSet (or, if performance is not a concern, // the WithAttributes) option to include measurement attributes. Add(ctx context.Context, incr int64, options ...AddOption) + + // IsEnabled returns true if this instrument is enabled. + // + // This helps users avoid performing computationally expensive operations when + // recording measurements. The returned value cannot be cached since it + // may change over time. + IsEnabled(ctx context.Context, options ...EnabledOption) bool } // Int64UpDownCounterConfig contains options for synchronous counter @@ -131,6 +145,13 @@ type Int64Histogram interface { // Use the WithAttributeSet (or, if performance is not a concern, // the WithAttributes) option to include measurement attributes. Record(ctx context.Context, incr int64, options ...RecordOption) + + // IsEnabled returns true if this instrument is enabled. + // + // This helps users avoid performing computationally expensive operations when + // recording measurements. The returned value cannot be cached since it + // may change over time. + IsEnabled(ctx context.Context, options ...EnabledOption) bool } // Int64HistogramConfig contains options for synchronous histogram instruments @@ -189,6 +210,13 @@ type Int64Gauge interface { // Use the WithAttributeSet (or, if performance is not a concern, // the WithAttributes) option to include measurement attributes. Record(ctx context.Context, value int64, options ...RecordOption) + + // IsEnabled returns true if this instrument is enabled. + // + // This helps users avoid performing computationally expensive operations when + // recording measurements. The returned value cannot be cached since it + // may change over time. + IsEnabled(ctx context.Context, options ...EnabledOption) bool } // Int64GaugeConfig contains options for synchronous gauge instruments that diff --git a/sdk/metric/instrument.go b/sdk/metric/instrument.go index b52a330b3bc..8dadd63c706 100644 --- a/sdk/metric/instrument.go +++ b/sdk/metric/instrument.go @@ -196,6 +196,10 @@ func (i *int64Inst) Record(ctx context.Context, val int64, opts ...metric.Record i.aggregate(ctx, val, c.Attributes()) } +func (i *int64Inst) IsEnabled(context.Context, ...metric.EnabledOption) 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) @@ -228,6 +232,10 @@ func (i *float64Inst) Record(ctx context.Context, val float64, opts ...metric.Re i.aggregate(ctx, val, c.Attributes()) } +func (i *float64Inst) IsEnabled(context.Context, ...metric.EnabledOption) 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/meter_test.go b/sdk/metric/meter_test.go index da614e62428..9f40acd079a 100644 --- a/sdk/metric/meter_test.go +++ b/sdk/metric/meter_test.go @@ -387,6 +387,7 @@ func TestMeterCreatesInstruments(t *testing.T) { ctr, err := m.Int64Counter("sint") assert.NoError(t, err) + assert.True(t, ctr.IsEnabled(ctx)) ctr.Add(ctx, 3) }, want: metricdata.Metrics{ @@ -406,6 +407,7 @@ func TestMeterCreatesInstruments(t *testing.T) { ctr, err := m.Int64UpDownCounter("sint") assert.NoError(t, err) + assert.True(t, ctr.IsEnabled(ctx)) ctr.Add(ctx, 11) }, want: metricdata.Metrics{ @@ -419,13 +421,32 @@ func TestMeterCreatesInstruments(t *testing.T) { }, }, }, + { + name: "SyncInt64Gauge", + fn: func(t *testing.T, m metric.Meter) { + gauge, err := m.Int64Gauge("sint") + assert.NoError(t, err) + + assert.True(t, gauge.IsEnabled(ctx)) + gauge.Record(ctx, 11) + }, + want: metricdata.Metrics{ + Name: "sint", + Data: metricdata.Gauge[int64]{ + DataPoints: []metricdata.DataPoint[int64]{ + {Value: 11}, + }, + }, + }, + }, { name: "SyncInt64Histogram", fn: func(t *testing.T, m metric.Meter) { - gauge, err := m.Int64Histogram("histogram") + histo, err := m.Int64Histogram("histogram") assert.NoError(t, err) - gauge.Record(ctx, 7) + assert.True(t, histo.IsEnabled(ctx)) + histo.Record(ctx, 7) }, want: metricdata.Metrics{ Name: "histogram", @@ -451,6 +472,7 @@ func TestMeterCreatesInstruments(t *testing.T) { ctr, err := m.Float64Counter("sfloat") assert.NoError(t, err) + assert.True(t, ctr.IsEnabled(ctx)) ctr.Add(ctx, 3) }, want: metricdata.Metrics{ @@ -470,6 +492,7 @@ func TestMeterCreatesInstruments(t *testing.T) { ctr, err := m.Float64UpDownCounter("sfloat") assert.NoError(t, err) + assert.True(t, ctr.IsEnabled(ctx)) ctr.Add(ctx, 11) }, want: metricdata.Metrics{ @@ -483,13 +506,32 @@ func TestMeterCreatesInstruments(t *testing.T) { }, }, }, + { + name: "SyncFloat64Gauge", + fn: func(t *testing.T, m metric.Meter) { + gauge, err := m.Float64Gauge("sfloat") + assert.NoError(t, err) + + assert.True(t, gauge.IsEnabled(ctx)) + gauge.Record(ctx, 11) + }, + want: metricdata.Metrics{ + Name: "sfloat", + Data: metricdata.Gauge[float64]{ + DataPoints: []metricdata.DataPoint[float64]{ + {Value: 11}, + }, + }, + }, + }, { name: "SyncFloat64Histogram", fn: func(t *testing.T, m metric.Meter) { - gauge, err := m.Float64Histogram("histogram") + histo, err := m.Float64Histogram("histogram") assert.NoError(t, err) - gauge.Record(ctx, 7) + assert.True(t, histo.IsEnabled(ctx)) + histo.Record(ctx, 7) }, want: metricdata.Metrics{ Name: "histogram", @@ -531,6 +573,94 @@ func TestMeterCreatesInstruments(t *testing.T) { } } +func TestMeterWithDropView(t *testing.T) { + // The synchronous measurement methods must ignore the context cancellation. + ctx, cancel := context.WithCancel(context.Background()) + cancel() + + 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) + assert.False(t, ctr.IsEnabled(ctx)) + }, + }, + { + name: "SyncInt64UpDownCount", + fn: func(t *testing.T, m metric.Meter) { + ctr, err := m.Int64UpDownCounter("sint") + assert.NoError(t, err) + assert.False(t, ctr.IsEnabled(ctx)) + }, + }, + { + name: "SyncInt64Gauge", + fn: func(t *testing.T, m metric.Meter) { + gauge, err := m.Int64Gauge("sint") + assert.NoError(t, err) + assert.False(t, gauge.IsEnabled(ctx)) + }, + }, + { + name: "SyncInt64Histogram", + fn: func(t *testing.T, m metric.Meter) { + histo, err := m.Int64Histogram("histogram") + assert.NoError(t, err) + assert.False(t, histo.IsEnabled(ctx)) + }, + }, + { + name: "SyncFloat64Count", + fn: func(t *testing.T, m metric.Meter) { + ctr, err := m.Float64Counter("sfloat") + assert.NoError(t, err) + assert.False(t, ctr.IsEnabled(ctx)) + }, + }, + { + name: "SyncFloat64UpDownCount", + fn: func(t *testing.T, m metric.Meter) { + ctr, err := m.Float64UpDownCounter("sfloat") + assert.NoError(t, err) + assert.False(t, ctr.IsEnabled(ctx)) + }, + }, + { + name: "SyncFloat64Gauge", + fn: func(t *testing.T, m metric.Meter) { + gauge, err := m.Float64Gauge("sfloat") + assert.NoError(t, err) + assert.False(t, gauge.IsEnabled(ctx)) + }, + }, + { + name: "SyncFloat64Histogram", + fn: func(t *testing.T, m metric.Meter) { + histo, err := m.Float64Histogram("histogram") + assert.NoError(t, err) + assert.False(t, histo.IsEnabled(ctx)) + }, + }, + } + + 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