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

Documentation: go.opentelemetry.io/otel/semconv/v1.20.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.20.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 Cloud Compute Engine (GCE)
   277  	CloudPlatformGCPComputeEngine = CloudPlatformKey.String("gcp_compute_engine")
   278  	// Google Cloud Run
   279  	CloudPlatformGCPCloudRun = CloudPlatformKey.String("gcp_cloud_run")
   280  	// Google Cloud Kubernetes Engine (GKE)
   281  	CloudPlatformGCPKubernetesEngine = CloudPlatformKey.String("gcp_kubernetes_engine")
   282  	// Google Cloud Functions (GCF)
   283  	CloudPlatformGCPCloudFunctions = CloudPlatformKey.String("gcp_cloud_functions")
   284  	// Google Cloud App Engine (GAE)
   285  	CloudPlatformGCPAppEngine = CloudPlatformKey.String("gcp_app_engine")
   286  	// Red Hat OpenShift on Google Cloud
   287  	CloudPlatformGCPOpenshift = CloudPlatformKey.String("gcp_openshift")
   288  	// Red Hat OpenShift on IBM Cloud
   289  	CloudPlatformIbmCloudOpenshift = CloudPlatformKey.String("ibm_cloud_openshift")
   290  	// Tencent Cloud Cloud Virtual Machine (CVM)
   291  	CloudPlatformTencentCloudCvm = CloudPlatformKey.String("tencent_cloud_cvm")
   292  	// Tencent Cloud Elastic Kubernetes Service (EKS)
   293  	CloudPlatformTencentCloudEKS = CloudPlatformKey.String("tencent_cloud_eks")
   294  	// Tencent Cloud Serverless Cloud Function (SCF)
   295  	CloudPlatformTencentCloudScf = CloudPlatformKey.String("tencent_cloud_scf")
   296  )
   297  
   298  // CloudAccountID returns an attribute KeyValue conforming to the
   299  // "cloud.account.id" semantic conventions. It represents the cloud account ID
   300  // the resource is assigned to.
   301  func CloudAccountID(val string) attribute.KeyValue {
   302  	return CloudAccountIDKey.String(val)
   303  }
   304  
   305  // CloudRegion returns an attribute KeyValue conforming to the
   306  // "cloud.region" semantic conventions. It represents the geographical region
   307  // the resource is running.
   308  func CloudRegion(val string) attribute.KeyValue {
   309  	return CloudRegionKey.String(val)
   310  }
   311  
   312  // CloudResourceID returns an attribute KeyValue conforming to the
   313  // "cloud.resource_id" semantic conventions. It represents the cloud
   314  // provider-specific native identifier of the monitored cloud resource (e.g. an
   315  // [ARN](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
   316  // on AWS, a [fully qualified resource
   317  // ID](https://learn.microsoft.com/en-us/rest/api/resources/resources/get-by-id)
   318  // on Azure, a [full resource
   319  // name](https://cloud.google.com/apis/design/resource_names#full_resource_name)
   320  // on GCP)
   321  func CloudResourceID(val string) attribute.KeyValue {
   322  	return CloudResourceIDKey.String(val)
   323  }
   324  
   325  // CloudAvailabilityZone returns an attribute KeyValue conforming to the
   326  // "cloud.availability_zone" semantic conventions. It represents the cloud
   327  // regions often have multiple, isolated locations known as zones to increase
   328  // availability. Availability zone represents the zone where the resource is
   329  // running.
   330  func CloudAvailabilityZone(val string) attribute.KeyValue {
   331  	return CloudAvailabilityZoneKey.String(val)
   332  }
   333  
   334  // Resources used by AWS Elastic Container Service (ECS).
   335  const (
   336  	// AWSECSContainerARNKey is the attribute Key conforming to the
   337  	// "aws.ecs.container.arn" semantic conventions. It represents the Amazon
   338  	// Resource Name (ARN) of an [ECS container
   339  	// instance](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_instances.html).
   340  	//
   341  	// Type: string
   342  	// RequirementLevel: Optional
   343  	// Stability: stable
   344  	// Examples:
   345  	// 'arn:aws:ecs:us-west-1:123456789123:container/32624152-9086-4f0e-acae-1a75b14fe4d9'
   346  	AWSECSContainerARNKey = attribute.Key("aws.ecs.container.arn")
   347  
   348  	// AWSECSClusterARNKey is the attribute Key conforming to the
   349  	// "aws.ecs.cluster.arn" semantic conventions. It represents the ARN of an
   350  	// [ECS
   351  	// cluster](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/clusters.html).
   352  	//
   353  	// Type: string
   354  	// RequirementLevel: Optional
   355  	// Stability: stable
   356  	// Examples: 'arn:aws:ecs:us-west-2:123456789123:cluster/my-cluster'
   357  	AWSECSClusterARNKey = attribute.Key("aws.ecs.cluster.arn")
   358  
   359  	// AWSECSLaunchtypeKey is the attribute Key conforming to the
   360  	// "aws.ecs.launchtype" semantic conventions. It represents the [launch
   361  	// type](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html)
   362  	// for an ECS task.
   363  	//
   364  	// Type: Enum
   365  	// RequirementLevel: Optional
   366  	// Stability: stable
   367  	AWSECSLaunchtypeKey = attribute.Key("aws.ecs.launchtype")
   368  
   369  	// AWSECSTaskARNKey is the attribute Key conforming to the
   370  	// "aws.ecs.task.arn" semantic conventions. It represents the ARN of an
   371  	// [ECS task
   372  	// definition](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definitions.html).
   373  	//
   374  	// Type: string
   375  	// RequirementLevel: Optional
   376  	// Stability: stable
   377  	// Examples:
   378  	// 'arn:aws:ecs:us-west-1:123456789123:task/10838bed-421f-43ef-870a-f43feacbbb5b'
   379  	AWSECSTaskARNKey = attribute.Key("aws.ecs.task.arn")
   380  
   381  	// AWSECSTaskFamilyKey is the attribute Key conforming to the
   382  	// "aws.ecs.task.family" semantic conventions. It represents the task
   383  	// definition family this task definition is a member of.
   384  	//
   385  	// Type: string
   386  	// RequirementLevel: Optional
   387  	// Stability: stable
   388  	// Examples: 'opentelemetry-family'
   389  	AWSECSTaskFamilyKey = attribute.Key("aws.ecs.task.family")
   390  
   391  	// AWSECSTaskRevisionKey is the attribute Key conforming to the
   392  	// "aws.ecs.task.revision" semantic conventions. It represents the revision
   393  	// for this task definition.
   394  	//
   395  	// Type: string
   396  	// RequirementLevel: Optional
   397  	// Stability: stable
   398  	// Examples: '8', '26'
   399  	AWSECSTaskRevisionKey = attribute.Key("aws.ecs.task.revision")
   400  )
   401  
   402  var (
   403  	// ec2
   404  	AWSECSLaunchtypeEC2 = AWSECSLaunchtypeKey.String("ec2")
   405  	// fargate
   406  	AWSECSLaunchtypeFargate = AWSECSLaunchtypeKey.String("fargate")
   407  )
   408  
   409  // AWSECSContainerARN returns an attribute KeyValue conforming to the
   410  // "aws.ecs.container.arn" semantic conventions. It represents the Amazon
   411  // Resource Name (ARN) of an [ECS container
   412  // instance](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_instances.html).
   413  func AWSECSContainerARN(val string) attribute.KeyValue {
   414  	return AWSECSContainerARNKey.String(val)
   415  }
   416  
   417  // AWSECSClusterARN returns an attribute KeyValue conforming to the
   418  // "aws.ecs.cluster.arn" semantic conventions. It represents the ARN of an [ECS
   419  // cluster](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/clusters.html).
   420  func AWSECSClusterARN(val string) attribute.KeyValue {
   421  	return AWSECSClusterARNKey.String(val)
   422  }
   423  
   424  // AWSECSTaskARN returns an attribute KeyValue conforming to the
   425  // "aws.ecs.task.arn" semantic conventions. It represents the ARN of an [ECS
   426  // task
   427  // definition](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definitions.html).
   428  func AWSECSTaskARN(val string) attribute.KeyValue {
   429  	return AWSECSTaskARNKey.String(val)
   430  }
   431  
   432  // AWSECSTaskFamily returns an attribute KeyValue conforming to the
   433  // "aws.ecs.task.family" semantic conventions. It represents the task
   434  // definition family this task definition is a member of.
   435  func AWSECSTaskFamily(val string) attribute.KeyValue {
   436  	return AWSECSTaskFamilyKey.String(val)
   437  }
   438  
   439  // AWSECSTaskRevision returns an attribute KeyValue conforming to the
   440  // "aws.ecs.task.revision" semantic conventions. It represents the revision for
   441  // this task definition.
   442  func AWSECSTaskRevision(val string) attribute.KeyValue {
   443  	return AWSECSTaskRevisionKey.String(val)
   444  }
   445  
   446  // Resources used by AWS Elastic Kubernetes Service (EKS).
   447  const (
   448  	// AWSEKSClusterARNKey is the attribute Key conforming to the
   449  	// "aws.eks.cluster.arn" semantic conventions. It represents the ARN of an
   450  	// EKS cluster.
   451  	//
   452  	// Type: string
   453  	// RequirementLevel: Optional
   454  	// Stability: stable
   455  	// Examples: 'arn:aws:ecs:us-west-2:123456789123:cluster/my-cluster'
   456  	AWSEKSClusterARNKey = attribute.Key("aws.eks.cluster.arn")
   457  )
   458  
   459  // AWSEKSClusterARN returns an attribute KeyValue conforming to the
   460  // "aws.eks.cluster.arn" semantic conventions. It represents the ARN of an EKS
   461  // cluster.
   462  func AWSEKSClusterARN(val string) attribute.KeyValue {
   463  	return AWSEKSClusterARNKey.String(val)
   464  }
   465  
   466  // Resources specific to Amazon Web Services.
   467  const (
   468  	// AWSLogGroupNamesKey is the attribute Key conforming to the
   469  	// "aws.log.group.names" semantic conventions. It represents the name(s) of
   470  	// the AWS log group(s) an application is writing to.
   471  	//
   472  	// Type: string[]
   473  	// RequirementLevel: Optional
   474  	// Stability: stable
   475  	// Examples: '/aws/lambda/my-function', 'opentelemetry-service'
   476  	// Note: Multiple log groups must be supported for cases like
   477  	// multi-container applications, where a single application has sidecar
   478  	// containers, and each write to their own log group.
   479  	AWSLogGroupNamesKey = attribute.Key("aws.log.group.names")
   480  
   481  	// AWSLogGroupARNsKey is the attribute Key conforming to the
   482  	// "aws.log.group.arns" semantic conventions. It represents the Amazon
   483  	// Resource Name(s) (ARN) of the AWS log group(s).
   484  	//
   485  	// Type: string[]
   486  	// RequirementLevel: Optional
   487  	// Stability: stable
   488  	// Examples:
   489  	// 'arn:aws:logs:us-west-1:123456789012:log-group:/aws/my/group:*'
   490  	// Note: See the [log group ARN format
   491  	// documentation](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/iam-access-control-overview-cwl.html#CWL_ARN_Format).
   492  	AWSLogGroupARNsKey = attribute.Key("aws.log.group.arns")
   493  
   494  	// AWSLogStreamNamesKey is the attribute Key conforming to the
   495  	// "aws.log.stream.names" semantic conventions. It represents the name(s)
   496  	// of the AWS log stream(s) an application is writing to.
   497  	//
   498  	// Type: string[]
   499  	// RequirementLevel: Optional
   500  	// Stability: stable
   501  	// Examples: 'logs/main/10838bed-421f-43ef-870a-f43feacbbb5b'
   502  	AWSLogStreamNamesKey = attribute.Key("aws.log.stream.names")
   503  
   504  	// AWSLogStreamARNsKey is the attribute Key conforming to the
   505  	// "aws.log.stream.arns" semantic conventions. It represents the ARN(s) of
   506  	// the AWS log stream(s).
   507  	//
   508  	// Type: string[]
   509  	// RequirementLevel: Optional
   510  	// Stability: stable
   511  	// Examples:
   512  	// 'arn:aws:logs:us-west-1:123456789012:log-group:/aws/my/group:log-stream:logs/main/10838bed-421f-43ef-870a-f43feacbbb5b'
   513  	// Note: See the [log stream ARN format
   514  	// documentation](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/iam-access-control-overview-cwl.html#CWL_ARN_Format).
   515  	// One log group can contain several log streams, so these ARNs necessarily
   516  	// identify both a log group and a log stream.
   517  	AWSLogStreamARNsKey = attribute.Key("aws.log.stream.arns")
   518  )
   519  
   520  // AWSLogGroupNames returns an attribute KeyValue conforming to the
   521  // "aws.log.group.names" semantic conventions. It represents the name(s) of the
   522  // AWS log group(s) an application is writing to.
   523  func AWSLogGroupNames(val ...string) attribute.KeyValue {
   524  	return AWSLogGroupNamesKey.StringSlice(val)
   525  }
   526  
   527  // AWSLogGroupARNs returns an attribute KeyValue conforming to the
   528  // "aws.log.group.arns" semantic conventions. It represents the Amazon Resource
   529  // Name(s) (ARN) of the AWS log group(s).
   530  func AWSLogGroupARNs(val ...string) attribute.KeyValue {
   531  	return AWSLogGroupARNsKey.StringSlice(val)
   532  }
   533  
   534  // AWSLogStreamNames returns an attribute KeyValue conforming to the
   535  // "aws.log.stream.names" semantic conventions. It represents the name(s) of
   536  // the AWS log stream(s) an application is writing to.
   537  func AWSLogStreamNames(val ...string) attribute.KeyValue {
   538  	return AWSLogStreamNamesKey.StringSlice(val)
   539  }
   540  
   541  // AWSLogStreamARNs returns an attribute KeyValue conforming to the
   542  // "aws.log.stream.arns" semantic conventions. It represents the ARN(s) of the
   543  // AWS log stream(s).
   544  func AWSLogStreamARNs(val ...string) attribute.KeyValue {
   545  	return AWSLogStreamARNsKey.StringSlice(val)
   546  }
   547  
   548  // Heroku dyno metadata
   549  const (
   550  	// HerokuReleaseCreationTimestampKey is the attribute Key conforming to the
   551  	// "heroku.release.creation_timestamp" semantic conventions. It represents
   552  	// the time and date the release was created
   553  	//
   554  	// Type: string
   555  	// RequirementLevel: Optional
   556  	// Stability: stable
   557  	// Examples: '2022-10-23T18:00:42Z'
   558  	HerokuReleaseCreationTimestampKey = attribute.Key("heroku.release.creation_timestamp")
   559  
   560  	// HerokuReleaseCommitKey is the attribute Key conforming to the
   561  	// "heroku.release.commit" semantic conventions. It represents the commit
   562  	// hash for the current release
   563  	//
   564  	// Type: string
   565  	// RequirementLevel: Optional
   566  	// Stability: stable
   567  	// Examples: 'e6134959463efd8966b20e75b913cafe3f5ec'
   568  	HerokuReleaseCommitKey = attribute.Key("heroku.release.commit")
   569  
   570  	// HerokuAppIDKey is the attribute Key conforming to the "heroku.app.id"
   571  	// semantic conventions. It represents the unique identifier for the
   572  	// application
   573  	//
   574  	// Type: string
   575  	// RequirementLevel: Optional
   576  	// Stability: stable
   577  	// Examples: '2daa2797-e42b-4624-9322-ec3f968df4da'
   578  	HerokuAppIDKey = attribute.Key("heroku.app.id")
   579  )
   580  
   581  // HerokuReleaseCreationTimestamp returns an attribute KeyValue conforming
   582  // to the "heroku.release.creation_timestamp" semantic conventions. It
   583  // represents the time and date the release was created
   584  func HerokuReleaseCreationTimestamp(val string) attribute.KeyValue {
   585  	return HerokuReleaseCreationTimestampKey.String(val)
   586  }
   587  
   588  // HerokuReleaseCommit returns an attribute KeyValue conforming to the
   589  // "heroku.release.commit" semantic conventions. It represents the commit hash
   590  // for the current release
   591  func HerokuReleaseCommit(val string) attribute.KeyValue {
   592  	return HerokuReleaseCommitKey.String(val)
   593  }
   594  
   595  // HerokuAppID returns an attribute KeyValue conforming to the
   596  // "heroku.app.id" semantic conventions. It represents the unique identifier
   597  // for the application
   598  func HerokuAppID(val string) attribute.KeyValue {
   599  	return HerokuAppIDKey.String(val)
   600  }
   601  
   602  // A container instance.
   603  const (
   604  	// ContainerNameKey is the attribute Key conforming to the "container.name"
   605  	// semantic conventions. It represents the container name used by container
   606  	// runtime.
   607  	//
   608  	// Type: string
   609  	// RequirementLevel: Optional
   610  	// Stability: stable
   611  	// Examples: 'opentelemetry-autoconf'
   612  	ContainerNameKey = attribute.Key("container.name")
   613  
   614  	// ContainerIDKey is the attribute Key conforming to the "container.id"
   615  	// semantic conventions. It represents the container ID. Usually a UUID, as
   616  	// for example used to [identify Docker
   617  	// containers](https://docs.docker.com/engine/reference/run/#container-identification).
   618  	// The UUID might be abbreviated.
   619  	//
   620  	// Type: string
   621  	// RequirementLevel: Optional
   622  	// Stability: stable
   623  	// Examples: 'a3bf90e006b2'
   624  	ContainerIDKey = attribute.Key("container.id")
   625  
   626  	// ContainerRuntimeKey is the attribute Key conforming to the
   627  	// "container.runtime" semantic conventions. It represents the container
   628  	// runtime managing this container.
   629  	//
   630  	// Type: string
   631  	// RequirementLevel: Optional
   632  	// Stability: stable
   633  	// Examples: 'docker', 'containerd', 'rkt'
   634  	ContainerRuntimeKey = attribute.Key("container.runtime")
   635  
   636  	// ContainerImageNameKey is the attribute Key conforming to the
   637  	// "container.image.name" semantic conventions. It represents the name of
   638  	// the image the container was built on.
   639  	//
   640  	// Type: string
   641  	// RequirementLevel: Optional
   642  	// Stability: stable
   643  	// Examples: 'gcr.io/opentelemetry/operator'
   644  	ContainerImageNameKey = attribute.Key("container.image.name")
   645  
   646  	// ContainerImageTagKey is the attribute Key conforming to the
   647  	// "container.image.tag" semantic conventions. It represents the container
   648  	// image tag.
   649  	//
   650  	// Type: string
   651  	// RequirementLevel: Optional
   652  	// Stability: stable
   653  	// Examples: '0.1'
   654  	ContainerImageTagKey = attribute.Key("container.image.tag")
   655  )
   656  
   657  // ContainerName returns an attribute KeyValue conforming to the
   658  // "container.name" semantic conventions. It represents the container name used
   659  // by container runtime.
   660  func ContainerName(val string) attribute.KeyValue {
   661  	return ContainerNameKey.String(val)
   662  }
   663  
   664  // ContainerID returns an attribute KeyValue conforming to the
   665  // "container.id" semantic conventions. It represents the container ID. Usually
   666  // a UUID, as for example used to [identify Docker
   667  // containers](https://docs.docker.com/engine/reference/run/#container-identification).
   668  // The UUID might be abbreviated.
   669  func ContainerID(val string) attribute.KeyValue {
   670  	return ContainerIDKey.String(val)
   671  }
   672  
   673  // ContainerRuntime returns an attribute KeyValue conforming to the
   674  // "container.runtime" semantic conventions. It represents the container
   675  // runtime managing this container.
   676  func ContainerRuntime(val string) attribute.KeyValue {
   677  	return ContainerRuntimeKey.String(val)
   678  }
   679  
   680  // ContainerImageName returns an attribute KeyValue conforming to the
   681  // "container.image.name" semantic conventions. It represents the name of the
   682  // image the container was built on.
   683  func ContainerImageName(val string) attribute.KeyValue {
   684  	return ContainerImageNameKey.String(val)
   685  }
   686  
   687  // ContainerImageTag returns an attribute KeyValue conforming to the
   688  // "container.image.tag" semantic conventions. It represents the container
   689  // image tag.
   690  func ContainerImageTag(val string) attribute.KeyValue {
   691  	return ContainerImageTagKey.String(val)
   692  }
   693  
   694  // The software deployment.
   695  const (
   696  	// DeploymentEnvironmentKey is the attribute Key conforming to the
   697  	// "deployment.environment" semantic conventions. It represents the name of
   698  	// the [deployment
   699  	// environment](https://en.wikipedia.org/wiki/Deployment_environment) (aka
   700  	// deployment tier).
   701  	//
   702  	// Type: string
   703  	// RequirementLevel: Optional
   704  	// Stability: stable
   705  	// Examples: 'staging', 'production'
   706  	DeploymentEnvironmentKey = attribute.Key("deployment.environment")
   707  )
   708  
   709  // DeploymentEnvironment returns an attribute KeyValue conforming to the
   710  // "deployment.environment" semantic conventions. It represents the name of the
   711  // [deployment
   712  // environment](https://en.wikipedia.org/wiki/Deployment_environment) (aka
   713  // deployment tier).
   714  func DeploymentEnvironment(val string) attribute.KeyValue {
   715  	return DeploymentEnvironmentKey.String(val)
   716  }
   717  
   718  // The device on which the process represented by this resource is running.
   719  const (
   720  	// DeviceIDKey is the attribute Key conforming to the "device.id" semantic
   721  	// conventions. It represents a unique identifier representing the device
   722  	//
   723  	// Type: string
   724  	// RequirementLevel: Optional
   725  	// Stability: stable
   726  	// Examples: '2ab2916d-a51f-4ac8-80ee-45ac31a28092'
   727  	// Note: The device identifier MUST only be defined using the values
   728  	// outlined below. This value is not an advertising identifier and MUST NOT
   729  	// be used as such. On iOS (Swift or Objective-C), this value MUST be equal
   730  	// to the [vendor
   731  	// identifier](https://developer.apple.com/documentation/uikit/uidevice/1620059-identifierforvendor).
   732  	// On Android (Java or Kotlin), this value MUST be equal to the Firebase
   733  	// Installation ID or a globally unique UUID which is persisted across
   734  	// sessions in your application. More information can be found
   735  	// [here](https://developer.android.com/training/articles/user-data-ids) on
   736  	// best practices and exact implementation details. Caution should be taken
   737  	// when storing personal data or anything which can identify a user. GDPR
   738  	// and data protection laws may apply, ensure you do your own due
   739  	// diligence.
   740  	DeviceIDKey = attribute.Key("device.id")
   741  
   742  	// DeviceModelIdentifierKey is the attribute Key conforming to the
   743  	// "device.model.identifier" semantic conventions. It represents the model
   744  	// identifier for the device
   745  	//
   746  	// Type: string
   747  	// RequirementLevel: Optional
   748  	// Stability: stable
   749  	// Examples: 'iPhone3,4', 'SM-G920F'
   750  	// Note: It's recommended this value represents a machine readable version
   751  	// of the model identifier rather than the market or consumer-friendly name
   752  	// of the device.
   753  	DeviceModelIdentifierKey = attribute.Key("device.model.identifier")
   754  
   755  	// DeviceModelNameKey is the attribute Key conforming to the
   756  	// "device.model.name" semantic conventions. It represents the marketing
   757  	// name for the device model
   758  	//
   759  	// Type: string
   760  	// RequirementLevel: Optional
   761  	// Stability: stable
   762  	// Examples: 'iPhone 6s Plus', 'Samsung Galaxy S6'
   763  	// Note: It's recommended this value represents a human readable version of
   764  	// the device model rather than a machine readable alternative.
   765  	DeviceModelNameKey = attribute.Key("device.model.name")
   766  
   767  	// DeviceManufacturerKey is the attribute Key conforming to the
   768  	// "device.manufacturer" semantic conventions. It represents the name of
   769  	// the device manufacturer
   770  	//
   771  	// Type: string
   772  	// RequirementLevel: Optional
   773  	// Stability: stable
   774  	// Examples: 'Apple', 'Samsung'
   775  	// Note: The Android OS provides this field via
   776  	// [Build](https://developer.android.com/reference/android/os/Build#MANUFACTURER).
   777  	// iOS apps SHOULD hardcode the value `Apple`.
   778  	DeviceManufacturerKey = attribute.Key("device.manufacturer")
   779  )
   780  
   781  // DeviceID returns an attribute KeyValue conforming to the "device.id"
   782  // semantic conventions. It represents a unique identifier representing the
   783  // device
   784  func DeviceID(val string) attribute.KeyValue {
   785  	return DeviceIDKey.String(val)
   786  }
   787  
   788  // DeviceModelIdentifier returns an attribute KeyValue conforming to the
   789  // "device.model.identifier" semantic conventions. It represents the model
   790  // identifier for the device
   791  func DeviceModelIdentifier(val string) attribute.KeyValue {
   792  	return DeviceModelIdentifierKey.String(val)
   793  }
   794  
   795  // DeviceModelName returns an attribute KeyValue conforming to the
   796  // "device.model.name" semantic conventions. It represents the marketing name
   797  // for the device model
   798  func DeviceModelName(val string) attribute.KeyValue {
   799  	return DeviceModelNameKey.String(val)
   800  }
   801  
   802  // DeviceManufacturer returns an attribute KeyValue conforming to the
   803  // "device.manufacturer" semantic conventions. It represents the name of the
   804  // device manufacturer
   805  func DeviceManufacturer(val string) attribute.KeyValue {
   806  	return DeviceManufacturerKey.String(val)
   807  }
   808  
   809  // A serverless instance.
   810  const (
   811  	// FaaSNameKey is the attribute Key conforming to the "faas.name" semantic
   812  	// conventions. It represents the name of the single function that this
   813  	// runtime instance executes.
   814  	//
   815  	// Type: string
   816  	// RequirementLevel: Required
   817  	// Stability: stable
   818  	// Examples: 'my-function', 'myazurefunctionapp/some-function-name'
   819  	// Note: This is the name of the function as configured/deployed on the
   820  	// FaaS
   821  	// platform and is usually different from the name of the callback
   822  	// function (which may be stored in the
   823  	// [`code.namespace`/`code.function`](../../trace/semantic_conventions/span-general.md#source-code-attributes)
   824  	// span attributes).
   825  	//
   826  	// For some cloud providers, the above definition is ambiguous. The
   827  	// following
   828  	// definition of function name MUST be used for this attribute
   829  	// (and consequently the span name) for the listed cloud
   830  	// providers/products:
   831  	//
   832  	// * **Azure:**  The full name `<FUNCAPP>/<FUNC>`, i.e., function app name
   833  	//   followed by a forward slash followed by the function name (this form
   834  	//   can also be seen in the resource JSON for the function).
   835  	//   This means that a span attribute MUST be used, as an Azure function
   836  	//   app can host multiple functions that would usually share
   837  	//   a TracerProvider (see also the `cloud.resource_id` attribute).
   838  	FaaSNameKey = attribute.Key("faas.name")
   839  
   840  	// FaaSVersionKey is the attribute Key conforming to the "faas.version"
   841  	// semantic conventions. It represents the immutable version of the
   842  	// function being executed.
   843  	//
   844  	// Type: string
   845  	// RequirementLevel: Optional
   846  	// Stability: stable
   847  	// Examples: '26', 'pinkfroid-00002'
   848  	// Note: Depending on the cloud provider and platform, use:
   849  	//
   850  	// * **AWS Lambda:** The [function
   851  	// version](https://docs.aws.amazon.com/lambda/latest/dg/configuration-versions.html)
   852  	//   (an integer represented as a decimal string).
   853  	// * **Google Cloud Run:** The
   854  	// [revision](https://cloud.google.com/run/docs/managing/revisions)
   855  	//   (i.e., the function name plus the revision suffix).
   856  	// * **Google Cloud Functions:** The value of the
   857  	//   [`K_REVISION` environment
   858  	// variable](https://cloud.google.com/functions/docs/env-var#runtime_environment_variables_set_automatically).
   859  	// * **Azure Functions:** Not applicable. Do not set this attribute.
   860  	FaaSVersionKey = attribute.Key("faas.version")
   861  
   862  	// FaaSInstanceKey is the attribute Key conforming to the "faas.instance"
   863  	// semantic conventions. It represents the execution environment ID as a
   864  	// string, that will be potentially reused for other invocations to the
   865  	// same function/function version.
   866  	//
   867  	// Type: string
   868  	// RequirementLevel: Optional
   869  	// Stability: stable
   870  	// Examples: '2021/06/28/[$LATEST]2f399eb14537447da05ab2a2e39309de'
   871  	// Note: * **AWS Lambda:** Use the (full) log stream name.
   872  	FaaSInstanceKey = attribute.Key("faas.instance")
   873  
   874  	// FaaSMaxMemoryKey is the attribute Key conforming to the
   875  	// "faas.max_memory" semantic conventions. It represents the amount of
   876  	// memory available to the serverless function converted to Bytes.
   877  	//
   878  	// Type: int
   879  	// RequirementLevel: Optional
   880  	// Stability: stable
   881  	// Examples: 134217728
   882  	// Note: It's recommended to set this attribute since e.g. too little
   883  	// memory can easily stop a Java AWS Lambda function from working
   884  	// correctly. On AWS Lambda, the environment variable
   885  	// `AWS_LAMBDA_FUNCTION_MEMORY_SIZE` provides this information (which must
   886  	// be multiplied by 1,048,576).
   887  	FaaSMaxMemoryKey = attribute.Key("faas.max_memory")
   888  )
   889  
   890  // FaaSName returns an attribute KeyValue conforming to the "faas.name"
   891  // semantic conventions. It represents the name of the single function that
   892  // this runtime instance executes.
   893  func FaaSName(val string) attribute.KeyValue {
   894  	return FaaSNameKey.String(val)
   895  }
   896  
   897  // FaaSVersion returns an attribute KeyValue conforming to the
   898  // "faas.version" semantic conventions. It represents the immutable version of
   899  // the function being executed.
   900  func FaaSVersion(val string) attribute.KeyValue {
   901  	return FaaSVersionKey.String(val)
   902  }
   903  
   904  // FaaSInstance returns an attribute KeyValue conforming to the
   905  // "faas.instance" semantic conventions. It represents the execution
   906  // environment ID as a string, that will be potentially reused for other
   907  // invocations to the same function/function version.
   908  func FaaSInstance(val string) attribute.KeyValue {
   909  	return FaaSInstanceKey.String(val)
   910  }
   911  
   912  // FaaSMaxMemory returns an attribute KeyValue conforming to the
   913  // "faas.max_memory" semantic conventions. It represents the amount of memory
   914  // available to the serverless function converted to Bytes.
   915  func FaaSMaxMemory(val int) attribute.KeyValue {
   916  	return FaaSMaxMemoryKey.Int(val)
   917  }
   918  
   919  // A host is defined as a general computing instance.
   920  const (
   921  	// HostIDKey is the attribute Key conforming to the "host.id" semantic
   922  	// conventions. It represents the unique host ID. For Cloud, this must be
   923  	// the instance_id assigned by the cloud provider. For non-containerized
   924  	// systems, this should be the `machine-id`. See the table below for the
   925  	// sources to use to determine the `machine-id` based on operating system.
   926  	//
   927  	// Type: string
   928  	// RequirementLevel: Optional
   929  	// Stability: stable
   930  	// Examples: 'fdbf79e8af94cb7f9e8df36789187052'
   931  	HostIDKey = attribute.Key("host.id")
   932  
   933  	// HostNameKey is the attribute Key conforming to the "host.name" semantic
   934  	// conventions. It represents the name of the host. On Unix systems, it may
   935  	// contain what the hostname command returns, or the fully qualified
   936  	// hostname, or another name specified by the user.
   937  	//
   938  	// Type: string
   939  	// RequirementLevel: Optional
   940  	// Stability: stable
   941  	// Examples: 'opentelemetry-test'
   942  	HostNameKey = attribute.Key("host.name")
   943  
   944  	// HostTypeKey is the attribute Key conforming to the "host.type" semantic
   945  	// conventions. It represents the type of host. For Cloud, this must be the
   946  	// machine type.
   947  	//
   948  	// Type: string
   949  	// RequirementLevel: Optional
   950  	// Stability: stable
   951  	// Examples: 'n1-standard-1'
   952  	HostTypeKey = attribute.Key("host.type")
   953  
   954  	// HostArchKey is the attribute Key conforming to the "host.arch" semantic
   955  	// conventions. It represents the CPU architecture the host system is
   956  	// running on.
   957  	//
   958  	// Type: Enum
   959  	// RequirementLevel: Optional
   960  	// Stability: stable
   961  	HostArchKey = attribute.Key("host.arch")
   962  
   963  	// HostImageNameKey is the attribute Key conforming to the
   964  	// "host.image.name" semantic conventions. It represents the name of the VM
   965  	// image or OS install the host was instantiated from.
   966  	//
   967  	// Type: string
   968  	// RequirementLevel: Optional
   969  	// Stability: stable
   970  	// Examples: 'infra-ami-eks-worker-node-7d4ec78312', 'CentOS-8-x86_64-1905'
   971  	HostImageNameKey = attribute.Key("host.image.name")
   972  
   973  	// HostImageIDKey is the attribute Key conforming to the "host.image.id"
   974  	// semantic conventions. It represents the vM image ID. For Cloud, this
   975  	// value is from the provider.
   976  	//
   977  	// Type: string
   978  	// RequirementLevel: Optional
   979  	// Stability: stable
   980  	// Examples: 'ami-07b06b442921831e5'
   981  	HostImageIDKey = attribute.Key("host.image.id")
   982  
   983  	// HostImageVersionKey is the attribute Key conforming to the
   984  	// "host.image.version" semantic conventions. It represents the version
   985  	// string of the VM image as defined in [Version
   986  	// Attributes](README.md#version-attributes).
   987  	//
   988  	// Type: string
   989  	// RequirementLevel: Optional
   990  	// Stability: stable
   991  	// Examples: '0.1'
   992  	HostImageVersionKey = attribute.Key("host.image.version")
   993  )
   994  
   995  var (
   996  	// AMD64
   997  	HostArchAMD64 = HostArchKey.String("amd64")
   998  	// ARM32
   999  	HostArchARM32 = HostArchKey.String("arm32")
  1000  	// ARM64
  1001  	HostArchARM64 = HostArchKey.String("arm64")
  1002  	// Itanium
  1003  	HostArchIA64 = HostArchKey.String("ia64")
  1004  	// 32-bit PowerPC
  1005  	HostArchPPC32 = HostArchKey.String("ppc32")
  1006  	// 64-bit PowerPC
  1007  	HostArchPPC64 = HostArchKey.String("ppc64")
  1008  	// IBM z/Architecture
  1009  	HostArchS390x = HostArchKey.String("s390x")
  1010  	// 32-bit x86
  1011  	HostArchX86 = HostArchKey.String("x86")
  1012  )
  1013  
  1014  // HostID returns an attribute KeyValue conforming to the "host.id" semantic
  1015  // conventions. It represents the unique host ID. For Cloud, this must be the
  1016  // instance_id assigned by the cloud provider. For non-containerized systems,
  1017  // this should be the `machine-id`. See the table below for the sources to use
  1018  // to determine the `machine-id` based on operating system.
  1019  func HostID(val string) attribute.KeyValue {
  1020  	return HostIDKey.String(val)
  1021  }
  1022  
  1023  // HostName returns an attribute KeyValue conforming to the "host.name"
  1024  // semantic conventions. It represents the name of the host. On Unix systems,
  1025  // it may contain what the hostname command returns, or the fully qualified
  1026  // hostname, or another name specified by the user.
  1027  func HostName(val string) attribute.KeyValue {
  1028  	return HostNameKey.String(val)
  1029  }
  1030  
  1031  // HostType returns an attribute KeyValue conforming to the "host.type"
  1032  // semantic conventions. It represents the type of host. For Cloud, this must
  1033  // be the machine type.
  1034  func HostType(val string) attribute.KeyValue {
  1035  	return HostTypeKey.String(val)
  1036  }
  1037  
  1038  // HostImageName returns an attribute KeyValue conforming to the
  1039  // "host.image.name" semantic conventions. It represents the name of the VM
  1040  // image or OS install the host was instantiated from.
  1041  func HostImageName(val string) attribute.KeyValue {
  1042  	return HostImageNameKey.String(val)
  1043  }
  1044  
  1045  // HostImageID returns an attribute KeyValue conforming to the
  1046  // "host.image.id" semantic conventions. It represents the vM image ID. For
  1047  // Cloud, this value is from the provider.
  1048  func HostImageID(val string) attribute.KeyValue {
  1049  	return HostImageIDKey.String(val)
  1050  }
  1051  
  1052  // HostImageVersion returns an attribute KeyValue conforming to the
  1053  // "host.image.version" semantic conventions. It represents the version string
  1054  // of the VM image as defined in [Version
  1055  // Attributes](README.md#version-attributes).
  1056  func HostImageVersion(val string) attribute.KeyValue {
  1057  	return HostImageVersionKey.String(val)
  1058  }
  1059  
  1060  // A Kubernetes Cluster.
  1061  const (
  1062  	// K8SClusterNameKey is the attribute Key conforming to the
  1063  	// "k8s.cluster.name" semantic conventions. It represents the name of the
  1064  	// cluster.
  1065  	//
  1066  	// Type: string
  1067  	// RequirementLevel: Optional
  1068  	// Stability: stable
  1069  	// Examples: 'opentelemetry-cluster'
  1070  	K8SClusterNameKey = attribute.Key("k8s.cluster.name")
  1071  )
  1072  
  1073  // K8SClusterName returns an attribute KeyValue conforming to the
  1074  // "k8s.cluster.name" semantic conventions. It represents the name of the
  1075  // cluster.
  1076  func K8SClusterName(val string) attribute.KeyValue {
  1077  	return K8SClusterNameKey.String(val)
  1078  }
  1079  
  1080  // A Kubernetes Node object.
  1081  const (
  1082  	// K8SNodeNameKey is the attribute Key conforming to the "k8s.node.name"
  1083  	// semantic conventions. It represents the name of the Node.
  1084  	//
  1085  	// Type: string
  1086  	// RequirementLevel: Optional
  1087  	// Stability: stable
  1088  	// Examples: 'node-1'
  1089  	K8SNodeNameKey = attribute.Key("k8s.node.name")
  1090  
  1091  	// K8SNodeUIDKey is the attribute Key conforming to the "k8s.node.uid"
  1092  	// semantic conventions. It represents the UID of the Node.
  1093  	//
  1094  	// Type: string
  1095  	// RequirementLevel: Optional
  1096  	// Stability: stable
  1097  	// Examples: '1eb3a0c6-0477-4080-a9cb-0cb7db65c6a2'
  1098  	K8SNodeUIDKey = attribute.Key("k8s.node.uid")
  1099  )
  1100  
  1101  // K8SNodeName returns an attribute KeyValue conforming to the
  1102  // "k8s.node.name" semantic conventions. It represents the name of the Node.
  1103  func K8SNodeName(val string) attribute.KeyValue {
  1104  	return K8SNodeNameKey.String(val)
  1105  }
  1106  
  1107  // K8SNodeUID returns an attribute KeyValue conforming to the "k8s.node.uid"
  1108  // semantic conventions. It represents the UID of the Node.
  1109  func K8SNodeUID(val string) attribute.KeyValue {
  1110  	return K8SNodeUIDKey.String(val)
  1111  }
  1112  
  1113  // A Kubernetes Namespace.
  1114  const (
  1115  	// K8SNamespaceNameKey is the attribute Key conforming to the
  1116  	// "k8s.namespace.name" semantic conventions. It represents the name of the
  1117  	// namespace that the pod is running in.
  1118  	//
  1119  	// Type: string
  1120  	// RequirementLevel: Optional
  1121  	// Stability: stable
  1122  	// Examples: 'default'
  1123  	K8SNamespaceNameKey = attribute.Key("k8s.namespace.name")
  1124  )
  1125  
  1126  // K8SNamespaceName returns an attribute KeyValue conforming to the
  1127  // "k8s.namespace.name" semantic conventions. It represents the name of the
  1128  // namespace that the pod is running in.
  1129  func K8SNamespaceName(val string) attribute.KeyValue {
  1130  	return K8SNamespaceNameKey.String(val)
  1131  }
  1132  
  1133  // A Kubernetes Pod object.
  1134  const (
  1135  	// K8SPodUIDKey is the attribute Key conforming to the "k8s.pod.uid"
  1136  	// semantic conventions. It represents the UID of the Pod.
  1137  	//
  1138  	// Type: string
  1139  	// RequirementLevel: Optional
  1140  	// Stability: stable
  1141  	// Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
  1142  	K8SPodUIDKey = attribute.Key("k8s.pod.uid")
  1143  
  1144  	// K8SPodNameKey is the attribute Key conforming to the "k8s.pod.name"
  1145  	// semantic conventions. It represents the name of the Pod.
  1146  	//
  1147  	// Type: string
  1148  	// RequirementLevel: Optional
  1149  	// Stability: stable
  1150  	// Examples: 'opentelemetry-pod-autoconf'
  1151  	K8SPodNameKey = attribute.Key("k8s.pod.name")
  1152  )
  1153  
  1154  // K8SPodUID returns an attribute KeyValue conforming to the "k8s.pod.uid"
  1155  // semantic conventions. It represents the UID of the Pod.
  1156  func K8SPodUID(val string) attribute.KeyValue {
  1157  	return K8SPodUIDKey.String(val)
  1158  }
  1159  
  1160  // K8SPodName returns an attribute KeyValue conforming to the "k8s.pod.name"
  1161  // semantic conventions. It represents the name of the Pod.
  1162  func K8SPodName(val string) attribute.KeyValue {
  1163  	return K8SPodNameKey.String(val)
  1164  }
  1165  
  1166  // A container in a
  1167  // [PodTemplate](https://kubernetes.io/docs/concepts/workloads/pods/#pod-templates).
  1168  const (
  1169  	// K8SContainerNameKey is the attribute Key conforming to the
  1170  	// "k8s.container.name" semantic conventions. It represents the name of the
  1171  	// Container from Pod specification, must be unique within a Pod. Container
  1172  	// runtime usually uses different globally unique name (`container.name`).
  1173  	//
  1174  	// Type: string
  1175  	// RequirementLevel: Optional
  1176  	// Stability: stable
  1177  	// Examples: 'redis'
  1178  	K8SContainerNameKey = attribute.Key("k8s.container.name")
  1179  
  1180  	// K8SContainerRestartCountKey is the attribute Key conforming to the
  1181  	// "k8s.container.restart_count" semantic conventions. It represents the
  1182  	// number of times the container was restarted. This attribute can be used
  1183  	// to identify a particular container (running or stopped) within a
  1184  	// container spec.
  1185  	//
  1186  	// Type: int
  1187  	// RequirementLevel: Optional
  1188  	// Stability: stable
  1189  	// Examples: 0, 2
  1190  	K8SContainerRestartCountKey = attribute.Key("k8s.container.restart_count")
  1191  )
  1192  
  1193  // K8SContainerName returns an attribute KeyValue conforming to the
  1194  // "k8s.container.name" semantic conventions. It represents the name of the
  1195  // Container from Pod specification, must be unique within a Pod. Container
  1196  // runtime usually uses different globally unique name (`container.name`).
  1197  func K8SContainerName(val string) attribute.KeyValue {
  1198  	return K8SContainerNameKey.String(val)
  1199  }
  1200  
  1201  // K8SContainerRestartCount returns an attribute KeyValue conforming to the
  1202  // "k8s.container.restart_count" semantic conventions. It represents the number
  1203  // of times the container was restarted. This attribute can be used to identify
  1204  // a particular container (running or stopped) within a container spec.
  1205  func K8SContainerRestartCount(val int) attribute.KeyValue {
  1206  	return K8SContainerRestartCountKey.Int(val)
  1207  }
  1208  
  1209  // A Kubernetes ReplicaSet object.
  1210  const (
  1211  	// K8SReplicaSetUIDKey is the attribute Key conforming to the
  1212  	// "k8s.replicaset.uid" semantic conventions. It represents the UID of the
  1213  	// ReplicaSet.
  1214  	//
  1215  	// Type: string
  1216  	// RequirementLevel: Optional
  1217  	// Stability: stable
  1218  	// Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
  1219  	K8SReplicaSetUIDKey = attribute.Key("k8s.replicaset.uid")
  1220  
  1221  	// K8SReplicaSetNameKey is the attribute Key conforming to the
  1222  	// "k8s.replicaset.name" semantic conventions. It represents the name of
  1223  	// the ReplicaSet.
  1224  	//
  1225  	// Type: string
  1226  	// RequirementLevel: Optional
  1227  	// Stability: stable
  1228  	// Examples: 'opentelemetry'
  1229  	K8SReplicaSetNameKey = attribute.Key("k8s.replicaset.name")
  1230  )
  1231  
  1232  // K8SReplicaSetUID returns an attribute KeyValue conforming to the
  1233  // "k8s.replicaset.uid" semantic conventions. It represents the UID of the
  1234  // ReplicaSet.
  1235  func K8SReplicaSetUID(val string) attribute.KeyValue {
  1236  	return K8SReplicaSetUIDKey.String(val)
  1237  }
  1238  
  1239  // K8SReplicaSetName returns an attribute KeyValue conforming to the
  1240  // "k8s.replicaset.name" semantic conventions. It represents the name of the
  1241  // ReplicaSet.
  1242  func K8SReplicaSetName(val string) attribute.KeyValue {
  1243  	return K8SReplicaSetNameKey.String(val)
  1244  }
  1245  
  1246  // A Kubernetes Deployment object.
  1247  const (
  1248  	// K8SDeploymentUIDKey is the attribute Key conforming to the
  1249  	// "k8s.deployment.uid" semantic conventions. It represents the UID of the
  1250  	// Deployment.
  1251  	//
  1252  	// Type: string
  1253  	// RequirementLevel: Optional
  1254  	// Stability: stable
  1255  	// Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
  1256  	K8SDeploymentUIDKey = attribute.Key("k8s.deployment.uid")
  1257  
  1258  	// K8SDeploymentNameKey is the attribute Key conforming to the
  1259  	// "k8s.deployment.name" semantic conventions. It represents the name of
  1260  	// the Deployment.
  1261  	//
  1262  	// Type: string
  1263  	// RequirementLevel: Optional
  1264  	// Stability: stable
  1265  	// Examples: 'opentelemetry'
  1266  	K8SDeploymentNameKey = attribute.Key("k8s.deployment.name")
  1267  )
  1268  
  1269  // K8SDeploymentUID returns an attribute KeyValue conforming to the
  1270  // "k8s.deployment.uid" semantic conventions. It represents the UID of the
  1271  // Deployment.
  1272  func K8SDeploymentUID(val string) attribute.KeyValue {
  1273  	return K8SDeploymentUIDKey.String(val)
  1274  }
  1275  
  1276  // K8SDeploymentName returns an attribute KeyValue conforming to the
  1277  // "k8s.deployment.name" semantic conventions. It represents the name of the
  1278  // Deployment.
  1279  func K8SDeploymentName(val string) attribute.KeyValue {
  1280  	return K8SDeploymentNameKey.String(val)
  1281  }
  1282  
  1283  // A Kubernetes StatefulSet object.
  1284  const (
  1285  	// K8SStatefulSetUIDKey is the attribute Key conforming to the
  1286  	// "k8s.statefulset.uid" semantic conventions. It represents the UID of the
  1287  	// StatefulSet.
  1288  	//
  1289  	// Type: string
  1290  	// RequirementLevel: Optional
  1291  	// Stability: stable
  1292  	// Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
  1293  	K8SStatefulSetUIDKey = attribute.Key("k8s.statefulset.uid")
  1294  
  1295  	// K8SStatefulSetNameKey is the attribute Key conforming to the
  1296  	// "k8s.statefulset.name" semantic conventions. It represents the name of
  1297  	// the StatefulSet.
  1298  	//
  1299  	// Type: string
  1300  	// RequirementLevel: Optional
  1301  	// Stability: stable
  1302  	// Examples: 'opentelemetry'
  1303  	K8SStatefulSetNameKey = attribute.Key("k8s.statefulset.name")
  1304  )
  1305  
  1306  // K8SStatefulSetUID returns an attribute KeyValue conforming to the
  1307  // "k8s.statefulset.uid" semantic conventions. It represents the UID of the
  1308  // StatefulSet.
  1309  func K8SStatefulSetUID(val string) attribute.KeyValue {
  1310  	return K8SStatefulSetUIDKey.String(val)
  1311  }
  1312  
  1313  // K8SStatefulSetName returns an attribute KeyValue conforming to the
  1314  // "k8s.statefulset.name" semantic conventions. It represents the name of the
  1315  // StatefulSet.
  1316  func K8SStatefulSetName(val string) attribute.KeyValue {
  1317  	return K8SStatefulSetNameKey.String(val)
  1318  }
  1319  
  1320  // A Kubernetes DaemonSet object.
  1321  const (
  1322  	// K8SDaemonSetUIDKey is the attribute Key conforming to the
  1323  	// "k8s.daemonset.uid" semantic conventions. It represents the UID of the
  1324  	// DaemonSet.
  1325  	//
  1326  	// Type: string
  1327  	// RequirementLevel: Optional
  1328  	// Stability: stable
  1329  	// Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
  1330  	K8SDaemonSetUIDKey = attribute.Key("k8s.daemonset.uid")
  1331  
  1332  	// K8SDaemonSetNameKey is the attribute Key conforming to the
  1333  	// "k8s.daemonset.name" semantic conventions. It represents the name of the
  1334  	// DaemonSet.
  1335  	//
  1336  	// Type: string
  1337  	// RequirementLevel: Optional
  1338  	// Stability: stable
  1339  	// Examples: 'opentelemetry'
  1340  	K8SDaemonSetNameKey = attribute.Key("k8s.daemonset.name")
  1341  )
  1342  
  1343  // K8SDaemonSetUID returns an attribute KeyValue conforming to the
  1344  // "k8s.daemonset.uid" semantic conventions. It represents the UID of the
  1345  // DaemonSet.
  1346  func K8SDaemonSetUID(val string) attribute.KeyValue {
  1347  	return K8SDaemonSetUIDKey.String(val)
  1348  }
  1349  
  1350  // K8SDaemonSetName returns an attribute KeyValue conforming to the
  1351  // "k8s.daemonset.name" semantic conventions. It represents the name of the
  1352  // DaemonSet.
  1353  func K8SDaemonSetName(val string) attribute.KeyValue {
  1354  	return K8SDaemonSetNameKey.String(val)
  1355  }
  1356  
  1357  // A Kubernetes Job object.
  1358  const (
  1359  	// K8SJobUIDKey is the attribute Key conforming to the "k8s.job.uid"
  1360  	// semantic conventions. It represents the UID of the Job.
  1361  	//
  1362  	// Type: string
  1363  	// RequirementLevel: Optional
  1364  	// Stability: stable
  1365  	// Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
  1366  	K8SJobUIDKey = attribute.Key("k8s.job.uid")
  1367  
  1368  	// K8SJobNameKey is the attribute Key conforming to the "k8s.job.name"
  1369  	// semantic conventions. It represents the name of the Job.
  1370  	//
  1371  	// Type: string
  1372  	// RequirementLevel: Optional
  1373  	// Stability: stable
  1374  	// Examples: 'opentelemetry'
  1375  	K8SJobNameKey = attribute.Key("k8s.job.name")
  1376  )
  1377  
  1378  // K8SJobUID returns an attribute KeyValue conforming to the "k8s.job.uid"
  1379  // semantic conventions. It represents the UID of the Job.
  1380  func K8SJobUID(val string) attribute.KeyValue {
  1381  	return K8SJobUIDKey.String(val)
  1382  }
  1383  
  1384  // K8SJobName returns an attribute KeyValue conforming to the "k8s.job.name"
  1385  // semantic conventions. It represents the name of the Job.
  1386  func K8SJobName(val string) attribute.KeyValue {
  1387  	return K8SJobNameKey.String(val)
  1388  }
  1389  
  1390  // A Kubernetes CronJob object.
  1391  const (
  1392  	// K8SCronJobUIDKey is the attribute Key conforming to the
  1393  	// "k8s.cronjob.uid" semantic conventions. It represents the UID of the
  1394  	// CronJob.
  1395  	//
  1396  	// Type: string
  1397  	// RequirementLevel: Optional
  1398  	// Stability: stable
  1399  	// Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
  1400  	K8SCronJobUIDKey = attribute.Key("k8s.cronjob.uid")
  1401  
  1402  	// K8SCronJobNameKey is the attribute Key conforming to the
  1403  	// "k8s.cronjob.name" semantic conventions. It represents the name of the
  1404  	// CronJob.
  1405  	//
  1406  	// Type: string
  1407  	// RequirementLevel: Optional
  1408  	// Stability: stable
  1409  	// Examples: 'opentelemetry'
  1410  	K8SCronJobNameKey = attribute.Key("k8s.cronjob.name")
  1411  )
  1412  
  1413  // K8SCronJobUID returns an attribute KeyValue conforming to the
  1414  // "k8s.cronjob.uid" semantic conventions. It represents the UID of the
  1415  // CronJob.
  1416  func K8SCronJobUID(val string) attribute.KeyValue {
  1417  	return K8SCronJobUIDKey.String(val)
  1418  }
  1419  
  1420  // K8SCronJobName returns an attribute KeyValue conforming to the
  1421  // "k8s.cronjob.name" semantic conventions. It represents the name of the
  1422  // CronJob.
  1423  func K8SCronJobName(val string) attribute.KeyValue {
  1424  	return K8SCronJobNameKey.String(val)
  1425  }
  1426  
  1427  // The operating system (OS) on which the process represented by this resource
  1428  // is running.
  1429  const (
  1430  	// OSTypeKey is the attribute Key conforming to the "os.type" semantic
  1431  	// conventions. It represents the operating system type.
  1432  	//
  1433  	// Type: Enum
  1434  	// RequirementLevel: Required
  1435  	// Stability: stable
  1436  	OSTypeKey = attribute.Key("os.type")
  1437  
  1438  	// OSDescriptionKey is the attribute Key conforming to the "os.description"
  1439  	// semantic conventions. It represents the human readable (not intended to
  1440  	// be parsed) OS version information, like e.g. reported by `ver` or
  1441  	// `lsb_release -a` commands.
  1442  	//
  1443  	// Type: string
  1444  	// RequirementLevel: Optional
  1445  	// Stability: stable
  1446  	// Examples: 'Microsoft Windows [Version 10.0.18363.778]', 'Ubuntu 18.04.1
  1447  	// LTS'
  1448  	OSDescriptionKey = attribute.Key("os.description")
  1449  
  1450  	// OSNameKey is the attribute Key conforming to the "os.name" semantic
  1451  	// conventions. It represents the human readable operating system name.
  1452  	//
  1453  	// Type: string
  1454  	// RequirementLevel: Optional
  1455  	// Stability: stable
  1456  	// Examples: 'iOS', 'Android', 'Ubuntu'
  1457  	OSNameKey = attribute.Key("os.name")
  1458  
  1459  	// OSVersionKey is the attribute Key conforming to the "os.version"
  1460  	// semantic conventions. It represents the version string of the operating
  1461  	// system as defined in [Version
  1462  	// Attributes](../../resource/semantic_conventions/README.md#version-attributes).
  1463  	//
  1464  	// Type: string
  1465  	// RequirementLevel: Optional
  1466  	// Stability: stable
  1467  	// Examples: '14.2.1', '18.04.1'
  1468  	OSVersionKey = attribute.Key("os.version")
  1469  )
  1470  
  1471  var (
  1472  	// Microsoft Windows
  1473  	OSTypeWindows = OSTypeKey.String("windows")
  1474  	// Linux
  1475  	OSTypeLinux = OSTypeKey.String("linux")
  1476  	// Apple Darwin
  1477  	OSTypeDarwin = OSTypeKey.String("darwin")
  1478  	// FreeBSD
  1479  	OSTypeFreeBSD = OSTypeKey.String("freebsd")
  1480  	// NetBSD
  1481  	OSTypeNetBSD = OSTypeKey.String("netbsd")
  1482  	// OpenBSD
  1483  	OSTypeOpenBSD = OSTypeKey.String("openbsd")
  1484  	// DragonFly BSD
  1485  	OSTypeDragonflyBSD = OSTypeKey.String("dragonflybsd")
  1486  	// HP-UX (Hewlett Packard Unix)
  1487  	OSTypeHPUX = OSTypeKey.String("hpux")
  1488  	// AIX (Advanced Interactive eXecutive)
  1489  	OSTypeAIX = OSTypeKey.String("aix")
  1490  	// SunOS, Oracle Solaris
  1491  	OSTypeSolaris = OSTypeKey.String("solaris")
  1492  	// IBM z/OS
  1493  	OSTypeZOS = OSTypeKey.String("z_os")
  1494  )
  1495  
  1496  // OSDescription returns an attribute KeyValue conforming to the
  1497  // "os.description" semantic conventions. It represents the human readable (not
  1498  // intended to be parsed) OS version information, like e.g. reported by `ver`
  1499  // or `lsb_release -a` commands.
  1500  func OSDescription(val string) attribute.KeyValue {
  1501  	return OSDescriptionKey.String(val)
  1502  }
  1503  
  1504  // OSName returns an attribute KeyValue conforming to the "os.name" semantic
  1505  // conventions. It represents the human readable operating system name.
  1506  func OSName(val string) attribute.KeyValue {
  1507  	return OSNameKey.String(val)
  1508  }
  1509  
  1510  // OSVersion returns an attribute KeyValue conforming to the "os.version"
  1511  // semantic conventions. It represents the version string of the operating
  1512  // system as defined in [Version
  1513  // Attributes](../../resource/semantic_conventions/README.md#version-attributes).
  1514  func OSVersion(val string) attribute.KeyValue {
  1515  	return OSVersionKey.String(val)
  1516  }
  1517  
  1518  // An operating system process.
  1519  const (
  1520  	// ProcessPIDKey is the attribute Key conforming to the "process.pid"
  1521  	// semantic conventions. It represents the process identifier (PID).
  1522  	//
  1523  	// Type: int
  1524  	// RequirementLevel: Optional
  1525  	// Stability: stable
  1526  	// Examples: 1234
  1527  	ProcessPIDKey = attribute.Key("process.pid")
  1528  
  1529  	// ProcessParentPIDKey is the attribute Key conforming to the
  1530  	// "process.parent_pid" semantic conventions. It represents the parent
  1531  	// Process identifier (PID).
  1532  	//
  1533  	// Type: int
  1534  	// RequirementLevel: Optional
  1535  	// Stability: stable
  1536  	// Examples: 111
  1537  	ProcessParentPIDKey = attribute.Key("process.parent_pid")
  1538  
  1539  	// ProcessExecutableNameKey is the attribute Key conforming to the
  1540  	// "process.executable.name" semantic conventions. It represents the name
  1541  	// of the process executable. On Linux based systems, can be set to the
  1542  	// `Name` in `proc/[pid]/status`. On Windows, can be set to the base name
  1543  	// of `GetProcessImageFileNameW`.
  1544  	//
  1545  	// Type: string
  1546  	// RequirementLevel: ConditionallyRequired (See alternative attributes
  1547  	// below.)
  1548  	// Stability: stable
  1549  	// Examples: 'otelcol'
  1550  	ProcessExecutableNameKey = attribute.Key("process.executable.name")
  1551  
  1552  	// ProcessExecutablePathKey is the attribute Key conforming to the
  1553  	// "process.executable.path" semantic conventions. It represents the full
  1554  	// path to the process executable. On Linux based systems, can be set to
  1555  	// the target of `proc/[pid]/exe`. On Windows, can be set to the result of
  1556  	// `GetProcessImageFileNameW`.
  1557  	//
  1558  	// Type: string
  1559  	// RequirementLevel: ConditionallyRequired (See alternative attributes
  1560  	// below.)
  1561  	// Stability: stable
  1562  	// Examples: '/usr/bin/cmd/otelcol'
  1563  	ProcessExecutablePathKey = attribute.Key("process.executable.path")
  1564  
  1565  	// ProcessCommandKey is the attribute Key conforming to the
  1566  	// "process.command" semantic conventions. It represents the command used
  1567  	// to launch the process (i.e. the command name). On Linux based systems,
  1568  	// can be set to the zeroth string in `proc/[pid]/cmdline`. On Windows, can
  1569  	// be set to the first parameter extracted from `GetCommandLineW`.
  1570  	//
  1571  	// Type: string
  1572  	// RequirementLevel: ConditionallyRequired (See alternative attributes
  1573  	// below.)
  1574  	// Stability: stable
  1575  	// Examples: 'cmd/otelcol'
  1576  	ProcessCommandKey = attribute.Key("process.command")
  1577  
  1578  	// ProcessCommandLineKey is the attribute Key conforming to the
  1579  	// "process.command_line" semantic conventions. It represents the full
  1580  	// command used to launch the process as a single string representing the
  1581  	// full command. On Windows, can be set to the result of `GetCommandLineW`.
  1582  	// Do not set this if you have to assemble it just for monitoring; use
  1583  	// `process.command_args` instead.
  1584  	//
  1585  	// Type: string
  1586  	// RequirementLevel: ConditionallyRequired (See alternative attributes
  1587  	// below.)
  1588  	// Stability: stable
  1589  	// Examples: 'C:\\cmd\\otecol --config="my directory\\config.yaml"'
  1590  	ProcessCommandLineKey = attribute.Key("process.command_line")
  1591  
  1592  	// ProcessCommandArgsKey is the attribute Key conforming to the
  1593  	// "process.command_args" semantic conventions. It represents the all the
  1594  	// command arguments (including the command/executable itself) as received
  1595  	// by the process. On Linux-based systems (and some other Unixoid systems
  1596  	// supporting procfs), can be set according to the list of null-delimited
  1597  	// strings extracted from `proc/[pid]/cmdline`. For libc-based executables,
  1598  	// this would be the full argv vector passed to `main`.
  1599  	//
  1600  	// Type: string[]
  1601  	// RequirementLevel: ConditionallyRequired (See alternative attributes
  1602  	// below.)
  1603  	// Stability: stable
  1604  	// Examples: 'cmd/otecol', '--config=config.yaml'
  1605  	ProcessCommandArgsKey = attribute.Key("process.command_args")
  1606  
  1607  	// ProcessOwnerKey is the attribute Key conforming to the "process.owner"
  1608  	// semantic conventions. It represents the username of the user that owns
  1609  	// the process.
  1610  	//
  1611  	// Type: string
  1612  	// RequirementLevel: Optional
  1613  	// Stability: stable
  1614  	// Examples: 'root'
  1615  	ProcessOwnerKey = attribute.Key("process.owner")
  1616  )
  1617  
  1618  // ProcessPID returns an attribute KeyValue conforming to the "process.pid"
  1619  // semantic conventions. It represents the process identifier (PID).
  1620  func ProcessPID(val int) attribute.KeyValue {
  1621  	return ProcessPIDKey.Int(val)
  1622  }
  1623  
  1624  // ProcessParentPID returns an attribute KeyValue conforming to the
  1625  // "process.parent_pid" semantic conventions. It represents the parent Process
  1626  // identifier (PID).
  1627  func ProcessParentPID(val int) attribute.KeyValue {
  1628  	return ProcessParentPIDKey.Int(val)
  1629  }
  1630  
  1631  // ProcessExecutableName returns an attribute KeyValue conforming to the
  1632  // "process.executable.name" semantic conventions. It represents the name of
  1633  // the process executable. On Linux based systems, can be set to the `Name` in
  1634  // `proc/[pid]/status`. On Windows, can be set to the base name of
  1635  // `GetProcessImageFileNameW`.
  1636  func ProcessExecutableName(val string) attribute.KeyValue {
  1637  	return ProcessExecutableNameKey.String(val)
  1638  }
  1639  
  1640  // ProcessExecutablePath returns an attribute KeyValue conforming to the
  1641  // "process.executable.path" semantic conventions. It represents the full path
  1642  // to the process executable. On Linux based systems, can be set to the target
  1643  // of `proc/[pid]/exe`. On Windows, can be set to the result of
  1644  // `GetProcessImageFileNameW`.
  1645  func ProcessExecutablePath(val string) attribute.KeyValue {
  1646  	return ProcessExecutablePathKey.String(val)
  1647  }
  1648  
  1649  // ProcessCommand returns an attribute KeyValue conforming to the
  1650  // "process.command" semantic conventions. It represents the command used to
  1651  // launch the process (i.e. the command name). On Linux based systems, can be
  1652  // set to the zeroth string in `proc/[pid]/cmdline`. On Windows, can be set to
  1653  // the first parameter extracted from `GetCommandLineW`.
  1654  func ProcessCommand(val string) attribute.KeyValue {
  1655  	return ProcessCommandKey.String(val)
  1656  }
  1657  
  1658  // ProcessCommandLine returns an attribute KeyValue conforming to the
  1659  // "process.command_line" semantic conventions. It represents the full command
  1660  // used to launch the process as a single string representing the full command.
  1661  // On Windows, can be set to the result of `GetCommandLineW`. Do not set this
  1662  // if you have to assemble it just for monitoring; use `process.command_args`
  1663  // instead.
  1664  func ProcessCommandLine(val string) attribute.KeyValue {
  1665  	return ProcessCommandLineKey.String(val)
  1666  }
  1667  
  1668  // ProcessCommandArgs returns an attribute KeyValue conforming to the
  1669  // "process.command_args" semantic conventions. It represents the all the
  1670  // command arguments (including the command/executable itself) as received by
  1671  // the process. On Linux-based systems (and some other Unixoid systems
  1672  // supporting procfs), can be set according to the list of null-delimited
  1673  // strings extracted from `proc/[pid]/cmdline`. For libc-based executables,
  1674  // this would be the full argv vector passed to `main`.
  1675  func ProcessCommandArgs(val ...string) attribute.KeyValue {
  1676  	return ProcessCommandArgsKey.StringSlice(val)
  1677  }
  1678  
  1679  // ProcessOwner returns an attribute KeyValue conforming to the
  1680  // "process.owner" semantic conventions. It represents the username of the user
  1681  // that owns the process.
  1682  func ProcessOwner(val string) attribute.KeyValue {
  1683  	return ProcessOwnerKey.String(val)
  1684  }
  1685  
  1686  // The single (language) runtime instance which is monitored.
  1687  const (
  1688  	// ProcessRuntimeNameKey is the attribute Key conforming to the
  1689  	// "process.runtime.name" semantic conventions. It represents the name of
  1690  	// the runtime of this process. For compiled native binaries, this SHOULD
  1691  	// be the name of the compiler.
  1692  	//
  1693  	// Type: string
  1694  	// RequirementLevel: Optional
  1695  	// Stability: stable
  1696  	// Examples: 'OpenJDK Runtime Environment'
  1697  	ProcessRuntimeNameKey = attribute.Key("process.runtime.name")
  1698  
  1699  	// ProcessRuntimeVersionKey is the attribute Key conforming to the
  1700  	// "process.runtime.version" semantic conventions. It represents the
  1701  	// version of the runtime of this process, as returned by the runtime
  1702  	// without modification.
  1703  	//
  1704  	// Type: string
  1705  	// RequirementLevel: Optional
  1706  	// Stability: stable
  1707  	// Examples: '14.0.2'
  1708  	ProcessRuntimeVersionKey = attribute.Key("process.runtime.version")
  1709  
  1710  	// ProcessRuntimeDescriptionKey is the attribute Key conforming to the
  1711  	// "process.runtime.description" semantic conventions. It represents an
  1712  	// additional description about the runtime of the process, for example a
  1713  	// specific vendor customization of the runtime environment.
  1714  	//
  1715  	// Type: string
  1716  	// RequirementLevel: Optional
  1717  	// Stability: stable
  1718  	// Examples: 'Eclipse OpenJ9 Eclipse OpenJ9 VM openj9-0.21.0'
  1719  	ProcessRuntimeDescriptionKey = attribute.Key("process.runtime.description")
  1720  )
  1721  
  1722  // ProcessRuntimeName returns an attribute KeyValue conforming to the
  1723  // "process.runtime.name" semantic conventions. It represents the name of the
  1724  // runtime of this process. For compiled native binaries, this SHOULD be the
  1725  // name of the compiler.
  1726  func ProcessRuntimeName(val string) attribute.KeyValue {
  1727  	return ProcessRuntimeNameKey.String(val)
  1728  }
  1729  
  1730  // ProcessRuntimeVersion returns an attribute KeyValue conforming to the
  1731  // "process.runtime.version" semantic conventions. It represents the version of
  1732  // the runtime of this process, as returned by the runtime without
  1733  // modification.
  1734  func ProcessRuntimeVersion(val string) attribute.KeyValue {
  1735  	return ProcessRuntimeVersionKey.String(val)
  1736  }
  1737  
  1738  // ProcessRuntimeDescription returns an attribute KeyValue conforming to the
  1739  // "process.runtime.description" semantic conventions. It represents an
  1740  // additional description about the runtime of the process, for example a
  1741  // specific vendor customization of the runtime environment.
  1742  func ProcessRuntimeDescription(val string) attribute.KeyValue {
  1743  	return ProcessRuntimeDescriptionKey.String(val)
  1744  }
  1745  
  1746  // A service instance.
  1747  const (
  1748  	// ServiceNameKey is the attribute Key conforming to the "service.name"
  1749  	// semantic conventions. It represents the logical name of the service.
  1750  	//
  1751  	// Type: string
  1752  	// RequirementLevel: Required
  1753  	// Stability: stable
  1754  	// Examples: 'shoppingcart'
  1755  	// Note: MUST be the same for all instances of horizontally scaled
  1756  	// services. If the value was not specified, SDKs MUST fallback to
  1757  	// `unknown_service:` concatenated with
  1758  	// [`process.executable.name`](process.md#process), e.g.
  1759  	// `unknown_service:bash`. If `process.executable.name` is not available,
  1760  	// the value MUST be set to `unknown_service`.
  1761  	ServiceNameKey = attribute.Key("service.name")
  1762  )
  1763  
  1764  // ServiceName returns an attribute KeyValue conforming to the
  1765  // "service.name" semantic conventions. It represents the logical name of the
  1766  // service.
  1767  func ServiceName(val string) attribute.KeyValue {
  1768  	return ServiceNameKey.String(val)
  1769  }
  1770  
  1771  // A service instance.
  1772  const (
  1773  	// ServiceNamespaceKey is the attribute Key conforming to the
  1774  	// "service.namespace" semantic conventions. It represents a namespace for
  1775  	// `service.name`.
  1776  	//
  1777  	// Type: string
  1778  	// RequirementLevel: Optional
  1779  	// Stability: stable
  1780  	// Examples: 'Shop'
  1781  	// Note: A string value having a meaning that helps to distinguish a group
  1782  	// of services, for example the team name that owns a group of services.
  1783  	// `service.name` is expected to be unique within the same namespace. If
  1784  	// `service.namespace` is not specified in the Resource then `service.name`
  1785  	// is expected to be unique for all services that have no explicit
  1786  	// namespace defined (so the empty/unspecified namespace is simply one more
  1787  	// valid namespace). Zero-length namespace string is assumed equal to
  1788  	// unspecified namespace.
  1789  	ServiceNamespaceKey = attribute.Key("service.namespace")
  1790  
  1791  	// ServiceInstanceIDKey is the attribute Key conforming to the
  1792  	// "service.instance.id" semantic conventions. It represents the string ID
  1793  	// of the service instance.
  1794  	//
  1795  	// Type: string
  1796  	// RequirementLevel: Optional
  1797  	// Stability: stable
  1798  	// Examples: 'my-k8s-pod-deployment-1',
  1799  	// '627cc493-f310-47de-96bd-71410b7dec09'
  1800  	// Note: MUST be unique for each instance of the same
  1801  	// `service.namespace,service.name` pair (in other words
  1802  	// `service.namespace,service.name,service.instance.id` triplet MUST be
  1803  	// globally unique). The ID helps to distinguish instances of the same
  1804  	// service that exist at the same time (e.g. instances of a horizontally
  1805  	// scaled service). It is preferable for the ID to be persistent and stay
  1806  	// the same for the lifetime of the service instance, however it is
  1807  	// acceptable that the ID is ephemeral and changes during important
  1808  	// lifetime events for the service (e.g. service restarts). If the service
  1809  	// has no inherent unique ID that can be used as the value of this
  1810  	// attribute it is recommended to generate a random Version 1 or Version 4
  1811  	// RFC 4122 UUID (services aiming for reproducible UUIDs may also use
  1812  	// Version 5, see RFC 4122 for more recommendations).
  1813  	ServiceInstanceIDKey = attribute.Key("service.instance.id")
  1814  
  1815  	// ServiceVersionKey is the attribute Key conforming to the
  1816  	// "service.version" semantic conventions. It represents the version string
  1817  	// of the service API or implementation.
  1818  	//
  1819  	// Type: string
  1820  	// RequirementLevel: Optional
  1821  	// Stability: stable
  1822  	// Examples: '2.0.0'
  1823  	ServiceVersionKey = attribute.Key("service.version")
  1824  )
  1825  
  1826  // ServiceNamespace returns an attribute KeyValue conforming to the
  1827  // "service.namespace" semantic conventions. It represents a namespace for
  1828  // `service.name`.
  1829  func ServiceNamespace(val string) attribute.KeyValue {
  1830  	return ServiceNamespaceKey.String(val)
  1831  }
  1832  
  1833  // ServiceInstanceID returns an attribute KeyValue conforming to the
  1834  // "service.instance.id" semantic conventions. It represents the string ID of
  1835  // the service instance.
  1836  func ServiceInstanceID(val string) attribute.KeyValue {
  1837  	return ServiceInstanceIDKey.String(val)
  1838  }
  1839  
  1840  // ServiceVersion returns an attribute KeyValue conforming to the
  1841  // "service.version" semantic conventions. It represents the version string of
  1842  // the service API or implementation.
  1843  func ServiceVersion(val string) attribute.KeyValue {
  1844  	return ServiceVersionKey.String(val)
  1845  }
  1846  
  1847  // The telemetry SDK used to capture data recorded by the instrumentation
  1848  // libraries.
  1849  const (
  1850  	// TelemetrySDKNameKey is the attribute Key conforming to the
  1851  	// "telemetry.sdk.name" semantic conventions. It represents the name of the
  1852  	// telemetry SDK as defined above.
  1853  	//
  1854  	// Type: string
  1855  	// RequirementLevel: Required
  1856  	// Stability: stable
  1857  	// Examples: 'opentelemetry'
  1858  	TelemetrySDKNameKey = attribute.Key("telemetry.sdk.name")
  1859  
  1860  	// TelemetrySDKLanguageKey is the attribute Key conforming to the
  1861  	// "telemetry.sdk.language" semantic conventions. It represents the
  1862  	// language of the telemetry SDK.
  1863  	//
  1864  	// Type: Enum
  1865  	// RequirementLevel: Required
  1866  	// Stability: stable
  1867  	TelemetrySDKLanguageKey = attribute.Key("telemetry.sdk.language")
  1868  
  1869  	// TelemetrySDKVersionKey is the attribute Key conforming to the
  1870  	// "telemetry.sdk.version" semantic conventions. It represents the version
  1871  	// string of the telemetry SDK.
  1872  	//
  1873  	// Type: string
  1874  	// RequirementLevel: Required
  1875  	// Stability: stable
  1876  	// Examples: '1.2.3'
  1877  	TelemetrySDKVersionKey = attribute.Key("telemetry.sdk.version")
  1878  )
  1879  
  1880  var (
  1881  	// cpp
  1882  	TelemetrySDKLanguageCPP = TelemetrySDKLanguageKey.String("cpp")
  1883  	// dotnet
  1884  	TelemetrySDKLanguageDotnet = TelemetrySDKLanguageKey.String("dotnet")
  1885  	// erlang
  1886  	TelemetrySDKLanguageErlang = TelemetrySDKLanguageKey.String("erlang")
  1887  	// go
  1888  	TelemetrySDKLanguageGo = TelemetrySDKLanguageKey.String("go")
  1889  	// java
  1890  	TelemetrySDKLanguageJava = TelemetrySDKLanguageKey.String("java")
  1891  	// nodejs
  1892  	TelemetrySDKLanguageNodejs = TelemetrySDKLanguageKey.String("nodejs")
  1893  	// php
  1894  	TelemetrySDKLanguagePHP = TelemetrySDKLanguageKey.String("php")
  1895  	// python
  1896  	TelemetrySDKLanguagePython = TelemetrySDKLanguageKey.String("python")
  1897  	// ruby
  1898  	TelemetrySDKLanguageRuby = TelemetrySDKLanguageKey.String("ruby")
  1899  	// webjs
  1900  	TelemetrySDKLanguageWebjs = TelemetrySDKLanguageKey.String("webjs")
  1901  	// swift
  1902  	TelemetrySDKLanguageSwift = TelemetrySDKLanguageKey.String("swift")
  1903  )
  1904  
  1905  // TelemetrySDKName returns an attribute KeyValue conforming to the
  1906  // "telemetry.sdk.name" semantic conventions. It represents the name of the
  1907  // telemetry SDK as defined above.
  1908  func TelemetrySDKName(val string) attribute.KeyValue {
  1909  	return TelemetrySDKNameKey.String(val)
  1910  }
  1911  
  1912  // TelemetrySDKVersion returns an attribute KeyValue conforming to the
  1913  // "telemetry.sdk.version" semantic conventions. It represents the version
  1914  // string of the telemetry SDK.
  1915  func TelemetrySDKVersion(val string) attribute.KeyValue {
  1916  	return TelemetrySDKVersionKey.String(val)
  1917  }
  1918  
  1919  // The telemetry SDK used to capture data recorded by the instrumentation
  1920  // libraries.
  1921  const (
  1922  	// TelemetryAutoVersionKey is the attribute Key conforming to the
  1923  	// "telemetry.auto.version" semantic conventions. It represents the version
  1924  	// string of the auto instrumentation agent, if used.
  1925  	//
  1926  	// Type: string
  1927  	// RequirementLevel: Optional
  1928  	// Stability: stable
  1929  	// Examples: '1.2.3'
  1930  	TelemetryAutoVersionKey = attribute.Key("telemetry.auto.version")
  1931  )
  1932  
  1933  // TelemetryAutoVersion returns an attribute KeyValue conforming to the
  1934  // "telemetry.auto.version" semantic conventions. It represents the version
  1935  // string of the auto instrumentation agent, if used.
  1936  func TelemetryAutoVersion(val string) attribute.KeyValue {
  1937  	return TelemetryAutoVersionKey.String(val)
  1938  }
  1939  
  1940  // Resource describing the packaged software running the application code. Web
  1941  // engines are typically executed using process.runtime.
  1942  const (
  1943  	// WebEngineNameKey is the attribute Key conforming to the "webengine.name"
  1944  	// semantic conventions. It represents the name of the web engine.
  1945  	//
  1946  	// Type: string
  1947  	// RequirementLevel: Required
  1948  	// Stability: stable
  1949  	// Examples: 'WildFly'
  1950  	WebEngineNameKey = attribute.Key("webengine.name")
  1951  
  1952  	// WebEngineVersionKey is the attribute Key conforming to the
  1953  	// "webengine.version" semantic conventions. It represents the version of
  1954  	// the web engine.
  1955  	//
  1956  	// Type: string
  1957  	// RequirementLevel: Optional
  1958  	// Stability: stable
  1959  	// Examples: '21.0.0'
  1960  	WebEngineVersionKey = attribute.Key("webengine.version")
  1961  
  1962  	// WebEngineDescriptionKey is the attribute Key conforming to the
  1963  	// "webengine.description" semantic conventions. It represents the
  1964  	// additional description of the web engine (e.g. detailed version and
  1965  	// edition information).
  1966  	//
  1967  	// Type: string
  1968  	// RequirementLevel: Optional
  1969  	// Stability: stable
  1970  	// Examples: 'WildFly Full 21.0.0.Final (WildFly Core 13.0.1.Final) -
  1971  	// 2.2.2.Final'
  1972  	WebEngineDescriptionKey = attribute.Key("webengine.description")
  1973  )
  1974  
  1975  // WebEngineName returns an attribute KeyValue conforming to the
  1976  // "webengine.name" semantic conventions. It represents the name of the web
  1977  // engine.
  1978  func WebEngineName(val string) attribute.KeyValue {
  1979  	return WebEngineNameKey.String(val)
  1980  }
  1981  
  1982  // WebEngineVersion returns an attribute KeyValue conforming to the
  1983  // "webengine.version" semantic conventions. It represents the version of the
  1984  // web engine.
  1985  func WebEngineVersion(val string) attribute.KeyValue {
  1986  	return WebEngineVersionKey.String(val)
  1987  }
  1988  
  1989  // WebEngineDescription returns an attribute KeyValue conforming to the
  1990  // "webengine.description" semantic conventions. It represents the additional
  1991  // description of the web engine (e.g. detailed version and edition
  1992  // information).
  1993  func WebEngineDescription(val string) attribute.KeyValue {
  1994  	return WebEngineDescriptionKey.String(val)
  1995  }
  1996  
  1997  // Attributes used by non-OTLP exporters to represent OpenTelemetry Scope's
  1998  // concepts.
  1999  const (
  2000  	// OTelScopeNameKey is the attribute Key conforming to the
  2001  	// "otel.scope.name" semantic conventions. It represents the name of the
  2002  	// instrumentation scope - (`InstrumentationScope.Name` in OTLP).
  2003  	//
  2004  	// Type: string
  2005  	// RequirementLevel: Optional
  2006  	// Stability: stable
  2007  	// Examples: 'io.opentelemetry.contrib.mongodb'
  2008  	OTelScopeNameKey = attribute.Key("otel.scope.name")
  2009  
  2010  	// OTelScopeVersionKey is the attribute Key conforming to the
  2011  	// "otel.scope.version" semantic conventions. It represents the version of
  2012  	// the instrumentation scope - (`InstrumentationScope.Version` in OTLP).
  2013  	//
  2014  	// Type: string
  2015  	// RequirementLevel: Optional
  2016  	// Stability: stable
  2017  	// Examples: '1.0.0'
  2018  	OTelScopeVersionKey = attribute.Key("otel.scope.version")
  2019  )
  2020  
  2021  // OTelScopeName returns an attribute KeyValue conforming to the
  2022  // "otel.scope.name" semantic conventions. It represents the name of the
  2023  // instrumentation scope - (`InstrumentationScope.Name` in OTLP).
  2024  func OTelScopeName(val string) attribute.KeyValue {
  2025  	return OTelScopeNameKey.String(val)
  2026  }
  2027  
  2028  // OTelScopeVersion returns an attribute KeyValue conforming to the
  2029  // "otel.scope.version" semantic conventions. It represents the version of the
  2030  // instrumentation scope - (`InstrumentationScope.Version` in OTLP).
  2031  func OTelScopeVersion(val string) attribute.KeyValue {
  2032  	return OTelScopeVersionKey.String(val)
  2033  }
  2034  
  2035  // Span attributes used by non-OTLP exporters to represent OpenTelemetry
  2036  // Scope's concepts.
  2037  const (
  2038  	// OTelLibraryNameKey is the attribute Key conforming to the
  2039  	// "otel.library.name" semantic conventions. It represents the deprecated,
  2040  	// use the `otel.scope.name` attribute.
  2041  	//
  2042  	// Type: string
  2043  	// RequirementLevel: Optional
  2044  	// Stability: deprecated
  2045  	// Examples: 'io.opentelemetry.contrib.mongodb'
  2046  	OTelLibraryNameKey = attribute.Key("otel.library.name")
  2047  
  2048  	// OTelLibraryVersionKey is the attribute Key conforming to the
  2049  	// "otel.library.version" semantic conventions. It represents the
  2050  	// deprecated, use the `otel.scope.version` attribute.
  2051  	//
  2052  	// Type: string
  2053  	// RequirementLevel: Optional
  2054  	// Stability: deprecated
  2055  	// Examples: '1.0.0'
  2056  	OTelLibraryVersionKey = attribute.Key("otel.library.version")
  2057  )
  2058  
  2059  // OTelLibraryName returns an attribute KeyValue conforming to the
  2060  // "otel.library.name" semantic conventions. It represents the deprecated, use
  2061  // the `otel.scope.name` attribute.
  2062  func OTelLibraryName(val string) attribute.KeyValue {
  2063  	return OTelLibraryNameKey.String(val)
  2064  }
  2065  
  2066  // OTelLibraryVersion returns an attribute KeyValue conforming to the
  2067  // "otel.library.version" semantic conventions. It represents the deprecated,
  2068  // use the `otel.scope.version` attribute.
  2069  func OTelLibraryVersion(val string) attribute.KeyValue {
  2070  	return OTelLibraryVersionKey.String(val)
  2071  }
  2072  

View as plain text