custom-prometheus-client 0.4.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 59513bdd6f293705f4f34c864ba6406d0fa9522d
+  data.tar.gz: a5f20ee8c59ff151cec16de150afff6924669fc9
+SHA512:
+  metadata.gz: c2f628acc7b16dbfe82db00b854705a8a20d53660d6e03e295afe5373284656b404852234ab209b40e895bcecfcc2534bf6f29609767026d77d32a8f7c8f97d7
+  data.tar.gz: da87469693d2646d160927edb6a928530a1f57cfb7bb4f5aafb79bdf4058dc162f450b7f15738a3558dfbd982e8ae12d81b83deba3400d8cdaafc0a55e2396b4

data/README.md

@@ -0,0 +1,27 @@
+# Custom Prometheus Ruby Client
+
+This repo is essentially a fork of https://github.com/prometheus/client_ruby and adds the following behaviour to the captured metrics.
+
+- It takes the service_name as an options to the rake middleware (see usage)
+- It adds the following labels to the metrics 
+	* User Agent
+	* Accept
+	* Content Type
+
+## Usage
+Add the following to your Gemfile
+```
+gem 'custom-prometheus-client'
+```
+
+Then in your config.ru add the following (Change 'my_app' to the name of your app being monitored)
+```
+require 'prometheus/client/rack/collector'
+require 'prometheus/client/rack/exporter'
+
+options = { service_name:  'my_app'}
+use Prometheus::Client::Rack::Collector, options
+use Prometheus::Client::Rack::Exporter
+```
+
+Configure your prometheus.yml to scrape /metrics from  rails service

data/lib/prometheus.rb

@@ -0,0 +1,5 @@
+# encoding: UTF-8
+
+# Prometheus is a generic time-series collection and computation server.
+module Prometheus
+end

data/lib/prometheus/client.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+require 'prometheus/client/registry'
+
+module Prometheus
+  # Client is a ruby implementation for a Prometheus compatible client.
+  module Client
+    # Returns a default registry object
+    def self.registry
+      @registry ||= Registry.new
+    end
+  end
+end

data/lib/prometheus/client/counter.rb

@@ -0,0 +1,27 @@
+# encoding: UTF-8
+
+require 'prometheus/client/metric'
+
+module Prometheus
+  module Client
+    # Counter is a metric that exposes merely a sum or tally of things.
+    class Counter < Metric
+      def type
+        :counter
+      end
+
+      def increment(labels = {}, by = 1)
+        fail ArgumentError, 'increment must be a non-negative number' if by < 0
+
+        label_set = label_set_for(labels)
+        synchronize { @values[label_set] += by }
+      end
+
+      private
+
+      def default
+        0
+      end
+    end
+  end
+end

data/lib/prometheus/client/formats/json.rb

