Arrow::Logger

A log class for Arrow systems.

Constants

SVNRev: SVN Revision
SVNId: SVN Id
Levels: Construct a log levels Hash on the fly
LevelNames: (Not documented)

Attributes

level[R]

The integer level of the logger.

name[R]

The name of this logger

outputters[RW]

The outputters attached to this branch of the logger tree.

subloggers[RW]

The branches of the logging hierarchy that fall below this one.

superlogger[R]

The logger object that is this logger‘s parent (if any).

trace[RW]

Set to a true value to turn tracing on

Public Class Methods

[]( mod=nil ) click to toggle source

Return the Arrow::Logger for the given module mod, which can be a Module object, a Symbol, or a String.

     # File lib/arrow/logger.rb, line 160
160:     def self::[]( mod=nil )
161:         modname = mod.to_s
162:         return self.global if modname.empty?
163: 
164:         names = modname.split( /::/ )
165: 
166:         # Create the global logger if it isn't already created
167:         self.global
168: 
169:         names.inject( @global_logger ) {|logger,key| logger[key]}
170:     end

configure( config, dispatcher ) click to toggle source

Configure logging from the ‘logging’ section of the config.

     # File lib/arrow/logger.rb, line 100
100:     def self::configure( config, dispatcher )
101: 
102:         self.reset
103:         apacheoutputter = Arrow::Logger::Outputter.create( 'apache' )
104: 
105:         config.each do |klass, setting|
106:             level, uri = self.parse_log_setting( setting )
107: 
108:             # Use the Apache log as the outputter if none is configured
109:             if uri.nil?
110:                 outputter = apacheoutputter
111:             else
112:                 outputter = Arrow::Logger::Outputter.create( uri )
113:             end
114: 
115:             # The 'global' entry configured the global logger
116:             if klass == :global
117:                 self.global.level = level
118:                 self.global.outputters << outputter
119:                 next
120:             end
121: 
122:             # If the class bit is something like 'applet', then transform
123:             # it into 'Arrow::Applet'
124:             if klass.to_s.match( /^[a-z][a-zA-Z]+$/ )
125:                 realclass = "Arrow::%s" % klass.to_s.sub(/^([a-z])/){ $1.upcase }
126:             else
127:                 realclass = klass.to_s
128:             end
129: 
130:             Arrow::Logger[ realclass ].level = level
131:             Arrow::Logger[ realclass ].outputters << outputter
132:         end
133:         
134:     end

global() click to toggle source

Return the global Arrow logger, setting it up if it hasn‘t been already.

     # File lib/arrow/logger.rb, line 175
175:     def self::global
176:         # debug_msg "Creating the global logger" unless @global_logger
177:         @global_logger ||= new( '' )
178:     end

method_missing( sym, *args ) click to toggle source

Autoload global logging methods for the log levels

     # File lib/arrow/logger.rb, line 190
190:     def self::method_missing( sym, *args )
191:         return super unless Levels.key?( sym )
192: 
193:         self.global.debug( "Autoloading class log method '#{sym}'." )
194:         (class << self; self; end).class_eval do
195:             define_method( sym ) do |*args|
196:                 self.global.send( sym, *args )
197:             end
198:         end
199: 
200:         self.global.send( sym, *args )
201:     end

new( name, level=:info, superlogger=nil, *outputters ) click to toggle source

Create and return a new Arrow::Logger object with the given name at the specified level, with the specified superlogger. Any outputters that are specified will be added.

     # File lib/arrow/logger.rb, line 211
211:     def initialize( name, level=:info, superlogger=nil, *outputters )
212:         if name.empty?
213:             # debug_msg "Creating global logger"
214:         else
215:             # debug_msg "Creating logger for #{name}"
216:         end
217: 
218:         @name = name
219:         @outputters = outputters
220:         @subloggers = {}
221:         @superlogger = superlogger
222:         @trace = false
223:         @level = nil
224: 
225:         self.level = level
226:     end

parse_log_setting( setting ) click to toggle source

Parse the configuration for a given class‘s logger. The configuration is in the form:

  <level> [<outputter_uri>]

where level is one of the logging levels defined by this class (see the Levels constant), and the optional outputter_uri indicates which outputter to use, and how it should be configured. See Arrow::Logger::Outputter for more info.

Examples:

  notice
  debug file:///tmp/broker-debug.log
  error dbi://www:password@localhost/www.errorlog?driver=postgresql

     # File lib/arrow/logger.rb, line 150
150:     def self::parse_log_setting( setting )
151:         level, rawuri = setting.split( ' ', 2 )
152:         uri = rawuri.nil? ? nil : URI.parse( rawuri )
153:         
154:         return level.to_sym, uri
155:     end

reset() click to toggle source

Reset the logging subsystem. Clears out any registered loggers and their associated outputters.

     # File lib/arrow/logger.rb, line 183
183:     def self::reset
184:         # debug_msg "Resetting the global logger"
185:         @global_logger = nil
186:     end

Public Instance Methods

<<( obj ) click to toggle source

Append the given obj to the logger at +:debug+ level. This is for compatibility with objects that append to $stderr for their logging (e.g., net/protocols-based libraries).

     # File lib/arrow/logger.rb, line 409
409:     def <<( obj )
410:         self.write( :debug, obj )
411:         return self
412:     end

[]( mod ) click to toggle source

Return the sublogger for the given module mod (a Module, a String, or a Symbol) under this logger. A new one will instantiated if it does not already exist.

     # File lib/arrow/logger.rb, line 399
399:     def []( mod )
400:         # debug_msg "creating sublogger for '#{mod}'" unless @subloggers.key?( mod.to_s )
401:         @subloggers[ mod.to_s ] ||=
402:             self.class.new( @name + "::" + mod.to_s, self.level, self )
403:     end

hierloggers( level=Levels[:emerg] ) {|logger| ...} click to toggle source

Return a uniquified Array of the loggers which are more-generally related hierarchically to the receiver, inclusive. If called with a block, it will be called once for each Logger object. If level is specified, only those loggers whose level is level or lower will be selected.

     # File lib/arrow/logger.rb, line 313
313:     def hierloggers( level=Levels[:emerg] )
314:         loggers = []
315:         logger = self
316:         lastlogger = nil
317:         level = Levels[ level ] if level.is_a?( Symbol )
318: 
319:         # debug_msg "Searching for loggers in the hierarchy above %s" % 
320:             # [ logger.name.empty? ? "[Global]" : logger.name ]
321: 
322:         # Traverse the logger hierarchy upward (more general), looking for ones
323:         # whose level is below the argument.
324:         begin
325:             lastlogger = logger
326:             next unless logger.level <= level
327: 
328:             # When one is found, add it to the ones being returned and yield it
329:             # if there's a block
330:             # debug_msg "hierloggers: added %s" % logger.readable_name
331:             loggers.push( logger )
332:             yield( logger ) if block_given?
333: 
334:         end while (( logger = lastlogger.superlogger ))
335: 
336:         return loggers
337:     end

