What goes in a Snowflake monitoring dashboard in Metabase?

A Snowflake monitoring dashboard tracks credits by warehouse, query duration percentiles, queue time, spill to local and remote storage, storage by type, and the queries responsible for the bill. Metabase connects to Snowflake natively, so every card is plain SQL over the account's own SNOWFLAKE.ACCOUNT_USAGE views — no exporter or agent in between.

What does a Snowflake monitoring dashboard look like?

Here’s the layout this guide builds. Account-level numbers and the month’s credit budget sit at the top; the middle section is performance — duration, queueing, warehouse load, and spill; the bottom section follows the money and the access, from credits per warehouse to the specific queries that dominate the total.

Which cards belong on a Snowflake monitoring dashboard?

Eight cards. Percentiles rather than averages for duration, queue time separated from execution time so the sizing decision is obvious, and spill split into local and remote — the difference is the difference between “busy” and “broken”.

• Query duration, p50 and p95 by day (line)
• Queue time vs. execution time by warehouse — average seconds of each (row)
• Warehouse load by hour — average running against average queued (area)
• Queries spilling to disk per day, local vs. remote (bar)
• Credits consumed by warehouse per day, compute plus cloud services (stacked bar)
• Logins and failed logins per day (combo)
• Storage by type — active, Time Travel, Fail-safe, stage (donut)
• Top queries by credits consumed, with warehouse, estimated cost, and remote spill (table)

What data does the dashboard need?

• SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY — one row per query: total_elapsed_time, queued_overload_time, bytes_spilled_to_local_storage and bytes_spilled_to_remote_storage, warehouse, user, role, error_code, and query text.
• WAREHOUSE_METERING_HISTORY — hourly credits_used_compute and credits_used_cloud_services per warehouse, the basis for every cost card.
• STORAGE_USAGE and TABLE_STORAGE_METRICS for active, Time Travel, Fail-safe, and stage bytes — and for the tables driving each.
• LOGIN_HISTORY for logins, failures, and client type, and METERING_DAILY_HISTORY to reconcile estimated cost against what Snowflake actually billed.
• INFORMATION_SCHEMA.WAREHOUSE_LOAD_HISTORY() for the running vs. queued load card — it is near real time, where ACCOUNT_USAGE lags.
• Your effective credit price, stored once in a model, so credits-to-dollars math never varies by card.

How do you build it?

1. Connect Snowflake to Metabase with a dedicated read-only role, granted IMPORTED PRIVILEGES on the SNOWFLAKE database so it can read ACCOUNT_USAGE.
2. Point the dashboard’s connection at a small, dedicated warehouse with a short auto-suspend — otherwise the monitoring keeps a large warehouse awake and shows up in its own credit chart.
3. Model the join once: daily credits per warehouse from WAREHOUSE_METERING_HISTORY, daily query stats from QUERY_HISTORY, and one credit-price constant. Every card reads the model.
4. Build the credits and top-queries cards first — they pay for the dashboard — then queue time, spill, and warehouse load, which tell you what to change.
5. Add filters for warehouse, user or role, and date range, and alert the platform channel when daily credits or remote-spilling queries cross their threshold.

Example card SQL

WITH credits AS (
SELECT
  DATE_TRUNC('day', start_time)          AS day,
  warehouse_name,
  SUM(credits_used_compute)              AS credits_compute,
  SUM(credits_used_cloud_services)       AS credits_cloud
FROM SNOWFLAKE.ACCOUNT_USAGE.WAREHOUSE_METERING_HISTORY
WHERE start_time >= DATEADD('day', -14, CURRENT_TIMESTAMP())
GROUP BY 1, 2
),
queries AS (
SELECT
  DATE_TRUNC('day', start_time)                              AS day,
  warehouse_name,
  COUNT(*)                                                   AS queries,
  ROUND(APPROX_PERCENTILE(total_elapsed_time, 0.95) / 1000, 1) AS p95_s,
  ROUND(AVG(queued_overload_time) / 1000, 2)                 AS avg_queue_s,
  COUNT_IF(bytes_spilled_to_local_storage  > 0)              AS local_spills,
  COUNT_IF(bytes_spilled_to_remote_storage > 0)              AS remote_spills
FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY
WHERE start_time >= DATEADD('day', -14, CURRENT_TIMESTAMP())
  AND warehouse_name IS NOT NULL
GROUP BY 1, 2
)
SELECT
c.day,
c.warehouse_name,
q.queries,
q.p95_s,
q.avg_queue_s,
q.local_spills,
q.remote_spills,
ROUND(c.credits_compute + c.credits_cloud, 2)          AS credits,
ROUND((c.credits_compute + c.credits_cloud) * 3.00, 2) AS est_cost_usd
FROM credits c
LEFT JOIN queries q
ON q.day = c.day AND q.warehouse_name = c.warehouse_name
ORDER BY c.day, credits DESC;

Related

Metrics

Integrations

Dashboards

FAQ