prometheus-client 0.2.0 → 0.3.0.pre.rc.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MjNjNjA5ODM2MDg5NzA0Mjk5ZmFhY2Q3MzgzYzU5NmQ0MmEwNjIzYw==
+  data.tar.gz: !binary |-
+    MWM4NWNhOWY5ZjA0YmUyNjY2YzJiZTA3Zjk0OTRkNjAyZTFhZDAzZg==
+SHA512:
+  metadata.gz: !binary |-
+    M2JlODIxYWUwZGE0ZDQxODJkODdlNzNmYmYzZjU5NDhiYmYzOTQxYTVlNDg0
+    ZGQ2NzE3MmEzZDk1ZTUzZmExMDc5ZGE0NDEyMmU5ZjQyZWUyODdmOWE5YWQ0
+    NThkZDRkNmYzM2Q4YTI0YmM1ZjliOWJmY2Q4OGJhZGZhMDg1NjY=
+  data.tar.gz: !binary |-
+    ZWZjODRiYzFiNjMxNzliYWM3M2E4M2ZhYTM2Y2Q0MjYyNmRhOWMzZDdiMzU3
+    ZTBmNDkzYjk1Y2IwMGY2ZTliYmNhYTk1NGEzYTU4YzAyNDc2YzNkZWRlOGY2
+    NjllNTA2OTFlMGY4ZjQ4NmZjNWFiNDMzODE3YWMyNzljZWYyNzE=

data/README.md

@@ -4,9 +4,15 @@ A suite of instrumentation metric primitives for Ruby that can be exposed
 through a JSON web services interface. Intended to be used together with a
 [Prometheus server][1].
 
