Error Monitoring for Shopify (Configure)

ComponentsEngineMobile AppRUM JS

Availability2023.3 or later

Configure Error Monitoring for Shopify

Errors by customer impact

Detect Functional Errors

Catch failures hidden in 200s

Configure error categorization

Rules using stable attributes

Troubleshooting

Fix Shopify error issues

Configure Error Monitoring for Shopify

Configure GermainUX to detect, classify, prioritize, and analyze Shopify errors according to their effect on customers, conversion, revenue, and critical business processes. The objective is not to treat every technical event as equally important. GermainUX helps teams focus on failures that affect real customers while separating expected validation and low-impact technical noise.

Prerequisites

Before configuring error monitoring:

Deploy GermainUX monitoring for Shopify
Confirm data ingestion
Privacy & consent
Business journeys
Access
Stakeholders

Error classifications

Use the following classifications consistently across Shopify KPIs, dashboards, alerts, and reports.

Classification	Example
User-facing application error	Add-to-cart fails and displays an error
Silent application error	An inventory request fails silently and leaves stale availability data
User validation	A required address field is missing
Technical event	A handled JavaScript warning with no customer impact
Business failure	Checkout completes without the required order integration
Payment decline	The issuing bank declines the transaction
Custom	<your custom classification>

Do not group user validation with application errors. Validation indicates that the application is operating as designed; an application error indicates that the software is not operating correctly.

Error sources

GermainUX can detect Shopify errors from browser, network, application, and integration telemetry.

Browser and JavaScript errors

Monitor:

JavaScript exceptions
Unhandled promise rejections
Resource-loading failures
Browser freezes
Failed event handlers
Theme and application errors
Third-party script failures
Custom application error events

Network errors

Monitor:

Failed HTTP and fetch requests
Timeouts
Connection failures
Incorrect HTTP status codes
GraphQL errors
Responses that report a failure despite returning HTTP 200
Shopify API failures
Third-party service failures

Customer-visible errors

Monitor error messages associated with:

Feature	Feature
Product search	Product availability
Product variants	Add-to-cart
Cart updates	Discount codes
Authentication	Customer accounts
Shipping	Checkout
Payment	Order submission
Returns and support

Backend and integration errors

When the GermainUX Engine is configured, monitor:

Shopify API errors
Webhook failures
Product or inventory synchronization
Order-processing integrations
Payment and tax services
CRM and ERP integrations

Show all 9

Fulfillment and warehouse systems
Scheduled jobs
Rate limits and authentication failures

Enable error monitoring

Go to: Germain Workspace > Analytics > UX Monitoring Profiles Select the profile used by the Shopify store. Depending on the GermainUX version and enabled components, review:

JavaScript error monitoring
Unhandled promise rejection monitoring
HTTP and fetch monitoring
Request and response processing
Browser console monitoring
Popup and visible-message monitoring

Show all 11

Resource error monitoring
Session Replay
Network request-body capture
Error categorization
Application-specific rules

Enable only the collection required for the analysis. Avoid capturing full request or response bodies unless necessary and approved.

Detect functional errors in successful HTTP responses

Some Shopify themes and third-party services return HTTP 200 even when the response represents a functional failure. In these cases, configure a response processor to identify the failure based on the response content. The following example detects common “page not found” responses:

settings.plugins.network.requestAndResponseBodyProcessor = function (fact) {
    if (
        fact.myClassName !== "OutboundDocumentRequest" ||
        !fact.responseBody
    ) {
        return;
    }

    const responseText = fact.responseBody.toLowerCase();

    const pageNotFound =
        responseText.includes("404 not found") ||
        responseText.includes("page not found") ||
        responseText.includes(
            "page you were looking for does not exist"
        );

    if (pageNotFound) {
        fact.success = false;
        fact.http = fact.http || {};
        fact.http.status = "404";
        fact.http.message = "404 - Page Not Found";

        germainApm.api.createEvent("Shopify Page Not Found", {
            success: false,
            errorClassification: "user-facing-application-error",
            http: fact.http
        });
    }
};

Because Shopify themes can customize the missing-page content, update the matching expressions for each store and language.

Important limitations

Response-body inspection can expose sensitive information or increase browser processing. Before enabling it:

Limitations and precautions:

Limit processing to the required endpoints.
Avoid storing the full response body.
Exclude checkout and payment responses unless explicitly approved.
Remove personal, order, authentication, and payment information.
Test the processor against legitimate responses to prevent false positives.
Confirm that the monitored response type is text before searching it.

Capture custom Shopify errors

When a store-specific failure cannot be detected automatically, create a custom event from the theme or application code. Example:

germainApm.api.createEvent("Shopify Add to Cart Failed", {
    success: false,
    errorClassification: "user-facing-application-error",
    operation: "AddToCart",
    productId: productId,
    variantId: variantId,
    message: sanitizedErrorMessage
});

