promenade 0.1.14 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: adcaab71fd39ecc1d4f8ef6c45c45305d142134b1e4cb1b12ea498348c3b3619
-  data.tar.gz: 7f3065548c66d15995f320ff3b3bd116009ae2d18dcec2779c99f282f7be571c
+  metadata.gz: 336c06ecdc7505702a9adfbb8b826b3ea3bcfe386f1f8e907bc5532dfeff1d62
+  data.tar.gz: 3af09e7c9f83d39b638086d7d1e285bded62e92086412fdc575f47dac9554794
 SHA512:
-  metadata.gz: 21ea6d256b2fd37675478c2014a9ec30a8e6c5e8eeea715131a01204c954d15551cd510852aec8438388814b77c873930f5c75db17c16a58039d528696c9412d
-  data.tar.gz: c0527ae3af87a4057f0e0a21dee78928d0d843e23b453042bd9ba33b08904da0f2bd898eae5960dd8af14527d23005b200dd1e1ccdce3a5f102d7bc99ae41d54
+  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.14)
+    promenade (0.2.0)
       activesupport
       prometheus-client-mmap (~> 0.9.3)
       rack
@@ -51,7 +51,7 @@ GEM
     parallel (1.17.0)
     parser (2.6.3.0)
       ast (~> 2.4.0)
-    prometheus-client-mmap (0.9.8)
+    prometheus-client-mmap (0.9.9)
     pry (0.12.2)
       coderay (~> 1.1.0)
       method_source (~> 0.9.0)
@@ -102,7 +102,7 @@ GEM
     url (0.3.2)
     with_progress (1.0.1)
       ruby-progressbar (~> 1.4)
-    zeitwerk (2.1.9)
+    zeitwerk (2.1.10)
 
 PLATFORMS
   ruby
@@ -121,4 +121,4 @@ DEPENDENCIES
   simplecov
 
 BUNDLED WITH
-   2.0.1
+   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/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
 
@@ -31,20 +31,20 @@ module Promenade
         max_queue_size = event.payload.fetch(:max_queue_size)
         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(labels) 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,68 +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_messages_fetched do
+      Promenade.counter :kafka_consumer_messages_fetched do
         doc "Messages fetched by this consumer"
       end
 
-      counter :kafka_consumer_message_processing_errors do
+      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
@@ -78,16 +78,16 @@ 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
@@ -96,13 +96,13 @@ module Promenade
         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, offset_lag)
+        Promenade.metric(:kafka_consumer_ofset_lag).set(labels, offset_lag)
       end
 
       def fetch_batch(event)
@@ -110,30 +110,30 @@ module Promenade
         offset_lag = event.payload.fetch(:offset_lag)
         messages = event.payload.fetch(:message_count)
 
-        metric(:kafka_consumer_messages_fetched).increment(labels, messages)
-        metric(:kafka_consumer_ofset_lag).set(labels, offset_lag)
+        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
 
@@ -68,15 +68,15 @@ module Promenade
         max_buffer_size = event.payload.fetch(:max_buffer_size)
         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,12 +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.14".freeze
+  VERSION = "0.2.0".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: promenade
 version: !ruby/object:Gem::Version
-  version: 0.1.14
+  version: 0.2.0
 platform: ruby
 authors:
 - Ed Robinson
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-23 00:00:00.000000000 Z
+date: 2019-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -201,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

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