$ show tag1consulting/goose
Goose is a high-performance, Rust-based load testing framework designed to simulate realistic HTTP/HTTPS user traffic. It functions as both a reusable library and a CLI tool, allowing developers to write load tests in Rust that are compiled into standalone binaries. The architecture relies on the Tokio async runtime for efficient concurrency, utilizing flume channels to decouple virtual user threads from the main metrics aggregation process. It supports complex test scenarios including weighted transactions, session data management, and custom protocol simulation (TCP, WebSocket, gRPC). The framework distinguishes itself through rigorous metric accuracy, specifically implementing mitigation strategies for Coordinated Omission (CO) to prevent misleading latency data during server stalls. It provides extensive reporting capabilities, generating HTML reports with ECharts visualizations, JSON metrics for CI/CD integration, and PDF reports via headless Chrome. Runtime control is available through Telnet and WebSocket interfaces, allowing test parameters to be adjusted dynamically without stopping the load generation. While the core library is stable and well-architected, the project exhibits signs of active but evolving development. The distributed testing feature (Gaggle) was removed and is currently being re-implemented, indicating ongoing architectural shifts. The project maintains a comprehensive documentation suite via mdBook but faces challenges in synchronizing documentation across multiple locations (README, CHANGELOG, mdBook, inline code). The AI-assisted development workflow relies on external APIs that may introduce dependency risks if those services change. For engineers evaluating reuse, Goose offers a robust foundation for performance testing with strong type safety guarantees in its client builder. The Coordinated Omission mitigation logic is a unique, high-value component for teams concerned with metric accuracy. However, users should be aware of the optional PDF dependency (Chrome) and the current instability of the distributed testing mode. The codebase is suitable for integration into CI/CD pipelines or as a library for custom performance validation tools.
The LLM identified 4 files worth highlighting for reuse:
Implements a type-safe HTTP client configuration using the type state pattern. By using phantom types (CookiesEnabled/CookiesDisabled), it enforces compile-time safety regarding cookie configuration, preventing invalid client states. This is a reusable pattern for building robust, self-documenting APIs in Rust where state transitions must be validated at compile time.
Contains the core logic for detecting and mitigating Coordinated Omission artifacts in load testing metrics. It tracks request cadence to identify upstream server stalls and injects synthetic measurements to correct latency histograms. This solves a specific, non-obvious problem in performance testing that standard tools often ignore, making it a valuable standalone algorithm for metric accuracy.
Provides a runtime control interface via Telnet and WebSocket to manage the load test lifecycle (start, stop, adjust users). It uses an extensible command pattern (ControllerCommand enum) to handle dynamic interactions without restarting the test. This allows for real-time performance tuning and is reusable for any long-running async process requiring external control.
Manages complex load patterns including ramp-up, steady state, and ramp-down phases via a structured test plan. It implements a state machine (AttackPhase) to handle transitions between load levels and validates compatibility between different configuration flags. This component encapsulates the logic for realistic traffic simulation, reusable for any load testing scenario requiring non-constant user counts.