Percursos
/
Elixir
Elixir
/
Exercícios
/
Analisador de logs
Analisador de logs

Analisador de logs

Exercício de aprendizagem

Introdução

Expressões regulares

As expressões regulares em Elixir seguem a especificação PCRE (Perl Compatible Regular Expressions), tal como acontece noutras linguagens populares, como Java, JavaScript ou Ruby.

O módulo Regex oferece funções para trabalhar com expressões regulares. Algumas das funções do módulo String também aceitam expressões regulares como argumentos.

Note

Este exercício assume que já conheces a sintaxe das expressões regulares, incluindo classes de carateres, quantificadores, grupos e capturas.

Se precisares de refrescar os teus conhecimentos de expressões regulares, consulta uma destas fontes: Regular-Expressions.info, Rex Egg, RegexOne, Regular Expressions 101, RegExr.

Sigilos

A forma mais comum de criar expressões regulares é usar o sigilo ~r.

~r/test/

Repara que todos os sigilos de Elixir suportam diferentes tipos de delimitadores, não apenas /.

Correspondência

O operador =~/2 pode ser usado para fazer uma correspondência de expressão regular que devolve um resultado boolean. Em alternativa, também existem as funções match?/2 no módulo Regex e no módulo String.

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

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

Captura

Se uma simples verificação boolean não for suficiente, usa a função Regex.run/3 para obteres uma lista com todas as capturas (ou nil se não houver correspondência). O primeiro elemento da lista devolvida corresponde sempre a toda a expressão regular, e os elementos seguintes são os grupos correspondidos.

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

Modificadores

O comportamento de uma expressão regular pode ser alterado acrescentando flags especiais. Quando usas um sigilo para criar uma expressão regular, adiciona os modificadores depois do segundo delimitador.

Os modificadores mais comuns são:

  • i - faz com que a correspondência não distinga maiúsculas de minúsculas.
  • u - ativa padrões específicos de Unicode como \p e faz com que as classes de carateres como \w, \s, etc. também correspondam a Unicode.
"this is a TEST" =~ ~r/test/i
# => true

Instruções

Depois de uma revisão de segurança recente, foi-te pedido que limpasse os ficheiros de log arquivados da organização.

1. Identifica as linhas de log corrompidas

Precisas de ter uma ideia de quantas linhas de log do teu arquivo não cumprem os padrões atuais. Acreditas que um teste simples revela se uma linha de log é válida. Para ser considerada válida, uma linha deve começar por uma das seguintes strings:

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

Implementa a função valid_line?/1 para devolver true se a linha de log for válida.

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

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

2. Divide a linha de log

Pouco depois de começares o projeto de análise de logs, dás-te conta de que os logs de uma aplicação não estão divididos em linhas como os das outras. Neste projeto, o que devia estar em linhas separadas aparece antes numa única linha, ligado por setas extravagantes como <---> ou <*~*~>.

Na verdade, qualquer string cujo primeiro caráter seja <, cujo último caráter seja > e que tenha, pelo meio, qualquer combinação dos seguintes carateres ~, *, =, e - pode ser usada como separador nos logs deste projeto.

Implementa a função split_line/1, que recebe uma linha e devolve uma lista de strings.

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

3. Remove os artefactos do log

Descobriste que algum processamento a montante dos logs tem vindo a espalhar pelos logs o texto "end-of-line" seguido de um número de linha (sem espaço entre eles).

Implementa a função remove_artifacts/1 para receber uma string e remover todas as ocorrências do texto end-of-line (independentemente de serem maiúsculas ou minúsculas), devolvendo uma linha de log limpa.

As linhas que não contenham o texto end-of-line devem ser devolvidas sem alterações.

Remove apenas a string end-of-line, não é preciso ajustar os espaços em branco.

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

4. Etiqueta as linhas com nomes de utilizador

Notaste que algumas das linhas de log incluem frases que se referem a utilizadores. Estas frases contêm sempre a string "User", seguida de um ou mais carateres de espaço e, depois, de um nome de utilizador. Decides etiquetar essas linhas.

Implementa uma função tag_with_user_name/1 que processa as linhas de log:

  • As linhas que não contêm a string "User" mantêm-se inalteradas.
  • Nas linhas que contêm a string "User", acrescenta ao início da linha [USER] seguido do nome do utilizador.
LogParser.tag_with_user_name("[INFO] User Alice created a new project")
# => "[USER] Alice [INFO] User Alice created a new project"

Podes assumir que:

  • Cada ocorrência da string "User" é seguida de um ou mais carateres de espaço e do nome de utilizador.
  • Há, no máximo, uma ocorrência da string "User" em cada linha.
  • Os nomes de utilizador são strings não vazias que não contêm espaços.
Editar via GitHub A ligação abre numa nova janela ou separador
Elixir Exercism

Estás pronto para começar Analisador de logs?

Inscreve-te no Exercism para aprenderes e dominares Elixir com 58 conceitos168 exercícios, e mentoria humana real, tudo grátis.