277 lines
7.5 KiB
Markdown
277 lines
7.5 KiB
Markdown
# 🚀 Stroke - Because Your Server Needs Some Exercise
|
|
|
|
[](https://golang.org)
|
|
[](LICENSE)
|
|
[](https://git.gostacks.org/iwasforcedtobehere/stroke)
|
|
|
|
> *"Why call it stress testing when you can call it therapeutic violence?"*
|
|
|
|
**Stroke** is a high-performance, concurrent stress testing tool built in Go that'll make your APIs sweat harder than a programmer during a code review. It's designed to pummel your services with requests until they either break or prove they're worthy of production.
|
|
|
|
## 🎯 What the Fuck Does This Thing Do?
|
|
|
|
- **Concurrent Chaos**: Spawns an army of goroutines to bombard your endpoints
|
|
- **Smart Rate Limiting**: Won't crash your server (unless you want it to)
|
|
- **Detailed Metrics**: Numbers that'll make your performance graphs look professional AF
|
|
- **Failure Injection**: Because sometimes you need to see how things break
|
|
- **Beautiful Reports**: Charts so pretty you'll want to frame them
|
|
|
|
## 🛠️ Installation
|
|
|
|
Because life's too short for complicated installations:
|
|
|
|
```bash
|
|
go install git.gostacks.org/iwasforcedtobehere/stroke/cmd/stroke@latest
|
|
```
|
|
|
|
Or if you're the type who likes to build from source (respect):
|
|
|
|
```bash
|
|
git clone https://git.gostacks.org/iwasforcedtobehere/stroke
|
|
cd stroke
|
|
go build -o stroke ./cmd/stroke
|
|
```
|
|
|
|
## 🚦 Quick Start
|
|
|
|
### Basic Usage (For the Impatient)
|
|
|
|
```bash
|
|
# Hit an endpoint 1000 times with 50 concurrent workers
|
|
stroke -url https://api.example.com/health -requests 1000 -concurrency 50
|
|
|
|
# Ramp up like a proper stress test
|
|
stroke -url https://api.example.com/users -requests 5000 -concurrency 100 -ramp-up 30s
|
|
|
|
# Go absolutely nuclear (use responsibly)
|
|
stroke -url https://api.example.com/heavy-endpoint -requests 10000 -concurrency 200 -duration 5m
|
|
```
|
|
|
|
### Configuration File (For the Organized)
|
|
|
|
Create a `stroke-config.yaml` because YAML is sexy:
|
|
|
|
```yaml
|
|
target:
|
|
url: "https://api.yourservice.com/api/v1/users"
|
|
method: "POST"
|
|
headers:
|
|
Content-Type: "application/json"
|
|
Authorization: "Bearer your-token-here"
|
|
body: |
|
|
{
|
|
"username": "testuser",
|
|
"email": "test@example.com"
|
|
}
|
|
|
|
load:
|
|
requests: 10000
|
|
concurrency: 100
|
|
duration: "5m"
|
|
ramp_up: "30s"
|
|
pattern: "ramp" # constant, ramp, spike
|
|
|
|
rate_limiting:
|
|
enabled: true
|
|
requests_per_second: 500
|
|
|
|
failure_injection:
|
|
enabled: true
|
|
network_delay: "10ms"
|
|
drop_rate: 0.05 # 5% packet loss
|
|
error_rate: 0.02 # 2% server errors
|
|
|
|
reporting:
|
|
format: ["console", "json", "html"]
|
|
output_dir: "./results"
|
|
percentiles: [50, 90, 95, 99]
|
|
```
|
|
|
|
Then run it like a boss:
|
|
|
|
```bash
|
|
stroke -config stroke-config.yaml
|
|
```
|
|
|
|
## 📊 What You Get
|
|
|
|
### Real-time Console Output
|
|
```
|
|
🚀 Stroke v1.0.0 - Server Stress Testing Tool
|
|
Target: https://api.example.com/users
|
|
Workers: 100 | Total Requests: 10000
|
|
|
|
Progress: [████████████████████████████████████████] 100% | 10000/10000
|
|
Duration: 45.2s | RPS: 221.24 | Errors: 0.2%
|
|
|
|
Response Times:
|
|
Min: 12ms | Max: 2.1s | Avg: 156ms
|
|
p50: 145ms | p90: 312ms | p95: 567ms | p99: 1.2s
|
|
|
|
Status Codes:
|
|
200: 9978 (99.8%)
|
|
500: 22 (0.2%)
|
|
|
|
Fuck yeah! Your API handled it like a champ! 💪
|
|
```
|
|
|
|
### Detailed Reports
|
|
|
|
Stroke generates comprehensive reports that won't make you want to cry:
|
|
|
|
- **JSON**: For when you need to integrate with other tools
|
|
- **HTML**: Beautiful graphs that make stakeholders happy
|
|
- **Prometheus**: Because monitoring is life
|
|
- **CSV**: For the Excel warriors
|
|
|
|
## 🏗️ Architecture
|
|
|
|
### Core Components
|
|
|
|
```
|
|
stroke/
|
|
├── cmd/stroke/ # CLI application entry point
|
|
├── pkg/
|
|
│ ├── engine/ # Core stress testing engine
|
|
│ ├── metrics/ # Performance metrics collection
|
|
│ ├── config/ # Configuration management
|
|
│ └── reporter/ # Report generation
|
|
├── internal/
|
|
│ └── ratelimit/ # Rate limiting implementation
|
|
└── examples/ # Example configurations
|
|
```
|
|
|
|
### Key Features
|
|
|
|
- **Goroutine Pool**: Efficiently manages concurrent workers
|
|
- **Channel-based Communication**: Because channels are fucking beautiful
|
|
- **Context Cancellation**: Graceful shutdowns (we're not animals)
|
|
- **Memory Efficient**: Won't eat your RAM like Chrome
|
|
- **Race Condition Free**: Tested with `-race` flag
|
|
|
|
## 🔥 Advanced Features
|
|
|
|
### Load Patterns
|
|
|
|
```bash
|
|
# Constant load (boring but effective)
|
|
stroke -pattern constant -rps 100
|
|
|
|
# Ramp up (like a good workout)
|
|
stroke -pattern ramp -start-rps 10 -end-rps 1000 -duration 5m
|
|
|
|
# Spike testing (shock therapy for your API)
|
|
stroke -pattern spike -base-rps 100 -spike-rps 1000 -spike-duration 30s
|
|
```
|
|
|
|
### Failure Injection
|
|
|
|
Because sometimes you need to see how things break:
|
|
|
|
```bash
|
|
# Add network chaos
|
|
stroke -network-delay 50ms -packet-loss 0.1
|
|
|
|
# Simulate server errors
|
|
stroke -error-injection 0.05 # 5% error rate
|
|
```
|
|
|
|
### Custom Scenarios
|
|
|
|
Write your own test scenarios in Go:
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"git.gostacks.org/iwasforcedtobehere/stroke/pkg/engine"
|
|
"git.gostacks.org/iwasforcedtobehere/stroke/pkg/config"
|
|
)
|
|
|
|
func main() {
|
|
cfg := &config.Config{
|
|
Target: config.Target{
|
|
URL: "https://api.example.com",
|
|
Method: "POST",
|
|
},
|
|
Load: config.Load{
|
|
Concurrency: 50,
|
|
Requests: 1000,
|
|
},
|
|
}
|
|
|
|
engine := engine.New(cfg)
|
|
results := engine.Run()
|
|
|
|
// Do whatever the fuck you want with the results
|
|
fmt.Printf("Average response time: %v\n", results.AvgResponseTime)
|
|
}
|
|
```
|
|
|
|
## 🧪 Testing
|
|
|
|
We take testing seriously (unlike some people):
|
|
|
|
```bash
|
|
# Run all tests
|
|
go test ./...
|
|
|
|
# Run with race detection (because data races are evil)
|
|
go test -race ./...
|
|
|
|
# Benchmark tests (for the performance nerds)
|
|
go test -bench=. ./...
|
|
|
|
# Coverage report (aim for >80% or you're doing it wrong)
|
|
go test -cover ./...
|
|
```
|
|
|
|
## 🤝 Contributing
|
|
|
|
Found a bug? Want to add a feature? Pull requests are welcome!
|
|
|
|
1. Fork it (you know how this works)
|
|
2. Create your feature branch (`git checkout -b feature/awesome-feature`)
|
|
3. Write tests (seriously, don't be that person)
|
|
4. Commit your changes (`git commit -am 'Add some awesome feature'`)
|
|
5. Push to the branch (`git push origin feature/awesome-feature`)
|
|
6. Create a Pull Request
|
|
|
|
### Code Style
|
|
|
|
- Use `gofmt` (if you don't, we can't be friends)
|
|
- Write meaningful commit messages
|
|
- Comment your code (future you will thank you)
|
|
- No magic numbers (constants are your friend)
|
|
|
|
## 📝 License
|
|
|
|
MIT License - because sharing is caring.
|
|
|
|
## 🙏 Acknowledgments
|
|
|
|
- The Go team for creating a language that doesn't make me want to quit programming
|
|
- Coffee, for making this project possible
|
|
- Stack Overflow, for obvious reasons
|
|
- My rubber duck, for listening to my debugging sessions
|
|
|
|
## 🐛 Known Issues
|
|
|
|
- May cause addiction to performance testing
|
|
- Your servers might actually become faster (side effect)
|
|
- Could make other load testing tools jealous
|
|
|
|
## 📞 Support
|
|
|
|
Having issues? Check these in order:
|
|
|
|
1. Read the fucking manual (this README)
|
|
2. Check the [examples](./examples/) directory
|
|
3. Search existing issues on [GitStacks](https://git.gostacks.org/iwasforcedtobehere/stroke/issues)
|
|
4. Create a new issue with details (and please include logs)
|
|
|
|
---
|
|
|
|
**Made with ❤️ and a healthy dose of sarcasm by [@iwasforcedtobehere](https://git.gostacks.org/iwasforcedtobehere)**
|
|
|
|
*"Stroke: Because your servers deserve to know their limits."* |