Meta programação em Go: usando Struct Tags

Eldio Santos Junior — Fri, 01 Nov 2024 18:18:56 +0000

Sempre gostei de meta programação, mas vejo que no Go isso é meio obscuro... Você encontra uns poucos textos sobre (e a maioria deles usa o mesmo exemplo).

Um tempo atrás eu fui procurar uma solução pra serializar uma struct pro formato properties do Java e, como não encontrei, resolvi criar algo que utilizasse o mesmo esquema de tags que o JSON serializer (o projeto esta nesse repositório eldius/properties). Vou usar esse caso como exemplo de como criar e utilizar suas tags customizadas.

Tentei seguir o exemplo do decoder de JSON.

if err := json.NewEncoder(os.Stdout).Encode(&struct{}{}); err != nil {
    panic(err)
}
if err := json.NewDecoder(os.Stdin).Decode(&struct{}{}); err != nil {
    panic(err)
}

Por onde começamos?

Então vamos lá, como podemos acessar as tags dos atributos de uma struct?

Vamos usar essa struct de exemplo:

type MyProperties struct {
    ServerPort int `prop:"server_port"`
    Hostname   string `prop:"hostname"`
}

Para pegarmos o valor da tag prop de cada atributo fazemos o seguinte:


props := MyProperties{
    ServerPort: 8080,
    Hostname: "localhost",
}

valueOf := reflect.ValueOf(&props)
element := valueOf.Elem()
valueType := element.Type()

// Primeiro atributo
field0TagValue, ok := valueType.Field(0).Tag.Lookup("prop")
if !ok {
    panic(errors.New("no prop tag"))
}

fmt.Println(field0TagValue)

// Segundo atributo
field1TagValue, ok := valueType.Field(1).Tag.Lookup("prop")
if !ok {
    panic(errors.New("no prop tag"))
}

fmt.Println(field1TagValue)

O trecho de código acima retornaria algo como

Output:

server_port
hostname

Exemplo no Go Playground

Daí, decidi simplificar a minha vida, achei que só
serializaria/deserializar os atributos da "instância mãe"
(não quis entrar em atributos de atributos 😂). Então
meu encoder ficou mais ou menos assim:

func (d *Decoder) Decode(v any) error {
    // Leitura do arquivo e transformação dos valores
    // em um mapa/dicionário
    values, err := readToMap(d.r)
    if err != nil {
        err = fmt.Errorf("reading input content: %w", err)
        return err
    }

    valueSource := reflect.ValueOf(v)
    if valueSource.Kind() != reflect.Ptr {
        return ErrNotAPointer
    }
    valueSource = valueSource.Elem()
    if valueSource.Kind() != reflect.Struct {
        return ErrNotAStruct
    }

    valueType := valueSource.Type()

    // Iterando pelos atributos da struct
    for i := 0; i < valueType.NumField(); i++ {
        // Pegar valor da tag
        fieldTag, ok := valueType.Field(i).Tag.Lookup(propertiesTag)
        if !ok {
            continue
        }

        // Buscar nome do atributo
        fieldName := valueType.Field(i).Name
        fieldValue := valueSource.FieldByName(fieldName)
        if !fieldValue.IsValid() {
            continue
        }

        // Validando se podemos alterar seu valor
        if !fieldValue.CanSet() {
            continue
        }

        // Pegar valor do atributo dentro do map
        v, ok := values[fieldTag]
        if !ok {
            continue
        }

        // Definindo o valor do atributo de acordo
        // com o seu tipo
        switch valueSource.Field(i).Kind() {
        case reflect.String:
            fieldValue.SetString(v)
        case reflect.Int:
            err := setIntValue(v, 64, fieldValue)
            if err != nil {
                err = fmt.Errorf("failed to parse int value for field '%s':%w", fieldTag, err)
                return err
            }

            // DEMAIS TIPOS //

        }
    }

    return nil
}


func readToMap(r io.Reader) (map[string]string, error) {
    b, err := io.ReadAll(r)
    if err != nil {
        err = fmt.Errorf("reading content: %w", err)
        return nil, err
    }

    values := make(map[string]string)
    for _, l := range strings.Split(string(b), "\n") {
        if strings.HasPrefix(l, "#") {
            continue
        }
        if len(l) == 0 {
            continue
        }

        tmp := strings.Split(l, "=")
        values[tmp[0]] = tmp[1]
    }

    return values, nil
}

