prometheus-client-mmap 0.7.0.beta1

data/lib/prometheus/client/histogram.rb

@@ -0,0 +1,84 @@
+# encoding: UTF-8
+
+require 'prometheus/client/metric'
+
+module Prometheus
+  module Client
+    # A histogram samples observations (usually things like request durations
+    # or response sizes) and counts them in configurable buckets. It also
+    # provides a sum of all observed values.
+    class Histogram < Metric
+      # Value represents the state of a Histogram at a given point.
+      class Value < Hash
+        attr_accessor :sum, :total
+
+        def initialize(type, name, labels, buckets)
+          @sum = ValueClass.new(type, name, name.to_s + '_sum', labels)
+          # TODO: get rid of total and use +Inf bucket instead.
+          @total = ValueClass.new(type, name, name.to_s + '_count', labels)
+
+          buckets.each do |bucket|
+            # TODO: check that there are no user-defined "le" labels.
+            self[bucket] = ValueClass.new(type, name, name.to_s + '_bucket', labels.merge({'le' => bucket.to_s}))
+          end
+        end
+
+        def observe(value)
+          @sum.increment(value)
+          @total.increment()
+
+          each_key do |bucket|
+            self[bucket].increment() if value <= bucket
+          end
+        end
+
+        def get()
+          hash = {}
+          each_key do |bucket|
+            hash[bucket] = self[bucket].get()
+          end
+          hash
+        end
+      end
+
+      # DEFAULT_BUCKETS are the default Histogram buckets. The default buckets
+      # are tailored to broadly measure the response time (in seconds) of a
+      # network service. (From DefBuckets client_golang)
+      DEFAULT_BUCKETS = [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1,
+                         2.5, 5, 10].freeze
+
+      # Offer a way to manually specify buckets
+      def initialize(name, docstring, base_labels = {},
+                     buckets = DEFAULT_BUCKETS)
+        raise ArgumentError, 'Unsorted buckets, typo?' unless sorted? buckets
+
+        @buckets = buckets
+        super(name, docstring, base_labels)
+      end
+
+      def type
+        :histogram
+      end
+
+      def observe(labels, value)
+        if labels[:le]
+          raise ArgumentError, 'Label with name "le" is not permitted'
+        end
+
+        label_set = label_set_for(labels)
+        synchronize { @values[label_set].observe(value) }
+      end
+
+      private
+
+      def default(labels)
+        # TODO: default function needs to know key of hash info (label names and values)
+        Value.new(type, @name, labels, @buckets)
+      end
+
+      def sorted?(bucket)
+        bucket.each_cons(2).all? { |i, j| i <= j }
+      end
+    end
+  end
+end

data/lib/prometheus/client/label_set_validator.rb

@@ -0,0 +1,69 @@
+# encoding: UTF-8
+
+module Prometheus
+  module Client
+    # LabelSetValidator ensures that all used label sets comply with the
+    # Prometheus specification.
+    class LabelSetValidator
+      # TODO: we might allow setting :instance in the future
+      RESERVED_LABELS = [:job, :instance].freeze
+
+      class LabelSetError < StandardError; end
+      class InvalidLabelSetError < LabelSetError; end
+      class InvalidLabelError < LabelSetError; end
+      class ReservedLabelError < LabelSetError; end
+
+      def initialize
+        @validated = {}
+      end
+
+      def valid?(labels)
+        unless labels.respond_to?(:all?)
+          raise InvalidLabelSetError, "#{labels} is not a valid label set"
+        end
+
+        labels.all? do |key, _|
+          validate_symbol(key)
+          validate_name(key)
+          validate_reserved_key(key)
+        end
+      end
+
+      def validate(labels)
+        return labels if @validated.key?(labels.hash)
+
+        valid?(labels)
+
+        unless @validated.empty? || match?(labels, @validated.first.last)
+          raise InvalidLabelSetError, 'labels must have the same signature'
+        end
+
+        @validated[labels.hash] = labels
+      end
+
+      private
+
+      def match?(a, b)
+        a.keys.sort == b.keys.sort
+      end
+
+      def validate_symbol(key)
+        return true if key.is_a?(Symbol)
+
+        raise InvalidLabelError, "label #{key} is not a symbol"
+      end
+
+      def validate_name(key)
+        return true unless key.to_s.start_with?('__')
+
+        raise ReservedLabelError, "label #{key} must not start with __"
+      end
+
+      def validate_reserved_key(key)
+        return true unless RESERVED_LABELS.include?(key)
+
+        raise ReservedLabelError, "#{key} is reserved"
+      end
+    end
+  end
+end

