{-# LANGUAGE DataKinds #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PatternSynonyms #-}
module OTel.API.Trace.Core.Attributes where

import Data.Int (Int64)
import Data.Text (Text)
import OTel.API.Common (AttrVals)
import OTel.API.Common.Internal (Key(..), SchemaURL(..), ToAttrVal(..))
import Prelude (Bool, Double)

-- | The URL of the OpenTelemetry schema for these keys and values.
pattern TRACE_SCHEMA_URL :: SchemaURL
pattern $mTRACE_SCHEMA_URL :: forall {r}. SchemaURL -> ((# #) -> r) -> ((# #) -> r) -> r
$bTRACE_SCHEMA_URL :: SchemaURL
TRACE_SCHEMA_URL <- SchemaURL "https://opentelemetry.io/schemas/1.12.0" where
  TRACE_SCHEMA_URL = Text -> SchemaURL
SchemaURL Text
"https://opentelemetry.io/schemas/1.12.0"

{-|
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).

[Notes]: This may be different from @faas.id@ if an alias is involved.
-}
pattern AWS_LAMBDA_INVOKED_ARN :: Key Text
pattern $mAWS_LAMBDA_INVOKED_ARN :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bAWS_LAMBDA_INVOKED_ARN :: Key Text
AWS_LAMBDA_INVOKED_ARN <- Key "aws.lambda.invoked_arn" where
  AWS_LAMBDA_INVOKED_ARN = Text -> Key Text
forall a. Text -> Key a
Key Text
"aws.lambda.invoked_arn"

{-|
The <https://github.com/cloudevents/spec/blob/v1.0.2/cloudevents/spec.md#id> uniquely identifies the event.
-}
pattern CLOUDEVENTS_EVENT_ID :: Key Text
pattern $mCLOUDEVENTS_EVENT_ID :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bCLOUDEVENTS_EVENT_ID :: Key Text
CLOUDEVENTS_EVENT_ID <- Key "cloudevents.event_id" where
  CLOUDEVENTS_EVENT_ID = Text -> Key Text
forall a. Text -> Key a
Key Text
"cloudevents.event_id"

{-|
The <https://github.com/cloudevents/spec/blob/v1.0.2/cloudevents/spec.md#source-1> identifies the context in which an event happened.
-}
pattern CLOUDEVENTS_EVENT_SOURCE :: Key Text
pattern $mCLOUDEVENTS_EVENT_SOURCE :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bCLOUDEVENTS_EVENT_SOURCE :: Key Text
CLOUDEVENTS_EVENT_SOURCE <- Key "cloudevents.event_source" where
  CLOUDEVENTS_EVENT_SOURCE = Text -> Key Text
forall a. Text -> Key a
Key Text
"cloudevents.event_source"

{-|
The <https://github.com/cloudevents/spec/blob/v1.0.2/cloudevents/spec.md#specversion> which the event uses.
-}
pattern CLOUDEVENTS_EVENT_SPEC_VERSION :: Key Text
pattern $mCLOUDEVENTS_EVENT_SPEC_VERSION :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bCLOUDEVENTS_EVENT_SPEC_VERSION :: Key Text
CLOUDEVENTS_EVENT_SPEC_VERSION <- Key "cloudevents.event_spec_version" where
  CLOUDEVENTS_EVENT_SPEC_VERSION = Text -> Key Text
forall a. Text -> Key a
Key Text
"cloudevents.event_spec_version"

{-|
The <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.
-}
pattern CLOUDEVENTS_EVENT_TYPE :: Key Text
pattern $mCLOUDEVENTS_EVENT_TYPE :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bCLOUDEVENTS_EVENT_TYPE :: Key Text
CLOUDEVENTS_EVENT_TYPE <- Key "cloudevents.event_type" where
  CLOUDEVENTS_EVENT_TYPE = Text -> Key Text
forall a. Text -> Key a
Key Text
"cloudevents.event_type"

{-|
The <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).
-}
pattern CLOUDEVENTS_EVENT_SUBJECT :: Key Text
pattern $mCLOUDEVENTS_EVENT_SUBJECT :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bCLOUDEVENTS_EVENT_SUBJECT :: Key Text
CLOUDEVENTS_EVENT_SUBJECT <- Key "cloudevents.event_subject" where
  CLOUDEVENTS_EVENT_SUBJECT = Text -> Key Text
forall a. Text -> Key a
Key Text
"cloudevents.event_subject"

{-|
Parent-child Reference type

[Notes]: The causal relationship between a child Span and a parent Span.
-}
pattern OPENTRACING_REF_TYPE :: Key Text
pattern $mOPENTRACING_REF_TYPE :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bOPENTRACING_REF_TYPE :: Key Text
OPENTRACING_REF_TYPE <- Key "opentracing.ref_type" where
  OPENTRACING_REF_TYPE = Text -> Key Text
forall a. Text -> Key a
Key Text
"opentracing.ref_type"

{-|
An identifier for the database management system (DBMS) product being used. See below for a list of well-known identifiers.
-}
pattern DB_SYSTEM :: Key Text
pattern $mDB_SYSTEM :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bDB_SYSTEM :: Key Text
DB_SYSTEM <- Key "db.system" where
  DB_SYSTEM = Text -> Key Text
forall a. Text -> Key a
Key Text
"db.system"

{-|
The connection string used to connect to the database. It is recommended to remove embedded credentials.
-}
pattern DB_CONNECTION_STRING :: Key Text
pattern $mDB_CONNECTION_STRING :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bDB_CONNECTION_STRING :: Key Text
DB_CONNECTION_STRING <- Key "db.connection_string" where
  DB_CONNECTION_STRING = Text -> Key Text
forall a. Text -> Key a
Key Text
"db.connection_string"

{-|
Username for accessing the database.
-}
pattern DB_USER :: Key Text
pattern $mDB_USER :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bDB_USER :: Key Text
DB_USER <- Key "db.user" where
  DB_USER = Text -> Key Text
forall a. Text -> Key a
Key Text
"db.user"

{-|
The fully-qualified class name of the <https://docs.oracle.com/javase/8/docs/technotes/guides/jdbc/> driver used to connect.
-}
pattern DB_JDBC_DRIVER_CLASSNAME :: Key Text
pattern $mDB_JDBC_DRIVER_CLASSNAME :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bDB_JDBC_DRIVER_CLASSNAME :: Key Text
DB_JDBC_DRIVER_CLASSNAME <- Key "db.jdbc.driver_classname" where
  DB_JDBC_DRIVER_CLASSNAME = Text -> Key Text
forall a. Text -> Key a
Key Text
"db.jdbc.driver_classname"

{-|
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).

[Notes]: In some SQL databases, the database name to be used is called &quot;schema name&quot;. 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).
-}
pattern DB_NAME :: Key Text
pattern $mDB_NAME :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bDB_NAME :: Key Text
DB_NAME <- Key "db.name" where
  DB_NAME = Text -> Key Text
forall a. Text -> Key a
Key Text
"db.name"

{-|
The database statement being executed.

[Notes]: The value may be sanitized to exclude sensitive information.
-}
pattern DB_STATEMENT :: Key Text
pattern $mDB_STATEMENT :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bDB_STATEMENT :: Key Text
DB_STATEMENT <- Key "db.statement" where
  DB_STATEMENT = Text -> Key Text
forall a. Text -> Key a
Key Text
"db.statement"

{-|
The name of the operation being executed, e.g. the <https://docs.mongodb.com/manual/reference/command/#database-operations> such as @findAndModify@, or the SQL keyword.

[Notes]: 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.
-}
pattern DB_OPERATION :: Key Text
pattern $mDB_OPERATION :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bDB_OPERATION :: Key Text
DB_OPERATION <- Key "db.operation" where
  DB_OPERATION = Text -> Key Text
forall a. Text -> Key a
Key Text
"db.operation"

{-|
The Microsoft SQL Server <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.

[Notes]: If setting a @db.mssql.instance_name@, @net.peer.port@ is no longer required (but still recommended if non-standard).
-}
pattern DB_MSSQL_INSTANCE_NAME :: Key Text
pattern $mDB_MSSQL_INSTANCE_NAME :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bDB_MSSQL_INSTANCE_NAME :: Key Text
DB_MSSQL_INSTANCE_NAME <- Key "db.mssql.instance_name" where
  DB_MSSQL_INSTANCE_NAME = Text -> Key Text
forall a. Text -> Key a
Key Text
"db.mssql.instance_name"

{-|
The fetch size used for paging, i.e. how many rows will be returned at once.
-}
pattern DB_CASSANDRA_PAGE_SIZE :: Key Int64
pattern $mDB_CASSANDRA_PAGE_SIZE :: forall {r}. Key Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDB_CASSANDRA_PAGE_SIZE :: Key Int64
DB_CASSANDRA_PAGE_SIZE <- Key "db.cassandra.page_size" where
  DB_CASSANDRA_PAGE_SIZE = Text -> Key Int64
forall a. Text -> Key a
Key Text
"db.cassandra.page_size"

{-|
The consistency level of the query. Based on consistency values from <https://docs.datastax.com/en/cassandra-oss/3.0/cassandra/dml/dmlConfigConsistency.html>.
-}
pattern DB_CASSANDRA_CONSISTENCY_LEVEL :: Key Text
pattern $mDB_CASSANDRA_CONSISTENCY_LEVEL :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bDB_CASSANDRA_CONSISTENCY_LEVEL :: Key Text
DB_CASSANDRA_CONSISTENCY_LEVEL <- Key "db.cassandra.consistency_level" where
  DB_CASSANDRA_CONSISTENCY_LEVEL = Text -> Key Text
forall a. Text -> Key a
Key Text
"db.cassandra.consistency_level"

{-|
The name of the primary table that the operation is acting upon, including the keyspace name (if applicable).

[Notes]: 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.
-}
pattern DB_CASSANDRA_TABLE :: Key Text
pattern $mDB_CASSANDRA_TABLE :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bDB_CASSANDRA_TABLE :: Key Text
DB_CASSANDRA_TABLE <- Key "db.cassandra.table" where
  DB_CASSANDRA_TABLE = Text -> Key Text
forall a. Text -> Key a
Key Text
"db.cassandra.table"

{-|
Whether or not the query is idempotent.
-}
pattern DB_CASSANDRA_IDEMPOTENCE :: Key Bool
pattern $mDB_CASSANDRA_IDEMPOTENCE :: forall {r}. Key Bool -> ((# #) -> r) -> ((# #) -> r) -> r
$bDB_CASSANDRA_IDEMPOTENCE :: Key Bool
DB_CASSANDRA_IDEMPOTENCE <- Key "db.cassandra.idempotence" where
  DB_CASSANDRA_IDEMPOTENCE = Text -> Key Bool
forall a. Text -> Key a
Key Text
"db.cassandra.idempotence"

{-|
The number of times a query was speculatively executed. Not set or @0@ if the query was not executed speculatively.
-}
pattern DB_CASSANDRA_SPECULATIVE_EXECUTION_COUNT :: Key Int64
pattern $mDB_CASSANDRA_SPECULATIVE_EXECUTION_COUNT :: forall {r}. Key Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDB_CASSANDRA_SPECULATIVE_EXECUTION_COUNT :: Key Int64
DB_CASSANDRA_SPECULATIVE_EXECUTION_COUNT <- Key "db.cassandra.speculative_execution_count" where
  DB_CASSANDRA_SPECULATIVE_EXECUTION_COUNT = Text -> Key Int64
forall a. Text -> Key a
Key Text
"db.cassandra.speculative_execution_count"

{-|
The ID of the coordinating node for a query.
-}
pattern DB_CASSANDRA_COORDINATOR_ID :: Key Text
pattern $mDB_CASSANDRA_COORDINATOR_ID :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bDB_CASSANDRA_COORDINATOR_ID :: Key Text
DB_CASSANDRA_COORDINATOR_ID <- Key "db.cassandra.coordinator.id" where
  DB_CASSANDRA_COORDINATOR_ID = Text -> Key Text
forall a. Text -> Key a
Key Text
"db.cassandra.coordinator.id"

{-|
The data center of the coordinating node for a query.
-}
pattern DB_CASSANDRA_COORDINATOR_DC :: Key Text
pattern $mDB_CASSANDRA_COORDINATOR_DC :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bDB_CASSANDRA_COORDINATOR_DC :: Key Text
DB_CASSANDRA_COORDINATOR_DC <- Key "db.cassandra.coordinator.dc" where
  DB_CASSANDRA_COORDINATOR_DC = Text -> Key Text
forall a. Text -> Key a
Key Text
"db.cassandra.coordinator.dc"

{-|
The index of the database being accessed as used in the <https://redis.io/commands/select>, provided as an integer. To be used instead of the generic @db.name@ attribute.
-}
pattern DB_REDIS_DATABASE_INDEX :: Key Int64
pattern $mDB_REDIS_DATABASE_INDEX :: forall {r}. Key Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDB_REDIS_DATABASE_INDEX :: Key Int64
DB_REDIS_DATABASE_INDEX <- Key "db.redis.database_index" where
  DB_REDIS_DATABASE_INDEX = Text -> Key Int64
forall a. Text -> Key a
Key Text
"db.redis.database_index"

{-|
The collection being accessed within the database stated in @db.name@.
-}
pattern DB_MONGODB_COLLECTION :: Key Text
pattern $mDB_MONGODB_COLLECTION :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bDB_MONGODB_COLLECTION :: Key Text
DB_MONGODB_COLLECTION <- Key "db.mongodb.collection" where
  DB_MONGODB_COLLECTION = Text -> Key Text
forall a. Text -> Key a
Key Text
"db.mongodb.collection"

{-|
The name of the primary table that the operation is acting upon, including the database name (if applicable).

[Notes]: 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.
-}
pattern DB_SQL_TABLE :: Key Text
pattern $mDB_SQL_TABLE :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bDB_SQL_TABLE :: Key Text
DB_SQL_TABLE <- Key "db.sql.table" where
  DB_SQL_TABLE = Text -> Key Text
forall a. Text -> Key a
Key Text
"db.sql.table"

{-|
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.
-}
pattern EXCEPTION_TYPE :: Key Text
pattern $mEXCEPTION_TYPE :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bEXCEPTION_TYPE :: Key Text
EXCEPTION_TYPE <- Key "exception.type" where
  EXCEPTION_TYPE = Text -> Key Text
forall a. Text -> Key a
Key Text
"exception.type"

{-|
The exception message.
-}
pattern EXCEPTION_MESSAGE :: Key Text
pattern $mEXCEPTION_MESSAGE :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bEXCEPTION_MESSAGE :: Key Text
EXCEPTION_MESSAGE <- Key "exception.message" where
  EXCEPTION_MESSAGE = Text -> Key Text
forall a. Text -> Key a
Key Text
"exception.message"

{-|
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.
-}
pattern EXCEPTION_STACKTRACE :: Key Text
pattern $mEXCEPTION_STACKTRACE :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bEXCEPTION_STACKTRACE :: Key Text
EXCEPTION_STACKTRACE <- Key "exception.stacktrace" where
  EXCEPTION_STACKTRACE = Text -> Key Text
forall a. Text -> Key a
Key Text
"exception.stacktrace"

{-|
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.

[Notes]: 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 &quot;in flight&quot;.
This may be actually &quot;in flight&quot; 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 <#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.
-}
pattern EXCEPTION_ESCAPED :: Key Bool
pattern $mEXCEPTION_ESCAPED :: forall {r}. Key Bool -> ((# #) -> r) -> ((# #) -> r) -> r
$bEXCEPTION_ESCAPED :: Key Bool
EXCEPTION_ESCAPED <- Key "exception.escaped" where
  EXCEPTION_ESCAPED = Text -> Key Bool
forall a. Text -> Key a
Key Text
"exception.escaped"

{-|
Type of the trigger which caused this function execution.

[Notes]: 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).
-}
pattern FAAS_TRIGGER :: Key Text
pattern $mFAAS_TRIGGER :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bFAAS_TRIGGER :: Key Text
FAAS_TRIGGER <- Key "faas.trigger" where
  FAAS_TRIGGER = Text -> Key Text
forall a. Text -> Key a
Key Text
"faas.trigger"

{-|
The execution ID of the current function execution.
-}
pattern FAAS_EXECUTION :: Key Text
pattern $mFAAS_EXECUTION :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bFAAS_EXECUTION :: Key Text
FAAS_EXECUTION <- Key "faas.execution" where
  FAAS_EXECUTION = Text -> Key Text
forall a. Text -> Key a
Key Text
"faas.execution"

{-|
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.
-}
pattern FAAS_DOCUMENT_COLLECTION :: Key Text
pattern $mFAAS_DOCUMENT_COLLECTION :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bFAAS_DOCUMENT_COLLECTION :: Key Text
FAAS_DOCUMENT_COLLECTION <- Key "faas.document.collection" where
  FAAS_DOCUMENT_COLLECTION = Text -> Key Text
forall a. Text -> Key a
Key Text
"faas.document.collection"

{-|
Describes the type of the operation that was performed on the data.
-}
pattern FAAS_DOCUMENT_OPERATION :: Key Text
pattern $mFAAS_DOCUMENT_OPERATION :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bFAAS_DOCUMENT_OPERATION :: Key Text
FAAS_DOCUMENT_OPERATION <- Key "faas.document.operation" where
  FAAS_DOCUMENT_OPERATION = Text -> Key Text
forall a. Text -> Key a
Key Text
"faas.document.operation"

{-|
A string containing the time when the data was accessed in the <https://www.iso.org/iso-8601-date-and-time-format.html> format expressed in <https://www.w3.org/TR/NOTE-datetime>.
-}
pattern FAAS_DOCUMENT_TIME :: Key Text
pattern $mFAAS_DOCUMENT_TIME :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bFAAS_DOCUMENT_TIME :: Key Text
FAAS_DOCUMENT_TIME <- Key "faas.document.time" where
  FAAS_DOCUMENT_TIME = Text -> Key Text
forall a. Text -> Key a
Key Text
"faas.document.time"

{-|
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.
-}
pattern FAAS_DOCUMENT_NAME :: Key Text
pattern $mFAAS_DOCUMENT_NAME :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bFAAS_DOCUMENT_NAME :: Key Text
FAAS_DOCUMENT_NAME <- Key "faas.document.name" where
  FAAS_DOCUMENT_NAME = Text -> Key Text
forall a. Text -> Key a
Key Text
"faas.document.name"

{-|
A string containing the function invocation time in the <https://www.iso.org/iso-8601-date-and-time-format.html> format expressed in <https://www.w3.org/TR/NOTE-datetime>.
-}
pattern FAAS_TIME :: Key Text
pattern $mFAAS_TIME :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bFAAS_TIME :: Key Text
FAAS_TIME <- Key "faas.time" where
  FAAS_TIME = Text -> Key Text
forall a. Text -> Key a
Key Text
"faas.time"

{-|
A string containing the schedule period as <https://docs.oracle.com/cd/E12058_01/doc/doc.1014/e12030/cron_expressions.htm>.
-}
pattern FAAS_CRON :: Key Text
pattern $mFAAS_CRON :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bFAAS_CRON :: Key Text
FAAS_CRON <- Key "faas.cron" where
  FAAS_CRON = Text -> Key Text
forall a. Text -> Key a
Key Text
"faas.cron"

{-|
A boolean that is true if the serverless function is executed for the first time (aka cold-start).
-}
pattern FAAS_COLDSTART :: Key Bool
pattern $mFAAS_COLDSTART :: forall {r}. Key Bool -> ((# #) -> r) -> ((# #) -> r) -> r
$bFAAS_COLDSTART :: Key Bool
FAAS_COLDSTART <- Key "faas.coldstart" where
  FAAS_COLDSTART = Text -> Key Bool
forall a. Text -> Key a
Key Text
"faas.coldstart"

{-|
The name of the invoked function.

[Notes]: SHOULD be equal to the @faas.name@ resource attribute of the invoked function.
-}
pattern FAAS_INVOKED_NAME :: Key Text
pattern $mFAAS_INVOKED_NAME :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bFAAS_INVOKED_NAME :: Key Text
FAAS_INVOKED_NAME <- Key "faas.invoked_name" where
  FAAS_INVOKED_NAME = Text -> Key Text
forall a. Text -> Key a
Key Text
"faas.invoked_name"

{-|
The cloud provider of the invoked function.

[Notes]: SHOULD be equal to the @cloud.provider@ resource attribute of the invoked function.
-}
pattern FAAS_INVOKED_PROVIDER :: Key Text
pattern $mFAAS_INVOKED_PROVIDER :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bFAAS_INVOKED_PROVIDER :: Key Text
FAAS_INVOKED_PROVIDER <- Key "faas.invoked_provider" where
  FAAS_INVOKED_PROVIDER = Text -> Key Text
forall a. Text -> Key a
Key Text
"faas.invoked_provider"

{-|
The cloud region of the invoked function.

[Notes]: SHOULD be equal to the @cloud.region@ resource attribute of the invoked function.
-}
pattern FAAS_INVOKED_REGION :: Key Text
pattern $mFAAS_INVOKED_REGION :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bFAAS_INVOKED_REGION :: Key Text
FAAS_INVOKED_REGION <- Key "faas.invoked_region" where
  FAAS_INVOKED_REGION = Text -> Key Text
forall a. Text -> Key a
Key Text
"faas.invoked_region"

{-|
Transport protocol used. See note below.
-}
pattern NET_TRANSPORT :: Key Text
pattern $mNET_TRANSPORT :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bNET_TRANSPORT :: Key Text
NET_TRANSPORT <- Key "net.transport" where
  NET_TRANSPORT = Text -> Key Text
forall a. Text -> Key a
Key Text
"net.transport"

{-|
Remote address of the peer (dotted decimal for IPv4 or <https://tools.ietf.org/html/rfc5952> for IPv6)
-}
pattern NET_PEER_IP :: Key Text
pattern $mNET_PEER_IP :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bNET_PEER_IP :: Key Text
NET_PEER_IP <- Key "net.peer.ip" where
  NET_PEER_IP = Text -> Key Text
forall a. Text -> Key a
Key Text
"net.peer.ip"

{-|
Remote port number.
-}
pattern NET_PEER_PORT :: Key Int64
pattern $mNET_PEER_PORT :: forall {r}. Key Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bNET_PEER_PORT :: Key Int64
NET_PEER_PORT <- Key "net.peer.port" where
  NET_PEER_PORT = Text -> Key Int64
forall a. Text -> Key a
Key Text
"net.peer.port"

{-|
Remote hostname or similar, see note below.

[Notes]: @net.peer.name@ SHOULD NOT be set if capturing it would require an extra DNS lookup.
-}
pattern NET_PEER_NAME :: Key Text
pattern $mNET_PEER_NAME :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bNET_PEER_NAME :: Key Text
NET_PEER_NAME <- Key "net.peer.name" where
  NET_PEER_NAME = Text -> Key Text
forall a. Text -> Key a
Key Text
"net.peer.name"

{-|
Like @net.peer.ip@ but for the host IP. Useful in case of a multi-IP host.
-}
pattern NET_HOST_IP :: Key Text
pattern $mNET_HOST_IP :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bNET_HOST_IP :: Key Text
NET_HOST_IP <- Key "net.host.ip" where
  NET_HOST_IP = Text -> Key Text
forall a. Text -> Key a
Key Text
"net.host.ip"

{-|
Like @net.peer.port@ but for the host port.
-}
pattern NET_HOST_PORT :: Key Int64
pattern $mNET_HOST_PORT :: forall {r}. Key Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bNET_HOST_PORT :: Key Int64
NET_HOST_PORT <- Key "net.host.port" where
  NET_HOST_PORT = Text -> Key Int64
forall a. Text -> Key a
Key Text
"net.host.port"

{-|
Local hostname or similar, see note below.
-}
pattern NET_HOST_NAME :: Key Text
pattern $mNET_HOST_NAME :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bNET_HOST_NAME :: Key Text
NET_HOST_NAME <- Key "net.host.name" where
  NET_HOST_NAME = Text -> Key Text
forall a. Text -> Key a
Key Text
"net.host.name"

{-|
The internet connection type currently being used by the host.
-}
pattern NET_HOST_CONNECTION_TYPE :: Key Text
pattern $mNET_HOST_CONNECTION_TYPE :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bNET_HOST_CONNECTION_TYPE :: Key Text
NET_HOST_CONNECTION_TYPE <- Key "net.host.connection.type" where
  NET_HOST_CONNECTION_TYPE = Text -> Key Text
forall a. Text -> Key a
Key Text
"net.host.connection.type"

{-|
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.
-}
pattern NET_HOST_CONNECTION_SUBTYPE :: Key Text
pattern $mNET_HOST_CONNECTION_SUBTYPE :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bNET_HOST_CONNECTION_SUBTYPE :: Key Text
NET_HOST_CONNECTION_SUBTYPE <- Key "net.host.connection.subtype" where
  NET_HOST_CONNECTION_SUBTYPE = Text -> Key Text
forall a. Text -> Key a
Key Text
"net.host.connection.subtype"

{-|
The name of the mobile carrier.
-}
pattern NET_HOST_CARRIER_NAME :: Key Text
pattern $mNET_HOST_CARRIER_NAME :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bNET_HOST_CARRIER_NAME :: Key Text
NET_HOST_CARRIER_NAME <- Key "net.host.carrier.name" where
  NET_HOST_CARRIER_NAME = Text -> Key Text
forall a. Text -> Key a
Key Text
"net.host.carrier.name"

{-|
The mobile carrier country code.
-}
pattern NET_HOST_CARRIER_MCC :: Key Text
pattern $mNET_HOST_CARRIER_MCC :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bNET_HOST_CARRIER_MCC :: Key Text
NET_HOST_CARRIER_MCC <- Key "net.host.carrier.mcc" where
  NET_HOST_CARRIER_MCC = Text -> Key Text
forall a. Text -> Key a
Key Text
"net.host.carrier.mcc"

{-|
The mobile carrier network code.
-}
pattern NET_HOST_CARRIER_MNC :: Key Text
pattern $mNET_HOST_CARRIER_MNC :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bNET_HOST_CARRIER_MNC :: Key Text
NET_HOST_CARRIER_MNC <- Key "net.host.carrier.mnc" where
  NET_HOST_CARRIER_MNC = Text -> Key Text
forall a. Text -> Key a
Key Text
"net.host.carrier.mnc"

{-|
The ISO 3166-1 alpha-2 2-character country code associated with the mobile carrier network.
-}
pattern NET_HOST_CARRIER_ICC :: Key Text
pattern $mNET_HOST_CARRIER_ICC :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bNET_HOST_CARRIER_ICC :: Key Text
NET_HOST_CARRIER_ICC <- Key "net.host.carrier.icc" where
  NET_HOST_CARRIER_ICC = Text -> Key Text
forall a. Text -> Key a
Key Text
"net.host.carrier.icc"

{-|
The <../../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.
-}
pattern PEER_SERVICE :: Key Text
pattern $mPEER_SERVICE :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bPEER_SERVICE :: Key Text
PEER_SERVICE <- Key "peer.service" where
  PEER_SERVICE = Text -> Key Text
forall a. Text -> Key a
Key Text
"peer.service"

{-|
Username or client_id extracted from the access token or <https://tools.ietf.org/html/rfc7235#section-4.2> header in the inbound request from outside the system.
-}
pattern ENDUSER_ID :: Key Text
pattern $mENDUSER_ID :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bENDUSER_ID :: Key Text
ENDUSER_ID <- Key "enduser.id" where
  ENDUSER_ID = Text -> Key Text
forall a. Text -> Key a
Key Text
"enduser.id"

{-|
Actual/assumed role the client is making the request under extracted from token or application security context.
-}
pattern ENDUSER_ROLE :: Key Text
pattern $mENDUSER_ROLE :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bENDUSER_ROLE :: Key Text
ENDUSER_ROLE <- Key "enduser.role" where
  ENDUSER_ROLE = Text -> Key Text
forall a. Text -> Key a
Key Text
"enduser.role"

{-|
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 <https://tools.ietf.org/html/rfc6749#section-3.3> or an attribute value in a <http://docs.oasis-open.org/security/saml/Post2.0/sstc-saml-tech-overview-2.0.html>.
-}
pattern ENDUSER_SCOPE :: Key Text
pattern $mENDUSER_SCOPE :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bENDUSER_SCOPE :: Key Text
ENDUSER_SCOPE <- Key "enduser.scope" where
  ENDUSER_SCOPE = Text -> Key Text
forall a. Text -> Key a
Key Text
"enduser.scope"

{-|
Current &quot;managed&quot; thread ID (as opposed to OS thread ID).
-}
pattern THREAD_ID :: Key Int64
pattern $mTHREAD_ID :: forall {r}. Key Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bTHREAD_ID :: Key Int64
THREAD_ID <- Key "thread.id" where
  THREAD_ID = Text -> Key Int64
forall a. Text -> Key a
Key Text
"thread.id"

{-|
Current thread name.
-}
pattern THREAD_NAME :: Key Text
pattern $mTHREAD_NAME :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTHREAD_NAME :: Key Text
THREAD_NAME <- Key "thread.name" where
  THREAD_NAME = Text -> Key Text
forall a. Text -> Key a
Key Text
"thread.name"

{-|
The method or function name, or equivalent (usually rightmost part of the code unit's name).
-}
pattern CODE_FUNCTION :: Key Text
pattern $mCODE_FUNCTION :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bCODE_FUNCTION :: Key Text
CODE_FUNCTION <- Key "code.function" where
  CODE_FUNCTION = Text -> Key Text
forall a. Text -> Key a
Key Text
"code.function"

{-|
The &quot;namespace&quot; 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.
-}
pattern CODE_NAMESPACE :: Key Text
pattern $mCODE_NAMESPACE :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bCODE_NAMESPACE :: Key Text
CODE_NAMESPACE <- Key "code.namespace" where
  CODE_NAMESPACE = Text -> Key Text
forall a. Text -> Key a
Key Text
"code.namespace"

{-|
The source code file name that identifies the code unit as uniquely as possible (preferably an absolute file path).
-}
pattern CODE_FILEPATH :: Key Text
pattern $mCODE_FILEPATH :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bCODE_FILEPATH :: Key Text
CODE_FILEPATH <- Key "code.filepath" where
  CODE_FILEPATH = Text -> Key Text
forall a. Text -> Key a
Key Text
"code.filepath"

{-|
The line number in @code.filepath@ best representing the operation. It SHOULD point within the code unit named in @code.function@.
-}
pattern CODE_LINENO :: Key Int64
pattern $mCODE_LINENO :: forall {r}. Key Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bCODE_LINENO :: Key Int64
CODE_LINENO <- Key "code.lineno" where
  CODE_LINENO = Text -> Key Int64
forall a. Text -> Key a
Key Text
"code.lineno"

{-|
HTTP request method.
-}
pattern HTTP_METHOD :: Key Text
pattern $mHTTP_METHOD :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bHTTP_METHOD :: Key Text
HTTP_METHOD <- Key "http.method" where
  HTTP_METHOD = Text -> Key Text
forall a. Text -> Key a
Key Text
"http.method"

{-|
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.

[Notes]: @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\/@.
-}
pattern HTTP_URL :: Key Text
pattern $mHTTP_URL :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bHTTP_URL :: Key Text
HTTP_URL <- Key "http.url" where
  HTTP_URL = Text -> Key Text
forall a. Text -> Key a
Key Text
"http.url"

{-|
The full request target as passed in a HTTP request line or equivalent.
-}
pattern HTTP_TARGET :: Key Text
pattern $mHTTP_TARGET :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bHTTP_TARGET :: Key Text
HTTP_TARGET <- Key "http.target" where
  HTTP_TARGET = Text -> Key Text
forall a. Text -> Key a
Key Text
"http.target"

{-|
The value of the <https://tools.ietf.org/html/rfc7230#section-5.4>. An empty Host header should also be reported, see note.

[Notes]: When the header is present but empty the attribute SHOULD be set to the empty string. Note that this is a valid situation that is expected in certain cases, according the aforementioned <https://tools.ietf.org/html/rfc7230#section-5.4>. When the header is not set the attribute MUST NOT be set.
-}
pattern HTTP_HOST :: Key Text
pattern $mHTTP_HOST :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bHTTP_HOST :: Key Text
HTTP_HOST <- Key "http.host" where
  HTTP_HOST = Text -> Key Text
forall a. Text -> Key a
Key Text
"http.host"

{-|
The URI scheme identifying the used protocol.
-}
pattern HTTP_SCHEME :: Key Text
pattern $mHTTP_SCHEME :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bHTTP_SCHEME :: Key Text
HTTP_SCHEME <- Key "http.scheme" where
  HTTP_SCHEME = Text -> Key Text
forall a. Text -> Key a
Key Text
"http.scheme"

{-|
<https://tools.ietf.org/html/rfc7231#section-6>.
-}
pattern HTTP_STATUS_CODE :: Key Int64
pattern $mHTTP_STATUS_CODE :: forall {r}. Key Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bHTTP_STATUS_CODE :: Key Int64
HTTP_STATUS_CODE <- Key "http.status_code" where
  HTTP_STATUS_CODE = Text -> Key Int64
forall a. Text -> Key a
Key Text
"http.status_code"

{-|
Kind of HTTP protocol used.

[Notes]: If @net.transport@ is not specified, it can be assumed to be @IP.TCP@ except if @http.flavor@ is @QUIC@, in which case @IP.UDP@ is assumed.
-}
pattern HTTP_FLAVOR :: Key Text
pattern $mHTTP_FLAVOR :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bHTTP_FLAVOR :: Key Text
HTTP_FLAVOR <- Key "http.flavor" where
  HTTP_FLAVOR = Text -> Key Text
forall a. Text -> Key a
Key Text
"http.flavor"

{-|
Value of the <https://tools.ietf.org/html/rfc7231#section-5.5.3> header sent by the client.
-}
pattern HTTP_USER_AGENT :: Key Text
pattern $mHTTP_USER_AGENT :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bHTTP_USER_AGENT :: Key Text
HTTP_USER_AGENT <- Key "http.user_agent" where
  HTTP_USER_AGENT = Text -> Key Text
forall a. Text -> Key a
Key Text
"http.user_agent"

{-|
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 <https://tools.ietf.org/html/rfc7230#section-3.3.2> header. For requests using transport encoding, this should be the compressed size.
-}
pattern HTTP_REQUEST_CONTENT_LENGTH :: Key Int64
pattern $mHTTP_REQUEST_CONTENT_LENGTH :: forall {r}. Key Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bHTTP_REQUEST_CONTENT_LENGTH :: Key Int64
HTTP_REQUEST_CONTENT_LENGTH <- Key "http.request_content_length" where
  HTTP_REQUEST_CONTENT_LENGTH = Text -> Key Int64
forall a. Text -> Key a
Key Text
"http.request_content_length"

{-|
The size of the uncompressed request payload body after transport decoding. Not set if transport encoding not used.
-}
pattern HTTP_REQUEST_CONTENT_LENGTH_UNCOMPRESSED :: Key Int64
pattern $mHTTP_REQUEST_CONTENT_LENGTH_UNCOMPRESSED :: forall {r}. Key Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bHTTP_REQUEST_CONTENT_LENGTH_UNCOMPRESSED :: Key Int64
HTTP_REQUEST_CONTENT_LENGTH_UNCOMPRESSED <- Key "http.request_content_length_uncompressed" where
  HTTP_REQUEST_CONTENT_LENGTH_UNCOMPRESSED = Text -> Key Int64
forall a. Text -> Key a
Key Text
"http.request_content_length_uncompressed"

{-|
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 <https://tools.ietf.org/html/rfc7230#section-3.3.2> header. For requests using transport encoding, this should be the compressed size.
-}
pattern HTTP_RESPONSE_CONTENT_LENGTH :: Key Int64
pattern $mHTTP_RESPONSE_CONTENT_LENGTH :: forall {r}. Key Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bHTTP_RESPONSE_CONTENT_LENGTH :: Key Int64
HTTP_RESPONSE_CONTENT_LENGTH <- Key "http.response_content_length" where
  HTTP_RESPONSE_CONTENT_LENGTH = Text -> Key Int64
forall a. Text -> Key a
Key Text
"http.response_content_length"

{-|
The size of the uncompressed response payload body after transport decoding. Not set if transport encoding not used.
-}
pattern HTTP_RESPONSE_CONTENT_LENGTH_UNCOMPRESSED :: Key Int64
pattern $mHTTP_RESPONSE_CONTENT_LENGTH_UNCOMPRESSED :: forall {r}. Key Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bHTTP_RESPONSE_CONTENT_LENGTH_UNCOMPRESSED :: Key Int64
HTTP_RESPONSE_CONTENT_LENGTH_UNCOMPRESSED <- Key "http.response_content_length_uncompressed" where
  HTTP_RESPONSE_CONTENT_LENGTH_UNCOMPRESSED = Text -> Key Int64
forall a. Text -> Key a
Key Text
"http.response_content_length_uncompressed"

{-|
The ordinal number of request re-sending attempt.
-}
pattern HTTP_RETRY_COUNT :: Key Int64
pattern $mHTTP_RETRY_COUNT :: forall {r}. Key Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bHTTP_RETRY_COUNT :: Key Int64
HTTP_RETRY_COUNT <- Key "http.retry_count" where
  HTTP_RETRY_COUNT = Text -> Key Int64
forall a. Text -> Key a
Key Text
"http.retry_count"

{-|
The primary server name of the matched virtual host. This should be obtained via configuration. If no such configuration can be obtained, this attribute MUST NOT be set ( @net.host.name@ should be used instead).

[Notes]: @http.url@ is usually not readily available on the server side but would have to be assembled in a cumbersome and sometimes lossy process from other information (see e.g. open-telemetry/opentelemetry-python/pull/148). It is thus preferred to supply the raw data that is available.
-}
pattern HTTP_SERVER_NAME :: Key Text
pattern $mHTTP_SERVER_NAME :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bHTTP_SERVER_NAME :: Key Text
HTTP_SERVER_NAME <- Key "http.server_name" where
  HTTP_SERVER_NAME = Text -> Key Text
forall a. Text -> Key a
Key Text
"http.server_name"

{-|
The matched route (path template).
-}
pattern HTTP_ROUTE :: Key Text
pattern $mHTTP_ROUTE :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bHTTP_ROUTE :: Key Text
HTTP_ROUTE <- Key "http.route" where
  HTTP_ROUTE = Text -> Key Text
forall a. Text -> Key a
Key Text
"http.route"

{-|
The IP address of the original client behind all proxies, if known (e.g. from <https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-For>).

[Notes]: This is not necessarily the same as @net.peer.ip@, 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.peer.ip@, is available even if that other
source just confirms the same value as @net.peer.ip@.
Rationale: For @net.peer.ip@, 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.peer.ip@ means that
one is at least somewhat confident that the address is not that of
the closest proxy.
-}
pattern HTTP_CLIENT_IP :: Key Text
pattern $mHTTP_CLIENT_IP :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bHTTP_CLIENT_IP :: Key Text
HTTP_CLIENT_IP <- Key "http.client_ip" where
  HTTP_CLIENT_IP = Text -> Key Text
forall a. Text -> Key a
Key Text
"http.client_ip"

{-|
The keys in the @RequestItems@ object field.
-}
pattern AWS_DYNAMODB_TABLE_NAMES :: Key (AttrVals Text)
pattern $mAWS_DYNAMODB_TABLE_NAMES :: forall {r}.
Key (AttrVals Text) -> ((# #) -> r) -> ((# #) -> r) -> r
$bAWS_DYNAMODB_TABLE_NAMES :: Key (AttrVals Text)
AWS_DYNAMODB_TABLE_NAMES <- Key "aws.dynamodb.table_names" where
  AWS_DYNAMODB_TABLE_NAMES = Text -> Key (AttrVals Text)
forall a. Text -> Key a
Key Text
"aws.dynamodb.table_names"

{-|
The JSON-serialized value of each item in the @ConsumedCapacity@ response field.
-}
pattern AWS_DYNAMODB_CONSUMED_CAPACITY :: Key (AttrVals Text)
pattern $mAWS_DYNAMODB_CONSUMED_CAPACITY :: forall {r}.
Key (AttrVals Text) -> ((# #) -> r) -> ((# #) -> r) -> r
$bAWS_DYNAMODB_CONSUMED_CAPACITY :: Key (AttrVals Text)
AWS_DYNAMODB_CONSUMED_CAPACITY <- Key "aws.dynamodb.consumed_capacity" where
  AWS_DYNAMODB_CONSUMED_CAPACITY = Text -> Key (AttrVals Text)
forall a. Text -> Key a
Key Text
"aws.dynamodb.consumed_capacity"

{-|
The JSON-serialized value of the @ItemCollectionMetrics@ response field.
-}
pattern AWS_DYNAMODB_ITEM_COLLECTION_METRICS :: Key Text
pattern $mAWS_DYNAMODB_ITEM_COLLECTION_METRICS :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bAWS_DYNAMODB_ITEM_COLLECTION_METRICS :: Key Text
AWS_DYNAMODB_ITEM_COLLECTION_METRICS <- Key "aws.dynamodb.item_collection_metrics" where
  AWS_DYNAMODB_ITEM_COLLECTION_METRICS = Text -> Key Text
forall a. Text -> Key a
Key Text
"aws.dynamodb.item_collection_metrics"

{-|
The value of the @ProvisionedThroughput.ReadCapacityUnits@ request parameter.
-}
pattern AWS_DYNAMODB_PROVISIONED_READ_CAPACITY :: Key Double
pattern $mAWS_DYNAMODB_PROVISIONED_READ_CAPACITY :: forall {r}. Key Double -> ((# #) -> r) -> ((# #) -> r) -> r
$bAWS_DYNAMODB_PROVISIONED_READ_CAPACITY :: Key Double
AWS_DYNAMODB_PROVISIONED_READ_CAPACITY <- Key "aws.dynamodb.provisioned_read_capacity" where
  AWS_DYNAMODB_PROVISIONED_READ_CAPACITY = Text -> Key Double
forall a. Text -> Key a
Key Text
"aws.dynamodb.provisioned_read_capacity"

{-|
The value of the @ProvisionedThroughput.WriteCapacityUnits@ request parameter.
-}
pattern AWS_DYNAMODB_PROVISIONED_WRITE_CAPACITY :: Key Double
pattern $mAWS_DYNAMODB_PROVISIONED_WRITE_CAPACITY :: forall {r}. Key Double -> ((# #) -> r) -> ((# #) -> r) -> r
$bAWS_DYNAMODB_PROVISIONED_WRITE_CAPACITY :: Key Double
AWS_DYNAMODB_PROVISIONED_WRITE_CAPACITY <- Key "aws.dynamodb.provisioned_write_capacity" where
  AWS_DYNAMODB_PROVISIONED_WRITE_CAPACITY = Text -> Key Double
forall a. Text -> Key a
Key Text
"aws.dynamodb.provisioned_write_capacity"

{-|
The value of the @ConsistentRead@ request parameter.
-}
pattern AWS_DYNAMODB_CONSISTENT_READ :: Key Bool
pattern $mAWS_DYNAMODB_CONSISTENT_READ :: forall {r}. Key Bool -> ((# #) -> r) -> ((# #) -> r) -> r
$bAWS_DYNAMODB_CONSISTENT_READ :: Key Bool
AWS_DYNAMODB_CONSISTENT_READ <- Key "aws.dynamodb.consistent_read" where
  AWS_DYNAMODB_CONSISTENT_READ = Text -> Key Bool
forall a. Text -> Key a
Key Text
"aws.dynamodb.consistent_read"

{-|
The value of the @ProjectionExpression@ request parameter.
-}
pattern AWS_DYNAMODB_PROJECTION :: Key Text
pattern $mAWS_DYNAMODB_PROJECTION :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bAWS_DYNAMODB_PROJECTION :: Key Text
AWS_DYNAMODB_PROJECTION <- Key "aws.dynamodb.projection" where
  AWS_DYNAMODB_PROJECTION = Text -> Key Text
forall a. Text -> Key a
Key Text
"aws.dynamodb.projection"

{-|
The value of the @Limit@ request parameter.
-}
pattern AWS_DYNAMODB_LIMIT :: Key Int64
pattern $mAWS_DYNAMODB_LIMIT :: forall {r}. Key Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bAWS_DYNAMODB_LIMIT :: Key Int64
AWS_DYNAMODB_LIMIT <- Key "aws.dynamodb.limit" where
  AWS_DYNAMODB_LIMIT = Text -> Key Int64
forall a. Text -> Key a
Key Text
"aws.dynamodb.limit"

{-|
The value of the @AttributesToGet@ request parameter.
-}
pattern AWS_DYNAMODB_ATTRIBUTES_TO_GET :: Key (AttrVals Text)
pattern $mAWS_DYNAMODB_ATTRIBUTES_TO_GET :: forall {r}.
Key (AttrVals Text) -> ((# #) -> r) -> ((# #) -> r) -> r
$bAWS_DYNAMODB_ATTRIBUTES_TO_GET :: Key (AttrVals Text)
AWS_DYNAMODB_ATTRIBUTES_TO_GET <- Key "aws.dynamodb.attributes_to_get" where
  AWS_DYNAMODB_ATTRIBUTES_TO_GET = Text -> Key (AttrVals Text)
forall a. Text -> Key a
Key Text
"aws.dynamodb.attributes_to_get"

{-|
The value of the @IndexName@ request parameter.
-}
pattern AWS_DYNAMODB_INDEX_NAME :: Key Text
pattern $mAWS_DYNAMODB_INDEX_NAME :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bAWS_DYNAMODB_INDEX_NAME :: Key Text
AWS_DYNAMODB_INDEX_NAME <- Key "aws.dynamodb.index_name" where
  AWS_DYNAMODB_INDEX_NAME = Text -> Key Text
forall a. Text -> Key a
Key Text
"aws.dynamodb.index_name"

{-|
The value of the @Select@ request parameter.
-}
pattern AWS_DYNAMODB_SELECT :: Key Text
pattern $mAWS_DYNAMODB_SELECT :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bAWS_DYNAMODB_SELECT :: Key Text
AWS_DYNAMODB_SELECT <- Key "aws.dynamodb.select" where
  AWS_DYNAMODB_SELECT = Text -> Key Text
forall a. Text -> Key a
Key Text
"aws.dynamodb.select"

{-|
The JSON-serialized value of each item of the @GlobalSecondaryIndexes@ request field
-}
pattern AWS_DYNAMODB_GLOBAL_SECONDARY_INDEXES :: Key (AttrVals Text)
pattern $mAWS_DYNAMODB_GLOBAL_SECONDARY_INDEXES :: forall {r}.
Key (AttrVals Text) -> ((# #) -> r) -> ((# #) -> r) -> r
$bAWS_DYNAMODB_GLOBAL_SECONDARY_INDEXES :: Key (AttrVals Text)
AWS_DYNAMODB_GLOBAL_SECONDARY_INDEXES <- Key "aws.dynamodb.global_secondary_indexes" where
  AWS_DYNAMODB_GLOBAL_SECONDARY_INDEXES = Text -> Key (AttrVals Text)
forall a. Text -> Key a
Key Text
"aws.dynamodb.global_secondary_indexes"

{-|
The JSON-serialized value of each item of the @LocalSecondaryIndexes@ request field.
-}
pattern AWS_DYNAMODB_LOCAL_SECONDARY_INDEXES :: Key (AttrVals Text)
pattern $mAWS_DYNAMODB_LOCAL_SECONDARY_INDEXES :: forall {r}.
Key (AttrVals Text) -> ((# #) -> r) -> ((# #) -> r) -> r
$bAWS_DYNAMODB_LOCAL_SECONDARY_INDEXES :: Key (AttrVals Text)
AWS_DYNAMODB_LOCAL_SECONDARY_INDEXES <- Key "aws.dynamodb.local_secondary_indexes" where
  AWS_DYNAMODB_LOCAL_SECONDARY_INDEXES = Text -> Key (AttrVals Text)
forall a. Text -> Key a
Key Text
"aws.dynamodb.local_secondary_indexes"

{-|
The value of the @ExclusiveStartTableName@ request parameter.
-}
pattern AWS_DYNAMODB_EXCLUSIVE_START_TABLE :: Key Text
pattern $mAWS_DYNAMODB_EXCLUSIVE_START_TABLE :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bAWS_DYNAMODB_EXCLUSIVE_START_TABLE :: Key Text
AWS_DYNAMODB_EXCLUSIVE_START_TABLE <- Key "aws.dynamodb.exclusive_start_table" where
  AWS_DYNAMODB_EXCLUSIVE_START_TABLE = Text -> Key Text
forall a. Text -> Key a
Key Text
"aws.dynamodb.exclusive_start_table"

{-|
The the number of items in the @TableNames@ response parameter.
-}
pattern AWS_DYNAMODB_TABLE_COUNT :: Key Int64
pattern $mAWS_DYNAMODB_TABLE_COUNT :: forall {r}. Key Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bAWS_DYNAMODB_TABLE_COUNT :: Key Int64
AWS_DYNAMODB_TABLE_COUNT <- Key "aws.dynamodb.table_count" where
  AWS_DYNAMODB_TABLE_COUNT = Text -> Key Int64
forall a. Text -> Key a
Key Text
"aws.dynamodb.table_count"

{-|
The value of the @ScanIndexForward@ request parameter.
-}
pattern AWS_DYNAMODB_SCAN_FORWARD :: Key Bool
pattern $mAWS_DYNAMODB_SCAN_FORWARD :: forall {r}. Key Bool -> ((# #) -> r) -> ((# #) -> r) -> r
$bAWS_DYNAMODB_SCAN_FORWARD :: Key Bool
AWS_DYNAMODB_SCAN_FORWARD <- Key "aws.dynamodb.scan_forward" where
  AWS_DYNAMODB_SCAN_FORWARD = Text -> Key Bool
forall a. Text -> Key a
Key Text
"aws.dynamodb.scan_forward"

{-|
The value of the @Segment@ request parameter.
-}
pattern AWS_DYNAMODB_SEGMENT :: Key Int64
pattern $mAWS_DYNAMODB_SEGMENT :: forall {r}. Key Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bAWS_DYNAMODB_SEGMENT :: Key Int64
AWS_DYNAMODB_SEGMENT <- Key "aws.dynamodb.segment" where
  AWS_DYNAMODB_SEGMENT = Text -> Key Int64
forall a. Text -> Key a
Key Text
"aws.dynamodb.segment"

{-|
The value of the @TotalSegments@ request parameter.
-}
pattern AWS_DYNAMODB_TOTAL_SEGMENTS :: Key Int64
pattern $mAWS_DYNAMODB_TOTAL_SEGMENTS :: forall {r}. Key Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bAWS_DYNAMODB_TOTAL_SEGMENTS :: Key Int64
AWS_DYNAMODB_TOTAL_SEGMENTS <- Key "aws.dynamodb.total_segments" where
  AWS_DYNAMODB_TOTAL_SEGMENTS = Text -> Key Int64
forall a. Text -> Key a
Key Text
"aws.dynamodb.total_segments"

{-|
The value of the @Count@ response parameter.
-}
pattern AWS_DYNAMODB_COUNT :: Key Int64
pattern $mAWS_DYNAMODB_COUNT :: forall {r}. Key Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bAWS_DYNAMODB_COUNT :: Key Int64
AWS_DYNAMODB_COUNT <- Key "aws.dynamodb.count" where
  AWS_DYNAMODB_COUNT = Text -> Key Int64
forall a. Text -> Key a
Key Text
"aws.dynamodb.count"

{-|
The value of the @ScannedCount@ response parameter.
-}
pattern AWS_DYNAMODB_SCANNED_COUNT :: Key Int64
pattern $mAWS_DYNAMODB_SCANNED_COUNT :: forall {r}. Key Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bAWS_DYNAMODB_SCANNED_COUNT :: Key Int64
AWS_DYNAMODB_SCANNED_COUNT <- Key "aws.dynamodb.scanned_count" where
  AWS_DYNAMODB_SCANNED_COUNT = Text -> Key Int64
forall a. Text -> Key a
Key Text
"aws.dynamodb.scanned_count"

{-|
The JSON-serialized value of each item in the @AttributeDefinitions@ request field.
-}
pattern AWS_DYNAMODB_ATTRIBUTE_DEFINITIONS :: Key (AttrVals Text)
pattern $mAWS_DYNAMODB_ATTRIBUTE_DEFINITIONS :: forall {r}.
Key (AttrVals Text) -> ((# #) -> r) -> ((# #) -> r) -> r
$bAWS_DYNAMODB_ATTRIBUTE_DEFINITIONS :: Key (AttrVals Text)
AWS_DYNAMODB_ATTRIBUTE_DEFINITIONS <- Key "aws.dynamodb.attribute_definitions" where
  AWS_DYNAMODB_ATTRIBUTE_DEFINITIONS = Text -> Key (AttrVals Text)
forall a. Text -> Key a
Key Text
"aws.dynamodb.attribute_definitions"

{-|
The JSON-serialized value of each item in the the @GlobalSecondaryIndexUpdates@ request field.
-}
pattern AWS_DYNAMODB_GLOBAL_SECONDARY_INDEX_UPDATES :: Key (AttrVals Text)
pattern $mAWS_DYNAMODB_GLOBAL_SECONDARY_INDEX_UPDATES :: forall {r}.
Key (AttrVals Text) -> ((# #) -> r) -> ((# #) -> r) -> r
$bAWS_DYNAMODB_GLOBAL_SECONDARY_INDEX_UPDATES :: Key (AttrVals Text)
AWS_DYNAMODB_GLOBAL_SECONDARY_INDEX_UPDATES <- Key "aws.dynamodb.global_secondary_index_updates" where
  AWS_DYNAMODB_GLOBAL_SECONDARY_INDEX_UPDATES = Text -> Key (AttrVals Text)
forall a. Text -> Key a
Key Text
"aws.dynamodb.global_secondary_index_updates"

{-|
A string identifying the messaging system.
-}
pattern MESSAGING_SYSTEM :: Key Text
pattern $mMESSAGING_SYSTEM :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGING_SYSTEM :: Key Text
MESSAGING_SYSTEM <- Key "messaging.system" where
  MESSAGING_SYSTEM = Text -> Key Text
forall a. Text -> Key a
Key Text
"messaging.system"

{-|
The message destination name. This might be equal to the span name but is required nevertheless.
-}
pattern MESSAGING_DESTINATION :: Key Text
pattern $mMESSAGING_DESTINATION :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGING_DESTINATION :: Key Text
MESSAGING_DESTINATION <- Key "messaging.destination" where
  MESSAGING_DESTINATION = Text -> Key Text
forall a. Text -> Key a
Key Text
"messaging.destination"

{-|
The kind of message destination
-}
pattern MESSAGING_DESTINATION_KIND :: Key Text
pattern $mMESSAGING_DESTINATION_KIND :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGING_DESTINATION_KIND :: Key Text
MESSAGING_DESTINATION_KIND <- Key "messaging.destination_kind" where
  MESSAGING_DESTINATION_KIND = Text -> Key Text
forall a. Text -> Key a
Key Text
"messaging.destination_kind"

{-|
A boolean that is true if the message destination is temporary.
-}
pattern MESSAGING_TEMP_DESTINATION :: Key Bool
pattern $mMESSAGING_TEMP_DESTINATION :: forall {r}. Key Bool -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGING_TEMP_DESTINATION :: Key Bool
MESSAGING_TEMP_DESTINATION <- Key "messaging.temp_destination" where
  MESSAGING_TEMP_DESTINATION = Text -> Key Bool
forall a. Text -> Key a
Key Text
"messaging.temp_destination"

{-|
The name of the transport protocol.
-}
pattern MESSAGING_PROTOCOL :: Key Text
pattern $mMESSAGING_PROTOCOL :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGING_PROTOCOL :: Key Text
MESSAGING_PROTOCOL <- Key "messaging.protocol" where
  MESSAGING_PROTOCOL = Text -> Key Text
forall a. Text -> Key a
Key Text
"messaging.protocol"

{-|
The version of the transport protocol.
-}
pattern MESSAGING_PROTOCOL_VERSION :: Key Text
pattern $mMESSAGING_PROTOCOL_VERSION :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGING_PROTOCOL_VERSION :: Key Text
MESSAGING_PROTOCOL_VERSION <- Key "messaging.protocol_version" where
  MESSAGING_PROTOCOL_VERSION = Text -> Key Text
forall a. Text -> Key a
Key Text
"messaging.protocol_version"

{-|
Connection string.
-}
pattern MESSAGING_URL :: Key Text
pattern $mMESSAGING_URL :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGING_URL :: Key Text
MESSAGING_URL <- Key "messaging.url" where
  MESSAGING_URL = Text -> Key Text
forall a. Text -> Key a
Key Text
"messaging.url"

{-|
A value used by the messaging system as an identifier for the message, represented as a string.
-}
pattern MESSAGING_MESSAGE_ID :: Key Text
pattern $mMESSAGING_MESSAGE_ID :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGING_MESSAGE_ID :: Key Text
MESSAGING_MESSAGE_ID <- Key "messaging.message_id" where
  MESSAGING_MESSAGE_ID = Text -> Key Text
forall a. Text -> Key a
Key Text
"messaging.message_id"

{-|
The <#conversations> identifying the conversation to which the message belongs, represented as a string. Sometimes called &quot;Correlation ID&quot;.
-}
pattern MESSAGING_CONVERSATION_ID :: Key Text
pattern $mMESSAGING_CONVERSATION_ID :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGING_CONVERSATION_ID :: Key Text
MESSAGING_CONVERSATION_ID <- Key "messaging.conversation_id" where
  MESSAGING_CONVERSATION_ID = Text -> Key Text
forall a. Text -> Key a
Key Text
"messaging.conversation_id"

{-|
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.
-}
pattern MESSAGING_MESSAGE_PAYLOAD_SIZE_BYTES :: Key Int64
pattern $mMESSAGING_MESSAGE_PAYLOAD_SIZE_BYTES :: forall {r}. Key Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGING_MESSAGE_PAYLOAD_SIZE_BYTES :: Key Int64
MESSAGING_MESSAGE_PAYLOAD_SIZE_BYTES <- Key "messaging.message_payload_size_bytes" where
  MESSAGING_MESSAGE_PAYLOAD_SIZE_BYTES = Text -> Key Int64
forall a. Text -> Key a
Key Text
"messaging.message_payload_size_bytes"

{-|
The compressed size of the message payload in bytes.
-}
pattern MESSAGING_MESSAGE_PAYLOAD_COMPRESSED_SIZE_BYTES :: Key Int64
pattern $mMESSAGING_MESSAGE_PAYLOAD_COMPRESSED_SIZE_BYTES :: forall {r}. Key Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGING_MESSAGE_PAYLOAD_COMPRESSED_SIZE_BYTES :: Key Int64
MESSAGING_MESSAGE_PAYLOAD_COMPRESSED_SIZE_BYTES <- Key "messaging.message_payload_compressed_size_bytes" where
  MESSAGING_MESSAGE_PAYLOAD_COMPRESSED_SIZE_BYTES = Text -> Key Int64
forall a. Text -> Key a
Key Text
"messaging.message_payload_compressed_size_bytes"

{-|
A string identifying the kind of message consumption as defined in the <#operation-names> section above. If the operation is &quot;send&quot;, this attribute MUST NOT be set, since the operation can be inferred from the span kind in that case.
-}
pattern MESSAGING_OPERATION :: Key Text
pattern $mMESSAGING_OPERATION :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGING_OPERATION :: Key Text
MESSAGING_OPERATION <- Key "messaging.operation" where
  MESSAGING_OPERATION = Text -> Key Text
forall a. Text -> Key a
Key Text
"messaging.operation"

{-|
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.
-}
pattern MESSAGING_CONSUMER_ID :: Key Text
pattern $mMESSAGING_CONSUMER_ID :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGING_CONSUMER_ID :: Key Text
MESSAGING_CONSUMER_ID <- Key "messaging.consumer_id" where
  MESSAGING_CONSUMER_ID = Text -> Key Text
forall a. Text -> Key a
Key Text
"messaging.consumer_id"

{-|
RabbitMQ message routing key.
-}
pattern MESSAGING_RABBITMQ_ROUTING_KEY :: Key Text
pattern $mMESSAGING_RABBITMQ_ROUTING_KEY :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGING_RABBITMQ_ROUTING_KEY :: Key Text
MESSAGING_RABBITMQ_ROUTING_KEY <- Key "messaging.rabbitmq.routing_key" where
  MESSAGING_RABBITMQ_ROUTING_KEY = Text -> Key Text
forall a. Text -> Key a
Key Text
"messaging.rabbitmq.routing_key"

{-|
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.

[Notes]: 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.
-}
pattern MESSAGING_KAFKA_MESSAGE_KEY :: Key Text
pattern $mMESSAGING_KAFKA_MESSAGE_KEY :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGING_KAFKA_MESSAGE_KEY :: Key Text
MESSAGING_KAFKA_MESSAGE_KEY <- Key "messaging.kafka.message_key" where
  MESSAGING_KAFKA_MESSAGE_KEY = Text -> Key Text
forall a. Text -> Key a
Key Text
"messaging.kafka.message_key"

{-|
Name of the Kafka Consumer Group that is handling the message. Only applies to consumers, not producers.
-}
pattern MESSAGING_KAFKA_CONSUMER_GROUP :: Key Text
pattern $mMESSAGING_KAFKA_CONSUMER_GROUP :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGING_KAFKA_CONSUMER_GROUP :: Key Text
MESSAGING_KAFKA_CONSUMER_GROUP <- Key "messaging.kafka.consumer_group" where
  MESSAGING_KAFKA_CONSUMER_GROUP = Text -> Key Text
forall a. Text -> Key a
Key Text
"messaging.kafka.consumer_group"

{-|
Client Id for the Consumer or Producer that is handling the message.
-}
pattern MESSAGING_KAFKA_CLIENT_ID :: Key Text
pattern $mMESSAGING_KAFKA_CLIENT_ID :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGING_KAFKA_CLIENT_ID :: Key Text
MESSAGING_KAFKA_CLIENT_ID <- Key "messaging.kafka.client_id" where
  MESSAGING_KAFKA_CLIENT_ID = Text -> Key Text
forall a. Text -> Key a
Key Text
"messaging.kafka.client_id"

{-|
Partition the message is sent to.
-}
pattern MESSAGING_KAFKA_PARTITION :: Key Int64
pattern $mMESSAGING_KAFKA_PARTITION :: forall {r}. Key Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGING_KAFKA_PARTITION :: Key Int64
MESSAGING_KAFKA_PARTITION <- Key "messaging.kafka.partition" where
  MESSAGING_KAFKA_PARTITION = Text -> Key Int64
forall a. Text -> Key a
Key Text
"messaging.kafka.partition"

{-|
A boolean that is true if the message is a tombstone.
-}
pattern MESSAGING_KAFKA_TOMBSTONE :: Key Bool
pattern $mMESSAGING_KAFKA_TOMBSTONE :: forall {r}. Key Bool -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGING_KAFKA_TOMBSTONE :: Key Bool
MESSAGING_KAFKA_TOMBSTONE <- Key "messaging.kafka.tombstone" where
  MESSAGING_KAFKA_TOMBSTONE = Text -> Key Bool
forall a. Text -> Key a
Key Text
"messaging.kafka.tombstone"

{-|
Namespace of RocketMQ resources, resources in different namespaces are individual.
-}
pattern MESSAGING_ROCKETMQ_NAMESPACE :: Key Text
pattern $mMESSAGING_ROCKETMQ_NAMESPACE :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGING_ROCKETMQ_NAMESPACE :: Key Text
MESSAGING_ROCKETMQ_NAMESPACE <- Key "messaging.rocketmq.namespace" where
  MESSAGING_ROCKETMQ_NAMESPACE = Text -> Key Text
forall a. Text -> Key a
Key Text
"messaging.rocketmq.namespace"

{-|
Name of the RocketMQ producer/consumer group that is handling the message. The client type is identified by the SpanKind.
-}
pattern MESSAGING_ROCKETMQ_CLIENT_GROUP :: Key Text
pattern $mMESSAGING_ROCKETMQ_CLIENT_GROUP :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGING_ROCKETMQ_CLIENT_GROUP :: Key Text
MESSAGING_ROCKETMQ_CLIENT_GROUP <- Key "messaging.rocketmq.client_group" where
  MESSAGING_ROCKETMQ_CLIENT_GROUP = Text -> Key Text
forall a. Text -> Key a
Key Text
"messaging.rocketmq.client_group"

{-|
The unique identifier for each client.
-}
pattern MESSAGING_ROCKETMQ_CLIENT_ID :: Key Text
pattern $mMESSAGING_ROCKETMQ_CLIENT_ID :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGING_ROCKETMQ_CLIENT_ID :: Key Text
MESSAGING_ROCKETMQ_CLIENT_ID <- Key "messaging.rocketmq.client_id" where
  MESSAGING_ROCKETMQ_CLIENT_ID = Text -> Key Text
forall a. Text -> Key a
Key Text
"messaging.rocketmq.client_id"

{-|
Type of message.
-}
pattern MESSAGING_ROCKETMQ_MESSAGE_TYPE :: Key Text
pattern $mMESSAGING_ROCKETMQ_MESSAGE_TYPE :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGING_ROCKETMQ_MESSAGE_TYPE :: Key Text
MESSAGING_ROCKETMQ_MESSAGE_TYPE <- Key "messaging.rocketmq.message_type" where
  MESSAGING_ROCKETMQ_MESSAGE_TYPE = Text -> Key Text
forall a. Text -> Key a
Key Text
"messaging.rocketmq.message_type"

{-|
The secondary classifier of message besides topic.
-}
pattern MESSAGING_ROCKETMQ_MESSAGE_TAG :: Key Text
pattern $mMESSAGING_ROCKETMQ_MESSAGE_TAG :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGING_ROCKETMQ_MESSAGE_TAG :: Key Text
MESSAGING_ROCKETMQ_MESSAGE_TAG <- Key "messaging.rocketmq.message_tag" where
  MESSAGING_ROCKETMQ_MESSAGE_TAG = Text -> Key Text
forall a. Text -> Key a
Key Text
"messaging.rocketmq.message_tag"

{-|
Key(s) of message, another way to mark message besides message id.
-}
pattern MESSAGING_ROCKETMQ_MESSAGE_KEYS :: Key (AttrVals Text)
pattern $mMESSAGING_ROCKETMQ_MESSAGE_KEYS :: forall {r}.
Key (AttrVals Text) -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGING_ROCKETMQ_MESSAGE_KEYS :: Key (AttrVals Text)
MESSAGING_ROCKETMQ_MESSAGE_KEYS <- Key "messaging.rocketmq.message_keys" where
  MESSAGING_ROCKETMQ_MESSAGE_KEYS = Text -> Key (AttrVals Text)
forall a. Text -> Key a
Key Text
"messaging.rocketmq.message_keys"

{-|
Model of message consumption. This only applies to consumer spans.
-}
pattern MESSAGING_ROCKETMQ_CONSUMPTION_MODEL :: Key Text
pattern $mMESSAGING_ROCKETMQ_CONSUMPTION_MODEL :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGING_ROCKETMQ_CONSUMPTION_MODEL :: Key Text
MESSAGING_ROCKETMQ_CONSUMPTION_MODEL <- Key "messaging.rocketmq.consumption_model" where
  MESSAGING_ROCKETMQ_CONSUMPTION_MODEL = Text -> Key Text
forall a. Text -> Key a
Key Text
"messaging.rocketmq.consumption_model"

{-|
A string identifying the remoting system. See below for a list of well-known identifiers.
-}
pattern RPC_SYSTEM :: Key Text
pattern $mRPC_SYSTEM :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bRPC_SYSTEM :: Key Text
RPC_SYSTEM <- Key "rpc.system" where
  RPC_SYSTEM = Text -> Key Text
forall a. Text -> Key a
Key Text
"rpc.system"

{-|
The full (logical) name of the service being called, including its package name, if applicable.

[Notes]: 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).
-}
pattern RPC_SERVICE :: Key Text
pattern $mRPC_SERVICE :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bRPC_SERVICE :: Key Text
RPC_SERVICE <- Key "rpc.service" where
  RPC_SERVICE = Text -> Key Text
forall a. Text -> Key a
Key Text
"rpc.service"

{-|
The name of the (logical) method being called, must be equal to the $method part in the span name.

[Notes]: 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).
-}
pattern RPC_METHOD :: Key Text
pattern $mRPC_METHOD :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bRPC_METHOD :: Key Text
RPC_METHOD <- Key "rpc.method" where
  RPC_METHOD = Text -> Key Text
forall a. Text -> Key a
Key Text
"rpc.method"

{-|
The <https://github.com/grpc/grpc/blob/v1.33.2/doc/statuscodes.md> of the gRPC request.
-}
pattern RPC_GRPC_STATUS_CODE :: Key Int64
pattern $mRPC_GRPC_STATUS_CODE :: forall {r}. Key Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bRPC_GRPC_STATUS_CODE :: Key Int64
RPC_GRPC_STATUS_CODE <- Key "rpc.grpc.status_code" where
  RPC_GRPC_STATUS_CODE = Text -> Key Int64
forall a. Text -> Key a
Key Text
"rpc.grpc.status_code"

{-|
Protocol version as in @jsonrpc@ property of request/response. Since JSON-RPC 1.0 does not specify this, the value can be omitted.
-}
pattern RPC_JSONRPC_VERSION :: Key Text
pattern $mRPC_JSONRPC_VERSION :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bRPC_JSONRPC_VERSION :: Key Text
RPC_JSONRPC_VERSION <- Key "rpc.jsonrpc.version" where
  RPC_JSONRPC_VERSION = Text -> Key Text
forall a. Text -> Key a
Key Text
"rpc.jsonrpc.version"

{-|
@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.
-}
pattern RPC_JSONRPC_REQUEST_ID :: Key Text
pattern $mRPC_JSONRPC_REQUEST_ID :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bRPC_JSONRPC_REQUEST_ID :: Key Text
RPC_JSONRPC_REQUEST_ID <- Key "rpc.jsonrpc.request_id" where
  RPC_JSONRPC_REQUEST_ID = Text -> Key Text
forall a. Text -> Key a
Key Text
"rpc.jsonrpc.request_id"

{-|
@error.code@ property of response if it is an error response.
-}
pattern RPC_JSONRPC_ERROR_CODE :: Key Int64
pattern $mRPC_JSONRPC_ERROR_CODE :: forall {r}. Key Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bRPC_JSONRPC_ERROR_CODE :: Key Int64
RPC_JSONRPC_ERROR_CODE <- Key "rpc.jsonrpc.error_code" where
  RPC_JSONRPC_ERROR_CODE = Text -> Key Int64
forall a. Text -> Key a
Key Text
"rpc.jsonrpc.error_code"

{-|
@error.message@ property of response if it is an error response.
-}
pattern RPC_JSONRPC_ERROR_MESSAGE :: Key Text
pattern $mRPC_JSONRPC_ERROR_MESSAGE :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bRPC_JSONRPC_ERROR_MESSAGE :: Key Text
RPC_JSONRPC_ERROR_MESSAGE <- Key "rpc.jsonrpc.error_message" where
  RPC_JSONRPC_ERROR_MESSAGE = Text -> Key Text
forall a. Text -> Key a
Key Text
"rpc.jsonrpc.error_message"

{-|
Whether this is a received or sent message.
-}
pattern MESSAGE_TYPE :: Key Text
pattern $mMESSAGE_TYPE :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGE_TYPE :: Key Text
MESSAGE_TYPE <- Key "message.type" where
  MESSAGE_TYPE = Text -> Key Text
forall a. Text -> Key a
Key Text
"message.type"

{-|
MUST be calculated as two different counters starting from @1@ one for sent messages and one for received message.

[Notes]: This way we guarantee that the values will be consistent between different implementations.
-}
pattern MESSAGE_ID :: Key Int64
pattern $mMESSAGE_ID :: forall {r}. Key Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGE_ID :: Key Int64
MESSAGE_ID <- Key "message.id" where
  MESSAGE_ID = Text -> Key Int64
forall a. Text -> Key a
Key Text
"message.id"

{-|
Compressed size of the message in bytes.
-}
pattern MESSAGE_COMPRESSED_SIZE :: Key Int64
pattern $mMESSAGE_COMPRESSED_SIZE :: forall {r}. Key Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGE_COMPRESSED_SIZE :: Key Int64
MESSAGE_COMPRESSED_SIZE <- Key "message.compressed_size" where
  MESSAGE_COMPRESSED_SIZE = Text -> Key Int64
forall a. Text -> Key a
Key Text
"message.compressed_size"

{-|
Uncompressed size of the message in bytes.
-}
pattern MESSAGE_UNCOMPRESSED_SIZE :: Key Int64
pattern $mMESSAGE_UNCOMPRESSED_SIZE :: forall {r}. Key Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bMESSAGE_UNCOMPRESSED_SIZE :: Key Int64
MESSAGE_UNCOMPRESSED_SIZE <- Key "message.uncompressed_size" where
  MESSAGE_UNCOMPRESSED_SIZE = Text -> Key Int64
forall a. Text -> Key a
Key Text
"message.uncompressed_size"
data OpentracingRefType
  = OpentracingRefTypeChildOf -- ^ The parent Span depends on the child Span in some capacity.
  | OpentracingRefTypeFollowsFrom -- ^ The parent Span does not depend in any way on the result of the child Span.

instance ToAttrVal OpentracingRefType Text where
  toAttrVal :: OpentracingRefType -> Text
toAttrVal = \case
    OpentracingRefType
OpentracingRefTypeChildOf -> Text
"child_of"
    OpentracingRefType
OpentracingRefTypeFollowsFrom -> Text
"follows_from"

data DbSystem
  = DbSystemOtherSql -- ^ Some other SQL database. Fallback only. See notes.
  | DbSystemMssql -- ^ Microsoft SQL Server.
  | DbSystemMysql -- ^ MySQL.
  | DbSystemOracle -- ^ Oracle Database.
  | DbSystemDb2 -- ^ IBM Db2.
  | DbSystemPostgresql -- ^ PostgreSQL.
  | DbSystemRedshift -- ^ Amazon Redshift.
  | DbSystemHive -- ^ Apache Hive.
  | DbSystemCloudscape -- ^ Cloudscape.
  | DbSystemHsqldb -- ^ HyperSQL DataBase.
  | DbSystemProgress -- ^ Progress Database.
  | DbSystemMaxdb -- ^ SAP MaxDB.
  | DbSystemHanadb -- ^ SAP HANA.
  | DbSystemIngres -- ^ Ingres.
  | DbSystemFirstsql -- ^ FirstSQL.
  | DbSystemEdb -- ^ EnterpriseDB.
  | DbSystemCache -- ^ InterSystems Caché.
  | DbSystemAdabas -- ^ Adabas (Adaptable Database System).
  | DbSystemFirebird -- ^ Firebird.
  | DbSystemDerby -- ^ Apache Derby.
  | DbSystemFilemaker -- ^ FileMaker.
  | DbSystemInformix -- ^ Informix.
  | DbSystemInstantdb -- ^ InstantDB.
  | DbSystemInterbase -- ^ InterBase.
  | DbSystemMariadb -- ^ MariaDB.
  | DbSystemNetezza -- ^ Netezza.
  | DbSystemPervasive -- ^ Pervasive PSQL.
  | DbSystemPointbase -- ^ PointBase.
  | DbSystemSqlite -- ^ SQLite.
  | DbSystemSybase -- ^ Sybase.
  | DbSystemTeradata -- ^ Teradata.
  | DbSystemVertica -- ^ Vertica.
  | DbSystemH2 -- ^ H2.
  | DbSystemColdfusion -- ^ ColdFusion IMQ.
  | DbSystemCassandra -- ^ Apache Cassandra.
  | DbSystemHbase -- ^ Apache HBase.
  | DbSystemMongodb -- ^ MongoDB.
  | DbSystemRedis -- ^ Redis.
  | DbSystemCouchbase -- ^ Couchbase.
  | DbSystemCouchdb -- ^ CouchDB.
  | DbSystemCosmosdb -- ^ Microsoft Azure Cosmos DB.
  | DbSystemDynamodb -- ^ Amazon DynamoDB.
  | DbSystemNeo4j -- ^ Neo4j.
  | DbSystemGeode -- ^ Apache Geode.
  | DbSystemElasticsearch -- ^ Elasticsearch.
  | DbSystemMemcached -- ^ Memcached.
  | DbSystemCockroachdb -- ^ CockroachDB.

instance ToAttrVal DbSystem Text where
  toAttrVal :: DbSystem -> Text
toAttrVal = \case
    DbSystem
DbSystemOtherSql -> Text
"other_sql"
    DbSystem
DbSystemMssql -> Text
"mssql"
    DbSystem
DbSystemMysql -> Text
"mysql"
    DbSystem
DbSystemOracle -> Text
"oracle"
    DbSystem
DbSystemDb2 -> Text
"db2"
    DbSystem
DbSystemPostgresql -> Text
"postgresql"
    DbSystem
DbSystemRedshift -> Text
"redshift"
    DbSystem
DbSystemHive -> Text
"hive"
    DbSystem
DbSystemCloudscape -> Text
"cloudscape"
    DbSystem
DbSystemHsqldb -> Text
"hsqldb"
    DbSystem
DbSystemProgress -> Text
"progress"
    DbSystem
DbSystemMaxdb -> Text
"maxdb"
    DbSystem
DbSystemHanadb -> Text
"hanadb"
    DbSystem
DbSystemIngres -> Text
"ingres"
    DbSystem
DbSystemFirstsql -> Text
"firstsql"
    DbSystem
DbSystemEdb -> Text
"edb"
    DbSystem
DbSystemCache -> Text
"cache"
    DbSystem
DbSystemAdabas -> Text
"adabas"
    DbSystem
DbSystemFirebird -> Text
"firebird"
    DbSystem
DbSystemDerby -> Text
"derby"
    DbSystem
DbSystemFilemaker -> Text
"filemaker"
    DbSystem
DbSystemInformix -> Text
"informix"
    DbSystem
DbSystemInstantdb -> Text
"instantdb"
    DbSystem
DbSystemInterbase -> Text
"interbase"
    DbSystem
DbSystemMariadb -> Text
"mariadb"
    DbSystem
DbSystemNetezza -> Text
"netezza"
    DbSystem
DbSystemPervasive -> Text
"pervasive"
    DbSystem
DbSystemPointbase -> Text
"pointbase"
    DbSystem
DbSystemSqlite -> Text
"sqlite"
    DbSystem
DbSystemSybase -> Text
"sybase"
    DbSystem
DbSystemTeradata -> Text
"teradata"
    DbSystem
DbSystemVertica -> Text
"vertica"
    DbSystem
DbSystemH2 -> Text
"h2"
    DbSystem
DbSystemColdfusion -> Text
"coldfusion"
    DbSystem
DbSystemCassandra -> Text
"cassandra"
    DbSystem
DbSystemHbase -> Text
"hbase"
    DbSystem
DbSystemMongodb -> Text
"mongodb"
    DbSystem
DbSystemRedis -> Text
"redis"
    DbSystem
DbSystemCouchbase -> Text
"couchbase"
    DbSystem
DbSystemCouchdb -> Text
"couchdb"
    DbSystem
DbSystemCosmosdb -> Text
"cosmosdb"
    DbSystem
DbSystemDynamodb -> Text
"dynamodb"
    DbSystem
DbSystemNeo4j -> Text
"neo4j"
    DbSystem
DbSystemGeode -> Text
"geode"
    DbSystem
DbSystemElasticsearch -> Text
"elasticsearch"
    DbSystem
DbSystemMemcached -> Text
"memcached"
    DbSystem
DbSystemCockroachdb -> Text
"cockroachdb"

data DbCassandraConsistencyLevel
  = DbCassandraConsistencyLevelAll -- ^ all.
  | DbCassandraConsistencyLevelEachQuorum -- ^ each_quorum.
  | DbCassandraConsistencyLevelQuorum -- ^ quorum.
  | DbCassandraConsistencyLevelLocalQuorum -- ^ local_quorum.
  | DbCassandraConsistencyLevelOne -- ^ one.
  | DbCassandraConsistencyLevelTwo -- ^ two.
  | DbCassandraConsistencyLevelThree -- ^ three.
  | DbCassandraConsistencyLevelLocalOne -- ^ local_one.
  | DbCassandraConsistencyLevelAny -- ^ any.
  | DbCassandraConsistencyLevelSerial -- ^ serial.
  | DbCassandraConsistencyLevelLocalSerial -- ^ local_serial.

instance ToAttrVal DbCassandraConsistencyLevel Text where
  toAttrVal :: DbCassandraConsistencyLevel -> Text
toAttrVal = \case
    DbCassandraConsistencyLevel
DbCassandraConsistencyLevelAll -> Text
"all"
    DbCassandraConsistencyLevel
DbCassandraConsistencyLevelEachQuorum -> Text
"each_quorum"
    DbCassandraConsistencyLevel
DbCassandraConsistencyLevelQuorum -> Text
"quorum"
    DbCassandraConsistencyLevel
DbCassandraConsistencyLevelLocalQuorum -> Text
"local_quorum"
    DbCassandraConsistencyLevel
DbCassandraConsistencyLevelOne -> Text
"one"
    DbCassandraConsistencyLevel
DbCassandraConsistencyLevelTwo -> Text
"two"
    DbCassandraConsistencyLevel
DbCassandraConsistencyLevelThree -> Text
"three"
    DbCassandraConsistencyLevel
DbCassandraConsistencyLevelLocalOne -> Text
"local_one"
    DbCassandraConsistencyLevel
DbCassandraConsistencyLevelAny -> Text
"any"
    DbCassandraConsistencyLevel
DbCassandraConsistencyLevelSerial -> Text
"serial"
    DbCassandraConsistencyLevel
DbCassandraConsistencyLevelLocalSerial -> Text
"local_serial"

data FaasTrigger
  = FaasTriggerDatasource -- ^ A response to some data source operation such as a database or filesystem read/write.
  | FaasTriggerHttp -- ^ To provide an answer to an inbound HTTP request.
  | FaasTriggerPubsub -- ^ A function is set to be executed when messages are sent to a messaging system.
  | FaasTriggerTimer -- ^ A function is scheduled to be executed regularly.
  | FaasTriggerOther -- ^ If none of the others apply.

instance ToAttrVal FaasTrigger Text where
  toAttrVal :: FaasTrigger -> Text
toAttrVal = \case
    FaasTrigger
FaasTriggerDatasource -> Text
"datasource"
    FaasTrigger
FaasTriggerHttp -> Text
"http"
    FaasTrigger
FaasTriggerPubsub -> Text
"pubsub"
    FaasTrigger
FaasTriggerTimer -> Text
"timer"
    FaasTrigger
FaasTriggerOther -> Text
"other"

data FaasDocumentOperation
  = FaasDocumentOperationInsert -- ^ When a new object is created.
  | FaasDocumentOperationEdit -- ^ When an object is modified.
  | FaasDocumentOperationDelete -- ^ When an object is deleted.

instance ToAttrVal FaasDocumentOperation Text where
  toAttrVal :: FaasDocumentOperation -> Text
toAttrVal = \case
    FaasDocumentOperation
FaasDocumentOperationInsert -> Text
"insert"
    FaasDocumentOperation
FaasDocumentOperationEdit -> Text
"edit"
    FaasDocumentOperation
FaasDocumentOperationDelete -> Text
"delete"

data FaasInvokedProvider
  = FaasInvokedProviderAlibabaCloud -- ^ Alibaba Cloud.
  | FaasInvokedProviderAws -- ^ Amazon Web Services.
  | FaasInvokedProviderAzure -- ^ Microsoft Azure.
  | FaasInvokedProviderGcp -- ^ Google Cloud Platform.
  | FaasInvokedProviderTencentCloud -- ^ Tencent Cloud.

instance ToAttrVal FaasInvokedProvider Text where
  toAttrVal :: FaasInvokedProvider -> Text
toAttrVal = \case
    FaasInvokedProvider
FaasInvokedProviderAlibabaCloud -> Text
"alibaba_cloud"
    FaasInvokedProvider
FaasInvokedProviderAws -> Text
"aws"
    FaasInvokedProvider
FaasInvokedProviderAzure -> Text
"azure"
    FaasInvokedProvider
FaasInvokedProviderGcp -> Text
"gcp"
    FaasInvokedProvider
FaasInvokedProviderTencentCloud -> Text
"tencent_cloud"

data NetTransport
  = NetTransportIpTcp -- ^ ip_tcp.
  | NetTransportIpUdp -- ^ ip_udp.
  | NetTransportIp -- ^ Another IP-based protocol.
  | NetTransportUnix -- ^ Unix Domain socket. See below.
  | NetTransportPipe -- ^ Named or anonymous pipe. See note below.
  | NetTransportInproc -- ^ In-process communication.
  | NetTransportOther -- ^ Something else (non IP-based).

instance ToAttrVal NetTransport Text where
  toAttrVal :: NetTransport -> Text
toAttrVal = \case
    NetTransport
NetTransportIpTcp -> Text
"ip_tcp"
    NetTransport
NetTransportIpUdp -> Text
"ip_udp"
    NetTransport
NetTransportIp -> Text
"ip"
    NetTransport
NetTransportUnix -> Text
"unix"
    NetTransport
NetTransportPipe -> Text
"pipe"
    NetTransport
NetTransportInproc -> Text
"inproc"
    NetTransport
NetTransportOther -> Text
"other"

data NetHostConnectionType
  = NetHostConnectionTypeWifi -- ^ wifi.
  | NetHostConnectionTypeWired -- ^ wired.
  | NetHostConnectionTypeCell -- ^ cell.
  | NetHostConnectionTypeUnavailable -- ^ unavailable.
  | NetHostConnectionTypeUnknown -- ^ unknown.

instance ToAttrVal NetHostConnectionType Text where
  toAttrVal :: NetHostConnectionType -> Text
toAttrVal = \case
    NetHostConnectionType
NetHostConnectionTypeWifi -> Text
"wifi"
    NetHostConnectionType
NetHostConnectionTypeWired -> Text
"wired"
    NetHostConnectionType
NetHostConnectionTypeCell -> Text
"cell"
    NetHostConnectionType
NetHostConnectionTypeUnavailable -> Text
"unavailable"
    NetHostConnectionType
NetHostConnectionTypeUnknown -> Text
"unknown"

data NetHostConnectionSubtype
  = NetHostConnectionSubtypeGprs -- ^ GPRS.
  | NetHostConnectionSubtypeEdge -- ^ EDGE.
  | NetHostConnectionSubtypeUmts -- ^ UMTS.
  | NetHostConnectionSubtypeCdma -- ^ CDMA.
  | NetHostConnectionSubtypeEvdo0 -- ^ EVDO Rel. 0.
  | NetHostConnectionSubtypeEvdoA -- ^ EVDO Rev. A.
  | NetHostConnectionSubtypeCdma20001xrtt -- ^ CDMA2000 1XRTT.
  | NetHostConnectionSubtypeHsdpa -- ^ HSDPA.
  | NetHostConnectionSubtypeHsupa -- ^ HSUPA.
  | NetHostConnectionSubtypeHspa -- ^ HSPA.
  | NetHostConnectionSubtypeIden -- ^ IDEN.
  | NetHostConnectionSubtypeEvdoB -- ^ EVDO Rev. B.
  | NetHostConnectionSubtypeLte -- ^ LTE.
  | NetHostConnectionSubtypeEhrpd -- ^ EHRPD.
  | NetHostConnectionSubtypeHspap -- ^ HSPAP.
  | NetHostConnectionSubtypeGsm -- ^ GSM.
  | NetHostConnectionSubtypeTdScdma -- ^ TD-SCDMA.
  | NetHostConnectionSubtypeIwlan -- ^ IWLAN.
  | NetHostConnectionSubtypeNr -- ^ 5G NR (New Radio).
  | NetHostConnectionSubtypeNrnsa -- ^ 5G NRNSA (New Radio Non-Standalone).
  | NetHostConnectionSubtypeLteCa -- ^ LTE CA.

instance ToAttrVal NetHostConnectionSubtype Text where
  toAttrVal :: NetHostConnectionSubtype -> Text
toAttrVal = \case
    NetHostConnectionSubtype
NetHostConnectionSubtypeGprs -> Text
"gprs"
    NetHostConnectionSubtype
NetHostConnectionSubtypeEdge -> Text
"edge"
    NetHostConnectionSubtype
NetHostConnectionSubtypeUmts -> Text
"umts"
    NetHostConnectionSubtype
NetHostConnectionSubtypeCdma -> Text
"cdma"
    NetHostConnectionSubtype
NetHostConnectionSubtypeEvdo0 -> Text
"evdo_0"
    NetHostConnectionSubtype
NetHostConnectionSubtypeEvdoA -> Text
"evdo_a"
    NetHostConnectionSubtype
NetHostConnectionSubtypeCdma20001xrtt -> Text
"cdma2000_1xrtt"
    NetHostConnectionSubtype
NetHostConnectionSubtypeHsdpa -> Text
"hsdpa"
    NetHostConnectionSubtype
NetHostConnectionSubtypeHsupa -> Text
"hsupa"
    NetHostConnectionSubtype
NetHostConnectionSubtypeHspa -> Text
"hspa"
    NetHostConnectionSubtype
NetHostConnectionSubtypeIden -> Text
"iden"
    NetHostConnectionSubtype
NetHostConnectionSubtypeEvdoB -> Text
"evdo_b"
    NetHostConnectionSubtype
NetHostConnectionSubtypeLte -> Text
"lte"
    NetHostConnectionSubtype
NetHostConnectionSubtypeEhrpd -> Text
"ehrpd"
    NetHostConnectionSubtype
NetHostConnectionSubtypeHspap -> Text
"hspap"
    NetHostConnectionSubtype
NetHostConnectionSubtypeGsm -> Text
"gsm"
    NetHostConnectionSubtype
NetHostConnectionSubtypeTdScdma -> Text
"td_scdma"
    NetHostConnectionSubtype
NetHostConnectionSubtypeIwlan -> Text
"iwlan"
    NetHostConnectionSubtype
NetHostConnectionSubtypeNr -> Text
"nr"
    NetHostConnectionSubtype
NetHostConnectionSubtypeNrnsa -> Text
"nrnsa"
    NetHostConnectionSubtype
NetHostConnectionSubtypeLteCa -> Text
"lte_ca"

data HttpFlavor
  = HttpFlavorHttp10 -- ^ HTTP/1.0.
  | HttpFlavorHttp11 -- ^ HTTP/1.1.
  | HttpFlavorHttp20 -- ^ HTTP/2.
  | HttpFlavorHttp30 -- ^ HTTP/3.
  | HttpFlavorSpdy -- ^ SPDY protocol.
  | HttpFlavorQuic -- ^ QUIC protocol.

instance ToAttrVal HttpFlavor Text where
  toAttrVal :: HttpFlavor -> Text
toAttrVal = \case
    HttpFlavor
HttpFlavorHttp10 -> Text
"http_1_0"
    HttpFlavor
HttpFlavorHttp11 -> Text
"http_1_1"
    HttpFlavor
HttpFlavorHttp20 -> Text
"http_2_0"
    HttpFlavor
HttpFlavorHttp30 -> Text
"http_3_0"
    HttpFlavor
HttpFlavorSpdy -> Text
"spdy"
    HttpFlavor
HttpFlavorQuic -> Text
"quic"

data MessagingDestinationKind
  = MessagingDestinationKindQueue -- ^ A message sent to a queue.
  | MessagingDestinationKindTopic -- ^ A message sent to a topic.

instance ToAttrVal MessagingDestinationKind Text where
  toAttrVal :: MessagingDestinationKind -> Text
toAttrVal = \case
    MessagingDestinationKind
MessagingDestinationKindQueue -> Text
"queue"
    MessagingDestinationKind
MessagingDestinationKindTopic -> Text
"topic"

data MessagingOperation
  = MessagingOperationReceive -- ^ receive.
  | MessagingOperationProcess -- ^ process.

instance ToAttrVal MessagingOperation Text where
  toAttrVal :: MessagingOperation -> Text
toAttrVal = \case
    MessagingOperation
MessagingOperationReceive -> Text
"receive"
    MessagingOperation
MessagingOperationProcess -> Text
"process"

data MessagingRocketmqMessageType
  = MessagingRocketmqMessageTypeNormal -- ^ Normal message.
  | MessagingRocketmqMessageTypeFifo -- ^ FIFO message.
  | MessagingRocketmqMessageTypeDelay -- ^ Delay message.
  | MessagingRocketmqMessageTypeTransaction -- ^ Transaction message.

instance ToAttrVal MessagingRocketmqMessageType Text where
  toAttrVal :: MessagingRocketmqMessageType -> Text
toAttrVal = \case
    MessagingRocketmqMessageType
MessagingRocketmqMessageTypeNormal -> Text
"normal"
    MessagingRocketmqMessageType
MessagingRocketmqMessageTypeFifo -> Text
"fifo"
    MessagingRocketmqMessageType
MessagingRocketmqMessageTypeDelay -> Text
"delay"
    MessagingRocketmqMessageType
MessagingRocketmqMessageTypeTransaction -> Text
"transaction"

data MessagingRocketmqConsumptionModel
  = MessagingRocketmqConsumptionModelClustering -- ^ Clustering consumption model.
  | MessagingRocketmqConsumptionModelBroadcasting -- ^ Broadcasting consumption model.

instance ToAttrVal MessagingRocketmqConsumptionModel Text where
  toAttrVal :: MessagingRocketmqConsumptionModel -> Text
toAttrVal = \case
    MessagingRocketmqConsumptionModel
MessagingRocketmqConsumptionModelClustering -> Text
"clustering"
    MessagingRocketmqConsumptionModel
MessagingRocketmqConsumptionModelBroadcasting -> Text
"broadcasting"

data RpcSystem
  = RpcSystemGrpc -- ^ gRPC.
  | RpcSystemJavaRmi -- ^ Java RMI.
  | RpcSystemDotnetWcf -- ^ .NET WCF.
  | RpcSystemApacheDubbo -- ^ Apache Dubbo.

instance ToAttrVal RpcSystem Text where
  toAttrVal :: RpcSystem -> Text
toAttrVal = \case
    RpcSystem
RpcSystemGrpc -> Text
"grpc"
    RpcSystem
RpcSystemJavaRmi -> Text
"java_rmi"
    RpcSystem
RpcSystemDotnetWcf -> Text
"dotnet_wcf"
    RpcSystem
RpcSystemApacheDubbo -> Text
"apache_dubbo"

data RpcGrpcStatusCode
  = RpcGrpcStatusCodeOk -- ^ OK.
  | RpcGrpcStatusCodeCancelled -- ^ CANCELLED.
  | RpcGrpcStatusCodeUnknown -- ^ UNKNOWN.
  | RpcGrpcStatusCodeInvalidArgument -- ^ INVALID_ARGUMENT.
  | RpcGrpcStatusCodeDeadlineExceeded -- ^ DEADLINE_EXCEEDED.
  | RpcGrpcStatusCodeNotFound -- ^ NOT_FOUND.
  | RpcGrpcStatusCodeAlreadyExists -- ^ ALREADY_EXISTS.
  | RpcGrpcStatusCodePermissionDenied -- ^ PERMISSION_DENIED.
  | RpcGrpcStatusCodeResourceExhausted -- ^ RESOURCE_EXHAUSTED.
  | RpcGrpcStatusCodeFailedPrecondition -- ^ FAILED_PRECONDITION.
  | RpcGrpcStatusCodeAborted -- ^ ABORTED.
  | RpcGrpcStatusCodeOutOfRange -- ^ OUT_OF_RANGE.
  | RpcGrpcStatusCodeUnimplemented -- ^ UNIMPLEMENTED.
  | RpcGrpcStatusCodeInternal -- ^ INTERNAL.
  | RpcGrpcStatusCodeUnavailable -- ^ UNAVAILABLE.
  | RpcGrpcStatusCodeDataLoss -- ^ DATA_LOSS.
  | RpcGrpcStatusCodeUnauthenticated -- ^ UNAUTHENTICATED.

instance ToAttrVal RpcGrpcStatusCode Text where
  toAttrVal :: RpcGrpcStatusCode -> Text
toAttrVal = \case
    RpcGrpcStatusCode
RpcGrpcStatusCodeOk -> Text
"ok"
    RpcGrpcStatusCode
RpcGrpcStatusCodeCancelled -> Text
"cancelled"
    RpcGrpcStatusCode
RpcGrpcStatusCodeUnknown -> Text
"unknown"
    RpcGrpcStatusCode
RpcGrpcStatusCodeInvalidArgument -> Text
"invalid_argument"
    RpcGrpcStatusCode
RpcGrpcStatusCodeDeadlineExceeded -> Text
"deadline_exceeded"
    RpcGrpcStatusCode
RpcGrpcStatusCodeNotFound -> Text
"not_found"
    RpcGrpcStatusCode
RpcGrpcStatusCodeAlreadyExists -> Text
"already_exists"
    RpcGrpcStatusCode
RpcGrpcStatusCodePermissionDenied -> Text
"permission_denied"
    RpcGrpcStatusCode
RpcGrpcStatusCodeResourceExhausted -> Text
"resource_exhausted"
    RpcGrpcStatusCode
RpcGrpcStatusCodeFailedPrecondition -> Text
"failed_precondition"
    RpcGrpcStatusCode
RpcGrpcStatusCodeAborted -> Text
"aborted"
    RpcGrpcStatusCode
RpcGrpcStatusCodeOutOfRange -> Text
"out_of_range"
    RpcGrpcStatusCode
RpcGrpcStatusCodeUnimplemented -> Text
"unimplemented"
    RpcGrpcStatusCode
RpcGrpcStatusCodeInternal -> Text
"internal"
    RpcGrpcStatusCode
RpcGrpcStatusCodeUnavailable -> Text
"unavailable"
    RpcGrpcStatusCode
RpcGrpcStatusCodeDataLoss -> Text
"data_loss"
    RpcGrpcStatusCode
RpcGrpcStatusCodeUnauthenticated -> Text
"unauthenticated"

data MessageType
  = MessageTypeSent -- ^ sent.
  | MessageTypeReceived -- ^ received.

instance ToAttrVal MessageType Text where
  toAttrVal :: MessageType -> Text
toAttrVal = \case
    MessageType
MessageTypeSent -> Text
"sent"
    MessageType
MessageTypeReceived -> Text
"received"

{-|
The name of the keyspace being accessed.

/Deprecated:/ This item has been removed as of 1.8.0 of the semantic conventions. Please use 'DB_NAME' instead.
-}
pattern DB_CASSANDRA_KEYSPACE :: Key Text
pattern $mDB_CASSANDRA_KEYSPACE :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bDB_CASSANDRA_KEYSPACE :: Key Text
DB_CASSANDRA_KEYSPACE <- Key "db.cassandra.keyspace" where
  DB_CASSANDRA_KEYSPACE = Text -> Key Text
forall a. Text -> Key a
Key Text
"db.cassandra.keyspace"
{-# DEPRECATED DB_CASSANDRA_KEYSPACE "This item has been removed as of 1.8.0 of the semantic conventions. Please use DB_NAME instead." #-}

{-|
The [HBase namespace](https://hbase.apache.org/book.html#_namespace) being accessed.

/Deprecated:/ This item has been removed as of 1.8.0 of the semantic conventions. Please use 'DB_NAME' instead.
-}
pattern DB_HBASE_NAMESPACE :: Key Text
pattern $mDB_HBASE_NAMESPACE :: forall {r}. Key Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bDB_HBASE_NAMESPACE :: Key Text
DB_HBASE_NAMESPACE <- Key "db.hbase.namespace" where
  DB_HBASE_NAMESPACE = Text -> Key Text
forall a. Text -> Key a
Key Text
"db.hbase.namespace"
{-# DEPRECATED DB_HBASE_NAMESPACE "This item has been removed as of 1.8.0 of the semantic conventions. Please use DB_NAME instead." #-}