rails_pulse 0.4.2 → 0.5.0.pre.2

data/lib/rails_pulse/mcp/tools/insights.rb

@@ -0,0 +1,99 @@
+module RailsPulse
+  module Mcp
+    module Tools
+      class Insights < ::MCP::Tool
+        extend Helpers
+
+        PERIODS = %w[hour day week month].freeze
+
+        tool_name "rails_pulse_insights"
+        description "What needs attention over one summary period, and whether the configured thresholds fit " \
+                    "it. Lists the routes, queries and jobs past their slow or critical thresholds (critical " \
+                    "first, ten at most), then checks route_thresholds and query_thresholds against the " \
+                    "period's slowest routes and most expensive queries and returns a config line to paste " \
+                    "when one is too noisy or never fires. Use it for 'what should I look at' and 'are my " \
+                    "thresholds right'. Reads whole periods, so the P95s are exact."
+
+        annotations(
+          read_only_hint: true,
+          destructive_hint: false,
+          open_world_hint: false
+        )
+
+        input_schema(
+          properties: {
+            period: {
+              type: "string",
+              enum: PERIODS,
+              description: "Summary period to read: 'hour', 'day', 'week' or 'month'.",
+              default: "week"
+            },
+            at: {
+              type: "string",
+              description: "A time inside the period, ISO 8601 (read as UTC with no zone). Omit for the last " \
+                           "complete period; the current one has no summary until it ends."
+            }
+          }
+        )
+
+        def self.call(period: "week", at: nil, server_context:, **_options)
+          respond(server_context) do |client|
+            unless PERIODS.include?(period)
+              raise Helpers::WindowError, "Unknown period #{period.inspect}. Use #{PERIODS.join(', ')}."
+            end
+
+            params = { period: period }
+            params[:at] = parse_time(at, "at").iso8601 if at
+            data = client.get("/insights", params)
+            attention = data["needs_attention"] || {}
+            recommendations = data["threshold_recommendations"] || []
+
+            {
+              period: data["period"],
+              thresholds: data["thresholds"],
+              needs_attention: attention,
+              threshold_recommendations: recommendations,
+              summary: build_summary(data["period"] || {}, attention, recommendations),
+              next_steps: build_next_steps(data["period"] || {}, attention, recommendations)
+            }
+          end
+        end
+
+        private_class_method def self.build_summary(period, attention, recommendations)
+          critical = Array(attention["critical"]).size
+          warning = Array(attention["warning"]).size
+          if !period["summarized"] && critical.zero? && warning.zero?
+            return "The #{period['type']} starting #{period['start']} has not been summarized yet."
+          end
+
+          parts = [ "#{period['type'].to_s.capitalize} starting #{period['start']}: #{critical} critical, #{warning} warning." ]
+          parts << "#{recommendations.size} threshold change(s) suggested." if recommendations.any?
+          parts << "SummaryJob has not finished this period, so the list may be incomplete." unless period["summarized"]
+          parts.join(" ")
+        end
+
+        private_class_method def self.build_next_steps(period, attention, recommendations)
+          items = Array(attention["critical"]) + Array(attention["warning"])
+          if !period["summarized"] && items.empty?
+            return [ "Pass an earlier 'at', or call rails_pulse_coverage to see how far summaries reach." ]
+          end
+
+          steps = []
+          if (route = items.find { |i| i["type"] == "route" })
+            steps << "Profile #{route['name']} with rails_pulse_endpoint, and pass route: #{route['id']} to " \
+                     "rails_pulse_queries for the SQL inside it."
+          end
+          if items.any? { |i| i["type"] == "job" }
+            steps << "Call rails_pulse_jobs for the failing or slow jobs' recent runs and error classes."
+          end
+          if recommendations.any?
+            steps << "Each config_snippet replaces the whole setting in config/initializers/rails_pulse.rb; " \
+                     "check the period was typical before changing a threshold."
+          end
+          steps << "Nothing passed its thresholds; compare an earlier period to confirm." if items.empty? && recommendations.empty?
+          steps
+        end
+      end
+    end
+  end
+end

