blob: e0e50e8346ddef9da98e62c5f54c4b94e41f7635 [file] [log] [blame]
mpagenkoaf801632020-07-03 10:00:42 +00001// Copyright (c) 2017 Uber Technologies, Inc.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package config
16
17import (
18 opentracing "github.com/opentracing/opentracing-go"
19 "github.com/uber/jaeger-lib/metrics"
20
21 "github.com/uber/jaeger-client-go"
22)
23
24// Option is a function that sets some option on the client.
25type Option func(c *Options)
26
27// Options control behavior of the client.
28type Options struct {
29 metrics metrics.Factory
30 logger jaeger.Logger
31 reporter jaeger.Reporter
32 sampler jaeger.Sampler
33 contribObservers []jaeger.ContribObserver
34 observers []jaeger.Observer
35 gen128Bit bool
36 poolSpans bool
37 zipkinSharedRPCSpan bool
38 maxTagValueLength int
39 noDebugFlagOnForcedSampling bool
40 tags []opentracing.Tag
41 injectors map[interface{}]jaeger.Injector
42 extractors map[interface{}]jaeger.Extractor
43}
44
45// Metrics creates an Option that initializes Metrics in the tracer,
46// which is used to emit statistics about spans.
47func Metrics(factory metrics.Factory) Option {
48 return func(c *Options) {
49 c.metrics = factory
50 }
51}
52
53// Logger can be provided to log Reporter errors, as well as to log spans
54// if Reporter.LogSpans is set to true.
55func Logger(logger jaeger.Logger) Option {
56 return func(c *Options) {
57 c.logger = logger
58 }
59}
60
61// Reporter can be provided explicitly to override the configuration.
62// Useful for testing, e.g. by passing InMemoryReporter.
63func Reporter(reporter jaeger.Reporter) Option {
64 return func(c *Options) {
65 c.reporter = reporter
66 }
67}
68
69// Sampler can be provided explicitly to override the configuration.
70func Sampler(sampler jaeger.Sampler) Option {
71 return func(c *Options) {
72 c.sampler = sampler
73 }
74}
75
76// Observer can be registered with the Tracer to receive notifications about new Spans.
77func Observer(observer jaeger.Observer) Option {
78 return func(c *Options) {
79 c.observers = append(c.observers, observer)
80 }
81}
82
83// ContribObserver can be registered with the Tracer to receive notifications
84// about new spans.
85func ContribObserver(observer jaeger.ContribObserver) Option {
86 return func(c *Options) {
87 c.contribObservers = append(c.contribObservers, observer)
88 }
89}
90
91// Gen128Bit specifies whether to generate 128bit trace IDs.
92func Gen128Bit(gen128Bit bool) Option {
93 return func(c *Options) {
94 c.gen128Bit = gen128Bit
95 }
96}
97
98// PoolSpans specifies whether to pool spans
99func PoolSpans(poolSpans bool) Option {
100 return func(c *Options) {
101 c.poolSpans = poolSpans
102 }
103}
104
105// ZipkinSharedRPCSpan creates an option that enables sharing span ID between client
106// and server spans a la zipkin. If false, client and server spans will be assigned
107// different IDs.
108func ZipkinSharedRPCSpan(zipkinSharedRPCSpan bool) Option {
109 return func(c *Options) {
110 c.zipkinSharedRPCSpan = zipkinSharedRPCSpan
111 }
112}
113
114// MaxTagValueLength can be provided to override the default max tag value length.
115func MaxTagValueLength(maxTagValueLength int) Option {
116 return func(c *Options) {
117 c.maxTagValueLength = maxTagValueLength
118 }
119}
120
121// NoDebugFlagOnForcedSampling can be used to decide whether debug flag will be set or not
122// when calling span.setSamplingPriority to force sample a span.
123func NoDebugFlagOnForcedSampling(noDebugFlagOnForcedSampling bool) Option {
124 return func(c *Options) {
125 c.noDebugFlagOnForcedSampling = noDebugFlagOnForcedSampling
126 }
127}
128
129// Tag creates an option that adds a tracer-level tag.
130func Tag(key string, value interface{}) Option {
131 return func(c *Options) {
132 c.tags = append(c.tags, opentracing.Tag{Key: key, Value: value})
133 }
134}
135
136// Injector registers an Injector with the given format.
137func Injector(format interface{}, injector jaeger.Injector) Option {
138 return func(c *Options) {
139 c.injectors[format] = injector
140 }
141}
142
143// Extractor registers an Extractor with the given format.
144func Extractor(format interface{}, extractor jaeger.Extractor) Option {
145 return func(c *Options) {
146 c.extractors[format] = extractor
147 }
148}
149
150func applyOptions(options ...Option) Options {
151 opts := Options{
152 injectors: make(map[interface{}]jaeger.Injector),
153 extractors: make(map[interface{}]jaeger.Extractor),
154 }
155 for _, option := range options {
156 option(&opts)
157 }
158 if opts.metrics == nil {
159 opts.metrics = metrics.NullFactory
160 }
161 if opts.logger == nil {
162 opts.logger = jaeger.NullLogger
163 }
164 return opts
165}