karafka-core 2.5.13 → 2.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b7b0d02f8480d00419f928a4fd78f6159e4d7fdb24cae7d426141c7b38c5eb1
-  data.tar.gz: 45077c9e98c506d1f2e40c82b81548bebf7105ba606dedda2cc2a3eae43a0679
+  metadata.gz: 2d9f6ba569f0c3a911cbe3ce80c545f3069b5aa2560782cf88bd11c97baa0432
+  data.tar.gz: 54f274da23e99841809f884ea871ce9a55705d76d3c4e5c40b0ef2ffbe0ae75a
 SHA512:
-  metadata.gz: faeb1f7ceed771456e3b6c2864042efe95d1a398969987873d8fe9773d8bda46bf2f16fddc4e4da9dced9f96d1fa17de3924cd0723e3f4a7f92c31d82be00b13
-  data.tar.gz: 064c8be576d37001c06cb13d6694b1e044662c76867a625db52a9551dcc00cc0f2be67cc01497979be3025bc837e0282e596c27949bc9f8d085dca939c46d961
+  metadata.gz: 3a6c6ba64216479cebb2c4f574dff194ae6665189f382b0a60193c5b4ec3ab4d55f4ff97d7fb3fc90800f105a5284da27493b5694adff6e1a6c0738fa5795f65
+  data.tar.gz: 8ea0eddcd9ae95603041f8a74a1a26311cd9aa13744759dd6e7a699eb6ce682fd89596ef85e77ee2fd280d4aa3eca14d8f2ddd7a75dc322fe6e7bb33903ac7b6

data/.github/workflows/ci.yml

@@ -29,7 +29,7 @@ jobs:
           - ruby: '4.0'
             coverage: 'true'
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
         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@3ff19f5e2baf30647122352b96108b1fbe250c64 # v1.299.0
+        uses: ruby/setup-ruby@12fd324f1d0b43274fdc8130f6980590a667c455 # v1.312.0
         with:
           ruby-version: ${{matrix.ruby}}
           bundler: 'latest'
@@ -65,13 +65,13 @@ jobs:
     env:
       BUNDLE_GEMFILE: Gemfile.lint
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
         with:
           fetch-depth: 0
       - name: Set up Ruby
-        uses: ruby/setup-ruby@3ff19f5e2baf30647122352b96108b1fbe250c64 # v1.299.0
+        uses: ruby/setup-ruby@12fd324f1d0b43274fdc8130f6980590a667c455 # v1.312.0
         with:
-          ruby-version: '4.0.2'
+          ruby-version: '4.0.5'
           bundler-cache: true
       - name: Run rubocop
         run: bundle exec rubocop
@@ -82,13 +82,13 @@ jobs:
     env:
       BUNDLE_GEMFILE: Gemfile.lint
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
         with:
           fetch-depth: 0
       - name: Set up Ruby
-        uses: ruby/setup-ruby@3ff19f5e2baf30647122352b96108b1fbe250c64 # v1.299.0
+        uses: ruby/setup-ruby@12fd324f1d0b43274fdc8130f6980590a667c455 # v1.312.0
         with:
-          ruby-version: '4.0.2'
+          ruby-version: '4.0.5'
           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@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
         with:
           fetch-depth: 0
       - name: Set up Node.js
-        uses: actions/setup-node@53b83947a5a98c8d113130e565377fae1a50d02f # v6.3.0
+        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
         with:
           node-version: '20'
           cache: 'npm'

data/.github/workflows/push.yml

@@ -19,12 +19,12 @@ jobs:
       id-token: write
 
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
         with:
           fetch-depth: 0
 
       - name: Set up Ruby
-        uses: ruby/setup-ruby@3ff19f5e2baf30647122352b96108b1fbe250c64 # v1.299.0
+        uses: ruby/setup-ruby@12fd324f1d0b43274fdc8130f6980590a667c455 # v1.312.0
         with:
           bundler-cache: false
 

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

