Class: PrcLib::Logging

Inherits:
Object show all
Defined in:
lib/logging.rb

Overview

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.

  • One for log file

  • One for print out.

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

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Logging

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>



93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# 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

Instance Attribute Details

#level ⇒ Object

Returns the value of attribute level.



170
171
172
 
# File 'lib/logging.rb', line 170

def level
  @level
end

Instance Method Details

#debug(message) ⇒ Object

Log to STDOUT and Log file and DEBUG class message



141
142
143
144
 
# File 'lib/logging.rb', line 141

def debug(message)
  @out_logger.debug(message + ANSI.clear_eol)
  @file_logger.debug(message)
end

#debug? ⇒ Boolean

Is Logging print out level is debug?

Returns:

  • (Boolean) 


120
121
122
 
# File 'lib/logging.rb', line 120

def debug?
  (@out_logger.debug?)
end

#error(message) ⇒ Object

Log to STDOUT and Log file and ERROR class message



147
148
149
150
 
# 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? ⇒ Boolean

Is Logging print out level is error?

Returns:

  • (Boolean) 


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

def error?
  (@out_logger.error?)
end

#fatal(message) ⇒ Object

Log to STDOUT and Log file and FATAL class message



153
154
155
156
 
# File 'lib/logging.rb', line 153

def fatal(message)
  @out_logger.fatal(message + ANSI.clear_eol)
  @file_logger.fatal(message)
end

#fatal? ⇒ Boolean

Is Logging print out level is fatal?

Returns:

  • (Boolean) 


130
131
132
 
# File 'lib/logging.rb', line 130

def fatal?
  (@out_logger.fatal?)
end

#info(message) ⇒ Object

Log to STDOUT and Log file and INFO class message



135
136
137
138
 
# File 'lib/logging.rb', line 135

def info(message)
  @out_logger.info(message + ANSI.clear_eol)
  @file_logger.info(message)
end

#info? ⇒ Boolean

Is Logging print out level is info?

Returns:

  • (Boolean) 


115
116
117
 
# File 'lib/logging.rb', line 115

def info?
  (@out_logger.info?)
end

#unknown(message) ⇒ Object

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



174
175
176
 
# File 'lib/logging.rb', line 174

def unknown(message)
  @out_logger.unknown(message + ANSI.clear_eol)
end

#warn(message) ⇒ Object

Log to STDOUT and Log file and WARNING class message



159
160
161
162
 
# File 'lib/logging.rb', line 159

def warn(message)
  @out_logger.warn(message + ANSI.clear_eol)
  @file_logger.warn(message)
end