| 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 |
} |