prometheus_exporter 0.7.0 → 2.3.0

data/lib/prometheus_exporter/server/sidekiq_stats_collector.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module PrometheusExporter::Server
+  class SidekiqStatsCollector < TypeCollector
+    MAX_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 = MetricsContainer.new(ttl: MAX_METRIC_AGE)
+      @gauges = {}
+    end
+
+    def type
+      "sidekiq_stats"
+    end
+
+    def metrics
+      SIDEKIQ_STATS_GAUGES.each_key { |name| gauges[name]&.reset! }
+
+      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/type_collector.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "prometheus_exporter/server/metrics_container"
+
 module PrometheusExporter::Server
   class TypeCollector
     def type

data/lib/prometheus_exporter/server/unicorn_collector.rb

@@ -2,47 +2,46 @@
 
 # custom type collector for prometheus_exporter for handling the metrics sent from
 # PrometheusExporter::Instrumentation::Unicorn
-class PrometheusExporter::Server::UnicornCollector < PrometheusExporter::Server::TypeCollector
-  MAX_UNICORN_METRIC_AGE = 60
-
-  UNICORN_GAUGES = {
-    workers_total: 'Number of unicorn workers.',
-    active_workers_total: 'Number of active unicorn workers',
-    request_backlog_total: 'Number of requests waiting to be processed by a unicorn worker.'
-  }.freeze
-
-  def initialize
-    @unicorn_metrics = []
-  end
+module PrometheusExporter::Server
+  class UnicornCollector < PrometheusExporter::Server::TypeCollector
+    MAX_METRIC_AGE = 60
+
+    UNICORN_GAUGES = {
+      workers: "Number of unicorn workers.",
+      active_workers: "Number of active unicorn workers",
+      request_backlog: "Number of requests waiting to be processed by a unicorn worker.",
+    }.freeze
+
+    def initialize
+      @unicorn_metrics = MetricsContainer.new(ttl: MAX_METRIC_AGE)
+    end
 
-  def type
-    'unicorn'
-  end
+    def type
+      "unicorn"
+    end
 
-  def metrics
-    return [] if @unicorn_metrics.length.zero?
+    def metrics
+      return [] if @unicorn_metrics.length.zero?
 
-    metrics = {}
+      metrics = {}
 
-    @unicorn_metrics.map do |m|
-      labels = m["custom_labels"] || {}
+      @unicorn_metrics.map do |m|
+        labels = m["custom_labels"] || {}
 
-      UNICORN_GAUGES.map do |k, help|
-        k = k.to_s
-        if (v = m[k])
-          g = metrics[k] ||= PrometheusExporter::Metric::Gauge.new("unicorn_#{k}", help)
-          g.observe(v, labels)
+        UNICORN_GAUGES.map do |k, help|
+          k = k.to_s
+          if (v = m[k])
+            g = metrics[k] ||= PrometheusExporter::Metric::Gauge.new("unicorn_#{k}", help)
+            g.observe(v, labels)
+          end
         end
       end
-    end
 
-    metrics.values
-  end
+      metrics.values
+    end
 
-  def collect(obj)
-    now = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-    obj["created_at"] = now
-    @unicorn_metrics.delete_if { |m| m['created_at'] + MAX_UNICORN_METRIC_AGE < now }
-    @unicorn_metrics << obj
+    def collect(obj)
+      @unicorn_metrics << obj
+    end
   end
 end

data/lib/prometheus_exporter/server/web_collector.rb

@@ -5,10 +5,11 @@ 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
+      @http_request_memcache_duration_seconds = nil
     end
 
     def type
@@ -28,51 +29,67 @@ module PrometheusExporter::Server
 
     def ensure_metrics
       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_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."
