rails-profiler 0.31.1 → 0.31.3

data/lib/profiler/collectors/scoped_notifications.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require_relative "../current_context"
+
+module Profiler
+  module Collectors
+    # ActiveSupport::Notifications subscriptions scoped to the request that made them.
+    #
+    # The notifications bus is process-wide: a collector subscribed on it directly receives the
+    # events of every thread, another request's SQL included. Here the process holds one
+    # subscriber per event name, whatever the number of requests being profiled, and hands each
+    # event to the handlers of the execution context that emitted it only.
+    #
+    # The context is ActiveSupport::IsolatedExecutionState, which Rails itself scopes its
+    # connections and instrumenters to: a thread, or a fiber with
+    # config.active_support.isolation_level = :fiber. ActionController::Live shares it with the
+    # thread it runs the action in, and ThreadContextPropagation hands it to the threads a request
+    # starts. A thread with no scope of its own that carries a profile's token
+    # (Profiler::CurrentContext), as a server thread iterating a streamed body does, gets the scope
+    # opened under that token. A scope lasts until its last handler is released, after the
+    # response body is closed for a streamed response, wherever that release runs; the next
+    # request of the thread then opens a new one, so a thread still holding the old scope, or the
+    # old token, receives nothing more.
+    module ScopedNotifications
+      STATE_KEY = :profiler_notification_scope
+      # Fiber storage, inherited by the fibers and threads a fiber creates: Ruby 3.2+.
+      FIBER_STORAGE = Fiber.respond_to?(:[])
+
+      # The handlers of one request, by event name.
+      class Scope
+        attr_reader :token, :owner
+
+        def initialize(token = nil)
+          @token = token
+          @owner = Thread.current
+          @mutex = Mutex.new
+          @handlers = {}
+          @size = 0
+          @closed = false
+        end
+
+        def closed?
+          @closed
+        end
+
+        def handlers_for(event)
+          @handlers[event]
+        end
+
+        # False when the scope was closed meanwhile: the caller opens a new one.
+        def add(event, handler)
+          @mutex.synchronize do
+            return false if @closed
+
+            @handlers[event] = [*@handlers[event], handler].freeze
+            @size += 1
+            true
+          end
+        end
+
+        # nil when the handler was not there (released already), :last when it was the scope's
+        # last one, :removed otherwise.
+        def remove(event, handler)
+          @mutex.synchronize do
+            list = @handlers[event]
+            return nil unless list&.any? { |h| h.equal?(handler) }
+
+            rest = list.reject { |h| h.equal?(handler) }
+            rest.empty? ? @handlers.delete(event) : @handlers[event] = rest.freeze
+            @size -= 1
+            @closed = @size.zero?
+            @closed ? :last : :removed
+          end
+        end
+      end
+
+      Handle = Struct.new(:scope, :event, :handler)
+
+      @mutex = Mutex.new
+      @subscribers = {} # event name => [subscriber, handler count]
+      @by_token = {}.freeze # profile token => the scope opened under it, replaced on write
+
+      class << self
+        # Calls +handler+ with (name, started, finished, id, payload), monotonic times, for each
+        # +event+ the current execution context emits until the handle is unsubscribed.
+        def subscribe(event, &handler)
+          # The process subscriber first: when the notifier fails, nothing was added to the scope.
+          retain(event)
+          scope = current_scope
+          scope = open_scope until scope.add(event, handler)
+          Handle.new(scope, event, handler)
+        end
+
+        # Safe from any thread, and more than once.
+        def unsubscribe(handle)
+          return unless handle
+
+          removed = handle.scope.remove(handle.event, handle.handler)
+          return unless removed
+
+          release(handle.event)
+          close_scope(handle.scope) if removed == :last
+        end
+
+        # The current context's scope, for ThreadContextPropagation to hand to a new thread: the
+        # one of its execution state, or else the one a fiber inherited from the fiber that created
+        # it (Fiber storage, Ruby 3.2+). With isolation_level = :fiber, a fiber the request creates
+        # (render stream: true renders the layout in one) has no execution state of its own.
+        def current
+          scope = state[STATE_KEY]
+          scope = fiber_scope if scope.nil? || scope.closed?
+          scope unless scope.nil? || scope.closed?
+        end
+
+        # The scope the current context's events go to.
+        def routed_scope
+          scope = current
+          return scope if scope
+
+          token = CurrentContext.token
+          @by_token[token] if token
+        end
+
+        def adopt(scope)
+          state[STATE_KEY] = scope
+          Fiber[STATE_KEY] = scope if FIBER_STORAGE
+        end
+
+        # A thread a pool creates inherits the Fiber storage of the code that created it, which
+        # may be a request's: it must not keep that request's scope.
+        def forget_inherited_scope
+          Fiber[STATE_KEY] = nil if FIBER_STORAGE && !Fiber[STATE_KEY].nil?
+        end
+
+        # Runs the block with a scope of its own when the current one was opened by another thread:
+        # a job a pool performs for the request that enqueued it (ActiveJob's :async adapter) is
+        # profiled apart from that request, which may still be running. A job performed inline,
+        # on the request's own thread, keeps sharing its scope, as it always did.
+        def apart_from_other_threads
+          scope = current
+          return yield if scope.nil? || scope.owner.equal?(Thread.current)
+
+          previous = adopted
+          adopt(nil)
+          begin
+            yield
+          ensure
+            restore(previous)
+          end
+        end
+
+        # What the current context holds, closed or not, for RequestContext to put back.
+        def adopted
+          [state[STATE_KEY], fiber_scope]
+        end
+
+        def restore(adopted)
+          state[STATE_KEY], inherited = adopted
+          Fiber[STATE_KEY] = inherited if FIBER_STORAGE
+        end
+
+        private
+
+        def state
+          defined?(ActiveSupport::IsolatedExecutionState) ? ActiveSupport::IsolatedExecutionState : Thread.current
+        end
+
+        def current_scope
+          current || open_scope
+        end
+
+        def fiber_scope
+          Fiber[STATE_KEY] if FIBER_STORAGE
+        end
+
+        def open_scope
+          token = CurrentContext.token
+          scope = Scope.new(token)
+          if token
+            @mutex.synchronize { @by_token = @by_token.merge(token => scope).freeze }
+          end
+          adopt(scope)
+          scope
+        end
+
+        def close_scope(scope)
+          state[STATE_KEY] = nil if state[STATE_KEY].equal?(scope)
+          Fiber[STATE_KEY] = nil if FIBER_STORAGE && fiber_scope.equal?(scope)
+          return unless scope.token
+
+          @mutex.synchronize do
+            @by_token = @by_token.reject { |_, s| s.equal?(scope) }.freeze if @by_token[scope.token].equal?(scope)
+          end
+        end
+
+        def retain(event)
+          @mutex.synchronize do
+            entry = (@subscribers[event] ||= [subscribe_process(event), 0])
+            entry[1] += 1
+          end
+        end
+
+        def release(event)
+          @mutex.synchronize do
+            entry = @subscribers[event]
+            return unless entry
+
+            entry[1] -= 1
+            return unless entry[1] <= 0
+
+            ActiveSupport::Notifications.unsubscribe(entry[0])
+            @subscribers.delete(event)
+          end
+        end
+
+        def subscribe_process(event)
+          ActiveSupport::Notifications.monotonic_subscribe(event) do |name, started, finished, id, payload|
+            routed_scope&.handlers_for(event)&.each do |handler|
+              handler.call(name, started, finished, id, payload)
+            rescue StandardError => e
+              # Never into the application's query, nor at the expense of the other collectors.
+              warn "Profiler: a collector failed on #{event}: #{e.class}: #{e.message}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/profiler/collectors/view_collector.rb

@@ -34,7 +34,7 @@ module Profiler
       def subscribe
         return unless defined?(ActiveSupport::Notifications)
 
-        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("render_template.action_view") do |name, started, finished, unique_id, payload|
+        @subscriptions << subscribe_notification("render_template.action_view") do |name, started, finished, unique_id, payload|
           duration = ((finished - started) * 1000).round(2)
           @views << {
             identifier: payload[:identifier],
@@ -43,7 +43,7 @@ module Profiler
           }
         end
 
-        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("render_partial.action_view") do |name, started, finished, unique_id, payload|
+        @subscriptions << subscribe_notification("render_partial.action_view") do |name, started, finished, unique_id, payload|
           duration = ((finished - started) * 1000).round(2)
           @partials << {
             identifier: payload[:identifier],
@@ -66,6 +66,11 @@ module Profiler
         store_data(data)
       end
 
+      # Collect reads only what the collector gathered itself.
+      def collect_from_any_thread?
+        true
+      end
+
       def unsubscribe
         unsubscribe_notifications(@subscriptions)
       end

data/lib/profiler/configuration.rb

@@ -2,6 +2,7 @@
 
 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,8 +32,8 @@ module Profiler
     RAILS_DEFAULTED = %i[enabled storage track_tests].freeze
 
     attr_accessor :storage_options, :collectors,
-                  :skip_paths, :slow_query_threshold, :max_queries_warning,
-                  :track_memory, :memory_warning_threshold,
+                  :skip_paths, :slow_query_threshold, :max_queries_warning, :sql_backtrace,
+                  :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,
@@ -43,7 +44,7 @@ module Profiler
                   :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,
@@ -61,8 +62,14 @@ module Profiler
       @skip_paths = [%r{^/_profiler}, /\.well-known/, /favicon\.ico/, /manifest\.json/]
       @slow_query_threshold = 100 # milliseconds
       @max_queries_warning = 50
+      # Where each query comes from: :first_and_slow captures the caller the first time a
+      # statement runs in the request and for every slow query, :all for every query (as earlier
+      # versions did, about 0.1 ms each), :none never.
+      @sql_backtrace = :first_and_slow
       @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
@@ -95,6 +102,9 @@ 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
@@ -126,6 +136,19 @@ module Profiler
 
     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)

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)
@@ -86,20 +86,5 @@ module Profiler
       # 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/instrumentation/executor_context_propagation.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "concurrent"
