protor 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 537a3afb0cc18e89d25b042061ca0ddebb5b5db6
+  data.tar.gz: 4470654d6e40c9554e88c4b6f652d96ea3fb11ed
+SHA512:
+  metadata.gz: 8c745d4dfe654901355e910ef80411451a04029c33383e92a8c066be490f1fa20591ac221504ff18463a7aec663c47c92218a372be5299aece418312dbc9f5c8
+  data.tar.gz: ba8dd56a6c69e65af5da3f84352ef3de50baff2b1f51c881d9ffc65e559819b0dbada0384da225e3034a50a600735a7cea65c349e223d25f740b8d538b367795

data/README.md

@@ -0,0 +1,53 @@
+# protor-ruby
+[Prometheus aggregator](https://github.com/rolandhawk/prometheus-aggregator) client for ruby
+
+## Installation
+In Gemfile
+````ruby
+gem 'protor'
+````
+Then run
+````shell
+bundle install
+````
+
+## Usage
+### Counter
+It automatically aggregate value
+
+````ruby
+Protor.counter(:counter, 1, {label1: 1}) # value => 1
+Protor.counter(:counter, 1, {label1: 1}) # value => 2
+````
+### Gauge
+It automatically replace value
+````ruby
+Protor.gauge(:gauge, 50) # value 50
+Protor.gauge(:gauge, 20) # value 20
+````
+
+### Histogram
+It save all observed values
+````ruby
+Protor.histogram(:histogram, 10, {label1: 1}, [1,2,3,4]) # observed value [10]
+Protor.histogram(:histogram, 2, {label1: 1}, [1,2,3,4](  # observed value [10,2]
+````
+
+### Publish
+To publish all saved metrics to aggregator
+````ruby
+Protor.publish
+````
+
+## Configuration
+To configure protor:
+````ruby
+Protor.configure do |config|
+  config.host = 'localhost'      # aggregator host, default to localhost
+  config.port = 10601            # aggregator port, default to 10601
+  config.max_packet_size = 56607 # max udp packet buffer, default to 56607
+end
+````
+
+## Contributing
+[Fork the project](https://github.com/rolandhawk/protor-ruby) and send pull requests.

data/lib/protor.rb

@@ -0,0 +1,49 @@
+require 'monitor'
+
+require_relative 'protor/configuration'
+require_relative 'protor/client'
+require_relative 'protor/registry'
+require_relative 'protor/version'
+
+module Protor
+  extend MonitorMixin
+end
+
+class << Protor
+  def configuration
+    @configuration ||= Protor::Configuration.new
+  end
+
+  def configure
+    yield(configuration)
+  end
+
+  def publish
+    synchronize do
+      unless @registry.empty?
+        client.publish(registry)
+        reset
+      end
+    end
+  end
+
+  [:counter, :gauge, :histogram].each do |method|
+    define_method method do |*args, &block|
+      synchronize{ registry.public_send(method, *args, &block) }
+    end
+  end
+
+  private
+
+  def client
+    @client ||= Protor::Client.new(configuration)
+  end
+
+  def registry
+    @registry || reset
+  end
+
+  def reset
+    @registry = Protor::Registry.new(configuration)
+  end
+end

data/lib/protor/accumulator.rb

@@ -0,0 +1,38 @@
+module Protor
+  class Accumulator
+    def initialize(type)
+      @data = {}
+      @type = type
+    end
+
+    def inc(metric_name, value, labels = {})
+      data[metric_name] ||= Hash.new(0)
+      data[metric_name][labels] += value
+    end
+
+    def set(metric_name, value, labels = {})
+      data[metric_name] ||= Hash.new(0)
+      data[metric_name][labels] = value
+    end
+
+    def to_a
+      array = []
+
+      data.each do |metric_name, values|
+        values.each do |labels, value|
+          array << { metric_name: metric_name, labels: labels, value: value, type: type }
+        end
+      end
+
+      return array
+    end
+
+    def empty?
+      data.empty?
+    end
+
+    private
+
+    attr_reader :type, :data
+  end
+end

data/lib/protor/client.rb

@@ -0,0 +1,30 @@
+require 'socket'
+
+module Protor
+  class Client
+    def initialize(configuration)
+      @options = configuration
+    end
+
+    def publish(payload)
+      established do |connection|
+        payload.each{ |str| connection.send(str, 0) }
+      end
+    end
+
+    private
+
+    attr_reader :options
+
+    def established
+      socket = UDPSocket.new
+      socket.connect(options.host, options.port)
+      yield socket
+    rescue Errno::ECONNREFUSED => exception
+      # omit error, it caused by aggregate server being down
+      exception
+    ensure
+      socket.close unless socket.closed?
+    end
+  end
+end

data/lib/protor/configuration.rb

@@ -0,0 +1,17 @@
+module Protor
+  class Configuration
+    attr_writer :host, :port, :max_packet_size
+
+    def host
+      @host ||= 'localhost'
+    end
+
+    def port
+      @port ||= 10601
+    end
+
+    def max_packet_size
+      @max_packet_size ||= 56_607
+    end
+  end
+end

data/lib/protor/observer.rb

@@ -0,0 +1,47 @@
+module Protor
+  class Observer
+    def initialize(type)
+      @data = {}
+      @type = type
+    end
+
+    def observe(metric_name, value, labels = {}, additional = [])
+      data[metric_name] ||= { values: {} }
+      data[metric_name][:values][labels] ||= []
+
+      data[metric_name][:additional] = additional
+      data[metric_name][:values][labels] << value
+    end
+
+    def to_a
+      array = []
+
+      data.each do |metric_name, values|
+        first = true
+        values[:values].each do |labels, value|
+          value.each do |val|
+            array << {
+              metric_name: metric_name,
+              labels: labels,
+              value: val,
+              additional: values[:additional],
+              first: first,
+              type: type
+            }
+            first = false
+          end
+        end
+      end
+
+      return array
+    end
+
+    def empty?
+      data.empty?
+    end
+
+    private
+
+    attr_reader :data, :type
+  end
+end

data/lib/protor/payload.rb

@@ -0,0 +1,100 @@
+module Protor
+  class Payload
+
+    Lf = "\n".freeze
+
+
+    def initialize(max_packet_size)
+      @max_packet_size = max_packet_size
+      @lines = []
+      @total_size = 0
+    end
+
+    def add(data)
+      data = data.dup
+      data[:first] = true if lines.empty?
+
+      return false if packet_overflow?(data)
+
+      self.common_labels = data[:labels]
+      @total_size += data_size(data)
+      @lines << data
+    end
+
+    def to_s
+      str = first_line
+      lines.each do |data|
+        line = template(data)
+        str << "#{line}#{Lf}"
+      end
+
+      return str
+    end
+
+    private
+
+    attr_reader :common_labels, :lines, :total_size, :max_packet_size
+
+    def data_size(data)
+      size = 3
+      [:metric_name, :value].each do |key|
+        size += data[key].to_s.size
+      end
+
+      size += labels_string(data[:labels]).size + 1 if data[:labels]
+
+      size += additional_string(data[:additional]).size + 1 if data[:first] && data[:additional]
+
+      return size
+    end
+
+    def common_labels=(labels = {})
+      @common_labels ||= labels.dup
+      intersect(common_labels, labels)
+      @common_labels.keep_if{ |k, v| labels.key? k }
+    end
+
+    def first_line
+      if !common_labels || common_labels.empty?
+        ""
+      else
+        "#{labels_string(common_labels)}#{Lf}"
+      end
+    end
+
+    def template(data)
+      labels = exclude_common(data[:labels])
+
+      "#{ data[:metric_name] }|#{ data[:type][0] }|".tap do |str|
+        str << "#{ additional_string(data[:additional]) }|" if data[:first] && data[:additional]
+        str << "#{ labels_string(labels) }|" unless labels.empty?
+        str << "#{ data[:value] }"
+      end
+    end
+
+    def labels_string(labels)
+      labels.map{ |k, v| "#{k}=#{v}" }.join(';')
+    end
+
+    def additional_string(additional)
+      additional.join(';')
+    end
+
+    def intersect(a, b)
+      a.keep_if{ |k, v| b.key? k }
+    end
+
+    def exclude_common(labels)
+      labels.keep_if{ |k, v| !common_labels[k] }
+    end
+
+    def packet_overflow?(data)
+      backup = common_labels && common_labels.dup || data[:labels]
+      intersect(backup, data[:labels])
+      size = data_size(data)
+
+      total_size + size - (labels_string(backup).size * lines.size) > max_packet_size
+    end
+  end
+end
+

data/lib/protor/registry.rb

@@ -0,0 +1,63 @@
+require_relative 'payload'
+require_relative 'accumulator'
+require_relative 'observer'
+
+module Protor
+  class Registry
+    HistogramDefaultBuckets = [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10].freeze
+
+    def initialize(options)
+      @options = options
+    end
+
+    def counter(metric_name, value, labels = {})
+      counter_data.inc(metric_name, value, labels)
+    end
+
+    def gauge(metric_name, value, labels = {})
+      gauge_data.set(metric_name, value, labels)
+    end
+
+    def histogram(metric_name, value, labels = {}, buckets = HistogramDefaultBuckets)
+      histogram_data.observe(metric_name, value, labels, buckets)
+    end
+
+    def each
+      payload = Payload.new options.max_packet_size
+      all_data.each do |data|
+        unless payload.add(data)
+          yield payload.to_s
+
+          payload = Payload.new options.max_packet_size
+          payload.add(data)
+        end
+      end
+
+      yield payload.to_s
+    end
+
+    def empty?
+      [@counter, @gauge, @histogram].all?{ |metrics| metrics && metrics.empty? }
+    end
+
+    private
+
+    attr_reader :options
+
+    def counter_data
+      @counter ||= Accumulator.new(:counter)
+    end
+
+    def gauge_data
+      @gauge ||= Accumulator.new(:gauge)
+    end
+
+    def histogram_data
+      @histogram ||= Observer.new(:histogram)
+    end
+
+    def all_data
+      [counter_data.to_a, gauge_data.to_a, histogram_data.to_a].flatten
+    end
+  end
+end

data/lib/protor/version.rb

@@ -0,0 +1,3 @@
+module Protor
+  VERSION = '0.0.3'
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: protor
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Roland Rinfandi Utama
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-18 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- roland_hawk@yahoo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/protor.rb
+- lib/protor/accumulator.rb
+- lib/protor/client.rb
+- lib/protor/configuration.rb
+- lib/protor/observer.rb
+- lib/protor/payload.rb
+- lib/protor/registry.rb
+- lib/protor/version.rb
+homepage: https://github.com/rolandhawk/protor-ruby
+licenses:
+- MIT
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Prometheus aggregator client for ruby.
+test_files: []