Meilleure façon de suivre un journal et d'exécuter une commande lorsqu'un texte apparaît dans le journal

J'ai un journal de serveur qui affiche une ligne de texte spécifique dans son fichier journal lorsque le serveur est opérationnel. Je veux exécuter une commande une fois que le serveur est en marche, et par conséquent, procédez comme suit:

tail -f /path/to/serverLog | grep "server is up" ...(now, e.g., wget on server)?

Quelle est la meilleure façon de procéder?

Un moyen simple serait génial.

tail -f /path/to/serverLog | awk '
                    /Printer is on fire!/ { system("shutdown -h now") }
                    /new USB high speed/  { system("echo \"New USB\" | mail admin") }'

Et oui, les deux sont de vrais messages d'un journal de noyau. Perl pourrait être un peu plus élégant à utiliser pour cela et peut également remplacer le besoin de queue. Si vous utilisez perl, cela ressemblera à ceci:

open(my $fd, "<", "/path/to/serverLog") or die "Can't open log";
while(1) {
    if(eof $fd) {
        sleep 1;
        $fd->clearerr;
        next;
    }
    my $line = <$fd>;
    chomp($line);
    if($line =~ /Printer is on fire!/) {
        system("shutdown -h now");
    } elsif($line =~ /new USB high speed/) {
        system("echo \"New USB\" | mail admin");
    }
}

Si vous recherchez seulement une possibilité et souhaitez rester principalement dans la coquille plutôt que d'utiliser awkou perl, vous pouvez faire quelque chose comme:

tail -F /path/to/serverLog | 
grep --line-buffered 'server is up' | 
while read ; do my_command ; done

... qui s'exécutera à my_commandchaque fois que "le serveur est en service " apparaît dans le fichier journal. Pour de multiples possibilités, vous pouvez peut-être laisser tomber le grepet utiliser plutôt un casedans le while.

La capitale -Findique tailde surveiller le fichier journal à faire pivoter; Par exemple, si le fichier en cours est renommé et qu'un autre fichier portant le même nom prend sa place, tailil basculera vers le nouveau fichier.

L' --line-bufferedoption indique grepde vider son tampon après chaque ligne; sinon, il my_commandpeut ne pas être atteint à temps (en supposant que les journaux contiennent des lignes de taille raisonnable).

On semble déjà avoir répondu à cette question, mais je pense qu'il existe une meilleure solution.

Plutôt que tail | whatever, je pense que ce que vous voulez vraiment, c'est swatch. Swatch est un programme conçu explicitement pour faire ce que vous demandez, regarder un fichier journal et exécuter des actions en fonction des lignes de journal. Pour utiliser tail|foocette fonction, vous devez disposer d’un terminal actif. Swatch, de son côté, fonctionne comme un démon et surveillera toujours vos journaux. Swatch est disponible dans toutes les distributions Linux,

Je vous encourage à l'essayer. Bien que vous puissiez enfoncer un clou dans le dos d’un tournevis, cela ne signifie pas que vous devriez le faire.

Le meilleur tutoriel de 30 secondes sur swatch que j'ai pu trouver est ici: http://www.campin.net/newlogcheck.html

Il est étrange que personne ne mentionne un multitailutilitaire doté de cette fonctionnalité immédiatement. Un exemple d'utilisation:

Affiche le résultat d'une commande ping et, s'il affiche un délai, envoie un message à tous les utilisateurs actuellement connectés.

multitail -ex timeout "echo timeout | wall" -l "ping 192.168.0.1"

Voir aussi un autre exemple d' multitailutilisation.

bash pourrait faire le travail tout seul

Voyons à quel point cela pourrait être simple et lisible:

mylog() {
    echo >>/path/to/myscriptLog "$@"
}

while read line;do
    case "$line" in
        *"Printer on fire"* )
            mylog Halting immediately
            shutdown -h now
            ;;
        *DHCPREQUEST* )
            [[ "$line" =~ DHCPREQUEST\ for\ ([^\ ]*)\  ]]
            mylog Incomming or refresh for ${BASH_REMATCH[1]}
            $HOME/SomethingWithNewClient ${BASH_REMATCH[1]}
            ;;
        * )
            mylog "untrapped entry: $line"
            ;;
    esac
  done < <(tail -f /path/to/logfile)

Bien que vous n'utilisiez pas bash regex, cela pourrait rester très rapide!

Mais bash + sed est un tandem très efficace et intéressant

Mais pour les serveurs à forte charge, et comme je l’aime bien sedparce que c’est très rapide et très évolutif, j’utilise souvent ceci:

while read event target lost ; do
    case $event in
        NEW )
            ip2int $target intTarget
            ((count[intTarget]++))
        ...

    esac
done < <(tail -f /path/logfile | sed -une '
  s/^.*New incom.*from ip \([0-9.]\+\) .*$/NEW \1/p;
  s/^.*Auth.*ip \([0-9.]\+\) failed./FAIL \1/p;
  ...
')

C'est comme ça que j'ai commencé à faire ça aussi mais que je suis devenu beaucoup plus sophistiqué avec ça. Quelques choses à se préoccuper de:

1. Si la fin du journal contient déjà "le serveur est en service".
2. Terminer automatiquement le processus de queue une fois qu'il est trouvé.

J'utilise quelque chose dans le sens de ceci:

RELEASE=/tmp/${RANDOM}$$
(
  trap 'false' 1
  trap "rm -f ${RELEASE}" 0
  while ! [ -s ${RELEASE} ]; do sleep 3; done
  # You can put code here if you want to do something
  # once the grep succeeds.
) & wait_pid=$!
tail --pid=${wait_pid} -F /path/to/serverLog \
| sed "1,10d" \
| grep "server is up" > ${RELEASE}

Cela fonctionne en maintenant tailouvert jusqu'à ce que le ${RELEASE}fichier contienne des données.

Une fois le grepréussit:

1. écrit la sortie sur ${RELEASE}laquelle
2. terminer le ${wait_pid}processus pour
3. sortir de la tail

Remarque: Il sedpeut être plus sophistiqué de déterminer le nombre de lignes tailgénérées au démarrage et de supprimer ce nombre. Mais généralement, il est 10.