# Ddosify — High-Performance Load Testing and Observability Platform

> Ddosify is a high-performance load testing tool written in Go that supports HTTP, HTTPS, HTTP/2, gRPC, and GraphQL protocols, with scenario-based testing and distributed execution.

## Install

Save as a script file and run:

# Ddosify — High-Performance Load Testing and Observability Platform

## Quick Use
```bash
# Install via Go
go install go.ddosify.com/ddosify@latest
# Simple load test: 1000 requests over 10 seconds
ddosify -t https://api.example.com -n 1000 -d 10
# Run a scenario-based test from a JSON config
ddosify -config scenario.json
# Docker alternative
docker run ddosify/ddosify -t https://api.example.com -n 500 -d 5
```

## Introduction
Ddosify is a load testing tool built in Go for high-performance HTTP/HTTPS, HTTP/2, gRPC, and GraphQL testing. It allows you to create multi-step test scenarios with dynamic variables, assertions, and correlation between steps. Ddosify is designed for both simple one-liner load tests and complex multi-endpoint scenario testing that mirrors real user workflows.

## What Ddosify Does
- Generates high-throughput load against HTTP, HTTPS, HTTP/2, gRPC, and GraphQL endpoints
- Supports multi-step scenarios with data passing between steps through dynamic variables and extractors
- Provides configurable load patterns including linear, incremental, and waved request distributions
- Runs distributed tests across multiple agents for large-scale load generation
- Outputs real-time metrics including latency percentiles, success rates, and error breakdowns

## Architecture Overview
Ddosify is built as a single Go binary using goroutines for concurrent request generation. Each test scenario is defined as a JSON configuration containing steps with request definitions, assertions, and variable extractors. The engine processes steps sequentially per virtual user while running multiple virtual users concurrently. For distributed testing, a controller coordinates multiple engine instances. Results are aggregated and displayed in real time with percentile breakdowns.

## Self-Hosting & Configuration
- Install as a single binary via Go, Homebrew, Docker, or download from GitHub releases
- Define scenarios in JSON with steps, headers, body templates, and environment variables
- Configure load shapes by specifying request count, duration, and load type (linear, incremental, waved)
- Use environment variable files to parameterize tests across different environments
- Set up distributed testing by deploying multiple Ddosify engine instances behind a controller

## Key Features
- Single binary with zero dependencies — no JVM, no runtime, no complex setup
- Scenario-based testing with correlation: extract values from one response and inject them into the next request
- Assertion engine validates response status codes, body content, and headers at each step
- Multiple load patterns let you simulate gradual ramp-up, spike, or sustained traffic
- Protocol-native support for gRPC with protobuf definitions and GraphQL queries

## Comparison with Similar Tools
- **k6** — JavaScript-based load testing with scripting flexibility, but requires a JS runtime and has a steeper learning curve for simple tests
- **wrk** — Extremely fast HTTP benchmarking tool but lacks scenario support, assertions, and protocol variety
- **Locust** — Python-based distributed load testing with a web UI, but lower raw throughput per instance
- **Vegeta** — Constant-rate HTTP attack tool in Go, but limited to single-step requests without scenario chaining
- **Artillery** — YAML-defined load testing with plugin ecosystem, but Node.js-based with higher resource overhead

## FAQ
**Q: How many requests per second can Ddosify generate?**
A: On a single machine, Ddosify can generate tens of thousands of RPS depending on the target latency and hardware. Its Go-based engine is optimized for minimal memory allocation per request.

**Q: Can I test gRPC services?**
A: Yes. Provide the protobuf definition file and service method in the scenario configuration. Ddosify handles serialization and deserialization natively.

**Q: How do I pass data between steps in a scenario?**
A: Use extractors (JSONPath, regex, XPath) to capture values from a response, then reference those captured variables in subsequent step URLs, headers, or bodies using template syntax.

**Q: Is there a web UI for viewing results?**
A: The open-source CLI outputs results to the terminal. The Ddosify platform (Anteon) provides a web-based dashboard for result visualization and team collaboration.

## Sources
- https://github.com/ddosify/ddosify
- https://docs.ddosify.com/

---
Source: https://tokrepo.com/en/workflows/asset-29171f0e
Author: Script Depot