Merge branch 'trunk' into luke-hill-patch-1

Author: aguspe

README.md

@@ -528,8 +528,6 @@ To update API documentation for a specific language: `./go <language>:docs`
 
 To update all documentation: `./go all:docs`
 
-Note that JavaScript generation is [currently broken](https://github.com/SeleniumHQ/selenium/issues/10185).
-
 
 ## Releasing
 

dotnet/src/webdriver/Chromium/ChromiumDriverLogLevel.cs

@@ -0,0 +1,61 @@
+// <copyright file="ChromiumDriverLogLevel.cs" company="Selenium Committers">
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+// </copyright>
+
+namespace OpenQA.Selenium.Chromium;
+
+/// <summary>
+/// Represents the valid values of logging levels available with the Chromium based drivers.
+/// </summary>
+public enum ChromiumDriverLogLevel
+{
+    /// <summary>
+    /// Represents the value All, the most detailed logging level available.
+    /// </summary>
+    All,
+
+    /// <summary>
+    /// Represents the Debug value
+    /// </summary>
+    Debug,
+
+    /// <summary>
+    /// Represents the Info value
+    /// </summary>
+    Info,
+
+    /// <summary>
+    /// Represents the Warning value
+    /// </summary>
+    Warning ,
+
+    /// <summary>
+    /// Represents the Severe value
+    /// </summary>
+    Severe,
+
+    /// <summary>
+    /// Represents the Off value, nothing gets logged
+    /// </summary>
+    Off,
+
+    /// <summary>
+    /// Represents that the logging value is unspecified, and should be the default level.
+    /// </summary>
+    Default
+}

dotnet/src/webdriver/Chromium/ChromiumDriverService.cs

@@ -84,6 +84,11 @@ protected ChromiumDriverService(string? executablePath, string? executableFileNa
     /// </summary>
     public bool EnableAppendLog { get; set; }
 
+    /// <summary>
+    /// Gets or sets the level at which log output is displayed.
+    /// </summary>
+    public ChromiumDriverLogLevel LogLevel { get; set; } = ChromiumDriverLogLevel.Default;
+
     /// <summary>
     /// <para>Gets or sets the comma-delimited list of IP addresses that are approved to connect to this instance of the Chrome driver.</para>
     /// <para>A value of <see langword="null"/> or <see cref="string.Empty"/> means only the local loopback address can connect.</para>
@@ -154,6 +159,15 @@ protected override string CommandLineArguments
                 argsBuilder.Append(string.Format(CultureInfo.InvariantCulture, " -allowed-ips={0}", this.AllowedIPAddresses));
             }
 
+            if (this.LogLevel != ChromiumDriverLogLevel.Default)
+            {
+                if (Enum.IsDefined(typeof(ChromiumDriverLogLevel), this.LogLevel))
+                {
+                    argsBuilder.Append(string.Format(CultureInfo.InvariantCulture, " --log-level={0}", this.LogLevel.ToString().ToUpperInvariant()));
+                }
+            }
+
+
             return argsBuilder.ToString();
         }
     }

java/src/org/openqa/selenium/grid/sessionmap/local/LocalSessionMap.java

@@ -20,13 +20,18 @@
 import static org.openqa.selenium.remote.RemoteTags.SESSION_ID;
 import static org.openqa.selenium.remote.RemoteTags.SESSION_ID_EVENT;
 
-import java.util.List;
+import java.net.URI;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.logging.Logger;
-import java.util.stream.Collectors;
 import org.openqa.selenium.NoSuchSessionException;
+import org.openqa.selenium.events.Event;
 import org.openqa.selenium.events.EventBus;
 import org.openqa.selenium.grid.config.Config;
 import org.openqa.selenium.grid.data.NodeRemovedEvent;
@@ -48,7 +53,7 @@ public class LocalSessionMap extends SessionMap {
   private static final Logger LOG = Logger.getLogger(LocalSessionMap.class.getName());
 
   private final EventBus bus;
-  private final ConcurrentMap<SessionId, Session> knownSessions = new ConcurrentHashMap<>();
+  private final IndexedSessionMap knownSessions = new IndexedSessionMap();
 
   public LocalSessionMap(Tracer tracer, EventBus bus) {
     super(tracer);
@@ -59,23 +64,14 @@ public LocalSessionMap(Tracer tracer, EventBus bus) {
 
     bus.addListener(
         NodeRemovedEvent.listener(
-            nodeStatus ->
-                nodeStatus.getSlots().stream()
-                    .filter(slot -> slot.getSession() != null)
-                    .map(slot -> slot.getSession().getId())
-                    .forEach(this::remove)));
+            nodeStatus -> {
+              batchRemoveByUri(nodeStatus.getExternalUri(), NodeRemovedEvent.class);
+            }));
 
     bus.addListener(
         NodeRestartedEvent.listener(
             previousNodeStatus -> {
-              List<SessionId> toRemove =
-                  knownSessions.entrySet().stream()
-                      .filter(
-                          (e) -> e.getValue().getUri().equals(previousNodeStatus.getExternalUri()))
-                      .map(Map.Entry::getKey)
-                      .collect(Collectors.toList());
-
-              toRemove.forEach(this::remove);
+              batchRemoveByUri(previousNodeStatus.getExternalUri(), NodeRestartedEvent.class);
             }));
   }
 
