rails-profiler 0.31.0 → 0.31.2

data/lib/profiler/configuration.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
+require "pathname"
 require_relative "local_request"
+require_relative "allocation_counter"
 
 module Profiler
   # Header the profiler's own clients send on every request. A page on another origin cannot
@@ -31,7 +33,7 @@ module Profiler
 
     attr_accessor :storage_options, :collectors,
                   :skip_paths, :slow_query_threshold, :max_queries_warning,
-                  :track_memory, :memory_warning_threshold,
+                  :track_memory, :allocated_objects_warning_threshold,
                   :mcp_enabled, :mcp_transport, :mcp_port,
                   :authorization_mode, :max_profiles, :extension_cors_enabled,
                   :cors_allowed_origins, :api_forgery_protection, :frame_ancestors,
@@ -39,18 +41,16 @@ module Profiler
                   :track_http, :slow_http_threshold, :http_skip_hosts, :http_backtrace_depth,
                   :track_jobs,
                   :track_console,
-                  :apply_env_overrides_when_disabled,
+                  :apply_env_overrides_when_disabled, :restrict_storage_permissions,
                   :test_runner_allow_undiscovered_files,
                   :track_mailers, :capture_mail_body, :sanitize_mailer_recipients, :mailer_skip_actions,
-                  :compress_bodies, :compress_body_threshold,
+                  :compress_bodies, :compress_body_threshold, :max_captured_body_bytes,
                   :redact_sensitive_data, :filter_parameters, :env_allowlist,
                   :name, :master_url, :self_url,
                   :cluster_heartbeat_interval, :cluster_offline_threshold,
                   :cluster_master, :cluster_secret, :cluster_require_secret,
                   :cluster_allow_insecure_http
 
-    attr_writer :tmp_path
-
     attr_reader :authorize_block, :enabled, :track_tests
 
     def initialize
@@ -63,7 +63,9 @@ module Profiler
       @slow_query_threshold = 100 # milliseconds
       @max_queries_warning = 50
       @track_memory = true
-      @memory_warning_threshold = 100 * 1024 * 1024 # 100 MB
+      # Not compared with anything yet. The default is the former 100 MB memory threshold read
+      # as the objects it stood for.
+      @allocated_objects_warning_threshold = 100 * 1024 * 1024 / AllocationCounter::LEGACY_BYTES_PER_OBJECT
       @mcp_enabled = false
       @mcp_transport = :stdio
       @mcp_port = 3001
@@ -96,10 +98,16 @@ module Profiler
       @mailer_skip_actions = []
       @compress_bodies = true
       @compress_body_threshold = 10 * 1024 # 10 KB
+      # The request and response bodies kept in a profile stop at this many bytes; the
+      # application still reads and sends all of them. nil keeps whole bodies.
+      @max_captured_body_bytes = 256 * 1024
       @redact_sensitive_data = true
       @filter_parameters = DEFAULT_FILTER_PARAMETERS.dup
       @env_allowlist = DEFAULT_ENV_ALLOWLIST.dup
       @tmp_path = nil
+      # The profiler's directories 0700 and files 0600 (Profiler::Storage::PrivateFiles). false
+      # leaves the modes to the umask, for a web process and workers running under two users.
+      @restrict_storage_permissions = true
       @name = nil
       @master_url = nil
       @self_url = nil
@@ -113,12 +121,30 @@ module Profiler
       @cluster_allow_insecure_http = false
     end
 
+    # Always a Pathname, whether set from a String or left to its default.
     def tmp_path
       @tmp_path || default_tmp_path
     end
 
+    def tmp_path=(value)
+      @tmp_path = value.nil? ? nil : Pathname.new(value)
+    end
+
     attr_reader :cluster_allowed_slave_urls
 
