re-enable tests with NewSDK

Signed-off-by: alex boten <[email protected]>

Author: codeboten

otelconf/log_test.go

@@ -713,33 +713,27 @@ func TestLoggerProviderOptions(t *testing.T) {
 	require.NoError(t, err)
 
 	res := resource.NewSchemaless(attribute.String("foo", "bar"))
-	// TODO: re-enable this once NewSDK is added
-	// sdk, err := NewSDK(
-	// 	WithOpenTelemetryConfiguration(cfg),
-	// 	WithLoggerProviderOptions(sdklog.WithProcessor(sdklog.NewSimpleProcessor(stdoutlogExporter))),
-	// 	WithLoggerProviderOptions(sdklog.WithResource(res)),
-	// )
-	lp, shutdown, err := loggerProvider(configOptions{
-		opentelemetryConfig:   cfg,
-		loggerProviderOptions: []sdklog.LoggerProviderOption{sdklog.WithProcessor(sdklog.NewSimpleProcessor(stdoutlogExporter))},
-	}, res)
+	sdk, err := NewSDK(
+		WithOpenTelemetryConfiguration(cfg),
+		WithLoggerProviderOptions(sdklog.WithProcessor(sdklog.NewSimpleProcessor(stdoutlogExporter))),
+		WithLoggerProviderOptions(sdklog.WithResource(res)),
+	)
 	require.NoError(t, err)
 	defer func() {
-		assert.NoError(t, shutdown(t.Context()))
+		assert.NoError(t, sdk.Shutdown(t.Context()))
 	}()
 
 	// The exporter, which we passed in as an extra option to NewSDK,
 	// should be wired up to the provider in addition to the
 	// configuration-based OTLP exporter.
-	logger := lp.Logger("test")
+	logger := sdk.LoggerProvider().Logger("test")
 	logger.Emit(t.Context(), log.Record{})
 	assert.NotZero(t, buf)
 	assert.Equal(t, 1, calls)
 	// Options provided by WithMeterProviderOptions may be overridden
 	// by configuration, e.g. the resource is always defined via
 	// configuration.
-	// TODO: re-enable this once NewSDK is added
-	// assert.NotContains(t, buf.String(), "foo")
+	assert.NotContains(t, buf.String(), "foo")
 }
 
 func Test_otlpGRPCLogExporter(t *testing.T) {

otelconf/metric_test.go

@@ -139,19 +139,14 @@ func TestMeterProviderOptions(t *testing.T) {
 	require.NoError(t, err)
 
 	res := resource.NewSchemaless(attribute.String("foo", "bar"))
-	// TODO: re-enable this once NewSDK is added
-	// sdk, err := NewSDK(
-	// 	WithOpenTelemetryConfiguration(cfg),
-	// 	WithMeterProviderOptions(sdkmetric.WithReader(sdkmetric.NewPeriodicReader(stdoutmetricExporter))),
-	// 	WithMeterProviderOptions(sdkmetric.WithResource(res)),
-	// )
-	mp, shutdown, err := meterProvider(configOptions{
-		opentelemetryConfig:  cfg,
-		meterProviderOptions: []sdkmetric.Option{sdkmetric.WithReader(sdkmetric.NewPeriodicReader(stdoutmetricExporter))},
-	}, res)
+	sdk, err := NewSDK(
+		WithOpenTelemetryConfiguration(cfg),
+		WithMeterProviderOptions(sdkmetric.WithReader(sdkmetric.NewPeriodicReader(stdoutmetricExporter))),
+		WithMeterProviderOptions(sdkmetric.WithResource(res)),
+	)
 	require.NoError(t, err)
 	defer func() {
-		assert.NoError(t, shutdown(t.Context()))
+		assert.NoError(t, sdk.Shutdown(t.Context()))
 		// The exporter, which we passed in as an extra option to NewSDK,
 		// should be wired up to the provider in addition to the
 		// configuration-based OTLP exporter.
@@ -161,11 +156,10 @@ func TestMeterProviderOptions(t *testing.T) {
 		// Options provided by WithMeterProviderOptions may be overridden
 		// by configuration, e.g. the resource is always defined via
 		// configuration.
-		// TODO: re-enable this once NewSDK is added
-		// assert.NotContains(t, buf.String(), "foo")
+		assert.NotContains(t, buf.String(), "foo")
 	}()
 
-	counter, _ := mp.Meter("test").Int64Counter("counter")
+	counter, _ := sdk.MeterProvider().Meter("test").Int64Counter("counter")
 	counter.Add(t.Context(), 1)
 }
 

otelconf/trace_test.go

@@ -157,35 +157,28 @@ func TestTracerProviderOptions(t *testing.T) {
 	require.NoError(t, err)
 
 	res := resource.NewSchemaless(attribute.String("foo", "bar"))
-	// TODO: re-enable this once NewSDK is added
-	// sdk, err := NewSDK(
-	// 	WithOpenTelemetryConfiguration(cfg),
-	// 	WithTracerProviderOptions(sdktrace.WithSyncer(stdouttraceExporter)),
-	// 	WithTracerProviderOptions(sdktrace.WithResource(res)),
-	// )
-	tp, shutdown, err := tracerProvider(configOptions{
-		ctx:                   t.Context(),
-		opentelemetryConfig:   cfg,
-		tracerProviderOptions: []sdktrace.TracerProviderOption{sdktrace.WithSyncer(stdouttraceExporter)},
-	}, res)
+	sdk, err := NewSDK(
+		WithOpenTelemetryConfiguration(cfg),
+		WithTracerProviderOptions(sdktrace.WithSyncer(stdouttraceExporter)),
+		WithTracerProviderOptions(sdktrace.WithResource(res)),
+	)
 	require.NoError(t, err)
 	defer func() {
-		assert.NoError(t, shutdown(t.Context()))
+		assert.NoError(t, sdk.Shutdown(t.Context()))
 	}()
 
 	// The exporter, which we passed in as an extra option to NewSDK,
 	// should be wired up to the provider in addition to the
 	// configuration-based OTLP exporter.
-	tracer := tp.Tracer("test")
+	tracer := sdk.TracerProvider().Tracer("test")
 	_, span := tracer.Start(t.Context(), "span")
 	span.End()
 	assert.NotZero(t, buf)
 	assert.Equal(t, 1, calls)
 	// Options provided by WithMeterProviderOptions may be overridden
 	// by configuration, e.g. the resource is always defined via
 	// configuration.
-	// TODO: re-enable this once NewSDK is added
-	// assert.NotContains(t, buf.String(), "foo")
+	assert.NotContains(t, buf.String(), "foo")
 }
 
 func TestSpanProcessor(t *testing.T) {