Hystrix EIP

The Hystrix EIP provides integration with Netflix Hystrix to be used as circuit breaker in the Camel routes. Hystrix is a latency and fault tolerance library designed to isolate points of access to remote systems, services and 3rd party libraries, stop cascading failure and enable resilience in complex distributed systems where failure is inevitable.

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>

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 Hystrix EIP.

Samples

Below is an example route showing an Hystrix endpoint that protects against slow operation by falling back to the in-lined fallback route. By default the timeout request is just 1000ms so the HTTP endpoint has to be fairly quick to succeed.

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

And in XML DSL:

<camelContext xmlns="http://camel.apache.org/schema/spring">
  <route>
    <from uri="direct:start"/>
    <circuitBreaker>
      <to uri="http://fooservice.com/slow"/>
      <onFallback>
        <transform>
          <constant>Fallback message</constant>
        </transform>
      </onFallback>
    </circuitBreaker>
    <to uri="mock:result"/>
  </route>
</camelContext>

Configuring Hystrix

You can fine-tune Hystrix by the many Hystrix Configuration options. For example to use a 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}")
        .toD("direct:${body}")
        .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}"/>
    <toD uri="direct:${body}"/>
    <log message="Hystrix processing end: ${threadName}"/>
  </circuitBreaker>
  <log message="After Hystrix: ${body}"/>
</route>

Fallback

See onFallback.

Other examples

You can find an example with the source code: camel-example-spring-boot-hystrix.

Using Hystrix with Spring Boot

See the Hystrix Component.

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 an unit 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.