+require_relative "request_context"
+
+module Profiler
+  module Instrumentation
+    # A task posted to a concurrent-ruby executor while a request is profiled runs in that
+    # request's context, whichever pool thread runs it and whenever: Concurrent::Promises,
+    # Concurrent::Future, ActiveJob's :async adapter and ActionController::Live all post their
+    # work this way. The pool thread has its own context back once the task returns.
+    module ExecutorContextPropagation
+      def post(*args, &task)
+        return super if task.nil?
+
+        context = RequestContext.capture
+        return super if context.nil?
+
+        wrapper = proc do |*task_args|
+          RequestContext.with(context) { task.call(*task_args) }
+        end
+        wrapper.ruby2_keywords
+        super(*args, &wrapper)
+      end
+      ruby2_keywords :post
+
+      # The executors that define post themselves; the others inherit it from one of them.
+      EXECUTORS = %w[
+        Concurrent::RubyExecutorService
+        Concurrent::SimpleExecutorService
+        Concurrent::TimerSet
+        Concurrent::SerializedExecutionDelegator
+      ].freeze
+
+      def self.install!
+        EXECUTORS.each do |name|
+          executor = Object.const_get(name)
+          executor.prepend(self) unless executor.ancestors.include?(self)
+        rescue NameError
+          next # not in this version of concurrent-ruby
+        end
+      end
+    end
+  end
+end
+
+Profiler::Instrumentation::ExecutorContextPropagation.install!

data/lib/profiler/instrumentation/request_context.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "../collectors/scoped_notifications"
+
+module Profiler
+  module Instrumentation
+    # What a request being profiled hands to the work it starts on other threads: its
+    # notification scope and the collectors that record through thread-local slots.
+    #
+    # It travels with the work, not with a thread: a thread the application starts with
+    # Thread.new gets it for the life of its block (ThreadContextPropagation), a task posted to a
+    # concurrent-ruby executor for the time the task runs (ExecutorContextPropagation). A thread
+    # an executor creates to run tasks, a pool worker or a Puma thread, gets nothing: it outlives
+    # the request and serves others.
+    module RequestContext
+      KEYS = %i[
+        profiler_http_collector
+        profiler_flamegraph_collector
+      ].freeze
+
+      # The files whose code calls Thread.new to create the threads of a pool: concurrent-ruby's
+      # executors (a worker of RubyThreadPoolExecutor, the thread of SimpleExecutorService) and
+      # Puma's thread pool.
+      POOL_FILES = %r{/concurrent/executor/[a-z_]+\.rb\z|/puma/thread_pool\.rb\z}
+
+      module_function
+
+      # The current request's context, or nil outside of one.
+      def capture
+        slots = KEYS.filter_map do |key|
+          value = Thread.current[key]
+          [key, value] unless value.nil?
+        end.to_h
+        scope = Collectors::ScopedNotifications.current
+        return nil if slots.empty? && scope.nil?
+
+        { slots: slots, scope: scope }.freeze
+      end
+
+      # Runs the block in +context+, and gives the thread back what it had before.
+      def with(context)
+        return yield if context.nil?
+
+        previous_slots = KEYS.to_h { |key| [key, Thread.current[key]] }
+        previous_scope = Collectors::ScopedNotifications.adopted
+        KEYS.each { |key| Thread.current[key] = context[:slots][key] }
+        Collectors::ScopedNotifications.adopt(context[:scope])
+        begin
+          yield
+        ensure
+          previous_slots.each { |key, value| Thread.current[key] = value }
+          Collectors::ScopedNotifications.restore(previous_scope)
+        end
+      end
+
+      # The block of a pool's thread, rid of the request's scope its Fiber storage inherits.
+      def without_inherited(block)
+        wrapper = proc do |*args|
+          Collectors::ScopedNotifications.forget_inherited_scope
+          block.call(*args)
+        end
+        wrapper.ruby2_keywords
+        wrapper
+      end
+
+      # Whether the thread being created is one of a pool's: then it must not inherit. Only the
+      # code that calls Thread.new counts; a thread the application starts from a task, or from a
+      # request a pool thread serves, is the request's.
+      def creating_pool_thread?
+        # 0 is this method, 1 the Thread#initialize patch, 2 Thread.new, which reports the file
+        # of the code that called it.
+        location = caller_locations(2, 1)&.first
+        location ? POOL_FILES.match?(location.path.to_s) : false
+      end
+    end
+  end
+end

