/
tracer.go
105 lines (86 loc) · 2.37 KB
/
tracer.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
package otlp_util
import (
"context"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/exporters/otlp/otlptrace"
"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
"go.opentelemetry.io/otel/propagation"
"go.opentelemetry.io/otel/sdk/resource"
sdktrace "go.opentelemetry.io/otel/sdk/trace"
semconv "go.opentelemetry.io/otel/semconv/v1.12.0"
"go.opentelemetry.io/otel/trace"
)
type InitOption func(*config)
type config struct {
serviceName string
endPoint string
grpcInSecure bool
errorHandler otel.ErrorHandlerFunc
}
func InitGlobalTracer(opts ...InitOption) {
cfg := config{}
for _, opt := range opts {
opt(&cfg)
}
r, err := resource.New(
context.Background(),
resource.WithAttributes(semconv.ServiceNameKey.String(cfg.serviceName)),
)
if err != nil {
panic(err)
}
options := make([]otlptracegrpc.Option, 0, 8)
options = append(options, otlptracegrpc.WithEndpoint(cfg.endPoint))
if cfg.grpcInSecure {
options = append(options, otlptracegrpc.WithInsecure())
}
client := otlptracegrpc.NewClient(options...)
exporter, err := otlptrace.New(context.Background(), client)
if err != nil {
panic(err)
}
sp := sdktrace.NewBatchSpanProcessor(
exporter,
)
provider := sdktrace.NewTracerProvider(
sdktrace.WithResource(r),
sdktrace.WithSpanProcessor(sp),
)
global_tracer_provider = provider
otel.SetTracerProvider(global_tracer_provider)
tracer := otel.GetTracerProvider().Tracer(cfg.serviceName)
global_tracer = tracer
otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(propagation.TraceContext{}, propagation.Baggage{}))
if cfg.errorHandler != nil {
otel.SetErrorHandler(cfg.errorHandler)
}
}
func WithServiceName(name string) InitOption {
return func(c *config) {
c.serviceName = name
}
}
func WithEndPoint(endPoint string) InitOption {
return func(c *config) {
c.endPoint = endPoint
}
}
func WithInSecure() InitOption {
return func(c *config) {
c.grpcInSecure = true
}
}
func WithErrorHandler(handler otel.ErrorHandlerFunc) InitOption {
return func(c *config) {
c.errorHandler = handler
}
}
func Start(ctx context.Context, spanName string, opts ...trace.SpanStartOption) (context.Context, trace.Span) {
return global_tracer.Start(ctx, spanName, opts...)
}
func ForceFlush(ctx context.Context) error {
if global_tracer_provider == nil {
return nil
}
return global_tracer_provider.ForceFlush(ctx)
}