rails-profiler 0.30.3 → 0.30.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3cc97292b89b1be664408c01611a72768b1212467b9149268ab1d16c8d90219e
-  data.tar.gz: f9b2cc7d021b18d65dd0b5232269c4cf1657071d6b0c9416f90ed5df75f16ed3
+  metadata.gz: 2940fc44efea04a648f7bba562f2fc19be1639d996525e9d08483ef7093baa16
+  data.tar.gz: 1b9f6534d20625950aef62f906319942d7327ea609649aef00b70ba88c9b17ce
 SHA512:
-  metadata.gz: '06952a2a976fbd59b49016384d11150b0a394e4e4c902446740e0d328b4c6fbaf7474277e0341ae87dd479de064aa7d80cbac2d289b66a2b886baa3d08b452b2'
-  data.tar.gz: 4dc610ff0b4f4aea0f52c76539bb06bfd068f1ebbad87840e2b8448239da77f38fc7ee4e977040f616137bdc06f04e8cfd7936fcf62e80f3d37d36a8016a873a
+  metadata.gz: 6ce1584ab5b3d70a6262d205cfbd0e4876d29e89b3766efde13fe345966734c20f6a73df1fe1e14b71f7b8af5c588b04e02c7e9a8b16a0f00c902ff8f5a55aa6
+  data.tar.gz: 6e02c794a279605d81ac11c5f31f099378af2d82c967e757bf571ce2ff27ec7ca3f7c342f7e90cca628c5a406c253b0f0252971a723d0c4970db86ec35bd5c4e

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

@@ -12,6 +12,7 @@ module Profiler
         # 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" }
+        scope  = scope.select { |p| p.parent_token == params[:parent_token] } if params[:parent_token].present?
         page   = scope.drop(offset).first(limit + 1)
         render json: {
           profiles: page.first(limit).map(&:to_h),

data/app/controllers/profiler/application_controller.rb

@@ -17,26 +17,30 @@ module Profiler
     end
 
     def build_child_jobs(profile)
-      Profiler.storage.find_by_parent(profile.token)
-               .select { |p| p.profile_type == "job" }
-               .map do |j|
-                 job_data = j.collector_data("job") || {}
-                 {
-                   token: j.token,
-                   job_class: j.path,
-                   job_id: job_data["job_id"],
-                   queue: job_data["queue"],
-                   status: job_data["status"],
-                   duration: j.duration,
-                   started_at: j.started_at&.iso8601
-                 }
-               end
+      storage = @resolved_storage || Profiler.storage
+      storage.find_by_parent(profile.token)
+             .select { |p| p.profile_type == "job" }
+             .map do |j|
+               job_data = j.collector_data("job") || {}
+               {
+                 token: j.token,
+                 job_class: j.path,
+                 job_id: job_data["job_id"],
+                 queue: job_data["queue"],
+                 status: job_data["status"],
+                 duration: j.duration,
+                 started_at: j.started_at&.iso8601
+               }
+             end
     end
 
     def build_parent_summary(profile)
       return nil unless profile.parent_token
 
-      parent = Profiler.storage.load(profile.parent_token)
+      storage = @resolved_storage || Profiler.storage
+      parent  = storage.load(profile.parent_token)
+      # Cross-node fallback: parent may live on the master when the profile is on a slave
+      parent ||= Profiler.storage.load(profile.parent_token) if storage != Profiler.storage
       return nil unless parent
 
       if parent.profile_type == "job"

data/app/controllers/profiler/profiles_controller.rb

@@ -13,7 +13,7 @@ module Profiler
     end
 
     def show
-      @profile = Profiler.storage.load(params[:id])
+      @profile = resolve_profile(params[:id])
 
       unless @profile
         render plain: "Profile not found", status: :not_found
@@ -34,46 +34,121 @@ module Profiler
     end
 
     def timeline
-      @profile = Profiler.storage.load(params[:id])
+      @profile = resolve_profile(params[:id])
+      return render plain: "Profile not found", status: :not_found unless @profile
+
       render json: @profile.collector_data("performance")
     end
 
     def database
-      @profile = Profiler.storage.load(params[:id])
+      @profile = resolve_profile(params[:id])
+      return render plain: "Profile not found", status: :not_found unless @profile
+
       render json: @profile.collector_data("database")
     end
 
     def views
-      @profile = Profiler.storage.load(params[:id])
+      @profile = resolve_profile(params[:id])
+      return render plain: "Profile not found", status: :not_found unless @profile
+
       render json: @profile.collector_data("view")
     end
 
     def cache
-      @profile = Profiler.storage.load(params[:id])
+      @profile = resolve_profile(params[:id])
+      return render plain: "Profile not found", status: :not_found unless @profile
+
       render json: @profile.collector_data("cache")
     end
 
     def performance
-      @profile = Profiler.storage.load(params[:id])
+      @profile = resolve_profile(params[:id])
+      return render plain: "Profile not found", status: :not_found unless @profile
+
       render json: @profile.collector_data("performance")
     end
 
     def flamegraph
-      @profile = Profiler.storage.load(params[:id])
+      @profile = resolve_profile(params[:id])
+      return render plain: "Profile not found", status: :not_found unless @profile
+
       render json: @profile.collector_data("flamegraph")
     end
 
     private
 
+    # Resolves a profile token against local storage first, then online slaves.
+    # Sets @resolved_storage to the storage that owns the profile so that
+    # secondary lookups (child jobs, parent, AJAX) go to the same node.
+    def resolve_profile(token)
+      # Local storage — fast path, covers master-owned profiles
+      if (profile = Profiler.storage.load(token))
+        @resolved_storage = Profiler.storage
+        return profile
+      end
+
+      # Cache hit — skip fan-out if we already know which slave has this token
+      if (cached_slave = Profiler.token_cache.fetch(token))
+        entry = Profiler.slave_registry.all.find { |e| e[:name] == cached_slave }
+        if entry && entry[:status] == "online"
+          begin
+            proxy = Cluster::SlaveProxy.new(cached_slave, open_timeout: 2, read_timeout: 3)
+            if (profile = proxy.load(token))
+              @resolved_storage = proxy
+              return profile
+            end
+          rescue => e
+            Rails.logger.warn("[Profiler] Cached slave #{cached_slave} failed for #{token}: #{e.message}")
+          end
+        end
+        Profiler.token_cache.invalidate(token)
+      end
+
+      # Parallel fan-out across all online slaves
+      online_slaves = Profiler.slave_registry.online_names
+      return nil if online_slaves.empty?
+
+      found_profile  = nil
+      found_proxy    = nil
+      found_slave    = nil
+      result_mutex   = Mutex.new
+
+      threads = online_slaves.map do |slave_name|
+        Thread.new do
+          begin
+            proxy   = Cluster::SlaveProxy.new(slave_name, open_timeout: 2, read_timeout: 3)
+            profile = proxy.load(token)
+            if profile
+              result_mutex.synchronize do
+                unless found_profile
+                  found_profile = profile
+                  found_proxy   = proxy
+                  found_slave   = slave_name
+                end
+              end
+            end
+          rescue => e
+            Rails.logger.warn("[Profiler] Fan-out error for slave #{slave_name} (#{token}): #{e.message}")
+          end
+        end
+      end
+
+      threads.each(&:join)
+
+      if found_profile
+        Profiler.token_cache.store(token, found_slave)
+        @resolved_storage = found_proxy
+        found_profile
+      end
+    end
+
     def recalculate_ajax_data(profile)
-      # Find AJAX collector in the configured collectors
       ajax_collector_class = Profiler::Collectors::AjaxCollector
 
       if Profiler.configuration.collectors.include?(ajax_collector_class)
-        collector = ajax_collector_class.new(profile)
+        collector = ajax_collector_class.new(profile, storage: @resolved_storage || Profiler.storage)
         collector.collect
 
-        # Update tab metadata to reflect has_data status
         if profile.instance_variable_get(:@collectors_metadata)
           ajax_tab = profile.instance_variable_get(:@collectors_metadata).find { |tab| tab[:key] == 'ajax' }
           if ajax_tab

data/lib/profiler/cluster/slave_proxy.rb

@@ -11,11 +11,13 @@ module Profiler
       OPEN_TIMEOUT = 5  # seconds
       READ_TIMEOUT = 10 # seconds
 
-      def initialize(slave_name)
+      def initialize(slave_name, open_timeout: nil, read_timeout: nil)
         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("/")
+        @open_timeout = open_timeout || OPEN_TIMEOUT
+        @read_timeout = read_timeout || READ_TIMEOUT
       end
 
       # Storage-compatible interface for MCP query tools
@@ -35,6 +37,11 @@ module Profiler
         profile_from_api(raw)
       end
 
+      def find_by_parent(parent_token)
+        data = get_json("/_profiler/api/profiles", parent_token: parent_token, all_types: true)
+        Array(data["profiles"]).map { |h| profile_from_api(h) }
+      end
+
       def clear(type: nil)
         params = type ? "?type=#{URI.encode_www_form_component(type)}" : ""
         delete_json("/_profiler/api/profiles/clear#{params}")
@@ -80,7 +87,7 @@ module Profiler
 
       def request(uri, req)
         resp = Net::HTTP.start(uri.hostname, uri.port,
-                               open_timeout: OPEN_TIMEOUT, read_timeout: READ_TIMEOUT,
+                               open_timeout: @open_timeout, read_timeout: @read_timeout,
                                use_ssl: uri.scheme == "https") do |http|
           http.request(req)
         end

data/lib/profiler/cluster/slave_registry.rb

@@ -45,6 +45,10 @@ module Profiler
       def all
         @slaves.values.map(&:to_h)
       end
+
+      def online_names
+        @slaves.select { |_, entry| entry.status == "online" }.keys
+      end
     end
   end
 end

data/lib/profiler/cluster/token_cache.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "concurrent-ruby"
+
+module Profiler
+  module Cluster
+    class TokenCache
+      TTL = 600 # 10 minutes
+
+      def initialize
+        @cache = Concurrent::Map.new
+      end
+
+      def fetch(token)
+        entry = @cache[token]
+        return nil if entry.nil? || Time.now > entry[:expires_at]
+
+        entry[:slave_name]
+      end
+
+      def store(token, slave_name)
+        @cache[token] = { slave_name: slave_name, expires_at: Time.now + TTL }
+      end
+
+      def invalidate(token)
+        @cache.delete(token)
+      end
+    end
+  end
+end

data/lib/profiler/collectors/ajax_collector.rb

@@ -5,6 +5,11 @@ require_relative "base_collector"
 module Profiler
   module Collectors
     class AjaxCollector < BaseCollector
+      def initialize(profile, storage: Profiler.storage)
+        super(profile)
+        @storage = storage
+      end
+
       def icon
         "🌐"
       end
@@ -29,8 +34,7 @@ module Profiler
       end
 
       def collect
-        # Query storage for child AJAX profiles
-        ajax_profiles = Profiler.storage.find_by_parent(@profile.token)
+        ajax_profiles = @storage.find_by_parent(@profile.token)
 
         return store_data({}) if ajax_profiles.empty?
 

data/lib/profiler/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Profiler
-  VERSION = "0.30.3"
+  VERSION = "0.30.4"
 end

data/lib/profiler.rb

@@ -36,6 +36,13 @@ module Profiler
       end
     end
 
+    def token_cache
+      @token_cache ||= begin
+        require_relative "profiler/cluster/token_cache"
+        Cluster::TokenCache.new
+      end
+    end
+
     def enabled?
       configuration.enabled
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-profiler
 version: !ruby/object:Gem::Version
-  version: 0.30.3
+  version: 0.30.4
 platform: ruby
 authors:
 - Sébastien Duplessy
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-06-29 00:00:00.000000000 Z
+date: 2026-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -135,6 +135,7 @@ files:
 - lib/profiler/cluster/master_client.rb
 - lib/profiler/cluster/slave_proxy.rb
 - lib/profiler/cluster/slave_registry.rb
+- lib/profiler/cluster/token_cache.rb
 - lib/profiler/collectors/ajax_collector.rb
 - lib/profiler/collectors/base_collector.rb
 - lib/profiler/collectors/cache_collector.rb