class PrcLib::Logging

Class used to create 2 logger object, in order to keep track of error in a log file and change log output to OUTPUT on needs (option flags). The idea is that everytime, if you did not set the debug level mode, you can refer to the log file which is already configured with Logger::DEBUG level.

As well, sometimes, you do not want to keep track on messages that are just to keep informed the end user about activity. So, this object implement 2 Logger objects.

Everytime you log a message with Logging, it is printed out if the level permits and stored everytime in the log file, never mind about Logger level set. In several cases, messages are printed out, but not stored in the log file.

To use the Prc::Logging system, do the following:

require 'PrcLib'

# To configure logging system:
PrcLib.app_name = 'config/app' # Define application data path as
                               # ~/.<app_name>.
                               #  Ex: 'config/app' will use ~/.config/app
PrcLib.log_file = 'app.log'    # Relative path to the log file name
                               # stored in the Application data path.
                               # Here, ~/.config/app/app.log
PrcLib.level = Logger::FATAL   # Define printout debug level. Can be any
                               # Logger predefined value.

# To log some information:
PrcLib.debug('My %s debug message', 'test')
PrcLib.info('My info message')
PrcLib.warning('my warning')
PrcLib.error('my error')
PrcLib.fatal(2, "Fatal error, with return code = 2)
PrcLib.message('Only printout message')

# You can printout some instant message to the terminal, not logged.
# This is useful before any action that will take time to be executed.
# It is inform the end user that something is still running, which means
# the application is not frozen
PrcLib.state("Running a long task")
# The next message will replace the previous state message.
sleep(10)
PrcLib.info("The long task has been executed successfully.")

# You can change the logger level with PrcLib.level
PrcLib.level = Logger::DEBUG

# You can just print high level message (print without \n)
# if PrcLib.level is not DEBUG or INFO.
PrcLib.high_level_msg("Print a message, not logged, if level is not DEBUG
# or INFO")

For details, see Logging functions

Attributes

level[R]

Public Class Methods

new() click to toggle source

Initialize Logging instance The log file name is defined by PrcLib.log_file The log path is defined by PrcLib.app_name and will be kept as ~/.<PrcLib.app_name> The log level is defined by PrcLib.level. It will update only log print out. Depending on levels, messages are prefixed by colored 'ERROR!!!', 'FATAL!!!', 'WARNING' or <LEVEL NAME>

# File lib/logging.rb, line 93
def initialize
  file_logger_initialize

  @out_logger = Logger.new(STDOUT)
  @level = Logger::WARN
  @out_logger.level = @level
  @out_logger.formatter = proc do |severity, _datetime, _progname, msg|
    case severity
    when 'ANY'
      str = "#{msg} \n"
    when 'ERROR', 'FATAL'
      str = ANSI.bold(ANSI.red("#{severity}!!!")) + ": #{msg} \n"
    when 'WARN'
      str = ANSI.bold(ANSI.yellow('WARNING')) + ": #{msg} \n"
    else
      str = "#{severity}: #{msg} \n"
    end
    str
  end
end

Public Instance Methods

debug(message) click to toggle source

Log to STDOUT and Log file and DEBUG class message

# File lib/logging.rb, line 141
def debug(message)
  @out_logger.debug(message + ANSI.clear_eol)
  @file_logger.debug(message)
end
debug?() click to toggle source

Is Logging print out level is debug?

# File lib/logging.rb, line 120
def debug?
  (@out_logger.debug?)
end
error(message) click to toggle source

Log to STDOUT and Log file and ERROR class message

# File lib/logging.rb, line 147
def error(message)
  @out_logger.error(message + ANSI.clear_eol)
  @file_logger.error(message + "\n" + caller.join("\n"))
end
error?() click to toggle source

Is Logging print out level is error?

# File lib/logging.rb, line 125
def error?
  (@out_logger.error?)
end
fatal(message) click to toggle source

Log to STDOUT and Log file and FATAL class message

# File lib/logging.rb, line 153
def fatal(message)
  @out_logger.fatal(message + ANSI.clear_eol)
  @file_logger.fatal(message)
end
fatal?() click to toggle source

Is Logging print out level is fatal?

# File lib/logging.rb, line 130
def fatal?
  (@out_logger.fatal?)
end
info(message) click to toggle source

Log to STDOUT and Log file and INFO class message

# File lib/logging.rb, line 135
def info(message)
  @out_logger.info(message + ANSI.clear_eol)
  @file_logger.info(message)
end
info?() click to toggle source

Is Logging print out level is info?

# File lib/logging.rb, line 115
def info?
  (@out_logger.info?)
end
level=(level) click to toggle source

set STDOUT logger level

# File lib/logging.rb, line 165
def level=(level)
  @level = level
  @out_logger.level = level
end
unknown(message) click to toggle source

Print out a message, not logged in the log file. This message is printed out systematically as not taking care of logger level.

# File lib/logging.rb, line 174
def unknown(message)
  @out_logger.unknown(message + ANSI.clear_eol)
end
warn(message) click to toggle source

Log to STDOUT and Log file and WARNING class message

# File lib/logging.rb, line 159
def warn(message)
  @out_logger.warn(message + ANSI.clear_eol)
  @file_logger.warn(message)
end

Private Instance Methods

file_logger_initialize() click to toggle source
# File lib/logging.rb, line 180
def file_logger_initialize
  @file_logger = Logger.new(PrcLib.log_file, 'weekly')
  @file_logger.level = Logger::DEBUG
  @file_logger.formatter = proc do |severity, datetime, progname, msg|
    "#{progname} : #{datetime}: #{severity}: #{msg} \n"
  end
end