prometheus_exporter 1.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b9fae4f661a2154e78754266e14a491a3d4271a7f2bf308586d1d5c16975452
-  data.tar.gz: 3c12e51359809b26963be8d148ebf0775f83ad588ca6b7f352b855e73f553598
+  metadata.gz: 0a8fb6585d155b56625dcd0d89c41301659e5b32cfc8272a340c7b067dbf686a
+  data.tar.gz: 6e5715300786de15f2906b4f8a5603bd19150cb1c511cb83e5c3a3bdf53a5f5b
 SHA512:
-  metadata.gz: 866d3593b9d575451efec2a87dac5d0e4b03b9ed265b776c9ae3f65ce417e7cb04c8ee29769ba38d3fc5ad1abb5824c56c10f5ee7b8461d62629c95145f8c58d
-  data.tar.gz: 6dd42a1d78443807ca0b026617e55e23089e772620d0dfd88ccc3c2871a6096fb081ca0065060e943680158f7b78c88035bb8d64327f95e4756f3902add36fe3
+  metadata.gz: 52cce25c1403f889f65fc25b054ec22703f32dad1c32d14e35af74b65308c2bf7f0a10e8343bd906c98f884167243484f43114700c3175113e8e75f002421823
+  data.tar.gz: de8bc77ce936ad4f045c0f34907febb881518b537d5828bfeba5476924355157902f6618a0acc37aa1202ff604853f7bb3908ba78478a6cd3cf57bb1b0f5ff66

data/.github/workflows/ci.yml

@@ -1,49 +1,53 @@
-name: Test Exporter
+name: CI
 
 on:
   push:
+    branches:
+      - main
   pull_request:
   schedule:
-    - cron: '0 0 * * 0' # weekly
+    - cron: "0 0 * * 0" # weekly
 
 jobs:
   build:
     runs-on: ubuntu-latest
-    name: Ruby ${{ matrix.ruby }}
+    name: Ruby ${{ matrix.ruby }} AR ${{ matrix.activerecord }}
+    timeout-minutes: 10
+
+    env:
+      BUNDLE_GEMFILE: ${{ github.workspace }}/gemfiles/ar_${{ matrix.activerecord }}.gemfile
+
     strategy:
+      fail-fast: false
       matrix:
-        ruby: ["3.0", "2.7", "2.6"]
+        ruby: ['2.6', '2.7', '3.0', '3.1']
+        activerecord: [60, 61]
+
     steps:
-      - uses: actions/checkout@master
-        with:
-          fetch-depth: 1
-      - uses: actions/setup-ruby@v1
+      - uses: actions/checkout@v2
+
+      - uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}
-      - uses: actions/cache@v2
-        with:
-          path: vendor/bundle
-          key: ${{ runner.os }}-${{ matrix.ruby }}-gems-v2-${{ hashFiles('**/Gemfile.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-${{ matrix.ruby }}-gems-v2-
-
-      - name: Downgrade rubygems
-        run: |
-          # for Ruby <= 2.6 , details https://github.com/rubygems/rubygems/issues/3284
-          gem update --system 3.0.8
-        if: ${{ matrix.ruby == '2.6' || matrix.ruby == '2.7' }}
-      - name: Upgrade rubygems
-        run: |
-          gem update --system
-      - name: Setup gems
-        run: |
-          gem install bundler
-          bundle config path vendor/bundle
-          bundle install --jobs 4
-          bundle exec appraisal install
+          bundler-cache: true
+
       - name: Rubocop
         run: bundle exec rubocop
-      - name: install gems
-        run: bundle exec appraisal bundle
+
       - name: Run tests
-        run: bundle exec appraisal rake
+        run: bundle exec rake
+
+  publish:
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    needs: build
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Release gem
+        uses: discourse/publish-rubygems-action@v2
+        env:
+          RUBYGEMS_API_KEY: ${{ secrets.RUBYGEMS_API_KEY }}
+          GIT_EMAIL: team@discourse.org
+          GIT_NAME: discoursebot

data/CHANGELOG

@@ -1,4 +1,21 @@
-1.0.0 - 23-11-2021
+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: 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).
+
+1.0.1 - 2021-12-22
+
+- FEATURE: add labels to preflight requests
+- FEATURE: SidekiqStats metrics
+- FIX: mintor refactors to Sidekiq metrics
+
+1.0.0 - 2021-11-23
 
 - BREAKING: rename metrics to match prometheus official naming conventions (See https://prometheus.io/docs/practices/naming/#metric-names)
 - FEATURE: Sidekiq process metrics
@@ -6,11 +23,11 @@
 - FIX: logger improved for web server
 - FIX: Remove job labels from DelayedJob queues
 
-0.8.1 - 04-08-2021
+0.8.1 - 2021-08-04
 
 - FEATURE: swap from hardcoded STDERR to logger pattern (see README for details)
 
-0.8.0 - 05-07-2021
+0.8.0 - 2021-07-05
 
 - FIX: handle ThreadError more gracefully in cases where process shuts down
 - FEATURE: add job_name and queue_name labels to delayed job metrics
@@ -22,7 +39,7 @@
 - FEATURE: Improve Active Record instrumentation
 - FEATURE: Support HTTP_X_AMZN_TRACE_ID when supplied
 
-0.7.0 - 29-12-2020
+0.7.0 - 2020-12-29
 
 - Dev: Removed support from EOL rubies, only 2.5, 2.6, 2.7 and 3.0 are supported now.
 - Dev: Better support for Ruby 3.0, explicitly depending on webrick
@@ -30,111 +47,111 @@
 - FEATURE: clean pattern for overriding middleware labels was introduced (in README)
 - Fix: Better support for forking
 
-0.6.0 - 17-11-2020
+0.6.0 - 2020-11-17
 
 - FEATURE: add support for basic-auth in the prometheus_exporter web server
 
-0.5.3 - 29-07-2020
+0.5.3 - 2020-07-29
 
 - FEATURE: added #remove to all metric types so users can remove specific labels if needed
 
-0.5.2 - 01-07-2020
+0.5.2 - 2020-07-01
 
 - FEATURE: expanded instrumentation for sidekiq
 - FEATURE: configurable default labels
 
-0.5.1 - 25-02-2020
+0.5.1 - 2020-02-25
 
 - FEATURE: Allow configuring the default client's host and port via environment variables
 
-0.5.0 - 14-02-2020
+0.5.0 - 2020-02-14
 
 - Breaking change: listen only to localhost by default to prevent unintended insecure configuration
 - FIX: Avoid calling `hostname` aggressively, instead cache it on the exporter instance
 
-0.4.17 - 13-01-2020
+0.4.17 - 2020-01-13
 
 - FEATURE: add support for `to_h` on all metrics which can be used to query existing key/values
 
-0.4.16 - 04-11-2019
+0.4.16 - 2019-11-04
 
 - FEATURE: Support #reset! on all metric types to reset a metric to default
 
-0.4.15 - 04-11-2019
+0.4.15 - 2019-11-04
 
 - FEATURE: Improve delayed job collector, add pending counts
 - FEATURE: New ActiveRecord collector (documented in readme)
 - FEATURE: Allow passing in histogram and summary options
 - FEATURE: Allow custom labels for unicorn collector
 
-0.4.14 - 10-09-2019
+0.4.14 - 2019-09-10
 
 - FEATURE: allow finding metrics by name RemoteMetric #find_registered_metric
 - FIX: guard socket closing
 
-0.4.13 - 09-07-2019
+0.4.13 - 2019-07-09
 
 - Fix: Memory leak in unicorn and puma collectors
 
-0.4.12 - 30-05-2019
+0.4.12 - 2019-05-30
 
 - Fix: unicorn collector reporting incorrect number of unicorn workers
 
-0.4.11 - 15-05-2019
+0.4.11 - 2019-05-15
 
 - Fix: Handle stopping nil worker_threads in Client
 - Dev: add frozen string literals
 
-0.4.10 - 29-04-2019
+0.4.10 - 2019-04-29
 
 - Fix: Custom label support for puma collector
 - Fix: Raindrops socket collector not working correctly
 
-0.4.9 - 11-04-2019
+0.4.9 - 2019-04-11
 
 - Fix: Gem was not working correctly in Ruby 2.4 and below due to a syntax error
 
-0.4.8 - 10-04-2019
+0.4.8 - 2019-04-10
 
 - Feature: added helpers for instrumenting unicorn using raindrops
 
-0.4.7 - 08-04-2019
+0.4.7 - 2019-04-08
 
 - Fix: collector was not escaping " \ and \n correctly. This could lead
   to a corrupt payload in some cases.
 
-0.4.6 - 02-04-2019
+0.4.6 - 2019-04-02
 
 - Feature: Allow resetting a counter
 - Feature: Add sidekiq metrics: restarted, dead jobs counters
 - Fix: Client shutting down before sending metrics to collector
 
-0.4.5 - 14-02-2019
+0.4.5 - 2019-02-14
 
 - Feature: Allow process collector to ship custom labels for all process metrics
 - Fix: Always scope process metrics on hostname in collector
 
-0.4.4 - 13-02-2019
+0.4.4 - 2019-02-13
 
 - Feature: add support for local metric collection without using HTTP
 
-0.4.3 - 11-02-2019
+0.4.3 - 2019-02-11
 
 - Feature: Add alias for Gauge #observe called #set, this makes it a bit easier to migrate from prom
 - Feature: Add increment and decrement to Counter
 
-0.4.2 - 30-11-2018
+0.4.2 - 2018-11-30
 
 - Fix/Feature: setting a Gauge to nil will remove Gauge (setting to non numeric will raise)
 
-0.4.0 - 23-10-2018
+0.4.0 - 2018-10-23
 
 - Feature: histogram support
 - Feature: custom quantile support for summary
 - Feature: Puma metrics
 - Fix: delayed job metrics
 
-0.3.4 - 02-10-2018
+0.3.4 - 2018-10-02
 
 - Fix: custom collector via CLI was not working correctly
 

data/README.md

@@ -28,6 +28,7 @@ To learn more see [Instrumenting Rails with Prometheus](https://samsaffron.com/a
   * [Client default labels](#client-default-labels)
   * [Client default host](#client-default-host)
   * [Histogram mode](#histogram-mode)
+  * [Histogram - custom buckets](#histogram-custom-buckets)
 * [Transport concerns](#transport-concerns)
 * [JSON generation and parsing](#json-generation-and-parsing)
 * [Logging](#logging)
@@ -202,13 +203,13 @@ $ bundle exec prometheus_exporter
 
 #### Metrics collected by Rails integration middleware
 
-| Type    | Name                            | Description                                                 |
-| ---     | ---                             | ---                                                         |
-| Counter | `http_requests_total`           | Total HTTP requests from web app                            |
-| Summary | `http_duration_seconds`         | Time spent in HTTP reqs in seconds                          |
-| Summary | `http_redis_duration_seconds`¹  | Time spent in HTTP reqs in Redis, in seconds                |
-| Summary | `http_sql_duration_seconds`²    | Time spent in HTTP reqs in SQL in seconds                   |
-| Summary | `http_queue_duration_seconds`³  | Time spent queueing the request in load balancer in seconds |
+| Type    | Name                                   | Description                                                 |
+| ---     | ---                                    | ---                                                         |
+| Counter | `http_requests_total`                  | Total HTTP requests from web app                            |
+| Summary | `http_request_duration_seconds`        | Time spent in HTTP reqs in seconds                          |
+| Summary | `http_request_redis_duration_seconds`¹ | Time spent in HTTP reqs in Redis, in seconds                |
+| Summary | `http_request_sql_duration_seconds`²   | Time spent in HTTP reqs in SQL in seconds                   |
+| Summary | `http_request_queue_duration_seconds`³ | Time spent queueing the request in load balancer in seconds |
 
 All metrics have a `controller` and an `action` label.
 `http_requests_total` additionally has a (HTTP response) `status` label.
@@ -251,7 +252,7 @@ end
 ```
 That way you won't have all metrics labeled with `controller=other` and `action=other`, but have labels such as
 ```
-ruby_http_duration_seconds{path="/api/v1/teams/:id",method="GET",status="200",quantile="0.99"} 0.009880661998977303
+ruby_http_request_duration_seconds{path="/api/v1/teams/:id",method="GET",status="200",quantile="0.99"} 0.009880661998977303
 ```
 
 ¹) Only available when Redis is used.
@@ -367,43 +368,49 @@ Metrics collected by Process instrumentation include labels `type` (as given wit
 
 #### Sidekiq metrics
 
-Including Sidekiq metrics (how many jobs ran? how many failed? how long did they take? how many are dead? how many were restarted?)
-
-```ruby
-Sidekiq.configure_server do |config|
-   config.server_middleware do |chain|
-      require 'prometheus_exporter/instrumentation'
-      chain.add PrometheusExporter::Instrumentation::Sidekiq
-   end
-   config.death_handlers << PrometheusExporter::Instrumentation::Sidekiq.death_handler
-end
-```
-
-To monitor Queue size and latency:
+There are different kinds of Sidekiq metrics that can be collected. A recommended setup looks like this:
 
 ```ruby
 Sidekiq.configure_server do |config|
+  require 'prometheus_exporter/instrumentation'
+  config.server_middleware do |chain|
+    chain.add PrometheusExporter::Instrumentation::Sidekiq
+  end
+  config.death_handlers << PrometheusExporter::Instrumentation::Sidekiq.death_handler
   config.on :startup do
-    require 'prometheus_exporter/instrumentation'
+    PrometheusExporter::Instrumentation::Process.start type: 'sidekiq'
+    PrometheusExporter::Instrumentation::SidekiqProcess.start
     PrometheusExporter::Instrumentation::SidekiqQueue.start
+    PrometheusExporter::Instrumentation::SidekiqStats.start
   end
 end
 ```
 
-This will only monitor the queues that are consumed by the sidekiq process you are on.  You can pass an `all_queues` parameter to monitor metrics on all queues.
+* The middleware and death handler will generate job specific metrics (how many jobs ran? how many failed? how long did they take? how many are dead? how many were restarted?).
+* The [`Process`](#per-process-stats) metrics provide basic ruby metrics.
+* The `SidekiqProcess` metrics provide the concurrency and busy metrics for this process.
+* The `SidekiqQueue` metrics provides size and latency for the queues run by this process.
+* The `SidekiqStats` metrics provide general, global Sidekiq stats (size of Scheduled, Retries, Dead queues, total number of jobs, etc).
+
+For `SidekiqQueue`, if you run more than one process for the same queues, note that the same metrics will be exposed by all the processes, just like the `SidekiqStats` will if you run more than one process of any kind. You might want use `avg` or `max` when consuming their metrics.
 
-To monitor Sidekiq process info:
+An alternative would be to expose these metrics in lone, long-lived process. Using a rake task, for example:
 
 ```ruby
-Sidekiq.configure_server do |config|
-  config.on :startup do
-    require 'prometheus_exporter/instrumentation'
-    PrometheusExporter::Instrumentation::Process.start type: 'sidekiq'
-    PrometheusExporter::Instrumentation::SidekiqProcess.start
-  end
+task :sidekiq_metrics do
+  server = PrometheusExporter::Server::WebServer.new
+  server.start
+
+  PrometheusExporter::Client.default = PrometheusExporter::LocalClient.new(collector: server.collector)
+
+  PrometheusExporter::Instrumentation::SidekiqQueue.start(all_queues: true)
+  PrometheusExporter::Instrumentation::SidekiqStats.start
+  sleep
 end
 ```
 
+The `all_queues` parameter for `SidekiqQueue` will expose metrics for all queues.
+
 Sometimes the Sidekiq server shuts down before it can send metrics, that were generated right before the shutdown, to the collector. Especially if you care about the `sidekiq_restarted_jobs_total` metric, it is a good idea to explicitly stop the client:
 
 ```ruby
@@ -414,6 +421,18 @@ Sometimes the Sidekiq server shuts down before it can send metrics, that were ge
   end
 ```
 
+Custom labels can be added for individual jobs by defining a class method on the job class. These labels will be added to all Sidekiq metrics written by the job:
+
+```ruby
+  class WorkerWithCustomLabels
+    def self.custom_labels
+      { my_label: 'value-here', other_label: 'second-val' }
+    end
+
+    def perform; end
+  end
+```
+
 ##### Metrics collected by Sidekiq Instrumentation
 
 **PrometheusExporter::Instrumentation::Sidekiq**
@@ -447,7 +466,21 @@ Both metrics will have a `queue` label with the name of the queue.
 | Gauge | `sidekiq_process_busy`        | Number of busy workers for this process |
 | Gauge | `sidekiq_process_concurrency` | Concurrency for this process            |
 
-Both metrics will include the labels `labels`, `queues`, `quiet`, `tag`, `hostname` and `identity`, as returned by the [Sidekiq API](https://github.com/mperham/sidekiq/wiki/API#processes).
+Both metrics will include the labels `labels`, `queues`, `quiet`, `tag`, `hostname` and `identity`, as returned by the [Sidekiq Processes API](https://github.com/mperham/sidekiq/wiki/API#processes).
+
+**PrometheusExporter::Instrumentation::SidekiqStats**
+| Type  | Name                            | Description                             |
+| ---   | ---                             | ---                                     |
+| Gauge | `sidekiq_stats_dead_size`       | Size of the dead queue                  |
+| Gauge | `sidekiq_stats_enqueued`        | Number of enqueued jobs                 |
+| Gauge | `sidekiq_stats_failed`          | Number of failed jobs                   |
+| Gauge | `sidekiq_stats_processed`       | Total number of processed jobs          |
+| Gauge | `sidekiq_stats_processes_size`  | Number of processes                     |
+| Gauge | `sidekiq_stats_retry_size`      | Size of the retries queue               |
+| Gauge | `sidekiq_stats_scheduled_size`  | Size of the scheduled queue             |
+| Gauge | `sidekiq_stats_workers_size`    | Number of jobs actively being processed |
+
+Based on the [Sidekiq Stats API](https://github.com/mperham/sidekiq/wiki/API#stats).
 
 _See [Metrics collected by Process Instrumentation](#metrics-collected-by-process-instrumentation) for a list of metrics the Process instrumentation will produce._
 
@@ -542,7 +575,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
 ```
 
@@ -871,6 +907,26 @@ In histogram mode, the same metrics will be collected but will be reported as hi
 
 [`histogram_quantile`]: https://prometheus.io/docs/prometheus/latest/querying/functions/#histogram_quantile
 
+### Histogram - custom buckets
+
+By default these buckets will be used:
+```
+[0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5.0, 10.0].freeze
+```
+if this is not enough you can specify `default_buckets` like this:
+```
+Histogram.default_buckets = [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2, 2.5, 3, 4, 5.0, 10.0, 12, 14, 15, 20, 25].freeze
+```
+
+Specfied buckets on the instance  takes precedence over default:
+
+```
+Histogram.default_buckets = [0.005, 0.01, 0,5].freeze
+buckets = [0.1, 0.2, 0.3]
+histogram = Histogram.new('test_bucktets', 'I have specified buckets', buckets: buckets)
+histogram.buckets => [0.1, 0.2, 0.3]
+```
+
 ## Transport concerns
 
 Prometheus Exporter handles transport using a simple HTTP protocol. In multi process mode we avoid needing a large number of HTTP request by using chunked encoding to send metrics. This means that a single HTTP channel can deliver 100s or even 1000s of metrics over a single HTTP session to the `/send-metrics` endpoint. All calls to `send` and `send_json` on the `PrometheusExporter::Client` class are **non-blocking** and batched.

data/bin/prometheus_exporter

@@ -88,7 +88,7 @@ def run
   end
 
   if custom_collector_filename
-    eval File.read(custom_collector_filename), nil, File.expand_path(custom_collector_filename)
+    require File.expand_path(custom_collector_filename)
     found = false
 
     base_klass = PrometheusExporter::Server::CollectorBase
@@ -108,7 +108,7 @@ def run
 
   if custom_type_collectors_filenames.length > 0
     custom_type_collectors_filenames.each do |t|
-      eval File.read(t), nil, File.expand_path(t)
+      require File.expand_path(t)
     end
 
     ObjectSpace.each_object(Class) do |klass|

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/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

@@ -15,16 +15,24 @@ module PrometheusExporter::Instrumentation
       -> (job, ex) do
         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)
+
         unless job_is_fire_and_forget
           PrometheusExporter::Client.default.send_json(
             type: "sidekiq",
             name: job["class"],
             dead: true,
+            custom_labels: worker_custom_labels
           )
         end
       end
     end
 
+    def self.get_worker_custom_labels(worker_class)
+      worker_class.respond_to?(:custom_labels) ? worker_class.custom_labels : {}
+    end
+
     def initialize(client: nil)
       @client = client || PrometheusExporter::Client.default
     end
@@ -47,7 +55,8 @@ module PrometheusExporter::Instrumentation
         queue: queue,
         success: success,
         shutdown: shutdown,
-        duration: duration
+        duration: duration,
+        custom_labels: self.class.get_worker_custom_labels(worker.class)
       )
     end
 
@@ -69,19 +78,30 @@ module PrometheusExporter::Instrumentation
     end
 
     def get_delayed_name(msg, class_name)
-      # fallback to class_name since we're relying on the internal implementation
-      # of the delayed extensions
-      # https://github.com/mperham/sidekiq/blob/master/lib/sidekiq/extensions/class_methods.rb
       begin
-        (target, method_name, _args) = YAML.load(msg['args'].first)
+        # fallback to class_name since we're relying on the internal implementation
+        # of the delayed extensions
+        # https://github.com/mperham/sidekiq/blob/master/lib/sidekiq/extensions/class_methods.rb
+        (target, method_name, _args) = YAML.load(msg['args'].first) # rubocop:disable Security/YAMLLoad
         if target.class == Class
           "#{target.name}##{method_name}"
         else
           "#{target.class.name}##{method_name}"
         end
-      rescue
-        class_name
+      rescue Psych::DisallowedClass, ArgumentError
+        parsed = Psych.parse(msg['args'].first)
+        children = parsed.root.children
+        target = (children[0].value || children[0].tag).sub('!', '')
+        method_name = (children[1].value || children[1].tag).sub(':', '')
+
+        if target && method_name
+          "#{target}##{method_name}"
+        else
+          class_name
+        end
       end
+    rescue
+      class_name
     end
   end
 end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module PrometheusExporter::Instrumentation
+  class SidekiqStats < PeriodicStats
+    def self.start(client: nil, frequency: 30)
+      client ||= PrometheusExporter::Client.default
+      sidekiq_stats_collector = new
+
+      worker_loop do
+        client.send_json(sidekiq_stats_collector.collect)
+      end
+
+      super
+    end
+
+    def collect
+      {
+        type: 'sidekiq_stats',
+        stats: collect_stats
+      }
+    end
+
+    def collect_stats
+      stats = ::Sidekiq::Stats.new
+      {
+        'dead_size' => stats.dead_size,
+        'enqueued' => stats.enqueued,
+        'failed' => stats.failed,
+        'processed' => stats.processed,
+        'processes_size' => stats.processes_size,
+        'retry_size' => stats.retry_size,
+        'scheduled_size' => stats.scheduled_size,
+        'workers_size' => stats.workers_size,
+      }
+    end
+  end
+end

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,11 +1,13 @@
 # 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"
 require_relative "instrumentation/sidekiq_queue"
 require_relative "instrumentation/sidekiq_process"
+require_relative "instrumentation/sidekiq_stats"
 require_relative "instrumentation/delayed_job"
 require_relative "instrumentation/puma"
 require_relative "instrumentation/hutch"

data/lib/prometheus_exporter/metric/base.rb

@@ -106,15 +106,8 @@ module PrometheusExporter::Metric
       end
     end
 
-    # when we drop Ruby 2.3 we can drop this
-    if "".respond_to? :match?
-      def needs_escape?(str)
-        str.match?(/[\n"\\]/m)
-      end
-    else
-      def needs_escape?(str)
-        !!str.match(/[\n"\\]/m)
-      end
+    def needs_escape?(str)
+      str.match?(/[\n"\\]/m)
     end
 
   end

data/lib/prometheus_exporter/metric/histogram.rb

@@ -5,9 +5,21 @@ module PrometheusExporter::Metric
 
     DEFAULT_BUCKETS = [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5.0, 10.0].freeze
 
+    @default_buckets = nil if !defined?(@default_buckets)
+
+    def self.default_buckets
+      @default_buckets || DEFAULT_BUCKETS
+    end
+
+    def self.default_buckets=(buckets)
+      @default_buckets = buckets
+    end
+
+    attr_reader :buckets
+
     def initialize(name, help, opts = {})
       super(name, help)
-      @buckets = (opts[:buckets] || DEFAULT_BUCKETS).sort.reverse
+      @buckets = (opts[:buckets] || self.class.default_buckets).sort.reverse
       reset!
     end
 

data/lib/prometheus_exporter/middleware.rb

@@ -36,11 +36,12 @@ class PrometheusExporter::Middleware
 
     result
   ensure
-
+    status = (result && result[0]) || -1
     obj = {
       type: "web",
       timings: info,
       queue_time: queue_time,
+      status: status,
       default_labels: default_labels(env, result)
     }
     labels = custom_labels(env)
@@ -52,18 +53,21 @@ class PrometheusExporter::Middleware
   end
 
   def default_labels(env, result)
-    status = (result && result[0]) || -1
     params = env["action_dispatch.request.parameters"]
     action = controller = nil
     if params
       action = params["action"]
       controller = params["controller"]
+    elsif (cors = env["rack.cors"]) && cors.respond_to?(:preflight?) && cors.preflight?
+      # if the Rack CORS Middleware identifies the request as a preflight request,
+      # the stack doesn't get to the point where controllers/actions are defined
+      action = "preflight"
+      controller = "preflight"
     end
 
     {
       action: action || "other",
-      controller: controller || "other",
-      status: status
+      controller: controller || "other"
     }
   end
 

data/lib/prometheus_exporter/server/collector.rb

@@ -15,6 +15,7 @@ module PrometheusExporter::Server
       register_collector(SidekiqCollector.new)
       register_collector(SidekiqQueueCollector.new)
       register_collector(SidekiqProcessCollector.new)
+      register_collector(SidekiqStatsCollector.new)
       register_collector(DelayedJobCollector.new)
       register_collector(PumaCollector.new)
       register_collector(HutchCollector.new)

data/lib/prometheus_exporter/server/sidekiq_process_collector.rb

@@ -26,7 +26,7 @@ module PrometheusExporter::Server
         SIDEKIQ_PROCESS_GAUGES.map do |name, help|
           if (value = metric[name])
             gauge = gauges[name] ||= PrometheusExporter::Metric::Gauge.new("sidekiq_process_#{name}", help)
-            gauges[name].observe(value, labels)
+            gauge.observe(value, labels)
           end
         end
       end

data/lib/prometheus_exporter/server/sidekiq_stats_collector.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module PrometheusExporter::Server
+  class SidekiqStatsCollector < TypeCollector
+    MAX_SIDEKIQ_METRIC_AGE = 60
+
+    SIDEKIQ_STATS_GAUGES = {
+      'dead_size' => 'Size of dead the queue',
+      'enqueued' => 'Number of enqueued jobs',
+      'failed' => 'Number of failed jobs',
+      'processed' => 'Total number of processed jobs',
+      'processes_size' => 'Number of processes',
+      'retry_size' => 'Size of the retries queue',
+      'scheduled_size' => 'Size of the scheduled queue',
+      'workers_size' => 'Number of jobs actively being processed',
+    }.freeze
+
+    attr_reader :sidekiq_metrics, :gauges
+
+    def initialize
+      @sidekiq_metrics = []
+      @gauges = {}
+    end
+
+    def type
+      'sidekiq_stats'
+    end
+
+    def metrics
+      sidekiq_metrics.map do |metric|
+        SIDEKIQ_STATS_GAUGES.map do |name, help|
+          if (value = metric['stats'][name])
+            gauge = gauges[name] ||= PrometheusExporter::Metric::Gauge.new("sidekiq_stats_#{name}", help)
+            gauge.observe(value)
+          end
+        end
+      end
+
+      gauges.values
+    end
+
+    def collect(object)
+      sidekiq_metrics << object
+    end
+  end
+end

data/lib/prometheus_exporter/server/web_collector.rb

@@ -5,10 +5,10 @@ module PrometheusExporter::Server
     def initialize
       @metrics = {}
       @http_requests_total = nil
-      @http_duration_seconds = nil
-      @http_redis_duration_seconds = nil
-      @http_sql_duration_seconds = nil
-      @http_queue_duration_seconds = nil
+      @http_request_duration_seconds = nil
+      @http_request_redis_duration_seconds = nil
+      @http_request_sql_duration_seconds = nil
+      @http_request_queue_duration_seconds = nil
     end
 
     def type
@@ -33,23 +33,23 @@ module PrometheusExporter::Server
           "Total HTTP requests from web app."
         )
 
-        @metrics["http_duration_seconds"] = @http_duration_seconds = PrometheusExporter::Metric::Base.default_aggregation.new(
-          "http_duration_seconds",
+        @metrics["http_request_duration_seconds"] = @http_request_duration_seconds = PrometheusExporter::Metric::Base.default_aggregation.new(
+          "http_request_duration_seconds",
           "Time spent in HTTP reqs in seconds."
         )
 
-        @metrics["http_redis_duration_seconds"] = @http_redis_duration_seconds = PrometheusExporter::Metric::Base.default_aggregation.new(
-          "http_redis_duration_seconds",
+        @metrics["http_request_redis_duration_seconds"] = @http_request_redis_duration_seconds = PrometheusExporter::Metric::Base.default_aggregation.new(
+          "http_request_redis_duration_seconds",
           "Time spent in HTTP reqs in Redis, in seconds."
         )
 
-        @metrics["http_sql_duration_seconds"] = @http_sql_duration_seconds = PrometheusExporter::Metric::Base.default_aggregation.new(
-          "http_sql_duration_seconds",
+        @metrics["http_request_sql_duration_seconds"] = @http_request_sql_duration_seconds = PrometheusExporter::Metric::Base.default_aggregation.new(
+          "http_request_sql_duration_seconds",
           "Time spent in HTTP reqs in SQL in seconds."
         )
 
-        @metrics["http_queue_duration_seconds"] = @http_queue_duration_seconds = PrometheusExporter::Metric::Base.default_aggregation.new(
-          "http_queue_duration_seconds",
+        @metrics["http_request_queue_duration_seconds"] = @http_request_queue_duration_seconds = PrometheusExporter::Metric::Base.default_aggregation.new(
+          "http_request_queue_duration_seconds",
           "Time spent queueing the request in load balancer in seconds."
         )
       end
@@ -60,19 +60,19 @@ module PrometheusExporter::Server
       custom_labels = obj['custom_labels']
       labels = custom_labels.nil? ? default_labels : default_labels.merge(custom_labels)
 
-      @http_requests_total.observe(1, labels)
+      @http_requests_total.observe(1, labels.merge(status: obj["status"]))
 
       if timings = obj["timings"]
-        @http_duration_seconds.observe(timings["total_duration"], labels)
+        @http_request_duration_seconds.observe(timings["total_duration"], labels)
         if redis = timings["redis"]
-          @http_redis_duration_seconds.observe(redis["duration"], labels)
+          @http_request_redis_duration_seconds.observe(redis["duration"], labels)
         end
         if sql = timings["sql"]
-          @http_sql_duration_seconds.observe(sql["duration"], labels)
+          @http_request_sql_duration_seconds.observe(sql["duration"], labels)
         end
       end
       if queue_time = obj["queue_time"]
-        @http_queue_duration_seconds.observe(queue_time, labels)
+        @http_request_queue_duration_seconds.observe(queue_time, labels)
       end
     end
   end

data/lib/prometheus_exporter/server.rb

@@ -7,6 +7,7 @@ require_relative "server/process_collector"
 require_relative "server/sidekiq_collector"
 require_relative "server/sidekiq_queue_collector"
 require_relative "server/sidekiq_process_collector"
+require_relative "server/sidekiq_stats_collector"
 require_relative "server/delayed_job_collector"
 require_relative "server/collector_base"
 require_relative "server/collector"

data/lib/prometheus_exporter/version.rb

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

data/prometheus_exporter.gemspec

@@ -31,7 +31,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "minitest", "~> 5.0"
   spec.add_development_dependency "guard", "~> 2.0"
-  spec.add_development_dependency "mini_racer", "~> 0.3.1"
+  spec.add_development_dependency "mini_racer", "~> 0.5.0"
   spec.add_development_dependency "guard-minitest", "~> 2.0"
   spec.add_development_dependency "oj", "~> 3.0"
   spec.add_development_dependency "rack-test", "~> 0.8.3"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prometheus_exporter
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.1
 platform: ruby
 authors:
 - Sam Saffron
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-11-23 00:00:00.000000000 Z
+date: 2022-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: webrick
@@ -100,14 +100,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.1
+        version: 0.5.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.1
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: guard-minitest
   requirement: !ruby/object:Gem::Requirement
@@ -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
@@ -245,6 +246,7 @@ files:
 - lib/prometheus_exporter/instrumentation/sidekiq.rb
 - lib/prometheus_exporter/instrumentation/sidekiq_process.rb
 - lib/prometheus_exporter/instrumentation/sidekiq_queue.rb
+- lib/prometheus_exporter/instrumentation/sidekiq_stats.rb
 - lib/prometheus_exporter/instrumentation/unicorn.rb
 - lib/prometheus_exporter/metric.rb
 - lib/prometheus_exporter/metric/base.rb
@@ -267,6 +269,7 @@ files:
 - lib/prometheus_exporter/server/sidekiq_collector.rb
 - lib/prometheus_exporter/server/sidekiq_process_collector.rb
 - lib/prometheus_exporter/server/sidekiq_queue_collector.rb
+- lib/prometheus_exporter/server/sidekiq_stats_collector.rb
 - lib/prometheus_exporter/server/type_collector.rb
 - lib/prometheus_exporter/server/unicorn_collector.rb
 - lib/prometheus_exporter/server/web_collector.rb