[API EPIC 3/4] SDK Wrapper

sdk/metric/controller/basic/controller.go

@@ -27,6 +27,7 @@ import (
 	controllerTime "go.opentelemetry.io/otel/sdk/metric/controller/time"
 	"go.opentelemetry.io/otel/sdk/metric/export"
 	"go.opentelemetry.io/otel/sdk/metric/registry"
+	"go.opentelemetry.io/otel/sdk/metric/sdkapi"
 	"go.opentelemetry.io/otel/sdk/resource"
 )
 
@@ -99,7 +100,7 @@ func (c *Controller) Meter(instrumentationName string, opts ...metric.MeterOptio
 				library:      library,
 			}))
 	}
-	return metric.WrapMeterImpl(m.(*registry.UniqueInstrumentMeterImpl))
+	return sdkapi.WrapMeterImpl(m.(*registry.UniqueInstrumentMeterImpl))
 }
 
 type accumulatorCheckpointer struct {
@@ -108,6 +109,8 @@ type accumulatorCheckpointer struct {
 	library      instrumentation.Library
 }
 
+var _ sdkapi.MeterImpl = &accumulatorCheckpointer{}
+
 // New constructs a Controller using the provided checkpointer factory
 // and options (including optional exporter) to configure a metric
 // export pipeline.

sdk/metric/controller/basic/controller_test.go

@@ -25,7 +25,7 @@ import (
 
 	"go.opentelemetry.io/otel/attribute"
 	ottest "go.opentelemetry.io/otel/internal/internaltest"
-	"go.opentelemetry.io/otel/metric"
+	"go.opentelemetry.io/otel/metric/instrument"
 	"go.opentelemetry.io/otel/sdk/instrumentation"
 	controller "go.opentelemetry.io/otel/sdk/metric/controller/basic"
 	"go.opentelemetry.io/otel/sdk/metric/controller/controllertest"
@@ -127,7 +127,7 @@ func TestControllerUsesResource(t *testing.T) {
 			ctx := context.Background()
 			require.NoError(t, cont.Start(ctx))
 
-			ctr := metric.Must(cont.Meter("named")).NewFloat64Counter("calls.sum")
+			ctr, _ := cont.Meter("named").SyncFloat64().Counter("calls.sum")
 			ctr.Add(context.Background(), 1.)
 
 			// Collect once
@@ -152,16 +152,19 @@ func TestStartNoExporter(t *testing.T) {
 	)
 	mock := controllertest.NewMockClock()
 	cont.SetClock(mock)
+	meter := cont.Meter("go.opentelemetry.io/otel/sdk/metric/controller/basic_test#StartNoExporter")
 
 	calls := int64(0)
 
-	_ = metric.Must(cont.Meter("named")).NewInt64CounterObserver("calls.lastvalue",
-		func(ctx context.Context, result metric.Int64ObserverResult) {
-			calls++
-			checkTestContext(t, ctx)
-			result.Observe(calls, attribute.String("A", "B"))
-		},
-	)
+	counterObserver, err := meter.AsyncInt64().Counter("calls.lastvalue")
+	require.NoError(t, err)
+
+	err = meter.RegisterCallback([]instrument.Asynchronous{counterObserver}, func(ctx context.Context) {
+		calls++
+		checkTestContext(t, ctx)
+		counterObserver.Observe(ctx, calls, attribute.String("A", "B"))
+	})
+	require.NoError(t, err)
 
 	// Collect() has not been called.  The controller is unstarted.
 	expect := map[string]float64{}
@@ -220,18 +223,22 @@ func TestObserverCanceled(t *testing.T) {
 		controller.WithCollectTimeout(time.Millisecond),
 		controller.WithResource(resource.Empty()),
 	)
+	meter := cont.Meter("go.opentelemetry.io/otel/sdk/metric/controller/basic_test#ObserverCanceled")
 
 	calls := int64(0)
 
-	_ = metric.Must(cont.Meter("named")).NewInt64CounterObserver("done.lastvalue",
-		func(ctx context.Context, result metric.Int64ObserverResult) {
-			<-ctx.Done()
-			calls++
-			result.Observe(calls)
-		},
-	)
+	counterObserver, err := meter.AsyncInt64().Counter("done.lastvalue")
+	require.NoError(t, err)
+
+	err = meter.RegisterCallback([]instrument.Asynchronous{counterObserver}, func(ctx context.Context) {
+		<-ctx.Done()
+		calls++
+		counterObserver.Observe(ctx, calls)
+	})
+	require.NoError(t, err)
+
 	// This relies on the context timing out
-	err := cont.Collect(context.Background())
+	err = cont.Collect(context.Background())
 	require.Error(t, err)
 	require.True(t, errors.Is(err, context.DeadlineExceeded))
 
@@ -251,14 +258,18 @@ func TestObserverContext(t *testing.T) {
 		controller.WithCollectTimeout(0),
 		controller.WithResource(resource.Empty()),
 	)
+	meter := cont.Meter("go.opentelemetry.io/otel/sdk/metric/controller/basic_test#ObserverContext")
+
+	counterObserver, err := meter.AsyncInt64().Counter("done.lastvalue")
+	require.NoError(t, err)
+
+	err = meter.RegisterCallback([]instrument.Asynchronous{counterObserver}, func(ctx context.Context) {
+		time.Sleep(10 * time.Millisecond)
+		checkTestContext(t, ctx)
+		counterObserver.Observe(ctx, 1)
+	})
+	require.NoError(t, err)
 
-	_ = metric.Must(cont.Meter("named")).NewInt64CounterObserver("done.lastvalue",
-		func(ctx context.Context, result metric.Int64ObserverResult) {
-			time.Sleep(10 * time.Millisecond)
-			checkTestContext(t, ctx)
-			result.Observe(1)
-		},
-	)
 	ctx := testContext()
 
 	require.NoError(t, cont.Collect(ctx))
@@ -314,14 +325,17 @@ func TestExportTimeout(t *testing.T) {
 	)
 	mock := controllertest.NewMockClock()
 	cont.SetClock(mock)
+	meter := cont.Meter("go.opentelemetry.io/otel/sdk/metric/controller/basic_test#ExportTimeout")
 
 	calls := int64(0)
-	_ = metric.Must(cont.Meter("named")).NewInt64CounterObserver("one.lastvalue",
-		func(ctx context.Context, result metric.Int64ObserverResult) {
-			calls++
-			result.Observe(calls)
-		},
-	)
+	counterObserver, err := meter.AsyncInt64().Counter("one.lastvalue")
+	require.NoError(t, err)
+
+	err = meter.RegisterCallback([]instrument.Asynchronous{counterObserver}, func(ctx context.Context) {
+		calls++
+		counterObserver.Observe(ctx, calls)
+	})
+	require.NoError(t, err)
 
 	require.NoError(t, cont.Start(context.Background()))
 
@@ -332,7 +346,7 @@ func TestExportTimeout(t *testing.T) {
 	// Collect after 1s, timeout
 	mock.Add(time.Second)
 
-	err := testHandler.Flush()
+	err = testHandler.Flush()
 	require.Error(t, err)
 	require.True(t, errors.Is(err, context.DeadlineExceeded))
 
@@ -369,13 +383,17 @@ func TestCollectAfterStopThenStartAgain(t *testing.T) {
 	mock := controllertest.NewMockClock()
 	cont.SetClock(mock)
 
+	meter := cont.Meter("go.opentelemetry.io/otel/sdk/metric/controller/basic_test#CollectAfterStopThenStartAgain")
+
 	calls := 0
-	_ = metric.Must(cont.Meter("named")).NewInt64CounterObserver("one.lastvalue",
-		func(ctx context.Context, result metric.Int64ObserverResult) {
-			calls++
-			result.Observe(int64(calls))
-		},
-	)
+	counterObserver, err := meter.AsyncInt64().Counter("one.lastvalue")
+	require.NoError(t, err)
+
+	err = meter.RegisterCallback([]instrument.Asynchronous{counterObserver}, func(ctx context.Context) {
+		calls++
+		counterObserver.Observe(ctx, int64(calls))
+	})
+	require.NoError(t, err)
 
 	// No collections happen (because mock clock does not advance):
 	require.NoError(t, cont.Start(context.Background()))
@@ -403,7 +421,7 @@ func TestCollectAfterStopThenStartAgain(t *testing.T) {
 	// explicit collection should still fail.
 	require.NoError(t, cont.Start(context.Background()))
 	require.True(t, cont.IsRunning())
-	err := cont.Collect(context.Background())
+	err = cont.Collect(context.Background())
 	require.Error(t, err)
 	require.Equal(t, controller.ErrControllerStarted, err)
 
@@ -452,10 +470,10 @@ func TestRegistryFunction(t *testing.T) {
 	require.NotNil(t, m1)
 	require.Equal(t, m1, m2)
 
-	c1, err := m1.NewInt64Counter("counter.sum")
+	c1, err := m1.SyncInt64().Counter("counter.sum")
 	require.NoError(t, err)
 
-	c2, err := m1.NewInt64Counter("counter.sum")
+	c2, err := m1.SyncInt64().Counter("counter.sum")
 	require.NoError(t, err)
 
 	require.Equal(t, c1, c2)

sdk/metric/controller/basic/pull_test.go

@@ -21,9 +21,7 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/require"
-
 	"go.opentelemetry.io/otel/attribute"
-	"go.opentelemetry.io/otel/metric"
 	controller "go.opentelemetry.io/otel/sdk/metric/controller/basic"
 	"go.opentelemetry.io/otel/sdk/metric/controller/controllertest"
 	"go.opentelemetry.io/otel/sdk/metric/export/aggregation"
@@ -45,7 +43,8 @@ func TestPullNoCollect(t *testing.T) {
 
 	ctx := context.Background()
 	meter := puller.Meter("nocache")
-	counter := metric.Must(meter).NewInt64Counter("counter.sum")
+	counter, err := meter.SyncInt64().Counter("counter.sum")
+	require.NoError(t, err)
 
 	counter.Add(ctx, 10, attribute.String("A", "B"))
 
@@ -83,7 +82,8 @@ func TestPullWithCollect(t *testing.T) {
 
 	ctx := context.Background()
 	meter := puller.Meter("nocache")
-	counter := metric.Must(meter).NewInt64Counter("counter.sum")
+	counter, err := meter.SyncInt64().Counter("counter.sum")
+	require.NoError(t, err)
 
 	counter.Add(ctx, 10, attribute.String("A", "B"))
 

sdk/metric/controller/basic/push_test.go

@@ -27,7 +27,6 @@ import (
 
 	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/attribute"
-	"go.opentelemetry.io/otel/metric"
 	controller "go.opentelemetry.io/otel/sdk/metric/controller/basic"
 	"go.opentelemetry.io/otel/sdk/metric/controller/controllertest"
 	"go.opentelemetry.io/otel/sdk/metric/export"
@@ -117,7 +116,8 @@ func TestPushTicker(t *testing.T) {
 
 	ctx := context.Background()
 
-	counter := metric.Must(meter).NewInt64Counter("counter.sum")
+	counter, err := meter.SyncInt64().Counter("counter.sum")
+	require.NoError(t, err)
 
 	require.NoError(t, p.Start(ctx))
 
@@ -197,8 +197,10 @@ func TestPushExportError(t *testing.T) {
 			ctx := context.Background()
 
 			meter := p.Meter("name")
-			counter1 := metric.Must(meter).NewInt64Counter("counter1.sum")
-			counter2 := metric.Must(meter).NewInt64Counter("counter2.sum")
+			counter1, err := meter.SyncInt64().Counter("counter1.sum")
+			require.NoError(t, err)
+			counter2, err := meter.SyncInt64().Counter("counter2.sum")
+			require.NoError(t, err)
 
 			require.NoError(t, p.Start(ctx))
 			runtime.Gosched()

sdk/metric/processor/basic/basic_test.go

@@ -25,7 +25,7 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"go.opentelemetry.io/otel/attribute"
-	"go.opentelemetry.io/otel/metric"
+	"go.opentelemetry.io/otel/metric/instrument"
 	"go.opentelemetry.io/otel/sdk/instrumentation"
 	sdk "go.opentelemetry.io/otel/sdk/metric"
 	"go.opentelemetry.io/otel/sdk/metric/aggregator"
@@ -450,15 +450,16 @@ func TestCounterObserverEndToEnd(t *testing.T) {
 		eselector,
 	)
 	accum := sdk.NewAccumulator(proc)
-	meter := metric.WrapMeterImpl(accum)
+	meter := sdkapi.WrapMeterImpl(accum)
 
 	var calls int64
-	metric.Must(meter).NewInt64CounterObserver("observer.sum",
-		func(_ context.Context, result metric.Int64ObserverResult) {
-			calls++
-			result.Observe(calls)
-		},
-	)
+	ctr, err := meter.AsyncInt64().Counter("observer.sum")
+	require.NoError(t, err)
+	err = meter.RegisterCallback([]instrument.Asynchronous{ctr}, func(ctx context.Context) {
+		calls++
+		ctr.Observe(ctx, calls)
+	})
+	require.NoError(t, err)
 	reader := proc.Reader()
 
 	var startTime [3]time.Time