Collector Architecture

Collector Overview

The OpenTelemetry Collector is a vendor-agnostic proxy that receives, processes, and exports telemetry. It decouples your application from backend-specific configuration. Deploy it as a sidecar, node agent, or dedicated cluster.

Receivers -> Processors -> Exporters
   |              |             |
OTLP/gRPC    Batch/Filter   Prometheus
OTLP/HTTP    Transform      Tempo
Zipkin       Memory Limit   Loki
Jaeger       Attributes     Kafka

Components

The Collector is built from composable components. Receivers ingest telemetry, processors transform it, exporters send it to backends, and extensions provide optional functionality like health checks and profiling.

Receivers

Receivers accept telemetry in various formats. The OTLP receiver is the standard. Additional receivers include Prometheus, Zipkin, Jaeger, and Kafka. You can configure multiple receivers to accept telemetry from different sources.

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318

  prometheus:
    config:
      scrape_configs:
        - job_name: 'otel-collector'
          static_configs:
            - targets: ['localhost:8888']

Processors

Processors modify telemetry between receivers and exporters. Common processors batch data for efficiency, filter unwanted signals, add metadata, and limit memory usage. Processors are optional but highly recommended.

processors:
  batch:
    timeout: 5s
    send_batch_size: 1000

  memory_limiter:
    check_interval: 1s
    limit_mib: 512
    spike_limit_mib: 128

  attributes:
    actions:
      - key: deployment.environment
        value: production
        action: upsert

Exporters

Exporters send telemetry to backends. Each exporter targets a specific backend. Configure multiple exporters to send the same telemetry to different backends simultaneously.

exporters:
  otlp/tempo:
    endpoint: tempo:4317
    tls:
      insecure: true

  prometheusremotewrite:
    endpoint: "http://mimir:9009/api/v1/push"

  loki:
    endpoint: "http://loki:3100/loki/api/v1/push"

Pipelines

Pipelines connect receivers to exporters through processors. Each pipeline defines the flow for a specific signal type (traces, metrics, logs). A receiver can feed multiple pipelines, and an exporter can receive from multiple pipelines.

service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [memory_limiter, batch]
      exporters: [otlp/tempo]

    metrics:
      receivers: [otlp, prometheus]
      processors: [memory_limiter, batch]
      exporters: [prometheusremotewrite]

    logs:
      receivers: [otlp]
      processors: [memory_limiter, batch]
      exporters: [loki]

Extensions

Extensions provide optional functionality that does not process telemetry directly. Common extensions include health checks, performance profiling, and bearer token authentication.

extensions:
  health_check:
    endpoint: 0.0.0.0:13133
  pprof:
    endpoint: 0.0.0.0:1777
  zpages:
    endpoint: 0.0.0.0:55679

service:
  extensions: [health_check, pprof, zpages]