riemann-client 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d87901a4f9a48ce3fcae0940d204c36cdabd949d4495b99f2445735fb2deddd8
-  data.tar.gz: d64e574731d1a1dce475fb2227eaf2fdd4f3bf581bd20bae33fb92a22321adb2
+  metadata.gz: 395c52ac148f9988953268a74e1e747c415e3b80c75e7e0cfef536d7f44a2d36
+  data.tar.gz: 81051904aef015898e9abde73a6bdf2cde446cec0ed8712b0a2cd569d1a62f50
 SHA512:
-  metadata.gz: b75e2bd1256a168dc185ceaf53c80f045e2011fa1fa2e2717147e48c35d65b767df60182884a154575e09598b4305cda0e9cc16c0f5a2d3e0ab3218fc6d4380f
-  data.tar.gz: 1b5d7a51402e65c7994b91bd903f2dae9881390ee890058a881311c3bb57bfb12139065c1a0d466c76f2438677789ad8f3347351e26d1005f704f673f8c06025
+  metadata.gz: d016e54a3881d70914163c88506da3936f47c6c3390f092eb1a2a179c1cd1034984337d81ecbbefdcef01019efa168f8d93662918c67125f31245cffa471b1f5
+  data.tar.gz: 330ea26290403c97dd44ac1b0d04b72ea9bebd27a147f00c0135ce9d46a09c01c4f8271daaa3c118a2feeebb84603d6dde77066ee5a994e6c7c32e8e2eb1c89a

data/.github/workflows/ci.yml

@@ -10,11 +10,24 @@ on:
       - main
 
 jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Setup ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '2.7'
+          bundler-cache: true
+      - name: Run rubocop
+        run: bundle exec rubocop
   test:
+    needs: lint
     runs-on: ubuntu-latest
     strategy:
       matrix:
         ruby-version:
+          - 2.6
           - 2.7
           - 3.0
           - 3.1

data/.rubocop.yml

@@ -0,0 +1,18 @@
+---
+Metrics/AbcSize:
+  Enabled: false
+Metrics/BlockLength:
+  Enabled: false
+Metrics/ClassLength:
+  Enabled: false
+Metrics/CyclomaticComplexity:
+  Enabled: false
+Metrics/MethodLength:
+  Enabled: false
+Metrics/PerceivedComplexity:
+  Enabled: false
+Naming/VariableNumber:
+  AllowedIdentifiers:
+  - TLSv1_2
+Style/Documentation:
+  Enabled: false

data/CHANGELOG.md

@@ -1,8 +1,16 @@
 # Changelog
 
-## [1.0.0](https://github.com/riemann/riemann-ruby-client/tree/1.0.0) (2022-06-16)
+## [1.0.1](https://github.com/riemann/riemann-ruby-client/tree/1.0.1) (2022-06-25)
 
