Debian Codegraph @

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