riemann-client 1.0.0 → 1.1.0

data/lib/riemann/event.rb

@@ -1,10 +1,12 @@
+# 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
@@ -22,9 +24,9 @@ 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
 
@@ -44,12 +46,10 @@ 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)
@@ -59,7 +59,8 @@ module Riemann
       init.time_micros = begin
         times = states.map(&:time_micros).compact
         (times.inject(:+) / times.size).to_i
-      rescue
+      rescue ZeroDivisionError
+        nil
       end
       init.time_micros ||= now
 
@@ -78,12 +79,10 @@ 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)
@@ -93,7 +92,8 @@ module Riemann
       init.time_micros = begin
         times = states.map(&:time_micros).compact
         (times.inject(:+) / times.size).to_i
-      rescue
+      rescue ZeroDivisionError
+        nil
       end
       init.time_micros ||= now
 
@@ -111,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|
@@ -127,7 +125,8 @@ module Riemann
       init.time_micros = begin
         times = states.map(&:time_micros).compact
         (times.inject(:+) / times.size).to_i
-      rescue
+      rescue ZeroDivisionError
+        nil
       end
       init.time_micros ||= now
 
@@ -135,23 +134,23 @@ module Riemann
     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
 
@@ -172,19 +171,15 @@ 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
@@ -200,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 = '1.0.0'
+  VERSION = '1.1.0'
 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

@@ -1,5 +1,8 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+require 'English'
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'riemann/version'
 
@@ -14,15 +17,17 @@ Gem::Specification.new do |spec|
   spec.license       = 'MIT'
   spec.platform      = Gem::Platform::RUBY
 
-  spec.files         = `git ls-files`.split($/)
+  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.7.0'
+  spec.required_ruby_version = '>= 2.6.0'
 
   spec.add_development_dependency 'bundler', '>= 1.3'
-  spec.add_development_dependency 'bacon'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'rubocop-rspec'
   spec.add_development_dependency 'timecop'
 
   spec.add_dependency 'beefcake', ['>= 1.0.0 ']

data/spec/client_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'riemann'
+require 'riemann/client'
+
+require 'spec_helper'
+require 'shared_examples'
+
+RSpec.describe 'Riemann::Client' do
+  let(:client) do
+    Riemann::Client.new(host: 'localhost', port: 5555)
+  end
+
+  let(:expected_rate) { 100 }
+
+  context('with TLS transport') do
+    let(:client) do
+      Riemann::Client.new(host: 'localhost', port: 5554, ssl: true,
+                          key_file: '/etc/riemann/riemann_server.pkcs8',
+                          cert_file: '/etc/riemann/riemann_server.crt',
+                          ca_file: '/etc/riemann/riemann_server.crt',
+                          ssl_verify: true)
+    end
+    let(:client_with_transport) { client.tcp }
+
+    it_behaves_like 'a riemann client'
+    it_behaves_like 'a riemann client that acknowledge messages'
+  end
+
+  context 'with TCP transport' do
+    let(:client_with_transport) { client.tcp }
+
+    it_behaves_like 'a riemann client'
+    it_behaves_like 'a riemann client that acknowledge messages'
+  end
+
+  context('with UDP transport') do
+    let(:client_with_transport) { client.udp }
+    let(:expected_rate) { 1000 }
+
+    it_behaves_like 'a riemann client'
+    it_behaves_like 'a riemann client that does not acknowledge messages'
+
+    context 'when sending a message too large for UDP transport' do
+      let(:large_message) do
+        {
+          data: 'X' * (Riemann::Client::UDP::MAX_SIZE + 10)
+        }
+      end
+
+      before do
+        allow(client.udp).to receive(:send_maybe_recv).and_call_original
+        allow(client.tcp).to receive(:send_maybe_recv).and_call_original
+        client << large_message
+      end
+
+      it 'has tried to send the message using UDP' do
+        expect(client.udp).to have_received(:send_maybe_recv)
+      end
+
+      it 'has retried to send the message using TCP' do
+        expect(client.tcp).to have_received(:send_maybe_recv)
+      end
+    end
+  end
+end