Make strategies inheritance optional.

lib/sidekiq/throttled.rb

@@ -6,6 +6,7 @@
 # internal
 require "sidekiq/throttled/version"
 require "sidekiq/throttled/communicator"
+require "sidekiq/throttled/configuration"
 require "sidekiq/throttled/queues_pauser"
 require "sidekiq/throttled/registry"
 require "sidekiq/throttled/worker"
@@ -47,6 +48,11 @@ module Throttled
     class << self
       include Utils
 
+      # @return [Configuration]
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
       # Hooks throttler into sidekiq.
       #
       # @return [void]

lib/sidekiq/throttled/configuration.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module Throttled
+    # Configuration holder.
+    class Configuration
+      # Class constructor.
+      def initialize
+        reset!
+      end
+
+      # Reset configuration to defaults.
+      #
+      # @return [void]
+      def reset!
+        @inherit_strategies = false
+      end
+
+      # Instructs throttler to lookup strategies in parent classes, if there's
+      # no own strategy:
+      #
+      #     class Foo
+      #       include Sidekiq::Worker
+      #       include Sidekiq::Worker::Throttled
+      #
+      #       sidekiq_throttle :concurrency => { :limit => 42 }
+      #     end
+      #
+      #     class Bar < Foo
+      #     end
+      #
+      # By default in the example above, `Bar` won't have throttling options.
+      # Set this flag to `true` to enable this lookup in initializer, after
+      # that `Bar` will use `Foo` throttling bucket.
+      def inherit_strategies=(value)
+        @inherit_strategies = value ? true : false
+      end
+
+      # Whenever throttled workers should inherit parent's strategies or not.
+      # Default: `false`.
+      #
+      # @return [Boolean]
+      def inherit_strategies?
+        @inherit_strategies
+      end
+    end
+  end
+end

lib/sidekiq/throttled/registry.rb

@@ -108,6 +108,8 @@ def find(name)
         # @param name [Class, #to_s]
         # @return [Strategy, nil]
         def find_by_class(name)
+          return unless Throttled.configuration.inherit_strategies?
+
           const = name.is_a?(Class) ? name : constantize(name)
           return unless const.is_a?(Class)
 

spec/sidekiq/throttled/registry_spec.rb

@@ -88,7 +88,15 @@ def capture_output
 
       before { described_class.add(parent_class.name, threshold) }
 
-      it { is_expected.to be_a Sidekiq::Throttled::Strategy }
+      it { is_expected.to be_nil }
+
+      context "when configuration has inherit strategy turned on" do
+        before { Sidekiq::Throttled.configuration.inherit_strategies = true }
+
+        after { Sidekiq::Throttled.configuration.reset! }
+
+        it { is_expected.to be described_class.get("Parent") }
+      end
     end
   end