pg_peek 0.1.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb99f16f0d2715eb1e038f98b4c7a43077678408b4f7f216f1238a823540f448
-  data.tar.gz: 2bda074f80788e6ab201e49948ce76539cb2e62ce2d0f06276ec22262ed32fda
+  metadata.gz: abc82aa27c9e7fcebbe27a38cc17ff102ae578afdd11d0be75908874ee5058e8
+  data.tar.gz: 7bc328de015861d67c0250ad0373c4639fe1a45c15426c084939d56409b74d5a
 SHA512:
-  metadata.gz: cbd81cbdb7abff990c656557f38e5d889e96c4b80a632a9c55d48b49b0363dd3443ee3ca13adc8ced93edcd5fde0b9c5fdeb4d202f8f64a755aeebacbcffe37d
-  data.tar.gz: 0f60578fbe2b529b6fc076d087a2908a0806e23f77597e70d57a8abc8166e8aa89509805f493af20a7495aba75c683a395ec4af1e1e6b032891491d20ae7b1c5
+  metadata.gz: 72349c589551ec7dd8b5875f1ccbd579a7bbeaba94588fd29251cec72f041f4610077963efdfdd47683f7741469f9ac0cc7f912453770698e5e68e346ea1a7a3
+  data.tar.gz: 8c336b095487533a4862016ee4ffd1d332f3dad19f2134a03716375df017809fa123b1cfa37c286a0d833efeffbc4104c126c2df5a50ae74dce5b7e9eb6ee5d3

data/app/assets/javascripts/pg_peek/application.js

@@ -1,4 +1,4 @@
-// pg_peek — no framework, no CDN, no import map. Three small behaviours.
+// pg_peek — no framework, no CDN, no import map. A few small behaviours.
 (function () {
   "use strict";
 
@@ -112,6 +112,29 @@
     });
   }
 
