lumberjack 1.0.13 → 1.1.0

data/Rakefile

@@ -1,40 +0,0 @@
-require 'rubygems'
-require 'rake'
-require 'rubygems/package_task'
-
-desc 'Default: run unit tests.'
-task :default => :test
-
-desc 'RVM likes to call it tests'
-task :tests => :test
-
-begin
-  require 'rspec'
-  require 'rspec/core/rake_task'
-  desc 'Run the unit tests'
-  RSpec::Core::RakeTask.new(:test)
-rescue LoadError
-  task :test do
-    STDERR.puts "You must have rspec 2.0 installed to run the tests"
-  end
-end
-
-namespace :rbx do
-  desc "Cleanup *.rbc files in lib directory"
-  task :delete_rbc_files do
-    FileList["**/*.rbc"].each do |rbc_file|
-      File.delete(rbc_file)
-    end
-    nil
-  end
-end
-
-spec_file = File.expand_path('../lumberjack.gemspec', __FILE__)
-if File.exist?(spec_file)
-  spec = eval(File.read(spec_file))
-
-  Gem::PackageTask.new(spec) do |p|
-    p.gem_spec = spec
-  end
-  Rake.application["package"].prerequisites.unshift("rbx:delete_rbc_files")
-end

data/spec/device/date_rolling_log_file_spec.rb

@@ -1,73 +0,0 @@
-require 'spec_helper'
-
-describe Lumberjack::Device::DateRollingLogFile do
-
-  before :all do
-    create_tmp_dir
-  end
-  
-  after :all do
-    delete_tmp_dir
-  end
-  
-  before :each do
-    delete_tmp_files
-  end
-  
-  let(:one_day){ 60 * 60 * 24 }
-  
-  it "should roll the file daily" do
-    now = Time.now
-    log_file = File.join(tmp_dir, "a#{rand(1000000000)}.log")
-    device = Lumberjack::Device::DateRollingLogFile.new(log_file, :roll => :daily, :template => ":message", :min_roll_check => 0)
-    logger = Lumberjack::Logger.new(device, :buffer_size => 2)
-    Timecop.travel(now) do
-      logger.error("test day one")
-      logger.flush
-    end
-    Timecop.travel(now + one_day) do
-      logger.error("test day two")
-      logger.close
-    end
-  
-    File.read("#{log_file}.#{now.to_date.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
-    now = Time.now
-    log_file = File.join(tmp_dir, "b#{rand(1000000000)}.log")
-    device = Lumberjack::Device::DateRollingLogFile.new(log_file, :roll => :weekly, :template => ":message", :min_roll_check => 0)
-    logger = Lumberjack::Logger.new(device, :buffer_size => 2)
-    Timecop.freeze(now) do
-      logger.error("test week one")
-      logger.flush
-    end
-    Timecop.freeze(now + (7 * one_day)) do
-      logger.error("test week two")
-      logger.close
-    end
-    
-    File.read("#{log_file}.#{now.to_date.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
-    now = Time.now
-    log_file = File.join(tmp_dir, "c#{rand(1000000000)}.log")
-    device = Lumberjack::Device::DateRollingLogFile.new(log_file, :roll => :monthly, :template => ":message", :min_roll_check => 0)
-    logger = Lumberjack::Logger.new(device, :buffer_size => 2)
-    Timecop.freeze(now) do
-      logger.error("test month one")
-      logger.flush
-    end
-    Timecop.freeze(now + (31 * one_day)) do
-      logger.error("test month two")
-      logger.close
-    end
-  
-    File.read("#{log_file}.#{now.to_date.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

@@ -1,48 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'spec_helper'
-
-describe Lumberjack::Device::LogFile do
-
-  before :all do
-    create_tmp_dir
-  end
-  
-  after :all do
-    delete_tmp_dir
-  end
-  
-  before :each do
-    delete_tmp_files
-  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
-
-  it "properly handles messages with broken UTF-8 characters" do
-    log_file = File.join(tmp_dir, "test_6.log")
-    device = Lumberjack::Device::LogFile.new(log_file,
-      :keep => 2, :buffer_size => 32767)
-
-    message = [0xC4, 0x90, 0xE1, 0xBB].pack("c*").force_encoding "ASCII-8BIT"
-    entry = Lumberjack::LogEntry.new(Time.now, 1, message, nil, $$, nil)
-    device.write entry
-
-    message = "проверка"
-    entry = Lumberjack::LogEntry.new(Time.now, 1, message, nil, $$, nil)
-    device.write entry
-
-    expect do
-      device.flush
-    end.to_not raise_error
-  end
-end

data/spec/device/null_spec.rb

@@ -1,12 +0,0 @@
-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

@@ -1,151 +0,0 @@
-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
-  
-  before :each do
-    delete_tmp_files
-  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, :min_roll_check => 0)
-    device.write(entry)
-    expect(device).to 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, :min_roll_check => 0)
-    expect(device).to receive(:roll_file?).and_return(false, true)
-    expect(device).to receive(:after_roll)
-    device.stub(:archive_file_suffix => "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", :min_roll_check => 0)
-    device.stub(:roll_file? => 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, :min_roll_check => 0)
-      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
-          device.flush
-        end
-      end
-      threads.each{|thread| thread.value}
-      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.value}
-    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
-    end
-    
-    file_count.should > 3
-  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, :min_roll_check => 0)
-    expect(device).to receive(:roll_file?).and_return(false, true, true, true)
-    expect(device).to receive(:archive_file_suffix).and_return("delete", "another", "keep")
-    t = Time.now
-    expect(File).to receive(:ctime).with("#{log_file}.delete").at_least(1).times.and_return(t + 1)
-    expect(File).to receive(:ctime).with("#{log_file}.another").at_least(1).times.and_return(t + 2)
-    expect(File).to receive(:ctime).with("#{log_file}.keep").at_least(1).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
-
-  context "when file is rolled" do
-    let(:log_file) { File.join(tmp_dir, "test_6.log") }
-
-    let(:device) do
-      device = Lumberjack::Device::RollingLogFile.new(log_file, :template => ":message", :keep => 2, :buffer_size => 32767, :min_roll_check => 0)
-      device.stub(:roll_file?).and_return(true)
-      device.stub(:archive_file_suffix => "rolled")
-      device
-    end
-
-    before do
-      device.write(entry)
-      device.flush
-    end
-
-    it "reopens file with proper encoding" do
-      encoding = device.send(:stream).external_encoding
-      expect(encoding).to_not be_nil
-      expect(encoding.name).to eq "ASCII-8BIT"
-    end
-  end
-
-end

data/spec/device/size_rolling_log_file_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-
-describe Lumberjack::Device::SizeRollingLogFile do
-
-  before :all do
-    create_tmp_dir
-  end
-  
-  after :all do
-    delete_tmp_dir
-  end
-  
-  before :each do
-    delete_tmp_files
-  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", :min_roll_check => 0)
-    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", :min_roll_check => 0)
-    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", :min_roll_check => 0)
-    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", :min_roll_check => 0)
-    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", :min_roll_check => 0)
-    device.archive_file_suffix.should == "12"
-  end
-
-end

data/spec/device/writer_spec.rb

@@ -1,118 +0,0 @@
-require 'spec_helper'
-
-describe Lumberjack::Device::Writer do
-
-  let(:time_string){ "2011-01-15T14:23:45.123" }
-  let(:time){ Time.parse(time_string) }
-  let(:stream){ StringIO.new }
-  let(:entry){ Lumberjack::LogEntry.new(time, Lumberjack::Severity::INFO, "test message", "app", 12345, "ABCD") }
-  
-  it "should buffer output and not write directly to the stream" do
-    device = Lumberjack::Device::Writer.new(stream, :template => ":message", :buffer_size => 32767)
-    device.write(entry)
-    stream.string.should == ""
-    device.flush
-    stream.string.should == "test message#{Lumberjack::LINE_SEPARATOR}"
-  end
-    
-  it "should flush the buffer when it gets to the specified size" do
-    device = Lumberjack::Device::Writer.new(stream, :buffer_size => 15, :template => ":message")
-    device.write(entry)
-    stream.string.should == ""
-    device.write(entry)
-    stream.string.should == "test message#{Lumberjack::LINE_SEPARATOR}test message#{Lumberjack::LINE_SEPARATOR}"
-  end
-  
-  it "should sync the stream and flush it when the device is flushed" do
-    # Create an IO like object that require flush to be called
-    io = Object.new
-    def io.init; @string = ""; @buffer = ""; @sync = false; end
-    def io.write(string); @buffer << string; end
-    def io.flush; @string << @buffer; @buffer = ""; end
-    def io.string; @string; end
-    def io.sync=(val); @sync = val; end
-    def io.sync; @sync; end
-    io.init
-    
-    device = Lumberjack::Device::Writer.new(io, :template => ":message", :buffer_size => 32767)
-    device.write(entry)
-    io.string.should == ""
-    device.flush
-    io.string.should == "test message#{Lumberjack::LINE_SEPARATOR}"
-    io.sync.should == true
-  end
-  
-  it "should be able to set the buffer size" do
-    device = Lumberjack::Device::Writer.new(stream, :buffer_size => 15)
-    device.buffer_size.should == 15
-    device.buffer_size = 100
-    device.buffer_size.should == 100
-  end
-  
-  it "should have a default buffer size of 0" do
-    device = Lumberjack::Device::Writer.new(stream)
-    device.buffer_size.should == 0
-  end
-  
-  it "should write entries out to the stream with a default template" do
-    device = Lumberjack::Device::Writer.new(stream)
-    device.write(entry)
-    device.flush
-    stream.string.should == "[2011-01-15T14:23:45.123 INFO app(12345) #ABCD] test message#{Lumberjack::LINE_SEPARATOR}"
-  end
-  
-  it "should write entries out to the stream with a custom template" do
-    device = Lumberjack::Device::Writer.new(stream, :template => ":message")
-    device.write(entry)
-    device.flush
-    stream.string.should == "test message#{Lumberjack::LINE_SEPARATOR}"
-  end
-  
-  it "should be able to specify the time format for the template" do
-    device = Lumberjack::Device::Writer.new(stream, :time_format => :microseconds)
-    device.write(entry)
-    device.flush
-    stream.string.should == "[2011-01-15T14:23:45.123000 INFO app(12345) #ABCD] test message#{Lumberjack::LINE_SEPARATOR}"
-  end
-  
-  it "should be able to specify a block template for log entries" do
-    device = Lumberjack::Device::Writer.new(stream, :template => lambda{|e| e.message.upcase})
-    device.write(entry)
-    device.flush
-    stream.string.should == "TEST MESSAGE#{Lumberjack::LINE_SEPARATOR}"
-  end
-  
-  it "should write to STDERR if an error is raised when flushing to the stream" do
-    stderr = $stderr
-    $stderr = StringIO.new
-    begin
-      device = Lumberjack::Device::Writer.new(stream, :template => ":message")
-      stream.should_receive(:write).and_raise(StandardError.new("Cannot write to stream"))
-      device.write(entry)
-      device.flush
-      $stderr.string.should include("test message#{Lumberjack::LINE_SEPARATOR}")
-      $stderr.string.should include("StandardError: Cannot write to stream")
-    ensure
-      $stderr = stderr
-    end
-  end
-  
-  context "multi line messages" do
-    let(:message){ "line 1#{Lumberjack::LINE_SEPARATOR}line 2#{Lumberjack::LINE_SEPARATOR}line 3" }
-    let(:entry){ Lumberjack::LogEntry.new(time, Lumberjack::Severity::INFO, message, "app", 12345, "ABCD") }
-    
-    it "should have a default template for multiline messages" do
-      device = Lumberjack::Device::Writer.new(stream)
-      device.write(entry)
-      device.flush
-      stream.string.split(Lumberjack::LINE_SEPARATOR).should == ["[2011-01-15T14:23:45.123 INFO app(12345) #ABCD] line 1", "> [#ABCD] line 2", "> [#ABCD] line 3"]
-    end
-  
-    it "should be able to specify a template for multiple line messages" do
-      device = Lumberjack::Device::Writer.new(stream, :additional_lines => " // :message")
-      device.write(entry)
-      device.flush
-      stream.string.should == "[2011-01-15T14:23:45.123 INFO app(12345) #ABCD] line 1 // line 2 // line 3#{Lumberjack::LINE_SEPARATOR}"
-    end
-  end
-end