clawbot
bd2bc9f626
Dockerfile.backend did not follow the Go multistage lint-stage pattern REPO_POLICIES.md mandates, and dragged the whole git history into the build context to resolve a version string. - Add an `AS lint` stage on the hash-pinned golangci/golangci-lint image (v2.7.2, the same golangci-lint commit main already pins), which ships Go, gofmt, make and the linter, so nothing is installed in it. It runs `make fmt-check` then `make lint`. - Add `COPY --from=lint /src/go.sum /dev/null` to the build stage so BuildKit cannot run the two stages in parallel and let a lint failure through. - Stop compiling golangci-lint from source in the build stage. - Drop `COPY .git /repo/.git`; the version now comes from `ARG VERSION=dev`, passed to the build via `make build VERSION=...`. - Drop gcc and musl-dev, and the corresponding `-linkmode external -extldflags -static` in backend/Makefile. The build is now `CGO_ENABLED=0 go build -trimpath` with `-ldflags "-s -w -X main.Version=... -X main.Buildarch=..."`, which is static without a C toolchain. - backend/Makefile's VERSION is now overridable and degrades to `dev` when git or .git is unavailable instead of emitting a git error and building an empty version string. - Every FROM stays pinned by @sha256 with a version and date comment. Runtime stage, exposed port and entrypoint are unchanged.
netwatch-server is an MIT-licensed Go HTTP backend by @sneak that receives telemetry reports from the NetWatch SPA and persists them as zstd-compressed JSONL files on disk.
Getting Started
# Build and run locally
make run
# Run tests, lint, and format check
make check
# Docker
docker build -t netwatch-server .
docker run -p 8080:8080 netwatch-server
Rationale
The NetWatch frontend collects latency measurements from the browser but has no
way to persist or aggregate them. This backend provides a minimal
POST /api/v1/reports endpoint that buffers incoming reports in memory and
flushes them to compressed files on disk for later analysis.
Design
The server is structured as an fx-wired Go application under cmd/netwatch-server/.
Internal packages in internal/ follow standard Go project layout:
config: Loads configuration from environment variables and config files via Viper.handlers: HTTP request handlers for the API (health check, report ingestion).reportbuf: In-memory buffer that accumulates JSONL report lines and flushes to zstd-compressed files when the buffer reaches 10 MiB or every 60 seconds.server: Chi-based HTTP server with middleware wiring and route registration.healthcheck,middleware,logger,globals: Supporting infrastructure.
Configuration
| Variable | Default | Description |
|---|---|---|
PORT |
8080 |
HTTP listen port |
DATA_DIR |
./data/reports |
Directory for compressed reports |
DEBUG |
false |
Enable debug logging |
Report storage
Reports are written as reports-<timestamp>.jsonl.zst files in DATA_DIR.
Each file contains one JSON object per line, compressed with zstd. Files are
created with O_EXCL to prevent overwrites.
TODO
- Add integration test that POSTs a report and verifies the compressed output
- Add report decompression/query endpoint
- Add metrics (Prometheus) for buffer size, flush count, report count
- Add retention policy to prune old report files
License
MIT. See LICENSE.