-
Notifications
You must be signed in to change notification settings - Fork 2
/
jaeger.go
153 lines (135 loc) · 4.84 KB
/
jaeger.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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
// Package jaeger wraps the Jaeger tracer
package jaeger
import (
"fmt"
"io"
opentracing "github.com/opentracing/opentracing-go"
"github.com/pkg/errors"
"github.com/deixis/spine/config"
"github.com/deixis/spine/log"
"github.com/deixis/spine/stats"
"github.com/deixis/spine/tracing"
"github.com/uber/jaeger-client-go"
jaegerconfig "github.com/uber/jaeger-client-go/config"
jaegermetrics "github.com/uber/jaeger-lib/metrics"
)
const Name = "jaeger"
func New(tree config.Tree, o ...tracing.TracerOption) (tracing.Tracer, error) {
config := &Config{}
if err := tree.Unmarshal(config); err != nil {
return nil, errors.Wrap(err, "cannot unmarshal tracing.jaeger config")
}
jconfig := jaegerconfig.Configuration{
ServiceName: config.ServiceName,
Disabled: config.Disabled,
RPCMetrics: config.RPCMetrics,
}
jconfig.Tags = make([]opentracing.Tag, 0, len(config.Tags))
for k, v := range config.Tags {
jconfig.Tags = append(jconfig.Tags, opentracing.Tag{Key: k, Value: v})
}
if config.Sampler != nil {
jconfig.Sampler = &jaegerconfig.SamplerConfig{
Type: config.Sampler.Type,
Param: config.Sampler.Param,
SamplingServerURL: config.Sampler.SamplingServerURL,
MaxOperations: config.Sampler.MaxOperations,
SamplingRefreshInterval: config.Sampler.SamplingRefreshInterval,
}
}
if config.Reporter != nil {
jconfig.Reporter = &jaegerconfig.ReporterConfig{
QueueSize: config.Reporter.QueueSize,
BufferFlushInterval: config.Reporter.BufferFlushInterval,
LogSpans: config.Reporter.LogSpans,
LocalAgentHostPort: config.Reporter.LocalAgentHostPort,
CollectorEndpoint: config.Reporter.CollectorEndpoint,
User: config.Reporter.User,
Password: config.Reporter.Password,
}
}
if config.Headers != nil {
jconfig.Headers = &jaeger.HeadersConfig{
JaegerDebugHeader: config.Headers.JaegerDebugHeader,
JaegerBaggageHeader: config.Headers.JaegerBaggageHeader,
TraceContextHeaderName: config.Headers.TraceContextHeaderName,
TraceBaggageHeaderPrefix: config.Headers.TraceBaggageHeaderPrefix,
}
}
if config.BaggageRestrictions != nil {
jconfig.BaggageRestrictions = &jaegerconfig.BaggageRestrictionsConfig{
DenyBaggageOnInitializationFailure: config.BaggageRestrictions.DenyBaggageOnInitializationFailure,
HostPort: config.BaggageRestrictions.HostPort,
RefreshInterval: config.BaggageRestrictions.RefreshInterval,
}
}
if config.Throttler != nil {
jconfig.Throttler = &jaegerconfig.ThrottlerConfig{
HostPort: config.Throttler.HostPort,
RefreshInterval: config.Throttler.RefreshInterval,
SynchronousInitialization: config.Throttler.SynchronousInitialization,
}
}
opts := tracing.TracerOptions{
Logger: log.NopLogger(),
Stats: stats.NopStats(),
}
for _, o := range o {
o(&opts)
}
jmet := jaegermetrics.NullFactory // TODO: Wrap spine stats
// Initialize tracer with a logger and a metrics factory
tracer, closer, err := jconfig.NewTracer(
jaegerconfig.Logger(&Logger{L: opts.Logger}),
jaegerconfig.Metrics(jmet),
)
if err != nil {
return nil, err
}
return &Tracer{
Tracer: tracer,
Closer: closer,
}, nil
}
type Tracer struct {
// Tracer is a jaeger Tracer instance
Tracer opentracing.Tracer
// Closer is the jaeger Closer that can be used to flush buffers before shutdown
Closer io.Closer
}
func (t *Tracer) StartSpan(operationName string, opts ...opentracing.StartSpanOption) opentracing.Span {
return t.Tracer.StartSpan(operationName, opts...)
}
func (t *Tracer) Inject(sm opentracing.SpanContext, format interface{}, carrier interface{}) error {
return t.Tracer.Inject(sm, format, carrier)
}
func (t *Tracer) Extract(format interface{}, carrier interface{}) (opentracing.SpanContext, error) {
return t.Tracer.Extract(format, carrier)
}
func (t *Tracer) Close() error {
return t.Closer.Close()
}
// Logger wraps Jaeger logs with spine
type Logger struct {
// L is a spine logger
L log.Logger
}
// Error logs a message at error priority
func (l *Logger) Error(msg string) {
// Log it as a warning in case Jaeger takes the error level lightly
l.L.Warning("tracing.jaeger.err", msg)
}
// Infof logs a message at info priority
func (l *Logger) Infof(msg string, args ...interface{}) {
l.L.Trace("tracing.jaeger.info", fmt.Sprintf(msg, args...))
}
// Metrics wrap Jaeger metrics with spine
// TODO:
// type Metrics struct{}
//
// func (m *Metrics) Counter(name string, tags map[string]string) metrics.Counter {}
// func (m *Metrics) Timer(name string, tags map[string]string) metrics.Timer {}
// func (m *Metrics) Gauge(name string, tags map[string]string) metrics.Gauge {}
//
// // Namespace returns a nested metrics factory.
// func (m *Metrics) Namespace(name string, tags map[string]string) metrics.Factory {}