-        )
+        @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::Summary.new(
-          "http_redis_duration_seconds",
-          "Time spent in HTTP reqs in Redis, in 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::Summary.new(
-          "http_sql_duration_seconds",
-          "Time spent in HTTP reqs in SQL in 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::Summary.new(
-          "http_queue_duration_seconds",
-          "Time spent queueing the request in load balancer in seconds."
-        )
+        @metrics[
+          "http_request_memcache_duration_seconds"
+        ] = @http_request_memcache_duration_seconds =
+          PrometheusExporter::Metric::Base.default_aggregation.new(
+            "http_request_memcache_duration_seconds",
+            "Time spent in HTTP reqs in Memcache in 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
     end
 
     def observe(obj)
-      default_labels = obj['default_labels']
-      custom_labels = obj['custom_labels']
+      default_labels = obj["default_labels"]
+      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
+        if memcache = timings["memcache"]
+          @http_request_memcache_duration_seconds.observe(memcache["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/web_server.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require 'webrick'
-require 'timeout'
-require 'zlib'
-require 'stringio'
+require "webrick"
+require "timeout"
+require "zlib"
+require "stringio"
 
 module PrometheusExporter::Server
   class WebServer
@@ -12,47 +12,67 @@ module PrometheusExporter::Server
     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.")
+      @metrics_total =
+        PrometheusExporter::Metric::Counter.new(
+          "collector_metrics_total",
+          "Total metrics processed by exporter web.",
+        )
 
-      @sessions_total = PrometheusExporter::Metric::Counter.new("collector_sessions_total", "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.",
+        )
 
-      @bad_metrics_total = PrometheusExporter::Metric::Counter.new("collector_bad_metrics_total", "Total mis-handled metrics by collector.")
+      @bad_metrics_total =
+        PrometheusExporter::Metric::Counter.new(
+          "collector_bad_metrics_total",
+          "Total mis-handled metrics by collector.",
+        )
 
       @metrics_total.observe(0)
       @sessions_total.observe(0)
       @bad_metrics_total.observe(0)
 
       @access_log, @logger = nil
+      log_target = opts[:log_target]
 
       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(log_target || $stderr)
       else
         @access_log = []
-        @logger = WEBrick::Log.new("/dev/null")
+        @logger = WEBrick::Log.new(log_target || "/dev/null")
       end
 
       @logger.info "Using Basic Authentication via #{@auth}" if @verbose && @auth
 
-      @server = WEBrick::HTTPServer.new(
-        Port: @port,
-        BindAddress: @bind,
-        Logger: @logger,
-        AccessLog: @access_log,
-      )
+      if %w[ALL ANY].include?(@bind)
+        @logger.info "Listening on both 0.0.0.0/:: network interfaces"
+        @bind = nil
+      end
+
+      @collector = opts[:collector] || Collector.new(logger: @logger)
 
-      @server.mount_proc '/' do |req, res|
-        res['Content-Type'] = 'text/plain; charset=utf-8'
-        if req.path == '/metrics'
+      @server =
+        WEBrick::HTTPServer.new(
+          Port: @port,
+          BindAddress: @bind,
+          Logger: @logger,
+          AccessLog: @access_log,
+        )
+
+      @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
@@ -70,11 +90,14 @@ module PrometheusExporter::Server
           else
             res.body = metrics
           end
-        elsif req.path == '/send-metrics'
+        elsif req.path == "/send-metrics"
           handle_metrics(req, res)
+        elsif req.path == "/ping"
+          res.body = "PONG"
         else
           res.status = 404
-          res.body = "Not Found! The Prometheus Ruby Exporter only listens on /metrics and /send-metrics"
+          res.body =
+            "Not Found! The Prometheus Ruby Exporter only listens on /ping, /metrics and /send-metrics"
         end
       end
     end
@@ -86,16 +109,11 @@ module PrometheusExporter::Server
           @metrics_total.observe
           @collector.process(block)
         rescue => e
-          if @verbose
-            STDERR.puts
-            STDERR.puts e.inspect
-            STDERR.puts e.backtrace
-            STDERR.puts
-          end
+          @logger.error "\n\n#{e.inspect}\n#{e.backtrace}\n\n" if @verbose
           @bad_metrics_total.observe
           res.body = "Bad Metrics #{e}"
           res.status = e.respond_to?(:status_code) ? e.status_code : 500
-          return
+          break
         end
       end
 
@@ -104,13 +122,14 @@ module PrometheusExporter::Server
     end
 
     def start
-      @runner ||= Thread.start do
-        begin
-          @server.start
-        rescue => e
-          STDERR.puts "Failed to start prometheus collector web on port #{@port}: #{e}"
+      @runner ||=
+        Thread.start do
+          begin
+            @server.start
+          rescue => e
+            @logger.error "Failed to start prometheus collector web on port #{@port}: #{e}"
+          end
         end
-      end
     end
 
     def stop
@@ -120,12 +139,10 @@ module PrometheusExporter::Server
     def metrics
       metric_text = nil
       begin
-        Timeout::timeout(@timeout) do
-          metric_text = @collector.prometheus_metrics_text
-        end
+        Timeout.timeout(@timeout) { metric_text = @collector.prometheus_metrics_text }
       rescue Timeout::Error
         # we timed out ... bummer
-        STDERR.puts "Generating Prometheus metrics text timed out"
+        @logger.error "Generating Prometheus metrics text timed out"
       end
 
       metrics = []
@@ -133,14 +150,10 @@ module PrometheusExporter::Server
       metrics << add_gauge(
         "collector_working",
         "Is the master process collector able to collect metrics",
-        metric_text && metric_text.length > 0 ? 1 : 0
+        metric_text && metric_text.length > 0 ? 1 : 0,
       )
 
-      metrics << add_gauge(
-        "collector_rss",
-        "total memory used by collector process",
-        get_rss
-      )
+      metrics << add_gauge("collector_rss", "total memory used by collector process", get_rss)
 
       metrics << @metrics_total
       metrics << @sessions_total
@@ -153,9 +166,18 @@ module PrometheusExporter::Server
     end
 
     def get_rss
-      @pagesize ||= `getconf PAGESIZE`.to_i rescue 4096
+      @pagesize ||=
+        begin
+          `getconf PAGESIZE`.to_i
+        rescue StandardError
+          4096
+        end
       @pid ||= Process.pid
-      File.read("/proc/#{@pid}/statm").split(' ')[1].to_i * @pagesize rescue 0
+      begin
+        File.read("/proc/#{@pid}/statm").split(" ")[1].to_i * @pagesize
+      rescue StandardError
+        0
+      end
     end
 
     def add_gauge(name, help, value)
@@ -166,10 +188,10 @@ module PrometheusExporter::Server
 
     def authenticate(req, res)
       htpasswd = WEBrick::HTTPAuth::Htpasswd.new(@auth)
-      basic_auth = WEBrick::HTTPAuth::BasicAuth.new({ Realm: @realm, UserDB: htpasswd, Logger: @logger })
+      basic_auth =
+        WEBrick::HTTPAuth::BasicAuth.new({ Realm: @realm, UserDB: htpasswd, Logger: @logger })
 
       basic_auth.authenticate(req, res)
     end
-
   end
 end

data/lib/prometheus_exporter/server.rb

@@ -6,6 +6,8 @@ require_relative "server/web_collector"
 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"
@@ -16,3 +18,5 @@ require_relative "server/hutch_collector"
 require_relative "server/unicorn_collector"
 require_relative "server/active_record_collector"
 require_relative "server/shoryuken_collector"
+require_relative "server/resque_collector"
+require_relative "server/good_job_collector"

data/lib/prometheus_exporter/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PrometheusExporter
-  VERSION = '0.7.0'
+  VERSION = "2.3.0"
 end

data/lib/prometheus_exporter.rb

@@ -2,21 +2,21 @@
 
 require_relative "prometheus_exporter/version"
 require "json"
-require "thread"
 
 module PrometheusExporter
   # per: https://github.com/prometheus/prometheus/wiki/Default-port-allocations
   DEFAULT_PORT = 9394
-  DEFAULT_BIND_ADDRESS = 'localhost'
-  DEFAULT_PREFIX = 'ruby_'
+  DEFAULT_BIND_ADDRESS = "localhost"
+  DEFAULT_PREFIX = "ruby_"
   DEFAULT_LABEL = {}
   DEFAULT_TIMEOUT = 2
-  DEFAULT_REALM = 'Prometheus Exporter'
+  DEFAULT_REALM = "Prometheus Exporter"
 
   class OjCompat
     def self.parse(obj)
       Oj.compat_load(obj)
     end
+
     def self.dump(obj)
       Oj.dump(obj, mode: :compat)
     end
@@ -25,7 +25,7 @@ module PrometheusExporter
   def self.hostname
     @hostname ||=
       begin
-        require 'socket'
+        require "socket"
         Socket.gethostname
       rescue => e
         STDERR.puts "Unable to lookup hostname #{e}"
@@ -45,13 +45,12 @@ module PrometheusExporter
   def self.has_oj?
     (
       @@has_oj ||=
-       begin
-         require 'oj'
-         :true
-       rescue LoadError
-         :false
-       end
-    ) == :true
+        begin
+          require "oj"
+          :T
+        rescue LoadError
+          :F
+        end
+    ) == :T
   end
-
 end