Logging in Java

import java.util.logging.Logger;
import java.util.logging.Level;

public class Main {
    // One logger per class, named after the class. Make it static final.
    private static final Logger log = Logger.getLogger("UserService");

    public static void main(String[] args) {
        // In production you run at INFO: anything below INFO is dropped.
        log.setLevel(Level.INFO);

        // Cheapest, noisiest messages. FINE here ~ DEBUG/TRACE elsewhere.
        log.fine("Entering findUser()");          // dropped (below INFO)
        log.fine("SQL: SELECT * FROM users");      // dropped (below INFO)

        // Normal, expected business events. Kept in production.
        log.info("User logged in: id=42");         // shown

        // Something looks off but the app keeps going.
        log.warning("Rate limit near: 950/1000");  // shown

        // A real failure a human must look at.
        log.severe("Payment failed for ORD-123");  // shown
    }
}

INFO: User logged in: id=42
WARNING: Rate limit near: 950/1000
SEVERE: Payment failed for ORD-123

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

public class OrderService {
    // SLF4J names the logger from the class — no hand-typed strings.
    private static final Logger log = LoggerFactory.getLogger(OrderService.class);

    public void placeOrder(String orderId, int items) {
        // Parameterized logging: {} is a placeholder filled by the next argument.
        // The string is only built if this level is actually enabled — so it is cheap.
        log.debug("Validating order {} with {} items", orderId, items);
        log.info("Order {} placed ({} items)", orderId, items);

        if (items > 100) {
            log.warn("Large order {}: {} items", orderId, items);
        }

        try {
            charge(orderId);
        } catch (Exception e) {
            // Pass the exception LAST, with NO {} for it — SLF4J prints the stack trace.
            log.error("Charge failed for order {}", orderId, e);
        }
    }

    private void charge(String orderId) { /* talk to payment provider */ }
}

# With Logback at INFO level, for placeOrder("ORD-9", 3):
14:02:11.310 INFO  OrderService - Order ORD-9 placed (3 items)
# (the debug line is dropped at INFO; warn/error appear only when triggered)

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

public class Main {
    private static final Logger log = LoggerFactory.getLogger(Main.class);

    public static void main(String[] args) {
        // 🎯 YOUR TURN — fill in the blanks marked with ___

        int userId = 42;

        // 1) A routine, expected event — "user logged in". Use the production level.
        log.___("User logged in: id={}", userId);   // 👉 the everyday "it happened" level

        // 2) Something suspicious but not fatal — a slow database query.
        log.___("Slow query: 1200ms");               // 👉 the "heads up" level

        // 3) A real failure a human must fix — the database is unreachable.
        log.___("Database unreachable");             // 👉 the most severe level

        // ✅ Expected output (at INFO level):
        // INFO  Main - User logged in: id=42
        // WARN  Main - Slow query: 1200ms
        // ERROR Main - Database unreachable
    }
}

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

public class Main {
    private static final Logger log = LoggerFactory.getLogger(Main.class);

    public static void main(String[] args) {
        // 🎯 YOUR TURN — fill in the blanks marked with ___
        // Rewrite these using PLACEHOLDERS instead of "+" concatenation.

        String user = "alice";
        int orders = 3;

        // 1) One placeholder. Replace the + concatenation with a {} placeholder.
        // BAD:  log.info("Welcome " + user);
        log.info("Welcome ___", user);               // 👉 put a {} where the name goes

        // 2) Two placeholders, filled left-to-right by the two arguments.
        log.info("User ___ has ___ orders", user, orders);  // 👉 two {} placeholders

        // ✅ Expected output (at INFO level):
        // INFO  Main - Welcome alice
        // INFO  Main - User alice has 3 orders
    }
}

<configuration>
  <!-- Rolls the log over by size AND date, keeps 30 days, caps total at 3GB. -->
  <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>logs/app.log</file>
    <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
      <fileNamePattern>logs/app.%d{yyyy-MM-dd}.%i.log.gz</fileNamePattern>
      <maxFileSize>100MB</maxFileSize>
      <maxHistory>30</maxHistory>
      <totalSizeCap>3GB</totalSizeCap>
    </rollingPolicy>
    <encoder>
      <!-- %X{requestId} pulls the value MDC.put("requestId", ...) stored. -->
      <pattern>%d %-5level [%X{requestId}] %logger - %msg%n</pattern>
    </encoder>
  </appender>

  <!-- Your own code logs at DEBUG; everything else stays at INFO. -->
  <logger name="com.myapp" level="DEBUG"/>
  <root level="INFO">
    <appender-ref ref="FILE"/>
  </root>
</configuration>

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

public class Main {
    private static final Logger log = LoggerFactory.getLogger(Main.class);

    // 🎯 MINI-CHALLENGE: tag every log line with a request id
    // 1. MDC.put("requestId", "req-7")  before doing the work
    // 2. log.info("Loading cart")  and  log.info("Checkout done")
    // 3. In a finally block, MDC.clear()  so the id never leaks to the next request
    //
    // With pattern  %-5level [%X{requestId}] %logger - %msg%n  you should see:
    // ✅ Expected output:
    // INFO  [req-7] Main - Loading cart
    // INFO  [req-7] Main - Checkout done

    public static void main(String[] args) {
        // your code here
    }
}