diff --git a/CHANGELOG.md b/CHANGELOG.md index 489ec0d1a21..14aa21f0826 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -46,6 +46,23 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm - Rename `go.opentelemetry.io/otel/api/metric.ConfigureInstrument` to `NewInstrumentConfig` and `go.opentelemetry.io/otel/api/metric.ConfigureMeter` to `NewMeterConfig`. - Move the `go.opentelemetry.io/otel/api/unit` package to `go.opentelemetry.io/otel/unit`. (#1185) +- Rename `Provider` to `MeterProvider` in the `go.opentelemetry.io/otel/api/metric` package. (#1190) +- Rename `NoopProvider` to `NoopMeterProvider` in the `go.opentelemetry.io/otel/api/metric` package. (#1190) +- Rename `NewProvider` to `NewMeterProvider` in the `go.opentelemetry.io/otel/api/metric/metrictest` package. (#1190) +- Rename `Provider` to `MeterProvider` in the `go.opentelemetry.io/otel/api/metric/registry` package. (#1190) +- Rename `NewProvider` to `NewMeterProvider` in the `go.opentelemetry.io/otel/api/metri/registryc` package. (#1190) +- Rename `Provider` to `TracerProvider` in the `go.opentelemetry.io/otel/api/trace` package. (#1190) +- Rename `NoopProvider` to `NoopTracerProvider` in the `go.opentelemetry.io/otel/api/trace` package. (#1190) +- Rename `Provider` to `TracerProvider` in the `go.opentelemetry.io/otel/api/trace/tracetest` package. (#1190) +- Rename `NewProvider` to `NewTracerProvider` in the `go.opentelemetry.io/otel/api/trace/tracetest` package. (#1190) +- Rename `WrapperProvider` to `WrapperTracerProvider` in the `go.opentelemetry.io/otel/bridge/opentracing` package. (#1190) +- Rename `NewWrapperProvider` to `NewWrapperTracerProvider` in the `go.opentelemetry.io/otel/bridge/opentracing` package. (#1190) +- Rename `Provider` method of the pull controller to `MeterProvider` in the `go.opentelemetry.io/otel/sdk/metric/controller/pull` package. (#1190) +- Rename `Provider` method of the push controller to `MeterProvider` in the `go.opentelemetry.io/otel/sdk/metric/controller/push` package. (#1190) +- Rename `ProviderOptions` to `TracerProviderConfig` in the `go.opentelemetry.io/otel/sdk/trace` package. (#1190) +- Rename `ProviderOption` to `TracerProviderOption` in the `go.opentelemetry.io/otel/sdk/trace` package. (#1190) +- Rename `Provider` to `TracerProvider` in the `go.opentelemetry.io/otel/sdk/trace` package. (#1190) +- Rename `NewProvider` to `NewTracerProvider` in the `go.opentelemetry.io/otel/sdk/trace` package. (#1190) - Renamed `SamplingDecision` values to comply with OpenTelemetry specification change. (#1192) ### Removed diff --git a/api/global/internal/meter.go b/api/global/internal/meter.go index 3c7764f7268..b45f4c94490 100644 --- a/api/global/internal/meter.go +++ b/api/global/internal/meter.go @@ -25,19 +25,19 @@ import ( "go.opentelemetry.io/otel/label" ) -// This file contains the forwarding implementation of metric.Provider -// used as the default global instance. Metric events using instruments -// provided by this implementation are no-ops until the first Meter -// implementation is set as the global provider. +// This file contains the forwarding implementation of MeterProvider used as +// the default global instance. Metric events using instruments provided by +// this implementation are no-ops until the first Meter implementation is set +// as the global provider. // -// The implementation here uses Mutexes to maintain a list of active -// Meters in the Provider and Instruments in each Meter, under the -// assumption that these interfaces are not performance-critical. +// The implementation here uses Mutexes to maintain a list of active Meters in +// the MeterProvider and Instruments in each Meter, under the assumption that +// these interfaces are not performance-critical. // -// We have the invariant that setDelegate() will be called before a -// new metric.Provider implementation is registered as the global -// provider. Mutexes in the Provider and Meters ensure that each -// instrument has a delegate before the global provider is set. +// We have the invariant that setDelegate() will be called before a new +// MeterProvider implementation is registered as the global provider. Mutexes +// in the MeterProvider and Meters ensure that each instrument has a delegate +// before the global provider is set. // // Bound instrument operations are implemented by delegating to the // instrument after it is registered, with a sync.Once initializer to @@ -51,7 +51,7 @@ type meterKey struct { } type meterProvider struct { - delegate metric.Provider + delegate metric.MeterProvider // lock protects `delegate` and `meters`. lock sync.Mutex @@ -113,7 +113,7 @@ type syncHandle struct { initialize sync.Once } -var _ metric.Provider = &meterProvider{} +var _ metric.MeterProvider = &meterProvider{} var _ metric.MeterImpl = &meterImpl{} var _ metric.InstrumentImpl = &syncImpl{} var _ metric.BoundSyncImpl = &syncHandle{} @@ -123,7 +123,7 @@ func (inst *instrument) Descriptor() metric.Descriptor { return inst.descriptor } -// Provider interface and delegation +// MeterProvider interface and delegation func newMeterProvider() *meterProvider { return &meterProvider{ @@ -131,7 +131,7 @@ func newMeterProvider() *meterProvider { } } -func (p *meterProvider) setDelegate(provider metric.Provider) { +func (p *meterProvider) setDelegate(provider metric.MeterProvider) { p.lock.Lock() defer p.lock.Unlock() @@ -166,7 +166,7 @@ func (p *meterProvider) Meter(instrumentationName string, opts ...metric.MeterOp // Meter interface and delegation -func (m *meterImpl) setDelegate(name, version string, provider metric.Provider) { +func (m *meterImpl) setDelegate(name, version string, provider metric.MeterProvider) { m.lock.Lock() defer m.lock.Unlock() diff --git a/api/global/internal/meter_test.go b/api/global/internal/meter_test.go index 6b6c8ef0b27..4c89de53d16 100644 --- a/api/global/internal/meter_test.go +++ b/api/global/internal/meter_test.go @@ -65,7 +65,7 @@ func TestDirect(t *testing.T) { second.Record(ctx, 1, labels3...) second.Record(ctx, 2, labels3...) - mock, provider := metrictest.NewProvider() + mock, provider := metrictest.NewMeterProvider() global.SetMeterProvider(provider) counter.Add(ctx, 1, labels1...) @@ -150,7 +150,7 @@ func TestBound(t *testing.T) { boundM.Record(ctx, 1) boundM.Record(ctx, 2) - mock, provider := metrictest.NewProvider() + mock, provider := metrictest.NewMeterProvider() global.SetMeterProvider(provider) boundC.Add(ctx, 1) @@ -198,7 +198,7 @@ func TestUnbindThenRecordOne(t *testing.T) { internal.ResetForTest() ctx := context.Background() - mock, provider := metrictest.NewProvider() + mock, provider := metrictest.NewMeterProvider() meter := global.Meter("test") counter := Must(meter).NewInt64Counter("test.counter") @@ -213,7 +213,7 @@ func TestUnbindThenRecordOne(t *testing.T) { } type meterProviderWithConstructorError struct { - metric.Provider + metric.MeterProvider } type meterWithConstructorError struct { @@ -221,7 +221,7 @@ type meterWithConstructorError struct { } func (m *meterProviderWithConstructorError) Meter(iName string, opts ...metric.MeterOption) metric.Meter { - return metric.WrapMeterImpl(&meterWithConstructorError{m.Provider.Meter(iName, opts...).MeterImpl()}, iName, opts...) + return metric.WrapMeterImpl(&meterWithConstructorError{m.MeterProvider.Meter(iName, opts...).MeterImpl()}, iName, opts...) } func (m *meterWithConstructorError) NewSyncInstrument(_ metric.Descriptor) (metric.SyncImpl, error) { @@ -237,7 +237,7 @@ func TestErrorInDeferredConstructor(t *testing.T) { c1 := Must(meter).NewInt64Counter("test") c2 := Must(meter).NewInt64Counter("test") - _, provider := metrictest.NewProvider() + _, provider := metrictest.NewMeterProvider() sdk := &meterProviderWithConstructorError{provider} require.Panics(t, func() { @@ -279,7 +279,7 @@ func TestImplementationIndirection(t *testing.T) { require.False(t, ok) // Register the SDK - _, provider := metrictest.NewProvider() + _, provider := metrictest.NewMeterProvider() global.SetMeterProvider(provider) // Repeat the above tests @@ -308,7 +308,7 @@ func TestRecordBatchMock(t *testing.T) { meter.RecordBatch(context.Background(), nil, counter.Measurement(1)) - mock, provider := metrictest.NewProvider() + mock, provider := metrictest.NewMeterProvider() global.SetMeterProvider(provider) meter.RecordBatch(context.Background(), nil, counter.Measurement(1)) diff --git a/api/global/internal/state.go b/api/global/internal/state.go index 3eeee94272a..ad48ff448f9 100644 --- a/api/global/internal/state.go +++ b/api/global/internal/state.go @@ -27,11 +27,11 @@ import ( type ( tracerProviderHolder struct { - tp trace.Provider + tp trace.TracerProvider } meterProviderHolder struct { - mp metric.Provider + mp metric.MeterProvider } propagatorsHolder struct { @@ -49,19 +49,19 @@ var ( ) // TracerProvider is the internal implementation for global.TracerProvider. -func TracerProvider() trace.Provider { +func TracerProvider() trace.TracerProvider { return globalTracer.Load().(tracerProviderHolder).tp } // SetTracerProvider is the internal implementation for global.SetTracerProvider. -func SetTracerProvider(tp trace.Provider) { +func SetTracerProvider(tp trace.TracerProvider) { delegateTraceOnce.Do(func() { current := TracerProvider() if current == tp { // Setting the provider to the prior default is nonsense, panic. // Panic is acceptable because we are likely still early in the // process lifetime. - panic("invalid Provider, the global instance cannot be reinstalled") + panic("invalid TracerProvider, the global instance cannot be reinstalled") } else if def, ok := current.(*tracerProvider); ok { def.setDelegate(tp) } @@ -71,12 +71,12 @@ func SetTracerProvider(tp trace.Provider) { } // MeterProvider is the internal implementation for global.MeterProvider. -func MeterProvider() metric.Provider { +func MeterProvider() metric.MeterProvider { return globalMeter.Load().(meterProviderHolder).mp } // SetMeterProvider is the internal implementation for global.SetMeterProvider. -func SetMeterProvider(mp metric.Provider) { +func SetMeterProvider(mp metric.MeterProvider) { delegateMeterOnce.Do(func() { current := MeterProvider() @@ -84,7 +84,7 @@ func SetMeterProvider(mp metric.Provider) { // Setting the provider to the prior default is nonsense, panic. // Panic is acceptable because we are likely still early in the // process lifetime. - panic("invalid Provider, the global instance cannot be reinstalled") + panic("invalid MeterProvider, the global instance cannot be reinstalled") } else if def, ok := current.(*meterProvider); ok { def.setDelegate(mp) } diff --git a/api/global/internal/trace.go b/api/global/internal/trace.go index 053c31c1e16..bcd14613052 100644 --- a/api/global/internal/trace.go +++ b/api/global/internal/trace.go @@ -15,15 +15,15 @@ package internal /* -This file contains the forwarding implementation of the trace.Provider used as +This file contains the forwarding implementation of the TracerProvider used as the default global instance. Prior to initialization of an SDK, Tracers -returned by the global Provider will provide no-op functionality. This means -that all Span created prior to initialization are no-op Spans. +returned by the global TracerProvider will provide no-op functionality. This +means that all Span created prior to initialization are no-op Spans. Once an SDK has been initialized, all provided no-op Tracers are swapped for -Tracers provided by the SDK defined Provider. However, any Span started prior -to this initialization does not change its behavior. Meaning, the Span remains -a no-op Span. +Tracers provided by the SDK defined TracerProvider. However, any Span started +prior to this initialization does not change its behavior. Meaning, the Span +remains a no-op Span. The implementation to track and swap Tracers locks all new Tracer creation until the swap is complete. This assumes that this operation is not @@ -39,27 +39,30 @@ import ( "go.opentelemetry.io/otel/internal/trace/noop" ) -// tracerProvider is a placeholder for a configured SDK Provider. +// tracerProvider is a placeholder for a configured SDK TracerProvider. // -// All Provider functionality is forwarded to a delegate once configured. +// All TracerProvider functionality is forwarded to a delegate once +// configured. type tracerProvider struct { mtx sync.Mutex tracers []*tracer - delegate trace.Provider + delegate trace.TracerProvider } -// Compile-time guarantee that tracerProvider implements the trace.Provider interface. -var _ trace.Provider = &tracerProvider{} +// Compile-time guarantee that tracerProvider implements the TracerProvider +// interface. +var _ trace.TracerProvider = &tracerProvider{} -// setDelegate configures p to delegate all Provider functionality to provider. +// setDelegate configures p to delegate all TracerProvider functionality to +// provider. // // All Tracers provided prior to this function call are switched out to be // Tracers provided by provider. // // Delegation only happens on the first call to this method. All subsequent // calls result in no delegation changes. -func (p *tracerProvider) setDelegate(provider trace.Provider) { +func (p *tracerProvider) setDelegate(provider trace.TracerProvider) { if p.delegate != nil { return } @@ -75,7 +78,7 @@ func (p *tracerProvider) setDelegate(provider trace.Provider) { p.tracers = nil } -// Tracer implements trace.Provider. +// Tracer implements TracerProvider. func (p *tracerProvider) Tracer(name string, opts ...trace.TracerOption) trace.Tracer { p.mtx.Lock() defer p.mtx.Unlock() @@ -111,7 +114,7 @@ var _ trace.Tracer = &tracer{} // // Delegation only happens on the first call to this method. All subsequent // calls result in no delegation changes. -func (t *tracer) setDelegate(provider trace.Provider) { +func (t *tracer) setDelegate(provider trace.TracerProvider) { t.once.Do(func() { t.delegate = provider.Tracer(t.name, t.opts...) }) } diff --git a/api/global/internal/trace_test.go b/api/global/internal/trace_test.go index bf8cc573f64..3a466612561 100644 --- a/api/global/internal/trace_test.go +++ b/api/global/internal/trace_test.go @@ -35,7 +35,7 @@ func TestTraceWithSDK(t *testing.T) { _, span1 := tracer1.Start(ctx, "span1") sr := new(tracetest.StandardSpanRecorder) - tp := tracetest.NewProvider(tracetest.WithSpanRecorder(sr)) + tp := tracetest.NewTracerProvider(tracetest.WithSpanRecorder(sr)) global.SetTracerProvider(tp) // This span was started before initialization, it is expected to be dropped. @@ -45,7 +45,7 @@ func TestTraceWithSDK(t *testing.T) { _, span2 := tracer1.Start(ctx, "span2") span2.End() - // The global trace Provider should now create Tracers that also use the newly configured SDK. + // The global TracerProvider should now create Tracers that also use the newly configured SDK. tracer2 := gtp.Tracer("post") _, span3 := tracer2.Start(ctx, "span3") span3.End() diff --git a/api/global/metric.go b/api/global/metric.go index 04409c46ea9..f1695bb7aa0 100644 --- a/api/global/metric.go +++ b/api/global/metric.go @@ -20,7 +20,7 @@ import ( ) // Meter creates an implementation of the Meter interface from the global -// Provider. The instrumentationName must be the name of the library +// MeterProvider. The instrumentationName must be the name of the library // providing instrumentation. This name may be the same as the instrumented // code only if that code provides built-in instrumentation. If the // instrumentationName is empty, then a implementation defined default name @@ -39,11 +39,11 @@ func Meter(instrumentationName string, opts ...metric.MeterOption) metric.Meter // meter := global.MeterProvider().Meter("example.com/foo") // or // meter := global.Meter("example.com/foo") -func MeterProvider() metric.Provider { +func MeterProvider() metric.MeterProvider { return internal.MeterProvider() } // SetMeterProvider registers `mp` as the global meter provider. -func SetMeterProvider(mp metric.Provider) { +func SetMeterProvider(mp metric.MeterProvider) { internal.SetMeterProvider(mp) } diff --git a/api/global/metric_test.go b/api/global/metric_test.go index 2262a32ac91..369388863dd 100644 --- a/api/global/metric_test.go +++ b/api/global/metric_test.go @@ -23,7 +23,7 @@ import ( type testMeterProvider struct{} -var _ metric.Provider = &testMeterProvider{} +var _ metric.MeterProvider = &testMeterProvider{} func (*testMeterProvider) Meter(_ string, _ ...metric.MeterOption) metric.Meter { return metric.Meter{} @@ -31,13 +31,13 @@ func (*testMeterProvider) Meter(_ string, _ ...metric.MeterOption) metric.Meter func TestMultipleGlobalMeterProvider(t *testing.T) { p1 := testMeterProvider{} - p2 := metric.NoopProvider{} + p2 := metric.NoopMeterProvider{} global.SetMeterProvider(&p1) global.SetMeterProvider(&p2) got := global.MeterProvider() want := &p2 if got != want { - t.Fatalf("Provider: got %p, want %p\n", got, want) + t.Fatalf("MeterProvider: got %p, want %p\n", got, want) } } diff --git a/api/global/trace.go b/api/global/trace.go index 6fcd928af90..49a7543897d 100644 --- a/api/global/trace.go +++ b/api/global/trace.go @@ -28,17 +28,17 @@ func Tracer(name string) trace.Tracer { } // TracerProvider returns the registered global trace provider. -// If none is registered then an instance of trace.NoopProvider is returned. +// If none is registered then an instance of NoopTracerProvider is returned. // // Use the trace provider to create a named tracer. E.g. // tracer := global.TracerProvider().Tracer("example.com/foo") // or // tracer := global.Tracer("example.com/foo") -func TracerProvider() trace.Provider { +func TracerProvider() trace.TracerProvider { return internal.TracerProvider() } // SetTracerProvider registers `tp` as the global trace provider. -func SetTracerProvider(tp trace.Provider) { +func SetTracerProvider(tp trace.TracerProvider) { internal.SetTracerProvider(tp) } diff --git a/api/global/trace_test.go b/api/global/trace_test.go index b66d172d477..c93c6d8ca44 100644 --- a/api/global/trace_test.go +++ b/api/global/trace_test.go @@ -24,7 +24,7 @@ import ( type testTracerProvider struct{} -var _ trace.Provider = &testTracerProvider{} +var _ trace.TracerProvider = &testTracerProvider{} func (*testTracerProvider) Tracer(_ string, _ ...trace.TracerOption) trace.Tracer { return noop.Tracer @@ -32,13 +32,13 @@ func (*testTracerProvider) Tracer(_ string, _ ...trace.TracerOption) trace.Trace func TestMultipleGlobalTracerProvider(t *testing.T) { p1 := testTracerProvider{} - p2 := trace.NoopProvider() + p2 := trace.NoopTracerProvider() global.SetTracerProvider(&p1) global.SetTracerProvider(p2) got := global.TracerProvider() want := p2 if got != want { - t.Fatalf("Provider: got %p, want %p\n", got, want) + t.Fatalf("TracerProvider: got %p, want %p\n", got, want) } } diff --git a/api/metric/doc.go b/api/metric/doc.go index 2822b997903..48a59c5b82a 100644 --- a/api/metric/doc.go +++ b/api/metric/doc.go @@ -42,9 +42,9 @@ // // The Meter interface supports allocating new instruments as well as // interfaces for recording batches of synchronous measurements or -// asynchronous observations. To obtain a Meter, use a Provider. +// asynchronous observations. To obtain a Meter, use a MeterProvider. // -// The Provider interface supports obtaining a named Meter interface. -// To obtain a Provider implementation, initialize and configure any +// The MeterProvider interface supports obtaining a named Meter interface. To +// obtain a MeterProvider implementation, initialize and configure any // compatible SDK. package metric // import "go.opentelemetry.io/otel/api/metric" diff --git a/api/metric/meter.go b/api/metric/meter.go index 079c294776f..d1749136f08 100644 --- a/api/metric/meter.go +++ b/api/metric/meter.go @@ -22,7 +22,7 @@ import ( // The file is organized as follows: // -// - Provider interface +// - MeterProvider interface // - Meter struct // - RecordBatch // - BatchObserver @@ -31,8 +31,8 @@ import ( // - Batch asynchronous constructors (1 x int64,float64) // - Internals -// Provider supports named Meter instances. -type Provider interface { +// MeterProvider supports named Meter instances. +type MeterProvider interface { // Meter creates an implementation of the Meter interface. // The instrumentationName must be the name of the library providing // instrumentation. This name may be the same as the instrumented code diff --git a/api/metric/metrictest/meter.go b/api/metric/metrictest/meter.go index d404dcc3009..40524cac33c 100644 --- a/api/metric/metrictest/meter.go +++ b/api/metric/metrictest/meter.go @@ -113,15 +113,15 @@ func (m *MeterImpl) doRecordSingle(ctx context.Context, labels []label.KeyValue, }}) } -func NewProvider() (*MeterImpl, apimetric.Provider) { +func NewMeterProvider() (*MeterImpl, apimetric.MeterProvider) { impl := &MeterImpl{ asyncInstruments: NewAsyncInstrumentState(), } - return impl, registry.NewProvider(impl) + return impl, registry.NewMeterProvider(impl) } func NewMeter() (*MeterImpl, apimetric.Meter) { - impl, p := NewProvider() + impl, p := NewMeterProvider() return impl, p.Meter("mock") } diff --git a/api/metric/noop.go b/api/metric/noop.go index de2c5681a9f..97867d9b7d6 100644 --- a/api/metric/noop.go +++ b/api/metric/noop.go @@ -20,19 +20,19 @@ import ( "go.opentelemetry.io/otel/label" ) -type NoopProvider struct{} +type NoopMeterProvider struct{} type noopInstrument struct{} type noopBoundInstrument struct{} type NoopSync struct{ noopInstrument } type NoopAsync struct{ noopInstrument } -var _ Provider = NoopProvider{} +var _ MeterProvider = NoopMeterProvider{} var _ SyncImpl = NoopSync{} var _ BoundSyncImpl = noopBoundInstrument{} var _ AsyncImpl = NoopAsync{} -func (NoopProvider) Meter(_ string, _ ...MeterOption) Meter { +func (NoopMeterProvider) Meter(_ string, _ ...MeterOption) Meter { return Meter{} } diff --git a/api/metric/registry/registry.go b/api/metric/registry/registry.go index 16b6883a9a6..ed9eccca3e2 100644 --- a/api/metric/registry/registry.go +++ b/api/metric/registry/registry.go @@ -23,12 +23,12 @@ import ( "go.opentelemetry.io/otel/label" ) -// Provider is a standard metric.Provider for wrapping `MeterImpl` -type Provider struct { +// MeterProvider is a standard MeterProvider for wrapping `MeterImpl` +type MeterProvider struct { impl metric.MeterImpl } -var _ metric.Provider = (*Provider)(nil) +var _ metric.MeterProvider = (*MeterProvider)(nil) // uniqueInstrumentMeterImpl implements the metric.MeterImpl interface, adding // uniqueness checking for instrument descriptors. Use NewUniqueInstrumentMeter @@ -47,16 +47,16 @@ type key struct { InstrumentationVersion string } -// NewProvider returns a new provider that implements instrument +// NewMeterProvider returns a new provider that implements instrument // name-uniqueness checking. -func NewProvider(impl metric.MeterImpl) *Provider { - return &Provider{ +func NewMeterProvider(impl metric.MeterImpl) *MeterProvider { + return &MeterProvider{ impl: NewUniqueInstrumentMeterImpl(impl), } } -// Meter implements metric.Provider. -func (p *Provider) Meter(instrumentationName string, opts ...metric.MeterOption) metric.Meter { +// Meter implements MeterProvider. +func (p *MeterProvider) Meter(instrumentationName string, opts ...metric.MeterOption) metric.Meter { return metric.WrapMeterImpl(p.impl, instrumentationName, opts...) } diff --git a/api/metric/registry/registry_test.go b/api/metric/registry/registry_test.go index f13c802370a..09c98e6065b 100644 --- a/api/metric/registry/registry_test.go +++ b/api/metric/registry/registry_test.go @@ -72,7 +72,7 @@ func unwrap(impl interface{}, err error) (metric.InstrumentImpl, error) { func TestRegistrySameInstruments(t *testing.T) { for _, nf := range allNew { - _, provider := mockTest.NewProvider() + _, provider := mockTest.NewMeterProvider() meter := provider.Meter("meter") inst1, err1 := nf(meter, "this") @@ -86,7 +86,7 @@ func TestRegistrySameInstruments(t *testing.T) { func TestRegistryDifferentNamespace(t *testing.T) { for _, nf := range allNew { - _, provider := mockTest.NewProvider() + _, provider := mockTest.NewMeterProvider() meter1 := provider.Meter("meter1") meter2 := provider.Meter("meter2") @@ -101,7 +101,7 @@ func TestRegistryDifferentNamespace(t *testing.T) { func TestRegistryDiffInstruments(t *testing.T) { for origName, origf := range allNew { - _, provider := mockTest.NewProvider() + _, provider := mockTest.NewMeterProvider() meter := provider.Meter("meter") _, err := origf(meter, "this") @@ -120,9 +120,9 @@ func TestRegistryDiffInstruments(t *testing.T) { } } -func TestProvider(t *testing.T) { +func TestMeterProvider(t *testing.T) { impl, _ := mockTest.NewMeter() - p := registry.NewProvider(impl) + p := registry.NewMeterProvider(impl) m1 := p.Meter("m1") m1p := p.Meter("m1") m2 := p.Meter("m2") diff --git a/api/trace/api.go b/api/trace/api.go index 8184888158b..614f5bab421 100644 --- a/api/trace/api.go +++ b/api/trace/api.go @@ -22,7 +22,8 @@ import ( "go.opentelemetry.io/otel/label" ) -type Provider interface { +// TracerProvider provides access to instrumentation Tracers. +type TracerProvider interface { // Tracer creates an implementation of the Tracer interface. // The instrumentationName must be the name of the library providing // instrumentation. This name may be the same as the instrumented code diff --git a/api/trace/noop_trace_provider.go b/api/trace/noop_trace_provider.go index fc49da58a24..414c8e3ab74 100644 --- a/api/trace/noop_trace_provider.go +++ b/api/trace/noop_trace_provider.go @@ -14,18 +14,17 @@ package trace -type noopProvider struct{} +type noopTracerProvider struct{} -var _ Provider = noopProvider{} +var _ TracerProvider = noopTracerProvider{} // Tracer returns noop implementation of Tracer. -func (p noopProvider) Tracer(_ string, _ ...TracerOption) Tracer { +func (p noopTracerProvider) Tracer(_ string, _ ...TracerOption) Tracer { return noopTracer{} } -// NoopProvider returns a noop implementation of Provider. -// The Tracer and Spans created from the noop provider will -// also be noop. -func NoopProvider() Provider { - return noopProvider{} +// NoopTracerProvider returns a noop implementation of TracerProvider. The +// Tracer and Spans created from the noop provider will also be noop. +func NoopTracerProvider() TracerProvider { + return noopTracerProvider{} } diff --git a/api/trace/tracetest/provider.go b/api/trace/tracetest/provider.go index 84b5c97ba64..511e80b0e7b 100644 --- a/api/trace/tracetest/provider.go +++ b/api/trace/tracetest/provider.go @@ -20,17 +20,17 @@ import ( "go.opentelemetry.io/otel/api/trace" ) -type Provider struct { +type TracerProvider struct { config config tracersMu sync.Mutex tracers map[instrumentation]*Tracer } -var _ trace.Provider = (*Provider)(nil) +var _ trace.TracerProvider = (*TracerProvider)(nil) -func NewProvider(opts ...Option) *Provider { - return &Provider{ +func NewTracerProvider(opts ...Option) *TracerProvider { + return &TracerProvider{ config: newConfig(opts...), tracers: make(map[instrumentation]*Tracer), } @@ -40,7 +40,7 @@ type instrumentation struct { Name, Version string } -func (p *Provider) Tracer(instName string, opts ...trace.TracerOption) trace.Tracer { +func (p *TracerProvider) Tracer(instName string, opts ...trace.TracerOption) trace.Tracer { conf := trace.NewTracerConfig(opts...) inst := instrumentation{ diff --git a/api/trace/tracetest/span_test.go b/api/trace/tracetest/span_test.go index a0f8642fa4c..1ae138c4f44 100644 --- a/api/trace/tracetest/span_test.go +++ b/api/trace/tracetest/span_test.go @@ -32,7 +32,7 @@ import ( func TestSpan(t *testing.T) { t.Run("#Tracer", func(t *testing.T) { - tp := tracetest.NewProvider() + tp := tracetest.NewTracerProvider() t.Run("returns the tracer used to start the span", func(t *testing.T) { t.Parallel() @@ -46,7 +46,7 @@ func TestSpan(t *testing.T) { }) t.Run("#End", func(t *testing.T) { - tp := tracetest.NewProvider() + tp := tracetest.NewTracerProvider() t.Run("ends the span", func(t *testing.T) { t.Parallel() @@ -125,7 +125,7 @@ func TestSpan(t *testing.T) { }) t.Run("#RecordError", func(t *testing.T) { - tp := tracetest.NewProvider() + tp := tracetest.NewTracerProvider() t.Run("records an error", func(t *testing.T) { t.Parallel() @@ -236,7 +236,7 @@ func TestSpan(t *testing.T) { }) t.Run("#IsRecording", func(t *testing.T) { - tp := tracetest.NewProvider() + tp := tracetest.NewTracerProvider() t.Run("returns true", func(t *testing.T) { t.Parallel() @@ -250,7 +250,7 @@ func TestSpan(t *testing.T) { }) t.Run("#SpanContext", func(t *testing.T) { - tp := tracetest.NewProvider() + tp := tracetest.NewTracerProvider() t.Run("returns a valid SpanContext", func(t *testing.T) { t.Parallel() @@ -275,7 +275,7 @@ func TestSpan(t *testing.T) { }) t.Run("#Name", func(t *testing.T) { - tp := tracetest.NewProvider() + tp := tracetest.NewTracerProvider() t.Run("returns the most recently set name on the span", func(t *testing.T) { t.Parallel() @@ -319,7 +319,7 @@ func TestSpan(t *testing.T) { }) t.Run("#Attributes", func(t *testing.T) { - tp := tracetest.NewProvider() + tp := tracetest.NewTracerProvider() t.Run("returns an empty map by default", func(t *testing.T) { t.Parallel() @@ -415,7 +415,7 @@ func TestSpan(t *testing.T) { }) t.Run("#Links", func(t *testing.T) { - tp := tracetest.NewProvider() + tp := tracetest.NewTracerProvider() t.Run("returns an empty map by default", func(t *testing.T) { t.Parallel() @@ -432,7 +432,7 @@ func TestSpan(t *testing.T) { }) t.Run("#Events", func(t *testing.T) { - tp := tracetest.NewProvider() + tp := tracetest.NewTracerProvider() t.Run("returns an empty slice by default", func(t *testing.T) { t.Parallel() @@ -526,7 +526,7 @@ func TestSpan(t *testing.T) { }) t.Run("#Status", func(t *testing.T) { - tp := tracetest.NewProvider() + tp := tracetest.NewTracerProvider() t.Run("defaults to OK", func(t *testing.T) { t.Parallel() @@ -608,7 +608,7 @@ func TestSpan(t *testing.T) { }) t.Run("#SpanKind", func(t *testing.T) { - tp := tracetest.NewProvider() + tp := tracetest.NewTracerProvider() t.Run("returns the value given at start", func(t *testing.T) { t.Parallel() diff --git a/api/trace/tracetest/tracer_test.go b/api/trace/tracetest/tracer_test.go index 43e246e9201..fffab3bee18 100644 --- a/api/trace/tracetest/tracer_test.go +++ b/api/trace/tracetest/tracer_test.go @@ -30,10 +30,10 @@ import ( ) func TestTracer(t *testing.T) { - tp := tracetest.NewProvider() + tp := tracetest.NewTracerProvider() apitest.NewHarness(t).TestTracer(func() func() trace.Tracer { - tp := tracetest.NewProvider() + tp := tracetest.NewTracerProvider() var i uint64 return func() trace.Tracer { return tp.Tracer(fmt.Sprintf("tracer %d", atomic.AddUint64(&i, 1))) @@ -259,7 +259,7 @@ func TestTracer(t *testing.T) { } func testTracedSpan(t *testing.T, fn func(tracer trace.Tracer, name string) (trace.Span, error)) { - tp := tracetest.NewProvider() + tp := tracetest.NewTracerProvider() t.Run("starts a span with the expected name", func(t *testing.T) { t.Parallel() @@ -304,7 +304,7 @@ func testTracedSpan(t *testing.T, fn func(tracer trace.Tracer, name string) (tra e := matchers.NewExpecter(t) sr := new(tracetest.StandardSpanRecorder) - subject := tracetest.NewProvider(tracetest.WithSpanRecorder(sr)).Tracer(t.Name()) + subject := tracetest.NewTracerProvider(tracetest.WithSpanRecorder(sr)).Tracer(t.Name()) subject.Start(context.Background(), "span1") e.Expect(len(sr.Started())).ToEqual(1) @@ -324,7 +324,7 @@ func testTracedSpan(t *testing.T, fn func(tracer trace.Tracer, name string) (tra e := matchers.NewExpecter(t) sr := new(tracetest.StandardSpanRecorder) - subject := tracetest.NewProvider(tracetest.WithSpanRecorder(sr)).Tracer(t.Name()) + subject := tracetest.NewTracerProvider(tracetest.WithSpanRecorder(sr)).Tracer(t.Name()) numSpans := 2 diff --git a/bridge/opentracing/util.go b/bridge/opentracing/util.go index 1863c34efb0..d2a4cd63a6c 100644 --- a/bridge/opentracing/util.go +++ b/bridge/opentracing/util.go @@ -20,20 +20,20 @@ import ( oteltrace "go.opentelemetry.io/otel/api/trace" ) -// NewTracerPair is a utility function that creates a BridgeTracer -// and a WrapperProvider. WrapperProvider creates a single instance of +// NewTracerPair is a utility function that creates a BridgeTracer and a +// WrapperTracerProvider. WrapperTracerProvider creates a single instance of // WrapperTracer. The BridgeTracer forwards the calls to the WrapperTracer -// that wraps the passed tracer. BridgeTracer and WrapperProvider are returned to -// the caller and the caller is expected to register BridgeTracer with opentracing and -// WrapperProvider with opentelemetry. -func NewTracerPair(tracer oteltrace.Tracer) (*BridgeTracer, *WrapperProvider) { +// that wraps the passed tracer. BridgeTracer and WrapperTracerProvider are +// returned to the caller and the caller is expected to register BridgeTracer +// with opentracing and WrapperTracerProvider with opentelemetry. +func NewTracerPair(tracer oteltrace.Tracer) (*BridgeTracer, *WrapperTracerProvider) { bridgeTracer := NewBridgeTracer() - wrapperProvider := NewWrappedProvider(bridgeTracer, tracer) + wrapperProvider := NewWrappedTracerProvider(bridgeTracer, tracer) bridgeTracer.SetOpenTelemetryTracer(wrapperProvider.Tracer("")) return bridgeTracer, wrapperProvider } -func NewTracerPairWithContext(ctx context.Context, tracer oteltrace.Tracer) (context.Context, *BridgeTracer, *WrapperProvider) { +func NewTracerPairWithContext(ctx context.Context, tracer oteltrace.Tracer) (context.Context, *BridgeTracer, *WrapperTracerProvider) { bridgeTracer, wrapperProvider := NewTracerPair(tracer) ctx = bridgeTracer.NewHookedContext(ctx) return ctx, bridgeTracer, wrapperProvider diff --git a/bridge/opentracing/wrapper.go b/bridge/opentracing/wrapper.go index f5070695bdc..4187a9d48b8 100644 --- a/bridge/opentracing/wrapper.go +++ b/bridge/opentracing/wrapper.go @@ -22,21 +22,21 @@ import ( "go.opentelemetry.io/otel/bridge/opentracing/migration" ) -type WrapperProvider struct { +type WrapperTracerProvider struct { wTracer *WrapperTracer } -var _ oteltrace.Provider = (*WrapperProvider)(nil) +var _ oteltrace.TracerProvider = (*WrapperTracerProvider)(nil) -// Tracer returns the WrapperTracer associated with the WrapperProvider. -func (p *WrapperProvider) Tracer(_ string, _ ...oteltrace.TracerOption) oteltrace.Tracer { +// Tracer returns the WrapperTracer associated with the WrapperTracerProvider. +func (p *WrapperTracerProvider) Tracer(_ string, _ ...oteltrace.TracerOption) oteltrace.Tracer { return p.wTracer } -// NewWrappedProvider creates a new trace provider that creates a single +// NewWrappedTracerProvider creates a new trace provider that creates a single // instance of WrapperTracer that wraps OpenTelemetry tracer. -func NewWrappedProvider(bridge *BridgeTracer, tracer oteltrace.Tracer) *WrapperProvider { - return &WrapperProvider{ +func NewWrappedTracerProvider(bridge *BridgeTracer, tracer oteltrace.Tracer) *WrapperTracerProvider { + return &WrapperTracerProvider{ wTracer: NewWrapperTracer(bridge, tracer), } } diff --git a/example/namedtracer/main.go b/example/namedtracer/main.go index aa0f5a3d0c7..fdc3eb4409b 100644 --- a/example/namedtracer/main.go +++ b/example/namedtracer/main.go @@ -33,7 +33,7 @@ var ( anotherKey = label.Key("ex.com/another") ) -var tp *sdktrace.Provider +var tp *sdktrace.TracerProvider // initTracer creates and registers trace provider instance. func initTracer() { @@ -43,7 +43,7 @@ func initTracer() { log.Panicf("failed to initialize stdout exporter %v\n", err) return } - tp = sdktrace.NewProvider( + tp = sdktrace.NewTracerProvider( sdktrace.WithConfig( sdktrace.Config{ DefaultSampler: sdktrace.AlwaysSample(), diff --git a/example/otel-collector/main.go b/example/otel-collector/main.go index 12b79a0457b..83c7c8bb22d 100644 --- a/example/otel-collector/main.go +++ b/example/otel-collector/main.go @@ -55,7 +55,7 @@ func initProvider() func() { handleErr(err, "failed to create exporter") bsp := sdktrace.NewBatchSpanProcessor(exp) - tracerProvider := sdktrace.NewProvider( + tracerProvider := sdktrace.NewTracerProvider( sdktrace.WithConfig(sdktrace.Config{DefaultSampler: sdktrace.AlwaysSample()}), sdktrace.WithResource(resource.New( // the service name used to display traces in backends @@ -74,7 +74,7 @@ func initProvider() func() { ) global.SetTracerProvider(tracerProvider) - global.SetMeterProvider(pusher.Provider()) + global.SetMeterProvider(pusher.MeterProvider()) pusher.Start() return func() { diff --git a/exporters/metric/prometheus/example_test.go b/exporters/metric/prometheus/example_test.go index 441e1addd78..b58b2cfa88f 100644 --- a/exporters/metric/prometheus/example_test.go +++ b/exporters/metric/prometheus/example_test.go @@ -45,7 +45,7 @@ func ExampleNewExportPipeline() { if err != nil { panic(err) } - meter := exporter.Provider().Meter("example") + meter := exporter.MeterProvider().Meter("example") ctx := context.Background() // Use two instruments diff --git a/exporters/metric/prometheus/prometheus.go b/exporters/metric/prometheus/prometheus.go index 77b428ce014..92bc2a07de6 100644 --- a/exporters/metric/prometheus/prometheus.go +++ b/exporters/metric/prometheus/prometheus.go @@ -134,7 +134,7 @@ func InstallNewPipeline(config Config, options ...pull.Option) (*Exporter, error if err != nil { return nil, err } - global.SetMeterProvider(exp.Provider()) + global.SetMeterProvider(exp.MeterProvider()) return exp, nil } @@ -154,9 +154,9 @@ func (e *Exporter) SetController(config Config, options ...pull.Option) { ) } -// Provider returns the metric.Provider of this exporter. -func (e *Exporter) Provider() metric.Provider { - return e.controller.Provider() +// MeterProvider returns the MeterProvider of this exporter. +func (e *Exporter) MeterProvider() metric.MeterProvider { + return e.controller.MeterProvider() } // Controller returns the controller object that coordinates collection for the SDK. diff --git a/exporters/metric/prometheus/prometheus_test.go b/exporters/metric/prometheus/prometheus_test.go index ba09e2240dc..ad71ced9736 100644 --- a/exporters/metric/prometheus/prometheus_test.go +++ b/exporters/metric/prometheus/prometheus_test.go @@ -43,7 +43,7 @@ func TestPrometheusExporter(t *testing.T) { ) require.NoError(t, err) - meter := exporter.Provider().Meter("test") + meter := exporter.MeterProvider().Meter("test") counter := metric.Must(meter).NewFloat64Counter("counter") valuerecorder := metric.Must(meter).NewFloat64ValueRecorder("valuerecorder") @@ -105,7 +105,7 @@ func TestPrometheusStatefulness(t *testing.T) { ) require.NoError(t, err) - meter := exporter.Provider().Meter("test") + meter := exporter.MeterProvider().Meter("test") // GET the HTTP endpoint scrape := func() string { diff --git a/exporters/otlp/README.md b/exporters/otlp/README.md index afd39b0e305..434e30d3dc8 100644 --- a/exporters/otlp/README.md +++ b/exporters/otlp/README.md @@ -41,16 +41,16 @@ func main() { }() // Note: The exporter can also be used as a Batcher. E.g. - // tracerProvider := sdktrace.NewProvider( + // tracerProvider := sdktrace.NewTracerProvider( // sdktrace.WithBatcher(exporter, // sdktrace.WithBatchTimeout(time.Second*15), // sdktrace.WithMaxExportBatchSize(100), // ), // ) - tracerProvider := sdktrace.NewProvider(sdktrace.WithBatcher(exporter)) + tracerProvider := sdktrace.NewTracerProvider(sdktrace.WithBatcher(exporter)) pusher := push.New(simple.NewWithExactDistribution(), exporter) pusher.Start() - metricProvider := pusher.Provider() + metricProvider := pusher.MeterProvider() // Your code here ... } diff --git a/exporters/otlp/example_test.go b/exporters/otlp/example_test.go index 290db6d54d5..05dcf413ff0 100644 --- a/exporters/otlp/example_test.go +++ b/exporters/otlp/example_test.go @@ -40,7 +40,7 @@ func Example_insecure() { } }() - tp := sdktrace.NewProvider( + tp := sdktrace.NewTracerProvider( sdktrace.WithConfig(sdktrace.Config{DefaultSampler: sdktrace.AlwaysSample()}), sdktrace.WithBatcher( exp, @@ -84,7 +84,7 @@ func Example_withTLS() { } }() - tp := sdktrace.NewProvider( + tp := sdktrace.NewTracerProvider( sdktrace.WithConfig(sdktrace.Config{DefaultSampler: sdktrace.AlwaysSample()}), sdktrace.WithBatcher( exp, diff --git a/exporters/otlp/otlp_integration_test.go b/exporters/otlp/otlp_integration_test.go index fe9f5213bff..fb92e13c6c2 100644 --- a/exporters/otlp/otlp_integration_test.go +++ b/exporters/otlp/otlp_integration_test.go @@ -86,7 +86,7 @@ func newExporterEndToEndTest(t *testing.T, additionalOpts []otlp.ExporterOption) } }() - pOpts := []sdktrace.ProviderOption{ + pOpts := []sdktrace.TracerProviderOption{ sdktrace.WithConfig(sdktrace.Config{DefaultSampler: sdktrace.AlwaysSample()}), sdktrace.WithBatcher( exp, @@ -95,13 +95,13 @@ func newExporterEndToEndTest(t *testing.T, additionalOpts []otlp.ExporterOption) sdktrace.WithMaxExportBatchSize(10), ), } - tp1 := sdktrace.NewProvider(append(pOpts, + tp1 := sdktrace.NewTracerProvider(append(pOpts, sdktrace.WithResource(resource.New( label.String("rk1", "rv11)"), label.Int64("rk2", 5), )))...) - tp2 := sdktrace.NewProvider(append(pOpts, + tp2 := sdktrace.NewTracerProvider(append(pOpts, sdktrace.WithResource(resource.New( label.String("rk1", "rv12)"), label.Float32("rk3", 6.5), @@ -127,7 +127,7 @@ func newExporterEndToEndTest(t *testing.T, additionalOpts []otlp.ExporterOption) pusher.Start() ctx := context.Background() - meter := pusher.Provider().Meter("test-meter") + meter := pusher.MeterProvider().Meter("test-meter") labels := []label.KeyValue{label.Bool("test", true)} type data struct { @@ -462,7 +462,7 @@ func TestNewExporter_withMultipleAttributeTypes(t *testing.T) { _ = exp.Shutdown(context.Background()) }() - tp := sdktrace.NewProvider( + tp := sdktrace.NewTracerProvider( sdktrace.WithConfig(sdktrace.Config{DefaultSampler: sdktrace.AlwaysSample()}), sdktrace.WithBatcher( exp, diff --git a/exporters/stdout/exporter.go b/exporters/stdout/exporter.go index 37832b67924..52608a89cb2 100644 --- a/exporters/stdout/exporter.go +++ b/exporters/stdout/exporter.go @@ -50,13 +50,13 @@ func NewExporter(options ...Option) (*Exporter, error) { // NewExportPipeline creates a complete export pipeline with the default // selectors, processors, and trace registration. It is the responsibility // of the caller to stop the returned push Controller. -func NewExportPipeline(exportOpts []Option, pushOpts []push.Option) (apitrace.Provider, *push.Controller, error) { +func NewExportPipeline(exportOpts []Option, pushOpts []push.Option) (apitrace.TracerProvider, *push.Controller, error) { exporter, err := NewExporter(exportOpts...) if err != nil { return nil, nil, err } - tp := sdktrace.NewProvider(sdktrace.WithBatcher(exporter)) + tp := sdktrace.NewTracerProvider(sdktrace.WithBatcher(exporter)) pusher := push.New( basic.New( simple.NewWithExactDistribution(), @@ -88,6 +88,6 @@ func InstallNewPipeline(exportOpts []Option, pushOpts []push.Option) (*push.Cont return controller, err } global.SetTracerProvider(tracerProvider) - global.SetMeterProvider(controller.Provider()) + global.SetMeterProvider(controller.MeterProvider()) return controller, err } diff --git a/exporters/trace/jaeger/jaeger.go b/exporters/trace/jaeger/jaeger.go index 5d77200648f..de9f0d5414d 100644 --- a/exporters/trace/jaeger/jaeger.go +++ b/exporters/trace/jaeger/jaeger.go @@ -151,14 +151,14 @@ func NewRawExporter(endpointOption EndpointOption, opts ...Option) (*Exporter, e // NewExportPipeline sets up a complete export pipeline // with the recommended setup for trace provider -func NewExportPipeline(endpointOption EndpointOption, opts ...Option) (apitrace.Provider, func(), error) { +func NewExportPipeline(endpointOption EndpointOption, opts ...Option) (apitrace.TracerProvider, func(), error) { o := options{} opts = append(opts, WithDisabledFromEnv()) for _, opt := range opts { opt(&o) } if o.Disabled { - return apitrace.NoopProvider(), func() {}, nil + return apitrace.NoopTracerProvider(), func() {}, nil } exporter, err := NewRawExporter(endpointOption, opts...) @@ -166,11 +166,11 @@ func NewExportPipeline(endpointOption EndpointOption, opts ...Option) (apitrace. return nil, nil, err } - pOpts := []sdktrace.ProviderOption{sdktrace.WithSyncer(exporter)} + pOpts := []sdktrace.TracerProviderOption{sdktrace.WithSyncer(exporter)} if exporter.o.Config != nil { pOpts = append(pOpts, sdktrace.WithConfig(*exporter.o.Config)) } - tp := sdktrace.NewProvider(pOpts...) + tp := sdktrace.NewTracerProvider(pOpts...) return tp, exporter.Flush, nil } diff --git a/exporters/trace/jaeger/jaeger_test.go b/exporters/trace/jaeger/jaeger_test.go index 10022a0fb4e..6fa0642dcdc 100644 --- a/exporters/trace/jaeger/jaeger_test.go +++ b/exporters/trace/jaeger/jaeger_test.go @@ -51,17 +51,17 @@ func TestInstallNewPipeline(t *testing.T) { name string endpoint EndpointOption options []Option - expectedProvider trace.Provider + expectedProvider trace.TracerProvider }{ { name: "simple pipeline", endpoint: WithCollectorEndpoint(collectorEndpoint), - expectedProvider: &sdktrace.Provider{}, + expectedProvider: &sdktrace.TracerProvider{}, }, { name: "with agent endpoint", endpoint: WithAgentEndpoint(agentEndpoint), - expectedProvider: &sdktrace.Provider{}, + expectedProvider: &sdktrace.TracerProvider{}, }, { name: "with disabled", @@ -69,7 +69,7 @@ func TestInstallNewPipeline(t *testing.T) { options: []Option{ WithDisabled(true), }, - expectedProvider: apitrace.NoopProvider(), + expectedProvider: apitrace.NoopTracerProvider(), }, } @@ -94,13 +94,13 @@ func TestNewExportPipeline(t *testing.T) { name string endpoint EndpointOption options []Option - expectedProviderType trace.Provider + expectedProviderType trace.TracerProvider testSpanSampling, spanShouldBeSampled bool }{ { name: "simple pipeline", endpoint: WithCollectorEndpoint(collectorEndpoint), - expectedProviderType: &sdktrace.Provider{}, + expectedProviderType: &sdktrace.TracerProvider{}, }, { name: "with disabled", @@ -108,7 +108,7 @@ func TestNewExportPipeline(t *testing.T) { options: []Option{ WithDisabled(true), }, - expectedProviderType: apitrace.NoopProvider(), + expectedProviderType: apitrace.NoopTracerProvider(), }, { name: "always on", @@ -118,7 +118,7 @@ func TestNewExportPipeline(t *testing.T) { DefaultSampler: sdktrace.AlwaysSample(), }), }, - expectedProviderType: &sdktrace.Provider{}, + expectedProviderType: &sdktrace.TracerProvider{}, testSpanSampling: true, spanShouldBeSampled: true, }, @@ -130,7 +130,7 @@ func TestNewExportPipeline(t *testing.T) { DefaultSampler: sdktrace.NeverSample(), }), }, - expectedProviderType: &sdktrace.Provider{}, + expectedProviderType: &sdktrace.TracerProvider{}, testSpanSampling: true, spanShouldBeSampled: false, }, @@ -173,7 +173,7 @@ func TestNewExportPipelineWithDisabledFromEnv(t *testing.T) { ) defer fn() assert.NoError(t, err) - assert.IsType(t, apitrace.NoopProvider(), tp) + assert.IsType(t, apitrace.NoopTracerProvider(), tp) } func TestNewRawExporter(t *testing.T) { @@ -339,7 +339,7 @@ func TestExporter_ExportSpan(t *testing.T) { assert.NoError(t, err) - tp := sdktrace.NewProvider( + tp := sdktrace.NewTracerProvider( sdktrace.WithConfig(sdktrace.Config{DefaultSampler: sdktrace.AlwaysSample()}), sdktrace.WithSyncer(exp), ) diff --git a/exporters/trace/zipkin/zipkin.go b/exporters/trace/zipkin/zipkin.go index 7e35ddbc724..b759880b78a 100644 --- a/exporters/trace/zipkin/zipkin.go +++ b/exporters/trace/zipkin/zipkin.go @@ -111,13 +111,13 @@ func NewRawExporter(collectorURL, serviceName string, opts ...Option) (*Exporter // NewExportPipeline sets up a complete export pipeline // with the recommended setup for trace provider -func NewExportPipeline(collectorURL, serviceName string, opts ...Option) (*sdktrace.Provider, error) { +func NewExportPipeline(collectorURL, serviceName string, opts ...Option) (*sdktrace.TracerProvider, error) { exp, err := NewRawExporter(collectorURL, serviceName, opts...) if err != nil { return nil, err } - tp := sdktrace.NewProvider(sdktrace.WithBatcher(exp)) + tp := sdktrace.NewTracerProvider(sdktrace.WithBatcher(exp)) if exp.o.config != nil { tp.ApplyConfig(*exp.o.config) } diff --git a/exporters/trace/zipkin/zipkin_test.go b/exporters/trace/zipkin/zipkin_test.go index 402e91bb803..f223938088c 100644 --- a/exporters/trace/zipkin/zipkin_test.go +++ b/exporters/trace/zipkin/zipkin_test.go @@ -48,7 +48,7 @@ func TestInstallNewPipeline(t *testing.T) { serviceName, ) assert.NoError(t, err) - assert.IsType(t, &sdktrace.Provider{}, global.TracerProvider()) + assert.IsType(t, &sdktrace.TracerProvider{}, global.TracerProvider()) } func TestNewExportPipeline(t *testing.T) { diff --git a/internal/trace/noop/noop.go b/internal/trace/noop/noop.go index bc02db11a1c..c09a7376cbb 100644 --- a/internal/trace/noop/noop.go +++ b/internal/trace/noop/noop.go @@ -30,6 +30,6 @@ var ( ) func init() { - Tracer = trace.NoopProvider().Tracer("") + Tracer = trace.NoopTracerProvider().Tracer("") _, Span = Tracer.Start(context.Background(), "") } diff --git a/sdk/metric/controller/pull/pull.go b/sdk/metric/controller/pull/pull.go index 15045314c74..23b98fd8489 100644 --- a/sdk/metric/controller/pull/pull.go +++ b/sdk/metric/controller/pull/pull.go @@ -30,13 +30,13 @@ import ( // will be returned without gathering metric data again. const DefaultCachePeriod time.Duration = 10 * time.Second -// Controller manages access to a *sdk.Accumulator and -// *basic.Processor. Use Provider() for obtaining Meters. Use -// Foreach() for accessing current records. +// Controller manages access to a *sdk.Accumulator and *basic.Processor. Use +// MeterProvider() for obtaining Meters. Use Foreach() for accessing current +// records. type Controller struct { accumulator *sdk.Accumulator checkpointer export.Checkpointer - provider *registry.Provider + provider *registry.MeterProvider period time.Duration lastCollect time.Time clock controllerTime.Clock @@ -65,7 +65,7 @@ func New(checkpointer export.Checkpointer, options ...Option) *Controller { return &Controller{ accumulator: accum, checkpointer: checkpointer, - provider: registry.NewProvider(accum), + provider: registry.NewMeterProvider(accum), period: config.CachePeriod, checkpoint: checkpointer.CheckpointSet(), clock: controllerTime.RealClock{}, @@ -79,9 +79,9 @@ func (c *Controller) SetClock(clock controllerTime.Clock) { c.clock = clock } -// Provider returns a metric.Provider for the implementation managed -// by this controller. -func (c *Controller) Provider() metric.Provider { +// MeterProvider returns a MeterProvider for the implementation managed by +// this controller. +func (c *Controller) MeterProvider() metric.MeterProvider { return c.provider } diff --git a/sdk/metric/controller/pull/pull_test.go b/sdk/metric/controller/pull/pull_test.go index f5a053b60ec..0a8f3aaa021 100644 --- a/sdk/metric/controller/pull/pull_test.go +++ b/sdk/metric/controller/pull/pull_test.go @@ -43,7 +43,7 @@ func TestPullNoCache(t *testing.T) { ) ctx := context.Background() - meter := puller.Provider().Meter("nocache") + meter := puller.MeterProvider().Meter("nocache") counter := metric.Must(meter).NewInt64Counter("counter.sum") counter.Add(ctx, 10, label.String("A", "B")) @@ -80,7 +80,7 @@ func TestPullWithCache(t *testing.T) { puller.SetClock(mock) ctx := context.Background() - meter := puller.Provider().Meter("nocache") + meter := puller.MeterProvider().Meter("nocache") counter := metric.Must(meter).NewInt64Counter("counter.sum") counter.Add(ctx, 10, label.String("A", "B")) diff --git a/sdk/metric/controller/push/push.go b/sdk/metric/controller/push/push.go index 056e636a840..7dd126c8e30 100644 --- a/sdk/metric/controller/push/push.go +++ b/sdk/metric/controller/push/push.go @@ -34,7 +34,7 @@ const DefaultPushPeriod = 10 * time.Second type Controller struct { lock sync.Mutex accumulator *sdk.Accumulator - provider *registry.Provider + provider *registry.MeterProvider checkpointer export.Checkpointer exporter export.Exporter wg sync.WaitGroup @@ -45,9 +45,9 @@ type Controller struct { ticker controllerTime.Ticker } -// New constructs a Controller, an implementation of metric.Provider, -// using the provided checkpointer, exporter, and options to configure -// an SDK with periodic collection. +// New constructs a Controller, an implementation of MeterProvider, using the +// provided checkpointer, exporter, and options to configure an SDK with +// periodic collection. func New(checkpointer export.Checkpointer, exporter export.Exporter, opts ...Option) *Controller { c := &Config{ Period: DefaultPushPeriod, @@ -64,7 +64,7 @@ func New(checkpointer export.Checkpointer, exporter export.Exporter, opts ...Opt sdk.WithResource(c.Resource), ) return &Controller{ - provider: registry.NewProvider(impl), + provider: registry.NewMeterProvider(impl), accumulator: impl, checkpointer: checkpointer, exporter: exporter, @@ -83,8 +83,8 @@ func (c *Controller) SetClock(clock controllerTime.Clock) { c.clock = clock } -// Provider returns a metric.Provider instance for this controller. -func (c *Controller) Provider() metric.Provider { +// MeterProvider returns a MeterProvider instance for this controller. +func (c *Controller) MeterProvider() metric.MeterProvider { return c.provider } diff --git a/sdk/metric/controller/push/push_test.go b/sdk/metric/controller/push/push_test.go index 0e656f69556..69c857e03dc 100644 --- a/sdk/metric/controller/push/push_test.go +++ b/sdk/metric/controller/push/push_test.go @@ -107,7 +107,7 @@ func TestPushTicker(t *testing.T) { push.WithPeriod(time.Second), push.WithResource(testResource), ) - meter := p.Provider().Meter("name") + meter := p.MeterProvider().Meter("name") mock := controllertest.NewMockClock() p.SetClock(mock) @@ -193,7 +193,7 @@ func TestPushExportError(t *testing.T) { ctx := context.Background() - meter := p.Provider().Meter("name") + meter := p.MeterProvider().Meter("name") counter1 := metric.Must(meter).NewInt64Counter("counter1.sum") counter2 := metric.Must(meter).NewInt64Counter("counter2.sum") diff --git a/sdk/trace/batch_span_processor_test.go b/sdk/trace/batch_span_processor_test.go index b0260d47f0c..74f81602b65 100644 --- a/sdk/trace/batch_span_processor_test.go +++ b/sdk/trace/batch_span_processor_test.go @@ -153,7 +153,7 @@ func TestNewBatchSpanProcessorWithOptions(t *testing.T) { for _, option := range options { t.Run(option.name, func(t *testing.T) { te := testBatchExporter{} - tp := basicProvider(t) + tp := basicTracerProvider(t) ssp := createAndRegisterBatchSP(option, &te) if ssp == nil { t.Fatalf("%s: Error creating new instance of BatchSpanProcessor\n", option.name) diff --git a/sdk/trace/benchmark_test.go b/sdk/trace/benchmark_test.go index 6f94de3780e..bf989fe1a35 100644 --- a/sdk/trace/benchmark_test.go +++ b/sdk/trace/benchmark_test.go @@ -166,6 +166,6 @@ func traceBenchmark(b *testing.B, name string, fn func(*testing.B, apitrace.Trac } func tracer(b *testing.B, name string, sampler sdktrace.Sampler) apitrace.Tracer { - tp := sdktrace.NewProvider(sdktrace.WithConfig(sdktrace.Config{DefaultSampler: sampler})) + tp := sdktrace.NewTracerProvider(sdktrace.WithConfig(sdktrace.Config{DefaultSampler: sampler})) return tp.Tracer(name) } diff --git a/sdk/trace/provider.go b/sdk/trace/provider.go index 056ef24fd50..e1ba09297d6 100644 --- a/sdk/trace/provider.go +++ b/sdk/trace/provider.go @@ -33,34 +33,34 @@ const ( // TODO (MrAlias): unify this API option design: // https://github.com/open-telemetry/opentelemetry-go/issues/536 -// ProviderOptions -type ProviderOptions struct { +// TracerProviderConfig +type TracerProviderConfig struct { processors []SpanProcessor config Config } -type ProviderOption func(*ProviderOptions) +type TracerProviderOption func(*TracerProviderConfig) -type Provider struct { +type TracerProvider struct { mu sync.Mutex namedTracer map[instrumentation.Library]*tracer spanProcessors atomic.Value config atomic.Value // access atomically } -var _ apitrace.Provider = &Provider{} +var _ apitrace.TracerProvider = &TracerProvider{} -// NewProvider creates an instance of trace provider. Optional +// NewTracerProvider creates an instance of trace provider. Optional // parameter configures the provider with common options applicable // to all tracer instances that will be created by this provider. -func NewProvider(opts ...ProviderOption) *Provider { - o := &ProviderOptions{} +func NewTracerProvider(opts ...TracerProviderOption) *TracerProvider { + o := &TracerProviderConfig{} for _, opt := range opts { opt(o) } - tp := &Provider{ + tp := &TracerProvider{ namedTracer: make(map[instrumentation.Library]*tracer), } tp.config.Store(&Config{ @@ -82,7 +82,7 @@ func NewProvider(opts ...ProviderOption) *Provider { // Tracer with the given name. If a tracer for the given name does not exist, // it is created first. If the name is empty, DefaultTracerName is used. -func (p *Provider) Tracer(name string, opts ...apitrace.TracerOption) apitrace.Tracer { +func (p *TracerProvider) Tracer(name string, opts ...apitrace.TracerOption) apitrace.Tracer { c := trace.NewTracerConfig(opts...) p.mu.Lock() @@ -106,7 +106,7 @@ func (p *Provider) Tracer(name string, opts ...apitrace.TracerOption) apitrace.T } // RegisterSpanProcessor adds the given SpanProcessor to the list of SpanProcessors -func (p *Provider) RegisterSpanProcessor(s SpanProcessor) { +func (p *TracerProvider) RegisterSpanProcessor(s SpanProcessor) { p.mu.Lock() defer p.mu.Unlock() new := make(spanProcessorMap) @@ -120,7 +120,7 @@ func (p *Provider) RegisterSpanProcessor(s SpanProcessor) { } // UnregisterSpanProcessor removes the given SpanProcessor from the list of SpanProcessors -func (p *Provider) UnregisterSpanProcessor(s SpanProcessor) { +func (p *TracerProvider) UnregisterSpanProcessor(s SpanProcessor) { p.mu.Lock() defer p.mu.Unlock() new := make(spanProcessorMap) @@ -140,7 +140,7 @@ func (p *Provider) UnregisterSpanProcessor(s SpanProcessor) { // ApplyConfig changes the configuration of the provider. // If a field in the configuration is empty or nil then its original value is preserved. -func (p *Provider) ApplyConfig(cfg Config) { +func (p *TracerProvider) ApplyConfig(cfg Config) { p.mu.Lock() defer p.mu.Unlock() c := *p.config.Load().(*Config) @@ -165,36 +165,36 @@ func (p *Provider) ApplyConfig(cfg Config) { p.config.Store(&c) } -// WithSyncer registers the exporter with the Provider using a +// WithSyncer registers the exporter with the TracerProvider using a // SimpleSpanProcessor. -func WithSyncer(e export.SpanExporter) ProviderOption { +func WithSyncer(e export.SpanExporter) TracerProviderOption { return WithSpanProcessor(NewSimpleSpanProcessor(e)) } -// WithBatcher registers the exporter with the Provider using a +// WithBatcher registers the exporter with the TracerProvider using a // BatchSpanProcessor configured with the passed opts. -func WithBatcher(e export.SpanExporter, opts ...BatchSpanProcessorOption) ProviderOption { +func WithBatcher(e export.SpanExporter, opts ...BatchSpanProcessorOption) TracerProviderOption { return WithSpanProcessor(NewBatchSpanProcessor(e, opts...)) } -// WithSpanProcessor registers the SpanProcessor with a Provider. -func WithSpanProcessor(sp SpanProcessor) ProviderOption { - return func(opts *ProviderOptions) { +// WithSpanProcessor registers the SpanProcessor with a TracerProvider. +func WithSpanProcessor(sp SpanProcessor) TracerProviderOption { + return func(opts *TracerProviderConfig) { opts.processors = append(opts.processors, sp) } } // WithConfig option sets the configuration to provider. -func WithConfig(config Config) ProviderOption { - return func(opts *ProviderOptions) { +func WithConfig(config Config) TracerProviderOption { + return func(opts *TracerProviderConfig) { opts.config = config } } // WithResource option attaches a resource to the provider. // The resource is added to the span when it is started. -func WithResource(r *resource.Resource) ProviderOption { - return func(opts *ProviderOptions) { +func WithResource(r *resource.Resource) TracerProviderOption { + return func(opts *TracerProviderConfig) { opts.config.Resource = r } } diff --git a/sdk/trace/simple_span_processor_test.go b/sdk/trace/simple_span_processor_test.go index 3ea2d70c68d..88b6ad5df59 100644 --- a/sdk/trace/simple_span_processor_test.go +++ b/sdk/trace/simple_span_processor_test.go @@ -51,7 +51,7 @@ func TestNewSimpleSpanProcessorWithNilExporter(t *testing.T) { } func TestSimpleSpanProcessorOnEnd(t *testing.T) { - tp := basicProvider(t) + tp := basicTracerProvider(t) te := testExporter{} ssp := sdktrace.NewSimpleSpanProcessor(&te) if ssp == nil { diff --git a/sdk/trace/span_processor_test.go b/sdk/trace/span_processor_test.go index 6a327ebd09a..24cf59f00fc 100644 --- a/sdk/trace/span_processor_test.go +++ b/sdk/trace/span_processor_test.go @@ -44,7 +44,7 @@ func (t *testSpanProcesor) ForceFlush() { func TestRegisterSpanProcessort(t *testing.T) { name := "Register span processor before span starts" - tp := basicProvider(t) + tp := basicTracerProvider(t) sp := NewTestSpanProcessor() tp.RegisterSpanProcessor(sp) @@ -64,7 +64,7 @@ func TestRegisterSpanProcessort(t *testing.T) { func TestUnregisterSpanProcessor(t *testing.T) { name := "Start span after unregistering span processor" - tp := basicProvider(t) + tp := basicTracerProvider(t) sp := NewTestSpanProcessor() tp.RegisterSpanProcessor(sp) @@ -91,7 +91,7 @@ func TestUnregisterSpanProcessor(t *testing.T) { func TestUnregisterSpanProcessorWhileSpanIsActive(t *testing.T) { name := "Unregister span processor while span is active" - tp := basicProvider(t) + tp := basicTracerProvider(t) sp := NewTestSpanProcessor() tp.RegisterSpanProcessor(sp) @@ -116,7 +116,7 @@ func TestUnregisterSpanProcessorWhileSpanIsActive(t *testing.T) { func TestSpanProcessorShutdown(t *testing.T) { name := "Increment shutdown counter of a span processor" - tp := basicProvider(t) + tp := basicTracerProvider(t) sp := NewTestSpanProcessor() if sp == nil { t.Fatalf("Error creating new instance of TestSpanProcessor\n") @@ -134,7 +134,7 @@ func TestSpanProcessorShutdown(t *testing.T) { func TestMultipleUnregisterSpanProcessorCalls(t *testing.T) { name := "Increment shutdown counter after first UnregisterSpanProcessor call" - tp := basicProvider(t) + tp := basicTracerProvider(t) sp := NewTestSpanProcessor() if sp == nil { t.Fatalf("Error creating new instance of TestSpanProcessor\n") diff --git a/sdk/trace/trace_test.go b/sdk/trace/trace_test.go index 8273a81a41f..91b1cfbedf6 100644 --- a/sdk/trace/trace_test.go +++ b/sdk/trace/trace_test.go @@ -60,7 +60,7 @@ func init() { } func TestTracerFollowsExpectedAPIBehaviour(t *testing.T) { - tp := NewProvider(WithConfig(Config{DefaultSampler: TraceIDRatioBased(0)})) + tp := NewTracerProvider(WithConfig(Config{DefaultSampler: TraceIDRatioBased(0)})) harness := apitest.NewHarness(t) subjectFactory := func() trace.Tracer { return tp.Tracer("") @@ -151,7 +151,7 @@ func (ts testSampler) Description() string { func TestSetName(t *testing.T) { fooSampler := &testSampler{prefix: "foo", t: t} - tp := NewProvider(WithConfig(Config{DefaultSampler: fooSampler})) + tp := NewTracerProvider(WithConfig(Config{DefaultSampler: fooSampler})) type testCase struct { name string @@ -206,7 +206,7 @@ func TestSetName(t *testing.T) { } func TestRecordingIsOn(t *testing.T) { - tp := NewProvider() + tp := NewTracerProvider() _, span := tp.Tracer("Recording on").Start(context.Background(), "StartSpan") defer span.End() if span.IsRecording() == false { @@ -259,7 +259,7 @@ func TestSampling(t *testing.T) { tc := tc t.Run(name, func(t *testing.T) { t.Parallel() - p := NewProvider(WithConfig(Config{DefaultSampler: tc.sampler})) + p := NewTracerProvider(WithConfig(Config{DefaultSampler: tc.sampler})) tr := p.Tracer("test") var sampled int for i := 0; i < total; i++ { @@ -297,7 +297,7 @@ func TestSampling(t *testing.T) { } func TestStartSpanWithParent(t *testing.T) { - tp := NewProvider() + tp := NewTracerProvider() tr := tp.Tracer("SpanWithParent") ctx := context.Background() @@ -341,7 +341,7 @@ func TestStartSpanWithParent(t *testing.T) { func TestSetSpanAttributesOnStart(t *testing.T) { te := NewTestExporter() - tp := NewProvider(WithSyncer(te)) + tp := NewTracerProvider(WithSyncer(te)) span := startSpan(tp, "StartSpanAttribute", apitrace.WithAttributes(label.String("key1", "value1")), @@ -374,7 +374,7 @@ func TestSetSpanAttributesOnStart(t *testing.T) { func TestSetSpanAttributes(t *testing.T) { te := NewTestExporter() - tp := NewProvider(WithSyncer(te)) + tp := NewTracerProvider(WithSyncer(te)) span := startSpan(tp, "SpanAttribute") span.SetAttributes(label.String("key1", "value1")) got, err := endSpan(te, span) @@ -404,7 +404,7 @@ func TestSetSpanAttributes(t *testing.T) { func TestSetSpanAttributesOverLimit(t *testing.T) { te := NewTestExporter() cfg := Config{MaxAttributesPerSpan: 2} - tp := NewProvider(WithConfig(cfg), WithSyncer(te)) + tp := NewTracerProvider(WithConfig(cfg), WithSyncer(te)) span := startSpan(tp, "SpanAttributesOverLimit") span.SetAttributes( @@ -441,7 +441,7 @@ func TestSetSpanAttributesOverLimit(t *testing.T) { func TestEvents(t *testing.T) { te := NewTestExporter() - tp := NewProvider(WithSyncer(te)) + tp := NewTracerProvider(WithSyncer(te)) span := startSpan(tp, "Events") k1v1 := label.String("key1", "value1") @@ -487,7 +487,7 @@ func TestEvents(t *testing.T) { func TestEventsOverLimit(t *testing.T) { te := NewTestExporter() cfg := Config{MaxEventsPerSpan: 2} - tp := NewProvider(WithConfig(cfg), WithSyncer(te)) + tp := NewTracerProvider(WithConfig(cfg), WithSyncer(te)) span := startSpan(tp, "EventsOverLimit") k1v1 := label.String("key1", "value1") @@ -538,7 +538,7 @@ func TestEventsOverLimit(t *testing.T) { func TestLinks(t *testing.T) { te := NewTestExporter() - tp := NewProvider(WithSyncer(te)) + tp := NewTracerProvider(WithSyncer(te)) k1v1 := label.String("key1", "value1") k2v2 := label.String("key2", "value2") @@ -583,7 +583,7 @@ func TestLinksOverLimit(t *testing.T) { sc2 := apitrace.SpanContext{TraceID: apitrace.ID([16]byte{1, 1}), SpanID: apitrace.SpanID{3}} sc3 := apitrace.SpanContext{TraceID: apitrace.ID([16]byte{1, 1}), SpanID: apitrace.SpanID{3}} - tp := NewProvider(WithConfig(cfg), WithSyncer(te)) + tp := NewTracerProvider(WithConfig(cfg), WithSyncer(te)) span := startSpan(tp, "LinksOverLimit", apitrace.WithLinks( @@ -624,7 +624,7 @@ func TestLinksOverLimit(t *testing.T) { func TestSetSpanName(t *testing.T) { te := NewTestExporter() - tp := NewProvider(WithSyncer(te)) + tp := NewTracerProvider(WithSyncer(te)) ctx := context.Background() want := "SpanName-1" @@ -646,7 +646,7 @@ func TestSetSpanName(t *testing.T) { func TestSetSpanStatus(t *testing.T) { te := NewTestExporter() - tp := NewProvider(WithSyncer(te)) + tp := NewTracerProvider(WithSyncer(te)) span := startSpan(tp, "SpanStatus") span.SetStatus(otelcodes.Canceled, "canceled") @@ -712,7 +712,7 @@ func checkChild(p apitrace.SpanContext, apiSpan apitrace.Span) error { // startSpan starts a span with a name "span0". See startNamedSpan for // details. -func startSpan(tp *Provider, trName string, args ...apitrace.SpanOption) apitrace.Span { +func startSpan(tp *TracerProvider, trName string, args ...apitrace.SpanOption) apitrace.Span { return startNamedSpan(tp, trName, "span0", args...) } @@ -720,7 +720,7 @@ func startSpan(tp *Provider, trName string, args ...apitrace.SpanOption) apitrac // passed name and with remote span context as parent. The remote span // context contains TraceFlags with sampled bit set. This allows the // span to be automatically sampled. -func startNamedSpan(tp *Provider, trName, name string, args ...apitrace.SpanOption) apitrace.Span { +func startNamedSpan(tp *TracerProvider, trName, name string, args ...apitrace.SpanOption) apitrace.Span { ctx := context.Background() ctx = apitrace.ContextWithRemoteSpanContext(ctx, remoteSpanContext()) args = append(args, apitrace.WithRecord()) @@ -777,7 +777,7 @@ func checkTime(x *time.Time) bool { func TestEndSpanTwice(t *testing.T) { te := NewTestExporter() - tp := NewProvider(WithSyncer(te)) + tp := NewTracerProvider(WithSyncer(te)) span := startSpan(tp, "EndSpanTwice") span.End() @@ -789,7 +789,7 @@ func TestEndSpanTwice(t *testing.T) { func TestStartSpanAfterEnd(t *testing.T) { te := NewTestExporter() - tp := NewProvider(WithConfig(Config{DefaultSampler: AlwaysSample()}), WithSyncer(te)) + tp := NewTracerProvider(WithConfig(Config{DefaultSampler: AlwaysSample()}), WithSyncer(te)) ctx := context.Background() tr := tp.Tracer("SpanAfterEnd") @@ -834,7 +834,7 @@ func TestStartSpanAfterEnd(t *testing.T) { func TestChildSpanCount(t *testing.T) { te := NewTestExporter() - tp := NewProvider(WithConfig(Config{DefaultSampler: AlwaysSample()}), WithSyncer(te)) + tp := NewTracerProvider(WithConfig(Config{DefaultSampler: AlwaysSample()}), WithSyncer(te)) tr := tp.Tracer("ChidSpanCount") ctx, span0 := tr.Start(context.Background(), "parent") @@ -888,7 +888,7 @@ func TestNilSpanEnd(t *testing.T) { func TestExecutionTracerTaskEnd(t *testing.T) { var n uint64 - tp := NewProvider(WithConfig(Config{DefaultSampler: NeverSample()})) + tp := NewTracerProvider(WithConfig(Config{DefaultSampler: NeverSample()})) tr := tp.Tracer("Execution Tracer Task End") executionTracerTaskEnd := func() { @@ -937,7 +937,7 @@ func TestExecutionTracerTaskEnd(t *testing.T) { func TestCustomStartEndTime(t *testing.T) { te := NewTestExporter() - tp := NewProvider(WithSyncer(te), WithConfig(Config{DefaultSampler: AlwaysSample()})) + tp := NewTracerProvider(WithSyncer(te), WithConfig(Config{DefaultSampler: AlwaysSample()})) startTime := time.Date(2019, time.August, 27, 14, 42, 0, 0, time.UTC) endTime := startTime.Add(time.Second * 20) @@ -980,7 +980,7 @@ func TestRecordError(t *testing.T) { for _, s := range scenarios { te := NewTestExporter() - tp := NewProvider(WithSyncer(te)) + tp := NewTracerProvider(WithSyncer(te)) span := startSpan(tp, "RecordError") errTime := time.Now() @@ -1022,7 +1022,7 @@ func TestRecordError(t *testing.T) { func TestRecordErrorWithStatus(t *testing.T) { te := NewTestExporter() - tp := NewProvider(WithSyncer(te)) + tp := NewTracerProvider(WithSyncer(te)) span := startSpan(tp, "RecordErrorWithStatus") testErr := ottest.NewTestError("test error") @@ -1068,7 +1068,7 @@ func TestRecordErrorWithStatus(t *testing.T) { func TestRecordErrorNil(t *testing.T) { te := NewTestExporter() - tp := NewProvider(WithSyncer(te)) + tp := NewTracerProvider(WithSyncer(te)) span := startSpan(tp, "RecordErrorNil") span.RecordError(context.Background(), nil) @@ -1098,7 +1098,7 @@ func TestRecordErrorNil(t *testing.T) { func TestWithSpanKind(t *testing.T) { te := NewTestExporter() - tp := NewProvider(WithSyncer(te), WithConfig(Config{DefaultSampler: AlwaysSample()})) + tp := NewTracerProvider(WithSyncer(te), WithConfig(Config{DefaultSampler: AlwaysSample()})) tr := tp.Tracer("withSpanKind") _, span := tr.Start(context.Background(), "WithoutSpanKind") @@ -1136,7 +1136,7 @@ func TestWithSpanKind(t *testing.T) { func TestWithResource(t *testing.T) { te := NewTestExporter() - tp := NewProvider(WithSyncer(te), + tp := NewTracerProvider(WithSyncer(te), WithConfig(Config{DefaultSampler: AlwaysSample()}), WithResource(resource.New(label.String("rk1", "rv1"), label.Int64("rk2", 5)))) span := startSpan(tp, "WithResource") @@ -1168,7 +1168,7 @@ func TestWithResource(t *testing.T) { func TestWithInstrumentationVersion(t *testing.T) { te := NewTestExporter() - tp := NewProvider(WithSyncer(te)) + tp := NewTracerProvider(WithSyncer(te)) ctx := context.Background() ctx = apitrace.ContextWithRemoteSpanContext(ctx, remoteSpanContext()) @@ -1202,7 +1202,7 @@ func TestWithInstrumentationVersion(t *testing.T) { func TestSpanCapturesPanic(t *testing.T) { te := NewTestExporter() - tp := NewProvider(WithSyncer(te)) + tp := NewTracerProvider(WithSyncer(te)) _, span := tp.Tracer("CatchPanic").Start( context.Background(), "span", diff --git a/sdk/trace/tracer.go b/sdk/trace/tracer.go index d03d7392315..e05b427e0a6 100644 --- a/sdk/trace/tracer.go +++ b/sdk/trace/tracer.go @@ -23,7 +23,7 @@ import ( ) type tracer struct { - provider *Provider + provider *TracerProvider instrumentationLibrary instrumentation.Library } diff --git a/sdk/trace/util_test.go b/sdk/trace/util_test.go index ade02fede4b..4354199f5d2 100644 --- a/sdk/trace/util_test.go +++ b/sdk/trace/util_test.go @@ -22,7 +22,7 @@ import ( var testConfig = sdktrace.Config{DefaultSampler: sdktrace.AlwaysSample()} -func basicProvider(t *testing.T) *sdktrace.Provider { - tp := sdktrace.NewProvider(sdktrace.WithConfig(testConfig)) +func basicTracerProvider(t *testing.T) *sdktrace.TracerProvider { + tp := sdktrace.NewTracerProvider(sdktrace.WithConfig(testConfig)) return tp }