karafka 1.4.12 → 2.2.10

data/bin/scenario

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+# Runner for non-parallel execution of a single scenario.
+# It prints all the info stdout, etc and basically replaces itself with the scenario execution.
+# It is useful when we work with a single spec and we need all the debug info
+
+raise 'This code needs to be executed WITHOUT bundle exec' if Kernel.const_defined?(:Bundler)
+
+require 'open3'
+require 'fileutils'
+require 'pathname'
+require 'tmpdir'
+require 'etc'
+
+ROOT_PATH = Pathname.new(File.expand_path(File.join(File.dirname(__FILE__), '../')))
+
+# Load all the specs
+specs = Dir[ROOT_PATH.join('spec/integrations/**/*.rb')]
+
+# If filters is provided, apply
+# Allows to provide several filters one after another and applies all of them
+ARGV.each do |filter|
+  specs.delete_if { |name| !name.include?(filter) }
+end
+
+raise ArgumentError, "No integration specs with filters: #{ARGV.join(', ')}" if specs.empty?
+raise ArgumentError, "Many specs found with filters: #{ARGV.join(', ')}" if specs.size != 1
+
+exec("bundle exec ruby -r #{ROOT_PATH}/spec/integrations_helper.rb #{specs[0]}")

data/bin/stress_many

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+# Runs integration specs in an endless loop
+# This allows us to ensure (after long enough time) that the integrations test suit is stable and
+# that there are no anomalies when running it for a long period of time
+
+set -e
+
+while :
+do
+  clear
+  bin/integrations $1
+done

data/bin/stress_one

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+# Runs a single integration spec in an endless loop
+# This allows us to ensure (after long enough time) that the integration spec is stable and
+# that there are no anomalies when running it for a long period of time
+
+set -e
+
+while :
+do
+  clear
+  bin/scenario $1
+done

data/bin/verify_license_integrity

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+
+# This script verifies integrity of the Pro license
+# Run it before bundle install to ensure, that what you are fetching is what you expect
+# Run it after bundle install to ensure that the local artefact was not compromised
+
+#!/usr/bin/env bash
+
+set -e
+
+if [ "$MODE" != "after" ]; then
+  # Check the remote license prior to bundle installing
+  curl \
+    --retry 5 \
+    --retry-delay 1 \
+    --fail \
+    -u $KARAFKA_PRO_USERNAME:$KARAFKA_PRO_PASSWORD \
+    https://gems.karafka.io/gems/karafka-license-$KARAFKA_PRO_VERSION.gem \
+    -o ./karafka-license.gem
+else
+  # Check the local cached one after bundle install
+  cache_path=`ruby -e 'puts "#{Gem.dir}/cache/"'`
+  cp "$cache_path/karafka-license-$KARAFKA_PRO_VERSION.gem" ./karafka-license.gem
+fi
+
+detected=`sha256sum ./karafka-license.gem | awk '{ print $1 }'`
+
+rm ./karafka-license.gem
+
+echo -n "Karafka Pro license artifact checksum verification result: "
+
+if [ "$detected" = "$KARAFKA_PRO_LICENSE_CHECKSUM" ]; then
+  echo "Success"
+else
+  echo -e "\033[0;31mFailure!\033[0m"
+  exit 1
+fi

data/bin/wait_for_kafka

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+# Waits for Kafka to be ready
+# Useful in CI where Kafka needs to be fully started before we run any tests
+
+require 'karafka'
+
+Karafka::App.setup do |config|
+  config.kafka[:'bootstrap.servers'] = '127.0.0.1:9092'
+end
+
+60.times do
+  begin
+    # Stop if we can connect to the cluster and get info
+    exit if Karafka::Admin.cluster_info
+  rescue Rdkafka::RdkafkaError
+    puts "Kafka not available, retrying..."
+    sleep(1)
+  end
+end
+
+puts 'Kafka not available!'
+
+exit 1

data/certs/cert_chain.pem

