mack 0.8.1 → 0.8.2

data/lib/gems/logging-0.9.4/lib/logging/appenders/syslog.rb

@@ -0,0 +1,201 @@
+
+begin
+  require 'syslog'
+  HAVE_SYSLOG = true
+rescue LoadError
+  HAVE_SYSLOG = false
+end
+
+# only load this class if we have the syslog library
+# Windows does not have syslog
+#
+if HAVE_SYSLOG
+
+module Logging::Appenders
+
+  # This class provides an Appender that can write to the UNIX syslog
+  # daemon.
+  #
+  class Syslog < ::Logging::Appender
+    include ::Syslog::Constants
+
+    # call-seq:
+    #    Syslog.new( name, opts = {} )
+    #
+    # Create an appender that will log messages to the system message
+    # logger. The message is then written to the system console, log files,
+    # logged-in users, or forwarded to other machines as appropriate. The
+    # options that can be used to configure the appender are as follows:
+    #
+    #    :ident     => identifier string (name is used by default)
+    #    :logopt    => options used when opening the connection
+    #    :facility  => the syslog facility to use
+    #
+    # The parameter :ident is a string that will be prepended to every
+    # message. The :logopt argument is a bit field specifying logging
+    # options, which is formed by OR'ing one or more of the following
+    # values:
+    #
+    #    LOG_CONS      If syslog() cannot pass the message to syslogd(8) it
+    #                  wil attempt to write the message to the console
+    #                  ('/dev/console').
+    #
+    #    LOG_NDELAY    Open the connection to syslogd(8) immediately. Normally
+    #                  the open is delayed until the first message is logged.
+    #                  Useful for programs that need to manage the order in
+    #                  which file descriptors are allocated.
+    #
+    #    LOG_PERROR    Write the message to standard error output as well to
+    #                  the system log.
+    #
+    #    LOG_PID       Log the process id with each message: useful for
+    #                  identifying instantiations of daemons.
+    #
+    # The :facility parameter encodes a default facility to be assigned to
+    # all messages that do not have an explicit facility encoded:
+    #
+    #    LOG_AUTH      The authorization system: login(1), su(1), getty(8),
+    #                  etc.
+    #
+    #    LOG_AUTHPRIV  The same as LOG_AUTH, but logged to a file readable
+    #                  only by selected individuals.
+    #
+    #    LOG_CONSOLE   Messages written to /dev/console by the kernel console
+    #                  output driver.
+    #
+    #    LOG_CRON      The cron daemon: cron(8).
+    #
+    #    LOG_DAEMON    System daemons, such as routed(8), that are not
+    #                  provided for explicitly by other facilities.
+    #
+    #    LOG_FTP       The file transfer protocol daemons: ftpd(8), tftpd(8).
+    #
+    #    LOG_KERN      Messages generated by the kernel. These cannot be
+    #                  generated by any user processes.
+    #
+    #    LOG_LPR       The line printer spooling system: lpr(1), lpc(8),
+    #                  lpd(8), etc.
+    #
+    #    LOG_MAIL      The mail system.
+    #
+    #    LOG_NEWS      The network news system.
+    #
+    #    LOG_SECURITY  Security subsystems, such as ipfw(4).
+    #
+    #    LOG_SYSLOG    Messages generated internally by syslogd(8).
+    #
+    #    LOG_USER      Messages generated by random user processes. This is
+    #                  the default facility identifier if none is specified.
+    #
+    #    LOG_UUCP      The uucp system.
+    #
+    #    LOG_LOCAL0    Reserved for local use. Similarly for LOG_LOCAL1
+    #                  through LOG_LOCAL7.
+    #
+    def initialize( name, opts = {} )
+      ident = opts.getopt(:ident, name)
+      logopt = opts.getopt(:logopt, (LOG_PID | LOG_CONS), :as => Integer)
+      facility = opts.getopt(:facility, LOG_USER, :as => Integer)
+      @syslog = ::Syslog.open(ident, logopt, facility)
+
+      # provides a mapping from the default Logging levels
+      # to the syslog levels
+      @map = [LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERR, LOG_CRIT]
+
+      map = opts.getopt(:map)
+      self.map = map unless map.nil?
+
+      super
+    end
+
+    # call-seq:
+    #    map = { logging_levels => syslog_levels }
+    #
+    # Configure the mapping from the Logging levels to the syslog levels.
+    # This is needed in order to log events at the proper syslog level.
+    #
+    # Without any configuration, the following maping will be used:
+    #
+    #    :debug  =>  LOG_DEBUG
+    #    :info   =>  LOG_INFO
+    #    :warn   =>  LOG_WARNING
+    #    :error  =>  LOG_ERR
+    #    :fatal  =>  LOG_CRIT
+    #
+    def map=( levels )
+      map = []
+      levels.keys.each do |lvl|
+        num = ::Logging.level_num(lvl)
+        map[num] = syslog_level_num(levels[lvl])
+      end
+      @map = map
+    end
+
+    # call-seq:
+    #    close
+    #
+    # Closes the connetion to the syslog facility.
+    #
+    def close( footer = true )
+      super
+      @syslog.close
+      self
+    end
+
+    # call-seq:
+    #    closed?    => true or false
+    #
+    # Queries the connection to the syslog facility and returns +true+ if
+    # the connection is closed.
+    #
+    def closed?
+      !@syslog.opened?
+    end
+
+
+    private
+
+    # call-seq:
+    #    write( event )
+    #
+    # Write the given _event_ to the syslog facility. The log event will be
+    # processed through the Layout assciated with this appender. The message
+    # will be logged at the level specified by the event.
+    #
+    def write( event )
+      pri = LOG_DEBUG
+      message = if event.instance_of?(::Logging::LogEvent)
+          pri = @map[event.level]
+          @layout.format(event)
+        else
+          event.to_s
+        end
+      return if message.empty?
+
+      @syslog.log(pri, '%s', message)
+      self
+    end
+
+    # call-seq:
+    #    syslog_level_num( level )    => integer
+    #
+    # Takes the given _level_ as a string, symbol, or integer and returns
+    # the corresponding syslog level number.
+    #
+    def syslog_level_num( level )
+      case level
+      when Integer; level
+      when String, Symbol
+        level = level.to_s.upcase
+        self.class.const_get level
+      else
+        raise ArgumentError, "unkonwn level '#{level}'"
+      end
+    end
+
+  end  # class Syslog
+
+end  # module Logging::Appenders
+end  # HAVE_SYSLOG
+
+# EOF

data/lib/gems/logging-0.9.4/lib/logging/config/configurator.rb

@@ -0,0 +1,190 @@
+
+module Logging::Config
+
+  # The Configurator class is used to configure the Logging framework
+  # using information found in a block of Ruby code. This block is evaluated
+  # in the context of the configurator's DSL.
+  #
+  class Configurator
+
+    class Error < StandardError; end  # :nodoc:
+
+    # call-seq:
+    #    Configuraotr.process( &block )
+    #
+    def self.process( &block )
+      new.load(&block)
+    end
+
+    # call-seq:
+    #    load { block }
+    #
+    # Loads the configuration from the _block_ and configures the Logging
+    # gem.
+    #
+    def load( &block )
+      raise Error, "missing configuration block" unless block
+
+      dsl = TopLevelDSL.new
+      dsl.__instance_eval(&block)
+
+      pre_config dsl.__pre_config
+      ::Logging::Logger[:root]  # ensures the log levels are defined
+      appenders  dsl.__appenders
+      loggers    dsl.__loggers
+    end
+
+    # call-seq:
+    #    pre_config( config )
+    #
+    # Configures the logging levels, object format style, and root logging
+    # level.
+    #
+    def pre_config( config )
+      if config.nil?
+        ::Logging.init unless ::Logging.const_defined? 'MAX_LEVEL_LENGTH'
+        return
+      end
+
+      # define levels
+      levels = config[:levels]
+      ::Logging.init(levels) unless levels.nil?
+
+      # format as
+      format = config[:format_as]
+      ::Logging.format_as(format) unless format.nil?
+
+      # backtrace
+      value = config[:backtrace]
+      ::Logging.backtrace(value) unless value.nil?
+    end
+
+    # call-seq:
+    #    appenders( ary )
+    #
+    # Given an array of Appender configurations, this method will iterate
+    # over each and create the Appender(s).
+    #
+    def appenders( ary )
+      ary.each {|name, config| appender(name, config)}
+    end
+
+    # call-seq:
+    #    loggers( ary )
+    #
+    # Given an array of Logger configurations, this method will iterate over
+    # each and create the Logger(s).
+    #
+    def loggers( ary )
+      ary.each do |name, config|
+        l = Logging::Logger[name]
+        l.level     = config[:level] if config[:level]
+        l.additive  = config[:additive] if l.respond_to? :additive= 
+        l.trace     = config[:trace]
+        l.appenders = Array(config[:appenders]).
+                            map {|name| ::Logging::Appender[name]}
+      end
+    end
+
+    # call-seq:
+    #    appender( name, config )
+    #
+    # Creates a new Appender based on the given _config_ options (a hash).
+    # The type of Appender created is determined by the 'type' option in the
+    # config. The remaining config options are passed to the Appender
+    # initializer.
+    #
+    # The config options can also contain a 'layout' option. This should be
+    # another set of options used to create a Layout for this Appender.
+    #
+    def appender( name, config )
+      type = config.delete(:type)
+      raise Error, "appender type not given for #{name.inspect}" if type.nil?
+
+      config[:layout] = layout(config[:layout]) if config.has_key? :layout
+
+      clazz = ::Logging::Appenders.const_get type
+      clazz.new(name, config)
+    rescue NameError => err
+      raise Error, "unknown appender class Logging::Appenders::#{type}"
+    end
+
+    # call-seq:
+    #    layout( config )
+    #
+    # Creates a new Layout based on the given _config_ options (a hash).
+    # The type of Layout created is determined by the 'type' option in the
+    # config. The remaining config options are passed to the Layout
+    # initializer.
+    #
+    def layout( config )
+      return ::Logging::Layouts::Basic.new if config.nil?
+
+      type = config.delete(:type)
+      raise Error, 'layout type not given' if type.nil?
+
+      clazz = ::Logging::Layouts.const_get type
+      clazz.new config
+    rescue NameError => err
+      raise Error, "unknown layout class Logging::Layouts::#{type}"
+    end
+
+    class DSL
+      alias :__instance_eval :instance_eval
+
+      instance_methods.each do |m|
+        undef_method m unless m[%r/^__/]
+      end
+
+      def self.process( &block )
+        dsl = new
+        dsl.__instance_eval(&block)
+        dsl.__hash
+      end
+
+      def __hash
+        @hash ||= Hash.new
+      end
+
+      def method_missing( method, *args, &block )
+        args << DSL.process(&block) if block
+
+        key = method.to_sym
+        value = (1 == args.length ? args.first : args)
+        __store(key, value)
+      end
+
+      def __store( key, value )
+        __hash[key] = value
+      end
+    end
+
+    class TopLevelDSL < DSL
+      undef_method :method_missing
+
+      def initialize
+        @loggers = []
+        @appenders = []
+      end
+
+      def pre_config( &block )
+        __store(:preconfig, DSL.process(&block))
+      end
+
+      def logger( name, &block )
+        @loggers << [name, DSL.process(&block)]
+      end
+
+      def appender( name, &block )
+        @appenders << [name, DSL.process(&block)]
+      end
+
+      def __pre_config() __hash[:preconfig]; end
+      def __loggers() @loggers; end
+      def __appenders() @appenders; end
+    end
+
+  end  # class Configurator
+end  # module Logging::Config
+
+# EOF

