riemann-client 0.2.4 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d87901a4f9a48ce3fcae0940d204c36cdabd949d4495b99f2445735fb2deddd8
+  data.tar.gz: d64e574731d1a1dce475fb2227eaf2fdd4f3bf581bd20bae33fb92a22321adb2
+SHA512:
+  metadata.gz: b75e2bd1256a168dc185ceaf53c80f045e2011fa1fa2e2717147e48c35d65b767df60182884a154575e09598b4305cda0e9cc16c0f5a2d3e0ab3218fc6d4380f
+  data.tar.gz: 1b5d7a51402e65c7994b91bd903f2dae9881390ee890058a881311c3bb57bfb12139065c1a0d466c76f2438677789ad8f3347351e26d1005f704f673f8c06025

data/.github/workflows/ci.yml

@@ -0,0 +1,45 @@
+---
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version:
+          - 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/CHANGELOG.md

@@ -0,0 +1,76 @@
+# Changelog
+
+## [1.0.0](https://github.com/riemann/riemann-ruby-client/tree/1.0.0) (2022-06-16)
+
+[Full Changelog](https://github.com/riemann/riemann-ruby-client/compare/0.2.6...1.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,5 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'github_changelog_generator'

data/README.markdown

@@ -48,8 +48,8 @@ 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
 ```

data/Rakefile

@@ -0,0 +1,12 @@
+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.future_release = Riemann::VERSION
+  config.add_issues_wo_labels = false
+end

data/lib/riemann/client/ssl_socket.rb

@@ -0,0 +1,91 @@
+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(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
+        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
+          if IO.select([ssl_socket], nil, nil, timeout)
+            retry
+          else
+            raise Timeout, "Could not read from #{host}:#{port} in #{timeout} seconds"
+          end
+        rescue IO::WaitWritable
+          if IO.select(nil, [ssl_socket], nil, timeout)
+            retry
+          else
+            raise Timeout, "Could not write to #{host}:#{port} in #{timeout} seconds"
+          end
+        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)
+        return super(maxlen, outbuf)
+      rescue OpenSSL::SSL::SSLErrorWaitReadable
+        if wait_readable(read_timeout)
+          retry
+        else
+          raise Timeout, "Could not read from #{host}:#{port} in #{read_timeout} seconds"
+        end
+      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
+        if wait_writable(write_timeout)
+          retry
+        else
+          raise Timeout, "Could not write to #{host}:#{port} in #{write_timeout} seconds"
+        end
+      end
+    end
+  end
+end

data/lib/riemann/client/tcp.rb

@@ -1,5 +1,6 @@
 require 'monitor'
 require 'riemann/client/tcp_socket'
+require 'riemann/client/ssl_socket'
 
 module Riemann
   class Client
@@ -14,7 +15,13 @@ module Riemann
 
       # 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 = {})

data/lib/riemann/client/tcp_socket.rb

@@ -107,16 +107,18 @@ module Riemann
       # Using the options from the initializer, a new ::Socket is created that
       # is:
       #
-      #   TCP, IPv4 only, autoclosing on exit, nagle's algorithm is disabled and has
+      #   TCP, autoclosing on exit, nagle's algorithm is disabled and has
       #   TCP Keepalive options set if keepalive is supported.
       #
-      # Returns a new ::Socket instance
-      def blank_socket
-        sock = ::Socket.new(::Socket::AF_INET, ::Socket::SOCK_STREAM, 0)
+      # Returns a new ::Socket instance for
 
-        # close file descriptors if we exec
-        sock.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+      def socket_factory(type)
+         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)
+          sock.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+        end
         # Disable Nagle's algorithm
         sock.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
 
@@ -166,13 +168,14 @@ module Riemann
         # Calculate our timeout deadline
         deadline = Time.now.to_f + connect_timeout
 
-        # Lookup destination address, we only want    IPv4             , TCP
-        addrs      = ::Socket.getaddrinfo(host, port, ::Socket::AF_INET, ::Socket::SOCK_STREAM )
+        # Lookup destination address, we only want TCP.
+        addrs      = ::Socket.getaddrinfo(host, port, nil, ::Socket::SOCK_STREAM )
         errors     = []
         conn_error = lambda { raise errors.first }
         sock       = nil
 
-        addrs.find( conn_error ) do |addr|
+        # Sort it so we get AF_INET, IPv4
+        addrs.sort.find( conn_error ) do |addr|
           sock = connect_or_error( addr, deadline, errors )
         end
         return sock
@@ -209,7 +212,7 @@ module Riemann
       # connection was possible.
       def connect_nonblock( addr, timeout )
         sockaddr = ::Socket.pack_sockaddr_in(addr[1], addr[3])
-        sock     = blank_socket()
+        sock     = self.socket_factory( addr[4] )
         sock.connect_nonblock( sockaddr )
         return sock
       rescue Errno::EINPROGRESS
@@ -331,4 +334,4 @@ module Riemann
       end
     end
   end
-end
+end

data/lib/riemann/client.rb

@@ -28,6 +28,13 @@ class Riemann::Client
 
     @udp = UDP.new(@options)
     @tcp = TCP.new(@options)
+    if block_given?
+      begin
+        yield self
+      ensure
+        close
+      end
+    end
   end
 
   def host

data/lib/riemann/event.rb

@@ -11,6 +11,7 @@ module Riemann
     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
@@ -27,6 +28,10 @@ module Riemann
       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.
@@ -51,12 +56,12 @@ module Riemann
       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
       end
-      init.time ||= Time.now.to_i
+      init.time_micros ||= now
 
       init
     end
@@ -85,12 +90,12 @@ module Riemann
       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
       end
-      init.time ||= Time.now.to_i
+      init.time_micros ||= now
 
       init
     end
@@ -119,12 +124,12 @@ 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
       end
-      init.time ||= Time.now.to_i
+      init.time_micros ||= now
 
       init
     end
@@ -186,7 +191,7 @@ module Riemann
         super()
       end
 
-      @time ||= Time.now.to_i
+      @time_micros ||= self.class.now unless @time
     end
 
     def metric

data/lib/riemann/version.rb

@@ -1,3 +1,3 @@
 module Riemann
-  VERSION = '0.2.4'
+  VERSION = '1.0.0'
 end

data/riemann-client.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$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($/)
+  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.add_development_dependency 'bundler', '>= 1.3'
+  spec.add_development_dependency 'bacon'
+  spec.add_development_dependency 'timecop'
+
+  spec.add_dependency 'beefcake', ['>= 1.0.0 ']
+  spec.add_dependency 'mtrc', '>= 0.0.4'
+end

data/spec/client.rb

@@ -0,0 +1,384 @@
+#!/usr/bin/env ruby
+
+# How to run the bacon tests:
+#   1. Start Riemann using the config from riemann.config
+#   2. $ bundle exec bacon spec/client.rb
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'riemann'))
+require 'riemann/client'
+require 'bacon'
+require 'set'
+require 'timecop'
+
+Bacon.summary_on_exit
+
+include Riemann
+
+INACTIVITY_TIME = 5
+
+def wait_for(&block)
+  tries = 0
+  while tries < 30
+    tries += 1
+    begin
+      res = block.call
+      return res if res
+    rescue NoMethodError
+      # If a query returns no result (#query retruns nil or #[] returns []),
+      # calling #first on it will raise a NoMethodError.  We can ignore it for
+      # these tests.
+    end
+    sleep(0.1)
+  end
+
+  raise "wait_for condition never realized"
+end
+
+def roundtrip_metric(m)
+  @client_with_transport << {
+    :service => 'metric-test',
+    :metric => m
+  }
+
+  wait_for {@client["service = \"metric-test\" and metric = #{m}"].first }.
+    metric.should.equal m
+end
+
+def truthy
+  lambda { |obj| !(obj.nil? || obj == false) }
+end
+
+def falsey
+  lambda { |obj| obj.nil? || obj == false }
+end
+
+shared "a riemann client" do
+
+  should 'yield itself to given block' do
+    client = nil
+    Client.new(:host => "localhost", :port => 5555) do |c|
+      client = c
+    end
+    client.should.be.kind_of?(Client)
+    client.should.not.be.connected
+  end
+
+  should 'close sockets if given a block that raises' do
+    client = nil
+    begin
+      Client.new(:host => "localhost", :port => 5555) do |c|
+        client = c
+        raise "The Boom"
+      end
+    rescue
+      # swallow the exception
+    end
+    client.should.be.kind_of?(Client)
+    client.should.not.be.connected
+  end
+
+  should 'be connected after sending' do
+    @client_with_transport.connected?.should.be falsey
+    @client.connected?.should.be falsey
+    @client_with_transport << {:state => 'ok', :service => 'connected check' }
+    @client_with_transport.connected?.should.be truthy
+    # NOTE: only single transport connected at this point, @client.connected? is still false until all transports used
+  end
+
+  should 'send longs' do
+    roundtrip_metric(0)
+    roundtrip_metric(-3)
+    roundtrip_metric(5)
+    roundtrip_metric(-(2**63))
+    roundtrip_metric(2**63 - 1)
+  end
+
+  should 'send doubles' do
+    roundtrip_metric 0.0
+    roundtrip_metric 12.0
+    roundtrip_metric 1.2300000190734863
+  end
+
+  should 'send custom attributes' do
+    event = Event.new(
+      :service => 'custom',
+      :state => 'ok',
+      :cats => 'meow',
+      :env => 'prod'
+    )
+    event[:sneak] = 'attack'
+    @client_with_transport << event
+    event2 = wait_for { @client['service = "custom"'].first }
+    event2.service.should.equal 'custom'
+    event2.state.should.equal 'ok'
+    event2[:cats].should.equal 'meow'
+    event2[:env].should.equal 'prod'
+    event2[:sneak].should.equal 'attack'
+  end
+
+  should 'send a state with a time' do
+    Timecop.freeze do
+      t = (Time.now - 10).to_i
+      @client_with_transport << {
+        :state => 'ok',
+        :service => 'test',
+        :time => t
+      }
+      wait_for { @client.query('service = "test"').events.first.time == t }
+      e = @client.query('service = "test"').events.first
+      e.time.should.equal t
+      e.time_micros.should.equal t * 1_000_000
+    end
+  end
+
+  should 'send a state with a time_micros' do
+    Timecop.freeze do
+      t = ((Time.now - 10).to_f * 1_000_000).to_i
+      @client_with_transport << {
+        :state => 'ok',
+        :service => 'test',
+        :time_micros => t
+      }
+      wait_for { @client.query('service = "test"').events.first.time_micros == t }
+      e = @client.query('service = "test"').events.first
+      e.time.should.equal (Time.now - 10).to_i
+      e.time_micros.should.equal t
+    end
+  end
+
+  should 'send a state without time nor time_micros' do
+    time_before = (Time.now.to_f * 1_000_000).to_i
+    @client_with_transport << {
+      :state => 'ok',
+      :service => 'timeless test'
+    }
+    wait_for { @client.query('service = "timeless test"').events.first.time_micros >= time_before }
+    e = @client.query('service = "timeless test"').events.first
+    time_after = (Time.now.to_f * 1_000_000).to_i
+
+    [time_before, e.time_micros, time_after].sort.should.equal([time_before, e.time_micros, time_after])
+  end
+
+  should "query states" do
+    @client_with_transport << { :state => 'critical', :service => '1' }
+    @client_with_transport << { :state => 'warning', :service => '2' }
+    @client_with_transport << { :state => 'critical', :service => '3' }
+    wait_for { @client.query('service = "3"').events.first }
+    @client.query.events.
+      map(&:service).to_set.should.superset ['1', '2', '3'].to_set
+    @client.query('state = "critical" and (service = "1" or service = "2" or service = "3")').events.
+      map(&:service).to_set.should.equal ['1', '3'].to_set
+  end
+
+  it '[]' do
+#    @client['state = "critical"'].should == []
+    @client_with_transport << {:state => 'critical'}
+    wait_for { @client['state = "critical"'].first }.state.should.equal 'critical'
+  end
+
+  should 'query quickly' do
+    t1 = Time.now
+    total = 1000
+    total.times do |i|
+      @client.query('state = "critical"')
+    end
+    t2 = Time.now
+
+    rate = total / (t2 - t1)
+    puts "\n     #{"%.2f" % rate} queries/sec (#{"%.2f" % (1000/rate)}ms per query)"
+    rate.should > 100
+  end
+
+  should 'be threadsafe' do
+    concurrency = 10
+    per_thread = 200
+    total = concurrency * per_thread
+
+    t1 = Time.now
+    (0...concurrency).map do |i|
+      Thread.new do
+        per_thread.times do
+          @client_with_transport.<<({
+            :state => 'ok',
+            :service => 'test',
+            :description => 'desc',
+            :metric_f => 1.0
+          })
+        end
+      end
+    end.each do |t|
+      t.join
+    end
+    t2 = Time.now
+
+    rate = total / (t2 - t1)
+    puts "\n     #{"%.2f" % rate} inserts/sec (#{"%.2f" % (1000/rate)}ms per insert)"
+    rate.should > @expected_rate
+  end
+
+end
+
+describe "Riemann::Client (TLS transport)" do
+  before do
+    @client = 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)
+    @client_with_transport = @client.tcp
+    @expected_rate = 100
+  end
+  behaves_like "a riemann client"
+
+  should 'send a state' do
+    res = @client_with_transport << {
+      :state => 'ok',
+      :service => 'test',
+      :description => 'desc',
+      :metric_f => 1.0
+    }
+
+    res.ok.should.be truthy
+    wait_for { @client['service = "test"'].first }.state.should.equal 'ok'
+  end
+
+  should 'survive inactivity' do
+    @client_with_transport.<<({
+      :state => 'warning',
+      :service => 'survive TCP inactivity',
+    })
+    wait_for { @client['service = "survive TCP inactivity"'].first.state == 'warning' }
+
+    sleep INACTIVITY_TIME
+
+    @client_with_transport.<<({
+      :state => 'ok',
+      :service => 'survive TCP inactivity',
+    }).ok.should.be truthy
+    wait_for { @client['service = "survive TCP inactivity"'].first.state == 'ok' }
+  end
+
+  should 'survive local close' do
+    @client_with_transport.<<({
+      :state => 'warning',
+      :service => 'survive TCP local close',
+    }).ok.should.be truthy
+    wait_for { @client['service = "survive TCP local close"'].first .state == 'warning' }
+
+    @client.close
+
+    @client_with_transport.<<({
+      :state => 'ok',
+      :service => 'survive TCP local close',
+    }).ok.should.be truthy
+    wait_for { @client['service = "survive TCP local close"'].first.state == 'ok' }
+  end
+end
+
+describe "Riemann::Client (TCP transport)" do
+  before do
+    @client = Client.new(:host => "localhost", :port => 5555)
+    @client_with_transport = @client.tcp
+    @expected_rate = 100
+  end
+  behaves_like "a riemann client"
+
+  should 'send a state' do
+    res = @client_with_transport << {
+      :state => 'ok',
+      :service => 'test',
+      :description => 'desc',
+      :metric_f => 1.0
+    }
+
+    res.ok.should.be truthy
+    wait_for { @client['service = "test"'].first }.state.should.equal 'ok'
+  end
+
+  should 'survive inactivity' do
+    @client_with_transport.<<({
+      :state => 'warning',
+      :service => 'survive TCP inactivity',
+    })
+    wait_for { @client['service = "survive TCP inactivity"'].first.state == 'warning' }
+
+    sleep INACTIVITY_TIME
+
+    @client_with_transport.<<({
+      :state => 'ok',
+      :service => 'survive TCP inactivity',
+    }).ok.should.be truthy
+    wait_for { @client['service = "survive TCP inactivity"'].first.state == 'ok' }
+  end
+
+  should 'survive local close' do
+    @client_with_transport.<<({
+      :state => 'warning',
+      :service => 'survive TCP local close',
+    }).ok.should.be truthy
+    wait_for { @client['service = "survive TCP local close"'].first.state == 'warning' }
+
+    @client.close
+
+    @client_with_transport.<<({
+      :state => 'ok',
+      :service => 'survive TCP local close',
+    }).ok.should.be truthy
+    wait_for { @client['service = "survive TCP local close"'].first.state == 'ok' }
+  end
+end
+
+describe "Riemann::Client (UDP transport)" do
+  before do
+    @client = Client.new(:host => "localhost", :port => 5555)
+    @client_with_transport = @client.udp
+    @expected_rate = 1000
+  end
+  behaves_like "a riemann client"
+
+  should 'send a state' do
+    res = @client_with_transport << {
+      :state => 'ok',
+      :service => 'test',
+      :description => 'desc',
+      :metric_f => 1.0
+    }
+
+    res.should.be.nil
+    wait_for { @client['service = "test"'].first }.state.should.equal 'ok'
+  end
+
+  should 'survive inactivity' do
+    @client_with_transport.<<({
+      :state => 'warning',
+      :service => 'survive UDP inactivity',
+    }).should.be.nil
+    wait_for { @client['service = "survive UDP inactivity"'].first.state == 'warning' }
+
+    sleep INACTIVITY_TIME
+
+    @client_with_transport.<<({
+      :state => 'ok',
+      :service => 'survive UDP inactivity',
+    }).should.be.nil
+    wait_for { @client['service = "survive UDP inactivity"'].first.state == 'ok' }
+  end
+
+  should 'survive local close' do
+    @client_with_transport.<<({
+      :state => 'warning',
+      :service => 'survive UDP local close',
+    }).should.be.nil
+    wait_for { @client['service = "survive UDP local close"'].first.state == 'warning' }
+
+    @client.close
+
+    @client_with_transport.<<({
+      :state => 'ok',
+      :service => 'survive UDP local close',
+    }).should.be.nil
+    wait_for { @client['service = "survive UDP local close"'].first.state == 'ok' }
+  end
+
+  should "raise Riemann::Client::Unsupported exception on query" do
+    should.raise(Riemann::Client::Unsupported) { @client_with_transport['service = "test"'] }
+    should.raise(Riemann::Client::Unsupported) { @client_with_transport.query('service = "test"') }
+  end
+
+end

data/spec/riemann.config

@@ -0,0 +1,30 @@
+; -*- mode: clojure; -*-
+; vim: filetype=clojure
+
+(logging/init {:file "/var/log/riemann/riemann.log"})
+
+; Listen on the local interface over TCP (5555), UDP (5555), websockets
+; (5556) and TLS (5554)
+(let [host "127.0.0.1"]
+  (tcp-server {:host host})
+  (udp-server {:host host})
+  (ws-server  {:host host})
+  (tcp-server {:host host :port 5554 :tls? true :key "/etc/riemann/riemann_server.pkcs8" :cert "/etc/riemann/riemann_server.crt" :ca-cert "/etc/riemann/riemann_server.crt"}))
+
+; Expire old events from the index every 5 seconds.
+(periodically-expire 5)
+
+(let [index (index)]
+  ; Inbound events will be passed to these streams:
+  (streams
+    (default :ttl 60
+      ; Index all events immediately.
+      ;index
+
+      ; Index all events after a delay.
+      (batch 1000 1/10
+             (sflatten index))
+
+      ; Log expired events.
+      (expired
+        (fn [event] (info "expired" event))))))

metadata

@@ -1,74 +1,103 @@
 --- !ruby/object:Gem::Specification
 name: riemann-client
 version: !ruby/object:Gem::Version
-  version: 0.2.4
-  prerelease: 
+  version: 1.0.0
 platform: ruby
 authors:
 - Kyle Kingsbury
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-03 00:00:00.000000000 Z
+date: 2022-06-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: beefcake
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.5
-  type: :runtime
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: bacon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.5
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: trollop
+  name: timecop
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.16.2
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: beefcake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.16.2
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: mtrc
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.0.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.0.4
-description: 
+description: Client for the distributed event system Riemann.
 email: aphyr@aphyr.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.markdown
+- Rakefile
 - lib/riemann.rb
 - lib/riemann/attribute.rb
 - lib/riemann/auto_state.rb
 - lib/riemann/client.rb
+- lib/riemann/client/ssl_socket.rb
 - lib/riemann/client/tcp.rb
 - lib/riemann/client/tcp_socket.rb
 - lib/riemann/client/udp.rb
@@ -78,30 +107,32 @@ files:
 - lib/riemann/query.rb
 - lib/riemann/state.rb
 - lib/riemann/version.rb
-- LICENSE
-- README.markdown
+- riemann-client.gemspec
+- spec/client.rb
+- spec/riemann.config
 homepage: https://github.com/aphyr/riemann-ruby-client
-licenses: []
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.8.7
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: riemann-client
-rubygems_version: 1.8.25
+rubygems_version: 3.2.5
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Client for the distributed event system Riemann.
-test_files: []
+test_files:
+- spec/client.rb
+- spec/riemann.config