Parcours
/
Elixir
Elixir
/
Exercices
/
Analyseur de logs
Analyseur de logs

Analyseur de logs

Exercice d'apprentissage

Introduction

Expressions régulières

En Elixir, les expressions régulières suivent la spécification PCRE (Perl Compatible Regular Expressions), comme dans d'autres langages populaires tels que Java, JavaScript ou Ruby.

Le module Regex offre des fonctions pour travailler avec les expressions régulières. Certaines fonctions du module String acceptent également des expressions régulières en argument.

Note

Cet exercice suppose que tu connais déjà la syntaxe des expressions régulières, y compris les classes de caractères, les quantificateurs, les groupes et les captures.

Si tu as besoin de rafraîchir tes connaissances sur les expressions régulières, consulte l'une de ces ressources : Regular-Expressions.info, Rex Egg, RegexOne, Regular Expressions 101, RegExr.

Sigils

La façon la plus courante de créer des expressions régulières est d'utiliser le sigil ~r.

~r/test/

Note que tous les sigils d'Elixir prennent en charge différents types de délimiteurs, pas seulement /.

Correspondance

L'opérateur =~/2 permet d'effectuer une correspondance d'expression régulière qui renvoie un résultat boolean. Il existe aussi, en alternative, des fonctions match?/2 dans le module Regex ainsi que dans le module String.

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

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

Capture

Si une simple vérification booléenne ne suffit pas, utilise la fonction Regex.run/3 pour obtenir un tableau de toutes les captures (ou nil s'il n'y a pas de correspondance). Le premier élément du tableau renvoyé correspond toujours à l'expression régulière entière, et les éléments suivants sont les groupes correspondants.

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

Modificateurs

Le comportement d'une expression régulière peut être modifié en ajoutant des options spéciales. Pour créer une expression régulière avec un sigil, ajoute les modificateurs après le second délimiteur.

Les modificateurs courants sont :

  • i : la correspondance ne tient pas compte de la casse.
  • u : active les motifs propres à Unicode comme \p et fait que les classes de caractères telles que \w, \s, etc. correspondent aussi aux caractères Unicode.
"this is a TEST" =~ ~r/test/i
# => true

Instructions

À la suite d'un récent audit de sécurité, on t'a demandé de nettoyer les fichiers de log archivés de l'organisation.

1. Identifie les lignes de log brouillées

Tu dois te faire une idée du nombre de lignes de log de ton archive qui ne respectent pas les normes actuelles. Tu penses qu'un test simple permet de savoir si une ligne de log est valide. Pour être considérée comme valide, une ligne doit commencer par l'une des strings suivantes :

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

Implémente la fonction valid_line?/1 pour qu'elle renvoie true si la ligne de log est valide.

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

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

2. Sépare la ligne de log

Peu après avoir commencé le projet d'analyse de logs, tu te rends compte que les logs d'une application ne sont pas découpés en lignes comme les autres. Dans ce projet, ce qui aurait dû former plusieurs lignes se retrouve sur une seule ligne, relié par d'étranges flèches comme <---> ou <*~*~>.

En fait, toute string qui commence par <, se termine par > et contient entre les deux n'importe quelle combinaison des caractères ~, *, = et - peut servir de séparateur dans les logs de ce projet.

Implémente la fonction split_line/1 qui prend une ligne et renvoie un tableau de strings.

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

3. Supprime les artefacts du log

Tu as découvert qu'un traitement en amont des logs a parsemé les logs du texte « end-of-line » suivi d'un numéro de ligne (sans espace intermédiaire).

Implémente la fonction remove_artifacts/1 qui prend une string et supprime toutes les occurrences du texte « end-of-line » (sans tenir compte de la casse), puis renvoie une ligne de log propre.

Les lignes qui ne contiennent pas de texte « end-of-line » doivent être renvoyées sans modification.

Supprime simplement la string « end-of-line », il n'est pas nécessaire d'ajuster les espaces.

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

4. Marque les lignes avec les noms d'utilisateur

Tu as remarqué que certaines lignes de log contiennent des phrases qui font référence à des utilisateurs. Ces phrases contiennent toujours la string "User", suivie d'un ou plusieurs caractères d'espacement, puis d'un nom d'utilisateur. Tu décides de marquer ces lignes.

Implémente une fonction tag_with_user_name/1 qui traite les lignes de log :

  • Les lignes qui ne contiennent pas la string "User" restent inchangées.
  • Pour les lignes qui contiennent la string "User", préfixe la ligne avec [USER] suivi du nom d'utilisateur.
LogParser.tag_with_user_name("[INFO] User Alice created a new project")
# => "[USER] Alice [INFO] User Alice created a new project"

Tu peux supposer que :

  • Chaque occurrence de la string "User" est suivie d'un ou plusieurs caractères d'espacement et du nom d'utilisateur.
  • Il y a au plus une occurrence de la string "User" par ligne.
  • Les noms d'utilisateur sont des strings non vides qui ne contiennent pas d'espace.
Modifie via GitHub Le lien s'ouvre dans une nouvelle fenêtre ou un nouvel onglet
Elixir Exercism

Prêt à commencer Analyseur de logs ?

Inscris-toi sur Exercism pour apprendre et maîtriser Elixir avec 58 concepts168 exercices, et un vrai mentorat humain, le tout gratuitement.