karafka 2.0.33 → 2.0.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 511cc39ce92e82706fcd6ac9c54b3416c7908cf5e9773ee15b972219046778ca
-  data.tar.gz: 737059dc4f9de33577f4883590f607da1ee4ee330ff9f5c18bd42dfe261c567d
+  metadata.gz: 36d890d825aaeaee5349dcc653d888da3a023c01a837864544a905db977569c4
+  data.tar.gz: be442485812a05a030bab33da31a8e2fda684add8c4d59a0af78f517bb2519bd
 SHA512:
-  metadata.gz: d91e5de5bddd7b9ff2e423c986eda7f8e795528dc5ffb7a3694c82a2a096f8b3ee31679ac221bb0da4cd6efc7efa55ab195f081fbd2cf393df7d21549d950cd9
-  data.tar.gz: dbea8026eb3385b6ee14a749b3bc0187f4e91e9e66b60f2e8ac74fcdd409ad238b8e6f7dd5e5d5fbb5f0cc36299795ed63b794f1dd4a2a2b53e26776a7523876
+  metadata.gz: d92be137485c436c1ed02435669785422e6e4da194ab19b97dca31f70b530fe7e0ae4e6b0c7c54895dbceca2d8fe4ef1bdcabdb287affe06e377942062777979
+  data.tar.gz: 0525b652373088a7a692134a6a4c89487e495e01934504d256a60ae7805c92f65a308d38c8d75ad806f39f5128d2d00865e10b1b4ae326c7dd60e7594c68558e

checksums.yaml.gz.sig

