prometheus-client-mmap 0.20.3-x86_64-linux

data/lib/prometheus/client/push.rb

@@ -0,0 +1,203 @@
+# encoding: UTF-8
+
+require 'base64'
+require 'thread'
+require 'net/http'
+require 'uri'
+require 'erb'
+require 'set'
+
+require 'prometheus/client'
+require 'prometheus/client/formats/text'
+require 'prometheus/client/label_set_validator'
+
+module Prometheus
+  # Client is a ruby implementation for a Prometheus compatible client.
+  module Client
+    # Push implements a simple way to transmit a given registry to a given
+    # Pushgateway.
+    class Push
+      class HttpError < StandardError; end
+      class HttpRedirectError < HttpError; end
+      class HttpClientError < HttpError; end
+      class HttpServerError < HttpError; end
+
+      DEFAULT_GATEWAY = 'http://localhost:9091'.freeze
+      PATH            = '/metrics/job/%s'.freeze
+      SUPPORTED_SCHEMES = %w(http https).freeze
+
+      attr_reader :job, :gateway, :path
+
+      def initialize(job:, gateway: DEFAULT_GATEWAY, grouping_key: {}, **kwargs)
+        raise ArgumentError, "job cannot be nil" if job.nil?
+        raise ArgumentError, "job cannot be empty" if job.empty?
+        @validator = LabelSetValidator.new()
+        @validator.validate(grouping_key)
+
+        @mutex = Mutex.new
+        @job = job
+        @gateway = gateway || DEFAULT_GATEWAY
+        @grouping_key = grouping_key
+        @path = build_path(job, grouping_key)
+
+        @uri = parse("#{@gateway}#{@path}")
+        validate_no_basic_auth!(@uri)
+
+        @http = Net::HTTP.new(@uri.host, @uri.port)
+        @http.use_ssl = (@uri.scheme == 'https')
+        @http.open_timeout = kwargs[:open_timeout] if kwargs[:open_timeout]
+        @http.read_timeout = kwargs[:read_timeout] if kwargs[:read_timeout]
+      end
+
+      def basic_auth(user, password)
+        @user = user
+        @password = password
+      end
+
+      def add(registry)
+        synchronize do
+          request(Net::HTTP::Post, registry)
+        end
+      end
+
+      def replace(registry)
+        synchronize do
+          request(Net::HTTP::Put, registry)
+        end
+      end
+
+      def delete
+        synchronize do
+          request(Net::HTTP::Delete)
+        end
+      end
+
+      private
+
+      def parse(url)
+        uri = URI.parse(url)
+
+        unless SUPPORTED_SCHEMES.include?(uri.scheme)
+          raise ArgumentError, 'only HTTP gateway URLs are supported currently.'
+        end
+
+        uri
+      rescue URI::InvalidURIError => e
+        raise ArgumentError, "#{url} is not a valid URL: #{e}"
+      end
+
+      def build_path(job, grouping_key)
+        path = format(PATH, ERB::Util::url_encode(job))
+
+        grouping_key.each do |label, value|
+          if value.include?('/')
+            encoded_value = Base64.urlsafe_encode64(value)
+            path += "/#{label}@base64/#{encoded_value}"
+          # While it's valid for the urlsafe_encode64 function to return an
+          # empty string when the input string is empty, it doesn't work for
+          # our specific use case as we're putting the result into a URL path
+          # segment. A double slash (`//`) can be normalised away by HTTP
+          # libraries, proxies, and web servers.
+          #
+          # For empty strings, we use a single padding character (`=`) as the
+          # value.
+          #
+          # See the pushgateway docs for more details:
+          #
+          # https://github.com/prometheus/pushgateway/blob/6393a901f56d4dda62cd0f6ab1f1f07c495b6354/README.md#url
+          elsif value.empty?
+            path += "/#{label}@base64/="
+          else
+            path += "/#{label}/#{ERB::Util::url_encode(value)}"
+          end
+        end
+
+        path
+      end
+
+      def request(req_class, registry = nil)
+        validate_no_label_clashes!(registry) if registry
+
+        req = req_class.new(@uri)
+        req.content_type = Formats::Text::CONTENT_TYPE
+        req.basic_auth(@user, @password) if @user
+        req.body = Formats::Text.marshal(registry) if registry
+
+        response = @http.request(req)
+        validate_response!(response)
+
+        response
+      end
+
+      def synchronize
+        @mutex.synchronize { yield }
+      end
+
+      def validate_no_basic_auth!(uri)
+        if uri.user || uri.password
+          raise ArgumentError, <<~EOF
+            Setting Basic Auth credentials in the gateway URL is not supported, please call the `basic_auth` method.
+
+            Received username `#{uri.user}` in gateway URL. Instead of passing
+            Basic Auth credentials like this:
+
+            ```
+            push = Prometheus::Client::Push.new(job: "my-job", gateway: "http://user:password@localhost:9091")
+            ```
+
+            please pass them like this:
+
+            ```
+            push = Prometheus::Client::Push.new(job: "my-job", gateway: "http://localhost:9091")
+            push.basic_auth("user", "password")
+            ```
+
+            While URLs do support passing Basic Auth credentials using the
+            `http://user:password@example.com/` syntax, the username and
+            password in that syntax have to follow the usual rules for URL
+            encoding of characters per RFC 3986
+            (https://datatracker.ietf.org/doc/html/rfc3986#section-2.1).
+
+            Rather than place the burden of correctly performing that encoding
+            on users of this gem, we decided to have a separate method for
+            supplying Basic Auth credentials, with no requirement to URL encode
+            the characters in them.
+          EOF
+        end
+      end
+
+      def validate_no_label_clashes!(registry)
+        # There's nothing to check if we don't have a grouping key
+        return if @grouping_key.empty?
+
+        # We could be doing a lot of comparisons, so let's do them against a
+        # set rather than an array
+        grouping_key_labels = @grouping_key.keys.to_set
+
+        registry.metrics.each do |metric|
+            metric.values.keys.first.keys.each do |label|
+            if grouping_key_labels.include?(label)
+              raise LabelSetValidator::InvalidLabelSetError,
+                "label :#{label} from grouping key collides with label of the " \
+                "same name from metric :#{metric.name} and would overwrite it"
+            end
+          end
+        end
+      end
+
+      def validate_response!(response)
+        status = Integer(response.code)
+        if status >= 300
+          message = "status: #{response.code}, message: #{response.message}, body: #{response.body}"
+          if status <= 399
+            raise HttpRedirectError, message
+          elsif status <= 499
+            raise HttpClientError, message
+          else
+            raise HttpServerError, message
+          end
+        end
+      end
+    end
+  end
+end

data/lib/prometheus/client/rack/collector.rb

@@ -0,0 +1,88 @@
+# encoding: UTF-8
+
+require 'prometheus/client'
+
+module Prometheus
+  module Client
+    module Rack
+      # Collector is a Rack middleware that provides a sample implementation of
+      # a HTTP tracer. The default label builder can be modified to export a
+      # different set of labels per recorded metric.
+      class Collector
+        attr_reader :app, :registry
+
+        def initialize(app, options = {}, &label_builder)
+          @app = app
+          @registry = options[:registry] || Client.registry
+          @label_builder = label_builder || DEFAULT_LABEL_BUILDER
+
+          init_request_metrics
+          init_exception_metrics
+        end
+
+        def call(env) # :nodoc:
+          trace(env) { @app.call(env) }
+        end
+
+        protected
+
+        DEFAULT_LABEL_BUILDER = proc do |env|
+          {
+            method: env['REQUEST_METHOD'].downcase,
+            host:   env['HTTP_HOST'].to_s,
+            path:   env['PATH_INFO'].to_s,
+          }
+        end
+
+        def init_request_metrics
+          @requests = @registry.counter(
+            :http_requests_total,
+            'A counter of the total number of HTTP requests made.',
+          )
+          @durations = @registry.summary(
+            :http_request_duration_seconds,
+            'A summary of the response latency.',
+          )
+          @durations_hist = @registry.histogram(
+            :http_req_duration_seconds,
+            'A histogram of the response latency.',
+          )
+        end
+
+        def init_exception_metrics
+          @exceptions = @registry.counter(
+            :http_exceptions_total,
+            'A counter of the total number of exceptions raised.',
+          )
+        end
+
+        def trace(env)
+          start = Time.now
+          yield.tap do |response|
+            duration = (Time.now - start).to_f
+            record(labels(env, response), duration)
+          end
+        rescue => exception
+          @exceptions.increment(exception: exception.class.name)
+          raise
+        end
+
+        def labels(env, response)
+          @label_builder.call(env).tap do |labels|
+            labels[:code] = response.first.to_s
+          end
+        end
+
+        def record(labels, duration)
+          @requests.increment(labels)
+          @durations.observe(labels, duration)
+          @durations_hist.observe(labels, duration)
+        rescue => exception
+          @exceptions.increment(exception: exception.class.name)
+          raise
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/prometheus/client/rack/exporter.rb

@@ -0,0 +1,96 @@
+# encoding: UTF-8
+
+require 'prometheus/client'
+require 'prometheus/client/formats/text'
+
+module Prometheus
+  module Client
+    module Rack
+      # Exporter is a Rack middleware that provides a sample implementation of
+      # a Prometheus HTTP client API.
+      class Exporter
+        attr_reader :app, :registry, :path
+
+        FORMATS = [Formats::Text].freeze
+        FALLBACK = Formats::Text
+
+        def initialize(app, options = {})
+          @app = app
+          @registry = options[:registry] || Client.registry
+          @path = options[:path] || '/metrics'
+          @acceptable = build_dictionary(FORMATS, FALLBACK)
+        end
+
+        def call(env)
+          if env['PATH_INFO'] == @path
+            format = negotiate(env['HTTP_ACCEPT'], @acceptable)
+            format ? respond_with(format) : not_acceptable(FORMATS)
+          else
+            @app.call(env)
+          end
+        end
+
+        private
+
+        def negotiate(accept, formats)
+          accept = '*/*' if accept.to_s.empty?
+
+          parse(accept).each do |content_type, _|
+            return formats[content_type] if formats.key?(content_type)
+          end
+
+          nil
+        end
+
+        def parse(header)
+          header.to_s.split(/\s*,\s*/).map do |type|
+            attributes = type.split(/\s*;\s*/)
+            quality = extract_quality(attributes)
+
+            [attributes.join('; '), quality]
+          end.sort_by(&:last).reverse
+        end
+
+        def extract_quality(attributes, default = 1.0)
+          quality = default
+
+          attributes.delete_if do |attr|
+            quality = attr.split('q=').last.to_f if attr.start_with?('q=')
+          end
+
+          quality
+        end
+
+        def respond_with(format)
+          response = if Prometheus::Client.configuration.value_class.multiprocess
+                       format.marshal_multiprocess
+                     else
+                       format.marshal
+                     end
+          [
+            200,
+            { 'Content-Type' => format::CONTENT_TYPE },
+            [response],
+          ]
+        end
+
+        def not_acceptable(formats)
+          types = formats.map { |format| format::MEDIA_TYPE }
+
+          [
+            406,
+            { 'Content-Type' => 'text/plain' },
+            ["Supported media types: #{types.join(', ')}"],
+          ]
+        end
+
+        def build_dictionary(formats, fallback)
+          formats.each_with_object('*/*' => fallback) do |format, memo|
+            memo[format::CONTENT_TYPE] = format
+            memo[format::MEDIA_TYPE] = format
+          end
+        end
+      end
+    end
+  end
+end

data/lib/prometheus/client/registry.rb

@@ -0,0 +1,65 @@
+# encoding: UTF-8
+
+require 'thread'
+
+require 'prometheus/client/counter'
+require 'prometheus/client/summary'
+require 'prometheus/client/gauge'
+require 'prometheus/client/histogram'
+
+module Prometheus
+  module Client
+    # Registry
+    class Registry
+      class AlreadyRegisteredError < StandardError; end
+
+      def initialize
+        @metrics = {}
+        @mutex = Mutex.new
+      end
+
+      def register(metric)
+        name = metric.name
+
+        @mutex.synchronize do
+          if exist?(name.to_sym)
+            raise AlreadyRegisteredError, "#{name} has already been registered"
+          else
+            @metrics[name.to_sym] = metric
+          end
+        end
+
+        metric
+      end
+
+      def counter(name, docstring, base_labels = {})
+        register(Counter.new(name, docstring, base_labels))
+      end
+
+      def summary(name, docstring, base_labels = {})
+        register(Summary.new(name, docstring, base_labels))
+      end
+
+      def gauge(name, docstring, base_labels = {}, multiprocess_mode = :all)
+        register(Gauge.new(name, docstring, base_labels, multiprocess_mode))
+      end
+
+      def histogram(name, docstring, base_labels = {},
+                    buckets = Histogram::DEFAULT_BUCKETS)
+        register(Histogram.new(name, docstring, base_labels, buckets))
+      end
+
+      def exist?(name)
+        @metrics.key?(name)
+      end
+
+      def get(name)
+        @metrics[name.to_sym]
+      end
+
+      def metrics
+        @metrics.values
+      end
+    end
+  end
+end

data/lib/prometheus/client/simple_value.rb

@@ -0,0 +1,31 @@
+require 'json'
+
+module Prometheus
+  module Client
+    class SimpleValue
+      def initialize(_type, _metric_name, _name, _labels, *_args)
+        @value = 0.0
+      end
+
+      def set(value)
+        @value = value
+      end
+
+      def increment(by = 1)
+        @value += by
+      end
+
+      def decrement(by = 1)
+        @value -= by
+      end
+
+      def get
+        @value
+      end
+
+      def self.multiprocess
+        false
+      end
+    end
+  end
+end

data/lib/prometheus/client/summary.rb

@@ -0,0 +1,69 @@
+require 'prometheus/client/metric'
+require 'prometheus/client/uses_value_type'
+
+module Prometheus
+  module Client
+    # Summary is an accumulator for samples. It captures Numeric data and
+    # provides an efficient quantile calculation mechanism.
+    class Summary < Metric
+      extend Gem::Deprecate
+
+      # Value represents the state of a Summary at a given point.
+      class Value < Hash
+        include UsesValueType
+        attr_accessor :sum, :total
+
+        def initialize(type, name, labels)
+          @sum = value_object(type, name, "#{name}_sum", labels)
+          @total = value_object(type, name, "#{name}_count", labels)
+        end
+
+        def observe(value)
+          @sum.increment(value)
+          @total.increment
+        end
+      end
+
+      def initialize(name, docstring, base_labels = {})
+        super(name, docstring, base_labels)
+      end
+
+      def type
+        :summary
+      end
+
+      # Records a given value.
+      def observe(labels, value)
+        label_set = label_set_for(labels)
+        synchronize { @values[label_set].observe(value) }
+      end
+
+      alias add observe
+      deprecate :add, :observe, 2016, 10
+
+      # Returns the value for the given label set
+      def get(labels = {})
+        @validator.valid?(labels)
+
+        synchronize do
+          @values[labels].sum.get
+        end
+      end
+
+      # Returns all label sets with their values
+      def values
+        synchronize do
+          @values.each_with_object({}) do |(labels, value), memo|
+            memo[labels] = value.sum
+          end
+        end
+      end
+
+      private
+
+      def default(labels)
+        Value.new(type, @name, labels)
+      end
+    end
+  end
+end

data/lib/prometheus/client/support/unicorn.rb

@@ -0,0 +1,35 @@
+module Prometheus
+  module Client
+    module Support
+      module Unicorn
+        def self.worker_pid_provider
+          wid = worker_id
+          if wid.nil?
+            "process_id_#{Process.pid}"
+          else
+            "worker_id_#{wid}"
+          end
+        end
+
+        def self.worker_id
+          match = $0.match(/worker\[([^\]]+)\]/)
+          if match
+            match[1]
+          else
+            object_based_worker_id
+          end
+        end
+
+        def self.object_based_worker_id
+          return unless defined?(::Unicorn::Worker)
+
+          workers = ObjectSpace.each_object(::Unicorn::Worker)
+          return if workers.nil?
+
+          workers_first = workers.first
+          workers_first.nr unless workers_first.nil?
+        end
+      end
+    end
+  end
+end

data/lib/prometheus/client/uses_value_type.rb

@@ -0,0 +1,20 @@
+require 'prometheus/client/simple_value'
+
+module Prometheus
+  module Client
+    # Module providing convenience methods for creating value_object
+    module UsesValueType
+      def value_class
+        Prometheus::Client.configuration.value_class
+      end
+
+      def value_object(type, metric_name, name, labels, *args)
+        value_class.new(type, metric_name, name, labels, *args)
+      rescue StandardError => e
+        Prometheus::Client.logger.info("error #{e} while creating instance of #{value_class} defaulting to SimpleValue")
+        Prometheus::Client.logger.debug("error #{e} backtrace #{e.backtrace.join("\n")}")
+        Prometheus::Client::SimpleValue.new(type, metric_name, name, labels)
+      end
+    end
+  end
+end

data/lib/prometheus/client/version.rb

@@ -0,0 +1,5 @@
+module Prometheus
+  module Client
+    VERSION = '0.20.3'.freeze
+  end
+end

data/lib/prometheus/client.rb

@@ -0,0 +1,58 @@
+require 'prometheus/client/registry'
+require 'prometheus/client/configuration'
+require 'prometheus/client/mmaped_value'
+
+module Prometheus
+  # Client is a ruby implementation for a Prometheus compatible client.
+  module Client
+    class << self
+      attr_writer :configuration
+
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield(configuration)
+      end
+
+      # Returns a default registry object
+      def registry
+        @registry ||= Registry.new
+      end
+
+      def logger
+        configuration.logger
+      end
+
+      def pid
+        configuration.pid_provider.call
+      end
+
+      # Resets the registry and reinitializes all metrics files.
+      # Use case: clean up everything in specs `before` block,
+      # to prevent leaking the state between specs which are updating metrics.
+      def reset!
+        @registry = nil
+        ::Prometheus::Client::MmapedValue.reset_and_reinitialize
+      end
+
+      def cleanup!
+        Dir.glob("#{configuration.multiprocess_files_dir}/*.db").each { |f| File.unlink(f) if File.exist?(f) }
+      end
+
+      # With `force: false`: reinitializes metric files only for processes with the changed PID.
+      # With `force: true`: reinitializes all metrics files.
+      # Always keeps the registry.
+      # Use case  (`force: false`): pick up new metric files on each worker start,
+      # without resetting already registered files for the master or previously initialized workers.
+      def reinitialize_on_pid_change(force: false)
+        if force
+          ::Prometheus::Client::MmapedValue.reset_and_reinitialize
+        else
+          ::Prometheus::Client::MmapedValue.reinitialize_on_pid_change
+        end
+      end
+    end
+  end
+end

data/lib/prometheus.rb

@@ -0,0 +1,3 @@
+# Prometheus is a generic time-series collection and computation server.
+module Prometheus
+end