Skip to content
CAI
Software that uses CAICheck a score

fluent/fluentd

62.8

Adequate · 10 November 2026

35.8k

lines of production code

Ruby

primary language

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add ConsoleAdapter to bridge Async gem's Console logger with Fluentd

Introduces a new \ConsoleAdapter\ class that adapts the \Console\ gem (used by the Async gem for HTTP server logging) to Fluentd's existing logger mechanism, ensuring that log levels are correctly reflected and redundant metadata is suppressed for a consistent user experience.

lib/fluent/log · high confidence

Add Markdown template variants for plugin configuration documentation

New ERB templates have been added to the \templates/plugin\_config\_formatter\ directory to support generating plugin configuration documentation in Markdown format. The addition includes \param.md.erb\ for standard parameter listings, \param.md-compact.erb\ for a condensed list view, \param.md-table.erb\ for table-based layouts, and \section.md.erb\ for section headers. These templates handle parameter details such as type, required status, default values, aliases, and deprecation notices, enabling users to generate structured Markdown documentation for Fluent Plugin configurations.

_templates/plugin\_config\formatter · high confidence

Add rake task to automate backporting pull requests

A new Ruby script (tasks/backport/backporter.rb) has been added to automate the backporting of closed pull requests from an upstream repository to a specified target branch. The tool identifies PRs labeled for backporting, creates corresponding branches, cherry-picks the changes, and opens new pull requests via the GitHub API, supporting features like dry-run mode and configurable logging.

tasks/backport · high confidence

Added benchmarking and backporting rake tasks

New rake tasks have been added to support development workflows. The \benchmark\ namespace provides tools to measure \in\_tail\ performance, including a task to generate a 1GB test file, a configuration for the benchmark, and a patch to instrument the \in\_tail\ plugin for timing. Additionally, a \backport\ task has been introduced to facilitate backporting pull requests to the v1.19 branch via environment variables.

tasks · high confidence

Added comprehensive configuration examples for Fluentd plugins and features

The example directory now includes a wide range of configuration files demonstrating core plugins and capabilities, including input plugins (in\_forward, in\_http, in\_syslog, in\_tail, in\_tcp, in\_udp, in\_sample), output plugins (out\_forward, out\_file, out\_copy, out\_null), and filters (filter\_stdout, multi\_filters). These examples cover advanced features such as TLS and shared-key security for forward communication, user authentication, multi-worker configurations, service discovery, buffer compression, and the v1 literal configuration syntax.

example · high confidence

Introduce Fluentd Counter plugin with client/server API

Adds a new distributed counter system to Fluentd, consisting of a server (\lib/fluent/counter/server.rb\) and a client (\lib/fluent/counter/client.rb\) that communicate over TCP on port 24321 using MessagePack. The client provides methods to establish scopes, initialize counters, increment (\inc\), get, delete, and reset values, supporting both synchronous returns and asynchronous block-based result handling. The server validates requests, manages scoped counter state via a mutex-based synchronization layer (\MutexHash\), and persists data using the local storage plugin.

lib/fluent/counter · high confidence

Introduce YAML-based configuration parsing for Fluentd

The Fluentd configuration system now supports a new YAML parser located in lib/fluent/config/yaml\_parser. This addition allows users to define plugins, sources, filters, and matches using YAML syntax, including support for array formats, glob-based file inclusion via the !include directive, and special handling for $id, $log\_level, and $tag elements. The parser translates YAML structures into Fluentd's internal configuration elements, enabling more readable and maintainable configuration files while maintaining compatibility with existing configuration semantics.

_lib/fluent/config/yaml\parser · high confidence

Introduce new core modules and restructure plugin APIs

This change introduces several new core modules to the Fluentd library, including \Capability\ (with Linux CapNG support), \Clock\ (for monotonic time handling), \Daemonizer\ (for standalone daemonization), and \UnrecoverableError\ (for fatal process errors). It also adds \FluentLogEventRouter\ to handle internal logging events via a dedicated thread and queue, and \OjOptions\ to configure the Oj JSON library via environment variables. The plugin architecture is restructured by moving plugin helpers into a dedicated \PluginHelper\ module and introducing \PluginId\ for unique plugin identification and root directory management. Existing core classes like \EventRouter\, \Label\, and \Registry\ are rewritten or added to support these new capabilities, while legacy plugin base classes (\Filter\, \Formatter\, \Parser\, \OutputChain\) are now aliased to their compatibility counterparts to maintain backward compatibility.

lib/fluent · high confidence

Introduces new v0.14 plugin base classes and helper modules

This change adds the foundational classes for the new Fluentd v0.14 plugin API, including \BareOutput\, \Filter\, and \Formatter\, along with supporting modules like \Compressable\ (which adds Zstandard compression support) and \ExecUtil\. These new base classes provide a standardized structure for plugins, introducing built-in metrics collection (such as emit counts and sizes) and helper integrations, while \ExecUtil\ serves as a compatibility shim to the legacy \Fluent::Compat::ExecUtil\.

