n_plus_insight 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b64b2190f32d5bd69dc972654ccb46add8d3a2a4bacc9938a3e0bf5b7035004f
-  data.tar.gz: 9af66e38cdbe1676aece5a7cf193f6eae284589163b845e58adf9bef36a5ef66
+  metadata.gz: b8ae9f6ffeef6402349d63d9ceb1797a71aeb567e18383019b95e455b32d9b1b
+  data.tar.gz: 86c59f125447834906a627ed2ace73cae60b171ecf4d3ef7183e7864d919cc0f
 SHA512:
-  metadata.gz: e6ed0f4ad2dacf35a5e9c52ba9d7597c6d536d05f2930d1798082da89bd811d4e6bb7b63a60b1f9f10608c63b2fbbc982b799038410acf5b46d2b5224c862170
-  data.tar.gz: f9c71aa555d723bb1b2d109e572c8f49458c361196de2ee48d6f734158ba55bafba84d4ef0fe418aea10559f994ef751eb3407ac29d4035a0923d54e56ae837b
+  metadata.gz: 137231015fad7ceee3a2658aafb9ab7accea46c44feea299e9d17eb4e5f960e65b4792102592556fa9cff7bfda956cba9f6e5c04c0b02ab641f4e6e0f4541b5c
+  data.tar.gz: f24bbbb97328f57c943a466c586494fbf94147349c99fb209c1232aa398e7058abe6d7c0b9dc5024e0a594b6388a0c9b6ac8999115e45054acf6961407b923c8

data/CHANGELOG.md

@@ -3,9 +3,15 @@
 ## 0.1.0 - 2026-07-28
 
 - Detect repeated Active Record query shapes within a request.
+- Combine multiple repeated query shapes attributed to the same source line.
 - Identify relevant application source files, line numbers, and code excerpts.
-- Visualize affected models and associations.
-- Recommend eager-loading and strict-loading remediations.
+- Visualize multi-model associations as nested trees.
+- Recommend combined eager-loading and strict-loading remediations for the
+  complete association tree.
 - Provide an optional on-page status indicator and findings panel.
 - Provide a full mounted findings dashboard.
+- Allow operators to clear stored findings from the dashboard.
+- Roll off the oldest dashboard findings according to `max_events`.
+- Publish canonical GitHub, documentation, changelog, and issue-tracker
+  metadata.
 - Support environment-neutral activation and deployment.

data/LICENSE.txt

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 NPlusInsight contributors
+Copyright (c) 2026 Jory Leech
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,70 +1,367 @@
 # NPlusInsight
 
