Subversion Info

Rev
439
Last Checked In
2008-04-10 23:27:34 (6 days ago)
Checked in by
deveiant

Parent

Object

Included Modules

Class Index

Quicksearch

Arrow::Logger

A hierarchical logging class for the Arrow framework. It provides a generalized means of logging from inside Arrow classes, and then selectively outputting/formatting log messages from points within the hierarchy.

A lot of concepts in this class were stolen from Log4r, though it‘s all original code, and works a bit differently.

Synopsis

  require 'arrow/object'
  require 'arrow/logger'

  logger = Arrow::Logger.global
  logfile = File.open( "global.log", "a" )
  logger.outputters << Arrow::Logger::Outputter.new(logfile)
  logger.level = :debug

  class MyClass < Arrow::Object

      def self::fooMethod
          Arrow::Logger.debug( "In server start routine" )
          Arrow::Logger.info( "Server is not yet configured." )
          Arrow::Logger.notice( "Server is starting up." )
      end

      def initialize
          self.log.info( "Initializing another MyClass object." )
      end
  end

Subversion Id

  $Id: logger.rb 439 2008-04-10 23:27:34Z deveiant $

Authors

Copyright

Copyright © 2003-2008 The FaerieMUD Consortium.

All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

    * Neither the name of FaerieMUD nor the names of its contributors
      may be used to endorse or promote products derived from this software
      without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Constants

SVNRev
SVN Revision
SVNId
SVN Id
LEVELS
Construct a log levels Hash on the fly
LEVEL_NAMES
(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 /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 156
156:     def self::[]( mod=nil )
157:         modname = mod.to_s
158:         return self.global if modname.empty?
159: 
160:         names = modname.split( /::/ )
161: 
162:         # Create the global logger if it isn't already created
163:         self.global
164: 
165:         names.inject( @global_logger ) {|logger,key| logger[key]}
166:     end
configure( config, dispatcher ) click to toggle source

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

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

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

     # File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 171
171:     def self::global
172:         # debug_msg "Creating the global logger" unless @global_logger
173:         @global_logger ||= new( '' )
174:     end
method_missing( sym, *args ) click to toggle source

Autoload global logging methods for the log levels 

     # File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 186
186:     def self::method_missing( sym, *args )
187:         return super unless LEVELS.key?( sym )
188: 
189:         self.global.debug( "Autoloading class log method '#{sym}'." )
190:         (class << self; self; end).class_eval do
191:             define_method( sym ) do |*args|
192:                 self.global.send( sym, *args )
193:             end
194:         end
195: 
196:         self.global.send( sym, *args )
197:     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 /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 207
207:     def initialize( name, level=:info, superlogger=nil, *outputters )
208:         if name.empty?
209:             # debug_msg "Creating global logger"
210:         else
211:             # debug_msg "Creating logger for #{name}"
212:         end
213: 
214:         @name = name
215:         @outputters = outputters
216:         @subloggers = {}
217:         @superlogger = superlogger
218:         @trace = false
219:         @level = nil
220: 
221:         self.level = level
222:     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 /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 146
146:     def self::parse_log_setting( setting )
147:         level, rawuri = setting.split( ' ', 2 )
148:         uri = rawuri.nil? ? nil : URI.parse( rawuri )
149:         
150:         return level.to_sym, uri
151:     end
reset() click to toggle source

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

     # File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 179
179:     def self::reset
180:         # debug_msg "Resetting the global logger"
181:         @global_logger = nil
182:     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 /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 432
432:     def <<( obj )
433:         self.write( :debug, obj )
434:         return self
435:     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 /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 422
422:     def []( mod )
423:         # debug_msg "creating sublogger for '#{mod}'" unless @subloggers.key?( mod.to_s )
424:         @subloggers[ mod.to_s ] ||=
425:             self.class.new( @name + "::" + mod.to_s, self.level, self )
426:     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 /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 340
340:     def hierloggers( level=LEVELS[:emerg] )
341:         loggers = []
342:         logger = self
343:         lastlogger = nil
344:         level = LEVELS[ level ] if level.is_a?( Symbol )
345: 
346:         # debug_msg "Searching for loggers in the hierarchy above %s" % 
347:             # [ logger.name.empty? ? "[Global]" : logger.name ]
348: 
349:         # Traverse the logger hierarchy upward (more general), looking for ones
350:         # whose level is below the argument.
351:         begin
352:             lastlogger = logger
353:             next unless logger.level <= level
354: 
355:             # When one is found, add it to the ones being returned and yield it
356:             # if there's a block
357:             # debug_msg "hierloggers: added %s" % logger.readable_name
358:             loggers.push( logger )
359:             yield( logger ) if block_given?
360: 
361:         end while (( logger = lastlogger.superlogger ))
362: 
363:         return loggers
364:     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 /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 371
371:     def hieroutputters( level=LEVELS[:emerg] )
372:         outputters = []
373: 
374:         # Look for loggers which are higher in the hierarchy
375:         self.hierloggers( level ) do |logger|
376:             outpary = logger.outputters || []
377:             newoutpary = outpary - (outpary & outputters)
378: 
379:             # If there are any outputters which haven't already been seen,
380:             # output to them.
381:             unless newoutpary.empty?
382:                 # debug_msg "hieroutputters: adding: %s" %
383:                     # newoutpary.collect {|outp| outp.description}.join(", ")
384:                 if block_given?
385:                     newoutpary.each {|outputter| yield(outputter, logger)}
386:                 end
387:                 outputters += newoutpary
388:             end
389:         end
390: 
391:         return outputters
392:     end
inspect() click to toggle source

Return a human-readable string representation of the object. 

     # File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 249
249:     def inspect
250:         "#<%s:0x%0x %s [level: %s, outputters: %d, trace: %s]>" % [
251:             self.class.name,
252:             self.object_id * 2,
253:             self.readable_name,
254:             self.readable_level,
255:             self.outputters.length,
256:             self.trace ? "on" : "off",
257:         ]
258:     end
inspect_details( level=0 ) click to toggle source

Return a (more-detailed) human-readable string representation of the object. 

     # File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 262
262:     def inspect_details( level=0 )
263:         indent = '  ' * (level + 1)
264: 
265:         prelude = "<< %s [level: %s, trace: %s] >>" % [
266:             self.readable_name,
267:             self.readable_level,
268:             self.trace ? "on" : "off",
269:           ]
270: 
271:         details = []
272:         
273:         unless self.outputters.empty?
274:             details << "Outputters:" << self.outputters.map {|op| op.inspect }
275:         end
276:         
277:         unless self.subloggers.empty?
278:             details << "Subloggers:" << 
279:                 self.subloggers.values.map {|sl| sl.inspect_details(level + 1) }
280:         end
281:         
282:         details = details.flatten.compact.map {|line| indent + line }
283:         
284:         if level.zero?
285:             return [ prelude, *details ].join( "\n" )
286:         else
287:             return [ prelude, *details ]
288:         end
289:     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 /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 309
309:     def level=( level )
310:         # debug_msg ">>> Setting log level for %s to %p" %
311:             # [ self.name.empty? ? "[Global]" : self.name, level ]
312: 
313:         case level
314:         when String
315:             @level = LEVELS[ level.intern ]
316:         when Symbol
317:             @level = LEVELS[ level ]
318:         when Integer
319:             @level = level
320:         else
321:             @level = nil
322:         end
323: 
324:         # If the level wasn't set correctly, raise an error after setting
325:         # the level to something reasonable.
326:         if @level.nil?
327:             @level = LEVELS[ :notice ]
328:             raise ArgumentError, "Illegal log level specification: %p for %s" %
329:                 [ level, self.name ]
330:         end
331:     end
readable_level() click to toggle source

Return the logger‘s level as a Symbol. 

     # File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 302
302:     def readable_level
303:         return LEVEL_NAMES[ @level ]
304:     end
readable_name() click to toggle source

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

     # File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 293
293:     def readable_name
294:         logname = self.name.sub( /^::/, '' )
295:         logname = '(global)' if logname.empty?
296: 
297:         return logname
298:     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. 

     # File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 397
397:     def write( level, *args )
398:         debug_msg "Writing message at %p: %p" % [ level, args ]
399: 
400:         msg, frame = nil, nil
401:         time = Time.now
402: 
403:         # If tracing is turned on, pick the first frame in the stack that
404:         # isn't in this file, or the last one if that fails to yield one.
405:         if @trace
406:             frame = caller(1).find {|fr| fr !~ %r{arrow/logger\.rb} } ||
407:                  caller(1).last
408:         end
409: 
410:         # Find the outputters that need to be written to, then write to them.
411:         self.hieroutputters( level ) do |outp, logger|
412:             debug_msg "Got outputter %p" % outp
413:             msg ||= args.collect {|obj| self.stringify_object(obj)}.join
414:             outp.write( time, level, self.readable_name, frame, msg )
415:         end
416:     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 /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 481
481:     def make_level_predicate_method( level )
482:         numeric_level = LEVELS[level]
483:         Proc.new { self.level < numeric_level }
484:     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 /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 489
489:     def make_writer_method( level )
490:         Proc.new {|*args| self.write(level, *args)}
491:     end
method_missing( sym, *args ) click to toggle source

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

     # File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 457
457:     def method_missing( sym, *args )
458:         name = sym.to_s
459:         level = name[/\w+/].to_sym
460:         return super unless Arrow::Logger::LEVELS.member?( level )
461:         code = nil
462: 
463:         case name
464:         when /^\w+\?/
465:             code = self.make_level_predicate_method( level )
466: 
467:         when /^\w+$/
468:             code = self.make_writer_method( level )
469:             
470:         else
471:             return super
472:         end
473:             
474:         self.class.send( :define_method, sym, &code )
475:         return self.method( sym ).call( *args )
476:     end
stringify_object( obj ) click to toggle source

Dump the given object for output in the log. 

     # File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 443
443:     def stringify_object( obj )
444:         return case obj
445:                when Exception
446:                    "%s:\n    %s" % [ obj.message, obj.backtrace.join("\n    ") ]
447:                when String
448:                    obj
449:                else
450:                    obj.inspect
451:                end
452:     end

secsequence

--- SEC00074

seccomment

--- ""

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: M000594
    name: "[]"
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 156</span>\n\
      156:     <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\
      157:         <span class=\"ruby-identifier\">modname</span> = <span class=\"ruby-identifier\">mod</span>.<span class=\"ruby-identifier\">to_s</span>\n\
      158:         <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\
      159: \n\
      160:         <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\
      161: \n\
      162:         <span class=\"ruby-comment cmt\"># Create the global logger if it isn't already created</span>\n\
      163:         <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">global</span>\n\
      164: \n\
      165:         <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\
      166:     <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 String.
      </p>
    params: ( mod=nil )
  - visibility: public
    aref: M000592
    name: configure
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 96</span>\n 96:     <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 97: \n 98:         <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">reset</span>\n 99:         <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\
      100: \n\
      101:         <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\
      102:             <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\
      103: \n\
      104:             <span class=\"ruby-comment cmt\"># Use the Apache log as the outputter if none is configured</span>\n\
      105:             <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-identifier\">uri</span>.<span class=\"ruby-identifier\">nil?</span>\n\
      106:                 <span class=\"ruby-identifier\">outputter</span> = <span class=\"ruby-identifier\">apacheoutputter</span>\n\
      107:             <span class=\"ruby-keyword kw\">else</span>\n\
      108:                 <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\
      109:             <span class=\"ruby-keyword kw\">end</span>\n\
      110: \n\
      111:             <span class=\"ruby-comment cmt\"># The 'global' entry configured the global logger</span>\n\
      112:             <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\
      113:                 <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\
      114:                 <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\
      115:                 <span class=\"ruby-keyword kw\">next</span>\n\
      116:             <span class=\"ruby-keyword kw\">end</span>\n\
      117: \n\
      118:             <span class=\"ruby-comment cmt\"># If the class bit is something like 'applet', then transform</span>\n\
      119:             <span class=\"ruby-comment cmt\"># it into 'Arrow::Applet'</span>\n\
      120:             <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\
      121:                 <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\
      122:             <span class=\"ruby-keyword kw\">else</span>\n\
      123:                 <span class=\"ruby-identifier\">realclass</span> = <span class=\"ruby-identifier\">klass</span>.<span class=\"ruby-identifier\">to_s</span>\n\
      124:             <span class=\"ruby-keyword kw\">end</span>\n\
      125: \n\
      126:             <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\
      127:             <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\
      128:         <span class=\"ruby-keyword kw\">end</span>\n\
      129:         \n\
      130:     <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: M000595
    name: global
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 171</span>\n\
      171:     <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\
      172:         <span class=\"ruby-comment cmt\"># debug_msg &quot;Creating the global logger&quot; unless @global_logger</span>\n\
      173:         <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\
      174:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Return the <a href="Logger.html#M000595">global</a> <a
      href="../Arrow.html">Arrow</a> logger, setting it up if it hasn&#8216;t
      been already.
      </p>
    params: ()
  - visibility: public
    aref: M000597
    name: method_missing
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 186</span>\n\
      186:     <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\
      187:         <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\
      188: \n\
      189:         <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\
      190:         (<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\
      191:             <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\
      192:                 <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\
      193:             <span class=\"ruby-keyword kw\">end</span>\n\
      194:         <span class=\"ruby-keyword kw\">end</span>\n\
      195: \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>"
    m_desc: |-
      <p>
      Autoload <a href="Logger.html#M000595">global</a> logging methods for the
      log levels
      </p>
    params: ( sym, *args )
  - visibility: public
    aref: M000598
    name: new
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 207</span>\n\
      207:     <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\
      208:         <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-identifier\">name</span>.<span class=\"ruby-identifier\">empty?</span>\n\
      209:             <span class=\"ruby-comment cmt\"># debug_msg &quot;Creating global logger&quot;</span>\n\
      210:         <span class=\"ruby-keyword kw\">else</span>\n\
      211:             <span class=\"ruby-comment cmt\"># debug_msg &quot;Creating logger for #{name}&quot;</span>\n\
      212:         <span class=\"ruby-keyword kw\">end</span>\n\
      213: \n\
      214:         <span class=\"ruby-ivar\">@name</span> = <span class=\"ruby-identifier\">name</span>\n\
      215:         <span class=\"ruby-ivar\">@outputters</span> = <span class=\"ruby-identifier\">outputters</span>\n\
      216:         <span class=\"ruby-ivar\">@subloggers</span> = {}\n\
      217:         <span class=\"ruby-ivar\">@superlogger</span> = <span class=\"ruby-identifier\">superlogger</span>\n\
      218:         <span class=\"ruby-ivar\">@trace</span> = <span class=\"ruby-keyword kw\">false</span>\n\
      219:         <span class=\"ruby-ivar\">@level</span> = <span class=\"ruby-keyword kw\">nil</span>\n\
      220: \n\
      221:         <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">level</span> = <span class=\"ruby-identifier\">level</span>\n\
      222:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Create and return a <a href="Logger.html#M000598">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: M000593
    name: parse_log_setting
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 146</span>\n\
      146:     <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\
      147:         <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\
      148:         <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\
      149:         \n\
      150:         <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\
      151:     <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: M000596
    name: reset
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 179</span>\n\
      179:     <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\
      180:         <span class=\"ruby-comment cmt\"># debug_msg &quot;Resetting the global logger&quot;</span>\n\
      181:         <span class=\"ruby-ivar\">@global_logger</span> = <span class=\"ruby-keyword kw\">nil</span>\n\
      182:     <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: M000608
    name: "&lt;&lt;"
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 432</span>\n\
      432:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-operator\">&lt;&lt;</span>( <span class=\"ruby-identifier\">obj</span> )\n\
      433:         <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\
      434:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-keyword kw\">self</span>\n\
      435:     <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: M000607
    name: "[]"
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 422</span>\n\
      422:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-operator\">[]</span>( <span class=\"ruby-identifier\">mod</span> )\n\
      423:         <span class=\"ruby-comment cmt\"># debug_msg &quot;creating sublogger for '#{mod}'&quot; unless @subloggers.key?( mod.to_s )</span>\n\
      424:         <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\
      425:             <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\
      426:     <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 String, or a Symbol) under this logger.
      A <a href="Logger.html#M000598">new</a> one will instantiated if it does
      not already exist.
      </p>
    params: ( mod )
  - visibility: public
    aref: M000604
    name: hierloggers
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 340</span>\n\
      340:     <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\
      341:         <span class=\"ruby-identifier\">loggers</span> = []\n\
      342:         <span class=\"ruby-identifier\">logger</span> = <span class=\"ruby-keyword kw\">self</span>\n\
      343:         <span class=\"ruby-identifier\">lastlogger</span> = <span class=\"ruby-keyword kw\">nil</span>\n\
      344:         <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\
      345: \n\
      346:         <span class=\"ruby-comment cmt\"># debug_msg &quot;Searching for loggers in the hierarchy above %s&quot; % </span>\n\
      347:             <span class=\"ruby-comment cmt\"># [ logger.name.empty? ? &quot;[Global]&quot; : logger.name ]</span>\n\
      348: \n\
      349:         <span class=\"ruby-comment cmt\"># Traverse the logger hierarchy upward (more general), looking for ones</span>\n\
      350:         <span class=\"ruby-comment cmt\"># whose level is below the argument.</span>\n\
      351:         <span class=\"ruby-keyword kw\">begin</span>\n\
      352:             <span class=\"ruby-identifier\">lastlogger</span> = <span class=\"ruby-identifier\">logger</span>\n\
      353:             <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\
      354: \n\
      355:             <span class=\"ruby-comment cmt\"># When one is found, add it to the ones being returned and yield it</span>\n\
      356:             <span class=\"ruby-comment cmt\"># if there's a block</span>\n\
      357:             <span class=\"ruby-comment cmt\"># debug_msg &quot;hierloggers: added %s&quot; % logger.readable_name</span>\n\
      358:             <span class=\"ruby-identifier\">loggers</span>.<span class=\"ruby-identifier\">push</span>( <span class=\"ruby-identifier\">logger</span> )\n\
      359:             <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\
      360: \n\
      361:         <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\
      362: \n\
      363:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-identifier\">loggers</span>\n\
      364:     <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: M000605
    name: hieroutputters
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 371</span>\n\
      371:     <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\
      372:         <span class=\"ruby-identifier\">outputters</span> = []\n\
      373: \n\
      374:         <span class=\"ruby-comment cmt\"># Look for loggers which are higher in the hierarchy</span>\n\
      375:         <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\
      376:             <span class=\"ruby-identifier\">outpary</span> = <span class=\"ruby-identifier\">logger</span>.<span class=\"ruby-identifier\">outputters</span> <span class=\"ruby-operator\">||</span> []\n\
      377:             <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\
      378: \n\
      379:             <span class=\"ruby-comment cmt\"># If there are any outputters which haven't already been seen,</span>\n\
      380:             <span class=\"ruby-comment cmt\"># output to them.</span>\n\
      381:             <span class=\"ruby-keyword kw\">unless</span> <span class=\"ruby-identifier\">newoutpary</span>.<span class=\"ruby-identifier\">empty?</span>\n\
      382:                 <span class=\"ruby-comment cmt\"># debug_msg &quot;hieroutputters: adding: %s&quot; %</span>\n\
      383:                     <span class=\"ruby-comment cmt\"># newoutpary.collect {|outp| outp.description}.join(&quot;, &quot;)</span>\n\
      384:                 <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-identifier\">block_given?</span>\n\
      385:                     <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\
      386:                 <span class=\"ruby-keyword kw\">end</span>\n\
      387:                 <span class=\"ruby-identifier\">outputters</span> <span class=\"ruby-operator\">+=</span> <span class=\"ruby-identifier\">newoutpary</span>\n\
      388:             <span class=\"ruby-keyword kw\">end</span>\n\
      389:         <span class=\"ruby-keyword kw\">end</span>\n\
      390: \n\
      391:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-identifier\">outputters</span>\n\
      392:     <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: M000599
    name: inspect
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 249</span>\n\
      249:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">inspect</span>\n\
      250:         <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\
      251:             <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">class</span>.<span class=\"ruby-identifier\">name</span>,\n\
      252:             <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\
      253:             <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">readable_name</span>,\n\
      254:             <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">readable_level</span>,\n\
      255:             <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">outputters</span>.<span class=\"ruby-identifier\">length</span>,\n\
      256:             <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\
      257:         ]\n\
      258:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Return a human-readable string representation of the object.
      </p>
    params: ()
  - visibility: public
    aref: M000600
    name: inspect_details
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 262</span>\n\
      262:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">inspect_details</span>( <span class=\"ruby-identifier\">level</span>=<span class=\"ruby-value\">0</span> )\n\
      263:         <span class=\"ruby-identifier\">indent</span> = <span class=\"ruby-value str\">'  '</span> <span class=\"ruby-operator\">*</span> (<span class=\"ruby-identifier\">level</span> <span class=\"ruby-operator\">+</span> <span class=\"ruby-value\">1</span>)\n\
      264: \n\
      265:         <span class=\"ruby-identifier\">prelude</span> = <span class=\"ruby-value str\">&quot;&lt;&lt; %s [level: %s, trace: %s] &gt;&gt;&quot;</span> <span class=\"ruby-operator\">%</span> [\n\
      266:             <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">readable_name</span>,\n\
      267:             <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">readable_level</span>,\n\
      268:             <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\
      269:           ]\n\
      270: \n\
      271:         <span class=\"ruby-identifier\">details</span> = []\n\
      272:         \n\
      273:         <span class=\"ruby-keyword kw\">unless</span> <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">outputters</span>.<span class=\"ruby-identifier\">empty?</span>\n\
      274:             <span class=\"ruby-identifier\">details</span> <span class=\"ruby-operator\">&lt;&lt;</span> <span class=\"ruby-value str\">&quot;Outputters:&quot;</span> <span class=\"ruby-operator\">&lt;&lt;</span> <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">outputters</span>.<span class=\"ruby-identifier\">map</span> {<span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">op</span><span class=\"ruby-operator\">|</span> <span class=\"ruby-identifier\">op</span>.<span class=\"ruby-identifier\">inspect</span> }\n\
      275:         <span class=\"ruby-keyword kw\">end</span>\n\
      276:         \n\
      277:         <span class=\"ruby-keyword kw\">unless</span> <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">subloggers</span>.<span class=\"ruby-identifier\">empty?</span>\n\
      278:             <span class=\"ruby-identifier\">details</span> <span class=\"ruby-operator\">&lt;&lt;</span> <span class=\"ruby-value str\">&quot;Subloggers:&quot;</span> <span class=\"ruby-operator\">&lt;&lt;</span> \n\
      279:                 <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">subloggers</span>.<span class=\"ruby-identifier\">values</span>.<span class=\"ruby-identifier\">map</span> {<span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">sl</span><span class=\"ruby-operator\">|</span> <span class=\"ruby-identifier\">sl</span>.<span class=\"ruby-identifier\">inspect_details</span>(<span class=\"ruby-identifier\">level</span> <span class=\"ruby-operator\">+</span> <span class=\"ruby-value\">1</span>) }\n\
      280:         <span class=\"ruby-keyword kw\">end</span>\n\
      281:         \n\
      282:         <span class=\"ruby-identifier\">details</span> = <span class=\"ruby-identifier\">details</span>.<span class=\"ruby-identifier\">flatten</span>.<span class=\"ruby-identifier\">compact</span>.<span class=\"ruby-identifier\">map</span> {<span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">line</span><span class=\"ruby-operator\">|</span> <span class=\"ruby-identifier\">indent</span> <span class=\"ruby-operator\">+</span> <span class=\"ruby-identifier\">line</span> }\n\
      283:         \n\
      284:         <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-identifier\">level</span>.<span class=\"ruby-identifier\">zero?</span>\n\
      285:             <span class=\"ruby-keyword kw\">return</span> [ <span class=\"ruby-identifier\">prelude</span>, <span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">details</span> ].<span class=\"ruby-identifier\">join</span>( <span class=\"ruby-value str\">&quot;\\n&quot;</span> )\n\
      286:         <span class=\"ruby-keyword kw\">else</span>\n\
      287:             <span class=\"ruby-keyword kw\">return</span> [ <span class=\"ruby-identifier\">prelude</span>, <span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">details</span> ]\n\
      288:         <span class=\"ruby-keyword kw\">end</span>\n\
      289:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Return a (more-detailed) human-readable string representation of the
      object.
      </p>
    params: ( level=0 )
  - visibility: public
    aref: M000603
    name: level=
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 309</span>\n\
      309:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">level=</span>( <span class=\"ruby-identifier\">level</span> )\n\
      310:         <span class=\"ruby-comment cmt\"># debug_msg &quot;&gt;&gt;&gt; Setting log level for %s to %p&quot; %</span>\n\
      311:             <span class=\"ruby-comment cmt\"># [ self.name.empty? ? &quot;[Global]&quot; : self.name, level ]</span>\n\
      312: \n\
      313:         <span class=\"ruby-keyword kw\">case</span> <span class=\"ruby-identifier\">level</span>\n\
      314:         <span class=\"ruby-keyword kw\">when</span> <span class=\"ruby-constant\">String</span>\n\
      315:             <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\
      316:         <span class=\"ruby-keyword kw\">when</span> <span class=\"ruby-constant\">Symbol</span>\n\
      317:             <span class=\"ruby-ivar\">@level</span> = <span class=\"ruby-constant\">LEVELS</span>[ <span class=\"ruby-identifier\">level</span> ]\n\
      318:         <span class=\"ruby-keyword kw\">when</span> <span class=\"ruby-constant\">Integer</span>\n\
      319:             <span class=\"ruby-ivar\">@level</span> = <span class=\"ruby-identifier\">level</span>\n\
      320:         <span class=\"ruby-keyword kw\">else</span>\n\
      321:             <span class=\"ruby-ivar\">@level</span> = <span class=\"ruby-keyword kw\">nil</span>\n\
      322:         <span class=\"ruby-keyword kw\">end</span>\n\
      323: \n\
      324:         <span class=\"ruby-comment cmt\"># If the level wasn't set correctly, raise an error after setting</span>\n\
      325:         <span class=\"ruby-comment cmt\"># the level to something reasonable.</span>\n\
      326:         <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-ivar\">@level</span>.<span class=\"ruby-identifier\">nil?</span>\n\
      327:             <span class=\"ruby-ivar\">@level</span> = <span class=\"ruby-constant\">LEVELS</span>[ <span class=\"ruby-identifier\">:notice</span> ]\n\
      328:             <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\
      329:                 [ <span class=\"ruby-identifier\">level</span>, <span class=\"ruby-keyword kw\">self</span>.<span class=\"ruby-identifier\">name</span> ]\n\
      330:         <span class=\"ruby-keyword kw\">end</span>\n\
      331:     <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
      String, a Symbol, or an <a href="../Integer.html">Integer</a>.
      </p>
    params: ( level )
  - visibility: public
    aref: M000602
    name: readable_level
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 302</span>\n\
      302:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">readable_level</span>\n\
      303:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-constant\">LEVEL_NAMES</span>[ <span class=\"ruby-ivar\">@level</span> ]\n\
      304:     <span class=\"ruby-keyword kw\">end</span>"
    m_desc: |-
      <p>
      Return the logger&#8216;s level as a Symbol.
      </p>
    params: ()
  - visibility: public
    aref: M000601
    name: readable_name
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 293</span>\n\
      293:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">readable_name</span>\n\
      294:         <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\
      295:         <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\
      296: \n\
      297:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-identifier\">logname</span>\n\
      298:     <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: M000606
    name: write
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 397</span>\n\
      397:     <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\
      398:         <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\
      399: \n\
      400:         <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\
      401:         <span class=\"ruby-identifier\">time</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>\n\
      402: \n\
      403:         <span class=\"ruby-comment cmt\"># If tracing is turned on, pick the first frame in the stack that</span>\n\
      404:         <span class=\"ruby-comment cmt\"># isn't in this file, or the last one if that fails to yield one.</span>\n\
      405:         <span class=\"ruby-keyword kw\">if</span> <span class=\"ruby-ivar\">@trace</span>\n\
      406:             <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\
      407:                  <span class=\"ruby-identifier\">caller</span>(<span class=\"ruby-value\">1</span>).<span class=\"ruby-identifier\">last</span>\n\
      408:         <span class=\"ruby-keyword kw\">end</span>\n\
      409: \n\
      410:         <span class=\"ruby-comment cmt\"># Find the outputters that need to be written to, then write to them.</span>\n\
      411:         <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\
      412:             <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\
      413:             <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\
      414:             <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\
      415:         <span class=\"ruby-keyword kw\">end</span>\n\
      416:     <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.
      </p>
    params: ( level, *args )
  category: Instance
  type: Public
