2024-01-15 10:23:14 [http-nio-8080-exec-3] INFO  OrderService - Processing order
2024-01-15 10:23:14 [http-nio-8080-exec-1] INFO  PaymentService - Charging card
2024-01-15 10:23:14 [http-nio-8080-exec-3] WARN  InventoryService - Low stock
2024-01-15 10:23:15 [http-nio-8080-exec-2] ERROR OrderService - Payment failed

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

public class OrderService {
    private static final Logger logger = LoggerFactory.getLogger(OrderService.class);
    
    public void processOrder(String orderId, String userId) {
        // Установка контекста в начале операции
        MDC.put("orderId", orderId);
        MDC.put("userId", userId);
        MDC.put("operation", "processOrder");
        
        try {
            logger.info("Starting order processing");
            validateOrder(orderId);
            chargePayment(orderId, userId);
            updateInventory(orderId);
            logger.info("Order processing completed");
        } catch (Exception e) {
            logger.error("Order processing failed", e);
            throw e;
        } finally {
            // Обязательная очистка контекста
            MDC.clear();
        }
    }
}

<property name="LOG_PATTERN" 
          value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} [%X{userId}] [%X{orderId}] - %msg%n"/>

<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
    <encoder>
        <pattern>${LOG_PATTERN}</pattern>
    </encoder>
</appender>

2024-01-15 10:23:14.123 [http-nio-8080-exec-3] INFO  OrderService [user-42] [order-789] - Starting order processing
2024-01-15 10:23:14.145 [http-nio-8080-exec-3] INFO  PaymentService [user-42] [order-789] - Charging payment
2024-01-15 10:23:14.167 [http-nio-8080-exec-3] INFO  OrderService [user-42] [order-789] - Order processing completed

import org.slf4j.MDC;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.UUID;

@Component
public class LoggingContextFilter extends OncePerRequestFilter {
    
    private static final String REQUEST_ID_HEADER = "X-Request-Id";
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                    HttpServletResponse response, 
                                    FilterChain filterChain) throws ServletException, IOException {
        
        // Генерация или извлечение идентификатора запроса
        String requestId = request.getHeader(REQUEST_ID_HEADER);
        if (requestId == null || requestId.isBlank()) {
            requestId = UUID.randomUUID().toString();
        }
        
        // Извлечение контекста аутентификации
        String userId = extractUserId(request);
        String sessionId = request.getSession(false) != null ? 
            request.getSession().getId() : "anonymous";
        
        // Установка MDC
        MDC.put("requestId", requestId);
        MDC.put("userId", userId != null ? userId : "anonymous");
        MDC.put("sessionId", sessionId);
        MDC.put("method", request.getMethod());
        MDC.put("uri", request.getRequestURI());
        
        // Проброс requestId в ответ для клиентской трассировки
        response.setHeader(REQUEST_ID_HEADER, requestId);
        
        try {
            filterChain.doFilter(request, response);
        } finally {
            // Очистка обязательна, иначе поток из пула вернется с загрязненным контекстом
            MDC.clear();
        }
    }
    
    private String extractUserId(HttpServletRequest request) {
        // Извлечение из SecurityContext или токена
        return SecurityContextHolder.getContext().getAuthentication() != null ?
            SecurityContextHolder.getContext().getAuthentication().getName() : null;
    }
}

<property name="LOG_PATTERN" 
          value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} [%X{requestId}] [%X{userId}] [%X{method} %X{uri}] - %msg%n"/>

<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
    <encoder>
        <pattern>${LOG_PATTERN}</pattern>
    </encoder>
</appender>

@Service
public class OrderClient {
    private final RestTemplate restTemplate;
    
    public OrderDto getOrder(String orderId) {
        String requestId = MDC.get("requestId");
        
        HttpHeaders headers = new HttpHeaders();
        headers.set("X-Request-Id", requestId);  // Propagation
        
        HttpEntity<Void> entity = new HttpEntity<>(headers);
        ResponseEntity<OrderDto> response = restTemplate.exchange(
            "http://order-service/orders/" + orderId,
            HttpMethod.GET,
            entity,
            OrderDto.class
        );
        
        return response.getBody();
    }
}

// Антипаттерн: MDC теряется при асинхронном выполнении
CompletableFuture.runAsync(() -> {
    // MDC пуст — задача выполняется в другом потоке
    logger.info("Async task");  // Нет requestId, userId
});

