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

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

     1  // Copyright The OpenTelemetry Authors
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  // Code generated from semantic convention specification. DO NOT EDIT.
    16  
    17  package semconv // import "go.opentelemetry.io/otel/semconv/v1.21.0"
    18  
    19  import "go.opentelemetry.io/otel/attribute"
    20  
    21  // The web browser in which the application represented by the resource is
    22  // running. The `browser.*` attributes MUST be used only for resources that
    23  // represent applications running in a web browser (regardless of whether
    24  // running on a mobile or desktop device).
    25  const (
    26  	// BrowserBrandsKey is the attribute Key conforming to the "browser.brands"
    27  	// semantic conventions. It represents the array of brand name and version
    28  	// separated by a space
    29  	//
    30  	// Type: string[]
    31  	// RequirementLevel: Optional
    32  	// Stability: stable
    33  	// Examples: ' Not A;Brand 99', 'Chromium 99', 'Chrome 99'
    34  	// Note: This value is intended to be taken from the [UA client hints
    35  	// API](https://wicg.github.io/ua-client-hints/#interface)
    36  	// (`navigator.userAgentData.brands`).
    37  	BrowserBrandsKey = attribute.Key("browser.brands")
    38  
    39  	// BrowserPlatformKey is the attribute Key conforming to the
    40  	// "browser.platform" semantic conventions. It represents the platform on
    41  	// which the browser is running
    42  	//
    43  	// Type: string
    44  	// RequirementLevel: Optional
    45  	// Stability: stable
    46  	// Examples: 'Windows', 'macOS', 'Android'
    47  	// Note: This value is intended to be taken from the [UA client hints
    48  	// API](https://wicg.github.io/ua-client-hints/#interface)
    49  	// (`navigator.userAgentData.platform`). If unavailable, the legacy
    50  	// `navigator.platform` API SHOULD NOT be used instead and this attribute
    51  	// SHOULD be left unset in order for the values to be consistent.
    52  	// The list of possible values is defined in the [W3C User-Agent Client
    53  	// Hints
    54  	// specification](https://wicg.github.io/ua-client-hints/#sec-ch-ua-platform).
    55  	// Note that some (but not all) of these values can overlap with values in
    56  	// the [`os.type` and `os.name` attributes](./os.md). However, for
    57  	// consistency, the values in the `browser.platform` attribute should
    58  	// capture the exact value that the user agent provides.
    59  	BrowserPlatformKey = attribute.Key("browser.platform")
    60  
    61  	// BrowserMobileKey is the attribute Key conforming to the "browser.mobile"
    62  	// semantic conventions. It represents a boolean that is true if the
    63  	// browser is running on a mobile device
    64  	//
    65  	// Type: boolean
    66  	// RequirementLevel: Optional
    67  	// Stability: stable
    68  	// Note: This value is intended to be taken from the [UA client hints
    69  	// API](https://wicg.github.io/ua-client-hints/#interface)
    70  	// (`navigator.userAgentData.mobile`). If unavailable, this attribute
    71  	// SHOULD be left unset.
    72  	BrowserMobileKey = attribute.Key("browser.mobile")
    73  
    74  	// BrowserLanguageKey is the attribute Key conforming to the
    75  	// "browser.language" semantic conventions. It represents the preferred
    76  	// language of the user using the browser
    77  	//
    78  	// Type: string
    79  	// RequirementLevel: Optional
    80  	// Stability: stable
    81  	// Examples: 'en', 'en-US', 'fr', 'fr-FR'
    82  	// Note: This value is intended to be taken from the Navigator API
    83  	// `navigator.language`.
    84  	BrowserLanguageKey = attribute.Key("browser.language")
    85  )
    86  
    87  // BrowserBrands returns an attribute KeyValue conforming to the
    88  // "browser.brands" semantic conventions. It represents the array of brand name
    89  // and version separated by a space
    90  func BrowserBrands(val ...string) attribute.KeyValue {
    91  	return BrowserBrandsKey.StringSlice(val)
    92  }
    93  
    94  // BrowserPlatform returns an attribute KeyValue conforming to the
    95  // "browser.platform" semantic conventions. It represents the platform on which
    96  // the browser is running
    97  func BrowserPlatform(val string) attribute.KeyValue {
    98  	return BrowserPlatformKey.String(val)
    99  }
   100  
   101  // BrowserMobile returns an attribute KeyValue conforming to the
   102  // "browser.mobile" semantic conventions. It represents a boolean that is true
   103  // if the browser is running on a mobile device
   104  func BrowserMobile(val bool) attribute.KeyValue {
   105  	return BrowserMobileKey.Bool(val)
   106  }
   107  
   108  // BrowserLanguage returns an attribute KeyValue conforming to the
   109  // "browser.language" semantic conventions. It represents the preferred
   110  // language of the user using the browser
   111  func BrowserLanguage(val string) attribute.KeyValue {
   112  	return BrowserLanguageKey.String(val)
   113  }
   114  
   115  // A cloud environment (e.g. GCP, Azure, AWS)
   116  const (
   117  	// CloudProviderKey is the attribute Key conforming to the "cloud.provider"
   118  	// semantic conventions. It represents the name of the cloud provider.
   119  	//
   120  	// Type: Enum
   121  	// RequirementLevel: Optional
   122  	// Stability: stable
   123  	CloudProviderKey = attribute.Key("cloud.provider")
   124  
   125  	// CloudAccountIDKey is the attribute Key conforming to the
   126  	// "cloud.account.id" semantic conventions. It represents the cloud account
   127  	// ID the resource is assigned to.
   128  	//
   129  	// Type: string
   130  	// RequirementLevel: Optional
   131  	// Stability: stable
   132  	// Examples: '111111111111', 'opentelemetry'
   133  	CloudAccountIDKey = attribute.Key("cloud.account.id")
   134  
   135  	// CloudRegionKey is the attribute Key conforming to the "cloud.region"
   136  	// semantic conventions. It represents the geographical region the resource
   137  	// is running.
   138  	//
   139  	// Type: string
   140  	// RequirementLevel: Optional
   141  	// Stability: stable
   142  	// Examples: 'us-central1', 'us-east-1'
   143  	// Note: Refer to your provider's docs to see the available regions, for
   144  	// example [Alibaba Cloud
   145  	// regions](https://www.alibabacloud.com/help/doc-detail/40654.htm), [AWS
   146  	// regions](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/),
   147  	// [Azure
   148  	// regions](https://azure.microsoft.com/en-us/global-infrastructure/geographies/),
   149  	// [Google Cloud regions](https://cloud.google.com/about/locations), or
   150  	// [Tencent Cloud
   151  	// regions](https://www.tencentcloud.com/document/product/213/6091).
   152  	CloudRegionKey = attribute.Key("cloud.region")
   153  
   154  	// CloudResourceIDKey is the attribute Key conforming to the
   155  	// "cloud.resource_id" semantic conventions. It represents the cloud
   156  	// provider-specific native identifier of the monitored cloud resource
   157  	// (e.g. an
   158  	// [ARN](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
   159  	// on AWS, a [fully qualified resource
   160  	// ID](https://learn.microsoft.com/en-us/rest/api/resources/resources/get-by-id)
   161  	// on Azure, a [full resource
   162  	// name](https://cloud.google.com/apis/design/resource_names#full_resource_name)
   163  	// on GCP)
   164  	//
   165  	// Type: string
   166  	// RequirementLevel: Optional
   167  	// Stability: stable
   168  	// Examples: 'arn:aws:lambda:REGION:ACCOUNT_ID:function:my-function',
   169  	// '//run.googleapis.com/projects/PROJECT_ID/locations/LOCATION_ID/services/SERVICE_ID',
   170  	// '/subscriptions/<SUBSCIPTION_GUID>/resourceGroups/<RG>/providers/Microsoft.Web/sites/<FUNCAPP>/functions/<FUNC>'
   171  	// Note: On some cloud providers, it may not be possible to determine the
   172  	// full ID at startup,
   173  	// so it may be necessary to set `cloud.resource_id` as a span attribute
   174  	// instead.
   175  	//
   176  	// The exact value to use for `cloud.resource_id` depends on the cloud
   177  	// provider.
   178  	// The following well-known definitions MUST be used if you set this
   179  	// attribute and they apply:
   180  	//
   181  	// * **AWS Lambda:** The function
   182  	// [ARN](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html).
   183  	//   Take care not to use the "invoked ARN" directly but replace any
   184  	//   [alias
   185  	// suffix](https://docs.aws.amazon.com/lambda/latest/dg/configuration-aliases.html)
   186  	//   with the resolved function version, as the same runtime instance may
   187  	// be invokable with
   188  	//   multiple different aliases.
   189  	// * **GCP:** The [URI of the
   190  	// resource](https://cloud.google.com/iam/docs/full-resource-names)
   191  	// * **Azure:** The [Fully Qualified Resource
   192  	// ID](https://docs.microsoft.com/en-us/rest/api/resources/resources/get-by-id)
   193  	// of the invoked function,
   194  	//   *not* the function app, having the form
   195  	// `/subscriptions/<SUBSCIPTION_GUID>/resourceGroups/<RG>/providers/Microsoft.Web/sites/<FUNCAPP>/functions/<FUNC>`.
   196  	//   This means that a span attribute MUST be used, as an Azure function
   197  	// app can host multiple functions that would usually share
   198  	//   a TracerProvider.
   199  	CloudResourceIDKey = attribute.Key("cloud.resource_id")
   200  
   201  	// CloudAvailabilityZoneKey is the attribute Key conforming to the
   202  	// "cloud.availability_zone" semantic conventions. It represents the cloud
   203  	// regions often have multiple, isolated locations known as zones to
   204  	// increase availability. Availability zone represents the zone where the
   205  	// resource is running.
   206  	//
   207  	// Type: string
   208  	// RequirementLevel: Optional
   209  	// Stability: stable
   210  	// Examples: 'us-east-1c'
   211  	// Note: Availability zones are called "zones" on Alibaba Cloud and Google
   212  	// Cloud.
   213  	CloudAvailabilityZoneKey = attribute.Key("cloud.availability_zone")
   214  
   215  	// CloudPlatformKey is the attribute Key conforming to the "cloud.platform"
   216  	// semantic conventions. It represents the cloud platform in use.
   217  	//
   218  	// Type: Enum
   219  	// RequirementLevel: Optional
   220  	// Stability: stable
   221  	// Note: The prefix of the service SHOULD match the one specified in
   222  	// `cloud.provider`.
   223  	CloudPlatformKey = attribute.Key("cloud.platform")
   224  )
   225  
   226  var (
   227  	// Alibaba Cloud
   228  	CloudProviderAlibabaCloud = CloudProviderKey.String("alibaba_cloud")
   229  	// Amazon Web Services
   230  	CloudProviderAWS = CloudProviderKey.String("aws")
   231  	// Microsoft Azure
   232  	CloudProviderAzure = CloudProviderKey.String("azure")
   233  	// Google Cloud Platform
   234  	CloudProviderGCP = CloudProviderKey.String("gcp")
   235  	// Heroku Platform as a Service
   236  	CloudProviderHeroku = CloudProviderKey.String("heroku")
   237  	// IBM Cloud
   238  	CloudProviderIbmCloud = CloudProviderKey.String("ibm_cloud")
   239  	// Tencent Cloud
   240  	CloudProviderTencentCloud = CloudProviderKey.String("tencent_cloud")
   241  )
   242  
   243  var (
   244  	// Alibaba Cloud Elastic Compute Service
   245  	CloudPlatformAlibabaCloudECS = CloudPlatformKey.String("alibaba_cloud_ecs")
   246  	// Alibaba Cloud Function Compute
   247  	CloudPlatformAlibabaCloudFc = CloudPlatformKey.String("alibaba_cloud_fc")
   248  	// Red Hat OpenShift on Alibaba Cloud
   249  	CloudPlatformAlibabaCloudOpenshift = CloudPlatformKey.String("alibaba_cloud_openshift")
   250  	// AWS Elastic Compute Cloud
   251  	CloudPlatformAWSEC2 = CloudPlatformKey.String("aws_ec2")
   252  	// AWS Elastic Container Service
   253  	CloudPlatformAWSECS = CloudPlatformKey.String("aws_ecs")
   254  	// AWS Elastic Kubernetes Service
   255  	CloudPlatformAWSEKS = CloudPlatformKey.String("aws_eks")
   256  	// AWS Lambda
   257  	CloudPlatformAWSLambda = CloudPlatformKey.String("aws_lambda")
   258  	// AWS Elastic Beanstalk
   259  	CloudPlatformAWSElasticBeanstalk = CloudPlatformKey.String("aws_elastic_beanstalk")
   260  	// AWS App Runner
   261  	CloudPlatformAWSAppRunner = CloudPlatformKey.String("aws_app_runner")
   262  	// Red Hat OpenShift on AWS (ROSA)
   263  	CloudPlatformAWSOpenshift = CloudPlatformKey.String("aws_openshift")
   264  	// Azure Virtual Machines
   265  	CloudPlatformAzureVM = CloudPlatformKey.String("azure_vm")
   266  	// Azure Container Instances
   267  	CloudPlatformAzureContainerInstances = CloudPlatformKey.String("azure_container_instances")
   268  	// Azure Kubernetes Service
   269  	CloudPlatformAzureAKS = CloudPlatformKey.String("azure_aks")
   270  	// Azure Functions
   271  	CloudPlatformAzureFunctions = CloudPlatformKey.String("azure_functions")
   272  	// Azure App Service
   273  	CloudPlatformAzureAppService = CloudPlatformKey.String("azure_app_service")
   274  	// Azure Red Hat OpenShift
   275  	CloudPlatformAzureOpenshift = CloudPlatformKey.String("azure_openshift")
   276  	// Google Bare Metal Solution (BMS)
   277  	CloudPlatformGCPBareMetalSolution = CloudPlatformKey.String("gcp_bare_metal_solution")
   278  	// Google Cloud Compute Engine (GCE)
   279  	CloudPlatformGCPComputeEngine = CloudPlatformKey.String("gcp_compute_engine")
   280  	// Google Cloud Run
   281  	CloudPlatformGCPCloudRun = CloudPlatformKey.String("gcp_cloud_run")
   282  	// Google Cloud Kubernetes Engine (GKE)
   283  	CloudPlatformGCPKubernetesEngine = CloudPlatformKey.String("gcp_kubernetes_engine")
   284  	// Google Cloud Functions (GCF)
   285  	CloudPlatformGCPCloudFunctions = CloudPlatformKey.String("gcp_cloud_functions")
   286  	// Google Cloud App Engine (GAE)
   287  	CloudPlatformGCPAppEngine = CloudPlatformKey.String("gcp_app_engine")
   288  	// Red Hat OpenShift on Google Cloud
   289  	CloudPlatformGCPOpenshift = CloudPlatformKey.String("gcp_openshift")
   290  	// Red Hat OpenShift on IBM Cloud
   291  	CloudPlatformIbmCloudOpenshift = CloudPlatformKey.String("ibm_cloud_openshift")
   292  	// Tencent Cloud Cloud Virtual Machine (CVM)
   293  	CloudPlatformTencentCloudCvm = CloudPlatformKey.String("tencent_cloud_cvm")
   294  	// Tencent Cloud Elastic Kubernetes Service (EKS)
   295  	CloudPlatformTencentCloudEKS = CloudPlatformKey.String("tencent_cloud_eks")
   296  	// Tencent Cloud Serverless Cloud Function (SCF)
   297  	CloudPlatformTencentCloudScf = CloudPlatformKey.String("tencent_cloud_scf")
   298  )
   299  
   300  // CloudAccountID returns an attribute KeyValue conforming to the
   301  // "cloud.account.id" semantic conventions. It represents the cloud account ID
   302  // the resource is assigned to.
   303  func CloudAccountID(val string) attribute.KeyValue {
   304  	return CloudAccountIDKey.String(val)
   305  }
   306  
   307  // CloudRegion returns an attribute KeyValue conforming to the
   308  // "cloud.region" semantic conventions. It represents the geographical region
   309  // the resource is running.
   310  func CloudRegion(val string) attribute.KeyValue {
   311  	return CloudRegionKey.String(val)
   312  }
   313  
   314  // CloudResourceID returns an attribute KeyValue conforming to the
   315  // "cloud.resource_id" semantic conventions. It represents the cloud
   316  // provider-specific native identifier of the monitored cloud resource (e.g. an
   317  // [ARN](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
   318  // on AWS, a [fully qualified resource
   319  // ID](https://learn.microsoft.com/en-us/rest/api/resources/resources/get-by-id)
   320  // on Azure, a [full resource
   321  // name](https://cloud.google.com/apis/design/resource_names#full_resource_name)
   322  // on GCP)
   323  func CloudResourceID(val string) attribute.KeyValue {
   324  	return CloudResourceIDKey.String(val)
   325  }
   326  
   327  // CloudAvailabilityZone returns an attribute KeyValue conforming to the
   328  // "cloud.availability_zone" semantic conventions. It represents the cloud
   329  // regions often have multiple, isolated locations known as zones to increase
   330  // availability. Availability zone represents the zone where the resource is
   331  // running.
   332  func CloudAvailabilityZone(val string) attribute.KeyValue {
   333  	return CloudAvailabilityZoneKey.String(val)
   334  }
   335  
   336  // Resources used by AWS Elastic Container Service (ECS).
   337  const (
   338  	// AWSECSContainerARNKey is the attribute Key conforming to the
   339  	// "aws.ecs.container.arn" semantic conventions. It represents the Amazon
   340  	// Resource Name (ARN) of an [ECS container
   341  	// instance](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_instances.html).
   342  	//
   343  	// Type: string
   344  	// RequirementLevel: Optional
   345  	// Stability: stable
   346  	// Examples:
   347  	// 'arn:aws:ecs:us-west-1:123456789123:container/32624152-9086-4f0e-acae-1a75b14fe4d9'
   348  	AWSECSContainerARNKey = attribute.Key("aws.ecs.container.arn")
   349  
   350  	// AWSECSClusterARNKey is the attribute Key conforming to the
   351  	// "aws.ecs.cluster.arn" semantic conventions. It represents the ARN of an
   352  	// [ECS
   353  	// cluster](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/clusters.html).
   354  	//
   355  	// Type: string
   356  	// RequirementLevel: Optional
   357  	// Stability: stable
   358  	// Examples: 'arn:aws:ecs:us-west-2:123456789123:cluster/my-cluster'
   359  	AWSECSClusterARNKey = attribute.Key("aws.ecs.cluster.arn")
   360  
   361  	// AWSECSLaunchtypeKey is the attribute Key conforming to the
   362  	// "aws.ecs.launchtype" semantic conventions. It represents the [launch
   363  	// type](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html)
   364  	// for an ECS task.
   365  	//
   366  	// Type: Enum
   367  	// RequirementLevel: Optional
   368  	// Stability: stable
   369  	AWSECSLaunchtypeKey = attribute.Key("aws.ecs.launchtype")
   370  
   371  	// AWSECSTaskARNKey is the attribute Key conforming to the
   372  	// "aws.ecs.task.arn" semantic conventions. It represents the ARN of an
   373  	// [ECS task
   374  	// definition](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definitions.html).
   375  	//
   376  	// Type: string
   377  	// RequirementLevel: Optional
   378  	// Stability: stable
   379  	// Examples:
   380  	// 'arn:aws:ecs:us-west-1:123456789123:task/10838bed-421f-43ef-870a-f43feacbbb5b'
   381  	AWSECSTaskARNKey = attribute.Key("aws.ecs.task.arn")
   382  
   383  	// AWSECSTaskFamilyKey is the attribute Key conforming to the
   384  	// "aws.ecs.task.family" semantic conventions. It represents the task
   385  	// definition family this task definition is a member of.
   386  	//
   387  	// Type: string
   388  	// RequirementLevel: Optional
   389  	// Stability: stable
   390  	// Examples: 'opentelemetry-family'
   391  	AWSECSTaskFamilyKey = attribute.Key("aws.ecs.task.family")
   392  
   393  	// AWSECSTaskRevisionKey is the attribute Key conforming to the
   394  	// "aws.ecs.task.revision" semantic conventions. It represents the revision
   395  	// for this task definition.
   396  	//
   397  	// Type: string
   398  	// RequirementLevel: Optional
   399  	// Stability: stable
   400  	// Examples: '8', '26'
   401  	AWSECSTaskRevisionKey = attribute.Key("aws.ecs.task.revision")
   402  )
   403  
   404  var (
   405  	// ec2
   406  	AWSECSLaunchtypeEC2 = AWSECSLaunchtypeKey.String("ec2")
   407  	// fargate
   408  	AWSECSLaunchtypeFargate = AWSECSLaunchtypeKey.String("fargate")
   409  )
   410  
   411  // AWSECSContainerARN returns an attribute KeyValue conforming to the
   412  // "aws.ecs.container.arn" semantic conventions. It represents the Amazon
   413  // Resource Name (ARN) of an [ECS container
   414  // instance](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_instances.html).
   415  func AWSECSContainerARN(val string) attribute.KeyValue {
   416  	return AWSECSContainerARNKey.String(val)
   417  }
   418  
   419  // AWSECSClusterARN returns an attribute KeyValue conforming to the
   420  // "aws.ecs.cluster.arn" semantic conventions. It represents the ARN of an [ECS
   421  // cluster](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/clusters.html).
   422  func AWSECSClusterARN(val string) attribute.KeyValue {
   423  	return AWSECSClusterARNKey.String(val)
   424  }
   425  
   426  // AWSECSTaskARN returns an attribute KeyValue conforming to the
   427  // "aws.ecs.task.arn" semantic conventions. It represents the ARN of an [ECS
   428  // task
   429  // definition](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definitions.html).
   430  func AWSECSTaskARN(val string) attribute.KeyValue {
   431  	return AWSECSTaskARNKey.String(val)
   432  }
   433  
   434  // AWSECSTaskFamily returns an attribute KeyValue conforming to the
   435  // "aws.ecs.task.family" semantic conventions. It represents the task
   436  // definition family this task definition is a member of.
   437  func AWSECSTaskFamily(val string) attribute.KeyValue {
   438  	return AWSECSTaskFamilyKey.String(val)
   439  }
   440  
   441  // AWSECSTaskRevision returns an attribute KeyValue conforming to the
   442  // "aws.ecs.task.revision" semantic conventions. It represents the revision for
   443  // this task definition.
   444  func AWSECSTaskRevision(val string) attribute.KeyValue {
   445  	return AWSECSTaskRevisionKey.String(val)
   446  }
   447  
   448  // Resources used by AWS Elastic Kubernetes Service (EKS).
   449  const (
   450  	// AWSEKSClusterARNKey is the attribute Key conforming to the
   451  	// "aws.eks.cluster.arn" semantic conventions. It represents the ARN of an
   452  	// EKS cluster.
   453  	//
   454  	// Type: string
   455  	// RequirementLevel: Optional
   456  	// Stability: stable
   457  	// Examples: 'arn:aws:ecs:us-west-2:123456789123:cluster/my-cluster'
   458  	AWSEKSClusterARNKey = attribute.Key("aws.eks.cluster.arn")
   459  )
   460  
   461  // AWSEKSClusterARN returns an attribute KeyValue conforming to the
   462  // "aws.eks.cluster.arn" semantic conventions. It represents the ARN of an EKS
   463  // cluster.
   464  func AWSEKSClusterARN(val string) attribute.KeyValue {
   465  	return AWSEKSClusterARNKey.String(val)
   466  }
   467  
   468  // Resources specific to Amazon Web Services.
   469  const (
   470  	// AWSLogGroupNamesKey is the attribute Key conforming to the
   471  	// "aws.log.group.names" semantic conventions. It represents the name(s) of
   472  	// the AWS log group(s) an application is writing to.
   473  	//
   474  	// Type: string[]
   475  	// RequirementLevel: Optional
   476  	// Stability: stable
   477  	// Examples: '/aws/lambda/my-function', 'opentelemetry-service'
   478  	// Note: Multiple log groups must be supported for cases like
   479  	// multi-container applications, where a single application has sidecar
   480  	// containers, and each write to their own log group.
   481  	AWSLogGroupNamesKey = attribute.Key("aws.log.group.names")
   482  
   483  	// AWSLogGroupARNsKey is the attribute Key conforming to the
   484  	// "aws.log.group.arns" semantic conventions. It represents the Amazon
   485  	// Resource Name(s) (ARN) of the AWS log group(s).
   486  	//
   487  	// Type: string[]
   488  	// RequirementLevel: Optional
   489  	// Stability: stable
   490  	// Examples:
   491  	// 'arn:aws:logs:us-west-1:123456789012:log-group:/aws/my/group:*'
   492  	// Note: See the [log group ARN format
   493  	// documentation](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/iam-access-control-overview-cwl.html#CWL_ARN_Format).
   494  	AWSLogGroupARNsKey = attribute.Key("aws.log.group.arns")
   495  
   496  	// AWSLogStreamNamesKey is the attribute Key conforming to the
   497  	// "aws.log.stream.names" semantic conventions. It represents the name(s)
   498  	// of the AWS log stream(s) an application is writing to.
   499  	//
   500  	// Type: string[]
   501  	// RequirementLevel: Optional
   502  	// Stability: stable
   503  	// Examples: 'logs/main/10838bed-421f-43ef-870a-f43feacbbb5b'
   504  	AWSLogStreamNamesKey = attribute.Key("aws.log.stream.names")
   505  
   506  	// AWSLogStreamARNsKey is the attribute Key conforming to the
   507  	// "aws.log.stream.arns" semantic conventions. It represents the ARN(s) of
   508  	// the AWS log stream(s).
   509  	//
   510  	// Type: string[]
   511  	// RequirementLevel: Optional
   512  	// Stability: stable
   513  	// Examples:
   514  	// 'arn:aws:logs:us-west-1:123456789012:log-group:/aws/my/group:log-stream:logs/main/10838bed-421f-43ef-870a-f43feacbbb5b'
   515  	// Note: See the [log stream ARN format
   516  	// documentation](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/iam-access-control-overview-cwl.html#CWL_ARN_Format).
   517  	// One log group can contain several log streams, so these ARNs necessarily
   518  	// identify both a log group and a log stream.
   519  	AWSLogStreamARNsKey = attribute.Key("aws.log.stream.arns")
   520  )
   521  
   522  // AWSLogGroupNames returns an attribute KeyValue conforming to the
   523  // "aws.log.group.names" semantic conventions. It represents the name(s) of the
   524  // AWS log group(s) an application is writing to.
   525  func AWSLogGroupNames(val ...string) attribute.KeyValue {
   526  	return AWSLogGroupNamesKey.StringSlice(val)
   527  }
   528  
   529  // AWSLogGroupARNs returns an attribute KeyValue conforming to the
   530  // "aws.log.group.arns" semantic conventions. It represents the Amazon Resource
   531  // Name(s) (ARN) of the AWS log group(s).
   532  func AWSLogGroupARNs(val ...string) attribute.KeyValue {
   533  	return AWSLogGroupARNsKey.StringSlice(val)
   534  }
   535  
   536  // AWSLogStreamNames returns an attribute KeyValue conforming to the
   537  // "aws.log.stream.names" semantic conventions. It represents the name(s) of
   538  // the AWS log stream(s) an application is writing to.
   539  func AWSLogStreamNames(val ...string) attribute.KeyValue {
   540  	return AWSLogStreamNamesKey.StringSlice(val)
   541  }
   542  
   543  // AWSLogStreamARNs returns an attribute KeyValue conforming to the
   544  // "aws.log.stream.arns" semantic conventions. It represents the ARN(s) of the
   545  // AWS log stream(s).
   546  func AWSLogStreamARNs(val ...string) attribute.KeyValue {
   547  	return AWSLogStreamARNsKey.StringSlice(val)
   548  }
   549  
   550  // Resource used by Google Cloud Run.
   551  const (
   552  	// GCPCloudRunJobExecutionKey is the attribute Key conforming to the
   553  	// "gcp.cloud_run.job.execution" semantic conventions. It represents the
   554  	// name of the Cloud Run
   555  	// [execution](https://cloud.google.com/run/docs/managing/job-executions)
   556  	// being run for the Job, as set by the
   557  	// [`CLOUD_RUN_EXECUTION`](https://cloud.google.com/run/docs/container-contract#jobs-env-vars)
   558  	// environment variable.
   559  	//
   560  	// Type: string
   561  	// RequirementLevel: Optional
   562  	// Stability: stable
   563  	// Examples: 'job-name-xxxx', 'sample-job-mdw84'
   564  	GCPCloudRunJobExecutionKey = attribute.Key("gcp.cloud_run.job.execution")
   565  
   566  	// GCPCloudRunJobTaskIndexKey is the attribute Key conforming to the
   567  	// "gcp.cloud_run.job.task_index" semantic conventions. It represents the
   568  	// index for a task within an execution as provided by the
   569  	// [`CLOUD_RUN_TASK_INDEX`](https://cloud.google.com/run/docs/container-contract#jobs-env-vars)
   570  	// environment variable.
   571  	//
   572  	// Type: int
   573  	// RequirementLevel: Optional
   574  	// Stability: stable
   575  	// Examples: 0, 1
   576  	GCPCloudRunJobTaskIndexKey = attribute.Key("gcp.cloud_run.job.task_index")
   577  )
   578  
   579  // GCPCloudRunJobExecution returns an attribute KeyValue conforming to the
   580  // "gcp.cloud_run.job.execution" semantic conventions. It represents the name
   581  // of the Cloud Run
   582  // [execution](https://cloud.google.com/run/docs/managing/job-executions) being
   583  // run for the Job, as set by the
   584  // [`CLOUD_RUN_EXECUTION`](https://cloud.google.com/run/docs/container-contract#jobs-env-vars)
   585  // environment variable.
   586  func GCPCloudRunJobExecution(val string) attribute.KeyValue {
   587  	return GCPCloudRunJobExecutionKey.String(val)
   588  }
   589  
   590  // GCPCloudRunJobTaskIndex returns an attribute KeyValue conforming to the
   591  // "gcp.cloud_run.job.task_index" semantic conventions. It represents the index
   592  // for a task within an execution as provided by the
   593  // [`CLOUD_RUN_TASK_INDEX`](https://cloud.google.com/run/docs/container-contract#jobs-env-vars)
   594  // environment variable.
   595  func GCPCloudRunJobTaskIndex(val int) attribute.KeyValue {
   596  	return GCPCloudRunJobTaskIndexKey.Int(val)
   597  }
   598  
   599  // Resources used by Google Compute Engine (GCE).
   600  const (
   601  	// GCPGceInstanceNameKey is the attribute Key conforming to the
   602  	// "gcp.gce.instance.name" semantic conventions. It represents the instance
   603  	// name of a GCE instance. This is the value provided by `host.name`, the
   604  	// visible name of the instance in the Cloud Console UI, and the prefix for
   605  	// the default hostname of the instance as defined by the [default internal
   606  	// DNS
   607  	// name](https://cloud.google.com/compute/docs/internal-dns#instance-fully-qualified-domain-names).
   608  	//
   609  	// Type: string
   610  	// RequirementLevel: Optional
   611  	// Stability: stable
   612  	// Examples: 'instance-1', 'my-vm-name'
   613  	GCPGceInstanceNameKey = attribute.Key("gcp.gce.instance.name")
   614  
   615  	// GCPGceInstanceHostnameKey is the attribute Key conforming to the
   616  	// "gcp.gce.instance.hostname" semantic conventions. It represents the
   617  	// hostname of a GCE instance. This is the full value of the default or
   618  	// [custom
   619  	// hostname](https://cloud.google.com/compute/docs/instances/custom-hostname-vm).
   620  	//
   621  	// Type: string
   622  	// RequirementLevel: Optional
   623  	// Stability: stable
   624  	// Examples: 'my-host1234.example.com',
   625  	// 'sample-vm.us-west1-b.c.my-project.internal'
   626  	GCPGceInstanceHostnameKey = attribute.Key("gcp.gce.instance.hostname")
   627  )
   628  
   629  // GCPGceInstanceName returns an attribute KeyValue conforming to the
   630  // "gcp.gce.instance.name" semantic conventions. It represents the instance
   631  // name of a GCE instance. This is the value provided by `host.name`, the
   632  // visible name of the instance in the Cloud Console UI, and the prefix for the
   633  // default hostname of the instance as defined by the [default internal DNS
   634  // name](https://cloud.google.com/compute/docs/internal-dns#instance-fully-qualified-domain-names).
   635  func GCPGceInstanceName(val string) attribute.KeyValue {
   636  	return GCPGceInstanceNameKey.String(val)
   637  }
   638  
   639  // GCPGceInstanceHostname returns an attribute KeyValue conforming to the
   640  // "gcp.gce.instance.hostname" semantic conventions. It represents the hostname
   641  // of a GCE instance. This is the full value of the default or [custom
   642  // hostname](https://cloud.google.com/compute/docs/instances/custom-hostname-vm).
   643  func GCPGceInstanceHostname(val string) attribute.KeyValue {
   644  	return GCPGceInstanceHostnameKey.String(val)
   645  }
   646  
   647  // Heroku dyno metadata
   648  const (
   649  	// HerokuReleaseCreationTimestampKey is the attribute Key conforming to the
   650  	// "heroku.release.creation_timestamp" semantic conventions. It represents
   651  	// the time and date the release was created
   652  	//
   653  	// Type: string
   654  	// RequirementLevel: Optional
   655  	// Stability: stable
   656  	// Examples: '2022-10-23T18:00:42Z'
   657  	HerokuReleaseCreationTimestampKey = attribute.Key("heroku.release.creation_timestamp")
   658  
   659  	// HerokuReleaseCommitKey is the attribute Key conforming to the
   660  	// "heroku.release.commit" semantic conventions. It represents the commit
   661  	// hash for the current release
   662  	//
   663  	// Type: string
   664  	// RequirementLevel: Optional
   665  	// Stability: stable
   666  	// Examples: 'e6134959463efd8966b20e75b913cafe3f5ec'
   667  	HerokuReleaseCommitKey = attribute.Key("heroku.release.commit")
   668  
   669  	// HerokuAppIDKey is the attribute Key conforming to the "heroku.app.id"
   670  	// semantic conventions. It represents the unique identifier for the
   671  	// application
   672  	//
   673  	// Type: string
   674  	// RequirementLevel: Optional
   675  	// Stability: stable
   676  	// Examples: '2daa2797-e42b-4624-9322-ec3f968df4da'
   677  	HerokuAppIDKey = attribute.Key("heroku.app.id")
   678  )
   679  
   680  // HerokuReleaseCreationTimestamp returns an attribute KeyValue conforming
   681  // to the "heroku.release.creation_timestamp" semantic conventions. It
   682  // represents the time and date the release was created
   683  func HerokuReleaseCreationTimestamp(val string) attribute.KeyValue {
   684  	return HerokuReleaseCreationTimestampKey.String(val)
   685  }
   686  
   687  // HerokuReleaseCommit returns an attribute KeyValue conforming to the
   688  // "heroku.release.commit" semantic conventions. It represents the commit hash
   689  // for the current release
   690  func HerokuReleaseCommit(val string) attribute.KeyValue {
   691  	return HerokuReleaseCommitKey.String(val)
   692  }
   693  
   694  // HerokuAppID returns an attribute KeyValue conforming to the
   695  // "heroku.app.id" semantic conventions. It represents the unique identifier
   696  // for the application
   697  func HerokuAppID(val string) attribute.KeyValue {
   698  	return HerokuAppIDKey.String(val)
   699  }
   700  
   701  // A container instance.
   702  const (
   703  	// ContainerNameKey is the attribute Key conforming to the "container.name"
   704  	// semantic conventions. It represents the container name used by container
   705  	// runtime.
   706  	//
   707  	// Type: string
   708  	// RequirementLevel: Optional
   709  	// Stability: stable
   710  	// Examples: 'opentelemetry-autoconf'
   711  	ContainerNameKey = attribute.Key("container.name")
   712  
   713  	// ContainerIDKey is the attribute Key conforming to the "container.id"
   714  	// semantic conventions. It represents the container ID. Usually a UUID, as
   715  	// for example used to [identify Docker
   716  	// containers](https://docs.docker.com/engine/reference/run/#container-identification).
   717  	// The UUID might be abbreviated.
   718  	//
   719  	// Type: string
   720  	// RequirementLevel: Optional
   721  	// Stability: stable
   722  	// Examples: 'a3bf90e006b2'
   723  	ContainerIDKey = attribute.Key("container.id")
   724  
   725  	// ContainerRuntimeKey is the attribute Key conforming to the
   726  	// "container.runtime" semantic conventions. It represents the container
   727  	// runtime managing this container.
   728  	//
   729  	// Type: string
   730  	// RequirementLevel: Optional
   731  	// Stability: stable
   732  	// Examples: 'docker', 'containerd', 'rkt'
   733  	ContainerRuntimeKey = attribute.Key("container.runtime")
   734  
   735  	// ContainerImageNameKey is the attribute Key conforming to the
   736  	// "container.image.name" semantic conventions. It represents the name of
   737  	// the image the container was built on.
   738  	//
   739  	// Type: string
   740  	// RequirementLevel: Optional
   741  	// Stability: stable
   742  	// Examples: 'gcr.io/opentelemetry/operator'
   743  	ContainerImageNameKey = attribute.Key("container.image.name")
   744  
   745  	// ContainerImageTagKey is the attribute Key conforming to the
   746  	// "container.image.tag" semantic conventions. It represents the container
   747  	// image tag.
   748  	//
   749  	// Type: string
   750  	// RequirementLevel: Optional
   751  	// Stability: stable
   752  	// Examples: '0.1'
   753  	ContainerImageTagKey = attribute.Key("container.image.tag")
   754  
   755  	// ContainerImageIDKey is the attribute Key conforming to the
   756  	// "container.image.id" semantic conventions. It represents the runtime
   757  	// specific image identifier. Usually a hash algorithm followed by a UUID.
   758  	//
   759  	// Type: string
   760  	// RequirementLevel: Optional
   761  	// Stability: stable
   762  	// Examples:
   763  	// 'sha256:19c92d0a00d1b66d897bceaa7319bee0dd38a10a851c60bcec9474aa3f01e50f'
   764  	// Note: Docker defines a sha256 of the image id; `container.image.id`
   765  	// corresponds to the `Image` field from the Docker container inspect
   766  	// [API](https://docs.docker.com/engine/api/v1.43/#tag/Container/operation/ContainerInspect)
   767  	// endpoint.
   768  	// K8S defines a link to the container registry repository with digest
   769  	// `"imageID": "registry.azurecr.io
   770  	// /namespace/service/dockerfile@sha256:bdeabd40c3a8a492eaf9e8e44d0ebbb84bac7ee25ac0cf8a7159d25f62555625"`.
   771  	// OCI defines a digest of manifest.
   772  	ContainerImageIDKey = attribute.Key("container.image.id")
   773  
   774  	// ContainerCommandKey is the attribute Key conforming to the
   775  	// "container.command" semantic conventions. It represents the command used
   776  	// to run the container (i.e. the command name).
   777  	//
   778  	// Type: string
   779  	// RequirementLevel: Optional
   780  	// Stability: stable
   781  	// Examples: 'otelcontribcol'
   782  	// Note: If using embedded credentials or sensitive data, it is recommended
   783  	// to remove them to prevent potential leakage.
   784  	ContainerCommandKey = attribute.Key("container.command")
   785  
   786  	// ContainerCommandLineKey is the attribute Key conforming to the
   787  	// "container.command_line" semantic conventions. It represents the full
   788  	// command run by the container as a single string representing the full
   789  	// command. [2]
   790  	//
   791  	// Type: string
   792  	// RequirementLevel: Optional
   793  	// Stability: stable
   794  	// Examples: 'otelcontribcol --config config.yaml'
   795  	ContainerCommandLineKey = attribute.Key("container.command_line")
   796  
   797  	// ContainerCommandArgsKey is the attribute Key conforming to the
   798  	// "container.command_args" semantic conventions. It represents the all the
   799  	// command arguments (including the command/executable itself) run by the
   800  	// container. [2]
   801  	//
   802  	// Type: string[]
   803  	// RequirementLevel: Optional
   804  	// Stability: stable
   805  	// Examples: 'otelcontribcol, --config, config.yaml'
   806  	ContainerCommandArgsKey = attribute.Key("container.command_args")
   807  )
   808  
   809  // ContainerName returns an attribute KeyValue conforming to the
   810  // "container.name" semantic conventions. It represents the container name used
   811  // by container runtime.
   812  func ContainerName(val string) attribute.KeyValue {
   813  	return ContainerNameKey.String(val)
   814  }
   815  
   816  // ContainerID returns an attribute KeyValue conforming to the
   817  // "container.id" semantic conventions. It represents the container ID. Usually
   818  // a UUID, as for example used to [identify Docker
   819  // containers](https://docs.docker.com/engine/reference/run/#container-identification).
   820  // The UUID might be abbreviated.
   821  func ContainerID(val string) attribute.KeyValue {
   822  	return ContainerIDKey.String(val)
   823  }
   824  
   825  // ContainerRuntime returns an attribute KeyValue conforming to the
   826  // "container.runtime" semantic conventions. It represents the container
   827  // runtime managing this container.
   828  func ContainerRuntime(val string) attribute.KeyValue {
   829  	return ContainerRuntimeKey.String(val)
   830  }
   831  
   832  // ContainerImageName returns an attribute KeyValue conforming to the
   833  // "container.image.name" semantic conventions. It represents the name of the
   834  // image the container was built on.
   835  func ContainerImageName(val string) attribute.KeyValue {
   836  	return ContainerImageNameKey.String(val)
   837  }
   838  
   839  // ContainerImageTag returns an attribute KeyValue conforming to the
   840  // "container.image.tag" semantic conventions. It represents the container
   841  // image tag.
   842  func ContainerImageTag(val string) attribute.KeyValue {
   843  	return ContainerImageTagKey.String(val)
   844  }
   845  
   846  // ContainerImageID returns an attribute KeyValue conforming to the
   847  // "container.image.id" semantic conventions. It represents the runtime
   848  // specific image identifier. Usually a hash algorithm followed by a UUID.
   849  func ContainerImageID(val string) attribute.KeyValue {
   850  	return ContainerImageIDKey.String(val)
   851  }
   852  
   853  // ContainerCommand returns an attribute KeyValue conforming to the
   854  // "container.command" semantic conventions. It represents the command used to
   855  // run the container (i.e. the command name).
   856  func ContainerCommand(val string) attribute.KeyValue {
   857  	return ContainerCommandKey.String(val)
   858  }
   859  
   860  // ContainerCommandLine returns an attribute KeyValue conforming to the
   861  // "container.command_line" semantic conventions. It represents the full
   862  // command run by the container as a single string representing the full
   863  // command. [2]
   864  func ContainerCommandLine(val string) attribute.KeyValue {
   865  	return ContainerCommandLineKey.String(val)
   866  }
   867  
   868  // ContainerCommandArgs returns an attribute KeyValue conforming to the
   869  // "container.command_args" semantic conventions. It represents the all the
   870  // command arguments (including the command/executable itself) run by the
   871  // container. [2]
   872  func ContainerCommandArgs(val ...string) attribute.KeyValue {
   873  	return ContainerCommandArgsKey.StringSlice(val)
   874  }
   875  
   876  // The software deployment.
   877  const (
   878  	// DeploymentEnvironmentKey is the attribute Key conforming to the
   879  	// "deployment.environment" semantic conventions. It represents the name of
   880  	// the [deployment
   881  	// environment](https://en.wikipedia.org/wiki/Deployment_environment) (aka
   882  	// deployment tier).
   883  	//
   884  	// Type: string
   885  	// RequirementLevel: Optional
   886  	// Stability: stable
   887  	// Examples: 'staging', 'production'
   888  	DeploymentEnvironmentKey = attribute.Key("deployment.environment")
   889  )
   890  
   891  // DeploymentEnvironment returns an attribute KeyValue conforming to the
   892  // "deployment.environment" semantic conventions. It represents the name of the
   893  // [deployment
   894  // environment](https://en.wikipedia.org/wiki/Deployment_environment) (aka
   895  // deployment tier).
   896  func DeploymentEnvironment(val string) attribute.KeyValue {
   897  	return DeploymentEnvironmentKey.String(val)
   898  }
   899  
   900  // The device on which the process represented by this resource is running.
   901  const (
   902  	// DeviceIDKey is the attribute Key conforming to the "device.id" semantic
   903  	// conventions. It represents a unique identifier representing the device
   904  	//
   905  	// Type: string
   906  	// RequirementLevel: Optional
   907  	// Stability: stable
   908  	// Examples: '2ab2916d-a51f-4ac8-80ee-45ac31a28092'
   909  	// Note: The device identifier MUST only be defined using the values
   910  	// outlined below. This value is not an advertising identifier and MUST NOT
   911  	// be used as such. On iOS (Swift or Objective-C), this value MUST be equal
   912  	// to the [vendor
   913  	// identifier](https://developer.apple.com/documentation/uikit/uidevice/1620059-identifierforvendor).
   914  	// On Android (Java or Kotlin), this value MUST be equal to the Firebase
   915  	// Installation ID or a globally unique UUID which is persisted across
   916  	// sessions in your application. More information can be found
   917  	// [here](https://developer.android.com/training/articles/user-data-ids) on
   918  	// best practices and exact implementation details. Caution should be taken
   919  	// when storing personal data or anything which can identify a user. GDPR
   920  	// and data protection laws may apply, ensure you do your own due
   921  	// diligence.
   922  	DeviceIDKey = attribute.Key("device.id")
   923  
   924  	// DeviceModelIdentifierKey is the attribute Key conforming to the
   925  	// "device.model.identifier" semantic conventions. It represents the model
   926  	// identifier for the device
   927  	//
   928  	// Type: string
   929  	// RequirementLevel: Optional
   930  	// Stability: stable
   931  	// Examples: 'iPhone3,4', 'SM-G920F'
   932  	// Note: It's recommended this value represents a machine readable version
   933  	// of the model identifier rather than the market or consumer-friendly name
   934  	// of the device.
   935  	DeviceModelIdentifierKey = attribute.Key("device.model.identifier")
   936  
   937  	// DeviceModelNameKey is the attribute Key conforming to the
   938  	// "device.model.name" semantic conventions. It represents the marketing
   939  	// name for the device model
   940  	//
   941  	// Type: string
   942  	// RequirementLevel: Optional
   943  	// Stability: stable
   944  	// Examples: 'iPhone 6s Plus', 'Samsung Galaxy S6'
   945  	// Note: It's recommended this value represents a human readable version of
   946  	// the device model rather than a machine readable alternative.
   947  	DeviceModelNameKey = attribute.Key("device.model.name")
   948  
   949  	// DeviceManufacturerKey is the attribute Key conforming to the
   950  	// "device.manufacturer" semantic conventions. It represents the name of
   951  	// the device manufacturer
   952  	//
   953  	// Type: string
   954  	// RequirementLevel: Optional
   955  	// Stability: stable
   956  	// Examples: 'Apple', 'Samsung'
   957  	// Note: The Android OS provides this field via
   958  	// [Build](https://developer.android.com/reference/android/os/Build#MANUFACTURER).
   959  	// iOS apps SHOULD hardcode the value `Apple`.
   960  	DeviceManufacturerKey = attribute.Key("device.manufacturer")
   961  )
   962  
   963  // DeviceID returns an attribute KeyValue conforming to the "device.id"
   964  // semantic conventions. It represents a unique identifier representing the
   965  // device
   966  func DeviceID(val string) attribute.KeyValue {
   967  	return DeviceIDKey.String(val)
   968  }
   969  
   970  // DeviceModelIdentifier returns an attribute KeyValue conforming to the
   971  // "device.model.identifier" semantic conventions. It represents the model
   972  // identifier for the device
   973  func DeviceModelIdentifier(val string) attribute.KeyValue {
   974  	return DeviceModelIdentifierKey.String(val)
   975  }
   976  
   977  // DeviceModelName returns an attribute KeyValue conforming to the
   978  // "device.model.name" semantic conventions. It represents the marketing name
   979  // for the device model
   980  func DeviceModelName(val string) attribute.KeyValue {
   981  	return DeviceModelNameKey.String(val)
   982  }
   983  
   984  // DeviceManufacturer returns an attribute KeyValue conforming to the
   985  // "device.manufacturer" semantic conventions. It represents the name of the
   986  // device manufacturer
   987  func DeviceManufacturer(val string) attribute.KeyValue {
   988  	return DeviceManufacturerKey.String(val)
   989  }
   990  
   991  // A serverless instance.
   992  const (
   993  	// FaaSNameKey is the attribute Key conforming to the "faas.name" semantic
   994  	// conventions. It represents the name of the single function that this
   995  	// runtime instance executes.
   996  	//
   997  	// Type: string
   998  	// RequirementLevel: Required
   999  	// Stability: stable
  1000  	// Examples: 'my-function', 'myazurefunctionapp/some-function-name'
  1001  	// Note: This is the name of the function as configured/deployed on the
  1002  	// FaaS
  1003  	// platform and is usually different from the name of the callback
  1004  	// function (which may be stored in the
  1005  	// [`code.namespace`/`code.function`](/docs/general/general-attributes.md#source-code-attributes)
  1006  	// span attributes).
  1007  	//
  1008  	// For some cloud providers, the above definition is ambiguous. The
  1009  	// following
  1010  	// definition of function name MUST be used for this attribute
  1011  	// (and consequently the span name) for the listed cloud
  1012  	// providers/products:
  1013  	//
  1014  	// * **Azure:**  The full name `<FUNCAPP>/<FUNC>`, i.e., function app name
  1015  	//   followed by a forward slash followed by the function name (this form
  1016  	//   can also be seen in the resource JSON for the function).
  1017  	//   This means that a span attribute MUST be used, as an Azure function
  1018  	//   app can host multiple functions that would usually share
  1019  	//   a TracerProvider (see also the `cloud.resource_id` attribute).
  1020  	FaaSNameKey = attribute.Key("faas.name")
  1021  
  1022  	// FaaSVersionKey is the attribute Key conforming to the "faas.version"
  1023  	// semantic conventions. It represents the immutable version of the
  1024  	// function being executed.
  1025  	//
  1026  	// Type: string
  1027  	// RequirementLevel: Optional
  1028  	// Stability: stable
  1029  	// Examples: '26', 'pinkfroid-00002'
  1030  	// Note: Depending on the cloud provider and platform, use:
  1031  	//
  1032  	// * **AWS Lambda:** The [function
  1033  	// version](https://docs.aws.amazon.com/lambda/latest/dg/configuration-versions.html)
  1034  	//   (an integer represented as a decimal string).
  1035  	// * **Google Cloud Run (Services):** The
  1036  	// [revision](https://cloud.google.com/run/docs/managing/revisions)
  1037  	//   (i.e., the function name plus the revision suffix).
  1038  	// * **Google Cloud Functions:** The value of the
  1039  	//   [`K_REVISION` environment
  1040  	// variable](https://cloud.google.com/functions/docs/env-var#runtime_environment_variables_set_automatically).
  1041  	// * **Azure Functions:** Not applicable. Do not set this attribute.
  1042  	FaaSVersionKey = attribute.Key("faas.version")
  1043  
  1044  	// FaaSInstanceKey is the attribute Key conforming to the "faas.instance"
  1045  	// semantic conventions. It represents the execution environment ID as a
  1046  	// string, that will be potentially reused for other invocations to the
  1047  	// same function/function version.
  1048  	//
  1049  	// Type: string
  1050  	// RequirementLevel: Optional
  1051  	// Stability: stable
  1052  	// Examples: '2021/06/28/[$LATEST]2f399eb14537447da05ab2a2e39309de'
  1053  	// Note: * **AWS Lambda:** Use the (full) log stream name.
  1054  	FaaSInstanceKey = attribute.Key("faas.instance")
  1055  
  1056  	// FaaSMaxMemoryKey is the attribute Key conforming to the
  1057  	// "faas.max_memory" semantic conventions. It represents the amount of
  1058  	// memory available to the serverless function converted to Bytes.
  1059  	//
  1060  	// Type: int
  1061  	// RequirementLevel: Optional
  1062  	// Stability: stable
  1063  	// Examples: 134217728
  1064  	// Note: It's recommended to set this attribute since e.g. too little
  1065  	// memory can easily stop a Java AWS Lambda function from working
  1066  	// correctly. On AWS Lambda, the environment variable
  1067  	// `AWS_LAMBDA_FUNCTION_MEMORY_SIZE` provides this information (which must
  1068  	// be multiplied by 1,048,576).
  1069  	FaaSMaxMemoryKey = attribute.Key("faas.max_memory")
  1070  )
  1071  
  1072  // FaaSName returns an attribute KeyValue conforming to the "faas.name"
  1073  // semantic conventions. It represents the name of the single function that
  1074  // this runtime instance executes.
  1075  func FaaSName(val string) attribute.KeyValue {
  1076  	return FaaSNameKey.String(val)
  1077  }
  1078  
  1079  // FaaSVersion returns an attribute KeyValue conforming to the
  1080  // "faas.version" semantic conventions. It represents the immutable version of
  1081  // the function being executed.
  1082  func FaaSVersion(val string) attribute.KeyValue {
  1083  	return FaaSVersionKey.String(val)
  1084  }
  1085  
  1086  // FaaSInstance returns an attribute KeyValue conforming to the
  1087  // "faas.instance" semantic conventions. It represents the execution
  1088  // environment ID as a string, that will be potentially reused for other
  1089  // invocations to the same function/function version.
  1090  func FaaSInstance(val string) attribute.KeyValue {
  1091  	return FaaSInstanceKey.String(val)
  1092  }
  1093  
  1094  // FaaSMaxMemory returns an attribute KeyValue conforming to the
  1095  // "faas.max_memory" semantic conventions. It represents the amount of memory
  1096  // available to the serverless function converted to Bytes.
  1097  func FaaSMaxMemory(val int) attribute.KeyValue {
  1098  	return FaaSMaxMemoryKey.Int(val)
  1099  }
  1100  
  1101  // A host is defined as a computing instance. For example, physical servers,
  1102  // virtual machines, switches or disk array.
  1103  const (
  1104  	// HostIDKey is the attribute Key conforming to the "host.id" semantic
  1105  	// conventions. It represents the unique host ID. For Cloud, this must be
  1106  	// the instance_id assigned by the cloud provider. For non-containerized
  1107  	// systems, this should be the `machine-id`. See the table below for the
  1108  	// sources to use to determine the `machine-id` based on operating system.
  1109  	//
  1110  	// Type: string
  1111  	// RequirementLevel: Optional
  1112  	// Stability: stable
  1113  	// Examples: 'fdbf79e8af94cb7f9e8df36789187052'
  1114  	HostIDKey = attribute.Key("host.id")
  1115  
  1116  	// HostNameKey is the attribute Key conforming to the "host.name" semantic
  1117  	// conventions. It represents the name of the host. On Unix systems, it may
  1118  	// contain what the hostname command returns, or the fully qualified
  1119  	// hostname, or another name specified by the user.
  1120  	//
  1121  	// Type: string
  1122  	// RequirementLevel: Optional
  1123  	// Stability: stable
  1124  	// Examples: 'opentelemetry-test'
  1125  	HostNameKey = attribute.Key("host.name")
  1126  
  1127  	// HostTypeKey is the attribute Key conforming to the "host.type" semantic
  1128  	// conventions. It represents the type of host. For Cloud, this must be the
  1129  	// machine type.
  1130  	//
  1131  	// Type: string
  1132  	// RequirementLevel: Optional
  1133  	// Stability: stable
  1134  	// Examples: 'n1-standard-1'
  1135  	HostTypeKey = attribute.Key("host.type")
  1136  
  1137  	// HostArchKey is the attribute Key conforming to the "host.arch" semantic
  1138  	// conventions. It represents the CPU architecture the host system is
  1139  	// running on.
  1140  	//
  1141  	// Type: Enum
  1142  	// RequirementLevel: Optional
  1143  	// Stability: stable
  1144  	HostArchKey = attribute.Key("host.arch")
  1145  
  1146  	// HostImageNameKey is the attribute Key conforming to the
  1147  	// "host.image.name" semantic conventions. It represents the name of the VM
  1148  	// image or OS install the host was instantiated from.
  1149  	//
  1150  	// Type: string
  1151  	// RequirementLevel: Optional
  1152  	// Stability: stable
  1153  	// Examples: 'infra-ami-eks-worker-node-7d4ec78312', 'CentOS-8-x86_64-1905'
  1154  	HostImageNameKey = attribute.Key("host.image.name")
  1155  
  1156  	// HostImageIDKey is the attribute Key conforming to the "host.image.id"
  1157  	// semantic conventions. It represents the vM image ID or host OS image ID.
  1158  	// For Cloud, this value is from the provider.
  1159  	//
  1160  	// Type: string
  1161  	// RequirementLevel: Optional
  1162  	// Stability: stable
  1163  	// Examples: 'ami-07b06b442921831e5'
  1164  	HostImageIDKey = attribute.Key("host.image.id")
  1165  
  1166  	// HostImageVersionKey is the attribute Key conforming to the
  1167  	// "host.image.version" semantic conventions. It represents the version
  1168  	// string of the VM image or host OS as defined in [Version
  1169  	// Attributes](README.md#version-attributes).
  1170  	//
  1171  	// Type: string
  1172  	// RequirementLevel: Optional
  1173  	// Stability: stable
  1174  	// Examples: '0.1'
  1175  	HostImageVersionKey = attribute.Key("host.image.version")
  1176  )
  1177  
  1178  var (
  1179  	// AMD64
  1180  	HostArchAMD64 = HostArchKey.String("amd64")
  1181  	// ARM32
  1182  	HostArchARM32 = HostArchKey.String("arm32")
  1183  	// ARM64
  1184  	HostArchARM64 = HostArchKey.String("arm64")
  1185  	// Itanium
  1186  	HostArchIA64 = HostArchKey.String("ia64")
  1187  	// 32-bit PowerPC
  1188  	HostArchPPC32 = HostArchKey.String("ppc32")
  1189  	// 64-bit PowerPC
  1190  	HostArchPPC64 = HostArchKey.String("ppc64")
  1191  	// IBM z/Architecture
  1192  	HostArchS390x = HostArchKey.String("s390x")
  1193  	// 32-bit x86
  1194  	HostArchX86 = HostArchKey.String("x86")
  1195  )
  1196  
  1197  // HostID returns an attribute KeyValue conforming to the "host.id" semantic
  1198  // conventions. It represents the unique host ID. For Cloud, this must be the
  1199  // instance_id assigned by the cloud provider. For non-containerized systems,
  1200  // this should be the `machine-id`. See the table below for the sources to use
  1201  // to determine the `machine-id` based on operating system.
  1202  func HostID(val string) attribute.KeyValue {
  1203  	return HostIDKey.String(val)
  1204  }
  1205  
  1206  // HostName returns an attribute KeyValue conforming to the "host.name"
  1207  // semantic conventions. It represents the name of the host. On Unix systems,
  1208  // it may contain what the hostname command returns, or the fully qualified
  1209  // hostname, or another name specified by the user.
  1210  func HostName(val string) attribute.KeyValue {
  1211  	return HostNameKey.String(val)
  1212  }
  1213  
  1214  // HostType returns an attribute KeyValue conforming to the "host.type"
  1215  // semantic conventions. It represents the type of host. For Cloud, this must
  1216  // be the machine type.
  1217  func HostType(val string) attribute.KeyValue {
  1218  	return HostTypeKey.String(val)
  1219  }
  1220  
  1221  // HostImageName returns an attribute KeyValue conforming to the
  1222  // "host.image.name" semantic conventions. It represents the name of the VM
  1223  // image or OS install the host was instantiated from.
  1224  func HostImageName(val string) attribute.KeyValue {
  1225  	return HostImageNameKey.String(val)
  1226  }
  1227  
  1228  // HostImageID returns an attribute KeyValue conforming to the
  1229  // "host.image.id" semantic conventions. It represents the vM image ID or host
  1230  // OS image ID. For Cloud, this value is from the provider.
  1231  func HostImageID(val string) attribute.KeyValue {
  1232  	return HostImageIDKey.String(val)
  1233  }
  1234  
  1235  // HostImageVersion returns an attribute KeyValue conforming to the
  1236  // "host.image.version" semantic conventions. It represents the version string
  1237  // of the VM image or host OS as defined in [Version
  1238  // Attributes](README.md#version-attributes).
  1239  func HostImageVersion(val string) attribute.KeyValue {
  1240  	return HostImageVersionKey.String(val)
  1241  }
  1242  
  1243  // A Kubernetes Cluster.
  1244  const (
  1245  	// K8SClusterNameKey is the attribute Key conforming to the
  1246  	// "k8s.cluster.name" semantic conventions. It represents the name of the
  1247  	// cluster.
  1248  	//
  1249  	// Type: string
  1250  	// RequirementLevel: Optional
  1251  	// Stability: stable
  1252  	// Examples: 'opentelemetry-cluster'
  1253  	K8SClusterNameKey = attribute.Key("k8s.cluster.name")
  1254  
  1255  	// K8SClusterUIDKey is the attribute Key conforming to the
  1256  	// "k8s.cluster.uid" semantic conventions. It represents a pseudo-ID for
  1257  	// the cluster, set to the UID of the `kube-system` namespace.
  1258  	//
  1259  	// Type: string
  1260  	// RequirementLevel: Optional
  1261  	// Stability: stable
  1262  	// Examples: '218fc5a9-a5f1-4b54-aa05-46717d0ab26d'
  1263  	// Note: K8S does not have support for obtaining a cluster ID. If this is
  1264  	// ever
  1265  	// added, we will recommend collecting the `k8s.cluster.uid` through the
  1266  	// official APIs. In the meantime, we are able to use the `uid` of the
  1267  	// `kube-system` namespace as a proxy for cluster ID. Read on for the
  1268  	// rationale.
  1269  	//
  1270  	// Every object created in a K8S cluster is assigned a distinct UID. The
  1271  	// `kube-system` namespace is used by Kubernetes itself and will exist
  1272  	// for the lifetime of the cluster. Using the `uid` of the `kube-system`
  1273  	// namespace is a reasonable proxy for the K8S ClusterID as it will only
  1274  	// change if the cluster is rebuilt. Furthermore, Kubernetes UIDs are
  1275  	// UUIDs as standardized by
  1276  	// [ISO/IEC 9834-8 and ITU-T
  1277  	// X.667](https://www.itu.int/ITU-T/studygroups/com17/oid.html).
  1278  	// Which states:
  1279  	//
  1280  	// > If generated according to one of the mechanisms defined in Rec.
  1281  	//   ITU-T X.667 | ISO/IEC 9834-8, a UUID is either guaranteed to be
  1282  	//   different from all other UUIDs generated before 3603 A.D., or is
  1283  	//   extremely likely to be different (depending on the mechanism chosen).
  1284  	//
  1285  	// Therefore, UIDs between clusters should be extremely unlikely to
  1286  	// conflict.
  1287  	K8SClusterUIDKey = attribute.Key("k8s.cluster.uid")
  1288  )
  1289  
  1290  // K8SClusterName returns an attribute KeyValue conforming to the
  1291  // "k8s.cluster.name" semantic conventions. It represents the name of the
  1292  // cluster.
  1293  func K8SClusterName(val string) attribute.KeyValue {
  1294  	return K8SClusterNameKey.String(val)
  1295  }
  1296  
  1297  // K8SClusterUID returns an attribute KeyValue conforming to the
  1298  // "k8s.cluster.uid" semantic conventions. It represents a pseudo-ID for the
  1299  // cluster, set to the UID of the `kube-system` namespace.
  1300  func K8SClusterUID(val string) attribute.KeyValue {
  1301  	return K8SClusterUIDKey.String(val)
  1302  }
  1303  
  1304  // A Kubernetes Node object.
  1305  const (
  1306  	// K8SNodeNameKey is the attribute Key conforming to the "k8s.node.name"
  1307  	// semantic conventions. It represents the name of the Node.
  1308  	//
  1309  	// Type: string
  1310  	// RequirementLevel: Optional
  1311  	// Stability: stable
  1312  	// Examples: 'node-1'
  1313  	K8SNodeNameKey = attribute.Key("k8s.node.name")
  1314  
  1315  	// K8SNodeUIDKey is the attribute Key conforming to the "k8s.node.uid"
  1316  	// semantic conventions. It represents the UID of the Node.
  1317  	//
  1318  	// Type: string
  1319  	// RequirementLevel: Optional
  1320  	// Stability: stable
  1321  	// Examples: '1eb3a0c6-0477-4080-a9cb-0cb7db65c6a2'
  1322  	K8SNodeUIDKey = attribute.Key("k8s.node.uid")
  1323  )
  1324  
  1325  // K8SNodeName returns an attribute KeyValue conforming to the
  1326  // "k8s.node.name" semantic conventions. It represents the name of the Node.
  1327  func K8SNodeName(val string) attribute.KeyValue {
  1328  	return K8SNodeNameKey.String(val)
  1329  }
  1330  
  1331  // K8SNodeUID returns an attribute KeyValue conforming to the "k8s.node.uid"
  1332  // semantic conventions. It represents the UID of the Node.
  1333  func K8SNodeUID(val string) attribute.KeyValue {
  1334  	return K8SNodeUIDKey.String(val)
  1335  }
  1336  
  1337  // A Kubernetes Namespace.
  1338  const (
  1339  	// K8SNamespaceNameKey is the attribute Key conforming to the
  1340  	// "k8s.namespace.name" semantic conventions. It represents the name of the
  1341  	// namespace that the pod is running in.
  1342  	//
  1343  	// Type: string
  1344  	// RequirementLevel: Optional
  1345  	// Stability: stable
  1346  	// Examples: 'default'
  1347  	K8SNamespaceNameKey = attribute.Key("k8s.namespace.name")
  1348  )
  1349  
  1350  // K8SNamespaceName returns an attribute KeyValue conforming to the
  1351  // "k8s.namespace.name" semantic conventions. It represents the name of the
  1352  // namespace that the pod is running in.
  1353  func K8SNamespaceName(val string) attribute.KeyValue {
  1354  	return K8SNamespaceNameKey.String(val)
  1355  }
  1356  
  1357  // A Kubernetes Pod object.
  1358  const (
  1359  	// K8SPodUIDKey is the attribute Key conforming to the "k8s.pod.uid"
  1360  	// semantic conventions. It represents the UID of the Pod.
  1361  	//
  1362  	// Type: string
  1363  	// RequirementLevel: Optional
  1364  	// Stability: stable
  1365  	// Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
  1366  	K8SPodUIDKey = attribute.Key("k8s.pod.uid")
  1367  
  1368  	// K8SPodNameKey is the attribute Key conforming to the "k8s.pod.name"
  1369  	// semantic conventions. It represents the name of the Pod.
  1370  	//
  1371  	// Type: string
  1372  	// RequirementLevel: Optional
  1373  	// Stability: stable
  1374  	// Examples: 'opentelemetry-pod-autoconf'
  1375  	K8SPodNameKey = attribute.Key("k8s.pod.name")
  1376  )
  1377  
  1378  // K8SPodUID returns an attribute KeyValue conforming to the "k8s.pod.uid"
  1379  // semantic conventions. It represents the UID of the Pod.
  1380  func K8SPodUID(val string) attribute.KeyValue {
  1381  	return K8SPodUIDKey.String(val)
  1382  }
  1383  
  1384  // K8SPodName returns an attribute KeyValue conforming to the "k8s.pod.name"
  1385  // semantic conventions. It represents the name of the Pod.
  1386  func K8SPodName(val string) attribute.KeyValue {
  1387  	return K8SPodNameKey.String(val)
  1388  }
  1389  
  1390  // A container in a
  1391  // [PodTemplate](https://kubernetes.io/docs/concepts/workloads/pods/#pod-templates).
  1392  const (
  1393  	// K8SContainerNameKey is the attribute Key conforming to the
  1394  	// "k8s.container.name" semantic conventions. It represents the name of the
  1395  	// Container from Pod specification, must be unique within a Pod. Container
  1396  	// runtime usually uses different globally unique name (`container.name`).
  1397  	//
  1398  	// Type: string
  1399  	// RequirementLevel: Optional
  1400  	// Stability: stable
  1401  	// Examples: 'redis'
  1402  	K8SContainerNameKey = attribute.Key("k8s.container.name")
  1403  
  1404  	// K8SContainerRestartCountKey is the attribute Key conforming to the
  1405  	// "k8s.container.restart_count" semantic conventions. It represents the
  1406  	// number of times the container was restarted. This attribute can be used
  1407  	// to identify a particular container (running or stopped) within a
  1408  	// container spec.
  1409  	//
  1410  	// Type: int
  1411  	// RequirementLevel: Optional
  1412  	// Stability: stable
  1413  	// Examples: 0, 2
  1414  	K8SContainerRestartCountKey = attribute.Key("k8s.container.restart_count")
  1415  )
  1416  
  1417  // K8SContainerName returns an attribute KeyValue conforming to the
  1418  // "k8s.container.name" semantic conventions. It represents the name of the
  1419  // Container from Pod specification, must be unique within a Pod. Container
  1420  // runtime usually uses different globally unique name (`container.name`).
  1421  func K8SContainerName(val string) attribute.KeyValue {
  1422  	return K8SContainerNameKey.String(val)
  1423  }
  1424  
  1425  // K8SContainerRestartCount returns an attribute KeyValue conforming to the
  1426  // "k8s.container.restart_count" semantic conventions. It represents the number
  1427  // of times the container was restarted. This attribute can be used to identify
  1428  // a particular container (running or stopped) within a container spec.
  1429  func K8SContainerRestartCount(val int) attribute.KeyValue {
  1430  	return K8SContainerRestartCountKey.Int(val)
  1431  }
  1432  
  1433  // A Kubernetes ReplicaSet object.
  1434  const (
  1435  	// K8SReplicaSetUIDKey is the attribute Key conforming to the
  1436  	// "k8s.replicaset.uid" semantic conventions. It represents the UID of the
  1437  	// ReplicaSet.
  1438  	//
  1439  	// Type: string
  1440  	// RequirementLevel: Optional
  1441  	// Stability: stable
  1442  	// Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
  1443  	K8SReplicaSetUIDKey = attribute.Key("k8s.replicaset.uid")
  1444  
  1445  	// K8SReplicaSetNameKey is the attribute Key conforming to the
  1446  	// "k8s.replicaset.name" semantic conventions. It represents the name of
  1447  	// the ReplicaSet.
  1448  	//
  1449  	// Type: string
  1450  	// RequirementLevel: Optional
  1451  	// Stability: stable
  1452  	// Examples: 'opentelemetry'
  1453  	K8SReplicaSetNameKey = attribute.Key("k8s.replicaset.name")
  1454  )
  1455  
  1456  // K8SReplicaSetUID returns an attribute KeyValue conforming to the
  1457  // "k8s.replicaset.uid" semantic conventions. It represents the UID of the
  1458  // ReplicaSet.
  1459  func K8SReplicaSetUID(val string) attribute.KeyValue {
  1460  	return K8SReplicaSetUIDKey.String(val)
  1461  }
  1462  
  1463  // K8SReplicaSetName returns an attribute KeyValue conforming to the
  1464  // "k8s.replicaset.name" semantic conventions. It represents the name of the
  1465  // ReplicaSet.
  1466  func K8SReplicaSetName(val string) attribute.KeyValue {
  1467  	return K8SReplicaSetNameKey.String(val)
  1468  }
  1469  
  1470  // A Kubernetes Deployment object.
  1471  const (
  1472  	// K8SDeploymentUIDKey is the attribute Key conforming to the
  1473  	// "k8s.deployment.uid" semantic conventions. It represents the UID of the
  1474  	// Deployment.
  1475  	//
  1476  	// Type: string
  1477  	// RequirementLevel: Optional
  1478  	// Stability: stable
  1479  	// Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
  1480  	K8SDeploymentUIDKey = attribute.Key("k8s.deployment.uid")
  1481  
  1482  	// K8SDeploymentNameKey is the attribute Key conforming to the
  1483  	// "k8s.deployment.name" semantic conventions. It represents the name of
  1484  	// the Deployment.
  1485  	//
  1486  	// Type: string
  1487  	// RequirementLevel: Optional
  1488  	// Stability: stable
  1489  	// Examples: 'opentelemetry'
  1490  	K8SDeploymentNameKey = attribute.Key("k8s.deployment.name")
  1491  )
  1492  
  1493  // K8SDeploymentUID returns an attribute KeyValue conforming to the
  1494  // "k8s.deployment.uid" semantic conventions. It represents the UID of the
  1495  // Deployment.
  1496  func K8SDeploymentUID(val string) attribute.KeyValue {
  1497  	return K8SDeploymentUIDKey.String(val)
  1498  }
  1499  
  1500  // K8SDeploymentName returns an attribute KeyValue conforming to the
  1501  // "k8s.deployment.name" semantic conventions. It represents the name of the
  1502  // Deployment.
  1503  func K8SDeploymentName(val string) attribute.KeyValue {
  1504  	return K8SDeploymentNameKey.String(val)
  1505  }
  1506  
  1507  // A Kubernetes StatefulSet object.
  1508  const (
  1509  	// K8SStatefulSetUIDKey is the attribute Key conforming to the
  1510  	// "k8s.statefulset.uid" semantic conventions. It represents the UID of the
  1511  	// StatefulSet.
  1512  	//
  1513  	// Type: string
  1514  	// RequirementLevel: Optional
  1515  	// Stability: stable
  1516  	// Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
  1517  	K8SStatefulSetUIDKey = attribute.Key("k8s.statefulset.uid")
  1518  
  1519  	// K8SStatefulSetNameKey is the attribute Key conforming to the
  1520  	// "k8s.statefulset.name" semantic conventions. It represents the name of
  1521  	// the StatefulSet.
  1522  	//
  1523  	// Type: string
  1524  	// RequirementLevel: Optional
  1525  	// Stability: stable
  1526  	// Examples: 'opentelemetry'
  1527  	K8SStatefulSetNameKey = attribute.Key("k8s.statefulset.name")
  1528  )
  1529  
  1530  // K8SStatefulSetUID returns an attribute KeyValue conforming to the
  1531  // "k8s.statefulset.uid" semantic conventions. It represents the UID of the
  1532  // StatefulSet.
  1533  func K8SStatefulSetUID(val string) attribute.KeyValue {
  1534  	return K8SStatefulSetUIDKey.String(val)
  1535  }
  1536  
  1537  // K8SStatefulSetName returns an attribute KeyValue conforming to the
  1538  // "k8s.statefulset.name" semantic conventions. It represents the name of the
  1539  // StatefulSet.
  1540  func K8SStatefulSetName(val string) attribute.KeyValue {
  1541  	return K8SStatefulSetNameKey.String(val)
  1542  }
  1543  
  1544  // A Kubernetes DaemonSet object.
  1545  const (
  1546  	// K8SDaemonSetUIDKey is the attribute Key conforming to the
  1547  	// "k8s.daemonset.uid" semantic conventions. It represents the UID of the
  1548  	// DaemonSet.
  1549  	//
  1550  	// Type: string
  1551  	// RequirementLevel: Optional
  1552  	// Stability: stable
  1553  	// Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
  1554  	K8SDaemonSetUIDKey = attribute.Key("k8s.daemonset.uid")
  1555  
  1556  	// K8SDaemonSetNameKey is the attribute Key conforming to the
  1557  	// "k8s.daemonset.name" semantic conventions. It represents the name of the
  1558  	// DaemonSet.
  1559  	//
  1560  	// Type: string
  1561  	// RequirementLevel: Optional
  1562  	// Stability: stable
  1563  	// Examples: 'opentelemetry'
  1564  	K8SDaemonSetNameKey = attribute.Key("k8s.daemonset.name")
  1565  )
  1566  
  1567  // K8SDaemonSetUID returns an attribute KeyValue conforming to the
  1568  // "k8s.daemonset.uid" semantic conventions. It represents the UID of the
  1569  // DaemonSet.
  1570  func K8SDaemonSetUID(val string) attribute.KeyValue {
  1571  	return K8SDaemonSetUIDKey.String(val)
  1572  }
  1573  
  1574  // K8SDaemonSetName returns an attribute KeyValue conforming to the
  1575  // "k8s.daemonset.name" semantic conventions. It represents the name of the
  1576  // DaemonSet.
  1577  func K8SDaemonSetName(val string) attribute.KeyValue {
  1578  	return K8SDaemonSetNameKey.String(val)
  1579  }
  1580  
  1581  // A Kubernetes Job object.
  1582  const (
  1583  	// K8SJobUIDKey is the attribute Key conforming to the "k8s.job.uid"
  1584  	// semantic conventions. It represents the UID of the Job.
  1585  	//
  1586  	// Type: string
  1587  	// RequirementLevel: Optional
  1588  	// Stability: stable
  1589  	// Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
  1590  	K8SJobUIDKey = attribute.Key("k8s.job.uid")
  1591  
  1592  	// K8SJobNameKey is the attribute Key conforming to the "k8s.job.name"
  1593  	// semantic conventions. It represents the name of the Job.
  1594  	//
  1595  	// Type: string
  1596  	// RequirementLevel: Optional
  1597  	// Stability: stable
  1598  	// Examples: 'opentelemetry'
  1599  	K8SJobNameKey = attribute.Key("k8s.job.name")
  1600  )
  1601  
  1602  // K8SJobUID returns an attribute KeyValue conforming to the "k8s.job.uid"
  1603  // semantic conventions. It represents the UID of the Job.
  1604  func K8SJobUID(val string) attribute.KeyValue {
  1605  	return K8SJobUIDKey.String(val)
  1606  }
  1607  
  1608  // K8SJobName returns an attribute KeyValue conforming to the "k8s.job.name"
  1609  // semantic conventions. It represents the name of the Job.
  1610  func K8SJobName(val string) attribute.KeyValue {
  1611  	return K8SJobNameKey.String(val)
  1612  }
  1613  
  1614  // A Kubernetes CronJob object.
  1615  const (
  1616  	// K8SCronJobUIDKey is the attribute Key conforming to the
  1617  	// "k8s.cronjob.uid" semantic conventions. It represents the UID of the
  1618  	// CronJob.
  1619  	//
  1620  	// Type: string
  1621  	// RequirementLevel: Optional
  1622  	// Stability: stable
  1623  	// Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
  1624  	K8SCronJobUIDKey = attribute.Key("k8s.cronjob.uid")
  1625  
  1626  	// K8SCronJobNameKey is the attribute Key conforming to the
  1627  	// "k8s.cronjob.name" semantic conventions. It represents the name of the
  1628  	// CronJob.
  1629  	//
  1630  	// Type: string
  1631  	// RequirementLevel: Optional
  1632  	// Stability: stable
  1633  	// Examples: 'opentelemetry'
  1634  	K8SCronJobNameKey = attribute.Key("k8s.cronjob.name")
  1635  )
  1636  
  1637  // K8SCronJobUID returns an attribute KeyValue conforming to the
  1638  // "k8s.cronjob.uid" semantic conventions. It represents the UID of the
  1639  // CronJob.
  1640  func K8SCronJobUID(val string) attribute.KeyValue {
  1641  	return K8SCronJobUIDKey.String(val)
  1642  }
  1643  
  1644  // K8SCronJobName returns an attribute KeyValue conforming to the
  1645  // "k8s.cronjob.name" semantic conventions. It represents the name of the
  1646  // CronJob.
  1647  func K8SCronJobName(val string) attribute.KeyValue {
  1648  	return K8SCronJobNameKey.String(val)
  1649  }
  1650  
  1651  // The operating system (OS) on which the process represented by this resource
  1652  // is running.
  1653  const (
  1654  	// OSTypeKey is the attribute Key conforming to the "os.type" semantic
  1655  	// conventions. It represents the operating system type.
  1656  	//
  1657  	// Type: Enum
  1658  	// RequirementLevel: Required
  1659  	// Stability: stable
  1660  	OSTypeKey = attribute.Key("os.type")
  1661  
  1662  	// OSDescriptionKey is the attribute Key conforming to the "os.description"
  1663  	// semantic conventions. It represents the human readable (not intended to
  1664  	// be parsed) OS version information, like e.g. reported by `ver` or
  1665  	// `lsb_release -a` commands.
  1666  	//
  1667  	// Type: string
  1668  	// RequirementLevel: Optional
  1669  	// Stability: stable
  1670  	// Examples: 'Microsoft Windows [Version 10.0.18363.778]', 'Ubuntu 18.04.1
  1671  	// LTS'
  1672  	OSDescriptionKey = attribute.Key("os.description")
  1673  
  1674  	// OSNameKey is the attribute Key conforming to the "os.name" semantic
  1675  	// conventions. It represents the human readable operating system name.
  1676  	//
  1677  	// Type: string
  1678  	// RequirementLevel: Optional
  1679  	// Stability: stable
  1680  	// Examples: 'iOS', 'Android', 'Ubuntu'
  1681  	OSNameKey = attribute.Key("os.name")
  1682  
  1683  	// OSVersionKey is the attribute Key conforming to the "os.version"
  1684  	// semantic conventions. It represents the version string of the operating
  1685  	// system as defined in [Version
  1686  	// Attributes](/docs/resource/README.md#version-attributes).
  1687  	//
  1688  	// Type: string
  1689  	// RequirementLevel: Optional
  1690  	// Stability: stable
  1691  	// Examples: '14.2.1', '18.04.1'
  1692  	OSVersionKey = attribute.Key("os.version")
  1693  )
  1694  
  1695  var (
  1696  	// Microsoft Windows
  1697  	OSTypeWindows = OSTypeKey.String("windows")
  1698  	// Linux
  1699  	OSTypeLinux = OSTypeKey.String("linux")
  1700  	// Apple Darwin
  1701  	OSTypeDarwin = OSTypeKey.String("darwin")
  1702  	// FreeBSD
  1703  	OSTypeFreeBSD = OSTypeKey.String("freebsd")
  1704  	// NetBSD
  1705  	OSTypeNetBSD = OSTypeKey.String("netbsd")
  1706  	// OpenBSD
  1707  	OSTypeOpenBSD = OSTypeKey.String("openbsd")
  1708  	// DragonFly BSD
  1709  	OSTypeDragonflyBSD = OSTypeKey.String("dragonflybsd")
  1710  	// HP-UX (Hewlett Packard Unix)
  1711  	OSTypeHPUX = OSTypeKey.String("hpux")
  1712  	// AIX (Advanced Interactive eXecutive)
  1713  	OSTypeAIX = OSTypeKey.String("aix")
  1714  	// SunOS, Oracle Solaris
  1715  	OSTypeSolaris = OSTypeKey.String("solaris")
  1716  	// IBM z/OS
  1717  	OSTypeZOS = OSTypeKey.String("z_os")
  1718  )
  1719  
  1720  // OSDescription returns an attribute KeyValue conforming to the
  1721  // "os.description" semantic conventions. It represents the human readable (not
  1722  // intended to be parsed) OS version information, like e.g. reported by `ver`
  1723  // or `lsb_release -a` commands.
  1724  func OSDescription(val string) attribute.KeyValue {
  1725  	return OSDescriptionKey.String(val)
  1726  }
  1727  
  1728  // OSName returns an attribute KeyValue conforming to the "os.name" semantic
  1729  // conventions. It represents the human readable operating system name.
  1730  func OSName(val string) attribute.KeyValue {
  1731  	return OSNameKey.String(val)
  1732  }
  1733  
  1734  // OSVersion returns an attribute KeyValue conforming to the "os.version"
  1735  // semantic conventions. It represents the version string of the operating
  1736  // system as defined in [Version
  1737  // Attributes](/docs/resource/README.md#version-attributes).
  1738  func OSVersion(val string) attribute.KeyValue {
  1739  	return OSVersionKey.String(val)
  1740  }
  1741  
  1742  // An operating system process.
  1743  const (
  1744  	// ProcessPIDKey is the attribute Key conforming to the "process.pid"
  1745  	// semantic conventions. It represents the process identifier (PID).
  1746  	//
  1747  	// Type: int
  1748  	// RequirementLevel: Optional
  1749  	// Stability: stable
  1750  	// Examples: 1234
  1751  	ProcessPIDKey = attribute.Key("process.pid")
  1752  
  1753  	// ProcessParentPIDKey is the attribute Key conforming to the
  1754  	// "process.parent_pid" semantic conventions. It represents the parent
  1755  	// Process identifier (PID).
  1756  	//
  1757  	// Type: int
  1758  	// RequirementLevel: Optional
  1759  	// Stability: stable
  1760  	// Examples: 111
  1761  	ProcessParentPIDKey = attribute.Key("process.parent_pid")
  1762  
  1763  	// ProcessExecutableNameKey is the attribute Key conforming to the
  1764  	// "process.executable.name" semantic conventions. It represents the name
  1765  	// of the process executable. On Linux based systems, can be set to the
  1766  	// `Name` in `proc/[pid]/status`. On Windows, can be set to the base name
  1767  	// of `GetProcessImageFileNameW`.
  1768  	//
  1769  	// Type: string
  1770  	// RequirementLevel: ConditionallyRequired (See alternative attributes
  1771  	// below.)
  1772  	// Stability: stable
  1773  	// Examples: 'otelcol'
  1774  	ProcessExecutableNameKey = attribute.Key("process.executable.name")
  1775  
  1776  	// ProcessExecutablePathKey is the attribute Key conforming to the
  1777  	// "process.executable.path" semantic conventions. It represents the full
  1778  	// path to the process executable. On Linux based systems, can be set to
  1779  	// the target of `proc/[pid]/exe`. On Windows, can be set to the result of
  1780  	// `GetProcessImageFileNameW`.
  1781  	//
  1782  	// Type: string
  1783  	// RequirementLevel: ConditionallyRequired (See alternative attributes
  1784  	// below.)
  1785  	// Stability: stable
  1786  	// Examples: '/usr/bin/cmd/otelcol'
  1787  	ProcessExecutablePathKey = attribute.Key("process.executable.path")
  1788  
  1789  	// ProcessCommandKey is the attribute Key conforming to the
  1790  	// "process.command" semantic conventions. It represents the command used
  1791  	// to launch the process (i.e. the command name). On Linux based systems,
  1792  	// can be set to the zeroth string in `proc/[pid]/cmdline`. On Windows, can
  1793  	// be set to the first parameter extracted from `GetCommandLineW`.
  1794  	//
  1795  	// Type: string
  1796  	// RequirementLevel: ConditionallyRequired (See alternative attributes
  1797  	// below.)
  1798  	// Stability: stable
  1799  	// Examples: 'cmd/otelcol'
  1800  	ProcessCommandKey = attribute.Key("process.command")
  1801  
  1802  	// ProcessCommandLineKey is the attribute Key conforming to the
  1803  	// "process.command_line" semantic conventions. It represents the full
  1804  	// command used to launch the process as a single string representing the
  1805  	// full command. On Windows, can be set to the result of `GetCommandLineW`.
  1806  	// Do not set this if you have to assemble it just for monitoring; use
  1807  	// `process.command_args` instead.
  1808  	//
  1809  	// Type: string
  1810  	// RequirementLevel: ConditionallyRequired (See alternative attributes
  1811  	// below.)
  1812  	// Stability: stable
  1813  	// Examples: 'C:\\cmd\\otecol --config="my directory\\config.yaml"'
  1814  	ProcessCommandLineKey = attribute.Key("process.command_line")
  1815  
  1816  	// ProcessCommandArgsKey is the attribute Key conforming to the
  1817  	// "process.command_args" semantic conventions. It represents the all the
  1818  	// command arguments (including the command/executable itself) as received
  1819  	// by the process. On Linux-based systems (and some other Unixoid systems
  1820  	// supporting procfs), can be set according to the list of null-delimited
  1821  	// strings extracted from `proc/[pid]/cmdline`. For libc-based executables,
  1822  	// this would be the full argv vector passed to `main`.
  1823  	//
  1824  	// Type: string[]
  1825  	// RequirementLevel: ConditionallyRequired (See alternative attributes
  1826  	// below.)
  1827  	// Stability: stable
  1828  	// Examples: 'cmd/otecol', '--config=config.yaml'
  1829  	ProcessCommandArgsKey = attribute.Key("process.command_args")
  1830  
  1831  	// ProcessOwnerKey is the attribute Key conforming to the "process.owner"
  1832  	// semantic conventions. It represents the username of the user that owns
  1833  	// the process.
  1834  	//
  1835  	// Type: string
  1836  	// RequirementLevel: Optional
  1837  	// Stability: stable
  1838  	// Examples: 'root'
  1839  	ProcessOwnerKey = attribute.Key("process.owner")
  1840  )
  1841  
  1842  // ProcessPID returns an attribute KeyValue conforming to the "process.pid"
  1843  // semantic conventions. It represents the process identifier (PID).
  1844  func ProcessPID(val int) attribute.KeyValue {
  1845  	return ProcessPIDKey.Int(val)
  1846  }
  1847  
  1848  // ProcessParentPID returns an attribute KeyValue conforming to the
  1849  // "process.parent_pid" semantic conventions. It represents the parent Process
  1850  // identifier (PID).
  1851  func ProcessParentPID(val int) attribute.KeyValue {
  1852  	return ProcessParentPIDKey.Int(val)
  1853  }
  1854  
  1855  // ProcessExecutableName returns an attribute KeyValue conforming to the
  1856  // "process.executable.name" semantic conventions. It represents the name of
  1857  // the process executable. On Linux based systems, can be set to the `Name` in
  1858  // `proc/[pid]/status`. On Windows, can be set to the base name of
  1859  // `GetProcessImageFileNameW`.
  1860  func ProcessExecutableName(val string) attribute.KeyValue {
  1861  	return ProcessExecutableNameKey.String(val)
  1862  }
  1863  
  1864  // ProcessExecutablePath returns an attribute KeyValue conforming to the
  1865  // "process.executable.path" semantic conventions. It represents the full path
  1866  // to the process executable. On Linux based systems, can be set to the target
  1867  // of `proc/[pid]/exe`. On Windows, can be set to the result of
  1868  // `GetProcessImageFileNameW`.
  1869  func ProcessExecutablePath(val string) attribute.KeyValue {
  1870  	return ProcessExecutablePathKey.String(val)
  1871  }
  1872  
  1873  // ProcessCommand returns an attribute KeyValue conforming to the
  1874  // "process.command" semantic conventions. It represents the command used to
  1875  // launch the process (i.e. the command name). On Linux based systems, can be
  1876  // set to the zeroth string in `proc/[pid]/cmdline`. On Windows, can be set to
  1877  // the first parameter extracted from `GetCommandLineW`.
  1878  func ProcessCommand(val string) attribute.KeyValue {
  1879  	return ProcessCommandKey.String(val)
  1880  }
  1881  
  1882  // ProcessCommandLine returns an attribute KeyValue conforming to the
  1883  // "process.command_line" semantic conventions. It represents the full command
  1884  // used to launch the process as a single string representing the full command.
  1885  // On Windows, can be set to the result of `GetCommandLineW`. Do not set this
  1886  // if you have to assemble it just for monitoring; use `process.command_args`
  1887  // instead.
  1888  func ProcessCommandLine(val string) attribute.KeyValue {
  1889  	return ProcessCommandLineKey.String(val)
  1890  }
  1891  
  1892  // ProcessCommandArgs returns an attribute KeyValue conforming to the
  1893  // "process.command_args" semantic conventions. It represents the all the
  1894  // command arguments (including the command/executable itself) as received by
  1895  // the process. On Linux-based systems (and some other Unixoid systems
  1896  // supporting procfs), can be set according to the list of null-delimited
  1897  // strings extracted from `proc/[pid]/cmdline`. For libc-based executables,
  1898  // this would be the full argv vector passed to `main`.
  1899  func ProcessCommandArgs(val ...string) attribute.KeyValue {
  1900  	return ProcessCommandArgsKey.StringSlice(val)
  1901  }
  1902  
  1903  // ProcessOwner returns an attribute KeyValue conforming to the
  1904  // "process.owner" semantic conventions. It represents the username of the user
  1905  // that owns the process.
  1906  func ProcessOwner(val string) attribute.KeyValue {
  1907  	return ProcessOwnerKey.String(val)
  1908  }
  1909  
  1910  // The single (language) runtime instance which is monitored.
  1911  const (
  1912  	// ProcessRuntimeNameKey is the attribute Key conforming to the
  1913  	// "process.runtime.name" semantic conventions. It represents the name of
  1914  	// the runtime of this process. For compiled native binaries, this SHOULD
  1915  	// be the name of the compiler.
  1916  	//
  1917  	// Type: string
  1918  	// RequirementLevel: Optional
  1919  	// Stability: stable
  1920  	// Examples: 'OpenJDK Runtime Environment'
  1921  	ProcessRuntimeNameKey = attribute.Key("process.runtime.name")
  1922  
  1923  	// ProcessRuntimeVersionKey is the attribute Key conforming to the
  1924  	// "process.runtime.version" semantic conventions. It represents the
  1925  	// version of the runtime of this process, as returned by the runtime
  1926  	// without modification.
  1927  	//
  1928  	// Type: string
  1929  	// RequirementLevel: Optional
  1930  	// Stability: stable
  1931  	// Examples: '14.0.2'
  1932  	ProcessRuntimeVersionKey = attribute.Key("process.runtime.version")
  1933  
  1934  	// ProcessRuntimeDescriptionKey is the attribute Key conforming to the
  1935  	// "process.runtime.description" semantic conventions. It represents an
  1936  	// additional description about the runtime of the process, for example a
  1937  	// specific vendor customization of the runtime environment.
  1938  	//
  1939  	// Type: string
  1940  	// RequirementLevel: Optional
  1941  	// Stability: stable
  1942  	// Examples: 'Eclipse OpenJ9 Eclipse OpenJ9 VM openj9-0.21.0'
  1943  	ProcessRuntimeDescriptionKey = attribute.Key("process.runtime.description")
  1944  )
  1945  
  1946  // ProcessRuntimeName returns an attribute KeyValue conforming to the
  1947  // "process.runtime.name" semantic conventions. It represents the name of the
  1948  // runtime of this process. For compiled native binaries, this SHOULD be the
  1949  // name of the compiler.
  1950  func ProcessRuntimeName(val string) attribute.KeyValue {
  1951  	return ProcessRuntimeNameKey.String(val)
  1952  }
  1953  
  1954  // ProcessRuntimeVersion returns an attribute KeyValue conforming to the
  1955  // "process.runtime.version" semantic conventions. It represents the version of
  1956  // the runtime of this process, as returned by the runtime without
  1957  // modification.
  1958  func ProcessRuntimeVersion(val string) attribute.KeyValue {
  1959  	return ProcessRuntimeVersionKey.String(val)
  1960  }
  1961  
  1962  // ProcessRuntimeDescription returns an attribute KeyValue conforming to the
  1963  // "process.runtime.description" semantic conventions. It represents an
  1964  // additional description about the runtime of the process, for example a
  1965  // specific vendor customization of the runtime environment.
  1966  func ProcessRuntimeDescription(val string) attribute.KeyValue {
  1967  	return ProcessRuntimeDescriptionKey.String(val)
  1968  }
  1969  
  1970  // A service instance.
  1971  const (
  1972  	// ServiceNameKey is the attribute Key conforming to the "service.name"
  1973  	// semantic conventions. It represents the logical name of the service.
  1974  	//
  1975  	// Type: string
  1976  	// RequirementLevel: Required
  1977  	// Stability: stable
  1978  	// Examples: 'shoppingcart'
  1979  	// Note: MUST be the same for all instances of horizontally scaled
  1980  	// services. If the value was not specified, SDKs MUST fallback to
  1981  	// `unknown_service:` concatenated with
  1982  	// [`process.executable.name`](process.md#process), e.g.
  1983  	// `unknown_service:bash`. If `process.executable.name` is not available,
  1984  	// the value MUST be set to `unknown_service`.
  1985  	ServiceNameKey = attribute.Key("service.name")
  1986  
  1987  	// ServiceVersionKey is the attribute Key conforming to the
  1988  	// "service.version" semantic conventions. It represents the version string
  1989  	// of the service API or implementation. The format is not defined by these
  1990  	// conventions.
  1991  	//
  1992  	// Type: string
  1993  	// RequirementLevel: Optional
  1994  	// Stability: stable
  1995  	// Examples: '2.0.0', 'a01dbef8a'
  1996  	ServiceVersionKey = attribute.Key("service.version")
  1997  )
  1998  
  1999  // ServiceName returns an attribute KeyValue conforming to the
  2000  // "service.name" semantic conventions. It represents the logical name of the
  2001  // service.
  2002  func ServiceName(val string) attribute.KeyValue {
  2003  	return ServiceNameKey.String(val)
  2004  }
  2005  
  2006  // ServiceVersion returns an attribute KeyValue conforming to the
  2007  // "service.version" semantic conventions. It represents the version string of
  2008  // the service API or implementation. The format is not defined by these
  2009  // conventions.
  2010  func ServiceVersion(val string) attribute.KeyValue {
  2011  	return ServiceVersionKey.String(val)
  2012  }
  2013  
  2014  // A service instance.
  2015  const (
  2016  	// ServiceNamespaceKey is the attribute Key conforming to the
  2017  	// "service.namespace" semantic conventions. It represents a namespace for
  2018  	// `service.name`.
  2019  	//
  2020  	// Type: string
  2021  	// RequirementLevel: Optional
  2022  	// Stability: stable
  2023  	// Examples: 'Shop'
  2024  	// Note: A string value having a meaning that helps to distinguish a group
  2025  	// of services, for example the team name that owns a group of services.
  2026  	// `service.name` is expected to be unique within the same namespace. If
  2027  	// `service.namespace` is not specified in the Resource then `service.name`
  2028  	// is expected to be unique for all services that have no explicit
  2029  	// namespace defined (so the empty/unspecified namespace is simply one more
  2030  	// valid namespace). Zero-length namespace string is assumed equal to
  2031  	// unspecified namespace.
  2032  	ServiceNamespaceKey = attribute.Key("service.namespace")
  2033  
  2034  	// ServiceInstanceIDKey is the attribute Key conforming to the
  2035  	// "service.instance.id" semantic conventions. It represents the string ID
  2036  	// of the service instance.
  2037  	//
  2038  	// Type: string
  2039  	// RequirementLevel: Optional
  2040  	// Stability: stable
  2041  	// Examples: 'my-k8s-pod-deployment-1',
  2042  	// '627cc493-f310-47de-96bd-71410b7dec09'
  2043  	// Note: MUST be unique for each instance of the same
  2044  	// `service.namespace,service.name` pair (in other words
  2045  	// `service.namespace,service.name,service.instance.id` triplet MUST be
  2046  	// globally unique). The ID helps to distinguish instances of the same
  2047  	// service that exist at the same time (e.g. instances of a horizontally
  2048  	// scaled service). It is preferable for the ID to be persistent and stay
  2049  	// the same for the lifetime of the service instance, however it is
  2050  	// acceptable that the ID is ephemeral and changes during important
  2051  	// lifetime events for the service (e.g. service restarts). If the service
  2052  	// has no inherent unique ID that can be used as the value of this
  2053  	// attribute it is recommended to generate a random Version 1 or Version 4
  2054  	// RFC 4122 UUID (services aiming for reproducible UUIDs may also use
  2055  	// Version 5, see RFC 4122 for more recommendations).
  2056  	ServiceInstanceIDKey = attribute.Key("service.instance.id")
  2057  )
  2058  
  2059  // ServiceNamespace returns an attribute KeyValue conforming to the
  2060  // "service.namespace" semantic conventions. It represents a namespace for
  2061  // `service.name`.
  2062  func ServiceNamespace(val string) attribute.KeyValue {
  2063  	return ServiceNamespaceKey.String(val)
  2064  }
  2065  
  2066  // ServiceInstanceID returns an attribute KeyValue conforming to the
  2067  // "service.instance.id" semantic conventions. It represents the string ID of
  2068  // the service instance.
  2069  func ServiceInstanceID(val string) attribute.KeyValue {
  2070  	return ServiceInstanceIDKey.String(val)
  2071  }
  2072  
  2073  // The telemetry SDK used to capture data recorded by the instrumentation
  2074  // libraries.
  2075  const (
  2076  	// TelemetrySDKNameKey is the attribute Key conforming to the
  2077  	// "telemetry.sdk.name" semantic conventions. It represents the name of the
  2078  	// telemetry SDK as defined above.
  2079  	//
  2080  	// Type: string
  2081  	// RequirementLevel: Required
  2082  	// Stability: stable
  2083  	// Examples: 'opentelemetry'
  2084  	// Note: The OpenTelemetry SDK MUST set the `telemetry.sdk.name` attribute
  2085  	// to `opentelemetry`.
  2086  	// If another SDK, like a fork or a vendor-provided implementation, is
  2087  	// used, this SDK MUST set the
  2088  	// `telemetry.sdk.name` attribute to the fully-qualified class or module
  2089  	// name of this SDK's main entry point
  2090  	// or another suitable identifier depending on the language.
  2091  	// The identifier `opentelemetry` is reserved and MUST NOT be used in this
  2092  	// case.
  2093  	// All custom identifiers SHOULD be stable across different versions of an
  2094  	// implementation.
  2095  	TelemetrySDKNameKey = attribute.Key("telemetry.sdk.name")
  2096  
  2097  	// TelemetrySDKLanguageKey is the attribute Key conforming to the
  2098  	// "telemetry.sdk.language" semantic conventions. It represents the
  2099  	// language of the telemetry SDK.
  2100  	//
  2101  	// Type: Enum
  2102  	// RequirementLevel: Required
  2103  	// Stability: stable
  2104  	TelemetrySDKLanguageKey = attribute.Key("telemetry.sdk.language")
  2105  
  2106  	// TelemetrySDKVersionKey is the attribute Key conforming to the
  2107  	// "telemetry.sdk.version" semantic conventions. It represents the version
  2108  	// string of the telemetry SDK.
  2109  	//
  2110  	// Type: string
  2111  	// RequirementLevel: Required
  2112  	// Stability: stable
  2113  	// Examples: '1.2.3'
  2114  	TelemetrySDKVersionKey = attribute.Key("telemetry.sdk.version")
  2115  )
  2116  
  2117  var (
  2118  	// cpp
  2119  	TelemetrySDKLanguageCPP = TelemetrySDKLanguageKey.String("cpp")
  2120  	// dotnet
  2121  	TelemetrySDKLanguageDotnet = TelemetrySDKLanguageKey.String("dotnet")
  2122  	// erlang
  2123  	TelemetrySDKLanguageErlang = TelemetrySDKLanguageKey.String("erlang")
  2124  	// go
  2125  	TelemetrySDKLanguageGo = TelemetrySDKLanguageKey.String("go")
  2126  	// java
  2127  	TelemetrySDKLanguageJava = TelemetrySDKLanguageKey.String("java")
  2128  	// nodejs
  2129  	TelemetrySDKLanguageNodejs = TelemetrySDKLanguageKey.String("nodejs")
  2130  	// php
  2131  	TelemetrySDKLanguagePHP = TelemetrySDKLanguageKey.String("php")
  2132  	// python
  2133  	TelemetrySDKLanguagePython = TelemetrySDKLanguageKey.String("python")
  2134  	// ruby
  2135  	TelemetrySDKLanguageRuby = TelemetrySDKLanguageKey.String("ruby")
  2136  	// rust
  2137  	TelemetrySDKLanguageRust = TelemetrySDKLanguageKey.String("rust")
  2138  	// swift
  2139  	TelemetrySDKLanguageSwift = TelemetrySDKLanguageKey.String("swift")
  2140  	// webjs
  2141  	TelemetrySDKLanguageWebjs = TelemetrySDKLanguageKey.String("webjs")
  2142  )
  2143  
  2144  // TelemetrySDKName returns an attribute KeyValue conforming to the
  2145  // "telemetry.sdk.name" semantic conventions. It represents the name of the
  2146  // telemetry SDK as defined above.
  2147  func TelemetrySDKName(val string) attribute.KeyValue {
  2148  	return TelemetrySDKNameKey.String(val)
  2149  }
  2150  
  2151  // TelemetrySDKVersion returns an attribute KeyValue conforming to the
  2152  // "telemetry.sdk.version" semantic conventions. It represents the version
  2153  // string of the telemetry SDK.
  2154  func TelemetrySDKVersion(val string) attribute.KeyValue {
  2155  	return TelemetrySDKVersionKey.String(val)
  2156  }
  2157  
  2158  // The telemetry SDK used to capture data recorded by the instrumentation
  2159  // libraries.
  2160  const (
  2161  	// TelemetryAutoVersionKey is the attribute Key conforming to the
  2162  	// "telemetry.auto.version" semantic conventions. It represents the version
  2163  	// string of the auto instrumentation agent, if used.
  2164  	//
  2165  	// Type: string
  2166  	// RequirementLevel: Optional
  2167  	// Stability: stable
  2168  	// Examples: '1.2.3'
  2169  	TelemetryAutoVersionKey = attribute.Key("telemetry.auto.version")
  2170  )
  2171  
  2172  // TelemetryAutoVersion returns an attribute KeyValue conforming to the
  2173  // "telemetry.auto.version" semantic conventions. It represents the version
  2174  // string of the auto instrumentation agent, if used.
  2175  func TelemetryAutoVersion(val string) attribute.KeyValue {
  2176  	return TelemetryAutoVersionKey.String(val)
  2177  }
  2178  
  2179  // Resource describing the packaged software running the application code. Web
  2180  // engines are typically executed using process.runtime.
  2181  const (
  2182  	// WebEngineNameKey is the attribute Key conforming to the "webengine.name"
  2183  	// semantic conventions. It represents the name of the web engine.
  2184  	//
  2185  	// Type: string
  2186  	// RequirementLevel: Required
  2187  	// Stability: stable
  2188  	// Examples: 'WildFly'
  2189  	WebEngineNameKey = attribute.Key("webengine.name")
  2190  
  2191  	// WebEngineVersionKey is the attribute Key conforming to the
  2192  	// "webengine.version" semantic conventions. It represents the version of
  2193  	// the web engine.
  2194  	//
  2195  	// Type: string
  2196  	// RequirementLevel: Optional
  2197  	// Stability: stable
  2198  	// Examples: '21.0.0'
  2199  	WebEngineVersionKey = attribute.Key("webengine.version")
  2200  
  2201  	// WebEngineDescriptionKey is the attribute Key conforming to the
  2202  	// "webengine.description" semantic conventions. It represents the
  2203  	// additional description of the web engine (e.g. detailed version and
  2204  	// edition information).
  2205  	//
  2206  	// Type: string
  2207  	// RequirementLevel: Optional
  2208  	// Stability: stable
  2209  	// Examples: 'WildFly Full 21.0.0.Final (WildFly Core 13.0.1.Final) -
  2210  	// 2.2.2.Final'
  2211  	WebEngineDescriptionKey = attribute.Key("webengine.description")
  2212  )
  2213  
  2214  // WebEngineName returns an attribute KeyValue conforming to the
  2215  // "webengine.name" semantic conventions. It represents the name of the web
  2216  // engine.
  2217  func WebEngineName(val string) attribute.KeyValue {
  2218  	return WebEngineNameKey.String(val)
  2219  }
  2220  
  2221  // WebEngineVersion returns an attribute KeyValue conforming to the
  2222  // "webengine.version" semantic conventions. It represents the version of the
  2223  // web engine.
  2224  func WebEngineVersion(val string) attribute.KeyValue {
  2225  	return WebEngineVersionKey.String(val)
  2226  }
  2227  
  2228  // WebEngineDescription returns an attribute KeyValue conforming to the
  2229  // "webengine.description" semantic conventions. It represents the additional
  2230  // description of the web engine (e.g. detailed version and edition
  2231  // information).
  2232  func WebEngineDescription(val string) attribute.KeyValue {
  2233  	return WebEngineDescriptionKey.String(val)
  2234  }
  2235  
  2236  // Attributes used by non-OTLP exporters to represent OpenTelemetry Scope's
  2237  // concepts.
  2238  const (
  2239  	// OTelScopeNameKey is the attribute Key conforming to the
  2240  	// "otel.scope.name" semantic conventions. It represents the name of the
  2241  	// instrumentation scope - (`InstrumentationScope.Name` in OTLP).
  2242  	//
  2243  	// Type: string
  2244  	// RequirementLevel: Optional
  2245  	// Stability: stable
  2246  	// Examples: 'io.opentelemetry.contrib.mongodb'
  2247  	OTelScopeNameKey = attribute.Key("otel.scope.name")
  2248  
  2249  	// OTelScopeVersionKey is the attribute Key conforming to the
  2250  	// "otel.scope.version" semantic conventions. It represents the version of
  2251  	// the instrumentation scope - (`InstrumentationScope.Version` in OTLP).
  2252  	//
  2253  	// Type: string
  2254  	// RequirementLevel: Optional
  2255  	// Stability: stable
  2256  	// Examples: '1.0.0'
  2257  	OTelScopeVersionKey = attribute.Key("otel.scope.version")
  2258  )
  2259  
  2260  // OTelScopeName returns an attribute KeyValue conforming to the
  2261  // "otel.scope.name" semantic conventions. It represents the name of the
  2262  // instrumentation scope - (`InstrumentationScope.Name` in OTLP).
  2263  func OTelScopeName(val string) attribute.KeyValue {
  2264  	return OTelScopeNameKey.String(val)
  2265  }
  2266  
  2267  // OTelScopeVersion returns an attribute KeyValue conforming to the
  2268  // "otel.scope.version" semantic conventions. It represents the version of the
  2269  // instrumentation scope - (`InstrumentationScope.Version` in OTLP).
  2270  func OTelScopeVersion(val string) attribute.KeyValue {
  2271  	return OTelScopeVersionKey.String(val)
  2272  }
  2273  
  2274  // Span attributes used by non-OTLP exporters to represent OpenTelemetry
  2275  // Scope's concepts.
  2276  const (
  2277  	// OTelLibraryNameKey is the attribute Key conforming to the
  2278  	// "otel.library.name" semantic conventions. It represents the deprecated,
  2279  	// use the `otel.scope.name` attribute.
  2280  	//
  2281  	// Type: string
  2282  	// RequirementLevel: Optional
  2283  	// Stability: deprecated
  2284  	// Examples: 'io.opentelemetry.contrib.mongodb'
  2285  	OTelLibraryNameKey = attribute.Key("otel.library.name")
  2286  
  2287  	// OTelLibraryVersionKey is the attribute Key conforming to the
  2288  	// "otel.library.version" semantic conventions. It represents the
  2289  	// deprecated, use the `otel.scope.version` attribute.
  2290  	//
  2291  	// Type: string
  2292  	// RequirementLevel: Optional
  2293  	// Stability: deprecated
  2294  	// Examples: '1.0.0'
  2295  	OTelLibraryVersionKey = attribute.Key("otel.library.version")
  2296  )
  2297  
  2298  // OTelLibraryName returns an attribute KeyValue conforming to the
  2299  // "otel.library.name" semantic conventions. It represents the deprecated, use
  2300  // the `otel.scope.name` attribute.
  2301  func OTelLibraryName(val string) attribute.KeyValue {
  2302  	return OTelLibraryNameKey.String(val)
  2303  }
  2304  
  2305  // OTelLibraryVersion returns an attribute KeyValue conforming to the
  2306  // "otel.library.version" semantic conventions. It represents the deprecated,
  2307  // use the `otel.scope.version` attribute.
  2308  func OTelLibraryVersion(val string) attribute.KeyValue {
  2309  	return OTelLibraryVersionKey.String(val)
  2310  }
  2311  

View as plain text