Debian Codegraph @

exporters/stdout/stdoutmetric/exporter.go

raw
1 // Copyright The OpenTelemetry Authors
2 // SPDX-License-Identifier: Apache-2.0
3
4 package stdoutmetric // import "go.opentelemetry.io/otel/exporters/stdout/stdoutmetric"
5
6 import (
7 "context"
8 "errors"
9 "fmt"
10 "sync"
11 "sync/atomic"
12
13 "go.opentelemetry.io/otel/exporters/stdout/stdoutmetric/internal/counter"
14 "go.opentelemetry.io/otel/exporters/stdout/stdoutmetric/internal/observ"
15 "go.opentelemetry.io/otel/internal/global"
16 "go.opentelemetry.io/otel/sdk/metric"
17 "go.opentelemetry.io/otel/sdk/metric/metricdata"
18 )
19
20 // exporter is an OpenTelemetry metric exporter.
21 type exporter struct {
22 encVal atomic.Value // encoderHolder
23
24 shutdownOnce sync.Once
25
26 temporalitySelector metric.TemporalitySelector
27 aggregationSelector metric.AggregationSelector
28
29 redactTimestamps bool
30
31 inst *observ.Instrumentation
32 }
33
34 // New returns a configured metric exporter.
35 //
36 // If no options are passed, the default exporter returned will use a JSON
37 // encoder with tab indentations that output to STDOUT.
38 func New(options ...Option) (metric.Exporter, error) {
39 cfg := newConfig(options...)
40 exp := &exporter{
41 temporalitySelector: cfg.temporalitySelector,
42 aggregationSelector: cfg.aggregationSelector,
43 redactTimestamps: cfg.redactTimestamps,
44 }
45 exp.encVal.Store(*cfg.encoder)
46 var err error
47 exp.inst, err = observ.NewInstrumentation(counter.NextExporterID())
48 return exp, err
49 }
50
51 func (e *exporter) Temporality(k metric.InstrumentKind) metricdata.Temporality {
52 return e.temporalitySelector(k)
53 }
54
55 func (e *exporter) Aggregation(k metric.InstrumentKind) metric.Aggregation {
56 return e.aggregationSelector(k)
57 }
58
59 func (e *exporter) Export(ctx context.Context, data *metricdata.ResourceMetrics) (err error) {
60 if e.inst != nil {
61 op := e.inst.ExportMetrics(ctx, countDataPoints(data))
62 defer func() { op.End(err) }()
63 }
64 err = ctx.Err()
65 if err != nil {
66 return err
67 }
68 if e.redactTimestamps {
69 redactTimestamps(data)
70 }
71
72 global.Debug("STDOUT exporter export", "Data", data)
73
74 return e.encVal.Load().(encoderHolder).Encode(data)
75 }
76
77 func (*exporter) ForceFlush(context.Context) error {
78 // exporter holds no state, nothing to flush.
79 return nil
80 }
81
82 func (e *exporter) Shutdown(context.Context) error {
83 e.shutdownOnce.Do(func() {
84 e.encVal.Store(encoderHolder{
85 encoder: shutdownEncoder{},
86 })
87 })
88 return nil
89 }
90
91 func (*exporter) MarshalLog() any {
92 return struct{ Type string }{Type: "STDOUT"}
93 }
94
95 func redactTimestamps(orig *metricdata.ResourceMetrics) {
96 for i, sm := range orig.ScopeMetrics {
97 metrics := sm.Metrics
98 for j, m := range metrics {
99 data := m.Data
100 orig.ScopeMetrics[i].Metrics[j].Data = redactAggregationTimestamps(data)
101 }
102 }
103 }
104
105 var errUnknownAggType = errors.New("unknown aggregation type")
106
107 func redactAggregationTimestamps(orig metricdata.Aggregation) metricdata.Aggregation {
108 switch a := orig.(type) {
109 case metricdata.Sum[float64]:
110 return metricdata.Sum[float64]{
111 Temporality: a.Temporality,
112 DataPoints: redactDataPointTimestamps(a.DataPoints),
113 IsMonotonic: a.IsMonotonic,
114 }
115 case metricdata.Sum[int64]:
116 return metricdata.Sum[int64]{
117 Temporality: a.Temporality,
118 DataPoints: redactDataPointTimestamps(a.DataPoints),
119 IsMonotonic: a.IsMonotonic,
120 }
121 case metricdata.Gauge[float64]:
122 return metricdata.Gauge[float64]{
123 DataPoints: redactDataPointTimestamps(a.DataPoints),
124 }
125 case metricdata.Gauge[int64]:
126 return metricdata.Gauge[int64]{
127 DataPoints: redactDataPointTimestamps(a.DataPoints),
128 }
129 case metricdata.Histogram[int64]:
130 return metricdata.Histogram[int64]{
131 Temporality: a.Temporality,
132 DataPoints: redactHistogramTimestamps(a.DataPoints),
133 }
134 case metricdata.Histogram[float64]:
135 return metricdata.Histogram[float64]{
136 Temporality: a.Temporality,
137 DataPoints: redactHistogramTimestamps(a.DataPoints),
138 }
139 default:
140 global.Error(errUnknownAggType, fmt.Sprintf("%T", a))
141 return orig
142 }
143 }
144
145 func redactHistogramTimestamps[T int64 | float64](
146 hdp []metricdata.HistogramDataPoint[T],
147 ) []metricdata.HistogramDataPoint[T] {
148 out := make([]metricdata.HistogramDataPoint[T], len(hdp))
149 for i, dp := range hdp {
150 out[i] = metricdata.HistogramDataPoint[T]{
151 Attributes: dp.Attributes,
152 Count: dp.Count,
153 Sum: dp.Sum,
154 Bounds: dp.Bounds,
155 BucketCounts: dp.BucketCounts,
156 Min: dp.Min,
157 Max: dp.Max,
158 }
159 }
160 return out
161 }
162
163 func redactDataPointTimestamps[T int64 | float64](sdp []metricdata.DataPoint[T]) []metricdata.DataPoint[T] {
164 out := make([]metricdata.DataPoint[T], len(sdp))
165 for i, dp := range sdp {
166 out[i] = metricdata.DataPoint[T]{
167 Attributes: dp.Attributes,
168 Value: dp.Value,
169 }
170 }
171 return out
172 }
173
174 // countDataPoints counts the total number of data points in a ResourceMetrics.
175 func countDataPoints(rm *metricdata.ResourceMetrics) int64 {
176 if rm == nil {
177 return 0
178 }
179
180 var total int64
181 for _, sm := range rm.ScopeMetrics {
182 for _, m := range sm.Metrics {
183 switch data := m.Data.(type) {
184 case metricdata.Gauge[int64]:
185 total += int64(len(data.DataPoints))
186 case metricdata.Gauge[float64]:
187 total += int64(len(data.DataPoints))
188 case metricdata.Sum[int64]:
189 total += int64(len(data.DataPoints))
190 case metricdata.Sum[float64]:
191 total += int64(len(data.DataPoints))
192 case metricdata.Histogram[int64]:
193 total += int64(len(data.DataPoints))
194 case metricdata.Histogram[float64]:
195 total += int64(len(data.DataPoints))
196 case metricdata.ExponentialHistogram[int64]:
197 total += int64(len(data.DataPoints))
198 case metricdata.ExponentialHistogram[float64]:
199 total += int64(len(data.DataPoints))
200 case metricdata.Summary:
201 total += int64(len(data.DataPoints))
202 }
203 }
204 }
205 return total
206 }