Class: LogEasy::Logger

Inherits:
Object
  • Object
show all
Defined in:
lib/logeasy/logger.rb

Overview

The logger class. Use the ‘get_logger’ method to create and use loggers.

Usage:

To create a new logger: LogEasy::Logger.get_logger(<logger_name>)

logger_name - this should be a '.' separated or '::' separated hierarchy of loggers.
eg. LogEasy::Logger.get_logger("ModuleName::SubModule::ClassName")

To change the level of a logger. LogEasy::Logger.get_logger(<logger_name>).change_min_level(<new_level>) # Recursively changes this logger and all child loggers. LogEasy::Logger.get_logger(<logger_name>).min_level = <new_level> # Only change this logger’s level.

logger_name - the logger name.
new_level - the new level to set (instance of LogEasy::Level).
eg. LogEasy::Logger.get_logger("ModuleName::SubModule::ClassName").change_min_level(LogEasy::Level::INFO)

To add an appender to a logger. LogEasy::Logger.get_logger(<logger_name>).add_appender(<appender>)

logger_name - the logger name.
appender - the appender to add (instance of LogEasy::Appender).
eg. LogEasy::Logger.get_logger("ModuleName::SubModule::ClassName").add_appender(LogEasy::ConsoleAppender.new)

By default all sub-loggers will also use this appender. A logger can be told not to use a parent’s appender using the

'use_parent_logger' flag. So by adding an appender to the root logger, logs sent to any logger will, by default,
be logged by the root logger's appender(s) also.

Right now the only way to configure the loggers is using code. Look at example/example.rb for how to do that.

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#full_name ⇒ Object (readonly)

Returns the value of attribute full_name.



83
84
85
 
# File 'lib/logeasy/logger.rb', line 83

def full_name
  @full_name
end

#min_level ⇒ Object

Returns the value of attribute min_level.



84
85
86
 
# File 'lib/logeasy/logger.rb', line 84

def min_level
  @min_level
end

#name ⇒ Object (readonly)

Returns the value of attribute name.



82
83
84
 
# File 'lib/logeasy/logger.rb', line 82

def name
  @name
end

#parent ⇒ Object (readonly)

Returns the value of attribute parent.



81
82
83
 
# File 'lib/logeasy/logger.rb', line 81

def parent
  @parent
end

#use_parent_logger ⇒ Object

Returns the value of attribute use_parent_logger.



85
86
87
 
# File 'lib/logeasy/logger.rb', line 85

def use_parent_logger
  @use_parent_logger
end

Class Method Details

.get_logger(logger_name) ⇒ Object

Get the logger identified by the specified name. If a logger does not exist, a new one is created and returned.

‘logger_name’ - The name of the logger. The name should be a hierarchy of logger names separated by the ‘.’ or “::” characters.



45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/logeasy/logger.rb', line 45

def Logger.get_logger(logger_name)
  # Return immediately if the logger was found.
  return @@loggers[logger_name] if @@loggers.has_key?(logger_name)
  # Logger does not exist. Create each part.
  parent = root_logger
  logger_name_parts = logger_name.split(/\.|::/)
  logger_name_parts.each do |part|
    # Each part must be at least one character long (i.e. 2 consecutive '.' are not allowed).
    raise "Invalid logger name '#{logger_name}'!" if part.length == 0
    # Add this part to the current parent. If the logger is already present in this parent, then nothing is done.
    parent = parent.add_logger(part)
  end
  # Finally, the parent is the required logger.
  parent
end

.root_logger ⇒ Object

Get the root logger. The root logger is special, since it does not have a parent.

Returns => Logger



64
65
66
67
 
# File 'lib/logeasy/logger.rb', line 64

def Logger.root_logger
  @@root_logger = new(nil, "Root") if @@root_logger.nil?
  @@root_logger
end

.self_logger ⇒ Object

Get the internal logger. By default this logger is switched off. This logger is special too, since it has no parent.

Returns => Logger



73
74
75
76
77
78
79
 
# File 'lib/logeasy/logger.rb', line 73

def Logger.self_logger
  if @@self_logger.nil?
    @@self_logger = new(nil, "EasyLog")
    @@self_logger.min_level = Level::OFF
  end
  @@self_logger
end

Instance Method Details

#<<(message, level = Level::UNFORMATTED) ⇒ Object

Writes the specified log without any formatting to the output. This is treated as any other log message (i.e. the level restrictions apply), only the output is not formatted. By default the level is UNFORMATTED (higher than FATAL).

‘message’ - The message to print. ‘level’ - The level of the message. Default is UNFORMATTED.



93
94
95
96
97
 
# File 'lib/logeasy/logger.rb', line 93

def <<(message, level = Level::UNFORMATTED)
  # The unformatted log item.
  log_item = Log.new(self, level, message, true)
  do_log(log_item)
end

#add_appender(appender) ⇒ Object

Adds an appender to this logger. Removes the appender from any other logger it was associated with.

‘appender’ - The appender to add.



102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/logeasy/logger.rb', line 102

def add_appender(appender)
  # Remove the appender from its earlier logger, if it exists.
  logger = appender.logger
  logger.remove_appender(appender) if not logger.nil?
  # Save the new logger and add it to the appender list.
  # Update the min_level to this logger's min level, if the appender's min level was nil (i.e. a new appender).
  appender.logger = self
  appender.min_level = self.min_level if appender.min_level.nil?
  appenders << appender
  Logger.self_logger.fine("Added '#{appender}' to '#{self}'.")
end

#add_logger(logger_name) ⇒ Object

Adds a child logger of the specified name. If a child already exists then nothing is done. The method will always return the child logger (new or old). This method is used internally to create loggers. Users should use the ‘get_logger’ method instead to create logger.

‘logger_name’ - The name of the logger.

Returns => Logger



121
122
123
124
125
126
127
128
129
 
# File 'lib/logeasy/logger.rb', line 121

def add_logger(logger_name)
  if not children.has_key?(logger_name)
    logger = Logger.new(self, logger_name)
    children[logger_name] = logger
    Logger.self_logger.fine("Created new logger '#{logger}'.")
  end
  # Return the logger.
  children[logger_name]
end

#change_min_level(new_level) ⇒ Object

Recursively change the level of this logger and all child loggers. Use min_level= to limit the change to this logger only.

‘new_level’ - The new level to set.



188
189
190
191
192
193
 
# File 'lib/logeasy/logger.rb', line 188

def change_min_level(new_level)
  self.min_level = new_level
  Logger.self_logger.fine("Changed minimum level for '#{self}' to '#{new_level}'.")
  # Cascade to all children.
  children.each_value { |child| child.change_min_level(new_level) }
end

#conf(message) ⇒ Object

Logs a CONF level message.

‘message’ - The log’s message.



134
135
136
 
# File 'lib/logeasy/logger.rb', line 134

def conf(message)
  log(Level::CONF, message)
end

#debug(message) ⇒ Object

Logs a DEBUG level message.

‘message’ - The log’s message.



141
142
143
 
# File 'lib/logeasy/logger.rb', line 141

def debug(message)
  log(Level::DEBUG, message)
end

#error(message) ⇒ Object

Logs a ERROR level message.

‘message’ - The log’s message.



148
149
150
 
# File 'lib/logeasy/logger.rb', line 148

def error(message)
  log(Level::ERROR, message)
end

#fatal(message) ⇒ Object

Logs a FATAL level message.

‘message’ - The log’s message.



155
156
157
 
# File 'lib/logeasy/logger.rb', line 155

def fatal(message)
  log(Level::FATAL, message)
end

#fine(message) ⇒ Object

Logs a FINE_TRACE level message.

‘message’ - The log’s message.



162
163
164
 
# File 'lib/logeasy/logger.rb', line 162

def fine(message)
  log(Level::FINE_TRACE, message)
end

#info(message) ⇒ Object

Logs a INFO level message.

‘message’ - The log’s message.



169
170
171
 
# File 'lib/logeasy/logger.rb', line 169

def info(message)
  log(Level::INFO, message)
end

#log(level, message) ⇒ Object

Creates a new log and dispatches it. If this logger’s level is higher than the specified level, this method will return immediately.

‘level’ - The level to log the message at. ‘message’ - The log’s message.



178
179
180
181
182
 
# File 'lib/logeasy/logger.rb', line 178

def log(level, message)
  return if level < min_level
  log_item = Log.new(self, level, message)
  do_log_no_check(log_item)
end

#remove_appender(appender) ⇒ Object

Remove the specified appender from the list of appenders for this logger.

‘appender’ - The appender to remove.



198
199
200
201
202
 
# File 'lib/logeasy/logger.rb', line 198

def remove_appender(appender)
  @appenders.reject! { |item| appender.eql?(item) }
  appender.logger = nil
  Logger.self_logger.fine("Removed '#{appender}' from '#{self}'.")
end

#to_s ⇒ Object

Override to_s to return the full name of this logger.



205
206
207
 
# File 'lib/logeasy/logger.rb', line 205

def to_s
  full_name
end

#trace(message) ⇒ Object

Logs a TRACE level message.

‘message’ - The log’s message.



212
213
214
 
# File 'lib/logeasy/logger.rb', line 212

def trace(message)
  log(Level::TRACE, message)
end

#warn(message) ⇒ Object

Logs a WARN level message.

‘message’ - The log’s message.



219
220
221
 
# File 'lib/logeasy/logger.rb', line 219

def warn(message)
  log(Level::WARN, message)
end