chrono_logger 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e4231d70e04d8cc920687cb1f31c11f6bba61cb8
-  data.tar.gz: 7e3697d47afa57f7b22d99e169ce64cf85b1e588
+  metadata.gz: e4685d19b4094e975b08164b4041c82d20a0d843
+  data.tar.gz: 87f197078fead7232cc75b576a5eee36def4b0dd
 SHA512:
-  metadata.gz: d9398a7c7046b9e171f499ee3a2dd8638ae964d660133b884c4bdf905d2c2f024fe4159130fc60f2b375bdd1d9727a631ddd1c8f903adac40582cf384f63be5e
-  data.tar.gz: 6292f9aa38ea3f72b72d50c6ffe3cdea0fdaf443a36b6737da812e3e80fff042360d2e91753bbc66ef18838ca12ef29ac0524029440d478a4b7ff5e1941a6f7f
+  metadata.gz: 6c453b8b694c821b515c7b40a4b8641e2fad33295676b11894aa6e6efedc995dffc1dd91ff83b5ee0a07e554a2b7fa943e1f173e0f0f540bcb334ec45535d57c
+  data.tar.gz: 53db7768b5ecfbafded33375ccf583faed190bf2997c78cb25ebb2e41e0db00189d1737c039b254ea762b678b9b7a7501d94b74122962065b8fcbe733af676f2

data/.gitignore

@@ -13,3 +13,4 @@
 *.a
 mkmf.log
 /vendor/bundle
+.ruby-version

data/README.md

@@ -1,6 +1,6 @@
 # ChronoLogger
 
-TODO: Write a gem description
+A lock-free logger with timebased file rotation.
 
 ## Installation
 
