Debian Codegraph @

sdk/log/logger_bench_test.go

raw
1 // Copyright The OpenTelemetry Authors
2 // SPDX-License-Identifier: Apache-2.0
3
4 package log // import "go.opentelemetry.io/otel/sdk/log"
5
6 import (
7 "errors"
8 "testing"
9 "time"
10
11 "github.com/stretchr/testify/require"
12
13 "go.opentelemetry.io/otel"
14 "go.opentelemetry.io/otel/log"
15 "go.opentelemetry.io/otel/sdk/instrumentation"
16 "go.opentelemetry.io/otel/sdk/metric"
17 "go.opentelemetry.io/otel/sdk/metric/metricdata"
18 semconv "go.opentelemetry.io/otel/semconv/v1.40.0"
19 )
20
21 func BenchmarkLoggerEmit(b *testing.B) {
22 logger := newTestLogger(b)
23
24 r := log.Record{}
25 r.SetTimestamp(time.Date(2000, time.January, 1, 0, 0, 0, 0, time.UTC))
26 r.SetObservedTimestamp(time.Date(2000, time.January, 1, 0, 0, 0, 0, time.UTC))
27 r.SetBody(log.StringValue("testing body value"))
28 r.SetSeverity(log.SeverityInfo)
29 r.SetSeverityText("testing text")
30
31 r.AddAttributes(
32 log.String("k1", "str"),
33 log.Float64("k2", 1.0),
34 log.Int("k3", 2),
35 log.Bool("k4", true),
36 log.Bytes("k5", []byte{1}),
37 )
38
39 r10 := r
40 r10.AddAttributes(
41 log.String("k6", "str"),
42 log.Float64("k7", 1.0),
43 log.Int("k8", 2),
44 log.Bool("k9", true),
45 log.Bytes("k10", []byte{1}),
46 )
47
48 require.Equal(b, 5, r.AttributesLen())
49 require.Equal(b, 10, r10.AttributesLen())
50
51 b.Run("5 attributes", func(b *testing.B) {
52 b.ReportAllocs()
53 b.RunParallel(func(pb *testing.PB) {
54 for pb.Next() {
55 logger.Emit(b.Context(), r)
56 }
57 })
58 })
59
60 b.Run("10 attributes", func(b *testing.B) {
61 b.ReportAllocs()
62 b.RunParallel(func(pb *testing.PB) {
63 for pb.Next() {
64 logger.Emit(b.Context(), r10)
65 }
66 })
67 })
68 }
69
70 func BenchmarkLoggerEmitObservability(b *testing.B) {
71 r := log.Record{}
72
73 orig := otel.GetMeterProvider()
74 b.Cleanup(func() { otel.SetMeterProvider(orig) })
75 reader := metric.NewManualReader()
76 mp := metric.NewMeterProvider(metric.WithReader(reader))
77 otel.SetMeterProvider(mp)
78
79 run := func(logger *logger) func(b *testing.B) {
80 return func(b *testing.B) {
81 b.ResetTimer()
82 b.ReportAllocs()
83 b.RunParallel(func(pb *testing.PB) {
84 for pb.Next() {
85 logger.Emit(b.Context(), r)
86 }
87 })
88 }
89 }
90
91 lp := NewLoggerProvider()
92 scope := instrumentation.Scope{}
93
94 b.Run("Disabled", run(newLogger(lp, scope)))
95
96 b.Run("Enabled", func(b *testing.B) {
97 b.Setenv("OTEL_GO_X_OBSERVABILITY", "true")
98
99 run(newLogger(lp, scope))(b)
100 })
101
102 var rm metricdata.ResourceMetrics
103 err := reader.Collect(b.Context(), &rm)
104 require.NoError(b, err)
105 require.Len(b, rm.ScopeMetrics, 1)
106 }
107
108 func BenchmarkLoggerEnabled(b *testing.B) {
109 logger := newTestLogger(b)
110 ctx := b.Context()
111 param := log.EnabledParameters{Severity: log.SeverityDebug}
112 var enabled bool
113
114 b.ReportAllocs()
115 b.ResetTimer()
116
117 for n := 0; n < b.N; n++ {
118 enabled = logger.Enabled(ctx, param)
119 }
120
121 _ = enabled
122 }
123
124 func BenchmarkLoggerSetErrAndEmit(b *testing.B) {
125 logger := newTestLogger(b)
126 err := errors.New("boom")
127
128 b.ReportAllocs()
129 b.ResetTimer()
130 for b.Loop() {
131 r := log.Record{}
132 r.SetErr(err)
133 logger.Emit(b.Context(), r)
134 }
135 }
136
137 func BenchmarkLoggerSetExceptionAttributesAndEmit(b *testing.B) {
138 logger := newTestLogger(b)
139 err := errors.New("boom")
140
141 b.ReportAllocs()
142 b.ResetTimer()
143 for b.Loop() {
144 r := log.Record{}
145 r.AddAttributes(log.String(string(semconv.ExceptionMessageKey), err.Error()))
146 r.AddAttributes(log.String(string(semconv.ExceptionTypeKey), errorType(err)))
147 logger.Emit(b.Context(), r)
148 }
149 }
150
151 func newTestLogger(t testing.TB) log.Logger {
152 provider := NewLoggerProvider(
153 WithProcessor(newFltrProcessor("0", false)),
154 WithProcessor(newFltrProcessor("1", true)),
155 )
156 return provider.Logger(t.Name())
157 }