@@ -7,7 +7,7 @@ jobs:
   verify_action_pins:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
       - 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/.ruby-version

@@ -1 +1 @@
-4.0.2
+4.0.5

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Karafka Core Changelog
 
+## 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.
+- [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] 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`.
+- [Change] Assigning a setting on a frozen config node now raises `FrozenError` (previously the write silently mutated internal storage despite the freeze).
+
+## 2.6.0 (2026-06-10)
+- [Enhancement] Add `Node#register` to allow runtime key-value registration on compiled nodes without going through the static `setting` DSL. Useful for dynamic registries (e.g. named clusters) where setting names are not known at class-load time.
+- [Enhancement] Replace version-gated `Warning[:performance]` with a `Warning.categories`-based loop that enables all opt-in Ruby warning categories automatically, picking up new categories (e.g. `strict_unused_block` in Ruby 3.4+) without future patches.
+
 ## 2.5.13 (2026-04-08)
 - [Enhancement] Extract `decorate_partitions` method from `StatisticsDecorator` to allow subclasses to filter which partitions are decorated (e.g. skip unassigned partitions in a consumer context).
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    karafka-core (2.5.13)
+    karafka-core (2.6.1)
       karafka-rdkafka (>= 0.20.0)
       logger (>= 1.6.0)
 
@@ -12,56 +12,62 @@ GEM
       reline (>= 0.6.0)
     docile (1.4.1)
     drb (2.2.3)
-    ffi (1.17.2)
-    ffi (1.17.2-aarch64-linux-gnu)
-    ffi (1.17.2-aarch64-linux-musl)
-    ffi (1.17.2-arm-linux-gnu)
-    ffi (1.17.2-arm-linux-musl)
-    ffi (1.17.2-arm64-darwin)
-    ffi (1.17.2-x86-linux-gnu)
-    ffi (1.17.2-x86-linux-musl)
-    ffi (1.17.2-x86_64-darwin)
-    ffi (1.17.2-x86_64-linux-gnu)
-    ffi (1.17.2-x86_64-linux-musl)
+    ffi (1.17.4)
+    ffi (1.17.4-aarch64-linux-gnu)
+    ffi (1.17.4-aarch64-linux-musl)
+    ffi (1.17.4-arm-linux-gnu)
+    ffi (1.17.4-arm-linux-musl)
+    ffi (1.17.4-arm64-darwin)
+    ffi (1.17.4-x86-linux-gnu)
+    ffi (1.17.4-x86-linux-musl)
+    ffi (1.17.4-x86_64-darwin)
+    ffi (1.17.4-x86_64-linux-gnu)
+    ffi (1.17.4-x86_64-linux-musl)
     io-console (0.8.2)
-    json (2.15.1)
-    karafka-rdkafka (0.22.2)
-      ffi (~> 1.15)
+    json (2.19.7)
+    karafka-rdkafka (0.27.2)
+      ffi (~> 1.17.1)
       json (> 2.0)
       logger
       mini_portile2 (~> 2.6)
       rake (> 12)
-    karafka-rdkafka (0.22.2-aarch64-linux-gnu)
-      ffi (~> 1.15)
+    karafka-rdkafka (0.27.2-aarch64-linux-gnu)
+      ffi (~> 1.17.1)
       json (> 2.0)
       logger
       mini_portile2 (~> 2.6)
       rake (> 12)
-    karafka-rdkafka (0.22.2-arm64-darwin)
-      ffi (~> 1.15)
+    karafka-rdkafka (0.27.2-aarch64-linux-musl)
+      ffi (~> 1.17.1)
       json (> 2.0)
       logger
       mini_portile2 (~> 2.6)
       rake (> 12)
-    karafka-rdkafka (0.22.2-x86_64-linux-gnu)
-      ffi (~> 1.15)
+    karafka-rdkafka (0.27.2-arm64-darwin)
+      ffi (~> 1.17.1)
       json (> 2.0)
       logger
       mini_portile2 (~> 2.6)
       rake (> 12)
