Mini-challenge: Log aggregator với NIO.2 và Stream

[2025-04-01T10:00:15Z] INFO  [svc-auth] User login OK
[2025-04-01T10:00:16Z] ERROR [svc-order] Order creation failed: out of stock
[2025-04-01T10:00:17Z] WARN  [svc-auth] Slow query detected 1200ms

record LogLine(Instant time, String level, String service, String message) { }

Map<LocalDate, Map<String, Long>> countByLevelPerDay(Path dir) throws IOException

{
  2025-04-01: {INFO=120, ERROR=5, WARN=3},
  2025-04-02: {INFO=98,  ERROR=12}
}

Map<String, Long> errorsByService(Path dir) throws IOException

date,level,count
2025-04-01,ERROR,5
2025-04-01,INFO,120
...

service,error_count
svc-auth,8
svc-order,15

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.time.*;
import java.util.*;
import java.util.regex.*;
import java.util.stream.*;

public class LogAggregatorApp {

    public record LogLine(Instant time, String level, String service, String message) {
        static final Pattern PATTERN = Pattern.compile(
            "\\[(\\S+)\\] (\\w+)\\s+\\[(\\S+)\\] (.+)");

        public static LogLine parse(String line) {
            Matcher m = PATTERN.matcher(line);
            if (!m.matches()) return null;
            try {
                return new LogLine(
                    Instant.parse(m.group(1)),
                    m.group(2),
                    m.group(3),
                    m.group(4));
            } catch (DateTimeException e) {
                return null;
            }
        }

        public LocalDate date() {
            return LocalDate.ofInstant(time, ZoneOffset.UTC);
        }
    }

    public static class LogAggregator {

        // Stream all log lines across all .log files under dir
        private Stream<LogLine> streamAllLines(Path dir) throws IOException {
            // TODO:
            // 1. Files.walk(dir)
            // 2. filter isRegularFile + name endsWith .log
            // 3. flatMap -> Files.lines(file)
            // 4. map LogLine::parse
            // 5. filter non-null
            // Note: streams must be closed - consumer responsibility
            return Stream.empty();
        }

        public Map<LocalDate, Map<String, Long>> countByLevelPerDay(Path dir) throws IOException {
            // TODO: consume streamAllLines va groupingBy 2 tang
            return Map.of();
        }

        public Map<String, Long> errorsByService(Path dir) throws IOException {
            // TODO: filter ERROR, groupingBy service, counting
            return Map.of();
        }

        public void writeReport(Path dir, Path outputCsv) throws IOException {
            // TODO: build CSV string, Files.writeString(outputCsv, csv, UTF_8)
        }
    }

    // Helper: tao data fake de test
    public static void seedLogs(Path dir) throws IOException {
        Files.createDirectories(dir);
        String[] samples = {
            "[2025-04-01T10:00:15Z] INFO  [svc-auth] User login OK",
            "[2025-04-01T10:00:16Z] ERROR [svc-order] Order creation failed: out of stock",
            "[2025-04-01T10:00:17Z] WARN  [svc-auth] Slow query detected 1200ms",
            "[2025-04-01T10:01:18Z] ERROR [svc-auth] Login rate limit",
            "[2025-04-02T09:00:00Z] INFO  [svc-order] Daily summary",
            "[2025-04-02T09:30:00Z] ERROR [svc-order] DB timeout",
            "malformed line ignore me",
            "[2025-04-02T10:00:00Z] INFO  [svc-auth] Token refresh"
        };
        Files.write(dir.resolve("service-a.log"), List.of(samples), StandardCharsets.UTF_8);
        Files.createDirectories(dir.resolve("service-b"));
        Files.write(dir.resolve("service-b/2025-04-02.log"), List.of(
            "[2025-04-02T11:00:00Z] ERROR [svc-payment] Card declined",
            "[2025-04-02T11:05:00Z] INFO  [svc-payment] Retry success",
            "[2025-04-02T11:10:00Z] ERROR [svc-payment] Fraud detected"
        ), StandardCharsets.UTF_8);
    }

    public static void main(String[] args) throws IOException {
        Path dir = Path.of("tmp-logs");
        seedLogs(dir);

        LogAggregator agg = new LogAggregator();
        Map<LocalDate, Map<String, Long>> byDay = agg.countByLevelPerDay(dir);
        Map<String, Long> byService = agg.errorsByService(dir);

        System.out.println("By day/level:");
        byDay.forEach((d, m) -> System.out.printf("  %s -> %s%n", d, m));

        System.out.println("Errors by service:");
        byService.forEach((s, c) -> System.out.printf("  %s: %d%n", s, c));

        Path report = dir.resolve("report.csv");
        agg.writeReport(dir, report);
        System.out.println("\nReport written to: " + report.toAbsolutePath());
    }
}

javac LogAggregatorApp.java
java LogAggregatorApp

.parallelStream()
.collect(Collectors.groupingByConcurrent(...));

private Stream<LogLine> streamLazy(Path dir) throws IOException {
    Stream<Path> files = Files.walk(dir);
    return files
        .filter(Files::isRegularFile)
        .filter(p -> p.toString().endsWith(".log"))
        .flatMap(p -> {
            try {
                Stream<String> lines = Files.lines(p, StandardCharsets.UTF_8);
                return lines.map(LogLine::parse).filter(Objects::nonNull);
            } catch (IOException e) {
                return Stream.empty();
            }
        })
        .onClose(files::close);
}

// Consumer phai try-with-resources:
try (Stream<LogLine> s = agg.streamLazy(dir)) {
    Map<...> result = s.collect(...);
}

interface ReportWriter {
    void write(Report report, Path output) throws IOException;
}

class CsvWriter implements ReportWriter { ... }
class JsonWriter implements ReportWriter { ... }