@@ -20,11 +20,22 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+Same interfaces ruby's stdlib `Logger` except for `new` method.
+
+```
+require 'chrono_logger'
+
+logger = ChronoLogger.new('development.%Y%m%d')
+
+logger.error("Enjoy")
+logger.warn("logging!")
+logger.info("Enjoy")
+logger.debug("programming!")
+```
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/chrono_logger/fork )
+1. Fork it ( https://github.com/ma2gedev/chrono_logger/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/Rakefile

@@ -3,6 +3,7 @@ require "rake/testtask"
 
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
+  t.test_files = Dir["test/**/test_*.rb"]
 end
 
 task :default => :test

data/chrono_logger.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["takayuki.1229@gmail.com"]
   spec.summary       = %q{A lock-free logger with timebased file rotation.}
   spec.description   = %q{A lock-free logger with timebased file rotation.}
-  spec.homepage      = ""
+  spec.homepage      = "https://github.com/ma2gedev/chrono_logger"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")
@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "test-unit"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "delorean"
   spec.add_development_dependency "parallel"

data/lib/chrono_logger/version.rb

@@ -1,5 +1,5 @@
 require 'logger'
 
 class ChronoLogger < Logger
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/chrono_logger.rb

@@ -30,7 +30,7 @@ class ChronoLogger < Logger
     end
 
     def write(message)
-      if @dev.respond_to?(:stat)
+      if @pattern && @dev.respond_to?(:stat)
         begin
           check_shift_log
         rescue
@@ -61,10 +61,7 @@ class ChronoLogger < Logger
     def create_logfile(filename)
       begin
         logdev = open(filename, (File::WRONLY | File::APPEND | File::CREAT | File::EXCL))
-        logdev.flock(File::LOCK_EX)
         logdev.sync = true
-        add_log_header(logdev)
-        logdev.flock(File::LOCK_UN)
       rescue Errno::EEXIST
         # file is created by another process
         logdev = open_logfile(filename)
@@ -73,12 +70,6 @@ class ChronoLogger < Logger
       logdev
     end
 
-    def add_log_header(file)
-      file.write(
-        "# Logfile created on %s by %s\n" % [Time.now.to_s, Logger::ProgName]
-      ) if file.size == 0
-    end
-
     def check_shift_log
       unless Time.now.strftime(@pattern) == @filename
         new_filename = Time.now.strftime(@pattern)

data/test/from_ruby_repo/test_logdevice.rb

@@ -0,0 +1,153 @@
+# coding: US-ASCII
+require 'helper'
+require 'tempfile'
+require 'tmpdir'
+require 'parallel'
+require 'delorean'
+require 'pry'
+
+class TestLogDevice < Test::Unit::TestCase
+  class LogExcnRaiser
+    def write(*arg)
+      raise 'disk is full'
+    end
+
+    def close
+    end
+  end
+
+  def setup
+    @tempfile = Tempfile.new("logger")
+    @tempfile.close
+    @format = [@tempfile.path, '%Y%m%d'].join
+    @filename = Time.now.strftime(@format)
+    File.unlink(@tempfile.path)
+  end
+
+  def teardown
+    @tempfile.close(true)
+  end
+
+  def d(format, opt = {})
+    ChronoLogger::TimeBasedLogDevice.new(format, opt)
+  end
+
+  def test_initialize
+    logdev = d(STDERR)
+    assert_equal(STDERR, logdev.dev)
+    assert_nil(logdev.filename)
+    assert_raises(TypeError) do
+      d(nil)
+    end
+    #
+    logdev = d(@format)
+    begin
+      assert(File.exist?(@filename))
+      assert(logdev.dev.sync)
+      assert_equal(@filename, logdev.filename)
+      logdev.write('hello')
+    ensure
+      logdev.close
+    end
+    # create logfile whitch is already exist.
+    logdev = d(@format)
+    begin
+      logdev.write('world')
+      logfile = File.read(@filename)
+      assert_equal(1, logfile.split(/\n/).size)
+      assert_match(/^helloworld$/, logfile)
+    ensure
+      logdev.close
+    end
+  end
+
+  def test_write
+    r, w = IO.pipe
+    logdev = d(w)
+    logdev.write("msg2\n\n")
+    IO.select([r], nil, nil, 0.1)
+    w.close
+    msg = r.read
+    r.close
+    assert_equal("msg2\n\n", msg)
+    #
+    logdev = d(LogExcnRaiser.new)
+    class << (stderr = '')
+      alias write <<
+    end
+    $stderr, stderr = stderr, $stderr
+    begin
+      assert_nothing_raised do
+        logdev.write('hello')
+      end
+    ensure
+      logdev.close
+      $stderr, stderr = stderr, $stderr
+    end
+    assert_equal "log writing failed. disk is full\n", stderr
+  end
+
+  def test_close
+    r, w = IO.pipe
+    logdev = d(w)
+    logdev.write("msg2\n\n")
+    IO.select([r], nil, nil, 0.1)
+    assert(!w.closed?)
+    logdev.close
+    assert(w.closed?)
+    r.close
+  end
+
+  def test_shifting_age_in_multiprocess
+    old_log = [@tempfile.path, '20150122'].join
+    new_log = [@tempfile.path, '20150123'].join
+    $stderr, stderr = StringIO.new, $stderr
+    begin
+      Delorean.time_travel_to '2015-01-22 23:59:59'
+      logger = ChronoLogger.new(@format)
+      Parallel.map(['a', 'b'], :in_processes => 2) do |letter|
+        5000.times do
+          logger.info letter * 5000
+        end
+      end
+      assert_no_match(/log shifting failed/, $stderr.string)
+      assert_no_match(/log writing failed/, $stderr.string)
+      assert { File.exist?(old_log) }
+      assert { File.exist?(new_log) }
+    ensure
+      $stderr, stderr = stderr, $stderr
+      Delorean.back_to_the_present
+      File.unlink(old_log)
+      File.unlink(new_log)
+    end
+  end
+
+  def test_shifting_midnight
+    Dir.mktmpdir do |tmpdir|
+      log = "log20140102"
+      old_log = File.join(tmpdir, log)
+      begin
+        File.open(old_log, "w") {}
+        File.utime(*[Time.mktime(2014, 1, 1, 23, 59, 59)]*2, old_log)
+
+        Delorean.time_travel_to '2014-01-02 23:59:59'
+        dev = ChronoLogger::TimeBasedLogDevice.new(File.join(tmpdir, "log%Y%m%d"))
+        dev.write("#{Time.now} hello-1\n")
+
+        Delorean.time_travel_to '2014-01-03 00:00:01'
+        dev.write("#{Time.now} hello-2\n")
+      ensure
+        Delorean.back_to_the_present
+        dev.close
+      end
+
+      cont = File.read(old_log)
+      assert_match(/hello-1/, cont)
+      assert_not_match(/hello-2/, cont)
+      new_log = File.join(tmpdir, "log20140103")
+      bug = '[GH-539]'
+      assert { File.exist?(new_log) }
+      assert_match(/hello-2/, File.read(new_log), bug)
+    end
+  end
+end

data/test/from_ruby_repo/test_logger.rb

@@ -0,0 +1,243 @@
+# coding: US-ASCII
+require 'helper'
+require 'tempfile'
+
+class TestLogger < Test::Unit::TestCase
+  include ChronoLogger::Severity
+
+  def setup
+    @logger = ChronoLogger.new(nil)
+  end
+
+  class Log
+    attr_reader :label, :datetime, :pid, :severity, :progname, :msg
+    def initialize(line)
+      /\A(\w+), \[([^#]*)#(\d+)\]\s+(\w+) -- (\w*): ([\x0-\xff]*)/ =~ line
+      @label, @datetime, @pid, @severity, @progname, @msg = $1, $2, $3, $4, $5, $6
+    end
+  end
+
+  def log_add(logger, severity, msg, progname = nil, &block)
+    log(logger, :add, severity, msg, progname, &block)
+  end
+
+  def log(logger, msg_id, *arg, &block)
+    Log.new(log_raw(logger, msg_id, *arg, &block))
+  end
+
+  def log_raw(logger, msg_id, *arg, &block)
+    Tempfile.create(File.basename(__FILE__) + '.log') {|logdev|
+      logger.instance_eval { @logdev = ChronoLogger::TimeBasedLogDevice.new(logdev) }
+      logger.__send__(msg_id, *arg, &block)
+      logdev.rewind
+      logdev.read
+    }
+  end
+
+  def test_level
+    @logger.level = UNKNOWN
+    assert_equal(UNKNOWN, @logger.level)
+    @logger.level = INFO
+    assert_equal(INFO, @logger.level)
+    @logger.sev_threshold = ERROR
+    assert_equal(ERROR, @logger.sev_threshold)
+    @logger.sev_threshold = WARN
+    assert_equal(WARN, @logger.sev_threshold)
+    assert_equal(WARN, @logger.level)
+
+    @logger.level = DEBUG
+    assert(@logger.debug?)
+    assert(@logger.info?)
+    @logger.level = INFO
+    assert(!@logger.debug?)
+    assert(@logger.info?)
+    assert(@logger.warn?)
+    @logger.level = WARN
+    assert(!@logger.info?)
+    assert(@logger.warn?)
+    assert(@logger.error?)
+    @logger.level = ERROR
+    assert(!@logger.warn?)
+    assert(@logger.error?)
+    assert(@logger.fatal?)
+    @logger.level = FATAL
+    assert(!@logger.error?)
+    assert(@logger.fatal?)
+    @logger.level = UNKNOWN
+    assert(!@logger.error?)
+    assert(!@logger.fatal?)
+  end
+
+  def test_progname
+    assert_nil(@logger.progname)
+    @logger.progname = "name"
+    assert_equal("name", @logger.progname)
+  end
+
+  def test_datetime_format
+    dummy = STDERR
+    logger = ChronoLogger.new(dummy)
+    log = log_add(logger, INFO, "foo")
+    assert_match(/^\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\d.\s*\d+ $/, log.datetime)
+    logger.datetime_format = "%d%b%Y@%H:%M:%S"
+    log = log_add(logger, INFO, "foo")
+    assert_match(/^\d\d\w\w\w\d\d\d\d@\d\d:\d\d:\d\d$/, log.datetime)
+    logger.datetime_format = ""
+    log = log_add(logger, INFO, "foo")
+    assert_match(/^$/, log.datetime)
+  end
+
+  def test_formatter
+    dummy = STDERR
+    logger = ChronoLogger.new(dummy)
+    # default
+    log = log(logger, :info, "foo")
+    assert_equal("foo\n", log.msg)
+    # config
+    logger.formatter = proc { |severity, timestamp, progname, msg|
+      "#{severity}:#{msg}\n\n"
+    }
+    line = log_raw(logger, :info, "foo")
+    assert_equal("INFO:foo\n\n", line)
+    # recover
+    logger.formatter = nil
+    log = log(logger, :info, "foo")
+    assert_equal("foo\n", log.msg)
+    # again
+    o = Object.new
+    def o.call(severity, timestamp, progname, msg)
+      "<<#{severity}-#{msg}>>\n"
+    end
+    logger.formatter = o
+    line = log_raw(logger, :info, "foo")
+    assert_equal("<""<INFO-foo>>\n", line)
+  end
+
+  def test_initialize
+    logger = ChronoLogger.new(STDERR)
+    assert_nil(logger.progname)
+    assert_equal(DEBUG, logger.level)
+    assert_nil(logger.datetime_format)
+  end
+
+  def test_add
+    logger = ChronoLogger.new(nil)
+    logger.progname = "my_progname"
+    assert(logger.add(INFO))
+    log = log_add(logger, nil, "msg")
+    assert_equal("ANY", log.severity)
+    assert_equal("my_progname", log.progname)
+    logger.level = WARN
+    assert(logger.log(INFO))
+    assert_nil(log_add(logger, INFO, "msg").msg)
+    log = log_add(logger, WARN, nil) { "msg" }
+    assert_equal("msg\n", log.msg)
+    log = log_add(logger, WARN, "") { "msg" }
+    assert_equal("\n", log.msg)
+    assert_equal("my_progname", log.progname)
+    log = log_add(logger, WARN, nil, "progname?")
+    assert_equal("progname?\n", log.msg)
+    assert_equal("my_progname", log.progname)
+  end
+
+  def test_level_log
+    logger = ChronoLogger.new(nil)
+    logger.progname = "my_progname"
+    log = log(logger, :debug, "custom_progname") { "msg" }
+    assert_equal("msg\n", log.msg)
+    assert_equal("custom_progname", log.progname)
+    assert_equal("DEBUG", log.severity)
+    assert_equal("D", log.label)
+    #
+    log = log(logger, :debug) { "msg_block" }
+    assert_equal("msg_block\n", log.msg)
+    assert_equal("my_progname", log.progname)
+    log = log(logger, :debug, "msg_inline")
+    assert_equal("msg_inline\n", log.msg)
+    assert_equal("my_progname", log.progname)
+    #
+    log = log(logger, :info, "custom_progname") { "msg" }
+    assert_equal("msg\n", log.msg)
+    assert_equal("custom_progname", log.progname)
+    assert_equal("INFO", log.severity)
+    assert_equal("I", log.label)
+    #
+    log = log(logger, :warn, "custom_progname") { "msg" }
+    assert_equal("msg\n", log.msg)
+    assert_equal("custom_progname", log.progname)
+    assert_equal("WARN", log.severity)
+    assert_equal("W", log.label)
+    #
+    log = log(logger, :error, "custom_progname") { "msg" }
+    assert_equal("msg\n", log.msg)
+    assert_equal("custom_progname", log.progname)
+    assert_equal("ERROR", log.severity)
+    assert_equal("E", log.label)
+    #
+    log = log(logger, :fatal, "custom_progname") { "msg" }
+    assert_equal("msg\n", log.msg)
+    assert_equal("custom_progname", log.progname)
+    assert_equal("FATAL", log.severity)
+    assert_equal("F", log.label)
+    #
+    log = log(logger, :unknown, "custom_progname") { "msg" }
+    assert_equal("msg\n", log.msg)
+    assert_equal("custom_progname", log.progname)
+    assert_equal("ANY", log.severity)
+    assert_equal("A", log.label)
+  end
+
+  def test_close
+    r, w = IO.pipe
+    assert(!w.closed?)
+    logger = ChronoLogger.new(w)
+    logger.close
+    assert(w.closed?)
+    r.close
+  end
+
+  class MyError < StandardError
+  end
+
+  class MyMsg
+    def inspect
+      "my_msg"
+    end
+  end
+
+  def test_format
+    logger = ChronoLogger.new(nil)
+    log = log_add(logger, INFO, "msg\n")
+    assert_equal("msg\n\n", log.msg)
+    begin
+      raise MyError.new("excn")
+    rescue MyError => e
+      log = log_add(logger, INFO, e)
+      assert_match(/^excn \(TestLogger::MyError\)/, log.msg)
+      # expects backtrace is dumped across multi lines.  10 might be changed.
+      assert(log.msg.split(/\n/).size >= 10)
+    end
+    log = log_add(logger, INFO, MyMsg.new)
+    assert_equal("my_msg\n", log.msg)
+  end
+
+  def test_lshift
+    r, w = IO.pipe
+    logger = ChronoLogger.new(w)
+    logger << "msg"
+    read_ready, = IO.select([r], nil, nil, 0.1)
+    w.close
+    msg = r.read
+    r.close
+    assert_equal("msg", msg)
+    #
+    r, w = IO.pipe
+    logger = ChronoLogger.new(w)
+    logger << "msg2\n\n"
+    read_ready, = IO.select([r], nil, nil, 0.1)
+    w.close
+    msg = r.read
+    r.close
+    assert_equal("msg2\n\n", msg)
+  end
+end

data/test/from_ruby_repo/test_severity.rb

@@ -0,0 +1,13 @@
+require 'helper'
+
+class TestLoggerSeverity < Test::Unit::TestCase
+  def test_enum
+    logger_levels = ChronoLogger.constants
+    levels = ["WARN", "UNKNOWN", "INFO", "FATAL", "DEBUG", "ERROR"]
+    ChronoLogger::Severity.constants.each do |level|
+      assert(levels.include?(level.to_s))
+      assert(logger_levels.include?(level))
+    end
+    assert_equal(levels.size, ChronoLogger::Severity.constants.size)
+  end
+end

data/test/{minitest_helper.rb → helper.rb}

@@ -1,4 +1,4 @@
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'chrono_logger'
 
-require 'minitest/autorun'
+require 'test/unit'

data/test/test_chrono_logger.rb

@@ -1,11 +1,7 @@
-require 'minitest_helper'
+require 'helper'
 
-class TestChronoLogger < MiniTest::Unit::TestCase
+class TestChronoLogger < Test::Unit::TestCase
   def test_that_it_has_a_version_number
     refute_nil ::ChronoLogger::VERSION
   end
-
-  def test_it_does_something_useful
-    assert false
-  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chrono_logger
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Takayuki Matsubara
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-21 00:00:00.000000000 Z
+date: 2015-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: test-unit
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -110,9 +110,12 @@ files:
 - chrono_logger.gemspec
 - lib/chrono_logger.rb
 - lib/chrono_logger/version.rb
-- test/minitest_helper.rb
+- test/from_ruby_repo/test_logdevice.rb
+- test/from_ruby_repo/test_logger.rb
+- test/from_ruby_repo/test_severity.rb
+- test/helper.rb
 - test/test_chrono_logger.rb
-homepage: ''
+homepage: https://github.com/ma2gedev/chrono_logger
 licenses:
 - MIT
 metadata: {}
@@ -137,5 +140,8 @@ signing_key:
 specification_version: 4
 summary: A lock-free logger with timebased file rotation.
 test_files:
-- test/minitest_helper.rb
+- test/from_ruby_repo/test_logdevice.rb
+- test/from_ruby_repo/test_logger.rb
+- test/from_ruby_repo/test_severity.rb
+- test/helper.rb
 - test/test_chrono_logger.rb