Class: F4R::F4RLogger

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

Overview

Singleton to provide a common logging mechanism for all objects. It exposes essentially the same interface as the Logger class but just as a singleton and with some additional methods like 'debug', 'warn', 'info'.

It also facilitates configurable log output redirection based on severity levels to help reduce noise in the different output devices.

Instance Method Summary collapse

Instance Method Details

#color=(bool) ⇒ Object

Allow other programs to enable or disable colour output.

Examples:

F4R::Log.color = true

Parameters:

  • bool (Boolean) 


183
184
185
 
# File 'lib/f4r.rb', line 183

def color=(bool)
  @color = bool
end

#color? ⇒ Boolean

When set to True enables logger colour output.

Returns:

  • (Boolean) —

    @color



192
193
194
 
# File 'lib/f4r.rb', line 192

def color?
  @color ||= false
end

#debug(msg = '', items = {}) {|block| ... } ⇒ String

DEBUG level messages.

Example:

>> Log.debug [self.class, __method__], {a:1, b:2}
=> DEBUG  <F4R::Record#fields> a: 1 b: 2

Parameters:

  • msg (String, Array<String>) (defaults to: '') —

    Mostly used to locate or describe items in the items parameter.

    String: Simple text message.

    Array: List of key words to be concatenated with a '#' inside '<>' (see: #format_message). Meant to be used for describing the class and method where the log message was called from.

    Example:
>> ['F4R::Record', 'fields'] #=> '<F4R::Record#fields>'
  • items (Hash) (defaults to: {}) —

    Key/Value list of items for debugging.

Yields:

  • (block) —

    passed directly to the [F4RLogger] logger.

Returns:

  • (String) —

    formatted message.



223
224
225
 
# File 'lib/f4r.rb', line 223

def debug(msg = '', items = {},  &block)
  logger.debug(format_message(msg, items), &block)
end

#decode(msg, items = {}) {|block| ... } ⇒ String

DECODE level messages.

Similar to #debug but with its specific [F4RLogger] logger.

Parameters:

  • msg (String, Array<String>)
  • items (Hash) (defaults to: {})

Yields:

  • (block) —

    passed directly to the [F4RLogger] logger

Returns:

  • (String) —

    formatted message



290
291
292
 
# File 'lib/f4r.rb', line 290

def decode(msg, items = {}, &block)
  decode_logger.decode(format_message(msg, items), &block)
end

#decode_logger ⇒ Logger

Returns @decode_logger.

Returns:



146
147
148
 
# File 'lib/f4r.rb', line 146

def decode_logger
  @decode_logger ||= Logger.new('/tmp/f4r-decode.log')
end

#decode_logger=(logger) ⇒ Logger

Returns @decode_logger.

Examples:

F4R::Log.decode_logger = F4R::Logger.new($stdout)

Parameters:

Returns:



125
126
127
 
# File 'lib/f4r.rb', line 125

def decode_logger=(logger)
  log_formater(logger) && @decode_logger = logger
end

#encode(msg, items = {}) {|block| ... } ⇒ String

ENCODE level messages.

Similar to #debug but with its specific [F4RLogger] logger

Parameters:

  • msg (String, Array<String>)
  • items (Hash) (defaults to: {})

Yields:

  • (block) —

    passed directly to the [F4RLogger] logger

Returns:

  • (String) —

    formatted message



276
277
278
 
# File 'lib/f4r.rb', line 276

def encode(msg, items = {}, &block)
  decode_logger.encode(format_message(msg, items), &block)
end

#encode_logger ⇒ Logger

Returns @encode_logger.

Returns:



139
140
141
 
# File 'lib/f4r.rb', line 139

def encode_logger
  @encode_logger ||= Logger.new('/tmp/f4r-encode.log')
end

#encode_logger=(logger) ⇒ Logger

Returns @encode_logger.

Examples:

F4R::Log.encode_logger = F4R::Logger.new($stdout)

Parameters:

Returns:



114
115
116
 
# File 'lib/f4r.rb', line 114

def encode_logger=(logger)
  log_formater(logger) && @encode_logger = logger
end

#error(msg) {|block| ... } ⇒ Object

ERROR level messages.

Raises [F4R::ERROR].

Parameters:

  • msg (String) —

    Passed directly to the [F4RLogger] logger.

Yields:

  • (block) —

    passed directly to the [F4RLogger] logger.

Raises:



261
262
263
264
 
# File 'lib/f4r.rb', line 261

def error(msg, &block)
  logger.error(msg, &block)
  raise Error, msg
end

#format_message(msg, items) ⇒ String

Formats message and items for the [F4RLogger] logger output. It also adds colour when #color? has been set to true.

Parameters:

  • msg (String, Array<String, Object>)
  • items (Hash)

Returns:

  • (String) —

    formatted message



318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
 
# File 'lib/f4r.rb', line 318

def format_message(msg, items)
  if msg.is_a?(Array)
    if Log.color?
      msg =  Log.tint(:blue, "<#{msg.join('#')}>")
    else
      msg = "<#{msg.join('#')}>"
    end
  end

  items.each do |k, v|
    k = Log.color? ? Log.tint(:green, k.to_s): k.to_s
    msg += " #{k}: #{v.to_s}"
  end
  msg
end

#info(msg) {|block| ... } ⇒ String

INFO level messages.

Parameters:

  • msg (String) —

    passed directly to the [F4RLogger] logger

Yields:

  • (block) —

    passed directly to the [F4RLogger] logger

Returns:

  • (String) —

    formatted message



234
235
236
 
# File 'lib/f4r.rb', line 234

def info(msg, &block)
  logger.info(msg, &block)
end

#level ⇒ Symbol, ...

Severity level for all [F4RLogger] loggers.

Returns:

  • (Symbol, String, Integer) —

    @@level



171
172
173
 
# File 'lib/f4r.rb', line 171

def level
  @level ||= :error
end

#level=(level) ⇒ Object

Method for setting the severity level for all loggers.

Examples:

F4R::Log.level = :error

Parameters:

  • level (Symbol, String, Integer) 


158
159
160
161
162
163
164
 
# File 'lib/f4r.rb', line 158

def level=(level)
  [
    logger,
    decode_logger,
    encode_logger
  ].each { |lgr| lgr.level = level}
end

#log_formater(logger) ⇒ Object

Logger formatter configuration



337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
 
# File 'lib/f4r.rb', line 337

def log_formater(logger)
  logger.formatter = proc do |severity, _, _, msg|

    if Log.color?
      sc = {
        'DEBUG' => :magenta,
        'INFO' => :blue,
        'WARN' => :yellow,
        'ERROR' => :red,
        'ENCODE' => :green,
        'DECODE' => :cyan,
      }
      Log.tint(sc[severity], "#{'%-6s' % severity} ") + "#{msg}\n"
    else
      severity + " #{msg}\n"
    end

  end
end

#logger ⇒ Logger

Returns @logger.

Returns:



132
133
134
 
# File 'lib/f4r.rb', line 132

def logger
  @logger ||= Logger.new($stdout)
end

#logger=(logger) ⇒ Logger

Returns @logger.

Examples:

F4R::Log.logger = F4R::Logger.new($stdout)

Parameters:

Returns:



103
104
105
 
# File 'lib/f4r.rb', line 103

def logger=(logger)
  log_formater(logger) && @logger = logger
end

#tint(clr, text) ⇒ String

Simple colour codes mapping.

Parameters:

  • clr (Symbol) —

    to define colour code to use

  • text (String) —

    to be coloured

Returns:

  • (String) —

    text with the proper colour code



301
302
303
304
305
306
307
308
 
# File 'lib/f4r.rb', line 301

def tint(clr, text)
  codes = {
    none: 0, bright: 1, black: 30, red: 31,
    green: 32, yellow: 33, blue: 34,
    magenta: 35, cyan: 36, white: 37, default: 39,
  }
  ["\x1B[", codes[clr].to_s, 'm', text.to_s, "\x1B[0m"].join
end

#warn(msg) {|block| ... } ⇒ String

WARN level messages.

Parameters:

  • msg (String) —

    Passed directly to the [F4RLogger] logger after removing all newlines.

Yields:

  • (block) —

    passed directly to the [F4RLogger] logger

Returns:

  • (String) —

    formatted message



248
249
250
 
# File 'lib/f4r.rb', line 248

def warn(msg, &block)
  logger.warn(msg.gsub(/\n/, ' '), &block)
end