logsly 1.2.0 → 1.3.0

data/lib/logsly/logging182/appenders/file.rb

@@ -0,0 +1,85 @@
+
+module Logsly::Logging182::Appenders
+
+  # Accessor / Factory for the File appender.
+  #
+  def self.file( *args )
+    return ::Logsly::Logging182::Appenders::File if args.empty?
+    ::Logsly::Logging182::Appenders::File.new(*args)
+  end
+
+  # This class provides an Appender that can write to a File.
+  #
+  class File < ::Logsly::Logging182::Appenders::IO
+
+    # call-seq:
+    #    File.assert_valid_logfile( filename )    => true
+    #
+    # Asserts that the given _filename_ can be used as a log file by ensuring
+    # that if the file exists it is a regular file and it is writable. If
+    # the file does not exist, then the directory is checked to see if it is
+    # writable.
+    #
+    # An +ArgumentError+ is raised if any of these assertions fail.
+    #
+    def self.assert_valid_logfile( fn )
+      if ::File.exist?(fn)
+        if not ::File.file?(fn)
+          raise ArgumentError, "#{fn} is not a regular file"
+        elsif not ::File.writable?(fn)
+          raise ArgumentError, "#{fn} is not writeable"
+        end
+      elsif not ::File.writable?(::File.dirname(fn))
+        raise ArgumentError, "#{::File.dirname(fn)} is not writable"
+      end
+      true
+    end
+
+    # call-seq:
+    #    File.new( name, :filename => 'file' )
+    #    File.new( name, :filename => 'file', :truncate => true )
+    #    File.new( name, :filename => 'file', :layout => layout )
+    #
+    # Creates a new File Appender that will use the given filename as the
+    # logging destination. If the file does not already exist it will be
+    # created. If the :truncate option is set to +true+ then the file will
+    # be truncated before writing begins; otherwise, log messages will be
+    # appended to the file.
+    #
+    def initialize( name, opts = {} )
+      @fn = opts.getopt(:filename, name)
+      raise ArgumentError, 'no filename was given' if @fn.nil?
+
+      @fn = ::File.expand_path(@fn)
+      self.class.assert_valid_logfile(@fn)
+      @mode = opts.getopt(:truncate) ? 'w' : 'a'
+
+      self.encoding = opts.fetch(:encoding, self.encoding)
+      @mode = "#{@mode}:#{self.encoding}" if self.encoding
+
+      super(name, ::File.new(@fn, @mode), opts)
+    end
+
+    # Returns the path to the logfile.
+    #
+    def filename() @fn.dup end
+
+    # Reopen the connection to the underlying logging destination. If the
+    # connection is currently closed then it will be opened. If the connection
+    # is currently open then it will be closed and immediately opened.
+    #
+    def reopen
+      @mutex.synchronize {
+        if defined? @io and @io
+          flush
+          @io.close rescue nil
+        end
+        @io = ::File.new(@fn, @mode)
+      }
+      super
+      self
+    end
+
+  end  # FileAppender
+end  # Logsly::Logging182::Appenders
+

data/lib/logsly/logging182/appenders/growl.rb

@@ -0,0 +1,200 @@
+
+module Logsly::Logging182::Appenders
+
+  # Accessor / Factory for the Growl appender.
+  #
+  def self.growl( *args )
+    return ::Logsly::Logging182::Appenders::Growl if args.empty?
+    ::Logsly::Logging182::Appenders::Growl.new(*args)
+  end
+
+  # This class provides an Appender that can send notifications to the Growl
+  # notification system on Mac OS X.
+  #
+  # +growlnotify+ must be installed somewhere in the path in order for the
+  # appender to function properly.
+  #
+  class Growl < ::Logsly::Logging182::Appender
+
+    # :stopdoc:
+    ColoredRegexp = %r/\e\[([34][0-7]|[0-9])m/
+    # :startdoc:
+
+    # call-seq:
+    #    Growl.new( name, opts = {} )
+    #
+    # Create an appender that will log messages to the Growl framework on a
+    # Mac OS X machine.
+    #
+    def initialize( name, opts = {} )
+      super
+
+      @growl = "growlnotify -w -n \"#{@name}\" -t \"%s\" -m \"%s\" -p %d &"
+
+      @coalesce = opts.getopt(:coalesce, false)
+      @title_sep = opts.getopt(:separator)
+
+      # provides a mapping from the default Logsly::Logging182 levels
+      # to the Growl notification levels
+      @map = [-2, -1, 0, 1, 2]
+
+      map = opts.getopt(:map)
+      self.map = map unless map.nil?
+      setup_coalescing if @coalesce
+
+      # make sure the growlnotify command can be called
+      unless system('growlnotify -v >> /dev/null 2>&1')
+        self.level = :off
+        ::Logsly::Logging182.log_internal {'growl notifications have been disabled'}
+      end
+    end
+
+    # call-seq:
+    #    map = { logging_levels => growl_levels }
+    #
+    # Configure the mapping from the Logsly::Logging182 levels to the Growl
+    # notification levels. This is needed in order to log events at the
+    # proper Growl level.
+    #
+    # Without any configuration, the following mapping will be used:
+    #
+    #    :debug  =>  -2
+    #    :info   =>  -1
+    #    :warn   =>  0
+    #    :error  =>  1
+    #    :fatal  =>  2
+    #
+    def map=( levels )
+      map = []
+      levels.keys.each do |lvl|
+        num = ::Logsly::Logging182.level_num(lvl)
+        map[num] = growl_level_num(levels[lvl])
+      end
+      @map = map
+    end
+
+
+  private
+
+    # call-seq:
+    #    write( event )
+    #
+    # Write the given _event_ to the growl notification facility. The log
+    # event will be processed through the Layout associated with this
+    # appender. The message will be logged at the level specified by the
+    # event.
+    #
+    def write( event )
+      title = ''
+      priority = 0
+      message = if event.instance_of?(::Logsly::Logging182::LogEvent)
+          priority = @map[event.level]
+          @layout.format(event)
+        else
+          event.to_s
+        end
+      return if message.empty?
+
+      message = message.gsub(ColoredRegexp, '')
+      if @title_sep
+        title, message = message.split(@title_sep)
+        title, message = '', title if message.nil?
+      end
+
+      growl(title.strip, message.strip, priority)
+      self
+    end
+
+    # call-seq:
+    #    growl_level_num( level )    => integer
+    #
+    # Takes the given _level_ as a string or integer and returns the
+    # corresponding Growl notification level number.
+    #
+    def growl_level_num( level )
+      level = Integer(level)
+      if level < -2 or level > 2
+        raise ArgumentError, "level '#{level}' is not in range -2..2"
+      end
+      level
+    end
+
+    # call-seq:
+    #    growl( title, message, priority )
+    #
+    # Send the _message_ to the growl notifier using the given _title_ and
+    # _priority_.
+    #
+    def growl( title, message, priority )
+      message.tr!("`", "'")
+      if @coalesce then coalesce(title, message, priority)
+      else call_growl(title, message, priority) end
+    end
+
+    # call-seq:
+    #    coalesce( title, message, priority )
+    #
+    # Attempt to coalesce the given _message_ with any that might be pending
+    # in the queue to send to the growl notifier. Messages are coalesced
+    # with any in the queue that have the same _title_ and _priority_.
+    #
+    # There can be only one message in the queue, so if the _title_ and/or
+    # _priority_ don't match, the message in the queue is sent immediately
+    # to the growl notifier, and the current _message_ is queued.
+    #
+    def coalesce( *msg )
+      @c_mutex.synchronize do
+        if @c_queue.empty?
+          @c_queue << msg
+          @c_thread.run
+
+        else
+          qmsg = @c_queue.last
+          if qmsg.first != msg.first or qmsg.last != msg.last
+            @c_queue << msg
+          else
+            qmsg[1] << "\n" << msg[1]
+          end
+        end
+      end
+    end
+
+    # call-seq:
+    #    setup_coalescing
+    #
+    # Setup the appender to handle coalescing of messages before sending
+    # them to the growl notifier. This requires the creation of a thread and
+    # mutex for passing messages from the appender thread to the growl
+    # notifier thread.
+    #
+    def setup_coalescing
+      @c_mutex = Mutex.new
+      @c_queue = []
+
+      @c_thread = Thread.new do
+        loop do
+          Thread.stop if @c_queue.empty?
+          sleep 1
+          @c_mutex.synchronize {
+            call_growl(*@c_queue.shift) until @c_queue.empty?
+          }
+        end  # loop
+      end  # Thread.new
+    end
+
+    # call-seq:
+    #    call_growl( title, message, priority )
+    #
+    # Call the growlnotify application with the given parameters. If the
+    # system call fails, the growl appender will be disabled.
+    #
+    def call_growl( *args )
+      unless system(@growl % args)
+        self.level = :off
+        ::Logsly::Logging182.log_internal {'growl notifications have been disabled'}
+      end
+    end
+
+  end  # Growl
+end  # Logsly::Logging182::Appenders
+

data/lib/logsly/logging182/appenders/io.rb

@@ -0,0 +1,84 @@
+
+module Logsly::Logging182::Appenders
+
+  # Accessor / Factory for the IO appender.
+  #
+  def self.io( *args )
+    return ::Logsly::Logging182::Appenders::IO if args.empty?
+    ::Logsly::Logging182::Appenders::IO.new(*args)
+  end
+
+  # This class provides an Appender that can write to any IO stream
+  # configured for writing.
+  #
+  class IO < ::Logsly::Logging182::Appender
+    include Buffering
+
+    # The method that will be used to close the IO stream. Defaults to :close
+    # but can be :close_read, :close_write or nil. When nil, the IO stream
+    # will not be closed when the appender's close method is called.
+    #
+    attr_accessor :close_method
+
+    # call-seq:
+    #    IO.new( name, io )
+    #    IO.new( name, io, :layout => layout )
+    #
+    # Creates a new IO Appender using the given name that will use the _io_
+    # stream as the logging destination.
+    #
+    def initialize( name, io, opts = {} )
+      unless io.respond_to? :syswrite
+        raise TypeError, "expecting an IO object but got '#{io.class.name}'"
+      end
+
+      @io = io
+      @io.sync = true if io.respond_to? :sync=    # syswrite complains if the IO stream is buffered
+      @io.flush rescue nil                        # syswrite also complains if in unbuffered mode and buffer isn't empty
+      @close_method = :close
+
+      super(name, opts)
+      configure_buffering(opts)
+    end
+
+    # call-seq:
+    #    close( footer = true )
+    #
+    # Close the appender and writes the layout footer to the logging
+    # destination if the _footer_ flag is set to +true+. Log events will
+    # no longer be written to the logging destination after the appender
+    # is closed.
+    #
+    def close( *args )
+      return self if @io.nil?
+      super
+
+      io, @io = @io, nil
+      unless [STDIN, STDERR, STDOUT].include?(io)
+        io.send(@close_method) if @close_method and io.respond_to? @close_method
+      end
+    rescue IOError
+    ensure
+      return self
+    end
+
+
+  private
+
+    # This method is called by the buffering code when messages need to be
+    # written to the logging destination.
+    #
+    def canonical_write( str )
+      return self if @io.nil?
+      str = str.force_encoding(encoding) if encoding and str.encoding != encoding
+      @io.syswrite str
+      self
+    rescue StandardError => err
+      self.level = :off
+      ::Logsly::Logging182.log_internal {"appender #{name.inspect} has been disabled"}
+      ::Logsly::Logging182.log_internal(-2) {err}
+    end
+
+  end  # IO
+end  # Logsly::Logging182::Appenders
+

data/lib/logsly/logging182/appenders/rolling_file.rb

@@ -0,0 +1,338 @@
+
+module Logsly::Logging182::Appenders
+
+  # Accessor / Factory for the RollingFile appender.
+  #
+  def self.rolling_file( *args )
+    return ::Logsly::Logging182::Appenders::RollingFile if args.empty?
+    ::Logsly::Logging182::Appenders::RollingFile.new(*args)
+  end
+
+  # An appender that writes to a file and ensures that the file size or age
+  # never exceeds some user specified level.
+  #
+  # The goal of this class is to write log messages to a file. When the file
+  # age or size exceeds a given limit then the log file is copied and then
+  # truncated. The name of the copy indicates it is an older log file.
+  #
+  # The name of the log file is changed by inserting the age of the log file
+  # (as a single number) between the log file name and the extension. If the
+  # file has no extension then the number is appended to the filename. Here
+  # is a simple example:
+  #
+  #    /var/log/ruby.log   =>   /var/log/ruby.1.log
+  #
+  # New log messages will continue to be appended to the same log file
+  # (<tt>/var/log/ruby.log</tt> in our example above). The age number for all
+  # older log files is incremented when the log file is rolled. The number of
+  # older log files to keep can be given, otherwise all the log files are
+  # kept.
+  #
+  # The actual process of rolling all the log file names can be expensive if
+  # there are many, many older log files to process.
+  #
+  # If you do not wish to use numbered files when rolling, you can specify the
+  # :roll_by option as 'date'. This will use a date/time stamp to
+  # differentiate the older files from one another. If you configure your
+  # rolling file appender to roll daily and ignore the file size:
+  #
+  #    /var/log/ruby.log   =>   /var/log/ruby.20091225.log
+  #
+  # Where the date is expressed as <tt>%Y%m%d</tt> in the Time#strftime format.
+  #
+  # NOTE: this class is not safe to use when log messages are written to files
+  # on NFS mounts or other remote file system. It should only be used for log
+  # files on the local file system. The exception to this is when a single
+  # process is writing to the log file; remote file systems are safe to
+  # use in this case but still not recommended.
+  #
+  class RollingFile < ::Logsly::Logging182::Appenders::IO
+
+    # call-seq:
+    #    RollingFile.new( name, opts )
+    #
+    # Creates a new Rolling File Appender. The _name_ is the unique Appender
+    # name used to retrieve this appender from the Appender hash. The only
+    # required option is the filename to use for creating log files.
+    #
+    #  [:filename]  The base filename to use when constructing new log
+    #               filenames.
+    #
+    # The following options are optional:
+    #
+    #  [:layout]    The Layout that will be used by this appender. The Basic
+    #               layout will be used if none is given.
+    #  [:truncate]  When set to true any existing log files will be rolled
+    #               immediately and a new, empty log file will be created.
+    #  [:size]      The maximum allowed size (in bytes) of a log file before
+    #               it is rolled.
+    #  [:age]       The maximum age (in seconds) of a log file before it is
+    #               rolled. The age can also be given as 'daily', 'weekly',
+    #               or 'monthly'.
+    #  [:keep]      The number of rolled log files to keep.
+    #  [:roll_by]   How to name the rolled log files. This can be 'number' or
+    #               'date'.
+    #
+    def initialize( name, opts = {} )
+      # raise an error if a filename was not given
+      @fn = opts.getopt(:filename, name)
+      raise ArgumentError, 'no filename was given' if @fn.nil?
+
+      @fn = ::File.expand_path(@fn)
+      @fn_copy = @fn + '._copy_'
+      ::Logsly::Logging182::Appenders::File.assert_valid_logfile(@fn)
+
+      # grab our options
+      @size = opts.getopt(:size, :as => Integer)
+
+      code = 'def sufficiently_aged?() false end'
+      @age_fn = @fn + '.age'
+      @age_fn_mtime = nil
+
+      case @age = opts.getopt(:age)
+      when 'daily'
+        code = <<-CODE
+        def sufficiently_aged?
+          @age_fn_mtime ||= ::File.mtime(@age_fn)
+          now = Time.now
+          if (now.day != @age_fn_mtime.day) or (now - @age_fn_mtime) > 86400
+            return true
+          end
+          false
+        end
+        CODE
+      when 'weekly'
+        code = <<-CODE
+        def sufficiently_aged?
+          @age_fn_mtime ||= ::File.mtime(@age_fn)
+          if (Time.now - @age_fn_mtime) > 604800
+            return true
+          end
+          false
+        end
+        CODE
+      when 'monthly'
+        code = <<-CODE
+        def sufficiently_aged?
+          @age_fn_mtime ||= ::File.mtime(@age_fn)
+          now = Time.now
+          if (now.month != @age_fn_mtime.month) or (now - @age_fn_mtime) > 2678400
+            return true
+          end
+          false
+        end
+        CODE
+      when Integer, String
+        @age = Integer(@age)
+        code = <<-CODE
+        def sufficiently_aged?
+          @age_fn_mtime ||= ::File.mtime(@age_fn)
+          if (Time.now - @age_fn_mtime) > @age
+            return true
+          end
+          false
+        end
+        CODE
+      end
+
+      FileUtils.touch(@age_fn) if @age and !test(?f, @age_fn)
+
+      meta = class << self; self end
+      meta.class_eval code, __FILE__, __LINE__
+
+      # we are opening the file in read/write mode so that a shared lock can
+      # be used on the file descriptor => http://pubs.opengroup.org/onlinepubs/009695399/functions/fcntl.html
+      @mode = encoding ? "a+:#{encoding}" : 'a+'
+      super(name, ::File.new(@fn, @mode), opts)
+
+      # setup the file roller
+      @roller =
+          case opts.getopt(:roll_by)
+          when 'number'; NumberedRoller.new(@fn, opts)
+          when 'date'; DateRoller.new(@fn, opts)
+          else
+            (@age and !@size) ?
+                DateRoller.new(@fn, opts) :
+                NumberedRoller.new(@fn, opts)
+          end
+
+      # if the truncate flag was set to true, then roll
+      roll_now = opts.getopt(:truncate, false)
+      if roll_now
+        copy_truncate
+        @roller.roll_files
+      end
+    end
+
+    # Returns the path to the logfile.
+    #
+    def filename() @fn.dup end
+
+    # Reopen the connection to the underlying logging destination. If the
+    # connection is currently closed then it will be opened. If the connection
+    # is currently open then it will be closed and immediately opened.
+    #
+    def reopen
+      @mutex.synchronize {
+        if defined? @io and @io
+          flush
+          @io.close rescue nil
+        end
+        @io = ::File.new(@fn, @mode)
+      }
+      super
+      self
+    end
+
+
+  private
+
+    # Write the given _event_ to the log file. The log file will be rolled
+    # if the maximum file size is exceeded or if the file is older than the
+    # maximum age.
+    #
+    def canonical_write( str )
+      return self if @io.nil?
+
+      str = str.force_encoding(encoding) if encoding and str.encoding != encoding
+      @io.flock_sh { @io.syswrite str }
+
+      if roll_required?
+        @io.flock? {
+          @age_fn_mtime = nil
+          copy_truncate if roll_required?
+        }
+        @roller.roll_files
+      end
+      self
+    rescue StandardError => err
+      self.level = :off
+      ::Logsly::Logging182.log_internal {"appender #{name.inspect} has been disabled"}
+      ::Logsly::Logging182.log_internal(-2) {err}
+    end
+
+    # Returns +true+ if the log file needs to be rolled.
+    #
+    def roll_required?
+      return false if ::File.exist?(@fn_copy) and (Time.now - ::File.mtime(@fn_copy)) < 180
+
+      # check if max size has been exceeded
+      s = @size ? ::File.size(@fn) > @size : false
+
+      # check if max age has been exceeded
+      a = sufficiently_aged?
+
+      return (s || a)
+    end
+
+    # Copy the contents of the logfile to another file. Truncate the logfile
+    # to zero length. This method will set the roll flag so that all the
+    # current logfiles will be rolled along with the copied file.
+    #
+    def copy_truncate
+      return unless ::File.exist?(@fn)
+      FileUtils.concat @fn, @fn_copy
+      @io.truncate 0
+
+      # touch the age file if needed
+      if @age
+        FileUtils.touch @age_fn
+        @age_fn_mtime = nil
+      end
+
+      @roller.roll = true
+    end
+
+
+    # :stopdoc:
+    class NumberedRoller
+      attr_accessor :roll
+
+      def initialize( fn, opts )
+        # grab the information we need to properly roll files
+        ext = ::File.extname(fn)
+        bn = ::File.join(::File.dirname(fn), ::File.basename(fn, ext))
+        @rgxp = %r/\.(\d+)#{Regexp.escape(ext)}\z/
+        @glob = "#{bn}.*#{ext}"
+        @logname_fmt = "#{bn}.%d#{ext}"
+        @fn_copy = fn + '._copy_'
+        @keep = opts.getopt(:keep, :as => Integer)
+        @roll = false
+      end
+
+      def roll_files
+        return unless @roll and ::File.exist?(@fn_copy)
+
+        files = Dir.glob(@glob).find_all {|fn| @rgxp =~ fn}
+        unless files.empty?
+          # sort the files in reverse order based on their count number
+          files = files.sort do |a,b|
+                    a = Integer(@rgxp.match(a)[1])
+                    b = Integer(@rgxp.match(b)[1])
+                    b <=> a
+                  end
+
+          # for each file, roll its count number one higher
+          files.each do |fn|
+            cnt = Integer(@rgxp.match(fn)[1])
+            if @keep and cnt >= @keep
+              ::File.delete fn
+              next
+            end
+            ::File.rename fn, sprintf(@logname_fmt, cnt+1)
+          end
+        end
+
+        # finally rename the copied log file
+        ::File.rename(@fn_copy, sprintf(@logname_fmt, 1))
+      ensure
+        @roll = false
+      end
+    end
+
+    class DateRoller
+      attr_accessor :roll
+
+      def initialize( fn, opts )
+        @fn_copy = fn + '._copy_'
+        @roll = false
+        @keep = opts.getopt(:keep, :as => Integer)
+
+        ext = ::File.extname(fn)
+        bn = ::File.join(::File.dirname(fn), ::File.basename(fn, ext))
+
+        if @keep
+          @rgxp = %r/\.(\d+)(-\d+)?#{Regexp.escape(ext)}\z/
+          @glob = "#{bn}.*#{ext}"
+        end
+
+        if %w[daily weekly monthly].include?(opts.getopt(:age)) and !opts.getopt(:size)
+          @logname_fmt = "#{bn}.%Y%m%d#{ext}"
+        else
+          @logname_fmt = "#{bn}.%Y%m%d-%H%M%S#{ext}"
+        end
+      end
+
+      def roll_files
+        return unless @roll and ::File.exist?(@fn_copy)
+
+        # rename the copied log file
+        ::File.rename(@fn_copy, Time.now.strftime(@logname_fmt))
+
+        # prune old log files
+        if @keep
+          files = Dir.glob(@glob).find_all {|fn| @rgxp =~ fn}
+          length = files.length
+          if length > @keep
+            files.sort {|a,b| b <=> a}.last(length-@keep).each {|fn| ::File.delete fn}
+          end
+        end
+      ensure
+        @roll = false
+      end
+    end
+    # :startdoc:
+
+  end  # RollingFile
+end  # Logsly::Logging182::Appenders
+