vcap_logging 0.1.4

data/spec/unit/file_sink_spec.rb

@@ -0,0 +1,79 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+require 'fileutils'
+require 'tmpdir'
+
+describe VCAP::Logging::Sink::FileSink do
+  before :each do
+    @tmp_dir = Dir.mktmpdir
+    @logfile = File.join(@tmp_dir, 'test.log')
+    @test_line = "testing 123\n"
+  end
+
+  after :each do
+    FileUtils.rm_rf(@tmp_dir)
+    File.directory?(@tmp_dir).should be_false
+  end
+
+  it 'creates a file if it does not exist' do
+    File.exist?(@logfile).should be_false
+    sink = VCAP::Logging::Sink::FileSink.new(@logfile)
+    File.exist?(@logfile).should be_true
+  end
+
+  it 'writes immediately to the file if buffering is disabled' do
+    fmt = mock(:formatter)
+    fmt.should_receive(:format_record).with(anything()).and_return(@test_line)
+    sink = VCAP::Logging::Sink::FileSink.new(@logfile, fmt)
+    sink.add_record('foo')
+    read_file(@log_file).should == @test_line
+  end
+
+  it 'does not write immediately to the file if buffering is enabled' do
+    buffer_size = @test_line.length * 4 + 1
+    fmt = mock(:formatter)
+    fmt.should_receive(:format_record).exactly(6).times.with(anything()).and_return(@test_line)
+    sink = VCAP::Logging::Sink::FileSink.new(@logfile, fmt, :buffer_size => buffer_size)
+    for x in 0..3
+      sink.add_record('foo')
+      read_file(@logfile).should == ""
+    end
+
+    expected = @test_line * 5
+    # Should flush the buffer
+    sink.add_record('foo')
+    read_file(@log_file).should == expected
+
+    # Should be buffered
+    sink.add_record('foo')
+    read_file(@log_file).should == expected
+  end
+
+  it 'flushes internal buffers when asked' do
+    buffer_size = @test_line.length * 2
+    fmt = mock(:formatter)
+    fmt.should_receive(:format_record).with(anything()).and_return(@test_line)
+    sink = VCAP::Logging::Sink::FileSink.new(@logfile, fmt, :buffer_size => buffer_size)
+    sink.add_record('foo')
+    read_file(@logfile).should == ""
+    sink.flush
+    read_file(@logfile).should == @test_line
+  end
+
+  it 'flushes internal buffers on close' do
+    buffer_size = @test_line.length * 2
+    fmt = mock(:formatter)
+    fmt.should_receive(:format_record).with(anything()).and_return(@test_line)
+    sink = VCAP::Logging::Sink::FileSink.new(@logfile, fmt, :buffer_size => buffer_size)
+    sink.add_record('foo')
+    read_file(@logfile).should == ""
+    sink.close
+    read_file(@logfile).should == @test_line
+  end
+
+  def read_file(file)
+    data = nil
+    File.open(@logfile, 'r') {|f| data = f.read }
+    data
+  end
+end

data/spec/unit/log_record_spec.rb

@@ -0,0 +1,51 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+require 'thread'
+
+describe VCAP::Logging::LogRecord do
+  before :each do
+    @logger = VCAP::Logging::Logger.new('bar', nil)
+    @tags = ['zaz']
+    @data = 'foo'
+    @log_level = :debug
+    @rec = VCAP::Logging::LogRecord.new(@log_level, @data, @logger, @tags)
+  end
+
+  describe '#initialize' do
+    it "sets the current thread id and short id" do
+      @rec.thread_id.should == Thread.current.object_id
+      @rec.thread_shortid.should_not == nil
+    end
+
+    it "sets the current process id" do
+      @rec.process_id.should == Process.pid
+    end
+
+    it "sets the current fiber id and short id" do
+      begin
+        require 'fiber'
+        @rec.fiber_id.should == Fiber.current.object_id
+        @rec.fiber_shortid.should_not == nil
+      rescue LoadError
+        @rec.fiber_id.should == nil
+        @rec.fiber_shortid.should == nil
+      end
+    end
+
+    it "sets the logger name" do
+      @rec.logger_name.should == @logger.name
+    end
+
+    it "sets the timestamp of when the record was created" do
+      @rec.timestamp.should_not be_nil
+    end
+
+    it "sets tags" do
+      @rec.tags.should == @tags
+    end
+
+    it "sets the log level" do
+      @rec.log_level.should == @log_level
+    end
+  end
+end

