Hystrix

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.

24,073

4,701

24,073

403

View on GitHub

Top Related Projects

RxJava

47,834

RxJava – Reactive Extensions for the JVM – a library for composing asynchronous and event-based programs using observable sequences for the Java VM.

resilience4j

9,654

Resilience4j is a fault tolerance library designed for Java8 and functional programming

Sentinel

22,289

A powerful flow control component enabling reliability, resilience and monitoring for microservices. (面向云原生微服务的高可用流控防护组件)

feign

9,422

Feign makes writing java http clients easier

spring-cloud-netflix

4,861

Integration with Netflix OSS components

akka

13,024

Build highly concurrent, distributed, and resilient message-driven applications on the JVM

Quick Overview

Hystrix is a latency and fault tolerance library designed to isolate points of access to remote systems, services, and 3rd party libraries in a distributed environment. It helps prevent cascading failures and enables resilience in complex distributed systems where failure is inevitable.

Pros

Improves system resilience by preventing cascading failures
Provides real-time monitoring and configuration changes
Offers fallback mechanisms for graceful degradation
Supports various JVM-based languages (Java, Scala, etc.)

Cons

No longer actively maintained (in maintenance mode since 2018)
Steep learning curve for proper implementation
Can add complexity to the codebase
Limited to JVM-based languages

Code Examples

Creating a Hystrix Command:

public class GetUserCommand extends HystrixCommand<User> {
    private final int userId;

    public GetUserCommand(int userId) {
        super(HystrixCommandGroupKey.Factory.asKey("UserGroup"));
        this.userId = userId;
    }

    @Override
    protected User run() {
        return userService.getUser(userId);
    }
}

Executing a Hystrix Command:

User user = new GetUserCommand(123).execute();

Implementing a fallback:

public class GetUserCommand extends HystrixCommand<User> {
    // ... constructor and run() method

    @Override
    protected User getFallback() {
        return new User("Default User");
    }
}

Using Hystrix Observable:

Observable<User> userObservable = new GetUserCommand(123).observe();
userObservable.subscribe(user -> System.out.println(user.getName()));

Getting Started

To use Hystrix in your project, add the following dependency to your Maven pom.xml:

<dependency>
    <groupId>com.netflix.hystrix</groupId>
    <artifactId>hystrix-core</artifactId>
    <version>1.5.18</version>
</dependency>

Or for Gradle:

implementation 'com.netflix.hystrix:hystrix-core:1.5.18'

Then, create a Hystrix command by extending HystrixCommand or HystrixObservableCommand, implement the run() method, and optionally provide a fallback. Execute the command using execute(), queue(), observe(), or toObservable() methods.

Competitor Comparisons

RxJava

47,834

RxJava – Reactive Extensions for the JVM – a library for composing asynchronous and event-based programs using observable sequences for the Java VM.

Pros of RxJava

More versatile and applicable to a wider range of reactive programming scenarios
Offers a rich set of operators for composing and transforming observable streams
Actively maintained and widely adopted in the Android development community

Cons of RxJava

Steeper learning curve due to its extensive API and concepts
Can lead to complex and hard-to-debug code if not used carefully
May introduce unnecessary overhead for simpler use cases

Code Comparison

RxJava:

Observable.just(1, 2, 3, 4, 5)
    .map(n -> n * 2)
    .filter(n -> n > 5)
    .subscribe(System.out::println);

Hystrix:

new HystrixCommand<String>(HystrixCommandGroupKey.Factory.asKey("ExampleGroup")) {
    @Override
    protected String run() {
        return "Hello, World!";
    }
}.execute();

Key Differences

RxJava focuses on reactive programming and handling asynchronous data streams
Hystrix is primarily designed for fault tolerance and latency tolerance in distributed systems
RxJava provides a more general-purpose toolkit, while Hystrix is specialized for circuit breaking and resilience patterns
Hystrix is no longer in active development, while RxJava continues to evolve and receive updates

resilience4j

9,654

Resilience4j is a fault tolerance library designed for Java8 and functional programming

Pros of resilience4j

Lightweight and modular design, allowing for selective use of components
Built with functional programming principles, making it more compatible with reactive programming models
Actively maintained and developed, with regular updates and improvements

Cons of resilience4j

Steeper learning curve for developers unfamiliar with functional programming concepts
Less extensive documentation and community resources compared to Hystrix
May require more manual configuration for complex scenarios

Code Comparison

Hystrix:

@HystrixCommand(fallbackMethod = "fallback")
public String doSomething() {
    // Method implementation
}

resilience4j:

private final CircuitBreaker circuitBreaker = CircuitBreaker.ofDefaults("myCircuitBreaker");

