prometheus_exporter 0.4.17 → 0.6.0

data/lib/prometheus_exporter/metric/summary.rb

@@ -32,6 +32,13 @@ module PrometheusExporter::Metric
       data
     end
 
+    def remove(labels)
+      @counts.delete(labels)
+      @sums.delete(labels)
+      @buffers[0].delete(labels)
+      @buffers[1].delete(labels)
+    end
+
     def type
       "summary"
     end

data/lib/prometheus_exporter/middleware.rb

@@ -44,14 +44,25 @@ class PrometheusExporter::Middleware
       controller = params["controller"]
     end
 
-    @client.send_json(
+    obj = {
       type: "web",
       timings: info,
       queue_time: queue_time,
       action: action,
       controller: controller,
       status: status
-    )
+    }
+    labels = custom_labels(env)
+    if labels
+      obj = obj.merge(custom_labels: labels)
+    end
+
+    @client.send_json(obj)
+  end
+
+  # allows subclasses to add custom labels based on env
+  def custom_labels(env)
+    nil
   end
 
   private

data/lib/prometheus_exporter/server.rb

@@ -5,6 +5,7 @@ require_relative "server/type_collector"
 require_relative "server/web_collector"
 require_relative "server/process_collector"
 require_relative "server/sidekiq_collector"
+require_relative "server/sidekiq_queue_collector"
 require_relative "server/delayed_job_collector"
 require_relative "server/collector_base"
 require_relative "server/collector"
@@ -14,3 +15,4 @@ require_relative "server/puma_collector"
 require_relative "server/hutch_collector"
 require_relative "server/unicorn_collector"
 require_relative "server/active_record_collector"
+require_relative "server/shoryuken_collector"

data/lib/prometheus_exporter/server/active_record_collector.rb

@@ -27,6 +27,7 @@ module PrometheusExporter::Server
 
       @active_record_metrics.map do |m|
         metric_key = (m["metric_labels"] || {}).merge("pid" => m["pid"])
+        metric_key.merge!(m["custom_labels"]) if m["custom_labels"]
 
         ACTIVE_RECORD_GAUGES.map do |k, help|
           k = k.to_s

data/lib/prometheus_exporter/server/collector.rb

@@ -13,11 +13,13 @@ module PrometheusExporter::Server
       register_collector(WebCollector.new)
       register_collector(ProcessCollector.new)
       register_collector(SidekiqCollector.new)
+      register_collector(SidekiqQueueCollector.new)
       register_collector(DelayedJobCollector.new)
       register_collector(PumaCollector.new)
       register_collector(HutchCollector.new)
       register_collector(UnicornCollector.new)
       register_collector(ActiveRecordCollector.new)
+      register_collector(ShoryukenCollector.new)
     end
 
     def register_collector(collector)

data/lib/prometheus_exporter/server/delayed_job_collector.rb

@@ -2,6 +2,17 @@
 
 module PrometheusExporter::Server
   class DelayedJobCollector < TypeCollector
+    def initialize
+      @delayed_jobs_total = nil
+      @delayed_job_duration_seconds = nil
+      @delayed_jobs_total = nil
+      @delayed_failed_jobs_total = nil
+      @delayed_jobs_max_attempts_reached_total = nil
+      @delayed_job_duration_seconds_summary = nil
+      @delayed_job_attempts_summary = nil
+      @delayed_jobs_enqueued = nil
+      @delayed_jobs_pending = nil
+    end
 
     def type
       "delayed_job"

data/lib/prometheus_exporter/server/hutch_collector.rb

@@ -2,6 +2,12 @@
 
 module PrometheusExporter::Server
   class HutchCollector < TypeCollector
+    def initialize
+      @hutch_jobs_total = nil
+      @hutch_job_duration_seconds = nil
+      @hutch_jobs_total = nil
+      @hutch_failed_jobs_total = nil
+    end
 
     def type
       "hutch"

data/lib/prometheus_exporter/server/runner.rb

@@ -9,6 +9,15 @@ module PrometheusExporter::Server
 
   class Runner
     def initialize(options = {})
+      @timeout = nil
+      @port = nil
+      @bind = nil
+      @collector_class = nil
+      @type_collectors = nil
+      @prefix = nil
+      @auth = nil
+      @realm = nil
+
       options.each do |k, v|
         send("#{k}=", v) if self.class.method_defined?("#{k}=")
       end
@@ -16,6 +25,7 @@ module PrometheusExporter::Server
 
     def start
       PrometheusExporter::Metric::Base.default_prefix = prefix
+      PrometheusExporter::Metric::Base.default_labels = label
 
       register_type_collectors
 
@@ -32,73 +42,62 @@ module PrometheusExporter::Server
         )
       end
 
-      server = server_class.new port: port, collector: collector, timeout: timeout, verbose: verbose
+      server = server_class.new(port: port, bind: bind, collector: collector, timeout: timeout, verbose: verbose, auth: auth, realm: realm)
       server.start
     end
 
