strftime_logger 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9329428c0cbb2bf7dc2d5589e420659a86d5ada4
+  data.tar.gz: 729cc3eacd69620002f9aadaff0cb138d288f22c
+SHA512:
+  metadata.gz: c4e88ff564ef06cb8ebed2571958f70f326fbd3330e65ca4056fd92283e35ea72764d20b517abd896a310cd260de95b8cc429c15422115b3f5ddaafeaaa45f32
+  data.tar.gz: 1f0fadbd16716c2aeb5af9c7de6b5026359eafbeb0ad4128dc007f0525fd1b33fcef0004c5bc87e1702c95c1339a58df106ea594146abda40e86f56a812104e6

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+example/log
+

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# 0.0.1 (2014/07/01)
+
+First version

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rspec'
+gem 'timecop'
+gem 'parallel'
+gem 'rake'
+gem 'pry'
+gem 'pry-nav'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Naotoshi Seo
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,101 @@
+# StrftimeLogger
+
+A logger treats log rotation in strftime fashion.
+
+## What is this for?
+
+This logger provides a feature to rotate logs in the basis of time although
+the ruby's built-in logger has a feature to rotate logs in the basis of log size.
+
+This logger allows to specify the log path with `strftime` format such as:
+
+```
+logger = StrftimeLogger.new('/var/log/application.log.%Y%m%d')
+```
+
+which enables to rotate logs in each specific time.
+
+In facts, this logger does not rotate logs, but just outputs to the strftime formatted path directly,
+which results in avoiding locking files in log rotation. 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'strftime_logger'
+
+And then execute:
+
+    $ bundle
+
+## How to use
+
+### Normal Usage
+
+```ruby
+require 'strftime_logger'
+logger = StrftimeLogger.new('/var/log/application.log.%Y%m%d')
+logger.info("foo\nbar")
+```
+
+which outputs logs to `/var/log/application.log.YYYYMMDD` with contents like
+
+```
+20140630T00:00:00+09:00 [INFO] foo\\nbar
+```
+
+where the time is in ISO8601 format, and the line feed characters `\n` in log messages
+are replaced with `\\n` so that the log message will be in one line.
+
+### Change the log level
+
+```
+logger.level = StrftimeLogger::WARN
+```
+
+### Change the Formatter
+
+It is possible to change the logger formmater as:
+
+```ruby
+logger.formatter = SampleFormatter.new
+```
+
+The interface which the costom formmatter must provide is only `#initialize(opts = {})` and `#call(sevirity, message = nil, &block)`. Following is a simple example:
+
+```ruby
+class SampleFormatter
+  LEVEL_TEXT = %w(DEBUG INFO WARN ERROR FATAL UNKNOWN)
+
+  def initialize(opts={})
+  end
+
+  # @param sevirity [int] log sevirity
+  def call(severity, message = nil, &block)
+    if message.nil?
+      if block_given?
+        message = yield
+      else
+        message = ""
+      end
+    end
+    "#{Time.now} #{LEVEL_TEXT[sevirity]} #{message}"
+  end
+end
+```
+
+## ChangeLog
+
+See [CHANGELOG.md](CHANGELOG.md) for details.
+
+## Contributing
+
+1. Fork it
+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`)
+5. Create new [Pull Request](../../pull/new/master)
+
+## Copyright
+
+See [LICENSE.txt](LICENSE.txt) for details.

data/Rakefile

@@ -0,0 +1,17 @@
+require "bundler/gem_tasks"
+
+task :default => :test
+
+task :test do
+  require 'rspec/core'
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:test) do |spec|
+    spec.pattern = FileList['spec/**/*_spec.rb']
+  end
+end
+
+desc 'Open an irb session preloaded with the gem library'
+task :console do
+  sh 'irb -rubygems -I lib -r pfsys-logger'
+end
+task :c => :console

data/lib/strftime_logger/adapter/file.rb

@@ -0,0 +1,77 @@
+require 'monitor'
+
+class StrftimeLogger
+  class Adapter
+    class File
+
+      class LogFileMutex
+        include MonitorMixin
+      end
+
+      def initialize(level, path)
+        @level = level
+        @path = path
+        @timestamp_path = Time.now.strftime(path)
+        @mutex = LogFileMutex.new
+        @log = open_logfile(@timestamp_path)
+      end
+
+      def write(msg)
+        begin
+          @mutex.synchronize do
+            if @log.nil? || !same_path?
+              begin
+                @timestamp_path = Time.now.strftime(@path)
+                @log.close rescue nil
+                @log = create_logfile(@timestamp_path)
+              rescue
+                warn("log shifting failed. #{$!}")
+              end
+            end
+
+            begin
+              @log.write msg
+            rescue
+              warn("log writing failed. #{$!}")
+            end
+          end
+        rescue Exception => ignored
+          warn("log writing failed. #{ignored}")
+        end
+      end
+
+      def close
+        if !@log.nil? && !@log.closed?
+          @log.close
+        end
+      end
+
+      private
+
+      # return nil if file not found
+      def open_logfile(filename)
+        begin
+          f = ::File.open filename, (::File::WRONLY | ::File::APPEND)
+          f.sync = true
+        rescue Errno::ENOENT
+          return nil
+        end
+        f
+      end
+
+      def create_logfile(filename)
+        begin
+          f = ::File.open filename, (::File::WRONLY | ::File::APPEND | ::File::CREAT | ::File::EXCL)
+          f.sync = true
+        rescue Errno::EEXIST
+          f = open_logfile(filename)
+        end
+        f
+      end
+
+      def same_path?
+        @timestamp_path == Time.now.strftime(@path)
+      end
+    end
+  end
+end

data/lib/strftime_logger/bridge.rb

@@ -0,0 +1,54 @@
+require_relative 'adapter/file'
+
+class StrftimeLogger
+  # A birdge to support logger's adapters. 
+  # This interface enables for the logger to output not only into file, but aslo syslog, fluentd, and queue, etc.
+  #
+  # In addition, one or some adapters can be configured for **each** log level. 
+  # If multiple adapters are specified, writing a log will output to the multiple destinations.
+  class Bridge
+
+    # @param [Symbol] level
+    def initialize(level, name, adapters = nil)
+      set_adapters(level, name, adapters)
+    end
+
+    def write(msg)
+      @adapters.each do |adapter|
+        adapter.write(msg)
+      end
+    end
+
+    def close
+      @adapters.each do |adapter|
+        adapter.close
+      end
+    end
+
+    private
+    def default_adapters
+      {
+        debug:   [StrftimeLogger::Adapter::File],
+        info:    [StrftimeLogger::Adapter::File],
+        warn:    [StrftimeLogger::Adapter::File],
+        error:   [StrftimeLogger::Adapter::File],
+        fatal:   [StrftimeLogger::Adapter::File],
+        unknown: [StrftimeLogger::Adapter::File],
+      }
+    end
+
+    def set_adapters(level, name, adapters = nil)
+      @adapters = Array.new
+      (adapters || default_adapters[level]).each do |adapter|
+        case adapter
+        when Class
+          @adapters.push adapter.new(level, name)
+        else
+          @adapters.push adapter
+        end
+      end
+    end
+  end
+end
+
+

data/lib/strftime_logger/formatter.rb

@@ -0,0 +1,41 @@
+require 'time'
+
+class StrftimeLogger
+  class Formatter
+    FORMAT = "%s [%s] %s\n"
+    LEVEL_TEXT = %w(DEBUG INFO WARN ERROR FATAL UNKNOWN)
+
+    def initialize(opts={})
+    end
+
+    def call(severity, message = nil, &block)
+      if message.nil?
+        if block_given?
+          message = yield
+        else
+          message = ""
+        end
+      end
+      FORMAT % [format_datetime(Time.now), format_severity(severity), format_message(message)]
+    end
+
+    private
+    def format_datetime(time)
+      time.iso8601
+    end
+
+    def format_severity(severity)
+      LEVEL_TEXT[severity]
+    end
+
+    def format_message(message)
+      case message
+      when ::Exception
+        e = message
+        "#{e.class} #{e.message} #{e.backtrace.first}"
+      else
+        message.to_s.gsub(/\n/, "\\n")
+      end
+    end
+  end
+end

data/lib/strftime_logger/ltsv_formatter.rb

@@ -0,0 +1,28 @@
+require 'time'
+
+class StrftimeLogger
+  class LtsvFormatter
+    def initialize(opts={})
+    end
+
+    def call(severity, message = nil, &block)
+      if message.nil?
+        if block_given?
+          message = yield
+        else
+          message = ""
+        end
+      end
+      "#{format_message(message)}\n"
+    end
+
+    private
+
+    def format_message(message)
+      unless message.is_a?(Hash)
+        message = { message: message }
+      end
+      message.map {|k, v| "#{k}:#{v}" }.join("\t")
+    end
+  end
+end

data/lib/strftime_logger.rb

@@ -0,0 +1,164 @@
+class StrftimeLogger
+  require 'strftime_logger/formatter'
+  require 'strftime_logger/ltsv_formatter'
+  require 'strftime_logger/bridge'
+  require 'strftime_logger/adapter/file'
+
+  SEV_LABEL = [:debug, :info, :warn, :error, :fatal, :unknown]
+
+  # Logging severity.
+  module Severity
+    # Low-level information, mostly for developers
+    DEBUG = 0
+    # generic, useful information about system operation
+    INFO = 1
+    # a warning
+    WARN = 2
+    # a handleable error condition
+    ERROR = 3
+    # an unhandleable error that results in a program crash
+    FATAL = 4
+    # an unknown message that should always be logged
+    UNKNOWN = 5
+  end
+  include Severity
+
+  # Logging severity threshold (e.g. <tt>Logger::INFO</tt>).
+  attr_accessor :level
+  attr_accessor :formatter
+
+  # @param [Hash|IO|String] path 
+  # @param [Hash] adapters
+  #
+  # Example:
+  # 
+  #     StrftimeLogger.new('/var/log/foo/webapp.log.%Y%m%d') # String
+  #     StrftimeLogger.new('/var/log/foo/webapp.log.%Y%m%d_%H')
+  #
+  # Exampl2:
+  #
+  #     # Hash
+  #     StrftimeLogger.new({
+  #       debug:   '/var/log/foo/webapp.debug.log.%Y%m%d',
+  #       info:    '/var/log/foo/webapp.info.log.%Y%m%d',
+  #       warn:    '/var/log/foo/webapp.warn.log.%Y%m%d',
+  #       error:   '/var/log/foo/webapp.error.log.%Y%m%d',
+  #       fatal:   '/var/log/foo/webapp.fatal.log.%Y%m%d',
+  #       unknown: '/var/log/foo/webapp.unknown.log.%Y%m%d'
+  #     })
+  #
+  # Exampl3:
+  #
+  #     # With Specified Adapter
+  #     StrftimeLogger.new('/var/log/foo/webapp.log.%Y%m%d', [StrftimeLogger::Adapter::File])
+  def initialize(path, adapter = nil)
+    @level = DEBUG
+    @default_formatter = StrftimeLogger::Formatter.new
+    @formatter = nil
+
+    if path.is_a?(Hash)
+      @path = path
+    else
+      # make a hash
+      keys = SEV_LABEL
+      vals = [path] * keys.size
+      @path = Hash[*(keys.zip(vals).flatten(1))]
+    end
+
+    if adapter.nil?
+      @adapter = {}
+    elsif adapter.is_a?(Hash)
+      @adapter = adapter
+    else
+      # make a hash
+      keys = SEV_LABEL
+      vals = [adapter] * keys.size
+      @adapter = Hash[*(keys.zip(vals).flatten(1))]
+    end
+
+    @bridge = {}
+    SEV_LABEL.each do |level|
+      @bridge[level] = StrftimeLogger::Bridge.new(level, @path[level], @adapter[level])
+    end
+  end
+
+  # @param severity [Int] log severity
+  def add(severity, message = nil, &block)
+    severity ||= UNKNOWN
+
+    if @bridge.nil? or severity < @level
+      return true
+    end
+
+    log_level = SEV_LABEL[severity]
+    if @bridge[log_level].nil?
+      @bridge[log_level] = StrftimeLogger::Adapter.new(log_level, @path[log_level])
+    end
+
+    @bridge[log_level].write(format_message(severity, message, &block))
+    true
+  end
+  alias log add
+
+  def debug(msg, &block)
+    add(DEBUG, msg, &block)
+  end
+
+  def info(msg, &block)
+    add(INFO, msg, &block)
+  end
+
+  def warn(msg, &block)
+    add(WARN, msg, &block)
+  end
+
+  def error(msg, &block)
+    add(ERROR, msg, &block)
+  end
+
+  def fatal(msg,  &block)
+    add(FATAL, msg, &block)
+  end
+
+  def unknown(msg, &block)
+    add(UNKNOWN, msg, &block)
+  end
+
+  def write(msg)
+    msg.chomp! if msg.respond_to?(:chomp!)
+    add(INFO, msg)
+  end
+
+  # Returns +true+ iff the current severity level allows for the printing of
+  # +DEBUG+ messages.
+  def debug?; @level <= DEBUG; end
+
+  # Returns +true+ iff the current severity level allows for the printing of
+  # +INFO+ messages.
+  def info?; @level <= INFO; end
+
+  # Returns +true+ iff the current severity level allows for the printing of
+  # +WARN+ messages.
+  def warn?; @level <= WARN; end
+
+  # Returns +true+ iff the current severity level allows for the printing of
+  # +ERROR+ messages.
+  def error?; @level <= ERROR; end
+
+  # Returns +true+ iff the current severity level allows for the printing of
+  # +FATAL+ messages.
+  def fatal?; @level <= FATAL; end
+
+  def close
+    SEV_LABEL.each do |level|
+      next if @bridge[level].nil?
+      @bridge[level].close
+    end
+  end
+
+  def format_message(severity, message = nil, &block)
+    (@formatter || @default_formatter).call(severity, message, &block)
+  end
+end
+
+

data/spec/formatter_spec.rb

@@ -0,0 +1,33 @@
+require_relative 'spec_helper'
+require 'strftime_logger'
+require 'fileutils'
+
+describe StrftimeLogger do
+  subject { StrftimeLogger.new("#{log_dir}/application.log.%Y%m%d") }
+  let(:log_dir)   { "#{File.dirname(__FILE__)}/log" }
+  let(:today)     { Time.now.strftime "%Y%m%d"}
+  let(:now)       { Time.now.iso8601 }
+
+  before do
+    Dir.mkdir(log_dir)
+    Timecop.freeze(Time.now)
+  end
+
+  after do
+    FileUtils.rm_rf log_dir
+    Timecop.return
+  end
+
+  it :write do
+    subject.write("test")
+    begin
+      raise ArgumentError.new('test')
+    rescue => e
+      subject.write(e)
+    end
+    File.open("#{log_dir}/application.log.#{today}") do |f|
+      expect(f.gets).to eq "#{now} [INFO] test\n"
+      expect(f.gets).to match(/#{Regexp.escape(now)} \[INFO\] ArgumentError test/)
+    end
+  end
+end

data/spec/ltsv_formatter_spec.rb

@@ -0,0 +1,32 @@
+require_relative 'spec_helper'
+require 'strftime_logger'
+require 'fileutils'
+
+describe StrftimeLogger do
+  subject do
+    StrftimeLogger.new("#{log_dir}/application.log.%Y%m%d").tap {|logger|
+      logger.formatter = StrftimeLogger::LtsvFormatter.new
+    }
+  end
+  let(:log_dir)   { "#{File.dirname(__FILE__)}/log" }
+  let(:today)     { Time.now.strftime "%Y%m%d"}
+
+  before do
+    Dir.mkdir(log_dir)
+    Timecop.freeze(Time.now)
+  end
+
+  after do
+    FileUtils.rm_rf log_dir
+    Timecop.return
+  end
+
+  it :write do
+    subject.write("test")
+    subject.write({a:1, b:2})
+    File.open("#{log_dir}/application.log.#{today}") do |f|
+      expect(f.gets).to eq "message:test\n"
+      expect(f.gets).to eq "a:1\tb:2\n"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'bundler'
+Bundler.setup(:default, :test)
+Bundler.require(:default, :test)
+
+$TESTING=true
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'strftime_logger'

data/spec/strftime_logger_spec.rb

@@ -0,0 +1,104 @@
+require_relative 'spec_helper'
+require 'strftime_logger'
+require 'fileutils'
+
+describe StrftimeLogger do
+  let(:log_dir)   { "#{File.dirname(__FILE__)}/log" }
+
+  before do
+    Dir.mkdir(log_dir)
+    Timecop.freeze(Time.now)
+  end
+
+  after do
+    FileUtils.rm_rf log_dir
+    Timecop.return
+  end
+
+  context :write do
+    subject { StrftimeLogger.new("#{log_dir}/application.log.%Y%m%d") }
+    let(:today)     { Time.now.strftime "%Y%m%d"}
+    let(:now)       { Time.now.iso8601 }
+
+    it :write do
+      subject.write("test")
+      subject.write("test")
+      expect(File.read("#{log_dir}/application.log.#{today}")).to eq "#{now} [INFO] test\n"*2
+    end
+
+    LEVEL_TEXT = %w(DEBUG INFO WARN ERROR FATAL UNKNOWN)
+    %w[debug info warn error fatal unknown].each_with_index do |level, severity|
+      it level do
+        subject.__send__(level, "test")
+        expect(File.read("#{log_dir}/application.log.#{today}")).to eq "#{now} [#{LEVEL_TEXT[severity]}] test\n"
+      end
+    end
+
+    it 'multiline' do
+      subject.info("foo\nbar")
+      expect(File.read("#{log_dir}/application.log.#{today}")).to eq "#{now} [INFO] foo\\nbar\n"
+    end
+
+    it 'rotate log' do
+      subject.info("test")
+      Timecop.freeze(Time.now + 24 * 60 * 60)
+      subject.info("test")
+      yesterday = (Time.now - 24 * 60 * 60).strftime "%Y%m%d"
+      one_day_ago = (Time.now - 24 * 60 * 60).iso8601
+      expect(File.read("#{log_dir}/application.log.#{yesterday}")).to eq "#{one_day_ago} [INFO] test\n"
+      expect(File.read("#{log_dir}/application.log.#{today}")).to eq "#{now} [INFO] test\n"
+    end
+  end
+
+  context :new do
+    let(:now) { Time.now.iso8601 }
+
+    it 'date format' do
+      logger = StrftimeLogger.new("#{log_dir}/application.log.%Y%m%d_%H")
+      current_hour = Time.now.strftime "%Y%m%d_%H"
+      logger.info("test")
+      expect(File.read("#{log_dir}/application.log.#{current_hour}")).to eq "#{now} [INFO] test\n"
+    end
+
+    it 'file per level' do
+      logger = StrftimeLogger.new({
+        debug:   "#{log_dir}/application.debug.log",
+        info:    "#{log_dir}/application.info.log",
+        warn:    "#{log_dir}/application.warn.log",
+        error:   "#{log_dir}/application.error.log",
+        fatal:   "#{log_dir}/application.fatal.log",
+        unknown: "#{log_dir}/application.unknown.log"
+      })
+      logger.info("test")
+      expect(File.read("#{log_dir}/application.info.log")).to eq "#{now} [INFO] test\n"
+    end
+
+    it 'level=' do
+      logger = StrftimeLogger.new("#{log_dir}/application.log")
+      logger.level = StrftimeLogger::WARN
+      logger.info("test")
+      logger.warn("test")
+      expect(File.read("#{log_dir}/application.log")).to eq "#{now} [WARN] test\n"
+    end
+
+    class MockAdapter
+      def initialize(level, path)
+      end
+      def write(msg)
+        ::File.open("#{File.dirname(__FILE__)}/log/mock", 'a+') do |f|
+          f.write msg
+          f.flush
+        end
+      end
+    end
+
+    describe 'switch adapter' do
+      it 'class and instance' do
+        logger = StrftimeLogger.new("#{log_dir}/test", {debug: [MockAdapter, MockAdapter.new('mock', 'mock')]})
+        logger.debug('mock')
+        expect(File.read("#{log_dir}/mock")).to eq "#{now} [DEBUG] mock\n#{now} [DEBUG] mock\n"
+      end
+    end
+  end
+end
+

data/spec/thread_safe/process_safe_check.rb

@@ -0,0 +1,14 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'strftime_logger'
+require 'parallel'
+
+logger = StrftimeLogger.new("#{__dir__}/test.log")
+Parallel.map(['a', 'b'], :in_processes => 2) do |letter|
+  3000.times do
+    logger.info letter * 5000
+  end
+end
+
+# egrep -e 'ab' -e 'ba' test.log
+# これはまざらない

data/spec/thread_safe/rotate_process_safe_check.rb

@@ -0,0 +1,37 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'strftime_logger'
+require 'parallel'
+require 'timecop'
+require 'test/unit'
+
+Timecop.scale(24 * 60 * 60)
+
+$proc_num = 2
+$execute_num = 10000
+
+logger = StrftimeLogger.new("#{__dir__}/test.log.%Y%m%d")
+Parallel.map(['a', 'b'], :in_processes => $proc_num) do |letter|
+  $execute_num.times do
+  logger.info letter * 5000
+  end
+end
+
+$total_num = `LANG=C wc -l #{__dir__}/test.log.*`.split("\n").map(&:strip).grep(/\stotal\z/).first.split(' ').first.to_i
+p "Actually total line num #{$total_num}"
+p "Expected total line num #{$execute_num * $proc_num}"
+
+class StrftimeLoggerTC < Test::Unit::TestCase
+  def test_logger
+    assert_equal($execute_num * $proc_num, $total_num)
+  end
+  def teardown
+    p 'rm -rf #{__dir__}/test.log.*'
+  end
+end
+
+=begin
+% ruby example/rotate_process_safe_check.rb
+no warn!!!
+=end
+

data/spec/thread_safe/rotate_thread_safe_check.rb

@@ -0,0 +1,36 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'strftime_logger'
+require 'parallel'
+require 'timecop'
+require 'test/unit'
+
+Timecop.scale(24 * 60 * 60)
+
+$proc_num = 2
+$execute_num = 10000
+
+logger = StrftimeLogger.new("#{__dir__}/test.log.%Y%m%d")
+Parallel.map(['a', 'b'], :in_threads => $proc_num) do |letter|
+  $execute_num.times do
+  logger.info letter * 5000
+  end
+end
+
+$total_num = `LANG=C wc -l #{__dir__}/test.log.*`.split("\n").map(&:strip).grep(/\stotal\z/).first.split(' ').first.to_i
+p "Actually total line num #{$total_num}"
+p "Expected total line num #{$execute_num * $proc_num}"
+
+class StrftimeLoggerTC < Test::Unit::TestCase
+  def test_logger
+    assert_equal($execute_num * $proc_num, $total_num)
+  end
+  def teardown
+    p 'rm -rf #{__dir__}/test.log.*'
+  end
+end
+
+=begin
+% ruby example/rotate_thread_safe_check.rb
+no warn!!!
+=end

data/spec/thread_safe/thread_safe_check.rb

@@ -0,0 +1,14 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'strftime_logger'
+require 'parallel'
+
+logger = StrftimeLogger.new("#{__dir__}/test.log")
+Parallel.map(['a', 'b'], :in_threads => 2) do |letter|
+  3000.times do
+    logger.info letter * 5000
+  end
+end
+
+# egrep -e 'ab' -e 'ba' test.log
+# これはまざらない

data/strftime_logger.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |gem|
+  gem.name          = "strftime_logger"
+  gem.version       = "0.0.1"
+  gem.authors       = ["Naotoshi Seo"]
+  gem.email         = ["seo.naotoshi@dena.jp"]
+  gem.description   = %q{A logger treats log rotation in strftime fashion}
+  gem.summary       = %q{A logger treats log rotation in strftime fashion.}
+  gem.homepage      = "https://github.com/sonots/strftime-logger"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: strftime_logger
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Naotoshi Seo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-01 00:00:00.000000000 Z
+dependencies: []
+description: A logger treats log rotation in strftime fashion
+email:
+- seo.naotoshi@dena.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/strftime_logger.rb
+- lib/strftime_logger/adapter/file.rb
+- lib/strftime_logger/bridge.rb
+- lib/strftime_logger/formatter.rb
+- lib/strftime_logger/ltsv_formatter.rb
+- spec/formatter_spec.rb
+- spec/ltsv_formatter_spec.rb
+- spec/spec_helper.rb
+- spec/strftime_logger_spec.rb
+- spec/thread_safe/process_safe_check.rb
+- spec/thread_safe/rotate_process_safe_check.rb
+- spec/thread_safe/rotate_thread_safe_check.rb
+- spec/thread_safe/thread_safe_check.rb
+- strftime_logger.gemspec
+homepage: https://github.com/sonots/strftime-logger
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A logger treats log rotation in strftime fashion.
+test_files:
+- spec/formatter_spec.rb
+- spec/ltsv_formatter_spec.rb
+- spec/spec_helper.rb
+- spec/strftime_logger_spec.rb
+- spec/thread_safe/process_safe_check.rb
+- spec/thread_safe/rotate_process_safe_check.rb
+- spec/thread_safe/rotate_thread_safe_check.rb
+- spec/thread_safe/thread_safe_check.rb