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

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 {

        // Lazy pipeline: walk -> .log files -> lines -> parsed LogLine.
        // Stream.flatMap closes each inner Files.lines stream after its
        // contents are consumed - only 1 file is open at a time.
        // Caller owns the outer files stream (try-with-resources).
        private Stream<LogLine> logLines(Stream<Path> files) {
            return files
                .filter(Files::isRegularFile)
                .filter(p -> p.toString().endsWith(".log"))
                .flatMap(this::tryLines)
                .map(LogLine::parse)
                .filter(Objects::nonNull);
        }

        private Stream<String> tryLines(Path file) {
            try {
                return Files.lines(file, StandardCharsets.UTF_8);
            } catch (IOException e) {
                System.err.println("Skipped " + file + ": " + e.getMessage());
                return Stream.empty();
            }
        }

        public Map<LocalDate, Map<String, Long>> countByLevelPerDay(Path dir) throws IOException {
            try (Stream<Path> files = Files.walk(dir)) {
                return logLines(files)
                    .collect(Collectors.groupingBy(
                        LogLine::date,
                        TreeMap::new,
                        Collectors.groupingBy(
                            LogLine::level,
                            Collectors.counting())));
            }
        }

        public Map<String, Long> errorsByService(Path dir) throws IOException {
            try (Stream<Path> files = Files.walk(dir)) {
                return logLines(files)
                    .filter(l -> "ERROR".equals(l.level()))
                    .collect(Collectors.groupingBy(
                        LogLine::service,
                        Collectors.counting()));
            }
        }

        public void writeReport(Path dir, Path outputCsv) throws IOException {
            Map<LocalDate, Map<String, Long>> byDay = countByLevelPerDay(dir);
            Map<String, Long> byService = errorsByService(dir);

            StringBuilder csv = new StringBuilder();
            csv.append("date,level,count\n");
            byDay.forEach((date, levelMap) ->
                levelMap.entrySet().stream()
                    .sorted(Map.Entry.comparingByKey())
                    .forEach(e -> csv.append(date).append(",")
                        .append(e.getKey()).append(",")
                        .append(e.getValue()).append("\n")));

            csv.append("\nservice,error_count\n");
            byService.entrySet().stream()
                .sorted(Map.Entry.<String, Long>comparingByValue().reversed())
                .forEach(e -> csv.append(e.getKey()).append(",")
                    .append(e.getValue()).append("\n"));

            Files.writeString(outputCsv, csv.toString(), StandardCharsets.UTF_8);
        }
    }

    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("\nErrors by service:");
        byService.forEach((s, c) -> System.out.printf("  %-15s %d%n", s, c));

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