1package ext
2
3import "github.com/opentracing/opentracing-go"
4
5// These constants define common tag names recommended for better portability across
6// tracing systems and languages/platforms.
7//
8// The tag names are defined as typed strings, so that in addition to the usual use
9//
10//     span.setTag(TagName, value)
11//
12// they also support value type validation via this additional syntax:
13//
14//    TagName.Set(span, value)
15//
16var (
17	//////////////////////////////////////////////////////////////////////
18	// SpanKind (client/server or producer/consumer)
19	//////////////////////////////////////////////////////////////////////
20
21	// SpanKind hints at relationship between spans, e.g. client/server
22	SpanKind = spanKindTagName("span.kind")
23
24	// SpanKindRPCClient marks a span representing the client-side of an RPC
25	// or other remote call
26	SpanKindRPCClientEnum = SpanKindEnum("client")
27	SpanKindRPCClient     = opentracing.Tag{Key: string(SpanKind), Value: SpanKindRPCClientEnum}
28
29	// SpanKindRPCServer marks a span representing the server-side of an RPC
30	// or other remote call
31	SpanKindRPCServerEnum = SpanKindEnum("server")
32	SpanKindRPCServer     = opentracing.Tag{Key: string(SpanKind), Value: SpanKindRPCServerEnum}
33
34	// SpanKindProducer marks a span representing the producer-side of a
35	// message bus
36	SpanKindProducerEnum = SpanKindEnum("producer")
37	SpanKindProducer     = opentracing.Tag{Key: string(SpanKind), Value: SpanKindProducerEnum}
38
39	// SpanKindConsumer marks a span representing the consumer-side of a
40	// message bus
41	SpanKindConsumerEnum = SpanKindEnum("consumer")
42	SpanKindConsumer     = opentracing.Tag{Key: string(SpanKind), Value: SpanKindConsumerEnum}
43
44	//////////////////////////////////////////////////////////////////////
45	// Component name
46	//////////////////////////////////////////////////////////////////////
47
48	// Component is a low-cardinality identifier of the module, library,
49	// or package that is generating a span.
50	Component = stringTagName("component")
51
52	//////////////////////////////////////////////////////////////////////
53	// Sampling hint
54	//////////////////////////////////////////////////////////////////////
55
56	// SamplingPriority determines the priority of sampling this Span.
57	SamplingPriority = uint16TagName("sampling.priority")
58
59	//////////////////////////////////////////////////////////////////////
60	// Peer tags. These tags can be emitted by either client-side of
61	// server-side to describe the other side/service in a peer-to-peer
62	// communications, like an RPC call.
63	//////////////////////////////////////////////////////////////////////
64
65	// PeerService records the service name of the peer.
66	PeerService = stringTagName("peer.service")
67
68	// PeerAddress records the address name of the peer. This may be a "ip:port",
69	// a bare "hostname", a FQDN or even a database DSN substring
70	// like "mysql://username@127.0.0.1:3306/dbname"
71	PeerAddress = stringTagName("peer.address")
72
73	// PeerHostname records the host name of the peer
74	PeerHostname = stringTagName("peer.hostname")
75
76	// PeerHostIPv4 records IP v4 host address of the peer
77	PeerHostIPv4 = ipv4Tag("peer.ipv4")
78
79	// PeerHostIPv6 records IP v6 host address of the peer
80	PeerHostIPv6 = stringTagName("peer.ipv6")
81
82	// PeerPort records port number of the peer
83	PeerPort = uint16TagName("peer.port")
84
85	//////////////////////////////////////////////////////////////////////
86	// HTTP Tags
87	//////////////////////////////////////////////////////////////////////
88
89	// HTTPUrl should be the URL of the request being handled in this segment
90	// of the trace, in standard URI format. The protocol is optional.
91	HTTPUrl = stringTagName("http.url")
92
93	// HTTPMethod is the HTTP method of the request, and is case-insensitive.
94	HTTPMethod = stringTagName("http.method")
95
96	// HTTPStatusCode is the numeric HTTP status code (200, 404, etc) of the
97	// HTTP response.
98	HTTPStatusCode = uint16TagName("http.status_code")
99
100	//////////////////////////////////////////////////////////////////////
101	// DB Tags
102	//////////////////////////////////////////////////////////////////////
103
104	// DBInstance is database instance name.
105	DBInstance = stringTagName("db.instance")
106
107	// DBStatement is a database statement for the given database type.
108	// It can be a query or a prepared statement (i.e., before substitution).
109	DBStatement = stringTagName("db.statement")
110
111	// DBType is a database type. For any SQL database, "sql".
112	// For others, the lower-case database category, e.g. "redis"
113	DBType = stringTagName("db.type")
114
115	// DBUser is a username for accessing database.
116	DBUser = stringTagName("db.user")
117
118	//////////////////////////////////////////////////////////////////////
119	// Message Bus Tag
120	//////////////////////////////////////////////////////////////////////
121
122	// MessageBusDestination is an address at which messages can be exchanged
123	MessageBusDestination = stringTagName("message_bus.destination")
124
125	//////////////////////////////////////////////////////////////////////
126	// Error Tag
127	//////////////////////////////////////////////////////////////////////
128
129	// Error indicates that operation represented by the span resulted in an error.
130	Error = boolTagName("error")
131)
132
133// ---
134
135// SpanKindEnum represents common span types
136type SpanKindEnum string
137
138type spanKindTagName string
139
140// Set adds a string tag to the `span`
141func (tag spanKindTagName) Set(span opentracing.Span, value SpanKindEnum) {
142	span.SetTag(string(tag), value)
143}
144
145type rpcServerOption struct {
146	clientContext opentracing.SpanContext
147}
148
149func (r rpcServerOption) Apply(o *opentracing.StartSpanOptions) {
150	if r.clientContext != nil {
151		opentracing.ChildOf(r.clientContext).Apply(o)
152	}
153	SpanKindRPCServer.Apply(o)
154}
155
156// RPCServerOption returns a StartSpanOption appropriate for an RPC server span
157// with `client` representing the metadata for the remote peer Span if available.
158// In case client == nil, due to the client not being instrumented, this RPC
159// server span will be a root span.
160func RPCServerOption(client opentracing.SpanContext) opentracing.StartSpanOption {
161	return rpcServerOption{client}
162}
163
164// ---
165
166type stringTagName string
167
168// Set adds a string tag to the `span`
169func (tag stringTagName) Set(span opentracing.Span, value string) {
170	span.SetTag(string(tag), value)
171}
172
173// ---
174
175type uint32TagName string
176
177// Set adds a uint32 tag to the `span`
178func (tag uint32TagName) Set(span opentracing.Span, value uint32) {
179	span.SetTag(string(tag), value)
180}
181
182// ---
183
184type uint16TagName string
185
186// Set adds a uint16 tag to the `span`
187func (tag uint16TagName) Set(span opentracing.Span, value uint16) {
188	span.SetTag(string(tag), value)
189}
190
191// ---
192
193type boolTagName string
194
195// Add adds a bool tag to the `span`
196func (tag boolTagName) Set(span opentracing.Span, value bool) {
197	span.SetTag(string(tag), value)
198}
199
200type ipv4Tag string
201
202// Set adds IP v4 host address of the peer as an uint32 value to the `span`, keep this for backward and zipkin compatibility
203func (tag ipv4Tag) Set(span opentracing.Span, value uint32) {
204	span.SetTag(string(tag), value)
205}
206
207// SetString records IP v4 host address of the peer as a .-separated tuple to the `span`. E.g., "127.0.0.1"
208func (tag ipv4Tag) SetString(span opentracing.Span, value string) {
209	span.SetTag(string(tag), value)
210}
211