Parent

Log4r::Logger

See log4r/logger.rb

Attributes

name[R]
fullname[R]
path[R]
level[R]
parent[R]
additive[R]
trace[R]
outputters[R]

Public Class Methods

[](_fullname) click to toggle source

Get a logger with a fullname from the repository or nil if logger wasn’t found.

    # File lib/log4r/staticlogger.rb, line 12
12:     def self.[](_fullname)
13:       # forces creation of RootLogger if it doesn't exist yet.
14:       return RootLogger.instance if _fullname=='root' or _fullname=='global'
15:       Repository[_fullname]
16:     end
each() click to toggle source

Yields fullname and logger for every logger in the system.

    # File lib/log4r/staticlogger.rb, line 29
29:     def self.each
30:       for fullname, logger in Repository.instance.loggers
31:         yield fullname, logger
32:       end
33:     end
each_logger() click to toggle source
    # File lib/log4r/staticlogger.rb, line 35
35:     def self.each_logger
36:       Repository.instance.loggers.each_value {|logger| yield logger}
37:     end
get(_fullname) click to toggle source

Like Logger[] except that it raises NameError if Logger wasn’t found.

    # File lib/log4r/staticlogger.rb, line 20
20:     def self.get(_fullname)
21:       logger = self[_fullname]
22:       if logger.nil?
23:         raise NameError, "Logger '#{_fullname}' not found.", caller
24:       end
25:       logger
26:     end
global() click to toggle source

Returns the root logger. Identical to Logger.root

   # File lib/log4r/staticlogger.rb, line 7
7:     def self.global; return root end
log_internal(level=1) click to toggle source

Internal logging for Log4r components. Accepts only blocks. To see such log events, create a logger named ‘log4r’ and give it an outputter.

    # File lib/log4r/staticlogger.rb, line 43
43:     def self.log_internal(level=1)
44:       internal = Logger['log4r']
45:       return if internal.nil?
46:       internal.send(LNAMES[level].downcase, yield)
47:     end
new(_fullname, _level=nil, _additive=true, _trace=false) click to toggle source

Logger requires a name. The last 3 parameters are:

level

Do I have a level? (Otherwise, I’ll inherit my parent’s)

additive

Am I additive?

trace

Do I record the execution trace? (slows things a wee bit)

    # File lib/log4r/logger.rb, line 26
26:     def initialize(_fullname, _level=nil, _additive=true, _trace=false)
27:       # validation
28:       raise ArgumentError, "Logger must have a name", caller if _fullname.nil?
29:       Log4rTools.validate_level(_level) unless _level.nil?
30:       validate_name(_fullname)
31:       
32:       # create the logger
33:       @fullname = _fullname
34:       @outputters = []
35:       @additive = _additive
36:       deal_with_inheritance(_level)
37:       LoggerFactory.define_methods(self)
38:       self.trace = _trace
39:       Repository[@fullname] = self
40:     end
root() click to toggle source

Returns the root logger. Identical to Logger.global

   # File lib/log4r/staticlogger.rb, line 5
5:     def self.root; return RootLogger.instance end

Public Instance Methods

==(other) click to toggle source
     # File lib/log4r/logger.rb, line 145
145:     def ==(other)
146:       return true if self.object_id == other.object_id
147:     end
add(*_outputters) click to toggle source

Add outputters by name or by reference. Can be done any time.

     # File lib/log4r/logger.rb, line 119
119:     def add(*_outputters)
120:       for thing in _outputters
121:         o = (thing.kind_of?(Outputter) ? thing : Outputter[thing])
122:         # some basic validation
123:         if not o.kind_of?(Outputter)
124:           raise TypeError, "Expected kind of Outputter, got #{o.class}", caller
125:         elsif o.nil?
126:           raise TypeError, "Couldn't find Outputter '#{thing}'", caller
127:         end
128:         @outputters.push o
129:         Logger.log_internal {"Added outputter '#{o.name}' to '#{@fullname}'"}
130:       end
131:       @outputters
132:     end
additive=(_additive) click to toggle source

Set the additivity of the logger dynamically. True or false.

    # File lib/log4r/logger.rb, line 87
87:     def additive=(_additive)
88:       @additive = _additive
89:       LoggerFactory.define_methods(self)
90:       Logger.log_internal {"Logger '#{@fullname}' is additive"}
91:       @additive
92:     end
is_root?() click to toggle source
     # File lib/log4r/logger.rb, line 143
143:     def is_root?; false end
level=(_level) click to toggle source

Set the logger level dynamically. Does not affect children.

    # File lib/log4r/logger.rb, line 73
73:     def level=(_level)
74:       Log4rTools.validate_level(_level)
75:       @level = _level
76:       LoggerFactory.define_methods(self)
77:       Logger.log_internal {"Logger '#{@fullname}' set to #{LNAMES[@level]}"}
78:       @level
79:     end
levels() click to toggle source

Return array of defined levels.

    # File lib/log4r/logger.rb, line 82
82:     def levels
83:       LNAMES
84:     end
outputters=(_outputters) click to toggle source

Set the Outputters dynamically by name or reference. Can be done any time.

     # File lib/log4r/logger.rb, line 113
113:     def outputters=(_outputters)
114:       @outputters.clear
115:       add(*_outputters)
116:     end
parent=(parent) click to toggle source

Please don’t reset the parent

     # File lib/log4r/logger.rb, line 107
107:     def parent=(parent)
108:       @parent = parent
109:     end
remove(*_outputters) click to toggle source

Remove outputters from this logger by name only. Can be done any time.

     # File lib/log4r/logger.rb, line 135
135:     def remove(*_outputters)
136:       for name in _outputters
137:         o = Outputter[name]
138:         @outputters.delete o
139:         Logger.log_internal {"Removed outputter '#{o.name}' from '#{@fullname}'"}
140:       end
141:     end
trace=(_trace) click to toggle source

Set whether the logger traces. Can be set dynamically. Defaults to false and understands the strings ‘true’ and ‘false’.

     # File lib/log4r/logger.rb, line 96
 96:     def trace=(_trace)
 97:       @trace =
 98:         case _trace
 99:         when "true", true then true
100:         else false end
101:       LoggerFactory.define_methods(self)
102:       Logger.log_internal {"Logger '#{@fullname}' is tracing"} if @trace
103:       @trace
104:     end

Private Instance Methods

deal_with_inheritance(_level) click to toggle source

Parses name for location in heiarchy, sets the parent, and deals with level inheritance

    # File lib/log4r/logger.rb, line 53
53:     def deal_with_inheritance(_level)
54:       mypath = @fullname.split Log4rConfig::LoggerPathDelimiter
55:       @name = mypath.pop
56:       if mypath.empty? # then root is my daddy
57:         @path = ""
58:         # This is one of the guarantees that RootLogger gets created
59:         @parent = Logger.root
60:       else
61:         @path = mypath.join(Log4rConfig::LoggerPathDelimiter)
62:         @parent = Repository.find_ancestor(@path)
63:         @parent = Logger.root if @parent.nil?
64:       end
65:       # inherit the level if no level defined
66:       if _level.nil? then @level = @parent.level
67:       else @level = _level end
68:       Repository.reassign_any_children(self)
69:     end
validate_name(_fullname) click to toggle source
    # File lib/log4r/logger.rb, line 42
42:     def validate_name(_fullname)
43:       parts = _fullname.split Log4rConfig::LoggerPathDelimiter
44:       for part in parts
45:         raise ArgumentError, "Malformed path", caller[1..1] if part.empty?
46:       end
47:     end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.