hoodoo 1.0.2

data/spec/logger/fast_writer_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Hoodoo::Logger::FastWriter do
+
+  # Nothing much to do here as code is covered by logger_spec.rb. The only
+  # thing we make sure of here is that the stream writer tested there is a
+  # subclass of the thing this test would otherwise cover.
+  #
+  it 'is used by the expected writer' do
+    expect( Hoodoo::Logger::StreamWriter < described_class ).to eq( true )
+  end
+
+  it 'complains about missing subclass implementation' do
+    expect {
+      Hoodoo::Logger::FastWriter.new().report( 1, 2, 3, 4 )
+    }.to raise_error( RuntimeError )
+  end
+end

data/spec/logger/logger_spec.rb

@@ -0,0 +1,259 @@
+require 'spec_helper'
+
+describe Hoodoo::Logger do
+
+  # ===========================================================================
+
+  context 'basic behaviour' do
+    before :each do
+      @logger = described_class.new
+    end
+
+    it 'has a debug level by default' do
+      expect( @logger.level ).to eq( :debug )
+    end
+
+    it 'has no writers by default' do
+      expect( $stdout ).to_not receive( :puts )
+      expect( $stderr ).to_not receive( :puts )
+
+      @logger.error( 'No writers' )
+    end
+
+    it 'complains about bad additions' do
+      expect {
+        @logger.add( Object.new )
+      }.to raise_error( RuntimeError )
+    end
+  end
+
+  # ===========================================================================
+
+  context 'pool operation' do
+    before :each do
+      @logger   = described_class.new
+      @stderr_1 = Hoodoo::Logger::StreamWriter.new( $stderr )
+      @stderr_2 = Hoodoo::Logger::StreamWriter.new( $stderr )
+      @stderr_3 = Hoodoo::Logger::StreamWriter.new( $stderr )
+
+      # Test single & multiple additions in passing.
+      #
+      @logger.add( @stderr_1 )
+      @logger.add( @stderr_2, @stderr_3 )
+    end
+
+    it 'calls added instances' do
+      expect( @stderr_1 ).to receive( :report ).once
+      expect( @stderr_2 ).to receive( :report ).once
+      expect( @stderr_3 ).to receive( :report ).once
+      expect( $stderr ).to_not receive( :puts )
+
+      @logger.error( 'Three instances of StreamWriter' )
+    end
+
+    it 'removes requested instances' do
+      @logger.remove( @stderr_2 )
+
+      expect( @stderr_1 ).to receive( :report ).once
+      expect( @stderr_2 ).to_not receive( :report )
+      expect( @stderr_3 ).to receive( :report ).once
+      expect( $stderr ).to_not receive( :puts )
+
+      @logger.error( 'Two instances of StreamWriter' )
+    end
+
+    it 'removes all instances' do
+      @logger.remove_all
+
+      expect( @stderr_1 ).to_not receive( :report )
+      expect( @stderr_2 ).to_not receive( :report )
+      expect( @stderr_3 ).to_not receive( :report )
+      expect( $stderr ).to_not receive( :puts )
+
+      @logger.error( 'No instances of StreamWriter' )
+    end
+
+    it 'retrieves instances in order' do
+      expect( @logger.instances ).to eq( [ @stderr_1, @stderr_2, @stderr_3 ] )
+    end
+  end
+
+  # ===========================================================================
+
+  context 'structured logging' do
+    before :each do
+      @logger = described_class.new
+      @writer = Hoodoo::Logger::StreamWriter.new( $stderr )
+      @logger.add( @writer )
+    end
+
+    it 'makes a structured log entry' do
+      expect(@writer).to receive(:report).with(:debug, :ComponentName, :code_value, {'_data'=>[1,2,3]})
+      @logger.report(
+        :debug,
+        :ComponentName,
+        :code_value,
+        {'_data'=>[1,2,3]}
+      )
+    end
+
+    it 'obeys debug log level' do
+      expect(@writer).to receive(:report).once
+
+      @logger.level = :debug
+      @logger.report(:debug, :comp, :code, {})
+
+      expect(@writer).to_not receive(:report)
+
+      @logger.level = :info
+      @logger.report(:debug, :comp, :code, {})
+      @logger.level = :warn
+      @logger.report(:debug, :comp, :code, {})
+      @logger.level = :error
+      @logger.report(:debug, :comp, :code, {})
+    end
+
+    it 'obeys info log level' do
+      expect(@writer).to receive(:report).exactly(2).times
+
+      @logger.level = :debug
+      @logger.report(:info, :comp, :code, {})
+      @logger.level = :info
+      @logger.report(:info, :comp, :code, {})
+
+      expect(@writer).to_not receive(:report)
+
+      @logger.level = :warn
+      @logger.report(:info, :comp, :code, {})
+      @logger.level = :error
+      @logger.report(:info, :comp, :code, {})
+    end
+
+    it 'obeys warn log level' do
+      expect(@writer).to receive(:report).exactly(3).times
+
+      @logger.level = :debug
+      @logger.report(:warn, :comp, :code, {})
+      @logger.level = :info
+      @logger.report(:warn, :comp, :code, {})
+      @logger.level = :warn
+      @logger.report(:warn, :comp, :code, {})
+
+      expect(@writer).to_not receive(:report)
+
+      @logger.level = :error
+      @logger.report(:warn, :comp, :code, {})
+    end
+
+    it 'obeys error log level' do
+      expect(@writer).to receive(:report).exactly(4).times
+
+      @logger.level = :debug
+      @logger.report(:error, :comp, :code, {})
+      @logger.level = :info
+      @logger.report(:error, :comp, :code, {})
+      @logger.level = :warn
+      @logger.report(:error, :comp, :code, {})
+      @logger.level = :error
+      @logger.report(:error, :comp, :code, {})
+    end
+  end
+
+  # ===========================================================================
+
+  context 'legacy logging' do
+    before :each do
+      @logger = described_class.new
+      @writer = Hoodoo::Logger::StreamWriter.new( $stderr )
+      @logger.add( @writer )
+    end
+
+    it 'makes debug log entry' do
+      expect(@writer).to receive(:report).with(:debug, :Middleware, :log, {'_data'=>[1,2,3]})
+      @logger.debug(1,2,3)
+    end
+
+    it 'makes info log entry' do
+      expect(@writer).to receive(:report).with(:info, :Middleware, :log, {'_data'=>[2,3,4]})
+      @logger.info(2,3,4)
+    end
+
+    it 'makes info log entry' do
+      expect(@writer).to receive(:report).with(:warn, :Middleware, :log, {'_data'=>[3,4,5]})
+      @logger.warn(3,4,5)
+    end
+
+    it 'makes error log entry' do
+      expect(@writer).to receive(:report).with(:error, :Middleware, :log, {'_data'=>[4,5,6]})
+      @logger.error(4,5,6)
+    end
+
+    it 'customises component' do
+      logger = described_class.new(:Custom)
+      logger.add(@writer)
+      expect(@writer).to receive(:report).with(:error, :Custom, :log, {'_data'=>[4,5,6]})
+      logger.error(4,5,6)
+    end
+
+    it 'obeys debug log level' do
+      expect(@writer).to receive(:report).once
+
+      @logger.level = :debug
+      @logger.debug( 'data' )
+
+      expect(@writer).to_not receive(:report)
+
+      @logger.level = :info
+      @logger.debug( 'data' )
+      @logger.level = :warn
+      @logger.debug( 'data' )
+      @logger.level = :error
+      @logger.debug( 'data' )
+    end
+
+    it 'obeys info log level' do
+      expect(@writer).to receive(:report).exactly(2).times
+
+      @logger.level = :debug
+      @logger.info( 'data' )
+      @logger.level = :info
+      @logger.info( 'data' )
+
+      expect(@writer).to_not receive(:report)
+
+      @logger.level = :warn
+      @logger.info( 'data' )
+      @logger.level = :error
+      @logger.info( 'data' )
+    end
+
+    it 'obeys warn log level' do
+      expect(@writer).to receive(:report).exactly(3).times
+
+      @logger.level = :debug
+      @logger.warn( 'data' )
+      @logger.level = :info
+      @logger.warn( 'data' )
+      @logger.level = :warn
+      @logger.warn( 'data' )
+
+      expect(@writer).to_not receive(:report)
+
+      @logger.level = :error
+      @logger.warn( 'data' )
+    end
+
+    it 'obeys error log level' do
+      expect(@writer).to receive(:report).exactly(4).times
+
+      @logger.level = :debug
+      @logger.error( 'data' )
+      @logger.level = :info
+      @logger.error( 'data' )
+      @logger.level = :warn
+      @logger.error( 'data' )
+      @logger.level = :error
+      @logger.error( 'data' )
+    end
+  end
+end

