123456789_123456789_123456789_123456789_123456789_

Class: ActiveSupport::ProxyLogger

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Instance Chain:
self, Logger::Severity, LoggerThreadSafeLevel, LoggerSilence
Inherits: Object
Defined in: activesupport/lib/active_support/proxy_logger.rb

Overview

The proxy logger, is a logger that forwards all received logs to another logger, but has its own independent severity level.

This is useful when you want some library you have no control over to use the same logger as the rest of your application, but to have a different severity level because it is logging too much:

SomeLibrary.logger = ActiveSupport::ProxyLogger.new(Rails.logger, :error)

Almost all of the standard Logger interface is supported.

Note that the proxy logger can only surpress some logs, if the proxy severity is lower than the severity of the proxied logger, the logs won't be emitted.

LoggerSilence - Attributes & Methods

Class Method Summary

Instance Attribute Summary

  • #debug? ⇒ Boolean readonly

    Returns true if the log level allows entries with severity Logger::DEBUG to be written, false otherwise.

  • #error? ⇒ Boolean readonly

    Returns true if the log level allows entries with severity Logger::ERROR to be written, false otherwise.

  • #fatal? ⇒ Boolean readonly

    Returns true if the log level allows entries with severity Logger::FATAL to be written, false otherwise.

  • #info? ⇒ Boolean readonly

    Returns true if the log level allows entries with severity Logger::INFO to be written, false otherwise.

  • #level rw

    Logging severity threshold (e.g.

  • #level=(severity) rw

    Sets the log level; returns severity.

  • #warn? ⇒ Boolean readonly

    Returns true if the log level allows entries with severity Logger::WARN to be written, false otherwise.

LoggerThreadSafeLevel - self

#local_level, #local_level=, #local_level_key

Instance Method Summary

LoggerThreadSafeLevel - self

#initialize, #initialize_copy, #level,
#log_at

Change the thread-local level for the duration of the given block.

LoggerSilence - Included

#silence

Silences the logger for the duration of the block.

Constructor Details

.new(logger, level = ::Logger::DEBUG) ⇒ ProxyLogger

[ GitHub ] 

  


# File 'activesupport/lib/active_support/proxy_logger.rb', line 26



def initialize(logger, level = ::Logger::DEBUG)
  @logger = logger
  @level = ::Logger::Severity.coerce(level)
end


  







Class Attribute Details



  

    .silencer   (rw)
    Also known as: #silencer
  

  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/logger_silence.rb', line 12



cattr_accessor :silencer, default: true


  







Instance Attribute Details



  

    #debug?  ⇒ Boolean  (readonly)
  



  

    
Returns true if the log level allows entries with severity
Logger::DEBUG to be written, false otherwise.

  





  


  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/proxy_logger.rb', line 59



def debug?; level <= DEBUG; end


  








  

    #error?  ⇒ Boolean  (readonly)
  



  

    
Returns true if the log level allows entries with severity
Logger::ERROR to be written, false otherwise.

  





  


  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/proxy_logger.rb', line 80



def error?; level <= ERROR; end


  








  

    #fatal?  ⇒ Boolean  (readonly)
  



  

    
Returns true if the log level allows entries with severity
Logger::FATAL to be written, false otherwise.

  





  


  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/proxy_logger.rb', line 87



def fatal?; level <= FATAL; end


  








  

    #info?  ⇒ Boolean  (readonly)
  



  

    
Returns true if the log level allows entries with severity
Logger::INFO to be written, false otherwise.

  





  


  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/proxy_logger.rb', line 66



def info?; level <= INFO; end


  








  

    #level   (rw)
  



  

    
Logging severity threshold (e.g. Logger::INFO).

  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/proxy_logger.rb', line 32



attr_reader :level


  








  

    #level=(severity)   (rw)
  



  

    
Sets the log level; returns severity.


Argument severity may be an integer, a string, or a symbol:


logger.level = Logger::ERROR # => 3
logger.level = 3             # => 3
logger.level = 'error'       # => "error"
logger.level = :error        # => :error

  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/proxy_logger.rb', line 42



def level=(severity)
  @level = ::Logger::Severity.coerce(severity)
end


  








  

    #silencer   (rw)
  

  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/logger_silence.rb', line 12



cattr_accessor :silencer, default: true


  








  

    #warn?  ⇒ Boolean  (readonly)
  



  

    
Returns true if the log level allows entries with severity
Logger::WARN to be written, false otherwise.

  





  


  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/proxy_logger.rb', line 73



def warn?; level <= WARN; end


  







Instance Method Details



  

    #<<(msg)  
  



  

    
Forward the given msg to the underlying logger with no formatting
returns the number of characters written,
or nil if the underlying logger is nil:


logger = ProxyLogger.new(Logger.new($stderr))
logger << 'My message.' # => 10


Output:


My message.

  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/proxy_logger.rb', line 136



def <<(msg)
  if @logger
    @logger << msg
  end
end


  








  

    #add(severity)  
  



  

    
Creates a log entry, which may or may not be written to the log,
depending on the entry's severity and on the log level.


Examples:


logger = ActiveSupport::ProxyLogger.new(Logger.new($stderr), :error)
logger.add(Logger::INFO, 'Will not show')
logger.add(Logger::ERROR, 'No good')
logger.add(Logger::ERROR, 'No good', 'gnum')


Output:


E, [2022-05-12T16:25:55.349414 #36328] ERROR -- mung: No good
E, [2022-05-12T16:26:35.841134 #36328] ERROR -- gnum: No good


These convenience methods have implicit severity:


  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/proxy_logger.rb', line 116



def add(severity, ...)
  severity ||= UNKNOWN
  if @logger && severity >= level
    @logger.add(severity, ...)
  else
    true
  end
end


  








  

    #close  
  



  

    
Closes the logger; returns nil:
Further logs won't be emitted.

  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/proxy_logger.rb', line 48



def close
  @logger = nil
end


  








  

    #debug(progname = nil, &block)   (readonly)
  



  

    
Equivalent to calling #add with severity Logger::DEBUG.

  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/proxy_logger.rb', line 143



def debug(progname = nil, &block)
  add(DEBUG, nil, progname, &block)
end


  








  

    #debug!  
  



  

    
Sets the log level to Logger::DEBUG.

  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/proxy_logger.rb', line 62



def debug!; self.level = DEBUG; end


  








  

    #error(progname = nil, &block)   (readonly)
  



  

    
Equivalent to calling #add with severity Logger::ERROR.

  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/proxy_logger.rb', line 160



def error(progname = nil, &block)
  add(ERROR, nil, progname, &block)
end


  








  

    #error!  
  



  

    
Sets the log level to Logger::ERROR.

  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/proxy_logger.rb', line 83



def error!; self.level = ERROR; end


  








  

    #fatal(progname = nil, &block)   (readonly)
  



  

    
Equivalent to calling #add with severity Logger::FATAL.

  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/proxy_logger.rb', line 166



def fatal(progname = nil, &block)
  add(FATAL, nil, progname, &block)
end


  








  

    #fatal!  
  



  

    
Sets the log level to Logger::FATAL.

  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/proxy_logger.rb', line 90



def fatal!; self.level = FATAL; end


  








  

    #info(progname = nil, &block)   (readonly)
  



  

    
Equivalent to calling #add with severity Logger::INFO.

  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/proxy_logger.rb', line 148



def info(progname = nil, &block)
  add(INFO, nil, progname, &block)
end


  








  

    #info!  
  



  

    
Sets the log level to Logger::INFO.

  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/proxy_logger.rb', line 69



def info!; self.level = INFO; end


  








  

    #reopen(logger)  
  



  

    
Change the underlying logger.

  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/proxy_logger.rb', line 53



def reopen(logger)
  @logger = logger
end


  








  

    #unknown(progname = nil, &block)  
  



  

    
Equivalent to calling #add with severity Logger::UNKNOWN.

  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/proxy_logger.rb', line 172



def unknown(progname = nil, &block)
  add(UNKNOWN, nil, progname, &block)
end


  








  

    #warn(progname = nil, &block)   (readonly)
  



  

    
Equivalent to calling #add with severity Logger::WARN.

  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/proxy_logger.rb', line 154



def warn(progname = nil, &block)
  add(WARN, nil, progname, &block)
end


  








  

    #warn!  
  



  

    
Sets the log level to Logger::WARN.

  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/proxy_logger.rb', line 76



def warn!; self.level = WARN; end