protor 0.0.11 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 08f75ca473acd6b2205bd2bd6eeee6436d8ee131
-  data.tar.gz: 3e4902b2fe77f54832bcb9004b77886784b89eeb
+  metadata.gz: 792b0db1c9b32cc19645c2c08afc39a5446b5834
+  data.tar.gz: f2cdf2b5eba5ec663611a0718f4c6c7fc5d7732c
 SHA512:
-  metadata.gz: 56d4a7e9dfff42ea32ec8449372c8a583bfeb0187a150d949caa59781e2b0cd9d7c3c643e6706db8e63c33a914152cb28d7a630f35eeff679d070be3ce138f78
-  data.tar.gz: c47557219550a752434337d210dd5a1396fd51bee68f6bb14ba54cf3a97ac39abe17cff18cc7e3af41416c9deb169f2ecd771da4af0b998aecdb8a5a10c8fcd4
+  metadata.gz: d551325d26dc6e8f62bd6670feb85ac1f66ef49a3a917113d014612da99770197da1f5bf6d5a6890ba046f7ec675771d3c38da50408c8d4822e6fadb769a8190
+  data.tar.gz: fd9e321c2650a27e2b8b343972157a9f1e5dabdac4f3c32e4d04f9db3dd80c9830e9c7bdf12289d4de1643ea59191d4fd9920cacba98b7dfcf149b7dce4f08f1

data/README.md

@@ -16,36 +16,39 @@ bundle install
 It automatically aggregate value
 
 ````ruby
-Protor.counter(:counter, 1, {label1: 1}) # value => 1
-Protor.counter(:counter, 1, {label1: 1}) # value => 2
+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
+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]
+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
+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
+$protor = Protor.new do |conf|
+  conf[:client] = :udp # valid option :udp and :logger, use :logger to print into a Logger
+  conf[:host] = 'localhost' # prometheus_aggregator host
+  conf[:port] = 10601 # prometheus_aggregator port
+  conf[:logger] = Rails.logger # logger to be used by protor
+  conf[:packet_size] = 56_607 # max udp packet buffer
+  conf[:formatter] = :udp # valid option only :udp, format to send
 end
 ````
 

data/lib/protor.rb

@@ -1,50 +1,73 @@
 require 'monitor'
 
-require_relative 'protor/error'
-require_relative 'protor/configuration'
-require_relative 'protor/client'
+require_relative 'protor/udp_formatter'
+require_relative 'protor/udp_client'
+require_relative 'protor/logger_client'
 require_relative 'protor/registry'
 require_relative 'protor/version'
 
-module Protor
-  extend MonitorMixin
-end
+class Protor
+  include MonitorMixin
 
-class << Protor
-  def configuration
-    @configuration ||= Protor::Configuration.new
-  end
+  DEFAULT_CONFIG = {
+    client: :udp,
+    formatter: :udp,
+    host: 'localhost',
+    port: 10601,
+    packet_size: 56_607
+  }
+
+  attr_reader :config, :registry
 
-  def configure
-    yield(configuration)
+  def initialize(&block)
+    super(&block)
+
+    @config = DEFAULT_CONFIG.dup
+    @registry = Registry.new
+    yield(config) if block_given?
   end
 
   def publish
-    synchronize do
-      unless registry.empty?
-        client.publish(registry)
-        reset
-      end
-    end
+    safely{ client.publish(registry) }
+    logger.debug("publish") if logger
   end
 
   [:counter, :gauge, :histogram].each do |method|
-    define_method method do |*args, &block|
-      synchronize{ registry.public_send(method, *args, &block) }
+    define_method method do |*args|
+      safely{ registry.public_send(method, *args) }
+      logger.debug("#{method} #{args}") if logger
     end
   end
 
   private
 
+  def safely(&block)
+    synchronize(&block)
+  rescue StandardError => err
+    logger.error(err) if logger
+    raise err unless silent
+  end
+
   def client