Map<String, String> contextMap = MDC.getCopyOfContextMap();

CompletableFuture.runAsync(() -> {
    MDC.setContextMap(contextMap);  // Восстановление контекста
    try {
        logger.info("Async task with context");
        processAsync();
    } finally {
        MDC.clear();
    }
});

@Configuration
public class AsyncConfig implements AsyncConfigurer {
    
    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setTaskDecorator(new MdcTaskDecorator());
        executor.initialize();
        return executor;
    }
}

public class MdcTaskDecorator implements TaskDecorator {
    @Override
    public Runnable decorate(Runnable runnable) {
        Map<String, String> contextMap = MDC.getCopyOfContextMap();
        return () -> {
            try {
                MDC.setContextMap(contextMap);
                runnable.run();
            } finally {
                MDC.clear();
            }
        };
    }
}

<encoder class="net.logstash.logback.encoder.LogstashEncoder"/>

{
  "@timestamp": "2024-01-15T10:23:14.123+00:00",
  "message": "Order processing completed",
  "logger_name": "com.example.OrderService",
  "level": "INFO",
  "thread_name": "http-nio-8080-exec-3",
  "requestId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "userId": "user-42",
  "sessionId": "session-xyz",
  "method": "POST",
  "uri": "/api/orders"
}

import com.fasterxml.jackson.databind.ObjectMapper;

public class Task260526 {
    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();

        String json = "{\"name\":\"Buddy\",\"breed\":\"Labrador\"}";

        Animal260526 animal = mapper.readValue(json, Animal260526.class);
        System.out.println(animal.getClass().getSimpleName());
    }
}

interface Animal260526 {
    String getName();
}

class Dog260526 implements Animal260526 {
    public String name;
    public String breed;

    public Dog260526() {}

    @Override
    public String getName() { return name; }
}

public class ComparatorComparing {
    
    static class Person {
        String name;
        int age;
        LocalDate birthDate;
        
        Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        
        @Override
        public String toString() {
            return name + "(" + age + ")";
        }
    }
    
    // Класс без Comparable
    static class ExternalId {
        String prefix;
        int number;
        
        ExternalId(String prefix, int number) {
            this.prefix = prefix;
            this.number = number;
        }
        
        @Override
        public String toString() {
            return prefix + "-" + number;
        }
    }
    
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
            new Person("Alice", 30),
            new Person("Bob", 25),
            new Person("Charlie", 35)
        );
        
        //Работает: String реализует Comparable
        people.sort(Comparator.comparing(p -> p.name));
        System.out.println("Sorted by name: " + people);
        
        //Работает: int примитив через comparingInt
        people.sort(Comparator.comparingInt(p -> p.age));
        System.out.println("Sorted by age: " + people);
        
        //Ошибка: ExternalId не реализует Comparable
        List<ExternalId> ids = Arrays.asList(
            new ExternalId("A", 10),
            new ExternalId("B", 5),
            new ExternalId("A", 20)
        );
        
        // ids.sort(Comparator.comparing(id -> id)); // не скомпилируется!
        
        //Решение 1: явный компаратор для ключа
        ids.sort(Comparator.comparing(
            (ExternalId id) -> id.prefix,
            Comparator.naturalOrder() // для строк
        ));
        System.out.println("Sorted by prefix: " + ids);
        
        //Решение 2: составной компаратор через thenComparing
        ids.sort(Comparator
            .comparing((ExternalId id) -> id.prefix)
            .thenComparingInt(id -> id.number));
        System.out.println("Sorted by prefix then number: " + ids);
        
        //Решение 3: собственный компаратор для ключа
        Comparator<ExternalId> byNumberDesc = Comparator.comparing(
            (ExternalId id) -> id.number,
            (n1, n2) -> n2 - n1 // обратный порядок
        );
        ids.sort(byNumberDesc);
        System.out.println("Sorted by number desc: " + ids);
    }
}

import java.util.*;

public class Task270526 {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
            new Person("Alice", 25),
            new Person("Bob", 30),
            new Person("Charlie", 20)
        );
        
        Comparator<Person> comparator = Comparator.comparing(p -> p.age);
        people.sort(comparator);
        System.out.println(people);
    }
    
    static class Person {
        String name;
        int age;
        
        Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        
        @Override
        public String toString() {
            return name + ":" + age;
        }
    }
}

