// spring-boot-auto-configure options: START
:page-partial:
:doctitle: Camel Spring Boot Starter for hystrix

== Spring Boot Auto-Configuration

When using hystrix with Spring Boot make sure to use the following Maven dependency to have support for auto configuration:

[source,xml]
----
<dependency>
  <groupId>org.apache.camel.springboot</groupId>
  <artifactId>camel-hystrix-starter</artifactId>
  <version>x.x.x</version>
  <!-- use the same version as your Camel core version -->
</dependency>
----


The component supports 3 options, which are listed below.



[width="100%",cols="2,5,^1,2",options="header"]
|===
| Name | Description | Default | Type
| *camel.hystrix.mapping.enabled* | Enables the automatic mapping of the hystrics metric servlet into the Spring web context. | true | Boolean
| *camel.hystrix.mapping.path* | Endpoint for hystrix metrics servlet. | /hystrix.stream | String
| *camel.hystrix.mapping.servlet-name* | Name of the Hystrix metrics servlet. | HystrixEventStreamServlet | String
|===
// spring-boot-auto-configure options: END
