Dashboard Analytics

The analytics summary covers every project you’re a member of and is computed when you load it. The Dashboard home page shows the headline counts (open, in progress and resolved bugs, and your projects); GET /api/analytics/dashboard returns the full breakdown:

• Bugs by status — open, in_progress, resolved, closed, wont_fix
• Bugs by priority — critical, high, medium, low
• Bugs by category — crash, visual, gameplay, performance, audio, ui, network, other
• Daily bug volume — new reports per day
• Average resolution time in hours
• Top reporters

Per-project charts — report volume, categories, platforms, response time by priority, top reporters and satisfaction — are on the Game Health page.

Crash Analytics & Session Tracking

Bugnet SDKs automatically track game sessions and crash events, giving you deep visibility into your game's stability across platforms and versions.

How It Works

1. Session Start — When the game launches, the SDK calls POST /api/sessions/start with a unique session token, platform, game version, and device info.
2. Crash Detection — On an uncaught error or crash, the SDK marks the session as crashed via POST /api/sessions/end with crashed: true.
3. Clean Exit — On normal shutdown, the SDK calls the same endpoint with crashed: false.

Key Metrics

• Crash-Free Rate — Percentage of sessions without a crash. Target: 99.5%+.
• Daily Trend — 30-day chart of crash-free rate over time.
• Platform Breakdown — Crash rates by the platform string your game reports.
• Version Comparison — Compare crash rates across game versions to spot regressions.
• Top Crash Signatures — Most frequent crashes grouped by fingerprint for faster debugging.

Custom Engine Integration

If you are using a custom engine without an official SDK, you can integrate session tracking directly via the REST API:

# Start a session
POST /api/sessions/start
{"api_key":"sk_live_...","session_token":"unique-id","platform":"Windows","game_version":"1.2.0"}

# End a session (clean exit)
POST /api/sessions/end
{"api_key":"sk_live_...","session_token":"unique-id","crashed":false}

# End a session (crash detected)
POST /api/sessions/end
{"api_key":"sk_live_...","session_token":"unique-id","crashed":true}

View crash analytics in the Game Health dashboard tab.

Session Replays

Watch what a player was doing just before a bug report. When session capture is on, the SDK keeps a short recording of recent gameplay and uploads it with each report.

How It Works

1. Turn on Session Capture on the project’s card on the Projects page (Studio Plus only)
2. The SDK reads the setting on init and starts recording
3. When a bug report is submitted, the recording is uploaded to POST /api/session-replays
4. Watch it in the bug’s detail panel

Recording Format

• Web and Construct 3 — WebM video of the game canvas
• Unity and Godot — Animated GIF of recent frames
• Unreal — MP4 video
• GameMaker and Pygame — Animated GIF of the last 10 seconds (5 frames per second, up to 320 px wide)

Plan Enforcement

Session replays are only available on the Studio Plus plan. The server enforces this in two ways:

• The GET /api/bugs/settings endpoint returns session_capture: false for Indie and Studio projects, so SDKs never start recording
• The POST /api/session-replays endpoint rejects submissions from projects not on the Studio Plus plan
• Uploads may be up to 50 MB

Event Tracking

Track custom analytics events from your game — level completions, item purchases, achievement unlocks, and more. Event data is aggregated in the Bugnet dashboard with daily trends, platform breakdowns, and unique session counts.

How It Works

1. Track events — Call trackEvent() (or track_event()) from your game code with an event name and optional custom data.
2. Batch for efficiency — Use trackEvents() to send up to 50 events in a single request.
3. View in dashboard — Event names, counts, trends, and platform breakdowns appear under Analytics > Dashboard in the sidebar.

Payload Format

Each event includes these fields, most of which are set automatically by the SDK:

Plan Limits

API Endpoints

Live Logs

Live Logs (under Analytics in the dashboard sidebar) is a unified, chronological feed of everything happening inside your game — bug reports, tracked events, and team activity — merged into a single terminal-style timeline. Use it to debug issues in near-real time or audit what players were doing just before they hit a bug.

What's in the Feed

• Events — every custom event sent via trackEvent() / trackEvents(), with event name, platform, session, and custom data.
• Bug reports — new bugs filed from the SDK or web form, with severity, category, and player context.
• Activity — dashboard actions taken by team members (status changes, assignments, comments).

Filtering & Time Range

