lumberjack 1.0.13 → 1.1.0

data/spec/formatter/exception_formatter_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-describe Lumberjack::Formatter::ExceptionFormatter do
-
-  it "should convert an exception without a backtrace to a string" do
-    e = ArgumentError.new("not expected")
-    formatter = Lumberjack::Formatter::ExceptionFormatter.new
-    formatter.call(e).should == "ArgumentError: not expected"
-  end
-  
-  it "should convert an exception with a backtrace to a string" do
-    begin
-      raise ArgumentError.new("not expected")
-    rescue => e
-      formatter = Lumberjack::Formatter::ExceptionFormatter.new
-      formatter.call(e).should == "ArgumentError: not expected#{Lumberjack::LINE_SEPARATOR}  #{e.backtrace.join(Lumberjack::LINE_SEPARATOR + '  ')}"
-    end
-  end
-  
-end

data/spec/formatter/inspect_formatter_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-describe Lumberjack::Formatter::InspectFormatter do
-
-  it "should format objects as string by calling their inspect method" do
-    formatter = Lumberjack::Formatter::InspectFormatter.new
-    formatter.call("abc").should == "\"abc\""
-    formatter.call(:test).should == ":test"
-    formatter.call(1).should == "1"
-    formatter.call([:a, 1, "b"]).should == [:a, 1, "b"].inspect
-  end
-
-end

data/spec/formatter/pretty_print_formatter_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-describe Lumberjack::Formatter::PrettyPrintFormatter do
-
-  it "should convert an object to a string using pretty print" do
-    object = Object.new
-    def object.pretty_print(q)
-      q.text "woot!"
-    end
-    formatter = Lumberjack::Formatter::PrettyPrintFormatter.new
-    formatter.call(object).should == "woot!"
-  end
-
-end

data/spec/formatter/string_formatter_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-
-describe Lumberjack::Formatter::StringFormatter do
-
-  it "should format objects as string by calling their to_s method" do
-    formatter = Lumberjack::Formatter::StringFormatter.new
-    formatter.call("abc").should == "abc"
-    formatter.call(:test).should == "test"
-    formatter.call(1).should == "1"
-  end
-
-end

data/spec/formatter_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe Lumberjack::Formatter do
-
-  let(:formatter){ Lumberjack::Formatter.new }
-  
-  it "should have a default set of formatters" do
-    formatter.format("abc").should == "abc"
-    formatter.format([1, 2, 3]).should == "[1, 2, 3]"
-    formatter.format(ArgumentError.new("boom")).should == "ArgumentError: boom"
-  end
-  
-  it "should be able to add a formatter object for a class" do
-    formatter.add(Numeric, lambda{|obj| "number: #{obj}"})
-    formatter.format(10).should == "number: 10"
-  end
-  
-  it "should be able to add a formatter block for a class" do
-    formatter.add(Numeric){|obj| "number: #{obj}"}
-    formatter.format(10).should == "number: 10"
-  end
-  
-  it "should be able to remove a formatter for a class" do
-    formatter.remove(String)
-    formatter.format("abc").should == "\"abc\""
-  end
-  
-  it "should be able to chain add and remove calls" do
-    formatter.remove(String).should == formatter
-    formatter.add(String, Lumberjack::Formatter::StringFormatter.new).should == formatter
-  end
-  
-  it "should format an object based on the class hierarchy" do
-    formatter.add(Numeric){|obj| "number: #{obj}"}
-    formatter.add(Integer){|obj| "fixed number: #{obj}"}
-    formatter.format(10).should == "fixed number: 10"
-    formatter.format(10.1).should == "number: 10.1"
-  end
-  
-  it "should have a default formatter" do
-    formatter.remove(Object)
-    formatter.format(:test).should == ":test"
-  end
-
-end

data/spec/log_entry_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-
-describe Lumberjack::LogEntry do
-  
-  it "should have a time" do
-    t = Time.now
-    entry = Lumberjack::LogEntry.new(t, Lumberjack::Severity::INFO, "test", "app", 1500, "ABCD")
-    entry.time.should == t
-    entry.time = t + 1
-    entry.time.should == t + 1
-  end
-  
-  it "should have a severity" do
-    entry = Lumberjack::LogEntry.new(Time.now, Lumberjack::Severity::INFO, "test", "app", 1500, "ABCD")
-    entry.severity.should == Lumberjack::Severity::INFO
-    entry.severity = Lumberjack::Severity::WARN
-    entry.severity.should == Lumberjack::Severity::WARN
-  end
-  
-  it "should convert a severity label to a numeric level" do
-    entry = Lumberjack::LogEntry.new(Time.now, "INFO", "test", "app", 1500, "ABCD")
-    entry.severity.should == Lumberjack::Severity::INFO
-  end
-  
-  it "should get the severity as a string" do
-    Lumberjack::LogEntry.new(Time.now, Lumberjack::Severity::DEBUG, "test", "app", 1500, nil).severity_label.should == "DEBUG"
-    Lumberjack::LogEntry.new(Time.now, Lumberjack::Severity::INFO, "test", "app", 1500, nil).severity_label.should == "INFO"
-    Lumberjack::LogEntry.new(Time.now, Lumberjack::Severity::WARN, "test", "app", 1500, nil).severity_label.should == "WARN"
-    Lumberjack::LogEntry.new(Time.now, Lumberjack::Severity::ERROR, "test", "app", 1500, nil).severity_label.should == "ERROR"
-    Lumberjack::LogEntry.new(Time.now, Lumberjack::Severity::FATAL, "test", "app", 1500, nil).severity_label.should == "FATAL"
-    Lumberjack::LogEntry.new(Time.now, -1, "test", "app", 1500, nil).severity_label.should == "UNKNOWN"
-    Lumberjack::LogEntry.new(Time.now, 1000, "test", "app", 1500, nil).severity_label.should == "UNKNOWN"
-  end
-  
-  it "should have a message" do
-    entry = Lumberjack::LogEntry.new(Time.now, Lumberjack::Severity::INFO, "test", "app", 1500, "ABCD")
-    entry.message.should == "test"
-    entry.message = "new message"
-    entry.message.should == "new message"
-  end
-  
-  it "should have a progname" do
-    entry = Lumberjack::LogEntry.new(Time.now, Lumberjack::Severity::INFO, "test", "app", 1500, "ABCD")
-    entry.progname.should == "app"
-    entry.progname = "prog"
-    entry.progname.should == "prog"
-  end
-  
-  it "should have a pid" do
-    entry = Lumberjack::LogEntry.new(Time.now, Lumberjack::Severity::INFO, "test", "app", 1500, "ABCD")
-    entry.pid.should == 1500
-    entry.pid = 150
-    entry.pid.should == 150
-  end
-  
-  it "should have a unit_of_work_id" do
-    entry = Lumberjack::LogEntry.new(Time.now, Lumberjack::Severity::INFO, "test", "app", 1500, "ABCD")
-    entry.unit_of_work_id.should == "ABCD"
-    entry.unit_of_work_id = "1234"
-    entry.unit_of_work_id.should == "1234"
-  end
-  
-  it "should be converted to a string" do
-    t = Time.parse("2011-01-29T12:15:32.001")
-    entry = Lumberjack::LogEntry.new(t, Lumberjack::Severity::INFO, "test", "app", 1500, "ABCD")
-    entry.to_s.should == "[2011-01-29T12:15:32.001 INFO app(1500) #ABCD] test"
-  end
-
-end

data/spec/logger_spec.rb

@@ -1,411 +0,0 @@
-require 'spec_helper'
-require 'pathname'
-
-describe Lumberjack::Logger do
-
-  context "initialization" do
-
-    before :all do
-      create_tmp_dir
-    end
-
-    after :all do
-      delete_tmp_dir
-    end
-
-    it "should wrap an IO stream in a device" do
-      output = StringIO.new
-      logger = Lumberjack::Logger.new(output)
-      logger.device.class.should == Lumberjack::Device::Writer
-    end
-
-    it "should have a formatter" do
-      output = StringIO.new
-      logger = Lumberjack::Logger.new(output)
-      logger.formatter.should be
-    end
-
-    it "should open a file path in a device" do
-      logger = Lumberjack::Logger.new(File.join(tmp_dir, "log_file_1.log"))
-      logger.device.class.should == Lumberjack::Device::LogFile
-    end
-
-    it "should open a pathname in a device" do
-      logger = Lumberjack::Logger.new(Pathname.new(File.join(tmp_dir, "log_file_1.log")))
-      logger.device.class.should == Lumberjack::Device::LogFile
-    end
-
-    it "should use the null device if the stream is :null" do
-      logger = Lumberjack::Logger.new(:null)
-      logger.device.class.should == Lumberjack::Device::Null
-    end
-
-    it "should set the level with a numeric" do
-      logger = Lumberjack::Logger.new(:null, :level => Lumberjack::Severity::WARN)
-      logger.level.should == Lumberjack::Severity::WARN
-    end
-
-    it "should set the level with a level" do
-      logger = Lumberjack::Logger.new(:null, :level => :warn)
-      logger.level.should == Lumberjack::Severity::WARN
-    end
-
-    it "should default the level to INFO" do
-      logger = Lumberjack::Logger.new(:null)
-      logger.level.should == Lumberjack::Severity::INFO
-    end
-
-    it "should set the progname"do
-      logger = Lumberjack::Logger.new(:null, :progname => "app")
-      logger.progname.should == "app"
-    end
-
-    it "should create a thread to flush the device" do
-      Thread.should_receive(:new)
-      logger = Lumberjack::Logger.new(:null, :flush_seconds => 10)
-    end
-  end
-
-  context "attributes" do
-    it "should have a level" do
-      logger = Lumberjack::Logger.new
-      logger.level = Lumberjack::Severity::DEBUG
-      logger.level.should == Lumberjack::Severity::DEBUG
-    end
-
-    it "should have a progname" do
-      logger = Lumberjack::Logger.new
-      logger.progname = "app"
-      logger.progname.should == "app"
-    end
-
-    it "should be able to silence the log in a block" do
-      output = StringIO.new
-      logger = Lumberjack::Logger.new(output, :buffer_size => 0, :level => Lumberjack::Severity::INFO, :template => ":message")
-      logger.info("one")
-      logger.silence do
-        logger.level.should == Lumberjack::Severity::ERROR
-        logger.info("two")
-        logger.error("three")
-      end
-      logger.info("four")
-      output.string.split.should == ["one", "three", "four"]
-    end
-
-    it "should be able to customize the level of silence in a block" do
-      output = StringIO.new
-      logger = Lumberjack::Logger.new(output, :buffer_size => 0, :level => Lumberjack::Severity::INFO, :template => ":message")
-      logger.info("one")
-      logger.silence(Lumberjack::Severity::FATAL) do
-        logger.level.should == Lumberjack::Severity::FATAL
-        logger.info("two")
-        logger.error("three")
-        logger.fatal("woof")
-      end
-      logger.info("four")
-      output.string.split.should == ["one", "woof", "four"]
-    end
-
-    it "should not be able to silence the logger if silencing is disabled" do
-      output = StringIO.new
-      logger = Lumberjack::Logger.new(output, :buffer_size => 0, :level => Lumberjack::Severity::INFO, :template => ":message")
-      logger.silencer = false
-      logger.info("one")
-      logger.silence do
-        logger.level.should == Lumberjack::Severity::INFO
-        logger.info("two")
-        logger.error("three")
-      end
-      logger.info("four")
-      output.string.split.should == ["one", "two", "three", "four"]
-    end
-
-    it "should be able to set the progname in a block" do
-      logger = Lumberjack::Logger.new
-      logger.set_progname("app")
-      logger.progname.should == "app"
-      block_executed = false
-      logger.set_progname("xxx") do
-        block_executed = true
-        logger.progname.should == "xxx"
-      end
-      block_executed.should == true
-      logger.progname.should == "app"
-    end
-
-    it "should only affect the current thread when silencing the logger" do
-      output = StringIO.new
-      logger = Lumberjack::Logger.new(output, :buffer_size => 0, :level => Lumberjack::Severity::INFO, :template => ":message")
-      # status is used to make sure the two threads are executing at the same time
-      status = 0
-      begin
-        Thread.new do
-          logger.silence do
-            logger.info("inner")
-            status = 1
-            loop{ sleep(0.001); break if status == 2}
-          end
-        end
-        loop{ sleep(0.001); break if status == 1}
-        logger.info("outer")
-        status = 2
-        logger.close
-        output.string.should include("outer")
-        output.string.should_not include("inner")
-      ensure
-        status = 2
-      end
-    end
-
-    it "should only affect the current thread when changing the progname in a block" do
-      output = StringIO.new
-      logger = Lumberjack::Logger.new(output, :progname => "thread1", :buffer_size => 0, :level => Lumberjack::Severity::INFO, :template => ":progname :message")
-      # status is used to make sure the two threads are executing at the same time
-      status = 0
-      begin
-        Thread.new do
-          logger.set_progname("thread2") do
-            logger.info("inner")
-            status = 1
-            loop{ sleep(0.001); break if status == 2}
-          end
-        end
-        loop{ sleep(0.001); break if status == 1}
-        logger.info("outer")
-        status = 2
-        logger.close
-        output.string.should include("thread1")
-        output.string.should include("thread2")
-      ensure
-        status = 2
-      end
-    end
-  end
-
-  context "flushing" do
-    it "should autoflush the buffer if it hasn't been flushed in a specified number of seconds" do
-      output = StringIO.new
-      logger = Lumberjack::Logger.new(output, :flush_seconds => 0.1, :level => Lumberjack::Severity::INFO, :template => ":message", :buffer_size => 32767)
-      logger.info("message 1")
-      logger.info("message 2")
-      output.string.should == ""
-      sleep(0.15)
-      output.string.split(Lumberjack::LINE_SEPARATOR).should == ["message 1", "message 2"]
-      logger.info("message 3")
-      output.string.should_not include("message 3")
-      sleep(0.15)
-      output.string.split(Lumberjack::LINE_SEPARATOR).should == ["message 1", "message 2", "message 3"]
-    end
-
-    it "should write the log entries to the device on flush and update the last flushed time" do
-      output = StringIO.new
-      logger = Lumberjack::Logger.new(output, :level => Lumberjack::Severity::INFO, :template => ":message", :buffer_size => 32767)
-      logger.info("message 1")
-      output.string.should == ""
-      last_flushed_at = logger.last_flushed_at
-      logger.flush
-      output.string.split(Lumberjack::LINE_SEPARATOR).should == ["message 1"]
-      logger.last_flushed_at.should >= last_flushed_at
-    end
-
-    it "should flush the buffer and close the devices" do
-      output = StringIO.new
-      logger = Lumberjack::Logger.new(output, :level => Lumberjack::Severity::INFO, :template => ":message", :buffer_size => 32767)
-      logger.info("message 1")
-      output.string.should == ""
-      logger.close
-      output.string.split(Lumberjack::LINE_SEPARATOR).should == ["message 1"]
-      output.should be_closed
-    end
-  end
-
-  context "logging" do
-    let(:output){ StringIO.new }
-    let(:device){ Lumberjack::Device::Writer.new(output, :buffer_size => 0) }
-    let(:logger){ Lumberjack::Logger.new(device, :level => Lumberjack::Severity::INFO, :progname => "test") }
-    let(:n){ Lumberjack::LINE_SEPARATOR }
-
-    it "should add entries with a numeric severity and a message" do
-      time = Time.parse("2011-01-30T12:31:56.123")
-      Time.stub(:now => time)
-      logger.add(Lumberjack::Severity::INFO, "test")
-      output.string.should == "[2011-01-30T12:31:56.123 INFO test(#{$$}) #] test#{n}"
-    end
-
-    it "should add entries with a severity label" do
-      time = Time.parse("2011-01-30T12:31:56.123")
-      Time.stub(:now => time)
-      logger.add(:info, "test")
-      output.string.should == "[2011-01-30T12:31:56.123 INFO test(#{$$}) #] test#{n}"
-    end
-
-    it "should add entries with a custom progname and message" do
-      time = Time.parse("2011-01-30T12:31:56.123")
-      Time.stub(:now => time)
-      logger.add(Lumberjack::Severity::INFO, "test", "app")
-      output.string.should == "[2011-01-30T12:31:56.123 INFO app(#{$$}) #] test#{n}"
-    end
-
-    it "should add entries with a local progname and message" do
-      time = Time.parse("2011-01-30T12:31:56.123")
-      Time.stub(:now => time)
-      logger.set_progname("block") do
-        logger.add(Lumberjack::Severity::INFO, "test")
-      end
-      output.string.should == "[2011-01-30T12:31:56.123 INFO block(#{$$}) #] test#{n}"
-    end
-
-    it "should add entries with a progname but no message or block" do
-      time = Time.parse("2011-01-30T12:31:56.123")
-      Time.stub(:now => time)
-      logger.set_progname("default") do
-        logger.add(Lumberjack::Severity::INFO, nil, "message")
-      end
-      output.string.should == "[2011-01-30T12:31:56.123 INFO default(#{$$}) #] message#{n}"
-    end
-
-    it "should add entries with a block" do
-      time = Time.parse("2011-01-30T12:31:56.123")
-      Time.stub(:now => time)
-      logger.add(Lumberjack::Severity::INFO){"test"}
-      output.string.should == "[2011-01-30T12:31:56.123 INFO test(#{$$}) #] test#{n}"
-    end
-
-    it "should log entries (::Logger compatibility)" do
-      time = Time.parse("2011-01-30T12:31:56.123")
-      Time.stub(:now => time)
-      logger.log(Lumberjack::Severity::INFO, "test")
-      output.string.should == "[2011-01-30T12:31:56.123 INFO test(#{$$}) #] test#{n}"
-    end
-
-    it "should append messages with unknown severity to the log" do
-      time = Time.parse("2011-01-30T12:31:56.123")
-      Time.stub(:now => time)
-      logger << "test"
-      output.string.should == "[2011-01-30T12:31:56.123 UNKNOWN test(#{$$}) #] test#{n}"
-    end
-
-    it "should ouput entries to STDERR if they can't be written the the device" do
-      stderr = $stderr
-      $stderr = StringIO.new
-      begin
-        time = Time.parse("2011-01-30T12:31:56.123")
-        Time.stub(:now => time)
-        device.should_receive(:write).and_raise(StandardError.new("Cannot write to device"))
-        logger.add(Lumberjack::Severity::INFO, "test")
-        $stderr.string.should include("[2011-01-30T12:31:56.123 INFO test(#{$$})] test")
-        $stderr.string.should include("StandardError: Cannot write to device")
-      ensure
-        $stderr = stderr
-      end
-    end
-
-    context "log helper methods" do
-      let(:device){ Lumberjack::Device::Writer.new(output, :buffer_size => 0, :template => ":message") }
-
-      it "should only add messages whose severity is greater or equal to the logger level" do
-        logger.add(Lumberjack::Severity::DEBUG, "debug")
-        logger.add(Lumberjack::Severity::INFO, "info")
-        logger.add(Lumberjack::Severity::ERROR, "error")
-        output.string.should == "info#{n}error#{n}"
-      end
-
-      it "should only log fatal messages when the level is set to fatal" do
-        logger.level = Lumberjack::Severity::FATAL
-        logger.fatal("fatal")
-        logger.fatal?.should == true
-        logger.error("error")
-        logger.error?.should == false
-        logger.warn("warn")
-        logger.warn?.should == false
-        logger.info("info")
-        logger.info?.should == false
-        logger.debug("debug")
-        logger.debug?.should == false
-        logger.unknown("unknown")
-        output.string.should == "fatal#{n}unknown#{n}"
-      end
-
-      it "should only log error messages and higher when the level is set to error" do
-        logger.level = Lumberjack::Severity::ERROR
-        logger.fatal("fatal")
-        logger.fatal?.should == true
-        logger.error("error")
-        logger.error?.should == true
-        logger.warn("warn")
-        logger.warn?.should == false
-        logger.info("info")
-        logger.info?.should == false
-        logger.debug("debug")
-        logger.debug?.should == false
-        logger.unknown("unknown")
-        output.string.should == "fatal#{n}error#{n}unknown#{n}"
-      end
-
-      it "should only log warn messages and higher when the level is set to warn" do
-        logger.level = Lumberjack::Severity::WARN
-        logger.fatal("fatal")
-        logger.fatal?.should == true
-        logger.error("error")
-        logger.error?.should == true
-        logger.warn("warn")
-        logger.warn?.should == true
-        logger.info("info")
-        logger.info?.should == false
-        logger.debug("debug")
-        logger.debug?.should == false
-        logger.unknown("unknown")
-        output.string.should == "fatal#{n}error#{n}warn#{n}unknown#{n}"
-      end
-
-      it "should only log info messages and higher when the level is set to info" do
-        logger.level = Lumberjack::Severity::INFO
-        logger.fatal("fatal")
-        logger.fatal?.should == true
-        logger.error("error")
-        logger.error?.should == true
-        logger.warn("warn")
-        logger.warn?.should == true
-        logger.info("info")
-        logger.info?.should == true
-        logger.debug("debug")
-        logger.debug?.should == false
-        logger.unknown("unknown")
-        output.string.should == "fatal#{n}error#{n}warn#{n}info#{n}unknown#{n}"
-      end
-
-      it "should log all messages when the level is set to debug" do
-        logger.level = Lumberjack::Severity::DEBUG
-        logger.fatal("fatal")
-        logger.fatal?.should == true
-        logger.error("error")
-        logger.error?.should == true
-        logger.warn("warn")
-        logger.warn?.should == true
-        logger.info("info")
-        logger.info?.should == true
-        logger.debug("debug")
-        logger.debug?.should == true
-        logger.unknown("unknown")
-        output.string.should == "fatal#{n}error#{n}warn#{n}info#{n}debug#{n}unknown#{n}"
-      end
-
-      it "should only log unkown messages when the level is set above fatal" do
-        logger.level = Lumberjack::Severity::FATAL + 1
-        logger.fatal("fatal")
-        logger.fatal?.should == false
-        logger.error("error")
-        logger.error?.should == false
-        logger.warn("warn")
-        logger.warn?.should == false
-        logger.info("info")
-        logger.info?.should == false
-        logger.debug("debug")
-        logger.debug?.should == false
-        logger.unknown("unknown")
-        output.string.should == "unknown#{n}"
-      end
-    end
-  end
-
-end