rails-profiler 0.15.0 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f9f680d793888c215c4b0203f3f4ceb538d415de05916400730fd86561e1c84
-  data.tar.gz: d0d944230d9e29d4fea24b54c6ea7134d1994e6624c1e7d0994cd7900a716406
+  metadata.gz: 786465dc498178e1ab9256de7b02b397df7db82b4fc817fc3adbe191d8170fcd
+  data.tar.gz: acdeb2a1cdb00a59429bdf14a75f0551c4e94e65787b0640096dd5e044520999
 SHA512:
-  metadata.gz: b46d2fd2ecc46a051a5616115a0c2ef8b4da155b009ac5734e5e44fe355e14b2b30c4cdeaf52721d403436eebb5076ca6b3c6c3343407d326cdae17394607df7
-  data.tar.gz: fc1e2d5d01929200d5fe4f705db509fce7daed7ed13f8a474b31196e397bf797b912a85add2c0f2ae662f3d90b94f65e8dcb383ea142f1706420dfe68b4a961f
+  metadata.gz: 5e6e51705278a372284b5936aab067c5c1fc09d257561b2787e9d8a5847f608c1cdc2149b74259abc9f411b48e8369f5fd368fd934b13eb8c2a47efbafd27651
+  data.tar.gz: f2cf3377ba982ee6135a0040d4f9d1c588c7255724d72d5fde8a38ed53cba188a40a669fa28161b906e3cc401b46405a2c24aac5d5438233e854b2e3c2ec3b74

data/app/assets/builds/profiler.css

@@ -2702,6 +2702,53 @@ a.profiler-toolbar-item.profiler-text--warning::after {
 .profiler-fn-profiling__toggle--active:hover {
   background: rgba(245, 158, 11, 0.15);
 }
+.profiler-fn-profiling__mode-selector {
+  display: inline-flex;
+  border: 1px solid var(--profiler-border-strong);
+  border-radius: var(--profiler-radius-sm);
+  overflow: hidden;
+}
+.profiler-fn-profiling__mode-btn {
+  height: 28px;
+  padding: 0 12px;
+  background: var(--profiler-bg-lighter);
+  border: none;
+  border-right: 1px solid var(--profiler-border-strong);
+  color: var(--profiler-text-muted);
+  font-size: var(--profiler-text-xs);
+  font-weight: 600;
+  font-family: var(--profiler-font-sans);
+  cursor: pointer;
+  transition: all var(--profiler-transition-base);
+  white-space: nowrap;
+}
+.profiler-fn-profiling__mode-btn:last-child {
+  border-right: none;
+}
+.profiler-fn-profiling__mode-btn:hover:not(:disabled):not(.profiler-fn-profiling__mode-btn--active) {
+  background: var(--profiler-bg-elevated);
+  color: var(--profiler-text);
+}
+.profiler-fn-profiling__mode-btn--active {
+  background: var(--profiler-accent-bg);
+  color: var(--profiler-accent);
+  cursor: default;
+}
+.profiler-fn-profiling__mode-btn:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+.profiler-fn-profiling__cpu-pct {
+  color: var(--profiler-text-subtle);
+  font-size: 0.85em;
+}
+.profiler-fn-profiling__gc--medium {
+  color: #f59e0b;
+}
+.profiler-fn-profiling__gc--high {
+  color: #ef4444;
+  font-weight: 600;
+}
 .profiler-fn-profiling__hint {
   margin: 12px 0 0;
   padding: 10px 14px;

data/app/assets/builds/profiler.js

@@ -2513,8 +2513,12 @@
     const [fnSortDir, setFnSortDir] = d2("desc");
     const [fnEnabled, setFnEnabled] = d2(functionProfileData?.enabled ?? false);
     const [fnMaxFrames, setFnMaxFrames] = d2(functionProfileData?.max_frames ?? 2e3);
+    const [fnMode, setFnMode] = d2(functionProfileData?.mode === "lite" ? "lite" : "full");
+    const [fnClock, setFnClock] = d2(functionProfileData?.clock ?? "wall");
     const [fnToggling, setFnToggling] = d2(false);
     const [fnMaxFramesUpdating, setFnMaxFramesUpdating] = d2(false);
+    const [fnModeUpdating, setFnModeUpdating] = d2(false);
+    const [fnClockUpdating, setFnClockUpdating] = d2(false);
     const patchFunctionProfiling = async (patch) => {
       const res = await fetch("/_profiler/api/function_profiling", {
         method: "PATCH",
@@ -2541,6 +2545,25 @@
         setFnMaxFramesUpdating(false);
       }
     };
+    const updateMode = async (value) => {
+      setFnMode(value);
+      setFnModeUpdating(true);
+      try {
+        const json = await patchFunctionProfiling({ mode: value });
+        setFnMode(json.mode ?? value);
+      } finally {
+        setFnModeUpdating(false);
+      }
+    };
+    const updateClock = async (value) => {
+      setFnClockUpdating(true);
+      try {
+        const json = await patchFunctionProfiling({ clock: value });
+        setFnClock(json.clock ?? value);
+      } finally {
+        setFnClockUpdating(false);
+      }
+    };
     const data = flamegraphData;
     y2(() => {
       if (!data?.root_events?.length || !canvasRef.current || !containerRef.current) return;
@@ -2623,10 +2646,16 @@
               toggling: fnToggling,
               maxFrames: fnMaxFrames,
               maxFramesUpdating: fnMaxFramesUpdating,
+              mode: fnMode,
+              modeUpdating: fnModeUpdating,
+              clock: fnClock,
+              clockUpdating: fnClockUpdating,
               sortKey: fnSortKey,
               sortDir: fnSortDir,
               onToggle: toggleFunctionProfiling,
               onMaxFramesChange: updateMaxFrames,
+              onModeChange: updateMode,
+              onClockChange: updateClock,
               onSortChange: (key, dir) => {
                 setFnSortKey(key);
                 setFnSortDir(dir);
@@ -2666,10 +2695,16 @@
             toggling: fnToggling,
             maxFrames: fnMaxFrames,
             maxFramesUpdating: fnMaxFramesUpdating,
+            mode: fnMode,
+            modeUpdating: fnModeUpdating,
+            clock: fnClock,
+            clockUpdating: fnClockUpdating,
             sortKey: fnSortKey,
             sortDir: fnSortDir,
             onToggle: toggleFunctionProfiling,
             onMaxFramesChange: updateMaxFrames,
+            onModeChange: updateMode,
+            onClockChange: updateClock,
             onSortChange: (key, dir) => {
               setFnSortKey(key);
               setFnSortDir(dir);
@@ -2755,10 +2790,16 @@
           toggling: fnToggling,
           maxFrames: fnMaxFrames,
           maxFramesUpdating: fnMaxFramesUpdating,
+          mode: fnMode,
+          modeUpdating: fnModeUpdating,
+          clock: fnClock,
+          clockUpdating: fnClockUpdating,
           sortKey: fnSortKey,
           sortDir: fnSortDir,
           onToggle: toggleFunctionProfiling,
           onMaxFramesChange: updateMaxFrames,
+          onModeChange: updateMode,
+          onClockChange: updateClock,
           onSortChange: (key, dir) => {
             setFnSortKey(key);
             setFnSortDir(dir);
@@ -2780,15 +2821,23 @@
     }
     return null;
   }
-  function FunctionProfilingSection({ data, enabled, toggling, maxFrames, maxFramesUpdating, sortKey, sortDir, onToggle, onMaxFramesChange, onSortChange }) {
+  function FunctionProfilingSection({ data, enabled, toggling, maxFrames, maxFramesUpdating, mode, modeUpdating, clock, clockUpdating, sortKey, sortDir, onToggle, onMaxFramesChange, onModeChange, onClockChange, onSortChange }) {
     const [filterNames, setFilterNames] = d2(null);
     const [filterLabel, setFilterLabel] = d2(null);
     const [hoveredFnName, setHoveredFnName] = d2(null);
     const fnRendererRef = A2(null);
     const hasData = enabled && data?.enabled && (data.functions?.length ?? 0) > 0;
+    const dataMode = data?.mode ?? "full";
+    const dataClock = data?.clock ?? "wall";
+    const isSampling = dataMode === "lite";
+    const isObjectClock = dataClock === "object";
+    const showAllocated = !isSampling;
+    const showMemory = dataMode === "full";
+    const showClock = mode === "lite";
+    const effectiveSortKey = sortKey === "memory_bytes" && !showMemory || sortKey === "allocated_objects" && !showAllocated ? "total_duration" : sortKey;
     const rootCalls = hasData ? data.root_calls ?? [] : [];
     const sortedFunctions = hasData ? [...data.functions].sort(
-      (a3, b) => sortDir === "asc" ? a3[sortKey] - b[sortKey] : b[sortKey] - a3[sortKey]
+      (a3, b) => sortDir === "asc" ? a3[effectiveSortKey] - b[effectiveSortKey] : b[effectiveSortKey] - a3[effectiveSortKey]
     ) : [];
     const displayedFunctions = filterNames ? sortedFunctions.filter((fn) => filterNames.has(fn.name)) : sortedFunctions;
     const handleFrameSelect = (node) => {
@@ -2808,7 +2857,7 @@
       }
     };
     const sortIcon = (key) => {
-      if (sortKey !== key) return /* @__PURE__ */ u3("span", { class: "sort-icon sort-icon--idle", children: "\u21C5" });
+      if (effectiveSortKey !== key) return /* @__PURE__ */ u3("span", { class: "sort-icon sort-icon--idle", children: "\u21C5" });
       return /* @__PURE__ */ u3("span", { class: "sort-icon sort-icon--active", children: sortDir === "asc" ? "\u25B2" : "\u25BC" });
     };
     const handleMaxFramesBlur = (e3) => {
@@ -2826,6 +2875,28 @@
       /* @__PURE__ */ u3("div", { class: "profiler-fn-profiling__header", children: [
         /* @__PURE__ */ u3("span", { class: `profiler-fn-profiling__title${enabled ? " profiler-fn-profiling__title--active" : ""}`, children: "Function Profiling" }),
         /* @__PURE__ */ u3("div", { class: "profiler-fn-profiling__controls", children: [
+          /* @__PURE__ */ u3("div", { class: "profiler-fn-profiling__mode-selector", children: ["full", "lite"].map((m3) => /* @__PURE__ */ u3(
+            "button",
+            {
+              class: `profiler-fn-profiling__mode-btn${mode === m3 ? " profiler-fn-profiling__mode-btn--active" : ""}`,
+              onClick: () => mode !== m3 && onModeChange(m3),
+              disabled: modeUpdating,
+              title: m3 === "full" ? "Exhaustive TracePoint \u2014 timing + allocations + memory bytes" : "StackProf sampling \u2014 very low overhead",
+              children: m3.charAt(0).toUpperCase() + m3.slice(1)
+            },
+            m3
+          )) }),
+          showClock && /* @__PURE__ */ u3("div", { class: "profiler-fn-profiling__mode-selector", children: ["wall", "cpu", "object"].map((c3) => /* @__PURE__ */ u3(
+            "button",
+            {
+              class: `profiler-fn-profiling__mode-btn${clock === c3 ? " profiler-fn-profiling__mode-btn--active" : ""}`,
+              onClick: () => clock !== c3 && onClockChange(c3),
+              disabled: clockUpdating,
+              title: c3 === "wall" ? "Wall-clock time (includes I/O waits)" : c3 === "cpu" ? "CPU time only (excludes I/O waits)" : "Object allocations per function",
+              children: c3 === "wall" ? "Wall" : c3 === "cpu" ? "CPU" : "Alloc"
+            },
+            c3
+          )) }),
           /* @__PURE__ */ u3("label", { class: "profiler-fn-profiling__max-frames-label", children: [
             "Max frames",
             /* @__PURE__ */ u3(
@@ -2853,7 +2924,15 @@
           )
         ] })
       ] }),
-      !enabled && /* @__PURE__ */ u3("p", { class: "profiler-fn-profiling__hint", children: "Enable function profiling to automatically track execution time and memory allocation for every method call in your app/ directory (using Ruby TracePoint). Warning: significant overhead \u2014 for development use only." }),
+      !enabled && /* @__PURE__ */ u3("p", { class: "profiler-fn-profiling__hint", children: [
+        "Enable function profiling to see where your app spends time.",
+        " ",
+        /* @__PURE__ */ u3("strong", { children: "Lite" }),
+        ": statistical sampling via stackprof \u2014 very low overhead (<1%), enabled by default.",
+        " ",
+        /* @__PURE__ */ u3("strong", { children: "Full" }),
+        ": exhaustive TracePoint tracing with memory bytes \u2014 significant overhead."
+      ] }),
       enabled && !hasData && /* @__PURE__ */ u3("p", { class: "profiler-fn-profiling__hint", children: "Function profiling is active. Data will appear on the next request." }),
       hasData && /* @__PURE__ */ u3(k, { children: [
         data.frame_cap_reached && /* @__PURE__ */ u3("div", { class: "profiler-fn-profiling__cap-warning", children: [
@@ -2867,18 +2946,54 @@
             /* @__PURE__ */ u3("span", { class: "stat-value", children: data.functions.length })
           ] }),
           /* @__PURE__ */ u3("div", { class: "stat-item", children: [
-            /* @__PURE__ */ u3("span", { class: "stat-label", children: "Total Calls" }),
+            /* @__PURE__ */ u3("span", { class: "stat-label", children: isSampling ? "Total Samples" : "Total Calls" }),
             /* @__PURE__ */ u3("span", { class: "stat-value", children: data.total_calls })
           ] }),
-          /* @__PURE__ */ u3("div", { class: "stat-item", children: [
-            /* @__PURE__ */ u3("span", { class: "stat-label", children: "Total Duration" }),
+          !isObjectClock && /* @__PURE__ */ u3("div", { class: "stat-item", children: [
+            /* @__PURE__ */ u3("span", { class: "stat-label", children: "Wall" }),
             /* @__PURE__ */ u3("span", { class: "stat-value", children: [
-              data.total_duration?.toFixed(2),
+              (data.elapsed_wall_ms ?? data.total_duration ?? 0).toFixed(2),
               " ",
               /* @__PURE__ */ u3("small", { children: "ms" })
             ] })
           ] }),
-          /* @__PURE__ */ u3("div", { class: "stat-item", children: [
+          isSampling && !isObjectClock && data.elapsed_cpu_ms != null && /* @__PURE__ */ u3("div", { class: "stat-item", children: [
+            /* @__PURE__ */ u3(
+              "span",
+              {
+                class: "stat-label",
+                title: "CPU time excludes I/O waits (DB, network, sleep). Low CPU% = I/O-bound.",
+                children: "CPU"
+              }
+            ),
+            /* @__PURE__ */ u3("span", { class: "stat-value", children: [
+              data.elapsed_cpu_ms.toFixed(2),
+              " ",
+              /* @__PURE__ */ u3("small", { children: "ms" }),
+              data.elapsed_wall_ms != null && data.elapsed_wall_ms > 0 && /* @__PURE__ */ u3("small", { class: "profiler-fn-profiling__cpu-pct", children: [
+                " ",
+                "(",
+                Math.round(data.elapsed_cpu_ms / data.elapsed_wall_ms * 100),
+                "%)"
+              ] })
+            ] })
+          ] }),
+          isObjectClock && /* @__PURE__ */ u3("div", { class: "stat-item", children: [
+            /* @__PURE__ */ u3("span", { class: "stat-label", children: "Allocations" }),
+            /* @__PURE__ */ u3("span", { class: "stat-value", children: [
+              data.total_duration?.toLocaleString(),
+              " ",
+              /* @__PURE__ */ u3("small", { children: "obj" })
+            ] })
+          ] }),
+          isSampling && (data.gc_overhead_pct ?? 0) > 0 && /* @__PURE__ */ u3("div", { class: "stat-item", children: [
+            /* @__PURE__ */ u3("span", { class: "stat-label", title: `${data.gc_samples} samples during GC`, children: "GC" }),
+            /* @__PURE__ */ u3("span", { class: `stat-value${(data.gc_overhead_pct ?? 0) >= 20 ? " profiler-fn-profiling__gc--high" : (data.gc_overhead_pct ?? 0) >= 5 ? " profiler-fn-profiling__gc--medium" : ""}`, children: [
+              data.gc_overhead_pct,
+              "%"
+            ] })
+          ] }),
+          showAllocated && /* @__PURE__ */ u3("div", { class: "stat-item", children: [
             /* @__PURE__ */ u3("span", { class: "stat-label", children: "Allocated" }),
             /* @__PURE__ */ u3("span", { class: "stat-value", children: [
               data.total_allocated_objects?.toLocaleString(),
@@ -2886,7 +3001,7 @@
               /* @__PURE__ */ u3("small", { children: "obj" })
             ] })
           ] }),
-          /* @__PURE__ */ u3("div", { class: "stat-item", children: [
+          showMemory && /* @__PURE__ */ u3("div", { class: "stat-item", children: [
             /* @__PURE__ */ u3("span", { class: "stat-label", children: "Memory" }),
             /* @__PURE__ */ u3("span", { class: "stat-value", children: formatBytes3(data.total_memory_bytes ?? 0) })
           ] })
@@ -2918,23 +3033,26 @@
           /* @__PURE__ */ u3("thead", { children: /* @__PURE__ */ u3("tr", { children: [
             /* @__PURE__ */ u3("th", { children: "Function" }),
             /* @__PURE__ */ u3("th", { children: "File" }),
-            /* @__PURE__ */ u3("th", { class: `profiler-text--right sortable${sortKey === "calls" ? " sortable--active" : ""}`, onClick: () => handleColClick("calls"), children: [
-              "Calls ",
+            /* @__PURE__ */ u3("th", { class: `profiler-text--right sortable${effectiveSortKey === "calls" ? " sortable--active" : ""}`, onClick: () => handleColClick("calls"), children: [
+              isSampling ? "Samples" : "Calls",
+              " ",
               sortIcon("calls")
             ] }),
-            /* @__PURE__ */ u3("th", { class: `profiler-text--right sortable${sortKey === "total_duration" ? " sortable--active" : ""}`, onClick: () => handleColClick("total_duration"), children: [
-              "Total Time ",
+            /* @__PURE__ */ u3("th", { class: `profiler-text--right sortable${effectiveSortKey === "total_duration" ? " sortable--active" : ""}`, onClick: () => handleColClick("total_duration"), children: [
+              isObjectClock ? "Total Alloc" : "Total Time",
+              " ",
               sortIcon("total_duration")
             ] }),
-            /* @__PURE__ */ u3("th", { class: `profiler-text--right sortable${sortKey === "self_duration" ? " sortable--active" : ""}`, onClick: () => handleColClick("self_duration"), children: [
-              "Self Time ",
+            /* @__PURE__ */ u3("th", { class: `profiler-text--right sortable${effectiveSortKey === "self_duration" ? " sortable--active" : ""}`, onClick: () => handleColClick("self_duration"), children: [
+              isObjectClock ? "Self Alloc" : "Self Time",
+              " ",
               sortIcon("self_duration")
             ] }),
-            /* @__PURE__ */ u3("th", { class: `profiler-text--right sortable${sortKey === "allocated_objects" ? " sortable--active" : ""}`, onClick: () => handleColClick("allocated_objects"), children: [
+            showAllocated && /* @__PURE__ */ u3("th", { class: `profiler-text--right sortable${effectiveSortKey === "allocated_objects" ? " sortable--active" : ""}`, onClick: () => handleColClick("allocated_objects"), children: [
               "Objects ",
               sortIcon("allocated_objects")
             ] }),
-            /* @__PURE__ */ u3("th", { class: `profiler-text--right sortable${sortKey === "memory_bytes" ? " sortable--active" : ""}`, onClick: () => handleColClick("memory_bytes"), children: [
+            showMemory && /* @__PURE__ */ u3("th", { class: `profiler-text--right sortable${effectiveSortKey === "memory_bytes" ? " sortable--active" : ""}`, onClick: () => handleColClick("memory_bytes"), children: [
               "Memory ",
               sortIcon("memory_bytes")
             ] })
@@ -2970,20 +3088,28 @@
                   fn.line
                 ] }),
                 /* @__PURE__ */ u3("td", { class: "profiler-text--right", children: fn.calls }),
-                /* @__PURE__ */ u3("td", { class: "profiler-text--right", children: /* @__PURE__ */ u3("span", { class: fn.total_duration >= 100 ? "badge-error" : fn.total_duration >= 10 ? "badge-warning" : "badge-success", children: [
+                /* @__PURE__ */ u3("td", { class: "profiler-text--right", children: isObjectClock ? /* @__PURE__ */ u3("span", { class: "profiler-text--muted", children: [
+                  fn.total_duration.toLocaleString(),
+                  " ",
+                  /* @__PURE__ */ u3("small", { children: "obj" })
+                ] }) : /* @__PURE__ */ u3("span", { class: fn.total_duration >= 100 ? "badge-error" : fn.total_duration >= 10 ? "badge-warning" : "badge-success", children: [
                   fn.total_duration.toFixed(2),
                   " ms"
                 ] }) }),
-                /* @__PURE__ */ u3("td", { class: "profiler-text--right", children: /* @__PURE__ */ u3("span", { class: fn.self_duration >= 50 ? "badge-error" : fn.self_duration >= 5 ? "badge-warning" : "badge-success", children: [
+                /* @__PURE__ */ u3("td", { class: "profiler-text--right", children: isObjectClock ? /* @__PURE__ */ u3("span", { class: "profiler-text--muted", children: [
+                  fn.self_duration.toLocaleString(),
+                  " ",
+                  /* @__PURE__ */ u3("small", { children: "obj" })
+                ] }) : /* @__PURE__ */ u3("span", { class: fn.self_duration >= 50 ? "badge-error" : fn.self_duration >= 5 ? "badge-warning" : "badge-success", children: [
                   fn.self_duration.toFixed(2),
                   " ms"
                 ] }) }),
-                /* @__PURE__ */ u3("td", { class: "profiler-text--right profiler-text--muted", children: [
+                showAllocated && /* @__PURE__ */ u3("td", { class: "profiler-text--right profiler-text--muted", children: [
                   fn.allocated_objects.toLocaleString(),
                   " ",
                   /* @__PURE__ */ u3("small", { children: "obj" })
                 ] }),
-                /* @__PURE__ */ u3("td", { class: "profiler-text--right profiler-text--muted", children: formatBytes3(fn.memory_bytes) })
+                showMemory && /* @__PURE__ */ u3("td", { class: "profiler-text--right profiler-text--muted", children: formatBytes3(fn.memory_bytes) })
               ]
             },
             i3

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

@@ -7,8 +7,10 @@ module Profiler
 
       def show
         render json: {
-          enabled: Profiler.function_profiling_enabled,
-          max_frames: Profiler.function_profiling_max_frames
+          enabled:    Profiler.function_profiling_enabled,
+          max_frames: Profiler.function_profiling_max_frames,
+          mode:       Profiler.function_profiling_mode,
+          clock:      Profiler.function_profiling_clock
         }
       end
 
@@ -22,9 +24,19 @@ module Profiler
           Profiler.function_profiling_max_frames = max.positive? ? max : Profiler.function_profiling_max_frames
         end
 
+        if params.key?(:mode) && %w[full lite].include?(params[:mode])
+          Profiler.function_profiling_mode = params[:mode]
+        end
+
+        if params.key?(:clock) && %w[wall cpu object].include?(params[:clock])
+          Profiler.function_profiling_clock = params[:clock]
+        end
+
         render json: {
-          enabled: Profiler.function_profiling_enabled,
-          max_frames: Profiler.function_profiling_max_frames
+          enabled:    Profiler.function_profiling_enabled,
+          max_frames: Profiler.function_profiling_max_frames,
+          mode:       Profiler.function_profiling_mode,
+          clock:      Profiler.function_profiling_clock
         }
       end
     end

data/lib/profiler/collectors/function_profiler_collector.rb

@@ -1,13 +1,20 @@
 # frozen_string_literal: true
 
 require_relative "base_collector"
-require "objspace"
+
+begin
+  require "stackprof"
+rescue LoadError
+  # stackprof not available — lite mode will fall back to TracePoint without memory tracking
+end
 
 module Profiler
   module Collectors
     class FunctionProfilerCollector < BaseCollector
       CallFrame = Struct.new(:name, :file, :line, :started_at, :alloc_before, :memsize_before, :recursive, :children)
 
+      GC_FRAME_NAME = "(garbage collection)"
+
       def name
         "function_profile"
       end
@@ -37,15 +44,227 @@ module Profiler
 
       def subscribe
         unless Profiler.function_profiling_enabled
-          store_data({ enabled: false, max_frames: Profiler.function_profiling_max_frames })
+          store_data({
+            enabled:    false,
+            max_frames: Profiler.function_profiling_max_frames,
+            mode:       Profiler.function_profiling_mode,
+            clock:      Profiler.function_profiling_clock
+          })
+          return
+        end
+
+        mode  = Profiler.function_profiling_mode
+        clock = Profiler.function_profiling_clock
+        Thread.current[:fn_profiler_mode]  = mode
+        Thread.current[:fn_profiler_clock] = clock
+
+        if mode == "lite" && defined?(StackProf)
+          # Always record wall + cpu at request level for the comparison stat
+          Thread.current[:fn_profiler_wall_start] = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          Thread.current[:fn_profiler_cpu_start]  = Process.clock_gettime(Process::CLOCK_PROCESS_CPUTIME_ID)
+
+          sp_mode = case clock
+                    when "cpu"    then :cpu
+                    when "object" then :object
+                    else               :wall
+                    end
+          StackProf.start(mode: sp_mode, interval: 1000, raw: true)
+        else
+          subscribe_tracepoint(mode)
+        end
+      end
+
+      def collect
+        mode  = Thread.current[:fn_profiler_mode]  || Profiler.function_profiling_mode
+        clock = Thread.current[:fn_profiler_clock] || Profiler.function_profiling_clock
+        Thread.current[:fn_profiler_mode]  = nil
+        Thread.current[:fn_profiler_clock] = nil
+
+        if mode == "lite" && defined?(StackProf)
+          StackProf.stop
+          result   = StackProf.results
+          wall_ms  = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - (Thread.current[:fn_profiler_wall_start] || 0)) * 1000
+          cpu_ms   = (Process.clock_gettime(Process::CLOCK_PROCESS_CPUTIME_ID) - (Thread.current[:fn_profiler_cpu_start] || 0)) * 1000
+          Thread.current[:fn_profiler_wall_start] = nil
+          Thread.current[:fn_profiler_cpu_start]  = nil
+          collect_stackprof(result, mode, clock, wall_ms, cpu_ms)
+        else
+          collect_tracepoint(mode)
+        end
+      end
+
+      def toolbar_summary
+        return { text: "off", color: "gray" } unless Profiler.function_profiling_enabled
+        case Profiler.function_profiling_mode
+        when "lite" then { text: "sampling on", color: "blue" }
+        else             { text: "fn profiling on", color: "purple" }
+        end
+      end
+
+      private
+
+      # ── StackProf (lite mode) ──────────────────────────────────────────────────
+
+      def collect_stackprof(result, mode, clock, wall_ms, cpu_ms)
+        unless result
+          store_data({ enabled: true, mode: mode, clock: clock, max_frames: 0,
+                       frame_cap_reached: false, total_calls: 0, total_duration: 0,
+                       functions: [], root_calls: [] })
           return
         end
 
-        app_root = app_root_path
+        frames_meta   = result[:frames] || {}
+        raw           = result[:raw]    || []
+        total_samples = [result[:samples] || 0, 1].max
+        elapsed_ms    = case clock
+                        when "object" then total_samples.to_f
+                        when "cpu"    then cpu_ms
+                        else               wall_ms
+                        end
+        app_root      = app_root_path
+
+        # Partition frames: app frames vs GC frame
+        # Exclude Ruby meta-frames (<main>, <class:Foo>, #<Class:0x...> generated templates) — noise
+        gc_frame_ids  = frames_meta.each_with_object(Set.new) { |(id, f), s| s << id if f[:name] == GC_FRAME_NAME }
+        app_frame_ids = frames_meta.each_with_object(Set.new) do |(id, f), s|
+          s << id if f[:file]&.start_with?(app_root) && !f[:name].to_s.match?(/\A[<#]/)
+        end
+
+        gc_samples, gc_overhead_pct = count_gc_samples(raw, gc_frame_ids, total_samples)
+
+        roots = build_sampling_tree(raw, frames_meta, app_frame_ids, total_samples, elapsed_ms)
+
+        functions = frames_meta.filter_map do |id, frame|
+          next unless app_frame_ids.include?(id)
+          next if frame[:name].to_s.match?(/\A[<#]/)
+          total_dur = (frame[:total_samples].to_f / total_samples) * elapsed_ms
+          self_dur  = (frame[:samples].to_f      / total_samples) * elapsed_ms
+          {
+            name:              frame[:name] || id.to_s,
+            file:              relative_path(frame[:file] || ""),
+            line:              frame[:line] || 0,
+            calls:             frame[:total_samples] || 0,
+            recursive_calls:   0,
+            total_duration:    total_dur.round(3),
+            self_duration:     self_dur.round(3),
+            allocated_objects: 0,
+            memory_bytes:      0,
+            self_memory_bytes: 0
+          }
+        end.sort_by { |f| -f[:total_duration] }
+
+        # For wall/cpu clocks, total_duration = stackprof elapsed (accurate).
+        # For object clock, total_duration = total allocations count.
+        total_duration = clock == "object" ? total_samples.to_f : elapsed_ms
+
+        store_data({
+          enabled:                 true,
+          mode:                    mode,
+          clock:                   clock,
+          elapsed_wall_ms:         wall_ms.round(2),
+          elapsed_cpu_ms:          cpu_ms.round(2),
+          gc_samples:              gc_samples,
+          gc_overhead_pct:         gc_overhead_pct,
+          max_frames:              total_samples,
+          frame_cap_reached:       false,
+          total_calls:             functions.sum { |f| f[:calls] },
+          total_duration:          total_duration.round(2),
+          total_allocated_objects: 0,
+          total_memory_bytes:      0,
+          functions:               functions,
+          root_calls:              roots.map { |n| serialize_node(n) }
+        })
+      end
+
+      # Count samples that contain at least one GC frame.
+      def count_gc_samples(raw, gc_frame_ids, total_samples)
+        return [0, 0.0] if gc_frame_ids.empty?
+
+        gc_count = 0
+        i = 0
+        while i < raw.length
+          depth = raw[i]
+          break if i + depth + 1 >= raw.length
+          stack = raw[i + 1, depth]
+          count = raw[i + depth + 1]
+          i += depth + 2
+          gc_count += count if stack.any? { |id| gc_frame_ids.include?(id) }
+        end
+
+        pct = (gc_count.to_f / total_samples * 100).round(1)
+        [gc_count, pct]
+      end
+
+      # Parse stackprof raw samples and build a call tree filtered to app/ frames.
+      #
+      # Raw format: [depth, frame[0]=outermost(caller), ..., frame[depth-1]=innermost(callee), count, ...]
+      # frames are already outermost-first, so no reversal needed.
+      def build_sampling_tree(raw, frames_meta, app_frame_ids, total_samples, elapsed_ms)
+        tree = {}
+
+        i = 0
+        while i < raw.length
+          depth = raw[i]
+          break if i + depth + 1 >= raw.length
+          stack = raw[i + 1, depth]
+          count = raw[i + depth + 1]
+          i += depth + 2
+
+          app_stack = stack.select { |id| app_frame_ids.include?(id) }
+          next if app_stack.empty?
+
+          current = tree
+          app_stack.each do |frame_id|
+            current[frame_id] ||= { samples: 0, children: {} }
+            current[frame_id][:samples] += count
+            current = current[frame_id][:children]
+          end
+        end
+
+        nodes_from_sampling_tree(tree, frames_meta, total_samples, elapsed_ms, 0.0)
+      end
+
+      def nodes_from_sampling_tree(tree_hash, frames_meta, total_samples, elapsed_ms, parent_offset)
+        nodes = []
+        cursor = parent_offset
+
+        tree_hash.each do |frame_id, node|
+          meta     = frames_meta[frame_id] || {}
+          duration = (node[:samples].to_f / total_samples) * elapsed_ms
+          children = nodes_from_sampling_tree(node[:children], frames_meta, total_samples, elapsed_ms, cursor)
+
+          nodes << {
+            name:        meta[:name] || frame_id.to_s,
+            started_at:  cursor / 1000.0,
+            finished_at: (cursor + duration) / 1000.0,
+            duration:    duration.round(3),
+            category:    "method",
+            payload: {
+              file:              relative_path(meta[:file] || ""),
+              line:              meta[:line] || 0,
+              allocated_objects: 0,
+              memory_bytes:      0,
+              recursive:         false,
+              samples:           node[:samples]
+            },
+            children: children
+          }
+          cursor += duration
+        end
+
+        nodes
+      end
+
+      # ── TracePoint (full mode) ────────────────────────────────────────────────
+
+      def subscribe_tracepoint(mode)
+        app_root   = app_root_path
         max_frames = Profiler.function_profiling_max_frames
+
         Thread.current[:fn_profiler_stack] = []
         Thread.current[:fn_profiler_roots] = []
         Thread.current[:fn_profiler_count] = 0
+        Thread.current[:fn_profiler_depth] = Hash.new(0)
 
         @trace = TracePoint.new(:call, :return) do |tp|
           next unless tp.path&.start_with?(app_root)
@@ -58,8 +277,9 @@ module Profiler
             count = (Thread.current[:fn_profiler_count] += 1)
             next if count > max_frames
 
-            fn_name = "#{tp.defined_class}##{tp.method_id}"
-            is_recursive = stack.any? { |f| f.name == fn_name }
+            fn_name      = "#{tp.defined_class}##{tp.method_id}"
+            depth_map    = Thread.current[:fn_profiler_depth]
+            is_recursive = (depth_map[fn_name] += 1) > 1
 
             stack.push(CallFrame.new(
               fn_name,
@@ -67,7 +287,7 @@ module Profiler
               tp.lineno,
               Process.clock_gettime(Process::CLOCK_MONOTONIC),
               GC.stat[:total_allocated_objects],
-              ObjectSpace.memsize_of_all,
+              GC.stat[:oldmalloc_increase_bytes],
               is_recursive,
               []
             ))
@@ -75,9 +295,10 @@ module Profiler
             frame = stack.pop
             next unless frame
 
-            finished_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            Thread.current[:fn_profiler_depth][frame.name] -= 1
+            finished_at  = Process.clock_gettime(Process::CLOCK_MONOTONIC)
             allocated    = GC.stat[:total_allocated_objects] - frame.alloc_before
-            memory_bytes = [ObjectSpace.memsize_of_all - frame.memsize_before, 0].max
+            memory_bytes = [GC.stat[:oldmalloc_increase_bytes] - frame.memsize_before, 0].max
             node = build_node(frame, finished_at, allocated, memory_bytes)
 
             if stack.empty?
@@ -91,22 +312,21 @@ module Profiler
         @trace.enable
       end
 
-      def collect
+      def collect_tracepoint(mode)
         @trace&.disable
         @trace = nil
 
-        stack  = Thread.current[:fn_profiler_stack]
-        roots  = Thread.current[:fn_profiler_roots] || []
-        count  = Thread.current[:fn_profiler_count] || 0
+        stack      = Thread.current[:fn_profiler_stack]
+        roots      = Thread.current[:fn_profiler_roots] || []
+        count      = Thread.current[:fn_profiler_count] || 0
         max_frames = Profiler.function_profiling_max_frames
 
-        # Flush any frames still on the stack (e.g. if an exception was raised)
         if stack&.any?
           finished_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
           until stack.empty?
             frame        = stack.pop
             allocated    = GC.stat[:total_allocated_objects] - frame.alloc_before
-            memory_bytes = [ObjectSpace.memsize_of_all - frame.memsize_before, 0].max
+            memory_bytes = [GC.stat[:oldmalloc_increase_bytes] - frame.memsize_before, 0].max
             node = build_node(frame, finished_at, allocated, memory_bytes)
             if stack.empty?
               roots << node
@@ -116,31 +336,38 @@ module Profiler
           end
         end
 
-        Thread.current[:fn_profiler_stack]  = nil
-        Thread.current[:fn_profiler_roots]  = nil
-        Thread.current[:fn_profiler_count]  = nil
+        Thread.current[:fn_profiler_stack] = nil
+        Thread.current[:fn_profiler_roots] = nil
+        Thread.current[:fn_profiler_count] = nil
+        Thread.current[:fn_profiler_depth] = nil
 
         stats = {}
         aggregate(roots, stats)
         sorted_functions = stats.values.sort_by { |s| -s[:total_duration] }
 
-        total_duration    = roots.sum { |n| n[:duration] }
-        total_allocated   = stats.values.sum { |s| s[:allocated_objects] }
-        total_memory      = stats.values.sum { |s| s[:memory_bytes] }
+        total_duration  = roots.sum { |n| n[:duration] }
+        total_allocated = stats.values.sum { |s| s[:allocated_objects] }
+        total_memory    = stats.values.sum { |s| s[:memory_bytes] }
 
         store_data({
-          enabled:           true,
-          max_frames:        max_frames,
-          frame_cap_reached: count >= max_frames,
-          total_calls:       stats.values.sum { |s| s[:calls] },
-          total_duration:    total_duration.round(2),
+          enabled:                 true,
+          mode:                    mode,
+          clock:                   "wall",
+          elapsed_wall_ms:         total_duration.round(2),
+          elapsed_cpu_ms:          nil,
+          gc_samples:              0,
+          gc_overhead_pct:         0.0,
+          max_frames:              max_frames,
+          frame_cap_reached:       count >= max_frames,
+          total_calls:             stats.values.sum { |s| s[:calls] },
+          total_duration:          total_duration.round(2),
           total_allocated_objects: total_allocated,
-          total_memory_bytes: total_memory,
+          total_memory_bytes:      total_memory,
           functions: sorted_functions.map do |s|
             s.merge(
-              total_duration:  s[:total_duration].round(3),
-              self_duration:   s[:self_duration].round(3),
-              memory_bytes:    s[:memory_bytes],
+              total_duration:    s[:total_duration].round(3),
+              self_duration:     s[:self_duration].round(3),
+              memory_bytes:      s[:memory_bytes],
               self_memory_bytes: s[:self_memory_bytes]
             )
           end,
@@ -148,12 +375,7 @@ module Profiler
         })
       end
 
-      def toolbar_summary
-        return { text: "off", color: "gray" } unless Profiler.function_profiling_enabled
-        { text: "fn profiling on", color: "purple" }
-      end
-
-      private
+      # ── Shared helpers ─────────────────────────────────────────────────────────
 
       def app_root_path
         if defined?(Rails) && Rails.respond_to?(:root) && Rails.root

data/lib/profiler/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Profiler
-  VERSION = "0.15.0"
+  VERSION = "0.16.0"
 end

data/lib/profiler.rb

@@ -10,6 +10,8 @@ module Profiler
     attr_writer :configuration
     attr_accessor :function_profiling_enabled
     attr_accessor :function_profiling_max_frames
+    attr_accessor :function_profiling_mode
+    attr_accessor :function_profiling_clock
 
     def configuration
       @configuration ||= Configuration.new
@@ -75,8 +77,10 @@ module Profiler
     end
   end
 
-  self.function_profiling_enabled = false
+  self.function_profiling_enabled = true
   self.function_profiling_max_frames = 2000
+  self.function_profiling_mode = "lite"
+  self.function_profiling_clock = "wall"
 end
 
 # Require core components

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-profiler
 version: !ruby/object:Gem::Version
-  version: 0.15.0
+  version: 0.16.0
 platform: ruby
 authors:
 - Sébastien Duplessy
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-11 00:00:00.000000000 Z
+date: 2026-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails