locustio/locust
Locust
Locust is a distributed performance testing framework that allows users to define complex system stress scenarios using standard Python code. By modeling concurrent users as classes with weighted tasks and lifecycle hooks, it enables the simulation of realistic user behavior across large-scale environments. The tool functions as a scalable load generator capable of orchestrating traffic across multiple worker nodes to measure system stability and responsiveness under heavy, real-world conditions.
The framework is distinguished by its protocol-agnostic architecture, which supports diverse communication standards including HTTP, gRPC, and MQTT through modular client abstractions. It provides dynamic runtime traffic shaping, allowing users to adjust load intensity and task weighting programmatically while tests are active. A built-in web interface offers real-time monitoring of throughput, latency, and error rates, while also supporting custom authentication and UI extensions to meet specific operational requirements.
Beyond core simulation, the platform includes comprehensive observability features such as granular request logging, automated instrumentation, and the ability to stream telemetry data to external monitoring backends. It integrates into continuous delivery pipelines by supporting automated performance threshold validation and headless execution. The system is designed for flexibility, allowing for containerized deployment, cloud-based scaling, and the ingestion of external datasets to ensure varied and representative load testing scenarios.
Locust is distributed as a Python package and can be installed via standard package managers to support both local development and automated infrastructure-as-code environments.
Features
- Performance Testing - Provides a distributed performance testing framework that simulates concurrent users using Python scripts.
- Load Testing Tools - Simulates millions of concurrent users by executing user scenarios defined as Python code in a distributed environment.
- Load Testing Orchestrators - Manages the lifecycle and coordination of distributed worker nodes to execute large-scale performance simulations.
- Real-Time Monitoring Dashboards - Features a built-in web dashboard for real-time monitoring of throughput, latency, and error rates during load tests.
- Load Shaping - Enables dynamic adjustment of traffic intensity and user spawn rates to simulate realistic system stress patterns.
- Stress Testing Platforms - Orchestrates traffic generation across clusters of worker nodes to measure system stability under heavy, real-world load.
- Protocol-Agnostic Clients - Acts as a traffic simulation engine supporting multiple protocols to validate system responsiveness across diverse network architectures.
- Pacing Strategies - Controls task execution frequency using pacing strategies like constant throughput and randomized delays.
- CI/CD Pipeline Integrations - Automates performance validation by triggering load tests within continuous integration and deployment workflows.
- Distributed Orchestration - Coordinates traffic generation across multiple worker nodes using a central master controller for distributed load testing.
- Web Dashboards - Exposes a web-based dashboard for starting, stopping, and monitoring load tests with support for custom extensions.
- Asynchronous Simulation - Simulates high-concurrency user behavior using asynchronous requests to maintain low resource overhead.
- Programmatic Scenario Definition - Constructs test logic using standard programming patterns to simulate complex user behaviors.
- Infrastructure and Monitoring - Scalable load testing tool with a web-based interface.
- Load Testing - Scalable user load testing tool written in Python.
- 图形用户界面 - Listed in the “Graphical User Interfaces” section of the The Book Of Secret Knowledge awesome list.
- 测试框架 - Scalable user load testing tool.
- Testing Tools - Listed in the “Testing Tools” section of the Awesome Python awesome list.
- Web and GUI Testing - Scalable user load testing tool.
- Data Throughput Optimizers - Optimizes request throughput by utilizing efficient network clients that minimize memory and CPU consumption.
- Worker Scaling - Scales traffic generation capacity by dynamically coordinating multiple worker nodes across distributed environments.
- Protocol Testing - Supports performance testing for non-HTTP protocols like gRPC and MQTT via specialized client drivers.
- Threshold Monitoring - Configures automated exit conditions based on response metrics to integrate load testing into continuous delivery pipelines.
- User Interaction Simulation - Models concurrent users as classes with lifecycle hooks and weighted tasks to simulate realistic interaction patterns.
- Test Execution Runners - Supports command-line execution of performance tests without a graphical interface for automated environments.
- Test Suites - Aggregates multiple test definitions from local files or remote URLs to build modular simulation suites.
- Auto-Instrumentation - Generates spans and metrics automatically for HTTP traffic to provide visibility into request performance.
- Protocol-Agnostic User Classes - Enables connectivity to diverse protocols like SocketIO and DNS through modular, custom user classes.
- Task Weighting - Provides programmatic control to adjust task weighting and load intensity dynamically during active performance tests.
- Telemetry Collection and Aggregation - Aggregates and streams real-time performance metrics from distributed workers to external monitoring backends.
- AI Service Load Testing - Simulates traffic to AI services by tracking token consumption and response latency.
- Test Execution Management - Allows programmatic control over test execution environments and runners directly from custom scripts.
- Plugin Systems - Supports third-party plugins to extend core functionality with custom user types, protocols, and execution logic.
- Cloud Infrastructure Deployment - Enables execution of load testing scenarios on managed cloud infrastructure to simulate large-scale traffic.
- Containerized Deployments - Packages test scenarios and environments into container images for consistent performance testing across host systems.
- Connection Lifecycle Managers - Manages network connection lifecycles to accurately replicate browser traffic patterns and ensure realistic performance metrics.
- Concurrency Models - Uses lightweight asynchronous coroutines to simulate high concurrency with minimal resource overhead.
- Telemetry Protocols - Streams traces, metrics, and logs from load tests to external observability backends using standard protocols.
- Request Logging - Records granular, per-request data points to files for detailed post-run performance analysis.
- Test Fixture Management - Executes load tests using standard testing syntax and fixtures for easier debugging and reuse.
- Test Lifecycle Hooks - Provides hooks to execute custom logic during test initialization, start, and teardown phases.
- Performance Analysis - Provides diagnostic insights and automated recommendations based on collected test metrics.
- RESTful API Clients - Automates JSON parsing, header configuration, and error handling for REST endpoints during load tests.
