Alloy vs OpenTelemetry Collector vs Vector
- Same engine, different chassis
- Vector: a different engine
- Feature comparison
- The same pipeline in both
- Decision table
- Name mapping
- Running both
- Related lessons
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: blockpushes 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, nobatchprocessor. 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: trueis required for OTLP → OTLP. Without it the config still passesvector 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
transformthat 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_*andvector_component_errors_totalinstead ofotelcol_*. 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).
Related lessons
- Pipeline model
- Topologies on Kubernetes
- Collecting Azure metrics and logs — Alloy vs azure-metrics-exporter vs Vector for Azure
- OTel Architecture