Parent

Included Modules

Log4r::Configurator

See log4r/configurator.rb

Constants

ExcludeParams

Public Class Methods

[](param) click to toggle source

Get a parameter’s value

    # File lib/log4r/configurator.rb, line 25
25:     def self.[](param); @@params[param] end
[]=(param, value) click to toggle source

Define a parameter with a value

    # File lib/log4r/configurator.rb, line 27
27:     def self.[]=(param, value); @@params[param] = value end
custom_levels(*levels) click to toggle source

Sets the custom levels. This method accepts symbols or strings.

  Configurator.custom_levels('My', 'Custom', :Levels)

Alternatively, you can specify custom levels in XML:

  <log4r_config>
    <pre_config>
      <custom_levels>
        My, Custom, Levels
      </custom_levels>
      ...
    # File lib/log4r/configurator.rb, line 42
42:     def self.custom_levels(*levels)
43:       return Logger.root if levels.size == 0
44:       for i in 0...levels.size
45:         name = levels[i].to_s
46:         if name =~ /\s/ or name !~ /^[A-Z]/
47:           raise TypeError, "#{name} is not a valid Ruby Constant name", caller
48:         end
49:       end
50:       Log4r.define_levels *levels
51:     end
load_xml_file(filename) click to toggle source

Given a filename, loads the XML configuration for Log4r.

    # File lib/log4r/configurator.rb, line 54
54:     def self.load_xml_file(filename)
55:       detect_rexml
56:       actual_load Document.new(File.new(filename))
57:     end
load_xml_string(string) click to toggle source

You can load a String XML configuration instead of a file.

    # File lib/log4r/configurator.rb, line 60
60:     def self.load_xml_string(string)
61:       detect_rexml
62:       actual_load Document.new(string)
63:     end

Private Class Methods

actual_load(doc) click to toggle source
    # File lib/log4r/configurator.rb, line 76
76:     def self.actual_load(doc)
77:       confignode = doc.elements['//log4r_config']
78:       if confignode.nil?
79:         raise ConfigError, 
80:         "<log4r_config> element not defined", caller[1..1]
81:       end
82:       decode_xml(confignode)
83:     end
decode_custom_levels(e) click to toggle source
     # File lib/log4r/configurator.rb, line 101
101:     def self.decode_custom_levels(e)
102:       return Logger.root if e.nil? or e.text.nil?
103:       begin custom_levels *Log4rTools.comma_split(e.text)
104:       rescue TypeError => te
105:         raise ConfigError, te.message, caller[1..4]
106:       end
107:     end
decode_formatter(e) click to toggle source
     # File lib/log4r/configurator.rb, line 160
160:     def self.decode_formatter(e)
161:       return nil if e.nil?
162:       type = e.value_of 'type' 
163:       raise ConfigError, "Formatter missing type", caller[1..4] if type.nil?
164:       buff = "#{type}.new " + decode_hash_params(e).join(',')
165:       begin return eval(buff)
166:       rescue Exception => ae
167:         raise ConfigError,
168:         "Problem creating outputter: #{ae.message}", caller[1..4]
169:       end
170:     end
decode_hash_params(e) click to toggle source

Does the fancy parameter to hash argument transformation

     # File lib/log4r/configurator.rb, line 175
175:     def self.decode_hash_params(e)
176:       buff = []
177:       e.attributes.each_attribute {|p| 
178:         next if ExcludeParams.include? p.name
179:         buff << ":" + p.name + "=>" + paramsub(p.value)
180:       }
181:       e.elements.each {|p| 
182:         next if ExcludeParams.include? p.name
183:         buff << ":" + p.name + "=>" + paramsub(p.text)
184:       }
185:       buff
186:     end
decode_logger(e) click to toggle source
     # File lib/log4r/configurator.rb, line 195
195:     def self.decode_logger(e)
196:       l = Logger.new e.value_of('name')
197:       decode_logger_common(l, e)
198:     end
decode_logger_common(l, e) click to toggle source
     # File lib/log4r/configurator.rb, line 208
208:     def self.decode_logger_common(l, e)
209:       level = e.value_of 'level'
210:       additive = e.value_of 'additive'
211:       trace = e.value_of 'trace'
212:       l.level = LNAMES.index(level) unless level.nil?
213:       l.additive = additive unless additive.nil?
214:       l.trace = trace unless trace.nil?
215:       # and now for outputters
216:       outs = e.value_of 'outputters'
217:       Log4rTools.comma_split(outs).each {|n| l.add n.strip} unless outs.nil?
218:       e.elements.each('outputter') {|e|
219:         name = (e.value_of 'name' or e.text)
220:         l.add Outputter[name]
221:       }
222:     end
decode_logserver(e) click to toggle source
     # File lib/log4r/configurator.rb, line 200
