Tracks
/
Elixir
Elixir
/
Ejercicios
/
Analizador de logs
Analizador de logs

Analizador de logs

Ejercicio de aprendizaje

Introducción

Expresiones regulares

Las expresiones regulares en Elixir siguen la especificación PCRE (Perl Compatible Regular Expressions), de forma similar a otros lenguajes populares como Java, JavaScript o Ruby.

El módulo Regex ofrece funciones para trabajar con expresiones regulares. Algunas funciones del módulo String también aceptan expresiones regulares como argumentos.

Note

Este ejercicio asume que ya conoces la sintaxis de las expresiones regulares, incluidas las clases de caracteres, los cuantificadores, los grupos y las capturas.

Si necesitas refrescar tus conocimientos sobre expresiones regulares, echa un vistazo a alguna de estas fuentes: Regular-Expressions.info, Rex Egg, RegexOne, Regular Expressions 101, RegExr.

Sigilos

La forma más común de crear expresiones regulares es usando el sigilo ~r.

~r/test/

Ten en cuenta que todos los sigilos de Elixir admiten diferentes tipos de delimitadores, no solo /.

Coincidencias

El operador =~/2 se puede usar para realizar una coincidencia con una expresión regular que devuelve un resultado boolean. Como alternativa, también hay funciones match?/2 en el módulo Regex y en el módulo String.

"this is a test" =~ ~r/test/
# => true

String.match?("Alice has 7 apples", ~r/\d{2}/)
# => false

Capturas

Si una simple comprobación booleana no es suficiente, usa la función Regex.run/3 para obtener una lista de todas las capturas (o nil si no hubo coincidencia). El primer elemento de la lista devuelta siempre es una coincidencia de toda la expresión regular, y los elementos siguientes son los grupos coincidentes.

Regex.run(~r/(\d) apples/, "Alice has 7 apples")
# => ["7 apples", "7"]

Modificadores

El comportamiento de una expresión regular se puede modificar agregando banderas especiales. Cuando usas un sigilo para crear una expresión regular, agrega los modificadores después del segundo delimitador.

Los modificadores más comunes son:

  • i - hace que la coincidencia no distinga entre mayúsculas y minúsculas.
  • u - habilita patrones específicos de Unicode como \p y hace que las clases de caracteres como \w, \s, etc. también coincidan con Unicode.
"this is a TEST" =~ ~r/test/i
# => true

Instrucciones

Después de una revisión de seguridad reciente, te han pedido que limpies los archivos de log archivados de la organización.

1. Identifica las líneas de log corruptas

Necesitas hacerte una idea de cuántas líneas de log de tu archivo no cumplen con los estándares actuales. Crees que una prueba sencilla revela si una línea de log es válida. Para que se considere válida, una línea debe comenzar con uno de los siguientes strings:

  • [DEBUG]
  • [INFO]
  • [WARNING]
  • [ERROR]

Implementa la función valid_line?/1 para que devuelva true si la línea de log es válida.

LogParser.valid_line?("[ERROR] Network Failure")
# => true

LogParser.valid_line?("Network Failure")
# => false

2. Divide la línea de log

Poco después de empezar el proyecto de análisis de logs, te das cuenta de que los logs de una aplicación no están divididos en líneas como los de las demás. En este proyecto, lo que debería haber sido varias líneas separadas aparece en una sola línea, unido por flechas llamativas como <---> o <*~*~>.

De hecho, cualquier string que tenga como primer carácter <, como último carácter >, y cualquier combinación de los siguientes caracteres ~, *, = y - en medio, puede usarse como separador en los logs de este proyecto.

Implementa la función split_line/1 que toma una línea y devuelve una lista de strings.

LogParser.split_line("[INFO] Start.<*>[INFO] Processing...<~~~>[INFO] Success.")
# => ["[INFO] Start.", "[INFO] Processing...", "[INFO] Success."]

3. Elimina los artefactos del log

Has descubierto que un procesamiento previo de los logs ha estado esparciendo por todos los logs el texto «end-of-line» seguido de un número de línea (sin un espacio intermedio).

Implementa la función remove_artifacts/1 que toma un string y elimina todas las apariciones del texto «end-of-line» (sin distinguir mayúsculas y minúsculas) y devuelve una línea de log limpia.

Las líneas que no contengan el texto «end-of-line» deben devolverse sin modificar.

Solo elimina el texto «end-of-line»; no es necesario ajustar los espacios en blanco.

LogParser.remove_artifacts("[WARNING] end-of-line23033 Network Failure end-of-line27")
# => "[WARNING]  Network Failure "

4. Etiqueta las líneas con nombres de usuario

Te has dado cuenta de que algunas de las líneas de log incluyen oraciones que se refieren a usuarios. Estas oraciones siempre contienen el string "User", seguido de uno o más caracteres de espacio en blanco y, después, un nombre de usuario. Decides etiquetar esas líneas.

Implementa una función tag_with_user_name/1 que procesa las líneas de log:

  • Las líneas que no contienen el string "User" permanecen sin cambios.
  • Para las líneas que contienen el string "User", añade al principio de la línea [USER] seguido del nombre de usuario.
LogParser.tag_with_user_name("[INFO] User Alice created a new project")
# => "[USER] Alice [INFO] User Alice created a new project"

Puedes asumir que:

  • Cada aparición del string "User" va seguida de uno o más caracteres de espacio en blanco y del nombre de usuario.
  • Hay como máximo una aparición del string "User" en cada línea.
  • Los nombres de usuario son strings no vacíos que no contienen espacios en blanco.
Editar en GitHub El enlace se abre en una ventana o una pestaña nuevas
Elixir Exercism

¿Todo listo para empezar Analizador de logs?

Regístrate en Exercism para aprender y dominar Elixir con 58 conceptos168 ejercicios y mentoría humana real, todo gratis.