SELECT COUNT(*)
FROM branches
WHERE project_id = :project_id
  AND status IN ('creating', 'active', 'expired');

{
  "error": "BRANCH_LIMIT_REACHED",
  "message": "Project has reached the maximum of 10 active branches.",
  "limit": 10,
  "current": 10,
  "retry_after": null
}

sq_<app_key>_<env>_br_<slug>

sq_payments_staging_br_fix-checkout-bug-very-long-name
│              │         │
│  48 max      │ 7 max   │ 48 max
│              │         │
└──────── Total: 63 chars max ──────────────────────┘

-- Run on the Postgres cluster for each branch database
SELECT pg_database_size('sq_payments_prod') AS main_bytes;

SELECT pg_database_size('sq_payments_prod_br_fix-checkout-bug') AS branch_bytes;

project_storage = Σ pg_database_size(branch_database) for all active branches

                    0%                    80%                   100%
                    │                      │                      │
  Normal operation  │    Warning emitted   │   Writes blocked     │
  ◄─────────────────┼──────────────────────┼──────────────────────►
                    │                      │                      │
                    │  ┌───────────────┐   │  ┌───────────────┐   │
                    │  │ ALERT_EMAIL   │   │  │ WRITE_BLOCKED │   │
                    │  │ sent to team  │   │  │ error on      │   │
                    │  │               │   │  │ INSERT/UPDATE │   │
                    │  └───────────────┘   │  └───────────────┘   │

{
  "event": "STORAGE_WARNING",
  "project_id": "proj_a1b2c3d4",
  "storage_used_gib": 0.21,
  "storage_quota_gib": 0.25,
  "usage_percent": 84.0,
  "timestamp": "2025-03-20T14:00:00Z"
}

-- Applied automatically by the control plane
ALTER ROLE payments_prod_rw SET default_transaction_read_only = on;
ALTER ROLE payments_prod_ro SET default_transaction_read_only = on;

curl -X PATCH https://gateway.axiomdb.io/v1/projects/proj_a1b2c3d4 \
  -H "Authorization: Bearer paseto_v4_..." \
  -H "Content-Type: application/json" \
  -d '{ "storage_quota_gib": 2.0 }'

-- CPU time per database
SELECT
  datname,
  sum(total_time) AS cpu_seconds,
  sum(calls) AS total_calls
FROM pg_stat_statements
WHERE datname = current_database()
GROUP BY datname;

-- Active connections
SELECT COUNT(*)
FROM pg_stat_activity
WHERE datname = current_database()
  AND state = 'active';

SELECT pg_database_size(current_database()) AS size_bytes,
       pg_size_pretty(pg_database_size(current_database())) AS size_pretty;

SELECT
  schemaname || '.' || tablename AS table_name,
  pg_size_pretty(pg_total_relation_size(schemaname || '.' || tablename)) AS total_size,
  pg_size_pretty(pg_relation_size(schemaname || '.' || tablename)) AS table_size,
  pg_size_pretty(pg_total_relation_size(schemaname || '.' || tablename) - pg_relation_size(schemaname || '.' || tablename)) AS index_size
FROM pg_tables
WHERE schemaname = 'public'
ORDER BY pg_total_relation_size(schemaname || '.' || tablename) DESC;

SELECT
  indexname,
  pg_size_pretty(pg_relation_size(indexname::regclass)) AS index_size
FROM pg_indexes
WHERE schemaname = 'public'
ORDER BY pg_relation_size(indexname::regclass) DESC
LIMIT 10;

SELECT
  schemaname || '.' || relname AS table_name,
  n_dead_tup,
  n_live_tup,
  round(n_dead_tup::numeric / GREATEST(n_live_tup, 1) * 100, 2) AS dead_pct
FROM pg_stat_user_tables
WHERE n_dead_tup > 1000
ORDER BY n_dead_tup DESC;

SELECT
  schemaname || '.' || tablename AS table_name,
  pg_size_pretty(pg_total_relation_size(schemaname || '.' || tablename)) AS total_size,
  n_dead_tup,
  n_live_tup,
  CASE WHEN n_live_tup > 0
    THEN round(n_dead_tup::numeric / n_live_tup * 100, 2)
    ELSE 0
  END AS bloat_pct
FROM pg_stat_user_tables
JOIN pg_tables USING (schemaname, tablename)
WHERE schemaname = 'public'
ORDER BY pg_total_relation_size(schemaname || '.' || tablename) DESC;

-- Comprehensive branch health check
SELECT
  'storage' AS metric,
  pg_size_pretty(pg_database_size(current_database())) AS value
UNION ALL
SELECT
  'active_connections',
  COUNT(*)::text
FROM pg_stat_activity
WHERE datname = current_database() AND state = 'active'
UNION ALL
SELECT
  'total_tables',
  COUNT(*)::text
FROM information_schema.tables
WHERE table_schema = 'public'
UNION ALL
SELECT
  'cache_hit_ratio',
  round(
    sum(heap_blks_hit)::numeric / GREATEST(sum(heap_blks_hit) + sum(heap_blks_read), 1),
    4
  )::text
FROM pg_statio_user_tables;

X-RateLimit-Limit: 1000
X-RateLimit-Remaining: 987
X-RateLimit-Reset: 1710940800

{
  "error": "RATE_LIMITED",
  "message": "Too many requests. Try again in 45 seconds.",
  "retry_after": 45
}