-    karafka-rdkafka (0.22.2-x86_64-linux-musl)
-      ffi (~> 1.15)
+    karafka-rdkafka (0.27.2-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)
+      ffi (~> 1.17.1)
       json (> 2.0)
       logger
       mini_portile2 (~> 2.6)
       rake (> 12)
     logger (1.7.0)
     mini_portile2 (2.8.9)
-    minitest (6.0.2)
+    minitest (6.0.6)
       drb (~> 2.0)
       prism (~> 1.5)
     prism (1.9.0)
-    rake (13.3.0)
+    rake (13.4.2)
     reline (0.6.3)
       io-console (~> 0.5)
     simplecov (0.22.0)
@@ -70,7 +76,7 @@ GEM
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.13.2)
     simplecov_json_formatter (0.1.4)
-    warning (1.5.0)
+    warning (1.6.0)
 
 PLATFORMS
   aarch64-linux-gnu

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

@@ -15,6 +15,49 @@ module Karafka
         # We need to be able to redefine children for deep copy
         attr_accessor :children
 
+        # Names that cannot be used as setting names because they would collide with the node
+        # internal state or the node public API: their accessors would shadow the node own
+        # readers (breaking for example `#deep_dup` or `#to_h`) and writers like `children=`
+        # would overwrite internal ivars. `#setting` and `#register` reject them upfront and
+        # `#ivar_backed?` keeps guarding the ivar mirror as defense in depth.
+        # Private method names are deliberately not reserved: that would make internal
+        # implementation details part of the public contract
+        RESERVED_NAMES = %i[
+          node_name
+          children
+          nestings
+          compiled
+          configs_refs
+          local_defs
+          setting
+          configure
+          to_h
+          deep_dup
+          register
+          compile
+        ].to_h { |name| [name, true] }.freeze
+
+        # Setting names that match this format can be backed by instance variables and use the
+        # fast `attr_reader` based readers. Others (e.g. registered names with dashes) fall back
+        # to the hash-based accessors
+        IVAR_NAMEABLE_FORMAT = /\A[A-Za-z_][A-Za-z0-9_]*\z/
+
+        private_constant :RESERVED_NAMES, :IVAR_NAMEABLE_FORMAT
+
+        class << self
+          # Builds each node through its own anonymous subclass. Since setting values are
+          # mirrored into instance variables for fast access and each node layout carries a
+          # different set of them, instantiating nodes directly from this class would grow its
+          # object shape variations past the Ruby limit, degrading ivar access for all nodes.
+          # A subclass per layout keeps shape variations per class minimal (late `setting`
+          # calls after inheritance or runtime `register` calls may add a few more, staying
+          # well under the limit). `#deep_dup` reuses the subclass of its template, so
+          # duplicated configs share shapes as well.
+          def new(...)
+            equal?(Node) ? Class.new(self).new(...) : super
+          end
+        end
+
         # @param node_name [Symbol] node name
         # @param nestings [Proc] block for nested settings
         # @param evaluate [Boolean] when false, skip evaluating the nestings block. Used by
@@ -31,12 +74,20 @@ module Karafka
 
         # Allows for a single leaf or nested node definition
         #
-        # @param node_name [Symbol] setting or nested node name
+        # @param node_name [Symbol, String] setting or nested node name
         # @param default [Object] default value
         # @param constructor [#call, nil] callable or nil
         # @param lazy [Boolean] is this a lazy leaf
         # @param block [Proc] block for nested settings
+        # @raise [ArgumentError] when the name is reserved for the node internal state
         def setting(node_name, default: nil, constructor: nil, lazy: false, &block)
+          # Symbolize at definition time (same as `#register`) so the config store, accessors,
+          # `#to_h` and the compile state checks all agree on the key type also when a String
+          # name is provided
+          node_name = node_name.to_sym
+
+          prevent_reserved_names!(node_name)
+
           @children << if block
             Node.new(node_name, block)
           else
