Debian Codegraph @

log/internal/global/log.go

raw
1 // Copyright The OpenTelemetry Authors
2 // SPDX-License-Identifier: Apache-2.0
3
4 // Package global is the internal implementation of the OpenTelemetry global
5 // Logs API.
6 package global // import "go.opentelemetry.io/otel/log/internal/global"
7
8 import (
9 "context"
10 "sync"
11 "sync/atomic"
12
13 "go.opentelemetry.io/otel/attribute"
14 "go.opentelemetry.io/otel/log"
15 "go.opentelemetry.io/otel/log/embedded"
16 )
17
18 // instLib defines the instrumentation library a logger is created for.
19 //
20 // Do not use sdk/instrumentation (API cannot depend on the SDK).
21 type instLib struct {
22 name string
23 version string
24 schemaURL string
25 attrs attribute.Set
26 }
27
28 type loggerProvider struct {
29 embedded.LoggerProvider
30
31 mu sync.Mutex
32 loggers map[instLib]*logger
33 delegate log.LoggerProvider
34 }
35
36 // Compile-time guarantee loggerProvider implements LoggerProvider.
37 var _ log.LoggerProvider = (*loggerProvider)(nil)
38
39 func (p *loggerProvider) Logger(name string, options ...log.LoggerOption) log.Logger {
40 p.mu.Lock()
41 defer p.mu.Unlock()
42
43 if p.delegate != nil {
44 return p.delegate.Logger(name, options...)
45 }
46
47 cfg := log.NewLoggerConfig(options...)
48 key := instLib{
49 name: name,
50 version: cfg.InstrumentationVersion(),
51 schemaURL: cfg.SchemaURL(),
52 attrs: cfg.InstrumentationAttributes(),
53 }
54
55 if p.loggers == nil {
56 l := &logger{name: name, options: options}
57 p.loggers = map[instLib]*logger{key: l}
58 return l
59 }
60
61 if l, ok := p.loggers[key]; ok {
62 return l
63 }
64
65 l := &logger{name: name, options: options}
66 p.loggers[key] = l
67 return l
68 }
69
70 func (p *loggerProvider) setDelegate(provider log.LoggerProvider) {
71 p.mu.Lock()
72 defer p.mu.Unlock()
73
74 p.delegate = provider
75 for _, l := range p.loggers {
76 l.setDelegate(provider)
77 }
78 p.loggers = nil // Only set logger delegates once.
79 }
80
81 type logger struct {
82 embedded.Logger
83
84 name string
85 options []log.LoggerOption
86
87 delegate atomic.Value // log.Logger
88 }
89
90 // Compile-time guarantee logger implements Logger.
91 var _ log.Logger = (*logger)(nil)
92
93 func (l *logger) Emit(ctx context.Context, r log.Record) {
94 if del, ok := l.delegate.Load().(log.Logger); ok {
95 del.Emit(ctx, r)
96 }
97 }
98
99 func (l *logger) Enabled(ctx context.Context, param log.EnabledParameters) bool {
100 var enabled bool
101 if del, ok := l.delegate.Load().(log.Logger); ok {
102 enabled = del.Enabled(ctx, param)
103 }
104 return enabled
105 }
106
107 func (l *logger) setDelegate(provider log.LoggerProvider) {
108 l.delegate.Store(provider.Logger(l.name, l.options...))
109 }