data/lib/prometheus/client/metric.rb

@@ -0,0 +1,70 @@
+# encoding: UTF-8
+
+require 'thread'
+require 'prometheus/client/label_set_validator'
+require 'prometheus/client/valuetype'
+
+module Prometheus
+  module Client
+    # Metric
+    class Metric
+      attr_reader :name, :docstring, :base_labels
+
+      def initialize(name, docstring, base_labels = {})
+        @mutex = Mutex.new
+        @validator = LabelSetValidator.new
+        @values = Hash.new { |hash, key| hash[key] = default(key) }
+
+        validate_name(name)
+        validate_docstring(docstring)
+        @validator.valid?(base_labels)
+
+        @name = name
+        @docstring = docstring
+        @base_labels = base_labels
+      end
+
+      # Returns the value for the given label set
+      def get(labels = {})
+        @validator.valid?(labels)
+
+        @values[labels].get
+      end
+
+      # Returns all label sets with their values
+      def values
+        synchronize do
+          @values.each_with_object({}) do |(labels, value), memo|
+            memo[labels] = value
+          end
+        end
+      end
+
+      private
+
+      def default(labels)
+        ValueClass.new(type, @name, @name, labels)
+      end
+
+      def validate_name(name)
+        return true if name.is_a?(Symbol)
+
+        raise ArgumentError, 'given name must be a symbol'
+      end
+
+      def validate_docstring(docstring)
+        return true if docstring.respond_to?(:empty?) && !docstring.empty?
+
+        raise ArgumentError, 'docstring must be given'
+      end
+
+      def label_set_for(labels)
+        @validator.validate(labels)
+      end
+
+      def synchronize(&block)
+        @mutex.synchronize(&block)
+      end
+    end
+  end
+end

data/lib/prometheus/client/push.rb

@@ -0,0 +1,72 @@
+# encoding: UTF-8
+
+require 'net/http'
+require 'uri'
+
+require 'prometheus/client'
+require 'prometheus/client/formats/text'
+
+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
+      DEFAULT_GATEWAY = 'http://localhost:9091'.freeze
+      PATH            = '/metrics/jobs/%s'.freeze
+      INSTANCE_PATH   = '/metrics/jobs/%s/instances/%s'.freeze
+      HEADER          = { 'Content-Type' => Formats::Text::CONTENT_TYPE }.freeze
+
+      attr_reader :job, :instance, :gateway, :path
+
+      def initialize(job, instance = nil, gateway = nil)
+        @job = job
+        @instance = instance
+        @gateway = gateway || DEFAULT_GATEWAY
+        @uri = parse(@gateway)
+        @path = build_path(job, instance)
+        @http = Net::HTTP.new(@uri.host, @uri.port)
+      end
+
+      def add(registry)
+        request('POST', registry)
+      end
+
+      def replace(registry)
+        request('PUT', registry)
+      end
+
+      def delete
+        @http.send_request('DELETE', path)
+      end
+
+      private
+
+      def parse(url)
+        uri = URI.parse(url)
+
+        if uri.scheme == 'http'
+          uri
+        else
+          raise ArgumentError, 'only HTTP gateway URLs are supported currently.'
+        end
+      rescue URI::InvalidURIError => e
+        raise ArgumentError, "#{url} is not a valid URL: #{e}"
+      end
+
+      def build_path(job, instance)
+        if instance
+          format(INSTANCE_PATH, URI.escape(job), URI.escape(instance))
+        else
+          format(PATH, URI.escape(job))
+        end
+      end
+
+      def request(method, registry)
+        data = Formats::Text.marshal(registry)
+
+        @http.send_request(method, path, data, HEADER)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# 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 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)
+        rescue
+          # TODO: log unexpected exception during request recording
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# 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)
+          [
+            200,
+            { 'Content-Type' => format::CONTENT_TYPE },
+            [format.marshal(@registry)],
+          ]
+        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