fix for methods + tunnel + enhanchments

Author: abhishek-lambda

.gradle/8.10/fileHashes/fileHashes.bin

@@ -1,2 +1,2 @@
-#Sun Nov 02 07:31:08 IST 2025
-gradle.version=8.5
+#Sun Nov 02 16:54:31 IST 2025
+gradle.version=8.10

.gradle/8.10/fileHashes/fileHashes.lock

@@ -7,8 +7,7 @@
     <groupId>com.lambdatest</groupId>
     <artifactId>lambdatest-java-selenium-sdk</artifactId>
     <!-- ⚠️ IMPORTANT: Keep this version in sync with gradle.properties -->
-    <!-- Single source of truth: gradle.properties (line 2) -->
-    <version>1.0.4</version>
+    <version>1.0.1</version>
     <packaging>jar</packaging>
 
     <name>LambdaTest Selenium SDK</name>

.gradle/buildOutputCleanup/buildOutputCleanup.lock

@@ -1,15 +1,18 @@
 package com.lambdatest.selenium.agent;
 
-import java.net.URL;
 import java.util.Map;
 
-import org.openqa.selenium.Capabilities;
 import org.openqa.selenium.MutableCapabilities;
 
 import com.lambdatest.selenium.lambdatest.LambdaTestConfig;
+import com.lambdatest.selenium.lambdatest.SessionThreadManager;
 
-import net.bytebuddy.asm.Advice;
-
+/**
+ * ByteBuddy Advice for RemoteWebDriver constructor interception.
+ * 
+ * This class enhances capabilities before RemoteWebDriver is created,
+ * adding LambdaTest-specific configuration from lambdatest.yml.
+ */
 public class RemoteWebDriverAdvice {
 
     // Track which capabilities objects have been enhanced to prevent double-processing
@@ -24,77 +27,16 @@ public class RemoteWebDriverAdvice {
 
     // Flag to warn only once about missing tunnel (avoid spam in parallel execution)
     private static volatile boolean warnedAboutMissingTunnel = false;
-
-    @Advice.OnMethodEnter
-    static void onEnter(@Advice.Argument(0) URL hubUrl, @Advice.Argument(1) Capabilities capabilities) {
-        
-        
-        // Check if capabilities can be modified
-        if (!(capabilities instanceof MutableCapabilities)) {
-            return;
-        }
-        
-        MutableCapabilities mutableCapabilities = (MutableCapabilities) capabilities;
-        
-        // Only intercept if it's a LambdaTest URL or if lt:options is present
-        boolean isLambdaTestUrl = hubUrl.toString().contains("lambdatest.com");
-        boolean hasLtOptions = capabilities.asMap().containsKey("lt:options");
-        
-        if (isLambdaTestUrl || hasLtOptions) {
-            
-            try {
-                // Check if SDK capabilities are stored by TestNG listener
-                String storedCapabilities = System.getProperty("lambdatest.sdk.capabilities");
-                if (storedCapabilities != null) {
-                    
-                    // Load configuration from lambdatest.yml
-                    LambdaTestConfig config = LambdaTestConfig.getInstance();
-                    Map<String, Object> sdkCapMap = config.getCapabilitiesFromYaml().asMap();
-                    Map<String, Object> userCapMap = mutableCapabilities.asMap();
-                    
-                    // Add missing capabilities from SDK config
-                    for (Map.Entry<String, Object> entry : sdkCapMap.entrySet()) {
-                        String key = entry.getKey();
-                        Object value = entry.getValue();
-                        
-                        if (!userCapMap.containsKey(key)) {
-                            mutableCapabilities.setCapability(key, value);
-                        }
-                    }
-                    
-                    // Ensure lt:options contains credentials
-                    if (userCapMap.containsKey("lt:options")) {
-                        Map<String, Object> ltOptions = (Map<String, Object>) userCapMap.get("lt:options");
-                        if (sdkCapMap.containsKey("lt:options")) {
-                            Map<String, Object> sdkLtOptions = (Map<String, Object>) sdkCapMap.get("lt:options");
-                            ltOptions.putAll(sdkLtOptions);
-                        }
-                    }
-                    
-                    
-                } else {
-                }
-                
-            } catch (Exception e) {
-            }
-        } else {
-        }
-    }
-    
-    /**
-     * Set flag to indicate SDK is creating RemoteWebDriver internally.
-     * This prevents recursive enhancement.
-     */
-    public static void setInternalDriverCreation(boolean value) {
-        internalDriverCreation.set(value);
-    }
 
+    // Session-thread manager for validating thread affinity
+    private static final SessionThreadManager sessionThreadManager = SessionThreadManager.getInstance();
+
     /**
      * Static method to enhance capabilities that can be called from ASM bytecode.
-     * This is the ACTUAL method that gets called by the agent's bytecode transformation.
+     * This is called by RemoteWebDriverBytecodeTransformer.
      */
     public static void enhanceCapabilities(MutableCapabilities capabilities) {
-        // Skip if this is an internal SDK driver creation (e.g., from ChromeDriverAdvice)
+        // Skip if this is an internal SDK driver creation
         if (internalDriverCreation.get()) {
             System.out.println("[LambdaTest SDK RemoteWebDriverAdvice] Skipping enhancement for internal driver creation");
             return;
@@ -114,35 +56,41 @@ public static void enhanceCapabilities(MutableCapabilities capabilities) {
         }
         processedCapabilities.add(capabilitiesHash);
 
+        // Log thread information for debugging
+        long threadId = Thread.currentThread().getId();
+        String threadName = Thread.currentThread().getName();
+        System.out.println(String.format(
+            "[LambdaTest SDK RemoteWebDriverAdvice] Enhancing capabilities on thread %d/%s",
+            threadId, threadName));
+        
         // Set re-entrance guard
         isEnhancing.set(true);
 
         try {
-        
             // Load configuration from lambdatest.yml
             LambdaTestConfig config = LambdaTestConfig.getInstance();
             Map<String, Object> sdkCapMap = config.getCapabilitiesFromYaml().asMap();
             Map<String, Object> userCapMap = capabilities.asMap();
 
-                // Add missing capabilities from SDK config
-                for (Map.Entry<String, Object> entry : sdkCapMap.entrySet()) {
-                    String key = entry.getKey();
-                    Object value = entry.getValue();
-                    
-                    if (!userCapMap.containsKey(key)) {
-                        capabilities.setCapability(key, value);
-                    }
+            // Add missing capabilities from SDK config
+            for (Map.Entry<String, Object> entry : sdkCapMap.entrySet()) {
+                String key = entry.getKey();
+                Object value = entry.getValue();
+                
+                if (!userCapMap.containsKey(key)) {
+                    capabilities.setCapability(key, value);
+                }
+            }
+            
+            // Ensure lt:options contains credentials
+            if (userCapMap.containsKey("lt:options")) {
+                Map<String, Object> ltOptions = (Map<String, Object>) userCapMap.get("lt:options");
+                if (sdkCapMap.containsKey("lt:options")) {
+                    Map<String, Object> sdkLtOptions = (Map<String, Object>) sdkCapMap.get("lt:options");
+                    ltOptions.putAll(sdkLtOptions);
                 }
 
-                // Ensure lt:options contains credentials
-                if (userCapMap.containsKey("lt:options")) {
-                    Map<String, Object> ltOptions = (Map<String, Object>) userCapMap.get("lt:options");
-                    if (sdkCapMap.containsKey("lt:options")) {
-                        Map<String, Object> sdkLtOptions = (Map<String, Object>) sdkCapMap.get("lt:options");
-                        ltOptions.putAll(sdkLtOptions);
-                    }
-                    
-                // Check if tunnel is enabled in YAML/capabilities only (no environment variable check)
+                // Check if tunnel is enabled in capabilities
                 if (ltOptions.containsKey("tunnel")) {
                     Object tunnelValue = ltOptions.get("tunnel");
                     boolean tunnelInCapabilities = false;
@@ -154,7 +102,7 @@ public static void enhanceCapabilities(MutableCapabilities capabilities) {
                     }
 
                     if (tunnelInCapabilities) {
-                        // Tunnel is enabled in YAML - check if it's running and add tunnel name
+                        // Tunnel is enabled - check if it's running and add tunnel name
                         try {
                             com.lambdatest.selenium.tunnel.TunnelManager tunnelManager = 
                                 com.lambdatest.selenium.tunnel.TunnelManager.getInstance();
@@ -165,7 +113,7 @@ public static void enhanceCapabilities(MutableCapabilities capabilities) {
                                     ltOptions.put("tunnelName", tunnelName);
                                 }
                             } else {
-                                // Tunnel configured in YAML but not running - warn but allow test to continue
+                                // Tunnel configured but not running - warn once
                                 if (!warnedAboutMissingTunnel) {
                                     warnedAboutMissingTunnel = true;
                                     System.err.println("[LambdaTest SDK] WARNING: tunnel=true in YAML but no tunnel is running.");
@@ -177,22 +125,32 @@ public static void enhanceCapabilities(MutableCapabilities capabilities) {
                         }
                     }
                 }
-                }
+            }
 
         } catch (Exception e) {
             System.err.println("[LambdaTest SDK RemoteWebDriverAdvice] Error enhancing capabilities: " + e.getMessage());
             e.printStackTrace();
         } finally {
-            // Always clear the re-entrance guard and clean up ThreadLocal
+            // Always clear the re-entrance guard
             isEnhancing.set(false);
-            // Clean up ThreadLocal to prevent memory leaks in long-running applications
-            // Note: We don't remove internalDriverCreation here as it might still be needed
+            
+            // Log completion with thread info
+            System.out.println(String.format(
+                "[LambdaTest SDK RemoteWebDriverAdvice] Capability enhancement completed on thread %d/%s",
+                Thread.currentThread().getId(), Thread.currentThread().getName()));
         }
     }
 
+    /**
+     * Set flag to indicate SDK is creating RemoteWebDriver internally.
+     * This prevents recursive enhancement.
+     */
+    public static void setInternalDriverCreation(boolean value) {
+        internalDriverCreation.set(value);
+    }
+    
     /**
      * Clean up all ThreadLocal variables to prevent memory leaks.
-     * Should be called after all tests complete.
      */
     public static void cleanupThreadLocals() {
         try {
@@ -202,4 +160,5 @@ public static void cleanupThreadLocals() {
             // Ignore cleanup errors
         }
     }
-}
+}
+

.gradle/buildOutputCleanup/cache.properties

@@ -19,7 +19,8 @@
  */
 public class LambdaTestConfig {
 
-    private static LambdaTestConfig instance;
+    private static volatile LambdaTestConfig instance;  // volatile for double-checked locking
+    private static final Object instanceLock = new Object();  // Lock for singleton initialization
     private Map<String, Object> config;
 
     // Static block to enable framework-level capability enhancement
@@ -36,11 +37,19 @@ private LambdaTestConfig() {
         loadConfig();
     }
 
+    /**
+     * Thread-safe singleton getInstance using double-checked locking.
+     * Critical for high-parallelism scenarios (e.g., parallel=50).
+     */
     public static LambdaTestConfig getInstance() {
-        if (instance == null) {
-            instance = new LambdaTestConfig();
-            // Automatically enhance any existing MutableCapabilities objects
-            enhanceExistingCapabilities();
+        if (instance == null) {  // First check (no locking)
+            synchronized (instanceLock) {  // Acquire lock
+                if (instance == null) {  // Second check (with locking)
+                    instance = new LambdaTestConfig();
+                    // Automatically enhance any existing MutableCapabilities objects
+                    enhanceExistingCapabilities();
+                }
+            }
         }
         return instance;
     }
@@ -124,6 +133,12 @@ public static void injectCapabilities(MutableCapabilities capabilities) {
     }
 
     private void loadConfig() {
+        long startTime = System.currentTimeMillis();
+        java.util.logging.Logger logger = java.util.logging.Logger.getLogger(getClass().getName());
+        
+        logger.fine(String.format("[Thread-%d/%s] Loading LambdaTest configuration...",
+            Thread.currentThread().getId(), Thread.currentThread().getName()));
+        
         Yaml yaml = new Yaml();
 
         // Try multiple locations for lambdatest.yml
@@ -162,6 +177,10 @@ private void loadConfig() {
                         config = rawConfig;
                     }
 
+                    long duration = System.currentTimeMillis() - startTime;
+                    logger.fine(String.format("[Thread-%d/%s] Configuration loaded in %dms",
+                        Thread.currentThread().getId(), Thread.currentThread().getName(), duration));
+                    
                     return; // Successfully loaded, exit
                 }
 
@@ -172,6 +191,7 @@ private void loadConfig() {
 
         // If we get here, no config file was found
         config = new HashMap<>();
+        logger.fine("No configuration file found, using empty config");
     }
 
     /**