Debian Codegraph @

log/internal/global/log_test.go

raw
1 // Copyright The OpenTelemetry Authors
2 // SPDX-License-Identifier: Apache-2.0
3
4 package global
5
6 import (
7 "context"
8 "fmt"
9 "testing"
10
11 "github.com/stretchr/testify/assert"
12
13 "go.opentelemetry.io/otel/attribute"
14 "go.opentelemetry.io/otel/log"
15 "go.opentelemetry.io/otel/log/embedded"
16 "go.opentelemetry.io/otel/log/noop"
17 )
18
19 func TestLoggerProviderConcurrentSafe(*testing.T) {
20 p := &loggerProvider{}
21
22 done := make(chan struct{})
23 stop := make(chan struct{})
24
25 go func() {
26 defer close(done)
27 var logger log.Logger
28 for i := 0; ; i++ {
29 logger = p.Logger(fmt.Sprintf("a%d", i))
30 select {
31 case <-stop:
32 _ = logger
33 return
34 default:
35 }
36 }
37 }()
38
39 p.setDelegate(noop.NewLoggerProvider())
40 close(stop)
41 <-done
42 }
43
44 func TestLoggerConcurrentSafe(t *testing.T) {
45 l := &logger{}
46
47 done := make(chan struct{})
48 stop := make(chan struct{})
49
50 go func() {
51 defer close(done)
52
53 ctx := t.Context()
54 var r log.Record
55 var param log.EnabledParameters
56
57 var enabled bool
58 for {
59 l.Emit(ctx, r)
60 enabled = l.Enabled(ctx, param)
61
62 select {
63 case <-stop:
64 _ = enabled
65 return
66 default:
67 }
68 }
69 }()
70
71 l.setDelegate(noop.NewLoggerProvider())
72 close(stop)
73 <-done
74 }
75
76 type testLoggerProvider struct {
77 embedded.LoggerProvider
78
79 loggers map[string]*testLogger
80 loggerN int
81 }
82
83 func (p *testLoggerProvider) Logger(name string, _ ...log.LoggerOption) log.Logger {
84 if p.loggers == nil {
85 l := &testLogger{}
86 p.loggers = map[string]*testLogger{name: l}
87 p.loggerN++
88 return l
89 }
90
91 if l, ok := p.loggers[name]; ok {
92 return l
93 }
94
95 p.loggerN++
96 l := &testLogger{}
97 p.loggers[name] = l
98 return l
99 }
100
101 type testLogger struct {
102 embedded.Logger
103
104 emitN, enabledN int
105 }
106
107 func (l *testLogger) Emit(context.Context, log.Record) { l.emitN++ }
108 func (l *testLogger) Enabled(context.Context, log.EnabledParameters) bool {
109 l.enabledN++
110 return true
111 }
112
113 func emitRecord(l log.Logger) {
114 ctx := context.Background()
115 var param log.EnabledParameters
116 var r log.Record
117
118 _ = l.Enabled(ctx, param)
119 l.Emit(ctx, r)
120 }
121
122 func TestDelegation(t *testing.T) {
123 provider := &loggerProvider{}
124
125 const preName = "pre"
126 pre0, pre1 := provider.Logger(preName), provider.Logger(preName)
127 assert.Same(t, pre0, pre1, "same logger instance not returned")
128
129 alt := provider.Logger("alt")
130 assert.NotSame(t, pre0, alt)
131
132 alt2 := provider.Logger(preName, log.WithInstrumentationAttributes(attribute.String("k", "v")))
133 assert.NotSame(t, pre0, alt2)
134
135 delegate := &testLoggerProvider{}
136 provider.setDelegate(delegate)
137
138 want := 2 // (pre0/pre1) and (alt)
139 if !assert.Equal(t, want, delegate.loggerN, "previous Loggers not delegated") {
140 want = delegate.loggerN
141 }
142
143 pre2 := provider.Logger(preName)
144 if !assert.Equal(t, want, delegate.loggerN, "previous Logger recreated") {
145 want = delegate.loggerN
146 }
147
148 post := provider.Logger("test")
149 want++
150 assert.Equal(t, want, delegate.loggerN, "new Logger not delegated")
151
152 emitRecord(pre0)
153 emitRecord(pre2)
154
155 if assert.IsType(t, &testLogger{}, pre2, "wrong pre-delegation Logger type") {
156 assert.Equal(t, 2, pre2.(*testLogger).emitN, "Emit not delegated")
157 assert.Equal(t, 2, pre2.(*testLogger).enabledN, "Enabled not delegated")
158 }
159
160 emitRecord(post)
161
162 if assert.IsType(t, &testLogger{}, post, "wrong post-delegation Logger type") {
163 assert.Equal(t, 1, post.(*testLogger).emitN, "Emit not delegated")
164 assert.Equal(t, 1, post.(*testLogger).enabledN, "Enabled not delegated")
165 }
166 }
167
168 func TestLoggerIdentity(t *testing.T) {
169 type id struct{ name, ver, url string }
170
171 ids := []id{
172 {"name-a", "version-a", "url-a"},
173 {"name-a", "version-a", "url-b"},
174 {"name-a", "version-b", "url-a"},
175 {"name-a", "version-b", "url-b"},
176 {"name-b", "version-a", "url-a"},
177 {"name-b", "version-a", "url-b"},
178 {"name-b", "version-b", "url-a"},
179 {"name-b", "version-b", "url-b"},
180 }
181
182 provider := &loggerProvider{}
183 newLogger := func(i id) log.Logger {
184 return provider.Logger(
185 i.name,
186 log.WithInstrumentationVersion(i.ver),
187 log.WithSchemaURL(i.url),
188 )
189 }
190
191 for i, id0 := range ids {
192 for j, id1 := range ids {
193 l0, l1 := newLogger(id0), newLogger(id1)
194
195 if i == j {
196 assert.Samef(t, l0, l1, "logger(%v) != logger(%v)", id0, id1)
197 } else {
198 assert.NotSamef(t, l0, l1, "logger(%v) == logger(%v)", id0, id1)
199 }
200 }
201 }
202 }