Skip to content

Debugging Observability Pipelines: OTCA practice questions

Keeping a telemetry pipeline healthy means being able to tell where data stops.

By Ibrahim Yesilay · Published · Updated

Independent community practice, not affiliated with or endorsed by CNCF or The Linux Foundation.

What Debugging Observability Pipelines covers in OTCA

Keeping a telemetry pipeline healthy means being able to tell where data stops. The Collector documentation suggests walking the path hop by hop and asking the same questions at each one: what the logs say, how data is received and modified, how it is exported, in which format, how the next hop is configured, and whether network policies block traffic in or out.

The Collector reports on itself. Its internal metrics are exposed in Prometheus format on port 8888 by default, at a verbosity of none, basic, normal or detailed, with normal as the default, and its logs go to stderr at INFO unless the level is changed under service.telemetry. A few metrics answer most questions. otelcol_receiver_accepted_spans (and the equivalents for metric points and log records) counts what entered a pipeline, while otelcol_receiver_refused_spans counts what could not be pushed in. otelcol_exporter_sent_spans counts successful sends and otelcol_exporter_send_failed_spans counts failed attempts, which do not mean data loss by themselves because a retry may succeed. otelcol_exporter_enqueue_failed_spans counts data that never reached the sending queue, and otelcol_exporter_queue_size against otelcol_exporter_queue_capacity shows how full the queue is. A persistent gap between accepted and sent data means data is being lost or held back.

For direct inspection, the debug exporter prints what passes through, and verbosity: detailed prints whole payloads; sending a test payload through it confirms that receiving, processing and exporting work. The zpages extension, on port 55679 locally, shows live data from receivers and exporters, and its TraceZ page helps with latency and stuck spans. The pprof extension on port 1777 profiles a running Collector, and otelcol components lists the components in a distribution with their stability.

Typical symptoms have typical causes. No data received points at network settings, the client and receiver configuration, or a receiver that is configured but not listed in any pipeline. Data that is not exported points at firewalls, DNS or proxies, the exporter configuration, or an unavailable destination. Dropped data usually means an undersized Collector or a destination that is down or slow. A Collector that exits or restarts is often under memory pressure, for example from a missing memory_limiter processor, a queue that is too large, or container limits.

Resilience is configured on exporters. The sending queue buffers data in memory, retry_on_failure retries with exponential backoff for up to five minutes by default, and once the queue is full new data is dropped to protect memory. Pointing the queue at the file_storage extension turns it into a write-ahead log on disk that survives restarts. Data is still lost if the destination is down longer than the retry window, the queue fills, or the Collector crashes with only an in-memory queue.

Scaling decisions follow from the same signals. Refusals from the memory_limiter, visible as otelcol_processor_refused_spans, and a queue staying above roughly 60 to 70 percent of capacity suggest more instances; a rising send failure count suggests the backend, where more Collectors would only make things worse. On the SDK side, metric views can drop attributes that are not needed before data ever leaves the application.

Key points

  • Internal Collector metrics are served on port 8888 by default.
  • Comparing accepted and sent counts shows whether data is lost inside the Collector.
  • A full sending queue drops new data; file_storage makes the queue persistent across restarts.
  • Rising exporter send failures point to the backend, where adding Collectors does not help.

Three sample questions

11 OTCA questions on Debugging Observability Pipelines, 11 with explanations. How practice works

Question 1

Which method can help reduce high-cardinality issues in OpenTelemetry metrics?
  1. A.Using more labels in every metric
  2. B.Removing all labels from traces
  3. C.Avoiding unique identifiers in label values
  4. D.Storing metrics in JSON format

Correct answer: C

Unique values (e.g., user IDs) increase **cardinality**, causing performance issues.

Question 2

What is one common cause of missing spans in distributed traces?
  1. A.Logs not being formatted correctly
  2. B.Context propagation being broken between services
  3. C.Not enough CPU resources being allocated
  4. D.Using an incorrect database schema

Correct answer: B

**Missing spans** often result from **incorrect trace context propagation**.

Question 3

How can schema management benefit an OpenTelemetry deployment?
  1. A.It ensures backward compatibility when renaming metrics
  2. B.It compresses logs for better storage efficiency
  3. C.It prevents OpenTelemetry from exporting traces
  4. D.It enables dynamic service discovery

Correct answer: A

**Schema management** prevents breaking queries when renaming metrics.

Practice this topic

Focus mode keeps every question on Debugging Observability Pipelines until you leave it. 10 free guest answers, then a free account; no credit card.

Or open OTCA practice across all topics.

Sources

The explanation above was checked against these official documents.

Frequently asked questions

Does otelcol_exporter_send_failed_spans mean spans were lost?

Not necessarily. It counts failed send attempts, and the retry mechanism may still deliver the data. Loss shows up as enqueue failures, a full queue, or a lasting gap between accepted and sent counts.