prometheus_exporter 0.1.16 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 110ab29cb92edc16e211b229efc5a431448eee7b
-  data.tar.gz: 1475fec1cbf79bb26563c6493efa8adb276650f8
+  metadata.gz: 1c30ea9a86408e636402bd2d12167b7a2da30970
+  data.tar.gz: 05657f39e1322fdc4f2c3886f16616dd21d0ce3c
 SHA512:
-  metadata.gz: 9b2eccbb5ac11181ed6dbed96a0817a86b0198584926adf26832c5d090afb2f67269aee153cc0b19bbbd1a3142bc81f79d42ec1fb9e77ebec052581cc1459286
-  data.tar.gz: 3ffa69f888f98481e78f78b69293acbebbe35b6538c239b96a8fca6cd417e35a50f735362a77a91773f6b332e7087dcfe460a7365604a18a104656eb97557d55
+  metadata.gz: 2b8c45beaac491fbc6673b3e9897ff0b91490ce34fdb68e4d393068056605696c300d757adc5869bd277e2d1facd0657156460cc09e9bbcbe5f3e8ac6ebdbdf0
+  data.tar.gz: efb69fc5380f233fb3564f782cfc8e2f978b4ca4fc78cba3d66ff96738b9c8804d213e980a8e9db63e833437353debddeab3251ecc515657c403ab013d82b6c9

data/.travis.yml

@@ -3,3 +3,4 @@ language: ruby
 rvm:
   - 2.5.0
 before_install: gem install bundler -v 1.16.1
+before_script: sudo sh -c 'echo 0 > /proc/sys/net/ipv6/conf/all/disable_ipv6'

data/CHANGELOG