<<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.4.14</version>
</dependency>
<<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>2.0.9</version>
</dependency>

<?xml version="1.0" encoding="UTF-8"?>
<<configuration>

    <!-- Переменная для профиля -->
    <springProperty scope="context" name="PROFILE" source="spring.profiles.active" defaultValue="default"/>
    <!-- Для не-Spring проекта используйте системное свойство -->
    <property name="PROFILE" value="${PROFILE:-default}"/>

    <!-- Консоль: INFO и выше -->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>INFO</level>
        </filter>
    </appender>

    <!-- Файл ошибок: ERROR и выше -->
    <appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>logs/errors.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>logs/errors.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <maxHistory>30</maxHistory>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>10MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n%ex</pattern>
        </encoder>
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>ERROR</level>
        </filter>
    </appender>

    <!-- Файл отладки: DEBUG и выше, только при профиле dev -->
    <appender name="DEBUG_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>logs/debug.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>logs/debug.%d{yyyy-MM-dd}.log</fileNamePattern>
            <maxHistory>7</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} [%X{operation}] - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- Корневой логгер -->
    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
        <appender-ref ref="ERROR_FILE"/>
    </root>

    <!-- Логгер приложения -->
    <logger name="library" level="INFO">
        <!-- DEBUG-файл подключается условно -->
    </logger>

    <!-- Условное включение DEBUG-файла через профиль -->
    <if condition='property("PROFILE").contains("dev")'>
        <then>
            <root level="DEBUG">
                <appender-ref ref="CONSOLE"/>
                <appender-ref ref="ERROR_FILE"/>
                <appender-ref ref="DEBUG_FILE"/>
            </root>
            <logger name="library" level="DEBUG"/>
        </then>
    </if>

</configuration>

<<dependency>
    <groupId>org.codehaus.janino</groupId>
    <artifactId>janino</artifactId>
    <version>3.1.11</version>
</dependency>

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

public class Library {
    private static final Logger log = LoggerFactory.getLogger(Library.class);
    private static final Marker SECURITY = MarkerFactory.getMarker("SECURITY");
    
    private final List<<Book> books = new ArrayList<>();
    
    // ...
}

public void addBook(Book book) {
    MDC.put("operation", "addBook");
    MDC.put("bookId", book.getId());
    
    try {
        Objects.requireNonNull(book, "Книга не может быть null");
        
        if (findById(book.getId()).isPresent()) {
            log.warn("Попытка добавить дубликат книги: id={}", book.getId());
            throw new DuplicateBookException(book.getId());
        }
        
        books.add(book);
        log.info("Книга добавлена: {} автор={} год={}", 
            book.getTitle(), book.getAuthor(), book.getYear());
            
    } finally {
        MDC.clear();
    }
}

public void removeBook(String bookId) {
    MDC.put("operation", "removeBook");
    MDC.put("bookId", bookId);
    
    try {
        Book removed = findById(bookId)
            .orElseThrow(() -> new BookNotFoundException(bookId));
        
        books.remove(removed);
        log.warn("Книга удалена: {} (автор={})", 
            removed.getTitle(), removed.getAuthor());
            
    } finally {
        MDC.clear();
    }
}

private List<<Book> parseBooks(String json) {
    try {
        return objectMapper.readValue(json, new TypeReference<List<<Book>>() {});
    } catch (JsonProcessingException e) {
        MDC.put("operation", "parseJson");
        log.error("Ошибка парсинга JSON: длина={}, причина={}", 
            json.length(), e.getOriginalMessage(), e);
        throw new LibraryException("Невалидный JSON", e);
    } finally {
        MDC.clear();
    }
}

public class MdcOperation implements AutoCloseable {
    private final String operation;
    
    public MdcOperation(String operation, String userId) {
        this.operation = operation;
        MDC.put("operation", operation);
        MDC.put("userId", userId);
        MDC.put("timestamp", Instant.now().toString());
    }
    
    @Override
    public void close() {
        MDC.remove("operation");
        MDC.remove("userId");
        MDC.remove("timestamp");
    }
}

public void processBatch(List<<Book> newBooks, String userId) {
    try (MdcOperation op = new MdcOperation("batchImport", userId)) {
        log.info("Начало пакетного импорта: {} книг", newBooks.size());
        
        for (Book book : newBooks) {
            try {
                addBook(book);
            } catch (DuplicateBookException e) {
                log.warn("Пропущен дубликат в пакете: {}", book.getId());
            }
        }
        
        log.info("Завершён пакетный импорт: добавлено {} из {}", 
            newBooks.size(), newBooks.size());
    }
}

public void clearAllBooks(String userId, String reason) {
    try (MdcOperation op = new MdcOperation("clearAll", userId)) {
        int count = books.size();
        
        log.info(SECURITY, "Запрос на удаление всех книг: причина='{}', пользователь={}", 
            reason, userId);
        
        if (count == 0) {
            log.warn("Попытка очистить пустую библиотеку");
            return;
        }
        
        // Дополнительное подтверждение для критической операции
        log.warn(SECURITY, "ВНИМАНИЕ: Удаление {} книг. Требуется подтверждение.", count);
        
        books.clear();
        
        log.error(SECURITY, "Библиотека полностью очищена: {} книг удалено пользователем {}", 
            count, userId);
    }
}

<<appender name="SECURITY_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>logs/security.log</file>
    <encoder>
        <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [SECURITY] %X{userId} %X{operation} - %msg%n</pattern>
    </encoder>
    <filter class="ch.qos.logback.core.filter.EvaluatorFilter">
        <evaluator class="ch.qos.logback.classic.boo.JaninoEventEvaluator">
            <expression>return marker != null &amp;&amp; marker.contains("SECURITY");</expression>
        </evaluator>
        <OnMatch>ACCEPT</OnMatch>
        <OnMismatch>DENY</OnMismatch>
    </filter>
</appender>

<<root level="INFO">
    <appender-ref ref="CONSOLE"/>
    <appender-ref ref="ERROR_FILE"/>
    <appender-ref ref="SECURITY_FILE"/>
</root>

// Опасно: пароль попадёт в лог
log.info("Авторизация: user={}, password={}", username, password);

public class User {
    private String login;
    private String passwordHash;  // храним хэш, не пароль
    private String plainPassword;  // только при создании, не логируем
    
    @Override
    public String toString() {
        return "User[login=" + login + ", password=***]";
    }
}

public String toLogString() {
    return "User[login=" + login + ", roles=" + roles + "]";
}

import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.filter.Filter;
import ch.qos.logback.core.spi.FilterReply;

public class PasswordMaskingFilter extends Filter<<ILoggingEvent> {
    private static final Pattern PASSWORD_PATTERN = 
        Pattern.compile("(?i)(password|passwd|pwd)\\s*=\\s*[^\\s,}]+");
    
    @Override
    public FilterReply decide(ILoggingEvent event) {
        String message = event.getFormattedMessage();
        if (PASSWORD_PATTERN.matcher(message).find()) {
            // Можно: заменить, отклонить, или передать с предупреждением
            return FilterReply.DENY;  // Полностью блокируем сообщение с паролем
        }
        return FilterReply.NEUTRAL;
    }
}

<<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
    <filter class="library.logging.PasswordMaskingFilter"/>
    <!-- ... -->
</appender>

public void authenticate(String login, char[] password) {
    // password — массив символов, не строка
    log.info("Попытка авторизации: login={}", login);
    
    boolean success = checkPassword(login, password);
    
    if (success) {
        log.info("Успешная авторизация: login={}", login);
    } else {
        log.warn("Неудачная авторизация: login={}", login);
    }
    
    // Очистка массива
    Arrays.fill(password, '\0');
}

public void addBookWithMetrics(Book book) {
    long start = System.currentTimeMillis();
    // ... операция ...
    long duration = System.currentTimeMillis() - start;
    log.info("Метрика: operation=addBook, durationMs={}", duration);
}

<<appender name="AUDIT" class="ch.qos.logback.core.FileAppender">
    <file>logs/audit.log</file>
    <append>true</append>
    <encoder>
        <pattern>%d{ISO8601} %X{userId} %X{operation} %msg%n</pattern>
    </encoder>
</appender>

import java.util.Arrays;
import java.util.List;

public class Task280526 {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(-5, -3, -1);
        int max = numbers.stream().reduce(0, Integer::max);
        System.out.println(max);
    }
}