data/spec/logger/slow_writer_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+
+describe Hoodoo::Logger::SlowWriter do
+
+  # See fast_writer_spec.rb comments.
+  #
+  it 'is used by the expected writer' do
+    expect( Hoodoo::Logger::FileWriter < described_class ).to eq( true )
+  end
+
+  class RSpecTestSlowWriter < Hoodoo::Logger::SlowWriter
+    def report( a, b, c, d )
+      expectable_hook( a, b, c, d )
+    end
+  end
+
+  context 'with exceptions' do
+    class RSpecTestErrantSlowWriter < Hoodoo::Logger::SlowWriter
+      def report( a, b, c, d )
+        raise 'I am broken'
+      end
+    end
+
+    before :each do
+      @logger = Hoodoo::Logger.new
+      @logger.add( RSpecTestErrantSlowWriter.new )
+    end
+
+    it 'logs them' do
+      @logger.debug( 'Doh' )
+    end
+  end
+
+  context 'message dropping' do
+    before :each do
+
+      # This sync queue is pushed from the running test and popped from the
+      # communicators inside their message handler, so that we can force the
+      # communicators to halt "mid-message" by not pushing until we're ready.
+
+      $sync_queue = Queue.new
+    end
+
+    before :each do
+      @logger = Hoodoo::Logger.new
+    end
+
+    class RSpecTestDroppingSlowWriter < Hoodoo::Logger::SlowWriter
+      def initialize
+        @count = 0
+      end
+
+      attr_reader :count
+
+      # This consumes one message then tries to pop a queue item, forcing it
+      # to wait for the test code to push. This lets us control completely
+      # consistently thread execution, guaranteeing no further processing of
+      # log messages until we want to let it run.
+      #
+      def report( a, b, c, d )
+        $sync_queue.pop if @count == 0
+        @count += 1
+      end
+    end
+
+    # Cribbed from the communicators/pool_spec.rb approach, with the same
+    # limitations.
+    #
+    it 'reports dropped messages' do
+
+      args   = [ :error, :CustomComponent, :custom_code, { :data => :foo } ]
+      writer = RSpecTestDroppingSlowWriter.new
+
+      @logger.add( writer )
+
+      # See communicators/pool_spec.rb for rationale.
+
+      expect(writer).to receive(:report).exactly(1).times.with( *args ).and_call_original
+      @logger.report( *args )
+
+      loop do
+        sleep 0.01
+        break if $sync_queue.num_waiting > 0
+      end
+
+      # See communicators/pool_spec.rb for rationale. Note the assumption
+      # here that the logger is running on a communicator pool, so the queue
+      # size there is applicable here. This makes the test potentially fragile.
+
+      limit      = Hoodoo::Communicators::Pool::MAX_SLOW_QUEUE_SIZE
+      additional = 10
+
+      # See communicators/pool_spec.rb for rationale.
+
+      1.upto( limit + additional ) do | i |
+        @logger.report( *args )
+        sleep 2 if i == 1
+      end
+
+      # See communicators/pool_spec.rb for rationale.
+
+      expect(writer).to receive(:report).exactly( limit ).times.with( *args ).and_call_original
+      $sync_queue << :go!
+
+      # See communicators/pool_spec.rb for rationale.
+
+      @logger.wait()
+
+      # See communicators/pool_spec.rb for rationale; send another report in,
+      # provoking first a 'dropped messages' log report.
+      #
+      # I cannot no matter how hard I try come up with a syntax for RSpec
+      # that expects the 'dropped messages' report then '*args'; it just
+      # messes up the test conditions ever time, causing timeouts in the
+      # processing thread, "writer.count" expectation failures (see end of
+      # test) and so-on.
+
+      expect(writer).to receive(:report).once.with(
+        :warn,
+        'Hoodoo::Logger::SlowCommunicator',
+        'dropped.messages',
+        "Logging flooded - #{ additional } messages dropped"
+      ).and_call_original
+
+      expect(writer).to receive(:report).once.with( *args ).and_call_original
+
+      @logger.report( *args )
+      @logger.wait()
+
+      # The writer counts only logged messages - the first 'sync up' message,
+      # 'limit' in the queue, 1 reporting the number of dropped messages and
+      # 1 that was sent to prompt that dropped messages report.
+      #
+      # Are you not seeing an expected count? It's possible that the RSpec
+      # message receiving expectations earlier were not met. If those fail,
+      # the test doesn't halt (theory - RSpec raises exceptions to detect
+      # this condition and the pool thread's aggressive exception handler hides
+      # all of that?) but the "and-call-original"'s never happen, so the counts
+      # are lower than they should be here.
+
+      expect( writer.count ).to eq( 1 + limit + 1 + 1 )
+    end
+  end
+end

data/spec/logger/writers/file_writer_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'tempfile'
+
+describe Hoodoo::Logger::FileWriter do
+
+  before :all do
+    temp_name = Dir::Tmpname.make_tmpname( 'hoodoo_rspec_', nil )
+    @temp_path = File.join( Dir::Tmpname.tmpdir, temp_name )
+  end
+
+  after :all do
+    begin
+      File.unlink( @temp_path )
+    rescue
+    end
+  end
+
+  it 'writes to files' do
+
+    # Create the instance; should not write anything.
+    #
+    instance = described_class.new( @temp_path )
+    expect( File.exist?( @temp_path ) ).to be( false )
+
+    # Log a message.
+    #
+    time = Time.parse("2014-01-01 00:00:00 UTC")
+    expect( Time ).to receive( :now ).at_least( 1 ).times.and_return( time )
+
+    instance.report( :a, :b, :c, :d )
+    expect( File.exist?( @temp_path ) ).to be( true )
+
+    logged = File.read( @temp_path )
+    expect( logged ).to eq( "A [2014-01-01T00:00:00.000000Z] b - c: :d\n")
+
+  end
+end