promenade 0.1.10 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d222c254996b462ac7314436b4cc4c59806a3beedb90d77e761f0f771604fc0
-  data.tar.gz: 23177e7fe90c5b80c8425a1cd86bc2b85ac4a40756957a4a2788ccc97cfeecb3
+  metadata.gz: 336c06ecdc7505702a9adfbb8b826b3ea3bcfe386f1f8e907bc5532dfeff1d62
+  data.tar.gz: 3af09e7c9f83d39b638086d7d1e285bded62e92086412fdc575f47dac9554794
 SHA512:
-  metadata.gz: 6588b702827ced64b962fd8ecd88febcf6daa74a9cf11c73ad9cbb939595899bc28d516bb3e5584d7b8f1681fc762e148b3d62f15bd8c3618b12b32e01dd7a39
-  data.tar.gz: 839d7696d71185bb2ee883fff46aab962e7e0e4458fd13705091838a93c3e98fdf42df9783436729fd5354165f73045e039e7f81ad447c3241ceea96b664fbcd
+  metadata.gz: 23e3dbdbfebc0661786c8643fc8e1b85965268a8b7287ec385d9114275c7aff6548e457d539fa9efc87d19d146a654c5f5f3db045eaf78146be177ba62814a8a
+  data.tar.gz: 63e70c2788ff665529e4bc9dcd610a48962f7a9f7722c6558d224bd028850b8ff672e10a17081c8459c73371a98fea8ff43dc2b58f2660c1427076869775a45d

data/.travis.yml

@@ -1,5 +1,6 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.5.1
-before_install: gem install bundler -v 1.16.2
+  - 2.5.5
+  - 2.6.3
+before_install: gem install bundler -v 2.0.2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    promenade (0.1.10)
+    promenade (0.2.0)
       activesupport
       prometheus-client-mmap (~> 0.9.3)
       rack
@@ -9,13 +9,14 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (5.2.2)
+    activesupport (6.0.0)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
+      zeitwerk (~> 2.1, >= 2.1.8)
     ast (2.4.0)
-    backports (3.11.4)
+    backports (3.15.0)
     binding_of_caller (0.8.0)
       debug_inspector (>= 0.0.1)
     climate_control (0.2.0)
@@ -24,87 +25,90 @@ GEM
       simplecov
       url
     coderay (1.1.2)
-    concurrent-ruby (1.1.3)
+    concurrent-ruby (1.1.5)
     debug_inspector (0.0.3)
-    deep-cover (0.7.0)
-      bundler
-      deep-cover-core (= 0.7.0)
+    deep-cover (0.7.5)
+      deep-cover-core (= 0.7.5)
       highline
       thor (>= 0.20.3)
       with_progress
-    deep-cover-core (0.7.0)
+    deep-cover-core (0.7.5)
       backports (>= 3.11.0)
       binding_of_caller
-      parser (~> 2.5.0)
+      parser (>= 2.5, < 2.7)
       pry
       term-ansicolor
       terminal-table
     diff-lcs (1.3)
-    docile (1.3.1)
-    highline (2.0.0)
-    i18n (1.1.1)
+    docile (1.3.2)
+    highline (2.0.2)
+    i18n (1.6.0)
       concurrent-ruby (~> 1.0)
-    jaro_winkler (1.5.1)
-    json (2.1.0)
+    jaro_winkler (1.5.3)
+    json (2.2.0)
     method_source (0.9.2)
     minitest (5.11.3)
-    parallel (1.12.1)
-    parser (2.5.3.0)
+    parallel (1.17.0)
+    parser (2.6.3.0)
       ast (~> 2.4.0)
-    powerpack (0.1.2)
-    prometheus-client-mmap (0.9.5)
+    prometheus-client-mmap (0.9.9)
     pry (0.12.2)
       coderay (~> 1.1.0)
       method_source (~> 0.9.0)
-    rack (2.0.6)
+    rack (2.0.7)
     rainbow (3.0.0)
     rake (10.5.0)
     rspec (3.8.0)
       rspec-core (~> 3.8.0)
       rspec-expectations (~> 3.8.0)
       rspec-mocks (~> 3.8.0)
-    rspec-core (3.8.0)
+    rspec-core (3.8.2)
       rspec-support (~> 3.8.0)
-    rspec-expectations (3.8.2)
+    rspec-expectations (3.8.4)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.8.0)
-    rspec-mocks (3.8.0)
+    rspec-mocks (3.8.1)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.8.0)
-    rspec-support (3.8.0)
-    rubocop (0.61.1)
+    rspec-support (3.8.2)
+    rubocop (0.74.0)
       jaro_winkler (~> 1.5.1)
       parallel (~> 1.10)
-      parser (>= 2.5, != 2.5.1.1)
-      powerpack (~> 0.1)
+      parser (>= 2.6)
       rainbow (>= 2.2.2, < 4.0)
       ruby-progressbar (~> 1.7)
-      unicode-display_width (~> 1.4.0)
-    ruby-progressbar (1.10.0)
-    simplecov (0.16.1)
+      unicode-display_width (>= 1.4.0, < 1.7)
+    rubocop-performance (1.4.1)
+      rubocop (>= 0.71.0)
+    rubocop-rails (2.3.0)
+      rack (>= 1.1)
+      rubocop (>= 0.72.0)
+    ruby-progressbar (1.10.1)
+    simplecov (0.17.0)
       docile (~> 1.1)
       json (>= 1.8, < 3)
       simplecov-html (~> 0.10.0)
     simplecov-html (0.10.2)
-    term-ansicolor (1.7.0)
+    term-ansicolor (1.7.1)
       tins (~> 1.0)
     terminal-table (1.8.0)
       unicode-display_width (~> 1.1, >= 1.1.1)
     thor (0.20.3)
     thread_safe (0.3.6)
-    tins (1.20.2)
+    tins (1.21.1)
     tzinfo (1.2.5)
       thread_safe (~> 0.1)
-    unicode-display_width (1.4.0)
+    unicode-display_width (1.6.0)
     url (0.3.2)
     with_progress (1.0.1)
       ruby-progressbar (~> 1.4)
+    zeitwerk (2.1.10)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.16)
+  bundler (~> 2.0)
   climate_control
   codecov
   deep-cover
@@ -112,7 +116,9 @@ DEPENDENCIES
   rake (~> 10.0)
   rspec (~> 3.0)
   rubocop
+  rubocop-performance
+  rubocop-rails
   simplecov
 
 BUNDLED WITH
-   1.16.6
+   2.0.2

data/README.md

@@ -4,13 +4,13 @@
 [![Gem Version](https://badge.fury.io/rb/promenade.svg)](https://badge.fury.io/rb/promenade)
 [![codecov](https://codecov.io/gh/errm/promenade/branch/master/graph/badge.svg)](https://codecov.io/gh/errm/promenade)
 
-Promenade is a libary to simplify instrumenting Ruby applications with prometheus.
+Promenade is a library to simplify instrumenting Ruby applications with Prometheus.
 
 It is currently under development.
 
 ## Usage
 
-Add promenade to your Gemfile:
+Add promenade to your Gemfle:
 
 ```
 gem "promenade"
@@ -20,7 +20,7 @@ gem "promenade"
 
 Promenade includes some built in instrumentation that can be used by requiring it (for example in an initializer).
 
-Currently there is just support for [ruby-kafka](https://github.com/zendesk/ruby-kafka), but I plan to support other things soon.
+Currently there is support for [ruby-kafka](https://github.com/zendesk/ruby-kafka), but I plan to support other things soon.
 
 ```
 # Instrument the ruby-kafka libary
@@ -29,35 +29,31 @@ require "promenade/kafka"
 
 ### Instrumentation DSL
 
-Promenade makes recording prometheus metrics from your own code a little simpler with a DSL of sorts.
+Promenade makes recording Prometheus metrics from your own code a little simpler with a DSL of sorts.
 
-`Promenade::Helper` includes some class macros for defining your own metrics, and a metric method you can use to record metrics.
+`Promenade` includes some methods for defining your own metrics, and a metric method you can use to record your metrics.
 
 #### Counter
 
 A counter is a metric that exposes a sum or tally of things.
 
 ```ruby
-require "promenade/helper"
-
 class WidgetService
-  include ::Promenade::Helper
-
-  counter :widgets_created do
+  Promenade.counter :widgets_created do
     doc "Records how many widgets are created"
   end
 
   def create
     # Widget creation code :)
-    metric(:widgets_created).increment
+    Promenade.metric(:widgets_created).increment
 
     # You can also add extra labels as you set increment counters
-    metric(:widgets_created).increment({ type: "guinness" })
+    Promenade.metric(:widgets_created).increment({ type: "guinness" })
   end
 
   def batch_create
     You can increment by more than 1 at a time if you need
-    metric(:widgets_created).increment({ type: "guinness" }, 100)
+    Promenade.metric(:widgets_created).increment({ type: "guinness" }, 100)
   end
 end
 ```
@@ -67,19 +63,15 @@ end
 A gauge is a metric that exposes an instantaneous value or some snapshot of a changing value.
 
 ```ruby
-require "promenade/helper"
-
 class Thermometer
-  include ::Promenade::Helper
-
-  gauge :room_temperature_celsius do
+  Promenade.gauge :room_temperature_celsius do
     doc "Records room temprature"
   end
 
   def take_mesurements
-    metric(:room_temperature_celsius).set({ room: "lounge" }, 22.3)
-    metric(:room_temperature_celsius).set({ room: "kitchen" }, 25.45)
-    metric(:room_temperature_celsius).set({ room: "broom_cupboard" }, 15.37)
+    Promenade.metric(:room_temperature_celsius).set({ room: "lounge" }, 22.3)
+    Promenade.metric(:room_temperature_celsius).set({ room: "kitchen" }, 25.45)
+    Promenade.metric(:room_temperature_celsius).set({ room: "broom_cupboard" }, 15.37)
   end
 end
 ```
@@ -91,12 +83,8 @@ response sizes) and counts them in configurable buckets. It also provides a sum
 of all observed values.
 
 ```ruby
-require "promenade/helper"
-
 class Calculator
-  include ::Promenade::Helper
-
-  histogram :calculator_time_taken do
+  Promenade.histogram :calculator_time_taken do
     doc "Records how long it takes to do the adding"
     # promenade also has some bucket presets like :network and :memory for common usecases
     buckets [0.25, 0.5, 1, 2, 4]
@@ -107,7 +95,7 @@ class Calculator
       # Some time consuming addition
     end
 
-    metric(:calculator_time_taken).observe({ operation: "addition"}, timing)
+    Promenade.metric(:calculator_time_taken).observe({ operation: "addition"}, timing)
   end
 end
 ```
@@ -117,12 +105,8 @@ end
 Summary is similar to a histogram, but for when you just care about percentile values. Often useful for timings.
 
 ```ruby
-require "promenade/helper"
-
 class ApiClient
-  include ::Promenade::Helper
-
-  summary :api_client_http_timing do
+  Promenade.summary :api_client_http_timing do
     doc "record how long requests to the api are taking"
   end
 
@@ -131,7 +115,7 @@ class ApiClient
       # Makes a network call
     end
 
-    metric(:api_client_http_timing).observe({ method: "get", path: "/api/v1/users" }, timing)
+    Promenade.metric(:api_client_http_timing).observe({ method: "get", path: "/api/v1/users" }, timing)
   end
 end
 ```
@@ -142,9 +126,9 @@ Because promenade is based on prometheus-client you can add the `Prometheus::Cli
 
 There is also a stand alone exporter that can be run with the `promenade` command.
 
-This is ideal if you are worried about acidently exposing your metrics, are concerned about the performance impact prometheus scrapes might have on your application, or for applications without a webserver (like background processing jobs). It does mean that you have another process to manage on your server though 🤷.
+This is ideal if you are worried about accidentally exposing your metrics, are concerned about the performance impact prometheus scrapes might have on your application, or for applications without a web server (like background processing jobs). It does mean that you have another process to manage on your server though 🤷.
 
-The exporter runs by default on port `9394` and the metrics are avaible at the standard path of `/metrics`, the standalone exporter is congfigured to use gzip.
+The exporter runs by default on port `9394` and the metrics are available at the standard path of `/metrics`, the stand-alone exporter is configured to use gzip.
 
 ### Configuration
 
@@ -156,7 +140,7 @@ In a typical development environment there should be nothing for you to do. Prom
 
 In a production environment you should try to store the state files on tmpfs for performance, you can configure the path that promenade will write to by setting the `PROMETHEUS_MULTIPROC_DIR` environment variable.
 
-If you are running the standalone exporter, you may also set the `PORT` environment variable to bind to a port other than the default (`9394`).
+If you are running the stand-alone exporter, you may also set the `PORT` environment variable to bind to a port other than the default (`9394`).
 
 ## Development
 

data/Rakefile

@@ -12,3 +12,5 @@ task :clean do
 end
 
 task spec: :clean
+
+task release: :spec

data/exe/promenade

@@ -9,7 +9,12 @@ Promenade.setup
 app = Rack::Builder.app do
   use Rack::Deflater
   use ::Prometheus::Client::Rack::Exporter
+  map "/health" do
+    run lambda { |_env| [200, { "Content-Type" => "text/plain" }, ["OK"]] }
+  end
   run ->(_env) { [404, {}, ["visit /metrics for metrics"]] }
 end
 
-Rack::Handler::WEBrick.run app, Port: ENV.fetch("PORT", "9394")
+Signal.trap("TERM") { Rack::Handler::WEBrick.shutdown }
+
+Rack::Handler::WEBrick.run app, Port: ENV.fetch("PORT", "9394"), Host: "0.0.0.0"

data/lib/promenade.rb

@@ -1,3 +1,18 @@
 require "promenade/version"
 require "promenade/setup"
 require "promenade/railtie" if defined? ::Rails::Railtie
+require "promenade/prometheus"
+
+module Promenade
+  class << self
+    %i(gauge counter summary histogram).each do |type|
+      define_method type do |*args, &block|
+        Promenade::Prometheus.define_metric(type, *args, &block)
+      end
+    end
+
+    def metric(name)
+      Promenade::Prometheus.metric(name)
+    end
+  end
+end

data/lib/promenade/kafka/async_producer_subscriber.rb

@@ -5,23 +5,23 @@ module Promenade
     class AsyncProducerSubscriber < Subscriber
       attach_to "async_producer.kafka"
 
-      gauge :kafka_async_producer_queue_size do
+      Promenade.gauge :kafka_async_producer_queue_size do
         doc "Size of Kafka async producer queue"
       end
 
-      gauge :kafka_async_producer_max_queue_size do
+      Promenade.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
+      Promenade.gauge :kafka_async_producer_queue_fill_ratio do
         doc "Size of Kafka async producer queue"
       end
 
-      counter :kafka_async_producer_buffer_overflows do
+      Promenade.counter :kafka_async_producer_buffer_overflows do
         doc "Count of buffer overflows"
       end
 
-      counter :kafka_async_producer_dropped_messages do
+      Promenade.counter :kafka_async_producer_dropped_messages do
         doc "Count of dropped messages"
       end
 
@@ -29,22 +29,22 @@ module Promenade
         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
+        queue_fill_ratio = queue_size.to_f / max_queue_size
 
-        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)
+        Promenade.metric(:kafka_async_producer_queue_size).set(labels, queue_size)
+        Promenade.metric(:kafka_async_producer_max_queue_size).set(labels, max_queue_size)
+        Promenade.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))
+        Promenade.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)
+        Promenade.metric(:kafka_async_producer_dropped_messages).increment({ client: client }, message_count)
       end
     end
   end

data/lib/promenade/kafka/connection_subscriber.rb

@@ -5,24 +5,24 @@ module Promenade
     class ConnectionSubscriber < Subscriber
       attach_to "connection.kafka"
 
-      histogram :kafka_connection_latency do
+      Promenade.histogram :kafka_connection_latency do
         doc "Request latency"
         buckets :network
       end
 
-      counter :kafka_connection_calls do
+      Promenade.counter :kafka_connection_calls do
         doc "Count of calls made to Kafka broker"
       end
 
-      summary :kafka_connection_request_size do
+      Promenade.summary :kafka_connection_request_size do
         doc "Average size of requests made to kafka"
       end
 
-      summary :kafka_connection_response_size do
+      Promenade.summary :kafka_connection_response_size do
         doc "Average size of responses made by kafka"
       end
 
-      counter :kafka_connection_errors do
+      Promenade.counter :kafka_connection_errors do
         doc "Count of Kafka connection errors"
       end
 
@@ -33,13 +33,13 @@ module Promenade
           broker: event.payload.fetch(:broker_host),
         }
 
-        metric(:kafka_connection_calls).increment(labels)
-        metric(:kafka_connection_latency).observe(labels, event.duration)
+        Promenade.metric(:kafka_connection_calls).increment(labels)
+        Promenade.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))
+        Promenade.metric(:kafka_connection_request_size).observe(labels, event.payload.fetch(:request_size, 0))
+        Promenade.metric(:kafka_connection_response_size).observe(labels, event.payload.fetch(:response_size, 0))
 
-        metric(:kafka_connection_errors).increment if event.payload.key?(:exception)
+        Promenade.metric(:kafka_connection_errors).increment(labels) if event.payload.key?(:exception)
       end
     end
   end

data/lib/promenade/kafka/consumer_subscriber.rb

@@ -5,64 +5,68 @@ module Promenade
     class ConsumerSubscriber < Subscriber
       attach_to "consumer.kafka"
 
-      gauge :kafka_consumer_time_lag do
+      Promenade.gauge :kafka_consumer_time_lag do
         doc "Lag between message create and consume time"
       end
 
-      gauge :kafka_consumer_ofset_lag do
+      Promenade.gauge :kafka_consumer_ofset_lag do
         doc "Lag between message create and consume time"
       end
 
-      histogram :kafka_consumer_message_processing_latency do
+      Promenade.histogram :kafka_consumer_message_processing_latency do
         doc "Consumer message processing latency"
         buckets :network
       end
 
-      counter :kafka_consumer_messages_processed do
+      Promenade.counter :kafka_consumer_messages_processed do
         doc "Messages processed by this consumer"
       end
 
-      counter :kafka_consumer_message_processing_errors do
+      Promenade.counter :kafka_consumer_messages_fetched do
+        doc "Messages fetched by this consumer"
+      end
+
+      Promenade.counter :kafka_consumer_message_processing_errors do
         doc "Consumer errors while processing a message"
       end
 
-      histogram :kafka_consumer_batch_processing_latency do
+      Promenade.histogram :kafka_consumer_batch_processing_latency do
         doc "Consumer batch processing latency"
         buckets :network
       end
 
-      counter :kafka_consumer_batch_processing_errors do
+      Promenade.counter :kafka_consumer_batch_processing_errors do
         doc "Consumer errors while processing a batch"
       end
 
-      histogram :kafka_consumer_join_group do
+      Promenade.histogram :kafka_consumer_join_group do
         doc "Time taken to join"
         buckets :network
       end
 
-      counter :kafka_consumer_join_group_errors do
+      Promenade.counter :kafka_consumer_join_group_errors do
         doc "Errors joining the group"
       end
 
-      histogram :kafka_consumer_sync_group do
+      Promenade.histogram :kafka_consumer_sync_group do
         doc "Time taken to sync"
         buckets :network
       end
 
-      counter :kafka_consumer_sync_group_errors do
+      Promenade.counter :kafka_consumer_sync_group_errors do
         doc "Errors syncing the group"
       end
 
-      histogram :kafka_consumer_leave_group do
+      Promenade.histogram :kafka_consumer_leave_group do
         doc "Time taken to leave group"
         buckets :network
       end
 
-      counter :kafka_consumer_leave_group_errors do
+      Promenade.counter :kafka_consumer_leave_group_errors do
         doc "Errors leaving the group"
       end
 
-      histogram :kafka_consumer_pause_duration do
+      Promenade.histogram :kafka_consumer_pause_duration do
         doc "Time taken to leave group"
         buckets :network
       end
@@ -74,53 +78,62 @@ module Promenade
         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)
+          Promenade.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)
+          Promenade.metric(:kafka_consumer_messages_processed).increment(labels)
+          Promenade.metric(:kafka_consumer_message_processing_latency).observe(labels, event.duration)
         end
 
-        metric(:kafka_consumer_ofset_lag).set(labels, offset_lag)
+        Promenade.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
+        Promenade.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)
+        offset_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)
+          Promenade.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)
+          Promenade.metric(:kafka_consumer_messages_processed).increment(labels, messages)
+          Promenade.metric(:kafka_consumer_batch_processing_latency).observe(labels, event.duration)
         end
 
-        metric(:kafka_consumer_ofset_lag).set(labels, lag)
+        Promenade.metric(:kafka_consumer_ofset_lag).set(labels, offset_lag)
+      end
+
+      def fetch_batch(event)
+        labels = get_labels(event)
+        offset_lag = event.payload.fetch(:offset_lag)
+        messages = event.payload.fetch(:message_count)
+
+        Promenade.metric(:kafka_consumer_messages_fetched).increment(labels, messages)
+        Promenade.metric(:kafka_consumer_ofset_lag).set(labels, offset_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)
+        Promenade.metric(:kafka_consumer_join_group).observe(labels, event.duration)
+        Promenade.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)
+        Promenade.metric(:kafka_consumer_sync_group).observe(labels, event.duration)
+        Promenade.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)
+        Promenade.metric(:kafka_consumer_leave_group).observe(labels, event.duration)
+        Promenade.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))
+        Promenade.metric(:kafka_consumer_pause_duration).observe(get_labels(event), event.payload.fetch(:duration))
       end
 
       private

data/lib/promenade/kafka/fetcher_subscriber.rb

@@ -5,7 +5,7 @@ module Promenade
     class FetcherSubscriber < Subscriber
       attach_to "fetcher.kafka"
 
-      gauge :kafka_fetcher_queue_size do
+      Promenade.gauge :kafka_fetcher_queue_size do
         doc "Fetcher queue size"
       end
 
@@ -14,7 +14,7 @@ module Promenade
         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)
+        Promenade.metric(:kafka_fetcher_queue_size).set({ client: client, group: group_id }, queue_size)
       end
     end
   end

data/lib/promenade/kafka/producer_subscriber.rb

@@ -5,59 +5,59 @@ module Promenade
     class ProducerSubscriber < Subscriber
       attach_to "producer.kafka"
 
-      counter :kafka_producer_messages do
+      Promenade.counter :kafka_producer_messages do
         doc "Number of messages written to Kafka producer"
       end
 
-      histogram :kafka_producer_message_size do
+      Promenade.histogram :kafka_producer_message_size do
         doc "Historgram of message sizes written to Kafka producer"
         buckets :memory
       end
 
-      gauge :kafka_producer_buffer_size do
+      Promenade.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
+      Promenade.gauge :kafka_producer_max_buffer_size do
         doc "The max size of the Kafka producer buffer"
       end
 
-      gauge :kafka_producer_buffer_fill_ratio do
+      Promenade.gauge :kafka_producer_buffer_fill_ratio do
         doc "The current ratio of Kafka producer buffer in use"
       end
 
-      counter :kafka_producer_buffer_overflows do
+      Promenade.counter :kafka_producer_buffer_overflows do
         doc "A count of kafka producer buffer overflow errors"
       end
 
-      counter :kafka_producer_delivery_errors do
+      Promenade.counter :kafka_producer_delivery_errors do
         doc "A count of kafka producer delivery errors"
       end
 
-      histogram :kafka_producer_delivery_latency do
+      Promenade.histogram :kafka_producer_delivery_latency do
         doc "Kafka producer delivery latency histogram"
         buckets :network
       end
 
-      counter :kafka_producer_delivered_messages do
+      Promenade.counter :kafka_producer_delivered_messages do
         doc "A count of the total messages delivered to Kafka"
       end
 
-      histogram :kafka_producer_delivery_attempts do
+      Promenade.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
+      Promenade.counter :kafka_producer_ack_messages do
         doc "Count of the number of messages Acked by Kafka"
       end
 
-      histogram :kafka_producer_ack_latency do
+      Promenade.histogram :kafka_producer_ack_latency do
         doc "Delay between message being produced and Acked"
         buckets :network
       end
 
-      counter :kafka_producer_ack_errors do
+      Promenade.counter :kafka_producer_ack_errors do
         doc "Count of the number of Kafka Ack errors"
       end
 
@@ -66,17 +66,17 @@ module Promenade
         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
+        buffer_fill_ratio = buffer_size.to_f / max_buffer_size
 
-        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)
+        Promenade.metric(:kafka_producer_messages).increment(labels)
+        Promenade.metric(:kafka_producer_message_size).observe(labels, message_size)
+        Promenade.metric(:kafka_producer_buffer_size).set(labels.slice(:client), buffer_size)
+        Promenade.metric(:kafka_producer_max_buffer_size).set(labels.slice(:client), max_buffer_size)
+        Promenade.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))
+        Promenade.metric(:kafka_producer_buffer_overflows).increment(get_labels(event))
       end
 
       def deliver_messages(event) # rubocop:disable Metrics/AbcSize
@@ -84,25 +84,25 @@ module Promenade
         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)
+        Promenade.metric(:kafka_producer_delivery_errors).increment(labels) if event.payload.key?(:exception)
+        Promenade.metric(:kafka_producer_delivery_latency).observe(labels, event.duration)
+        Promenade.metric(:kafka_producer_delivered_messages).increment(labels, message_count)
+        Promenade.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)
+        Promenade.metric(:kafka_producer_ack_messages).increment(labels)
+        Promenade.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)
+        Promenade.metric(:kafka_producer_ack_errors).increment(client: client, topic: topic)
       end
 
       private

data/lib/promenade/kafka/subscriber.rb

@@ -1,11 +1,9 @@
-require "promenade/helper"
 require "active_support/subscriber"
+require "concurrent/utility/monotonic_time"
 
 module Promenade
   module Kafka
     class Subscriber < ActiveSupport::Subscriber
-      include ::Promenade::Helper
-
       private
 
         def get_labels(event)

data/lib/promenade/version.rb

@@ -1,3 +1,3 @@
 module Promenade
-  VERSION = "0.1.10".freeze
+  VERSION = "0.2.0".freeze
 end

data/promenade.gemspec

@@ -26,11 +26,13 @@ Gem::Specification.new do |spec|
   spec.add_dependency "prometheus-client-mmap", "~> 0.9.3"
   spec.add_dependency "rack"
 
-  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "climate_control"
   spec.add_development_dependency "deep-cover"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "rubocop-performance"
+  spec.add_development_dependency "rubocop-rails"
   spec.add_development_dependency "simplecov"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: promenade
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.2.0
 platform: ruby
 authors:
 - Ed Robinson
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-12-10 00:00:00.000000000 Z
+date: 2019-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: climate_control
   requirement: !ruby/object:Gem::Requirement
@@ -136,6 +136,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  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: rubocop-rails
+  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: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -173,7 +201,6 @@ files:
 - bin/setup
 - exe/promenade
 - lib/promenade.rb
-- lib/promenade/helper.rb
 - lib/promenade/kafka.rb
 - lib/promenade/kafka/async_producer_subscriber.rb
 - lib/promenade/kafka/connection_subscriber.rb
@@ -205,8 +232,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: Promenade makes it simple to instrument Ruby apps for prometheus scraping

data/lib/promenade/helper.rb

@@ -1,23 +0,0 @@
-require "promenade/prometheus"
-
-module Promenade
-  module Helper
-    extend ActiveSupport::Concern
-
-    class_methods do
-      %i(gauge counter summary histogram).each do |type|
-        define_method type do |*args, &block|
-          Promenade::Prometheus.define_metric(type, *args, &block)
-        end
-      end
-
-      def metric(name)
-        Promenade::Prometheus.metric(name)
-      end
-    end
-
-    def metric(name)
-      Promenade::Prometheus.metric(name)
-    end
-  end
-end