Alloy vs OpenTelemetry Collector vs Vector

Alloy is Grafana’s distribution of the OpenTelemetry Collector with its own configuration language and a native Prometheus/Loki/Pyroscope pipeline next to the OTel one.

In the otelcol.* layer both run the same upstream Go code. Comparing their CPU or memory for OTLP processing measures noise.

Vector is the third option: a separate Rust engine from Datadog that shares no code with either. For Vector, OTLP is one input format among many.

Same engine, different chassis

The real differences are:

  • Component catalog — which receivers, processors and exporters exist.
  • Lifecycle — how config is loaded, reloaded and managed across a fleet.
  • Operations tooling — UI, clustering, remote config.

Vector: a different engine

  • Own data model. Events are logs, metrics or traces in Vector’s internal format. OTLP is decoded on the way in and re-encoded on the way out.
  • Logs first. Parsing and reshaping in VRL (remap), plus a large catalog of log sinks. Metrics are solid. Traces are the thinnest signal, and there are no profiles.
  • Buffers instead of a memory limiter. Each sink has a memory or disk buffer. when_full: block pushes backpressure to the source. End-to-end acknowledgements hold the source ack until the sink has delivered.
  • Still versioned 0.x (v0.58.0 at the time of writing).

Feature comparison

Feature OpenTelemetry Collector Grafana Alloy Vector
Project CNCF, vendor-neutral Grafana Labs, Apache 2.0 Datadog (ex-Timber.io), MPL 2.0, Rust
Config YAML; wiring in service.pipelines Alloy syntax; wiring by references YAML / TOML / JSON; each component lists its inputs
Signals Traces, metrics, logs (profiles in development) Traces, metrics, logs, profiles (pyroscope.*) Logs, metrics; traces via opentelemetry / datadog_traces; no profiles
Transforms OTTL (transform processor) OTTL (otelcol.processor.transform), loki.process, prometheus.relabel VRL (remap), with a vector vrl REPL
Prometheus scraping prometheus receiver (converts to OTLP) Native prometheus.scrape, ServiceMonitor/PodMonitor CRDs (prometheus.operator.*) prometheus_scrape with a static endpoints list; no service discovery, no CRDs
Component catalog Full contrib (hundreds of components); ocb builds a minimal binary Curated subset of contrib wrapped as otelcol.*, plus Alloy-only components Own catalog: 51 sources, 18 transforms, 64 sinks (v0.58.0); shares nothing with contrib
Trace tail sampling tail_sampling, loadbalancing otelcol.processor.tail_sampling, otelcol.exporter.loadbalancing None (sample is per event, not per trace)
Buffering memory_limiter + exporter sending_queue (optionally on file_storage) Same via otelcol.*; WAL in prometheus.remote_write Per-sink buffer (memory or disk), when_full: block or drop_newest; end-to-end acks
Stability gating Per component (feature gates) Per process (--stability.level) None; status is documented per component
Reload Restart (or OpAMP Supervisor) /-/reload; local.file, remote.kubernetes.secret, remote.vault re-evaluate live SIGHUP or --watch-config; an invalid config aborts the reload and the old one keeps running
Remote config OpAMP + Supervisor remotecfg block, Grafana Fleet Management None in OSS (Datadog Observability Pipelines is built on Vector)
Clustering None built in; shard with the Target Allocator (Operator) Built in: gossip + consistent hashing of scrape targets None; stateless aggregators behind a load balancer
Debug UI None (zPages, logs) Component graph, health, live debugging on :12345 No UI; vector top, vector tap (live events) over the API on :8686
Config tests validate alloy validate vector validate + vector test (unit tests with input fixtures, experimental)
Reusable modules — declare, import.git, import.file — (--config-dir merges files)
Config conversion — alloy convert --source-format=... (otelcol, prometheus, promtail) — one way, into Alloy convert-config only between YAML, TOML and JSON

Components that exist in contrib but not in Alloy v1.16.1 (checked with alloy validate): otelcol.exporter.elasticsearch, otelcol.connector.routing. Both loadbalancing and tail_sampling are available.

The same pipeline in both

OpenTelemetry Collector (YAML):

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: "0.0.0.0:4317"

processors:
  memory_limiter:
    check_interval: 1s
    limit_percentage: 80
    spike_limit_percentage: 20
  batch:
    timeout: 5s

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

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

Grafana Alloy:

otelcol.receiver.otlp "default" {
  grpc {
    endpoint = "0.0.0.0:4317"
  }
  output {
    traces = [otelcol.processor.memory_limiter.default.input]
  }
}

otelcol.processor.memory_limiter "default" {
  check_interval         = "1s"
  limit_percentage       = 80
  spike_limit_percentage = 20
  output {
    traces = [otelcol.processor.batch.default.input]
  }
}