@@ -0,0 +1,33 @@
+# encoding: UTF-8
+
+require 'json'
+
+module Prometheus
+  module Client
+    module Formats
+      # JSON format is a deprecated, human-readable format to expose the state
+      # of a given registry.
+      module JSON
+        MEDIA_TYPE   = 'application/json'
+        SCHEMA       = 'prometheus/telemetry'
+        VERSION      = '0.0.2'
+        CONTENT_TYPE = %(#{MEDIA_TYPE}; schema="#{SCHEMA}"; version=#{VERSION})
+
+        MAPPING = { summary: :histogram }
+
+        def self.marshal(registry)
+          registry.metrics.map do |metric|
+            {
+              baseLabels: metric.base_labels.merge(__name__: metric.name),
+              docstring:  metric.docstring,
+              metric: {
+                type:  MAPPING[metric.type] || metric.type,
+                value: metric.values.map { |l, v| { labels: l, value: v } },
+              },
+            }
+          end.to_json
+        end
+      end
+    end
+  end
+end

data/lib/prometheus/client/formats/text.rb

@@ -0,0 +1,81 @@
+# encoding: UTF-8
+
+module Prometheus
+  module Client
+    module Formats
+      # Text format is human readable mainly used for manual inspection.
+      module Text
+        MEDIA_TYPE   = 'text/plain'
+        VERSION      = '0.0.4'
+        CONTENT_TYPE = "#{MEDIA_TYPE}; version=#{VERSION}"
+
+        METRIC_LINE = '%s%s %s'
+        TYPE_LINE   = '# TYPE %s %s'
+        HELP_LINE   = '# HELP %s %s'
+
+        LABEL     = '%s="%s"'
+        SEPARATOR = ','
+        DELIMITER = "\n"
+
+        REGEX   = { doc: /[\n\\]/, label: /[\n\\"]/ }
+        REPLACE = { "\n" => '\n', '\\' => '\\\\', '"' => '\"' }
+
+        def self.marshal(registry)
+          lines = []
+
+          registry.metrics.each do |metric|
+            lines << format(TYPE_LINE, metric.name, metric.type)
+            lines << format(HELP_LINE, metric.name, escape(metric.docstring))
+
+            metric.values.each do |label_set, value|
+              representation(metric, label_set, value) { |l| lines << l }
+            end
+          end
+
+          # there must be a trailing delimiter
+          (lines << nil).join(DELIMITER)
+        end
+
+        private
+
+        def self.representation(metric, label_set, value, &block)
+          set = metric.base_labels.merge(label_set)
+
+          if metric.type == :summary
+            summary(metric.name, set, value, &block)
+          else
+            yield metric(metric.name, labels(set), value)
+          end
+        end
+
+        def self.summary(name, set, value)
+          value.each do |q, v|
+            yield metric(name, labels(set.merge(quantile: q)), v)
+          end
+
+          l = labels(set)
+          yield metric("#{name}_sum", l, value.sum)
+          yield metric("#{name}_count", l, value.total)
+        end
+
+        def self.metric(name, labels, value)
+          format(METRIC_LINE, name, labels, value)
+        end
+
+        def self.labels(set)
+          return if set.empty?
+
+          strings = set.each_with_object([]) do |(key, value), memo|
+            memo << format(LABEL, key, escape(value, :label))
+          end
+
+          "{#{strings.join(SEPARATOR)}}"
+        end
+
+        def self.escape(string, format = :doc)
+          string.to_s.gsub(REGEX[format], REPLACE)
+        end
+      end
+    end
+  end
+end

data/lib/prometheus/client/gauge.rb

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+
+require 'prometheus/client/metric'
+
+module Prometheus
+  module Client
+    # A Gauge is a metric that exposes merely an instantaneous value or some
+    # snapshot thereof.
+    class Gauge < Metric
+      def type
+        :gauge
+      end
+
+      # Sets the value for the given label set
+      def set(labels, value)
+        @values[label_set_for(labels)] = value
+      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]
+
+      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?)
+          fail 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)
+          fail 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)
+
+        fail InvalidLabelError, "label #{key} is not a symbol"
+      end
+
+      def validate_name(key)
+        return true unless key.to_s.start_with?('__')
+
+        fail ReservedLabelError, "label #{key} must not start with __"
+      end
+
+      def validate_reserved_key(key)
+        return true unless RESERVED_LABELS.include?(key)
+
+        fail ReservedLabelError, "#{key} is reserved"
+      end
+    end
+  end
+end

data/lib/prometheus/client/metric.rb

@@ -0,0 +1,74 @@
+# encoding: UTF-8
+
+require 'thread'
+require 'prometheus/client/label_set_validator'
+
+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 }
+
+        validate_name(name)
+        validate_docstring(docstring)
+        @validator.valid?(base_labels)
+
+        @name = name
+        @docstring = docstring
+        @base_labels = base_labels
+      end
+
+      # Returns the metric type
+      def type
+        fail NotImplementedError
+      end
+
+      # Returns the value for the given label set
+      def get(labels = {})
+        @validator.valid?(labels)
+
+        @values[labels]
+      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
+        nil
+      end
+
+      def validate_name(name)
+        return true if name.is_a?(Symbol)
+
+        fail ArgumentError, 'given name must be a symbol'
+      end
+
+      def validate_docstring(docstring)
+        return true if docstring.respond_to?(:empty?) && !docstring.empty?
+
+        fail 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,68 @@
+# 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'
+      PATH            = '/metrics/jobs/%s'
+      INSTANCE_PATH   = '/metrics/jobs/%s/instances/%s'
+      HEADER          = { 'Content-Type' => Formats::Text::CONTENT_TYPE }
+
+      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
+
+      private
+
+      def parse(url)
+        uri = URI.parse(url)
+
+        if uri.scheme == 'http'
+          uri
+        else
+          fail 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,92 @@
+# 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
+          # The service name should be read from config or could be git repo name 
+          @service_name = options[:service_name]
+          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,
+            ua: env['HTTP_USER_AGENT'].to_s,
+            accept: env['HTTP_ACCEPT'],
+            host:   env['HTTP_HOST'].to_s,
+            path:   env['PATH_INFO'].to_s,
+            content_type: env['CONTENT_TYPE'].to_s
+          }
+        end
+
+        def init_request_metrics
+          @request_metrics = @service_name + "__counter_requests_total"
+          @response_metrics =  @service_name + "__counter_responses_total"
+          @response_time_metrics =  @service_name + "__summary_responses_duration_microseconds"
+
+          @requests = @registry.counter(
+            @request_metrics.to_sym,
+            'Total number of HTTP requests.')
+          @requests_duration = @registry.counter(
+            @response_metrics.to_sym,
+            'Total time spent answering HTTP requests ' \
+            '(microseconds).')
+          @durations = @registry.summary(
+            @response_time_metrics.to_sym,
+            'A histogram of the response latency (microseconds).')
+        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) * 1_000_000).to_i
+            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)
+          @requests_duration.increment(labels, duration)
+          @durations.add(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,92 @@
+# encoding: UTF-8
+
+require 'prometheus/client'
+require 'prometheus/client/formats/json'
+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, Formats::JSON]
+        FALLBACK = Formats::JSON
+
+        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

