@terreno/api 0.20.1 → 0.21.0

package/src/githubAuth.test.ts

@@ -8,10 +8,10 @@ import supertest from "supertest";
 import type TestAgent from "supertest/lib/agent";
 
 import {generateTokens, type UserModel} from "./auth";
-import {setupServer} from "./expressServer";
 import {type GitHubUserFields, githubUserPlugin, setupGitHubAuth} from "./githubAuth";
 import {logger} from "./logger";
 import {createdUpdatedPlugin, isDisabledPlugin} from "./plugins";
+import {TerrenoApp} from "./terrenoApp";
 
 interface FakeStrategyOutcome {
   type: "success" | "redirect" | "fail";
@@ -142,8 +142,8 @@ describe("GitHub auth routes", () => {
       router.get("/test", (_req, res) => res.json({ok: true}));
     }
 
-    app = setupServer({
-      addRoutes,
+    app = new TerrenoApp({
+      configureApp: addRoutes,
       githubAuth: {
         allowAccountLinking: true,
         callbackURL: "http://localhost:9000/auth/github/callback",
@@ -152,7 +152,7 @@ describe("GitHub auth routes", () => {
       },
       skipListen: true,
       userModel: GitHubTestUserModel as any,
-    });
+    }).build();
     agent = supertest.agent(app);
   });
 
@@ -249,11 +249,11 @@ describe("GitHub auth disabled", () => {
     }
 
     // Setup server WITHOUT GitHub auth
-    app = setupServer({
-      addRoutes,
+    app = new TerrenoApp({
+      configureApp: addRoutes,
       skipListen: true,
       userModel: GitHubTestUserModel as any,
-    });
+    }).build();
     agent = supertest.agent(app);
   });
 
@@ -517,8 +517,8 @@ describe("addGitHubAuthRoutes link endpoints", () => {
       router.get("/test", (_req, res) => res.json({ok: true}));
     }
 
-    app = setupServer({
-      addRoutes,
+    app = new TerrenoApp({
+      configureApp: addRoutes,
       githubAuth: {
         allowAccountLinking: true,
         callbackURL: "http://localhost:9000/auth/github/callback",
@@ -527,7 +527,7 @@ describe("addGitHubAuthRoutes link endpoints", () => {
       },
       skipListen: true,
       userModel: GitHubTestUserModel as any,
-    });
+    }).build();
     agent = supertest.agent(app);
   });
 
@@ -586,10 +586,10 @@ describe("GitHub callback handler (fake strategy)", () => {
       router.get("/test", (_req, res) => res.json({ok: true}));
     }
 
-    app = setupServer({
-      addMiddleware: (a) => {
+    app = new TerrenoApp({
+      beforeJsonSetup: (a) => {
         // The handler reads (req as unknown as {session?: {returnTo?: string}}).session?.returnTo.
-        // setupServer does not install express-session, so prime a fake session from a request
+        // TerrenoApp does not install express-session, so prime a fake session from a request
         // header for tests.
         a.use((req, _res, next) => {
           const headerReturnTo = req.headers["x-mock-return-to"];
@@ -599,7 +599,7 @@ describe("GitHub callback handler (fake strategy)", () => {
           next();
         });
       },
-      addRoutes,
+      configureApp: addRoutes,
       githubAuth: {
         allowAccountLinking: true,
         callbackURL: "http://localhost:9000/auth/github/callback",
@@ -608,8 +608,8 @@ describe("GitHub callback handler (fake strategy)", () => {
       },
       skipListen: true,
       userModel: GitHubTestUserModel as unknown as UserModel,
-    });
-    // Swap the github strategy with our fake after setupServer registered it.
+    }).build();
+    // Swap the github strategy with our fake after TerrenoApp registered it.
     installFakeGithubStrategy();
     agent = supertest.agent(app);
   });
@@ -691,8 +691,8 @@ describe("GET /auth/github/link with JWT (fake strategy)", () => {
       router.get("/test", (_req, res) => res.json({ok: true}));
     }
 
-    app = setupServer({
-      addRoutes,
+    app = new TerrenoApp({
+      configureApp: addRoutes,
       githubAuth: {
         allowAccountLinking: true,
         callbackURL: "http://localhost:9000/auth/github/callback",
@@ -701,7 +701,7 @@ describe("GET /auth/github/link with JWT (fake strategy)", () => {
       },
       skipListen: true,
       userModel: GitHubTestUserModel as unknown as UserModel,
-    });
+    }).build();
     installFakeGithubStrategy();
     agent = supertest.agent(app);
   });
@@ -746,8 +746,8 @@ describe("DELETE /auth/github/unlink edge cases", () => {
       router.get("/test", (_req, res) => res.json({ok: true}));
     }
 
-    app = setupServer({
-      addRoutes,
+    app = new TerrenoApp({
+      configureApp: addRoutes,
       githubAuth: {
         allowAccountLinking: true,
         callbackURL: "http://localhost:9000/auth/github/callback",
@@ -756,7 +756,7 @@ describe("DELETE /auth/github/unlink edge cases", () => {
       },
       skipListen: true,
       userModel: GitHubTestUserModel as unknown as UserModel,
-    });
+    }).build();
     installFakeGithubStrategy();
     agent = supertest.agent(app);
   });

package/src/logger.test.ts

@@ -2,9 +2,19 @@ import {afterEach, beforeEach, describe, expect, it} from "bun:test";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import {Writable} from "node:stream";
 import winston from "winston";
 
-import {logger, setupLogging} from "./logger";
+import {
+  createFeatureFlaggedLogger,
+  createScopedLogger,
+  formatLogContextSuffix,
+  logger,
+  setupLogging,
+  type TerrenoRequestLogEntry,
+  winstonLogger,
+} from "./logger";
+import {runWithRequestContext} from "./requestContext";
 
 describe("logger", () => {
   const OLD_ENV = process.env;
@@ -47,6 +57,420 @@ describe("logger", () => {
   });
 });
 
+describe("formatLogContextSuffix", () => {
+  it("includes request ids and sorts terrenoLabels for stable output", () => {
+    const suffix = formatLogContextSuffix({
+      requestId: "r1",
+      terrenoLabels: {alpha: "a", zebra: "z"},
+    });
+    expect(suffix).toContain("requestId=r1");
+    expect(suffix.indexOf("alpha=a")).toBeLessThan(suffix.indexOf("zebra=z"));
+  });
+
+  it("returns empty string when no fields are set", () => {
+    expect(formatLogContextSuffix({})).toBe("");
+  });
+
+  it("includes terrenoLogPrefix in suffix", () => {
+    const suffix = formatLogContextSuffix({
+      requestId: "r1",
+      terrenoLogPrefix: "[Job]",
+    });
+    expect(suffix).toContain("logPrefix=[Job]");
+    expect(suffix).toContain("requestId=r1");
+  });
+});
+
+describe("createScopedLogger", () => {
+  afterEach(() => {
+    setupLogging({disableFileLogging: true});
+  });
+
+  it("returns the global logger when prefix and labels are empty", () => {
+    expect(createScopedLogger({})).toBe(logger);
+    expect(createScopedLogger({labels: {skipped: undefined}})).toBe(logger);
+  });
+
+  it("prefixes messages when only prefix is set", () => {
+    const lines: string[] = [];
+    const snapshots: Array<{terrenoLogPrefix?: unknown}> = [];
+    const captureTransport = new winston.transports.Stream({
+      format: winston.format.combine(
+        winston.format((info) => {
+          snapshots.push({
+            terrenoLogPrefix: (info as {terrenoLogPrefix?: unknown}).terrenoLogPrefix,
+          });
+          return info;
+        })(),
+        winston.format.printf((info) => {
+          const msg = typeof info.message === "string" ? info.message : String(info.message);
+          return `${info.level}: ${msg}`;
+        })
+      ),
+      stream: new Writable({
+        write(chunk, _encoding, callback): void {
+          lines.push(chunk.toString().trim());
+          callback();
+        },
+      }),
+    });
+    winstonLogger.add(captureTransport);
+    try {
+      createScopedLogger({prefix: "[ScopedTest]"}).info("hello");
+    } finally {
+      winstonLogger.remove(captureTransport);
+    }
+    expect(lines.some((l) => l.includes("[ScopedTest]") && l.includes("hello"))).toBe(true);
+    expect(snapshots.some((s) => s.terrenoLogPrefix === "[ScopedTest]")).toBe(true);
+  });
+
+  it("attaches terrenoLabels to winston metadata for structured transports", () => {
+    const snapshots: Array<{level?: string; message?: unknown; terrenoLabels?: unknown}> = [];
+    const captureTransport = new winston.transports.Stream({
+      format: winston.format((info) => {
+        snapshots.push({
+          level: info.level,
+          message: info.message,
+          terrenoLabels: (info as {terrenoLabels?: unknown}).terrenoLabels,
+        });
+        return info;
+      })(),
+      stream: new Writable({
+        write(_chunk, _encoding, callback): void {
+          callback();
+        },
+      }),
+    });
+    winstonLogger.add(captureTransport);
+    try {
+      createScopedLogger({labels: {billingId: "b1"}}).warn("charged");
+    } finally {
+      winstonLogger.remove(captureTransport);
+    }
+    expect(
+      snapshots.some(
+        (s) => (s.terrenoLabels as {billingId?: string} | undefined)?.billingId === "b1"
+      )
+    ).toBe(true);
+  });
+
+  it("includes terrenoLogPrefix alongside terrenoLabels in metadata", () => {
+    const snapshots: Array<{terrenoLogPrefix?: unknown; terrenoLabels?: unknown}> = [];
+    const captureTransport = new winston.transports.Stream({
+      format: winston.format((info) => {
+        snapshots.push({
+          terrenoLabels: (info as {terrenoLabels?: unknown}).terrenoLabels,
+          terrenoLogPrefix: (info as {terrenoLogPrefix?: unknown}).terrenoLogPrefix,
+        });
+        return info;
+      })(),
+      stream: new Writable({
+        write(_chunk, _encoding, callback): void {
+          callback();
+        },
+      }),
+    });
+    winstonLogger.add(captureTransport);
+    try {
+      createScopedLogger({labels: {x: "1"}, prefix: "[Both]"}).info("m");
+    } finally {
+      winstonLogger.remove(captureTransport);
+    }
+    expect(
+      snapshots.some(
+        (s) =>
+          (s.terrenoLabels as {x?: string} | undefined)?.x === "1" &&
+          (s.terrenoLogPrefix as string | undefined) === "[Both]"
+      )
+    ).toBe(true);
+  });
+
+  it("merges all request context fields including jobId, sessionId, spanId, traceId, traceSampled", () => {
+    const snapshots: Array<Record<string, unknown>> = [];
+    const captureTransport = new winston.transports.Stream({
+      format: winston.format((info) => {
+        snapshots.push({
+          jobId: info.jobId,
+          requestId: info.requestId,
+          sessionId: info.sessionId,
+          spanId: info.spanId,
+          traceId: info.traceId,
+          traceSampled: info.traceSampled,
+          userId: info.userId,
+        });
+        return info;
+      })(),
+      stream: new Writable({
+        write(_chunk, _encoding, callback): void {
+          callback();
+        },
+      }),
+    });
+    winstonLogger.add(captureTransport);
+    try {
+      runWithRequestContext(
+        {
+          jobId: "job-42",
+          requestId: "req-full",
+          sessionId: "sess-7",
+          spanId: "span-abc",
+          traceId: "trace-xyz",
+          traceSampled: true,
+          userId: "user-1",
+        },
+        () => {
+          logger.info("full context");
+        }
+      );
+    } finally {
+      winstonLogger.remove(captureTransport);
+    }
+    const entry = snapshots.find((s) => s.requestId === "req-full");
+    expect(entry).toBeDefined();
+    expect(entry?.jobId).toBe("job-42");
+    expect(entry?.sessionId).toBe("sess-7");
+    expect(entry?.spanId).toBe("span-abc");
+    expect(entry?.traceId).toBe("trace-xyz");
+    expect(entry?.traceSampled).toBe(true);
+    expect(entry?.userId).toBe("user-1");
+  });
+
+  it("exercises all scoped logger methods (debug, error, catch)", () => {
+    const lines: string[] = [];
+    const captureTransport = new winston.transports.Stream({
+      format: winston.format.printf((info) => {
+        const msg = typeof info.message === "string" ? info.message : String(info.message);
+        return `${info.level}: ${msg}`;
+      }),
+      stream: new Writable({
+        write(chunk, _encoding, callback): void {
+          lines.push(chunk.toString().trim());
+          callback();
+        },
+      }),
+    });
+    winstonLogger.add(captureTransport);
+    try {
+      const scoped = createScopedLogger({prefix: "[Methods]"});
+      scoped.debug("d-msg");
+      scoped.error("e-msg");
+      scoped.catch(new Error("caught-msg"));
+    } finally {
+      winstonLogger.remove(captureTransport);
+    }
+    expect(lines.some((l) => l.includes("[Methods]") && l.includes("d-msg"))).toBe(true);
+    expect(lines.some((l) => l.includes("[Methods]") && l.includes("e-msg"))).toBe(true);
+    expect(lines.some((l) => l.includes("[Methods]") && l.includes("caught-msg"))).toBe(true);
+  });
+
+  it("scoped logger catch with Sentry enabled and Error instance", () => {
+    const OLD_ENV = process.env;
+    process.env = {...OLD_ENV, USE_SENTRY_LOGGING: "true"};
+    try {
+      const scoped = createScopedLogger({prefix: "[Sentry]"});
+      expect(() => scoped.catch(new Error("sentry scoped error"))).not.toThrow();
+    } finally {
+      process.env = OLD_ENV;
+    }
+  });
+
+  it("attaches terrenoRequestLog while request ALS scope is active", () => {
+    const snapshots: Array<{terrenoRequestLog?: TerrenoRequestLogEntry}> = [];
+    const captureTransport = new winston.transports.Stream({
+      format: winston.format((info) => {
+        snapshots.push({
+          terrenoRequestLog: (info as {terrenoRequestLog?: TerrenoRequestLogEntry})
+            .terrenoRequestLog,
+        });
+        return info;
+      })(),
+      stream: new Writable({
+        write(_chunk, _encoding, callback): void {
+          callback();
+        },
+      }),
+    });
+    winstonLogger.add(captureTransport);
+    try {
+      runWithRequestContext({requestId: "req-als-1", userId: "user-99"}, () => {
+        logger.info("in scope");
+      });
+      runWithRequestContext({requestId: "req-als-2"}, () => {
+        logger.info("anon");
+      });
+    } finally {
+      winstonLogger.remove(captureTransport);
+    }
+    const withUser = snapshots.find((s) => s.terrenoRequestLog?.requestId === "req-als-1");
+    expect(withUser?.terrenoRequestLog?.userId).toBe("user-99");
+    const anon = snapshots.find((s) => s.terrenoRequestLog?.requestId === "req-als-2");
+    expect(anon?.terrenoRequestLog?.userId).toBeNull();
+  });
+});
+
+describe("createFeatureFlaggedLogger", () => {
+  afterEach(() => {
+    setupLogging({disableFileLogging: true});
+  });
+
+  it("drops info lines while disabled", () => {
+    let hits = 0;
+    const captureTransport = new winston.transports.Stream({
+      format: winston.format.printf(() => {
+        hits += 1;
+        return "";
+      }),
+      stream: new Writable({
+        write(_chunk, _encoding, callback): void {
+          callback();
+        },
+      }),
+    });
+    winstonLogger.add(captureTransport);
+    try {
+      const log = createFeatureFlaggedLogger({isEnabled: () => false, target: logger});
+      log.info("hidden");
+    } finally {
+      winstonLogger.remove(captureTransport);
+    }
+    expect(hits).toBe(0);
+  });
+
+  it("forwards lines when enabled", () => {
+    let hits = 0;
+    const captureTransport = new winston.transports.Stream({
+      format: winston.format.printf(() => {
+        hits += 1;
+        return "";
+      }),
+      stream: new Writable({
+        write(_chunk, _encoding, callback): void {
+          callback();
+        },
+      }),
+    });
+    winstonLogger.add(captureTransport);
+    try {
+      const log = createFeatureFlaggedLogger({isEnabled: () => true, target: logger});
+      log.info("visible");
+    } finally {
+      winstonLogger.remove(captureTransport);
+    }
+    expect(hits).toBeGreaterThan(0);
+  });
+
+  it("forwards catch while disabled when gateCatch is false", () => {
+    let hits = 0;
+    const captureTransport = new winston.transports.Stream({
+      format: winston.format.printf(() => {
+        hits += 1;
+        return "";
+      }),
+      stream: new Writable({
+        write(_chunk, _encoding, callback): void {
+          callback();
+        },
+      }),
+    });
+    winstonLogger.add(captureTransport);
+    try {
+      const log = createFeatureFlaggedLogger({
+        gateCatch: false,
+        isEnabled: () => false,
+        target: logger,
+      });
+      log.catch(new Error("still-logged"));
+    } finally {
+      winstonLogger.remove(captureTransport);
+    }
+    expect(hits).toBeGreaterThan(0);
+  });
+
+  it("forwards all methods when enabled (debug, warn, error)", () => {
+    const levels: string[] = [];
+    const captureTransport = new winston.transports.Stream({
+      format: winston.format((info) => {
+        levels.push(info.level);
+        return info;
+      })(),
+      stream: new Writable({
+        write(_chunk, _encoding, callback): void {
+          callback();
+        },
+      }),
+    });
+    winstonLogger.add(captureTransport);
+    try {
+      const log = createFeatureFlaggedLogger({isEnabled: () => true, target: logger});
+      log.debug("d");
+      log.warn("w");
+      log.error("e");
+    } finally {
+      winstonLogger.remove(captureTransport);
+    }
+    expect(levels.some((l) => l === "debug")).toBe(true);
+    expect(levels.some((l) => l === "warn")).toBe(true);
+    expect(levels.some((l) => l === "error")).toBe(true);
+  });
+
+  it("drops debug, warn, error lines when disabled", () => {
+    let hits = 0;
+    const captureTransport = new winston.transports.Stream({
+      format: winston.format.printf(() => {
+        hits += 1;
+        return "";
+      }),
+      stream: new Writable({
+        write(_chunk, _encoding, callback): void {
+          callback();
+        },
+      }),
+    });
+    winstonLogger.add(captureTransport);
+    try {
+      const log = createFeatureFlaggedLogger({isEnabled: () => false, target: logger});
+      log.debug("hidden-d");
+      log.warn("hidden-w");
+      log.error("hidden-e");
+    } finally {
+      winstonLogger.remove(captureTransport);
+    }
+    expect(hits).toBe(0);
+  });
+
+  it("uses the global logger as default target when target is not provided", () => {
+    const log = createFeatureFlaggedLogger({isEnabled: () => true});
+    expect(() => log.info("default target")).not.toThrow();
+  });
+
+  it("drops catch while disabled when gateCatch is true", () => {
+    let hits = 0;
+    const captureTransport = new winston.transports.Stream({
+      format: winston.format.printf(() => {
+        hits += 1;
+        return "";
+      }),
+      stream: new Writable({
+        write(_chunk, _encoding, callback): void {
+          callback();
+        },
+      }),
+    });
+    winstonLogger.add(captureTransport);
+    try {
+      const log = createFeatureFlaggedLogger({
+        gateCatch: true,
+        isEnabled: () => false,
+        target: logger,
+      });
+      log.catch(new Error("suppressed"));
+    } finally {
+      winstonLogger.remove(captureTransport);
+    }
+    expect(hits).toBe(0);
+  });
+});
+
 describe("setupLogging", () => {
   let tempDir: string;
 
@@ -146,4 +570,45 @@ describe("setupLogging", () => {
     });
     expect(true).toBe(true);
   });
+
+  it("console format includes timestamps when showConsoleTimestamps is true", () => {
+    const lines: string[] = [];
+    setupLogging({
+      disableFileLogging: true,
+      showConsoleTimestamps: true,
+    });
+    const captureTransport = new winston.transports.Stream({
+      format: winston.format.combine(
+        winston.format.timestamp(),
+        winston.format.printf((info) => {
+          if (info.timestamp) {
+            return `${info.timestamp} - ${info.level}: ${info.message}`;
+          }
+          return `${info.level}: ${info.message}`;
+        })
+      ),
+      stream: new Writable({
+        write(chunk, _encoding, callback): void {
+          lines.push(chunk.toString().trim());
+          callback();
+        },
+      }),
+    });
+    winstonLogger.add(captureTransport);
+    try {
+      logger.info("timestamp-test");
+    } finally {
+      winstonLogger.remove(captureTransport);
+    }
+    expect(lines.some((l) => l.includes("timestamp-test"))).toBe(true);
+  });
+
+  it("disableTerrenoDevJsonlLog skips the dev JSONL transport", () => {
+    expect(() =>
+      setupLogging({
+        disableFileLogging: true,
+        disableTerrenoDevJsonlLog: true,
+      })
+    ).not.toThrow();
+  });
 });