The feed can be filtered by entry type (All, Events, Bugs, Activity) and time window (24 hours, 7 days, 30 days, or 90 days). Entries are paginated and loaded on demand — click Refresh at any time to pull the latest.

Plan Availability

Live Logs is available on the Studio and Studio Plus plans. On the Indie (Free) plan, the Live Logs page shows an upgrade prompt instead of the feed, and GET /api/projects/:slug/log-stack returns 403.

API Endpoint

Release Health Monitor

Monitor the health of each game version at a glance and spot problem releases before they spread. Release health is shown on the Game Health page.

Per-Version Metrics

• Total, open, resolved, crash and critical bug counts for the version
• Crash-free session rate — from the sessions your SDK reports
• Health score (0–100) — starts at 100 and is reduced by the share of bugs still open, by crash and critical bugs, and by high bug volume
• Letter grade — a quick visual indicator derived from the health score
• First and latest report timestamps

API Endpoints

Performance Profiling

Capture detailed performance metrics alongside bug reports. Performance snapshots help you correlate bugs with hardware bottlenecks, frame drops, and resource spikes.

Available on the Studio plan and above.

Metrics Captured

• FPS — frames per second at the time of the report
• Frame time — time per frame in milliseconds
• Memory usage — current memory consumption in MB
• GPU usage — GPU utilization percentage
• CPU usage — CPU utilization percentage
• Draw calls — number of draw calls in the current frame
• Triangle count — total triangles rendered
• Network latency — round-trip time in milliseconds (for multiplayer games)
• Custom metrics — game-specific values you define (e.g., entity count, AI tick time)

Performance snapshots are attached to individual bug reports. You can also view the project-wide performance summary for trend analysis across all reports.

Submit performance data automatically via the SDK, or manually via the API:

Regression Detection

Bugnet looks for new bug reports that resemble bugs you already resolved, so you can catch fixes that didn’t stick.

How It Works

1. Open Game Health (or call the detect endpoint). Bugnet compares recent reports against resolved ones in the same project by title similarity, and lists likely matches with their game versions and a similarity score.
2. Your team reviews each match and confirms or dismisses it.
3. Confirmed and dismissed decisions are stored, so the list of regressions builds up over time.

Regression States

Matches you haven’t reviewed yet are only returned by the detect endpoint; they aren’t stored.

API Endpoints

Satisfaction Ratings

Record how satisfied a player was with the handling of their bug, and track the trend across your project. Ratings are recorded through the API — for example from your own support tool or a follow-up survey — and summarized on the Game Health page.

How It Works

• A rating is 1–5 with an optional comment, and can be recorded once a bug is resolved or closed
• Ratings are recorded with a session token, so they come from your team’s tooling rather than directly from players

Project-Level Summary

• Average rating and rating distribution (1 through 5)
• Monthly trend
• Average by category, and the lowest-rated bugs

API Endpoints

API Usage

See how much data your games are sending, to plan capacity and keep an eye on plan limits. Usage figures are available through the API:

• Bug submissions — total, today, last 7 days and last 30 days, per project
• Game sessions — sessions started in the last 30 days, per project
• Team size per project

Your plan’s limits and how much of them you’ve used are on the Billing page.

Alert Rules

Configure automated alerts based on metric thresholds. Bugnet checks your rules every hour and emails your team when one fires.

Alert Types

Configuration Options

• Metric to monitor — bug_spike, crash_rate or satisfaction_drop
• Threshold value — the value that must be exceeded (or dropped below) to fire
• Time window — evaluation period in hours (e.g., 1, 6, 24)
• Enable/disable toggle — temporarily silence an alert without deleting it

A fired alert emails the project’s members who have new bug emails turned on. Alerts don’t send webhooks or Discord messages.

API Endpoints

Auto-Triage

Auto-triage reads a report’s text and suggests how to handle it, so incoming reports need less manual sorting.

Available on the Studio plan and above.

Capabilities

• Suggested category and priority — inferred from keywords and severity indicators in the title and description, with a confidence score
• Suggested response — a draft reply you can send to the player
• Frustration level — how upset the reporter sounds (calm, frustrated, angry, furious)
• Potential duplicates — similar existing reports
• Crash grouping — clusters crash reports by normalized title to reduce noise
• Early churn warning — flags players whose recent reports suggest they may stop playing

On every plan, reports submitted with the default other category and medium priority are automatically recategorized and reprioritized from their text when they arrive (reports the SDK auto-captures from engine errors keep the SDK’s classification).

API Endpoints