如何在每个操作的基础上禁用Ruby on Rails中的日志记录？

Question

我有一个Rails应用程序，它有一个经常被调用的动作，在我开发时很不方便，因为它导致了很多额外的日志输出我不关心。如何才能让rails不记录任何内容（控制器，动作，参数，计算时间等）？我也想在RAILS_ENV上对其进行条件化，因此生产中的日志已经完成。

谢谢！

Answer 1

您可以使Rails记录器对象静音：

def action
  Rails.logger.silence do
    # Things within this block will not be logged...
  end
end

Answer 2

以下适用于至少Rails 3.1.0：

制作可以沉默的自定义记录器：

# selective_logger.rb
class SelectiveLogger < Rails::Rack::Logger

  def initialize  app, opts = {}
    @app = app
    @opts = opts
    @opts[:silenced] ||= []
  end

  def call  env
    if @opts[:silenced].include?(env['PATH_INFO']) || @opts[:silenced].any? {|silencer| silencer.is_a?( Regexp) && silencer.match( env['PATH_INFO']) }
      Rails.logger.silence do
        @app.call env
      end
    else
      super env
    end                        
  end

end

告诉Rails使用它：

# application.rb
config.middleware.swap Rails::Rack::Logger, SelectiveLogger, :silenced => ["/remote/every_minute", %r"^/assets/"]

上面的示例显示了静默资产服务请求，这在开发环境中意味着需要更少（有时没有）回滚来查看实际请求。

Answer 3

使用lograge gem。

的Gemfile：

gem 'lograge'

配置/ application.rb中：

config.lograge.enabled = true
config.lograge.ignore_actions = ['StatusController#nginx', ...]

Answer 4

答案结果比我预期的要困难得多，因为rails确实没有提供钩子来做到这一点。相反，你需要包装一些ActionController :: Base的内容。在我的控制器的公共基类中，我这样做

def silent?(action)
  false
end

# this knows more than I'd like about the internals of process, but
# the other options require knowing even more.  It would have been
# nice to be able to use logger.silence, but there isn't a good
# method to hook that around, due to the way benchmarking logs.

def log_processing_with_silence_logs
  if logger && silent?(action_name) then
    @old_logger_level, logger.level = logger.level, Logger::ERROR
  end

  log_processing_without_silence_logs
end

def process_with_silence_logs(request, response, method = :perform_action, *arguments)
  ret = process_without_silence_logs(request, response, method, *arguments)
  if logger && silent?(action_name) then
    logger.level = @old_logger_level
  end
  ret
end

alias_method_chain :log_processing, :silence_logs
alias_method_chain :process, :silence_logs

然后，在控制器中使用我想要禁止登录的方法：

def silent?(action)
  RAILS_ENV == "development" && ['my_noisy_action'].include?(action)
end

Answer 5

您可以将gem添加到Gemfile silencer。

gem 'silencer', '>= 1.0.1'

在你的config / initializers / silencer.rb中：

  require 'silencer/logger'

  Rails.application.configure do
    config.middleware.swap Rails::Rack::Logger, Silencer::Logger, silence: ['/api/notifications']
  end

Answer 6

以下适用于Rails 2.3.14：

制作可以沉默的自定义记录器：

#selective_logger.rb  
require "active_support"

class SelectiveLogger < ActiveSupport::BufferedLogger

  attr_accessor :silent

  def initialize path_to_log_file
    super path_to_log_file
  end

  def add severity, message = nil, progname = nil, &block
    super unless @silent
  end
end

告诉Rails使用它：

#environment.rb
  config.logger = SelectiveLogger.new  config.log_path

在每个操作开始时拦截日志输出，并根据操作是否应该是静默来（重新）配置记录器：

#application_controller.rb
  # This method is invoked in order to log the lines that begin "Processing..."
  # for each new request.
  def log_processing
    logger.silent = %w"ping time_zone_table".include? params[:action]
    super
  end

Answer 7

