¿Cómo registrar algo en Rails en un archivo de registro independiente?

Update

Hice una gema basada en la solución de abajo, llamada multi_logger. Simplemente haga esto en el inicializador:

MultiLogger.add_logger('post')

Y llamar

Rails.logger.post.error('hi')
# or call logger.post.error('hi') if it is accessible.

Y has terminado.

Si desea codificarlo usted mismo, vea a continuación:

Una solución más completa sería colocar lo siguiente en su directorio lib/ o config/initializers/.

El beneficio es que puede configurar formatter para prefijar marcas de tiempo o severidad a los registros automáticamente. Esto es accesible desde cualquier lugar en los carriles, y se ve más limpio mediante el uso del patrón de singleton.

# Custom Post logger
require 'singleton'
class PostLogger < Logger
  include Singleton

  def initialize
    super(Rails.root.join('log/post_error.log'))
    self.formatter = formatter()
    self
  end

  # Optional, but good for prefixing timestamps automatically
  def formatter
    Proc.new{|severity, time, progname, msg|
      formatted_severity = sprintf("%-5s",severity.to_s)
      formatted_time = time.strftime("%Y-%m-%d %H:%M:%S")
      "[#{formatted_severity} #{formatted_time} #{$$}] #{msg.to_s.strip}\n"
    }
  end

  class << self
    delegate :error, :debug, :fatal, :info, :warn, :add, :log, :to => :instance
  end
end

PostLogger.error('hi')
# [ERROR 2012-09-12 10:40:15] hi

Una opción decente que funciona para mí es simplemente agregar una clase bastante simple a su carpeta app/models como app/models/my_log.rb

class MyLog
  def self.debug(message=nil)
    @my_log ||= Logger.new("#{Rails.root}/log/my.log")
    @my_log.debug(message) unless message.nil?
  end
end

Luego, en su controlador, o realmente casi en cualquier lugar donde pueda hacer referencia a la clase de un modelo desde su aplicación rails, es decir, en cualquier lugar que pueda hacer Post.create(:title => "Hello world", :contents => "Lorum ipsum"); o algo similar, puede iniciar sesión en su archivo personalizado de esta manera

MyLog.debug "Hello world"

Aquí está mi registrador personalizado:

class DebugLog
  def self.debug(message=nil)
    return unless Rails.env.development? and message.present?
    @logger ||= Logger.new(File.join(Rails.root, 'log', 'debug.log'))
    @logger.debug(message) 
  end
end

Defina una clase logger en (digamos) app/models/special_log.rb:

class SpecialLog
  LogFile = Rails.root.join('log', 'special.log')
  class << self
    cattr_accessor :logger
    delegate :debug, :info, :warn, :error, :fatal, :to => :logger
  end
end

Inicializa el logger en (digamos) config/initializers/special_log.rb:

SpecialLog.logger = Logger.new(SpecialLog::LogFile)
SpecialLog.logger.level = 'debug' # could be debug, info, warn, error or fatal

En cualquier lugar de su aplicación, puede iniciar sesión con:

SpecialLog.debug("something went wrong")
# or
SpecialLog.info("life is good")

class Article < ActiveRecord::Base  

      LOGFILE = File.join(RAILS_ROOT, '/log/', "article_#{RAILS_ENV}.log")  

      def validate  
        log "was validated!"  
      end   

      def log(*args)  
       args.size == 1 ? (message = args; severity = :info) : (severity, message = args)  
       Article.logger severity, "Article##{self.id}: #{message}"  
     end  

     def self.logger(severity = nil, message = nil)  
       @article_logger ||= Article.open_log  
       if !severity.nil? && !message.nil? && @article_logger.respond_to?(severity)  
         @article_logger.send severity, "[#{Time.now.to_s(:db)}] [#{severity.to_s.capitalize}] #{message}\n"  
       end  
       message or @article_logger  
     end  

     def self.open_log  
       ActiveSupport::BufferedLogger.new(LOGFILE)  
     end  

   end  

Sugeriría usar Log4r gem para el registro personalizado. Citando la descripción de su página:

Log4r es una biblioteca de registro completa y flexible escrita en Ruby para su uso en programas Ruby. Cuenta con un sistema de registro jerárquico de cualquier número de niveles, nombres de nivel personalizados, herencia del registrador, múltiples destinos de salida por evento de registro, seguimiento de ejecución, formato personalizado, seguridad del hilo, XML y configuración YAML, y más.

class Post < ActiveRecord::Base
    def initialize(attributes)
        super(attributes)
        @logger = Logger.new("#{Rails.root}/log/post.log")
    end

    def logger
        @logger
    end

    def some_method
        logger.info('Test 1')
    end
end

ps = Post.new
ps.some_method
ps.logger.info('Test 2')
Post.new.logger.info('Test 3')

El marco de registro, con su nombre engañosamente simple, tiene la sofisticación que usted anhela!

Siga las instrucciones muy cortas de logging-rails para comenzar a filtrar el ruido, obtener alertas y elegir la salida de una manera precisa y de alto nivel.

Date palmaditas en la espalda cuando hayas terminado. Registro de rodadura, todos los días. Vale la pena solo por eso.