When you implement the Performance-Traceability policy in API Management:

It enables detailed monitoring of API calls, including latency, performance metrics, and message traces.

This data is available in the API Monitor (Monitor → Integration APIs) within the SAP Integration Suite cockpit.

Other options:

SAP Cloud ALM → General monitoring, not API trace-specific.

Third-party monitoring → Possible but not where SAP policy data is viewed.

SAP Analytics Cloud → For analytics, not direct monitoring of API proxy performance.

Thus, the correct monitoring location is API monitor under Monitor → Integration APIs.

For executing custom logic inside an integration flow:

Groovy script (via Script step) is the supported mechanism in SAP Cloud Integration.

External REST APIs can enrich data but are not for embedded custom logic execution.

Mule components are not part of SAP CPI.

Java connectors are not directly supported in SAP CPI runtime.

Thus, the best suited for executing custom logic is Groovy script.

SAP Event Mesh supports two key asynchronous messaging patterns:

Publish/Subscribe → Producers publish an event once, multiple subscribers consume independently.

Point-to-Point (Queue-based) → Messages sent from one producer to a single consumer via a queue.

Other options are incorrect:

Request/Reply → Synchronous pattern, not the focus of Event Mesh.

Multicast messaging → Not explicitly supported; handled through Pub-Sub.

Thus, Event Mesh supports Publish/Subscribe and Point-to-Point messaging patterns.

In SAP Cloud Integration (part of Integration Suite), error handling within integration flows is implemented using:

Exception Subprocesses → Dedicated subprocesses triggered by an Error Start Event to handle unexpected runtime exceptions.

These allow logging, error notifications, or compensating logic.

Other options:

Try-Catch subprocesses → Not a modeling construct in SAP CPI.

Exception handler integration flow elements → Not a standard artifact; error handling is done with exception subprocesses.

Status code checks → Useful for response validation but not full error handling.

Thus, the correct answer is Exception-handling subprocesses.

The Clean Core Approach emphasizes keeping the SAP digital core free from modifications and isolating custom code:

Separation of Concerns → Custom logic/extensions are isolated from SAP standard functionality, ensuring upgrades and innovations are not disrupted.

Other principles (modular design, coding standards, reusability) are good practices but not specifically tied to Clean Core’s goal of isolating custom code.

Thus, the correct principle is Maintain separation of concerns.

In Event-Driven Architecture, resilience is ensured by:

Loose coupling → Services do not depend on each other’s runtime availability. A failure in one service does not directly impact others.

This design minimizes cascading failures that can occur in tightly coupled systems.

Asynchronous communication and error handling help further, but loose coupling is the fundamental characteristic that limits failure propagation.

Incorrect options:

A → Robust error handling is important but not the main architectural limiter of cascading failures.

C → Centralized logging helps with troubleshooting, not failure prevention.

D → Asynchronous buffering mitigates impact but loose coupling fundamentally prevents direct propagation.

In SAP Cloud Integration, an Exception Subprocess is used to catch and handle errors during message processing.

It is always triggered by an Error Start Event.

When an error occurs in the main process (e.g., mapping error, adapter error), control is handed to the Exception Subprocess.

Other start events (Message, Escalation, Normal Start) are not valid in an Exception Subprocess.

Hence, the correct event to start the Exception Subprocess is the Error Start Event.