prometheus_exporter 2.0.0 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5e708b8c63be6ecff9750deebf18cad149d9b4fa7350a4523af2f145caffec5
-  data.tar.gz: 1204a53af367dc60e24ded2e1630e2b447ef79d3caff32165ac5c40b62955ded
+  metadata.gz: 07f116c0fdf15835af1b9520ca81b47c1d7a6011b3b8991cf9b569127d7a22fc
+  data.tar.gz: f631d2d3259d72577e896a4f2a650f7af65e70b5703f24a02cbcebadd75f97d1
 SHA512:
-  metadata.gz: 5dee50712e73be92702e2948a0a69aa8b8007df59de35f10c5980d9d5a2653092a4247e7ad207713460df80f59bb0691835a3aa2b04fa751d28cc5b9c3f66f48
-  data.tar.gz: 0af7415fd207b1eb5f7f62639f8d48bc7735df9397537524c536631d24150b9b7daa87d17652f070a79f8134d50e780c9143ddeedcfc2d44eaa27586ffe64b19
+  metadata.gz: 81894939793a45953be6efbf90db9506abb6cc5ca196e03fd0bfe92035430284240820e1311e3f9532933602fa337790eb828e99809f003378cb6290b74f1eba
+  data.tar.gz: 151c49417eee04b2f9b931d9bda160fd19df22d2d9ff474f2f54b57bc828504eaf2d2f047eae2be1f121ce4d0b3ed74e9695959bcd51da8a52949da8a3931604

data/CHANGELOG

@@ -1,6 +1,20 @@
+2.0.3 - 2022-05-23
+
+- FEATURE: new ping endpoint for keepalive checks
+- FIX: order histogram correctly for GCP support
+- FIX: improve sidekiq instrumentation
+
+2.0.2 - 2022-02-25
+
+- FIX: runner was not requiring unicorn integration correctly leading to a crash
+
+2.0.1 - 2022-02-24
+
+- FIX: ensure threads do not leak when calling #start repeatedly on instrumentation classes, this is an urgent patch for Puma integration
+
 2.0.0 - 2022-02-18
 
