Dev10V2

import java.io.*;

import java.util.*;

import java.util.regex.*;

import java.util.stream.Collectors;



public class SQLLogAnalyzer {

    // Updated pattern to capture all possible thread states and include SELECT in output

    private static final Pattern LOG_PATTERN = Pattern.compile(".*?\\[((?:ACTIVE|STUCK|Async-Pool-\\d+-thread-\\d+|.*?))\\].*?(?:ExecuteThread:\\s+'(\\d+)'|).*?((?i)SELECT\\s+.*)");

    private final Map<String, QueryStats> queryDistribution;

    private final Set<String> knownStates;



    public SQLLogAnalyzer() {

        this.queryDistribution = new HashMap<>();

        this.knownStates = new HashSet<>();

    }



    private static String repeatString(String str, int count) {

        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < count; i++) {

            sb.append(str);

        }

        return sb.toString();

    }



    public static class ThreadInfo {

        private final String threadId;

        private int occurrences;

        private final Set<Integer> lineNumbers;



        public ThreadInfo(String threadId) {

            this.threadId = threadId;

            this.occurrences = 0;

            this.lineNumbers = new HashSet<>();

        }



        public void addOccurrence(int lineNumber) {

            occurrences++;

            lineNumbers.add(lineNumber);

        }



        @Override

        public String toString() {

            return String.format("Thread %s: %d occurrences, Lines: %s", 

                threadId, 

                occurrences,

                lineNumbers.stream()

                    .sorted()

                    .map(String::valueOf)

                    .collect(Collectors.joining(", "))

            );

        }

    }



    public static class StateInfo {

        private final Map<String, ThreadInfo> threadStats;

        private int totalOccurrences;



        public StateInfo() {

            this.threadStats = new HashMap<>();

            this.totalOccurrences = 0;

        }



        public void addOccurrence(String threadId, int lineNumber) {

            threadStats.computeIfAbsent(threadId, ThreadInfo::new)

                      .addOccurrence(lineNumber);

            totalOccurrences++;

        }



        public int getTotalOccurrences() {

            return totalOccurrences;

        }



        public Collection<ThreadInfo> getThreadStats() {

            return threadStats.values();

        }

    }



    public static class QueryStats {

        private final String originalQuery;

        private final String normalizedQuery;

        private int occurrences;

        private final Map<String, StateInfo> stateStats;



        public QueryStats(String query) {

            this.originalQuery = query.trim();

            this.normalizedQuery = normalizeQuery(query);

            this.occurrences = 0;

            this.stateStats = new HashMap<>();

        }



        private static String normalizeQuery(String query) {

            return query.replaceAll("\\s+", " ").trim();

        }



        public void addOccurrence(String threadId, String state, int lineNumber) {

            occurrences++;

            stateStats.computeIfAbsent(state, k -> new StateInfo())

                     .addOccurrence(threadId, lineNumber);

        }



        @Override

        public String toString() {

            StringBuilder sb = new StringBuilder();

            sb.append(String.format("Query: %s%n", originalQuery));

            sb.append(String.format("Total Occurrences: %d%n", occurrences));



            // State-wise breakdown

            sb.append("State Distribution:\n");

            stateStats.forEach((state, stateInfo) -> {

                sb.append(String.format("  %s (Total: %d):%n", state, stateInfo.getTotalOccurrences()));

                stateInfo.getThreadStats().forEach(threadInfo -> 

                    sb.append(String.format("    %s%n", threadInfo))

                );

            });



            return sb.toString();

        }



        public String getNormalizedQuery() {

            return normalizedQuery;

        }

    }



    public void analyzeLogs(String filePath) throws IOException {

        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {

            String line;

            int lineNumber = 0;



            while ((line = reader.readLine()) != null) {

                lineNumber++;

                processLine(line, lineNumber);

            }

        }

    }



    private void processLine(String line, int lineNumber) {

        Matcher matcher = LOG_PATTERN.matcher(line);

        if (matcher.find()) {

            String state = matcher.group(1);

            knownStates.add(state);

            String threadId = matcher.group(2) != null ? matcher.group(2) : "N/A";

            String sqlStatement = matcher.group(3).trim();



            String normalizedSQL = sqlStatement.replaceAll("\\s+", " ").trim();

            queryDistribution

                .computeIfAbsent(normalizedSQL, query -> new QueryStats(sqlStatement))

                .addOccurrence(threadId, state, lineNumber);

        }

    }



    public void printAnalysis() {

        System.out.println("=== SQL Query Analysis ===\n");



        queryDistribution.values().stream()

            .sorted((a, b) -> Integer.compare(b.occurrences, a.occurrences))

            .forEach(stats -> {

                System.out.println(stats);

                System.out.println(repeatString("-", 80) + "\n");

            });



        printSummaryStats();

    }



    private void printSummaryStats() {

        System.out.println("=== Summary Statistics ===");



        System.out.println("Total unique queries: " + queryDistribution.size());



        System.out.println("\nThread states found: " + 

            knownStates.stream().sorted().collect(Collectors.joining(", ")));



        Map<String, Integer> totalStateDistribution = new HashMap<>();

        queryDistribution.values().forEach(stats -> 

            stats.stateStats.forEach((state, stateInfo) -> 

                totalStateDistribution.merge(state, stateInfo.getTotalOccurrences(), Integer::sum))

        );



        System.out.println("\nOverall state distribution:");

        totalStateDistribution.entrySet().stream()

            .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())

            .forEach(entry -> 

                System.out.printf("  %s: %d occurrences%n", entry.getKey(), entry.getValue())

            );

    }



    public static void main(String[] args) {

        if (args.length != 1) {

            System.out.println("Usage: java SQLLogAnalyzer <log-file-path>");

            return;

        }



        SQLLogAnalyzer analyzer = new SQLLogAnalyzer();

        try {

            analyzer.analyzeLogs(args[0]);

            analyzer.printAnalysis();

        } catch (IOException e) {

            System.err.println("Error processing log file: " + e.getMessage());

            e.printStackTrace();

        }

    }

}