hieroutputters( level=Levels[:emerg] ) {|outputter, logger| ...} click to toggle source

Return a uniquified Array of all outputters for this logger and all of the loggers above it in the logging hierarchy. If called with a block, it will be called once for each outputter and the first logger to which it is attached.

     # File lib/arrow/logger.rb, line 344
344:     def hieroutputters( level=Levels[:emerg] )
345:         outputters = []
346: 
347:         # Look for loggers which are higher in the hierarchy
348:         self.hierloggers( level ) do |logger|
349:             outpary = logger.outputters || []
350:             newoutpary = outpary - (outpary & outputters)
351: 
352:             # If there are any outputters which haven't already been seen,
353:             # output to them.
354:             unless newoutpary.empty?
355:                 # debug_msg "hieroutputters: adding: %s" %
356:                     # newoutpary.collect {|outp| outp.description}.join(", ")
357:                 if block_given?
358:                     newoutpary.each {|outputter| yield(outputter, logger)}
359:                 end
360:                 outputters += newoutpary
361:             end
362:         end
363: 
364:         return outputters
365:     end

inspect() click to toggle source

Return a human-readable string representation of the object.

     # File lib/arrow/logger.rb, line 253
253:     def inspect
254:         "#<%s:0x%0x %s [level: %s, outputters: %d, trace: %s]>" % [
255:             self.class.name,
256:             self.object_id * 2,
257:             self.readable_name,
258:             self.readable_level,
259:             self.outputters.length,
260:             self.trace ? "on" : "off",
261:         ]
262:     end

level=( level ) click to toggle source

Set the level of this logger to level. The level can be a String, a Symbol, or an Integer.

     # File lib/arrow/logger.rb, line 282
282:     def level=( level )
283:         # debug_msg ">>> Setting log level for %s to %p" %
284:             # [ self.name.empty? ? "[Global]" : self.name, level ]
285: 
286:         case level
287:         when String
288:             @level = Levels[ level.intern ]
289:         when Symbol
290:             @level = Levels[ level ]
291:         when Integer
292:             @level = level
293:         else
294:             @level = nil
295:         end
296: 
297:         # If the level wasn't set correctly, raise an error after setting
298:         # the level to something reasonable.
299:         if @level.nil?
300:             @level = Levels[ :notice ]
301:             raise ArgumentError, "Illegal log level specification: %p for %s" %
302:                 [ level, self.name ]
303:         end
304:     end

readable_level() click to toggle source

Return the logger‘s level as a Symbol.

     # File lib/arrow/logger.rb, line 275
275:     def readable_level
276:         return LevelNames[ @level ]
277:     end

readable_name() click to toggle source

Return the name of the logger formatted to be suitable for reading.

     # File lib/arrow/logger.rb, line 266
266:     def readable_name
267:         logname = self.name.sub( /^::/, '' )
268:         logname = '(global)' if logname.empty?
269: 
270:         return logname
271:     end

write( level, *args ) click to toggle source

Write the given args to any connected outputters if level is less than or equal to this logger‘s level. If the first item in args is a String and contains %<char> codes, the message will formed by using the first argument as a format string in sprintf with the remaining items. Otherwise, the message will be formed by catenating the results of calling #formatObject on each of them.

     # File lib/arrow/logger.rb, line 374
374:     def write( level, *args )
375:         debug_msg "Writing message at %p: %p" % [ level, args ]
376: 
377:         msg, frame = nil, nil
378:         time = Time.now
379: 
380:         # If tracing is turned on, pick the first frame in the stack that
381:         # isn't in this file, or the last one if that fails to yield one.
382:         if @trace
383:             frame = caller(1).find {|fr| fr !~ %r{arrow/logger\.rb} } ||
384:                  caller(1).last
385:         end
386: 
387:         # Find the outputters that need to be written to, then write to them.
388:         self.hieroutputters( level ) do |outp, logger|
389:             debug_msg "Got outputter %p" % outp
390:             msg ||= args.collect {|obj| self.stringify_object(obj)}.join
391:             outp.write( time, level, self.readable_name, frame, msg )
392:         end
393:     end

Protected Instance Methods

make_level_predicate_method( level ) click to toggle source

Return a Proc suitable for installing as a predicate method for the given logging level.

     # File lib/arrow/logger.rb, line 458
458:     def make_level_predicate_method( level )
459:         numeric_level = Levels[level]
460:         Proc.new { self.level < numeric_level }
461:     end

make_writer_method( level ) click to toggle source

Return a Proc suitable for installing as a log-writing method for the given logging level.

     # File lib/arrow/logger.rb, line 466
466:     def make_writer_method( level )
467:         Proc.new {|*args| self.write(level, *args)}
468:     end

method_missing( sym, *args ) click to toggle source

