SAP CPI Monitoring Best Practices for Silent Failures and Delays

An SAP Cloud Integration (CPI) interface can show no failed messages while business transactions are delayed or missing. A sender may stop transmitting, a scheduled file may never arrive, or messages may remain in a JMS queue long enough to miss their delivery deadline. None of these situations necessarily creates a failed Message Processing Log (MPL), so monitoring built exclusively around failures can overlook them.
SAP Cloud ALM supports failed-message alerts, high-processing-time events, integration artefact errors and message-volume anomaly detection. Its Health Monitoring capabilities also provide visibility into JMS resources, certificate validity and database usage. These are important components of SAP CPI monitoring, but they do not automatically confirm that every expected business transaction has reached its destination.
That distinction matters for critical integrations. A low-volume alert can identify a change in message activity, but it cannot necessarily identify which order, invoice or payment is missing. An integration flow can complete successfully while the wider business process remains incomplete.
Effective SAP CPI monitoring combines platform health, message-level visibility, expected-arrival checks and business-transaction verification.
This guide explains what SAP's monitoring tools cover, where additional controls are needed and how to design alerts for missing messages, JMS backlogs, end-to-end latency and conditions that may lead to failures.
What SAP's monitoring tools cover for Cloud Integration
Before adding custom monitoring, integration teams should establish which signals their existing SAP tools already provide.
SAP Cloud Integration's native monitoring capabilities focus on message processing, integration artefacts and runtime resources. SAP Cloud ALM extends that visibility through Integration & Exception Monitoring and Health Monitoring.
The table below summarises the available capabilities and where additional design may be required.
| Monitoring signal | CPI native monitoring | Cloud ALM Integration & Exception Monitoring | Cloud ALM Health Monitoring | Additional monitoring required? |
|---|---|---|---|---|
| Individual failed message | Yes, through MPL | Yes, individual failure event | No | Usually no |
| Multiple failed messages | Yes, through MPL | Yes, grouped failure event | No | Usually no |
| Processing time above threshold | Duration visible in MPL | Yes, high-processing-time event | No | For cross-flow latency |
| Integration artefact not operational | Artefact status visible | Yes, non-operational artefact event | No | Usually no |
| Unexpectedly low or high message volume | Message activity visible | Yes, volume anomaly event | No | For exact expected-arrival rules |
| Specific expected file or transaction missing | No automatic business expectation | Not guaranteed by volume anomaly detection | No | Yes |
| JMS queue capacity and message count | Yes | Not its primary function | Yes, JMS resource metrics | For deadline-based queue age |
| Certificate approaching expiry | Keystore information visible | No | Yes, certificate validity | Usually no |
| Time waiting between chained flows | Not included in individual MPL duration | Not measured as end-to-end wait | No | Yes |
| Confirmed business outcome in target system | No | No | No | Yes |
SAP's current Cloud ALM monitoring content for Cloud Integration includes an Anomalies Detected in Message Processing event when processed-message volumes are unusually low or high. It also supports individual and grouped failure events and high-processing-time alerts.
Volume anomaly detection is valuable, but it answers a different question from transaction reconciliation.
A volume alert asks whether message activity is outside an expected range. A reconciliation check asks whether a particular business record that should have arrived actually did.
For enterprise integrations, both questions can matter. The available metrics and events should also be checked against the organisation's runtime environment and current Cloud ALM configuration before relying on them operationally.
Why SAP CPI message monitoring alone cannot guarantee delivery
A Message Processing Log records an execution that Cloud Integration has logged. It does not represent every transaction that an external application was expected to send.
For example, suppose an order interface normally receives several thousand transactions during business hours. If the sending application stops transmitting, Cloud Integration may have no new execution to record and therefore no new failure.
A volume anomaly alert may identify the unusual decline, depending on its configuration and observation window. But the absence of a specific order is still a business-level expectation that must be verified separately.
Cloud ALM depends on existing Message Processing Logs
SAP Cloud ALM collects existing MPLs from Cloud Integration. SAP explicitly notes that when the configured log level prevents MPL creation, those messages will not appear in Cloud ALM.
Custom checks using the Message Processing Logs OData API inherit the same dependency.
Two operational rules follow:
- Business-critical flows should use production log settings that provide the required monitoring visibility.
- Any check based on MPL counts should treat missing logs as ambiguous until logging configuration and data collection have been verified.
A zero count may mean that no messages arrived. It may also indicate missing monitoring data.
Logging configuration, retention and troubleshooting are covered in Tarento's SAP CPI logging limits guide.
Detecting missing SAP CPI messages: which monitoring approach should you use?
Missing-message detection requires a definition of what should have happened.
That expectation may be a scheduled file arriving before a cutoff time, a minimum number of messages during a business window, a recurring integration job completing successfully or an individual source transaction appearing in the target application.
Different requirements call for different monitoring controls.
| Monitoring requirement | Recommended approach | What it verifies |
|---|---|---|
| Identify an unusual decline in message activity | Cloud ALM volume anomaly detection | Whether observed message volume differs from expected activity |
| Detect a missing scheduled file or expected batch | Expected-arrival watchdog | Whether a defined event occurred before its deadline |
| Detect a stopped tenant or scheduler | External heartbeat monitoring | Whether an expected signal continues to arrive outside the tenant |
| Confirm that orders or invoices reach the target | Source-to-target reconciliation | Whether expected business records are present |
| Detect messages waiting too long in JMS | Queue-age and deadline checks | Whether queued messages remain within delivery expectations |
These controls are complementary rather than interchangeable.
Design 1: Monitor message-volume anomalies with Cloud ALM
For interfaces with predictable traffic patterns, Cloud ALM's message-volume anomaly event provides a useful starting point. Integration teams can configure available monitoring filters and event rules to observe relevant message activity and identify unusually low or high processing volumes.
This is especially useful for continuous interfaces where a sudden decline may indicate sender connectivity problems, an upstream outage or a scheduling issue. However, overall volume is not always a reliable indicator of business completeness.
Consider an interface that processes hundreds of orders daily. A small number of missing orders may not materially change the total message volume. An anomaly rule can remain within its expected range even though important transactions are absent.
Cloud ALM volume monitoring is therefore a valuable first line of detection, but not a substitute for transaction-specific assurance.
Design 2: Build an expected-arrival watchdog using the MPL API
An expected-arrival watchdog checks whether a defined message or volume requirement was satisfied within a particular time window.
A scheduled integration flow can query the Cloud Integration OData API:
/api/v1/MessageProcessingLogs
The watchdog filters relevant records by properties such as integration flow, sender, message status and processing timestamps. It then compares the observed results with the expected activity.
For example, an interface may require a supplier file to arrive by a specific time on every business day. The watchdog can check for a corresponding processing record shortly after the deadline. If no matching record exists, it raises an alert. A watchdog needs to account for API paging, suitable time windows, log retention and monitoring API failures. It should also distinguish a successful processing record from a business requirement that has actually been fulfilled.
The limitation is where the watchdog runs.
If the watchdog runs on the same tenant it monitors, a tenant outage or scheduler failure may stop the watchdog as well. That makes an internal watchdog suitable for lower-cost expected-arrival checks, but insufficient as the sole availability control for critical interfaces.
Design 3: Use an external heartbeat to detect silent outages
An external heartbeat addresses the main weakness of a watchdog that depends on its own monitored tenant. A critical integration flow or a companion component sends a signal to an independent monitoring service. The external service tracks whether the expected signal arrives within an agreed interval.
If the heartbeat stops, the external system can raise an alert even when Cloud Integration itself cannot execute a monitoring flow. This pattern is commonly called a dead man's switch.
There are two important heartbeat designs:
- Schedule-based heartbeat: A lightweight process sends a signal at defined intervals. This helps detect whether the tenant, scheduler or heartbeat-producing component is operating.
- Execution-based heartbeat: A business integration sends a signal after reaching a defined processing milestone. This helps detect missed executions or an absence of successful completions.
The distinction matters. A healthy schedule-based heartbeat does not prove that business transactions are flowing. An execution-based heartbeat confirms only the milestone at which it was emitted, not necessarily final completion in a downstream system.
Heartbeat calls should also be designed so a temporary monitoring-service outage does not cause otherwise valid business transactions to fail. For critical interfaces, independent heartbeat monitoring is most useful when combined with an explicit expected-arrival rule.
Design 4: Reconcile transactions between source and target systems
For business processes where every record matters, source-to-target reconciliation provides stronger assurance than monitoring message volume alone.
Reconciliation compares the transactions created in the source application with those acknowledged or recorded in the target system. It can identify records lost before reaching Cloud Integration, failures within the integration landscape and transactions that were processed by the middleware but did not achieve the expected downstream outcome.
For example, an invoice integration could compare invoice identifiers exported from the source application against successfully created invoice records in the receiving ERP.
A reliable design requires:
- A shared transaction identifier or matching key.
- An agreed reconciliation window and business cutoff.
- Rules for legitimate delays, duplicates and cancelled transactions.
- A process for investigating and safely recovering mismatches.
Reconciliation typically runs less frequently than operational alerts, but it provides evidence that the business outcome occurred. For financial, order-management and other critical transaction interfaces, it should complement real-time monitoring rather than replace it.
Account for business calendars and expected behaviour
An expected-arrival rule is only useful when the expectation is accurate.
Trading days, public holidays, month-end processing, planned maintenance and seasonal demand can all change legitimate message patterns. A fixed minimum-volume threshold may work for a stable continuous interface, while a scheduled batch may need an explicit deadline and holiday calendar.
Monitoring rules should reflect these differences. Otherwise, teams receive false alerts during normal quiet periods and gradually lose confidence in the monitoring system.
SAP CPI JMS queue monitoring: capacity, backlog and message age
JMS queues allow SAP Cloud Integration to decouple message producers from consumers. This helps manage asynchronous processing and temporary receiver unavailability.
However, queued messages introduce another form of operational risk. A message can be accepted and stored successfully while the downstream business transaction remains incomplete.
If the receiver slows down, the backlog grows. If the queue approaches its resource limit, new messages may begin to fail.
Effective SAP CPI JMS queue monitoring must therefore consider capacity, message count, processing throughput and delivery deadlines.
Understand JMS resource limits
SAP documents the following default and self-service maximum JMS resources for the applicable SAP Integration Suite service plans and existing Cloud Integration Enterprise Edition licences.
| JMS resource | Default | Self-service maximum |
|---|---|---|
| Number of queues | 30 | 100 |
| Total queue capacity | 9.3 GB | 30 GB |
| Transactions | 150 | 500 |
| Consumers | 150 | 500 |
| Providers | 159 | 500 |
These are documented resource values, not a guarantee of the limits available in every environment. Teams should check their tenant, entitlement and runtime configuration against SAP's current JMS resource limits documentation.
Approaching a quota can affect flows other than the one responsible for the backlog. For example, one integration may consume shared JMS resources while another flow encounters failures when attempting to produce new messages.
Four JMS monitoring signals that matter
1. Queue capacity and available resources
Monitor consumed storage against the configured limit, together with queue count, transactions, consumers and providers. SAP Cloud ALM Health Monitoring provides JMS resource metrics, helping operations teams identify conditions that may affect processing before capacity is exhausted.
2. Message count per queue
Message count shows how many records are currently waiting in a queue. However, queue depth requires context. A queue holding several hundred messages may be normal for one interface and a serious incident for another. Use observed traffic patterns and interface-specific processing expectations to establish meaningful thresholds.
3. Age of the oldest message
Message age often provides a more useful operational signal than depth. A small queue containing a message that has exceeded its business delivery deadline can be more urgent than a much larger queue draining normally. Where age is not directly available as a monitoring metric, the queue's message timestamps or appropriate monitoring APIs can support an additional age-based check. Alert against the agreed delivery deadline, taking legitimate processing and retry behaviour into account.
4. Consumer activity and unused queues
Review whether expected consumers are active, whether messages are being processed and whether inactive queues continue to consume allocated resources. Queue maintenance should be controlled. A queue that appears unused should not be deleted without confirming its dependencies and retention requirements.
Use the JMS OData API for programmatic queue inspection
SAP has introduced newer JMS OData API capabilities that support more detailed programmatic inspection and management of JMS messages. The API exposes resources including:
MessagingQueuesMessagingMessages
These allow authorised clients to inspect queues and message records, subject to the supported runtime version, available permissions and API limitations. SAP Community documentation identifies availability starting with Cloud Integration version 7.52.x on Cloud Foundry and version 8.41 on Edge Integration Cell. For example, an authorised monitoring client can retrieve queue information using:
GET /api/v1/MessagingQueues
It can also inspect messages associated with a specific queue using the corresponding MessagingMessages resource.
This makes it possible to build more specific queue-inspection workflows, including checks that correlate message state with application identifiers or timestamps where the required information is exposed.
Monitoring access should use appropriately scoped credentials. Operations such as deletion, movement or retry of messages require additional controls because they can change business processing outcomes.
JMS retry intervals are not guaranteed processing times
A configured JMS retry interval should not be treated as an exact delivery schedule. SAP KBA 3569999 describes cases involving non-exclusive JMS queues where retry attempts occur later than the configured interval. Initial processing may also be delayed, and processing order can differ from arrival order without necessarily indicating a platform fault. Consequently, monitoring thresholds should include suitable retry headroom and use the business delivery deadline as the primary operational measure. A message should be investigated because it threatens or exceeds a meaningful processing expectation, not simply because a retry did not occur at an exact minute.
Estimate how long a JMS backlog will take to clear
When a receiver recovers, integration operations often need to estimate how long the queue will take to drain. A simple approximation is: Estimated drain time = Messages waiting ÷ (Consumption rate − Arrival rate) The formula assumes that consumption exceeds arrivals and that both rates remain reasonably stable. For example, suppose a queue contains 6,000 messages. The receiver processes 1,200 messages per minute while new messages arrive at 900 per minute. The net reduction is 300 messages per minute. The estimated drain time is therefore:
6,000 ÷ 300 = 20 minutes
If consumption falls below the arrival rate, the backlog grows instead of shrinking. Real processing rates can change with retries, concurrency, batching, downstream throttling and message complexity. The calculation is an operational estimate, not a guaranteed recovery time. For a backlog approaching a business deadline, the practical response may involve adjusting consumer throughput, resolving a receiver constraint or coordinating upstream traffic rather than merely increasing retry frequency.
Measuring end-to-end latency across chained integration flows
An MPL measures the execution of an individual message-processing run.
In asynchronous integrations, that execution time may represent only a portion of the total business processing journey.
Consider an order moving through two integration flows:
- The producer flow receives the order and writes it to a JMS queue.
- The consumer flow later retrieves the message and delivers it to the target application.
Each execution has its own processing duration. The period spent waiting in the queue is not automatically included in either individual execution's duration.
A flow can therefore complete quickly while the overall transaction experiences a significant delay.
Cloud ALM's high-processing-time events help identify slow individual executions, but do not automatically establish the full elapsed time across a multi-flow business process.
Link related executions with a business identifier
Measuring end-to-end latency requires a reliable way to associate the relevant processing stages. Where correlation identifiers are propagated consistently, monitoring can use them to link related records. Where they are not, an integration design may need a shared business identifier such as an order ID, invoice ID or application message ID. SAP Cloud Integration supports custom header properties that can improve message searchability and correlation through monitoring APIs. The design should record the relevant business start point and the event that represents successful completion.
For example:
- Start: Order accepted by the sending application.
- Intermediate stage: Order placed in a JMS queue.
- Processing stage: Consumer flow sends the order to the receiver.
- Completion: Target application confirms the expected business outcome.
End-to-end latency is the elapsed time between the agreed start and completion events. This distinction is important for service-level reporting. Measuring only middleware execution time can materially understate the delay experienced by the business.
Platform health signals that can warn before integration failures
Not every monitoring alert should wait for message processing to fail. SAP Cloud ALM Health Monitoring provides several signals that can help teams identify developing platform conditions.
Certificate validity
Cloud ALM exposes certificate validity information, including remaining days before expiry. Certificate expiry can interrupt authentication or secure communication across several integrations at once. Set renewal alerts early enough to accommodate approval, certificate issuance, deployment and testing. The appropriate threshold depends on the organisation's actual renewal process rather than a universal number of days.
Database and storage resources
Health Monitoring exposes resource information such as data store usage, monitoring storage consumption, database connection usage and maximum transaction duration. Unexpected increases may indicate accumulating processing data, sustained resource usage or a workload that requires investigation.
Memory exhaustion
Memory exhaustion events can provide an indication of runtime resource pressure. The response should account for the affected tenant, workload patterns and whether the condition is recurring.
Integration artefacts that are not operational
Cloud ALM Integration & Exception Monitoring can raise events when integration content becomes non-operational. These events are useful after deployment and during ongoing operations, especially when an artefact problem prevents expected executions from occurring.
For organisations operating recovery environments, the readiness of a secondary tenant is another important consideration. Tarento's SAP Integration Suite failover readiness article discusses this broader operational requirement. Each platform alert should have an owner, an appropriate lead time and an agreed first response.
Turning SAP CPI monitoring signals into actionable alerts
Collecting monitoring data is only the first step. The operational value comes from knowing which condition needs attention, who owns it and what should be investigated first.
The following matrix provides a starting point for defining monitoring responsibilities.
| Signal | Example alert condition | Primary owner | First investigation |
|---|---|---|---|
| Failed-message cluster | Multiple failures affecting the same receiver | Integration operations | Receiver availability and common error |
| Low message volume | Observed traffic outside expected activity | Integration operations | Sender activity and Cloud ALM collection status |
| Missing scheduled file | Expected file not recorded by cutoff time | Sending application owner | File generation, transfer and schedule |
| Missing external heartbeat | Expected signal not received | Integration operations | Tenant availability, scheduler and monitored flow |
| JMS queue age | Oldest message exceeds allowed waiting time | Integration and receiver teams | Consumer activity and receiver throughput |
| High JMS resource usage | Usage approaching configured resource limit | Platform owner | Queue growth, consumer behaviour and quotas |
| Certificate expiry | Remaining validity below renewal lead time | Security or platform owner | Renewal and deployment plan |
| Transaction mismatch | Source record has no valid target match | Application and business operations | Transaction state and recovery eligibility |
These are example alert conditions, not recommended universal thresholds.
Group alerts around likely root causes
If ten integration flows fail because they depend on one unavailable receiver, creating ten unrelated incidents makes diagnosis harder. Where the monitoring platform and event configuration support it, group related failures around the common dependency or likely root cause.
Suppress alerts only when silence is expected
Maintenance windows and business calendars should inform monitoring rules. However, suppressing a missing-message alert must not conceal unexpected transactions that should still be processed during the same period. The monitoring policy should distinguish approved inactivity from unplanned silence.
Define recovery before an incident occurs
A monitoring alert should lead to a defined investigation and recovery procedure. Teams need to know when a message can be safely retried, when a source application must resend data and when reconciliation is needed before recovery. For these decisions, see Tarento's guide to SAP CPI failed-message reprocessing.
Example: Monitoring a business-critical order interface
Consider an illustrative order-processing scenario involving a source commerce application, SAP Cloud Integration and a target ERP. The business expects all accepted orders to appear in the ERP within an agreed processing window. An effective monitoring design would use several controls.
First, Cloud ALM monitors processing failures and message-volume anomalies. This helps identify failed executions and unusual traffic patterns.
Second, an external heartbeat verifies that the expected monitoring signal continues to arrive. If the tenant or critical scheduled process stops producing the signal, the independent monitor raises an alert.
Third, JMS monitoring observes queue capacity and waiting time. If orders accumulate while the receiver is unavailable, operations can identify the backlog before the delivery deadline is missed.
Finally, reconciliation compares accepted order identifiers with confirmed ERP records. This identifies transactions that have not reached the expected business outcome, even where middleware execution appears successful.
The purpose is not to deploy every monitoring mechanism indiscriminately. It is to select controls according to the impact of a missed transaction and the failure modes the business needs to detect. This scenario is illustrative and is not presented as a Tarento customer implementation or measured performance result.
Where iVolve Integration Inspector fits
SAP's monitoring tools provide essential visibility into Cloud Integration processing and platform health. Enterprise teams may also need more convenient investigation, reporting and operational workflows across their integration landscape.
Integration Inspector is the enhanced monitoring capability within Tarento's iVolve integration framework.
As described in Tarento's integration debt and monitoring article, its capabilities include full monitoring reports, downloadable error reports for offline analysis, restart through reusable scripts, and searches using sender, receiver, message type, application ID, date and time.
It also supports statistics and aggregate views for operational investigation. These capabilities can help teams investigate message activity, analyse recurring failures and locate relevant processing records without relying entirely on individual MPL searches. For example, aggregate views by sender and time can support investigation of an apparent decline in traffic. Search by business-relevant identifiers can help narrow down a transaction investigation. Integration Inspector complements SAP Cloud Integration and Cloud ALM rather than replacing the monitoring architecture required for each business process. Expected-traffic rules, independent tenant monitoring and source-to-target reconciliation still need to be designed according to the organisation's requirements. The value lies in combining platform monitoring with efficient investigation and a clear operational response.
Frequently asked questions
Can SAP Cloud ALM detect missing SAP CPI messages?
SAP Cloud ALM supports message-volume anomaly detection for Cloud Integration, including events when processed-message volumes are unusually low or high. However, a volume anomaly does not necessarily identify a specific missing business transaction. If a sender never creates a message, there may be no corresponding MPL to inspect. For critical interfaces, use explicit expected-arrival checks or source-to-target reconciliation alongside Cloud ALM monitoring.
How do you detect a scheduled SAP CPI iFlow that did not run?
A scheduled iFlow that never starts may produce no new MPL and therefore no failed-message event. An expected-arrival watchdog can check whether the required execution was recorded. For stronger outage detection, use an external heartbeat that does not depend on the monitored tenant. The appropriate approach depends on whether the requirement is to detect a missed schedule, confirm successful processing or identify tenant-wide unavailability.
What are the JMS resource limits for SAP Cloud Integration?
For applicable SAP Integration Suite service plans and existing Cloud Integration Enterprise Edition licences, SAP documents default JMS resources of 30 queues, 9.3 GB of queue capacity and 150 transactions. Self-service maximums are documented as 100 queues, 30 GB and 500 transactions. Actual availability should be verified against the tenant's entitlement, runtime and current SAP documentation.
Why do JMS retries sometimes happen later than the configured interval?
SAP explains in KBA 3569999 that retries and initial processing for non-exclusive JMS queues can be delayed. Processing order can also differ from message arrival order. These conditions do not necessarily indicate a fault. Monitoring should therefore use business delivery expectations with suitable retry headroom rather than assuming precise retry timing.
Does Cloud ALM measure time spent waiting in a JMS queue?
Cloud ALM's high-processing-time monitoring is based on individual message-processing executions. In an asynchronous producer-consumer design, waiting time between executions is not automatically represented as the duration of either processing run. End-to-end measurement requires suitable correlation and timestamps covering the complete business transaction.
Should an SAP CPI monitoring watchdog run on the same tenant?
An internal watchdog can be suitable for expected-arrival or message-volume checks, but it has an important availability limitation. If the monitored tenant or its scheduler stops, the watchdog may stop as well. For critical integrations, use at least one independent monitoring mechanism that can detect the absence of expected signals from outside the tenant.
What is the difference between SAP CPI message monitoring and transaction reconciliation?
SAP CPI message monitoring observes processing executions, statuses, durations and related technical information. Transaction reconciliation compares expected business records with actual outcomes in the source and target applications. Monitoring can show that a message completed successfully, while reconciliation establishes whether the expected business transaction was recorded in the receiving system.
Both are important when the cost of a missing transaction is high.
Start with the interfaces where silent failures matter most
Improving SAP CPI monitoring does not have to begin with a new platform or a large monitoring programme.
Start with the business-critical interfaces where a missing or delayed transaction would cause the greatest operational impact.
For each interface, establish five things:
- What message activity or business outcome is expected?
- Which signals are already covered by SAP Cloud Integration and Cloud ALM?
- Can the current monitoring detect an expected transaction that never arrived?
- Is there visibility into queue waiting time and end-to-end delivery?
- Who receives the alert, and what action should follow?
This review often reveals gaps that are not visible in conventional failure dashboards, particularly around expected arrivals, asynchronous processing and business outcomes.
Tarento's enterprise integration team can help assess SAP Integration Suite monitoring coverage, including Cloud ALM configuration, log-level dependencies, JMS resources, heartbeat and reconciliation design, and operational alert routing.
Request an SAP integration monitoring gap review · Explore iVolve Integration Inspector


