riemann-client 1.0.0 → 1.0.1

data/lib/riemann/client/udp.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 module Riemann
   class Client
     class UDP < Client
-      MAX_SIZE = 16384
+      MAX_SIZE = 16_384
 
       attr_accessor :host, :port, :max_size
 
-      def initialize(opts = {})
+      def initialize(opts = {}) # rubocop:disable Lint/MissingSuper
         @host     = opts[:host] || HOST
         @port     = opts[:port] || PORT
         @max_size = opts[:max_size] || MAX_SIZE
@@ -13,6 +15,7 @@ module Riemann
 
       def socket
         return @socket if connected?
+
         @socket = UDPSocket.new
       end
 
@@ -26,17 +29,18 @@ module Riemann
       end
 
       # Read a message from a stream
-      def read_message(s)
+      def read_message(_socket)
         raise Unsupported
       end
 
-      def send_recv(*a)
+      def send_recv(_message)
         raise Unsupported
       end
 
       def send_maybe_recv(message)
         encoded_string = message.encode.to_s
         raise TooBig unless encoded_string.length < @max_size
+
         socket.send(encoded_string, 0, @host, @port)
         nil
       end

data/lib/riemann/client.rb

@@ -1,111 +1,110 @@
+# frozen_string_literal: true
+
 require 'riemann'
 
-class Riemann::Client
-  class Error < RuntimeError; end
-  class InvalidResponse < Error; end
-  class ServerError < Error; end
-  class Unsupported < Error; end
-  class TooBig < Unsupported; end
+module Riemann
+  class Client
+    class Error < RuntimeError; end
+    class InvalidResponse < Error; end
+    class ServerError < Error; end
+    class Unsupported < Error; end
+    class TooBig < Unsupported; end
+
+    require 'socket'
+    require 'time'
 
-  require 'thread'
-  require 'socket'
-  require 'time'
+    HOST = '127.0.0.1'
+    PORT = 5555
+    TIMEOUT = 5
 
-  HOST = '127.0.0.1'
-  PORT = 5555
-  TIMEOUT = 5
+    require 'riemann/client/tcp'
+    require 'riemann/client/udp'
 
-  require 'riemann/client/tcp'
-  require 'riemann/client/udp'
+    attr_reader :tcp, :udp
 
-  attr_reader :tcp, :udp
+    def initialize(opts = {})
+      @options = opts.dup
+      @options[:host] ||= HOST
+      @options[:port] ||= PORT
+      @options[:timeout] ||= TIMEOUT
 
-  def initialize(opts = {})
-    @options = opts.dup
-    @options[:host] ||= HOST
-    @options[:port] ||= PORT
-    @options[:timeout] ||= TIMEOUT
+      @udp = UDP.new(@options)
+      @tcp = TCP.new(@options)
+      return unless block_given?
 
-    @udp = UDP.new(@options)
-    @tcp = TCP.new(@options)
-    if block_given?
       begin
         yield self
       ensure
         close
       end
     end
-  end
 
-  def host
-    @options[:host]
-  end
+    def host
+      @options[:host]
+    end
 
-  def port
-    @options[:port]
-  end
+    def port
+      @options[:port]
+    end
 
-  def timeout
-    @options[:timeout]
-  end
+    def timeout
+      @options[:timeout]
+    end
 
-  # Send a state
-  def <<(event_opts)
-    # Create state
-    case event_opts
-    when Riemann::State
-      event = event_opts
-    when Riemann::Event
-      event = event_opts
-    else
-      unless event_opts.include? :host
-        event_opts[:host] = Socket.gethostname
+    # Send a state
+    def <<(event_opts)
+      # Create state
+      case event_opts
+      when Riemann::State
+        event = event_opts
+      when Riemann::Event
+        event = event_opts
+      else
+        event_opts[:host] = Socket.gethostname unless event_opts.include? :host
+        event = Riemann::Event.new(event_opts)
       end
-      event = Riemann::Event.new(event_opts)
-    end
 
-    message = Riemann::Message.new :events => [event]
+      message = Riemann::Message.new events: [event]
 
-    # Transmit
-    send_maybe_recv message
-  end
+      # Transmit
+      send_maybe_recv message
+    end
 
-  # Returns an array of states matching query.
-  def [](query)
-    response = query(query)
-    (response.events || []) |
-      (response.states || [])
-  end
+    # Returns an array of states matching query.
+    def [](query)
+      response = query(query)
+      (response.events || []) |
+        (response.states || [])
+    end
 
-  def connect
-    # NOTE: connections are made automatically on send
-    warn "Riemann client#connect is deprecated"
-  end
+    def connect
+      # NOTE: connections are made automatically on send
+      warn 'Riemann client#connect is deprecated'
+    end
 
-  # Close both UDP and TCP sockets.
-  def close
-    @udp.close
-    @tcp.close
-  end
+    # Close both UDP and TCP sockets.
+    def close
+      @udp.close
+      @tcp.close
+    end
 
-  def connected?
-    tcp.connected? and udp.connected?
-  end
+    def connected?
+      tcp.connected? and udp.connected?
+    end
 
-  # Ask for states
-  def query(string = "true")
-    send_recv Riemann::Message.new(:query => Riemann::Query.new(:string => string))
-  end
+    # Ask for states
+    def query(string = 'true')
+      send_recv Riemann::Message.new(query: Riemann::Query.new(string: string))
+    end
 
-  def send_recv(*a)
-    @tcp.send_recv *a
-  end
+    def send_recv(message)
+      @tcp.send_recv(message)
+    end
 
-  def send_maybe_recv(*a)
-    begin
-      @udp.send_maybe_recv *a
+    def send_maybe_recv(message)
+      @udp.send_maybe_recv(message)
     rescue TooBig
-      @tcp.send_maybe_recv *a
+      @tcp.send_maybe_recv(*a)
     end
   end
 end

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.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

@@ -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,16 @@ 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 'bundler', '>= 1.3'
+  spec.add_development_dependency 'rubocop'
   spec.add_development_dependency 'timecop'
 
   spec.add_dependency 'beefcake', ['>= 1.0.0 ']