refactor(logger): Flatten logger.initSelfObservability into logger.newLoggerr and use t.Cleanup instead of defer (#7228)

- Flatten `logger.initSelfObservability` into `logger.newLoggerr` 
- use `t.Cleanup` instead of `defer`

---------

Co-authored-by: Tyler Yahn <[email protected]>

Author: yumosx

sdk/log/logger.go

@@ -5,6 +5,7 @@ package log // import "go.opentelemetry.io/otel/sdk/log"
 
 import (
 	"context"
+	"fmt"
 	"time"
 
 	"go.opentelemetry.io/otel"
@@ -39,15 +40,9 @@ func newLogger(p *LoggerProvider, scope instrumentation.Scope) *logger {
 		provider:             p,
 		instrumentationScope: scope,
 	}
-	l.initSelfObservability()
-	return l
-}
-
-func (l *logger) initSelfObservability() {
 	if !x.SelfObservability.Enabled() {
-		return
+		return l
 	}
-
 	l.selfObservabilityEnabled = true
 	mp := otel.GetMeterProvider()
 	m := mp.Meter("go.opentelemetry.io/otel/sdk/log",
@@ -56,8 +51,10 @@ func (l *logger) initSelfObservability() {
 
 	var err error
 	if l.logCreatedMetric, err = otelconv.NewSDKLogCreated(m); err != nil {
+		err = fmt.Errorf("failed to create log created metric: %w", err)
 		otel.Handle(err)
 	}
+	return l
 }
 
 func (l *logger) Emit(ctx context.Context, r log.Record) {

sdk/log/logger_test.go

@@ -16,9 +16,10 @@ import (
 	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/log"
+	"go.opentelemetry.io/otel/metric"
 	"go.opentelemetry.io/otel/sdk"
 	"go.opentelemetry.io/otel/sdk/instrumentation"
-	"go.opentelemetry.io/otel/sdk/metric"
+	sdkmetric "go.opentelemetry.io/otel/sdk/metric"
 	"go.opentelemetry.io/otel/sdk/metric/metricdata"
 	"go.opentelemetry.io/otel/sdk/metric/metricdata/metricdatatest"
 	"go.opentelemetry.io/otel/sdk/resource"
@@ -383,9 +384,11 @@ func TestLoggerSelfObservability(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Setenv("OTEL_GO_X_SELF_OBSERVABILITY", strconv.FormatBool(tc.selfObservabilityEnabled))
 			prev := otel.GetMeterProvider()
-			defer otel.SetMeterProvider(prev)
-			r := metric.NewManualReader()
-			mp := metric.NewMeterProvider(metric.WithReader(r))
+			t.Cleanup(func() {
+				otel.SetMeterProvider(prev)
+			})
+			r := sdkmetric.NewManualReader()
+			mp := sdkmetric.NewMeterProvider(sdkmetric.WithReader(r))
 			otel.SetMeterProvider(mp)
 			l := newLogger(NewLoggerProvider(), instrumentation.Scope{})
 
@@ -422,3 +425,48 @@ func TestLoggerSelfObservability(t *testing.T) {
 		})
 	}
 }
+
+func TestNewLoggerSelfObservabilityErrorHandled(t *testing.T) {
+	errHandler := otel.GetErrorHandler()
+	t.Cleanup(func() {
+		otel.SetErrorHandler(errHandler)
+	})
+
+	var errs []error
+	eh := otel.ErrorHandlerFunc(func(e error) { errs = append(errs, e) })
+	otel.SetErrorHandler(eh)
+
+	orig := otel.GetMeterProvider()
+	t.Cleanup(func() { otel.SetMeterProvider(orig) })
+	otel.SetMeterProvider(&errMeterProvider{err: assert.AnError})
+
+	t.Setenv("OTEL_GO_X_SELF_OBSERVABILITY", "true")
+	l := newLogger(NewLoggerProvider(), instrumentation.Scope{})
+	_ = l
+	require.Len(t, errs, 1)
+	assert.ErrorIs(t, errs[0], assert.AnError)
+}
+
+type errMeterProvider struct {
+	metric.MeterProvider
+
+	err error
+}
+
+func (mp *errMeterProvider) Meter(string, ...metric.MeterOption) metric.Meter {
+	return &errMeter{err: mp.err}
+}
+
+type errMeter struct {
+	metric.Meter
+
+	err error
+}
+
+func (m *errMeter) Int64Counter(string, ...metric.Int64CounterOption) (metric.Int64Counter, error) {
+	return nil, m.err
+}
+
+func (m *errMeter) Int64UpDownCounter(string, ...metric.Int64UpDownCounterOption) (metric.Int64UpDownCounter, error) {
+	return nil, m.err
+}