rails_memory_profiler 0.1.0

checksums.yaml

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

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright Chuck Smith
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,107 @@
+# RailsMemoryProfiler
+
+[![CI](https://github.com/eclectic-coding/rails_memory_profiler/actions/workflows/main.yml/badge.svg)](https://github.com/eclectic-coding/rails_memory_profiler/actions/workflows/main.yml)
+[![Gem Version](https://img.shields.io/gem/v/rails_memory_profiler)](https://rubygems.org/gems/rails_memory_profiler)
+[![Gem Downloads](https://img.shields.io/gem/dt/rails_memory_profiler)](https://rubygems.org/gems/rails_memory_profiler)
+[![Ruby](https://img.shields.io/badge/ruby-%3E%3D%203.3-CC342D?logo=ruby&logoColor=white)](https://www.ruby-lang.org)
+[![Rails](https://img.shields.io/badge/rails-%3E%3D%207.1-CC0000?logo=rubyonrails&logoColor=white)](https://rubyonrails.org)
+[![codecov](https://codecov.io/gh/eclectic-coding/rails_memory_profiler/branch/main/graph/badge.svg)](https://codecov.io/gh/eclectic-coding/rails_memory_profiler)
+
+Per-request memory allocation reports with a mountable dashboard UI. Fills the gap between the [`memory_profiler`](https://github.com/SamSaffron/memory_profiler) gem (terminal-only output, manual block wrapping) and having nowhere useful to browse results in a Rails app.
+
+A Rack middleware captures object allocations for every request using `GC.stat` diffs. Results are stored in a thread-safe ring buffer and served through a mountable engine with a sortable, filterable dashboard.
+
+---
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Dashboard](#dashboard)
+- [Configuration](#configuration)
+- [Contributing](#contributing)
+- [License](#license)
+
+---
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "rails_memory_profiler", group: :development
+```
+
+Run the install generator:
+
+```bash
+bundle exec rails generate rails_memory_profiler:install
+```
+
+This creates `config/initializers/rails_memory_profiler.rb` with all options documented and prints mount instructions.
+
+Mount the dashboard in `config/routes.rb`:
+
+```ruby
+mount RailsMemoryProfiler::Engine, at: "/rails/memory"
+```
+
+Then visit `/rails/memory/reports` to see per-request allocation data.
+
+[↑ Back to top](#railsmemoryprofiler)
+
+---
+
+## Dashboard
+
+The index view shows a sortable table of captured requests. Click any row to open the detail view for that request.
+
+Columns: **Path**, **Controller#Action**, **Allocated Objects** (colour-coded), **Retained Objects**, **Duration (ms)**, **Recorded At**.
+
+Use the controller filter to narrow the table down to a specific controller without a page reload.
+
+[↑ Back to top](#railsmemoryprofiler)
+
+---
+
+## Configuration
+
+All options and their defaults:
+
+| Option | Default | Description |
+|---|---|---|
+| `enabled` | `true` in development | Enable/disable request profiling |
+| `sample_rate` | `1` | Profile every Nth request (`1` = every request) |
+| `store_size` | `100` | Max reports in the ring buffer; oldest are evicted when full |
+| `dashboard_enabled` | `true` in development | Enable the dashboard endpoint |
+| `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"`) |
+
+Example:
+
+```ruby
+RailsMemoryProfiler.configure do |config|
+  config.sample_rate           = 5
+  config.min_allocated_objects = 1_000
+  config.ignore_paths          = ["/rails/memory", "/up"]
+  config.ignore_controllers    = ["rails/health"]
+end
+```
+
+[↑ Back to top](#railsmemoryprofiler)
+
+---
+
+## Contributing
+
+Bug reports and pull requests are welcome on [GitHub](https://github.com/eclectic-coding/rails_memory_profiler).
+
+[↑ Back to top](#railsmemoryprofiler)
+
+---
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+[↑ Back to top](#railsmemoryprofiler)

data/Rakefile

@@ -0,0 +1,16 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+require "bundler/gem_tasks"
+
+require 'rubocop/rake_task'
+require 'bundler/audit/task'
+require 'rspec/core/rake_task'
+
+RuboCop::RakeTask.new(:lint)
+Bundler::Audit::Task.new
+RSpec::Core::RakeTask.new(:spec)
+
+task default: [:lint, :'bundle:audit:update', 'bundle:audit:check', :spec]

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

@@ -0,0 +1,24 @@
+*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+
+:root {
+  --bg:      #f8f9fa;
+  --surface: #ffffff;
+  --border:  #dee2e6;
+  --text:    #212529;
+  --muted:   #6c757d;
+  --accent:  #4f46e5;
+  --radius:  6px;
+  --shadow:  0 1px 3px rgba(0,0,0,.08);
+}
+
+body {
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+  font-size: 14px;
+  line-height: 1.5;
+  color: var(--text);
+  background: var(--bg);
+  padding: 2rem;
+}
+
+.rmp-monospace { font-family: ui-monospace, "SFMono-Regular", Menlo, monospace; font-size: 12px; }
+.rmp-muted     { color: var(--muted); font-size: 12px; }

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

@@ -0,0 +1,49 @@
+.rmp-header   { margin-bottom: 1.5rem; }
+.rmp-header h1 { font-size: 1.4rem; font-weight: 600; }
+.rmp-header p  { color: var(--muted); margin-top: 0.2rem; }
+
+.rmp-empty   { color: var(--muted); font-style: italic; margin-top: 1rem; }
+.rmp-summary { margin-bottom: 0.5rem; }
+
+.rmp-back {
+  display: inline-block;
+  margin-bottom: 1rem;
+  color: var(--accent);
+  text-decoration: none;
+  font-size: 13px;
+}
+.rmp-back:hover { text-decoration: underline; }
+
+.rmp-detail {
+  background: var(--surface);
+  border-radius: var(--radius);
+  box-shadow: var(--shadow);
+  padding: 1.5rem;
+}
+
+.rmp-detail-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
+  gap: 1rem;
+}
+
+.rmp-detail-item {
+  padding: 0.75rem 1rem;
+  background: var(--bg);
+  border-radius: var(--radius);
+}
+
+.rmp-detail-label {
+  font-size: 11px;
+  font-weight: 600;
+  color: var(--muted);
+  text-transform: uppercase;
+  letter-spacing: .04em;
+  margin-bottom: 0.25rem;
+}
+
+.rmp-detail-value {
+  font-size: 1.25rem;
+  font-weight: 600;
+  color: var(--text);
+}

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

@@ -0,0 +1,39 @@
+.rmp-table {
+  width: 100%;
+  border-collapse: collapse;
+  background: var(--surface);
+  border-radius: var(--radius);
+  overflow: hidden;
+  box-shadow: var(--shadow);
+}
+
+.rmp-table th {
+  text-align: left;
+  padding: 0.6rem 1rem;
+  background: #f0f0f0;
+  font-weight: 600;
+  font-size: 11px;
+  text-transform: uppercase;
+  letter-spacing: .04em;
+  color: var(--muted);
+  border-bottom: 1px solid var(--border);
+}
+
+.rmp-table td {
+  padding: 0.6rem 1rem;
+  border-bottom: 1px solid #eee;
+  vertical-align: middle;
+}
+
+.rmp-table tr:last-child td { border-bottom: none; }
+.rmp-table tr:hover td      { background: #fafafa; }
+
+.rmp-sort-link {
+  color: inherit;
+  text-decoration: none;
+  display: block;
+}
+.rmp-sort-link:hover  { color: var(--accent); }
+.rmp-sort-active      { color: var(--accent); }
+
+.rmp-path { font-family: ui-monospace, "SFMono-Regular", Menlo, monospace; font-size: 11px; opacity: .7; }

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

@@ -0,0 +1,12 @@
+.rmp-badge {
+  display: inline-block;
+  padding: 2px 8px;
+  border-radius: 3px;
+  font-size: 11px;
+  font-weight: 600;
+  white-space: nowrap;
+}
+
+.rmp-badge--low  { background: #d1fae5; color: #065f46; }
+.rmp-badge--mid  { background: #fef3c7; color: #92400e; }
+.rmp-badge--high { background: #fee2e2; color: #991b1b; }

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

@@ -0,0 +1,58 @@
+.rmp-filters {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  margin-bottom: 1rem;
+  padding: 0.6rem 1rem;
+  background: var(--surface);
+  border-radius: var(--radius);
+  box-shadow: var(--shadow);
+}
+
+.rmp-filters label {
+  font-size: 11px;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: .04em;
+  color: var(--muted);
+}
+
+.rmp-input {
+  font-family: inherit;
+  font-size: 13px;
+  padding: 0.3rem 0.6rem;
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  background: var(--bg);
+  color: var(--text);
+  min-width: 200px;
+}
+
+.rmp-input:focus {
+  outline: none;
+  border-color: #86b7fe;
+  box-shadow: 0 0 0 2px rgba(13,110,253,.15);
+}
+
+.rmp-input-wrapper {
+  position: relative;
+  display: inline-flex;
+  align-items: center;
+}
+
+.rmp-input-wrapper .rmp-input { padding-right: 1.6rem; }
+
+.rmp-input-clear {
+  position: absolute;
+  right: 0.4rem;
+  background: none;
+  border: none;
+  cursor: pointer;
+  color: var(--muted);
+  font-size: 11px;
+  line-height: 1;
+  padding: 0.15rem 0.2rem;
+  border-radius: 2px;
+}
+
+.rmp-input-clear:hover { color: var(--text); background: var(--border); }

data/app/controllers/rails_memory_profiler/application_controller.rb

@@ -0,0 +1,4 @@
+module RailsMemoryProfiler
+  class ApplicationController < ActionController::API
+  end
+end

data/app/controllers/rails_memory_profiler/reports_controller.rb

@@ -0,0 +1,50 @@
+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
+
+    SORTABLE_COLUMNS = %w[path controller allocated_objects retained_objects duration_ms recorded_at].freeze
+
+    def index
+      reports = ReportStore.all
+
+      respond_to do |format|
+        format.json { render json: reports }
+        format.html do
+          @sort      = SORTABLE_COLUMNS.include?(params[:sort]) ? params[:sort] : "recorded_at"
+          @direction = params[:direction] == "asc" ? "asc" : "desc"
+          @reports   = sorted(reports, @sort, @direction)
+        end
+      end
+    end
+
+    def show
+      @report = ReportStore.find(params[:id])
+
+      respond_to do |format|
+        format.html
+        format.json do
+          if @report
+            render json: @report
+          else
+            render json: { error: "Report not found" }, status: :not_found
+          end
+        end
+      end
+    end
+
+    private
+
+      def sorted(reports, sort, direction)
+        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/helpers/rails_memory_profiler/application_helper.rb

@@ -0,0 +1,35 @@
+module RailsMemoryProfiler
+  module ApplicationHelper
+    def inline_styles
+      dir = RailsMemoryProfiler::Engine.root.join("app/assets/stylesheets/rails_memory_profiler")
+      css = dir.glob("_*.css").sort.map(&:read).join("\n")
+      content_tag(:style, css.html_safe)
+    end
+
+    def sort_th(label, column, current_sort, current_dir)
+      active    = current_sort == column.to_s
+      next_dir  = (active && current_dir == "asc") ? "desc" : "asc"
+      indicator = active ? (current_dir == "asc" ? " ▲" : " ▼") : ""
+      params    = request.query_parameters.merge("sort" => column, "direction" => next_dir)
+      href      = "?" + params.to_query
+      content_tag(:th) do
+        link_to(
+          "#{label}#{indicator}".html_safe,
+          href,
+          class: ["rmp-sort-link", ("rmp-sort-active" if active)].compact.join(" ")
+        )
+      end
+    end
+
+    def allocation_badge(count)
+      css_class = if count < 5_000
+        "rmp-badge--low"
+      elsif count < 20_000
+        "rmp-badge--mid"
+      else
+        "rmp-badge--high"
+      end
+      content_tag(:span, number_with_delimiter(count), class: "rmp-badge #{css_class}")
+    end
+  end
+end

data/app/javascript/rails_memory_profiler/application.js

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

data/app/javascript/rails_memory_profiler/filter_controller.js

@@ -0,0 +1,30 @@
+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
+    }
+  }
+}

data/app/jobs/rails_memory_profiler/application_job.rb

@@ -0,0 +1,4 @@
+module RailsMemoryProfiler
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/rails_memory_profiler/application_mailer.rb

@@ -0,0 +1,6 @@
+module RailsMemoryProfiler
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end

data/app/models/rails_memory_profiler/application_record.rb

@@ -0,0 +1,5 @@
+module RailsMemoryProfiler
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/views/layouts/rails_memory_profiler/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>RailsMemoryProfiler</title>
+  <link rel="icon" href="data:,">
+  <%= inline_styles %>
+  <%= javascript_importmap_tags "rails_memory_profiler" %>
+</head>
+<body>
+  <%= yield %>
+</body>
+</html>

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

@@ -0,0 +1,56 @@
+<div class="rmp-header">
+  <h1>Memory Profiler</h1>
+  <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">
+    <button type="button"
+            class="rmp-input-clear"
+            aria-label="Clear filter"
+            hidden
+            data-filter-target="clearButton"
+            data-action="click->filter#clear">✕</button>
+  </div>
+
+  <% if @reports.empty? %>
+  <% 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>
+        </tr>
+      <% end %>
+    </tbody>
+  </table>
+<% end %>

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

@@ -0,0 +1,35 @@
+<%= link_to "← All Requests", reports_path, class: "rmp-back" %>
+
+<% if @report %>
+  <div class="rmp-header">
+    <h1><%= @report[:method] %> <%= @report[:path] %></h1>
+    <p>
+      <%= [@report[:controller], @report[:action]].compact.join("#") %>
+      &middot;
+      <%= @report[:recorded_at]&.strftime("%Y-%m-%d %H:%M:%S") %>
+    </p>
+  </div>
+
+  <div class="rmp-detail">
+    <div class="rmp-detail-grid">
+      <div class="rmp-detail-item">
+        <div class="rmp-detail-label">Allocated Objects</div>
+        <div class="rmp-detail-value"><%= number_with_delimiter(@report[:allocated_objects]) %></div>
+      </div>
+      <div class="rmp-detail-item">
+        <div class="rmp-detail-label">Retained Objects</div>
+        <div class="rmp-detail-value"><%= number_with_delimiter(@report[:retained_objects]) %></div>
+      </div>
+      <div class="rmp-detail-item">
+        <div class="rmp-detail-label">Duration</div>
+        <div class="rmp-detail-value"><%= @report[:duration_ms] %> ms</div>
+      </div>
+      <div class="rmp-detail-item">
+        <div class="rmp-detail-label">HTTP Method</div>
+        <div class="rmp-detail-value"><%= @report[:method] %></div>
+      </div>
+    </div>
+  </div>
+<% else %>
+  <p class="rmp-empty">Report not found — it may have been evicted from the store.</p>
+<% end %>

data/config/importmap.rb

@@ -0,0 +1,4 @@
+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"

data/config/routes.rb

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

data/lib/generators/rails_memory_profiler/install/install_generator.rb

@@ -0,0 +1,25 @@
+require "rails/generators"
+
+module RailsMemoryProfiler
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates a RailsMemoryProfiler initializer in config/initializers."
+
+      def copy_initializer
+        template "initializer.rb", "config/initializers/rails_memory_profiler.rb"
+      end
+
+      def show_readme
+        say ""
+        say "  Mount the dashboard in config/routes.rb:", :green
+        say ""
+        say '    mount RailsMemoryProfiler::Engine, at: "/rails/memory"'
+        say ""
+        say "  Then visit /rails/memory/reports to see per-request allocation data.", :green
+        say ""
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+RailsMemoryProfiler.configure do |config|
+  # Enable or disable per-request memory profiling.
+  # Defaults to true in development, false elsewhere.
+  # config.enabled = Rails.env.development?
+
+  # Profile every Nth request. 1 = every request, 10 = every 10th, etc.
+  # Increase for busier apps where profiling every request adds too much overhead.
+  # config.sample_rate = 1
+
+  # Maximum number of reports kept in the in-memory ring buffer.
+  # Oldest reports are evicted when the buffer is full.
+  # config.store_size = 100
+
+  # Enable the HTML/JSON dashboard at /reports (relative to the engine mount point).
+  # Defaults to true in development, false elsewhere.
+  # config.dashboard_enabled = Rails.env.development?
+
+  # Skip recording requests that allocate fewer objects than this threshold.
+  # Useful for filtering out trivial requests (health checks, asset hits, etc.).
+  # config.min_allocated_objects = 0
+
+  # Paths to skip entirely — accepts strings (prefix match) or regexes.
+  # The engine's own mount path is a good candidate to add here.
+  # config.ignore_paths = ["/rails/memory", "/up", %r{^/assets/}]
+
+  # Controllers to skip — matched against the Rails controller name.
+  # config.ignore_controllers = ["rails/health", "rails_memory_profiler/reports"]
+end

data/lib/rails_memory_profiler/configuration.rb

@@ -0,0 +1,16 @@
+module RailsMemoryProfiler
+  class Configuration
+    attr_accessor :enabled, :sample_rate, :store_size, :dashboard_enabled,
+                  :min_allocated_objects, :ignore_paths, :ignore_controllers
+
+    def initialize
+      @enabled               = Rails.env.development?
+      @sample_rate           = 1
+      @store_size            = 100
+      @dashboard_enabled     = Rails.env.development?
+      @min_allocated_objects = 0
+      @ignore_paths          = []
+      @ignore_controllers    = []
+    end
+  end
+end

data/lib/rails_memory_profiler/engine.rb

@@ -0,0 +1,26 @@
+require "turbo-rails"
+require "importmap-rails"
+
+module RailsMemoryProfiler
+  class Engine < ::Rails::Engine
+    isolate_namespace RailsMemoryProfiler
+    config.generators.api_only = true
+
+    initializer "rails_memory_profiler.assets" do |app|
+      if app.config.respond_to?(:assets)
+        app.config.assets.paths << root.join("app/javascript")
+      end
+    end
+
+    initializer "rails_memory_profiler.importmap", before: "importmap" do |app|
+      if app.config.respond_to?(:importmap)
+        app.config.importmap.paths << root.join("config/importmap.rb")
+        app.config.importmap.cache_sweepers << root.join("app/javascript")
+      end
+    end
+
+    initializer "rails_memory_profiler.middleware" do |app|
+      app.middleware.use(Middleware)
+    end
+  end
+end

data/lib/rails_memory_profiler/middleware.rb

@@ -0,0 +1,76 @@
+module RailsMemoryProfiler
+  class Middleware
+    def initialize(app)
+      @app           = app
+      @request_count = 0
+      @mutex         = Mutex.new
+    end
+
+    def call(env)
+      return @app.call(env) unless RailsMemoryProfiler.config.enabled
+      return @app.call(env) if ignored_path?(env["PATH_INFO"])
+      return @app.call(env) unless sample?
+
+      profile(env)
+    end
+
+    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]
+
+        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)
+
+        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
+
+        [status, headers, body]
+      end
+
+      def sample?
+        rate = RailsMemoryProfiler.config.sample_rate
+        return true if rate <= 1
+
+        @mutex.synchronize do
+          @request_count = (@request_count + 1) % rate
+          @request_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)
+        end
+      end
+
+      def ignored_controller?(controller)
+        return false unless controller
+
+        RailsMemoryProfiler.config.ignore_controllers.any? { |name| name.to_s == controller }
+      end
+  end
+end

data/lib/rails_memory_profiler/report_store.rb

@@ -0,0 +1,63 @@
+module RailsMemoryProfiler
+  module ReportStore
+    class << self
+      def push(report)
+        mutex.synchronize do
+          ensure_buffer_size
+          buffer[@write_pos] = report.merge(id: SecureRandom.hex(6))
+          @write_pos = (@write_pos + 1) % capacity
+          @stored    = [@stored + 1, capacity].min
+        end
+      end
+
+      def find(id)
+        all.find { |r| r[:id] == id }
+      end
+
+      def all
+        mutex.synchronize do
+          stored = @stored || 0
+          return [] if stored.zero?
+
+          if stored < capacity
+            buffer.first(stored)
+          else
+            buffer[@write_pos..] + buffer[0...@write_pos]
+          end
+        end
+      end
+
+      def clear
+        mutex.synchronize { reset! }
+      end
+
+      def size
+        mutex.synchronize { @stored || 0 }
+      end
+
+      private
+
+        def mutex
+          @mutex ||= Mutex.new
+        end
+
+        def capacity
+          RailsMemoryProfiler.config.store_size
+        end
+
+        def ensure_buffer_size
+          reset! if @write_pos.nil? || @buffer.nil? || @buffer.size != capacity
+        end
+
+        def buffer
+          @buffer ||= Array.new(capacity)
+        end
+
+        def reset!
+          @buffer    = Array.new(capacity)
+          @write_pos = 0
+          @stored    = 0
+        end
+    end
+  end
+end

data/lib/rails_memory_profiler/request_context.rb

@@ -0,0 +1,22 @@
+module RailsMemoryProfiler
+  module RequestContext
+    class << self
+      def set(controller:, action:, path:, method:)
+        Thread.current[:rails_memory_profiler_context] = {
+          controller: controller,
+          action: action,
+          path: path,
+          method: method
+        }
+      end
+
+      def current
+        Thread.current[:rails_memory_profiler_context] || {}
+      end
+
+      def clear
+        Thread.current[:rails_memory_profiler_context] = nil
+      end
+    end
+  end
+end

data/lib/rails_memory_profiler/version.rb

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

data/lib/rails_memory_profiler.rb

@@ -0,0 +1,22 @@
+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/middleware"
+require "rails_memory_profiler/engine"
+
+module RailsMemoryProfiler
+  class << self
+    def configure
+      yield config
+    end
+
+    def config
+      @config ||= Configuration.new
+    end
+
+    def reset_config!
+      @config = Configuration.new
+    end
+  end
+end

data/lib/tasks/rails_memory_profiler_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :rails_memory_profiler do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: rails_memory_profiler
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Chuck Smith
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: importmap-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: turbo-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Rack middleware captures object allocations per request using GC.stat
+  diffs and stores them in a thread-safe ring buffer. Results are served through a
+  mountable engine with a sortable, filterable dashboard — filling the gap between
+  the memory_profiler gem and having nowhere useful to view results in a Rails app.
+email:
+- eclectic-coding@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/stylesheets/rails_memory_profiler/_01_base.css
+- app/assets/stylesheets/rails_memory_profiler/_02_layout.css
+- 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/controllers/rails_memory_profiler/application_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/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/reports/index.html.erb
+- app/views/rails_memory_profiler/reports/show.html.erb
+- config/importmap.rb
+- config/routes.rb
+- lib/generators/rails_memory_profiler/install/install_generator.rb
+- lib/generators/rails_memory_profiler/install/templates/initializer.rb
+- lib/rails_memory_profiler.rb
+- lib/rails_memory_profiler/configuration.rb
+- lib/rails_memory_profiler/engine.rb
+- lib/rails_memory_profiler/middleware.rb
+- lib/rails_memory_profiler/report_store.rb
+- lib/rails_memory_profiler/request_context.rb
+- lib/rails_memory_profiler/version.rb
+- lib/tasks/rails_memory_profiler_tasks.rake
+homepage: https://github.com/eclectic-coding/rails_memory_profiler
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/eclectic-coding/rails_memory_profiler
+  source_code_uri: https://github.com/eclectic-coding/rails_memory_profiler
+  changelog_uri: https://github.com/eclectic-coding/rails_memory_profiler/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Per-request memory allocation reports with a mountable dashboard UI for Rails.
+test_files: []