serverengine 1.5.5 → 1.5.6

data/.rspec

@@ -0,0 +1,2 @@
+--require spec_helper
+

data/.travis.yml

@@ -3,7 +3,6 @@ language: ruby
 rvm:
   - 1.9.3
   - 2.0.0
-  - rbx-19mode
 
 branches:
   only:

data/Changelog

@@ -1,4 +1,10 @@
 
+2013-10-20 version 1.5.6:
+
+* Fixed log rotation in worker_type=process mode [#9]
+* DaemonLogger supports 'trace' level
+
+
 2013-09-17 version 1.5.5:
 
 * worker_type=thread and embedded show uncaught errors caused in Worker#stop

data/README.md

@@ -57,33 +57,35 @@ se = ServerEngine.create(nil, MyWorker, {
 se.run
 ```
 
-Send `TERM` signal to kill the daemon. See also **Signals** section bellow.
+Send `TERM` signal to kill the daemon. See also **Signals** section bellow for details.
 
 
 ### Multiprocess server
 
-Simply set **process** or **thread** to `worker_type` parameter and number of workers to `workers` parameter.
+Simply set **worker_type=process** or **worker_type=thread** parameter, and set number of workers to `workers` parameter.
 
 ```ruby
 se = ServerEngine.create(nil, MyWorker, {
   :daemonize => true,
   :log => 'myserver.log',
   :pid_path => 'myserver.pid',
-  :workers => 4,
   :worker_type => 'process',
+  :workers => 4,
 })
 se.run
 ```
 
 See also **Worker types** section bellow.
 
-#### Multiprocess TCP server
 
-One of typical implementation styles of TCP servers is that a parent process listens socket and child processes accept connections from clients.
+### Multiprocess TCP server
+
+One of the typical implementation styles of TCP servers is that a parent process listens socket and child processes accept connections from clients.
 
-You can optionally implement a server module to control the parent process.
+ServerEngine allows you to optionally implement a server module to control the parent process:
 
 ```ruby
+# Server module controls the parent process
 module MyServer
   def before_run
     @sock = TCPServer.new(config[:bind], config[:port])
@@ -92,6 +94,7 @@ module MyServer
   attr_reader :sock
 end
 
+# Worker module controls child processes
 module MyWorker
   def run
     until @stop
@@ -111,8 +114,8 @@ se = ServerEngine.create(MyServer, MyWorker, {
   :daemonize => true,
   :log => 'myserver.log',
   :pid_path => 'myserver.pid',
-  :workers => 4,
   :worker_type => 'process',
+  :workers => 4,
   :bind => '0.0.0.0',
   :port => 9071,
 })
@@ -141,7 +144,7 @@ See also **Configuration** section bellow.
 
 Server programs running 24x7 hours need to survive even if a process stalled because of unexpected memory swapping or network errors.
 
-Supervisor automatically reboots the server process if heartbeat breaks out.
+Supervisor process runs as the parent process of the server process and monitor it to restart automatically.
 
 ```ruby
 se = ServerEngine.create(nil, MyWorker, {
@@ -152,10 +155,11 @@ se = ServerEngine.create(nil, MyWorker, {
 se.run
 ```
 
+
 ### Live restart
 
-You can restart a server process without waiting for completion of shutdown process (if `supervisor` and `enable_detach` parameters are enabled).
-This feature is useful to minimize downtime where workers take long time to complete tasks.
+You can restart a server process without waiting for completion of all workers using `INT` signal (`supervisor=true` and `enable_detach=true` parameters must be enabled).
+This feature allows you to minimize downtime where workers take long time to complete a task.
 
 ```
 # 1. starts server
@@ -187,7 +191,7 @@ This feature is useful to minimize downtime where workers take long time to comp
                   +----------+    +-----------+
 ```
 
-Note that network servers (which listen sockets) shouldn't use live restart because it causes "Address already in use" error. Instead, simply use `worker_type=process` configuration and send `USR1` to restart only workers. USR1 signal doesn't restart server (by default. See also `restart_server_process` parameter). Restarting workers don't wait for completion of all running workers.
+Note that network servers (which listen sockets) shouldn't use live restart because it causes "Address already in use" error at the server process. Instead, simply use `worker_type=process` configuration and send `USR1` to restart workers instead of the server. It restarts a worker without waiting for shutdown of the other workers. This way doesn't cause downtime because server process doesn't close listening sockets and keeps accepting new clients (See also `restart_server_process` parameter if necessary).
 
 
 ### Dynamic configuration reloading
@@ -322,43 +326,43 @@ Graceful shutdown and restart call `Worker#stop` method and wait for completion
 ## Configuration
 
 - Daemon
-  - **daemonize** enables daemonize (default: false) (not dynamic reloadable)
-  - **pid_path** sets the path to pid file (default: don't create pid file) (not dynamic reloadable)
-  - **supervisor** enables supervisor if it's true (default: false) (not dynamic reloadable)
-  - **daemon_process_name** changes process name ($0) of server or supervisor process (not dynamic reloadable)
-  - **chuser** changes execution user (not dynamic reloadable)
-  - **chgroup** changes execution group (not dynamic reloadable)
-  - **chumask** changes umask (not dynamic reloadable)
-  - **daemonize_error_exit_code** exit code when daemonize, changing user or changing group fails (default: 1) (not dynamic reloadable)
+  - **daemonize** enables daemonize (default: false)
+  - **pid_path** sets the path to pid file (default: don't create pid file)
+  - **supervisor** enables supervisor if it's true (default: false)
+  - **daemon_process_name** changes process name ($0) of server or supervisor process
+  - **chuser** changes execution user
+  - **chgroup** changes execution group
+  - **chumask** changes umask
+  - **daemonize_error_exit_code** exit code when daemonize, changing user or changing group fails (default: 1)
 - Supervisor: available only when `supervisor` parameters is true
-  - **server_process_name** changes process name ($0) of server process (not dynamic reloadable)
-  - **restart_server_process** restarts server process when it receives USR1 or HUP signal. (default: false) (not dynamic reloadable)
-  - **enable_detach** enables INT signal (default: true) (not dynamic reloadable)
-  - **exit_on_detach** exits supervisor after detaching server process instead of restarting it (default: false) (not dynamic reloadable)
-  - **disable_reload** disables USR2 signal (default: false) (not dynamic reloadable)
-  - **server_restart_wait** sets wait time before restarting server after last restarting (default: 1.0)
-  - **server_detach_wait** sets wait time before starting live restart (default: 10.0)
+  - **server_process_name** changes process name ($0) of server process
+  - **restart_server_process** restarts server process when it receives USR1 or HUP signal. (default: false)
+  - **enable_detach** enables INT signal (default: true)
+  - **exit_on_detach** exits supervisor after detaching server process instead of restarting it (default: false)
+  - **disable_reload** disables USR2 signal (default: false)
+  - **server_restart_wait** sets wait time before restarting server after last restarting (default: 1.0) [dynamic reloadable]
+  - **server_detach_wait** sets wait time before starting live restart (default: 10.0) [dynamic reloadable]
 - Multithread server and multiprocess server: available only when `worker_type` is thread or process
-  - **workers** sets number of workers (default: 1)
-  - **start_worker_delay** sets wait time before starting a new worker (default: 0)
-  - **start_worker_delay_rand** randomizes start_worker_delay at this ratio (default: 0.2)
-- Multiprocess server: available only when `worker_type` is "process"
-  - **worker_process_name** changes process name ($0) of workers
-  - **worker_heartbeat_interval** sets interval of heartbeats in seconds (default: 1.0)
-  - **worker_heartbeat_timeout** sets timeout of heartbeat in seconds (default: 180)
-  - **worker_graceful_kill_interval** sets the first interval of TERM signals in seconds (default: 15)
-  - **worker_graceful_kill_interval_increment** sets increment of TERM signal interval in seconds (default: 10)
-  - **worker_graceful_kill_timeout** sets promotion timeout from TERM to QUIT signal in seconds. -1 means no timeout (default: 600)
-  - **worker_immediate_kill_interval** sets the first interval of QUIT signals in seconds (default: 10)
-  - **worker_immediate_kill_interval_increment** sets increment of QUIT signal interval in seconds (default: 10)
-  - **worker_immediate_kill_timeout** sets promotion timeout from QUIT to KILL signal in seconds. -1 means no timeout (default: 600)
+  - **workers** sets number of workers (default: 1) [dynamic reloadable]
+  - **start_worker_delay** sets wait time before starting a new worker (default: 0) [dynamic reloadable]
+  - **start_worker_delay_rand** randomizes start_worker_delay at this ratio (default: 0.2) [dynamic reloadable]
+- Multiprocess server: available only when `worker_type` is "process" [dynamic reloadable]
+  - **worker_process_name** changes process name ($0) of workers [dynamic reloadable]
+  - **worker_heartbeat_interval** sets interval of heartbeats in seconds (default: 1.0) [dynamic reloadable]
+  - **worker_heartbeat_timeout** sets timeout of heartbeat in seconds (default: 180) [dynamic reloadable]
+  - **worker_graceful_kill_interval** sets the first interval of TERM signals in seconds (default: 15) [dynamic reloadable]
+  - **worker_graceful_kill_interval_increment** sets increment of TERM signal interval in seconds (default: 10) [dynamic reloadable]
+  - **worker_graceful_kill_timeout** sets promotion timeout from TERM to QUIT signal in seconds. -1 means no timeout (default: 600) [dynamic reloadable]
+  - **worker_immediate_kill_interval** sets the first interval of QUIT signals in seconds (default: 10) [dynamic reloadable]
+  - **worker_immediate_kill_interval_increment** sets increment of QUIT signal interval in seconds (default: 10) [dynamic reloadable]
+  - **worker_immediate_kill_timeout** sets promotion timeout from QUIT to KILL signal in seconds. -1 means no timeout (default: 600) [dynamic reloadable]
 - Logger
-  - **log** sets path to log file. Set "-" for STDOUT (default: STDERR)
-  - **log_level** log level: debug, info, warn, error or fatal. (default: debug)
-  - **log_rotate_age** generations to keep rotated log files (default: 5) (not dynamic reloadable)
-  - **log_rotate_size** sets the size to rotate log files (default: 1048576) (not dynamic reloadable)
-  - **log_stdout** hooks STDOUT to log file (default: true) (not dynamic reloadable)
-  - **log_stderr** hooks STDERR to log file (default: true) (not dynamic reloadable)
+  - **log** sets path to log file. Set "-" for STDOUT (default: STDERR) [dynamic reloadable]
+  - **log_level** log level: trace, debug, info, warn, error or fatal. (default: debug) [dynamic reloadable]
+  - **log_rotate_age** generations to keep rotated log files (default: 5)
+  - **log_rotate_size** sets the size to rotate log files (default: 1048576)
+  - **log_stdout** hooks STDOUT to log file (default: true)
+  - **log_stderr** hooks STDERR to log file (default: true)
   - **logger_class** class of the logger instance (default: ServerEngine::DaemonLogger)
 
 ---

data/Rakefile

@@ -8,7 +8,6 @@ require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec) do |t|
   t.fail_on_error = false
-  t.rspec_opts = %w[-rspec_helper]
 end
 
 task :default => [:spec, :build]

data/lib/serverengine/config_loader.rb

@@ -40,20 +40,13 @@ module ServerEngine
 
       @logger_class = @config[:logger_class] || DaemonLogger
 
-      case c = @config[:log]
-      when nil  # default
-        @log_dev = STDERR
-      when "-"
-        @log_dev = STDOUT
-      else
-        @log_dev = c
-      end
-
       if @logger
-        if @log_dev.is_a?(String)
-          @logger.path = @log_dev
+        logdev = logdev_from_config(@config)
+        unless logdev.is_a?(IO)
+          # Here doesn't allow to change logdev to IO dynamically
+          # because Server#start_io_logging_thread can't follow it.
+          @logger.logdev = io
         end
-
         @logger.level = @config[:log_level] || 'debug'
       end
 
@@ -68,7 +61,18 @@ module ServerEngine
         return
       end
 
-      @logger = @logger_class.new(@log_dev, @config)
+      @logger = @logger_class.new(logdev_from_config(@config), @config)
+    end
+
+    def logdev_from_config(config)
+      case c = @config[:log]
+      when nil  # default
+        return STDERR
+      when "-"
+        return STDOUT
+      else
+        return c
+      end
     end
   end
 

data/lib/serverengine/daemon_logger.rb

@@ -20,42 +20,74 @@ module ServerEngine
   require 'logger'
 
   class DaemonLogger < Logger
-    def initialize(dev, config={})
-      @hook_stdout = config.fetch(:log_stdout, true)
-      @hook_stderr = config.fetch(:log_stderr, true)
+    def initialize(logdev, config={})
       rotate_age = config[:log_rotate_age] || 5
       rotate_size = config[:log_rotate_size] || 1048576
 
-      if dev.is_a?(String)
-        @path = dev
-        @io = File.open(@path, "a")
-        @io.sync = true
+      @file_dev = MultiprocessFileLogDevice.new(nil,
+        shift_age: rotate_age, shift_size: rotate_size)
+
+      super(nil)
+
+      self.level = config[:log_level] || 'debug'
+      self.logdev = logdev
+    end
+
+    def logdev=(logdev)
+      # overwrites Logger's @logdev variable
+      if logdev.respond_to?(:write) and logdev.respond_to?(:close)
+        # IO
+        @logdev = logdev
+        @logdev.sync = true if @logdev.respond_to?(:sync=)
+        @file_dev.path = nil
       else
-        @io = dev
+        # path string
+        @file_dev.path = logdev
+        @logdev = @file_dev
       end
+      logdev
+    end
 
-      hook_stdout! if @hook_stdout
-      hook_stderr! if @hook_stderr
-
-      super(@io, rotate_age, rotate_size)
+    # override add method
+    def add(severity, message = nil, progname = nil, &block)
+      if severity < @level
+        return true
+      end
+      if message.nil?
+        if block_given?
+          message = yield
+        else
+          message = progname
+          progname = nil
+        end
+      end
+      progname ||= @progname
+      self << format_message(SEVERITY_FORMATS_[severity+1], Time.now, progname, message)
+      true
+    end
 
-      self.level = config[:log_level] || 'debug'
+    module Severity
+      include Logger::Severity
+      TRACE = -1
     end
+    include Severity
 
-    attr_accessor :path
+    SEVERITY_FORMATS_ = %w(TRACE DEBUG INFO WARN ERROR FATAL ANY)
 
     def level=(expr)
       case expr.to_s
-      when 'fatal', Logger::FATAL.to_s
-        e = Logger::FATAL
-      when 'error', Logger::ERROR.to_s
-        e = Logger::ERROR
-      when 'warn', Logger::WARN.to_s
-        e = Logger::WARN
-      when 'info', Logger::INFO.to_s
-        e = Logger::INFO
-      when 'debug', Logger::DEBUG.to_s
-        e = Logger::DEBUG
+      when 'fatal', FATAL.to_s
+        e = FATAL
+      when 'error', ERROR.to_s
+        e = ERROR
+      when 'warn', WARN.to_s
+        e = WARN
+      when 'info', INFO.to_s
+        e = INFO
+      when 'debug', DEBUG.to_s
+        e = DEBUG
+      when 'trace', TRACE.to_s
+        e = TRACE
       else
         raise ArgumentError, "invalid log level: #{expr}"
       end
@@ -63,29 +95,10 @@ module ServerEngine
       super(e)
     end
 
-    def hook_stdout!
-      STDOUT.sync = true
-      @hook_stdout = true
-
-      STDOUT.reopen(@io) if @io != STDOUT
-      self
-    end
-
-    def hook_stderr!
-      STDERR.sync = true
-      @hook_stderr = true
-
-      STDERR.reopen(@io) if @io != STDERR
-      self
-    end
+    def trace?; @level <= TRACE; end
 
     def reopen!
-      if @path
-        @io.reopen(@path, "a")
-        @io.sync = true
-        hook_stdout! if @hook_stdout
-        hook_stderr! if @hook_stderr
-      end
+      @file_dev.reopen!
       nil
     end
 
@@ -100,11 +113,139 @@ module ServerEngine
     end
 
     def close
-      if @path
-        @io.close unless @io.closed?
-      end
+      @file_dev.close
       nil
     end
+
+    class MultiprocessFileLogDevice
+      def initialize(path, opts={})
+        @shift_age = opts[:shift_age] || 7
+        @shift_size = opts[:shift_size] || 1024*1024
+        @mutex = Mutex.new
+        self.path = path
+      end
+
+      def write(data)
+        # it's hard to remove this synchronize because IO#write raises
+        # Errno::ENOENT if IO#reopen is running concurrently.
+        @mutex.synchronize do
+          unless @file
+            return nil
+          end
+          log_rotate_or_reopen
+          @file.write(data)
+        end
+      rescue Exception => e
+        warn "log writing failed: #{e}"
+      end
+
+      def path=(path)
+        @mutex.synchronize do
+          old_file = @file
+          file = open_logfile(path)
+          begin
+            @file = file
+            @path = path
+            file = old_file
+          ensure
+            file.close if file
+          end
+        end
+        return path
+      end
+
+      def close
+        @mutex.synchronize do
+          @file.close
+          @file = nil
+        end
+        nil
+      end
+
+      attr_reader :path
+
+      def reopen!
+        @mutex.synchronize do
+          if @file
+            @file.reopen(@path, 'a')
+            @file.sync = true
+          end
+        end
+        true
+      end
+
+      # for compatibility with Logger::LogDevice
+      def dev
+        @file
+      end
+
+      # for compatibility with Logger::LogDevice
+      def filename
+        @path
+      end
+
+      private
+
+      def open_logfile(path)
+        return nil unless path
+        file = File.open(path, 'a')
+        file.sync = true
+        return file
+      end
+
+      def log_rotate_or_reopen
+        stat = @file.stat
+        if stat.size <= @shift_size
+          return
+        end
+
+        # inter-process locking
+        retry_limit = 8
+        retry_sleep = 0.1
+        begin
+          # 1) other process is log-rotating now
+          # 2) other process log rotated
+          # 3) no active processes
+          lock = File.open(@path, File::WRONLY | File::APPEND)
+          begin
+            lock.flock(File::LOCK_EX)
+            ino = lock.stat.ino
+            if ino == File.stat(@path).ino
+              # 3)
+              log_rotate
+            else
+              reopen!
+            end
+          rescue
+            lock.close
+          end
+        rescue Errno::ENOENT => e
+          raise e if retry_limit <= 0
+          sleep retry_sleep
+          retry_limit -= 1
+          retry_sleep *= 2
+          retry
+        end
+
+      rescue => e
+        warn "log rotation inter-process lock failed: #{e}"
+      end
+
+      def log_rotate
+        (@shift_age-2).downto(0) do |i|
+          old_path = "#{@path}.#{i}"
+          shift_path = "#{@path}.#{i+1}"
+          if FileTest.exist?(old_path)
+            File.rename(old_path, shift_path)
+          end
+        end
+        File.rename(@path, "#{@path}.0")
+        @file.reopen(@path, 'a')
+        @file.sync = true
+      rescue => e
+        warn "log rotation failed: #{e}"
+      end
+    end
   end
 
 end

data/lib/serverengine/server.rb

@@ -26,6 +26,11 @@ module ServerEngine
       @stop = false
 
       super(load_config_proc, &block)
+
+      @log_stdout = !!@config.fetch(:log_stdout, true)
+      @log_stderr = !!@config.fetch(:log_stderr, true)
+      @log_stdout = false if logdev_from_config(@config) == STDOUT
+      @log_stderr = false if logdev_from_config(@config) == STDERR
     end
 
     def before_run
@@ -70,6 +75,10 @@ module ServerEngine
     def main
       create_logger unless @logger
 
+      # start threads to transfer logs from STDOUT/ERR to the logger
+      start_io_logging_thread(STDOUT) if @log_stdout
+      start_io_logging_thread(STDERR) if @log_stderr
+
       before_run
 
       begin
@@ -93,6 +102,22 @@ module ServerEngine
       w.instance_eval { initialize }
       w
     end
+
+    def start_io_logging_thread(io)
+      r, w = IO.pipe
+      io.reopen(w)
+      w.close
+
+      Thread.new do
+        begin
+          while line = r.gets
+            @logger << line
+          end
+        rescue => e
+          ServerEngine.dump_uncaught_error(e)
+        end
+      end
+    end
   end
 
 end

data/lib/serverengine/version.rb

@@ -1,3 +1,3 @@
 module ServerEngine
-  VERSION = "1.5.5"
+  VERSION = "1.5.6"
 end

data/spec/daemon_logger_spec.rb

@@ -1,40 +1,26 @@
+require 'stringio'
 
 describe ServerEngine::DaemonLogger do
   before { FileUtils.mkdir_p("tmp") }
   before { FileUtils.rm_f("tmp/se1.log") }
+  before { FileUtils.rm_f Dir["tmp/se1.log.**"] }
   before { FileUtils.rm_f("tmp/se2.log") }
 
-  subject { DaemonLogger.new("tmp/se1.log", log_stdout: false, log_stderr: false) }
+  subject { DaemonLogger.new("tmp/se1.log", level: 'trace') }
 
   it 'reopen' do
-    subject.path = 'tmp/se2.log'
-    subject.reopen!
-    subject.warn "test"
-
-    File.read('tmp/se2.log').should =~ /test$/
-  end
-
-  it 'stderr hook 1' do
-    subject.hook_stderr!
-    STDERR.puts "test"
-
-    File.read('tmp/se1.log').should == "test\n"
-  end
+    subject.warn "ABCDEF"
+    File.open('tmp/se1.log', "w") {|f| }
+    subject.warn "test2"
 
-  it 'stderr hook 2' do
-    log = DaemonLogger.new("tmp/se1.log", log_stdout: false, log_stderr: true)
-    STDERR.puts "test"
-
-    File.read('tmp/se1.log').should == "test\n"
+    File.read('tmp/se1.log').should_not =~ /ABCDEF/
   end
 
-  it 'stderr hook and reopen' do
-    subject.hook_stderr!
-    subject.path = 'tmp/se2.log'
-    subject.reopen!
-    STDERR.puts "test"
+  it 'reset path' do
+    subject.logdev = 'tmp/se2.log'
+    subject.warn "test"
 
-    File.read('tmp/se2.log').should == "test\n"
+    File.read('tmp/se2.log').should =~ /test$/
   end
 
   it 'default level is debug' do
@@ -45,18 +31,57 @@ describe ServerEngine::DaemonLogger do
   it 'level set by int' do
     subject.level = Logger::FATAL
     subject.level.should == Logger::FATAL
+    subject.trace?.should == false
+    subject.debug?.should == false
+    subject.info?.should  == false
+    subject.warn?.should  == false
+    subject.error?.should == false
+    subject.fatal?.should == true
 
     subject.level = Logger::ERROR
     subject.level.should == Logger::ERROR
+    subject.trace?.should == false
+    subject.debug?.should == false
+    subject.info?.should  == false
+    subject.warn?.should  == false
+    subject.error?.should == true
+    subject.fatal?.should == true
 
     subject.level = Logger::WARN
     subject.level.should == Logger::WARN
+    subject.trace?.should == false
+    subject.debug?.should == false
+    subject.info?.should  == false
+    subject.warn?.should  == true
+    subject.error?.should == true
+    subject.fatal?.should == true
 
     subject.level = Logger::INFO
     subject.level.should == Logger::INFO
+    subject.trace?.should == false
+    subject.debug?.should == false
+    subject.info?.should  == true
+    subject.warn?.should  == true
+    subject.error?.should == true
+    subject.fatal?.should == true
 
     subject.level = Logger::DEBUG
     subject.level.should == Logger::DEBUG
+    subject.trace?.should == false
+    subject.debug?.should == true
+    subject.info?.should  == true
+    subject.warn?.should  == true
+    subject.error?.should == true
+    subject.fatal?.should == true
+
+    subject.level = DaemonLogger::TRACE
+    subject.level.should == DaemonLogger::TRACE
+    subject.trace?.should == true
+    subject.debug?.should == true
+    subject.info?.should  == true
+    subject.warn?.should  == true
+    subject.error?.should == true
+    subject.fatal?.should == true
   end
 
   it 'level set by string' do
@@ -74,15 +99,43 @@ describe ServerEngine::DaemonLogger do
 
     subject.level = 'debug'
     subject.level.should == Logger::DEBUG
+
+    subject.level = 'trace'
+    subject.level.should == DaemonLogger::TRACE
   end
 
   it 'unknown level' do
     lambda { subject.level = 'unknown' }.should raise_error(ArgumentError)
   end
 
-  it 'stdout logger' do
-    STDOUT.should_not_receive(:reopen)
-    log = DaemonLogger.new(STDOUT)
+  it 'rotation' do
+    log = DaemonLogger.new("tmp/se1.log", level: 'trace', log_rotate_age: 3, log_rotate_size: 10)
+    log.warn "test1"
+    File.exist?("tmp/se1.log").should == true
+    File.exist?("tmp/se1.log.0").should == false
+
+    log.warn "test2"
+    File.exist?("tmp/se1.log").should == true
+    File.exist?("tmp/se1.log.0").should == true
+    File.read("tmp/se1.log.0") =~ /test2$/
+
+    log.warn "test3"
+    log.warn "test4"
+    File.exist?("tmp/se1.log").should == true
+    File.exist?("tmp/se1.log.2").should == true
+    File.exist?("tmp/se1.log.3").should == false
+
+    log.warn "test5"
+    File.read("tmp/se1.log.0") =~ /test5$/
+  end
+
+  it 'IO logger' do
+    io = StringIO.new
+    io.should_receive(:write)
+    io.should_not_receive(:reopen)
+
+    log = DaemonLogger.new(io)
     log.debug "stdout logging test"
+    log.reopen!
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: serverengine
 version: !ruby/object:Gem::Version
-  version: 1.5.5
+  version: 1.5.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-17 00:00:00.000000000 Z
+date: 2013-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sigdump
@@ -67,6 +67,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
 - .travis.yml
 - Changelog
 - Gemfile
@@ -118,6 +119,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -2266789879425924886
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -133,4 +137,3 @@ test_files:
 - spec/signal_thread_spec.rb
 - spec/spec_helper.rb
 - spec/supervisor_spec.rb
-has_rdoc: false