Auto-install logging methods (ie., methods whose names match one of Arrow::Logger::Levels.

     # File lib/arrow/logger.rb, line 434
434:     def method_missing( sym, *args )
435:         name = sym.to_s
436:         level = name[/\w+/].to_sym
437:         return super unless Arrow::Logger::Levels.member?( level )
438:         code = nil
439: 
440:         case name
441:         when /^\w+\?/
442:             code = self.make_level_predicate_method( level )
443: 
444:         when /^\w+$/
445:             code = self.make_writer_method( level )
446:             
447:         else
448:             return super
449:         end
450:             
451:         self.class.send( :define_method, sym, &code )
452:         return self.method( sym ).call( *args )
453:     end

stringify_object( obj ) click to toggle source

Dump the given object for output in the log.

     # File lib/arrow/logger.rb, line 420
420:     def stringify_object( obj )
421:         return case obj
422:                when Exception
423:                    "%s:\n    %s" % [ obj.message, obj.backtrace.join("\n    ") ]
424:                when String
425:                    obj
426:                else
427:                    obj.inspect
428:                end
429:     end

secsequence

--- SEC00073

seccomment

--- ""

classlist

--- |
Module <a href="Logger/DebugLogger.html" class="link">Arrow::Logger::DebugLogger</a><br />

attributes

--- 
- name: level
  rw: R
  a_desc: |+
    
    The integer level of the logger.
    
- name: name
  rw: R
  a_desc: |+
    
    The name of this logger
    
- name: outputters
  rw: RW
  a_desc: |+
    
    The outputters attached to this branch of the logger tree.
    
- name: subloggers
  rw: RW
  a_desc: |+
    
    The branches of the logging hierarchy that fall below this one.
    
- name: superlogger
  rw: R
  a_desc: |+
    
    The logger object that is this logger&#8216;s parent (if any).
    
- name: trace
  rw: RW
  a_desc: |+
    
    Set to a true value to turn tracing on

method_list

--- 
- methods: 
  - visibility: public
    aref: M000588
    name: "[]"
    sourcecode: "     <span class=\"ruby-comment cmt\"># File lib/arrow/logger.rb, line 160</span>\n\
      160:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-keyword kw\">self</span><span class=\"ruby-operator\">::</span><span class=\"ruby-operator\">[]</span>( <span class=\"ruby-identifier\">mod</span>=<span class=\"ruby-keyword kw\">nil</span> )\n\
      161:         <span class=\"ruby-identifier\">modname</span> = <span class=\"ruby-identifier\">mod</span>.<span class=\"ruby-identifier\">to_s</span>\n\
      162:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">global</span> <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-identifier\">modname</span>.<span class=\"ruby-identifier\">empty?</span>\n\
      163: \n\
      164:         <span class=\"ruby-identifier\">names</span> = <span class=\"ruby-identifier\">modname</span>.<span class=\"ruby-identifier\">split</span>( <span class=\"ruby-regexp re\">/::/</span> )\n\
      165: \n\
      166:         <span class=\"ruby-comment cmt\"># Create the global logger if it isn't already created</span>\n\
      167:         <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">global</span>\n\
      168: \n\
      169:         <span class=\"ruby-identifier\">names</span>.<span class=\"ruby-identifier\">inject</span>( <span class=\"ruby-ivar\">@global_logger</span> ) {<span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">logger</span>,<span class=\"ruby-identifier\">key</span><span class=\"ruby-operator\">|</span> <span class=\"ruby-identifier\">logger</span>[<span class=\"ruby-identifier\">key</span>]}\n\
      170:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Return the <a href="Logger.html">Arrow::Logger</a> for the given module
      <tt>mod</tt>, which can be a <a href="../Module.html">Module</a> object, a
      Symbol, or a <a href="../String.html">String</a>.
      </p>
    params: ( mod=nil )
  - visibility: public
    aref: M000586
    name: configure
    sourcecode: "     <span class=\"ruby-comment cmt\"># File lib/arrow/logger.rb, line 100</span>\n\
      100:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-keyword kw\">self</span><span class=\"ruby-operator\">::</span><span class=\"ruby-identifier\">configure</span>( <span class=\"ruby-identifier\">config</span>, <span class=\"ruby-identifier\">dispatcher</span> )\n\
      101: \n\
      102:         <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">reset</span>\n\
      103:         <span class=\"ruby-identifier\">apacheoutputter</span> = <span class=\"ruby-constant\">Arrow</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Logger</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Outputter</span>.<span class=\"ruby-identifier\">create</span>( <span class=\"ruby-value str\">'apache'</span> )\n\
      104: \n\
      105:         <span class=\"ruby-identifier\">config</span>.<span class=\"ruby-identifier\">each</span> <span class=\"ruby-keyword kw\">do</span> <span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">klass</span>, <span class=\"ruby-identifier\">setting</span><span class=\"ruby-operator\">|</span>\n\
      106:             <span class=\"ruby-identifier\">level</span>, <span class=\"ruby-identifier\">uri</span> = <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">parse_log_setting</span>( <span class=\"ruby-identifier\">setting</span> )\n\
      107: \n\
      108:             <span class=\"ruby-comment cmt\"># Use the Apache log as the outputter if none is configured</span>\n\
      109:             <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-identifier\">uri</span>.<span class=\"ruby-identifier\">nil?</span>\n\
      110:                 <span class=\"ruby-identifier\">outputter</span> = <span class=\"ruby-identifier\">apacheoutputter</span>\n\
      111:             <span class=\"ruby-keyword kw\">else</span>\n\
      112:                 <span class=\"ruby-identifier\">outputter</span> = <span class=\"ruby-constant\">Arrow</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Logger</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Outputter</span>.<span class=\"ruby-identifier\">create</span>( <span class=\"ruby-identifier\">uri</span> )\n\
      113:             <span class=\"ruby-keyword kw\">end</span>\n\
      114: \n\
      115:             <span class=\"ruby-comment cmt\"># The 'global' entry configured the global logger</span>\n\
      116:             <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-identifier\">klass</span> <span class=\"ruby-operator\">==</span> <span class=\"ruby-identifier\">:global</span>\n\
      117:                 <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">global</span>.<span class=\"ruby-identifier\">level</span> = <span class=\"ruby-identifier\">level</span>\n\
      118:                 <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">global</span>.<span class=\"ruby-identifier\">outputters</span> <span class=\"ruby-operator\">&lt;&lt;</span> <span class=\"ruby-identifier\">outputter</span>\n\
      119:                 <span class=\"ruby-keyword kw\">next</span>\n\
      120:             <span class=\"ruby-keyword kw\">end</span>\n\
      121: \n\
      122:             <span class=\"ruby-comment cmt\"># If the class bit is something like 'applet', then transform</span>\n\
      123:             <span class=\"ruby-comment cmt\"># it into 'Arrow::Applet'</span>\n\
      124:             <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-identifier\">klass</span>.<span class=\"ruby-identifier\">to_s</span>.<span class=\"ruby-identifier\">match</span>( <span class=\"ruby-regexp re\">/^[a-z][a-zA-Z]+$/</span> )\n\
      125:                 <span class=\"ruby-identifier\">realclass</span> = <span class=\"ruby-value str\">&quot;Arrow::%s&quot;</span> <span class=\"ruby-operator\">%</span> <span class=\"ruby-identifier\">klass</span>.<span class=\"ruby-identifier\">to_s</span>.<span class=\"ruby-identifier\">sub</span>(<span class=\"ruby-regexp re\">/^([a-z])/</span>){ <span class=\"ruby-identifier\">$1</span>.<span class=\"ruby-identifier\">upcase</span> }\n\
      126:             <span class=\"ruby-keyword kw\">else</span>\n\
      127:                 <span class=\"ruby-identifier\">realclass</span> = <span class=\"ruby-identifier\">klass</span>.<span class=\"ruby-identifier\">to_s</span>\n\
      128:             <span class=\"ruby-keyword kw\">end</span>\n\
      129: \n\
      130:             <span class=\"ruby-constant\">Arrow</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Logger</span>[ <span class=\"ruby-identifier\">realclass</span> ].<span class=\"ruby-identifier\">level</span> = <span class=\"ruby-identifier\">level</span>\n\
      131:             <span class=\"ruby-constant\">Arrow</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Logger</span>[ <span class=\"ruby-identifier\">realclass</span> ].<span class=\"ruby-identifier\">outputters</span> <span class=\"ruby-operator\">&lt;&lt;</span> <span class=\"ruby-identifier\">outputter</span>\n\
      132:         <span class=\"ruby-keyword kw\">end</span>\n\
      133:         \n\
      134:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Configure logging from the &#8216;logging&#8217; section of the config.
      </p>
    params: ( config, dispatcher )
  - visibility: public
    aref: M000589
    name: global
    sourcecode: "     <span class=\"ruby-comment cmt\"># File lib/arrow/logger.rb, line 175</span>\n\
      175:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-keyword kw\">self</span><span class=\"ruby-operator\">::</span><span class=\"ruby-identifier\">global</span>\n\
      176:         <span class=\"ruby-comment cmt\"># debug_msg &quot;Creating the global logger&quot; unless @global_logger</span>\n\
      177:         <span class=\"ruby-ivar\">@global_logger</span> <span class=\"ruby-operator\">||=</span> <span class=\"ruby-identifier\">new</span>( <span class=\"ruby-value str\">''</span> )\n\
      178:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Return the <a href="Logger.html#M000589">global</a> <a
      href="../Arrow.html">Arrow</a> logger, setting it up if it hasn&#8216;t
      been already.
      </p>
    params: ()
  - visibility: public
    aref: M000591
    name: method_missing
    sourcecode: "     <span class=\"ruby-comment cmt\"># File lib/arrow/logger.rb, line 190</span>\n\
      190:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-keyword kw\">self</span><span class=\"ruby-operator\">::</span><span class=\"ruby-identifier\">method_missing</span>( <span class=\"ruby-identifier\">sym</span>, <span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">args</span> )\n\
      191:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-keyword kw\">super</span> <span class=\"ruby-keyword kw\">unless</span> <span class=\"ruby-constant\">Levels</span>.<span class=\"ruby-identifier\">key?</span>( <span class=\"ruby-identifier\">sym</span> )\n\
      192: \n\
      193:         <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">global</span>.<span class=\"ruby-identifier\">debug</span>( <span class=\"ruby-node\">&quot;Autoloading class log method '#{sym}'.&quot;</span> )\n\
      194:         (<span class=\"ruby-keyword kw\">class</span> <span class=\"ruby-operator\">&lt;&lt;</span> <span class=\"ruby-keyword kw\">self</span>; <span class=\"ruby-keyword kw\">self</span>; <span class=\"ruby-keyword kw\">end</span>).<span class=\"ruby-identifier\">class_eval</span> <span class=\"ruby-keyword kw\">do</span>\n\
      195:             <span class=\"ruby-identifier\">define_method</span>( <span class=\"ruby-identifier\">sym</span> ) <span class=\"ruby-keyword kw\">do</span> <span class=\"ruby-operator\">|</span><span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">args</span><span class=\"ruby-operator\">|</span>\n\
      196:                 <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">global</span>.<span class=\"ruby-identifier\">send</span>( <span class=\"ruby-identifier\">sym</span>, <span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">args</span> )\n\
      197:             <span class=\"ruby-keyword kw\">end</span>\n\
      198:         <span class=\"ruby-keyword kw\">end</span>\n\
      199: \n\
      200:         <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">global</span>.<span class=\"ruby-identifier\">send</span>( <span class=\"ruby-identifier\">sym</span>, <span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">args</span> )\n\
      201:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Autoload <a href="Logger.html#M000589">global</a> logging methods for the
      log levels
      </p>
    params: ( sym, *args )
  - visibility: public
    aref: M000592
    name: new
    sourcecode: "     <span class=\"ruby-comment cmt\"># File lib/arrow/logger.rb, line 211</span>\n\
      211:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">initialize</span>( <span class=\"ruby-identifier\">name</span>, <span class=\"ruby-identifier\">level</span>=<span class=\"ruby-identifier\">:info</span>, <span class=\"ruby-identifier\">superlogger</span>=<span class=\"ruby-keyword kw\">nil</span>, <span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">outputters</span> )\n\
      212:         <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-identifier\">name</span>.<span class=\"ruby-identifier\">empty?</span>\n\
      213:             <span class=\"ruby-comment cmt\"># debug_msg &quot;Creating global logger&quot;</span>\n\
      214:         <span class=\"ruby-keyword kw\">else</span>\n\
      215:             <span class=\"ruby-comment cmt\"># debug_msg &quot;Creating logger for #{name}&quot;</span>\n\
      216:         <span class=\"ruby-keyword kw\">end</span>\n\
      217: \n\
      218:         <span class=\"ruby-ivar\">@name</span> = <span class=\"ruby-identifier\">name</span>\n\
      219:         <span class=\"ruby-ivar\">@outputters</span> = <span class=\"ruby-identifier\">outputters</span>\n\
      220:         <span class=\"ruby-ivar\">@subloggers</span> = {}\n\
      221:         <span class=\"ruby-ivar\">@superlogger</span> = <span class=\"ruby-identifier\">superlogger</span>\n\
      222:         <span class=\"ruby-ivar\">@trace</span> = <span class=\"ruby-keyword kw\">false</span>\n\
      223:         <span class=\"ruby-ivar\">@level</span> = <span class=\"ruby-keyword kw\">nil</span>\n\
      224: \n\
      225:         <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">level</span> = <span class=\"ruby-identifier\">level</span>\n\
      226:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Create and return a <a href="Logger.html#M000592">new</a> <a
      href="Logger.html">Arrow::Logger</a> object with the given <tt>name</tt> at
      the specified <tt>level</tt>, with the specified <tt>superlogger</tt>. Any
      <tt>outputters</tt> that are specified will be added.
      </p>
    params: ( name, level=:info, superlogger=nil, *outputters )
  - visibility: public
    aref: M000587
    name: parse_log_setting
    sourcecode: "     <span class=\"ruby-comment cmt\"># File lib/arrow/logger.rb, line 150</span>\n\
      150:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-keyword kw\">self</span><span class=\"ruby-operator\">::</span><span class=\"ruby-identifier\">parse_log_setting</span>( <span class=\"ruby-identifier\">setting</span> )\n\
      151:         <span class=\"ruby-identifier\">level</span>, <span class=\"ruby-identifier\">rawuri</span> = <span class=\"ruby-identifier\">setting</span>.<span class=\"ruby-identifier\">split</span>( <span class=\"ruby-value str\">' '</span>, <span class=\"ruby-value\">2</span> )\n\
      152:         <span class=\"ruby-identifier\">uri</span> = <span class=\"ruby-identifier\">rawuri</span>.<span class=\"ruby-identifier\">nil?</span> <span class=\"ruby-value\">? </span><span class=\"ruby-keyword kw\">nil</span> <span class=\"ruby-operator\">:</span> <span class=\"ruby-constant\">URI</span>.<span class=\"ruby-identifier\">parse</span>( <span class=\"ruby-identifier\">rawuri</span> )\n\
      153:         \n\
      154:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-identifier\">level</span>.<span class=\"ruby-identifier\">to_sym</span>, <span class=\"ruby-identifier\">uri</span>\n\
      155:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Parse the configuration for a given class&#8216;s logger. The configuration
      is in the form:
      </p>
      <pre>
        &lt;level&gt; [&lt;outputter_uri&gt;]
      </pre>
      <p>
      where <tt>level</tt> is one of the logging levels defined by this class
      (see the Levels constant), and the optional <tt>outputter_uri</tt>
      indicates which outputter to use, and how it should be configured. See <a
      href="Logger/Outputter.html">Arrow::Logger::Outputter</a> for more info.
      </p>
      <p>
      Examples:
      </p>
      <pre>
        notice
        debug file:///tmp/broker-debug.log
        error dbi://www:password@localhost/www.errorlog?driver=postgresql
      </pre>
    params: ( setting )
  - visibility: public
    aref: M000590
    name: reset
    sourcecode: "     <span class=\"ruby-comment cmt\"># File lib/arrow/logger.rb, line 183</span>\n\
      183:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-keyword kw\">self</span><span class=\"ruby-operator\">::</span><span class=\"ruby-identifier\">reset</span>\n\
      184:         <span class=\"ruby-comment cmt\"># debug_msg &quot;Resetting the global logger&quot;</span>\n\
      185:         <span class=\"ruby-ivar\">@global_logger</span> = <span class=\"ruby-keyword kw\">nil</span>\n\
      186:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Reset the logging subsystem. Clears out any registered loggers and their
      associated outputters.
      </p>
    params: ()
  category: Class
  type: Public
