rails_memory_profiler 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 358d4a7e75c7fbdc553c28acc6350da8906ea834308410f32020168bc6e31985
-  data.tar.gz: 910ce5bc705376412f44904d6d3640ec4ad48aa5396f330dd45e8101ca77cb5c
+  metadata.gz: da1c19f27cafbf571c7f5fe0e724c56e305d81307c99c1d970fdc96777459888
+  data.tar.gz: d95173a0c57ec1afefc7a13eed43e06b5fef53a8350a3b5b2955f42ad01c382f
 SHA512:
-  metadata.gz: ae42d9f95d0e6b01b82be8359de89a4b95379dbbfa5acb66a8ee35a3579dd98870d95b9015ee1041a2a1e43c70978c066509cead89a96c70fd5b7da15dce9fa5
-  data.tar.gz: dab8d94f6fbd06e9d96844b1e3c1dc5d010b0aa5b6257cba15f6dbef6e8a4202fe2df0d2b3a763803509ec5d4c08443d60adb146f9f9a86ea977716db4ee1a7e
+  metadata.gz: c34cfa6505349cae21f6e808c55bd8c682456809ac3052ed2d67ed72099ec72f4cfd890653c36cf580d15f92c9988b1a94ce95dfa679c1cda1fb4f2fefa51747
+  data.tar.gz: e5e1c2f7194e48d82b0073aed382662f95ffb552e119993a25dd62a58285f5a89e31e600664928a7bcd515696a5abebc2f02d32d9a49df5a5124d7c38c5165b6

data/README.md

@@ -76,6 +76,11 @@ All options and their defaults:
 | `min_allocated_objects` | `0` | Skip requests that allocate fewer objects than this |
 | `ignore_paths` | `[]` | Paths to skip — strings (prefix) or regexes |
 | `ignore_controllers` | `[]` | Controller names to skip (e.g. `"rails/health"`) |
+| `detailed_reports` | `false` | Capture full `MemoryProfiler.report` breakdowns; requires `gem "memory_profiler"` in your Gemfile |
+| `detailed_sample_rate` | `10` | When `detailed_reports` is enabled, capture a full report every Nth profiled request |
+| `notifiers` | `[]` | Array of objects responding to `#call(report)`; called after each report is stored |
+| `log_file` | `nil` | Path to append JSON-serialized reports (one per line); shortcut for `Notifiers::FileLogger` |
+| `raise_on_allocation_spike` | `nil` | Raise `AllocationSpikeError` when `allocated_objects` exceeds this threshold |
 
 Example:
 
@@ -85,9 +90,26 @@ RailsMemoryProfiler.configure do |config|
   config.min_allocated_objects = 1_000
   config.ignore_paths          = ["/rails/memory", "/up"]
   config.ignore_controllers    = ["rails/health"]