otelcol.processor.batch "default" {
  timeout = "5s"
  output {
    traces = [otelcol.exporter.otlp.tempo.input]
  }
}

otelcol.exporter.otlp "tempo" {
  client {
    endpoint = "tempo:4317"
    tls {
      insecure = true
    }
  }
}

Field names drift between the two: limit_mib in YAML is limit (a size string) in Alloy, and spike_limit_mib is spike_limit.

Vector (YAML):

sources:
  otlp:
    type: opentelemetry
    grpc:
      address: "0.0.0.0:4317"
    http:
      address: "0.0.0.0:4318"
    use_otlp_decoding: true

sinks:
  tempo:
    type: opentelemetry
    inputs: [otlp.traces]
    protocol:
      type: http
      uri: "http://tempo:4318/v1/traces"
      encoding:
        codec: otlp
    batch:
      timeout_secs: 5
    buffer:
      type: memory
      max_events: 10000
      when_full: block
  • No memory_limiter, no batch processor. Batching and the memory bound are sink settings.
  • inputs: [otlp.traces]. The source has one named output per signal. Outputs with no consumer only produce a warning.
  • use_otlp_decoding: true is required for OTLP → OTLP. Without it the config still passes vector validate, but at runtime the sink drops every trace: Trace event does not contain OTLP top-level field (resourceSpans). Measured on v0.58.0 with telemetrygen → Vector → Collector.

Decision table

Situation Pick Why
You need a component Alloy does not wrap (Elasticsearch exporter, routing connector, a niche receiver) Collector The only hard technical argument
“GA only in production” policy, but one pipeline needs a preview component Collector Alloy’s --stability.level lowers the bar for the whole process; the Collector gates per component
You patch config with kustomize / yq, or template it from another system Collector Plain YAML
Minimal image, minimal attack surface Collector (ocb build) Only the components you list are compiled in
Grafana backends (Mimir, Loki, Tempo, Pyroscope) Alloy Native writers, profiles
Prometheus scraping at scale, ServiceMonitors already exist Alloy Native scrape, CRD support, built-in target sharding
Secrets or config must change without a restart Alloy local.file / remote.kubernetes.secret re-evaluate live
Central config management for a fleet Alloy (remotecfg) or Collector + OpAMP Supervisor Both manage config, not binaries
Logs from pods without hostPath Alloy loki.source.kubernetes tails through the API
eBPF auto-instrumentation, DB observability Alloy beyla.ebpf, database_observability.*
Log pipeline with heavy parsing into non-Grafana sinks (Elasticsearch, ClickHouse, S3, Kafka, Splunk) Vector VRL, a large log sink catalog, disk buffers
The source must not ack before delivery (Kafka, S3/SQS, HTTP push) Vector End-to-end acknowledgements
Pipeline changes must pass unit tests in CI Vector vector test runs fixtures through transforms
Traces with tail sampling, Prometheus service discovery, profiles Not Vector None of these exist in Vector

Name mapping

OTel Collector Alloy Vector
health_check extension /-/healthy, /-/ready on the HTTP server /health on the API (api.enabled: true, :8686)
file_storage extension otelcol.storage.file (public preview in v1.16) buffer.type: disk on the sink (needs data_dir)
bearertokenauth otelcol.auth.bearer auth.strategy: bearer on the sink
headers_setter otelcol.auth.headers request.headers on the sink
pprof extension /debug/pprof on the HTTP server —
:8888/metrics (internal telemetry) :12345/metrics internal_metrics source → prometheus_exporter sink (:9598)
debug exporter otelcol.exporter.debug (experimental) console sink, or vector tap
prometheusremotewrite exporter otelcol.exporter.prometheus → prometheus.remote_write prometheus_remote_write sink

Running both

A two-tier setup (Alloy agents → Collector gateway, or the other way round) is common and fine. Costs to plan for:

  • Two embedded OTel versions. OTTL functions and processor defaults can differ between tiers. A transform that works on one may not parse on the other.
  • Two metric naming conventions for self-monitoring. Alloy exposes otelcol_*_total; older Collectors expose the same counters without _total (lesson 09).
  • Two upgrade cadences. Alloy ships a minor release roughly every three weeks and bumps its embedded Collector and Prometheus with it.

Adding Vector (for example Vector for logs next to Alloy or a Collector for traces and metrics) adds:

  • A third self-monitoring namespace. vector_component_sent_events_total, vector_buffer_* and vector_component_errors_total instead of otelcol_*. Error counters appear only after the first error, so an empty result does not prove zero errors.
  • A lossy OTLP hop by default. Vector ↔ Collector over OTLP needs use_otlp_decoding: true. Otherwise the sink drops events (see above).

results matching ""

    No results matching ""