data/lib/rails_pulse/mcp/tools/jobs.rb

@@ -0,0 +1,155 @@
+module RailsPulse
+  module Mcp
+    module Tools
+      class Jobs < ::MCP::Tool
+        extend Helpers
+
+        ERROR_MESSAGE_LENGTH = 200
+
+        # Failed runs fetched for recent_failures. The count reported beside
+        # them is the API's total, not the size of this sample.
+        FAILED_RUN_SAMPLE = 100
+
+        tool_name "rails_pulse_jobs"
+        description "Background job health: failure rates, slow jobs, and recent failures with error classes. " \
+                    "Use this to find failing or slow background jobs."
+
+        annotations(
+          read_only_hint: true,
+          destructive_hint: false,
+          open_world_hint: false
+        )
+
+        input_schema(
+          properties: {
+            **Helpers.window_properties("last_24_hours"),
+            limit: {
+              type: "integer",
+              description: "Maximum number of jobs to return (1-50)",
+              default: 10
+            },
+            job: {
+              type: "string",
+              description: "Restrict to one job class (e.g. 'GenerateReportJob')"
+            }
+          }
+        )
+
+        def self.call(period: "last_24_hours", limit: 10, job: nil, server_context:, **options)
+          respond(server_context) do |client|
+            window = resolve_window(period: period, since: options[:since], until_time: options[:until])
+            limit = limit.to_i.clamp(1, 50)
+
+            # Windowed: the API answers these from summaries so the counts and
+            # durations cover the same period as recent_failures. Every job is
+            # fetched because the API orders by name and the ranking here is
+            # by failure rate; a first page would drop the worst after the
+            # alphabet ran past it.
+            job_params = window_params(window)
+            job_params[:job] = job if job
+            jobs, result = fetch_all(client, "/jobs", job_params)
+            granularity = result.dig("meta", "window", "period_type")
+
+            run_params = window_params(window).merge(status: "failed", limit: FAILED_RUN_SAMPLE)
+            run_params[:job] = job if job
+            runs_result = client.get("/job_runs", run_params)
+            failed_runs = runs_result["data"] || []
+            failed_total = runs_result.dig("meta", "total") || failed_runs.size
+
+            formatted = jobs.map { |j| format_job(j) }
+              .sort_by { |j| [ -j[:failure_rate].to_f, -slowness(j) ] }
+              .first(limit)
+
+            payload = {
+              window: window.merge(granularity ? { summary_period: granularity } : {}),
+              jobs: formatted,
+              failed_runs: failed_total,
+              recent_failures: format_failures(failed_runs),
+              summary: build_summary(formatted, jobs.size, failed_total, failed_runs.size),
+              next_steps: build_next_steps(formatted, failed_runs)
+            }
+            note = formatted.filter_map { |j| j[:percentiles_note] }.first
+            payload[:note] = note if note
+            payload
+          end
+        end
+
+        # The tool always asks for a window, so every figure comes from the
+        # window's `stats`. The job's lifetime counters are never substituted:
+        # a withheld percentile stays nil rather than becoming an all-time one.
+        private_class_method def self.format_job(job)
+          stats = job["stats"] || {}
+          formatted = {
+            name: job["name"],
+            queue: job["queue_name"],
+            runs: stats["runs_count"].to_i,
+            failures: stats["failures_count"].to_i,
+            failure_rate: stats["failure_rate"].to_f.round(1),
+            avg_ms: stats["avg_duration"]&.to_f&.round(1),
+            max_ms: stats["max_duration"]&.to_f&.round(1),
+            p95_ms: stats["p95_duration"]&.to_f&.round(1),
+            p99_ms: stats["p99_duration"]&.to_f&.round(1)
+          }
+          formatted[:percentiles_note] = stats["percentiles_note"] if stats["percentiles_note"]
+          formatted
+        end
+
+        # p95 when the window has one, otherwise the mean.
+        private_class_method def self.slowness(job)
+          (job[:p95_ms] || job[:avg_ms]).to_f
+        end
+
+        private_class_method def self.format_failures(runs)
+          runs.group_by { |r| r["job_name"] || "unknown" }.map do |name, group|
+            latest = group.max_by { |r| r["occurred_at"].to_s }
+            {
+              job: name,
+              count: group.size,
+              error_classes: group.map { |r| r["error_class"] || "unknown" }.tally,
+              latest: {
+                occurred_at: latest["occurred_at"],
+                error_class: latest["error_class"],
+                error_message: truncate(latest["error_message"], ERROR_MESSAGE_LENGTH),
+                attempts: latest["attempts"]
+              }
+            }
+          end.sort_by { |f| -f[:count] }
+        end
+
+        private_class_method def self.build_summary(jobs, job_total, failed_total, failed_sampled)
+          return "No background jobs recorded." if jobs.empty?
+
+          failed = "#{failed_total} failed run(s) in period"
+          failed += " (latest #{failed_sampled} grouped in recent_failures)" if failed_total > failed_sampled
+          parts = [ "#{job_total} job(s) ran, #{failed}" ]
+          worst = jobs.max_by { |j| j[:failure_rate] }
+          parts << "Highest failure rate: #{worst[:name]} (#{worst[:failure_rate]}%)" if worst[:failure_rate] > 0
+          slowest = jobs.max_by { |j| slowness(j) }
+          if slowest
+            label = slowest[:p95_ms] ? "p95 #{slowest[:p95_ms]}ms" : "avg #{slowest[:avg_ms]}ms"
+            parts << "Slowest: #{slowest[:name]} (#{label})"
+          end
+          parts.join(". ") + "."
+        end
+
+        private_class_method def self.build_next_steps(jobs, failed_runs)
+          steps = []
+          if jobs.empty?
+            steps << "No jobs tracked — confirm `config.track_jobs` is enabled in the Rails Pulse initializer."
+          end
+          if failed_runs.any?
+            steps << "Group failures by error_class in recent_failures; a single class dominating usually points at one root cause."
+          end
+          if jobs.any? { |j| j[:failure_rate] > 5 }
+            steps << "Jobs with failure rate above 5% need retry/discard handling reviewed."
+          end
+          if jobs.any? { |j| slowness(j) > 60_000 }
+            steps << "Jobs taking over 60s (p95, or the mean where no p95 is given) may be blocking queues — consider splitting or batching."
+          end
+          steps << "Use rails_pulse_queries to check whether slow jobs are dominated by SQL."
+          steps
+        end
+      end
+    end
+  end
+end

