CodeBull - Dynamic Instrument Solution

Stop guessing. Start inspecting. Skip the rebuild. Check our website

Dynamic observability for Go. Inject logs, metrics, and traces into your running application directly from VS Code.

Features

Dynamic Logging

Inject log statements instantly to capture variable values. Get the data you need without polluting your source code or dirtying your git history.

Instant Metric

Instantly attach counters and gauges to any line of code. Track hit rates and variable trends without defining globals or registering metrics manually.

Raw Data Storage

CodeBull now uses a shared in-memory raw data store for both Log and Metric panels.

Log panel keeps full session records (no fixed-size truncation)
Metric panel keeps full session samples (no fixed-size point cap)
MCP codebull_read_panels includes rawDataStats for quick storage debugging

Instrument Point History Upload

The Monitor dashboard view uploads and visualizes a manual snapshot of history across all instrument points.

Use Generate monitor dashboard to create one dashboard for all current instrument points
Existing history data (up to 30 days) is uploaded only when you press Generate monitor dashboard
Use Open Dashboard to view the generated static report page

Plug and Play Profiling (Coming Soon)

Start and stop profiling sessions directly from VS Code. Analyze runtime performance without modifying your code or configuring external tools.

Tracing Everywhere (Coming Soon)

Inject traces on the fly. Visualize execution paths and measure function latency without modifying a single line of code.

Getting Started

Follow this step-by-step guide to master dynamic instrumentation in VS Code.

1. Installation

Search for "CodeBull" in the VS Code Marketplace and click Install. Ensure you have a Go project open.

2. Injecting Logs

Open any Go file. You will see CodeLens actions above your functions. Click "Set Log" to inject a log point. The IDE will automatically track the next execution.

3. Viewing Live Logs

Open the CodeBull Log panel. As your application runs, logs will stream in real-time without you having to rebuild or restart your app.

4. Visualizing Metrics

Click "Set Metric" via CodeLens. Select a variable to track. Open the CodeBull Metric panel to see real-time graphs of the variable's value over time.

MCP Agent Integration

CodeBull now includes a built-in MCP bridge server so VS Code agents can control tracepoints and read panel data.

MCP bridge settings

codebull.mcpEnabled (default: true)
codebull.mcpHost (default: 127.0.0.1)
codebull.mcpPort (default: 48765)

When enabled, the extension starts an HTTP MCP endpoint at:

http://127.0.0.1:48765/mcp

Health check:

http://127.0.0.1:48765/health

Tools exposed to MCP

codebull_register_tracepoint
- Input: { path, line, kind?, variableName? }
codebull_unregister_tracepoint
- Input: { path, line }
codebull_set_tracepoint_kind
- Input: { path, line, kind, variableName? }
codebull_list_tracepoints
- Input: {}
codebull_remove_all_tracepoints
- Input: {}
codebull_set_all_tracepoints_enabled
- Input: { enabled }
codebull_set_connection
- Input: { host, port }
codebull_check_connection
- Input: {}
codebull_health_check
- Input: {}
codebull_show_panel
- Input: { panel }, panel = log | metric | flamegraph | instrument | connection
codebull_read_panels
- Input: { limit? }, returns snapshots for connection/instrument/log/metric/flamegraph
codebull_read_raw_data
- Input: { logLimit?, metricLimit? }
codebull_reset_panel_data
- Input: { target? }, target = all | logs | metrics | flamegraph | analysis
codebull_plot_variable_trend
- Input: { variableName, startTime?, endTime? }
- Plots a line chart in Agent analysis panel

Example MCP client config (JSON)

{
	"mcpServers": {
		"codebull": {
			"transport": {
				"type": "http",
				"url": "http://127.0.0.1:48765/mcp"
			}
		}
	}
}

Agent call examples

Use these prompts directly in your VS Code agent chat after MCP is connected:

Use CodeBull MCP tool codebull_register_tracepoint with:
{
	"path": "main.go",
	"line": 42,
	"kind": "log"
}
Then focus the log panel.

Use CodeBull MCP tool codebull_register_tracepoint with:
{
	"path": "service/order.go",
	"line": 88,
	"kind": "metric",
	"variableName": "latencyMs"
}
Then focus the metric panel.

Read all panel snapshots

Use CodeBull MCP tool codebull_read_panels with:
{
	"limit": 100
}
Summarize connection status, instrument points, latest logs, and metric trends.

Unregister tracepoint

Use CodeBull MCP tool codebull_unregister_tracepoint with:
{
	"path": "service/order.go",
	"line": 88
}

Plot variable trend in Agent analysis panel

Use CodeBull MCP tool codebull_plot_variable_trend with:
{
	"variableName": "latencyMs",
	"startTime": "2026-03-08T00:00:00.000Z",
	"endTime": "2026-03-08T23:59:59.999Z"
}

Local smoke test (without agent)

You can verify MCP bridge responses directly with curl:

chmod +x ./scripts/mcp-smoke.sh
./scripts/mcp-smoke.sh

Requirements:

jq installed (used for pretty JSON output)
extension is running and MCP bridge is enabled

Optional custom target:

MCP_URL=http://127.0.0.1:48765/mcp PROJECT_PATH=main.go PROJECT_LINE=42 ./scripts/mcp-smoke.sh

Website | GitHub

CodeBull

0xbu11