pg_reports 0.9.0 → 1.0.0

data/lib/pg_reports/executor.rb

@@ -7,25 +7,39 @@ module PgReports
   # context set by PgReports.with_target / with_database is honored even when an
   # Executor instance has been memoized at the module level.
   class Executor
+    # Marks the SQL as ours where a statement name cannot reach: inside a host
+    # application these queries share its connections and application_name, so
+    # this is all that tells them apart in pg_stat_activity.
+    QUERY_TAG = "/* pg_reports */"
+
+    # A report that needs a lock someone else holds has nothing to wait for: during
+    # an incident the answer is more use now than after the full statement timeout.
+    REPORT_LOCK_TIMEOUT_MS = 3_000
+
+    # Not the second colon of a :: cast, nor the middle of a word
+    PLACEHOLDER = /(?<![:\w]):([a-zA-Z_]\w*)/
+
     def initialize(connection: nil)
       @connection_override = connection
     end
 
-    # Execute SQL from a file and return results as array of hashes
+    # Execute SQL from a file and return results as array of hashes.
+    #
+    # These files only read, so they run under the report time limits.
     def execute_from_file(category, name, **params)
       sql = SqlLoader.load(category, name)
-      execute(sql, **params)
+      within_report_limits { execute(sql, **params) }
     end
 
     # Execute raw SQL and return results as array of hashes.
     #
     # Every query is tagged with the "PgReports" AR statement name so the Query
-    # Monitor can skip our own queries by name (see QueryMonitor#should_skip?),
+    # Monitor can skip our own queries by name (see QueryMonitor#skip_by_payload?),
     # reliably and independent of backtrace depth — the internal live_metrics /
     # status polling would otherwise leak into the monitor's history.
     def execute(sql, **params)
       processed_sql = interpolate_params(sql, params)
-      result = connection.exec_query(processed_sql, "PgReports")
+      result = connection.exec_query("#{QUERY_TAG} #{processed_sql}", "PgReports")
       result.to_a
     end
 
@@ -36,14 +50,37 @@ module PgReports
 
     private
 
-    # Simple parameter interpolation for SQL
-    # Replaces :param_name with quoted values
+    # The limits are local to a transaction, and a savepoint inside the host
+    # application's transaction would hand them on to it when released. Rolling back
+    # discards them in both cases, and there is nothing here to keep.
+    def within_report_limits
+      timeout_ms = PgReports.config.report_statement_timeout_ms.to_i
+      return yield unless timeout_ms.positive?
+
+      rows = nil
+      connection.transaction(requires_new: true) do
+        connection.exec_query(report_limits_sql(timeout_ms), "PgReports")
+        rows = yield
+        raise ActiveRecord::Rollback
+      end
+      rows
+    end
+
+    def report_limits_sql(timeout_ms)
+      lock_timeout_ms = [timeout_ms, REPORT_LOCK_TIMEOUT_MS].min
+
+      "#{QUERY_TAG} SELECT set_config('statement_timeout', '#{timeout_ms}', true), " \
+        "set_config('lock_timeout', '#{lock_timeout_ms}', true)"
+    end
+
+    # Replaces :param_name with quoted values in a single pass, so a value is never
+    # read back as SQL: one holding ":other" stays text, and :limit leaves :limit_x alone.
     def interpolate_params(sql, params)
       return sql if params.empty?
 
-      params.reduce(sql) do |query, (key, value)|
-        quoted_value = quote_value(value)
-        query.gsub(":#{key}", quoted_value)
+      sql.gsub(PLACEHOLDER) do |placeholder|
+        key = Regexp.last_match(1).to_sym
+        params.key?(key) ? quote_value(params[key]) : placeholder
       end
     end
 

data/lib/pg_reports/modules/queries.rb

@@ -10,6 +10,7 @@ module PgReports
       # The following methods are auto-generated from YAML:
       # - slow_queries(limit: 20)
       # - heavy_queries(limit: 20)
+      # - frequent_queries(limit: 20)
       # - expensive_queries(limit: 20)
       # - missing_index_queries(limit: 20)
       # - low_cache_hit_queries(limit: 20, min_calls: 100)