Class: Logging::Repository

Inherits:
Object
  • Object
show all
Includes:
Singleton
Defined in:
lib/logging/repository.rb

Overview

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.

Constant Summary collapse

PATH_DELIMITER =

:nodoc:

'::'

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Repository

nodoc:

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



20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
# File 'lib/logging/repository.rb', line 20

def initialize
  @masters = []
  @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

Class Method Details

.reset ⇒ Object

:stopdoc:



208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
 
# File 'lib/logging/repository.rb', line 208

def self.reset
  if defined?(@singleton__instance__)
    @singleton__mutex__.synchronize {
      @singleton__instance__ = nil
    }
  else
    @__instance__ = nil
    class << self
      nonce = class << Singleton; self; end
      if defined?(nonce::FirstInstanceCall)
        define_method(:instance, nonce::FirstInstanceCall)
      else
        remove_method(:instance)
        Singleton.__init__(::Logging::Repository)
      end
    end
  end
  return nil
end

Instance Method Details

#[](key) ⇒ Object

call-seq:

instance[name]

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



57
 
# File 'lib/logging/repository.rb', line 57

def []( key ) @h[to_key(key)] end

#[]=(key, val) ⇒ Object

call-seq:

instance[name] = logger

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.



69
 
# File 'lib/logging/repository.rb', line 69

def []=( key, val ) @h[to_key(key)] = val end

#add_master(*args) ⇒ Object

call-seq:

add_master( 'First::Name', 'Second::Name', ... )

Add the given logger names to the list of consolidation masters. All classes in the given namespace(s) will use these loggers instead of creating their own individual loggers.



177
178
179
180
181
182
183
 
# File 'lib/logging/repository.rb', line 177

def add_master( *args )
  args.map do |key|
    key = to_key(key)
    @masters << key unless @masters.include? key
    key
  end
end

#children(parent) ⇒ Object

call-seq:

children( key )

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.



124
125
126
127
128
129
130
131
132
133
 
# File 'lib/logging/repository.rb', line 124

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

#fetch(key) ⇒ Object

call-seq:

fetch( name )

Returns the Logger named name. An IndexError 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.



82
 
# File 'lib/logging/repository.rb', line 82

def fetch( key ) @h.fetch(to_key(key)) end

#has_logger?(key) ⇒ Boolean

call-seq:

has_logger?( name )

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.

Returns:

  • (Boolean) 


95
 
# File 'lib/logging/repository.rb', line 95

def has_logger?( key ) @h.has_key?(to_key(key)) end

#master_for(key) ⇒ Object

call-seq:

master_for( key )

Returns the consolidation master name for the given key. If there is no consolidation master, then nil is returned.



191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
 
# File 'lib/logging/repository.rb', line 191

def master_for( key )
  return if @masters.empty?
  key = to_key(key)

  loop do
    break key if @masters.include? key
    break nil if :root == key

    if index = key.rindex(PATH_DELIMITER)
      key = key.slice(0, index)
    else
      key = :root
    end
  end
end

#parent(key) ⇒ Object

call-seq:

parent( key )

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.



110
111
112
113
114
 
# File 'lib/logging/repository.rb', line 110

def parent( key )
  name = parent_name(to_key(key))
  return if name.nil?
  @h[name]
end

#parent_name(key) ⇒ Object

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.



158
159
160
161
162
163
164
165
166
167
168
 
# File 'lib/logging/repository.rb', line 158

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) ⇒ Object

call-seq:

to_key( key )

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.



145
146
147
148
149
150
151
152
153
 
# File 'lib/logging/repository.rb', line 145

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