Track
/
Elixir
Elixir
/
Esercizi
/
Parser di log
Parser di log

Parser di log

Esercizio di apprendimento

Introduzione

Espressioni regolari

Le espressioni regolari in Elixir seguono la specifica PCRE (Perl Compatible Regular Expressions), in modo simile ad altri linguaggi diffusi come Java, JavaScript o Ruby.

Il modulo Regex offre funzioni per lavorare con le espressioni regolari. Anche alcune funzioni del modulo String accettano espressioni regolari come argomenti.

Note

Questo esercizio presuppone che tu conosca già la sintassi delle espressioni regolari, incluse classi di caratteri, quantificatori, gruppi e catture.

Se hai bisogno di rinfrescare le tue conoscenze sulle espressioni regolari, dai un'occhiata a una di queste risorse: Regular-Expressions.info, Rex Egg, RegexOne, Regular Expressions 101, RegExr.

Sigils

Il modo più comune per creare espressioni regolari è usare il sigil ~r.

~r/test/

Tieni presente che tutti i sigil di Elixir supportano diversi tipi di delimitatori, non solo /.

Corrispondenze

L'operatore =~/2 può essere usato per eseguire una corrispondenza con un'espressione regolare che restituisce un risultato boolean. In alternativa, ci sono anche le funzioni match?/2 sia nel modulo Regex sia nel modulo String.

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

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

Cattura

Se un semplice controllo booleano non basta, usa la funzione Regex.run/3 per ottenere un array con tutte le catture (o nil se non c'è stata alcuna corrispondenza). Il primo elemento dell'array restituito è sempre una corrispondenza dell'intera espressione regolare, mentre gli elementi successivi sono i gruppi trovati.

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

Modificatori

Il comportamento di un'espressione regolare può essere modificato aggiungendo dei flag speciali. Quando usi un sigil per creare un'espressione regolare, aggiungi i modificatori dopo il secondo delimitatore.

I modificatori più comuni sono:

  • i: rende la corrispondenza non sensibile alle maiuscole e alle minuscole.
  • u: abilita pattern specifici di Unicode come \p e fa sì che classi di caratteri come \w, \s ecc. corrispondano anche ai caratteri Unicode.
"this is a TEST" =~ ~r/test/i
# => true

Istruzioni

In seguito a una recente revisione della sicurezza, ti è stato chiesto di ripulire i file di log archiviati dell'organizzazione.

1. Individuare le righe di log corrotte

Ti serve un'idea di quante righe di log dell'archivio non rispettino gli standard attuali. Ritieni che un semplice test riveli se una riga di log è valida. Per essere considerata valida, una riga deve iniziare con una delle seguenti stringhe:

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

Implementa la funzione valid_line?/1 in modo che restituisca true se la riga di log è valida.

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

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

2. Suddividere la riga di log

Poco dopo aver iniziato il progetto di analisi dei log, ti accorgi che i log di un'applicazione non sono suddivisi in righe come gli altri. In questo progetto, quello che dovrebbe essere su righe separate si trova invece su un'unica riga, collegato da bizzarre frecce come <---> o <*~*~>.

In realtà, qualsiasi stringa che abbia come primo carattere <, come ultimo carattere > e, in mezzo, una qualsiasi combinazione dei seguenti caratteri ~, *, = e - può essere usata come separatore nei log di questo progetto.

Implementa la funzione split_line/1 che prende una riga e restituisce un array di stringhe.

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

3. Rimuovere gli artefatti dal log

Hai scoperto che un'elaborazione a monte dei log ha disseminato il testo «end-of-line» seguito da un numero di riga (senza spazio in mezzo) in tutti i log.

Implementa la funzione remove_artifacts/1 che prende una stringa, rimuove tutte le occorrenze del testo end-of-line (senza distinguere tra maiuscole e minuscole) e restituisce una riga di log pulita.

Le righe che non contengono il testo end-of-line devono essere restituite senza modifiche.

Rimuovi solo la stringa end of line, non serve sistemare gli spazi bianchi.

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

4. Etichettare le righe con i nomi utente

Hai notato che alcune righe di log contengono frasi che si riferiscono agli utenti. Queste frasi contengono sempre la stringa "User", seguita da uno o più caratteri di spazio, e poi da un nome utente. Decidi di etichettare queste righe.

Implementa una funzione tag_with_user_name/1 che elabora le righe di log:

  • Le righe che non contengono la stringa "User" restano invariate.
  • Per le righe che contengono la stringa "User", anteponi alla riga [USER] seguito dal nome utente.
LogParser.tag_with_user_name("[INFO] User Alice created a new project")
# => "[USER] Alice [INFO] User Alice created a new project"

Puoi presumere che:

  • Ogni occorrenza della stringa "User" è seguita da uno o più caratteri di spazio e dal nome utente.
  • C'è al massimo un'occorrenza della stringa "User" in ogni riga.
  • I nomi utente sono stringhe non vuote che non contengono spazi.
Modifica tramite GitHub Il link si apre in una nuova finestra o scheda
Elixir Exercism

Vuoi iniziare Parser di log?

Iscriviti a Exercism per imparare e padroneggiare Elixir con 58 concetti168 esercizi e il mentoring di persone reali, tutto gratis.