data/lib/rails_pulse/mcp/tools/queries.rb

@@ -0,0 +1,142 @@
+module RailsPulse
+  module Mcp
+    module Tools
+      class Queries < ::MCP::Tool
+        extend Helpers
+
+        SQL_LENGTH = 300
+        MAX_PAGE = 500
+
+        tool_name "rails_pulse_queries"
+        description "Find the most expensive SQL queries for a time period: execution count, average/max/total time, " \
+                    "and N+1 detection. Use this to see which queries are worth optimising."
+
+        annotations(
+          read_only_hint: true,
+          destructive_hint: false,
+          open_world_hint: false
+        )
+
+        input_schema(
+          properties: {
+            **Helpers.window_properties("last_24_hours"),
+            limit: {
+              type: "integer",
+              description: "Maximum number of queries (1-50)",
+              default: 10
+            },
+            sort: {
+              type: "string",
+              description: "Order by 'total_duration' (default), 'avg_duration', 'max_duration', or 'executions'",
+              default: "total_duration"
+            },
+            n_plus_one_only: {
+              type: "boolean",
+              description: "Only return queries flagged as likely N+1",
+              default: false
+            },
+            # rails_pulse_endpoint and rails_pulse_slow_requests hand back an
+            # integer route_id, so the next call passes a number.
+            route: {
+              type: %w[integer string],
+              description: "Restrict to SQL issued while serving one endpoint. A route_id from rails_pulse_routes " \
+                           "or rails_pulse_slow_requests, or a controller action or path to match on."
+            },
+            hashed_sql: {
+              type: "string",
+              description: "Exact hashed_sql of one query, as returned by this tool or by Rails Pulse Cloud"
+            }
+          }
+        )
+
+        def self.call(period: "last_24_hours", limit: 10, sort: "total_duration", n_plus_one_only: false, route: nil, hashed_sql: nil, server_context:, **options)
+          respond(server_context) do |client|
+            window = resolve_window(period: period, since: options[:since], until_time: options[:until])
+            limit = limit.to_i.clamp(1, 50)
+            # The N+1 flag is filtered here, not by the API, so fetch the
+            # largest page it allows and keep the first `limit` matches.
+            page = n_plus_one_only ? MAX_PAGE : limit
+            params = window_params(window).merge(sort: sort, limit: page)
+            params[:route] = route if route
+            params[:hashed_sql] = hashed_sql if hashed_sql
+            result = client.get("/queries", params)
+
+            queries = (result["data"] || []).map { |q| format_query(q) }
+            queries = queries.select { |q| q[:n_plus_one][:likely] }.first(limit) if n_plus_one_only
+
+            payload = {
+              window: window,
+              sort: sort,
+              total_queries: result.dig("meta", "total") || queries.size,
+              queries: queries,
+              summary: build_summary(queries),
+              next_steps: build_next_steps(queries)
+            }
+            payload[:route] = route if route
+            payload
+          end
+        end
+
+        # Transaction control repeats within a request by design; it is never
+        # an N+1 however often it appears.
+        TRANSACTION_STATEMENT = /\A(BEGIN|COMMIT|ROLLBACK|SAVEPOINT|RELEASE)\b/i
+
+        private_class_method def self.format_query(query)
+          stats = query["stats"] || {}
+          analysis = query["n_plus_one"] || {}
+          repetition = stats["max_repetition_count"].to_i
+          sql = query["normalized_sql"].to_s.gsub(/\s+/, " ").strip
+          repeated = repetition > 1 && !sql.match?(TRANSACTION_STATEMENT)
+
+          {
+            id: query["id"],
+            hashed_sql: query["hashed_sql"],
+            sql: truncate(sql, SQL_LENGTH),
+            executions: stats["executions"],
+            avg_duration_ms: stats["avg_duration_ms"],
+            max_duration_ms: stats["max_duration_ms"],
+            total_duration_ms: stats["total_duration_ms"],
+            n_plus_one: {
+              likely: analysis["likely"] == true || repeated,
+              confidence: analysis["confidence"],
+              max_repetition_count: repetition > 0 ? repetition : nil
+            },
+            issue_count: Array(query["issues"]).size,
+            suggestions: Array(query["suggestions"]),
+            # Where the query was issued from, most frequent first, so the
+            # investigation reaches the code rather than stopping at the SQL.
+            source_locations: Array(stats["source_locations"])
+          }
+        end
+
+        private_class_method def self.build_summary(queries)
+          return "No query activity found for this period." if queries.empty?
+
+          top = queries.first
+          n_plus_one = queries.count { |q| q[:n_plus_one][:likely] }
+          parts = [ "Top query by #{top[:executions]} executions / #{top[:total_duration_ms]}ms total: #{truncate(top[:sql], 80)}" ]
+          parts << "#{n_plus_one} likely N+1 quer#{n_plus_one == 1 ? 'y' : 'ies'}" if n_plus_one > 0
+          parts.join(". ") + "."
+        end
+
+        private_class_method def self.build_next_steps(queries)
+          steps = []
+          if queries.any? { |q| q[:n_plus_one][:likely] }
+            steps << "N+1 candidates: find the call site and preload the association (`includes`/`preload`) or batch the lookup."
+          end
+          if queries.any? { |q| q[:avg_duration_ms].to_f > 100 }
+            steps << "Queries averaging over 100ms: check `suggestions` for missing indexes and run EXPLAIN on the normalized SQL."
+          end
+          if queries.any? { |q| q[:executions].to_i > 1000 && q[:avg_duration_ms].to_f < 5 }
+            steps << "Very frequent fast queries add up — consider caching or reducing calls per request."
+          end
+          if queries.any? { |q| q[:source_locations].any? }
+            steps << "source_locations names the file and line each query was issued from — start there rather than searching for the SQL."
+          end
+          steps << "Use rails_pulse_endpoint to see which endpoints are slow and correlate with these queries."
+          steps
+        end
+      end
+    end
+  end
+end

data/lib/rails_pulse/mcp/tools/routes.rb

@@ -0,0 +1,108 @@
+module RailsPulse
+  module Mcp
+    module Tools
+      class Routes < ::MCP::Tool
+        extend Helpers
+
+        tool_name "rails_pulse_routes"
+        description "List the application's tracked routes/endpoints with request volume, average latency, and error " \
+                    "counts for a period. Use this to discover endpoint names before calling rails_pulse_endpoint."
+
+        annotations(
+          read_only_hint: true,
+          destructive_hint: false,
+          open_world_hint: false
+        )
+
+        input_schema(
+          properties: {
+            **Helpers.window_properties("last_7_days"),
+            search: {
+              type: "string",
+              description: "Case-insensitive substring match on path or controller action (e.g. 'checkout')"
+            },
+            path: {
+              type: "string",
+              description: "Exact route path, e.g. '/orders/:id'. With controller_action, identifies one route " \
+                           "the way Rails Pulse Cloud does."
+            },
+            controller_action: {
+              type: "string",
+              description: "Exact controller action, e.g. 'orders#show'"
+            },
+            limit: {
+              type: "integer",
+              description: "Maximum number of routes (1-100)",
+              default: 50
+            },
+            sort: {
+              type: "string",
+              description: "Order by 'request_count' (default), 'avg_duration', or 'error_count'",
+              default: "request_count"
+            }
+          }
+        )
+
+        def self.call(period: "last_7_days", search: nil, path: nil, controller_action: nil, limit: 50, sort: "request_count", server_context:, **options)
+          respond(server_context) do |client|
+            window = resolve_window(period: period, since: options[:since], until_time: options[:until])
+            limit = limit.to_i.clamp(1, 100)
+
+            params = window_params(window).merge(sort: sort, limit: limit)
+            params[:search] = search if search
+            params[:path] = path if path
+            params[:controller_action] = controller_action if controller_action
+            result = client.get("/routes", params)
+
+            routes = (result["data"] || []).map { |r| format_route(r) }
+            routes.select! { |r| matches?(r, search) } if search
+
+            {
+              window: window,
+              sort: sort,
+              total_routes: result.dig("meta", "total") || routes.size,
+              routes: routes,
+              summary: build_summary(routes, search),
+              next_steps: [
+                "Pass a route's controller_action (e.g. 'CheckoutController#create') to rails_pulse_endpoint for a full profile.",
+                "Routes with traffic but no controller_action are usually engine or Rack endpoints."
+              ]
+            }
+          end
+        end
+
+        private_class_method def self.format_route(route)
+          stats = route["stats"] || {}
+          {
+            id: route["id"],
+            http_methods: route["http_methods"],
+            path: route["path"],
+            controller_action: route["controller_action"],
+            request_count: stats["request_count"],
+            avg_duration_ms: stats["avg_duration_ms"],
+            error_count: stats["error_count"],
+            tags: route["tags"]
+          }
+        end
+
+        private_class_method def self.matches?(route, search)
+          term = search.downcase
+          route[:path].to_s.downcase.include?(term) || route[:controller_action].to_s.downcase.include?(term)
+        end
+
+        private_class_method def self.build_summary(routes, search)
+          if routes.empty?
+            return search ? "No routes matching '#{search}' had traffic in this period." : "No routes had traffic in this period."
+          end
+
+          busiest = routes.max_by { |r| r[:request_count].to_i }
+          parts = [ "#{routes.size} route(s) with traffic" ]
+          parts << "Busiest: #{busiest[:controller_action] || busiest[:path]} (#{busiest[:request_count]} requests)"
+          slowest = routes.max_by { |r| r[:avg_duration_ms].to_f }
+          parts << "Slowest: #{slowest[:controller_action] || slowest[:path]} (avg #{slowest[:avg_duration_ms]}ms)" if slowest
+          parts.join(". ") + "."
+        end
+      end
+    end
+  end
+end

data/lib/rails_pulse/mcp/tools/slow_requests.rb

@@ -0,0 +1,118 @@
+require "json"
+
+module RailsPulse
+  module Mcp
+    module Tools
+      class SlowRequests < ::MCP::Tool
+        extend Helpers
+
+        tool_name "rails_pulse_slow_requests"
+        description "The slowest endpoints for a time period, ranked by average response time over every " \
+                    "request in the window, with request volume and error counts. " \
+                    "Use this to find which routes are taking the longest to respond."
+
+        annotations(
+          read_only_hint: true,
+          destructive_hint: false,
+          open_world_hint: false
+        )
+
+        input_schema(
+          properties: {
+            **Helpers.window_properties("last_24_hours"),
+            limit: {
+              type: "integer",
+              description: "Maximum number of endpoints (1-100)",
+              default: 10
+            },
+            min_requests: {
+              type: "integer",
+              description: "Skip endpoints with fewer requests than this in the period, so a single slow hit does not top the list",
+              default: 1
+            }
+          }
+        )
+
+        # The routes endpoint aggregates every request in the window on the
+        # server, so the ranking covers the whole period rather than a page
+        # of the most recent requests.
+        def self.call(period: "last_24_hours", limit: 10, min_requests: 1, server_context:, **options)
+          respond(server_context) do |client|
+            window = resolve_window(period: period, since: options[:since], until_time: options[:until])
+            limit = limit.to_i.clamp(1, 100)
+            min_requests = min_requests.to_i.clamp(1, 1_000_000)
+
+            result = client.get("/routes", window_params(window).merge(sort: "avg_duration", limit: limit, min_requests: min_requests))
+            routes = result["data"] || []
+            routes_with_traffic = result.dig("meta", "routes_with_traffic") || result.dig("meta", "total") || 0
+
+            endpoints = routes.map do |route|
+              stats = route["stats"] || {}
+              request_count = stats["request_count"].to_i
+              error_count = stats["error_count"].to_i
+              {
+                # The stable handle for a follow-up call: passing it to
+                # rails_pulse_queries avoids a name lookup that a path
+                # containing a LIKE metacharacter could get wrong.
+                route_id: route["id"],
+                endpoint: route["controller_action"] || route["path"],
+                path: route["path"],
+                http_methods: route["http_methods"],
+                request_count: request_count,
+                avg_duration_ms: stats["avg_duration_ms"].to_f.round(1),
+                error_count: error_count,
+                error_rate: request_count > 0 ? ((error_count.to_f / request_count) * 100).round(1) : 0
+              }
+            end
+
+            {
+              window: window,
+              routes_with_traffic: routes_with_traffic,
+              min_requests: min_requests,
+              endpoints: endpoints,
+              summary: build_summary(endpoints, routes_with_traffic, min_requests),
+              next_steps: build_next_steps(endpoints, routes_with_traffic, min_requests)
+            }
+          end
+        end
+
+        # An empty result means one of two things, and they lead to different
+        # next steps: nothing was recorded at all, or endpoints ran but none
+        # reached min_requests.
+        private_class_method def self.build_summary(endpoints, routes_with_traffic, min_requests)
+          if endpoints.empty?
+            return "No request data found for this period." if routes_with_traffic.zero?
+
+            return "#{routes_with_traffic} #{routes_with_traffic == 1 ? 'endpoint' : 'endpoints'} received traffic, " \
+                   "but none reached min_requests of #{min_requests}."
+          end
+
+          slowest = endpoints.first
+          parts = [ "Slowest endpoint: #{slowest[:endpoint]} (avg #{slowest[:avg_duration_ms]}ms over #{slowest[:request_count]} requests)" ]
+
+          error_endpoints = endpoints.select { |e| e[:error_rate] > 0 }
+          if error_endpoints.any?
+            worst = error_endpoints.max_by { |e| e[:error_rate] }
+            parts << "Highest error rate: #{worst[:endpoint]} (#{worst[:error_rate]}%)"
+          end
+
+          parts.join(". ") + "."
+        end
+
+        private_class_method def self.build_next_steps(endpoints, routes_with_traffic, min_requests)
+          if endpoints.empty?
+            return [ "Lower min_requests below #{min_requests} to rank the #{routes_with_traffic} #{routes_with_traffic == 1 ? 'endpoint' : 'endpoints'} that did receive traffic." ] if routes_with_traffic > 0
+
+            return [ "Widen the period or confirm requests are being recorded (rails_pulse_routes with period: \"last_7_days\")." ]
+          end
+
+          steps = [ "Pass an endpoint's controller_action to rails_pulse_endpoint for percentiles and recent errors." ]
+          steps << "Pass an endpoint's route_id to rails_pulse_queries to see the SQL that ran inside it and where it was issued from."
+          steps << "Low-volume endpoints at the top may be one slow hit; raise min_requests to rank by sustained latency." if endpoints.any? { |e| e[:request_count] < 5 }
+          steps << "Use rails_pulse_queries with the same period to see whether SQL accounts for the time."
+          steps
+        end
+      end
+    end
+  end
+end

