Skip to content

[service/telemetry] Collector is generating different service.instance.id for its own telemetry #14140

New issue
New issue
Closed
#14141
Closed
[service/telemetry] Collector is generating different service.instance.id for its own telemetry#14140
#14141
Labels
bugSomething isn't working
@douglascamata

Description

@douglascamata
douglascamata
opened on Nov 6, 2025

Component(s)

service

What happened?

Describe the bug

Since version 0.136.0, the Collector has been generating different service.instance.ids for its own telemetry. This also affects the opampextension and potentially other components.

Steps to reproduce

  • Prepare a configuration for the Otel Collector v0.136.0
  • Enable the opampextension.
    • In the extension, do NOT provide an instance UID
    • Enable the include_resource_attributes in the agent description
  • Enable service telemetry and send it somewhere for checking later

What did you expect to see?

  • Consistent service.instance.id across the Collector logs, metrics, traces, and other components that need to access it.

What did you see instead?

Logs showing one service instance id (83a67ea4-2068-4c4b-b2f6-f44c84045d27):

{"level":"info","ts":"2025-11-06T16:46:14.932Z","caller":"extensions/extensions.go:62","msg":"Extension started.","resource":{"cx.agent.type":"agent","k8s.daemonset.name":"coralogix-opentelemetry","k8s.namespace.name":"monitoring","k8s.node.name":"ip-10-0-2-13.eu-west-1.compute.internal","k8s.pod.name":"coralogix-opentelemetry-agent-pqwts","service.instance.id":"83a67ea4-2068-4c4b-b2f6-f44c84045d27","service.name":"opentelemetry-collector","service.version":"0.136.0"},"otelcol.component.id":"health_check","otelcol.component.kind":"extension"}

Metrics showing a different service instance id (af5d9852-766d-4e27-9d79-2436d828df45):

{k8s_pod_name="coralogix-opentelemetry-agent-pqwts", service_instance_id="af5d9852-766d-4e27-9d79-2436d828df45"}

opampextension showing a different service instance id (af835b9e-a35a-43ca-8839-10db05ca9a1b):

  k8s.node.name: "ip-10-0-2-13.eu-west-1.compute.internal"
  os.type: "linux"
  helm.chart.opentelemetry-agent.version: "0.121.6"
  service.instance.id: "af835b9e-a35a-43ca-8839-10db05ca9a1b"
  cx.cluster.name: "eco-system-onlineboutique"
  k8s.namespace.name: "monitoring"
  k8s.pod.name: "coralogix-opentelemetry-agent-pqwts"
  host.arch: "amd64"
  os.description: " "
  service.version: "0.136.0"
  host.name: "ip-10-0-2-13.eu-west-1.compute.internal"
  cx.agent.type: "agent"
  service.name: "opentelemetry-collector"
  cx.otel.agent.attributes: true
  k8s.daemonset.name: "coralogix-opentelemetry"

Collector version

v0.136.0

Environment information

No response

OpenTelemetry Collector configuration