-    @client ||= Protor::Client.new(configuration)
+    @client ||=
+      case config[:client]
+      when :udp; UDPClient.new(config[:host], config[:port], formatter)
+      when :logger; LoggerClient.new(logger, formatter)
+      end
+  end
+
+  def formatter
+    @formatter ||=
+      case config[:formatter]
+      when :udp; UDPFormatter.new(config[:packet_size])
+      end
   end
 
-  def registry
-    @registry || reset
+  def logger
+    config[:logger]
   end
 
-  def reset
-    @registry = Protor::Registry.new(configuration)
+  def silent
+    config[:silent]
   end
 end

data/lib/protor/entry.rb

@@ -0,0 +1,66 @@
+class Protor
+  class Entry
+    attr_reader :name, :type, :value, :labels, :additional
+    attr_writer :value
+
+    VALID_NAME        = /^[a-zA-Z_:][a-zA-Z0-9_:]+$/
+    VALID_TYPE        = [:c, :g, :h]
+    VALID_LABEL_NAME  = /^[a-zA-Z_][a-zA-Z0-9_]*$/
+    VALID_LABEL_VALUE = /^[^;|=]+$/
+
+    def initialize(name, type, value, labels = nil, additional = nil)
+      @name       = name.to_s
+      @type       = type
+      @value      = value
+      @labels     = labels || {}
+      @additional = additional || []
+
+      verify
+    end
+
+    private
+
+    def verify
+      raise InvalidNameError, name unless name =~ VALID_NAME
+      raise InvalidTypeError, type unless VALID_TYPE.include?(type)
+      labels.each do |k, v|
+        raise InvalidLabelNameError, labels unless k =~ VALID_LABEL_NAME
+        raise InvalidLabelValueError, labels unless v =~ VALID_LABEL_VALUE
+      end
+      additional.each do |a|
+        raise InvalidAdditionalError, additional unless a.is_a?(Numeric)
+      end
+    end
+
+  end
+
+  class InvalidNameError < StandardError
+    def initialize(message)
+      super("Invalid name #{message}, please satisfy /^[a-zA-Z_:][a-zA-Z0-9_:]+$/")
+    end
+  end
+
+  class InvalidTypeError < StandardError
+    def initialize(message)
+      super("Invalid type #{message}, allowed types are [c, g, h]")
+    end
+  end
+
+  class InvalidLabelNameError < StandardError
+    def initialize(message)
+      super("Invalid label name #{message}, please satisfy /^[a-zA-Z_][a-zA-Z0-9_]*$/")
+    end
+  end
+
+  class InvalidLabelValueError < StandardError
+    def initialize(message)
+      super("Invalid label value #{message}, please satisfy /^[^;|=\s]+$/")
+    end
+  end
+
+  class InvalidAdditionalError < StandardError
+    def initialize(message)
+      super("Invalid additional {message}, additional must be numbers")
+    end
+  end
+end

data/lib/protor/entry_family.rb

@@ -0,0 +1,25 @@
+class Protor
+  class EntryFamily
+    attr_reader :name, :type, :data
+
+    def initialize(name, type)
+      @name = name
+      @type = type
+      @data = {}
+    end
+
+    def []=(label, value)
+      data[label] = value
+    end
+
+    def [](label)
+      data[label]
+    end
+
+    def each
+      return unless block_given?
+
+      data.each_value{ |d| yield(d) }
+    end
+  end
+end

data/lib/protor/logger_client.rb

@@ -0,0 +1,16 @@
+class Protor
+  class LoggerClient
+    attr_reader :logger, :formatter
+
+    def initialize(logger, formatter)
+      @logger = logger
+      @formatter = formatter
+    end
+
+    def publish(payload)
+      formatter.format(payload) do |msg|
+        logger.info(msg)
+      end
+    end
+  end
+end

data/lib/protor/registry.rb

@@ -1,70 +1,84 @@
-require_relative 'payload'
-require_relative 'accumulator'
-require_relative 'observer'
+require_relative 'entry'
+require_relative 'entry_family'
 
