rails-profiler 0.31.3 → 0.31.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09422d8df091081147998c5e266018f8156874c3f2590b4269dfc1bab5b2efcf'
-  data.tar.gz: 3f0ac06620cf6d1f0297528cdce39e80962b736e835d127538968a2aff8b748f
+  metadata.gz: 87fc21dec17ab7627d4430f49b042e53061efb33034d7309ea07aac6eb83ac5d
+  data.tar.gz: 3e64027bb71fa5ce3d2a23a23cf1525f0e5a55c508c019f1398c35c705f20434
 SHA512:
-  metadata.gz: 7d74679898828ec69cea3718945c08e8c8ce4aec93d1ccb8942de28617a888ff2dfc2fbde4e4c01892f9a05a8723f713907a87b378b3be5dd11d5cb7cec7500b
-  data.tar.gz: 918333cbc7efbb6c61217adb4c52ced40be60a62b621fb828e942878598defd92d69bd36672bf515bcd5b6f9e4ed82869268fe704f64b674c309e2f61846fe6a
+  metadata.gz: 596fda2dad5ffa7e2a7c98a2b749c03901df7748d26776203a30d88a86b842e5956d92453b3847a3cf856a7afee5c4511f02ce83070a6dd26d0ef4d1e6784b5b
+  data.tar.gz: b70a833918e15474ac410c182763f13e03e0352e39cd7a0ed066c68a47f2f86762e7ef01fcd5246bfe47d391d86c03556929f66dbb84f0098f0bc43c43e9b415

data/CHANGELOG.md

@@ -19,6 +19,135 @@ every commit of every tag interval is accounted for one way or the other.
 
 ## [Unreleased]
 
+## [0.31.5] - 2026-10-05
+
+<!-- stamped -->
+
+### Fixed
+
+- **Logging:** Send the profiler's own errors and warnings to the application's log instead of
+  `$stderr`. A profile that could not be saved, a collector that failed, a store that could not be
+  read, a cluster node out of reach: about thirty places wrote to `$stderr`, which is not where
+  `log/development.log` is, so these errors went unseen. They now go through one entry point,
+  `Profiler.log_error`, to `config.logger` when the application sets one (read on each message),
+  otherwise `Rails.logger`, otherwise `$stderr`. Every line starts with `[Profiler]` (the cluster's
+  lines, `[Profiler Cluster]` before, now start with `[Profiler] Cluster:`), carries the error's
+  class and message, masked then cut at 1,000 bytes, and has the cluster secret masked. A logger that
+  raises never fails a request, a job or the boot: the line then goes to `$stderr`. A slave whose
+  `Rails.logger` was still nil raised instead of logging. Several failures that left no trace at
+  all are now logged, once per place and error class for the life of the process: a store lookup or broadcast, the Redis
+  version read of the toolbar, the MCP body cache, the mailer collector reading a mail, the route
+  lookup of the Request tab, a file profile that cannot be read to rebuild the index. The request middleware saves its
+  profiles through `Profiler.save_profile`, like jobs, console commands and tests; a page whose
+  profile could not be saved gets neither the `X-Profiler-Token` header nor the toolbar, which
+  would point to a missing profile. The profiler's own lines no longer appear in the Logs tab of
+  the request during which they are written, nor count as its errors. The same holds while the store is
+  unavailable, for pages and for streamed responses, which no longer send `X-Profiler-Token` for a
+  profile that will be dropped. The storage warnings (a store that cannot be created, said once
+  per cause; a Redis profile that cannot be indexed; a SQLite summary that cannot be read) go to
+  the application's log too, and the `run_tests` MCP tool answers an unavailable store as an error
+  instead of a run without profiles.
+- **Outbound HTTP:** Record the calls to services on the same machine. `127.0.0.1`, `localhost`
+  and `::1` were always left out, so in development the calls to a neighbouring service never
+  showed. `config.http_skip_hosts` is now the whole list, empty by default. The profiler's own
+  calls are never recorded, whatever the list says: a slave's registration and heartbeats, and the
+  master's requests to its slaves (the slave proxy, the fan-out of the profile pages and the MCP
+  tools that query a slave), marked where they are made, and any call to the host and port of
+  `config.master_url`. `NetHttpInstrumentation::SKIP_HOSTS` stays, deprecated, with its former value
+  (`%w[127.0.0.1 localhost ::1]`); nothing reads it any more.
+- **Outbound HTTP:** Keep the bodies of outbound `Net::HTTP` calls to the first
+  `config.max_captured_body_bytes`, sent and received, instead of copying them whole; a compressed
+  answer is inflated only up to that size, give or take one 16 KB buffer. A `body_stream` is read
+  only when it can be put back where it was (a `StringIO`, a file), up to that size and no further
+  than its `Content-Length`: a pipe or a socket was read whole and then sent empty, it is now sent
+  unread and its body is not captured. A `body_stream` without `pos`, such as a Faraday multipart
+  body or a `RestClient::Payload`, is not captured either, where earlier versions replaced it with
+  a copy read whole. The size is the `Content-Length` or the stream's own size, otherwise a
+  minimum. The HTTP tab and the `get_profile_http` MCP tool say when a body was cut or not
+  captured; each call carries `request_body_truncated`, `response_body_truncated`,
+  `request_body_not_captured` and `request_size_is_minimum`. Text bodies read in part stay UTF-8.
+- **Middleware:** Cap the `params` a profile keeps at `config.max_captured_body_bytes`: long values
+  are cut and the entries past it left out, with a `"[profiler]"` key saying so, and the profile
+  carries `params_truncated`. The application still gets all of its params. With the log line
+  capped below, a 5 MB JSON request no longer takes about 15 MB in its profile.
+- **Logs:** Cap what a profile keeps of its request's log lines at the new
+  `config.max_captured_log_bytes` (1 MB by default). A request, or a stream held open, that logged
+  without end grew its thread's buffer without bound; a single line, such as the
+  `Parameters: ...` line of a large request, is cut at the cap. The Logs tab ends with the number
+  of lines left out, and the collected data carries `truncated` and `dropped`.
+- **Dump:** `Profiler.dump` returns its argument when the profiler is disabled too; it returned
+  `nil`, so a call left in the code changed the value of the expression in production.
+- **Engine:** Stop failing the boot of an application that loads `ActionController::API` (an
+  `api_only` application, or a single API controller): the engine called `helper` on it, which
+  `ActionController::API` does not have (`NoMethodError`).
+- **Toolbar:** Find where the toolbar goes about four times faster on a page of many tags (0.8 ms
+  instead of 4 ms for a page of 20 KB and 4,000 tags, 10 ms instead of 25 ms for 320 KB of tags
+  with attributes): ordinary text and tags are skipped in one pass. The place is the same, and a
+  `</body>` in an attribute, a comment, a script or a CDATA section, an unclosed quote or a
+  `<plaintext>` are handled as before.
+- **Upgrading:** to get the previous behaviour back, in `config/initializers/profiler.rb`:
+  - the profiler's messages on `$stderr`: `config.logger = Logger.new($stderr)`;
+  - the local hosts left out of the HTTP tab:
+    `config.http_skip_hosts += Profiler::Configuration::LOCAL_HTTP_HOSTS`;
+  - whole outbound bodies and params: `config.max_captured_body_bytes = nil` (also keeps the
+    incoming bodies whole); every log line: `config.max_captured_log_bytes = nil`.
+
+## [0.31.4] - 2026-10-05
+
+<!-- stamped -->
+
+### Fixed
+
+- **Storage:** A save into the file store costs the same whatever the number of profiles on disk:
+  it listed the directory and read the size of every file on each save, about 5 ms with 500
+  profiles and 100 ms with 10,000, now under 1 ms. The store keeps an index next to the profiles
+  (`.profiles-index.jsonl`, with its lock `.profiles-index.lock`), which the processes writing to
+  the directory share; a missing or damaged one is rebuilt from the profile files, so the profiles
+  already saved are found without any migration. Temporary files left by a killed process are now
+  removed. The index relies on `flock`: a file store shared between hosts over NFS is not
+  supported, use Redis there.
+- **Storage:** `config.max_profiles` (100) is honoured by every backend, the first saved profiles
+  evicted first (a job saved when it ends counts as new, whenever it started): only the memory
+  store applied it, so the file store grew to `max_size` (100 MB,
+  tens of thousands of profiles), SQLite without limit and Redis up to its TTL. In the test
+  environment, where every example saves a profile, there is no cap on the count unless the
+  application sets one.
+- **Storage:** Finding the children of a page (its AJAX sub-requests and its jobs) reads only
+  them, through an index of their parent, instead of reading and parsing every stored profile
+  (about 260 ms with 1,500 profiles of 17 KB in the file store, now under 1 ms). Every profile page
+  and toolbar paid it, once for the child jobs and once more for the AJAX tab; they now read the
+  children once.
+- **Dashboard:** The HTTP, job, console and test lists are filtered and paged by the storage, and
+  list summaries of the profiles (without the bodies, params, headers and nested collector data):
+  they loaded the 1,000 newest profiles in full on every page (about 200 ms with 1,500 profiles of
+  17 KB, now under 10 ms), showed nothing past the thousandth, said there was no next page there,
+  and missed the profiles of one type behind 1,000 newer ones of another. The MCP tools and
+  resources that list one type of profile (jobs, console, tests) and the test report ask the
+  storage for that type too, and found nothing behind 500 newer profiles of another type.
+- **AJAX:** The AJAX tab shows the sub-requests of a page whatever `config.collectors` holds: it
+  only appeared with `AjaxCollector` in the list, which the default list does not have. The jobs a
+  page enqueued are no longer counted as AJAX requests: they stay under its child jobs. The MCP
+  tool `get_profile_ajax` finds the sub-requests too: it read the AJAX data saved with the page,
+  before any sub-request.
+- **Storage:** The storage is created once, under a lock: the first requests of a threaded server
+  could each create their own store (16 for 16 threads in the spec), and with the memory store the
+  profiles saved in all but one were lost. Several file, SQLite or Redis stores share their data
+  and lost nothing.
+- **Storage:** A store that cannot be created (its index or lock replaced by a symbolic link, say)
+  is reported once per process instead of with a backtrace on every request: the profiles are not
+  saved and no toolbar is added, the dashboard and its API answer `503` with the cause in one line
+  (no path) instead of a `500`, the MCP tools an error with it, and the store is created again
+  once the cause is gone.
+- **Upgrading:** the file, SQLite and Redis stores now keep 100 profiles outside the test
+  environment, and **the first save after the upgrade removes the profiles past the cap**, the
+  first saved first: of 3,000 profiles written by 0.31.1 in the file store, about 80 remain, and
+  that first save takes about a second, during which the other processes writing to the store
+  wait. To keep them, set `config.max_profiles` (or `storage_options[:max_profiles]`) **before**
+  upgrading: to a higher number, or to `nil` for the earlier behaviour, no cap on the count (the
+  file store then keeps up to `max_size`, Redis up to its TTL). The memory store keeps 100 with
+  `nil`, as before. A Redis store written by an earlier version is indexed once, by one process,
+  on first use, which also removes the profiles past the cap then (about 0.4 s for 20,000).
+
 ## [0.31.3] - 2026-10-05
 
 <!-- stamped -->

data/app/assets/builds/profiler.js

@@ -4414,6 +4414,13 @@
     parts.push(`  ${JSON.stringify(req.url)}`);
     return parts.join(" \\\n");
   }
+  function bodyNotes(req) {
+    const notes = [];
+    if (req.request_body_not_captured) notes.push("Request body not captured: a stream that cannot be rewound is sent unread.");
+    if (req.request_body_truncated) notes.push("Request body truncated: only the beginning was kept (max_captured_body_bytes).");
+    if (req.response_body_truncated) notes.push("Response body truncated: only the beginning was kept (max_captured_body_bytes).");
+    return notes;
+  }
   function HttpRequestDetail({ req, index, threshold }) {
     const [open, setOpen] = d2(false);
     const isError = req.status >= 400 || req.status === 0;
@@ -4436,12 +4443,13 @@
       /* @__PURE__ */ u3("div", { class: "profiler-ajax-card__row", children: [
         /* @__PURE__ */ u3("span", { class: "profiler-text--xs profiler-text--muted", children: [
           "\u2191 ",
-          formatBytes(req.request_size),
+          req.request_size == null ? "size unknown" : `${req.request_size_is_minimum ? "at least " : ""}${formatBytes(req.request_size)}`,
           " \xB7 \u2193 ",
           formatBytes(req.response_size)
         ] }),
         req.backtrace && req.backtrace.length > 0 && /* @__PURE__ */ u3("span", { class: "profiler-text--xs profiler-text--muted", style: "margin-left:12px", children: req.backtrace[0] })
       ] }),
+      bodyNotes(req).map((note) => /* @__PURE__ */ u3("div", { class: "profiler-ajax-card__row", children: /* @__PURE__ */ u3("span", { class: "profiler-text--xs profiler-text--muted", children: note }) })),
       req.error && /* @__PURE__ */ u3("div", { class: "profiler-ajax-card__row", children: /* @__PURE__ */ u3("span", { class: "profiler-text--xs profiler-text--error", children: req.error }) }),
       open && /* @__PURE__ */ u3(
         HttpReqRespDetail,

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

@@ -4,17 +4,7 @@ module Profiler
   module Api
     class ConsoleController < ApplicationController
       def index
-        limit  = (params[:limit]  || 50).to_i
-        offset = (params[:offset] || 0).to_i
-        all    = Profiler.storage.list(limit: 1000, offset: 0)
-        console = all.select { |p| p.profile_type == "console" }
-        page   = console.drop(offset).first(limit + 1)
-        render json: {
-          profiles: page.first(limit).map(&:to_h),
-          limit:    limit,
-          offset:   offset,
-          has_more: page.size > limit
-        }
+        render_profile_page(type: "console")
       end
 
       def show

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

@@ -4,17 +4,7 @@ module Profiler
   module Api
     class JobsController < ApplicationController
       def index
-        limit  = (params[:limit]  || 50).to_i
-        offset = (params[:offset] || 0).to_i
-        all    = Profiler.storage.list(limit: 1000, offset: 0)
-        jobs   = all.select { |p| p.profile_type == "job" }
-        page   = jobs.drop(offset).first(limit + 1)
-        render json: {
-          profiles: page.first(limit).map(&:to_h),
-          limit:    limit,
-          offset:   offset,
-          has_more: page.size > limit
-        }
+        render_profile_page(type: "job")
       end
 
       def show

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

@@ -4,20 +4,16 @@ module Profiler
   module Api
     class ProfilesController < ApplicationController
       def index
-        limit  = (params[:limit]  || 50).to_i
-        offset = (params[:offset] || 0).to_i
-        all    = Profiler.storage.list(limit: 1000, offset: 0)
         # 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),
-          limit:    limit,
-          offset:   offset,
-          has_more: page.size > limit
-        }
+        # storage.list contract (every type, or the one given as type, full profiles); the
+        # dashboard relies on the default: http profiles, as summaries.
+        if params[:parent_token].present?
+          render_children_page
+        elsif all_types?
+          render_profile_page(type: profile_type_param, summary: false)
+        else
+          render_profile_page(type: "http")
+        end
       end
 
       def show
@@ -57,22 +53,16 @@ module Profiler
         %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
-
-        if Profiler.configuration.collectors.include?(ajax_collector_class)
-          collector = ajax_collector_class.new(profile)
-          collector.collect
+      def profile_type_param
+        params[:type].to_s.match?(/\A[a-z_]{1,32}\z/) ? params[:type].to_s : nil
+      end
 
-          # 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
-              ajax_tab[:has_data] = collector.has_data?
-            end
-          end
-        end
+      # The children of a page, oldest last, read through the store's parent index.
+      def render_children_page
+        limit, offset = page_params
+        children = Profiler.storage.find_by_parent(params[:parent_token].to_s).reverse
+        children = children.select { |p| p.profile_type == "http" } unless all_types?
+        render_page(children.drop(offset).first(limit + 1), limit, offset)
       end
     end
   end

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

@@ -4,17 +4,7 @@ module Profiler
   module Api
     class TestsController < ApplicationController
       def index
-        limit  = (params[:limit]  || 50).to_i
-        offset = (params[:offset] || 0).to_i
-        all    = Profiler.storage.list(limit: 1000, offset: 0)
-        tests  = all.select { |p| p.profile_type == "test" }
-        page   = tests.drop(offset).first(limit + 1)
-        render json: {
-          profiles: page.first(limit).map(&:to_h),
-          limit:    limit,
-          offset:   offset,
-          has_more: page.size > limit
-        }
+        render_profile_page(type: "test")
       end
 
       def show

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

@@ -24,26 +24,6 @@ module Profiler
           events_cursor: events_cursor
         }
       end
-
-      private
-
-      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.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
-              ajax_tab[:has_data] = collector.has_data?
-            end
-          end
-        end
-      end
     end
   end
 end

data/app/controllers/profiler/application_controller.rb

@@ -6,6 +6,9 @@ module Profiler
   class ApplicationController < ActionController::Base
     layout "profiler/application"
 
+    # A store that cannot be created: the cause in one line, as a 503, for every page and API.
+    rescue_from Profiler::Storage::Unavailable::Error, with: :storage_unavailable
+
     before_action :check_authorization
     before_action :authorize_request
     # Declared after the access checks, so that an unauthorized request gets its 403 first.
@@ -48,6 +51,14 @@ module Profiler
       deny("Missing #{Profiler::FORGERY_PROTECTION_HEADER} header or CSRF token")
     end
 
+    def storage_unavailable(error)
+      if controller_path.start_with?("profiler/api/")
+        render json: { error: error.message }, status: :service_unavailable
+      else
+        render plain: error.message, status: :service_unavailable
+      end
+    end
+
     def deny(message)
       if controller_path.start_with?("profiler/api/")
         render json: { error: message }, status: :forbidden
@@ -56,22 +67,51 @@ module Profiler
       end
     end
 
+    # A page of one type of profile, filtered, ordered and paged by the store: one profile more
+    # than the limit tells whether there is a next page, at any offset.
+    def render_profile_page(type:, summary: true)
+      limit, offset = page_params
+      render_page(Profiler.storage.list(limit: limit + 1, offset: offset, type: type, summary: summary), limit, offset)
+    end
+
+    def render_page(profiles, limit, offset)
+      render json: {
+        profiles: profiles.first(limit).map(&:to_h),
+        limit:    limit,
+        offset:   offset,
+        has_more: profiles.size > limit
+      }
+    end
+
+    def page_params
+      [[(params[:limit] || 50).to_i, 0].max, [(params[:offset] || 0).to_i, 0].max]
+    end
+
+    # The children of a page, read once per request: the child jobs and the AJAX tab share them.
+    def child_profiles(profile)
+      @child_profiles ||= {}
+      @child_profiles[profile.token] ||= (@resolved_storage || Profiler.storage).find_by_parent(profile.token)
+    end
+
+    # The AJAX sub-requests are saved after the page: their tab is computed here, whatever the
+    # configured collector list (Profiler::AjaxData).
+    def recalculate_ajax_data(profile)
+      Profiler::AjaxData.attach(profile, child_profiles(profile))
+    end
+
     def build_child_jobs(profile)
-      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
+      child_profiles(profile).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)

data/app/controllers/profiler/profiles_controller.rb

@@ -100,7 +100,7 @@ module Profiler
               return profile
             end
           rescue => e
-            Rails.logger.warn("[Profiler] Cached slave #{cached_slave} failed for #{token}: #{e.message}")
+            Profiler.log_warn("Cluster: cached slave #{cached_slave} failed for #{token}", e)
           end
         end
         Profiler.token_cache.invalidate(token)
@@ -130,7 +130,7 @@ module Profiler
               end
             end
           rescue => e
-            Rails.logger.warn("[Profiler] Fan-out error for slave #{slave_name} (#{token}): #{e.message}")
+            Profiler.log_warn("Cluster: fan-out error for slave #{slave_name} (#{token})", e)
           end
         end
       end
@@ -144,22 +144,6 @@ module Profiler
       end
     end
 
-    def recalculate_ajax_data(profile)
-      ajax_collector_class = Profiler::Collectors::AjaxCollector
-
-      if Profiler.configuration.collectors.include?(ajax_collector_class)
-        collector = ajax_collector_class.new(profile, storage: @resolved_storage || Profiler.storage)
-        collector.collect
-
-        if profile.instance_variable_get(:@collectors_metadata)
-          ajax_tab = profile.instance_variable_get(:@collectors_metadata).find { |tab| tab[:key] == 'ajax' }
-          if ajax_tab
-            ajax_tab[:has_data] = collector.has_data?
-          end
-        end
-      end
-    end
-
     def filter_profiles(profiles)
       filtered = profiles
 

data/lib/profiler/ajax_data.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "collectors/ajax_collector"
+
+module Profiler
+  # The AJAX tab of a page: its sub-requests are saved after the page itself, so the tab is
+  # computed when the page is shown, from its children, whatever the configured collector list.
+  # The children are the ones the caller already read (the same find_by_parent gives the child
+  # jobs): only the http ones are sub-requests, the jobs stay in child_jobs.
+  module AjaxData
+    # Hands the children already read to the AjaxCollector in place of the storage.
+    Children = Struct.new(:profiles) do
+      def find_by_parent(_parent_token)
+        profiles
+      end
+    end
+
+    module_function
+
+    # Adds the ajax collector data to profile, and its tab when it has none: a page without
+    # sub-requests and without the tab is left as it is.
+    def attach(profile, children)
+      requests = children.select { |child| child.profile_type == "http" }
+      # A copy: the memory store hands out the very tabs it keeps.
+      tabs = profile.collectors_metadata = (profile.collectors_metadata || []).map(&:dup)
+      tab = tabs.find { |entry| (entry[:key] || entry["key"]).to_s == "ajax" }
+      return if requests.empty? && tab.nil?
+
+      collector = Collectors::AjaxCollector.new(profile, storage: Children.new(requests))
+      collector.collect
+      if tab.nil?
+        profile.add_collector_metadata(collector)
+      elsif tab.key?("key")
+        tab["has_data"] = collector.has_data?
+      else
+        tab[:has_data] = collector.has_data?
+      end
+    end
+  end
+end

data/lib/profiler/cluster/master_client.rb

@@ -14,7 +14,7 @@ module Profiler
           register!
           @registered = true
         rescue => e
-          log_warn("Could not register with master at startup: #{e.message} — will retry in heartbeat loop")
+          log_warn("could not register with master at startup, will retry in the heartbeat loop", e)
         end
         start_heartbeat_thread
       end
@@ -25,7 +25,7 @@ module Profiler
         config = Profiler.configuration
         uri = master_uri("register")
         body = { name: config.resolved_name, url: config.self_url }.to_json
-        resp = Net::HTTP.post(uri, body, request_headers)
+        resp = Profiler.untracked_http { Net::HTTP.post(uri, body, request_headers) }
         unless resp.code.to_i.between?(200, 299)
           raise "Master returned #{resp.code}: #{resp.body.to_s.slice(0, 200)}"
         end
@@ -37,7 +37,7 @@ module Profiler
         config = Profiler.configuration
         uri = master_uri("heartbeat")
         body = { name: config.resolved_name }.to_json
-        resp = Net::HTTP.post(uri, body, request_headers)
+        resp = Profiler.untracked_http { Net::HTTP.post(uri, body, request_headers) }
         raise "Heartbeat rejected #{resp.code}" unless resp.code.to_i.between?(200, 299)
       end
 
@@ -74,25 +74,17 @@ module Profiler
             end
           rescue => e
             @registered = false
-            log_warn("Cluster communication failed: #{e.message} — will retry")
+            log_warn("communication with the master failed, will retry", e)
           end
         end
       end
 
       def log_info(msg)
-        if defined?(Rails)
-          Rails.logger.info("[Profiler Cluster] #{msg}")
-        else
-          $stderr.puts("[Profiler Cluster] #{msg}")
-        end
+        Profiler.log_info("Cluster: #{msg}")
       end
 
-      def log_warn(msg)
-        if defined?(Rails)
-          Rails.logger.warn("[Profiler Cluster] #{msg}")
-        else
-          $stderr.puts("[Profiler Cluster] WARN #{msg}")
-        end
+      def log_warn(msg, error = nil)
+        Profiler.log_warn("Cluster: #{msg}", error)
       end
     end
   end

data/lib/profiler/cluster/security.rb

@@ -44,9 +44,9 @@ module Profiler
           return unless config.cluster_master? || config.slave?
           return unless (problem = secret_problem) && secret_required?
 
-          logger.warn("[Profiler Cluster] #{problem}: registrations, heartbeats and proxied requests " \
-                      "are refused. Generate one with `ruby -rsecurerandom -e 'puts SecureRandom.hex(32)'` " \
-                      "and give the same value to every node.")
+          Profiler.log_warn("Cluster: #{problem}: registrations, heartbeats and proxied requests " \
+                            "are refused. Generate one with `ruby -rsecurerandom -e 'puts SecureRandom.hex(32)'` " \
+                            "and give the same value to every node.", logger: logger)
         end
 
         # Constant-time comparison of the secret a request carries with the configured one.

data/lib/profiler/cluster/slave_proxy.rb

@@ -33,11 +33,13 @@ module Profiler
 
       # 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) }
+      def list(limit: 50, offset: 0, type: nil, **)
+        # all_types mirrors Profiler.storage.list, which returns every profile type, or the one
+        # given as type; without it the proxy would only ever see http profiles (see
+        # ProfilesController#index). A slave of an earlier version ignores type: filtered here too.
+        data = get_json("/_profiler/api/profiles", limit: limit, offset: offset, all_types: true, type: type)
+        profiles = Array(data["profiles"]).map { |h| profile_from_api(h) }
+        type ? profiles.select { |p| p.profile_type == type.to_s } : profiles
       end
 
       # A token that is not one the gem issues is not found, without asking the slave.
@@ -113,10 +115,13 @@ module Profiler
         Security.outgoing_headers.each { |name, value| req[name] = value }
         # Net::HTTP never follows a redirect; a 3xx is reported, without its body, rather than
         # handed back as if the slave had answered.
-        resp = Net::HTTP.start(uri.hostname, uri.port,
-                               open_timeout: @open_timeout, read_timeout: @read_timeout,
-                               use_ssl: uri.scheme == "https") do |http|
-          http.request(req)
+        # The profiler's own call, never recorded in the profile of the request that makes it.
+        resp = Profiler.untracked_http do
+          Net::HTTP.start(uri.hostname, uri.port,
+                          open_timeout: @open_timeout, read_timeout: @read_timeout,
+                          use_ssl: uri.scheme == "https") do |http|
+            http.request(req)
+          end
         end
         return {} if resp.code == "204"
         if resp.code.to_s.start_with?("3")

data/lib/profiler/collectors/lifecycle.rb

@@ -13,7 +13,7 @@ module Profiler
         collectors.each { |collector| collector.subscribe if collector.respond_to?(:subscribe) }
         true
       rescue => e
-        warn "Profiler #{label}: Collector subscribe failed: #{e.message}"
+        Profiler.log_error("#{label}: collector subscribe failed", e)
         release_all(collectors)
         false
       end
@@ -23,7 +23,7 @@ module Profiler
         collectors&.each do |collector|
           collector.unsubscribe if collector.respond_to?(:unsubscribe)
         rescue => e
-          warn "Profiler: Collector #{collector.class} release failed: #{e.message}"
+          Profiler.log_error("collector #{collector.class} release failed", e)
         end
       end
     end