karafka 2.0.21 → 2.0.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9de6cb2d19b24258eb60548b383e664dc035f1f48ffc7077ca5f238b3a85aa3e
-  data.tar.gz: 706d4e81a74b1aad9d1f9b13a67d168a7ef3c45088b89ec710d29abb3a767f11
+  metadata.gz: 84d8130c528081b283889f9f1ebe89b8829b800a2c5d1f4ca99f6d6ce9b4c9df
+  data.tar.gz: 3cc30f65586226bcb6d8ed4fdac912a72c1a4a7eb5691862b378629d9de1347f
 SHA512:
-  metadata.gz: a22be6ff489f9f7cce39e0e4d6d374a70680124842afeeb962e33eaa8c6cd3db8cbcd6f3251543653c98777d025b6d9b0385f4580d92fd4b807e835a68296a43
-  data.tar.gz: 466d9723427771594701071e5a27a3a1a53b6b4efce9ffa6b241f5261c9a887136b2a8a4a90b35e216b2af01539336bde5377f4edc1ab99837087dd751b830a8
+  metadata.gz: 8e1f3fc0a3c73035fdb38093eb0594c999d0a715752f41ed95079b1d8f2e89a5a0fa0abdf054272891e89ffa4dd8d010dd2225540d4480067d8bc0359bf2b7b8
+  data.tar.gz: 7c1f3f958ef52682e46efb11e8a3ddcbe641ba85c62956fefb84ec6eacadbe9d28ee509bdfd61fcd73ea8f52b1ab867de4909990503024cc5c603788931264ca

data/.github/workflows/ci.yml

@@ -101,6 +101,9 @@ jobs:
       - name: Install package dependencies
         run: "[ -e $APT_DEPS ] || sudo apt-get install -y --no-install-recommends $APT_DEPS"
 
+      - name: Remove libzstd-dev to check no supported compressions
+        run: sudo apt-get -y remove libzstd-dev
+
       - name: Start Kafka with docker-compose
         run: |
           docker-compose up -d
@@ -124,5 +127,8 @@ jobs:
       - name: Run integration tests
         env:
           KARAFKA_PRO_LICENSE_TOKEN: ${{ secrets.KARAFKA_PRO_LICENSE_TOKEN }}
+          KARAFKA_PRO_USERNAME: ${{ secrets.KARAFKA_PRO_USERNAME }}
+          KARAFKA_PRO_PASSWORD: ${{ secrets.KARAFKA_PRO_PASSWORD }}
+          KARAFKA_PRO_VERSION: ${{ secrets.KARAFKA_PRO_VERSION }}
           GITHUB_COVERAGE: ${{matrix.coverage}}
         run: bin/integrations

data/.ruby-version

@@ -1 +1 @@
-3.1.2
+3.1.3

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Karafka framework changelog
 
+## 2.0.23 (2022-12-07)
+- [Maintenance] Align with `waterdrop` and `karafka-core`
+- [Improvement] Provide `Admin#read_topic` API to get topic data without subscribing.
+- [Improvement] Upon an end user `#pause`, do not commit the offset in automatic offset management mode. This will prevent from a scenario where pause is needed but during it a rebalance occurs and a different assigned process starts not from the pause location but from the automatic offset that may be different. This still allows for using the `#mark_as_consumed`.
+- [Fix] Fix a scenario where manual `#pause` would be overwritten by a resume initiated by the strategy.
+- [Fix] Fix a scenario where manual `#pause` in LRJ would cause infinite pause.
+
+## 2.0.22 (2022-12-02)
+- [Improvement] Load Pro components upon Karafka require so they can be altered prior to setup.
+- [Improvement] Do not run LRJ jobs that were added to the jobs queue but were revoked meanwhile.
+- [Improvement] Allow running particular named subscription groups similar to consumer groups.
+- [Improvement] Allow running particular topics similar to consumer groups.
+- [Improvement] Raise configuration error when trying to run Karafka with options leading to no subscriptions.
+- [Fix] Fix `karafka info` subscription groups count reporting as it was misleading.
+- [Fix] Allow for defining subscription groups with symbols similar to consumer groups and topics to align the API.
+- [Fix] Do not allow for an explicit `nil` as a `subscription_group` block argument.
+- [Fix] Fix instability in subscription groups static members ids when using `--consumer_groups` CLI flag.
+- [Fix] Fix a case in routing, where anonymous subscription group could not be used inside of a consumer group.
+- [Fix] Fix a case where shutdown prior to listeners build would crash the server initialization.
+- [Fix] Duplicated logs in development environment for Rails when logger set to `$stdout`.
+
 ## 20.0.21 (2022-11-25)
 - [Improvement] Make revocation jobs for LRJ topics non-blocking to prevent blocking polling when someone uses non-revocation aware LRJ jobs and revocation happens.
 

data/Gemfile.lock

@@ -1,11 +1,10 @@
 PATH
   remote: .
   specs:
-    karafka (2.0.21)
-      karafka-core (>= 2.0.4, < 3.0.0)
-      rdkafka (>= 0.12)
+    karafka (2.0.23)
+      karafka-core (>= 2.0.6, < 3.0.0)
       thor (>= 0.20)
-      waterdrop (>= 2.4.1, < 3.0.0)
+      waterdrop (>= 2.4.3, < 3.0.0)
       zeitwerk (~> 2.3)
 
 GEM
@@ -30,8 +29,9 @@ GEM
       activesupport (>= 5.0)
     i18n (1.12.0)
       concurrent-ruby (~> 1.0)
-    karafka-core (2.0.4)
+    karafka-core (2.0.6)
       concurrent-ruby (>= 1.1)
+      rdkafka (>= 0.12)
     mini_portile2 (2.8.0)
     minitest (5.16.3)
     rake (13.0.6)
@@ -61,9 +61,8 @@ GEM
     thor (1.2.1)
     tzinfo (2.0.5)
       concurrent-ruby (~> 1.0)
-    waterdrop (2.4.2)
-      karafka-core (>= 2.0.2, < 3.0.0)
-      rdkafka (>= 0.10)
+    waterdrop (2.4.3)
+      karafka-core (>= 2.0.6, < 3.0.0)
       zeitwerk (~> 2.3)
     zeitwerk (2.6.6)
 

data/README.md