public String doSomething() {
    return circuitBreaker.executeSupplier(() -> {
        // Method implementation
    });
}

Both libraries provide circuit breaking functionality, but resilience4j offers a more flexible and modular approach. Hystrix uses annotations for configuration, while resilience4j employs a programmatic approach, allowing for more fine-grained control over the circuit breaker behavior.

Sentinel

22,289

A powerful flow control component enabling reliability, resilience and monitoring for microservices. (面向云原生微服务的高可用流控防护组件)

Pros of Sentinel

More flexible and customizable flow control rules
Better support for cloud-native environments and microservices
Provides real-time monitoring and dynamic configuration capabilities

Cons of Sentinel

Less mature ecosystem compared to Hystrix
Steeper learning curve due to more complex configuration options
Limited documentation and community resources in English

Code Comparison

Hystrix:

@HystrixCommand(fallbackMethod = "fallback")
public String doSomething() {
    // Business logic
}

Sentinel:

@SentinelResource(value = "doSomething", fallback = "fallback")
public String doSomething() {
    // Business logic
}

Both libraries use similar annotations for defining protected methods, but Sentinel offers more granular control over resource definitions and flow control rules.

Sentinel provides a more comprehensive approach to distributed system reliability, with features like circuit breaking, flow control, and system adaptive protection. It's particularly well-suited for cloud-native applications and microservices architectures.

Hystrix, while more established, has been placed in maintenance mode by Netflix. It offers a simpler implementation but may lack some of the advanced features and flexibility provided by Sentinel.

Ultimately, the choice between Sentinel and Hystrix depends on the specific requirements of your project, the complexity of your distributed system, and your team's familiarity with each library.

feign

9,422

Feign makes writing java http clients easier

Pros of Feign

Simplifies HTTP API clients with declarative annotations
Integrates seamlessly with Spring Boot and other Spring projects
Supports various encoders and decoders for flexible data handling

Cons of Feign

Limited built-in fault tolerance and circuit breaking capabilities
Less comprehensive monitoring and metrics compared to Hystrix
May require additional libraries for advanced resilience patterns

Code Comparison

Feign:

@FeignClient("user-service")
public interface UserClient {
    @GetMapping("/users/{id}")
    User getUser(@PathVariable("id") Long id);
}

Hystrix:

@HystrixCommand(fallbackMethod = "getDefaultUser")
public User getUser(Long id) {
    return userService.getUser(id);
}

Key Differences

Feign focuses on simplifying HTTP client creation, while Hystrix emphasizes fault tolerance and circuit breaking
Feign is primarily for API consumption, whereas Hystrix is for general method invocation protection
Hystrix provides more extensive monitoring and configuration options for resilience
Feign can be used with Hystrix for combined benefits, but they serve different primary purposes

Use Cases

Choose Feign for streamlined API client development, especially in Spring ecosystems
Opt for Hystrix when robust fault tolerance and circuit breaking are critical
Consider using both together for comprehensive microservices communication and resilience

spring-cloud-netflix

4,861

Integration with Netflix OSS components

Pros of Spring Cloud Netflix

Integrates seamlessly with Spring Boot and other Spring Cloud projects
Provides a more comprehensive set of cloud-native patterns and tools
Actively maintained and regularly updated

Cons of Spring Cloud Netflix

Steeper learning curve due to broader feature set
Potentially heavier resource consumption
May introduce unnecessary dependencies for simpler applications

Code Comparison

Hystrix circuit breaker implementation:

@HystrixCommand(fallbackMethod = "fallback")
public String doSomething() {
    // Method implementation
}

Spring Cloud Netflix circuit breaker implementation:

@CircuitBreaker(name = "myCircuitBreaker", fallbackMethod = "fallback")
public String doSomething() {
    // Method implementation
}

Both implementations are similar, with Spring Cloud Netflix offering a more standardized approach across different circuit breaker implementations.

Spring Cloud Netflix provides a higher-level abstraction and integration with the Spring ecosystem, while Hystrix offers a more focused circuit breaker implementation. Spring Cloud Netflix is better suited for complex microservices architectures using Spring, while Hystrix may be preferred for simpler applications or those not using the Spring framework.

akka

13,024

Build highly concurrent, distributed, and resilient message-driven applications on the JVM

Pros of Akka

Provides a comprehensive actor-based concurrency model for building distributed systems
Offers built-in clustering capabilities for creating scalable, fault-tolerant applications
Supports multiple programming paradigms, including reactive and stream processing

Cons of Akka

Steeper learning curve due to its more complex architecture and concepts
Requires more boilerplate code for simple use cases compared to Hystrix
Less focused on circuit breaking and fault tolerance specifically

Code Comparison

Akka example:

class MyActor extends Actor {
  def receive = {
    case "message" => println("Received message")
  }
}

Hystrix example:

public class CommandHelloWorld extends HystrixCommand<String> {
    private final String name;
    public CommandHelloWorld(String name) {
        super(HystrixCommandGroupKey.Factory.asKey("ExampleGroup"));
        this.name = name;
    }
    @Override
    protected String run() {
        return "Hello " + name + "!";
    }
}

While Hystrix focuses on circuit breaking and fault tolerance for distributed systems, Akka provides a more comprehensive toolkit for building distributed, concurrent, and resilient applications. Akka's actor model offers greater flexibility but requires more setup, whereas Hystrix provides a simpler API for specific resilience patterns.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

Hystrix: Latency and Fault Tolerance for Distributed Systems

Hystrix Status

Hystrix is no longer in active development, and is currently in maintenance mode.

Hystrix (at version 1.5.18) is stable enough to meet the needs of Netflix for our existing applications. Meanwhile, our focus has shifted towards more adaptive implementations that react to an applicationâs real time performance rather than pre-configured settings (for example, through adaptive concurrency limits). For the cases where something like Hystrix makes sense, we intend to continue using Hystrix for existing applications, and to leverage open and active projects like resilience4j for new internal projects. We are beginning to recommend others do the same.

Netflix Hystrix is now officially in maintenance mode, with the following expectations to the greater community: Netflix will no longer actively review issues, merge pull-requests, and release new versions of Hystrix. We have made a final release of Hystrix (1.5.18) per issue 1891 so that the latest version in Maven Central is aligned with the last known stable version used internally at Netflix (1.5.11). If members of the community are interested in taking ownership of Hystrix and moving it back into active mode, please reach out to hystrixoss@googlegroups.com.

Hystrix has served Netflix and the community well over the years, and the transition to maintenance mode is in no way an indication that the concepts and ideas from Hystrix are no longer valuable. On the contrary, Hystrix has inspired many great ideas and projects. We thank everyone at Netflix, and in the greater community, for all the contributions made to Hystrix over the years.

Introduction

Full Documentation

See the Wiki for full documentation, examples, operational details and other information.

See the Javadoc for the API.

Communication

Google Group: HystrixOSS
Twitter: @HystrixOSS
GitHub Issues

What does it do?

1) Latency and Fault Tolerance

Stop cascading failures. Fallbacks and graceful degradation. Fail fast and rapid recovery.

Thread and semaphore isolation with circuit breakers.

2) Realtime Operations

Realtime monitoring and configuration changes. Watch service and property changes take effect immediately as they spread across a fleet.

Be alerted, make decisions, affect change and see results in seconds.

3) Concurrency

Parallel execution. Concurrency aware request caching. Automated batching through request collapsing.

Hello World!

Code to be isolated is wrapped inside the run() method of a HystrixCommand similar to the following:

public class CommandHelloWorld extends HystrixCommand<String> {

    private final String name;

    public CommandHelloWorld(String name) {
        super(HystrixCommandGroupKey.Factory.asKey("ExampleGroup"));
        this.name = name;
    }

    @Override
    protected String run() {
        return "Hello " + name + "!";
    }
}

This command could be used like this:

String s = new CommandHelloWorld("Bob").execute();
Future<String> s = new CommandHelloWorld("Bob").queue();
Observable<String> s = new CommandHelloWorld("Bob").observe();

More examples and information can be found in the How To Use section.

Example source code can be found in the hystrix-examples module.

Binaries

Binaries and dependency information for Maven, Ivy, Gradle and others can be found at http://search.maven.org.

Change history and version numbers => CHANGELOG.md

Example for Maven:

<dependency>
    <groupId>com.netflix.hystrix</groupId>
    <artifactId>hystrix-core</artifactId>
    <version>x.y.z</version>
</dependency>

and for Ivy:

<dependency org="com.netflix.hystrix" name="hystrix-core" rev="x.y.z" />

If you need to download the jars instead of using a build system, create a Maven pom file like this with the desired version:

<?xml version="1.0"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.netflix.hystrix.download</groupId>
	<artifactId>hystrix-download</artifactId>
	<version>1.0-SNAPSHOT</version>
	<name>Simple POM to download hystrix-core and dependencies</name>
	<url>http://github.com/Netflix/Hystrix</url>
	<dependencies>
		<dependency>
			<groupId>com.netflix.hystrix</groupId>
			<artifactId>hystrix-core</artifactId>
			<version>x.y.z</version>
			<scope/>
		</dependency>
	</dependencies>
