Celigo’s error management automates the detection, resolution, and prevention of integration errors. Key features include automatic resolution of duplicate errors and retries for temporary issues, minimizing the need for manual intervention. Powered by AI and machine learning, Celigo enhances error handling, making the process faster and more efficient.

We recommend watching our introduction to error management, which focuses on where in the platform you can find error notifications.

Here, we’ll discuss how to identify where errors occur, understand common causes, and resolve them.

Identifying the source of errors

The first and most crucial step in managing errors is identifying where they occur. This initial step dictates the entire troubleshooting process, helping you focus your efforts where they will be most effective.

Internal vs. external errors

Errors within the Celigo platform can generally be categorized into two types: internal and external.

Understanding the difference between these two is key to efficient error management.

Internal errors

These occur within the Celigo platform itself and are typically related to issues like misconfigured flows, script errors, or problems with integration settings.

For example, a script error in a pre-save page hook would be classified as an internal error. Internal errors are often related to the logic or settings within Celigo, making them easier to diagnose and resolve directly within the platform.

Examples:

• Script errors: Issues in custom scripts or business logic within the flow.
• Mapping issues: Problems related to how data is mapped between systems.
• Configuration errors: Misconfigurations in integration settings, such as incorrect field names or missing required fields.

External errors

These originate outside the Celigo platform, typically within your source or destination applications. External errors can result from issues like API failures, data format mismatches, or connectivity problems with third-party systems like Shopify, Salesforce, or NetSuite.

For instance, if Shopify returns an error due to a malformed request or an API timeout, it would be classified as an external error.

Identifying these errors requires understanding how your external systems interact with Celigo and may involve checking logs or API responses from those systems.

Examples:

• API failures: Errors due to API request issues, such as authentication failures or rate limits.
• Data mismatches: Errors arising from data format differences between systems, like a phone number format that doesn’t match the destination system’s requirements.
• Connectivity issues: Problems with connecting to external systems due to network issues or expired credentials.

Tailoring your troubleshooting process

Knowing whether an error is internal or external allows you to tailor your troubleshooting approach effectively:

For internal errors: Start by reviewing the configuration and logic within Celigo. Check for issues in your flow setup, such as incorrect mappings, exceptions in scripts, or faulty business logic.

Since these errors are within your control, you can often resolve them by adjusting the settings directly in the platform.

For external errors: Examine the interaction between Celigo and the external system. This may involve reviewing API logs, checking the external system’s documentation, or testing connectivity.

In some cases, resolving external errors might require collaboration with your external system’s support team or developers, especially if the issue lies beyond your control (e.g., a third-party API outage).

Tools for identifying error sources

Celigo provides several tools to help you identify the source of errors:

• Error table: By clicking on the error count in your integration flow, you can access the error table, which acts as your central hub for troubleshooting. This table provides a clear breakdown of where the error occurred—whether internally within Celigo or externally in one of your connected systems.
• Error classifications: Celigo categorizes errors, making it easier to identify whether the issue is internal or external. This classification system allows you to quickly determine the nature of the error and decide on the appropriate troubleshooting steps.
• Flow Builder: View your integration flow to find the exact step where the error occurred. The visual tools in Flow Builder help you pinpoint whether the problem is in a specific action within Celigo (or if it’s due to an external system interaction).

By accurately identifying the source of errors, you set the stage for a more efficient and targeted troubleshooting process.

This foundational step ensures that you’re focusing your efforts on the right area, whether that’s adjusting settings within Celigo or addressing issues in an external system. This ultimately leads to quicker resolutions and smoother operations.

Analyzing error messages

Error messages are critical in diagnosing and resolving issues within your integrations. These messages are not just alerts; they contain detailed information that can guide you toward the root cause of the problem.

AI/ML-powered error classifications

We’ve implemented machine learning and AI-powered error management to automatically classify errors into seven categories. The AI engine can recognize and classify errors from any API, including custom APIs, even if we’ve never integrated that API before.

Learn about the seven types of error classifications.

Error codes

Each error message is accompanied by an error code. These codes are standardized identifiers that help you quickly understand the type of issue you’re dealing with.

For example, an error code might indicate a problem with data formatting, a missing required field, or an authentication failure. Familiarizing yourself with common error codes can save time during troubleshooting, as you’ll immediately know where to start looking.

Timestamps

Timestamps in error messages are crucial for tracking an error, particularly when dealing with time-sensitive processes or when multiple flows are running simultaneously. Timestamps allow you to correlate errors with specific events or changes in your system, making it easier to identify what triggered the error.

Detailed error messages

Beyond the error code and classification, the detailed message contains specific information about what went wrong. This might include details like which data field caused the issue, the expected vs. actual data format, or a description of the failed operation.

Reading through these details carefully can often provide direct clues on resolving the error.

Consulting API documentation

If the error message doesn’t fully clarify the issue, your next step should be to consult the third-party API documentation. API documentation often contains information about the expected data formats, required fields, and common error codes, which can help you understand why the error occurred and how to fix it.

When to submit a support ticket

If you’ve analyzed the error message, checked the API documentation, and still can’t resolve the issue, it may be time to submit a support ticket. When doing so, include all relevant details from the error message, including the error code, timestamp, and any troubleshooting steps you’ve already taken.

This information will help the support team diagnose and resolve the issue more efficiently.

Addressing common error causes

Errors often arise from straightforward issues, such as data formatting mismatches. For example, if a phone number in your data includes parentheses and hyphens, but your destination application expects only numerical values, a mapping error will occur. 

While a quick fix can be applied through retrying the data, a more permanent solution involves adjusting the mapping settings to prevent future errors.

Managing errors

Celigo provides several tools to help you manage errors efficiently:

Auto-resolve external errors

Once errors from external applications are fixed, you can mark them as resolved. The platform’s trace key feature automatically identifies and resolves similar errors in future runs. Our AI-driven system also allows auto-resolution policies based on error type, automatically resolving errors by retrying the operation, fixing the issue, or marking them resolved if the original condition no longer exists.

For example, if the source system’s data has been corrected or an API connection restored, the system can retry failed processes or auto-resolve duplicate errors without manual intervention.

Retry errors in bulk

You can retry multiple errors simultaneously, which not only saves time but also enhances efficiency in handling tasks. This approach allows you to address various issues at once, streamlining the process and minimizing downtime.

Assign to teams

Errors that occur within a flow can be assigned to specific teams. This will ensure they are addressed and resolved efficiently according to your integration administration approach. Using a targeted, administrative approach allows each team to use its specialized skills and knowledge to effectively manage the issues within its domain, ultimately improving overall performance and reliability.

Tagging and filtering

To enhance error management, organize your errors by tagging and filtering them. This allows for easier identification and categorization, ensuring that issues can be addressed systematically and efficiently.

By implementing this approach, you can streamline the error resolution process and improve overall workflow.

Checking and debugging connections

If your processes aren’t running smoothly, check the Connections tab in your integration. Connections going down can halt processes, often due to global issues or credential expirations.

Debugging connections can help identify ongoing problems, and if necessary, you can submit a support ticket for further assistance.

Learn more about Celigo’s error management

Celigo’s Help Center articles on error management provide comprehensive guidance on best practices, collaborative troubleshooting, and techniques for root-cause analysis to streamline and improve error resolution.

• Intro to error management
• Best practices for managing errors – part 1
• Best practices for managing errors – part 2