khenaidoo | c6c7bda | 2020-06-17 17:20:18 -0400 | [diff] [blame] | 1 | package ext |
| 2 | |
| 3 | import "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 | // |
| 16 | var ( |
| 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 |
| 136 | type SpanKindEnum string |
| 137 | |
| 138 | type spanKindTagName string |
| 139 | |
| 140 | // Set adds a string tag to the `span` |
| 141 | func (tag spanKindTagName) Set(span opentracing.Span, value SpanKindEnum) { |
| 142 | span.SetTag(string(tag), value) |
| 143 | } |
| 144 | |
| 145 | type rpcServerOption struct { |
| 146 | clientContext opentracing.SpanContext |
| 147 | } |
| 148 | |
| 149 | func (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. |
| 160 | func RPCServerOption(client opentracing.SpanContext) opentracing.StartSpanOption { |
| 161 | return rpcServerOption{client} |
| 162 | } |
| 163 | |
| 164 | // --- |
| 165 | |
| 166 | type stringTagName string |
| 167 | |
| 168 | // Set adds a string tag to the `span` |
| 169 | func (tag stringTagName) Set(span opentracing.Span, value string) { |
| 170 | span.SetTag(string(tag), value) |
| 171 | } |
| 172 | |
| 173 | // --- |
| 174 | |
| 175 | type uint32TagName string |
| 176 | |
| 177 | // Set adds a uint32 tag to the `span` |
| 178 | func (tag uint32TagName) Set(span opentracing.Span, value uint32) { |
| 179 | span.SetTag(string(tag), value) |
| 180 | } |
| 181 | |
| 182 | // --- |
| 183 | |
| 184 | type uint16TagName string |
| 185 | |
| 186 | // Set adds a uint16 tag to the `span` |
| 187 | func (tag uint16TagName) Set(span opentracing.Span, value uint16) { |
| 188 | span.SetTag(string(tag), value) |
| 189 | } |
| 190 | |
| 191 | // --- |
| 192 | |
| 193 | type boolTagName string |
| 194 | |
| 195 | // Add adds a bool tag to the `span` |
| 196 | func (tag boolTagName) Set(span opentracing.Span, value bool) { |
| 197 | span.SetTag(string(tag), value) |
| 198 | } |
| 199 | |
| 200 | type 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 |
| 203 | func (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" |
| 208 | func (tag ipv4Tag) SetString(span opentracing.Span, value string) { |
| 209 | span.SetTag(string(tag), value) |
| 210 | } |