go-fault
A Go HTTP middleware library for injecting faults like latency, errors, and request rejection into services for resilience testing.
What is go-fault?
Fault is a Go library that provides HTTP middleware for injecting controlled faults into web services. It enables developers to simulate failure scenarios like latency spikes, HTTP errors, and request rejection to test system resilience and error handling. The package integrates seamlessly with standard Go HTTP handlers and allows fine-grained control over when and where faults are injected.
Go developers building HTTP services who need to test failure resilience, particularly those working on microservices architectures or distributed systems where fault tolerance is critical.
Developers choose Fault for its simple middleware-based approach, minimal performance overhead when disabled, and built-in injectors for common failure scenarios without requiring external dependencies or complex setup.
Overview
go fault injection library
Use Cases
Best For
- Testing service resilience against latency spikes in production-like environments
- Simulating backend HTTP errors to verify client error handling
- Validating circuit breaker and retry logic in microservices architectures
- Performing chaos engineering experiments in Go-based HTTP services
- Creating controlled failure scenarios for disaster recovery testing
- Benchmarking system performance under partial failure conditions
Not Ideal For
- Simulating dropped requests where no HTTP response is sent (e.g., network timeouts or connection resets)
- Non-Go projects or services not built on Go's standard net/http package
- Chaos engineering requiring automated, multi-service fault injection with integrated monitoring
- Testing failure scenarios beyond HTTP layers, such as database or filesystem errors
Pros & Cons
Pros
Benchmarks in the README show negligible overhead when faults are disabled (e.g., 1771 ns/op vs 1734 ns/op without faults), making it safe for production use.
Seamlessly works with standard Go HTTP handlers, as shown in the usage example where a fault wraps a main handler with a few lines of code.
Supports percentage-based participation and path filtering (e.g., blocklisting /ping and /health), allowing targeted fault injection without affecting critical endpoints.
Separates injectors for failures and fault logic for execution, prioritizing safety and minimal disruption during normal operation, per the philosophy section.
Cons
Only handles HTTP-based failures via middleware; it cannot simulate other system-level faults like network partitioning or database outages without custom extensions.
The README admits the RejectInjector always sends a response, so simulating truly dropped requests requires a workaround with a SlowInjector, which may not be realistic.
Lacks integrated dashboards or alerting for chaos engineering experiments, requiring developers to manually track and analyze fault injection effects.
Tightly coupled to Go's HTTP stack, so it's not suitable for polyglot microservices or projects using other languages without significant adaptation.
Frequently Asked Questions
Related Projects
CORSGo net/http configurable handler to handle CORS requests
TollboothSimple middleware to rate-limit HTTP requests.
LimiterDead simple rate limit middleware for Go.
ln-paywallGo middleware for monetizing your API on a per-request basis with Bitcoin and Lightning ⚡️
Found a gem we're missing?
Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.