@@ -0,0 +1,26 @@
+-----BEGIN CERTIFICATE-----
+MIIEcDCCAtigAwIBAgIBATANBgkqhkiG9w0BAQsFADA/MRAwDgYDVQQDDAdjb250
+YWN0MRcwFQYKCZImiZPyLGQBGRYHa2FyYWZrYTESMBAGCgmSJomT8ixkARkWAmlv
+MB4XDTIzMDgyMTA3MjU1NFoXDTI0MDgyMDA3MjU1NFowPzEQMA4GA1UEAwwHY29u
+dGFjdDEXMBUGCgmSJomT8ixkARkWB2thcmFma2ExEjAQBgoJkiaJk/IsZAEZFgJp
+bzCCAaIwDQYJKoZIhvcNAQEBBQADggGPADCCAYoCggGBAOuZpyQKEwsTG9plLat7
+8bUaNuNBEnouTsNMr6X+XTgvyrAxTuocdsyP1sNCjdS1B8RiiDH1/Nt9qpvlBWon
+sdJ1SYhaWNVfqiYStTDnCx3PRMmHRdD4KqUWKpN6VpZ1O/Zu+9Mw0COmvXgZuuO9
+wMSJkXRo6dTCfMedLAIxjMeBIxtoLR2e6Jm6MR8+8WYYVWrO9kSOOt5eKQLBY7aK
+b/Dc40EcJKPg3Z30Pia1M9ZyRlb6SOj6SKpHRqc7vbVQxjEw6Jjal1lZ49m3YZMd
+ArMAs9lQZNdSw5/UX6HWWURLowg6k10RnhTUtYyzO9BFev0JFJftHnmuk8vtb+SD
+5VPmjFXg2VOcw0B7FtG75Vackk8QKfgVe3nSPhVpew2CSPlbJzH80wChbr19+e3+
+YGr1tOiaJrL6c+PNmb0F31NXMKpj/r+n15HwlTMRxQrzFcgjBlxf2XFGnPQXHhBm
+kp1OFnEq4GG9sON4glRldkwzi/f/fGcZmo5fm3d+0ZdNgwIDAQABo3cwdTAJBgNV
+HRMEAjAAMAsGA1UdDwQEAwIEsDAdBgNVHQ4EFgQUPVH5+dLA80A1kJ2Uz5iGwfOa
+1+swHQYDVR0RBBYwFIESY29udGFjdEBrYXJhZmthLmlvMB0GA1UdEgQWMBSBEmNv
+bnRhY3RAa2FyYWZrYS5pbzANBgkqhkiG9w0BAQsFAAOCAYEAnpa0jcN7JzREHMTQ
+bfZ+xcvlrzuROMY6A3zIZmQgbnoZZNuX4cMRrT1p1HuwXpxdpHPw7dDjYqWw3+1h
+3mXLeMuk7amjQpYoSWU/OIZMhIsARra22UN8qkkUlUj3AwTaChVKN/bPJOM2DzfU
+kz9vUgLeYYFfQbZqeI6SsM7ltilRV4W8D9yNUQQvOxCFxtLOetJ00fC/E7zMUzbK
+IBwYFQYsbI6XQzgAIPW6nGSYKgRhkfpmquXSNKZRIQ4V6bFrufa+DzD0bt2ZA3ah
+fMmJguyb5L2Gf1zpDXzFSPMG7YQFLzwYz1zZZvOU7/UCpQsHpID/YxqDp4+Dgb+Y
+qma0whX8UG/gXFV2pYWpYOfpatvahwi+A1TwPQsuZwkkhi1OyF1At3RY+hjSXyav
+AnG1dJU+yL2BK7vaVytLTstJME5mepSZ46qqIJXMuWob/YPDmVaBF39TDSG9e34s
+msG3BiCqgOgHAnL23+CN3Rt8MsuRfEtoTKpJVcCfoEoNHOkc
+-----END CERTIFICATE-----

data/certs/karafka-pro.pem