data/lib/rails_pulse/middleware/request_collector.rb

@@ -10,7 +10,7 @@ module RailsPulse
         return @app.call(env) unless RailsPulse.configuration.enabled
 
         # Skip logging if we are already recording RailsPulse activity. This is to avoid recursion issues
-        return @app.call(env) if RequestStore.store[:skip_recording_rails_pulse_activity]
+        return @app.call(env) if RailsPulse::Current.skip_recording_rails_pulse_activity
 
         req = ActionDispatch::Request.new(env)
 
@@ -26,8 +26,8 @@ module RailsPulse
         end
 
         # Clear any previous request data and set a placeholder ID
-        RequestStore.store[:rails_pulse_request_id] = SecureRandom.uuid
-        RequestStore.store[:rails_pulse_operations] = []
+        RailsPulse::Current.rails_pulse_request_id = SecureRandom.uuid
+        RailsPulse::Current.rails_pulse_operations = []
 
         start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         occurred_at = Time.current
@@ -38,7 +38,7 @@ module RailsPulse
 
         # Collect all tracking data. Operations are copied because the writer
         # thread annotates them (N+1 detection) after this request has moved on.
-        operations = RequestStore.store[:rails_pulse_operations] || []
+        operations = RailsPulse::Current.rails_pulse_operations || []
         path_params = env["action_dispatch.request.path_parameters"] || {}
         controller_action = [ path_params[:controller], path_params[:action] ].compact.join("#").presence
         tracking_data = {
@@ -63,18 +63,18 @@ module RailsPulse
 
         [ status, headers, response ]
       ensure
-        RequestStore.store[:skip_recording_rails_pulse_activity] = false
-        RequestStore.store[:rails_pulse_request_id] = nil
-        RequestStore.store[:rails_pulse_operations] = nil
+        RailsPulse::Current.skip_recording_rails_pulse_activity = false
+        RailsPulse::Current.rails_pulse_request_id = nil
+        RailsPulse::Current.rails_pulse_operations = nil
       end
 
       private
 
       def with_recording_suppressed
-        RequestStore.store[:skip_recording_rails_pulse_activity] = true
+        RailsPulse::Current.skip_recording_rails_pulse_activity = true
         yield
       ensure
-        RequestStore.store[:skip_recording_rails_pulse_activity] = false
+        RailsPulse::Current.skip_recording_rails_pulse_activity = false
       end
 
       def response_size_bytes(headers, response)