@@ -1,3 +1,7 @@
+Unreleased
+
+- Follow Prometheus metric [naming conventions](https://prometheus.io/docs/practices/naming/#metric-names)
+
 0.1.15 - 2018-02-19
 
 - Feature: Prefer to use oj if it is loadable

data/README.md

@@ -20,7 +20,11 @@ Or install it yourself as:
 
     $ gem install prometheus_exporter
 
-## Can I have some pretty pictures please? 
+## Ruby Version
+
+Minimum Ruby of version 2.3.0 is required, Ruby 2.2.0 is EOL as of 2018-03-31
+
+## Can I have some pretty pictures please?
 
 Sure, check out: [Instrumenting Rails with Prometheus](https://samsaffron.com/archive/2018/02/02/instrumenting-rails-with-prometheus)
 
@@ -153,12 +157,32 @@ Sidekiq.configure_server do |config|
 end
 ```
 
+It also comes with a DelayedJob plugin.
+
+```
+# in an initializer
+unless Rails.env == "test"
+  require 'prometheus_exporter/instrumentation'
+  PrometheusExporter::Instrumentation::DelayedJob.register_plugin
+end
+```
+
 Ensure you run the exporter in a monitored background process via
 
 ```
 % bundle exec prometheus_exporter
 ```
 
+#### Instrumenting Request Queueing Time
+
+Request Queueing is defined as the time it takes for a request to reach your application (instrumented by this `prometheus_exporter`) from farther upstream (as your load balancer). A high queueing time usually means that your backend cannot handle all the incoming requests in time, so they queue up (= you should see if you need to add more capacity)
+
+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).
+
+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.
+
+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`.
+
 ### Custom type collectors
 
 In some cases you may have custom metrics you want to ship the collector in a batch, in this case you may still be interested in the base collector behavior but would like to add your own special messages.
@@ -205,7 +229,7 @@ bundle exec prometheus_exporter -a person_collector.rb
 
 #### Global metrics in a custom type collector
 
-Custom type collectors are the ideal place to collect global metrics, such as user/article counts and connection counts. The custom type collector runs in the collector which usually runs in the prometheus exporter process. 
+Custom type collectors are the ideal place to collect global metrics, such as user/article counts and connection counts. The custom type collector runs in the collector which usually runs in the prometheus exporter process.
 
 Out-of-the-box we try to keep the prometheus exporter as lean as possible, we do not load all the Rails dependencies so you will not have access to your models. You can always ensure it is loaded in your custom type collector with:
 
@@ -218,14 +242,14 @@ end
 Then you can collect the metrics you need on demand:
 
 ```
-def metrics 
+def metrics
   user_count_gague = PrometheusExporter::Metric::Gauge.new('user_count', 'number of users in the app')
   user_count_gague.observe User.count
   [user_count_gauge]
 end
 ```
 
-The metrics endpoint is called whenever prometheus calls the `/metrics` HTTP endpoint, it may make sense to introduce some caching so database calls are only performed once every N seconds. [lru_redux](https://github.com/SamSaffron/lru_redux) is the perfect gem for that kind of job as you can `LruRedux::TTL::Cache` which will automatically expire after N seconds. 
+The metrics endpoint is called whenever prometheus calls the `/metrics` HTTP endpoint, it may make sense to introduce some caching so database calls are only performed once every N seconds. [lru_redux](https://github.com/SamSaffron/lru_redux) is the perfect gem for that kind of job as you can `LruRedux::TTL::Cache` which will automatically expire after N seconds.
 
 
 ### Multi process mode with custom collector
@@ -301,7 +325,7 @@ thing2 12
 
 ## 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. 
+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.
 
 The `/bench` directory has simple benchmark it is able to send through 10k messages in 500ms.
 

data/lib/prometheus_exporter/instrumentation/delayed_job.rb

@@ -0,0 +1,43 @@
+module PrometheusExporter::Instrumentation
+  class DelayedJob
+    JOB_CLASS_REGEXP = %r{job_class: (\w+:{0,2})+}.freeze
+
+    class << self
+      def register_plugin(client: nil)
+        instrumenter = self.new(client: client)
+        return unless defined?(Delayed::Plugin)
+
+        plugin = Class.new(Delayed::Plugin) do
+          callbacks do |lifecycle|
+            lifecycle.around(:invoke_job) do |job, *args, &block|
+              instrumenter.call(job, *args, &block)
+            end
+          end
+        end
+
+        Delayed::Worker.plugins << plugin
+      end
+    end
+
+    def initialize(client: nil)
+      @client = client || PrometheusExporter::Client.default
+    end
+
+    def call(job, *args, &block)
+      success = false
+      start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      result = block.call(job, *args)
+      success = true
+      result
+    ensure
+      duration = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start
+
+      @client.send_json(
+        type: "delayed_job",
+        name: job.handler.to_s.match(JOB_CLASS_REGEXP).to_a[1].to_s,
+        success: success,
+        duration: duration
+      )
+    end
+  end
+end

data/lib/prometheus_exporter/instrumentation/process.rb

@@ -10,7 +10,7 @@ module PrometheusExporter::Instrumentation
             metric = process_collector.collect
             client.send_json metric
           rescue => e
-            STDERR.puts("Prometheus Discoruse Failed To Collect Process Stats #{e}")
+            STDERR.puts("Prometheus Exporter Failed To Collect Process Stats #{e}")
           ensure
             sleep frequency
           end
@@ -51,9 +51,9 @@ module PrometheusExporter::Instrumentation
       stat = GC.stat
       metric[:heap_live_slots] = stat[:heap_live_slots]
       metric[:heap_free_slots] = stat[:heap_free_slots]
-      metric[:major_gc_count] = stat[:major_gc_count]
-      metric[:minor_gc_count] = stat[:minor_gc_count]
-      metric[:total_allocated_objects] = stat[:total_allocated_objects]
+      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]
     end
 
     def collect_v8_stats(metric)

data/lib/prometheus_exporter/instrumentation.rb

@@ -1,4 +1,5 @@
 require_relative "instrumentation/process"
 require_relative "instrumentation/method_profiler"
 require_relative "instrumentation/sidekiq"
+require_relative "instrumentation/delayed_job"
 require_relative "instrumentation/global"

data/lib/prometheus_exporter/middleware.rb

@@ -23,9 +23,12 @@ class PrometheusExporter::Middleware
   end
 
   def call(env)
+    queue_time = measure_queue_time(env)
+
     MethodProfiler.start
     result = @app.call(env)
     info = MethodProfiler.stop
+
     result
   ensure
     status = (result && result[0]) || -1
@@ -39,9 +42,44 @@ class PrometheusExporter::Middleware
     @client.send_json(
       type: "web",
       timings: info,
+      queue_time: queue_time,
       action: action,
       controller: controller,
       status: status
     )
   end
+
+  private
+
+  # measures the queue time (= time between receiving the request in downstream
+  # load balancer and starting request in ruby process)
+  def measure_queue_time(env)
+    start_time = queue_start(env)
+
+    return unless start_time
+
+    queue_time = request_start.to_f - start_time.to_f
+    queue_time unless queue_time.negative?
+  end
+
+  # need to use CLOCK_REALTIME, as nginx/apache write this also out as the unix timestamp
+  def request_start
+    Process.clock_gettime(Process::CLOCK_REALTIME)
+  end
+
+  # get the content of the x-queue-start or x-request-start header
+  def queue_start(env)
+    value = env['HTTP_X_REQUEST_START'] || env['HTTP_X_QUEUE_START']
+    unless value.nil? || value == ''
+      convert_header_to_ms(value.to_s)
+    end
+  end
+
+  # nginx returns time as milliseconds with 3 decimal places
+  # apache returns time as microseconds without decimal places
+  # this method takes care to convert both into a proper second + fractions timestamp
+  def convert_header_to_ms(str)
+    str = str.gsub(/t=|\./, '')
+    "#{str[0,10]}.#{str[10,13]}".to_f
+  end
 end

data/lib/prometheus_exporter/server/collector.rb

@@ -5,19 +5,19 @@ module PrometheusExporter::Server
   class Collector < CollectorBase
     MAX_PROCESS_METRIC_AGE = 60
     PROCESS_GAUGES = {
-      heap_free_slots: "Free ruby heap slots",
-      heap_live_slots: "Used ruby heap slots",
-      v8_heap_size: "Total JavaScript V8 heap size (bytes)",
-      v8_used_heap_size: "Total used JavaScript V8 heap size (bytes)",
-      v8_physical_size: "Physical size consumed by V8 heaps",
-      v8_heap_count: "Number of V8 contexts running",
-      rss: "Total RSS used by process",
+      heap_free_slots: "Free ruby heap slots.",
+      heap_live_slots: "Used ruby heap slots.",
+      v8_heap_size: "Total JavaScript V8 heap size (bytes).",
+      v8_used_heap_size: "Total used JavaScript V8 heap size (bytes).",
+      v8_physical_size: "Physical size consumed by V8 heaps.",
+      v8_heap_count: "Number of V8 contexts running.",
+      rss: "Total RSS used by process.",
     }
 
     PROCESS_COUNTERS = {
-      major_gc_count: "Major GC operations by process",
-      minor_gc_count: "Minor GC operations by process",
-      total_allocated_objects: "Total number of allocateds objects by process",
+      major_gc_ops_total: "Major GC operations by process.",
+      minor_gc_ops_total: "Minor GC operations by process.",
+      allocated_objects_total: "Total number of allocated objects by process.",
     }
 
     def initialize(json_serializer: nil)
@@ -29,6 +29,7 @@ module PrometheusExporter::Server
       register_collector(WebCollector.new)
       register_collector(ProcessCollector.new)
       register_collector(SidekiqCollector.new)
+      register_collector(DelayedJobCollector.new)
     end
 
     def register_collector(collector)

data/lib/prometheus_exporter/server/delayed_job_collector.rb

@@ -0,0 +1,42 @@
+module PrometheusExporter::Server
+  class DelayedJobCollector < TypeCollector
+
+    def type
+      "delayed_job"
+    end
+
+    def collect(obj)
+      ensure_delayed_job_metrics
+      @delayed_job_duration_seconds.observe(obj["duration"], job_name: obj["name"])
+      @delayed_jobs_total.observe(1, job_name: obj["name"])
+      @delayed_failed_jobs_total.observe(1, job_name: obj["name"]) if !obj["success"]
+    end
+
+    def metrics
+      if @delayed_jobs_total
+        [@delayed_job_duration_seconds, @delayed_jobs_total, @delayed_failed_jobs_total]
+      else
+        []
+      end
+    end
+
+    protected
+
+    def ensure_delayed_job_metrics
+      if !@delayed_jobs_total
+
+        @delayed_job_duration_seconds =
+        PrometheusExporter::Metric::Counter.new(
+          "delayed_job_duration_seconds", "Total time spent in delayed jobs.")
+
+        @delayed_jobs_total =
+        PrometheusExporter::Metric::Counter.new(
+          "delayed_jobs_total", "Total number of delayed jobs executed.")
+
+        @delayed_failed_jobs_total =
+        PrometheusExporter::Metric::Counter.new(
+          "delayed_failed_jobs_total", "Total number failed delayed jobs executed.")
+      end
+    end
+  end
+end

data/lib/prometheus_exporter/server/process_collector.rb

@@ -5,19 +5,19 @@ module PrometheusExporter::Server
   class ProcessCollector < TypeCollector
     MAX_PROCESS_METRIC_AGE = 60
     PROCESS_GAUGES = {
-      heap_free_slots: "Free ruby heap slots",
-      heap_live_slots: "Used ruby heap slots",
-      v8_heap_size: "Total JavaScript V8 heap size (bytes)",
-      v8_used_heap_size: "Total used JavaScript V8 heap size (bytes)",
-      v8_physical_size: "Physical size consumed by V8 heaps",
-      v8_heap_count: "Number of V8 contexts running",
-      rss: "Total RSS used by process",
+      heap_free_slots: "Free ruby heap slots.",
+      heap_live_slots: "Used ruby heap slots.",
+      v8_heap_size: "Total JavaScript V8 heap size (bytes).",
+      v8_used_heap_size: "Total used JavaScript V8 heap size (bytes).",
+      v8_physical_size: "Physical size consumed by V8 heaps.",
+      v8_heap_count: "Number of V8 contexts running.",
+      rss: "Total RSS used by process.",
     }
 
     PROCESS_COUNTERS = {
-      major_gc_count: "Major GC operations by process",
-      minor_gc_count: "Minor GC operations by process",
-      total_allocated_objects: "Total number of allocateds objects by process",
+      major_gc_ops_total: "Major GC operations by process.",
+      minor_gc_ops_total: "Minor GC operations by process.",
+      allocated_objects_total: "Total number of allocated objects by process.",
     }
 
     def initialize

data/lib/prometheus_exporter/server/sidekiq_collector.rb

@@ -8,13 +8,13 @@ module PrometheusExporter::Server
     def collect(obj)
       ensure_sidekiq_metrics
       @sidekiq_job_duration_seconds.observe(obj["duration"], job_name: obj["name"])
-      @sidekiq_job_count.observe(1, job_name: obj["name"])
-      @sidekiq_failed_job_count.observe(1, job_name: obj["name"]) if !obj["success"]
+      @sidekiq_jobs_total.observe(1, job_name: obj["name"])
+      @sidekiq_failed_jobs_total.observe(1, job_name: obj["name"]) if !obj["success"]
     end
 
     def metrics
-      if @sidekiq_job_count
-        [@sidekiq_job_duration_seconds, @sidekiq_job_count, @sidekiq_failed_job_count]
+      if @sidekiq_jobs_total
+        [@sidekiq_job_duration_seconds, @sidekiq_jobs_total, @sidekiq_failed_jobs_total]
       else
         []
       end
@@ -23,19 +23,19 @@ module PrometheusExporter::Server
     protected
 
     def ensure_sidekiq_metrics
-      if !@sidekiq_job_count
+      if !@sidekiq_jobs_total
 
         @sidekiq_job_duration_seconds =
         PrometheusExporter::Metric::Counter.new(
-          "sidekiq_job_duration_seconds", "Total time spent in sidekiq jobs")
+          "sidekiq_job_duration_seconds", "Total time spent in sidekiq jobs.")
 
-        @sidekiq_job_count =
+        @sidekiq_jobs_total =
         PrometheusExporter::Metric::Counter.new(
-          "sidekiq_job_count", "Total number of sidekiq jobs executed")
+          "sidekiq_jobs_total", "Total number of sidekiq jobs executed.")
 
-        @sidekiq_failed_job_count =
+        @sidekiq_failed_jobs_total =
         PrometheusExporter::Metric::Counter.new(
-          "sidekiq_failed_job_count", "Total number failed sidekiq jobs executed")
+          "sidekiq_failed_jobs_total", "Total number failed sidekiq jobs executed.")
       end
     end
   end

