Cómo monitorear el trabajo retrasado con monit

Por si sirve de algo, siempre puede usar /usr/bin/env con monit para configurar el entorno. Esto es especialmente importante en la versión actual de delayed_job, 1.8.4, donde la opción environment (-e) está obsoleta.

check process delayed_job with pidfile /var/app/shared/pids/delayed_job.pid
start program = "/usr/bin/env RAILS_ENV=production /var/app/current/script/delayed_job start"
stop  program = "/usr/bin/env RAILS_ENV=production /var/app/current/script/delayed_job stop"

En algunos casos, es posible que también necesite establecer la RUTA con env.

Encontré que era más fácil crear un script de inicio para el trabajo retrasado. Está disponible aquí: http://gist.github.com/408929 o más abajo:

#! /bin/sh
set_path="cd /home/rails/evatool_staging/current"

case "$1" in
  start)
        echo -n "Starting delayed_job: "
                su - rails -c "$set_path; RAILS_ENV=staging script/delayed_job start" >> /var/log/delayed_job.log 2>&1
        echo "done."
        ;;
  stop)
        echo -n "Stopping sphinx: "
                su - rails -c "$set_path; RAILS_ENV=staging script/delayed_job stop" >> /var/log/delayed_job.log 2>&1
        echo "done."
        ;;
      *)
            N=/etc/init.d/delayed_job_staging
            echo "Usage: $N {start|stop}" >&2
            exit 1
            ;;
    esac

    exit 0

Luego asegúrese de que monit esté configurado para iniciar / reiniciar la aplicación para que en su archivo monitrc:

check process delayed_job with pidfile "/path_to_my_rails_app/shared/pids/delayed_job.pid"
start program = "/etc/init.d/delayed_job start"
stop program = "/etc/init.d/delayed_job stop"

Y eso funciona muy bien!

Encontré una buena manera de comenzar delayed_job con cron en el arranque. Estoy usando siempre que para controlar cron.

Mi horario.rb:

# custom job type to control delayed_job
job_type :delayed_job, 'cd :path;RAILS_ENV=:environment script/delayed_job ":task"'

# delayed job start on boot
every :reboot do
  delayed_job "start"
end

Nota: Actualizé cada vez que gem a la versión 0.5.0 para poder usar job_type

No lo sé con Monit, pero he escrito un par de plugins de Munin para monitorear el Tamaño de la Cola y el Tiempo Promedio de Ejecución del Trabajo. Los cambios que hice en delayed_job en ese parche también podrían hacer que sea más fácil para usted escribir complementos Monit en caso de que se quede con eso.

Gracias por el guión.

One gotcha since ya que monit por definición tiene un 'camino espartano' de

/bin:/usr/bin:/sbin:/usr/sbin

... y para mí ruby estaba instalado / enlazado en/usr/local / bin, tuve que revolotear durante horas tratando de averiguar por qué monit estaba fallando silenciosamente al intentar reiniciar delayed_job (incluso con-v para monit verbose mode).

Al final tuve que hacer esto:

check process delayed_job with pidfile /var/www/app/shared/pids/delayed_job.pid
start program = "/usr/bin/env PATH=$PATH:/usr/local/bin /var/www/app/current/script/delayed_job -e production start"
stop program = "/usr/bin/env PATH=$PATH:/usr/local/bin /var/www/app/current/script/delayed_job -e production stop"

Si tu monit se ejecuta como root y quieres ejecutar delayed_job como my_user entonces haz esto:

/etc / init.d / delayed_job :

#!/bin/sh
#   chmod 755 /etc/init.d/delayed_job
#   chown root:root /etc/init.d/delayed_job

case "$1" in
  start|stop|restart)
    DJ_CMD=$1
    ;;
  *)
    echo "Usage: $0 {start|stop|restart}"
    exit
esac

su -c "cd /var/www/my_app/current && /usr/bin/env bin/delayed_job $DJ_CMD" - my_user

/var/www/my_app/shared/monit / delayed_job.monitrc :

check process delayed_job with pidfile /var/www/my_app/shared/tmp/pids/delayed_job.pid
start program = "/etc/init.d/delayed_job start"
stop  program = "/etc/init.d/delayed_job stop"
if 5 restarts within 5 cycles then timeout

/etc / monit / monitrc :

# add at bottom
include /var/www/my_app/shared/monit/*

Dado que no quería correr como root, terminé creando un script de inicio bash que monit usó para iniciar y detener (PROGNAME sería la ruta absoluta a script/delayed_job):

start() {
    echo "Starting $PROGNAME"
    sudo -u $USER /usr/bin/env HOME=$HOME RAILS_ENV=$RAILS_ENV $PROGNAME start
}

stop() {
    echo "Stopping $PROGNAME"
    sudo -u $USER /usr/bin/env HOME=$HOME RAILS_ENV=$RAILS_ENV $PROGNAME stop
}

Tuve que combinar las soluciones de esta página con otro script hecho por toby para que funcionara con monit y comenzando con el usuario correcto.

Así que mi trabajo demorado.monitrc se ve así:

check process delayed_job
  with pidfile /var/app/shared/pids/delayed_job.pid
  start program = "/bin/su -c '/usr/bin/env RAILS_ENV=production /var/app/current/script/delayed_job start' - rails"
  stop program = "/bin/su -c '/usr/bin/env RAILS_ENV=production /var/app/current/script/delayed_job stop' - rails"

He dedicado bastante tiempo a este tema. Estaba harto de no tener una buena solución para ello, así que escribí el plugin delayed_job_tracer que aborda específicamente el monitoreo de delayed_job y sus trabajos.

He aquí un artículo que he escrito al respecto: http://modernagility.com/articles/5-monitoring-delayed_job-and-its-jobs

Este plugin monitorizará su proceso de trabajo retrasado y le enviará un correo electrónico si delayed_job se bloquea o si uno de sus trabajos falla.

Para Rails 3, es posible que necesite configurar HOME env para que compass funcione correctamente, y debajo de la configuración funciona para mí:

check process delayed_job
  with pidfile /home/user/app/shared/pids/delayed_job.pid
  start program = "/bin/sh -c 'cd /home/user/app/current; HOME=/home/user RAILS_ENV=production script/delayed_job start'"
  stop program  = "/bin/sh -c 'cd /home/user/app/current; HOME=/home/user RAILS_ENV=production script/delayed_job stop'"

Me encontré con un problema en el que si el trabajo retrasado muere mientras todavía tiene un trabajo bloqueado, ese trabajo no se liberará. Escribí un script de envoltura alrededor del trabajo retrasado que mirará el archivo pid y liberará cualquier trabajo del trabajador muerto.

El guion es para rubber / capistrano

Roles / delayedjob/delayed_job_wrapper:

<% @path = '/etc/monit/monit.d/monit-delayedjob.conf' %>
<% workers = 4 %>
<% workers.times do |i| %>
<% PIDFILE = "/mnt/custora-#{RUBBER_ENV}/shared/pids/delayed_job.#{i}.pid" %>
<%= "check process delayed_job.#{i} with pidfile #{PIDFILE}"%>
group delayed_job-<%= RUBBER_ENV %>
<%= " start program = \"/bin/bash /mnt/#{rubber_env.app_name}-#{RUBBER_ENV}/current/script/delayed_job_wrapper #{i} start\"" %>
<%= " stop program = \"/bin/bash /mnt/#{rubber_env.app_name}-#{RUBBER_ENV}/current/script/delayed_job_wrapper #{i} stop\"" %>
<% end %>

Roles/delayedjob / delayed_job_wrapper

#!/bin/bash
<%   @path = "/mnt/#{rubber_env.app_name}-#{RUBBER_ENV}/current/script/delayed_job_wrapper" %>

<%= "pid_file=/mnt/#{rubber_env.app_name}-#{RUBBER_ENV}/shared/pids/delayed_job.$1.pid" %>
if [ -e $pid_file ]; then
 pid=`cat $pid_file`
 if [ $2 == "start" ]; then
   ps -e | grep ^$pid
   if [ $? -eq 0 ]; then
     echo "already running $pid"
     exit
   fi
   rm $pid_file
 fi

locked_by="delayed_job.$1 host:`hostname` pid:$pid"

<%="   /usr/bin/mysql -e \"update delayed_jobs set locked_at = null, locked_by = null where locked_by='$locked_by'\" -u#{rubber_env.db_user} -h#{rubber_instances.for_role('db', 'primary' => true).first.full_name}  #{rubber_env.db_name} " %>

fi
<%= "cd /mnt/#{rubber_env.app_name}-#{RUBBER_ENV}/current" %>

. /etc/profile
<%= "RAILS_ENV=#{RUBBER_ENV} script/delayed_job -i $1 $2"%>

Para ver lo que está pasando, ejecute monit en modo detallado en primer plano: sudo monit -Iv

Usando rvm instalado bajo el usuario "www1" y el grupo "www1".

En el archivo /etc/monit/monitrc:

#delayed_job
check process delayed_job with pidfile /home/www1/your_app/current/tmp/pids/delayed_job.pid
    start program "/bin/bash -c 'PATH=$PATH:/home/www1/.rvm/bin;source /home/www1/.rvm/scripts/rvm;cd /home/www1/your_app/current;RAILS_ENV=production bundle exec script/delayed_job start'" as uid www1 and gid www1
    stop program "/bin/bash -c 'PATH=$PATH:/home/www1/.rvm/bin;source /home/www1/.rvm/scripts/rvm;cd /home/www1/your_app/current;RAILS_ENV=production bundle exec script/delayed_job stop'" as uid www1 and gid www1
    if totalmem is greater than 200 MB for 2 cycles then alert