data/lib/gems/logging-0.9.4/lib/logging/config/yaml_configurator.rb

@@ -0,0 +1,195 @@
+
+require 'yaml'
+
+module Logging
+module Config
+
+  # The YamlConfigurator class is used to configure the Logging framework
+  # using information found in a YAML file.
+  #
+  class YamlConfigurator
+
+    class Error < StandardError; end  # :nodoc:
+
+    class << self
+
+      # call-seq:
+      #    YamlConfigurator.load( file, key = 'logging_config' )
+      #
+      # Load the given YAML _file_ and use it to configure the Logging
+      # framework. The file can be either a filename, and open File, or an
+      # IO object. If it is the latter two, the File / IO object will not be
+      # closed by this method.
+      #
+      # The configuration will be loaded from the given _key_ in the YAML
+      # stream.
+      #
+      def load( file, key = 'logging_config' )
+        io, close = nil, false
+        case file
+        when String
+          io = File.open(file, 'r')
+          close = true
+        when IO
+          io = file
+        else
+          raise Error, 'expecting a filename or a File'
+        end
+
+        begin
+          new(io, key).load
+        ensure
+          io.close if close
+        end
+        nil
+      end
+    end  # class << self
+
+    # call-seq:
+    #    YamlConfigurator.new( io, key )
+    #
+    # Creates a new YAML configurator that will load the Logging
+    # configuration from the given _io_ stream. The configuration will be
+    # loaded from the given _key_ in the YAML stream.
+    #
+    def initialize( io, key  )
+      YAML.load_documents(io) do |doc|
+        @config = doc[key]
+        break if @config.instance_of?(Hash)
+      end
+
+      unless @config.instance_of?(Hash)
+        raise Error, "Key '#{key}' not defined in YAML configuration"
+      end
+    end
+
+    # call-seq:
+    #    load
+    #
+    # Loads the Logging configuration from the data loaded from the YAML
+    # file.
+    #
+    def load
+      pre_config @config['pre_config']
+      ::Logging::Logger[:root]  # ensures the log levels are defined
+      appenders @config['appenders']
+      loggers @config['loggers']
+    end
+
+    # call-seq:
+    #    pre_config( config )
+    #
+    # Configures the logging levels, object format style, and root logging
+    # level.
+    #
+    def pre_config( config )
+      # if no pre_config section was given, just create an empty hash
+      # we do this to ensure that some logging levels are always defined
+      config ||= Hash.new
+
+      # define levels
+      levels = config['define_levels']
+      ::Logging.init(levels) unless levels.nil?
+
+      # format as
+      format = config['format_as']
+      ::Logging.format_as(format) unless format.nil?
+
+      # backtrace
+      value = config['backtrace']
+      ::Logging.backtrace(value) unless value.nil?
+
+      # grab the root logger and set the logging level
+      root = ::Logging::Logger.root
+      if config.has_key?('root')
+        root.level = config['root']['level']
+      end
+    end
+
+    # call-seq:
+    #    appenders( ary )
+    #
+    # Given an array of Appender configurations, this method will iterate
+    # over each and create the Appender(s).
+    #
+    def appenders( ary )
+      return if ary.nil?
+
+      ary.each {|h| appender(h)}
+    end
+
+    # call-seq:
+    #    loggers( ary )
+    #
+    # Given an array of Logger configurations, this method will iterate over
+    # each and create the Logger(s).
+    #
+    def loggers( ary )
+      return if ary.nil?
+
+      ary.each do |config|
+        name = config['name']
+        raise Error, 'Logger name not given' if name.nil?
+
+        l = Logging::Logger.new name
+        l.level = config['level'] if config.has_key?('level')
+        l.additive = config['additive'] if l.respond_to? :additive=
+        l.trace = config['trace'] if l.respond_to? :trace=
+
+        if config.has_key?('appenders')
+          l.appenders = config['appenders'].map {|n| ::Logging::Appender[n]}
+        end
+      end
+    end
+
+    # call-seq:
+    #    appender( config )
+    #
+    # Creates a new Appender based on the given _config_ options (a hash).
+    # The type of Appender created is determined by the 'type' option in the
+    # config. The remaining config options are passed to the Appender
+    # initializer.
+    #
+    # The config options can also contain a 'layout' option. This should be
+    # another set of options used to create a Layout for this Appender.
+    #
+    def appender( config )
+      return if config.nil?
+      config = config.dup
+
+      type = config.delete('type')
+      raise Error, 'Appender type not given' if type.nil?
+
+      name = config.delete('name')
+      raise Error, 'Appender name not given' if name.nil?
+
+      config['layout'] = layout(config.delete('layout'))
+
+      clazz = ::Logging::Appenders.const_get type
+      clazz.new(name, config)
+    end
+
+    # call-seq:
+    #    layout( config )
+    #
+    # Creates a new Layout based on the given _config_ options (a hash).
+    # The type of Layout created is determined by the 'type' option in the
+    # config. The remaining config options are passed to the Layout
+    # initializer.
+    #
+    def layout( config )
+      return if config.nil?
+      config = config.dup
+
+      type = config.delete('type')
+      raise Error, 'Layout type not given' if type.nil?
+
+      clazz = ::Logging::Layouts.const_get type
+      clazz.new config
+    end
+
+  end  # class YamlConfigurator
+end  # module Config
+end  # module Logging
+
+# EOF