Do not include customer email addresses, names, authentication values, payment data, or other sensitive values in custom error attributes. Use stable event names such as:

Shopify Add to Cart Failed
Shopify Cart Update Failed
Shopify Discount Application Failed
Shopify Checkout Failed
Shopify Search Failed
Shopify Order Submission Failed
Shopify Integration Failed

Configure error categorization

Categorization groups repeated occurrences of the same underlying error so teams can analyze problems instead of individual noisy events. Go to: Germain Workspace > Analytics > Categorization Create categorization rules using stable attributes such as:

Error name
Normalized message
Stack signature
Page or logical route
Request endpoint
HTTP status

Show all 10

Shopify operation
Third-party service
Business-process step
Theme or application version

Remove variable values that create unnecessary categories, including:

Product identifiers
Cart identifiers
Checkout tokens
Order identifiers
Customer identifiers
Timestamps
Random values
Request correlation IDs

For example, these messages should normally belong to one category:

Product 12345 could not be added to cart
Product 78492 could not be added to cart

Normalized category:

Product {productId} could not be added to cart

Identify new and changing errors

Use categorization and baseline comparison to identify:

New error categories
Errors introduced after a theme or application release
Sudden increases
Errors affecting additional customers
Errors spreading to new browsers or devices
Previously resolved errors that have returned
Errors associated with conversion loss

A technically new message is not necessarily a new root cause. Normalize variable content before using “new error” alerts.

Configure business-impact analysis

Prioritize errors using their effect on customer and business outcomes. Measure:

Number of occurrences
Unique affected customers
Affected sessions
Conversion rate
Abandoned carts
Failed checkouts

Show all 14

Lost or at-risk revenue
Affected products
Affected bus
Affected products
Affected business-process steps
Duration of impact
First and most recent occurrence
Store, market, browser, device, and release

An error occurring thousands of times in an unused background operation may be less important than an error affecting a small number of high-value checkout sessions.

Recommended prioritization

Priority	Suggested criteria
Critical	Prevents checkout or purchase for many customers, affects significant revenue, or creates a security or data-integrity risk
High	Breaks a major journey such as search, product selection, cart, login, or checkout
Medium	Degrades the experience but permits completion through an alternative path
Low	Limited impact, isolated occurrence, or non-customer-facing technical noise

Adjust these criteria to the store’s transaction volume, revenue, and service-level objectives.

Configure an error dashboard

Create or update a dashboard portlet with the following settings.

KPIs

Use one or more relevant KPIs, such as:

Browser Event
JavaScript Error
Unhandled Promise Rejection
Outbound HTTP Request
Resource Error
Application Error
Shopify custom error KPIs

Measures

Recommended measures include:

Count
Unique Users
Sessions
Error Rate
Failed Transactions
Conversion Rate

Show all 10

Abandonment Rate
Revenue Impact
Average Duration
95th-percentile Duration

Pivots

Recommended pivots include:

Error Category
Name
Normalized Message
Page
Request Endpoint
Business-Process Step

Show all 14

Product
Collection
Browser
Device
Country
Store
Environment
Release

Filters

Use filters such as:

Error classification
Success equals false
Application
Store
Environment
Date and time

Show all 11

Business-process step
New error
User-facing
Silent
User validation

Older configurations may store application errors under legacy fields such as User Error or userError. Retain those fields only for compatibility with historical data. For new configurations, use explicit classifications that distinguish visible application failures, silent failures, and user validation.

Analyze an error

For each important error, investigate:

How many customers and sessions were affected?
Is the failure visible to the customer?
Which page, product, or checkout step is affected?
Does the error prevent conversion?
What happened immediately before the error?
Which browser request failed?
Is the issue limited to a browser, device, country, or release?
Did the same customer retry or find another path?
Is the problem new, recurring, or increasing?
What technical evidence identifies the likely cause?

Use Session Replay to reconstruct the customer’s actions around the error. Correlate replay with clicks, pages, Shopify events, network requests, console activity, and business-process steps. Session Replay is an event-based reconstruction, not a video recording.

Include and exclude errors

Use rules and filters to control which error categories appear in operational dashboards and alerts. Exclude an error only when:

It is expected behavior.
It has no meaningful technical or business impact.
It is generated by a known browser extension or bot.
It is duplicate telemetry.
It contains unusable third-party noise.
Another KPI already represents it more accurately.

Do not delete or permanently ignore an error merely because it occurs frequently. First verify its impact on customers and conversion. Where possible, retain excluded events in a lower-priority analytical view so they remain available if their behavior changes.

Include or Exclude errors on a Dashboard - GermainUX

Configure alerts

Go to the GermainUX alert configuration and create notifications for actionable conditions. Recommended alerts include:

