Ddosify — High-Performance Load Testing and Observability Platform

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/