Metrics

The Metrics section shows real-time and historical performance data for your database. Watch CPU, memory, connections, disk usage, and network activity to understand how your database is performing.

Understanding Your Database Performance

Metrics are your window into how hard your database is working. You'll see charts for CPU usage, memory consumption, active connections, disk usage, and network traffic. These tell you whether your database is humming along or struggling under load.

Check metrics regularly. You'll spot trends before they become problems. A steadily climbing CPU line? Time to optimize queries or scale up. Memory consistently maxed out? Your instance size might be too small.

Time Range Filtering

At the top, you can filter metrics by time period. Choose from preset options like 5 minutes, 1 hour, 24 hours, and 7 days to understand performance over different timeframes.

Did something spike yesterday at 3pm? Set that time range and see what the metrics were doing then. Investigating an issue that happened last week? Pull up metrics from that specific window.

Metrics are most useful when correlated with actual events. Deploy new code and watch metrics. Performance regressed? You'll see it here.

Active Connections

This chart shows how many database connections are currently open. Each line represents a different type of connection activity. Watch this when your app scales up or when traffic patterns change.

A sudden spike in connections might indicate that your app is creating too many database sessions, which can be inefficient. A healthy pattern shows connections rising with traffic and falling during quiet periods.

Network Traffic

See data flowing in and out of your database. Network In shows data coming into your database (queries, writes, updates). Network Out shows data leaving (query results, reads).

If network traffic is consistently high, you might be transferring too much data between your app and database. Consider optimizing queries to fetch only what you need.

Memory Utilization

Your database uses RAM for caching, indexes, and operations. This chart shows how much of your allocated memory is being used.

Watch for patterns. Is memory usage proportional to your data size and query load? Good. Is memory constantly at 100%? Consider upgrading to a larger instance. Memory pressure causes performance to degrade fast.

If memory hits 100% frequently, your queries might be inefficient or your data is growing faster than your instance can handle. Either optimize your schema and queries, or upgrade to a larger instance size.

CPU Utilization

Your database's processor power is precious. This chart shows what percentage of your CPU is being used.

Normal patterns show CPU spiking with heavy queries then returning to baseline. If CPU is constantly high, your queries might be doing expensive operations. Consider adding indexes or optimizing slow queries.

Operations

This chart breaks down database operations by type: commands (green), queries (orange), updates (blue), deletes (red), and inserts (yellow). Watch which operations dominate your traffic.

A read-heavy workload (mostly queries) has different scaling needs than a write-heavy one (mostly inserts and updates). Understanding your operation pattern helps you optimize effectively.

Disk Usage

Shows how much storage you're actually using versus your allocated capacity.

Watch for a steadily climbing line. If you're approaching capacity, plan to increase storage before you hit the limit. Running out of disk space is one of the worst things that can happen to a database.

Keep an eye on disk usage. If you approach your allocated storage limit, your database can fail. Increase your instance size well before you hit capacity.

Reading the Charts

Each metric chart shows:

X-axis: Time. The chart displays data over your selected time range.

Y-axis: The metric value. CPU percentage, memory in MB, connections count, disk in GB, etc.

Color-coded lines or areas: Different aspects of that metric, or comparisons over time.

Hover over any point to see exact values at that time. This helps you pinpoint the exact moment something changed.

What to Look For

Healthy patterns:

Metrics that rise with traffic and fall during quiet periods
Gradual trends, not sudden spikes
Values consistently below your instance's capacity limits
Balanced operation types (not all writes or all reads)

Warning signs:

Metrics staying at or near 100% capacity
Sudden unexplained spikes
Connections climbing without leveling off
Disk usage approaching limits
Network traffic way higher than expected

Comparing Metrics Over Time

Metrics are most useful when you compare them over time. Is your app getting slower over weeks? Pull up metrics from different dates and compare. See if CPU or memory usage is trending upward, which might indicate data growth or inefficient queries.

This historical perspective helps you plan for growth. If memory usage grows 10% per week, you know you'll need a larger instance in a few weeks.

Troubleshooting with Metrics

App is slow: Check CPU and memory metrics. Are they consistently high? That's your bottleneck. Are they low? The problem might be network latency or query efficiency, not resource constraints.

Database connections keep increasing: Look at active connections. Are new connections staying open instead of closing? That's a resource leak in your app. Each connection holds memory.

Disk filling up: Check disk usage chart. Is it growing steadily? You need either to delete old data or upgrade your instance size.

Performance got worse after a code change: Compare metrics before and after the change. Did CPU or connections spike? That tells you what the change broke.

Metrics alone don't solve problems, but they point you in the right direction. Use them with Logs and Query Insights to get the full picture.