prometheus_exporter 2.0.2 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5cd7d7181c0dcb2e26efe99605bd72e6f4747394018a74b8eee93a126a10c2ee
-  data.tar.gz: 94d70aa9f50ef97fee06ed8fa5963588ba55ee98ab702d50136abbbba18b9f56
+  metadata.gz: 07f116c0fdf15835af1b9520ca81b47c1d7a6011b3b8991cf9b569127d7a22fc
+  data.tar.gz: f631d2d3259d72577e896a4f2a650f7af65e70b5703f24a02cbcebadd75f97d1
 SHA512:
-  metadata.gz: 26c52753448d360c229e0827a08f42e8bcc3cbd602caf7c530d0f7306b1c0d848a8604aa2959115c97aae1eaf41ebf1b1b8bad1735ddf89a11c7d4174d62c71c
-  data.tar.gz: c80255a6d646371390f2f3157b736878a1a2df6b0a45c0905ec518debf4fe33f1a4dfaa02203f24141132991ef1f570114417120b25b37d949b0c343da7448bf
+  metadata.gz: 81894939793a45953be6efbf90db9506abb6cc5ca196e03fd0bfe92035430284240820e1311e3f9532933602fa337790eb828e99809f003378cb6290b74f1eba
+  data.tar.gz: 151c49417eee04b2f9b931d9bda160fd19df22d2d9ff474f2f54b57bc828504eaf2d2f047eae2be1f121ce4d0b3ed74e9695959bcd51da8a52949da8a3931604

data/CHANGELOG

@@ -1,3 +1,9 @@
+2.0.3 - 2022-05-23
+
+- FEATURE: new ping endpoint for keepalive checks
+- FIX: order histogram correctly for GCP support
+- FIX: improve sidekiq instrumentation
+
 2.0.2 - 2022-02-25
 
 - FIX: runner was not requiring unicorn integration correctly leading to a crash

data/README.md

@@ -201,6 +201,14 @@ Ensure you run the exporter in a monitored background process:
 $ bundle exec prometheus_exporter
 ```
 
+#### Choosing the style of method patching
+
+By default, `prometheus_exporter` uses `alias_method` to instrument methods used by SQL and Redis as it is the fastest approach (see [this article](https://samsaffron.com/archive/2017/10/18/fastest-way-to-profile-a-method-in-ruby)). You may desire to add additional instrumentation libraries beyond `prometheus_exporter` to your app. This can become problematic if these other libraries instead use `prepend` to instrument methods. To resolve this, you can tell the middleware to instrument using `prepend` by passing an `instrument` option like so:
+
+```ruby
+Rails.application.middleware.unshift PrometheusExporter::Middleware, instrument: :prepend
+```
+
 #### Metrics collected by Rails integration middleware
 
 | Type    | Name                                   | Description                                                 |
@@ -952,6 +960,26 @@ You can also pass a log level (default is [`Logger::WARN`](https://ruby-doc.org/
 PrometheusExporter::Client.new(log_level: Logger::DEBUG)
 ```
 
+## Docker/Kubernetes Healthcheck
+
+A `/ping` endpoint which only returns `PONG` is available so you can run container healthchecks :
+
+Example:
+
+```yml
+services:
+  rails-exporter:
+    command:
+      - bin/prometheus_exporter
+      - -b
+      - 0.0.0.0
+    healthcheck:
+      test: ["CMD", "curl", "--silent", "--show-error", "--fail", "--max-time", "3", "http://0.0.0.0:9394/ping"]
+      timeout: 3s
+      interval: 10s
+      retries: 5
+```
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/discourse/prometheus_exporter. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

data/lib/prometheus_exporter/instrumentation/method_profiler.rb

@@ -4,30 +4,14 @@
 module PrometheusExporter::Instrumentation; end
 
 class PrometheusExporter::Instrumentation::MethodProfiler