-NPlusInsight is a Rails gem that detects repeated query
-shapes within a request and turns them into a useful debugging report:
+[![Ruby 3.1+](https://img.shields.io/badge/Ruby-3.1%2B-CC342D?logo=ruby&logoColor=white)](https://www.ruby-lang.org/)
+[![Rails 7–8](https://img.shields.io/badge/Rails-7.0%E2%80%938.x-D30001?logo=rubyonrails&logoColor=white)](https://rubyonrails.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-2563EB.svg)](LICENSE.txt)
 
-- the exact application file and line that issued the query;
-- a model/association graph for the tables involved;
-- normalized SQL, repetition count, and total query time;
-- suggested `includes` and `strict_loading` fixes.
+[Source code](https://github.com/joryleech/NPlusInsight) ·
+[Issue tracker](https://github.com/joryleech/NPlusInsight/issues) ·
+[Changelog](CHANGELOG.md)
 
-## Install
+NPlusInsight detects N+1 queries in Ruby on Rails applications and turns them
+into actionable, source-level diagnostics.
 
-Add the gem in every environment where you may enable it:
+For each finding, NPlusInsight shows:
+
+- the application file, line number, and surrounding source code;
+- the repeated SQL shape, query count, and cumulative duration;
+- the Active Record models and associations involved;
+- suggested eager-loading and strict-loading remediations;
+- an optional on-page alert and a mounted findings dashboard.
+
+NPlusInsight is environment-neutral. Enable it anywhere you need diagnostics,
+including development, test, staging, or a controlled production environment.
+
+## Table of contents
+
+- [Why NPlusInsight?](#why-nplusinsight)
+- [Screenshots](#screenshots)
+- [Requirements](#requirements)
+- [Installation](#installation)
+- [Quick start](#quick-start)
+- [Configuration](#configuration)
+- [Dashboard and on-page inspector](#dashboard-and-on-page-inspector)
+- [How detection works](#how-detection-works)
+- [Security and privacy](#security-and-privacy)
+- [Operational considerations](#operational-considerations)
+- [CI and test environments](#ci-and-test-environments)
+- [Troubleshooting](#troubleshooting)
+- [Development](#development)
+- [Contributing](#contributing)
+- [Releasing](#releasing)
+- [License](#license)
+
+## Why NPlusInsight?
+
+Rails logs make repeated queries visible, but they do not always make the cause
+obvious. NPlusInsight connects runtime query evidence to the application code
+that triggered it, then presents the affected model relationship and a
+candidate fix in one place.
+
+The gem is designed to keep the feedback loop short:
+
+1. Exercise an application page.
+2. See the on-page alert when repeated query patterns are detected.
+3. Open the finding to inspect the responsible source line and model graph.
+4. Apply eager loading.
+5. Reload the page and confirm that the finding is gone.
+
+## Screenshots
+
+### On-page alert
+
+The corner indicator turns red and displays the number of N+1 query patterns
+detected while rendering the current page.
+
+![NPlusInsight on-page N+1 alert](docs/images/on-page-alert.png)
+
+### On-page findings inspector
+
+Open the indicator to inspect relevant source lines, affected models, and
+remediation suggestions without leaving the page.
+
+![NPlusInsight grouped query patterns and multi-model tree in the on-page inspector](docs/images/on-page-popout-modeled.png)
+
+### Mounted findings dashboard
+
+The mounted dashboard collects recent findings across requests for deeper
+inspection.
+
+![NPlusInsight full findings dashboard](docs/images/full-dashboard.png)
+
+## Requirements
+
+| Dependency | Supported versions |
+| --- | --- |
+| Ruby | 3.1 or newer |
+| Ruby on Rails | 7.0 through 8.x |
+| Active Record | Provided by the Rails application |
+
+## Installation
+
+Add NPlusInsight to the environments where it must be available:
 
 ```ruby
+# Gemfile
 gem "n_plus_insight"
 ```
 
-Run `bundle install`, then configure NPlusInsight for the environments where it
-should be active.
+Install dependencies:
+
+```sh
+bundle install
+```
+
+The Rails engine registers its middleware and mounts its dashboard
+automatically. No route declaration is required.
 
-Then configure activation from the environment rather than tying it to a Rails
-environment name:
+## Quick start
+
+Enable NPlusInsight in the Rails environment where you want to use it:
+
+```ruby
+# config/environments/development.rb
+NPlusInsight.configure do |config|
+  config.enabled = true
+end
+```
+
+Keep shared settings in an initializer:
+
+```ruby
+# config/initializers/n_plus_insight.rb
+NPlusInsight.configure do |config|
+  config.minimum_repetitions = 2
+  config.max_events = 100
+  config.mount_path = "/n_plus_insight"
+  config.on_page = true
+  config.raise_on_detection = false
+end
+```
+
+Start Rails, exercise the application, and visit:
+
+```text
+http://localhost:3000/n_plus_insight
+```
+
+### Environment-variable activation
+
+For containerized or remotely managed deployments, activation can be driven by
+an environment variable:
 
 ```ruby
 # config/initializers/n_plus_insight.rb
-if Rails.env.development?
-  NPlusInsight.configure do |config|
-    config.minimum_repetitions = 2
-    config.mount_path = "/n_plus_insight"
-    config.on_page = true
-    config.max_events = 100
-    config.raise_on_detection = false
-  end
+NPlusInsight.configure do |config|
+  config.enabled = ENV.fetch("NPLUS_INSIGHT_ENABLED", "false")
+    .match?(/\A(?:1|true|yes|on)\z/i)
+end
+```
+
+The gem uses the same `NPLUS_INSIGHT_ENABLED` parsing when `enabled` is not set
+explicitly. Its default value is `false`.
+
+## Configuration
+
+| Option | Default | Description |
+| --- | --- | --- |
+| `enabled` | `NPLUS_INSIGHT_ENABLED`, otherwise `false` | Enables request-level query collection and analysis. |
+| `minimum_repetitions` | `2` | Number of matching query shapes required to create a finding. |
+| `max_events` | `100` | Maximum number of findings retained for the dashboard. The oldest findings are removed first. |
+| `mount_path` | `"/n_plus_insight"` | Path used for the mounted dashboard and overlay assets. Configure this before the application finishes booting. |
+| `on_page` | `true` | Injects the status indicator and findings inspector into HTML responses. |
+| `raise_on_detection` | `false` | Raises when a request produces at least one finding. Useful in controlled tests or CI. |
+| `ignore_paths` | Asset and Active Storage paths | Array of regular expressions for request paths that should not be analyzed. |
+| `ignore_sql` | Transactions and Rails metadata | Array of regular expressions for SQL statements that should be ignored. |
+
+### Ignoring application paths
+
+```ruby
+NPlusInsight.configure do |config|
+  config.ignore_paths += [
+    %r{\A/health\z},
+    %r{\A/metrics\z}
+  ]
 end
 ```
-With `on_page` enabled, every HTML page also gets a small status circle in the
-bottom-right corner. It turns red and shows a count when the current request
-contains N+1 query patterns. Select it to inspect source lines, the affected
-model graph, and suggested fixes without leaving the page. Set
-`config.on_page = false` to remove the on-page tool while retaining collection
-and the full dashboard.
+
+### Ignoring known query patterns
+
+```ruby
+NPlusInsight.configure do |config|
+  config.ignore_sql += [
+    /FROM "audit_events"/i
+  ]
+end
+```
+
+## Dashboard and on-page inspector
+
+### On-page inspector
+
+When `on_page` is enabled, NPlusInsight injects a small status indicator into
+HTML responses:
+
+- green means no repeated query pattern was detected for that request;
+- red means one or more patterns were detected;
+- the badge shows the number of findings;
+- selecting the indicator opens source, model, and remediation details.
+
+Set `config.on_page = false` to disable response injection while continuing to
+collect findings for the mounted dashboard.
+
+### Mounted dashboard
+
+The dashboard is available at `mount_path`, which defaults to
+`/n_plus_insight`. It lists the most recent findings stored by the current Rails
+process and links to a detailed report for each finding. Use **Clear** to remove
+all stored findings. The dashboard retains at most `max_events`
+findings, rolling off the oldest finding whenever the configured limit is
+exceeded.
 
 ## How detection works
 
-The gem listens to `sql.active_record` events during each web request. It
-removes literal values from SQL and groups matching shapes. A shape repeated at
-least `minimum_repetitions` times is reported. Framework, gem, schema, cached,
-transaction, and asset requests are excluded.
+NPlusInsight subscribes to `sql.active_record` notifications while a web
+request is being processed.
+
+For each uncached `SELECT` query, it:
 
-This deliberately reports evidence rather than patching source automatically.
-Suggested fixes should be reviewed because scopes, polymorphic associations,
-and intentionally lazy-loaded data can change the best eager-loading strategy.
+1. captures the first relevant application stack frame;
+2. extracts tables referenced by `FROM` and `JOIN`;
+3. replaces literal strings and numbers with placeholders;
+4. groups queries with the same normalized shape;
+5. keeps shapes meeting `minimum_repetitions`;
+6. combines repeated shapes attributed to the same application source line into
+   one finding;
+7. inspects Active Record reflections to infer every relevant model association;
+8. renders the affected associations as a model tree;
+9. generates combined eager-loading and strict-loading suggestions for the
+   complete tree.
 
-## CI mode
+For example, if one serializer line lazily loads both `post.comments` and
+`post.likes`, NPlusInsight reports one finding with two query patterns, a
+`Post` tree branching to `Comment` and `Like`, and a combined remediation such
+as `Post.includes(:comments, :likes)`. Deeper paths are represented with nested
+`includes`, such as `User.includes({ posts: [:comments, :likes] })`.
 
-To turn findings into failures in a test or staging environment:
+Cached queries, schema activity, Rails metadata queries, transaction statements,
+and ignored requests are excluded.
+
+NPlusInsight reports evidence and candidate remediations; it does not modify
+application source code automatically.
+
+## Security and privacy
+
+Findings can contain:
+
+- local source paths and source-code excerpts;
+- normalized SQL shapes;
+- controller paths and request methods;
+- model and association names.
+
+The dashboard is intentionally not restricted to a specific Rails environment.
+If NPlusInsight is enabled on an internet-facing deployment, protect
+`mount_path` with application authentication, a VPN, network policy, or
+reverse-proxy access controls.
+
+NPlusInsight stores findings in process memory. It does not persist findings to
+a database or transmit them to an external service.
+
+## Operational considerations
+
+- **Process-local storage:** each Rails process maintains its own findings.
+  Findings are not shared between Puma workers, containers, or hosts.
+- **Ephemeral history:** findings are cleared when the Rails process restarts.
+- **HTML buffering:** the on-page inspector buffers eligible HTML responses so
+  it can inject the overlay before `</body>`.
+- **Non-HTML responses:** JSON, files, streams, and other response types are not
+  modified.
+- **Compressed responses:** responses already carrying `Content-Encoding` are
+  not modified by the on-page inspector.
+- **Heuristic detection:** repeated queries can be intentional. Review each
+  finding before changing loading behavior.
+- **Heuristic suggestions:** polymorphic relationships, custom scopes, and
+  indirect associations may require a different preload strategy than the
+  suggested code.
+
+For high-traffic production deployments, begin with `on_page = false`, use a
+small `max_events`, and evaluate overhead under representative load.
+
+## CI and test environments
+
+Enable `raise_on_detection` to turn a finding into a request failure:
 
 ```ruby
-config.raise_on_detection = true
+# config/environments/test.rb
+NPlusInsight.configure do |config|
+  config.enabled = true
+  config.on_page = false
+  config.raise_on_detection = true
+end
 ```
 
-The dashboard is not restricted to a particular Rails environment. If it is
-enabled on an internet-facing deployment, protect `/n_plus_insight` with your
-application's authentication, authorization, VPN, or reverse-proxy access
-controls because findings contain source paths, code excerpts, and SQL shapes.
+Use this mode selectively. Test setup, factories, and intentionally repeated
+queries can otherwise produce noisy failures.
+
+## Troubleshooting
+
+### The indicator does not appear
+
+Confirm that:
+
+- `config.enabled` and `config.on_page` are both `true`;
+- the response has a `text/html` content type;
+- the response is not already compressed;
+- the request path does not match `ignore_paths`;
+- the application's Content Security Policy permits same-origin scripts and
+  styles.
+
+### The indicator is green, but repeated queries appear in the Rails log
+
+Check whether the queries:
+
+- occur fewer times than `minimum_repetitions`;
+- are served from the Active Record query cache;
+- are not `SELECT` statements;
+- match an `ignore_sql` pattern;
+- execute outside the lifecycle of an HTTP request.
+
+### The dashboard is empty in a multi-process deployment
+
+The store is process-local. A request served by one worker is not visible in a
+dashboard request served by another worker.
+
+### Findings point to the correct line but suggest the wrong association
+
+Association inference is heuristic. Use the source location, SQL shape, and
+model graph as evidence, then apply the eager-loading strategy appropriate for
+the relation that feeds that code.
+
+## Development
+
+Install dependencies and run the test suite:
+
+```sh
+bundle install
+bundle exec rake test
+```
+
+Build the gem locally:
+
+```sh
+bundle exec rake build
+```
+
+The built package is written to `pkg/`.
+
+## Contributing
+
+[Bug reports](https://github.com/joryleech/NPlusInsight/issues/new/choose) and
+[pull requests](https://github.com/joryleech/NPlusInsight/pulls) are welcome.
+
+When proposing a change:
+
+1. include a focused reproduction or test;
+2. keep detection behavior deterministic;
+3. preserve environment-neutral configuration;
+4. verify both the mounted dashboard and on-page inspector when changing UI;
+5. run `bundle exec rake test`.
+
+Please avoid including production SQL, source code, credentials, or other
+sensitive application data in public issues.
 
 ## License
 
-MIT
+NPlusInsight is maintained by
+[Jory Leech](https://github.com/joryleech) and available under the
+[MIT License](LICENSE.txt).

data/app/assets/n_plus_insight/overlay.css

@@ -100,14 +100,22 @@
 #n1v-root .n1v-heading { margin: 0 0 8px !important; color: var(--n1v-text) !important; font: 650 13px/1.3 ui-sans-serif, system-ui, sans-serif !important; }
 #n1v-root .n1v-location { margin: 0 0 8px !important; color: var(--n1v-muted) !important; overflow-wrap: anywhere !important; font: 12px/1.4 ui-monospace, SFMono-Regular, Consolas, monospace !important; }
 #n1v-root .n1v-code { display: block !important; max-width: 100% !important; margin: 0 !important; padding: 10px 0 !important; overflow: auto !important; border-radius: 8px !important; background: var(--n1v-code) !important; color: #e4e7ec !important; font: 12px/1.5 ui-monospace, SFMono-Regular, Consolas, monospace !important; white-space: pre !important; }
+#n1v-root .n1v-code code { display: block !important; margin: 0 !important; padding: 0 12px !important; border: 0 !important; border-radius: 0 !important; background: transparent !important; color: inherit !important; font: inherit !important; white-space: inherit !important; }
 #n1v-root .n1v-line { display: grid !important; grid-template-columns: 38px minmax(0, 1fr) !important; min-width: max-content !important; padding: 0 12px !important; }
 #n1v-root .n1v-line.n1v-active { background: rgba(217, 45, 32, .28) !important; }
 #n1v-root .n1v-line-number { color: #98a2b3 !important; user-select: none !important; }
-#n1v-root .n1v-graph { display: flex !important; align-items: center !important; gap: 7px !important; min-height: 74px !important; overflow-x: auto !important; padding: 8px 0 !important; }
-#n1v-root .n1v-node { flex: 0 0 auto !important; min-width: 130px !important; padding: 10px 12px !important; border: 1px solid var(--n1v-accent) !important; border-radius: 9px !important; background: var(--n1v-accent-soft) !important; color: var(--n1v-text) !important; text-align: center !important; }
+#n1v-root .n1v-graph { min-height: 74px !important; overflow: auto !important; padding: 4px 0 !important; }
+#n1v-root .n1v-tree { margin: 0 !important; padding: 0 !important; list-style: none !important; }
+#n1v-root .n1v-tree .n1v-tree { margin-left: 18px !important; padding-left: 18px !important; border-left: 1px solid var(--n1v-border) !important; }
+#n1v-root .n1v-tree-item { position: relative !important; margin: 9px 0 !important; list-style: none !important; }
+#n1v-root .n1v-tree .n1v-tree > .n1v-tree-item::before { content: "" !important; position: absolute !important; left: -18px !important; top: 27px !important; width: 18px !important; border-top: 1px solid var(--n1v-border) !important; }
+#n1v-root .n1v-node { display: inline-grid !important; min-width: 130px !important; padding: 10px 12px !important; border: 1px solid var(--n1v-accent) !important; border-radius: 9px !important; background: var(--n1v-accent-soft) !important; color: var(--n1v-text) !important; text-align: center !important; }
 #n1v-root .n1v-node strong, #n1v-root .n1v-node small { display: block !important; color: inherit !important; }
 #n1v-root .n1v-node small { margin-top: 2px !important; color: var(--n1v-muted) !important; font-size: 11px !important; }
-#n1v-root .n1v-edge { flex: 0 0 auto !important; color: var(--n1v-muted) !important; text-align: center !important; font-size: 11px !important; }
+#n1v-root .n1v-edge { display: block !important; margin: 0 0 4px !important; color: var(--n1v-muted) !important; font-size: 11px !important; }
+#n1v-root .n1v-query { margin: 0 !important; padding: 8px 0 !important; border-top: 1px solid var(--n1v-border) !important; }
+#n1v-root .n1v-query:first-of-type { padding-top: 0 !important; border-top: 0 !important; }
+#n1v-root .n1v-query-meta { margin: 0 0 5px !important; color: var(--n1v-muted) !important; font: 11px/1.4 ui-sans-serif, system-ui, sans-serif !important; }
 #n1v-root .n1v-fix { margin: 0 !important; padding: 12px 0 !important; border-top: 1px solid var(--n1v-border) !important; }
 #n1v-root .n1v-fix:first-of-type { padding-top: 0 !important; border-top: 0 !important; }
 #n1v-root .n1v-fix-title { margin: 0 0 4px !important; color: var(--n1v-text) !important; font: 650 13px/1.4 ui-sans-serif, system-ui, sans-serif !important; }

data/app/assets/n_plus_insight/overlay.js

@@ -23,10 +23,33 @@
     }
   }
 
+  function queryGroupsFor(finding) {
+    if ((finding.query_groups || []).length) return finding.query_groups;
+    return [{
+      sql: finding.sql,
+      query_count: finding.query_count,
+      total_ms: finding.total_ms,
+      tables: []
+    }];
+  }
+
   var findings = decodePayload(root.dataset.payload || "");
+  var initialFindingIndex = findings.reduce(function (bestIndex, finding, index) {
+    var best = findings[bestIndex];
+    var patternCount = queryGroupsFor(finding).length;
+    var bestPatternCount = best ? queryGroupsFor(best).length : -1;
+
+    if (patternCount > bestPatternCount) return index;
+    if (patternCount === bestPatternCount && finding.query_count > best.query_count) return index;
+    return bestIndex;
+  }, 0);
+  var patternCount = findings.reduce(function (total, finding) {
+    return total + queryGroupsFor(finding).length;
+  }, 0);
+
   var launcher = element("button", "n1v-launcher" + (findings.length ? " n1v-has-alert" : ""), "N+1");
   launcher.type = "button";
-  launcher.setAttribute("aria-label", findings.length ? "Open NPlusInsight: " + findings.length + " detected" : "Open NPlusInsight: no detections");
+  launcher.setAttribute("aria-label", findings.length ? "Open NPlusInsight: " + findings.length + " affected source locations" : "Open NPlusInsight: no detections");
   launcher.setAttribute("aria-expanded", "false");
 
   if (findings.length) {
@@ -44,7 +67,14 @@
   var header = element("div", "n1v-header");
   var headingWrap = element("div");
   headingWrap.appendChild(element("h2", "n1v-title", findings.length ? "N+1 detected" : "No N+1 queries"));
-  headingWrap.appendChild(element("p", "n1v-subtitle", findings.length ? findings.length + " repeated query pattern" + (findings.length === 1 ? "" : "s") + " on this page" : "This request is clear"));
+  headingWrap.appendChild(element(
+    "p",
+    "n1v-subtitle",
+    findings.length ?
+      findings.length + " affected source location" + (findings.length === 1 ? "" : "s") +
+        " · " + patternCount + " query pattern" + (patternCount === 1 ? "" : "s") :
+      "This request is clear"
+  ));
   header.appendChild(headingWrap);
 
   var close = element("button", "n1v-close", "×");
@@ -70,6 +100,7 @@
       container.appendChild(section);
       return;
     }
+
     section.appendChild(element("p", "n1v-location", finding.location.path + ":" + finding.location.line));
     var pre = element("pre", "n1v-code");
     var code = element("code");
@@ -84,22 +115,60 @@
     container.appendChild(section);
   }
 
+  function renderQueries(container, finding) {
+    var section = element("section", "n1v-section");
+    section.appendChild(element("h3", "n1v-heading", "Repeated query patterns"));
+    queryGroupsFor(finding).forEach(function (group, index) {
+      var query = element("div", "n1v-query");
+      var tables = (group.tables || []).join(", ");
+      var metadata = "Pattern " + (index + 1) + " · " + group.query_count +
+        " queries · " + group.total_ms + " ms" + (tables ? " · " + tables : "");
+      query.appendChild(element("p", "n1v-query-meta", metadata));
+      appendCode(query, group.sql);
+      section.appendChild(query);
+    });
+    container.appendChild(section);
+  }
+
+  function renderTreeNode(entry) {
+    var item = element("li", "n1v-tree-item");
+    if (entry.association) {
+      item.appendChild(element(
+        "span",
+        "n1v-edge",
+        entry.association + (entry.macro ? " (" + entry.macro + ")" : "")
+      ));
+    }
+
+    var node = element("div", "n1v-node");
+    node.appendChild(element("strong", "", entry.name));
+    node.appendChild(element("small", "", entry.table));
+    item.appendChild(node);
+
+    if ((entry.children || []).length) {
+      var children = element("ul", "n1v-tree");
+      entry.children.forEach(function (child) {
+        children.appendChild(renderTreeNode(child));
+      });
+      item.appendChild(children);
+    }
+    return item;
+  }
+
   function renderGraph(container, finding) {
     var section = element("section", "n1v-section");
-    section.appendChild(element("h3", "n1v-heading", "Affected models"));
+    section.appendChild(element("h3", "n1v-heading", "Affected model tree"));
     var graph = element("div", "n1v-graph");
     graph.setAttribute("role", "img");
-    graph.setAttribute("aria-label", "Model associations involved in the repeated query");
-    (finding.models || []).forEach(function (model, index) {
-      if (index > 0) {
-        var edge = (finding.edges || [])[index - 1];
-        graph.appendChild(element("span", "n1v-edge", (edge && edge.association ? edge.association + " " : "") + "→"));
-      }
-      var node = element("div", "n1v-node");
-      node.appendChild(element("strong", "", model.name));
-      node.appendChild(element("small", "", model.table));
-      graph.appendChild(node);
+    graph.setAttribute("aria-label", "Tree of models and associations involved in the repeated queries");
+    var tree = element("ul", "n1v-tree");
+    var roots = finding.tree || (finding.models || []).map(function (model) {
+      return { name: model.name, table: model.table, children: [] };
+    });
+    roots.forEach(function (entry) {
+      tree.appendChild(renderTreeNode(entry));
     });
+    graph.appendChild(tree);
     section.appendChild(graph);
     container.appendChild(section);
   }
@@ -112,6 +181,7 @@
       var copy = element("button", "n1v-copy", "Copy");
       copy.type = "button";
       copy.addEventListener("click", function () {
+        if (!navigator.clipboard) return;
         navigator.clipboard.writeText(suggestion.code).then(function () {
           copy.textContent = "Copied";
           window.setTimeout(function () { copy.textContent = "Copy"; }, 1200);
@@ -136,7 +206,12 @@
       var tabs = element("div", "n1v-tabs");
       tabs.setAttribute("role", "tablist");
       findings.forEach(function (finding, tabIndex) {
-        var tab = element("button", "n1v-tab", "#" + (tabIndex + 1) + " · " + finding.query_count + " queries");
+        var groupCount = queryGroupsFor(finding).length;
+        var tab = element(
+          "button",
+          "n1v-tab",
+          "#" + (tabIndex + 1) + " · " + groupCount + " pattern" + (groupCount === 1 ? "" : "s")
+        );
         tab.type = "button";
         tab.setAttribute("role", "tab");
         tab.setAttribute("aria-selected", String(tabIndex === index));
@@ -149,6 +224,7 @@
     var finding = findings[index];
     renderSource(body, finding);
     renderGraph(body, finding);
+    renderQueries(body, finding);
     renderFixes(body, finding);
   }
 
@@ -167,7 +243,7 @@
     if (event.key === "Escape" && panel.getAttribute("aria-hidden") === "false") setOpen(false);
   });
 
-  renderFinding(0);
+  renderFinding(initialFindingIndex);
   root.appendChild(panel);
   root.appendChild(launcher);
 }());

data/app/controllers/n_plus_insight/detections_controller.rb

@@ -8,5 +8,10 @@ module NPlusInsight
       @detection = Store.find(params[:id])
       return head :not_found unless @detection
     end
+
+    def clear
+      Store.clear
+      redirect_to root_path, status: :see_other, notice: "Stored detections cleared."
+    end
   end
 end