data/lib/prometheus_exporter/server/web_collector.rb

@@ -22,25 +22,30 @@ module PrometheusExporter::Server
     protected
 
     def ensure_metrics
-      unless @http_requests
-        @metrics["http_requests"] = @http_requests = PrometheusExporter::Metric::Counter.new(
-          "http_requests",
-          "Total HTTP requests from web app"
+      unless @http_requests_total
+        @metrics["http_requests_total"] = @http_requests_total = PrometheusExporter::Metric::Counter.new(
+          "http_requests_total",
+          "Total HTTP requests from web app."
         )
 
         @metrics["http_duration_seconds"] = @http_duration_seconds = PrometheusExporter::Metric::Summary.new(
           "http_duration_seconds",
-          "Time spent in HTTP reqs in seconds"
+          "Time spent in HTTP reqs in seconds."
         )
 
         @metrics["http_redis_duration_seconds"] = @http_redis_duration_seconds = PrometheusExporter::Metric::Summary.new(
           "http_redis_duration_seconds",
-          "Time spent in HTTP reqs in redis seconds"
+          "Time spent in HTTP reqs in Redis, in seconds."
         )
 
         @metrics["http_sql_duration_seconds"] = @http_sql_duration_seconds = PrometheusExporter::Metric::Summary.new(
           "http_sql_duration_seconds",
-          "Time spent in HTTP reqs in SQL in seconds"
+          "Time spent in HTTP reqs in SQL in seconds."
+        )
+
+        @metrics["http_queue_duration_seconds"] = @http_queue_duration_seconds = PrometheusExporter::Metric::Summary.new(
+          "http_queue_duration_seconds",
+          "Time spent queueing the request in load balancer in seconds."
         )
       end
     end
@@ -52,7 +57,7 @@ module PrometheusExporter::Server
         action: obj["action"] || "other"
       }
 
