Debian Codegraph @

internal/errorhandler/errorhandler.go

raw
1 // Copyright The OpenTelemetry Authors
2 // SPDX-License-Identifier: Apache-2.0
3
4 // Package errorhandler provides the global error handler for OpenTelemetry.
5 //
6 // This package has no OTel dependencies, allowing it to be imported by any
7 // package in the module without creating import cycles.
8 package errorhandler // import "go.opentelemetry.io/otel/internal/errorhandler"
9
10 import (
11 "errors"
12 "log"
13 "sync"
14 "sync/atomic"
15 )
16
17 // ErrorHandler handles irremediable events.
18 type ErrorHandler interface {
19 // Handle handles any error deemed irremediable by an OpenTelemetry
20 // component.
21 Handle(error)
22 }
23
24 type ErrDelegator struct {
25 delegate atomic.Pointer[ErrorHandler]
26 }
27
28 // Compile-time check that delegator implements ErrorHandler.
29 var _ ErrorHandler = (*ErrDelegator)(nil)
30
31 func (d *ErrDelegator) Handle(err error) {
32 if eh := d.delegate.Load(); eh != nil {
33 (*eh).Handle(err)
34 return
35 }
36 log.Print(err)
37 }
38
39 // setDelegate sets the ErrorHandler delegate.
40 func (d *ErrDelegator) setDelegate(eh ErrorHandler) {
41 d.delegate.Store(&eh)
42 }
43
44 type errorHandlerHolder struct {
45 eh ErrorHandler
46 }
47
48 var (
49 globalErrorHandler = defaultErrorHandler()
50 delegateErrorHandlerOnce sync.Once
51 )
52
53 // GetErrorHandler returns the global ErrorHandler instance.
54 //
55 // The default ErrorHandler instance returned will log all errors to STDERR
56 // until an override ErrorHandler is set with SetErrorHandler. All
57 // ErrorHandler returned prior to this will automatically forward errors to
58 // the set instance instead of logging.
59 //
60 // Subsequent calls to SetErrorHandler after the first will not forward errors
61 // to the new ErrorHandler for prior returned instances.
62 func GetErrorHandler() ErrorHandler {
63 return globalErrorHandler.Load().(errorHandlerHolder).eh
64 }
65
66 // SetErrorHandler sets the global ErrorHandler to h.
67 //
68 // The first time this is called all ErrorHandler previously returned from
69 // GetErrorHandler will send errors to h instead of the default logging
70 // ErrorHandler. Subsequent calls will set the global ErrorHandler, but not
71 // delegate errors to h.
72 func SetErrorHandler(h ErrorHandler) {
73 current := GetErrorHandler()
74
75 if _, cOk := current.(*ErrDelegator); cOk {
76 if _, ehOk := h.(*ErrDelegator); ehOk && current == h {
77 // Do not assign to the delegate of the default ErrDelegator to be
78 // itself.
79 log.Print(errors.New("no ErrorHandler delegate configured"), " ErrorHandler remains its current value.")
80 return
81 }
82 }
83
84 delegateErrorHandlerOnce.Do(func() {
85 if def, ok := current.(*ErrDelegator); ok {
86 def.setDelegate(h)
87 }
88 })
89 globalErrorHandler.Store(errorHandlerHolder{eh: h})
90 }
91
92 func defaultErrorHandler() *atomic.Value {
93 v := &atomic.Value{}
94 v.Store(errorHandlerHolder{eh: &ErrDelegator{}})
95 return v
96 }