+    # Deprecated: the figure it was meant for was never a byte count (see AllocationCounter).
+    # Read and written as allocated_objects_warning_threshold times the bytes per object the
+    # former figure used.
+    def memory_warning_threshold
+      @allocated_objects_warning_threshold&.*(AllocationCounter::LEGACY_BYTES_PER_OBJECT)
+    end
+
+    def memory_warning_threshold=(bytes)
+      warn "[Profiler] memory_warning_threshold is deprecated, set allocated_objects_warning_threshold " \
+           "(a number of objects) instead"
+      @allocated_objects_warning_threshold = bytes && bytes / AllocationCounter::LEGACY_BYTES_PER_OBJECT
+    end
+
     # :any, or a list of slave URLs and anchored Regexp patterns (see Profiler::Cluster::Security).
     # A Regexp that is not anchored with \A and \z is refused here, at boot, rather than ignored.
     def cluster_allowed_slave_urls=(value)
@@ -226,7 +252,7 @@ module Profiler
       if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
         Rails.root.join("tmp", "rails-profiler")
       else
-        File.expand_path("tmp/rails-profiler", Dir.pwd)
+        Pathname.new(File.expand_path("tmp/rails-profiler", Dir.pwd))
       end
     end
 

data/lib/profiler/console_profiler.rb

@@ -48,7 +48,7 @@ module Profiler
 
       exception_collector = collectors.find { |c| c.is_a?(Collectors::ExceptionCollector) }
 
-      memory_before = current_memory if Profiler.configuration.track_memory
+      allocations_before = AllocationCounter.current if Profiler.configuration.track_memory
 
       console_status = "completed"
 
@@ -66,7 +66,7 @@ module Profiler
       ensure
         Profiler::CurrentContext.token = previous_token
         if Profiler.configuration.track_memory
-          profile.memory = current_memory - memory_before
+          profile.allocated_objects = AllocationCounter.current - allocations_before
         end
 
         profile.finish(console_status == "completed" ? 200 : 500)
@@ -80,26 +80,11 @@ module Profiler
           end
         end
 
-        Profiler.storage.save(profile.token, profile)
+        Profiler.save_profile(profile, from: "ConsoleProfiler")
       end
     ensure
       # After collect, and also when collect or the storage failed.
       Collectors::Lifecycle.release_all(collectors)
     end
-
-    private
-
-    def current_memory
-      return 0 unless defined?(GC.stat)
-
-      stats = GC.stat
-      if stats.key?(:total_allocated_size)
-        stats[:total_allocated_size]
-      elsif stats.key?(:total_allocated_objects)
-        stats[:total_allocated_objects] * 40
-      else
-        0
-      end
-    end
   end
 end

data/lib/profiler/env_override_store.rb

@@ -2,9 +2,16 @@
 
 require "json"
 require "fileutils"
+require_relative "storage/private_files"
 
 module Profiler
   class EnvOverrideStore
+    # Raised by the methods a caller asked for (set, delete, reset, reset_all, clear and
+    # all_overrides) when the overrides file cannot be read or written. The caller then knows that
+    # nothing was changed. apply! and apply_at_boot! still only warn: they run at boot and before
+    # the application's jobs, where an override must never make the application fail.
+    class Error < Profiler::Error; end
+
     DELETED_SENTINEL = "__profiler_deleted__"
     RESTORE_SENTINEL = "__profiler_restore__"
 
@@ -30,53 +37,53 @@ module Profiler
     end
 
     def set(key, value)
-      remember_process_original(key)
-      update_overrides do |overrides|
-        overrides[key] = { "value" => value.to_s, "original" => original_for(overrides, key) }
+      surfacing("set #{key}") do
+        remember_process_original(key)
+        update_overrides do |overrides|
+          overrides[key] = { "value" => value.to_s, "original" => original_for(overrides, key) }
+        end
       end
-    rescue => e
-      warn "[Profiler] EnvOverrideStore: failed to set #{key}: #{e.message}"
     end
 
     def delete(key)