</project>

Then execute:

mvn -f download-hystrix-pom.xml dependency:copy-dependencies

It will download hystrix-core-*.jar and its dependencies into ./target/dependency/.

You need Java 6 or later.

Build

To build:

$ git clone git@github.com:Netflix/Hystrix.git
$ cd Hystrix/
$ ./gradlew build

Further details on building can be found on the Getting Started page of the wiki.

Run Demo

To run a demo app do the following:

$ git clone git@github.com:Netflix/Hystrix.git
$ cd Hystrix/
./gradlew runDemo

You will see output similar to the following:

Request => GetUserAccountCommand[SUCCESS][8ms], GetPaymentInformationCommand[SUCCESS][20ms], GetUserAccountCommand[SUCCESS, RESPONSE_FROM_CACHE][0ms]x2, GetOrderCommand[SUCCESS][101ms], CreditCardCommand[SUCCESS][1075ms]
Request => GetUserAccountCommand[FAILURE, FALLBACK_SUCCESS][2ms], GetPaymentInformationCommand[SUCCESS][22ms], GetUserAccountCommand[FAILURE, FALLBACK_SUCCESS, RESPONSE_FROM_CACHE][0ms]x2, GetOrderCommand[SUCCESS][130ms], CreditCardCommand[SUCCESS][1050ms]
Request => GetUserAccountCommand[FAILURE, FALLBACK_SUCCESS][4ms], GetPaymentInformationCommand[SUCCESS][19ms], GetUserAccountCommand[FAILURE, FALLBACK_SUCCESS, RESPONSE_FROM_CACHE][0ms]x2, GetOrderCommand[SUCCESS][145ms], CreditCardCommand[SUCCESS][1301ms]
Request => GetUserAccountCommand[SUCCESS][4ms], GetPaymentInformationCommand[SUCCESS][11ms], GetUserAccountCommand[SUCCESS, RESPONSE_FROM_CACHE][0ms]x2, GetOrderCommand[SUCCESS][93ms], CreditCardCommand[SUCCESS][1409ms]

#####################################################################################
# CreditCardCommand: Requests: 17 Errors: 0 (0%)   Mean: 1171 75th: 1391 90th: 1470 99th: 1486 
# GetOrderCommand: Requests: 21 Errors: 0 (0%)   Mean: 100 75th: 144 90th: 207 99th: 230 
# GetUserAccountCommand: Requests: 21 Errors: 4 (19%)   Mean: 8 75th: 11 90th: 46 99th: 51 
# GetPaymentInformationCommand: Requests: 21 Errors: 0 (0%)   Mean: 18 75th: 21 90th: 24 99th: 25 
#####################################################################################

Request => GetUserAccountCommand[SUCCESS][10ms], GetPaymentInformationCommand[SUCCESS][16ms], GetUserAccountCommand[SUCCESS, RESPONSE_FROM_CACHE][0ms]x2, GetOrderCommand[SUCCESS][51ms], CreditCardCommand[SUCCESS][922ms]
Request => GetUserAccountCommand[SUCCESS][12ms], GetPaymentInformationCommand[SUCCESS][12ms], GetUserAccountCommand[SUCCESS, RESPONSE_FROM_CACHE][0ms]x2, GetOrderCommand[SUCCESS][68ms], CreditCardCommand[SUCCESS][1257ms]
Request => GetUserAccountCommand[SUCCESS][10ms], GetPaymentInformationCommand[SUCCESS][11ms], GetUserAccountCommand[SUCCESS, RESPONSE_FROM_CACHE][0ms]x2, GetOrderCommand[SUCCESS][78ms], CreditCardCommand[SUCCESS][1295ms]
Request => GetUserAccountCommand[FAILURE, FALLBACK_SUCCESS][6ms], GetPaymentInformationCommand[SUCCESS][11ms], GetUserAccountCommand[FAILURE, FALLBACK_SUCCESS, RESPONSE_FROM_CACHE][0ms]x2, GetOrderCommand[SUCCESS][153ms], CreditCardCommand[SUCCESS][1321ms]

This demo simulates 4 different HystrixCommand implementations with failures, latency, timeouts and duplicate calls in a multi-threaded environment.

It logs the results of HystrixRequestLog and metrics from HystrixCommandMetrics.

Dashboard

The hystrix-dashboard component of this project has been deprecated and moved to Netflix-Skunkworks/hystrix-dashboard. Please see the README there for more details including important security considerations.

Bugs and Feedback

For bugs, questions and discussions please use the GitHub Issues.

LICENSE

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot