Source file src/go.opentelemetry.io/otel/semconv/v1.21.0/attribute_group.go

Documentation: go.opentelemetry.io/otel/semconv/v1.21.0

     1  // Copyright The OpenTelemetry Authors
     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  
    15  // Code generated from semantic convention specification. DO NOT EDIT.
    16  
    17  package semconv // import "go.opentelemetry.io/otel/semconv/v1.21.0"
    18  
    19  import "go.opentelemetry.io/otel/attribute"
    20  
    21  // These attributes may be used to describe the client in a connection-based
    22  // network interaction where there is one side that initiates the connection
    23  // (the client is the side that initiates the connection). This covers all TCP
    24  // network interactions since TCP is connection-based and one side initiates
    25  // the connection (an exception is made for peer-to-peer communication over TCP
    26  // where the "user-facing" surface of the protocol / API does not expose a
    27  // clear notion of client and server). This also covers UDP network
    28  // interactions where one side initiates the interaction, e.g. QUIC (HTTP/3)
    29  // and DNS.
    30  const (
    31  	// ClientAddressKey is the attribute Key conforming to the "client.address"
    32  	// semantic conventions. It represents the client address - unix domain
    33  	// socket name, IPv4 or IPv6 address.
    34  	//
    35  	// Type: string
    36  	// RequirementLevel: Optional
    37  	// Stability: stable
    38  	// Examples: '/tmp/my.sock', '10.1.2.80'
    39  	// Note: When observed from the server side, and when communicating through
    40  	// an intermediary, `client.address` SHOULD represent client address behind
    41  	// any intermediaries (e.g. proxies) if it's available.
    42  	ClientAddressKey = attribute.Key("client.address")
    43  
    44  	// ClientPortKey is the attribute Key conforming to the "client.port"
    45  	// semantic conventions. It represents the client port number
    46  	//
    47  	// Type: int
    48  	// RequirementLevel: Optional
    49  	// Stability: stable
    50  	// Examples: 65123
    51  	// Note: When observed from the server side, and when communicating through
    52  	// an intermediary, `client.port` SHOULD represent client port behind any
    53  	// intermediaries (e.g. proxies) if it's available.
    54  	ClientPortKey = attribute.Key("client.port")
    55  
    56  	// ClientSocketAddressKey is the attribute Key conforming to the
    57  	// "client.socket.address" semantic conventions. It represents the
    58  	// immediate client peer address - unix domain socket name, IPv4 or IPv6
    59  	// address.
    60  	//
    61  	// Type: string
    62  	// RequirementLevel: Recommended (If different than `client.address`.)
    63  	// Stability: stable
    64  	// Examples: '/tmp/my.sock', '127.0.0.1'
    65  	ClientSocketAddressKey = attribute.Key("client.socket.address")
    66  
    67  	// ClientSocketPortKey is the attribute Key conforming to the
    68  	// "client.socket.port" semantic conventions. It represents the immediate
    69  	// client peer port number
    70  	//
    71  	// Type: int
    72  	// RequirementLevel: Recommended (If different than `client.port`.)
    73  	// Stability: stable
    74  	// Examples: 35555
    75  	ClientSocketPortKey = attribute.Key("client.socket.port")
    76  )
    77  
    78  // ClientAddress returns an attribute KeyValue conforming to the
    79  // "client.address" semantic conventions. It represents the client address -
    80  // unix domain socket name, IPv4 or IPv6 address.
    81  func ClientAddress(val string) attribute.KeyValue {
    82  	return ClientAddressKey.String(val)
    83  }
    84  
    85  // ClientPort returns an attribute KeyValue conforming to the "client.port"
    86  // semantic conventions. It represents the client port number
    87  func ClientPort(val int) attribute.KeyValue {
    88  	return ClientPortKey.Int(val)
    89  }
    90  
    91  // ClientSocketAddress returns an attribute KeyValue conforming to the
    92  // "client.socket.address" semantic conventions. It represents the immediate
    93  // client peer address - unix domain socket name, IPv4 or IPv6 address.
    94  func ClientSocketAddress(val string) attribute.KeyValue {
    95  	return ClientSocketAddressKey.String(val)
    96  }
    97  
    98  // ClientSocketPort returns an attribute KeyValue conforming to the
    99  // "client.socket.port" semantic conventions. It represents the immediate
   100  // client peer port number
   101  func ClientSocketPort(val int) attribute.KeyValue {
   102  	return ClientSocketPortKey.Int(val)
   103  }
   104  
   105  // Describes deprecated HTTP attributes.
   106  const (
   107  	// HTTPMethodKey is the attribute Key conforming to the "http.method"
   108  	// semantic conventions. It represents the deprecated, use
   109  	// `http.request.method` instead.
   110  	//
   111  	// Type: string
   112  	// RequirementLevel: Optional
   113  	// Stability: deprecated
   114  	// Examples: 'GET', 'POST', 'HEAD'
   115  	HTTPMethodKey = attribute.Key("http.method")
   116  
   117  	// HTTPStatusCodeKey is the attribute Key conforming to the
   118  	// "http.status_code" semantic conventions. It represents the deprecated,
   119  	// use `http.response.status_code` instead.
   120  	//
   121  	// Type: int
   122  	// RequirementLevel: Optional
   123  	// Stability: deprecated
   124  	// Examples: 200
   125  	HTTPStatusCodeKey = attribute.Key("http.status_code")
   126  
   127  	// HTTPSchemeKey is the attribute Key conforming to the "http.scheme"
   128  	// semantic conventions. It represents the deprecated, use `url.scheme`
   129  	// instead.
   130  	//
   131  	// Type: string
   132  	// RequirementLevel: Optional
   133  	// Stability: deprecated
   134  	// Examples: 'http', 'https'
   135  	HTTPSchemeKey = attribute.Key("http.scheme")
   136  
   137  	// HTTPURLKey is the attribute Key conforming to the "http.url" semantic
   138  	// conventions. It represents the deprecated, use `url.full` instead.
   139  	//
   140  	// Type: string
   141  	// RequirementLevel: Optional
   142  	// Stability: deprecated
   143  	// Examples: 'https://www.foo.bar/search?q=OpenTelemetry#SemConv'
   144  	HTTPURLKey = attribute.Key("http.url")
   145  
   146  	// HTTPTargetKey is the attribute Key conforming to the "http.target"
   147  	// semantic conventions. It represents the deprecated, use `url.path` and
   148  	// `url.query` instead.
   149  	//
   150  	// Type: string
   151  	// RequirementLevel: Optional
   152  	// Stability: deprecated
   153  	// Examples: '/search?q=OpenTelemetry#SemConv'
   154  	HTTPTargetKey = attribute.Key("http.target")
   155  
   156  	// HTTPRequestContentLengthKey is the attribute Key conforming to the
   157  	// "http.request_content_length" semantic conventions. It represents the
   158  	// deprecated, use `http.request.body.size` instead.
   159  	//
   160  	// Type: int
   161  	// RequirementLevel: Optional
   162  	// Stability: deprecated
   163  	// Examples: 3495
   164  	HTTPRequestContentLengthKey = attribute.Key("http.request_content_length")
   165  
   166  	// HTTPResponseContentLengthKey is the attribute Key conforming to the
   167  	// "http.response_content_length" semantic conventions. It represents the
   168  	// deprecated, use `http.response.body.size` instead.
   169  	//
   170  	// Type: int
   171  	// RequirementLevel: Optional
   172  	// Stability: deprecated
   173  	// Examples: 3495
   174  	HTTPResponseContentLengthKey = attribute.Key("http.response_content_length")
   175  )
   176  
   177  // HTTPMethod returns an attribute KeyValue conforming to the "http.method"
   178  // semantic conventions. It represents the deprecated, use
   179  // `http.request.method` instead.
   180  func HTTPMethod(val string) attribute.KeyValue {
   181  	return HTTPMethodKey.String(val)
   182  }
   183  
   184  // HTTPStatusCode returns an attribute KeyValue conforming to the
   185  // "http.status_code" semantic conventions. It represents the deprecated, use
   186  // `http.response.status_code` instead.
   187  func HTTPStatusCode(val int) attribute.KeyValue {
   188  	return HTTPStatusCodeKey.Int(val)
   189  }
   190  
   191  // HTTPScheme returns an attribute KeyValue conforming to the "http.scheme"
   192  // semantic conventions. It represents the deprecated, use `url.scheme`
   193  // instead.
   194  func HTTPScheme(val string) attribute.KeyValue {
   195  	return HTTPSchemeKey.String(val)
   196  }
   197  
   198  // HTTPURL returns an attribute KeyValue conforming to the "http.url"
   199  // semantic conventions. It represents the deprecated, use `url.full` instead.
   200  func HTTPURL(val string) attribute.KeyValue {
   201  	return HTTPURLKey.String(val)
   202  }
   203  
   204  // HTTPTarget returns an attribute KeyValue conforming to the "http.target"
   205  // semantic conventions. It represents the deprecated, use `url.path` and
   206  // `url.query` instead.
   207  func HTTPTarget(val string) attribute.KeyValue {
   208  	return HTTPTargetKey.String(val)
   209  }
   210  
   211  // HTTPRequestContentLength returns an attribute KeyValue conforming to the
   212  // "http.request_content_length" semantic conventions. It represents the
   213  // deprecated, use `http.request.body.size` instead.
   214  func HTTPRequestContentLength(val int) attribute.KeyValue {
   215  	return HTTPRequestContentLengthKey.Int(val)
   216  }
   217  
   218  // HTTPResponseContentLength returns an attribute KeyValue conforming to the
   219  // "http.response_content_length" semantic conventions. It represents the
   220  // deprecated, use `http.response.body.size` instead.
   221  func HTTPResponseContentLength(val int) attribute.KeyValue {
   222  	return HTTPResponseContentLengthKey.Int(val)
   223  }
   224  
   225  // These attributes may be used for any network related operation.
   226  const (
   227  	// NetSockPeerNameKey is the attribute Key conforming to the
   228  	// "net.sock.peer.name" semantic conventions. It represents the deprecated,
   229  	// use `server.socket.domain` on client spans.
   230  	//
   231  	// Type: string
   232  	// RequirementLevel: Optional
   233  	// Stability: deprecated
   234  	// Examples: '/var/my.sock'
   235  	NetSockPeerNameKey = attribute.Key("net.sock.peer.name")
   236  
   237  	// NetSockPeerAddrKey is the attribute Key conforming to the
   238  	// "net.sock.peer.addr" semantic conventions. It represents the deprecated,
   239  	// use `server.socket.address` on client spans and `client.socket.address`
   240  	// on server spans.
   241  	//
   242  	// Type: string
   243  	// RequirementLevel: Optional
   244  	// Stability: deprecated
   245  	// Examples: '192.168.0.1'
   246  	NetSockPeerAddrKey = attribute.Key("net.sock.peer.addr")
   247  
   248  	// NetSockPeerPortKey is the attribute Key conforming to the
   249  	// "net.sock.peer.port" semantic conventions. It represents the deprecated,
   250  	// use `server.socket.port` on client spans and `client.socket.port` on
   251  	// server spans.
   252  	//
   253  	// Type: int
   254  	// RequirementLevel: Optional
   255  	// Stability: deprecated
   256  	// Examples: 65531
   257  	NetSockPeerPortKey = attribute.Key("net.sock.peer.port")
   258  
   259  	// NetPeerNameKey is the attribute Key conforming to the "net.peer.name"
   260  	// semantic conventions. It represents the deprecated, use `server.address`
   261  	// on client spans and `client.address` on server spans.
   262  	//
   263  	// Type: string
   264  	// RequirementLevel: Optional
   265  	// Stability: deprecated
   266  	// Examples: 'example.com'
   267  	NetPeerNameKey = attribute.Key("net.peer.name")
   268  
   269  	// NetPeerPortKey is the attribute Key conforming to the "net.peer.port"
   270  	// semantic conventions. It represents the deprecated, use `server.port` on
   271  	// client spans and `client.port` on server spans.
   272  	//
   273  	// Type: int
   274  	// RequirementLevel: Optional
   275  	// Stability: deprecated
   276  	// Examples: 8080
   277  	NetPeerPortKey = attribute.Key("net.peer.port")
   278  
   279  	// NetHostNameKey is the attribute Key conforming to the "net.host.name"
   280  	// semantic conventions. It represents the deprecated, use
   281  	// `server.address`.
   282  	//
   283  	// Type: string
   284  	// RequirementLevel: Optional
   285  	// Stability: deprecated
   286  	// Examples: 'example.com'
   287  	NetHostNameKey = attribute.Key("net.host.name")
   288  
   289  	// NetHostPortKey is the attribute Key conforming to the "net.host.port"
   290  	// semantic conventions. It represents the deprecated, use `server.port`.
   291  	//
   292  	// Type: int
   293  	// RequirementLevel: Optional
   294  	// Stability: deprecated
   295  	// Examples: 8080
   296  	NetHostPortKey = attribute.Key("net.host.port")
   297  
   298  	// NetSockHostAddrKey is the attribute Key conforming to the
   299  	// "net.sock.host.addr" semantic conventions. It represents the deprecated,
   300  	// use `server.socket.address`.
   301  	//
   302  	// Type: string
   303  	// RequirementLevel: Optional
   304  	// Stability: deprecated
   305  	// Examples: '/var/my.sock'
   306  	NetSockHostAddrKey = attribute.Key("net.sock.host.addr")
   307  
   308  	// NetSockHostPortKey is the attribute Key conforming to the
   309  	// "net.sock.host.port" semantic conventions. It represents the deprecated,
   310  	// use `server.socket.port`.
   311  	//
   312  	// Type: int
   313  	// RequirementLevel: Optional
   314  	// Stability: deprecated
   315  	// Examples: 8080
   316  	NetSockHostPortKey = attribute.Key("net.sock.host.port")
   317  
   318  	// NetTransportKey is the attribute Key conforming to the "net.transport"
   319  	// semantic conventions. It represents the deprecated, use
   320  	// `network.transport`.
   321  	//
   322  	// Type: Enum
   323  	// RequirementLevel: Optional
   324  	// Stability: deprecated
   325  	NetTransportKey = attribute.Key("net.transport")
   326  
   327  	// NetProtocolNameKey is the attribute Key conforming to the
   328  	// "net.protocol.name" semantic conventions. It represents the deprecated,
   329  	// use `network.protocol.name`.
   330  	//
   331  	// Type: string
   332  	// RequirementLevel: Optional
   333  	// Stability: deprecated
   334  	// Examples: 'amqp', 'http', 'mqtt'
   335  	NetProtocolNameKey = attribute.Key("net.protocol.name")
   336  
   337  	// NetProtocolVersionKey is the attribute Key conforming to the
   338  	// "net.protocol.version" semantic conventions. It represents the
   339  	// deprecated, use `network.protocol.version`.
   340  	//
   341  	// Type: string
   342  	// RequirementLevel: Optional
   343  	// Stability: deprecated
   344  	// Examples: '3.1.1'
   345  	NetProtocolVersionKey = attribute.Key("net.protocol.version")
   346  
   347  	// NetSockFamilyKey is the attribute Key conforming to the
   348  	// "net.sock.family" semantic conventions. It represents the deprecated,
   349  	// use `network.transport` and `network.type`.
   350  	//
   351  	// Type: Enum
   352  	// RequirementLevel: Optional
   353  	// Stability: deprecated
   354  	NetSockFamilyKey = attribute.Key("net.sock.family")
   355  )
   356  
   357  var (
   358  	// ip_tcp
   359  	NetTransportTCP = NetTransportKey.String("ip_tcp")
   360  	// ip_udp
   361  	NetTransportUDP = NetTransportKey.String("ip_udp")
   362  	// Named or anonymous pipe
   363  	NetTransportPipe = NetTransportKey.String("pipe")
   364  	// In-process communication
   365  	NetTransportInProc = NetTransportKey.String("inproc")
   366  	// Something else (non IP-based)
   367  	NetTransportOther = NetTransportKey.String("other")
   368  )
   369  
   370  var (
   371  	// IPv4 address
   372  	NetSockFamilyInet = NetSockFamilyKey.String("inet")
   373  	// IPv6 address
   374  	NetSockFamilyInet6 = NetSockFamilyKey.String("inet6")
   375  	// Unix domain socket path
   376  	NetSockFamilyUnix = NetSockFamilyKey.String("unix")
   377  )
   378  
   379  // NetSockPeerName returns an attribute KeyValue conforming to the
   380  // "net.sock.peer.name" semantic conventions. It represents the deprecated, use
   381  // `server.socket.domain` on client spans.
   382  func NetSockPeerName(val string) attribute.KeyValue {
   383  	return NetSockPeerNameKey.String(val)
   384  }
   385  
   386  // NetSockPeerAddr returns an attribute KeyValue conforming to the
   387  // "net.sock.peer.addr" semantic conventions. It represents the deprecated, use
   388  // `server.socket.address` on client spans and `client.socket.address` on
   389  // server spans.
   390  func NetSockPeerAddr(val string) attribute.KeyValue {
   391  	return NetSockPeerAddrKey.String(val)
   392  }
   393  
   394  // NetSockPeerPort returns an attribute KeyValue conforming to the
   395  // "net.sock.peer.port" semantic conventions. It represents the deprecated, use
   396  // `server.socket.port` on client spans and `client.socket.port` on server
   397  // spans.
   398  func NetSockPeerPort(val int) attribute.KeyValue {
   399  	return NetSockPeerPortKey.Int(val)
   400  }
   401  
   402  // NetPeerName returns an attribute KeyValue conforming to the
   403  // "net.peer.name" semantic conventions. It represents the deprecated, use
   404  // `server.address` on client spans and `client.address` on server spans.
   405  func NetPeerName(val string) attribute.KeyValue {
   406  	return NetPeerNameKey.String(val)
   407  }
   408  
   409  // NetPeerPort returns an attribute KeyValue conforming to the
   410  // "net.peer.port" semantic conventions. It represents the deprecated, use
   411  // `server.port` on client spans and `client.port` on server spans.
   412  func NetPeerPort(val int) attribute.KeyValue {
   413  	return NetPeerPortKey.Int(val)
   414  }
   415  
   416  // NetHostName returns an attribute KeyValue conforming to the
   417  // "net.host.name" semantic conventions. It represents the deprecated, use
   418  // `server.address`.
   419  func NetHostName(val string) attribute.KeyValue {
   420  	return NetHostNameKey.String(val)
   421  }
   422  
   423  // NetHostPort returns an attribute KeyValue conforming to the
   424  // "net.host.port" semantic conventions. It represents the deprecated, use
   425  // `server.port`.
   426  func NetHostPort(val int) attribute.KeyValue {
   427  	return NetHostPortKey.Int(val)
   428  }
   429  
   430  // NetSockHostAddr returns an attribute KeyValue conforming to the
   431  // "net.sock.host.addr" semantic conventions. It represents the deprecated, use
   432  // `server.socket.address`.
   433  func NetSockHostAddr(val string) attribute.KeyValue {
   434  	return NetSockHostAddrKey.String(val)
   435  }
   436  
   437  // NetSockHostPort returns an attribute KeyValue conforming to the
   438  // "net.sock.host.port" semantic conventions. It represents the deprecated, use
   439  // `server.socket.port`.
   440  func NetSockHostPort(val int) attribute.KeyValue {
   441  	return NetSockHostPortKey.Int(val)
   442  }
   443  
   444  // NetProtocolName returns an attribute KeyValue conforming to the
   445  // "net.protocol.name" semantic conventions. It represents the deprecated, use
   446  // `network.protocol.name`.
   447  func NetProtocolName(val string) attribute.KeyValue {
   448  	return NetProtocolNameKey.String(val)
   449  }
   450  
   451  // NetProtocolVersion returns an attribute KeyValue conforming to the
   452  // "net.protocol.version" semantic conventions. It represents the deprecated,
   453  // use `network.protocol.version`.
   454  func NetProtocolVersion(val string) attribute.KeyValue {
   455  	return NetProtocolVersionKey.String(val)
   456  }
   457  
   458  // These attributes may be used to describe the receiver of a network
   459  // exchange/packet. These should be used when there is no client/server
   460  // relationship between the two sides, or when that relationship is unknown.
   461  // This covers low-level network interactions (e.g. packet tracing) where you
   462  // don't know if there was a connection or which side initiated it. This also
   463  // covers unidirectional UDP flows and peer-to-peer communication where the
   464  // "user-facing" surface of the protocol / API does not expose a clear notion
   465  // of client and server.
   466  const (
   467  	// DestinationDomainKey is the attribute Key conforming to the
   468  	// "destination.domain" semantic conventions. It represents the domain name
   469  	// of the destination system.
   470  	//
   471  	// Type: string
   472  	// RequirementLevel: Optional
   473  	// Stability: stable
   474  	// Examples: 'foo.example.com'
   475  	// Note: This value may be a host name, a fully qualified domain name, or
   476  	// another host naming format.
   477  	DestinationDomainKey = attribute.Key("destination.domain")
   478  
   479  	// DestinationAddressKey is the attribute Key conforming to the
   480  	// "destination.address" semantic conventions. It represents the peer
   481  	// address, for example IP address or UNIX socket name.
   482  	//
   483  	// Type: string
   484  	// RequirementLevel: Optional
   485  	// Stability: stable
   486  	// Examples: '10.5.3.2'
   487  	DestinationAddressKey = attribute.Key("destination.address")
   488  
   489  	// DestinationPortKey is the attribute Key conforming to the
   490  	// "destination.port" semantic conventions. It represents the peer port
   491  	// number
   492  	//
   493  	// Type: int
   494  	// RequirementLevel: Optional
   495  	// Stability: stable
   496  	// Examples: 3389, 2888
   497  	DestinationPortKey = attribute.Key("destination.port")
   498  )
   499  
   500  // DestinationDomain returns an attribute KeyValue conforming to the
   501  // "destination.domain" semantic conventions. It represents the domain name of
   502  // the destination system.
   503  func DestinationDomain(val string) attribute.KeyValue {
   504  	return DestinationDomainKey.String(val)
   505  }
   506  
   507  // DestinationAddress returns an attribute KeyValue conforming to the
   508  // "destination.address" semantic conventions. It represents the peer address,
   509  // for example IP address or UNIX socket name.
   510  func DestinationAddress(val string) attribute.KeyValue {
   511  	return DestinationAddressKey.String(val)
   512  }
   513  
   514  // DestinationPort returns an attribute KeyValue conforming to the
   515  // "destination.port" semantic conventions. It represents the peer port number
   516  func DestinationPort(val int) attribute.KeyValue {
   517  	return DestinationPortKey.Int(val)
   518  }
   519  
   520  // Describes HTTP attributes.
   521  const (
   522  	// HTTPRequestMethodKey is the attribute Key conforming to the
   523  	// "http.request.method" semantic conventions. It represents the hTTP
   524  	// request method.
   525  	//
   526  	// Type: Enum
   527  	// RequirementLevel: Required
   528  	// Stability: stable
   529  	// Examples: 'GET', 'POST', 'HEAD'
   530  	// Note: HTTP request method value SHOULD be "known" to the
   531  	// instrumentation.
   532  	// By default, this convention defines "known" methods as the ones listed
   533  	// in [RFC9110](https://www.rfc-editor.org/rfc/rfc9110.html#name-methods)
   534  	// and the PATCH method defined in
   535  	// [RFC5789](https://www.rfc-editor.org/rfc/rfc5789.html).
   536  	//
   537  	// If the HTTP request method is not known to instrumentation, it MUST set
   538  	// the `http.request.method` attribute to `_OTHER` and, except if reporting
   539  	// a metric, MUST
   540  	// set the exact method received in the request line as value of the
   541  	// `http.request.method_original` attribute.
   542  	//
   543  	// If the HTTP instrumentation could end up converting valid HTTP request
   544  	// methods to `_OTHER`, then it MUST provide a way to override
   545  	// the list of known HTTP methods. If this override is done via environment
   546  	// variable, then the environment variable MUST be named
   547  	// OTEL_INSTRUMENTATION_HTTP_KNOWN_METHODS and support a comma-separated
   548  	// list of case-sensitive known HTTP methods
   549  	// (this list MUST be a full override of the default known method, it is
   550  	// not a list of known methods in addition to the defaults).
   551  	//
   552  	// HTTP method names are case-sensitive and `http.request.method` attribute
   553  	// value MUST match a known HTTP method name exactly.
   554  	// Instrumentations for specific web frameworks that consider HTTP methods
   555  	// to be case insensitive, SHOULD populate a canonical equivalent.
   556  	// Tracing instrumentations that do so, MUST also set
   557  	// `http.request.method_original` to the original value.
   558  	HTTPRequestMethodKey = attribute.Key("http.request.method")
   559  
   560  	// HTTPResponseStatusCodeKey is the attribute Key conforming to the
   561  	// "http.response.status_code" semantic conventions. It represents the
   562  	// [HTTP response status
   563  	// code](https://tools.ietf.org/html/rfc7231#section-6).
   564  	//
   565  	// Type: int
   566  	// RequirementLevel: ConditionallyRequired (If and only if one was
   567  	// received/sent.)
   568  	// Stability: stable
   569  	// Examples: 200
   570  	HTTPResponseStatusCodeKey = attribute.Key("http.response.status_code")
   571  )
   572  
   573  var (
   574  	// CONNECT method
   575  	HTTPRequestMethodConnect = HTTPRequestMethodKey.String("CONNECT")
   576  	// DELETE method
   577  	HTTPRequestMethodDelete = HTTPRequestMethodKey.String("DELETE")
   578  	// GET method
   579  	HTTPRequestMethodGet = HTTPRequestMethodKey.String("GET")
   580  	// HEAD method
   581  	HTTPRequestMethodHead = HTTPRequestMethodKey.String("HEAD")
   582  	// OPTIONS method
   583  	HTTPRequestMethodOptions = HTTPRequestMethodKey.String("OPTIONS")
   584  	// PATCH method
   585  	HTTPRequestMethodPatch = HTTPRequestMethodKey.String("PATCH")
   586  	// POST method
   587  	HTTPRequestMethodPost = HTTPRequestMethodKey.String("POST")
   588  	// PUT method
   589  	HTTPRequestMethodPut = HTTPRequestMethodKey.String("PUT")
   590  	// TRACE method
   591  	HTTPRequestMethodTrace = HTTPRequestMethodKey.String("TRACE")
   592  	// Any HTTP method that the instrumentation has no prior knowledge of
   593  	HTTPRequestMethodOther = HTTPRequestMethodKey.String("_OTHER")
   594  )
   595  
   596  // HTTPResponseStatusCode returns an attribute KeyValue conforming to the
   597  // "http.response.status_code" semantic conventions. It represents the [HTTP
   598  // response status code](https://tools.ietf.org/html/rfc7231#section-6).
   599  func HTTPResponseStatusCode(val int) attribute.KeyValue {
   600  	return HTTPResponseStatusCodeKey.Int(val)
   601  }
   602  
   603  // HTTP Server attributes
   604  const (
   605  	// HTTPRouteKey is the attribute Key conforming to the "http.route"
   606  	// semantic conventions. It represents the matched route (path template in
   607  	// the format used by the respective server framework). See note below
   608  	//
   609  	// Type: string
   610  	// RequirementLevel: ConditionallyRequired (If and only if it's available)
   611  	// Stability: stable
   612  	// Examples: '/users/:userID?', '{controller}/{action}/{id?}'
   613  	// Note: MUST NOT be populated when this is not supported by the HTTP
   614  	// server framework as the route attribute should have low-cardinality and
   615  	// the URI path can NOT substitute it.
   616  	// SHOULD include the [application
   617  	// root](/docs/http/http-spans.md#http-server-definitions) if there is one.
   618  	HTTPRouteKey = attribute.Key("http.route")
   619  )
   620  
   621  // HTTPRoute returns an attribute KeyValue conforming to the "http.route"
   622  // semantic conventions. It represents the matched route (path template in the
   623  // format used by the respective server framework). See note below
   624  func HTTPRoute(val string) attribute.KeyValue {
   625  	return HTTPRouteKey.String(val)
   626  }
   627  
   628  // Attributes for Events represented using Log Records.
   629  const (
   630  	// EventNameKey is the attribute Key conforming to the "event.name"
   631  	// semantic conventions. It represents the name identifies the event.
   632  	//
   633  	// Type: string
   634  	// RequirementLevel: Required
   635  	// Stability: stable
   636  	// Examples: 'click', 'exception'
   637  	EventNameKey = attribute.Key("event.name")
   638  
   639  	// EventDomainKey is the attribute Key conforming to the "event.domain"
   640  	// semantic conventions. It represents the domain identifies the business
   641  	// context for the events.
   642  	//
   643  	// Type: Enum
   644  	// RequirementLevel: Required
   645  	// Stability: stable
   646  	// Note: Events across different domains may have same `event.name`, yet be
   647  	// unrelated events.
   648  	EventDomainKey = attribute.Key("event.domain")
   649  )
   650  
   651  var (
   652  	// Events from browser apps
   653  	EventDomainBrowser = EventDomainKey.String("browser")
   654  	// Events from mobile apps
   655  	EventDomainDevice = EventDomainKey.String("device")
   656  	// Events from Kubernetes
   657  	EventDomainK8S = EventDomainKey.String("k8s")
   658  )
   659  
   660  // EventName returns an attribute KeyValue conforming to the "event.name"
   661  // semantic conventions. It represents the name identifies the event.
   662  func EventName(val string) attribute.KeyValue {
   663  	return EventNameKey.String(val)
   664  }
   665  
   666  // The attributes described in this section are rather generic. They may be
   667  // used in any Log Record they apply to.
   668  const (
   669  	// LogRecordUIDKey is the attribute Key conforming to the "log.record.uid"
   670  	// semantic conventions. It represents a unique identifier for the Log
   671  	// Record.
   672  	//
   673  	// Type: string
   674  	// RequirementLevel: Optional
   675  	// Stability: stable
   676  	// Examples: '01ARZ3NDEKTSV4RRFFQ69G5FAV'
   677  	// Note: If an id is provided, other log records with the same id will be
   678  	// considered duplicates and can be removed safely. This means, that two
   679  	// distinguishable log records MUST have different values.
   680  	// The id MAY be an [Universally Unique Lexicographically Sortable
   681  	// Identifier (ULID)](https://github.com/ulid/spec), but other identifiers
   682  	// (e.g. UUID) may be used as needed.
   683  	LogRecordUIDKey = attribute.Key("log.record.uid")
   684  )
   685  
   686  // LogRecordUID returns an attribute KeyValue conforming to the
   687  // "log.record.uid" semantic conventions. It represents a unique identifier for
   688  // the Log Record.
   689  func LogRecordUID(val string) attribute.KeyValue {
   690  	return LogRecordUIDKey.String(val)
   691  }
   692  
   693  // Describes Log attributes
   694  const (
   695  	// LogIostreamKey is the attribute Key conforming to the "log.iostream"
   696  	// semantic conventions. It represents the stream associated with the log.
   697  	// See below for a list of well-known values.
   698  	//
   699  	// Type: Enum
   700  	// RequirementLevel: Optional
   701  	// Stability: stable
   702  	LogIostreamKey = attribute.Key("log.iostream")
   703  )
   704  
   705  var (
   706  	// Logs from stdout stream
   707  	LogIostreamStdout = LogIostreamKey.String("stdout")
   708  	// Events from stderr stream
   709  	LogIostreamStderr = LogIostreamKey.String("stderr")
   710  )
   711  
   712  // A file to which log was emitted.
   713  const (
   714  	// LogFileNameKey is the attribute Key conforming to the "log.file.name"
   715  	// semantic conventions. It represents the basename of the file.
   716  	//
   717  	// Type: string
   718  	// RequirementLevel: Recommended
   719  	// Stability: stable
   720  	// Examples: 'audit.log'
   721  	LogFileNameKey = attribute.Key("log.file.name")
   722  
   723  	// LogFilePathKey is the attribute Key conforming to the "log.file.path"
   724  	// semantic conventions. It represents the full path to the file.
   725  	//
   726  	// Type: string
   727  	// RequirementLevel: Optional
   728  	// Stability: stable
   729  	// Examples: '/var/log/mysql/audit.log'
   730  	LogFilePathKey = attribute.Key("log.file.path")
   731  
   732  	// LogFileNameResolvedKey is the attribute Key conforming to the
   733  	// "log.file.name_resolved" semantic conventions. It represents the
   734  	// basename of the file, with symlinks resolved.
   735  	//
   736  	// Type: string
   737  	// RequirementLevel: Optional
   738  	// Stability: stable
   739  	// Examples: 'uuid.log'
   740  	LogFileNameResolvedKey = attribute.Key("log.file.name_resolved")
   741  
   742  	// LogFilePathResolvedKey is the attribute Key conforming to the
   743  	// "log.file.path_resolved" semantic conventions. It represents the full
   744  	// path to the file, with symlinks resolved.
   745  	//
   746  	// Type: string
   747  	// RequirementLevel: Optional
   748  	// Stability: stable
   749  	// Examples: '/var/lib/docker/uuid.log'
   750  	LogFilePathResolvedKey = attribute.Key("log.file.path_resolved")
   751  )
   752  
   753  // LogFileName returns an attribute KeyValue conforming to the
   754  // "log.file.name" semantic conventions. It represents the basename of the
   755  // file.
   756  func LogFileName(val string) attribute.KeyValue {
   757  	return LogFileNameKey.String(val)
   758  }
   759  
   760  // LogFilePath returns an attribute KeyValue conforming to the
   761  // "log.file.path" semantic conventions. It represents the full path to the
   762  // file.
   763  func LogFilePath(val string) attribute.KeyValue {
   764  	return LogFilePathKey.String(val)
   765  }
   766  
   767  // LogFileNameResolved returns an attribute KeyValue conforming to the
   768  // "log.file.name_resolved" semantic conventions. It represents the basename of
   769  // the file, with symlinks resolved.
   770  func LogFileNameResolved(val string) attribute.KeyValue {
   771  	return LogFileNameResolvedKey.String(val)
   772  }
   773  
   774  // LogFilePathResolved returns an attribute KeyValue conforming to the
   775  // "log.file.path_resolved" semantic conventions. It represents the full path
   776  // to the file, with symlinks resolved.
   777  func LogFilePathResolved(val string) attribute.KeyValue {
   778  	return LogFilePathResolvedKey.String(val)
   779  }
   780  
   781  // Describes JVM memory metric attributes.
   782  const (
   783  	// TypeKey is the attribute Key conforming to the "type" semantic
   784  	// conventions. It represents the type of memory.
   785  	//
   786  	// Type: Enum
   787  	// RequirementLevel: Recommended
   788  	// Stability: stable
   789  	// Examples: 'heap', 'non_heap'
   790  	TypeKey = attribute.Key("type")
   791  
   792  	// PoolKey is the attribute Key conforming to the "pool" semantic
   793  	// conventions. It represents the name of the memory pool.
   794  	//
   795  	// Type: string
   796  	// RequirementLevel: Recommended
   797  	// Stability: stable
   798  	// Examples: 'G1 Old Gen', 'G1 Eden space', 'G1 Survivor Space'
   799  	// Note: Pool names are generally obtained via
   800  	// [MemoryPoolMXBean#getName()](https://docs.oracle.com/en/java/javase/11/docs/api/java.management/java/lang/management/MemoryPoolMXBean.html#getName()).
   801  	PoolKey = attribute.Key("pool")
   802  )
   803  
   804  var (
   805  	// Heap memory
   806  	TypeHeap = TypeKey.String("heap")
   807  	// Non-heap memory
   808  	TypeNonHeap = TypeKey.String("non_heap")
   809  )
   810  
   811  // Pool returns an attribute KeyValue conforming to the "pool" semantic
   812  // conventions. It represents the name of the memory pool.
   813  func Pool(val string) attribute.KeyValue {
   814  	return PoolKey.String(val)
   815  }
   816  
   817  // These attributes may be used to describe the server in a connection-based
   818  // network interaction where there is one side that initiates the connection
   819  // (the client is the side that initiates the connection). This covers all TCP
   820  // network interactions since TCP is connection-based and one side initiates
   821  // the connection (an exception is made for peer-to-peer communication over TCP
   822  // where the "user-facing" surface of the protocol / API does not expose a
   823  // clear notion of client and server). This also covers UDP network
   824  // interactions where one side initiates the interaction, e.g. QUIC (HTTP/3)
   825  // and DNS.
   826  const (
   827  	// ServerAddressKey is the attribute Key conforming to the "server.address"
   828  	// semantic conventions. It represents the logical server hostname, matches
   829  	// server FQDN if available, and IP or socket address if FQDN is not known.
   830  	//
   831  	// Type: string
   832  	// RequirementLevel: Optional
   833  	// Stability: stable
   834  	// Examples: 'example.com'
   835  	ServerAddressKey = attribute.Key("server.address")
   836  
   837  	// ServerPortKey is the attribute Key conforming to the "server.port"
   838  	// semantic conventions. It represents the logical server port number
   839  	//
   840  	// Type: int
   841  	// RequirementLevel: Optional
   842  	// Stability: stable
   843  	// Examples: 80, 8080, 443
   844  	ServerPortKey = attribute.Key("server.port")
   845  
   846  	// ServerSocketDomainKey is the attribute Key conforming to the
   847  	// "server.socket.domain" semantic conventions. It represents the domain
   848  	// name of an immediate peer.
   849  	//
   850  	// Type: string
   851  	// RequirementLevel: Recommended (If different than `server.address`.)
   852  	// Stability: stable
   853  	// Examples: 'proxy.example.com'
   854  	// Note: Typically observed from the client side, and represents a proxy or
   855  	// other intermediary domain name.
   856  	ServerSocketDomainKey = attribute.Key("server.socket.domain")
   857  
   858  	// ServerSocketAddressKey is the attribute Key conforming to the
   859  	// "server.socket.address" semantic conventions. It represents the physical
   860  	// server IP address or Unix socket address. If set from the client, should
   861  	// simply use the socket's peer address, and not attempt to find any actual
   862  	// server IP (i.e., if set from client, this may represent some proxy
   863  	// server instead of the logical server).
   864  	//
   865  	// Type: string
   866  	// RequirementLevel: Recommended (If different than `server.address`.)
   867  	// Stability: stable
   868  	// Examples: '10.5.3.2'
   869  	ServerSocketAddressKey = attribute.Key("server.socket.address")
   870  
   871  	// ServerSocketPortKey is the attribute Key conforming to the
   872  	// "server.socket.port" semantic conventions. It represents the physical
   873  	// server port.
   874  	//
   875  	// Type: int
   876  	// RequirementLevel: Recommended (If different than `server.port`.)
   877  	// Stability: stable
   878  	// Examples: 16456
   879  	ServerSocketPortKey = attribute.Key("server.socket.port")
   880  )
   881  
   882  // ServerAddress returns an attribute KeyValue conforming to the
   883  // "server.address" semantic conventions. It represents the logical server
   884  // hostname, matches server FQDN if available, and IP or socket address if FQDN
   885  // is not known.
   886  func ServerAddress(val string) attribute.KeyValue {
   887  	return ServerAddressKey.String(val)
   888  }
   889  
   890  // ServerPort returns an attribute KeyValue conforming to the "server.port"
   891  // semantic conventions. It represents the logical server port number
   892  func ServerPort(val int) attribute.KeyValue {
   893  	return ServerPortKey.Int(val)
   894  }
   895  
   896  // ServerSocketDomain returns an attribute KeyValue conforming to the
   897  // "server.socket.domain" semantic conventions. It represents the domain name
   898  // of an immediate peer.
   899  func ServerSocketDomain(val string) attribute.KeyValue {
   900  	return ServerSocketDomainKey.String(val)
   901  }
   902  
   903  // ServerSocketAddress returns an attribute KeyValue conforming to the
   904  // "server.socket.address" semantic conventions. It represents the physical
   905  // server IP address or Unix socket address. If set from the client, should
   906  // simply use the socket's peer address, and not attempt to find any actual
   907  // server IP (i.e., if set from client, this may represent some proxy server
   908  // instead of the logical server).
   909  func ServerSocketAddress(val string) attribute.KeyValue {
   910  	return ServerSocketAddressKey.String(val)
   911  }
   912  
   913  // ServerSocketPort returns an attribute KeyValue conforming to the
   914  // "server.socket.port" semantic conventions. It represents the physical server
   915  // port.
   916  func ServerSocketPort(val int) attribute.KeyValue {
   917  	return ServerSocketPortKey.Int(val)
   918  }
   919  
   920  // These attributes may be used to describe the sender of a network
   921  // exchange/packet. These should be used when there is no client/server
   922  // relationship between the two sides, or when that relationship is unknown.
   923  // This covers low-level network interactions (e.g. packet tracing) where you
   924  // don't know if there was a connection or which side initiated it. This also
   925  // covers unidirectional UDP flows and peer-to-peer communication where the
   926  // "user-facing" surface of the protocol / API does not expose a clear notion
   927  // of client and server.
   928  const (
   929  	// SourceDomainKey is the attribute Key conforming to the "source.domain"
   930  	// semantic conventions. It represents the domain name of the source
   931  	// system.
   932  	//
   933  	// Type: string
   934  	// RequirementLevel: Optional
   935  	// Stability: stable
   936  	// Examples: 'foo.example.com'
   937  	// Note: This value may be a host name, a fully qualified domain name, or
   938  	// another host naming format.
   939  	SourceDomainKey = attribute.Key("source.domain")
   940  
   941  	// SourceAddressKey is the attribute Key conforming to the "source.address"
   942  	// semantic conventions. It represents the source address, for example IP
   943  	// address or Unix socket name.
   944  	//
   945  	// Type: string
   946  	// RequirementLevel: Optional
   947  	// Stability: stable
   948  	// Examples: '10.5.3.2'
   949  	SourceAddressKey = attribute.Key("source.address")
   950  
   951  	// SourcePortKey is the attribute Key conforming to the "source.port"
   952  	// semantic conventions. It represents the source port number
   953  	//
   954  	// Type: int
   955  	// RequirementLevel: Optional
   956  	// Stability: stable
   957  	// Examples: 3389, 2888
   958  	SourcePortKey = attribute.Key("source.port")
   959  )
   960  
   961  // SourceDomain returns an attribute KeyValue conforming to the
   962  // "source.domain" semantic conventions. It represents the domain name of the
   963  // source system.
   964  func SourceDomain(val string) attribute.KeyValue {
   965  	return SourceDomainKey.String(val)
   966  }
   967  
   968  // SourceAddress returns an attribute KeyValue conforming to the
   969  // "source.address" semantic conventions. It represents the source address, for
   970  // example IP address or Unix socket name.
   971  func SourceAddress(val string) attribute.KeyValue {
   972  	return SourceAddressKey.String(val)
   973  }
   974  
   975  // SourcePort returns an attribute KeyValue conforming to the "source.port"
   976  // semantic conventions. It represents the source port number
   977  func SourcePort(val int) attribute.KeyValue {
   978  	return SourcePortKey.Int(val)
   979  }
   980  
   981  // These attributes may be used for any network related operation.
   982  const (
   983  	// NetworkTransportKey is the attribute Key conforming to the
   984  	// "network.transport" semantic conventions. It represents the [OSI
   985  	// Transport Layer](https://osi-model.com/transport-layer/) or
   986  	// [Inter-process Communication
   987  	// method](https://en.wikipedia.org/wiki/Inter-process_communication). The
   988  	// value SHOULD be normalized to lowercase.
   989  	//
   990  	// Type: Enum
   991  	// RequirementLevel: Optional
   992  	// Stability: stable
   993  	// Examples: 'tcp', 'udp'
   994  	NetworkTransportKey = attribute.Key("network.transport")
   995  
   996  	// NetworkTypeKey is the attribute Key conforming to the "network.type"
   997  	// semantic conventions. It represents the [OSI Network
   998  	// Layer](https://osi-model.com/network-layer/) or non-OSI equivalent. The
   999  	// value SHOULD be normalized to lowercase.
  1000  	//
  1001  	// Type: Enum
  1002  	// RequirementLevel: Optional
  1003  	// Stability: stable
  1004  	// Examples: 'ipv4', 'ipv6'
  1005  	NetworkTypeKey = attribute.Key("network.type")
  1006  
  1007  	// NetworkProtocolNameKey is the attribute Key conforming to the
  1008  	// "network.protocol.name" semantic conventions. It represents the [OSI
  1009  	// Application Layer](https://osi-model.com/application-layer/) or non-OSI
  1010  	// equivalent. The value SHOULD be normalized to lowercase.
  1011  	//
  1012  	// Type: string
  1013  	// RequirementLevel: Optional
  1014  	// Stability: stable
  1015  	// Examples: 'amqp', 'http', 'mqtt'
  1016  	NetworkProtocolNameKey = attribute.Key("network.protocol.name")
  1017  
  1018  	// NetworkProtocolVersionKey is the attribute Key conforming to the
  1019  	// "network.protocol.version" semantic conventions. It represents the
  1020  	// version of the application layer protocol used. See note below.
  1021  	//
  1022  	// Type: string
  1023  	// RequirementLevel: Optional
  1024  	// Stability: stable
  1025  	// Examples: '3.1.1'
  1026  	// Note: `network.protocol.version` refers to the version of the protocol
  1027  	// used and might be different from the protocol client's version. If the
  1028  	// HTTP client used has a version of `0.27.2`, but sends HTTP version
  1029  	// `1.1`, this attribute should be set to `1.1`.
  1030  	NetworkProtocolVersionKey = attribute.Key("network.protocol.version")
  1031  )
  1032  
  1033  var (
  1034  	// TCP
  1035  	NetworkTransportTCP = NetworkTransportKey.String("tcp")
  1036  	// UDP
  1037  	NetworkTransportUDP = NetworkTransportKey.String("udp")
  1038  	// Named or anonymous pipe. See note below
  1039  	NetworkTransportPipe = NetworkTransportKey.String("pipe")
  1040  	// Unix domain socket
  1041  	NetworkTransportUnix = NetworkTransportKey.String("unix")
  1042  )
  1043  
  1044  var (
  1045  	// IPv4
  1046  	NetworkTypeIpv4 = NetworkTypeKey.String("ipv4")
  1047  	// IPv6
  1048  	NetworkTypeIpv6 = NetworkTypeKey.String("ipv6")
  1049  )
  1050  
  1051  // NetworkProtocolName returns an attribute KeyValue conforming to the
  1052  // "network.protocol.name" semantic conventions. It represents the [OSI
  1053  // Application Layer](https://osi-model.com/application-layer/) or non-OSI
  1054  // equivalent. The value SHOULD be normalized to lowercase.
  1055  func NetworkProtocolName(val string) attribute.KeyValue {
  1056  	return NetworkProtocolNameKey.String(val)
  1057  }
  1058  
  1059  // NetworkProtocolVersion returns an attribute KeyValue conforming to the
  1060  // "network.protocol.version" semantic conventions. It represents the version
  1061  // of the application layer protocol used. See note below.
  1062  func NetworkProtocolVersion(val string) attribute.KeyValue {
  1063  	return NetworkProtocolVersionKey.String(val)
  1064  }
  1065  
  1066  // These attributes may be used for any network related operation.
  1067  const (
  1068  	// NetworkConnectionTypeKey is the attribute Key conforming to the
  1069  	// "network.connection.type" semantic conventions. It represents the
  1070  	// internet connection type.
  1071  	//
  1072  	// Type: Enum
  1073  	// RequirementLevel: Optional
  1074  	// Stability: stable
  1075  	// Examples: 'wifi'
  1076  	NetworkConnectionTypeKey = attribute.Key("network.connection.type")
  1077  
  1078  	// NetworkConnectionSubtypeKey is the attribute Key conforming to the
  1079  	// "network.connection.subtype" semantic conventions. It represents the
  1080  	// this describes more details regarding the connection.type. It may be the
  1081  	// type of cell technology connection, but it could be used for describing
  1082  	// details about a wifi connection.
  1083  	//
  1084  	// Type: Enum
  1085  	// RequirementLevel: Optional
  1086  	// Stability: stable
  1087  	// Examples: 'LTE'
  1088  	NetworkConnectionSubtypeKey = attribute.Key("network.connection.subtype")
  1089  
  1090  	// NetworkCarrierNameKey is the attribute Key conforming to the
  1091  	// "network.carrier.name" semantic conventions. It represents the name of
  1092  	// the mobile carrier.
  1093  	//
  1094  	// Type: string
  1095  	// RequirementLevel: Optional
  1096  	// Stability: stable
  1097  	// Examples: 'sprint'
  1098  	NetworkCarrierNameKey = attribute.Key("network.carrier.name")
  1099  
  1100  	// NetworkCarrierMccKey is the attribute Key conforming to the
  1101  	// "network.carrier.mcc" semantic conventions. It represents the mobile
  1102  	// carrier country code.
  1103  	//
  1104  	// Type: string
  1105  	// RequirementLevel: Optional
  1106  	// Stability: stable
  1107  	// Examples: '310'
  1108  	NetworkCarrierMccKey = attribute.Key("network.carrier.mcc")
  1109  
  1110  	// NetworkCarrierMncKey is the attribute Key conforming to the
  1111  	// "network.carrier.mnc" semantic conventions. It represents the mobile
  1112  	// carrier network code.
  1113  	//
  1114  	// Type: string
  1115  	// RequirementLevel: Optional
  1116  	// Stability: stable
  1117  	// Examples: '001'
  1118  	NetworkCarrierMncKey = attribute.Key("network.carrier.mnc")
  1119  
  1120  	// NetworkCarrierIccKey is the attribute Key conforming to the
  1121  	// "network.carrier.icc" semantic conventions. It represents the ISO 3166-1
  1122  	// alpha-2 2-character country code associated with the mobile carrier
  1123  	// network.
  1124  	//
  1125  	// Type: string
  1126  	// RequirementLevel: Optional
  1127  	// Stability: stable
  1128  	// Examples: 'DE'
  1129  	NetworkCarrierIccKey = attribute.Key("network.carrier.icc")
  1130  )
  1131  
  1132  var (
  1133  	// wifi
  1134  	NetworkConnectionTypeWifi = NetworkConnectionTypeKey.String("wifi")
  1135  	// wired
  1136  	NetworkConnectionTypeWired = NetworkConnectionTypeKey.String("wired")
  1137  	// cell
  1138  	NetworkConnectionTypeCell = NetworkConnectionTypeKey.String("cell")
  1139  	// unavailable
  1140  	NetworkConnectionTypeUnavailable = NetworkConnectionTypeKey.String("unavailable")
  1141  	// unknown
  1142  	NetworkConnectionTypeUnknown = NetworkConnectionTypeKey.String("unknown")
  1143  )
  1144  
  1145  var (
  1146  	// GPRS
  1147  	NetworkConnectionSubtypeGprs = NetworkConnectionSubtypeKey.String("gprs")
  1148  	// EDGE
  1149  	NetworkConnectionSubtypeEdge = NetworkConnectionSubtypeKey.String("edge")
  1150  	// UMTS
  1151  	NetworkConnectionSubtypeUmts = NetworkConnectionSubtypeKey.String("umts")
  1152  	// CDMA
  1153  	NetworkConnectionSubtypeCdma = NetworkConnectionSubtypeKey.String("cdma")
  1154  	// EVDO Rel. 0
  1155  	NetworkConnectionSubtypeEvdo0 = NetworkConnectionSubtypeKey.String("evdo_0")
  1156  	// EVDO Rev. A
  1157  	NetworkConnectionSubtypeEvdoA = NetworkConnectionSubtypeKey.String("evdo_a")
  1158  	// CDMA2000 1XRTT
  1159  	NetworkConnectionSubtypeCdma20001xrtt = NetworkConnectionSubtypeKey.String("cdma2000_1xrtt")
  1160  	// HSDPA
  1161  	NetworkConnectionSubtypeHsdpa = NetworkConnectionSubtypeKey.String("hsdpa")
  1162  	// HSUPA
  1163  	NetworkConnectionSubtypeHsupa = NetworkConnectionSubtypeKey.String("hsupa")
  1164  	// HSPA
  1165  	NetworkConnectionSubtypeHspa = NetworkConnectionSubtypeKey.String("hspa")
  1166  	// IDEN
  1167  	NetworkConnectionSubtypeIden = NetworkConnectionSubtypeKey.String("iden")
  1168  	// EVDO Rev. B
  1169  	NetworkConnectionSubtypeEvdoB = NetworkConnectionSubtypeKey.String("evdo_b")
  1170  	// LTE
  1171  	NetworkConnectionSubtypeLte = NetworkConnectionSubtypeKey.String("lte")
  1172  	// EHRPD
  1173  	NetworkConnectionSubtypeEhrpd = NetworkConnectionSubtypeKey.String("ehrpd")
  1174  	// HSPAP
  1175  	NetworkConnectionSubtypeHspap = NetworkConnectionSubtypeKey.String("hspap")
  1176  	// GSM
  1177  	NetworkConnectionSubtypeGsm = NetworkConnectionSubtypeKey.String("gsm")
  1178  	// TD-SCDMA
  1179  	NetworkConnectionSubtypeTdScdma = NetworkConnectionSubtypeKey.String("td_scdma")
  1180  	// IWLAN
  1181  	NetworkConnectionSubtypeIwlan = NetworkConnectionSubtypeKey.String("iwlan")
  1182  	// 5G NR (New Radio)
  1183  	NetworkConnectionSubtypeNr = NetworkConnectionSubtypeKey.String("nr")
  1184  	// 5G NRNSA (New Radio Non-Standalone)
  1185  	NetworkConnectionSubtypeNrnsa = NetworkConnectionSubtypeKey.String("nrnsa")
  1186  	// LTE CA
  1187  	NetworkConnectionSubtypeLteCa = NetworkConnectionSubtypeKey.String("lte_ca")
  1188  )
  1189  
  1190  // NetworkCarrierName returns an attribute KeyValue conforming to the
  1191  // "network.carrier.name" semantic conventions. It represents the name of the
  1192  // mobile carrier.
  1193  func NetworkCarrierName(val string) attribute.KeyValue {
  1194  	return NetworkCarrierNameKey.String(val)
  1195  }
  1196  
  1197  // NetworkCarrierMcc returns an attribute KeyValue conforming to the
  1198  // "network.carrier.mcc" semantic conventions. It represents the mobile carrier
  1199  // country code.
  1200  func NetworkCarrierMcc(val string) attribute.KeyValue {
  1201  	return NetworkCarrierMccKey.String(val)
  1202  }
  1203  
  1204  // NetworkCarrierMnc returns an attribute KeyValue conforming to the
  1205  // "network.carrier.mnc" semantic conventions. It represents the mobile carrier
  1206  // network code.
  1207  func NetworkCarrierMnc(val string) attribute.KeyValue {
  1208  	return NetworkCarrierMncKey.String(val)
  1209  }
  1210  
  1211  // NetworkCarrierIcc returns an attribute KeyValue conforming to the
  1212  // "network.carrier.icc" semantic conventions. It represents the ISO 3166-1
  1213  // alpha-2 2-character country code associated with the mobile carrier network.
  1214  func NetworkCarrierIcc(val string) attribute.KeyValue {
  1215  	return NetworkCarrierIccKey.String(val)
  1216  }
  1217  
  1218  // Semantic conventions for HTTP client and server Spans.
  1219  const (
  1220  	// HTTPRequestMethodOriginalKey is the attribute Key conforming to the
  1221  	// "http.request.method_original" semantic conventions. It represents the
  1222  	// original HTTP method sent by the client in the request line.
  1223  	//
  1224  	// Type: string
  1225  	// RequirementLevel: ConditionallyRequired (If and only if it's different
  1226  	// than `http.request.method`.)
  1227  	// Stability: stable
  1228  	// Examples: 'GeT', 'ACL', 'foo'
  1229  	HTTPRequestMethodOriginalKey = attribute.Key("http.request.method_original")
  1230  
  1231  	// HTTPRequestBodySizeKey is the attribute Key conforming to the
  1232  	// "http.request.body.size" semantic conventions. It represents the size of
  1233  	// the request payload body in bytes. This is the number of bytes
  1234  	// transferred excluding headers and is often, but not always, present as
  1235  	// the
  1236  	// [Content-Length](https://www.rfc-editor.org/rfc/rfc9110.html#field.content-length)
  1237  	// header. For requests using transport encoding, this should be the
  1238  	// compressed size.
  1239  	//
  1240  	// Type: int
  1241  	// RequirementLevel: Optional
  1242  	// Stability: stable
  1243  	// Examples: 3495
  1244  	HTTPRequestBodySizeKey = attribute.Key("http.request.body.size")
  1245  
  1246  	// HTTPResponseBodySizeKey is the attribute Key conforming to the
  1247  	// "http.response.body.size" semantic conventions. It represents the size
  1248  	// of the response payload body in bytes. This is the number of bytes
  1249  	// transferred excluding headers and is often, but not always, present as
  1250  	// the
  1251  	// [Content-Length](https://www.rfc-editor.org/rfc/rfc9110.html#field.content-length)
  1252  	// header. For requests using transport encoding, this should be the
  1253  	// compressed size.
  1254  	//
  1255  	// Type: int
  1256  	// RequirementLevel: Optional
  1257  	// Stability: stable
  1258  	// Examples: 3495
  1259  	HTTPResponseBodySizeKey = attribute.Key("http.response.body.size")
  1260  )
  1261  
  1262  // HTTPRequestMethodOriginal returns an attribute KeyValue conforming to the
  1263  // "http.request.method_original" semantic conventions. It represents the
  1264  // original HTTP method sent by the client in the request line.
  1265  func HTTPRequestMethodOriginal(val string) attribute.KeyValue {
  1266  	return HTTPRequestMethodOriginalKey.String(val)
  1267  }
  1268  
  1269  // HTTPRequestBodySize returns an attribute KeyValue conforming to the
  1270  // "http.request.body.size" semantic conventions. It represents the size of the
  1271  // request payload body in bytes. This is the number of bytes transferred
  1272  // excluding headers and is often, but not always, present as the
  1273  // [Content-Length](https://www.rfc-editor.org/rfc/rfc9110.html#field.content-length)
  1274  // header. For requests using transport encoding, this should be the compressed
  1275  // size.
  1276  func HTTPRequestBodySize(val int) attribute.KeyValue {
  1277  	return HTTPRequestBodySizeKey.Int(val)
  1278  }
  1279  
  1280  // HTTPResponseBodySize returns an attribute KeyValue conforming to the
  1281  // "http.response.body.size" semantic conventions. It represents the size of
  1282  // the response payload body in bytes. This is the number of bytes transferred
  1283  // excluding headers and is often, but not always, present as the
  1284  // [Content-Length](https://www.rfc-editor.org/rfc/rfc9110.html#field.content-length)
  1285  // header. For requests using transport encoding, this should be the compressed
  1286  // size.
  1287  func HTTPResponseBodySize(val int) attribute.KeyValue {
  1288  	return HTTPResponseBodySizeKey.Int(val)
  1289  }
  1290  
  1291  // Semantic convention describing per-message attributes populated on messaging
  1292  // spans or links.
  1293  const (
  1294  	// MessagingMessageIDKey is the attribute Key conforming to the
  1295  	// "messaging.message.id" semantic conventions. It represents a value used
  1296  	// by the messaging system as an identifier for the message, represented as
  1297  	// a string.
  1298  	//
  1299  	// Type: string
  1300  	// RequirementLevel: Optional
  1301  	// Stability: stable
  1302  	// Examples: '452a7c7c7c7048c2f887f61572b18fc2'
  1303  	MessagingMessageIDKey = attribute.Key("messaging.message.id")
  1304  
  1305  	// MessagingMessageConversationIDKey is the attribute Key conforming to the
  1306  	// "messaging.message.conversation_id" semantic conventions. It represents
  1307  	// the [conversation ID](#conversations) identifying the conversation to
  1308  	// which the message belongs, represented as a string. Sometimes called
  1309  	// "Correlation ID".
  1310  	//
  1311  	// Type: string
  1312  	// RequirementLevel: Optional
  1313  	// Stability: stable
  1314  	// Examples: 'MyConversationID'
  1315  	MessagingMessageConversationIDKey = attribute.Key("messaging.message.conversation_id")
  1316  
  1317  	// MessagingMessagePayloadSizeBytesKey is the attribute Key conforming to
  1318  	// the "messaging.message.payload_size_bytes" semantic conventions. It
  1319  	// represents the (uncompressed) size of the message payload in bytes. Also
  1320  	// use this attribute if it is unknown whether the compressed or
  1321  	// uncompressed payload size is reported.
  1322  	//
  1323  	// Type: int
  1324  	// RequirementLevel: Optional
  1325  	// Stability: stable
  1326  	// Examples: 2738
  1327  	MessagingMessagePayloadSizeBytesKey = attribute.Key("messaging.message.payload_size_bytes")
  1328  
  1329  	// MessagingMessagePayloadCompressedSizeBytesKey is the attribute Key
  1330  	// conforming to the "messaging.message.payload_compressed_size_bytes"
  1331  	// semantic conventions. It represents the compressed size of the message
  1332  	// payload in bytes.
  1333  	//
  1334  	// Type: int
  1335  	// RequirementLevel: Optional
  1336  	// Stability: stable
  1337  	// Examples: 2048
  1338  	MessagingMessagePayloadCompressedSizeBytesKey = attribute.Key("messaging.message.payload_compressed_size_bytes")
  1339  )
  1340  
  1341  // MessagingMessageID returns an attribute KeyValue conforming to the
  1342  // "messaging.message.id" semantic conventions. It represents a value used by
  1343  // the messaging system as an identifier for the message, represented as a
  1344  // string.
  1345  func MessagingMessageID(val string) attribute.KeyValue {
  1346  	return MessagingMessageIDKey.String(val)
  1347  }
  1348  
  1349  // MessagingMessageConversationID returns an attribute KeyValue conforming
  1350  // to the "messaging.message.conversation_id" semantic conventions. It
  1351  // represents the [conversation ID](#conversations) identifying the
  1352  // conversation to which the message belongs, represented as a string.
  1353  // Sometimes called "Correlation ID".
  1354  func MessagingMessageConversationID(val string) attribute.KeyValue {
  1355  	return MessagingMessageConversationIDKey.String(val)
  1356  }
  1357  
  1358  // MessagingMessagePayloadSizeBytes returns an attribute KeyValue conforming
  1359  // to the "messaging.message.payload_size_bytes" semantic conventions. It
  1360  // represents the (uncompressed) size of the message payload in bytes. Also use
  1361  // this attribute if it is unknown whether the compressed or uncompressed
  1362  // payload size is reported.
  1363  func MessagingMessagePayloadSizeBytes(val int) attribute.KeyValue {
  1364  	return MessagingMessagePayloadSizeBytesKey.Int(val)
  1365  }
  1366  
  1367  // MessagingMessagePayloadCompressedSizeBytes returns an attribute KeyValue
  1368  // conforming to the "messaging.message.payload_compressed_size_bytes" semantic
  1369  // conventions. It represents the compressed size of the message payload in
  1370  // bytes.
  1371  func MessagingMessagePayloadCompressedSizeBytes(val int) attribute.KeyValue {
  1372  	return MessagingMessagePayloadCompressedSizeBytesKey.Int(val)
  1373  }
  1374  
  1375  // Semantic convention for attributes that describe messaging destination on
  1376  // broker
  1377  const (
  1378  	// MessagingDestinationNameKey is the attribute Key conforming to the
  1379  	// "messaging.destination.name" semantic conventions. It represents the
  1380  	// message destination name
  1381  	//
  1382  	// Type: string
  1383  	// RequirementLevel: Optional
  1384  	// Stability: stable
  1385  	// Examples: 'MyQueue', 'MyTopic'
  1386  	// Note: Destination name SHOULD uniquely identify a specific queue, topic
  1387  	// or other entity within the broker. If
  1388  	// the broker does not have such notion, the destination name SHOULD
  1389  	// uniquely identify the broker.
  1390  	MessagingDestinationNameKey = attribute.Key("messaging.destination.name")
  1391  
  1392  	// MessagingDestinationTemplateKey is the attribute Key conforming to the
  1393  	// "messaging.destination.template" semantic conventions. It represents the
  1394  	// low cardinality representation of the messaging destination name
  1395  	//
  1396  	// Type: string
  1397  	// RequirementLevel: Optional
  1398  	// Stability: stable
  1399  	// Examples: '/customers/{customerID}'
  1400  	// Note: Destination names could be constructed from templates. An example
  1401  	// would be a destination name involving a user name or product id.
  1402  	// Although the destination name in this case is of high cardinality, the
  1403  	// underlying template is of low cardinality and can be effectively used
  1404  	// for grouping and aggregation.
  1405  	MessagingDestinationTemplateKey = attribute.Key("messaging.destination.template")
  1406  
  1407  	// MessagingDestinationTemporaryKey is the attribute Key conforming to the
  1408  	// "messaging.destination.temporary" semantic conventions. It represents a
  1409  	// boolean that is true if the message destination is temporary and might
  1410  	// not exist anymore after messages are processed.
  1411  	//
  1412  	// Type: boolean
  1413  	// RequirementLevel: Optional
  1414  	// Stability: stable
  1415  	MessagingDestinationTemporaryKey = attribute.Key("messaging.destination.temporary")
  1416  
  1417  	// MessagingDestinationAnonymousKey is the attribute Key conforming to the
  1418  	// "messaging.destination.anonymous" semantic conventions. It represents a
  1419  	// boolean that is true if the message destination is anonymous (could be
  1420  	// unnamed or have auto-generated name).
  1421  	//
  1422  	// Type: boolean
  1423  	// RequirementLevel: Optional
  1424  	// Stability: stable
  1425  	MessagingDestinationAnonymousKey = attribute.Key("messaging.destination.anonymous")
  1426  )
  1427  
  1428  // MessagingDestinationName returns an attribute KeyValue conforming to the
  1429  // "messaging.destination.name" semantic conventions. It represents the message
  1430  // destination name
  1431  func MessagingDestinationName(val string) attribute.KeyValue {
  1432  	return MessagingDestinationNameKey.String(val)
  1433  }
  1434  
  1435  // MessagingDestinationTemplate returns an attribute KeyValue conforming to
  1436  // the "messaging.destination.template" semantic conventions. It represents the
  1437  // low cardinality representation of the messaging destination name
  1438  func MessagingDestinationTemplate(val string) attribute.KeyValue {
  1439  	return MessagingDestinationTemplateKey.String(val)
  1440  }
  1441  
  1442  // MessagingDestinationTemporary returns an attribute KeyValue conforming to
  1443  // the "messaging.destination.temporary" semantic conventions. It represents a
  1444  // boolean that is true if the message destination is temporary and might not
  1445  // exist anymore after messages are processed.
  1446  func MessagingDestinationTemporary(val bool) attribute.KeyValue {
  1447  	return MessagingDestinationTemporaryKey.Bool(val)
  1448  }
  1449  
  1450  // MessagingDestinationAnonymous returns an attribute KeyValue conforming to
  1451  // the "messaging.destination.anonymous" semantic conventions. It represents a
  1452  // boolean that is true if the message destination is anonymous (could be
  1453  // unnamed or have auto-generated name).
  1454  func MessagingDestinationAnonymous(val bool) attribute.KeyValue {
  1455  	return MessagingDestinationAnonymousKey.Bool(val)
  1456  }
  1457  
  1458  // Attributes for RabbitMQ
  1459  const (
  1460  	// MessagingRabbitmqDestinationRoutingKeyKey is the attribute Key
  1461  	// conforming to the "messaging.rabbitmq.destination.routing_key" semantic
  1462  	// conventions. It represents the rabbitMQ message routing key.
  1463  	//
  1464  	// Type: string
  1465  	// RequirementLevel: ConditionallyRequired (If not empty.)
  1466  	// Stability: stable
  1467  	// Examples: 'myKey'
  1468  	MessagingRabbitmqDestinationRoutingKeyKey = attribute.Key("messaging.rabbitmq.destination.routing_key")
  1469  )
  1470  
  1471  // MessagingRabbitmqDestinationRoutingKey returns an attribute KeyValue
  1472  // conforming to the "messaging.rabbitmq.destination.routing_key" semantic
  1473  // conventions. It represents the rabbitMQ message routing key.
  1474  func MessagingRabbitmqDestinationRoutingKey(val string) attribute.KeyValue {
  1475  	return MessagingRabbitmqDestinationRoutingKeyKey.String(val)
  1476  }
  1477  
  1478  // Attributes for Apache Kafka
  1479  const (
  1480  	// MessagingKafkaMessageKeyKey is the attribute Key conforming to the
  1481  	// "messaging.kafka.message.key" semantic conventions. It represents the
  1482  	// message keys in Kafka are used for grouping alike messages to ensure
  1483  	// they're processed on the same partition. They differ from
  1484  	// `messaging.message.id` in that they're not unique. If the key is `null`,
  1485  	// the attribute MUST NOT be set.
  1486  	//
  1487  	// Type: string
  1488  	// RequirementLevel: Optional
  1489  	// Stability: stable
  1490  	// Examples: 'myKey'
  1491  	// Note: If the key type is not string, it's string representation has to
  1492  	// be supplied for the attribute. If the key has no unambiguous, canonical
  1493  	// string form, don't include its value.
  1494  	MessagingKafkaMessageKeyKey = attribute.Key("messaging.kafka.message.key")
  1495  
  1496  	// MessagingKafkaConsumerGroupKey is the attribute Key conforming to the
  1497  	// "messaging.kafka.consumer.group" semantic conventions. It represents the
  1498  	// name of the Kafka Consumer Group that is handling the message. Only
  1499  	// applies to consumers, not producers.
  1500  	//
  1501  	// Type: string
  1502  	// RequirementLevel: Optional
  1503  	// Stability: stable
  1504  	// Examples: 'my-group'
  1505  	MessagingKafkaConsumerGroupKey = attribute.Key("messaging.kafka.consumer.group")
  1506  
  1507  	// MessagingKafkaDestinationPartitionKey is the attribute Key conforming to
  1508  	// the "messaging.kafka.destination.partition" semantic conventions. It
  1509  	// represents the partition the message is sent to.
  1510  	//
  1511  	// Type: int
  1512  	// RequirementLevel: Optional
  1513  	// Stability: stable
  1514  	// Examples: 2
  1515  	MessagingKafkaDestinationPartitionKey = attribute.Key("messaging.kafka.destination.partition")
  1516  
  1517  	// MessagingKafkaMessageOffsetKey is the attribute Key conforming to the
  1518  	// "messaging.kafka.message.offset" semantic conventions. It represents the
  1519  	// offset of a record in the corresponding Kafka partition.
  1520  	//
  1521  	// Type: int
  1522  	// RequirementLevel: Optional
  1523  	// Stability: stable
  1524  	// Examples: 42
  1525  	MessagingKafkaMessageOffsetKey = attribute.Key("messaging.kafka.message.offset")
  1526  
  1527  	// MessagingKafkaMessageTombstoneKey is the attribute Key conforming to the
  1528  	// "messaging.kafka.message.tombstone" semantic conventions. It represents
  1529  	// a boolean that is true if the message is a tombstone.
  1530  	//
  1531  	// Type: boolean
  1532  	// RequirementLevel: ConditionallyRequired (If value is `true`. When
  1533  	// missing, the value is assumed to be `false`.)
  1534  	// Stability: stable
  1535  	MessagingKafkaMessageTombstoneKey = attribute.Key("messaging.kafka.message.tombstone")
  1536  )
  1537  
  1538  // MessagingKafkaMessageKey returns an attribute KeyValue conforming to the
  1539  // "messaging.kafka.message.key" semantic conventions. It represents the
  1540  // message keys in Kafka are used for grouping alike messages to ensure they're
  1541  // processed on the same partition. They differ from `messaging.message.id` in
  1542  // that they're not unique. If the key is `null`, the attribute MUST NOT be
  1543  // set.
  1544  func MessagingKafkaMessageKey(val string) attribute.KeyValue {
  1545  	return MessagingKafkaMessageKeyKey.String(val)
  1546  }
  1547  
  1548  // MessagingKafkaConsumerGroup returns an attribute KeyValue conforming to
  1549  // the "messaging.kafka.consumer.group" semantic conventions. It represents the
  1550  // name of the Kafka Consumer Group that is handling the message. Only applies
  1551  // to consumers, not producers.
  1552  func MessagingKafkaConsumerGroup(val string) attribute.KeyValue {
  1553  	return MessagingKafkaConsumerGroupKey.String(val)
  1554  }
  1555  
  1556  // MessagingKafkaDestinationPartition returns an attribute KeyValue
  1557  // conforming to the "messaging.kafka.destination.partition" semantic
  1558  // conventions. It represents the partition the message is sent to.
  1559  func MessagingKafkaDestinationPartition(val int) attribute.KeyValue {
  1560  	return MessagingKafkaDestinationPartitionKey.Int(val)
  1561  }
  1562  
  1563  // MessagingKafkaMessageOffset returns an attribute KeyValue conforming to
  1564  // the "messaging.kafka.message.offset" semantic conventions. It represents the
  1565  // offset of a record in the corresponding Kafka partition.
  1566  func MessagingKafkaMessageOffset(val int) attribute.KeyValue {
  1567  	return MessagingKafkaMessageOffsetKey.Int(val)
  1568  }
  1569  
  1570  // MessagingKafkaMessageTombstone returns an attribute KeyValue conforming
  1571  // to the "messaging.kafka.message.tombstone" semantic conventions. It
  1572  // represents a boolean that is true if the message is a tombstone.
  1573  func MessagingKafkaMessageTombstone(val bool) attribute.KeyValue {
  1574  	return MessagingKafkaMessageTombstoneKey.Bool(val)
  1575  }
  1576  
  1577  // Attributes for Apache RocketMQ
  1578  const (
  1579  	// MessagingRocketmqNamespaceKey is the attribute Key conforming to the
  1580  	// "messaging.rocketmq.namespace" semantic conventions. It represents the
  1581  	// namespace of RocketMQ resources, resources in different namespaces are
  1582  	// individual.
  1583  	//
  1584  	// Type: string
  1585  	// RequirementLevel: Required
  1586  	// Stability: stable
  1587  	// Examples: 'myNamespace'
  1588  	MessagingRocketmqNamespaceKey = attribute.Key("messaging.rocketmq.namespace")
  1589  
  1590  	// MessagingRocketmqClientGroupKey is the attribute Key conforming to the
  1591  	// "messaging.rocketmq.client_group" semantic conventions. It represents
  1592  	// the name of the RocketMQ producer/consumer group that is handling the
  1593  	// message. The client type is identified by the SpanKind.
  1594  	//
  1595  	// Type: string
  1596  	// RequirementLevel: Required
  1597  	// Stability: stable
  1598  	// Examples: 'myConsumerGroup'
  1599  	MessagingRocketmqClientGroupKey = attribute.Key("messaging.rocketmq.client_group")
  1600  
  1601  	// MessagingRocketmqMessageDeliveryTimestampKey is the attribute Key
  1602  	// conforming to the "messaging.rocketmq.message.delivery_timestamp"
  1603  	// semantic conventions. It represents the timestamp in milliseconds that
  1604  	// the delay message is expected to be delivered to consumer.
  1605  	//
  1606  	// Type: int
  1607  	// RequirementLevel: ConditionallyRequired (If the message type is delay
  1608  	// and delay time level is not specified.)
  1609  	// Stability: stable
  1610  	// Examples: 1665987217045
  1611  	MessagingRocketmqMessageDeliveryTimestampKey = attribute.Key("messaging.rocketmq.message.delivery_timestamp")
  1612  
  1613  	// MessagingRocketmqMessageDelayTimeLevelKey is the attribute Key
  1614  	// conforming to the "messaging.rocketmq.message.delay_time_level" semantic
  1615  	// conventions. It represents the delay time level for delay message, which
  1616  	// determines the message delay time.
  1617  	//
  1618  	// Type: int
  1619  	// RequirementLevel: ConditionallyRequired (If the message type is delay
  1620  	// and delivery timestamp is not specified.)
  1621  	// Stability: stable
  1622  	// Examples: 3
  1623  	MessagingRocketmqMessageDelayTimeLevelKey = attribute.Key("messaging.rocketmq.message.delay_time_level")
  1624  
  1625  	// MessagingRocketmqMessageGroupKey is the attribute Key conforming to the
  1626  	// "messaging.rocketmq.message.group" semantic conventions. It represents
  1627  	// the it is essential for FIFO message. Messages that belong to the same
  1628  	// message group are always processed one by one within the same consumer
  1629  	// group.
  1630  	//
  1631  	// Type: string
  1632  	// RequirementLevel: ConditionallyRequired (If the message type is FIFO.)
  1633  	// Stability: stable
  1634  	// Examples: 'myMessageGroup'
  1635  	MessagingRocketmqMessageGroupKey = attribute.Key("messaging.rocketmq.message.group")
  1636  
  1637  	// MessagingRocketmqMessageTypeKey is the attribute Key conforming to the
  1638  	// "messaging.rocketmq.message.type" semantic conventions. It represents
  1639  	// the type of message.
  1640  	//
  1641  	// Type: Enum
  1642  	// RequirementLevel: Optional
  1643  	// Stability: stable
  1644  	MessagingRocketmqMessageTypeKey = attribute.Key("messaging.rocketmq.message.type")
  1645  
  1646  	// MessagingRocketmqMessageTagKey is the attribute Key conforming to the
  1647  	// "messaging.rocketmq.message.tag" semantic conventions. It represents the
  1648  	// secondary classifier of message besides topic.
  1649  	//
  1650  	// Type: string
  1651  	// RequirementLevel: Optional
  1652  	// Stability: stable
  1653  	// Examples: 'tagA'
  1654  	MessagingRocketmqMessageTagKey = attribute.Key("messaging.rocketmq.message.tag")
  1655  
  1656  	// MessagingRocketmqMessageKeysKey is the attribute Key conforming to the
  1657  	// "messaging.rocketmq.message.keys" semantic conventions. It represents
  1658  	// the key(s) of message, another way to mark message besides message id.
  1659  	//
  1660  	// Type: string[]
  1661  	// RequirementLevel: Optional
  1662  	// Stability: stable
  1663  	// Examples: 'keyA', 'keyB'
  1664  	MessagingRocketmqMessageKeysKey = attribute.Key("messaging.rocketmq.message.keys")
  1665  
  1666  	// MessagingRocketmqConsumptionModelKey is the attribute Key conforming to
  1667  	// the "messaging.rocketmq.consumption_model" semantic conventions. It
  1668  	// represents the model of message consumption. This only applies to
  1669  	// consumer spans.
  1670  	//
  1671  	// Type: Enum
  1672  	// RequirementLevel: Optional
  1673  	// Stability: stable
  1674  	MessagingRocketmqConsumptionModelKey = attribute.Key("messaging.rocketmq.consumption_model")
  1675  )
  1676  
  1677  var (
  1678  	// Normal message
  1679  	MessagingRocketmqMessageTypeNormal = MessagingRocketmqMessageTypeKey.String("normal")
  1680  	// FIFO message
  1681  	MessagingRocketmqMessageTypeFifo = MessagingRocketmqMessageTypeKey.String("fifo")
  1682  	// Delay message
  1683  	MessagingRocketmqMessageTypeDelay = MessagingRocketmqMessageTypeKey.String("delay")
  1684  	// Transaction message
  1685  	MessagingRocketmqMessageTypeTransaction = MessagingRocketmqMessageTypeKey.String("transaction")
  1686  )
  1687  
  1688  var (
  1689  	// Clustering consumption model
  1690  	MessagingRocketmqConsumptionModelClustering = MessagingRocketmqConsumptionModelKey.String("clustering")
  1691  	// Broadcasting consumption model
  1692  	MessagingRocketmqConsumptionModelBroadcasting = MessagingRocketmqConsumptionModelKey.String("broadcasting")
  1693  )
  1694  
  1695  // MessagingRocketmqNamespace returns an attribute KeyValue conforming to
  1696  // the "messaging.rocketmq.namespace" semantic conventions. It represents the
  1697  // namespace of RocketMQ resources, resources in different namespaces are
  1698  // individual.
  1699  func MessagingRocketmqNamespace(val string) attribute.KeyValue {
  1700  	return MessagingRocketmqNamespaceKey.String(val)
  1701  }
  1702  
  1703  // MessagingRocketmqClientGroup returns an attribute KeyValue conforming to
  1704  // the "messaging.rocketmq.client_group" semantic conventions. It represents
  1705  // the name of the RocketMQ producer/consumer group that is handling the
  1706  // message. The client type is identified by the SpanKind.
  1707  func MessagingRocketmqClientGroup(val string) attribute.KeyValue {
  1708  	return MessagingRocketmqClientGroupKey.String(val)
  1709  }
  1710  
  1711  // MessagingRocketmqMessageDeliveryTimestamp returns an attribute KeyValue
  1712  // conforming to the "messaging.rocketmq.message.delivery_timestamp" semantic
  1713  // conventions. It represents the timestamp in milliseconds that the delay
  1714  // message is expected to be delivered to consumer.
  1715  func MessagingRocketmqMessageDeliveryTimestamp(val int) attribute.KeyValue {
  1716  	return MessagingRocketmqMessageDeliveryTimestampKey.Int(val)
  1717  }
  1718  
  1719  // MessagingRocketmqMessageDelayTimeLevel returns an attribute KeyValue
  1720  // conforming to the "messaging.rocketmq.message.delay_time_level" semantic
  1721  // conventions. It represents the delay time level for delay message, which
  1722  // determines the message delay time.
  1723  func MessagingRocketmqMessageDelayTimeLevel(val int) attribute.KeyValue {
  1724  	return MessagingRocketmqMessageDelayTimeLevelKey.Int(val)
  1725  }
  1726  
  1727  // MessagingRocketmqMessageGroup returns an attribute KeyValue conforming to
  1728  // the "messaging.rocketmq.message.group" semantic conventions. It represents
  1729  // the it is essential for FIFO message. Messages that belong to the same
  1730  // message group are always processed one by one within the same consumer
  1731  // group.
  1732  func MessagingRocketmqMessageGroup(val string) attribute.KeyValue {
  1733  	return MessagingRocketmqMessageGroupKey.String(val)
  1734  }
  1735  
  1736  // MessagingRocketmqMessageTag returns an attribute KeyValue conforming to
  1737  // the "messaging.rocketmq.message.tag" semantic conventions. It represents the
  1738  // secondary classifier of message besides topic.
  1739  func MessagingRocketmqMessageTag(val string) attribute.KeyValue {
  1740  	return MessagingRocketmqMessageTagKey.String(val)
  1741  }
  1742  
  1743  // MessagingRocketmqMessageKeys returns an attribute KeyValue conforming to
  1744  // the "messaging.rocketmq.message.keys" semantic conventions. It represents
  1745  // the key(s) of message, another way to mark message besides message id.
  1746  func MessagingRocketmqMessageKeys(val ...string) attribute.KeyValue {
  1747  	return MessagingRocketmqMessageKeysKey.StringSlice(val)
  1748  }
  1749  
  1750  // Attributes describing URL.
  1751  const (
  1752  	// URLSchemeKey is the attribute Key conforming to the "url.scheme"
  1753  	// semantic conventions. It represents the [URI
  1754  	// scheme](https://www.rfc-editor.org/rfc/rfc3986#section-3.1) component
  1755  	// identifying the used protocol.
  1756  	//
  1757  	// Type: string
  1758  	// RequirementLevel: Optional
  1759  	// Stability: stable
  1760  	// Examples: 'https', 'ftp', 'telnet'
  1761  	URLSchemeKey = attribute.Key("url.scheme")
  1762  
  1763  	// URLFullKey is the attribute Key conforming to the "url.full" semantic
  1764  	// conventions. It represents the absolute URL describing a network
  1765  	// resource according to [RFC3986](https://www.rfc-editor.org/rfc/rfc3986)
  1766  	//
  1767  	// Type: string
  1768  	// RequirementLevel: Optional
  1769  	// Stability: stable
  1770  	// Examples: 'https://www.foo.bar/search?q=OpenTelemetry#SemConv',
  1771  	// '//localhost'
  1772  	// Note: For network calls, URL usually has
  1773  	// `scheme://host[:port][path][?query][#fragment]` format, where the
  1774  	// fragment is not transmitted over HTTP, but if it is known, it should be
  1775  	// included nevertheless.
  1776  	// `url.full` MUST NOT contain credentials passed via URL in form of
  1777  	// `https://username:password@www.example.com/`. In such case username and
  1778  	// password should be redacted and attribute's value should be
  1779  	// `https://REDACTED:REDACTED@www.example.com/`.
  1780  	// `url.full` SHOULD capture the absolute URL when it is available (or can
  1781  	// be reconstructed) and SHOULD NOT be validated or modified except for
  1782  	// sanitizing purposes.
  1783  	URLFullKey = attribute.Key("url.full")
  1784  
  1785  	// URLPathKey is the attribute Key conforming to the "url.path" semantic
  1786  	// conventions. It represents the [URI
  1787  	// path](https://www.rfc-editor.org/rfc/rfc3986#section-3.3) component
  1788  	//
  1789  	// Type: string
  1790  	// RequirementLevel: Optional
  1791  	// Stability: stable
  1792  	// Examples: '/search'
  1793  	// Note: When missing, the value is assumed to be `/`
  1794  	URLPathKey = attribute.Key("url.path")
  1795  
  1796  	// URLQueryKey is the attribute Key conforming to the "url.query" semantic
  1797  	// conventions. It represents the [URI
  1798  	// query](https://www.rfc-editor.org/rfc/rfc3986#section-3.4) component
  1799  	//
  1800  	// Type: string
  1801  	// RequirementLevel: Optional
  1802  	// Stability: stable
  1803  	// Examples: 'q=OpenTelemetry'
  1804  	// Note: Sensitive content provided in query string SHOULD be scrubbed when
  1805  	// instrumentations can identify it.
  1806  	URLQueryKey = attribute.Key("url.query")
  1807  
  1808  	// URLFragmentKey is the attribute Key conforming to the "url.fragment"
  1809  	// semantic conventions. It represents the [URI
  1810  	// fragment](https://www.rfc-editor.org/rfc/rfc3986#section-3.5) component
  1811  	//
  1812  	// Type: string
  1813  	// RequirementLevel: Optional
  1814  	// Stability: stable
  1815  	// Examples: 'SemConv'
  1816  	URLFragmentKey = attribute.Key("url.fragment")
  1817  )
  1818  
  1819  // URLScheme returns an attribute KeyValue conforming to the "url.scheme"
  1820  // semantic conventions. It represents the [URI
  1821  // scheme](https://www.rfc-editor.org/rfc/rfc3986#section-3.1) component
  1822  // identifying the used protocol.
  1823  func URLScheme(val string) attribute.KeyValue {
  1824  	return URLSchemeKey.String(val)
  1825  }
  1826  
  1827  // URLFull returns an attribute KeyValue conforming to the "url.full"
  1828  // semantic conventions. It represents the absolute URL describing a network
  1829  // resource according to [RFC3986](https://www.rfc-editor.org/rfc/rfc3986)
  1830  func URLFull(val string) attribute.KeyValue {
  1831  	return URLFullKey.String(val)
  1832  }
  1833  
  1834  // URLPath returns an attribute KeyValue conforming to the "url.path"
  1835  // semantic conventions. It represents the [URI
  1836  // path](https://www.rfc-editor.org/rfc/rfc3986#section-3.3) component
  1837  func URLPath(val string) attribute.KeyValue {
  1838  	return URLPathKey.String(val)
  1839  }
  1840  
  1841  // URLQuery returns an attribute KeyValue conforming to the "url.query"
  1842  // semantic conventions. It represents the [URI
  1843  // query](https://www.rfc-editor.org/rfc/rfc3986#section-3.4) component
  1844  func URLQuery(val string) attribute.KeyValue {
  1845  	return URLQueryKey.String(val)
  1846  }
  1847  
  1848  // URLFragment returns an attribute KeyValue conforming to the
  1849  // "url.fragment" semantic conventions. It represents the [URI
  1850  // fragment](https://www.rfc-editor.org/rfc/rfc3986#section-3.5) component
  1851  func URLFragment(val string) attribute.KeyValue {
  1852  	return URLFragmentKey.String(val)
  1853  }
  1854  
  1855  // Describes user-agent attributes.
  1856  const (
  1857  	// UserAgentOriginalKey is the attribute Key conforming to the
  1858  	// "user_agent.original" semantic conventions. It represents the value of
  1859  	// the [HTTP
  1860  	// User-Agent](https://www.rfc-editor.org/rfc/rfc9110.html#field.user-agent)
  1861  	// header sent by the client.
  1862  	//
  1863  	// Type: string
  1864  	// RequirementLevel: Optional
  1865  	// Stability: stable
  1866  	// Examples: 'CERN-LineMode/2.15 libwww/2.17b3'
  1867  	UserAgentOriginalKey = attribute.Key("user_agent.original")
  1868  )
  1869  
  1870  // UserAgentOriginal returns an attribute KeyValue conforming to the
  1871  // "user_agent.original" semantic conventions. It represents the value of the
  1872  // [HTTP
  1873  // User-Agent](https://www.rfc-editor.org/rfc/rfc9110.html#field.user-agent)
  1874  // header sent by the client.
  1875  func UserAgentOriginal(val string) attribute.KeyValue {
  1876  	return UserAgentOriginalKey.String(val)
  1877  }
  1878  

View as plain text