phobos 2.1.4 → 2.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02e1b97b3d44dffefffea99da0c15393997043598697d88fe3f7c7ab83549193
-  data.tar.gz: 4e3ec45a1db997825ace585a1535ac5c1504105afabe0470c0c676f8f301c66a
+  metadata.gz: 24a11008734215b1d581b98e05eac705dd079e9fc6ccbd860c172c9d353ae967
+  data.tar.gz: ed890beddcc432d630a1f8484bd40383ca97fc0120359219012f3d30e9ee541b
 SHA512:
-  metadata.gz: b249c05f44dfe0dcb0f81b8177dd27a129e4364e0dbcbf8492295d9823473a7de66ee913c088945346a4e1943b3f2226c8106083cf5502d90341b8bb8fbac0eb
-  data.tar.gz: f6725f584a75f099bb2b4624338e424f7ba44859ace5c660bfc20d8f5681d663a1cd051381d18f832659f87bd1406d5c8aea3098112876a1f119649b56645be6
+  metadata.gz: 87a05771626c4c1aeb849cc7857769beca6648dac5e2f87e11fdb62ba798e036d6c366f848c274d7a17ff209f4754380266f21a6fe68d7c7cdcd70d369e6dea3
+  data.tar.gz: ec3e274766f29c73ba31037fb6cbce779b9d2bb4d89f7da127973046682fa3426450b006aba94c9f67ab559a062b2e4d1f28d25667dc9d9eb8de279d69eb84a1

data/CHANGELOG.md

@@ -6,6 +6,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 ``
 ## UNRELEASED
 
+## [2.1.5] - 2022-09-08
+
+- Added RBS signatures.
+
 ## [2.1.4] - 2022-06-15
 
 - Re-raise consuming errors so that threads don't die forever and are retried

data/lib/phobos/batch_handler.rb

@@ -2,21 +2,32 @@
 
 module Phobos
   module BatchHandler
+    # @!visibility private
     def self.included(base)
       base.extend(ClassMethods)
     end
 
+    # @param _payloads [Array]
+    # @param _metadata [Hash<String, Object>]
+    # @return [void]
     def consume_batch(_payloads, _metadata)
       raise NotImplementedError
     end
 
+    # @param payloads [Array]
+    # @param metadata [Hash<String, Object>]
+    # @yield [Array, Hash<String, Object>]
+    # @return [void]
     def around_consume_batch(payloads, metadata)
       yield payloads, metadata
     end
 
     module ClassMethods
+      # @param kafka_client
+      # @return [void]
       def start(kafka_client); end
 
+      # @return [void]
       def stop; end
     end
   end

data/lib/phobos/batch_message.rb

@@ -2,8 +2,23 @@
 
 module Phobos
   class BatchMessage
-    attr_accessor :key, :partition, :offset, :payload, :headers
+    # @return
+    attr_accessor :key
+    # @return [Integer]
+    attr_accessor :partition
+    # @return [Integer]
+    attr_accessor :offset
+    # @return
+    attr_accessor :payload
+    # @return
+    attr_accessor :headers
 
+    # @param key
+    # @param partition [Integer]
+    # @param offset [Integer]
+    # @param payload
+    # @param headers
+    # @return [void]
     def initialize(key:, partition:, offset:, payload:, headers:)
       @key = key
       @partition = partition
@@ -12,6 +27,8 @@ module Phobos
       @headers = headers
     end
 
+    # @param other [Phobos::BatchMessage]
+    # @return [Boolean]
     def ==(other)
       [:key, :partition, :offset, :payload, :headers].all? do |s|
         public_send(s) == other.public_send(s)

data/lib/phobos/cli.rb

@@ -4,6 +4,7 @@ require 'thor'
 require 'phobos/cli/start'
 
 module Phobos
+  # @!visibility private
   module CLI
     def self.logger
       @logger ||= Logging.logger[self].tap do |l|
@@ -11,6 +12,7 @@ module Phobos
       end
     end
 
+    # @!visibility private
     class Commands < Thor
       include Thor::Actions
 

data/lib/phobos/configuration.rb

@@ -4,6 +4,8 @@ require 'phobos/deep_struct'
 
 module Phobos
   module Configuration
