rails-profiler 0.37.0 → 0.38.0

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

@@ -9,6 +9,8 @@ module Profiler
         # dashboard relies on the default: http profiles, as summaries.
         if params[:parent_token].present?
           render_children_page
+        elsif params[:trace_id].present?
+          render_trace_page
         elsif all_types?
           render_profile_page(type: profile_type_param, summary: false)
         else
@@ -57,6 +59,14 @@ module Profiler
         params[:type].to_s.match?(/\A[a-z_]{1,32}\z/) ? params[:type].to_s : nil
       end
 
+      # The profiles of a trace, oldest last, read through the store's trace index.
+      def render_trace_page
+        limit, offset = page_params
+        members = Profiler.storage.find_by_trace(params[:trace_id].to_s).reverse
+        members = members.select { |p| p.profile_type == "http" } unless all_types?
+        render_page(members.drop(offset).first(limit + 1), limit, offset)
+      end
+
       # The children of a page, oldest last, read through the store's parent index.
       def render_children_page
         limit, offset = page_params

data/lib/profiler/current_context.rb

@@ -10,8 +10,18 @@ module Profiler
       Thread.current[:profiler_token] = value
     end
 
+    # The trace id of the profile in progress, for the outgoing calls to carry.
+    def self.trace_id
+      Thread.current[:profiler_trace_id]
+    end
+
+    def self.trace_id=(value)
+      Thread.current[:profiler_trace_id] = value
+    end
+
     def self.clear
       Thread.current[:profiler_token] = nil
+      Thread.current[:profiler_trace_id] = nil
     end
   end
 end

data/lib/profiler/instrumentation/net_http_instrumentation.rb

@@ -8,12 +8,18 @@ require "securerandom"
 require_relative "../redaction"
 require_relative "../body_content"
 require_relative "../configuration"
+require_relative "../current_context"
+require_relative "../trace_context"
 
 module Profiler
   module Instrumentation
     module NetHttpInstrumentation
       module RequestPatch
         def request(req, body = nil, &block)
+          # Before the guards below: the profiler's own calls (the master's requests to its
+          # slaves) carry the trace too, so that the slave's profile joins the request's trace.
+          NetHttpInstrumentation.inject_trace_context(req, address.to_s, port)
+
           collector = Thread.current[:profiler_http_collector]
           return super unless collector
           # Re-entrancy guard: Net::HTTP#request calls itself recursively when
@@ -128,6 +134,20 @@ module Profiler
         @installed = true
       end
 
+      # Adds a traceparent to a call made while a profiled request runs on this thread: the trace
+      # id of that request and a span id of its own. A traceparent the application set is kept,
+      # and a host excluded from the instrumentation gets none.
+      def self.inject_trace_context(req, host, port)
+        trace_id = CurrentContext.trace_id
+        return unless trace_id
+        return if req[TraceContext::HEADER]
+        return if skip_host?(host, port)
+
+        req[TraceContext::HEADER] = TraceContext.format(trace_id, TraceContext.new_span_id)
+      rescue => e
+        Profiler.log_error("NetHttpInstrumentation: could not add the traceparent header", e)
+      end
+
       # The hosts of http_skip_hosts, and the cluster's master (host and port): a slave's calls to
       # it are the profiler's, whichever code makes them.
       def self.skip_host?(host, port = nil)

data/lib/profiler/middleware/profiler_middleware.rb

@@ -3,6 +3,7 @@
 require "rack"
 require_relative "../models/profile"
 require_relative "../current_context"
+require_relative "../trace_context"
 require_relative "../collectors/lifecycle"
 require_relative "toolbar_injector"
 require_relative "capturing_body"
@@ -31,6 +32,7 @@ module Profiler
             profile = Models::Profile.new(build_request(env), params: false)
             profile.gem_version = Profiler.version
             Profiler::CurrentContext.token = profile.token
+            assign_trace(env, profile)
 
             # Capture request body before app processes it
             request_body = read_request_body(env)
@@ -76,6 +78,16 @@ module Profiler
 
       private
 
+      # Continues the trace of a valid incoming traceparent (its parent-id becomes this profile's
+      # parent_span_id), or starts a new one. Either way the profile gets a span of its own.
+      def assign_trace(env, profile)
+        incoming = TraceContext.parse(env["HTTP_TRACEPARENT"])
+        profile.trace_id = incoming ? incoming.trace_id : TraceContext.new_trace_id
+        profile.parent_span_id = incoming&.parent_id
+        profile.span_id = TraceContext.new_span_id
+        Profiler::CurrentContext.trace_id = profile.trace_id
+      end
+
       # Read after the application has run, so after the routing: the route parameters are there,
       # and the params carry the encoding the route declared, as the controller saw them.
       def capture_params(env, profile)

