karafka 1.4.13 → 2.0.0

data/bin/benchmarks

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+
+# Runner for running given benchmark cases
+# Some of the cases require pre-populated data and we populate this in places that need it
+# In other cases we generate this data in a background process, so the partitions data stream
+# is consistent and we don't end up consuming huge batches of a single partition.
+
+require 'open3'
+require 'pathname'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..'))
+
+ROOT_PATH = Pathname.new(File.expand_path(File.join(File.dirname(__FILE__), '../')))
+
+# Load all the benchmarks
+benchmarks = Dir[ROOT_PATH.join('spec/benchmarks/**/*.rb')]
+
+# If filter is provided, apply
+benchmarks.delete_if { |name| !name.include?(ARGV[0]) } if ARGV[0]
+
+raise ArgumentError, "No benchmarks with filter: #{ARGV[0]}" if benchmarks.empty?
+
+# We may skip seeding if we are running the benchmarks multiple times, then since we do not
+# commit offsets we can skip generating more data
+if ENV['SEED']
+  require 'spec/benchmarks_helper'
+
+  # We need to setup karafka here to have producer for data seeding
+  setup_karafka
+
+  # This takes some time but needs to run only once per benchmark session
+  puts 'Seeding benchmarks data...'
+
+  producer = Karafka::App.producer
+
+  # We make our data json compatible so we can also benchmark serialization
+  elements = Array.new(100_000) { { a: :b }.to_json }
+
+  # We do not populate data of benchmarks_0_10 as we use it with life-stream data only
+  %w[
+    benchmarks_00_01
+    benchmarks_00_05
+  ].each do |topic_name|
+    partitions_count = topic_name.split('_').last.to_i
+
+    partitions_count.times do |partition|
+      puts "Seeding #{topic_name}:#{partition}"
+
+      elements.each_slice(10_000) do |data_slice|
+        data = data_slice.map do |data|
+          { topic: topic_name, payload: data, partition: partition }
+        end
+
+        producer.buffer_many(data)
+        producer.flush_sync
+      end
+    end
+  end
+end
+
+# Selects requested benchmarks and runs them one after another
+benchmarks.each do |benchmark_path|
+  puts "Running #{benchmark_path.gsub("#{ROOT_PATH}/spec/benchmarks/", '')}"
+
+  benchmark = "bundle exec ruby -r ./spec/benchmarks_helper.rb #{benchmark_path}"
+
+  Open3.popen3(benchmark) do |stdin, stdout, stderr, thread|
+    t1 = Thread.new do
+      while line = stdout.gets
+        puts(line)
+      end
+    rescue IOError
+    end
+
+    t2 = Thread.new do
+      while line = stderr.gets
+        puts(line)
+      end
+    rescue IOError
+    end
+
+    thread.join
+  end
+end

data/bin/create_token

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+require 'openssl'
+require 'base64'
+require 'json'
+require 'date'
+
+PRIVATE_KEY_LOCATION = File.join(Dir.home, '.ssh', 'karafka-pro', 'id_rsa')
+
+# Name of the entity that acquires the license
+ENTITY = ARGV[0]
+
+raise ArgumentError, 'Entity missing' if ENTITY.nil? || ENTITY.empty?
+
+pro_token_data = { entity: ENTITY }
+
+# This code uses my private key to generate a new token for Karafka Pro capabilities
+private_key = OpenSSL::PKey::RSA.new(File.read(PRIVATE_KEY_LOCATION))
+
+bin_key = private_key.private_encrypt(pro_token_data.to_json)
+
+puts Base64.encode64(bin_key)

data/bin/integrations

