Como monitorar delayed_job com monit

StackOverflow https://stackoverflow.com/questions/1226302

Pergunta

Existem exemplos na web de como monitorar delayed_job com Monit ?

Tudo que eu posso encontrar usos Deus , mas eu me recuso a usar Deus, desde há muito a execução de processos em Ruby geralmente sugam . (O atual cargo mais na lista de discussão Deus? Usage Deus memória cresce constantemente .)

Update: delayed_job agora vem com um provar monit configuração com base nesta questão.

Foi útil?

Solução

Aqui está como eu tenho esse trabalho.

  1. Use o collectiveidea garfo de delayed_job além de ser mantido ativamente, esta versão tem um bom script/delayed_job daemon você pode usar com monit. Railscasts tem um bom episódio sobre esta versão do delayed_job ( ASCIICasts versão ). Este script também tem algumas outras características interessantes, como a capacidade de executar vários trabalhadores. Eu não cobrir isso aqui.
  2. Instale monit. Eu instalei a partir da fonte porque a versão do Ubuntu é tão ridiculamente desatualizado. Segui estas instruções para obter o padrão init.d scripts que vêm com os pacotes do Ubuntu. Eu também precisava configure com ./configure --sysconfdir=/etc/monit de modo a dir configuração padrão do Ubuntu foi apanhado.

  3. Escrever um script monit. Aqui está o que eu vim com:

    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"

    Eu armazenar isso no meu sistema de controle soucre e ponto monit para ele com include /var/www/app/current/config/monit no arquivo /etc/monit/monitrc.

  4. Configurar Monit. Estas instruções são carregados com anúncios, mas caso contrário OK.
  5. Escrever uma tarefa para Capistrano para parar e iniciar. monit start delayed_job e monit stop delayed_job é o que você deseja executar. Eu também recarregar monit ao implantar para pegar todas as alterações de arquivo de configuração.

Problemas Corri para:

  1. gem daemons deve ser instalado para script/delayed_job a prazo.
  2. Você deve passar o Rails ambiente para script/delayed_job com -e production (por exemplo). Isso está documentado no arquivo README, mas não na ajuda a saída do script.
  3. Eu uso o Ruby Enterprise Edition, então eu precisava para obter monit começar com essa cópia do Ruby. Por causa da maneira sudo lida com a PATH no Ubuntu, acabei link simbólico /usr/bin/ruby e /usr/bin/gem ao versões REE.

Quando a depuração monit, achei que ajuda a parar a versão init.d e executá-lo a partir da linha de comando th, para que possa receber mensagens de erro. Caso contrário, é muito difícil descobrir por que as coisas vão mal. 

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

Esperemos que esta ajuda a próxima pessoa que deseja monitorar delayed_job com monit.

Outras dicas

Por que vale a pena, você sempre pode usar / usr / bin / env com monit para configurar o ambiente. Isto é especialmente importante para a versão atual do delayed_job, 1.8.4, onde a opção de ambiente (-e) é obsoleto. 

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"

Em alguns casos, você pode também precisa definir o caminho com env, também.

Eu achei que era mais fácil para criar um script de inicialização para o trabalho atrasado. Ele está disponível aqui: http://gist.github.com/408929 ou abaixo: 

#! /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

Em seguida, certifique-se de que monit está definido para iniciar / reiniciar o aplicativo para que no seu arquivo 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"

e que funciona muito bem!

Eu encontrei uma boa maneira de começar delayed_job com cron na inicialização. Estou usando sempre para controlar cron.

Meu schedule.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: eu atualizado sempre jóia para 0.5.0 versão para ser capaz de usar job_type

Eu não sei com Monit, mas eu escrevi um casal Munin plugins para monitorar tamanho da fila e Média Job Run Time. As alterações que fiz para delayed_job em que patch também pode tornar mais fácil para você escrever plugins Monit no caso de você ficar com isso.

Obrigado pelo script.

Uma pegadinha - desde monit, por definição, tem um 'caminho espartano' de 

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

... e para mim rubi foi instalado / ligado em / usr / / bin local, eu tinha de thrash em torno de horas tentando descobrir por que monit foi silenciosamente falhar ao tentar reiniciar delayed_job (mesmo com -v para monit verbose mode).

No final, eu tinha que fazer isso: 

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"

Eu tive que combinar as soluções a esta página com uma outra roteiro feito por Toby para que ele funcione com monit e começando com o direito do usuário.

Assim, meus delayed_job.monitrc esta aparência: 

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"

Se o seu monit está sendo executado como root e você deseja executar delayed_job como my_user , em seguida, faça o seguinte:

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

Desde que eu não quero correr como root, acabei criando um script de inicialização que monit utilizado para iniciar e parar (progname seria o caminho absoluto para 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
}

Eu passei um pouco de tempo sobre este tema. Eu estava farto de não ter uma boa solução para ele assim que eu escrevi o delayed_job_tracer plugin que trata especificamente de monitoramento de delayed_job e seus postos de trabalho.

Aqui está um artigo que eu escrevi sobre isso: http: //modernagility.com/articles/5-monitoring-delayed_job-and-its-jobs

Este plugin irá acompanhar o seu processo de trabalho atrasado e enviar-lhe um e-mail se delayed_job falhar ou se um de seus postos de trabalho falhar.

Para Rails 3, você pode precisar casa conjunto env para tornar o trabalho bússola corretamente, e abaixo de configuração funciona para mim: 

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

Eu corri para um problema onde se dos moldes de trabalho adiada enquanto ele ainda tem um trabalho fechados, que o trabalho não será libertado. Eu escrevi um script invólucro em torno adiada trabalho que vai olhar para o arquivo pid e libertar todos os trabalhos do trabalhador morto.

O roteiro é de borracha / Capistrano

papéis / 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 %>

papéis / 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 o que está acontecendo, executar monit em primeiro plano detalhado modo: sudo monit -Iv

usando rvm instalado sob usuário "www1" e grupo "www1".

em /etc/monit/monitrc arquivo: 

#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
Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top