data/lib/profiler/middleware/streamed_profile.rb

@@ -114,7 +114,9 @@ module Profiler
       # once the collectors are released.
       def enter
         token = CurrentContext.token
+        trace_id = CurrentContext.trace_id
         CurrentContext.token = @profile.token
+        CurrentContext.trace_id = @profile.trace_id
         lent = @mutex.synchronize do
           next [] if @released
 
@@ -122,13 +124,14 @@ module Profiler
             [collector, collector.lend_thread_slots] if collector.respond_to?(:lend_thread_slots)
           end
         end
-        [token, lent]
+        [token, lent, trace_id]
       end
 
       def leave(state)
-        token, lent = state
+        token, lent, trace_id = state
         lent.reverse_each { |collector, previous| collector.return_thread_slots(previous) }
         CurrentContext.token = token
+        CurrentContext.trace_id = trace_id
       end
     end
   end

data/lib/profiler/models/profile.rb

@@ -21,7 +21,7 @@ module Profiler
                     :request_body_size, :request_body_truncated, :request_body_size_is_minimum,
                     :response_body_size, :response_body_truncated, :response_body_size_is_minimum,
                     :collectors_released_after_seconds, :params_truncated,
-                    :gem_version
+                    :gem_version, :trace_id, :span_id, :parent_span_id
 
       # +params+: false leaves the params to capture_params, for a caller that builds the profile
       # before the router has run.
@@ -167,6 +167,9 @@ module Profiler
           collectors_data: @collectors_data,
           tabs: @collectors_metadata,
           parent_token: @parent_token,
+          trace_id: @trace_id,
+          span_id: @span_id,
+          parent_span_id: @parent_span_id,
           is_ajax: @is_ajax
         }
       end
@@ -217,6 +220,9 @@ module Profiler
         profile.is_ajax = data[:is_ajax] || false
         profile.profile_type = data[:profile_type] || "http"
         profile.gem_version = data[:gem_version]
+        profile.trace_id = data[:trace_id]
+        profile.span_id = data[:span_id]
+        profile.parent_span_id = data[:parent_span_id]
 
         # Convert collectors_data keys to strings recursively for consistency
         profile.collectors_data = (data[:collectors_data] || {}).transform_keys(&:to_s).transform_values do |value|

data/lib/profiler/storage/base_store.rb

@@ -45,6 +45,11 @@ module Profiler
         raise NotImplementedError, "#{self.class} must implement #find_by_parent"
       end
 
+      # The profiles sharing a trace id, oldest first.
+      def find_by_trace(trace_id)
+        raise NotImplementedError, "#{self.class} must implement #find_by_trace"
+      end
+
       def delete(token)
         raise NotImplementedError, "#{self.class} must implement #delete"
       end

data/lib/profiler/storage/file_store.rb

@@ -41,7 +41,7 @@ module Profiler
       # Past a cap, the oldest profiles are evicted down to this share of it.
       LOW_WATER = 0.8
 
-      Entry = Struct.new(:token, :at, :type, :parent, :bytes, :summary, :sequence)
+      Entry = Struct.new(:token, :at, :type, :parent, :bytes, :summary, :sequence, :trace)
 
       def initialize(options = {})
         super()
@@ -138,6 +138,16 @@ module Profiler
         children.filter_map { |entry| load(entry.token) }.sort_by(&:started_at)
       end
 
+      def find_by_trace(trace_id)
+        return [] unless Token.valid?(trace_id)
+
+        members = @mutex.synchronize do
+          refresh
+          (@traces[trace_id] || {}).keys.filter_map { |token| @entries[token] }
+        end
+        members.filter_map { |entry| load(entry.token) }.sort_by(&:started_at)
+      end
+
       def delete(token)
         return unless Token.valid?(token)
 
@@ -173,13 +183,14 @@ module Profiler
       def put_record(token, data, bytes, started_at: nil)
         started_at = started_at&.to_f || (data[:started_at] ? Time.parse(data[:started_at]).to_f : Time.now.to_f)
         { "op" => "put", "token" => token, "at" => started_at, "type" => (data[:profile_type] || "http").to_s,
-          "parent" => data[:parent_token], "bytes" => bytes, "summary" => Summary.build(data) }
+          "parent" => data[:parent_token], "trace" => data[:trace_id], "bytes" => bytes, "summary" => Summary.build(data) }
       end
 
       def forget_index
         @entries = {}
         @sequence = 0
         @children = {}