lib/fluent/plugin · high confidence

New CLI commands and startup optimization for Fluentd

This update introduces several new command-line tools to the bin directory, including fluent-binlog-reader (renamed from unpacker), fluent-ca-generate, fluent-cap-ctl, fluent-debug, fluent-gem, fluent-plugin-config-format, and fluent-plugin-generate, expanding the available utilities for log reading, certificate generation, capability management, debugging, and plugin configuration. Additionally, the main fluentd binary now optimizes startup performance by disabling instruction tracing via RubyVM::InstructionSequence when available, reducing memory usage by approximately 0.5 megabytes, and removes redundant rubygems require statements from fluent-cat and fluentd.

bin · high confidence

New plugin helper modules for configuration, TLS, and process management

This change introduces a suite of new plugin helper modules in lib/fluent/plugin\_helper to standardize plugin development and improve internal consistency. The new helpers include CertOption for managing TLS certificate generation and validation, ChildProcess for handling external process execution and lifecycle, CompatParameters for mapping legacy v0.12 configuration parameters to the v0.14 API, and dedicated helpers for Inject, Extract, Formatter, and Parser instantiation. Additionally, new modules are provided for Metrics collection, Counter client management, Event Emission routing, HTTP/HTTPS server creation, and Event Loop management, providing a unified interface for these common plugin capabilities.

_lib/fluent/plugin\helper · high confidence

Architecture

Refactor in\_tail plugin into modular components

The in\_tail plugin implementation has been restructured by splitting the previously monolithic code into distinct, separate files: group\_watch.rb (handling log grouping and rate limiting), io\_handler.rb (managing file I/O, buffering, and line reading), line\_feeder.rb (parsing lines and emitting events), position\_file.rb (managing read offsets and position tracking), stat\_watcher.rb (file system change detection), and tail\_watcher.rb (coordinating file watching and rotation). This change improves code organization and maintainability without altering the external behavior of the plugin.

_lib/fluent/plugin/in\tail · high confidence

Refactored out\_forward plugin into modular components

The out\_forward plugin has been restructured into distinct, reusable modules to improve maintainability and thread safety. The new \ack\_handler.rb\ manages acknowledgment waiting and response collection, while \connection\_manager.rb\ handles socket lifecycle, keepalive pooling, and discarding stale connections. \socket\_cache.rb\ provides a thread-safe cache for reusing TCP connections, and \load\_balancer.rb\ implements weighted round-robin selection with standby node fallback. Additional modules include \failure\_detector.rb\ for node health monitoring using the phi accrual algorithm, \handshake\_protocol.rb\ for secure authentication, and \error.rb\ for specific exception types. This refactoring isolates concerns, making the plugin's internal logic clearer and more robust.

_lib/fluent/plugin/out\forward · high confidence

Behavioural changes

Compatibility layer for v0.12 plugins

A new compatibility layer in lib/fluent/compat enables plugins written for the v0.12 API to function within the current version. This includes wrapper classes for Input, Output, Filter, Parser, and Formatter that bridge legacy configurations to modern helpers, alongside utility modules for handling tag/time keys, record filtering, and process detachment. The layer also provides backward-compatible exec utilities for parsing and formatting data, ensuring that existing third-party plugins continue to operate without requiring immediate code changes.

lib/fluent/compat · high confidence

Fluentd v1.20.0 release and v1.19.x maintenance updates

This release introduces Fluentd v1.20.0, which fixes an IPv6 binding issue in the http\_server helper that previously caused URI construction errors when binding to IPv6 addresses. It also includes the v1.19.x maintenance updates, which address several buffer memory leaks and spurious overflow errors, enforce message length limits on the in\_syslog plugin, and add basic authentication and network allowlisting capabilities to the in\_http plugin. The release also adds zstd compression support for buffers and outputs, TLS 1.3 support for out\_http, and updates the minimum supported Ruby version to 3.3.

(repo-wide) · high confidence

HTTP server helper now uses Async HTTP with HTTPS and IPv6 support

The http\_server plugin helper has been rewritten to use the Async HTTP library instead of the previous implementation. This change introduces native support for HTTPS via TLS context configuration and proper handling of IPv6 bind addresses. The new architecture includes dedicated components for request handling, routing, and SSL context building, ensuring that request bodies are properly closed to prevent socket leaks and that the server can be stopped safely.

_lib/fluent/plugin\_helper/http\server · high confidence

Migrate Fluentd command-line interface to a modular structure

The \lib/fluent/command\ directory has been restructured to replace the monolithic \fluentd.rb\ script with a set of dedicated, modular command implementations. This change introduces new standalone commands including \fluent-binlog-reader\ (renamed from \unpacker\), \fluent-ca-generate\ for creating CA certificates, \fluent-cap-ctl\ for managing Linux capabilities, \fluent-ctl\ for sending control signals to running services, and \fluent-debug\ for interactive debugging. The main \fluentd\ command now delegates its configuration and runtime options to a new \Fluent::Supervisor\ class, centralizing option parsing and enabling features like \--dry-run\ for configuration validation, \--workers\ for specifying supervisor worker counts, and \--log-rotate-age\ for log management. Additionally, \fluent-cat\ has been enhanced with retry logic, secondary file support, and configurable event times.

lib/fluent/command · high confidence

Refactored buffer chunk implementation with new state management and file handling

The buffer chunk logic has been restructured to introduce a new 'unstaged' state for chunks generated but not yet staged, improving the handling of chunk lifecycle. File-based chunks now manage metadata and data files more robustly, including stricter checks for broken metadata files and better error handling for 'Too many open files' scenarios. The implementation also adds support for Zstd compression and ensures proper cleanup of temporary files and metadata, reducing the risk of data corruption or duplication during commit/rollback operations.

lib/fluent/plugin/buffer · high confidence

Refactored configuration parsing into modular components

The configuration parsing logic in lib/fluent/config has been restructured into distinct, specialized modules to improve maintainability and clarity. This change introduces a new BasicParser for low-level token scanning, a dedicated LiteralParser for handling string and embedded code literals, and a V1Parser that builds upon them for the legacy configuration format. Additionally, the configuration definition DSL has been separated into its own module (DSL), and the configuration element structure is now handled by a dedicated Element class. This modularization isolates parsing concerns, making the configuration system easier to extend and debug without altering the external configuration syntax.

lib/fluent/config · high confidence

Updated plugin generator templates with storage support and improved documentation

The plugin generator templates in templates/new\_gem have been updated to include a new storage plugin template, alongside existing input, output, filter, parser, and formatter templates. The generated gemspec now explicitly specifies version constraints for development dependencies (bundler, rake, test-unit) and sets the runtime dependency for fluentd to \[\>= 0.14.10, \< 2\]. A new .gitignore file is included in generated projects to exclude common build artifacts. The README template has been updated to include an installation section and uses HTTPS for the Fluentd link.

_templates/new\gem · high confidence

Test coverage

Added benchmark scripts for in\_tail worker-thread parsing; Added comprehensive test coverage for plugin helpers; Added comprehensive test coverage for v0.14 plugin base classes and buffer implementations; Added comprehensive test suite for configuration parsing and system settings; Added test coverage for in\_tail FIFO, IOHandler, LineFeeder, and PositionFile components; Added test fixtures for certificate validation scenarios; Added test fixtures for sd\_file and log data; Added test plugins and fixtures for Fluentd parser and formatter testing; Added test suite and test infrastructure; Added test suite for the Counter plugin components; Added test templates for new Fluentd plugin gems; Added tests for Fluent::Log::ConsoleAdapter; Added tests for Service Discovery Manager and Round Robin Balancer; Added tests for compatibility layer plugin lifecycle and parser configuration; Added tests for new and refactored command-line utilities; Added tests for out\_forward internal components; Added tests for script execution and Windows service lifecycle; Added tests for the HTTP server plugin helper components; Introduce plugin test drivers and test utilities; New test driver base classes and plugin-specific drivers for Fluentd.

Dependencies

Adopts Bundler for dependency management and updates runtime requirements

The project now uses Bundler (via a new Gemfile and fluentd.gemspec) to manage dependencies, replacing the previous packaging system. This change updates the minimum required Ruby version to 3.3 and refreshes runtime dependencies, including msgpack (\>= 1.3.1), cool.io (\>= 1.4.5), serverengine (\>= 2.3.2), and json (\>= 2.21). It also adds explicit dependencies for gems no longer included in Ruby's default gemset in recent versions, such as base64, csv, drb, logger, and ostruct, while maintaining compatibility for Windows-specific gems like win32-service and win32-registry.

(dependencies) · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 62 → 63 (+1.2)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 59 → 56 (-3.2)
  • Architecture 84 → 96 (+12.0)
  • Maturity 51 → 56 (+5.0)
  • Readiness 78 → 78 (-0.8)
  • Security 86 → 79 (-7.1)
  • Performance 85 → 85 (+0.0)

