rails-profiler 0.36.2 → 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/app/controllers/profiler/health_controller.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Profiler
+  # GET /_profiler/health: the state of the circuit of each collector (see
+  # Profiler::Collectors::CircuitBreaker), as a page or, with a .json suffix or an Accept
+  # header, as JSON. Always 200: an open circuit means a collector is left out of the profiles,
+  # not that the profiler or the application is down, and a 503 would trip any probe pointed at it.
+  class HealthController < ApplicationController
+    def show
+      @enabled = Profiler.configuration.collector_circuit_breaker_enabled ? true : false
+      @threshold = Profiler.configuration.collector_circuit_breaker_threshold
+      @collectors = Profiler.configuration.collectors.map do |collector_class|
+        Collectors::CircuitBreaker.status(collector_class).merge(name: collector_class.name.to_s)
+      end
+
+      respond_to do |format|
+        format.html
+        format.json do
+          render json: {
+            circuit_breaker: { enabled: @enabled, threshold: @threshold },
+            collectors: @collectors
+          }
+        end
+      end
+    end
+  end
+end

data/app/views/profiler/health/show.html.erb

@@ -0,0 +1,26 @@
+<div style="max-width: 900px; margin: 24px auto; padding: 0 16px; font-family: system-ui, sans-serif;">
+  <p><a href="<%= profiler.root_path %>">&larr; Profiler</a></p>
+  <h1>Collector health</h1>
+  <p>
+    Circuit breaker: <strong><%= @enabled ? "enabled" : "disabled" %></strong>,
+    opens after <strong><%= @threshold %></strong> consecutive failures.
+  </p>
+  <table style="border-collapse: collapse; width: 100%;">
+    <thead>
+      <tr>
+        <th style="text-align: left; border-bottom: 1px solid #888; padding: 6px;">Collector</th>
+        <th style="text-align: left; border-bottom: 1px solid #888; padding: 6px;">State</th>
+        <th style="text-align: right; border-bottom: 1px solid #888; padding: 6px;">Consecutive failures</th>
+      </tr>
+    </thead>
+    <tbody>
+      <% @collectors.each do |collector| %>
+        <tr>
+          <td style="padding: 6px;"><%= collector[:name] %></td>
+          <td style="padding: 6px; font-weight: bold; color: <%= { closed: "#2e7d32", open: "#c62828", half_open: "#ef6c00" }[collector[:state]] %>;"><%= collector[:state] %></td>
+          <td style="padding: 6px; text-align: right;"><%= collector[:failures] %></td>
+        </tr>
+      <% end %>
+    </tbody>
+  </table>
+</div>

data/config/routes.rb

@@ -29,6 +29,7 @@ Profiler::Engine.routes.draw do
   get "assets/icon.png", to: "assets#icon"
 
   get "test_runner", to: "test_runner#index"
+  get "health", to: "health#show"
 
   namespace :api do
     resources :profiles, only: [:index, :show, :destroy] do

data/lib/profiler/collectors/circuit_breaker.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Profiler
+  module Collectors
+    # One circuit per collector class, shared by the threads and requests of the process. A
+    # class that fails config.collector_circuit_breaker_threshold times in a row (a subscribe or
+    # a collect that raises) is no longer instantiated: its circuit is open. After RECOVERY_SECONDS
+    # a single request tries it again (half open): a success closes the circuit, a failure
+    # opens it again for another RECOVERY_SECONDS. With the option off, nothing is counted and
+    # nothing is blocked.
+    module CircuitBreaker
+      RECOVERY_SECONDS = 60
+
+      # state: :closed, :open or :half_open. +since+ is when the circuit opened, or when the
+      # trial of a half open one was granted.
+      Circuit = Struct.new(:failures, :state, :since)
+
+      LOCK = Mutex.new
+      CIRCUITS = {}
+      private_constant :LOCK, :CIRCUITS
+
+      module_function
+
+      def enabled?
+        Profiler.configuration.collector_circuit_breaker_enabled ? true : false
+      end
+
+      # Whether a collector of this class is to be created for the next profile. An open circuit
+      # whose delay has passed answers true once, and becomes half open; a half open one answers
+      # false while its trial is under way, unless that trial never reported for RECOVERY_SECONDS.
+      def allow?(collector_class)
+        return true unless enabled?
+
+        LOCK.synchronize do
+          circuit = CIRCUITS[collector_class]
+          return true unless circuit
+
+          case circuit.state
+          when :closed then true
+          else
+            return false if now - circuit.since < RECOVERY_SECONDS
+
+            circuit.state = :half_open
+            circuit.since = now
+            true
+          end
+        end
+      end
+
+      def record_failure(collector_class)
+        return unless enabled?
+
+        LOCK.synchronize do
+          circuit = (CIRCUITS[collector_class] ||= Circuit.new(0, :closed, nil))
+          circuit.failures += 1
+          if circuit.state == :half_open || circuit.failures >= Profiler.configuration.collector_circuit_breaker_threshold
+            circuit.state = :open
+            circuit.since = now
+          end
+        end
+      end
+
+      def record_success(collector_class)
+        return unless enabled?
+
+        LOCK.synchronize do
+          circuit = CIRCUITS[collector_class]
+          return unless circuit
+
+          # A late success of a request that started before the circuit opened does not close it.
+          return if circuit.state == :open
+
+          CIRCUITS.delete(collector_class)
+        end
+      end
+
+      # { state:, failures: } for one class, without changing anything. An open circuit whose
+      # delay has passed is reported half open: the next request will try it.
+      def status(collector_class)
+        return { state: :closed, failures: 0 } unless enabled?
+
+        LOCK.synchronize do
+          circuit = CIRCUITS[collector_class]
+          return { state: :closed, failures: 0 } unless circuit
+
+          state = circuit.state
+          state = :half_open if state == :open && now - circuit.since >= RECOVERY_SECONDS
+          { state: state, failures: circuit.failures }
+        end
+      end
+
+      def reset!
+        LOCK.synchronize { CIRCUITS.clear }
+      end
+
+      # Monotonic seconds; a spec replaces it to move time.
+      def now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+    end
+  end
+end

data/lib/profiler/collectors/lifecycle.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "circuit_breaker"
+
 module Profiler
   module Collectors
     # Subscribes and releases the collectors of one profile, for every entry point that runs
@@ -7,14 +9,26 @@ module Profiler
     module Lifecycle
       module_function
 
-      # Subscribes each collector in turn. When one fails, releases them all, the ones that
-      # never subscribed included, and returns false: the caller then runs the work unprofiled.
+      # Subscribes each collector in turn. A collector whose subscribe raises is released and
+      # taken out of +collectors+ (the array is changed in place, so that the caller only collects
+      # the ones that subscribed); the others keep profiling. Returns false, with every collector
+      # released, only when none could subscribe: the caller then runs the work unprofiled.
       def subscribe_all(collectors, label)
-        collectors.each { |collector| collector.subscribe if collector.respond_to?(:subscribe) }
+        return true if collectors.empty?
+
+        collectors.reject! { |collector| !subscribe_one(collector, label) }
+        !collectors.empty?
+      end
+
+      # Runs the block that collects from one collector. A failure is logged and counted against
+      # the collector's class (CircuitBreaker), a success clears that count; the others carry on.
+      def guard(collector, label)
+        yield
+        CircuitBreaker.record_success(collector.class)
         true
       rescue => e
-        Profiler.log_error("#{label}: collector subscribe failed", e)
-        release_all(collectors)
+        Profiler.log_error("#{label}: collector #{collector.class} failed", e)
+        CircuitBreaker.record_failure(collector.class)
         false
       end
 
@@ -26,6 +40,17 @@ module Profiler
           Profiler.log_error("collector #{collector.class} release failed", e)
         end
       end
+
+      def subscribe_one(collector, label)
+        collector.subscribe if collector.respond_to?(:subscribe)
+        true
+      rescue => e
+        Profiler.log_error("#{label}: collector #{collector.class} subscribe failed", e)
+        CircuitBreaker.record_failure(collector.class)
+        release_all([collector])
+        false
+      end
+      private_class_method :subscribe_one
     end
   end
 end

data/lib/profiler/configuration.rb

@@ -57,7 +57,8 @@ module Profiler
                   :name, :master_url, :self_url,
                   :cluster_heartbeat_interval, :cluster_offline_threshold,
                   :cluster_master, :cluster_secret, :cluster_require_secret,
-                  :cluster_allow_insecure_http, :logger
+                  :cluster_allow_insecure_http, :logger,
+                  :collector_circuit_breaker_enabled
 
     attr_reader :authorize_block, :enabled, :track_tests, :max_profiles
 
@@ -156,6 +157,23 @@ module Profiler
       # Where the profiler's own errors go (Profiler.log): Rails.logger when nil, or $stderr when
       # there is none.
       @logger = nil
