1 // Copyright The OpenTelemetry Authors
2 // SPDX-License-Identifier: Apache-2.0
3 4 // Code generated from semantic convention specification. DO NOT EDIT.
5 6 package semconv // import "go.opentelemetry.io/otel/semconv/v1.20.0"
7 8 import "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).
14 const (
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
79 func 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
86 func 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
93 func 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
100 func BrowserLanguage(val string) attribute.KeyValue {
101 return BrowserLanguageKey.String(val)
102 }
103 104 // A cloud environment (e.g. GCP, Azure, AWS)
105 const (
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 215 var (
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 232 var (
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.
290 func 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.
297 func 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)
310 func 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.
319 func CloudAvailabilityZone(val string) attribute.KeyValue {
320 return CloudAvailabilityZoneKey.String(val)
321 }
322 323 // Resources used by AWS Elastic Container Service (ECS).
324 const (
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 391 var (
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).
402 func 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).
409 func 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).
417 func 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.
424 func 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.
431 func AWSECSTaskRevision(val string) attribute.KeyValue {
432 return AWSECSTaskRevisionKey.String(val)
433 }
434 435 // Resources used by AWS Elastic Kubernetes Service (EKS).
436 const (
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.
451 func AWSEKSClusterARN(val string) attribute.KeyValue {
452 return AWSEKSClusterARNKey.String(val)
453 }
454 455 // Resources specific to Amazon Web Services.
456 const (
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.
512 func 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).
519 func 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.
526 func 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).
533 func AWSLogStreamARNs(val ...string) attribute.KeyValue {
534 return AWSLogStreamARNsKey.StringSlice(val)
535 }
536 537 // Heroku dyno metadata
538 const (
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
573 func 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
580 func 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
587 func HerokuAppID(val string) attribute.KeyValue {
588 return HerokuAppIDKey.String(val)
589 }
590 591 // A container instance.
592 const (
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.
649 func 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.
658 func 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.
665 func 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.
672 func 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.
679 func ContainerImageTag(val string) attribute.KeyValue {
680 return ContainerImageTagKey.String(val)
681 }
682 683 // The software deployment.
684 const (
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).
703 func 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.
708 const (
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
773 func 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
780 func 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
787 func 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
794 func DeviceManufacturer(val string) attribute.KeyValue {
795 return DeviceManufacturerKey.String(val)
796 }
797 798 // A serverless instance.
799 const (
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.
882 func 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.
889 func 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.
897 func 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.
904 func FaaSMaxMemory(val int) attribute.KeyValue {
905 return FaaSMaxMemoryKey.Int(val)
906 }
907 908 // A host is defined as a general computing instance.
909 const (
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 984 var (
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.
1008 func 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.
1016 func 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.
1023 func 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.
1030 func 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.
1037 func 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).
1045 func HostImageVersion(val string) attribute.KeyValue {
1046 return HostImageVersionKey.String(val)
1047 }
1048 1049 // A Kubernetes Cluster.
1050 const (
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.
1065 func K8SClusterName(val string) attribute.KeyValue {
1066 return K8SClusterNameKey.String(val)
1067 }
1068 1069 // A Kubernetes Node object.
1070 const (
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.
1092 func 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.
1098 func K8SNodeUID(val string) attribute.KeyValue {
1099 return K8SNodeUIDKey.String(val)
1100 }
1101 1102 // A Kubernetes Namespace.
1103 const (
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.
1118 func K8SNamespaceName(val string) attribute.KeyValue {
1119 return K8SNamespaceNameKey.String(val)
1120 }
1121 1122 // A Kubernetes Pod object.
1123 const (
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.
1145 func 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.
1151 func 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).
1157 const (
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`).
1186 func 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.
1194 func K8SContainerRestartCount(val int) attribute.KeyValue {
1195 return K8SContainerRestartCountKey.Int(val)
1196 }
1197 1198 // A Kubernetes ReplicaSet object.
1199 const (
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.
1224 func 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.
1231 func K8SReplicaSetName(val string) attribute.KeyValue {
1232 return K8SReplicaSetNameKey.String(val)
1233 }
1234 1235 // A Kubernetes Deployment object.
1236 const (
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.
1261 func 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.
1268 func K8SDeploymentName(val string) attribute.KeyValue {
1269 return K8SDeploymentNameKey.String(val)
1270 }
1271 1272 // A Kubernetes StatefulSet object.
1273 const (
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.
1298 func 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.
1305 func K8SStatefulSetName(val string) attribute.KeyValue {
1306 return K8SStatefulSetNameKey.String(val)
1307 }
1308 1309 // A Kubernetes DaemonSet object.
1310 const (
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.
1335 func 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.
1342 func K8SDaemonSetName(val string) attribute.KeyValue {
1343 return K8SDaemonSetNameKey.String(val)
1344 }
1345 1346 // A Kubernetes Job object.
1347 const (
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.
1369 func 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.
1375 func K8SJobName(val string) attribute.KeyValue {
1376 return K8SJobNameKey.String(val)
1377 }
1378 1379 // A Kubernetes CronJob object.
1380 const (
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.
1405 func 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.
1412 func 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.
1418 const (
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 1460 var (
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.
1489 func 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.
1495 func 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).
1503 func OSVersion(val string) attribute.KeyValue {
1504 return OSVersionKey.String(val)
1505 }
1506 1507 // An operating system process.
1508 const (
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).
1609 func 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).
1616 func 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`.
1625 func 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`.
1634 func 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`.
1643 func 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.
1653 func 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`.
1664 func 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.
1671 func ProcessOwner(val string) attribute.KeyValue {
1672 return ProcessOwnerKey.String(val)
1673 }
1674 1675 // The single (language) runtime instance which is monitored.
1676 const (
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.
1715 func 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.
1723 func 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.
1731 func ProcessRuntimeDescription(val string) attribute.KeyValue {
1732 return ProcessRuntimeDescriptionKey.String(val)
1733 }
1734 1735 // A service instance.
1736 const (
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.
1756 func ServiceName(val string) attribute.KeyValue {
1757 return ServiceNameKey.String(val)
1758 }
1759 1760 // A service instance.
1761 const (
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`.
1818 func 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.
1825 func 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.
1832 func 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.
1838 const (
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 1869 var (
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.
1897 func 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.
1904 func 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.
1910 const (
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.
1925 func 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.
1931 const (
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.
1967 func 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.
1974 func 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).
1982 func 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.
1988 const (
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).
2013 func 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).
2020 func 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.
2026 const (
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.
2051 func 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.
2058 func OTelLibraryVersion(val string) attribute.KeyValue {
2059 return OTelLibraryVersionKey.String(val)
2060 }
2061