Class DefaultErrorHandlerDefinition
java.lang.Object
org.apache.camel.model.IdentifiedType
org.apache.camel.model.errorhandler.DefaultErrorHandlerDefinition
- All Implemented Interfaces:
org.apache.camel.ErrorHandlerFactory
- Direct Known Subclasses:
DeadLetterChannelDefinition
,DefaultErrorHandlerBuilder
,TransactionErrorHandlerDefinition
@Metadata(label="configuration,error")
public class DefaultErrorHandlerDefinition
extends IdentifiedType
The default error handler.
-
Constructor Summary
-
Method Summary
Modifier and TypeMethodDescriptionallowRedeliveryWhileStopping
(boolean allowRedeliveryWhileStopping) Controls whether to allow redelivery while stopping/shutting down a route that uses error handling.Will allow asynchronous delayed redeliveries.backOffMultiplier
(double backOffMultiplier) org.apache.camel.ErrorHandlerFactory
protected void
collisionAvoidancePercent
(double collisionAvoidancePercent) protected RedeliveryPolicyDefinition
delayPattern
(String delayPattern) exchangeFormatterRef
(String exchangeFormatterRef) executorService
(ScheduledExecutorService executorService) Sets the thread pool to be used for redelivery.executorServiceRef
(String ref) Sets a reference to a thread pool to be used for redelivery.getLevel()
org.apache.camel.spi.CamelLogger
org.apache.camel.Processor
org.apache.camel.Processor
org.apache.camel.Processor
org.apache.camel.Predicate
boolean
Sets the log used for caught exceptionsSets the log used for caught exceptionslog
(org.slf4j.Logger log) Sets the log used for caught exceptionslogExhausted
(boolean logExhausted) logExhaustedMessageBody
(boolean logExhaustedMessageBody) logExhaustedMessageHistory
(boolean logExhaustedMessageHistory) logger
(org.apache.camel.spi.CamelLogger logger) Sets the logger used for caught exceptionsloggingLevel
(String level) Sets the logging level of exceptions caughtloggingLevel
(org.apache.camel.LoggingLevel level) Sets the logging level of exceptions caughtlogHandled
(boolean logHandled) logNewException
(boolean logNewException) logRetryAttempted
(boolean logRetryAttempted) logRetryStackTrace
(boolean logRetryStackTrace) logStackTrace
(boolean logStackTrace) maximumRedeliveries
(int maximumRedeliveries) maximumRedeliveryDelay
(long maximumRedeliveryDelay) onExceptionOccurred
(org.apache.camel.Processor processor) Sets a customProcessor
to process theExchange
just after an exception was thrown.onExceptionOccurredRef
(String onExceptionOccurredRef) Sets a reference for the processor to use just after an exception was thrown.onPrepareFailure
(org.apache.camel.Processor processor) Sets a customProcessor
to prepare theExchange
before handled by the failure processor / dead letter channel.onPrepareFailureRef
(String onPrepareFailureRef) Sets a reference for the processor to use before handled by the failure processor.onRedelivery
(org.apache.camel.Processor processor) Sets a processor that should be processed before a redelivery attempt.onRedeliveryRef
(String onRedeliveryRef) Sets a reference for the processor to use before a redelivery attempt.redeliveryDelay
(long delay) redeliveryPolicyRef
(String redeliveryPolicyRef) Sets a reference to aRedeliveryPolicy
to be used for redelivery settings.retriesExhaustedLogLevel
(org.apache.camel.LoggingLevel retriesExhaustedLogLevel) retryAttemptedLogInterval
(int retryAttemptedLogInterval) retryAttemptedLogLevel
(org.apache.camel.LoggingLevel retryAttemptedLogLevel) retryWhile
(org.apache.camel.Expression retryWhile) Sets the retry while expression.retryWhileRef
(String retryWhileRef) void
setExecutorServiceBean
(ScheduledExecutorService executorServiceBean) Sets a thread pool to be used by the error handlervoid
setExecutorServiceRef
(String executorServiceRef) Sets a reference to a thread pool to be used by the error handlervoid
Logging level to use by error handlervoid
setLoggerBean
(org.apache.camel.spi.CamelLogger loggerBean) void
setLoggerRef
(String loggerRef) References to a logger to use as logger for the error handlervoid
setLogName
(String logName) Name of the logger to use by the error handlervoid
setOnExceptionOccurredProcessor
(org.apache.camel.Processor onExceptionOccurredProcessor) Sets a processor that should be processed just after an exception occurred.void
setOnExceptionOccurredRef
(String onExceptionOccurredRef) Sets a reference to a processor that should be processed just after an exception occurred.void
setOnPrepareFailureProcessor
(org.apache.camel.Processor onPrepareFailureProcessor) Sets a processor to prepare theExchange
before handled by the failure processor / dead letter channel.void
setOnPrepareFailureRef
(String onPrepareFailureRef) Sets a reference to a processor to prepare theExchange
before handled by the failure processor / dead letter channel.void
setOnRedeliveryProcessor
(org.apache.camel.Processor onRedeliveryProcessor) Sets a processor that should be processed before a redelivery attempt.void
setOnRedeliveryRef
(String onRedeliveryRef) Sets a reference to a processor that should be processed before a redelivery attempt.void
setRedeliveryPolicy
(RedeliveryPolicyDefinition redeliveryPolicy) Sets the redelivery settingsvoid
setRedeliveryPolicyRef
(String redeliveryPolicyRef) Sets a reference to aRedeliveryPolicy
to be used for redelivery settings.void
setRetryWhilePredicate
(org.apache.camel.Predicate retryWhilePredicate) Sets a retry while predicate.void
setRetryWhileRef
(String retryWhileRef) Sets a retry while predicate.void
setUseOriginalBody
(String useOriginalBody) Will use the original inputMessage
body (original body only) when anExchange
is moved to the dead letter queue.void
setUseOriginalMessage
(String useOriginalMessage) Will use the original inputMessage
(original body and headers) when anExchange
is moved to the dead letter queue.boolean
Will use the original inputMessage
body (original body only) when anExchange
is moved to the dead letter queue.Will use the original inputMessage
(original body and headers) when anExchange
is moved to the dead letter queue.Methods inherited from class org.apache.camel.model.IdentifiedType
getId, setId
-
Constructor Details
-
DefaultErrorHandlerDefinition
public DefaultErrorHandlerDefinition()
-
-
Method Details
-
supportTransacted
public boolean supportTransacted() -
cloneBuilder
public org.apache.camel.ErrorHandlerFactory cloneBuilder() -
cloneBuilder
-
createRedeliveryPolicy
-
getLoggerRef
-
setLoggerRef
References to a logger to use as logger for the error handler -
getLoggerBean
public org.apache.camel.spi.CamelLogger getLoggerBean() -
setLoggerBean
public void setLoggerBean(org.apache.camel.spi.CamelLogger loggerBean) -
getLevel
-
setLevel
Logging level to use by error handler -
getLogName
-
setLogName
Name of the logger to use by the error handler -
getUseOriginalMessage
-
setUseOriginalMessage
Will use the original inputMessage
(original body and headers) when anExchange
is moved to the dead letter queue. Notice: this only applies when all redeliveries attempt have failed and theExchange
is doomed for failure.
Instead of using the current inprogressExchange
IN message we use the original IN message instead. This allows you to store the original input in the dead letter queue instead of the inprogress snapshot of the IN message. For instance if you route transform the IN body during routing and then failed. With the original exchange store in the dead letter queue it might be easier to manually re submit theExchange
again as the IN message is the same as when Camel received it. So you should be able to send theExchange
to the same input. The difference between useOriginalMessage and useOriginalBody is that the former includes both the original body and headers, where as the latter only includes the original body. You can use the latter to enrich the message with custom headers and include the original message body. The former wont let you do this, as its using the original message body and headers as they are. You cannot enable both useOriginalMessage and useOriginalBody. The original input message is defensively copied, and the copied message body is converted toStreamCache
if possible (stream caching is enabled, can be disabled globally or on the original route), to ensure the body can be read when the original message is being used later. If the body is converted toStreamCache
then the message body on the currentExchange
is replaced with theStreamCache
body. If the body is not converted toStreamCache
then the body will not be able to re-read when accessed later. Important: The original input means the input message that are bounded by the currentUnitOfWork
. An unit of work typically spans one route, or multiple routes if they are connected using internal endpoints such as direct or seda. When messages is passed via external endpoints such as JMS or HTTP then the consumer will create a new unit of work, with the message it received as input as the original input. Also some EIP patterns such as splitter, multicast, will create a new unit of work boundary for the messages in their sub-route (eg the splitted message); however these EIPs have an option named shareUnitOfWork which allows to combine with the parent unit of work in regard to error handling and therefore use the parent original message. By default this feature is off. -
getUseOriginalBody
-
setUseOriginalBody
Will use the original inputMessage
body (original body only) when anExchange
is moved to the dead letter queue. Notice: this only applies when all redeliveries attempt have failed and theExchange
is doomed for failure.
Instead of using the current inprogressExchange
IN message we use the original IN message instead. This allows you to store the original input in the dead letter queue instead of the inprogress snapshot of the IN message. For instance if you route transform the IN body during routing and then failed. With the original exchange store in the dead letter queue it might be easier to manually re submit theExchange
again as the IN message is the same as when Camel received it. So you should be able to send theExchange
to the same input. The difference between useOriginalMessage and useOriginalBody is that the former includes both the original body and headers, where as the latter only includes the original body. You can use the latter to enrich the message with custom headers and include the original message body. The former wont let you do this, as its using the original message body and headers as they are. You cannot enable both useOriginalMessage and useOriginalBody. The original input message is defensively copied, and the copied message body is converted toStreamCache
if possible (stream caching is enabled, can be disabled globally or on the original route), to ensure the body can be read when the original message is being used later. If the body is converted toStreamCache
then the message body on the currentExchange
is replaced with theStreamCache
body. If the body is not converted toStreamCache
then the body will not be able to re-read when accessed later. Important: The original input means the input message that are bounded by the currentUnitOfWork
. An unit of work typically spans one route, or multiple routes if they are connected using internal endpoints such as direct or seda. When messages is passed via external endpoints such as JMS or HTTP then the consumer will create a new unit of work, with the message it received as input as the original input. Also some EIP patterns such as splitter, multicast, will create a new unit of work boundary for the messages in their sub-route (eg the splitted message); however these EIPs have an option named shareUnitOfWork which allows to combine with the parent unit of work in regard to error handling and therefore use the parent original message. By default this feature is off. -
getOnRedeliveryRef
-
setOnRedeliveryRef
Sets a reference to a processor that should be processed before a redelivery attempt. Can be used to change theExchange
before its being redelivered. -
getOnRedeliveryProcessor
public org.apache.camel.Processor getOnRedeliveryProcessor() -
setOnRedeliveryProcessor
public void setOnRedeliveryProcessor(org.apache.camel.Processor onRedeliveryProcessor) Sets a processor that should be processed before a redelivery attempt. Can be used to change theExchange
before its being redelivered. -
getOnExceptionOccurredRef
-
setOnExceptionOccurredRef
Sets a reference to a processor that should be processed just after an exception occurred. Can be used to perform custom logging about the occurred exception at the exact time it happened. Important: Any exception thrown from this processor will be ignored. -
getOnExceptionOccurredProcessor
public org.apache.camel.Processor getOnExceptionOccurredProcessor() -
setOnExceptionOccurredProcessor
public void setOnExceptionOccurredProcessor(org.apache.camel.Processor onExceptionOccurredProcessor) Sets a processor that should be processed just after an exception occurred. Can be used to perform custom logging about the occurred exception at the exact time it happened. Important: Any exception thrown from this processor will be ignored. -
getOnPrepareFailureRef
-
setOnPrepareFailureRef
Sets a reference to a processor to prepare theExchange
before handled by the failure processor / dead letter channel. This allows for example to enrich the message before sending to a dead letter queue. -
getOnPrepareFailureProcessor
public org.apache.camel.Processor getOnPrepareFailureProcessor() -
setOnPrepareFailureProcessor
public void setOnPrepareFailureProcessor(org.apache.camel.Processor onPrepareFailureProcessor) Sets a processor to prepare theExchange
before handled by the failure processor / dead letter channel. This allows for example to enrich the message before sending to a dead letter queue. -
getRetryWhileRef
-
setRetryWhileRef
Sets a retry while predicate. Will continue retrying until the predicate evaluates to false. -
getRedeliveryPolicyRef
-
setRedeliveryPolicyRef
Sets a reference to aRedeliveryPolicy
to be used for redelivery settings. -
getExecutorServiceRef
-
setExecutorServiceRef
Sets a reference to a thread pool to be used by the error handler -
getExecutorServiceBean
-
setExecutorServiceBean
Sets a thread pool to be used by the error handler -
getRetryWhilePredicate
public org.apache.camel.Predicate getRetryWhilePredicate() -
setRetryWhilePredicate
public void setRetryWhilePredicate(org.apache.camel.Predicate retryWhilePredicate) Sets a retry while predicate. Will continue retrying until the predicate evaluates to false. -
getRedeliveryPolicy
-
hasRedeliveryPolicy
public boolean hasRedeliveryPolicy() -
setRedeliveryPolicy
Sets the redelivery settings -
backOffMultiplier
-
collisionAvoidancePercent
-
redeliveryDelay
-
delayPattern
-
maximumRedeliveries
-
disableRedelivery
-
maximumRedeliveryDelay
-
useCollisionAvoidance
-
useExponentialBackOff
-
retriesExhaustedLogLevel
public DefaultErrorHandlerDefinition retriesExhaustedLogLevel(org.apache.camel.LoggingLevel retriesExhaustedLogLevel) -
retryAttemptedLogLevel
public DefaultErrorHandlerDefinition retryAttemptedLogLevel(org.apache.camel.LoggingLevel retryAttemptedLogLevel) -
retryAttemptedLogInterval
-
logStackTrace
-
logRetryStackTrace
-
logHandled
-
logNewException
-
logExhausted
-
logRetryAttempted
-
logExhaustedMessageHistory
-
logExhaustedMessageBody
-
exchangeFormatterRef
-
asyncDelayedRedelivery
Will allow asynchronous delayed redeliveries. The route, in particular the consumer's component, must support the Asynchronous Routing Engine (e.g. seda)- Returns:
- the builder
- See Also:
-
RedeliveryPolicy.setAsyncDelayedRedelivery(boolean)
-
allowRedeliveryWhileStopping
public DefaultErrorHandlerDefinition allowRedeliveryWhileStopping(boolean allowRedeliveryWhileStopping) Controls whether to allow redelivery while stopping/shutting down a route that uses error handling.- Parameters:
allowRedeliveryWhileStopping
- true to allow redelivery, false to reject redeliveries- Returns:
- the builder
-
executorService
Sets the thread pool to be used for redelivery.- Parameters:
executorService
- the scheduled thread pool to use- Returns:
- the builder.
-
executorServiceRef
Sets a reference to a thread pool to be used for redelivery.- Parameters:
ref
- reference to a scheduled thread pool- Returns:
- the builder.
-
logger
Sets the logger used for caught exceptions- Parameters:
logger
- the logger- Returns:
- the builder
-
loggingLevel
Sets the logging level of exceptions caught- Parameters:
level
- the logging level- Returns:
- the builder
-
loggingLevel
Sets the logging level of exceptions caught- Parameters:
level
- the logging level- Returns:
- the builder
-
log
Sets the log used for caught exceptions- Parameters:
log
- the logger- Returns:
- the builder
-
log
Sets the log used for caught exceptions- Parameters:
log
- the log name- Returns:
- the builder
-
log
Sets the log used for caught exceptions- Parameters:
log
- the log class- Returns:
- the builder
-
onRedelivery
Sets a processor that should be processed before a redelivery attempt. Can be used to change theExchange
before its being redelivered.- Parameters:
processor
- the processor- Returns:
- the builder
-
onRedeliveryRef
Sets a reference for the processor to use before a redelivery attempt.- Parameters:
onRedeliveryRef
- the processor's reference- Returns:
- the builder
- See Also:
-
retryWhile
Sets the retry while expression. Will continue retrying until expression evaluates to false.- Parameters:
retryWhile
- expression that determines when to stop retrying- Returns:
- the builder
-
retryWhileRef
-
useOriginalMessage
Will use the original inputMessage
(original body and headers) when anExchange
is moved to the dead letter queue. Notice: this only applies when all redeliveries attempt have failed and theExchange
is doomed for failure.
Instead of using the current inprogressExchange
IN message we use the original IN message instead. This allows you to store the original input in the dead letter queue instead of the inprogress snapshot of the IN message. For instance if you route transform the IN body during routing and then failed. With the original exchange store in the dead letter queue it might be easier to manually re submit theExchange
again as the IN message is the same as when Camel received it. So you should be able to send theExchange
to the same input. The difference between useOriginalMessage and useOriginalBody is that the former includes both the original body and headers, where as the latter only includes the original body. You can use the latter to enrich the message with custom headers and include the original message body. The former wont let you do this, as its using the original message body and headers as they are. You cannot enable both useOriginalMessage and useOriginalBody. The original input message is defensively copied, and the copied message body is converted toStreamCache
if possible (stream caching is enabled, can be disabled globally or on the original route), to ensure the body can be read when the original message is being used later. If the body is converted toStreamCache
then the message body on the currentExchange
is replaced with theStreamCache
body. If the body is not converted toStreamCache
then the body will not be able to re-read when accessed later. Important: The original input means the input message that are bounded by the currentUnitOfWork
. An unit of work typically spans one route, or multiple routes if they are connected using internal endpoints such as direct or seda. When messages is passed via external endpoints such as JMS or HTTP then the consumer will create a new unit of work, with the message it received as input as the original input. Also some EIP patterns such as splitter, multicast, will create a new unit of work boundary for the messages in their sub-route (eg the split message); however these EIPs have an option named shareUnitOfWork which allows to combine with the parent unit of work in regard to error handling and therefore use the parent original message. By default this feature is off.- Returns:
- the builder
- See Also:
-
useOriginalBody
Will use the original inputMessage
body (original body only) when anExchange
is moved to the dead letter queue. Notice: this only applies when all redeliveries attempt have failed and theExchange
is doomed for failure.
Instead of using the current inprogressExchange
IN message we use the original IN message instead. This allows you to store the original input in the dead letter queue instead of the inprogress snapshot of the IN message. For instance if you route transform the IN body during routing and then failed. With the original exchange store in the dead letter queue it might be easier to manually re submit theExchange
again as the IN message is the same as when Camel received it. So you should be able to send theExchange
to the same input. The difference between useOriginalMessage and useOriginalBody is that the former includes both the original body and headers, where as the latter only includes the original body. You can use the latter to enrich the message with custom headers and include the original message body. The former wont let you do this, as its using the original message body and headers as they are. You cannot enable both useOriginalMessage and useOriginalBody. The original input message is defensively copied, and the copied message body is converted toStreamCache
if possible, to ensure the body can be read when the original message is being used later. If the body is not converted toStreamCache
then the body will not be able to re-read when accessed later. Important: The original input means the input message that are bounded by the currentUnitOfWork
. An unit of work typically spans one route, or multiple routes if they are connected using internal endpoints such as direct or seda. When messages is passed via external endpoints such as JMS or HTTP then the consumer will create a new unit of work, with the message it received as input as the original input. Also some EIP patterns such as splitter, multicast, will create a new unit of work boundary for the messages in their sub-route (eg the split message); however these EIPs have an option named shareUnitOfWork which allows to combine with the parent unit of work in regard to error handling and therefore use the parent original message. By default this feature is off.- Returns:
- the builder
- See Also:
-
onPrepareFailure
Sets a customProcessor
to prepare theExchange
before handled by the failure processor / dead letter channel. This allows for example to enrich the message before sending to a dead letter queue.- Parameters:
processor
- the processor- Returns:
- the builder
-
onPrepareFailureRef
Sets a reference for the processor to use before handled by the failure processor.- Parameters:
onPrepareFailureRef
- the processor's reference- Returns:
- the builder
- See Also:
-
onExceptionOccurred
Sets a customProcessor
to process theExchange
just after an exception was thrown. This allows to execute the processor at the same time the exception was thrown. Important: Any exception thrown from this processor will be ignored.- Parameters:
processor
- the processor- Returns:
- the builder
-
onExceptionOccurredRef
Sets a reference for the processor to use just after an exception was thrown.- Parameters:
onExceptionOccurredRef
- the processor's reference- Returns:
- the builder
- See Also:
-
redeliveryPolicyRef
Sets a reference to aRedeliveryPolicy
to be used for redelivery settings.- Parameters:
redeliveryPolicyRef
- the redelivrey policy reference- Returns:
- the builder
-