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