@@ -0,0 +1,237 @@
+#!/usr/bin/env ruby
+
+# Runner to run integration specs in parallel
+
+# Part of integration specs run pristine without bundler.
+# If we would run bundle exec when running this code, bundler would inject its own context
+# into them, messing things up heavily
+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__), '../')))
+
+# How many child processes with integration specs do we want to run in parallel
+# When the value is high, there's a problem with thread allocation on Github CI, tht is why
+# we limit it. Locally we can run a lot of those, as many of them have sleeps and do not use a lot
+# of CPU
+CONCURRENCY = ENV.key?('CI') ? 5 : Etc.nprocessors * 2
+
+# How may bytes do we want to keep from the stdout in the buffer for when we need to print it
+MAX_BUFFER_OUTPUT = 51_200
+
+# Abstraction around a single test scenario execution process
+class Scenario
+  # How long a scenario can run before we kill it
+  # This is a fail-safe just in case something would hang
+  MAX_RUN_TIME = 3 * 60 # 3 minutes tops
+
+  # There are rare cases where Karafka may force shutdown for some of the integration cases
+  # This includes exactly those
+  EXIT_CODES = {
+    default: [0],
+    'consumption/worker_critical_error_behaviour.rb' => [0, 2].freeze,
+    'shutdown/on_hanging_jobs_and_a_shutdown.rb' => [2].freeze,
+    'shutdown/on_hanging_on_shutdown_job_and_a_shutdown.rb' => [2].freeze,
+    'shutdown/on_hanging_listener_and_shutdown.rb' => [2].freeze
+  }.freeze
+
+  private_constant :MAX_RUN_TIME, :EXIT_CODES
+
+  # Creates scenario instance and runs in the background process
+  #
+  # @param path [String] path to the scenarios file
+  def initialize(path)
+    @path = path
+    # Last 1024 characters from stdout
+    @stdout_tail = ''
+  end
+
+  # Starts running given scenario in a separate process
+  def start
+    @stdin, @stdout, @stderr, @wait_thr = Open3.popen3(init_and_build_cmd)
+    @started_at = current_time
+  end
+
+  # @return [String] integration spec name
+  def name
+    @path.gsub("#{ROOT_PATH}/spec/integrations/", '')
+  end
+
+  # @return [Boolean] true if spec is pristine
+  def pristine?
+    scenario_dir = File.dirname(@path)
+
+    # If there is a Gemfile in a scenario directory, it means it is a pristine spec and we need
+    # to run bundle install, etc in order to run it
+    File.exist?(File.join(scenario_dir, 'Gemfile'))
+  end
+
+  # @return [Boolean] did this scenario finished or is it still running
+  def finished?
+    # If the thread is running too long, kill it
+    if current_time - @started_at > MAX_RUN_TIME
+      @wait_thr.kill
+
+      begin
+        Process.kill('TERM', pid)
+      # It may finish right after we want to kill it, that's why we ignore this
+      rescue Errno::ESRCH
+      end
+    end
+
+    # We read it so it won't grow as we use our default logger that prints to both test.log and
+    # to stdout. Otherwise after reaching the buffer size, it would hang
+    buffer = ''
+    @stdout.read_nonblock(MAX_BUFFER_OUTPUT, buffer, exception: false)
+    @stdout_tail << buffer
+    @stdout_tail = @stdout_tail[-MAX_BUFFER_OUTPUT..-1] || @stdout_tail
+
+    !@wait_thr.alive?
+  end
+
+  # @return [Boolean] did this scenario finish successfully or not
+  def success?
+    expected_exit_codes = EXIT_CODES[name] || EXIT_CODES[:default]
+
+    expected_exit_codes.include?(exit_code)
+  end
+
+  # @return [Integer] pid of the process of this scenario
+  def pid
+    @wait_thr.pid
+  end
+
+  # @return [Integer] exit code of the process running given scenario
+  def exit_code
+    # There may be no exit status if we killed the thread
+    @wait_thr.value&.exitstatus || 123
+  end
+
+  # Prints a status report when scenario is finished and stdout if it failed
+  def report
+    if success?
+      print "\e[#{32}m#{'.'}\e[0m"
+    else
+      buffer = ''
+
+      @stderr.read_nonblock(MAX_BUFFER_OUTPUT, buffer, exception: false)
+
+      puts
+      puts "\e[#{31}m#{'[FAILED]'}\e[0m #{name}"
+      puts "Exit code: #{exit_code}"
+      puts @stdout_tail
+      puts buffer
+      puts
+    end
+  end
+
+  private
+
+  # Sets up a proper environment for a given spec to run and returns the run command
+  # @return [String] run command
+  def init_and_build_cmd
+    # If there is a Gemfile in a scenario directory, it means it is a pristine spec and we need
+    # to run bundle install, etc in order to run it
+    if pristine?
+      scenario_dir = File.dirname(@path)
+      # We copy the spec into a temp dir, not to pollute the spec location with logs, etc
+      temp_dir = Dir.mktmpdir
+      file_name = File.basename(@path)
+
+      FileUtils.cp_r("#{scenario_dir}/.", temp_dir)
+
+      <<~CMD
+        cd #{temp_dir} &&
+        KARAFKA_GEM_DIR=#{ROOT_PATH} \
+        BUNDLE_AUTO_INSTALL=true \
+        PRISTINE_MODE=true \
+        bundle exec ruby -r #{ROOT_PATH}/spec/integrations_helper.rb #{file_name}
+      CMD
+    else
+      <<~CMD
+        KARAFKA_GEM_DIR=#{ROOT_PATH} \
+        bundle exec ruby -r ./spec/integrations_helper.rb #{@path}
+      CMD
+    end
+  end
+
+  # @return [Float] current machine time
+  def current_time
+    Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+end
+
+# 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?
+
+# Randomize order
+seed = (ENV['SEED'] || rand(0..10_000)).to_i
+
+puts "Random seed: #{seed}"
+
+scenarios = specs
+            .shuffle(random: Random.new(seed))
+            .map { |integration_test| Scenario.new(integration_test) }
+
+regulars = scenarios.reject(&:pristine?)
+pristine = scenarios.select(&:pristine?)
+
+active_scenarios = []
+finished_scenarios = []
+
+while finished_scenarios.size < scenarios.size
+  # If we have space to run another scenario, we add it
+  if active_scenarios.size < CONCURRENCY
+    scenario = nil
+    # We can run only one pristine at the same time due to concurrency issues within bundler
+    # Since they usually take longer than others, we try to run them as fast as possible when there
+    # is a slot
+    scenario = pristine.pop unless active_scenarios.any?(&:pristine?)
+    scenario ||= regulars.pop
+
+    if scenario
+      scenario.start
+      active_scenarios << scenario
+    end
+  end
+
+  active_scenarios.select(&:finished?).each do |exited|
+    scenario = active_scenarios.delete(exited)
+    scenario.report
+    finished_scenarios << scenario
+  end
+
+  sleep(0.1)
+end
+
+failed_scenarios = finished_scenarios.reject(&:success?)
+
+# Report once more on the failed jobs
+# This will only list scenarios that failed without printing their stdout here.
+if failed_scenarios.empty?
+  puts
+else
+  puts "\nFailed scenarios:\n\n"
+
+  failed_scenarios.each do |scenario|
+    puts "\e[#{31}m#{'[FAILED]'}\e[0m #{scenario.name}"
+  end
+
+  puts
+
+  # Exit with 1 if not all scenarios were successful
+  exit 1
+end