@@ -85,12 +136,12 @@ module Karafka
         # and non-side-effect usage on an instance/inherited.
         # @return [Node] duplicated node
         def deep_dup
-          dupped = Node.new(node_name, nestings, evaluate: false)
+          # Same-layout nodes reuse the class of their template so they share object shapes
+          dupped = self.class.new(node_name, nestings, evaluate: false)
 
           children.each do |value|
             dupped.children << if value.is_a?(Leaf)
-              # After inheritance we need to reload the state so the leafs are
-              # recompiled again
+              # After inheritance we need to reload the state so the leafs are recompiled again
               value = value.dup
               value.compiled = false
               value
@@ -102,6 +153,36 @@ module Karafka
           dupped
         end
 
+        # Registers a key-value pair as a setting on an already-compiled node without going
+        # through the static `setting` DSL. Useful for dynamic registries (e.g. named clusters)
+        # where the keys are not known at class-load time.
+        #
+        # Unlike `setting`, which is designed to be called at class-definition time, `register`
+        # is safe to call at runtime because it:
+        #   - appends a pre-compiled Leaf so `deep_dup` and `to_h` include it
+        #   - sets `@configs_refs` directly so the reader accessor returns the value immediately
+        #   - builds reader/writer accessors via the same `build_accessors` path
+        #
+        # Raises `ArgumentError` if the name is already registered to prevent silent overwrites.
+        #
+        # @param name [Symbol, String] setting name
+        # @param value [Object] the setting value assigned immediately; also used as the default
+        #   when the node is deep-duped and recompiled on a new instance
+        # @raise [ArgumentError] when the name is already taken or reserved for the node
+        #   internal state
+        def register(name, value)
+          name = name.to_sym
+
+          prevent_reserved_names!(name)
+
+          raise ArgumentError, "#{name} is already registered" if @configs_refs.key?(name)
+
+          leaf = Leaf.new(name, value, nil, true, false)
+          @children << leaf
+          build_accessors(leaf)
+          config_write(name, value)
+        end
+
         # Converts the settings definitions into end children
         # @note It runs once, after things are compiled, they will not be recompiled again
         def compile
@@ -135,7 +216,7 @@ module Karafka
             if lazy_leaf && !initialized
               build_dynamic_accessor(value)
             else
-              @configs_refs[value.node_name] = initialized
+              config_write(value.node_name, initialized)
             end
           end
 
@@ -146,8 +227,7 @@ module Karafka
 
         # Defines a lazy evaluated read and writer that will re-evaluate in case value constructor
         # evaluates to `nil` or `false`. This allows us to define dynamic constructors that
-        # can react to external conditions to become expected value once this value is
-        # available
+        # can react to external conditions to become expected value once this value is available
         #
         # @param value [Leaf]
         def build_dynamic_accessor(value)
@@ -182,6 +262,12 @@ module Karafka
 
         # Builds regular accessors for value fetching
         #
+        # Settings with names that can form valid instance variables get `attr_reader` based
+        # readers backed by an ivar mirror of the config value. This is significantly faster
+        # than a method with a hash lookup, which matters since settings are read on hot paths
+        # across the whole ecosystem. `@configs_refs` remains the canonical store used by
+        # `#to_h`, `#compile` and `#register`, with `#config_write` keeping the mirror in sync.
+        #
         # @param value [Leaf]
         def build_accessors(value)
           reader_name = value.node_name.to_sym
@@ -194,17 +280,64 @@ module Karafka
           if reader_respond ? !@local_defs.key?(reader_name) : true
             @local_defs[reader_name] = true
 
-            define_singleton_method(reader_name) do
-              @configs_refs[reader_name]
+            if ivar_backed?(reader_name)
+              singleton_class.attr_reader(reader_name)
+            else
+              define_singleton_method(reader_name) do
+                @configs_refs[reader_name]
+              end
             end
           end
 
-          return if respond_to?(:"#{value.node_name}=")
+          return if respond_to?(:"#{reader_name}=")
 
