collect_by_queue added as optional argument to GoodJob#Start

don't forget the documentation!

RuntimeMetric unused struct removed

GoodJobCollector refactor

empty? changed to length.zero? to respect expiry

metrics_container changes reverted since I didn't use any enumerable methods post refactor

Author: benngarcia

README.md

@@ -654,6 +654,9 @@ installation, you'll need to start the instrumentation:
 # e.g. config/initializers/good_job.rb
 require 'prometheus_exporter/instrumentation'
 PrometheusExporter::Instrumentation::GoodJob.start
+
+# or, to collect metrics labelled by their queue name
+PrometheusExporter::Instrumentation::GoodJob.start(collect_by_queue: true)
 ```
 
 #### Metrics collected by GoodJob Instrumentation

lib/prometheus_exporter/instrumentation/delayed_job.rb

@@ -4,8 +4,6 @@ module PrometheusExporter::Instrumentation
   class DelayedJob
     JOB_CLASS_REGEXP = /job_class: ((\w+:{0,2})+)/.freeze
 
-    RuntimeMetric = Struct.new(:max_attempts, :enqueued_count, :pending_count, :ready_count)
-
     class << self
       def register_plugin(client: nil, include_module_name: false)
         instrumenter = self.new(client: client)

lib/prometheus_exporter/instrumentation/good_job.rb

@@ -3,25 +3,32 @@
 # collects stats from GoodJob
 module PrometheusExporter::Instrumentation
   class GoodJob < PeriodicStats
-    def self.start(client: nil, frequency: 30)
+    COUNT_BY_QUEUE = ->(collection) { collection.group(:queue_name).size }
+    COUNT_ALL = ->(collection) { collection.size }
+
+    def self.start(client: nil, frequency: 30, collect_by_queue: false)
       good_job_collector = new
       client ||= PrometheusExporter::Client.default
 
-      worker_loop { client.send_json(good_job_collector.collect) }
+      worker_loop do
+        client.send_json(good_job_collector.collect(collect_by_queue))
+      end
 
       super
     end
 
-    def collect
+    def collect(by_queue = false)
+      count_method = by_queue ? COUNT_BY_QUEUE : COUNT_ALL
       {
         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,
+        by_queue: by_queue,
+        scheduled: ::GoodJob::Job.scheduled.yield_self(&count_method),
+        retried: ::GoodJob::Job.retried.yield_self(&count_method),
+        queued: ::GoodJob::Job.queued.yield_self(&count_method),
+        running: ::GoodJob::Job.running.yield_self(&count_method),
+        finished: ::GoodJob::Job.finished.yield_self(&count_method),
+        succeeded: ::GoodJob::Job.succeeded.yield_self(&count_method),
+        discarded: ::GoodJob::Job.discarded.yield_self(&count_method)
       }
     end
   end

lib/prometheus_exporter/server/good_job_collector.rb

@@ -23,21 +23,9 @@ def type
     end
 
     def metrics
-      return [] if good_job_metrics.length == 0
-
-      good_job_metrics.map do |metric|
-        labels = metric.fetch("custom_labels", {})
-
-        GOOD_JOB_GAUGES.map do |name, help|
-          value = metric[name.to_s]
-
-          if value
-            gauge = gauges[name] ||= PrometheusExporter::Metric::Gauge.new("good_job_#{name}", help)
-            gauge.observe(value, labels)
-          end
-        end
-      end
+      return [] if good_job_metrics.length.zero?
 
+      good_job_metrics.each(&method(:process_metric))
       gauges.values
     end
 
@@ -48,5 +36,24 @@ def collect(object)
     private
 
     attr_reader :good_job_metrics, :gauges
+
+    def process_metric(metric)
+      labels = metric.fetch("custom_labels", {})
+
+      GOOD_JOB_GAUGES.each do |name, help|
+        next unless (value = metric[name.to_s])
+
+        gauge = gauges[name] ||= PrometheusExporter::Metric::Gauge.new("good_job_#{name}", help)
+        observe_metric(gauge, metric, labels, value)
+      end
+    end
+
+    def observe_metric(gauge, metric, labels, value)
+      if metric["by_queue"]
+        value.each { |queue_name, count| gauge.observe(count, labels.merge(queue_name: queue_name)) }
+      else
+        gauge.observe(value, labels)
+      end
+    end
   end
 end

lib/prometheus_exporter/server/metrics_container.rb

@@ -34,14 +34,14 @@ def size(&blk)
     end
     alias_method :length, :size
 
-    def map(&blk)
-      wrap_expire(:map, &blk)
-    end
-
     def each(&blk)
       wrap_expire(:each, &blk)
     end
 
+    def map(&blk)
+      wrap_expire(:map, &blk)
+    end
+
     def expire(time: nil, new_metric: nil)
       time ||= get_time