Observabilityintermediate

Fluent Bit vs Vector

Fluent Bit vs Vector compared for 2026: Fluent Bit 5.2, the C-based CNCF telemetry agent with 100+ built-in plugins, OTLP, filesystem buffering, a dead letter queue and Lua scripting, vs Vector 0.62, Datadog's Rust pipeline with VRL, config unit tests, disk buffers and end-to-end acknowledgements. Includes a Vector test we ran, sizing guidance, retry defaults, release cadence and a clear pick per situation.

Quick Answer

Fluent Bit and Vector both collect, transform and route logs and metrics, and both work as a per-node agent or a central aggregator. Fluent Bit (Apache-2.0, a CNCF graduated project under the Fluentd umbrella) is written in C, ships more than 100 built-in plugins, handles logs, metrics, traces and profiles with native OTLP, and is built for small footprints: the project quotes about 450 KB of memory and zero dependencies. Version 5.2.0 (9 November 2026) added Fluent Typed Scripting, a typed Lua processor. Vector (MPL-2.0, maintained by Datadog) is written in Rust and is built around VRL, a transform language that refuses to start if an expression can fail unhandled, plus config unit tests, disk buffers and end-to-end acknowledgements; logs and metrics are stable, traces are limited to some components. Vector 0.62.0 shipped on 16 November 2026 and is still pre-1.0, so minor releases carry breaking changes. In our test Vector's VRL check caught an unsafe route condition before the pipeline started. Pick Fluent Bit for lightweight node agents, embedded and edge devices, and OpenTelemetry-heavy setups; pick Vector for aggregators where complex, tested transformations and delivery guarantees matter more than memory.