-      remember_process_original(key)
-      update_overrides do |overrides|
-        overrides[key] = { "value" => DELETED_SENTINEL, "original" => original_for(overrides, key) }
+      surfacing("delete #{key}") do
+        remember_process_original(key)
+        update_overrides do |overrides|
+          overrides[key] = { "value" => DELETED_SENTINEL, "original" => original_for(overrides, key) }
+        end
       end
-    rescue => e
-      warn "[Profiler] EnvOverrideStore: failed to delete #{key}: #{e.message}"
     end
 
     # Returns whether ENV was written in this process.
     def reset(key)
       entry = nil
-      update_overrides do |overrides|
-        entry = overrides[key]
-        # Keep a RESTORE entry so Sidekiq workers pick it up on next job
-        overrides[key] = { "value" => RESTORE_SENTINEL, "original" => entry["original"] } if entry
+      surfacing("reset #{key}") do
+        update_overrides do |overrides|
+          entry = overrides[key]
+          # Keep a RESTORE entry so Sidekiq workers pick it up on next job
+          overrides[key] = { "value" => RESTORE_SENTINEL, "original" => entry["original"] } if entry
+        end
       end
 
       # Apply immediately to the current (web) process
       restore_env(key, entry, blocked: blocked_reason)
-    rescue => e
-      warn "[Profiler] EnvOverrideStore: failed to reset #{key}: #{e.message}"
     end
 
     def reset_all
       originals = {}
-      update_overrides do |overrides|
-        overrides.each do |key, entry|
-          originals[key] = entry.is_a?(Hash) ? entry["original"] : nil
-          # Leave a RESTORE sentinel for Sidekiq workers to pick up
-          overrides[key] = { "value" => RESTORE_SENTINEL, "original" => originals[key] }
+      surfacing("reset the overrides") do
+        update_overrides do |overrides|
+          overrides.each do |key, entry|
+            originals[key] = entry.is_a?(Hash) ? entry["original"] : nil
+            # Leave a RESTORE sentinel for Sidekiq workers to pick up
+            overrides[key] = { "value" => RESTORE_SENTINEL, "original" => originals[key] }
+          end
         end
       end
 
       # Apply immediately to the current (web) process
       blocked = blocked_reason
       originals.each { |key, original| restore_env(key, { "original" => original }, blocked: blocked) }
-    rescue => e
-      warn "[Profiler] EnvOverrideStore: failed to reset all: #{e.message}"
     end
 
     # Why the persisted overrides must not reach ENV in this process, or nil when they may.
@@ -154,27 +161,36 @@ module Profiler
       warn "[Profiler] EnvOverrideStore: failed to apply overrides: #{e.message}"
     end
 
-    # Returns active overrides (excludes RESTORE entries — already being reverted)
+    # Returns active overrides (excludes RESTORE entries, already being reverted)
+    # A file that does not parse reads as no override; one that cannot be read raises Error.
     def all_overrides
-      load_overrides.reject do |_, entry|
-        value = entry.is_a?(Hash) ? entry["value"] : entry
-        value == RESTORE_SENTINEL
-      end.transform_values do |entry|
-        entry.is_a?(Hash) ? entry : { "value" => entry, "original" => nil }
+      surfacing("read the overrides") do
+        load_overrides.reject do |_, entry|
+          value = entry.is_a?(Hash) ? entry["value"] : entry
+          value == RESTORE_SENTINEL
+        end.transform_values do |entry|
+          entry.is_a?(Hash) ? entry : { "value" => entry, "original" => nil }
+        end
       end
-    rescue => e
-      warn "[Profiler] EnvOverrideStore: failed to load overrides: #{e.message}"
-      {}
     end
 
     def clear
-      with_lock { FileUtils.rm_f(override_file_path) }
-    rescue => e
-      warn "[Profiler] EnvOverrideStore: failed to clear: #{e.message}"
+      surfacing("clear the overrides") { with_lock { FileUtils.rm_f(override_file_path) } }
     end
 
     private
 
+    # The message names the file relative to tmp_path, and an Errno by its description only: it
+    # goes back to the Env tab, the MCP tools and the test runner output, without absolute paths.
+    def surfacing(action)
+      yield
+    rescue Error
+      raise
+    rescue StandardError => e
+      reason = e.is_a?(SystemCallError) ? e.class.new.message : e.class.name
+      raise Error, "could not #{action} in env_overrides.json under tmp_path: #{reason}"
+    end
+
     def remember_process_original(key)
       @process_originals_lock.synchronize do
         @process_originals[key] = ENV[key] unless @process_originals.key?(key)
@@ -227,8 +243,8 @@ module Profiler
     # An exclusive flock on a file next to the overrides file. Not reentrant: never nest it.
     def with_lock
       path = override_file_path
-      FileUtils.mkdir_p(path.dirname)
-      File.open("#{path}.lock", File::RDWR | File::CREAT, 0o644) do |lock|
+      Storage::PrivateFiles.tmp_dir
+      Storage::PrivateFiles.open("#{path}.lock") do |lock|
         lock.flock(File::LOCK_EX)
         yield
       end
@@ -237,12 +253,7 @@ module Profiler
     # Written to a temporary file then renamed over the old one, so that a reader never sees a
     # half-written file, which would parse as no override at all.
     def save_overrides(overrides)
-      path = override_file_path
-      tmp = "#{path}.#{Process.pid}.#{Thread.current.object_id}.tmp"
-      File.write(tmp, JSON.generate(overrides))
-      File.rename(tmp, path)
-    ensure
-      FileUtils.rm_f(tmp) if tmp
+      Storage::PrivateFiles.write(override_file_path, JSON.generate(overrides))
     end
   end
 end

data/lib/profiler/job_profiler.rb

@@ -71,7 +71,7 @@ module Profiler
 
       exception_collector = collectors.find { |c| c.is_a?(Collectors::ExceptionCollector) }
 
-      memory_before = current_memory if Profiler.configuration.track_memory
+      allocations_before = AllocationCounter.current if Profiler.configuration.track_memory
 
       job_status = "completed"
       error_message = nil
@@ -92,7 +92,7 @@ module Profiler
         Thread.current[:profiler_current_job_class] = previous_job_class
         Profiler::CurrentContext.token = previous_token
         if Profiler.configuration.track_memory
-          profile.memory = current_memory - memory_before
+          profile.allocated_objects = AllocationCounter.current - allocations_before
         end
 
         job_collector.update_status(job_status, error_message)
@@ -107,7 +107,7 @@ module Profiler
           end
         end
 
-        Profiler.storage.save(profile.token, profile)
+        Profiler.save_profile(profile, from: "JobProfiler")
       end
     ensure
       # After collect, and also when collect or the storage failed.
@@ -131,18 +131,5 @@ module Profiler
         arg.to_s
       end
     end
-
-    def current_memory
-      return 0 unless defined?(GC.stat)
-
-      stats = GC.stat
-      if stats.key?(:total_allocated_size)
-        stats[:total_allocated_size]
-      elsif stats.key?(:total_allocated_objects)
-        stats[:total_allocated_objects] * 40
-      else
-        0
-      end
-    end
   end
 end

data/lib/profiler/mcp/body_formatter.rb

@@ -9,10 +9,10 @@ module Profiler
       # Formats a body string for MCP output.
       #
       # params keys used:
-      #   "save_bodies"   (boolean) — save to ./tmp/rails-profiler/{token}/{name} and return path
-      #   "max_body_size" (number)  — truncate inline body at N chars
-      #   "json_path"     (string)  — JSONPath to extract from body when save_bodies is true
-      #   "xml_path"      (string)  — XPath to extract from body when save_bodies is true
+      #   "save_bodies"   (boolean): save to {tmp_path}/mcp-cache/{token}/{name} and return path
+      #   "max_body_size" (number):  truncate inline body at N chars
+      #   "json_path"     (string):  JSONPath to extract from body when save_bodies is true
+      #   "xml_path"      (string):  XPath to extract from body when save_bodies is true
       #
       # Returns a formatted string ready to embed in markdown, or nil if body is blank.
       def self.format_body(token, name, body, encoding, params)

