Class: Logging::Config::YamlConfigurator

### Home Classes Methods

### In Files

- lib/logging/config/yaml_configurator.rb

### Parent

Object

### Namespace

- CLASS Logging::Config::YamlConfigurator::Error

### Methods

- ::load
- ::new
- #appender
- #appenders
- #layout
- #load
- #loggers
- #pre_config

### Files

- History.txt
- README.rdoc

### Class/Module Index

Quicksearch

- Logging
- Logging::Appender
- Logging::Appenders
- Logging::Appenders::Buffering
- Logging::Appenders::Email
- Logging::Appenders::File
- Logging::Appenders::Growl
- Logging::Appenders::IO
- Logging::Appenders::RollingFile
- Logging::Appenders::Stderr
- Logging::Appenders::Stdout
- Logging::Appenders::StringIo
- Logging::Appenders::Syslog
- Logging::ColorScheme
- Logging::Config
- Logging::Config::Configurator
- Logging::Config::Configurator::DSL
- Logging::Config::Configurator::Error
- Logging::Config::Configurator::TopLevelDSL
- Logging::Config::YamlConfigurator
- Logging::Config::YamlConfigurator::Error
- Logging::Layout
- Logging::Layouts
- Logging::Layouts::Basic
- Logging::Layouts::Parseable
- Logging::Layouts::Pattern
- Logging::Logger
- Logging::MappedDiagnosticContext
- Logging::NestedDiagnosticContext
- Logging::Proxy
- Logging::RailsCompat
- Logging::Repository
- Logging::Repository::Singleton
- Logging::RootLogger
- Logging::Stats
- Logging::Stats::Sampler
- Logging::Stats::Tracker
- RSpec
- RSpec::Core
- RSpec::Core::Configuration
- RSpec::LoggingHelper
- RSpec::LoggingHelper
- Spec
- Spec::Runner
- Spec::Runner::Configuration
- Object
- Object::LoggingHelper
- File
- FileUtils
- Hash
- Kernel
- Module
- ReentrantMutex
- String

No matching classes.

# Logging::Config::YamlConfigurator

The YamlConfigurator class is used to configure the Logging framework using information found in a YAML file.

### Public Class Methods

load( file, key = 'logging_config' ) click to toggle source

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.

    # File lib/logging/config/yaml_configurator.rb, line 24
    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

new( io, key ) click to toggle source

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.

    # File lib/logging/config/yaml_configurator.rb, line 52
    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

### Public Instance Methods

appender( config ) click to toggle source

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.

    # File lib/logging/config/yaml_configurator.rb, line 153
    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

appenders( ary ) click to toggle source

Given an array of Appender configurations, this method will iterate over each and create the Appender(s).

    # File lib/logging/config/yaml_configurator.rb, line 112
    def appenders( ary )
      return if ary.nil?

      ary.each {|h| appender(h)}
    end

layout( config ) click to toggle source

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.

    # File lib/logging/config/yaml_configurator.rb, line 177
    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

load click to toggle source

Loads the Logging configuration from the data loaded from the YAML file.

    # File lib/logging/config/yaml_configurator.rb, line 69
    def load
      pre_config @config['pre_config']
      ::Logging::Logger[:root]  # ensures the log levels are defined
      appenders @config['appenders']
      loggers @config['loggers']
    end

loggers( ary ) click to toggle source

Given an array of Logger configurations, this method will iterate over each and create the Logger(s).

    # File lib/logging/config/yaml_configurator.rb, line 124
    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::Appenders[n]}
        end
      end
    end

pre_config( config ) click to toggle source

Configures the logging levels, object format style, and root logging level.

    # File lib/logging/config/yaml_configurator.rb, line 82
    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

[Validate]

Generated with the Darkfish Rdoc Generator 2.