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.
GO TO FULL VERSION