Debian Codegraph @

exporters/otlp/otlpmetric/otlpmetrichttp/internal/transform/metricdata_test.go

raw
1 // Code generated by gotmpl. DO NOT MODIFY.
2 // source: internal/shared/otlp/otlpmetric/transform/metricdata_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 "github.com/stretchr/testify/require"
15
16 "go.opentelemetry.io/otel/attribute"
17 "go.opentelemetry.io/otel/sdk/instrumentation"
18 "go.opentelemetry.io/otel/sdk/metric/metricdata"
19 "go.opentelemetry.io/otel/sdk/resource"
20 semconv "go.opentelemetry.io/otel/semconv/v1.40.0"
21 cpb "go.opentelemetry.io/proto/otlp/common/v1"
22 mpb "go.opentelemetry.io/proto/otlp/metrics/v1"
23 rpb "go.opentelemetry.io/proto/otlp/resource/v1"
24 )
25
26 type unknownAggT struct {
27 metricdata.Aggregation
28 }
29
30 var (
31 // Sat Jan 01 2000 00:00:00 GMT+0000.
32 start = time.Date(2000, time.January, 0o1, 0, 0, 0, 0, time.FixedZone("GMT", 0))
33 end = start.Add(30 * time.Second)
34
35 alice = attribute.NewSet(attribute.String("user", "alice"))
36 bob = attribute.NewSet(attribute.String("user", "bob"))
37
38 filterAlice = []attribute.KeyValue{attribute.String("user", "filter alice")}
39 filterBob = []attribute.KeyValue{attribute.String("user", "filter bob")}
40
41 pbAlice = &cpb.KeyValue{Key: "user", Value: &cpb.AnyValue{
42 Value: &cpb.AnyValue_StringValue{StringValue: "alice"},
43 }}
44 pbBob = &cpb.KeyValue{Key: "user", Value: &cpb.AnyValue{
45 Value: &cpb.AnyValue_StringValue{StringValue: "bob"},
46 }}
47
48 pbFilterAlice = &cpb.KeyValue{Key: "user", Value: &cpb.AnyValue{
49 Value: &cpb.AnyValue_StringValue{StringValue: "filter alice"},
50 }}
51 pbFilterBob = &cpb.KeyValue{Key: "user", Value: &cpb.AnyValue{
52 Value: &cpb.AnyValue_StringValue{StringValue: "filter bob"},
53 }}
54
55 spanIDA = []byte{0, 0, 0, 0, 0, 0, 0, 1}
56 spanIDB = []byte{0, 0, 0, 0, 0, 0, 0, 2}
57 traceIDA = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}
58 traceIDB = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2}
59
60 exemplarInt64A = metricdata.Exemplar[int64]{
61 FilteredAttributes: filterAlice,
62 Time: end,
63 Value: -10,
64 SpanID: spanIDA,
65 TraceID: traceIDA,
66 }
67 exemplarFloat64A = metricdata.Exemplar[float64]{
68 FilteredAttributes: filterAlice,
69 Time: end,
70 Value: -10.0,
71 SpanID: spanIDA,
72 TraceID: traceIDA,
73 }
74 exemplarInt64B = metricdata.Exemplar[int64]{
75 FilteredAttributes: filterBob,
76 Time: end,
77 Value: 12,
78 SpanID: spanIDB,
79 TraceID: traceIDB,
80 }
81 exemplarFloat64B = metricdata.Exemplar[float64]{
82 FilteredAttributes: filterBob,
83 Time: end,
84 Value: 12.0,
85 SpanID: spanIDB,
86 TraceID: traceIDB,
87 }
88
89 pbExemplarInt64A = &mpb.Exemplar{
90 FilteredAttributes: []*cpb.KeyValue{pbFilterAlice},
91 TimeUnixNano: uint64(end.UnixNano()),
92 Value: &mpb.Exemplar_AsInt{
93 AsInt: -10,
94 },
95 SpanId: spanIDA,
96 TraceId: traceIDA,
97 }
98 pbExemplarInt64B = &mpb.Exemplar{
99 FilteredAttributes: []*cpb.KeyValue{pbFilterBob},
100 TimeUnixNano: uint64(end.UnixNano()),
101 Value: &mpb.Exemplar_AsInt{
102 AsInt: 12,
103 },
104 SpanId: spanIDB,
105 TraceId: traceIDB,
106 }
107 pbExemplarFloat64A = &mpb.Exemplar{
108 FilteredAttributes: []*cpb.KeyValue{pbFilterAlice},
109 TimeUnixNano: uint64(end.UnixNano()),
110 Value: &mpb.Exemplar_AsDouble{
111 AsDouble: -10.0,
112 },
113 SpanId: spanIDA,
114 TraceId: traceIDA,
115 }
116 pbExemplarFloat64B = &mpb.Exemplar{
117 FilteredAttributes: []*cpb.KeyValue{pbFilterBob},
118 TimeUnixNano: uint64(end.UnixNano()),
119 Value: &mpb.Exemplar_AsDouble{
120 AsDouble: 12.0,
121 },
122 SpanId: spanIDB,
123 TraceId: traceIDB,
124 }
125
126 minA, maxA, sumA = 2.0, 4.0, 90.0
127 minB, maxB, sumB = 4.0, 150.0, 234.0
128 otelHDPInt64 = []metricdata.HistogramDataPoint[int64]{
129 {
130 Attributes: alice,
131 StartTime: start,
132 Time: end,
133 Count: 30,
134 Bounds: []float64{1, 5},
135 BucketCounts: []uint64{0, 30, 0},
136 Min: metricdata.NewExtrema(int64(minA)),
137 Max: metricdata.NewExtrema(int64(maxA)),
138 Sum: int64(sumA),
139 Exemplars: []metricdata.Exemplar[int64]{exemplarInt64A},
140 }, {
141 Attributes: bob,
142 StartTime: start,
143 Time: end,
144 Count: 3,
145 Bounds: []float64{1, 5},
146 BucketCounts: []uint64{0, 1, 2},
147 Min: metricdata.NewExtrema(int64(minB)),
148 Max: metricdata.NewExtrema(int64(maxB)),
149 Sum: int64(sumB),
150 Exemplars: []metricdata.Exemplar[int64]{exemplarInt64B},
151 },
152 }
153 otelHDPFloat64 = []metricdata.HistogramDataPoint[float64]{
154 {
155 Attributes: alice,
156 StartTime: start,
157 Time: end,
158 Count: 30,
159 Bounds: []float64{1, 5},
160 BucketCounts: []uint64{0, 30, 0},
161 Min: metricdata.NewExtrema(minA),
162 Max: metricdata.NewExtrema(maxA),
163 Sum: sumA,
164 Exemplars: []metricdata.Exemplar[float64]{exemplarFloat64A},
165 }, {
166 Attributes: bob,
167 StartTime: start,
168 Time: end,
169 Count: 3,
170 Bounds: []float64{1, 5},
171 BucketCounts: []uint64{0, 1, 2},
172 Min: metricdata.NewExtrema(minB),
173 Max: metricdata.NewExtrema(maxB),
174 Sum: sumB,
175 Exemplars: []metricdata.Exemplar[float64]{exemplarFloat64B},
176 },
177 }
178
179 otelEBucketA = metricdata.ExponentialBucket{
180 Offset: 5,
181 Counts: []uint64{0, 5, 0, 5},
182 }
183 otelEBucketB = metricdata.ExponentialBucket{
184 Offset: 3,
185 Counts: []uint64{0, 5, 0, 5},
186 }
187 otelEBucketsC = metricdata.ExponentialBucket{
188 Offset: 5,
189 Counts: []uint64{0, 1},
190 }
191 otelEBucketsD = metricdata.ExponentialBucket{
192 Offset: 3,
193 Counts: []uint64{0, 1},
194 }
195
196 otelEHDPInt64 = []metricdata.ExponentialHistogramDataPoint[int64]{
197 {
198 Attributes: alice,
199 StartTime: start,
200 Time: end,
201 Count: 30,
202 Scale: 2,
203 ZeroCount: 10,
204 PositiveBucket: otelEBucketA,
205 NegativeBucket: otelEBucketB,
206 ZeroThreshold: .01,
207 Min: metricdata.NewExtrema(int64(minA)),
208 Max: metricdata.NewExtrema(int64(maxA)),
209 Sum: int64(sumA),
210 Exemplars: []metricdata.Exemplar[int64]{exemplarInt64A},
211 }, {
212 Attributes: bob,
213 StartTime: start,
214 Time: end,
215 Count: 3,
216 Scale: 4,
217 ZeroCount: 1,
218 PositiveBucket: otelEBucketsC,
219 NegativeBucket: otelEBucketsD,
220 ZeroThreshold: .02,
221 Min: metricdata.NewExtrema(int64(minB)),
222 Max: metricdata.NewExtrema(int64(maxB)),
223 Sum: int64(sumB),
224 Exemplars: []metricdata.Exemplar[int64]{exemplarInt64B},
225 },
226 }
227 otelEHDPFloat64 = []metricdata.ExponentialHistogramDataPoint[float64]{
228 {
229 Attributes: alice,
230 StartTime: start,
231 Time: end,
232 Count: 30,
233 Scale: 2,
234 ZeroCount: 10,
235 PositiveBucket: otelEBucketA,
236 NegativeBucket: otelEBucketB,
237 ZeroThreshold: .01,
238 Min: metricdata.NewExtrema(minA),
239 Max: metricdata.NewExtrema(maxA),
240 Sum: sumA,
241 Exemplars: []metricdata.Exemplar[float64]{exemplarFloat64A},
242 }, {
243 Attributes: bob,
244 StartTime: start,
245 Time: end,
246 Count: 3,
247 Scale: 4,
248 ZeroCount: 1,
249 PositiveBucket: otelEBucketsC,
250 NegativeBucket: otelEBucketsD,
251 ZeroThreshold: .02,
252 Min: metricdata.NewExtrema(minB),
253 Max: metricdata.NewExtrema(maxB),
254 Sum: sumB,
255 Exemplars: []metricdata.Exemplar[float64]{exemplarFloat64B},
256 },
257 }
258
259 pbHDPInt64 = []*mpb.HistogramDataPoint{
260 {
261 Attributes: []*cpb.KeyValue{pbAlice},
262 StartTimeUnixNano: uint64(start.UnixNano()),
263 TimeUnixNano: uint64(end.UnixNano()),
264 Count: 30,
265 Sum: &sumA,
266 ExplicitBounds: []float64{1, 5},
267 BucketCounts: []uint64{0, 30, 0},
268 Min: &minA,
269 Max: &maxA,
270 Exemplars: []*mpb.Exemplar{pbExemplarInt64A},
271 }, {
272 Attributes: []*cpb.KeyValue{pbBob},
273 StartTimeUnixNano: uint64(start.UnixNano()),
274 TimeUnixNano: uint64(end.UnixNano()),
275 Count: 3,
276 Sum: &sumB,
277 ExplicitBounds: []float64{1, 5},
278 BucketCounts: []uint64{0, 1, 2},
279 Min: &minB,
280 Max: &maxB,
281 Exemplars: []*mpb.Exemplar{pbExemplarInt64B},
282 },
283 }
284
285 pbHDPFloat64 = []*mpb.HistogramDataPoint{
286 {
287 Attributes: []*cpb.KeyValue{pbAlice},
288 StartTimeUnixNano: uint64(start.UnixNano()),
289 TimeUnixNano: uint64(end.UnixNano()),
290 Count: 30,
291 Sum: &sumA,
292 ExplicitBounds: []float64{1, 5},
293 BucketCounts: []uint64{0, 30, 0},
294 Min: &minA,
295 Max: &maxA,
296 Exemplars: []*mpb.Exemplar{pbExemplarFloat64A},
297 }, {
298 Attributes: []*cpb.KeyValue{pbBob},
299 StartTimeUnixNano: uint64(start.UnixNano()),
300 TimeUnixNano: uint64(end.UnixNano()),
301 Count: 3,
302 Sum: &sumB,
303 ExplicitBounds: []float64{1, 5},
304 BucketCounts: []uint64{0, 1, 2},
305 Min: &minB,
306 Max: &maxB,
307 Exemplars: []*mpb.Exemplar{pbExemplarFloat64B},
308 },
309 }
310
311 pbEHDPBA = &mpb.ExponentialHistogramDataPoint_Buckets{
312 Offset: 5,
313 BucketCounts: []uint64{0, 5, 0, 5},
314 }
315 pbEHDPBB = &mpb.ExponentialHistogramDataPoint_Buckets{
316 Offset: 3,
317 BucketCounts: []uint64{0, 5, 0, 5},
318 }
319 pbEHDPBC = &mpb.ExponentialHistogramDataPoint_Buckets{
320 Offset: 5,
321 BucketCounts: []uint64{0, 1},
322 }
323 pbEHDPBD = &mpb.ExponentialHistogramDataPoint_Buckets{
324 Offset: 3,
325 BucketCounts: []uint64{0, 1},
326 }
327
328 pbEHDPInt64 = []*mpb.ExponentialHistogramDataPoint{
329 {
330 Attributes: []*cpb.KeyValue{pbAlice},
331 StartTimeUnixNano: uint64(start.UnixNano()),
332 TimeUnixNano: uint64(end.UnixNano()),
333 Count: 30,
334 Sum: &sumA,
335 Scale: 2,
336 ZeroCount: 10,
337 Positive: pbEHDPBA,
338 Negative: pbEHDPBB,
339 Min: &minA,
340 Max: &maxA,
341 Exemplars: []*mpb.Exemplar{pbExemplarInt64A},
342 }, {
343 Attributes: []*cpb.KeyValue{pbBob},
344 StartTimeUnixNano: uint64(start.UnixNano()),
345 TimeUnixNano: uint64(end.UnixNano()),
346 Count: 3,
347 Sum: &sumB,
348 Scale: 4,
349 ZeroCount: 1,
350 Positive: pbEHDPBC,
351 Negative: pbEHDPBD,
352 Min: &minB,
353 Max: &maxB,
354 Exemplars: []*mpb.Exemplar{pbExemplarInt64B},
355 },
356 }
357
358 pbEHDPFloat64 = []*mpb.ExponentialHistogramDataPoint{
359 {
360 Attributes: []*cpb.KeyValue{pbAlice},
361 StartTimeUnixNano: uint64(start.UnixNano()),
362 TimeUnixNano: uint64(end.UnixNano()),
363 Count: 30,
364 Sum: &sumA,
365 Scale: 2,
366 ZeroCount: 10,
367 Positive: pbEHDPBA,
368 Negative: pbEHDPBB,
369 Min: &minA,
370 Max: &maxA,
371 Exemplars: []*mpb.Exemplar{pbExemplarFloat64A},
372 }, {
373 Attributes: []*cpb.KeyValue{pbBob},
374 StartTimeUnixNano: uint64(start.UnixNano()),
375 TimeUnixNano: uint64(end.UnixNano()),
376 Count: 3,
377 Sum: &sumB,
378 Scale: 4,
379 ZeroCount: 1,
380 Positive: pbEHDPBC,
381 Negative: pbEHDPBD,
382 Min: &minB,
383 Max: &maxB,
384 Exemplars: []*mpb.Exemplar{pbExemplarFloat64B},
385 },
386 }
387
388 otelHistInt64 = metricdata.Histogram[int64]{
389 Temporality: metricdata.DeltaTemporality,
390 DataPoints: otelHDPInt64,
391 }
392 otelHistFloat64 = metricdata.Histogram[float64]{
393 Temporality: metricdata.DeltaTemporality,
394 DataPoints: otelHDPFloat64,
395 }
396 invalidTemporality metricdata.Temporality
397 otelHistInvalid = metricdata.Histogram[int64]{
398 Temporality: invalidTemporality,
399 DataPoints: otelHDPInt64,
400 }
401
402 otelExpoHistInt64 = metricdata.ExponentialHistogram[int64]{
403 Temporality: metricdata.DeltaTemporality,
404 DataPoints: otelEHDPInt64,
405 }
406 otelExpoHistFloat64 = metricdata.ExponentialHistogram[float64]{
407 Temporality: metricdata.DeltaTemporality,
408 DataPoints: otelEHDPFloat64,
409 }
410 otelExpoHistInvalid = metricdata.ExponentialHistogram[int64]{
411 Temporality: invalidTemporality,
412 DataPoints: otelEHDPInt64,
413 }
414
415 pbHistInt64 = &mpb.Histogram{
416 AggregationTemporality: mpb.AggregationTemporality_AGGREGATION_TEMPORALITY_DELTA,
417 DataPoints: pbHDPInt64,
418 }
419
420 pbHistFloat64 = &mpb.Histogram{
421 AggregationTemporality: mpb.AggregationTemporality_AGGREGATION_TEMPORALITY_DELTA,
422 DataPoints: pbHDPFloat64,
423 }
424
425 pbExpoHistInt64 = &mpb.ExponentialHistogram{
426 AggregationTemporality: mpb.AggregationTemporality_AGGREGATION_TEMPORALITY_DELTA,
427 DataPoints: pbEHDPInt64,
428 }
429
430 pbExpoHistFloat64 = &mpb.ExponentialHistogram{
431 AggregationTemporality: mpb.AggregationTemporality_AGGREGATION_TEMPORALITY_DELTA,
432 DataPoints: pbEHDPFloat64,
433 }
434
435 quantileValuesA = []metricdata.QuantileValue{
436 {
437 Quantile: 0.0,
438 Value: 0.1,
439 },
440 {
441 Quantile: 0.5,
442 Value: 1.0,
443 },
444 {
445 Quantile: 1.0,
446 Value: 10.4,
447 },
448 }
449 quantileValuesB = []metricdata.QuantileValue{
450 {
451 Quantile: 0.0,
452 Value: 0.5,
453 },
454 {
455 Quantile: 0.5,
456 Value: 3.1,
457 },
458 {
459 Quantile: 1.0,
460 Value: 8.3,
461 },
462 }
463
464 pbQuantileValuesA = []*mpb.SummaryDataPoint_ValueAtQuantile{
465 {
466 Quantile: 0.0,
467 Value: 0.1,
468 },
469 {
470 Quantile: 0.5,
471 Value: 1.0,
472 },
473 {
474 Quantile: 1.0,
475 Value: 10.4,
476 },
477 }
478 pbQuantileValuesB = []*mpb.SummaryDataPoint_ValueAtQuantile{
479 {
480 Quantile: 0.0,
481 Value: 0.5,
482 },
483 {
484 Quantile: 0.5,
485 Value: 3.1,
486 },
487 {
488 Quantile: 1.0,
489 Value: 8.3,
490 },
491 }
492
493 otelSummaryDPts = []metricdata.SummaryDataPoint{
494 {
495 Attributes: alice,
496 StartTime: start,
497 Time: end,
498 Count: 20,
499 Sum: sumA,
500 QuantileValues: quantileValuesA,
501 },
502 {
503 Attributes: bob,
504 StartTime: start,
505 Time: end,
506 Count: 26,
507 Sum: sumB,
508 QuantileValues: quantileValuesB,
509 },
510 }
511
512 otelDPtsInt64 = []metricdata.DataPoint[int64]{
513 {
514 Attributes: alice,
515 StartTime: start,
516 Time: end,
517 Value: 1,
518 Exemplars: []metricdata.Exemplar[int64]{exemplarInt64A},
519 },
520 {
521 Attributes: bob,
522 StartTime: start,
523 Time: end,
524 Value: 2,
525 Exemplars: []metricdata.Exemplar[int64]{exemplarInt64B},
526 },
527 }
528 otelDPtsFloat64 = []metricdata.DataPoint[float64]{
529 {
530 Attributes: alice,
531 StartTime: start,
532 Time: end,
533 Value: 1.0,
534 Exemplars: []metricdata.Exemplar[float64]{exemplarFloat64A},
535 },
536 {
537 Attributes: bob,
538 StartTime: start,
539 Time: end,
540 Value: 2.0,
541 Exemplars: []metricdata.Exemplar[float64]{exemplarFloat64B},
542 },
543 }
544
545 pbDPtsInt64 = []*mpb.NumberDataPoint{
546 {
547 Attributes: []*cpb.KeyValue{pbAlice},
548 StartTimeUnixNano: uint64(start.UnixNano()),
549 TimeUnixNano: uint64(end.UnixNano()),
550 Value: &mpb.NumberDataPoint_AsInt{AsInt: 1},
551 Exemplars: []*mpb.Exemplar{pbExemplarInt64A},
552 },
553 {
554 Attributes: []*cpb.KeyValue{pbBob},
555 StartTimeUnixNano: uint64(start.UnixNano()),
556 TimeUnixNano: uint64(end.UnixNano()),
557 Value: &mpb.NumberDataPoint_AsInt{AsInt: 2},
558 Exemplars: []*mpb.Exemplar{pbExemplarInt64B},
559 },
560 }
561 pbDPtsFloat64 = []*mpb.NumberDataPoint{
562 {
563 Attributes: []*cpb.KeyValue{pbAlice},
564 StartTimeUnixNano: uint64(start.UnixNano()),
565 TimeUnixNano: uint64(end.UnixNano()),
566 Value: &mpb.NumberDataPoint_AsDouble{AsDouble: 1.0},
567 Exemplars: []*mpb.Exemplar{pbExemplarFloat64A},
568 },
569 {
570 Attributes: []*cpb.KeyValue{pbBob},
571 StartTimeUnixNano: uint64(start.UnixNano()),
572 TimeUnixNano: uint64(end.UnixNano()),
573 Value: &mpb.NumberDataPoint_AsDouble{AsDouble: 2.0},
574 Exemplars: []*mpb.Exemplar{pbExemplarFloat64B},
575 },
576 }
577
578 pbDPtsSummary = []*mpb.SummaryDataPoint{
579 {
580 Attributes: []*cpb.KeyValue{pbAlice},
581 StartTimeUnixNano: uint64(start.UnixNano()),
582 TimeUnixNano: uint64(end.UnixNano()),
583 Count: 20,
584 Sum: sumA,
585 QuantileValues: pbQuantileValuesA,
586 },
587 {
588 Attributes: []*cpb.KeyValue{pbBob},
589 StartTimeUnixNano: uint64(start.UnixNano()),
590 TimeUnixNano: uint64(end.UnixNano()),
591 Count: 26,
592 Sum: sumB,
593 QuantileValues: pbQuantileValuesB,
594 },
595 }
596
597 otelSumInt64 = metricdata.Sum[int64]{
598 Temporality: metricdata.CumulativeTemporality,
599 IsMonotonic: true,
600 DataPoints: otelDPtsInt64,
601 }
602 otelSumFloat64 = metricdata.Sum[float64]{
603 Temporality: metricdata.DeltaTemporality,
604 IsMonotonic: false,
605 DataPoints: otelDPtsFloat64,
606 }
607 otelSumInvalid = metricdata.Sum[float64]{
608 Temporality: invalidTemporality,
609 IsMonotonic: false,
610 DataPoints: otelDPtsFloat64,
611 }
612
613 pbSumInt64 = &mpb.Sum{
614 AggregationTemporality: mpb.AggregationTemporality_AGGREGATION_TEMPORALITY_CUMULATIVE,
615 IsMonotonic: true,
616 DataPoints: pbDPtsInt64,
617 }
618 pbSumFloat64 = &mpb.Sum{
619 AggregationTemporality: mpb.AggregationTemporality_AGGREGATION_TEMPORALITY_DELTA,
620 IsMonotonic: false,
621 DataPoints: pbDPtsFloat64,
622 }
623
624 otelGaugeInt64 = metricdata.Gauge[int64]{DataPoints: otelDPtsInt64}
625 otelGaugeFloat64 = metricdata.Gauge[float64]{DataPoints: otelDPtsFloat64}
626 otelGaugeZeroStartTime = metricdata.Gauge[int64]{
627 DataPoints: []metricdata.DataPoint[int64]{
628 {
629 Attributes: alice,
630 StartTime: time.Time{},
631 Time: end,
632 Value: 1,
633 Exemplars: []metricdata.Exemplar[int64]{exemplarInt64A},
634 },
635 },
636 }
637
638 pbGaugeInt64 = &mpb.Gauge{DataPoints: pbDPtsInt64}
639 pbGaugeFloat64 = &mpb.Gauge{DataPoints: pbDPtsFloat64}
640 pbGaugeZeroStartTime = &mpb.Gauge{DataPoints: []*mpb.NumberDataPoint{
641 {
642 Attributes: []*cpb.KeyValue{pbAlice},
643 StartTimeUnixNano: 0,
644 TimeUnixNano: uint64(end.UnixNano()),
645 Value: &mpb.NumberDataPoint_AsInt{AsInt: 1},
646 Exemplars: []*mpb.Exemplar{pbExemplarInt64A},
647 },
648 }}
649
650 pbSummary = &mpb.Summary{DataPoints: pbDPtsSummary}
651
652 otelSummary = metricdata.Summary{DataPoints: otelSummaryDPts}
653
654 unknownAgg unknownAggT
655 otelMetrics = []metricdata.Metrics{
656 {
657 Name: "int64-gauge",
658 Description: "Gauge with int64 values",
659 Unit: "1",
660 Data: otelGaugeInt64,
661 },
662 {
663 Name: "float64-gauge",
664 Description: "Gauge with float64 values",
665 Unit: "1",
666 Data: otelGaugeFloat64,
667 },
668 {
669 Name: "int64-sum",
670 Description: "Sum with int64 values",
671 Unit: "1",
672 Data: otelSumInt64,
673 },
674 {
675 Name: "float64-sum",
676 Description: "Sum with float64 values",
677 Unit: "1",
678 Data: otelSumFloat64,
679 },
680 {
681 Name: "invalid-sum",
682 Description: "Sum with invalid temporality",
683 Unit: "1",
684 Data: otelSumInvalid,
685 },
686 {
687 Name: "int64-histogram",
688 Description: "Histogram",
689 Unit: "1",
690 Data: otelHistInt64,
691 },
692 {
693 Name: "float64-histogram",
694 Description: "Histogram",
695 Unit: "1",
696 Data: otelHistFloat64,
697 },
698 {
699 Name: "invalid-histogram",
700 Description: "Invalid histogram",
701 Unit: "1",
702 Data: otelHistInvalid,
703 },
704 {
705 Name: "unknown",
706 Description: "Unknown aggregation",
707 Unit: "1",
708 Data: unknownAgg,
709 },
710 {
711 Name: "int64-ExponentialHistogram",
712 Description: "Exponential Histogram",
713 Unit: "1",
714 Data: otelExpoHistInt64,
715 },
716 {
717 Name: "float64-ExponentialHistogram",
718 Description: "Exponential Histogram",
719 Unit: "1",
720 Data: otelExpoHistFloat64,
721 },
722 {
723 Name: "invalid-ExponentialHistogram",
724 Description: "Invalid Exponential Histogram",
725 Unit: "1",
726 Data: otelExpoHistInvalid,
727 },
728 {
729 Name: "zero-time",
730 Description: "Gauge with 0 StartTime",
731 Unit: "1",
732 Data: otelGaugeZeroStartTime,
733 },
734 {
735 Name: "summary",
736 Description: "Summary metric",
737 Unit: "1",
738 Data: otelSummary,
739 },
740 }
741
742 pbMetrics = []*mpb.Metric{
743 {
744 Name: "int64-gauge",
745 Description: "Gauge with int64 values",
746 Unit: "1",
747 Data: &mpb.Metric_Gauge{Gauge: pbGaugeInt64},
748 },
749 {
750 Name: "float64-gauge",
751 Description: "Gauge with float64 values",
752 Unit: "1",
753 Data: &mpb.Metric_Gauge{Gauge: pbGaugeFloat64},
754 },
755 {
756 Name: "int64-sum",
757 Description: "Sum with int64 values",
758 Unit: "1",
759 Data: &mpb.Metric_Sum{Sum: pbSumInt64},
760 },
761 {
762 Name: "float64-sum",
763 Description: "Sum with float64 values",
764 Unit: "1",
765 Data: &mpb.Metric_Sum{Sum: pbSumFloat64},
766 },
767 {
768 Name: "int64-histogram",
769 Description: "Histogram",
770 Unit: "1",
771 Data: &mpb.Metric_Histogram{Histogram: pbHistInt64},
772 },
773 {
774 Name: "float64-histogram",
775 Description: "Histogram",
776 Unit: "1",
777 Data: &mpb.Metric_Histogram{Histogram: pbHistFloat64},
778 },
779 {
780 Name: "int64-ExponentialHistogram",
781 Description: "Exponential Histogram",
782 Unit: "1",
783 Data: &mpb.Metric_ExponentialHistogram{ExponentialHistogram: pbExpoHistInt64},
784 },
785 {
786 Name: "float64-ExponentialHistogram",
787 Description: "Exponential Histogram",
788 Unit: "1",
789 Data: &mpb.Metric_ExponentialHistogram{ExponentialHistogram: pbExpoHistFloat64},
790 },
791 {
792 Name: "zero-time",
793 Description: "Gauge with 0 StartTime",
794 Unit: "1",
795 Data: &mpb.Metric_Gauge{Gauge: pbGaugeZeroStartTime},
796 },
797 {
798 Name: "summary",
799 Description: "Summary metric",
800 Unit: "1",
801 Data: &mpb.Metric_Summary{Summary: pbSummary},
802 },
803 }
804
805 otelScopeMetrics = []metricdata.ScopeMetrics{
806 {
807 Scope: instrumentation.Scope{
808 Name: "test/code/path",
809 Version: "v0.1.0",
810 SchemaURL: semconv.SchemaURL,
811 Attributes: attribute.NewSet(attribute.String("foo", "bar")),
812 },
813 Metrics: otelMetrics,
814 },
815 }
816
817 pbScopeMetrics = []*mpb.ScopeMetrics{
818 {
819 Scope: &cpb.InstrumentationScope{
820 Name: "test/code/path",
821 Version: "v0.1.0",
822 Attributes: []*cpb.KeyValue{
823 {
824 Key: "foo",
825 Value: &cpb.AnyValue{
826 Value: &cpb.AnyValue_StringValue{StringValue: "bar"},
827 },
828 },
829 },
830 },
831 Metrics: pbMetrics,
832 SchemaUrl: semconv.SchemaURL,
833 },
834 }
835
836 otelRes = resource.NewWithAttributes(
837 semconv.SchemaURL,
838 semconv.ServiceName("test server"),
839 semconv.ServiceVersion("v0.1.0"),
840 )
841
842 pbRes = &rpb.Resource{
843 Attributes: []*cpb.KeyValue{
844 {
845 Key: "service.name",
846 Value: &cpb.AnyValue{
847 Value: &cpb.AnyValue_StringValue{StringValue: "test server"},
848 },
849 },
850 {
851 Key: "service.version",
852 Value: &cpb.AnyValue{
853 Value: &cpb.AnyValue_StringValue{StringValue: "v0.1.0"},
854 },
855 },
856 },
857 }
858
859 otelResourceMetrics = &metricdata.ResourceMetrics{
860 Resource: otelRes,
861 ScopeMetrics: otelScopeMetrics,
862 }
863
864 pbResourceMetrics = &mpb.ResourceMetrics{
865 Resource: pbRes,
866 ScopeMetrics: pbScopeMetrics,
867 SchemaUrl: semconv.SchemaURL,
868 }
869 )
870
871 func TestTransformations(t *testing.T) {
872 // Run tests from the "bottom-up" of the metricdata data-types and halt
873 // when a failure occurs to ensure the clearest failure message (as
874 // opposed to the opposite of testing from the top-down which will obscure
875 // errors deep inside the structs).
876
877 // DataPoint types.
878 assert.Equal(t, pbHDPInt64, HistogramDataPoints(otelHDPInt64))
879 assert.Equal(t, pbHDPFloat64, HistogramDataPoints(otelHDPFloat64))
880 assert.Equal(t, pbDPtsInt64, DataPoints[int64](otelDPtsInt64))
881 require.Equal(t, pbDPtsFloat64, DataPoints[float64](otelDPtsFloat64))
882 assert.Equal(t, pbEHDPInt64, ExponentialHistogramDataPoints(otelEHDPInt64))
883 assert.Equal(t, pbEHDPFloat64, ExponentialHistogramDataPoints(otelEHDPFloat64))
884 assert.Equal(t, pbEHDPBA, ExponentialHistogramDataPointBuckets(otelEBucketA))
885 assert.Equal(t, pbDPtsSummary, SummaryDataPoints(otelSummaryDPts))
886
887 // Aggregations.
888 h, err := Histogram(otelHistInt64)
889 assert.NoError(t, err)
890 assert.Equal(t, &mpb.Metric_Histogram{Histogram: pbHistInt64}, h)
891 h, err = Histogram(otelHistFloat64)
892 assert.NoError(t, err)
893 assert.Equal(t, &mpb.Metric_Histogram{Histogram: pbHistFloat64}, h)
894 h, err = Histogram(otelHistInvalid)
895 assert.ErrorIs(t, err, errUnknownTemporality)
896 assert.Nil(t, h)
897
898 s, err := Sum[int64](otelSumInt64)
899 assert.NoError(t, err)
900 assert.Equal(t, &mpb.Metric_Sum{Sum: pbSumInt64}, s)
901 s, err = Sum[float64](otelSumFloat64)
902 assert.NoError(t, err)
903 assert.Equal(t, &mpb.Metric_Sum{Sum: pbSumFloat64}, s)
904 s, err = Sum[float64](otelSumInvalid)
905 assert.ErrorIs(t, err, errUnknownTemporality)
906 assert.Nil(t, s)
907
908 assert.Equal(t, &mpb.Metric_Gauge{Gauge: pbGaugeInt64}, Gauge[int64](otelGaugeInt64))
909 require.Equal(t, &mpb.Metric_Gauge{Gauge: pbGaugeFloat64}, Gauge[float64](otelGaugeFloat64))
910
911 e, err := ExponentialHistogram(otelExpoHistInt64)
912 assert.NoError(t, err)
913 assert.Equal(t, &mpb.Metric_ExponentialHistogram{ExponentialHistogram: pbExpoHistInt64}, e)
914 e, err = ExponentialHistogram(otelExpoHistFloat64)
915 assert.NoError(t, err)
916 assert.Equal(t, &mpb.Metric_ExponentialHistogram{ExponentialHistogram: pbExpoHistFloat64}, e)
917 e, err = ExponentialHistogram(otelExpoHistInvalid)
918 assert.ErrorIs(t, err, errUnknownTemporality)
919 assert.Nil(t, e)
920
921 require.Equal(t, &mpb.Metric_Summary{Summary: pbSummary}, Summary(otelSummary))
922
923 // Metrics.
924 m, err := Metrics(otelMetrics)
925 assert.ErrorIs(t, err, errUnknownTemporality)
926 assert.ErrorIs(t, err, errUnknownAggregation)
927 require.Equal(t, pbMetrics, m)
928
929 // Scope Metrics.
930 sm, err := ScopeMetrics(otelScopeMetrics)
931 assert.ErrorIs(t, err, errUnknownTemporality)
932 assert.ErrorIs(t, err, errUnknownAggregation)
933 require.Equal(t, pbScopeMetrics, sm)
934
935 // Resource Metrics.
936 rm, err := ResourceMetrics(otelResourceMetrics)
937 assert.ErrorIs(t, err, errUnknownTemporality)
938 assert.ErrorIs(t, err, errUnknownAggregation)
939 require.Equal(t, pbResourceMetrics, rm)
940 }
941
942 func BenchmarkResourceMetrics(b *testing.B) {
943 for _, bb := range []struct {
944 name string
945 aggregation metricdata.Aggregation
946 }{
947 {
948 name: "with a gauge",
949 aggregation: metricdata.Gauge[int64]{
950 DataPoints: []metricdata.DataPoint[int64]{
951 {Value: 1},
952 {Value: 2},
953 },
954 },
955 },
956 {
957 name: "with a sum",
958 aggregation: metricdata.Sum[int64]{
959 DataPoints: []metricdata.DataPoint[int64]{
960 {Value: 1},
961 {Value: 2},
962 },
963 },
964 },
965 {
966 name: "with a histogram",
967 aggregation: metricdata.Histogram[int64]{
968 DataPoints: []metricdata.HistogramDataPoint[int64]{
969 {
970 Count: 2,
971 Min: metricdata.NewExtrema[int64](2),
972 Max: metricdata.NewExtrema[int64](3),
973 Sum: 5,
974 },
975 },
976 },
977 },
978 {
979 name: "with an exponential histogram",
980 aggregation: metricdata.ExponentialHistogram[int64]{
981 DataPoints: []metricdata.ExponentialHistogramDataPoint[int64]{
982 {
983 Count: 2,
984 Min: metricdata.NewExtrema[int64](2),
985 Max: metricdata.NewExtrema[int64](3),
986 Sum: 5,
987 },
988 },
989 },
990 },
991 {
992 name: "with a summary",
993 aggregation: metricdata.Summary{
994 DataPoints: []metricdata.SummaryDataPoint{
995 {
996 Count: 1,
997 Sum: 5,
998 QuantileValues: []metricdata.QuantileValue{
999 {Quantile: 0.5, Value: 5},
1000 },
1001 },
1002 },
1003 },
1004 },
1005 } {
1006 b.Run(bb.name, func(b *testing.B) {
1007 records := &metricdata.ResourceMetrics{
1008 ScopeMetrics: []metricdata.ScopeMetrics{
1009 {
1010 Metrics: []metricdata.Metrics{
1011 {
1012 Data: bb.aggregation,
1013 },
1014 },
1015 },
1016 },
1017 }
1018
1019 b.ResetTimer()
1020 b.ReportAllocs()
1021 b.RunParallel(func(pb *testing.PB) {
1022 var out *mpb.ResourceMetrics
1023 for pb.Next() {
1024 out, _ = ResourceMetrics(records)
1025 }
1026 _ = out
1027 })
1028 })
1029 }
1030 }