Wednesday, November 18, 2026

OIC – Code Review Points || Best Practices

 1. Real-Time & Synchronous Services

  1. Retry Mechanism: Retry is not recommended for synchronous or real-time services. If required, ensure it aligns with the calling system's timeout and SLA requirements.

  2. Wait Activities: Wait activities are not recommended in synchronous integrations, as they can unnecessarily increase response times and impact the overall user experience.

  3. Reply Activity & Global Fault Handling: Add Reply activities in both the Main Flow and Global Fault Handler, and remove the Rethrow activity from the Global Fault Handler as per Pen Test guidelines.

  4. Large-Volume Processing: Processing large volumes of data within loops presents scalability risks. The integration may fail or experience performance degradation. Consider optimizing the design to handle bulk data efficiently.

  5. OIC Runtime Limits: Respect OIC runtime limits and avoid integrations running longer than one hour. For long-running or high-volume processing, consider asynchronous patterns, batching, or chunking to improve reliability and scalability.

  6. Centralized Datadog Logging: For synchronous integrations (ABC), Datadog logging should be implemented only in Service A. Child services should return error details to the parent service for centralized monitoring and incident creation, avoiding duplicate alerts.

2. Batch Services

  1. Scheduler Integration: The scheduler integration should not contain any business logic. Its responsibility should be limited to triggering the process. Move all business processing, validations, transformations, and downstream calls to the Main integration or appropriate child services.

  2. Integration Naming Convention: Integration naming conventions are not being followed. Use the standard hierarchy: SCH → Main → Child. Ensure names clearly reflect the business context.

  3. Empty File / No File Handling: For empty file or no-file scenarios, consider throwing a custom fault and generating a Warning or Error alert in Datadog based on business requirements and interface criticality.

3. General Code Review Points

  1. Avoid Hardcoding: Avoid hardcoding configuration values. Maintain retry settings, endpoint configurations, and other business parameters in Lookups, Configuration Tables, or OCI Vault for easier maintenance and flexibility.

  2. Integration Description: The integration description is missing. Provide a meaningful description explaining the integration's purpose and functionality.

  3. Connection and Lookup Descriptions: Connection and Lookup descriptions are missing. Add meaningful descriptions to improve maintainability and understanding.

  4. Runtime Error Details: Capture and return actual runtime error details instead of using hardcoded or lookup-based error messages. Avoid generic names such as Stitch2, FOREach1, etc., in error descriptions.

  5. Activity Naming Standards: Activity names are not following the naming standards in the OIC integration. Use meaningful and standardized names for all activities.

  6. Retry for Asynchronous Integrations: Consider implementing retry mechanisms for API calls to edge systems in asynchronous or one-way integrations to handle transient failures and intermittent connectivity issues.

  7. Centralized Datadog Logging: Multiple Datadog calls were identified. Datadog logging should not be invoked from the Main Flow. Instead, throw the fault to the Global Fault Handler and perform the Datadog call there. Datadog should be called only once from the Global Fault Handler.

  8. Business Tracking Parameters: Tracking parameters are missing. Configure meaningful business tracking fields to improve transaction traceability, monitoring, and troubleshooting across the integration lifecycle.

  9. Separate Retry Blocks: Multiple invoke activities are configured under one retry block. Each invoke activity should be configured with a separate retry block instead of sharing a common retry mechanism.

  10. Code Modularization: Code readability needs improvement. Split complex logic into multiple child integrations for better maintainability and easier review. Consider:

    • Breaking complex logic into smaller, reusable child integrations.
    • Calling a child integration for each file from the For Each activity.
    • Creating separate child services for standard error handling, data logging, and utility calls.
    • Using Parent-Child integration patterns wherever appropriate.
  11. Remove Unused Components: Remove unused variables and activities to improve readability and maintainability.

  12. Meaningful Integration Names: Integration names should be meaningful and clearly indicate the source, target, or business context.

  13. Datadog Field Mapping: Ensure all required fields are mapped and sent in the Datadog format.

  14. Date Format Validation: VarDateFormat is generally expected to be in HKT (Hong Kong Time). However, it does not appear to be in HKT currently. Verify the date format and timezone.

  15. Avoid Unnecessary Activities and Deep Nesting: Avoid Scope and Catch activities when there is no specific requirement for fault handling. Avoid deep nesting of Scope, Switch, For-Each, and While activities. Simplify the design to improve readability and maintenance.

  16. Avoid Loop-Invoke Anti-Patterns: Avoid unnecessary invoke calls inside loops. Consider moving invoke calls outside the loop wherever possible, or process records in batches/chunks to improve performance, scalability, and maintainability.

  17. Secure Credential Management: Use OCI Vault for storing secrets such as keys and credentials.

  18. Standardized Directory and Stage Names: Use meaningful and standardized names for directories, stages, and other artifacts. Avoid generic names such as mystage or tempfolder. Instead, use descriptive names such as /stage/zip, /stage/unzip, or /stage/archive.

  19. Mandatory Input Validation: Validate mandatory input fields at the beginning of the integration and fail fast if required data is missing.

  20. Lookup-Driven Routing: Use lookup-driven routing instead of hardcoded IF/Switch conditions wherever feasible.

  21. Optimize Child Integration Payloads: Avoid unnecessarily large payloads between child integrations. Pass only the required data elements.

  22. Reusable Common Services: Use Child Integrations/Common Services for reusable functionality such as Datadog logging, email notifications, audit logging, and utility functions.


Objective: Ensure OIC integrations follow standard design principles, improve performance and scalability, maintain consistency, simplify troubleshooting, and support long-term maintainability.

Sunday, November 15, 2026

OIC - Disaster Recovery (DR) Validation: End-to-End Test Scenarios

 1. Introduction

  • Disaster Recovery (DR) is an important aspect of any enterprise integration platform. Organizations rely on Oracle Integration Cloud (OIC) to exchange business-critical data between Oracle Fusion Applications, on-premise applications, OCI services, and external systems.
  • In the event of a regional outage or infrastructure failure, the DR environment must be capable of taking over integration workloads with minimal business disruption.
  • However, configuring a secondary OIC instance is not sufficient. We must validate connectivity, authentication, integrations, scheduling, messaging, and external application access after failover.

This blog covers nine important test scenarios to validate OIC functionality following a disaster recovery exercise.

2. Business Use Case

Consider an organization running its integrations in a primary OCI region, connecting to:

  • Oracle Fusion ERP.
  • On-premise applications through OIC Connectivity Agent.
  • OCI Functions and Vault.
  • OCI Object Storage.
  • External applications consuming OIC REST services.
  • Kafka messaging platforms.

The organization maintains a secondary OIC environment in another region.

During a disaster recovery exercise, the secondary environment takes over the integration workloads.

The objective is to ensure that all critical integration capabilities continue functioning as expected after failover.

3. DR Validation Architecture

Primary Region:

  • OIC Primary Instance
  • Oracle Fusion ERP
  • OCI Services
  • On-premise Connectivity Agent
  • External Applications
  • Kafka Platform

Secondary Region:

  • OIC Secondary Instance
  • Replicated or configured integration artifacts
  • Required connections and credentials
  • DR connectivity and service configurations

After failover, the secondary OIC instance becomes responsible for processing integration requests.

4. Disaster Recovery Test Scenarios

TEST01: OIC to ERP Connectivity

Objective: Verify connectivity between OIC and Oracle ERP.

Test Steps:

  1. Access the OIC DR instance.
  2. Navigate to Connections.
  3. Validate the ERP connection.
  4. Execute the connection test.
  5. Validate authentication and connectivity using the configured consent user.

Expected Result: OIC should successfully authenticate and establish connectivity with Oracle ERP.

TEST02: OIC to On-Premise Shared Folder Connectivity

