Go Academy · Aula

Manipuladores personalizados

Crie sua própria saída de registros

Manipuladores personalizados é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

Quando os manipuladores integrados não são suficientes

Os manipuladores de texto e JSON atendem à maioria das necessidades, mas às vezes você quer uma saída personalizada: terminais coloridos, envio para um sistema de métricas ou remoção de informações secretas. Você cria um custom Handler.

A interface do Handler

Um manipulador implementa quatro métodos:

Enabled(ctx, level) bool
Handle(ctx, record) error
WithAttrs(attrs) Handler
WithGroup(name) Handler

type Handler interface {
    Enabled(context.Context, slog.Level) bool
    Handle(context.Context, slog.Record) error
    WithAttrs(attrs []slog.Attr) slog.Handler
    WithGroup(name string) slog.Handler
}

Enabled controla a filtragem

Enabled é chamado antes da criação de um registro. Retornar false permite que o slog ignore todo o trabalho, portanto use-o para verificações de nível.

func (h *MyHandler) Enabled(_ context.Context, l slog.Level) bool {
    return l >= slog.LevelInfo
}

Handle realiza o trabalho

Handle recebe um slog.Record com a hora, o nível, a mensagem e os atributos. Você pode formatá-lo e escrevê-lo como quiser.

func (h *MyHandler) Handle(_ context.Context, r slog.Record) error {
    fmt.Printf("[%s] %s\n", r.Level, r.Message)
    return nil
}

Iterando pelos atributos

Um registro expõe seus atributos por meio de r.Attrs, que chama sua função para cada um deles.

r.Attrs(func(a slog.Attr) bool {
    fmt.Printf("  %s=%v\n", a.Key, a.Value)
    return true // keep going
})

WithAttrs e WithGroup

Esses métodos retornam uma cópia do seu manipulador com atributos predefinidos ou um prefixo de grupo. Eles dão suporte a logger.With e slog.Group. Um manipulador mínimo pode armazená-los e reproduzi-los ou, para fins didáticos, retornar a si próprio.

Envolvendo em vez de criar

Muitas vezes, você não precisa de um manipulador completo: envolva um já existente e substitua apenas o comportamento necessário, como adicionar um atributo constante ou remover chaves.

type RedactHandler struct{ slog.Handler }

func (h RedactHandler) Handle(ctx context.Context, r slog.Record) error {
    // mutate r here, then delegate
    return h.Handler.Handle(ctx, r)
}

Caso de uso: remoção de informações

Um manipulador que remove informações pode procurar atributos com chaves sensíveis, como password ou token, e substituir o valor antes de delegar a um manipulador JSON.

Caso de uso: roteamento

Um manipulador personalizado pode rotear por nível: enviar registros Error para o erro padrão e para um endpoint de alertas, enquanto Info vai para a saída padrão. Isso mantém a lógica de roteamento fora de cada ponto de chamada.

Observações sobre desempenho

Handle pode ser executado em caminhos críticos de desempenho. Evite alocações, faça verificações de nível em Enabled e reutilize memórias intermediárias. Os manipuladores padrão usam internamente uma memória intermediária agrupada por esse motivo.

Executável: um Handler personalizado mínimo

Este programa independente define um manipulador pequeno que imprime o nível, a mensagem e os atributos e, em seguida, registra dados por meio dele.

package main

import (
    "context"
    "fmt"
    "log/slog"
)

type Mini struct{}

func (Mini) Enabled(context.Context, slog.Level) bool { return true }
func (Mini) WithAttrs(a []slog.Attr) slog.Handler   { return Mini{} }
func (Mini) WithGroup(string) slog.Handler          { return Mini{} }
func (Mini) Handle(_ context.Context, r slog.Record) error {
    fmt.Printf("%s: %s", r.Level, r.Message)
    r.Attrs(func(a slog.Attr) bool {
        fmt.Printf(" %s=%v", a.Key, a.Value)
        return true
    })
    fmt.Println()
    return nil
}

func main() {
    l := slog.New(Mini{})
    l.Info("hello", "user", "ada", "id", 7)
}

Verificação rápida

Teste sua compreensão sobre manipuladores personalizados.

Recapitulação

Você aprendeu a criar manipuladores personalizados:

Implemente Enabled, Handle, WithAttrs, WithGroup
Faça verificações de nível em Enabled para obter melhor desempenho
Itere pelos atributos com r.Attrs
Muitas vezes é mais fácil envolver um manipulador existente do que criar um do zero

Perguntas Frequentes

A aula “Manipuladores personalizados” é grátis?

Sim — o texto completo de “Manipuladores personalizados” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Manipuladores personalizados”?

Crie sua própria saída de registros Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Manipuladores personalizados”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy