Benchmarks / Pipeline Performance Bench

Can a pipeline handle petabytes of data?

7AgentsLogs, metrics, tracesSignals2.5× less CPULogs vs next best4.2× less CPUTail sampling vs next bestNov 12, 2026Updated

Petabyte scale comes down to what each pipeline spends on every log, metric and span. The Pipeline Performance Bench measures that every day. Seven agents run the same pipelines at the same fixed loads, each on its own AWS c8i.2xlarge instance, and the benchmark records the CPU and memory each one uses. An agent passes a load only if it takes in at least 98% of what was offered. The results below are from the run of 12 November 2026, and every raw measurement is public.

Logs: up to 2.5× less CPU than the next best

At 75,000 logs per second the Edge Delta Rust agent uses 1.6 to 2.5× less CPU and 1.7 to 1.9× less memory than Vector, the next most efficient agent, in all four pipelines. Only the Rust agent and Vector sustain every pipeline at 125,000 logs per second, where the Rust agent processes 64,318 logs per second per core against 26,499 for Vector.

CPU cores on Pass-Through at 75,000 logs/sec. Lower is better.

Edge Delta Rust
1.18 cores
Vector
2.94 cores
Bindplane
5.59 cores
OpenTelemetry Collector
5.61 cores
CPU cores and average memory at 75,000 logs/sec
AgentPass-ThroughFilterMaskLookup
Edge Delta Rust1.18 · 54 MB1.70 · 53 MB2.30 · 53 MB1.97 · 63 MB
Vector2.94 · 103 MB3.05 · 101 MB3.74 · 99 MB3.27 · 105 MB
Bindplane5.59 · 188 MBShort (73%)Not runShort (74%)
OpenTelemetry Collector5.61 · 183 MBShort (72%)Not runN/A
Highest load sustained, logs/sec
AgentPass-ThroughFilterMaskLookup
Edge Delta Rust125k125k125k125k
Vector125k125k125k125k
Bindplane75k50k10k50k
OpenTelemetry Collector75k50k10kN/A
Fluent Bit25k25kN/A25k
Fluentd10k10kInconclusiveInconclusive
CriblInconclusiveInconclusiveInconclusiveInconclusive

Short (n%): did not sustain the load and reached n% of it. Not run: skipped after falling short at a lower load. N/A: no supported implementation (the OpenTelemetry Collector ships no CSV lookup processor, and the suite has no Fluent Bit regex mask). Inconclusive: the run below 10,000 logs/sec was flagged as limited by the load generator, which shares the instance with the agent. Logs runs use Edge Delta Rust agent 3.15.2.

Traces: a quarter of the CPU on tail sampling

At 500 OTLP requests per second of 512 spans each, or 256,000 spans per second, all three agents sustain every trace pipeline. The Rust agent uses the least CPU in each one. Tail sampling takes it 0.68 cores and 1.6 GB, against 2.83 cores and 3.5 GB for Bindplane, the next best, so 4.2× less CPU. Across the other trace pipelines it uses 1.4 to 2.0× less CPU than the next best.

CPU cores on tail sampling at 256,000 spans/sec. Lower is better.

Edge Delta Rust
0.68 cores
Bindplane
2.83 cores
OpenTelemetry Collector
2.83 cores
CPU cores and memory at 256,000 spans/sec
AgentPass-ThroughFilterMaskProbabilistic samplingTail sampling
Edge Delta Rust0.35 · 83 MB0.34 · 89 MB0.38 · 77 MB0.36 · 78 MB0.68 · 1,564 MB
Bindplane0.53 · 241 MB0.53 · 242 MB0.54 · 246 MB0.73 · 240 MB2.83 · 3,543 MB
OpenTelemetry Collector0.55 · 242 MB0.56 · 245 MB0.58 · 243 MB0.75 · 243 MB2.83 · 3,644 MB

Agents, load generator and destination run on separate hosts. The destination checks trace identities and parent links, and that only traces with errors survive tail sampling. Traces runs use Edge Delta Rust agent 3.15.2-rc.68, OpenTelemetry Collector 0.162.0 and Bindplane v1.110.1.

Metrics: a third of the CPU on aggregation

At 8,000 OTLP requests per second of 512 points each, or about 4.1 million points per second, forwarding costs about the same for all three agents: across 24 daily runs the Rust agent ranged from 9% more CPU to 33% less on Pass-Through. Processing is where the gap opens. Aggregating across host labels takes the Rust agent 4.08 cores against 13.17 for the OpenTelemetry Collector, the next best, so 3.2× less CPU.

CPU cores on Aggregate at 4.1 million points/sec. Lower is better.

Edge Delta Rust
4.08 cores
OpenTelemetry Collector
13.17 cores
Bindplane
13.89 cores
CPU cores and memory at 4.1 million points/sec
AgentPass-ThroughFilterAggregateRollupAggregate + Rollup
Edge Delta Rust4.86 · 247 MB4.66 · 259 MB4.08 · 198 MB4.61 · 261 MB3.97 · 202 MB
OpenTelemetry Collector4.70 · 286 MB4.94 · 308 MB13.17 · 347 MBShort (21%)Short (25%)
Bindplane4.47 · 322 MB5.18 · 296 MB13.89 · 313 MBShort (21%)Short (29%)

Short (n%): did not sustain the load and reached n% of it. Each agent implements rollup with its own native interval behavior, so output point counts can differ. Metrics runs use Edge Delta Rust agent 3.15.2-rc.68, OpenTelemetry Collector 0.162.0 and Bindplane v1.110.1.

How the benchmark runs

Every agent runs the same pipelines at the same fixed loads, so the only variable is the agent. Fresh agents are installed from their current release channels for every run, and each run publishes a dated release with the report, raw measurements, configurations and checksums.

  • →One AWS c8i.2xlarge instance (8 vCPUs, 16 GiB, Ubuntu 24.04) per agent, all agents in parallel.
  • →Logs: JSON over HTTP at 10k, 25k, 50k, 75k and 125k logs/sec. The load generator shares the instance with the agent.
  • →Metrics: OTLP/gRPC at 1k to 8k requests/sec of 512 points. Traces: OTLP/gRPC at 100 to 500 requests/sec of 512 spans.
  • →For metrics and traces the load generator and destination run on their own hosts, and the destination verifies the output.
  • →Shortfalls stay visible in the data and are never reported as zero.
SignalPipelineWhat it does
LogsPass-ThroughReceive JSON logs over HTTP and forward them unchanged.
LogsFilterDrop events whose pii.color is Green.
LogsMaskMask PII such as IP addresses, emails and card numbers with regexes.
LogsLookupMatch pii.ipv4 against a shared CSV and add region and env.
MetricsAggregateSum points across host labels.
MetricsRollupCombine points into 60-second intervals.
MetricsAggregate + RollupBoth steps in one pipeline.
TracesProbabilistic samplingKeep a fixed share of traces.
TracesTail samplingWait for whole traces and keep only those with errors.

Key findings

  • →Logs: the Edge Delta Rust agent uses 1.6 to 2.5× less CPU than Vector, the next best, in all four pipelines at 75,000 logs/sec, and processes 2.4× more logs per core at 125,000 logs/sec.
  • →Traces: tail sampling costs the Rust agent 0.68 cores against 2.83 for the next best, 4.2× less CPU and less than half the memory.
  • →Metrics: aggregation costs the Rust agent 4.08 cores against 13.17 for the next best, 3.2× less CPU. Pass-through costs about the same for all three agents.
  • →The gaps hold from day to day. Across 13 daily logs runs the Rust agent used 1.5 to 2.6× less CPU than Vector, and across 24 daily metrics and traces runs it used 3.7 to 4.7× less on tail sampling and 3.2 to 4.3× less on aggregation than the next best.

Put a real AI Teammate on call

Edge Delta's AI Teammates triage, investigate, and find root cause in your stack.