+  config.notifiers             = [RailsMemoryProfiler::Notifiers::Console.new]
+  config.log_file              = Rails.root.join("log/memory_profiler.jsonl")
 end
 ```
 
+### Test helpers
+
+```ruby
+# Minitest / plain Ruby
+require "rails_memory_profiler/test_helper"
+
+count = RailsMemoryProfiler::TestHelper.capture_allocations { MyClass.new }
+RailsMemoryProfiler::TestHelper.assert_allocations_below(500) { MyClass.new }
+
+# RSpec
+require "rails_memory_profiler/rspec_matchers"
+
+expect { MyClass.new }.to allocate_fewer_than(500)
+```
+
 [↑ Back to top](#railsmemoryprofiler)
 
 ---

data/app/assets/stylesheets/rails_memory_profiler/_05_filters.css

@@ -1,8 +1,9 @@
 .rmp-filters {
   display: flex;
   align-items: center;
+  flex-wrap: wrap;
   gap: 0.75rem;
-  margin-bottom: 1rem;
+  margin-bottom: 0.75rem;
   padding: 0.6rem 1rem;
   background: var(--surface);
   border-radius: var(--radius);
@@ -55,4 +56,33 @@
   border-radius: 2px;
 }
 
-.rmp-input-clear:hover { color: var(--text); background: var(--border); }
+.rmp-input-clear:hover { color: var(--text); background: var(--border); }
+
+.rmp-select {
+  font-family: inherit;
+  font-size: 13px;
+  padding: 0.3rem 0.5rem;
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  background: var(--bg);
+  color: var(--text);
+}
+
+.rmp-select:focus {
+  outline: none;
+  border-color: #86b7fe;
+  box-shadow: 0 0 0 2px rgba(13,110,253,.15);
+}
+
+.rmp-btn-reset {
+  font-family: inherit;
+  font-size: 12px;
+  padding: 0.3rem 0.7rem;
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  background: var(--bg);
+  color: var(--muted);
+  cursor: pointer;
+}
+
+.rmp-btn-reset:hover { color: var(--text); background: var(--border); }

data/app/assets/stylesheets/rails_memory_profiler/_06_breakdowns.css

@@ -0,0 +1,40 @@
+.rmp-breakdowns {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(420px, 1fr));
+  gap: 1.5rem;
+  margin-top: 2rem;
+}
+
+.rmp-breakdown {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  overflow: hidden;
+}
+
+.rmp-breakdown-title {
+  font-size: 0.85rem;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  color: var(--muted);
+  padding: 0.75rem 1rem;
+  border-bottom: 1px solid var(--border);
+  margin: 0;
+}
+
+.rmp-breakdown .rmp-table {
+  margin: 0;
+  border: none;
+}
+
+.rmp-breakdown .rmp-table th,
+.rmp-breakdown .rmp-table td {
+  padding: 0.4rem 1rem;
+}
+
+.rmp-breakdown .rmp-table td:last-child {
+  text-align: right;
+  font-variant-numeric: tabular-nums;
+  color: var(--muted);
+}

data/app/assets/stylesheets/rails_memory_profiler/_07_compare.css

@@ -0,0 +1,46 @@
+.rmp-col-check { width: 2.5rem; text-align: center; }
+.rmp-checkbox   { cursor: pointer; accent-color: var(--accent); width: 15px; height: 15px; }
+
+.rmp-compare-bar {
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+  padding: 0.55rem 1rem;
+  margin-bottom: 0.75rem;
+  background: #eff6ff;
+  border: 1px solid #bfdbfe;
+  border-radius: var(--radius);
+}
+
+.rmp-compare-bar-hint { font-size: 13px; color: #1e40af; }
+
+.rmp-btn {
+  display: inline-block;
+  padding: 0.3rem 0.9rem;
+  font-size: 13px;
+  font-weight: 500;
+  border-radius: var(--radius);
+  background: var(--accent);
+  color: #fff;
+  text-decoration: none;
+}
+
+.rmp-btn:hover { background: #4338ca; }
+
+.rmp-compare { margin-top: 1.5rem; }
+
+.rmp-compare-table .rmp-compare-field {
+  font-weight: 600;
+  color: var(--muted);
+  font-size: 12px;
+  width: 14rem;
+}
+
+.rmp-compare-table .rmp-compare-delta {
+  font-variant-numeric: tabular-nums;
+  text-align: right;
+  width: 12rem;
+}
+
+.rmp-delta--worse  { color: #dc3545; font-weight: 600; }
+.rmp-delta--better { color: #198754; font-weight: 600; }

data/app/controllers/rails_memory_profiler/base_controller.rb

@@ -0,0 +1,15 @@
+module RailsMemoryProfiler
+  class BaseController < ActionController::Base
+    protect_from_forgery with: :null_session
+    layout "rails_memory_profiler/application"
+    helper RailsMemoryProfiler::ApplicationHelper
+
+    before_action :check_dashboard_enabled
+
+    private
+
+      def check_dashboard_enabled
+        head :forbidden unless RailsMemoryProfiler.config.dashboard_enabled
+      end
+  end
+end

data/app/controllers/rails_memory_profiler/comparisons_controller.rb

@@ -0,0 +1,20 @@
+module RailsMemoryProfiler
+  class ComparisonsController < BaseController
+    def show
+      ids     = Array(params[:ids]).first(2)
+      reports = ids.map { |id| ReportStore.find(id) }.compact
+
+      if reports.size < 2
+        redirect_to reports_path
+        return
+      end
+
+      @left, @right = reports
+
+      respond_to do |format|
+        format.html
+        format.json { render json: { left: @left, right: @right } }
+      end
+    end
+  end
+end

data/app/controllers/rails_memory_profiler/reports_controller.rb

@@ -1,11 +1,5 @@
 module RailsMemoryProfiler
-  class ReportsController < ActionController::Base
-    protect_from_forgery with: :null_session
-    layout "rails_memory_profiler/application"
-    helper RailsMemoryProfiler::ApplicationHelper
-
-    before_action :check_dashboard_enabled
-
+  class ReportsController < BaseController
     SORTABLE_COLUMNS = %w[path controller allocated_objects retained_objects duration_ms recorded_at].freeze
 
     def index
@@ -42,9 +36,5 @@ module RailsMemoryProfiler
         sorted = reports.sort_by { |r| r[sort.to_sym] || 0 }
         direction == "asc" ? sorted : sorted.reverse
       end
-
-      def check_dashboard_enabled
-        head :forbidden unless RailsMemoryProfiler.config.dashboard_enabled
-      end
   end
 end

data/app/javascript/rails_memory_profiler/application.js

@@ -1,6 +1,2 @@
 import "@hotwired/turbo"
-import { Application } from "@hotwired/stimulus"
-import FilterController from "rails_memory_profiler/filter_controller"
-
-const application = Application.start()
-application.register("filter", FilterController)
+import "rails_memory_profiler/controllers"

data/app/javascript/rails_memory_profiler/controllers/application.js

@@ -0,0 +1,4 @@
+import { Application } from "@hotwired/stimulus"
+
+const application = Application.start()
+export { application }

data/app/javascript/rails_memory_profiler/controllers/compare_controller.js

@@ -0,0 +1,27 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["checkbox", "bar", "link"]
+  static values  = { path: String }
+
+  toggle(event) {
+    const checked = this.checkboxTargets.filter(cb => cb.checked)
+    if (checked.length > 2) {
+      const oldest = checked.find(cb => cb !== event.target)
+      if (oldest) oldest.checked = false
+    }
+    this._update()
+  }
+
+  _update() {
+    const checked = this.checkboxTargets.filter(cb => cb.checked)
+    const ready   = checked.length === 2
+
+    this.barTarget.hidden = !ready
+
+    if (ready) {
+      const query = checked.map(cb => `ids[]=${encodeURIComponent(cb.value)}`).join("&")
+      this.linkTarget.href = `${this.pathValue}?${query}`
+    }
+  }
+}

data/app/javascript/rails_memory_profiler/controllers/filter_controller.js

@@ -0,0 +1,50 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["controllerInput", "controllerClear", "actionInput", "actionClear",
+                    "methodSelect", "row", "clearButton"]
+
+  connect() {
+    this._updateClear()
+  }
+
+  filter() {
+    const controller = this.controllerInputTarget.value.toLowerCase()
+    const action     = this.actionInputTarget.value.toLowerCase()
+    const method     = this.methodSelectTarget.value
+
+    this.rowTargets.forEach(row => {
+      const matchController = !controller || (row.dataset.controllerName || "").toLowerCase().includes(controller)
+      const matchAction     = !action     || (row.dataset.actionName     || "").toLowerCase().includes(action)
+      const matchMethod     = !method     || (row.dataset.httpMethod     || "") === method
+      row.hidden = !(matchController && matchAction && matchMethod)
+    })
+    this._updateClear()
+  }
+
+  clearField({ params: { field } }) {
+    this[`${field}InputTarget`].value = ""
+    this.filter()
+  }
+
+  clear() {
+    this.controllerInputTarget.value = ""
+    this.actionInputTarget.value     = ""
+    this.methodSelectTarget.value    = ""
+    this.rowTargets.forEach(row => { row.hidden = false })
+    this._updateClear()
+  }
+
+  _updateClear() {
+    if (this.hasControllerClearTarget)
+      this.controllerClearTarget.hidden = this.controllerInputTarget.value.length === 0
+    if (this.hasActionClearTarget)
+      this.actionClearTarget.hidden = this.actionInputTarget.value.length === 0
+    if (this.hasClearButtonTarget) {
+      const active = this.controllerInputTarget.value.length > 0 ||
+                     this.actionInputTarget.value.length     > 0 ||
+                     this.methodSelectTarget.value.length    > 0
+      this.clearButtonTarget.hidden = !active
+    }
+  }
+}

data/app/javascript/rails_memory_profiler/controllers/index.js

@@ -0,0 +1,6 @@
+import { application } from "rails_memory_profiler/controllers/application"
+import FilterController  from "rails_memory_profiler/controllers/filter_controller"
+import CompareController from "rails_memory_profiler/controllers/compare_controller"
+
+application.register("filter",  FilterController)
+application.register("compare", CompareController)

data/app/views/rails_memory_profiler/comparisons/show.html.erb

@@ -0,0 +1,75 @@
+<%= link_to "← All Requests", reports_path, class: "rmp-back" %>
+
+<div class="rmp-header">
+  <h1>Request Comparison</h1>
+  <p>
+    <%= link_to @left[:path], report_path(@left[:id]), class: "rmp-path" %>
+    &nbsp;vs&nbsp;
+    <%= link_to @right[:path], report_path(@right[:id]), class: "rmp-path" %>
+  </p>
+</div>
+
+<div class="rmp-compare">
+  <table class="rmp-table rmp-compare-table">
+    <thead>
+      <tr>
+        <th class="rmp-compare-field">Field</th>
+        <th>
+          <%= link_to @left[:path], report_path(@left[:id]) %>
+          <br><span class="rmp-muted"><%= [@left[:controller], @left[:action]].compact.join("#") %></span>
+        </th>
+        <th>
+          <%= link_to @right[:path], report_path(@right[:id]) %>
+          <br><span class="rmp-muted"><%= [@right[:controller], @right[:action]].compact.join("#") %></span>
+        </th>
+        <th class="rmp-compare-delta">Delta (B − A)</th>
+      </tr>
+    </thead>
+    <tbody>
+      <tr>
+        <td class="rmp-compare-field">HTTP Method</td>
+        <td><%= @left[:method] %></td>
+        <td><%= @right[:method] %></td>
+        <td class="rmp-muted">—</td>
+      </tr>
+      <tr>
+        <td class="rmp-compare-field">Recorded At</td>
+        <td><%= @left[:recorded_at]&.strftime("%Y-%m-%d %H:%M:%S") %></td>
+        <td><%= @right[:recorded_at]&.strftime("%Y-%m-%d %H:%M:%S") %></td>
+        <td class="rmp-muted">—</td>
+      </tr>
+      <%
+        numeric_rows = [
+          ["Allocated Objects", :allocated_objects],
+          ["Retained Objects",  :retained_objects],
+          ["Duration (ms)",     :duration_ms],
+        ]
+      %>
+      <% numeric_rows.each do |label, key| %>
+        <%
+          lv    = @left[key]  || 0
+          rv    = @right[key] || 0
+          delta = rv - lv
+          delta_class = if delta > 0 then "rmp-delta--worse"
+                        elsif delta < 0 then "rmp-delta--better"
+                        else nil end
+          delta_str = if delta > 0 then "+#{number_with_delimiter(delta.round(2))}"
+                      elsif delta < 0 then number_with_delimiter(delta.round(2)).to_s
+                      else "—" end
+        %>
+        <tr>
+          <td class="rmp-compare-field"><%= label %></td>
+          <td><%= number_with_delimiter(lv.is_a?(Float) ? lv : lv) %></td>
+          <td><%= number_with_delimiter(rv.is_a?(Float) ? rv : rv) %></td>
+          <td class="<%= delta_class %>"><%= delta_str %></td>
+        </tr>
+      <% end %>
+      <tr>
+        <td class="rmp-compare-field">Detailed Report</td>
+        <td><%= @left[:detail] ? "Yes" : "No" %></td>
+        <td><%= @right[:detail] ? "Yes" : "No" %></td>
+        <td class="rmp-muted">—</td>
+      </tr>
+    </tbody>
+  </table>
+</div>

data/app/views/rails_memory_profiler/reports/index.html.erb

@@ -3,54 +3,109 @@
   <p><%= @reports.size %> request<%= "s" unless @reports.size == 1 %> captured</p>
 </div>
 
-<div class="rmp-filters" data-controller="filter">
-  <label for="rmp-controller-filter">Controller</label>
-  <div class="rmp-input-wrapper">
-    <input id="rmp-controller-filter"
-           type="text"
-           class="rmp-input"
-           placeholder="e.g. posts"
-           data-filter-target="input"
-           data-action="input->filter#filter">
+<div data-controller="filter compare" data-compare-path-value="<%= comparison_path %>">
+  <div class="rmp-filters">
+    <label for="rmp-controller-filter">Controller</label>
+    <div class="rmp-input-wrapper">
+      <input id="rmp-controller-filter"
+             type="text"
+             class="rmp-input"
+             placeholder="e.g. posts"
+             data-filter-target="controllerInput"
+             data-action="input->filter#filter">
+      <button type="button"
+              class="rmp-input-clear"
+              aria-label="Clear controller filter"
+              hidden
+              data-filter-target="controllerClear"
+              data-action="click->filter#clearField"
+              data-filter-field-param="controller">✕</button>
+    </div>
+
+    <label for="rmp-action-filter">Action</label>
+    <div class="rmp-input-wrapper">
+      <input id="rmp-action-filter"
+             type="text"
+             class="rmp-input"
+             placeholder="e.g. index"
+             data-filter-target="actionInput"
+             data-action="input->filter#filter">
+      <button type="button"
+              class="rmp-input-clear"
+              aria-label="Clear action filter"
+              hidden
+              data-filter-target="actionClear"
+              data-action="click->filter#clearField"
+              data-filter-field-param="action">✕</button>
+    </div>
+
+    <label for="rmp-method-filter">Method</label>
+    <select id="rmp-method-filter"
+            class="rmp-select"
+            data-filter-target="methodSelect"
+            data-action="change->filter#filter">
+      <option value="">All</option>
+      <option value="GET">GET</option>
+      <option value="POST">POST</option>
+      <option value="PATCH">PATCH</option>
+      <option value="PUT">PUT</option>
+      <option value="DELETE">DELETE</option>
+    </select>
+
     <button type="button"
-            class="rmp-input-clear"
-            aria-label="Clear filter"
+            class="rmp-btn-reset"
             hidden
             data-filter-target="clearButton"
-            data-action="click->filter#clear">✕</button>
+            data-action="click->filter#clear">Reset</button>
+
+    <% unless @reports.empty? %>
+      <span class="rmp-muted">Filtering is client-side — no page reload needed.</span>
+    <% end %>
+  </div>
+
+  <div class="rmp-compare-bar" hidden data-compare-target="bar">
+    <span class="rmp-compare-bar-hint">2 requests selected</span>
+    <a href="#" class="rmp-btn" data-compare-target="link">Compare →</a>
   </div>
 
   <% if @reports.empty? %>
+    <p class="rmp-empty">No requests recorded yet. Browse your app and refresh.</p>
   <% else %>
-    <span class="rmp-muted">Filtering is client-side — no page reload needed.</span>
-  <% end %>
-</div>
-
-<% if @reports.empty? %>
-  <p class="rmp-empty">No requests recorded yet. Browse your app and refresh.</p>
-<% else %>
-  <table class="rmp-table">
-    <thead>
-      <tr>
-        <%= sort_th("Path", "path", @sort, @direction) %>
-        <%= sort_th("Controller#Action", "controller", @sort, @direction) %>
-        <%= sort_th("Allocated", "allocated_objects", @sort, @direction) %>
-        <%= sort_th("Retained", "retained_objects", @sort, @direction) %>
-        <%= sort_th("Duration (ms)", "duration_ms", @sort, @direction) %>
-        <%= sort_th("Recorded", "recorded_at", @sort, @direction) %>
-      </tr>
-    </thead>
-    <tbody>
-      <% @reports.each do |report| %>
-        <tr data-filter-target="row" data-controller-name="<%= report[:controller] %>">
-          <td><%= link_to report[:path], report_path(report[:id]), class: "rmp-path" %></td>
-          <td><%= [report[:controller], report[:action]].compact.join("#") %></td>
-          <td><%= allocation_badge(report[:allocated_objects]) %></td>
-          <td class="rmp-muted"><%= number_with_delimiter(report[:retained_objects]) %></td>
-          <td class="rmp-muted"><%= report[:duration_ms] %></td>
-          <td class="rmp-muted"><%= report[:recorded_at]&.strftime("%H:%M:%S") %></td>
+    <table class="rmp-table">
+      <thead>
+        <tr>
+          <th class="rmp-col-check"></th>
+          <%= sort_th("Path", "path", @sort, @direction) %>
+          <%= sort_th("Controller#Action", "controller", @sort, @direction) %>
+          <%= sort_th("Allocated", "allocated_objects", @sort, @direction) %>
+          <%= sort_th("Retained", "retained_objects", @sort, @direction) %>
+          <%= sort_th("Duration (ms)", "duration_ms", @sort, @direction) %>
+          <%= sort_th("Recorded", "recorded_at", @sort, @direction) %>
         </tr>
-      <% end %>
-    </tbody>
-  </table>
-<% end %>
+      </thead>
+      <tbody>
+        <% @reports.each do |report| %>
+          <tr data-filter-target="row"
+              data-controller-name="<%= report[:controller] %>"
+              data-action-name="<%= report[:action] %>"
+              data-http-method="<%= report[:method] %>">
+            <td class="rmp-col-check">
+              <input type="checkbox"
+                     class="rmp-checkbox"
+                     value="<%= report[:id] %>"
+                     aria-label="Select for comparison"
+                     data-compare-target="checkbox"
+                     data-action="change->compare#toggle">
+            </td>
+            <td><%= link_to report[:path], report_path(report[:id]), class: "rmp-path" %></td>
+            <td><%= [report[:controller], report[:action]].compact.join("#") %></td>
+            <td><%= allocation_badge(report[:allocated_objects]) %></td>
+            <td class="rmp-muted"><%= number_with_delimiter(report[:retained_objects]) %></td>
+            <td class="rmp-muted"><%= report[:duration_ms] %></td>
+            <td class="rmp-muted"><%= report[:recorded_at]&.strftime("%H:%M:%S") %></td>
+          </tr>
+        <% end %>
+      </tbody>
+    </table>
+  <% end %>
+</div>

data/app/views/rails_memory_profiler/reports/show.html.erb

@@ -30,6 +30,40 @@
       </div>
     </div>
   </div>
+
+  <% if (detail = @report[:detail]) %>
+    <div class="rmp-breakdowns">
+      <% [
+        ["Allocated by Gem",      detail[:allocated_by_gem]],
+        ["Allocated by Class",    detail[:allocated_by_class]],
+        ["Allocated by File",     detail[:allocated_by_file]],
+        ["Allocated by Location", detail[:allocated_by_location]],
+        ["Retained by Gem",       detail[:retained_by_gem]],
+        ["Retained by Class",     detail[:retained_by_class]],
+      ].each do |title, stats| %>
+        <% next if stats.blank? %>
+        <div class="rmp-breakdown">
+          <h2 class="rmp-breakdown-title"><%= title %></h2>
+          <table class="rmp-table">
+            <thead>
+              <tr>
+                <th>Name</th>
+                <th>Count</th>
+              </tr>
+            </thead>
+            <tbody>
+              <% stats.first(20).each do |stat| %>
+                <tr>
+                  <td><%= stat[:name] %></td>
+                  <td><%= number_with_delimiter(stat[:count]) %></td>
+                </tr>
+              <% end %>
+            </tbody>
+          </table>
+        </div>
+      <% end %>
+    </div>
+  <% end %>
 <% else %>
   <p class="rmp-empty">Report not found — it may have been evicted from the store.</p>
 <% end %>

data/config/importmap.rb

@@ -1,4 +1,7 @@
 pin "@hotwired/turbo", to: "https://cdn.jsdelivr.net/npm/@hotwired/turbo@8.0.23/dist/turbo.es2017-esm.js"
 pin "@hotwired/stimulus", to: "https://cdn.jsdelivr.net/npm/@hotwired/stimulus@3.2.2/dist/stimulus.js"
-pin "rails_memory_profiler", to: "rails_memory_profiler/application.js"
-pin "rails_memory_profiler/filter_controller", to: "rails_memory_profiler/filter_controller.js"
+pin "rails_memory_profiler",                                to: "rails_memory_profiler/application.js"
+pin "rails_memory_profiler/controllers",                    to: "rails_memory_profiler/controllers/index.js"
+pin "rails_memory_profiler/controllers/application",        to: "rails_memory_profiler/controllers/application.js"
+pin "rails_memory_profiler/controllers/filter_controller",  to: "rails_memory_profiler/controllers/filter_controller.js"
+pin "rails_memory_profiler/controllers/compare_controller", to: "rails_memory_profiler/controllers/compare_controller.js"

data/config/routes.rb

@@ -1,3 +1,4 @@
 RailsMemoryProfiler::Engine.routes.draw do
   resources :reports, only: [:index, :show]
+  resource  :comparison, only: [:show]
 end

data/lib/generators/rails_memory_profiler/install/templates/initializer.rb

@@ -25,4 +25,25 @@ RailsMemoryProfiler.configure do |config|
 
   # Controllers to skip — matched against the Rails controller name.
   # config.ignore_controllers = ["rails/health", "rails_memory_profiler/reports"]
+
+  # Capture full MemoryProfiler.report breakdowns (by gem, class, file, location).
+  # Requires `gem "memory_profiler"` in your Gemfile. Has significant overhead — use with sampling.
+  # config.detailed_reports = false
+
+  # When detailed_reports is enabled, capture a full report every Nth profiled request.
+  # config.detailed_sample_rate = 10
+
+  # Notifiers — called after each report is stored. Each must respond to #call(report).
+  # Built-in options:
+  #   RailsMemoryProfiler::Notifiers::Logger.new   — writes to Rails.logger
+  #   RailsMemoryProfiler::Notifiers::Stdout.new   — writes to $stdout
+  #   RailsMemoryProfiler::Notifiers::Console.new  — colorized terminal output
+  # config.notifiers = [RailsMemoryProfiler::Notifiers::Logger.new]
+
+  # Append JSON-serialized reports to a file (one report per line).
+  # config.log_file = Rails.root.join("log/memory_profiler.log").to_s
+
+  # Raise AllocationSpikeError when a request exceeds this many allocated objects.
+  # Useful in test environments to catch unexpected memory spikes.
+  # config.raise_on_allocation_spike = nil
 end

data/lib/rails_memory_profiler/configuration.rb

@@ -1,7 +1,10 @@
 module RailsMemoryProfiler
   class Configuration
     attr_accessor :enabled, :sample_rate, :store_size, :dashboard_enabled,
-                  :min_allocated_objects, :ignore_paths, :ignore_controllers
+                  :min_allocated_objects, :ignore_paths, :ignore_controllers,
+                  :detailed_reports, :detailed_sample_rate,
+                  :raise_on_allocation_spike,
+                  :notifiers, :log_file
 
     def initialize
       @enabled               = Rails.env.development?
@@ -11,6 +14,11 @@ module RailsMemoryProfiler
       @min_allocated_objects = 0
       @ignore_paths          = []
       @ignore_controllers    = []
+      @detailed_reports          = false
+      @detailed_sample_rate      = 10
+      @raise_on_allocation_spike = nil
+      @notifiers                 = []
+      @log_file                  = nil
     end
   end
 end

data/lib/rails_memory_profiler/middleware.rb

@@ -1,9 +1,10 @@
 module RailsMemoryProfiler
   class Middleware
     def initialize(app)
-      @app           = app
-      @request_count = 0
-      @mutex         = Mutex.new
+      @app            = app
+      @request_count  = 0
+      @detailed_count = 0
+      @mutex          = Mutex.new
     end
 
     def call(env)
@@ -17,40 +18,110 @@ module RailsMemoryProfiler
     private
 
       def profile(env)
-        start          = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        before_alloc   = GC.stat[:total_allocated_objects]
-        before_freed   = GC.stat[:total_freed_objects]
+        config = RailsMemoryProfiler.config
+        if config.detailed_reports && detailed_sample?
+          profile_detailed(env)
+        else
+          profile_basic(env)
+        end
+      end
+
+      def profile_basic(env)
+        start        = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        before_alloc = GC.stat[:total_allocated_objects]
+        before_freed = GC.stat[:total_freed_objects]
 
         status, headers, body = @app.call(env)
 
-        after_alloc  = GC.stat[:total_allocated_objects]
-        after_freed  = GC.stat[:total_freed_objects]
-        duration_ms  = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).round(2)
+        after_alloc = GC.stat[:total_allocated_objects]
+        after_freed = GC.stat[:total_freed_objects]
+        duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).round(2)
 
         allocated_objects = after_alloc - before_alloc
         retained_objects  = (after_alloc - after_freed) - (before_alloc - before_freed)
 
-        if allocated_objects >= RailsMemoryProfiler.config.min_allocated_objects
-          params     = env["action_dispatch.request.path_parameters"] || {}
-          controller = params[:controller]
-
-          unless ignored_controller?(controller)
-            ReportStore.push(
-              controller: controller,
-              action: params[:action],
-              path: env["PATH_INFO"],
-              method: env["REQUEST_METHOD"],
-              duration_ms: duration_ms,
-              allocated_objects: allocated_objects,
-              retained_objects: [retained_objects, 0].max,
-              recorded_at: Time.current
-            )
-          end
-        end
+        push_report(env, duration_ms, allocated_objects, retained_objects)
 
         [status, headers, body]
       end
 
+      def profile_detailed(env)
+        require_memory_profiler!
+
+        start  = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        result = nil
+
+        memory_report = MemoryProfiler.report { result = @app.call(env) }
+
+        duration_ms       = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).round(2)
+        allocated_objects = memory_report.total_allocated
+        retained_objects  = memory_report.total_retained
+
+        detail = {
+          allocated_by_gem:      serialize_stats(memory_report.allocated_objects_by_gem),
+          allocated_by_file:     serialize_stats(memory_report.allocated_objects_by_file),
+          allocated_by_class:    serialize_stats(memory_report.allocated_objects_by_class),
+          allocated_by_location: serialize_stats(memory_report.allocated_objects_by_location),
+          retained_by_gem:       serialize_stats(memory_report.retained_objects_by_gem),
+          retained_by_file:      serialize_stats(memory_report.retained_objects_by_file),
+          retained_by_class:     serialize_stats(memory_report.retained_objects_by_class),
+          retained_by_location:  serialize_stats(memory_report.retained_objects_by_location)
+        }
+
+        push_report(env, duration_ms, allocated_objects, retained_objects, detail)
+
+        result
+      end
+
+      def push_report(env, duration_ms, allocated_objects, retained_objects, detail = nil)
+        return if allocated_objects < RailsMemoryProfiler.config.min_allocated_objects
+
+        params     = env["action_dispatch.request.path_parameters"] || {}
+        controller = params[:controller]
+        return if ignored_controller?(controller)
+
+        payload = {
+          controller: controller,
+          action: params[:action],
+          path: env["PATH_INFO"],
+          method: env["REQUEST_METHOD"],
+          duration_ms: duration_ms,
+          allocated_objects: allocated_objects,
+          retained_objects: [retained_objects, 0].max,
+          recorded_at: Time.current
+        }
+        payload[:detail] = detail if detail
+
+        ReportStore.push(payload)
+        notify!(payload)
+        check_spike!(allocated_objects, env)
+      end
+
+      def notify!(report)
+        RailsMemoryProfiler.config.notifiers.each { |n| n.call(report) }
+        if (path = RailsMemoryProfiler.config.log_file)
+          Notifiers::FileLogger.new(path).call(report)
+        end
+      end
+
+      def check_spike!(allocated_objects, env)
+        threshold = RailsMemoryProfiler.config.raise_on_allocation_spike
+        return unless threshold && allocated_objects > threshold
+
+        raise AllocationSpikeError,
+          "#{env['PATH_INFO']} allocated #{allocated_objects} objects (threshold: #{threshold})"
+      end
+
+      def serialize_stats(stats)
+        stats.map { |s| { name: s[:data], count: s[:count] } }
+      end
+
+      def require_memory_profiler!
+        require "memory_profiler"
+      rescue LoadError
+        raise LoadError, "Add `gem 'memory_profiler'` to your Gemfile to use config.detailed_reports = true"
+      end
+
       def sample?
         rate = RailsMemoryProfiler.config.sample_rate
         return true if rate <= 1
@@ -61,6 +132,16 @@ module RailsMemoryProfiler
         end
       end
 
+      def detailed_sample?
+        rate = RailsMemoryProfiler.config.detailed_sample_rate
+        return true if rate <= 1
+
+        @mutex.synchronize do
+          @detailed_count = (@detailed_count + 1) % rate
+          @detailed_count.zero?
+        end
+      end
+
       def ignored_path?(path)
         RailsMemoryProfiler.config.ignore_paths.any? do |pattern|
           pattern.is_a?(Regexp) ? pattern.match?(path) : path.start_with?(pattern.to_s)

data/lib/rails_memory_profiler/notifiers/console.rb

@@ -0,0 +1,36 @@
+module RailsMemoryProfiler
+  module Notifiers
+    class Console
+      RESET  = "\e[0m"
+      CYAN   = "\e[36m"
+      DIM    = "\e[2m"
+      GREEN  = "\e[32m"
+      YELLOW = "\e[33m"
+      RED    = "\e[31m"
+
+      def call(report)
+        $stdout.puts(colorize(report))
+      end
+
+      private
+
+        def colorize(report)
+          action = [report[:controller], report[:action]].compact.join("#")
+          alloc  = report[:allocated_objects]
+
+          "#{DIM}[RMP]#{RESET} " \
+          "#{CYAN}#{report[:method]} #{report[:path]}#{RESET} " \
+          "#{DIM}(#{action})#{RESET}  " \
+          "#{alloc_color(alloc)}#{Notifiers.thousands(alloc)} alloc#{RESET}  " \
+          "#{DIM}#{report[:retained_objects]} retained  #{report[:duration_ms]}ms#{RESET}"
+        end
+
+        def alloc_color(count)
+          if count < 5_000 then GREEN
+          elsif count < 20_000 then YELLOW
+          else RED
+          end
+        end
+    end
+  end
+end

data/lib/rails_memory_profiler/notifiers/file_logger.rb

@@ -0,0 +1,16 @@
+require "json"
+
+module RailsMemoryProfiler
+  module Notifiers
+    class FileLogger
+      def initialize(path)
+        @path = path
+      end
+
+      def call(report)
+        serializable = report.merge(recorded_at: report[:recorded_at]&.iso8601)
+        File.open(@path, "a") { |f| f.puts(serializable.to_json) }
+      end
+    end
+  end
+end

data/lib/rails_memory_profiler/notifiers/logger.rb

@@ -0,0 +1,9 @@
+module RailsMemoryProfiler
+  module Notifiers
+    class Logger
+      def call(report)
+        Rails.logger.info(Notifiers.format_line(report))
+      end
+    end
+  end
+end

data/lib/rails_memory_profiler/notifiers/stdout.rb

@@ -0,0 +1,9 @@
+module RailsMemoryProfiler
+  module Notifiers
+    class Stdout
+      def call(report)
+        $stdout.puts(Notifiers.format_line(report))
+      end
+    end
+  end
+end

data/lib/rails_memory_profiler/notifiers.rb

@@ -0,0 +1,19 @@
+require "rails_memory_profiler/notifiers/logger"
+require "rails_memory_profiler/notifiers/stdout"
+require "rails_memory_profiler/notifiers/console"
+require "rails_memory_profiler/notifiers/file_logger"
+
+module RailsMemoryProfiler
+  module Notifiers
+    def self.format_line(report)
+      action = [report[:controller], report[:action]].compact.join("#")
+      "[RailsMemoryProfiler] #{report[:method]} #{report[:path]} (#{action})" \
+        " — #{thousands(report[:allocated_objects])} allocated," \
+        " #{report[:retained_objects]} retained, #{report[:duration_ms]}ms"
+    end
+
+    def self.thousands(n)
+      n.to_s.reverse.scan(/\d{1,3}/).join(",").reverse
+    end
+  end
+end

data/lib/rails_memory_profiler/rspec_matchers.rb

@@ -0,0 +1,20 @@
+require "rails_memory_profiler/test_helper"
+
+if defined?(RSpec)
+  RSpec::Matchers.define :allocate_fewer_than do |expected|
+    supports_block_expectations
+
+    match do |block|
+      @count = RailsMemoryProfiler::TestHelper.capture_allocations(&block)
+      @count < expected
+    end
+
+    failure_message do
+      "expected block to allocate fewer than #{expected} objects, but got #{@count}"
+    end
+
+    failure_message_when_negated do
+      "expected block to allocate #{expected} or more objects, but got #{@count}"
+    end
+  end
+end

data/lib/rails_memory_profiler/test_helper.rb

@@ -0,0 +1,21 @@
+require "rails_memory_profiler"
+
+module RailsMemoryProfiler
+  module TestHelper
+    extend self
+
+    def capture_allocations
+      GC.start
+      before = GC.stat(:total_allocated_objects)
+      yield
+      GC.stat(:total_allocated_objects) - before
+    end
+
+    def assert_allocations_below(threshold, &block)
+      count = capture_allocations(&block)
+      return if count < threshold
+
+      raise "Expected fewer than #{threshold} allocated objects but got #{count}"
+    end
+  end
+end

data/lib/rails_memory_profiler/version.rb

@@ -1,3 +1,3 @@
 module RailsMemoryProfiler
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/rails_memory_profiler.rb

@@ -2,10 +2,13 @@ require "rails_memory_profiler/version"
 require "rails_memory_profiler/configuration"
 require "rails_memory_profiler/request_context"
 require "rails_memory_profiler/report_store"
+require "rails_memory_profiler/notifiers"
 require "rails_memory_profiler/middleware"
 require "rails_memory_profiler/engine"
 
 module RailsMemoryProfiler
+  class AllocationSpikeError < StandardError; end
+
   class << self
     def configure
       yield config

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_memory_profiler
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Chuck Smith
@@ -69,15 +69,23 @@ files:
 - app/assets/stylesheets/rails_memory_profiler/_03_table.css
 - app/assets/stylesheets/rails_memory_profiler/_04_badges.css
 - app/assets/stylesheets/rails_memory_profiler/_05_filters.css
+- app/assets/stylesheets/rails_memory_profiler/_06_breakdowns.css
+- app/assets/stylesheets/rails_memory_profiler/_07_compare.css
 - app/controllers/rails_memory_profiler/application_controller.rb
+- app/controllers/rails_memory_profiler/base_controller.rb
+- app/controllers/rails_memory_profiler/comparisons_controller.rb
 - app/controllers/rails_memory_profiler/reports_controller.rb
 - app/helpers/rails_memory_profiler/application_helper.rb
 - app/javascript/rails_memory_profiler/application.js
-- app/javascript/rails_memory_profiler/filter_controller.js
+- app/javascript/rails_memory_profiler/controllers/application.js
+- app/javascript/rails_memory_profiler/controllers/compare_controller.js
+- app/javascript/rails_memory_profiler/controllers/filter_controller.js
+- app/javascript/rails_memory_profiler/controllers/index.js
 - app/jobs/rails_memory_profiler/application_job.rb
 - app/mailers/rails_memory_profiler/application_mailer.rb
 - app/models/rails_memory_profiler/application_record.rb
 - app/views/layouts/rails_memory_profiler/application.html.erb
+- app/views/rails_memory_profiler/comparisons/show.html.erb
 - app/views/rails_memory_profiler/reports/index.html.erb
 - app/views/rails_memory_profiler/reports/show.html.erb
 - config/importmap.rb
@@ -88,8 +96,15 @@ files:
 - lib/rails_memory_profiler/configuration.rb
 - lib/rails_memory_profiler/engine.rb
 - lib/rails_memory_profiler/middleware.rb
+- lib/rails_memory_profiler/notifiers.rb
+- lib/rails_memory_profiler/notifiers/console.rb
+- lib/rails_memory_profiler/notifiers/file_logger.rb
+- lib/rails_memory_profiler/notifiers/logger.rb
+- lib/rails_memory_profiler/notifiers/stdout.rb
 - lib/rails_memory_profiler/report_store.rb
 - lib/rails_memory_profiler/request_context.rb
+- lib/rails_memory_profiler/rspec_matchers.rb
+- lib/rails_memory_profiler/test_helper.rb
 - lib/rails_memory_profiler/version.rb
 - lib/tasks/rails_memory_profiler_tasks.rake
 homepage: https://github.com/eclectic-coding/rails_memory_profiler

data/app/javascript/rails_memory_profiler/filter_controller.js

@@ -1,30 +0,0 @@
-import { Controller } from "@hotwired/stimulus"
-
-export default class extends Controller {
-  static targets = ["input", "row", "clearButton"]
-
-  connect() {
-    this._updateClear()
-  }
-
-  filter() {
-    const query = this.inputTarget.value.toLowerCase()
-    this.rowTargets.forEach(row => {
-      const name = (row.dataset.controllerName || "").toLowerCase()
-      row.hidden = query.length > 0 && !name.includes(query)
-    })
-    this._updateClear()
-  }
-
-  clear() {
-    this.inputTarget.value = ""
-    this.rowTargets.forEach(row => { row.hidden = false })
-    this._updateClear()
-  }
-
-  _updateClear() {
-    if (this.hasClearButtonTarget) {
-      this.clearButtonTarget.hidden = this.inputTarget.value.length === 0
-    }
-  }
-}