@@ -0,0 +1,11 @@
+-----BEGIN RSA PUBLIC KEY-----
+MIIBigKCAYEApcd6ybskiNs9WUvBGVUE8GdWDehjZ9TyjSj/fDl/UcMYqY0R5YX9
+tnYxEwZZRMdVltKWxr88Qmshh1IQz6CpJVbcfYjt/158pSGPm+AUua6tkLqIvZDM
+ocFOMafmroI+BMuL+Zu5QH7HC2tkT16jclGYfMQkJjXVUQTk2UZr+94+8RlUz/CH
+Y6hPA7xPgIyPfyPCxz1VWzAwXwT++NCJQPBr5MqT84LNSEzUSlR9pFNShf3UCUT+
+8LWOvjFSNGmMMSsbo2T7/+dz9/FM02YG00EO0x04qteggwcaEYLFrigDN6/fM0ih
+BXZILnMUqC/qrfW2YFg4ZqKZJuxaALqqkPxrkBDYqoqcAloqn36jBSke6tc/2I/J
+2Afq3r53UoAbUH7h5I/L8YeaiA4MYjAuq724lHlrOmIr4D6yjYC0a1LGlPjLk869
+2nsVXNgomhVb071E6amR+rJJnfvkdZgCmEBFnqnBV5A1u4qgNsa2rVcD+gJRvb2T
+aQtjlQWKPx5xAgMBAAE=
+-----END RSA PUBLIC KEY-----

data/config/locales/errors.yml

@@ -0,0 +1,97 @@
+en:
+  validations:
+    config:
+      missing: needs to be present
+      client_id_format: 'needs to be a string with a Kafka accepted format'
+      license.entity_format: needs to be a string
+      license.token_format: needs to be either false or a string
+      license.expires_on_format: needs to be a valid date
+      concurrency_format: needs to be an integer bigger than 0
+      consumer_mapper_format: needs to be present
+      consumer_persistence_format: needs to be either true or false
+      pause_timeout_format: needs to be an integer bigger than 0
+      pause_max_timeout_format: needs to be an integer bigger than 0
+      pause_with_exponential_backoff_format: needs to be either true or false
+      shutdown_timeout_format: needs to be an integer bigger than 0
+      max_wait_time_format: needs to be an integer bigger than 0
+      kafka_format: needs to be a filled hash
+      internal.processing.jobs_builder_format: cannot be nil
+      internal.processing.scheduler_format: cannot be nil
+      internal.processing.coordinator_class_format: cannot be nil
+      internal.processing.partitioner_class_format: cannot be nil
+      internal.processing.strategy_selector_format: cannot be nil
+      internal.processing.expansions_selector_format: cannot be nil
+      internal.active_job.dispatcher: cannot be nil
+      internal.active_job.job_options_contract: cannot be nil
+      internal.active_job.consumer_class: cannot be nil
+      internal.status_format: needs to be present
+      internal.process_format: needs to be present
+      internal.routing.builder_format: needs to be present
+      internal.routing.subscription_groups_builder_format: needs to be present
+      internal.connection.proxy.query_watermark_offsets.timeout_format: needs to be an integer bigger than 0
+      internal.connection.proxy.query_watermark_offsets.max_attempts_format: needs to be an integer bigger than 0
+      internal.connection.proxy.query_watermark_offsets.wait_time_format: needs to be an integer bigger than 0
+      internal.connection.proxy.offsets_for_times.timeout_format: needs to be an integer bigger than 0
+      internal.connection.proxy.offsets_for_times.max_attempts_format: needs to be an integer bigger than 0
+      internal.connection.proxy.offsets_for_times.wait_time_format: needs to be an integer bigger than 0
+      key_must_be_a_symbol: All keys under the kafka settings scope need to be symbols
+      max_timeout_vs_pause_max_timeout: pause_timeout must be less or equal to pause_max_timeout
+      shutdown_timeout_vs_max_wait_time: shutdown_timeout must be more than max_wait_time
+      admin.kafka_format: needs to be a hash
+      admin.group_id_format: 'needs to be a string with a Kafka accepted format'
+      admin.max_wait_time_format: 'needs to be an integer bigger than 0'
+      admin.max_attempts_format: 'needs to be an integer bigger than 0'
+
+    server_cli_options:
+      missing: needs to be present
+      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:
+      kafka: needs to be a hash with kafka scope settings details
+      missing: needs to be present
+      max_messages_format: 'needs to be an integer bigger than 0'
+      max_wait_time_format: 'needs to be an integer bigger than 0'
+      name_format: 'needs to be a string with a Kafka accepted format'
+      deserializer_format: needs to be present
+      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_name_format: must be a non-empty string
+      manual_offset_management.active_format: needs to be either true or false
+      manual_offset_management_must_be_enabled: cannot be disabled for ActiveJob topics
+      inline_insights.active_format: needs to be either true or false
+      consumer_active_job_missing: ActiveJob needs to be available
+      dead_letter_queue.max_retries_format: needs to be equal or bigger than 0
+      dead_letter_queue.topic_format: 'needs to be a string with a Kafka accepted format'
+      dead_letter_queue.active_format: needs to be either true or false
+      active_format: needs to be either true or false
+      declaratives.partitions_format: needs to be more or equal to 1
+      declaratives.active_format: needs to be true
+      declaratives.replication_factor_format: needs to be more or equal to 1
+      declaratives.details_format: needs to be a hash with only symbol keys
+      inconsistent_namespacing: |
+        needs to be consistent namespacing style
+        disable this validation by setting config.strict_topics_namespacing to false
+
+    consumer_group:
+      missing: needs to be present
+      topics_names_not_unique: all topic names within a single consumer group must be unique
+      id_format: 'needs to be a string with a Kafka accepted format'
+      topics_format: needs to be a non-empty array
+      topics_namespaced_names_not_unique: |
+        all topic names within a single consumer group must be unique considering namespacing styles
+        disable this validation by setting config.strict_topics_namespacing to false
+
+    job_options:
+      missing: needs to be present
+      dispatch_method_format: needs to be either :produce_async or :produce_sync
+      dispatch_many_method_format: needs to be either :produce_many_async or :produce_many_sync
+      partitioner_format: 'needs to respond to #call'
+      partition_key_type_format: 'needs to be either :key or :partition_key'
+
+    test:
+      missing: needs to be present
+      id_format: needs to be a String

