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