-- FEATURE: Add per worker custom labels 
+- FEATURE: Add per worker custom labels
 - FEATURE: support custom histogram buckets
 - FIX: all metrics are exposing status label, and not only `http_requests_total`
 - BREAKING: rename all `http_duration` metrics to `http_request_duration` to match prometheus official naming conventions (See https://prometheus.io/docs/practices/naming/#metric-names).

data/README.md

@@ -201,6 +201,14 @@ Ensure you run the exporter in a monitored background process:
 $ bundle exec prometheus_exporter
 ```
 
+#### Choosing the style of method patching
+
+By default, `prometheus_exporter` uses `alias_method` to instrument methods used by SQL and Redis as it is the fastest approach (see [this article](https://samsaffron.com/archive/2017/10/18/fastest-way-to-profile-a-method-in-ruby)). You may desire to add additional instrumentation libraries beyond `prometheus_exporter` to your app. This can become problematic if these other libraries instead use `prepend` to instrument methods. To resolve this, you can tell the middleware to instrument using `prepend` by passing an `instrument` option like so:
+
+```ruby
+Rails.application.middleware.unshift PrometheusExporter::Middleware, instrument: :prepend
+```
+
 #### Metrics collected by Rails integration middleware
 
 | Type    | Name                                   | Description                                                 |
@@ -575,7 +583,10 @@ The easiest way to gather this metrics is to put the following in your `puma.rb`
 # puma.rb config
 after_worker_boot do
   require 'prometheus_exporter/instrumentation'
-  PrometheusExporter::Instrumentation::Puma.start
+  # optional check, avoids spinning up and down threads per worker
+  if !PrometheusExporter::Instrumentation::Puma.started?
+    PrometheusExporter::Instrumentation::Puma.start
+  end
 end
 ```
 
@@ -949,6 +960,26 @@ You can also pass a log level (default is [`Logger::WARN`](https://ruby-doc.org/
 PrometheusExporter::Client.new(log_level: Logger::DEBUG)
 ```
 
+## Docker/Kubernetes Healthcheck
+
+A `/ping` endpoint which only returns `PONG` is available so you can run container healthchecks :
+
+Example:
+
+```yml
+services:
+  rails-exporter:
+    command:
+      - bin/prometheus_exporter
+      - -b
+      - 0.0.0.0
+    healthcheck:
+      test: ["CMD", "curl", "--silent", "--show-error", "--fail", "--max-time", "3", "http://0.0.0.0:9394/ping"]
+      timeout: 3s
+      interval: 10s
+      retries: 5
+```
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/discourse/prometheus_exporter. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

data/lib/prometheus_exporter/instrumentation/active_record.rb

@@ -2,11 +2,10 @@
 
 # collects stats from currently running process
 module PrometheusExporter::Instrumentation
-  class ActiveRecord
+  class ActiveRecord < PeriodicStats
     ALLOWED_CONFIG_LABELS = %i(database username host port)
 
     def self.start(client: nil, frequency: 30, custom_labels: {}, config_labels: [])
-
       client ||= PrometheusExporter::Client.default
 
       # Not all rails versions support connection pool stats
@@ -20,20 +19,12 @@ module PrometheusExporter::Instrumentation
 
       active_record_collector = new(custom_labels, config_labels)
 
-      stop if @thread
-
-      @thread = Thread.new do
-        while true
-          begin
-            metrics = active_record_collector.collect
-            metrics.each { |metric| client.send_json metric }
-          rescue => e
-            client.logger.error("Prometheus Exporter Failed To Collect Process Stats #{e}")
-          ensure
-            sleep frequency
-          end
-        end
+      worker_loop do
+        metrics = active_record_collector.collect
+        metrics.each { |metric| client.send_json metric }
       end
+
+      super
     end
 
     def self.validate_config_labels(config_labels)
@@ -41,13 +32,6 @@ module PrometheusExporter::Instrumentation
       raise "Invalid Config Labels, available options #{ALLOWED_CONFIG_LABELS}" if (config_labels - ALLOWED_CONFIG_LABELS).size > 0
     end
 
-    def self.stop
-      if t = @thread
-        t.kill
-        @thread = nil
-      end
-    end
-
     def initialize(metric_labels, config_labels)
       @metric_labels = metric_labels
       @config_labels = config_labels

data/lib/prometheus_exporter/instrumentation/method_profiler.rb

@@ -4,30 +4,14 @@
 module PrometheusExporter::Instrumentation; end
 
 class PrometheusExporter::Instrumentation::MethodProfiler
-  def self.patch(klass, methods, name)
-    patch_source_line = __LINE__ + 3
-    patches = methods.map do |method_name|
-      <<~RUBY
-      unless defined?(#{method_name}__mp_unpatched)
-        alias_method :#{method_name}__mp_unpatched, :#{method_name}
-        def #{method_name}(*args, &blk)
-          unless prof = Thread.current[:_method_profiler]
-            return #{method_name}__mp_unpatched(*args, &blk)
-          end
-          begin
-            start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-            #{method_name}__mp_unpatched(*args, &blk)
-          ensure
-            data = (prof[:#{name}] ||= {duration: 0.0, calls: 0})
-            data[:duration] += Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
-            data[:calls] += 1
-          end
-        end
-      end
-      RUBY
-    end.join("\n")
-
-    klass.class_eval patches, __FILE__, patch_source_line
+  def self.patch(klass, methods, name, instrument:)
+    if instrument == :alias_method
+      patch_using_alias_method(klass, methods, name)
+    elsif instrument == :prepend
+      patch_using_prepend(klass, methods, name)
+    else
+      raise ArgumentError, "instrument must be :alias_method or :prepend"
+    end
   end
 
   def self.transfer
@@ -55,4 +39,57 @@ class PrometheusExporter::Instrumentation::MethodProfiler
     end
     data
   end
+
+private
+
+  def self.patch_using_prepend(klass, methods, name)
+    prepend_instument = Module.new
+    patch_source_line = __LINE__ + 3
+    patches = methods.map do |method_name|
+      <<~RUBY
+        def #{method_name}(*args, &blk)
+          unless prof = Thread.current[:_method_profiler]
+            return super
+          end
+          begin
+            start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            super
+          ensure
+            data = (prof[:#{name}] ||= {duration: 0.0, calls: 0})
+            data[:duration] += Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+            data[:calls] += 1
+          end
+        end
+      RUBY
+    end.join("\n")
+
+    prepend_instument.module_eval patches, __FILE__, patch_source_line
+    klass.prepend(prepend_instument)
+  end
+
+  def self.patch_using_alias_method(klass, methods, name)
+    patch_source_line = __LINE__ + 3
+    patches = methods.map do |method_name|
+      <<~RUBY
+      unless defined?(#{method_name}__mp_unpatched)
+        alias_method :#{method_name}__mp_unpatched, :#{method_name}
+        def #{method_name}(*args, &blk)
+          unless prof = Thread.current[:_method_profiler]
+            return #{method_name}__mp_unpatched(*args, &blk)
+          end
+          begin
+            start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            #{method_name}__mp_unpatched(*args, &blk)
+          ensure
+            data = (prof[:#{name}] ||= {duration: 0.0, calls: 0})
+            data[:duration] += Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+            data[:calls] += 1
+          end
+        end
+      end
+      RUBY
+    end.join("\n")
+
+    klass.class_eval patches, __FILE__, patch_source_line
+  end
 end

data/lib/prometheus_exporter/instrumentation/periodic_stats.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module PrometheusExporter::Instrumentation
+  class PeriodicStats
+
+    def self.start(*args, frequency:, client: nil, **kwargs)
+      client ||= PrometheusExporter::Client.default
+
+      if !(Numeric === frequency)
+        raise ArgumentError.new("Expected frequency to be a number")
+      end
+
+      if frequency < 0
+        raise ArgumentError.new("Expected frequency to be a positive number")
+      end
+
+      if !@worker_loop
+        raise ArgumentError.new("Worker loop was not set")
+      end
+
+      klass = self
+
+      stop
+
+      @stop_thread = false
+
+      @thread = Thread.new do
+        while !@stop_thread
+          begin
+            @worker_loop.call
+          rescue => e
+            client.logger.error("#{klass} Prometheus Exporter Failed To Collect Stats #{e}")
+          ensure
+            sleep frequency
+          end
+        end
+      end
+
+    end
+
+    def self.started?
+      !!@thread&.alive?
+    end
+
+    def self.worker_loop(&blk)
+      @worker_loop = blk
+    end
+
+    def self.stop
+      # to avoid a warning
+      @thread = nil if !defined?(@thread)
+
+      if @thread&.alive?
+        @stop_thread = true
+        @thread.wakeup
+        @thread.join
+      end
+      @thread = nil
+    end
+
+  end
+end

data/lib/prometheus_exporter/instrumentation/process.rb

@@ -2,8 +2,7 @@
 
 # collects stats from currently running process
 module PrometheusExporter::Instrumentation
-  class Process
-    @thread = nil if !defined?(@thread)
+  class Process < PeriodicStats
 
     def self.start(client: nil, type: "ruby", frequency: 30, labels: nil)
 
@@ -19,27 +18,12 @@ module PrometheusExporter::Instrumentation
       process_collector = new(metric_labels)
       client ||= PrometheusExporter::Client.default
 
-      stop if @thread
-
-      @thread = Thread.new do
-        while true
-          begin
-            metric = process_collector.collect
-            client.send_json metric
-          rescue => e
-            client.logger.error("Prometheus Exporter Failed To Collect Process Stats #{e}")
-          ensure
-            sleep frequency
-          end
-        end
+      worker_loop do
+        metric = process_collector.collect
+        client.send_json metric
       end
-    end
 
-    def self.stop
-      if t = @thread
-        t.kill
-        @thread = nil
-      end
+      super
     end
 
     def initialize(metric_labels)

data/lib/prometheus_exporter/instrumentation/puma.rb

@@ -4,22 +4,17 @@ require "json"
 
 # collects stats from puma
 module PrometheusExporter::Instrumentation
-  class Puma
+  class Puma < PeriodicStats
     def self.start(client: nil, frequency: 30, labels: {})
       puma_collector = new(labels)
       client ||= PrometheusExporter::Client.default
-      Thread.new do
-        while true
-          begin
-            metric = puma_collector.collect
-            client.send_json metric
-          rescue => e
-            client.logger.error("Prometheus Exporter Failed To Collect Puma Stats #{e}")
-          ensure
-            sleep frequency
-          end
-        end
+
+      worker_loop do
+        metric = puma_collector.collect
+        client.send_json metric
       end
+
+      super
     end
 
     def initialize(metric_labels = {})

data/lib/prometheus_exporter/instrumentation/resque.rb

@@ -2,21 +2,16 @@
 
 # collects stats from resque
 module PrometheusExporter::Instrumentation
-  class Resque
+  class Resque < PeriodicStats
     def self.start(client: nil, frequency: 30)
       resque_collector = new
       client ||= PrometheusExporter::Client.default
-      Thread.new do
-        while true
-          begin
-            client.send_json(resque_collector.collect)
-          rescue => e
-            client.logger.error("Prometheus Exporter Failed To Collect Resque Stats #{e}")
-          ensure
-            sleep frequency
-          end
-        end
+
+      worker_loop do
+        client.send_json(resque_collector.collect)
       end
+
+      super
     end
 
     def collect

data/lib/prometheus_exporter/instrumentation/sidekiq.rb

@@ -16,12 +16,12 @@ module PrometheusExporter::Instrumentation
         job_is_fire_and_forget = job["retry"] == false
 
         worker_class = Object.const_get(job["class"])
-        worker_custom_labels = self.get_worker_custom_labels(worker_class)
+        worker_custom_labels = self.get_worker_custom_labels(worker_class, job)
 
         unless job_is_fire_and_forget
           PrometheusExporter::Client.default.send_json(
             type: "sidekiq",
-            name: job["class"],
+            name: get_name(job["class"], job),
             dead: true,
             custom_labels: worker_custom_labels
           )
@@ -29,12 +29,21 @@ module PrometheusExporter::Instrumentation
       end
     end
 
-    def self.get_worker_custom_labels(worker_class)
-      worker_class.respond_to?(:custom_labels) ? worker_class.custom_labels : {}
+    def self.get_worker_custom_labels(worker_class, msg)
+      return {} unless worker_class.respond_to?(:custom_labels)
+
+      # TODO remove when version 3.0.0 is released
+      method_arity = worker_class.method(:custom_labels).arity
+
+      if method_arity > 0
+        worker_class.custom_labels(msg)
+      else
+        worker_class.custom_labels
+      end
     end
 
-    def initialize(client: nil)
-      @client = client || PrometheusExporter::Client.default
+    def initialize(options = { client: nil })
+      @client = options.fetch(:client, nil) || PrometheusExporter::Client.default
     end
 
     def call(worker, msg, queue)
@@ -51,19 +60,18 @@ module PrometheusExporter::Instrumentation
       duration = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start
       @client.send_json(
         type: "sidekiq",
-        name: get_name(worker, msg),
+        name: self.class.get_name(worker.class.to_s, msg),
         queue: queue,
         success: success,
         shutdown: shutdown,
         duration: duration,
-        custom_labels: self.class.get_worker_custom_labels(worker.class)
+        custom_labels: self.class.get_worker_custom_labels(worker.class, msg)
       )
     end
 
     private
 
-    def get_name(worker, msg)
-      class_name = worker.class.to_s
+    def self.get_name(class_name, msg)
       if class_name == JOB_WRAPPER_CLASS_NAME
         get_job_wrapper_name(msg)
       elsif DELAYED_CLASS_NAMES.include?(class_name)
@@ -73,11 +81,11 @@ module PrometheusExporter::Instrumentation
       end
     end
 
-    def get_job_wrapper_name(msg)
+    def self.get_job_wrapper_name(msg)
       msg['wrapped']
     end
 
-    def get_delayed_name(msg, class_name)
+    def self.get_delayed_name(msg, class_name)
       begin
         # fallback to class_name since we're relying on the internal implementation
         # of the delayed extensions

data/lib/prometheus_exporter/instrumentation/sidekiq_process.rb

@@ -1,22 +1,16 @@
 # frozen_string_literal: true
 
 module PrometheusExporter::Instrumentation
-  class SidekiqProcess
+  class SidekiqProcess < PeriodicStats
     def self.start(client: nil, frequency: 30)
       client ||= PrometheusExporter::Client.default
       sidekiq_process_collector = new
 
-      Thread.new do
-        loop do
-          begin
-            client.send_json(sidekiq_process_collector.collect)
-          rescue StandardError => e
-            STDERR.puts("Prometheus Exporter Failed To Collect Sidekiq Processes metrics #{e}")
-          ensure
-            sleep frequency
-          end
-        end
+      worker_loop do
+        client.send_json(sidekiq_process_collector.collect)
       end
+
+      super
     end
 
     def initialize

data/lib/prometheus_exporter/instrumentation/sidekiq_queue.rb

@@ -1,22 +1,16 @@
 # frozen_string_literal: true
 
 module PrometheusExporter::Instrumentation
-  class SidekiqQueue
+  class SidekiqQueue < PeriodicStats
     def self.start(client: nil, frequency: 30, all_queues: false)
       client ||= PrometheusExporter::Client.default
       sidekiq_queue_collector = new(all_queues: all_queues)
 
-      Thread.new do
-        loop do
-          begin
-            client.send_json(sidekiq_queue_collector.collect)
-          rescue StandardError => e
-            client.logger.error("Prometheus Exporter Failed To Collect Sidekiq Queue metrics #{e}")
-          ensure
-            sleep frequency
-          end
-        end
+      worker_loop do
+        client.send_json(sidekiq_queue_collector.collect)
       end
+
+      super
     end
 
     def initialize(all_queues: false)

data/lib/prometheus_exporter/instrumentation/sidekiq_stats.rb

@@ -1,22 +1,16 @@
 # frozen_string_literal: true
 
 module PrometheusExporter::Instrumentation
-  class SidekiqStats
+  class SidekiqStats < PeriodicStats
     def self.start(client: nil, frequency: 30)
       client ||= PrometheusExporter::Client.default
       sidekiq_stats_collector = new
 
-      Thread.new do
-        loop do
-          begin
-            client.send_json(sidekiq_stats_collector.collect)
-          rescue StandardError => e
-            STDERR.puts("Prometheus Exporter Failed To Collect Sidekiq Stats metrics #{e}")
-          ensure
-            sleep frequency
-          end
-        end
+      worker_loop do
+        client.send_json(sidekiq_stats_collector.collect)
       end
+
+      super
     end
 
     def collect

data/lib/prometheus_exporter/instrumentation/unicorn.rb

@@ -8,22 +8,17 @@ end
 
 module PrometheusExporter::Instrumentation
   # collects stats from unicorn
-  class Unicorn
+  class Unicorn < PeriodicStats
     def self.start(pid_file:, listener_address:, client: nil, frequency: 30)
       unicorn_collector = new(pid_file: pid_file, listener_address: listener_address)
       client ||= PrometheusExporter::Client.default
-      Thread.new do
-        loop do
-          begin
-            metric = unicorn_collector.collect
-            client.send_json metric
-          rescue StandardError => e
-            client.logger.error("Prometheus Exporter Failed To Collect Unicorn Stats #{e}")
-          ensure
-            sleep frequency
-          end
-        end
+
+      worker_loop do
+        metric = unicorn_collector.collect
+        client.send_json metric
       end
+
+      super
     end
 
     def initialize(pid_file:, listener_address:)

data/lib/prometheus_exporter/instrumentation.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "client"
+require_relative "instrumentation/periodic_stats"
 require_relative "instrumentation/process"
 require_relative "instrumentation/method_profiler"
 require_relative "instrumentation/sidekiq"

data/lib/prometheus_exporter/metric/histogram.rb

@@ -19,7 +19,7 @@ module PrometheusExporter::Metric
 
     def initialize(name, help, opts = {})
       super(name, help)
-      @buckets = (opts[:buckets] || self.class.default_buckets).sort.reverse
+      @buckets = (opts[:buckets] || self.class.default_buckets).sort
       reset!
     end
 
@@ -57,11 +57,11 @@ module PrometheusExporter::Metric
         first = false
         count = @counts[labels]
         sum = @sums[labels]
-        text << "#{prefix(@name)}_bucket#{labels_text(with_bucket(labels, "+Inf"))} #{count}\n"
         @buckets.each do |bucket|
           value = @observations[labels][bucket]
           text << "#{prefix(@name)}_bucket#{labels_text(with_bucket(labels, bucket.to_s))} #{value}\n"
         end
+        text << "#{prefix(@name)}_bucket#{labels_text(with_bucket(labels, "+Inf"))} #{count}\n"
         text << "#{prefix(@name)}_count#{labels_text(labels)} #{count}\n"
         text << "#{prefix(@name)}_sum#{labels_text(labels)} #{sum}"
       end
@@ -91,7 +91,7 @@ module PrometheusExporter::Metric
     end
 
     def fill_buckets(value, buckets)
-      @buckets.each do |b|
+      @buckets.reverse.each do |b|
         break if value > b
         buckets[b] += 1
       end

data/lib/prometheus_exporter/middleware.rb

@@ -6,23 +6,25 @@ require 'prometheus_exporter/client'
 class PrometheusExporter::Middleware
   MethodProfiler = PrometheusExporter::Instrumentation::MethodProfiler
 
-  def initialize(app, config = { instrument: true, client: nil })
+  def initialize(app, config = { instrument: :alias_method, client: nil })
     @app = app
     @client = config[:client] || PrometheusExporter::Client.default
 
     if config[:instrument]
       if defined? Redis::Client
-        MethodProfiler.patch(Redis::Client, [:call, :call_pipeline], :redis)
+        MethodProfiler.patch(Redis::Client, [
+          :call, :call_pipeline
+        ], :redis, instrument: config[:instrument])
       end
       if defined? PG::Connection
         MethodProfiler.patch(PG::Connection, [
           :exec, :async_exec, :exec_prepared, :send_query_prepared, :query
-        ], :sql)
+        ], :sql, instrument: config[:instrument])
       end
       if defined? Mysql2::Client
-        MethodProfiler.patch(Mysql2::Client, [:query], :sql)
-        MethodProfiler.patch(Mysql2::Statement, [:execute], :sql)
-        MethodProfiler.patch(Mysql2::Result, [:each], :sql)
+        MethodProfiler.patch(Mysql2::Client, [:query], :sql, instrument: config[:instrument])
+        MethodProfiler.patch(Mysql2::Statement, [:execute], :sql, instrument: config[:instrument])
+        MethodProfiler.patch(Mysql2::Result, [:each], :sql, instrument: config[:instrument])
       end
     end
   end

data/lib/prometheus_exporter/server/runner.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative '../client'
-require_relative '../instrumentation/unicorn'
 
 module PrometheusExporter::Server
   class RunnerException < StandardError; end
@@ -39,6 +38,9 @@ module PrometheusExporter::Server
       end
 
       if unicorn_listen_address && unicorn_pid_file
+
+        require_relative '../instrumentation'
+
         local_client = PrometheusExporter::LocalClient.new(collector: collector)
         PrometheusExporter::Instrumentation::Unicorn.start(
           pid_file: unicorn_pid_file,

data/lib/prometheus_exporter/server/web_server.rb

@@ -73,9 +73,11 @@ module PrometheusExporter::Server
           end
         elsif req.path == '/send-metrics'
           handle_metrics(req, res)
+        elsif req.path == '/ping'
+          res.body = 'PONG'
         else
           res.status = 404
-          res.body = "Not Found! The Prometheus Ruby Exporter only listens on /metrics and /send-metrics"
+          res.body = "Not Found! The Prometheus Ruby Exporter only listens on /ping, /metrics and /send-metrics"
         end
       end
     end

data/lib/prometheus_exporter/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PrometheusExporter
-  VERSION = '2.0.0'
+  VERSION = '2.0.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prometheus_exporter
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.3
 platform: ruby
 authors:
 - Sam Saffron
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-18 00:00:00.000000000 Z
+date: 2022-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: webrick
@@ -238,6 +238,7 @@ files:
 - lib/prometheus_exporter/instrumentation/delayed_job.rb
 - lib/prometheus_exporter/instrumentation/hutch.rb
 - lib/prometheus_exporter/instrumentation/method_profiler.rb
+- lib/prometheus_exporter/instrumentation/periodic_stats.rb
 - lib/prometheus_exporter/instrumentation/process.rb
 - lib/prometheus_exporter/instrumentation/puma.rb
 - lib/prometheus_exporter/instrumentation/resque.rb