data/config/locales/pro_errors.yml

@@ -0,0 +1,59 @@
+en:
+  validations:
+    topic:
+      virtual_partitions.partitioner_respond_to_call: needs to be defined and needs to respond to `#call`
+      virtual_partitions.max_partitions_format: needs to be equal or more than 1
+
+      long_running_job.active_format: needs to be either true or false
+
+      dead_letter_queue_with_virtual_partitions: when using Dead Letter Queue with Virtual Partitions, at least one retry is required.
+
+      throttling.active_format: needs to be either true or false
+      throttling.limit_format: needs to be equal or more than 1
+      throttling.interval_format: needs to be equal or more than 1
+
+      filtering.active_missing: needs to be present
+      filtering.factory_format: 'needs to respond to #call'
+      filtering.factories_format: 'needs to contain only factories responding to #call'
+      filtering.active_format: 'needs to be boolean'
+
+      expiring.ttl_format: 'needs to be equal or more than 0 and an integer'
+      expiring.active_format: 'needs to be boolean'
+
+      delaying.delay_format: 'needs to be equal or more than 0 and an integer'
+      delaying.active_format: 'needs to be boolean'
+
+      pause_timeout_format: needs to be an integer bigger than 0
+      pause_max_timeout_format: needs to be an integer bigger than 0
+      pause_with_exponential_backoff_format: needs to be either true or false
+      pause_timeout_max_timeout_vs_pause_max_timeout: pause_timeout must be less or equal to pause_max_timeout
+
+      patterns.active_format: 'needs to be boolean'
+      patterns.type_format: 'needs to be :matcher, :discovered or :regular'
+
+      inline_insights.active_format: 'needs to be boolean'
+      inline_insights.required_format: 'needs to be boolean'
+
+    consumer_group:
+      patterns_format: must be an array with hashes
+      patterns_missing: needs to be present
+      patterns_regexps_not_unique: 'must be unique within consumer group'
+
+    pattern:
+      regexp_format: must be a regular expression
+      name_format: 'needs to be a string with a Kafka accepted format'
+      regexp_string_format: 'needs to be a string and start with ^'
+      missing: needs to be present
+
+    config:
+      encryption.active_format: 'needs to be either true or false'
+      encryption.public_key_invalid: 'is not a valid public RSA key'
+      encryption.public_key_needs_to_be_public: 'is a private RSA key not a public one'
+      encryption.private_keys_format: 'needs to be a hash of version and private key value'
+      encryption.private_keys_need_to_be_private: 'all keys need to be private'
+      encryption.version_format: must be a non-empty string
+      encryption.public_key_format: 'is not a valid public RSA key'
+      encryption.private_keys_invalid: 'contains an invalid private RSA key string'
+
+      patterns.ttl_format: needs to be an integer bigger than 0
+      patterns.ttl_missing: needs to be present

data/docker-compose.yml

@@ -1,17 +1,25 @@
 version: '2'
+
 services:
-  zookeeper:
-    image: wurstmeister/zookeeper
-    ports:
-      - "2181:2181"
   kafka:
-    image: wurstmeister/kafka:1.0.1
+    container_name: kafka
+    image: confluentinc/cp-kafka:7.5.1
+
     ports:
-      - "9092:9092"
+      - 9092:9092
+
     environment:
-      KAFKA_ADVERTISED_HOST_NAME: localhost
-      KAFKA_ADVERTISED_PORT: 9092
-      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
+      CLUSTER_ID: kafka-docker-cluster-1
+      KAFKA_INTER_BROKER_LISTENER_NAME: PLAINTEXT
+      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
+      KAFKA_PROCESS_ROLES: broker,controller
+      KAFKA_CONTROLLER_LISTENER_NAMES: CONTROLLER
+      KAFKA_LISTENERS: PLAINTEXT://:9092,CONTROLLER://:9093
+      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT
+      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://127.0.0.1:9092
+      KAFKA_BROKER_ID: 1
+      KAFKA_CONTROLLER_QUORUM_VOTERS: 1@127.0.0.1:9093
+      ALLOW_PLAINTEXT_LISTENER: 'yes'
       KAFKA_AUTO_CREATE_TOPICS_ENABLE: 'true'
-    volumes:
-      - /var/run/docker.sock:/var/run/docker.sock
+      KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 1
+      KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: 1

data/karafka.gemspec

@@ -5,38 +5,42 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 require 'karafka/version'
 
-# rubocop:disable Metrics/BlockLength
 Gem::Specification.new do |spec|
   spec.name        = 'karafka'
   spec.version     = ::Karafka::VERSION
   spec.platform    = Gem::Platform::RUBY
-  spec.authors     = ['Maciej Mensfeld', 'Pavlo Vavruk', 'Adam Gwozdowski']
-  spec.email       = %w[maciej@mensfeld.pl pavlo.vavruk@gmail.com adam99g@gmail.com]
+  spec.authors     = ['Maciej Mensfeld']
+  spec.email       = %w[contact@karafka.io]
   spec.homepage    = 'https://karafka.io'
-  spec.summary     = 'Ruby based framework for working with Apache Kafka'
-  spec.description = 'Framework used to simplify Apache Kafka based Ruby applications development'
-  spec.license     = 'MIT'
-
-  spec.add_dependency 'dry-configurable', '~> 0.13'
-  spec.add_dependency 'dry-inflector', '~> 0.2'
-  spec.add_dependency 'dry-monitor', '~> 0.5'
-  spec.add_dependency 'dry-validation', '~> 1.7'
-  spec.add_dependency 'envlogic', '~> 1.1'
-  spec.add_dependency 'ruby-kafka', '>= 1.3.0'
-  spec.add_dependency 'thor', '>= 1.1'
-  spec.add_dependency 'waterdrop', '~> 1.4'
-  spec.add_dependency 'zeitwerk', '~> 2.4'
-
-  spec.required_ruby_version = '>= 2.6.0'
+  spec.licenses    = %w[LGPL-3.0 Commercial]
+  spec.summary     = 'Karafka is Ruby and Rails efficient Kafka processing framework.'
+  spec.description = <<-DESC
+    Karafka is Ruby and Rails efficient Kafka processing framework.
+
+    Karafka allows you to capture everything that happens in your systems in large scale,
+    without having to focus on things that are not your business domain.
+  DESC
+
+  spec.add_dependency 'karafka-core', '>= 2.2.2', '< 2.3.0'
+  spec.add_dependency 'waterdrop', '>= 2.6.10', '< 3.0.0'
+  spec.add_dependency 'zeitwerk', '~> 2.3'
 
   if $PROGRAM_NAME.end_with?('gem')
     spec.signing_key = File.expand_path('~/.ssh/gem-private_key.pem')
   end
 