data/bin/karafka

@@ -2,6 +2,10 @@
 
 require 'karafka'
 
+# We set this to indicate, that the process in which we are (whatever it does) was started using
+# our bin/karafka cli
+ENV['KARAFKA_CLI'] = 'true'
+
 # If there is a boot file, we need to require it as we expect it to contain
 # Karafka app setup, routes, etc
 if File.exist?(Karafka.boot_file)

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/wait_for_kafka

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+# This script allows us to wait for Kafka docker to fully be ready
+# We consider it fully ready when all our topics that need to be created are created as expected
+
+KAFKA_NAME='karafka_20_kafka'
+ZOOKEEPER='zookeeper:2181'
+LIST_CMD="kafka-topics.sh --list --zookeeper $ZOOKEEPER"
+
+# Take the number of topics that we need to create prior to running anything
+TOPICS_COUNT=`cat docker-compose.yml | grep -E -i 'integrations_|benchmarks_' | wc -l`
+
+# And wait until all of them are created
+until (((`docker exec $KAFKA_NAME $LIST_CMD | wc -l`) >= $TOPICS_COUNT));
+do
+  echo "Waiting for Kafka to create all the needed topics..."
+  sleep 1
+done
+
+echo "All the needed topics created."

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/errors.yml

@@ -1,41 +1,56 @@
 en:
-  dry_validation:
-    errors:
-      invalid_broker_schema: >
-        has an invalid format
-        Expected schema, host and port number
-        Example: kafka://127.0.0.1:9092 or kafka+ssl://127.0.0.1:9092
-      invalid_certificate: >
-        is not a valid certificate
-      invalid_certificate_from_path: >
-        is not a valid certificate
-      invalid_private_key: >
-        is not a valid private key
-      max_timeout_size_for_exponential: >
-        pause_timeout cannot be more than pause_max_timeout
-      max_wait_time_limit:
-        max_wait_time cannot be more than socket_timeout
-      topics_names_not_unique: >
-        all topic names within a single consumer group must be unique
-      ssl_client_cert_with_ssl_client_cert_key: >
-        Both ssl_client_cert and ssl_client_cert_key need to be provided
-      ssl_client_cert_key_with_ssl_client_cert: >
-        Both ssl_client_cert_key and ssl_client_cert need to be provided
-      ssl_client_cert_chain_with_ssl_client_cert: >
-        Both ssl_client_cert_chain and ssl_client_cert need to be provided
-      ssl_client_cert_chain_with_ssl_client_cert_key: >
-        Both ssl_client_cert_chain and ssl_client_cert_key need to be provided
-      ssl_client_cert_key_password_with_ssl_client_cert_key: >
-        Both ssl_client_cert_key_password and ssl_client_cert_key need to be provided
-      does_not_respond_to_token: >
-        needs to respond to a #token method
-      required_usage_count: >
-        Given topic must be used at least once
-      pid_already_exists: >
-        Pidfile already exists
-      consumer_groups_inclusion: >
-        Unknown consumer group
-      does_not_exist:
-        Given file does not exist or cannot be read
-      does_not_respond_to_call: >
-        needs to respond to a #call method
+  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.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
+      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
+
+    server_cli_options:
+      missing: needs to be present
+      consumer_groups_inclusion: Unknown consumer group
+
+    consumer_group_topic:
+      missing: needs to be present
+      name_format: 'needs to be a string with a Kafka accepted format'
+      deserializer_format: needs to be present
+      manual_offset_management_format: needs to be either true or false
+      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
+
+    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
+
+    job_options:
+      missing: needs to be present
+      dispatch_method_format: needs to be either :produce_async or :produce_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
+
+    pro_consumer_group_topic:
+      consumer_format: needs to inherit from Karafka::Pro::BaseConsumer and not Karafka::Consumer

