PostgreSQL Database Information Metrics Guide - Database Health & Performance

Comprehensive guide to PostgreSQL database metrics. Monitor rollback rates, deadlocks, cache efficiency, tuple statistics, and temp file usage for optimal database health and performance.

Rollback Percentage

  • What it measures: The percentage of transactions that are rolled back versus committed in the database.
  • Why it matters: A high rollback percentage indicates application bugs causing unintended rollbacks, data integrity issues, locking conflicts (deadlocks), or insufficient resources leading to transaction aborts. This can significantly impact application performance and user experience.
  • Ideal value & Best Practice:
    • Maintain rollback percentage below 1%
    • Investigate immediately if rollback rates exceed 2-3%
    • Monitor for patterns indicating specific problematic transactions
    • Review application error handling and transaction management
    • Ensure adequate resources for transaction processing

Deadlocks Count

  • What it measures: The number of deadlock occurrences where two or more transactions block each other indefinitely.
  • Why it matters: Deadlocks cause performance degradation, transaction failures, and may require manual intervention to resolve. They indicate concurrency issues in application logic or database design.
  • Ideal value & Best Practice:
    • Aim for zero deadlocks in production environments
    • Implement retry logic in applications for deadlock scenarios
    • Ensure consistent transaction ordering across applications
    • Use appropriate transaction isolation levels
    • Monitor and optimize query patterns that frequently cause locking

Fetched/Returned Tuple Percentage

  • What it measures: The ratio of tuples fetched from disk to tuples returned to queries, indicating index efficiency.
  • Why it matters: Measures how effectively PostgreSQL uses indexes to minimize disk accesses. High percentages indicate inefficient index usage or missing indexes.
  • Ideal value & Best Practice:
    • OLTP systems: target less than 1.00%
    • OLAP systems: keep as low as possible despite higher expected values
    • Ensure proper indexing strategy for frequently queried columns
    • Regularly analyze and update statistics for query optimization
    • Monitor for query patterns that bypass indexes

Deleted/Inserted Tuple Percentage

  • What it measures: The ratio of deleted tuples to inserted tuples, indicating data modification patterns.
  • Why it matters: High deletion rates may indicate inefficient data modeling, excessive data retention policies, or unoptimized cleanup operations leading to table fragmentation and increased I/O load.
  • Ideal value & Best Practice:
    • Target 0.1-0.2% for healthy, growing datasets
    • Investigate rates exceeding 1%
    • Implement efficient data archiving strategies
    • Consider partitioning for tables with high deletion rates
    • Regular VACUUM operations to manage table bloat

Cache/Hit Percentage

  • What it measures: The efficiency of PostgreSQL serving data from memory (shared_buffers) instead of disk.
  • Why it matters: Low cache hit rates indicate excessive disk I/O, which slows down queries and indicates insufficient memory allocation or inefficient queries.
  • Ideal value & Best Practice:
    • Target 99% or above for optimal performance
    • Investigate rates below 90% (especially below 50%)
    • Optimize shared_buffers configuration based on workload
    • Implement query optimization to reduce large sequential scans
    • Consider increasing memory allocation for database cache

Temp File Usage

  • What it measures: The number and size of temporary files created when queries exceed work_mem allocations.
  • Why it matters: Excessive temp file usage indicates queries relying on slow disk operations instead of memory, suggesting inefficient queries or inadequate memory settings.
  • Ideal value & Best Practice:
    • Minimize temp file creation through proper work_mem configuration
    • Monitor for queries generating large temp files
    • Optimize queries with large sorts, joins, or aggregations
    • Set appropriate work_mem per connection based on workload
    • Use EXPLAIN ANALYZE to identify temp file-generating operations

Try pghealth Free Today 🚀

Start your journey toward a healthier PostgreSQL with pghealth.
You can explore all features immediately with a free trial — no installation required.

👉 Start Free Trial