How to build Rollbar dashboards in Metabase

{
  "mcpServers": {
    "rollbar": {
      "command": "npx",
      "args": ["@rollbar/mcp-server@latest"],
      "env": {
        "ROLLBAR_ACCESS_TOKEN": "your-project-access-token"
      }
    }
  }
}

# Install the Metabase CLI
npm install -g @metabase/cli

# Log in (opens your browser; requires Metabase v62+)
mb auth login --url https://your-metabase.example.com

# Load a error-groups-(items) export — creates a table AND a model
mb upload csv --file rollbar-error-groups-(items).csv --collection root

# Refresh that same table later from a new export
mb upload replace <table-id> --file rollbar-error-groups-(items).csv

Create a polished Metabase dashboard for Rollbar error monitoring analytics.
Work end to end: get the data into Metabase if it isn't there yet, then build.

Goal: Help engineering and operations leaders understand error inflow, release quality, user impact, and resolution speed from Rollbar data.

Step 1 — Find or load the data:
- First, check what already exists in Metabase (search for rollbar tables and
  models). If durable Rollbar data is already present — synced from a warehouse
  or uploaded earlier — use it and skip to Step 2.
- If nothing is there, pull a scoped, summarized export with the Rollbar MCP server:
  error groups (items), plus occurrence rollups, deploys, projects.
  Prefer aggregated or rollup views over raw events. Write each result to a CSV,
  then load it with the Metabase CLI — run "mb upload csv --file <export>.csv" so
  each upload creates a table and a ready-to-query model. Use "mb upload replace
  <table-id> --file <export>.csv" to refresh an existing table instead of creating
  duplicates.

Step 2 — Inspect before querying:
Do not assume exact table or column names. Inspect available fields, services,
environments, timestamps, and whether rollups or history exist before creating
duration or trend cards.

Important:
- Build on whatever data is present; don't claim Metabase connects natively to
  Rollbar — it reads a database or CLI-uploaded tables.
- Never try to load the raw event firehose into Metabase; use rollups, entity
  tables, and incident- or group-grain data.
- Only compute durations (MTTA, MTTR, time-to-resolve) when the required
  timestamps exist.
- Exclude test, staging, or muted objects from headline reliability cards, and
  segment by environment where the field exists.
- A single CSV is a point-in-time snapshot: only build trend cards if there is a
  usable date column or multiple periods have been uploaded.

Dashboard title: Rollbar Error Monitoring Overview

Sections:
1. Executive summary: Open error groups; New groups last 7 days; Regressions;
   Affected users last 7 days; Median time to resolve.
2. Inflow: New vs resolved error groups by week; error events by service.
3. Release quality: Error rate by release; new groups per release; crash-free rate
   if session data exists.
4. Impact: Top groups by affected users; unassigned groups; stale open groups.
5. Resolution: Time from first-seen to resolved; reopened/regressed groups.

Filters: Date range, Service, Environment, Severity, Team, Status.

Output: Build the dashboard if you have permission; otherwise provide the exact
questions, SQL, model definitions, and layout. Include caveats for any metric
that cannot be calculated from the available data.

Whether fixes are keeping up with inflow.

-- New groups bucket by first_seen_at; resolved groups bucket by resolved_at.
WITH new_groups AS (
  SELECT
    date_trunc('week', first_seen_at) AS week,
    COUNT(*) AS new_error_groups
  FROM error_groups
  WHERE environment = 'production'
  GROUP BY 1
),
resolved_groups AS (
  SELECT
    date_trunc('week', resolved_at) AS week,
    COUNT(*) AS resolved_error_groups
  FROM error_groups
  WHERE environment = 'production'
    AND resolved_at IS NOT NULL
  GROUP BY 1
)
SELECT
  COALESCE(n.week, r.week) AS week,
  COALESCE(n.new_error_groups, 0) AS new_error_groups,
  COALESCE(r.resolved_error_groups, 0) AS resolved_error_groups
FROM new_groups n
FULL OUTER JOIN resolved_groups r ON r.week = n.week
ORDER BY 1;

Release quality from rollups joined to release metadata.

SELECT
  r.version AS release,
  SUM(e.event_count) AS error_events,
  COUNT(DISTINCT e.error_group_id) AS distinct_groups,
  ROUND(
    1.0 * SUM(e.event_count) / NULLIF(MAX(r.sessions), 0), 4
  ) AS errors_per_session
FROM error_rollups e
JOIN releases r ON r.id = e.release_id
WHERE e.environment = 'production'
GROUP BY r.version
ORDER BY MIN(r.released_at) DESC;

The triage table: peak daily reach first (not a summed unique count).

SELECT
  g.title,
  g.service,
  -- affected_users is per daily window; MAX is peak daily reach, not a unique sum.
  MAX(e.affected_users) AS peak_daily_affected_users,
  SUM(e.event_count) AS events
FROM error_rollups e
JOIN error_groups g ON g.id = e.error_group_id
WHERE e.window_start >= CURRENT_DATE - INTERVAL '30 days'
  AND g.resolved_at IS NULL
GROUP BY g.title, g.service
ORDER BY peak_daily_affected_users DESC
LIMIT 20;