prometheus-client 0.9.0 → 0.10.0.pre.alpha.1

data/lib/prometheus/client/gauge.rb

@@ -12,32 +12,26 @@ module Prometheus
       end
 
       # Sets the value for the given label set
-      def set(labels, value)
+      def set(value, labels: {})
         unless value.is_a?(Numeric)
           raise ArgumentError, 'value must be a number'
         end
 
-        @values[label_set_for(labels)] = value.to_f
+        @store.set(labels: label_set_for(labels), val: value)
       end
 
       # Increments Gauge value by 1 or adds the given value to the Gauge.
       # (The value can be negative, resulting in a decrease of the Gauge.)
-      def increment(labels = {}, by = 1)
+      def increment(by: 1, labels: {})
         label_set = label_set_for(labels)
-        synchronize do
-          @values[label_set] ||= 0
-          @values[label_set] += by
-        end
+        @store.increment(labels: label_set, by: by)
       end
 
       # Decrements Gauge value by 1 or subtracts the given value from the Gauge.
       # (The value can be negative, resulting in a increase of the Gauge.)
-      def decrement(labels = {}, by = 1)
+      def decrement(by: 1, labels: {})
         label_set = label_set_for(labels)
-        synchronize do
-          @values[label_set] ||= 0
-          @values[label_set] -= by
-        end
+        @store.increment(labels: label_set, by: -by)
       end
     end
   end

data/lib/prometheus/client/histogram.rb

@@ -8,61 +8,109 @@ module Prometheus
     # 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(buckets)
-          @sum = 0.0
-          @total = 0.0
-
-          buckets.each do |bucket|
-            self[bucket] = 0.0
-          end
-        end
-
-        def observe(value)
-          @sum += value
-          @total += 1
-
-          each_key do |bucket|
-            self[bucket] += 1 if value <= bucket
-          end
-        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
 
+      attr_reader :buckets
+
       # Offer a way to manually specify buckets
-      def initialize(name, docstring, base_labels = {},
-                     buckets = DEFAULT_BUCKETS)
-        raise ArgumentError, 'Unsorted buckets, typo?' unless sorted? buckets
+      def initialize(name,
+                     docstring:,
+                     labels: [],
+                     preset_labels: {},
+                     buckets: DEFAULT_BUCKETS,
+                     store_settings: {})
+        raise ArgumentError, 'Unsorted buckets, typo?' unless sorted?(buckets)
 
         @buckets = buckets
-        super(name, docstring, base_labels)
+        super(name,
+              docstring: docstring,
+              labels: labels,
+              preset_labels: preset_labels,
+              store_settings: store_settings)
+      end
+
+      def with_labels(labels)
+        self.class.new(name,
+                       docstring: docstring,
+                       labels: @labels,
+                       preset_labels: preset_labels.merge(labels),
+                       buckets: @buckets,
+                       store_settings: @store_settings)
       end
 
       def type
         :histogram
       end
 
-      def observe(labels, value)
-        if labels[:le]
-          raise ArgumentError, 'Label with name "le" is not permitted'
+      def observe(value, labels: {})
+        bucket = buckets.find {|upper_limit| upper_limit > value  }
+        bucket = "+Inf" if bucket.nil?
+
+        base_label_set = label_set_for(labels)
+
+        # This is basically faster than doing `.merge`
+        bucket_label_set = base_label_set.dup
+        bucket_label_set[:le] = bucket.to_s
+        sum_label_set = base_label_set.dup
+        sum_label_set[:le] = "sum"
+
+        @store.synchronize do
+          @store.increment(labels: bucket_label_set, by: 1)
+          @store.increment(labels: sum_label_set, by: value)
         end
+      end
+
+      # Returns a hash with all the buckets plus +Inf (count) plus Sum for the given label set
+      def get(labels: {})
+        base_label_set = label_set_for(labels)
 
-        label_set = label_set_for(labels)
-        synchronize { @values[label_set].observe(value) }
+        all_buckets = buckets + ["+Inf", "sum"]
+
+        @store.synchronize do
+          all_buckets.each_with_object({}) do |upper_limit, acc|
+            acc[upper_limit.to_s] = @store.get(labels: base_label_set.merge(le: upper_limit.to_s))
+          end.tap do |acc|
+            accumulate_buckets(acc)
+          end
+        end
+      end
+
+      # Returns all label sets with their values expressed as hashes with their buckets
+      def values
+        v = @store.all_values
+
+        result = v.each_with_object({}) do |(label_set, v), acc|
+          actual_label_set = label_set.reject{|l| l == :le }
+          acc[actual_label_set] ||= @buckets.map{|b| [b.to_s, 0.0]}.to_h
+          acc[actual_label_set][label_set[:le].to_s] = v
+        end
+
+        result.each do |(label_set, v)|
+          accumulate_buckets(v)
+        end
       end
 
       private
 