-[Full Changelog](https://github.com/riemann/riemann-ruby-client/compare/0.2.6...1.0.0)
+[Full Changelog](https://github.com/riemann/riemann-ruby-client/compare/v1.0.0...1.0.1)
+
+**Merged pull requests:**
+
+- Setup Rubocop and lower required Ruby version [\#37](https://github.com/riemann/riemann-ruby-client/pull/37) ([smortex](https://github.com/smortex))
+
+## [v1.0.0](https://github.com/riemann/riemann-ruby-client/tree/v1.0.0) (2022-06-16)
+
+[Full Changelog](https://github.com/riemann/riemann-ruby-client/compare/0.2.6...v1.0.0)
 
 **Implemented enhancements:**
 

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 gemspec

data/README.markdown

@@ -1,12 +1,16 @@
-Installing
-==========
+# Riemann Ruby Client
 
-    gem install riemann-client
+[![CI](https://github.com/riemann/riemann-ruby-client/actions/workflows/ci.yml/badge.svg)](https://github.com/riemann/riemann-ruby-client/actions/workflows/ci.yml)
 
-Use
-===
+## Installing
 
-``` ruby
+```shell
+gem install riemann-client
+```
+
+## Use
+
+```ruby
 require 'riemann/client'
 
 # Create a client. Host, port and timeout are optional.
@@ -38,8 +42,8 @@ c['host =~ "%.dc1" and (state = "critical" or state = "warning")']
 
 ```
 
-Transports
-==========
+## Transports
+
 
 Riemann::Client sends small events over UDP by default, and uses TCP for
 queries and large events. UDP sends are essentially "shouting into the void".
@@ -54,8 +58,7 @@ c.tcp["true"]            # => [#<Event ... >, ...]
 c.udp["true"]            # => raise Riemann::Client::Unsupported
 ```
 
-Client state management
-=======================
+## Client state management
 
 Riemann::Client provides some classes to make managing state updates easier.
 
@@ -64,3 +67,9 @@ be used to flush an accumulated value to ustate at regular intervals.
 
 Riemann::AutoState bundles a state and a client together. Any changes to the
 AutoState automatically send the new state to the client.
+
+## License
+
+The MIT License
+
+Copyright (c) 2011-2022 Kyle Kingsbury

data/Rakefile

@@ -1,12 +1,15 @@
+# frozen_string_literal: true
+
 require 'riemann'
 
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
 
 require 'github_changelog_generator/task'
 
 GitHubChangelogGenerator::RakeTask.new :changelog do |config|
   config.user = 'riemann'
   config.project = 'riemann-ruby-client'
+  config.exclude_labels = ['skip-changelog']
   config.future_release = Riemann::VERSION
   config.add_issues_wo_labels = false
 end

data/lib/riemann/attribute.rb

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

data/lib/riemann/auto_state.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Riemann
   class AutoState
     # Binds together a state hash and a Client. Any change made here
@@ -40,7 +42,7 @@ module Riemann
     #     @state.state = 'heavy lifting b'
     #     ...
     #   end
-    
+
     def initialize(client = Client.new, state = {})
       @client = client
       @state = state
@@ -95,7 +97,11 @@ module Riemann
     def once(opts)
       o = @state.merge opts
       o[:time] = Time.now.to_i
-      o[:tags] = ((o[:tags] | ["once"]) rescue ["once"])
+      o[:tags] = begin
+        (o[:tags] | ['once'])
+      rescue StandardError
+        ['once']
+      end
       @client << o
     end
 
@@ -111,7 +117,7 @@ module Riemann
     def service=(service)
       @state[:service] = service
       flush
-    end 
+    end
 
     def service
       @state[:service]

data/lib/riemann/client/ssl_socket.rb

@@ -1,11 +1,12 @@
+# frozen_string_literal: true
+
 require 'openssl'
 require_relative 'tcp_socket'
 
 module Riemann
   class Client
-  # Socket: A specialized socket that has been configure
+    # Socket: A specialized socket that has been configure
     class SSLSocket < TcpSocket
-
       def initialize(options = {})
         super(options)
         @key_file = options[:key_file]
@@ -16,11 +17,11 @@ module Riemann
 
       def ssl_context
         @ssl_context ||= OpenSSL::SSL::SSLContext.new.tap do |ctx|
-            ctx.key = OpenSSL::PKey::RSA.new(open(@key_file) {|f| f.read})
-            ctx.cert = OpenSSL::X509::Certificate.new(open(@cert_file) {|f| f.read})
-            ctx.ca_file = @ca_file if @ca_file
-            ctx.ssl_version = :TLSv1_2
-            ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER if @ssl_verify
+          ctx.key = OpenSSL::PKey::RSA.new(File.read(@key_file))
+          ctx.cert = OpenSSL::X509::Certificate.new(File.read(@cert_file))
+          ctx.ca_file = @ca_file if @ca_file
+          ctx.ssl_version = :TLSv1_2
+          ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER if @ssl_verify
         end
       end
 
@@ -30,7 +31,7 @@ module Riemann
       #
       # Return the ::Socket when it is connected, or raise an Error if no
       # connection was possible.
-      def connect_nonblock( addr, timeout )
+      def connect_nonblock(addr, timeout)
         sock = super(addr, timeout)
         ssl_socket = OpenSSL::SSL::SSLSocket.new(sock, ssl_context)
         ssl_socket.sync = true
@@ -38,17 +39,17 @@ module Riemann
         begin
           ssl_socket.connect_nonblock
         rescue IO::WaitReadable
-          if IO.select([ssl_socket], nil, nil, timeout)
-            retry
-          else
+          unless IO.select([ssl_socket], nil, nil, timeout)
             raise Timeout, "Could not read from #{host}:#{port} in #{timeout} seconds"
           end
+
+          retry
         rescue IO::WaitWritable
-          if IO.select(nil, [ssl_socket], nil, timeout)
-            retry
-          else
+          unless IO.select(nil, [ssl_socket], nil, timeout)
             raise Timeout, "Could not write to #{host}:#{port} in #{timeout} seconds"
           end
+
+          retry
         end
         ssl_socket
       end
@@ -60,13 +61,13 @@ module Riemann
       #
       # Returns the bytes read
       def readpartial(maxlen, outbuf = nil)
-        return super(maxlen, outbuf)
+        super(maxlen, outbuf)
       rescue OpenSSL::SSL::SSLErrorWaitReadable
-        if wait_readable(read_timeout)
-          retry
-        else
+        unless wait_readable(read_timeout)
           raise Timeout, "Could not read from #{host}:#{port} in #{read_timeout} seconds"
         end
+
+        retry
       end
 
       # Internal: Write the given data to the socket
@@ -80,11 +81,11 @@ module Riemann
       def write(buf)
         super(buf)
       rescue OpenSSL::SSL::SSLErrorWaitWritable
-        if wait_writable(write_timeout)
-          retry
-        else
+        unless wait_writable(write_timeout)
           raise Timeout, "Could not write to #{host}:#{port} in #{write_timeout} seconds"
         end
+
+        retry
       end
     end
   end

data/lib/riemann/client/tcp.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'monitor'
 require 'riemann/client/tcp_socket'
 require 'riemann/client/ssl_socket'
@@ -5,12 +7,12 @@ require 'riemann/client/ssl_socket'
 module Riemann
   class Client
     class TCP < Client
-      attr_accessor :host, :port, :socket
+      attr_accessor :host, :port
 
       # Public: Set a socket factory -- an object responding
       # to #call(options) that returns a Socket object
-      def self.socket_factory=(factory)
-        @socket_factory = factory
+      class << self
+        attr_writer :socket_factory
       end
 
       # Public: Return a socket factory
@@ -24,16 +26,14 @@ module Riemann
         }
       end
 
-      def initialize(options = {})
+      def initialize(options = {}) # rubocop:disable Lint/MissingSuper
         @options = options
         @locket  = Monitor.new
       end
 
       def socket
         @locket.synchronize do
-          if @pid && @pid != Process.pid
-            close
-          end
+          close if @pid && @pid != Process.pid
 
           return @socket if connected?
 
@@ -58,32 +58,32 @@ module Riemann
       end
 
       # Read a message from a stream
-      def read_message(s)
-        if buffer = s.read(4) and buffer.size == 4
-          length = buffer.unpack('N').first
-          begin
-            str = s.read length
-            message = Riemann::Message.decode str
-          rescue => e
-            puts "Message was #{str.inspect}"
-            raise
-          end
+      def read_message(socket)
+        unless (buffer = socket.read(4)) && (buffer.size == 4)
+          raise InvalidResponse, 'unexpected EOF'
+        end
 
-          unless message.ok
-            puts "Failed"
-            raise ServerError, message.error
-          end
+        length = buffer.unpack1('N')
+        begin
+          str = socket.read length
+          message = Riemann::Message.decode str
+        rescue StandardError
+          puts "Message was #{str.inspect}"
+          raise
+        end
 
-          message
-        else
-          raise InvalidResponse, "unexpected EOF"
+        unless message.ok
+          puts 'Failed'
+          raise ServerError, message.error
         end
+
+        message
       end
 
       def send_recv(message)
-        with_connection do |s|
-          s.write(message.encode_with_length)
-          read_message(s)
+        with_connection do |socket|
+          socket.write(message.encode_with_length)
+          read_message(socket)
         end
       end
 
@@ -94,17 +94,17 @@ module Riemann
         tries = 0
 
         @locket.synchronize do
-          begin
-            tries += 1
-            yield(socket)
-          rescue IOError, Errno::EPIPE, Errno::ECONNREFUSED, InvalidResponse, Timeout::Error, Riemann::Client::TcpSocket::Error
-            close
-            raise if tries > 3
-            retry
-          rescue Exception
-            close
-            raise
-          end
+          tries += 1
+          yield(socket)
+        rescue IOError, Errno::EPIPE, Errno::ECONNREFUSED, InvalidResponse, Timeout::Error,
+               Riemann::Client::TcpSocket::Error
+          close
+          raise if tries > 3
+
+          retry
+        rescue StandardError
+          close
+          raise
         end
       end
     end

data/lib/riemann/client/tcp_socket.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require 'socket'
 require 'fcntl'
 
 module Riemann
   class Client
-  # Socket: A specialized socket that has been configure
+    # Socket: A specialized socket that has been configure
     class TcpSocket
       class Error < Riemann::Client::Error; end
       class Timeout < Error; end
@@ -68,7 +70,6 @@ module Riemann
       #   connection dead and notifying the application layer.
       attr_reader :keepalive_count
 
-
       # Internal: Create and connect to the given location.
       #
       # options, same as Constructor
@@ -77,11 +78,11 @@ module Riemann
       def self.connect(options = {})
         s = new(options)
         s.connect
-        return s
+        s
       end
 
       # Internal: Creates a new KJess::Socket
-      def initialize( options = {} )
+      def initialize(options = {})
         @host = options[:host]
         @port = options[:port]
 
@@ -113,7 +114,7 @@ module Riemann
       # Returns a new ::Socket instance for
 
       def socket_factory(type)
-         sock = ::Socket.new(type, ::Socket::SOCK_STREAM, 0)
+        sock = ::Socket.new(type, ::Socket::SOCK_STREAM, 0)
 
         # close file descriptors if we exec
         if Fcntl.constants.include?(:F_SETFD) && Fcntl.constants.include?(:FD_CLOEXEC)
@@ -122,14 +123,14 @@ module Riemann
         # Disable Nagle's algorithm
         sock.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
 
-        if using_keepalive? then
-          sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE , true)
-          sock.setsockopt(::Socket::SOL_TCP,    ::Socket::TCP_KEEPIDLE , keepalive_idle)
+        if using_keepalive?
+          sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE, true)
+          sock.setsockopt(::Socket::SOL_TCP,    ::Socket::TCP_KEEPIDLE, keepalive_idle)
           sock.setsockopt(::Socket::SOL_TCP,    ::Socket::TCP_KEEPINTVL, keepalive_interval)
-          sock.setsockopt(::Socket::SOL_TCP,    ::Socket::TCP_KEEPCNT  , keepalive_count)
+          sock.setsockopt(::Socket::SOL_TCP,    ::Socket::TCP_KEEPCNT, keepalive_count)
         end
 
-        return sock
+        sock
       end
 
       # Internal: Return the connected raw Socket.
@@ -139,7 +140,8 @@ module Riemann
       # Returns a ::Socket
       def socket
         return @socket unless closed?
-        @socket ||= connect()
+
+        @socket ||= connect
       end
 
       # Internal: Closes the internal ::Socket
@@ -154,7 +156,8 @@ module Riemann
       def closed?
         return true if @socket.nil?
         return true if @socket.closed?
-        return false
+
+        false
       end
 
       # Internal:
@@ -169,16 +172,16 @@ module Riemann
         deadline = Time.now.to_f + connect_timeout
 
         # Lookup destination address, we only want TCP.
-        addrs      = ::Socket.getaddrinfo(host, port, nil, ::Socket::SOCK_STREAM )
+        addrs      = ::Socket.getaddrinfo(host, port, nil, ::Socket::SOCK_STREAM)
         errors     = []
-        conn_error = lambda { raise errors.first }
+        conn_error = -> { raise errors.first }
         sock       = nil
 
         # Sort it so we get AF_INET, IPv4
-        addrs.sort.find( conn_error ) do |addr|
-          sock = connect_or_error( addr, deadline, errors )
+        addrs.sort.find(conn_error) do |addr|
+          sock = connect_or_error(addr, deadline, errors)
         end
-        return sock
+        sock
       end
 
       # Internal: Connect to the destination or raise an error.
@@ -195,13 +198,14 @@ module Riemann
       # Should the connection fail, append the exception to the errors array and
       # return false.
       #
-      def connect_or_error( addr, deadline, errors )
+      def connect_or_error(addr, deadline, errors)
         timeout = deadline - Time.now.to_f
         raise Timeout, "Could not connect to #{host}:#{port}" if timeout <= 0
-        return connect_nonblock( addr, timeout )
+
+        connect_nonblock(addr, timeout)
       rescue Error => e
         errors << e
-        return false
+        false
       end
 
       # Internal: Connect to the give address within the timeout.
@@ -210,36 +214,47 @@ module Riemann
       #
       # Return the ::Socket when it is connected, or raise an Error if no
       # connection was possible.
-      def connect_nonblock( addr, timeout )
+      def connect_nonblock(addr, timeout)
         sockaddr = ::Socket.pack_sockaddr_in(addr[1], addr[3])
-        sock     = self.socket_factory( addr[4] )
-        sock.connect_nonblock( sockaddr )
-        return sock
+        sock     = socket_factory(addr[4])
+        sock.connect_nonblock(sockaddr)
+        sock
       rescue Errno::EINPROGRESS
         if IO.select(nil, [sock], nil, timeout).nil?
-          sock.close rescue nil
+          begin
+            sock.close
+          rescue StandardError
+            nil
+          end
           raise Timeout, "Could not connect to #{host}:#{port} within #{timeout} seconds"
         end
-        return connect_nonblock_finalize( sock, sockaddr )
-      rescue => ex
-        sock.close rescue nil
-        raise Error, "Could not connect to #{host}:#{port}: #{ex.class}: #{ex.message}", ex.backtrace
+        connect_nonblock_finalize(sock, sockaddr)
+      rescue StandardError => e
+        begin
+          sock.close
+        rescue StandardError
+          nil
+        end
+        raise Error, "Could not connect to #{host}:#{port}: #{e.class}: #{e.message}", e.backtrace
       end
 
-
       # Internal: Make sure that a non-blocking connect has truely connected.
       #
       # Ensure that the given socket is actually connected to the given adddress.
       #
       # Returning the socket if it is and raising an Error if it isn't.
-      def connect_nonblock_finalize( sock, sockaddr )
-        sock.connect_nonblock( sockaddr )
-        return sock
+      def connect_nonblock_finalize(sock, sockaddr)
+        sock.connect_nonblock(sockaddr)
+        sock
       rescue Errno::EISCONN
-        return sock
-      rescue => ex
-        sock.close rescue nil
-        raise Error, "Could not connect to #{host}:#{port}: #{ex.class}: #{ex.message}", ex.backtrace
+        sock
+      rescue StandardError => e
+        begin
+          sock.close
+        rescue StandardError
+          nil
+        end
+        raise Error, "Could not connect to #{host}:#{port}: #{e.class}: #{e.message}", e.backtrace
       end
 
       # Internal: say if we are using TCP Keep Alive or not
@@ -255,12 +270,12 @@ module Riemann
       # Returns true or false
       def using_keepalive?
         using = false
-        if keepalive_active? then
-          using = [ :SOL_SOCKET, :SO_KEEPALIVE, :SOL_TCP, :TCP_KEEPIDLE, :TCP_KEEPINTVL, :TCP_KEEPCNT].all? do |c|
+        if keepalive_active?
+          using = %i[SOL_SOCKET SO_KEEPALIVE SOL_TCP TCP_KEEPIDLE TCP_KEEPINTVL TCP_KEEPCNT].all? do |c|
             ::Socket.const_defined? c
           end
         end
-        return using
+        using
       end
 
       # Reads length bytes from the socket
@@ -274,18 +289,18 @@ module Riemann
           outbuf.replace('')
           buf = outbuf
         else
-          buf = ''
+          buf = String.new
         end
 
         while buf.length < length
-          unless rb = readpartial(length - buf.length)
+          unless (rb = readpartial(length - buf.length))
             break
           end
 
           buf << rb
         end
 
-        return buf
+        buf
       end
 
       # Internal: Read up to a maxlen of data from the socket and store it in outbuf
@@ -295,13 +310,13 @@ module Riemann
       #
       # Returns the bytes read
       def readpartial(maxlen, outbuf = nil)
-        return socket.read_nonblock(maxlen, outbuf)
+        socket.read_nonblock(maxlen, outbuf)
       rescue Errno::EWOULDBLOCK, Errno::EAGAIN, Errno::ECONNRESET
-        if wait_readable(read_timeout)
-          retry
-        else
+        unless wait_readable(read_timeout)
           raise Timeout, "Could not read from #{host}:#{port} in #{read_timeout} seconds"
         end
+
+        retry
       end
 
       # Internal: Write the given data to the socket
@@ -313,16 +328,16 @@ module Riemann
       #
       # returns nothing
       def write(buf)
-        until buf.nil? or (buf.length == 0) do
+        until buf.nil? || buf.length.zero?
           written = socket.write_nonblock(buf)
           buf = buf[written, buf.length]
         end
       rescue Errno::EWOULDBLOCK, Errno::EINTR, Errno::EAGAIN, Errno::ECONNRESET
-        if wait_writable(write_timeout)
-          retry
-        else
+        unless wait_writable(write_timeout)
           raise Timeout, "Could not write to #{host}:#{port} in #{write_timeout} seconds"
         end
+
+        retry
       end
 
       def wait_writable(timeout = nil)