+        @traces = {}
         @bytes = 0
         @records = 0
         @offset = 0
@@ -243,8 +254,9 @@ module Profiler
         when "put"
           remove_entry(token)
           parent = Token.valid?(record["parent"]) ? record["parent"] : nil
+          trace = Token.valid?(record["trace"]) ? record["trace"] : nil
           add_entry(Entry.new(token, record["at"].to_f, record["type"], parent, record["bytes"].to_i,
-                              record["summary"].is_a?(Hash) ? record["summary"] : nil))
+                              record["summary"].is_a?(Hash) ? record["summary"] : nil, nil, trace))
         when "del"
           remove_entry(token)
         end
@@ -255,6 +267,7 @@ module Profiler
         @entries[entry.token] = entry
         @bytes += entry.bytes
         (@children[entry.parent] ||= {})[entry.token] = true if entry.parent
+        (@traces[entry.trace] ||= {})[entry.token] = true if entry.trace
         @sorted = nil
       end
 
@@ -267,6 +280,10 @@ module Profiler
           siblings.delete(token)
           @children.delete(entry.parent) if siblings.empty?
         end
+        if entry.trace && (members = @traces[entry.trace])
+          members.delete(token)
+          @traces.delete(entry.trace) if members.empty?
+        end
         @sorted = nil
       end
 
@@ -344,7 +361,8 @@ module Profiler
       def entry_from_file(token)
         json = PrivateFiles.open_for_reading(profile_file_path(token), &:read)
         record = put_record(token, Models::Profile.from_json(json).to_h, json.bytesize)
-        Entry.new(token, record["at"], record["type"], record["parent"], record["bytes"], record["summary"])
+        trace = Token.valid?(record["trace"]) ? record["trace"] : nil
+        Entry.new(token, record["at"], record["type"], record["parent"], record["bytes"], record["summary"], nil, trace)
       rescue StandardError => e
         # Unreadable: kept in the count, so that it is evicted in turn; listed by no one.
         Profiler.log_error_once(:file_store_entry, "FileStore: could not read profile #{token} to index it", e)
@@ -353,7 +371,7 @@ module Profiler
         rescue SystemCallError
           nil
         end
-        Entry.new(token, stat ? stat.mtime.to_f : 0.0, nil, nil, stat ? stat.size : 0, nil)
+        Entry.new(token, stat ? stat.mtime.to_f : 0.0, nil, nil, stat ? stat.size : 0, nil, nil, nil)
       end
 
       def modified_at(token)
@@ -390,7 +408,8 @@ module Profiler
                                "compacted_at" => Time.now.to_f)]
         @entries.each_value do |entry|
           lines << JSON.generate("op" => "put", "token" => entry.token, "at" => entry.at, "type" => entry.type,
-                                 "parent" => entry.parent, "bytes" => entry.bytes, "summary" => entry.summary)
+                                 "parent" => entry.parent, "trace" => entry.trace, "bytes" => entry.bytes,
+                                 "summary" => entry.summary)
         end
         data = "#{lines.join("\n")}\n"
         PrivateFiles.write(@index_path, data)

data/lib/profiler/storage/memory_store.rb

@@ -12,7 +12,7 @@ module Profiler
     # cap). Beside them, the start time, type and parent of each, and the children of each parent,
     # so that listing, finding the children and evicting deserialize only what they return.
     class MemoryStore < BaseStore
-      Entry = Struct.new(:at, :type, :parent, :sequence)
+      Entry = Struct.new(:at, :type, :parent, :sequence, :trace)
 
       def initialize(options = {})
         @profiles = Concurrent::Hash.new
@@ -20,6 +20,7 @@ module Profiler
         @mutex = Mutex.new
         @entries = {}
         @children = {}
+        @traces = {}
         @sequence = 0
         @sorted = nil
       end
@@ -30,8 +31,9 @@ module Profiler
           cleanup_if_needed unless @profiles.key?(token)
           remove_entry(token)
           @profiles[token] = data
-          @entries[token] = Entry.new(profile.started_at.to_f, data[:profile_type].to_s, profile.parent_token, @sequence += 1)
+          @entries[token] = Entry.new(profile.started_at.to_f, data[:profile_type].to_s, profile.parent_token, @sequence += 1, profile.trace_id)
           (@children[profile.parent_token] ||= {})[token] = true if profile.parent_token
+          (@traces[profile.trace_id] ||= {})[token] = true if profile.trace_id
           @sorted = nil
         end
         token
@@ -70,6 +72,13 @@ module Profiler
         children.map { |data| deserialize_profile(data) }.sort_by(&:started_at)
       end
 
+      def find_by_trace(trace_id)
+        return [] unless Token.valid?(trace_id)
+
+        members = @mutex.synchronize { (@traces[trace_id] || {}).keys.filter_map { |token| @profiles[token] } }
+        members.map { |data| deserialize_profile(data) }.sort_by(&:started_at)
+      end
+
       def delete(token)
         return unless Token.valid?(token)
 
@@ -109,6 +118,10 @@ module Profiler
           siblings.delete(token)
           @children.delete(entry.parent) if siblings.empty?
         end
+        if entry.trace && (members = @traces[entry.trace])
+          members.delete(token)
+          @traces.delete(entry.trace) if members.empty?
+        end
         @sorted = nil
       end
 

data/lib/profiler/storage/redis_store.rb

@@ -102,6 +102,16 @@ module Profiler
               .sort_by(&:started_at)
       end
 
+      def find_by_trace(trace_id)
+        return [] unless Token.valid?(trace_id)
+
+        ensure_index
+        @redis.smembers(traces_key(trace_id))
+              .filter_map { |token| load(token) if Token.valid?(token) }
+              .select { |profile| profile.trace_id == trace_id }
+              .sort_by(&:started_at)
+      end
+
       def delete(token)
         return unless Token.valid?(token)
 
@@ -172,6 +182,11 @@ module Profiler
         client.zadd(saved_key, saved_at, token)
         client.sadd(types_key, type)
         [list_key, type_list_key(type), saved_key, types_key].each { |key| client.expire(key, @ttl) }
+        trace = summary[:trace_id] || summary["trace_id"]
+        if Token.valid?(trace)
+          client.sadd(traces_key(trace), token)
+          client.expire(traces_key(trace), @ttl)
+        end
         return unless Token.valid?(parent)
 
         client.sadd(children_key(parent), token)
@@ -185,6 +200,8 @@ module Profiler
         @redis.zrem(type_list_key(summary["profile_type"] || "http"), token)
         parent = summary["parent_token"]
         @redis.srem(children_key(parent), token) if Token.valid?(parent)
+        trace = summary["trace_id"]
+        @redis.srem(traces_key(trace), token) if Token.valid?(trace)
       end
 
       def remove(token)
@@ -205,6 +222,8 @@ module Profiler
               pipe.zrem(type_list_key(summary["profile_type"] || "http"), token)
               parent = summary["parent_token"]
               pipe.srem(children_key(parent), token) if Token.valid?(parent)
+              trace = summary["trace_id"]
+              pipe.srem(traces_key(trace), token) if Token.valid?(trace)
             else
               types.each { |type| pipe.zrem(type_list_key(type), token) }
             end
@@ -349,6 +368,10 @@ module Profiler
         "#{@key_prefix}:children:#{parent_token}"
       end
 
+      def traces_key(trace_id)
+        "#{@key_prefix}:traces:#{trace_id}"
+      end
+
       def index_version_key
         "#{@key_prefix}:index_version"
       end

data/lib/profiler/storage/sqlite_store.rb

@@ -66,11 +66,11 @@ module Profiler
           <<~SQL,
             INSERT OR REPLACE INTO profiler_profiles (
               token, profile_type, gem_version, path, method, status, duration, memory,
-              started_at, finished_at, parent_token, is_ajax,
+              started_at, finished_at, parent_token, trace_id, span_id, parent_span_id, is_ajax,
               tabs, params, headers, response_headers, collectors_meta, summary
             ) VALUES (
               :token, :profile_type, :gem_version, :path, :method, :status, :duration, :memory,
-              :started_at, :finished_at, :parent_token, :is_ajax,
+              :started_at, :finished_at, :parent_token, :trace_id, :span_id, :parent_span_id, :is_ajax,
               :tabs, :params, :headers, :response_headers, :collectors_meta, :summary
             )
           SQL
@@ -85,6 +85,9 @@ module Profiler
           started_at:       utc_iso8601(data[:started_at]),
           finished_at:      utc_iso8601(data[:finished_at]),
           parent_token:     data[:parent_token],
+          trace_id:         data[:trace_id],
+          span_id:          data[:span_id],
+          parent_span_id:   data[:parent_span_id],
           is_ajax:          data[:is_ajax] ? 1 : 0,
           tabs:             JSON.generate(data[:tabs] || []),
           params:           JSON.generate(data[:params] || {}),
@@ -136,6 +139,16 @@ module Profiler
         rows.map { |row| row_to_profile(row) }.compact
       end
 
+      def find_by_trace(trace_id)
+        return [] unless Token.valid?(trace_id)
+
+        rows = @db.execute(
+          "SELECT * FROM profiler_profiles WHERE trace_id = :trace_id ORDER BY started_at ASC, rowid ASC",
+          trace_id: trace_id
+        )
+        rows.map { |row| row_to_profile(row) }.compact
+      end
+
       def delete(token)
         return unless Token.valid?(token)
 
@@ -276,12 +289,13 @@ module Profiler
             ON profiler_profiles(profile_type);
         SQL
 
-        %w[gem_version summary].each do |column|
+        %w[gem_version summary trace_id span_id parent_span_id].each do |column|
           @db.execute("ALTER TABLE profiler_profiles ADD COLUMN #{column} TEXT")
         rescue SQLite3::Exception
           # column already exists
         end
 
+        @db.execute("CREATE INDEX IF NOT EXISTS idx_profiler_trace_id ON profiler_profiles(trace_id)")
         migrate_times_to_utc
       end
 
@@ -331,6 +345,9 @@ module Profiler
           started_at:             local_iso8601(row["started_at"]),
           finished_at:            local_iso8601(row["finished_at"]),
           parent_token:           row["parent_token"],
+          trace_id:               row["trace_id"],
+          span_id:                row["span_id"],
+          parent_span_id:         row["parent_span_id"],
           is_ajax:                row["is_ajax"] == 1,
           tabs:                   parse_json(row["tabs"], []),
           params:                 parse_json(row["params"], {}),

data/lib/profiler/trace_context.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Profiler
+  # The W3C Trace Context `traceparent` header, version 00:
+  # `00-{trace-id:32 hex}-{parent-id:16 hex}-{trace-flags:2 hex}`.
+  module TraceContext
+    HEADER = "traceparent"
+    # Version ff is forbidden by the specification; a later version is read by its first four
+    # fields, as the specification asks of a parser that does not know it.
+    PATTERN = /\A(?<version>\h{2})-(?<trace_id>\h{32})-(?<parent_id>\h{16})-(?<flags>\h{2})(?:-.*)?\z/
+    ZERO_TRACE_ID = ("0" * 32).freeze
+    ZERO_SPAN_ID = ("0" * 16).freeze
+
+    Parsed = Struct.new(:trace_id, :parent_id, :flags)
+
+    module_function
+
+    # The trace-id, parent-id and flags of a valid header value, nil for anything else.
+    def parse(value)
+      match = PATTERN.match(value.to_s.strip)
+      return nil unless match
+
+      version = match[:version].downcase
+      trace_id = match[:trace_id].downcase
+      parent_id = match[:parent_id].downcase
+      return nil if version == "ff"
+      # Version 00 has exactly four fields; the all-zero ids are invalid.
+      return nil if version == "00" && value.to_s.strip.count("-") != 3
+      return nil if trace_id == ZERO_TRACE_ID || parent_id == ZERO_SPAN_ID
+
+      Parsed.new(trace_id, parent_id, match[:flags].downcase)
+    end
+
+    def new_trace_id
+      SecureRandom.hex(16)
+    end
+
+    def new_span_id
+      SecureRandom.hex(8)
+    end
+
+    def format(trace_id, span_id, flags = "01")
+      "00-#{trace_id}-#{span_id}-#{flags}"
+    end
+  end
+end

data/lib/profiler/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Profiler
-  VERSION = "0.37.0"
+  VERSION = "0.38.0"
 
   GEM_ROOT = File.expand_path("../..", __dir__)
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-profiler
 version: !ruby/object:Gem::Version
-  version: 0.37.0
+  version: 0.38.0
 platform: ruby
 authors:
 - Sébastien Duplessy
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-18 00:00:00.000000000 Z
+date: 2026-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -260,6 +260,7 @@ files:
 - lib/profiler/test_runner/discovery.rb
 - lib/profiler/test_runner/run_store.rb
 - lib/profiler/test_runner/runner.rb
+- lib/profiler/trace_context.rb
 - lib/profiler/version.rb
 homepage: https://github.com/Pepsit36/rails-profiler
 licenses: