Class: Logging::Config::Configurator

Inherits:
Object
  • Object
show all
Defined in:
lib/logging/config/configurator.rb

Overview

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.

Defined Under Namespace

Classes: DSL, Error, TopLevelDSL

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.process(&block) ⇒ Object

call-seq:

Configurator.process( &block )



15
16
17
 
# File 'lib/logging/config/configurator.rb', line 15

def self.process( &block )
  new.load(&block)
end

Instance Method Details

#appender(name, config) ⇒ Object

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.



100
101
102
103
104
105
106
107
108
109
110
 
# File 'lib/logging/config/configurator.rb', line 100

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
  raise Error, "unknown appender class Logging::Appenders::#{type}"
end

#appenders(ary) ⇒ Object

call-seq:

appenders( ary )

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



68
69
70
 
# File 'lib/logging/config/configurator.rb', line 68

def appenders( ary )
  ary.each {|name, config| appender(name, config)}
end

#layout(config) ⇒ Object

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.



120
121
122
123
124
125
126
127
128
129
130
 
# File 'lib/logging/config/configurator.rb', line 120

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
  raise Error, "unknown layout class Logging::Layouts::#{type}"
end

#load(&block) ⇒ Object

call-seq:

load { block }

Loads the configuration from the block and configures the Logging gem.

Raises:



25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/logging/config/configurator.rb', line 25

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

#loggers(ary) ⇒ Object

call-seq:

loggers( ary )

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



78
79
80
81
82
83
84
85
86
87
 
# File 'lib/logging/config/configurator.rb', line 78

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 {|nm| ::Logging::Appenders[nm]}
  end
end

#pre_config(config) ⇒ Object

call-seq:

pre_config( config )

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



43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/logging/config/configurator.rb', line 43

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