criar log com limite de linhas

Boa tarde VoL \../ 0.0 \../
Estou criando um log bem simples, grava tudo que um comando está fazendo, exemplo:

sudo wvdial conexao 1>> /home/usuario/log_wvdial.log 2>&1

Então, tudo que se passar no wvdial será gravado em log_wvdial.log, mas eu gostaria de melhorá-lo, gostaria de, exemplo, quando o log escrever a linha de numero 100, ele ir apagando as primeiras linhas, ou seja, manter sómente as últimas 100 linhas gravadas no log, como eu faria isso?
Abraços, Lucas.

Acho que achei uma solução:

while true
do
tail -n 100 /home/usuario/log.txt > /home/usuario/log_tmp.txt
cp /home/usuario/log_tmp.txt /home/usuario/log.txt
sleep 1
done

Pronto, agora meu log sempre terá 100 linhas, as vezes algumas linhas a mais. mas no meu caso não precisa de ser 100 linhas exatas. Criei um script que gera linhas em um arquivo, testei e funcionou 100%.
Mas ainda aceito idéias melhores. :-)
Abraços.

Olá @lucasdona , se puder colaborar e testar esta solução ;)


#!/bin/bash
#
# logmaneiro.sh
#-----------------------------------------------------------------------------
# Como usar: Salve o Script onde desejar. Se for na própria pasta vide abaixo.
# source logmaneiro.sh
# Na hora de gravar o seu log, faça uma chamada apenas, vide abaixo:
# _grv_log "nomedoseu.log" "SuaVariavelComDadosDoBlog"
# Mais detalhes no final.

_TOTAL_MAX_LINHAS="75"
_TMP_TOT_LINHAS="0"
_LOG="nomedoseu.log" # Nome do log oficial
_TMP_LOG_COPIA="/tmp/tmp_log_wvdial.$$" #Temporário de trabalho.
_TMP_BKP_LOG="/tmp/tmp_log_wvdial.log" # Posição anterior.
_MEU_TEXTO_DO_LOG="$2"


# Testa para ter certeza que o arquivo de log está em condições.
[ -e "$_LOG" ] || {
echo "Onde está o arquivo do log $LOG ? "
return 1
}

# Testa permissões do arquivo de log.
[ -r "$_LOG" -a -w "$_LOG" ] || {
echo -e "Arquivo de log precisa de todas permissões ou estará na lama"
read
return 1
}

# Confere se o nome do arquivo de log está correto.
function _conf_nome_log {

[ "$1" ] && _LOG="$1" || {
echo -e "Putz, errou o nome do log. Confira: $_LOG "
read
return 1
}
}

# Verifica se foi passado um texto para gravar o LOG.
function _conf_texto_log {

[ "$2" ] && _MEU_TEXTO_DO_LOG="$2" || {
echo "A coisa tá feia, não passou os dados pra gravar no log."
read
return 1
}
}

# Efetiva gravação dentro do LOG.
function _gravando {

# Eba, gravando $2 no danado $_LOG."
echo "$2" >> $_LOG
}

# Se tudo andou bem, faz a gravação do LOG com verificações.
function _grv_log {

# Confere se o nome está ok.
if [ _conf_nome_log = 1 ]; then return 1; fi

# Confere se passou o texto pra gravar o log.
if [ _conf_texto_log = 1 ]; then return 1; fi

# Se chegou até aqui é porque pode gravar $2 no log.
_gravando "$1" "$2"

# Vai apagar as linhas desnecessárias.
_apaga_linhas $_LOG
}

# Faz apenas a verificação do total de linhas. Útil para usar em separado.
function _log_linhas {

# Verifica a quantidade de linhas em $_LOG "
_TMP_TOT_LINHAS=$(cat $_LOG | wc -l)
}

# Efetivamente apagará as linhas. Antes verifica se será necessário.
function _apaga_linhas {

# Pega quantas linhas tem no log.
_log_linhas
if [ $_TMP_TOT_LINHAS -le $_TOTAL_MAX_LINHAS ]; then return 1;fi

#Salvando um backup antes da gravação final de limpeza.
cp "${_LOG}" "${_TMP_BKP_LOG}"

# Pega o total máximo do arq $_LOG e copia em $_TMP_LOG_COPIA "
tail -n ${_TOTAL_MAX_LINHAS} "${_LOG}" > ${_TMP_LOG_COPIA}

# Copia resultado $_TMP_LOG_COPIA para o arquivo $_LOG "
cp "${_TMP_LOG_COPIA}" "$_LOG"

# Remove arquivo temporário _TMP_LOG_COPIA
rm -f "${_TMP_LOG_COPIA}"

}

# O problema:
# Gravar todos os logs de um determinado comando.
# Este log deve ter no máximo X número linhas. (pode virar parâmetro)
# Quando gravar a linha X número, eliminar a mais antiga. (a 1ª linha)
# Recebe a linha a ser gravada. (Faz a gravação no log)
# grava a linha.
# calcula para saber se já tem + de X linhas. (vide _TOTAL_MAX_LINHAS )
# Se tiver , pica o pau na primeira linha que é a mais antiga.
# variáveis de controle devem estar em outro local.
# Foram colocadas no início da lib para facilitar.
# Grava o log sem QUASE fazer delongas.
# 1º parâmetro é obrigatório o nome do log.
# Assim poderá usar este POG em outros locais que desejar.
# Evoluções que poderiam ser feitas.
# Adicionar mais um parâmetro (3º) para forçar verificação de linhas.
# Se ele for adicionado, poderia alterar a function _grv_log na questão
# do _apaga_linhas. Assim ele poderá funcionar com um gravador de LOGS.
# E somente vai fazer o lance do apaga linhas quando desejar.
# _TOTAL_MAX_LINHAS poderia vir de outro local.
# _TMP_TOT_LINHAS usado somente com inicialização "0"
# _LOG="nomedoseu.log" Não pode falhar nem a paulada.
# _TMP_LOG_COPIA será o nosso temporário com base no processo atual.
# _TMP_BKP_LOG é um backup da posição antes das gravações. Pode ser retirado.
# _MEU_TEXTO_DO_LOG é obrigatório com sendo o 2º parâmetro.
# Se gostou, faça o seu boneco fazia, vá pra galera :)
# Qualquer BUG eu não sei quem vai te ajudar rsrs estou aprendendo.
# Só tentei vender a ideia que vale a pena fazer código reaproveitável.
# Lembrando que neste caso é apenas parcial. Tem depêndencias.
# Como lição de casa, poderia tentar alterar ele para deixar 100% portável.

Correr pra galera, seu boneco. http://www.youtube.com/watch?v=Toylh9nQn0c&feature=related

@AprenbdiNoLinux @Ga_Tux

oops: Testado em zsh usando a função autoload e não source usado em bash. Trabalhou muito bem. :)

https://twitter.com/#!/AprendiNoLinux/status/103490741757689856