karafka-core 2.6.1 → 2.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d9f6ba569f0c3a911cbe3ce80c545f3069b5aa2560782cf88bd11c97baa0432
-  data.tar.gz: 54f274da23e99841809f884ea871ce9a55705d76d3c4e5c40b0ef2ffbe0ae75a
+  metadata.gz: 70aa3940193aebd6b4f232950a2b765ee57025aea6b3d3d7c72234429f904de4
+  data.tar.gz: e4a550006b517eea864370ef12534dacdb6fddae40f3adf7308981fa99a1e7a1
 SHA512:
-  metadata.gz: 3a6c6ba64216479cebb2c4f574dff194ae6665189f382b0a60193c5b4ec3ab4d55f4ff97d7fb3fc90800f105a5284da27493b5694adff6e1a6c0738fa5795f65
-  data.tar.gz: 8ea0eddcd9ae95603041f8a74a1a26311cd9aa13744759dd6e7a699eb6ce682fd89596ef85e77ee2fd280d4aa3eca14d8f2ddd7a75dc322fe6e7bb33903ac7b6
+  metadata.gz: '05908e99fd999ee007bcb3efd46a6a3b949d88e40d980c5ca4e8aa90a3c312755717dc8feef7a7de42c5c7c235e3ac623e26b91e9a3456568e4d552a2d8782ea'
+  data.tar.gz: 61456523b5822db6c78ad36c839ed6e3bdcbd9bc18d56cebfb95947443296aad94b917b3bef7798f093b471d703ae9d5a7f43d1b09d726ea655e0b2a0b091a3c

data/.github/workflows/ci.yml

@@ -29,7 +29,7 @@ jobs:
           - ruby: '4.0'
             coverage: 'true'
     steps:
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           fetch-depth: 0
 
@@ -37,7 +37,7 @@ jobs:
         run: "[ -e $APT_DEPS ] || sudo apt-get install -y --no-install-recommends $APT_DEPS"
 
       - name: Set up Ruby
-        uses: ruby/setup-ruby@12fd324f1d0b43274fdc8130f6980590a667c455 # v1.312.0
+        uses: ruby/setup-ruby@95ef2b042f9d7a56d8268cba8559e2842e2ad01b # v1.321.0
         with:
           ruby-version: ${{matrix.ruby}}
           bundler: 'latest'
@@ -65,13 +65,13 @@ jobs:
     env:
       BUNDLE_GEMFILE: Gemfile.lint
     steps:
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           fetch-depth: 0
       - name: Set up Ruby
-        uses: ruby/setup-ruby@12fd324f1d0b43274fdc8130f6980590a667c455 # v1.312.0
+        uses: ruby/setup-ruby@95ef2b042f9d7a56d8268cba8559e2842e2ad01b # v1.321.0
         with:
-          ruby-version: '4.0.5'
+          ruby-version: '4.0.6'
           bundler-cache: true
       - name: Run rubocop
         run: bundle exec rubocop
@@ -82,13 +82,13 @@ jobs:
     env:
       BUNDLE_GEMFILE: Gemfile.lint
     steps:
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           fetch-depth: 0
       - name: Set up Ruby
-        uses: ruby/setup-ruby@12fd324f1d0b43274fdc8130f6980590a667c455 # v1.312.0
+        uses: ruby/setup-ruby@95ef2b042f9d7a56d8268cba8559e2842e2ad01b # v1.321.0
         with:
-          ruby-version: '4.0.5'
+          ruby-version: '4.0.6'
           bundler-cache: true
       - name: Run yard-lint
         run: bundle exec yard-lint lib/
@@ -97,11 +97,11 @@ jobs:
     timeout-minutes: 5
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           fetch-depth: 0
       - name: Set up Node.js
-        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
+        uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0
         with:
           node-version: '20'
           cache: 'npm'

data/.github/workflows/push.yml

@@ -19,12 +19,12 @@ jobs:
       id-token: write
 
     steps:
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           fetch-depth: 0
 
       - name: Set up Ruby
-        uses: ruby/setup-ruby@12fd324f1d0b43274fdc8130f6980590a667c455 # v1.312.0
+        uses: ruby/setup-ruby@95ef2b042f9d7a56d8268cba8559e2842e2ad01b # v1.321.0
         with:
           bundler-cache: false
 
@@ -32,4 +32,4 @@ jobs:
         run: |
           bundle install --jobs 4 --retry 3
 
-      - uses: rubygems/release-gem@6317d8d1f7e28c24d28f6eff169ea854948bd9f7 # v1.2.0
+      - uses: rubygems/release-gem@7f9650160c1a4e7989fdc9855807bdbd421d8b6b # v1.4.1

data/.github/workflows/verify-action-pins.yml

@@ -7,7 +7,7 @@ jobs:
   verify_action_pins:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
       - name: Check SHA pins
         run: |
           if grep -E -r "uses: .*/.*@(v[0-9]+|main|master)($|[[:space:]]|$)" --include="*.yml" --include="*.yaml" .github/workflows/ | grep -v "#"; then

data/.gitignore