New critical error category
Checkout error-rate increase
Add-to-cart failure increase
Search failure increase
Application error affecting multiple customers
Error correlated with conversion degradation

Show all 9

Third-party service failure
Shopify API or webhook failure
Previously resolved error recurrence

Avoid sending one alert for every error occurrence. Use aggregation, categorization, deduplication, cooldown periods, and business-impact thresholds.

Configure reports

Schedule reports for trends that do not require immediate notification. Recommended report sections include:

New errors
Most frequent errors
Errors affecting the most customers
Errors with the greatest conversion impact
Checkout failures
Errors by release

Show all 10

Resolved and recurring errors
User validation trends
Silent application errors
Third-party service failures

Keep user validation in a separate section from software failures.

Validate the configuration

Test the configuration safely using a non-production store or Shopify test mode when possible. Verify:

JavaScript errors are captured.
Unhandled promise rejections are captured.
Failed HTTP requests are captured.
Functional failures returned with HTTP 200 are detected correctly.
Visible application errors use the correct classification.
Silent failures remain distinct.

Show all 14

Expected validation is not counted as an application error.
Sensitive values are masked or excluded.
Categories normalize dynamic values.
New errors can be identified.
Dashboards show affected customers and sessions.
Session Replay opens at the relevant point.
Alerts are deduplicated and routed correctly.
Test errors do not contaminate production reporting.

Troubleshooting

Too many insignificant errors

Suggested actions:

Add categorization and normalization.
Exclude known browser-extension noise.
Filter bot and crawler traffic.
Separate technical events from confirmed application errors.
Apply minimum occurrence or affected-user thresholds.
Alert only on new, increasing, or business-impacting categories.

One error creates many categories

Normalize dynamic product, cart, checkout, order, timestamp, and correlation values before categorization.

Errors appear without Session Replay

Confirm that:

Session Replay is enabled.
The session was selected by the replay sampling rules.
Consent permitted replay.
The page is within capture scope.
The error and replay use the same application and session identifiers.

A visible error is not detected

Determine whether the error is:

Rendered as DOM text
Displayed in a popup
Returned in a network response
Logged only to the console
Produced inside a cross-origin iframe
Generated by a third-party checkout

Configure the appropriate capture method. GermainUX running in a parent page cannot directly inspect protected content inside a cross-origin iframe.

A request returns HTTP 200 but failed functionally

Add a narrowly scoped response processor or create a custom event from the application code. Do not mark all HTTP 200 responses as successful without considering the application result.

Deploy Monitoring for Shopify
Configure Shopify Events
Configure Error Monitoring for Shopify
Configure User Feedback for Shopify
More details on Error Analysis

Get Help

Contact GermainUX Support

The GermainUX team helps you get up and running faster, empower your team, turn data into actionable insights, and optimize performance to deliver measurable business outcomes.

Can't find what you need?

Search all GermainUX docs with Ctrl + K, or use the feedback buttons at the bottom of this page to tell us what is missing.

The content of this document is proprietary to GERMAIN SOFTWARE.

Configure Error Monitoring for Shopify

Detect Functional Errors

Configure error categorization

Troubleshooting

​Configure Error Monitoring for Shopify

​Prerequisites

​Error classifications

​Error sources

​Browser and JavaScript errors

​Network errors

​Customer-visible errors

​Backend and integration errors

​Enable error monitoring

​Detect functional errors in successful HTTP responses

​Important limitations

​Capture custom Shopify errors

​Configure error categorization

​Identify new and changing errors

​Configure business-impact analysis

​Recommended prioritization

​Configure an error dashboard

​KPIs

​Measures

​Pivots

​Filters

​Analyze an error

​Include and exclude errors

​Configure alerts

​Suggested alert content

​Configure reports

​Validate the configuration

​Troubleshooting

​Too many insignificant errors

​One error creates many categories

​Errors appear without Session Replay

​A visible error is not detected

​A request returns HTTP 200 but failed functionally

​Related documentation

​Get Help

Contact GermainUX Support

Can't find what you need?

Configure Error Monitoring for Shopify

Prerequisites

Error classifications

Error sources

Browser and JavaScript errors

Network errors

Customer-visible errors

Backend and integration errors

Enable error monitoring

Detect functional errors in successful HTTP responses

Important limitations

Capture custom Shopify errors

Configure error categorization

Identify new and changing errors

Configure business-impact analysis

Recommended prioritization

Configure an error dashboard

KPIs

Measures

Pivots

Filters

Analyze an error

Include and exclude errors

Configure alerts

Suggested alert content

Configure reports

Validate the configuration

Troubleshooting

Too many insignificant errors

One error creates many categories

Errors appear without Session Replay

A visible error is not detected

A request returns HTTP 200 but failed functionally

Related documentation

Get Help