Como 'grep' um fluxo contínuo?

É possível usar grepem um fluxo contínuo?

O que quero dizer é uma espécie de tail -f <file>comando, mas com grepa saída para manter apenas as linhas que me interessam.

Eu tentei, tail -f <file> | grep patternmas parece que grepsó pode ser executado quando tailterminar, ou seja, nunca.

Ative o grepmodo de buffer de linha ao usar o BSD grep (FreeBSD, Mac OS X etc.)

tail -f file | grep --line-buffered my_pattern

Você não precisa fazer isso no GNU grep (usado em praticamente qualquer Linux), pois ele será liberado por padrão (YMMV para outros gostos de Unix, como SmartOS, AIX ou QNX).

Eu uso tail -f <file> | grep <pattern>o tempo todo.

Esperará até que o grep seja liberado, não até que termine (estou usando o Ubuntu).

Eu acho que o seu problema é que o grep usa algum buffer de saída. Tentar

tail -f file | stdbuf -o0 grep my_pattern

ele definirá o modo de buffer de saída do grep como sem buffer.

Se você deseja encontrar correspondências no arquivo inteiro (não apenas no final) e deseja que ele fique aguardando novas correspondências, isso funciona perfeitamente:

tail -c +0 -f <file> | grep --line-buffered <pattern>

O -c +0sinalizador diz que a saída deve iniciar 0bytes ( -c) desde o início ( +) do arquivo.

Na maioria dos casos, você pode tail -f /var/log/some.log |grep fooe funcionará bem.

Se você precisar usar vários greps em um arquivo de log de execução e você achar que você tem nenhuma saída, pode ser necessário furar o --line-bufferedinterruptor em seu meio grep (s), assim:

tail -f /var/log/some.log | grep --line-buffered foo | grep bar

você pode considerar esta resposta como aprimoramento .. geralmente estou usando

tail -F <fileName> | grep --line-buffered  <pattern> -A 3 -B 5

-F é melhor no caso de rotação do arquivo (-f não funcionará corretamente se o arquivo for girado)

-A e -B é útil para obter linhas imediatamente antes e após a ocorrência do padrão. Esses blocos aparecerão entre os separadores de linhas tracejadas

Mas para mim eu prefiro fazer o seguinte

tail -F <file> | less

isso é muito útil se você deseja pesquisar dentro de logs transmitidos. Quero dizer, voltar e avançar e olhar profundamente

Não vi ninguém oferecer o meu aval habitual para isso:

less +F <file>
ctrl + c
/<search term>
<enter>
shift + f

Eu prefiro isso, porque você pode usar ctrl + cpara parar e navegar pelo arquivo sempre que quiser e depois pressionar shift + fpara retornar à pesquisa de transmissão ao vivo.

sed seria uma escolha melhor ( editor de stream )

tail -n0 -f <file> | sed -n '/search string/p'

e, se você quiser que o comando tail saia, depois de encontrar uma sequência específica:

tail --pid=$(($BASHPID+1)) -n0 -f <file> | sed -n '/search string/{p; q}'

Obviamente, um basismo: $ BASHPID será o ID do processo do comando tail. O comando sed é o próximo após a cauda no pipe, portanto, o ID do processo sed será $ BASHPID + 1.

Sim, isso realmente funcionará bem. Grepe a maioria dos comandos Unix opera em fluxos uma linha por vez. Cada linha que sai da cauda será analisada e transmitida se corresponder.

Este comando funciona para mim (Suse):

mail-srv:/var/log # tail -f /var/log/mail.info |grep --line-buffered LOGIN  >> logins_to_mail

coletando logons no serviço de correio

você certamente não terá sucesso com

tail -f /var/log/foo.log |grep --line-buffered string2search

quando você usa "colortail" como um pseudônimo para cauda, ​​por exemplo. na festança

alias tail='colortail -n 30'

você pode verificar por tipo de alias se isso gera algo como tail isan alias of colortail -n 30 . então você tem o seu culpado :)

Solução:

remova o alias com

unalias tail

verifique se você está usando o binário real 'real' por este comando

type tail

que deve gerar algo como:

tail is /usr/bin/tail

e então você pode executar seu comando

tail -f foo.log |grep --line-buffered something

Boa sorte.

Use awk (outro ótimo utilitário bash) em vez de grep, onde você não tem a opção de buffer de linha! Ele transmitirá continuamente seus dados da cauda.

é assim que você usa grep

tail -f <file> | grep pattern

É assim que você usaria o awk

tail -f <file> | awk '/pattern/{print $0}'