sintax - ruby on rails haml

Ruby: comparte la instancia del registrador entre el módulo/clases

Question

Trabajando en un pequeño script de Ruby que sale a la web y rastrea varios servicios. Tengo un módulo con varias clases dentro:

module Crawler
  class Runner
  class Options
  class Engine
end

Quiero compartir un registrador entre todos aquellos de esas clases. Normalmente solo pondría esto en una constante en el módulo y lo referenciaría así:

Crawler::LOGGER.info("Hello, world")

El problema es que no puedo crear mi instancia de registro hasta que sepa a dónde va la salida. Inicia el rastreador a través de la línea de comandos y en ese punto puede indicarle que desea ejecutar en desarrollo (el resultado del registro va a STDOUT) o producción (el resultado del registro va a un archivo, crawler.log):

crawler --environment=production

Tengo una clase Options que analiza las opciones pasadas a través de la línea de comando. Solo en ese punto sé cómo crear una instancia del registrador con la ubicación de salida correcta.

Entonces, mi pregunta es: ¿cómo / dónde colocar mi objeto logger para que todas mis clases tengan acceso a él?

Podría pasar mi instancia de registrador a cada llamada new() para cada instancia de clase que cree, pero sé que tiene que haber una forma mejor, Ruby para hacerlo. Me estoy imaginando una variable de clase extraña en el módulo que compartió con la class << self o alguna otra magia. :)

Un poco más de detalle: Runner comienza todo pasando las opciones de la línea de comando a la clase Options y recupera un objeto con un par de variables de instancia:

module Crawler
  class Runner
    def initialize(argv)
      @options = Options.new(argv)
      # feels like logger initialization should go here
      # @options.log_output => STDOUT or string (log file name)
      # @options.log_level => Logger::DEBUG or Logger::INFO
      @engine = Engine.new()
    end
    def run
      @engine.go
    end
  end
end

runner = Runner.new(ARGV)
runner.run

Necesito el código en Engine para poder acceder al objeto logger (junto con un par de clases más que se inicializan dentro de Engine ). ¡Ayuda!

Todo esto podría evitarse si pudiera cambiar dinámicamente la ubicación de salida de un registrador ya instanciado (similar a cómo cambia el nivel de registro). Lo instanciaría en STDOUT y luego cambiaría a un archivo si estoy en producción. Vi una sugerencia en algún lugar sobre el cambio de la variable global $ stdout de Ruby, que redirigiría la salida a otro lugar que STDOUT, pero esto parece bastante hacky.

¡Gracias!

Answer 1

¿Qué hay de envolver el registrador en un singleton luego podría acceder a él utilizando MyLogger.instance

Answer 2

Aunque es una vieja pregunta, pensé que valía la pena documentar un enfoque diferente.

Basándome en la respuesta de Jacob, sugeriría un módulo que puede agregar cuando sea necesario.

Mi versión es esta:

# saved into lib/my_log.rb

require ''logger''

module MyLog

  def self.logger
    if @logger.nil?
      @logger = Logger.new( STDERR)
      @logger.datetime_format = "%H:%M:%S "
    end
    @logger
  end

  def self.logger=( logger)
    @logger = logger
  end

  levels = %w(debug info warn error fatal)
  levels.each do |level|
    define_method( "#{level.to_sym}") do |msg|
      self.logger.send( level, msg)
    end
  end
end

include MyLog

Tengo esto guardado en una biblioteca de prácticos módulos, y lo usaría así:

#! /usr/bin/env ruby
#

require_relative ''../lib/my_log.rb''

MyLog.debug "hi"
# => D, [19:19:32 #31112] DEBUG -- : hi

MyLog.warn "ho"
# => W, [19:20:14 #31112]  WARN -- : ho

MyLog.logger.level = Logger::INFO

MyLog.logger = Logger.new( ''logfile.log'')

MyLog.debug ''huh''
# => no output, sent to logfile.log instead

Me parece mucho más fácil y más versátil que otras opciones que he visto hasta ahora, así que espero que te ayude con las tuyas.

Answer 3

Basado en tu comentario

Todo esto podría evitarse si pudiera cambiar dinámicamente la ubicación de salida de un registrador ya instanciado (similar a cómo cambia el nivel de registro).

Si no está restringido al registrador predeterminado, puede usar otro log-gem.

Como un ejemplo con log4r :

require ''log4r'' 

module Crawler
  LOGGER = Log4r::Logger.new(''mylog'')
  class Runner
    def initialize
        LOGGER.info(''Created instance for %s'' % self.class)
    end
  end
