GO4 opens or requests the storefront
HTTP/Page and Browser Lab run from GO4 infrastructure with a known target and repeatable test conditions.
- Availability and response evidence
- Controlled browser execution
- Repeatable synthetic comparisons
Shopify client-side monitoring
See how your Shopify storefront behaves in real visitor browsers
GO4 JS Agent runs with the storefront and turns matching pageviews into client-side monitoring evidence — browser timing, rendered page signals, Shopify context, Custom DOM results, resource diagnostics and browser errors.
A different monitoring vantage point
Controlled checks and real browser pageviews answer different questions
GO4 keeps synthetic monitoring and client-side monitoring separate because they observe the storefront from different places. Used together, they make it easier to distinguish a server problem from a loaded-page or visitor-browser problem.
The loaded storefront reports what the browser saw
Matching pageviews send browser-side evidence after the storefront has loaded in a real visitor session.
- Navigation timing from the pageview
- Rendered page and Shopify context
- Check-specific DOM and browser signals
Client-side monitoring does not replace Browser Lab or HTTP/Page checks. It adds a second vantage point from inside the loaded storefront.
Browser-side evidence
Collect the signals that only exist after the storefront reaches a browser
The active JS Agent check decides which browser-side signals matter for its URL scope. The agent then returns only the evidence needed by the matching monitoring profile.
Know what page and viewport reported
Keep the URL scope and browser context attached to the event.
URL / pathPage typeViewport & screen
Carry storefront-specific context with the pageview
When available, the event includes Shopify-aware context from the loaded storefront.
Shopify detectedProduct / variant contextTheme context
Inspect what the browser ended up with
Evaluate browser-visible page signals rather than relying only on the original server response.
Title & descriptionCanonicalRobots / noindex
Measure the pageview from inside the browser
Navigation Timing adds real pageview evidence around loading and response timing.
Total loadTTFBDOM ready & load event
Keep browser failures with the event
Capture client-side failures that can happen after the server has already returned a valid page.
JavaScript errorsResource load errorsUnhandled promise rejections
Add cart and resource evidence where configured
The matching profile can include a passive cart endpoint check and selected slow or large resource samples.
/cart.js signalSlow resourcesLarge resources
Check-driven monitoring
The site enables browser events; the checks decide what gets evaluated
JS Agent is not an unrestricted analytics collector. Active checks provide URL scope, evaluation mode, thresholds and Custom DOM rules, while site settings control how matching browser events are collected and stored.
Visitor pageviewJS AgentMatching checksEvaluation & evidence
Confirm that fresh matching browser events are still arriving for the check scope.
Evaluate configured page, performance, error and Shopify browser signals.
Use the current saved DOM assertion contract without enabling built-in signal evaluation.
Combine browser signals with current Custom DOM proof in the same monitoring profile.
Include and exclude patterns can narrow which pageviews match a check. Sampling controls how many matching pageviews are collected.
Custom DOM Assertions
Turn important storefront elements into passive browser proof
Custom DOM rules verify the state of the page that a visitor actually loaded. They inspect the current DOM without clicking, submitting forms or changing the storefront.
Example DOM proofProduct page UI
Current rulesAdd-to-cart control existsselector_exists · .product-form button
PassedReviews block is presentselector_count_min · .reviews-widget · min 1
PassedExpected product text renderedselector_text_contains · .product-info
PassedError banner is absentselector_missing · .critical-error
PassedGO4 also supports text contains / not contains and minimum / maximum selector counts.
Use the page the visitor actually received
The assertion runs against the loaded DOM after the configured JS Agent delay, so late theme or app elements can be included.
Keep proof tied to the saved rule set
GO4 fingerprints the effective Custom DOM configuration so stale proof from older rules cannot satisfy a newer check.
Stay passive
Custom DOM monitoring observes state only. Interactive storefront paths belong in Action Journey.
See how selector, text and count rules become check-specific browser proof without turning the agent into browser automation.
Event history and diagnostics
Keep the browser evidence behind the monitoring result
GO4 keeps matched browser-event history according to each check storage mode, with status, timing and detailed event context. Resource diagnostics can add focused slow and large resource samples to saved evidence.
Matched browser eventsRecent evidence
Check scopeMatched events184
Warnings7
Avg browser load1.96 s
/products/example-productMobile · 1.84 s · DOM 3/3
OK20:42/collections/newDesktop · 3.92 s · load over limit
Warning20:39/products/second-productDesktop · 1.71 s · DOM 2/2
OK20:37/products/example-productMobile · Custom DOM rule failed
Fail20:31Focused resource evidenceSlow / large samples
theme-bundle.jsScript · slow sample
812 msreviews-widget.jsThird-party script
534 mshero-image.webpImage · large sample
428 KBResource diagnostics are configurable. Depending on the selected mode, GO4 can keep them for warning/fail events or for every saved event.
Shopify App Embed setup
Enable browser-side monitoring without editing theme code
For a Shopify App-linked site, GO4 uses the storefront App Embed. Enable it in Theme Editor, save the theme and let matching pageviews begin feeding the configured JS Agent checks.
Install GO4 and keep the monitoring site linked to the Shopify installation.
Turn on the GO4 App Embed in Shopify Theme Editor and save the active theme.
Active JS Agent checks start receiving evidence from pageviews that match their URL scope and sampling settings.
The App Embed loads the same canonical JS Agent runtime used by GO4. Generic non-Shopify sites can use the manual snippet path instead.
Collection and privacy controls
Decide how much client-side evidence you need to keep
The agent includes controls that help balance monitoring coverage, database volume and URL privacy without changing the purpose of the check.
Sampling rate
Collect every matching pageview or sample a smaller share when full coverage is unnecessary.
Post-load delay
Wait briefly after page load when late theme or app elements need time to appear before evidence is collected.
URL query controls
Store only the path or keep query parameters with sanitization of common sensitive values.
Event storage mode
Keep all matching events or compact OK history while retaining warning/fail evidence and the latest OK proof.
From pageview to monitoring signal
Turn incoming browser evidence into the same monitoring lifecycle as the rest of GO4
A pageview is useful because it is evaluated against a check. The resulting browser-side signal can then participate in status, incident and recovery workflows instead of living as isolated telemetry.
A storefront visitor loads a page with the JS Agent enabled.
GO4 applies the active URL scope and current check configuration.
Built-in browser signals and optional Custom DOM proof are assessed.
Repeated check failures can enter the normal incident and alert lifecycle.
Fresh browser evidence can confirm that the monitored condition is healthy again.
Shopify client-side monitoring questions
What merchants usually want to know about JS Agent monitoring
JS Agent is a passive monitoring layer for browser-side evidence. It complements GO4 synthetic checks rather than replacing them.
What is Shopify client-side monitoring?
It is monitoring from inside the loaded storefront. GO4 JS Agent runs with the page and sends browser-side evidence from matching pageviews so a check can evaluate what the browser actually saw.
Is JS Agent the same as Browser Lab?
No. Browser Lab is a controlled synthetic browser started by GO4. JS Agent receives passive evidence from pageviews that load the storefront with the agent enabled. The two layers answer different questions and work well together.
What can GO4 receive from the browser?
Depending on the active check profile, GO4 can receive rendered page signals, Navigation Timing, viewport and Shopify context, JavaScript and resource errors, a passive cart endpoint result, Custom DOM proof and selected slow or large resource samples.
Does GO4 collect every pageview?
Not necessarily. Site settings include a sampling rate, and only pageviews that match active JS Agent check scope are relevant to check evaluation. Event storage can also be compacted instead of keeping every OK event.
Can JS Agent verify storefront widgets or app-rendered elements?
Yes. Custom DOM Assertions can verify selector presence or absence, expected text and selector count conditions against the loaded DOM after the configured delay.
Does JS Agent click buttons or change the storefront?
No. JS Agent monitoring is passive. It reads page state and can perform the passive Shopify cart endpoint check, but it does not click, submit forms or execute shopping journeys. Interactive paths belong in Action Journey.
Do Shopify merchants need to edit theme code?
For a Shopify App-linked site, the normal setup is to enable the GO4 Storefront monitoring App Embed in Theme Editor and save the theme. Manual theme-code installation is not required for that path.
What controls exist for URL privacy and event volume?
GO4 can omit query parameters, sanitize common sensitive query values, sample matching pageviews and choose between broader or compact event storage. Full raw payload storage is also optional rather than required.
Add a browser-side view of the storefront
Monitor what your visitors’ browsers actually receive
Use GO4 JS Agent to add passive real-browser evidence to the server, Shopify and synthetic browser checks already protecting the storefront.
Real browser pageviewsCheck-driven evaluationCustom DOM evidence