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.
Supported Golang Versions
CodeBull currently supports the following Go versions:
We plan to expand compatibility coverage in future releases.
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.
CodeBull provides robust, high-performance data persistence and visualization across panels.
- Log panel keeps full session records (no fixed-size truncation) with advanced tooltip support.
- Metric panel keeps full session samples (no fixed-size point cap) and features a stunning glassmorphic UI.
- Fast data synchronization ensures your visualizations remain smooth and stable.
- 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 (Flamegraphs)
Capture full execution profiles instantly using Flamegraph tracepoints. CodeBull offers a powerful Flamegraph panel complete with regex, literal, and case-sensitive search functionality, allowing you to easily analyze stack traces and runtime performance.
Built-in AI Analysis (Coming Soon)
CodeBull features an integrated AI agent that autonomously analyzes your observability data. It reviews logs, metrics, and flamegraphs to deliver real-time insights directly into the Agent Analysis Panel.
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 Tracepoints
Open any Go file. You will see CodeLens actions above your functions providing clear toggles for Log, Metric, and Flamegraph tracepoints. Select your tracepoint type to opt-in to specific instrumentation without hijacking your native debugger.
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 to launch the Metric Wizard UI, explicitly selecting captured values and labels. Open the CodeBull Metric panel to see real-time graphs and trend analysis in a modern, glassmorphic UI.
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: 6666)
When enabled, the extension starts an HTTP MCP endpoint at:
http://127.0.0.1:6666/mcp
Health check:
http://127.0.0.1:6666/health
codebull_register_tracepoint
- Input:
{ path, line, kind?, variableName? }
codebull_unregister_tracepoint
codebull_set_tracepoint_kind
- Input:
{ path, line, kind, variableName? }
codebull_list_tracepoints
codebull_remove_all_tracepoints
codebull_set_all_tracepoints_enabled
codebull_set_connection
codebull_check_connection
codebull_health_check
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)
{
"servers": {
"codebull": {
"type": "http",
"url": "http://127.0.0.1:6666/mcp"
}
}
}
Agent call examples
Use these prompts directly in your VS Code agent chat after MCP is connected:
- Register log tracepoint
Use CodeBull MCP tool codebull_register_tracepoint with:
{
"path": "main.go",
"line": 42,
"kind": "log"
}
Then focus the log panel.
- Register metric tracepoint (track a variable)
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:6666/mcp PROJECT_PATH=main.go PROJECT_LINE=42 ./scripts/mcp-smoke.sh
Website | GitHub
