CodeGym /Kursy /JAVA 25 SELF /Logowanie w aplikacjach wielowątkowych i webowych

Logowanie w aplikacjach wielowątkowych i webowych

JAVA 25 SELF
Poziom 63, Lekcja 2
Dostępny

1. Bezpieczeństwo wątkowe logowania

W jednowątkowych programach wszystko jest proste: jeden wątek zapisuje logi, nikt mu nie przeszkadza. A w prawdziwych aplikacjach – serwisach webowych, mikrousługach – jednocześnie działa dziesiątki i setki wątków. Wyobraź sobie, że kilka osób jednocześnie długopisem pisze w tej samej linijce w notesie – rezultat byłby, delikatnie mówiąc, nieczytelny.

Bezpieczeństwo wątkowe (thread safety) – to gwarancja, że nawet jeśli 100500 wątków jednocześnie zapisuje logi, komunikaty się nie pomieszają, nie zleją i nie zginą.

Jak jest to zrealizowane w bibliotekach?

Współczesne biblioteki logowania (Log4j 2, Logback, java.util.logging) są od początku zaprojektowane tak, aby były bezpieczne wątkowo. Oznacza to:

  • Każdy wątek może bezpiecznie wywoływać metody loggera.
  • Wewnątrz biblioteki używana jest synchronizacja i kolejki, aby komunikaty sobie nie przeszkadzały.
  • Nawet gdy kilka wątków jednocześnie zapisuje do tego samego pliku, logi się nie pomieszają.

WAŻNE: Sam logger (na przykład obiekt Logger z SLF4J lub Log4j) można używać jako pole static final w dowolnej klasie – nie spowoduje to problemów z wątkami.

Przykład

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MultiThreadedLoggerExample {
    private static final Logger logger = LoggerFactory.getLogger(MultiThreadedLoggerExample.class);

    public static void main(String[] args) {
        Runnable task = () -> {
            for (int i = 0; i < 5; i++) {
                logger.info("Wątek {} zapisuje komunikat {}", Thread.currentThread().getName(), i);
            }
        };

        Thread t1 = new Thread(task, "Pierwszy");
        Thread t2 = new Thread(task, "Drugi");
        t1.start();
        t2.start();
    }
}

W logach zobaczysz uporządkowane komunikaty od obu wątków – bez chaosu i nakładania.

2. Kontekst logowania: MDC (Mapped Diagnostic Context)

Wyobraź sobie: Twoja aplikacja obsługuje setki żądań jednocześnie, każde – w swoim wątku. W logach migają komunikaty, ale nie wiadomo, które dotyczą którego żądania. Chcemy widzieć nie tylko „co się stało”, ale także z kim i w ramach jakiego żądania to się stało.

MDC (Mapped Diagnostic Context) – to mechanizm, który pozwala „dołączyć” do logów dodatkowe informacje związane z bieżącym wątkiem. Wszystkie komunikaty zapisywane przez wątek automatycznie otrzymują te dane.

Przykład: logujemy identyfikator żądania

W aplikacji webowej każdemu żądaniu można nadać unikalny ID (na przykład UUID). Za pomocą MDC ten ID będzie automatycznie dodawany do wszystkich logów zapisywanych przez wątek obsługujący żądanie.

Jak to wygląda w kodzie (SLF4J + Logback):

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;

import java.util.UUID;

public class MdcExample {
    private static final Logger logger = LoggerFactory.getLogger(MdcExample.class);

    public static void main(String[] args) {
        Runnable task = () -> {
            // Generujemy unikalny identyfikator żądania
            String requestId = UUID.randomUUID().toString();
            MDC.put("requestId", requestId); // dodajemy do MDC

            logger.info("Przetwarzamy żądanie");
            doSomeWork();
            logger.info("Zakończyliśmy przetwarzanie");

            MDC.clear(); // koniecznie czyścimy po zakończeniu!
        };

        Thread t1 = new Thread(task, "Wątek-1");
        Thread t2 = new Thread(task, "Wątek-2");
        t1.start();
        t2.start();
    }

    static void doSomeWork() {
        logger.debug("Wykonujemy pracę...");
    }
}

Konfiguracja formatu logu (np. logback.xml):

<encoder>
    <pattern>%d{HH:mm:ss} [%thread] %-5level %logger{36} [requestId=%X{requestId}] - %msg%n</pattern>
</encoder>

Wynik:

12:01:23 [Wątek-1] INFO  MdcExample [requestId=ad8d...f3] - Przetwarzamy żądanie
12:01:23 [Wątek-1] DEBUG MdcExample [requestId=ad8d...f3] - Wykonujemy pracę...
12:01:23 [Wątek-1] INFO  MdcExample [requestId=ad8d...f3] - Zakończyliśmy przetwarzanie

Ważne!

  • MDC działa tylko w obrębie jednego wątku. Jeśli przekazujesz pracę do innego wątku (np. przez pulę wątków), musisz ręcznie przekazać wartości MDC (albo użyć specjalnych bibliotek, które robią to automatycznie).
  • Nie zapominaj czyścić MDC! Jeśli nie wyczyścisz, dane mogą „przenieść się” do kolejnego żądania w tym samym wątku (np. w puli wątków serwera webowego). Używaj MDC.clear() w bloku finally.

3. Logowanie w aplikacjach webowych

Aplikacja webowa to nie tylko program, który się uruchomił i działa. To prawdziwa linia produkcyjna: żądania przychodzą, są przetwarzane, wychodzą odpowiedzi. I wszystko to – jednocześnie, setkami. Tu logowanie to nie luksus, lecz konieczność!

Co logować w aplikacjach webowych?

  • Żądania i odpowiedzi HTTP: metoda, URL, parametry, status odpowiedzi, czas obsługi.
  • Błędy i wyjątki: wszystkie nieoczekiwane awarie, stack trace.
  • Zdarzenia biznesowe: rejestracja, logowanie, złożenie zamówienia, płatność itd.
  • Szczegóły techniczne: interakcje z bazą danych, usługami zewnętrznymi, czasy wykonywania operacji.

Główna zasada: loguj tak, aby za miesiąc, gdy coś się zepsuje o 3 w nocy, dało się zrozumieć, co poszło nie tak.

Przykład: logowanie żądania HTTP (Spring Boot)

Najprostszy sposób – użyć filtra lub aspektu, który będzie logował każde przychodzące żądanie.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
import org.springframework.stereotype.Component;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.util.UUID;

@Component
public class RequestLoggingFilter implements Filter {
    private static final Logger logger = LoggerFactory.getLogger(RequestLoggingFilter.class);

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        String requestId = UUID.randomUUID().toString();
        MDC.put("requestId", requestId);

        HttpServletRequest httpRequest = (HttpServletRequest) request;
        logger.info("Żądanie: {} {}", httpRequest.getMethod(), httpRequest.getRequestURI());

        long start = System.currentTimeMillis();
        try {
            chain.doFilter(request, response); // dalej w łańcuchu (do kontrolera)
        } finally {
            long duration = System.currentTimeMillis() - start;
            logger.info("Odpowiedź wysłana, czas przetwarzania: {} ms", duration);
            MDC.clear();
        }
    }
}

Logowanie błędów i wyjątków

W frameworkach webowych (np. Spring) stosuje się specjalne handlery błędów (@ExceptionHandler), aby ładnie logować wszystkie nieoczekiwane awarie.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class GlobalExceptionHandler {
    private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);

    @ExceptionHandler(Exception.class)
    public String handleException(Exception ex) {
        logger.error("Wystąpił błąd: ", ex); // logujemy z pełnym stack trace!
        return "error"; // zwracamy stronę błędu
    }
}

Integracja z frameworkami webowymi

Prawie wszystkie współczesne frameworki webowe (Spring, Jakarta EE, Micronaut itd.) integrują się z loggerami „od razu” (out of the box). Zwykle wystarczy dodać zależność SLF4J/Logback do projektu – i wszystkie standardowe komunikaty (start aplikacji, obsługa żądań, błędy) będą logowane automatycznie.

4. Praktyka: przykład logowania w zadaniu wielowątkowym

Dodajmy do naszej aplikacji edukacyjnej (np. serwisu obsługi zamówień) przetwarzanie wielowątkowe i zobaczmy, jak logowanie pomaga zachować porządek.

Przykład: obsługa zamówień w kilku wątkach z MDC

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;

import java.util.UUID;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class OrderProcessingApp {
    private static final Logger logger = LoggerFactory.getLogger(OrderProcessingApp.class);

    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);

        for (int i = 1; i <= 5; i++) {
            final int orderId = i;
            executor.submit(() -> {
                String requestId = UUID.randomUUID().toString();
                MDC.put("requestId", requestId);

                try {
                    logger.info("Zaczynamy przetwarzanie zamówienia {}", orderId);
                    processOrder(orderId);
                    logger.info("Zamówienie {} przetworzone pomyślnie", orderId);
                } catch (Exception ex) {
                    logger.error("Błąd podczas przetwarzania zamówienia " + orderId, ex);
                } finally {
                    MDC.clear();
                }
            });
        }
        executor.shutdown();
    }

    static void processOrder(int orderId) throws InterruptedException {
        if (orderId % 2 == 0) {
            throw new RuntimeException("Symulacja błędu dla parzystego zamówienia");
        }
        Thread.sleep(500); // imitacja pracy
    }
}

