riemann-client 0.2.5 → 1.0.1

checksums.yaml

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

data/.github/workflows/ci.yml

@@ -0,0 +1,58 @@
+---
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - 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
+    steps:
+      - uses: actions/checkout@v2
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true
+      - name: Install riemann
+        run: |
+          wget --quiet https://github.com/riemann/riemann/releases/download/0.3.8/riemann_0.3.8_all.deb
+          sudo dpkg -i riemann_0.3.8_all.deb
+
+          sudo systemctl stop riemann
+
+          sudo openssl genrsa -out /etc/riemann/riemann_server.key 4096
+          sudo openssl pkcs8 -topk8 -nocrypt -in /etc/riemann/riemann_server.key -out /etc/riemann/riemann_server.pkcs8
+          sudo openssl req -x509 -new -nodes -key /etc/riemann/riemann_server.key -days 7 -out /etc/riemann/riemann_server.crt -subj '/CN=localhost'
+          sudo chmod +r /etc/riemann/riemann_server.pkcs8
+          sudo cp -v spec/riemann.config /etc/riemann/
+
+          sudo systemctl start riemann
+
+          while ! nc -z localhost 5555; do sleep 1; done
+      - name: Run the test suite
+        run: bundle exec bacon spec/*.rb

data/.gitignore

@@ -0,0 +1,10 @@
+pkg/
+._*
+*~
+.DS_Store
+.*.swp
+*.log
+.bundle/
+bin/
+vendor/
+Gemfile.lock

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

@@ -0,0 +1,84 @@
+# Changelog
+
+## [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/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:**
+
+- Add support for micro-seconds resolution [\#34](https://github.com/riemann/riemann-ruby-client/pull/34) ([smortex](https://github.com/smortex))
+- Add support for TLS [\#33](https://github.com/riemann/riemann-ruby-client/pull/33) ([smortex](https://github.com/smortex))
+- Add support for IPv6 addresses [\#30](https://github.com/riemann/riemann-ruby-client/pull/30) ([dch](https://github.com/dch))
+
+**Merged pull requests:**
+
+- Fix race conditions in CI [\#35](https://github.com/riemann/riemann-ruby-client/pull/35) ([smortex](https://github.com/smortex))
+- Modernize and setup CI [\#32](https://github.com/riemann/riemann-ruby-client/pull/32) ([smortex](https://github.com/smortex))
+- Bump beefcake dependency [\#29](https://github.com/riemann/riemann-ruby-client/pull/29) ([dch](https://github.com/dch))
+
+## [0.2.6](https://github.com/riemann/riemann-ruby-client/tree/0.2.6) (2015-11-18)
+
+[Full Changelog](https://github.com/riemann/riemann-ruby-client/compare/0.2.5...0.2.6)
+
+**Merged pull requests:**
+
+- Client should yield self [\#22](https://github.com/riemann/riemann-ruby-client/pull/22) ([agile](https://github.com/agile))
+- Allow TCP sockets to work on Windows [\#21](https://github.com/riemann/riemann-ruby-client/pull/21) ([sgran](https://github.com/sgran))
+- README hash syntax fix [\#20](https://github.com/riemann/riemann-ruby-client/pull/20) ([squarism](https://github.com/squarism))
+
+## [0.2.5](https://github.com/riemann/riemann-ruby-client/tree/0.2.5) (2015-02-05)
+
+[Full Changelog](https://github.com/riemann/riemann-ruby-client/compare/0.2.4...0.2.5)
+
+## [0.2.4](https://github.com/riemann/riemann-ruby-client/tree/0.2.4) (2015-02-03)
+
+[Full Changelog](https://github.com/riemann/riemann-ruby-client/compare/0.2.2...0.2.4)
+
+**Merged pull requests:**
+
+- Tightening beefcake requirement [\#19](https://github.com/riemann/riemann-ruby-client/pull/19) ([aphyr](https://github.com/aphyr))
+- Fix for \#17, plus test and connection refactor [\#18](https://github.com/riemann/riemann-ruby-client/pull/18) ([RKelln](https://github.com/RKelln))
+- Ensure that we close the connection if we got an error back [\#16](https://github.com/riemann/riemann-ruby-client/pull/16) ([eric](https://github.com/eric))
+- String\#clear doesn't exist in 1.8 [\#15](https://github.com/riemann/riemann-ruby-client/pull/15) ([eric](https://github.com/eric))
+- Tcp client with timeouts [\#14](https://github.com/riemann/riemann-ruby-client/pull/14) ([eric](https://github.com/eric))
+
+## [0.2.2](https://github.com/riemann/riemann-ruby-client/tree/0.2.2) (2013-05-28)
+
+[Full Changelog](https://github.com/riemann/riemann-ruby-client/compare/0.2.0...0.2.2)
+
+**Merged pull requests:**
+
+- Update README with timeout information [\#11](https://github.com/riemann/riemann-ruby-client/pull/11) ([gsandie](https://github.com/gsandie))
+- Add tcp socket timeouts [\#10](https://github.com/riemann/riemann-ruby-client/pull/10) ([gsandie](https://github.com/gsandie))
+- Socket can not be opened in method connected? [\#9](https://github.com/riemann/riemann-ruby-client/pull/9) ([vadv](https://github.com/vadv))
+
+## [0.2.0](https://github.com/riemann/riemann-ruby-client/tree/0.2.0) (2013-04-02)
+
+[Full Changelog](https://github.com/riemann/riemann-ruby-client/compare/version-0.0.7...0.2.0)
+
+**Merged pull requests:**
+
+- Get and set attributes using hash-style accessors [\#8](https://github.com/riemann/riemann-ruby-client/pull/8) ([jegt](https://github.com/jegt))
+- Add extra attributes added to the Event constructor to the event as Attribute instances [\#7](https://github.com/riemann/riemann-ruby-client/pull/7) ([jegt](https://github.com/jegt))
+- Change attribute name to attribute key [\#6](https://github.com/riemann/riemann-ruby-client/pull/6) ([b](https://github.com/b))
+- Arbitrary attributes on events [\#5](https://github.com/riemann/riemann-ruby-client/pull/5) ([b](https://github.com/b))
+
+## [version-0.0.7](https://github.com/riemann/riemann-ruby-client/tree/version-0.0.7) (2012-04-16)
+
+[Full Changelog](https://github.com/riemann/riemann-ruby-client/compare/fe25a3b01681612defc39250006748069e06a172...version-0.0.7)
+
+**Merged pull requests:**
+
+- Add support for ruby 1.8 [\#1](https://github.com/riemann/riemann-ruby-client/pull/1) ([eric](https://github.com/eric))
+
+
+
+\* *This Changelog was automatically generated by [github_changelog_generator](https://github.com/github-changelog-generator/github-changelog-generator)*

data/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'github_changelog_generator'

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".
@@ -48,14 +52,13 @@ faster than TCP, but you will not know if the server is down or encountered an
 error. You can specify what transport to use by selecting a subclient:
 
 ``` ruby
-c.udp << { :state "ok" } # => nil
-c.tcp << { :state "ok" } # => #<Message ...>
+c.udp << { :state => "ok" } # => nil
+c.tcp << { :state => "ok" } # => #<Message ...>
 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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'riemann'
+
+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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'openssl'
+require_relative 'tcp_socket'
+
+module Riemann
+  class Client
+    # Socket: A specialized socket that has been configure
+    class SSLSocket < TcpSocket
+      def initialize(options = {})
+        super(options)
+        @key_file = options[:key_file]
+        @cert_file = options[:cert_file]
+        @ca_file = options[:ca_file]
+        @ssl_verify = options[:ssl_verify]
+      end
+
+      def ssl_context
+        @ssl_context ||= OpenSSL::SSL::SSLContext.new.tap do |ctx|
+          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
+
+      # Internal: Connect to the give address within the timeout.
+      #
+      # Make an attempt to connect to a single address within the given timeout.
+      #
+      # Return the ::Socket when it is connected, or raise an Error if no
+      # connection was possible.
+      def connect_nonblock(addr, timeout)
+        sock = super(addr, timeout)
+        ssl_socket = OpenSSL::SSL::SSLSocket.new(sock, ssl_context)
+        ssl_socket.sync = true
+
+        begin
+          ssl_socket.connect_nonblock
+        rescue IO::WaitReadable
+          unless IO.select([ssl_socket], nil, nil, timeout)
+            raise Timeout, "Could not read from #{host}:#{port} in #{timeout} seconds"
+          end
+
+          retry
+        rescue IO::WaitWritable
+          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
+
+      # Internal: Read up to a maxlen of data from the socket and store it in outbuf
+      #
+      # maxlen - the maximum number of bytes to read from the socket
+      # outbuf - the buffer in which to store the bytes.
+      #
+      # Returns the bytes read
+      def readpartial(maxlen, outbuf = nil)
+        super(maxlen, outbuf)
+      rescue OpenSSL::SSL::SSLErrorWaitReadable
+        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
+      #
+      # buf - the data to write to the socket.
+      #
+      # Raises an error if it is unable to write the data to the socket within the
+      # write_timeout.
+      #
+      # returns nothing
+      def write(buf)
+        super(buf)
+      rescue OpenSSL::SSL::SSLErrorWaitWritable
+        unless wait_writable(write_timeout)
+          raise Timeout, "Could not write to #{host}:#{port} in #{write_timeout} seconds"
+        end
+
+        retry
+      end
+    end
+  end
+end

data/lib/riemann/client/tcp.rb

@@ -1,32 +1,39 @@
+# frozen_string_literal: true
+
 require 'monitor'
 require 'riemann/client/tcp_socket'
+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
       def self.socket_factory
-        @socket_factory || proc { |options| TcpSocket.connect(options) }
+        @socket_factory || proc { |options|
+          if options[:ssl]
+            SSLSocket.connect(options)
+          else
+            TcpSocket.connect(options)
+          end
+        }
       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?
 
@@ -51,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
 
@@ -87,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