F2

// Only showing the modified parts that need to change:



public class SQLAnalyzer {

    // Updated pattern to properly capture all states

    private static final Pattern LOG_PATTERN = Pattern.compile(

        // First part captures ACTIVE/STUCK states

        "\\[(ACTIVE|STUCK)\\].*?ExecuteThread: '(\\d+)'.*?(?:preparing:|select)\\s+(.+?)(?=\\[|$)|" +

        // Second part captures Async-Pool threads

        "\\[(Async-Pool-\\d+-Thread-\\d+)\\].*?(?:preparing:|select)\\s+(.+?)(?=\\[|$)",

        Pattern.CASE_INSENSITIVE);



    private void processLine(String line, int lineNumber) {

        Matcher matcher = LOG_PATTERN.matcher(line);

        if (matcher.find()) {

            String state;

            String threadId;

            String sqlStatement;

            boolean isAsyncPool;



            // Check if this is a regular (ACTIVE/STUCK) thread

            if (matcher.group(1) != null) {

                // Regular thread case

                state = matcher.group(1);

                threadId = matcher.group(2);

                sqlStatement = matcher.group(3);

                isAsyncPool = false;

            } else {

                // Async-Pool thread case

                state = matcher.group(4);

                threadId = state;  // Use the full Async-Pool-X-Thread-Y as the ID

                sqlStatement = matcher.group(5);

                isAsyncPool = true;

            }



            if (sqlStatement != null) {

                // Normalize SQL statement

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



                // Add to distribution

                queryDistribution

                    .computeIfAbsent(normalizedSQL, QueryStats::new)

                    .addOccurrence(threadId, state, lineNumber, isAsyncPool);



                knownStates.add(state);

            }

        }

    }



    // Optional debug method to help verify pattern matching

    private void debugProcessLine(String line) {

        System.out.println("\nAnalyzing line: " + line);

        Matcher matcher = LOG_PATTERN.matcher(line);

        if (matcher.find()) {

            System.out.println("Match found!");

            System.out.println("Regular thread state: " + matcher.group(1));

            System.out.println("Regular thread ID: " + matcher.group(2));

            System.out.println("Regular thread SQL: " + matcher.group(3));

            System.out.println("Async thread full state: " + matcher.group(4));

            System.out.println("Async thread SQL: " + matcher.group(5));

        } else {

            System.out.println("No match found");

        }

    }



    // Add this to main method for debugging

    public static void main(String[] args) {

        if (args.length < 2) {

            System.out.println("Usage: java SQLAnalyzer <log-file-path> <output-file-path> [--debug]");

            return;

        }



        SQLAnalyzer analyzer = new SQLAnalyzer();

        try {

            boolean debug = args.length > 2 && args[2].equals("--debug");



            if (debug) {

                // Read first few lines for debugging

                try (BufferedReader reader = new BufferedReader(new FileReader(args[0]))) {

                    String line;

                    int count = 0;

                    while ((line = reader.readLine()) != null && count < 5) {

                        analyzer.debugProcessLine(line);

                        count++;

                    }

                }

                return;

            }



            analyzer.analyzeLogs(args[0]);

            analyzer.writeAnalysisToFile(args[1]);

            System.out.println("\nAnalysis complete. Results have been written to: " + args[1]);

        } catch (IOException e) {

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

            e.printStackTrace();

        }

    }

}