Objective: Verify connectivity between OIC and on-premise applications through the Connectivity Agent.

Test Steps:

  1. Verify the Connectivity Agent status.
  2. Execute an integration using the configured agent.
  3. Write a sample file to the on-premise shared folder.
  4. Verify whether the file is successfully created.

Expected Result: OIC should successfully communicate with the on-premise environment and write the file to the shared folder.

TEST03: OIC to On-Premise SOAP/API Connectivity

Objective: Verify SOAP/API connectivity between OIC and on-premise applications through the Connectivity Agent.

Test Steps:

  1. Validate the agent connectivity.
  2. Execute an integration invoking the on-premise SOAP/API service.
  3. Validate the request and response.
  4. Verify that the target application processes the request successfully.

Expected Result: OIC should successfully invoke the on-premise SOAP/API service and receive the expected response.

TEST04: OIC to OCI Function Service Connectivity

Objective: Verify connectivity between OIC and OCI Functions.

Test Steps:

  1. Validate the OCI Function connection configuration.
  2. Execute an OIC integration invoking the configured Function Service.
  3. Validate the request payload.
  4. Verify the response returned by the Function.

Expected Result: OIC should successfully invoke the OCI Function and receive the expected response.

TEST05: OIC to OCI Vault Connectivity

Objective: Verify connectivity between OIC and OCI Vault.

Test Steps:

  1. Validate the Vault connection configuration.
  2. Verify the required authentication and IAM permissions.
  3. Execute an integration that retrieves the required secret from Vault.
  4. Validate the response.

Expected Result: OIC should successfully access the configured Vault resource based on the assigned permissions.

TEST06: OIC to OCI Object Storage Connectivity

Objective: Verify connectivity between OIC and OCI Object Storage.

Test Steps:

  1. Validate the Object Storage connection.
  2. Execute an integration that uploads a sample file to the configured bucket.
  3. Verify that the file is available in the target bucket.
  4. Validate download/access functionality if applicable.

Expected Result: OIC should successfully upload and access files in the configured Object Storage bucket.

TEST07: External Application to OIC Connectivity

Objective: Verify that external systems can continue invoking OIC services after DR failover.

Test Steps:

  1. Identify the production OIC REST service URL.
  2. Perform the DR failover.
  3. Verify the production endpoint and DNS/routing configuration.
  4. Invoke the OIC REST service from the external application.
  5. Validate the response.

Expected Result: External applications should successfully invoke OIC services using the unchanged production URL.

Important: This validation assumes a common custom endpoint or equivalent routing strategy is configured. The endpoint and DNS handling depend on the DR approach being used.

TEST08: Next/Queue Execution and Scheduling

Objective: Verify that asynchronous processing and scheduled integrations function correctly after DR failover.

Test Steps:

  1. Execute a sample integration using the configured Next/Queue processing mechanism.
  2. Verify that the message is successfully processed.
  3. Validate the scheduled integration configuration.
  4. Verify schedule activation and execution.
  5. Check the integration monitoring logs for successful execution.

Expected Result: Queue-based processing and scheduled integrations should operate as expected in the DR environment.

Note: Validate pending and in-flight transactions separately. Some asynchronous transactions may require manual retry after failover.

TEST09: OIC to Kafka Connectivity

Objective: Verify Kafka connectivity through the Connectivity Agent.

Test Steps:

  1. Validate the Kafka connection configuration.
  2. Verify agent connectivity.
  3. Execute a Publish operation from OIC.
  4. Verify that the message is available in the target Kafka topic.
  5. Execute a Subscribe operation.
  6. Validate that OIC successfully consumes the published message.

Expected Result: OIC should successfully publish and subscribe to Kafka events after DR failover.

5. Overall DR Validation Checklist

After executing all nine test cases, validate the following:

  • ERP connectivity is working.
  • On-premise shared folder connectivity is working.
  • SOAP/API connectivity is working.
  • OCI Function invocation is successful.
  • OCI Vault access is successful.
  • Object Storage operations are successful.
  • External applications can invoke OIC services.
  • Queue processing and schedules are functioning.
  • Kafka Publish/Subscribe operations are successful.