end

ARGV << ''test''  #testcode

#...
case ARGV.first
  when ''test''
    Crawler::LOGGER.outputters = Log4r::StdoutOutputter.new(''stdout'')
  when ''prod''
    Crawler::LOGGER.outputters = Log4r::FileOutputter.new(''file'', :filename => ''test.log'') #append to existing log
end
#...
Crawler::Runner.new

En el modo prod, los datos de registro se almacenan en un archivo (adjunto al archivo existente, pero hay opciones para crear nuevos archivos de registro o implementar archivos de registro continuos).

El resultado:

 INFO main: Created instance for Crawler::Runner

Si usa el mecanismo de herencia de log4r (a), puede definir un registrador para cada clase (o en mi ejemplo siguiente para cada instancia) y compartir el outputter.

El ejemplo:

require ''log4r'' 

module Crawler
  LOGGER = Log4r::Logger.new(''mylog'')
  class Runner
    def initialize(id)
      @log = Log4r::Logger.new(''%s::%s %s'' % [LOGGER.fullname,self.class,id])
      @log.info(''Created instance for %s with id %s'' % [self.class, id])
    end
  end
end

ARGV << ''test''  #testcode

#...
case ARGV.first
  when ''test''
    Crawler::LOGGER.outputters = Log4r::StdoutOutputter.new(''stdout'')
  when ''prod''
    Crawler::LOGGER.outputters = Log4r::FileOutputter.new(''file'', :filename => ''test.log'') #append to existing log
end
#...
Crawler::Runner.new(1)
Crawler::Runner.new(2)

El resultado:

 INFO Runner 1: Created instance for Crawler::Runner with id 1
 INFO Runner 2: Created instance for Crawler::Runner with id 2

(a) Un nombre de registrador como A::B tiene el nombre B y es un hijo del registrador con el nombre A Hasta donde yo sé, esto no es herencia de objetos.

Una ventaja de este enfoque: si desea utilizar un único registrador para cada clase, solo necesita cambiar el nombre del registrador.

Answer 4

Como lo señala Zenagray, la extracción de los métodos de clase se dejó fuera de la respuesta de Jacob. Una pequeña adición resuelve eso:

require ''logger''

module Logging
  class << self
    def logger
      @logger ||= Logger.new($stdout)
    end

    def logger=(logger)
      @logger = logger
    end
  end

  # Addition
  def self.included(base)
    class << base
      def logger
        Logging.logger
      end
    end
  end

  def logger
    Logging.logger
  end
end

El uso previsto es a través de "incluir":

class Dog
  include Logging

  def self.bark
    logger.debug "chirp"
    puts "#{logger.__id__}"
  end

  def bark
    logger.debug "grrr"
    puts "#{logger.__id__}"
  end
end

class Cat
  include Logging

  def self.bark
    logger.debug "chirp"
    puts "#{logger.__id__}"
  end

  def bark
    logger.debug "grrr"
    puts "#{logger.__id__}"
  end
end

Dog.new.bark
Dog.bark
Cat.new.bark
Cat.bark

Produce:

D, [2014-05-06T22:27:33.991454 #2735] DEBUG -- : grrr
70319381806200
D, [2014-05-06T22:27:33.991531 #2735] DEBUG -- : chirp
70319381806200
D, [2014-05-06T22:27:33.991562 #2735] DEBUG -- : grrr
70319381806200
D, [2014-05-06T22:27:33.991588 #2735] DEBUG -- : chirp
70319381806200

Tenga en cuenta que la identificación del registrador es la misma en los cuatro casos. Si desea una instancia diferente para cada clase, no use Logging.logger , más bien use self.class.logger :

require ''logger''

module Logging
  def self.included(base)
    class << base
      def logger
        @logger ||= Logger.new($stdout)
      end

      def logger=(logger)
        @logger = logger
      end
    end
  end

  def logger
    self.class.logger
  end
end

El mismo programa ahora produce:

D, [2014-05-06T22:36:07.709645 #2822] DEBUG -- : grrr
70350390296120
D, [2014-05-06T22:36:07.709723 #2822] DEBUG -- : chirp
70350390296120
D, [2014-05-06T22:36:07.709763 #2822] DEBUG -- : grrr
70350390295100
D, [2014-05-06T22:36:07.709791 #2822] DEBUG -- : chirp
70350390295100

Tenga en cuenta que los dos primeros identificadores son los mismos, pero son diferentes de los dos identificadores que muestran que tenemos dos instancias, una para cada clase.

Answer 5

Con el diseño que ha diseñado, parece que la solución más fácil es darle a Crawler un método de módulo que devuelve un módulo ivar.

module Crawler
  def self.logger
    @logger
  end
  def self.logger=(logger)
    @logger = logger
  end
end

O podría usar " class <<self magia" si quisiera:

module Crawler
  class <<self
    attr_accessor :logger
  end
end

Hace exactamente lo mismo.

Answer 6

Inspirado por este hilo, creé la joya easy_logging .

Combina todas las características discutidas, tales como:

• Agrega funcionalidad de registro en cualquier lugar con un comando breve y autodescriptivo
• Logger funciona tanto en clase como en métodos de instancia
• Logger es específico de la clase y contiene el nombre de la clase

Instalación:

gem install ''easy_logging

Uso:

require ''easy_logging''

class YourClass
  include EasyLogging

  def do_something
    # ...
    logger.info ''something happened''
  end
end

class YourOtherClass
  include EasyLogging

  def self.do_something
    # ...
    logger.info ''something happened''
  end
end

YourClass.new.do_something
YourOtherClass.do_something

Salida

I, [2017-06-03T21:59:25.160686 #5900]  INFO -- YourClass: something happened
I, [2017-06-03T21:59:25.160686 #5900]  INFO -- YourOtherClass: something happened

Más detalles sobre easy_logging .

Answer 7

Me gusta tener un método de logger disponible en mis clases, pero no me gusta @logger = Logging.logger en todos mis inicializadores. Por lo general, hago esto:

module Logging
  # This is the magical bit that gets mixed into your classes
  def logger
    Logging.logger
  end

  # Global, memoized, lazy initialized instance of a logger
  def self.logger
    @logger ||= Logger.new(STDOUT)
  end
end

Luego, en tus clases:

class Widget
  # Mix in the ability to log stuff ...
  include Logging

  # ... and proceed to log with impunity:
  def discombobulate(whizbang)
    logger.warn "About to combobulate the whizbang"
    # commence discombobulation
  end
end

Debido a que el método Logging#logger puede acceder a la instancia en la que se mezcla el módulo, es trivial ampliar su módulo de registro para registrar el nombre de clase con los mensajes de registro:

module Logging
  def logger
    @logger ||= Logging.logger_for(self.class.name)
  end

  # Use a hash class-ivar to cache a unique Logger per class:
  @loggers = {}

  class << self
    def logger_for(classname)
      @loggers[classname] ||= configure_logger_for(classname)
    end

    def configure_logger_for(classname)
      logger = Logger.new(STDOUT)
      logger.progname = classname
      logger
    end
  end
end

Su Widget ahora registra mensajes con su nombre de clase, y no necesita cambiar un bit :)

Answer 8

Puede haber alguna extraña magia de Ruby que te permita evitarla, pero hay una solución bastante simple que no necesita ser extraña. Simplemente coloque el registrador en el módulo y acceda directamente, con un mecanismo para configurarlo. Si quiere estar tranquilo, defina un "registrador diferido" que mantenga un indicador que indique si todavía tiene un registrador, y cuelgue mensajes en silencio hasta que se configure el registrador, emite una excepción de que algo se registra antes de que el registrador establecer o agrega el mensaje de registro a una lista para que pueda registrarse una vez que se haya definido el registrador.

Answer 9

Una pequeña porción de código para demostrar cómo funciona esto. Simplemente estoy creando un nuevo Objeto básico para poder observar que object_id permanece igual durante todas las llamadas:

module M

  class << self
    attr_accessor :logger
  end

  @logger = nil

  class C
    def initialize
      puts "C.initialize, before setting M.logger: #{M.logger.object_id}"
      M.logger = Object.new
      puts "C.initialize, after setting M.logger: #{M.logger.object_id}"
      @base = D.new
    end
  end

  class D
    def initialize
      puts "D.initialize M.logger: #{M.logger.object_id}"
    end
  end
end

puts "M.logger (before C.new): #{M.logger.object_id}"
engine = M::C.new
puts "M.logger (after C.new): #{M.logger.object_id}"

El resultado de este código es similar (un object_id de 4 significa nil ):

M.logger (before C.new): 4
C.initialize, before setting M.logger: 4
C.initialize, after setting M.logger: 59360
D.initialize M.logger: 59360
M.logger (after C.new): 59360

¡Gracias por la ayuda chicos!