- methods: 
  - visibility: public
    aref: M000601
    name: "&lt;&lt;"
    sourcecode: "     <span class=\"ruby-comment cmt\"># File lib/arrow/logger.rb, line 409</span>\n\
      409:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-operator\">&lt;&lt;</span>( <span class=\"ruby-identifier\">obj</span> )\n\
      410:         <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">write</span>( <span class=\"ruby-identifier\">:debug</span>, <span class=\"ruby-identifier\">obj</span> )\n\
      411:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-keyword kw\">self</span>\n\
      412:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Append the given <tt>obj</tt> to the logger at +:debug+ level. This is for
      compatibility with objects that append to $stderr for their logging (e.g.,
      net/protocols-based libraries).
      </p>
    params: ( obj )
  - visibility: public
    aref: M000600
    name: "[]"
    sourcecode: "     <span class=\"ruby-comment cmt\"># File lib/arrow/logger.rb, line 399</span>\n\
      399:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-operator\">[]</span>( <span class=\"ruby-identifier\">mod</span> )\n\
      400:         <span class=\"ruby-comment cmt\"># debug_msg &quot;creating sublogger for '#{mod}'&quot; unless @subloggers.key?( mod.to_s )</span>\n\
      401:         <span class=\"ruby-ivar\">@subloggers</span>[ <span class=\"ruby-identifier\">mod</span>.<span class=\"ruby-identifier\">to_s</span> ] <span class=\"ruby-operator\">||=</span>\n\
      402:             <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">class</span>.<span class=\"ruby-identifier\">new</span>( <span class=\"ruby-ivar\">@name</span> <span class=\"ruby-operator\">+</span> <span class=\"ruby-value str\">&quot;::&quot;</span> <span class=\"ruby-operator\">+</span> <span class=\"ruby-identifier\">mod</span>.<span class=\"ruby-identifier\">to_s</span>, <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">level</span>, <span class=\"ruby-keyword kw\">self</span> )\n\
      403:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Return the sublogger for the given module <tt>mod</tt> (a <a
      href="../Module.html">Module</a>, a <a href="../String.html">String</a>, or
      a Symbol) under this logger. A <a href="Logger.html#M000592">new</a> one
      will instantiated if it does not already exist.
      </p>
    params: ( mod )
  - visibility: public
    aref: M000597
    name: hierloggers
    sourcecode: "     <span class=\"ruby-comment cmt\"># File lib/arrow/logger.rb, line 313</span>\n\
      313:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">hierloggers</span>( <span class=\"ruby-identifier\">level</span>=<span class=\"ruby-constant\">Levels</span>[<span class=\"ruby-identifier\">:emerg</span>] )\n\
      314:         <span class=\"ruby-identifier\">loggers</span> = []\n\
      315:         <span class=\"ruby-identifier\">logger</span> = <span class=\"ruby-keyword kw\">self</span>\n\
      316:         <span class=\"ruby-identifier\">lastlogger</span> = <span class=\"ruby-keyword kw\">nil</span>\n\
      317:         <span class=\"ruby-identifier\">level</span> = <span class=\"ruby-constant\">Levels</span>[ <span class=\"ruby-identifier\">level</span> ] <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-identifier\">level</span>.<span class=\"ruby-identifier\">is_a?</span>( <span class=\"ruby-constant\">Symbol</span> )\n\
      318: \n\
      319:         <span class=\"ruby-comment cmt\"># debug_msg &quot;Searching for loggers in the hierarchy above %s&quot; % </span>\n\
      320:             <span class=\"ruby-comment cmt\"># [ logger.name.empty? ? &quot;[Global]&quot; : logger.name ]</span>\n\
      321: \n\
      322:         <span class=\"ruby-comment cmt\"># Traverse the logger hierarchy upward (more general), looking for ones</span>\n\
      323:         <span class=\"ruby-comment cmt\"># whose level is below the argument.</span>\n\
      324:         <span class=\"ruby-keyword kw\">begin</span>\n\
      325:             <span class=\"ruby-identifier\">lastlogger</span> = <span class=\"ruby-identifier\">logger</span>\n\
      326:             <span class=\"ruby-keyword kw\">next</span> <span class=\"ruby-keyword kw\">unless</span> <span class=\"ruby-identifier\">logger</span>.<span class=\"ruby-identifier\">level</span> <span class=\"ruby-operator\">&lt;=</span> <span class=\"ruby-identifier\">level</span>\n\
      327: \n\
      328:             <span class=\"ruby-comment cmt\"># When one is found, add it to the ones being returned and yield it</span>\n\
      329:             <span class=\"ruby-comment cmt\"># if there's a block</span>\n\
      330:             <span class=\"ruby-comment cmt\"># debug_msg &quot;hierloggers: added %s&quot; % logger.readable_name</span>\n\
      331:             <span class=\"ruby-identifier\">loggers</span>.<span class=\"ruby-identifier\">push</span>( <span class=\"ruby-identifier\">logger</span> )\n\
      332:             <span class=\"ruby-keyword kw\">yield</span>( <span class=\"ruby-identifier\">logger</span> ) <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-identifier\">block_given?</span>\n\
      333: \n\
      334:         <span class=\"ruby-keyword kw\">end</span> <span class=\"ruby-keyword kw\">while</span> (( <span class=\"ruby-identifier\">logger</span> = <span class=\"ruby-identifier\">lastlogger</span>.<span class=\"ruby-identifier\">superlogger</span> ))\n\
      335: \n\
      336:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-identifier\">loggers</span>\n\
      337:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Return a uniquified Array of the loggers which are more-generally related
      hierarchically to the receiver, inclusive. If called with a block, it will
      be called once for each <a href="Logger.html">Logger</a> object. If
      <tt>level</tt> is specified, only those loggers whose level is
      <tt>level</tt> or lower will be selected.
      </p>
    params: ( level=Levels[:emerg] ) {|logger| ...}
  - visibility: public
    aref: M000598
    name: hieroutputters
    sourcecode: "     <span class=\"ruby-comment cmt\"># File lib/arrow/logger.rb, line 344</span>\n\
      344:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">hieroutputters</span>( <span class=\"ruby-identifier\">level</span>=<span class=\"ruby-constant\">Levels</span>[<span class=\"ruby-identifier\">:emerg</span>] )\n\
      345:         <span class=\"ruby-identifier\">outputters</span> = []\n\
      346: \n\
      347:         <span class=\"ruby-comment cmt\"># Look for loggers which are higher in the hierarchy</span>\n\
      348:         <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">hierloggers</span>( <span class=\"ruby-identifier\">level</span> ) <span class=\"ruby-keyword kw\">do</span> <span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">logger</span><span class=\"ruby-operator\">|</span>\n\
      349:             <span class=\"ruby-identifier\">outpary</span> = <span class=\"ruby-identifier\">logger</span>.<span class=\"ruby-identifier\">outputters</span> <span class=\"ruby-operator\">||</span> []\n\
      350:             <span class=\"ruby-identifier\">newoutpary</span> = <span class=\"ruby-identifier\">outpary</span> <span class=\"ruby-operator\">-</span> (<span class=\"ruby-identifier\">outpary</span> <span class=\"ruby-operator\">&amp;</span> <span class=\"ruby-identifier\">outputters</span>)\n\
      351: \n\
      352:             <span class=\"ruby-comment cmt\"># If there are any outputters which haven't already been seen,</span>\n\
      353:             <span class=\"ruby-comment cmt\"># output to them.</span>\n\
      354:             <span class=\"ruby-keyword kw\">unless</span> <span class=\"ruby-identifier\">newoutpary</span>.<span class=\"ruby-identifier\">empty?</span>\n\
      355:                 <span class=\"ruby-comment cmt\"># debug_msg &quot;hieroutputters: adding: %s&quot; %</span>\n\
      356:                     <span class=\"ruby-comment cmt\"># newoutpary.collect {|outp| outp.description}.join(&quot;, &quot;)</span>\n\
      357:                 <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-identifier\">block_given?</span>\n\
      358:                     <span class=\"ruby-identifier\">newoutpary</span>.<span class=\"ruby-identifier\">each</span> {<span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">outputter</span><span class=\"ruby-operator\">|</span> <span class=\"ruby-keyword kw\">yield</span>(<span class=\"ruby-identifier\">outputter</span>, <span class=\"ruby-identifier\">logger</span>)}\n\
      359:                 <span class=\"ruby-keyword kw\">end</span>\n\
      360:                 <span class=\"ruby-identifier\">outputters</span> <span class=\"ruby-operator\">+=</span> <span class=\"ruby-identifier\">newoutpary</span>\n\
      361:             <span class=\"ruby-keyword kw\">end</span>\n\
      362:         <span class=\"ruby-keyword kw\">end</span>\n\
      363: \n\
      364:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-identifier\">outputters</span>\n\
      365:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Return a uniquified Array of all outputters for this logger and all of the
      loggers above it in the logging hierarchy. If called with a block, it will
      be called once for each outputter and the first logger to which it is
      attached.
      </p>
    params: ( level=Levels[:emerg] ) {|outputter, logger| ...}
  - visibility: public
    aref: M000593
    name: inspect
    sourcecode: "     <span class=\"ruby-comment cmt\"># File lib/arrow/logger.rb, line 253</span>\n\
      253:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">inspect</span>\n\
      254:         <span class=\"ruby-value str\">&quot;#&lt;%s:0x%0x %s [level: %s, outputters: %d, trace: %s]&gt;&quot;</span> <span class=\"ruby-operator\">%</span> [\n\
      255:             <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">class</span>.<span class=\"ruby-identifier\">name</span>,\n\
      256:             <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">object_id</span> <span class=\"ruby-operator\">*</span> <span class=\"ruby-value\">2</span>,\n\
      257:             <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">readable_name</span>,\n\
      258:             <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">readable_level</span>,\n\
      259:             <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">outputters</span>.<span class=\"ruby-identifier\">length</span>,\n\
      260:             <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">trace</span> <span class=\"ruby-value\">? </span><span class=\"ruby-value str\">&quot;on&quot;</span> <span class=\"ruby-operator\">:</span> <span class=\"ruby-value str\">&quot;off&quot;</span>,\n\
      261:         ]\n\
      262:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Return a human-readable string representation of the object.
      </p>
    params: ()
  - visibility: public
    aref: M000596
    name: level=
    sourcecode: "     <span class=\"ruby-comment cmt\"># File lib/arrow/logger.rb, line 282</span>\n\
      282:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">level=</span>( <span class=\"ruby-identifier\">level</span> )\n\
      283:         <span class=\"ruby-comment cmt\"># debug_msg &quot;&gt;&gt;&gt; Setting log level for %s to %p&quot; %</span>\n\
      284:             <span class=\"ruby-comment cmt\"># [ self.name.empty? ? &quot;[Global]&quot; : self.name, level ]</span>\n\
      285: \n\
      286:         <span class=\"ruby-keyword kw\">case</span> <span class=\"ruby-identifier\">level</span>\n\
      287:         <span class=\"ruby-keyword kw\">when</span> <span class=\"ruby-constant\">String</span>\n\
      288:             <span class=\"ruby-ivar\">@level</span> = <span class=\"ruby-constant\">Levels</span>[ <span class=\"ruby-identifier\">level</span>.<span class=\"ruby-identifier\">intern</span> ]\n\
      289:         <span class=\"ruby-keyword kw\">when</span> <span class=\"ruby-constant\">Symbol</span>\n\
      290:             <span class=\"ruby-ivar\">@level</span> = <span class=\"ruby-constant\">Levels</span>[ <span class=\"ruby-identifier\">level</span> ]\n\
      291:         <span class=\"ruby-keyword kw\">when</span> <span class=\"ruby-constant\">Integer</span>\n\
      292:             <span class=\"ruby-ivar\">@level</span> = <span class=\"ruby-identifier\">level</span>\n\
      293:         <span class=\"ruby-keyword kw\">else</span>\n\
      294:             <span class=\"ruby-ivar\">@level</span> = <span class=\"ruby-keyword kw\">nil</span>\n\
      295:         <span class=\"ruby-keyword kw\">end</span>\n\
      296: \n\
      297:         <span class=\"ruby-comment cmt\"># If the level wasn't set correctly, raise an error after setting</span>\n\
      298:         <span class=\"ruby-comment cmt\"># the level to something reasonable.</span>\n\
      299:         <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-ivar\">@level</span>.<span class=\"ruby-identifier\">nil?</span>\n\
      300:             <span class=\"ruby-ivar\">@level</span> = <span class=\"ruby-constant\">Levels</span>[ <span class=\"ruby-identifier\">:notice</span> ]\n\
      301:             <span class=\"ruby-identifier\">raise</span> <span class=\"ruby-constant\">ArgumentError</span>, <span class=\"ruby-value str\">&quot;Illegal log level specification: %p for %s&quot;</span> <span class=\"ruby-operator\">%</span>\n\
      302:                 [ <span class=\"ruby-identifier\">level</span>, <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">name</span> ]\n\
      303:         <span class=\"ruby-keyword kw\">end</span>\n\
      304:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Set the level of this logger to <tt>level</tt>. The <tt>level</tt> can be a
      <a href="../String.html">String</a>, a Symbol, or an <a
      href="../Integer.html">Integer</a>.
      </p>
    params: ( level )
  - visibility: public
    aref: M000595
    name: readable_level
    sourcecode: "     <span class=\"ruby-comment cmt\"># File lib/arrow/logger.rb, line 275</span>\n\
      275:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">readable_level</span>\n\
      276:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-constant\">LevelNames</span>[ <span class=\"ruby-ivar\">@level</span> ]\n\
      277:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Return the logger&#8216;s level as a Symbol.
      </p>
    params: ()
  - visibility: public
    aref: M000594
    name: readable_name
    sourcecode: "     <span class=\"ruby-comment cmt\"># File lib/arrow/logger.rb, line 266</span>\n\
      266:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">readable_name</span>\n\
      267:         <span class=\"ruby-identifier\">logname</span> = <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">name</span>.<span class=\"ruby-identifier\">sub</span>( <span class=\"ruby-regexp re\">/^::/</span>, <span class=\"ruby-value str\">''</span> )\n\
      268:         <span class=\"ruby-identifier\">logname</span> = <span class=\"ruby-value str\">'(global)'</span> <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-identifier\">logname</span>.<span class=\"ruby-identifier\">empty?</span>\n\
      269: \n\
      270:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-identifier\">logname</span>\n\
      271:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Return the name of the logger formatted to be suitable for reading.
      </p>
    params: ()
  - visibility: public
    aref: M000599
    name: write
    sourcecode: "     <span class=\"ruby-comment cmt\"># File lib/arrow/logger.rb, line 374</span>\n\
      374:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">write</span>( <span class=\"ruby-identifier\">level</span>, <span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">args</span> )\n\
      375:         <span class=\"ruby-identifier\">debug_msg</span> <span class=\"ruby-value str\">&quot;Writing message at %p: %p&quot;</span> <span class=\"ruby-operator\">%</span> [ <span class=\"ruby-identifier\">level</span>, <span class=\"ruby-identifier\">args</span> ]\n\
      376: \n\
      377:         <span class=\"ruby-identifier\">msg</span>, <span class=\"ruby-identifier\">frame</span> = <span class=\"ruby-keyword kw\">nil</span>, <span class=\"ruby-keyword kw\">nil</span>\n\
      378:         <span class=\"ruby-identifier\">time</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>\n\
      379: \n\
      380:         <span class=\"ruby-comment cmt\"># If tracing is turned on, pick the first frame in the stack that</span>\n\
      381:         <span class=\"ruby-comment cmt\"># isn't in this file, or the last one if that fails to yield one.</span>\n\
      382:         <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-ivar\">@trace</span>\n\
      383:             <span class=\"ruby-identifier\">frame</span> = <span class=\"ruby-identifier\">caller</span>(<span class=\"ruby-value\">1</span>).<span class=\"ruby-identifier\">find</span> {<span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">fr</span><span class=\"ruby-operator\">|</span> <span class=\"ruby-identifier\">fr</span> <span class=\"ruby-operator\">!~</span> <span class=\"ruby-regexp re\">%r{arrow/logger\\.rb}</span> } <span class=\"ruby-operator\">||</span>\n\
      384:                  <span class=\"ruby-identifier\">caller</span>(<span class=\"ruby-value\">1</span>).<span class=\"ruby-identifier\">last</span>\n\
      385:         <span class=\"ruby-keyword kw\">end</span>\n\
      386: \n\
      387:         <span class=\"ruby-comment cmt\"># Find the outputters that need to be written to, then write to them.</span>\n\
      388:         <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">hieroutputters</span>( <span class=\"ruby-identifier\">level</span> ) <span class=\"ruby-keyword kw\">do</span> <span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">outp</span>, <span class=\"ruby-identifier\">logger</span><span class=\"ruby-operator\">|</span>\n\
      389:             <span class=\"ruby-identifier\">debug_msg</span> <span class=\"ruby-value str\">&quot;Got outputter %p&quot;</span> <span class=\"ruby-operator\">%</span> <span class=\"ruby-identifier\">outp</span>\n\
      390:             <span class=\"ruby-identifier\">msg</span> <span class=\"ruby-operator\">||=</span> <span class=\"ruby-identifier\">args</span>.<span class=\"ruby-identifier\">collect</span> {<span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">obj</span><span class=\"ruby-operator\">|</span> <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">stringify_object</span>(<span class=\"ruby-identifier\">obj</span>)}.<span class=\"ruby-identifier\">join</span>\n\
      391:             <span class=\"ruby-identifier\">outp</span>.<span class=\"ruby-identifier\">write</span>( <span class=\"ruby-identifier\">time</span>, <span class=\"ruby-identifier\">level</span>, <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">readable_name</span>, <span class=\"ruby-identifier\">frame</span>, <span class=\"ruby-identifier\">msg</span> )\n\
      392:         <span class=\"ruby-keyword kw\">end</span>\n\
      393:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Write the given <tt>args</tt> to any connected outputters if <tt>level</tt>
      is less than or equal to this logger&#8216;s level. If the first item in
      <tt>args</tt> is a <a href="../String.html">String</a> and contains
      %&lt;char&gt; codes, the message will formed by using the first argument as
      a format string in <tt>sprintf</tt> with the remaining items. Otherwise,
      the message will be formed by catenating the results of calling
      #formatObject on each of them.
      </p>
    params: ( level, *args )
  category: Instance
  type: Public
- methods: 
  - visibility: protected
    aref: M000604
    name: make_level_predicate_method
    sourcecode: "     <span class=\"ruby-comment cmt\"># File lib/arrow/logger.rb, line 458</span>\n\
      458:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">make_level_predicate_method</span>( <span class=\"ruby-identifier\">level</span> )\n\
      459:         <span class=\"ruby-identifier\">numeric_level</span> = <span class=\"ruby-constant\">Levels</span>[<span class=\"ruby-identifier\">level</span>]\n\
      460:         <span class=\"ruby-constant\">Proc</span>.<span class=\"ruby-identifier\">new</span> { <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">level</span> <span class=\"ruby-operator\">&lt;</span> <span class=\"ruby-identifier\">numeric_level</span> }\n\
      461:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Return a Proc suitable for installing as a predicate method for the given
      logging level.
      </p>
    params: ( level )
  - visibility: protected
    aref: M000605
    name: make_writer_method
    sourcecode: "     <span class=\"ruby-comment cmt\"># File lib/arrow/logger.rb, line 466</span>\n\
      466:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">make_writer_method</span>( <span class=\"ruby-identifier\">level</span> )\n\
      467:         <span class=\"ruby-constant\">Proc</span>.<span class=\"ruby-identifier\">new</span> {<span class=\"ruby-operator\">|</span><span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">args</span><span class=\"ruby-operator\">|</span> <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">write</span>(<span class=\"ruby-identifier\">level</span>, <span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">args</span>)}\n\
      468:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Return a Proc suitable for installing as a log-writing method for the given
      logging level.
      </p>
    params: ( level )
  - visibility: protected
    aref: M000603
    name: method_missing
    sourcecode: "     <span class=\"ruby-comment cmt\"># File lib/arrow/logger.rb, line 434</span>\n\
      434:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">method_missing</span>( <span class=\"ruby-identifier\">sym</span>, <span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">args</span> )\n\
      435:         <span class=\"ruby-identifier\">name</span> = <span class=\"ruby-identifier\">sym</span>.<span class=\"ruby-identifier\">to_s</span>\n\
      436:         <span class=\"ruby-identifier\">level</span> = <span class=\"ruby-identifier\">name</span>[<span class=\"ruby-regexp re\">/\\w+/</span>].<span class=\"ruby-identifier\">to_sym</span>\n\
      437:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-keyword kw\">super</span> <span class=\"ruby-keyword kw\">unless</span> <span class=\"ruby-constant\">Arrow</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Logger</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Levels</span>.<span class=\"ruby-identifier\">member?</span>( <span class=\"ruby-identifier\">level</span> )\n\
      438:         <span class=\"ruby-identifier\">code</span> = <span class=\"ruby-keyword kw\">nil</span>\n\
      439: \n\
      440:         <span class=\"ruby-keyword kw\">case</span> <span class=\"ruby-identifier\">name</span>\n\
      441:         <span class=\"ruby-keyword kw\">when</span> <span class=\"ruby-regexp re\">/^\\w+\\?/</span>\n\
      442:             <span class=\"ruby-identifier\">code</span> = <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">make_level_predicate_method</span>( <span class=\"ruby-identifier\">level</span> )\n\
      443: \n\
      444:         <span class=\"ruby-keyword kw\">when</span> <span class=\"ruby-regexp re\">/^\\w+$/</span>\n\
      445:             <span class=\"ruby-identifier\">code</span> = <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">make_writer_method</span>( <span class=\"ruby-identifier\">level</span> )\n\
      446:             \n\
      447:         <span class=\"ruby-keyword kw\">else</span>\n\
      448:             <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-keyword kw\">super</span>\n\
      449:         <span class=\"ruby-keyword kw\">end</span>\n\
      450:             \n\
      451:         <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">class</span>.<span class=\"ruby-identifier\">send</span>( <span class=\"ruby-identifier\">:define_method</span>, <span class=\"ruby-identifier\">sym</span>, <span class=\"ruby-operator\">&amp;</span><span class=\"ruby-identifier\">code</span> )\n\
      452:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">method</span>( <span class=\"ruby-identifier\">sym</span> ).<span class=\"ruby-identifier\">call</span>( <span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">args</span> )\n\
      453:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Auto-install logging methods (ie., methods whose names match one of
      Arrow::Logger::Levels.
      </p>
    params: ( sym, *args )
  - visibility: protected
    aref: M000602
    name: stringify_object
    sourcecode: "     <span class=\"ruby-comment cmt\"># File lib/arrow/logger.rb, line 420</span>\n\
      420:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">stringify_object</span>( <span class=\"ruby-identifier\">obj</span> )\n\
      421:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-keyword kw\">case</span> <span class=\"ruby-identifier\">obj</span>\n\
      422:                <span class=\"ruby-keyword kw\">when</span> <span class=\"ruby-constant\">Exception</span>\n\
      423:                    <span class=\"ruby-value str\">&quot;%s:\\n    %s&quot;</span> <span class=\"ruby-operator\">%</span> [ <span class=\"ruby-identifier\">obj</span>.<span class=\"ruby-identifier\">message</span>, <span class=\"ruby-identifier\">obj</span>.<span class=\"ruby-identifier\">backtrace</span>.<span class=\"ruby-identifier\">join</span>(<span class=\"ruby-value str\">&quot;\\n    &quot;</span>) ]\n\
      424:                <span class=\"ruby-keyword kw\">when</span> <span class=\"ruby-constant\">String</span>\n\
      425:                    <span class=\"ruby-identifier\">obj</span>\n\
      426:                <span class=\"ruby-keyword kw\">else</span>\n\
      427:                    <span class=\"ruby-identifier\">obj</span>.<span class=\"ruby-identifier\">inspect</span>\n\
      428:                <span class=\"ruby-keyword kw\">end</span>\n\
      429:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Dump the given object for output in the log.
      </p>
    params: ( obj )
  category: Instance
  type: Protected

sectitle

---

constants

--- 
- name: SVNRev
  desc: |+
    
    SVN Revision
    
  value: "%q$Rev: 432 $"
- name: SVNId
  desc: |+
    
    SVN Id
    
  value: "%q$Id: logger.rb 432 2008-02-20 19:26:10Z deveiant $"
- name: Levels
  desc: |+
    
    Construct a log levels Hash on the fly
    
  value: "[         :debug,         :info,         :notice,         :warning,         :error,         :crit,         :alert,         :emerg,     ].inject({}) {|hsh, sym| hsh[ sym ] = hsh.length;"
- name: LevelNames
  value: Levels.invert

In Files

Subversion Info

Parent

Namespace

Methods

Included Modules

Class Index