pg_peek 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: edfdc4a86128d1eec3f1c69e731780b9ef71afdd071d76cde2756eee57d55ff8
-  data.tar.gz: 666c7f0204c05e295f6c6950e32362720e273d579ec3eec6c557fd2769ab14c0
+  metadata.gz: 52d233ab8cafc3dae1e3386c44b9244549344b3b4bf97bc9f053cfdb843bd223
+  data.tar.gz: 3abf5a72e79b3ffff19323bb6fc7812c479bfd23c8bbee8667aff5a52732cb1f
 SHA512:
-  metadata.gz: 4ecde1526a25bd02fe30c47dbbe62ff2058ce2d8f6b1ff741ffd50b2eea26236e102646f98b67dabf4d9f6d566717a838c04c15be895d5d3b335a59bde342945
-  data.tar.gz: 44fa0fbf8d8ccd408c9e967b78ec29503fc94f605beb961cdc8480137773e7b6145af740990c039ac4f09be1c7664d03c204290190c0f9cd94a1e674b9517d15
+  metadata.gz: 93640cabe15c0afecb89784c94623a77ccb118a1679a9fe821b58e4fb9f04f68de2e28b88222f475a5930f1daff722f577c65149159c498aece5b19e1fe20f9f
+  data.tar.gz: 37074ace65e4e13d9953f4d342a8b4011a0fa7903b7141e29b8961d3db44ea680273c78b4835157605275f4578878b23d04e28df1287a99ce3505703b33b11ab

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,6 +208,24 @@ tbody th + td { text-align: right; }
 .bar-4 .bar-on { opacity: 0.95; }
 .bar-5 .bar-on { opacity: 1; }
 .bar-off { color: var(--line); }