Resolved (26)

  • Ambiguous naming convention. now() and now_raw() are semantically similar but the distinction (likely UTC vs local or monotonic vs wall clock) is not obvious from the names. now_raw suggests a low-level implementation detail that might be better named explicitly (e.g., now_utc or now_monotonic) or documented more clearly.
  • Change coupling: in_exec.rb ↔ in_object_space.rb (lib/fluent/plugin/in_exec.rb)
  • Change coupling: in_object_space.rb ↔ in_syslog.rb (lib/fluent/plugin/in_object_space.rb)
  • Change coupling: in_tcp.rb ↔ in_udp.rb (lib/fluent/plugin/in_tcp.rb)
  • Change-coupling hub: bare_output.rb → filter.rb, input.rb, multi_output.rb, output.rb (lib/fluent/plugin/bare_output.rb)
  • Duplicated block (14–17 lines × 2) (lib/fluent/plugin/parser_syslog.rb)
  • Duplicated block (19 lines × 2) (lib/fluent/plugin/in_tcp.rb)
  • Duplicated block (5 lines × 2) (lib/fluent/plugin/parser_syslog.rb)
  • Off-boarding risk: anonymized user #1
  • Orphaned file (lib/fluent/compat/socket_util.rb)
  • Orphaned file (lib/fluent/plugin/in_tcp.rb)
  • Orphaned file (lib/fluent/plugin/out_forward/ack_handler.rb)
  • Orphaned file (lib/fluent/plugin/out_forward/load_balancer.rb)
  • Orphaned file (lib/fluent/plugin/parser.rb)
  • Orphaned file (lib/fluent/plugin_helper/extract.rb)
  • Orphaned file (lib/fluent/plugin_helper/inject.rb)
  • Orphaned file (lib/fluent/plugin_helper/record_accessor.rb)
  • Orphaned file (lib/fluent/timezone.rb)
  • Outdated: flexmock
  • Outdated: parallel_tests
  • …and 6 more

New (11)

  • Change coupling: bare_output.rb ↔ multi_output.rb (lib/fluent/plugin/bare_output.rb)
  • Duplicated block (10 lines × 2) (lib/fluent/plugin/parser_syslog.rb)
  • Duplicated block (19 lines × 2) (lib/fluent/plugin/in_tcp.rb)
  • Duplicated block (27–30 lines × 2) (lib/fluent/plugin/parser_syslog.rb)
  • Hotspot: lib/fluent/plugin/in_syslog.rb (lib/fluent/plugin/in_syslog.rb)
  • Hotspot: lib/fluent/plugin/in_tcp.rb (lib/fluent/plugin/in_tcp.rb)
  • Hotspot: lib/fluent/plugin/parser_syslog.rb (lib/fluent/plugin/parser_syslog.rb)
  • Off-boarding risk: anonymized user #3
  • Off-boarding risk: anonymized user #2
  • Off-boarding risk: anonymized user #1
  • Parser.build_type_converters (cognitive 19) (lib/fluent/plugin/parser.rb)

Changes since last survey

  • 24 commits — 15 feature/other, 9 fixes

By area

  • lib/fluent — 17 commits
  • (root) — 3 commits
  • test/plugin — 2 commits
  • .github/workflows — 1 commit
  • test/plugin_helper — 1 commit

Notable commits

  • fix: in_tcp, in_syslog: fix a non-ASCII delimiter raising Encoding::CompatibilityError (#5606)
  • fix: in_tcp, in_syslog: fix an infinite loop with an empty delimiter (#5604)
  • fix: in_tcp: fix inflated output emit_count when a message arrives in several reads (#5608)
  • fix: out_forward: fix NoMethodError when the destination closes before sending an ACK (#5607)
  • fix: parser_syslog, in_syslog: fix handling of a priority on a later line (#5598)
  • fix: parser_syslog: fix NoMethodError on malformed messages in string parser (#5589)
  • fix: test_in_tail: fix flaky worker unwatch test by disabling the periodic refresh (#5599)
  • fix: test_inject: fix localtime tests that depend on the current daylight saving time (#5583)
  • fix: time: fix parse_float with ten or more fractional digits (#5575)
  • change: build(deps): bump the monthly-updates group with 4 updates (#5581)
  • change: compat: speed up receiving long messages in SocketUtil::TcpHandler (#5605)
  • change: gem: remove yajl-ruby from runtime dependencies for Ruby 4.1 (#5574)
  • change: in_tcp: do not put the whole received data into logs (#5592)
  • change: in_tcp: speed up receiving long messages (#5597)
  • change: out_forward: use the standby node after a failed ACK or handshake (#5623)
  • change: parser_json: speed up parsing when no value conversion is configured (#5579)
  • change: parser_syslog: do not end RFC5424 structured data at an escaped "]" in string parser (#5591)
  • change: parser_syslog: reject truncated RFC5424 messages without raising in regexp parser (#5590)
  • change: parser_syslog: reject truncated messages without raising in string parser (#5585)
  • change: record_accessor: raise ConfigError for a non-integer array index (#5596)
  • …and 4 more

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

fluent/fluentd was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 10 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit e7d3c3e40f9deeb8533402001efddd63be246347 — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.24+preprod-0d1d40a55c0b.