Review the following service limits for Oracle Integration 3
resources. A service limit is the quota or allowance set on a resource. You cannot change
the service limits configured for your tenancy.
Note
The service limits described below are enforced.
Oracle Cloud
Infrastructure Console Service Limits
🔗
For more Oracle Cloud
Infrastructure
Console service limits, see Service Limits in the OCI
documentation.
Resource
Service Limit
Integration service instances
200 service instances per region
Note: This value is the number of service instances you provision per region, and not the number of integration instances (for example, application and schedule) that you activate and monitor under the Observability tab in Oracle Integration.
The ability to create service instances outside your home region depends on several factors. See Restrictions.
Private endpoints
1 private endpoint per service instance
1 subnet per private endpoint
Custom endpoints
1 custom endpoint per service instance
Oracle Integration internal diagnostic logs
30 days - retained in Oracle Cloud
Infrastructure Logging for debugging use
A minimum of 8 GB memory with 4 GB of heap size dedicated to the on-premise agent's Java Virtual Machine (JVM). To include any other processes on the host besides the agent, increase the physical memory to a value greater than 8 GB.
Connectivity agent message payloads
10 MB through the use of compression
All connectivity-agent-enabled adapters
50 MB as request
50 MB as response
SOAP and REST adapters configured with connectivity agent
50 MB (structured XML/JSON document) as response from SOAP/REST endpoints
1 GB for attachments as part of a response from SOAP/REST endpoints
Structured payloads (JSON, XML) for connectivity-agent-based adapters
SOAP and REST: 50 MB
File and FTP invoke responses: 50 MB
Other protocols: 10 MB (for example, database, JMS, MQ, Kafka, and others)
Structured payloads for trigger connections and responses from invoke connections
Cloud endpoints: 100 MB (not using the connectivity agent)
Private endpoints: 100 MB
Binary (unstructured) payloads (for example, attachments, MTOM) for trigger connections and responses from invoke connections
1 GB
Private endpoint support
Connecting to private endpoints is supported in a growing list of adapters.
10 MB with schema transformation for all the outbound operations
AS2 Adapter
100 MB
Database adapters
Oracle Autonomous Data Warehouse
Adapter
Oracle Autonomous Transaction Processing
Adapter
Oracle Database Adapter
Oracle Database Cloud Service
Adapter
IBM DB2 Adapter
Microsoft SQL Server
Adapter
MySQL Adapter
Netezza Adapter
PostgreSQL Adapter
SAP ASE (Sybase) Adapter
Snowflake Adapter
For trigger configurations
Polling operations:
50 MB with schema transformation for agent-based endpoints
100 MB with schema transformation through private endpoints
For invoke configurations
Stored Procedure, Operation on Table, and Run PureSQL Statement operations:
10 MB with schema transformation for all the outbound operations
Database Select operations:
100 MB for public internet-based endpoints
100 MB for private endpoints
50 MB for agent-based endpoints
File Adapter (available only with the connectivity agent)
Read File operations:
1 GB when used without a schema
50 MB when using a schema for transformation
50 MB for a read operation with structured payload
Polling with a connectivity agent:
50 MB
Download File operations:
1 GB
Note: The size of CSV files increases when translated into a message. Therefore, the file size must be less than 50 MB, so that the after-translation message size does not exceed 50 MB.
FTP Adapter
For invoke configurations
Read File operations:
1 GB when used without a schema (when used with or without a connectivity agent)
100 MB for cloud-based endpoints when using a schema for transformation
50 MB for agent-based endpoints when using a schema for transformation
100 MB for public internet-based endpoints
100 MB for private endpoints
Download File operations:
1 GB (when used with or without a connectivity agent)
1 GB for messages with attachments (for example, multipart/form-data)
100 MB for incoming structured message payloads (any content-type header containing JSON, XML, HTML, YAML, or YML)
Note: If the string length for fields in a JSON payload exceeds 20 MB, you receive a translation failure error. See ORABPEL-15235 Translation Failure Occurrence in Using the REST Adapter
with Oracle Integration 3.
1 GB for incoming content as raw bytes (application/octet-stream as content type)
100 KB for JSON sample files used to specify the response payload format in the Adapter Endpoint Configuration Wizard
For invoke configurations
3 MB for XML documents used for data definition generation
For example, a parent integration (schedule integration) invokes a child integration (application integration), which in turn recursively invokes the parent integration.
Integration entry points along the request execution path are counted towards the limit. When 16 is exceeded, it results in an error.
String size limit
10,000 characters
This limit applies to all variables of type string, including global variables, and all functions, including concat functions used inside an assign, stitch, or mapper.
Parallel action concurrency
Parallel action branches independent of the integration type (synchronous, asynchronous, and so on) count towards the concurrency limits on synchronous requests.
For example. a parallel action with three branches needs two extra concurrency slots for the duration of the parallel action; one branch is counted towards the original flow already obtained.
Triggers - concurrent requests
Synchronous: 100 concurrent requests per message pack, up to a maximum of 600
Increasing the concurrent request limit with additional message packs is useful if you have high concurrency requirements in respect to synchronous integration executions.
Parallel action branches independent of the integration type (synchronous, asynchronous, and so on) count towards the concurrency limits on synchronous requests.
For example. a parallel action with three branches needs two extra concurrency slots for the duration of the parallel action; one branch is counted towards the original flow already obtained.
Asynchronous: No limit; the following number of requests can execute at a time, the rest are queued; 50 requests per message pack, up to a maximum of 300
Asynchronous concurrent execution includes scheduled + triggered + connectivity agent.
Event integrations (integrations that can subscribe to events)
50 integrations per service instance
Tracking events (per single integration instance/request execution)
Non-error events: 20,000
Error events: 30,000 (extra 10,000 if events are associated with errors)
Maximum errors recorded: 2,000
After those limits are reached, events are no longer recorded in the activity stream, but they continue to be processed, and the integration instance overall state is calculated. This ensures that the integration instance state is updated in all scenarios.
Integration flow duration
Synchronous: 5 minutes
After that, an HTTP 502 occurs.
Asynchronous: 6 hours
After that, the integration instance is marked as aborted due to deadline timeout.
Scheduled: 6 hours
After that, the integration instance is marked as aborted due to deadline timeout.
Stage file action (in integrations) limits
Read Entire File operations: 100 MB
For files greater than 100 MB, use the Read File in Segments operation.
Encrypt File operations: 1 GB
Decrypt File operations: 1 GB
Synchronous integration message timeout
300 seconds
After that, the integration returns a timeout error.
Oracle Integration Messaging message size
10 MB
Encode and decode file attachment content (mapper)
10 MB for encodeReferenceToBase64(String reference) and decodeBase64ToReference(String base64Content) functions
Lookup column length
1,024 characters
Notification action limits
Default method: 2 MB
Customer tenancy method: 2 MB default
This value can be increased until the maximum value supported by the Oracle Cloud
Infrastructure Email Delivery Service is reached.
Both the email body and attachment are considered in calculating the total size.
Note: After 24 hours, Debug (Not recommended) is automatically reset to Production. See Activate an Integration in Using Integrations
in Oracle Integration 3.
Time window for recovering a failed integration instance that's recoverable
The integration instance is recoverable until one of the following occurs:
It's aborted. This can happen due to integration deactivation.
It's successfully recovered or the recovery leads to a nonrecoverable error.
It's beyond its associated retention time, which is 32 days (default) for Standard and Enterprise editions, 184 days for Healthcare edition.
Activity stream - displayable rows
5,000 rows (when expanding the tree)
Activity stream - total size (REST response)
No limit
Integration instances returned per monitoring request
50 instances
Resubmissions allowed per integration instance ID
10 resubmissions
Schedule parameter values character limit
256 characters
Schedule parameters per integration
5 parameters
Integration property values character limit
256 characters
Integrations and connections character limits
Name: 50 characters
Package name: 50 characters
Version: 10 characters
Description: 1,024 characters
Maximum offset supported (Instances and Errors API)
500
Maximum limit supported (Instances and Errors API)
50
Factory API timeout
2 minutes
Payloads for publishing and subscribing to events in integrations
The same limit supported by the inbound (trigger) adapter.
Assigning a robot instance to an environment timeout
Varies, depending upon the environments:
If the environment pool contains no
environments:
0 seconds, and then the status of the robot instance changes to Failed
If the robot agent on the environment doesn't
accept the request:
30 seconds, and then Oracle Integration attempts to assign the robot instance to a different environment
If all environments in the environment pool have
a status of Unavailable:
240 seconds, and then the status of the robot instance changes to Failed
If at least one environment in the environment
pool has a status of Available:
No limit
File download timeout
180 seconds by default but the robot builder can specify a different value while creating a robot
File download size
50 MB
Polling frequency (frequency at which the robot agent polls Oracle Integration for work)
15 seconds
Maximum time that Oracle Integration waits for the robot agent to poll for work
before changing its environment's status to Unavailable
35 seconds
Environments in an environment pool
100 environments
Robot character limits
Name: 50 characters
Description: 1,024 characters
Keywords: 1,024 characters
Environment pool character limits
Name: 50 characters
Description: 1,024 characters
Keywords: 1,024 characters
Robot connection type character limits
Name: 50 characters
Description: 1,024 characters
Keywords: 1,024 characters
Robot connection character limits
Name: 50 characters
Description: 1,024 characters
Keywords: 1,024 characters
Component: File Server 🔗
Resource
Service Limit
Storage
500 GB
Concurrent connections
50 connections per service instance
Component: Process
Automation 🔗
For Process
Automation service limits,
see Service Limits in Administering Oracle
Cloud Infrastructure Process Automation.
Message Pack Usage and Synchronous
Requests 🔗
The following table describes the request limits based on the number of
message packs.
Message Packs Assigned
Synchronous Request Limit
6
600
5
500
4
400
3
300
2
200
1
100
When to Increase Message Packs
Your message packs must equate with the number of messages you consume per
hour. Ensure you know your hourly throughput. An increase in message packs is also
beneficial if you want quicker processing of synchronous requests. The following
examples describe when you need higher concurrency.
Examples
Message Packs
How quickly can a customer consume message packs
with high synchronous concurrency?
Assume a customer has 2 message packs assigned (10K
messages per hour). Each synchronous request takes 5 seconds to
complete. Therefore:
A concurrency of 1 can execute 12 requests
per minute.
A concurrency of 200 can execute 2400
requests per minute.
A 10-minute burst with 200 concurrent
synchronous requests = 24000 messages, which provides an
overage of 14K messages (24K - 10K) for
that hour.
When is the 600 synchronous requests limit
reached?
The 600 concurrent synchronous request limit is
reached when the customer applies 6 message packs to the Oracle Integration instance. Consider
the following example in which each synchronous request takes 10
seconds to execute:
A concurrency of 1 can execute 6 requests
per minute.
A concurrency of 600 can execute 3600
requests per minute.
A 10-minute burst with 600 concurrent
synchronous requests equals 36000 messages, which
results in an overage of 6K messages (36K -
30K) for that hour.
Therefore, a customer with a high message throughput per hour already has a
larger number of message packs assigned to the service instance. The need for a customer
to increase the number of message packs to gain more synchronous request processing
concurrency is as follows:
Less than 5K messages per hour
A burst of synchronous requests that exceed 100 messages