Debian Codegraph @

internal/global/state.go

raw
1 // Copyright The OpenTelemetry Authors
2 // SPDX-License-Identifier: Apache-2.0
3
4 package global // import "go.opentelemetry.io/otel/internal/global"
5
6 import (
7 "errors"
8 "sync"
9 "sync/atomic"
10
11 "go.opentelemetry.io/otel/internal/errorhandler"
12 "go.opentelemetry.io/otel/metric"
13 "go.opentelemetry.io/otel/propagation"
14 "go.opentelemetry.io/otel/trace"
15 )
16
17 type (
18 tracerProviderHolder struct {
19 tp trace.TracerProvider
20 }
21
22 propagatorsHolder struct {
23 tm propagation.TextMapPropagator
24 }
25
26 meterProviderHolder struct {
27 mp metric.MeterProvider
28 }
29 )
30
31 var (
32 globalTracer = defaultTracerValue()
33 globalPropagators = defaultPropagatorsValue()
34 globalMeterProvider = defaultMeterProvider()
35
36 delegateTraceOnce sync.Once
37 delegateTextMapPropagatorOnce sync.Once
38 delegateMeterOnce sync.Once
39 )
40
41 // GetErrorHandler returns the global ErrorHandler instance.
42 //
43 // The default ErrorHandler instance returned will log all errors to STDERR
44 // until an override ErrorHandler is set with SetErrorHandler. All
45 // ErrorHandler returned prior to this will automatically forward errors to
46 // the set instance instead of logging.
47 //
48 // Subsequent calls to SetErrorHandler after the first will not forward errors
49 // to the new ErrorHandler for prior returned instances.
50 func GetErrorHandler() ErrorHandler {
51 return errorhandler.GetErrorHandler()
52 }
53
54 // SetErrorHandler sets the global ErrorHandler to h.
55 //
56 // The first time this is called all ErrorHandler previously returned from
57 // GetErrorHandler will send errors to h instead of the default logging
58 // ErrorHandler. Subsequent calls will set the global ErrorHandler, but not
59 // delegate errors to h.
60 func SetErrorHandler(h ErrorHandler) {
61 errorhandler.SetErrorHandler(h)
62 }
63
64 // TracerProvider is the internal implementation for global.TracerProvider.
65 func TracerProvider() trace.TracerProvider {
66 return globalTracer.Load().(tracerProviderHolder).tp
67 }
68
69 // SetTracerProvider is the internal implementation for global.SetTracerProvider.
70 func SetTracerProvider(tp trace.TracerProvider) {
71 current := TracerProvider()
72
73 if _, cOk := current.(*tracerProvider); cOk {
74 if _, tpOk := tp.(*tracerProvider); tpOk && current == tp {
75 // Do not assign the default delegating TracerProvider to delegate
76 // to itself.
77 Error(
78 errors.New("no delegate configured in tracer provider"),
79 "Setting tracer provider to its current value. No delegate will be configured",
80 )
81 return
82 }
83 }
84
85 delegateTraceOnce.Do(func() {
86 if def, ok := current.(*tracerProvider); ok {
87 def.setDelegate(tp)
88 }
89 })
90 globalTracer.Store(tracerProviderHolder{tp: tp})
91 }
92
93 // TextMapPropagator is the internal implementation for global.TextMapPropagator.
94 func TextMapPropagator() propagation.TextMapPropagator {
95 return globalPropagators.Load().(propagatorsHolder).tm
96 }
97
98 // SetTextMapPropagator is the internal implementation for global.SetTextMapPropagator.
99 func SetTextMapPropagator(p propagation.TextMapPropagator) {
100 current := TextMapPropagator()
101
102 if _, cOk := current.(*textMapPropagator); cOk {
103 if _, pOk := p.(*textMapPropagator); pOk && current == p {
104 // Do not assign the default delegating TextMapPropagator to
105 // delegate to itself.
106 Error(
107 errors.New("no delegate configured in text map propagator"),
108 "Setting text map propagator to its current value. No delegate will be configured",
109 )
110 return
111 }
112 }
113
114 // For the textMapPropagator already returned by TextMapPropagator
115 // delegate to p.
116 delegateTextMapPropagatorOnce.Do(func() {
117 if def, ok := current.(*textMapPropagator); ok {
118 def.SetDelegate(p)
119 }
120 })
121 // Return p when subsequent calls to TextMapPropagator are made.
122 globalPropagators.Store(propagatorsHolder{tm: p})
123 }
124
125 // MeterProvider is the internal implementation for global.MeterProvider.
126 func MeterProvider() metric.MeterProvider {
127 return globalMeterProvider.Load().(meterProviderHolder).mp
128 }
129
130 // SetMeterProvider is the internal implementation for global.SetMeterProvider.
131 func SetMeterProvider(mp metric.MeterProvider) {
132 current := MeterProvider()
133 if _, cOk := current.(*meterProvider); cOk {
134 if _, mpOk := mp.(*meterProvider); mpOk && current == mp {
135 // Do not assign the default delegating MeterProvider to delegate
136 // to itself.
137 Error(
138 errors.New("no delegate configured in meter provider"),
139 "Setting meter provider to its current value. No delegate will be configured",
140 )
141 return
142 }
143 }
144
145 delegateMeterOnce.Do(func() {
146 if def, ok := current.(*meterProvider); ok {
147 def.setDelegate(mp)
148 }
149 })
150 globalMeterProvider.Store(meterProviderHolder{mp: mp})
151 }
152
153 func defaultTracerValue() *atomic.Value {
154 v := &atomic.Value{}
155 v.Store(tracerProviderHolder{tp: &tracerProvider{}})
156 return v
157 }
158
159 func defaultPropagatorsValue() *atomic.Value {
160 v := &atomic.Value{}
161 v.Store(propagatorsHolder{tm: newTextMapPropagator()})
162 return v
163 }
164
165 func defaultMeterProvider() *atomic.Value {
166 v := &atomic.Value{}
167 v.Store(meterProviderHolder{mp: &meterProvider{}})
168 return v
169 }