karafka 2.5.1 → 2.5.3

data/lib/karafka/pro/routing/features/swarm/contracts/routing.rb

@@ -18,10 +18,8 @@ module Karafka
             # This is why we use it before warmup when everything is expected to be configured.
             class Routing < Karafka::Contracts::Base
               configure do |config|
-                config.error_messages = YAML.safe_load(
-                  File.read(
-                    File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-                  )
+                config.error_messages = YAML.safe_load_file(
+                  File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
                 ).fetch('en').fetch('validations').fetch('routing')
               end
 

data/lib/karafka/pro/routing/features/swarm/contracts/topic.rb

@@ -13,10 +13,8 @@ module Karafka
             # Contract to validate configuration of the swarm feature
             class Topic < Karafka::Contracts::Base
               configure do |config|
-                config.error_messages = YAML.safe_load(
-                  File.read(
-                    File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-                  )
+                config.error_messages = YAML.safe_load_file(
+                  File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
                 ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
               end
 
@@ -25,15 +23,15 @@ module Karafka
 
                 required(:nodes) do |val|
                   next true if val.is_a?(Range)
-                  next true if val.is_a?(Array) && val.all? { |id| id.is_a?(Integer) }
+                  next true if val.is_a?(Array) && val.all?(Integer)
                   next false unless val.is_a?(Hash)
-                  next false unless val.keys.all? { |id| id.is_a?(Integer) }
+                  next false unless val.keys.all?(Integer)
 
                   values = val.values
 
                   next false unless values.all? { |ps| ps.is_a?(Array) || ps.is_a?(Range) }
-                  next true if values.flatten.all? { |part| part.is_a?(Integer) }
-                  next true if values.flatten.all? { |part| part.is_a?(Range) }
+                  next true if values.flatten.all?(Integer)
+                  next true if values.flatten.all?(Range)
 
                   false
                 end

data/lib/karafka/pro/routing/features/swarm.rb

@@ -14,7 +14,7 @@ module Karafka
             # Binds our routing validation contract prior to warmup in the supervisor, so we can
             # run it when all the context should be there (config + full routing)
             #
-            # @param config [Karafka::Core::Configurable::Node] app config
+            # @param config [Karafka::Core::Configurable::Node]
             def post_setup(config)
               config.monitor.subscribe('app.before_warmup') do
                 Contracts::Routing.new.validate!(

data/lib/karafka/pro/routing/features/throttling/contracts/topic.rb

@@ -13,10 +13,8 @@ module Karafka
             # Rules around throttling settings
             class Topic < Karafka::Contracts::Base
               configure do |config|
-                config.error_messages = YAML.safe_load(
-                  File.read(
-                    File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-                  )
+                config.error_messages = YAML.safe_load_file(
+                  File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
                 ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
               end
 

data/lib/karafka/pro/routing/features/throttling/topic.rb

@@ -46,7 +46,9 @@ module Karafka
 
             # Just an alias for nice API
             #
-            # @param args [Array] Anything `#throttling` accepts
+            # @param args [Hash] Anything `#throttling` accepts
+            # @option args [Integer] :limit max messages to process in a time interval
+            # @option args [Integer] :interval time interval for processing in milliseconds
             def throttle(**args)
               throttling(**args)
             end

data/lib/karafka/pro/routing/features/virtual_partitions/contracts/topic.rb

@@ -13,10 +13,8 @@ module Karafka
             # Rules around virtual partitions
             class Topic < Karafka::Contracts::Base
               configure do |config|
-                config.error_messages = YAML.safe_load(
-                  File.read(
-                    File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-                  )
+                config.error_messages = YAML.safe_load_file(
+                  File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
                 ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
               end
 

data/lib/karafka/pro/scheduled_messages/consumer.rb

@@ -7,7 +7,7 @@ module Karafka
   module Pro
     module ScheduledMessages
       # Consumer that coordinates scheduling of messages when the time comes
-      class Consumer < ::Karafka::BaseConsumer
+      class Consumer < Karafka::BaseConsumer
         include Helpers::ConfigImporter.new(
           dispatcher_class: %i[scheduled_messages dispatcher_class]
         )

data/lib/karafka/pro/scheduled_messages/contracts/config.rb

@@ -9,17 +9,15 @@ module Karafka
       # Recurring Tasks related contracts
       module Contracts
         # Makes sure, all the expected config is defined as it should be
-        class Config < ::Karafka::Contracts::Base
+        class Config < Karafka::Contracts::Base
           configure do |config|
-            config.error_messages = YAML.safe_load(
-              File.read(
-                File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-              )
+            config.error_messages = YAML.safe_load_file(
+              File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
             ).fetch('en').fetch('validations').fetch('setup').fetch('config')
           end
 
           nested(:scheduled_messages) do
-            required(:consumer_class) { |val| val < ::Karafka::BaseConsumer }
+            required(:consumer_class) { |val| val < Karafka::BaseConsumer }
 
             # Do not allow to run more often than every second
             required(:interval) { |val| val.is_a?(Integer) && val >= 1_000 }

data/lib/karafka/pro/scheduled_messages/contracts/message.rb

@@ -11,12 +11,10 @@ module Karafka
         #
         # Our envelope always needs to comply with this format, otherwise we won't have enough
         # details to be able to dispatch the message
-        class Message < ::Karafka::Contracts::Base
+        class Message < Karafka::Contracts::Base
           configure do |config|
-            config.error_messages = YAML.safe_load(
-              File.read(
-                File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-              )
+            config.error_messages = YAML.safe_load_file(
+              File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
             ).fetch('en').fetch('validations').fetch('scheduled_messages_message')
           end
 

data/lib/karafka/pro/scheduled_messages/daily_buffer.rb

@@ -14,6 +14,7 @@ module Karafka
       # up to 1.5 second, thus it is acceptable. Please ping me if you encounter performance
       # issues with this naive implementation so it can be improved.
       class DailyBuffer
+        # Initializes the daily buffer with empty accumulator
         def initialize
           @accu = {}
         end
@@ -69,8 +70,8 @@ module Karafka
           selected.each { |_, message| yield(message) }
         end
 
-        # Removes given key from the accumulator
-        # @param key [String] key to remove
+        # Removes the schedule entry identified by the given key from the daily buffer
+        # @param key [String]
         def delete(key)
           @accu.delete(key)
         end

data/lib/karafka/pro/scheduled_messages/day.rb

@@ -18,6 +18,7 @@ module Karafka
         # @return [Integer] utc timestamp when this day starts. Equal to 00:00:00
         attr_reader :starts_at
 
+        # Initializes a day representation for the current UTC day
         def initialize
           @created_at = Time.now.to_i
 

data/lib/karafka/pro/scheduled_messages/deserializers/headers.rb

@@ -16,7 +16,7 @@ module Karafka
 
           private_constant :WORKABLE_TYPES
 
-          # @param metadata [Karafka::aMessages::Metadata]
+          # @param metadata [Karafka::Messages::Metadata]
           # @return [Hash] headers
           def call(metadata)
             raw_headers = metadata.raw_headers

data/lib/karafka/pro/scheduled_messages/deserializers/payload.rb

@@ -15,7 +15,7 @@ module Karafka
           # @param message [::Karafka::Messages::Message]
           # @return [Hash] deserialized data
           def call(message)
-            ::JSON.parse(
+            JSON.parse(
               Zlib::Inflate.inflate(message.raw_payload),
               symbolize_names: true
             )

data/lib/karafka/pro/scheduled_messages/max_epoch.rb

@@ -23,6 +23,7 @@ module Karafka
         # @return [Integer] max epoch recorded
         attr_reader :to_i
 
+        # Initializes max epoch tracker with -1 as starting value
         def initialize
           @max = -1
           @to_i = @max

data/lib/karafka/pro/scheduled_messages/proxy.rb

@@ -21,7 +21,7 @@ module Karafka
       module Proxy
         # General WaterDrop message contract. Before we envelop a message, we need to be certain
         # it is correct, hence we use this contract.
-        MSG_CONTRACT = ::WaterDrop::Contracts::Message.new(
+        MSG_CONTRACT = WaterDrop::Contracts::Message.new(
           # Payload size is a subject to the target producer dispatch validation, so we set it
           # to 100MB basically to ignore it here.
           max_payload_size: 104_857_600

data/lib/karafka/pro/scheduled_messages/serializer.rb

@@ -9,7 +9,7 @@ module Karafka
       # Serializers used to build payloads (if applicable) for dispatch
       # @note We only deal with states payload. Other payloads are not ours but end users.
       class Serializer
-        include ::Karafka::Core::Helpers::Time
+        include Karafka::Core::Helpers::Time
 
         # @param tracker [Tracker] tracker based on which we build the state
         # @return [String] compressed payload with the state details
@@ -32,9 +32,9 @@ module Karafka
           hash.to_json
         end
 
-        # Compresses the provided data
+        # Compresses the provided data using Zlib deflate algorithm
         #
-        # @param data [String] data to compress
+        # @param data [String]
         # @return [String] compressed data
         def compress(data)
           Zlib::Deflate.deflate(data)

data/lib/karafka/pro/scheduled_messages/setup/config.rb

@@ -10,7 +10,7 @@ module Karafka
       module Setup
         # Config for recurring tasks
         class Config
-          extend ::Karafka::Core::Configurable
+          extend Karafka::Core::Configurable
 
           setting(:consumer_class, default: Consumer)
           setting(:group_id, default: 'karafka_scheduled_messages')
@@ -27,7 +27,7 @@ module Karafka
           # Producer to use. By default uses default Karafka producer.
           setting(
             :producer,
-            constructor: -> { ::Karafka.producer },
+            constructor: -> { Karafka.producer },
             lazy: true
           )
 

data/lib/karafka/pro/scheduled_messages/state.rb

@@ -27,6 +27,7 @@ module Karafka
 
         private_constant :STATES
 
+        # Initializes the state as fresh
         def initialize
           @state = 'fresh'
         end

data/lib/karafka/pro/scheduled_messages/tracker.rb

@@ -18,6 +18,7 @@ module Karafka
         # @return [Integer] time epoch when this tracker was started
         attr_reader :started_at
 
+        # Initializes the tracker with empty statistics
         def initialize
           @daily = Hash.new { |h, k| h[k] = 0 }
           @started_at = Time.now.to_i

data/lib/karafka/pro/scheduled_messages.rb

@@ -24,17 +24,15 @@ module Karafka
 
       class << self
         # Runs the `Proxy.call`
-        # @param kwargs [Hash] things requested by the proxy
         # @return [Hash] message wrapped with the scheduled message envelope
-        def schedule(**kwargs)
-          Proxy.schedule(**kwargs)
+        def schedule(**)
+          Proxy.schedule(**)
         end
 
         # Generates a tombstone message to cancel given dispatch (if not yet happened)
-        # @param kwargs [Hash] things requested by the proxy
         # @return [Hash] tombstone cancelling message
-        def cancel(**kwargs)
-          Proxy.cancel(**kwargs)
+        def cancel(**)
+          Proxy.cancel(**)
         end
 
         # Below are private APIs

data/lib/karafka/pro/swarm/liveness_listener.rb

@@ -171,14 +171,14 @@ module Karafka
         def rss_mb_linux
           kb_rss = 0
 
-          IO.readlines("/proc/#{node.pid}/status").each do |line|
+          File.readlines("/proc/#{node.pid}/status").each do |line|
             next unless line.start_with?('VmRSS:')
 
             kb_rss = line.split[1].to_i
             break
           end
 
-          (kb_rss / 1_024.to_i).round
+          (kb_rss / 1_024).round
         rescue Errno::ENOENT, Errno::EACCES
           # /proc file doesn't exist or no permission to read it
           0

data/lib/karafka/process.rb

@@ -5,7 +5,7 @@ module Karafka
   # @note There might be only one process - this class is a singleton
   class Process
     # Allow for process tagging for instrumentation
-    extend ::Karafka::Core::Taggable
+    extend Karafka::Core::Taggable
 
     # Signal types that we handle
     HANDLED_SIGNALS = %i[
@@ -79,12 +79,12 @@ module Karafka
     private
 
     # Traps a single signal and performs callbacks (if any) or just ignores this signal
-    # @param [Symbol] signal type that we want to catch
+    # @param signal [Symbol] signal type that we want to catch
     # @note Since we do a lot of threading and queuing, we don't want to handle signals from the
     # trap context s some things may not work there as expected, that is why we spawn a separate
     # thread to handle the signals process
     def trap_signal(signal)
-      previous_handler = ::Signal.trap(signal) do
+      previous_handler = Signal.trap(signal) do
         Thread.new do
           notice_signal(signal)
 
@@ -96,7 +96,7 @@ module Karafka
     end
 
     # Informs monitoring about trapped signal
-    # @param [Symbol] signal type that we received
+    # @param signal [Symbol] signal type that we received
     def notice_signal(signal)
       Karafka.monitor.instrument('process.notice_signal', caller: self, signal: signal)
     end

data/lib/karafka/processing/coordinator.rb

@@ -198,8 +198,6 @@ module Karafka
 
       # Allows to run synchronized (locked) code that can operate only from a given thread
       #
-      # @param block [Proc] code we want to run in the synchronized mode
-      #
       # @note We check if mutex is not owned already by the current thread so we won't end up with
       #   a deadlock in case user runs coordinated code from inside of his own lock
       #
@@ -207,11 +205,11 @@ module Karafka
       #   Otherwise user indirectly could cause deadlocks or prolonged locks by running his logic.
       #   This can and should however be used for multi-thread strategy applications and other
       #   internal operations locks.
-      def synchronize(&block)
+      def synchronize(&)
         if @mutex.owned?
           yield
         else
-          @mutex.synchronize(&block)
+          @mutex.synchronize(&)
         end
       end
     end

data/lib/karafka/processing/coordinators_buffer.rb

@@ -36,11 +36,10 @@ module Karafka
       end
 
       # Resumes processing of partitions for which pause time has ended.
-      # @param block we want to run for resumed topic partitions
       # @yieldparam [String] topic name
       # @yieldparam [Integer] partition number
-      def resume(&block)
-        @pauses_manager.resume(&block)
+      def resume(&)
+        @pauses_manager.resume(&)
       end
 
       # @param topic_name [String] topic name

data/lib/karafka/processing/executor.rb

@@ -83,9 +83,8 @@ module Karafka
 
       # Runs the wrap/around execution context appropriate for a given action
       # @param action [Symbol] action execution wrapped with our block
-      # @param block [Proc] execution context
-      def wrap(action, &block)
-        consumer.on_wrap(action, &block)
+      def wrap(action, &)
+        consumer.on_wrap(action, &)
       end
 
       # Runs consumer data processing against given batch and handles failures and errors.
@@ -185,7 +184,7 @@ module Karafka
           # We assign producer only when not available already. It may already be available if
           # user redefined the `#producer` method for example. This can be useful for example when
           # having a multi-cluster setup and using a totally custom producer
-          consumer.producer ||= ::Karafka::App.producer
+          consumer.producer ||= Karafka::App.producer
           # Since we have some message-less flows (idle, etc), we initialize consumer with empty
           # messages set. In production we have persistent consumers, so this is not a performance
           # overhead as this will happen only once per consumer lifetime

data/lib/karafka/processing/inline_insights/tracker.rb

@@ -51,6 +51,7 @@ module Karafka
           def_delegators :instance, :find, :add, :exists?, :clear
         end
 
+        # Initializes the tracker with empty accumulator
         def initialize
           @accu = {}
           @mutex = Mutex.new

data/lib/karafka/processing/jobs/base.rb

@@ -29,11 +29,10 @@ module Karafka
         end
 
         # Runs the wrap/around job hook within which the rest of the flow happens
-        # @param block [Proc] whole user related processing flow
         # @note We inject the action name so user can decide whether to run custom logic on a
         #   given action or not.
-        def wrap(&block)
-          executor.wrap(self.class.action, &block)
+        def wrap(&)
+          executor.wrap(self.class.action, &)
         end
 
         # When redefined can run any code prior to the job being scheduled

data/lib/karafka/processing/jobs_queue.rb

@@ -99,7 +99,7 @@ module Karafka
       # Marks a given job from a given group as completed. When there are no more jobs from a given
       # group to be executed, we won't wait.
       #
-      # @param [Jobs::Base] job that was completed
+      # @param job [Jobs::Base] job that was completed
       def complete(job)
         @mutex.synchronize do
           # We finish one job and if there is another, we pick it up

data/lib/karafka/processing/result.rb

@@ -8,6 +8,7 @@ module Karafka
     class Result
       attr_reader :cause
 
+      # Initializes the result as successful with no cause
       def initialize
         @success = true
         @cause = false

data/lib/karafka/processing/strategy_selector.rb

@@ -13,6 +13,7 @@ module Karafka
         dead_letter_queue
       ].freeze
 
+      # Initializes the strategy selector and preloads all strategies
       def initialize
         # We load them once for performance reasons not to do too many lookups
         @strategies = find_all

data/lib/karafka/processing/workers_batch.rb

@@ -16,9 +16,8 @@ module Karafka
       end
 
       # Iterates over available workers and yields each worker
-      # @param block [Proc] block we want to run
-      def each(&block)
-        @batch.each(&block)
+      def each(&)
+        @batch.each(&)
       end
 
       # @return [Integer] number of workers in the batch

data/lib/karafka/railtie.rb

@@ -49,6 +49,7 @@ if Karafka.rails?
         rails71plus = Rails.gem_version >= Gem::Version.new('7.1.0')
 
         # Rails 7.1 replaced the broadcast module with a broadcast logger
+        # While 7.1 is EOL, we keep this for users who may still use it without official support
         if rails71plus
           Rails.logger.broadcast_to(stdout_logger)
         else

data/lib/karafka/routing/activity_manager.rb

@@ -12,6 +12,7 @@ module Karafka
         topics
       ].freeze
 
+      # Initializes the activity manager with empty inclusion and exclusion lists
       def initialize
         @included = Hash.new { |h, k| h[k] = [] }
         @excluded = Hash.new { |h, k| h[k] = [] }
@@ -58,8 +59,8 @@ module Karafka
       # @return [Hash] accumulated data in a hash for validations
       def to_h
         (
-          SUPPORTED_TYPES.map { |type| ["include_#{type}".to_sym, @included[type]] } +
-          SUPPORTED_TYPES.map { |type| ["exclude_#{type}".to_sym, @excluded[type]] }
+          SUPPORTED_TYPES.map { |type| [:"include_#{type}", @included[type]] } +
+          SUPPORTED_TYPES.map { |type| [:"exclude_#{type}", @excluded[type]] }
         ).to_h
       end
 

data/lib/karafka/routing/builder.rb

@@ -23,6 +23,7 @@ module Karafka
 
       private_constant :EMPTY_DEFAULTS
 
+      # Initializes the routing builder with empty routes
       def initialize
         @mutex = Mutex.new
         @draws = []
@@ -81,13 +82,12 @@ module Karafka
       private :array_clear
 
       # Clear routes and draw them again with the given block. Helpful for testing purposes.
-      # @param block [Proc] block we will evaluate within the builder context
-      def redraw(&block)
+      def redraw(&)
         @mutex.synchronize do
           @draws.clear
           array_clear
         end
-        draw(&block)
+        draw(&)
       end
 
       # @return [Array<Karafka::Routing::ConsumerGroup>] only active consumer groups that
@@ -124,15 +124,14 @@ module Karafka
 
       # Builds and saves given consumer group
       # @param group_id [String, Symbol] name for consumer group
-      # @param block [Proc] proc that should be executed in the proxy context
-      def consumer_group(group_id, &block)
+      def consumer_group(group_id, &)
         consumer_group = find { |cg| cg.name == group_id.to_s }
 
         if consumer_group
-          Proxy.new(consumer_group, &block).target
+          Proxy.new(consumer_group, &).target
         else
           consumer_group = ConsumerGroup.new(group_id.to_s)
-          self << Proxy.new(consumer_group, &block).target
+          self << Proxy.new(consumer_group, &).target
         end
       end
 
@@ -140,8 +139,9 @@ module Karafka
       # subscription group customization
       # @param subscription_group_name [String, Symbol] subscription group id. When not provided,
       #   a random uuid will be used
-      # @param args [Array] any extra arguments accepted by the subscription group builder
+      # @param args [Hash] any extra arguments accepted by the subscription group builder
       # @param block [Proc] further topics definitions
+      # @option args [String] :kafka optional kafka scope settings
       def subscription_group(
         subscription_group_name = SubscriptionGroup.id,
         **args,

data/lib/karafka/routing/consumer_group.rb

@@ -40,14 +40,13 @@ module Karafka
 
       # Builds a topic representation inside of a current consumer group route
       # @param name [String, Symbol] name of topic to which we want to subscribe
-      # @param block [Proc] block that we want to evaluate in the topic context
       # @return [Karafka::Routing::Topic] newly built topic instance
-      def topic=(name, &block)
+      def topic=(name, &)
         topic = Topic.new(name, self)
         @topics << Proxy.new(
           topic,
           builder.defaults,
-          &block
+          &
         ).target
         built_topic = @topics.last
         # We overwrite it conditionally in case it was not set by the user inline in the topic
@@ -59,13 +58,12 @@ module Karafka
       # Assigns the current subscription group id based on the defined one and allows for further
       # topic definition
       # @param name [String, Symbol] name of the current subscription group
-      # @param block [Proc] block that may include topics definitions
-      def subscription_group=(name = SubscriptionGroup.id, &block)
+      def subscription_group=(name = SubscriptionGroup.id, &)
         # We cast it here, so the routing supports symbol based but that's anyhow later on
         # validated as a string
         @current_subscription_group_details = { name: name.to_s }
 
-        Proxy.new(self, &block)
+        Proxy.new(self, &)
 
         # We need to reset the current subscription group after it is used, so it won't leak
         # outside to other topics that would be defined without a defined subscription group

data/lib/karafka/routing/contracts/consumer_group.rb

@@ -7,10 +7,8 @@ module Karafka
       # Contract for single full route (consumer group + topics) validation.
       class ConsumerGroup < Karafka::Contracts::Base
         configure do |config|
-          config.error_messages = YAML.safe_load(
-            File.read(
-              File.join(Karafka.gem_root, 'config', 'locales', 'errors.yml')
-            )
+          config.error_messages = YAML.safe_load_file(
+            File.join(Karafka.gem_root, 'config', 'locales', 'errors.yml')
           ).fetch('en').fetch('validations').fetch('routing').fetch('consumer_group')
         end
 
@@ -39,21 +37,22 @@ module Karafka
             topics_consumers[topic[:name]] << topic[:consumer]
           end
 
-          next if topics_consumers.values.map(&:size).all? { |count| count == 1 }
+          next if topics_consumers.values.map(&:size).all?(1)
 
           [[%i[topics], :many_consumers_same_topic]]
         end
 
         virtual do |data, errors|
           next unless errors.empty?
-          next unless ::Karafka::App.config.strict_topics_namespacing
+          next unless Karafka::App.config.strict_topics_namespacing
 
           names = data.fetch(:topics).map { |topic| topic[:name] }
           names_hash = names.each_with_object({}) { |n, h| h[n] = true }
           error_occured = false
+          namespace_chars = ['.', '_'].freeze
           names.each do |n|
             # Skip topic names that are not namespaced
-            next unless n.chars.find { |c| ['.', '_'].include?(c) }
+            next unless n.chars.find { |c| namespace_chars.include?(c) }
 
             if n.chars.include?('.')
               # Check underscore styled topic

data/lib/karafka/routing/contracts/routing.rb

@@ -6,10 +6,8 @@ module Karafka
       # Ensures that routing wide rules are obeyed
       class Routing < Karafka::Contracts::Base
         configure do |config|
-          config.error_messages = YAML.safe_load(
-            File.read(
-              File.join(Karafka.gem_root, 'config', 'locales', 'errors.yml')
-            )
+          config.error_messages = YAML.safe_load_file(
+            File.join(Karafka.gem_root, 'config', 'locales', 'errors.yml')
           ).fetch('en').fetch('validations').fetch('routing')
         end