> ## Documentation Index
> Fetch the complete documentation index at: https://docs.germainux.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Error Monitoring for SAP (Configure)

> Configure GermainUX to detect, classify, analyze, and prioritize errors affecting SAP users, business processes, applications, and integrations.

Components
[`Engine`](https://docs.germainux.com/main/germain-ux-engine)
[`JS Profiler`](https://docs.germainux.com/main/germain-ux-js-profiler)
[`Mobile App`](https://docs.germainux.com/main/germain-ux-mobile-app)
[`RPA Bot Recorder`](https://docs.germainux.com/main/germain-ux-rpa-bot-recorder)
[`RUM JS`](https://docs.germainux.com/main/germain-ux-rum-js)

Availability
2022.1 or later

> [card] [Configure browser-error monitoring](#configure-browser-error-monitoring)
>
> Select profile and monitors

> [card] [Configure SAP Commerce Cloud error monitoring](#configure-sap-commerce-cloud-error-monitoring)
>
> Conversion-focused commerce errors

> [card] [Configure Engine-based error monitoring](#configure-engine-based-error-monitoring)
>
> Collect technical source errors

> [card] [Troubleshooting](#troubleshooting)
>
> Resolve error capture issues

**Configure Error Monitoring for SAP**

Configure GermainUX to detect, classify, analyze, and prioritize errors affecting SAP users, business processes, applications, integrations, and supporting technology.

GermainUX correlates errors with user sessions, Session Replay, business-process steps, browser activity, network requests, logs, APIs, integrations, Java execution, infrastructure, and supported database telemetry when those data sources are available.

## Supported SAP applications

Error monitoring can be configured for:

* SAP Fiori
* SAPUI5 applications
* SAP Web GUI
* Custom SAP web applications
* SAP portals
* SAP Commerce Cloud, formerly SAP Hybris
* Customer-controlled Java components associated with SAP
* SAP-related APIs, integrations, logs, servers, and supported databases

Coverage depends on the deployed GermainUX components and accessible data sources.

## Error-monitoring components

| Component | Error-monitoring capabilities |
| - | - |
| RUM JS | Browser errors, visible messages, failed requests, resource errors, freezes, custom events, user impact, and Session Replay |
| JS Profiler | Advanced browser-side JavaScript and network diagnostics |
| Engine | HTTP failures, log events, file events, process and service failures, integrations, and supported database errors |
| Code Profiler | Exceptions and execution details from supported, customer-controlled SAP Commerce Cloud Java runtimes |
| RPA Bot Recorder | Synthetic detection of availability, functional, and workflow failures |

## Error classifications

Use consistent classifications across KPIs, dashboards, alerts, and reports.

| Classification | Definition | Example |
| - | - | - |
| User-facing application error | The software is not operating correctly, and the failure is visible to the user | A SAP operation fails and displays an error message |
| Silent application error | The software fails without displaying the failure to the user | A background request fails, but the page does not notify the user |
| User validation | Expected feedback prevents invalid input or action | A required field is missing |
| Business-process failure | The expected business outcome is not achieved | Submission appears successful, but the required transaction is not created |
| Integration failure | A configured dependent service or data exchange fails | Inventory or payment integration times out |
| Technical event | A technical condition that has not yet been confirmed as a software failure | A handled browser warning with no demonstrated impact |
| Availability failure | A required application, process, service, or endpoint is unavailable | Fiori application or Commerce endpoint cannot be reached |

Keep user validation separate from application errors. Validation usually indicates that the application is operating as designed.

## Configure browser-error monitoring

Go to:

**Germain Workspace > Analytics > UX Monitoring Profiles**

Select the profile used by the SAP web application.

Configure the applicable browser monitors:

* JavaScript errors
* Unhandled promise rejections
* Browser console events
* Failed HTTP and fetch requests
* Resource-loading failures
* Browser freezes

> [accordion] Show all 12
>
> * Popup and visible-message monitoring
> * Custom application events
> * Session Replay
> * Network monitoring
> * Error categorization
> * Privacy and masking

Depending on the GermainUX version, UX Monitoring Profiles may appear under **Settings > Analytics**.

### JavaScript errors

RUM JS can capture supported JavaScript exceptions with information such as:

* Error name
* Message
* Stack
* Page
* Application
* Environment

> [accordion] Show all 10
>
> * Browser
> * User session
> * Timestamp
> * Related user action

Use the JS Profiler when additional browser-side execution evidence is required.

### Unhandled promise rejections

Unhandled promise rejections can indicate asynchronous failures in SAPUI5, Fiori, Commerce storefronts, or custom JavaScript.

Configure categorization rules to distinguish actionable failures from benign rejected operations.

### Browser console events

Console collection can provide diagnostic context when the application or a third-party component writes errors or warnings to the browser console.

Do not classify every console warning as an application error. Evaluate its effect on the user or business process.

### Resource errors

Capture failures involving:

* JavaScript files
* Stylesheets
* Images
* Fonts
* Application resources
* Third-party resources

Resource failures can explain incomplete pages, missing controls, broken layouts, and application-startup failures.

## Configure visible-message monitoring

GermainUX can capture supported browser dialogs or application messages when the message is available in the monitored page.

Potential sources include:

* Inline messages
* Banners
* Toast notifications
* Modal dialogs
* Browser dialogs
* Validation messages
* Custom application components

For each message rule, define:

* Page or application scope
* Element or message selector
* Message extraction
* Error classification
* Success state
* Severity
* Application and environment
* Privacy rules

The same visual component may display application errors, validation, warnings, and informational messages. Use the message and context to classify each event correctly.

## Configure network-error monitoring

Monitor browser requests associated with:

* REST A
* OData services
* SOAP services
* SAPUI5 resources
* Commerce services
* Authentication
* Integrations
* Third-party services

Potential failures include:

* Network connection failure
* Timeout
* HTTP error status
* Authentication failure
* Invalid response
* Functional failure returned with HTTP `200`
* Repeated retry
* Slow request followed by abandonment

Configure:

* Request naming
* URL normalization
* Success criteria
* Timeout thresholds
* Error categorization
* Header exclusion

> [accordion] Show all 14
>
> * Request- and respo
> * URL normalization
> * Success criteria
> * Timeout thresholds
> * Error categorization
> * Header exclusion
> * Request- and response-body exclusion
> * Correlation attributes

### Functional errors returned with HTTP 200

Some services return HTTP `200` while the response represents a failed operation.

Where required, configure narrowly scoped response processing to evaluate:

* Error field
* Business status
* Expected object
* Result count
* Response schema
* Known failure message

Avoid collecting complete response bodies. Extract only the fields required to determine success.

## Configure custom application errors

Create custom events when an important SAP application failure cannot be identified reliably through standard browser or network telemetry.

Example:

```text theme={null}
germainApm.api.createEvent("SAP Operation Failed", {
    success: false,
    errorClassification: "user-facing-application-error",
    operation: "SubmitPurchaseRequisition",
    message: sanitizedErrorMessage
});
```

Use stable names such as:

```text theme={null}
SAP Login Failed
SAP Search Failed
SAP Submission Failed
SAP Approval Failed
SAP Integration Failed
SAP Commerce Add to Cart Failed
SAP Commerce Checkout Failed
```

Do not include passwords, tokens, personal information, or sensitive business data in custom event attributes.

## Configure SAP Commerce Cloud error monitoring

GermainUX can monitor SAP Commerce Cloud with the same customer-experience and conversion-oriented approach used for other e-commerce platforms.

### Storefront errors

Monitor:

* JavaScript errors
* Failed browser requests
* Resource failures
* Product-loading failures
* Search failures
* Searches returning no results

> [accordion] Show all 14
>
> * Category-navigation failures
> * Product-configuration failures
> * Add-to-cart failures
> * Cart-update failures
> * Authentication failures
> * Checkout failures
> * Customer-visible messages
> * Third-party script failures

### Conversion-impacting errors

Correlate errors with:

* Product views
* Product configuration
* Add-to-cart
* Cart views
* Checkout starts
* Checkout steps

> [accordion] Show all 10
>
> * Purchase completion
> * Abandonment
> * Customer feedback
> * Revenue or cart value, when approved and available

This helps identify errors that:

* Prevent customers from finding products
* Block products from being added to the cart
* Cause cart abandonment
* Prevent checkout progression
* Affect a specific product, category, browser, or customer segment
* Reduce conversion

### Commerce integrations

Monitor accessible services such as:

* OCC APIs
* Search
* Inventory
* Pricing
* Promotions
* Payment

> [accordion] Show all 10
>
> * Tax
> * Shipping
> * Customer identity
> * CRM and ERP integrations

Each service requires an accessible data source and explicit configuration.

### Java exceptions

For supported, customer-controlled SAP Commerce Cloud Java runtimes, the GermainUX Code Profiler can collect:

* Exceptions
* Transaction failures
* Method-level execution context
* Outbound calls
* Supported database calls
* Related performance information

Code Profiler deployment requires:

* A supported Java runtime
* Permission to install the profiler
* Network access
* Approved configuration

In SAP-managed environments, Java runtime access may be restricted.

## Configure Engine-based error monitoring

The GermainUX Engine can collect errors from accessible technical sources.

### HTTP monitoring

Configure HTTP checks for:

* Availability
* Response time
* Expected status
* Functional response
* Authentication
* Timeou

> [accordion] Show all 13
>
> * Availability
> * Response time
> * Expected status
> * Functional response
> * Authentication
> * Timeout
> * Error message

A failed check can generate an availability, performance, or functional-error KPI.

### Log monitoring

Configure accessible log sources using a generic or custom parser.

Potential log events include:

* Prevent customers from finding products
* Block products from being added to the cart
* Cause cart abandonment
* Prevent checkout progression
* Affect a specific product, category, browser, or customer segment
* Reduce conversion

For each source, configure:

* Path and pattern
* Encoding
* Timestamp
* Time zone
* Multiline handling
* Rotation

> [accordion] Show all 10
>
> * Severity
> * Parser
> * Application and environment
> * Privacy rules

### Process and service failures

Monitor supported operating-system processes and services for:

* Missing process
* Stopped service
* Unexpected instance count
* Repeated restart
* Startup failure

Process unavailability indicates a technical condition. Correlate it with application and user evidence before assigning business impact.

### Supported database errors

When a compatible database monitor is configured, GermainUX can collect supported:

* Connection failures
* Query failures
* Locks and blocking
* Long-running queries
* Capacity conditions
* Availability failures

Use a dedicated read-only monitoring account.

## Analyze imported SAP diagnostic events

SAP-related errors, dumps, traces, or workload events can be analyzed when they are supplied through an accessible and configured source.

Potential sources include:

* Exported text files
* Accessible logs
* Approved APIs
* Database queries
* Custom scripts
* Custom integrations

Once collected, GermainUX can:

* Normalize the error
* Categorize it
* Analyze its frequency
* Identify affected applications and environments
* Correlate it with other events
* Alert and report on it
* Compare it with previous occurrences

The available analysis depends on the fields extracted from the source.

## Configure error categorization

Go to:

**Germain Workspace > Analytics > Categorization**

Create rules using stable attributes such as:

* Error name
* Normalized message
* Error code
* Stack signature
* Page
* Request endpoint

> [accordion] Show all 11
>
> * Application component
> * Business-process step
> * Java exception type
> * Integration
> * Application and environment

Normalize variable values such as:

* User identifiers
* Document identifiers
* Session identifiers
* Request identifiers
* Timestamps
* Memory addresses

> [accordion] Show all 9
>
> * Thread identifiers
> * Generated file names
> * Dynamic product or order identifiers

### Exact and fuzzy matching

Use exact matching for attributes that must be identical, such as:

* Error type
* Normalized error code
* Application
* Component

Use fuzzy matching for fields that can vary slightly, such as:

* Normalized message
* Stack signature
* Diagnostic text

Categorization helps identify:

* New errors
* Recurring errors
* Increasing errors
* Errors introduced after a release
* Similar errors across users or systems
* Previously resolved errors that returned

## Prioritize errors by business impact

Use the GermainUX Analysis Dashboard and other analytical views to determine:

* Number of occurrences
* Unique affected users
* Affected sessions
* Affected business processes
* Affected process steps
* Completion and abandonment impact

> [accordion] Show all 13
>
> * Conversion impact
> * Revenue impact, when configured
> * Applications and environments affected
> * Browsers, devices, roles, and locations affected
> * First and most recent occurrence
> * Relationship with a release or deployment
> * Related technical KPIs

A frequent technical warning may be less important than a less frequent error that blocks a critical business process or purchase.

## Analyze an individual error

For an error instance, review:

* Classification
* Message
* Timestamp
* Application and environment
* User session
* Page or application view

> [accordion] Show all 14
>
> * User action
> * Session Replay
> * Browser errors
> * Network requests
> * Business-process step
> * Related log or API event
> * Java execution details, when available
> * Related infrastructure or database conditions

Use Session Replay to understand what the user experienced before and after the error.

Session Replay reconstructs captured browser activity. It is not a video recording.

## Correlate frontend and backend evidence

Where compatible identifiers are available, correlate:

**1. User action**

**2. Browser activity**

**3. Outbound request**

**4. HTTP or integration event**

**5. Application log or Java exception**

**6. Supported database event**

**7. User-visible result**

Potential correlation attributes include:

* Session identifier
* Request identifier
* Correlation identifier
* Transaction identifier
* Application
* Environment
* User
* Timestamp

Time-based relationships can support investigation, but a shared identifier provides stronger evidence.

## Configure error KPIs

Potential KPIs include:

| KPI | Description |
| - | - |
| User-Facing Application Error | Software failure visible to the user |
| Silent Application Error | Software failure not visible to the user |
| User Validation | Expected feedback preventing invalid input |
| Browser Error | Browser-side error event |
| JavaScript Error | JavaScript exception |
| Unhandled Promise Rejection | Unhandled asynchronous JavaScript failure |
| Failed HTTP Request | Browser or Engine request that failed |
| Resource Error | Browser resource failed to load |
| Java Exception | Exception from a supported profiled Java runtime |
| Integration Failure | Configured integration operation failed |
| Functional Validation Failure | Operation returned an incorrect functional result |
| Process or Service Unavailable | Required operating-system process or service is unavailable |
| Synthetic Scenario Failure | Synthetic SAP journey failed |
| Error-Affected Users | Distinct users associated with qualifying errors |
| Error-Affected Sessions | Sessions containing qualifying errors |

Create custom KPIs when a configured SAP event does not map to an existing KPI.

## Configure dashboards

Go to:

**Germain Workspace > Dashboards > All**

Search for SAP, error, user-experience, business-process, or Commerce dashboards, or create a dashboard from the configured KPIs.

### Recommended dashboard views

#### Error overview

Include:

* Total application errors
* New error categories
* Unique affected users
* Error-affected sessions
* Error trend
* Most impactful errors

#### User-impact analysis

Include:

* Errors by user
* Errors by page
* Errors by application
* Errors by business-process step
* Session Replay links
* Completion and abandonment impact

#### SAP Commerce Cloud errors

Include:

* Product errors
* Search failures
* Add-to-cart failures
* Cart errors
* Checkout errors
* Conversion impact
* Revenue impact
* Errors by product, category, browser, and device

#### Technical errors

Include:

* Failed requests
* JavaScript errors
* Java exceptions
* Log errors
* Integration failures
* Process and service failures
* Supported database errors

## Configure alerts

Create alerts for actionable conditions such as:

* New critical error category
* User-facing application error affecting multiple users
* Business-process failure increase
* Checkout failure increase
* Integration unavailable
* Java exception increase

> [accordion] Show all 10
>
> * Failed request increase
> * Required process or service stopped
> * Error introduced after a release
> * Previously resolved error returned

Avoid sending one alert for every occurrence.

Use:

* Categorization
* Aggregation
* Deduplication
* Affected-user thresholds
* Business-impact thresholds
* Consecutive-failure rules
* Cooldown periods
* Maintenance periods

### Alert content

An error alert should include:

* Error name and category
* Classification
* Severity
* Application and environment
* First and most recent occurrence
* Number of occurrences

> [accordion] Show all 11
>
> * Unique affected users
> * Affected process or conversion stage
> * Related release
> * Link to analysis
> * Link to affected sessions or replay

## Configure reports

Schedule reports for:

* New errors
* Recurring errors
* Most frequent errors
* Errors affecting the most users
* Errors affecting critical processes
* SAP Commerce conversion errors

> [accordion] Show all 12
>
> * Errors by application or environment
> * Errors by release
> * Resolved and recurring errors
> * User-validation trends
> * Silent application errors
> * Integration and Java exceptions

Keep user validation separate from software failures.

## Configure automated actions

GermainUX can initiate approved actions in response to configured error conditions.

Potential actions include:

* Send an email or collaboration notification
* Create an incident or ticket
* Call an approved webhook
* Execute an authorized diagnostic script
* Run a synthetic scenario
* Generate an analysis or report
* Invoke an approved corrective action

Configure:

* Trigger
* Scope
* Permissions
* Safeguards
* Cooldown
* Failure handling
* Audit trail
* Manual approval when required

## Privacy and security

Errors and diagnostic data can contain sensitive information.

Configure:

* Text and input masking
* URL sanitization
* Request-header exclusion
* Request- and response-body exclusion
* Log-field redaction
* Session Replay exclusions

> [accordion] Show all 10
>
> * Data retention
> * Role-based access
> * Export restrictions
> * Sensitive-data detection, where available

Do not collect:

* Passwords
* Authentication tokens
* Session cookies
* Payment-card information
* Security codes
* Unnecessary personal data
* Unrestricted business documents
* Sensitive request or response content

## Validate the configuration

Confirm that:

* JavaScript errors are captured.
* Unhandled promise rejections are captured.
* Failed requests are captured.
* Resource failures are captured.
* Visible application errors are classified correctly.
* Silent failures remain separate.

> [accordion] Show all 17
>
> * User validation is not counted as an application error.
> * Commerce errors correlate with the correct journey stage.
> * Engine-based events use the correct application and environment.
> * Java exceptions appear only where Code Profiler is deployed.
> * Error categories normalize dynamic values.
> * New errors can be identified.
> * Session Replay opens the affected session.
> * Business impact appears correctly.
> * Sensitive values are protected.
> * Alerts are deduplicated and routed correctly.
> * Test events do not contaminate production reporting.

## Troubleshooting

### Too many insignificant events

* Separate technical events from confirmed application errors.
* Categorize and normalize recurring messages.
* Exclude known browser-extension or bot noise.

![Error Monitoring for SAP (Configure): Too many insignificant events](https://mintcdn.com/germain-ux/8KX3c-GSSWR99tdN/images/main/error-monitoring-for-sap-configure/image-20240227-165033.png?fit=max\&auto=format\&n=8KX3c-GSSWR99tdN\&q=85\&s=9f2c47b8a026e2b9945724796d588076)

* Filter expected validation.
* Use affected-user and business-impact thresholds.
* Alert only on new, increasing, or important categories.

### One error creates many categories

Normalize dynamic:

* User identifiers
* Document identifiers
* Request identifiers
* Timestamps
* Memory addresses
* Product identifiers
* Order identifiers

### A visible error is not detected

Determine whether it is:

* DOM text
* Toast notification
* Modal dialog
* Browser dialog
* Console event
* Network response
* Custom component
* Cross-origin content

Configure the corresponding detection method.

### Error appears without Session Replay

Confirm that:

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

### Backend error is not linked to the user session

Verify:

* Correlation identifiers
* Application and environment
* Clock synchronization
* Request naming
* Log extraction
* Correlation rules

Without a shared identifier, use time-based analysis cautiously.

## Related documentation

| Topic | Link |
| - | - |
| SAP Monitoring | [SAP Commerce Cloud Operational Experience Intelligence](https://docs.germainux.com/sap/commerce-cloud.md) |
| Configure Monitoring for SAP | [Configure Monitoring for SAP](https://docs.germainux.com/main/configure-monitoring-for-sap.md) |
| Configure Application Monitoring for SAP | [Application Monitoring for SAP (Configure)](https://docs.germainux.com/main/application-monitoring-for-sap-configure.md) |
| Configure Business-Process Monitoring for SAP | [Business Process Monitoring for SAP (Configure)](https://docs.germainux.com/main/business-process-monitoring-for-sap-configure.md) |
| Configure Crash and Diagnostic-File Monitoring for SAP | [Crash and Diagnostic-File Monitoring for SAP (Configure)](https://docs.germainux.com/main/crash-monitoring-for-sap-configure.md) |
| Configure User Monitoring and Session Replay for SAP | [User Monitoring and Session Replay for SAP (Configure)](https://docs.germainux.com/main/user-monitoring-and-session-replay-for-sap-configu.md) |
| Engine Deployment for SAP | [Engine Deployment for SAP](https://docs.germainux.com/main/engine-deployment-for-sap.md) |
| RUM JS Deployment for SAP | [RUM JS Deployment for SAP](https://docs.germainux.com/main/rum-js-deployment-for-sap.md) |
| JS Profiler Deployment for SAP | [JS Profiler Deployment for SAP](https://docs.germainux.com/main/js-profiler-deployment-for-sap.md) |
| KPIs for SAP | [KPIs for SAP](https://docs.germainux.com/main/kpis-for-sap.md) |

### Get More Information

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

[Contact GermainUX Support](https://docs.germainux.com/main/support.md).

## Get Help

> [card] [Contact GermainUX Support](https://docs.germainux.com/main/support.md)
>
> 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.

> [card] 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.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.