@@ -19,6 +19,7 @@ db/*.sqlite3
 *.rbc
 *.sassc
 .byebug_history
+.claude/
 .redcar/
 .capistrano/
 .sass-cache

data/.ruby-version

@@ -1 +1 @@
-4.0.5
+4.0.6

data/.yard-lint.yml

@@ -62,6 +62,34 @@ Documentation/BlankLineBeforeDefinition:
     SingleBlankLine: true
     OrphanedDocs: true
 
+Documentation/DuplicateNamespaceComment:
+  Description: Detects namespaces documented with a YARD comment in more than one file.
+  Enabled: true
+  Severity: error
+
+Documentation/UnderfilledLines:
+  Description: Detects documentation prose that wraps too early and wastes horizontal space.
+  Enabled: true
+  Severity: error
+  # Aligned with RuboCop's Layout/LineLength (Max: 100) so documentation prose
+  # wraps to the same width as code.
+  MaxLength: 100
+
+Documentation/LineLength:
+  Description: Detects documentation lines that exceed the maximum length.
+  Enabled: true
+  Severity: error
+  # Aligned with RuboCop's Layout/LineLength (Max: 100).
+  MaxLength: 100
+
+Documentation/TextSubstitution:
+  Description: Detects em/en-dashes in documentation and replaces them with hyphens.
+  Enabled: true
+  Severity: error
+  Substitutions:
+    "—": "-"    # em-dash (U+2014)
+    "–": "-"    # en-dash (U+2013)
+
 # Tags validators
 Tags/Order:
   Description: Enforces consistent ordering of YARD tags.
@@ -142,7 +170,7 @@ Tags/OptionTags:
 Tags/ExampleSyntax:
   Description: Validates Ruby syntax in @example tags.
   Enabled: true
-  Severity: warning
+  Severity: error
 
 Tags/RedundantParamDescription:
   Description: Detects meaningless parameter descriptions that add no value.

data/CHANGELOG.md

@@ -1,11 +1,34 @@
 # Karafka Core Changelog
 
+## 2.6.3 (2026-08-31)
+- [Enhancement] Add `Configurable::Injector`, a reusable base for injecting default values into a config hash without overwriting user-provided settings, with support for layering extra defaults on top.
+
+## 2.6.2 (2026-06-29)
+- [Enhancement] Document that a leaf's `default` value is shared by reference across all config instances, so a mutable default (e.g. `default: []`) mutated in place is visible everywhere. Assign it inside a `configure` block if you need a per-instance copy.
+- [Fix] `require "pathname"` explicitly in `lib/karafka-core.rb` (with the other top-level requires). `Karafka::Core.gem_root` returns a `Pathname`, but the gem never required `pathname` -- it only worked because Bundler (or another gem) happened to load it first. In an environment where nothing else loads it, `gem_root` raised `NameError: uninitialized constant Pathname`.
+- [Enhancement] Document that a `virtual` rule must return a freshly built `Array` of `[path, message]` error pairs on each call; a memoized, shared or frozen array is unsupported.
+- [Fix] `Configurable::Node#register` raises the documented "already registered" `ArgumentError` for a name already used by an unread lazy-with-constructor setting. The duplicate guard only checked `@configs_refs`, but a lazy setting with a constructor is absent from it until first read, so `register` silently overwrote it; it now checks the defined children.
+- [Fix] `Contractable::Contract.nested` now pops its path in an `ensure`. If the block raised while the contract was being defined and the caller rescued it, the path stayed on the nesting stack and was prefixed onto every rule defined afterwards.
+- [Fix] `Contract#call` no longer raises `NoMethodError` when validating a non-Hash root with a 1-key or 2-key rule path; it reports the path as missing, consistent with the 3+-key path (and the non-Hash intermediate handling added in 2.6.1).
+- [Fix] Honor `excluded_keys` containing `"cgrp"` in `StatisticsDecorator` `only_keys` mode. The `cgrp` branch of the structure-aware fast path lacked the exclusion guard that the `brokers` and `topics` branches have, so excluding the consumer-group subtree still decorated it (inconsistent with the full-decoration path).
+- [Fix] Guard the patched rdkafka error callback against a null client pointer. librdkafka can invoke the error callback with a NULL `rd_kafka_t` (e.g. very early in client construction); calling `rd_kafka_name` on it dereferenced the null pointer and could segfault the process. Mirrors the upstream `ErrorCallback`.
+- [Fix] Resolve fatal errors in the patched rdkafka error callback. `ERR__FATAL` is only a generic marker, so the callback now fetches the real underlying error code and description via `RdkafkaError.build_fatal` (`rd_kafka_fatal_error`) instead of reporting the generic fatal code. Mirrors the upstream `ErrorCallback`.
+- [Fix] A lazy setting declared without a constructor (`setting(:x, lazy: true)`) no longer raises when read; it now behaves like a regular setting backed by its default.
+- [Fix] `Contract#call` no longer raises `NoMethodError` when a virtual rule returns `false`. A virtual rule now signals "no errors" with any non-Array result (`true`/`false`/`nil`); only an `Array` of error pairs is collected. Previously a `false` return reached `false.each` (a `nil` return was already tolerated).
+- [Fix] Make `CallbacksManager` thread-safe under concurrent `add`/`delete` during dispatch. A callback registered or removed while callbacks were firing could be lost — kept firing after removal, or never fired after being added. librdkafka fires these from a background thread, so it was reachable in practice.
+- [Fix] Make `Notifications` subscriptions thread-safe: a listener that unsubscribes itself (or another) from within its own handler no longer causes the next listener to be skipped, and concurrent subscribe/unsubscribe during dispatch is now safe.
+- [Fix] Report a freeze duration (`_fd`) of `0` for statistics keys that first appear mid-stream (e.g. a new broker or partition) instead of the time since the previous emission, which was incorrect and made the related spec flaky.
+- [Fix] Make assigning a setting on a frozen `Configurable::Node` atomic. The ivar-backed writer evaluated `@configs_refs[name] = value` before `instance_variable_set`, so a frozen node mutated the canonical store and only then raised `FrozenError`, leaving the store and the ivar-backed reader permanently out of sync. It now raises before touching any state.
+- [Fix] `Configurable::Node#to_h` no longer raises for a setting using the `->(default) { ... }` constructor form when its value has not been set yet (e.g. `#to_h` on an unconfigured instance or an unread lazy setting).
+- [Fix] Honor `excluded_keys` inside `StatisticsDecorator` `only_keys` decoration. A key listed in both `only_keys` and `excluded_keys` was still decorated because the direct-access decoration loop never consulted `excluded_keys`; exclusion now wins, matching the full-decoration path.
+- [Fix] Strip the tests/specs root directory as an anchored prefix (`sub(/\A.../)`) instead of a global `gsub` in `MinitestLocator` and `RSpecLocator`. When the root directory string recurred later in a test/spec file path, the global replace removed every occurrence and corrupted the derived subject class path; only the leading prefix is now removed.
+
 ## 2.6.1 (2026-06-15)
-- [Enhancement] Speed up `Contract#call` by ~1.25x for minimal and ~1.4x for fully populated data: resolve rule paths with a single `Hash#fetch` per level instead of `key?` + `[]`, inline the per-rule type dispatch into the rules loop, and compare the dig sentinel via `#equal?` so `#==` is never dispatched to the validated (user-provided) values. This is the per-message validation path in WaterDrop producers.
+- [Enhancement] Speed up `Contract#call` by ~1.25–1.4x, the per-message validation path in WaterDrop producers.
 - [Fix] `Contract#call` with rule paths of 3+ keys no longer raises `NoMethodError` when an intermediate value is not a `Hash` and reports the path as missing instead, consistent with the 2-key path behavior.
 - [Change] Reject reserved setting names with an `ArgumentError` in `Configurable::Node#setting` and `#register`: internal state names (`node_name`, `children`, `nestings`, `compiled`, `configs_refs`, `local_defs`) and the node public API names (`setting`, `configure`, `to_h`, `deep_dup`, `register`, `compile`). Previously such names silently shadowed the node own accessors, breaking `deep_dup` or `to_h`, and assignments like `config.children = value` corrupted the node internal state.
-- [Enhancement] Skip the event name mapping hash lookup in `Monitor#instrument` when no namespace is used and the event id is already a `String`, which is the case for all events in the Karafka ecosystem (~1.2x faster dispatch on the common no-subscribers path). Symbol event ids and namespaced monitors keep going through the mapping.
-- [Enhancement] Mirror config values into instance variables and use `attr_reader` based readers in `Configurable::Node`, yielding ~1.4x faster flat and ~1.6x faster nested settings reads on hot paths. `@configs_refs` remains the canonical store; non-identifier setting names (e.g. registered names with dashes) keep the previous hash-based accessors.
+- [Enhancement] Speed up `Monitor#instrument` dispatch (~1.2x) on the common no-subscribers path.
+- [Enhancement] Speed up `Configurable::Node` settings reads (~1.4x flat, ~1.6x nested) on hot paths.
 - [Enhancement] Instantiate each `Configurable::Node` through a per-layout anonymous subclass so the ivar-backed settings do not grow object shape variations on the shared `Node` class (which would degrade ivar access and trigger Ruby performance warnings). `deep_dup` reuses the template's subclass, so duplicated configs share object shapes.
 - [Fix] Symbolize setting names at definition time (`setting`, same as `register`) and on config store writes so `String` setting names work end to end (accessors, `#to_h`, recompilation state) and cannot corrupt node internal state when matching reserved internal names (previously string-named settings were quietly broken as accessors and the store disagreed on the key type).
 - [Change] Config nodes are now instances of anonymous `Node` subclasses: `is_a?(Karafka::Core::Configurable::Node)` still holds, but `instance_of?(Node)` is now `false` and `node.class.name` is `nil`.
@@ -33,6 +56,7 @@
 - [Enhancement] Replace `StatisticsDecorator#diff` pending-writes buffer with `keys.each` direct-write iteration, eliminating the buffer and write-back loop for ~13% faster decoration at scale (10 brokers, 20 topics, 2000 partitions).
 - [Enhancement] Reorder `StatisticsDecorator#diff` type checks to test `Numeric` before `Hash`, matching the ~80% numeric value distribution in librdkafka statistics.
 - [Enhancement] Support `only_keys` option in `StatisticsDecorator` to decorate only specified numeric keys (e.g. `consumer_lag`, `committed_offset`). When combined with `excluded_keys`, reduces decoration cost from ~80ms to ~8.5ms per call on large clusters (10 brokers, 20 topics, 2000 partitions) by using structure-aware navigation of the librdkafka statistics tree and direct key access instead of full-hash iteration.
+- [Enhancement] Cache `Tags#to_a` values array and invalidate on `add`/`delete`/`clear` to avoid allocating a new Array and running `uniq` on every call, yielding ~7x faster reads at 5 tags and ~28x faster at 20 tags.
 
 ## 2.5.10 (2026-03-02)
 - [Enhancement] Introduce `MinitestLocator` helper for minitest/spec subject class auto-discovery from test file paths.

data/Gemfile.lint.lock

@@ -55,11 +55,11 @@ GEM
     unicode-display_width (3.2.0)
       unicode-emoji (~> 4.1)
     unicode-emoji (4.2.0)
-    yard (0.9.38)
-    yard-lint (1.4.0)
+    yard (0.9.45)
+    yard-lint (1.10.1)
       yard (~> 0.9)
       zeitwerk (~> 2.6)
-    zeitwerk (2.7.4)
+    zeitwerk (2.8.2)
 
 PLATFORMS
   ruby
@@ -75,6 +75,7 @@ DEPENDENCIES
 
 CHECKSUMS
   ast (2.4.3) sha256=954615157c1d6a382bc27d690d973195e79db7f55e9765ac7c481c60bdb4d383
+  bundler (4.0.17) sha256=214e21431b5665dd2f99df8a5511c6b151d7a72e8015c8b38f8b775b61cbb6c1
   json (2.18.0) sha256=b10506aee4183f5cf49e0efc48073d7b75843ce3782c68dbeb763351c08fd505
   language_server-protocol (3.17.0.5) sha256=fd1e39a51a28bf3eec959379985a72e296e9f9acfce46f6a79d31ca8760803cc
   lint_roller (1.1.0) sha256=2c0c845b632a7d172cb849cc90c1bce937a28c5c8ccccb50dfd46a485003cc87
@@ -95,9 +96,9 @@ CHECKSUMS
   standard-performance (1.9.0) sha256=49483d31be448292951d80e5e67cdcb576c2502103c7b40aec6f1b6e9c88e3f2
   unicode-display_width (3.2.0) sha256=0cdd96b5681a5949cdbc2c55e7b420facae74c4aaf9a9815eee1087cb1853c42
   unicode-emoji (4.2.0) sha256=519e69150f75652e40bf736106cfbc8f0f73aa3fb6a65afe62fefa7f80b0f80f
-  yard (0.9.38) sha256=721fb82afb10532aa49860655f6cc2eaa7130889df291b052e1e6b268283010f
-  yard-lint (1.4.0) sha256=7dd88fbb08fd77cb840bea899d58812817b36d92291b5693dd0eeb3af9f91f0f
-  zeitwerk (2.7.4) sha256=2bef90f356bdafe9a6c2bd32bcd804f83a4f9b8bc27f3600fff051eb3edcec8b
+  yard (0.9.45) sha256=52e211493f7cb8a3ebf7e104a25a1e73937a3103092545d34cb88fafebb3dc51
+  yard-lint (1.10.1) sha256=172ea1905304580bd515c093d82831ec4889e725100c49d5bf77e62101f49129
+  zeitwerk (2.8.2) sha256=7212a61311083c604184b1ea2574b9aa05cd14f855a0841c06985cabe9181d12
 
 BUNDLED WITH
-  4.0.3
+  4.0.17

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    karafka-core (2.6.1)
+    karafka-core (2.6.3)
       karafka-rdkafka (>= 0.20.0)
       logger (>= 1.6.0)
 
@@ -10,7 +10,6 @@ GEM
   specs:
     byebug (13.0.0)
       reline (>= 0.6.0)
-    docile (1.4.1)
     drb (2.2.3)
     ffi (1.17.4)
     ffi (1.17.4-aarch64-linux-gnu)
@@ -24,38 +23,38 @@ GEM
     ffi (1.17.4-x86_64-linux-gnu)
     ffi (1.17.4-x86_64-linux-musl)
     io-console (0.8.2)
-    json (2.19.7)
-    karafka-rdkafka (0.27.2)
+    json (2.21.2)
+    karafka-rdkafka (0.28.0)
       ffi (~> 1.17.1)
       json (> 2.0)
       logger
       mini_portile2 (~> 2.6)
       rake (> 12)
-    karafka-rdkafka (0.27.2-aarch64-linux-gnu)
+    karafka-rdkafka (0.28.0-aarch64-linux-gnu)
       ffi (~> 1.17.1)
       json (> 2.0)
       logger
       mini_portile2 (~> 2.6)
       rake (> 12)
-    karafka-rdkafka (0.27.2-aarch64-linux-musl)
+    karafka-rdkafka (0.28.0-aarch64-linux-musl)
       ffi (~> 1.17.1)
       json (> 2.0)
       logger
       mini_portile2 (~> 2.6)
       rake (> 12)
-    karafka-rdkafka (0.27.2-arm64-darwin)
+    karafka-rdkafka (0.28.0-arm64-darwin)
       ffi (~> 1.17.1)
       json (> 2.0)
       logger
       mini_portile2 (~> 2.6)
       rake (> 12)
-    karafka-rdkafka (0.27.2-x86_64-linux-gnu)
+    karafka-rdkafka (0.28.0-x86_64-linux-gnu)
       ffi (~> 1.17.1)
       json (> 2.0)
       logger
       mini_portile2 (~> 2.6)
       rake (> 12)
-    karafka-rdkafka (0.27.2-x86_64-linux-musl)
+    karafka-rdkafka (0.28.0-x86_64-linux-musl)
       ffi (~> 1.17.1)
       json (> 2.0)
       logger
@@ -70,12 +69,7 @@ GEM
     rake (13.4.2)
     reline (0.6.3)
       io-console (~> 0.5)
-    simplecov (0.22.0)
-      docile (~> 1.1)
-      simplecov-html (~> 0.11)
-      simplecov_json_formatter (~> 0.1)
-    simplecov-html (0.13.2)
-    simplecov_json_formatter (0.1.4)
+    simplecov (1.1.1)
     warning (1.6.0)
 
 PLATFORMS

data/lib/karafka/core/configurable/injector.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Karafka
+  module Core
+    module Configurable
+      # Base class for config defaults injectors.
+      #
+      # An injector enriches a config-like hash with a set of default values, applying each
+      # default only when the corresponding key is not already present. This lets a component
+      # ship sane defaults while still letting users override any of them by pre-populating the
+      # key themselves.
+      #
+      # Injectors are meant to be layered. A base (e.g. OSS) injector defines its {defaults} and
+      # an extension (e.g. Pro) prepends a module onto the singleton class and calls `super` to
+      # contribute additional defaults on top:
+      #
+      #   Base.singleton_class.prepend(Extension)
+      #
+      # The only-if-absent rule applies to the target being enriched, not to the defaults
+      # themselves: a key the user already set in the target is never touched. How two layers
+      # resolve a key they both define is up to the layers -- e.g. an extension using
+      # `super.merge(extra)` lets its own value win, while `extra.merge(super)` would keep the
+      # base value.
+      #
+      # @example Define an injector with defaults
+      #   class MyInjector < Karafka::Core::Configurable::Injector
+      #     DEFAULTS = { 'a' => 1, 'b' => 2 }.freeze
+      #
+      #     class << self
+      #       def defaults
+      #         DEFAULTS
+      #       end
+      #     end
+      #   end
+      #
+      #   MyInjector.call({ 'b' => 20 }) #=> { 'b' => 20, 'a' => 1 }
+      #
+      # @example Layer extra defaults (e.g. Pro) via prepend + super
+      #   module ProDefaults
+      #     def defaults
+      #       super.merge('c' => 3)
+      #     end
+      #   end
+      #
+      #   MyInjector.singleton_class.prepend(ProDefaults)
+      #   MyInjector.call({}) #=> { 'a' => 1, 'b' => 2, 'c' => 3 }
+      #
+      # @note The base class holds no state and defines no defaults on its own; it is not useful
+      #   directly and is expected to be subclassed. Subclasses should return the same defaults
+      #   object (e.g. a frozen constant) on each call so that a prepended layer doing
+      #   `super.merge(...)` never mutates it.
+      #
+      # @note Default values are injected by reference, not copied. A mutable default (an array or
+      #   hash) is therefore shared across every target it is injected into, and mutating it in one
+      #   place is visible everywhere. When a per-target mutable value is needed, the defaults
+      #   layer should hand out a copy (e.g. `dup` it in `.defaults`).
+      class Injector
+        # Empty, immutable defaults used by the base class, which defines none of its own.
+        EMPTY_DEFAULTS = {}.freeze
+
+        private_constant :EMPTY_DEFAULTS
+
+        class << self
+          # Enriches the target with the defaults, without overwriting any key that is already
+          # present in it. The target is mutated in place.
+          #
+          # @param target [Hash] config hash to enrich in place
+          # @return [Hash] the same target, enriched with the missing defaults
+          def call(target)
+            defaults.each do |key, value|
+              next if target.key?(key)
+
+              target[key] = value
+            end
+
+            target
+          end
+
+          # @return [Hash] default values to inject. Override in subclasses; extensions may
+          #   prepend a module onto the singleton class and call `super` to contribute additional
+          #   defaults on top. The base class defines none.
+          def defaults
+            EMPTY_DEFAULTS
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/core/configurable/node.rb

@@ -3,8 +3,7 @@
 module Karafka
   module Core
     module Configurable
-      # Single non-leaf node
-      # This is a core component for the configurable settings
+      # Single non-leaf node. This is a core component for the configurable settings
       #
       # The idea here is simple: we collect settings (leafs) and children (nodes) information and
       # we only compile/initialize the values prior to user running the `#configure` API. This API
@@ -116,7 +115,10 @@ module Karafka
               result = if @configs_refs.key?(value.node_name)
                 @configs_refs[value.node_name]
               elsif value.constructor
-                value.constructor.call
+                # Use the arity-aware helper (same as `#compile`) so a `->(default) { ... }`
+                # constructor receives its default instead of being called with no arguments,
+                # which would raise `ArgumentError: wrong number of arguments`.
+                call_constructor(value)
               elsif value.default
                 value.default
               end
@@ -144,6 +146,17 @@ module Karafka
               # After inheritance we need to reload the state so the leafs are recompiled again
               value = value.dup
               value.compiled = false
+
+              # `Struct#dup` is intentionally shallow here: the leaf's `default` value is shared by
+              # reference across the class template and every config instance produced by
+              # `deep_dup`. This is the contract -- one uniform rule for all default types -- and it
+              # is what lets a shared service object passed as a default (e.g. a logger) keep its
+              # identity across all configs instead of being cloned per instance. The flip side is
+              # that an in-place mutation of a mutable container default (e.g. `config.list << :x`)
+              # is visible on every other instance and on the template. A caller that needs a
+              # per-instance mutable default should not rely on a mutable `default:` (e.g.
+              # `default: []`): assign the value inside a `configure` block, or dup it themselves,
+              # so each instance owns its own copy.
               value
             else
               value.deep_dup
@@ -175,7 +188,12 @@ module Karafka
 
           prevent_reserved_names!(name)
 
-          raise ArgumentError, "#{name} is already registered" if @configs_refs.key?(name)
+          # Check the defined children, not just @configs_refs: a lazy setting with a constructor
+          # is not written to @configs_refs until first read, so a `@configs_refs.key?` guard
+          # alone would silently overwrite it instead of raising the documented error.
+          if @children.any? { |child| child.node_name == name }
+            raise ArgumentError, "#{name} is already registered"
+          end
 
           leaf = Leaf.new(name, value, nil, true, false)
           @children << leaf
@@ -190,7 +208,12 @@ module Karafka
             # Do not redefine something that was already set during compilation
             # This will allow us to reconfigure things and skip override with defaults
             skippable = @configs_refs.key?(value.node_name) || (value.is_a?(Leaf) && value.compiled?)
-            lazy_leaf = value.is_a?(Leaf) && value.lazy?
+            # A leaf is only treated as lazy (a dynamically (re)evaluated accessor) when it
+            # actually has a constructor to evaluate. `lazy: true` without a constructor has
+            # nothing to evaluate, so it behaves like a regular setting backed by its default.
+            # Otherwise the lazy path builds a dynamic accessor that calls `constructor.arity`
+            # on a `nil` constructor and crashes on first read.
+            lazy_leaf = value.is_a?(Leaf) && value.lazy? && !value.constructor.nil?
 
             # Do not create accessor for leafs that are lazy as they will get a custom method
             # created instead
@@ -295,7 +318,8 @@ module Karafka
             ivar_name = :"@#{reader_name}"
 
             define_singleton_method(:"#{reader_name}=") do |new_value|
-              instance_variable_set(ivar_name, @configs_refs[reader_name] = new_value)
+              instance_variable_set(ivar_name, new_value)
+              @configs_refs[reader_name] = new_value
             end
           else
             define_singleton_method(:"#{reader_name}=") do |new_value|

data/lib/karafka/core/contractable/contract.rb

@@ -40,8 +40,14 @@ module Karafka
           def nested(path, &)
             init_accu
             @nested << path
-            instance_eval(&)
-            @nested.pop
+            begin
+              instance_eval(&)
+            ensure
+              # Always pop, even if the block raises. Otherwise a rescued exception during
+              # contract definition would leave `path` on @nested and prefix it onto every rule
+              # defined afterwards.
+              @nested.pop
+            end
           end
 
           # Defines a rule for a required field (required means, that will automatically create an
@@ -61,10 +67,19 @@ module Karafka
             @rules << Rule.new(@nested + keys, :optional, block).freeze
           end
 
-          # @param block [Proc] validation rule
+          # Defines a virtual rule that validates the whole data rather than a single key. Unlike
+          # `required`/`optional`, the block receives the full data and returns its own errors.
+          #
+          # @param block [Proc] validation rule, called with `(data, errors, contract)`. It must
+          #   return either a non-Array (`true`/`nil`/`false`) for "no errors", or an `Array` of
+          #   `[path, message]` error pairs (where `path` is itself an `Array` of symbols).
           #
-          # @note Virtual rules have different result expectations. Please see contracts or specs for
-          #   details.
+          # @note The returned error `Array` is owned by the contract: `#call` prepends the current
+          #   scope onto each pair in place and collects them, so a rule must return a freshly
+          #   built `Array` on every call. Returning a memoized, shared or frozen `Array` is not
+          #   supported -- in-place scoping would accumulate the prefix across validations (or
+          #   raise `FrozenError`). Build the result in the block (e.g. `[[%i[id], :invalid]]`)
+          #   rather than returning a constant.
           def virtual(&block)
             init_accu
             @rules << Rule.new([], :virtual, block).freeze
@@ -94,19 +109,32 @@ module Karafka
         def call(data, scope: EMPTY_ARRAY)
           errors = []
 
+          # A non-Hash root has no keys to dig; resolve it once here so #dig stays on its lean
+          # fast path and is only invoked with a Hash. Non-Hash data makes every required rule
+          # report missing, consistent with the non-Hash intermediate handling inside #dig.
+          data_is_hash = data.is_a?(Hash)
+
           self.class.rules.each do |rule|
             if rule.type == :virtual
               result = rule.validator.call(data, errors, self)
 
-              next if result == true
-
-              result&.each do |sub_result|
+              # A virtual rule signals "no errors" with any non-Array result (true, but also a
+              # falsy `nil`/`false` returned by e.g. `condition && [[...], :err]`). Only an Array
+              # of error pairs is iterated; previously a `false` return reached `false.each` and
+              # raised NoMethodError (a `nil` return was already tolerated by the safe navigation).
+              next unless result.is_a?(Array)
+
+              # Apply the scope prefix in place on the rule's returned pairs and collect them
+              # directly. Per the `virtual` contract the rule hands back a freshly built Array
+              # each call (see `DSL#virtual`), so mutating it here is safe and avoids allocating a
+              # new pair per error.
+              result.each do |sub_result|
                 sub_result[0] = scope + sub_result[0]
               end
 
               errors.push(*result)
             else
-              for_checking = dig(data, rule.path)
+              for_checking = data_is_hash ? dig(data, rule.path) : DIG_MISS
 
               if DIG_MISS.equal?(for_checking)
                 errors << [scope + rule.path, :missing] if rule.type == :required

data/lib/karafka/core/helpers/minitest_locator.rb

@@ -24,7 +24,7 @@ module Karafka
           this = self
           # Allows "auto subject" definitions for the `describe` method, as it will figure
           # out the proper class that we want to describe
-          # @param block [Proc] block with tests
+          # block - block with tests
           minitest_module.define_singleton_method :describe_current do |&block|
             describe(this.inherited, &block)
           end
@@ -36,7 +36,7 @@ module Karafka
             .first
             .split(":")
             .first
-            .gsub(@tests_root_dir, "")
+            .sub(/\A#{::Regexp.escape(@tests_root_dir)}/, "")
             .gsub("_test.rb", "")
             .split("/")
             .delete_if(&:empty?)

data/lib/karafka/core/helpers/rspec_locator.rb

@@ -27,7 +27,7 @@ module Karafka
           this = self
           # Allows "auto subject" definitions for the `#describe` method, as it will figure
           # out the proper class that we want to describe
-          # @param block [Proc] block with specs
+          # block - block with specs
           rspec.define_singleton_method :describe_current do |&block|
             describe(this.inherited, &block)
           end
@@ -39,7 +39,7 @@ module Karafka
             .first
             .split(":")
             .first
-            .gsub(@specs_root_dir, "")
+            .sub(/\A#{::Regexp.escape(@specs_root_dir)}/, "")
             .gsub("_spec.rb", "")
             .split("/")
             .delete_if(&:empty?)

data/lib/karafka/core/instrumentation/callbacks_manager.rb

@@ -2,7 +2,6 @@
 
 module Karafka
   module Core
-    # Karafka instrumentation related shared components
     module Instrumentation
       # This manager allows us to register multiple callbacks into a hook that is suppose to support
       # a single callback
@@ -10,20 +9,21 @@ module Karafka
         # @return [::Karafka::Core::Instrumentation::CallbacksManager]
         def initialize
           @callbacks = {}
-          @values_cache = nil
+          @values = [].freeze
+          @mutex = Mutex.new
         end
 
         # Invokes all the callbacks registered one after another
         #
         # @param args [Object] any args that should go to the callbacks
-        # @note We do not use `#each_value` here on purpose. With it being used, we cannot dispatch
-        #   callbacks and add new at the same time. Since we don't know when and in what thread
-        #   things are going to be added to the manager, we need to extract values into an array and
-        #   run it. That way we can add new things the same time.
-        #   The values snapshot is cached and invalidated on add/delete to avoid allocating a new
-        #   Array on every call while preserving the thread-safety snapshot semantics.
+        # @note Copy-on-write: dispatch iterates an immutable snapshot that `add`/`delete`
+        #   rebuild and swap in under a mutex. Because `#call` never mutates shared state, it
+        #   needs neither a lock nor a per-call `#values` allocation, and a callback registered
+        #   or removed from another thread is never lost; it just takes effect on the next
+        #   `#call`. A cache invalidated from within `#call` could not be updated atomically
+        #   against this read, so a stale write-back would permanently drop callbacks.
         def call(*args)
-          (@values_cache ||= @callbacks.values).each { |callback| callback.call(*args) }
+          @values.each { |callback| callback.call(*args) }
         end
 
         # Adds a callback to the manager
@@ -31,15 +31,19 @@ module Karafka
         # @param id [String] id of the callback (used when deleting it)
         # @param callable [#call] object that responds to a `#call` method
         def add(id, callable)
-          @callbacks[id] = callable
-          @values_cache = nil
+          @mutex.synchronize do
+            @callbacks[id] = callable
+            @values = @callbacks.values.freeze
+          end
         end
 
         # Removes the callback from the manager
         # @param id [String] id of the callback we want to remove
         def delete(id)
-          @callbacks.delete(id)
-          @values_cache = nil
+          @mutex.synchronize do
+            @callbacks.delete(id)
+            @values = @callbacks.values.freeze
+          end
         end
       end
     end

data/lib/karafka/core/monitoring/notifications.rb

@@ -48,8 +48,17 @@ module Karafka
         # @param event_id [String] the key of the event to clear listeners for.
         def clear(event_id = nil)
           @mutex.synchronize do
-            return @listeners.each_value(&:clear) unless event_id
-            return @listeners[event_id].clear if @listeners.key?(event_id)
+            # Copy-on-write: replace the per-event arrays rather than mutating them in place, so a
+            # dispatch iterating a previously captured array is unaffected (see #notify_listeners).
+            unless event_id
+              @listeners.transform_values! { [] }
+              return
+            end
+
+            if @listeners.key?(event_id)
+              @listeners[event_id] = []
+              return
+            end
 
             raise(EventNotRegistered, "#{event_id} not registered!")
           end
@@ -76,21 +85,23 @@ module Karafka
 
               raise EventNotRegistered, event_id unless @listeners.key?(event_id)
 
-              @listeners[event_id] << block
+              # Copy-on-write: append by replacing the array, never mutating the one a concurrent
+              # dispatch may be iterating (see #notify_listeners).
+              @listeners[event_id] += [block]
             else
               listener = event_id_or_listener
 
               @listeners.each_key do |reg_event_id|
                 next unless listener.respond_to?(@events_methods_map[reg_event_id])
 
-                @listeners[reg_event_id] << listener
+                @listeners[reg_event_id] += [listener]
               end
             end
           end
         end
 
-        # Allows for unsubscription from events
-        # This method will remove the listener/block from all events where it's currently subscribed.
+        # Allows for unsubscription from events. This method will remove the listener/block from all
+        # events where it's currently subscribed.
         #
         # @param listener_or_block [Object] listener object or block to remove from all events
         #
@@ -98,9 +109,9 @@ module Karafka
         #   unsubscribe(my_listener)
         def unsubscribe(listener_or_block)
           @mutex.synchronize do
-            @listeners.each_value do |event_listeners|
-              event_listeners.delete(listener_or_block)
-            end
+            # Copy-on-write: rebuild each array without the listener instead of deleting in place,
+            # so a dispatch iterating a previously captured array still sees the full set.
+            @listeners.transform_values! { |event_listeners| event_listeners - [listener_or_block] }
           end
         end
 

data/lib/karafka/core/monitoring/statistics_decorator.rb

@@ -14,7 +14,16 @@ module Karafka
       #   - KEY_fd - freeze duration - describes how long the delta remains unchanged (zero)
       #              and can be useful for detecting values that "hang" for extended period of time
       #              and do not have any change (delta always zero). This value is in ms for the
-      #              consistency with other time operators we use.
+      #              consistency with other time operators we use. A newly introduced key (one
+      #              that had no value in the previous emission) starts at a freeze duration of
+      #              zero, since there is no prior value it could have been "frozen" against.
+      #
+      # The `_d` and `_fd` suffixes are reserved. For every numeric KEY the decorator writes
+      # `KEY_d` and `KEY_fd` into the same hash, so if the input already contains a real key
+      # literally named `KEY_d` or `KEY_fd` (for another numeric KEY present in that hash) it is
+      # overwritten by the computed delta/freeze duration. librdkafka statistics never use these
+      # suffixes, so this does not happen with real stats; it only matters if you feed custom data
+      # through the decorator.
       class StatisticsDecorator
         include Helpers::Time
 
@@ -28,11 +37,17 @@ module Karafka
         #   duration suffixes. This is useful for skipping large subtrees of the librdkafka
         #   statistics that are not consumed by the application (e.g. broker toppars, window
         #   stats like int_latency, outbuf_latency, throttle, batchsize, batchcnt, req).
-        # @param only_keys [Array<String>] when set, only these numeric keys will be decorated
-        #   with delta/freeze duration suffixes. Hash children are still recursed into for
-        #   structural navigation, but only the listed keys receive _d and _fd computation.
-        #   This drastically reduces work at the partition level where most cost occurs.
-        #   When empty (default), all numeric keys are decorated.
+        # @param only_keys [Array<String>] when set, only these numeric keys are decorated with
+        #   delta/freeze duration suffixes, and only at the levels of the known librdkafka
+        #   statistics tree: the root, each broker, each topic, each partition and cgrp. The
+        #   decorator navigates that known structure directly and decorates the listed keys it
+        #   finds at each of those levels. It deliberately does NOT descend into nested
+        #   sub-objects within a broker, topic, partition or cgrp (e.g. broker window stats like
+        #   rtt/throttle/int_latency, or the toppars map) -- skipping that descent is exactly what
+        #   makes this mode cheap on large clusters. Non-librdkafka hash children found at the
+        #   root are still fully recursed for correctness. If you need a key nested inside one of
+        #   those sub-objects decorated, use the default full-decoration mode. When empty
+        #   (default), all numeric keys at every depth are decorated.
         def initialize(excluded_keys: [], only_keys: [])
           @previous = EMPTY_HASH
           # Operate on ms precision only
@@ -44,9 +59,12 @@ module Karafka
           @excluded_keys = unless excluded_keys.empty?
             excluded_keys.each_with_object({}) { |k, h| h[k] = true }.freeze
           end
-          # Frozen array for direct-access decoration, nil when empty to use full decoration
+          # Frozen array for direct-access decoration, nil when empty to use full decoration.
+          # Exclusions are applied once here (excluded_keys wins over only_keys), so the hot
+          # decoration loop iterates an already-filtered list and never re-checks exclusions.
           @only_keys = unless only_keys.empty?
-            only_keys.freeze
+            effective = @excluded_keys ? only_keys.reject { |k| @excluded_keys.key?(k) } : only_keys
+            effective.freeze
           end
         end
 
@@ -120,18 +138,17 @@ module Karafka
             if value.is_a?(Numeric)
               prev_value = filled_previous[key]
 
+              pair = cache[key] || (cache[key] = ["#{key}_fd".freeze, "#{key}_d".freeze].freeze)
+
               if prev_value.nil?
-                result = 0
-              elsif prev_value.is_a?(Numeric)
-                result = value - prev_value
+                current[pair[0]] = 0
+                current[pair[1]] = 0
               else
-                next
-              end
-
-              pair = cache[key] || (cache[key] = ["#{key}_fd".freeze, "#{key}_d".freeze].freeze)
+                result = value - prev_value
 
-              current[pair[0]] = (result == 0) ? (filled_previous[pair[0]] || 0) + change_d : 0
-              current[pair[1]] = result
+                current[pair[0]] = (result == 0) ? (filled_previous[pair[0]] || 0) + change_d : 0
+                current[pair[1]] = result
+              end
             elsif value.is_a?(Hash)
               diff_all(filled_previous[key], value, change_d)
             end
@@ -156,8 +173,13 @@ module Karafka
         # librdkafka statistics layout: root → brokers → broker, root → topics → topic →
         # partitions → partition, root → cgrp.
         #
-        # For non-librdkafka hash children (e.g. custom or test data), falls back to generic
-        # recursion to maintain correctness with arbitrary nested structures.
+        # Broker, topic, partition and cgrp nodes are decorated as leaves: their listed keys are
+        # decorated, but their nested sub-objects (e.g. broker window stats like rtt/throttle, or
+        # the toppars map) are NOT descended into. Not descending into those large sub-objects is
+        # the whole point of this path, so they are intentionally left untouched here.
+        #
+        # For non-librdkafka hash children at the root (e.g. custom or test data), falls back to
+        # generic recursion to maintain correctness with arbitrary nested structures.
         #
         # @param previous [Object] previous value from the given scope
         # @param current [Hash] current stats hash (root level)
@@ -209,8 +231,10 @@ module Karafka
           end
 
           # Consumer group (leaf-like)
-          cgrp = current["cgrp"]
-          decorate_keys(cgrp, filled_previous["cgrp"] || EMPTY_HASH, change_d) if cgrp.is_a?(Hash)
+          unless excluded&.key?("cgrp")
+            cgrp = current["cgrp"]
+            decorate_keys(cgrp, filled_previous["cgrp"] || EMPTY_HASH, change_d) if cgrp.is_a?(Hash)
+          end
 
           # Fallback: handle any non-standard hash children not in the known structure.
           # This ensures correctness for arbitrary nested data while the known paths above
@@ -275,18 +299,17 @@ module Karafka
 
             prev_value = filled_previous[key]
 
+            pair = cache[key] || (cache[key] = ["#{key}_fd".freeze, "#{key}_d".freeze].freeze)
+
             if prev_value.nil?
-              result = 0
-            elsif prev_value.is_a?(Numeric)
-              result = value - prev_value
+              current[pair[0]] = 0
+              current[pair[1]] = 0
             else
-              next
-            end
-
-            pair = cache[key] || (cache[key] = ["#{key}_fd".freeze, "#{key}_d".freeze].freeze)
+              result = value - prev_value
 
-            current[pair[0]] = (result == 0) ? (filled_previous[pair[0]] || 0) + change_d : 0
-            current[pair[1]] = result
+              current[pair[0]] = (result == 0) ? (filled_previous[pair[0]] || 0) + change_d : 0
+              current[pair[1]] = result
+            end
           end
         end
       end

data/lib/karafka/core/monitoring.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-# Main module namespace
 module Karafka
   module Core
     # Monitoring for Karafka and WaterDrop

data/lib/karafka/core/patches/rdkafka/bindings.rb

@@ -27,9 +27,28 @@ module Karafka
               ) do |client_ptr, err_code, reason, _opaque|
                 return nil unless ::Rdkafka::Config.error_callback
 
-                name = ::Rdkafka::Bindings.rd_kafka_name(client_ptr)
+                # Guard against a null client pointer. librdkafka can invoke the error callback
+                # with a NULL `rd_kafka_t` (e.g. very early in client construction), and calling
+                # `rd_kafka_name` on it dereferences the pointer and segfaults the whole process.
+                # Mirrors the upstream `ErrorCallback`.
+                name = client_ptr.null? ? nil : ::Rdkafka::Bindings.rd_kafka_name(client_ptr)
+
+                # Resolve fatal errors to their underlying cause. `ERR__FATAL` is only a generic
+                # marker; the real error code and description must be fetched from librdkafka via
+                # `rd_kafka_fatal_error` (done by `RdkafkaError.build_fatal`). Without this the
+                # callback would report the generic fatal code instead of the actual error.
+                # Mirrors the upstream `ErrorCallback`.
+                error = if err_code == ::Rdkafka::Bindings::RD_KAFKA_RESP_ERR__FATAL
+                  ::Rdkafka::RdkafkaError.build_fatal(
+                    client_ptr,
+                    fallback_error_code: err_code,
+                    fallback_message: reason,
+                    instance_name: name
+                  )
+                else
+                  ::Rdkafka::RdkafkaError.new(err_code, broker_message: reason)
+                end
 
-                error = ::Rdkafka::RdkafkaError.new(err_code, broker_message: reason)
                 error.set_backtrace(caller)
 
                 ::Rdkafka::Config.error_callback.call(name, error)

data/lib/karafka/core/taggable/tags.rb

@@ -10,6 +10,7 @@ module Karafka
         # Creates new tags accumulator
         def initialize
           @accu = {}
+          @values_cache = nil
         end
 
         # Adds a tag with a given name to tags
@@ -17,22 +18,25 @@ module Karafka
         # @param tag [#to_s] any object that can be converted into a string via `#to_s`
         def add(name, tag)
           @accu[name] = tag.to_s
+          @values_cache = nil
         end
 
         # Removes all the tags
         def clear
           @accu.clear
+          @values_cache = nil
         end
 
         # Removes a tag with a given name
         # @param name [Symbol] name of the tag
         def delete(name)
           @accu.delete(name)
+          @values_cache = nil
         end
 
         # @return [Array<String>] all unique tags registered
         def to_a
-          @accu.values.tap(&:uniq!)
+          @values_cache ||= @accu.values.uniq
         end
 
         # @param _args [Object] anything that the standard `to_json` accepts

data/lib/karafka/core/version.rb

@@ -2,8 +2,7 @@
 
 module Karafka
   module Core
-    # Current Karafka::Core version
-    # We follow the versioning schema of given Karafka version
-    VERSION = "2.6.1"
+    # Current Karafka::Core version. We follow the versioning schema of given Karafka version
+    VERSION = "2.6.3"
   end
 end

data/lib/karafka-core.rb

@@ -2,6 +2,7 @@
 
 require "logger"
 require "yaml"
+require "pathname"
 require "rdkafka"
 require "karafka/core"
 require "karafka/core/version"
@@ -14,6 +15,7 @@ require "karafka/core/monitoring/statistics_decorator"
 require "karafka/core/configurable"
 require "karafka/core/configurable/leaf"
 require "karafka/core/configurable/node"
+require "karafka/core/configurable/injector"
 require "karafka/core/contractable/contract"
 require "karafka/core/contractable/result"
 require "karafka/core/contractable/rule"
@@ -35,12 +37,12 @@ rd_config = Rdkafka::Config
 
 # Rdkafka uses a single global callback for things. We bypass that by injecting a manager for
 # each callback type. Callback manager allows us to register more than one callback
-# @note Those managers are also used by Karafka for consumer related statistics
+# Those managers are also used by Karafka for consumer related statistics
 rd_config.statistics_callback = instrumentation.statistics_callbacks
 rd_config.error_callback = instrumentation.error_callbacks
 rd_config.oauthbearer_token_refresh_callback = instrumentation.oauthbearer_token_refresh_callbacks
 
 # This loads librdkafka components into memory prior to initializing the client.
 # This mitigates macos forking issues.
-# @see https://github.com/confluentinc/librdkafka/issues/4590
+# See https://github.com/confluentinc/librdkafka/issues/4590
 Rdkafka::Bindings.rd_kafka_global_init if Rdkafka::Bindings.respond_to?(:rd_kafka_global_init)

data/package-lock.json

@@ -286,9 +286,9 @@
       }
     },
     "node_modules/smol-toml": {
-      "version": "1.6.1",
-      "resolved": "https://registry.npmjs.org/smol-toml/-/smol-toml-1.6.1.tgz",
-      "integrity": "sha512-dWUG8F5sIIARXih1DTaQAX4SsiTXhInKf1buxdY9DIg4ZYPZK5nGM1VRIYmEbDbsHt7USo99xSLFu5Q1IqTmsg==",
+      "version": "1.7.1",
+      "resolved": "https://registry.npmjs.org/smol-toml/-/smol-toml-1.7.1.tgz",
+      "integrity": "sha512-PPlsspAZ4jbMBu5DMFhfUGDQLu/vrL4SyBROVS37x8ynnVmFIs1VPBz1Co8Xks3TvpIaZXmU85y4DrQ+UyVFoQ==",
       "dev": true,
       "license": "BSD-3-Clause",
       "engines": {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: karafka-core
 version: !ruby/object:Gem::Version
-  version: 2.6.1
+  version: 2.6.3
 platform: ruby
 authors:
 - Maciej Mensfeld
@@ -72,6 +72,7 @@ files:
 - lib/karafka-core.rb
 - lib/karafka/core.rb
 - lib/karafka/core/configurable.rb
+- lib/karafka/core/configurable/injector.rb
 - lib/karafka/core/configurable/leaf.rb
 - lib/karafka/core/configurable/node.rb
 - lib/karafka/core/contractable.rb
@@ -120,7 +121,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Karafka ecosystem core modules
 test_files: []