def add(severity, message = nil, progname_or_message = nil, &block)
      @logger.add(severity, message, progname_or_message, &block) if @logger
    end
def add(severity, message = nil, progname_or_message = nil, &block)
      @logger.add(severity, message, progname_or_message, &block) if @logger
    end
Log a message at the given level if the logger is present

 This isn't generally a recommended method to use while logging in your
 libraries. Instead see {#debug}, {#info}, {#warn}, {#error}, {#fatal}, and
 {#unknown} as they simplify messaging considerably.

 If you don't want to use the recommended methods and want more control for
 some reason. There are a few ways to log a message depending on your usecase.

 The first is probably the most generally useful, which is logging messages
 that aren't costly to build. This is accomplished as follows:

     add(::Logger::INFO, 'some message', nil)

 The second is for use cases in which it is costly to build the log message
 as it avoids executing the block until the logger knows that the message
 level will be displayed. If the message level would not be displayed then
 the block is not executed, saving the performance cost of building the
 message.

     add(::Logger::INFO) { 'some expensive message' }

 The third gives you the benefits of preventing uneeded expensive messages
 but also allows you to override the program name that will be prefixed on
 that log message. This is accomplished as follows.

     add(::Logger::INFO, nil, 'overridden progname') { 'some expensive message' }

 It is important to realize that if the wrapped logger is nil then this
 method will simply do nothing.

 @param severity ::Logger::DEBUG, ::Logger::INFO, ::Logger::WARN,
   ::Logger::ERROR, ::Logger::FATAL, ::Logger::UNKNOWN
 @param message the optional message to log
 @param progname_or_message the optional program name or message, if
   message is nil, and a block is NOT provided, then progname_or_message is
   treated as a message rather than progname
 @param block the block to evaluate and yield a message, generally useful
   preventing building of expensive messages when message of that level
   aren't allowed