riemann-client 0.2.5 → 1.0.1

data/lib/riemann/event.rb

@@ -1,16 +1,19 @@
+# frozen_string_literal: true
+
 module Riemann
   class Event
     require 'set'
     include Beefcake::Message
 
     optional :time, :int64, 1
-    optional :state, :string,  2
+    optional :state, :string, 2
     optional :service, :string, 3
     optional :host, :string, 4
     optional :description, :string, 5
     repeated :tags, :string, 7
     optional :ttl, :float, 8
     repeated :attributes, Attribute, 9
+    optional :time_micros, :int64, 10
 
     optional :metric_sint64, :sint64, 13
     optional :metric_d, :double, 14
@@ -21,12 +24,16 @@ module Riemann
     VIRTUAL_FIELDS = Set.new([:metric])
     # Fields which are specially encoded in the Event protobuf--that is, they
     # can't be used as attributes.
-    RESERVED_FIELDS = fields.map do |i, field|
+    RESERVED_FIELDS = fields.map do |_i, field|
       field.name.to_sym
-    end.reduce(VIRTUAL_FIELDS) do |set, field|
+    end.reduce(VIRTUAL_FIELDS) do |set, field| # rubocop:disable Style/MultilineBlockChain
       set << field
     end
 
+    def self.now
+      (Time.now.to_f * 1_000_000).to_i
+    end
+
     # Average a set of states together. Chooses the mean metric, the mode
     # state, mode service, and the mean time. If init is provided, its values
     # override (where present) the computed ones.
@@ -39,24 +46,23 @@ module Riemann
              end
 
       # Metric
-      init.metric_f ||= states.inject(0.0) { |a, state|
-          a + (state.metric || 0)
-        } / states.size
-      if init.metric_f.nan?
-        init.metric_f = 0.0
-      end
+      init.metric_f ||= states.inject(0.0) do |a, state|
+        a + (state.metric || 0)
+      end / states.size
+      init.metric_f = 0.0 if init.metric_f.nan?
 
       # Event
       init.state ||= mode states.map(&:state)
       init.service ||= mode states.map(&:service)
 
       # Time
-      init.time = begin
-        times = states.map(&:time).compact
+      init.time_micros = begin
+        times = states.map(&:time_micros).compact
         (times.inject(:+) / times.size).to_i
-      rescue
+      rescue ZeroDivisionError
+        nil
       end
-      init.time ||= Time.now.to_i
+      init.time_micros ||= now
 
       init
     end
@@ -73,24 +79,23 @@ module Riemann
              end
 
       # Metric
-      init.metric_f ||= states.inject(0.0) { |a, state|
-          a + (state.metric || 0)
-        }
-      if init.metric_f.nan?
-        init.metric_f = 0.0
+      init.metric_f ||= states.inject(0.0) do |a, state|
+        a + (state.metric || 0)
       end
+      init.metric_f = 0.0 if init.metric_f.nan?
 
       # Event
       init.state ||= mode states.map(&:state)
       init.service ||= mode states.map(&:service)
 
       # Time
-      init.time = begin
-        times = states.map(&:time).compact
+      init.time_micros = begin
+        times = states.map(&:time_micros).compact
         (times.inject(:+) / times.size).to_i
-      rescue
+      rescue ZeroDivisionError
+        nil
       end
-      init.time ||= Time.now.to_i
+      init.time_micros ||= now
 
       init
     end
@@ -106,12 +111,10 @@ module Riemann
              end
 
       # Metric
-      init.metric_f ||= states.inject(0.0) { |a, state|
-          a + (state.metric || 0)
-        }
-      if init.metric.nan?
-        init.metric = 0.0
+      init.metric_f ||= states.inject(0.0) do |a, state|
+        a + (state.metric || 0)
       end
+      init.metric = 0.0 if init.metric.nan?
 
       # Event
       init.state ||= states.inject(nil) do |max, state|
@@ -119,34 +122,35 @@ module Riemann
       end
 
       # Time
-      init.time = begin
-        times = states.map(&:time).compact
+      init.time_micros = begin
+        times = states.map(&:time_micros).compact
         (times.inject(:+) / times.size).to_i
-      rescue
+      rescue ZeroDivisionError
+        nil
       end
-      init.time ||= Time.now.to_i
+      init.time_micros ||= now
 
       init
     end
 
     def self.mode(array)
-      array.inject(Hash.new(0)) do |counts, e|
+      array.each_with_object(Hash.new(0)) do |e, counts|
         counts[e] += 1
-        counts
-      end.sort_by { |e, count| count }.last.first rescue nil
+      end.max_by { |_e, count| count }.first # rubocop:disable Style/MultilineBlockChain
+    rescue StandardError
+      nil
     end
 
     # Partition a list of states by a field
     # Returns a hash of field_value => state
     def self.partition(states, field)
-      states.inject({}) do |p, state|
+      states.each_with_object({}) do |state, p|
         k = state.send field
         if p.include? k
           p[k] << state
         else
           p[k] = [state]
         end
-        p
       end
     end
 
@@ -167,26 +171,22 @@ module Riemann
 
     def initialize(hash = nil)
       if hash
-        if hash[:metric]
-          super hash
-          self.metric = hash[:metric]
-        else
-          super hash
-        end
+        super hash
+        self.metric = hash[:metric] if hash[:metric]
 
         # Add extra attributes to the event as Attribute instances with values
         # converted to String
-        self.attributes = hash.map do |key, value|
+        self.attributes = hash.map do |key, _value|
           unless RESERVED_FIELDS.include? key.to_sym
-            Attribute.new(:key => key.to_s,
-                          :value => (hash[key] || hash[key.to_sym]).to_s)
+            Attribute.new(key: key.to_s,
+                          value: (hash[key] || hash[key.to_sym]).to_s)
           end
         end.compact
       else
         super()
       end
 
-      @time ||= Time.now.to_i
+      @time_micros ||= self.class.now unless @time
     end
 
     def metric
@@ -195,36 +195,35 @@ module Riemann
         metric_f
     end
 
-    def metric=(m)
-      if Integer === m and (-(2**63)...2**63) === m
+    def metric=(value)
+      if value.is_a?(Integer) && (-(2**63)...2**63).include?(value)
         # Long
-        self.metric_sint64 = m
-        self.metric_f = m.to_f
+        self.metric_sint64 = value
       else
-        self.metric_d = m.to_f
-        self.metric_f = m.to_f
+        self.metric_d = value.to_f
       end
+      self.metric_f = value.to_f
     end
 
     # Look up attributes
-    def [](k)
-      if RESERVED_FIELDS.include? k.to_sym
+    def [](key)
+      if RESERVED_FIELDS.include? key.to_sym
         super
       else
-        r = attributes.find {|a| a.key.to_s == k.to_s }.value
+        attributes.find { |a| a.key.to_s == key.to_s }.value
       end
     end
 
     # Set attributes
-    def []=(k, v)
-      if RESERVED_FIELDS.include? k.to_sym
+    def []=(key, value)
+      if RESERVED_FIELDS.include? key.to_sym
         super
       else
-        a = self.attributes.find {|a| a.key == k.to_s }
-        if(a)
-          a.value = v.to_s
+        attr = attributes.find { |a| a.key == key.to_s }
+        if attr
+          attr.value = value.to_s
         else
-          self.attributes << Attribute.new(:key => k.to_s, :value => v.to_s)
+          attributes << Attribute.new(key: key.to_s, value: value.to_s)
         end
       end
     end

data/lib/riemann/message.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Riemann
   class Message
     include Beefcake::Message

data/lib/riemann/metric_thread.rb

@@ -1,68 +1,73 @@
-class Riemann::MetricThread
-  # A metric thread is simple: it wraps some metric object which responds to <<,
-  # and every interval seconds, calls #flush which replaces the object and calls
-  # a user specified function.
- 
-  INTERVAL = 10
-  
-  attr_accessor :interval
-  attr_accessor :metric
+# frozen_string_literal: true
 
-  # client = Riemann::Client.new
-  # m = MetricThread.new Mtrc::Rate do |rate|
-  #   client << rate
-  # end
-  #
-  # loop do
-  #   sleep rand
-  #   m << rand
-  # end
-  def initialize(klass, *klass_args, &f)
-    @klass = klass
-    @klass_args = klass_args
-    @f = f
-    @interval = INTERVAL
+module Riemann
+  class MetricThread
+    # A metric thread is simple: it wraps some metric object which responds to <<,
+    # and every interval seconds, calls #flush which replaces the object and calls
+    # a user specified function.
 
-    @metric = new_metric
+    INTERVAL = 10
 
-    start
-  end
+    attr_accessor :interval, :metric
 
-  def <<(*a)
-    @metric.<<(*a)
-  end
+    # client = Riemann::Client.new
+    # m = MetricThread.new Mtrc::Rate do |rate|
+    #   client << rate
+    # end
+    #
+    # loop do
+    #   sleep rand
+    #   m << rand
+    # end
+    def initialize(klass, *klass_args, &block)
+      @klass = klass
+      @klass_args = klass_args
+      @block = block
+      @interval = INTERVAL
 
-  def new_metric
-    @klass.new *@klass_args
-  end
+      @metric = new_metric
 
-  def flush
-    old, @metric = @metric, new_metric
-    @f[old]
-  end
+      start
+    end
+
+    def <<(value)
+      @metric.<<(value)
+    end
+
+    def new_metric
+      @klass.new(*@klass_args)
+    end
+
+    def flush
+      old = @metric
+      @metric = new_metric
+      @block[old]
+    end
+
+    def start
+      raise 'already running' if @runner
 
-  def start
-    raise RuntimeError, "already running" if @runner
-  
-    @running = true
-    @runner = Thread.new do
-      while @running
-        sleep @interval
-        begin
-          flush
-        rescue Exception => e
+      @running = true
+      @runner = Thread.new do
+        while @running
+          sleep @interval
+          begin
+            flush
+          rescue StandardError
+            # ignore
+          end
         end
+        @runner = nil
       end
-      @runner = nil
     end
-  end
 
-  def stop
-    stop!
-    @runner.join
-  end
+    def stop
+      stop!
+      @runner.join
+    end
 
-  def stop!
-    @running = false
+    def stop!
+      @running = false
+    end
   end
 end

data/lib/riemann/query.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module Riemann
   class Query
     include Beefcake::Message
-  
+
     optional :string, :string, 1
-  end 
+  end
 end

data/lib/riemann/state.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Riemann
   class State
     include Beefcake::Message
-    
-    optional :time, :int64, 1 
-    optional :state, :string,  2
+
+    optional :time, :int64, 1
+    optional :state, :string, 2
     optional :service, :string, 3
     optional :host, :string, 4
     optional :description, :string, 5
@@ -12,8 +14,8 @@ module Riemann
     optional :ttl, :float, 8
     optional :metric_f, :float, 15
 
-    def initialize(*a)
-      super *a
+    def initialize
+      super
 
       @time ||= Time.now.to_i
     end
@@ -22,8 +24,6 @@ module Riemann
       @metric || metric_f
     end
 
-    def metric=(m)
-      @metric = m
-    end
+    attr_writer :metric
   end
 end

data/lib/riemann/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Riemann
-  VERSION = '0.2.5'
+  VERSION = '1.0.1'
 end

data/lib/riemann.rb

@@ -1,6 +1,6 @@
-module Riemann
-  $LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__))
+# frozen_string_literal: true
 
+module Riemann
   require 'rubygems'
   require 'beefcake'
   require 'timeout'
@@ -10,5 +10,4 @@ module Riemann
   require 'riemann/event'
   require 'riemann/query'
   require 'riemann/message'
-  require 'riemann/client'
 end

data/riemann-client.gemspec

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'English'
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'riemann/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'riemann-client'
+  spec.version       = Riemann::VERSION
+  spec.author        = 'Kyle Kingsbury'
+  spec.email         = 'aphyr@aphyr.com'
+  spec.summary       = 'Client for the distributed event system Riemann.'
+  spec.description   = 'Client for the distributed event system Riemann.'
+  spec.homepage      = 'https://github.com/aphyr/riemann-ruby-client'
+  spec.license       = 'MIT'
+  spec.platform      = Gem::Platform::RUBY
+
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 2.6.0'
+
+  spec.add_development_dependency 'bacon'
+  spec.add_development_dependency 'bundler', '>= 1.3'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'timecop'
+
+  spec.add_dependency 'beefcake', ['>= 1.0.0 ']
+  spec.add_dependency 'mtrc', '>= 0.0.4'
+end