OpenTelemetry Collector Deep Dive

Guangya Liu
6 min readMar 4, 2024


The OpenTelemetry Collector is a core component of the OpenTelemetry project, which aims to provide a comprehensive suite of tools for collecting, processing, and exporting telemetry data (metrics, logs, and traces) in a vendor-agnostic manner. The Collector is designed to be deployed at scale in various environments, including cloud, on-premises, and edge, serving as a central component in the observability infrastructure. Here’s a deep dive into its key features, architecture, and usage:

Key Features

  • Multi-Format Support: It can receive and export data in multiple formats, including but not limited to Prometheus, Jaeger, Zipkin, and OTLP (OpenTelemetry Protocol). This makes it a versatile tool that can integrate with various observability tools and platforms.
  • Processor Capabilities: The Collector can process data before it’s exported. This includes the ability to batch, filter, and transform telemetry data. This processing capability enables users to reduce the volume of data exported, enrich the data, or transform it to meet the needs of downstream services.
  • Multi-Destination Exporting: It can export data to multiple backends simultaneously. This is useful for scenarios where data needs to be sent to different analysis tools or stored in multiple locations for redundancy and analysis.
  • Performance and Scalability: Designed for high performance and scalability, it can handle large volumes of telemetry data with minimal resource consumption. Its architecture supports horizontal scaling to accommodate growing data volumes.


The OpenTelemetry Collector architecture is modular, consisting of Receivers, Processors, Exporters, and Extensions:


Receivers are the entry points for data into the OpenTelemetry Collector. They are responsible for accepting and ingesting telemetry data from various sources. Receivers can support different types of telemetry data, including metrics, logs, and traces. Some receivers collect data over the network, listening for data sent over protocols such as HTTP, gRPC, or UDP, while others collect data from the host machine, such as system metrics or logs.

Types of Receivers: There are two main types of receivers: push-based and pull-based.

  • Push-based receivers accept data sent directly to them from applications or agents.
  • Pull-based receivers periodically fetch data from a source, commonly used for scraping metrics from endpoints that expose data in formats like Prometheus.

Examples: otlp (OpenTelemetry Protocol), jaeger, prometheus, zipkin, and fluentforward are examples of receivers that can ingest data in various formats from different sources.


Processors manipulate, transform, or enrich the data as it flows through the Collector. They can perform a wide range of operations, from simple tasks like batch processing and filtering to more complex manipulations like transforming data formats and adding additional context to telemetry data.

Types of Processors: Processors can be categorized based on their function, such as filtering, modifying, aggregating, or sampling telemetry data.

  • Batch Processor: Batches multiple records together to reduce the number of outgoing operations.
  • Attribute Processor: Adds, removes, or modifies attributes of telemetry data.
  • Sampling Processor: Samples traces based on specified criteria, reducing the volume of data sent to backends.

Chainable: Processors can be chained together in the configuration to perform a sequence of operations on the data before it is exported.


Exporters are responsible for sending processed telemetry data to one or more destinations. These destinations can be analysis tools, observability platforms, storage systems, or any other service capable of receiving and processing telemetry data.

Types of Exporters: Exporters are typically categorized by the type of destination they support, such as logging systems, metrics databases, or tracing backends.

  • Tracing Exporters: Send trace data to tracing tools (e.g., Jaeger, Zipkin).
  • Metrics Exporters: Export metrics to databases or monitoring systems (e.g., Prometheus, InfluxDB).
  • Logging Exporters: Send log data to centralized logging platforms (e.g., Elasticsearch, Splunk).

Multiple Destinations: The Collector configuration can include multiple exporters, allowing data to be sent to different systems simultaneously for redundancy, analysis, or different use cases.


Extensions in the OpenTelemetry Collector offer capabilities that go beyond the core data collection, processing, and exporting functions. These extensions are primarily used for supplementary tasks such as monitoring, health checking, performance management, and advanced configuration. Extensions can significantly enhance the functionality of the Collector, making it more versatile and suitable for complex observability infrastructures. Here’s a closer look at some common types of extensions and their purposes:

Health Check

  • The health check extension provides a way to monitor the health of the OpenTelemetry Collector itself. It typically exposes an HTTP endpoint that returns the current health status of the Collector, indicating whether it is operational or if there are issues affecting its performance. This is crucial for deployment environments where automated systems need to monitor the health of their components and possibly restart or scale them based on their health status.


  • The PProf extension adds the ability to collect profiling data from the Collector. This is particularly useful for diagnosing performance issues and optimizing resource usage. PProf is a tool for visualization and analysis of profiling data. By enabling the PProf extension, developers and operators can access runtime profiling data for the Collector, helping them identify and resolve bottlenecks or inefficiencies.


  • zPages are an extension that provides an HTTP endpoint for dynamic web pages that display trace and metrics data collected by the Collector. This can be very useful for troubleshooting and monitoring the Collector’s operation in real-time. zPages offer insights into the Collector’s processing pipelines, including data about received, processed, and exported data, as well as detailed information about traces.


  • Extensions for observability add support for metrics and logging about the Collector itself. These extensions can be configured to emit metrics and logs that provide insights into the operation of the Collector, such as the volume of data being processed, the performance of individual components (receivers, processors, exporters), and any errors or warnings that occur. This information is invaluable for maintaining and optimizing the Collector.


  • Some extensions enable advanced configuration capabilities, such as dynamic configuration updates. These allow the Collector’s configuration to be updated on the fly without needing to restart the service, enabling more flexible and responsive deployment scenarios. Dynamic configuration can be particularly useful in environments where telemetry data sources or destinations change frequently or where Collector performance tuning is an ongoing task.


  • Storage extensions provide the Collector with capabilities to store data temporarily. This can be useful for buffering or caching data, ensuring that telemetry data is not lost during temporary network outages or when destination services are down. Such extensions can enhance the reliability and fault tolerance of the observability infrastructure.


Configuring the OpenTelemetry Collector involves defining pipelines in a YAML file, where each pipeline consists of a series of receivers, processors, and exporters. A pipeline is defined for each type of telemetry data (metrics, logs, traces) and specifies how data should be ingested, processed, and exported. This flexible configuration system allows users to tailor the Collector to their specific needs, optimizing data flow and integration with their observability stack.

The combination of these components within the OpenTelemetry Collector’s architecture enables it to serve as a powerful and flexible tool for telemetry data collection, processing, and exportation, fitting a wide range of observability requirements.

Deployment Models

The Collector can be deployed in several models, depending on the needs of the observability infrastructure:

  • Agent: Running alongside applications on the same host to collect telemetry data directly.
  • Gateway: Deployed as a standalone service to aggregate and process data from multiple agents or other sources before exporting it to backend systems.
  • Sidecar: Deployed in environments like Kubernetes, running as a sidecar container alongside application containers to collect telemetry data. Configuration

The Collector is highly configurable, allowing users to define the pipelines (receiver, processor, exporter sequences) that match their specific observability needs. Configuration is typically done via YAML files, where users specify the components to be used, their settings, and how they are wired together to form processing pipelines.


The OpenTelemetry Collector is a powerful and flexible tool that plays a crucial role in modern observability infrastructures. Its ability to collect, process, and export telemetry data in a vendor-neutral manner makes it a key enabler for monitoring, troubleshooting, and understanding system performance and health across diverse environments.



Guangya Liu

STSM@IBM, Member - IBM Academy of Technology, Kubernetes Member, Istio Maintainer, Apache Mesos Committer & PMC Member.