midline-agent 0.3.0 → 0.4.1

package/test/helpers.js

@@ -90,6 +90,59 @@ async function startCollector({ tls, respond } = {}) {
   };
 }
 
+/**
+ * A fake ingest gateway: a real socket.io server on the `/ingest` namespace,
+ * recording what it receives and acking with whatever `respond` returns
+ * (defaulting to "everything accepted"). Shaped like `startCollector` so most
+ * assertions port over unchanged: `requests`, `events()`, `setResponder()`, `close()`.
+ */
+async function startSocketCollector({ tls, respond, noAck } = {}) {
+  const { Server } = require("socket.io");
+  const requests = [];
+  let responder =
+    respond ||
+    ((record) => ({ ok: true, accepted: (record.body?.events || []).length, rejected: 0 }));
+
+  const httpServer = tls ? https.createServer(tls) : http.createServer();
+  await new Promise((resolve) => httpServer.listen(0, "127.0.0.1", resolve));
+  const { port } = httpServer.address();
+
+  const io = new Server(httpServer, { cors: { origin: "*" } });
+  const nsp = io.of("/ingest");
+  nsp.on("connection", (socket) => {
+    socket.on("ingest", (payload, ack) => {
+      const record = {
+        // Old HTTP-era assertions read the key off a header; a synthesized one
+        // keeps those checks meaningful without rewriting every one of them.
+        headers: { ...socket.handshake.headers, "x-api-key": socket.handshake.auth?.apiKey },
+        auth: socket.handshake.auth,
+        body: payload,
+      };
+      requests.push(record);
+      // Simulates a connected server that never answers, so callers can exercise
+      // the SDK's per-emit ack timeout rather than its connect timeout.
+      if (noAck) return;
+      ack(responder(record, requests.length));
+    });
+  });
+
+  return {
+    url: `${tls ? "https" : "http"}://${tls ? "localhost" : "127.0.0.1"}:${port}`,
+    port,
+    requests,
+    events: () => requests.flatMap((request) => (request.body && request.body.events) || []),
+    setResponder: (fn) => {
+      responder = fn;
+    },
+    close: () =>
+      new Promise((resolve) => {
+        io.close();
+        httpServer.closeAllConnections?.();
+        httpServer.close(() => resolve());
+      }),
+  };
+}
+
 /** Starts any request listener on an ephemeral loopback port. */
 async function listen(listener, tls) {
   const server = tls ? https.createServer(tls, listener) : http.createServer(listener);
@@ -148,4 +201,4 @@ async function waitFor(predicate, timeoutMs = 3000) {
   return false;
 }
 
-module.exports = { makeCerts, startCollector, listen, request, closedPort, diagnostics, waitFor };
+module.exports = { makeCerts, startCollector, startSocketCollector, listen, request, closedPort, diagnostics, waitFor };

package/test/middleware.test.js

@@ -5,10 +5,10 @@ const assert = require("node:assert/strict");
 const express = require("express");
 const { MidlineAgent, midlineMiddleware, midlineErrorHandler, getRequestContext } = require("../dist");
 const { REDACTED } = require("../dist/redact");
-const { startCollector, listen, request, closedPort, waitFor } = require("./helpers");
+const { startSocketCollector, listen, request, closedPort, waitFor } = require("./helpers");
 
 test("express: captured headers, query and bodies are redacted before they leave the process", async () => {
-  const collector = await startCollector();
+  const collector = await startSocketCollector();
   const agent = new MidlineAgent({
     apiKey: "ak_mw",
     endpoint: collector.url,
@@ -74,7 +74,7 @@ test("express: captured headers, query and bodies are redacted before they leave
 });
 
 test("express: nothing is captured beyond method/path/status unless asked", async () => {
-  const collector = await startCollector();
+  const collector = await startSocketCollector();
   const agent = new MidlineAgent({ apiKey: "ak_mw", endpoint: collector.url, flushIntervalMs: 60_000 });
   const app = express();
   app.use(midlineMiddleware({ agent }));
@@ -100,7 +100,7 @@ test("express: nothing is captured beyond method/path/status unless asked", asyn
 });
 
 test("express: errors are recorded and still reach the app's own handler", async () => {
-  const collector = await startCollector();
+  const collector = await startSocketCollector();
   const agent = new MidlineAgent({ apiKey: "ak_mw", endpoint: collector.url, flushIntervalMs: 60_000 });
   const app = express();
   app.use(midlineMiddleware({ agent }));
@@ -154,7 +154,7 @@ test("the host app is unaffected when the Midline server is unreachable or the a
 });
 
 test("plain node http servers work with the same middleware", async () => {
-  const collector = await startCollector();
+  const collector = await startSocketCollector();
   const agent = new MidlineAgent({ apiKey: "ak_mw", endpoint: collector.url, flushIntervalMs: 60_000 });
   const middleware = midlineMiddleware({ agent });
   const server = await listen((req, res) => {

package/test/proxy.test.js

@@ -5,7 +5,7 @@ const assert = require("node:assert/strict");
 const net = require("net");
 const { MidlineAgent, createMidlineProxy, startMidlineProxy, ConfigError } = require("../dist");
 const { REDACTED } = require("../dist/redact");
-const { makeCerts, startCollector, listen, request, closedPort, waitFor } = require("./helpers");
+const { makeCerts, startSocketCollector, listen, request, closedPort, waitFor } = require("./helpers");
 
 const certs = makeCerts();
 const needsOpenssl = certs ? {} : { skip: "openssl not available" };
@@ -27,7 +27,7 @@ function echo(req, res) {
 }
 
 async function setup({ target, collectorOptions, agentOptions, proxyOptions } = {}) {
-  const collector = await startCollector(collectorOptions);
+  const collector = await startSocketCollector(collectorOptions);
   const agent = new MidlineAgent({ apiKey: "ak_proxy", endpoint: collector.url, flushIntervalMs: 60_000, ...agentOptions });
   const server = await startMidlineProxy({ target, port: 0, agent, onError: () => {}, ...proxyOptions });
   const base = `http://127.0.0.1:${server.address().port}`;
@@ -93,7 +93,7 @@ test("forwards to the destination and reports the exchange to Midline separately
     await waitFor(() => ctx.agent.queued === 1);
     await ctx.agent.flush();
     const [event] = ctx.collector.events();
-    assert.equal(ctx.collector.requests[0].url, "/api/api-monitor/events/batch", "events go to Midline, not the destination");
+    assert.equal(ctx.collector.requests.length, 1, "events go to Midline, not the destination");
     assert.equal(event.route, "/v1/items");
     assert.equal(event.metadata.integrationType, "proxy");
     assert.equal(event.metadata.requestId, "rid-7");
@@ -254,7 +254,7 @@ test("https destination with a private CA: trusted only via targetCa, never by d
 
 test("the destination CA and the Midline CA are independent", needsOpenssl, async () => {
   const destination = await listen(echo, certs.trusted);
-  const collector = await startCollector({ tls: certs.selfSigned });
+  const collector = await startSocketCollector({ tls: certs.selfSigned });
   const agent = new MidlineAgent({ apiKey: "ak_proxy", endpoint: collector.url, flushIntervalMs: 60_000, onError: () => {} });
   const server = await startMidlineProxy({ target: `https://localhost:${destination.port}`, targetCa: certs.ca, port: 0, agent });
   try {

package/tsconfig.esm.json

@@ -0,0 +1,14 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "ES2020",
+    "moduleResolution": "node",
+    "outDir": "dist/esm",
+    "declaration": false
+  },
+  "include": [
+    "src/browser",
+    "src/redact.ts",
+    "src/types.ts"
+  ]
+}

package/src/transport.ts

@@ -1,125 +0,0 @@
-import * as http from "http";
-import * as https from "https";
-
-export interface PostResult {
-  status: number;
-  headers: http.IncomingHttpHeaders;
-  body: string;
-}
-
-export interface TransportOptions {
-  /** Full trust store for https, or undefined for Node's default. Verification is never disabled. */
-  ca?: Array<string | Buffer>;
-  connectTimeoutMs: number;
-  timeoutMs: number;
-  userAgent: string;
-  /** Response bodies are only read for diagnostics; anything past this is discarded. */
-  maxResponseBytes?: number;
-}
-
-/** A transport failure with a stable `code`, including the two timeouts Node doesn't name. */
-export class TransportError extends Error {
-  constructor(message: string, readonly code: string) {
-    super(message);
-    this.name = "TransportError";
-  }
-}
-
-/**
- * Minimal JSON POST over Node's own http/https.
- *
- * Node's modules rather than fetch because this needs things fetch doesn't expose
- * portably: a per-endpoint CA that extends rather than replaces the trust store, a
- * connect timeout separate from the request deadline, and sockets that don't keep
- * the host process alive.
- */
-export class Transport {
-  private readonly agent: http.Agent;
-
-  constructor(origin: URL, private readonly options: TransportOptions) {
-    this.agent = origin.protocol === "https:"
-      ? new https.Agent({ keepAlive: true, maxSockets: 4, ca: options.ca })
-      : new http.Agent({ keepAlive: true, maxSockets: 4 });
-  }
-
-  post(url: URL, body: string, headers: Record<string, string>, keepProcessAlive: boolean): Promise<PostResult> {
-    const { connectTimeoutMs, timeoutMs } = this.options;
-    const maxResponseBytes = this.options.maxResponseBytes ?? 64 * 1024;
-    const isHttps = url.protocol === "https:";
-
-    return new Promise<PostResult>((resolve, reject) => {
-      let settled = false;
-      let connectTimer: NodeJS.Timeout | undefined;
-
-      const settle = (fn: () => void) => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(deadline);
-        if (connectTimer) clearTimeout(connectTimer);
-        fn();
-      };
-
-      const request = (isHttps ? https : http).request(url, {
-        method: "POST",
-        agent: this.agent,
-        headers: {
-          ...headers,
-          "content-type": "application/json",
-          "content-length": String(Buffer.byteLength(body)),
-          "user-agent": this.options.userAgent,
-        },
-      });
-
-      const deadline = setTimeout(() => {
-        request.destroy(new TransportError(`no response within ${timeoutMs}ms`, "ETIMEDOUT"));
-      }, timeoutMs);
-
-      request.on("socket", (socket) => {
-        if (!keepProcessAlive) {
-          socket.unref();
-        } else {
-          socket.ref();
-        }
-        // A pooled keep-alive socket is already connected; only time fresh ones.
-        // The overall deadline still covers a handshake that stalls after connect.
-        if ((socket as any).connecting) {
-          connectTimer = setTimeout(() => {
-            request.destroy(new TransportError(`connection not established within ${connectTimeoutMs}ms`, "ECONNECT_TIMEOUT"));
-          }, connectTimeoutMs);
-          socket.once(isHttps ? "secureConnect" : "connect", () => clearTimeout(connectTimer));
-        }
-      });
-
-      request.on("response", (response) => {
-        const chunks: Buffer[] = [];
-        let received = 0;
-        response.on("data", (chunk: Buffer) => {
-          if (received < maxResponseBytes) {
-            chunks.push(chunk.subarray(0, maxResponseBytes - received));
-          }
-          received += chunk.length;
-        });
-        response.on("end", () =>
-          settle(() =>
-            resolve({
-              status: response.statusCode ?? 0,
-              headers: response.headers,
-              body: Buffer.concat(chunks).toString("utf8"),
-            }),
-          ),
-        );
-        response.on("error", (err) => settle(() => reject(err)));
-        response.on("aborted", () =>
-          settle(() => reject(new TransportError("response aborted by the server", "ECONNRESET"))),
-        );
-      });
-
-      request.on("error", (err) => settle(() => reject(err)));
-      request.end(body);
-    });
-  }
-
-  destroy(): void {
-    this.agent.destroy();
-  }
-}