rails-profiler 0.29.0 → 0.30.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5388819e53342bdba701e37c877cddf9b2e6b888fa163198ef7760b689bc8796
-  data.tar.gz: ca44a3e2c623ab6d46fec1fef941e76fb7941a1c77e5261077f0585ab6e70b53
+  metadata.gz: fcc4a5ad4cdedde3dd6427df52aeb75a54c4c8e973e0816f5f3d71e958042a89
+  data.tar.gz: b4f2c42db2a3a4fd0d1afd3648dcde087284dd3cf35aef0bca86049a832f3f71
 SHA512:
-  metadata.gz: 5f01b92b17838b1730e5e571299ba0de4abfcc51fe56921e343a35ffe3aeaa38ebff0f95565d334f0b9a78123b3fd489dc96accf4244a9bb346fdd1536e45ce4
-  data.tar.gz: 1e8960c6060b7f9a070497def307c9e04f4e57ac61f28bf6e9d48aac136ff48655c0df2bd3481c0628537290efbc093db6df9cdc68eaa3cc8bf75785fb6d98bf
+  metadata.gz: 3e0083dfee931dcc4e1d13eff5e873cd18eb24a8853ce503b57a38e4ec7bd3d32862e4298cf8a4cc100ee4b47863eb715a0317488e41b0b9e228127d7fcd62fd
+  data.tar.gz: 8eabcaefdfeaf5fd5fbc0149aacb179dd139b05c92157fa48708484e140c868c36869c3d03023ffcfc7603f318fde2e156ef292ca1265406d176de591c832d64

data/app/assets/builds/profiler-toolbar.js

@@ -4146,9 +4146,26 @@
     ] }) });
   }
 
+  // app/assets/typescript/profiler/cluster-context.ts
+  var STORAGE_KEY = "profiler-active-slave";
+  var activeSlavePrefix = (() => {
+    try {
+      const stored = sessionStorage.getItem(STORAGE_KEY);
+      return stored ? `/slaves/${stored}` : "";
+    } catch {
+      return "";
+    }
+  })();
+  function getActiveSlavePrefix() {
+    return activeSlavePrefix;
+  }
+
   // app/assets/typescript/profiler/api-fetcher.ts
   async function apiFetch(config) {
-    const { url, method, params, data, headers = {}, signal } = config;
+    const prefix = getActiveSlavePrefix();
+    const resolvedUrl = prefix ? config.url.replace("/_profiler/api", `/_profiler/api${prefix}`) : config.url;
+    const { method, params, data, headers = {}, signal } = config;
+    const url = resolvedUrl;
     const qs = params ? "?" + new URLSearchParams(Object.entries(params).map(([k3, v3]) => [k3, String(v3)])).toString() : "";
     const res = await fetch(url + qs, {
       method,

data/app/assets/builds/profiler.js

@@ -3419,9 +3419,42 @@
     );
   }
 
+  // app/assets/typescript/profiler/cluster-context.ts
+  var STORAGE_KEY = "profiler-active-slave";
+  var activeSlavePrefix = (() => {
+    try {
+      const stored = sessionStorage.getItem(STORAGE_KEY);
+      return stored ? `/slaves/${stored}` : "";
+    } catch {
+      return "";
+    }
+  })();
+  function getActiveSlavePrefix() {
+    return activeSlavePrefix;
+  }
+  function getActiveSlaveName() {
+    if (!activeSlavePrefix) return null;
+    return activeSlavePrefix.replace("/slaves/", "");
+  }
+  function setActiveSlave(name) {
+    try {
+      if (name) {
+        sessionStorage.setItem(STORAGE_KEY, name);
+      } else {
+        sessionStorage.removeItem(STORAGE_KEY);
+      }
+    } catch {
+    }
+    activeSlavePrefix = name ? `/slaves/${name}` : "";
+    window.location.reload();
+  }
+
   // app/assets/typescript/profiler/api-fetcher.ts
   async function apiFetch(config) {
-    const { url, method, params, data, headers = {}, signal } = config;
+    const prefix = getActiveSlavePrefix();
+    const resolvedUrl = prefix ? config.url.replace("/_profiler/api", `/_profiler/api${prefix}`) : config.url;
+    const { method, params, data, headers = {}, signal } = config;
+    const url = resolvedUrl;
     const qs = params ? "?" + new URLSearchParams(Object.entries(params).map(([k3, v3]) => [k3, String(v3)])).toString() : "";
     const res = await fetch(url + qs, {
       method,
@@ -6321,6 +6354,53 @@
     ] });
   }
 
+  // app/assets/typescript/profiler/components/ProfilerSelector.tsx
+  function ProfilerSelector() {
+    const [slaves, setSlaves] = d2([]);
+    const [loading, setLoading] = d2(true);
+    const activeSlave = getActiveSlaveName();
+    y2(() => {
+      fetch("/_profiler/api/cluster/slaves").then((r3) => r3.json()).then((data) => {
+        setSlaves(data.slaves ?? []);
+        setLoading(false);
+      }).catch(() => setLoading(false));
+    }, []);
+    if (loading || slaves.length === 0) return null;
+    const handleChange = (e3) => {
+      const value = e3.target.value;
+      setActiveSlave(value === "__local__" ? null : value);
+    };
+    const currentValue = activeSlave ?? "__local__";
+    return /* @__PURE__ */ u3("div", { class: "profiler-selector", style: { display: "flex", alignItems: "center", gap: "8px", padding: "4px 12px", background: "var(--profiler-bg-secondary, #f5f5f5)", borderBottom: "1px solid var(--profiler-border, #e0e0e0)" }, children: [
+      /* @__PURE__ */ u3("span", { style: { fontSize: "12px", fontWeight: 600, color: "var(--profiler-text-secondary, #666)", textTransform: "uppercase", letterSpacing: "0.05em" }, children: "Profiler" }),
+      /* @__PURE__ */ u3(
+        "select",
+        {
+          value: currentValue,
+          onChange: handleChange,
+          style: { fontSize: "13px", padding: "2px 6px", borderRadius: "4px", border: "1px solid var(--profiler-border, #ccc)", background: "var(--profiler-bg, #fff)", color: "var(--profiler-text, #333)", cursor: "pointer" },
+          children: [
+            /* @__PURE__ */ u3("option", { value: "__local__", children: "Local (master)" }),
+            slaves.map((slave) => /* @__PURE__ */ u3(
+              "option",
+              {
+                value: slave.name,
+                disabled: slave.status === "offline",
+                children: [
+                  slave.name,
+                  " ",
+                  slave.status === "offline" ? "(offline)" : ""
+                ]
+              },
+              slave.name
+            ))
+          ]
+        }
+      ),
+      activeSlave && /* @__PURE__ */ u3("span", { style: { fontSize: "11px", color: "var(--profiler-text-secondary, #888)", fontStyle: "italic" }, children: "Viewing slave data via proxy" })
+    ] });
+  }
+
   // app/assets/typescript/profiler/components/dashboard/tabs/RequestTab.tsx
   function buildCurl2(profile) {
     const headers = profile.headers ?? {};
@@ -9383,7 +9463,7 @@ Duration: ${event.duration.toFixed(2)}ms`;
   }
 
   // app/assets/typescript/profiler/theme.ts
-  var STORAGE_KEY = "profiler-theme";
+  var STORAGE_KEY2 = "profiler-theme";
   var THEME_ATTRIBUTE = "data-theme";
   var ThemeManager = class {
     constructor() {
@@ -9399,18 +9479,18 @@ Duration: ${event.duration.toFixed(2)}ms`;
         }
       });
       window.addEventListener("storage", (e3) => {
-        if (e3.key === STORAGE_KEY && e3.newValue) {
+        if (e3.key === STORAGE_KEY2 && e3.newValue) {
           this.currentTheme = e3.newValue;
           this.applyTheme(this.currentTheme);
         }
       });
     }
     loadTheme() {
-      const stored = localStorage.getItem(STORAGE_KEY);
+      const stored = localStorage.getItem(STORAGE_KEY2);
       return stored || "auto";
     }
     saveTheme(theme) {
-      localStorage.setItem(STORAGE_KEY, theme);
+      localStorage.setItem(STORAGE_KEY2, theme);
     }
     applyTheme(theme) {
       const resolvedTheme = this.resolveTheme(theme);
@@ -9508,6 +9588,14 @@ Duration: ${event.duration.toFixed(2)}ms`;
     defaultOptions: { queries: { staleTime: 3e4, retry: 1 } }
   });
   document.addEventListener("DOMContentLoaded", () => {
+    const selectorEl = document.getElementById("profiler-cluster-selector");
+    const isMaster = document.querySelector('meta[name="profiler-is-master"]')?.getAttribute("content") === "true";
+    if (selectorEl && isMaster) {
+      J(
+        /* @__PURE__ */ u3(QueryClientProvider, { client: queryClient, children: /* @__PURE__ */ u3(ProfilerSelector, {}) }),
+        selectorEl
+      );
+    }
     const indexEl = document.getElementById("profiler-index");
     if (indexEl) {
       J(

data/app/controllers/profiler/api/cluster_controller.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Profiler
+  module Api
+    class ClusterController < Profiler::ApplicationController
+      skip_before_action :verify_authenticity_token
+
+      def register
+        name = params[:name].to_s
+        url  = params[:url].to_s
+
+        if name.empty? || url.empty?
+          return render json: { error: "name and url are required" }, status: :unprocessable_entity
+        end
+
+        Profiler.slave_registry.register(name: name, url: url)
+        render json: { ok: true, name: name }
+      end
+
+      def heartbeat
+        name = params[:name].to_s
+        entry = Profiler.slave_registry.heartbeat(name)
+        if entry.nil?
+          render json: { error: "Unknown slave — please re-register" }, status: :not_found
+        else
+          render json: { ok: true }
+        end
+      end
+
+      def slaves
+        render json: { slaves: Profiler.slave_registry.all }
+      end
+    end
+  end
+end

data/app/controllers/profiler/api/profiles_controller.rb

@@ -9,8 +9,10 @@ module Profiler
         limit  = (params[:limit]  || 50).to_i
         offset = (params[:offset] || 0).to_i
         all    = Profiler.storage.list(limit: 1000, offset: 0)
-        http   = all.select { |p| p.profile_type == "http" }
-        page   = http.drop(offset).first(limit + 1)
+        # all_types is an opt-in used by the cluster proxy so it can mirror the full
+        # storage.list contract; the dashboard relies on the default http-only filter.
+        scope  = all_types? ? all : all.select { |p| p.profile_type == "http" }
+        page   = scope.drop(offset).first(limit + 1)
         render json: {
           profiles: page.first(limit).map(&:to_h),
           limit:    limit,
@@ -50,6 +52,10 @@ module Profiler
 
       private
 
+      def all_types?
+        %w[1 true].include?(params[:all_types].to_s)
+      end
+
       def recalculate_ajax_data(profile)
         # Find AJAX collector in the configured collectors
         ajax_collector_class = Profiler::Collectors::AjaxCollector

data/app/controllers/profiler/api/slave_proxy_controller.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "../../../../lib/profiler/cluster/slave_proxy"
+
+module Profiler
+  module Api
+    class SlaveProxyController < Profiler::ApplicationController
+      skip_before_action :verify_authenticity_token
+
+      def forward
+        proxy = Cluster::SlaveProxy.new(params[:slave_name])
+        sub_path = params[:path].to_s
+        full_path = "/_profiler/api/#{sub_path}"
+
+        result = case request.method
+                 when "GET"
+                   proxy.get_json(full_path, request.query_parameters.to_h)
+                 when "POST"
+                   proxy.post_json(full_path, parsed_body)
+                 when "PATCH"
+                   proxy.patch_json(full_path, parsed_body)
+                 when "DELETE"
+                   proxy.delete_json(full_path)
+                 else
+                   return head :method_not_allowed
+                 end
+
+        render json: result
+      rescue Profiler::Error => e
+        render json: { error: e.message }, status: :bad_gateway
+      rescue => e
+        render json: { error: "Proxy error: #{e.message}" }, status: :bad_gateway
+      end
+
+      private
+
+      def parsed_body
+        return {} if request.body.nil?
+
+        raw = request.body.read
+        return {} if raw.empty?
+
+        JSON.parse(raw)
+      rescue JSON::ParserError
+        {}
+      end
+    end
+  end
+end

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

@@ -6,12 +6,15 @@
     <%= csrf_meta_tags %>
     <%= csp_meta_tag %>
     <meta name="profiler-version" content="<%= Profiler::VERSION %>">
+    <meta name="profiler-name" content="<%= Profiler.configuration.resolved_name %>">
+    <meta name="profiler-is-master" content="<%= Profiler.configuration.master? %>">
 
     <link rel="stylesheet" href="/_profiler/assets/profiler.css">
     <script src="/_profiler/assets/profiler.js" defer></script>
   </head>
 
   <body>
+    <div id="profiler-cluster-selector"></div>
     <%= yield %>
   </body>
 </html>

data/config/routes.rb

@@ -51,5 +51,15 @@ Profiler::Engine.routes.draw do
     get    "test_runner/runs/:id/stream", to: "test_runner#stream", as: :test_runner_run_stream
     delete "test_runner/runs/:id",        to: "test_runner#destroy"
     get    "events/:token",               to: "events#subscribe",  as: :profile_events
+
+    # Cluster endpoints (master-side)
+    post "cluster/register",  to: "cluster#register"
+    post "cluster/heartbeat", to: "cluster#heartbeat"
+    get  "cluster/slaves",    to: "cluster#slaves"
+
+    # Slave proxy — must be last to avoid shadowing other api routes
+    scope "/slaves/:slave_name" do
+      match "*path", to: "slave_proxy#forward", via: :all
+    end
   end
 end

data/lib/profiler/cluster/master_client.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module Profiler
+  module Cluster
+    class MasterClient
+      def start
+        @registered = false
+        begin
+          register!
+          @registered = true
+        rescue => e
+          log_warn("Could not register with master at startup: #{e.message} — will retry in heartbeat loop")
+        end
+        start_heartbeat_thread
+      end
+
+      private
+
+      def register!
+        config = Profiler.configuration
+        uri = URI("#{config.master_url}/_profiler/api/cluster/register")
+        body = { name: config.resolved_name, url: config.self_url }.to_json
+        resp = Net::HTTP.post(uri, body, "Content-Type" => "application/json")
+        unless resp.code.to_i.between?(200, 299)
+          raise "Master returned #{resp.code}: #{resp.body.to_s.slice(0, 200)}"
+        end
+
+        log_info("Registered with master at #{config.master_url} as '#{config.resolved_name}'")
+      end
+
+      def heartbeat!
+        config = Profiler.configuration
+        uri = URI("#{config.master_url}/_profiler/api/cluster/heartbeat")
+        body = { name: config.resolved_name }.to_json
+        resp = Net::HTTP.post(uri, body, "Content-Type" => "application/json")
+        raise "Heartbeat rejected #{resp.code}" unless resp.code.to_i.between?(200, 299)
+      end
+
+      def start_heartbeat_thread
+        Thread.new do
+          interval = Profiler.configuration.cluster_heartbeat_interval
+          loop do
+            sleep interval
+            unless @registered
+              register!
+              @registered = true
+              log_info("Re-registered with master after previous failure")
+            else
+              heartbeat!
+            end
+          rescue => e
+            @registered = false
+            log_warn("Cluster communication failed: #{e.message} — will retry")
+          end
+        end
+      end
+
+      def log_info(msg)
+        if defined?(Rails)
+          Rails.logger.info("[Profiler Cluster] #{msg}")
+        else
+          $stderr.puts("[Profiler Cluster] #{msg}")
+        end
+      end
+
+      def log_warn(msg)
+        if defined?(Rails)
+          Rails.logger.warn("[Profiler Cluster] #{msg}")
+        else
+          $stderr.puts("[Profiler Cluster] WARN #{msg}")
+        end
+      end
+    end
+  end
+end

data/lib/profiler/cluster/slave_proxy.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module Profiler
+  module Cluster
+    class SlaveProxy
+      # A slow or hung slave must not block the master's request thread for long.
+      OPEN_TIMEOUT = 5  # seconds
+      READ_TIMEOUT = 10 # seconds
+
+      def initialize(slave_name)
+        entry = Profiler.slave_registry.find!(slave_name)
+        raise Profiler::Error, "Slave profiler '#{slave_name}' is offline" if entry.status == "offline"
+
+        @base_url = entry.url.to_s.chomp("/")
+      end
+
+      # Storage-compatible interface for MCP query tools
+
+      def list(limit: 50, offset: 0, **)
+        # all_types mirrors Profiler.storage.list, which returns every profile type;
+        # without it the proxy would only ever see http profiles (see ProfilesController#index).
+        data = get_json("/_profiler/api/profiles", limit: limit, offset: offset, all_types: true)
+        Array(data["profiles"]).map { |h| profile_from_api(h) }
+      end
+
+      def load(token)
+        data = get_json("/_profiler/api/profiles/#{token}")
+        return nil unless data["token"] || data["profile"]
+
+        raw = data["profile"] || data
+        profile_from_api(raw)
+      end
+
+      def clear(type: nil)
+        params = type ? "?type=#{URI.encode_www_form_component(type)}" : ""
+        delete_json("/_profiler/api/profiles/clear#{params}")
+      end
+
+      # Generic HTTP access for action tools
+
+      def get_json(path, params = {})
+        uri = build_uri(path, params)
+        request(uri, Net::HTTP::Get.new(uri))
+      end
+
+      def post_json(path, body = {})
+        request(*json_request(Net::HTTP::Post, path, body))
+      end
+
+      def patch_json(path, body = {})
+        request(*json_request(Net::HTTP::Patch, path, body))
+      end
+
+      def delete_json(path)
+        uri = build_uri(path)
+        request(uri, Net::HTTP::Delete.new(uri))
+      end
+
+      private
+
+      def build_uri(path, params = {})
+        uri = URI("#{@base_url}#{path}")
+        unless params.empty?
+          uri.query = URI.encode_www_form(params.compact.transform_values(&:to_s))
+        end
+        uri
+      end
+
+      def json_request(klass, path, body)
+        uri = build_uri(path)
+        req = klass.new(uri)
+        req["Content-Type"] = "application/json"
+        req.body = body.to_json
+        [uri, req]
+      end
+
+      def request(uri, req)
+        resp = Net::HTTP.start(uri.hostname, uri.port,
+                               open_timeout: OPEN_TIMEOUT, read_timeout: READ_TIMEOUT) do |http|
+          http.request(req)
+        end
+        return {} if resp.code == "204"
+
+        parse_response(resp)
+      end
+
+      def parse_response(resp)
+        return {} if resp.body.nil? || resp.body.empty?
+
+        JSON.parse(resp.body)
+      rescue JSON::ParserError
+        { "raw" => resp.body }
+      end
+
+      def profile_from_api(hash)
+        require_relative "../models/profile"
+        # from_hash expects symbol keys at the top level
+        Profiler::Models::Profile.from_hash(hash.transform_keys(&:to_sym))
+      end
+    end
+  end
+end

data/lib/profiler/cluster/slave_registry.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "concurrent-ruby"
+
+module Profiler
+  module Cluster
+    class SlaveRegistry
+      Entry = Struct.new(:name, :url, :registered_at, :last_heartbeat_at, keyword_init: true) do
+        def status
+          threshold = Profiler.configuration.cluster_offline_threshold
+          (Time.now - last_heartbeat_at) < threshold ? "online" : "offline"
+        end
+
+        def to_h
+          super.merge(status: status).tap do |h|
+            h[:registered_at] = h[:registered_at]&.iso8601
+            h[:last_heartbeat_at] = h[:last_heartbeat_at]&.iso8601
+          end
+        end
+      end
+
+      def initialize
+        @slaves = Concurrent::Hash.new
+      end
+
+      def register(name:, url:)
+        now = Time.now
+        if (existing = @slaves[name])
+          existing.url = url
+          existing.last_heartbeat_at = now
+        else
+          @slaves[name] = Entry.new(name: name, url: url, registered_at: now, last_heartbeat_at: now)
+        end
+        @slaves[name]
+      end
+
+      def heartbeat(name)
+        @slaves[name]&.tap { |e| e.last_heartbeat_at = Time.now }
+      end
+
+      def find!(name)
+        @slaves[name] || raise(Profiler::Error, "Unknown slave profiler: #{name}")
+      end
+
+      def all
+        @slaves.values.map(&:to_h)
+      end
+    end
+  end
+end

data/lib/profiler/configuration.rb

@@ -14,7 +14,9 @@ module Profiler
                   :track_console,
                   :track_tests,
                   :track_mailers, :capture_mail_body, :sanitize_mailer_recipients, :mailer_skip_actions,
-                  :compress_bodies, :compress_body_threshold
+                  :compress_bodies, :compress_body_threshold,
+                  :name, :master_url, :self_url,
+                  :cluster_heartbeat_interval, :cluster_offline_threshold
 
     attr_writer :tmp_path
 
@@ -54,12 +56,29 @@ module Profiler
       @compress_bodies = true
       @compress_body_threshold = 10 * 1024 # 10 KB
       @tmp_path = nil
+      @name = nil
+      @master_url = nil
+      @self_url = nil
+      @cluster_heartbeat_interval = 15
+      @cluster_offline_threshold = 60
     end
 
     def tmp_path
       @tmp_path || default_tmp_path
     end
 
+    def slave?
+      !master_url.nil? && !master_url.empty?
+    end
+
+    def master?
+      !slave?
+    end
+
+    def resolved_name
+      @name || (defined?(Rails) ? Rails.application.class.module_parent_name.underscore : "profiler")
+    end
+
     def authorize_with(&block)
       @authorize_block = block
     end