backlens 0.2.4 → 0.2.5

package/README.md

@@ -151,7 +151,7 @@ cd backlens && npm install
 node --test test/
 ```
 
-Bug reports and pull requests are welcome.
+Bug reports and pull requests are welcome: see [CONTRIBUTING.md](CONTRIBUTING.md). To report a security problem privately, see [SECURITY.md](SECURITY.md).
 
 ## License
 

package/analyze.js

@@ -237,8 +237,8 @@ function percentile(values, p) {
 
 /** Routes and issues across every trace kept. */
 /**
- * fixed: issue key -> when a fix for it was kept. Such an issue is hidden until a request after
- * that moment shows it again.
+ * fixed: issue key -> when a fix for it was kept, and 'route:<route>' -> when code behind that
+ * route changed. Such issues are hidden until a request after that moment shows them again.
  */
 export function summarize(traces, known = [], advice = [], fixed = new Map()) {
   const routes = new Map();
@@ -323,7 +323,8 @@ export function summarize(traces, known = [], advice = [], fixed = new Map()) {
     if (!routes.has(route)) routes.set(route, { route, calls: 0, durations: [], queries: 0, redis: 0, http: 0, errors: 0, issueKeys: new Set(), last: 0 });
   }
   for (const [key, issue] of issues) {
-    if (fixed.has(key) && fixed.get(key) >= (issue.lastAt || 0)) {
+    const since = Math.max(fixed.get(key) || 0, fixed.get(`route:${issue.route}`) || 0);
+    if (since && since >= (issue.lastAt || 0)) {
       issues.delete(key);
       routes.get(issue.route)?.issueKeys.delete(key);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backlens",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "description": "Run your Node backend through backlens and see every request, every query, and what is wrong with them.",
   "license": "MIT",
   "type": "module",

package/server.js

@@ -35,6 +35,20 @@ export function startServer({ port, root = process.cwd(), token, manualArgv = nu
   // Issue key -> the index created for it from the dashboard, so Undo still knows it.
   const createdIndexes = new Map();
 
+  /** Sends a recorded read to the app without recording it, so the app opens its connections. */
+  function warmUp(port, payload) {
+    return new Promise((resolve) => {
+      const r = http.request({ host: '127.0.0.1', port, method: payload.method, path: payload.url, headers: { ...payload.headers, 'x-backlens': 'skip' } }, (res) => {
+        res.resume();
+        res.on('end', resolve);
+      });
+      r.setTimeout(20000, () => r.destroy());
+      r.on('error', resolve);
+      r.on('close', resolve);
+      r.end();
+    });
+  }
+
   /** Sends one command to the recorder inside the app (see register.cjs). */
   function appCommand(port, body) {
     return new Promise((resolve, reject) => {
@@ -337,14 +351,24 @@ export function startServer({ port, root = process.cwd(), token, manualArgv = nu
       if (!app || !app.port) return json(res, 409, { error: 'The app is not running. Start it first.' });
       const body = (await readJson(req)) || {};
       let index = null;
+      const { issues } = summarize(traces, [...known.keys()], [...advice.values()]);
+      const issue = issues.find((i) => i.key === body.key);
       if (action !== 'info') {
-        const { issues } = summarize(traces, [...known.keys()], [...advice.values()]);
-        const issue = issues.find((i) => i.key === body.key);
         index = issue && issue.index ? issue.index : createdIndexes.get(body.key);
         if (!index) return json(res, 404, { error: 'That suggestion is gone. Refresh the list.' });
       }
       try {
-        const out = await appCommand(app.port, { action, ...(index || {}) });
+        let out;
+        try {
+          out = await appCommand(app.port, { action, ...(index || {}) });
+        } catch (err) {
+          // A restarted app has no database connection until a request uses one. Replay the
+          // request that showed the issue once, unrecorded, so it opens one, then try again.
+          const payload = issue && replays.get(issue.example);
+          if (!/not used Postgres yet/.test(err.message) || !payload || !['GET', 'HEAD'].includes(payload.method)) throw err;
+          await warmUp(app.port, payload);
+          out = await appCommand(app.port, { action, ...(index || {}) });
+        }
         if (action === 'create') {
           createdIndexes.set(body.key, index);
           fixedAt.set(body.key, Date.now());
@@ -425,14 +449,18 @@ export function startServer({ port, root = process.cwd(), token, manualArgv = nu
         // Recorded requests on a route since the last fix kept there (the code they ran is the
         // code being changed now), oldest first.
         routeTraces: (route) => {
-          const since = Math.max(0, ...[...fixedAt].filter(([key]) => key.split('|')[1] === route).map(([, at]) => at));
+          const since = fixedAt.get(`route:${route}`) || 0;
           return traces.filter((t) => t.at > since && routeOf(t.method, t.url, t.template) === route);
         },
         markFixed: (key, after) => {
-          fixedAt.set(key, Date.now());
+          const now = Date.now();
+          fixedAt.set(key, now);
+          // The code behind this route changed: issues from its older requests point at old
+          // lines, so they wait for a request on the new code (the after-fix one below, or later).
+          fixedAt.set(`route:${key.split('|')[1]}`, now);
           if (after) {
             const { replayOf, ...trace } = after;
-            traces.push({ ...trace, afterFix: true });
+            traces.push({ ...trace, at: now + 1, afterFix: true });
             received++;
             if (traces.length > KEEP) replays.delete(traces.shift().id);
           }

package/ui.html

@@ -790,7 +790,7 @@ function compareCard(j) {
 let idx = {};
 async function loadIndexInfo() {
   idx.loading = true;
-  try { idx.db = await aiPost('/api/index/info', {}); } catch (err) { idx.dbError = err.message; }
+  try { idx.db = await aiPost('/api/index/info', { key: fixJob && fixJob.issueKey }); } catch (err) { idx.dbError = err.message; }
   idx.loading = false;
   renderFix();
 }