Error Handler
Camel supports pluggable ErrorHandler strategies to deal with errors processing an Event Driven Consumer. An alternative is to specify the error handling directly in the DSL using the Exception Clause.
Some current implementations include
- Dead Letter Channel which supports attempting to redeliver the message exchange a number of times before sending it to a dead letter endpoint
- LoggingErrorHandler for just catching and logging exceptions
- NoErrorHandler for no error handling
- Transaction for transactional error handling (Spring based). See the Transactional Client EIP pattern.
Transaction
If the route is transactional then the Dead Letter Channel is disabled. The exchange.isTransacted()
is used to determine if an Exchange is transacted or not.
So if you are using transacted routes then you should configure the TransactionErrorHandler instread of DeadLetterChannel. See Transactional Client for further details and samples.
These error handlers can be applied in the DSL to an entire set of rules or a specific routing rule as we show in the next examples. Error handling rules are inherited on each routing rule within a single RouteBuilder
Setting global error handlers
The following example shows how you can register a global error handler (in this case using the logging handler)
Setting error handlers on a specific route
The following example shows how you can register a local error handler; the customized logging handler is only registered for the route from Endpoint seda:a
Spring based configuration
In Camel 1.4 the error handler can be configured as a spring bean and referenced as either:
- global (the camelContext tag)
- per route (the route tag)
- per policy (the policy tag)
The error handler is configured with the errorHandlerRef
attribute.
See Transactional Client for examples.
Default Error Handler
The default error handler is the Dead Letter Channel which is automatically configured for you. You can then configure the specific dead letter endpoint to use either for an entire rule base or a specific rule as shown above. For example
Logging Error Handler
The logging error handler will log (by default at ERROR level) whenever an uncaught exception is thrown. The logging category, logger and level may all be defined in the builder.
errorHandler(loggingErrorHandler("mylogger.name").level(LoggingLevel.INFO));
This would create an error handler which logs exceptions using the category mylogger.name and uses the level INFO for all log messages created.
from("seda:a").errorHandler(loggingErrorHandler("mylogger.name").level(LoggingLevel.DEBUG).to("seda:b");
Loggers may also be defined for specific routes.
Overriding default behavior
You can also configure the RedeliveryPolicy as this example shows
As of Camel 1.4 you can configure the ExceptionPolicyStrategy as this example shows
Using our own strategy MyPolicy we can change the default behavior of Camel with our own code to resolve which ExceptionType from above should be handling the given thrown exception.
Using the transactional error handler
The transactional error handler is introduced in Camel 1.4 and is based on spring transaction. This requires the usage of the camel-spring component.
See Transactional Client that has many samples for how to use and transactional behavior and configuration with this error handler.
See also
The Dead Letter Channel for further details.
The Transactional Client for transactional behavior