Capture the execution status, test evidence, and any issues identified during validation.

6. Conclusion

Disaster Recovery validation is not just about making the secondary OIC instance available. It is about ensuring that the complete integration ecosystem continues to operate successfully after failover.

Executing these nine test scenarios provides a practical approach to validating connectivity, authentication, OCI services, scheduling, messaging, and external application access.

Regular DR simulations and end-to-end testing help organizations improve recovery readiness, minimize business disruption, and maintain integration service continuity.

The ultimate goal is simple: When the primary region becomes unavailable, the business integrations should continue operating through the secondary region with minimum disruption.

7. Oracle Documentation References

  1. Configuring Oracle-Managed DR for OIC 3: https://docs.oracle.com/en/cloud/paas/application-integration/oracle-disaster-recovery/introduction-oracle-managed-disaster-recovery.html

  2. Configuring Customer-Managed DR for OIC 3: https://docs.oracle.com/en/cloud/paas/application-integration/disaster-recovery/disaster-recovery-integrations.html

  3. OIC Connectivity Agent Responsibilities During Failover: https://docs.oracle.com/en/cloud/paas/application-integration/oracle-disaster-recovery/understand-connectivity-agent-responsibilities-failover.html

  4. OIC Failover Process: https://docs.oracle.com/en/cloud/paas/application-integration/oracle-disaster-recovery/fail-secondary-instance.html

Tuesday, November 10, 2026

Oracle Integration Cloud (OIC): Understanding Start vs Resume and Stop vs Pause for Scheduled Integrations

 Introduction

In Oracle Integration Cloud (OIC), we can control scheduled integration executions using four important operations: Start, Stop, Pause, and Resume.

Although these operations may look similar, they behave differently, especially when managing scheduled integration executions.

Let's understand the differences with simple real-time examples.

1. Start vs Resume

Start

  • Activates a schedule that is currently stopped.
  • Enables the integration to execute according to its configured schedule.
  • Once started, OIC begins generating scheduled execution instances.

Example:

Consider an integration that synchronizes employee information from Oracle HCM to an external application every day at 10 AM.

If the schedule is stopped, it will not execute.

When we perform the Start operation, the schedule becomes active again, and the integration will execute according to its configured schedule.

Resume

  • Reactivates a schedule that was previously paused.
  • Continues the existing schedule from its paused state.
  • Allows paused scheduled executions to continue.

Example:

Consider the same employee synchronization integration scheduled to run every day at 10 AM.

Suppose we pause the schedule temporarily due to maintenance. The upcoming scheduled execution is held.

Once maintenance is completed, we perform the Resume operation.

OIC resumes the paused schedule, and the pending scheduled execution can proceed.

Key Difference:

Start is used to activate a stopped schedule, whereas Resume is used to continue a previously paused schedule.

2. Stop vs Pause

Stop

  • Completely stops the active schedule.
  • Cancels all scheduled runs, including pending future executions.
  • To execute the integration again on its configured schedule, we need to Start it.

Example:

Consider an integration that sends daily sales reports to the finance team at 9 AM.

Suppose the integration is no longer required because the business process has been discontinued.

We perform the Stop operation.

The schedule is stopped, and all scheduled runs are cancelled.

If the business requires the integration again in the future, we can Start the schedule.

Pause

  • Temporarily suspends scheduled executions.
  • Does not permanently stop the schedule.
  • Upcoming scheduled executions are held until the schedule is resumed.
  • Once resumed, pending executions can proceed.

Example:

Consider an integration scheduled to run every hour:

  • 2 PM
  • 3 PM
  • 4 PM
  • 5 PM

Suppose the 3 PM execution completes successfully and we pause the schedule.

The 4 PM execution will be paused.

If we resume the schedule at 4:30 PM, the pending 4 PM execution will be triggered.

This is particularly useful during temporary maintenance, troubleshooting, or planned downtime.


Key Difference:

Stop cancels scheduled runs, whereas Pause temporarily suspends them so they can continue after Resume.

3. Quick Comparison

Start: Activates a stopped schedule.

Resume: Continues a previously paused schedule.

Stop: Stops the schedule and cancels scheduled runs.

Pause: Temporarily suspends scheduled executions without cancelling the pending execution.

4. Real-Time Use Cases

  • Start: Enable a newly configured or previously stopped integration schedule.
  • Resume: Continue an integration after planned maintenance.
  • Stop: Permanently discontinue an integration schedule that is no longer required.
  • Pause: Temporarily prevent scheduled executions during troubleshooting or maintenance.

5. OIC Factory API Endpoints

We can automate these operations using Oracle Integration Factory REST APIs.

For an integration in the standard Integrations area, the endpoints are:

Start Schedule POST /ic/api/integration/v1/integrations/{id}/schedule/start

Stop Schedule POST /ic/api/integration/v1/integrations/{id}/schedule/stop

Pause Schedule POST /ic/api/integration/v1/integrations/{id}/schedule/pause

Resume Schedule POST /ic/api/integration/v1/integrations/{id}/schedule/resume

Here, {id} represents the integration composite identifier containing the integration code and version.

Conclusion

Understanding the difference between these four operations is important when managing OIC scheduled integrations.

In simple terms:

  • Start = Activate
  • Resume = Continue
  • Stop = Cancel and deactivate
  • Pause = Temporarily hold

Choosing the correct operation helps manage scheduled integrations effectively and avoids unnecessary execution interruptions.

Oracle Documentation

  1. Oracle Integration 3 – Start and Pause an Integration Schedule: https://docs.oracle.com/en/cloud/paas/application-integration/integrations-user/start-pause-integration-schedule.html
  2. Oracle Integration 3 – Scheduled Integrations REST Endpoints: https://docs.oracle.com/en/cloud/paas/application-integration/rest-api/api-integrations-integrations-scheduled-integrations.html




Monday, November 2, 2026

OIC - Common Service - Streamlining OIC Schedule Management Through REST API Automation

Introduction

In Oracle Integration Cloud (OIC), managing scheduled integrations involves operations such as Stop, Start, Pause, Resume, Add Schedule, and Update Schedule. Performing these operations manually across multiple integrations can be time-consuming.

To simplify this process, we can develop an automated Scheduling Management Service using OIC Factory REST APIs. The solution follows a lookup-driven approach to identify the integrations, execute the required scheduling operations, and generate a consolidated execution report.

Solution Approach

1. Lookup Configuration

Maintain all required details in an OIC lookup, including:

  • Project name
  • Integration identifier
  • Schedule name
  • Operation type (Stop/Start/Pause/Resume/Add/Update)
  • Required schedule configuration for Add or Update operations.

2. Main Integration – Scheduling Service

  • Fetch all configuration records from the lookup.
  • Read the project, integration, schedule, and operation details.
  • Pass the required configuration details to the Child Integration.
  • Invoke the Child Integration to process the scheduling operations.

3. Child Integration – Schedule Operations

  • Receive configuration details from the Main Integration.
  • For each record, call the OIC Factory API to retrieve the existing schedule details.
  • Append the retrieved schedule information to a file for processing.
  • Iterate through each schedule entry.
  • Use a Switch action to identify the requested operation.
  • Based on the operation type, invoke the corresponding OIC Factory REST API.

Supported Operations:

  • Stop: Stop an active schedule.
  • Start: Start a stopped schedule.
  • Pause: Temporarily pause schedule execution.
  • Resume: Resume a paused schedule.
  • Add Schedule: Create a new schedule.
  • Update Schedule: Modify an existing schedule.
Stop Schedule:





Resume Schedule:



Pause Schedule:



Start Schedule:






Get schedule info:





ADD Schedule:






Update Schedule:







4. Consolidated Execution Report

After processing all records:

  • Capture the API response for each operation.
  • Maintain success and failure status for every record.
  • Capture error details wherever an operation fails.
  • Generate a consolidated execution report.
  • Send the report through email to the configured recipients.

Benefits

  • Automates bulk scheduling operations across multiple OIC integrations.
  • Eliminates repetitive manual schedule management.
  • Lookup-driven configuration makes the solution reusable and easy to maintain.
  • Supports multiple scheduling operations through a single service.
  • Provides centralized execution tracking and failure details.
  • Improves operational efficiency and reduces manual errors.

Conclusion

By leveraging OIC Factory REST APIs and lookup-driven configurations, we can build a reusable Scheduling Management Service that automates multiple scheduling operations from a single integration. This approach simplifies OIC operational management and provides a consolidated view of all scheduling activities through email reporting.


Reference:

https://docs.oracle.com/en/cloud/paas/integration-cloud/rest-api/op-ic-api-integration-v1-integrations-id-schedule-stop-post.html



Friday, October 30, 2026

OIC - Automated OIC Project Export and Backup Using Factory APIs

1. Introduction

To simplify OIC project backup, we developed a reusable integration solution using OIC Factory APIs to export projects as CAR files and save them to the OIC embedded SFTP server. The exported files can then be manually downloaded and uploaded to SharePoint or any other backup location.

2. Solution Overview

The solution consists of two integrations: Main and Child.

Lookup Configuration

An OIC lookup maintains the following project details:

  • Project Code
  • Project Type (Developed / XBA)
  • Version (for Accelerator projects)

3. Integration Flow

Main Integration:

  1. Fetch all project details from the configured lookup.
  2. Iterate through the lookup records.
  3. Pass project code, project type, and version one by one to the child integration.
  4. Invoke the child integration for each project.
Get Export lookup data:
GET /ic/api/integration/v1/projects/{projectId}/lookups/{name}


Trigger:


Run from Lookup for all projects:










Adhoc projects run:








Child Integration:

  1. Receive project details from the main integration.
  2. Prepare the export request based on the project type and version.
  3. Invoke the OIC Factory API to export the respective project.
  4. Retrieve the generated CAR file.
  5. Save the CAR file to the configured OIC SFTP directory.
  6. Return the export status to the main integration.
API used: https://<OIC-HOST>/ic/api/integration/v1/projects/{id}/archive?integrationInstance=<service-instance-name>

Request payload:
{
  "code": "TEST_PROJECT",
  "type": "DEVELOPED",
  "label": "01.00.0000"
}












4. Backup Process

Once all projects are exported successfully, the CAR files are available in the OIC SFTP directory. These files can be manually downloaded and uploaded to SharePoint, OCI Object Storage, or any other enterprise backup location.

Oracle Documentation:

https://docs.oracle.com/en/cloud/paas/application-integration/rest-api/op-ic-api-integration-v1-projects-id-archive-post.html?utm_source=chatgpt.com

https://docs.oracle.com/en/cloud/paas/application-integration/rest-api/op-ic-api-integration-v1-lookups-name-get.html?source=%3Aow%3Alp%3Acpo%3A%3A%3A%3ARC_CORP250721P00028%3ADMO400412486

5. Benefits

  • Automates project export using OIC Factory APIs.
  • Centralizes project configuration through lookups.
  • Supports multiple project types.
  • Reuses a common child integration for all projects.
  • Reduces manual effort in project backup.
  • Provides a centralized location for exported CAR files.

6. Conclusion

This solution provides a reusable and configurable approach to exporting multiple OIC projects and consolidating their CAR files in SFTP. It simplifies project backup activities and makes the exported archives available for storage in external backup locations.

Featured Post

OIC – Code Review Points || Best Practices

 1. Real-Time & Synchronous Services Retry Mechanism: Retry is not recommended for synchronous or real-time services. If required, e...