riemann-client 1.0.1 → 1.1.0

data/spec/shared_examples.rb

@@ -0,0 +1,531 @@
+# frozen_string_literal: true
+
+require 'riemann'
+require 'riemann/client'
+require 'set'
+require 'timecop'
+
+INACTIVITY_TIME = 5
+
+class Sequence
+  include Singleton
+
+  def initialize
+    @nextval = 0
+  end
+
+  def nextval
+    @nextval += 1
+  end
+
+  def current
+    @nextval
+  end
+end
+
+def next_message_id
+  Sequence.instance.nextval
+  "#{Process.pid}-#{Sequence.instance.current}"
+end
+
+def wait_for_message_with_id(message_id)
+  wait_for { client[%(message_id = "#{message_id}")].first }
+end
+
+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)
+  message_id = next_message_id
+
+  client_with_transport << {
+    service: 'metric-test',
+    metric: metric,
+    message_id: message_id
+  }
+
+  e = wait_for_message_with_id(message_id)
+  expect(e.metric).to eq(metric)
+end
+
+RSpec.shared_examples 'a riemann client' do
+  it 'is not connected before sending' do
+    expect(client).not_to be_connected
+  end
+
+  context 'when given a block that raises' do
+    let(:client) do
+      res = nil
+      begin
+        Riemann::Client.new(host: 'localhost', port: 5555) do |c|
+          res = c
+          raise 'The Boom'
+        end
+      rescue StandardError
+        # swallow the exception
+      end
+      res
+    end
+
+    it 'in not connected' do
+      expect(client).not_to be_connected
+    end
+  end
+
+  it 'is connected after sending' do
+    client_with_transport << { state: 'ok', service: 'connected check' }
+    expect(client_with_transport).to be_connected
+    # NOTE: only single transport connected at this point, client.connected? is still false until all transports used
+  end
+
+  describe '#<<' do
+    subject { wait_for_message_with_id(message_id) }
+
+    let(:message_id) { next_message_id }
+
+    before do
+      client_with_transport << {
+        state: 'ok',
+        service: 'test',
+        description: 'desc',
+        metric_f: 1.0,
+        message_id: message_id
+      }
+    end
+
+    it 'finds the send message' do
+      expect(subject.state).to eq('ok')
+    end
+  end
+
+  it 'send longs' do
+    roundtrip_metric(0)
+    roundtrip_metric(-3)
+    roundtrip_metric(5)
+    roundtrip_metric(-(2**63))
+    roundtrip_metric(2**63 - 1)
+  end
+
+  it 'send doubles' do
+    roundtrip_metric 0.0
+    roundtrip_metric 12.0
+    roundtrip_metric 1.2300000190734863
+  end
+
+  context 'when sending custom attributes' do
+    subject { wait_for_message_with_id(message_id) }
+
+    before do
+      event = Riemann::Event.new(
+        service: 'custom',
+        state: 'ok',
+        cats: 'meow',
+        env: 'prod',
+        message_id: message_id
+      )
+      event[:sneak] = 'attack'
+      client_with_transport << event
+    end
+
+    let(:message_id) { next_message_id }
+
+    it 'has the expected service' do
+      expect(subject.service).to eq('custom')
+    end
+
+    it 'has the expected state' do
+      expect(subject.state).to eq('ok')
+    end
+
+    it 'has the expected cats' do
+      expect(subject[:cats]).to eq('meow')
+    end
+
+    it 'has the expected env' do
+      expect(subject[:env]).to eq('prod')
+    end
+
+    it 'has the expected sneak' do
+      expect(subject[:sneak]).to eq('attack')
+    end
+  end
+
+  context 'when passing time' do
+    subject { wait_for_message_with_id(message_id) }
+
+    before do
+      Timecop.freeze
+      client_with_transport << {
+        state: 'ok',
+        service: 'test',
+        time: t,
+        message_id: message_id
+      }
+    end
+
+    after do
+      Timecop.return
+    end
+
+    let(:message_id) { next_message_id }
+    let(:t) { (Time.now - 10).to_i }
+
+    it 'has the expected time' do
+      expect(subject.time).to eq(t)
+    end
+
+    it 'has the expected time_micros' do
+      expect(subject.time_micros).to eq(t * 1_000_000)
+    end
+  end
+
+  context 'when passing time_micros' do
+    subject { wait_for_message_with_id(message_id) }
+
+    before do
+      Timecop.freeze
+      client_with_transport << {
+        state: 'ok',
+        service: 'test',
+        time_micros: t,
+        message_id: message_id
+      }
+    end
+
+    after do
+      Timecop.return
+    end
+
+    let(:message_id) { next_message_id }
+    let(:t) { ((Time.now - 10).to_f * 1_000_000).to_i }
+
+    it 'has the expected time' do
+      expect(subject.time).to eq((Time.now - 10).to_i)
+    end
+
+    it 'has the expected time_micros' do
+      expect(subject.time_micros).to eq(t)
+    end
+  end
+
+  context 'when passing no time nor time_micros' do
+    let(:message_id) { next_message_id }
+
+    let(:time_before) { (Time.now.to_f * 1_000_000).to_i }
+    let(:event) do
+      client_with_transport << {
+        state: 'ok',
+        service: 'timeless test',
+        message_id: message_id
+      }
+    end
+    let(:time_after) { (Time.now.to_f * 1_000_000).to_i }
+
+    it 'has the expected time_micros' do
+      time_before
+      event
+      time_after
+
+      e = wait_for_message_with_id(message_id)
+
+      expect([time_before, e.time_micros, time_after].sort).to eq([time_before, e.time_micros, time_after])
+    end
+  end
+
+  describe '#query' do
+    before do
+      message_id1 = next_message_id
+      message_id2 = next_message_id
+      message_id3 = next_message_id
+
+      client_with_transport << { state: 'critical', service: '1', message_id: message_id1 }
+      client_with_transport << { state: 'warning', service: '2', message_id: message_id2 }
+      client_with_transport << { state: 'critical', service: '3', message_id: message_id3 }
+
+      wait_for_message_with_id(message_id3)
+    end
+
+    let(:rate) do
+      t1 = Time.now
+      total = 1000
+      total.times do |_i|
+        client.query('state = "critical"')
+      end
+      t2 = Time.now
+
+      total / (t2 - t1)
+    end
+
+    it 'returns all events without parameters' do
+      expect(client.query.events
+            .map(&:service).to_set).to include(%w[1 2 3].to_set)
+    end
+
+    it 'returns matched events with parameters' do
+      expect(client.query('state = "critical" and (service = "1" or service = "2" or service = "3")').events
+            .map(&:service).to_set).to eq(%w[1 3].to_set)
+    end
+
+    it 'query quickly' do
+      puts "\n     #{format('%.2f', rate)} queries/sec (#{format('%.2f', (1000 / rate))}ms per query)"
+      expect(rate).to be > 100
+    end
+  end
+
+  it '[]' do
+    message_id = next_message_id
+
+    #    expect(client['state = "critical"']).to be_empty
+    client_with_transport << { state: 'critical', message_id: message_id }
+    e = wait_for_message_with_id(message_id)
+    expect(e.state).to eq('critical')
+  end
+
+  describe '#bulk_send' do
+    let(:message_id1) { next_message_id }
+    let(:message_id2) { next_message_id }
+    let(:event1) { wait_for_message_with_id(message_id1) }
+    let(:event2) { wait_for_message_with_id(message_id2) }
+
+    before do
+      client_with_transport.bulk_send(
+        [
+          {
+            state: 'ok',
+            service: 'foo',
+            message_id: message_id1
+          },
+          {
+            state: 'warning',
+            service: 'bar',
+            message_id: message_id2
+          }
+        ]
+      )
+    end
+
+    it 'has send the first event' do
+      expect(event2.state).to eq('warning')
+    end
+
+    it 'has send the second event' do
+      expect(event1.state).to eq('ok')
+    end
+  end
+
+  context 'when using multiple threads' do
+    let!(:rate) do
+      concurrency = 10
+      per_thread = 200
+      total = concurrency * per_thread
+
+      t1 = Time.now
+      concurrency.times.map do
+        Thread.new do
+          per_thread.times do
+            client_with_transport << {
+              state: 'ok',
+              service: 'test',
+              description: 'desc',
+              metric_f: 1.0,
+              message_id: next_message_id
+            }
+          end
+        end
+      end.each(&:join)
+      t2 = Time.now
+
+      total / (t2 - t1)
+    end
+
+    it 'is threadsafe' do
+      puts "\n     #{format('%.2f', rate)} inserts/sec (#{format('%.2f', (1000 / rate))}ms per insert)"
+      expect(rate).to be > expected_rate
+    end
+  end
+end
+
+RSpec.shared_examples 'a riemann client that acknowledge messages' do
+  describe '#<<' do
+    subject do
+      client_with_transport << {
+        state: 'ok',
+        service: 'test',
+        description: 'desc',
+        metric_f: 1.0
+      }
+    end
+
+    it 'acknowledge the message' do
+      expect(subject.ok).to be_truthy
+    end
+  end
+
+  context 'when inactive' do
+    let(:message_id1) { next_message_id }
+    let(:message1) do
+      {
+        state: 'warning',
+        service: 'survive TCP inactivity',
+        message_id: message_id1
+      }
+    end
+
+    let(:message_id2) { next_message_id }
+    let(:message2) do
+      {
+        state: 'ok',
+        service: 'survive TCP inactivity',
+        message_id: message_id2
+      }
+    end
+
+    before do
+      client_with_transport << message1
+      wait_for_message_with_id(message_id1)
+    end
+
+    it 'survive inactivity' do
+      sleep INACTIVITY_TIME
+
+      expect((client_with_transport << message2).ok).to be_truthy
+      wait_for_message_with_id(message_id2)
+    end
+  end
+
+  context 'when the connection is closed' do
+    let(:message_id1) { next_message_id }
+    let(:message1) do
+      {
+        state: 'warning',
+        service: 'survive TCP local close',
+        message_id: message_id1
+      }
+    end
+
+    let(:message_id2) { next_message_id }
+    let(:message2) do
+      {
+        state: 'ok',
+        service: 'survive TCP local close',
+        message_id: message_id2
+      }
+    end
+
+    before do
+      client_with_transport << message1
+      wait_for_message_with_id(message_id1)
+    end
+
+    it 'survive local close' do
+      client.close
+
+      expect((client_with_transport << message2).ok).to be_truthy
+      wait_for_message_with_id(message_id2)
+    end
+  end
+end
+
+RSpec.shared_examples 'a riemann client that does not acknowledge messages' do
+  describe '#<<' do
+    subject do
+      client_with_transport << {
+        state: 'ok',
+        service: 'test',
+        description: 'desc',
+        metric_f: 1.0
+      }
+    end
+
+    it 'does not acknowledge the message' do
+      expect(subject).to be_nil
+    end
+  end
+
+  context 'when inactive' do
+    let(:message_id1) { next_message_id }
+    let(:message1) do
+      {
+        state: 'warning',
+        service: 'survive UDP inactivity',
+        message_id: message_id1
+      }
+    end
+
+    let(:message_id2) { next_message_id }
+    let(:message2) do
+      {
+        state: 'ok',
+        service: 'survive UDP inactivity',
+        message_id: message_id2
+      }
+    end
+
+    before do
+      client_with_transport << message1
+      wait_for_message_with_id(message_id1)
+    end
+
+    it 'survive inactivity' do
+      sleep INACTIVITY_TIME
+
+      client_with_transport << message2
+      wait_for_message_with_id(message_id2)
+    end
+  end
+
+  context 'when the connection is closed' do
+    let(:message_id1) { next_message_id }
+    let(:message1) do
+      {
+        state: 'warning',
+        service: 'survive UDP local close',
+        message_id: message_id1
+      }
+    end
+
+    let(:message_id2) { next_message_id }
+    let(:message2) do
+      {
+        state: 'ok',
+        service: 'survive UDP local close',
+        message_id: message_id2
+      }
+    end
+
+    before do
+      client_with_transport << message1
+      wait_for_message_with_id(message_id1)
+    end
+
+    it 'survive local close' do
+      client.close
+
+      client_with_transport << message2
+      wait_for_message_with_id(message_id2)
+    end
+  end
+
+  it 'raise Riemann::Client::Unsupported exception on #[]' do
+    expect { client_with_transport['service = "test"'] }.to raise_error(Riemann::Client::Unsupported)
+  end
+
+  it 'raise Riemann::Client::Unsupported exception on #query' do
+    expect { client_with_transport.query('service = "test"') }.to raise_error(Riemann::Client::Unsupported)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+RSpec.configure do |config|
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  # https://relishapp.com/rspec/rspec-core/docs/configuration/zero-monkey-patching-mode
+  # config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  # RSpec tries to be friendly to us by detecting deadlocks but this breaks CI
+  # :-(
+  #
+  # Some tests want to start multiple thread in a let block, and this
+  # thread-safety mechanism makes it impossible and raise an exception while
+  # our code is working correctly.
+  #
+  # This issue seems the same as:
+  # https://github.com/rspec/rspec-core/issues/2064
+  #
+  # The feature we disable was introduced in:
+  # https://github.com/rspec/rspec-core/commit/ffe00a1d4e369e312881e6b2c091c8b6fb7e6087
+  config.threadsafe = false
+end