-    def prefix=(prefix)
-      @prefix = prefix
+    attr_accessor :unicorn_listen_address, :unicorn_pid_file
+    attr_writer :prefix, :port, :bind, :collector_class, :type_collectors, :timeout, :verbose, :server_class, :label, :auth, :realm
+
+    def auth
+      @auth || nil
     end
 
-    def prefix
-      @prefix || PrometheusExporter::DEFAULT_PREFIX
+    def realm
+      @realm || PrometheusExporter::DEFAULT_REALM
     end
 
-    def port=(port)
-      @port = port
+    def prefix
+      @prefix || PrometheusExporter::DEFAULT_PREFIX
     end
 
     def port
       @port || PrometheusExporter::DEFAULT_PORT
     end
 
-    def collector_class=(collector_class)
-      @collector_class = collector_class
+    def bind
+      @bind || PrometheusExporter::DEFAULT_BIND_ADDRESS
     end
 
     def collector_class
       @collector_class || PrometheusExporter::Server::Collector
     end
 
-    def type_collectors=(type_collectors)
-      @type_collectors = type_collectors
-    end
-
     def type_collectors
       @type_collectors || []
     end
 
-    def timeout=(timeout)
-      @timeout = timeout
-    end
-
     def timeout
       @timeout || PrometheusExporter::DEFAULT_TIMEOUT
     end
 
-    def verbose=(verbose)
-      @verbose = verbose
-    end
-
     def verbose
       return @verbose if defined? @verbose
       false
     end
 
-    def server_class=(server_class)
-      @server_class = server_class
-    end
-
     def server_class
       @server_class || PrometheusExporter::Server::WebServer
     end
 
-    attr_accessor :unicorn_listen_address, :unicorn_pid_file
-
     def collector
       @_collector ||= collector_class.new
     end
 
+    def label
+      @label ||= PrometheusExporter::DEFAULT_LABEL
+    end
+
     private
 
     def register_type_collectors

data/lib/prometheus_exporter/server/shoryuken_collector.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module PrometheusExporter::Server
+  class ShoryukenCollector < TypeCollector
+
+    def initialize
+      @shoryuken_jobs_total = nil
+      @shoryuken_job_duration_seconds = nil
+      @shoryuken_jobs_total = nil
+      @shoryuken_restarted_jobs_total = nil
+      @shoryuken_failed_jobs_total = nil
+    end
+
+    def type
+      "shoryuken"
+    end
+
+    def collect(obj)
+      default_labels = { job_name: obj['name'] , queue_name: obj['queue'] }
+      custom_labels = obj['custom_labels']
+      labels = custom_labels.nil? ? default_labels : default_labels.merge(custom_labels)
+
+      ensure_shoryuken_metrics
+      @shoryuken_job_duration_seconds.observe(obj["duration"], labels)
+      @shoryuken_jobs_total.observe(1, labels)
+      @shoryuken_restarted_jobs_total.observe(1, labels) if obj["shutdown"]
+      @shoryuken_failed_jobs_total.observe(1, labels) if !obj["success"] && !obj["shutdown"]
+    end
+
+    def metrics
+      if @shoryuken_jobs_total
+        [
+            @shoryuken_job_duration_seconds,
+            @shoryuken_jobs_total,
+            @shoryuken_restarted_jobs_total,
+            @shoryuken_failed_jobs_total,
+        ]
+      else
+        []
+      end
+    end
+
+    protected
+
+    def ensure_shoryuken_metrics
+      if !@shoryuken_jobs_total
+
+        @shoryuken_job_duration_seconds =
+            PrometheusExporter::Metric::Counter.new(
+                "shoryuken_job_duration_seconds", "Total time spent in shoryuken jobs.")
+
+        @shoryuken_jobs_total =
+            PrometheusExporter::Metric::Counter.new(
+                "shoryuken_jobs_total", "Total number of shoryuken jobs executed.")
+
+        @shoryuken_restarted_jobs_total =
+            PrometheusExporter::Metric::Counter.new(
+                "shoryuken_restarted_jobs_total", "Total number of shoryuken jobs that we restarted because of a shoryuken shutdown.")
+
+        @shoryuken_failed_jobs_total =
+            PrometheusExporter::Metric::Counter.new(
+                "shoryuken_failed_jobs_total", "Total number of failed shoryuken jobs.")
+
+      end
+    end
+  end
+end

data/lib/prometheus_exporter/server/sidekiq_collector.rb

@@ -3,12 +3,21 @@
 module PrometheusExporter::Server
   class SidekiqCollector < TypeCollector
 
+    def initialize
+      @sidekiq_jobs_total = nil
+      @sidekiq_job_duration_seconds = nil
+      @sidekiq_jobs_total = nil
+      @sidekiq_restarted_jobs_total = nil
+      @sidekiq_failed_jobs_total = nil
+      @sidekiq_dead_jobs_total = nil
+    end
+
     def type
       "sidekiq"
     end
 
     def collect(obj)
-      default_labels = { job_name: obj['name'] }
+      default_labels = { job_name: obj['name'], queue: obj['queue'] }
       custom_labels = obj['custom_labels']
       labels = custom_labels.nil? ? default_labels : default_labels.merge(custom_labels)
 
