Merge remote-tracking branch 'upstream/main' into logger

sdk/log/go.mod

@@ -3,6 +3,7 @@ module go.opentelemetry.io/otel/sdk/log
 go 1.21
 
 require (
+	github.com/go-logr/logr v1.4.1
 	github.com/stretchr/testify v1.9.0
 	go.opentelemetry.io/otel v1.24.0
 	go.opentelemetry.io/otel/log v0.0.1-alpha
@@ -12,7 +13,6 @@ require (
 
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/go-logr/logr v1.4.1 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	go.opentelemetry.io/otel/metric v1.24.0 // indirect

sdk/log/logger_test.go

@@ -19,7 +19,7 @@ import (
 
 func TestLoggerEmit(t *testing.T) {
 	p0, p1, p2WithError := newProcessor("0"), newProcessor("1"), newProcessor("2")
-	p2WithError.err = errors.New("error")
+	p2WithError.Err = errors.New("error")
 
 	r := log.Record{}
 	r.SetTimestamp(time.Date(2000, time.January, 1, 0, 0, 0, 0, time.UTC))

sdk/log/provider.go

@@ -5,13 +5,19 @@ package log // import "go.opentelemetry.io/otel/sdk/log"
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"os"
 	"strconv"
+	"sync"
+	"sync/atomic"
 
 	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/internal/global"
 	"go.opentelemetry.io/otel/log"
 	"go.opentelemetry.io/otel/log/embedded"
+	"go.opentelemetry.io/otel/log/noop"
+	"go.opentelemetry.io/otel/sdk/instrumentation"
 	"go.opentelemetry.io/otel/sdk/resource"
 )
 
@@ -100,6 +106,11 @@ type LoggerProvider struct {
 	processors                []Processor
 	attributeCountLimit       int
 	attributeValueLengthLimit int
+
+	loggersMu sync.Mutex
+	loggers   map[instrumentation.Scope]*logger
+
+	stopped atomic.Bool
 }
 
 // Compile-time check LoggerProvider implements log.LoggerProvider.
@@ -123,26 +134,72 @@ func NewLoggerProvider(opts ...LoggerProviderOption) *LoggerProvider {
 
 // Logger returns a new [log.Logger] with the provided name and configuration.
 //
+// If p is shut down, a [noop.Logger] instace is returned.
+//
 // This method can be called concurrently.
 func (p *LoggerProvider) Logger(name string, opts ...log.LoggerOption) log.Logger {
-	// TODO (#5060): Implement.
-	return &logger{}
+	if name == "" {
+		global.Warn("Invalid Logger name.", "name", name)
+	}
+
+	if p.stopped.Load() {
+		return noop.NewLoggerProvider().Logger(name, opts...)
+	}
+
+	cfg := log.NewLoggerConfig(opts...)
+	scope := instrumentation.Scope{
+		Name:      name,
+		Version:   cfg.InstrumentationVersion(),
+		SchemaURL: cfg.SchemaURL(),
+	}
+
+	p.loggersMu.Lock()
+	defer p.loggersMu.Unlock()
+
+	if p.loggers == nil {
+		l := newLogger(p, scope)
+		p.loggers = map[instrumentation.Scope]*logger{scope: l}
+		return l
+	}
+
+	l, ok := p.loggers[scope]
+	if !ok {
+		l = newLogger(p, scope)
+		p.loggers[scope] = l
+	}
+
+	return l
 }
 
 // Shutdown flushes queued log records and shuts down the decorated expoter.
 //
 // This method can be called concurrently.
 func (p *LoggerProvider) Shutdown(ctx context.Context) error {
-	// TODO (#5060): Implement.
-	return nil
+	stopped := p.stopped.Swap(true)
+	if stopped {
+		return nil
+	}
+
+	var err error
+	for _, p := range p.processors {
+		err = errors.Join(err, p.Shutdown(ctx))
+	}
+	return err
 }
 
 // ForceFlush flushes all exporters.
 //
 //	This method can be called concurrently.
 func (p *LoggerProvider) ForceFlush(ctx context.Context) error {
-	// TODO (#5060): Implement.
-	return nil
+	if p.stopped.Load() {
+		return nil
+	}
+
+	var err error
+	for _, p := range p.processors {
+		err = errors.Join(err, p.ForceFlush(ctx))
+	}
+	return err
 }
 
 // LoggerProviderOption applies a configuration option value to a LoggerProvider.

sdk/log/provider_test.go

@@ -16,27 +16,41 @@ import (
 )
 
 type processor struct {
-	name string
-	err  error
+	Name string
+	Err  error
+
+	shutdownCalls   int
+	forceFlushCalls int
 
 	records []Record
 }
 
 func newProcessor(name string) *processor {
-	return &processor{name: name}
+	return &processor{Name: name}
 }
 
 func (p *processor) OnEmit(ctx context.Context, r Record) error {
-	if p.err != nil {
-		return p.err
+	if p.Err != nil {
+		return p.Err
 	}
 
 	p.records = append(p.records, r)
 	return nil
 }
-func (p *processor) Enabled(context.Context, Record) bool { return true }
-func (p *processor) Shutdown(context.Context) error       { return nil }
-func (p *processor) ForceFlush(context.Context) error     { return nil }
+
+func (*processor) Enabled(context.Context, Record) bool {
+	return true
+}
+
+func (p *processor) Shutdown(context.Context) error {
+	p.shutdownCalls++
+	return p.Err
+}
+
+func (p *processor) ForceFlush(context.Context) error {
+	p.forceFlushCalls++
+	return p.Err
+}
 
 func TestNewLoggerProviderConfiguration(t *testing.T) {
 	t.Cleanup(func(orig otel.ErrorHandler) func() {