Dashboard → Analytics → Query Performance

Sort by:
- Slowest queries (high response time)
- Most frequent queries (optimization impact)
- Highest error rate (reliability issues)

-- Analyze query plan
EXPLAIN ANALYZE SELECT * FROM orders WHERE user_id = 123;

Seq Scan on orders  (cost=0.00..1000.00 rows=100 width=200)
  Filter: (user_id = 123)
  Rows Removed by Filter: 9900

Index Scan using idx_orders_user_id on orders  (cost=0.00..10.00 rows=100 width=200)
  Index Cond: (user_id = 123)

CREATE TABLE performance_log (
  id SERIAL PRIMARY KEY,
  endpoint VARCHAR(255),
  method VARCHAR(10),
  response_time_ms INTEGER,
  query_count INTEGER,
  created_at TIMESTAMP DEFAULT NOW()
);

// At start of endpoint
now() as $start_time

// ... endpoint logic ...

// At end of endpoint
now() - $start_time as $duration_ms

db.add performance_log {
  endpoint = $request.path,
  method = $request.method,
  response_time_ms = $duration_ms,
  query_count = $query_count
}

-- Average response time by endpoint
SELECT 
  endpoint,
  AVG(response_time_ms) as avg_time,
  MAX(response_time_ms) as max_time,
  COUNT(*) as request_count
FROM performance_log
WHERE created_at > NOW() - INTERVAL '24 hours'
GROUP BY endpoint
ORDER BY avg_time DESC;

-- Hourly performance trends
SELECT 
  date_trunc('hour', created_at) as hour,
  AVG(response_time_ms) as avg_time,
  COUNT(*) as requests
FROM performance_log
GROUP BY hour
ORDER BY hour DESC;

// Error log table
// id, level, message, context, stack_trace, user_id, created_at

try {
  // Risky operation
  db.query some_table { filter = "id = ?", var.id } as $result
} catch ($error) {
  db.add error_log {
    level = "error",
    message = $error.message,
    context = {
      endpoint: $request.path,
      input: var,
      user_id: $auth.id
    } | json_encode,
    stack_trace = $error.stack,
    user_id = $auth.id
  }
  
  throw $error  // Re-throw after logging
}

-- Error frequency by type
SELECT 
  message,
  COUNT(*) as occurrences,
  MAX(created_at) as last_seen
FROM error_log
WHERE level = 'error'
AND created_at > NOW() - INTERVAL '7 days'
GROUP BY message
ORDER BY occurrences DESC;

-- Errors by user
SELECT 
  user_id,
  COUNT(*) as error_count
FROM error_log
WHERE created_at > NOW() - INTERVAL '24 hours'
GROUP BY user_id
HAVING COUNT(*) > 5
ORDER BY error_count DESC;

-- Table sizes
SELECT 
  relname as table_name,
  pg_size_pretty(pg_total_relation_size(relid)) as total_size,
  pg_size_pretty(pg_relation_size(relid)) as table_size,
  pg_size_pretty(pg_total_relation_size(relid) - pg_relation_size(relid)) as index_size
FROM pg_catalog.pg_statio_user_tables
ORDER BY pg_total_relation_size(relid) DESC;

-- Index usage (find unused indexes)
SELECT 
  schemaname,
  tablename,
  indexname,
  idx_scan as times_used,
  idx_tup_read as rows_read
FROM pg_stat_user_indexes
ORDER BY idx_scan ASC;

-- Indexes never used (candidates for removal)
SELECT indexname, tablename
FROM pg_stat_user_indexes
WHERE idx_scan = 0;

-- Approximate row counts (fast)
SELECT 
  relname as table_name,
  reltuples::BIGINT as row_count
FROM pg_class
WHERE relkind = 'r'
ORDER BY reltuples DESC;

-- Current database connections
SELECT 
  state,
  COUNT(*) as connection_count
FROM pg_stat_activity
WHERE datname = current_database()
GROUP BY state;

-- Long-running queries
SELECT 
  pid,
  now() - pg_stat_activity.query_start as duration,
  query,
  state
FROM pg_stat_activity
WHERE (now() - pg_stat_activity.query_start) > interval '30 seconds'
AND state != 'idle';

-- Check for blocking locks
SELECT 
  blocked.pid as blocked_pid,
  blocked.query as blocked_query,
  blocking.pid as blocking_pid,
  blocking.query as blocking_query
FROM pg_stat_activity blocked
JOIN pg_stat_activity blocking ON blocking.pid = ANY(pg_blocking_pids(blocked.pid))
WHERE blocked.pid != blocking.pid;

// Check metrics and alert if thresholds exceeded
db.raw "SELECT AVG(response_time_ms) as avg_time FROM performance_log WHERE created_at > NOW() - INTERVAL '5 minutes'" as $recent_perf

if ($recent_perf[0].avg_time > 500) {
  // Send alert (webhook, email, etc.)
  http.post "https://hooks.slack.com/your-webhook" {
    body = {
      text: "Performance Alert: Average response time " + $recent_perf[0].avg_time + "ms (threshold: 500ms)"
    }
  }
}

db.raw "
  SELECT 
    COUNT(*) FILTER (WHERE status >= 500) as errors,
    COUNT(*) as total
  FROM request_log
  WHERE created_at > NOW() - INTERVAL '5 minutes'
" as $error_stats

$error_stats[0].errors / $error_stats[0].total as $error_rate

if ($error_rate > 0.05) {  // 5% error rate
  // Send critical alert
}

1. Check Query Analytics for slow endpoints
2. Look at error logs for failures
3. Review recent changes/deployments

1. Get specific request parameters
2. Test in Xano debugger
3. Observe query execution

// Enable debug logging
debug = true

// Log intermediate values
log("User ID: " + $user_id)
log("Query result count: " + ($result | count))

1. Apply fix (index, code change, etc.)
2. Test specific case
3. Monitor metrics for improvement
4. Document the fix

Webhook → External monitoring:
- Datadog
- New Relic
- Custom solutions

Export logs to:
- Cloud logging services
- Data warehouses
- Alerting platforms