@@ -13,7 +13,7 @@ Karafka is a Ruby and Rails multi-threaded efficient Kafka processing framework
 - Supports parallel processing in [multiple threads](https://karafka.io/docs/Concurrency-and-multithreading) (also for a [single topic partition](https://karafka.io/docs/Pro-Virtual-Partitions) work)
 - [Automatically integrates](https://karafka.io/docs/Integrating-with-Ruby-on-Rails-and-other-frameworks#integrating-with-ruby-on-rails) with Ruby on Rails
 - Has [ActiveJob backend](https://karafka.io/docs/Active-Job) support (including [ordered jobs](https://karafka.io/docs/Pro-Enhanced-Active-Job#ordered-jobs))
-- Has a seamless [Dead Letter Queue](karafka.io/docs/Dead-Letter-Queue/) functionality built-in
+- Has a seamless [Dead Letter Queue](https://karafka.io/docs/Dead-Letter-Queue/) functionality built-in
 - Supports in-development [code reloading](https://karafka.io/docs/Auto-reload-of-code-changes-in-development)
 - Is powered by [librdkafka](https://github.com/edenhill/librdkafka) (the Apache Kafka C/C++ client library)
 - Has an out-of the box [StatsD/DataDog monitoring](https://karafka.io/docs/Monitoring-and-logging) with a dashboard template.

data/bin/integrations

@@ -74,8 +74,8 @@ class Scenario
   def type
     scenario_dir = File.dirname(@path)
 
-    return :poro if scenario_dir.end_with?('_poro')
-    return :pristine if scenario_dir.end_with?('_pristine')
+    return :poro if scenario_dir.include?('_poro')
+    return :pristine if scenario_dir.include?('_pristine')
 
     :regular
   end

data/bin/rspecs

@@ -1,4 +1,6 @@
 #!/usr/bin/env bash
 
+set -e
+
 SPECS_TYPE=regular bundle exec rspec --tag ~type:pro
 SPECS_TYPE=pro bundle exec rspec --tag type:pro

data/config/errors.yml

@@ -25,7 +25,10 @@ en:
 
     server_cli_options:
       missing: needs to be present
-      consumer_groups_inclusion: Unknown consumer group
+      consumer_groups_inclusion: Unknown consumer group name
+      subscription_groups_inclusion: Unknown subscription group name
+      topics_inclusion: Unknown topic name
+      topics_missing: No topics to subscribe to
 
     topic:
       missing: needs to be present
@@ -34,7 +37,7 @@ en:
       consumer_format: needs to be present
       id_format: 'needs to be a string with a Kafka accepted format'
       initial_offset_format: needs to be either earliest or latest
-      subscription_group_format: must be nil or a non-empty string
+      subscription_group_format: must be a non-empty string
       manual_offset_management.active_format: needs to be either true or false
       consumer_active_job_missing: ActiveJob needs to be available
       manual_offset_management_must_be_enabled: cannot be disabled for ActiveJob topics

data/karafka.gemspec

@@ -21,10 +21,9 @@ Gem::Specification.new do |spec|
     without having to focus on things that are not your business domain.
   DESC
 
-  spec.add_dependency 'karafka-core', '>= 2.0.4', '< 3.0.0'
-  spec.add_dependency 'rdkafka', '>= 0.12'
+  spec.add_dependency 'karafka-core', '>= 2.0.6', '< 3.0.0'
   spec.add_dependency 'thor', '>= 0.20'
-  spec.add_dependency 'waterdrop', '>= 2.4.1', '< 3.0.0'
+  spec.add_dependency 'waterdrop', '>= 2.4.3', '< 3.0.0'
   spec.add_dependency 'zeitwerk', '~> 2.3'
 
   spec.required_ruby_version = '>= 2.7.0'

data/lib/karafka/admin.rb

@@ -9,7 +9,70 @@ module Karafka
   # @note It always uses the primary defined cluster and does not support multi-cluster work.
   #   If you need this, just replace the cluster info for the time you use this
   module Admin
+    # A fake admin topic representation that we use for messages fetched using this API
+    # We cannot use the topics directly because we may want to request data from topics that we
+    # do not have in the routing
+    Topic = Struct.new(:name, :deserializer)
+
+    # Defaults for config
+    CONFIG_DEFAULTS = {
+      'group.id': 'karafka_admin',
+      # We want to know when there is no more data not to end up with an endless loop
+      'enable.partition.eof': true,
+      'statistics.interval.ms': 0
+    }.freeze
+
+    private_constant :Topic, :CONFIG_DEFAULTS
+
     class << self
+      # Allows us to read messages from the topic
+      #
+      # @param name [String, Symbol] topic name
+      # @param partition [Integer] partition
+      # @param count [Integer] how many messages we want to get at most
+      # @param offset [Integer] offset from which we should start. If -1 is provided (default) we
+      #   will start from the latest offset
+      #
+      # @return [Array<Karafka::Messages::Message>] array with messages
+      def read_topic(name, partition, count, offset = -1)
+        messages = []
+        tpl = Rdkafka::Consumer::TopicPartitionList.new
+
+        with_consumer do |consumer|
+          if offset.negative?
+            offsets = consumer.query_watermark_offsets(name, partition)
+            offset = offsets.last - count
+          end
+
+          offset = offset.negative? ? 0 : offset
+
+          tpl.add_topic_and_partitions_with_offsets(name, partition => offset)
+          consumer.assign(tpl)
+
+          # We should poll as long as we don't have all the messages that we need or as long as
+          # we do not read all the messages from the topic
+          loop do
+            break if messages.size >= count
+
+            message = consumer.poll(200)
+            messages << message if message
+          rescue Rdkafka::RdkafkaError => e
+            # End of partition
+            break if e.code == :partition_eof
+
+            raise e
+          end
+        end
+
+        messages.map do |message|
+          Messages::Builders::Message.call(
+            message,
+            Topic.new(name, Karafka::App.config.deserializer),
+            Time.now
+          )
+        end
+      end
+
       # Creates Kafka topic with given settings
       #
       # @param name [String] topic name
@@ -52,15 +115,32 @@ module Karafka
 
       # Creates admin instance and yields it. After usage it closes the admin instance
       def with_admin
-        # Admin needs a producer config
-        config = Karafka::Setup::AttributesMap.producer(Karafka::App.config.kafka.dup)
-
-        admin = ::Rdkafka::Config.new(config).admin
+        admin = config(:producer).admin
         result = yield(admin)
         result
       ensure
         admin&.close
       end
+
+      # Creates consumer instance and yields it. After usage it closes the consumer instance
+      def with_consumer
+        consumer = config(:consumer).consumer
+        result = yield(consumer)
+        result
+      ensure
+        consumer&.close
+      end
+
+      # @param type [Symbol] type of config we want
+      # @return [::Rdkafka::Config] rdkafka config
+      def config(type)
+        config_hash = Karafka::Setup::AttributesMap.public_send(
+          type,
+          Karafka::App.config.kafka.dup.merge(CONFIG_DEFAULTS)
+        )
+
+        ::Rdkafka::Config.new(config_hash)
+      end
     end
   end
 end

data/lib/karafka/app.rb

@@ -16,9 +16,19 @@ module Karafka
 
       # @return [Hash] active subscription groups grouped based on consumer group in a hash
       def subscription_groups
+        # We first build all the subscription groups, so they all get the same position, despite
+        # later narrowing that. It allows us to maintain same position number for static members
+        # even when we want to run subset of consumer groups or subscription groups
+        #
+        # We then narrow this to active consumer groups from which we select active subscription
+        # groups.
         consumer_groups
-          .active
-          .map { |consumer_group| [consumer_group, consumer_group.subscription_groups] }
+          .map { |cg| [cg, cg.subscription_groups] }
+          .select { |cg, _| cg.active? }
+          .select { |_, sgs| sgs.delete_if { |sg| !sg.active? } }
+          .delete_if { |_, sgs| sgs.empty? }
+          .each { |_, sgs| sgs.each { |sg| sg.topics.delete_if { |top| !top.active? } } }
+          .each { |_, sgs| sgs.delete_if { |sg| sg.topics.empty? } }
           .to_h
       end
 

data/lib/karafka/base_consumer.rb

@@ -62,14 +62,8 @@ module Karafka
     #   that may not yet kick in when error occurs. That way we pause always on the last processed
     #   message.
     def on_consume
-      Karafka.monitor.instrument('consumer.consumed', caller: self) do
-        consume
-      end
-
-      coordinator.consumption(self).success!
+      handle_consume
     rescue StandardError => e
-      coordinator.consumption(self).failure!(e)
-
       Karafka.monitor.instrument(
         'error.occurred',
         error: e,
@@ -77,9 +71,6 @@ module Karafka
         seek_offset: coordinator.seek_offset,
         type: 'consumer.consume.error'
       )
-    ensure
-      # We need to decrease number of jobs that this coordinator coordinates as it has finished
-      coordinator.decrement
     end
 
     # @private
@@ -199,7 +190,10 @@ module Karafka
     # @param offset [Integer] offset from which we want to restart the processing
     # @param timeout [Integer, nil] how long in milliseconds do we want to pause or nil to use the
     #   default exponential pausing strategy defined for retries
-    def pause(offset, timeout = nil)
+    # @param manual_pause [Boolean] Flag to differentiate between user pause and system/strategy
+    #   based pause. While they both pause in exactly the same way, the strategy application
+    #   may need to differentiate between them.
+    def pause(offset, timeout = nil, manual_pause = true)
       timeout ? coordinator.pause_tracker.pause(timeout) : coordinator.pause_tracker.pause
 
       client.pause(
@@ -207,6 +201,9 @@ module Karafka
         messages.metadata.partition,
         offset
       )
+
+      # Indicate, that user took a manual action of pausing
+      coordinator.manual_pause if manual_pause
     end
 
     # Resumes processing of the current topic partition

data/lib/karafka/cli/info.rb

@@ -37,7 +37,8 @@ module Karafka
           "Karafka version: #{Karafka::VERSION}#{postfix}",
           "Ruby version: #{RUBY_DESCRIPTION}",
           "Rdkafka version: #{::Rdkafka::VERSION}",
-          "Subscription groups count: #{Karafka::App.subscription_groups.size}",
+          "Consumer groups count: #{Karafka::App.consumer_groups.size}",
+          "Subscription groups count: #{Karafka::App.subscription_groups.values.flatten.size}",
           "Workers count: #{Karafka::App.config.concurrency}",
           "Application client id: #{config.client_id}",
           "Boot file: #{Karafka.boot_file}",

data/lib/karafka/cli/server.rb

@@ -9,18 +9,19 @@ module Karafka
 
       desc 'Start the Karafka server (short-cut alias: "s")'
       option aliases: 's'
-      option :consumer_groups, type: :array, default: nil, aliases: :g
+      option :consumer_groups, type: :array, default: [], aliases: :g
+      option :subscription_groups, type: :array, default: []
+      option :topics, type: :array, default: []
 
       # Start the Karafka server
       def call
         # Print our banner and info in the dev mode
         print_marketing_info if Karafka::App.env.development?
 
-        Contracts::ServerCliOptions.new.validate!(cli.options)
-
-        # We assign active topics on a server level, as only server is expected to listen on
-        # part of the topics
-        Karafka::Server.consumer_groups = cli.options[:consumer_groups]
+        active_routing_config = Karafka::App.config.internal.routing.active
+        active_routing_config.consumer_groups = cli.options[:consumer_groups]
+        active_routing_config.subscription_groups = cli.options[:subscription_groups]
+        active_routing_config.topics = cli.options[:topics]
 
         Karafka::Server.run
       end

data/lib/karafka/connection/client.rb

@@ -308,8 +308,8 @@ module Karafka
             @closed = true
 
             # Remove callbacks runners that were registered
-            ::Karafka::Instrumentation.statistics_callbacks.delete(@subscription_group.id)
-            ::Karafka::Instrumentation.error_callbacks.delete(@subscription_group.id)
+            ::Karafka::Core::Instrumentation.statistics_callbacks.delete(@subscription_group.id)
+            ::Karafka::Core::Instrumentation.error_callbacks.delete(@subscription_group.id)
 
             @kafka.close
             @buffer.clear
@@ -397,7 +397,7 @@ module Karafka
         @name = consumer.name
 
         # Register statistics runner for this particular type of callbacks
-        ::Karafka::Instrumentation.statistics_callbacks.add(
+        ::Karafka::Core::Instrumentation.statistics_callbacks.add(
           @subscription_group.id,
           Instrumentation::Callbacks::Statistics.new(
             @subscription_group.id,
@@ -408,7 +408,7 @@ module Karafka
         )
 
         # Register error tracking callback
-        ::Karafka::Instrumentation.error_callbacks.add(
+        ::Karafka::Core::Instrumentation.error_callbacks.add(
           @subscription_group.id,
           Instrumentation::Callbacks::Error.new(
             @subscription_group.id,

data/lib/karafka/contracts/server_cli_options.rb

@@ -12,7 +12,9 @@ module Karafka
         ).fetch('en').fetch('validations').fetch('server_cli_options')
       end
 
-      optional(:consumer_groups) { |cg| cg.is_a?(Array) && !cg.empty? }
+      optional(:consumer_groups) { |cg| cg.is_a?(Array) }
+      optional(:subscription_groups) { |sg| sg.is_a?(Array) }
+      optional(:topics) { |topics| topics.is_a?(Array) }
 
       virtual do |data, errors|
         next unless errors.empty?
@@ -22,11 +24,66 @@ module Karafka
 
         # If there were no consumer_groups declared in the server cli, it means that we will
         # run all of them and no need to validate them here at all
-        next if value.nil?
-        next if (value - Karafka::App.config.internal.routing.builder.map(&:name)).empty?
+        next if value.empty?
+        next if (value - Karafka::App.consumer_groups.map(&:name)).empty?
 
+        # Found unknown consumer groups
         [[%i[consumer_groups], :consumer_groups_inclusion]]
       end
+
+      virtual do |data, errors|
+        next unless errors.empty?
+        next unless data.key?(:subscription_groups)
+
+        value = data.fetch(:subscription_groups)
+
+        # If there were no subscription_groups declared in the server cli, it means that we will
+        # run all of them and no need to validate them here at all
+        next if value.empty?
+
+        subscription_groups = Karafka::App
+                              .consumer_groups
+                              .map(&:subscription_groups)
+                              .flatten
+                              .map(&:name)
+
+        next if (value - subscription_groups).empty?
+
+        # Found unknown subscription groups
+        [[%i[subscription_groups], :subscription_groups_inclusion]]
+      end
+
+      virtual do |data, errors|
+        next unless errors.empty?
+        next unless data.key?(:topics)
+
+        value = data.fetch(:topics)
+
+        # If there were no topics declared in the server cli, it means that we will
+        # run all of them and no need to validate them here at all
+        next if value.empty?
+
+        topics = Karafka::App
+                 .consumer_groups
+                 .map(&:subscription_groups)
+                 .flatten
+                 .map(&:topics)
+                 .map { |gtopics| gtopics.map(&:name) }
+                 .flatten
+
+        next if (value - topics).empty?
+
+        # Found unknown topics
+        [[%i[topics], :topics_inclusion]]
+      end
+
+      # Makes sure we have anything to subscribe to when we start the server
+      virtual do |_, errors|
+        next unless errors.empty?
+        next unless Karafka::App.subscription_groups.empty?
+
+        [[%i[topics], :topics_missing]]
+      end
     end
   end
 end

data/lib/karafka/contracts/topic.rb

@@ -20,7 +20,7 @@ module Karafka
       required(:initial_offset) { |val| %w[earliest latest].include?(val) }
       required(:max_wait_time) { |val| val.is_a?(Integer) && val >= 10 }
       required(:name) { |val| val.is_a?(String) && Contracts::TOPIC_REGEXP.match?(val) }
-      required(:subscription_group) { |val| val.nil? || (val.is_a?(String) && !val.empty?) }
+      required(:subscription_group) { |val| val.is_a?(String) && !val.empty? }
 
       virtual do |data, errors|
         next unless errors.empty?

data/lib/karafka/licenser.rb

@@ -8,68 +8,71 @@ module Karafka
 
     private_constant :PUBLIC_KEY_LOCATION
 
-    # Tries to prepare license and verifies it
-    #
-    # @param license_config [Karafka::Core::Configurable::Node] config related to the licensing
-    def prepare_and_verify(license_config)
-      prepare(license_config)
-      verify(license_config)
-    end
-
-    private
+    class << self
+      # Tries to load the license and yields if successful
+      def detect
+        # If required, do not require again
+        require('karafka-license') unless const_defined?('::Karafka::License')
 
-    # @param license_config [Karafka::Core::Configurable::Node] config related to the licensing
-    def prepare(license_config)
-      # If there is token, no action needed
-      # We support a case where someone would put the token in instead of using one from the
-      # license. That's in case there are limitations to using external package sources, etc
-      return if license_config.token
+        yield
 
-      begin
-        license_config.token || require('karafka-license')
+        true
       rescue LoadError
-        return
+        false
       end
 
-      license_config.token = Karafka::License.token
-    end
-
-    # Check license and setup license details (if needed)
-    # @param license_config [Karafka::Core::Configurable::Node] config related to the licensing
-    def verify(license_config)
-      # If no license, it will just run LGPL components without anything extra
-      return unless license_config.token
+      # Tries to prepare license and verifies it
+      #
+      # @param license_config [Karafka::Core::Configurable::Node] config related to the licensing
+      def prepare_and_verify(license_config)
+        # If license is not loaded, nothing to do
+        return unless const_defined?('::Karafka::License')
 
-      public_key = OpenSSL::PKey::RSA.new(File.read(PUBLIC_KEY_LOCATION))
+        prepare(license_config)
+        verify(license_config)
+      end
 
-      # We gsub and strip in case someone copy-pasted it as a multi line string
-      formatted_token = license_config.token.strip.delete("\n").delete(' ')
-      decoded_token = Base64.decode64(formatted_token)
+      private
 
-      begin
-        data = public_key.public_decrypt(decoded_token)
-      rescue OpenSSL::OpenSSLError
-        data = nil
+      # @param license_config [Karafka::Core::Configurable::Node] config related to the licensing
+      def prepare(license_config)
+        license_config.token = Karafka::License.token
       end
 
-      details = data ? JSON.parse(data) : raise_invalid_license_token(license_config)
+      # Check license and setup license details (if needed)
+      # @param license_config [Karafka::Core::Configurable::Node] config related to the licensing
+      def verify(license_config)
+        public_key = OpenSSL::PKey::RSA.new(File.read(PUBLIC_KEY_LOCATION))
 
-      license_config.entity = details.fetch('entity')
-    end
+        # We gsub and strip in case someone copy-pasted it as a multi line string
+        formatted_token = license_config.token.strip.delete("\n").delete(' ')
+        decoded_token = Base64.decode64(formatted_token)
 
-    # Raises an error with info, that used token is invalid
-    # @param license_config [Karafka::Core::Configurable::Node]
-    def raise_invalid_license_token(license_config)
-      # We set it to false so `Karafka.pro?` method behaves as expected
-      license_config.token = false
-
-      raise(
-        Errors::InvalidLicenseTokenError,
-        <<~MSG.tr("\n", ' ')
-          License key you provided is invalid.
-          Please reach us at contact@karafka.io or visit https://karafka.io to obtain a valid one.
-        MSG
-      )
+        begin
+          data = public_key.public_decrypt(decoded_token)
+        rescue OpenSSL::OpenSSLError
+          data = nil
+        end
+
+        details = data ? JSON.parse(data) : raise_invalid_license_token(license_config)
+
+        license_config.entity = details.fetch('entity')
+      end
+
+      # Raises an error with info, that used token is invalid
+      # @param license_config [Karafka::Core::Configurable::Node]
+      def raise_invalid_license_token(license_config)
+        # We set it to false so `Karafka.pro?` method behaves as expected
+        license_config.token = false
+
+        raise(
+          Errors::InvalidLicenseTokenError,
+          <<~MSG.tr("\n", ' ')
+            License key you provided is invalid.
+            Please reach us at contact@karafka.io or visit https://karafka.io to obtain a valid one.
+          MSG
+        )
+      end
     end
   end
 end

data/lib/karafka/pro/loader.rb

@@ -45,8 +45,6 @@ module Karafka
         # @param config [Karafka::Core::Configurable::Node] app config that we can alter with pro
         #   components
         def setup(config)
-          require_all
-
           reconfigure(config)
 
           load_topic_features
@@ -55,7 +53,7 @@ module Karafka
         private
 
         # Sets proper config options to use pro components
-        # @param config [WaterDrop::Configurable::Node] root config node
+        # @param config [::Karafka::Core::Configurable::Node] root config node
         def reconfigure(config)
           icfg = config.internal