Documentation

Overview

Package semconv implements OpenTelemetry semantic conventions.

This package is currently in a pre-GA phase. Backwards incompatible changes may be introduced in subsequent minor version releases as we work to track the evolving OpenTelemetry specification and user feedback.

OpenTelemetry semantic conventions are agreed standardized naming patterns for OpenTelemetry things. This package aims to be the centralized place to interact with these conventions.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Index

Constants

View Source
const (
	// The Go type containing the error or exception.
	ExceptionTypeKey = attribute.Key("exception.type")

	// The exception message.
	ExceptionMessageKey = attribute.Key("exception.message")

	// A stacktrace as a string. This most commonly will come from
	// "runtime/debug".Stack.
	ExceptionStacktraceKey = attribute.Key("exception.stacktrace")

	// If the exception event is recorded at a point where it is known
	// that the exception is escaping the scope of the span this
	// attribute is set to true.
	ExceptionEscapedKey = attribute.Key("exception.escaped")
)

    Semantic conventions for exception attribute keys.

    View Source
    const (
    	// Name of the service.
    	ServiceNameKey = attribute.Key("service.name")
    
    	// A namespace for `service.name`. This needs to have 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.
    	ServiceNamespaceKey = attribute.Key("service.namespace")
    
    	// A unique identifier of the service instance. In conjunction with the
    	// `service.name` and `service.namespace` this must be unique.
    	ServiceInstanceIDKey = attribute.Key("service.instance.id")
    
    	// The version of the service API.
    	ServiceVersionKey = attribute.Key("service.version")
    )

      Semantic conventions for service resource attribute keys.

      View Source
      const (
      	// The name of the telemetry SDK.
      	//
      	// The default OpenTelemetry SDK provided by the OpenTelemetry project
      	// MUST set telemetry.sdk.name to the value `opentelemetry`.
      	//
      	// If another SDK is used, this attribute MUST be set to the import path
      	// of that SDK's package.
      	//
      	// The value `opentelemetry` is reserved and MUST NOT be used by
      	// non-OpenTelemetry SDKs.
      	TelemetrySDKNameKey = attribute.Key("telemetry.sdk.name")
      
      	// The language of the telemetry SDK.
      	TelemetrySDKLanguageKey = attribute.Key("telemetry.sdk.language")
      
      	// The version string of the telemetry SDK.
      	TelemetrySDKVersionKey = attribute.Key("telemetry.sdk.version")
      )

        Semantic conventions for telemetry SDK resource attribute keys.

        View Source
        const (
        	// A uniquely identifying name for the Container.
        	ContainerNameKey = attribute.Key("container.name")
        
        	// Container ID, usually a UUID, as for example used to
        	// identify Docker containers. The UUID might be abbreviated.
        	ContainerIDKey = attribute.Key("container.id")
        
        	// Name of the image the container was built on.
        	ContainerImageNameKey = attribute.Key("container.image.name")
        
        	// Container image tag.
        	ContainerImageTagKey = attribute.Key("container.image.tag")
        )

          Semantic conventions for container resource attribute keys.

          View Source
          const (
          	// A uniquely identifying name for the FaaS.
          	FaaSNameKey = attribute.Key("faas.name")
          
          	// The unique name of the function being executed.
          	FaaSIDKey = attribute.Key("faas.id")
          
          	// The version of the function being executed.
          	FaaSVersionKey = attribute.Key("faas.version")
          
          	// The execution environment identifier.
          	FaaSInstanceKey = attribute.Key("faas.instance")
          )

            Semantic conventions for Function-as-a-Service resource attribute keys.

            View Source
            const (
            	// Process identifier (PID).
            	ProcessPIDKey = attribute.Key("process.pid")
            	// 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`.
            	ProcessExecutableNameKey = attribute.Key("process.executable.name")
            	// 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`.
            	ProcessExecutablePathKey = attribute.Key("process.executable.path")
            	// 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`.
            	ProcessCommandKey = attribute.Key("process.command")
            	// The full command used to launch the process. The value can be either
            	// a list of strings representing the ordered list of arguments, or a
            	// single string representing the full command. On Linux based systems,
            	// can be set to the list of null-delimited strings extracted from
            	// `proc/[pid]/cmdline`. On Windows, can be set to the result of
            	// `GetCommandLineW`.
            	ProcessCommandLineKey = attribute.Key("process.command_line")
            	// 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`.
            	ProcessCommandArgsKey = attribute.Key("process.command_args")
            	// The username of the user that owns the process.
            	ProcessOwnerKey = attribute.Key("process.owner")
            	// The name of the runtime of this process. For compiled native
            	// binaries, this SHOULD be the name of the compiler.
            	ProcessRuntimeNameKey = attribute.Key("process.runtime.name")
            	// The version of the runtime of this process, as returned by the
            	// runtime without modification.
            	ProcessRuntimeVersionKey = attribute.Key("process.runtime.version")
            	// An additional description about the runtime of the process, for
            	// example a specific vendor customization of the runtime environment.
            	ProcessRuntimeDescriptionKey = attribute.Key("process.runtime.description")
            )

              Semantic conventions for operating system process resource attribute keys.

              View Source
              const (
              	// A uniquely identifying name for the Kubernetes cluster. Kubernetes
              	// does not have cluster names as an internal concept so this may be
              	// set to any meaningful value within the environment. For example,
              	// GKE clusters have a name which can be used for this attribute.
              	K8SClusterNameKey = attribute.Key("k8s.cluster.name")
              
              	// The name of the Node.
              	K8SNodeNameKey = attribute.Key("k8s.node.name")
              
              	// The UID of the Node.
              	K8SNodeUIDKey = attribute.Key("k8s.node.uid")
              
              	// The name of the namespace that the pod is running in.
              	K8SNamespaceNameKey = attribute.Key("k8s.namespace.name")
              
              	// The uid of the Pod.
              	K8SPodUIDKey = attribute.Key("k8s.pod.uid")
              
              	// The name of the pod.
              	K8SPodNameKey = attribute.Key("k8s.pod.name")
              
              	// The name of the Container in a Pod template.
              	K8SContainerNameKey = attribute.Key("k8s.container.name")
              
              	// The uid of the ReplicaSet.
              	K8SReplicaSetUIDKey = attribute.Key("k8s.replicaset.uid")
              
              	// The name of the ReplicaSet.
              	K8SReplicaSetNameKey = attribute.Key("k8s.replicaset.name")
              
              	// The uid of the Deployment.
              	K8SDeploymentUIDKey = attribute.Key("k8s.deployment.uid")
              
              	// The name of the deployment.
              	K8SDeploymentNameKey = attribute.Key("k8s.deployment.name")
              
              	// The uid of the StatefulSet.
              	K8SStatefulSetUIDKey = attribute.Key("k8s.statefulset.uid")
              
              	// The name of the StatefulSet.
              	K8SStatefulSetNameKey = attribute.Key("k8s.statefulset.name")
              
              	// The uid of the DaemonSet.
              	K8SDaemonSetUIDKey = attribute.Key("k8s.daemonset.uid")
              
              	// The name of the DaemonSet.
              	K8SDaemonSetNameKey = attribute.Key("k8s.daemonset.name")
              
              	// The uid of the Job.
              	K8SJobUIDKey = attribute.Key("k8s.job.uid")
              
              	// The name of the Job.
              	K8SJobNameKey = attribute.Key("k8s.job.name")
              
              	// The uid of the CronJob.
              	K8SCronJobUIDKey = attribute.Key("k8s.cronjob.uid")
              
              	// The name of the CronJob.
              	K8SCronJobNameKey = attribute.Key("k8s.cronjob.name")
              )

                Semantic conventions for Kubernetes resource attribute keys.

                View Source
                const (
                	// The operating system type.
                	OSTypeKey = attribute.Key("os.type")
                	// Human readable (not intended to be parsed) OS version information.
                	OSDescriptionKey = attribute.Key("os.description")
                )

                  Semantic conventions for OS resource attribute keys.

                  View Source
                  const (
                  	// A uniquely identifying name for the host: 'hostname', FQDN, or user specified name
                  	HostNameKey = attribute.Key("host.name")
                  
                  	// Unique host ID. For cloud environments this will be the instance ID.
                  	HostIDKey = attribute.Key("host.id")
                  
                  	// Type of host. For cloud environments this will be the machine type.
                  	HostTypeKey = attribute.Key("host.type")
                  
                  	// Name of the OS or VM image the host is running.
                  	HostImageNameKey = attribute.Key("host.image.name")
                  
                  	// Identifier of the image the host is running.
                  	HostImageIDKey = attribute.Key("host.image.id")
                  
                  	// Version of the image the host is running.
                  	HostImageVersionKey = attribute.Key("host.image.version")
                  )

                    Semantic conventions for host resource attribute keys.

                    View Source
                    const (
                    	// Name of the cloud provider.
                    	CloudProviderKey = attribute.Key("cloud.provider")
                    
                    	// The account ID from the cloud provider used for authorization.
                    	CloudAccountIDKey = attribute.Key("cloud.account.id")
                    
                    	// Geographical region where this resource is.
                    	CloudRegionKey = attribute.Key("cloud.region")
                    
                    	// Zone of the region where this resource is.
                    	CloudZoneKey = attribute.Key("cloud.zone")
                    )

                      Semantic conventions for cloud environment resource attribute keys.

                      View Source
                      const (
                      	// Transport protocol used.
                      	NetTransportKey = attribute.Key("net.transport")
                      
                      	// Remote address of the peer.
                      	NetPeerIPKey = attribute.Key("net.peer.ip")
                      
                      	// Remote port number.
                      	NetPeerPortKey = attribute.Key("net.peer.port")
                      
                      	// Remote hostname or similar.
                      	NetPeerNameKey = attribute.Key("net.peer.name")
                      
                      	// Local host IP. Useful in case of a multi-IP host.
                      	NetHostIPKey = attribute.Key("net.host.ip")
                      
                      	// Local host port.
                      	NetHostPortKey = attribute.Key("net.host.port")
                      
                      	// Local hostname or similar.
                      	NetHostNameKey = attribute.Key("net.host.name")
                      )

                        Semantic conventions for attribute keys used for network related operations.

                        View Source
                        const (
                        	// Username or the client identifier extracted from the access token or
                        	// authorization header in the inbound request from outside the system.
                        	EnduserIDKey = attribute.Key("enduser.id")
                        
                        	// Actual or assumed role the client is making the request with.
                        	EnduserRoleKey = attribute.Key("enduser.role")
                        
                        	// Scopes or granted authorities the client currently possesses.
                        	EnduserScopeKey = attribute.Key("enduser.scope")
                        )

                          Semantic conventions for attribute keys used to identify an authorized user.

                          View Source
                          const (
                          	// HTTP request method.
                          	HTTPMethodKey = attribute.Key("http.method")
                          
                          	// Full HTTP request URL in the form:
                          	// scheme://host[:port]/path?query[#fragment].
                          	HTTPURLKey = attribute.Key("http.url")
                          
                          	// The full request target as passed in a HTTP request line or
                          	// equivalent, e.g. "/path/12314/?q=ddds#123".
                          	HTTPTargetKey = attribute.Key("http.target")
                          
                          	// The value of the HTTP host header.
                          	HTTPHostKey = attribute.Key("http.host")
                          
                          	// The URI scheme identifying the used protocol.
                          	HTTPSchemeKey = attribute.Key("http.scheme")
                          
                          	// HTTP response status code.
                          	HTTPStatusCodeKey = attribute.Key("http.status_code")
                          
                          	// Kind of HTTP protocol used.
                          	HTTPFlavorKey = attribute.Key("http.flavor")
                          
                          	// Value of the HTTP User-Agent header sent by the client.
                          	HTTPUserAgentKey = attribute.Key("http.user_agent")
                          
                          	// The primary server name of the matched virtual host.
                          	HTTPServerNameKey = attribute.Key("http.server_name")
                          
                          	// The matched route served (path template). For example,
                          	// "/users/:userID?".
                          	HTTPRouteKey = attribute.Key("http.route")
                          
                          	// The IP address of the original client behind all proxies, if known
                          	// (e.g. from X-Forwarded-For).
                          	HTTPClientIPKey = attribute.Key("http.client_ip")
                          
                          	// The size of the request payload body in bytes.
                          	HTTPRequestContentLengthKey = attribute.Key("http.request_content_length")
                          
                          	// The size of the uncompressed request payload body after transport decoding.
                          	// Not set if transport encoding not used.
                          	HTTPRequestContentLengthUncompressedKey = attribute.Key("http.request_content_length_uncompressed")
                          
                          	// The size of the response payload body in bytes.
                          	HTTPResponseContentLengthKey = attribute.Key("http.response_content_length")
                          
                          	// The size of the uncompressed response payload body after transport decoding.
                          	// Not set if transport encoding not used.
                          	HTTPResponseContentLengthUncompressedKey = attribute.Key("http.response_content_length_uncompressed")
                          )

                            Semantic conventions for attribute keys for HTTP.

                            View Source
                            const (
                            	// Identifier for the database system (DBMS) being used.
                            	DBSystemKey = attribute.Key("db.system")
                            
                            	// Database Connection String with embedded credentials removed.
                            	DBConnectionStringKey = attribute.Key("db.connection_string")
                            
                            	// Username for accessing database.
                            	DBUserKey = attribute.Key("db.user")
                            )

                              Semantic conventions for attribute keys for database connections.

                              View Source
                              const (
                              	// Database instance name.
                              	DBNameKey = attribute.Key("db.name")
                              
                              	// A database statement for the given database type.
                              	DBStatementKey = attribute.Key("db.statement")
                              
                              	// A database operation for the given database type.
                              	DBOperationKey = attribute.Key("db.operation")
                              )

                                Semantic conventions for attribute keys for database calls.

                                View Source
                                const (
                                	// Name of the Cassandra keyspace accessed. Use instead of `db.name`.
                                	DBCassandraKeyspaceKey = attribute.Key("db.cassandra.keyspace")
                                
                                	// HBase namespace accessed. Use instead of `db.name`.
                                	DBHBaseNamespaceKey = attribute.Key("db.hbase.namespace")
                                
                                	// Index of Redis database accessed. Use instead of `db.name`.
                                	DBRedisDBIndexKey = attribute.Key("db.redis.database_index")
                                
                                	// Collection being accessed within the database in `db.name`.
                                	DBMongoDBCollectionKey = attribute.Key("db.mongodb.collection")
                                )

                                  Database technology-specific attributes

                                  View Source
                                  const (
                                  	// A string identifying the remoting system.
                                  	RPCSystemKey = attribute.Key("rpc.system")
                                  
                                  	// The full name of the service being called.
                                  	RPCServiceKey = attribute.Key("rpc.service")
                                  
                                  	// The name of the method being called.
                                  	RPCMethodKey = attribute.Key("rpc.method")
                                  
                                  	// Name of message transmitted or received.
                                  	RPCNameKey = attribute.Key("name")
                                  
                                  	// Type of message transmitted or received.
                                  	RPCMessageTypeKey = attribute.Key("message.type")
                                  
                                  	// Identifier of message transmitted or received.
                                  	RPCMessageIDKey = attribute.Key("message.id")
                                  
                                  	// The compressed size of the message transmitted or received in bytes.
                                  	RPCMessageCompressedSizeKey = attribute.Key("message.compressed_size")
                                  
                                  	// The uncompressed size of the message transmitted or received in
                                  	// bytes.
                                  	RPCMessageUncompressedSizeKey = attribute.Key("message.uncompressed_size")
                                  )

                                    Semantic conventions for attribute keys for RPC.

                                    View Source
                                    const (
                                    	// A unique identifier describing the messaging system. For example,
                                    	// kafka, rabbitmq or activemq.
                                    	MessagingSystemKey = attribute.Key("messaging.system")
                                    
                                    	// The message destination name, e.g. MyQueue or MyTopic.
                                    	MessagingDestinationKey = attribute.Key("messaging.destination")
                                    
                                    	// The kind of message destination.
                                    	MessagingDestinationKindKey = attribute.Key("messaging.destination_kind")
                                    
                                    	// Describes if the destination is temporary or not.
                                    	MessagingTempDestinationKey = attribute.Key("messaging.temp_destination")
                                    
                                    	// The name of the transport protocol.
                                    	MessagingProtocolKey = attribute.Key("messaging.protocol")
                                    
                                    	// The version of the transport protocol.
                                    	MessagingProtocolVersionKey = attribute.Key("messaging.protocol_version")
                                    
                                    	// Messaging service URL.
                                    	MessagingURLKey = attribute.Key("messaging.url")
                                    
                                    	// Identifier used by the messaging system for a message.
                                    	MessagingMessageIDKey = attribute.Key("messaging.message_id")
                                    
                                    	// Identifier used by the messaging system for a conversation.
                                    	MessagingConversationIDKey = attribute.Key("messaging.conversation_id")
                                    
                                    	// The (uncompressed) size of the message payload in bytes.
                                    	MessagingMessagePayloadSizeBytesKey = attribute.Key("messaging.message_payload_size_bytes")
                                    
                                    	// The compressed size of the message payload in bytes.
                                    	MessagingMessagePayloadCompressedSizeBytesKey = attribute.Key("messaging.message_payload_compressed_size_bytes")
                                    
                                    	// Identifies which part and kind of message consumption is being
                                    	// preformed.
                                    	MessagingOperationKey = attribute.Key("messaging.operation")
                                    
                                    	// RabbitMQ specific attribute describing the destination routing key.
                                    	MessagingRabbitMQRoutingKeyKey = attribute.Key("messaging.rabbitmq.routing_key")
                                    )

                                      Semantic conventions for attribute keys for messaging systems.

                                      View Source
                                      const (
                                      
                                      	// Type of the trigger on which the function is executed.
                                      	FaaSTriggerKey = attribute.Key("faas.trigger")
                                      
                                      	// String containing the execution identifier of the function.
                                      	FaaSExecutionKey = attribute.Key("faas.execution")
                                      
                                      	// A boolean indicating that the serverless function is executed
                                      	// for the first time (aka cold start).
                                      	FaaSColdstartKey = attribute.Key("faas.coldstart")
                                      
                                      	// The name of the source on which the operation was performed.
                                      	// For example, in Cloud Storage or S3 corresponds to the bucket name,
                                      	// and in Cosmos DB to the database name.
                                      	FaaSDocumentCollectionKey = attribute.Key("faas.document.collection")
                                      
                                      	// The type of the operation that was performed on the data.
                                      	FaaSDocumentOperationKey = attribute.Key("faas.document.operation")
                                      
                                      	// A string containing the time when the data was accessed.
                                      	FaaSDocumentTimeKey = attribute.Key("faas.document.time")
                                      
                                      	// The document name/table subjected to the operation.
                                      	FaaSDocumentNameKey = attribute.Key("faas.document.name")
                                      
                                      	// The function invocation time.
                                      	FaaSTimeKey = attribute.Key("faas.time")
                                      
                                      	// The schedule period as Cron Expression.
                                      	FaaSCronKey = attribute.Key("faas.cron")
                                      )

                                        Semantic conventions for attribute keys for FaaS systems.

                                        View Source
                                        const (
                                        	// The method or function name, or equivalent (usually rightmost part of
                                        	// the code unit's name).
                                        	CodeFunctionKey = attribute.Key("code.function")
                                        
                                        	// 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.
                                        	CodeNamespaceKey = attribute.Key("code.namespace")
                                        
                                        	// The source code file name that identifies the code unit as uniquely as
                                        	// possible (preferably an absolute file path).
                                        	CodeFilepathKey = attribute.Key("code.filepath")
                                        
                                        	// The line number in `code.filepath` best representing the operation.
                                        	// It SHOULD point within the code unit named in `code.function`.
                                        	CodeLineNumberKey = attribute.Key("code.lineno")
                                        )

                                          Semantic conventions for source code attributes.

                                          View Source
                                          const (
                                          	// Name of the deployment environment (aka deployment tier); e.g. (staging, production).
                                          	DeploymentEnvironmentKey = attribute.Key("deployment.environment")
                                          )

                                            Semantic conventions for deployment attributes.

                                            View Source
                                            const (
                                            	// ExceptionEventName is the name of the Span event representing an exception.
                                            	ExceptionEventName = "exception"
                                            )
                                            View Source
                                            const (
                                            	// Service name of the remote service. Should equal the actual
                                            	// `service.name` resource attribute of the remote service, if any.
                                            	PeerServiceKey = attribute.Key("peer.service")
                                            )

                                              General attribute keys for spans.

                                              Variables

                                              View Source
                                              var (
                                              	CloudProviderAWS   = CloudProviderKey.String("aws")
                                              	CloudProviderAzure = CloudProviderKey.String("azure")
                                              	CloudProviderGCP   = CloudProviderKey.String("gcp")
                                              )

                                                Semantic conventions for common cloud provider resource attributes.

                                                View Source
                                                var (
                                                	NetTransportTCP    = NetTransportKey.String("IP.TCP")
                                                	NetTransportUDP    = NetTransportKey.String("IP.UDP")
                                                	NetTransportIP     = NetTransportKey.String("IP")
                                                	NetTransportUnix   = NetTransportKey.String("Unix")
                                                	NetTransportPipe   = NetTransportKey.String("pipe")
                                                	NetTransportInProc = NetTransportKey.String("inproc")
                                                	NetTransportOther  = NetTransportKey.String("other")
                                                )

                                                  Semantic conventions for common transport protocol attributes.

                                                  View Source
                                                  var (
                                                  	// Semantic conventions for HTTP(S) URI schemes.
                                                  	HTTPSchemeHTTP  = HTTPSchemeKey.String("http")
                                                  	HTTPSchemeHTTPS = HTTPSchemeKey.String("https")
                                                  
                                                  	// Semantic conventions for HTTP protocols.
                                                  	HTTPFlavor1_0  = HTTPFlavorKey.String("1.0")
                                                  	HTTPFlavor1_1  = HTTPFlavorKey.String("1.1")
                                                  	HTTPFlavor2    = HTTPFlavorKey.String("2")
                                                  	HTTPFlavorSPDY = HTTPFlavorKey.String("SPDY")
                                                  	HTTPFlavorQUIC = HTTPFlavorKey.String("QUIC")
                                                  )

                                                    Semantic conventions for common HTTP attributes.

                                                    View Source
                                                    var (
                                                    	DBSystemDB2       = DBSystemKey.String("db2")        // IBM DB2
                                                    	DBSystemDerby     = DBSystemKey.String("derby")      // Apache Derby
                                                    	DBSystemHive      = DBSystemKey.String("hive")       // Apache Hive
                                                    	DBSystemMariaDB   = DBSystemKey.String("mariadb")    // MariaDB
                                                    	DBSystemMSSql     = DBSystemKey.String("mssql")      // Microsoft SQL Server
                                                    	DBSystemMySQL     = DBSystemKey.String("mysql")      // MySQL
                                                    	DBSystemOracle    = DBSystemKey.String("oracle")     // Oracle Database
                                                    	DBSystemPostgres  = DBSystemKey.String("postgresql") // PostgreSQL
                                                    	DBSystemSqlite    = DBSystemKey.String("sqlite")     // SQLite
                                                    	DBSystemTeradata  = DBSystemKey.String("teradata")   // Teradata
                                                    	DBSystemOtherSQL  = DBSystemKey.String("other_sql")  // Some other Sql database. Fallback only
                                                    	DBSystemCassandra = DBSystemKey.String("cassandra")  // Cassandra
                                                    	DBSystemCosmosDB  = DBSystemKey.String("cosmosdb")   // Microsoft Azure CosmosDB
                                                    	DBSystemCouchbase = DBSystemKey.String("couchbase")  // Couchbase
                                                    	DBSystemCouchDB   = DBSystemKey.String("couchdb")    // CouchDB
                                                    	DBSystemDynamoDB  = DBSystemKey.String("dynamodb")   // Amazon DynamoDB
                                                    	DBSystemHBase     = DBSystemKey.String("hbase")      // HBase
                                                    	DBSystemMongodb   = DBSystemKey.String("mongodb")    // MongoDB
                                                    	DBSystemNeo4j     = DBSystemKey.String("neo4j")      // Neo4j
                                                    	DBSystemRedis     = DBSystemKey.String("redis")      // Redis
                                                    )

                                                      Semantic conventions for common database system attributes.

                                                      View Source
                                                      var (
                                                      	// Semantic convention for gRPC as the remoting system.
                                                      	RPCSystemGRPC = RPCSystemKey.String("grpc")
                                                      
                                                      	// Semantic convention for a message named message.
                                                      	RPCNameMessage = RPCNameKey.String("message")
                                                      
                                                      	// Semantic conventions for RPC message types.
                                                      	RPCMessageTypeSent     = RPCMessageTypeKey.String("SENT")
                                                      	RPCMessageTypeReceived = RPCMessageTypeKey.String("RECEIVED")
                                                      )

                                                        Semantic conventions for common RPC attributes.

                                                        View Source
                                                        var (
                                                        	// Semantic conventions for message destinations.
                                                        	MessagingDestinationKindKeyQueue = MessagingDestinationKindKey.String("queue")
                                                        	MessagingDestinationKindKeyTopic = MessagingDestinationKindKey.String("topic")
                                                        
                                                        	// Semantic convention for message destinations that are temporary.
                                                        	MessagingTempDestination = MessagingTempDestinationKey.Bool(true)
                                                        
                                                        	// Semantic convention for the operation parts of message consumption.
                                                        	// This does not include a "send" attribute as that is explicitly not
                                                        	// allowed in the OpenTelemetry specification.
                                                        	MessagingOperationReceive = MessagingOperationKey.String("receive")
                                                        	MessagingOperationProcess = MessagingOperationKey.String("process")
                                                        )

                                                          Semantic conventions for common messaging system attributes.

                                                          View Source
                                                          var (
                                                          	// Semantic conventions for the types of triggers.
                                                          	FaasTriggerDatasource = FaaSTriggerKey.String("datasource")
                                                          	FaasTriggerHTTP       = FaaSTriggerKey.String("http")
                                                          	FaasTriggerPubSub     = FaaSTriggerKey.String("pubsub")
                                                          	FaasTriggerTimer      = FaaSTriggerKey.String("timer")
                                                          	FaasTriggerOther      = FaaSTriggerKey.String("other")
                                                          
                                                          	// Semantic conventions for the types of operations performed.
                                                          	FaaSDocumentOperationInsert = FaaSDocumentOperationKey.String("insert")
                                                          	FaaSDocumentOperationEdit   = FaaSDocumentOperationKey.String("edit")
                                                          	FaaSDocumentOperationDelete = FaaSDocumentOperationKey.String("delete")
                                                          )

                                                            Semantic conventions for common FaaS system attributes.

                                                            View Source
                                                            var (
                                                            	TelemetrySDKLanguageGo = TelemetrySDKLanguageKey.String("go")
                                                            )

                                                              Semantic conventions for telemetry SDK resource attributes.

                                                              Functions

                                                              func EndUserAttributesFromHTTPRequest

                                                              func EndUserAttributesFromHTTPRequest(request *http.Request) []attribute.KeyValue

                                                                EndUserAttributesFromHTTPRequest generates attributes of the enduser namespace as specified by the OpenTelemetry specification for a span.

                                                                func HTTPAttributesFromHTTPStatusCode

                                                                func HTTPAttributesFromHTTPStatusCode(code int) []attribute.KeyValue

                                                                  HTTPAttributesFromHTTPStatusCode generates attributes of the http namespace as specified by the OpenTelemetry specification for a span.

                                                                  func HTTPClientAttributesFromHTTPRequest

                                                                  func HTTPClientAttributesFromHTTPRequest(request *http.Request) []attribute.KeyValue

                                                                    HTTPClientAttributesFromHTTPRequest generates attributes of the http namespace as specified by the OpenTelemetry specification for a span on the client side.

                                                                    func HTTPServerAttributesFromHTTPRequest

                                                                    func HTTPServerAttributesFromHTTPRequest(serverName, route string, request *http.Request) []attribute.KeyValue

                                                                      HTTPServerAttributesFromHTTPRequest generates attributes of the http namespace as specified by the OpenTelemetry specification for a span on the server side. Currently, only basic authentication is supported.

                                                                      func HTTPServerMetricAttributesFromHTTPRequest

                                                                      func HTTPServerMetricAttributesFromHTTPRequest(serverName string, request *http.Request) []attribute.KeyValue

                                                                        HTTPServerMetricAttributesFromHTTPRequest generates low-cardinality attributes to be used with server-side HTTP metrics.

                                                                        func NetAttributesFromHTTPRequest

                                                                        func NetAttributesFromHTTPRequest(network string, request *http.Request) []attribute.KeyValue

                                                                          NetAttributesFromHTTPRequest generates attributes of the net namespace as specified by the OpenTelemetry specification for a span. The network parameter is a string that net.Dial function from standard library can understand.

                                                                          func SpanStatusFromHTTPStatusCode

                                                                          func SpanStatusFromHTTPStatusCode(code int) (codes.Code, string)

                                                                            SpanStatusFromHTTPStatusCode generates a status code and a message as specified by the OpenTelemetry specification for a span.

                                                                            Types

                                                                            This section is empty.