-  def self.patch(klass, methods, name)
-    patch_source_line = __LINE__ + 3
-    patches = methods.map do |method_name|
-      <<~RUBY
-      unless defined?(#{method_name}__mp_unpatched)
-        alias_method :#{method_name}__mp_unpatched, :#{method_name}
-        def #{method_name}(*args, &blk)
-          unless prof = Thread.current[:_method_profiler]
-            return #{method_name}__mp_unpatched(*args, &blk)
-          end
-          begin
-            start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-            #{method_name}__mp_unpatched(*args, &blk)
-          ensure
-            data = (prof[:#{name}] ||= {duration: 0.0, calls: 0})
-            data[:duration] += Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
-            data[:calls] += 1
-          end
-        end
-      end
-      RUBY
-    end.join("\n")
-
-    klass.class_eval patches, __FILE__, patch_source_line
+  def self.patch(klass, methods, name, instrument:)
+    if instrument == :alias_method
+      patch_using_alias_method(klass, methods, name)
+    elsif instrument == :prepend
+      patch_using_prepend(klass, methods, name)
+    else
+      raise ArgumentError, "instrument must be :alias_method or :prepend"
+    end
   end
 
   def self.transfer
@@ -55,4 +39,57 @@ class PrometheusExporter::Instrumentation::MethodProfiler
     end
     data
   end
+
+private
+
+  def self.patch_using_prepend(klass, methods, name)
+    prepend_instument = Module.new
+    patch_source_line = __LINE__ + 3
+    patches = methods.map do |method_name|
+      <<~RUBY
+        def #{method_name}(*args, &blk)
+          unless prof = Thread.current[:_method_profiler]
+            return super
+          end
+          begin
+            start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            super
+          ensure
+            data = (prof[:#{name}] ||= {duration: 0.0, calls: 0})
+            data[:duration] += Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+            data[:calls] += 1
+          end
+        end
+      RUBY
+    end.join("\n")
+
+    prepend_instument.module_eval patches, __FILE__, patch_source_line
+    klass.prepend(prepend_instument)
+  end
+
+  def self.patch_using_alias_method(klass, methods, name)
+    patch_source_line = __LINE__ + 3
+    patches = methods.map do |method_name|
+      <<~RUBY
+      unless defined?(#{method_name}__mp_unpatched)
+        alias_method :#{method_name}__mp_unpatched, :#{method_name}
+        def #{method_name}(*args, &blk)
+          unless prof = Thread.current[:_method_profiler]
+            return #{method_name}__mp_unpatched(*args, &blk)
+          end
+          begin
+            start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            #{method_name}__mp_unpatched(*args, &blk)
+          ensure
+            data = (prof[:#{name}] ||= {duration: 0.0, calls: 0})
+            data[:duration] += Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+            data[:calls] += 1
+          end
+        end
+      end
+      RUBY
+    end.join("\n")
+
+    klass.class_eval patches, __FILE__, patch_source_line
+  end
 end

data/lib/prometheus_exporter/instrumentation/sidekiq.rb

@@ -16,12 +16,12 @@ module PrometheusExporter::Instrumentation
         job_is_fire_and_forget = job["retry"] == false
 
         worker_class = Object.const_get(job["class"])
-        worker_custom_labels = self.get_worker_custom_labels(worker_class)
+        worker_custom_labels = self.get_worker_custom_labels(worker_class, job)
 
         unless job_is_fire_and_forget
           PrometheusExporter::Client.default.send_json(
             type: "sidekiq",
-            name: job["class"],
+            name: get_name(job["class"], job),
             dead: true,
             custom_labels: worker_custom_labels
           )
@@ -29,12 +29,21 @@ module PrometheusExporter::Instrumentation
       end
     end
 
-    def self.get_worker_custom_labels(worker_class)
-      worker_class.respond_to?(:custom_labels) ? worker_class.custom_labels : {}
+    def self.get_worker_custom_labels(worker_class, msg)
+      return {} unless worker_class.respond_to?(:custom_labels)
+
+      # TODO remove when version 3.0.0 is released
+      method_arity = worker_class.method(:custom_labels).arity
+
+      if method_arity > 0
+        worker_class.custom_labels(msg)
+      else
+        worker_class.custom_labels
+      end
     end
 
-    def initialize(client: nil)
-      @client = client || PrometheusExporter::Client.default
+    def initialize(options = { client: nil })
+      @client = options.fetch(:client, nil) || PrometheusExporter::Client.default
     end
 
     def call(worker, msg, queue)
@@ -51,19 +60,18 @@ module PrometheusExporter::Instrumentation
       duration = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start
       @client.send_json(
         type: "sidekiq",
-        name: get_name(worker, msg),
+        name: self.class.get_name(worker.class.to_s, msg),
         queue: queue,
         success: success,
         shutdown: shutdown,
         duration: duration,
-        custom_labels: self.class.get_worker_custom_labels(worker.class)
+        custom_labels: self.class.get_worker_custom_labels(worker.class, msg)
       )
     end
 
     private
 
-    def get_name(worker, msg)
-      class_name = worker.class.to_s
+    def self.get_name(class_name, msg)
       if class_name == JOB_WRAPPER_CLASS_NAME
         get_job_wrapper_name(msg)
       elsif DELAYED_CLASS_NAMES.include?(class_name)
@@ -73,11 +81,11 @@ module PrometheusExporter::Instrumentation
       end
     end
 
-    def get_job_wrapper_name(msg)
+    def self.get_job_wrapper_name(msg)
       msg['wrapped']
     end
 
-    def get_delayed_name(msg, class_name)
+    def self.get_delayed_name(msg, class_name)
       begin
         # fallback to class_name since we're relying on the internal implementation
         # of the delayed extensions

data/lib/prometheus_exporter/metric/histogram.rb

@@ -19,7 +19,7 @@ module PrometheusExporter::Metric
 
     def initialize(name, help, opts = {})
       super(name, help)
-      @buckets = (opts[:buckets] || self.class.default_buckets).sort.reverse
+      @buckets = (opts[:buckets] || self.class.default_buckets).sort
       reset!
     end
 
@@ -57,11 +57,11 @@ module PrometheusExporter::Metric
         first = false
         count = @counts[labels]
         sum = @sums[labels]
-        text << "#{prefix(@name)}_bucket#{labels_text(with_bucket(labels, "+Inf"))} #{count}\n"
         @buckets.each do |bucket|
           value = @observations[labels][bucket]
           text << "#{prefix(@name)}_bucket#{labels_text(with_bucket(labels, bucket.to_s))} #{value}\n"
         end
+        text << "#{prefix(@name)}_bucket#{labels_text(with_bucket(labels, "+Inf"))} #{count}\n"
         text << "#{prefix(@name)}_count#{labels_text(labels)} #{count}\n"
         text << "#{prefix(@name)}_sum#{labels_text(labels)} #{sum}"
       end
@@ -91,7 +91,7 @@ module PrometheusExporter::Metric
     end
 
     def fill_buckets(value, buckets)
-      @buckets.each do |b|
+      @buckets.reverse.each do |b|
         break if value > b
         buckets[b] += 1
       end

data/lib/prometheus_exporter/middleware.rb

@@ -6,23 +6,25 @@ require 'prometheus_exporter/client'
 class PrometheusExporter::Middleware
   MethodProfiler = PrometheusExporter::Instrumentation::MethodProfiler
 
-  def initialize(app, config = { instrument: true, client: nil })
+  def initialize(app, config = { instrument: :alias_method, client: nil })
     @app = app
     @client = config[:client] || PrometheusExporter::Client.default
 
     if config[:instrument]
       if defined? Redis::Client
-        MethodProfiler.patch(Redis::Client, [:call, :call_pipeline], :redis)
+        MethodProfiler.patch(Redis::Client, [
+          :call, :call_pipeline
+        ], :redis, instrument: config[:instrument])
       end
       if defined? PG::Connection
         MethodProfiler.patch(PG::Connection, [
           :exec, :async_exec, :exec_prepared, :send_query_prepared, :query
-        ], :sql)
+        ], :sql, instrument: config[:instrument])
       end
       if defined? Mysql2::Client
-        MethodProfiler.patch(Mysql2::Client, [:query], :sql)
-        MethodProfiler.patch(Mysql2::Statement, [:execute], :sql)
-        MethodProfiler.patch(Mysql2::Result, [:each], :sql)
+        MethodProfiler.patch(Mysql2::Client, [:query], :sql, instrument: config[:instrument])
+        MethodProfiler.patch(Mysql2::Statement, [:execute], :sql, instrument: config[:instrument])
+        MethodProfiler.patch(Mysql2::Result, [:each], :sql, instrument: config[:instrument])
       end
     end
   end

data/lib/prometheus_exporter/server/web_server.rb

@@ -73,9 +73,11 @@ module PrometheusExporter::Server
           end
         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

data/lib/prometheus_exporter/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PrometheusExporter
-  VERSION = '2.0.2'
+  VERSION = '2.0.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prometheus_exporter
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.0.3
 platform: ruby
 authors:
 - Sam Saffron
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-25 00:00:00.000000000 Z
+date: 2022-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: webrick