ruby-on-rails - perform - delayed_job_active_record

Obtención de trabajo retrasado para iniciar sesión

Question

#Here is how I have delayed job set up.
Delayed::Worker.backend = :active_record
#Delayed::Worker.logger = Rails.logger
Delayed::Worker.logger = ActiveSupport::BufferedLogger.new("log/
##{Rails.env}_delayed_jobs.log", Rails.logger.level)
Delayed::Worker.logger.auto_flushing = 1
class Delayed::Job
def logger
Delayed::Worker.logger
end
end
if JobsCommon::check_job_exists("PeriodicJob").blank?
Delayed::Job.enqueue PeriodicJob.new(), 0, 30.seconds.from_now
end
#end
#Here is my simple job.
class PeriodicJob
def perform
Rails.logger.info "Periodic job writing #{Time.now}"
Delayed::Job.enqueue PeriodicJob.new(), 0,
30.seconds.from_now
end
end

No veo ningún mensaje de registro de trabajo retrasado en mis registros de carriles o archivo de registro de trabajo retrasado, los únicos mensajes que veo son trabajos que comienzan / éxito / falla en el archivo delayed_jobs.log.

Esto está causando grandes problemas, ¡incluso detectar errores y fugas de memoria en los trabajadores es casi imposible! ¡Por favor ayuda!

Answer 1

DelayedJob no parece salir si hay algo mal:

1- Las clases de registro no activas deben ser requeridas e inicializadas:

Cómo: Crear un archivo config / initializers / load_classes_for_dj.rb Agregue a ello las líneas:

require ''lib/libtest/delayed_test.rb''
DelayedTest

Tenga en cuenta que si tiene ''# {config.root} / lib / libtest'' en config.autoload_paths en config / application.rb, no necesita hacer el requerimiento.

Fuente: Rails Delayed Job & Library Class

2- Las clases que implementan el módulo Singleton no funcionarán llamando a: SingletonClass.instance.delay.sayhello

Para arreglar eso, haga lo siguiente:

class SingletonClass
include Singleton
# create a class method that does the call for you
def self.delayed_sayhello
SingletonClass.instance.sayhello
end
def sayhello
# this is how you can actually write to delayed_job.log
# https://.com/questions/9507765/delayed-job-not-logging
Delayed::Worker.logger.add(Logger::INFO, "hello there")
end
end

Para llamar al método de clase diferido, haga lo siguiente:

SingletonClass.delay.delayed_sayhello

Sí, estoy llamando a .delay en una clase aquí. Como las clases en Ruby también son objetos, la llamada es válida aquí y me permite acceder al método de clase "delayed_sayhello"

3- No pase objetos ActiveRecord o algunos objetos complejos a su llamada, sino que pase los identificadores, busque los objetos en la base de datos en su método diferido y luego haga su trabajo:

NO HAGAS:

DelayedClass.new.delay.do_some_processing_on_album Album.first

HAGA ESTO EN SU INTERIOR:

 DelayedClass.new.delay.do_some_processing_on_album Album.first.id

y dentro de DelayedClass do_some_processing_on_album, do

a = Album.find_by_id id

Hubo una publicación de sobre esto que vi hace un tiempo - no estoy seguro de cuál :-)

4- Para completar, esto es cómo hacer envíos de correo (no llame al método de entrega):

Notifier.delay.signup(user_id)

Según el punto 3, no pase el objeto del usuario sino su identificación, realice la búsqueda dentro del método de registro.

Ahora, una vez que se haya asegurado de haber seguido las pautas anteriores , puede utilizar:

Delayed::Worker.logger.add(Logger::INFO, "hello")

Si aún estás enfrentando problemas, te sugiero que analices tu problema:

a- Crea una nueva clase b- Asegúrate de que esté incluida e inicializada como en el paso 1 c- Agrega el registro desde el paso 4 e intenta llamar a MyNewClass.new.delay para ver si funciona

Espero que esto les ayude chicos :-)

Answer 2

Esto puede ser una solución simple pero funciona lo suficientemente bien para mí:

system("echo #{your message here} >> logfile.log")

Simple pero funciona

Answer 3

Lo conseguimos para que funcione en Rails 3 / Delayed Job 2.0.3 hackeando Rails.logger para usar un archivo de registro diferente (el que queremos para las entradas delayed_job) y también configuramos el registrador de trabajos diferidos para que use el mismo objeto. :

file_handle = File.open("log/#{Rails.env}_delayed_jobs.log", (File::WRONLY | File::APPEND | File::CREAT))
# Be paranoid about syncing, part #1
file_handle.sync = true
# Be paranoid about syncing, part #2
Rails.logger.auto_flushing = true
# Hack the existing Rails.logger object to use our new file handle
Rails.logger.instance_variable_set :@log, file_handle
# Calls to Rails.logger go to the same object as Delayed::Worker.logger
Delayed::Worker.logger = Rails.logger

Si el código anterior no funciona, intente reemplazar Rails.logger con RAILS_DEFAULT_LOGGER .

Answer 4

Lo tengo trabajando con la siguiente configuración en el inicializador:

require ''delayed/worker''
Delayed::Worker.logger = Rails.logger
module Delayed
class Worker
def say_with_flushing(text, level = Logger::INFO)
if logger
say_without_flushing(text, level)
logger.flush
end
end
alias_method_chain :say, :flushing
end
end

Answer 5

No te olvides de cambiar el ActiveRecord :: Base.logger

Delayed::Worker.logger = Logger.new("log/delayed_job.log", 5, 104857600)
if caller.last =~ /script//delayed_job/ or (File.basename($0) == "rake" and ARGV[0] =~ /jobs/:work/)
ActiveRecord::Base.logger = Delayed::Worker.logger
end

Respuesta más detallada: tener el registro delayed_job "pone", consultas de SQL y el estado de los trabajos

Answer 6

simplemente hice esto

/config/environments/development.rb
MyApp::Application.configure do
[...]
[...]
[...]
Delayed::Worker.logger = Rails.logger
end

En cada solicitud que haga, el correo aparecerá en el registro.

NOTA : A veces, debe actualizar la página para que el correo se registre en el registro. No te olvides de reiniciar el servidor;)