-      @http_requests.observe(1, labels.merge(status: obj["status"]))
+      @http_requests_total.observe(1, labels.merge(status: obj["status"]))
 
       if timings = obj["timings"]
         @http_duration_seconds.observe(timings["total_duration"], labels)
@@ -63,6 +68,9 @@ module PrometheusExporter::Server
           @http_sql_duration_seconds.observe(sql["duration"], labels)
         end
       end
+      if queue_time = obj["queue_time"]
+        @http_queue_duration_seconds.observe(queue_time, labels)
+      end
     end
   end
 end

data/lib/prometheus_exporter/server/web_server.rb

@@ -13,15 +13,15 @@ module PrometheusExporter::Server
 
       @verbose = verbose
 
-      @total_metrics = PrometheusExporter::Metric::Counter.new("total_collector_metrics", "total metrics processed by exporter web")
+      @metrics_total = PrometheusExporter::Metric::Counter.new("collector_metrics_total", "Total metrics processed by exporter web.")
 
-      @total_sessions = PrometheusExporter::Metric::Counter.new("total_collector_sessions", "total send_metric sessions processed by exporter web")
+      @sessions_total = PrometheusExporter::Metric::Counter.new("collector_sessions_total", "Total send_metric sessions processed by exporter web.")
 
-      @total_bad_metrics = PrometheusExporter::Metric::Counter.new("total_collector_bad_metrics", "total mis-handled metrics by collector")
+      @bad_metrics_total = PrometheusExporter::Metric::Counter.new("collector_bad_metrics_total", "Total mis-handled metrics by collector.")
 