+      # A collector that fails this many times in a row is no longer run (see
+      # Profiler::Collectors::CircuitBreaker); false never stops one.
+      @collector_circuit_breaker_enabled = true
+      @collector_circuit_breaker_threshold = 3
+    end
+
+    attr_reader :collector_circuit_breaker_threshold
+
+    # A positive Integer. Anything else is left out with a warning, the previous value kept: the
+    # gem is loaded in production too, where a mistake here must not stop the application booting.
+    def collector_circuit_breaker_threshold=(value)
+      if value.is_a?(Integer) && value.positive?
+        @collector_circuit_breaker_threshold = value
+      else
+        Profiler.log_warn("config.collector_circuit_breaker_threshold: #{value.inspect} is not a positive " \
+                          "Integer; keeping #{@collector_circuit_breaker_threshold}")
+      end
     end
 
     # Always a Pathname, whether set from a String or left to its default.

data/lib/profiler/console_profiler.rb

@@ -72,11 +72,9 @@ module Profiler
         profile.finish(console_status == "completed" ? 200 : 500)
 
         collectors.each do |collector|
-          begin
+          Collectors::Lifecycle.guard(collector, "ConsoleProfiler") do
             collector.collect if collector.respond_to?(:collect)
             profile.add_collector_metadata(collector)
-          rescue => e
-            Profiler.log_error("ConsoleProfiler: collector #{collector.class} failed", e)
           end
         end
 

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/job_profiler.rb

@@ -102,11 +102,9 @@ module Profiler
         profile.finish(job_status == "completed" ? 200 : 500)
 
         collectors.each do |collector|
-          begin
+          Collectors::Lifecycle.guard(collector, "JobProfiler") do
             collector.collect if collector.respond_to?(:collect)
             profile.add_collector_metadata(collector)
-          rescue => e
-            Profiler.log_error("JobProfiler: collector #{collector.class} failed", e)
           end
         end
 

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)
@@ -153,10 +165,10 @@ module Profiler
         # A Rack 3 streaming body (call without each) writes to the socket itself: nothing to relay.
         unless body.respond_to?(:each)
           kept.each do |collector|
-            collector.collect if collector.respond_to?(:collect)
-            profile.refresh_collector_metadata(collector)
-          rescue => e
-            Profiler.log_error("ProfilerMiddleware: collector #{collector.class} failed", e)
+            Collectors::Lifecycle.guard(collector, "ProfilerMiddleware") do
+              collector.collect if collector.respond_to?(:collect)
+              profile.refresh_collector_metadata(collector)
+            end
           end
           record_response(env, profile, request_body, status, profiled_headers, "", nil, false)
           # Saved before the headers leave: a profile that is not there gets no token.
@@ -199,10 +211,10 @@ module Profiler
           next unless collector.is_a?(Collectors::RequestCollector) ||
                       (error && collector.respond_to?(:capture) && !collect_from_any_thread?(collector))
 
-          collector.collect
-          profile.refresh_collector_metadata(collector)
-        rescue => e
-          Profiler.log_error("ProfilerMiddleware: collector #{collector.class} failed", e)
+          Collectors::Lifecycle.guard(collector, "ProfilerMiddleware") do
+            collector.collect
+            profile.refresh_collector_metadata(collector)
+          end
         end
 
         Profiler.save_profile(profile, from: "ProfilerMiddleware")
@@ -261,11 +273,9 @@ module Profiler
 
       def collect_all(profile, collectors)
         collectors.each do |collector|
-          begin
+          Collectors::Lifecycle.guard(collector, "ProfilerMiddleware") do
             collector.collect if collector.respond_to?(:collect)
             profile.add_collector_metadata(collector)
-          rescue => e
-            Profiler.log_error("ProfilerMiddleware: collector #{collector.class} failed", e)
           end
         end
       end
@@ -303,7 +313,9 @@ module Profiler
       # Builds the collectors without subscribing them: Lifecycle.subscribe_all does, so that
       # a failure part way leaves every collector reachable for release.
       def create_collectors(profile)
-        Profiler.configuration.collectors.map { |collector_class| collector_class.new(profile) }
+        Profiler.configuration.collectors
+                .select { |collector_class| Collectors::CircuitBreaker.allow?(collector_class) }
+                .map { |collector_class| collector_class.new(profile) }
       end
 
       def html_response?(headers)

data/lib/profiler/middleware/streamed_profile.rb

@@ -82,10 +82,10 @@ module Profiler
           @released = true
           @profile.collectors_released_after_seconds = after_seconds if after_seconds
           @collectors.each do |collector|
-            collector.collect if collector.respond_to?(:collect)
-            @profile.refresh_collector_metadata(collector)
-          rescue => e
-            Profiler.log_error("ProfilerMiddleware: collector #{collector.class} failed", e)
+            Collectors::Lifecycle.guard(collector, "ProfilerMiddleware") do
+              collector.collect if collector.respond_to?(:collect)
+              @profile.refresh_collector_metadata(collector)
+            end
           end
           Collectors::Lifecycle.release_all(@collectors)
         end
@@ -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)