SkillFoxx

barrage skill

Skill and Go load tester that runs HTTP, database and Redis load on one clock and reports where the slowdown starts

  • 129 ★ on the repository
  • Last commit
Skill

Extended access

Why this level

  • Generates real load on the configured endpoints, databases and Redis.
All reasons and checks

codetesla51/barrageAuthor:codetesla51

Install

In your terminal, with SkillFoxx CLI

npx skillfoxx add skills/barrage

Detects the agents on your machine, shows the access level and pins the version.

Other ways to install

Access and checks

How we review

Extended accessThe tool runs code or makes network calls and only reads external data.

  • Generates real load on the configured endpoints, databases and Redis.

This is third-party code. Review the repository files before installing.

What it does

barrage is a Go tool that drives HTTP, database and Redis load at the same moment and records every layer's latency into shared time buckets. The report compares layers bucket by bucket and shows whether the application or the storage under it slowed down. The skill in `SKILL.md` walks an agent through the work: inspect the project, ask the user about goals, build a YAML config, run `barrage run` and interpret the result. The agent asks about missing details instead of guessing. `barrage compare` diffs two runs, and the report is a self-contained HTML page.

Who it is for. Backend developers and SREs hunting the bottleneck across an API, a database and a cache. Postgres, MySQL and SQLite work out of the box.

Good fit when

  • A service slows under load and it is unclear whether the app or the database is at fault.
  • You want a report that places API, database and Redis latencies on one timeline.
  • Before a release two runs are diffed with `barrage compare`.
  • Storage load is checked with failure injection through Toxiproxy.

Not a fit when

  • You need browser-level scenarios with user scripts.
  • The target is someone else's production system and you lack the owner's consent.
  • A one-off measurement of a single HTTP endpoint is enough.

Example request

Find the bottleneck: load the API and Postgres together and show when the database started slowing the app.

Limitations

The tool generates real load, so aim it at your own test environments and not at production without agreement. Database and Redis checks work only with connections configured in `config.yaml`. The install script downloads a prebuilt binary from GitHub releases; building from source needs Go 1.25 or later. The report loads Chart.js from a CDN while run data is embedded in the page. The agent follows the workflow in `SKILL.md`: inspect the project and ask questions first, then the config, so a fully unattended run is not intended.

How to disable. Delete the skill folder and the `barrage` binary from the directory the script used. Remove config and report files by hand.

FAQ

How do I install barrage?

Run `curl -fsSL https://raw.githubusercontent.com/codetesla51/barrage/main/install.sh | bash`. The script fetches a prebuilt binary from the releases, so Go is not required.

Which databases are supported?

Postgres, MySQL and SQLite. Another driver can be linked with a blank import because the layer sits on `database/sql`.

How is barrage different from a plain load test?

It records HTTP, database and Redis latencies into the same time buckets and flags the bucket where a storage layer spiked and whether the app was affected.

How do I compare two runs?

`barrage compare --baseline base.json --current new.json` shows the difference between results.

Does CI need a browser for the report?

No. The `--no-report --json results.json` flags write the result to a file without opening a page.

Discussion

No questions or reviews yet.

Skills

A skill teaching agents to write Go tests with the gotest framework: lifecycle hooks, parallelism and the CLI via go tool.

SkillMinimal access129

Caliper runs agent tasks with and without your skill, then shows whether the skill helps and how many tokens it costs

CLIExtended access232

A CLI to evaluate and evolve agent skills: declarative YAML cases, runs across engines and structured reports

CLIExtended access1.5K

A CLI and MCP for testing agent skills: repeatable YAML evals, report comparison, regression detection and skilled-improve

CLIExtended access72

A skill that reads a repository once and installs checks: code rules become gates that fail a commit or a CI run.

SkillExtended access180

A Rust HTTP load-testing tool with an MCP server: an agent runs a benchmark and gets latency percentiles and status breakdowns.

CLIBroad access146

README in short

The tool drives HTTP, database and Redis load on a shared timeline and writes an HTML report. Scenarios, rate and ramp live in `config.yaml`, and CI gets JSON output without a browser.

README badge

Original SKILL.md

---
name: barrage
description: Diagnose app slowness with barrage — run HTTP/DB/Redis/scenario load, correlate spikes to find bottlenecks, compare runs for regressions, estimate capacity. Use when a project is slow, when asked where latency comes from, or when working in the barrage repo itself.
---

# Barrage skill

Barrage is a Go CLI that answers one question: **when an app slows down, is it
the app, or the database / cache underneath it?** It fires HTTP, DB, and Redis
load on one clock, buckets every layer's latencies onto the same timeline, and
flags exactly which bucket a storage layer spiked in — and whether the app
felt it.

Use this skill whenever:

- someone says "the API is slow", "p99 is high", "it works locally but not
  under load", "find the bottleneck"
- you need to check a project for perf problems (N+1, missing index,
  pool exhaustion, cache miss, rate limiter, slow journey step)
- you need a before/after proof for a migration, tuning pass, or release
- you are editing the barrage repo itself

## Install / build

```sh
# preferred: prebuilt binary from GitHub releases (no Go needed)
curl -fsSL https://raw.githubusercontent.com/codetesla51/barrage/main/install.sh | bash

# pin a version, change the install dir, or build from source instead:
curl -fsSL https://raw.githubusercontent.com/codetesla51/barrage/main/install.sh | bash -s -- --version v0.7.2 --dir ~/.local/bin
curl -fsSL https://raw.githubusercontent.com/codetesla51/barrage/main/install.sh | bash -s -- --from-source

# from a checkout (requires Go 1.25+):
go build -o barrage ./cmd/barrage
go install github.com/codetesla51/barrage/cmd/barrage@latest  # fallback only
```

## Fastest run (30 seconds)

```sh
# 1. start the demo backend (login/me/products/orders/checkout on :8080)
go run ./cmd/demoserver &

# 2. run a canned profile against it
./barrage run -c examples/light.yaml
./barrage run -c examples/scenarios-weighted.yaml   # user journeys, not plain HTTP

# 3. artifacts land next to you
ls report.html results.json   # --report PATH, --json PATH, --no-report to skip
./barrage run -c config.yaml -o   # ...and open the report in a browser

Report a problem