Debian Codegraph @

semconv/v1.6.1/resource.go

raw
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.6.1"
7
8 import "go.opentelemetry.io/otel/attribute"
9
10 // A cloud environment (e.g. GCP, Azure, AWS)
11 const (
12 // Name of the cloud provider.
13 //
14 // Type: Enum
15 // Required: No
16 // Stability: stable
17 CloudProviderKey = attribute.Key("cloud.provider")
18 // The cloud account ID the resource is assigned to.
19 //
20 // Type: string
21 // Required: No
22 // Stability: stable
23 // Examples: '111111111111', 'opentelemetry'
24 CloudAccountIDKey = attribute.Key("cloud.account.id")
25 // The geographical region the resource is running. Refer to your provider's docs
26 // to see the available regions, for example [Alibaba Cloud
27 // regions](https://www.alibabacloud.com/help/doc-detail/40654.htm), [AWS
28 // regions](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/),
29 // [Azure regions](https://azure.microsoft.com/en-us/global-
30 // infrastructure/geographies/), or [Google Cloud
31 // regions](https://cloud.google.com/about/locations).
32 //
33 // Type: string
34 // Required: No
35 // Stability: stable
36 // Examples: 'us-central1', 'us-east-1'
37 CloudRegionKey = attribute.Key("cloud.region")
38 // Cloud regions often have multiple, isolated locations known as zones to
39 // increase availability. Availability zone represents the zone where the resource
40 // is running.
41 //
42 // Type: string
43 // Required: No
44 // Stability: stable
45 // Examples: 'us-east-1c'
46 // Note: Availability zones are called "zones" on Alibaba Cloud and Google Cloud.
47 CloudAvailabilityZoneKey = attribute.Key("cloud.availability_zone")
48 // The cloud platform in use.
49 //
50 // Type: Enum
51 // Required: No
52 // Stability: stable
53 // Note: The prefix of the service SHOULD match the one specified in
54 // `cloud.provider`.
55 CloudPlatformKey = attribute.Key("cloud.platform")
56 )
57
58 var (
59 // Alibaba Cloud
60 CloudProviderAlibabaCloud = CloudProviderKey.String("alibaba_cloud")
61 // Amazon Web Services
62 CloudProviderAWS = CloudProviderKey.String("aws")
63 // Microsoft Azure
64 CloudProviderAzure = CloudProviderKey.String("azure")
65 // Google Cloud Platform
66 CloudProviderGCP = CloudProviderKey.String("gcp")
67 )
68
69 var (
70 // Alibaba Cloud Elastic Compute Service
71 CloudPlatformAlibabaCloudECS = CloudPlatformKey.String("alibaba_cloud_ecs")
72 // Alibaba Cloud Function Compute
73 CloudPlatformAlibabaCloudFc = CloudPlatformKey.String("alibaba_cloud_fc")
74 // AWS Elastic Compute Cloud
75 CloudPlatformAWSEC2 = CloudPlatformKey.String("aws_ec2")
76 // AWS Elastic Container Service
77 CloudPlatformAWSECS = CloudPlatformKey.String("aws_ecs")
78 // AWS Elastic Kubernetes Service
79 CloudPlatformAWSEKS = CloudPlatformKey.String("aws_eks")
80 // AWS Lambda
81 CloudPlatformAWSLambda = CloudPlatformKey.String("aws_lambda")
82 // AWS Elastic Beanstalk
83 CloudPlatformAWSElasticBeanstalk = CloudPlatformKey.String("aws_elastic_beanstalk")
84 // Azure Virtual Machines
85 CloudPlatformAzureVM = CloudPlatformKey.String("azure_vm")
86 // Azure Container Instances
87 CloudPlatformAzureContainerInstances = CloudPlatformKey.String("azure_container_instances")
88 // Azure Kubernetes Service
89 CloudPlatformAzureAKS = CloudPlatformKey.String("azure_aks")
90 // Azure Functions
91 CloudPlatformAzureFunctions = CloudPlatformKey.String("azure_functions")
92 // Azure App Service
93 CloudPlatformAzureAppService = CloudPlatformKey.String("azure_app_service")
94 // Google Cloud Compute Engine (GCE)
95 CloudPlatformGCPComputeEngine = CloudPlatformKey.String("gcp_compute_engine")
96 // Google Cloud Run
97 CloudPlatformGCPCloudRun = CloudPlatformKey.String("gcp_cloud_run")
98 // Google Cloud Kubernetes Engine (GKE)
99 CloudPlatformGCPKubernetesEngine = CloudPlatformKey.String("gcp_kubernetes_engine")
100 // Google Cloud Functions (GCF)
101 CloudPlatformGCPCloudFunctions = CloudPlatformKey.String("gcp_cloud_functions")
102 // Google Cloud App Engine (GAE)
103 CloudPlatformGCPAppEngine = CloudPlatformKey.String("gcp_app_engine")
104 )
105
106 // Resources used by AWS Elastic Container Service (ECS).
107 const (
108 // The Amazon Resource Name (ARN) of an [ECS container instance](https://docs.aws.
109 // amazon.com/AmazonECS/latest/developerguide/ECS_instances.html).
110 //
111 // Type: string
112 // Required: No
113 // Stability: stable
114 // Examples: 'arn:aws:ecs:us-
115 // west-1:123456789123:container/32624152-9086-4f0e-acae-1a75b14fe4d9'
116 AWSECSContainerARNKey = attribute.Key("aws.ecs.container.arn")
117 // The ARN of an [ECS cluster](https://docs.aws.amazon.com/AmazonECS/latest/develo
118 // perguide/clusters.html).
119 //
120 // Type: string
121 // Required: No
122 // Stability: stable
123 // Examples: 'arn:aws:ecs:us-west-2:123456789123:cluster/my-cluster'
124 AWSECSClusterARNKey = attribute.Key("aws.ecs.cluster.arn")
125 // The [launch type](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/l
126 // aunch_types.html) for an ECS task.
127 //
128 // Type: Enum
129 // Required: No
130 // Stability: stable
131 AWSECSLaunchtypeKey = attribute.Key("aws.ecs.launchtype")
132 // The ARN of an [ECS task definition](https://docs.aws.amazon.com/AmazonECS/lates
133 // t/developerguide/task_definitions.html).
134 //
135 // Type: string
136 // Required: No
137 // Stability: stable
138 // Examples: 'arn:aws:ecs:us-
139 // west-1:123456789123:task/10838bed-421f-43ef-870a-f43feacbbb5b'
140 AWSECSTaskARNKey = attribute.Key("aws.ecs.task.arn")
141 // The task definition family this task definition is a member of.
142 //
143 // Type: string
144 // Required: No
145 // Stability: stable
146 // Examples: 'opentelemetry-family'
147 AWSECSTaskFamilyKey = attribute.Key("aws.ecs.task.family")
148 // The revision for this task definition.
149 //
150 // Type: string
151 // Required: No
152 // Stability: stable
153 // Examples: '8', '26'
154 AWSECSTaskRevisionKey = attribute.Key("aws.ecs.task.revision")
155 )
156
157 var (
158 // ec2
159 AWSECSLaunchtypeEC2 = AWSECSLaunchtypeKey.String("ec2")
160 // fargate
161 AWSECSLaunchtypeFargate = AWSECSLaunchtypeKey.String("fargate")
162 )
163
164 // Resources used by AWS Elastic Kubernetes Service (EKS).
165 const (
166 // The ARN of an EKS cluster.
167 //
168 // Type: string
169 // Required: No
170 // Stability: stable
171 // Examples: 'arn:aws:ecs:us-west-2:123456789123:cluster/my-cluster'
172 AWSEKSClusterARNKey = attribute.Key("aws.eks.cluster.arn")
173 )
174
175 // Resources specific to Amazon Web Services.
176 const (
177 // The name(s) of the AWS log group(s) an application is writing to.
178 //
179 // Type: string[]
180 // Required: No
181 // Stability: stable
182 // Examples: '/aws/lambda/my-function', 'opentelemetry-service'
183 // Note: Multiple log groups must be supported for cases like multi-container
184 // applications, where a single application has sidecar containers, and each write
185 // to their own log group.
186 AWSLogGroupNamesKey = attribute.Key("aws.log.group.names")
187 // The Amazon Resource Name(s) (ARN) of the AWS log group(s).
188 //
189 // Type: string[]
190 // Required: No
191 // Stability: stable
192 // Examples: 'arn:aws:logs:us-west-1:123456789012:log-group:/aws/my/group:*'
193 // Note: See the [log group ARN format
194 // documentation](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/iam-
195 // access-control-overview-cwl.html#CWL_ARN_Format).
196 AWSLogGroupARNsKey = attribute.Key("aws.log.group.arns")
197 // The name(s) of the AWS log stream(s) an application is writing to.
198 //
199 // Type: string[]
200 // Required: No
201 // Stability: stable
202 // Examples: 'logs/main/10838bed-421f-43ef-870a-f43feacbbb5b'
203 AWSLogStreamNamesKey = attribute.Key("aws.log.stream.names")
204 // The ARN(s) of the AWS log stream(s).
205 //
206 // Type: string[]
207 // Required: No
208 // Stability: stable
209 // Examples: 'arn:aws:logs:us-west-1:123456789012:log-group:/aws/my/group:log-
210 // stream:logs/main/10838bed-421f-43ef-870a-f43feacbbb5b'
211 // Note: See the [log stream ARN format
212 // documentation](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/iam-
213 // access-control-overview-cwl.html#CWL_ARN_Format). One log group can contain
214 // several log streams, so these ARNs necessarily identify both a log group and a
215 // log stream.
216 AWSLogStreamARNsKey = attribute.Key("aws.log.stream.arns")
217 )
218
219 // A container instance.
220 const (
221 // Container name.
222 //
223 // Type: string
224 // Required: No
225 // Stability: stable
226 // Examples: 'opentelemetry-autoconf'
227 ContainerNameKey = attribute.Key("container.name")
228 // Container ID. Usually a UUID, as for example used to [identify Docker
229 // containers](https://docs.docker.com/engine/reference/run/#container-
230 // identification). The UUID might be abbreviated.
231 //
232 // Type: string
233 // Required: No
234 // Stability: stable
235 // Examples: 'a3bf90e006b2'
236 ContainerIDKey = attribute.Key("container.id")
237 // The container runtime managing this container.
238 //
239 // Type: string
240 // Required: No
241 // Stability: stable
242 // Examples: 'docker', 'containerd', 'rkt'
243 ContainerRuntimeKey = attribute.Key("container.runtime")
244 // Name of the image the container was built on.
245 //
246 // Type: string
247 // Required: No
248 // Stability: stable
249 // Examples: 'gcr.io/opentelemetry/operator'
250 ContainerImageNameKey = attribute.Key("container.image.name")
251 // Container image tag.
252 //
253 // Type: string
254 // Required: No
255 // Stability: stable
256 // Examples: '0.1'
257 ContainerImageTagKey = attribute.Key("container.image.tag")
258 )
259
260 // The software deployment.
261 const (
262 // Name of the [deployment
263 // environment](https://en.wikipedia.org/wiki/Deployment_environment) (aka
264 // deployment tier).
265 //
266 // Type: string
267 // Required: No
268 // Stability: stable
269 // Examples: 'staging', 'production'
270 DeploymentEnvironmentKey = attribute.Key("deployment.environment")
271 )
272
273 // The device on which the process represented by this resource is running.
274 const (
275 // A unique identifier representing the device
276 //
277 // Type: string
278 // Required: No
279 // Stability: stable
280 // Examples: '2ab2916d-a51f-4ac8-80ee-45ac31a28092'
281 // Note: The device identifier MUST only be defined using the values outlined
282 // below. This value is not an advertising identifier and MUST NOT be used as
283 // such. On iOS (Swift or Objective-C), this value MUST be equal to the [vendor id
284 // entifier](https://developer.apple.com/documentation/uikit/uidevice/1620059-iden
285 // tifierforvendor). On Android (Java or Kotlin), this value MUST be equal to the
286 // Firebase Installation ID or a globally unique UUID which is persisted across
287 // sessions in your application. More information can be found
288 // [here](https://developer.android.com/training/articles/user-data-ids) on best
289 // practices and exact implementation details. Caution should be taken when
290 // storing personal data or anything which can identify a user. GDPR and data
291 // protection laws may apply, ensure you do your own due diligence.
292 DeviceIDKey = attribute.Key("device.id")
293 // The model identifier for the device
294 //
295 // Type: string
296 // Required: No
297 // Stability: stable
298 // Examples: 'iPhone3,4', 'SM-G920F'
299 // Note: It's recommended this value represents a machine readable version of the
300 // model identifier rather than the market or consumer-friendly name of the
301 // device.
302 DeviceModelIdentifierKey = attribute.Key("device.model.identifier")
303 // The marketing name for the device model
304 //
305 // Type: string
306 // Required: No
307 // Stability: stable
308 // Examples: 'iPhone 6s Plus', 'Samsung Galaxy S6'
309 // Note: It's recommended this value represents a human readable version of the
310 // device model rather than a machine readable alternative.
311 DeviceModelNameKey = attribute.Key("device.model.name")
312 )
313
314 // A serverless instance.
315 const (
316 // The name of the single function that this runtime instance executes.
317 //
318 // Type: string
319 // Required: Always
320 // Stability: stable
321 // Examples: 'my-function'
322 // Note: This is the name of the function as configured/deployed on the FaaS
323 // platform and is usually different from the name of the callback function (which
324 // may be stored in the
325 // [`code.namespace`/`code.function`](../../trace/semantic_conventions/span-
326 // general.md#source-code-attributes) span attributes).
327 FaaSNameKey = attribute.Key("faas.name")
328 // The unique ID of the single function that this runtime instance executes.
329 //
330 // Type: string
331 // Required: No
332 // Stability: stable
333 // Examples: 'arn:aws:lambda:us-west-2:123456789012:function:my-function'
334 // Note: Depending on the cloud provider, use:
335
336 // * **AWS Lambda:** The function
337 // [ARN](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-
338 // namespaces.html).
339 // Take care not to use the "invoked ARN" directly but replace any
340 // [alias suffix](https://docs.aws.amazon.com/lambda/latest/dg/configuration-
341 // aliases.html) with the resolved function version, as the same runtime instance
342 // may be invokable with multiple
343 // different aliases.
344 // * **GCP:** The [URI of the resource](https://cloud.google.com/iam/docs/full-
345 // resource-names)
346 // * **Azure:** The [Fully Qualified Resource ID](https://docs.microsoft.com/en-
347 // us/rest/api/resources/resources/get-by-id).
348
349 // On some providers, it may not be possible to determine the full ID at startup,
350 // which is why this field cannot be made required. For example, on AWS the
351 // account ID
352 // part of the ARN is not available without calling another AWS API
353 // which may be deemed too slow for a short-running lambda function.
354 // As an alternative, consider setting `faas.id` as a span attribute instead.
355 FaaSIDKey = attribute.Key("faas.id")
356 // The immutable version of the function being executed.
357 //
358 // Type: string
359 // Required: No
360 // Stability: stable
361 // Examples: '26', 'pinkfroid-00002'
362 // Note: Depending on the cloud provider and platform, use:
363
364 // * **AWS Lambda:** The [function
365 // version](https://docs.aws.amazon.com/lambda/latest/dg/configuration-
366 // versions.html)
367 // (an integer represented as a decimal string).
368 // * **Google Cloud Run:** The
369 // [revision](https://cloud.google.com/run/docs/managing/revisions)
370 // (i.e., the function name plus the revision suffix).
371 // * **Google Cloud Functions:** The value of the
372 // [`K_REVISION` environment
373 // variable](https://cloud.google.com/functions/docs/env-
374 // var#runtime_environment_variables_set_automatically).
375 // * **Azure Functions:** Not applicable. Do not set this attribute.
376 FaaSVersionKey = attribute.Key("faas.version")
377 // The execution environment ID as a string, that will be potentially reused for
378 // other invocations to the same function/function version.
379 //
380 // Type: string
381 // Required: No
382 // Stability: stable
383 // Examples: '2021/06/28/[$LATEST]2f399eb14537447da05ab2a2e39309de'
384 // Note: * **AWS Lambda:** Use the (full) log stream name.
385 FaaSInstanceKey = attribute.Key("faas.instance")
386 // The amount of memory available to the serverless function in MiB.
387 //
388 // Type: int
389 // Required: No
390 // Stability: stable
391 // Examples: 128
392 // Note: It's recommended to set this attribute since e.g. too little memory can
393 // easily stop a Java AWS Lambda function from working correctly. On AWS Lambda,
394 // the environment variable `AWS_LAMBDA_FUNCTION_MEMORY_SIZE` provides this
395 // information.
396 FaaSMaxMemoryKey = attribute.Key("faas.max_memory")
397 )
398
399 // A host is defined as a general computing instance.
400 const (
401 // Unique host ID. For Cloud, this must be the instance_id assigned by the cloud
402 // provider.
403 //
404 // Type: string
405 // Required: No
406 // Stability: stable
407 // Examples: 'opentelemetry-test'
408 HostIDKey = attribute.Key("host.id")
409 // Name of the host. On Unix systems, it may contain what the hostname command
410 // returns, or the fully qualified hostname, or another name specified by the
411 // user.
412 //
413 // Type: string
414 // Required: No
415 // Stability: stable
416 // Examples: 'opentelemetry-test'
417 HostNameKey = attribute.Key("host.name")
418 // Type of host. For Cloud, this must be the machine type.
419 //
420 // Type: string
421 // Required: No
422 // Stability: stable
423 // Examples: 'n1-standard-1'
424 HostTypeKey = attribute.Key("host.type")
425 // The CPU architecture the host system is running on.
426 //
427 // Type: Enum
428 // Required: No
429 // Stability: stable
430 HostArchKey = attribute.Key("host.arch")
431 // Name of the VM image or OS install the host was instantiated from.
432 //
433 // Type: string
434 // Required: No
435 // Stability: stable
436 // Examples: 'infra-ami-eks-worker-node-7d4ec78312', 'CentOS-8-x86_64-1905'
437 HostImageNameKey = attribute.Key("host.image.name")
438 // VM image ID. For Cloud, this value is from the provider.
439 //
440 // Type: string
441 // Required: No
442 // Stability: stable
443 // Examples: 'ami-07b06b442921831e5'
444 HostImageIDKey = attribute.Key("host.image.id")
445 // The version string of the VM image as defined in [Version
446 // Attributes](README.md#version-attributes).
447 //
448 // Type: string
449 // Required: No
450 // Stability: stable
451 // Examples: '0.1'
452 HostImageVersionKey = attribute.Key("host.image.version")
453 )
454
455 var (
456 // AMD64
457 HostArchAMD64 = HostArchKey.String("amd64")
458 // ARM32
459 HostArchARM32 = HostArchKey.String("arm32")
460 // ARM64
461 HostArchARM64 = HostArchKey.String("arm64")
462 // Itanium
463 HostArchIA64 = HostArchKey.String("ia64")
464 // 32-bit PowerPC
465 HostArchPPC32 = HostArchKey.String("ppc32")
466 // 64-bit PowerPC
467 HostArchPPC64 = HostArchKey.String("ppc64")
468 // 32-bit x86
469 HostArchX86 = HostArchKey.String("x86")
470 )
471
472 // A Kubernetes Cluster.
473 const (
474 // The name of the cluster.
475 //
476 // Type: string
477 // Required: No
478 // Stability: stable
479 // Examples: 'opentelemetry-cluster'
480 K8SClusterNameKey = attribute.Key("k8s.cluster.name")
481 )
482
483 // A Kubernetes Node object.
484 const (
485 // The name of the Node.
486 //
487 // Type: string
488 // Required: No
489 // Stability: stable
490 // Examples: 'node-1'
491 K8SNodeNameKey = attribute.Key("k8s.node.name")
492 // The UID of the Node.
493 //
494 // Type: string
495 // Required: No
496 // Stability: stable
497 // Examples: '1eb3a0c6-0477-4080-a9cb-0cb7db65c6a2'
498 K8SNodeUIDKey = attribute.Key("k8s.node.uid")
499 )
500
501 // A Kubernetes Namespace.
502 const (
503 // The name of the namespace that the pod is running in.
504 //
505 // Type: string
506 // Required: No
507 // Stability: stable
508 // Examples: 'default'
509 K8SNamespaceNameKey = attribute.Key("k8s.namespace.name")
510 )
511
512 // A Kubernetes Pod object.
513 const (
514 // The UID of the Pod.
515 //
516 // Type: string
517 // Required: No
518 // Stability: stable
519 // Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
520 K8SPodUIDKey = attribute.Key("k8s.pod.uid")
521 // The name of the Pod.
522 //
523 // Type: string
524 // Required: No
525 // Stability: stable
526 // Examples: 'opentelemetry-pod-autoconf'
527 K8SPodNameKey = attribute.Key("k8s.pod.name")
528 )
529
530 // A container in a [PodTemplate](https://kubernetes.io/docs/concepts/workloads/pods/#pod-templates).
531 const (
532 // The name of the Container in a Pod template.
533 //
534 // Type: string
535 // Required: No
536 // Stability: stable
537 // Examples: 'redis'
538 K8SContainerNameKey = attribute.Key("k8s.container.name")
539 )
540
541 // A Kubernetes ReplicaSet object.
542 const (
543 // The UID of the ReplicaSet.
544 //
545 // Type: string
546 // Required: No
547 // Stability: stable
548 // Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
549 K8SReplicaSetUIDKey = attribute.Key("k8s.replicaset.uid")
550 // The name of the ReplicaSet.
551 //
552 // Type: string
553 // Required: No
554 // Stability: stable
555 // Examples: 'opentelemetry'
556 K8SReplicaSetNameKey = attribute.Key("k8s.replicaset.name")
557 )
558
559 // A Kubernetes Deployment object.
560 const (
561 // The UID of the Deployment.
562 //
563 // Type: string
564 // Required: No
565 // Stability: stable
566 // Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
567 K8SDeploymentUIDKey = attribute.Key("k8s.deployment.uid")
568 // The name of the Deployment.
569 //
570 // Type: string
571 // Required: No
572 // Stability: stable
573 // Examples: 'opentelemetry'
574 K8SDeploymentNameKey = attribute.Key("k8s.deployment.name")
575 )
576
577 // A Kubernetes StatefulSet object.
578 const (
579 // The UID of the StatefulSet.
580 //
581 // Type: string
582 // Required: No
583 // Stability: stable
584 // Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
585 K8SStatefulSetUIDKey = attribute.Key("k8s.statefulset.uid")
586 // The name of the StatefulSet.
587 //
588 // Type: string
589 // Required: No
590 // Stability: stable
591 // Examples: 'opentelemetry'
592 K8SStatefulSetNameKey = attribute.Key("k8s.statefulset.name")
593 )
594
595 // A Kubernetes DaemonSet object.
596 const (
597 // The UID of the DaemonSet.
598 //
599 // Type: string
600 // Required: No
601 // Stability: stable
602 // Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
603 K8SDaemonSetUIDKey = attribute.Key("k8s.daemonset.uid")
604 // The name of the DaemonSet.
605 //
606 // Type: string
607 // Required: No
608 // Stability: stable
609 // Examples: 'opentelemetry'
610 K8SDaemonSetNameKey = attribute.Key("k8s.daemonset.name")
611 )
612
613 // A Kubernetes Job object.
614 const (
615 // The UID of the Job.
616 //
617 // Type: string
618 // Required: No
619 // Stability: stable
620 // Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
621 K8SJobUIDKey = attribute.Key("k8s.job.uid")
622 // The name of the Job.
623 //
624 // Type: string
625 // Required: No
626 // Stability: stable
627 // Examples: 'opentelemetry'
628 K8SJobNameKey = attribute.Key("k8s.job.name")
629 )
630
631 // A Kubernetes CronJob object.
632 const (
633 // The UID of the CronJob.
634 //
635 // Type: string
636 // Required: No
637 // Stability: stable
638 // Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff'
639 K8SCronJobUIDKey = attribute.Key("k8s.cronjob.uid")
640 // The name of the CronJob.
641 //
642 // Type: string
643 // Required: No
644 // Stability: stable
645 // Examples: 'opentelemetry'
646 K8SCronJobNameKey = attribute.Key("k8s.cronjob.name")
647 )
648
649 // The operating system (OS) on which the process represented by this resource is running.
650 const (
651 // The operating system type.
652 //
653 // Type: Enum
654 // Required: Always
655 // Stability: stable
656 OSTypeKey = attribute.Key("os.type")
657 // Human readable (not intended to be parsed) OS version information, like e.g.
658 // reported by `ver` or `lsb_release -a` commands.
659 //
660 // Type: string
661 // Required: No
662 // Stability: stable
663 // Examples: 'Microsoft Windows [Version 10.0.18363.778]', 'Ubuntu 18.04.1 LTS'
664 OSDescriptionKey = attribute.Key("os.description")
665 // Human readable operating system name.
666 //
667 // Type: string
668 // Required: No
669 // Stability: stable
670 // Examples: 'iOS', 'Android', 'Ubuntu'
671 OSNameKey = attribute.Key("os.name")
672 // The version string of the operating system as defined in [Version
673 // Attributes](../../resource/semantic_conventions/README.md#version-attributes).
674 //
675 // Type: string
676 // Required: No
677 // Stability: stable
678 // Examples: '14.2.1', '18.04.1'
679 OSVersionKey = attribute.Key("os.version")
680 )
681
682 var (
683 // Microsoft Windows
684 OSTypeWindows = OSTypeKey.String("windows")
685 // Linux
686 OSTypeLinux = OSTypeKey.String("linux")
687 // Apple Darwin
688 OSTypeDarwin = OSTypeKey.String("darwin")
689 // FreeBSD
690 OSTypeFreeBSD = OSTypeKey.String("freebsd")
691 // NetBSD
692 OSTypeNetBSD = OSTypeKey.String("netbsd")
693 // OpenBSD
694 OSTypeOpenBSD = OSTypeKey.String("openbsd")
695 // DragonFly BSD
696 OSTypeDragonflyBSD = OSTypeKey.String("dragonflybsd")
697 // HP-UX (Hewlett Packard Unix)
698 OSTypeHPUX = OSTypeKey.String("hpux")
699 // AIX (Advanced Interactive eXecutive)
700 OSTypeAIX = OSTypeKey.String("aix")
701 // Oracle Solaris
702 OSTypeSolaris = OSTypeKey.String("solaris")
703 // IBM z/OS
704 OSTypeZOS = OSTypeKey.String("z_os")
705 )
706
707 // An operating system process.
708 const (
709 // Process identifier (PID).
710 //
711 // Type: int
712 // Required: No
713 // Stability: stable
714 // Examples: 1234
715 ProcessPIDKey = attribute.Key("process.pid")
716 // The name of the process executable. On Linux based systems, can be set to the
717 // `Name` in `proc/[pid]/status`. On Windows, can be set to the base name of
718 // `GetProcessImageFileNameW`.
719 //
720 // Type: string
721 // Required: See below
722 // Stability: stable
723 // Examples: 'otelcol'
724 ProcessExecutableNameKey = attribute.Key("process.executable.name")
725 // The full path to the process executable. On Linux based systems, can be set to
726 // the target of `proc/[pid]/exe`. On Windows, can be set to the result of
727 // `GetProcessImageFileNameW`.
728 //
729 // Type: string
730 // Required: See below
731 // Stability: stable
732 // Examples: '/usr/bin/cmd/otelcol'
733 ProcessExecutablePathKey = attribute.Key("process.executable.path")
734 // The command used to launch the process (i.e. the command name). On Linux based
735 // systems, can be set to the zeroth string in `proc/[pid]/cmdline`. On Windows,
736 // can be set to the first parameter extracted from `GetCommandLineW`.
737 //
738 // Type: string
739 // Required: See below
740 // Stability: stable
741 // Examples: 'cmd/otelcol'
742 ProcessCommandKey = attribute.Key("process.command")
743 // The full command used to launch the process as a single string representing the
744 // full command. On Windows, can be set to the result of `GetCommandLineW`. Do not
745 // set this if you have to assemble it just for monitoring; use
746 // `process.command_args` instead.
747 //
748 // Type: string
749 // Required: See below
750 // Stability: stable
751 // Examples: 'C:\\cmd\\otecol --config="my directory\\config.yaml"'
752 ProcessCommandLineKey = attribute.Key("process.command_line")
753 // All the command arguments (including the command/executable itself) as received
754 // by the process. On Linux-based systems (and some other Unixoid systems
755 // supporting procfs), can be set according to the list of null-delimited strings
756 // extracted from `proc/[pid]/cmdline`. For libc-based executables, this would be
757 // the full argv vector passed to `main`.
758 //
759 // Type: string[]
760 // Required: See below
761 // Stability: stable
762 // Examples: 'cmd/otecol', '--config=config.yaml'
763 ProcessCommandArgsKey = attribute.Key("process.command_args")
764 // The username of the user that owns the process.
765 //
766 // Type: string
767 // Required: No
768 // Stability: stable
769 // Examples: 'root'
770 ProcessOwnerKey = attribute.Key("process.owner")
771 )
772
773 // The single (language) runtime instance which is monitored.
774 const (
775 // The name of the runtime of this process. For compiled native binaries, this
776 // SHOULD be the name of the compiler.
777 //
778 // Type: string
779 // Required: No
780 // Stability: stable
781 // Examples: 'OpenJDK Runtime Environment'
782 ProcessRuntimeNameKey = attribute.Key("process.runtime.name")
783 // The version of the runtime of this process, as returned by the runtime without
784 // modification.
785 //
786 // Type: string
787 // Required: No
788 // Stability: stable
789 // Examples: '14.0.2'
790 ProcessRuntimeVersionKey = attribute.Key("process.runtime.version")
791 // An additional description about the runtime of the process, for example a
792 // specific vendor customization of the runtime environment.
793 //
794 // Type: string
795 // Required: No
796 // Stability: stable
797 // Examples: 'Eclipse OpenJ9 Eclipse OpenJ9 VM openj9-0.21.0'
798 ProcessRuntimeDescriptionKey = attribute.Key("process.runtime.description")
799 )
800
801 // A service instance.
802 const (
803 // Logical name of the service.
804 //
805 // Type: string
806 // Required: Always
807 // Stability: stable
808 // Examples: 'shoppingcart'
809 // Note: MUST be the same for all instances of horizontally scaled services. If
810 // the value was not specified, SDKs MUST fallback to `unknown_service:`
811 // concatenated with [`process.executable.name`](process.md#process), e.g.
812 // `unknown_service:bash`. If `process.executable.name` is not available, the
813 // value MUST be set to `unknown_service`.
814 ServiceNameKey = attribute.Key("service.name")
815 // A namespace for `service.name`.
816 //
817 // Type: string
818 // Required: No
819 // Stability: stable
820 // Examples: 'Shop'
821 // Note: A string value having a meaning that helps to distinguish a group of
822 // services, for example the team name that owns a group of services.
823 // `service.name` is expected to be unique within the same namespace. If
824 // `service.namespace` is not specified in the Resource then `service.name` is
825 // expected to be unique for all services that have no explicit namespace defined
826 // (so the empty/unspecified namespace is simply one more valid namespace). Zero-
827 // length namespace string is assumed equal to unspecified namespace.
828 ServiceNamespaceKey = attribute.Key("service.namespace")
829 // The string ID of the service instance.
830 //
831 // Type: string
832 // Required: No
833 // Stability: stable
834 // Examples: '627cc493-f310-47de-96bd-71410b7dec09'
835 // Note: MUST be unique for each instance of the same
836 // `service.namespace,service.name` pair (in other words
837 // `service.namespace,service.name,service.instance.id` triplet MUST be globally
838 // unique). The ID helps to distinguish instances of the same service that exist
839 // at the same time (e.g. instances of a horizontally scaled service). It is
840 // preferable for the ID to be persistent and stay the same for the lifetime of
841 // the service instance, however it is acceptable that the ID is ephemeral and
842 // changes during important lifetime events for the service (e.g. service
843 // restarts). If the service has no inherent unique ID that can be used as the
844 // value of this attribute it is recommended to generate a random Version 1 or
845 // Version 4 RFC 4122 UUID (services aiming for reproducible UUIDs may also use
846 // Version 5, see RFC 4122 for more recommendations).
847 ServiceInstanceIDKey = attribute.Key("service.instance.id")
848 // The version string of the service API or implementation.
849 //
850 // Type: string
851 // Required: No
852 // Stability: stable
853 // Examples: '2.0.0'
854 ServiceVersionKey = attribute.Key("service.version")
855 )
856
857 // The telemetry SDK used to capture data recorded by the instrumentation libraries.
858 const (
859 // The name of the telemetry SDK as defined above.
860 //
861 // Type: string
862 // Required: No
863 // Stability: stable
864 // Examples: 'opentelemetry'
865 TelemetrySDKNameKey = attribute.Key("telemetry.sdk.name")
866 // The language of the telemetry SDK.
867 //
868 // Type: Enum
869 // Required: No
870 // Stability: stable
871 TelemetrySDKLanguageKey = attribute.Key("telemetry.sdk.language")
872 // The version string of the telemetry SDK.
873 //
874 // Type: string
875 // Required: No
876 // Stability: stable
877 // Examples: '1.2.3'
878 TelemetrySDKVersionKey = attribute.Key("telemetry.sdk.version")
879 // The version string of the auto instrumentation agent, if used.
880 //
881 // Type: string
882 // Required: No
883 // Stability: stable
884 // Examples: '1.2.3'
885 TelemetryAutoVersionKey = attribute.Key("telemetry.auto.version")
886 )
887
888 var (
889 // cpp
890 TelemetrySDKLanguageCPP = TelemetrySDKLanguageKey.String("cpp")
891 // dotnet
892 TelemetrySDKLanguageDotnet = TelemetrySDKLanguageKey.String("dotnet")
893 // erlang
894 TelemetrySDKLanguageErlang = TelemetrySDKLanguageKey.String("erlang")
895 // go
896 TelemetrySDKLanguageGo = TelemetrySDKLanguageKey.String("go")
897 // java
898 TelemetrySDKLanguageJava = TelemetrySDKLanguageKey.String("java")
899 // nodejs
900 TelemetrySDKLanguageNodejs = TelemetrySDKLanguageKey.String("nodejs")
901 // php
902 TelemetrySDKLanguagePHP = TelemetrySDKLanguageKey.String("php")
903 // python
904 TelemetrySDKLanguagePython = TelemetrySDKLanguageKey.String("python")
905 // ruby
906 TelemetrySDKLanguageRuby = TelemetrySDKLanguageKey.String("ruby")
907 // webjs
908 TelemetrySDKLanguageWebjs = TelemetrySDKLanguageKey.String("webjs")
909 )
910
911 // Resource describing the packaged software running the application code. Web engines are typically executed using process.runtime.
912 const (
913 // The name of the web engine.
914 //
915 // Type: string
916 // Required: Always
917 // Stability: stable
918 // Examples: 'WildFly'
919 WebEngineNameKey = attribute.Key("webengine.name")
920 // The version of the web engine.
921 //
922 // Type: string
923 // Required: No
924 // Stability: stable
925 // Examples: '21.0.0'
926 WebEngineVersionKey = attribute.Key("webengine.version")
927 // Additional description of the web engine (e.g. detailed version and edition
928 // information).
929 //
930 // Type: string
931 // Required: No
932 // Stability: stable
933 // Examples: 'WildFly Full 21.0.0.Final (WildFly Core 13.0.1.Final) - 2.2.2.Final'
934 WebEngineDescriptionKey = attribute.Key("webengine.description")
935 )