Merge pull request #2 from soumyaprasadrana/dev

💡 Macro Multithread recording and playback

Author: soumyaprasadrana

.gitignore

@@ -2,4 +2,5 @@ node_modules/
 out
 classes/
 macros/
-vscode-java-debugx-*
+vscode-java-debugx-*.json
+vscode-java-debugx-*.vsix

README.md

@@ -16,96 +16,97 @@
 ---
 
 
-## Overview
+## 🌟 Overview
 
-**Java DebugX** is a Visual Studio Code extension aimed at improving Java debugging by offering advanced macro recording and playback features. It allows developers to record key debugging events such as step-in, step-out, and breakpoints in a macro JSON format. This feature enables users to capture complex debugging sessions and replay them later, saving time and eliminating the need to manually redo the debugging process.
+**Java DebugX** is a powerful Visual Studio Code extension designed to enhance your Java debugging experience with advanced macro recording and playback features. 📽️✨ With Java DebugX, you can record essential debugging events—like **step-in**, **step-out**, and **breakpoints**—in a structured JSON format. 
 
+This feature enables you to capture intricate debugging sessions and replay them effortlessly, saving time and sparing you from manually redoing steps. ⏱️🔄 Perfect for complex Java applications, Java DebugX streamlines your workflow and boosts your productivity. ⚡
 
 ## Features
 
-- **Macro Recording and Playback**: Record debugging sessions, including step-ins, step-outs, and breakpoints. Play back the recorded sessions at any time.
+- 🎥 **Macro Recording & Playback**: Effortlessly record your debugging sessions, capturing all **step-ins**, **step-outs**, and **breakpoints**. Rewind and replay these recorded sessions anytime for quick and efficient troubleshooting! ⏪⏯️
  **Recording**
 ![JavaDebugXMacroRecording](/media/vscode-java-debugx-macro-recording.gif)
  **Playback**
 ![JavaDebugXMacro](/media/vscode-java-debugx-play-macro.gif)
+**🧵 Enhanced Multi-Threaded Compatibility**
+Java DebugX is designed to work seamlessly with **multi-threaded debugging**! 🎉 Now, you can record and replay debugging sessions even in complex, multi-threaded applications. This enhancement captures step-in, step-over, and other critical debugging events across threads, allowing you to efficiently review and trace through complex scenarios without retracing steps manually. 🚀
+![JavaDebugXMacroMultiThread](/media/vscode-java-debugx-play-macro-play-multithread.gif)
 
-- **Customizable Bridge Configurations**: Define custom bridge classes and methods to integrate additional debugging insights.
-- **Advanced Debug Insights**: View detailed, real-time debugging information in a dedicated Insights view.
+- 🔧 **Customizable Bridge Configurations**: Set up custom bridge classes and methods to bring extra insights into your debugging process, tailored to your needs. 🌉
+- 🕵️‍♂️ **Advanced Debug Insights**: Access in-depth, real-time debugging details in the specialized **Insights** view for more informed problem-solving. 📊
 ![DebugInsight](/media/vscode-java-debugx-bridge.gif)
 
-- **Search External Files**: Search and index external files during debugging to improve traceability.
-- **Customizable File Patterns**: Define which files to include when indexing external files.
+- 🔍 **Search External Files**: Seamlessly search and index external files during debugging to boost traceability and streamline your workflow. 📁
+- 🎛️ **Customizable File Patterns**: Tailor which files to include in indexing external files by defining custom file patterns for optimized debugging. 📝
 
 
 
 
-## Installation
+## 🚀 Installation
 
 To install the **Java DebugX** extension in Visual Studio Code:
 
 1. Open **Visual Studio Code**.
 2. Go to the **Extensions** view by clicking on the Extensions icon in the Activity Bar or pressing `Ctrl+Shift+X`.