使用Rails 5，可以在几个类中记录更复杂的请求处理。首先我们需要在call_app类中覆盖Logger，让我们称这个文件为lib/logger.rb：

# original class:
# https://github.com/rails/rails/blob/master/railties/lib/rails/rack/logger.rb
require 'rails/rack/logger'
module Rails
  module Rack
    class Logger < ActiveSupport::LogSubscriber

      def call_app(request, env) # :doc:
        unless Rails.configuration.logger_exclude.call(request.filtered_path)
          instrumenter = ActiveSupport::Notifications.instrumenter
          instrumenter.start "request.action_dispatch", request: request
          logger.info { started_request_message(request) }
        end
        status, headers, body = @app.call(env)
        body = ::Rack::BodyProxy.new(body) { finish(request) }
        [status, headers, body]
      rescue Exception
        finish(request)
        raise
      ensure
        ActiveSupport::LogSubscriber.flush_all!
      end

    end
  end
end

然后跟随lib/silent_log_subscriber.rb：

require 'active_support/log_subscriber'
require 'action_view/log_subscriber'
require 'action_controller/log_subscriber'
# original class:
# https://github.com/rails/rails/blob/master/actionpack/lib/action_controller/log_subscriber.rb
class SilentLogSubscriber < ActiveSupport::LogSubscriber

  def start_processing(event)
    return unless logger.info?

    payload = event.payload
    return if Rails.configuration.logger_exclude.call(payload[:path])

    params  = payload[:params].except(*ActionController::LogSubscriber::INTERNAL_PARAMS)
    format  = payload[:format]
    format  = format.to_s.upcase if format.is_a?(Symbol)
    info "Processing by #{payload[:controller]}##{payload[:action]} as #{format}"
    info "  Parameters: #{params.inspect}" unless params.empty?
  end

  def process_action(event)
    return if Rails.configuration.logger_exclude.call(event.payload[:path])

    info do
      payload = event.payload
      additions = ActionController::Base.log_process_action(payload)
      status = payload[:status]

      if status.nil? && payload[:exception].present?
        exception_class_name = payload[:exception].first
        status = ActionDispatch::ExceptionWrapper.status_code_for_exception(exception_class_name)
      end

      additions << "Allocations: #{event.allocations}" if event.respond_to? :allocations

      message = +"Completed #{status} #{Rack::Utils::HTTP_STATUS_CODES[status]} in #{event.duration.round}ms"
      message << " (#{additions.join(" | ")})" unless additions.empty?
      message << "\n\n" if defined?(Rails.env) && Rails.env.development?

      message
    end
  end

  def self.setup
    # unsubscribe default processors
    ActiveSupport::LogSubscriber.log_subscribers.each do |subscriber|
      case subscriber
      when ActionView::LogSubscriber
        self.unsubscribe(:action_view, subscriber)
      when ActionController::LogSubscriber
        self.unsubscribe(:action_controller, subscriber)
      end
    end
  end

  def self.unsubscribe(component, subscriber)
    events = subscriber.public_methods(false).reject { |method| method.to_s == 'call' }
    events.each do |event|
      ActiveSupport::Notifications.notifier.listeners_for("#{event}.#{component}").each do |listener|
        if listener.instance_variable_get('@delegate') == subscriber
          ActiveSupport::Notifications.unsubscribe listener
        end
      end
    end
  end
end
# subscribe this class
SilentLogSubscriber.attach_to :action_controller
SilentLogSubscriber.setup

确保加载修改后的模块，例如加载config/application.rb后在rails中：

require_relative '../lib/logger'
require_relative '../lib/silent_log_subscriber'

最后配置排除路径：

Rails.application.configure do
  config.logger_exclude = ->(path) { path == "/health" }
end

当我们修改Rails的核心代码时，最好检查您正在使用的Rails版本中的原始类。

如果这看起来有太多修改，你可以简单地使用lograge gem，它几乎与其他一些修改相同。虽然Rack::Loggger code has changed since Rails 3，所以你可能会失去一些功能。