Global Error Handling in Mule application

Introduction

This article is the continued part in the MuleSoft articles series; if you would like to understand the basics of MuleSoft, refer to these articles before going next:

• Getting Started MuleSoft
• How To Connect to Azure SQL Database with MuleSoft
• Load Data from S3 Bucket Using MuleSoft S3 Connector
• How To Call Stored Procedure with MuleSoft
• How To Post Data Using Stored Procedure with MuleSoft
• How To Set Variable and Payload in MuleSoft
• Fetch MySQL Data Using Database Connector in MuleSoft
• Retrieve Data From Database Based On Conditions In MuleSoft
• Create and Write CSV Files Using File Connector in MuleSoft
• Read Files Using File Connector in MuleSoft
• Default Error Handling Behavior of a Mule Application
• Basic Internal Error Handlers in Mule application

Why Global Error Handling?

In MuleSoft, global error handling refers to the process of handling errors and exceptions that occur during the execution of a Mule application at a central location. It provides a way to capture and handle errors consistently across multiple integration flows and components.

Global error handling is typically implemented using error handlers, which are special components in MuleSoft that can be configured to handle specific types of errors or exceptions. These error handlers are defined at the application level and are invoked whenever an error occurs within the application.

Here's how global error handling works in MuleSoft:

1. Error Propagation: Whenever an error occurs during the execution of a Mule application, the error is propagated along the flow until it reaches an error handler. This propagation can be automatic or manual, depending on how the application is configured.
2. Error Handler Configuration: Error handlers are configured to handle specific types of errors or exceptions. They can be defined globally for the entire application or at a more granular level, such as for individual flows or components.
3. Error Handler Invocation: When an error occurs, MuleSoft checks the error type and looks for a matching error handler based on the configured rules. Once a matching error handler is found, it is invoked to handle the error.
4. Error Handling Actions: Error handlers can perform various actions to handle the error, such as logging the error, transforming the error message, sending notifications, retrying the operation, or returning a custom response to the client.
5. Error Propagation or Resolution: After the error is handled by the error handler, the application can choose to propagate the error further along the flow or resolve it, depending on the desired behavior. Propagation may involve passing the error to subsequent error handlers or returning an error response to the client.

By implementing global error handling, you can ensure consistent error handling and management across your MuleSoft applications. It helps centralize error handling logic, improve maintainability, and provide a better user experience by gracefully handling errors.

Getting Started

Let's do a quick project setup and include the required global config files; these are the quick steps:

• First, open Anypoint Studio and Create a New Mule Project.
• Enter a project name and selection location and click finish.
• Click on Add Modules in the Mule palette and find File in the featured components.
• Drag and drop the File onto the Mule palette before adding it to the project.
• Now let's add a new Mule Configuration File and give the name as global.
• Enter the file name as global.
• Go to Global Elements, click the Create button, and add an HTTP Listener config.
• Leave everything as default and click ok.
• Click the Create button, Select File Config, and click OK.
• Provide the Working Directory path in the General tab.

Drag and Drop Listener HTTP from Mule Palette and give a name and select connector configurations and endpoint Path; also, make sure to provide the GET method in advanced settings.

Next, drag and drop the Request (HTTP) component from Mule Palette and provide the name and configuration and request method, and Path.

Next to the user global error handler in the mule application, it is important to reference the request component.

Go back to the Message Flow of the Global.xml file and drag and drop Core >> Error Handler connector and give a name.

Next, drag and drop On Error Propagate inside the Error Handler connector and select the type ANY.

Next, drag and drop Logger inside the On Error Propagate connector to log the error. Set a logger display name, generic message, and level ERROR.

Next, set payload on error propagate, drag and drop Set Payload (Core) and set a display name and Value.

Now let's work on Error continue in the global handler.

Drag and drop On Error Continue component from Core module and place inside Error Handler and replicate previous steps like provide name and error type (ANY).

Next, drag and drop the Logger from the Core module and place inside On Error Continue and provide the logger name and generic message and level type ERROR.

At last, drag and drop the Set Payload component from the Core module and give a display name and data weave values.

Now we are done with our global work.

The final step is to reference global error in the global error handling configuration.

Go to the global elements and click Create button.

Search for configuration under Global Configurations and click OK.

Select Default Error Handler and HA Profile.

Also, put some notes if you like and click OK.

The final global File will look like this with all settings.

Let's run both examples to see the result in Postman.

Everything looks good, the application is deployed without any errors. Let's open Postman and enter the endpoint to see the result.

As you can see, we are getting 500 Server Errors. As we have defined error type ANY and the first error handler in On Erro Propagate, that's why it's picking the first error handler. If you change the order of both internal error elements, then things will be different.

You also can review the execution log in the Console view.

Everything looks good with a global error handler.

Conclusion

In this article, we learned about how to use global error handlers in the Mule application and how to see the result in Postman.