Remove the push controller named Meter map (#738)

* Remove the push controller named Meter map

* Checkpoint

* Remove Provider impls

* Add a test

* Expose Provider() getter instead of implementing the interface

api/global/internal/meter_test.go

@@ -407,7 +407,7 @@ func TestRecordBatchRealSDK(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	global.SetMeterProvider(pusher)
+	global.SetMeterProvider(pusher.Provider())
 
 	meter.RecordBatch(context.Background(), nil, counter.Measurement(1))
 	pusher.Stop()

api/metric/registry/registry.go

@@ -23,6 +23,13 @@ import (
 	"go.opentelemetry.io/otel/api/metric"
 )
 
+// Provider is a standard metric.Provider for wrapping `MeterImpl`
+type Provider struct {
+	impl metric.MeterImpl
+}
+
+var _ metric.Provider = (*Provider)(nil)
+
 // uniqueInstrumentMeterImpl implements the metric.MeterImpl interface, adding
 // uniqueness checking for instrument descriptors.  Use NewUniqueInstrumentMeter
 // to wrap an implementation with uniqueness checking.
@@ -39,6 +46,19 @@ type key struct {
 	libraryName string
 }
 
+// NewProvider returns a new provider that implements instrument
+// name-uniqueness checking.
+func NewProvider(impl metric.MeterImpl) *Provider {
+	return &Provider{
+		impl: NewUniqueInstrumentMeterImpl(impl),
+	}
+}
+
+// Meter implements metric.Provider.
+func (p *Provider) Meter(name string) metric.Meter {
+	return metric.WrapMeterImpl(p.impl, name)
+}
+
 // ErrMetricKindMismatch is the standard error for mismatched metric
 // instrument definitions.
 var ErrMetricKindMismatch = fmt.Errorf(

api/metric/registry/registry_test.go

@@ -118,3 +118,14 @@ func TestRegistryDiffInstruments(t *testing.T) {
 		}
 	}
 }
+
+func TestProvider(t *testing.T) {
+	impl, _ := mockTest.NewMeter()
+	p := registry.NewProvider(impl)
+	m1 := p.Meter("m1")
+	m1p := p.Meter("m1")
+	m2 := p.Meter("m2")
+
+	require.Equal(t, m1, m1p)
+	require.NotEqual(t, m1, m2)
+}

exporters/metric/prometheus/prometheus.go

@@ -140,7 +140,7 @@ func InstallNewPipeline(config Config) (*push.Controller, http.HandlerFunc, erro
 	if err != nil {
 		return controller, hf, err
 	}
-	global.SetMeterProvider(controller)
+	global.SetMeterProvider(controller.Provider())
 	return controller, hf, err
 }
 

exporters/metric/stdout/example_test.go

@@ -38,7 +38,7 @@ func ExampleNewExportPipeline() {
 	ctx := context.Background()
 
 	key := kv.Key("key")
-	meter := pusher.Meter("example")
+	meter := pusher.Provider().Meter("example")
 
 	// Create and update a single counter:
 	counter := metric.Must(meter).NewInt64Counter("a.counter")

exporters/metric/stdout/stdout.go

@@ -126,7 +126,7 @@ func InstallNewPipeline(config Config, opts ...push.Option) (*push.Controller, e
 	if err != nil {
 		return controller, err
 	}
-	global.SetMeterProvider(controller)
+	global.SetMeterProvider(controller.Provider())
 	return controller, err
 }
 

exporters/otlp/otlp_integration_test.go

@@ -115,7 +115,7 @@ func newExporterEndToEndTest(t *testing.T, additionalOpts []otlp.ExporterOption)
 	pusher.Start()
 
 	ctx := context.Background()
-	meter := pusher.Meter("test-meter")
+	meter := pusher.Provider().Meter("test-meter")
 	labels := []kv.KeyValue{kv.Bool("test", true)}
 
 	type data struct {

internal/metric/mock.go

@@ -38,13 +38,6 @@ type (
 		LibraryName  string
 	}
 
-	MeterProvider struct {
-		lock       sync.Mutex
-		impl       *MeterImpl
-		unique     metric.MeterImpl
-		registered map[string]apimetric.Meter
-	}
-
 	MeterImpl struct {
 		lock sync.Mutex
 
@@ -123,24 +116,7 @@ func NewProvider() (*MeterImpl, apimetric.Provider) {
 	impl := &MeterImpl{
 		asyncInstruments: NewAsyncInstrumentState(nil),
 	}
-	p := &MeterProvider{
-		impl:       impl,
-		unique:     registry.NewUniqueInstrumentMeterImpl(impl),
-		registered: map[string]apimetric.Meter{},
-	}
-	return impl, p
-}
-
-func (p *MeterProvider) Meter(name string) apimetric.Meter {
-	p.lock.Lock()
-	defer p.lock.Unlock()
-
-	if lookup, ok := p.registered[name]; ok {
-		return lookup
-	}
-	m := apimetric.WrapMeterImpl(p.unique, name)
-	p.registered[name] = m
-	return m
+	return impl, registry.NewProvider(impl)
 }
 
 func NewMeter() (*MeterImpl, apimetric.Meter) {

sdk/metric/controller/push/push.go

@@ -32,8 +32,6 @@ type Controller struct {
 	collectLock  sync.Mutex
 	accumulator  *sdk.Accumulator
 	resource     *resource.Resource
-	uniq         metric.MeterImpl
-	named        map[string]metric.Meter
 	errorHandler sdk.ErrorHandler
 	integrator   export.Integrator
 	exporter     export.Exporter
@@ -42,10 +40,9 @@ type Controller struct {
 	period       time.Duration
 	ticker       Ticker
 	clock        Clock
+	provider     *registry.Provider
 }
 
-var _ metric.Provider = &Controller{}
-
 // Several types below are created to match "github.com/benbjohnson/clock"
 // so that it remains a test-only dependency.
 
@@ -83,8 +80,7 @@ func New(integrator export.Integrator, exporter export.Exporter, period time.Dur
 	return &Controller{
 		accumulator:  impl,
 		resource:     c.Resource,
-		uniq:         registry.NewUniqueInstrumentMeterImpl(impl),
-		named:        map[string]metric.Meter{},
+		provider:     registry.NewProvider(impl),
 		errorHandler: c.ErrorHandler,
 		integrator:   integrator,
 		exporter:     exporter,
@@ -102,6 +98,8 @@ func (c *Controller) SetClock(clock Clock) {
 	c.clock = clock
 }
 
+// SetErrorHandler sets the handler for errors.  If none has been set, the
+// SDK default error handler is used.
 func (c *Controller) SetErrorHandler(errorHandler sdk.ErrorHandler) {
 	c.lock.Lock()
 	defer c.lock.Unlock()
@@ -109,19 +107,9 @@ func (c *Controller) SetErrorHandler(errorHandler sdk.ErrorHandler) {
 	c.accumulator.SetErrorHandler(errorHandler)
 }
 
-// Meter returns a named Meter, satisifying the metric.Provider
-// interface.
-func (c *Controller) Meter(name string) metric.Meter {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-
-	if meter, ok := c.named[name]; ok {
-		return meter
-	}
-
-	meter := metric.WrapMeterImpl(c.uniq, name)
-	c.named[name] = meter
-	return meter
+// Provider returns a metric.Provider instance for this controller.
+func (c *Controller) Provider() metric.Provider {
+	return c.provider
 }
 
 // Start begins a ticker that periodically collects and exports

sdk/metric/controller/push/push_test.go

@@ -183,7 +183,7 @@ func TestPushTicker(t *testing.T) {
 	fix := newFixture(t)
 
 	p := push.New(fix.integrator, fix.exporter, time.Second)
-	meter := p.Meter("name")
+	meter := p.Provider().Meter("name")
 
 	mock := mockClock{clock.NewMock()}
 	p.SetClock(mock)
@@ -280,7 +280,7 @@ func TestPushExportError(t *testing.T) {
 
 			ctx := context.Background()
 
-			meter := p.Meter("name")
+			meter := p.Provider().Meter("name")
 			counter1 := metric.Must(meter).NewInt64Counter("counter1")
 			counter2 := metric.Must(meter).NewInt64Counter("counter2")
 

sdk/metric/example_test.go

@@ -38,7 +38,7 @@ func ExampleNew() {
 	ctx := context.Background()
 
 	key := kv.Key("key")
-	meter := pusher.Meter("example")
+	meter := pusher.Provider().Meter("example")
 
 	counter := metric.Must(meter).NewInt64Counter("a.counter")