-          define_singleton_method(:"#{value.node_name}=") do |new_value|
-            @configs_refs[value.node_name] = new_value
+          if ivar_backed?(reader_name)
+            ivar_name = :"@#{reader_name}"
+
+            define_singleton_method(:"#{reader_name}=") do |new_value|
+              instance_variable_set(ivar_name, @configs_refs[reader_name] = new_value)
+            end
+          else
+            define_singleton_method(:"#{reader_name}=") do |new_value|
+              @configs_refs[reader_name] = new_value
+            end
           end
         end
+
+        # Writes a config value to the canonical store and mirrors it into the backing instance
+        # variable when the setting uses the fast ivar-backed reader
+        #
+        # @param name [Symbol, String] setting name
+        # @param value [Object] config value assigned to the setting
+        def config_write(name, value)
+          # Accessors operate on symbolized names, so the store has to be keyed consistently.
+          # This also guarantees that a String name matching a reserved internal name is
+          # recognized by the `ivar_backed?` guard and cannot corrupt the node internal state
+          name = name.to_sym
+
+          @configs_refs[name] = value
+          instance_variable_set(:"@#{name}", value) if ivar_backed?(name)
+        end
+
+        # @param name [Symbol] setting name
+        # @return [Boolean] true if this setting can be backed by an instance variable and use
+        #   the fast `attr_reader` based reader
+        def ivar_backed?(name)
+          !RESERVED_NAMES.key?(name) && IVAR_NAMEABLE_FORMAT.match?(name)
+        end
+
+        # Rejects setting names that would collide with the node internal state. Without this,
+        # such names would shadow the node own accessors, breaking `#deep_dup` and silently
+        # corrupting internals on assignment (e.g. `config.children = value` hitting the node
+        # own `attr_writer`)
+        #
+        # @param name [Symbol] already symbolized setting name
+        # @raise [ArgumentError] when the name is reserved
+        def prevent_reserved_names!(name)
+          return unless RESERVED_NAMES.key?(name)
+
+          raise ArgumentError, "#{name} is a reserved name and cannot be used as a setting name"
+        end
       end
     end
   end

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

@@ -15,7 +15,7 @@ module Karafka
         DIG_MISS = Object.new
 
         # Empty array for scope default to avoid allocating a new Array on each
-        # `#call` / `#validate!` invocation. Safe because scope is never mutated – it is only
+        # `#call` / `#validate!` invocation. Safe because scope is never mutated - it is only
         # used in `scope + rule.path` which creates a new Array.
         EMPTY_ARRAY = [].freeze
 
@@ -81,6 +81,12 @@ module Karafka
 
         # Runs the validation
         #
+        # The per-rule handling is inlined instead of dispatching to per-type methods because
+        # this runs per rule per validation, including the per-message validations in
+        # WaterDrop. Required and optional rules share the whole flow except the missing-key
+        # handling. `DIG_MISS` is compared via `#equal?` so we never dispatch `#==` to the
+        # validated (user-provided) values.
+        #
         # @param data [Hash] hash with data we want to validate
         # @param scope [Array<String>] scope of this contract (if any) or empty array if no parent
         #   scope is needed if contract starts from root
@@ -89,13 +95,28 @@ module Karafka
           errors = []
 
           self.class.rules.each do |rule|
-            case rule.type
-            when :required
-              validate_required(data, rule, errors, scope)
-            when :optional
-              validate_optional(data, rule, errors, scope)
-            when :virtual
-              validate_virtual(data, rule, errors, scope)
+            if rule.type == :virtual
+              result = rule.validator.call(data, errors, self)
+
+              next if result == true
+
+              result&.each do |sub_result|
+                sub_result[0] = scope + sub_result[0]
+              end
+
+              errors.push(*result)
+            else
+              for_checking = dig(data, rule.path)
+
+              if DIG_MISS.equal?(for_checking)
+                errors << [scope + rule.path, :missing] if rule.type == :required
+              else
+                result = rule.validator.call(for_checking, data, errors, self)
+
+                next if result == true
+
+                errors << [scope + rule.path, result || :format]
+              end
             end
           end
 
