promenade 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa72a557cfa72b79c12ff7990482904030bafa8cc1e5f1539d657b00e8a39d42
-  data.tar.gz: 291a376f071a9e79cc00b812350ae1e6ad47f0a628481c653732c7c6357db2ea
+  metadata.gz: f7623122f1e7054e684064826e995acb44df8d056574b2c942a91d033d0a996a
+  data.tar.gz: 6da50efcc35f572b65a8bb0d85380442cdaa7529f8250efc00386ad2a0eb6267
 SHA512:
-  metadata.gz: cb99059452e3faa5253c4d04bef70331a4853a7a7f567265e52ef2639931db386a2ec67a3420b1331d6f98b841e3c865d35d183f9afa7022c87768e87820c9ed
-  data.tar.gz: 0cba0b9a5be3e357faac9ffd05bffbfe5b27a7d7cd0c2b7b7119a9c6ee43ecaad738162fb6fd6b8f669eb9e74b7c69319e48121cd4280fba1b893f14bcffd5c6
+  metadata.gz: 7bd6eb7ade6531acfbabb050c7d93986a9af727256f02afaef949146c286ea70a54ea6039eb48a18c60aa5662610111557db83ef2ab653ae3ba93436e6eb72c8
+  data.tar.gz: bf642c2d8e698be5d6d01b827472a1fbc65c7c6eb1db6ba5094e266b53339155b94454c73d1f0a3406b8fe9153728186d931c5cc16d79ff568ee377a92b60e53

data/.gitignore

@@ -6,6 +6,7 @@
 /pkg/
 /spec/reports/
 /tmp/
+.rubocop-https*yml
 
 # rspec failure tracking
 .rspec_status

data/.rubocop.yml

@@ -0,0 +1,10 @@
+inherit_from:
+  - https://raw.githubusercontent.com/cookpad/guides/master/.rubocop.yml
+
+AllCops:
+  TargetRubyVersion: 2.4
+
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: comma
+Style/TrailingCommaInArguments:
+  EnforcedStyleForMultiline: comma

data/Gemfile

@@ -1,6 +1,4 @@
 source "https://rubygems.org"
 
-git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
-
 # Specify your gem's dependencies in promenade.gemspec
 gemspec

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    promenade (0.1.0)
+    promenade (0.1.1)
       activesupport
       prometheus-client-mmap (~> 0.9.3)
 
@@ -13,14 +13,21 @@ GEM
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
+    ast (2.4.0)
     concurrent-ruby (1.0.5)
     diff-lcs (1.3)
     docile (1.3.1)
     i18n (1.0.1)
       concurrent-ruby (~> 1.0)
+    jaro_winkler (1.5.1)
     json (2.1.0)
     minitest (5.11.3)
+    parallel (1.12.1)
+    parser (2.5.1.0)
+      ast (~> 2.4.0)
+    powerpack (0.1.2)
     prometheus-client-mmap (0.9.3)
+    rainbow (3.0.0)
     rake (10.5.0)
     rspec (3.7.0)
       rspec-core (~> 3.7.0)
@@ -35,6 +42,15 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.7.0)
     rspec-support (3.7.1)
+    rubocop (0.57.2)
+      jaro_winkler (~> 1.5.1)
+      parallel (~> 1.10)
+      parser (>= 2.5)
+      powerpack (~> 0.1)
+      rainbow (>= 2.2.2, < 4.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    ruby-progressbar (1.9.0)
     simplecov (0.16.1)
       docile (~> 1.1)
       json (>= 1.8, < 3)
@@ -43,6 +59,7 @@ GEM
     thread_safe (0.3.6)
     tzinfo (1.2.5)
       thread_safe (~> 0.1)
+    unicode-display_width (1.4.0)
 
 PLATFORMS
   ruby
@@ -52,6 +69,7 @@ DEPENDENCIES
   promenade!
   rake (~> 10.0)
   rspec (~> 3.0)
+  rubocop
   simplecov
 
 BUNDLED WITH

data/README.md

@@ -1,5 +1,8 @@
 # Promenade
 
+[![Build Status](https://travis-ci.org/errm/promenade.svg?branch=master)](https://travis-ci.org/errm/promenade)
+[![Gem Version](https://badge.fury.io/rb/promenade.svg)](https://badge.fury.io/rb/promenade)
+
 Promenade is a libary to simplify instrumenting Ruby applications with prometheus.
 
 It is currently under development.

data/Rakefile

@@ -1,6 +1,8 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
+require "rubocop/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
 
-task :default => :spec
+task default: %i(spec rubocop)

data/lib/promenade/helper.rb

@@ -5,7 +5,7 @@ module Promenade
     extend ActiveSupport::Concern
 
     class_methods do
-      %i[gauge counter summary, histogram].each do |type|
+      %i(gauge counter summary histogram).each do |type|
         define_method type do |*args, &block|
           Promenade::Prometheus.define_metric(type, *args, &block)
         end

data/lib/promenade/kafka/async_producer_subscriber.rb

@@ -0,0 +1,51 @@
+require "promenade/kafka/subscriber"
+
+module Promenade
+  module Kafka
+    class AsyncProducerSubscriber < Subscriber
+      attach_to "async_producer.kafka"
+
+      gauge :kafka_async_producer_queue_size do
+        doc "Size of Kafka async producer queue"
+      end
+
+      gauge :kafka_async_producer_max_queue_size do
+        doc "Max size of Kafka async producer queue"
+      end
+
+      gauge :kafka_async_producer_queue_fill_ratio do
+        doc "Size of Kafka async producer queue"
+      end
+
+      counter :kafka_async_producer_buffer_overflows do
+        doc "Count of buffer overflows"
+      end
+
+      counter :kafka_async_producer_dropped_messages do
+        doc "Count of dropped messages"
+      end
+
+      def enqueue_message(event)
+        labels = get_labels(event)
+        queue_size = event.payload.fetch(:queue_size)
+        max_queue_size = event.payload.fetch(:max_queue_size)
+        queue_fill_ratio = queue_size.to_f / max_queue_size.to_f
+
+        metric(:kafka_async_producer_queue_size).set(labels, queue_size)
+        metric(:kafka_async_producer_max_queue_size).set(labels, max_queue_size)
+        metric(:kafka_async_producer_queue_fill_ratio).set(labels, queue_fill_ratio)
+      end
+
+      def buffer_overflow(event)
+        metric(:kafka_async_producer_buffer_overflows).increment(get_labels(event))
+      end
+
+      def drop_messages(event)
+        client = event.payload.fetch(:client_id)
+        message_count = event.payload.fetch(:message_count)
+
+        metric(:kafka_async_producer_dropped_messages).increment({ client: client }, message_count)
+      end
+    end
+  end
+end

data/lib/promenade/kafka/connection_subscriber.rb

@@ -0,0 +1,47 @@
+require "promenade/kafka/subscriber"
+
+module Promenade
+  module Kafka
+    class ConnectionSubscriber < Subscriber
+      attach_to "connection.kafka"
+
+      histogram :kafka_connection_latency do
+        doc "Request latency"
+        buckets :network
+      end
+
+      counter :kafka_connection_calls do
+        doc "Count of calls made to Kafka broker"
+      end
+
+      summary :kafka_connection_request_size do
+        doc "Average size of requests made to kafka"
+      end
+
+      summary :kafka_connection_response_size do
+        doc "Average size of responses made by kafka"
+      end
+
+      histogram :kafka_connection_errors do
+        doc "Count of Kafka connection errors"
+        buckets :memory
+      end
+
+      def request(event) # rubocop:disable Metrics/AbcSize
+        labels = {
+          client: event.payload.fetch(:client_id),
+          api: event.payload.fetch(:api, "unknown"),
+          broker: event.payload.fetch(:broker_host),
+        }
+
+        metric(:kafka_connection_calls).increment(labels)
+        metric(:kafka_connection_latency).observe(labels, event.duration)
+
+        metric(:kafka_connection_request_size).observe(labels, event.payload.fetch(:request_size, 0))
+        metric(:kafka_connection_response_size).observe(labels, event.payload.fetch(:response_size, 0))
+
+        metric(:kafka_connection_errors).increment if event.payload.key?(:exception)
+      end
+    end
+  end
+end

data/lib/promenade/kafka/consumer_subscriber.rb

@@ -0,0 +1,145 @@
+require "promenade/kafka/subscriber"
+
+module Promenade
+  module Kafka
+    class ConsumerSubscriber < Subscriber
+      attach_to "consumer.kafka"
+
+      gauge :kafka_consumer_time_lag do
+        doc "Lag between message create and consume time"
+      end
+
+      gauge :kafka_consumer_ofset_lag do
+        doc "Lag between message create and consume time"
+      end
+
+      histogram :kafka_consumer_message_processing_latency do
+        doc "Consumer message processing latency"
+        buckets :network
+      end
+
+      counter :kafka_consumer_messages_processed do
+        doc "Messages processed by this consumer"
+      end
+
+      counter :kafka_consumer_message_processing_errors do
+        doc "Consumer errors while processing a message"
+      end
+
+      histogram :kafka_consumer_batch_processing_latency do
+        doc "Consumer batch processing latency"
+        buckets :network
+      end
+
+      counter :kafka_consumer_batch_processing_errors do
+        doc "Consumer errors while processing a batch"
+      end
+
+      histogram :kafka_consumer_join_group do
+        doc "Time taken to join"
+        buckets :network
+      end
+
+      counter :kafka_consumer_join_group_errors do
+        doc "Errors joining the group"
+      end
+
+      histogram :kafka_consumer_sync_group do
+        doc "Time taken to sync"
+        buckets :network
+      end
+
+      counter :kafka_consumer_sync_group_errors do
+        doc "Errors syncing the group"
+      end
+
+      histogram :kafka_consumer_leave_group do
+        doc "Time taken to leave group"
+        buckets :network
+      end
+
+      counter :kafka_consumer_leave_group_errors do
+        doc "Errors leaving the group"
+      end
+
+      histogram :kafka_consumer_pause_duration do
+        doc "Time taken to leave group"
+        buckets :network
+      end
+
+      def process_message(event) # rubocop:disable Metrics/AbcSize
+        labels = get_labels(event)
+        offset_lag = event.payload.fetch(:offset_lag)
+        create_time = event.payload.fetch(:create_time)
+        time_lag = create_time && ((Time.now.utc - create_time) * 1000).to_i
+
+        if event.payload.key?(:exception)
+          metric(:kafka_consumer_message_processing_errors).increment(labels)
+        else
+          metric(:kafka_consumer_messages_processed).increment(labels)
+          metric(:kafka_consumer_message_processing_latency).observe(labels, event.duration)
+        end
+
+        metric(:kafka_consumer_ofset_lag).set(labels, offset_lag)
+
+        # Not all messages have timestamps.
+        metric(:kafka_consumer_time_lag).set(labels, time_lag) if time_lag
+      end
+
+      def process_batch(event) # rubocop:disable Metrics/AbcSize
+        labels = get_labels(event)
+        lag = event.payload.fetch(:offset_lag)
+        messages = event.payload.fetch(:message_count)
+
+        if event.payload.key?(:exception)
+          metric(:kafka_consumer_batch_processing_errors).increment(labels)
+        else
+          metric(:kafka_consumer_messages_processed).increment(labels, messages)
+          metric(:kafka_consumer_batch_processing_latency).observe(labels, event.duration)
+        end
+
+        metric(:kafka_consumer_ofset_lag).set(labels, lag)
+      end
+
+      def join_group(event)
+        labels = group_labels(event)
+        metric(:kafka_consumer_join_group).observe(labels, event.duration)
+        metric(:kafka_consumer_join_group_errors).increment(labels) if event.payload.key?(:exception)
+      end
+
+      def sync_group(event)
+        labels = group_labels(event)
+        metric(:kafka_consumer_sync_group).observe(labels, event.duration)
+        metric(:kafka_consumer_sync_group_errors).increment(labels) if event.payload.key?(:exception)
+      end
+
+      def leave_group(event)
+        labels = group_labels(event)
+        metric(:kafka_consumer_leave_group).observe(labels, event.duration)
+        metric(:kafka_consumer_leave_group_errors).increment(labels) if event.payload.key?(:exception)
+      end
+
+      def pause_status(event)
+        metric(:kafka_consumer_pause_duration).observe(get_labels(event), event.payload.fetch(:duration))
+      end
+
+      private
+
+        def get_labels(event)
+          {
+            client: event.payload.fetch(:client_id),
+            group: event.payload.fetch(:group_id),
+            topic: event.payload.fetch(:topic),
+            partition: event.payload.fetch(:partition),
+          }
+        end
+
+        def group_labels(event)
+          {
+            client: event.payload.fetch(:client_id),
+            group: event.payload.fetch(:group_id),
+          }
+        end
+    end
+  end
+end

data/lib/promenade/kafka/fetcher_subscriber.rb

@@ -0,0 +1,21 @@
+require "promenade/kafka/subscriber"
+
+module Promenade
+  module Kafka
+    class FetcherSubscriber < Subscriber
+      attach_to "fetcher.kafka"
+
+      gauge :kafka_fetcher_queue_size do
+        doc "Fetcher queue size"
+      end
+
+      def loop(event)
+        queue_size = event.payload.fetch(:queue_size)
+        client = event.payload.fetch(:client_id)
+        group_id = event.payload.fetch(:group_id)
+
+        metric(:kafka_fetcher_queue_size).set({ client: client, group: group_id }, queue_size)
+      end
+    end
+  end
+end

data/lib/promenade/kafka/producer_subscriber.rb

@@ -0,0 +1,117 @@
+require "promenade/kafka/subscriber"
+
+module Promenade
+  module Kafka
+    class ProducerSubscriber < Subscriber
+      attach_to "producer.kafka"
+
+      counter :kafka_producer_messages do
+        doc "Number of messages written to Kafka producer"
+      end
+
+      histogram :kafka_producer_message_size do
+        doc "Historgram of message sizes written to Kafka producer"
+        buckets :memory
+      end
+
+      gauge :kafka_producer_buffer_size do
+        doc "The current size of the Kafka producer buffer, in messages"
+      end
+
+      gauge :kafka_producer_max_buffer_size do
+        doc "The max size of the Kafka producer buffer"
+      end
+
+      gauge :kafka_producer_buffer_fill_ratio do
+        doc "The current ratio of Kafka producer buffer in use"
+      end
+
+      counter :kafka_producer_buffer_overflows do
+        doc "A count of kafka producer buffer overflow errors"
+      end
+
+      counter :kafka_producer_delivery_errors do
+        doc "A count of kafka producer delivery errors"
+      end
+
+      histogram :kafka_producer_delivery_latency do
+        doc "Kafka producer delivery latency histogram"
+        buckets :network
+      end
+
+      counter :kafka_producer_delivered_messages do
+        doc "A count of the total messages delivered to Kafka"
+      end
+
+      histogram :kafka_producer_delivery_attempts do
+        doc "A count of the total message deliveries attempted"
+        buckets [0, 6, 12, 18, 24, 30]
+      end
+
+      counter :kafka_producer_ack_messages do
+        doc "Count of the number of messages Acked by Kafka"
+      end
+
+      histogram :kafka_producer_ack_latency do
+        doc "Delay between message being produced and Acked"
+        buckets :network
+      end
+
+      counter :kafka_producer_ack_errors do
+        doc "Count of the number of Kafka Ack errors"
+      end
+
+      def produce_message(event) # rubocop:disable Metrics/AbcSize
+        labels = get_labels(event)
+        message_size = event.payload.fetch(:message_size)
+        buffer_size = event.payload.fetch(:buffer_size)
+        max_buffer_size = event.payload.fetch(:max_buffer_size)
+        buffer_fill_ratio = buffer_size.to_f / max_buffer_size.to_f
+
+        metric(:kafka_producer_messages).increment(labels)
+        metric(:kafka_producer_message_size).observe(labels, message_size)
+        metric(:kafka_producer_buffer_size).set(labels.slice(:client), buffer_size)
+        metric(:kafka_producer_max_buffer_size).set(labels.slice(:client), max_buffer_size)
+        metric(:kafka_producer_buffer_fill_ratio).set(labels.slice(:client), buffer_fill_ratio)
+      end
+
+      def buffer_overflow(event)
+        metric(:kafka_producer_buffer_overflows).increment(get_labels(event))
+      end
+
+      def deliver_messages(event) # rubocop:disable Metrics/AbcSize
+        labels = { client: event.payload.fetch(:client_id) }
+        message_count = event.payload.fetch(:delivered_message_count)
+        attempts = event.payload.fetch(:attempts)
+
+        metric(:kafka_producer_delivery_errors).increment(labels) if event.payload.key?(:exception)
+        metric(:kafka_producer_delivery_latency).observe(labels, event.duration)
+        metric(:kafka_producer_delivered_messages).increment(labels, message_count)
+        metric(:kafka_producer_delivery_attempts).observe(labels, attempts)
+      end
+
+      def ack_message(event)
+        labels = get_labels(event)
+        delay = event.payload.fetch(:delay)
+
+        metric(:kafka_producer_ack_messages).increment(labels)
+        metric(:kafka_producer_ack_latency).observe(labels, delay)
+      end
+
+      def topic_error(event)
+        client = event.payload.fetch(:client_id)
+        topic = event.payload.fetch(:topic)
+
+        metric(:kafka_producer_ack_errors).increment(client: client, topic: topic)
+      end
+
+      private
+
+        def get_labels(event)
+          client = event.payload.fetch(:client_id)
+          topic = event.payload.fetch(:topic)
+          { client: client, topic: topic }
+        end
+    end
+  end
+end

data/lib/promenade/kafka/subscriber.rb

@@ -0,0 +1,18 @@
+require "promenade/helper"
+require "active_support/subscriber"
+
+module Promenade
+  module Kafka
+    class Subscriber < ActiveSupport::Subscriber
+      include ::Promenade::Helper
+
+      private
+
+        def get_labels(event)
+          client = event.payload.fetch(:client_id)
+          topic = event.payload.fetch(:topic)
+          { client: client, topic: topic }
+        end
+    end
+  end
+end

data/lib/promenade/kafka.rb

@@ -0,0 +1,5 @@
+require "promenade/kafka/async_producer_subscriber"
+require "promenade/kafka/connection_subscriber"
+require "promenade/kafka/consumer_subscriber"
+require "promenade/kafka/fetcher_subscriber"
+require "promenade/kafka/producer_subscriber"

data/lib/promenade/prometheus.rb

@@ -25,68 +25,62 @@ module Promenade
     end
 
     def self.registry
-      @_registry ||= begin
-                       REGISTRY_MUTEX.synchronize do
-                         ::Prometheus::Client.registry
-                       end
-                     end
-    end
-
-    def self.reset!
-      @_registry = nil
-      ::Prometheus::Client.reset!
+      REGISTRY_MUTEX.synchronize do
+        @_registry ||= ::Prometheus::Client.registry
+      end
     end
-  end
 
-  class Options
-    BUCKET_PRESETS = {
-      network: [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10].freeze,
-    }.freeze
+    class Options
+      BUCKET_PRESETS = {
+        network: [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10].freeze,
+        memory: (0..10).map { |i| 128 * 2**i },
+      }.freeze
 
-    def initialize
-      @buckets = BUCKET_PRESETS[:network]
-      @base_labels = {}
-      @doc = nil
-      @multiprocess_mode = :all
-    end
+      def initialize
+        @buckets = BUCKET_PRESETS[:network]
+        @base_labels = {}
+        @doc = nil
+        @multiprocess_mode = :all
+      end
 
-    def doc(str)
-      @doc = str
-    end
+      def doc(str)
+        @doc = str
+      end
 
-    def base_labels(labels)
-      @base_labels = labels
-    end
+      def base_labels(labels)
+        @base_labels = labels
+      end
 
-    def multiprocess_mode(mode)
-      @multiprocess_mode = mode
-    end
+      def multiprocess_mode(mode)
+        @multiprocess_mode = mode
+      end
 
-    def buckets(buckets)
-      if buckets.is_a?(Symbol)
-        @buckets = BUCKET_PRESETS[buckets]
-        fail "#{buckets} is not a valid bucket preset" if @buckets.nil?
-      else
-        @buckets = buckets
+      def buckets(buckets)
+        if buckets.is_a?(Symbol)
+          @buckets = BUCKET_PRESETS[buckets]
+          fail "#{buckets} is not a valid bucket preset" if @buckets.nil?
+        else
+          @buckets = buckets
+        end
       end
-    end
 
-    def args(type)
-      case type
-      when :gauge
-        [@doc, @base_labels, @multiprocess_mode]
-      when :histogram
-        [@doc, @base_labels, @buckets]
-      when :counter, :summary
-        [@doc, @base_labels]
-      else
-        fail "Unsupported metric type: #{type}"
+      def args(type)
+        case type
+        when :gauge
+          [@doc, @base_labels, @multiprocess_mode]
+        when :histogram
+          [@doc, @base_labels, @buckets]
+        when :counter, :summary
+          [@doc, @base_labels]
+        else
+          fail "Unsupported metric type: #{type}"
+        end
       end
-    end
 
-    def evaluate(&block)
-      instance_eval(&block) if block_given?
-      self
+      def evaluate(&block)
+        instance_eval(&block) if block_given?
+        self
+      end
     end
   end
 end

data/lib/promenade/version.rb

@@ -1,3 +1,3 @@
 module Promenade
-  VERSION = "0.1.0"
+  VERSION = "0.1.1".freeze
 end

data/promenade.gemspec

@@ -1,5 +1,4 @@
-
-lib = File.expand_path("../lib", __FILE__)
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "promenade/version"
 
@@ -9,22 +8,24 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Ed Robinson"]
   spec.email         = ["edward-robinson@cookpad.com"]
 
-  spec.summary       = %q{Promenade makes it simple to instrument Ruby apps for prometheus scraping}
+  spec.summary       = "Promenade makes it simple to instrument Ruby apps for prometheus scraping"
   spec.homepage      = "https://github.com/errm/promenade"
   spec.license       = "MIT"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+  spec.files         = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
 
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "activesupport"
+  spec.add_dependency "prometheus-client-mmap", "~> 0.9.3"
+
   spec.add_development_dependency "bundler", "~> 1.16"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rubocop"
   spec.add_development_dependency "simplecov"
-  spec.add_dependency "activesupport"
-  spec.add_dependency "prometheus-client-mmap", "~> 0.9.3"
 end

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: promenade
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Ed Robinson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-02 00:00:00.000000000 Z
+date: 2018-07-05 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: prometheus-client-mmap
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.3
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -53,7 +81,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: simplecov
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -67,33 +95,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: prometheus-client-mmap
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.9.3
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.9.3
 description: 
 email:
 - edward-robinson@cookpad.com
@@ -103,6 +117,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -115,6 +130,13 @@ files:
 - bin/setup
 - lib/promenade.rb
 - lib/promenade/helper.rb
+- lib/promenade/kafka.rb
+- lib/promenade/kafka/async_producer_subscriber.rb
+- lib/promenade/kafka/connection_subscriber.rb
+- lib/promenade/kafka/consumer_subscriber.rb
+- lib/promenade/kafka/fetcher_subscriber.rb
+- lib/promenade/kafka/producer_subscriber.rb
+- lib/promenade/kafka/subscriber.rb
 - lib/promenade/prometheus.rb
 - lib/promenade/version.rb
 - promenade.gemspec