data/lib/profiler/mcp/file_cache.rb

@@ -1,22 +1,31 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require_relative "../storage/private_files"
+require_relative "../storage/token"
 
 module Profiler
   module MCP
+    # The bodies the MCP tools save on request (save_bodies), under tmp_path/mcp-cache/<token>/<name>.
+    # The token comes from a profile, which a slave may have sent: one that is not a token the gem
+    # issues, or a name that is not one the tools use, is refused. The cleanup only removes the
+    # token directories of this cache: tmp_path also holds the profiles, the SQLite blobs and the
+    # env overrides.
     class FileCache
+      DIR_NAME = "mcp-cache"
+      NAME_FORMAT = /\A[a-z0-9_]+\z/
+
       def self.base_dir
-        Profiler.configuration.tmp_path.to_s
+        Profiler.configuration.tmp_path.join(DIR_NAME).to_s
       end
 
       def self.save(token, name, content)
+        return nil unless Storage::Token.valid?(token) && name.is_a?(String) && NAME_FORMAT.match?(name)
+
         cleanup if rand < 0.05
 
-        dir = File.join(base_dir, token)
-        FileUtils.mkdir_p(dir)
-        path = File.join(dir, name)
-        File.write(path, content)
-        path
+        dir = Storage::PrivateFiles.tmp_dir(DIR_NAME, token)
+        Storage::PrivateFiles.write(dir.join(name), content)
       rescue Errno::EACCES, Errno::EROFS
         nil
       end
@@ -25,7 +34,10 @@ module Profiler
         bd = base_dir
         return unless Dir.exist?(bd)
 
-        Dir.glob(File.join(bd, "*")).each do |dir|
+        Dir.children(bd).each do |entry|
+          next unless Storage::Token.valid?(entry)
+
+          dir = File.join(bd, entry)
           FileUtils.rm_rf(dir) if File.directory?(dir) && (Time.now - File.mtime(dir)) > max_age
         end
       end

data/lib/profiler/mcp/resources/recent_requests.rb

@@ -14,6 +14,8 @@ module Profiler
               method: profile.method,
               status: profile.status,
               duration: profile.duration&.round(2),
+              allocated_objects: profile.allocated_objects,
+              # Deprecated, kept for the readers that expect it: allocated_objects times 40, in MB.
               memory: profile.memory ? (profile.memory / 1024.0 / 1024.0).round(2) : nil,
               timestamp: profile.started_at&.iso8601,
               query_count: profile.collector_data("database")&.dig("total_queries") || 0,

data/lib/profiler/mcp/tools/delete_env_var.rb

@@ -26,7 +26,9 @@ module Profiler
           Profiler.env_override_store.delete(key)
           ENV.delete(key)
 
-          [{ type: "text", text: "Deleted #{key}. Override persisted — will remain deleted across restarts until reset." }]
+          [{ type: "text", text: "Deleted #{key}. Override persisted: it will remain deleted across restarts until reset." }]
+        rescue Profiler::EnvOverrideStore::Error => e
+          ::MCP::Tool::Response.new([{ type: "text", text: "Error: #{e.message}; #{key} was left unchanged." }], error: true)
         end
       end
     end

data/lib/profiler/mcp/tools/get_profile_detail.rb

@@ -87,7 +87,7 @@ module Profiler
           lines << "**Request:** #{profile.method} #{profile.path}"
           lines << "**Status:** #{profile.status}"
           lines << "**Duration:** #{profile.duration.round(2)} ms"
-          lines << "**Memory:** #{(profile.memory / 1024.0 / 1024.0).round(2)} MB" if profile.memory
+          lines << "**Allocated objects:** #{profile.allocated_objects}" if profile.allocated_objects
           lines << "**Time:** #{profile.started_at}"
           if profile.gem_version
             if profile.gem_version != Profiler::VERSION
