cómo emitir un pitido en el evento tail -f

Quiero que mi PC emita un pitido del sistema en cada evento de cola

Tengo el siguiente comando

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

¿Hay alguna manera fácil como canalizarlo a algo que suene? me gusta

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

si es así, ¿se mostrará la salida grep?

Simplemente defina beeplo siguiente:

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

Entonces, puedes usar tu comando:

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

La pantalla GNU tiene una función incorporada para emitir un pitido cuando cambia una ventana determinada: consulte la sección correspondiente de la página de manual .

Resumen del titular:

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

Como se señaló en los comentarios, esto emitirá un pitido en cada entrada de registro nueva, no solo en aquellas que coincidan con "algo raro", por lo que esto no hace exactamente lo que solicitó el OP. Sigue siendo un truco útil para saber en mi humilde opinión.

Puede obtener lo mejor de ambos mundos abriendo dos screenventanas ( <C-a> cpara abrir una ventana, <C-a> <C-a>para alternar entre dos ventanas):

1. monitoreado, con tail -f yourfile.log | grep 'something rare'
2. sin vigilancia, con una llanura tail -f yourfile.log

Luego, puede sentarse mirando el registro desplazarse en la ventana 2, y se escuchará un pitido desde la ventana 1 cuando ocurra "algo raro".

screen es increíblemente versátil: recomiendo leerlo.

Puede detener la salida de la memoria intermedia en el comando grep. Ver man grep para más detalles.

Puede canalizar la salida grep en pitido.

El siguiente ejemplo es del hombre beep ...

   As part of a log-watching pipeline

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

Hay muchas cosas buenas en esos manuales. Si tan solo no tuviéramos que leerlos para encontrarlo. ;-)

El comando watch tiene una opción --beep, y también puede establecer el intervalo de sondeo, pero el estándar con 2 segundos debería estar bien

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

Puede usar sed para agregar el control-G de la siguiente manera:

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

o solo en líneas raras, sin usar grep, de la siguiente manera:

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

que dice: en las líneas donde se produce algo raro, s ubstitute todo por el mismo material con el control G-tachuelas en el final, y de impresión (pero no se imprimen las líneas no coincidentes). ¡Funciona genial!

Hm, complicado. ¿Quizás podríamos hacer algo como esto?

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

O en tu caso

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

Sin embargo, parece estar haciendo algo de almacenamiento en búfer. Veré si hay una manera de desactivar este almacenamiento intermedio por forbucle.

Aparentemente, deberías poder ajustar el almacenamiento en búfer de la tubería mediante el uso, ulimit -ppero eso sigue quejándome sobre el argumento no válido para mí. También encontré una publicación que dice que necesitas recompilar el kernel para cambiar este límite.

En un trabajo anterior, no pude conseguir un observador fiable con solo comando-fu, así que tenía un guión envoltorio como la de abajo, que inspeccionó el archivo cada poll_duration segundos y grepped las nuevas líneas para la frase interesados.

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

Esto estaba en una máquina Unix. En Linux, puede ir mejor usando su interfaz inotify filewatcher. Si este paquete ( inotify-tools en Ubuntu) está presente, reemplace

sleep $poll_duration 

con

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

Esta llamada se bloquea hasta que se modifica el archivo. La versión de bloqueo es casi tan eficiente como lo que obtendría con la tail -fversión si la tubería se pudiera configurar para funcionar sin almacenamiento en búfer.

Nota: El script primero hace una head --lines=$new_linecountpara garantizar que las líneas agregadas al archivo después de que lo verifiquemos no sesguen el fragmento del archivo que se verifica en este bucle.