| 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 |
} |