logging 0.7.0 → 0.7.1

data/History.txt

@@ -1,3 +1,11 @@
+== 0.7.1 / 2008-
+
+1 minor enhancement
+  - Removed dependency on the Lockfile gem (brought the ruby
+    file into the logging/stelan directory)
+1 bug fix
+  - Fixed bug with age based rolling: was not multi-process safe
+
 == 0.7.0 / 2008-02-12
 
 1 major enhancement

data/Manifest.txt

@@ -20,8 +20,11 @@ lib/logging/log_event.rb
 lib/logging/logger.rb
 lib/logging/repository.rb
 lib/logging/root_logger.rb
+lib/logging/stelan/lockfile.rb
 lib/logging/utils.rb
+tasks/ann.rake
 tasks/annotations.rake
+tasks/bones.rake
 tasks/doc.rake
 tasks/gem.rake
 tasks/manifest.rake

data/README.txt

@@ -1,21 +1,22 @@
 Logging
+    by Tim Pease
 
 * {Homepage}[http://logging.rubyforge.org/]
 * {Rubyforge Project}[http://rubyforge.org/projects/logging]
 * email tim dot pease at gmail dot com
 
-== DESCRIPTION:
+== DESCRIPTION
 
 Logging is a flexible logging library for use in Ruby programs based on the
 design of Java's log4j library. It features a hierarchical logging system,
 custom level names, multiple output destinations per log event, custom
 formatting, and more.
 
-== INSTALL:
+== INSTALL
 
    sudo gem install logging
 
-== EXAMPLE:
+== EXAMPLE
 
 This example configures a logger to output messages in a format similar to the
 core ruby Logger class. Only log messages that are warnings or higher will be
@@ -35,8 +36,10 @@ file. Only log messages that are informational or higher will be logged.
    require 'logging'
 
    logger = Logging::Logger['example_logger']
-   logger.add  Logging::Appender.stdout
-   logger.add  Logging::Appenders::File.new('example.log')
+   logger.add_appenders(
+       Logging::Appender.stdout,
+       Logging::Appenders::File.new('example.log')
+   )
    logger.level = :info
 
    logger.debug "this debug message will not be output by the logger"
@@ -72,7 +75,7 @@ the recommended way of accomplishing this.
      end
    end
 
-== NOTES:
+== NOTES
 
 Although Logging is intended to supersede Log4r, it is not a one-to-one
 replacement for the Log4r library. Most notably is the difference in namespaces
@@ -81,10 +84,10 @@ Logging::Appender and renaming Log4r::Formatter to Logging::Layout. These
 changes were meant to bring the Logging class names more in line with the Log4j
 class names.
 
-== REQUIREMENTS:
+== REQUIREMENTS
 
 Logging does not depend on any other installed libraries or gems.
 
-== LICENSE:
+== LICENSE
 
 Ruby

data/Rakefile

@@ -18,11 +18,10 @@ PROJ.rdoc_dir = 'doc/rdoc'
 PROJ.rdoc_remote_dir = ''
 PROJ.version = Logging::VERSION
 
-PROJ.exclude << '^tags$' << '^tasks/archive' << '^coverage'
+PROJ.exclude += %w[^tags$ ^tasks/archive ^coverage]
 PROJ.rdoc_exclude << '^data'
 PROJ.svn = true
 
 depend_on 'flexmock'
-depend_on 'lockfile'
 
 # EOF

data/lib/logging.rb

@@ -1,4 +1,4 @@
-# $Id: logging.rb 98 2008-02-13 00:40:28Z tim_pease $
+# $Id: logging.rb 105 2008-02-26 04:43:21Z tim_pease $
 
 # Equivalent to a header guard in C/C++
 # Used to prevent the class/module from being loaded more than once
@@ -12,7 +12,7 @@ unless defined? Logging
 module Logging
 
   # :stopdoc:
-  VERSION = '0.7.0'
+  VERSION = '0.7.1'
   LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
   PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
   WIN32 = %r/djgpp|(cyg|ms|bcc)win|mingw/ =~ RUBY_PLATFORM

data/lib/logging/appenders/rolling_file.rb

@@ -1,19 +1,6 @@
-# $Id: rolling_file.rb 97 2008-02-13 00:32:18Z tim_pease $
-
-begin
-  require 'lockfile'
-rescue LoadError
-  require 'rubygems'
-  require 'lockfile'
-end
-
-# FIXME: bug when truncating a rolling file on create
-#        If there is not log file in existence, it is created and then
-#        immediately rolld resulting in two log files
-#
-#        This appears to be because of rails -- creating the logfile and
-#        then we replace the default logger with a rolling file appender. It
-#        sees the already existing log file and happily rolls it right over.
+# $Id: rolling_file.rb 106 2008-02-26 04:52:42Z tim_pease $
+
+require Logging.libpath(*%w[logging stelan lockfile])
 
 module Logging::Appenders
 
@@ -88,7 +75,7 @@ module Logging::Appenders
       @size = opts.getopt(:size, :as => Integer)
 
       @lockfile = if opts.getopt(:safe, false) and !::Logging::WIN32
-        Lockfile.new(
+        ::Logging::Lockfile.new(
             @fn + '.lck',
             :retries => 1,
             :timeout => 2
@@ -96,39 +83,38 @@ module Logging::Appenders
       end
 
       code = 'def sufficiently_aged?() false end'
+      @age_fn = @fn + '.age'
 
       case @age = opts.getopt(:age)
       when 'daily'
-        @start_time = Time.now
+        FileUtils.touch(@age_fn) unless test(?f, @age_fn)
         code = <<-CODE
         def sufficiently_aged?
           now = Time.now
-          if (now.day != @start_time.day) or (now - @start_time) > 86400
-            @start_time = now
+          start = ::File.mtime(@age_fn)
+          if (now.day != start.day) or (now - start) > 86400
             return true
           end
           false
         end
         CODE
       when 'weekly'
-        @start_time = Time.now
+        FileUtils.touch(@age_fn) unless test(?f, @age_fn)
         code = <<-CODE
         def sufficiently_aged?
-          now = Time.now
-          if (now - @start_time) > 604800
-            @start_time = now
+          if (Time.now - ::File.mtime(@age_fn)) > 604800
             return true
           end
           false
         end
         CODE
       when 'monthly'
-        @start_time = Time.now
+        FileUtils.touch(@age_fn) unless test(?f, @age_fn)
         code = <<-CODE
         def sufficiently_aged?
           now = Time.now
-          if (now.month != @start_time.month) or (now - @start_time) > 2678400
-            @start_time = now
+          start = ::File.mtime(@age_fn)
+          if (now.month != start.month) or (now - start) > 2678400
             return true
           end
           false
@@ -136,12 +122,10 @@ module Logging::Appenders
         CODE
       when Integer, String
         @age = Integer(@age)
-        @start_time = Time.now
+        FileUtils.touch(@age_fn) unless test(?f, @age_fn)
         code = <<-CODE
         def sufficiently_aged?
-          now = Time.now
-          if (now - @start_time) > @age
-            @start_time = now
+          if (Time.now - ::File.mtime(@age_fn)) > @age
             return true
           end
           false
@@ -264,6 +248,9 @@ module Logging::Appenders
 
       # finally reanme the base log file
       ::File.rename(@fn, sprintf(@logname_fmt, 1))
+
+      # touch the age file if needed
+      FileUtils.touch(@age_fn) if @age
     end
 
     # call-seq:

data/lib/logging/stelan/lockfile.rb

@@ -0,0 +1,530 @@
+# $Id: lockfile.rb 101 2008-02-13 17:10:47Z tim_pease $
+
+# This file was stolen with permission from Ara T. Howrad's gem of the same
+# name. The only difference is the removal of Ara's vim folding turds and
+# making the code work with Ruby1.9
+
+unless(defined?($__logging_lockfile__) or defined?(Logging::Lockfile))
+
+  require 'socket'
+  require 'timeout'
+  require 'fileutils'
+
+  module Logging
+  class Lockfile
+
+    VERSION = '1.4.3'
+    def version() VERSION end
+
+    class LockError < StandardError; end
+    class StolenLockError < LockError; end
+    class StackingLockError < LockError; end
+    class StatLockError < LockError; end
+    class MaxTriesLockError < LockError; end
+    class TimeoutLockError < LockError; end
+    class NFSLockError < LockError; end
+    class UnLockError < LockError; end
+
+    class SleepCycle < Array
+      attr :min
+      attr :max
+      attr :range
+      attr :inc
+
+      def initialize( min, max, inc )
+        @min, @max, @inc = Float(min), Float(max), Float(inc)
+        @range = @max - @min
+        raise RangeError, "max(#{ @max }) <= min(#{ @min })" if @max <= @min
+        raise RangeError, "inc(#{ @inc }) > range(#{ @range })" if @inc > @range
+        raise RangeError, "inc(#{ @inc }) <= 0" if @inc <= 0
+        raise RangeError, "range(#{ @range }) <= 0" if @range <= 0
+        s = @min
+        push(s) and s += @inc while(s <= @max)
+        self[-1] = @max if self[-1] < @max
+        reset
+      end
+
+      def next
+        ret = self[@idx]
+        @idx = ((@idx + 1) % self.size)
+        ret
+      end
+
+      def reset
+        @idx = 0
+      end
+    end  # class SleepCycle
+
+    HOSTNAME = Socket::gethostname
+
+    DEFAULT_RETRIES          = nil    # maximum number of attempts
+    DEFAULT_TIMEOUT          = nil    # the longest we will try
+    DEFAULT_MAX_AGE          = 3600   # lockfiles older than this are stale
+    DEFAULT_SLEEP_INC        = 2      # sleep cycle is this much longer each time
+    DEFAULT_MIN_SLEEP        = 2      # shortest sleep time
+    DEFAULT_MAX_SLEEP        = 32     # longest sleep time
+    DEFAULT_SUSPEND          = 1800   # iff we steal a lock wait this long before we go on
+    DEFAULT_REFRESH          = 8      # how often we touch/validate the lock
+    DEFAULT_DONT_CLEAN       = false  # iff we leave lock files lying around
+    DEFAULT_POLL_RETRIES     = 16     # this many polls makes one 'try'
+    DEFAULT_POLL_MAX_SLEEP   = 0.08   # the longest we'll sleep between polls
+    DEFAULT_DONT_SWEEP       = false  # if we cleanup after other process on our host
+    DEFAULT_DONT_USE_LOCK_ID = false  # if we dump lock info into lockfile
+
+    DEFAULT_DEBUG = ENV['LOCKFILE_DEBUG'] || false
+
+    class << self
+      attr_accessor :retries
+      attr_accessor :max_age
+      attr_accessor :sleep_inc
+      attr_accessor :min_sleep
+      attr_accessor :max_sleep
+      attr_accessor :suspend
+      attr_accessor :timeout
+      attr_accessor :refresh
+      attr_accessor :debug
+      attr_accessor :dont_clean
+      attr_accessor :poll_retries
+      attr_accessor :poll_max_sleep
+      attr_accessor :dont_sweep
+      attr_accessor :dont_use_lock_id
+
+      def init
+        @retries          = DEFAULT_RETRIES
+        @max_age          = DEFAULT_MAX_AGE
+        @sleep_inc        = DEFAULT_SLEEP_INC
+        @min_sleep        = DEFAULT_MIN_SLEEP
+        @max_sleep        = DEFAULT_MAX_SLEEP
+        @suspend          = DEFAULT_SUSPEND
+        @timeout          = DEFAULT_TIMEOUT
+        @refresh          = DEFAULT_REFRESH
+        @dont_clean       = DEFAULT_DONT_CLEAN
+        @poll_retries     = DEFAULT_POLL_RETRIES
+        @poll_max_sleep   = DEFAULT_POLL_MAX_SLEEP
+        @dont_sweep       = DEFAULT_DONT_SWEEP
+        @dont_use_lock_id = DEFAULT_DONT_USE_LOCK_ID
+
+        @debug          = DEFAULT_DEBUG
+
+        STDOUT.sync = true if @debug
+        STDERR.sync = true if @debug
+      end
+    end
+    self.init
+
+    attr :klass
+    attr :path
+    attr :opts
+    attr :locked
+    attr :thief
+    attr :dirname
+    attr :basename
+    attr :clean
+    attr :retries
+    attr :max_age
+    attr :sleep_inc
+    attr :min_sleep
+    attr :max_sleep
+    attr :suspend
+    attr :refresh
+    attr :timeout
+    attr :dont_clean
+    attr :poll_retries
+    attr :poll_max_sleep
+    attr :dont_sweep
+    attr :dont_use_lock_id
+
+    attr_accessor :debug
+
+    alias thief? thief
+    alias locked? locked
+    alias debug? debug
+
+    def self::create( path, *a, &b )
+      opts = {
+        'retries' => 0,
+        'min_sleep' => 0,
+        'max_sleep' => 1,
+        'sleep_inc' => 1,
+        'max_age' => nil,
+        'suspend' => 0,
+        'refresh' => nil,
+        'timeout' => nil,
+        'poll_retries' => 0,
+        'dont_clean' => true,
+        'dont_sweep' => false,
+        'dont_use_lock_id' => true
+      }
+      begin
+        new(path, opts).lock
+      rescue LockError
+        raise Errno::EEXIST, path
+      end
+      open(path, *a, &b)
+    end
+
+    def initialize( path, opts = {}, &block )
+      @klass = self.class
+      @path  = path
+      @opts  = opts
+
+      @retries          = getopt 'retries'          , @klass.retries
+      @max_age          = getopt 'max_age'          , @klass.max_age
+      @sleep_inc        = getopt 'sleep_inc'        , @klass.sleep_inc
+      @min_sleep        = getopt 'min_sleep'        , @klass.min_sleep
+      @max_sleep        = getopt 'max_sleep'        , @klass.max_sleep
+      @suspend          = getopt 'suspend'          , @klass.suspend
+      @timeout          = getopt 'timeout'          , @klass.timeout
+      @refresh          = getopt 'refresh'          , @klass.refresh
+      @dont_clean       = getopt 'dont_clean'       , @klass.dont_clean
+      @poll_retries     = getopt 'poll_retries'     , @klass.poll_retries
+      @poll_max_sleep   = getopt 'poll_max_sleep'   , @klass.poll_max_sleep
+      @dont_sweep       = getopt 'dont_sweep'       , @klass.dont_sweep
+      @dont_use_lock_id = getopt 'dont_use_lock_id' , @klass.dont_use_lock_id
+      @debug            = getopt 'debug'            , @klass.debug
+
+      @sleep_cycle = SleepCycle::new @min_sleep, @max_sleep, @sleep_inc
+
+      @clean    = @dont_clean ? nil : lambda{ File::unlink @path rescue nil }
+      @dirname  = File::dirname @path
+      @basename = File::basename @path
+      @thief    = false
+      @locked   = false
+
+      lock(&block) if block
+    end
+
+    def lock
+      raise StackingLockError, "<#{ @path }> is locked!" if @locked
+
+      sweep unless @dont_sweep
+
+      ret = nil
+
+      attempt do
+        begin
+          @sleep_cycle.reset
+          create_tmplock do |f|
+            begin
+              Timeout::timeout(@timeout) do
+                tmp_path = f.path
+                tmp_stat = f.lstat
+                n_retries = 0
+                trace{ "attempting to lock <#{ @path }>..." }
+                begin
+                  i = 0
+                  begin
+                    trace{ "polling attempt <#{ i }>..." }
+                    begin
+                      File::link tmp_path, @path
+                    rescue Errno::ENOENT
+                      try_again!
+                    end
+                    lock_stat = File::lstat @path
+                    raise StatLockError, "stat's do not agree" unless
+                      tmp_stat.rdev == lock_stat.rdev and tmp_stat.ino == lock_stat.ino
+                    trace{ "aquired lock <#{ @path }>" }
+                    @locked = true
+                rescue => e
+                  i += 1
+                  unless i >= @poll_retries
+                    t = [rand(@poll_max_sleep), @poll_max_sleep].min
+                    trace{ "poll sleep <#{ t }>..." }
+                    sleep t
+                    retry
+                  end
+                  raise
+                end
+
+                rescue => e
+                  n_retries += 1
+                  trace{ "n_retries <#{ n_retries }>" }
+                  case validlock?
+                    when true
+                      raise MaxTriesLockError, "surpased retries <#{ @retries }>" if
+                        @retries and n_retries >= @retries
+                      trace{ "found valid lock" }
+                      sleeptime = @sleep_cycle.next
+                      trace{ "sleep <#{ sleeptime }>..." }
+                      sleep sleeptime
+                    when false
+                      trace{ "found invalid lock and removing" }
+                      begin
+                        File::unlink @path
+                        @thief = true
+                        warn "<#{ @path }> stolen by <#{ Process.pid }> at <#{ timestamp }>"
+                        trace{ "i am a thief!" }
+                      rescue Errno::ENOENT
+                      end
+                      trace{ "suspending <#{ @suspend }>" }
+                      sleep @suspend
+                    when nil
+                      raise MaxTriesLockError, "surpased retries <#{ @retries }>" if
+                        @retries and n_retries >= @retries
+                  end
+                  retry
+                end # begin
+              end # timeout
+            rescue Timeout::Error
+              raise TimeoutLockError, "surpassed timeout <#{ @timeout }>"
+            end # begin
+          end # create_tmplock
+
+          if block_given?
+            stolen = false
+            refresher = (@refresh ? new_refresher : nil)
+            begin
+              begin
+                ret = yield @path
+              rescue StolenLockError
+                stolen = true
+                raise
+              end
+            ensure
+              begin
+                refresher.kill if refresher and refresher.status
+              ensure
+                unlock unless stolen
+              end
+            end
+          else
+            ObjectSpace.define_finalizer self, @clean if @clean
+            ret = self
+          end
+        rescue Errno::ESTALE, Errno::EIO => e
+          raise(NFSLockError, errmsg(e))
+        end
+      end
+
+      return ret
+    end
+
+    def sweep
+      begin
+        glob = File::join(@dirname, ".*lck")
+        paths = Dir[glob]
+        paths.each do |path|
+          begin
+            basename = File::basename path
+            pat = %r/^\s*\.([^_]+)_([^_]+)/o
+            if pat.match(basename)
+              host, pid = $1, $2
+            else
+              next
+            end
+            host.gsub!(%r/^\.+|\.+$/,'')
+            quad = host.split %r/\./
+            host = quad.first
+            pat = %r/^\s*#{ host }/i
+            if pat.match(HOSTNAME) and %r/^\s*\d+\s*$/.match(pid)
+              unless alive?(pid)
+                trace{ "process <#{ pid }> on <#{ host }> is no longer alive" }
+                trace{ "sweeping <#{ path }>" }
+                FileUtils::rm_f path
+              else
+                trace{ "process <#{ pid }> on <#{ host }> is still alive" }
+                trace{ "ignoring <#{ path }>" }
+              end
+            else
+              trace{ "ignoring <#{ path }> generated by <#{ host }>" }
+            end
+          rescue
+            next
+          end
+        end
+      rescue => e
+        warn(errmsg(e))
+      end
+    end
+
+    def alive?( pid )
+      pid = Integer("#{ pid }")
+      begin
+        Process::kill 0, pid
+        true
+      rescue Errno::ESRCH
+        false
+      end
+    end
+
+    def unlock
+      raise UnLockError, "<#{ @path }> is not locked!" unless @locked
+      begin
+        File::unlink @path
+      rescue Errno::ENOENT
+        raise StolenLockError, @path
+      ensure
+        @thief = false
+        @locked = false
+        ObjectSpace.undefine_finalizer self if @clean
+      end
+    end
+
+    def new_refresher
+      Thread::new(Thread::current, @path, @refresh, @dont_use_lock_id) do |thread, path, refresh, dont_use_lock_id|
+        loop do
+          begin
+            touch path
+            trace{"touched <#{ path }> @ <#{ Time.now.to_f }>"}
+            unless dont_use_lock_id
+              loaded = load_lock_id(IO.read(path))
+              trace{"loaded <\n#{ loaded.inspect }\n>"}
+              raise unless loaded == @lock_id
+            end
+            sleep refresh
+          rescue Exception => e
+            trace{errmsg e}
+            thread.raise StolenLockError
+            Thread::exit
+          end
+        end
+      end
+    end
+
+    def validlock?
+      if @max_age
+        uncache @path rescue nil
+        begin
+          return((Time.now - File::stat(@path).mtime) < @max_age)
+        rescue Errno::ENOENT
+          return nil
+        end
+      else
+        exist = File::exist?(@path)
+        return(exist ? true : nil)
+      end
+    end
+
+    def uncache( file )
+      refresh = nil
+      begin
+        is_a_file = File === file
+        path = (is_a_file ? file.path : file.to_s)
+        stat = (is_a_file ? file.stat : File::stat(file.to_s))
+        refresh = tmpnam(File::dirname(path))
+        File::link path, refresh
+        File::chmod stat.mode, path
+        File::utime stat.atime, stat.mtime, path
+      ensure
+        begin
+          File::unlink refresh if refresh
+        rescue Errno::ENOENT
+        end
+      end
+    end
+
+    def create_tmplock
+      tmplock = tmpnam @dirname
+      begin
+        create(tmplock) do |f|
+          unless dont_use_lock_id
+            @lock_id = gen_lock_id
+            dumped = dump_lock_id
+            trace{"lock_id <\n#{ @lock_id.inspect }\n>"}
+            f.write dumped
+            f.flush
+          end
+          yield f
+        end
+      ensure
+        begin; File::unlink tmplock; rescue Errno::ENOENT; end if tmplock
+      end
+    end
+
+    def gen_lock_id
+      Hash[
+        'host' => "#{ HOSTNAME }",
+        'pid' => "#{ Process.pid }",
+        'ppid' => "#{ Process.ppid }",
+        'time' => timestamp
+      ]
+    end
+
+    def timestamp
+      time = Time.now
+      usec = time.usec.to_s
+      usec << '0' while usec.size < 6
+      "#{ time.strftime('%Y-%m-%d %H:%M:%S') }.#{ usec }"
+    end
+
+    def dump_lock_id lock_id = @lock_id
+      "host: %s\npid: %s\nppid: %s\ntime: %s\n" %
+        lock_id.values_at('host','pid','ppid','time')
+    end
+
+    def load_lock_id( buf )
+      lock_id = {}
+      kv = %r/([^:]+):(.*)/o
+      buf.each do |line|
+        m = kv.match line
+        k, v = m[1], m[2]
+        next unless m and k and v
+        lock_id[k.strip] = v.strip
+      end
+      lock_id
+    end
+
+    def tmpnam( dir, seed = File::basename($0) )
+      pid = Process.pid
+      time = Time.now
+      sec = time.to_i
+      usec = time.usec
+      "%s%s.%s_%d_%s_%d_%d_%d.lck" %
+        [dir, File::SEPARATOR, HOSTNAME, pid, seed, sec, usec, rand(sec)]
+    end
+
+    def create( path )
+      umask = nil
+      f = nil
+      begin
+        umask = File::umask 022
+        f = open path, File::WRONLY|File::CREAT|File::EXCL, 0644
+      ensure
+        File::umask umask if umask
+      end
+      return(block_given? ? begin; yield f; ensure; f.close; end : f)
+    end
+
+    def touch( path )
+      FileUtils.touch path
+    end
+
+    def getopt( key, default = nil )
+      [ key, key.to_s, key.to_s.intern ].each do |k|
+        return @opts[k] if @opts.has_key?(k)
+      end
+      return default
+    end
+
+    def to_str
+      @path
+    end
+    alias to_s to_str
+
+    def trace( s = nil )
+      STDERR.puts((s ? s : yield)) if @debug
+    end
+
+    def errmsg( e )
+      "%s (%s)\n%s\n" % [e.class, e.message, e.backtrace.join("\n")]
+    end
+
+    def attempt
+      ret = nil
+      loop{ break unless catch('attempt'){ ret = yield } == 'try_again' }
+      ret
+    end
+
+    def try_again!
+      throw 'attempt', 'try_again'
+    end
+    alias again! try_again!
+
+    def give_up!
+      throw 'attempt', 'give_up'
+    end
+  end  # class Lockfile
+  end  # module Logging
+
+  $__logging_lockfile__ = __FILE__
+end

data/tasks/ann.rake

@@ -0,0 +1,76 @@
+# $Id: ann.rake 105 2008-02-26 04:43:21Z tim_pease $
+
+begin
+  require 'bones/smtp_tls'
+rescue LoadError
+  require 'net/smtp'
+end
+require 'time'
+
+namespace :ann do
+
+  file PROJ.ann_file do
+    puts "Generating #{PROJ.ann_file}"
+    File.open(PROJ.ann_file,'w') do |fd|
+      fd.puts("#{PROJ.name} version #{PROJ.version}")
+      fd.puts("    by #{Array(PROJ.authors).first}") if PROJ.authors
+      fd.puts("    #{PROJ.url}") if PROJ.url
+      fd.puts("    (the \"#{PROJ.release_name}\" release)") if PROJ.release_name
+      fd.puts
+      fd.puts("== DESCRIPTION")
+      fd.puts
+      fd.puts(PROJ.description)
+      fd.puts
+      fd.puts(PROJ.changes.sub(%r/^.*$/, '== CHANGES'))
+      fd.puts
+      PROJ.ann_paragraphs.each do |p|
+        fd.puts "== #{p.upcase}"
+        fd.puts
+        fd.puts paragraphs_of(PROJ.readme_file, p).join("\n\n")
+        fd.puts
+      end
+      fd.puts PROJ.ann_text if PROJ.ann_text
+    end
+  end
+
+  desc "Create an announcement file"
+  task :announcement => PROJ.ann_file
+
+  desc "Send an email announcement"
+  task :email => PROJ.ann_file do
+    from = PROJ.ann_email[:from] || PROJ.email
+    to   = Array(PROJ.ann_email[:to])
+
+    ### build a mail header for RFC 822
+    rfc822msg =  "From: #{from}\n"
+    rfc822msg << "To: #{to.join(',')}\n"
+    rfc822msg << "Subject: [ANN] #{PROJ.name} #{PROJ.version}"
+    rfc822msg << " (#{PROJ.release_name})" if PROJ.release_name
+    rfc822msg << "\n"
+    rfc822msg << "Date: #{Time.new.rfc822}\n"
+    rfc822msg << "Message-Id: "
+    rfc822msg << "<#{"%.8f" % Time.now.to_f}@#{PROJ.ann_email[:domain]}>\n\n"
+    rfc822msg << File.read(PROJ.ann_file)
+
+    params = [:server, :port, :domain, :acct, :passwd, :authtype].map do |key|
+      PROJ.ann_email[key]
+    end
+
+    params[3] = PROJ.email if params[3].nil?
+
+    if params[4].nil?
+      STDOUT.write "Please enter your e-mail password (#{params[3]}): "
+      params[4] = STDIN.gets.chomp
+    end
+
+    ### send email
+    Net::SMTP.start(*params) {|smtp| smtp.sendmail(rfc822msg, from, to)}
+  end
+end  # namespace :ann
+
+desc 'Alias to ann:announcement'
+task :ann => 'ann:announcement'
+
+CLOBBER << PROJ.ann_file
+
+# EOF

data/tasks/annotations.rake

@@ -1,4 +1,4 @@
-# $Id: annotations.rake 87 2008-02-08 17:21:07Z tim_pease $
+# $Id$
 
 if HAVE_BONES
 

data/tasks/bones.rake

@@ -0,0 +1,40 @@
+# $Id: bones.rake 105 2008-02-26 04:43:21Z tim_pease $
+
+require 'pp'
+require 'stringio'
+
+namespace :bones do
+
+  desc 'Show the PROJ open struct'
+  task :debug do |t|
+    atr = if ARGV.length == 2
+      t.application.top_level_tasks.pop
+    end
+    sio = StringIO.new
+    sep = "\n" + ' '*27
+    fmt = "%23s => %s"
+
+    if atr
+      PP.pp(PROJ.send(atr.to_sym), sio, 49)
+      sio.seek 0
+      val = sio.read
+      val = val.split("\n").join(sep)
+
+      puts fmt % [atr, val]
+    else
+      h = PROJ.instance_variable_get(:@table)
+      h.keys.map {|k| k.to_s}.sort.each do |k|
+        sio.truncate 0
+        PP.pp(h[k.to_sym], sio, 49)
+        sio.seek 0
+        val = sio.read
+        val = val.split("\n").join(sep)
+
+        puts fmt % [k, val]
+      end
+    end
+  end
+
+end  # namespace :bones
+
+# EOF

data/tasks/doc.rake

@@ -31,7 +31,6 @@ namespace :doc do
     sh "#{RDOC} --ri -o ri ."
   end
 
-  desc 'Remove ri products'
   task :clobber_ri do
     rm_r 'ri' rescue nil
   end
@@ -44,6 +43,6 @@ task :doc => 'doc:rdoc'
 desc 'Remove all build products'
 task :clobber => %w(doc:clobber_rdoc doc:clobber_ri)
 
-remove_desc_for_task %w(doc:clobber_rdoc doc:clobber_ri)
+remove_desc_for_task %w(doc:clobber_rdoc)
 
 # EOF

data/tasks/gem.rake

@@ -12,6 +12,7 @@ namespace :gem do
     s.email = PROJ.email
     s.homepage = Array(PROJ.url).first
     s.rubyforge_project = PROJ.rubyforge_name
+    s.post_install_message = PROJ.post_install_message
 
     s.description = PROJ.description
 
@@ -62,9 +63,29 @@ namespace :gem do
     puts PROJ.spec.to_ruby
   end
 
-  Rake::GemPackageTask.new(PROJ.spec) do |pkg|
+  pkg = Rake::PackageTask.new(PROJ.name, PROJ.version) do |pkg|
     pkg.need_tar = PROJ.need_tar
     pkg.need_zip = PROJ.need_zip
+    pkg.package_files += PROJ.spec.files
+  end
+  Rake::Task['gem:package'].instance_variable_set(:@full_comment, nil)
+
+  gem_file = if PROJ.spec.platform == Gem::Platform::RUBY
+      "#{pkg.package_name}.gem"
+    else
+      "#{pkg.package_name}-#{PROJ.spec.platform}.gem"
+    end
+
+  desc "Build the gem file #{gem_file}"
+  task :package => "#{pkg.package_dir}/#{gem_file}"
+
+  file "#{pkg.package_dir}/#{gem_file}" => [pkg.package_dir] + PROJ.spec.files do
+    when_writing("Creating GEM") {
+      Gem::Builder.new(PROJ.spec).build
+      verbose(true) {
+        mv gem_file, "#{pkg.package_dir}/#{gem_file}"
+      }
+    }
   end
 
   desc 'Install the gem'
@@ -74,9 +95,12 @@ namespace :gem do
 
   desc 'Uninstall the gem'
   task :uninstall do
-    sh "#{SUDO} #{GEM} uninstall -v '#{PROJ.version}' -x #{PROJ.name}"
+    sh "#{SUDO} #{GEM} uninstall -v '#{PROJ.version}' -i -x #{PROJ.name}"
   end
 
+  desc 'Reinstall the gem'
+  task :reinstall => [:uninstall, :install]
+
 end  # namespace :gem
 
 desc 'Alias to gem:package'

data/tasks/manifest.rake

@@ -6,18 +6,11 @@ namespace :manifest do
 
   desc 'Verify the manifest'
   task :check do
-    fn = 'Manifest.tmp'
-    files = []
-    exclude = Regexp.new(PROJ.exclude.join('|'))
-    Find.find '.' do |path|
-      path.sub! %r/^(\.\/|\/)/o, ''
-      next unless test ?f, path
-      next if path =~ exclude
-      files << path
-    end
+    fn = PROJ.manifest_file + '.tmp'
+    files = manifest_files
 
-    File.open(fn, 'w') {|fp| fp.puts files.sort}
-    lines = %x(#{DIFF} -du Manifest.txt #{fn}).split("\n")
+    File.open(fn, 'w') {|fp| fp.puts files}
+    lines = %x(#{DIFF} -du #{PROJ.manifest_file} #{fn}).split("\n")
     if HAVE_FACETS_ANSICODE and ENV.has_key?('TERM')
       lines.map! do |line|
         case line
@@ -34,19 +27,20 @@ namespace :manifest do
 
   desc 'Create a new manifest'
   task :create do
-    fn = 'Manifest.txt'
-    files = []
-    exclude = Regexp.new(PROJ.exclude.join('|'))
-    Find.find '.' do |path|
-      path.sub! %r/^(\.\/|\/)/o, ''
-      next unless test ?f, path
-      next if path =~ exclude
-      files << path
+    files = manifest_files
+    unless test(?f, PROJ.manifest_file)
+      files << PROJ.manifest_file
+      files.sort!
     end
+    File.open(PROJ.manifest_file, 'w') {|fp| fp.puts files}
+  end
 
-    files << fn unless test ?f, fn
-    File.open(fn, 'w') {|fp| fp.puts files.sort}
+  task :assert do
+    files = manifest_files
+    manifest = File.read(PROJ.manifest_file).split($/)
+    raise "ERROR: #{PROJ.manifest_file} is out of date" unless files == manifest
   end
+
 end  # namespace :manifest
 
 desc 'Alias to manifest:check'

data/tasks/post_load.rake

@@ -1,18 +1,30 @@
-# $Id$
+# $Id: post_load.rake 105 2008-02-26 04:43:21Z tim_pease $
 
 # This file does not define any rake tasks. It is used to load some project
 # settings if they are not defined by the user.
 
-unless PROJ.changes
-  PROJ.changes = paragraphs_of('History.txt', 0..1).join("\n\n")
-end
+PROJ.rdoc_exclude << "^#{Regexp.escape(PROJ.manifest_file)}$"
+PROJ.exclude << "^#{Regexp.escape(PROJ.ann_file)}$"
 
-unless PROJ.description
-  PROJ.description = paragraphs_of('README.txt', 'description').join("\n\n")
-end
+PROJ.exclude.flatten!
+PROJ.rdoc_exclude.flatten!
+PROJ.annotation_exclude.flatten!
 
-unless PROJ.summary
-  PROJ.summary = PROJ.description.split('.').first
-end
+PROJ.changes ||= paragraphs_of(PROJ.history_file, 0..1).join("\n\n")
+
+PROJ.description ||= paragraphs_of(PROJ.readme_file, 'description').join("\n\n")
+
+PROJ.summary ||= PROJ.description.split('.').first
+
+PROJ.files ||=
+  if test(?f, PROJ.manifest_file)
+    files = File.readlines(PROJ.manifest_file).map {|fn| fn.chomp.strip}
+    files.delete ''
+    files
+  else [] end
+
+PROJ.executables ||= PROJ.files.find_all {|fn| fn =~ %r/^bin/}
+
+PROJ.rdoc_main ||= PROJ.readme_file
 
 # EOF

data/tasks/setup.rb

@@ -1,7 +1,8 @@
-# $Id: setup.rb 87 2008-02-08 17:21:07Z tim_pease $
+# $Id: setup.rb 105 2008-02-26 04:43:21Z tim_pease $
 
 require 'rubygems'
 require 'rake'
+require 'rake/clean'
 require 'fileutils'
 require 'ostruct'
 
@@ -17,6 +18,10 @@ PROJ.url = nil
 PROJ.version = ENV['VERSION'] || '0.0.0'
 PROJ.rubyforge_name = nil
 PROJ.exclude = %w(tmp$ bak$ ~$ CVS .svn/ ^pkg/ ^doc/)
+PROJ.release_name = ENV['RELEASE']
+PROJ.history_file = 'History.txt'
+PROJ.manifest_file = 'Manifest.txt'
+PROJ.readme_file = 'README.txt'
 
 # Rspec
 PROJ.specs = FileList['spec/**/*_spec.rb']
@@ -28,13 +33,16 @@ PROJ.test_file = 'test/all.rb'
 PROJ.test_opts = []
 
 # Rcov
+PROJ.rcov_dir = 'coverage'
 PROJ.rcov_opts = ['--sort', 'coverage', '-T']
+PROJ.rcov_threshold = 90.0
+PROJ.rcov_threshold_exact = false
 
 # Rdoc
 PROJ.rdoc_opts = []
 PROJ.rdoc_include = %w(^lib/ ^bin/ ^ext/ .txt$)
-PROJ.rdoc_exclude = %w(extconf.rb$ ^Manifest.txt$)
-PROJ.rdoc_main = 'README.txt'
+PROJ.rdoc_exclude = %w(extconf.rb$)
+PROJ.rdoc_main = nil
 PROJ.rdoc_dir = 'doc'
 PROJ.rdoc_remote_dir = nil
 
@@ -45,16 +53,12 @@ PROJ.libs = []
 %w(lib ext).each {|dir| PROJ.libs << dir if test ?d, dir}
 
 # Gem Packaging
-PROJ.files =
-  if test ?f, 'Manifest.txt'
-    files = File.readlines('Manifest.txt').map {|fn| fn.chomp.strip}
-    files.delete ''
-    files
-  else [] end
-PROJ.executables = PROJ.files.find_all {|fn| fn =~ %r/^bin/}
+PROJ.files = nil
+PROJ.executables = nil
 PROJ.dependencies = []
 PROJ.need_tar = true
 PROJ.need_zip = false
+PROJ.post_install_message = nil
 
 # File Annotations
 PROJ.annotation_exclude = %w(^tasks/setup.rb$)
@@ -68,6 +72,21 @@ PROJ.svn_trunk = 'trunk'
 PROJ.svn_tags = 'tags'
 PROJ.svn_branches = 'branches'
 
+# Announce
+PROJ.ann_file = 'announcement.txt'
+PROJ.ann_text = nil
+PROJ.ann_paragraphs = []
+PROJ.ann_email = {
+  :from     => nil,
+  :to       => %w(ruby-talk@ruby-lang.org),
+  :server   => 'localhost',
+  :port     => 25,
+  :domain   => ENV['HOSTNAME'],
+  :acct     => nil,
+  :passwd   => nil,
+  :authtype => :plain
+}
+
 # Load the other rake files in the tasks folder
 rakefiles = Dir.glob('tasks/*.rake').sort
 rakefiles.unshift(rakefiles.delete('tasks/post_load.rake')).compact!
@@ -100,8 +119,8 @@ SUDO = if WIN32 then ''
          else '' end
        end
 
-RCOV = WIN32 ? 'rcov.cmd'  : 'rcov'
-GEM  = WIN32 ? 'gem.cmd'   : 'gem'
+RCOV = WIN32 ? 'rcov.bat' : 'rcov'
+GEM  = WIN32 ? 'gem.bat'  : 'gem'
 
 %w(rcov spec/rake/spectask rubyforge bones facets/ansicode).each do |lib|
   begin
@@ -150,7 +169,10 @@ def depend_on( name, version = nil )
   spec = Gem.source_index.find_name(name).last
   version = spec.version.to_s if version.nil? and !spec.nil?
 
-  PROJ.dependencies << (version.nil? ? [name] : [name, ">= #{version}"])
+  PROJ.dependencies << case version
+    when nil; [name]
+    when %r/^\d/; [name, ">= #{version}"]
+    else [name, version] end
 end
 
 # Adds the given arguments to the include path if they are not already there
@@ -187,4 +209,19 @@ def in_directory( dir, &block )
   end
 end
 
+# Scans the current working directory and creates a list of files that are
+# candidates to be in the manifest.
+#
+def manifest_files
+  files = []
+  exclude = Regexp.new(PROJ.exclude.join('|'))
+  Find.find '.' do |path|
+    path.sub! %r/^(\.\/|\/)/o, ''
+    next unless test ?f, path
+    next if path =~ exclude
+    files << path
+  end
+  files.sort!
+end
+
 # EOF

data/tasks/test.rake

@@ -6,7 +6,7 @@ namespace :test do
 
   Rake::TestTask.new(:run) do |t|
     t.libs = PROJ.libs
-    t.test_files = if test ?f, PROJ.test_file then [PROJ.test_file]
+    t.test_files = if test(?f, PROJ.test_file) then [PROJ.test_file]
                    else PROJ.tests end
     t.ruby_opts += PROJ.ruby_opts
     t.ruby_opts += PROJ.test_opts
@@ -15,14 +15,14 @@ namespace :test do
   if HAVE_RCOV
     desc 'Run rcov on the unit tests'
     task :rcov => :clobber_rcov do
-      opts = PROJ.rcov_opts.join(' ')
-      files = if test ?f, PROJ.test_file then [PROJ.test_file]
+      opts = PROJ.rcov_opts.dup << '-o' << PROJ.rcov_dir
+      opts = opts.join(' ')
+      files = if test(?f, PROJ.test_file) then [PROJ.test_file]
               else PROJ.tests end
       files = files.join(' ')
       sh "#{RCOV} #{files} #{opts}"
     end
 
-    desc 'Remove rcov products'
     task :clobber_rcov do
       rm_r 'coverage' rescue nil
     end
@@ -35,6 +35,4 @@ task :test => 'test:run'
 
 task :clobber => 'test:clobber_rcov' if HAVE_RCOV
 
-remove_desc_for_task %w(test:clobber_rcov)
-
 # EOF

data/test/appenders/test_rolling_file.rb

@@ -1,4 +1,4 @@
-# $Id: test_rolling_file.rb 97 2008-02-13 00:32:18Z tim_pease $
+# $Id: test_rolling_file.rb 105 2008-02-26 04:43:21Z tim_pease $
 
 require File.join(File.dirname(__FILE__), %w[.. setup])
 
@@ -109,8 +109,10 @@ module TestAppenders
       ap << "random message\n"
       assert_equal 2, Dir.glob(@glob).length
 
-      t = ap.instance_variable_get :@start_time
-      ap.instance_variable_set :@start_time, t - 3600 * 24
+      age_fn = @fn + '.age'
+      now = ::File.mtime(age_fn)
+      start = now - 3600 * 24
+      ::File.utime(start, start, age_fn)
 
       sleep 0.250
       ap << "yet another random message\n"
@@ -122,8 +124,8 @@ module TestAppenders
       ap << "random message\n"
       assert_equal 3, Dir.glob(@glob).length
 
-      t = ap.instance_variable_get :@start_time
-      ap.instance_variable_set :@start_time, t - 3600 * 24 * 7
+      start = now - 3600 * 24 * 7
+      ::File.utime(start, start, age_fn)
 
       sleep 0.250
       ap << "yet another random message\n"
@@ -135,8 +137,8 @@ module TestAppenders
       ap << "random message\n"
       assert_equal 4, Dir.glob(@glob).length
 
-      t = ap.instance_variable_get :@start_time
-      ap.instance_variable_set :@start_time, t - 3600 * 24 * 31
+      start = now - 3600 * 24 * 31
+      ::File.utime(start, start, age_fn)
 
       sleep 0.250
       ap << "yet another random message\n"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: logging
 version: !ruby/object:Gem::Version 
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors: 
 - Tim Pease
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-02-12 00:00:00 -07:00
+date: 2008-02-25 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -21,15 +21,6 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 0.8.0
     version: 
-- !ruby/object:Gem::Dependency 
-  name: lockfile
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.4.3
-    version: 
 description: Logging is a flexible logging library for use in Ruby programs based on the design of Java's log4j library. It features a hierarchical logging system, custom level names, multiple output destinations per log event, custom formatting, and more.
 email: tim.pease@gmail.com
 executables: []
@@ -62,8 +53,11 @@ files:
 - lib/logging/logger.rb
 - lib/logging/repository.rb
 - lib/logging/root_logger.rb
+- lib/logging/stelan/lockfile.rb
 - lib/logging/utils.rb
+- tasks/ann.rake
 - tasks/annotations.rake
+- tasks/bones.rake
 - tasks/doc.rake
 - tasks/gem.rake
 - tasks/manifest.rake