prometheus_exporter 2.0.8 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af71a5656b5fe6a90de6fe6ad1b76efa05ccfb67d4fdb3cdcc740f539097546f
-  data.tar.gz: cd6ef704ecdc7110d5f78dd999354e1ea093adcba51f2355a0211e99e0fb3c67
+  metadata.gz: e5381fb78e6440d77a61269f3bf7c40a84b44a53594d687db4a683be3cb82725
+  data.tar.gz: 18216fbeae6978d5427fa9f97a67bbf3f0ee36e92091a2606b2dadcaa6497d83
 SHA512:
-  metadata.gz: adf3c09a5609699bd055094bc509e997e320a72833b7c2beca03186d0c3d3fa0fa65fc005708b7faf496a9bf32c68c489cc7a1985525eed7a35ceb6b2d53a9df
-  data.tar.gz: 3975585eb3842c5cf409793d9257a184e33af062d4dd45e5bf64164bbba88c87d14aaea946bed519f9db1034afb8695fbdeecef337286bcaf00132cd2cd7a5f2
+  metadata.gz: 626d1f7c05e5bf21bc499e69fd1ab0d73c94c5a565ac7eae81ec9d43fc93f6cf96b83a6fd72b25846e49371079a9c87a497e719d74c20dfa57c0fb5cbe4507e5
+  data.tar.gz: b43a57442d6326648cbc3539c50400556575e425756358d45ad39832e099671ca617ea66b6754d16d66693b9fbdf9045b96a95713b36f1f135ab8ab0e38a6d0b

data/.github/workflows/ci.yml

@@ -8,6 +8,13 @@ on:
   schedule:
     - cron: "0 0 * * 0" # weekly
 
+permissions:
+  contents: write
+  packages: write
+
+env:
+  DOCKER_REPO: ghcr.io/discourse/prometheus_exporter
+
 jobs:
   build:
     runs-on: ubuntu-latest
@@ -20,15 +27,16 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: ['2.6', '2.7', '3.0', '3.1', '3.2']
-        activerecord: [60, 61]
+        ruby: ['3.1', '3.2', '3.3']
+        activerecord: [61, 70, 71]
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
 
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}
+          bundler: latest
           bundler-cache: true
 
       - name: Rubocop
@@ -42,12 +50,51 @@ jobs:
     needs: build
     runs-on: ubuntu-latest
 
+    outputs:
+      new_version_published: ${{ steps.release.outputs.new_version }}
+
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
 
       - name: Release gem
+        id: release
         uses: discourse/publish-rubygems-action@v2
         env:
           RUBYGEMS_API_KEY: ${{ secrets.RUBYGEMS_API_KEY }}
           GIT_EMAIL: team@discourse.org
           GIT_NAME: discoursebot
+
+  publish_docker:
+    needs: publish
+    if: needs.publish.outputs.new_version_published == 'true'
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: docker/setup-qemu-action@v2
+      - uses: docker/setup-buildx-action@v2
+
+      - name: Set vars
+        id: vars
+        run: |
+          ruby -r ./lib/prometheus_exporter/version.rb -e 'print "version=#{PrometheusExporter::VERSION}"' >> $GITHUB_OUTPUT
+
+      - name: Login to Github Container Registry
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build and push images
+        uses: docker/build-push-action@v3
+        with:
+          context: .
+          push: true
+          platforms: linux/amd64,linux/arm64
+          build-args: |
+            GEM_VERSION=${{ steps.vars.outputs.version }}
+          tags: |
+            ${{ env.DOCKER_REPO }}:${{ steps.vars.outputs.version }}
+            ${{ env.DOCKER_REPO }}:latest

data/.rubocop

@@ -0,0 +1 @@
+--ignore-unrecognized-cops

data/.rubocop.yml

@@ -4,4 +4,15 @@ inherit_gem:
 AllCops:
   Exclude:
     - 'gemfiles/**/*'
-    - 'vendor/**/*'
+    - 'vendor/**/*'
+
+Discourse/Plugins/NoMonkeyPatching:
+  Enabled: false
+
+Discourse/Plugins/NamespaceMethods:
+  Exclude:
+    - bin/prometheus_exporter
+
+Style/InvertibleUnlessCondition:
+  Exclude:
+    - '*.gemspec' 

data/Appraisals

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
 appraise "ar-60" do
-  # we are using this version as default in gemspec
-  # gem "activerecord", "~> 6.0.0"
+  gem "activerecord", "~> 6.0.0"
 end
 
 appraise "ar-61" do
   gem "activerecord", "~> 6.1.1"
 end
