Technology
OpenTelemetry Kubernetes Operator
For monitoring your Kubernetes cluster and workloads you can also use the OpenTelemetry Kubernetes Operator. Gain clear visibility into your system metrics.
Overview
Overview
Use the OpenTelemetry Kubernetes operator to manage OpenTelemetry collector deployments. It is generally useful for advanced observability needs.
Use Cases
- Manage and deploy various OpenTelemetry Collectors.
- Automatically instrument your workloads.
Setup
Overview
The OpenTelemetry Operator simplifies and automates the management of OpenTelemetry within your Kubernetes environment. It handles everything from managing collectors to enabling auto-instrumentation for your applications.
Installation
Deploy Cert Manager
Before deploying the OpenTelemetry Operator, ensure that Cert Manager is installed. It's a required prerequisite. If it is not already running in your cluster, you can install it using Helm with the following commands:
helm repo add jetstack https://charts.jetstack.io --force-update
helm install \
cert-manager jetstack/cert-manager \
--namespace cert-manager \
--create-namespace \
--set crds.enabled=trueDeploy the OpenTelemetry Operator
You can now deploy the OpenTelemetry Operator. The collectorImage repository must be explicitly specified, as the default image is the OpenTelemetry Collector core distribution, which lacks the necessary components.
Additionally, it is recommended to define the namespace where the operator will be deployed and ensure it is created if it does not already exist:
helm repo add open-telemetry https://open-telemetry.github.io/opentelemetry-helm-charts
helm upgrade --install opentelemetry-operator open-telemetry/opentelemetry-operator \
--set "manager.collectorImage.repository=otel/opentelemetry-collector-k8s" \
--namespace opentelemetry \
--create-namespaceIf you need automatic instrumentation for Go applications, you can enable it by adding the following flag to the command above:
--set manager.extraArgs="{--enable-go-instrumentation}"Note: Enabling this feature comes with security trade-offs, as it relies on eBPF, which requires elevated permissions for the sidecar container. For more details, see this deep dive.
Create a Kubernetes secret for the Dash0 Authorization Token
To send data to Dash0, you need to obtain your Authorization Token and store it as a Kubernetes secret.
Run the following command to create a secret containing your Dash0 Authorization Token:
kubectl create secret generic dash0-secrets --from-literal=dash0-authorization-token={{token}} --namespace opentelemetryApply the The OpenTelemetry Collector configurations
In this configuration, we will deploy two different OpenTelemetry Collectors:
otel-collector(mode: DaemonSet)- Runs on every node to minimize latency and reduce network overhead. It is responsible for:
- Collecting node-level metrics using the Kubeletstats Receiver (CPU, memory, disk usage).
- Collecting host-level metrics (CPU, filesystem, and memory utilization) using the Host Metrics Receiver.
- Collecting logs using the filelog receiver
- Automatically enriching telemetry data with Kubernetes metadata using the Kubernetes Attributes Processor.
- Runs on every node to minimize latency and reduce network overhead. It is responsible for:
otel-collector-central(mode: Deployment)- A single-replica collector that handles:
- Cluster-wide metrics via the Kubernetes Cluster Receiver (node conditions, pod phases, resource quotas).
- Kubernetes API server objects using the Kubernetes Objects Receiver (events, namespaces, resource quotas).
- A single-replica collector that handles:
Our OpenTelemetry Collectors need to interact with various Kubernetes components, such as the Kubernetes API, to collect telemetry data. To enable this, we must ensure they have the necessary permissions and access within the cluster.
Deploy the necessary ServiceAccount's, ClusterRoleBinding's, ClusterRole's to the cluster:
kubectl apply -f - <<EOF
---
apiVersion: v1
kind: ServiceAccount
metadata:
name: otel-collector
namespace: opentelemetry
---
apiVersion: v1
kind: ServiceAccount
metadata:
name: otel-collector-central
namespace: opentelemetry
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: otel-collector
rules:
- apiGroups:
- ""
resources:
- events
- namespaces
- namespaces/status
- nodes
- nodes/spec
- nodes/stats
- nodes/proxy
- pods
- pods/status
- replicationcontrollers
- replicationcontrollers/status
- resourcequotas
- services
verbs:
- get
- list
- watch
- apiGroups:
- apps
resources:
- daemonsets
- deployments
- replicasets
- statefulsets
verbs:
- get
- list
- watch
- apiGroups:
- extensions
resources:
- daemonsets
- deployments
- replicasets
verbs:
- get
- list
- watch
- apiGroups:
- batch
resources:
- jobs
- cronjobs
verbs:
- get
- list
- watch
- apiGroups:
- autoscaling
resources:
- horizontalpodautoscalers
verbs:
- get
- list
- watch
- apiGroups:
- metrics.k8s.io
resources:
- pods
- nodes
verbs:
- get
- list
- watch
- nonResourceURLs:
- /metrics
- /metrics/cadvisor
verbs:
- get
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: otel-collector-central
rules:
- apiGroups:
- ''
resources:
- events
- namespaces
- namespaces/status
- nodes
- nodes/spec
- pods
- pods/status
- replicationcontrollers
- replicationcontrollers/status
- resourcequotas
- services
verbs:
- get
- list
- watch
- apiGroups:
- apps
resources:
- daemonsets
- deployments
- replicasets
- statefulsets
verbs:
- get
- list
- watch
- apiGroups:
- extensions
resources:
- daemonsets
- deployments
- replicasets
verbs:
- get
- list
- watch
- apiGroups:
- batch
resources:
- jobs
- cronjobs
verbs:
- get
- list
- watch
- apiGroups:
- autoscaling
resources:
- horizontalpodautoscalers
verbs:
- get
- list
- watch
- apiGroups:
- events.k8s.io
resources:
- events
verbs:
- list
- watch
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
name: otel-collector
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
name: otel-collector
subjects:
- kind: ServiceAccount
name: otel-collector
namespace: opentelemetry
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
name: otel-collector-central
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
name: otel-collector-central
subjects:
- kind: ServiceAccount
name: otel-collector-central
namespace: opentelemetry
---
# otel-collector-central runs as a Deployment. Its k8s_cluster and k8sobjects receivers watch the whole cluster, so
# running more than one replica without leader election would duplicate every cluster metric and event. The
# k8sleaderelector extension (wired up on the collector below) needs to get/create/update a Lease to elect an
# active replica; a namespace-scoped Role is enough since Leases aren't cluster-scoped.
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
name: otel-collector-central-leader-election
namespace: opentelemetry
rules:
- apiGroups:
- coordination.k8s.io
resources:
- leases
verbs:
- get
- list
- watch
- create
- update
- patch
- delete
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
name: otel-collector-central-leader-election
namespace: opentelemetry
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: Role
name: otel-collector-central-leader-election
subjects:
- kind: ServiceAccount
name: otel-collector-central
namespace: opentelemetry
EOFDeploy the otel-collector:
kubectl apply -f - <<EOF
apiVersion: opentelemetry.io/v1beta1
kind: OpenTelemetryCollector
metadata:
name: otel
namespace: opentelemetry
spec:
mode: daemonset
serviceAccount: otel-collector
volumeMounts:
- name: varlogpods
mountPath: /var/log/pods
readOnly: true
- name: varlibdockercontainers
mountPath: /var/lib/docker/containers
readOnly: true
# --- BEGIN optional: persist filelog receiver offsets - see the file_storage extension in `config` below ---
- name: filelogreceiveroffsets
mountPath: /var/otelcol/filelogreceiver_offsets
# --- END optional: persist filelog receiver offsets ---
# --- BEGIN optional: host-level metrics - see the hostmetrics receiver in `config` below ---
- name: hostfs
mountPath: /hostfs
readOnly: true
mountPropagation: HostToContainer
# --- END optional: host-level metrics ---
volumes:
- name: varlogpods
hostPath:
path: /var/log/pods
- name: varlibdockercontainers
hostPath:
path: /var/lib/docker/containers
# --- BEGIN optional: persist filelog receiver offsets ---
- name: filelogreceiveroffsets
emptyDir: {}
# --- END optional: persist filelog receiver offsets ---
# --- BEGIN optional: host-level metrics ---
- name: hostfs
hostPath:
path: /
# --- END optional: host-level metrics ---
env:
- name: DASH0_AUTHORIZATION_TOKEN
valueFrom:
secretKeyRef:
name: dash0-secrets
key: dash0-authorization-token
- name: K8S_NODE_NAME
valueFrom:
fieldRef:
fieldPath: spec.nodeName
config:
exporters:
otlp/dash0:
auth:
authenticator: bearertokenauth/dash0
endpoint: {{endpoint_otlp_grpc}}
headers:
Dash0-Dataset: default
extensions:
bearertokenauth/dash0:
scheme: Bearer
token: \${env:DASH0_AUTHORIZATION_TOKEN}
health_check:
endpoint: "0.0.0.0:13133"
# --- BEGIN optional: persist filelog receiver offsets across container restarts ---
# Requires the /var/otelcol/filelogreceiver_offsets volume mount and matching emptyDir volume declared in
# `volumeMounts`/`volumes` above (grep for "optional: persist filelog" to find every piece that belongs
# together). Without this, a collector container restart re-reads (or skips, depending on log rotation) pod
# logs from wherever the log files currently stand, instead of resuming exactly where it left off.
file_storage/filelogreceiver_offsets:
directory: /var/otelcol/filelogreceiver_offsets
timeout: 1s
# --- END optional: persist filelog receiver offsets ---
processors:
memory_limiter:
check_interval: 1s
limit_percentage: 50
spike_limit_percentage: 30
batch: {}
resource:
attributes:
- key: k8s.node.name
value: "\${env:K8S_NODE_NAME}"
action: upsert
resourcedetection:
detectors:
# Note: later detectors do *not* overwrite attributes provided by earlier detectors, hence more specific
# detectors must come first (e.g. eks before ec2 - both write to cloud.platform).
- eks
- ecs
- ec2
- gcp
- azure
- aks
- k8snode
- system
timeout: 2s
system:
resource_attributes:
host.name:
# Do not collect host.name via system resource detector, as this would result in the podname being set as the
# hostname, see https://kubernetes.io/docs/concepts/containers/container-environment/#container-information.
enabled: false
k8sattributes:
extract:
metadata:
- k8s.cluster.uid
- k8s.cronjob.name
- k8s.cronjob.uid
- k8s.daemonset.name
- k8s.daemonset.uid
- k8s.deployment.name
- k8s.deployment.uid
- k8s.job.name
- k8s.job.uid
- k8s.namespace.name
- k8s.node.name
- k8s.pod.hostname
- k8s.pod.ip
- k8s.pod.name
- k8s.pod.start_time
- k8s.pod.uid
- k8s.replicaset.name
- k8s.replicaset.uid
- k8s.statefulset.name
- k8s.statefulset.uid
- container.image.name
- container.image.tag
filter:
node_from_env_var: K8S_NODE_NAME
passthrough: false
pod_association:
- sources:
- from: resource_attribute
name: k8s.pod.ip
- sources:
- from: resource_attribute
name: k8s.pod.uid
- sources:
- from: connection
receivers:
kubeletstats:
collection_interval: 30s
auth_type: 'serviceAccount'
endpoint: '\${env:K8S_NODE_NAME}:10250'
insecure_skip_verify: true
node: '\${env:K8S_NODE_NAME}'
metric_groups:
- container
- pod
- node
- volume
# extra_metadata_labels requires the nodes/proxy RBAC permission (already included in the otel-collector
# ClusterRole below) and is unavailable on managed clusters that disable that permission, e.g. GKE Autopilot.
extra_metadata_labels:
- container.id
- k8s.volume.type
k8s_api_config:
auth_type: serviceAccount
# These volume-related resource attributes are deprecated upstream but still enabled by default; disable
# them explicitly to avoid startup warning log messages.
resource_attributes:
aws.volume.id:
enabled: false
fs.type:
enabled: false
gce.pd.name:
enabled: false
glusterfs.endpoints.name:
enabled: false
glusterfs.path:
enabled: false
partition:
enabled: false
metrics:
container.cpu.usage:
enabled: true
k8s.node.cpu.usage:
enabled: true
k8s.pod.cpu.usage:
enabled: true
k8s.pod.cpu_limit_utilization:
enabled: true
k8s.pod.cpu_request_utilization:
enabled: true
k8s.pod.memory_limit_utilization:
enabled: true
k8s.pod.memory_request_utilization:
enabled: true
# --- BEGIN optional: host-level metrics (cpu/filesystem/memory) ---
# Requires the /hostfs volume mount and matching hostPath volume declared in `volumeMounts`/`volumes` above
# (grep for "optional: host-level metrics" to find every piece that belongs together). Remove all of them
# together if you don't want to collect host-level metrics.
hostmetrics:
collection_interval: 60s
root_path: /hostfs
scrapers:
cpu:
metrics:
# Disable the metric that's enabled by default in favor of the utilization one below.
system.cpu.time:
enabled: false
system.cpu.utilization:
enabled: true
filesystem:
metrics:
# Disable the metrics that are enabled by default in favor of the utilization one below.
system.filesystem.inodes.usage:
enabled: false
system.filesystem.usage:
enabled: false
system.filesystem.utilization:
enabled: true
exclude_fs_types:
fs_types:
- autofs
- binfmt_misc
- bpf
- cgroup2
- configfs
- debugfs
- devpts
- devtmpfs
- fusectl
- hugetlbfs
- iso9660
- mqueue
- nsfs
- overlay
- proc
- procfs
- pstore
- rpc_pipefs
- securityfs
- selinuxfs
- squashfs
- sysfs
- tracefs
match_type: strict
exclude_mount_points:
match_type: regexp
mount_points:
- /dev/*
- /proc/*
- /sys/*
- /var/lib/docker/*
- /var/lib/kubelet/*
- /snap/*
memory:
metrics:
system.memory.usage:
enabled: false
system.memory.utilization:
enabled: true
# --- END optional: host-level metrics ---
otlp:
protocols:
grpc:
endpoint: 0.0.0.0:4317
http:
endpoint: 0.0.0.0:4318
filelog:
exclude:
- /var/log/pods/kube-system_*/*/*.log
include:
- /var/log/pods/*/*/*.log
start_at: beginning
include_file_path: true
# See "optional: persist filelog receiver offsets" above.
storage: file_storage/filelogreceiver_offsets
operators:
- id: container-parser
type: container
add_metadata_from_filepath: true
- type: trace_parser
trace_id:
parse_from: attributes.trace_id
span_id:
parse_from: attributes.span_id
trace_flags:
parse_from: attributes.trace_flags
service:
extensions:
- bearertokenauth/dash0
- health_check
# See "optional: persist filelog receiver offsets" above; remove this line too if you removed that extension.
- file_storage/filelogreceiver_offsets
pipelines:
logs:
exporters:
- otlp/dash0
processors:
- memory_limiter
- k8sattributes
- resourcedetection
- batch
- resource
receivers:
- otlp
- filelog
metrics:
exporters:
- otlp/dash0
processors:
- memory_limiter
- k8sattributes
- resourcedetection
- batch
- resource
receivers:
- otlp
- kubeletstats
# See "optional: host-level metrics" above; remove this line too if you removed that receiver.
- hostmetrics
traces:
exporters:
- otlp/dash0
processors:
- memory_limiter
- k8sattributes
- resourcedetection
- batch
- resource
receivers:
- otlp
telemetry:
metrics:
level: detailed
EOFDeploy the otel-collector-central:
kubectl apply -f - <<EOF
apiVersion: opentelemetry.io/v1beta1
kind: OpenTelemetryCollector
metadata:
name: otel-collector-central
namespace: opentelemetry
spec:
mode: deployment
# Safe to run more than one replica because the k8sleaderelector extension below (see `config.extensions` and
# `config.service.extensions`) ensures only one replica is ever active at a time; the standby replica(s) take
# over within `lease_duration` if the active one is lost, e.g. during a node drain or rolling update.
replicas: 2
serviceAccount: otel-collector-central
env:
- name: DASH0_AUTHORIZATION_TOKEN
valueFrom:
secretKeyRef:
name: dash0-secrets
key: dash0-authorization-token
- name: K8S_NODE_NAME
valueFrom:
fieldRef:
fieldPath: spec.nodeName
- name: OTEL_RESOURCE_ATTRIBUTES
value: node.name=\$(K8S_NODE_NAME)
config:
exporters:
otlp/dash0:
auth:
authenticator: bearertokenauth/dash0
endpoint: {{endpoint_otlp_grpc}}
headers:
Dash0-Dataset: default
extensions:
bearertokenauth/dash0:
scheme: Bearer
token: \${env:DASH0_AUTHORIZATION_TOKEN}
health_check:
endpoint: "0.0.0.0:13133"
k8s_leader_elector:
auth_type: serviceAccount
lease_name: otel-collector-central
lease_namespace: opentelemetry
processors:
batch: {}
# The k8sobjects receiver's watch-mode Event records carry the involved object's identity (kind/name/uid) and
# are shaped `{type, object: {...}}` — this identity lives in the log body, not as resource attributes, so
# the k8sattributes processor right below has nothing to pod_association-match on. This promotes just enough
# identity onto the resource for that to work: Node-kind events already carry the node's own uid directly;
# Pod-kind events only carry k8s.pod.uid, which k8sattributes then resolves to the pod's node (name + uid)
# via its own Node cache — the same mechanism that backfills k8s.node.uid on the k8s_cluster receiver's
# metrics below. Safe to set directly on the resource: our receiver runs in watch mode, which emits one
# ResourceLogs per event (never multiple events sharing one resource). `regarding` (not the legacy core-API
# `involvedObject`) because our receiver watches the `events.k8s.io` group.
transform/logs/k8s_events_node_identity:
error_mode: ignore
log_statements:
- context: log
statements:
- set(resource.attributes["k8s.node.uid"], log.body["object"]["regarding"]["uid"]) where log.body["object"]["regarding"]["kind"] == "Node"
- set(resource.attributes["k8s.node.name"], log.body["object"]["regarding"]["name"]) where log.body["object"]["regarding"]["kind"] == "Node"
- set(resource.attributes["k8s.pod.uid"], log.body["object"]["regarding"]["uid"]) where log.body["object"]["regarding"]["kind"] == "Pod"
k8sattributes:
extract:
metadata:
- k8s.cluster.uid
- k8s.cronjob.name
- k8s.cronjob.uid
- k8s.daemonset.name
- k8s.daemonset.uid
- k8s.deployment.name
- k8s.deployment.uid
- k8s.job.name
- k8s.job.uid
- k8s.namespace.name
- k8s.node.name
# k8s.node.uid backfills the node identity on the k8s.pod.* / k8s.container.* metrics that the k8s_cluster
# receiver below only tags with k8s.node.name (a plain string, not the k8s.node entity's identity
# attribute) — without this, those metrics and the k8s.node.* metrics describe what looks like two
# different nodes to anything resolving node identity by uid. Requires get/list/watch on nodes, which the
# otel-collector-central ClusterRole below already grants.
- k8s.node.uid
- k8s.pod.hostname
- k8s.pod.ip
- k8s.pod.name
- k8s.pod.start_time
- k8s.pod.uid
- k8s.replicaset.name
- k8s.replicaset.uid
- k8s.statefulset.name
- k8s.statefulset.uid
- container.image.name
- container.image.tag
# Deliberately no `filter: node_from_env_var` here (unlike the daemonset's k8sattributes processor): this
# collector is cluster-wide, so its pod informer must see pods on every node, not just the node this
# Deployment pod happens to be scheduled on.
passthrough: false
pod_association:
- sources:
- from: resource_attribute
name: k8s.pod.ip
- sources:
- from: resource_attribute
name: k8s.pod.uid
- sources:
- from: connection
# Enrich cluster-scoped telemetry with cloud/account resource attributes (cloud.provider, cloud.platform,
# cloud.account.id, cloud.region). Deliberately not adding node- or host-related attributes (host.*,
# cloud.availability_zone, cloud instance identifiers): this collector isn't node-scoped, so its own node's
# identity must not leak onto cluster-wide telemetry.
resourcedetection:
detectors:
- eks
- ec2
- gcp
- azure
- aks
# Never overwrite resource attributes already set by receivers (e.g. per-object k8s.* attributes from the
# k8s_cluster receiver).
override: false
timeout: 2s
eks:
node_from_env_var: K8S_NODE_NAME
ec2:
resource_attributes:
cloud.availability_zone:
enabled: false
host.id:
enabled: false
host.image.id:
enabled: false
host.name:
enabled: false
host.type:
enabled: false
gcp:
resource_attributes:
cloud.availability_zone:
enabled: false
host.id:
enabled: false
host.name:
enabled: false
host.type:
enabled: false
gcp.gce.instance_group_manager.name:
enabled: false
gcp.gce.instance_group_manager.region:
enabled: false
gcp.gce.instance_group_manager.zone:
enabled: false
azure:
resource_attributes:
azure.resourcegroup.name:
enabled: false
azure.vm.name:
enabled: false
azure.vm.scaleset.name:
enabled: false
azure.vm.size:
enabled: false
host.id:
enabled: false
host.name:
enabled: false
# Remove noisy replicaset metrics (Kubernetes keeps a history of up to 10 replicasets per deployment by
# default; collecting metrics for all of them adds no value). Dropping the zero-value datapoints keeps only
# the actual active replicaset (desired > 0) visible.
filter/drop-replicaset-metrics-zero-value:
error_mode: ignore
metrics:
datapoint:
- metric.name == "k8s.replicaset.available" and value_int == 0
- metric.name == "k8s.replicaset.desired" and value_int == 0
memory_limiter:
check_interval: 1s
limit_percentage: 50
spike_limit_percentage: 30
receivers:
prometheus:
config:
scrape_configs:
- job_name: 'otel-collector'
scrape_interval: 10s
static_configs:
- targets: [ '0.0.0.0:8888' ]
metric_relabel_configs:
- action: labeldrop
regex: (id|name)
replacement: \$\$1
- action: labelmap
regex: label_(.+)
replacement: \$\$1
k8s_cluster:
auth_type: serviceAccount
k8s_leader_elector: k8s_leader_elector
collection_interval: 30s
node_conditions_to_report:
- Ready
- MemoryPressure
allocatable_types_to_report:
- cpu
- memory
metrics:
k8s.container.status.reason:
enabled: true
k8s.container.status.state:
enabled: true
k8s.namespace.phase:
enabled: false
k8sobjects:
k8s_leader_elector: k8s_leader_elector
objects:
- name: events
mode: "watch"
group: "events.k8s.io"
exclude_watch_type:
- "DELETED"
service:
extensions:
- bearertokenauth/dash0
- health_check
- k8s_leader_elector
pipelines:
metrics:
exporters:
- otlp/dash0
processors:
- memory_limiter
- resourcedetection
- k8sattributes
- filter/drop-replicaset-metrics-zero-value
- batch
receivers:
- k8s_cluster
- prometheus
logs:
exporters:
- otlp/dash0
processors:
- memory_limiter
- resourcedetection
- transform/logs/k8s_events_node_identity
- k8sattributes
- batch
receivers:
- k8sobjects
telemetry:
metrics:
level: detailed
EOFUsing the deployed OpenTelemetry Collector
The OpenTelemetry Collectors have now been deployed to your cluster and can be used to send data.
The following services can be addressed within your cluster now, and all sent data will be forwarded to Dash0 using the configured endpoint and Auth Token:
otel-collector.opentelemetryis ClusterIP service. It can be addressed using OTLP gRPC (tcp/4317) and OTLP HTTP (tcp/4318)otel-collector-headless.opentelemetrycan be used as a headless service. It can be addressed using OTLP gRPC (tcp/4317) and OTLP HTTP (tcp/4318)
Optional: Adding automatic instrumentation to your workloads
By default, the OpenTelemetry Operator does not automatically instrument workloads. If you want your applications to be
instrumented automatically first create an Instrumentation configuration and add it to your cluster:
kubectl apply -f - <<EOF
apiVersion: opentelemetry.io/v1alpha1
kind: Instrumentation
metadata:
name: instrumentation
namespace: opentelemetry
spec:
exporter:
endpoint: http://otel-collector-headless.opentelemetry.svc.cluster.local:4317
propagators:
- tracecontext
- baggage
sampler:
type: always_on
argument: "1"
EOFNext add the following annotation to your workload's pod spec:
annotations:
instrumentation.opentelemetry.io/inject-nodejs: "opentelemetry/instrumentation"Dataset control
By default, telemetry data is sent to the default dataset in Dash0. To route data to a different dataset, modify the Dash0-Dataset header in the exporter configuration:
config:
exporters:
otlp/dash0:
auth:
authenticator: bearertokenauth/dash0
endpoint: { { endpoint_otlp_grpc } }
headers:
Dash0-Dataset: your-dataset-nameTroubleshooting
Refer to the official OpenTelemetry Operator troubleshooting documentation.