ActiveSupport::BroadcastLogger (original) (raw)

Active Support Broadcast Logger

The Broadcast logger is a logger used to write messages to multiple IO. It is commonly used in development to display messages on STDOUT and also write them to a file (development.log). With the Broadcast logger, you can broadcast your logs to a unlimited number of sinks.

The BroadcastLogger acts as a standard logger and all methods you are used to are available. However, all the methods on this logger will propagate and be delegated to the other loggers that are part of the broadcast.

Broadcasting your logs.

stdout_logger = Logger.new(STDOUT)
file_logger   = Logger.new("development.log")
broadcast = BroadcastLogger.new(stdout_logger, file_logger)

broadcast.info("Hello world!") # Writes the log to STDOUT and the development.log file.

Add a logger to the broadcast.

stdout_logger = Logger.new(STDOUT)
broadcast = BroadcastLogger.new(stdout_logger)
file_logger   = Logger.new("development.log")
broadcast.broadcast_to(file_logger)

broadcast.info("Hello world!") # Writes the log to STDOUT and the development.log file.

Modifying the log level for all broadcasted loggers.

stdout_logger = Logger.new(STDOUT)
file_logger   = Logger.new("development.log")
broadcast = BroadcastLogger.new(stdout_logger, file_logger)

broadcast.level = Logger::FATAL # Modify the log level for the whole broadcast.

Stop broadcasting log to a sink.

stdout_logger = Logger.new(STDOUT)
file_logger   = Logger.new("development.log")
broadcast = BroadcastLogger.new(stdout_logger, file_logger)
broadcast.info("Hello world!") # Writes the log to STDOUT and the development.log file.

broadcast.stop_broadcasting_to(file_logger)
broadcast.info("Hello world!") # Writes the log *only* to STDOUT.

At least one sink has to be part of the broadcast. Otherwise, your logs will not be written anywhere. For instance:

broadcast = BroadcastLogger.new
broadcast.info("Hello world") # The log message will appear nowhere.

If you are adding a custom logger with custom methods to the broadcast, the ‘BroadcastLogger` will proxy them and return the raw value, or an array of raw values, depending on how many loggers in the broadcasts responded to the method:

class MyLogger < ::Logger
  def loggable?
    true
  end
end

logger = BroadcastLogger.new
logger.loggable? # => A NoMethodError exception is raised because no loggers in the broadcasts could respond.

logger.broadcast_to(MyLogger.new(STDOUT))
logger.loggable? # => true
logger.broadcast_to(MyLogger.new(STDOUT))
puts logger.broadcasts # => [MyLogger, MyLogger]
logger.loggable? # [true, true]

Methods

• <<

A

• add

B

• broadcast_to

C

• close

D

• debug,
• debug!,
• debug?

E

• error,
• error!,
• error?

F

• fatal,
• fatal!,
• fatal?,
• formatter=

I

• info,
• info!,
• info?,
• initialize_copy

L

• level,
• level=,
• local_level=,
• log

N

• new

S

• sev_threshold=,
• stop_broadcasting_to

U

• unknown

W

• warn,
• warn!,
• warn?

Included Modules

• ActiveSupport::LoggerSilence

Attributes

Class Public methods

new(*loggers)Link

Source: show | on GitHub

def initialize(*loggers) @broadcasts = [] @progname = "Broadcast"

broadcast_to(*loggers) end

Instance Public methods

<<(message)Link

Source: show | on GitHub

def <<(message) dispatch { |logger| logger.<<(message) } end

add(...)Link

Also aliased as: log

Source: show | on GitHub

def add(...) dispatch { |logger| logger.add(...) } end

broadcast_to(*loggers)Link

Add logger(s) to the broadcast.

broadcast_logger = ActiveSupport::BroadcastLogger.new
broadcast_logger.broadcast_to(Logger.new(STDOUT), Logger.new(STDERR))

Source: show | on GitHub

def broadcast_to(*loggers) @broadcasts.concat(loggers) end

close()Link

Source: show | on GitHub

def close dispatch { |logger| logger.close } end

debug(...)Link

Source: show | on GitHub

def debug(...) dispatch { |logger| logger.debug(...) } end

debug!()Link

Sets the log level to Logger::DEBUG for the whole broadcast.

Source: show | on GitHub

def debug! dispatch { |logger| logger.debug! } end

debug?()Link

True if the log level allows entries with severity Logger::DEBUG to be written to at least one broadcast. False otherwise.

Source: show | on GitHub

def debug? @broadcasts.any? { |logger| logger.debug? } end

error(...)Link

Source: show | on GitHub

def error(...) dispatch { |logger| logger.error(...) } end

error!()Link

Sets the log level to Logger::ERROR for the whole broadcast.

Source: show | on GitHub

def error! dispatch { |logger| logger.error! } end

error?()Link

True if the log level allows entries with severity Logger::ERROR to be written to at least one broadcast. False otherwise.

Source: show | on GitHub

def error? @broadcasts.any? { |logger| logger.error? } end

fatal(...)Link

Source: show | on GitHub

def fatal(...) dispatch { |logger| logger.fatal(...) } end

fatal!()Link

Sets the log level to Logger::FATAL for the whole broadcast.

Source: show | on GitHub

def fatal! dispatch { |logger| logger.fatal! } end

fatal?()Link

True if the log level allows entries with severity Logger::FATAL to be written to at least one broadcast. False otherwise.

Source: show | on GitHub

def fatal? @broadcasts.any? { |logger| logger.fatal? } end

formatter=(formatter)Link

Source: show | on GitHub

def formatter=(formatter) dispatch { |logger| logger.formatter = formatter }

@formatter = formatter end

info(...)Link

Source: show | on GitHub

def info(...) dispatch { |logger| logger.info(...) } end

info!()Link

Sets the log level to Logger::INFO for the whole broadcast.

Source: show | on GitHub

def info! dispatch { |logger| logger.info! } end

info?()Link

True if the log level allows entries with severity Logger::INFO to be written to at least one broadcast. False otherwise.

Source: show | on GitHub

def info? @broadcasts.any? { |logger| logger.info? } end

initialize_copy(other)Link

Source: show | on GitHub

def initialize_copy(other) @broadcasts = [] @progname = other.progname.dup @formatter = other.formatter.dup

broadcast_to(*other.broadcasts.map(&:dup)) end

level=(level)Link

Source: show | on GitHub

def level=(level) dispatch { |logger| logger.level = level } end

local_level=(level)Link

Source: show | on GitHub

def local_level=(level) dispatch do |logger| logger.local_level = level if logger.respond_to?(:local_level=) end end

sev_threshold=(level)Link

stop_broadcasting_to(logger)Link

Remove a logger from the broadcast. When a logger is removed, messages sent to the broadcast will no longer be written to its sink.

sink = Logger.new(STDOUT)
broadcast_logger = ActiveSupport::BroadcastLogger.new

broadcast_logger.stop_broadcasting_to(sink)

Source: show | on GitHub

def stop_broadcasting_to(logger) @broadcasts.delete(logger) end

unknown(...)Link

Source: show | on GitHub

def unknown(...) dispatch { |logger| logger.unknown(...) } end

warn(...)Link

Source: show | on GitHub

def warn(...) dispatch { |logger| logger.warn(...) } end

warn!()Link

Sets the log level to Logger::WARN for the whole broadcast.

Source: show | on GitHub

def warn! dispatch { |logger| logger.warn! } end

warn?()Link

True if the log level allows entries with severity Logger::WARN to be written to at least one broadcast. False otherwise.

Source: show | on GitHub

def warn? @broadcasts.any? { |logger| logger.warn? } end