Last updated November 17, 2026. Covers Fluent Bit 5.2.0 (9 November 2026), 5.1.5 and 5.0.11 with the current manual (what is Fluent Bit, Fluentd comparison, what's new in v5, upgrade notes, buffering, backpressure, dead letter queue, retries, hot reload, monitoring, multithreading, processors, stream processing, configuration, downloads) against Vector 0.62.0 (16 November 2026) with the docs (architecture, buffering model, guarantees, end-to-end acknowledgements, sizing, deployment roles, management, API, configuration, sources/sinks/transforms references, release notes), all read on 17 November 2026, plus a Vector pipeline and unit test we ran the same day.

Feature comparison of Fluent Bit vs Vector
FeatureFluent BitVector
Licence & Governance
Apache-2.0; CNCF graduated (Fluentd umbrella)
MPL-2.0; maintained by Datadog
Implementation
C, single binary
Rust, single binary
Signals Supported
Logs, metrics, traces, profiles
Logs and metrics (stable); traces in selected components
OpenTelemetry (OTLP)
Native OTLP input and output; OpenTelemetry envelope and journald-OTel processors
OpenTelemetry source (logs, metrics, traces) and OTLP-capable sinks
Inputs / Outputs / Transforms
100+ built in (~49 inputs, ~54 outputs, ~22 filters, ~10 processors)
47 sources, 62 sinks, 18 transforms in the reference docs
Transformation Language
Filters and processors (content modifier, labels, sampling, SQL, FTS typed Lua)
VRL (remap) with compile-time error checking and a large function library
Scripting & Extensions
Lua filter, Fluent Typed Scripting processor, WASM filters/inputs, Go output plugins
Lua transform; VRL everywhere conditions are used
SQL / Stream Processing
Stream processor (streaming SQL with aggregation) and inline SQL processor
No SQL engine; aggregate, reduce, window and log_to_metric transforms
Configuration Format
YAML (standard since 3.2); classic .conf deprecated end of 2026
YAML, TOML or JSON
Config Validation & Tests
--dry-run config validation; no built-in unit tests
vector validate plus config unit tests (vector test)
Buffering
Memory, memory ring buffer (drops oldest) or filesystem hybrid via mmap; ~2 MB chunks
In-memory per component (500 events at sinks by default) or disk buffers
Delivery Guarantees
Retries with exponential backoff; at-least-once with filesystem storage
End-to-end acknowledgements; at-least-once or best-effort per component
Retry Defaults
Retry_Limit default 1; scheduler.base 5 s, scheduler.cap 2000 s
Per-sink request retries with backoff (sink-specific settings)
Failed Data Handling
Dead letter queue: rejected chunks copied to storage.rejected.path, size-limited
No DLQ; disk buffers keep events through restarts
Backpressure
mem_buf_limit pauses inputs; storage.max_chunks_up; per-input rate gate (5.1+)
Propagates from sinks through transforms to sources and HTTP clients
Concurrency Model
Main event loop; threaded inputs and output workers; processors run in plugin threads
Async runtime using all available cores; adaptive request concurrency
Hot Reload
Hot reload via SIGHUP or HTTP endpoint (--enable-hot-reload)
SIGHUP reload; --watch-config (inotify or poll)
Self-monitoring
HTTP server: /api/v2/metrics/prometheus, /api/v2/health, storage metrics
internal_metrics and internal_logs sources; gRPC observability API
Footprint
~450 KB memory per project docs (not measured by us)
166.6 MB binary; ~84 MB RSS for a small pipeline (our test)
Published Sizing Guidance
No per-vCPU throughput table in the docs
~10-25 MiB/s/vCPU, 2 GiB memory per vCPU; agent ≥2 vCPU, aggregator ≥4 vCPU
Platforms
Linux (incl. Buildroot/Yocto/Raspbian), macOS, Windows, containers
Linux (many distros and package managers), macOS, Windows, Docker
Kubernetes
DaemonSet via Helm/manifests; Kubernetes filter and Kubernetes events input
Helm, kubectl or Vector Operator; agent and aggregator roles; kubernetes_logs source
Release Cadence & Stability
Frequent minors; 5.2.0 on 9 Nov 2026, patch lines for 5.1 and 5.0
Minor every 2-6 weeks (0.59 to 0.62 in Oct-Nov 2026); pre-1.0
Commercial Backing
Enterprise providers for EOL versions and CVE backports (listed on fluentbit.io)
Datadog Observability Pipelines builds on Vector (separately priced)
Latest Release (Nov 2026)
5.2.0 (9 Nov 2026); 5.1.5 (21 Oct 2026)
0.62.0 (16 Nov 2026)

Fluent Bit

Fluent Bit is an open-source telemetry agent written in C that collects, processes and forwards logs, metrics, traces and profiles. It started in 2014 at Treasure Data as a lightweight sibling of Fluentd for embedded Linux and is now a CNCF graduated project under the Fluentd umbrella. It runs as an edge agent or a central aggregator, speaks OTLP natively, and its docs note that cloud providers have moved from Fluentd to Fluent Bit for performance and compatibility.

Pros

  • Very small footprint: the project quotes about 450 KB of memory and zero dependencies unless a plugin needs one
  • More than 100 built-in plugins (roughly 49 inputs, 54 outputs and 22 filters in the current docs) with no plugin install step
  • Handles logs, metrics, traces and profiles, with native OTLP ingestion and delivery
  • Filesystem buffering with a dead letter queue (storage.keep.rejected) for chunks that fail permanently
  • Runs on embedded Linux (Buildroot, Yocto, Raspberry Pi), all major Linux distros, macOS, Windows and containers
  • Several maintained release lines at once (5.2, 5.1, 5.0 and 4.2 all had releases in 2026)

Cons

  • Default Retry_Limit is 1: a chunk that fails twice is dropped unless you raise it or set no_limits
  • Transformations are spread across filters, processors, Lua, WASM and SQL rather than one typed language; no built-in config unit tests
  • Processors and many newer features need YAML; classic .conf files are slated for deprecation at the end of 2026
  • Memory-only buffering can lose data at mem_buf_limit for some inputs; durability needs filesystem storage configured
  • Filters always run on the main thread, so heavy filter chains can bottleneck a single core

Best For

Per-node log and metric agents on Kubernetes and VMs, embedded and edge devices, and OpenTelemetry pipelines where low memory and broad built-in integrations matter most.

Vector

Vector is an open-source observability data pipeline written in Rust and maintained by Datadog's Community Open Source Engineering team. It deploys as a daemon, sidecar or aggregator, connects sources to sinks through transforms in a directed acyclic graph, and centres transformation on VRL (Vector Remap Language). Logs and metrics are stable; trace support exists in selected components such as the OpenTelemetry source.

Pros

  • VRL catches unhandled errors at load time, so a fallible transform or route condition fails validation instead of failing at 3 a.m.
  • Unit tests live in the config and run with vector test, which suits code review and CI
  • Disk buffers act like a write-ahead log, and end-to-end acknowledgements let sources wait for sinks before acking
  • Published sizing guidance: about 10 MiB/s per vCPU for unstructured logs and 25 MiB/s for structured logs
  • Rich routing and shaping: route, exclusive_route, dedupe, reduce, sample, throttle, log_to_metric, aggregate
  • Accepts Fluent Bit and Fluentd traffic through its fluent source, so it can sit behind existing agents

Cons

  • Still pre-1.0: each minor can carry breaking changes (0.62.0 had six) and the docs advise stepping through minors
  • Much larger binary: 166.6 MB for linux-amd64 0.62.0, and about 84 MB RSS for a tiny pipeline in our test
  • Traces are limited to some components; no profiles signal
  • Disk buffers have a minimum size of about 256 MiB each
  • The observability API has no authentication and must not be exposed to untrusted clients

Best For

Central aggregators and complex pipelines that parse, enrich, sample, reduce and fan out logs and metrics, where tested transformations and delivery guarantees are worth more memory and CPU.

Design: a tiny C agent versus a Rust pipeline built around VRL

Fluent Bit began in 2014 at Treasure Data as a lightweight Fluentd for embedded Linux and gateways, and that origin still shows. It is written in C, the docs quote about 450 KB of memory and zero dependencies unless a plugin needs one, and it ships more than 100 plugins in the binary; the current documentation index lists roughly 49 inputs, 54 outputs and 22 filters. Data flows input, parser, filter, buffer, router, output, and newer processors attach directly to inputs and outputs in YAML. It covers logs, metrics, traces and profiles and speaks OTLP natively. Vector is written in Rust and models a pipeline as a directed acyclic graph of sources, transforms and sinks: 47 sources, 62 sinks and 18 transforms in the reference docs. Its centre of gravity is the remap transform and VRL, a small expression language with a large function library and one important property: any expression that can fail must be handled, or the configuration does not load. Logs and metrics are stable in Vector; traces are supported only in selected components such as the OpenTelemetry source. In practice, Fluent Bit wins on breadth of built-in collection and on footprint, while Vector wins on how safely and readably you can express complex transformation logic.

Durability: buffers, retries, acknowledgements and lost data

This is where defaults bite. Fluent Bit groups records into chunks of about 2 MB and buffers them in memory, in a memory ring buffer that drops the oldest chunks when full, or in filesystem mode, which keeps a copy of every chunk on disk through mmap. With memory-only buffering, mem_buf_limit pauses an input when reached, and the docs warn some inputs can lose data there. Each output retries with exponential backoff (scheduler.base 5 seconds, scheduler.cap 2000 seconds), but Retry_Limit defaults to 1, so a chunk is discarded after one failed retry unless you raise the limit or set no_limits. A dead letter queue can keep rejected chunks on disk, capped by storage.rejected.limit. Vector puts a small in-memory buffer between every pair of components (typically 100 events, 500 at sinks) and lets you replace a sink's buffer with a disk buffer that behaves like a write-ahead log, checksums events and survives restarts; each disk buffer needs at least about 256 MiB. End-to-end acknowledgements let a source such as HTTP or Kafka hold its acknowledgement until every connected sink has delivered or durably buffered the event, and the worst status across fan-out wins. Vector documents each component as at-least-once or best-effort. Fluent Bit can be made durable, but Vector makes the guarantee explicit per component.

Transformations, testing and day-two operations

In Fluent Bit you shape data with filters (Grep, Modify, Nest, Record modifier, Rewrite tag, Kubernetes, Lua, Wasm and more), YAML processors such as content modifier, labels, sampling and SQL, the streaming SQL engine for aggregations, a Lua filter, WASM filter and input plugins, and Go output plugins. Version 5.2 added Fluent Typed Scripting, a Lua processor with typed access to logs, metrics and traces that preserves integer widths and nanosecond timestamps. That is powerful but spread across several mechanisms, and testing means running the pipeline with --dry-run or sample data. Vector concentrates the same work in VRL and adds route, exclusive_route, dedupe, reduce, sample, throttle, aggregate and log_to_metric transforms, with a Lua transform as an escape hatch. Tests are part of the config: you inject an event at a transform and assert on what comes out, then run vector test in CI. Both reload without a restart: Fluent Bit on SIGHUP or an HTTP endpoint with hot reload enabled, Vector on SIGHUP or automatically with --watch-config. Both export their own metrics: Fluent Bit at /api/v2/metrics/prometheus with a JSON health endpoint, Vector through internal_metrics and internal_logs sources. Vector's gRPC API has no authentication, so keep it on localhost. Fluent Bit's classic .conf format is being deprecated at the end of 2026, so new configs should be YAML.

Footprint, sizing, platforms and upgrades

Fluent Bit is the clear choice when resources are scarce: besides Linux distributions, macOS, Windows and containers, the docs cover Buildroot and Yocto embedded Linux and Raspberry Pi. We could not run it in our sandbox this time, so its 450 KB figure is the project's claim. Vector's binary for linux-amd64 0.62.0 is 166.6 MB, and a two-component test pipeline sat at about 84 MB resident on our 2-vCPU sandbox. In return, Vector publishes concrete sizing: roughly 10 MiB/s per vCPU for unstructured logs and about 25 MiB/s for structured logs, metrics and spans, 2 GiB of memory per vCPU as a starting point, at least 2 vCPUs for agents and 4 for aggregators, and enough disk for about 10 minutes of data behind each disk-buffered sink. On upgrades, Fluent Bit maintains several lines in parallel; 5.2.0, 5.1.5, 5.0.11 and 4.2.8 all shipped between August and November 2026, and upgrade notes flag behaviour changes such as the Forward output now retaining metadata by default. Vector releases a minor every few weeks (0.59.0 on 6 October to 0.62.0 on 16 November 2026) and, being pre-1.0, warns that every minor may include breaking changes; 0.62.0 removed several deprecated internal metrics. Pin versions and read upgrade guides for both.

Worked example: VRL refusing an unsafe route on Vector 0.62.0

On 17 November 2026 we downloaded Vector 0.62.0 for x86_64 Linux from GitHub Releases, verified it against the published SHA256SUMS, and wrote a three-stage pipeline: a stdin source, a remap transform running parse_nginx_log!(.message, "combined"), and a route transform whose errors branch fed a JSON console sink, plus one unit test. The first vector validate failed before anything ran: the route condition .status >= 500 raised error E100, 'expression can result in runtime error', because the route transform cannot know that status is an integer. Rewriting it as (to_int(.status) ?? 0) >= 500 validated. Our first unit test then failed with 'assertion failed: null == "/api/orders"', which showed that the combined parser returns the request line as request rather than a path field; fixing the assertion made the test pass. Feeding two access-log lines through the running pipeline printed only the 502 event as JSON, with client, status, size, agent and timestamp parsed, and dropped the 200 health check. Resident memory was 85,956 kB with 6 threads. In Fluent Bit the equivalent is a tail input, a regular-expression parser and a grep or rewrite tag filter, which works well but has no load-time type check or built-in test runner.

Verdict

Pick Fluent Bit for the node agent. It is the lighter process, it already knows how to tail container logs, enrich them with Kubernetes metadata, scrape node metrics and speak OTLP, and it runs on hardware where Vector would not fit. Before production, switch inputs to filesystem storage, raise Retry_Limit from its default of 1 (or set no_limits for critical outputs), set storage.keep.rejected so failed chunks land in the dead letter queue, and move to YAML now because classic .conf is being deprecated at the end of 2026. Pick Vector for the aggregator tier and for any pipeline whose transformation logic deserves code review: VRL refuses unsafe expressions at load time, unit tests run in CI, disk buffers and end-to-end acknowledgements give you a clear durability story, and the sizing table makes capacity planning concrete. Budget for its larger memory use, pin a version, and read the upgrade guide for every minor release because it is still pre-1.0. A common and sensible split is both: Fluent Bit on every node forwarding to a few Vector aggregators through Vector's fluent source, then fan-out to your stores. If you only want one tool and memory is not tight, Vector is simpler to reason about; if memory or device diversity is tight, Fluent Bit is the safer single choice.

All Comparisons

Fluent Bit vs Vector — FAQ

Common questions answered from the comparison above

Is Fluent Bit faster than Vector?

It depends on the workload, and we did not benchmark them against each other. Fluent Bit is lighter on memory by design, while Vector publishes throughput estimates of about 10 MiB/s per vCPU for unstructured logs and 25 MiB/s for structured events. Several third-party benchmarks exist with conflicting results; test with your own log shapes, parsers and outputs.

Can Vector receive logs from Fluent Bit?

Yes. Vector's fluent source accepts the Fluent forward protocol from Fluentd or Fluent Bit agents, so you can keep Fluent Bit on the nodes and run Vector as the aggregator that parses, samples and routes.

Does Fluent Bit drop logs when the output is down?

It can. By default each output retries a failed chunk only once (Retry_Limit 1) and memory-only buffering can pause or lose data at mem_buf_limit. For production, enable filesystem storage, raise Retry_Limit or set it to no_limits, and turn on the dead letter queue with storage.keep.rejected.

Is Vector production ready if it is still version 0.x?

Many companies run it in production, and the project labels components as stable, beta or alpha. The 0.x version means minor releases may contain breaking changes, so pin the version, read the upgrade guide for each minor and step through minors rather than skipping several.

Which is better for OpenTelemetry?

Fluent Bit has native OTLP input and output for logs, metrics and traces plus OpenTelemetry-specific processors. Vector has an OpenTelemetry source covering logs, metrics and traces, but trace support across the rest of Vector is limited to selected components. For trace-heavy pipelines Fluent Bit or the OpenTelemetry Collector is the safer pick.

Who maintains Fluent Bit and Vector?

Fluent Bit is a CNCF graduated project under the Fluentd umbrella, Apache-2.0 licensed, with enterprise providers offering CVE backports for older versions. Vector is MPL-2.0 and maintained by Datadog's Community Open Source Engineering team; Datadog sells Observability Pipelines on top of it.

Get the next comparison by email

One email a week: new and trending developer tools, fresh comparisons, and what shipped. Unsubscribe in one click.