metadata

@@ -1,17 +1,31 @@
 --- !ruby/object:Gem::Specification
 name: riemann-client
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Kyle Kingsbury
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-25 00:00:00.000000000 Z
+date: 2023-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bacon
+  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
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -25,21 +39,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -100,14 +114,18 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/dependabot.yml"
 - ".github/workflows/ci.yml"
+- ".github/workflows/codeql-analysis.yml"
 - ".gitignore"
+- ".rspec"
 - ".rubocop.yml"
 - CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.markdown
 - Rakefile
+- SECURITY.md
 - lib/riemann.rb
 - lib/riemann/attribute.rb
 - lib/riemann/auto_state.rb
@@ -123,8 +141,10 @@ files:
 - lib/riemann/state.rb
 - lib/riemann/version.rb
 - riemann-client.gemspec
-- spec/client.rb
+- spec/client_spec.rb
 - spec/riemann.config
+- spec/shared_examples.rb
+- spec/spec_helper.rb
 homepage: https://github.com/aphyr/riemann-ruby-client
 licenses:
 - MIT
@@ -144,10 +164,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.15
+rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
 summary: Client for the distributed event system Riemann.
 test_files:
-- spec/client.rb
+- spec/client_spec.rb
 - spec/riemann.config
+- spec/shared_examples.rb
+- spec/spec_helper.rb