Telemtra
Sign in Start free
/blog/opentelemetry-collector-receivers
otlp + filelog + hostmetrics + ...
free plan / 1 gb-mo
telemtra.io
// collector

OpenTelemetry Collector receivers:
a practical guide.

The receiver list in opentelemetry-collector-contrib is long. Most teams only need a handful. This is the practical map: what each receiver does, when to reach for it, and a minimal config you can paste into a pipeline that ships to Telemtra.

> Start free ~ Browse blog

The receivers most teams actually use

The OpenTelemetry Collector ships dozens of receivers, but a typical production deployment uses three to five. Knowing which ones cover the common cases saves a lot of time wading through the contrib repo.

otlp

The default receiver. Accepts OTLP HTTP and gRPC from any OpenTelemetry SDK. Use this in every Collector you run; it is the entry point for app-emitted traces, logs, and metrics.

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

filelog

Reads log files from disk, applies parsing operators (regex, JSON, container), and emits OTLP log records. The right tool for tailing application log files, container runtime logs, and host log directories like /var/log.

receivers:
  filelog:
    include: [/var/log/myapp/*.log]
    start_at: end
    operators:
      - type: json_parser
        parse_from: body

hostmetrics

Scrapes the local host for CPU, memory, disk, filesystem, network, load, and process metrics. The OTel equivalent of Prometheus's node_exporter. Use it in every DaemonSet or host-installed Collector.

receivers:
  hostmetrics:
    collection_interval: 30s
    scrapers:
      cpu: {}
      memory: {}
      disk: {}
      filesystem: {}
      network: {}
      load: {}

kubeletstats

Talks to the kubelet stats API and emits per-pod and per-container CPU, memory, network, and volume metrics. Required for accurate per-pod observability in Kubernetes.

receivers:
  kubeletstats:
    collection_interval: 30s
    auth_type: serviceAccount
    endpoint: "https://${env:NODE_NAME}:10250"
    insecure_skip_verify: true

prometheus

Scrapes any Prometheus-format /metrics endpoint and converts to OTLP. The right way to pull from kube-state-metrics, node_exporter, or any third-party exporter you would otherwise scrape with a Prometheus server.

receivers:
  prometheus:
    config:
      scrape_configs:
        - job_name: kube-state-metrics
          static_configs:
            - targets: [kube-state-metrics:8080]

jaeger

Accepts legacy Jaeger Thrift and gRPC traces. Use it during a migration from Jaeger client SDKs to OpenTelemetry SDKs so both kinds of services emit into the same backend.

receivers:
  jaeger:
    protocols:
      thrift_http:
        endpoint: 0.0.0.0:14268
      grpc:
        endpoint: 0.0.0.0:14250

syslog

Accepts syslog over UDP or TCP, RFC3164 or RFC5424. Useful for network devices, OS-level system messages, and legacy services that only know how to ship syslog.

receivers:
  syslog:
    udp:
      listen_address: 0.0.0.0:514
    protocol: rfc5424

k8sevents

Subscribes to the Kubernetes events API and emits each event as an OTLP log record. The fastest way to get "pod failed to schedule," "OOMKilled," and "image pull backoff" into your log search.

receivers:
  k8s_events:
    namespaces: []

docker_stats

Reads per-container stats from the Docker socket. Useful when you run Docker outside Kubernetes and want CPU and memory per container without an in-container exporter.

journald

Reads the systemd journal. Use this instead of filelog on hosts that send everything through journald (the default on most modern Linux distributions).

How to combine receivers in a pipeline

Receivers can be mixed and matched per pipeline. A typical Kubernetes DaemonSet Collector combines four receivers into three pipelines:

service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [memory_limiter, k8sattributes, batch]
      exporters: [otlphttp/telemtra]
    metrics:
      receivers: [otlp, hostmetrics, kubeletstats]
      processors: [memory_limiter, k8sattributes, batch]
      exporters: [otlphttp/telemtra]
    logs:
      receivers: [otlp, filelog, k8s_events]
      processors: [memory_limiter, k8sattributes, batch]
      exporters: [otlphttp/telemtra]

This single Collector handles app-emitted OTLP, container log files, Kubernetes events, node metrics, and pod metrics — and forwards all of it to Telemtra. See OpenTelemetry on Kubernetes for the full DaemonSet manifest.

How to pick which to enable

  • Apps and SDKs → otlp.
  • Files on disk → filelog (or journald on systemd hosts).
  • Linux hosts → hostmetrics.
  • Kubernetes pods → kubeletstats + k8s_events.
  • Prometheus exporters → prometheus.
  • Legacy Jaeger clients → jaeger.
  • Network appliances and OS messages → syslog.

For protocol details see What is OTLP?. For a working starting pipeline, see the Collector quickstart. Start a Telemtra workspace to receive the output.

Further reading