-module Protor
+class Protor
   class Registry
-    HistogramDefaultBuckets = [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10].freeze
+    attr_reader :families
 
-    def initialize(options)
-      @options = options
+    DEFAULT_BUCKET = [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10].freeze
+
+    def initialize
+      @families = {}
     end
 
     def counter(metric_name, value, labels = {})
-      verify_label(labels)
-      counter_data.inc(metric_name, value, labels)
+      labels = stringify(labels)
+      fam = family(metric_name, :counter)
+
+      if (entry = fam[labels])
+        entry.value += value
+      else
+        fam[labels] = Entry.new(metric_name, :c, value, labels)
+      end
     end
 
     def gauge(metric_name, value, labels = {})
-      verify_label(labels)
-      gauge_data.set(metric_name, value, labels)
+      labels = stringify(labels)
+      fam = family(metric_name, :gauge)
+
+      if (entry = fam[labels])
+        entry.value = value
+      else
+        fam[labels] = Entry.new(metric_name, :g, value, labels)
+      end
     end
 
-    def histogram(metric_name, value, labels = {}, buckets = HistogramDefaultBuckets)
-      verify_label(labels)
-      histogram_data.observe(metric_name, value, labels, buckets)
+    def histogram(metric_name, value, labels = {}, buckets = DEFAULT_BUCKET)
+      labels = stringify(labels)
+      fam = family(metric_name, :histogram)
+
+      entry = Entry.new(metric_name, :h, value, labels, buckets)
+      if (array = fam[labels])
+        array << entry
+      else
+        fam[labels] = [ entry ]
+      end
     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)
+      families.each_value do |family|
+        if family.type == :histogram
+          family.each{ |arr| arr.each{ |e| yield(e) }}
+        else
+          family.each{ |e| yield(e) }
         end
       end
-
-      yield payload.to_s
     end
 
     def empty?
-      [@counter, @gauge, @histogram].all?{ |metrics| metrics && metrics.empty? }
+      families.empty?
     end
 
     private
 
-    attr_reader :options
-
-    def verify_label(label)
-      raise LabelError.new("Need Hash as labels, but found #{label.class.name}") if label && !label.is_a?(Hash)
-    end
-
-    def counter_data
-      @counter ||= Accumulator.new(:counter)
+    def stringify(labels)
+      {}.tap do |h|
+        labels.each{ |k, v| h[k.to_s] = v.to_s }
+      end
     end
 
-    def gauge_data
-      @gauge ||= Accumulator.new(:gauge)
-    end
+    def family(name, type)
+      families[name] ||= EntryFamily.new(name, type)
+      family = families[name]
+      raise IncompatibleTypeError.new(name, family.type, type) if family.type != type
 
-    def histogram_data
-      @histogram ||= Observer.new(:histogram)
+      return family
     end
+  end
 
-    def all_data
-      [counter_data.to_a, gauge_data.to_a, histogram_data.to_a].flatten
+  class IncompatibleTypeError < StandardError
+    def initialize(name, previous, now)
+      super("Incompatible type for metric #{name}, previously it was a #{previous}, now it is a #{now}")
     end
   end
 end

data/lib/protor/udp_client.rb

@@ -0,0 +1,31 @@
+require 'socket'
+
+class Protor
+  class UDPClient
+    attr_reader :host, :port, :formatter, :connection
+
+    def initialize(host, port, formatter)
+      @port = port
+      @host = host
+      @formatter = formatter
+    end
+
+    def publish(payload)
+      connect do |conn|
+        formatter.format(payload) do |msg|
+          conn.send(msg, 0)
+        end
+      end
+    end
+
+    private
+
+    def connect
+      connection = UDPSocket.new
+      connection.connect(host, port)
+      yield(connection)
+    ensure
+      connection.close unless connection.closed?
+    end
+  end
+end

data/lib/protor/udp_formatter.rb

@@ -0,0 +1,50 @@
+class Protor
+  class UDPFormatter
+    attr_reader :max_packet_size
+
+    LF = "\n".freeze
+
+    def initialize(max_packet_size)
+      @max_packet_size = max_packet_size
+    end
+
+    def format(registry)
+      return unless block_given?
+
+      str = ""
+      size = 0
+      registry.each do |entry|
+        line = stringify(entry)
+
+        if size + line.size > max_packet_size
+          yield(str)
+          str = line
+          size = line.size
+        else
+          str << line
+          size += line.size
+        end
+      end
+      yield(str)
+    end
+
+    private
+
+    def stringify(entry)
+      "#{ entry.name }|#{ entry.type }|".tap do |str|
+        str << "#{ additional_string(entry.additional) }|" unless entry.additional.empty?
+        str << "#{ labels_string(entry.labels) }|" unless entry.labels.empty?
+        str << "#{ entry.value }#{LF}"
+      end
+    end
+
+    def labels_string(labels)
+      labels.map{ |k, v| "#{k}=#{v}" }.join(';')
+    end
+
+    def additional_string(additional)
+      additional.join(';')
+    end
+  end
+end
+

data/lib/protor/version.rb

@@ -1,3 +1,3 @@
-module Protor
-  VERSION = '0.0.11'
+class Protor
+  VERSION = '0.1.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: protor
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.1.0
 platform: ruby
 authors:
 - Roland Rinfandi Utama
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-22 00:00:00.000000000 Z
+date: 2017-03-08 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -19,13 +19,12 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/protor.rb
-- lib/protor/accumulator.rb
-- lib/protor/client.rb
-- lib/protor/configuration.rb
-- lib/protor/error.rb
-- lib/protor/observer.rb
-- lib/protor/payload.rb
+- lib/protor/entry.rb
+- lib/protor/entry_family.rb
+- lib/protor/logger_client.rb
 - lib/protor/registry.rb
+- lib/protor/udp_client.rb
+- lib/protor/udp_formatter.rb
 - lib/protor/version.rb
 homepage: https://github.com/rolandhawk/protor-ruby
 licenses:

data/lib/protor/accumulator.rb

@@ -1,38 +0,0 @@
-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

@@ -1,50 +0,0 @@
-require 'socket'
-
-module Protor
-  class Client
-    def initialize(configuration)
-      @options = configuration
-      @retries = 0
-    end
-
-    def publish(payload)
-      connect
-      payload.each do |message|
-        send(message)
-      end
-    rescue Errno::EPERM, Errno::ECONNREFUSED => e
-      options.logger.error(e)
-    ensure
-      close
-    end
-
-    private
-
-    attr_reader :options, :connection, :retries
-
-    def send(message)
-      connection.send(message, 0)
-    rescue Errno::EPERM => exception
-      retries += 1
-      if retries <= 3
-        refresh && retry
-      else
-        raise exception
-      end
-    end
-
-    def connect
-      @connection = UDPSocket.new
-      @connection.connect(options.host, options.port)
-    end
-
-    def refresh
-      close
-      connect
-    end
-
-    def close
-      connection.close unless connection.closed?
-    end
-  end
-end

data/lib/protor/configuration.rb

@@ -1,23 +0,0 @@
-require 'logger'
-
-module Protor
-  class Configuration
-    attr_writer :host, :port, :max_packet_size, :logger
-
-    def host
-      @host ||= 'localhost'
-    end
-
-    def port
-      @port ||= 10601
-    end
-
-    def max_packet_size
-      @max_packet_size ||= 56_607
-    end
-
-    def logger
-      @logger ||= Logger.new(STDOUT)
-    end
-  end
-end

data/lib/protor/error.rb

@@ -1,3 +0,0 @@
-module Protor
-  class LabelError < StandardError; end
-end

data/lib/protor/observer.rb

@@ -1,47 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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?
-
-      if data[:labels]
-        data[:labels].delete_if{ |k, v| v.to_s.empty? }
-      else
-        data[:labels] = {}
-      end
-
-      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[k] == v }
-    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
-