@@ -43,7 +52,7 @@ module PrometheusExporter::Server
       if !@sidekiq_jobs_total
 
         @sidekiq_job_duration_seconds =
-        PrometheusExporter::Metric::Counter.new(
+        PrometheusExporter::Metric::Summary.new(
           "sidekiq_job_duration_seconds", "Total time spent in sidekiq jobs.")
 
         @sidekiq_jobs_total =

data/lib/prometheus_exporter/server/sidekiq_queue_collector.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+module PrometheusExporter::Server
+  class SidekiqQueueCollector < TypeCollector
+    MAX_SIDEKIQ_METRIC_AGE = 60
+
+    SIDEKIQ_QUEUE_GAUGES = {
+      'backlog_total' => 'Size of the sidekiq queue.',
+      'latency_seconds' => 'Latency of the sidekiq queue.',
+    }.freeze
+
+    attr_reader :sidekiq_metrics, :gauges
+
+    def initialize
+      @sidekiq_metrics = []
+      @gauges = {}
+    end
+
+    def type
+      'sidekiq_queue'
+    end
+
+    def metrics
+      sidekiq_metrics.map do |metric|
+        labels = metric.fetch("labels", {})
+        SIDEKIQ_QUEUE_GAUGES.map do |name, help|
+          if (value = metric[name])
+            gauge = gauges[name] ||= PrometheusExporter::Metric::Gauge.new("sidekiq_queue_#{name}", help)
+            gauge.observe(value, labels)
+          end
+        end
+      end
+
+      gauges.values
+    end
+
+    def collect(object)
+      now = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      object['queues'].each do |queue|
+        queue["created_at"] = now
+        queue["labels"].merge!(object['custom_labels']) if object['custom_labels']
+        sidekiq_metrics.delete_if { |metric| metric['created_at'] + MAX_SIDEKIQ_METRIC_AGE < now }
+        sidekiq_metrics << queue
+      end
+    end
+  end
+end

data/lib/prometheus_exporter/server/web_collector.rb

@@ -4,6 +4,11 @@ module PrometheusExporter::Server
   class WebCollector < TypeCollector
     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
     end
 
     def type

data/lib/prometheus_exporter/server/web_server.rb

@@ -9,9 +9,14 @@ module PrometheusExporter::Server
   class WebServer
     attr_reader :collector
 
-    def initialize(port: , collector: nil, timeout: PrometheusExporter::DEFAULT_TIMEOUT, verbose: false)
-
-      @verbose = verbose
+    def initialize(opts)
+      @port = opts[:port] || PrometheusExporter::DEFAULT_PORT
+      @bind = opts[:bind] || PrometheusExporter::DEFAULT_BIND_ADDRESS
+      @collector = opts[:collector] || Collector.new
+      @timeout = opts[:timeout] || PrometheusExporter::DEFAULT_TIMEOUT
+      @verbose = opts[:verbose] || false
+      @auth = opts[:auth]
+      @realm = opts[:realm] || PrometheusExporter::DEFAULT_REALM
 
       @metrics_total = PrometheusExporter::Metric::Counter.new("collector_metrics_total", "Total metrics processed by exporter web.")
 
@@ -23,32 +28,33 @@ module PrometheusExporter::Server
       @sessions_total.observe(0)
       @bad_metrics_total.observe(0)
 
-      access_log, logger = nil
+      @access_log, @logger = nil
 
-      if verbose
-        access_log = [
+      if @verbose
+        @access_log = [
           [$stderr, WEBrick::AccessLog::COMMON_LOG_FORMAT],
           [$stderr, WEBrick::AccessLog::REFERER_LOG_FORMAT],
         ]
-        logger = WEBrick::Log.new($stderr)
+        @logger = WEBrick::Log.new($stderr)
       else
-        access_log = []
-        logger = WEBrick::Log.new("/dev/null")
+        @access_log = []
+        @logger = WEBrick::Log.new("/dev/null")
       end
 
+      @logger.info "Using Basic Authentication via #{@auth}" if @verbose && @auth
+
       @server = WEBrick::HTTPServer.new(
-        Port: port,
-        Logger: logger,
-        AccessLog: access_log,
+        Port: @port,
+        BindAddress: @bind,
+        Logger: @logger,
+        AccessLog: @access_log,
       )
 
-      @collector = collector || Collector.new
-      @port = port
-      @timeout = timeout
-
       @server.mount_proc '/' do |req, res|
         res['Content-Type'] = 'text/plain; charset=utf-8'
         if req.path == '/metrics'
+          authenticate(req, res) if @auth
+
           res.status = 200
           if req.header["accept-encoding"].to_s.include?("gzip")
             sio = StringIO.new
@@ -158,5 +164,12 @@ module PrometheusExporter::Server
       gauge
     end
 
+    def authenticate(req, res)
+      htpasswd = WEBrick::HTTPAuth::Htpasswd.new(@auth)
+      basic_auth = WEBrick::HTTPAuth::BasicAuth.new({ Realm: @realm, UserDB: htpasswd, Logger: @logger })
+
+      basic_auth.authenticate(req, res)
+    end
+
   end
 end