+    # @param configuration
+    # @return [void]
     def configure(configuration)
       @config = fetch_configuration(configuration)
       @config.class.send(:define_method, :producer_hash) do
@@ -16,7 +18,7 @@ module Phobos
       configure_logger
     end
 
-    # :nodoc:
+    # @return [void]
     def configure_logger
       Logging.backtrace(true)
       Logging.logger.root.level = silence_log ? :fatal : config.logger.level

data/lib/phobos/handler.rb

@@ -2,6 +2,7 @@
 
 module Phobos
   module Handler
+    # @!visibility private
     def self.included(base)
       base.extend(ClassMethods)
     end

data/lib/phobos/listener.rb

@@ -9,9 +9,28 @@ module Phobos
     DEFAULT_MAX_BYTES_PER_PARTITION = 1_048_576 # 1 MB
     DELIVERY_OPTS = %w[batch message inline_batch].freeze
 
-    attr_reader :group_id, :topic, :id
-    attr_reader :handler_class, :encoding, :consumer
-
+    # @return [String]
+    attr_reader :group_id
+    # @return [String]
+    attr_reader :topic
+    attr_reader :id
+    # @return [Class]
+    attr_reader :handler_class
+    attr_reader :encoding, :consumer
+
+    # @param handler [Class]
+    # @param group_id [String]
+    # @param topic [String]
+    # @param min_bytes [Integer]
+    # @param max_wait_time [Integer]
+    # @param start_from_beginning [Boolean]
+    # @param delivery [String]
+    # @param max_bytes_per_partition [Integer]
+    # @param session_timeout [Integer]
+    # @param offset_commit_interval [Integer]
+    # @param heartbeat_interval [Integer]
+    # @param offset_commit_threshold [Integer]
+    # @param offset_retention_time [Integer]
     # rubocop:disable Metrics/MethodLength
     def initialize(handler:, group_id:, topic:, min_bytes: nil, max_wait_time: nil,
                    force_encoding: nil, start_from_beginning: true, backoff: nil,
@@ -40,6 +59,7 @@ module Phobos
     end
     # rubocop:enable Metrics/MethodLength
 
+    # @return [void]
     def start
       @signal_to_stop = false
       start_listener
@@ -60,6 +80,7 @@ module Phobos
       stop_listener
     end
 
+    # @return [void]
     def stop
       return if should_stop?
 

data/lib/phobos/producer.rb

@@ -2,10 +2,12 @@
 
 module Phobos
   module Producer
+    # @!visibility private
     def self.included(base)
       base.extend(Phobos::Producer::ClassMethods)
     end
 
+    # @return [Phobos::Producer::PublicAPI]
     def producer
       Phobos::Producer::PublicAPI.new(self)
     end
@@ -15,6 +17,12 @@ module Phobos
         @host_obj = host_obj
       end
 
+      # @param topic [String]
+      # @param payload [String]
+      # @param key [String]
+      # @param partition_key [Integer]
+      # @param headers [Hash]
+      # @return [void]
       def publish(topic:, payload:, key: nil, partition_key: nil, headers: nil)
         class_producer.publish(topic: topic,
                                payload: payload,
@@ -23,6 +31,12 @@ module Phobos
                                headers: headers)
       end
 
+      # @param topic [String]
+      # @param payload [String]
+      # @param key [String]
+      # @param partition_key [Integer]
+      # @param headers [Hash]
+      # @return [void]
       def async_publish(topic:, payload:, key: nil, partition_key: nil, headers: nil)
         class_producer.async_publish(topic: topic,
                                      payload: payload,
@@ -31,7 +45,7 @@ module Phobos
                                      headers: headers)
       end
 
-      # @param messages [Array(Hash(:topic, :payload, :key, :headers))]
+      # @param messages [Array<Hash>]
       #        e.g.: [
       #          { topic: 'A', payload: 'message-1', key: '1', headers: { foo: 'bar' } },
       #          { topic: 'B', payload: 'message-2', key: '2', headers: { foo: 'bar' } }
@@ -41,6 +55,7 @@ module Phobos
         class_producer.publish_list(messages)
       end
 
+      # @param messages [Array<Hash>]
       def async_publish_list(messages)
         class_producer.async_publish_list(messages)
       end
@@ -53,29 +68,35 @@ module Phobos
     end
 
     module ClassMethods
+      # @return [Phobos::Producer::ClassMethods::PublicAPI]
       def producer
         Phobos::Producer::ClassMethods::PublicAPI.new
       end
 
       class PublicAPI
+        # @return [Symbol]
         NAMESPACE = :phobos_producer_store
+        # @return [Array<Symbol>]
         ASYNC_PRODUCER_PARAMS = [:max_queue_size, :delivery_threshold, :delivery_interval].freeze
+        # @return [Array<Symbol>]
         INTERNAL_PRODUCER_PARAMS = [:persistent_connections].freeze
 
         # This method configures the kafka client used with publish operations
         # performed by the host class
         #
         # @param kafka_client [Kafka::Client]
-        #
+        # @return [void]
         def configure_kafka_client(kafka_client)
           async_producer_shutdown
           producer_store[:kafka_client] = kafka_client
         end
 
+        # @return [Kafka::Client]
         def kafka_client
           producer_store[:kafka_client]
         end
 
+        # @return [Kafka::Producer]
         def create_sync_producer
           client = kafka_client || configure_kafka_client(Phobos.create_kafka_client(:producer))
           sync_producer = client.producer(**regular_configs)
@@ -85,20 +106,29 @@ module Phobos
           sync_producer
         end
 
+        # @return [Kafka::Producer]
         def sync_producer
           producer_store[:sync_producer]
         end
 
+        # @return [void]
         def sync_producer_shutdown
           sync_producer&.shutdown
           producer_store[:sync_producer] = nil
         end
 
+        # @param topic [String]
+        # @param payload [String]
+        # @param partition_key [Integer]
+        # @param headers [Hash]
+        # @return [void]
         def publish(topic:, payload:, key: nil, partition_key: nil, headers: nil)
           publish_list([{ topic: topic, payload: payload, key: key,
                           partition_key: partition_key, headers: headers }])
         end
 
+        # @param messages [Array<Hash>]
+        # @return [void]
         def publish_list(messages)
           producer = sync_producer || create_sync_producer
           produce_messages(producer, messages)
@@ -107,39 +137,51 @@ module Phobos
           producer&.shutdown unless Phobos.config.producer_hash[:persistent_connections]
         end
 
+        # @return [Kafka::AsyncProducer]
         def create_async_producer
           client = kafka_client || configure_kafka_client(Phobos.create_kafka_client(:producer))
           async_producer = client.async_producer(**async_configs)
           producer_store[:async_producer] = async_producer
         end
 
+        # @return [Kafka::AsyncProducer]
         def async_producer
           producer_store[:async_producer]
         end
 
+        # @param topic [String]
+        # @param payload [String]
+        # @param partition_key [Integer]
+        # @param headers [Hash]
+        # @return [void]
         def async_publish(topic:, payload:, key: nil, partition_key: nil, headers: nil)
           async_publish_list([{ topic: topic, payload: payload, key: key,
                                 partition_key: partition_key, headers: headers }])
         end
 
+        # @param messages [Array<Hash>]
+        # @return [void]
         def async_publish_list(messages)
           producer = async_producer || create_async_producer
           produce_messages(producer, messages)
           producer.deliver_messages unless async_automatic_delivery?
         end
 
+        # @return [void]
         def async_producer_shutdown
           async_producer&.deliver_messages
           async_producer&.shutdown
           producer_store[:async_producer] = nil
         end
 
+        # @return [Hash]
         def regular_configs
           Phobos.config.producer_hash
                 .reject { |k, _| ASYNC_PRODUCER_PARAMS.include?(k) }
                 .reject { |k, _| INTERNAL_PRODUCER_PARAMS.include?(k) }
         end
 
+        # @return [Hash]
         def async_configs
           Phobos.config.producer_hash
                 .reject { |k, _| INTERNAL_PRODUCER_PARAMS.include?(k) }

data/lib/phobos/version.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
 module Phobos
-  VERSION = '2.1.4'
+  # @return [String]
+  VERSION = '2.1.5'
 end

data/lib/phobos.rb

@@ -34,6 +34,7 @@ Thread.abort_on_exception = true
 Logging.init :debug, :info, :warn, :error, :fatal
 
 # Monkey patch to fix this issue: https://github.com/zendesk/ruby-kafka/pull/732
+# @!visibility private
 module Logging
   # :nodoc:
   class Logger
@@ -51,14 +52,21 @@ end
 module Phobos
   extend Configuration
   class << self
-    attr_reader :config, :logger
+    # @return [Phobos::DeepStruct]
+    attr_reader :config
+    # @return [Logger]
+    attr_reader :logger
+    # @return [Boolean]
     attr_accessor :silence_log
 
+    # @param configuration [Hash<String, Object>]
+    # @return [void]
     def add_listeners(configuration)
       listeners_config = fetch_configuration(configuration)
       @config.listeners += listeners_config.listeners
     end
 
+    # @param config_key [String]
     def create_kafka_client(config_key = nil)
       kafka_config = config.kafka.to_hash.merge(logger: @ruby_kafka_logger)
 
@@ -69,6 +77,7 @@ module Phobos
       Kafka.new(**kafka_config)
     end
 
+    # @param backoff_config [Hash<Symbol, Integer>]
     def create_exponential_backoff(backoff_config = nil)
       backoff_config ||= Phobos.config.backoff.to_hash
       min = backoff_config[:min_ms] / 1000.0
@@ -76,6 +85,8 @@ module Phobos
       ExponentialBackoff.new(min, max).tap { |backoff| backoff.randomize_factor = rand }
     end
 
+    # @param message [String]
+    # @return [void]
     def deprecate(message)
       location = caller.find { |line| line !~ %r{/phobos/} }
       warn "DEPRECATION WARNING: #{message}: #{location}"

data/phobos.gemspec

@@ -58,7 +58,9 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rubocop', '0.62.0'
   spec.add_development_dependency 'rubocop_rules'
   spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'sord'
   spec.add_development_dependency 'timecop'
+  spec.add_development_dependency 'yard'
 
   spec.add_dependency 'activesupport', '>= 3.0.0'
   spec.add_dependency 'concurrent-ruby', '>= 1.0.2'

data/sig/defs.rbs

@@ -0,0 +1,459 @@
+# Please use this with at least the same consideration as you would when using OpenStruct.
+# Right now we only use this to parse our internal configuration files. It is not meant to
+# be used on incoming data.
+module Phobos
+  extend Phobos::Configuration
+  VERSION: String
+
+  # _@param_ `configuration`
+  def self.add_listeners: (::Hash[String, Object] configuration) -> void
+
+  # _@param_ `config_key`
+  def self.create_kafka_client: (?String? config_key) -> untyped
+
+  # _@param_ `backoff_config`
+  def self.create_exponential_backoff: (?::Hash[Symbol, Integer]? backoff_config) -> untyped
+
+  # _@param_ `message`
+  def self.deprecate: (String message) -> void
+
+  # _@param_ `configuration`
+  def self.configure: (untyped configuration) -> void
+
+  def self.configure_logger: () -> void
+
+  def self.config: () -> Phobos::DeepStruct
+
+  def self.logger: () -> Logger
+
+  def self.silence_log: () -> bool
+
+  def self.silence_log=: (bool value) -> bool
+
+  module Log
+    def log_info: (untyped msg, ?untyped metadata) -> untyped
+
+    def log_debug: (untyped msg, ?untyped metadata) -> untyped
+
+    def log_error: (untyped msg, untyped metadata) -> untyped
+
+    def log_warn: (untyped msg, ?untyped metadata) -> untyped
+  end
+
+  module LoggerHelper
+    def self.log: (untyped method, untyped msg, untyped metadata) -> untyped
+  end
+
+  class Error < StandardError
+  end
+
+  class AbortError < Phobos::Error
+  end
+
+  module Handler
+    def consume: (untyped _payload, untyped _metadata) -> untyped
+
+    def around_consume: (untyped payload, untyped metadata) -> untyped
+
+    module ClassMethods
+      def start: (untyped kafka_client) -> untyped
+
+      def stop: () -> untyped
+    end
+  end
+
+  class Executor
+    include Phobos::Instrumentation
+    include Phobos::Log
+
+    def initialize: () -> void
+
+    def start: () -> untyped
+
+    def stop: () -> untyped
+
+    def log_info: (untyped msg, ?untyped metadata) -> untyped
+
+    def log_debug: (untyped msg, ?untyped metadata) -> untyped
+
+    def log_error: (untyped msg, untyped metadata) -> untyped
+
+    def log_warn: (untyped msg, ?untyped metadata) -> untyped
+
+    def instrument: (untyped event, ?untyped extra) -> untyped
+  end
+
+  # rubocop:disable Metrics/ParameterLists, Metrics/ClassLength
+  class Listener
+    include Phobos::Instrumentation
+    include Phobos::Log
+    DEFAULT_MAX_BYTES_PER_PARTITION: untyped
+    DELIVERY_OPTS: untyped
+
+    # rubocop:disable Metrics/MethodLength
+    # 
+    # _@param_ `handler`
+    # 
+    # _@param_ `group_id`
+    # 
+    # _@param_ `topic`
+    # 
+    # _@param_ `min_bytes`
+    # 
+    # _@param_ `max_wait_time`
+    # 
+    # _@param_ `start_from_beginning`
+    # 
+    # _@param_ `delivery`
+    # 
+    # _@param_ `max_bytes_per_partition`
+    # 
+    # _@param_ `session_timeout`
+    # 
+    # _@param_ `offset_commit_interval`
+    # 
+    # _@param_ `heartbeat_interval`
+    # 
+    # _@param_ `offset_commit_threshold`
+    # 
+    # _@param_ `offset_retention_time`
+    def initialize: (
+                      handler: Class,
+                      group_id: String,
+                      topic: String,
+                      ?min_bytes: Integer?,
+                      ?max_wait_time: Integer?,
+                      ?force_encoding: untyped,
+                      ?start_from_beginning: bool,
+                      ?backoff: untyped,
+                      ?delivery: String,
+                      ?max_bytes_per_partition: Integer,
+                      ?session_timeout: Integer?,
+                      ?offset_commit_interval: Integer?,
+                      ?heartbeat_interval: Integer?,
+                      ?offset_commit_threshold: Integer?,
+                      ?offset_retention_time: Integer?
+                    ) -> void
+
+    def start: () -> void
+
+    def stop: () -> void
+
+    def create_exponential_backoff: () -> untyped
+
+    def should_stop?: () -> bool
+
+    def send_heartbeat_if_necessary: () -> untyped
+
+    def log_info: (untyped msg, ?untyped metadata) -> untyped
+
+    def log_debug: (untyped msg, ?untyped metadata) -> untyped
+
+    def log_error: (untyped msg, untyped metadata) -> untyped
+
+    def log_warn: (untyped msg, ?untyped metadata) -> untyped
+
+    def instrument: (untyped event, ?untyped extra) -> untyped
+
+    attr_reader group_id: String
+
+    attr_reader topic: String
+
+    # Returns the value of attribute id.
+    attr_reader id: untyped
+
+    attr_reader handler_class: Class
+
+    # Returns the value of attribute encoding.
+    attr_reader encoding: untyped
+
+    # Returns the value of attribute consumer.
+    attr_reader consumer: untyped
+  end
+
+  module Producer
+    def producer: () -> Phobos::Producer::PublicAPI
+
+    class PublicAPI
+      def initialize: (untyped host_obj) -> void
+
+      # _@param_ `topic`
+      # 
+      # _@param_ `payload`
+      # 
+      # _@param_ `key`
+      # 
+      # _@param_ `partition_key`
+      # 
+      # _@param_ `headers`
+      def publish: (
+                     topic: String,
+                     payload: String,
+                     ?key: String?,
+                     ?partition_key: Integer?,
+                     ?headers: ::Hash[untyped, untyped]?
+                   ) -> void
+
+      # _@param_ `topic`
+      # 
+      # _@param_ `payload`
+      # 
+      # _@param_ `key`
+      # 
+      # _@param_ `partition_key`
+      # 
+      # _@param_ `headers`
+      def async_publish: (
+                           topic: String,
+                           payload: String,
+                           ?key: String?,
+                           ?partition_key: Integer?,
+                           ?headers: ::Hash[untyped, untyped]?
+                         ) -> void
+
+      # _@param_ `messages` — e.g.: [   { topic: 'A', payload: 'message-1', key: '1', headers: { foo: 'bar' } },   { topic: 'B', payload: 'message-2', key: '2', headers: { foo: 'bar' } } ]
+      def publish_list: (::Array[::Hash[untyped, untyped]] messages) -> untyped
+
+      # _@param_ `messages`
+      def async_publish_list: (::Array[::Hash[untyped, untyped]] messages) -> untyped
+    end
+
+    module ClassMethods
+      def producer: () -> Phobos::Producer::ClassMethods::PublicAPI
+
+      class PublicAPI
+        NAMESPACE: Symbol
+        ASYNC_PRODUCER_PARAMS: ::Array[Symbol]
+        INTERNAL_PRODUCER_PARAMS: ::Array[Symbol]
+
+        # This method configures the kafka client used with publish operations
+        # performed by the host class
+        # 
+        # _@param_ `kafka_client`
+        def configure_kafka_client: (Kafka::Client kafka_client) -> void
+
+        def kafka_client: () -> Kafka::Client
+
+        def create_sync_producer: () -> Kafka::Producer
+
+        def sync_producer: () -> Kafka::Producer
+
+        def sync_producer_shutdown: () -> void
+
+        # _@param_ `topic`
+        # 
+        # _@param_ `payload`
+        # 
+        # _@param_ `partition_key`
+        # 
+        # _@param_ `headers`
+        def publish: (
+                       topic: String,
+                       payload: String,
+                       ?key: untyped,
+                       ?partition_key: Integer?,
+                       ?headers: ::Hash[untyped, untyped]?
+                     ) -> void
+
+        # _@param_ `messages`
+        def publish_list: (::Array[::Hash[untyped, untyped]] messages) -> void
+
+        def create_async_producer: () -> Kafka::AsyncProducer
+
+        def async_producer: () -> Kafka::AsyncProducer
+
+        # _@param_ `topic`
+        # 
+        # _@param_ `payload`
+        # 
+        # _@param_ `partition_key`
+        # 
+        # _@param_ `headers`
+        def async_publish: (
+                             topic: String,
+                             payload: String,
+                             ?key: untyped,
+                             ?partition_key: Integer?,
+                             ?headers: ::Hash[untyped, untyped]?
+                           ) -> void
+
+        # _@param_ `messages`
+        def async_publish_list: (::Array[::Hash[untyped, untyped]] messages) -> void
+
+        def async_producer_shutdown: () -> void
+
+        def regular_configs: () -> ::Hash[untyped, untyped]
+
+        def async_configs: () -> ::Hash[untyped, untyped]
+      end
+    end
+  end
+
+  module Constants
+    LOG_DATE_PATTERN: untyped
+    KAFKA_CONSUMER_OPTS: untyped
+    LISTENER_OPTS: untyped
+  end
+
+  module Processor
+    include Phobos::Instrumentation
+    extend ActiveSupport::Concern
+    MAX_SLEEP_INTERVAL: untyped
+
+    def snooze: (untyped interval) -> untyped
+
+    def instrument: (untyped event, ?untyped extra) -> untyped
+  end
+
+  class DeepStruct < OpenStruct
+    # Based on
+    # https://docs.omniref.com/ruby/2.3.0/files/lib/ostruct.rb#line=88
+    def initialize: (?untyped hash) -> void
+
+    def to_h: () -> untyped
+  end
+
+  module Test
+    module Helper
+      TOPIC: untyped
+      GROUP: untyped
+
+      def process_message: (
+                             handler: untyped,
+                             payload: untyped,
+                             ?metadata: untyped,
+                             ?force_encoding: untyped
+                           ) -> untyped
+    end
+  end
+
+  class EchoHandler
+    include Phobos::Handler
+
+    def consume: (untyped message, untyped metadata) -> untyped
+
+    def around_consume: (untyped payload, untyped metadata) -> untyped
+  end
+
+  module BatchHandler
+    # _@param_ `_payloads`
+    # 
+    # _@param_ `_metadata`
+    def consume_batch: (::Array[untyped] _payloads, ::Hash[String, Object] _metadata) -> void
+
+    # _@param_ `payloads`
+    # 
+    # _@param_ `metadata`
+    def around_consume_batch: (::Array[untyped] payloads, ::Hash[String, Object] metadata) -> void
+
+    module ClassMethods
+      # _@param_ `kafka_client`
+      def start: (untyped kafka_client) -> void
+
+      def stop: () -> void
+    end
+  end
+
+  class BatchMessage
+    # _@param_ `key`
+    # 
+    # _@param_ `partition`
+    # 
+    # _@param_ `offset`
+    # 
+    # _@param_ `payload`
+    # 
+    # _@param_ `headers`
+    def initialize: (
+                      key: untyped,
+                      partition: Integer,
+                      offset: Integer,
+                      payload: untyped,
+                      headers: untyped
+                    ) -> void
+
+    # _@param_ `other`
+    def ==: (Phobos::BatchMessage other) -> bool
+
+    attr_accessor key: untyped
+
+    attr_accessor partition: Integer
+
+    attr_accessor offset: Integer
+
+    attr_accessor payload: untyped
+
+    attr_accessor headers: untyped
+  end
+
+  module Configuration
+    # _@param_ `configuration`
+    def configure: (untyped configuration) -> void
+
+    def configure_logger: () -> void
+  end
+
+  module Instrumentation
+    NAMESPACE: untyped
+
+    def self.subscribe: (untyped event) -> untyped
+
+    def self.unsubscribe: (untyped subscriber) -> untyped
+
+    def instrument: (untyped event, ?untyped extra) -> untyped
+  end
+
+  module Actions
+    class ProcessBatch
+      include Phobos::Instrumentation
+      include Phobos::Log
+
+      def initialize: (listener: untyped, batch: untyped, listener_metadata: untyped) -> void
+
+      def execute: () -> untyped
+
+      def log_info: (untyped msg, ?untyped metadata) -> untyped
+
+      def log_debug: (untyped msg, ?untyped metadata) -> untyped
+
+      def log_error: (untyped msg, untyped metadata) -> untyped
+
+      def log_warn: (untyped msg, ?untyped metadata) -> untyped
+
+      def instrument: (untyped event, ?untyped extra) -> untyped
+
+      # Returns the value of attribute metadata.
+      attr_reader metadata: untyped
+    end
+
+    class ProcessMessage
+      include Phobos::Processor
+
+      def initialize: (listener: untyped, message: untyped, listener_metadata: untyped) -> void
+
+      def execute: () -> untyped
+
+      def snooze: (untyped interval) -> untyped
+
+      def instrument: (untyped event, ?untyped extra) -> untyped
+
+      # Returns the value of attribute metadata.
+      attr_reader metadata: untyped
+    end
+
+    class ProcessBatchInline
+      include Phobos::Processor
+
+      def initialize: (listener: untyped, batch: untyped, metadata: untyped) -> void
+
+      def execute: () -> untyped
+
+      def snooze: (untyped interval) -> untyped
+
+      def instrument: (untyped event, ?untyped extra) -> untyped
+
+      # Returns the value of attribute metadata.
+      attr_reader metadata: untyped
+    end
+  end
+end

data/sig/kafka.rbs

@@ -0,0 +1,12 @@
+# Ruby-Kafka definitions
+
+module Kafka
+  class Client
+  end
+
+  class Producer
+  end
+
+  class AsyncProducer
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: phobos
 version: !ruby/object:Gem::Version
-  version: 2.1.4
+  version: 2.1.5
 platform: ruby
 authors:
 - Túlio Ornelas
@@ -15,7 +15,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-15 00:00:00.000000000 Z
+date: 2022-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -115,6 +115,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: sord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: timecop
   requirement: !ruby/object:Gem::Requirement
@@ -129,6 +143,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -294,6 +322,8 @@ files:
 - lib/phobos/version.rb
 - logo.png
 - phobos.gemspec
+- sig/defs.rbs
+- sig/kafka.rbs
 - utils/create-topic.sh
 homepage: https://github.com/klarna/phobos
 licenses:
@@ -315,7 +345,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.5
+rubygems_version: 3.3.21
 signing_key:
 specification_version: 4
 summary: Simplifying Kafka for ruby apps