▽

Package semconv

Constants

Describes HTTP attributes.

const (
    // HTTPMethodKey is the attribute Key conforming to the "http.method"
    // semantic conventions. It represents the hTTP request method.
    //
    // Type: string
    // RequirementLevel: Required
    // Stability: stable
    // Examples: 'GET', 'POST', 'HEAD'
    HTTPMethodKey = attribute.Key("http.method")

    // HTTPStatusCodeKey is the attribute Key conforming to the
    // "http.status_code" semantic conventions. It represents the [HTTP
    // response status code](https://tools.ietf.org/html/rfc7231#section-6).
    //
    // Type: int
    // RequirementLevel: ConditionallyRequired (If and only if one was
    // received/sent.)
    // Stability: stable
    // Examples: 200
    HTTPStatusCodeKey = attribute.Key("http.status_code")

    // HTTPFlavorKey is the attribute Key conforming to the "http.flavor"
    // semantic conventions. It represents the kind of HTTP protocol used.
    //
    // Type: Enum
    // RequirementLevel: Optional
    // Stability: stable
    HTTPFlavorKey = attribute.Key("http.flavor")
)

HTTP Server spans attributes

const (
    // HTTPSchemeKey is the attribute Key conforming to the "http.scheme"
    // semantic conventions. It represents the URI scheme identifying the used
    // protocol.
    //
    // Type: string
    // RequirementLevel: Required
    // Stability: stable
    // Examples: 'http', 'https'
    HTTPSchemeKey = attribute.Key("http.scheme")

    // HTTPRouteKey is the attribute Key conforming to the "http.route"
    // semantic conventions. It represents the matched route (path template in
    // the format used by the respective server framework). See note below
    //
    // Type: string
    // RequirementLevel: ConditionallyRequired (If and only if it's available)
    // Stability: stable
    // Examples: '/users/:userID?', '{controller}/{action}/{id?}'
    // Note: MUST NOT be populated when this is not supported by the HTTP
    // server framework as the route attribute should have low-cardinality and
    // the URI path can NOT substitute it.
    // SHOULD include the [application
    // root](/specification/trace/semantic_conventions/http.md#http-server-definitions)
    // if there is one.
    HTTPRouteKey = attribute.Key("http.route")
)

Attributes for Events represented using Log Records.

const (
    // EventNameKey is the attribute Key conforming to the "event.name"
    // semantic conventions. It represents the name identifies the event.
    //
    // Type: string
    // RequirementLevel: Required
    // Stability: stable
    // Examples: 'click', 'exception'
    EventNameKey = attribute.Key("event.name")

    // EventDomainKey is the attribute Key conforming to the "event.domain"
    // semantic conventions. It represents the domain identifies the business
    // context for the events.
    //
    // Type: Enum
    // RequirementLevel: Required
    // Stability: stable
    // Note: Events across different domains may have same `event.name`, yet be
    // unrelated events.
    EventDomainKey = attribute.Key("event.domain")
)

These attributes may be used for any network related operation.

const (
    // NetTransportKey is the attribute Key conforming to the "net.transport"
    // semantic conventions. It represents the transport protocol used. See
    // note below.
    //
    // Type: Enum
    // RequirementLevel: Optional
    // Stability: stable
    NetTransportKey = attribute.Key("net.transport")

    // NetAppProtocolNameKey is the attribute Key conforming to the
    // "net.app.protocol.name" semantic conventions. It represents the
    // application layer protocol used. The value SHOULD be normalized to
    // lowercase.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'amqp', 'http', 'mqtt'
    NetAppProtocolNameKey = attribute.Key("net.app.protocol.name")

    // NetAppProtocolVersionKey is the attribute Key conforming to the
    // "net.app.protocol.version" semantic conventions. It represents the
    // version of the application layer protocol used. See note below.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '3.1.1'
    // Note: `net.app.protocol.version` refers to the version of the protocol
    // used and might be different from the protocol client's version. If the
    // HTTP client used has a version of `0.27.2`, but sends HTTP version
    // `1.1`, this attribute should be set to `1.1`.
    NetAppProtocolVersionKey = attribute.Key("net.app.protocol.version")

    // NetSockPeerNameKey is the attribute Key conforming to the
    // "net.sock.peer.name" semantic conventions. It represents the remote
    // socket peer name.
    //
    // Type: string
    // RequirementLevel: Recommended (If available and different from
    // `net.peer.name` and if `net.sock.peer.addr` is set.)
    // Stability: stable
    // Examples: 'proxy.example.com'
    NetSockPeerNameKey = attribute.Key("net.sock.peer.name")

    // NetSockPeerAddrKey is the attribute Key conforming to the
    // "net.sock.peer.addr" semantic conventions. It represents the remote
    // socket peer address: IPv4 or IPv6 for internet protocols, path for local
    // communication,
    // [etc](https://man7.org/linux/man-pages/man7/address_families.7.html).
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '127.0.0.1', '/tmp/mysql.sock'
    NetSockPeerAddrKey = attribute.Key("net.sock.peer.addr")

    // NetSockPeerPortKey is the attribute Key conforming to the
    // "net.sock.peer.port" semantic conventions. It represents the remote
    // socket peer port.
    //
    // Type: int
    // RequirementLevel: Recommended (If defined for the address family and if
    // different than `net.peer.port` and if `net.sock.peer.addr` is set.)
    // Stability: stable
    // Examples: 16456
    NetSockPeerPortKey = attribute.Key("net.sock.peer.port")

    // NetSockFamilyKey is the attribute Key conforming to the
    // "net.sock.family" semantic conventions. It represents the protocol
    // [address
    // family](https://man7.org/linux/man-pages/man7/address_families.7.html)
    // which is used for communication.
    //
    // Type: Enum
    // RequirementLevel: ConditionallyRequired (If different than `inet` and if
    // any of `net.sock.peer.addr` or `net.sock.host.addr` are set. Consumers
    // of telemetry SHOULD accept both IPv4 and IPv6 formats for the address in
    // `net.sock.peer.addr` if `net.sock.family` is not set. This is to support
    // instrumentations that follow previous versions of this document.)
    // Stability: stable
    // Examples: 'inet6', 'bluetooth'
    NetSockFamilyKey = attribute.Key("net.sock.family")

    // NetPeerNameKey is the attribute Key conforming to the "net.peer.name"
    // semantic conventions. It represents the logical remote hostname, see
    // note below.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'example.com'
    // Note: `net.peer.name` SHOULD NOT be set if capturing it would require an
    // extra DNS lookup.
    NetPeerNameKey = attribute.Key("net.peer.name")

    // NetPeerPortKey is the attribute Key conforming to the "net.peer.port"
    // semantic conventions. It represents the logical remote port number
    //
    // Type: int
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 80, 8080, 443
    NetPeerPortKey = attribute.Key("net.peer.port")

    // NetHostNameKey is the attribute Key conforming to the "net.host.name"
    // semantic conventions. It represents the logical local hostname or
    // similar, see note below.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'localhost'
    NetHostNameKey = attribute.Key("net.host.name")

    // NetHostPortKey is the attribute Key conforming to the "net.host.port"
    // semantic conventions. It represents the logical local port number,
    // preferably the one that the peer used to connect
    //
    // Type: int
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 8080
    NetHostPortKey = attribute.Key("net.host.port")

    // NetSockHostAddrKey is the attribute Key conforming to the
    // "net.sock.host.addr" semantic conventions. It represents the local
    // socket address. Useful in case of a multi-IP host.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '192.168.0.1'
    NetSockHostAddrKey = attribute.Key("net.sock.host.addr")

    // NetSockHostPortKey is the attribute Key conforming to the
    // "net.sock.host.port" semantic conventions. It represents the local
    // socket port number.
    //
    // Type: int
    // RequirementLevel: ConditionallyRequired (If defined for the address
    // family and if different than `net.host.port` and if `net.sock.host.addr`
    // is set. In other cases, it is still recommended to set this.)
    // Stability: stable
    // Examples: 35555
    NetSockHostPortKey = attribute.Key("net.sock.host.port")

    // NetHostConnectionTypeKey is the attribute Key conforming to the
    // "net.host.connection.type" semantic conventions. It represents the
    // internet connection type currently being used by the host.
    //
    // Type: Enum
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'wifi'
    NetHostConnectionTypeKey = attribute.Key("net.host.connection.type")

    // NetHostConnectionSubtypeKey is the attribute Key conforming to the
    // "net.host.connection.subtype" semantic conventions. It represents the
    // this describes more details regarding the connection.type. It may be the
    // type of cell technology connection, but it could be used for describing
    // details about a wifi connection.
    //
    // Type: Enum
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'LTE'
    NetHostConnectionSubtypeKey = attribute.Key("net.host.connection.subtype")

    // NetHostCarrierNameKey is the attribute Key conforming to the
    // "net.host.carrier.name" semantic conventions. It represents the name of
    // the mobile carrier.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'sprint'
    NetHostCarrierNameKey = attribute.Key("net.host.carrier.name")

    // NetHostCarrierMccKey is the attribute Key conforming to the
    // "net.host.carrier.mcc" semantic conventions. It represents the mobile
    // carrier country code.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '310'
    NetHostCarrierMccKey = attribute.Key("net.host.carrier.mcc")

    // NetHostCarrierMncKey is the attribute Key conforming to the
    // "net.host.carrier.mnc" semantic conventions. It represents the mobile
    // carrier network code.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '001'
    NetHostCarrierMncKey = attribute.Key("net.host.carrier.mnc")

    // NetHostCarrierIccKey is the attribute Key conforming to the
    // "net.host.carrier.icc" semantic conventions. It represents the ISO
    // 3166-1 alpha-2 2-character country code associated with the mobile
    // carrier network.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'DE'
    NetHostCarrierIccKey = attribute.Key("net.host.carrier.icc")
)

Semantic conventions for HTTP client and server Spans.

const (
    // HTTPRequestContentLengthKey is the attribute Key conforming to the
    // "http.request_content_length" semantic conventions. It represents the
    // size of the request payload body in bytes. This is the number of bytes
    // transferred excluding headers and is often, but not always, present as
    // the
    // [Content-Length](https://www.rfc-editor.org/rfc/rfc9110.html#field.content-length)
    // header. For requests using transport encoding, this should be the
    // compressed size.
    //
    // Type: int
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 3495
    HTTPRequestContentLengthKey = attribute.Key("http.request_content_length")

    // HTTPResponseContentLengthKey is the attribute Key conforming to the
    // "http.response_content_length" semantic conventions. It represents the
    // size of the response payload body in bytes. This is the number of bytes
    // transferred excluding headers and is often, but not always, present as
    // the
    // [Content-Length](https://www.rfc-editor.org/rfc/rfc9110.html#field.content-length)
    // header. For requests using transport encoding, this should be the
    // compressed size.
    //
    // Type: int
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 3495
    HTTPResponseContentLengthKey = attribute.Key("http.response_content_length")
)

Semantic convention describing per-message attributes populated on messaging spans or links.

const (
    // MessagingMessageIDKey is the attribute Key conforming to the
    // "messaging.message.id" semantic conventions. It represents a value used
    // by the messaging system as an identifier for the message, represented as
    // a string.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '452a7c7c7c7048c2f887f61572b18fc2'
    MessagingMessageIDKey = attribute.Key("messaging.message.id")

    // MessagingMessageConversationIDKey is the attribute Key conforming to the
    // "messaging.message.conversation_id" semantic conventions. It represents
    // the [conversation ID](#conversations) identifying the conversation to
    // which the message belongs, represented as a string. Sometimes called
    // "Correlation ID".
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'MyConversationID'
    MessagingMessageConversationIDKey = attribute.Key("messaging.message.conversation_id")

    // MessagingMessagePayloadSizeBytesKey is the attribute Key conforming to
    // the "messaging.message.payload_size_bytes" semantic conventions. It
    // represents the (uncompressed) size of the message payload in bytes. Also
    // use this attribute if it is unknown whether the compressed or
    // uncompressed payload size is reported.
    //
    // Type: int
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 2738
    MessagingMessagePayloadSizeBytesKey = attribute.Key("messaging.message.payload_size_bytes")

    // MessagingMessagePayloadCompressedSizeBytesKey is the attribute Key
    // conforming to the "messaging.message.payload_compressed_size_bytes"
    // semantic conventions. It represents the compressed size of the message
    // payload in bytes.
    //
    // Type: int
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 2048
    MessagingMessagePayloadCompressedSizeBytesKey = attribute.Key("messaging.message.payload_compressed_size_bytes")
)

Semantic convention for attributes that describe messaging destination on broker

const (
    // MessagingDestinationNameKey is the attribute Key conforming to the
    // "messaging.destination.name" semantic conventions. It represents the
    // message destination name
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'MyQueue', 'MyTopic'
    // Note: Destination name SHOULD uniquely identify a specific queue, topic
    // or other entity within the broker. If
    // the broker does not have such notion, the destination name SHOULD
    // uniquely identify the broker.
    MessagingDestinationNameKey = attribute.Key("messaging.destination.name")

    // MessagingDestinationKindKey is the attribute Key conforming to the
    // "messaging.destination.kind" semantic conventions. It represents the
    // kind of message destination
    //
    // Type: Enum
    // RequirementLevel: Optional
    // Stability: stable
    MessagingDestinationKindKey = attribute.Key("messaging.destination.kind")

    // MessagingDestinationTemplateKey is the attribute Key conforming to the
    // "messaging.destination.template" semantic conventions. It represents the
    // low cardinality representation of the messaging destination name
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '/customers/{customerID}'
    // Note: Destination names could be constructed from templates. An example
    // would be a destination name involving a user name or product id.
    // Although the destination name in this case is of high cardinality, the
    // underlying template is of low cardinality and can be effectively used
    // for grouping and aggregation.
    MessagingDestinationTemplateKey = attribute.Key("messaging.destination.template")

    // MessagingDestinationTemporaryKey is the attribute Key conforming to the
    // "messaging.destination.temporary" semantic conventions. It represents a
    // boolean that is true if the message destination is temporary and might
    // not exist anymore after messages are processed.
    //
    // Type: boolean
    // RequirementLevel: Optional
    // Stability: stable
    MessagingDestinationTemporaryKey = attribute.Key("messaging.destination.temporary")

    // MessagingDestinationAnonymousKey is the attribute Key conforming to the
    // "messaging.destination.anonymous" semantic conventions. It represents a
    // boolean that is true if the message destination is anonymous (could be
    // unnamed or have auto-generated name).
    //
    // Type: boolean
    // RequirementLevel: Optional
    // Stability: stable
    MessagingDestinationAnonymousKey = attribute.Key("messaging.destination.anonymous")
)

Semantic convention for attributes that describe messaging source on broker

const (
    // MessagingSourceNameKey is the attribute Key conforming to the
    // "messaging.source.name" semantic conventions. It represents the message
    // source name
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'MyQueue', 'MyTopic'
    // Note: Source name SHOULD uniquely identify a specific queue, topic, or
    // other entity within the broker. If
    // the broker does not have such notion, the source name SHOULD uniquely
    // identify the broker.
    MessagingSourceNameKey = attribute.Key("messaging.source.name")

    // MessagingSourceKindKey is the attribute Key conforming to the
    // "messaging.source.kind" semantic conventions. It represents the kind of
    // message source
    //
    // Type: Enum
    // RequirementLevel: Optional
    // Stability: stable
    MessagingSourceKindKey = attribute.Key("messaging.source.kind")

    // MessagingSourceTemplateKey is the attribute Key conforming to the
    // "messaging.source.template" semantic conventions. It represents the low
    // cardinality representation of the messaging source name
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '/customers/{customerID}'
    // Note: Source names could be constructed from templates. An example would
    // be a source name involving a user name or product id. Although the
    // source name in this case is of high cardinality, the underlying template
    // is of low cardinality and can be effectively used for grouping and
    // aggregation.
    MessagingSourceTemplateKey = attribute.Key("messaging.source.template")

    // MessagingSourceTemporaryKey is the attribute Key conforming to the
    // "messaging.source.temporary" semantic conventions. It represents a
    // boolean that is true if the message source is temporary and might not
    // exist anymore after messages are processed.
    //
    // Type: boolean
    // RequirementLevel: Optional
    // Stability: stable
    MessagingSourceTemporaryKey = attribute.Key("messaging.source.temporary")

    // MessagingSourceAnonymousKey is the attribute Key conforming to the
    // "messaging.source.anonymous" semantic conventions. It represents a
    // boolean that is true if the message source is anonymous (could be
    // unnamed or have auto-generated name).
    //
    // Type: boolean
    // RequirementLevel: Optional
    // Stability: stable
    MessagingSourceAnonymousKey = attribute.Key("messaging.source.anonymous")
)

Attributes for Apache Kafka

const (
    // MessagingKafkaMessageKeyKey is the attribute Key conforming to the
    // "messaging.kafka.message.key" semantic conventions. It represents the
    // message keys in Kafka are used for grouping alike messages to ensure
    // they're processed on the same partition. They differ from
    // `messaging.message.id` in that they're not unique. If the key is `null`,
    // the attribute MUST NOT be set.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'myKey'
    // Note: If the key type is not string, it's string representation has to
    // be supplied for the attribute. If the key has no unambiguous, canonical
    // string form, don't include its value.
    MessagingKafkaMessageKeyKey = attribute.Key("messaging.kafka.message.key")

    // MessagingKafkaConsumerGroupKey is the attribute Key conforming to the
    // "messaging.kafka.consumer.group" semantic conventions. It represents the
    // name of the Kafka Consumer Group that is handling the message. Only
    // applies to consumers, not producers.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'my-group'
    MessagingKafkaConsumerGroupKey = attribute.Key("messaging.kafka.consumer.group")

    // MessagingKafkaClientIDKey is the attribute Key conforming to the
    // "messaging.kafka.client_id" semantic conventions. It represents the
    // client ID for the Consumer or Producer that is handling the message.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'client-5'
    MessagingKafkaClientIDKey = attribute.Key("messaging.kafka.client_id")

    // MessagingKafkaDestinationPartitionKey is the attribute Key conforming to
    // the "messaging.kafka.destination.partition" semantic conventions. It
    // represents the partition the message is sent to.
    //
    // Type: int
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 2
    MessagingKafkaDestinationPartitionKey = attribute.Key("messaging.kafka.destination.partition")

    // MessagingKafkaSourcePartitionKey is the attribute Key conforming to the
    // "messaging.kafka.source.partition" semantic conventions. It represents
    // the partition the message is received from.
    //
    // Type: int
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 2
    MessagingKafkaSourcePartitionKey = attribute.Key("messaging.kafka.source.partition")

    // MessagingKafkaMessageOffsetKey is the attribute Key conforming to the
    // "messaging.kafka.message.offset" semantic conventions. It represents the
    // offset of a record in the corresponding Kafka partition.
    //
    // Type: int
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 42
    MessagingKafkaMessageOffsetKey = attribute.Key("messaging.kafka.message.offset")

    // MessagingKafkaMessageTombstoneKey is the attribute Key conforming to the
    // "messaging.kafka.message.tombstone" semantic conventions. It represents
    // a boolean that is true if the message is a tombstone.
    //
    // Type: boolean
    // RequirementLevel: ConditionallyRequired (If value is `true`. When
    // missing, the value is assumed to be `false`.)
    // Stability: stable
    MessagingKafkaMessageTombstoneKey = attribute.Key("messaging.kafka.message.tombstone")
)

Attributes for Apache RocketMQ

const (
    // MessagingRocketmqNamespaceKey is the attribute Key conforming to the
    // "messaging.rocketmq.namespace" semantic conventions. It represents the
    // namespace of RocketMQ resources, resources in different namespaces are
    // individual.
    //
    // Type: string
    // RequirementLevel: Required
    // Stability: stable
    // Examples: 'myNamespace'
    MessagingRocketmqNamespaceKey = attribute.Key("messaging.rocketmq.namespace")

    // MessagingRocketmqClientGroupKey is the attribute Key conforming to the
    // "messaging.rocketmq.client_group" semantic conventions. It represents
    // the name of the RocketMQ producer/consumer group that is handling the
    // message. The client type is identified by the SpanKind.
    //
    // Type: string
    // RequirementLevel: Required
    // Stability: stable
    // Examples: 'myConsumerGroup'
    MessagingRocketmqClientGroupKey = attribute.Key("messaging.rocketmq.client_group")

    // MessagingRocketmqClientIDKey is the attribute Key conforming to the
    // "messaging.rocketmq.client_id" semantic conventions. It represents the
    // unique identifier for each client.
    //
    // Type: string
    // RequirementLevel: Required
    // Stability: stable
    // Examples: 'myhost@8742@s8083jm'
    MessagingRocketmqClientIDKey = attribute.Key("messaging.rocketmq.client_id")

    // MessagingRocketmqMessageDeliveryTimestampKey is the attribute Key
    // conforming to the "messaging.rocketmq.message.delivery_timestamp"
    // semantic conventions. It represents the timestamp in milliseconds that
    // the delay message is expected to be delivered to consumer.
    //
    // Type: int
    // RequirementLevel: ConditionallyRequired (If the message type is delay
    // and delay time level is not specified.)
    // Stability: stable
    // Examples: 1665987217045
    MessagingRocketmqMessageDeliveryTimestampKey = attribute.Key("messaging.rocketmq.message.delivery_timestamp")

    // MessagingRocketmqMessageDelayTimeLevelKey is the attribute Key
    // conforming to the "messaging.rocketmq.message.delay_time_level" semantic
    // conventions. It represents the delay time level for delay message, which
    // determines the message delay time.
    //
    // Type: int
    // RequirementLevel: ConditionallyRequired (If the message type is delay
    // and delivery timestamp is not specified.)
    // Stability: stable
    // Examples: 3
    MessagingRocketmqMessageDelayTimeLevelKey = attribute.Key("messaging.rocketmq.message.delay_time_level")

    // MessagingRocketmqMessageGroupKey is the attribute Key conforming to the
    // "messaging.rocketmq.message.group" semantic conventions. It represents
    // the it is essential for FIFO message. Messages that belong to the same
    // message group are always processed one by one within the same consumer
    // group.
    //
    // Type: string
    // RequirementLevel: ConditionallyRequired (If the message type is FIFO.)
    // Stability: stable
    // Examples: 'myMessageGroup'
    MessagingRocketmqMessageGroupKey = attribute.Key("messaging.rocketmq.message.group")

    // MessagingRocketmqMessageTypeKey is the attribute Key conforming to the
    // "messaging.rocketmq.message.type" semantic conventions. It represents
    // the type of message.
    //
    // Type: Enum
    // RequirementLevel: Optional
    // Stability: stable
    MessagingRocketmqMessageTypeKey = attribute.Key("messaging.rocketmq.message.type")

    // MessagingRocketmqMessageTagKey is the attribute Key conforming to the
    // "messaging.rocketmq.message.tag" semantic conventions. It represents the
    // secondary classifier of message besides topic.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'tagA'
    MessagingRocketmqMessageTagKey = attribute.Key("messaging.rocketmq.message.tag")

    // MessagingRocketmqMessageKeysKey is the attribute Key conforming to the
    // "messaging.rocketmq.message.keys" semantic conventions. It represents
    // the key(s) of message, another way to mark message besides message id.
    //
    // Type: string[]
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'keyA', 'keyB'
    MessagingRocketmqMessageKeysKey = attribute.Key("messaging.rocketmq.message.keys")

    // MessagingRocketmqConsumptionModelKey is the attribute Key conforming to
    // the "messaging.rocketmq.consumption_model" semantic conventions. It
    // represents the model of message consumption. This only applies to
    // consumer spans.
    //
    // Type: Enum
    // RequirementLevel: Optional
    // Stability: stable
    MessagingRocketmqConsumptionModelKey = attribute.Key("messaging.rocketmq.consumption_model")
)

This semantic convention defines the attributes used to represent a feature flag evaluation as an event.

const (
    // FeatureFlagKeyKey is the attribute Key conforming to the
    // "feature_flag.key" semantic conventions. It represents the unique
    // identifier of the feature flag.
    //
    // Type: string
    // RequirementLevel: Required
    // Stability: stable
    // Examples: 'logo-color'
    FeatureFlagKeyKey = attribute.Key("feature_flag.key")

    // FeatureFlagProviderNameKey is the attribute Key conforming to the
    // "feature_flag.provider_name" semantic conventions. It represents the
    // name of the service provider that performs the flag evaluation.
    //
    // Type: string
    // RequirementLevel: Recommended
    // Stability: stable
    // Examples: 'Flag Manager'
    FeatureFlagProviderNameKey = attribute.Key("feature_flag.provider_name")

    // FeatureFlagVariantKey is the attribute Key conforming to the
    // "feature_flag.variant" semantic conventions. It represents the sHOULD be
    // a semantic identifier for a value. If one is unavailable, a stringified
    // version of the value can be used.
    //
    // Type: string
    // RequirementLevel: Recommended
    // Stability: stable
    // Examples: 'red', 'true', 'on'
    // Note: A semantic identifier, commonly referred to as a variant, provides
    // a means
    // for referring to a value without including the value itself. This can
    // provide additional context for understanding the meaning behind a value.
    // For example, the variant `red` maybe be used for the value `#c05543`.
    //
    // A stringified version of the value can be used in situations where a
    // semantic identifier is unavailable. String representation of the value
    // should be determined by the implementer.
    FeatureFlagVariantKey = attribute.Key("feature_flag.variant")
)

RPC received/sent message.

const (
    // MessageTypeKey is the attribute Key conforming to the "message.type"
    // semantic conventions. It represents the whether this is a received or
    // sent message.
    //
    // Type: Enum
    // RequirementLevel: Optional
    // Stability: stable
    MessageTypeKey = attribute.Key("message.type")

    // MessageIDKey is the attribute Key conforming to the "message.id"
    // semantic conventions. It represents the mUST be calculated as two
    // different counters starting from `1` one for sent messages and one for
    // received message.
    //
    // Type: int
    // RequirementLevel: Optional
    // Stability: stable
    // Note: This way we guarantee that the values will be consistent between
    // different implementations.
    MessageIDKey = attribute.Key("message.id")

    // MessageCompressedSizeKey is the attribute Key conforming to the
    // "message.compressed_size" semantic conventions. It represents the
    // compressed size of the message in bytes.
    //
    // Type: int
    // RequirementLevel: Optional
    // Stability: stable
    MessageCompressedSizeKey = attribute.Key("message.compressed_size")

    // MessageUncompressedSizeKey is the attribute Key conforming to the
    // "message.uncompressed_size" semantic conventions. It represents the
    // uncompressed size of the message in bytes.
    //
    // Type: int
    // RequirementLevel: Optional
    // Stability: stable
    MessageUncompressedSizeKey = attribute.Key("message.uncompressed_size")
)

The web browser in which the application represented by the resource is running. The `browser.*` attributes MUST be used only for resources that represent applications running in a web browser (regardless of whether running on a mobile or desktop device).

const (
    // BrowserBrandsKey is the attribute Key conforming to the "browser.brands"
    // semantic conventions. It represents the array of brand name and version
    // separated by a space
    //
    // Type: string[]
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: ' Not A;Brand 99', 'Chromium 99', 'Chrome 99'
    // Note: This value is intended to be taken from the [UA client hints
    // API](https://wicg.github.io/ua-client-hints/#interface)
    // (`navigator.userAgentData.brands`).
    BrowserBrandsKey = attribute.Key("browser.brands")

    // BrowserPlatformKey is the attribute Key conforming to the
    // "browser.platform" semantic conventions. It represents the platform on
    // which the browser is running
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'Windows', 'macOS', 'Android'
    // Note: This value is intended to be taken from the [UA client hints
    // API](https://wicg.github.io/ua-client-hints/#interface)
    // (`navigator.userAgentData.platform`). If unavailable, the legacy
    // `navigator.platform` API SHOULD NOT be used instead and this attribute
    // SHOULD be left unset in order for the values to be consistent.
    // The list of possible values is defined in the [W3C User-Agent Client
    // Hints
    // specification](https://wicg.github.io/ua-client-hints/#sec-ch-ua-platform).
    // Note that some (but not all) of these values can overlap with values in
    // the [`os.type` and `os.name` attributes](./os.md). However, for
    // consistency, the values in the `browser.platform` attribute should
    // capture the exact value that the user agent provides.
    BrowserPlatformKey = attribute.Key("browser.platform")

    // BrowserMobileKey is the attribute Key conforming to the "browser.mobile"
    // semantic conventions. It represents a boolean that is true if the
    // browser is running on a mobile device
    //
    // Type: boolean
    // RequirementLevel: Optional
    // Stability: stable
    // Note: This value is intended to be taken from the [UA client hints
    // API](https://wicg.github.io/ua-client-hints/#interface)
    // (`navigator.userAgentData.mobile`). If unavailable, this attribute
    // SHOULD be left unset.
    BrowserMobileKey = attribute.Key("browser.mobile")

    // BrowserLanguageKey is the attribute Key conforming to the
    // "browser.language" semantic conventions. It represents the preferred
    // language of the user using the browser
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'en', 'en-US', 'fr', 'fr-FR'
    // Note: This value is intended to be taken from the Navigator API
    // `navigator.language`.
    BrowserLanguageKey = attribute.Key("browser.language")
)

A cloud environment (e.g. GCP, Azure, AWS)

const (
    // CloudProviderKey is the attribute Key conforming to the "cloud.provider"
    // semantic conventions. It represents the name of the cloud provider.
    //
    // Type: Enum
    // RequirementLevel: Optional
    // Stability: stable
    CloudProviderKey = attribute.Key("cloud.provider")

    // CloudAccountIDKey is the attribute Key conforming to the
    // "cloud.account.id" semantic conventions. It represents the cloud account
    // ID the resource is assigned to.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '111111111111', 'opentelemetry'
    CloudAccountIDKey = attribute.Key("cloud.account.id")

    // CloudRegionKey is the attribute Key conforming to the "cloud.region"
    // semantic conventions. It represents the geographical region the resource
    // is running.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'us-central1', 'us-east-1'
    // Note: Refer to your provider's docs to see the available regions, for
    // example [Alibaba Cloud
    // regions](https://www.alibabacloud.com/help/doc-detail/40654.htm), [AWS
    // regions](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/),
    // [Azure
    // regions](https://azure.microsoft.com/en-us/global-infrastructure/geographies/),
    // [Google Cloud regions](https://cloud.google.com/about/locations), or
    // [Tencent Cloud
    // regions](https://www.tencentcloud.com/document/product/213/6091).
    CloudRegionKey = attribute.Key("cloud.region")

    // CloudResourceIDKey is the attribute Key conforming to the
    // "cloud.resource_id" semantic conventions. It represents the cloud
    // provider-specific native identifier of the monitored cloud resource
    // (e.g. an
    // [ARN](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
    // on AWS, a [fully qualified resource
    // ID](https://learn.microsoft.com/en-us/rest/api/resources/resources/get-by-id)
    // on Azure, a [full resource
    // name](https://cloud.google.com/apis/design/resource_names#full_resource_name)
    // on GCP)
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'arn:aws:lambda:REGION:ACCOUNT_ID:function:my-function',
    // '//run.googleapis.com/projects/PROJECT_ID/locations/LOCATION_ID/services/SERVICE_ID',
    // '/subscriptions/<SUBSCIPTION_GUID>/resourceGroups/<RG>/providers/Microsoft.Web/sites/<FUNCAPP>/functions/<FUNC>'
    // Note: On some cloud providers, it may not be possible to determine the
    // full ID at startup,
    // so it may be necessary to set `cloud.resource_id` as a span attribute
    // instead.
    //
    // The exact value to use for `cloud.resource_id` depends on the cloud
    // provider.
    // The following well-known definitions MUST be used if you set this
    // attribute and they apply:
    //
    // * **AWS Lambda:** The function
    // [ARN](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html).
    //   Take care not to use the "invoked ARN" directly but replace any
    //   [alias
    // suffix](https://docs.aws.amazon.com/lambda/latest/dg/configuration-aliases.html)
    //   with the resolved function version, as the same runtime instance may
    // be invokable with
    //   multiple different aliases.
    // * **GCP:** The [URI of the
    // resource](https://cloud.google.com/iam/docs/full-resource-names)
    // * **Azure:** The [Fully Qualified Resource
    // ID](https://docs.microsoft.com/en-us/rest/api/resources/resources/get-by-id)
    // of the invoked function,
    //   *not* the function app, having the form
    // `/subscriptions/<SUBSCIPTION_GUID>/resourceGroups/<RG>/providers/Microsoft.Web/sites/<FUNCAPP>/functions/<FUNC>`.
    //   This means that a span attribute MUST be used, as an Azure function
    // app can host multiple functions that would usually share
    //   a TracerProvider.
    CloudResourceIDKey = attribute.Key("cloud.resource_id")

    // CloudAvailabilityZoneKey is the attribute Key conforming to the
    // "cloud.availability_zone" semantic conventions. It represents the cloud
    // regions often have multiple, isolated locations known as zones to
    // increase availability. Availability zone represents the zone where the
    // resource is running.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'us-east-1c'
    // Note: Availability zones are called "zones" on Alibaba Cloud and Google
    // Cloud.
    CloudAvailabilityZoneKey = attribute.Key("cloud.availability_zone")

    // CloudPlatformKey is the attribute Key conforming to the "cloud.platform"
    // semantic conventions. It represents the cloud platform in use.
    //
    // Type: Enum
    // RequirementLevel: Optional
    // Stability: stable
    // Note: The prefix of the service SHOULD match the one specified in
    // `cloud.provider`.
    CloudPlatformKey = attribute.Key("cloud.platform")
)

Resources used by AWS Elastic Container Service (ECS).

const (
    // AWSECSContainerARNKey is the attribute Key conforming to the
    // "aws.ecs.container.arn" semantic conventions. It represents the Amazon
    // Resource Name (ARN) of an [ECS container
    // instance](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_instances.html).
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples:
    // 'arn:aws:ecs:us-west-1:123456789123:container/32624152-9086-4f0e-acae-1a75b14fe4d9'
    AWSECSContainerARNKey = attribute.Key("aws.ecs.container.arn")

    // AWSECSClusterARNKey is the attribute Key conforming to the
    // "aws.ecs.cluster.arn" semantic conventions. It represents the ARN of an
    // [ECS
    // cluster](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/clusters.html).
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'arn:aws:ecs:us-west-2:123456789123:cluster/my-cluster'
    AWSECSClusterARNKey = attribute.Key("aws.ecs.cluster.arn")

    // AWSECSLaunchtypeKey is the attribute Key conforming to the
    // "aws.ecs.launchtype" semantic conventions. It represents the [launch
    // type](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html)
    // for an ECS task.
    //
    // Type: Enum
    // RequirementLevel: Optional
    // Stability: stable
    AWSECSLaunchtypeKey = attribute.Key("aws.ecs.launchtype")

    // AWSECSTaskARNKey is the attribute Key conforming to the
    // "aws.ecs.task.arn" semantic conventions. It represents the ARN of an
    // [ECS task
    // definition](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definitions.html).
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples:
    // 'arn:aws:ecs:us-west-1:123456789123:task/10838bed-421f-43ef-870a-f43feacbbb5b'
    AWSECSTaskARNKey = attribute.Key("aws.ecs.task.arn")

    // AWSECSTaskFamilyKey is the attribute Key conforming to the
    // "aws.ecs.task.family" semantic conventions. It represents the task
    // definition family this task definition is a member of.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'opentelemetry-family'
    AWSECSTaskFamilyKey = attribute.Key("aws.ecs.task.family")

    // AWSECSTaskRevisionKey is the attribute Key conforming to the
    // "aws.ecs.task.revision" semantic conventions. It represents the revision
    // for this task definition.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '8', '26'
    AWSECSTaskRevisionKey = attribute.Key("aws.ecs.task.revision")
)

Resources specific to Amazon Web Services.

const (
    // AWSLogGroupNamesKey is the attribute Key conforming to the
    // "aws.log.group.names" semantic conventions. It represents the name(s) of
    // the AWS log group(s) an application is writing to.
    //
    // Type: string[]
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '/aws/lambda/my-function', 'opentelemetry-service'
    // Note: Multiple log groups must be supported for cases like
    // multi-container applications, where a single application has sidecar
    // containers, and each write to their own log group.
    AWSLogGroupNamesKey = attribute.Key("aws.log.group.names")

    // AWSLogGroupARNsKey is the attribute Key conforming to the
    // "aws.log.group.arns" semantic conventions. It represents the Amazon
    // Resource Name(s) (ARN) of the AWS log group(s).
    //
    // Type: string[]
    // RequirementLevel: Optional
    // Stability: stable
    // Examples:
    // 'arn:aws:logs:us-west-1:123456789012:log-group:/aws/my/group:*'
    // Note: See the [log group ARN format
    // documentation](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/iam-access-control-overview-cwl.html#CWL_ARN_Format).
    AWSLogGroupARNsKey = attribute.Key("aws.log.group.arns")

    // AWSLogStreamNamesKey is the attribute Key conforming to the
    // "aws.log.stream.names" semantic conventions. It represents the name(s)
    // of the AWS log stream(s) an application is writing to.
    //
    // Type: string[]
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'logs/main/10838bed-421f-43ef-870a-f43feacbbb5b'
    AWSLogStreamNamesKey = attribute.Key("aws.log.stream.names")

    // AWSLogStreamARNsKey is the attribute Key conforming to the
    // "aws.log.stream.arns" semantic conventions. It represents the ARN(s) of
    // the AWS log stream(s).
    //
    // Type: string[]
    // RequirementLevel: Optional
    // Stability: stable
    // Examples:
    // 'arn:aws:logs:us-west-1:123456789012:log-group:/aws/my/group:log-stream:logs/main/10838bed-421f-43ef-870a-f43feacbbb5b'
    // Note: See the [log stream ARN format
    // documentation](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/iam-access-control-overview-cwl.html#CWL_ARN_Format).
    // One log group can contain several log streams, so these ARNs necessarily
    // identify both a log group and a log stream.
    AWSLogStreamARNsKey = attribute.Key("aws.log.stream.arns")
)

Heroku dyno metadata

const (
    // HerokuReleaseCreationTimestampKey is the attribute Key conforming to the
    // "heroku.release.creation_timestamp" semantic conventions. It represents
    // the time and date the release was created
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '2022-10-23T18:00:42Z'
    HerokuReleaseCreationTimestampKey = attribute.Key("heroku.release.creation_timestamp")

    // HerokuReleaseCommitKey is the attribute Key conforming to the
    // "heroku.release.commit" semantic conventions. It represents the commit
    // hash for the current release
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'e6134959463efd8966b20e75b913cafe3f5ec'
    HerokuReleaseCommitKey = attribute.Key("heroku.release.commit")

    // HerokuAppIDKey is the attribute Key conforming to the "heroku.app.id"
    // semantic conventions. It represents the unique identifier for the
    // application
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '2daa2797-e42b-4624-9322-ec3f968df4da'
    HerokuAppIDKey = attribute.Key("heroku.app.id")
)

A container instance.

const (
    // ContainerNameKey is the attribute Key conforming to the "container.name"
    // semantic conventions. It represents the container name used by container
    // runtime.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'opentelemetry-autoconf'
    ContainerNameKey = attribute.Key("container.name")

    // ContainerIDKey is the attribute Key conforming to the "container.id"
    // semantic conventions. It represents the container ID. Usually a UUID, as
    // for example used to [identify Docker
    // containers](https://docs.docker.com/engine/reference/run/#container-identification).
    // The UUID might be abbreviated.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'a3bf90e006b2'
    ContainerIDKey = attribute.Key("container.id")

    // ContainerRuntimeKey is the attribute Key conforming to the
    // "container.runtime" semantic conventions. It represents the container
    // runtime managing this container.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'docker', 'containerd', 'rkt'
    ContainerRuntimeKey = attribute.Key("container.runtime")

    // ContainerImageNameKey is the attribute Key conforming to the
    // "container.image.name" semantic conventions. It represents the name of
    // the image the container was built on.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'gcr.io/opentelemetry/operator'
    ContainerImageNameKey = attribute.Key("container.image.name")

    // ContainerImageTagKey is the attribute Key conforming to the
    // "container.image.tag" semantic conventions. It represents the container
    // image tag.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '0.1'
    ContainerImageTagKey = attribute.Key("container.image.tag")
)

The device on which the process represented by this resource is running.

const (
    // DeviceIDKey is the attribute Key conforming to the "device.id" semantic
    // conventions. It represents a unique identifier representing the device
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '2ab2916d-a51f-4ac8-80ee-45ac31a28092'
    // Note: The device identifier MUST only be defined using the values
    // outlined below. This value is not an advertising identifier and MUST NOT
    // be used as such. On iOS (Swift or Objective-C), this value MUST be equal
    // to the [vendor
    // identifier](https://developer.apple.com/documentation/uikit/uidevice/1620059-identifierforvendor).
    // On Android (Java or Kotlin), this value MUST be equal to the Firebase
    // Installation ID or a globally unique UUID which is persisted across
    // sessions in your application. More information can be found
    // [here](https://developer.android.com/training/articles/user-data-ids) on
    // best practices and exact implementation details. Caution should be taken
    // when storing personal data or anything which can identify a user. GDPR
    // and data protection laws may apply, ensure you do your own due
    // diligence.
    DeviceIDKey = attribute.Key("device.id")

    // DeviceModelIdentifierKey is the attribute Key conforming to the
    // "device.model.identifier" semantic conventions. It represents the model
    // identifier for the device
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'iPhone3,4', 'SM-G920F'
    // Note: It's recommended this value represents a machine readable version
    // of the model identifier rather than the market or consumer-friendly name
    // of the device.
    DeviceModelIdentifierKey = attribute.Key("device.model.identifier")

    // DeviceModelNameKey is the attribute Key conforming to the
    // "device.model.name" semantic conventions. It represents the marketing
    // name for the device model
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'iPhone 6s Plus', 'Samsung Galaxy S6'
    // Note: It's recommended this value represents a human readable version of
    // the device model rather than a machine readable alternative.
    DeviceModelNameKey = attribute.Key("device.model.name")

    // DeviceManufacturerKey is the attribute Key conforming to the
    // "device.manufacturer" semantic conventions. It represents the name of
    // the device manufacturer
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'Apple', 'Samsung'
    // Note: The Android OS provides this field via
    // [Build](https://developer.android.com/reference/android/os/Build#MANUFACTURER).
    // iOS apps SHOULD hardcode the value `Apple`.
    DeviceManufacturerKey = attribute.Key("device.manufacturer")
)

A serverless instance.

const (
    // FaaSNameKey is the attribute Key conforming to the "faas.name" semantic
    // conventions. It represents the name of the single function that this
    // runtime instance executes.
    //
    // Type: string
    // RequirementLevel: Required
    // Stability: stable
    // Examples: 'my-function', 'myazurefunctionapp/some-function-name'
    // Note: This is the name of the function as configured/deployed on the
    // FaaS
    // platform and is usually different from the name of the callback
    // function (which may be stored in the
    // [`code.namespace`/`code.function`](../../trace/semantic_conventions/span-general.md#source-code-attributes)
    // span attributes).
    //
    // For some cloud providers, the above definition is ambiguous. The
    // following
    // definition of function name MUST be used for this attribute
    // (and consequently the span name) for the listed cloud
    // providers/products:
    //
    // * **Azure:**  The full name `<FUNCAPP>/<FUNC>`, i.e., function app name
    //   followed by a forward slash followed by the function name (this form
    //   can also be seen in the resource JSON for the function).
    //   This means that a span attribute MUST be used, as an Azure function
    //   app can host multiple functions that would usually share
    //   a TracerProvider (see also the `cloud.resource_id` attribute).
    FaaSNameKey = attribute.Key("faas.name")

    // FaaSVersionKey is the attribute Key conforming to the "faas.version"
    // semantic conventions. It represents the immutable version of the
    // function being executed.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '26', 'pinkfroid-00002'
    // Note: Depending on the cloud provider and platform, use:
    //
    // * **AWS Lambda:** The [function
    // version](https://docs.aws.amazon.com/lambda/latest/dg/configuration-versions.html)
    //   (an integer represented as a decimal string).
    // * **Google Cloud Run:** The
    // [revision](https://cloud.google.com/run/docs/managing/revisions)
    //   (i.e., the function name plus the revision suffix).
    // * **Google Cloud Functions:** The value of the
    //   [`K_REVISION` environment
    // variable](https://cloud.google.com/functions/docs/env-var#runtime_environment_variables_set_automatically).
    // * **Azure Functions:** Not applicable. Do not set this attribute.
    FaaSVersionKey = attribute.Key("faas.version")

    // FaaSInstanceKey is the attribute Key conforming to the "faas.instance"
    // semantic conventions. It represents the execution environment ID as a
    // string, that will be potentially reused for other invocations to the
    // same function/function version.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '2021/06/28/[$LATEST]2f399eb14537447da05ab2a2e39309de'
    // Note: * **AWS Lambda:** Use the (full) log stream name.
    FaaSInstanceKey = attribute.Key("faas.instance")

    // FaaSMaxMemoryKey is the attribute Key conforming to the
    // "faas.max_memory" semantic conventions. It represents the amount of
    // memory available to the serverless function converted to Bytes.
    //
    // Type: int
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 134217728
    // Note: It's recommended to set this attribute since e.g. too little
    // memory can easily stop a Java AWS Lambda function from working
    // correctly. On AWS Lambda, the environment variable
    // `AWS_LAMBDA_FUNCTION_MEMORY_SIZE` provides this information (which must
    // be multiplied by 1,048,576).
    FaaSMaxMemoryKey = attribute.Key("faas.max_memory")
)

A host is defined as a general computing instance.

const (
    // HostIDKey is the attribute Key conforming to the "host.id" semantic
    // conventions. It represents the unique host ID. For Cloud, this must be
    // the instance_id assigned by the cloud provider. For non-containerized
    // systems, this should be the `machine-id`. See the table below for the
    // sources to use to determine the `machine-id` based on operating system.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'fdbf79e8af94cb7f9e8df36789187052'
    HostIDKey = attribute.Key("host.id")

    // HostNameKey is the attribute Key conforming to the "host.name" semantic
    // conventions. It represents the name of the host. On Unix systems, it may
    // contain what the hostname command returns, or the fully qualified
    // hostname, or another name specified by the user.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'opentelemetry-test'
    HostNameKey = attribute.Key("host.name")

    // HostTypeKey is the attribute Key conforming to the "host.type" semantic
    // conventions. It represents the type of host. For Cloud, this must be the
    // machine type.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'n1-standard-1'
    HostTypeKey = attribute.Key("host.type")

    // HostArchKey is the attribute Key conforming to the "host.arch" semantic
    // conventions. It represents the CPU architecture the host system is
    // running on.
    //
    // Type: Enum
    // RequirementLevel: Optional
    // Stability: stable
    HostArchKey = attribute.Key("host.arch")

    // HostImageNameKey is the attribute Key conforming to the
    // "host.image.name" semantic conventions. It represents the name of the VM
    // image or OS install the host was instantiated from.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'infra-ami-eks-worker-node-7d4ec78312', 'CentOS-8-x86_64-1905'
    HostImageNameKey = attribute.Key("host.image.name")

    // HostImageIDKey is the attribute Key conforming to the "host.image.id"
    // semantic conventions. It represents the vM image ID. For Cloud, this
    // value is from the provider.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'ami-07b06b442921831e5'
    HostImageIDKey = attribute.Key("host.image.id")

    // HostImageVersionKey is the attribute Key conforming to the
    // "host.image.version" semantic conventions. It represents the version
    // string of the VM image as defined in [Version
    // Attributes](README.md#version-attributes).
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '0.1'
    HostImageVersionKey = attribute.Key("host.image.version")
)

A Kubernetes Node object.

const (
    // K8SNodeNameKey is the attribute Key conforming to the "k8s.node.name"
    // semantic conventions. It represents the name of the Node.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'node-1'
    K8SNodeNameKey = attribute.Key("k8s.node.name")

    // K8SNodeUIDKey is the attribute Key conforming to the "k8s.node.uid"
    // semantic conventions. It represents the UID of the Node.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '1eb3a0c6-0477-4080-a9cb-0cb7db65c6a2'
    K8SNodeUIDKey = attribute.Key("k8s.node.uid")
)

A Kubernetes Pod object.

const (
    // K8SPodUIDKey is the attribute Key conforming to the "k8s.pod.uid"
    // semantic conventions. It represents the UID of the Pod.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
    K8SPodUIDKey = attribute.Key("k8s.pod.uid")

    // K8SPodNameKey is the attribute Key conforming to the "k8s.pod.name"
    // semantic conventions. It represents the name of the Pod.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'opentelemetry-pod-autoconf'
    K8SPodNameKey = attribute.Key("k8s.pod.name")
)

