Class: Log4r::YamlConfigurator

Inherits:
Object
  • Object
show all
Defined in:
lib/j1_app/log4r/yamlconfigurator.rb

Overview

See log4r/yamlconfigurator.rb

Constant Summary collapse

@@params = 
Hash.new

Class Method Summary collapse

Class Method Details

.[](param) ⇒ Object

Get a parameter’s value



17
 
# File 'lib/j1_app/log4r/yamlconfigurator.rb', line 17

def self.[](param); @@params[param] end

.[]=(param, value) ⇒ Object

Define a parameter with a value



19
 
# File 'lib/j1_app/log4r/yamlconfigurator.rb', line 19

def self.[]=(param, value); @@params[param] = value end

.actual_load(yaml_docs) ⇒ Object 



47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
# File 'lib/j1_app/log4r/yamlconfigurator.rb', line 47

def self.actual_load(yaml_docs)
  log4r_config = nil
  # See:    https://ruby-doc.org/stdlib-2.4.1/libdoc/psych/rdoc/Psych.html#method-c-load_documents
  # NOTE:   'load_documents' method from Psych is deprecated (removed since ruby 2.5)
  # NOTE:   use ::load_stream instead
#     YAML.load_documents( yaml_docs){ |doc|
  YAML.load_stream(yaml_docs){ |doc|
    doc.has_key?('log4r_config') and log4r_config = doc['log4r_config'] and break
  }
  if log4r_config.nil?
    raise ConfigError,
      "Key 'log4r_config:' not defined in yaml documents", caller[1..-1]
  end
  decode_yaml(log4r_config)
end

.custom_levels(levels) ⇒ Object 



21
22
23
24
25
26
27
28
29
30
 
# File 'lib/j1_app/log4r/yamlconfigurator.rb', line 21

def self.custom_levels(levels)
  return Logger.root if levels.size == 0
  for i in 0...levels.size
    name = levels[i].to_s
    if name =~ /\s/ or name !~ /^[A-Z]/
      raise TypeError, "#{name} is not a valid Ruby Constant name", caller
    end
  end
  Log4r.define_levels *levels
end

.decode_custom_levels(levels) ⇒ Object 



78
79
80
81
82
83
84
 
# File 'lib/j1_app/log4r/yamlconfigurator.rb', line 78

def self.decode_custom_levels(levels)
  return Logger.root if levels.nil?
  begin custom_levels(levels)
  rescue TypeError => te
    raise ConfigError, te.message, caller[1..-4]
  end
end

.decode_formatter(fo) ⇒ Object

Raises:



135
136
137
138
139
140
141
142
143
144
145
 
# File 'lib/j1_app/log4r/yamlconfigurator.rb', line 135

def self.decode_formatter(fo)
  return nil if fo.nil?
  type = fo['type']
  raise ConfigError, "Formatter missing type", caller[1..-4] if type.nil?
  begin
    return Log4r.const_get(type).new(decode_hash_params(fo))
  rescue Exception => ae
    raise ConfigError,
          "Problem creating outputter: #{ae.message}", caller[1..-4]
  end
end

.decode_hash_params(ph) ⇒ Object

Does the fancy parameter to hash argument transformation



150
151
152
153
154
155
156
157
158
159
160
161
 
# File 'lib/j1_app/log4r/yamlconfigurator.rb', line 150

def self.decode_hash_params(ph)
  case ph
  when Hash
    ph.inject({}){|a,(k,v)| a[k] = self.decode_hash_params(v); a}
  when Array
    ph.map{|v| self.decode_hash_params(v)}
  when String
    self.paramsub(ph)
  else
    ph
  end
end

.decode_logger(lo) ⇒ Object 



171
172
173
174
 
# File 'lib/j1_app/log4r/yamlconfigurator.rb', line 171

def self.decode_logger(lo)
  l = Logger.new lo['name']
  decode_logger_common(l, lo)
end

.decode_logger_common(l, lo) ⇒ Object 



183
184
185
186
187
188
189
190
191
192
193
 
# File 'lib/j1_app/log4r/yamlconfigurator.rb', line 183

def self.decode_logger_common(l, lo)
  level    = lo['level']
  additive = lo['additive']
  trace    = lo['trace']
  l.level    = LNAMES.index( level) unless level.nil?
  l.additive = additive unless additive.nil?
  l.trace    = trace unless trace.nil?
  # and now for outputters
  outs = lo['outputters']
  outs.each {|n| l.add n.strip} unless outs.nil?
