prometheus-client-mmap 0.7.0.beta1

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 = {})
+        register(Gauge.new(name, docstring, base_labels))
+      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/summary.rb

@@ -0,0 +1,71 @@
+# 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
+      extend Gem::Deprecate
+
+      # Value represents the state of a Summary at a given point.
+      class Value < Hash
+        attr_accessor :sum, :total
+
+        def initialize(name, labels, estimator)
+          @sum = ValueClass.new(name, name + '_sum', labels, estimator.sum)
+          @total = ValueClass.new(name, name + '_count', labels, estimator.observations)
+
+          estimator.invariants.each do |invariant|
+            self[invariant.quantile] = ValueClass.new(type, name, labels, estimator.query(invariant.quantile), nil)
+          end
+        end
+      end
+
+      def initialize(name, docstring, base_labels = {}, multiprocess_mode)
+        if ENV['prometheus_multiproc_dir']
+          raise ArgumentError, "Summary metric type does not have multiprocess support"
+        end
+        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
+          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(labels)
+        Quantile::Estimator.new
+      end
+    end
+  end
+end

data/lib/prometheus/client/valuetype.rb

@@ -0,0 +1,204 @@
+# encoding: UTF-8
+
+require "json"
+require "mmap"
+
+module Prometheus
+  module Client
+    class SimpleValue
+      def initialize(type, metric_name, name, labels, value = 0)
+        @value = value
+      end
+
+      def set(value)
+        @value = value
+      end
+
+      def increment(by = 1)
+        @value += by
+      end
+
+      def get
+        @value
+      end
+
+      def self.multiprocess
+        false
+      end
+    end
+
+    # A float protected by a mutex backed by a per-process mmaped file.
+    class MmapedValue
+      @@files = {}
+      @@files_lock = Mutex.new
+      @@pid = Process.pid
+
+      def initialize(type, metric_name, name, labels, multiprocess_mode='')
+        @@pid = Process.pid
+        file_prefix = type.to_s
+        if type == :gauge
+          file_prefix += '_' +  multiprocess_mode.to_s
+        end
+
+        @@files_lock.synchronize do
+          if !@@files.has_key?(file_prefix)
+            filename = File.join(ENV['prometheus_multiproc_dir'], "#{file_prefix}_#{@@pid}.db")
+            @@files[file_prefix] = MmapedDict.new(filename)
+          end
+        end
+
+        @file = @@files[file_prefix]
+        labelnames = []
+        labelvalues = []
+        labels.each do |k, v|
+          labelnames << k
+          labelvalues << v
+        end
+
+        @key = [metric_name, name, labelnames, labelvalues].to_json
+        @value = @file.read_value(@key)
+        @mutex = Mutex.new
+      end
+
+      def increment(amount=1)
+        @mutex.synchronize do
+          @value += amount
+          @file.write_value(@key, @value)
+        end
+      end
+
+      def set(value)
+        @mutex.synchronize do
+          @value = value
+          @file.write_value(@key, @value)
+        end
+      end
+
+      def get
+        @mutex.synchronize do
+          return @value
+        end
+      end
+
+      def self.multiprocess
+        true
+      end
+    end
+
+    # Should we enable multi-process mode?
+    # This needs to be chosen before the first metric is constructed,
+    # and as that may be in some arbitrary library the user/admin has
+    # no control over we use an enviroment variable.
+    if ENV.has_key?('prometheus_multiproc_dir')
+      ValueClass = MmapedValue
+    else
+      ValueClass = SimpleValue
+    end
+  end
+end
+
+# A dict of doubles, backed by an mmapped file.
+#
+# The file starts with a 4 byte int, indicating how much of it is used.
+# Then 4 bytes of padding.
+# There's then a number of entries, consisting of a 4 byte int which is the
+# size of the next field, a utf-8 encoded string key, padding to an 8 byte
+# alignment, and then a 8 byte float which is the value.
+#
+# TODO(julius): dealing with Mmap.new, truncate etc. errors?
+class MmapedDict
+  @@INITIAL_MMAP_SIZE = 1024*1024
+
+  attr_reader :m, :capacity, :used, :positions
+
+  def initialize(filename)
+    @mutex = Mutex.new
+    @f = File.open(filename, 'a+b')
+    if @f.size == 0
+      @f.truncate(@@INITIAL_MMAP_SIZE)
+    end
+    @capacity = @f.size
+    @m = Mmap.new(filename, 'rw', Mmap::MAP_SHARED)
+    # @m.mlock # TODO: Why does this raise an error?
+
+    @positions = {}
+    @used = @m[0..3].unpack('l')[0]
+    if @used == 0
+      @used = 8
+      @m[0..3] = [@used].pack('l')
+    else
+      read_all_values.each do |key, _, pos|
+        @positions[key] = pos
+      end
+    end
+  end
+
+  # Yield (key, value, pos). No locking is performed.
+  def all_values
+    read_all_values.map { |k, v, p| [k, v] }
+  end
+
+  def read_value(key)
+    @mutex.synchronize do
+      if !@positions.has_key?(key)
+        init_value(key)
+      end
+    end
+    pos = @positions[key]
+    # We assume that reading from an 8 byte aligned value is atomic.
+    @m[pos..pos+7].unpack('d')[0]
+  end
+
+  def write_value(key, value)
+    @mutex.synchronize do
+      if !@positions.has_key?(key)
+        init_value(key)
+      end
+    end
+    pos = @positions[key]
+    # We assume that writing to an 8 byte aligned value is atomic.
+    @m[pos..pos+7] = [value].pack('d')
+  end
+
+  def close()
+    @m.munmap
+    @f.close
+  end
+
+  private
+
+  # Initialize a value. Lock must be held by caller.
+  def init_value(key)
+    # Pad to be 8-byte aligned.
+    padded = key + (' ' * (8 - (key.length + 4) % 8))
+    value = [key.length, padded, 0.0].pack("lA#{padded.length}d")
+    while @used + value.length > @capacity
+      @capacity *= 2
+      @f.truncate(@capacity)
+      @m = Mmap.new(@f.path, 'rw', Mmap::MAP_SHARED)
+    end
+    @m[@used..@used + value.length] = value
+
+    # Update how much space we've used.
+    @used += value.length
+    @m[0..3] = [@used].pack('l')
+    @positions[key] = @used - 8
+  end
+
+  # Yield (key, value, pos). No locking is performed.
+  def read_all_values
+    pos = 8
+    values = []
+    while pos < @used
+      encoded_len = @m[pos..-1].unpack('l')[0]
+      pos += 4
+      encoded = @m[pos..-1].unpack("A#{encoded_len}")[0]
+      padded_len = encoded_len + (8 - (encoded_len + 4) % 8)
+      pos += padded_len
+      value = @m[pos..-1].unpack('d')[0]
+      values << [encoded, value, pos]
+      pos += 8
+    end
+    values
+  end
+end

data/lib/prometheus/client/version.rb

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

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: prometheus-client-mmap
+version: !ruby/object:Gem::Version
+  version: 0.7.0.beta1
+platform: ruby
+authors:
+- Tobias Schmidt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-04-24 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:
+- ts@soundcloud.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/text.rb
+- lib/prometheus/client/gauge.rb
+- lib/prometheus/client/histogram.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/valuetype.rb
+- lib/prometheus/client/version.rb
+homepage: https://github.com/pchojnacki/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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: A suite of instrumentation metric primitivesthat can be exposed through a
+  web services interface.
+test_files: []