k6

k6 embeds Sobek (a Go-based JavaScript runtime forked from Goja) to execute test scripts written in JavaScript, compiling them to bytecode and executing within isolated virtual user contexts. This approach combines Go's performance characteristics with JavaScript's expressiveness, enabling developers to write load tests as version-controlled code that integrates into CI/CD pipelines without requiring a separate Node.js runtime.

k6 provides native modules for HTTP, WebSocket, gRPC, and browser automation (via Chromium), each implementing protocol-specific request/response handling, connection pooling, and metrics collection. The module architecture uses a registry pattern where each protocol module implements a common interface, allowing developers to mix protocols within a single test script and share metrics across them.

k6 Cloud (Grafana's managed service) enables distributed load testing by uploading test scripts and orchestrating execution across multiple cloud regions. The cloud backend aggregates metrics from all regions, provides real-time dashboards, and stores results for historical comparison. Local k6 instances can also be coordinated via the Control API for on-premises distributed testing.

k6's k6/html module provides a Response.html() method that parses HTML responses and returns a Selection object supporting jQuery-like CSS selector queries. Developers can extract data from HTML (links, form fields, text content) using familiar selector syntax without manual regex or string parsing. This enables testing of server-rendered applications and web scraping scenarios within load tests.

k6's k6/ws module provides WebSocket client functionality with methods for connecting, sending/receiving messages, and handling connection events. The module supports text and binary frames, automatic reconnection, and event listeners (open, message, close, error). Metrics are collected for connection latency, message throughput, and error rates, enabling load testing of real-time services.

k6's k6/net/grpc module provides gRPC client functionality for unary calls, server streaming, client streaming, and bidirectional streaming. The module requires .proto definitions to be compiled into the test script and supports metadata, authentication, and custom interceptors. Metrics are collected for call latency, error rates, and streaming throughput, enabling load testing of gRPC microservices.

k6 supports parameterizing test scripts via environment variables and command-line flags, enabling test configuration without modifying script code. Environment variables are accessed via __ENV object in test scripts; command-line parameters are passed via --env flag (e.g., --env BASE_URL=https://api.example.com). This enables CI/CD integration where test parameters (API endpoint, load profile, credentials) are injected at runtime without script changes.

k6 manages virtual user (VU) instances through a lifecycle model where each VU executes setup code once, then runs a main test function repeatedly for a configured duration or iteration count, and finally executes teardown code. The Runner interface orchestrates VU creation, scheduling, and cleanup, with the Control API allowing runtime manipulation of VU count and execution state through REST endpoints.

k6 uses an executor-based system where load patterns (constant VU, ramping VU, stages, arrival rate) are defined declaratively in test options or via CLI flags. Each executor implements a scheduling strategy that determines how VUs are spawned, ramped, or maintained over time. The Execution Engine reads executor configurations and orchestrates VU lifecycle according to the specified pattern, supporting complex multi-stage scenarios without code changes.

k6 collects metrics during test execution (HTTP latency, error rates, custom metrics) and evaluates them against configurable thresholds at test completion. Metrics are aggregated by default (p95, p99 latencies) and can be tagged for fine-grained filtering. The threshold system supports expressions (e.g., 'p95 < 500') that determine test success/failure, enabling automated performance regression detection in CI/CD pipelines.

k6's HTTP module provides a chainable API (http.get(), http.post(), http.batch()) for constructing requests with headers, body, cookies, and TLS configuration. Responses are parsed into Response objects with properties for status, body, headers, and timings. The API supports response assertions (check() function) that validate status codes, body content, and custom conditions, with failures recorded as metrics without halting test execution.

k6 implements a custom module resolver that supports ES6 import/export syntax, allowing test scripts to import modules from local files (relative paths), npm-style packages (k6/* built-ins), and remote URLs (https://example.com/module.js). The resolver uses Sobek's module system to compile and cache modules, enabling code reuse and modularization without requiring npm or a build step.

k6 provides Counter, Gauge, Trend, and Rate metric types that developers can instantiate and update within test scripts. Metrics support tags (key-value pairs) for dimensional filtering and can be aggregated by tag values. The metrics system integrates with the threshold evaluation engine, allowing custom metrics to be included in pass/fail criteria and exported to external backends.

k6's HTTP module allows per-request TLS configuration including custom CA certificates, client certificates, and certificate pinning. The configuration is applied at the transport layer (Go's tls.Config) and supports hostname verification control, cipher suite selection, and minimum TLS version enforcement. This enables testing of services with self-signed certificates, mTLS requirements, and certificate pinning policies.

k6 supports multiple output backends (InfluxDB, Prometheus, Grafana Cloud, JSON, CSV) that receive metrics in real-time during test execution. The output system uses a plugin architecture where each backend implements a Collector interface that receives metric samples. Backends can be configured via CLI flags or environment variables, enabling metrics to be streamed to monitoring systems without code changes.

k6 is a modern, open-source load testing tool designed for developers, allowing them to write performance tests in JavaScript and execute them easily in CI/CD pipelines, making load testing as intuitive as writing unit tests.