feat: Request recordings

README.md

@@ -23,4 +23,4 @@ development, not ready for production use,  and the feature set is currently lim
 - Node 18+ supported.
 - Instruments all the files under current directory that aren't node_modules.
 - Only captures named `function`s and methods.
-- Only whole process recording and Jest, mocha, vitest per-test recordings.
+- Remote recording not supported yet.

src/Recording.ts

@@ -14,7 +14,7 @@ import compactObject from "./util/compactObject";
 
 export default class Recording {
   constructor(type: AppMap.RecorderType, recorder: string, ...names: string[]) {
-    const dirs = [recorder, ...names];
+    const dirs = [recorder, ...names].map(quotePathSegment);
     const name = dirs.pop()!; // it must have at least one element
     this.path = join(appMapDir, ...dirs, makeAppMapFilename(name));
     this.stream = new AppMapStream(this.path);
@@ -211,3 +211,7 @@ function makeAppMapFilename(name: string): string {
   // TODO make sure it isn't too long
   return name + ".appmap.json";
 }
+
+function quotePathSegment(value: string): string {
+  return value.replaceAll(/[/\\]/g, "-");
+}

src/hooks/http.ts

@@ -1,12 +1,14 @@
 import assert from "node:assert";
-import { ClientRequest } from "node:http";
 import type http from "node:http";
+import { ClientRequest } from "node:http";
 import type https from "node:https";
 import { URL } from "node:url";
 
 import type AppMap from "../AppMap";
+import Recording from "../Recording";
+import { info } from "../message";
 import { parameter } from "../parameter";
-import { recording } from "../recorder";
+import { recording, start } from "../recorder";
 import { getTime } from "../util/getTime";
 
 type HTTP = typeof http | typeof https;
@@ -111,6 +113,7 @@ function handleRequest(request: http.IncomingMessage, response: http.ServerRespo
   if (requests.has(request)) return;
   if (!(request.method && request.url)) return;
   const url = new URL(request.url, "http://example");
+  const timestamp = startRequestRecording(url.pathname);
   const requestEvent = recording.httpRequest(
     request.method,
     url.pathname,
@@ -121,8 +124,7 @@ function handleRequest(request: http.IncomingMessage, response: http.ServerRespo
   const startTime = getTime();
   requests.add(request);
   response.once("finish", () => {
-    if (fixupEvent(request, requestEvent)) recording.fixup(requestEvent);
-    handleResponse(requestEvent, startTime, response);
+    handleResponse(request, requestEvent, startTime, timestamp, response);
   });
 }
 
@@ -184,16 +186,31 @@ function normalizeHeaders(
 }
 
 function handleResponse(
+  request: http.IncomingMessage,
   requestEvent: AppMap.HttpServerRequestEvent,
   startTime: number,
+  timestamp: string,
   response: http.ServerResponse<http.IncomingMessage>,
 ): void {
+  if (fixupEvent(request, requestEvent)) recording.fixup(requestEvent);
   recording.httpResponse(
     requestEvent.id,
     getTime() - startTime,
     response.statusCode,
     normalizeHeaders(response.getHeaders()),
   );
+  const { request_method, path_info } = requestEvent.http_server_request;
+  recording.metadata.name = `${request_method} ${path_info} (${response.statusCode}) — ${timestamp}`;
+  recording.finish();
+  info("Wrote %s", recording.path);
+  start(); // just so there's always a recording running
+}
+
+function startRequestRecording(pathname: string): string {
+  recording.abandon();
+  const timestamp = new Date().toISOString();
+  start(new Recording("requests", "requests", [timestamp, pathname].join(" ")));
+  return timestamp;
 }
 
 function capitalize(str: string): string {

src/recorder.ts

@@ -9,7 +9,7 @@ import { FunctionInfo } from "./registry";
 import commonPathPrefix from "./util/commonPathPrefix";
 import { getTime } from "./util/getTime";
 
-export let recording: Recording = new Recording("process", "process", new Date().toISOString());
+export let recording: Recording;
 
 export function record<This, Return>(
   this: This,
@@ -64,11 +64,15 @@ function isNullPrototype(obj: unknown) {
   return obj != null && Object.getPrototypeOf(obj) === null;
 }
 
-export function start(newRecording: Recording) {
-  assert(!recording.running);
+export function start(
+  newRecording: Recording = new Recording("process", "process", new Date().toISOString()),
+) {
+  assert(!recording?.running);
   recording = newRecording;
 }
 
+start();
+
 process.on("exit", () => {
   recording.finish();
   if (writtenAppMaps.length === 1) info("Wrote %s", writtenAppMaps[0]);