+  // Long queries --------------------------------------------------------------
+  // Clamped to their first lines by CSS. Measured here, so only a query that
+  // is actually longer gets the toggle.
+  function initClamp() {
+    document.querySelectorAll("[data-clamp]").forEach(function (code) {
+      code.classList.add("clamped");
+      if (code.scrollHeight <= code.clientHeight) {
+        code.classList.remove("clamped");
+        return;
+      }
+
+      var button = document.createElement("button");
+      button.type = "button";
+      button.className = "clamp-toggle";
+      button.textContent = "show all";
+      button.addEventListener("click", function () {
+        var expanded = code.classList.toggle("expanded");
+        button.textContent = expanded ? "show less" : "show all";
+      });
+      code.insertAdjacentElement("afterend", button);
+    });
+  }
+
   // Database switcher -------------------------------------------------------
   function initSwitcher() {
     document.querySelectorAll("[data-switcher]").forEach(function (select) {
@@ -135,6 +158,7 @@
     initTheme();
     initFilter();
     initConfirm();
+    initClamp();
     initSwitcher();
     initReload();
   }

data/app/assets/stylesheets/pg_peek/application.css

@@ -149,6 +149,11 @@ pre {
 
 pre code { background: none; border: 0; padding: 0; }
 
+/* Names from the data (a job class, a table) keep their case inside the
+   lowercase headings, and read as the heading rather than as a code box. */
+.name { text-transform: none; }
+code.name { background: none; border: 0; padding: 0; }
+
 /* Tables ------------------------------------------------------------------ */
 
 .scroll { overflow-x: auto; }
@@ -194,7 +199,6 @@ tbody th + td { text-align: right; }
 .nowrap { white-space: nowrap; }
 .dim { color: var(--dim); }
 .warn { color: var(--warn); }
-.intensity { white-space: nowrap; }
 .bar { letter-spacing: 0.08em; }
 .bar-on { color: var(--accent); }
 /* Brightness follows the value: a one-segment bar sits at 80%, five at full. */
@@ -204,7 +208,48 @@ tbody th + td { text-align: right; }
 .bar-4 .bar-on { opacity: 0.95; }
 .bar-5 .bar-on { opacity: 1; }
 .bar-off { color: var(--line); }
-.sql { word-break: break-all; white-space: pre-wrap; background: none; border: 0; padding: 0; }
+/* An endpoint or job name takes the width the figures leave over, so a long
+   one is cut instead of pushing them out of view (max-width: 0 drops the name
+   from the table's width calculation). The dimmed namespace shrinks first and
+   is cut from the left, since the end of a name tells rows apart: rtl puts
+   the ellipsis on the left, the inner span keeps the text itself ltr so "::"
+   and "/" stay in place. A leaf wider than the cell is cut on the right. */
+.name-column { width: 100%; max-width: 0; min-width: 12ch; }
+.name-column > a { display: block; }
+.qualified { display: flex; overflow: hidden; white-space: nowrap; }
+.qualified .namespace {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  direction: rtl;
+  opacity: 0.6;
+}
+.qualified .namespace > span { direction: ltr; unicode-bidi: embed; }
+.qualified .leaf { flex-shrink: 0; max-width: 100%; overflow: hidden; text-overflow: ellipsis; }
+/* Formatted one clause per line (SqlFormat); a line longer than the cell
+   wraps at spaces and breaks inside a word only when nothing else fits. */
+.sql { display: block; overflow-wrap: anywhere; white-space: pre-wrap; background: none; border: 0; padding: 0; }
+
+/* A long query shows its first lines, with a toggle for the rest. The script
+   adds the class only where the query is longer, so short ones stay as they
+   are, and without it every query shows in full. */
+.sql.clamped:not(.expanded) {
+  display: -webkit-box;
+  -webkit-box-orient: vertical;
+  -webkit-line-clamp: 3;
+  line-clamp: 3;
+  overflow: hidden;
+}
+
+button.clamp-toggle {
+  background: none;
+  border: 0;
+  padding: 0;
+  color: var(--dim);
+  font-size: inherit;
+}
+
+button.clamp-toggle:hover { color: var(--fg); }
 
 /* What issued a query, from its SQLcommenter tags: a link line under the SQL,
    plus every raw tag behind a disclosure. The page-level details/summary
@@ -353,6 +398,7 @@ footer.status button:hover { color: var(--fg); }
 
 .vitals { margin: 0 0 1rem; }
 .vitals span + span::before { content: " · "; color: var(--line); }
+a.provisional { color: color-mix(in srgb, var(--warn) 70%, var(--dim)); }
 
 .panels {
   display: grid;

data/app/controllers/pg_peek/databases_controller.rb

@@ -21,7 +21,6 @@ class PgPeek::DatabasesController < PgPeek::ApplicationController
   def show
     @database = PgPeek::Database.find(params[:id]) or raise ActiveRecord::RecordNotFound, "Database not found"
     @pg_stat_statements = PgPeek::PgStatStatements.new(database: @database)
-    @tables = PgPeek::Reports::Tables.new(database: @database)
     @vitals = @database.vitals
     @stats_reset_at = @pg_stat_statements.reset_at
     @sessions = PgPeek::Reports::Sessions.new(database: @database)
@@ -54,10 +53,18 @@ class PgPeek::DatabasesController < PgPeek::ApplicationController
                    href: database_table_path(@database, table["relname"]) }
       end
 
-      indexes = PgPeek::Reports::Indexes.new(database: @database)
-      if indexes.unused.any?
-        items << { text: "#{helpers.pluralize(indexes.unused.size, "unused index")} · #{helpers.number_to_human_size(indexes.unused_bytes)}",
-                   href: database_indexes_path(@database) }
+      # Scan counts restart at zero on a statistics reset, so right after one
+      # every index looks unused. Small ones cost too little to act on; the
+      # indexes page still lists them all.
+      reset_at = @database.stats_reset_at
+      if reset_at.nil? || reset_at < PgPeek.config.unused_index_min_stats_age.ago
+        unused = PgPeek::Reports::Indexes.new(database: @database).unused
+                   .select { |row| row["size_bytes"].to_i >= PgPeek.config.unused_index_min_size }
+        if unused.any?
+          bytes = unused.sum { |row| row["size_bytes"].to_i }
+          items << { text: "#{helpers.pluralize(unused.size, "unused index")} · #{helpers.number_to_human_size(bytes)}",
+                     href: database_indexes_path(@database) }
+        end
       end
 
       activity = database_activity_path(@database)
@@ -86,11 +93,6 @@ class PgPeek::DatabasesController < PgPeek::ApplicationController
         items << { text: "#{used} of #{max} connections in use", href: activity }
       end
 
-      if @stats_reset_at && @stats_reset_at > 1.hour.ago
-        items << { text: "statistics were reset #{helpers.time_ago_in_words(@stats_reset_at)} ago -- figures may not be representative yet",
-                   href: database_path(@database, anchor: "pg_stat_statements") }
-      end
-
       items
     end
 end

data/app/controllers/pg_peek/endpoints_controller.rb

@@ -1,10 +1,22 @@
 class PgPeek::EndpointsController < PgPeek::ApplicationController
-  def index
-    @database = PgPeek::Database.find(params[:database_id])
-    @pg_stat_statements = PgPeek::PgStatStatements.new(database: @database)
+  before_action :set_database
 
+  def index
     return render "pg_peek/pg_stat_statements/not_preloaded" unless @pg_stat_statements.usable?
 
     @report = PgPeek::Reports::Endpoints.new(database: @database)
   end
+
+  def show
+    @endpoint = "#{params[:endpoint_controller]}##{params[:endpoint_action]}"
+    return render "pg_peek/pg_stat_statements/not_preloaded" unless @pg_stat_statements.usable?
+
+    @report = PgPeek::Reports::EndpointQueries.new(database: @database, endpoint: @endpoint)
+  end
+
+  private
+    def set_database
+      @database = PgPeek::Database.find(params[:database_id])
+      @pg_stat_statements = PgPeek::PgStatStatements.new(database: @database)
+    end
 end

data/app/controllers/pg_peek/jobs_controller.rb

@@ -13,7 +13,7 @@ class PgPeek::JobsController < PgPeek::ApplicationController
   end
 
   def show
-    @job_class = CGI.unescape(params[:job_class])
+    @job_class = params[:job_class]
     return render "pg_peek/pg_stat_statements/not_preloaded" unless @pg_stat_statements.usable?
 
     @report = PgPeek::Reports::JobQueries.new(database: @database, job_class: @job_class)

data/app/controllers/pg_peek/pg_stat_statements_controller.rb

@@ -1,17 +1,28 @@
 # Manages the extension itself. What it records is read by QueriesController,
 # EndpointsController and JobsController.
 class PgPeek::PgStatStatementsController < PgPeek::ApplicationController
-  def reset
-    @database = PgPeek::Database.find(params[:database_id]) or raise ActiveRecord::RecordNotFound, "Database not found"
-    pg_stat_statements = PgPeek::PgStatStatements.new(database: @database)
+  before_action :set_database
+
+  def show
+    return render "pg_peek/pg_stat_statements/not_preloaded" unless @pg_stat_statements.usable?
+
+    @connection_summary = @database.connection_summary
+  end
 
-    if pg_stat_statements.resettable?
-      pg_stat_statements.reset!
+  def reset
+    if @pg_stat_statements.resettable?
+      @pg_stat_statements.reset!
       flash[:notice] = "pg_stat_statements has been reset."
     else
       flash[:alert] = "This role may not reset pg_stat_statements; the statistics were left as they are."
     end
 
-    redirect_to database_path(@database, anchor: "pg_stat_statements")
+    redirect_to database_pg_stat_statements_path(@database)
   end
+
+  private
+    def set_database
+      @database = PgPeek::Database.find(params[:database_id]) or raise ActiveRecord::RecordNotFound, "Database not found"
+      @pg_stat_statements = PgPeek::PgStatStatements.new(database: @database)
+    end
 end

data/app/controllers/pg_peek/tables_controller.rb

@@ -1,6 +1,16 @@
 class PgPeek::TablesController < PgPeek::ApplicationController
+  before_action :set_database
+
+  def index
+    @tables = PgPeek::Reports::Tables.new(database: @database)
+  end
+
   def show
-    @database = PgPeek::Database.find(params[:database_id]) or raise ActiveRecord::RecordNotFound, "Database not found"
     @table = @database.find_table(params[:name]) or raise ActiveRecord::RecordNotFound, "Table '#{params[:name]}' not found"
   end
+
+  private
+    def set_database
+      @database = PgPeek::Database.find(params[:database_id]) or raise ActiveRecord::RecordNotFound, "Database not found"
+    end
 end

data/app/helpers/pg_peek/application_helper.rb

@@ -30,16 +30,23 @@ module PgPeek::ApplicationHelper
     sql.gsub(SQLCOMMENTER_PATTERN, "").strip
   end
 
-  # Where a query's SQLcommenter tags point, if anywhere: a job's own page,
-  # or the endpoints list for a controller/action (there is no per-endpoint
-  # page to link into yet, so this lands on the list rather than one row of it).
+  # Where a query's SQLcommenter tags point, if anywhere: a job's own page, or
+  # a controller/action's own page. A controller without an action has no page,
+  # so it lands on the endpoints list.
   def sqlcommenter_href(database, tags)
     return database_job_path(database, tags["job"]) if tags["job"].present?
 
     controller = tags["namespaced_controller"] || tags["controller"]
-    return database_endpoints_path(database) if controller.present?
+    return nil if controller.blank?
+    return database_endpoints_path(database) if tags["action"].blank?
 
-    nil
+    endpoint_path(database, "#{controller}##{tags["action"]}")
+  end
+
+  # An endpoint's page, from its controller#action name.
+  def endpoint_path(database, endpoint)
+    controller, action = endpoint.split("#", 2)
+    database_endpoint_path(database, endpoint_controller: controller, endpoint_action: action)
   end
 
   # Format a rate with auto-scaled units based on magnitude
@@ -95,11 +102,17 @@ module PgPeek::ApplicationHelper
   end
 
   # Every pg_stat_statements figure is cumulative since the last reset. Each
-  # page says so in its header and links to the overview block that resets it.
+  # page says so in its header and links to the extension's page, which
+  # resets it.
+  # Within the first hour the figures cover too little to go by, and the link
+  # is marked provisional.
   def stats_since_link(database, reset_at)
+    provisional = reset_at && reset_at > 1.hour.ago
+
     link_to "stats since #{format_time_ago(reset_at)}",
-            database_path(database, anchor: "pg_stat_statements"),
-            title: "figures are cumulative since the last pg_stat_statements reset"
+            database_pg_stat_statements_path(database),
+            class: ("provisional" if provisional),
+            title: provisional ? "figures may not be representative yet" : "figures are cumulative since the last pg_stat_statements reset"
   end
 
   # Format cache hit ratio for inline display
@@ -134,12 +147,15 @@ module PgPeek::ApplicationHelper
     ((value.to_f / max_value) * INTENSITY_SEGMENTS).ceil.clamp(0, INTENSITY_SEGMENTS)
   end
 
-  # Durations pick their unit by magnitude: 210ms, 1.20s, 2m 05s, 1h 12m.
-  # Values stay narrow and read at a glance, and a header sits over data of
-  # similar width. The exact figure belongs in a title, not the cell.
+  # Durations pick their unit by magnitude: <1ms, 210ms, 1.20s, 2m 05s,
+  # 1h 12m. Values stay narrow and read at a glance, and a header sits over
+  # data of similar width. The exact figure belongs in a title, not the cell.
+  # Anything above zero but under a millisecond is <1ms, so a fast query never
+  # reads as 0ms -- that is kept for a real zero.
   def format_duration_from_ms(total_ms)
     ms = total_ms.to_f
     return "0ms" if ms <= 0
+    return "<1ms" if ms < 1
     return format("%.1fms", ms) if ms < 10
     return "#{ms.round}ms" if ms < 1000
 

data/app/helpers/pg_peek/report_helper.rb

@@ -1,11 +1,18 @@
 # Turns a report cell into markup. The report is passed alongside the column
-# because some formats are relative -- an intensity bar means nothing without
-# the largest value in its column.
+# because a bar is relative -- it means nothing without the largest value in
+# its column.
 module PgPeek::ReportHelper
   def format_cell(report, column, row)
     value = row.value(column)
     return "" if value.nil? || value.to_s.empty?
 
+    content = format_value(report, column, value)
+    return content unless column.bar?
+
+    safe_join([ content, intensity_bar(value.to_f, report.max_for(column)) ], " ")
+  end
+
+  def format_value(report, column, value)
     case column.format
     when :number       then format_number(value.to_i)
     when :duration_ms  then duration_cell(value.to_f)
@@ -13,21 +20,37 @@ module PgPeek::ReportHelper
     when :percent      then "#{value}%"
     when :ratio        then "~#{value}"
     when :sql          then sql_cell(report, value.to_s)
-    when :intensity    then intensity_bar(value.to_f, report.max_for(column))
+    when :name         then name_cell(value.to_s)
     else value.to_s
     end
   end
 
   # The compact figure is what you scan; the exact one is a hover away.
   def duration_cell(ms)
-    tag.span(format_duration_from_ms(ms), title: "#{number_with_delimiter(ms.round(1))} ms")
+    tag.span(format_duration_from_ms(ms), title: "#{number_with_delimiter(ms.round(3))} ms")
+  end
+
+  # An endpoint or job name in its native form, the namespace dimmed so the
+  # eye goes to the last part. When the column is too narrow, the namespace
+  # is what gets cut; the full name is on hover.
+  def name_cell(name)
+    namespace, leaf = name_parts(name)
+    tag.span(class: "qualified", title: name) do
+      safe_join([ (tag.span(tag.span(namespace), class: "namespace") if namespace), tag.span(leaf, class: "leaf") ].compact)
+    end
+  end
+
+  # Splits after the last "/" or "::": courier_company_app/dashboard/ and
+  # executions#show, or GDPR::OrderAnonymizationBatch:: and ProgressMonitorJob.
+  def name_parts(name)
+    name.match(%r{\A(.*(?:/|::))?(.*)\z}m).captures
   end
 
   # The SQL text, plus -- when SQLcommenter tagged it -- what issued it (a
   # link into the page that already aggregates this exact query across every
   # call site) and every raw tag behind a disclosure, for the rest.
   def sql_cell(report, sql)
-    code = tag.code(strip_sqlcommenter(sql).squish, class: "sql")
+    code = tag.code(PgPeek::SqlFormat.format(strip_sqlcommenter(sql)), class: "sql", data: { clamp: true })
     tags = PgPeek::SqlComment.tags(sql)
     return code if tags.empty?
 
@@ -50,9 +73,10 @@ module PgPeek::ReportHelper
   end
 
   def cell_class(column)
-    case column.format
-    when :intensity then "intensity"
-    else column.numeric? ? "num" : nil
+    if column.format == :name
+      "name-column"
+    elsif column.numeric?
+      "num"
     end
   end
 end

data/app/models/pg_peek/pg_stat_statements.rb

@@ -93,6 +93,37 @@ class PgPeek::PgStatStatements
     Time.zone.parse(value.to_s) if value.present?
   end
 
+  # How many statements the server dropped since the last reset because the
+  # table was full (pg_stat_statements.max). Above zero, every total is an
+  # undercount: whatever was dropped took its calls and time with it.
+  def dealloc
+    return unless usable?
+
+    connection.select_value(PgPeek::QueryLoader.mark(<<~SQL)).to_i
+      SELECT dealloc FROM pg_stat_statements_info
+    SQL
+  end
+
+  # The table is shared by every database on the server, so max is measured
+  # against all of them, not just this one.
+  def server_statement_count
+    return unless usable?
+
+    connection.select_value(PgPeek::QueryLoader.mark(<<~SQL)).to_i
+      SELECT count(*) FROM pg_stat_statements
+    SQL
+  end
+
+  # pg_stat_statements.* settings, by name without the prefix.
+  def settings
+    return {} unless usable?
+
+    connection.select_rows(PgPeek::QueryLoader.mark(<<~SQL)).to_h
+      SELECT substr(name, length('pg_stat_statements.') + 1), setting
+      FROM pg_settings WHERE name LIKE 'pg_stat_statements.%' ORDER BY name
+    SQL
+  end
+
   def outliers
     return unless usable?
 
@@ -133,10 +164,10 @@ class PgPeek::PgStatStatements
   def outliers_by_job(job_class)
     return unless usable?
 
-    # Build pattern to match job='JobClassName' in SQLcommenter
-    # Need to escape for SQL LIKE and quote properly
-    escaped_job = job_class.gsub("'", "''")
-    pattern = "%job='#{escaped_job}'%"
+    # Rails writes the job tag url-encoded (job='Reports%3A%3ADigestJob'), so
+    # match it encoded, with the % of the encoding escaped for LIKE.
+    encoded_job = ActiveRecord::Base.sanitize_sql_like(ERB::Util.url_encode(job_class))
+    pattern = "%job='#{encoded_job}'%"
 
     query = PgPeek::QueryLoader.load("pg_stat_statements/outliers_by_job",
                                       pg_version: database.major_version,
@@ -146,6 +177,22 @@ class PgPeek::PgStatStatements
     result.to_a
   end
 
+  # endpoint is controller#action, as the endpoints report names it.
+  def outliers_by_endpoint(endpoint)
+    return unless usable?
+
+    # Rails writes the tags url-encoded (namespaced_controller='staff%2Fprocesses'),
+    # so compare them encoded.
+    controller, action = endpoint.split("#", 2).map { |part| ERB::Util.url_encode(part) }
+
+    query = PgPeek::QueryLoader.load("pg_stat_statements/outliers_by_endpoint",
+                                      pg_version: database.major_version,
+                                      controller: connection.quote(controller),
+                                      action: connection.quote(action),
+                                      limit: PgPeek.config.outliers_limit)
+    connection.execute(query).to_a
+  end
+
   private
 
   # pg_stat_statements_info() raises PG::ObjectNotInPrerequisiteState unless

data/app/models/pg_peek/sql_format.rb

@@ -0,0 +1,74 @@
+# Lays a query out one clause per line, so the first lines of a long query say
+# what it reads and from where, and its joins and conditions read as a list.
+# Only line breaks and spacing change. Breaks go in at the top level only --
+# never inside parentheses, quotes or a CASE -- so subqueries and function
+# calls stay on one line, and a query this does not understand comes out with
+# an odd break at worst.
+class PgPeek::SqlFormat
+  TOKEN = /'(?:[^']|'')*'|"(?:[^"]|"")*"|[(),;]|[^\s'"(),;]+|\s+/
+  CLAUSES = %w[SELECT FROM WHERE GROUP HAVING WINDOW ORDER LIMIT OFFSET FETCH FOR
+               UNION INTERSECT EXCEPT RETURNING SET VALUES].freeze
+  JOIN_PREFIXES = %w[INNER LEFT RIGHT FULL CROSS NATURAL].freeze
+  CONDITIONS = %w[WHERE HAVING].freeze
+
+  def self.format(sql)
+    tokens = []
+    space = false
+    sql.to_s.strip.scan(TOKEN) do |token|
+      if token.match?(/\A\s/)
+        space = true
+      else
+        tokens << [ token, space ]
+        space = false
+      end
+    end
+
+    out = +""
+    depth = case_depth = 0
+    clause = nil
+    between = false
+
+    tokens.each_with_index do |(token, space_before), index|
+      word = token.upcase
+      top = index.positive? && depth.zero? && case_depth.zero?
+      previous = tokens[index - 1]&.first&.upcase if index.positive?
+      following = tokens[index + 1]&.first&.upcase
+
+      line_break = nil
+      if top
+        if CLAUSES.include?(word)
+          line_break = "\n"
+          clause = word
+        elsif JOIN_PREFIXES.include?(word) && %w[JOIN OUTER].include?(following)
+          line_break = "\n"
+          clause = "JOIN"
+        elsif word == "JOIN" && !(JOIN_PREFIXES + %w[OUTER]).include?(previous)
+          line_break = "\n"
+          clause = "JOIN"
+        elsif word == "BETWEEN"
+          between = true
+        elsif word == "AND" && between
+          between = false
+        elsif %w[AND OR].include?(word) && CONDITIONS.include?(clause)
+          line_break = "\n  "
+        end
+      end
+
+      if line_break
+        out << line_break
+      elsif space_before && !out.empty?
+        out << " "
+      end
+      out << token
+
+      case word
+      when "(" then depth += 1
+      when ")" then depth -= 1 if depth.positive?
+      when "CASE" then case_depth += 1
+      when "END" then case_depth -= 1 if case_depth.positive?
+      end
+    end
+
+    out
+  end
+end

data/app/models/pg_peek/table.rb

@@ -147,10 +147,11 @@ class PgPeek::Table
     (dead_tuples.to_f / total * 100).round(1)
   end
 
+  # The same rule as the overview's attention list: past autovacuum's trigger
+  # point as well as the percentage threshold.
   def dead_tuple_warning?
-    ratio = dead_tuple_ratio
-    return false if ratio.nil?
-    ratio >= PgPeek.config.dead_tuple_warning_threshold
+    database.tables_with_dead_tuples(PgPeek.config.dead_tuple_warning_threshold)
+            .any? { |table| table["relname"] == name }
   end
 
   def row_estimate

data/app/queries/pg_peek/pg14/pg_stat_statements/outliers.sql

@@ -2,7 +2,7 @@ SELECT
   interval '1 millisecond' * total_exec_time AS total_exec_time,
   COALESCE(to_char((total_exec_time/NULLIF(sum(total_exec_time) OVER(), 0)) * 100, 'FM990D0'), '0') || '%' AS prop_exec_time,
   to_char(calls, 'FM999G999G999G990') AS ncalls,
-  ROUND(total_exec_time/NULLIF(calls, 0)) AS avg_exec_ms,
+  total_exec_time/NULLIF(calls, 0) AS avg_exec_ms,
   interval '1 millisecond' * (blk_read_time + blk_write_time) AS sync_io_time,
   query
 FROM pg_stat_statements

data/app/queries/pg_peek/pg14/pg_stat_statements/outliers_by_endpoint.sql

@@ -0,0 +1,24 @@
+-- The query shapes one controller#action issued. The endpoint is read from the
+-- tags exactly as endpoints.sql reads it, so this page lists the same shapes
+-- that endpoints.sql counts for it. An equality, not a LIKE: with both tags on,
+-- controller='posts' also appears in the queries of admin/posts.
+SELECT
+  interval '1 millisecond' * total_exec_time AS total_exec_time,
+  COALESCE(to_char((total_exec_time/NULLIF(sum(total_exec_time) OVER(), 0)) * 100, 'FM990D0'), '0') || '%' AS prop_exec_time,
+  to_char(calls, 'FM999G999G999G990') AS ncalls,
+  ROUND(total_exec_time/NULLIF(calls, 0)) AS avg_exec_ms,
+  interval '1 millisecond' * (blk_read_time + blk_write_time) AS sync_io_time,
+  query
+FROM pg_stat_statements
+WHERE userid = (SELECT usesysid FROM pg_user WHERE usename = current_user LIMIT 1)
+  AND dbid = (SELECT oid FROM pg_database WHERE datname = current_database())
+  AND query NOT LIKE '%/* pg_peek */%'
+  AND COALESCE(
+    substring(query from 'namespaced_controller=''([^'']+)'''),
+    substring(query from 'controller=''([^'']+)''')
+  ) = {{controller}}
+  AND substring(query from 'action=''([^'']+)''') = {{action}}
+  AND query !~* 'pg_catalog|information_schema|pg_index|pg_class|pg_attribute'
+  AND query !~* '^\s*SHOW '
+ORDER BY total_exec_time DESC
+LIMIT {{limit}}

data/app/queries/pg_peek/pg14/pg_stat_statements/outliers_by_job.sql

@@ -2,7 +2,7 @@ SELECT
   interval '1 millisecond' * total_exec_time AS total_exec_time,
   COALESCE(to_char((total_exec_time/NULLIF(sum(total_exec_time) OVER(), 0)) * 100, 'FM990D0'), '0') || '%' AS prop_exec_time,
   to_char(calls, 'FM999G999G999G990') AS ncalls,
-  ROUND(total_exec_time/NULLIF(calls, 0)) AS avg_exec_ms,
+  total_exec_time/NULLIF(calls, 0) AS avg_exec_ms,
   interval '1 millisecond' * (blk_read_time + blk_write_time) AS sync_io_time,
   query
 FROM pg_stat_statements

data/app/queries/pg_peek/pg14/tables/dead_tuples.sql

@@ -1,4 +1,7 @@
--- Tables whose dead-tuple share is at or above the warning threshold.
+-- Tables that autovacuum should have cleaned by now: more dead tuples than its
+-- own trigger point (autovacuum_vacuum_threshold + scale_factor * live rows),
+-- and a dead-tuple share at or above the warning threshold. Small tables never
+-- reach the trigger point, so a high share alone is not a problem.
 SELECT
   relname,
   n_live_tup,
@@ -6,6 +9,7 @@ SELECT
   round(100.0 * n_dead_tup / NULLIF(n_live_tup + n_dead_tup, 0), 1) AS dead_ratio,
   last_autovacuum
 FROM pg_stat_user_tables
-WHERE n_live_tup + n_dead_tup > 0
-  AND 100.0 * n_dead_tup / (n_live_tup + n_dead_tup) >= {{threshold}}
+WHERE n_dead_tup > current_setting('autovacuum_vacuum_threshold')::int
+                   + current_setting('autovacuum_vacuum_scale_factor')::float * n_live_tup
+  AND 100.0 * n_dead_tup / NULLIF(n_live_tup + n_dead_tup, 0) >= {{threshold}}
 ORDER BY dead_ratio DESC

data/app/queries/pg_peek/pg15/pg_stat_statements/outliers.sql

@@ -2,7 +2,7 @@ SELECT
   interval '1 millisecond' * total_exec_time AS total_exec_time,
   COALESCE(to_char((total_exec_time/NULLIF(sum(total_exec_time) OVER(), 0)) * 100, 'FM990D0'), '0') || '%' AS prop_exec_time,
   to_char(calls, 'FM999G999G999G990') AS ncalls,
-  ROUND(total_exec_time/NULLIF(calls, 0)) AS avg_exec_ms,
+  total_exec_time/NULLIF(calls, 0) AS avg_exec_ms,
   interval '1 millisecond' * (blk_read_time + blk_write_time) AS sync_io_time,
   query
 FROM pg_stat_statements