+[![Gem Version][4]](http://badge.fury.io/rb/prometheus-client)
+[![Build Status][3]](http://travis-ci.org/prometheus/client_ruby)
+[![Dependency Status][5]](https://gemnasium.com/prometheus/client_ruby)
+[![Code Climate][6]](https://codeclimate.com/github/prometheus/client_ruby)
+[![Coverage Status][7]](https://coveralls.io/r/prometheus/client_ruby)
+
 ## Usage
 
-### Library
+### Overview
 
 ```ruby
 require 'prometheus/client'
@@ -15,9 +21,9 @@ require 'prometheus/client'
 prometheus = Prometheus::Client.registry
 
 # create a new counter metric
-http_requests = Prometheus::Client::Counter.new
+http_requests = Prometheus::Client::Counter.new(:http_requests, 'A counter of HTTP requests made')
 # register the metric
-prometheus.register(:http_requests, 'A counter of HTTP requests made', http_requests)
+prometheus.register(http_requests)
 
 # equivalent helper function
 http_requests = prometheus.counter(:http_requests, 'A counter of HTTP requests made')
@@ -50,16 +56,38 @@ Start the server and have a look at the metrics endpoint:
 For further instructions and other scripts to get started, have a look at the
 integrated [example application](examples/rack/README.md).
 
+### Pushgateway
+
+The Ruby client can also be used to push its collected metrics to a
+[Pushgateway][8]. This comes in handy with batch jobs or in other scenarios
+where it's not possible or feasible to let a Prometheus server scrape a Ruby
+process.
+
+```ruby
+require 'prometheus/client'
+require 'prometheus/client/push'
+
+prometheus = Prometheus::Client.registry
+# ... register some metrics, set/add/increment/etc. their values
+
+# push the registry state to the default gateway
+Prometheus::Client::Push.new('my-batch-job').push(prometheus)
+
+# optional: specify the instance name (instead of IP) and gateway
+Prometheus::Client::Push.new(
+  'my-job', 'instance-name', 'http://example.domain:1234').push(prometheus)
+```
+
 ## Metrics
 
 The following metric types are currently supported.
 
 ### Counter
 
-A Counter is a metric that exposes merely a sum or tally of things.
+Counter is a metric that exposes merely a sum or tally of things.
 
 ```ruby
-counter = Prometheus::Client::Counter.new
+counter = Prometheus::Client::Counter.new(:foo, '...')
 
 # increment the counter for a given label set
 counter.increment(service: 'foo')
@@ -77,11 +105,11 @@ counter.get(service: 'bar')
 
 ### Gauge
 
-A Gauge is a metric that exposes merely an instantaneous value or some
-snapshot thereof.
+Gauge is a metric that exposes merely an instantaneous value or some snapshot
+thereof.
 
 ```ruby
-gauge = Prometheus::Client::Gauge.new
+gauge = Prometheus::Client::Gauge.new(:bar, '...')
 
 # set a value
 gauge.set({ role: 'base' }, 'up')
@@ -93,11 +121,11 @@ gauge.get({ role: 'problematic' })
 
 ### Summary
 
-The Summary is an accumulator for samples. It captures Numeric data and provides
+Summary is an accumulator for samples. It captures Numeric data and provides
 an efficient percentile calculation mechanism.
 
 ```ruby
-summary = Prometheus::Client::Summary.new
+summary = Prometheus::Client::Summary.new(:baz, '...')
 
 # record a value
 summary.add({ service: 'slow' }, Benchmark.realtime { service.call(arg) })
@@ -109,21 +137,22 @@ summary.get({ service: 'database' })
 
 ## Todo
 
-  * add push support to a vanilla prometheus exporter
-  * use a more performant JSON library
   * add protobuf support
 
 ## Tests
 
-[![Build Status][3]](http://travis-ci.org/prometheus/client_ruby)
-
 Install necessary development gems with `bundle install` and run tests with
 rspec:
 
 ```bash
-rspec
+rake
 ```
 
 [1]: https://github.com/prometheus/prometheus
 [2]: http://rack.github.io/
 [3]: https://secure.travis-ci.org/prometheus/client_ruby.png?branch=master
+[4]: https://badge.fury.io/rb/prometheus-client.svg
+[5]: https://gemnasium.com/prometheus/client_ruby.svg
+[6]: https://codeclimate.com/github/prometheus/client_ruby.png
+[7]: https://coveralls.io/repos/prometheus/client_ruby/badge.png?branch=master
+[8]: https://github.com/prometheus/pushgateway

data/lib/prometheus.rb

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

data/lib/prometheus/client.rb

@@ -1,12 +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
+      @registry ||= Registry.new
     end
-
   end
 end

data/lib/prometheus/client/counter.rb

@@ -1,7 +1,10 @@
+# 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
@@ -16,12 +19,11 @@ module Prometheus
         increment(labels, -by)
       end
 
-    private
+      private
 
       def default
         0
       end
-
     end
   end
 end

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

@@ -0,0 +1,34 @@
+# 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 = \
+          %Q(#{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,76 @@
+# 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 = %Q(#{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|
+              set = metric.base_labels.merge(label_set)
+              representation(metric, set, value) { |l| lines << l }
+            end
+          end
+
+          # there must be a trailing delimiter
+          (lines << nil).join(DELIMITER)
+        end
+
+        private
+
+        def self.representation(metric, set, value)
+          if metric.type == :summary
+            value.each do |q, v|
+              yield metric(metric.name, labels(set.merge(quantile: q)), v)
+            end
+
+            l = labels(set)
+            yield metric("#{metric.name}_sum", l, value.sum)
+            yield metric("#{metric.name}_total", l, value.total)
+          else
+            yield metric(metric.name, labels(set), value)
+          end
+        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

@@ -1,7 +1,11 @@
+# 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

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

@@ -1,47 +1,68 @@
+# encoding: UTF-8
+
 require 'thread'
-require 'prometheus/client/label_set'
+require 'prometheus/client/label_set_validator'
 
 module Prometheus
   module Client
     # Metric
     class Metric
-      def initialize
+      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, @docstring = name, docstring
+        @base_labels = base_labels
       end
 
       # Returns the metric type
       def type
-        raise NotImplementedError
+        fail NotImplementedError
       end
 
       # Returns the value for the given label set
       def get(labels = {})
-        @values[label_set_for(labels)]
+        @validator.valid?(labels)
+
+        @values[labels]
       end
 
-      # Generates JSON representation
-      def to_json(*json)
-        {
-          'type' => type,
-          'value' => value
-        }.to_json(*json)
+      # 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
+      private
 
       def default
         nil
       end
 
-      def value
-        @values.map do |labels, value|
-          { :labels => labels, :value => get(labels) }
-        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)
-        LabelSet.new(labels)
+        @validator.validate(labels)
       end
 
       def synchronize(&block)

data/lib/prometheus/client/push.rb

@@ -0,0 +1,59 @@
+# 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, @instance, @gateway = job, instance, gateway || DEFAULT_GATEWAY
+
+        @uri  = parse(@gateway)
+        @path = build_path(job, instance)
+      end
+
+      def push(registry)
+        data = Formats::Text.marshal(registry)
+        http = Net::HTTP.new(@uri.host, @uri.port)
+
+        http.send_request('PUT', path, data, HEADER)
+      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
+    end
+  end
+end

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

@@ -1,59 +1,79 @@
+# encoding: UTF-8
+
 require 'prometheus/client'
 
 module Prometheus
   module Client
     module Rack
+      # Collector is a Rack middleware that provides a sample implementation of
+      # a Prometheus HTTP client API.
       class Collector
         attr_reader :app, :registry
 
-        def initialize(app, options = {})
+        def initialize(app, options = {}, &label_builder)
           @app = app
           @registry = options[:registry] || Client.registry
+          @label_builder = label_builder || proc do |env|
+            {
+              method: env['REQUEST_METHOD'].downcase,
+              path:   env['PATH_INFO'].to_s,
+            }
+          end
 
-          init_metrics
+          init_request_metrics
+          init_exception_metrics
         end
 
         def call(env) # :nodoc:
           trace(env) { @app.call(env) }
         end
 
-      protected
+        protected
+
+        def init_request_metrics
+          @requests = @registry.counter(
+            :http_requests_total,
+            'A counter of the total number of HTTP requests made.',)
+          @requests_duration = @registry.counter(
+            :http_request_durations_total_microseconds,
+            'The total amount of time spent answering HTTP requests ' \
+            '(microseconds).',)
+          @durations = @registry.summary(
+            :http_request_durations_microseconds,
+            'A histogram of the response latency (microseconds).',)
+        end
 
-        def init_metrics
-          @requests = @registry.counter(:http_requests_total, 'A counter of the total number of HTTP requests made')
-          @requests_duration = @registry.counter(:http_request_durations_total_microseconds, 'The total amount of time Rack has spent answering HTTP requests (microseconds).')
-          @durations = @registry.summary(:http_request_durations_microseconds, 'A histogram of the response latency for requests made (microseconds).')
+        def init_exception_metrics
+          @exceptions = @registry.counter(
+            :http_exceptions_total,
+            'A counter of the total number of exceptions raised.',)
         end
 
-        def trace(env, &block)
+        def trace(env)
           start = Time.now
-          response = yield
+          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
-        ensure
-          duration = ((Time.now - start) * 1_000_000).to_i
-          record(duration, env, response, exception)
         end
 
-        def record(duration, env, response, exception)
-          labels = {
-            :method => env['REQUEST_METHOD'].downcase,
-            :path   => env['PATH_INFO'].to_s,
-          }
-
-          if response
+        def labels(env, response)
+          @label_builder.call(env).tap do |labels|
             labels[:code] = response.first.to_s
-          else
-            labels[:exception] = exception.class.name
           end
+        end
 
+        def record(labels, duration)
           @requests.increment(labels)
           @requests_duration.increment(labels, duration)
           @durations.add(labels, duration)
-        rescue => error
+        rescue
           # TODO: log unexpected exception during request recording
+          nil
         end
-
       end
     end
   end

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

@@ -1,35 +1,84 @@
+# 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 HTTP tracer. The default label builder can be modified to export a
+      # differet set of labels per recorded metric.
       class Exporter
         attr_reader :app, :registry, :path
 
-        API_VERSION  = '0.0.2'
-        CONTENT_TYPE = 'application/json; schema="prometheus/telemetry"; version=' + API_VERSION
-        HEADERS      = { 'Content-Type' => CONTENT_TYPE }
+        FORMATS  = [Formats::Text, Formats::JSON]
+        FALLBACK = Formats::JSON
 
         def initialize(app, options = {})
           @app = app
           @registry = options[:registry] || Client.registry
           @path = options[:path] || '/metrics'
+          @accpetable = build_dictionary(FORMATS)
         end
 
         def call(env)
           if env['PATH_INFO'] == @path
-            metrics_response
+            format = negotiate(env['HTTP_ACCEPT'], @accpetable, FALLBACK)
+            format ? respond_with(format) : not_acceptable(FORMATS)
           else
             @app.call(env)
           end
         end
 
-      protected
+        private
+
+        def negotiate(accept, formats, fallback)
+          return fallback if accept.to_s.empty?
+
+          parse(accept).each do |content_type, _|
+            return formats[content_type] if formats.key?(content_type)
+          end
 
-        def metrics_response
-          [200, HEADERS, [@registry.to_json]]
+          nil
         end
 
+        def parse(header)
+          header.to_s.split(/\s*,\s*/).map do |type|
+            attributes = type.split(/\s*;\s*/)
+            quality = 1.0
+            attributes.delete_if do |attr|
+              quality = attr.split('q=').last.to_f if attr.start_with?('q=')
+            end
+            [attributes.join('; '), quality]
+          end.sort_by(&:last).reverse
+        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)
+          formats.each_with_object({}) do |format, memo|
+            memo[format::CONTENT_TYPE] = format
+            memo[format::MEDIA_TYPE] = format
+          end
+        end
       end
     end
   end

data/lib/prometheus/client/registry.rb

@@ -1,7 +1,7 @@
-require 'json'
+# encoding: UTF-8
+
 require 'thread'
 
-require 'prometheus/client/container'
 require 'prometheus/client/counter'
 require 'prometheus/client/summary'
 require 'prometheus/client/gauge'
@@ -9,52 +9,50 @@ require 'prometheus/client/gauge'
 module Prometheus
   module Client
     # Registry
-    #
-    #
     class Registry
       class AlreadyRegisteredError < StandardError; end
 
-      def initialize()
-        @containers = {}
+      def initialize
+        @metrics = {}
         @mutex = Mutex.new
       end
 
-      def register(name, docstring, metric, base_labels = {})
-        container = Container.new(name, docstring, metric, base_labels)
+      def register(metric)
+        name = metric.name
 
         @mutex.synchronize do
-          if exist?(name)
-            raise AlreadyRegisteredError, "#{name} has already been registered"
+          if exist?(name.to_sym)
+            fail AlreadyRegisteredError, "#{name} has already been registered"
           else
-            @containers[name] = container
+            @metrics[name.to_sym] = metric
           end
         end
 
-        container
+        metric
       end
 
       def counter(name, docstring, base_labels = {})
-        register(name, docstring, Counter.new, base_labels).metric
+        register(Counter.new(name, docstring, base_labels))
       end
 
       def summary(name, docstring, base_labels = {})
-        register(name, docstring, Summary.new, base_labels).metric
+        register(Summary.new(name, docstring, base_labels))
       end
 
       def gauge(name, docstring, base_labels = {})
-        register(name, docstring, Gauge.new, base_labels).metric
+        register(Gauge.new(name, docstring, base_labels))
       end
 
       def exist?(name)
-        @containers.has_key?(name)
+        @metrics.key?(name)
       end
 
       def get(name)
-        @containers[name]
+        @metrics[name.to_sym]
       end
 
-      def to_json(*json)
-        @containers.values.to_json(*json)
+      def metrics
+        @metrics.values
       end
     end
   end

data/lib/prometheus/client/summary.rb

@@ -1,11 +1,30 @@
+# 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, @total = estimator.sum, estimator.observations
+
+          values = estimator.invariants.each_with_object({}) do |i, memo|
+            memo[i.quantile] = estimator.query(i.quantile)
+          end
+
+          replace(values)
+        end
+      end
+
       def type
-        :histogram
+        :summary
       end
 
       # Records a given value.
@@ -16,21 +35,27 @@ module Prometheus
 
       # Returns the value for the given label set
       def get(labels = {})
+        @validator.valid?(labels)
+
         synchronize do
-          estimator = @values[label_set_for(labels)]
-          estimator.invariants.inject({}) do |memo, invariant|
-            memo[invariant.quantile] = estimator.query(invariant.quantile)
-            memo
+          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
+      private
 
       def default
         Quantile::Estimator.new
       end
-
     end
   end
 end

data/lib/prometheus/client/version.rb

@@ -1,5 +1,7 @@
+# encoding: UTF-8
+
 module Prometheus
   module Client
-    VERSION = '0.2.0'
+    VERSION = '0.3.0-rc.1'
   end
 end

metadata

@@ -1,27 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: prometheus-client
 version: !ruby/object:Gem::Version
-  version: 0.2.0
-  prerelease: 
+  version: 0.3.0.pre.rc.1
 platform: ruby
 authors:
 - Tobias Schmidt
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-13 00:00:00.000000000 Z
+date: 2014-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: quantile
-  requirement: &19137520 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.2.0
   type: :runtime
   prerelease: false
-  version_requirements: *19137520
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.2.0
 description: 
 email:
 - ts@soundcloud.com
@@ -30,42 +32,43 @@ extensions: []
 extra_rdoc_files: []
 files:
 - README.md
-- lib/prometheus/client/counter.rb
-- lib/prometheus/client/gauge.rb
-- lib/prometheus/client/metric.rb
-- lib/prometheus/client/container.rb
+- lib/prometheus.rb
+- lib/prometheus/client.rb
 - lib/prometheus/client/registry.rb
 - lib/prometheus/client/rack/collector.rb
 - lib/prometheus/client/rack/exporter.rb
-- lib/prometheus/client/version.rb
-- lib/prometheus/client/label_set.rb
+- lib/prometheus/client/gauge.rb
+- lib/prometheus/client/label_set_validator.rb
+- lib/prometheus/client/formats/json.rb
+- lib/prometheus/client/formats/text.rb
+- lib/prometheus/client/push.rb
+- lib/prometheus/client/metric.rb
+- lib/prometheus/client/counter.rb
 - lib/prometheus/client/summary.rb
-- lib/prometheus/client.rb
-- lib/prometheus.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
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.5
+rubygems_version: 2.1.11
 signing_key: 
-specification_version: 3
-summary: A suite of instrumentation metric primitives for Ruby that can be exposed
-  through a JSON web services interface.
+specification_version: 4
+summary: A suite of instrumentation metric primitivesthat can be exposed through a
+  web services interface.
 test_files: []

data/lib/prometheus/client/container.rb

@@ -1,26 +0,0 @@
-require 'prometheus/client/label_set'
-
-module Prometheus
-  module Client
-    # Metric Container
-    class Container
-      attr_reader :name, :docstring, :metric, :base_labels
-
-      def initialize(name, docstring, metric, base_labels)
-        @name = name
-        @docstring = docstring
-        @metric = metric
-        @base_labels = LabelSet.new(base_labels)
-      end
-
-      def to_json(*json)
-        {
-          'baseLabels' => base_labels.merge(:name => name),
-          'docstring'  => docstring,
-          'metric'     => metric
-        }.to_json(*json)
-      end
-
-    end
-  end
-end

data/lib/prometheus/client/label_set.rb

@@ -1,44 +0,0 @@
-module Prometheus
-  module Client
-    # LabelSet is a pseudo class used to ensure given labels are semantically
-    # correct.
-    class LabelSet
-      # TODO: we might allow setting :instance in the future
-      RESERVED_LABELS = [:name, :job, :instance]
-
-      class LabelSetError        < StandardError; end
-      class InvalidLabelSetError < LabelSetError; end
-      class InvalidLabelError    < LabelSetError; end
-      class ReservedLabelError   < LabelSetError; end
-
-      # A list of validated label sets
-      @@validated = {}
-
-      def self.new(labels)
-        validate(labels)
-        labels
-      end
-
-    protected
-
-      def self.validate(labels)
-        @@validated[labels.hash] ||= begin
-          labels.keys.each do |key|
-            unless Symbol === key
-              raise InvalidLabelError, "label name #{key} is not a symbol"
-            end
-
-            if RESERVED_LABELS.include?(key)
-              raise ReservedLabelError, "labels may not contain reserved #{key} label"
-            end
-          end
-
-          true
-        end
-      rescue NoMethodError
-        raise InvalidLabelSetError, "#{labels} is not a valid label set"
-      end
-
-    end
-  end
-end