-3. Search for **Java DebugX**.
-4. Click **Install**.
-
-Here's the updated section with the Open VSX URL included:
+3. 🔍 Search for **Java DebugX**.
+4. Click **Install** to add it to your editor.
 
 > Alternatively, you can install it directly from the [Marketplace](https://marketplace.visualstudio.com/items?itemName=soumyaprasadrana.vscode-java-debugx) or from [Open VSX](https://open-vsx.org/extension/soumyaprasadrana/vscode-java-debugx).
 
-## Getting Started
-
-Once installed, the extension is activated when a Java project is opened. You can then start using the extension to record, play, and analyze debugging sessions.
+## 🎉 Getting Started
 
-### Key Features and Commands
+After installing **Java DebugX**, it activates automatically whenever you open a Java project. You can now dive right in and start using its powerful features to record, play back, and analyze your debugging sessions for a more efficient development workflow! 🛠️
 
-- **Start Macro Recording**: Begin recording your debugging session. This will capture step-ins, step-outs, and breakpoints.
-- **Stop Macro Recording**: Stop recording and save the session data.
-![MacroRecActions](/media/vscode-java-debugx-macro-start-stop.gif)
-- **Play Macro Recording**: Re-execute the recorded session.
-- **Pause/Resume/Stop Macro Playback**: Pause,resume or stop the playback of your recorded debugging session.
-![MacroRecPlayActions](/media/vscode-java-debugx-play-macro-action-buttons.gif)
-- **Generate Sample Bridge Config**: Generate a sample configuration file to set up your custom bridge and define commands.
-- **Debug Insights**: View detailed insights from bridge configuration into your debugging session through a dedicated panel.
+### 🚀 Key Features and Commands
 
-You can access these commands via the **Command Palette** (`Ctrl+Shift+P`), or find them in the **JavaDebugX** menu.
+- **🎬 Start Macro Recording**: Begin capturing your debugging session, including step-ins, step-outs, and breakpoints.
+- **⏹️ Stop Macro Recording**: End the recording and save the session data.  
+  ![MacroRecActions](/media/vscode-java-debugx-macro-start-stop.gif)
+- **▶️ Play Macro Recording**: Re-execute the captured debugging session.
+- **⏸️/▶️/⏹️ Pause, Resume, or Stop Playback**: Control the playback of your recorded debugging session.  
+  ![MacroRecPlayActions](/media/vscode-java-debugx-play-macro-action-buttons.gif)
+- **🛠️ Generate Sample Bridge Config**: Create a sample config file to define custom bridge commands and methods.
+- **🔍 Debug Insights**: Access detailed insights and bridge configurations in a dedicated panel for enriched debugging information.
 
+These commands are accessible through the **Command Palette** (`Ctrl+Shift+P`). Happy debugging! 🎉
 
-## Configuration
+## Configuration ⚙️
 
 You can configure the extension by modifying the settings in your `settings.json`. The available settings are:
 
-- **java.debugx.filePatterns**: Define file patterns to include when indexing external files (e.g., `*.java`, `*.js`, `*.xml`).
-- **java.debugx.externalFolder**: Set the path to an external folder that you want to index.
-- **java.debugx.macro.stepDelayInSeconds**: Configure the step delay during macro playback.
-- **java.debugx.bridgeConfigPath**: Set the absolute path to your custom bridge configuration file.
-
-You can access and modify these settings in the **Settings** tab or directly in your `settings.json` file.
+- **java.debugx.filePatterns** 📂: Define file patterns to include when indexing external files (e.g., `*.java`, `*.js`, `*.xml`).
+- **java.debugx.externalFolder** 🗂️: Set the path to an external folder that you want to index.
+- **java.debugx.macro.stepDelayInSeconds** ⏱️: Configure the step delay during macro playback.
+- **java.debugx.bridgeConfigPath** 🔧: Set the absolute path to your custom bridge configuration file.
 
-## Views and Menus
+You can access and modify these settings in the **Settings** tab ⚙️ or directly in your `settings.json` file. 
 
-- **Insights View**: A dedicated view to show real-time debugging insights.
-![DebugInsightView](/media/vscode-java-debugx-bridge-insights.gif)
+## Views and Menus 🖥️
 
-- **Debug Toolbar**: Commands for controlling the macro recording and playback are available in the debug toolbar.
+- **Insights View** 📊: A dedicated view to show real-time debugging insights.  
+  ![DebugInsightView](/media/vscode-java-debugx-bridge-insights.gif)
 
-## Example Usage
+- **Debug Toolbar** 🛠️: Commands for controlling the macro recording and playback are available in the debug toolbar.
 
-### Generating a Sample Bridge Config
+## Example Usage 💡
 
-To generate a sample bridge configuration file:
+### Typical Scenario 🚀
 
-1. Open the Command Palette (`Ctrl+Shift+P`).
-2. Search for and select **Generate Sample Bridge Config**.
+Here’s a typical scenario: You’re debugging a large Java application and find a potential root cause. But after stepping forward, you realize you need to repeat the process to verify something. In a real-life setting, this is where Java DebugX shines—you can record the session once, then replay it up to the exact point you need to examine again.
 
-This will generate a new bridge configuration file in your workspace, which you can modify to create your custom bridge logic.
+**Java DebugX** even includes enhanced diagnostics to help when your macro takes a wrong path. If your playback reaches a point that differs from the expected line (like reaching an unexpected catch block or exception), DebugX will try to gather diagnostics and log them to a file, giving you a better understanding of potential issues. 📂🛠️
 
+### Generating a Sample Bridge Config ⚙️
 
+To generate a sample bridge configuration file:
 
-## Limitation
+1. Open the Command Palette (`Ctrl+Shift+P`) 🔍.
+2. Search for and select **Generate Sample Bridge Config** 📝.
 
-The macro recording feature is well-tested when your debug session interacts with only a single thread. However, if you are debugging multiple threads simultaneously, the events will be recorded but playback might not work as expected. We are actively working on improving support for multi-threaded debugging sessions.
+This will generate a new bridge configuration file in your workspace, which you can modify to create your custom bridge logic. 🔧
 
-## Development
+## Development 🛠️
 
 If you'd like to contribute or develop the extension locally, follow these steps:
 
@@ -117,19 +118,18 @@ If you'd like to contribute or develop the extension locally, follow these steps
    ```bash
    npm install
    ```
-3. Launch the extension in VS Code with from debug view
+3. Launch the extension in VS Code from the debug view ▶️
 
-## License
+## License 📜
 
 This project is licensed under the [SEE LICENSE IN LICENSE](LICENSE).
 
-## Author
+## Author ✍️
 
 **Soumya Prasad Rana**  
-Email: soumyaprasad.rana@gmail.com  
-GitHub: [soumyaprasadrana](https://github.com/soumyaprasadrana)
+Email: soumyaprasad.rana@gmail.com 📧  
+GitHub: [soumyaprasadrana](https://github.com/soumyaprasadrana) 🐙
 
-## Support
+## Support 🆘
 
 If you encounter any issues or need help, please visit the [issues page](https://github.com/soumyaprasadrana/vscode-java-debugx/issues) and open a new issue or check for existing discussions.
-

media/vscode-java-debugx-play-macro-play-multithread.gif

@@ -6,7 +6,7 @@
     "name": "Soumya Prasad Rana",
     "email": "soumyaprasad.rana@gmail.com"
   },
-  "version": "1.0.2",
+  "version": "1.0.3",
   "publisher": "soumyaprasadrana",
   "icon": "vscode-java-debugx.png",
   "engines": {

media/vscode-java-debugx-play-small-macro.gif

@@ -52,6 +52,9 @@ export class DebugSessionsTracker implements vscode.DebugAdapterTracker {
     private currentFrame: any;
     private currentThread: any;
 
+    private debugRequestMap: Map<number, { request: any; response: any }> = new Map();
+
+
     // Singleton implementation
     private constructor(session: vscode.DebugSession) {
         this.setActiveSession(session);
@@ -186,13 +189,30 @@ export class DebugSessionsTracker implements vscode.DebugAdapterTracker {
 
     onWillReceiveMessage(message: any) {
         //console.log("onWillReceiveMessage", message);
+        if (message && message.type && message.type == 'request' && (message.command == 'threads' || message.command == 'evaluate' || message.command == 'variables')) return; //Performance ; We don't need these request for macro processing
+
         this.debugSessionEventTracker.push({ event: "onWillReceiveMessage", eventMessage: message });
+        if (message && message.type && message.type == 'request') {
+            //Store the request into the map
+            this.debugRequestMap.set(message.seq, { request: message, response: null })
+        }
     }
 
     onDidSendMessage?(message: any): void {
         //console.log("onDidSendMessage", message);
+        if (message && message.type && message.type == 'response' && (message.command == 'threads' || message.command == 'evaluate' || message.command == 'variables')) return; //Performance ; We don't need these request for macro processing
+
         this.debugSessionEventTracker.push({ event: "onDidSendMessage", eventMessage: message });
 
+        if (message && message.type && message.type == 'response') {
+            let reqMap = this.debugRequestMap.get(message.request_seq);
+            if (reqMap) {
+                reqMap.response = message;
+                this.debugRequestMap.set(message.request_seq, reqMap);
+            }
+
+        }
+
         if (message.event === 'stopped') {
             this.currentThread = message.body.threadId;
         } else if (message.command === 'stackTrace' && this.currentThread !== null) {
@@ -292,7 +312,7 @@ export class DebugSessionsTracker implements vscode.DebugAdapterTracker {
                                     lastStackFrame.line !== currentFrame.line ||
                                     lastStackFrame.method !== currentFrame.method) {
                                     // Extract the last relevant event for the step
-                                    const lastEvent = this.getLastThreadOperationEvent(sessionData.events);
+                                    const lastEvent = this.getLastThreadOperationEvent(sessionData.events, eventMessage);
 
                                     if (lastStoppedEvent.body.reason == 'breakpoint' && lastEvent.event.command == 'continue') {
                                         const lastSetBreakPointEvent = this.getLastThreadBreakpointOperationEvent(sessionData.events);
@@ -364,11 +384,32 @@ export class DebugSessionsTracker implements vscode.DebugAdapterTracker {
         return sessionData;
     }
 
-    private getLastThreadOperationEvent(events: { event: any; parsedMessage: string }[]): any {
+    private getLastThreadOperationEvent(events: { event: any; parsedMessage: string }[], currentEvent: any): any {
         for (let i = events.length - 1; i >= 0; i--) {
             const event = events[i];
             // Check the parsedMessage for relevant thread operations
             if (event.parsedMessage.includes('Step command issued:')) {
+                if (currentEvent.request_seq) {
+                    const reqResMap = this.debugRequestMap.get(currentEvent.request_seq); // retrieve the reqResMap to validate the thread ID of the current event
+                    if (reqResMap?.request && reqResMap?.request.arguments && reqResMap?.request.arguments.threadId) {
+                        const currentEventThreadId = reqResMap?.request.arguments.threadId;
+                        const prevThreadOpEventThreadId = event?.event.arguments.threadId;
+                        if (currentEventThreadId != prevThreadOpEventThreadId) {
+                            // Mock event to prevent the current event from playing prev event while macro playback
+                            return {
+                                event: {
+                                    command: "multithread-stopped",
+                                    arguments: {
+                                        threadId: currentEventThreadId
+                                    },
+                                    type: "request",
+                                    seq: 191
+                                }, parsedMessage: 'Thread stopped'
+                            } // Thread doesn't match seems the current event is paused by a breakpoint and user's debug session is multithreaded
+                        }
+                    }
+
+                }
                 return event; // Return the last relevant thread operation event
             }
         }

package.json

@@ -17,6 +17,39 @@ import { ContextProvider } from './vscodeContextProvider';
 export class DebugInfoStore {
     private activeThread: vscode.DebugThread | null = null;
     private activeStackFrame: vscode.DebugStackFrame | null = null;
+    private isMultiThreadedSession: boolean = false;
+    private activeThreadIdForMultiThreadedSession: any = null;
+    private hasThreadChangedBetweenFrames: boolean = false;
+
+    public setMultiThreadedSession() {
+        this.isMultiThreadedSession = true;
+    }
+
+    public setActiveThreadForMultiThreadSession(threadId: any) {
+        this.activeThreadIdForMultiThreadedSession = threadId;
+    }
+
+    public setHasThreadChangedBetweenFrames(status: boolean) {
+        this.hasThreadChangedBetweenFrames = status;
+    }
+
+    public getHasThreadChangedBetweenFrames(): boolean {
+        return this.hasThreadChangedBetweenFrames;
+    }
+
+    public isMultiThreaded(): boolean {
+        return this.isMultiThreadedSession;
+    }
+
+    public resetMultiThreadVars() {
+        this.isMultiThreadedSession = false;
+        this.hasThreadChangedBetweenFrames = false;
+        this.activeThreadIdForMultiThreadedSession = null;
+    }
+
+    public getThreadIdForMultiThreadedSession() {
+        return this.activeThreadIdForMultiThreadedSession;
+    }
 
     // Store the active thread and frame information
     public updateActiveDebugInfo(thread: vscode.DebugThread | null, stackFrame: vscode.DebugStackFrame | null) {