Fernando escribiste:Armé un script en Perl que con la ayuda de uds., que procesa un archivo de LOG (de dansguardian) y va escribiendo en una base de datos. Lo hace en tiempo real. FIFO
Hace lo que quiero que haga. Pero el tema es que tengo permanentemente el micro al 99%.
El problema es que has creado un bucle sin fin, en donde no indicas en ningún sitio (salvo con usleep()) que el procesador puede tomarse un descanso hasta que haya nuevos datos. En cambio, el procesador está volcado en tu tarea, continuamente.
Fernando escribiste:Lo estuve investigando un poco y muchos tienen el mismo problema con este tipo de scripts. Entonces, lo que quiero hacer es otro script, que en lugar de pasar la info a la DB en tiempo real, lo haga cada 1 o 2 minutos (proceso en cron).
El tema es que el archivo puede pesar bastante, y yo necesito ir pasando las diferencias, es decir las últimas líneas, con lo cual debería leer una marca (supongamos MARK1 que puede ser una fecha:hora) y pasar a la base de datos desde ahí hasta el final. Luego vuelvo a poner la marca en el final (o guardo algún dato relevante de la última línea), y cuando se vuelva a ejecutar el script se repetiría el proceso.
Pensé en guardar esa marca en la misma base de datos, pero es irrelevante para el problema en cuestión.
Estuve leyendo un poco cómo hacerlo, pero mi duda es cómo puedo hacer para guardar en memoria (o archivo) para trabajar en el pasaje a la base de datos solamente la parte que necesito, y no todo el archivo.
Y otra duda que tengo es cómo almacenar algún dato (MARK1 o fecha:hora) de la última línea leída para utilizar como marca la próxima vez que se ejecute el script. Probé con un while(), pero las variables del while() no me las toma fuera de éste.
Bueno, sí, esa es una forma de hacerlo, pero la "marca" que normalmente se usa en registros que van creciendo es ir guardando el tamaño del fichero en ese momento. Ejemplo:
- Entramos en el bucle
- Leemos la última posición leída en el registro access.log
- Mirar a ver si esa última posición es menor, mayor o igual que el actual tamaño del registro
- Si son iguales, terminamos el bucle (no hubo cambios)
- Si la última posición leída es mayor que el tamaño del registro, es posible que el registro haya sido inicializado (el servicio del que depende ha sido reinicializado, por ejemplo, o se ha producido una rotación de ficheros de registro). En ese caso, ponemos el valor de posición a 0 y comenzamos a procesar el registro desde el principio
- Sino, es que la última posición leída es menor que el tamaño del fichero. Entonces, abrimos el fichero con open(), nos posicionamos con seek() en la última posición leída, y procesamos el resto del registro
- Una vez terminado de procesar, solo tenemos que guardar la actual posición de lectura del fichero de registro para la siguiente vuelta. Ese dato lo podemos saber con la función tell().
- Repetir bucle
Quedaría pendiente de resolver el caso de qué hacer si se detecta un cambio por rotación de ficheros de registro, y si se debe, o no, procesar las últimas líneas del registro anterior. Por ejemplo, los registros de actividad de Apache, pasan de llamarse access.log a access.log.0, a las 06:30 del domingo. Pueden quedarse algunas líneas sin procesar en el access.log.0. Dependerá de lo vital que sea la información, tendremos que procesarlas o no.
Hay otra forma de resolver esto...
Para estas situaciones en las cuales hay que estar pendiente de la actividad de un registro que va creciendo y/o que puede ir rotando con el tiempo, uso el módulo
File::Tail, que se ocupa de hacer todo lo que hemos comentado antes, y de forma muy cómoda para nosotros.
Al principio del programa hago un listado de los registros que voy a monitorizar:
Using perl Syntax Highlighting
my @ficheros_a_vigilar = qw(
/var/log/exim4/mainlog
/var/log/mail/mail.log
/var/log/syslog
);
Coloreado en 0.001 segundos, usando
GeSHi 1.0.8.4
luego, creo tantos objetos File::Tail como ficheros tengo:
Using perl Syntax Highlighting
my @ft;
for my $fichero (@ficheros_a_vigilar) {
push @ft , File::Tail->new(name => $fichero, debug => $debug);
}
Coloreado en 0.001 segundos, usando
GeSHi 1.0.8.4
entro en el bucle, infinito, naturalmente, y lo primero que hago es llamar a File::Tail para que vigile la actividad de todos los ficheros:
Using perl Syntax Highlighting
...;
while ("forever") { # bucle infinito
my ($nfound,$timeleft,@pending) # File::Tail esperará $timeout segundos por la
= File::Tail::select(undef, undef, undef, $timeout, @ft); # actividad en los ficheros @ft, guardándolos
# en @pending. $nfound indicará cuántos son, y
# $timeleft indica cuántos segundos quedaban
# para el siguiente $timeout
unless ($nfound) { # si no hubo actividad
say "PING" if $debug; # ocurrió un timeout
}
else { # si sí hubo actividad
for (@pending) { # para todos los ficheros con cambios
my $log = $_->{input}; # nombre del fichero con cambios
my $linea = $_->read; # nueva línea del fichero
given ($log) {
when (/mainlog$/) { # si el fichero es mainlog
if ($linea =~ / \[([\d.]+?)\] /o) { # si la línea contiene una '[IP]'
$ip = $1; # nos quedamos con ella
...;
Coloreado en 0.002 segundos, usando
GeSHi 1.0.8.4
Y ya está. No tenemos que preocuparnos de mirar en qué posición está, cada cuánto hay que mirar el registro, etc. Como ves en el código, solo me preocupo de preguntar qué fichero ha cambiado, y a continuación extraigo una línea para procesarla. (El par
given/when y el
say son de Perl v5.10 o superior. El operador
... es de Perl v5.12 o superior.)
File::Tail ajustará los tiempos de lectura según el fichero vaya cambiando: cuantos más cambios, con más frecuencia mirará por más cambios. También, por defecto cada 60 segundos, mirará a ver si el fichero ha sido puesto a cero, y en ese caso, lo volverá a abrir como si empezara de nuevo.
Esta es una forma de usar el módulo. Otra sería usar read() en lugar de select(). El programa quedaría bloqueado hasta que, efectivamente, hubiera una nueva.
Estando en Linux, no tengo miedo a que pase nada raro.