@@ -6,36 +6,27 @@ import (
66 "errors"
77 "fmt"
88 "log"
9- "net/http"
109 "os"
11- "time "
10+ "strings "
1211
13- "github.com/prometheus/client_golang/prometheus"
14- "github.com/prometheus/client_golang/prometheus/promhttp"
15- otelprom "go.opentelemetry.io/contrib/bridges/prometheus"
12+ "go.opentelemetry.io/contrib/exporters/autoexport"
1613 "go.opentelemetry.io/otel"
17- "go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc"
18- "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
19- promexp "go.opentelemetry.io/otel/exporters/prometheus"
2014 "go.opentelemetry.io/otel/propagation"
2115 "go.opentelemetry.io/otel/sdk/metric"
2216 "go.opentelemetry.io/otel/sdk/resource"
2317 "go.opentelemetry.io/otel/sdk/trace"
2418)
2519
26- const (
27- metricsEndpoint = "/metrics"
28- shutdownTimeout = 5 * time .Second
29- trueString = "true"
30- )
31-
3220// InitGlobalTraceProvider initializes and sets a global trace provider for OpenTelemetry.
3321func InitGlobalTraceProvider (ctx context.Context ) (func (context.Context ) (error , error ), error ) {
34- var (
35- traceProvider * trace.TracerProvider
36- meterProvider * metric.MeterProvider
37- err error
38- )
22+ sdkDisabled := getBoolEnv ("OTEL_SDK_DISABLED" )
23+ if sdkDisabled {
24+ log .Println ("OTEL_SDK_DISABLED is set to true, skipping OpenTelemetry initialization" )
25+
26+ return func (_ context.Context ) (error , error ) {
27+ return nil , nil //nolint:nilnil // No-op shutdown function.
28+ }, nil
29+ }
3930
4031 res , err := resource .New (ctx , resource .WithFromEnv (), resource .WithHost ())
4132 if errors .Is (err , resource .ErrPartialResource ) ||
@@ -45,49 +36,23 @@ func InitGlobalTraceProvider(ctx context.Context) (func(context.Context) (error,
4536 return nil , fmt .Errorf ("failed initializing otlp resource: %w" , err )
4637 }
4738
48- if shouldEnableTracing () {
49- traceProvider , err = initTracerProvider (ctx , res )
50- if err != nil {
51- return nil , err
52- }
39+ traceProvider , err := initTracerProvider (ctx , res )
40+ if err != nil {
41+ return nil , err
5342 }
5443
55- if shouldEnableMetrics () {
56- meterProvider , err = initMeterProvider (ctx , res )
57- if err != nil {
58- return nil , err
59- }
44+ meterProvider , err := initMeterProvider (ctx , res )
45+ if err != nil {
46+ return nil , err
6047 }
6148
6249 return func (ctx context.Context ) (error , error ) {
63- var traceErr , metricErr error
64-
65- if traceProvider != nil {
66- traceErr = traceProvider .Shutdown (ctx )
67- }
68-
69- if meterProvider != nil {
70- metricErr = meterProvider .Shutdown (ctx )
71- }
72-
73- return traceErr , metricErr
50+ return traceProvider .Shutdown (ctx ), meterProvider .Shutdown (ctx )
7451 }, nil
7552}
7653
77- func shouldEnableTracing () bool {
78- enableTracing := os .Getenv ("CF_TELEMETRY_ENABLE" )
79- if enableTracing != trueString {
80- enableTracing = os .Getenv ("CF_TELEMETRY_TRACE_ENABLE" )
81- }
82-
83- return enableTracing == trueString
84- }
85-
86- func initTracerProvider (
87- ctx context.Context ,
88- res * resource.Resource ,
89- ) (* trace.TracerProvider , error ) {
90- exporter , err := otlptracegrpc .New (ctx )
54+ func initTracerProvider (ctx context.Context , res * resource.Resource ) (* trace.TracerProvider , error ) {
55+ exporter , err := autoexport .NewSpanExporter (ctx )
9156 if err != nil {
9257 return nil , fmt .Errorf ("failed initializing global trace provider: %w" , err )
9358 }
@@ -108,92 +73,23 @@ func initTracerProvider(
10873 return traceprovider , nil
10974}
11075
111- func shouldEnableMetrics () bool {
112- enableMetrics := os .Getenv ("CF_TELEMETRY_ENABLE" )
113- if enableMetrics != trueString {
114- enableMetrics = os .Getenv ("CF_TELEMETRY_METRICS_ENABLE" )
115- }
116-
117- return enableMetrics == trueString
118- }
119-
12076func initMeterProvider (ctx context.Context , res * resource.Resource ) (* metric.MeterProvider , error ) {
121- meterProvider , err := newMeterProvider (ctx , res )
77+ reader , err := autoexport . NewMetricReader (ctx )
12278 if err != nil {
123- return nil , fmt .Errorf ("failed initializing global meter provider : %w" , err )
79+ return nil , fmt .Errorf ("failed initializing autoexport metric reader : %w" , err )
12480 }
12581
82+ meterProvider := metric .NewMeterProvider (
83+ metric .WithResource (res ),
84+ metric .WithReader (reader ),
85+ )
12686 otel .SetMeterProvider (meterProvider )
12787
12888 return meterProvider , nil
12989}
13090
131- func newMeterProvider ( ctx context. Context , res * resource. Resource ) ( * metric. MeterProvider , error ) {
132- metricsBindAddress := os .Getenv ("METRICS_BIND_ADDRESS" )
91+ func getBoolEnv ( key string ) bool {
92+ val := os .Getenv (key )
13393
134- var (
135- reader metric.Reader
136- err error
137- )
138- if metricsBindAddress != "" && metricsBindAddress != "0" {
139- // using prometheus
140- reader , err = promexp .New ()
141- if err != nil {
142- return nil , fmt .Errorf ("failed to create Prometheus exporter: %w" , err )
143- }
144-
145- go serveMetrics (ctx , metricsBindAddress )
146- } else {
147- // using otlp grpc
148- exporter , err := otlpmetricgrpc .New (ctx )
149- if err != nil {
150- return nil , fmt .Errorf ("failed to create OTLP metric exporter: %w" , err )
151- }
152-
153- // make sure to read from the prometheus default gatherer
154- promBridge := otelprom .NewMetricProducer (
155- otelprom .WithGatherer (prometheus .DefaultGatherer ),
156- )
157-
158- reader = metric .NewPeriodicReader (
159- exporter ,
160- metric .WithProducer (promBridge ),
161- )
162- }
163-
164- return metric .NewMeterProvider (
165- metric .WithResource (res ),
166- metric .WithReader (reader ),
167- ), nil
168- }
169-
170- func serveMetrics (ctx context.Context , metricsBindAddress string ) {
171- log .Printf ("serving metrics at localhost%s/metrics" , metricsBindAddress )
172-
173- mux := http .NewServeMux ()
174- mux .Handle (metricsEndpoint , promhttp .Handler ())
175- //nolint:gosec // Ignoring G112: Use of net/http serve function that has no support for setting timeouts.
176- server := & http.Server {
177- Addr : metricsBindAddress ,
178- Handler : mux ,
179- }
180-
181- go func () {
182- <- ctx .Done ()
183-
184- shutdownCtx , cancel := context .WithTimeout (context .Background (), shutdownTimeout )
185- defer cancel ()
186- //nolint:contextcheck // We must use context.Background() here because the parent ctx is already canceled.
187- err := server .Shutdown (shutdownCtx )
188- if err != nil {
189- log .Printf ("failed to shutdown metrics server: %v" , err )
190- }
191- }()
192-
193- err := server .ListenAndServe ()
194- if err != nil && ! errors .Is (err , http .ErrServerClosed ) {
195- log .Printf ("error serving http: %v" , err )
196-
197- return
198- }
94+ return strings .EqualFold (val , "true" )
19995}
0 commit comments