+/* 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; }
 .sql { word-break: break-all; white-space: pre-wrap; background: none; border: 0; padding: 0; }
 
 /* What issued a query, from its SQLcommenter tags: a link line under the SQL,
@@ -280,6 +302,12 @@ button, .button {
 button:hover { border-color: var(--fg); }
 button.danger { color: var(--danger); border-color: var(--danger); }
 button.danger:hover { background: var(--danger); color: var(--bg); }
+button:disabled, button:disabled:hover {
+  background: var(--panel);
+  color: var(--dim);
+  border-color: var(--line);
+  cursor: not-allowed;
+}
 
 form.inline { display: inline; margin: 0; }
 
@@ -297,6 +325,13 @@ form.inline { display: inline; margin: 0; }
   margin: 0.75rem 0;
 }
 
+.alert {
+  border: 1px solid var(--danger);
+  color: var(--danger);
+  padding: 0.4rem 0.75rem;
+  margin: 0.75rem 0;
+}
+
 mark { background: var(--accent); color: var(--bg); }
 
 .grid {
@@ -340,6 +375,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

@@ -54,10 +54,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 +94,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

@@ -3,9 +3,15 @@
 class PgPeek::PgStatStatementsController < PgPeek::ApplicationController
   def reset
     @database = PgPeek::Database.find(params[:database_id]) or raise ActiveRecord::RecordNotFound, "Database not found"
-    PgPeek::PgStatStatements.new(database: @database).reset!
+    pg_stat_statements = PgPeek::PgStatStatements.new(database: @database)
 
-    redirect_to database_path(@database, anchor: "pg_stat_statements"),
-                notice: "pg_stat_statements has been 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")
   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
@@ -96,10 +103,15 @@ module PgPeek::ApplicationHelper
 
   # 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.
+  # 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"
+            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 +146,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,14 +20,30 @@ 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
@@ -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

@@ -24,16 +24,34 @@ class PgPeek::PgStatStatements
   # The extension can be created in the database while the module itself was
   # never loaded at server start. Querying the view then raises
   # PG::ObjectNotInPrerequisiteState, so every read has to check this first.
+  #
+  # Roles without pg_read_all_settings (dokku's postgres plugin, most managed
+  # hosts) cannot read shared_preload_libraries, so then the only way to tell
+  # is to ask the module itself.
   def preloaded?
-    shared_preload_libraries.split(",").map(&:strip).include?(LIBRARY_NAME)
+    if shared_preload_libraries
+      shared_preload_libraries.split(",").map(&:strip).include?(LIBRARY_NAME)
+    else
+      installed? && module_loaded?
+    end
   end
 
   def usable?
     installed? && preloaded?
   end
 
+  # nil when this role may not examine the setting, as opposed to "" when
+  # nothing is preloaded.
   def shared_preload_libraries
-    @shared_preload_libraries ||= connection.select_value(PgPeek::QueryLoader.mark("SHOW shared_preload_libraries")).to_s
+    return @shared_preload_libraries if defined?(@shared_preload_libraries)
+
+    @shared_preload_libraries = without_aborting_transaction do
+      connection.select_value(PgPeek::QueryLoader.mark("SHOW shared_preload_libraries")).to_s
+    end
+  rescue ActiveRecord::StatementInvalid => e
+    raise unless e.cause.is_a?(PG::InsufficientPrivilege)
+
+    @shared_preload_libraries = nil
   end
 
   def outdated?
@@ -42,12 +60,23 @@ class PgPeek::PgStatStatements
     @installed_version != @default_version
   end
 
+  # The extension revokes EXECUTE on the reset from PUBLIC, so only superusers
+  # and roles granted it may run one.
+  def resettable?
+    return @resettable if defined?(@resettable)
+
+    @resettable = usable? && connection.select_value(PgPeek::QueryLoader.mark(<<~SQL)) == true
+      SELECT bool_and(has_function_privilege(oid, 'EXECUTE'))
+      FROM pg_proc WHERE proname = 'pg_stat_statements_reset'
+    SQL
+  end
+
   # Server-wide on purpose. pg_stat_statements_info keeps a single stats_reset
   # for the whole server and only moves it when every entry is removed, so a
   # reset scoped to this database would leave "stats since" pointing at the
   # old time.
   def reset!
-    return unless usable?
+    return unless resettable?
 
     connection.execute PgPeek::QueryLoader.mark(<<-SQL)
       SELECT pg_stat_statements_reset();
@@ -104,10 +133,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,
@@ -117,8 +146,45 @@ 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
+  # the module was loaded at server start, and is readable by any role.
+  def module_loaded?
+    return @module_loaded if defined?(@module_loaded)
+
+    @module_loaded = without_aborting_transaction do
+      connection.select_value(PgPeek::QueryLoader.mark("SELECT 1 FROM pg_stat_statements_info"))
+      true
+    end
+  rescue ActiveRecord::StatementInvalid => e
+    raise unless e.cause.is_a?(PG::ObjectNotInPrerequisiteState)
+
+    @module_loaded = false
+  end
+
+  # A failed statement inside an open transaction (a host app's, or a
+  # transactional test) would poison it; a savepoint confines the failure.
+  def without_aborting_transaction(&)
+    connection.transaction(requires_new: true, &)
+  end
+
   def verify_installation
     result = connection.execute PgPeek::QueryLoader.mark(<<-SQL)
       SELECT default_version, installed_version FROM pg_available_extensions WHERE name = 'pg_stat_statements';

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

data/app/queries/pg_peek/pg15/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/pg15/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/pg15/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/pg16/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/pg16/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/pg16/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/pg16/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/pg17/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' * (shared_blk_read_time + shared_blk_write_time) AS sync_io_time,
   query
 FROM pg_stat_statements

data/app/queries/pg_peek/pg17/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' * (shared_blk_read_time + shared_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/pg17/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' * (shared_blk_read_time + shared_blk_write_time) AS sync_io_time,
   query
 FROM pg_stat_statements

data/app/queries/pg_peek/pg17/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/pg18/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' * (shared_blk_read_time + shared_blk_write_time) AS sync_io_time,
   query
 FROM pg_stat_statements

data/app/queries/pg_peek/pg18/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' * (shared_blk_read_time + shared_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/pg18/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' * (shared_blk_read_time + shared_blk_write_time) AS sync_io_time,
   query
 FROM pg_stat_statements

data/app/queries/pg_peek/pg18/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/reports/pg_peek/column.rb

@@ -7,7 +7,9 @@ class PgPeek::Column
 
   attr_reader :key, :align, :format, :title
 
-  def initialize(key, header: nil, align: :left, format: :text, title: nil)
+  # bar: draw the value with a bar next to it, scaled against the largest value
+  # in the column, so the biggest rows stand out without reading every figure.
+  def initialize(key, header: nil, align: :left, format: :text, title: nil, bar: false)
     raise ArgumentError, "unknown alignment #{align.inspect}" unless ALIGNMENTS.include?(align)
 
     @key = key
@@ -15,12 +17,15 @@ class PgPeek::Column
     @align = align
     @format = format
     @title = title
+    @bar = bar
   end
 
   def header
     @header || key.to_s.tr("_", " ")
   end
 
+  def bar? = @bar
+
   def numeric?
     align == :right
   end

data/app/reports/pg_peek/report.rb

@@ -43,8 +43,7 @@ class PgPeek::Report
 
   def title = self.class.title
 
-  # Relative formats -- an intensity bar, a share of total -- need the extent of
-  # the column, not just the cell.
+  # A bar is relative: it needs the extent of the column, not just the cell.
   def max_for(column)
     @maxima ||= {}
     @maxima[column.key] ||= rows.filter_map { |row| row.value(column)&.to_f }.max

data/app/reports/pg_peek/reports/endpoint_queries.rb

@@ -0,0 +1,14 @@
+# The query shapes one controller#action issues, most expensive first.
+class PgPeek::Reports::EndpointQueries < PgPeek::Reports::Queries
+  attr_reader :endpoint
+
+  def initialize(database:, endpoint:)
+    super(database: database)
+    @endpoint = endpoint
+  end
+
+  private
+    def source_rows
+      pg_stat_statements.outliers_by_endpoint(endpoint)
+    end
+end

data/app/reports/pg_peek/reports/endpoints.rb

@@ -6,9 +6,9 @@ class PgPeek::Reports::Endpoints < PgPeek::Report
   # the shape of an N+1 rather than a page that legitimately asks twice.
   N_PLUS_ONE_THRESHOLD = 5
 
-  column :endpoint
-  column :total_exec_time_ms, header: "db time", align: :right, format: :duration_ms
-  column :share, align: :right, format: :intensity, title: "Share of database time across endpoints"
+  column :endpoint, format: :name
+  column :total_exec_time_ms, header: "db time", align: :right, format: :duration_ms, bar: true,
+                             title: "Database time; the bar compares it with the other endpoints listed"
   column :request_count, header: "requests", align: :right, format: :number,
                          title: "Estimated from the least-called query of this endpoint"
   column :total_calls, header: "queries", align: :right, format: :number
@@ -26,10 +26,7 @@ class PgPeek::Reports::Endpoints < PgPeek::Report
       rows = pg_stat_statements.endpoints
       return [] if rows.blank?
 
-      rows.each do |row|
-        # namespaced_controller arrives url-encoded: staff%2Fprocesses#show.
-        row["endpoint"] = CGI.unescape(row["endpoint"].to_s)
-        row["share"] = row["total_exec_time_ms"]
-      end
+      # namespaced_controller arrives url-encoded: staff%2Fprocesses#show.
+      rows.each { |row| row["endpoint"] = CGI.unescape(row["endpoint"].to_s) }
     end
 end

data/app/reports/pg_peek/reports/jobs.rb

@@ -4,18 +4,18 @@
 class PgPeek::Reports::Jobs < PgPeek::Report
   title "Jobs"
 
-  column :job_class, header: "job"
-  column :total_exec_time_ms, header: "db time", align: :right, format: :duration_ms
-  column :share, align: :right, format: :intensity, title: "Share of database time across jobs"
+  column :job_class, header: "job", format: :name
+  column :total_exec_time_ms, header: "db time", align: :right, format: :duration_ms, bar: true,
+                             title: "Database time; the bar compares it with the other jobs listed"
   column :total_calls, header: "queries", align: :right, format: :number
   column :query_count, header: "shapes", align: :right, format: :number,
                        title: "Distinct query shapes issued by this job"
 
   private
     def fetch_rows
-      rows = pg_stat_statements.jobs
-      return [] if rows.blank?
-
-      rows.each { |row| row["share"] = row["total_exec_time_ms"] }
+      pg_stat_statements.jobs.to_a.each do |row|
+        # The job tag arrives url-encoded: Reports%3A%3ADigestJob.
+        row["job_class"] = CGI.unescape(row["job_class"].to_s)
+      end
     end
 end

data/app/reports/pg_peek/reports/queries.rb

@@ -2,7 +2,8 @@
 class PgPeek::Reports::Queries < PgPeek::Report
   title "Queries"
 
-  column :calls, align: :right, format: :intensity, title: "Call count relative to the other queries listed"
+  column :calls, align: :right, format: :number, bar: true,
+                 title: "Call count; the bar compares it with the other queries listed"
   column :total_exec_time, header: "db time", align: :right, format: :duration
   column :prop_exec_time, header: "share", align: :right
   column :avg_exec_ms, header: "avg", align: :right, format: :duration_ms

data/app/views/layouts/pg_peek/application.html.erb

@@ -15,6 +15,7 @@
   <body>
     <main>
       <% if flash[:notice] %><p class="notice"><%= flash[:notice] %></p><% end %>
+      <% if flash[:alert] %><p class="alert"><%= flash[:alert] %></p><% end %>
       <nav>
         <ul>
           <li><%= link_to "pg_peek", databases_path, class: "wordmark" %></li>

data/app/views/pg_peek/databases/show.html.erb

@@ -63,8 +63,10 @@ end</code></pre>
         <p class="dim">No endpoint has run a query yet.</p>
       <% else %>
         <%= render "pg_peek/reports/report", report: @endpoints,
-                   columns: %i[endpoint share total_exec_time_ms max_queries_per_request],
-                   limit: PgPeek::DatabasesController::OVERVIEW_ROWS %>
+                   columns: %i[endpoint total_exec_time_ms max_queries_per_request],
+                   limit: PgPeek::DatabasesController::OVERVIEW_ROWS,
+                   link_column: :endpoint,
+                   link: ->(row) { endpoint_path(@database, row["endpoint"]) } %>
       <% end %>
     </section>
 
@@ -74,8 +76,10 @@ end</code></pre>
         <p class="dim">No job has run a query yet.</p>
       <% else %>
         <%= render "pg_peek/reports/report", report: @jobs,
-                   columns: %i[job_class share total_exec_time_ms],
-                   limit: PgPeek::DatabasesController::OVERVIEW_ROWS %>
+                   columns: %i[job_class total_exec_time_ms],
+                   limit: PgPeek::DatabasesController::OVERVIEW_ROWS,
+                   link_column: :job_class,
+                   link: ->(row) { database_job_path(@database, row["job_class"]) } %>
       <% end %>
     </section>
 
@@ -142,8 +146,16 @@ end</code></pre>
                   reset_database_pg_stat_statements_path(@database),
                   method: :delete,
                   class: "danger",
+                  disabled: !@pg_stat_statements.resettable?,
                   form_class: "inline",
                   form: { data: { confirm: "Reset pg_stat_statements? This clears statement statistics for every database on this server." } } %>
+    <% unless @pg_stat_statements.resettable? %>
+      <p class="dim">
+        <%= @connection_summary["username"] %> may not reset the statistics: the extension
+        allows it only to superusers and roles granted it. To allow it:
+      </p>
+      <pre><code>GRANT EXECUTE ON FUNCTION pg_stat_statements_reset TO <%= @connection_summary["username"] %>;</code></pre>
+    <% end %>
     <% if @pg_stat_statements.outdated? %>
       <p class="dim">
         Version <%= @pg_stat_statements.default_version %> is available:

data/app/views/pg_peek/endpoints/index.html.erb

@@ -13,7 +13,20 @@
     </p>
   </article>
 <% else %>
-  <%= render "pg_peek/reports/report", report: @report %>
+  <input type="search"
+         placeholder="filter endpoints… (press / to focus)"
+         data-filter-input
+         data-filter-noun="endpoint"
+         autofocus
+         autocomplete="off">
+  <p class="dim" data-filter-count></p>
+
+  <%= render "pg_peek/reports/report",
+             report: @report,
+             link_column: :endpoint,
+             link: ->(row) { endpoint_path(@database, row["endpoint"]) } %>
+
+  <p class="dim" data-filter-empty hidden>No endpoints match that filter.</p>
 
   <p class="dim">
     <strong>q/req</strong> is an estimate: the request count is inferred from the

data/app/views/pg_peek/endpoints/show.html.erb

@@ -0,0 +1,17 @@
+<div class="toolbar">
+  <h1><code class="name"><%= @endpoint %></code></h1>
+  <%= link_to "← endpoints", database_endpoints_path(@database) %>
+</div>
+
+<% if @report.empty? %>
+  <article aria-label="No queries found">
+    <header>No queries found for this endpoint</header>
+    <p>This could mean:</p>
+    <ul>
+      <li>The endpoint hasn't executed any database queries since statistics were last reset</li>
+      <li>The endpoint's queries are not among the top outliers</li>
+    </ul>
+  </article>
+<% else %>
+  <%= render "pg_peek/reports/report", report: @report %>
+<% end %>

data/app/views/pg_peek/jobs/index.html.erb

@@ -45,7 +45,7 @@
   <%= render "pg_peek/reports/report",
              report: @report,
              link_column: :job_class,
-             link: ->(row) { database_job_path(@database, ERB::Util.url_encode(row["job_class"])) } %>
+             link: ->(row) { database_job_path(@database, row["job_class"]) } %>
 
   <p class="dim" data-filter-empty hidden>No jobs match that filter.</p>
 <% end %>

data/app/views/pg_peek/jobs/show.html.erb

@@ -1,5 +1,5 @@
 <div class="toolbar">
-  <h1><%= @job_class %></h1>
+  <h1><code class="name"><%= @job_class %></code></h1>
   <%= link_to "← jobs", database_jobs_path(@database) %>
 </div>
 

data/app/views/pg_peek/pg_stat_statements/_preload_instructions.html.erb

@@ -11,7 +11,11 @@
   <footer>
     <small>
       A server restart is required — this setting cannot be reloaded.
-      Currently loaded: <code><%= pg_stat_statements.shared_preload_libraries.presence || "(none)" %></code>
+      <% if pg_stat_statements.shared_preload_libraries %>
+        Currently loaded: <code><%= pg_stat_statements.shared_preload_libraries.presence || "(none)" %></code>
+      <% else %>
+        This role may not read <code>shared_preload_libraries</code>; the module itself reported it is not loaded.
+      <% end %>
     </small>
   </footer>
 </article>

data/app/views/pg_peek/tables/show.html.erb

@@ -1,5 +1,5 @@
 <div class="toolbar">
-  <h1><%= @table.name %></h1>
+  <h1><code class="name"><%= @table.name %></code></h1>
   <%= link_to "← tables", database_path(@database, anchor: "tables") %>
 </div>
 

data/config/routes.rb

@@ -3,6 +3,9 @@ PgPeek::Engine.routes.draw do
     resources :queries, only: [ :index ]
     resources :tables, only: [ :show ], param: :name
     resources :endpoints, only: [ :index ]
+    # admin/posts#index lives at endpoints/admin/posts/index: the slashes of a
+    # namespace stay as they are, and no # needs encoding.
+    get "endpoints/*endpoint_controller/:endpoint_action", to: "endpoints#show", as: :endpoint, format: false
     resources :indexes, only: [ :index ]
     resource :activity, only: [ :show ], controller: "activity"
     resources :jobs, only: [ :index, :show ], param: :job_class

data/lib/generators/pg_peek/install/templates/initializer.rb

@@ -29,6 +29,15 @@ Rails.application.config.pg_peek.tap do |config|
   # Dead tuple ratio threshold (percentage) for warnings.
   # config.dead_tuple_warning_threshold = 10
 
+  # Index scan counts start from zero when statistics are reset, so right
+  # after a reset every index looks unused. The overview waits this long
+  # before calling unused indexes out.
+  # config.unused_index_min_stats_age = 1.day
+
+  # Unused indexes smaller than this (in bytes) are left out of the overview;
+  # the indexes page still lists them all.
+  # config.unused_index_min_size = 1.megabyte
+
   # A query running longer than this is called out on the overview.
   # config.long_query_warning_seconds = 5
 

data/lib/pg_peek/configuration.rb

@@ -1,3 +1,5 @@
+require "active_support/core_ext/integer/time"
+
 module PgPeek
   class Configuration
     DEFAULT_EXCLUDED_TABLES = %w[schema_migrations ar_internal_metadata].freeze
@@ -6,10 +8,13 @@ module PgPeek
     DEFAULT_CACHE_HIT_WARNING_THRESHOLD = 99 # percentage
     DEFAULT_LONG_QUERY_WARNING_SECONDS = 5
     DEFAULT_IDLE_IN_TRANSACTION_WARNING_SECONDS = 60
+    DEFAULT_UNUSED_INDEX_MIN_STATS_AGE = 1.day
+    DEFAULT_UNUSED_INDEX_MIN_SIZE = 1.megabyte
 
     attr_accessor :connections, :excluded_tables, :dead_tuple_warning_threshold, :outliers_limit,
                   :cache_hit_warning_threshold, :long_query_warning_seconds,
-                  :idle_in_transaction_warning_seconds, :public_dashboard
+                  :idle_in_transaction_warning_seconds, :unused_index_min_stats_age,
+                  :unused_index_min_size, :public_dashboard
     attr_writer :username, :password
 
     def initialize
@@ -20,6 +25,8 @@ module PgPeek
       @cache_hit_warning_threshold = DEFAULT_CACHE_HIT_WARNING_THRESHOLD
       @long_query_warning_seconds = DEFAULT_LONG_QUERY_WARNING_SECONDS
       @idle_in_transaction_warning_seconds = DEFAULT_IDLE_IN_TRANSACTION_WARNING_SECONDS
+      @unused_index_min_stats_age = DEFAULT_UNUSED_INDEX_MIN_STATS_AGE
+      @unused_index_min_size = DEFAULT_UNUSED_INDEX_MIN_SIZE
       @public_dashboard = false
     end
 

data/lib/pg_peek/version.rb

@@ -1,3 +1,3 @@
 module PgPeek
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_peek
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Tomasz Mazur
@@ -78,6 +78,7 @@ files:
 - app/queries/pg_peek/pg14/pg_stat_statements/endpoints.sql
 - app/queries/pg_peek/pg14/pg_stat_statements/jobs.sql
 - app/queries/pg_peek/pg14/pg_stat_statements/outliers.sql
+- app/queries/pg_peek/pg14/pg_stat_statements/outliers_by_endpoint.sql
 - app/queries/pg_peek/pg14/pg_stat_statements/outliers_by_job.sql
 - app/queries/pg_peek/pg14/tables/dead_tuples.sql
 - app/queries/pg_peek/pg14/tables/inline_stats.sql
@@ -90,6 +91,7 @@ files:
 - app/queries/pg_peek/pg15/pg_stat_statements/endpoints.sql
 - app/queries/pg_peek/pg15/pg_stat_statements/jobs.sql
 - app/queries/pg_peek/pg15/pg_stat_statements/outliers.sql
+- app/queries/pg_peek/pg15/pg_stat_statements/outliers_by_endpoint.sql
 - app/queries/pg_peek/pg15/pg_stat_statements/outliers_by_job.sql
 - app/queries/pg_peek/pg15/tables/dead_tuples.sql
 - app/queries/pg_peek/pg15/tables/inline_stats.sql
@@ -102,6 +104,7 @@ files:
 - app/queries/pg_peek/pg16/pg_stat_statements/endpoints.sql
 - app/queries/pg_peek/pg16/pg_stat_statements/jobs.sql
 - app/queries/pg_peek/pg16/pg_stat_statements/outliers.sql
+- app/queries/pg_peek/pg16/pg_stat_statements/outliers_by_endpoint.sql
 - app/queries/pg_peek/pg16/pg_stat_statements/outliers_by_job.sql
 - app/queries/pg_peek/pg16/tables/dead_tuples.sql
 - app/queries/pg_peek/pg16/tables/inline_stats.sql
@@ -114,6 +117,7 @@ files:
 - app/queries/pg_peek/pg17/pg_stat_statements/endpoints.sql
 - app/queries/pg_peek/pg17/pg_stat_statements/jobs.sql
 - app/queries/pg_peek/pg17/pg_stat_statements/outliers.sql
+- app/queries/pg_peek/pg17/pg_stat_statements/outliers_by_endpoint.sql
 - app/queries/pg_peek/pg17/pg_stat_statements/outliers_by_job.sql
 - app/queries/pg_peek/pg17/tables/dead_tuples.sql
 - app/queries/pg_peek/pg17/tables/inline_stats.sql
@@ -126,6 +130,7 @@ files:
 - app/queries/pg_peek/pg18/pg_stat_statements/endpoints.sql
 - app/queries/pg_peek/pg18/pg_stat_statements/jobs.sql
 - app/queries/pg_peek/pg18/pg_stat_statements/outliers.sql
+- app/queries/pg_peek/pg18/pg_stat_statements/outliers_by_endpoint.sql
 - app/queries/pg_peek/pg18/pg_stat_statements/outliers_by_job.sql
 - app/queries/pg_peek/pg18/tables/dead_tuples.sql
 - app/queries/pg_peek/pg18/tables/inline_stats.sql
@@ -134,6 +139,7 @@ files:
 - app/reports/pg_peek/report.rb
 - app/reports/pg_peek/reports/blocked.rb
 - app/reports/pg_peek/reports/databases.rb
+- app/reports/pg_peek/reports/endpoint_queries.rb
 - app/reports/pg_peek/reports/endpoints.rb
 - app/reports/pg_peek/reports/indexes.rb
 - app/reports/pg_peek/reports/job_queries.rb
@@ -147,6 +153,7 @@ files:
 - app/views/pg_peek/databases/index.html.erb
 - app/views/pg_peek/databases/show.html.erb
 - app/views/pg_peek/endpoints/index.html.erb
+- app/views/pg_peek/endpoints/show.html.erb
 - app/views/pg_peek/indexes/index.html.erb
 - app/views/pg_peek/jobs/index.html.erb
 - app/views/pg_peek/jobs/show.html.erb
@@ -171,6 +178,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/trix/pg_peek
   source_code_uri: https://github.com/trix/pg_peek
+  changelog_uri: https://github.com/trix/pg_peek/releases
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths: