记录器中的tee功能。
答案 0 :(得分：113)
您可以编写一个将写入多个IO对象的伪IO类。类似的东西：
class MultiIO
def initialize(*targets)
@targets = targets
end
def write(*args)
@targets.each {|t| t.write(*args)}
end
def close
@targets.each(&:close)
end
end
然后将其设置为您的日志文件：
log_file = File.open("log/debug.log", "a")
Logger.new MultiIO.new(STDOUT, log_file)
每次Logger调用puts对象上的MultiIO时，它都会同时写入STDOUT和您的日志文件。
编辑：我继续前进并找出了界面的其余部分。日志设备必须回复write和close（不是puts）。只要MultiIO响应那些并将它们代理到真实的IO对象，这应该可行。
答案 1 :(得分：46)
@David的解决方案非常好。我根据他的代码为多个目标创建了一个通用委托者类。
require 'logger'
class MultiDelegator
def initialize(*targets)
@targets = targets
end
def self.delegate(*methods)
methods.each do |m|
define_method(m) do |*args|
@targets.map { |t| t.send(m, *args) }
end
end
self
end
class <<self
alias to new
end
end
log_file = File.open("debug.log", "a")
log = Logger.new MultiDelegator.delegate(:write, :close).to(STDOUT, log_file)
答案 2 :(得分：31)
如果您在Rails 3或4中，this blog post指出Rails 4 has this functionality built in。所以你可以这样做：
# config/environment/production.rb
file_logger = Logger.new(Rails.root.join("log/alternative-output.log"))
config.logger.extend(ActiveSupport::Logger.broadcast(file_logger))
或者，如果您使用的是Rails 3，则可以向后移植它：
# config/initializers/alternative_output_log.rb
# backported from rails4
module ActiveSupport
class Logger < ::Logger
# Broadcasts logs to multiple loggers. Returns a module to be
# `extended`'ed into other logger instances.
def self.broadcast(logger)
Module.new do
define_method(:add) do |*args, &block|
logger.add(*args, &block)
super(*args, &block)
end
define_method(:<<) do |x|
logger << x
super(x)
end
define_method(:close) do
logger.close
super()
end
define_method(:progname=) do |name|
logger.progname = name
super(name)
end
define_method(:formatter=) do |formatter|
logger.formatter = formatter
super(formatter)
end
define_method(:level=) do |level|
logger.level = level
super(level)
end
end
end
end
end
file_logger = Logger.new(Rails.root.join("log/alternative-output.log"))
Rails.logger.extend(ActiveSupport::Logger.broadcast(file_logger))
答案 3 :(得分：11)
虽然我非常喜欢其他建议，但我发现我遇到了同样的问题，但希望能够为STDERR和文件设置不同的日志记录级别。
我最终得到了一个路由策略，它在记录器级而不是IO级复用，这样每个记录器就可以在独立的日志级别运行：
class MultiLogger
def initialize(*targets)
@targets = targets
end
%w(log debug info warn error fatal unknown).each do |m|
define_method(m) do |*args|
@targets.map { |t| t.send(m, *args) }
end
end
end
stderr_log = Logger.new(STDERR)
file_log = Logger.new(File.open('logger.log', 'a'))
stderr_log.level = Logger::INFO
file_log.level = Logger::DEBUG
log = MultiLogger.new(stderr_log, file_log)
答案 4 :(得分：10)
对于那些喜欢它的人来说简单：
log = Logger.new("| tee test.log") # note the pipe ( '|' )
log.info "hi" # will log to both STDOUT and test.log
或者在Logger格式化程序中打印消息：
log = Logger.new("test.log")
log.formatter = proc do |severity, datetime, progname, msg|
puts msg
msg
end
log.info "hi" # will log to both STDOUT and test.log
我实际上使用这种技术打印到日志文件，云记录器服务（logentries）以及它的开发环境 - 也打印到STDOUT。
答案 5 :(得分：10)
您还可以将多个设备日志记录功能直接添加到Logger中：
require 'logger'
class Logger
# Creates or opens a secondary log file.
def attach(name)
@logdev.attach(name)
end
# Closes a secondary log file.
def detach(name)
@logdev.detach(name)
end
class LogDevice # :nodoc:
attr_reader :devs
def attach(log)
@devs ||= {}
@devs[log] = open_logfile(log)
end
def detach(log)
@devs ||= {}
@devs[log].close
@devs.delete(log)
end
alias_method :old_write, :write
def write(message)
old_write(message)
@devs ||= {}
@devs.each do |log, dev|
dev.write(message)
end
end
end
end
例如：
logger = Logger.new(STDOUT)
logger.warn('This message goes to stdout')
logger.attach('logfile.txt')
logger.warn('This message goes both to stdout and logfile.txt')
logger.detach('logfile.txt')
logger.warn('This message goes just to stdout')
答案 6 :(得分：9)
这是另一个实现，受 @ jonas054 的回答启发。
这使用类似于Delegator的模式。这样您就不必列出要委派的所有方法，因为它将委托在任何目标对象中定义的所有方法：
class Tee < DelegateToAllClass(IO)
end
$stdout = Tee.new(STDOUT, File.open("#{__FILE__}.log", "a"))
你也应该可以在Logger中使用它。
delegate_to_all.rb可从此处获取：https://gist.github.com/TylerRick/4990898
答案 7 :(得分：3)
@ jonas054上面的答案很棒，但是每个新代表都会污染MultiDelegator类。如果多次使用MultiDelegator，它将继续向类添加方法，这是不可取的。 （例如参见下文）
这是相同的实现，但使用匿名类，因此方法不会污染委托者类。
class BetterMultiDelegator
def self.delegate(*methods)
Class.new do
def initialize(*targets)
@targets = targets
end
methods.each do |m|
define_method(m) do |*args|
@targets.map { |t| t.send(m, *args) }
end
end
class <<self
alias to new
end
end # new class
end # delegate
end
以下是原始实现方法污染的一个示例，与修改后的实现形成对比：
tee = MultiDelegator.delegate(:write).to(STDOUT)
tee.respond_to? :write
# => true
tee.respond_to? :size
# => false
一切都很好。 tee有一个write方法，但没有预期的size方法。现在，考虑我们何时创建另一个委托：
tee2 = MultiDelegator.delegate(:size).to("bar")
tee2.respond_to? :size
# => true
tee2.respond_to? :write
# => true !!!!! Bad
tee.respond_to? :size
# => true !!!!! Bad
哦不，tee2按预期响应size，但由于第一个代表，它也会响应write。由于方法污染，即使tee现在也会响应size。
将此与匿名类解决方案进行对比，一切都符合预期：
see = BetterMultiDelegator.delegate(:write).to(STDOUT)
see.respond_to? :write
# => true
see.respond_to? :size
# => false
see2 = BetterMultiDelegator.delegate(:size).to("bar")
see2.respond_to? :size
# => true
see2.respond_to? :write
# => false
see.respond_to? :size
# => false
答案 8 :(得分：2)
您是否仅限于标准记录器？
如果不是，您可以使用log4r：
require 'log4r'
LOGGER = Log4r::Logger.new('mylog')
LOGGER.outputters << Log4r::StdoutOutputter.new('stdout')
LOGGER.outputters << Log4r::FileOutputter.new('file', :filename => 'test.log') #attach to existing log-file
LOGGER.info('aa') #Writs on STDOUT and sends to file
一个优点：您还可以为stdout和file定义不同的日志级别。
答案 9 :(得分：2)
快速而肮脏（参考：https://coderwall.com/p/y_b3ra/log-to-stdout-and-a-file-at-the-same-time）
require 'logger'
ll=Logger.new('| tee script.log')
ll.info('test')
答案 10 :(得分：1)
我采用了“将所有方法委托给子元素”的相同想法，其他人已经探索过了，但我为每个方法返回了方法最后一次调用的返回值。
如果我没有，那就会导致logger-colors因为期待Integer并且地图返回Array而崩溃。
class MultiIO
def self.delegate_all
IO.methods.each do |m|
define_method(m) do |*args|
ret = nil
@targets.each { |t| ret = t.send(m, *args) }
ret
end
end
end
def initialize(*targets)
@targets = targets
MultiIO.delegate_all
end
end
这会将每个方法重新发布到所有目标，并仅返回上次调用的返回值。
另外，如果你想要颜色，STDOUT或STDERR必须放在最后，因为只有两个颜色应该输出。但是，它还会为您的文件输出颜色。
logger = Logger.new MultiIO.new(File.open("log/test.log", 'w'), STDOUT)
logger.error "Roses are red"
logger.unknown "Violets are blue"
答案 11 :(得分：1)
我写了一些RubyGem，允许你做以下几件事：
# Pipe calls to an instance of Ruby's logger class to $stdout
require 'teerb'
log_file = File.open("debug.log", "a")
logger = Logger.new(TeeRb::IODelegate.new(log_file, STDOUT))
logger.warn "warn"
$stderr.puts "stderr hello"
puts "stdout hello"
您可以在github上找到代码：teerb
答案 12 :(得分：0)
还有一种方法。 如果您在其他日志文件中使用标记日志记录和需要标记，则可以这样做
# backported from rails4
# config/initializers/active_support_logger.rb
module ActiveSupport
class Logger < ::Logger
# Broadcasts logs to multiple loggers. Returns a module to be
# `extended`'ed into other logger instances.
def self.broadcast(logger)
Module.new do
define_method(:add) do |*args, &block|
logger.add(*args, &block)
super(*args, &block)
end
define_method(:<<) do |x|
logger << x
super(x)
end
define_method(:close) do
logger.close
super()
end
define_method(:progname=) do |name|
logger.progname = name
super(name)
end
define_method(:formatter=) do |formatter|
logger.formatter = formatter
super(formatter)
end
define_method(:level=) do |level|
logger.level = level
super(level)
end
end # Module.new
end # broadcast
def initialize(*args)
super
@formatter = SimpleFormatter.new
end
# Simple formatter which only displays the message.
class SimpleFormatter < ::Logger::Formatter
# This method is invoked when a log event occurs
def call(severity, time, progname, msg)
element = caller[4] ? caller[4].split("/").last : "UNDEFINED"
"#{Thread.current[:activesupport_tagged_logging_tags]||nil } # {time.to_s(:db)} #{severity} #{element} -- #{String === msg ? msg : msg.inspect}\n"
end
end
end # class Logger
end # module ActiveSupport
custom_logger = ActiveSupport::Logger.new(Rails.root.join("log/alternative_#{Rails.env}.log"))
Rails.logger.extend(ActiveSupport::Logger.broadcast(custom_logger))
在此之后，您将在替代记录器中获得uuid标签
["fbfea87d1d8cc101a4ff9d12461ae810"] 2015-03-12 16:54:04 INFO logger.rb:28:in `call_app' --
["fbfea87d1d8cc101a4ff9d12461ae810"] 2015-03-12 16:54:04 INFO logger.rb:31:in `call_app' -- Started POST "/psp/entrypoint" for 192.168.56.1 at 2015-03-12 16:54:04 +0700
希望能有所帮助。
答案 13 :(得分：0)
还有一个选项; - ）
require 'logger'
class MultiDelegator
def initialize(*targets)
@targets = targets
end
def method_missing(method_sym, *arguments, &block)
@targets.each do |target|
target.send(method_sym, *arguments, &block) if target.respond_to?(method_sym)
end
end
end
log = MultiDelegator.new(Logger.new(STDOUT), Logger.new(File.open("debug.log", "a")))
log.info('Hello ...')
答案 14 :(得分：0)
我喜欢 MultiIO 方法。它适用于Ruby Logger 。如果您使用纯IO ，它将停止工作，因为它缺少一些IO对象应该具有的方法。之前提到过 Pipes ：How can I have ruby logger log output to stdout as well as file?。这对我来说最有效。
def watch(cmd)
output = StringIO.new
IO.popen(cmd) do |fd|
until fd.eof?
bit = fd.getc
output << bit
$stdout.putc bit
end
end
output.rewind
[output.read, $?.success?]
ensure
output.close
end
result, success = watch('./my/shell_command as a String')
注意我知道这并没有直接回答这个问题，但它有很强的相关性。每当我搜索到多个IO的输出时，我都会遇到这个帖子。所以，我希望你也觉得这很有用。
答案 15 :(得分：0)
这是@rado解决方案的简化。
def delegator(*methods)
Class.new do
def initialize(*targets)
@targets = targets
end
methods.each do |m|
define_method(m) do |*args|
@targets.map { |t| t.send(m, *args) }
end
end
class << self
alias for new
end
end # new class
end # delegate
它具有与他相同的所有优点，而无需外部类包装器。这是一个有用的实用程序，可放在单独的ruby文件中。
将其用作单行生成类似这样的委托实例：
IO_delegator_instance = delegator(:write, :read).for(STDOUT, STDERR)
IO_delegator_instance.write("blah")
或将其用作工厂：
logger_delegator_class = delegator(:log, :warn, :error)
secret_delegator = logger_delegator_class(main_logger, secret_logger)
secret_delegator.warn("secret")
general_delegator = logger_delegator_class(main_logger, debug_logger, other_logger)
general_delegator.log("message")
答案 16 :(得分：0)
答案 17 :(得分：0)
如果您可以使用ActiveSupport，那么我强烈建议您检出ActiveSupport::Logger.broadcast，这是向记录器中添加其他日志目标的绝佳且简洁的方法。
实际上，如果您使用的是Rails 4+（自this commit起），则无需执行任何操作即可获得所需的行为-至少在以下情况下使用rails console。每当您使用rails console时，Rails automatically 都会扩展Rails.logger使其输出到其通常的文件目标位置（例如，log/production.log）， STDERR：
console do |app|
…
unless ActiveSupport::Logger.logger_outputs_to?(Rails.logger, STDERR, STDOUT)
console = ActiveSupport::Logger.new(STDERR)
Rails.logger.extend ActiveSupport::Logger.broadcast console
end
ActiveRecord::Base.verbose_query_logs = false
end
由于某些未知和不幸的原因，此方法为undocumented，但您可以参考source code或博客文章以了解其工作原理或查看示例。
require "active_support/logger"
console_logger = ActiveSupport::Logger.new(STDOUT)
file_logger = ActiveSupport::Logger.new("my_log.log")
combined_logger = console_logger.extend(ActiveSupport::Logger.broadcast(file_logger))
combined_logger.debug "Debug level"
…
答案 18 :(得分：0)
最近我也有这种需要，所以我实现了一个实现此目的的库。我刚刚发现了这个StackOverflow问题，所以我将它发布给需要它的任何人：https://github.com/agis/multi_io。
与这里提到的其他解决方案相比，它努力成为自己的IO对象，因此可以用作其他常规IO对象（文件，套接字等）的替代品。 / p>
也就是说，我尚未实现所有标准的IO方法，但是遵循IO语义的方法（例如，#write返回写入所有基础底层的字节数之和IO目标）。
答案 19 :(得分：0)
您可以继承 Logger 并覆盖 write 方法：
class LoggerWithStdout < Logger
def initialize(*)
super
def @logdev.write(msg)
super
puts msg
end
end
end
logger = LoggerWithStdout.new('path/to/log_file.log')
答案 20 :(得分：-3)
我认为您的STDOUT用于关键运行时信息和引发的错误。
所以我用
$log = Logger.new('process.log', 'daily')
记录调试和常规日志记录，然后写了几个
puts "doing stuff..."
我需要查看我的脚本运行的STDOUT信息！
Bah，只是我的10美分： - ）