Debian Codegraph @

exporters/otlp/otlplog/otlploghttp/internal/transform/log_test.go

raw
1 // Code generated by gotmpl. DO NOT MODIFY.
2 // source: internal/shared/otlp/otlplog/transform/log_test.go.tmpl
3
4 // Copyright The OpenTelemetry Authors
5 // SPDX-License-Identifier: Apache-2.0
6
7 package transform
8
9 import (
10 "testing"
11 "time"
12
13 "github.com/stretchr/testify/assert"
14
15 cpb "go.opentelemetry.io/proto/otlp/common/v1"
16 lpb "go.opentelemetry.io/proto/otlp/logs/v1"
17 rpb "go.opentelemetry.io/proto/otlp/resource/v1"
18
19 "go.opentelemetry.io/otel/attribute"
20 api "go.opentelemetry.io/otel/log"
21 "go.opentelemetry.io/otel/sdk/instrumentation"
22 "go.opentelemetry.io/otel/sdk/log"
23 "go.opentelemetry.io/otel/sdk/log/logtest"
24 "go.opentelemetry.io/otel/sdk/resource"
25 semconv "go.opentelemetry.io/otel/semconv/v1.40.0"
26 "go.opentelemetry.io/otel/trace"
27 )
28
29 var (
30 // Sat Jan 01 2000 00:00:00 GMT+0000.
31 ts = time.Date(2000, time.January, 0o1, 0, 0, 0, 0, time.FixedZone("GMT", 0))
32 obs = ts.Add(30 * time.Second)
33
34 tom = api.String("user", "tom")
35 jerry = api.String("user", "jerry")
36 // A time before unix 0.
37 negativeTs = time.Date(1969, 7, 20, 20, 17, 0, 0, time.UTC)
38
39 pbTom = &cpb.KeyValue{Key: "user", Value: &cpb.AnyValue{
40 Value: &cpb.AnyValue_StringValue{StringValue: "tom"},
41 }}
42 pbJerry = &cpb.KeyValue{Key: "user", Value: &cpb.AnyValue{
43 Value: &cpb.AnyValue_StringValue{StringValue: "jerry"},
44 }}
45
46 sevC = api.SeverityInfo
47 sevD = api.SeverityError
48
49 pbSevC = lpb.SeverityNumber_SEVERITY_NUMBER_INFO
50 pbSevD = lpb.SeverityNumber_SEVERITY_NUMBER_ERROR
51
52 bodyC = api.StringValue("c")
53 bodyD = api.StringValue("d")
54
55 pbBodyC = &cpb.AnyValue{
56 Value: &cpb.AnyValue_StringValue{
57 StringValue: "c",
58 },
59 }
60 pbBodyD = &cpb.AnyValue{
61 Value: &cpb.AnyValue_StringValue{
62 StringValue: "d",
63 },
64 }
65
66 spanIDC = []byte{0, 0, 0, 0, 0, 0, 0, 1}
67 spanIDD = []byte{0, 0, 0, 0, 0, 0, 0, 2}
68 traceIDC = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}
69 traceIDD = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2}
70 flagsC = byte(1)
71 flagsD = byte(0)
72
73 scope = instrumentation.Scope{
74 Name: "otel/test/code/path1",
75 Version: "v0.1.1",
76 SchemaURL: semconv.SchemaURL,
77 Attributes: attribute.NewSet(attribute.String("foo", "bar")),
78 }
79 scope2 = instrumentation.Scope{
80 Name: "otel/test/code/path2",
81 Version: "v0.2.2",
82 SchemaURL: semconv.SchemaURL,
83 }
84 scopeList = []instrumentation.Scope{scope, scope2}
85
86 pbScope = &cpb.InstrumentationScope{
87 Name: "otel/test/code/path1",
88 Version: "v0.1.1",
89 Attributes: []*cpb.KeyValue{
90 {
91 Key: "foo",
92 Value: &cpb.AnyValue{
93 Value: &cpb.AnyValue_StringValue{StringValue: "bar"},
94 },
95 },
96 },
97 }
98 pbScope2 = &cpb.InstrumentationScope{
99 Name: "otel/test/code/path2",
100 Version: "v0.2.2",
101 }
102
103 res = resource.NewWithAttributes(
104 semconv.SchemaURL,
105 semconv.ServiceName("service1"),
106 semconv.ServiceVersion("v0.1.1"),
107 )
108 res2 = resource.NewWithAttributes(
109 semconv.SchemaURL,
110 semconv.ServiceName("service2"),
111 semconv.ServiceVersion("v0.2.2"),
112 )
113 resList = []*resource.Resource{res, res2}
114
115 pbRes = &rpb.Resource{
116 Attributes: []*cpb.KeyValue{
117 {
118 Key: "service.name",
119 Value: &cpb.AnyValue{
120 Value: &cpb.AnyValue_StringValue{StringValue: "service1"},
121 },
122 },
123 {
124 Key: "service.version",
125 Value: &cpb.AnyValue{
126 Value: &cpb.AnyValue_StringValue{StringValue: "v0.1.1"},
127 },
128 },
129 },
130 }
131 pbRes2 = &rpb.Resource{
132 Attributes: []*cpb.KeyValue{
133 {
134 Key: "service.name",
135 Value: &cpb.AnyValue{
136 Value: &cpb.AnyValue_StringValue{StringValue: "service2"},
137 },
138 },
139 {
140 Key: "service.version",
141 Value: &cpb.AnyValue{
142 Value: &cpb.AnyValue_StringValue{StringValue: "v0.2.2"},
143 },
144 },
145 },
146 }
147
148 records = func() []log.Record {
149 var out []log.Record
150
151 for _, r := range resList {
152 for _, s := range scopeList {
153 out = append(out, logtest.RecordFactory{
154 Timestamp: ts,
155 ObservedTimestamp: obs,
156 EventName: "evnt",
157 Severity: sevC,
158 SeverityText: "C",
159 Body: bodyC,
160 Attributes: []api.KeyValue{tom},
161 TraceID: trace.TraceID(traceIDC),
162 SpanID: trace.SpanID(spanIDC),
163 TraceFlags: trace.TraceFlags(flagsC),
164 InstrumentationScope: &s,
165 Resource: r,
166 }.NewRecord())
167
168 out = append(out, logtest.RecordFactory{
169 Timestamp: ts,
170 ObservedTimestamp: obs,
171 Severity: sevC,
172 SeverityText: "C",
173 Body: bodyC,
174 Attributes: []api.KeyValue{jerry},
175 TraceID: trace.TraceID(traceIDC),
176 SpanID: trace.SpanID(spanIDC),
177 TraceFlags: trace.TraceFlags(flagsC),
178 InstrumentationScope: &s,
179 Resource: r,
180 }.NewRecord())
181
182 out = append(out, logtest.RecordFactory{
183 Timestamp: ts,
184 ObservedTimestamp: obs,
185 Severity: sevD,
186 SeverityText: "D",
187 Body: bodyD,
188 Attributes: []api.KeyValue{tom},
189 TraceID: trace.TraceID(traceIDD),
190 SpanID: trace.SpanID(spanIDD),
191 TraceFlags: trace.TraceFlags(flagsD),
192 InstrumentationScope: &s,
193 Resource: r,
194 }.NewRecord())
195
196 out = append(out, logtest.RecordFactory{
197 Timestamp: ts,
198 ObservedTimestamp: obs,
199 Severity: sevD,
200 SeverityText: "D",
201 Body: bodyD,
202 Attributes: []api.KeyValue{jerry},
203 TraceID: trace.TraceID(traceIDD),
204 SpanID: trace.SpanID(spanIDD),
205 TraceFlags: trace.TraceFlags(flagsD),
206 InstrumentationScope: &s,
207 Resource: r,
208 }.NewRecord())
209
210 out = append(out, logtest.RecordFactory{
211 Timestamp: negativeTs,
212 ObservedTimestamp: obs,
213 Severity: sevD,
214 SeverityText: "D",
215 Body: bodyD,
216 Attributes: []api.KeyValue{jerry},
217 TraceID: trace.TraceID(traceIDD),
218 SpanID: trace.SpanID(spanIDD),
219 TraceFlags: trace.TraceFlags(flagsD),
220 InstrumentationScope: &s,
221 Resource: r,
222 }.NewRecord())
223 }
224 }
225
226 return out
227 }()
228
229 pbLogRecords = []*lpb.LogRecord{
230 {
231 TimeUnixNano: uint64(ts.UnixNano()),
232 ObservedTimeUnixNano: uint64(obs.UnixNano()),
233 EventName: "evnt",
234 SeverityNumber: pbSevC,
235 SeverityText: "C",
236 Body: pbBodyC,
237 Attributes: []*cpb.KeyValue{pbTom},
238 Flags: uint32(flagsC),
239 TraceId: traceIDC,
240 SpanId: spanIDC,
241 },
242 {
243 TimeUnixNano: uint64(ts.UnixNano()),
244 ObservedTimeUnixNano: uint64(obs.UnixNano()),
245 SeverityNumber: pbSevC,
246 SeverityText: "C",
247 Body: pbBodyC,
248 Attributes: []*cpb.KeyValue{pbJerry},
249 Flags: uint32(flagsC),
250 TraceId: traceIDC,
251 SpanId: spanIDC,
252 },
253 {
254 TimeUnixNano: uint64(ts.UnixNano()),
255 ObservedTimeUnixNano: uint64(obs.UnixNano()),
256 SeverityNumber: pbSevD,
257 SeverityText: "D",
258 Body: pbBodyD,
259 Attributes: []*cpb.KeyValue{pbTom},
260 Flags: uint32(flagsD),
261 TraceId: traceIDD,
262 SpanId: spanIDD,
263 },
264 {
265 TimeUnixNano: uint64(ts.UnixNano()),
266 ObservedTimeUnixNano: uint64(obs.UnixNano()),
267 SeverityNumber: pbSevD,
268 SeverityText: "D",
269 Body: pbBodyD,
270 Attributes: []*cpb.KeyValue{pbJerry},
271 Flags: uint32(flagsD),
272 TraceId: traceIDD,
273 SpanId: spanIDD,
274 },
275 {
276 TimeUnixNano: 0,
277 ObservedTimeUnixNano: uint64(obs.UnixNano()),
278 SeverityNumber: pbSevD,
279 SeverityText: "D",
280 Body: pbBodyD,
281 Attributes: []*cpb.KeyValue{pbJerry},
282 Flags: uint32(flagsD),
283 TraceId: traceIDD,
284 SpanId: spanIDD,
285 },
286 }
287
288 pbScopeLogsList = []*lpb.ScopeLogs{
289 {
290 Scope: pbScope,
291 SchemaUrl: semconv.SchemaURL,
292 LogRecords: pbLogRecords,
293 },
294 {
295 Scope: pbScope2,
296 SchemaUrl: semconv.SchemaURL,
297 LogRecords: pbLogRecords,
298 },
299 }
300
301 pbResourceLogsList = []*lpb.ResourceLogs{
302 {
303 Resource: pbRes,
304 SchemaUrl: semconv.SchemaURL,
305 ScopeLogs: pbScopeLogsList,
306 },
307 {
308 Resource: pbRes2,
309 SchemaUrl: semconv.SchemaURL,
310 ScopeLogs: pbScopeLogsList,
311 },
312 }
313 )
314
315 func TestResourceLogs(t *testing.T) {
316 want := pbResourceLogsList
317 assert.ElementsMatch(t, want, ResourceLogs(records))
318 }
319
320 func TestSeverityNumber(t *testing.T) {
321 for i := 0; i <= int(api.SeverityFatal4); i++ {
322 want := lpb.SeverityNumber(i)
323 want += lpb.SeverityNumber_SEVERITY_NUMBER_UNSPECIFIED
324 assert.Equal(t, want, SeverityNumber(api.Severity(i)))
325 }
326 }
327
328 func BenchmarkResourceLogs(b *testing.B) {
329 b.ReportAllocs()
330 b.RunParallel(func(pb *testing.PB) {
331 var out []*lpb.ResourceLogs
332 for pb.Next() {
333 out = ResourceLogs(records)
334 }
335 _ = out
336 })
337 }