-      @total_metrics.observe(0)
-      @total_sessions.observe(0)
-      @total_bad_metrics.observe(0)
+      @metrics_total.observe(0)
+      @sessions_total.observe(0)
+      @bad_metrics_total.observe(0)
 
       access_log, logger = nil
 
@@ -73,10 +73,10 @@ module PrometheusExporter::Server
     end
 
     def handle_metrics(req, res)
-      @total_sessions.observe
+      @sessions_total.observe
       req.body do |block|
         begin
-          @total_metrics.observe
+          @metrics_total.observe
           @collector.process(block)
         rescue => e
           if @verbose
@@ -85,7 +85,7 @@ module PrometheusExporter::Server
             STDERR.puts e.backtrace
             STDERR.puts
           end
-          @total_bad_metrics.observe
+          @bad_metrics_total.observe
           res.body = "Bad Metrics #{e}"
           res.status = e.respond_to?(:status_code) ? e.status_code : 500
           return
@@ -135,9 +135,9 @@ module PrometheusExporter::Server
         get_rss
       )
 
-      metrics << @total_metrics
-      metrics << @total_sessions
-      metrics << @total_bad_metrics
+      metrics << @metrics_total
+      metrics << @sessions_total
+      metrics << @bad_metrics_total
 
       <<~TEXT
       #{metrics.map(&:to_prometheus_text).join("\n\n")}

