Error Monitoring for Shopify (Configure)

⚙️ 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:

🏷️ Error classifications

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

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:

☁️ Network errors

Monitor:

👥 Customer-visible errors

Monitor error messages associated with:

🖥️ Backend and integration errors

When the GermainUX Engine is configured, monitor:

🚀 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:

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:

🔧 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:

🔎 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:

Remove variable values that create unnecessary categories, including:

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:

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:

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

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:

📏 Measures

Recommended measures include:

🔀 Pivots

Recommended pivots include:

🔎 Filters

Use filters such as:

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:

1. How many customers and sessions were affected?

2. Is the failure visible to the customer?

3. Which page, product, or checkout step is affected?

4. Does the error prevent conversion?

5. What happened immediately before the error?

6. Which browser request failed?

7. Is the issue limited to a browser, device, country, or release?

8. Did the same customer retry or find another path?

9. Is the problem new, recurring, or increasing?

10. 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:

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.

🔔 Configure alerts

Go to the GermainUX alert configuration and create notifications for actionable conditions.

Recommended alerts include:

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

📄 Suggested alert content

An error alert should include:

🗂️ Configure reports

Schedule reports for trends that do not require immediate notification.

Recommended report sections include:

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:

🧰 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.

🔗 Related documentation

• Deploy Monitoring for Shopify

• Configure Monitoring for Shopify

• Configure Third-Party Checkout Monitoring

• Configure Shopify Events

• Configure User Feedback

• KPIs for Shopify Monitoring

ℹ️ Get More Information

GermainUX can help determine which monitoring, analytics and automation capabilities are appropriate for your Salesforce Experience Cloud environment.

Contact GermainUX Support.