@@ -184,6 +184,9 @@ module Profiler
           req_body = req_data["request_body"]
           if req_body && !req_body.empty?
             lines << "## Request Body"
+            if req_data["request_body_truncated"]
+              lines << truncation_note(req_data["request_body_size"], req_data["request_body_size_is_minimum"])
+            end
             formatted = BodyFormatter.format_body(
               profile.token,
               "request_body",
@@ -209,6 +212,10 @@ module Profiler
           resp_body = profile.response_body
           if resp_body && !resp_body.empty?
             lines << "## Response Body"
+            response_data = profile.collector_data("request") || {}
+            if response_data["response_body_truncated"]
+              lines << truncation_note(response_data["response_body_size"], response_data["response_body_size_is_minimum"])
+            end
             formatted = BodyFormatter.format_body(
               profile.token,
               "response_body",
@@ -222,6 +229,11 @@ module Profiler
           lines
         end
 
+        def self.truncation_note(size, minimum)
+          "_Truncated: the body was #{"at least " if minimum}#{size || "?"} bytes, only its beginning was kept " \
+            "(max_captured_body_bytes)._"
+        end
+
         def self.section_curl(profile)
           req_data = profile.collector_data("request")
           lines = []

data/lib/profiler/mcp/tools/get_test_profile_detail.rb

@@ -52,7 +52,7 @@ module Profiler
           lines << "| File | #{test_data["test_file"]}:#{test_data["test_line"]} |"
           lines << "| Duration | #{profile.duration&.round(2)}ms |"
           lines << "| Assertions | #{test_data["assertions"] || "-"} |"
-          lines << "| Memory delta | #{profile.memory ? "#{(profile.memory.to_f / 1024 / 1024).round(2)} MB" : "-"} |"
+          lines << "| Allocated objects | #{profile.allocated_objects || "-"} |"
           lines << "| Time | #{profile.started_at&.strftime("%H:%M:%S")} |"
 
           # Exception / skip

data/lib/profiler/mcp/tools/list_env_vars.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "mcp"
 require_relative "../slave_support"
 require_relative "../../env_override_store"
 require_relative "../../redaction"
@@ -61,6 +62,8 @@ module Profiler
           end
 
           [{ type: "text", text: text }]
+        rescue Profiler::EnvOverrideStore::Error => e
+          ::MCP::Tool::Response.new([{ type: "text", text: "Error: #{e.message}." }], error: true)
         end
 
         private

data/lib/profiler/mcp/tools/reset_all_env_vars.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "mcp"
 require_relative "../slave_support"
 
 module Profiler
@@ -22,6 +23,8 @@ module Profiler
           Profiler.env_override_store.reset_all
 
           [{ type: "text", text: "Reset #{count} environment variable#{"s" if count != 1} to original values." }]
+        rescue Profiler::EnvOverrideStore::Error => e
+          ::MCP::Tool::Response.new([{ type: "text", text: "Error: #{e.message}; nothing was changed." }], error: true)
         end
       end
     end

data/lib/profiler/mcp/tools/reset_env_var.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "mcp"
 require_relative "../slave_support"
 
 require "uri"
@@ -27,6 +28,8 @@ module Profiler
 
           done = restored ? "original value restored" : "ENV left unchanged"
           [{ type: "text", text: "Reset #{key}: override removed, #{done} in this process." }]
+        rescue Profiler::EnvOverrideStore::Error => e
+          ::MCP::Tool::Response.new([{ type: "text", text: "Error: #{e.message}; #{key} was left unchanged." }], error: true)
         end
       end
     end

data/lib/profiler/mcp/tools/set_env_var.rb

@@ -33,6 +33,8 @@ module Profiler
           ENV[key] = value
 
           [{ type: "text", text: "Set #{key}=#{value}" }]
+        rescue Profiler::EnvOverrideStore::Error => e
+          ::MCP::Tool::Response.new([{ type: "text", text: "Error: #{e.message}; #{key} was left unchanged." }], error: true)
         end
       end
     end