riemann-client 0.2.5 → 1.0.1

data/spec/client.rb

@@ -0,0 +1,384 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# 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 # rubocop:disable Style/MixinUsage
+
+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(metric)
+  @client_with_transport << {
+    service: 'metric-test',
+    metric: metric
+  }
+
+  wait_for { @client["service = \"metric-test\" and metric = #{metric}"].first }
+    .metric.should.equal metric
+end
+
+def truthy
+  ->(obj) { !(obj.nil? || obj == false) }
+end
+
+def falsey
+  ->(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.is_a?(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 StandardError
+      # swallow the exception
+    end
+    client.should.be.is_a?(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 %w[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 %w[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     #{format('%.2f', rate)} queries/sec (#{format('%.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(&:join)
+    t2 = Time.now
+
+    rate = total / (t2 - t1)
+    puts "\n     #{format('%.2f', rate)} inserts/sec (#{format('%.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,118 @@
 --- !ruby/object:Gem::Specification
 name: riemann-client
 version: !ruby/object:Gem::Version
-  version: 0.2.5
-  prerelease: 
+  version: 1.0.1
 platform: ruby
 authors:
 - Kyle Kingsbury
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-02-05 00:00:00.000000000 Z
+date: 2022-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: beefcake
+  name: bacon
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.5
-  type: :runtime
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.5
+        version: '1.3'
 - !ruby/object:Gem::Dependency
-  name: trollop
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.16.2
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        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"
+- ".rubocop.yml"
+- 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 +122,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: []
-post_install_message: 
+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.6.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
-signing_key: 
-specification_version: 3
+rubygems_version: 3.3.15
+signing_key:
+specification_version: 4
 summary: Client for the distributed event system Riemann.
-test_files: []
+test_files:
+- spec/client.rb
+- spec/riemann.config