como emitir um sinal sonoro no evento tail -f

Quero que o meu PC faça um bipe no sistema em todos os eventos de cauda

Eu tenho o seguinte comando

tail -f development.log | grep "something rare"

existe uma maneira fácil como canalizá-lo para algo que emite um sinal sonoro? gostar

tail -f development.log | grep "something rare" | beep

se sim, a saída grep ainda será mostrada?

Basta definir da beepseguinte maneira:

beep() { read a || exit; printf "$a\007\n"; beep; }

Então, você pode usar seu comando:

tail -f development.log | grep "something rare" | beep

A tela GNU possui um recurso embutido para emitir um bipe quando uma janela é alterada: consulte a seção relevante da página de manual .

Resumo do título:

$ screen
$ tail -f yourfile.log    # inside the screen session
<C-a> M    # "Window 0 (bash) is now being monitored for all activity."

Como apontado nos comentários, este será emitido um bipe em cada nova entrada de log, não apenas nas que correspondem a "algo raro"; portanto, isso não faz exatamente o que o OP solicitou. Ainda é um truque útil para conhecer o IMHO.

Você pode obter o melhor dos dois mundos abrindo duas screenjanelas ( <C-a> cpara abrir uma janela, <C-a> <C-a>para alternar entre duas janelas):

1. monitorado, com tail -f yourfile.log | grep 'something rare'
2. não monitorado, com uma planície tail -f yourfile.log

Em seguida, você pode ficar assistindo o log rolar na janela 2 e será acionado da janela 1 quando "algo raro" ocorrer.

screen é incrivelmente versátil - eu recomendo a leitura.

Você pode impedir que a saída seja armazenada em buffer no comando grep. Veja man grep para detalhes.

Você pode canalizar a saída grep em um bipe.

O exemplo a seguir é do man beep ...

   As part of a log-watching pipeline

          tail -f /var/log/xferlog | grep --line-buffered passwd | \
          beep -f 1000 -r 5 -s

Há muitas coisas boas nesses manuais. Se não tivéssemos que lê-los para encontrá-lo. ;-)

O comando watch possui uma opção --beep, e você também pode definir o intervalo de pesquisa, mas o padrão com 2 s deve estar ok

watch --beep 'tail development.log | grep "something rare"'

Você pode usar sed para adicionar o controle-G da seguinte maneira:

tail -f myFile | sed "s/.*/&\x07/"

ou apenas em linhas raras, sem usar grep, da seguinte maneira:

tail -f myFile | sed -n "/something rare/s/.*/&\x07/p"

que diz: nas linhas onde algo raro ocorre, é tudo ubstitute para a mesma coisa com o controle-G pregado na extremidade, e impressão (mas não imprimir as linhas não correspondentes). Funciona bem!

Hum, complicado. Talvez pudéssemos fazer algo assim?

for i in `find | grep 7171`; do beep; echo $i; done

Ou no seu caso

for i in `tail -f development.log | grep "something rare"`; do beep; echo $i; done

Parece estar fazendo algum buffer embora. Vou procurar se há uma maneira de desativar esse buffer pelo forloop.

Aparentemente, você deve poder ajustar o buffer do pipe usando, ulimit -pmas isso continua reclamando de argumento inválido para mim. Eu também encontrei um post que afirma que você precisa recompilar o kernel para alterar esse limite.

Em um trabalho anterior, eu não conseguia encontrar um observador confiável apenas com command-fu, então eu tinha um script de wrapper como o abaixo, que inspecionava o arquivo a cada segundo de poll_duration e preenchia as novas linhas da frase interessada.

#!/bin/bash

file=$1
phrase=$2
poll_duration=$3

typeset -i checked_linecount
typeset -i new_linecount
typeset -i new_lines
let checked_linecount=new_linecount=new_lines=0
echo "Watching file $file for phrase \"$phrase\" every $poll_duration seconds"

while [ 1 ]
do
        let new_linecount=`wc -l $file| awk '{print $1}'`
        if [[ $new_linecount > $checked_linecount ]]; then
                let "new_lines = $new_linecount-$checked_linecount"
                head --lines=$new_linecount "$file" | tail --lines=$new_lines | grep "$phrase" && beep
                let checked_linecount=$new_linecount
        fi
        sleep $poll_duration
done

Isso foi em uma máquina Unix. No Linux, você pode melhorar ainda mais usando sua interface inotify filewatcher. Se este pacote ( inotify-tools no Ubuntu) estiver presente, substitua

sleep $poll_duration 

com

inotifywait -e modify "$file"  1>/dev/null 2>&1

Essa chamada é bloqueada até que o arquivo seja modificado. A versão de bloqueio é quase tão eficiente quanto a que você obteria com a tail -fversão se o pipe pudesse ser configurado para funcionar sem buffer.

Nota: O script primeiro faz um head --lines=$new_linecountpara garantir que as linhas adicionadas ao arquivo após a verificação não distorcem a parte do arquivo que é verificado nesse loop.