data/lib/profiler/instrumentation/thread_context_propagation.rb

@@ -1,24 +1,24 @@
 # frozen_string_literal: true
 
+require_relative "request_context"
+
 module Profiler
   module Instrumentation
+    # A thread the application starts while a request is profiled works for that request: it gets
+    # the request's context (RequestContext) for the life of its block. A thread a pool creates
+    # (concurrent-ruby, Puma) does not: it outlives the request, and the tasks it runs bring
+    # their own context (ExecutorContextPropagation).
     module ThreadContextPropagation
-      PROPAGATED_KEYS = %i[
-        profiler_http_collector
-        profiler_flamegraph_collector
-      ].freeze
+      PROPAGATED_KEYS = RequestContext::KEYS
 
       def initialize(*args, &block)
         # Ruby refuses a Thread with no block, and the wrapper below is a block, so
         # without this the error would never come while a profile is being collected.
         return super if block.nil?
 
-        parent_context = PROPAGATED_KEYS.filter_map do |key|
-          val = Thread.current[key]
-          [key, val] unless val.nil?
-        end.to_h
-
-        return super if parent_context.empty?
+        context = RequestContext.capture
+        return super if context.nil?
+        return super(*args, &RequestContext.without_inherited(block)) if RequestContext.creating_pool_thread?
 
         # Thread.new hands its arguments to the block, so the wrapper has to take
         # them and pass them on. Ruby 3.4 depends on it in the stdlib: the Happy
@@ -30,12 +30,7 @@ module Profiler
         # on this method, keeps a trailing keyword hash a keyword hash rather than
         # flattening it into a positional argument.
         wrapper = proc do |*block_args|
-          parent_context.each { |k, v| Thread.current[k] = v }
-          begin
-            block&.call(*block_args)
-          ensure
-            PROPAGATED_KEYS.each { |k| Thread.current[k] = nil }
-          end
+          RequestContext.with(context) { block&.call(*block_args) }
         end
         wrapper.ruby2_keywords
 

data/lib/profiler/job_profiler.rb

@@ -31,14 +31,16 @@ module Profiler
     def self.profile(job_class:, job_id:, queue:, arguments:, executions:, parent_token: nil, &block)
       return block.call unless Profiler.enabled? && Profiler.configuration.track_jobs
 
-      new(
+      profiler = new(
         job_class: job_class,
         job_id: job_id,
         queue: queue,
         arguments: arguments,
         executions: executions,
         parent_token: parent_token
-      ).run(&block)
+      )
+      # Performed by a pool for the request that enqueued it: the job's notifications are its own.
+      Collectors::ScopedNotifications.apart_from_other_threads { profiler.run(&block) }
     end
 
     def initialize(job_class:, job_id:, queue:, arguments:, executions:, parent_token: nil)
@@ -71,7 +73,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 +94,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)
@@ -131,18 +133,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/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/get_profile_detail.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../slave_support"
+require_relative "../../process_snapshot"
 
 require "shellwords"
 require "cgi"
@@ -22,7 +23,10 @@ module Profiler
 
           storage = MCP::SlaveSupport.resolve_storage(params)
           profile = if token == "latest"
-            storage.list(limit: 1).first
+            # Loaded by its token: a slave adds its own routes and ENV to what it serves then,
+            # never to the profiles it lists.
+            latest = storage.list(limit: 1).first
+            latest && (storage.load(latest.token) || latest)
           else
             storage.load(token)
           end
@@ -50,6 +54,9 @@ module Profiler
         def self.format_profile_detail(profile, params = {})
           requested = params["sections"]&.map(&:to_s)
           want = ->(name) { requested.nil? || requested.include?(name) }
+          # The route table and ENV are the process's, not stored in the profile. A slave's
+          # profile comes with the slave's: this process's would be another process's.
+          Profiler::ProcessSnapshot.hydrate(profile) unless params["slave"]
 
           lines = []
           lines += section_overview(profile)              if want.("overview")
@@ -87,7 +94,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 +191,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 +219,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 +236,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 = []