lumberjack 1.0.4 → 1.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d18e80866556c7f4fb366d5b3877e18471c5a13b
+  data.tar.gz: eabc812fc6145223e566b85d4197a431e6127a18
+SHA512:
+  metadata.gz: 35e888599a3613e410685282574d3f02be1ede309d51633095a8a73bd2a48a00b0d19d2c6c9f7bc14f4a90e603d0f011f64e7fd9c05760ad4498c25ca134a775
+  data.tar.gz: 5a0814c7a3b66427fa24e5a4f0d957f4bd259bc0cc252c84db8a5462929096bde2d4ff7e3267042754c7c51b44477f62244aac281584699e2a0ab4a46c66c0cb

data/README.rdoc

@@ -98,3 +98,35 @@ The built in stream based logging devices use an internal buffer. The size of th
 The built in devices include two that can automatically roll log files based either on date or on file size. When a log file is rolled, it will be renamed with a suffix and a new file will be created to receive new log entries. This can keep your log files from growing to unusable sizes and removes the need to schedule an external process to roll the files.
 
 There is a similar feature in the standard library Logger class, but the implementation here is safe to use with multiple processes writing to the same log file.
+
+== Examples
+
+These example are for Rails applications, but there is no dependency on Rails for using this gem. Most of the examples are applicable to any Ruby application.
+
+In a Rails application you can replace the default production logger by adding this to your config/environments/production.rb file:
+
+  # Add the unit of work id to each request
+  config.middleware.insert(0, Lumberjack::Rack::UnitOfWork)
+  # Change the logger to use Lumberjack
+  log_file_path = Rails.root + "log" + "#{Rails.env}.log"
+  config.logger = Lumberjack::Logger.new(log_file, :level => :warn)
+
+To set up a logger to roll every day at midnight, you could use this code (you can also specify :weekly or :monthly):
+
+  config.logger = Lumberjack::Logger.new(log_file_path, :roll => :daily)
+
+To set up a logger to roll log files when they get to 100Mb, you could use this:
+
+  config.logger = Lumberjack::Logger.new(log_file_path, :max_size => 100.megabytes)
+  
+To change the log message format, you could use this code:
+
+  config.logger = Lumberjack::Logger.new(log_file_path, :template => ":time - :message")
+
+To change the log message format to output JSON, you could use this code (this example requires the multi-json gem):
+  
+  config.logger = Lumberjack::Logger.new(log_file_path, :template => lambda{|e| MultiJson.dump(e)})
+
+To send log messages to syslog instead of to a file, you could use this (require the lumberjack_syslog_device gem):
+
+  config.logger = Lumberjack::Logger.new(Lumberjack::SyslogDevice.new)

data/VERSION

@@ -1 +1 @@
-1.0.4
+1.0.5

data/lib/lumberjack/device.rb

@@ -2,12 +2,12 @@ module Lumberjack
   # This is an abstract class for logging devices. Subclasses must implement the +write+ method and
   # may implement the +close+ and +flush+ methods if applicable.
   class Device
-    autoload :DateRollingLogFile, File.expand_path("../device/date_rolling_log_file.rb", __FILE__)
-    autoload :LogFile, File.expand_path("../device/log_file.rb", __FILE__)
-    autoload :Null, File.expand_path("../device/null.rb", __FILE__)
-    autoload :RollingLogFile, File.expand_path("../device/rolling_log_file.rb", __FILE__)
-    autoload :SizeRollingLogFile, File.expand_path("../device/size_rolling_log_file.rb", __FILE__)
-    autoload :Writer, File.expand_path("../device/writer.rb", __FILE__)
+    load File.expand_path("../device/writer.rb", __FILE__)
+    load File.expand_path("../device/log_file.rb", __FILE__)
+    load File.expand_path("../device/rolling_log_file.rb", __FILE__)
+    load File.expand_path("../device/date_rolling_log_file.rb", __FILE__)
+    load File.expand_path("../device/size_rolling_log_file.rb", __FILE__)
+    load File.expand_path("../device/null.rb", __FILE__)
 
     # Subclasses must implement this method to write a LogEntry.
     def write(entry)

data/lib/lumberjack/formatter.rb

@@ -8,10 +8,10 @@ module Lumberjack
   # By default, all object will be converted to strings using their inspect method except for Strings
   # and Exceptions. Strings are not converted and Exceptions are converted using the ExceptionFormatter.
   class Formatter
-    autoload :ExceptionFormatter, File.expand_path("../formatter/exception_formatter.rb", __FILE__)
-    autoload :InspectFormatter, File.expand_path("../formatter/inspect_formatter.rb", __FILE__)
-    autoload :PrettyPrintFormatter, File.expand_path("../formatter/pretty_print_formatter.rb", __FILE__)
-    autoload :StringFormatter, File.expand_path("../formatter/string_formatter.rb", __FILE__)
+    load File.expand_path("../formatter/exception_formatter.rb", __FILE__)
+    load File.expand_path("../formatter/inspect_formatter.rb", __FILE__)
+    load File.expand_path("../formatter/pretty_print_formatter.rb", __FILE__)
+    load File.expand_path("../formatter/string_formatter.rb", __FILE__)
     
     def initialize
       @class_formatters = {}

data/lib/lumberjack/logger.rb

@@ -24,22 +24,22 @@ module Lumberjack
   # using a Formatter associated with the logger.
   class Logger
     include Severity
-    
+
     # The Formatter object used to convert messages into strings.
     attr_reader :formatter
-    
+
     # The time that the device was last flushed.
     attr_reader :last_flushed_at
-    
+
     # The name of the program associated with log messages.
     attr_writer :progname
-    
+
     # The device being written to.
     attr_reader :device
-    
+
     # Set +silencer+ to false to disable silencing the log.
     attr_accessor :silencer
-    
+
     # Create a new logger to log to a Device.
     #
     # The +device+ argument can be in any one of several formats.
@@ -60,27 +60,27 @@ module Lumberjack
     # All other options are passed to the device constuctor.
     def initialize(device = STDOUT, options = {})
       @thread_settings = {}
-      
+
       options = options.dup
       self.level = options.delete(:level) || INFO
       self.progname = options.delete(:progname)
       max_flush_seconds = options.delete(:flush_seconds).to_f
-      
+
       @device = open_device(device, options)
       @formatter = Formatter.new
       @lock = Mutex.new
       @last_flushed_at = Time.now
       @silencer = true
-      
+
       create_flusher_thread(max_flush_seconds) if max_flush_seconds > 0
     end
-    
+
     # Get the level of severity of entries that are logged. Entries with a lower
     # severity level will be ignored.
     def level
       thread_local_value(:lumberjack_logger_level) || @level
     end
-    
+
     # Add a message to the log with a given severity. The message can be either
     # passed in the +message+ argument or supplied with a block. This method
     # is not normally called. Instead call one of the helper functions
@@ -97,94 +97,105 @@ module Lumberjack
     #   logger.add(Lumberjack::Severity::DEBUG){"Start processing with options #{options.inspect}"}
     def add(severity, message = nil, progname = nil)
       severity = Severity.label_to_level(severity) if severity.is_a?(String) || severity.is_a?(Symbol)
-      if severity && severity >= level
-        time = Time.now
-        message = yield if message.nil? && block_given?
-        message = @formatter.format(message)
-        entry = LogEntry.new(time, severity, message, progname || self.progname, $$, Lumberjack.unit_of_work_id)
-        begin
-          device.write(entry)
-        rescue => e
-          $stderr.puts("#{e.class.name}: #{e.message}#{' at ' + e.backtrace.first if e.backtrace}")
-          $stderr.puts(entry.to_s)
+
+      return unless severity && severity >= level
+
+      time = Time.now
+      if message.nil?
+        if block_given?
+          message = yield
+        else
+          message = progname
+          progname = nil
         end
       end
+
+      message = @formatter.format(message)
+      progname ||= self.progname
+      entry = LogEntry.new(time, severity, message, progname, $$, Lumberjack.unit_of_work_id)
+      begin
+        device.write(entry)
+      rescue => e
+        $stderr.puts("#{e.class.name}: #{e.message}#{' at ' + e.backtrace.first if e.backtrace}")
+        $stderr.puts(entry.to_s)
+      end
+
       nil
     end
-    
+
     alias_method :log, :add
-    
+
     # Flush the logging device. Messages are not guaranteed to be written until this method is called.
     def flush
       device.flush
       @last_flushed_at = Time.now
       nil
     end
-    
+
     # Close the logging device.
     def close
       flush
       @device.close if @device.respond_to?(:close)
     end
-    
+
     # Log a +FATAL+ message. The message can be passed in either the +message+ argument or in a block.
     def fatal(message = nil, progname = nil, &block)
       add(FATAL, message, progname, &block)
     end
-    
+
     # Return +true+ if +FATAL+ messages are being logged.
     def fatal?
       level <= FATAL
     end
-    
+
     # Log an +ERROR+ message. The message can be passed in either the +message+ argument or in a block.
     def error(message = nil, progname = nil, &block)
       add(ERROR, message, progname, &block)
     end
-    
+
     # Return +true+ if +ERROR+ messages are being logged.
     def error?
       level <= ERROR
     end
-    
+
     # Log a +WARN+ message. The message can be passed in either the +message+ argument or in a block.
     def warn(message = nil, progname = nil, &block)
       add(WARN, message, progname, &block)
     end
-    
+
     # Return +true+ if +WARN+ messages are being logged.
     def warn?
       level <= WARN
     end
-    
+
     # Log an +INFO+ message. The message can be passed in either the +message+ argument or in a block.
     def info(message = nil, progname = nil, &block)
       add(INFO, message, progname, &block)
     end
-    
+
     # Return +true+ if +INFO+ messages are being logged.
     def info?
       level <= INFO
     end
-    
+
     # Log a +DEBUG+ message. The message can be passed in either the +message+ argument or in a block.
     def debug(message = nil, progname = nil, &block)
       add(DEBUG, message, progname, &block)
     end
-    
+
     # Return +true+ if +DEBUG+ messages are being logged.
     def debug?
       level <= DEBUG
     end
-    
+
     # Log a message when the severity is not known. Unknown messages will always appear in the log.
     # The message can be passed in either the +message+ argument or in a block.
     def unknown(message = nil, progname = nil, &block)
       add(UNKNOWN, message, progname, &block)
     end
-    
+
     alias_method :<<, :unknown
-    
+
     # Set the minimum level of severity of messages to log.
     def level=(severity)
       if severity.is_a?(Fixnum)
@@ -193,7 +204,7 @@ module Lumberjack
         @level = Severity.label_to_level(severity)
       end
     end
-    
+
     # Silence the logger by setting a new log level inside a block. By default, only +ERROR+ or +FATAL+
     # messages will be logged.
     #
@@ -210,7 +221,7 @@ module Lumberjack
         yield
       end
     end
-    
+
     # Set the program name that is associated with log messages. If a block
     # is given, the program name will be valid only within the block.
     def set_progname(value, &block)
@@ -220,14 +231,14 @@ module Lumberjack
         self.progname = value
       end
     end
-    
+
     # Get the program name associated with log messages.
     def progname
       thread_local_value(:lumberjack_logger_progname) || @progname
     end
-        
+
     private
-    
+
     # Set a local value for a thread tied to this object.
     def set_thread_local_value(name, value) #:nodoc:
       values = Thread.current[name]
@@ -242,13 +253,13 @@ module Lumberjack
         values[self] = value
       end
     end
-    
+
     # Get a local value for a thread tied to this object.
     def thread_local_value(name) #:nodoc:
       values = Thread.current[name]
       values[self] if values
     end
-    
+
     # Set a local value for a thread tied to this object within a block.
     def push_thread_local_value(name, value) #:nodoc:
       save_val = thread_local_value(name)
@@ -259,12 +270,12 @@ module Lumberjack
         set_thread_local_value(name, save_val)
       end
     end
-    
+
     # Open a logging device.
     def open_device(device, options) #:nodoc:
       if device.is_a?(Device)
         device
-      elsif device.respond_to?(:write)
+      elsif device.respond_to?(:write) && device.respond_to?(:flush)
         Device::Writer.new(device, options)
       elsif device == :null
         Device::Null.new
@@ -279,7 +290,7 @@ module Lumberjack
         end
       end
     end
-    
+
     # Create a thread that will periodically call flush.
     def create_flusher_thread(flush_seconds) #:nodoc:
       if flush_seconds > 0

data/lib/lumberjack.rb

@@ -3,16 +3,17 @@ require 'time'
 require 'thread'
 
 module Lumberjack
-  autoload :Device, File.expand_path("../lumberjack/device.rb", __FILE__)
-  autoload :Formatter, File.expand_path("../lumberjack/formatter.rb", __FILE__)
-  autoload :LogEntry, File.expand_path("../lumberjack/log_entry.rb", __FILE__)
-  autoload :Logger, File.expand_path("../lumberjack/logger.rb", __FILE__)
-  autoload :Rack, File.expand_path("../lumberjack/rack.rb", __FILE__)
-  autoload :Severity, File.expand_path("../lumberjack/severity.rb", __FILE__)
-  autoload :Template, File.expand_path("../lumberjack/template.rb", __FILE__)
-  
   LINE_SEPARATOR = (RbConfig::CONFIG['host_os'].match(/mswin/i) ? "\r\n" : "\n")
 
+  load File.expand_path("../lumberjack/severity.rb", __FILE__)
+  load File.expand_path("../lumberjack/log_entry.rb", __FILE__)
+  load File.expand_path("../lumberjack/formatter.rb", __FILE__)
+  load File.expand_path("../lumberjack/device.rb", __FILE__)
+  load File.expand_path("../lumberjack/logger.rb", __FILE__)
+  load File.expand_path("../lumberjack/template.rb", __FILE__)
+
+  autoload :Rack, File.expand_path("../lumberjack/rack.rb", __FILE__)
+  
   class << self
     # Define a unit of work within a block. Within the block supplied to this
     # method, calling +unit_of_work_id+ will return the same value that can

data/spec/device/date_rolling_log_file_spec.rb

@@ -20,8 +20,8 @@ describe Lumberjack::Device::DateRollingLogFile do
     logger = Lumberjack::Logger.new(device, :buffer_size => 2)
     logger.error("test day one")
     logger.flush
-    Time.stub!(:now).and_return(now + one_day)
-    Date.stub!(:today).and_return(today + 1)
+    Time.stub(:now => now + one_day)
+    Date.stub(:today => today + 1)
     logger.error("test day two")
     logger.close
     
@@ -37,8 +37,8 @@ describe Lumberjack::Device::DateRollingLogFile do
     logger = Lumberjack::Logger.new(device, :buffer_size => 2)
     logger.error("test week one")
     logger.flush
-    Time.stub!(:now).and_return(now + (7 * one_day))
-    Date.stub!(:today).and_return(today + 7)
+    Time.stub(:now => now + (7 * one_day))
+    Date.stub(:today => today + 7)
     logger.error("test week two")
     logger.close
     
@@ -54,8 +54,8 @@ describe Lumberjack::Device::DateRollingLogFile do
     logger = Lumberjack::Logger.new(device, :buffer_size => 2)
     logger.error("test month one")
     logger.flush
-    Time.stub!(:now).and_return(now + (31 * one_day))
-    Date.stub!(:today).and_return(today + 31)
+    Time.stub(:now => now + (31 * one_day))
+    Date.stub(:today => today + 31)
     logger.error("test month two")
     logger.close
     

data/spec/device/rolling_log_file_spec.rb

@@ -26,7 +26,7 @@ describe Lumberjack::Device::RollingLogFile do
     device = Lumberjack::Device::RollingLogFile.new(log_file, :template => ":message", :buffer_size => 32767)
     device.should_receive(:roll_file?).and_return(false, true)
     device.should_receive(:after_roll)
-    device.stub!(:archive_file_suffix).and_return("rolled")
+    device.stub(:archive_file_suffix => "rolled")
     device.write(entry)
     device.flush
     device.write(Lumberjack::LogEntry.new(Time.now, 1, "Another log entry", nil, $$, nil))
@@ -38,7 +38,7 @@ describe Lumberjack::Device::RollingLogFile do
   it "should reopen the file if the stream inode doesn't match the file path inode" do
     log_file = File.join(tmp_dir, "test_3.log")
     device = Lumberjack::Device::RollingLogFile.new(log_file, :template => ":message")
-    device.stub!(:roll_file?).and_return(false)
+    device.stub(:roll_file? => false)
     device.write(entry)
     device.flush
     File.rename(log_file, "#{log_file}.rolled")
@@ -109,12 +109,11 @@ describe Lumberjack::Device::RollingLogFile do
     log_file = File.join(tmp_dir, "test_5.log")
     device = Lumberjack::Device::RollingLogFile.new(log_file, :template => ":message", :keep => 2, :buffer_size => 32767)
     device.should_receive(:roll_file?).and_return(false, true, true, true)
-    device.stub!(:archive_file_suffix).and_return("delete", "another", "keep")
+    device.should_receive(:archive_file_suffix).and_return("delete", "another", "keep")
     t = Time.now
-    File.should_receive(:ctime).with(log_file).any_number_of_times.and_return(t)
-    File.should_receive(:ctime).with("#{log_file}.delete").any_number_of_times.and_return(t + 1)
-    File.should_receive(:ctime).with("#{log_file}.another").any_number_of_times.and_return(t + 2)
-    File.should_receive(:ctime).with("#{log_file}.keep").any_number_of_times.and_return(t + 3)
+    File.should_receive(:ctime).with("#{log_file}.delete").at_least(1).times.and_return(t + 1)
+    File.should_receive(:ctime).with("#{log_file}.another").at_least(1).times.and_return(t + 2)
+    File.should_receive(:ctime).with("#{log_file}.keep").at_least(1).times.and_return(t + 3)
     device.write(entry)
     device.flush
     device.write(entry)

data/spec/logger_spec.rb