data/lib/prometheus/client/registry.rb

@@ -0,0 +1,59 @@
+# encoding: UTF-8
+
+require 'thread'
+
+require 'prometheus/client/counter'
+require 'prometheus/client/summary'
+require 'prometheus/client/gauge'
+
+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)
+            fail 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 = {})
+        register(Gauge.new(name, docstring, base_labels))
+      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/summary.rb

@@ -0,0 +1,60 @@
+# encoding: UTF-8
+
+require 'quantile'
+require 'prometheus/client/metric'
+
+module Prometheus
+  module Client
+    # Summary is an accumulator for samples. It captures Numeric data and
+    # provides an efficient quantile calculation mechanism.
+    class Summary < Metric
+      # Value represents the state of a Summary at a given point.
+      class Value < Hash
+        attr_accessor :sum, :total
+
+        def initialize(estimator)
+          @sum = estimator.sum
+          @total = estimator.observations
+
+          estimator.invariants.each do |invariant|
+            self[invariant.quantile] = estimator.query(invariant.quantile)
+          end
+        end
+      end
+
+      def type
+        :summary
+      end
+
+      # Records a given value.
+      def add(labels, value)
+        label_set = label_set_for(labels)
+        synchronize { @values[label_set].observe(value) }
+      end
+
+      # Returns the value for the given label set
+      def get(labels = {})
+        @validator.valid?(labels)
+
+        synchronize do
+          Value.new(@values[labels])
+        end
+      end
+
+      # Returns all label sets with their values
+      def values
+        synchronize do
+          @values.each_with_object({}) do |(labels, value), memo|
+            memo[labels] = Value.new(value)
+          end
+        end
+      end
+
+      private
+
+      def default
+        Quantile::Estimator.new
+      end
+    end
+  end
+end

data/lib/prometheus/client/version.rb

@@ -0,0 +1,7 @@
+# encoding: UTF-8
+
+module Prometheus
+  module Client
+    VERSION = '0.4.3'
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: custom-prometheus-client
+version: !ruby/object:Gem::Version
+  version: 0.4.3
+platform: ruby
+authors:
+- Shah Bagdadi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: quantile
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+description: 
+email:
+- email.shanu@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/prometheus.rb
+- lib/prometheus/client.rb
+- lib/prometheus/client/counter.rb
+- lib/prometheus/client/formats/json.rb
+- lib/prometheus/client/formats/text.rb
+- lib/prometheus/client/gauge.rb
+- lib/prometheus/client/label_set_validator.rb
+- lib/prometheus/client/metric.rb
+- lib/prometheus/client/push.rb
+- lib/prometheus/client/rack/collector.rb
+- lib/prometheus/client/rack/exporter.rb
+- lib/prometheus/client/registry.rb
+- lib/prometheus/client/summary.rb
+- lib/prometheus/client/version.rb
+homepage: https://github.com/prometheus/client_ruby
+licenses:
+- Apache 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: A suite of instrumentation metric primitivesthat can be exposed through a
+  web services interface.
+test_files: []