@@ -121,99 +142,39 @@ module Karafka
 
         private
 
-        # Runs validation for rules on fields that are required and adds errors (if any) to the
-        # errors array
-        #
-        # @param data [Hash] input hash
-        # @param rule [Rule] validation rule
-        # @param errors [Array] array with errors from previous rules (if any)
-        # @param scope [Array<String>]
-        def validate_required(data, rule, errors, scope)
-          for_checking = dig(data, rule.path)
-
-          # We need to compare `DIG_MISS` against stuff because of the ownership of the `#==`
-          # method
-          if for_checking == DIG_MISS
-            errors << [scope + rule.path, :missing]
-          else
-            result = rule.validator.call(for_checking, data, errors, self)
-
-            return if result == true
-
-            errors << [scope + rule.path, result || :format]
-          end
-        end
-
-        # Runs validation for rules on fields that are optional and adds errors (if any) to the
-        # errors array
-        #
-        # @param data [Hash] input hash
-        # @param rule [Rule] validation rule
-        # @param errors [Array] array with errors from previous rules (if any)
-        # @param scope [Array<String>]
-        def validate_optional(data, rule, errors, scope)
-          for_checking = dig(data, rule.path)
-
-          return if for_checking == DIG_MISS
-
-          result = rule.validator.call(for_checking, data, errors, self)
-
-          return if result == true
-
-          errors << [scope + rule.path, result || :format]
-        end
-
-        # Runs validation for rules on virtual fields (aggregates, etc) and adds errors (if any) to
-        # the errors array
-        #
-        # @param data [Hash] input hash
-        # @param rule [Rule] validation rule
-        # @param errors [Array] array with errors from previous rules (if any)
-        # @param scope [Array<String>]
-        def validate_virtual(data, rule, errors, scope)
-          result = rule.validator.call(data, errors, self)
-
-          return if result == true
-
-          result&.each do |sub_result|
-            sub_result[0] = scope + sub_result[0]
-          end
-
-          errors.push(*result)
-        end
-
         # Tries to dig for a given key in a hash and returns it with indication whether or not it
         # was possible to find it (dig returns nil and we don't know if it wasn't the digged key
         # value)
         #
+        # Uses `Hash#fetch` with the `DIG_MISS` sentinel as the default, which resolves presence
+        # and value in a single hash lookup instead of a `key?` check followed by `[]`. This
+        # runs per rule per validation, including the per-message validations in WaterDrop,
+        # hence the lookup count matters. `fetch` with a default ignores `default_proc`, same
+        # as the previous `key?` based logic.
+        #
         # @param data [Hash]
         # @param keys [Array<Symbol>]
         # @return [DIG_MISS, Object] found element or DIGG_MISS indicating that not found
         def dig(data, keys)
           case keys.length
           when 1
-            key = keys[0]
-
-            return DIG_MISS unless data.key?(key)
-
-            data[key]
+            data.fetch(keys[0], DIG_MISS)
           when 2
-            key1 = keys[0]
-
-            return DIG_MISS unless data.key?(key1)
+            mid = data.fetch(keys[0], DIG_MISS)
 
-            mid = data[key1]
+            return DIG_MISS if DIG_MISS.equal?(mid)
+            return DIG_MISS unless mid.is_a?(Hash)
 
-            return DIG_MISS unless mid.is_a?(Hash) && mid.key?(keys[1])
-
-            mid[keys[1]]
+            mid.fetch(keys[1], DIG_MISS)
           else
             current = data
 
             keys.each do |nesting|
-              return DIG_MISS unless current.key?(nesting)
+              return DIG_MISS unless current.is_a?(Hash)
+
+              current = current.fetch(nesting, DIG_MISS)
 
-              current = current[nesting]
+              return DIG_MISS if DIG_MISS.equal?(current)
             end
 
             current

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