Full yaml config 

    connectors:
      forward/compact: {}
      forward/db: {}
      forward/db_compact: {}
      spanmetrics:
        aggregation_cardinality_limit: 100000
        dimensions:
        - name: http.method
        - name: cgx.transaction
        - name: cgx.transaction.root
        - name: status_code
        - name: db.namespace
        - name: db.operation.name
        - name: db.collection.name
        - name: db.system
        - name: http.response.status_code
        - name: rpc.grpc.status_code
        - name: service.version
        histogram:
          explicit:
            buckets:
            - 1ms
            - 4ms
            - 10ms
            - 20ms
            - 50ms
            - 100ms
            - 200ms
            - 500ms
            - 1s
            - 2s
            - 5s
        metrics_expiration: 5m
        metrics_flush_interval: '30s'
        namespace: ""
      spanmetrics/compact:
        aggregation_cardinality_limit: 100000
        exclude_dimensions:
        - span.name
        histogram:
          explicit:
            buckets:
            - 1ms
            - 4ms
            - 10ms
            - 20ms
            - 50ms
            - 100ms
            - 200ms
            - 500ms
            - 1s
            - 2s
            - 5s
        metrics_expiration: 5m
        metrics_flush_interval: '30s'
        namespace: compact
      spanmetrics/db:
        aggregation_cardinality_limit: 100000
        dimensions:
        - name: db.namespace
        - name: db.operation.name
        - name: db.collection.name
        - name: db.system
        - name: service.version
        histogram:
          explicit:
            buckets:
            - 100us
            - 1ms
            - 2ms
            - 2.5ms
            - 4ms
            - 6ms
            - 10ms
            - 100ms
            - 250ms
        metrics_expiration: 5m
        metrics_flush_interval: '30s'
        namespace: db
      spanmetrics/db_compact:
        aggregation_cardinality_limit: 100000
        dimensions:
        - name: db.namespace
        - name: db.system
        exclude_dimensions:
        - span.name
        - span.kind
        histogram:
          explicit:
            buckets:
            - 1ms
            - 4ms
            - 10ms
            - 20ms
            - 50ms
            - 100ms
            - 200ms
            - 500ms
            - 1s
            - 2s
            - 5s
        metrics_expiration: 5m
        metrics_flush_interval: '30s'
        namespace: db_compact
    exporters:
      coralogix:
        application_name: otel
        application_name_attributes:
        - k8s.namespace.name
        - service.namespace
        domain: coralogix.com
        domain_settings:
          tls:
            insecure_skip_verify: true
        logs:
          headers:
            X-Coralogix-Distribution: helm-otel-integration/0.0.232
        metrics:
          headers:
            X-Coralogix-Distribution: helm-otel-integration/0.0.232
        private_key: ${env:CORALOGIX_PRIVATE_KEY}
        profiles:
          headers:
            X-Coralogix-Distribution: helm-otel-integration/0.0.232
        subsystem_name: integration
        subsystem_name_attributes:
        - k8s.deployment.name
        - k8s.statefulset.name
        - k8s.daemonset.name
        - k8s.cronjob.name
        - service.name
        timeout: 30s
        traces:
          headers:
            X-Coralogix-Distribution: helm-otel-integration/0.0.232
      coralogix/resource_catalog:
        application_name: resource
        domain: coralogix.com
        logs:
          headers:
            X-Coralogix-Distribution: helm-otel-integration/0.0.232
            x-coralogix-ingress: metadata-as-otlp-logs/v1
        private_key: ${CORALOGIX_PRIVATE_KEY}
        subsystem_name: catalog
        timeout: 30s
      debug: {}
      loadbalancing:
        protocol:
          otlp:
            tls:
              insecure: true
        resolver:
          dns:
            hostname: coralogix-opentelemetry-gateway
        routing_key: traceID
    extensions:
      file_storage:
        directory: /var/lib/otelcol
      health_check:
        endpoint: ${env:MY_POD_IP}:13133
      opamp:
        agent_description:
          include_resource_attributes: true
          non_identifying_attributes:
            cx.agent.type: agent
            cx.cluster.name: eco-system-onlineboutique
            helm.chart.opentelemetry-agent.version: 0.121.6
        server:
          http:
            endpoint: https://ingress.coralogix.com/opamp/v1
            headers:
              Authorization: Bearer ${env:CORALOGIX_PRIVATE_KEY}
            polling_interval: 2m
      pprof:
        endpoint: localhost:1777
      zpages:
        endpoint: localhost:55679
    processors:
      batch:
        send_batch_max_size: 2048
        send_batch_size: 1024
        timeout: 1s
      filter/db_compact_spanmetrics:
        traces:
          span:
          - kind != SPAN_KIND_CLIENT or attributes["db.namespace"] == nil or attributes["db.system"]
            == nil
      filter/db_spanmetrics:
        traces:
          span:
          - attributes["db.system"] == nil
      filter/drop_db_compact_histogram:
        metrics:
          metric:
          - name == "db_compact.duration"
      filter/drop_histogram:
        metrics:
          metric:
          - name == "compact.duration"
      k8sattributes:
        extract:
          metadata:
          - k8s.namespace.name
          - k8s.replicaset.name
          - k8s.statefulset.name
          - k8s.daemonset.name
          - k8s.cronjob.name
          - k8s.job.name
          - k8s.node.name
          - k8s.pod.name
        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
        - sources:
          - from: resource_attribute
            name: k8s.job.name
      memory_limiter:
        check_interval: 5s
        limit_percentage: 80
        spike_limit_percentage: 25
      resource/metadata:
        attributes:
        - action: upsert
          key: k8s.cluster.name
          value: 'eco-system-onlineboutique'
        - action: upsert
          key: cx.otel_integration.name
          value: coralogix-integration-helm
      resourcedetection/entity:
        detectors:
        - system
        - env
        override: false
        system:
          resource_attributes:
            host.cpu.cache.l2.size:
              enabled: true
            host.cpu.family:
              enabled: true
            host.cpu.model.id:
              enabled: true
            host.cpu.model.name:
              enabled: true
            host.cpu.stepping:
              enabled: true
            host.cpu.vendor.id:
              enabled: true
            host.id:
              enabled: true
            host.ip:
              enabled: true
            host.mac:
              enabled: true
            os.description:
              enabled: true
        timeout: 2s
      resourcedetection/env:
        detectors:
        - system
        - env
        override: false
        system:
          resource_attributes:
            host.id:
              enabled: true
        timeout: 2s
      resourcedetection/region:
        detectors:
        - gcp
        - ec2
        - azure
        - eks
        eks:
          node_from_env_var: K8S_NODE_NAME
        override: true
        timeout: 2s
      transform/compact:
        trace_statements:
        - context: resource
          statements:
          - keep_keys(attributes, ["service.name", "k8s.cluster.name", "host.name"])
      transform/compact_histogram:
        metric_statements:
        - context: metric
          statements:
          - extract_sum_metric(false, ".sum") where name == "compact.duration"
          - extract_count_metric(false, ".count") where name == "compact.duration"
          - set(unit, "") where name == "compact.duration.sum"
          - set(unit, "") where name == "compact.duration.count"
          - set(name, "compact.duration.ms.sum") where name == "compact.duration.sum"
          - set(name, "compact.duration.ms.count") where name == "compact.duration.count"
      transform/db_compact:
        trace_statements:
        - context: resource
          statements:
          - keep_keys(attributes, ["service.name", "k8s.cluster.name", "host.name"])
        - context: span
          statements:
          - keep_keys(attributes, ["db.namespace", "db.system"])
      transform/db_compact_histogram:
        metric_statements:
        - context: metric
          statements:
          - extract_sum_metric(false, ".sum") where name == "db_compact.duration"
          - extract_count_metric(false, ".count") where name == "db_compact.duration"
          - set(unit, "") where name == "db_compact.duration.sum"
          - set(unit, "") where name == "db_compact.duration.count"
          - set(name, "db_compact.duration.ms.sum") where name == "db_compact.duration.sum"
          - set(name, "db_compact.duration.ms.count") where name == "db_compact.duration.count"
      transform/entity-event:
        error_mode: silent
        log_statements:
        - context: log
          statements:
          - set(attributes["otel.entity.id"]["host.id"], resource.attributes["host.id"])
          - merge_maps(attributes, resource.attributes, "insert")
        - context: resource
          statements:
          - keep_keys(attributes, [""])
      transform/k8s_attributes:
        log_statements:
        - context: resource
          statements:
          - set(attributes["k8s.deployment.name"], attributes["k8s.replicaset.name"])
          - replace_pattern(attributes["k8s.deployment.name"], "^(.*)-[0-9a-zA-Z]+$",
            "$$1") where attributes["k8s.replicaset.name"] != nil
          - delete_key(attributes, "k8s.replicaset.name")
        metric_statements:
        - context: resource
          statements:
          - set(attributes["k8s.deployment.name"], attributes["k8s.replicaset.name"])
          - replace_pattern(attributes["k8s.deployment.name"], "^(.*)-[0-9a-zA-Z]+$",
            "$$1") where attributes["k8s.replicaset.name"] != nil
          - delete_key(attributes, "k8s.replicaset.name")
        trace_statements:
        - context: resource
          statements:
          - set(attributes["k8s.deployment.name"], attributes["k8s.replicaset.name"])
          - replace_pattern(attributes["k8s.deployment.name"], "^(.*)-[0-9a-zA-Z]+$",
            "$$1") where attributes["k8s.replicaset.name"] != nil
          - delete_key(attributes, "k8s.replicaset.name")
      transform/kubeletstatscpu:
        error_mode: ignore
        metric_statements:
        - context: metric
          statements:
          - set(unit, "1") where name == "container.cpu.usage"
          - set(name, "container.cpu.utilization") where name == "container.cpu.usage"
          - set(unit, "1") where name == "k8s.pod.cpu.usage"
          - set(name, "k8s.pod.cpu.utilization") where name == "k8s.pod.cpu.usage"
          - set(unit, "1") where name == "k8s.node.cpu.usage"
          - set(name, "k8s.node.cpu.utilization") where name == "k8s.node.cpu.usage"
      transform/prometheus:
        error_mode: ignore
        metric_statements:
        - context: metric
          statements:
          - replace_pattern(metric.name, "_total$", "") where resource.attributes["service.name"]
            == "opentelemetry-collector"
          - replace_pattern(metric.name, "^otelcol_process_cpu_seconds_seconds$", "otelcol_process_cpu_seconds")
            where resource.attributes["service.name"] == "opentelemetry-collector"
          - replace_pattern(metric.name, "^otelcol_process_memory_rss_bytes$", "otelcol_process_memory_rss_bytes")
            where resource.attributes["service.name"] == "opentelemetry-collector"
          - replace_pattern(metric.name, "^otelcol_process_runtime_heap_alloc_bytes_bytes$",
            "otelcol_process_runtime_heap_alloc_bytes") where resource.attributes["service.name"]
            == "opentelemetry-collector"
          - replace_pattern(metric.name, "^otelcol_process_runtime_total_alloc_bytes_bytes$",
            "otelcol_process_runtime_total_alloc_bytes") where resource.attributes["service.name"]
            == "opentelemetry-collector"
          - replace_pattern(metric.name, "^otelcol_process_runtime_total_sys_memory_bytes_bytes$",
            "otelcol_process_runtime_total_sys_memory_bytes") where resource.attributes["service.name"]
            == "opentelemetry-collector"
          - replace_pattern(metric.name, "^otelcol_fileconsumer_open_files$", "otelcol_fileconsumer_open_files_ratio")
            where resource.attributes["service.name"] == "opentelemetry-collector"
          - replace_pattern(metric.name, "^otelcol_fileconsumer_reading_files$", "otelcol_fileconsumer_reading_files_ratio")
            where resource.attributes["service.name"] == "opentelemetry-collector"
          - replace_pattern(metric.name, "^otelcol_otelsvc_k8s_ip_lookup_miss$", "otelcol_otelsvc_k8s_ip_lookup_miss_ratio")
            where resource.attributes["service.name"] == "opentelemetry-collector"
          - replace_pattern(metric.name, "^otelcol_otelsvc_k8s_pod_added$", "otelcol_otelsvc_k8s_pod_added_ratio")
            where resource.attributes["service.name"] == "opentelemetry-collector"
          - replace_pattern(metric.name, "^otelcol_otelsvc_k8s_pod_table_size_ratio$",
            "otelcol_otelsvc_k8s_pod_table_size_ratio") where resource.attributes["service.name"]
            == "opentelemetry-collector"
          - replace_pattern(metric.name, "^otelcol_otelsvc_k8s_pod_updated$", "otelcol_otelsvc_k8s_pod_updated_ratio")
            where resource.attributes["service.name"] == "opentelemetry-collector"
          - replace_pattern(metric.name, "^otelcol_otelsvc_k8s_pod_deleted$", "otelcol_otelsvc_k8s_pod_deleted_ratio")
            where resource.attributes["service.name"] == "opentelemetry-collector"
          - replace_pattern(metric.name, "^otelcol_processor_filter_spans\\.filtered$",
            "otelcol_processor_filter_spans.filtered_ratio") where resource.attributes["service.name"]
            == "opentelemetry-collector"
        - context: resource
          statements:
          - set(attributes["k8s.pod.ip"], attributes["net.host.name"]) where attributes["service.name"]
            == "opentelemetry-collector"
          - delete_key(attributes, "service_name") where attributes["service.name"] ==
            "opentelemetry-collector"
        - context: datapoint
          statements:
          - delete_key(attributes, "service_name") where resource.attributes["service.name"]
            == "opentelemetry-collector"
          - delete_key(attributes, "otel_scope_name") where attributes["service.name"]
            == "opentelemetry-collector"
      transform/semconv:
        error_mode: ignore
        trace_statements:
        - context: span
          statements:
          - set(attributes["http.method"], attributes["http.request.method"]) where attributes["http.request.method"]
            != nil
    receivers:
      filelog:
        exclude: []
        force_flush_period: 0
        include:
        - /var/log/pods/*/*/*.log
        include_file_name: false
        include_file_path: true
        operators:
        - id: get-format
          routes:
          - expr: body matches "^\\{"
            output: parser-docker
          - expr: body matches "^[^ Z]+ "
            output: parser-crio
          - expr: body matches "^[^ Z]+Z"
            output: parser-containerd
          type: router
        - id: parser-crio
          regex: ^(?P<time>[^ Z]+) (?P<stream>stdout|stderr) (?P<logtag>[^ ]*) ?(?P<log>.*)$
          timestamp:
            layout: 2006-01-02T15:04:05.999999999Z07:00
            layout_type: gotime
            parse_from: attributes.time
          type: regex_parser
        - combine_field: attributes.log
          combine_with: ""
          id: crio-recombine
          is_last_entry: attributes.logtag == 'F'
          max_batch_size: 1000
          max_log_size: 1048576
          output: handle_empty_log
          source_identifier: attributes["log.file.path"]
          type: recombine
        - id: parser-containerd
          regex: ^(?P<time>[^ ^Z]+Z) (?P<stream>stdout|stderr) (?P<logtag>[^ ]*) ?(?P<log>.*)$
          timestamp:
            layout: '%Y-%m-%dT%H:%M:%S.%LZ'
            parse_from: attributes.time
          type: regex_parser
        - combine_field: attributes.log
          combine_with: ""
          id: containerd-recombine
          is_last_entry: attributes.logtag == 'F'
          max_batch_size: 1000
          max_log_size: 1048576
          output: handle_empty_log
          source_identifier: attributes["log.file.path"]
          type: recombine
        - id: parser-docker
          timestamp:
            layout: '%Y-%m-%dT%H:%M:%S.%LZ'
            parse_from: attributes.time
          type: json_parser
        - combine_field: attributes.log
          combine_with: ""
          id: docker-recombine
          is_last_entry: attributes.log endsWith "\n"
          max_batch_size: 1000
          max_log_size: 1048576
          output: handle_empty_log
          source_identifier: attributes["log.file.path"]
          type: recombine
        - field: attributes.log
          id: handle_empty_log
          if: attributes.log == nil
          type: add
          value: ""
        - parse_from: attributes["log.file.path"]
          regex: ^.*\/(?P<namespace>[^_]+)_(?P<pod_name>[^_]+)_(?P<uid>[a-f0-9\-]+)\/(?P<container_name>[^\._]+)\/(?P<restart_count>\d+)\.log$
          type: regex_parser
        - from: attributes.stream
          to: attributes["log.iostream"]
          type: move
        - from: attributes.container_name
          to: resource["k8s.container.name"]
          type: move
        - from: attributes.namespace
          to: resource["k8s.namespace.name"]
          type: move
        - from: attributes.pod_name
          to: resource["k8s.pod.name"]
          type: move
        - from: attributes.restart_count
          to: resource["k8s.container.restart_count"]
          type: move
        - from: attributes.uid
          to: resource["k8s.pod.uid"]
          type: move
        - from: attributes.log
          id: clean-up-log-record
          to: body
          type: move
        - drop_ratio: 1
          expr: (attributes["log.file.path"] matches "/var/log/pods/monitoring_coralogix-opentelemetry.*_.*/opentelemetry-agent/.*.log")
            and ((body contains "logRecord") or (body contains "ResourceLog"))
          type: filter
        - default: logs-collection-continue
          routes:
          - expr: (body matches "\"resource\":{.*?},?")
            output: parse-body
          type: router
        - id: parse-body
          if: (attributes["log.file.path"] matches "/var/log/pods/monitoring_coralogix-opentelemetry.*_.*/.*/.*.log")
          on_error: send_quiet
          parse_to: attributes["parsed_body_tmp"]
          type: json_parser
        - field: body
          if: (attributes["log.file.path"] matches "/var/log/pods/monitoring_coralogix-opentelemetry.*_.*/.*/.*.log")
          on_error: send_quiet
          regex: \"resource\":{.*?},?
          replace_with: ""
          type: regex_replace
        - from: attributes["parsed_body_tmp"]["resource"]
          if: (attributes["log.file.path"] matches "/var/log/pods/monitoring_coralogix-opentelemetry.*_.*/.*/.*.log")
          on_error: send_quiet
          to: resource["attributes_tmp"]
          type: move
        - field: attributes["parsed_body_tmp"]
          if: (attributes["log.file.path"] matches "/var/log/pods/monitoring_coralogix-opentelemetry.*_.*/.*/.*.log")
          on_error: send_quiet
          type: remove
        - field: resource["attributes_tmp"]
          id: flatten-resource
          if: (attributes["log.file.path"] matches "/var/log/pods/monitoring_coralogix-opentelemetry.*_.*/.*/.*.log")
          on_error: send_quiet
          type: flatten
        - id: logs-collection-continue
          type: noop
        retry_on_failure:
          enabled: true
        start_at: beginning
        storage: file_storage
      hostmetrics:
        collection_interval: '30s'
        root_path: /hostfs
        scrapers:
          cpu:
            metrics:
              system.cpu.utilization:
                enabled: true
          disk: null
          filesystem:
            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/*
              - /run/k3s/containerd/*
              - /run/containerd/runc/*
              - /var/lib/docker/*
              - /var/lib/kubelet/*
              - /snap/*
          load: null
          memory:
            metrics:
              system.memory.utilization:
                enabled: true
          network: null
      jaeger:
        protocols:
          grpc:
            endpoint: ${env:MY_POD_IP}:14250
          thrift_binary:
            endpoint: ${env:MY_POD_IP}:6832
          thrift_compact:
            endpoint: ${env:MY_POD_IP}:6831
          thrift_http:
            endpoint: ${env:MY_POD_IP}:14268
      kubeletstats:
        auth_type: serviceAccount
        collect_all_network_interfaces:
          node: true
          pod: true
        collection_interval: '30s'
        endpoint: ${env:K8S_NODE_IP}:10250
        insecure_skip_verify: true
      otlp:
        protocols:
          grpc:
            endpoint: ${env:MY_POD_IP}:4317
            max_recv_msg_size_mib: 20
          http:
            endpoint: ${env:MY_POD_IP}:4318
      prometheus:
        config:
          scrape_configs:
          - job_name: opentelemetry-collector
            scrape_interval: '30s'
            static_configs:
            - targets:
              - ${env:MY_POD_IP}:8888
      statsd:
        endpoint: ${env:MY_POD_IP}:8125
      zipkin:
        endpoint: ${env:MY_POD_IP}:9411
    service:
      extensions:
      - health_check
      - file_storage
      - opamp
      - zpages
      - pprof
      pipelines:
        logs:
          exporters:
          - coralogix
          processors:
          - memory_limiter
          - resource/metadata
          - resourcedetection/region
          - resourcedetection/env
          - k8sattributes
          - transform/k8s_attributes
          - batch
          receivers:
          - filelog
          - otlp
        logs/resource_catalog:
          exporters:
          - coralogix/resource_catalog
          processors:
          - memory_limiter
          - resource/metadata
          - k8sattributes
          - resourcedetection/entity
          - resourcedetection/region
          - transform/entity-event
          receivers:
          - hostmetrics
        metrics:
          exporters:
          - coralogix
          processors:
          - memory_limiter
          - resource/metadata
          - resourcedetection/region
          - resourcedetection/env
          - k8sattributes
          - transform/kubeletstatscpu
          - transform/k8s_attributes
          - transform/prometheus
          - batch
          receivers:
          - hostmetrics
          - kubeletstats
          - spanmetrics
          - spanmetrics/db
          - prometheus
          - otlp
          - statsd
        metrics/compact:
          exporters:
          - coralogix
          processors:
          - memory_limiter
          - transform/compact_histogram
          - filter/drop_histogram
          - batch
          receivers:
          - spanmetrics/compact
        metrics/db_compact:
          exporters:
          - coralogix
          processors:
          - memory_limiter
          - transform/db_compact_histogram
          - filter/drop_db_compact_histogram
          - batch
          receivers:
          - spanmetrics/db_compact
        traces:
          exporters:
          - loadbalancing
          - spanmetrics
          - forward/db
          - forward/compact
          - forward/db_compact
          processors:
          - memory_limiter
          - resource/metadata
          - resourcedetection/region
          - resourcedetection/env
          - k8sattributes
          - transform/k8s_attributes
          - transform/semconv
          - batch
          receivers:
          - jaeger
          - zipkin
          - otlp
        traces/compact:
          exporters:
          - spanmetrics/compact
          processors:
          - transform/compact
          - batch
          receivers:
          - forward/compact
        traces/db:
          exporters:
          - spanmetrics/db
          processors:
          - filter/db_spanmetrics
          - batch
          receivers:
          - forward/db
        traces/db_compact:
          exporters:
          - spanmetrics/db_compact
          processors:
          - filter/db_compact_spanmetrics
          - transform/db_compact
          - batch
          receivers:
          - forward/db_compact
      telemetry:
        logs:
          encoding: json
          level: 'info'
        metrics:
          level: detailed
          readers:
          - pull:
              exporter:
                prometheus:
                  host: ${env:MY_POD_IP}
                  port: 8888
        resource:
          cx.agent.type: agent
          k8s.daemonset.name: coralogix-opentelemetry
          k8s.namespace.name: monitoring
          k8s.node.name: ${env:KUBE_NODE_NAME}
          k8s.pod.name: ${env:KUBE_POD_NAME}
          service.name: opentelemetry-collector

Log output

Additional context

Rolling back to v0.135.0 with the exact same configuration works as expected. I think the issue is related to #13739, as I couldn't find any other related PRs in the changes between 0.135.0 and 0.136.0.

Tip

React with 👍 to help prioritize this issue. Please use comments to provide useful context, avoiding +1 or me too, to help us triage it. Learn more here.

Metadata

Metadata

Assignees

No one assigned

    Labels

    bugSomething isn't working

    Type

    No type

    Projects

    No projects

    Milestone

    No milestone

    Relationships

    None yet

    Development

    No branches or pull requests

    Issue actions