Fault Handler in Oracle Integration Cloud

  

Fault handling in Oracle Integration Cloud (OIC)

Fault handling in Oracle Integration Cloud (OIC) is an essential mechanism for managing errors that occur during integration execution.

It is like fixing a problem when it happens so it doesn't go ignored.

Purpose 

Instead of allowing an integration to fail silently, 

fault handling logic executes recovery actions or notifies the appropriate persons. 

Common techniques include:

1. Email Notifications: Sending email about error codes, messages, and details to business or support teams for rectification.
2. Audit Tables: Dumping error records and instance IDs into custom tables (such as ATP or DBAS) for periodic review and tracking.
3. Generic Error Handlers: Building a single, reusable REST API integration for error handling that can be invoked by multiple other integrations to save time and avoid repetitive tasks.
4. Bulk Record Handling: For high-volume data loads (like FBDI), failed records can be stored in a file and emailed to the support team for correction.

Types of Fault Hanndles in OIC

Scope Level

• Handles errors only for specific nodes placed within a designated "scope" or container.
• It is only responsible for nodes inside its scope; it will not handle errors from outside nodes.

Global Level

• Responsible for the entire integration.
• Acts as a final "catch-all" if no scope-level handler exists or if a scope-level handler fails to catch an error.

Note:

In nested scopes, an error is passed from an inner fault handler to the next higher-level handler. If it remains unhandled after passing through all scopes, it eventually reaches the global level fault handler.

Variable Management: 

Assign vs Global Variable vs Data Stitch

• Assign: Used to create local variables and store values. It is limited to specific data types (string or fault) and is only accessible within the scope where it was created.
• Global Variables: Accessible throughout the entire integration and across multiple scopes. They support multiple data types, including string, boolean, date, time, number, and objects.
• Data Stitch: This specific action is required to assign, append, or remove values from a global variable, providing more flexibility than the standard "assign" action.

===============

FAQ

What is fault handling in OIC and why is it necessary? 

Fault handling is a mechanism used to manage errors that occur during integration execution. 

It is critical because it prevents errors from going unnoticed and allows for recovery logic or notifications to be sent to support teams.

What are some common fault handling techniques used in real-time integrations?

Email Notifications: Sending error codes and messages to business or support teams.

Custom Audit Tables: Dumping error records and instance IDs into tables (like ATP) for periodic tracking.

Generic Error Handlers: Creating a single reusable REST API integration for error handling that can be invoked by multiple other integrations to save time.

Error Files: Storing failed records from bulk data processes into a file and emailing it for rectification.

What is the difference between a Scope Level and a Global Level fault handler?

Scope Level: Only handles errors for the specific nodes contained within that scope.

Global Level: Responsible for the entire integration and acts as the final "catch-all" if no scope-level handler exists or if a scope-level handler fails to catch an error.

How does error propagation work in nested scopes? 

When scopes are nested, an error that is not handled by an inner scope's fault handler is passed up to the next higher-level scope's handler. If it remains unhandled through all layers, it eventually reaches the global level fault handler.

What is the difference between the "Assign" action and using Global Variables with "Data Stitch"?

Assign: 

• Used to create local variables restricted to string or fault data types. 
• These variables are only accessible within the scope where they were created.

Global Variables: 

• Accessible across the entire integration and multiple scopes. They support various data types including string, boolean, date, time, number, and objects.

Data Stitch: 

• A specific action required to assign, append, or remove values from these global variables

======================

Scope

Inside the Scope, add the nodes and then we can handle Scope level faults

Cut and paste the nodes inside Scope

Click on three dots on Scope level so that we can see an option enable Fault Handlers 

The options we get are: Edit, Delete, Fault Handlers, Collapse and Cut

Under Fault Handlers we can see Default Handler

Scope Level Fauld Handler take care of the errors within Scope level nodes. But it cannot handle the errors that occurs out of the Scope level nodes.

Adding the default handler within Scope

Scope inside another scope(nested)

If Scope 1 is getting an error but it unable to handle it then throw the error to Scope 2.

If Scope 2 also not able to handle the error then it will throw to Global Level Fault Hanler.

----------

And so on.

By clicking + symbol inside Fault Handler we can configure sending notification about the errors.

Now, we will how Global Level Fault Handler works.

Any errors that occurs outside of Scope, will be take care of Global Level Fault Handler.

How to add Global Level Fault Handler

Global Fault and Re-Throw Fault

Global Fault Handler on the top with exclamatory symbol

Here, we can implement our logic by click on + symbol

Under Actions: 

(X) Assign

B2B

Data Stitch

Logger

Map

Note

Notification

Stage File

Wait

Decision

File Server

Integration

JavaScript

OCI Function

OCI Object Storage

Process

Publish Event

Robot Flow

============

Assign:

To create local variables and store the values

create a variable and store some in it

Only two datatypes: Either String or Fault

If we assign a variable within Scope then we cannot use it outside of the scope

So, assign can be used only within specific Scope but not cannot used on multiple scopes.

To overcome the above problem, we have Global Level Variable

Global Level can work across the integration and also works within multiple scopes as well.

 Data Type can be:

String, Boolean, Date, Date Time, Object and Number.

In local variable using assign, we can see an option to store the values but not in the case of Global Level variable

To assign values to the Global Variable, we have a Data Stitch

Data Stitch is used to assign/append/Remove the values for the Global Level Variables

Assign: used to just assign the value to the variable

Append: used to add some more data to the existing data

Remove: Remove the existing data assigned to the variable