Co się dzieje:

  • Każde zamówienie jest przetwarzane w osobnym wątku.
  • Dla każdego wątku tworzony jest unikalny requestId (przez MDC).
  • Wszystkie logi dotyczące jednego zamówienia można znaleźć po tym identyfikatorze.
  • Błędy są logowane z pełnym stosem.

Format logu jest skonfigurowany tak, by pokazywać requestId.

5. Ważne niuanse i szczegóły

  • Wątki, pule i MDC. Jeśli pracujesz z pulami wątków (a na pewno pracujesz), zapamiętaj: wątki w puli są ponownie używane! Jeśli zapomnisz wyczyścić MDC, dane z jednego żądania mogą trafić do logów innego. Zawsze wywołuj MDC.clear() na końcu pracy.
  • MDC i zadania asynchroniczne. W asynchronicznych frameworkach webowych (np. Spring WebFlux) MDC nie zawsze działa „od razu”, ponieważ obsługa żądania może przeskakiwać między wątkami. Dla takich przypadków istnieją specjalne rozszerzenia lub adaptery.
  • Logowanie w mikrousługach. W architekturze mikrousługowej przyjęło się logować nie tylko lokalny identyfikator żądania, ale i globalny (traceId), przekazywany między usługami. Pozwala to prześledzić drogę żądania przez cały system (śledzenie rozproszone). Do tego często używa się systemów takich jak Zipkin, Jaeger, OpenTelemetry.

6. Demonstracja: różnica między System.out.println a logowaniem

System.out.println – po prostu wypisuje linię do konsoli. W środowisku wielowątkowym:

  • Komunikaty mogą się mieszać.
  • Brak informacji o czasie, wątku, poziomie, kontekście.
  • Nie da się skonfigurować zapisu do pliku, formatu, filtrowania po poziomie.

Logger – zapisuje ustrukturyzowane komunikaty, uwzględnia wątki, poziomy, format, wspiera zapis w różne miejsca (plik, konsola, sieć).

Przykład porównania

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class PrintVsLogger {
    private static final Logger logger = LoggerFactory.getLogger(PrintVsLogger.class);

    public static void main(String[] args) {
        Runnable task = () -> {
            for (int i = 0; i < 3; i++) {
                System.out.println("System.out: " + Thread.currentThread().getName() + " krok " + i);
                logger.info("Logger: krok {}", i);
            }
        };
        new Thread(task, "T1").start();
        new Thread(task, "T2").start();
    }
}

Wynik:

  • System.out – komunikaty mogą iść w przypadkowej kolejności, bez czasu i poziomu.
  • Logger – każdy komunikat zawiera czas, wątek, poziom; można filtrować i szybko znaleźć potrzebne.

7. Typowe błędy przy logowaniu w aplikacjach wielowątkowych i webowych

Błąd nr 1: używanie System.out.println zamiast loggera. W środowisku wielowątkowym prowadzi to do „chaosu” w konsoli, braku możliwości filtrowania komunikatów i utraty informacji o kontekście.

Błąd nr 2: ignorowanie MDC lub jego nieprawidłowe użycie. Jeśli nie używać MDC do przekazywania identyfikatora żądania/użytkownika, logi stają się mało użyteczne – nie da się zrozumieć, którego żądania dotyczy błąd. Jeśli zapomina się czyścić MDC, dane mogą „przeniknąć” do innego żądania.

Błąd nr 3: logger tworzony jako zmienna lokalna. Lepiej używać private static final Logger – wtedy logger tworzony jest raz na klasę, nie marnuje się pamięć i nie ma ryzyka błędów.

Błąd nr 4: logowanie danych wrażliwych. Do logów nie powinny trafiać hasła, numery kart płatniczych, dane osobowe – to naruszenie bezpieczeństwa!

Błąd nr 5: logowanie tylko „INFO” albo tylko „ERROR”. Używaj odpowiednich poziomów: DEBUG do debugowania, INFO dla zdarzeń biznesowych, ERROR dla błędów. Nie zapisuj wszystkiego jednym poziomem – inaczej logi tracą sens.

Błąd nr 6: brak logowania stack trace wyjątków. Jeśli pisać tylko logger.error("Błąd: " + ex.getMessage()), traci się informację o przyczynie. Zawsze loguj całe wyjątki: logger.error("Błąd", ex).

Błąd nr 7: własne loggery bez bezpieczeństwa wątkowego. Jeśli ktoś postanowi „zrobić własny logger” bez synchronizacji – w środowisku wielowątkowym to niemal gwarantowana utrata lub uszkodzenie logów.

1
Zadanie
JAVA 25 SELF, poziom 63, lekcja 2
Niedostępne
Serwer gry
Serwer gry
1
Zadanie
JAVA 25 SELF, poziom 63, lekcja 2
Niedostępne
Wsparcie techniczne
Wsparcie techniczne
Komentarze
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION