Cómo comprimir y limpiar registros con logrotate pero no rotarlos

Tengo un servidor Tomcat que crea registros de acceso a través de una válvula ( org.apache.catalina.valves.FastCommonAccessLogValve ). Esta válvula se encarga de rotar el archivo de registro de acceso, pero no de comprimirlos o eliminarlos después de un tiempo.

Por el momento, tengo un trabajo cron que se usa find [...] -mtime +30 [...]para comprimir y eliminar los registros. Prefiero usar logrotate, para que la rotación de registros esté en un lugar centralizado para todos los registros. No me gusta tener una solución separada solo para Tomcat.

Traté de leer la documentación de logrotate, pero todavía estoy un poco perdido. ¿Puedo usar logrotate solo para comprimir y limpiar archivos de registro? Como podría hacerlo ?

O para resolver el problema, ¿hay una válvula de registro de acceso de Tomcat que comprima y limpie los archivos de registro?

Gracias por tu ayuda !

Uno bastante simple que he visto funciona así.

Cree un archivo en /etc/logrotate.d llamado tomcat que contenga lo siguiente: -

/var/log/tomcat/catalina.out { 
  copytruncate 
  daily 
  rotate 7 
  compress 
  missingok 
}

Esto se ejecuta a diario , comprime el archivo y mantiene el valor de 7 días ( rotar 7 ). copytruncate significa que copiará y truncará el archivo original para que no sea necesario reiniciar tomcat. faltar ok no producirá errores si no está allí.

La válvula access.log se puede cambiar para que no gire agregando rotatable = false: -

<Valve className="org.apache.catalina.valves.AccessLogValve
     ...
     ...
     suffix="log" rotatable="false" />

Secuencia de comandos de TimP modificada: se agregaron eliminando archivos muy antiguos, se agregó análisis para archivos comprimidos antiguos.

#!/bin/bash
#
# TPP 2013-02-21
# RJK 2014-08-14
#
# Tomcat apps use a variety of loggers, mostly log4j.
# These rotate, conflicting with logrotate, the unix log rotation system.
#
# Some files eg catalina.out
# are rotated to a backup containing a date eg catalina.2013-01-06.log
# which can then be compressed with bz2 to catalina.2013-01-06.log.bz2
# or removed if older than a given number of days(MTIME).
#
cd /var/log/tomcat6
# 2013-02-21
DATE=`date --rfc-3339=date`
YEAR=`date +%Y`
MILLENIUM=20
# 2014-08-14
MTIME=14
# 2014-08-14
#for f in $(find catalina* |grep -v bz2 |grep -v '$DATE' |grep $YEAR)
for f in $(find catalina* |grep -v bz2 |grep -v '$DATE' |grep $MILLENIUM)
do
 # 2014-08-14
 if test `find $f -mtime +$MTIME`
 then
   echo "rm -f $f"
   rm -f $f
 else
   echo "bzip2 $f"
   bzip2 $f
 fi
done
# However others are active whilst containing a date
# so we will find all and not compress the most recent
for l in 'localhost*' 'opt-db*' 'opt*' 'host-manager*' 'manager*'
do
 export previous=
 for f in $(find $l |grep -v bz2 |sort)
 do
  if [ "${previous}" != "" ]
  then
    echo "bzip2 ${previous}"
    bzip2 $previous
  fi
  export previous=$f
 done
done
# 2014-08-14
for f in $(find *bz2)
do
 if test `find $f -mtime +$MTIME`
 then
   echo "rm -f $f"
   rm -f $f
 fi
done
exit 0 

No deseaba cambiar la configuración de Tomcat, así que creé un script que comprimía los archivos rotados

#! / bin / bash
# #
# TPP 2013-02-21
# #
# Las aplicaciones de Tomcat utilizan una variedad de registradores, principalmente log4j.
# Estos giran, en conflicto con logrotate, el sistema de rotación de registros de Unix. 
# #
# Algunos archivos, p. Ej. Catalina.out
# se rotan a una copia de seguridad que contiene una fecha, p. ej. catalina.2013-01-06.log
# que luego se puede comprimir con bz2 a catalina.2013-01-06.log.bz2
# #

cd / var / log / tomcat6

# 2013-02-21
FECHA = `fecha --rfc-3339 = fecha`
AÑO = `fecha +% Y`

para f en $ (busque catalina * | grep -v bz2 | grep -v '$ DATE' | grep $ YEAR)
hacer
 echo "bzip2 $ f" 
 bzip2 $ f
hecho

# Sin embargo, otros están activos mientras contienen una fecha
# así que encontraremos todo y no comprimiremos el más reciente
para l en 'localhost *' 'opt-db *' 'opt *' 'host-manager *' 'manager *'
hacer
 export anterior =
 para f en $ (encuentre $ l | grep -v bz2 | sort)
 hacer
  si ["$ {anterior}"! = ""]
  luego
    echo "bzip2 $ {anterior}" 
    bzip2 $ anterior
  fi
  export anterior = $ f
 hecho
hecho

salida 0

Es sorprendentemente simple. Solo dígale a logrotate qué archivos desea rotar específicamente. nocreatele dice a logrotate que no vuelva a crear un archivo vacío después de mover el antiguo (si está rotando archivos en una subcarpeta).

/var/log/tomcat/catalina.out.* { 
  daily 
  nocreate
  compress 
  missingok 
}

Para la compresión local_access_log.YYYY-MM-DD.txt escribí este script después de ver esta publicación: -

#!/bin/bash
#
# If Tomcat uses server.xml config to rotate localhost_access_log,
# the daily rotated logs will need compressing and old ones deleted to stop filling
# the log partiton. Cannot use the system logrotate command as conficts with tomcat rotate
# therefore run this script in a daily cronjob
#
# localhost_access_log.2015-09-03.txt
#
# Add this script in /etc/cron.daily/ owned by root
#

CATALINA_BASE=`ps aux | grep catalina.base | awk -F'catalina.base\=' '{print $2}' | awk '{print $1}'`

if [ ! $CATALINA_BASE ]
then
    if [ -r /var/lib/tomcat8 ]
    then
        CATALINA_BASE=/var/lib/tomcat8
    else
        echo "Error: cannot find CATALINA_BASE"
        exit 1
    fi
fi

cd ${CATALINA_BASE}/logs

if [ $? -ne 0 ]
then
    echo "Error, cannot cd to logs directory, quitting...."
    exit 1
fi

# today's date (not to be gzipped)
DATE=`date --rfc-3339=date`
# number of days to keep
MTIME=28

# Compress all previous days uncompressed logs
for log in `ls localhost_access_log* | grep -v bz2 | grep -v $DATE`
do
    bzip2 $log
done

# delete old logs
find . -name "*.bz2" -mtime +$MTIME -exec rm {} \;

exit 0

Una solución simple proporcionada aquí. Esto también incluye la opción de carga s3.

https://yottabrain.org/tomcat/tomcat-log-backup/