+
+appraise "ar-70" do
+  # latest version
+  gem "activerecord", "~> 7.1.2"
+end

data/CHANGELOG

@@ -1,3 +1,15 @@
+2.1.1 - 2024-06-19
+
+- FEATURE: improve good_job instrumentation
+- FIX: improve Ruby 3.X support
+- FEATURE: imstrumentation for malloc / oldmalloc increace in GC stats
+
+2.1.0 - 2024-01-08
+
+- FEATURE: good_job instrumentation
+- PERF: improve performance of histogram
+- DEV: use new metric collector pattern so we reuse code between collectors
+
 2.0.8 - 2023-01-20
 
 - FEATURE: attempting to make our first docker release

data/README.md

@@ -21,6 +21,7 @@ To learn more see [Instrumenting Rails with Prometheus](https://samsaffron.com/a
   * [Puma metrics](#puma-metrics)
   * [Unicorn metrics](#unicorn-process-metrics)
   * [Resque metrics](#resque-metrics)
+  * [GoodJob metrics](#goodjob-metrics)
   * [Custom type collectors](#custom-type-collectors)
   * [Multi process mode with custom collector](#multi-process-mode-with-custom-collector)
   * [GraphQL support](#graphql-support)
@@ -28,7 +29,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)
+  * [Histogram - custom buckets](#histogram---custom-buckets)
 * [Transport concerns](#transport-concerns)
 * [JSON generation and parsing](#json-generation-and-parsing)
 * [Logging](#logging)
@@ -39,7 +40,7 @@ To learn more see [Instrumenting Rails with Prometheus](https://samsaffron.com/a
 
 ## Requirements
 
-Minimum Ruby of version 2.6.0 is required, Ruby 2.5.0 is EOL as of March 31st 2021.
+Minimum Ruby of version 3.0.0 is required, Ruby 2.7 is EOL as of March 31st 2023.
 
 ## Migrating from v0.x
 
@@ -188,7 +189,7 @@ gem 'prometheus_exporter'
 In an initializer:
 
 ```ruby
-unless Rails.env == "test"
+unless Rails.env.test?
   require 'prometheus_exporter/middleware'
 
   # This reports stats per request like HTTP status and timings
@@ -341,7 +342,7 @@ You may also be interested in per-process stats. This collects memory and GC sta
 
 ```ruby
 # in an initializer
-unless Rails.env == "test"
+unless Rails.env.test?
   require 'prometheus_exporter/instrumentation'
 
   # this reports basic process stats like RSS and GC info
@@ -522,7 +523,7 @@ All metrics have labels for `job_name` and `queue_name`.
 In an initializer:
 
 ```ruby
-unless Rails.env == "test"
+unless Rails.env.test?
   require 'prometheus_exporter/instrumentation'
   PrometheusExporter::Instrumentation::DelayedJob.register_plugin
 end
@@ -533,6 +534,7 @@ end
 | Type    | Name                                      | Description                                                        | Labels     |
 | ---     | ---                                       | ---                                                                | ---        |
 | Counter | `delayed_job_duration_seconds`            | Total time spent in delayed jobs                                   | `job_name` |
+| Counter | `delayed_job_latency_seconds_total`       | Total delayed jobs latency                                         | `job_name` |
 | Counter | `delayed_jobs_total`                      | Total number of delayed jobs executed                              | `job_name` |
 | Gauge   | `delayed_jobs_enqueued`                   | Number of enqueued delayed jobs                                    | -          |
 | Gauge   | `delayed_jobs_pending`                    | Number of pending delayed jobs                                     | -          |
@@ -542,13 +544,14 @@ end
 | Summary | `delayed_job_attempts_summary`            | Summary of the amount of attempts it takes delayed jobs to succeed | -          |
 
 All metrics have labels for `job_name` and `queue_name`.
+`delayed_job_latency_seconds_total` is considering delayed job's [sleep_delay](https://github.com/collectiveidea/delayed_job#:~:text=If%20no%20jobs%20are%20found%2C%20the%20worker%20sleeps%20for%20the%20amount%20of%20time%20specified%20by%20the%20sleep%20delay%20option.%20Set%20Delayed%3A%3AWorker.sleep_delay%20%3D%2060%20for%20a%2060%20second%20sleep%20time.) parameter, so please be aware of this in case you are looking for high latency precision.
 
 #### Hutch Message Processing Tracer
 
 Capture [Hutch](https://github.com/gocardless/hutch) metrics (how many jobs ran? how many failed? how long did they take?)
 
 ```ruby
-unless Rails.env == "test"
+unless Rails.env.test?
   require 'prometheus_exporter/instrumentation'
   Hutch::Config.set(:tracer, PrometheusExporter::Instrumentation::Hutch)
 end
@@ -570,7 +573,7 @@ Request Queueing is defined as the time it takes for a request to reach your app
 
 As this metric starts before `prometheus_exporter` can handle the request, you must add a specific HTTP header as early in your infrastructure as possible (we recommend your load balancer or reverse proxy).
 
-The Amazon Application Load Balancer [request tracing header](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-request-tracing.html) is natively supported. If you are using another upstream entrypoint, you may configure your HTTP server / load balancer to add a header `X-Request-Start: t=<MSEC>` when passing the request upstream. For more information, please consult your software manual.
+The Amazon Application Load Balancer [request tracing header](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-request-tracing.html) is natively supported. If you are using another upstream entrypoint, you may configure your HTTP server / load balancer to add a header `X-Request-Start: t=<MSEC>` when passing the request upstream. Please keep in mind request time start is reported as epoch time (in seconds) and lacks precision, which may introduce additional latency in reported metrics. For more information, please consult your software manual.
 
 Hint: we aim to be API-compatible with the big APM solutions, so if you've got requests queueing time configured for them, it should be expected to also work with `prometheus_exporter`.
 
@@ -580,6 +583,17 @@ The puma metrics are using the `Puma.stats` method and hence need to be started
 workers has been booted and from a Puma thread otherwise the metrics won't be accessible.
 The easiest way to gather this metrics is to put the following in your `puma.rb` config:
 
+For Puma single mode
+```ruby
+# puma.rb config
+require 'prometheus_exporter/instrumentation'
+# optional check, avoids spinning up and down threads per worker
+if !PrometheusExporter::Instrumentation::Puma.started?
+  PrometheusExporter::Instrumentation::Puma.start
+end
+```
+
+For Puma clustered mode
 ```ruby
 # puma.rb config
 after_worker_boot do
@@ -627,6 +641,29 @@ PrometheusExporter::Instrumentation::Resque.start
 | Gauge | `resque_workers`        | Total number of Resque workers running |
 | Gauge | `resque_working`        | Total number of Resque workers working |
 
+### GoodJob metrics
+
+The metrics are generated from the database using the relevant scopes. To start monitoring your GoodJob
+installation, you'll need to start the instrumentation:
+
+```ruby
+# e.g. config/initializers/good_job.rb
+require 'prometheus_exporter/instrumentation'
+PrometheusExporter::Instrumentation::GoodJob.start
+```
+
+#### Metrics collected by GoodJob Instrumentation
+
+| Type  | Name                 | Description                             |
+| ---   |----------------------|-----------------------------------------|
+| Gauge | `good_job_scheduled` | Total number of scheduled GoodJob jobs. |
+| Gauge | `good_job_retried`   | Total number of retried GoodJob jobs.   |
+| Gauge | `good_job_queued`    | Total number of queued GoodJob jobs.    |
+| Gauge | `good_job_running`   | Total number of running GoodJob jobs.   |
+| Gauge | `good_job_finished`  | Total number of finished GoodJob jobs.  |
+| Gauge | `good_job_succeeded` | Total number of succeeded GoodJob jobs. |
+| Gauge | `good_job_discarded` | Total number of discarded GoodJob jobs  |
+
 ### Unicorn process metrics
 
 In order to gather metrics from unicorn processes, we use `rainbows`, which exposes `Rainbows::Linux.tcp_listener_stats` to gather information about active workers and queued requests. To start monitoring your unicorn processes, you'll need to know both the path to unicorn PID file and the listen address (`pid_file` and `listen` in your unicorn config file)
@@ -858,7 +895,7 @@ prometheus_exporter -p 8080 \
                     --prefix 'foo_'
 ```
 
-You can use `-b` option to bind the `prometheus_exporter` web server to any IPv4 interface with `-b 0.0.0.0`, 
+You can use `-b` option to bind the `prometheus_exporter` web server to any IPv4 interface with `-b 0.0.0.0`,
 any IPv6 interface with `-b ::`, or `-b ANY` to any IPv4/IPv6 interfaces available on your host system.
 
 #### Enabling Basic Authentication

data/bin/prometheus_exporter

@@ -74,7 +74,7 @@ def run
   end.parse!
 
   logger = Logger.new(options[:logger_path])
-  logger.level = Logger::WARN
+  logger.level = Logger::INFO
 
   if options.has_key?(:realm) && !options.has_key?(:auth)
     logger.warn "Providing REALM without AUTH has no effect"
@@ -121,7 +121,7 @@ def run
 
   runner = PrometheusExporter::Server::Runner.new(options)
 
-  puts "#{Time.now} Starting prometheus exporter on #{runner.bind}:#{runner.port}"
+  logger.info "Starting prometheus exporter on #{runner.bind}:#{runner.port}"
   runner.start
   sleep
 end

data/gemfiles/ar_70.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 7.0.0"
+
+gemspec path: "../"

data/gemfiles/ar_71.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 7.1.0"
+
+gemspec path: "../"

data/lib/prometheus_exporter/client.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
-require 'socket'
-require 'thread'
-require 'logger'
+require "socket"
+require "logger"
 
 module PrometheusExporter
   class Client
@@ -25,7 +24,9 @@ module PrometheusExporter
           keys: keys,
           value: value
         }
-        values[:prometheus_exporter_action] = prometheus_exporter_action if prometheus_exporter_action
+        values[
+          :prometheus_exporter_action
+        ] = prometheus_exporter_action if prometheus_exporter_action
         values[:opts] = @opts if @opts
         values
       end
@@ -57,8 +58,11 @@ module PrometheusExporter
     attr_reader :logger
 
     def initialize(
-      host: ENV.fetch('PROMETHEUS_EXPORTER_HOST', 'localhost'),
-      port: ENV.fetch('PROMETHEUS_EXPORTER_PORT', PrometheusExporter::DEFAULT_PORT),
+      host: ENV.fetch("PROMETHEUS_EXPORTER_HOST", "localhost"),
+      port: ENV.fetch(
+        "PROMETHEUS_EXPORTER_PORT",
+        PrometheusExporter::DEFAULT_PORT
+      ),
       max_queue_size: nil,
       thread_sleep: 0.5,
       json_serializer: nil,
@@ -90,7 +94,8 @@ module PrometheusExporter
       @mutex = Mutex.new
       @thread_sleep = thread_sleep
 
-      @json_serializer = json_serializer == :oj ? PrometheusExporter::OjCompat : JSON
+      @json_serializer =
+        json_serializer == :oj ? PrometheusExporter::OjCompat : JSON
 
       @custom_labels = custom_labels
     end
@@ -100,7 +105,14 @@ module PrometheusExporter
     end
 
     def register(type, name, help, opts = nil)
-      metric = RemoteMetric.new(type: type, name: name, help: help, client: self, opts: opts)
+      metric =
+        RemoteMetric.new(
+          type: type,
+          name: name,
+          help: help,
+          client: self,
+          opts: opts
+        )
       @metrics << metric
       metric
     end
@@ -161,9 +173,7 @@ module PrometheusExporter
       @mutex.synchronize do
         wait_for_empty_queue_with_timeout(wait_timeout_seconds)
         @worker_thread&.kill
-        while @worker_thread&.alive?
-          sleep 0.001
-        end
+        sleep 0.001 while @worker_thread&.alive?
         @worker_thread = nil
         close_socket!
       end
@@ -183,12 +193,13 @@ module PrometheusExporter
         @mutex.synchronize do
           return if @worker_thread&.alive?
 
-          @worker_thread = Thread.new do
-            while true
-              worker_loop
-              sleep @thread_sleep
+          @worker_thread =
+            Thread.new do
+              while true
+                worker_loop
+                sleep @thread_sleep
+              end
             end
-          end
         end
       end
     rescue ThreadError => e
@@ -212,7 +223,8 @@ module PrometheusExporter
     end
 
     def close_socket_if_old!
-      if @socket_pid == Process.pid && @socket && @socket_started && ((@socket_started + MAX_SOCKET_AGE) < Time.now.to_f)
+      if @socket_pid == Process.pid && @socket && @socket_started &&
+           ((@socket_started + MAX_SOCKET_AGE) < Time.now.to_f)
         close_socket!
       end
     end
@@ -240,7 +252,7 @@ module PrometheusExporter
       end
 
       nil
-    rescue
+    rescue StandardError
       @socket = nil
       @socket_started = nil
       @socket_pid = nil
@@ -250,7 +262,10 @@ module PrometheusExporter
     def wait_for_empty_queue_with_timeout(timeout_seconds)
       start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
       while @queue.length > 0
-        break if start_time + timeout_seconds < ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+        if start_time + timeout_seconds <
+             ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+          break
+        end
         sleep(0.05)
       end
     end

data/lib/prometheus_exporter/instrumentation/delayed_job.rb

@@ -2,10 +2,10 @@
 
 module PrometheusExporter::Instrumentation
   class DelayedJob
-    JOB_CLASS_REGEXP = %r{job_class: (\w+:{0,2})+}.freeze
+    JOB_CLASS_REGEXP = %r{job_class: ((\w+:{0,2})+)}.freeze
 
     class << self
-      def register_plugin(client: nil)
+      def register_plugin(client: nil, include_module_name: false)
         instrumenter = self.new(client: client)
         return unless defined?(Delayed::Plugin)
 
@@ -15,7 +15,8 @@ module PrometheusExporter::Instrumentation
               max_attempts = Delayed::Worker.max_attempts
               enqueued_count = Delayed::Job.where(queue: job.queue).count
               pending_count = Delayed::Job.where(attempts: 0, locked_at: nil, queue: job.queue).count
-              instrumenter.call(job, max_attempts, enqueued_count, pending_count, *args, &block)
+              instrumenter.call(job, max_attempts, enqueued_count, pending_count, include_module_name,
+                                *args, &block)
             end
           end
         end
@@ -28,9 +29,10 @@ module PrometheusExporter::Instrumentation
       @client = client || PrometheusExporter::Client.default
     end
 
-    def call(job, max_attempts, enqueued_count, pending_count, *args, &block)
+    def call(job, max_attempts, enqueued_count, pending_count, include_module_name, *args, &block)
       success = false
       start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      latency = Time.current - job.run_at
       attempts = job.attempts + 1 # Increment because we're adding the current attempt
       result = block.call(job, *args)
       success = true
@@ -40,10 +42,11 @@ module PrometheusExporter::Instrumentation
 
       @client.send_json(
         type: "delayed_job",
-        name: job.handler.to_s.match(JOB_CLASS_REGEXP).to_a[1].to_s,
+        name: job.handler.to_s.match(JOB_CLASS_REGEXP).to_a[include_module_name ? 1 : 2].to_s,
         queue_name: job.queue,
         success: success,
         duration: duration,
+        latency: latency,
         attempts: attempts,
         max_attempts: max_attempts,
         enqueued: enqueued_count,

data/lib/prometheus_exporter/instrumentation/good_job.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# collects stats from GoodJob
+module PrometheusExporter::Instrumentation
+  class GoodJob < PeriodicStats
+    def self.start(client: nil, frequency: 30)
+      good_job_collector = new
+      client ||= PrometheusExporter::Client.default
+
+      worker_loop do
+        client.send_json(good_job_collector.collect)
+      end
+
+      super
+    end
+
+    def collect
+      {
+        type: "good_job",
+        scheduled: ::GoodJob::Job.scheduled.size,
+        retried: ::GoodJob::Job.retried.size,
+        queued: ::GoodJob::Job.queued.size,
+        running: ::GoodJob::Job.running.size,
+        finished: ::GoodJob::Job.finished.size,
+        succeeded: ::GoodJob::Job.succeeded.size,
+        discarded: ::GoodJob::Job.discarded.size
+      }
+    end
+  end
+end

data/lib/prometheus_exporter/instrumentation/method_profiler.rb

@@ -44,7 +44,7 @@ class PrometheusExporter::Instrumentation::MethodProfiler
     patch_source_line = __LINE__ + 3
     patches = methods.map do |method_name|
       <<~RUBY
-        def #{method_name}(*args, &blk)
+        def #{method_name}(...)
           unless prof = Thread.current[:_method_profiler]
             return super
           end
@@ -75,13 +75,13 @@ class PrometheusExporter::Instrumentation::MethodProfiler
       <<~RUBY
       unless defined?(#{method_name}__mp_unpatched)
         alias_method :#{method_name}__mp_unpatched, :#{method_name}
-        def #{method_name}(*args, &blk)
+        def #{method_name}(...)
           unless prof = Thread.current[:_method_profiler]
-            return #{method_name}__mp_unpatched(*args, &blk)
+            return #{method_name}__mp_unpatched(...)
           end
           begin
             start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-            #{method_name}__mp_unpatched(*args, &blk)
+            #{method_name}__mp_unpatched(...)
           ensure
             data = (prof[:#{name}] ||= {duration: 0.0, calls: 0})
             data[:duration] += Process.clock_gettime(Process::CLOCK_MONOTONIC) - start

data/lib/prometheus_exporter/instrumentation/process.rb

@@ -63,6 +63,8 @@ module PrometheusExporter::Instrumentation
       metric[:major_gc_ops_total] = stat[:major_gc_count]
       metric[:minor_gc_ops_total] = stat[:minor_gc_count]
       metric[:allocated_objects_total] = stat[:total_allocated_objects]
+      metric[:malloc_increase_bytes_limit] = stat[:malloc_increase_bytes_limit]
+      metric[:oldmalloc_increase_bytes_limit] = stat[:oldmalloc_increase_bytes_limit]
     end
 
     def collect_v8_stats(metric)

data/lib/prometheus_exporter/instrumentation/sidekiq.rb

@@ -1,18 +1,19 @@
 # frozen_string_literal: true
 
-require 'yaml'
+require "yaml"
 
 module PrometheusExporter::Instrumentation
-  JOB_WRAPPER_CLASS_NAME = 'ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper'
-  DELAYED_CLASS_NAMES = [
-    'Sidekiq::Extensions::DelayedClass',
-    'Sidekiq::Extensions::DelayedModel',
-    'Sidekiq::Extensions::DelayedMailer',
+  JOB_WRAPPER_CLASS_NAME =
+    "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper"
+  DELAYED_CLASS_NAMES = %w[
+    Sidekiq::Extensions::DelayedClass
+    Sidekiq::Extensions::DelayedModel
+    Sidekiq::Extensions::DelayedMailer
   ]
 
   class Sidekiq
     def self.death_handler
-      -> (job, ex) do
+      ->(job, ex) do
         job_is_fire_and_forget = job["retry"] == false
 
         worker_class = Object.const_get(job["class"])
@@ -43,7 +44,8 @@ module PrometheusExporter::Instrumentation
     end
 
     def initialize(options = { client: nil })
-      @client = options.fetch(:client, nil) || PrometheusExporter::Client.default
+      @client =
+        options.fetch(:client, nil) || PrometheusExporter::Client.default
     end
 
     def call(worker, msg, queue)
@@ -82,7 +84,7 @@ module PrometheusExporter::Instrumentation
     end
 
     def self.get_job_wrapper_name(msg)
-      msg['wrapped']
+      msg["wrapped"]
     end
 
     def self.get_delayed_name(msg, class_name)
@@ -90,17 +92,17 @@ module PrometheusExporter::Instrumentation
         # 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
+        target, method_name, _args = YAML.load(msg["args"].first)
         if target.class == Class
           "#{target.name}##{method_name}"
         else
           "#{target.class.name}##{method_name}"
         end
       rescue Psych::DisallowedClass, ArgumentError
-        parsed = Psych.parse(msg['args'].first)
+        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(':', '')
+        target = (children[0].value || children[0].tag).sub("!", "")
+        method_name = (children[1].value || children[1].tag).sub(":", "")
 
         if target && method_name
           "#{target}##{method_name}"
@@ -108,7 +110,7 @@ module PrometheusExporter::Instrumentation
           class_name
         end
       end
-    rescue
+    rescue StandardError
       class_name
     end
   end

data/lib/prometheus_exporter/instrumentation.rb

@@ -15,3 +15,4 @@ require_relative "instrumentation/unicorn"
 require_relative "instrumentation/active_record"
 require_relative "instrumentation/shoryuken"
 require_relative "instrumentation/resque"
+require_relative "instrumentation/good_job"

data/lib/prometheus_exporter/metric/histogram.rb

@@ -91,7 +91,7 @@ module PrometheusExporter::Metric
     end
 
     def fill_buckets(value, buckets)
-      @buckets.reverse.each do |b|
+      @buckets.reverse_each do |b|
         break if value > b
         buckets[b] += 1
       end

data/lib/prometheus_exporter/middleware.rb

@@ -23,7 +23,7 @@ class PrometheusExporter::Middleware
       end
       if defined? PG::Connection
         MethodProfiler.patch(PG::Connection, [
-          :exec, :async_exec, :exec_prepared, :send_query_prepared, :query
+          :exec, :async_exec, :exec_prepared, :exec_params, :send_query_prepared, :query
         ], :sql, instrument: config[:instrument])
       end
       if defined? Mysql2::Client