-  spec.cert_chain    = %w[certs/mensfeld.pem]
+  spec.cert_chain    = %w[certs/cert_chain.pem]
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(spec)/}) }
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.executables   = %w[karafka]
   spec.require_paths = %w[lib]
-  spec.metadata      = { 'source_code_uri' => 'https://github.com/karafka/karafka' }
+
+  spec.metadata = {
+    'funding_uri' => 'https://karafka.io/#become-pro',
+    'homepage_uri' => 'https://karafka.io',
+    'changelog_uri' => 'https://karafka.io/docs/Changelog-Karafka',
+    'bug_tracker_uri' => 'https://github.com/karafka/karafka/issues',
+    'source_code_uri' => 'https://github.com/karafka/karafka',
+    'documentation_uri' => 'https://karafka.io/docs',
+    'rubygems_mfa_required' => 'true'
+  }
 end
-# rubocop:enable Metrics/BlockLength

data/lib/active_job/karafka.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+begin
+  # Do not load active job if already loaded
+  require 'active_job' unless Object.const_defined?('ActiveJob')
+
+  require_relative 'queue_adapters/karafka_adapter'
+
+  module ActiveJob
+    # Namespace for usage simplification outside of Rails where Railtie will not kick in.
+    # That way a require 'active_job/karafka' should be enough to use it
+    module Karafka
+    end
+  end
+rescue LoadError
+  # We extend ActiveJob stuff in the railtie
+end

data/lib/active_job/queue_adapters/karafka_adapter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# ActiveJob components to allow for jobs consumption with Karafka
+module ActiveJob
+  # ActiveJob queue adapters
+  module QueueAdapters
+    # Karafka adapter for enqueuing jobs
+    # This is here for ease of integration with ActiveJob.
+    class KarafkaAdapter
+      # Enqueues the job using the configured dispatcher
+      #
+      # @param job [Object] job that should be enqueued
+      def enqueue(job)
+        ::Karafka::App.config.internal.active_job.dispatcher.dispatch(job)
+      end
+
+      # Enqueues multiple jobs in one go
+      # @param jobs [Array<Object>] jobs that we want to enqueue
+      def enqueue_all(jobs)
+        ::Karafka::App.config.internal.active_job.dispatcher.dispatch_many(jobs)
+      end
+
+      # Raises info, that Karafka backend does not support scheduling jobs
+      #
+      # @param _job [Object] job we cannot enqueue
+      # @param _timestamp [Time] time when job should run
+      def enqueue_at(_job, _timestamp)
+        raise NotImplementedError, 'This queueing backend does not support scheduling jobs.'
+      end
+    end
+  end
+end

