A melhor maneira de seguir um log e executar um comando quando algum texto aparecer no log

Eu tenho um log do servidor que gera uma linha específica de texto em seu arquivo de log quando o servidor está ativo. Quero executar um comando quando o servidor estiver ativo e, portanto, faça algo como o seguinte:

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

Qual é a melhor maneira de fazer isso?

Uma maneira simples seria estranha.

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

E sim, ambas são mensagens reais de um log do kernel. Perl pode ser um pouco mais elegante de usar e também pode substituir a necessidade de cauda. Se estiver usando perl, será algo parecido com isto:

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");
    }
}

Se você está procurando apenas uma possibilidade e deseja permanecer principalmente no shell, em vez de usar awkou perl, pode fazer algo como:

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

... que será executado my_commandsempre que "o servidor estiver ativo " aparecer no arquivo de log. Para várias possibilidades, talvez você possa largar o grepe, em vez disso, usar um casedentro do while.

A capital -Fdiz tailpara observar o arquivo de log ser girado; ou seja, se o arquivo atual for renomeado e outro arquivo com o mesmo nome substituir, ele tailpassará para o novo arquivo.

A --line-bufferedopção diz greppara liberar seu buffer após cada linha; caso contrário, my_commandpoderá não ser alcançado em tempo hábil (assumindo que os logs tenham linhas de tamanho razoável).

Esta pergunta parece já ter sido respondida, mas acho que há uma solução melhor.

Em vez disso tail | whatever, acho que você realmente quer swatch. O Swatch é um programa projetado explicitamente para fazer o que você está pedindo, assistindo a um arquivo de log e executando ações com base nas linhas de log. O uso tail|fooexigirá que você tenha um terminal em execução ativamente para fazer isso. Por outro lado, a amostra é executada como um daemon e sempre estará observando seus registros. O Swatch está disponível em todas as distribuições Linux,

Encorajo-vos a experimentar. Embora você possa pregar um prego na parte traseira de uma chave de fenda, isso não significa que você deva.

O melhor tutorial de 30 segundos sobre amostras que pude encontrar está aqui: http://www.campin.net/newlogcheck.html

É estranho que ninguém tenha mencionado sobre o multitailutilitário que possui essa funcionalidade pronta para uso. Um exemplo de uso:

Mostre a saída de um comando ping e, se ele exibir um tempo limite, envie uma mensagem para todos os usuários atualmente conectados

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

Veja também outros exemplos de multitailuso.

bash poderia fazer o trabalho sozinho

Vamos ver como pode ser simples e legível:

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)

Enquanto você não usa o bash regex, isso pode ficar muito rápido!

Mas o bash + sed é um conjunto muito eficiente e interessante

Mas, para servidores de alta carga, e como eu gosto, sedporque é muito rápido e muito escalável, costumo usar isso:

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;
  ...
')

Foi assim que eu comecei a fazer isso também, mas ficou muito mais sofisticado com isso. Algumas coisas para se preocupar:

1. Se a cauda do log já contiver "o servidor está ativo".
2. Finalizando automaticamente o processo de cauda assim que for encontrado.

Eu uso algo na mesma linha:

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}

Funciona mantendo tailaberto até que o ${RELEASE}arquivo contenha dados.

Depois que o grepconseguir:

1. grava a saída na ${RELEASE}qual será
2. encerrar o ${wait_pid}processo para
3. saia do tail

Nota: sedPode ser mais sofisticado para determinar realmente o número de linhas que tailserão produzidas na inicialização e remover esse número. Mas geralmente são 10.