A container in a [PodTemplate](https://kubernetes.io/docs/concepts/workloads/pods/#pod-templates).

const (
    // K8SContainerNameKey is the attribute Key conforming to the
    // "k8s.container.name" semantic conventions. It represents the name of the
    // Container from Pod specification, must be unique within a Pod. Container
    // runtime usually uses different globally unique name (`container.name`).
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'redis'
    K8SContainerNameKey = attribute.Key("k8s.container.name")

    // K8SContainerRestartCountKey is the attribute Key conforming to the
    // "k8s.container.restart_count" semantic conventions. It represents the
    // number of times the container was restarted. This attribute can be used
    // to identify a particular container (running or stopped) within a
    // container spec.
    //
    // Type: int
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 0, 2
    K8SContainerRestartCountKey = attribute.Key("k8s.container.restart_count")
)

A Kubernetes ReplicaSet object.

const (
    // K8SReplicaSetUIDKey is the attribute Key conforming to the
    // "k8s.replicaset.uid" semantic conventions. It represents the UID of the
    // ReplicaSet.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
    K8SReplicaSetUIDKey = attribute.Key("k8s.replicaset.uid")

    // K8SReplicaSetNameKey is the attribute Key conforming to the
    // "k8s.replicaset.name" semantic conventions. It represents the name of
    // the ReplicaSet.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'opentelemetry'
    K8SReplicaSetNameKey = attribute.Key("k8s.replicaset.name")
)

A Kubernetes Deployment object.

const (
    // K8SDeploymentUIDKey is the attribute Key conforming to the
    // "k8s.deployment.uid" semantic conventions. It represents the UID of the
    // Deployment.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
    K8SDeploymentUIDKey = attribute.Key("k8s.deployment.uid")

    // K8SDeploymentNameKey is the attribute Key conforming to the
    // "k8s.deployment.name" semantic conventions. It represents the name of
    // the Deployment.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'opentelemetry'
    K8SDeploymentNameKey = attribute.Key("k8s.deployment.name")
)

A Kubernetes StatefulSet object.

const (
    // K8SStatefulSetUIDKey is the attribute Key conforming to the
    // "k8s.statefulset.uid" semantic conventions. It represents the UID of the
    // StatefulSet.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
    K8SStatefulSetUIDKey = attribute.Key("k8s.statefulset.uid")

    // K8SStatefulSetNameKey is the attribute Key conforming to the
    // "k8s.statefulset.name" semantic conventions. It represents the name of
    // the StatefulSet.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'opentelemetry'
    K8SStatefulSetNameKey = attribute.Key("k8s.statefulset.name")
)

A Kubernetes DaemonSet object.

const (
    // K8SDaemonSetUIDKey is the attribute Key conforming to the
    // "k8s.daemonset.uid" semantic conventions. It represents the UID of the
    // DaemonSet.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
    K8SDaemonSetUIDKey = attribute.Key("k8s.daemonset.uid")

    // K8SDaemonSetNameKey is the attribute Key conforming to the
    // "k8s.daemonset.name" semantic conventions. It represents the name of the
    // DaemonSet.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'opentelemetry'
    K8SDaemonSetNameKey = attribute.Key("k8s.daemonset.name")
)

A Kubernetes Job object.

const (
    // K8SJobUIDKey is the attribute Key conforming to the "k8s.job.uid"
    // semantic conventions. It represents the UID of the Job.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
    K8SJobUIDKey = attribute.Key("k8s.job.uid")

    // K8SJobNameKey is the attribute Key conforming to the "k8s.job.name"
    // semantic conventions. It represents the name of the Job.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'opentelemetry'
    K8SJobNameKey = attribute.Key("k8s.job.name")
)

A Kubernetes CronJob object.

const (
    // K8SCronJobUIDKey is the attribute Key conforming to the
    // "k8s.cronjob.uid" semantic conventions. It represents the UID of the
    // CronJob.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
    K8SCronJobUIDKey = attribute.Key("k8s.cronjob.uid")

    // K8SCronJobNameKey is the attribute Key conforming to the
    // "k8s.cronjob.name" semantic conventions. It represents the name of the
    // CronJob.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'opentelemetry'
    K8SCronJobNameKey = attribute.Key("k8s.cronjob.name")
)

The operating system (OS) on which the process represented by this resource is running.

const (
    // OSTypeKey is the attribute Key conforming to the "os.type" semantic
    // conventions. It represents the operating system type.
    //
    // Type: Enum
    // RequirementLevel: Required
    // Stability: stable
    OSTypeKey = attribute.Key("os.type")

    // OSDescriptionKey is the attribute Key conforming to the "os.description"
    // semantic conventions. It represents the human readable (not intended to
    // be parsed) OS version information, like e.g. reported by `ver` or
    // `lsb_release -a` commands.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'Microsoft Windows [Version 10.0.18363.778]', 'Ubuntu 18.04.1
    // LTS'
    OSDescriptionKey = attribute.Key("os.description")

    // OSNameKey is the attribute Key conforming to the "os.name" semantic
    // conventions. It represents the human readable operating system name.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'iOS', 'Android', 'Ubuntu'
    OSNameKey = attribute.Key("os.name")

    // OSVersionKey is the attribute Key conforming to the "os.version"
    // semantic conventions. It represents the version string of the operating
    // system as defined in [Version
    // Attributes](../../resource/semantic_conventions/README.md#version-attributes).
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '14.2.1', '18.04.1'
    OSVersionKey = attribute.Key("os.version")
)

An operating system process.

const (
    // ProcessPIDKey is the attribute Key conforming to the "process.pid"
    // semantic conventions. It represents the process identifier (PID).
    //
    // Type: int
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 1234
    ProcessPIDKey = attribute.Key("process.pid")

    // ProcessParentPIDKey is the attribute Key conforming to the
    // "process.parent_pid" semantic conventions. It represents the parent
    // Process identifier (PID).
    //
    // Type: int
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 111
    ProcessParentPIDKey = attribute.Key("process.parent_pid")

    // ProcessExecutableNameKey is the attribute Key conforming to the
    // "process.executable.name" semantic conventions. It represents the name
    // of the process executable. On Linux based systems, can be set to the
    // `Name` in `proc/[pid]/status`. On Windows, can be set to the base name
    // of `GetProcessImageFileNameW`.
    //
    // Type: string
    // RequirementLevel: ConditionallyRequired (See alternative attributes
    // below.)
    // Stability: stable
    // Examples: 'otelcol'
    ProcessExecutableNameKey = attribute.Key("process.executable.name")

    // ProcessExecutablePathKey is the attribute Key conforming to the
    // "process.executable.path" semantic conventions. It represents the full
    // path to the process executable. On Linux based systems, can be set to
    // the target of `proc/[pid]/exe`. On Windows, can be set to the result of
    // `GetProcessImageFileNameW`.
    //
    // Type: string
    // RequirementLevel: ConditionallyRequired (See alternative attributes
    // below.)
    // Stability: stable
    // Examples: '/usr/bin/cmd/otelcol'
    ProcessExecutablePathKey = attribute.Key("process.executable.path")

    // ProcessCommandKey is the attribute Key conforming to the
    // "process.command" semantic conventions. It represents the command used
    // to launch the process (i.e. the command name). On Linux based systems,
    // can be set to the zeroth string in `proc/[pid]/cmdline`. On Windows, can
    // be set to the first parameter extracted from `GetCommandLineW`.
    //
    // Type: string
    // RequirementLevel: ConditionallyRequired (See alternative attributes
    // below.)
    // Stability: stable
    // Examples: 'cmd/otelcol'
    ProcessCommandKey = attribute.Key("process.command")

    // ProcessCommandLineKey is the attribute Key conforming to the
    // "process.command_line" semantic conventions. It represents the full
    // command used to launch the process as a single string representing the
    // full command. On Windows, can be set to the result of `GetCommandLineW`.
    // Do not set this if you have to assemble it just for monitoring; use
    // `process.command_args` instead.
    //
    // Type: string
    // RequirementLevel: ConditionallyRequired (See alternative attributes
    // below.)
    // Stability: stable
    // Examples: 'C:\\cmd\\otecol --config="my directory\\config.yaml"'
    ProcessCommandLineKey = attribute.Key("process.command_line")

    // ProcessCommandArgsKey is the attribute Key conforming to the
    // "process.command_args" semantic conventions. It represents the all the
    // command arguments (including the command/executable itself) as received
    // by the process. On Linux-based systems (and some other Unixoid systems
    // supporting procfs), can be set according to the list of null-delimited
    // strings extracted from `proc/[pid]/cmdline`. For libc-based executables,
    // this would be the full argv vector passed to `main`.
    //
    // Type: string[]
    // RequirementLevel: ConditionallyRequired (See alternative attributes
    // below.)
    // Stability: stable
    // Examples: 'cmd/otecol', '--config=config.yaml'
    ProcessCommandArgsKey = attribute.Key("process.command_args")

    // ProcessOwnerKey is the attribute Key conforming to the "process.owner"
    // semantic conventions. It represents the username of the user that owns
    // the process.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'root'
    ProcessOwnerKey = attribute.Key("process.owner")
)

The single (language) runtime instance which is monitored.

const (
    // ProcessRuntimeNameKey is the attribute Key conforming to the
    // "process.runtime.name" semantic conventions. It represents the name of
    // the runtime of this process. For compiled native binaries, this SHOULD
    // be the name of the compiler.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'OpenJDK Runtime Environment'
    ProcessRuntimeNameKey = attribute.Key("process.runtime.name")

    // ProcessRuntimeVersionKey is the attribute Key conforming to the
    // "process.runtime.version" semantic conventions. It represents the
    // version of the runtime of this process, as returned by the runtime
    // without modification.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '14.0.2'
    ProcessRuntimeVersionKey = attribute.Key("process.runtime.version")

    // ProcessRuntimeDescriptionKey is the attribute Key conforming to the
    // "process.runtime.description" semantic conventions. It represents an
    // additional description about the runtime of the process, for example a
    // specific vendor customization of the runtime environment.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'Eclipse OpenJ9 Eclipse OpenJ9 VM openj9-0.21.0'
    ProcessRuntimeDescriptionKey = attribute.Key("process.runtime.description")
)

A service instance.

const (
    // ServiceNameKey is the attribute Key conforming to the "service.name"
    // semantic conventions. It represents the logical name of the service.
    //
    // Type: string
    // RequirementLevel: Required
    // Stability: stable
    // Examples: 'shoppingcart'
    // Note: MUST be the same for all instances of horizontally scaled
    // services. If the value was not specified, SDKs MUST fallback to
    // `unknown_service:` concatenated with
    // [`process.executable.name`](process.md#process), e.g.
    // `unknown_service:bash`. If `process.executable.name` is not available,
    // the value MUST be set to `unknown_service`.
    ServiceNameKey = attribute.Key("service.name")

    // ServiceNamespaceKey is the attribute Key conforming to the
    // "service.namespace" semantic conventions. It represents a namespace for
    // `service.name`.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'Shop'
    // Note: A string value having a meaning that helps to distinguish a group
    // of services, for example the team name that owns a group of services.
    // `service.name` is expected to be unique within the same namespace. If
    // `service.namespace` is not specified in the Resource then `service.name`
    // is expected to be unique for all services that have no explicit
    // namespace defined (so the empty/unspecified namespace is simply one more
    // valid namespace). Zero-length namespace string is assumed equal to
    // unspecified namespace.
    ServiceNamespaceKey = attribute.Key("service.namespace")

    // ServiceInstanceIDKey is the attribute Key conforming to the
    // "service.instance.id" semantic conventions. It represents the string ID
    // of the service instance.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '627cc493-f310-47de-96bd-71410b7dec09'
    // Note: MUST be unique for each instance of the same
    // `service.namespace,service.name` pair (in other words
    // `service.namespace,service.name,service.instance.id` triplet MUST be
    // globally unique). The ID helps to distinguish instances of the same
    // service that exist at the same time (e.g. instances of a horizontally
    // scaled service). It is preferable for the ID to be persistent and stay
    // the same for the lifetime of the service instance, however it is
    // acceptable that the ID is ephemeral and changes during important
    // lifetime events for the service (e.g. service restarts). If the service
    // has no inherent unique ID that can be used as the value of this
    // attribute it is recommended to generate a random Version 1 or Version 4
    // RFC 4122 UUID (services aiming for reproducible UUIDs may also use
    // Version 5, see RFC 4122 for more recommendations).
    ServiceInstanceIDKey = attribute.Key("service.instance.id")

    // ServiceVersionKey is the attribute Key conforming to the
    // "service.version" semantic conventions. It represents the version string
    // of the service API or implementation.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '2.0.0'
    ServiceVersionKey = attribute.Key("service.version")
)

The telemetry SDK used to capture data recorded by the instrumentation libraries.

const (
    // TelemetrySDKNameKey is the attribute Key conforming to the
    // "telemetry.sdk.name" semantic conventions. It represents the name of the
    // telemetry SDK as defined above.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'opentelemetry'
    TelemetrySDKNameKey = attribute.Key("telemetry.sdk.name")

    // TelemetrySDKLanguageKey is the attribute Key conforming to the
    // "telemetry.sdk.language" semantic conventions. It represents the
    // language of the telemetry SDK.
    //
    // Type: Enum
    // RequirementLevel: Optional
    // Stability: stable
    TelemetrySDKLanguageKey = attribute.Key("telemetry.sdk.language")

    // TelemetrySDKVersionKey is the attribute Key conforming to the
    // "telemetry.sdk.version" semantic conventions. It represents the version
    // string of the telemetry SDK.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '1.2.3'
    TelemetrySDKVersionKey = attribute.Key("telemetry.sdk.version")

    // TelemetryAutoVersionKey is the attribute Key conforming to the
    // "telemetry.auto.version" semantic conventions. It represents the version
    // string of the auto instrumentation agent, if used.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '1.2.3'
    TelemetryAutoVersionKey = attribute.Key("telemetry.auto.version")
)

Resource describing the packaged software running the application code. Web engines are typically executed using process.runtime.

const (
    // WebEngineNameKey is the attribute Key conforming to the "webengine.name"
    // semantic conventions. It represents the name of the web engine.
    //
    // Type: string
    // RequirementLevel: Required
    // Stability: stable
    // Examples: 'WildFly'
    WebEngineNameKey = attribute.Key("webengine.name")

    // WebEngineVersionKey is the attribute Key conforming to the
    // "webengine.version" semantic conventions. It represents the version of
    // the web engine.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '21.0.0'
    WebEngineVersionKey = attribute.Key("webengine.version")

    // WebEngineDescriptionKey is the attribute Key conforming to the
    // "webengine.description" semantic conventions. It represents the
    // additional description of the web engine (e.g. detailed version and
    // edition information).
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'WildFly Full 21.0.0.Final (WildFly Core 13.0.1.Final) -
    // 2.2.2.Final'
    WebEngineDescriptionKey = attribute.Key("webengine.description")
)

Attributes used by non-OTLP exporters to represent OpenTelemetry Scope's concepts.

const (
    // OTelScopeNameKey is the attribute Key conforming to the
    // "otel.scope.name" semantic conventions. It represents the name of the
    // instrumentation scope - (`InstrumentationScope.Name` in OTLP).
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'io.opentelemetry.contrib.mongodb'
    OTelScopeNameKey = attribute.Key("otel.scope.name")

    // OTelScopeVersionKey is the attribute Key conforming to the
    // "otel.scope.version" semantic conventions. It represents the version of
    // the instrumentation scope - (`InstrumentationScope.Version` in OTLP).
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '1.0.0'
    OTelScopeVersionKey = attribute.Key("otel.scope.version")
)

Span attributes used by non-OTLP exporters to represent OpenTelemetry Scope's concepts.

const (
    // OTelLibraryNameKey is the attribute Key conforming to the
    // "otel.library.name" semantic conventions. It represents the deprecated,
    // use the `otel.scope.name` attribute.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: deprecated
    // Examples: 'io.opentelemetry.contrib.mongodb'
    OTelLibraryNameKey = attribute.Key("otel.library.name")

    // OTelLibraryVersionKey is the attribute Key conforming to the
    // "otel.library.version" semantic conventions. It represents the
    // deprecated, use the `otel.scope.version` attribute.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: deprecated
    // Examples: '1.0.0'
    OTelLibraryVersionKey = attribute.Key("otel.library.version")
)

The shared attributes used to report a single exception associated with a span or log.

const (
    // ExceptionTypeKey is the attribute Key conforming to the "exception.type"
    // semantic conventions. It represents the type of the exception (its
    // fully-qualified class name, if applicable). The dynamic type of the
    // exception should be preferred over the static type in languages that
    // support it.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'java.net.ConnectException', 'OSError'
    ExceptionTypeKey = attribute.Key("exception.type")

    // ExceptionMessageKey is the attribute Key conforming to the
    // "exception.message" semantic conventions. It represents the exception
    // message.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'Division by zero', "Can't convert 'int' object to str
    // implicitly"
    ExceptionMessageKey = attribute.Key("exception.message")

    // ExceptionStacktraceKey is the attribute Key conforming to the
    // "exception.stacktrace" semantic conventions. It represents a stacktrace
    // as a string in the natural representation for the language runtime. The
    // representation is to be determined and documented by each language SIG.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'Exception in thread "main" java.lang.RuntimeException: Test
    // exception\\n at '
    //  'com.example.GenerateTrace.methodB(GenerateTrace.java:13)\\n at '
    //  'com.example.GenerateTrace.methodA(GenerateTrace.java:9)\\n at '
    //  'com.example.GenerateTrace.main(GenerateTrace.java:5)'
    ExceptionStacktraceKey = attribute.Key("exception.stacktrace")
)

Attributes for CloudEvents. CloudEvents is a specification on how to define event data in a standard way. These attributes can be attached to spans when performing operations with CloudEvents, regardless of the protocol being used.

const (
    // CloudeventsEventIDKey is the attribute Key conforming to the
    // "cloudevents.event_id" semantic conventions. It represents the
    // [event_id](https://github.com/cloudevents/spec/blob/v1.0.2/cloudevents/spec.md#id)
    // uniquely identifies the event.
    //
    // Type: string
    // RequirementLevel: Required
    // Stability: stable
    // Examples: '123e4567-e89b-12d3-a456-426614174000', '0001'
    CloudeventsEventIDKey = attribute.Key("cloudevents.event_id")

    // CloudeventsEventSourceKey is the attribute Key conforming to the
    // "cloudevents.event_source" semantic conventions. It represents the
    // [source](https://github.com/cloudevents/spec/blob/v1.0.2/cloudevents/spec.md#source-1)
    // identifies the context in which an event happened.
    //
    // Type: string
    // RequirementLevel: Required
    // Stability: stable
    // Examples: 'https://github.com/cloudevents',
    // '/cloudevents/spec/pull/123', 'my-service'
    CloudeventsEventSourceKey = attribute.Key("cloudevents.event_source")

    // CloudeventsEventSpecVersionKey is the attribute Key conforming to the
    // "cloudevents.event_spec_version" semantic conventions. It represents the
    // [version of the CloudEvents
    // specification](https://github.com/cloudevents/spec/blob/v1.0.2/cloudevents/spec.md#specversion)
    // which the event uses.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '1.0'
    CloudeventsEventSpecVersionKey = attribute.Key("cloudevents.event_spec_version")

    // CloudeventsEventTypeKey is the attribute Key conforming to the
    // "cloudevents.event_type" semantic conventions. It represents the
    // [event_type](https://github.com/cloudevents/spec/blob/v1.0.2/cloudevents/spec.md#type)
    // contains a value describing the type of event related to the originating
    // occurrence.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'com.github.pull_request.opened',
    // 'com.example.object.deleted.v2'
    CloudeventsEventTypeKey = attribute.Key("cloudevents.event_type")

    // CloudeventsEventSubjectKey is the attribute Key conforming to the
    // "cloudevents.event_subject" semantic conventions. It represents the
    // [subject](https://github.com/cloudevents/spec/blob/v1.0.2/cloudevents/spec.md#subject)
    // of the event in the context of the event producer (identified by
    // source).
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'mynewfile.jpg'
    CloudeventsEventSubjectKey = attribute.Key("cloudevents.event_subject")
)

The attributes used to perform database client calls.

const (
    // DBSystemKey is the attribute Key conforming to the "db.system" semantic
    // conventions. It represents an identifier for the database management
    // system (DBMS) product being used. See below for a list of well-known
    // identifiers.
    //
    // Type: Enum
    // RequirementLevel: Required
    // Stability: stable
    DBSystemKey = attribute.Key("db.system")

    // DBConnectionStringKey is the attribute Key conforming to the
    // "db.connection_string" semantic conventions. It represents the
    // connection string used to connect to the database. It is recommended to
    // remove embedded credentials.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'Server=(localdb)\\v11.0;Integrated Security=true;'
    DBConnectionStringKey = attribute.Key("db.connection_string")

    // DBUserKey is the attribute Key conforming to the "db.user" semantic
    // conventions. It represents the username for accessing the database.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'readonly_user', 'reporting_user'
    DBUserKey = attribute.Key("db.user")

    // DBJDBCDriverClassnameKey is the attribute Key conforming to the
    // "db.jdbc.driver_classname" semantic conventions. It represents the
    // fully-qualified class name of the [Java Database Connectivity
    // (JDBC)](https://docs.oracle.com/javase/8/docs/technotes/guides/jdbc/)
    // driver used to connect.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'org.postgresql.Driver',
    // 'com.microsoft.sqlserver.jdbc.SQLServerDriver'
    DBJDBCDriverClassnameKey = attribute.Key("db.jdbc.driver_classname")

    // DBNameKey is the attribute Key conforming to the "db.name" semantic
    // conventions. It represents the this attribute is used to report the name
    // of the database being accessed. For commands that switch the database,
    // this should be set to the target database (even if the command fails).
    //
    // Type: string
    // RequirementLevel: ConditionallyRequired (If applicable.)
    // Stability: stable
    // Examples: 'customers', 'main'
    // Note: In some SQL databases, the database name to be used is called
    // "schema name". In case there are multiple layers that could be
    // considered for database name (e.g. Oracle instance name and schema
    // name), the database name to be used is the more specific layer (e.g.
    // Oracle schema name).
    DBNameKey = attribute.Key("db.name")

    // DBStatementKey is the attribute Key conforming to the "db.statement"
    // semantic conventions. It represents the database statement being
    // executed.
    //
    // Type: string
    // RequirementLevel: ConditionallyRequired (If applicable and not
    // explicitly disabled via instrumentation configuration.)
    // Stability: stable
    // Examples: 'SELECT * FROM wuser_table', 'SET mykey "WuValue"'
    // Note: The value may be sanitized to exclude sensitive information.
    DBStatementKey = attribute.Key("db.statement")

    // DBOperationKey is the attribute Key conforming to the "db.operation"
    // semantic conventions. It represents the name of the operation being
    // executed, e.g. the [MongoDB command
    // name](https://docs.mongodb.com/manual/reference/command/#database-operations)
    // such as `findAndModify`, or the SQL keyword.
    //
    // Type: string
    // RequirementLevel: ConditionallyRequired (If `db.statement` is not
    // applicable.)
    // Stability: stable
    // Examples: 'findAndModify', 'HMSET', 'SELECT'
    // Note: When setting this to an SQL keyword, it is not recommended to
    // attempt any client-side parsing of `db.statement` just to get this
    // property, but it should be set if the operation name is provided by the
    // library being instrumented. If the SQL statement has an ambiguous
    // operation, or performs more than one operation, this value may be
    // omitted.
    DBOperationKey = attribute.Key("db.operation")
)

Call-level attributes for Cassandra

const (
    // DBCassandraPageSizeKey is the attribute Key conforming to the
    // "db.cassandra.page_size" semantic conventions. It represents the fetch
    // size used for paging, i.e. how many rows will be returned at once.
    //
    // Type: int
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 5000
    DBCassandraPageSizeKey = attribute.Key("db.cassandra.page_size")

    // DBCassandraConsistencyLevelKey is the attribute Key conforming to the
    // "db.cassandra.consistency_level" semantic conventions. It represents the
    // consistency level of the query. Based on consistency values from
    // [CQL](https://docs.datastax.com/en/cassandra-oss/3.0/cassandra/dml/dmlConfigConsistency.html).
    //
    // Type: Enum
    // RequirementLevel: Optional
    // Stability: stable
    DBCassandraConsistencyLevelKey = attribute.Key("db.cassandra.consistency_level")

    // DBCassandraTableKey is the attribute Key conforming to the
    // "db.cassandra.table" semantic conventions. It represents the name of the
    // primary table that the operation is acting upon, including the keyspace
    // name (if applicable).
    //
    // Type: string
    // RequirementLevel: Recommended
    // Stability: stable
    // Examples: 'mytable'
    // Note: This mirrors the db.sql.table attribute but references cassandra
    // rather than sql. It is not recommended to attempt any client-side
    // parsing of `db.statement` just to get this property, but it should be
    // set if it is provided by the library being instrumented. If the
    // operation is acting upon an anonymous table, or more than one table,
    // this value MUST NOT be set.
    DBCassandraTableKey = attribute.Key("db.cassandra.table")

    // DBCassandraIdempotenceKey is the attribute Key conforming to the
    // "db.cassandra.idempotence" semantic conventions. It represents the
    // whether or not the query is idempotent.
    //
    // Type: boolean
    // RequirementLevel: Optional
    // Stability: stable
    DBCassandraIdempotenceKey = attribute.Key("db.cassandra.idempotence")

    // DBCassandraSpeculativeExecutionCountKey is the attribute Key conforming
    // to the "db.cassandra.speculative_execution_count" semantic conventions.
    // It represents the number of times a query was speculatively executed.
    // Not set or `0` if the query was not executed speculatively.
    //
    // Type: int
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 0, 2
    DBCassandraSpeculativeExecutionCountKey = attribute.Key("db.cassandra.speculative_execution_count")

    // DBCassandraCoordinatorIDKey is the attribute Key conforming to the
    // "db.cassandra.coordinator.id" semantic conventions. It represents the ID
    // of the coordinating node for a query.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'be13faa2-8574-4d71-926d-27f16cf8a7af'
    DBCassandraCoordinatorIDKey = attribute.Key("db.cassandra.coordinator.id")

    // DBCassandraCoordinatorDCKey is the attribute Key conforming to the
    // "db.cassandra.coordinator.dc" semantic conventions. It represents the
    // data center of the coordinating node for a query.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'us-west-2'
    DBCassandraCoordinatorDCKey = attribute.Key("db.cassandra.coordinator.dc")
)

Span attributes used by non-OTLP exporters to represent OpenTelemetry Span's concepts.

const (
    // OTelStatusCodeKey is the attribute Key conforming to the
    // "otel.status_code" semantic conventions. It represents the name of the
    // code, either "OK" or "ERROR". MUST NOT be set if the status code is
    // UNSET.
    //
    // Type: Enum
    // RequirementLevel: Optional
    // Stability: stable
    OTelStatusCodeKey = attribute.Key("otel.status_code")

    // OTelStatusDescriptionKey is the attribute Key conforming to the
    // "otel.status_description" semantic conventions. It represents the
    // description of the Status if it has a value, otherwise not set.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'resource not found'
    OTelStatusDescriptionKey = attribute.Key("otel.status_description")
)

This semantic convention describes an instance of a function that runs without provisioning or managing of servers (also known as serverless functions or Function as a Service (FaaS)) with spans.

const (
    // FaaSTriggerKey is the attribute Key conforming to the "faas.trigger"
    // semantic conventions. It represents the type of the trigger which caused
    // this function invocation.
    //
    // Type: Enum
    // RequirementLevel: Optional
    // Stability: stable
    // Note: For the server/consumer span on the incoming side,
    // `faas.trigger` MUST be set.
    //
    // Clients invoking FaaS instances usually cannot set `faas.trigger`,
    // since they would typically need to look in the payload to determine
    // the event type. If clients set it, it should be the same as the
    // trigger that corresponding incoming would have (i.e., this has
    // nothing to do with the underlying transport used to make the API
    // call to invoke the lambda, which is often HTTP).
    FaaSTriggerKey = attribute.Key("faas.trigger")

    // FaaSInvocationIDKey is the attribute Key conforming to the
    // "faas.invocation_id" semantic conventions. It represents the invocation
    // ID of the current function invocation.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'af9d5aa4-a685-4c5f-a22b-444f80b3cc28'
    FaaSInvocationIDKey = attribute.Key("faas.invocation_id")
)

Semantic Convention for FaaS triggered as a response to some data source operation such as a database or filesystem read/write.

const (
    // FaaSDocumentCollectionKey is the attribute Key conforming to the
    // "faas.document.collection" semantic conventions. It represents the name
    // of the source on which the triggering operation was performed. For
    // example, in Cloud Storage or S3 corresponds to the bucket name, and in
    // Cosmos DB to the database name.
    //
    // Type: string
    // RequirementLevel: Required
    // Stability: stable
    // Examples: 'myBucketName', 'myDBName'
    FaaSDocumentCollectionKey = attribute.Key("faas.document.collection")

    // FaaSDocumentOperationKey is the attribute Key conforming to the
    // "faas.document.operation" semantic conventions. It represents the
    // describes the type of the operation that was performed on the data.
    //
    // Type: Enum
    // RequirementLevel: Required
    // Stability: stable
    FaaSDocumentOperationKey = attribute.Key("faas.document.operation")

    // FaaSDocumentTimeKey is the attribute Key conforming to the
    // "faas.document.time" semantic conventions. It represents a string
    // containing the time when the data was accessed in the [ISO
    // 8601](https://www.iso.org/iso-8601-date-and-time-format.html) format
    // expressed in [UTC](https://www.w3.org/TR/NOTE-datetime).
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '2020-01-23T13:47:06Z'
    FaaSDocumentTimeKey = attribute.Key("faas.document.time")

    // FaaSDocumentNameKey is the attribute Key conforming to the
    // "faas.document.name" semantic conventions. It represents the document
    // name/table subjected to the operation. For example, in Cloud Storage or
    // S3 is the name of the file, and in Cosmos DB the table name.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'myFile.txt', 'myTableName'
    FaaSDocumentNameKey = attribute.Key("faas.document.name")
)

Semantic Convention for FaaS scheduled to be executed regularly.

const (
    // FaaSTimeKey is the attribute Key conforming to the "faas.time" semantic
    // conventions. It represents a string containing the function invocation
    // time in the [ISO
    // 8601](https://www.iso.org/iso-8601-date-and-time-format.html) format
    // expressed in [UTC](https://www.w3.org/TR/NOTE-datetime).
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '2020-01-23T13:47:06Z'
    FaaSTimeKey = attribute.Key("faas.time")

    // FaaSCronKey is the attribute Key conforming to the "faas.cron" semantic
    // conventions. It represents a string containing the schedule period as
    // [Cron
    // Expression](https://docs.oracle.com/cd/E12058_01/doc/doc.1014/e12030/cron_expressions.htm).
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '0/5 * * * ? *'
    FaaSCronKey = attribute.Key("faas.cron")
)

Contains additional attributes for outgoing FaaS spans.

const (
    // FaaSInvokedNameKey is the attribute Key conforming to the
    // "faas.invoked_name" semantic conventions. It represents the name of the
    // invoked function.
    //
    // Type: string
    // RequirementLevel: Required
    // Stability: stable
    // Examples: 'my-function'
    // Note: SHOULD be equal to the `faas.name` resource attribute of the
    // invoked function.
    FaaSInvokedNameKey = attribute.Key("faas.invoked_name")

    // FaaSInvokedProviderKey is the attribute Key conforming to the
    // "faas.invoked_provider" semantic conventions. It represents the cloud
    // provider of the invoked function.
    //
    // Type: Enum
    // RequirementLevel: Required
    // Stability: stable
    // Note: SHOULD be equal to the `cloud.provider` resource attribute of the
    // invoked function.
    FaaSInvokedProviderKey = attribute.Key("faas.invoked_provider")

    // FaaSInvokedRegionKey is the attribute Key conforming to the
    // "faas.invoked_region" semantic conventions. It represents the cloud
    // region of the invoked function.
    //
    // Type: string
    // RequirementLevel: ConditionallyRequired (For some cloud providers, like
    // AWS or GCP, the region in which a function is hosted is essential to
    // uniquely identify the function and also part of its endpoint. Since it's
    // part of the endpoint being called, the region is always known to
    // clients. In these cases, `faas.invoked_region` MUST be set accordingly.
    // If the region is unknown to the client or not required for identifying
    // the invoked function, setting `faas.invoked_region` is optional.)
    // Stability: stable
    // Examples: 'eu-central-1'
    // Note: SHOULD be equal to the `cloud.region` resource attribute of the
    // invoked function.
    FaaSInvokedRegionKey = attribute.Key("faas.invoked_region")
)

These attributes may be used for any operation with an authenticated and/or authorized enduser.

const (
    // EnduserIDKey is the attribute Key conforming to the "enduser.id"
    // semantic conventions. It represents the username or client_id extracted
    // from the access token or
    // [Authorization](https://tools.ietf.org/html/rfc7235#section-4.2) header
    // in the inbound request from outside the system.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'username'
    EnduserIDKey = attribute.Key("enduser.id")

    // EnduserRoleKey is the attribute Key conforming to the "enduser.role"
    // semantic conventions. It represents the actual/assumed role the client
    // is making the request under extracted from token or application security
    // context.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'admin'
    EnduserRoleKey = attribute.Key("enduser.role")

    // EnduserScopeKey is the attribute Key conforming to the "enduser.scope"
    // semantic conventions. It represents the scopes or granted authorities
    // the client currently possesses extracted from token or application
    // security context. The value would come from the scope associated with an
    // [OAuth 2.0 Access
    // Token](https://tools.ietf.org/html/rfc6749#section-3.3) or an attribute
    // value in a [SAML 2.0
    // Assertion](http://docs.oasis-open.org/security/saml/Post2.0/sstc-saml-tech-overview-2.0.html).
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'read:message, write:files'
    EnduserScopeKey = attribute.Key("enduser.scope")
)

These attributes may be used for any operation to store information about a thread that started a span.

const (
    // ThreadIDKey is the attribute Key conforming to the "thread.id" semantic
    // conventions. It represents the current "managed" thread ID (as opposed
    // to OS thread ID).
    //
    // Type: int
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 42
    ThreadIDKey = attribute.Key("thread.id")

    // ThreadNameKey is the attribute Key conforming to the "thread.name"
    // semantic conventions. It represents the current thread name.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'main'
    ThreadNameKey = attribute.Key("thread.name")
)

These attributes allow to report this unit of code and therefore to provide more context about the span.

const (
    // CodeFunctionKey is the attribute Key conforming to the "code.function"
    // semantic conventions. It represents the method or function name, or
    // equivalent (usually rightmost part of the code unit's name).
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'serveRequest'
    CodeFunctionKey = attribute.Key("code.function")

    // CodeNamespaceKey is the attribute Key conforming to the "code.namespace"
    // semantic conventions. It represents the "namespace" within which
    // `code.function` is defined. Usually the qualified class or module name,
    // such that `code.namespace` + some separator + `code.function` form a
    // unique identifier for the code unit.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'com.example.MyHTTPService'
    CodeNamespaceKey = attribute.Key("code.namespace")

    // CodeFilepathKey is the attribute Key conforming to the "code.filepath"
    // semantic conventions. It represents the source code file name that
    // identifies the code unit as uniquely as possible (preferably an absolute
    // file path).
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '/usr/local/MyApplication/content_root/app/index.php'
    CodeFilepathKey = attribute.Key("code.filepath")

    // CodeLineNumberKey is the attribute Key conforming to the "code.lineno"
    // semantic conventions. It represents the line number in `code.filepath`
    // best representing the operation. It SHOULD point within the code unit
    // named in `code.function`.
    //
    // Type: int
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 42
    CodeLineNumberKey = attribute.Key("code.lineno")

    // CodeColumnKey is the attribute Key conforming to the "code.column"
    // semantic conventions. It represents the column number in `code.filepath`
    // best representing the operation. It SHOULD point within the code unit
    // named in `code.function`.
    //
    // Type: int
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 16
    CodeColumnKey = attribute.Key("code.column")
)

Semantic Convention for HTTP Client

const (
    // HTTPURLKey is the attribute Key conforming to the "http.url" semantic
    // conventions. It represents the full HTTP request URL in the form
    // `scheme://host[:port]/path?query[#fragment]`. Usually the fragment is
    // not transmitted over HTTP, but if it is known, it should be included
    // nevertheless.
    //
    // Type: string
    // RequirementLevel: Required
    // Stability: stable
    // Examples: 'https://www.foo.bar/search?q=OpenTelemetry#SemConv'
    // Note: `http.url` MUST NOT contain credentials passed via URL in form of
    // `https://username:password@www.example.com/`. In such case the
    // attribute's value should be `https://www.example.com/`.
    HTTPURLKey = attribute.Key("http.url")

    // HTTPResendCountKey is the attribute Key conforming to the
    // "http.resend_count" semantic conventions. It represents the ordinal
    // number of request resending attempt (for any reason, including
    // redirects).
    //
    // Type: int
    // RequirementLevel: Recommended (if and only if request was retried.)
    // Stability: stable
    // Examples: 3
    // Note: The resend count SHOULD be updated each time an HTTP request gets
    // resent by the client, regardless of what was the cause of the resending
    // (e.g. redirection, authorization failure, 503 Server Unavailable,
    // network issues, or any other).
    HTTPResendCountKey = attribute.Key("http.resend_count")
)

Semantic Convention for HTTP Server

const (
    // HTTPTargetKey is the attribute Key conforming to the "http.target"
    // semantic conventions. It represents the full request target as passed in
    // a HTTP request line or equivalent.
    //
    // Type: string
    // RequirementLevel: Required
    // Stability: stable
    // Examples: '/path/12314/?q=ddds'
    HTTPTargetKey = attribute.Key("http.target")

    // HTTPClientIPKey is the attribute Key conforming to the "http.client_ip"
    // semantic conventions. It represents the IP address of the original
    // client behind all proxies, if known (e.g. from
    // [X-Forwarded-For](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-For)).
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '83.164.160.102'
    // Note: This is not necessarily the same as `net.sock.peer.addr`, which
    // would
    // identify the network-level peer, which may be a proxy.
    //
    // This attribute should be set when a source of information different
    // from the one used for `net.sock.peer.addr`, is available even if that
    // other
    // source just confirms the same value as `net.sock.peer.addr`.
    // Rationale: For `net.sock.peer.addr`, one typically does not know if it
    // comes from a proxy, reverse proxy, or the actual client. Setting
    // `http.client_ip` when it's the same as `net.sock.peer.addr` means that
    // one is at least somewhat confident that the address is not that of
    // the closest proxy.
    HTTPClientIPKey = attribute.Key("http.client_ip")
)

Attributes that exist for multiple DynamoDB request types.

const (
    // AWSDynamoDBTableNamesKey is the attribute Key conforming to the
    // "aws.dynamodb.table_names" semantic conventions. It represents the keys
    // in the `RequestItems` object field.
    //
    // Type: string[]
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'Users', 'Cats'
    AWSDynamoDBTableNamesKey = attribute.Key("aws.dynamodb.table_names")

    // AWSDynamoDBConsumedCapacityKey is the attribute Key conforming to the
    // "aws.dynamodb.consumed_capacity" semantic conventions. It represents the
    // JSON-serialized value of each item in the `ConsumedCapacity` response
    // field.
    //
    // Type: string[]
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '{ "CapacityUnits": number, "GlobalSecondaryIndexes": {
    // "string" : { "CapacityUnits": number, "ReadCapacityUnits": number,
    // "WriteCapacityUnits": number } }, "LocalSecondaryIndexes": { "string" :
    // { "CapacityUnits": number, "ReadCapacityUnits": number,
    // "WriteCapacityUnits": number } }, "ReadCapacityUnits": number, "Table":
    // { "CapacityUnits": number, "ReadCapacityUnits": number,
    // "WriteCapacityUnits": number }, "TableName": "string",
    // "WriteCapacityUnits": number }'
    AWSDynamoDBConsumedCapacityKey = attribute.Key("aws.dynamodb.consumed_capacity")

    // AWSDynamoDBItemCollectionMetricsKey is the attribute Key conforming to
    // the "aws.dynamodb.item_collection_metrics" semantic conventions. It
    // represents the JSON-serialized value of the `ItemCollectionMetrics`
    // response field.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '{ "string" : [ { "ItemCollectionKey": { "string" : { "B":
    // blob, "BOOL": boolean, "BS": [ blob ], "L": [ "AttributeValue" ], "M": {
    // "string" : "AttributeValue" }, "N": "string", "NS": [ "string" ],
    // "NULL": boolean, "S": "string", "SS": [ "string" ] } },
    // "SizeEstimateRangeGB": [ number ] } ] }'
    AWSDynamoDBItemCollectionMetricsKey = attribute.Key("aws.dynamodb.item_collection_metrics")

    // AWSDynamoDBProvisionedReadCapacityKey is the attribute Key conforming to
    // the "aws.dynamodb.provisioned_read_capacity" semantic conventions. It
    // represents the value of the `ProvisionedThroughput.ReadCapacityUnits`
    // request parameter.
    //
    // Type: double
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 1.0, 2.0
    AWSDynamoDBProvisionedReadCapacityKey = attribute.Key("aws.dynamodb.provisioned_read_capacity")

    // AWSDynamoDBProvisionedWriteCapacityKey is the attribute Key conforming
    // to the "aws.dynamodb.provisioned_write_capacity" semantic conventions.
    // It represents the value of the
    // `ProvisionedThroughput.WriteCapacityUnits` request parameter.
    //
    // Type: double
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 1.0, 2.0
    AWSDynamoDBProvisionedWriteCapacityKey = attribute.Key("aws.dynamodb.provisioned_write_capacity")

    // AWSDynamoDBConsistentReadKey is the attribute Key conforming to the
    // "aws.dynamodb.consistent_read" semantic conventions. It represents the
    // value of the `ConsistentRead` request parameter.
    //
    // Type: boolean
    // RequirementLevel: Optional
    // Stability: stable
    AWSDynamoDBConsistentReadKey = attribute.Key("aws.dynamodb.consistent_read")

    // AWSDynamoDBProjectionKey is the attribute Key conforming to the
    // "aws.dynamodb.projection" semantic conventions. It represents the value
    // of the `ProjectionExpression` request parameter.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'Title', 'Title, Price, Color', 'Title, Description,
    // RelatedItems, ProductReviews'
    AWSDynamoDBProjectionKey = attribute.Key("aws.dynamodb.projection")

    // AWSDynamoDBLimitKey is the attribute Key conforming to the
    // "aws.dynamodb.limit" semantic conventions. It represents the value of
    // the `Limit` request parameter.
    //
    // Type: int
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 10
    AWSDynamoDBLimitKey = attribute.Key("aws.dynamodb.limit")

    // AWSDynamoDBAttributesToGetKey is the attribute Key conforming to the
    // "aws.dynamodb.attributes_to_get" semantic conventions. It represents the
    // value of the `AttributesToGet` request parameter.
    //
    // Type: string[]
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'lives', 'id'
    AWSDynamoDBAttributesToGetKey = attribute.Key("aws.dynamodb.attributes_to_get")

    // AWSDynamoDBIndexNameKey is the attribute Key conforming to the
    // "aws.dynamodb.index_name" semantic conventions. It represents the value
    // of the `IndexName` request parameter.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'name_to_group'
    AWSDynamoDBIndexNameKey = attribute.Key("aws.dynamodb.index_name")

    // AWSDynamoDBSelectKey is the attribute Key conforming to the
    // "aws.dynamodb.select" semantic conventions. It represents the value of
    // the `Select` request parameter.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'ALL_ATTRIBUTES', 'COUNT'
    AWSDynamoDBSelectKey = attribute.Key("aws.dynamodb.select")
)

DynamoDB.CreateTable

const (
    // AWSDynamoDBGlobalSecondaryIndexesKey is the attribute Key conforming to
    // the "aws.dynamodb.global_secondary_indexes" semantic conventions. It
    // represents the JSON-serialized value of each item of the
    // `GlobalSecondaryIndexes` request field
    //
    // Type: string[]
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '{ "IndexName": "string", "KeySchema": [ { "AttributeName":
    // "string", "KeyType": "string" } ], "Projection": { "NonKeyAttributes": [
    // "string" ], "ProjectionType": "string" }, "ProvisionedThroughput": {
    // "ReadCapacityUnits": number, "WriteCapacityUnits": number } }'
    AWSDynamoDBGlobalSecondaryIndexesKey = attribute.Key("aws.dynamodb.global_secondary_indexes")

    // AWSDynamoDBLocalSecondaryIndexesKey is the attribute Key conforming to
    // the "aws.dynamodb.local_secondary_indexes" semantic conventions. It
    // represents the JSON-serialized value of each item of the
    // `LocalSecondaryIndexes` request field.
    //
    // Type: string[]
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '{ "IndexARN": "string", "IndexName": "string",
    // "IndexSizeBytes": number, "ItemCount": number, "KeySchema": [ {
    // "AttributeName": "string", "KeyType": "string" } ], "Projection": {
    // "NonKeyAttributes": [ "string" ], "ProjectionType": "string" } }'
    AWSDynamoDBLocalSecondaryIndexesKey = attribute.Key("aws.dynamodb.local_secondary_indexes")
)

DynamoDB.ListTables

const (
    // AWSDynamoDBExclusiveStartTableKey is the attribute Key conforming to the
    // "aws.dynamodb.exclusive_start_table" semantic conventions. It represents
    // the value of the `ExclusiveStartTableName` request parameter.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'Users', 'CatsTable'
    AWSDynamoDBExclusiveStartTableKey = attribute.Key("aws.dynamodb.exclusive_start_table")

    // AWSDynamoDBTableCountKey is the attribute Key conforming to the
    // "aws.dynamodb.table_count" semantic conventions. It represents the the
    // number of items in the `TableNames` response parameter.
    //
    // Type: int
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 20
    AWSDynamoDBTableCountKey = attribute.Key("aws.dynamodb.table_count")
)

DynamoDB.Scan

const (
    // AWSDynamoDBSegmentKey is the attribute Key conforming to the
    // "aws.dynamodb.segment" semantic conventions. It represents the value of
    // the `Segment` request parameter.
    //
    // Type: int
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 10
    AWSDynamoDBSegmentKey = attribute.Key("aws.dynamodb.segment")

    // AWSDynamoDBTotalSegmentsKey is the attribute Key conforming to the
    // "aws.dynamodb.total_segments" semantic conventions. It represents the
    // value of the `TotalSegments` request parameter.
    //
    // Type: int
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 100
    AWSDynamoDBTotalSegmentsKey = attribute.Key("aws.dynamodb.total_segments")

    // AWSDynamoDBCountKey is the attribute Key conforming to the
    // "aws.dynamodb.count" semantic conventions. It represents the value of
    // the `Count` response parameter.
    //
    // Type: int
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 10
    AWSDynamoDBCountKey = attribute.Key("aws.dynamodb.count")

    // AWSDynamoDBScannedCountKey is the attribute Key conforming to the
    // "aws.dynamodb.scanned_count" semantic conventions. It represents the
    // value of the `ScannedCount` response parameter.
    //
    // Type: int
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 50
    AWSDynamoDBScannedCountKey = attribute.Key("aws.dynamodb.scanned_count")
)

DynamoDB.UpdateTable

const (
    // AWSDynamoDBAttributeDefinitionsKey is the attribute Key conforming to
    // the "aws.dynamodb.attribute_definitions" semantic conventions. It
    // represents the JSON-serialized value of each item in the
    // `AttributeDefinitions` request field.
    //
    // Type: string[]
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '{ "AttributeName": "string", "AttributeType": "string" }'
    AWSDynamoDBAttributeDefinitionsKey = attribute.Key("aws.dynamodb.attribute_definitions")

    // AWSDynamoDBGlobalSecondaryIndexUpdatesKey is the attribute Key
    // conforming to the "aws.dynamodb.global_secondary_index_updates" semantic
    // conventions. It represents the JSON-serialized value of each item in the
    // the `GlobalSecondaryIndexUpdates` request field.
    //
    // Type: string[]
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '{ "Create": { "IndexName": "string", "KeySchema": [ {
    // "AttributeName": "string", "KeyType": "string" } ], "Projection": {
    // "NonKeyAttributes": [ "string" ], "ProjectionType": "string" },
    // "ProvisionedThroughput": { "ReadCapacityUnits": number,
    // "WriteCapacityUnits": number } }'
    AWSDynamoDBGlobalSecondaryIndexUpdatesKey = attribute.Key("aws.dynamodb.global_secondary_index_updates")
)

Semantic conventions to apply when instrumenting the GraphQL implementation. They map GraphQL operations to attributes on a Span.

const (
    // GraphqlOperationNameKey is the attribute Key conforming to the
    // "graphql.operation.name" semantic conventions. It represents the name of
    // the operation being executed.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'findBookByID'
    GraphqlOperationNameKey = attribute.Key("graphql.operation.name")

    // GraphqlOperationTypeKey is the attribute Key conforming to the
    // "graphql.operation.type" semantic conventions. It represents the type of
    // the operation being executed.
    //
    // Type: Enum
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'query', 'mutation', 'subscription'
    GraphqlOperationTypeKey = attribute.Key("graphql.operation.type")

    // GraphqlDocumentKey is the attribute Key conforming to the
    // "graphql.document" semantic conventions. It represents the GraphQL
    // document being executed.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'query findBookByID { bookByID(id: ?) { name } }'
    // Note: The value may be sanitized to exclude sensitive information.
    GraphqlDocumentKey = attribute.Key("graphql.document")
)

General attributes used in messaging systems.

const (
    // MessagingSystemKey is the attribute Key conforming to the
    // "messaging.system" semantic conventions. It represents a string
    // identifying the messaging system.
    //
    // Type: string
    // RequirementLevel: Required
    // Stability: stable
    // Examples: 'kafka', 'rabbitmq', 'rocketmq', 'activemq', 'AmazonSQS'
    MessagingSystemKey = attribute.Key("messaging.system")

    // MessagingOperationKey is the attribute Key conforming to the
    // "messaging.operation" semantic conventions. It represents a string
    // identifying the kind of messaging operation as defined in the [Operation
    // names](#operation-names) section above.
    //
    // Type: Enum
    // RequirementLevel: Required
    // Stability: stable
    // Note: If a custom value is used, it MUST be of low cardinality.
    MessagingOperationKey = attribute.Key("messaging.operation")

    // MessagingBatchMessageCountKey is the attribute Key conforming to the
    // "messaging.batch.message_count" semantic conventions. It represents the
    // number of messages sent, received, or processed in the scope of the
    // batching operation.
    //
    // Type: int
    // RequirementLevel: ConditionallyRequired (If the span describes an
    // operation on a batch of messages.)
    // Stability: stable
    // Examples: 0, 1, 2
    // Note: Instrumentations SHOULD NOT set `messaging.batch.message_count` on
    // spans that operate with a single message. When a messaging client
    // library supports both batch and single-message API for the same
    // operation, instrumentations SHOULD use `messaging.batch.message_count`
    // for batching APIs and SHOULD NOT use it for single-message APIs.
    MessagingBatchMessageCountKey = attribute.Key("messaging.batch.message_count")
)

Semantic conventions for remote procedure calls.

const (
    // RPCSystemKey is the attribute Key conforming to the "rpc.system"
    // semantic conventions. It represents a string identifying the remoting
    // system. See below for a list of well-known identifiers.
    //
    // Type: Enum
    // RequirementLevel: Required
    // Stability: stable
    RPCSystemKey = attribute.Key("rpc.system")

    // RPCServiceKey is the attribute Key conforming to the "rpc.service"
    // semantic conventions. It represents the full (logical) name of the
    // service being called, including its package name, if applicable.
    //
    // Type: string
    // RequirementLevel: Recommended
    // Stability: stable
    // Examples: 'myservice.EchoService'
    // Note: This is the logical name of the service from the RPC interface
    // perspective, which can be different from the name of any implementing
    // class. The `code.namespace` attribute may be used to store the latter
    // (despite the attribute name, it may include a class name; e.g., class
    // with method actually executing the call on the server side, RPC client
    // stub class on the client side).
    RPCServiceKey = attribute.Key("rpc.service")

    // RPCMethodKey is the attribute Key conforming to the "rpc.method"
    // semantic conventions. It represents the name of the (logical) method
    // being called, must be equal to the $method part in the span name.
    //
    // Type: string
    // RequirementLevel: Recommended
    // Stability: stable
    // Examples: 'exampleMethod'
    // Note: This is the logical name of the method from the RPC interface
    // perspective, which can be different from the name of any implementing
    // method/function. The `code.function` attribute may be used to store the
    // latter (e.g., method actually executing the call on the server side, RPC
    // client stub method on the client side).
    RPCMethodKey = attribute.Key("rpc.method")
)

Tech-specific attributes for [JSON RPC](https://www.jsonrpc.org/).

const (
    // RPCJsonrpcVersionKey is the attribute Key conforming to the
    // "rpc.jsonrpc.version" semantic conventions. It represents the protocol
    // version as in `jsonrpc` property of request/response. Since JSON-RPC 1.0
    // does not specify this, the value can be omitted.
    //
    // Type: string
    // RequirementLevel: ConditionallyRequired (If other than the default
    // version (`1.0`))
    // Stability: stable
    // Examples: '2.0', '1.0'
    RPCJsonrpcVersionKey = attribute.Key("rpc.jsonrpc.version")

    // RPCJsonrpcRequestIDKey is the attribute Key conforming to the
    // "rpc.jsonrpc.request_id" semantic conventions. It represents the `id`
    // property of request or response. Since protocol allows id to be int,
    // string, `null` or missing (for notifications), value is expected to be
    // cast to string for simplicity. Use empty string in case of `null` value.
    // Omit entirely if this is a notification.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: '10', 'request-7', ''
    RPCJsonrpcRequestIDKey = attribute.Key("rpc.jsonrpc.request_id")

    // RPCJsonrpcErrorCodeKey is the attribute Key conforming to the
    // "rpc.jsonrpc.error_code" semantic conventions. It represents the
    // `error.code` property of response if it is an error response.
    //
    // Type: int
    // RequirementLevel: ConditionallyRequired (If response is not successful.)
    // Stability: stable
    // Examples: -32700, 100
    RPCJsonrpcErrorCodeKey = attribute.Key("rpc.jsonrpc.error_code")

    // RPCJsonrpcErrorMessageKey is the attribute Key conforming to the
    // "rpc.jsonrpc.error_message" semantic conventions. It represents the
    // `error.message` property of response if it is an error response.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'Parse error', 'User already exists'
    RPCJsonrpcErrorMessageKey = attribute.Key("rpc.jsonrpc.error_message")
)

DynamoDB.Query

const (
    // AWSDynamoDBScanForwardKey is the attribute Key conforming to the
    // "aws.dynamodb.scan_forward" semantic conventions. It represents the
    // value of the `ScanIndexForward` request parameter.
    //
    // Type: boolean
    // RequirementLevel: Optional
    // Stability: stable
    AWSDynamoDBScanForwardKey = attribute.Key("aws.dynamodb.scan_forward")
)

Resources used by AWS Elastic Kubernetes Service (EKS).

const (
    // AWSEKSClusterARNKey is the attribute Key conforming to the
    // "aws.eks.cluster.arn" semantic conventions. It represents the ARN of an
    // EKS cluster.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'arn:aws:ecs:us-west-2:123456789123:cluster/my-cluster'
    AWSEKSClusterARNKey = attribute.Key("aws.eks.cluster.arn")
)

Span attributes used by AWS Lambda (in addition to general `faas` attributes).

const (
    // AWSLambdaInvokedARNKey is the attribute Key conforming to the
    // "aws.lambda.invoked_arn" semantic conventions. It represents the full
    // invoked ARN as provided on the `Context` passed to the function
    // (`Lambda-Runtime-Invoked-Function-ARN` header on the
    // `/runtime/invocation/next` applicable).
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'arn:aws:lambda:us-east-1:123456:function:myfunction:myalias'
    // Note: This may be different from `cloud.resource_id` if an alias is
    // involved.
    AWSLambdaInvokedARNKey = attribute.Key("aws.lambda.invoked_arn")
)

Connection-level attributes for Microsoft SQL Server

const (
    // DBMSSQLInstanceNameKey is the attribute Key conforming to the
    // "db.mssql.instance_name" semantic conventions. It represents the
    // Microsoft SQL Server [instance
    // name](https://docs.microsoft.com/en-us/sql/connect/jdbc/building-the-connection-url?view=sql-server-ver15)
    // connecting to. This name is used to determine the port of a named
    // instance.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'MSSQLSERVER'
    // Note: If setting a `db.mssql.instance_name`, `net.peer.port` is no
    // longer required (but still recommended if non-standard).
    DBMSSQLInstanceNameKey = attribute.Key("db.mssql.instance_name")
)

Call-level attributes for MongoDB

const (
    // DBMongoDBCollectionKey is the attribute Key conforming to the
    // "db.mongodb.collection" semantic conventions. It represents the
    // collection being accessed within the database stated in `db.name`.
    //
    // Type: string
    // RequirementLevel: Required
    // Stability: stable
    // Examples: 'customers', 'products'
    DBMongoDBCollectionKey = attribute.Key("db.mongodb.collection")
)

Call-level attributes for Redis

const (
    // DBRedisDBIndexKey is the attribute Key conforming to the
    // "db.redis.database_index" semantic conventions. It represents the index
    // of the database being accessed as used in the [`SELECT`
    // command](https://redis.io/commands/select), provided as an integer. To
    // be used instead of the generic `db.name` attribute.
    //
    // Type: int
    // RequirementLevel: ConditionallyRequired (If other than the default
    // database (`0`).)
    // Stability: stable
    // Examples: 0, 1, 15
    DBRedisDBIndexKey = attribute.Key("db.redis.database_index")
)

Call-level attributes for SQL databases

const (
    // DBSQLTableKey is the attribute Key conforming to the "db.sql.table"
    // semantic conventions. It represents the name of the primary table that
    // the operation is acting upon, including the database name (if
    // applicable).
    //
    // Type: string
    // RequirementLevel: Recommended
    // Stability: stable
    // Examples: 'public.users', 'customers'
    // Note: It is not recommended to attempt any client-side parsing of
    // `db.statement` just to get this property, but it should be set if it is
    // provided by the library being instrumented. If the operation is acting
    // upon an anonymous table, or more than one table, this value MUST NOT be
    // set.
    DBSQLTableKey = attribute.Key("db.sql.table")
)

The software deployment.

const (
    // DeploymentEnvironmentKey is the attribute Key conforming to the
    // "deployment.environment" semantic conventions. It represents the name of
    // the [deployment
    // environment](https://en.wikipedia.org/wiki/Deployment_environment) (aka
    // deployment tier).
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'staging', 'production'
    DeploymentEnvironmentKey = attribute.Key("deployment.environment")
)

The attributes used to report a single exception associated with a span.

const (
    // ExceptionEscapedKey is the attribute Key conforming to the
    // "exception.escaped" semantic conventions. It represents the sHOULD be
    // set to true if the exception event is recorded at a point where it is
    // known that the exception is escaping the scope of the span.
    //
    // Type: boolean
    // RequirementLevel: Optional
    // Stability: stable
    // Note: An exception is considered to have escaped (or left) the scope of
    // a span,
    // if that span is ended while the exception is still logically "in
    // flight".
    // This may be actually "in flight" in some languages (e.g. if the
    // exception
    // is passed to a Context manager's `__exit__` method in Python) but will
    // usually be caught at the point of recording the exception in most
    // languages.
    //
    // It is usually not possible to determine at the point where an exception
    // is thrown
    // whether it will escape the scope of a span.
    // However, it is trivial to know that an exception
    // will escape, if one checks for an active exception just before ending
    // the span,
    // as done in the [example above](#recording-an-exception).
    //
    // It follows that an exception may still escape the scope of the span
    // even if the `exception.escaped` attribute was not set or set to false,
    // since the event might have been recorded at a time where it was not
    // clear whether the exception will escape.
    ExceptionEscapedKey = attribute.Key("exception.escaped")
)

const (
    // ExceptionEventName is the name of the Span event representing an exception.
    ExceptionEventName = "exception"
)

Contains additional attributes for incoming FaaS spans.

const (
    // FaaSColdstartKey is the attribute Key conforming to the "faas.coldstart"
    // semantic conventions. It represents a boolean that is true if the
    // serverless function is executed for the first time (aka cold-start).
    //
    // Type: boolean
    // RequirementLevel: Optional
    // Stability: stable
    FaaSColdstartKey = attribute.Key("faas.coldstart")
)

A Kubernetes Cluster.

const (
    // K8SClusterNameKey is the attribute Key conforming to the
    // "k8s.cluster.name" semantic conventions. It represents the name of the
    // cluster.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'opentelemetry-cluster'
    K8SClusterNameKey = attribute.Key("k8s.cluster.name")
)

A Kubernetes Namespace.

const (
    // K8SNamespaceNameKey is the attribute Key conforming to the
    // "k8s.namespace.name" semantic conventions. It represents the name of the
    // namespace that the pod is running in.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'default'
    K8SNamespaceNameKey = attribute.Key("k8s.namespace.name")
)

Semantic convention for a consumer of messages received from a messaging system

const (
    // MessagingConsumerIDKey is the attribute Key conforming to the
    // "messaging.consumer.id" semantic conventions. It represents the
    // identifier for the consumer receiving a message. For Kafka, set it to
    // `{messaging.kafka.consumer.group} - {messaging.kafka.client_id}`, if
    // both are present, or only `messaging.kafka.consumer.group`. For brokers,
    // such as RabbitMQ and Artemis, set it to the `client_id` of the client
    // consuming the message.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'mygroup - client-6'
    MessagingConsumerIDKey = attribute.Key("messaging.consumer.id")
)

Attributes for RabbitMQ

const (
    // MessagingRabbitmqDestinationRoutingKeyKey is the attribute Key
    // conforming to the "messaging.rabbitmq.destination.routing_key" semantic
    // conventions. It represents the rabbitMQ message routing key.
    //
    // Type: string
    // RequirementLevel: ConditionallyRequired (If not empty.)
    // Stability: stable
    // Examples: 'myKey'
    MessagingRabbitmqDestinationRoutingKeyKey = attribute.Key("messaging.rabbitmq.destination.routing_key")
)

Semantic conventions for the OpenTracing Shim

const (
    // OpentracingRefTypeKey is the attribute Key conforming to the
    // "opentracing.ref_type" semantic conventions. It represents the
    // parent-child Reference type
    //
    // Type: Enum
    // RequirementLevel: Optional
    // Stability: stable
    // Note: The causal relationship between a child Span and a parent Span.
    OpentracingRefTypeKey = attribute.Key("opentracing.ref_type")
)

Operations that access some remote service.

const (
    // PeerServiceKey is the attribute Key conforming to the "peer.service"
    // semantic conventions. It represents the
    // [`service.name`](../../resource/semantic_conventions/README.md#service)
    // of the remote service. SHOULD be equal to the actual `service.name`
    // resource attribute of the remote service if any.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'AuthTokenCache'
    PeerServiceKey = attribute.Key("peer.service")
)

Tech-specific attributes for Connect RPC.

const (
    // RPCConnectRPCErrorCodeKey is the attribute Key conforming to the
    // "rpc.connect_rpc.error_code" semantic conventions. It represents the
    // [error codes](https://connect.build/docs/protocol/#error-codes) of the
    // Connect request. Error codes are always string values.
    //
    // Type: Enum
    // RequirementLevel: ConditionallyRequired (If response is not successful
    // and if error code available.)
    // Stability: stable
    RPCConnectRPCErrorCodeKey = attribute.Key("rpc.connect_rpc.error_code")
)

Tech-specific attributes for gRPC.

const (
    // RPCGRPCStatusCodeKey is the attribute Key conforming to the
    // "rpc.grpc.status_code" semantic conventions. It represents the [numeric
    // status
    // code](https://github.com/grpc/grpc/blob/v1.33.2/doc/statuscodes.md) of
    // the gRPC request.
    //
    // Type: Enum
    // RequirementLevel: Required
    // Stability: stable
    RPCGRPCStatusCodeKey = attribute.Key("rpc.grpc.status_code")
)

SchemaURL is the schema URL that matches the version of the semantic conventions that this package defines. Semconv packages starting from v1.4.0 must declare non-empty schema URL in the form https://opentelemetry.io/schemas/<version>

const SchemaURL = "https://opentelemetry.io/schemas/1.19.0"

Describes user-agent attributes.

const (
    // UserAgentOriginalKey is the attribute Key conforming to the
    // "user_agent.original" semantic conventions. It represents the value of
    // the [HTTP
    // User-Agent](https://www.rfc-editor.org/rfc/rfc9110.html#field.user-agent)
    // header sent by the client.
    //
    // Type: string
    // RequirementLevel: Optional
    // Stability: stable
    // Examples: 'CERN-LineMode/2.15 libwww/2.17b3'
    UserAgentOriginalKey = attribute.Key("user_agent.original")
)

Variables

var (
    // HTTP/1.0
    HTTPFlavorHTTP10 = HTTPFlavorKey.String("1.0")
    // HTTP/1.1
    HTTPFlavorHTTP11 = HTTPFlavorKey.String("1.1")
    // HTTP/2
    HTTPFlavorHTTP20 = HTTPFlavorKey.String("2.0")
    // HTTP/3
    HTTPFlavorHTTP30 = HTTPFlavorKey.String("3.0")
    // SPDY protocol
    HTTPFlavorSPDY = HTTPFlavorKey.String("SPDY")
    // QUIC protocol
    HTTPFlavorQUIC = HTTPFlavorKey.String("QUIC")
)

var (
    // Events from browser apps
    EventDomainBrowser = EventDomainKey.String("browser")
    // Events from mobile apps
    EventDomainDevice = EventDomainKey.String("device")
    // Events from Kubernetes
    EventDomainK8S = EventDomainKey.String("k8s")
)

var (
    // ip_tcp
    NetTransportTCP = NetTransportKey.String("ip_tcp")
    // ip_udp
    NetTransportUDP = NetTransportKey.String("ip_udp")
    // Named or anonymous pipe. See note below
    NetTransportPipe = NetTransportKey.String("pipe")
    // In-process communication
    NetTransportInProc = NetTransportKey.String("inproc")
    // Something else (non IP-based)
    NetTransportOther = NetTransportKey.String("other")
)

var (
    // IPv4 address
    NetSockFamilyInet = NetSockFamilyKey.String("inet")
    // IPv6 address
    NetSockFamilyInet6 = NetSockFamilyKey.String("inet6")
    // Unix domain socket path
    NetSockFamilyUnix = NetSockFamilyKey.String("unix")
)

var (
    // wifi
    NetHostConnectionTypeWifi = NetHostConnectionTypeKey.String("wifi")
    // wired
    NetHostConnectionTypeWired = NetHostConnectionTypeKey.String("wired")
    // cell
    NetHostConnectionTypeCell = NetHostConnectionTypeKey.String("cell")
    // unavailable
    NetHostConnectionTypeUnavailable = NetHostConnectionTypeKey.String("unavailable")
    // unknown
    NetHostConnectionTypeUnknown = NetHostConnectionTypeKey.String("unknown")
)

var (
    // GPRS
    NetHostConnectionSubtypeGprs = NetHostConnectionSubtypeKey.String("gprs")
    // EDGE
    NetHostConnectionSubtypeEdge = NetHostConnectionSubtypeKey.String("edge")
    // UMTS
    NetHostConnectionSubtypeUmts = NetHostConnectionSubtypeKey.String("umts")
    // CDMA
    NetHostConnectionSubtypeCdma = NetHostConnectionSubtypeKey.String("cdma")
    // EVDO Rel. 0
    NetHostConnectionSubtypeEvdo0 = NetHostConnectionSubtypeKey.String("evdo_0")
    // EVDO Rev. A
    NetHostConnectionSubtypeEvdoA = NetHostConnectionSubtypeKey.String("evdo_a")
    // CDMA2000 1XRTT
    NetHostConnectionSubtypeCdma20001xrtt = NetHostConnectionSubtypeKey.String("cdma2000_1xrtt")
    // HSDPA
    NetHostConnectionSubtypeHsdpa = NetHostConnectionSubtypeKey.String("hsdpa")
    // HSUPA
    NetHostConnectionSubtypeHsupa = NetHostConnectionSubtypeKey.String("hsupa")
    // HSPA
    NetHostConnectionSubtypeHspa = NetHostConnectionSubtypeKey.String("hspa")
    // IDEN
    NetHostConnectionSubtypeIden = NetHostConnectionSubtypeKey.String("iden")
    // EVDO Rev. B
    NetHostConnectionSubtypeEvdoB = NetHostConnectionSubtypeKey.String("evdo_b")
    // LTE
    NetHostConnectionSubtypeLte = NetHostConnectionSubtypeKey.String("lte")
    // EHRPD
    NetHostConnectionSubtypeEhrpd = NetHostConnectionSubtypeKey.String("ehrpd")
    // HSPAP
    NetHostConnectionSubtypeHspap = NetHostConnectionSubtypeKey.String("hspap")
    // GSM
    NetHostConnectionSubtypeGsm = NetHostConnectionSubtypeKey.String("gsm")
    // TD-SCDMA
    NetHostConnectionSubtypeTdScdma = NetHostConnectionSubtypeKey.String("td_scdma")
    // IWLAN
    NetHostConnectionSubtypeIwlan = NetHostConnectionSubtypeKey.String("iwlan")
    // 5G NR (New Radio)
    NetHostConnectionSubtypeNr = NetHostConnectionSubtypeKey.String("nr")
    // 5G NRNSA (New Radio Non-Standalone)
    NetHostConnectionSubtypeNrnsa = NetHostConnectionSubtypeKey.String("nrnsa")
    // LTE CA
    NetHostConnectionSubtypeLteCa = NetHostConnectionSubtypeKey.String("lte_ca")
)

var (
    // A message sent to a queue
    MessagingDestinationKindQueue = MessagingDestinationKindKey.String("queue")
    // A message sent to a topic
    MessagingDestinationKindTopic = MessagingDestinationKindKey.String("topic")
)

var (
    // A message received from a queue
    MessagingSourceKindQueue = MessagingSourceKindKey.String("queue")
    // A message received from a topic
    MessagingSourceKindTopic = MessagingSourceKindKey.String("topic")
)

var (
    // Normal message
    MessagingRocketmqMessageTypeNormal = MessagingRocketmqMessageTypeKey.String("normal")
    // FIFO message
    MessagingRocketmqMessageTypeFifo = MessagingRocketmqMessageTypeKey.String("fifo")
    // Delay message
    MessagingRocketmqMessageTypeDelay = MessagingRocketmqMessageTypeKey.String("delay")
    // Transaction message
    MessagingRocketmqMessageTypeTransaction = MessagingRocketmqMessageTypeKey.String("transaction")
)

var (
    // Clustering consumption model
    MessagingRocketmqConsumptionModelClustering = MessagingRocketmqConsumptionModelKey.String("clustering")
    // Broadcasting consumption model
    MessagingRocketmqConsumptionModelBroadcasting = MessagingRocketmqConsumptionModelKey.String("broadcasting")
)

var (
    // sent
    MessageTypeSent = MessageTypeKey.String("SENT")
    // received
    MessageTypeReceived = MessageTypeKey.String("RECEIVED")
)

HTTP scheme attributes.

var (
    HTTPSchemeHTTP  = HTTPSchemeKey.String("http")
    HTTPSchemeHTTPS = HTTPSchemeKey.String("https")
)

var (
    // Alibaba Cloud
    CloudProviderAlibabaCloud = CloudProviderKey.String("alibaba_cloud")
    // Amazon Web Services
    CloudProviderAWS = CloudProviderKey.String("aws")
    // Microsoft Azure
    CloudProviderAzure = CloudProviderKey.String("azure")
    // Google Cloud Platform
    CloudProviderGCP = CloudProviderKey.String("gcp")
    // Heroku Platform as a Service
    CloudProviderHeroku = CloudProviderKey.String("heroku")
    // IBM Cloud
    CloudProviderIbmCloud = CloudProviderKey.String("ibm_cloud")
    // Tencent Cloud
    CloudProviderTencentCloud = CloudProviderKey.String("tencent_cloud")
)

var (
    // Alibaba Cloud Elastic Compute Service
    CloudPlatformAlibabaCloudECS = CloudPlatformKey.String("alibaba_cloud_ecs")
    // Alibaba Cloud Function Compute
    CloudPlatformAlibabaCloudFc = CloudPlatformKey.String("alibaba_cloud_fc")
    // Red Hat OpenShift on Alibaba Cloud
    CloudPlatformAlibabaCloudOpenshift = CloudPlatformKey.String("alibaba_cloud_openshift")
    // AWS Elastic Compute Cloud
    CloudPlatformAWSEC2 = CloudPlatformKey.String("aws_ec2")
    // AWS Elastic Container Service
    CloudPlatformAWSECS = CloudPlatformKey.String("aws_ecs")
    // AWS Elastic Kubernetes Service
    CloudPlatformAWSEKS = CloudPlatformKey.String("aws_eks")
    // AWS Lambda
    CloudPlatformAWSLambda = CloudPlatformKey.String("aws_lambda")
    // AWS Elastic Beanstalk
    CloudPlatformAWSElasticBeanstalk = CloudPlatformKey.String("aws_elastic_beanstalk")
    // AWS App Runner
    CloudPlatformAWSAppRunner = CloudPlatformKey.String("aws_app_runner")
    // Red Hat OpenShift on AWS (ROSA)
    CloudPlatformAWSOpenshift = CloudPlatformKey.String("aws_openshift")
    // Azure Virtual Machines
    CloudPlatformAzureVM = CloudPlatformKey.String("azure_vm")
    // Azure Container Instances
    CloudPlatformAzureContainerInstances = CloudPlatformKey.String("azure_container_instances")
    // Azure Kubernetes Service
    CloudPlatformAzureAKS = CloudPlatformKey.String("azure_aks")
    // Azure Functions
    CloudPlatformAzureFunctions = CloudPlatformKey.String("azure_functions")
    // Azure App Service
    CloudPlatformAzureAppService = CloudPlatformKey.String("azure_app_service")
    // Azure Red Hat OpenShift
    CloudPlatformAzureOpenshift = CloudPlatformKey.String("azure_openshift")
    // Google Cloud Compute Engine (GCE)
    CloudPlatformGCPComputeEngine = CloudPlatformKey.String("gcp_compute_engine")
    // Google Cloud Run
    CloudPlatformGCPCloudRun = CloudPlatformKey.String("gcp_cloud_run")
    // Google Cloud Kubernetes Engine (GKE)
    CloudPlatformGCPKubernetesEngine = CloudPlatformKey.String("gcp_kubernetes_engine")
    // Google Cloud Functions (GCF)
    CloudPlatformGCPCloudFunctions = CloudPlatformKey.String("gcp_cloud_functions")
    // Google Cloud App Engine (GAE)
    CloudPlatformGCPAppEngine = CloudPlatformKey.String("gcp_app_engine")
    // Red Hat OpenShift on Google Cloud
    CloudPlatformGCPOpenshift = CloudPlatformKey.String("gcp_openshift")
    // Red Hat OpenShift on IBM Cloud
    CloudPlatformIbmCloudOpenshift = CloudPlatformKey.String("ibm_cloud_openshift")
    // Tencent Cloud Cloud Virtual Machine (CVM)
    CloudPlatformTencentCloudCvm = CloudPlatformKey.String("tencent_cloud_cvm")
    // Tencent Cloud Elastic Kubernetes Service (EKS)
    CloudPlatformTencentCloudEKS = CloudPlatformKey.String("tencent_cloud_eks")
    // Tencent Cloud Serverless Cloud Function (SCF)
    CloudPlatformTencentCloudScf = CloudPlatformKey.String("tencent_cloud_scf")
)

var (
    // ec2
    AWSECSLaunchtypeEC2 = AWSECSLaunchtypeKey.String("ec2")
    // fargate
    AWSECSLaunchtypeFargate = AWSECSLaunchtypeKey.String("fargate")
)

var (
    // AMD64
    HostArchAMD64 = HostArchKey.String("amd64")
    // ARM32
    HostArchARM32 = HostArchKey.String("arm32")
    // ARM64
    HostArchARM64 = HostArchKey.String("arm64")
    // Itanium
    HostArchIA64 = HostArchKey.String("ia64")
    // 32-bit PowerPC
    HostArchPPC32 = HostArchKey.String("ppc32")
    // 64-bit PowerPC
    HostArchPPC64 = HostArchKey.String("ppc64")
    // IBM z/Architecture
    HostArchS390x = HostArchKey.String("s390x")
    // 32-bit x86
    HostArchX86 = HostArchKey.String("x86")
)

var (
    // Microsoft Windows
    OSTypeWindows = OSTypeKey.String("windows")
    // Linux
    OSTypeLinux = OSTypeKey.String("linux")
    // Apple Darwin
    OSTypeDarwin = OSTypeKey.String("darwin")
    // FreeBSD
    OSTypeFreeBSD = OSTypeKey.String("freebsd")
    // NetBSD
    OSTypeNetBSD = OSTypeKey.String("netbsd")
    // OpenBSD
    OSTypeOpenBSD = OSTypeKey.String("openbsd")
    // DragonFly BSD
    OSTypeDragonflyBSD = OSTypeKey.String("dragonflybsd")
    // HP-UX (Hewlett Packard Unix)
    OSTypeHPUX = OSTypeKey.String("hpux")
    // AIX (Advanced Interactive eXecutive)
    OSTypeAIX = OSTypeKey.String("aix")
    // SunOS, Oracle Solaris
    OSTypeSolaris = OSTypeKey.String("solaris")
    // IBM z/OS
    OSTypeZOS = OSTypeKey.String("z_os")
)

var (
    // cpp
    TelemetrySDKLanguageCPP = TelemetrySDKLanguageKey.String("cpp")
    // dotnet
    TelemetrySDKLanguageDotnet = TelemetrySDKLanguageKey.String("dotnet")
    // erlang
    TelemetrySDKLanguageErlang = TelemetrySDKLanguageKey.String("erlang")
    // go
    TelemetrySDKLanguageGo = TelemetrySDKLanguageKey.String("go")
    // java
    TelemetrySDKLanguageJava = TelemetrySDKLanguageKey.String("java")
    // nodejs
    TelemetrySDKLanguageNodejs = TelemetrySDKLanguageKey.String("nodejs")
    // php
    TelemetrySDKLanguagePHP = TelemetrySDKLanguageKey.String("php")
    // python
    TelemetrySDKLanguagePython = TelemetrySDKLanguageKey.String("python")
    // ruby
    TelemetrySDKLanguageRuby = TelemetrySDKLanguageKey.String("ruby")
    // webjs
    TelemetrySDKLanguageWebjs = TelemetrySDKLanguageKey.String("webjs")
    // swift
    TelemetrySDKLanguageSwift = TelemetrySDKLanguageKey.String("swift")
)

var (
    // The parent Span depends on the child Span in some capacity
    OpentracingRefTypeChildOf = OpentracingRefTypeKey.String("child_of")
    // The parent Span does not depend in any way on the result of the child Span
    OpentracingRefTypeFollowsFrom = OpentracingRefTypeKey.String("follows_from")
)

var (
    // Some other SQL database. Fallback only. See notes
    DBSystemOtherSQL = DBSystemKey.String("other_sql")
    // Microsoft SQL Server
    DBSystemMSSQL = DBSystemKey.String("mssql")
    // Microsoft SQL Server Compact
    DBSystemMssqlcompact = DBSystemKey.String("mssqlcompact")
    // MySQL
    DBSystemMySQL = DBSystemKey.String("mysql")
    // Oracle Database
    DBSystemOracle = DBSystemKey.String("oracle")
    // IBM DB2
    DBSystemDB2 = DBSystemKey.String("db2")
    // PostgreSQL
    DBSystemPostgreSQL = DBSystemKey.String("postgresql")
    // Amazon Redshift
    DBSystemRedshift = DBSystemKey.String("redshift")
    // Apache Hive
    DBSystemHive = DBSystemKey.String("hive")
    // Cloudscape
    DBSystemCloudscape = DBSystemKey.String("cloudscape")
    // HyperSQL DataBase
    DBSystemHSQLDB = DBSystemKey.String("hsqldb")
    // Progress Database
    DBSystemProgress = DBSystemKey.String("progress")
    // SAP MaxDB
    DBSystemMaxDB = DBSystemKey.String("maxdb")
    // SAP HANA
    DBSystemHanaDB = DBSystemKey.String("hanadb")
    // Ingres
    DBSystemIngres = DBSystemKey.String("ingres")
    // FirstSQL
    DBSystemFirstSQL = DBSystemKey.String("firstsql")
    // EnterpriseDB
    DBSystemEDB = DBSystemKey.String("edb")
    // InterSystems Caché
    DBSystemCache = DBSystemKey.String("cache")
    // Adabas (Adaptable Database System)
    DBSystemAdabas = DBSystemKey.String("adabas")
    // Firebird
    DBSystemFirebird = DBSystemKey.String("firebird")
    // Apache Derby
    DBSystemDerby = DBSystemKey.String("derby")
    // FileMaker
    DBSystemFilemaker = DBSystemKey.String("filemaker")
    // Informix
    DBSystemInformix = DBSystemKey.String("informix")
    // InstantDB
    DBSystemInstantDB = DBSystemKey.String("instantdb")
    // InterBase
    DBSystemInterbase = DBSystemKey.String("interbase")
    // MariaDB
    DBSystemMariaDB = DBSystemKey.String("mariadb")
    // Netezza
    DBSystemNetezza = DBSystemKey.String("netezza")
    // Pervasive PSQL
    DBSystemPervasive = DBSystemKey.String("pervasive")
    // PointBase
    DBSystemPointbase = DBSystemKey.String("pointbase")
    // SQLite
    DBSystemSqlite = DBSystemKey.String("sqlite")
    // Sybase
    DBSystemSybase = DBSystemKey.String("sybase")
    // Teradata
    DBSystemTeradata = DBSystemKey.String("teradata")
    // Vertica
    DBSystemVertica = DBSystemKey.String("vertica")
    // H2
    DBSystemH2 = DBSystemKey.String("h2")
    // ColdFusion IMQ
    DBSystemColdfusion = DBSystemKey.String("coldfusion")
    // Apache Cassandra
    DBSystemCassandra = DBSystemKey.String("cassandra")
    // Apache HBase
    DBSystemHBase = DBSystemKey.String("hbase")
    // MongoDB
    DBSystemMongoDB = DBSystemKey.String("mongodb")
    // Redis
    DBSystemRedis = DBSystemKey.String("redis")
    // Couchbase
    DBSystemCouchbase = DBSystemKey.String("couchbase")
    // CouchDB
    DBSystemCouchDB = DBSystemKey.String("couchdb")
    // Microsoft Azure Cosmos DB
    DBSystemCosmosDB = DBSystemKey.String("cosmosdb")
    // Amazon DynamoDB
    DBSystemDynamoDB = DBSystemKey.String("dynamodb")
    // Neo4j
    DBSystemNeo4j = DBSystemKey.String("neo4j")
    // Apache Geode
    DBSystemGeode = DBSystemKey.String("geode")
    // Elasticsearch
    DBSystemElasticsearch = DBSystemKey.String("elasticsearch")
    // Memcached
    DBSystemMemcached = DBSystemKey.String("memcached")
    // CockroachDB
    DBSystemCockroachdb = DBSystemKey.String("cockroachdb")
    // OpenSearch
    DBSystemOpensearch = DBSystemKey.String("opensearch")
    // ClickHouse
    DBSystemClickhouse = DBSystemKey.String("clickhouse")
    // Cloud Spanner
    DBSystemSpanner = DBSystemKey.String("spanner")
)

var (
    // all
    DBCassandraConsistencyLevelAll = DBCassandraConsistencyLevelKey.String("all")
    // each_quorum
    DBCassandraConsistencyLevelEachQuorum = DBCassandraConsistencyLevelKey.String("each_quorum")
    // quorum
    DBCassandraConsistencyLevelQuorum = DBCassandraConsistencyLevelKey.String("quorum")
    // local_quorum
    DBCassandraConsistencyLevelLocalQuorum = DBCassandraConsistencyLevelKey.String("local_quorum")
    // one
    DBCassandraConsistencyLevelOne = DBCassandraConsistencyLevelKey.String("one")
    // two
    DBCassandraConsistencyLevelTwo = DBCassandraConsistencyLevelKey.String("two")
    // three
    DBCassandraConsistencyLevelThree = DBCassandraConsistencyLevelKey.String("three")
    // local_one
    DBCassandraConsistencyLevelLocalOne = DBCassandraConsistencyLevelKey.String("local_one")
    // any
    DBCassandraConsistencyLevelAny = DBCassandraConsistencyLevelKey.String("any")
    // serial
    DBCassandraConsistencyLevelSerial = DBCassandraConsistencyLevelKey.String("serial")
    // local_serial
    DBCassandraConsistencyLevelLocalSerial = DBCassandraConsistencyLevelKey.String("local_serial")
)

var (
    // The operation has been validated by an Application developer or Operator to have completed successfully
    OTelStatusCodeOk = OTelStatusCodeKey.String("OK")
    // The operation contains an error
    OTelStatusCodeError = OTelStatusCodeKey.String("ERROR")
)

var (
    // A response to some data source operation such as a database or filesystem read/write
    FaaSTriggerDatasource = FaaSTriggerKey.String("datasource")
    // To provide an answer to an inbound HTTP request
    FaaSTriggerHTTP = FaaSTriggerKey.String("http")
    // A function is set to be executed when messages are sent to a messaging system
    FaaSTriggerPubsub = FaaSTriggerKey.String("pubsub")
    // A function is scheduled to be executed regularly
    FaaSTriggerTimer = FaaSTriggerKey.String("timer")
    // If none of the others apply
    FaaSTriggerOther = FaaSTriggerKey.String("other")
)

var (
    // When a new object is created
    FaaSDocumentOperationInsert = FaaSDocumentOperationKey.String("insert")
    // When an object is modified
    FaaSDocumentOperationEdit = FaaSDocumentOperationKey.String("edit")
    // When an object is deleted
    FaaSDocumentOperationDelete = FaaSDocumentOperationKey.String("delete")
)

var (
    // Alibaba Cloud
    FaaSInvokedProviderAlibabaCloud = FaaSInvokedProviderKey.String("alibaba_cloud")
    // Amazon Web Services
    FaaSInvokedProviderAWS = FaaSInvokedProviderKey.String("aws")
    // Microsoft Azure
    FaaSInvokedProviderAzure = FaaSInvokedProviderKey.String("azure")
    // Google Cloud Platform
    FaaSInvokedProviderGCP = FaaSInvokedProviderKey.String("gcp")
    // Tencent Cloud
    FaaSInvokedProviderTencentCloud = FaaSInvokedProviderKey.String("tencent_cloud")
)

var (
    // GraphQL query
    GraphqlOperationTypeQuery = GraphqlOperationTypeKey.String("query")
    // GraphQL mutation
    GraphqlOperationTypeMutation = GraphqlOperationTypeKey.String("mutation")
    // GraphQL subscription
    GraphqlOperationTypeSubscription = GraphqlOperationTypeKey.String("subscription")
)

var (
    // publish
    MessagingOperationPublish = MessagingOperationKey.String("publish")
    // receive
    MessagingOperationReceive = MessagingOperationKey.String("receive")
    // process
    MessagingOperationProcess = MessagingOperationKey.String("process")
)

var (
    // gRPC
    RPCSystemGRPC = RPCSystemKey.String("grpc")
    // Java RMI
    RPCSystemJavaRmi = RPCSystemKey.String("java_rmi")
    // .NET WCF
    RPCSystemDotnetWcf = RPCSystemKey.String("dotnet_wcf")
    // Apache Dubbo
    RPCSystemApacheDubbo = RPCSystemKey.String("apache_dubbo")
    // Connect RPC
    RPCSystemConnectRPC = RPCSystemKey.String("connect_rpc")
)

var (
    // OK
    RPCGRPCStatusCodeOk = RPCGRPCStatusCodeKey.Int(0)
    // CANCELLED
    RPCGRPCStatusCodeCancelled = RPCGRPCStatusCodeKey.Int(1)
    // UNKNOWN
    RPCGRPCStatusCodeUnknown = RPCGRPCStatusCodeKey.Int(2)
    // INVALID_ARGUMENT
    RPCGRPCStatusCodeInvalidArgument = RPCGRPCStatusCodeKey.Int(3)
    // DEADLINE_EXCEEDED
    RPCGRPCStatusCodeDeadlineExceeded = RPCGRPCStatusCodeKey.Int(4)
    // NOT_FOUND
    RPCGRPCStatusCodeNotFound = RPCGRPCStatusCodeKey.Int(5)
    // ALREADY_EXISTS
    RPCGRPCStatusCodeAlreadyExists = RPCGRPCStatusCodeKey.Int(6)
    // PERMISSION_DENIED
    RPCGRPCStatusCodePermissionDenied = RPCGRPCStatusCodeKey.Int(7)
    // RESOURCE_EXHAUSTED
    RPCGRPCStatusCodeResourceExhausted = RPCGRPCStatusCodeKey.Int(8)
    // FAILED_PRECONDITION
    RPCGRPCStatusCodeFailedPrecondition = RPCGRPCStatusCodeKey.Int(9)
    // ABORTED
    RPCGRPCStatusCodeAborted = RPCGRPCStatusCodeKey.Int(10)
    // OUT_OF_RANGE
    RPCGRPCStatusCodeOutOfRange = RPCGRPCStatusCodeKey.Int(11)
    // UNIMPLEMENTED
    RPCGRPCStatusCodeUnimplemented = RPCGRPCStatusCodeKey.Int(12)
    // INTERNAL
    RPCGRPCStatusCodeInternal = RPCGRPCStatusCodeKey.Int(13)
    // UNAVAILABLE
    RPCGRPCStatusCodeUnavailable = RPCGRPCStatusCodeKey.Int(14)
    // DATA_LOSS
    RPCGRPCStatusCodeDataLoss = RPCGRPCStatusCodeKey.Int(15)
    // UNAUTHENTICATED
    RPCGRPCStatusCodeUnauthenticated = RPCGRPCStatusCodeKey.Int(16)
)

var (
    // cancelled
    RPCConnectRPCErrorCodeCancelled = RPCConnectRPCErrorCodeKey.String("cancelled")
    // unknown
    RPCConnectRPCErrorCodeUnknown = RPCConnectRPCErrorCodeKey.String("unknown")
    // invalid_argument
    RPCConnectRPCErrorCodeInvalidArgument = RPCConnectRPCErrorCodeKey.String("invalid_argument")
    // deadline_exceeded
    RPCConnectRPCErrorCodeDeadlineExceeded = RPCConnectRPCErrorCodeKey.String("deadline_exceeded")
    // not_found
    RPCConnectRPCErrorCodeNotFound = RPCConnectRPCErrorCodeKey.String("not_found")
    // already_exists
    RPCConnectRPCErrorCodeAlreadyExists = RPCConnectRPCErrorCodeKey.String("already_exists")
    // permission_denied
    RPCConnectRPCErrorCodePermissionDenied = RPCConnectRPCErrorCodeKey.String("permission_denied")
    // resource_exhausted
    RPCConnectRPCErrorCodeResourceExhausted = RPCConnectRPCErrorCodeKey.String("resource_exhausted")
    // failed_precondition
    RPCConnectRPCErrorCodeFailedPrecondition = RPCConnectRPCErrorCodeKey.String("failed_precondition")
    // aborted
    RPCConnectRPCErrorCodeAborted = RPCConnectRPCErrorCodeKey.String("aborted")
    // out_of_range
    RPCConnectRPCErrorCodeOutOfRange = RPCConnectRPCErrorCodeKey.String("out_of_range")
    // unimplemented
    RPCConnectRPCErrorCodeUnimplemented = RPCConnectRPCErrorCodeKey.String("unimplemented")
    // internal
    RPCConnectRPCErrorCodeInternal = RPCConnectRPCErrorCodeKey.String("internal")
    // unavailable
    RPCConnectRPCErrorCodeUnavailable = RPCConnectRPCErrorCodeKey.String("unavailable")
    // data_loss
    RPCConnectRPCErrorCodeDataLoss = RPCConnectRPCErrorCodeKey.String("data_loss")
    // unauthenticated
    RPCConnectRPCErrorCodeUnauthenticated = RPCConnectRPCErrorCodeKey.String("unauthenticated")
)

func AWSDynamoDBAttributeDefinitions ¶

func AWSDynamoDBAttributeDefinitions(val ...string) attribute.KeyValue

AWSDynamoDBAttributeDefinitions returns an attribute KeyValue conforming to the "aws.dynamodb.attribute_definitions" semantic conventions. It represents the JSON-serialized value of each item in the `AttributeDefinitions` request field.

func AWSDynamoDBAttributesToGet ¶

func AWSDynamoDBAttributesToGet(val ...string) attribute.KeyValue

AWSDynamoDBAttributesToGet returns an attribute KeyValue conforming to the "aws.dynamodb.attributes_to_get" semantic conventions. It represents the value of the `AttributesToGet` request parameter.

func AWSDynamoDBConsistentRead ¶

func AWSDynamoDBConsistentRead(val bool) attribute.KeyValue

AWSDynamoDBConsistentRead returns an attribute KeyValue conforming to the "aws.dynamodb.consistent_read" semantic conventions. It represents the value of the `ConsistentRead` request parameter.

func AWSDynamoDBConsumedCapacity ¶

func AWSDynamoDBConsumedCapacity(val ...string) attribute.KeyValue

AWSDynamoDBConsumedCapacity returns an attribute KeyValue conforming to the "aws.dynamodb.consumed_capacity" semantic conventions. It represents the JSON-serialized value of each item in the `ConsumedCapacity` response field.

func AWSDynamoDBCount ¶

func AWSDynamoDBCount(val int) attribute.KeyValue

AWSDynamoDBCount returns an attribute KeyValue conforming to the "aws.dynamodb.count" semantic conventions. It represents the value of the `Count` response parameter.

func AWSDynamoDBExclusiveStartTable ¶

func AWSDynamoDBExclusiveStartTable(val string) attribute.KeyValue

AWSDynamoDBExclusiveStartTable returns an attribute KeyValue conforming to the "aws.dynamodb.exclusive_start_table" semantic conventions. It represents the value of the `ExclusiveStartTableName` request parameter.

func AWSDynamoDBGlobalSecondaryIndexUpdates ¶

func AWSDynamoDBGlobalSecondaryIndexUpdates(val ...string) attribute.KeyValue

AWSDynamoDBGlobalSecondaryIndexUpdates returns an attribute KeyValue conforming to the "aws.dynamodb.global_secondary_index_updates" semantic conventions. It represents the JSON-serialized value of each item in the the `GlobalSecondaryIndexUpdates` request field.

func AWSDynamoDBGlobalSecondaryIndexes ¶

func AWSDynamoDBGlobalSecondaryIndexes(val ...string) attribute.KeyValue

AWSDynamoDBGlobalSecondaryIndexes returns an attribute KeyValue conforming to the "aws.dynamodb.global_secondary_indexes" semantic conventions. It represents the JSON-serialized value of each item of the `GlobalSecondaryIndexes` request field

func AWSDynamoDBIndexName ¶

func AWSDynamoDBIndexName(val string) attribute.KeyValue

AWSDynamoDBIndexName returns an attribute KeyValue conforming to the "aws.dynamodb.index_name" semantic conventions. It represents the value of the `IndexName` request parameter.

func AWSDynamoDBItemCollectionMetrics ¶

func AWSDynamoDBItemCollectionMetrics(val string) attribute.KeyValue

AWSDynamoDBItemCollectionMetrics returns an attribute KeyValue conforming to the "aws.dynamodb.item_collection_metrics" semantic conventions. It represents the JSON-serialized value of the `ItemCollectionMetrics` response field.

func AWSDynamoDBLimit ¶

func AWSDynamoDBLimit(val int) attribute.KeyValue

AWSDynamoDBLimit returns an attribute KeyValue conforming to the "aws.dynamodb.limit" semantic conventions. It represents the value of the `Limit` request parameter.

func AWSDynamoDBLocalSecondaryIndexes ¶

func AWSDynamoDBLocalSecondaryIndexes(val ...string) attribute.KeyValue

AWSDynamoDBLocalSecondaryIndexes returns an attribute KeyValue conforming to the "aws.dynamodb.local_secondary_indexes" semantic conventions. It represents the JSON-serialized value of each item of the `LocalSecondaryIndexes` request field.

func AWSDynamoDBProjection ¶

func AWSDynamoDBProjection(val string) attribute.KeyValue

AWSDynamoDBProjection returns an attribute KeyValue conforming to the "aws.dynamodb.projection" semantic conventions. It represents the value of the `ProjectionExpression` request parameter.

func AWSDynamoDBProvisionedReadCapacity ¶

func AWSDynamoDBProvisionedReadCapacity(val float64) attribute.KeyValue

AWSDynamoDBProvisionedReadCapacity returns an attribute KeyValue conforming to the "aws.dynamodb.provisioned_read_capacity" semantic conventions. It represents the value of the `ProvisionedThroughput.ReadCapacityUnits` request parameter.

func AWSDynamoDBProvisionedWriteCapacity ¶

func AWSDynamoDBProvisionedWriteCapacity(val float64) attribute.KeyValue

AWSDynamoDBProvisionedWriteCapacity returns an attribute KeyValue conforming to the "aws.dynamodb.provisioned_write_capacity" semantic conventions. It represents the value of the `ProvisionedThroughput.WriteCapacityUnits` request parameter.

func AWSDynamoDBScanForward ¶

func AWSDynamoDBScanForward(val bool) attribute.KeyValue

AWSDynamoDBScanForward returns an attribute KeyValue conforming to the "aws.dynamodb.scan_forward" semantic conventions. It represents the value of the `ScanIndexForward` request parameter.

func AWSDynamoDBScannedCount ¶

func AWSDynamoDBScannedCount(val int) attribute.KeyValue

AWSDynamoDBScannedCount returns an attribute KeyValue conforming to the "aws.dynamodb.scanned_count" semantic conventions. It represents the value of the `ScannedCount` response parameter.

func AWSDynamoDBSegment ¶

func AWSDynamoDBSegment(val int) attribute.KeyValue

AWSDynamoDBSegment returns an attribute KeyValue conforming to the "aws.dynamodb.segment" semantic conventions. It represents the value of the `Segment` request parameter.

func AWSDynamoDBSelect ¶

func AWSDynamoDBSelect(val string) attribute.KeyValue

AWSDynamoDBSelect returns an attribute KeyValue conforming to the "aws.dynamodb.select" semantic conventions. It represents the value of the `Select` request parameter.

func AWSDynamoDBTableCount ¶

func AWSDynamoDBTableCount(val int) attribute.KeyValue

AWSDynamoDBTableCount returns an attribute KeyValue conforming to the "aws.dynamodb.table_count" semantic conventions. It represents the the number of items in the `TableNames` response parameter.

func AWSDynamoDBTableNames ¶

func AWSDynamoDBTableNames(val ...string) attribute.KeyValue

AWSDynamoDBTableNames returns an attribute KeyValue conforming to the "aws.dynamodb.table_names" semantic conventions. It represents the keys in the `RequestItems` object field.

func AWSDynamoDBTotalSegments ¶

func AWSDynamoDBTotalSegments(val int) attribute.KeyValue

AWSDynamoDBTotalSegments returns an attribute KeyValue conforming to the "aws.dynamodb.total_segments" semantic conventions. It represents the value of the `TotalSegments` request parameter.

func AWSECSClusterARN ¶

func AWSECSClusterARN(val string) attribute.KeyValue

AWSECSClusterARN returns an attribute KeyValue conforming to the "aws.ecs.cluster.arn" semantic conventions. It represents the ARN of an [ECS cluster](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/clusters.html).

func AWSECSContainerARN ¶

func AWSECSContainerARN(val string) attribute.KeyValue

AWSECSContainerARN returns an attribute KeyValue conforming to the "aws.ecs.container.arn" semantic conventions. It represents the Amazon Resource Name (ARN) of an [ECS container instance](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_instances.html).

func AWSECSTaskARN ¶

func AWSECSTaskARN(val string) attribute.KeyValue

AWSECSTaskARN returns an attribute KeyValue conforming to the "aws.ecs.task.arn" semantic conventions. It represents the ARN of an [ECS task definition](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definitions.html).

func AWSECSTaskFamily ¶

func AWSECSTaskFamily(val string) attribute.KeyValue

AWSECSTaskFamily returns an attribute KeyValue conforming to the "aws.ecs.task.family" semantic conventions. It represents the task definition family this task definition is a member of.

func AWSECSTaskRevision ¶

func AWSECSTaskRevision(val string) attribute.KeyValue

AWSECSTaskRevision returns an attribute KeyValue conforming to the "aws.ecs.task.revision" semantic conventions. It represents the revision for this task definition.

func AWSEKSClusterARN ¶

func AWSEKSClusterARN(val string) attribute.KeyValue

AWSEKSClusterARN returns an attribute KeyValue conforming to the "aws.eks.cluster.arn" semantic conventions. It represents the ARN of an EKS cluster.

func AWSLambdaInvokedARN ¶

func AWSLambdaInvokedARN(val string) attribute.KeyValue

AWSLambdaInvokedARN returns an attribute KeyValue conforming to the "aws.lambda.invoked_arn" semantic conventions. It represents the full invoked ARN as provided on the `Context` passed to the function (`Lambda-Runtime-Invoked-Function-ARN` header on the `/runtime/invocation/next` applicable).

func AWSLogGroupARNs ¶

func AWSLogGroupARNs(val ...string) attribute.KeyValue

AWSLogGroupARNs returns an attribute KeyValue conforming to the "aws.log.group.arns" semantic conventions. It represents the Amazon Resource Name(s) (ARN) of the AWS log group(s).

func AWSLogGroupNames ¶

func AWSLogGroupNames(val ...string) attribute.KeyValue

AWSLogGroupNames returns an attribute KeyValue conforming to the "aws.log.group.names" semantic conventions. It represents the name(s) of the AWS log group(s) an application is writing to.

func AWSLogStreamARNs ¶

func AWSLogStreamARNs(val ...string) attribute.KeyValue

AWSLogStreamARNs returns an attribute KeyValue conforming to the "aws.log.stream.arns" semantic conventions. It represents the ARN(s) of the AWS log stream(s).

func AWSLogStreamNames ¶

func AWSLogStreamNames(val ...string) attribute.KeyValue

AWSLogStreamNames returns an attribute KeyValue conforming to the "aws.log.stream.names" semantic conventions. It represents the name(s) of the AWS log stream(s) an application is writing to.

func BrowserBrands ¶

func BrowserBrands(val ...string) attribute.KeyValue

BrowserBrands returns an attribute KeyValue conforming to the "browser.brands" semantic conventions. It represents the array of brand name and version separated by a space

func BrowserLanguage ¶

func BrowserLanguage(val string) attribute.KeyValue

BrowserLanguage returns an attribute KeyValue conforming to the "browser.language" semantic conventions. It represents the preferred language of the user using the browser

func BrowserMobile ¶

func BrowserMobile(val bool) attribute.KeyValue

BrowserMobile returns an attribute KeyValue conforming to the "browser.mobile" semantic conventions. It represents a boolean that is true if the browser is running on a mobile device

func BrowserPlatform ¶

func BrowserPlatform(val string) attribute.KeyValue

BrowserPlatform returns an attribute KeyValue conforming to the "browser.platform" semantic conventions. It represents the platform on which the browser is running

func CloudAccountID ¶

func CloudAccountID(val string) attribute.KeyValue

CloudAccountID returns an attribute KeyValue conforming to the "cloud.account.id" semantic conventions. It represents the cloud account ID the resource is assigned to.

func CloudAvailabilityZone ¶

func CloudAvailabilityZone(val string) attribute.KeyValue

CloudAvailabilityZone returns an attribute KeyValue conforming to the "cloud.availability_zone" semantic conventions. It represents the cloud regions often have multiple, isolated locations known as zones to increase availability. Availability zone represents the zone where the resource is running.

func CloudRegion ¶

func CloudRegion(val string) attribute.KeyValue

CloudRegion returns an attribute KeyValue conforming to the "cloud.region" semantic conventions. It represents the geographical region the resource is running.

func CloudResourceID ¶

func CloudResourceID(val string) attribute.KeyValue

CloudResourceID returns an attribute KeyValue conforming to the "cloud.resource_id" semantic conventions. It represents the cloud provider-specific native identifier of the monitored cloud resource (e.g. an [ARN](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) on AWS, a [fully qualified resource ID](https://learn.microsoft.com/en-us/rest/api/resources/resources/get-by-id) on Azure, a [full resource name](https://cloud.google.com/apis/design/resource_names#full_resource_name) on GCP)

func CloudeventsEventID ¶

func CloudeventsEventID(val string) attribute.KeyValue

CloudeventsEventID returns an attribute KeyValue conforming to the "cloudevents.event_id" semantic conventions. It represents the [event_id](https://github.com/cloudevents/spec/blob/v1.0.2/cloudevents/spec.md#id) uniquely identifies the event.

func CloudeventsEventSource ¶

func CloudeventsEventSource(val string) attribute.KeyValue

CloudeventsEventSource returns an attribute KeyValue conforming to the "cloudevents.event_source" semantic conventions. It represents the [source](https://github.com/cloudevents/spec/blob/v1.0.2/cloudevents/spec.md#source-1) identifies the context in which an event happened.

func CloudeventsEventSpecVersion ¶

func CloudeventsEventSpecVersion(val string) attribute.KeyValue

CloudeventsEventSpecVersion returns an attribute KeyValue conforming to the "cloudevents.event_spec_version" semantic conventions. It represents the [version of the CloudEvents specification](https://github.com/cloudevents/spec/blob/v1.0.2/cloudevents/spec.md#specversion) which the event uses.

func CloudeventsEventSubject ¶

func CloudeventsEventSubject(val string) attribute.KeyValue

CloudeventsEventSubject returns an attribute KeyValue conforming to the "cloudevents.event_subject" semantic conventions. It represents the [subject](https://github.com/cloudevents/spec/blob/v1.0.2/cloudevents/spec.md#subject) of the event in the context of the event producer (identified by source).

func CloudeventsEventType ¶

func CloudeventsEventType(val string) attribute.KeyValue

CloudeventsEventType returns an attribute KeyValue conforming to the "cloudevents.event_type" semantic conventions. It represents the [event_type](https://github.com/cloudevents/spec/blob/v1.0.2/cloudevents/spec.md#type) contains a value describing the type of event related to the originating occurrence.

func CodeColumn ¶

func CodeColumn(val int) attribute.KeyValue

CodeColumn returns an attribute KeyValue conforming to the "code.column" semantic conventions. It represents the column number in `code.filepath` best representing the operation. It SHOULD point within the code unit named in `code.function`.

func CodeFilepath ¶

func CodeFilepath(val string) attribute.KeyValue

CodeFilepath returns an attribute KeyValue conforming to the "code.filepath" semantic conventions. It represents the source code file name that identifies the code unit as uniquely as possible (preferably an absolute file path).

func CodeFunction ¶

func CodeFunction(val string) attribute.KeyValue

CodeFunction returns an attribute KeyValue conforming to the "code.function" semantic conventions. It represents the method or function name, or equivalent (usually rightmost part of the code unit's name).

func CodeLineNumber ¶

func CodeLineNumber(val int) attribute.KeyValue

CodeLineNumber returns an attribute KeyValue conforming to the "code.lineno" semantic conventions. It represents the line number in `code.filepath` best representing the operation. It SHOULD point within the code unit named in `code.function`.

func CodeNamespace ¶

func CodeNamespace(val string) attribute.KeyValue

CodeNamespace returns an attribute KeyValue conforming to the "code.namespace" semantic conventions. It represents the "namespace" within which `code.function` is defined. Usually the qualified class or module name, such that `code.namespace` + some separator + `code.function` form a unique identifier for the code unit.

func ContainerID ¶

func ContainerID(val string) attribute.KeyValue

ContainerID returns an attribute KeyValue conforming to the "container.id" semantic conventions. It represents the container ID. Usually a UUID, as for example used to [identify Docker containers](https://docs.docker.com/engine/reference/run/#container-identification). The UUID might be abbreviated.

func ContainerImageName ¶

func ContainerImageName(val string) attribute.KeyValue

ContainerImageName returns an attribute KeyValue conforming to the "container.image.name" semantic conventions. It represents the name of the image the container was built on.

func ContainerImageTag ¶

func ContainerImageTag(val string) attribute.KeyValue

ContainerImageTag returns an attribute KeyValue conforming to the "container.image.tag" semantic conventions. It represents the container image tag.

func ContainerName ¶

func ContainerName(val string) attribute.KeyValue

ContainerName returns an attribute KeyValue conforming to the "container.name" semantic conventions. It represents the container name used by container runtime.

func ContainerRuntime ¶

func ContainerRuntime(val string) attribute.KeyValue

ContainerRuntime returns an attribute KeyValue conforming to the "container.runtime" semantic conventions. It represents the container runtime managing this container.

func DBCassandraCoordinatorDC ¶

func DBCassandraCoordinatorDC(val string) attribute.KeyValue

DBCassandraCoordinatorDC returns an attribute KeyValue conforming to the "db.cassandra.coordinator.dc" semantic conventions. It represents the data center of the coordinating node for a query.

func DBCassandraCoordinatorID ¶

func DBCassandraCoordinatorID(val string) attribute.KeyValue

DBCassandraCoordinatorID returns an attribute KeyValue conforming to the "db.cassandra.coordinator.id" semantic conventions. It represents the ID of the coordinating node for a query.

func DBCassandraIdempotence ¶

func DBCassandraIdempotence(val bool) attribute.KeyValue

DBCassandraIdempotence returns an attribute KeyValue conforming to the "db.cassandra.idempotence" semantic conventions. It represents the whether or not the query is idempotent.

func DBCassandraPageSize ¶

func DBCassandraPageSize(val int) attribute.KeyValue

DBCassandraPageSize returns an attribute KeyValue conforming to the "db.cassandra.page_size" semantic conventions. It represents the fetch size used for paging, i.e. how many rows will be returned at once.

func DBCassandraSpeculativeExecutionCount ¶

func DBCassandraSpeculativeExecutionCount(val int) attribute.KeyValue

DBCassandraSpeculativeExecutionCount returns an attribute KeyValue conforming to the "db.cassandra.speculative_execution_count" semantic conventions. It represents the number of times a query was speculatively executed. Not set or `0` if the query was not executed speculatively.

func DBCassandraTable ¶

func DBCassandraTable(val string) attribute.KeyValue

DBCassandraTable returns an attribute KeyValue conforming to the "db.cassandra.table" semantic conventions. It represents the name of the primary table that the operation is acting upon, including the keyspace name (if applicable).

func DBConnectionString ¶

func DBConnectionString(val string) attribute.KeyValue

DBConnectionString returns an attribute KeyValue conforming to the "db.connection_string" semantic conventions. It represents the connection string used to connect to the database. It is recommended to remove embedded credentials.

func DBJDBCDriverClassname ¶

func DBJDBCDriverClassname(val string) attribute.KeyValue

DBJDBCDriverClassname returns an attribute KeyValue conforming to the "db.jdbc.driver_classname" semantic conventions. It represents the fully-qualified class name of the [Java Database Connectivity (JDBC)](https://docs.oracle.com/javase/8/docs/technotes/guides/jdbc/) driver used to connect.

func DBMSSQLInstanceName ¶

func DBMSSQLInstanceName(val string) attribute.KeyValue

DBMSSQLInstanceName returns an attribute KeyValue conforming to the "db.mssql.instance_name" semantic conventions. It represents the Microsoft SQL Server [instance name](https://docs.microsoft.com/en-us/sql/connect/jdbc/building-the-connection-url?view=sql-server-ver15) connecting to. This name is used to determine the port of a named instance.

func DBMongoDBCollection ¶

func DBMongoDBCollection(val string) attribute.KeyValue

DBMongoDBCollection returns an attribute KeyValue conforming to the "db.mongodb.collection" semantic conventions. It represents the collection being accessed within the database stated in `db.name`.

func DBName ¶

func DBName(val string) attribute.KeyValue

DBName returns an attribute KeyValue conforming to the "db.name" semantic conventions. It represents the this attribute is used to report the name of the database being accessed. For commands that switch the database, this should be set to the target database (even if the command fails).

func DBOperation ¶

func DBOperation(val string) attribute.KeyValue

DBOperation returns an attribute KeyValue conforming to the "db.operation" semantic conventions. It represents the name of the operation being executed, e.g. the [MongoDB command name](https://docs.mongodb.com/manual/reference/command/#database-operations) such as `findAndModify`, or the SQL keyword.

func DBRedisDBIndex ¶

func DBRedisDBIndex(val int) attribute.KeyValue

DBRedisDBIndex returns an attribute KeyValue conforming to the "db.redis.database_index" semantic conventions. It represents the index of the database being accessed as used in the [`SELECT` command](https://redis.io/commands/select), provided as an integer. To be used instead of the generic `db.name` attribute.

func DBSQLTable ¶

func DBSQLTable(val string) attribute.KeyValue

DBSQLTable returns an attribute KeyValue conforming to the "db.sql.table" semantic conventions. It represents the name of the primary table that the operation is acting upon, including the database name (if applicable).

func DBStatement ¶

func DBStatement(val string) attribute.KeyValue

DBStatement returns an attribute KeyValue conforming to the "db.statement" semantic conventions. It represents the database statement being executed.

func DBUser ¶

func DBUser(val string) attribute.KeyValue

DBUser returns an attribute KeyValue conforming to the "db.user" semantic conventions. It represents the username for accessing the database.

func DeploymentEnvironment ¶

func DeploymentEnvironment(val string) attribute.KeyValue

DeploymentEnvironment returns an attribute KeyValue conforming to the "deployment.environment" semantic conventions. It represents the name of the [deployment environment](https://en.wikipedia.org/wiki/Deployment_environment) (aka deployment tier).

func DeviceID ¶

func DeviceID(val string) attribute.KeyValue

DeviceID returns an attribute KeyValue conforming to the "device.id" semantic conventions. It represents a unique identifier representing the device

func DeviceManufacturer ¶

func DeviceManufacturer(val string) attribute.KeyValue

DeviceManufacturer returns an attribute KeyValue conforming to the "device.manufacturer" semantic conventions. It represents the name of the device manufacturer

func DeviceModelIdentifier ¶

func DeviceModelIdentifier(val string) attribute.KeyValue

DeviceModelIdentifier returns an attribute KeyValue conforming to the "device.model.identifier" semantic conventions. It represents the model identifier for the device

func DeviceModelName ¶

func DeviceModelName(val string) attribute.KeyValue

DeviceModelName returns an attribute KeyValue conforming to the "device.model.name" semantic conventions. It represents the marketing name for the device model

func EnduserID ¶

func EnduserID(val string) attribute.KeyValue

EnduserID returns an attribute KeyValue conforming to the "enduser.id" semantic conventions. It represents the username or client_id extracted from the access token or [Authorization](https://tools.ietf.org/html/rfc7235#section-4.2) header in the inbound request from outside the system.

func EnduserRole ¶

func EnduserRole(val string) attribute.KeyValue

EnduserRole returns an attribute KeyValue conforming to the "enduser.role" semantic conventions. It represents the actual/assumed role the client is making the request under extracted from token or application security context.

func EnduserScope ¶

func EnduserScope(val string) attribute.KeyValue

EnduserScope returns an attribute KeyValue conforming to the "enduser.scope" semantic conventions. It represents the scopes or granted authorities the client currently possesses extracted from token or application security context. The value would come from the scope associated with an [OAuth 2.0 Access Token](https://tools.ietf.org/html/rfc6749#section-3.3) or an attribute value in a [SAML 2.0 Assertion](http://docs.oasis-open.org/security/saml/Post2.0/sstc-saml-tech-overview-2.0.html).

func EventName ¶

func EventName(val string) attribute.KeyValue

EventName returns an attribute KeyValue conforming to the "event.name" semantic conventions. It represents the name identifies the event.

func ExceptionEscaped ¶

func ExceptionEscaped(val bool) attribute.KeyValue

ExceptionEscaped returns an attribute KeyValue conforming to the "exception.escaped" semantic conventions. It represents the sHOULD be set to true if the exception event is recorded at a point where it is known that the exception is escaping the scope of the span.

func ExceptionMessage ¶

func ExceptionMessage(val string) attribute.KeyValue

ExceptionMessage returns an attribute KeyValue conforming to the "exception.message" semantic conventions. It represents the exception message.

func ExceptionStacktrace ¶

func ExceptionStacktrace(val string) attribute.KeyValue

ExceptionStacktrace returns an attribute KeyValue conforming to the "exception.stacktrace" semantic conventions. It represents a stacktrace as a string in the natural representation for the language runtime. The representation is to be determined and documented by each language SIG.

func ExceptionType ¶

func ExceptionType(val string) attribute.KeyValue

ExceptionType returns an attribute KeyValue conforming to the "exception.type" semantic conventions. It represents the type of the exception (its fully-qualified class name, if applicable). The dynamic type of the exception should be preferred over the static type in languages that support it.

func FaaSColdstart ¶

func FaaSColdstart(val bool) attribute.KeyValue

FaaSColdstart returns an attribute KeyValue conforming to the "faas.coldstart" semantic conventions. It represents a boolean that is true if the serverless function is executed for the first time (aka cold-start).

func FaaSCron ¶

func FaaSCron(val string) attribute.KeyValue

FaaSCron returns an attribute KeyValue conforming to the "faas.cron" semantic conventions. It represents a string containing the schedule period as [Cron Expression](https://docs.oracle.com/cd/E12058_01/doc/doc.1014/e12030/cron_expressions.htm).

func FaaSDocumentCollection ¶

func FaaSDocumentCollection(val string) attribute.KeyValue

FaaSDocumentCollection returns an attribute KeyValue conforming to the "faas.document.collection" semantic conventions. It represents the name of the source on which the triggering operation was performed. For example, in Cloud Storage or S3 corresponds to the bucket name, and in Cosmos DB to the database name.

func FaaSDocumentName ¶

func FaaSDocumentName(val string) attribute.KeyValue

FaaSDocumentName returns an attribute KeyValue conforming to the "faas.document.name" semantic conventions. It represents the document name/table subjected to the operation. For example, in Cloud Storage or S3 is the name of the file, and in Cosmos DB the table name.

func FaaSDocumentTime ¶

func FaaSDocumentTime(val string) attribute.KeyValue

FaaSDocumentTime returns an attribute KeyValue conforming to the "faas.document.time" semantic conventions. It represents a string containing the time when the data was accessed in the [ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html) format expressed in [UTC](https://www.w3.org/TR/NOTE-datetime).

func FaaSInstance ¶

func FaaSInstance(val string) attribute.KeyValue

FaaSInstance returns an attribute KeyValue conforming to the "faas.instance" semantic conventions. It represents the execution environment ID as a string, that will be potentially reused for other invocations to the same function/function version.

func FaaSInvocationID ¶

func FaaSInvocationID(val string) attribute.KeyValue

FaaSInvocationID returns an attribute KeyValue conforming to the "faas.invocation_id" semantic conventions. It represents the invocation ID of the current function invocation.

func FaaSInvokedName ¶

func FaaSInvokedName(val string) attribute.KeyValue

FaaSInvokedName returns an attribute KeyValue conforming to the "faas.invoked_name" semantic conventions. It represents the name of the invoked function.

func FaaSInvokedRegion ¶

func FaaSInvokedRegion(val string) attribute.KeyValue

FaaSInvokedRegion returns an attribute KeyValue conforming to the "faas.invoked_region" semantic conventions. It represents the cloud region of the invoked function.

func FaaSMaxMemory ¶

func FaaSMaxMemory(val int) attribute.KeyValue

FaaSMaxMemory returns an attribute KeyValue conforming to the "faas.max_memory" semantic conventions. It represents the amount of memory available to the serverless function converted to Bytes.

func FaaSName ¶

func FaaSName(val string) attribute.KeyValue

FaaSName returns an attribute KeyValue conforming to the "faas.name" semantic conventions. It represents the name of the single function that this runtime instance executes.

func FaaSTime ¶

func FaaSTime(val string) attribute.KeyValue

FaaSTime returns an attribute KeyValue conforming to the "faas.time" semantic conventions. It represents a string containing the function invocation time in the [ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html) format expressed in [UTC](https://www.w3.org/TR/NOTE-datetime).

func FaaSVersion ¶

func FaaSVersion(val string) attribute.KeyValue

FaaSVersion returns an attribute KeyValue conforming to the "faas.version" semantic conventions. It represents the immutable version of the function being executed.

func FeatureFlagKey ¶

func FeatureFlagKey(val string) attribute.KeyValue

FeatureFlagKey returns an attribute KeyValue conforming to the "feature_flag.key" semantic conventions. It represents the unique identifier of the feature flag.

func FeatureFlagProviderName ¶

func FeatureFlagProviderName(val string) attribute.KeyValue

FeatureFlagProviderName returns an attribute KeyValue conforming to the "feature_flag.provider_name" semantic conventions. It represents the name of the service provider that performs the flag evaluation.

func FeatureFlagVariant ¶

func FeatureFlagVariant(val string) attribute.KeyValue

FeatureFlagVariant returns an attribute KeyValue conforming to the "feature_flag.variant" semantic conventions. It represents the sHOULD be a semantic identifier for a value. If one is unavailable, a stringified version of the value can be used.

func GraphqlDocument ¶

func GraphqlDocument(val string) attribute.KeyValue

GraphqlDocument returns an attribute KeyValue conforming to the "graphql.document" semantic conventions. It represents the GraphQL document being executed.

func GraphqlOperationName ¶

func GraphqlOperationName(val string) attribute.KeyValue

GraphqlOperationName returns an attribute KeyValue conforming to the "graphql.operation.name" semantic conventions. It represents the name of the operation being executed.

func HTTPClientIP ¶

func HTTPClientIP(val string) attribute.KeyValue

HTTPClientIP returns an attribute KeyValue conforming to the "http.client_ip" semantic conventions. It represents the IP address of the original client behind all proxies, if known (e.g. from [X-Forwarded-For](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-For)).

func HTTPMethod ¶

func HTTPMethod(val string) attribute.KeyValue

HTTPMethod returns an attribute KeyValue conforming to the "http.method" semantic conventions. It represents the hTTP request method.

func HTTPRequestContentLength ¶

func HTTPRequestContentLength(val int) attribute.KeyValue

HTTPRequestContentLength returns an attribute KeyValue conforming to the "http.request_content_length" semantic conventions. It represents the size of the request payload body in bytes. This is the number of bytes transferred excluding headers and is often, but not always, present as the [Content-Length](https://www.rfc-editor.org/rfc/rfc9110.html#field.content-length) header. For requests using transport encoding, this should be the compressed size.

func HTTPResendCount ¶

func HTTPResendCount(val int) attribute.KeyValue

HTTPResendCount returns an attribute KeyValue conforming to the "http.resend_count" semantic conventions. It represents the ordinal number of request resending attempt (for any reason, including redirects).

func HTTPResponseContentLength ¶

func HTTPResponseContentLength(val int) attribute.KeyValue

HTTPResponseContentLength returns an attribute KeyValue conforming to the "http.response_content_length" semantic conventions. It represents the size of the response payload body in bytes. This is the number of bytes transferred excluding headers and is often, but not always, present as the [Content-Length](https://www.rfc-editor.org/rfc/rfc9110.html#field.content-length) header. For requests using transport encoding, this should be the compressed size.

func HTTPRoute ¶

func HTTPRoute(val string) attribute.KeyValue

HTTPRoute returns an attribute KeyValue conforming to the "http.route" semantic conventions. It represents the matched route (path template in the format used by the respective server framework). See note below

func HTTPScheme ¶

func HTTPScheme(val string) attribute.KeyValue

HTTPScheme returns an attribute KeyValue conforming to the "http.scheme" semantic conventions. It represents the URI scheme identifying the used protocol.

func HTTPStatusCode ¶

func HTTPStatusCode(val int) attribute.KeyValue

HTTPStatusCode returns an attribute KeyValue conforming to the "http.status_code" semantic conventions. It represents the [HTTP response status code](https://tools.ietf.org/html/rfc7231#section-6).

func HTTPTarget ¶

func HTTPTarget(val string) attribute.KeyValue

HTTPTarget returns an attribute KeyValue conforming to the "http.target" semantic conventions. It represents the full request target as passed in a HTTP request line or equivalent.

func HTTPURL ¶

func HTTPURL(val string) attribute.KeyValue

HTTPURL returns an attribute KeyValue conforming to the "http.url" semantic conventions. It represents the full HTTP request URL in the form `scheme://host[:port]/path?query[#fragment]`. Usually the fragment is not transmitted over HTTP, but if it is known, it should be included nevertheless.

func HerokuAppID ¶

func HerokuAppID(val string) attribute.KeyValue

HerokuAppID returns an attribute KeyValue conforming to the "heroku.app.id" semantic conventions. It represents the unique identifier for the application

func HerokuReleaseCommit ¶

func HerokuReleaseCommit(val string) attribute.KeyValue

HerokuReleaseCommit returns an attribute KeyValue conforming to the "heroku.release.commit" semantic conventions. It represents the commit hash for the current release

func HerokuReleaseCreationTimestamp ¶

func HerokuReleaseCreationTimestamp(val string) attribute.KeyValue

HerokuReleaseCreationTimestamp returns an attribute KeyValue conforming to the "heroku.release.creation_timestamp" semantic conventions. It represents the time and date the release was created

func HostID ¶

func HostID(val string) attribute.KeyValue

HostID returns an attribute KeyValue conforming to the "host.id" semantic conventions. It represents the unique host ID. For Cloud, this must be the instance_id assigned by the cloud provider. For non-containerized systems, this should be the `machine-id`. See the table below for the sources to use to determine the `machine-id` based on operating system.

func HostImageID ¶

func HostImageID(val string) attribute.KeyValue

HostImageID returns an attribute KeyValue conforming to the "host.image.id" semantic conventions. It represents the vM image ID. For Cloud, this value is from the provider.

func HostImageName ¶

func HostImageName(val string) attribute.KeyValue

HostImageName returns an attribute KeyValue conforming to the "host.image.name" semantic conventions. It represents the name of the VM image or OS install the host was instantiated from.

func HostImageVersion ¶

func HostImageVersion(val string) attribute.KeyValue

HostImageVersion returns an attribute KeyValue conforming to the "host.image.version" semantic conventions. It represents the version string of the VM image as defined in [Version Attributes](README.md#version-attributes).

func HostName ¶

func HostName(val string) attribute.KeyValue

HostName returns an attribute KeyValue conforming to the "host.name" semantic conventions. It represents the name of the host. On Unix systems, it may contain what the hostname command returns, or the fully qualified hostname, or another name specified by the user.

func HostType ¶

func HostType(val string) attribute.KeyValue

HostType returns an attribute KeyValue conforming to the "host.type" semantic conventions. It represents the type of host. For Cloud, this must be the machine type.

func K8SClusterName ¶

func K8SClusterName(val string) attribute.KeyValue

K8SClusterName returns an attribute KeyValue conforming to the "k8s.cluster.name" semantic conventions. It represents the name of the cluster.

func K8SContainerName ¶

func K8SContainerName(val string) attribute.KeyValue

K8SContainerName returns an attribute KeyValue conforming to the "k8s.container.name" semantic conventions. It represents the name of the Container from Pod specification, must be unique within a Pod. Container runtime usually uses different globally unique name (`container.name`).

func K8SContainerRestartCount ¶

func K8SContainerRestartCount(val int) attribute.KeyValue

K8SContainerRestartCount returns an attribute KeyValue conforming to the "k8s.container.restart_count" semantic conventions. It represents the number of times the container was restarted. This attribute can be used to identify a particular container (running or stopped) within a container spec.

func K8SCronJobName ¶

func K8SCronJobName(val string) attribute.KeyValue

K8SCronJobName returns an attribute KeyValue conforming to the "k8s.cronjob.name" semantic conventions. It represents the name of the CronJob.

func K8SCronJobUID ¶

func K8SCronJobUID(val string) attribute.KeyValue

K8SCronJobUID returns an attribute KeyValue conforming to the "k8s.cronjob.uid" semantic conventions. It represents the UID of the CronJob.

func K8SDaemonSetName ¶

func K8SDaemonSetName(val string) attribute.KeyValue

K8SDaemonSetName returns an attribute KeyValue conforming to the "k8s.daemonset.name" semantic conventions. It represents the name of the DaemonSet.

func K8SDaemonSetUID ¶

func K8SDaemonSetUID(val string) attribute.KeyValue

K8SDaemonSetUID returns an attribute KeyValue conforming to the "k8s.daemonset.uid" semantic conventions. It represents the UID of the DaemonSet.

func K8SDeploymentName ¶

func K8SDeploymentName(val string) attribute.KeyValue

K8SDeploymentName returns an attribute KeyValue conforming to the "k8s.deployment.name" semantic conventions. It represents the name of the Deployment.

func K8SDeploymentUID ¶

func K8SDeploymentUID(val string) attribute.KeyValue

K8SDeploymentUID returns an attribute KeyValue conforming to the "k8s.deployment.uid" semantic conventions. It represents the UID of the Deployment.

func K8SJobName ¶

func K8SJobName(val string) attribute.KeyValue

K8SJobName returns an attribute KeyValue conforming to the "k8s.job.name" semantic conventions. It represents the name of the Job.

func K8SJobUID ¶

func K8SJobUID(val string) attribute.KeyValue

K8SJobUID returns an attribute KeyValue conforming to the "k8s.job.uid" semantic conventions. It represents the UID of the Job.

func K8SNamespaceName ¶

func K8SNamespaceName(val string) attribute.KeyValue

K8SNamespaceName returns an attribute KeyValue conforming to the "k8s.namespace.name" semantic conventions. It represents the name of the namespace that the pod is running in.

func K8SNodeName ¶

func K8SNodeName(val string) attribute.KeyValue

K8SNodeName returns an attribute KeyValue conforming to the "k8s.node.name" semantic conventions. It represents the name of the Node.

func K8SNodeUID ¶

func K8SNodeUID(val string) attribute.KeyValue

K8SNodeUID returns an attribute KeyValue conforming to the "k8s.node.uid" semantic conventions. It represents the UID of the Node.

func K8SPodName ¶

func K8SPodName(val string) attribute.KeyValue

K8SPodName returns an attribute KeyValue conforming to the "k8s.pod.name" semantic conventions. It represents the name of the Pod.

func K8SPodUID ¶

func K8SPodUID(val string) attribute.KeyValue

K8SPodUID returns an attribute KeyValue conforming to the "k8s.pod.uid" semantic conventions. It represents the UID of the Pod.

func K8SReplicaSetName ¶

func K8SReplicaSetName(val string) attribute.KeyValue

K8SReplicaSetName returns an attribute KeyValue conforming to the "k8s.replicaset.name" semantic conventions. It represents the name of the ReplicaSet.

func K8SReplicaSetUID ¶

func K8SReplicaSetUID(val string) attribute.KeyValue

K8SReplicaSetUID returns an attribute KeyValue conforming to the "k8s.replicaset.uid" semantic conventions. It represents the UID of the ReplicaSet.

func K8SStatefulSetName ¶

func K8SStatefulSetName(val string) attribute.KeyValue

K8SStatefulSetName returns an attribute KeyValue conforming to the "k8s.statefulset.name" semantic conventions. It represents the name of the StatefulSet.

func K8SStatefulSetUID ¶

func K8SStatefulSetUID(val string) attribute.KeyValue

K8SStatefulSetUID returns an attribute KeyValue conforming to the "k8s.statefulset.uid" semantic conventions. It represents the UID of the StatefulSet.

func MessageCompressedSize ¶

func MessageCompressedSize(val int) attribute.KeyValue

MessageCompressedSize returns an attribute KeyValue conforming to the "message.compressed_size" semantic conventions. It represents the compressed size of the message in bytes.

func MessageID ¶

func MessageID(val int) attribute.KeyValue

MessageID returns an attribute KeyValue conforming to the "message.id" semantic conventions. It represents the mUST be calculated as two different counters starting from `1` one for sent messages and one for received message.

func MessageUncompressedSize ¶

func MessageUncompressedSize(val int) attribute.KeyValue

MessageUncompressedSize returns an attribute KeyValue conforming to the "message.uncompressed_size" semantic conventions. It represents the uncompressed size of the message in bytes.

func MessagingBatchMessageCount ¶

func MessagingBatchMessageCount(val int) attribute.KeyValue

MessagingBatchMessageCount returns an attribute KeyValue conforming to the "messaging.batch.message_count" semantic conventions. It represents the number of messages sent, received, or processed in the scope of the batching operation.

func MessagingConsumerID ¶

func MessagingConsumerID(val string) attribute.KeyValue

MessagingConsumerID returns an attribute KeyValue conforming to the "messaging.consumer.id" semantic conventions. It represents the identifier for the consumer receiving a message. For Kafka, set it to `{messaging.kafka.consumer.group} - {messaging.kafka.client_id}`, if both are present, or only `messaging.kafka.consumer.group`. For brokers, such as RabbitMQ and Artemis, set it to the `client_id` of the client consuming the message.

func MessagingDestinationAnonymous ¶

func MessagingDestinationAnonymous(val bool) attribute.KeyValue

MessagingDestinationAnonymous returns an attribute KeyValue conforming to the "messaging.destination.anonymous" semantic conventions. It represents a boolean that is true if the message destination is anonymous (could be unnamed or have auto-generated name).

func MessagingDestinationName ¶

func MessagingDestinationName(val string) attribute.KeyValue

MessagingDestinationName returns an attribute KeyValue conforming to the "messaging.destination.name" semantic conventions. It represents the message destination name

func MessagingDestinationTemplate ¶

func MessagingDestinationTemplate(val string) attribute.KeyValue

MessagingDestinationTemplate returns an attribute KeyValue conforming to the "messaging.destination.template" semantic conventions. It represents the low cardinality representation of the messaging destination name

func MessagingDestinationTemporary ¶

func MessagingDestinationTemporary(val bool) attribute.KeyValue

MessagingDestinationTemporary returns an attribute KeyValue conforming to the "messaging.destination.temporary" semantic conventions. It represents a boolean that is true if the message destination is temporary and might not exist anymore after messages are processed.

func MessagingKafkaClientID ¶

func MessagingKafkaClientID(val string) attribute.KeyValue

MessagingKafkaClientID returns an attribute KeyValue conforming to the "messaging.kafka.client_id" semantic conventions. It represents the client ID for the Consumer or Producer that is handling the message.

func MessagingKafkaConsumerGroup ¶

func MessagingKafkaConsumerGroup(val string) attribute.KeyValue

MessagingKafkaConsumerGroup returns an attribute KeyValue conforming to the "messaging.kafka.consumer.group" semantic conventions. It represents the name of the Kafka Consumer Group that is handling the message. Only applies to consumers, not producers.

func MessagingKafkaDestinationPartition ¶

func MessagingKafkaDestinationPartition(val int) attribute.KeyValue

MessagingKafkaDestinationPartition returns an attribute KeyValue conforming to the "messaging.kafka.destination.partition" semantic conventions. It represents the partition the message is sent to.

func MessagingKafkaMessageKey ¶

func MessagingKafkaMessageKey(val string) attribute.KeyValue

MessagingKafkaMessageKey returns an attribute KeyValue conforming to the "messaging.kafka.message.key" semantic conventions. It represents the message keys in Kafka are used for grouping alike messages to ensure they're processed on the same partition. They differ from `messaging.message.id` in that they're not unique. If the key is `null`, the attribute MUST NOT be set.

func MessagingKafkaMessageOffset ¶

func MessagingKafkaMessageOffset(val int) attribute.KeyValue

MessagingKafkaMessageOffset returns an attribute KeyValue conforming to the "messaging.kafka.message.offset" semantic conventions. It represents the offset of a record in the corresponding Kafka partition.

func MessagingKafkaMessageTombstone ¶

func MessagingKafkaMessageTombstone(val bool) attribute.KeyValue

MessagingKafkaMessageTombstone returns an attribute KeyValue conforming to the "messaging.kafka.message.tombstone" semantic conventions. It represents a boolean that is true if the message is a tombstone.

func MessagingKafkaSourcePartition ¶

func MessagingKafkaSourcePartition(val int) attribute.KeyValue

MessagingKafkaSourcePartition returns an attribute KeyValue conforming to the "messaging.kafka.source.partition" semantic conventions. It represents the partition the message is received from.

func MessagingMessageConversationID ¶

func MessagingMessageConversationID(val string) attribute.KeyValue

MessagingMessageConversationID returns an attribute KeyValue conforming to the "messaging.message.conversation_id" semantic conventions. It represents the [conversation ID](#conversations) identifying the conversation to which the message belongs, represented as a string. Sometimes called "Correlation ID".

func MessagingMessageID ¶

func MessagingMessageID(val string) attribute.KeyValue

MessagingMessageID returns an attribute KeyValue conforming to the "messaging.message.id" semantic conventions. It represents a value used by the messaging system as an identifier for the message, represented as a string.

func MessagingMessagePayloadCompressedSizeBytes ¶

func MessagingMessagePayloadCompressedSizeBytes(val int) attribute.KeyValue

MessagingMessagePayloadCompressedSizeBytes returns an attribute KeyValue conforming to the "messaging.message.payload_compressed_size_bytes" semantic conventions. It represents the compressed size of the message payload in bytes.

func MessagingMessagePayloadSizeBytes ¶

func MessagingMessagePayloadSizeBytes(val int) attribute.KeyValue

MessagingMessagePayloadSizeBytes returns an attribute KeyValue conforming to the "messaging.message.payload_size_bytes" semantic conventions. It represents the (uncompressed) size of the message payload in bytes. Also use this attribute if it is unknown whether the compressed or uncompressed payload size is reported.

func MessagingRabbitmqDestinationRoutingKey ¶

func MessagingRabbitmqDestinationRoutingKey(val string) attribute.KeyValue

MessagingRabbitmqDestinationRoutingKey returns an attribute KeyValue conforming to the "messaging.rabbitmq.destination.routing_key" semantic conventions. It represents the rabbitMQ message routing key.

func MessagingRocketmqClientGroup ¶

func MessagingRocketmqClientGroup(val string) attribute.KeyValue

MessagingRocketmqClientGroup returns an attribute KeyValue conforming to the "messaging.rocketmq.client_group" semantic conventions. It represents the name of the RocketMQ producer/consumer group that is handling the message. The client type is identified by the SpanKind.

func MessagingRocketmqClientID ¶

func MessagingRocketmqClientID(val string) attribute.KeyValue

MessagingRocketmqClientID returns an attribute KeyValue conforming to the "messaging.rocketmq.client_id" semantic conventions. It represents the unique identifier for each client.

func MessagingRocketmqMessageDelayTimeLevel ¶

func MessagingRocketmqMessageDelayTimeLevel(val int) attribute.KeyValue

MessagingRocketmqMessageDelayTimeLevel returns an attribute KeyValue conforming to the "messaging.rocketmq.message.delay_time_level" semantic conventions. It represents the delay time level for delay message, which determines the message delay time.

func MessagingRocketmqMessageDeliveryTimestamp ¶

func MessagingRocketmqMessageDeliveryTimestamp(val int) attribute.KeyValue

MessagingRocketmqMessageDeliveryTimestamp returns an attribute KeyValue conforming to the "messaging.rocketmq.message.delivery_timestamp" semantic conventions. It represents the timestamp in milliseconds that the delay message is expected to be delivered to consumer.

func MessagingRocketmqMessageGroup ¶

func MessagingRocketmqMessageGroup(val string) attribute.KeyValue

MessagingRocketmqMessageGroup returns an attribute KeyValue conforming to the "messaging.rocketmq.message.group" semantic conventions. It represents the it is essential for FIFO message. Messages that belong to the same message group are always processed one by one within the same consumer group.

func MessagingRocketmqMessageKeys ¶

func MessagingRocketmqMessageKeys(val ...string) attribute.KeyValue

MessagingRocketmqMessageKeys returns an attribute KeyValue conforming to the "messaging.rocketmq.message.keys" semantic conventions. It represents the key(s) of message, another way to mark message besides message id.

func MessagingRocketmqMessageTag ¶

func MessagingRocketmqMessageTag(val string) attribute.KeyValue

MessagingRocketmqMessageTag returns an attribute KeyValue conforming to the "messaging.rocketmq.message.tag" semantic conventions. It represents the secondary classifier of message besides topic.

func MessagingRocketmqNamespace ¶

func MessagingRocketmqNamespace(val string) attribute.KeyValue

MessagingRocketmqNamespace returns an attribute KeyValue conforming to the "messaging.rocketmq.namespace" semantic conventions. It represents the namespace of RocketMQ resources, resources in different namespaces are individual.

func MessagingSourceAnonymous ¶

func MessagingSourceAnonymous(val bool) attribute.KeyValue

MessagingSourceAnonymous returns an attribute KeyValue conforming to the "messaging.source.anonymous" semantic conventions. It represents a boolean that is true if the message source is anonymous (could be unnamed or have auto-generated name).

func MessagingSourceName ¶

func MessagingSourceName(val string) attribute.KeyValue

MessagingSourceName returns an attribute KeyValue conforming to the "messaging.source.name" semantic conventions. It represents the message source name

func MessagingSourceTemplate ¶

func MessagingSourceTemplate(val string) attribute.KeyValue

MessagingSourceTemplate returns an attribute KeyValue conforming to the "messaging.source.template" semantic conventions. It represents the low cardinality representation of the messaging source name

func MessagingSourceTemporary ¶

func MessagingSourceTemporary(val bool) attribute.KeyValue

MessagingSourceTemporary returns an attribute KeyValue conforming to the "messaging.source.temporary" semantic conventions. It represents a boolean that is true if the message source is temporary and might not exist anymore after messages are processed.

func MessagingSystem ¶

func MessagingSystem(val string) attribute.KeyValue

MessagingSystem returns an attribute KeyValue conforming to the "messaging.system" semantic conventions. It represents a string identifying the messaging system.

func NetAppProtocolName ¶

func NetAppProtocolName(val string) attribute.KeyValue

NetAppProtocolName returns an attribute KeyValue conforming to the "net.app.protocol.name" semantic conventions. It represents the application layer protocol used. The value SHOULD be normalized to lowercase.

func NetAppProtocolVersion ¶

func NetAppProtocolVersion(val string) attribute.KeyValue

NetAppProtocolVersion returns an attribute KeyValue conforming to the "net.app.protocol.version" semantic conventions. It represents the version of the application layer protocol used. See note below.

func NetHostCarrierIcc ¶

func NetHostCarrierIcc(val string) attribute.KeyValue

NetHostCarrierIcc returns an attribute KeyValue conforming to the "net.host.carrier.icc" semantic conventions. It represents the ISO 3166-1 alpha-2 2-character country code associated with the mobile carrier network.

func NetHostCarrierMcc ¶

func NetHostCarrierMcc(val string) attribute.KeyValue

NetHostCarrierMcc returns an attribute KeyValue conforming to the "net.host.carrier.mcc" semantic conventions. It represents the mobile carrier country code.

func NetHostCarrierMnc ¶

func NetHostCarrierMnc(val string) attribute.KeyValue

NetHostCarrierMnc returns an attribute KeyValue conforming to the "net.host.carrier.mnc" semantic conventions. It represents the mobile carrier network code.

func NetHostCarrierName ¶

func NetHostCarrierName(val string) attribute.KeyValue

NetHostCarrierName returns an attribute KeyValue conforming to the "net.host.carrier.name" semantic conventions. It represents the name of the mobile carrier.

func NetHostName ¶

func NetHostName(val string) attribute.KeyValue

NetHostName returns an attribute KeyValue conforming to the "net.host.name" semantic conventions. It represents the logical local hostname or similar, see note below.

func NetHostPort ¶

func NetHostPort(val int) attribute.KeyValue

NetHostPort returns an attribute KeyValue conforming to the "net.host.port" semantic conventions. It represents the logical local port number, preferably the one that the peer used to connect

func NetPeerName ¶

func NetPeerName(val string) attribute.KeyValue

NetPeerName returns an attribute KeyValue conforming to the "net.peer.name" semantic conventions. It represents the logical remote hostname, see note below.

func NetPeerPort ¶

func NetPeerPort(val int) attribute.KeyValue

NetPeerPort returns an attribute KeyValue conforming to the "net.peer.port" semantic conventions. It represents the logical remote port number

func NetSockHostAddr ¶

func NetSockHostAddr(val string) attribute.KeyValue

NetSockHostAddr returns an attribute KeyValue conforming to the "net.sock.host.addr" semantic conventions. It represents the local socket address. Useful in case of a multi-IP host.

func NetSockHostPort ¶

func NetSockHostPort(val int) attribute.KeyValue

NetSockHostPort returns an attribute KeyValue conforming to the "net.sock.host.port" semantic conventions. It represents the local socket port number.

func NetSockPeerAddr ¶

func NetSockPeerAddr(val string) attribute.KeyValue

NetSockPeerAddr returns an attribute KeyValue conforming to the "net.sock.peer.addr" semantic conventions. It represents the remote socket peer address: IPv4 or IPv6 for internet protocols, path for local communication, [etc](https://man7.org/linux/man-pages/man7/address_families.7.html).

func NetSockPeerName ¶

func NetSockPeerName(val string) attribute.KeyValue

NetSockPeerName returns an attribute KeyValue conforming to the "net.sock.peer.name" semantic conventions. It represents the remote socket peer name.

func NetSockPeerPort ¶

func NetSockPeerPort(val int) attribute.KeyValue

NetSockPeerPort returns an attribute KeyValue conforming to the "net.sock.peer.port" semantic conventions. It represents the remote socket peer port.

func OSDescription ¶

func OSDescription(val string) attribute.KeyValue

OSDescription returns an attribute KeyValue conforming to the "os.description" semantic conventions. It represents the human readable (not intended to be parsed) OS version information, like e.g. reported by `ver` or `lsb_release -a` commands.

func OSName ¶

func OSName(val string) attribute.KeyValue

OSName returns an attribute KeyValue conforming to the "os.name" semantic conventions. It represents the human readable operating system name.

func OSVersion ¶

func OSVersion(val string) attribute.KeyValue

OSVersion returns an attribute KeyValue conforming to the "os.version" semantic conventions. It represents the version string of the operating system as defined in [Version Attributes](../../resource/semantic_conventions/README.md#version-attributes).

func OTelLibraryName ¶

func OTelLibraryName(val string) attribute.KeyValue

OTelLibraryName returns an attribute KeyValue conforming to the "otel.library.name" semantic conventions. It represents the deprecated, use the `otel.scope.name` attribute.

func OTelLibraryVersion ¶

func OTelLibraryVersion(val string) attribute.KeyValue

OTelLibraryVersion returns an attribute KeyValue conforming to the "otel.library.version" semantic conventions. It represents the deprecated, use the `otel.scope.version` attribute.

func OTelScopeName ¶

func OTelScopeName(val string) attribute.KeyValue

OTelScopeName returns an attribute KeyValue conforming to the "otel.scope.name" semantic conventions. It represents the name of the instrumentation scope - (`InstrumentationScope.Name` in OTLP).

func OTelScopeVersion ¶

func OTelScopeVersion(val string) attribute.KeyValue

OTelScopeVersion returns an attribute KeyValue conforming to the "otel.scope.version" semantic conventions. It represents the version of the instrumentation scope - (`InstrumentationScope.Version` in OTLP).

func OTelStatusDescription ¶

func OTelStatusDescription(val string) attribute.KeyValue

OTelStatusDescription returns an attribute KeyValue conforming to the "otel.status_description" semantic conventions. It represents the description of the Status if it has a value, otherwise not set.

func PeerService ¶

func PeerService(val string) attribute.KeyValue

PeerService returns an attribute KeyValue conforming to the "peer.service" semantic conventions. It represents the [`service.name`](../../resource/semantic_conventions/README.md#service) of the remote service. SHOULD be equal to the actual `service.name` resource attribute of the remote service if any.

func ProcessCommand ¶

func ProcessCommand(val string) attribute.KeyValue

ProcessCommand returns an attribute KeyValue conforming to the "process.command" semantic conventions. It represents the command used to launch the process (i.e. the command name). On Linux based systems, can be set to the zeroth string in `proc/[pid]/cmdline`. On Windows, can be set to the first parameter extracted from `GetCommandLineW`.

func ProcessCommandArgs ¶

func ProcessCommandArgs(val ...string) attribute.KeyValue

ProcessCommandArgs returns an attribute KeyValue conforming to the "process.command_args" semantic conventions. It represents the all the command arguments (including the command/executable itself) as received by the process. On Linux-based systems (and some other Unixoid systems supporting procfs), can be set according to the list of null-delimited strings extracted from `proc/[pid]/cmdline`. For libc-based executables, this would be the full argv vector passed to `main`.

func ProcessCommandLine ¶

func ProcessCommandLine(val string) attribute.KeyValue

ProcessCommandLine returns an attribute KeyValue conforming to the "process.command_line" semantic conventions. It represents the full command used to launch the process as a single string representing the full command. On Windows, can be set to the result of `GetCommandLineW`. Do not set this if you have to assemble it just for monitoring; use `process.command_args` instead.

func ProcessExecutableName ¶

func ProcessExecutableName(val string) attribute.KeyValue

ProcessExecutableName returns an attribute KeyValue conforming to the "process.executable.name" semantic conventions. It represents the name of the process executable. On Linux based systems, can be set to the `Name` in `proc/[pid]/status`. On Windows, can be set to the base name of `GetProcessImageFileNameW`.

func ProcessExecutablePath ¶

func ProcessExecutablePath(val string) attribute.KeyValue

ProcessExecutablePath returns an attribute KeyValue conforming to the "process.executable.path" semantic conventions. It represents the full path to the process executable. On Linux based systems, can be set to the target of `proc/[pid]/exe`. On Windows, can be set to the result of `GetProcessImageFileNameW`.

func ProcessOwner ¶

func ProcessOwner(val string) attribute.KeyValue

ProcessOwner returns an attribute KeyValue conforming to the "process.owner" semantic conventions. It represents the username of the user that owns the process.

func ProcessPID ¶

func ProcessPID(val int) attribute.KeyValue

ProcessPID returns an attribute KeyValue conforming to the "process.pid" semantic conventions. It represents the process identifier (PID).

func ProcessParentPID ¶

func ProcessParentPID(val int) attribute.KeyValue

ProcessParentPID returns an attribute KeyValue conforming to the "process.parent_pid" semantic conventions. It represents the parent Process identifier (PID).

func ProcessRuntimeDescription ¶

func ProcessRuntimeDescription(val string) attribute.KeyValue

ProcessRuntimeDescription returns an attribute KeyValue conforming to the "process.runtime.description" semantic conventions. It represents an additional description about the runtime of the process, for example a specific vendor customization of the runtime environment.

func ProcessRuntimeName ¶

func ProcessRuntimeName(val string) attribute.KeyValue

ProcessRuntimeName returns an attribute KeyValue conforming to the "process.runtime.name" semantic conventions. It represents the name of the runtime of this process. For compiled native binaries, this SHOULD be the name of the compiler.

func ProcessRuntimeVersion ¶

func ProcessRuntimeVersion(val string) attribute.KeyValue

ProcessRuntimeVersion returns an attribute KeyValue conforming to the "process.runtime.version" semantic conventions. It represents the version of the runtime of this process, as returned by the runtime without modification.

func RPCJsonrpcErrorCode ¶

func RPCJsonrpcErrorCode(val int) attribute.KeyValue

RPCJsonrpcErrorCode returns an attribute KeyValue conforming to the "rpc.jsonrpc.error_code" semantic conventions. It represents the `error.code` property of response if it is an error response.

func RPCJsonrpcErrorMessage ¶

func RPCJsonrpcErrorMessage(val string) attribute.KeyValue

RPCJsonrpcErrorMessage returns an attribute KeyValue conforming to the "rpc.jsonrpc.error_message" semantic conventions. It represents the `error.message` property of response if it is an error response.

func RPCJsonrpcRequestID ¶

func RPCJsonrpcRequestID(val string) attribute.KeyValue

RPCJsonrpcRequestID returns an attribute KeyValue conforming to the "rpc.jsonrpc.request_id" semantic conventions. It represents the `id` property of request or response. Since protocol allows id to be int, string, `null` or missing (for notifications), value is expected to be cast to string for simplicity. Use empty string in case of `null` value. Omit entirely if this is a notification.

func RPCJsonrpcVersion ¶

func RPCJsonrpcVersion(val string) attribute.KeyValue

RPCJsonrpcVersion returns an attribute KeyValue conforming to the "rpc.jsonrpc.version" semantic conventions. It represents the protocol version as in `jsonrpc` property of request/response. Since JSON-RPC 1.0 does not specify this, the value can be omitted.

func RPCMethod ¶

func RPCMethod(val string) attribute.KeyValue

RPCMethod returns an attribute KeyValue conforming to the "rpc.method" semantic conventions. It represents the name of the (logical) method being called, must be equal to the $method part in the span name.

func RPCService ¶

func RPCService(val string) attribute.KeyValue

RPCService returns an attribute KeyValue conforming to the "rpc.service" semantic conventions. It represents the full (logical) name of the service being called, including its package name, if applicable.

func ServiceInstanceID ¶

func ServiceInstanceID(val string) attribute.KeyValue

ServiceInstanceID returns an attribute KeyValue conforming to the "service.instance.id" semantic conventions. It represents the string ID of the service instance.

func ServiceName ¶

func ServiceName(val string) attribute.KeyValue

ServiceName returns an attribute KeyValue conforming to the "service.name" semantic conventions. It represents the logical name of the service.

func ServiceNamespace ¶

func ServiceNamespace(val string) attribute.KeyValue

ServiceNamespace returns an attribute KeyValue conforming to the "service.namespace" semantic conventions. It represents a namespace for `service.name`.

func ServiceVersion ¶

func ServiceVersion(val string) attribute.KeyValue

ServiceVersion returns an attribute KeyValue conforming to the "service.version" semantic conventions. It represents the version string of the service API or implementation.

func TelemetryAutoVersion ¶

func TelemetryAutoVersion(val string) attribute.KeyValue

TelemetryAutoVersion returns an attribute KeyValue conforming to the "telemetry.auto.version" semantic conventions. It represents the version string of the auto instrumentation agent, if used.

func TelemetrySDKName ¶

func TelemetrySDKName(val string) attribute.KeyValue

TelemetrySDKName returns an attribute KeyValue conforming to the "telemetry.sdk.name" semantic conventions. It represents the name of the telemetry SDK as defined above.

func TelemetrySDKVersion ¶

func TelemetrySDKVersion(val string) attribute.KeyValue

TelemetrySDKVersion returns an attribute KeyValue conforming to the "telemetry.sdk.version" semantic conventions. It represents the version string of the telemetry SDK.

func ThreadID ¶

func ThreadID(val int) attribute.KeyValue

ThreadID returns an attribute KeyValue conforming to the "thread.id" semantic conventions. It represents the current "managed" thread ID (as opposed to OS thread ID).

func ThreadName ¶

func ThreadName(val string) attribute.KeyValue

ThreadName returns an attribute KeyValue conforming to the "thread.name" semantic conventions. It represents the current thread name.

func UserAgentOriginal ¶

func UserAgentOriginal(val string) attribute.KeyValue

UserAgentOriginal returns an attribute KeyValue conforming to the "user_agent.original" semantic conventions. It represents the value of the [HTTP User-Agent](https://www.rfc-editor.org/rfc/rfc9110.html#field.user-agent) header sent by the client.

func WebEngineDescription ¶

func WebEngineDescription(val string) attribute.KeyValue

WebEngineDescription returns an attribute KeyValue conforming to the "webengine.description" semantic conventions. It represents the additional description of the web engine (e.g. detailed version and edition information).

func WebEngineName ¶

func WebEngineName(val string) attribute.KeyValue

WebEngineName returns an attribute KeyValue conforming to the "webengine.name" semantic conventions. It represents the name of the web engine.

func WebEngineVersion ¶

func WebEngineVersion(val string) attribute.KeyValue

WebEngineVersion returns an attribute KeyValue conforming to the "webengine.version" semantic conventions. It represents the version of the web engine.

Subdirectories