So überwachen Sie delay_job mit monit

Gibt es im Internet Beispiele für die Überwachung von delay_job mit Monit ?

Alles, was ich finden kann, nutzt Gott , aber ich weigere mich, Gott zu benutzen, da lang laufende Prozesse in Ruby im Allgemeinen scheiße sind. (Der aktuellste Beitrag in der God-Mailingliste? Die Nutzung des God-Gedächtnisses wächst stetig .)

Update: delay_job enthält jetzt eine Beispielkonfiguration für die Überwachung, die auf dieser Frage basiert.

Hier ist, wie ich das zum Laufen gebracht habe.

1. Verwenden Sie die Collectiveidea-Gabel von delay_job. Diese Version wird nicht nur aktiv gewartet, sondern verfügt auch über einen netten script/delayed_jobDaemon, den Sie mit monit verwenden können. Railscasts hat eine gute Folge über diese Version von delayed_job( ASCIICasts-Version ). Dieses Skript bietet auch einige andere nützliche Funktionen, z. B. die Möglichkeit, mehrere Worker auszuführen. Das werde ich hier nicht behandeln.
2. Monit installieren. Ich habe von der Quelle installiert, weil Ubuntus Version so lächerlich veraltet ist. Ich habe diese Anweisungen befolgt , um die Standard-init.d-Skripte zu erhalten, die mit den Ubuntu-Paketen geliefert werden. Ich musste auch mit konfigurieren, ./configure --sysconfdir=/etc/monitdamit das Standard-Ubuntu-Konfigurationsverzeichnis übernommen wurde.

3. Schreiben Sie ein Überwachungsskript. Folgendes habe ich mir ausgedacht:

   check process delayed_job with pidfile /var/www/app/shared/pids/delayed_job.pid
start program = "/var/www/app/current/script/delayed_job -e production start"
stop program = "/var/www/app/current/script/delayed_job -e production stop"
   

   Ich speichere dies in meinem Soucre-Kontrollsystem und zeige darauf mit include /var/www/app/current/config/monitin der /etc/monit/monitrcDatei.

4. Monit konfigurieren. Diese Anweisungen sind mit Anzeigen beladen, aber ansonsten in Ordnung.
5. Schreiben Sie eine Aufgabe, damit capistrano stoppt und startet. monit start delayed_jobund monit stop delayed_jobist das, was Sie ausführen möchten. Ich lade auch monit bei der Bereitstellung neu, um Änderungen an der Konfigurationsdatei zu erfassen.

Probleme, auf die ich gestoßen bin:

1. daemonsEdelstein muss installiert sein, um script/delayed_jobzu laufen.
2. Sie müssen die Rails - Umgebung passieren script/delayed_jobmit -e production(zum Beispiel). Dies ist in der README-Datei dokumentiert, jedoch nicht in der Hilfeausgabe des Skripts.
3. Ich verwende Ruby Enterprise Edition, daher musste ich eine Überwachung durchführen, um mit dieser Kopie von Ruby zu beginnen. Aufgrund der Art und Weise sudo Griffe des PATH in Ubuntu, ich landete SymLink /usr/bin/rubyund /usr/bin/gemdie REE - Versionen.

Beim Debuggen von monit habe ich festgestellt, dass es hilfreich ist, die init.d-Version zu stoppen und über die Befehlszeile auszuführen, damit Sie Fehlermeldungen erhalten. Ansonsten ist es sehr schwierig herauszufinden, warum etwas schief geht.

sudo /etc/init.d/monit stop
sudo monit start delayed_job

Hoffentlich hilft dies der nächsten Person, die delayed_jobmit Monit überwachen möchte.

Für das, was es wert ist, können Sie immer / usr / bin / env mit monit verwenden, um die Umgebung einzurichten. Dies ist besonders wichtig in der aktuellen Version von delay_job, 1.8.4, in der die Umgebungsoption (-e) veraltet ist.

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"

In einigen Fällen müssen Sie den PATH möglicherweise auch mit env festlegen.

Ich fand es einfacher, ein Init-Skript für verzögerte Jobs zu erstellen. Es ist hier verfügbar: http://gist.github.com/408929 oder darunter:

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

Fall "$ 1" in
  Start)
        echo -n "Delayed_job starten:"
                su - Rails -c "$ set_path; RAILS_ENV = Staging-Skript / verzögerter_Startstart" >> /var/log/delayed_job.log 2> & 1
        Echo "fertig".
        ;;
  halt)
        echo -n "Sphinx stoppen:"
                su - Rails -c "$ set_path; RAILS_ENV = Staging-Skript / verzögerter_Jobstopp" >> /var/log/delayed_job.log 2> & 1
        Echo "fertig".
        ;;
      *)
            N = / etc / init.d / delay_job_staging
            echo "Verwendung: $ N {start | stop}"> & 2
            Ausfahrt 1
            ;;
    esac

    Ausfahrt 0

Stellen Sie dann sicher, dass monit so eingestellt ist, dass die App in Ihrer monitrc-Datei gestartet / neu gestartet wird:

Überprüfen Sie den Prozess delay_job mit der PID-Datei "/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"

und das funktioniert super!

Ich habe einen guten Weg gefunden, delay_job mit cron beim Booten zu starten. Ich benutze wann immer , um Cron zu kontrollieren.

Mein Zeitplan.rb:

# Benutzerdefinierter Jobtyp zur Steuerung von delay_job
job_type: delay_job, 'cd: path; RAILS_ENV =: Umgebungsskript / delay_job ": task"'

# verzögerter Jobstart beim Booten
alle: Neustart tun
  delay_job "start"
Ende

Hinweis: Ich habe jedes Mal ein Upgrade auf die Version 0.5.0 durchgeführt, um job_type verwenden zu können

Ich weiß es nicht mit Monit, aber ich habe ein paar Munin-Plugins geschrieben , um die Warteschlangengröße und die durchschnittliche Joblaufzeit zu überwachen. Die Änderungen, die ich in diesem Patch an delay_job vorgenommen habe, erleichtern Ihnen möglicherweise auch das Schreiben von Monit-Plugins, falls Sie dabei bleiben.

Danke für das Skript.

Ein Gotcha - da Monit per Definition einen "spartanischen Pfad" von hat

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

... und für mich wurde Ruby in / usr / local / bin installiert / verlinkt. Ich musste stundenlang herumschlagen, um herauszufinden, warum monit beim Versuch, delay_job neu zu starten, stillschweigend fehlschlug (sogar mit -v für den ausführlichen Monit-Modus). .

Am Ende musste ich das machen:

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"

Ich musste die Lösungen auf dieser Seite mit einem anderen Skript von toby kombinieren, damit es mit monit funktioniert und mit dem richtigen Benutzer beginnt.

Also sieht mein delay_job.monitrc so aus:

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"

Wenn Ihr Monit als root ausgeführt wird und Sie delay_job als my_user ausführen möchten, gehen Sie folgendermaßen vor:

/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/*

Da ich nicht als root ausgeführt werden wollte, erstellte ich ein Bash-Init-Skript, das zum Starten und Stoppen verwendet wurde (PROGNAME wäre der absolute Pfad zu script / delay_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
}

Ich habe ziemlich viel Zeit mit diesem Thema verbracht. Ich hatte es satt, keine gute Lösung dafür zu haben, also schrieb ich das Plugin delay_job_tracer, das sich speziell mit der Überwachung von delay_job und seinen Jobs befasst.

Hier ist ein Artikel, den ich darüber geschrieben habe: http://modernagility.com/articles/5-monitoring-delayed_job-and-its-jobs

Dieses Plugin überwacht Ihren verzögerten Jobprozess und sendet Ihnen eine E-Mail, wenn delay_job abstürzt oder einer seiner Jobs fehlschlägt.

Für Rails 3 müssen Sie möglicherweise HOME env festlegen, damit der Kompass ordnungsgemäß funktioniert. Die folgende Konfiguration funktioniert für mich:

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'"

Ich bin auf ein Problem gestoßen, bei dem der Job nicht freigegeben wird, wenn der verzögerte Job stirbt, während noch ein Job gesperrt ist. Ich habe ein Wrapper-Skript für verzögerte Jobs geschrieben, das die PID-Datei überprüft und alle Jobs vom toten Arbeiter befreit.

Das Skript ist für Gummi / Capistrano

Rollen / verzögertjob / verzögert_job_verpackung:

<% @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 %>

Rollen / verzögertjob / verzögert_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"%>

Um zu sehen, was los ist, führen Sie monit im ausführlichen Vordergrundmodus aus: sudo monit -Iv

mit rvminstalliert unter Benutzer "www1" und Gruppe "www1".

in Datei /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