- methods: 
  - visibility: protected
    aref: M000611
    name: make_level_predicate_method
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 481</span>\n\
      481:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">make_level_predicate_method</span>( <span class=\"ruby-identifier\">level</span> )\n\
      482:         <span class=\"ruby-identifier\">numeric_level</span> = <span class=\"ruby-constant\">LEVELS</span>[<span class=\"ruby-identifier\">level</span>]\n\
      483:         <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\
      484:     <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: M000612
    name: make_writer_method
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 489</span>\n\
      489:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">make_writer_method</span>( <span class=\"ruby-identifier\">level</span> )\n\
      490:         <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\
      491:     <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: M000610
    name: method_missing
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 457</span>\n\
      457:     <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\
      458:         <span class=\"ruby-identifier\">name</span> = <span class=\"ruby-identifier\">sym</span>.<span class=\"ruby-identifier\">to_s</span>\n\
      459:         <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\
      460:         <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\
      461:         <span class=\"ruby-identifier\">code</span> = <span class=\"ruby-keyword kw\">nil</span>\n\
      462: \n\
      463:         <span class=\"ruby-keyword kw\">case</span> <span class=\"ruby-identifier\">name</span>\n\
      464:         <span class=\"ruby-keyword kw\">when</span> <span class=\"ruby-regexp re\">/^\\w+\\?/</span>\n\
      465:             <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\
      466: \n\
      467:         <span class=\"ruby-keyword kw\">when</span> <span class=\"ruby-regexp re\">/^\\w+$/</span>\n\
      468:             <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\
      469:             \n\
      470:         <span class=\"ruby-keyword kw\">else</span>\n\
      471:             <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-keyword kw\">super</span>\n\
      472:         <span class=\"ruby-keyword kw\">end</span>\n\
      473:             \n\
      474:         <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\
      475:         <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\
      476:     <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: M000609
    name: stringify_object
    sourcecode: "     <span class=\"ruby-comment cmt\"># File /Users/ged/source/ruby/Arrow/lib/arrow/logger.rb, line 443</span>\n\
      443:     <span class=\"ruby-keyword kw\">def</span> <span class=\"ruby-identifier\">stringify_object</span>( <span class=\"ruby-identifier\">obj</span> )\n\
      444:         <span class=\"ruby-keyword kw\">return</span> <span class=\"ruby-keyword kw\">case</span> <span class=\"ruby-identifier\">obj</span>\n\
      445:                <span class=\"ruby-keyword kw\">when</span> <span class=\"ruby-constant\">Exception</span>\n\
      446:                    <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\
      447:                <span class=\"ruby-keyword kw\">when</span> <span class=\"ruby-constant\">String</span>\n\
      448:                    <span class=\"ruby-identifier\">obj</span>\n\
      449:                <span class=\"ruby-keyword kw\">else</span>\n\
      450:                    <span class=\"ruby-identifier\">obj</span>.<span class=\"ruby-identifier\">inspect</span>\n\
      451:                <span class=\"ruby-keyword kw\">end</span>\n\
      452:     <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: 439 $"
- name: SVNId
  desc: |+
    
    SVN Id
    
  value: "%q$Id: logger.rb 439 2008-04-10 23:27:34Z 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: LEVEL_NAMES
  value: LEVELS.invert

[Validate]

Generated with the Darkfish Rdoc Generator.