data/spec/unit/logger_spec.rb

@@ -0,0 +1,148 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe VCAP::Logging::Logger do
+  before :each do
+    @levels = {:debug => 2, :info => 1, :fatal => 0}
+    @sink_map = VCAP::Logging::SinkMap.new(@levels)
+    @logger = VCAP::Logging::Logger.new('test_logger', @sink_map)
+    VCAP::Logging::Logger.define_log_levels(@levels)
+  end
+
+  describe '.define_log_levels' do
+    it 'should define helper methods corresponding to the name of the log levels' do
+      level_map = {:error => 2, :info => 1, :debug => 0}
+      VCAP::Logging::Logger.define_log_levels(level_map)
+
+      # Check that existing loggers are updated
+      for name in level_map.keys
+        @logger.respond_to?(name).should be_true
+        name_f = name.to_s + 'f'
+        @logger.respond_to?(name_f.to_sym).should be_true
+      end
+
+      # Check that new loggers are updated as well
+      new_logger = VCAP::Logging::Logger.new('test_logger2', VCAP::Logging::SinkMap.new(level_map))
+      for name in level_map.keys
+        new_logger.respond_to?(name).should be_true
+        name_f = name.to_s + 'f'
+        new_logger.respond_to?(name_f.to_sym).should be_true
+      end
+    end
+
+    it 'should undefine previously defined helpers' do
+      level_map = {:error => 2, :info => 1, :debug => 0}
+      VCAP::Logging::Logger.define_log_levels(level_map)
+      for name in level_map.keys
+        @logger.respond_to?(name).should be_true
+        name_f = name.to_s + 'f'
+        @logger.respond_to?(name_f.to_sym).should be_true
+      end
+
+      # Check that previously defined methods are no longer there, and that the
+      # appropriate methods have been defined
+      new_levels = {:foo => 2, :bar => 1}
+      VCAP::Logging::Logger.define_log_levels(new_levels)
+      for name in level_map.keys
+        @logger.respond_to?(name).should be_false
+        name_f = name.to_s + 'f'
+        @logger.respond_to?(name_f.to_sym).should be_false
+      end
+      for name in new_levels.keys
+        @logger.respond_to?(name).should be_true
+        name_f = name.to_s + 'f'
+        @logger.respond_to?(name_f.to_sym).should be_true
+      end
+    end
+  end
+
+  describe '#log' do
+    it 'should raise an exception if called with an invalid level' do
+      lambda { @logger.log(3, 'foo') }.should raise_error(ArgumentError)
+    end
+
+    it 'should use supplied blocks to generate log data' do
+      block_called = false
+      sink = mock(:sink)
+      sink.should_receive(:add_record).with(an_instance_of(VCAP::Logging::LogRecord)).once
+      @sink_map.add_sink(nil, nil, sink)
+      @logger.log_level = :info
+      @logger.log(:fatal) { block_called = true; 'foo' }
+      block_called.should be_true
+    end
+
+    it 'should create log records for active levels' do
+      sink = mock(:sink)
+      sink.should_receive(:add_record).with(an_instance_of(VCAP::Logging::LogRecord)).twice
+      @sink_map.add_sink(nil, nil, sink)
+      @logger.log_level = :info
+      @logger.log(:fatal, 'foo')
+      @logger.log(:info, 'foo')
+      @logger.log(:debug, 'foo')
+    end
+
+    it 'should not create log records for levels that are not active' do
+      sink = mock(:sink)
+      sink.should_not_receive(:add_record)
+      @sink_map.add_sink(nil, nil, sink)
+      @logger.log_level = :info
+      @logger.log(:debug, 'foo')
+    end
+
+    it 'should not call blocks associated with inactive levels' do
+      sink = mock(:sink)
+      sink.should_not_receive(:add_record)
+      @sink_map.add_sink(nil, nil, sink)
+      @logger.log_level = :info
+      block_called = false
+      @logger.log(:debug) { block_called = true; 'foo' }
+      block_called.should be_false
+    end
+
+    it "should add an 'exception' tag when data is a kind of Exception" do
+      @logger.log_level = :info
+      ex = StandardError.new("Testing 123")
+      VCAP::Logging::LogRecord.should_receive(:new).with(:info, ex, @logger, [:exception])
+      @logger.info(ex)
+    end
+  end
+
+  describe '#logf' do
+    it 'should raise an exception if called with an invalid level' do
+      lambda { @logger.logf(:level3, 'foo') }.should raise_error(ArgumentError)
+    end
+
+    it 'should create log records for active levels' do
+      sink = mock(:sink)
+      sink.should_receive(:add_record).with(an_instance_of(VCAP::Logging::LogRecord)).twice
+      @sink_map.add_sink(nil, nil, sink)
+      @logger.log_level = :info
+      @logger.logf(:fatal, 'foo %s', ['bar'])
+      @logger.logf(:info, 'foo %s', ['baz'])
+      @logger.logf(:debug, 'foo %s', ['jaz'])
+    end
+
+    it 'should not create log records for levels that are not active' do
+      sink = mock(:sink)
+      sink.should_not_receive(:add_record)
+      @sink_map.add_sink(nil, nil, sink)
+      @logger.log_level = :info
+      @logger.logf(:debug, 'foo', [])
+    end
+  end
+
+  describe 'helper methods' do
+    it 'should correctly pass their associated log levels' do
+      fmt  = '%s'
+      data = 'foo'
+      for name in @levels.keys
+        @logger.should_receive(:log).with(name, data).once
+        @logger.should_receive(:logf).with(name, fmt, [data]).once
+
+        @logger.send(name, data)
+        name_f = name.to_s + 'f'
+        @logger.send(name_f.to_sym, fmt, [data])
+      end
+    end
+  end
+
+end

data/spec/unit/logging_spec.rb

@@ -0,0 +1,114 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+require 'fileutils'
+require 'tmpdir'
+
+require 'vcap/logging'
+
+describe VCAP::Logging do
+  before :each do
+    VCAP::Logging.reset
+  end
+
+  describe '.init' do
+    it 'should pick a default log level' do
+      VCAP::Logging.default_log_level.should_not be_nil
+    end
+  end
+
+  describe '.logger' do
+    it 'should create a new logger if one does not exist' do
+      logger = VCAP::Logging.logger('foo.bar')
+      logger.should_not be_nil
+    end
+
+    it 'should return the same logger for multiple calls' do
+      logger = VCAP::Logging.logger('foo.bar')
+      logger.should_not be_nil
+
+      VCAP::Logging.logger('foo.bar').should == logger
+    end
+
+    it 'should set log level to the default if no masks are present' do
+      logger = VCAP::Logging.logger('foo.bar')
+      logger.should_not be_nil
+      logger.log_level.should == VCAP::Logging.default_log_level
+    end
+
+    it 'should set log level to the most restrictive mask that matches' do
+      VCAP::Logging.set_log_level('.*', :debug)
+      VCAP::Logging.set_log_level('foo\..*', :fatal)
+      logger = VCAP::Logging.logger('foo.bar')
+      logger.log_level.should == :fatal
+    end
+  end
+
+  describe '.set_log_level' do
+    it 'should raise an error if supplied with an unknown level' do
+      lambda { VCAP::Logging.set_log_level('foo', :zazzle) }.should raise_error(ArgumentError)
+    end
+
+    it 'should set the log level on all loggers that match the supplied regex' do
+      level_map = {
+        'foo.bar.baz' => [:debug, :error],
+        'foo.bar.jaz' => [:debug, :error],
+        'foo.bar'     => [:info,  :info],
+        'foo'         => [:warn,  :warn],
+      }
+
+      for name, levels in level_map
+        VCAP::Logging.logger(name).log_level = levels[0]
+      end
+
+      VCAP::Logging.set_log_level('foo\.bar\..*', :error)
+
+      for name, levels in level_map
+        VCAP::Logging.logger(name).log_level.should == levels[1]
+      end
+    end
+
+    it 'should reset loggers at a given level that no longer match to the default level' do
+      logger = VCAP::Logging.logger('foo.bar')
+      VCAP::Logging.set_log_level('foo.bar', :warn)
+      logger.log_level.should == :warn
+      VCAP::Logging.set_log_level('zazzle', :warn)
+      logger.log_level.should == VCAP::Logging.default_log_level
+    end
+  end
+
+  describe '.setup_from_config' do
+    it 'should set the default log level if supplied with a level key' do
+      # Should handle both string/symbol keys
+      VCAP::Logging.setup_from_config(:level => 'debug')
+      VCAP::Logging.default_log_level.should == :debug
+
+      VCAP::Logging.setup_from_config('level' => 'warn')
+      VCAP::Logging.default_log_level.should == :warn
+    end
+
+    it 'should raise an exception if given an invalid level' do
+      lambda { VCAP::Logging.setup_from_config(:level => 'zazzle') }.should raise_error(ArgumentError)
+    end
+
+    it 'should add a stdio sink if no other sinks are configured' do
+      VCAP::Logging.should_receive(:add_sink).with(nil, nil, an_instance_of(VCAP::Logging::Sink::StdioSink)).once
+      VCAP::Logging.setup_from_config(:level => 'debug')
+    end
+
+    it 'should add a file sink if given a file key' do
+      tmpdir = Dir.mktmpdir
+      File.directory?(tmpdir).should be_true
+
+      VCAP::Logging.should_receive(:add_sink).with(nil, nil, an_instance_of(VCAP::Logging::Sink::FileSink)).once
+      VCAP::Logging.setup_from_config('file' => File.join(tmpdir, 'test_file1'))
+
+      FileUtils.rm_rf(tmpdir)
+      File.directory?(tmpdir).should be_false
+    end
+
+    it 'should add a syslog sink if given a syslog key' do
+      VCAP::Logging.should_receive(:add_sink).with(nil, nil, an_instance_of(VCAP::Logging::Sink::SyslogSink)).once
+      VCAP::Logging.setup_from_config('syslog' => 'test1')
+    end
+  end
+end