-      def default
-        Value.new(@buckets)
+      # Modifies the passed in parameter
+      def accumulate_buckets(h)
+        bucket_acc = 0
+        buckets.each do |upper_limit|
+          bucket_value = h[upper_limit.to_s]
+          h[upper_limit.to_s] += bucket_acc
+          bucket_acc += bucket_value
+        end
+
+        inf_value = h["+Inf"] || 0.0
+        h["+Inf"] = inf_value + bucket_acc
+      end
+
+      def reserved_labels
+        [:le]
       end
 
       def sorted?(bucket)

data/lib/prometheus/client/label_set_validator.rb

@@ -6,18 +6,22 @@ module Prometheus
     # Prometheus specification.
     class LabelSetValidator
       # TODO: we might allow setting :instance in the future
-      RESERVED_LABELS = [:job, :instance].freeze
+      BASE_RESERVED_LABELS = [:job, :instance].freeze
 
       class LabelSetError < StandardError; end
       class InvalidLabelSetError < LabelSetError; end
       class InvalidLabelError < LabelSetError; end
       class ReservedLabelError < LabelSetError; end
 
-      def initialize
+      attr_reader :expected_labels, :reserved_labels
+
+      def initialize(expected_labels:, reserved_labels: [])
+        @expected_labels = expected_labels.sort
+        @reserved_labels = BASE_RESERVED_LABELS + reserved_labels
         @validated = {}
       end
 
-      def valid?(labels)
+      def validate_symbols!(labels)
         unless labels.respond_to?(:all?)
           raise InvalidLabelSetError, "#{labels} is not a valid label set"
         end
@@ -29,24 +33,24 @@ module Prometheus
         end
       end
 
-      def validate(labels)
-        return labels if @validated.key?(labels.hash)
+      def validate_labelset!(labelset)
+        return labelset if @validated.key?(labelset.hash)
 
-        valid?(labels)
+        validate_symbols!(labelset)
 
-        unless @validated.empty? || match?(labels, @validated.first.last)
+        unless keys_match?(labelset)
           raise InvalidLabelSetError, "labels must have the same signature " \
-                                      "(keys given: #{labels.keys.sort} vs." \
-                                      " keys expected: #{@validated.first.last.keys.sort}"
+                                      "(keys given: #{labelset.keys.sort} vs." \
+                                      " keys expected: #{expected_labels}"
         end
 
-        @validated[labels.hash] = labels
+        @validated[labelset.hash] = labelset
       end
 
       private
 
-      def match?(a, b)
-        a.keys.sort == b.keys.sort
+      def keys_match?(labelset)
+        labelset.keys.sort == expected_labels
       end
 
       def validate_symbol(key)
@@ -62,7 +66,7 @@ module Prometheus
       end
 
       def validate_reserved_key(key)
-        return true unless RESERVED_LABELS.include?(key)
+        return true unless reserved_labels.include?(key)
 
         raise ReservedLabelError, "#{key} is reserved"
       end

data/lib/prometheus/client/metric.rb

@@ -7,42 +7,63 @@ module Prometheus
   module Client
     # Metric
     class Metric
-      attr_reader :name, :docstring, :base_labels
+      attr_reader :name, :docstring, :preset_labels
 
-      def initialize(name, docstring, base_labels = {})
-        @mutex = Mutex.new
-        @validator = LabelSetValidator.new
-        @values = Hash.new { |hash, key| hash[key] = default }
+      def initialize(name,
+                     docstring:,
+                     labels: [],
+                     preset_labels: {},
+                     store_settings: {})
 
         validate_name(name)
         validate_docstring(docstring)
-        @validator.valid?(base_labels)
+        @validator = LabelSetValidator.new(expected_labels: labels,
+                                           reserved_labels: reserved_labels)
+        @validator.validate_symbols!(labels)
+        @validator.validate_symbols!(preset_labels)
+
+        @labels = labels
+        @store_settings = store_settings
 
         @name = name
         @docstring = docstring
-        @base_labels = base_labels
+        @preset_labels = preset_labels
+
+        @store = Prometheus::Client.config.data_store.for_metric(
+          name,
+          metric_type: type,
+          metric_settings: store_settings
+        )
+
+        if preset_labels.keys.length == labels.length
+          @validator.validate_labelset!(preset_labels)
+          @all_labels_preset = true
+        end
       end
 
       # Returns the value for the given label set
-      def get(labels = {})
-        @validator.valid?(labels)
+      def get(labels: {})
+        label_set = label_set_for(labels)
+        @store.get(labels: label_set)
+      end
 