@@ -28,7 +28,15 @@ module Karafka
         # @param event_id [String, Symbol] event id
         # @param payload [Hash]
         def instrument(event_id, payload = EMPTY_HASH, &)
-          full_event_name = @mapped_events[event_id] ||= [event_id, @namespace].compact.join(".")
+          # With no namespace, string event ids already are the full event names. This is the
+          # case for all the events in the Karafka ecosystem, so we can skip the mapping hash
+          # lookup on this hot path. Symbols still go through the mapping to be converted into
+          # strings without allocating on each call.
+          full_event_name = if @namespace.nil? && event_id.is_a?(String)
+            event_id
+          else
+            @mapped_events[event_id] ||= [event_id, @namespace].compact.join(".")
+          end
 
           @notifications_bus.instrument(full_event_name, payload, &)
         end

data/lib/karafka/core/version.rb

@@ -4,6 +4,6 @@ module Karafka
   module Core
     # Current Karafka::Core version
     # We follow the versioning schema of given Karafka version
-    VERSION = "2.5.13"
+    VERSION = "2.6.1"
   end
 end

data/package-lock.json

@@ -217,9 +217,9 @@
       }
     },
     "node_modules/picomatch": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
-      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.2.tgz",
+      "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -286,9 +286,9 @@
       }
     },
     "node_modules/smol-toml": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/smol-toml/-/smol-toml-1.6.0.tgz",
-      "integrity": "sha512-4zemZi0HvTnYwLfrpk/CF9LOd9Lt87kAt50GnqhMpyF9U3poDAP2+iukq2bZsO/ufegbYehBkqINbsWxj4l4cw==",
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/smol-toml/-/smol-toml-1.6.1.tgz",
+      "integrity": "sha512-dWUG8F5sIIARXih1DTaQAX4SsiTXhInKf1buxdY9DIg4ZYPZK5nGM1VRIYmEbDbsHt7USo99xSLFu5Q1IqTmsg==",
       "dev": true,
       "license": "BSD-3-Clause",
       "engines": {
@@ -312,9 +312,9 @@
       }
     },
     "node_modules/yaml": {
-      "version": "2.8.2",
-      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.8.2.tgz",
-      "integrity": "sha512-mplynKqc1C2hTVYxd0PU2xQAc22TI1vShAYGksCCfxbn/dFwnHTNi1bvYsBTkhdUNtGIf5xNOg938rrSSYvS9A==",
+      "version": "2.9.0",
+      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.9.0.tgz",
+      "integrity": "sha512-2AvhNX3mb8zd6Zy7INTtSpl1F15HW6Wnqj0srWlkKLcpYl/gMIMJiyuGq2KeI2YFxUPjdlB+3Lc10seMLtL4cA==",
       "dev": true,
       "license": "ISC",
       "bin": {

data/renovate.json

@@ -15,7 +15,7 @@
     {
       "minimumReleaseAge": "7 days",
       "matchDepNames": [
-        "/*/"
+        "*"
       ]
     },
     {
@@ -30,11 +30,25 @@
         "ruby/setup-ruby",
         "ruby"
       ],
-      "groupName": "ruby setup"
+      "groupName": "ruby setup",
+      "internalChecksFilter": "strict"
+    },
+    {
+      "description": "Let setup-ruby pass age gate before ruby so it is ready when the group PR is created",
+      "matchPackageNames": [
+        "ruby/setup-ruby"
+      ],
+      "minimumReleaseAge": "5 days"
     }
   ],
   "labels": [
     "dependencies"
   ],
-  "minimumReleaseAge": "7 days"
+  "minimumReleaseAge": "7 days",
+  "lockFileMaintenance": {
+    "enabled": true,
+    "schedule": [
+      "before 4am on the first day of the month"
+    ]
+  }
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: karafka-core
 version: !ruby/object:Gem::Version
-  version: 2.5.13
+  version: 2.6.1
 platform: ruby
 authors:
 - Maciej Mensfeld
@@ -120,7 +120,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Karafka ecosystem core modules
 test_files: []