end

.decode_logserver(lo) ⇒ Object 



176
177
178
179
180
181
 
# File 'lib/j1_app/log4r/yamlconfigurator.rb', line 176

def self.decode_logserver(lo)
  name = lo['name']
  uri  = lo['uri']
  l = LogServer.new name, uri
  decode_logger_common(l, lo)
end

.decode_outputter(op) ⇒ Object

Raises:



99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
 
# File 'lib/j1_app/log4r/yamlconfigurator.rb', line 99

def self.decode_outputter(op)
  # fields
  name    = op['name']
  type    = op['type']
  level   = op['level']
  only_at = op['only_at']

  # validation
  raise ConfigError, "Outputter missing name", caller[1..-3] if name.nil?
  raise ConfigError, "Outputter missing type", caller[1..-3] if type.nil?
  Log4rTools.validate_level(LNAMES.index(level)) unless level.nil?
  only_levels = []
  unless only_at.nil?
    for lev in only_at
      alev = LNAMES.index(lev)
      Log4rTools.validate_level(alev, 3)
      only_levels.push alev
    end
  end

  formatter = decode_formatter(op['formatter'])

  opts = {}
  opts[:level] = LNAMES.index(level) unless level.nil?
  opts[:formatter] = formatter unless formatter.nil?
  opts.merge!(decode_hash_params(op))
  begin
    Outputter[name] = Log4r.const_get(type).new name, opts
  rescue Exception => ae
    raise ConfigError,
      "Problem creating outputter: #{ae.message}", caller[1..-3]
  end
  Outputter[name].only_at(*only_levels) if only_levels.size > 0
  Outputter[name]
end

.decode_parameters(params) ⇒ Object 



95
96
97
 
# File 'lib/j1_app/log4r/yamlconfigurator.rb', line 95

def self.decode_parameters(params)
  params.each{ |p| @@params[p['name']] = p['value']} unless params.nil?
end

.decode_pre_config(pre) ⇒ Object 



70
71
72
73
74
75
76
 
# File 'lib/j1_app/log4r/yamlconfigurator.rb', line 70

def self.decode_pre_config(pre)
  return Logger.root if pre.nil?
  decode_custom_levels( pre['custom_levels'])
  global_config( pre['global'])
  global_config( pre['root'])
  decode_parameters( pre['parameters'])
end

.decode_yaml(cfg) ⇒ Object 



63
64
65
66
67
68
 
# File 'lib/j1_app/log4r/yamlconfigurator.rb', line 63

def self.decode_yaml(cfg)
  decode_pre_config(cfg['pre_config'])
  cfg['outputters'].each{ |op| decode_outputter(op)}
  cfg['loggers'].each{ |lo| decode_logger(lo)}
  cfg['logserver'].each{ |lo| decode_logserver(lo)} unless cfg['logserver'].nil?
end

.global_config(e) ⇒ Object 



86
87
88
89
90
91
92
93
 
# File 'lib/j1_app/log4r/yamlconfigurator.rb', line 86

def self.global_config(e)
  return if e.nil?
  globlev = e['level']
  return if globlev.nil?
  lev = LNAMES.index(globlev)                                               # find value in LNAMES
  Log4rTools.validate_level(lev, 4)                                         # choke on bad level
  Logger.global.level = lev
end

.load_yaml_file(filename) ⇒ Object

Given a filename, loads the YAML configuration for Log4r



33
34
35
 
# File 'lib/j1_app/log4r/yamlconfigurator.rb', line 33

def self.load_yaml_file(filename)
  actual_load( File.open(filename))
end

.load_yaml_string(string) ⇒ Object

You can load a String YAML configuration instead of a file



38
39
40
 
# File 'lib/j1_app/log4r/yamlconfigurator.rb', line 38

def self.load_yaml_string(string)
  actual_load(string)
end

.paramsub(str) ⇒ Object

Substitues any #foo in the YAML with Parameter



164
165
166
167
168
169
 
# File 'lib/j1_app/log4r/yamlconfigurator.rb', line 164

def self.paramsub(str)
  @@params.each {|param, value|
    str = str.sub("\#{#{param}}", value)
  }
  str
end