No meu caso eu precisava apenas pegar o nome do
atributo na tag, então isso já resolveria, mas
caso minha tag tivesse propriedades, como as tags
de validação, que possuem atributos (algo tipo
validation:"field_name,required=true,min=1,max=10"), você
precisa tratar a string para extrair essas
informações na mão.

Segue um exemplo simplificado de como fazer isso.


func parseComplexTag(rawTagValue string) (map[string]interface{}, error) {
    var result map[string]interface{}
    tagSplittedValues := strings.Split(rawTagValue, ",")
    for _, tagPart := range tagSplittedValues {
        var tagPartSplitted = strings.Split(tagPart, "=")
        if len(tagPartSplitted) == 1 {
            result["name"] = tagPartSplitted[0]
        } else if len(tagPartSplitted) == 2 {
            var err error
            switch tagPartSplitted[0] {
            case "required":
                result[tagPartSplitted[0]], err = strconv.ParseBool(tagPartSplitted[1])
                if err != nil {
                    return nil, err
                }

            case "min":
                result[tagPartSplitted[0]], err = strconv.ParseInt(tagPartSplitted[1], 10, 64)
                if err != nil {
                    return nil, err
                }

            case "max":
                result[tagPartSplitted[0]], err = strconv.ParseInt(tagPartSplitted[1], 10, 64)
                if err != nil {
                    return nil, err
                }
            default:
                return nil, fmt.Errorf("unknown tag parameter: %s", tagPart)
            }
        } else {
            return nil, fmt.Errorf("invalid tag parameter format: %s", tagPart)
        }
        return result, nil
    }
}

Você pode ver o output da execução deste snippet no
Go Playground.

Monitoramento e rastreamento

Eldio Santos Junior — Thu, 06 Apr 2023 23:47:37 +0000

Um tempo atrás a firma decidiu deixar de usar a biblioteca do NewRelic para coletar dados de traces distribuídos e métricas de runtime (usados pra rastrear requisições, monitorar memória, processamento, erros e definir alertas) e passaria a utilizar o OpenTelemetry, que é uma especificação de coleta de métricas e dados de trace agnóstico a ferramenta onde você guarda os dados e possui implementação pra várias linguagens (todas as linguagens que eu procurei tinham sua implementação). Na época, programando em Java, você adicionara o Java Agent do OpenTelemetry e já tínhamos uns 70% funcionando, como usava Spring Boot, era só adicionar o Spring Cloud Blá Blá Blá (se não me falha a memória era o Spring Cloud Sleuth, mas não poria a minha mão no fogo) e o trabalho estava feito.

Atualmente, programando em Go, percebi que não tem nada automágico, que algumas bibliotecas não tinham um mecanismo pra coletar essas informações e nem tem muito material sobre, nem em inglês (eu até vi algum material falando sobre trace, mas quase nada sobre métricas de runtime, nem mesmo em inglês)... Então resolvi pegar o assunto pra dar uma olhada e comecei a fazer uma prova de conceito e achei válido ir documentando o que fosse aprendendo sobre o assunto. A ideia é utilizar o máximo possível de soluções da comunidade (principalmente do repositório oficial de Go do OpenTelemetry, o open-telemetry/opentelemetry-go-contrib)...

Daí, pensei em uma organização de micro serviços meio aleatória e saiu o desenho abaixo.

Depois comecei a pesquisar ferramentas de visualização dessas paradas e encontrei duas opções que me pareceram interessantes, o Jaeger, que só tinha suporte a visualização dos traces (mas a visualização dele fica bem legal) e a stack do OpenSearch (OpenSearch e OpenSearch Dashboards), que tem visualização de traces e te da uma estrutura pra criar gráficos com as métricas de runtime (mas a visualização é bem mequetrefe), na dúvida tentei configurar ambos utilizando Docker (e, como todo castigo pra trouxa é pouco, resolvi aproveitar a opção com o Opensearch e subir também uma estrutura pra jogar o stdout do Docker num índice do OpenSearch e permitir visualizar no Dashboards, deu um trabalhinho, mas no final funcionou mais ou menos bem)...

A estrutura com o Jaeger ficou da seguitne forma:

E a estrutura utilizando o OpenSearch ficou assim:

O código do projeto esta em eldius/golang-observability-poc.

Pretendo ir documentando o que for aprendendo no processo.

DEV Community: Eldio Santos Junior

Meta programação em Go: usando Struct Tags

Por onde começamos?

Monitoramento e rastreamento