data/spec/unit/sink_map_spec.rb

@@ -0,0 +1,64 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe VCAP::Logging::SinkMap do
+  before :all do
+    @level_map = {
+      :fatal  => 0,
+      :info   => 1,
+      :debug  => 2,
+      :debug2 => 3,
+    }
+  end
+
+  describe '#add_sink' do
+    before :each do
+      @sink_map = VCAP::Logging::SinkMap.new(@level_map)
+    end
+
+    it 'raises an error for an unknown level' do
+      lambda { @sink_map.add_sink(:zazzle, :info, 'foo') }.should raise_error(ArgumentError)
+      lambda { @sink_map.add_sink(:info, :zazzle, 'foo') }.should raise_error(ArgumentError)
+    end
+
+    it 'handles a single level range' do
+      @sink_map.add_sink(:info, :info, 'foo')
+      @sink_map.get_sinks(:info).should == ['foo']
+      [:fatal, :debug, :debug2].each {|l| @sink_map.get_sinks(l).should == [] }
+    end
+
+    it 'handles a range with both start and end set' do
+      @sink_map.add_sink(:debug, :info, 'foo')
+      [:info, :debug].each {|l| @sink_map.get_sinks(l).should == ['foo'] }
+      [:fatal, :debug2].each {|l| @sink_map.get_sinks(l).should == [] }
+    end
+
+    it 'handles a range with only an end set' do
+      @sink_map.add_sink(nil, :info, 'foo')
+      [:info, :debug, :debug2].each {|l| @sink_map.get_sinks(l).should == ['foo'] }
+      @sink_map.get_sinks(:fatal).should == []
+    end
+
+    it 'handles a range with only a start set' do
+      @sink_map.add_sink(:info, nil, 'foo')
+      [:info, :fatal].each {|l| @sink_map.get_sinks(l).should == ['foo'] }
+      [:debug, :debug2].each {|l| @sink_map.get_sinks(l).should == [] }
+    end
+
+    it 'handles a range with no start or end' do
+      @sink_map.add_sink(nil, nil, 'foo')
+      [:fatal, :info, :debug, :debug2].each {|l| @sink_map.get_sinks(l).should == ['foo'] }
+    end
+
+  end
+
+  describe '#each_sink' do
+    it 'maps over each sink only once' do
+      sink_map = VCAP::Logging::SinkMap.new(@level_map)
+      sink_map.add_sink(nil, nil, 'foo')
+      sink_map.add_sink(:info, :info, 'bar')
+      sinks = []
+      sink_map.each_sink {|s| sinks << s }
+      sinks.should == ['foo', 'bar']
+    end
+  end
+end