Open-Source Observability · doganarif

GoVisual

GoVisual is a zero-configuration HTTP debugger for Go web development that wraps your HTTP handlers to capture and visualize every request, response, database query, logs, and panic in a local dashboard. It includes an MCP server mode to let AI coding agents (Claude Code, Cursor) inspect, replay, and diff requests against your running application.

Talk to DEV.co Discuss Implementation

Source: GitHub — github.com/doganarif/GoVisual

685

GitHub stars

Forks

Primary language

MIT

License (OSI-approved)

Key facts

Objective fields from the source. Values we can't verify are shown as “Unknown” rather than guessed.

Field	Value
Repository	doganarif/GoVisual
Owner	doganarif
Primary language	Go
License	MIT — OSI-approved
Stars	685
Forks	20
Open issues	6
Latest release	v2.0.0 (2026-07-02)
Last updated	2026-07-02
Source	https://github.com/doganarif/GoVisual

What GoVisual is

A pure-Go middleware library (MIT licensed, stdlib + pprof only in core) that captures per-request context: SQL queries via driver wrapping, outbound HTTP via RoundTripper wrapping, slog records, panics, and custom events. Modular design separates storage backends (postgres, redis, sqlite, mongodb), telemetry (OpenTelemetry), and MCP tooling into optional modules. Dashboard served over SSE; loopback-only by default with opt-in replay and basic auth.

Quickstart

Get the GoVisual source

Clone the repository and explore it locally.

terminalbash

1git clone https://github.com/doganarif/GoVisual.git2cd GoVisual3# follow the project's README for install & configuration

Need it deployed, integrated, or customized instead? DEV.co ships production installs.

Best use cases

Local development debugging with AI agents

Register the MCP endpoint with Claude Code or Cursor to let the agent autonomously inspect request/response pairs, replay them after code changes, and diff outcomes—accelerating fix validation.

Request-scoped observability during development

Trace SQL queries, outbound HTTP calls, and application logs back to the originating inbound request without external infrastructure; ideal for debugging race conditions and cascading failures.

Zero-config middleware addition to existing Go services

Single `Wrap()` call with optional arguments; no invasive code changes, no mandatory external backends, no startup boilerplate—drop it into any `net/http` handler and inspect the dashboard at `/__viz`.

Implementation considerations

Core module has zero external dependencies (only stdlib and google/pprof); storage, telemetry, and MCP are opt-in. Reduces transitive dependency risk if only using in-memory capture.
Driver wrapping for SQL (via sql.Register) and RoundTripper wrapping for outbound HTTP are transparent but require the application to already use context-aware calls; legacy code passing nil contexts will not capture those events.
Slog handler wrapping requires replacing the logger; not compatible with other structured logging libraries (logrus, zap) without writing custom wrappers or bridges.
MCP endpoint is loopback-only by default; enabling remote access or replay requires explicit configuration and SSRF checks are enforced but should be verified in your threat model.
Dashboard state (dark mode preference) persists to browser localStorage; no server-side session management, suitable only for local development on trusted machines.

When to avoid it — and what to weigh

Production traffic analysis at scale — Designed for local development; memory-bounded storage (100 requests by default), no native distributed tracing, dashboard is loopback-only by design. Not intended for SaaS or multi-tenant deployments.
Non-Go or non-http.Handler ecosystems — Go-specific middleware; requires wrapping `http.Handler` or `http.RoundTripper`. Incompatible with gRPC services (no native gRPC capture), Fastapi/Node/Java stacks, or custom protocol servers.
Strict performance budgets on every request — Adds latency and memory overhead for context capture, SQL wrapping, and slog handler delegation. Sample-rate option available but not a substitute for truly zero-cost observability in high-throughput scenarios.
Regulatory compliance or security-sensitive environments — Dashboard and MCP replay endpoint can expose request/response bodies, SQL queries, and application logs. Opt-in basic auth and replay controls exist but require active configuration; not certified for HIPAA, PCI-DSS, or similar.

License & commercial use

MIT License. Permissive; allows commercial use, modification, distribution, and private use with attribution and no liability. No copyleft obligations.

MIT is an OSI-approved permissive license. You may use GoVisual in commercial products and closed-source applications without payment or reciprocal licensing. No warranties are provided by the project; typical commercial use would add your own support/indemnification layer. Review for any embedded notices or trademark use in your product.

DEV.co evaluation signals

Editorial assessment — not user reviews. Directional, with an explicit confidence level.

Signal	Assessment
Maintenance	Active
Documentation	Adequate
License clarity	Clear
Deployment complexity	Low
DEV.co fit	Strong
Assessment confidence	High

Security considerations

Dashboard and MCP endpoint expose request/response bodies, SQL queries, slog output, and panic stacks. Loopback-only default mitigates remote exposure in development. Opt-in replay endpoint enforces base URL pinning to prevent SSRF to arbitrary hosts. Basic auth is available but not mandatory. No mention of input validation on replay payloads, query bounds, or SQL injection via captured data; review before exposing to untrusted network. Not suitable for capturing sensitive data (PII, credentials, payment info) without additional redaction logic.

Alternatives to consider

Delve (Go debugger)

Low-level stepping debugger; powerful but requires manual breakpoint setup and does not provide high-level request/response visualization or MCP integration for AI agents.

Jaeger (distributed tracing)

Production-grade observability with OpenTelemetry; requires external infrastructure (Jaeger backend), Collector, more overhead, and steeper learning curve. Better for multi-service deployments than local dev.

Fiddler / Postman

General-purpose HTTP inspection tools; require proxy setup and do not natively capture application logs, SQL, or panics; good for API testing but not request-scoped app observability.

Software development agency

Build on GoVisual with DEV.co software developers

Add GoVisual to your Go project with a single import. Connect Claude Code or Cursor via MCP to inspect, replay, and diff requests as you develop.

Talk to DEV.co

Related open-source tools

Surfaced by semantic similarity across the DEV.co open-source index.

opentelemetry-go opentelemetry-go-instrumentation go-grpc-middleware

Related on DEV.co

Explore the category and the services that help you build with it.

Open-Source Observability AI development Web app development API development Talk to DEV.co

GoVisual FAQ

Can I use GoVisual in production?

Not recommended. It is designed for local development. Memory-bounded storage, loopback-only dashboard by default, and lack of distributed tracing make it unsuitable for production traffic analysis. Use Jaeger, Datadog, or similar for production observability.

Does GoVisual work with non-http.Handler servers (e.g., gRPC, custom protocols)?

No. GoVisual wraps `net/http` handlers and RoundTrip interfaces. It does not natively support gRPC, WebSocket, or custom protocol servers. You would need to build custom instrumentation for those.

What is the performance overhead?

Unknown; not quantified in the documentation. Context capture, driver wrapping, and slog delegation add latency and memory per request. Use the sample-rate option to reduce impact, but benchmark against your workload if latency is critical.

Can I redact sensitive data (passwords, tokens) from captures?

Not built-in. The tool captures raw request/response bodies and logs. You must either implement custom request/response filters upstream or avoid logging sensitive data via slog in the first place.

Software development & web development with DEV.co

Adopting GoVisual is usually one piece of a larger software development effort. As a software development agency, DEV.co provides software development services and web development expertise — pairing senior software developers and web developers with your team to design, build, and operate open-source observability software in production.

Debug Go HTTP requests with AI agents in real time.

Add GoVisual to your Go project with a single import. Connect Claude Code or Cursor via MCP to inspect, replay, and diff requests as you develop.

Talk to DEV.co Schedule a Consultation