data/lib/prometheus_exporter/server.rb

@@ -3,6 +3,7 @@ require_relative "server/type_collector"
 require_relative "server/web_collector"
 require_relative "server/process_collector"
 require_relative "server/sidekiq_collector"
+require_relative "server/delayed_job_collector"
 require_relative "server/collector_base"
 require_relative "server/collector"
 require_relative "server/web_server"

data/lib/prometheus_exporter/version.rb

@@ -1,3 +1,3 @@
 module PrometheusExporter
-  VERSION = "0.1.16"
+  VERSION = "0.2.0"
 end

data/prometheus_exporter.gemspec

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
@@ -28,4 +29,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "mini_racer", "~> 0.1"
   spec.add_development_dependency "guard-minitest", "~> 2.0"
   spec.add_development_dependency "oj", "~> 3.0"
+  spec.add_development_dependency "rack-test", "~> 0.8.3"
+  spec.required_ruby_version = '>= 2.3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prometheus_exporter
 version: !ruby/object:Gem::Version
-  version: 0.1.16
+  version: 0.2.0
 platform: ruby
 authors:
 - Sam Saffron
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-19 00:00:00.000000000 Z
+date: 2018-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -108,6 +108,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.3
 description: Prometheus metric collector and exporter for Ruby
 email:
 - sam.saffron@gmail.com
@@ -133,6 +147,7 @@ files:
 - lib/prometheus_exporter.rb
 - lib/prometheus_exporter/client.rb
 - lib/prometheus_exporter/instrumentation.rb
+- lib/prometheus_exporter/instrumentation/delayed_job.rb
 - lib/prometheus_exporter/instrumentation/global.rb
 - lib/prometheus_exporter/instrumentation/method_profiler.rb
 - lib/prometheus_exporter/instrumentation/process.rb
@@ -146,6 +161,7 @@ files:
 - lib/prometheus_exporter/server.rb
 - lib/prometheus_exporter/server/collector.rb
 - lib/prometheus_exporter/server/collector_base.rb
+- lib/prometheus_exporter/server/delayed_job_collector.rb
 - lib/prometheus_exporter/server/process_collector.rb
 - lib/prometheus_exporter/server/runner.rb
 - lib/prometheus_exporter/server/sidekiq_collector.rb
@@ -166,7 +182,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -174,7 +190,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Prometheus Exporter