Java Academy · Aula

Por que usar logging estruturado

Além de System.out.println.

Por que usar logging estruturado é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 1 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 Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

O problema com a impressão de linhas

System.out.println é adequado para um experimento rápido, mas é uma ferramenta ruim de registro para aplicações reais.

Não há marcas de data e hora, níveis nem nomes de linhas de execução.
Não há como desativá-lo em produção.
Escreve apenas na saída padrão, sem encaminhamento.

public class Main {
    public static void main(String[] args) {
        // Crude: no level, no timestamp, always on
        System.out.println("User logged in");
    }
}

O que as estruturas de registro acrescentam

Uma estrutura de registro oferece:

Níveis (TRACE, DEBUG, INFO, WARN, ERROR) para filtrar o excesso de informações.
Marcas de data e hora, linha de execução e nomes de registradores automaticamente.
Encaminhamento para arquivos, console ou sistemas remotos.
Configuração durante a execução sem recompilar.

public class Main {
    public static void main(String[] args) {
        // A framework would render: time, level, logger, thread, message
        String simulated = "2026-01-01 10:00:00 INFO  c.e.App [main] - User logged in";
        System.out.println(simulated);
    }
}

Níveis de registro explicados

Os níveis classificam as mensagens por importância:

TRACE: detalhes muito minuciosos.
DEBUG: diagnósticos de desenvolvimento.
INFO: marcos normais.
WARN: algo inesperado, mas recuperável.
ERROR: uma falha que requer atenção.

public class Main {
    enum Level { TRACE, DEBUG, INFO, WARN, ERROR }
    public static void main(String[] args) {
        Level threshold = Level.INFO;
        for (Level l : Level.values()) {
            boolean shown = l.ordinal() >= threshold.ordinal();
            System.out.println(l + " visible? " + shown);
        }
    }
}

Filtragem por limiar

Um registrador tem um limiar. Mensagens abaixo desse limiar são descartadas com baixo custo.

Em produção, você pode definir INFO para que DEBUG e TRACE desapareçam, reduzindo o excesso de informações e o custo sem alterações no código.

public class Main {
    enum Level { TRACE, DEBUG, INFO, WARN, ERROR }
    static void log(Level threshold, Level level, String msg) {
        if (level.ordinal() >= threshold.ordinal()) {
            System.out.println(level + " - " + msg);
        }
    }
    public static void main(String[] args) {
        Level t = Level.WARN;
        log(t, Level.DEBUG, "hidden detail");
        log(t, Level.ERROR, "shown error");
    }
}

Estruturado versus não estruturado

Os registros não estruturados são frases simples. Os registros estruturados associam um contexto de chave e valor (identificador do usuário, identificador da solicitação) que as máquinas podem analisar.

Registros estruturados podem ser pesquisados e agregados em ferramentas como Elasticsearch ou Loki.

import java.util.Map;

public class Main {
    public static void main(String[] args) {
        // Structured context as key-value pairs
        Map<String, Object> fields = Map.of("event", "login", "userId", 42, "ok", true);
        System.out.println(fields);
    }
}

A ideia da fachada

Você não deve vincular seu código a uma biblioteca específica de registro. Uma fachada como SLF4J permite programar usando uma única API e trocar a implementação de retaguarda (Logback, Log4j2) posteriormente.

Isso desacopla sua aplicação das escolhas de implementação do registro.

public class Main {
    public static void main(String[] args) {
        // Concept: your code calls a facade interface, not a concrete logger
        System.out.println("App -> SLF4J facade -> Logback backend");
    }
}

Por que não usar apenas um sinalizador booleano

Alguns códigos usam if (DEBUG) System.out.println(...). Isso espalha condicionais pela base de código e não oferece controle por pacote.

Uma estrutura de registro centraliza a configuração: ative DEBUG para um pacote e ERROR para todo o restante.

public class Main {
    static final boolean DEBUG = false;
    public static void main(String[] args) {
        // Inflexible: one global switch, scattered checks
        if (DEBUG) System.out.println("diagnostic");
        System.out.println("A framework controls this per logger instead");
    }
}

Questões de desempenho

O registro deve ser barato quando desativado. As estruturas ignoram o trabalho dos níveis filtrados, e as mensagens parametrizadas evitam criar textos que serão descartados.

println sempre avalia seu argumento, mesmo que ninguém leia a saída.

public class Main {
    static String expensive() {
        System.out.println("(building expensive string)");
        return "big report";
    }
    public static void main(String[] args) {
        boolean debugEnabled = false;
        // Only build the message if it will actually be logged
        if (debugEnabled) System.out.println(expensive());
        System.out.println("skipped expensive work");
    }
}

Encaminhamento centralizado da saída

As estruturas enviam registros para um ou mais anexadores: console, arquivos rotativos, syslog ou um coletor de rede.

Você configura o encaminhamento uma vez; o código da aplicação permanece igual.

public class Main {
    public static void main(String[] args) {
        String[] appenders = {"CONSOLE", "ROLLING_FILE", "JSON_HTTP"};
        for (String a : appenders) System.out.println("route logs to: " + a);
    }
}

Correlação e contexto

Sistemas reais adicionam um identificador da solicitação a cada linha de registro pertencente a uma solicitação, para que você possa acompanhar a jornada de um usuário entre linhas de execução e serviços.

SLF4J oferece suporte a isso por meio do MDC (Contexto de diagnóstico mapeado).

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, String> mdc = new HashMap<>();
        mdc.put("requestId", "req-1234");
        System.out.println("All logs in this request tagged with " + mdc);
    }
}

O plano

Durante este curso, você irá:

Usar a fachada SLF4J e obter registradores com get.
Registrar mensagens no nível correto.
Usar mensagens parametrizadas para obter eficiência.
Configurar o Logback com anexadores e padrões.

public class Main {
    public static void main(String[] args) {
        System.out.println("Next: SLF4J facade and loggers");
    }
}

Verificação rápida

Verifique sua compreensão sobre o registro estruturado.

Recapitulação

Você aprendeu por que o registro estruturado é importante:

println não oferece níveis, metadados nem roteamento.
As estruturas adicionam níveis, filtragem e anexadores.
Uma fachada desacopla o código da implementação de suporte.
O contexto estruturado e o MDC permitem a correlação.

A seguir, a fachada SLF4J e a criação de registradores.

public class Main {
    public static void main(String[] args) {
        System.out.println("Structured logging recap complete");
    }
}

Perguntas Frequentes

A aula “Por que usar logging estruturado” é grátis?

Sim — o texto completo de “Por que usar logging estruturado” é 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 Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Por que usar logging estruturado”?

Além de System.out.println. Você pratica Java 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 Java Academy?

Nenhuma experiência prévia é necessária. Java 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 1 de 4.

Quanto tempo leva a aula “Por que usar logging estruturado”?

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 Java Academy?

Sim. Cada aula de Java 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 Java Academy