@@ -95,17 +91,23 @@ public boolean isReady() {
   public boolean add(Session session) {
     Require.nonNull("Session", session);
 
+    SessionId id = session.getId();
+    knownSessions.put(id, session);
+
     try (Span span = tracer.getCurrentContext().createSpan("local_sessionmap.add")) {
       AttributeMap attributeMap = tracer.createAttributeMap();
       attributeMap.put(AttributeKey.LOGGER_CLASS.getKey(), getClass().getName());
-      SessionId id = session.getId();
       SESSION_ID.accept(span, id);
       SESSION_ID_EVENT.accept(attributeMap, id);
-      knownSessions.put(session.getId(), session);
-      span.addEvent("Added session into local session map", attributeMap);
 
-      return true;
+      String sessionAddedMessage =
+          String.format(
+              "Added session to local Session Map, Id: %s, Node: %s", id, session.getUri());
+      span.addEvent(sessionAddedMessage, attributeMap);
+      LOG.info(sessionAddedMessage);
     }
+
+    return true;
   }
 
   @Override
@@ -116,23 +118,157 @@ public Session get(SessionId id) {
     if (session == null) {
       throw new NoSuchSessionException("Unable to find session with ID: " + id);
     }
-
     return session;
   }
 
   @Override
   public void remove(SessionId id) {
     Require.nonNull("Session ID", id);
 
+    Session removedSession = knownSessions.remove(id);
+
     try (Span span = tracer.getCurrentContext().createSpan("local_sessionmap.remove")) {
       AttributeMap attributeMap = tracer.createAttributeMap();
       attributeMap.put(AttributeKey.LOGGER_CLASS.getKey(), getClass().getName());
       SESSION_ID.accept(span, id);
       SESSION_ID_EVENT.accept(attributeMap, id);
-      knownSessions.remove(id);
-      String sessionDeletedMessage = "Deleted session from local Session Map";
+
+      String sessionDeletedMessage =
+          String.format(
+              "Deleted session from local Session Map, Id: %s, Node: %s",
+              id,
+              removedSession != null ? String.valueOf(removedSession.getUri()) : "unidentified");
       span.addEvent(sessionDeletedMessage, attributeMap);
-      LOG.info(String.format("%s, Id: %s", sessionDeletedMessage, id));
+      LOG.info(sessionDeletedMessage);
+    }
+  }
+
+  private void batchRemoveByUri(URI externalUri, Class<? extends Event> eventClass) {
+    Set<SessionId> sessionsToRemove = knownSessions.getSessionsByUri(externalUri);
+
+    if (sessionsToRemove.isEmpty()) {
+      return; // Early return for empty operations - no tracing overhead
+    }
+
+    knownSessions.batchRemove(sessionsToRemove);
+
+    try (Span span = tracer.getCurrentContext().createSpan("local_sessionmap.batch_remove")) {
+      AttributeMap attributeMap = tracer.createAttributeMap();
+      attributeMap.put(AttributeKey.LOGGER_CLASS.getKey(), getClass().getName());
+      attributeMap.put("event.class", eventClass.getName());
+      attributeMap.put("node.uri", externalUri.toString());
+      attributeMap.put("sessions.count", sessionsToRemove.size());
+
+      String batchRemoveMessage =
+          String.format(
+              "Batch removed %d sessions from local Session Map for Node %s (triggered by %s)",
+              sessionsToRemove.size(), externalUri, eventClass.getSimpleName());
+      span.addEvent(batchRemoveMessage, attributeMap);
+      LOG.info(batchRemoveMessage);
+    }
+  }
+
+  private static class IndexedSessionMap {
+    private final ConcurrentMap<SessionId, Session> sessions = new ConcurrentHashMap<>();
+    private final ConcurrentMap<URI, Set<SessionId>> sessionsByUri = new ConcurrentHashMap<>();
+    private final Object coordinationLock = new Object();
+
+    public Session get(SessionId id) {
+      return sessions.get(id);
+    }
+
+    public Session put(SessionId id, Session session) {
+      synchronized (coordinationLock) {
+        Session previous = sessions.put(id, session);
+
+        if (previous != null && previous.getUri() != null) {
+          cleanupUriIndex(previous.getUri(), id);
+        }
+
+        URI sessionUri = session.getUri();
+        if (sessionUri != null) {
+          sessionsByUri.computeIfAbsent(sessionUri, k -> ConcurrentHashMap.newKeySet()).add(id);
+        }
+
+        return previous;
+      }
+    }
+
+    public Session remove(SessionId id) {
+      synchronized (coordinationLock) {
+        Session removed = sessions.remove(id);
+
+        if (removed != null && removed.getUri() != null) {
+          cleanupUriIndex(removed.getUri(), id);
+        }
+
+        return removed;
+      }
+    }
+
+    public void batchRemove(Set<SessionId> sessionIds) {
+      synchronized (coordinationLock) {
+        Map<URI, Set<SessionId>> uriToSessionIds = new HashMap<>();
+
+        // Single loop: remove sessions and collect URI mappings in one pass
+        for (SessionId id : sessionIds) {
+          Session session = sessions.remove(id);
+          if (session != null && session.getUri() != null) {
+            uriToSessionIds.computeIfAbsent(session.getUri(), k -> new HashSet<>()).add(id);
+          }
+        }
+
+        // Clean up URI index for all affected URIs
+        for (Map.Entry<URI, Set<SessionId>> entry : uriToSessionIds.entrySet()) {
+          cleanupUriIndex(entry.getKey(), entry.getValue());
+        }
+      }
+    }
+
+    private void cleanupUriIndex(URI uri, SessionId sessionId) {
+      sessionsByUri.computeIfPresent(
+          uri,
+          (key, sessionIds) -> {
+            sessionIds.remove(sessionId);
+            return sessionIds.isEmpty() ? null : sessionIds;
+          });
+    }
+
+    private void cleanupUriIndex(URI uri, Set<SessionId> sessionIdsToRemove) {
+      sessionsByUri.computeIfPresent(
+          uri,
+          (key, sessionIds) -> {
+            sessionIds.removeAll(sessionIdsToRemove);
+            return sessionIds.isEmpty() ? null : sessionIds;
+          });
+    }
+
+    public Set<SessionId> getSessionsByUri(URI uri) {
+      Set<SessionId> result = sessionsByUri.get(uri);
+      return (result != null && !result.isEmpty()) ? result : Set.of();
+    }
+
+    public Set<Map.Entry<SessionId, Session>> entrySet() {
+      return Collections.unmodifiableSet(sessions.entrySet());
+    }
+
+    public Collection<Session> values() {
+      return Collections.unmodifiableCollection(sessions.values());
+    }
+
+    public int size() {
+      return sessions.size();
+    }
+
+    public boolean isEmpty() {
+      return sessions.isEmpty();
+    }
+
+    public void clear() {
+      synchronized (coordinationLock) {
+        sessions.clear();
+        sessionsByUri.clear();
+      }
     }
   }
 }

java/test/org/openqa/selenium/grid/sessionmap/local/BUILD.bazel

@@ -0,0 +1,20 @@
+load("@rules_jvm_external//:defs.bzl", "artifact")
+load("//java:defs.bzl", "JUNIT5_DEPS", "java_test_suite")
+
+java_test_suite(
+    name = "SmallTests",
+    size = "medium",
+    srcs = glob(["*.java"]),
+    deps = [
+        "//java/src/org/openqa/selenium:core",
+        "//java/src/org/openqa/selenium/events",
+        "//java/src/org/openqa/selenium/events/local",
+        "//java/src/org/openqa/selenium/grid/data",
+        "//java/src/org/openqa/selenium/grid/sessionmap",
+        "//java/src/org/openqa/selenium/grid/sessionmap/local",
+        "//java/src/org/openqa/selenium/remote",
+        "//java/test/org/openqa/selenium/remote/tracing:tracing-support",
+        artifact("org.assertj:assertj-core"),
+        artifact("org.junit.jupiter:junit-jupiter-api"),
+    ] + JUNIT5_DEPS,
+)