lumberjack_aziz_light 1.0.5

data/lib/lumberjack/rack/unit_of_work.rb

@@ -0,0 +1,15 @@
+module Lumberjack
+  module Rack
+    class UnitOfWork
+      def initialize(app)
+        @app = app
+      end
+      
+      def call(env)
+        Lumberjack.unit_of_work do
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/lumberjack/rack.rb

@@ -0,0 +1,5 @@
+module Lumberjack
+  module Rack
+    autoload :UnitOfWork, File.expand_path("../rack/unit_of_work.rb", __FILE__)
+  end
+end

data/lib/lumberjack/severity.rb

@@ -0,0 +1,23 @@
+module Lumberjack
+  # The standard severity levels for logging messages.
+  module Severity
+    UNKNOWN = 5
+    FATAL = 4
+    ERROR = 3
+    WARN = 2
+    INFO = 1
+    DEBUG = 0
+    
+    SEVERITY_LABELS = %w(DEBUG INFO WARN ERROR FATAL UNKNOWN).freeze
+    
+    class << self
+      def level_to_label(severity)
+        SEVERITY_LABELS[severity] || SEVERITY_LABELS.last
+      end
+    
+      def label_to_level(label)
+        SEVERITY_LABELS.index(label.to_s.upcase) || UNKNOWN
+      end
+    end
+  end
+end

data/lib/lumberjack/template.rb

@@ -0,0 +1,71 @@
+module Lumberjack
+  # A template converts entries to strings. Templates can contain the following place holders to
+  # reference log entry values:
+  #
+  # * <tt>:time</tt>
+  # * <tt>:severity</tt>
+  # * <tt>:progname</tt>
+  # * <tt>:unit_of_work_id</tt>
+  # * <tt>:message</tt>
+  class Template
+    TEMPLATE_ARGUMENT_ORDER = %w(:time :severity :progname :pid :unit_of_work_id :message).freeze
+    DEFAULT_TIME_FORMAT = "%Y-%m-%dT%H:%M:%S."
+    MILLISECOND_FORMAT = "%03d"
+    MICROSECOND_FORMAT = "%06d"
+    
+    # Create a new template from the markup. The +first_line+ argument is used to format only the first
+    # line of a message. Additional lines will be added to the message unformatted. If you wish to format
+    # the additional lines, use the <tt>:additional_lines</tt> options to specify a template. Note that you'll need
+    # to provide the line separator character in this template if you want to keep the message on multiple lines.
+    #
+    # The time will be formatted as YYYY-MM-DDTHH:MM:SSS.SSS by default. If you wish to change the format, you
+    # can specify the <tt>:time_format</tt> option which can be either a time format template as documented in
+    # +Time#strftime+ or the values +:milliseconds+ or +:microseconds+ to use the standard format with the
+    # specified precision.
+    #
+    # Messages will have white space stripped from both ends.
+    def initialize(first_line, options = {})
+      @first_line_template = compile(first_line)
+      additional_lines = options[:additional_lines] || "#{Lumberjack::LINE_SEPARATOR}:message"
+      @additional_line_template = compile(additional_lines)
+      # Formatting the time is relatively expensive, so only do it if it will be used
+      @template_include_time = first_line.include?(":time") || additional_lines.include?(":time")
+      @time_format = options[:time_format] || :milliseconds
+    end
+    
+    # Convert an entry into a string using the template.
+    def call(entry)
+      lines = entry.message.strip.split(Lumberjack::LINE_SEPARATOR)
+      formatted_time = format_time(entry.time) if @template_include_time
+      message = @first_line_template % [formatted_time, entry.severity_label, entry.progname, entry.pid, entry.unit_of_work_id, lines.shift]
+      lines.each do |line|
+        message << @additional_line_template % [formatted_time, entry.severity_label, entry.progname, entry.pid, entry.unit_of_work_id, line]
+      end
+      message
+    end
+    
+    private
+
+    def format_time(time) #:nodoc:
+      if @time_format.is_a?(String)
+        time.strftime(@time_format)
+      elsif @time_format == :milliseconds
+        time.strftime(DEFAULT_TIME_FORMAT) << MILLISECOND_FORMAT % (time.usec / 1000.0).round
+      else
+        time.strftime(DEFAULT_TIME_FORMAT) << MICROSECOND_FORMAT % time.usec
+      end
+    end
+    
+    # Compile the template string into a value that can be used with sprintf.
+    def compile(template) #:nodoc:
+      template.gsub(/:[a-z0-9_]+/) do |match|
+        position = TEMPLATE_ARGUMENT_ORDER.index(match)
+        if position
+          "%#{position + 1}$s"
+        else
+          match
+        end
+      end
+    end
+  end
+end

data/lib/lumberjack.rb

@@ -0,0 +1,42 @@
+require 'rbconfig'
+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")
+
+  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
+    # This can then be used for tying together log entries.
+    #
+    # You can specify the id for the unit of work if desired. If you don't supply
+    # it, a 12 digit hexidecimal number will be automatically generated for you.
+    #
+    # For the common use case of treating a single web request as a unit of work, see the
+    # Lumberjack::Rack::UnitOfWork class.
+    def unit_of_work(id = nil)
+      save_val = Thread.current[:lumberjack_logger_unit_of_work_id]
+      id ||= rand(0xFFFFFFFFFFFF).to_s(16).rjust(12, '0').upcase
+      Thread.current[:lumberjack_logger_unit_of_work_id] = id
+      begin
+        return yield
+      ensure
+        Thread.current[:lumberjack_logger_unit_of_work_id] = save_val
+      end
+    end
+    
+    # Get the UniqueIdentifier for the current unit of work.
+    def unit_of_work_id
+      Thread.current[:lumberjack_logger_unit_of_work_id] 
+    end
+  end
+end

data/spec/device/date_rolling_log_file_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Lumberjack::Device::DateRollingLogFile do
+
+  before :all do
+    create_tmp_dir
+  end
+  
+  after :all do
+    delete_tmp_dir
+  end
+  
+  let(:one_day){ 60 * 60 * 24 }
+  
+  it "should roll the file daily" do
+    today = Date.today
+    now = Time.now
+    log_file = File.join(tmp_dir, "a#{rand(1000000000)}.log")
+    device = Lumberjack::Device::DateRollingLogFile.new(log_file, :roll => :daily, :template => ":message")
+    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)
+    logger.error("test day two")
+    logger.close
+    
+    File.read("#{log_file}.#{today.strftime('%Y-%m-%d')}").should == "test day one#{Lumberjack::LINE_SEPARATOR}"
+    File.read(log_file).should == "test day two#{Lumberjack::LINE_SEPARATOR}"
+  end
+
+  it "should roll the file weekly" do
+    today = Date.today
+    now = Time.now
+    log_file = File.join(tmp_dir, "b#{rand(1000000000)}.log")
+    device = Lumberjack::Device::DateRollingLogFile.new(log_file, :roll => :weekly, :template => ":message")
+    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)
+    logger.error("test week two")
+    logger.close
+    
+    File.read("#{log_file}.#{today.strftime('week-of-%Y-%m-%d')}").should == "test week one#{Lumberjack::LINE_SEPARATOR}"
+    File.read(log_file).should == "test week two#{Lumberjack::LINE_SEPARATOR}"
+  end
+
+  it "should roll the file monthly" do
+    today = Date.today
+    now = Time.now
+    log_file = File.join(tmp_dir, "c#{rand(1000000000)}.log")
+    device = Lumberjack::Device::DateRollingLogFile.new(log_file, :roll => :monthly, :template => ":message")
+    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)
+    logger.error("test month two")
+    logger.close
+    
+    File.read("#{log_file}.#{today.strftime('%Y-%m')}").should == "test month one#{Lumberjack::LINE_SEPARATOR}"
+    File.read(log_file).should == "test month two#{Lumberjack::LINE_SEPARATOR}"
+  end
+
+end

data/spec/device/log_file_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Lumberjack::Device::LogFile do
+
+  before :all do
+    create_tmp_dir
+  end
+  
+  after :all do
+    delete_tmp_dir
+  end
+  
+  it "should append to a file" do
+    log_file = File.join(tmp_dir, "a#{rand(1000000000)}.log")
+    File.open(log_file, 'w') do |f|
+      f.puts("Existing contents")
+    end
+    
+    device = Lumberjack::Device::LogFile.new(log_file, :template => ":message")
+    device.write(Lumberjack::LogEntry.new(Time.now, 1, "New log entry", nil, $$, nil))
+    device.close
+    
+    File.read(log_file).should == "Existing contents\nNew log entry#{Lumberjack::LINE_SEPARATOR}"
+  end
+
+end

data/spec/device/null_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Lumberjack::Device::Null do
+
+  it "should not generate any output" do
+    device = Lumberjack::Device::Null.new
+    device.write(Lumberjack::LogEntry.new(Time.now, 1, "New log entry", nil, $$, nil))
+    device.flush
+    device.close
+  end
+
+end

data/spec/device/rolling_log_file_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+describe Lumberjack::Device::RollingLogFile do
+
+  before :all do
+    Lumberjack::Device::SizeRollingLogFile #needed by jruby
+    create_tmp_dir
+  end
+  
+  after :all do
+    delete_tmp_dir
+  end
+  
+  let(:entry){ Lumberjack::LogEntry.new(Time.now, 1, "New log entry", nil, $$, nil) }
+
+  it "should check for rolling the log file on flush" do
+    device = Lumberjack::Device::RollingLogFile.new(File.join(tmp_dir, "test.log"), :buffer_size => 32767)
+    device.write(entry)
+    device.should_receive(:roll_file?).twice.and_return(false)
+    device.flush
+    device.close
+  end
+  
+  it "should roll the file by archiving the existing file and opening a new stream and calling after_roll" do
+    log_file = File.join(tmp_dir, "test_2.log")
+    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.write(entry)
+    device.flush
+    device.write(Lumberjack::LogEntry.new(Time.now, 1, "Another log entry", nil, $$, nil))
+    device.close
+    File.read("#{log_file}.rolled").should == "New log entry#{Lumberjack::LINE_SEPARATOR}"
+    File.read(log_file).should == "Another log entry#{Lumberjack::LINE_SEPARATOR}"
+  end
+  
+  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.write(entry)
+    device.flush
+    File.rename(log_file, "#{log_file}.rolled")
+    device.flush
+    device.write(Lumberjack::LogEntry.new(Time.now, 1, "Another log entry", nil, $$, nil))
+    device.close
+    File.read("#{log_file}.rolled").should == "New log entry#{Lumberjack::LINE_SEPARATOR}"
+    File.read(log_file).should == "Another log entry#{Lumberjack::LINE_SEPARATOR}"
+  end
+  
+  it "should roll the file properly with multiple thread and processes using it" do
+    log_file = File.join(tmp_dir, "test_4.log")
+    process_count = 8
+    thread_count = 4
+    entry_count = 400
+    max_size = 128
+    severity = Lumberjack::Severity::INFO
+    message = "This is a test message that is written to the log file to indicate what the state of the application is."
+    
+    logger_test = lambda do
+      device = Lumberjack::Device::SizeRollingLogFile.new(log_file, :max_size => max_size, :template => ":message", :buffer_size => 32767)
+      threads = []
+      thread_count.times do
+        threads << Thread.new do
+          entry_count.times do |i|
+            device.write(Lumberjack::LogEntry.new(Time.now, severity, message, "test", $$, nil))
+            device.flush if i % 10 == 0
+          end
+        end
+      end
+      threads.each{|thread| thread.join}
+      device.close
+    end
+    
+    # Process.fork is unavailable on jruby so we need to use the java threads instead.
+    if RUBY_PLATFORM.match(/java/)
+      outer_threads = []
+      process_count.times do
+        outer_threads << Thread.new(&logger_test)
+      end
+      outer_threads.each{|thread| thread.join}
+    else
+      process_count.times do
+        Process.fork(&logger_test)
+      end
+      Process.waitall
+    end
+    
+    line_count = 0
+    file_count = 0
+    Dir.glob("#{log_file}*").each do |file|
+      file_count += 1
+      lines = File.read(file).split(Lumberjack::LINE_SEPARATOR)
+      line_count += lines.size
+      lines.each do |line|
+        line.should == message
+      end
+      unless file == log_file
+        #File.size(file).should >= max_size
+      end
+    end
+    
+    file_count.should > 3
+    line_count.should == process_count * thread_count * entry_count
+  end
+  
+  it "should only keep a specified number of archived log files" 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")
+    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)
+    device.write(entry)
+    device.flush
+    device.write(entry)
+    device.flush
+    device.write(entry)
+    device.flush
+    device.write(entry)
+    device.close
+    Dir.glob("#{log_file}*").sort.should == [log_file, "#{log_file}.another", "#{log_file}.keep"]
+  end
+
+end

data/spec/device/size_rolling_log_file_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Lumberjack::Device::SizeRollingLogFile do
+
+  before :all do
+    create_tmp_dir
+  end
+  
+  after :all do
+    delete_tmp_dir
+  end
+
+  it "should roll a file when it gets to a specified size" do
+    log_file = File.join(tmp_dir, "a#{rand(1000000000)}.log")
+    device = Lumberjack::Device::SizeRollingLogFile.new(log_file, :max_size => 40, :template => ":message")
+    logger = Lumberjack::Logger.new(device, :buffer_size => 2)
+    4.times do |i|
+      logger.error("test message #{i + 1}")
+      logger.flush
+    end
+    logger.close
+    
+    File.read("#{log_file}.1").split(Lumberjack::LINE_SEPARATOR).should == ["test message 1", "test message 2", "test message 3"]
+    File.read(log_file).should == "test message 4#{Lumberjack::LINE_SEPARATOR}"
+  end
+  
+  it "should be able to specify the max size in kilobytes" do
+    log_file = File.join(tmp_dir, "b#{rand(1000000000)}.log")
+    device = Lumberjack::Device::SizeRollingLogFile.new(log_file, :max_size => "32K")
+    device.max_size.should == 32768
+  end
+  
+  it "should be able to specify the max size in megabytes" do
+    log_file = File.join(tmp_dir, "c#{rand(1000000000)}.log")
+    device = Lumberjack::Device::SizeRollingLogFile.new(log_file, :max_size => "100M")
+    device.max_size.should == 104_857_600
+  end
+  
+  it "should be able to specify the max size in gigabytes" do
+    log_file = File.join(tmp_dir, "d#{rand(1000000000)}.log")
+    device = Lumberjack::Device::SizeRollingLogFile.new(log_file, :max_size => "1G")
+    device.max_size.should == 1_073_741_824
+  end
+  
+  it "should figure out the next archive file name available" do
+    log_file = File.join(tmp_dir, "filename.log")
+    (3..11).each do |i|
+      File.open("#{log_file}.#{i}", 'w'){|f| f.write(i.to_s)}
+    end
+    device = Lumberjack::Device::SizeRollingLogFile.new(log_file, :max_size => "100M")
+    device.archive_file_suffix.should == "12"
+  end
+
+end