class Logging::Repository

The Repository is a hash that stores references to all Loggers that have been created. It provides methods to determine parent/child relationships between Loggers and to retrieve Loggers from the hash.

Public Class Methods

new() click to toggle source

nodoc:

This is a singleton class – use the instance method to obtain the Repository instance.

# File lib/logging/repository.rb, line 20
def initialize
  @h = {:root => ::Logging::RootLogger.new}

  # configures the internal logger which is disabled by default
  logger = ::Logging::Logger.allocate
  logger._setup(
      to_key(::Logging),
      :parent   => @h[:root],
      :additive => false,
      :level    => ::Logging::LEVELS.length   # turns this logger off
  )
  @h[logger.name] = logger
end

Public Instance Methods

instance[name] click to toggle source

Returns the Logger named name.

When name is a String or a Symbol it will be used “as is” to retrieve the logger. When name is a Class the class name will be used to retrieve the logger. When name is an object the name of the object's class will be used to retrieve the logger.

Example:

repo = Repository.instance
obj = MyClass.new

log1 = repo[obj]
log2 = repo[MyClass]
log3 = repo['MyClass']

log1.object_id == log2.object_id         # => true
log2.object_id == log3.object_id         # => true
# File lib/logging/repository.rb, line 56
def []( key ) @h[to_key(key)] end
instance[name] = logger click to toggle source

Stores the logger under the given name.

When name is a String or a Symbol it will be used “as is” to store the logger. When name is a Class the class name will be used to store the logger. When name is an object the name of the object's class will be used to store the logger.

# File lib/logging/repository.rb, line 68
def []=( key, val ) @h[to_key(key)] = val end
children( key ) click to toggle source

Returns an array of the children loggers for the logger identified by key where key follows the same identification rules described in +Repository#[]+. Children are returned regardless of the existence of the logger referenced by key.

# File lib/logging/repository.rb, line 146
def children( parent )
  ary = []
  parent = to_key(parent)

  @h.each_pair do |child,logger|
    next if :root == child
    ary << logger if parent == parent_name(child)
  end
  return ary.sort
end
delete( name ) click to toggle source

Deletes the named logger from the repository. All direct children of the logger will have their parent reassigned. So the parent of the logger being deleted becomes the new parent of the children.

When name is a String or a Symbol it will be used “as is” to remove the logger. When name is a Class the class name will be used to remove the logger. When name is an object the name of the object's class will be used to remove the logger.

Raises a RuntimeError if you try to delete the root logger. Raises an KeyError if the named logger is not found.

# File lib/logging/repository.rb, line 110
def delete( key )
  key = to_key(key)
  raise 'the :root logger cannot be deleted' if :root == key

  parent = @h.fetch(key).parent
  children(key).each {|c| c.__send__(:parent=, parent)}
  @h.delete(key)
end
fetch( name ) click to toggle source

Returns the Logger named name. An KeyError will be raised if the logger does not exist.

When name is a String or a Symbol it will be used “as is” to retrieve the logger. When name is a Class the class name will be used to retrieve the logger. When name is an object the name of the object's class will be used to retrieve the logger.

# File lib/logging/repository.rb, line 81
def fetch( key ) @h.fetch(to_key(key)) end
has_logger?( name ) click to toggle source

Returns true if the given logger exists in the repository. Returns false if this is not the case.

When name is a String or a Symbol it will be used “as is” to retrieve the logger. When name is a Class the class name will be used to retrieve the logger. When name is an object the name of the object's class will be used to retrieve the logger.

# File lib/logging/repository.rb, line 94
def has_logger?( key ) @h.has_key?(to_key(key)) end
parent( key ) click to toggle source

Returns the parent logger for the logger identified by key where key follows the same identification rules described in Repository#[]. A parent is returned regardless of the existence of the logger referenced by key.

A note about parents -

If you have a class A::B::C, then the parent of C is B, and the parent of B is A. Parents are determined by namespace.

# File lib/logging/repository.rb, line 132
def parent( key )
  name = parent_name(to_key(key))
  return if name.nil?
  @h[name]
end
parent_name( key ) click to toggle source

Returns the name of the parent for the logger identified by the given key. If the key is for the root logger, then nil is returned.

# File lib/logging/repository.rb, line 180
def parent_name( key )
  return if :root == key

  a = key.split PATH_DELIMITER
  p = :root
  while a.slice!(-1) and !a.empty?
    k = a.join PATH_DELIMITER
    if @h.has_key? k then p = k; break end
  end
  p
end
to_key( key ) click to toggle source

Takes the given key and converts it into a form that can be used to retrieve a logger from the Repository hash.

When key is a String or a Symbol it will be returned “as is”. When key is a Class the class name will be returned. When key is an object the name of the object's class will be returned.

# File lib/logging/repository.rb, line 167
def to_key( key )
  case key
  when :root, 'root'; :root
  when String; key
  when Symbol; key.to_s
  when Module; key.logger_name
  when Object; key.class.logger_name
  end
end