-        @values[labels]
+      def with_labels(labels)
+        self.class.new(name,
+                       docstring: docstring,
+                       labels: @labels,
+                       preset_labels: preset_labels.merge(labels),
+                       store_settings: @store_settings)
       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
+        @store.all_values
       end
 
       private
 
-      def default
-        nil
+      def reserved_labels
+        []
       end
 
       def validate_name(name)
@@ -62,11 +83,9 @@ module Prometheus
       end
 
       def label_set_for(labels)
-        @validator.validate(labels)
-      end
-
-      def synchronize
-        @mutex.synchronize { yield }
+        # We've already validated, and there's nothing to merge. Save some cycles
+        return preset_labels if @all_labels_preset && labels.empty?
+        @validator.validate_labelset!(preset_labels.merge(labels))
       end
     end
   end

data/lib/prometheus/client/registry.rb

@@ -37,21 +37,39 @@ module Prometheus
         end
       end
 
-      def counter(name, docstring, base_labels = {})
-        register(Counter.new(name, docstring, base_labels))
+      def counter(name, docstring:, labels: [], preset_labels: {}, store_settings: {})
+        register(Counter.new(name,
+                             docstring: docstring,
+                             labels: labels,
+                             preset_labels: preset_labels,
+                             store_settings: {}))
       end
 
-      def summary(name, docstring, base_labels = {})
-        register(Summary.new(name, docstring, base_labels))
+      def summary(name, docstring:, labels: [], preset_labels: {}, store_settings: {})
+        register(Summary.new(name,
+                             docstring: docstring,
+                             labels: labels,
+                             preset_labels: preset_labels,
+                             store_settings: {}))
       end
 
-      def gauge(name, docstring, base_labels = {})
-        register(Gauge.new(name, docstring, base_labels))
+      def gauge(name, docstring:, labels: [], preset_labels: {}, store_settings: {})
+        register(Gauge.new(name,
+                           docstring: docstring,
+                           labels: labels,
+                           preset_labels: preset_labels,
+                           store_settings: {}))
       end
 
-      def histogram(name, docstring, base_labels = {},
-                    buckets = Histogram::DEFAULT_BUCKETS)
-        register(Histogram.new(name, docstring, base_labels, buckets))
+      def histogram(name, docstring:, labels: [], preset_labels: {},
+                    buckets: Histogram::DEFAULT_BUCKETS,
+                    store_settings: {})
+        register(Histogram.new(name,
+                               docstring: docstring,
+                               labels: labels,
+                               preset_labels: preset_labels,
+                               buckets: buckets,
+                               store_settings: {}))
       end
 
       def exist?(name)

data/lib/prometheus/client/summary.rb

@@ -1,63 +1,54 @@
 # 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.
+    # provides the total count and sum of observations.
     class Summary < Metric
-      extend Gem::Deprecate
-
-      # 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 observe(labels, value)
-        label_set = label_set_for(labels)
-        synchronize { @values[label_set].observe(value) }
+      def observe(value, labels: {})
+        base_label_set = label_set_for(labels)
+
+        @store.synchronize do
+          @store.increment(labels: base_label_set.merge(quantile: "count"), by: 1)
+          @store.increment(labels: base_label_set.merge(quantile: "sum"), by: value)
+        end
       end
-      alias add observe
-      deprecate :add, :observe, 2016, 10
 
-      # Returns the value for the given label set
-      def get(labels = {})
-        @validator.valid?(labels)
+      # Returns a hash with "sum" and "count" as keys
+      def get(labels: {})
+        base_label_set = label_set_for(labels)
+
+        internal_counters = ["count", "sum"]
 
-        synchronize do
-          Value.new(@values[labels])
+        @store.synchronize do
+          internal_counters.each_with_object({}) do |counter, acc|
+            acc[counter] = @store.get(labels: base_label_set.merge(quantile: counter))
+          end
         end
       end
 
-      # Returns all label sets with their values
+      # Returns all label sets with their values expressed as hashes with their sum/count
       def values
-        synchronize do
-          @values.each_with_object({}) do |(labels, value), memo|
-            memo[labels] = Value.new(value)
-          end
+        v = @store.all_values
+
+        v.each_with_object({}) do |(label_set, v), acc|
+          actual_label_set = label_set.reject{|l| l == :quantile }
+          acc[actual_label_set] ||= { "count" => 0.0, "sum" => 0.0 }
+          acc[actual_label_set][label_set[:quantile]] = v
         end
       end
 
       private
 
-      def default
-        Quantile::Estimator.new
+      def reserved_labels
+        [:quantile]
       end
     end
   end