data/docker-compose.yml

@@ -1,17 +1,53 @@
 version: '2'
 services:
   zookeeper:
+    container_name: karafka_20_zookeeper
     image: wurstmeister/zookeeper
     ports:
-      - "2181:2181"
+      - '2181:2181'
   kafka:
-    image: wurstmeister/kafka:1.0.1
+    container_name: karafka_20_kafka
+    image: wurstmeister/kafka
     ports:
-      - "9092:9092"
+      - '9092:9092'
     environment:
       KAFKA_ADVERTISED_HOST_NAME: localhost
       KAFKA_ADVERTISED_PORT: 9092
       KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
       KAFKA_AUTO_CREATE_TOPICS_ENABLE: 'true'
+      KAFKA_CREATE_TOPICS:
+        "integrations_00_02:2:1,\
+         integrations_01_02:2:1,\
+         integrations_02_02:2:1,\
+         integrations_03_02:2:1,\
+         integrations_04_02:2:1,\
+         integrations_05_02:2:1,\
+         integrations_06_02:2:1,\
+         integrations_07_02:2:1,\
+         integrations_08_02:2:1,\
+         integrations_09_02:2:1,\
+         integrations_10_02:2:1,\
+         integrations_11_02:2:1,\
+         integrations_12_02:2:1,\
+         integrations_13_02:2:1,\
+         integrations_14_02:2:1,\
+         integrations_15_02:2:1,\
+         integrations_16_02:2:1,\
+         integrations_17_02:2:1,\
+         integrations_18_02:2:1,\
+         integrations_19_02:2:1,\
+         integrations_20_02:2:1,\
+         integrations_21_02:2:1,\
+         integrations_00_03:3:1,\
+         integrations_01_03:3:1,\
+         integrations_02_03:3:1,\
+         integrations_03_03:3:1,\
+         integrations_04_03:3:1,\
+         integrations_00_10:10:1,\
+         integrations_01_10:10:1,\
+         benchmarks_00_01:1:1,\
+         benchmarks_00_05:5:1,\
+         benchmarks_01_05:5:1,\
+         benchmarks_00_10:10:1"
     volumes:
       - /var/run/docker.sock:/var/run/docker.sock

data/karafka.gemspec

@@ -5,29 +5,24 @@ $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[maciej@mensfeld.pl]
   spec.homepage    = 'https://karafka.io'
-  spec.summary     = 'Ruby based framework for working with Apache Kafka'
+  spec.summary     = 'Efficient Kafka processing framework for Ruby and Rails'
   spec.description = 'Framework used to simplify Apache Kafka based Ruby applications development'
-  spec.license     = 'MIT'
+  spec.licenses    = ['LGPL-3.0', 'Commercial']
 
-  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.add_dependency 'karafka-core', '>= 2.0.2', '< 3.0.0'
+  spec.add_dependency 'rdkafka', '>= 0.12'
+  spec.add_dependency 'thor', '>= 0.20'
+  spec.add_dependency 'waterdrop', '>= 2.4.1', '< 3.0.0'
+  spec.add_dependency 'zeitwerk', '~> 2.3'
 
-  spec.required_ruby_version = '>= 2.7'
+  spec.required_ruby_version = '>= 2.7.0'
 
   if $PROGRAM_NAME.end_with?('gem')
     spec.signing_key = File.expand_path('~/.ssh/gem-private_key.pem')
@@ -35,7 +30,7 @@ Gem::Specification.new do |spec|
 
   spec.cert_chain    = %w[certs/mensfeld.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 = {
@@ -43,4 +38,3 @@ Gem::Specification.new do |spec|
     'rubygems_mfa_required' => 'true'
   }
 end
-# rubocop:enable Metrics/BlockLength