data/lib/karafka/active_job/consumer.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Karafka
+  # Namespace for all the ActiveJob related things from within Karafka
+  module ActiveJob
+    # This is the consumer for ActiveJob that eats the messages enqueued with it one after another.
+    # It marks the offset after each message, so we make sure, none of the jobs is executed twice
+    class Consumer < ::Karafka::BaseConsumer
+      # Executes the ActiveJob logic
+      # @note ActiveJob does not support batches, so we just run one message after another
+      def consume
+        messages.each do |message|
+          break if Karafka::App.stopping?
+
+          consume_job(message)
+
+          mark_as_consumed(message)
+        end
+      end
+
+      private
+
+      # Consumes a message with the job and runs needed instrumentation
+      #
+      # @param job_message [Karafka::Messages::Message] message with active job
+      def consume_job(job_message)
+        with_deserialized_job(job_message) do |job|
+          tags.add(:job_class, job['job_class'])
+
+          payload = { caller: self, job: job, message: job_message }
+
+          # We publish both to make it consistent with `consumer.x` events
+          Karafka.monitor.instrument('active_job.consume', payload)
+          Karafka.monitor.instrument('active_job.consumed', payload) do
+            ::ActiveJob::Base.execute(job)
+          end
+        end
+      end
+
+      # @param job_message [Karafka::Messages::Message] message with active job
+      def with_deserialized_job(job_message)
+        # We technically speaking could set this as deserializer and reference it from the
+        # message instead of using the `#raw_payload`. This is not done on purpose to simplify
+        # the ActiveJob setup here
+        yield ::ActiveSupport::JSON.decode(job_message.raw_payload)
+      end
+    end
+  end
+end

data/lib/karafka/active_job/current_attributes/loading.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Karafka
+  module ActiveJob
+    module CurrentAttributes
+      # Module expanding the job deserialization to extract current attributes and load them
+      # for the time of the job execution
+      module Loading
+        # @param job_message [Karafka::Messages::Message] message with active job
+        def with_deserialized_job(job_message)
+          super(job_message) do |job|
+            resetable = []
+
+            _cattr_klasses.each do |key, cattr_klass_str|
+              next unless job.key?(key)
+
+              attributes = job.delete(key)
+
+              cattr_klass = cattr_klass_str.constantize
+
+              attributes.each do |name, value|
+                cattr_klass.public_send("#{name}=", value)
+              end
+
+              resetable << cattr_klass
+            end
+
+            yield(job)
+
+            resetable.each(&:reset)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/active_job/current_attributes/persistence.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Karafka
+  module ActiveJob
+    module CurrentAttributes
+      # Module adding the current attributes persistence into the ActiveJob jobs
+      module Persistence
+        # Alters the job serialization to inject the current attributes into the json before we
+        # send it to Kafka
+        #
+        # @param job [ActiveJob::Base] job
+        def serialize_job(job)
+          json = super(job)
+
+          _cattr_klasses.each do |key, cattr_klass_str|
+            next if json.key?(key)
+
+            attrs = cattr_klass_str.constantize.attributes
+
+            json[key] = attrs unless attrs.empty?
+          end
+
+          json
+        end
+      end
+    end
+  end
+end

data/lib/karafka/active_job/current_attributes.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'active_support/current_attributes'
+require_relative 'current_attributes/loading'
+require_relative 'current_attributes/persistence'
+
+# This code is based on Sidekiqs approach to persisting current attributes
+# @see https://github.com/sidekiq/sidekiq/blob/main/lib/sidekiq/middleware/current_attributes.rb
+module Karafka
+  module ActiveJob
+    # Module that allows to persist current attributes on Karafka jobs
+    module CurrentAttributes
+      # Allows for persistence of given current attributes via AJ + Karafka
+      #
+      # @param klasses [Array<String, Class>] classes or names of the current attributes classes
+      def persist(*klasses)
+        # Support for providing multiple classes
+        klasses = Array(klasses).flatten
+
+        [Dispatcher, Consumer]
+          .reject { |expandable| expandable.respond_to?(:_cattr_klasses) }
+          .each { |expandable| expandable.class_attribute :_cattr_klasses, default: {} }
+
+        # Do not double inject in case of running persist multiple times
+        Dispatcher.prepend(Persistence) unless Dispatcher.ancestors.include?(Persistence)
+        Consumer.prepend(Loading) unless Consumer.ancestors.include?(Loading)
+
+        klasses.map(&:to_s).each do |stringified_klass|
+          # Prevent registering same klass multiple times
+          next if Dispatcher._cattr_klasses.value?(stringified_klass)
+
+          key = "cattr_#{Dispatcher._cattr_klasses.count}"
+
+          Dispatcher._cattr_klasses[key] = stringified_klass
+          Consumer._cattr_klasses[key] = stringified_klass
+        end
+      end
+
+      module_function :persist
+    end
+  end
+end