@@ -1 +1 @@
-����m?{a`�M�a���u2t0�v�:#e�m�Ͳ9��nǘa6N͝����x����sB��^�E�q35*dF��1��GO�zS�9���WT�t�_f��ޓ2"0���q@�[lbd�
+Ԫ����D�����jO����dl�0m��I���t�uNv�b��2z_����viGzW:dA|��A����՛<u��i�R
�8�LW��[m�ڳ�3�y΄Py{#�
)�����j�z.�::�z`���ו�,b�ֵ�:w��H-���/���Ӷ2�B�s
��r6c

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Karafka framework changelog
 
+## 2.0.34 (2023-03-04)
+- [Improvement] Attach an `embedded` tag to Karafka processes started using the embedded API.
+- [Change] Renamed `Datadog::Listener` to `Datadog::MetricsListener` for consistency. (#1124)
+
+### Upgrade notes
+
+1. Replace `Datadog::Listener` references to `Datadog::MetricsListener`.
+
 ## 2.0.33 (2023-02-24)
 - **[Feature]** Support `perform_all_later` in ActiveJob adapter for Rails `7.1+`
 - **[Feature]** Introduce ability to assign and re-assign tags in consumer instances. This can be used for extra instrumentation that is context aware.
@@ -99,7 +107,7 @@ class KarafkaApp < Karafka::App
 - [Improvement] Expand `LoggerListener` with `client.resume` notification.
 - [Improvement] Replace random anonymous subscription groups ids with stable once.
 - [Improvement] Add `consumer.consume`, `consumer.revoke` and `consumer.shutting_down` notification events and move the revocation logic calling to strategies.
-- [Change] Rename job queue statistics `processing` key to `busy`. No changes needed because naming in the DataDog listener stays the same. 
+- [Change] Rename job queue statistics `processing` key to `busy`. No changes needed because naming in the DataDog listener stays the same.
 - [Fix] Fix proctitle listener state changes reporting on new states.
 - [Fix] Make sure all files descriptors are closed in the integration specs.
 - [Fix] Fix a case where empty subscription groups could leak into the execution flow.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    karafka (2.0.33)
+    karafka (2.0.34)
       karafka-core (>= 2.0.12, < 3.0.0)
       thor (>= 0.20)
       waterdrop (>= 2.4.10, < 3.0.0)
@@ -19,7 +19,7 @@ GEM
       minitest (>= 5.1)
       tzinfo (~> 2.0)
     byebug (11.1.3)
-    concurrent-ruby (1.2.0)
+    concurrent-ruby (1.2.2)
     diff-lcs (1.5.0)
     docile (1.4.0)
     factory_bot (6.2.1)
@@ -61,8 +61,8 @@ GEM
     thor (1.2.1)
     tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
-    waterdrop (2.4.10)
-      karafka-core (>= 2.0.9, < 3.0.0)
+    waterdrop (2.4.11)
+      karafka-core (>= 2.0.12, < 3.0.0)
       zeitwerk (~> 2.3)
     zeitwerk (2.6.7)
 

data/lib/karafka/embedded.rb

@@ -7,7 +7,10 @@ module Karafka
       # Starts Karafka without supervision and without ownership of signals in a background thread
       # so it won't interrupt other things running
       def start
-        Thread.new { Karafka::Server.start }
+        Thread.new do
+          Karafka::Process.tags.add(:execution_mode, 'embedded')
+          Karafka::Server.start
+        end
       end
 
       # Stops Karafka upon any event

data/lib/karafka/instrumentation/vendors/datadog/listener.rb

@@ -1,258 +1,15 @@
 # frozen_string_literal: true
 
+require_relative 'metrics_listener'
+
 module Karafka
   module Instrumentation
     # Namespace for vendor specific instrumentation
     module Vendors
       # Datadog specific instrumentation
       module Datadog
-        # Listener that can be used to subscribe to Karafka to receive stats via StatsD
-        # and/or Datadog
-        #
-        # @note You need to setup the `dogstatsd-ruby` client and assign it
-        class Listener
-          include ::Karafka::Core::Configurable
-          extend Forwardable
-
-          def_delegators :config, :client, :rd_kafka_metrics, :namespace, :default_tags
-
-          # Value object for storing a single rdkafka metric publishing details
-          RdKafkaMetric = Struct.new(:type, :scope, :name, :key_location)
-
-          # Namespace under which the DD metrics should be published
-          setting :namespace, default: 'karafka'
-
-          # Datadog client that we should use to publish the metrics
-          setting :client
-
-          # Default tags we want to publish (for example hostname)
-          # Format as followed (example for hostname): `["host:#{Socket.gethostname}"]`
-          setting :default_tags, default: []
-
-          # All the rdkafka metrics we want to publish
-          #
-          # By default we publish quite a lot so this can be tuned
-          # Note, that the once with `_d` come from Karafka, not rdkafka or Kafka
-          setting :rd_kafka_metrics, default: [
-            # Client metrics
-            RdKafkaMetric.new(:count, :root, 'messages.consumed', 'rxmsgs_d'),
-            RdKafkaMetric.new(:count, :root, 'messages.consumed.bytes', 'rxmsg_bytes'),
-
-            # Broker metrics
-            RdKafkaMetric.new(:count, :brokers, 'consume.attempts', 'txretries_d'),
-            RdKafkaMetric.new(:count, :brokers, 'consume.errors', 'txerrs_d'),
-            RdKafkaMetric.new(:count, :brokers, 'receive.errors', 'rxerrs_d'),
-            RdKafkaMetric.new(:count, :brokers, 'connection.connects', 'connects_d'),
-            RdKafkaMetric.new(:count, :brokers, 'connection.disconnects', 'disconnects_d'),
-            RdKafkaMetric.new(:gauge, :brokers, 'network.latency.avg', %w[rtt avg]),
-            RdKafkaMetric.new(:gauge, :brokers, 'network.latency.p95', %w[rtt p95]),
-            RdKafkaMetric.new(:gauge, :brokers, 'network.latency.p99', %w[rtt p99]),
-
-            # Topics metrics
-            RdKafkaMetric.new(:gauge, :topics, 'consumer.lags', 'consumer_lag_stored'),
-            RdKafkaMetric.new(:gauge, :topics, 'consumer.lags_delta', 'consumer_lag_stored_d')
-          ].freeze
-
-          configure
-
-          # @param block [Proc] configuration block
-          def initialize(&block)
-            configure
-            setup(&block) if block
-          end
-
-          # @param block [Proc] configuration block
-          # @note We define this alias to be consistent with `WaterDrop#setup`
-          def setup(&block)
-            configure(&block)
-          end
-
-          # Hooks up to WaterDrop instrumentation for emitted statistics
-          #
-          # @param event [Karafka::Core::Monitoring::Event]
-          def on_statistics_emitted(event)
-            statistics = event[:statistics]
-            consumer_group_id = event[:consumer_group_id]
-
-            base_tags = default_tags + ["consumer_group:#{consumer_group_id}"]
-
-            rd_kafka_metrics.each do |metric|
-              report_metric(metric, statistics, base_tags)
-            end
-          end
-
-          # Increases the errors count by 1
-          #
-          # @param event [Karafka::Core::Monitoring::Event]
-          def on_error_occurred(event)
-            extra_tags = ["type:#{event[:type]}"]
-
-            if event.payload[:caller].respond_to?(:messages)
-              extra_tags += consumer_tags(event.payload[:caller])
-            end
-
-            count('error_occurred', 1, tags: default_tags + extra_tags)
-          end
-
-          # Reports how many messages we've polled and how much time did we spend on it
-          #
-          # @param event [Karafka::Core::Monitoring::Event]
-          def on_connection_listener_fetch_loop_received(event)
-            time_taken = event[:time]
-            messages_count = event[:messages_buffer].size
-
-            consumer_group_id = event[:subscription_group].consumer_group_id
-
-            extra_tags = ["consumer_group:#{consumer_group_id}"]
-
-            histogram('listener.polling.time_taken', time_taken, tags: default_tags + extra_tags)
-            histogram('listener.polling.messages', messages_count, tags: default_tags + extra_tags)
-          end
-
-          # Here we report majority of things related to processing as we have access to the
-          # consumer
-          # @param event [Karafka::Core::Monitoring::Event]
-          def on_consumer_consumed(event)
-            consumer = event.payload[:caller]
-            messages = consumer.messages
-            metadata = messages.metadata
-
-            tags = default_tags + consumer_tags(consumer)
-
-            count('consumer.messages', messages.count, tags: tags)
-            count('consumer.batches', 1, tags: tags)
-            gauge('consumer.offset', metadata.last_offset, tags: tags)
-            histogram('consumer.consumed.time_taken', event[:time], tags: tags)
-            histogram('consumer.batch_size', messages.count, tags: tags)
-            histogram('consumer.processing_lag', metadata.processing_lag, tags: tags)
-            histogram('consumer.consumption_lag', metadata.consumption_lag, tags: tags)
-          end
-
-          # @param event [Karafka::Core::Monitoring::Event]
-          def on_consumer_revoked(event)
-            tags = default_tags + consumer_tags(event.payload[:caller])
-
-            count('consumer.revoked', 1, tags: tags)
-          end
-
-          # @param event [Karafka::Core::Monitoring::Event]
-          def on_consumer_shutdown(event)
-            tags = default_tags + consumer_tags(event.payload[:caller])
-
-            count('consumer.shutdown', 1, tags: tags)
-          end
-
-          # Worker related metrics
-          # @param event [Karafka::Core::Monitoring::Event]
-          def on_worker_process(event)
-            jq_stats = event[:jobs_queue].statistics
-
-            gauge('worker.total_threads', Karafka::App.config.concurrency, tags: default_tags)
-            histogram('worker.processing', jq_stats[:busy], tags: default_tags)
-            histogram('worker.enqueued_jobs', jq_stats[:enqueued], tags: default_tags)
-          end
-
-          # We report this metric before and after processing for higher accuracy
-          # Without this, the utilization would not be fully reflected
-          # @param event [Karafka::Core::Monitoring::Event]
-          def on_worker_processed(event)
-            jq_stats = event[:jobs_queue].statistics
-
-            histogram('worker.processing', jq_stats[:busy], tags: default_tags)
-          end
-
-          private
-
-          %i[
-            count
-            gauge
-            histogram
-            increment
-            decrement
-          ].each do |metric_type|
-            class_eval <<~METHODS, __FILE__, __LINE__ + 1
-              def #{metric_type}(key, *args)
-                client.#{metric_type}(
-                  namespaced_metric(key),
-                  *args
-                )
-              end
-            METHODS
-          end
-
-          # Wraps metric name in listener's namespace
-          # @param metric_name [String] RdKafkaMetric name
-          # @return [String]
-          def namespaced_metric(metric_name)
-            "#{namespace}.#{metric_name}"
-          end
-
-          # Reports a given metric statistics to Datadog
-          # @param metric [RdKafkaMetric] metric value object
-          # @param statistics [Hash] hash with all the statistics emitted
-          # @param base_tags [Array<String>] base tags we want to start with
-          def report_metric(metric, statistics, base_tags)
-            case metric.scope
-            when :root
-              public_send(
-                metric.type,
-                metric.name,
-                statistics.fetch(*metric.key_location),
-                tags: base_tags
-              )
-            when :brokers
-              statistics.fetch('brokers').each_value do |broker_statistics|
-                # Skip bootstrap nodes
-                # Bootstrap nodes have nodeid -1, other nodes have positive
-                # node ids
-                next if broker_statistics['nodeid'] == -1
-
-                public_send(
-                  metric.type,
-                  metric.name,
-                  broker_statistics.dig(*metric.key_location),
-                  tags: base_tags + ["broker:#{broker_statistics['nodename']}"]
-                )
-              end
-            when :topics
-              statistics.fetch('topics').each do |topic_name, topic_values|
-                topic_values['partitions'].each do |partition_name, partition_statistics|
-                  next if partition_name == '-1'
-                  # Skip until lag info is available
-                  next if partition_statistics['consumer_lag'] == -1
-
-                  public_send(
-                    metric.type,
-                    metric.name,
-                    partition_statistics.dig(*metric.key_location),
-                    tags: base_tags + [
-                      "topic:#{topic_name}",
-                      "partition:#{partition_name}"
-                    ]
-                  )
-                end
-              end
-            else
-              raise ArgumentError, metric.scope
-            end
-          end
-
-          # Builds basic per consumer tags for publication
-          #
-          # @param consumer [Karafka::BaseConsumer]
-          # @return [Array<String>]
-          def consumer_tags(consumer)
-            messages = consumer.messages
-            metadata = messages.metadata
-            consumer_group_id = consumer.topic.consumer_group.id
-
-            [
-              "topic:#{metadata.topic}",
-              "partition:#{metadata.partition}",
-              "consumer_group:#{consumer_group_id}"
-            ]
-          end
-        end
+        # Alias to keep backwards compatibility
+        Listener = MetricsListener
       end
     end
   end

data/lib/karafka/instrumentation/vendors/datadog/metrics_listener.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+module Karafka
+  module Instrumentation
+    # Namespace for vendor specific instrumentation
+    module Vendors
+      # Datadog specific instrumentation
+      module Datadog
+        # Listener that can be used to subscribe to Karafka to receive stats via StatsD
+        # and/or Datadog
+        #
+        # @note You need to setup the `dogstatsd-ruby` client and assign it
+        class MetricsListener
+          include ::Karafka::Core::Configurable
+          extend Forwardable
+
+          def_delegators :config, :client, :rd_kafka_metrics, :namespace, :default_tags
+
+          # Value object for storing a single rdkafka metric publishing details
+          RdKafkaMetric = Struct.new(:type, :scope, :name, :key_location)
+
+          # Namespace under which the DD metrics should be published
+          setting :namespace, default: 'karafka'
+
+          # Datadog client that we should use to publish the metrics
+          setting :client
+
+          # Default tags we want to publish (for example hostname)
+          # Format as followed (example for hostname): `["host:#{Socket.gethostname}"]`
+          setting :default_tags, default: []
+
+          # All the rdkafka metrics we want to publish
+          #
+          # By default we publish quite a lot so this can be tuned
+          # Note, that the once with `_d` come from Karafka, not rdkafka or Kafka
+          setting :rd_kafka_metrics, default: [
+            # Client metrics
+            RdKafkaMetric.new(:count, :root, 'messages.consumed', 'rxmsgs_d'),
+            RdKafkaMetric.new(:count, :root, 'messages.consumed.bytes', 'rxmsg_bytes'),
+
+            # Broker metrics
+            RdKafkaMetric.new(:count, :brokers, 'consume.attempts', 'txretries_d'),
+            RdKafkaMetric.new(:count, :brokers, 'consume.errors', 'txerrs_d'),
+            RdKafkaMetric.new(:count, :brokers, 'receive.errors', 'rxerrs_d'),
+            RdKafkaMetric.new(:count, :brokers, 'connection.connects', 'connects_d'),
+            RdKafkaMetric.new(:count, :brokers, 'connection.disconnects', 'disconnects_d'),
+            RdKafkaMetric.new(:gauge, :brokers, 'network.latency.avg', %w[rtt avg]),
+            RdKafkaMetric.new(:gauge, :brokers, 'network.latency.p95', %w[rtt p95]),
+            RdKafkaMetric.new(:gauge, :brokers, 'network.latency.p99', %w[rtt p99]),
+
+            # Topics metrics
+            RdKafkaMetric.new(:gauge, :topics, 'consumer.lags', 'consumer_lag_stored'),
+            RdKafkaMetric.new(:gauge, :topics, 'consumer.lags_delta', 'consumer_lag_stored_d')
+          ].freeze
+
+          configure
+
+          # @param block [Proc] configuration block
+          def initialize(&block)
+            configure
+            setup(&block) if block
+          end
+
+          # @param block [Proc] configuration block
+          # @note We define this alias to be consistent with `WaterDrop#setup`
+          def setup(&block)
+            configure(&block)
+          end
+
+          # Hooks up to WaterDrop instrumentation for emitted statistics
+          #
+          # @param event [Karafka::Core::Monitoring::Event]
+          def on_statistics_emitted(event)
+            statistics = event[:statistics]
+            consumer_group_id = event[:consumer_group_id]
+
+            base_tags = default_tags + ["consumer_group:#{consumer_group_id}"]
+
+            rd_kafka_metrics.each do |metric|
+              report_metric(metric, statistics, base_tags)
+            end
+          end
+
+          # Increases the errors count by 1
+          #
+          # @param event [Karafka::Core::Monitoring::Event]
+          def on_error_occurred(event)
+            extra_tags = ["type:#{event[:type]}"]
+
+            if event.payload[:caller].respond_to?(:messages)
+              extra_tags += consumer_tags(event.payload[:caller])
+            end
+
+            count('error_occurred', 1, tags: default_tags + extra_tags)
+          end
+
+          # Reports how many messages we've polled and how much time did we spend on it
+          #
+          # @param event [Karafka::Core::Monitoring::Event]
+          def on_connection_listener_fetch_loop_received(event)
+            time_taken = event[:time]
+            messages_count = event[:messages_buffer].size
+
+            consumer_group_id = event[:subscription_group].consumer_group_id
+
+            extra_tags = ["consumer_group:#{consumer_group_id}"]
+
+            histogram('listener.polling.time_taken', time_taken, tags: default_tags + extra_tags)
+            histogram('listener.polling.messages', messages_count, tags: default_tags + extra_tags)
+          end
+
+          # Here we report majority of things related to processing as we have access to the
+          # consumer
+          # @param event [Karafka::Core::Monitoring::Event]
+          def on_consumer_consumed(event)
+            consumer = event.payload[:caller]
+            messages = consumer.messages
+            metadata = messages.metadata
+
+            tags = default_tags + consumer_tags(consumer)
+
+            count('consumer.messages', messages.count, tags: tags)
+            count('consumer.batches', 1, tags: tags)
+            gauge('consumer.offset', metadata.last_offset, tags: tags)
+            histogram('consumer.consumed.time_taken', event[:time], tags: tags)
+            histogram('consumer.batch_size', messages.count, tags: tags)
+            histogram('consumer.processing_lag', metadata.processing_lag, tags: tags)
+            histogram('consumer.consumption_lag', metadata.consumption_lag, tags: tags)
+          end
+
+          # @param event [Karafka::Core::Monitoring::Event]
+          def on_consumer_revoked(event)
+            tags = default_tags + consumer_tags(event.payload[:caller])
+
+            count('consumer.revoked', 1, tags: tags)
+          end
+
+          # @param event [Karafka::Core::Monitoring::Event]
+          def on_consumer_shutdown(event)
+            tags = default_tags + consumer_tags(event.payload[:caller])
+
+            count('consumer.shutdown', 1, tags: tags)
+          end
+
+          # Worker related metrics
+          # @param event [Karafka::Core::Monitoring::Event]
+          def on_worker_process(event)
+            jq_stats = event[:jobs_queue].statistics
+
+            gauge('worker.total_threads', Karafka::App.config.concurrency, tags: default_tags)
+            histogram('worker.processing', jq_stats[:busy], tags: default_tags)
+            histogram('worker.enqueued_jobs', jq_stats[:enqueued], tags: default_tags)
+          end
+
+          # We report this metric before and after processing for higher accuracy
+          # Without this, the utilization would not be fully reflected
+          # @param event [Karafka::Core::Monitoring::Event]
+          def on_worker_processed(event)
+            jq_stats = event[:jobs_queue].statistics
+
+            histogram('worker.processing', jq_stats[:busy], tags: default_tags)
+          end
+
+          private
+
+          %i[
+            count
+            gauge
+            histogram
+            increment
+            decrement
+          ].each do |metric_type|
+            class_eval <<~METHODS, __FILE__, __LINE__ + 1
+              def #{metric_type}(key, *args)
+                client.#{metric_type}(
+                  namespaced_metric(key),
+                  *args
+                )
+              end
+            METHODS
+          end
+
+          # Wraps metric name in listener's namespace
+          # @param metric_name [String] RdKafkaMetric name
+          # @return [String]
+          def namespaced_metric(metric_name)
+            "#{namespace}.#{metric_name}"
+          end
+
+          # Reports a given metric statistics to Datadog
+          # @param metric [RdKafkaMetric] metric value object
+          # @param statistics [Hash] hash with all the statistics emitted
+          # @param base_tags [Array<String>] base tags we want to start with
+          def report_metric(metric, statistics, base_tags)
+            case metric.scope
+            when :root
+              public_send(
+                metric.type,
+                metric.name,
+                statistics.fetch(*metric.key_location),
+                tags: base_tags
+              )
+            when :brokers
+              statistics.fetch('brokers').each_value do |broker_statistics|
+                # Skip bootstrap nodes
+                # Bootstrap nodes have nodeid -1, other nodes have positive
+                # node ids
+                next if broker_statistics['nodeid'] == -1
+
+                public_send(
+                  metric.type,
+                  metric.name,
+                  broker_statistics.dig(*metric.key_location),
+                  tags: base_tags + ["broker:#{broker_statistics['nodename']}"]
+                )
+              end
+            when :topics
+              statistics.fetch('topics').each do |topic_name, topic_values|
+                topic_values['partitions'].each do |partition_name, partition_statistics|
+                  next if partition_name == '-1'
+                  # Skip until lag info is available
+                  next if partition_statistics['consumer_lag'] == -1
+
+                  public_send(
+                    metric.type,
+                    metric.name,
+                    partition_statistics.dig(*metric.key_location),
+                    tags: base_tags + [
+                      "topic:#{topic_name}",
+                      "partition:#{partition_name}"
+                    ]
+                  )
+                end
+              end
+            else
+              raise ArgumentError, metric.scope
+            end
+          end
+
+          # Builds basic per consumer tags for publication
+          #
+          # @param consumer [Karafka::BaseConsumer]
+          # @return [Array<String>]
+          def consumer_tags(consumer)
+            messages = consumer.messages
+            metadata = messages.metadata
+            consumer_group_id = consumer.topic.consumer_group.id
+
+            [
+              "topic:#{metadata.topic}",
+              "partition:#{metadata.partition}",
+              "consumer_group:#{consumer_group_id}"
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/version.rb

@@ -3,5 +3,5 @@
 # Main module namespace
 module Karafka
   # Current Karafka version
-  VERSION = '2.0.33'
+  VERSION = '2.0.34'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: karafka
 version: !ruby/object:Gem::Version
-  version: 2.0.33
+  version: 2.0.34
 platform: ruby
 authors:
 - Maciej Mensfeld
@@ -35,7 +35,7 @@ cert_chain:
   Qf04B9ceLUaC4fPVEz10FyobjaFoY4i32xRto3XnrzeAgfEe4swLq8bQsR3w/EF3
   MGU0FeSV2Yj7Xc2x/7BzLK8xQn5l7Yy75iPF+KP3vVmDHnNl
   -----END CERTIFICATE-----
-date: 2023-02-24 00:00:00.000000000 Z
+date: 2023-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: karafka-core
@@ -198,6 +198,7 @@ files:
 - lib/karafka/instrumentation/vendors/datadog/dashboard.json
 - lib/karafka/instrumentation/vendors/datadog/listener.rb
 - lib/karafka/instrumentation/vendors/datadog/logger_listener.rb
+- lib/karafka/instrumentation/vendors/datadog/metrics_listener.rb
 - lib/karafka/licenser.rb
 - lib/karafka/messages/batch_metadata.rb
 - lib/karafka/messages/builders/batch_metadata.rb