Fluentd vs Fluent Bit: when to choose each
Choose Fluentd when plugin coverage and an aggregation tier matter most. Choose Fluent Bit when memory footprint, native OpenTelemetry and edge collection matter most. Both are Apache-2.0 projects from the same CNCF lineage, and the Fluent Bit documentation says either tool can act as a forwarder or an aggregator, so the choice is less about role and more about what your sources and destinations require. If your team is placing a collector on servers, in containers or on both, start by listing every source type and every destination, then check which of those already have a maintained plugin in each tool.
The decision turns on four things. First, destinations: Fluentd's ecosystem has the wider set of output plugins, and the Fluent Bit documentation says Fluentd suits cases that need that breadth. Second, source types: Fluent Bit offers more than 100 built-in plugins and native OTLP ingestion and delivery, while Fluentd cites more than 1,000 external plugins. Third, the memory budget: the Fluent Bit comparison table lists about 450 KB against more than 60 MB for Fluentd, which matters on small hosts and embedded Linux. Fourth, whether an existing estate must move. If you run td-agent v4, which reached end of life in December 2023, or fluent-package v5, which reached end of life in December 2025, you must move to fluent-package v6 LTS (supported until December 2027) or to another agent.
Which scenario favors which agent
This table maps common Fluentd and Fluent Bit deployment scenarios to the agent that fits best and the condition under which the other would also work. Read each row against your own topology, plugin needs and team skills, since the better fit depends on where the logs go and how much runs on each host.
| Scenario | Better fit | Reason and the condition for the other agent |
|---|---|---|
| Central aggregator fed by many forwarders | Fluentd as aggregator | Fluentd's Ruby plugin ecosystem and aggregation role suit a central tier that routes, buffers and transforms streams from many sources. Fluent Bit can also aggregate, so it works if your required outputs and transforms are covered by its built-in plugins. |
| Lightweight collection on VMs or containers | Fluent Bit as forwarder | The documentation puts Fluent Bit at about 450 KB of memory against more than 60 MB for Fluentd, which matters when many small hosts or sidecars each run an agent. Fluentd is still reasonable here if the hosts have memory to spare and you depend on a Fluentd-only plugin. |
| Embedded Linux devices | Fluent Bit | Fluent Bit is written in C with no dependencies beyond its plugins and is described as suited to resource-constrained and embedded environments. Fluentd's Ruby runtime and gem dependencies make it a weaker fit unless the device has ample resources, which you should confirm during testing. |
| Estate of td-agent hosts | Fluent-package v6 LTS or Fluent Bit | td-agent v4 reached end of life in December 2023 and fluent-package v5 in December 2025, so these hosts need an upgrade either way. Fluent-package v6 LTS is supported until December 2027 and keeps Fluentd behavior, while Fluent Bit suits a rewrite if the pipelines are simple. Confirm plugin compatibility before choosing. |
| Need for a niche Ruby plugin | Fluentd | Fluentd has more than 500 plugins per its own site and the Fluent Bit documentation says Fluentd suits cases that need its large plugin ecosystem. If the plugin is available for Fluent Bit or as an OpenTelemetry Collector component, Fluent Bit may work, so check its exact behavior first. |
| OTLP-first telemetry pipelines | Fluent Bit | Fluent Bit offers native OpenTelemetry (OTLP) ingestion and delivery and handles logs, metrics, traces and profiles. Fluentd supports OpenTelemetry through plugins, so choose it only if a required plugin is Fluentd-specific and you accept that extra layer. |
| Mixed fleet with a central aggregator and edge agents | Both, used together | The Fluent Bit documentation says the two can be used together, with Fluent Bit forwarding from hosts and Fluentd aggregating. This suits illustrative estates where edge hosts are constrained but routing needs Fluentd plugins. It adds a second component to patch and monitor. |
| Teams with a Fluentd skills base and modest host counts | Fluentd | Existing configuration, plugins and runbooks have real migration cost, and memory is less of a constraint on a small estate. Fluent Bit remains an option once you confirm that its built-in plugins cover your inputs and outputs, and a planned migration reduces risk. |
How each agent is built and what that means for operations
Both tools come from the same CNCF project, but they were built for different jobs, and that shapes how each one is packaged, patched, debugged and sized. The cards below cover the language and runtime, packaging, plugin model and deployment scope, and what each choice asks of your operations team.
Language and runtime footprint
Fluentd is written in C and Ruby, so its process carries a Ruby interpreter and its plugins run inside that runtime. Fluent Bit is written in C, which gives it a smaller process image. When you debug a Fluentd pipeline, you need Ruby-aware tooling and familiarity with its plugin code. When you debug Fluent Bit, you work with a compiled binary and its configuration. Check which runtime your security team is willing to patch and monitor.
Packaging and dependency management
Fluentd ships as a Ruby gem that depends on other gems, so your patch process must track gem versions alongside OS packages. Fluent Bit has no dependencies beyond what individual plugins need, which simplifies software bills of materials and image builds. Fluentd users on fluent-package get a bundled runtime. Confirm how your image scanner and change board handle gem-level advisories before you commit to a layout.
Plugin coverage and extension effort
fluentd.org cites more than 500 plugins, and the Fluent Bit comparison table lists more than 1,000 external plugins for Fluentd. Fluent Bit has more than 100 built-in plugins. A large Fluentd plugin catalog helps when you need a niche destination, but each third-party plugin adds code to review and maintain. Fluent Bit's smaller built-in set covers common sources and sinks, so inventory your sources and destinations before deciding which side of that trade-off you need.
Deployment scope and capacity planning
The comparison table lists Fluentd's scope as containers and servers, while Fluent Bit also targets embedded Linux. Fluent Bit suits resource-constrained hosts and high-performance collection, so capacity planning on small nodes usually starts there. Fluentd needs more memory per node and is usually sized for aggregation tiers. Measure resident memory and throughput on your own log volumes, because the published figures describe typical conditions, not your workload.
Capability differences that decide the choice
This table compares Fluentd and Fluent Bit on license, language, memory, plugins, telemetry signals and deployment roles. Read the memory and performance rows as the Fluent Bit documentation's own comparison, and confirm plugin and signal support against current documentation before deciding. The main takeaway is that the two tools are sized for different jobs, so the right choice depends on the plugins and roles your pipeline needs.
| Capability | Fluentd | Fluent Bit |
|---|---|---|
| License and governance | Apache-2.0, a CNCF graduated project according to fluentd.org | Apache-2.0, a CNCF graduated project under the umbrella of Fluentd |
| Language and packaging | Written in C and Ruby, shipped as a Ruby gem with gem dependencies | Written in C, with no dependencies beyond what individual plugins need |
| Memory footprint | More than 60 MB, per the Fluent Bit documentation's comparison table | About 450 KB, per the Fluent Bit documentation's comparison table |
| Performance rating | Medium, per the Fluent Bit documentation's comparison table | High, per the Fluent Bit documentation's comparison table |
| Plugin count and form | More than 1,000 external plugins in the Fluent Bit table, while fluentd.org cites more than 500. Confirm the current count | More than 100 built-in plugins. Confirm current coverage for your sources and destinations |
| OpenTelemetry support | Through plugins. Confirm the plugin and OTLP version you need | Native OTLP ingestion and delivery, per the Fluent Bit documentation |
| Metrics, traces and Prometheus | Confirm metrics and trace handling through plugins against current documentation | Processes logs, metrics, traces and profiles, and integrates with Prometheus per the documentation |
| Forwarder and aggregator roles | Can act as forwarder or aggregator, suited to cases needing its large plugin ecosystem | Can act as forwarder or aggregator, suited to resource-constrained and embedded environments |
| Platform coverage | fluent-package v6 LTS covers RHEL 8, 9 and 10, Ubuntu 22.04, 24.04 and 26.04, Debian 12 and 13, and Windows | Latest releases are v5.1.4 and v5.0.11. Confirm the distributions and architectures you run |
What drives running cost for each agent
Running cost splits across four payers: your infrastructure team (aggregator capacity and the per-node footprint of every forwarder), your engineers (writing and maintaining Fluentd Ruby plugins or Fluent Bit configuration), your support budget (if you buy commercial support, which the fluent-package download page says several companies offer for Fluentd, including help upgrading from end-of-life versions), and your upgrade effort. Fluent Bit's footprint is the main infrastructure lever. The Fluent Bit documentation's comparison table lists Fluentd at more than 60 MB of memory and Fluent Bit at about 450 KB, so a fleet of thousands of small nodes or embedded devices is where that gap shows up in the bill. Confirm the figures against your own workload, since the table describes the agents, not your pipeline.
Costs fall into two groups. One-time costs include the migration itself, rebuilding pipelines in a new configuration model, re-testing parsers and destinations, and moving off td-agent v4 or fluent-package v5, both past end of life. Recurring costs include patching, keeping plugin versions aligned with your Fluentd release line (v1.19.4 was published on September 28, 2026), monitoring the aggregator tier, and capacity growth as log volume rises. Plugin maintenance is the recurring cost most often underestimated in Fluentd estates, because the Ruby plugin ecosystem is large and each plugin can have its own upkeep. Running both agents adds a second set of packages, configurations and runbooks, which is a recurring cost even when each agent is individually cheap to run.
When you request a quote, DeployOpen does not publish prices, and a quote follows from the written scope. Ask the vendor or partner to price against: the node count split by forwarder and aggregator role, the list of log sources and their formats, every destination, the full plugin list with versions, and the upgrade path from any td-agent or fluent-package estate, including whether you move to fluent-package v6 LTS (supported until December 2027) or another agent. Ask for the one-time and recurring items separately, and state which support window you are buying. Those inputs determine whether the cost of Fluentd's plugin coverage or Fluent Bit's lower footprint is the larger line item in your case.
License, editions and what is paid for
Fluentd is licensed under Apache-2.0 and is a project under the Cloud Native Computing Foundation, so the source code can be used, modified and redistributed under that license without a paid edition of the software itself. The project's own download guidance points enterprise users toward the LTS channel of the packaged build rather than the raw gem. Commercial support for Fluentd is available from several companies, and the fluent-package download page notes that this includes help upgrading from end-of-life versions.
- License: Apache-2.0 applies to the Fluentd code in the fluent/fluentd repository.
- Foundation status: Fluentd is a CNCF project, which governs the project but does not sell support.
- Support: Several companies sell commercial support for Fluentd, so the support contract is a separate purchase from the software.
- Upgrade help: Vendors that offer upgrade help can move teams off end-of-life packages, which is useful if you inherited td-agent.
- Cost drivers: Your recurring cost is staff time plus any support contract, and it rises with the number of plugins you depend on.
Before you commit, ask each support provider which Fluentd versions and plugins they cover, and confirm the response commitments in writing.
Fluent Bit is licensed under Apache-2.0 and is described in its documentation as a CNCF graduated project under the umbrella of Fluentd. The supplied facts do not name a paid edition or commercial tier for Fluent Bit, so do not assume one exists. Confirm with the project and its maintainers whether any commercial support, enterprise build or hosted option is offered, and whether it is available in your region.
- License: Apache-2.0 applies to the Fluent Bit repository and its plugins in the core project.
- Project status: The documentation calls Fluent Bit a CNCF graduated project, which you should verify on the CNCF site before citing it in procurement.
- Paid edition: No paid edition is named in the supplied facts, so treat any vendor claim as unverified until you have it in writing.
- Release lines: Fluent Bit ships on separate release lines, so check which line you are pinning before you plan upgrades.
- Cost drivers: Without a paid edition, your costs are staff time, testing and any third-party support you choose to buy.
Ask the project or a commercial provider to confirm in writing whether any paid support or enterprise build exists before you budget for one.
fluent-package is the successor to Treasure Agent (td-agent) and is the packaged distribution that installs Fluentd for supported operating systems. It is published with an LTS channel, which adds no new features and receives only security and bug fixes. The fluentd.org site recommends LTS for enterprise services. Other channels carry newer features, so the choice between them is about change tolerance rather than license.
- LTS channel: fluent-package LTS v6.0.5 is supported until December 2027, per the download page.
- End of life: fluent-package v5 reached end of life in December 2025 and td-agent v4 in December 2023, with no further releases or security updates.
- Platform coverage: v6 packages cover RHEL 8, 9 and 10, Amazon Linux 2023, several Ubuntu and Debian releases, and Windows, so check your exact OS version.
- Migration: Teams on td-agent v4 or fluent-package v5 must move to v6 LTS or to another agent.
- Cost drivers: Packages are free to install, so the cost is the upgrade effort, configuration review and any support contract.
Confirm your operating system is on the download page's list and plan the move off the end-of-life package before the support window closes.
What the td-agent and fluent-package end-of-life dates mean for your upgrade
If your Fluentd estate still runs td-agent v4 or fluent-package v5, you are already past end of life. td-agent v4 reached end of life in December 2023 and fluent-package v5 in December 2025, and neither line receives further releases or security updates. The first decision is to move to fluent-package v6 LTS, which is supported until December 2027, or to choose another agent. Waiting for a vendor patch is not an option on the ended lines, so treat the move as a current security item rather than a routine refresh.
The LTS channel is the right default for enterprise services because it receives only security and bug fixes and adds no new features. For a Fluentd estate, moving to fluent-package v6 LTS is a package upgrade: the td-agent.conf configuration and the Ruby plugins you depend on must be checked against the new package before cutover. Moving to Fluent Bit is a different kind of change. Fluent Bit uses its own configuration format and its own plugin set, so the move is a pipeline rewrite, with each input, filter and output re-expressed and tested, not a package swap. Ask your team to inventory every plugin in use and to mark which ones have a Fluent Bit equivalent before choosing a path.
fluent-package v6 is published for RHEL 8, 9 and 10, Amazon Linux 2023, Ubuntu 22.04, 24.04 and 26.04, Debian 12 and 13, and 64-bit Windows Server 2016 or later and Windows 10 or later. Confirm that each host's exact OS version appears on the fluent-package download page before you schedule the upgrade, including older hosts and images that have not been rebuilt. Hosts outside that list need an OS upgrade or a different agent. The same page says commercial support is available from several companies, including help upgrading from end-of-life versions, so ask any provider for a written scope that covers your plugin inventory, test plan and rollback path.
How to move pipelines between Fluentd and Fluent Bit, or run both
This sequence moves log collection from Fluentd to Fluent Bit at the edge, or sets up both side by side, without losing records in transit. Each step closes with a check your team can record, so the cutover rests on evidence from your own hosts.
Inventory sources, parsers, filters and destinations
Your team lists every log source, tag, parser, filter, buffer setting and destination in the current Fluentd configuration, along with the td-agent or fluent-package version on each host. Each pipeline owner reviews and signs off on the inventory. The step is done when one document lists every host group, the agent version it runs and the endpoint each stream reaches, so nothing is discovered during cutover. Note any hosts on td-agent v4 or fluent-package v5, since both are past end of life and need upgrading whichever agent you choose.
Map each Fluentd plugin to a replacement
Engineers check every plugin in the inventory against Fluent Bit's built-in plugins and its external plugin options, then mark each one as a direct match, a configuration change or a gap. Fluent Bit documents more than 100 built-in plugins, while Fluentd's comparison lists more than 1,000 external plugins, so gaps are most likely in niche outputs and custom filters. Treat each gap as a decision: keep that stream on Fluentd, confirm whether a supported option exists, or change the destination. The step is done when a gap register exists with one named owner per entry.
Decide which tier Fluent Bit replaces
Architects decide whether Fluent Bit replaces the edge forwarder while Fluentd keeps the aggregator, or whether Fluent Bit takes both roles. Either tool can act as a forwarder or an aggregator, so the choice follows from the gap register and from which destinations depend on Fluentd's ecosystem. Running both is the right end state when some streams need Fluentd plugins that Fluent Bit cannot match and the edge still benefits from Fluent Bit's small footprint. Otherwise, a single agent is simpler to operate. The step is done when an approved diagram shows the tier boundary, the forwarding path between tiers and the buffer location.
Rebuild configuration, tag routing and parsers
Engineers rewrite the configuration in Fluent Bit syntax, recreating tag routing, parser definitions and filter order from the inventory. Destination endpoints, index or schema mappings and retention rules transfer unchanged, so dashboards, alerts and compliance retention keep working. Parsers and tag routes are rebuilt and need testing against sample logs from every source type. Compare field names and types with the Fluentd output in a staging backend. The step is done when every stream produces matching fields and the new configuration passes review in version control.
Run both agents in parallel on a subset
Operators deploy Fluent Bit on a limited set of hosts while Fluentd keeps collecting on the rest, and both write to the same destinations under distinct source labels or index names. Pick hosts that cover each log type and operating system in your fleet, including the Windows or Linux builds your package channel supports. Compare event counts per stream between the two agents over a window your team sets. The step is done when counts match within the tolerance your log owners accepted and no duplicate records appear in the backend.
Validate delivery and buffering under failure
Testers induce failures on purpose: stop the destination, block the network path to the aggregator, fill the disk buffer and restart the agent. They confirm that each agent resumes delivery, that buffered records arrive once the destination returns and that memory and buffer limits behave as configured. Record the observed behavior for each agent and each destination, and tune settings where results fall short. The step is done when a signed test report covers every failure case and the security and platform leads approve it before production traffic moves.
Cut over and retire the old packages
Platform engineers move the remaining hosts to the chosen agent in waves, keeping the old Fluentd configuration in version control so a wave can roll back. A host leaves its old service only after that wave's checks pass. Remove td-agent v4 and fluent-package v5 from the fleet, since neither receives further releases or security updates. Any host that stays on Fluentd moves to fluent-package v6 LTS, which is supported until December 2027. The step is done when the inventory shows no end-of-life package and each retired configuration has a dated retirement record.
Where implementation projects usually run long
Fluentd projects usually run long on plugin selection and aggregator sizing. Fluentd's value comes from its plugin ecosystem, but every output and filter you rely on is a Ruby gem with its own dependencies, so the first task is mapping each source and destination to a plugin, a maintainer and a version that installs cleanly on your target operating system. Pin gem versions in the build, record which gems are dependencies of others, and test them on the same package baseline you will run in production. On the aggregator side, sizing depends on buffer paths, chunk limits and the number of forwarders feeding it, so expect a load test before you commit to a topology. Confirm the Fluentd release line and package channel first, because fluent-package LTS is the supported path for enterprise services.
Fluent Bit projects usually run long on configuration migration and OTLP mapping. Most of the effort sits in translating existing Fluentd match and filter logic into Fluent Bit's classic or YAML configuration, then checking that parsers still extract the same fields. Custom Ruby plugins are the usual surprise: if no built-in input, filter or output covers them, the replacement is a Lua filter, an external process or a change of design, and that decision should be made before the schedule is set. Map OpenTelemetry attributes deliberately, since OTLP output and input can rename or nest fields your dashboards and alert rules depend on. Test edge buffering under a network outage with filesystem or memory limits matching the device, because backpressure behavior is where edge agents most often fail quietly.
Across both agents, the reader's team must supply the inputs that stall projects. Provide a source inventory with log formats and volumes, named owners for every destination, and written retention and access requirements, including which fields may never leave the source host. Auditing retained fields is a separate workstream: a redaction rule that is missing at the forwarder is harder to fix after data reaches a backend. Agree a test window with production-like traffic and a rollback path, and ask your vendor or partner to state in writing which tasks are fixed scope and which depend on your environment. Where the effort is uncertain, confirm it with the maintainers' documentation and a pilot rather than assuming it.
Questions buyers ask before hiring outside help
What drives the cost of moving to Fluent Bit or running Fluentd in production?
The main cost drivers are the number of log sources, the number of distinct destinations, how many custom parsers and filters must be rewritten, and how much of the pipeline must be tested against each backend. Fluentd's Ruby plugin ecosystem can reduce build effort when a required plugin already exists, while Fluent Bit's smaller plugin set may need more custom work for niche sources. Costs are one-time for design, build and cutover, and recurring for patching, upgrades and on-call. Ask for a written scope that lists each source, destination, parser and the test plan, then compare quotes against that same list. DeployOpen does not publish a price list, so the quote follows from the agreed scope.
How long does a log collector migration take, and what sets the timeline?
The timeline depends on the number of pipelines, the complexity of parsing and routing rules, the number of plugins that need replacement, and how many environments must be validated before cutover. Running both agents in parallel for a period usually adds time but lowers cutover risk. No duration is fixed here because the source inventory determines it, so ask the delivery team to propose a phased plan with milestones tied to pipeline groups. Confirm how parallel running, rollback and sign-off are handled in the written scope before work starts.
What does the work need from our own engineering and security teams?
Your team needs to provide access to log sources, a current inventory of pipelines and destinations, sample log formats with sensitive fields identified, and a named owner who can approve parser and routing changes. Security teams should confirm retention, redaction and access requirements before pipelines are rebuilt, because those rules change the configuration. Ask the vendor to list these inputs as client dependencies in the scope, with the date each one is due, so that delays are visible early.
Can our team run the migration without outside help?
Yes, a capable platform team can migrate a small pipeline set using the upstream documentation and a test environment, especially where plugins map directly. The effort rises with the number of Fluentd plugins that have no direct equivalent, with aggregation tiers that must be redesigned, and with compliance evidence that must be produced. Teams should decide based on available engineering time, test coverage and the cost of a failed cutover. If you hire outside help, request a written handover covering configuration, runbooks and test records.
How does td-agent end of life change the decision?
If you run td-agent v4 or fluent-package v5, those versions no longer receive releases or security updates, so you must move to fluent-package v6 LTS, which the fluent-package download page lists as supported until December 2027, or to another agent. That date creates a deadline regardless of which tool you prefer. Staying on Fluentd through the fluent-package LTS line is a lower-change path than switching agents, while a move to Fluent Bit is a larger change that also needs plugin mapping. Check your installed package version and the supported platform list before scoping.
Can we keep Fluentd for aggregation and use Fluent Bit at the edge?
Yes. The Fluent Bit documentation states that either tool can act as a forwarder or an aggregator and that the two can be used together. A common layout uses Fluent Bit on hosts and nodes for low memory collection and forwards to a Fluentd aggregator that holds the larger plugin set and routing logic. The design must agree on the forward protocol, buffering, TLS, and how tags and record formats are preserved across the hop. Ask for an architecture note and a failure test that shows what happens when the aggregator is unavailable.
Does DeployOpen issue an audit report for our logging controls?
No. DeployOpen does not issue audit reports, attestations or certifications. It can prepare systems, configuration, retention settings and evidence for compliance assessments, and independent auditors or certification bodies perform the assessment. Ask the vendor to list which evidence artifacts will be produced, such as configuration records, access settings and test results, and confirm with your auditor which controls they expect to see before the scope is signed.
How DeployOpen helps choose, implement or migrate log collection
DeployOpen plans, implements and supports self-hosted log collection inside your own cloud accounts, data centers or air-gapped networks. For Fluentd vs Fluent Bit, the work starts with which roles each agent should play in your environment, then moves to a written, fixed-scope plan that covers the pipeline, the hosts and the handover.
How we scope
- Map which hosts, containers and nodes need a forwarder and which need an aggregator.
- Inventory every destination and plugin your pipelines depend on before choosing an agent.
- Confirm which Fluentd packaging you run today and its end-of-life date, if any.
- Agree the written scope, deliverables and timelines before any work starts.
How we build
- Build forwarder and aggregator configurations sized to your memory and throughput limits.
- Test OpenTelemetry (OTLP) routes if your telemetry standard requires them.
- Validate plugin coverage against each destination, including any Fluentd Ruby plugins you rely on.
- Install fluent-package builds on your supported operating systems through your own change process.
How we hand over
- Document the agent layout, configuration structure and the reason each agent was chosen.
- Provide runbooks for upgrades, rollback and moving pipelines between packaging versions.
- Deliver test results and evidence that supports your internal or external compliance assessments.
- Walk your operations team through the pipeline before the engagement closes.
How we support
- Ongoing support, upgrades and continuous testing are available as a retainer.
- Retainers can cover moving off end-of-life packages before their support dates pass.
- Ask for the support scope, response expectations and upgrade cadence in the written quote.
- DeployOpen prepares evidence for compliance assessments but does not issue audit reports or certifications.