@@ -17,56 +17,56 @@ describe Lumberjack::Logger do
       logger = Lumberjack::Logger.new(output)
       logger.device.class.should == Lumberjack::Device::Writer
     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 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")
@@ -79,7 +79,7 @@ describe Lumberjack::Logger do
       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")
@@ -93,7 +93,7 @@ describe Lumberjack::Logger do
       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")
@@ -107,7 +107,7 @@ describe Lumberjack::Logger do
       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")
@@ -120,7 +120,7 @@ describe Lumberjack::Logger do
       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")
@@ -144,7 +144,7 @@ describe Lumberjack::Logger do
         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")
@@ -169,7 +169,7 @@ describe Lumberjack::Logger do
       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
@@ -184,7 +184,7 @@ describe Lumberjack::Logger do
       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)
@@ -195,7 +195,7 @@ describe Lumberjack::Logger do
       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)
@@ -206,7 +206,7 @@ describe Lumberjack::Logger do
       output.should be_closed
     end
   end
-  
+
   context "logging" do
     let(:output){ StringIO.new }
     let(:device){ Lumberjack::Device::Writer.new(output, :buffer_size => 0) }
@@ -215,61 +215,70 @@ describe Lumberjack::Logger do
 
     it "should add entries with a numeric severity and a message" do
       time = Time.parse("2011-01-30T12:31:56.123")
-      Time.stub!(:now).and_return(time)
+      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).and_return(time)
+      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).and_return(time)
+      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).and_return(time)
+      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).and_return(time)
+      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).and_return(time)
+      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).and_return(time)
+      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).and_return(time)
+        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")
@@ -278,17 +287,17 @@ describe Lumberjack::Logger do
         $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")
@@ -304,7 +313,7 @@ describe Lumberjack::Logger do
         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")
@@ -320,7 +329,7 @@ describe Lumberjack::Logger do
         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")
@@ -336,7 +345,7 @@ describe Lumberjack::Logger do
         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")
@@ -352,7 +361,7 @@ describe Lumberjack::Logger do
         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")
@@ -368,7 +377,7 @@ describe Lumberjack::Logger do
         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")

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lumberjack
 version: !ruby/object:Gem::Version
-  version: 1.0.4
-  prerelease: 
+  version: 1.0.5
 platform: ruby
 authors:
 - Brian Durand
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-26 00:00:00.000000000 Z
+date: 2014-03-20 00:00:00.000000000 Z
 dependencies: []
 description: A simple, powerful, and very fast logging utility that can be a drop
   in replacement for Logger or ActiveSupport::BufferedLogger. Provides support for
@@ -22,29 +21,29 @@ extensions: []
 extra_rdoc_files:
 - README.rdoc
 files:
+- MIT_LICENSE
 - README.rdoc
-- VERSION
 - Rakefile
-- MIT_LICENSE
+- VERSION
+- lib/lumberjack.rb
+- lib/lumberjack/device.rb
 - lib/lumberjack/device/date_rolling_log_file.rb
 - lib/lumberjack/device/log_file.rb
 - lib/lumberjack/device/null.rb
 - lib/lumberjack/device/rolling_log_file.rb
 - lib/lumberjack/device/size_rolling_log_file.rb
 - lib/lumberjack/device/writer.rb
-- lib/lumberjack/device.rb
+- lib/lumberjack/formatter.rb
 - lib/lumberjack/formatter/exception_formatter.rb
 - lib/lumberjack/formatter/inspect_formatter.rb
 - lib/lumberjack/formatter/pretty_print_formatter.rb
 - lib/lumberjack/formatter/string_formatter.rb
-- lib/lumberjack/formatter.rb
 - lib/lumberjack/log_entry.rb
 - lib/lumberjack/logger.rb
-- lib/lumberjack/rack/unit_of_work.rb
 - lib/lumberjack/rack.rb
+- lib/lumberjack/rack/unit_of_work.rb
 - lib/lumberjack/severity.rb
 - lib/lumberjack/template.rb
-- lib/lumberjack.rb
 - spec/device/date_rolling_log_file_spec.rb
 - spec/device/log_file_spec.rb
 - spec/device/null_spec.rb
@@ -64,31 +63,31 @@ files:
 - spec/spec_helper.rb
 - spec/template_spec.rb
 homepage: http://github.com/bdurand/lumberjack
-licenses: []
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options:
-- --charset=UTF-8
-- --main
+- "--charset=UTF-8"
+- "--main"
 - README.rdoc
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A simple, powerful, and very fast logging utility that can be a drop in replacement
   for Logger or ActiveSupport::BufferedLogger.
 test_files: []