Hystrix EIP (deprecated)

The Hystrix EIP provides integration with Netflix Hystrix to be used as Circuit Breaker in the Camel routes.

Resilience4j is a lightweight fault tolerance library inspired by Netflix Hystrix, but designed for functional programming.

Configuration options

The Hystrix EIP supports 2 options which are listed below:

Name Description Default Type

hystrixConfiguration

Configures the Hystrix EIP Use end when configuration is complete, to return back to the Hystrix EIP.

HystrixConfigurationDefinition

hystrixConfigurationRef

Refers to a Hystrix configuration to use for configuring the Hystrix EIP.

String

See Hystrix Configuration for all the configuration options on the Hystrix Circuit Breaker.

Using Hystrix EIP

Below is an example route showing a Hystrix EIP circuit breaker that protects against a downstream HTTP operation with fallback.

from("direct:start")
    .circuitBreaker()
        .to("http://fooservice.com/slow")
    .onFallback()
        .transform().constant("Fallback message")
    .end()
    .to("mock:result");

And in XML DSL:

<route>
    <from uri="direct:start"/>
    <circuitBreaker>
        <to uri="http://fooservice.com/faulty"/>
        <onFallback>
            <transform>
                <constant>Fallback message</constant>
            </transform>
        </onFallback>
    </circuitBreaker>
    <to uri="mock:result"/>
</route>

In case the calling the downstream HTTP service is failing, and an exception is thrown then the circuit breaker will react and execute the fallback route instead.

If there was no fallback, then the circuit breaker will throw an exception.

For more information about fallback see onFallback.

Configuring Hystrix

You can fine-tune Hystrix EIP by the many Hystrix Configuration options.

For example to use 2 second execution timeout, you can do as follows:

from("direct:start")
    .circuitBreaker()
        // use 2 second timeout
        .hystrixConfiguration().executionTimeoutInMilliseconds(2000).end()
        .log("Hystrix processing start: ${threadName}")
        .to("http://fooservice.com/faulty")
        .log("Hystrix processing end: ${threadName}")
    .end()
    .log("After Hystrix ${body}");

And in XML:

<route>
  <from uri="direct:start"/>
  <circuitBreaker>
    <hystrixConfiguration executionTimeoutInMilliseconds="2000"/>
    <log message="Hystrix processing start: ${threadName}"/>
    <to uri="http://fooservice.com/faulty"/>
    <log message="Hystrix processing end: ${threadName}"/>
  </circuitBreaker>
  <log message="After Hystrix: ${body}"/>
</route>

In this example if calling the downstream service does not return a response within 2 seconds, a timeout is triggered, and the exchange will fail with a TimeoutException.

Camel’s Error Handler and Circuit Breaker EIP

By default, the Circuit Breaker EIP handles errors by itself. This means if the circuit breaker is open, and the message fails, then Camel’s error handler is not reacting also.

However, you can enable Camels error handler with circuit breaker by enabling the inheritErrorHandler option, as shown:

// Camel's error handler that will attempt to redeliver the message 3 times
errorHandler(deadLetterChannel("mock:dead").maximumRedeliveries(3).redeliveryDelay(0));

from("direct:start")
    .to("log:start")
    // turn on Camel's error handler on circuit breaker so Camel can do redeliveries
    .circuitBreaker().inheritErrorHandler(true)
        .to("mock:a")
        .throwException(new IllegalArgumentException("Forced"))
    .end()
    .to("log:result")
    .to("mock:result");

This example is from a test, where you can see the Circuit Breaker EIP block has been hardcoded to always fail by throwing an exception. Because the inheritErrorHandler has been enabled, then Camel’s error handler will attempt to call the Circuit Breaker EIP block again.

That means the mock:a endpoint will receive the message again, and a total of 1 + 3 = 4 message (first time + 3 redeliveries).

If we turn off the inheritErrorHandler option (default) then the Circuit Breaker EIP will only be executed once because it handled the error itself.

Dependencies

Camel provides the Circuit Breaker EIP in the route model, which allows to plugin different implementations. Hystrix is one such implementation.

Maven users will need to add the following dependency to their pom.xml to use this EIP:

<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-hystrix</artifactId>
    <version>x.x.x</version><!-- use the same version as your Camel core version -->
</dependency>
Back to top