200:     def self.decode_logserver(e)
201:       return unless HAVE_REXML
202:       name = e.value_of 'name'
203:       uri = e.value_of 'uri'
204:       l = LogServer.new name, uri
205:       decode_logger_common(l, e)
206:     end
decode_outputter(e) click to toggle source
     # File lib/log4r/configurator.rb, line 126
126:     def self.decode_outputter(e)
127:       # fields
128:       name = e.value_of 'name'
129:       type = e.value_of 'type'
130:       level = e.value_of 'level'
131:       only_at = e.value_of 'only_at'
132:       # validation
133:       raise ConfigError, "Outputter missing name", caller[1..3] if name.nil?
134:       raise ConfigError, "Outputter missing type", caller[1..3] if type.nil?
135:       Log4rTools.validate_level(LNAMES.index(level)) unless level.nil?
136:       only_levels = []
137:       unless only_at.nil?
138:         for lev in Log4rTools.comma_split(only_at)
139:           alev = LNAMES.index(lev)
140:           Log4rTools.validate_level(alev, 3)
141:           only_levels.push alev
142:         end
143:       end
144:       formatter = decode_formatter(e.elements['formatter'])
145:       # build the eval string
146:       buff = "Outputter[name] = #{type}.new name"
147:       buff += ",:level=>#{LNAMES.index(level)}" unless level.nil?
148:       buff += ",:formatter=>formatter" unless formatter.nil?
149:       params = decode_hash_params(e)
150:       buff += "," + params.join(',') if params.size > 0
151:       begin eval buff
152:       rescue Exception => ae
153:         raise ConfigError, 
154:         "Problem creating outputter: #{ae.message}", caller[1..3]
155:       end
156:       Outputter[name].only_at *only_levels if only_levels.size > 0
157:       Outputter[name]
158:     end
decode_parameter(e) click to toggle source
     # File lib/log4r/configurator.rb, line 122
122:     def self.decode_parameter(e)
123:       @@params[e.value_of('name')] = e.value_of 'value'
124:     end
decode_parameters(e) click to toggle source
     # File lib/log4r/configurator.rb, line 118
118:     def self.decode_parameters(e)
119:       e.elements.each{|p| @@params[p.name] = p.text} unless e.nil?
120:     end
decode_pre_config(e) click to toggle source
    # File lib/log4r/configurator.rb, line 92
92:     def self.decode_pre_config(e)
93:       return Logger.root if e.nil?
94:       decode_custom_levels(e.elements['custom_levels'])
95:       global_config(e.elements['global'])
96:       global_config(e.elements['root'])
97:       decode_parameters(e.elements['parameters'])
98:       e.elements.each('parameter') {|p| decode_parameter(p)}
99:     end
decode_xml(doc) click to toggle source
    # File lib/log4r/configurator.rb, line 85
85:     def self.decode_xml(doc)
86:       decode_pre_config(doc.elements['pre_config'])
87:       doc.elements.each('outputter') {|e| decode_outputter(e)}
88:       doc.elements.each('logger') {|e| decode_logger(e)}
89:       doc.elements.each('logserver') {|e| decode_logserver(e)}
90:     end
detect_rexml() click to toggle source
    # File lib/log4r/configurator.rb, line 69
69:     def self.detect_rexml
70:       unless HAVE_REXML
71:         raise LoadError,
72:         "Need REXML to load XML configuration", caller[1..1]
73:       end
74:     end
global_config(e) click to toggle source
     # File lib/log4r/configurator.rb, line 109
109:     def self.global_config(e)
110:       return if e.nil?
111:       globlev = e.value_of 'level'
112:       return if globlev.nil?
113:       lev = LNAMES.index(globlev)     # find value in LNAMES
114:       Log4rTools.validate_level(lev, 4)  # choke on bad level
115:       Logger.global.level = lev
116:     end
paramsub(str) click to toggle source

Substitues any #{foo} in the XML with Parameter[‘foo’]

     # File lib/log4r/configurator.rb, line 189
189:     def self.paramsub(str)
190:       return nil if str.nil?
191:       @@params.each {|param, value| str.sub! '#{'+param+'}', value}
192:       "'" + str + "'"
193:     end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.