kennethkalmer-daemon-kit 0.1.7.4 → 0.1.7.5

data/Configuration.txt

@@ -29,6 +29,7 @@ DaemonKit includes a couple of its own arguments that can be used:
 
   -e ENV (or --env ENV) to set the daemon environment
   --pid /path/to/pidfile to set the path to a pidfile
+  -l path (or --log path) to set the path for the log file
   -v shows the DaemonKit version
   -h shows a useful help message
 

data/Deployment.txt

@@ -0,0 +1,113 @@
+= Deploying your daemons
+
+daemon-kit provides built-in support for
+Capistrano[http://www.capify.org] deployments, using a customized
+version of the standard 'deploy' recipe for Ruby on Rails
+applications.
+
+User of Vlad[http://hitsquad.rubyforge.org/vlad/]? Get in touch so we
+can discuss your contribution to daemon-kit ;)
+
+== Generating capistrano configurations
+
+When generating a new daemon, you can pass the <em>-d capistrano</em>
+argument to the <em>daemon_kit</em> command. In case you already have
+a generated daemon, run the following command inside your project:
+
+  $ ruby script/generate deploy_capistrano
+
+== Overview of generated configurations
+
+The generator creates the following files worth noticing:
+
+  config/deploy.rb
+  config/deploy/*.rb
+
+The generator also creates a new environment for you, a
+<em>staging</em> environment. Useful for testing your deployments
+before taking anything into production.
+
+== Configuring capistrano
+
+For each environment (staging & production) you only need to specify
+the target hosts in <em>config/deploy/(staging|production).rb</em>.
+
+Each of the stub files have example configuration values you can just
+edit.
+
+The rest of your configuration generally occurs in
+<em>config/deploy.rb</em>.
+
+Everything works exactly like standard capistrano, with the exception
+of the following directives:
+
+* :config_files
+* :shared_children
+
+=== :config_files
+
+Since the daemon configuration files will almost always differ between
+your development environment and your staging/production environment,
+the deployment recipe makes adequate provision for this.
+
+Use the :config_files directive to set an array of file names from the
+<em>config</em> directory that you want replaced with production
+configuration files found on the server:
+
+  set :config_files, %w{ amqp.yaml }
+
+On your target server, in the <em>:deploy_to</em> folder, create a
+<em>config</em> directory and place your configuration files in
+there. One each deploy, capistrano will rename the files in your
+deployed configuration directory with a <em>.orig</em> extension, and copy
+the files from <em>:deploy_to/config</em> into the newly deployed
+release.
+
+This makes it easy to keep production configurations out of your
+working directories or version control systems.
+
+=== :shared_children
+
+The original capistrano recipe that daemon-kit's recipe is built from
+provided support for tracking shared directories between
+deployments. This works by removing the deployed directory, and
+creating a symlink from <em>:deploy_to/shared/</em> into the correct
+location within the deployed release.
+
+You specify your list of directories with the
+<em>:shared_children</em>, each being relative to the DAEMON_ROOT.
+
+  set :shared_children, %w{ log }
+
+The daemon-kit deployment recipe makes no assumptions on shared
+directories, and gives you full control. The default only includes the
+log directory, which you can remove if you want separate log
+directories for each deployed release.
+
+== Remote dependencies
+
+By default, the deployment configuration file is configured to check
+the remote dependencies before updating the code on the target
+host. You can disable this behaviour by commenting out the following
+line:
+
+  before "deploy:update_code", "deploy:check"
+
+The only default remote dependency is the daemon-kit gem, and it will
+check for the same version you currently have installed (or a later
+one).
+
+== More capistrano resources
+
+To see a list of available commands, please run the following command
+in the root of your project:
+
+  $ cap -vT
+
+For more information on capistrano, please refer to the following list
+of online resources:
+
+* Capistrano Website[http://www.capify.org]
+* Capistrano Wiki[http://wiki.capify.org]
+* Capistrano Group[http://groups.google.com/group/capistrano]
+* #capistrano on Freenode

data/History.txt

@@ -1,5 +1,13 @@
-== 0.1.7.4 (Not released)
+== 0.1.7.5 2009-06-08
 
+* New AbstractLogger
+** Default Logger backend
+** SysLogLogger support
+* More documentation
+
+== 0.1.7.4 2009-06-05
+
+* Fixed bug with control script generator (thanks Sho Fukamachi)
 * Enhanced deploy.rb template to check for current dk gem verion,
   unless vendored
 * Fix bug in capistrano recipe for restarting daemons

data/Logging.txt

@@ -0,0 +1,92 @@
+= Logging from inside your daemon
+
+Proper logging inside your daemon process is critical, and daemon-kit
+provides you with a great logging facility to (ab)use.
+
+== Logging examples
+
+From anywhere in your code you can access the
+<em>DaemonKit.logger</em> instance, which is a configured
+DaemonKit::AbstractLogger. It is compatible with Ruby's Logger class
+but is much more verbose to help you gain some insight into your
+running process.
+
+  DaemonKit.logger.info( "Hello world" )
+
+This logs a 'Hello world' line to the log file, complete with the
+calling file name and line number. Log lines look something like this:
+
+  2009-06-07 23:21:30.248575 capd(32513) [INFO] initializer.rb:91: DaemonKit (0.1.7.4) booted, now running capd
+
+Log as much as you can, but be careful not to abuse the <em>info</em>
+level since your log files can become huge. For general processing
+hints, use the <em>debug</em> level.
+
+To log exceptions, use the special <em>exception</em> helper:
+
+  begin
+    # dangerous operation
+  rescue => e
+    DaemonKit.logger.exception( e )
+  end
+
+== Controlling logging in a running process
+
+Logging can be controlled in a running process, either via code or by
+sending UNIX signals to the running process.
+
+=== Changing log levels in your code
+
+Log levels can be toggled with the <em>level=</em> method:
+
+  DaemonKit.logger.level = :info
+
+Alternatively you can silence all the logging activity for a while
+using the silence helper:
+
+  DaemonKit.logger.silence do |logger|
+    # logger will only report :error or higher levels
+  end
+
+=== Changing log levels via UNIX signals
+
+Send your process the +USR1+ signal to toggle between <em>:debug</em>
+and <em>:info</em> log levels. Sending a +USR2+ signal will force the
+logger into <em>:debug</em> mode (+USR1+ will revert).
+
+== Support for log rotation
+
+Support for logrotate is baked right into daemon-kit. By sending your
+daemon a +HUP+ signal all the log files file be closed and re-opened
+again on first use. Here is an example logrotate configuration:
+
+  /path/to/daemon.log {
+    rotate 5
+    weekly
+    postrotate
+      kill -HUP `cat /path/to/daemon.pid`
+    endscript
+  }
+
+== Support for syslog logging
+
+If you have the
+SyslogLogger[http://seattlerb.rubyforge.org/SyslogLogger/] gem
+installed, you can have your process log to a UNIX syslog server. You
+can change the logging to syslog by either updating your
+<em>environment.rb</em> file like this:
+
+  config.log_path = :syslog
+
+Or by passing 'syslog' as the logfile argument when starting a daemon
+
+  $ ruby ./bin/daemon start -l syslog
+
+The SyslogLogger rdoc's provide configuration examples for configuring
+various UNIX syslog servers.
+
+== More logging information
+
+If you're running your daemon in the foreground (with the <em>run</em>
+command, you'll get copies of all the log messages on STDOUT, and thus
+voiding the need to tail log files the whole time.

data/Manifest.txt

@@ -1,5 +1,7 @@
 Configuration.txt
+Deployment.txt
 History.txt
+Logging.txt
 Manifest.txt
 PostInstall.txt
 README.rdoc
@@ -52,6 +54,7 @@ daemon_generators/nanite_agent/templates/config/nanite.yml
 daemon_generators/nanite_agent/templates/lib/actors/sample.rb
 daemon_generators/nanite_agent/templates/libexec/daemon.rb
 lib/daemon_kit.rb
+lib/daemon_kit/abstract_logger.rb
 lib/daemon_kit/amqp.rb
 lib/daemon_kit/application.rb
 lib/daemon_kit/arguments.rb
@@ -87,6 +90,7 @@ script/console
 script/destroy
 script/generate
 script/txt2html
+spec/abstract_logger_spec.rb
 spec/argument_spec.rb
 spec/config_spec.rb
 spec/daemon_kit_spec.rb

data/README.rdoc

@@ -21,7 +21,6 @@ Supported generators:
 
 * Build it
 * Review TODO.txt
-* Review Configuration.txt
 
 == Synopsis
 
@@ -80,6 +79,11 @@ Stable versions, when released are available directly from Rubyforge:
 
   $ gem install daemon-kit
 
+== Further reading
+
+* Configuration.txt
+* Deployment.txt
+
 == License
 
 (The MIT License)

data/lib/daemon_kit/abstract_logger.rb

@@ -0,0 +1,235 @@
+require 'logger'
+
+module DaemonKit
+  # One of the key parts of succesful background processes is adequate
+  # logging. The AbstractLogger aims to simplify logging from inside
+  # daemon processes by providing additional useful information with
+  # each log line, including calling file name and line number and
+  # support for cleanly logging exceptions.
+  #
+  # The logger can be accessed through #DaemonKit.logger.
+  #
+  # AbstractLogger provides an interface that is fully compatible with
+  # the Logger class provided by Ruby's Standard Library, and is
+  # extended with some additional conveniences.
+  #
+  # The AbstractLogger supports different backends, by default it uses
+  # a Logger instance, but can by swapped out for a SysLogLogger
+  # logger as well.
+  class AbstractLogger
+
+    attr_accessor :copy_to_stdout
+
+    @severities = {
+      :debug   => Logger::DEBUG,
+      :info    => Logger::INFO,
+      :warn    => Logger::WARN,
+      :error   => Logger::ERROR,
+      :fatal   => Logger::FATAL,
+      :unknown => Logger::UNKNOWN
+    }
+
+    @silencer = true
+
+    class << self
+      attr_reader :severities
+      attr_accessor :silencer
+    end
+
+    # Optional log path, defaults to
+    # <em>DAEMON_ROOT/log/DAEMON_ENV.log</em>
+    def initialize( log_path = nil )
+      if log_path.to_s == "syslog"
+        @backend = :syslog
+      else
+        @logger_file = log_path || "#{DAEMON_ROOT}/log/#{DAEMON_ENV}.log"
+        @backend = :logger
+      end
+
+      @copy_to_stdout = false
+    end
+
+    # Silence the logger for the duration of the block.
+    def silence( temporary_level = :error )
+      if self.class.silencer
+        begin
+          old_level, self.level = self.level, temporary_level
+          yield self
+        ensure
+          self.level = old_level
+        end
+      else
+        yield self
+      end
+    end
+
+    def debug( msg )
+      add( :debug, msg )
+    end
+
+    def debug?
+      self.level == :debug
+    end
+
+    def info( msg )
+      add( :info, msg )
+    end
+
+    def info?
+      self.level == :info
+    end
+
+    def warn( msg )
+      add( :warn, msg )
+    end
+
+    def warn?
+      self.level == :warn
+    end
+
+    def error( msg )
+      add( :error, msg )
+    end
+
+    def error?
+      self.level == :error
+    end
+
+    def fatal( msg )
+      add( :fatal, msg )
+    end
+
+    def fatal?
+      self.level == :fatal
+    end
+
+    def unknown( msg )
+      add( :unknown, msg )
+    end
+
+    def unknown?
+      self.level == :unknown
+    end
+
+    def exception( e )
+      message = "EXCEPTION: #{e.message}: #{clean_trace( e.backtrace )}"
+      self.add( :error, message, true )
+    end
+
+    def add( severity, message, skip_caller = false )
+      message = "#{called(caller)}: #{message}" unless skip_caller
+
+      self.logger.add( self.class.severities[ severity ] ) { message }
+
+      STDOUT.puts( message ) if self.copy_to_stdout
+    end
+
+    def level
+      self.class.severities.invert[ @logger.level ]
+    end
+
+    def level=( level )
+      level = ( Symbol === level ? self.class.severities[ level ] : level )
+      self.logger.level = level
+    end
+
+    def logger
+      @logger ||= create_logger
+    end
+
+    def logger=( logger )
+      if logger.is_a?( Symbol )
+        @backend = logger
+        @logger.close rescue nil
+        @logger = create_logger
+      else
+        @logger.close rescue nil
+        @logger = logger
+      end
+    end
+
+    def clean_trace( trace )
+      trace = trace.map { |l| l.gsub(DAEMON_ROOT, '') }
+      trace = trace.reject { |l| l =~ /gems\/daemon[\-_]kit/ }
+      trace = trace.reject { |l| l =~ /vendor\/daemon[\-_]kit/ }
+      trace
+    end
+
+    def close
+      case @backend
+      when :logger
+        self.logger.close
+        @logger = nil
+      end
+    end
+
+    private
+
+    def called( trace )
+      l = trace.detect('unknown:0') { |l| l.index('abstract_logger.rb').nil? }
+      file, num, _ = l.split(':')
+
+      [ File.basename(file), num ].join(':')
+    end
+
+    def create_logger
+      case @backend
+      when :logger
+        create_standard_logger
+      when :syslog
+        create_syslog_logger
+      end
+    end
+
+    def create_standard_logger
+      log_path = File.dirname( @logger_file )
+      unless File.directory?( log_path )
+        begin
+          FileUtils.mkdir_p( log_path )
+        rescue
+          STDERR.puts "#{log_path} not writable, using STDERR for logging"
+          @logger_file = STDERR
+        end
+      end
+
+      l = Logger.new( @logger_file )
+      l.formatter = Formatter.new
+      l.progname = if DaemonKit.configuration
+                     DaemonKit.configuration.daemon_name
+                   else
+                     File.basename($0)
+                   end
+      l
+    end
+
+    def create_syslog_logger
+      begin
+        require 'syslog_logger'
+        SyslogLogger.new( DaemonKit.configuration ? DaemonKit.configuration.daemon_name : File.basename($0) )
+      rescue LoadError
+        self.logger = :logger
+        self.error( "Couldn't load syslog_logger gem, reverting to standard logger" )
+      end
+    end
+
+    class Formatter
+
+      # YYYY:MM:DD HH:MM:SS.MS daemon_name(pid) level: message
+      @format = "%s %s(%d) [%s] %s\n"
+
+      class << self
+        attr_accessor :format
+      end
+
+      def call(severity, time, progname, msg)
+        self.class.format % [ format_time( time ), progname, $$, severity, msg.to_s ]
+      end
+
+      private
+
+      def format_time( time )
+        time.strftime( "%Y-%m-%d %H:%M:%S." ) + time.usec.to_s
+      end
+    end
+  end
+end

data/lib/daemon_kit/application.rb

@@ -33,6 +33,8 @@ module DaemonKit
         self.clean_fd
         self.redirect_io( true )
 
+        DaemonKit.configuration.log_stdout = true
+
         require file
       end
 

data/lib/daemon_kit/arguments.rb

@@ -58,6 +58,7 @@ module DaemonKit
       #
       #   -e value or --env value => environment
       #   --pid pidfile           => pid_file
+      #   -l path or --log path   => /path/to/log/file
       #
       def configuration( argv )
         configs = []
@@ -74,6 +75,11 @@ module DaemonKit
             configs << "environment=#{argv.delete_at(i)}"
           end
 
+          if argv[i] == "-l" || argv[i] == "--log"
+            argv.delete_at( i )
+            configs << "log_path=#{argv.delete_at(i)}"
+          end
+
           if argv[i] == "--pid"
             argv.delete_at( i )
             configs << "pid_file=#{argv.delete_at(i)}"
@@ -92,7 +98,7 @@ module DaemonKit
     end
 
     attr_reader :options
-    
+
     def initialize
       @options = {}
 
@@ -121,6 +127,10 @@ module DaemonKit
           # Nothing, just here for show
         end
 
+        opts.on("-l", "--log /path/to/logfile", "Path to the log file", "Defaults to log/[environment].log") do
+          # Nothing, just here for show
+        end
+
         opts.separator ""
         opts.separator "Advanced configurations:"
         opts.on("--config ATTRIBUTE=VALUE",

data/lib/daemon_kit/initializer.rb

@@ -1,4 +1,3 @@
-require 'logger'
 require 'pathname'
 
 DAEMON_ENV = (ENV['DAEMON_ENV'] || 'development').dup unless defined?(DAEMON_ENV)
@@ -135,8 +134,9 @@ module DaemonKit
       return if DaemonKit.logger
 
       unless logger = configuration.logger
-        logger = Logger.new( configuration.log_path )
+        logger = AbstractLogger.new( configuration.log_path )
         logger.level = configuration.log_level
+        logger.copy_to_stdout = configuration.log_stdout
       end
 
       DaemonKit.logger = logger
@@ -144,13 +144,16 @@ module DaemonKit
       DaemonKit.logger.info "DaemonKit (#{DaemonKit::VERSION}) booting in #{DAEMON_ENV} mode"
 
       configuration.trap("USR1") {
-        DaemonKit.logger.level = DaemonKit.logger.debug? ? Logger::INFO : Logger::DEBUG
+        DaemonKit.logger.level = DaemonKit.logger.debug? ? :info : :debug
         DaemonKit.logger.info "Log level changed to #{DaemonKit.logger.debug? ? 'DEBUG' : 'INFO' }"
       }
       configuration.trap("USR2") {
-        DaemonKit.logger.level = Logger::DEBUG
+        DaemonKit.logger.level = :debug
         DaemonKit.logger.info "Log level changed to DEBUG"
       }
+      configuration.trap("HUP") {
+        DaemonKit.logger.close
+      }
     end
 
     def initialize_signal_traps
@@ -178,14 +181,17 @@ module DaemonKit
     # List of load paths
     attr_accessor :load_paths
 
+    # Custom logger instance to use
+    attr_accessor :logger
+
     # The log level to use, defaults to DEBUG
     attr_accessor :log_level
 
     # Path to the log file, defaults to 'log/<environment>.log'
     attr_accessor :log_path
 
-    # Provide a custom logger to use
-    attr_accessor :logger
+    # Duplicate log data to stdout
+    attr_accessor :log_stdout
 
     # Path to the pid file, defaults to 'log/<daemon_name>.pid'
     attr_accessor :pid_file
@@ -209,8 +215,8 @@ module DaemonKit
       set_daemon_defaults!
 
       self.load_paths = default_load_paths
-      self.log_level  = default_log_level
-      self.log_path   = default_log_path
+      self.log_level  ||= default_log_level
+      self.log_path   ||= default_log_path
 
       self.force_kill_wait = false
 
@@ -299,21 +305,13 @@ module DaemonKit
       raise "DAEMON_ROOT is not a directory" unless File.directory?(::DAEMON_ROOT)
 
       @root_path = ::DAEMON_ROOT.to_absolute_path
-        # Pathname is incompatible with Windows, but Windows doesn't have
-        # real symlinks so File.expand_path is safe.
-        #if RUBY_PLATFORM =~ /(:?mswin|mingw)/
-        #  File.expand_path(::DAEMON_ROOT)
-
-        # Otherwise use Pathname#realpath which respects symlinks.
-        #else
-        #  File.expand_path( Pathname.new(::DAEMON_ROOT).realpath.to_s )
-        #end
 
       Object.const_set(:RELATIVE_DAEMON_ROOT, ::DAEMON_ROOT.dup) unless defined?(::RELATIVE_DAEMON_ROOT)
       ::DAEMON_ROOT.replace @root_path
     end
 
     def set_daemon_defaults!
+      self.log_stdout = false
     end
 
     def default_load_paths
@@ -325,7 +323,7 @@ module DaemonKit
     end
 
     def default_log_level
-      environment == 'production' ? Logger::INFO : Logger::DEBUG
+      environment == 'production' ? :info : :debug
     end
 
     def error( msg )

data/lib/daemon_kit.rb

@@ -7,19 +7,20 @@ $:.unshift( File.dirname(__FILE__).to_absolute_path ) unless
   $:.include?( File.dirname(__FILE__).to_absolute_path )
 
 module DaemonKit
-  VERSION = '0.1.7.4'
-
-  autoload :Initializer, 'daemon_kit/initializer'
-  autoload :Application, 'daemon_kit/application'
-  autoload :Arguments,   'daemon_kit/arguments'
-  autoload :Config,      'daemon_kit/config'
-  autoload :Safety,      'daemon_kit/safety'
-  autoload :PidFile,     'daemon_kit/pid_file'
-
-  autoload :Cron,        'daemon_kit/cron'
-  autoload :Jabber,      'daemon_kit/jabber'
-  autoload :AMQP,        'daemon_kit/amqp'
-  autoload :Nanite,      'daemon_kit/nanite'
+  VERSION = '0.1.7.5'
+
+  autoload :Initializer,    'daemon_kit/initializer'
+  autoload :Application,    'daemon_kit/application'
+  autoload :Arguments,      'daemon_kit/arguments'
+  autoload :Config,         'daemon_kit/config'
+  autoload :Safety,         'daemon_kit/safety'
+  autoload :PidFile,        'daemon_kit/pid_file'
+  autoload :AbstractLogger, 'daemon_kit/abstract_logger'
+
+  autoload :Cron,   'daemon_kit/cron'
+  autoload :Jabber, 'daemon_kit/jabber'
+  autoload :AMQP,   'daemon_kit/amqp'
+  autoload :Nanite, 'daemon_kit/nanite'
 
   class << self
     def logger

data/spec/abstract_logger_spec.rb

@@ -0,0 +1,126 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe DaemonKit::AbstractLogger do
+
+  before(:each) do
+    @log_file = "#{DAEMON_ROOT}/log/spec.log"
+    @logger = DaemonKit::AbstractLogger.new( @log_file )
+    @logger.level = :debug
+  end
+
+  it "should have a log level" do
+    @logger.level.should == :debug
+  end
+
+  it "should have a backend logger" do
+    @logger.logger.should_not be_nil
+  end
+
+  it "should accept a different backend" do
+    l = Logger.new('/dev/null')
+    @logger.logger = l
+    @logger.logger.should == l
+  end
+
+  it "should be able to log to STDOUT as well" do
+    @logger.copy_to_stdout = true
+
+    STDOUT.expects(:puts).with(regexp_matches(/test/))
+
+    @logger.debug "test"
+    IO.readlines( @log_file ).last.should match(/test/)
+  end
+
+  it "should log debug level messages" do
+    @logger.debug( "Debug test" )
+
+    IO.readlines( @log_file ).last.should match(/\[DEBUG\].*Debug test/)
+  end
+
+  it "should log info level messages" do
+    @logger.info( "Info test" )
+
+    IO.readlines( @log_file ).last.should match(/\[INFO\].*Info test/)
+  end
+
+  it "should log warn level messages" do
+    @logger.warn( "Warn test" )
+
+    IO.readlines( @log_file ).last.should match(/\[WARN\].*Warn test/)
+  end
+
+  it "should log error level messages" do
+    @logger.error( "Err test" )
+
+    IO.readlines( @log_file ).last.should match(/\[ERROR\].*Err test/)
+  end
+
+  it "should log fatal level messages" do
+    @logger.fatal( "Fatal test" )
+
+    IO.readlines( @log_file ).last.should match(/\[FATAL\].*Fatal test/)
+  end
+
+  it "should log unknown level messages" do
+    @logger.unknown( "Unknown test" )
+
+    IO.readlines( @log_file ).last.should match(/\[ANY\].*Unknown test/)
+  end
+
+  it "should log the caller file and line number" do
+    f = File.basename(__FILE__)
+    l = __LINE__ + 2
+
+    @logger.info( "Caller test" )
+
+    IO.readlines( @log_file ).last.should match(/#{f}:#{l}:/)
+  end
+
+  it "should log exceptions with daemon traces" do
+    fake_trace = [
+                  "/home/kenneth/daemon/libexec/daemon-daemon.rb:1:in `foo'",
+                  "/usr/lib/ruby/gems/1.8/gems/daemon-kit-0.0.1/lib/daemon_kit/abstract_logger.rb:49: in `info'"
+                 ]
+
+    e = RuntimeError.new( 'Test error' )
+    e.set_backtrace( fake_trace )
+
+    @logger.exception( e )
+
+    IO.readlines( @log_file ).last.should match(/EXCEPTION: Test error/)
+  end
+
+  it "should log exceptions without framework traces" do
+    fake_trace = [
+                  "/home/kenneth/daemon/libexec/daemon-daemon.rb:1:in `foo'",
+                  "/usr/lib/ruby/gems/1.8/gems/daemon-kit-0.0.1/lib/daemon_kit/abstract_logger.rb:49: in `info'"
+                 ]
+
+    clean_trace = @logger.clean_trace( fake_trace )
+
+    clean_trace.should include("/home/kenneth/daemon/libexec/daemon-daemon.rb:1:in `foo'")
+    clean_trace.should_not include("/usr/lib/ruby/gems/1.8/gems/daemon-kit-0.0.1/lib/daemon_kit/abstract_logger.rb:49: in `info'")
+  end
+
+  it "should support reopening log files" do
+    @logger.close
+
+    FileUtils.rm( @log_file )
+
+    @logger.info( 'Reopen')
+    IO.readlines( @log_file ).last.should match(/Reopen/)
+  end
+
+  it "should support silencing" do
+    @logger.silence do |logger|
+      logger.info "This should never be logged"
+    end
+
+    @logger.info "This should be logged"
+
+    log = IO.readlines( @log_file )
+
+    log.detect { |l| l =~ /This should never be logged/ }.should be_nil
+    log.detect { |l| l =~ /This should be logged/ }.should_not be_nil
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: kennethkalmer-daemon-kit
 version: !ruby/object:Gem::Version 
-  version: 0.1.7.4
+  version: 0.1.7.5
 platform: ruby
 authors: 
 - Kenneth Kalmer
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-05 00:00:00 -07:00
+date: 2009-06-08 00:00:00 -07:00
 default_executable: daemon_kit
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -51,14 +51,18 @@ extensions: []
 
 extra_rdoc_files: 
 - Configuration.txt
+- Deployment.txt
 - History.txt
+- Logging.txt
 - Manifest.txt
 - PostInstall.txt
 - README.rdoc
 - TODO.txt
 files: 
 - Configuration.txt
+- Deployment.txt
 - History.txt
+- Logging.txt
 - Manifest.txt
 - PostInstall.txt
 - README.rdoc
@@ -111,6 +115,7 @@ files:
 - daemon_generators/nanite_agent/templates/lib/actors/sample.rb
 - daemon_generators/nanite_agent/templates/libexec/daemon.rb
 - lib/daemon_kit.rb
+- lib/daemon_kit/abstract_logger.rb
 - lib/daemon_kit/amqp.rb
 - lib/daemon_kit/application.rb
 - lib/daemon_kit/arguments.rb
@@ -146,6 +151,7 @@ files:
 - script/destroy
 - script/generate
 - script/txt2html
+- spec/abstract_logger_spec.rb
 - spec/argument_spec.rb
 - spec/config_spec.rb
 - spec/daemon_kit_spec.rb