tablas - Análisis de archivo de registro en R?

tablas de datos en r

Question

Sé que hay otras herramientas, como awstats o splunk, pero me pregunto si hay algún análisis serio (web) del archivo de registro del servidor en R. Puede que no sea el primer pensamiento en hacerlo en R, pero aún así R tiene una buena visualización Capacidades y también agradables paquetes espaciales. ¿Sabes de alguno? ¿O hay un paquete / código de R que maneja los formatos de archivo de registro más comunes en los que se podría construir? ¿O es simplemente una muy mala idea?

Answer 1

De hecho, es una excelente idea. R también tiene muy buenas capacidades de fecha / hora, puede hacer análisis de conglomerados o usar cualquier variedad de alogoritmos de aprendizaje automático, tiene tres motores de expresiones regulares diferentes para analizar, etc. pp.

Y puede que no sea una idea novedosa. Hace unos años, tuve un breve contacto por correo electrónico con alguien que usaba R para el análisis proactivo (en lugar de reactivo) del archivo de registro: Lea los registros, (en su caso) construya modelos de series de tiempo, predice los puntos críticos. Eso es tan obviamente una buena idea. Era uno de los laboratorios del Departamento de Energía, pero ya no tengo una URL. Incluso fuera de los patrones temporales hay mucho que se podría hacer aquí.

Answer 2

En relación con un proyecto para crear una caja de herramientas de análisis para nuestros usuarios de Network Ops, construí uno de estos hace aproximadamente dos meses. Mi empleador no tiene problemas si lo abro, por lo que si alguien está interesado puedo ponerlo en mi repositorio de github. Supongo que es más útil para este grupo si construyo un paquete R. Sin embargo, no podré hacerlo de inmediato porque necesito investigar los documentos sobre la creación de paquetes con código no R (podría ser tan simple como lanzar los archivos de código de bytes de python en / exec junto con un tiempo de ejecución Python adecuado, pero no tengo idea).

Realmente me sorprendió que necesitaba emprender un proyecto de este tipo. Hay al menos varios analizadores / visores excelentes de código abierto y de registro libre (incluidos el excelente Webalyzer y AWStats) pero ninguno analiza los registros de errores del servidor (el análisis de los registros de acceso del servidor es el principal caso de uso para ambos).

Si no está familiarizado con los registros de errores o con la diferencia entre ellos y los registros de acceso, en resumen, los servidores Apache (likewsie, nginx e IIS) registran dos registros distintos y los almacenan en el disco de forma predeterminada uno al lado del otro en el mismo directorio. En Mac OS X, ese directorio en / var, justo debajo de la raíz:

$> pwd
   /var/log/apache2

$> ls
   access_log   error_log

Para los diagnósticos de red, los registros de errores suelen ser mucho más útiles que los registros de acceso. También resultan ser mucho más difíciles de procesar debido a la naturaleza no estructurada de los datos en muchos de los campos y, lo que es más importante, porque el archivo de datos que queda después del análisis es una serie de tiempo irregular. Es posible que tenga varias entradas con clave a una sola marca de tiempo, la siguiente entrada es tres segundos más tarde, y así sucesivamente.

Quería que una aplicación que pudiera incluir en los registros de errores en bruto (de cualquier tamaño, pero por lo general varios cientos de MB a la vez) tuviera algo útil que saliera por el otro extremo, que en este caso tenía que ser un análisis preempaquetado. también un cubo de datos disponible dentro de R para análisis de línea de comando. Dado esto, codifiqué el analizador de registro sin procesar en python, mientras que el procesador (por ejemplo, reticulando la salida del analizador para crear una serie de tiempo regular) y todos los análisis y visualización de datos, codifiqué en R.

He estado desarrollando herramientas de análisis durante mucho tiempo, pero solo en los últimos cuatro años he estado usando R. Así que mi primera impresión: inmediatamente después de analizar un archivo de registro sin procesar y cargar el marco de datos en R, es un placer R es para trabajar y cómo es tan adecuado para tareas de este tipo. Unas cuantas sorpresas bienvenidas:

• Serialización . Persistir datos de trabajo en R es un solo comando (guardar). Sabía esto, pero no sabía cuán eficiente es este formato binario. Los datos reales: por cada 50 MB de archivos de registro sin procesar analizados, la representación de .RData fue de aproximadamente 500 KB - 100: 1 compresión. (Nota: empujé esto hacia abajo a cerca de 300: 1 usando la biblioteca data.table y configurando manualmente el argumento del nivel de compresión para la función de guardar);

• IO . Mi Data Warehouse se basa en gran medida en un servidor de estructura de datos ligero que reside completamente en la RAM y escribe en el disco de forma asíncrona, llamado redis. El proyecto en sí tiene solo unos dos años, sin embargo, ya existe un cliente redis para R en CRAN (por BW Lewis, versión 1.6.1 a partir de este post);

• Análisis de datos primarios . El propósito de este proyecto era construir una biblioteca para que la usen nuestros chicos de Network Ops. Mi objetivo era una interfaz tipo "un comando = una vista de datos". Así, por ejemplo, utilicé el excelente Paquete de GoogleVis para crear tablas HTML con desplazamiento / paginación de aspecto profesional con columnas clasificables, en las que cargué un marco de datos de datos agregados (> 5,000 líneas). Solo esos pocos elementos interactivos, por ejemplo, clasificar una columna, brindaron análisis descriptivos útiles. Otro ejemplo es que escribí muchos envoltorios delgados sobre algunos malabarismos de datos básicos y funciones de mesa; Cada una de estas funciones, por ejemplo, estaría vinculada a un botón en el que se puede hacer clic en una página web con pestañas. Nuevamente, fue un placer hacer esto en R, en parte debido a que a menudo la función no requería envoltura, el comando único con los argumentos proporcionados fue suficiente para generar una vista útil de los datos.

Un par de ejemplos de la última bala:

# what are the most common issues that cause an error to be logged?

err_order = function(df){
    t0 = xtabs(~Issue_Descr, df)
    m = cbind( names(t0), t0)
    rownames(m) = NULL
    colnames(m) = c("Cause", "Count")
    x = m[,2]
    x = as.numeric(x)
    ndx = order(x, decreasing=T)
    m = m[ndx,]
    m1 = data.frame(Cause=m[,1], Count=as.numeric(m[,2]),
                    CountAsProp=100*as.numeric(m[,2])/dim(df)[1])
    subset(m1, CountAsProp >= 1.)
}

# calling this function, passing in a data frame, returns something like:


                        Cause       Count    CountAsProp
1  ''connect to unix://var/ failed''    200        40.0
2  ''object buffered to temp file''     185        37.0
3  ''connection refused''                94        18.8

El cubo de datos principal que se muestra para el análisis interactivo utilizando googleVis :



Una tabla de contingencia (de una llamada a la función xtab) mostrada usando googleVis)

Answer 3

He utilizado R para cargar y analizar archivos de registro de IIS con cierto éxito. Aquí está mi código.

Load IIS Log files
require(data.table)

setwd("Log File Directory")

# get a list of all the log files
log_files <- Sys.glob("*.log")

# This line
# 1) reads each log file
# 2) concatenates them
IIS <- do.call( "rbind", lapply( log_files,  read.csv, sep = " ", header = FALSE, comment.char = "#", na.strings = "-" ) )

# Add field names - Copy the "Fields" line from one of the log files :header line 
colnames(IIS) <- c("date", "time", "s_ip", "cs_method", "cs_uri_stem", "cs_uri_query", "s_port", "cs_username", "c_ip", "cs_User_Agent", "sc_status", "sc_substatus", "sc_win32_status", "sc_bytes", "cs_bytes", "time-taken")

#Change it to a data.table
IIS <- data.table( IIS )

#Query at will
IIS[, .N, by = list(sc_status,cs_username, cs_uri_stem,sc_win32_status) ]

Answer 4

Hice un análisis de archivo de registro recientemente utilizando R. No era una cosa realmente compleja, en su mayoría tablas descriptivas. Las funciones integradas de R eran suficientes para este trabajo.
El problema fue el almacenamiento de datos, ya que mis archivos de registro tenían aproximadamente 10 GB. Revolutions R ofrece nuevos métodos para manejar datos tan grandes, pero finalmente decidí usar una base de datos MySQL como backend (lo que en realidad redujo el tamaño a 2 GB a pesar de la normalización).
Eso también podría resolver su problema al leer los archivos de registro en R.

Answer 5

#!python

import argparse
import csv
import cStringIO as StringIO

class OurDialect:
    escapechar = '',''
    delimiter = '' ''
    quoting = csv.QUOTE_NONE


parser = argparse.ArgumentParser()
parser.add_argument(''-f'', ''--source'', type=str, dest=''line'', default=[[''''''54.67.81.141 - - [01/Apr/2015:13:39:22 +0000] "GET / HTTP/1.1" 502 173 "-" "curl/7.41.0" "-"''''''], [''''''54.67.81.141 - - [01/Apr/2015:13:39:22 +0000] "GET / HTTP/1.1" 502 173 "-" "curl/7.41.0" "-"'''''']])
arguments = parser.parse_args()

try:
    with open(arguments.line, ''wb'') as fin:
        line = fin.readlines()
except: 
    pass
finally:
    line = arguments.line

header = [''IP'', ''Ident'', ''User'', ''Timestamp'', ''Offset'', ''HTTP Verb'', ''HTTP Endpoint'', ''HTTP Version'', ''HTTP Return code'', ''Size in bytes'', ''User-Agent'']

lines = [[l[:-1].replace(''['', ''"'').replace('']'', ''"'').replace(''"'', '''') for l in l1] for l1 in line]

out = StringIO.StringIO()

writer = csv.writer(out)
writer.writerow(header)

writer = csv.writer(out,dialect=OurDialect)
writer.writerows([[l1 for l1 in l] for l in lines])

print(out.getvalue())

Salida de demostración:

IP,Ident,User,Timestamp,Offset,HTTP Verb,HTTP Endpoint,HTTP Version,HTTP Return code,Size in bytes,User-Agent
54.67.81.141, -, -, 01/Apr/2015:13:39:22, +0000, GET, /, HTTP/1.1, 502, 173, -, curl/7.41.0, -
54.67.81.141, -, -, 01/Apr/2015:13:39:22, +0000, GET, /, HTTP/1.1, 502, 173, -, curl/7.41.0, -

Este formato se puede leer fácilmente en R usando read.csv. Y, no requiere ninguna biblioteca de terceros.