Rutas
/
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 de las funciones del módulo String también aceptan expresiones regulares como argumentos.

Note

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

Si necesitas repasar 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 habitual de crear expresiones regulares es usar el sigilo ~r.

~r/test/

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

Coincidencias

El operador =~/2 sirve para comprobar si hay coincidencia con una expresión regular y devuelve un resultado boolean. Como alternativa, también hay funciones match?/2 tanto en el módulo Regex como 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 con todas las capturas (o nil si no hubo ninguna coincidencia). El primer elemento de la lista devuelta siempre es la coincidencia con toda la expresión regular, y los elementos siguientes son los grupos que coincidieron.

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

Modificadores

El comportamiento de una expresión regular se puede modificar añadiendo modificadores especiales. Cuando uses un sigilo para crear una expresión regular, añade los modificadores después del segundo delimitador.

Los modificadores más habituales 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 caracteres Unicode.
"this is a TEST" =~ ~r/test/i
# => true

Instrucciones

Tras una reciente revisión de seguridad, te han pedido que limpies los archivos de registro archivados de la organización.

1. Identifica las líneas de registro corruptas

Necesitas hacerte una idea de cuántas líneas de registro de tu archivo no cumplen los estándares actuales. Crees que una prueba sencilla revela si una línea de registro es válida. Para que se considere válida, una línea debe empezar por 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 registro es válida.

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

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

2. Divide la línea de registro

Poco después de empezar el proyecto de análisis de registros, te das cuenta de que los registros de una aplicación no están divididos en líneas como los de las demás. En este proyecto, lo que deberían haber sido líneas separadas está en una sola línea, conectado 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 registros de este proyecto.

Implementa la función split_line/1, que recibe una línea y devuelve un array de strings.

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

3. Elimina los artefactos del registro

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

Implementa la función remove_artifacts/1 para que reciba un string y elimine todas las apariciones del texto end-of-line (sin distinguir mayúsculas de minúsculas), y devuelva una línea de registro limpia.

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

Solo hay que eliminar 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 registro incluyen frases que se refieren a usuarios. Estas frases siempre contienen el string "User", seguido de uno o más caracteres de espacio en blanco y, a continuación, un nombre de usuario. Decides etiquetar esas líneas.

Implementa una función tag_with_user_name/1 que procese las líneas de registro:

  • Las líneas que no contengan el string "User" permanecen sin cambios.
  • En las líneas que contengan 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 dar por supuesto 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 pestaña nueva
Elixir Exercism

¿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.