Use Selenium Grid’s UI or /status for a quick health check, GraphQL for structured capacity and session data, and OpenTelemetry traces to follow a request across Grid components. These tools answer different questions: live state tells you what is available now; traces help explain how a request moved through the system and where it slowed or failed.
Which Selenium Grid observability tool answers your question?
| Need | Use | What it shows |
|---|---|---|
| Quickly check whether Grid is available | Grid UI or /status |
Grid status and a visual or basic endpoint view. |
| Query capacity, nodes, slots, or active sessions | GraphQL | Structured current-state fields such as maxSession, sessionCount, node status, slots, and session details. |
| Understand a request’s route, timing, or failure context | OpenTelemetry traces | A request journey across services, represented by timed spans and timestamped events. |
| Inspect trace output locally | Console exporter at FINE logging level | Trace and event details in server logs. |
| Collect and query traces centrally | Jaeger or another configured trace backend | Searchable and visualized trace data, subject to the deployed server’s configuration. |
Selenium Server is instrumented with OpenTelemetry tracing. The official Selenium observability guide describes traces as request journeys, spans as timed operations, and events as timestamped context within spans.
As an Amazon Associate I earn from qualifying purchases.
Check Grid health and current sessions
Start with the UI or status endpoint
For a quick operational check, open the Grid UI or request /status on the Grid endpoint. These are useful first checks when you need to know whether Grid is responding, but use GraphQL when you need specific fields for automation, dashboards, or a more detailed session inventory. Selenium documents the UI, /status, and GraphQL as ways to query Grid state in its getting-started guide.
Recommended Free Tools
Query structured capacity and session data
GraphQL can expose Grid capacity, node and slot state, and session information. Useful fields include:
#1 Best Overall
maxSessionandsessionCountfor configured capacity and current session count.- Node status and slot data to see where capacity is available or occupied.
- Session capabilities, start time, node information, and duration to identify where a running test is executing and how long it has been active.
Use Selenium’s GraphQL query support documentation for the current query examples and response fields. Treat these results as a view of current Grid state, not as a historical record of how a request reached that state.
Make sessions identifiable
Set the se:name capability to a useful test label, and add other suitable se: metadata when it helps distinguish runs. Selenium documents that this metadata can be viewed in the Grid UI and queried through GraphQL. Prefer stable, meaningful names such as a suite and test identifier over generic labels like “test”; avoid placing secrets or sensitive user data in metadata.
Rank #2
Trace a request through Grid
Understand what a trace contains
Tracing is most useful when a client command fails, stalls, or takes unexpectedly long and a current-state query cannot explain why. Follow the trace’s spans to see which services handled the request, how long each operation took, and what timestamped events were recorded. Interpret the spans in the context of the components that actually exist in your deployment.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Inspect traces in server logs
The Selenium observability guide says tracing is enabled by default and documents console traces and event logs at FINE log level. This is a practical starting point for local diagnosis: increase the relevant logging detail, reproduce the issue, and inspect the emitted trace and event context. Exact logger configuration and output can depend on the server version and deployment, so consult the running server’s configuration help rather than assuming a flag from another release still applies.
Use Jaeger for queryable traces
Selenium presents Jaeger as a backend for collecting, querying, filtering, and visualizing traces. Configure the exporter and backend using the tracing instructions reported by the deployed Selenium Server. A trace backend is more useful than console output when multiple services or test runs need to be inspected centrally; it does not replace GraphQL for a live capacity snapshot.
Follow failures across the deployed topology
Grid can be deployed as a standalone server, a Hub/Node setup, or a fully distributed system. Distributed deployments separate responsibilities across components such as the Router, New Session Queue, Distributor, Node, Session Map, and Event Bus. When diagnosing a failed session request, use the trace to follow the request through the components present in your topology, then correlate the relevant span with node, slot, or session information from GraphQL.
- Establish current state. Check the Grid UI or
/status; use GraphQL to inspect capacity, node health, slots, and current sessions. - Identify the test session. Use its session details and meaningful
se:nameor otherse:metadata to distinguish it from concurrent runs. - Find the request trace. Inspect console trace output at FINE level or use the configured trace backend.
- Locate the failing or slow span. Determine which Grid role handled that part of the request and compare its timing and events with the session and node data.
- Check the matching component. Investigate the relevant Router, queue, Distributor, Node, Session Map, or Event Bus boundary that exists in your deployment.
The Grid overview explains Grid’s remote-execution purpose and its component architecture. The tracing guide covers supported Grid modes; the amount of cross-component detail you can interpret depends on the topology you run.
Free tools Windows power users keep installed
One-click scans. No signup required.
Verify options for the Selenium Server you actually run
Tracing instructions and configuration flags can vary by version. Run the deployed server’s info config and info tracing commands to see the implementation’s current configuration and tracing help. Selenium’s configuration help, modified September 16, 2026, documents these runtime help commands. Prefer that output over copying a flag or exporter setting from an example intended for a different release.
Prometheus and the Session Event API are version-bound
The Selenium Grid 4.41.0 release article describes a Session Event API and a native Prometheus metrics endpoint. Treat these as release-specific features: verify the installed Selenium Server version and its configuration help before planning dashboards or integrations around them. The release article does not establish a complete compatibility matrix across every version, so do not assume either feature is available on an older deployment. See Selenium Grid 4.41.0: What’s New and Why It Matters.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Common monitoring problems and fixes
- The UI or
/statuslooks healthy, but a test still fails. A health view describes current status, not the full route or history of a command. Inspect the request trace and correlate it with GraphQL session and node data. - GraphQL shows sessions but not why a request failed. GraphQL exposes current state. Use tracing for request path, span timing, and event context.
- No useful trace output appears in the console. Confirm the deployed server’s FINE-level logging instructions with
info tracingand reproduce the request after applying the version-appropriate configuration. - Trace setup instructions do not match the installed release. Run
info configandinfo tracingon that server; configuration behavior and flags can vary by version. - A session is difficult to identify among concurrent runs. Add an informative
se:nameand suitablese:metadata, then inspect them in the UI or GraphQL. - A Prometheus endpoint or Session Event API is unavailable. Verify that the deployed release includes the 4.41.0 feature and check its runtime help before configuring a client or dashboard.
Or skip the browser setup
If your task is to capture a page as part of a test or debugging workflow, ScreenshotNeo offers a website screenshot API and MCP server. It is separate from Selenium Grid observability: it captures pages, rather than showing Grid health, session counts, or traces. A single request can return an image or PDF, for example:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpSee the ScreenshotNeo API documentation for request options. Cookie banners, popups, and chat widgets are removed before capture; bot checks, blank pages, and failed loads are never billed; an MCP server lets AI agents take screenshots. The free plan includes 1,000 screenshots a month with no card, and paid plans start at $5 for 3,000. Learn about ScreenshotNeo, or sign up for the free plan.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →Frequently Asked Questions
Does Selenium Grid observability require an external tracing service?
No. The documented console exporter provides a local inspection route; Jaeger is an option when you need to collect and query traces centrally.
Can GraphQL show how a session request moved through Grid?
GraphQL reports structured current Grid and session data. Use OpenTelemetry traces to inspect the request’s route and timing.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
