Criando um servidor de tracing distribuído (parte 1)

Vítor Roque — Mon, 11 Sep 2023 04:30:14 +0000

Em Haskell tudo começa pelas tipagens e dados que você precisa. Primeiramente certifique-se que tenha instalado o cabal ou stack para criar projetos em Haskell.

Criando projeto

Para criar o projeto é simples

$ cabal init -n tracer

O cabal irá criar um projeto de modo interativo (bem como o npm init).

Tipos e dados

Primeiro precisamos definir o que será cada coisa, os componentes e a implementação.

Na estrutura temos o que chamaremos de ISO ou EDIO (Estrutura de instrumentação da observabilidade) que é nada mais que um mapa chave-valor, onde a chave é a ação originária e o valor é a uma lista de ações possíveis (ou ações alvos possíveis).

module Instrumentation () where

newtype ISO = ISO [(String, [String])] deriving (Eq, Show)

O Map, bem utilizado em outras linguagens, se resume a uma lista de tuplas com apenas 2 valores, a chave e o valor em si. E pra isso teremos que criar algumas funções auxiliares para inserir, procurar ou deletar entradas nesse mapa.

Funções auxiliares

No caso, por agora, precisamos ter uma função para criar um ISO vazio e um para inserir.

newISO :: ISO
newISO = ISO []

A função de criação é bem simples pois só precisamos ter uma função que usa o método construtor ISO com uma lista vazia.

insert :: (String, [String]) -> ISO -> ISO
insert (key, value) (ISO items) = ISO newIso
  where
    newIso = items ++ [(key, value)]

A função de inserção seria apenas a concatenação da lista anterior com uma lista nova. Em Haskell, podemos ter N formas de criar essa função, usei a notação where, pois ela nos dá uma forma mais fácil de compreender o que é cada parte da função. Nesse caso eu separei a concatenação de listas numa variável desse where para facilitar a legibilidade da função em si.

Testes, pois sem testes não viveríamos

Em Haskell, testes são feitos por, acredite ou não, funções! Essas funções podem ser escritas de várias maneiras mas aqui usarei o mais comum na comunidade, que é o HUnit.

Primeiro nós instalamos o HUnit pelo cabal.

$ cabal install --lib HUnit

E precisamos alterar no nosso arquivo tracer.cabal

test-suite tracer-test
    import:           warnings
    default-language: Haskell2010
    type:             exitcode-stdio-1.0
    hs-source-dirs:   test
    main-is:          Main.hs
    other-modules:    InstrumentationTest -- novo
    build-depends:
        base ^>=4.18.0.0,
        tracer,
        HUnit -- novo

Nesse arquivo adicionamos um novo módulo além do Main que o cabal cria para nós, e o que depende do build desse teste.

Teste da estrutura ISO

Com isso precisamos criar os testes nesse arquivo test/InstrumentationTest.hs

module InstrumentationTest () where

import Instrumentation (ISO (..), insert, newISO)
import Test.HUnit

createNewISOTest :: Test
createNewISOTest = TestCase (assertEqual "should return empty ISO" (ISO [] newISO)

insertEntryTest :: Test
insertEntryTest = TestCase (assertEqual "should return a ISO with entry" desired appliedFunction)
   where
     desired = ISO [("chave", ["valor1"])]
     appliedFunction = insert ("chave", ["valor1"]) newISO

Nesse arquivo criamos tanto o teste para checar a criação de uma nova ISO e a inserção de uma entrada. E agora precisamos colocar ele no arquivo test/Main.hs

module Main (main) where

import Test.HUnit
import InstrumentationTest (createNewISOTest, insertEntryTest)
import qualified System.Exit as Exit

tests :: Test
tests = TestList [TestLabel "createNewISO" createNewISOTest, TestLabel "insertEntryTest" insertEntryTest]

main :: IO ()
main = do
  result <- runTestTT tests
  if failures result > 0 then Exit.exitFailure else Exit.exitSuccess

Nesse arquivo nós criamos uma suite de testes para que ele rode todos os testes do módulo InstrumentationTest

Para rodar os testes apenas rodamos

$ cabal test

E ele terá um resultado parecido com esse (além dos logs de build)

Test suite eyaara-test: RUNNING...
Cases: 2  Tried: 2  Errors: 0  Failures: 0
Test suite tracer-test: PASS

E por hoje é só! Nessa série de artigos eu irei recriar o sistema e estrutura que desenvolvi baseado no algoritmo Drain para parsing de logs.

O ṣeun! 👋🏾

Criando um monitor de logs em Go - parte 1

Vítor Roque — Thu, 20 Apr 2023 21:49:30 +0000

Esse é um post onde vou mostrar como eu desenvolvi esse monitor de logs, que você pode estar acompanhando nesse repositório.

Protocolo AWO e Parser

Eu precisava de uma estrutura para esse protocolo, como seria uma aplicação que muitas apps podem utilizar essa estrutura precisava de um padrão. Segue um exemplo:

LOG abc@123 AWO1.1
02:30:22
This is my LOG message content!

Como todo protocolo em cima do TCP, tudo isso é um texto, então eu precisava converte-lo em alguma estrutura.

Em Go, criei um parser para tratar todo tipo de mensagem que enviarem para a aplicação. Caso ele não siga esse padrão, um erro deve ser gerado.

type Log struct {
  Header Header
  Timer string
  Message string
}

type Header struct {
  Verb, AppKey, Version string
}

Essas estruturas serão a base da mensagem, onde Header tem sua verificação, pois se algo estiver errado antes da validação, não queremos receber a mensagem.

Validando o Header

Precisamos também criar um construtor para esse Header.

func NewHeader(head string) (Header, error) {
        parts := strings.Split(head, " ")
        if len(parts) != 3 {
                return Header{}, errors.New("malformed header")
        }

        verb := parts[0]
        app_key := parts[1]
        version := parts[2]

        return Header{Verb: verb, AppKey: app_key, Version: version}, nil
}

Aqui apenas divido o header em 3 pelo whitespace, e caso ele venha mais ou venha menos partes, ele está errado. Aqui também poderia adicionar alguma forma de validação da app_key ou se o verb não faz parte dos verbos do protocolo que estamos criando (o que implementarei mais para frente).

Criando a função Parse

Agora que tenho o Header com sua validação preciso transformar a mensagem numa estrutura.

func Parse(packet string) (Log, error) {
        parts := strings.Split(packet, "\n")
        if len(parts) != 3 {
                return Log{}, errors.New("malformed packet")
        }

        header, header_error := NewHeader(parts[0])

        if header_error != nil {
                return Log{}, header_error
        }

        timer := parts[1]
        if timer == "" {
                return Log{}, errors.New("timer is empty")
        }
        message := parts[2]

        return Log{
                Header:  header,
                Timer:   timer,
                Message: message,
        }, nil

}

Esse parser irá validar se a mensagem tem também 3 partes, pois só tenho a estrutura: Header, Timer e Message. Então caso não siga isso, irei trata-lo como inválido.

Logo depois crio o Header e também checo se o timer está vazio ou não, pois preciso do tempo que esse log chegou na aplicação.

Por fim, coloco ele numa estrutura Log como já definido e o retorno.

Na próxima publicação sobre esse projeto irei abordar como criei o sistema de regras para a monitoração customizada usando o Oluwoye.

O ṣeun, e até a próxima!

DEV Community: Vítor Roque