apitally 0.18.1 → 0.19.0

package/dist/h3/plugin.cjs

@@ -38,11 +38,12 @@ __export(plugin_exports, {
 });
 module.exports = __toCommonJS(plugin_exports);
 var import_h3 = require("h3");
-var import_perf_hooks = require("perf_hooks");
+var import_node_async_hooks = require("async_hooks");
+var import_node_perf_hooks = require("perf_hooks");
 
 // src/common/client.ts
-var import_crypto5 = require("crypto");
 var import_fetch_retry = __toESM(require("fetch-retry"), 1);
+var import_node_crypto5 = require("crypto");
 
 // src/common/consumerRegistry.ts
 var consumerFromStringOrObject = /* @__PURE__ */ __name((consumer) => {
@@ -102,7 +103,7 @@ var ConsumerRegistry = _ConsumerRegistry;
 
 // src/common/logging.ts
 var import_winston = require("winston");
-var getLogger = /* @__PURE__ */ __name(() => {
+function getLogger() {
   return (0, import_winston.createLogger)({
     level: process.env.APITALLY_DEBUG ? "debug" : "warn",
     format: import_winston.format.combine(import_winston.format.colorize(), import_winston.format.timestamp(), import_winston.format.printf((info) => `${info.timestamp} ${info.level}: ${info.message}`)),
@@ -110,7 +111,8 @@ var getLogger = /* @__PURE__ */ __name(() => {
       new import_winston.transports.Console()
     ]
   });
-}, "getLogger");
+}
+__name(getLogger, "getLogger");
 
 // src/common/paramValidation.ts
 function isValidClientId(clientId) {
@@ -212,11 +214,11 @@ var RequestCounter = _RequestCounter;
 
 // src/common/requestLogger.ts
 var import_async_lock = __toESM(require("async-lock"), 1);
-var import_buffer2 = require("buffer");
-var import_crypto3 = require("crypto");
-var import_fs2 = require("fs");
-var import_os2 = require("os");
-var import_path2 = require("path");
+var import_node_buffer2 = require("buffer");
+var import_node_crypto3 = require("crypto");
+var import_node_fs2 = require("fs");
+var import_node_os2 = require("os");
+var import_node_path2 = require("path");
 
 // src/common/sentry.ts
 var sentry;
@@ -235,7 +237,7 @@ function getSentryEventId() {
 __name(getSentryEventId, "getSentryEventId");
 
 // src/common/serverErrorCounter.ts
-var import_crypto = require("crypto");
+var import_node_crypto = require("crypto");
 var MAX_MSG_LENGTH = 2048;
 var MAX_STACKTRACE_LENGTH = 65536;
 var _ServerErrorCounter = class _ServerErrorCounter {
@@ -277,6 +279,7 @@ var _ServerErrorCounter = class _ServerErrorCounter {
     });
     this.errorCounts.clear();
     this.errorDetails.clear();
+    this.sentryEventIds.clear();
     return data;
   }
   getKey(serverError) {
@@ -288,7 +291,7 @@ var _ServerErrorCounter = class _ServerErrorCounter {
       serverError.msg.trim(),
       serverError.traceback.trim()
     ].join("|");
-    return (0, import_crypto.createHash)("md5").update(hashInput).digest("hex");
+    return (0, import_node_crypto.createHash)("md5").update(hashInput).digest("hex");
   }
 };
 __name(_ServerErrorCounter, "ServerErrorCounter");
@@ -321,12 +324,13 @@ function truncateExceptionStackTrace(stack) {
 __name(truncateExceptionStackTrace, "truncateExceptionStackTrace");
 
 // src/common/tempGzipFile.ts
-var import_buffer = require("buffer");
-var import_crypto2 = require("crypto");
-var import_fs = require("fs");
-var import_os = require("os");
-var import_path = require("path");
-var import_zlib = require("zlib");
+var import_node_buffer = require("buffer");
+var import_node_crypto2 = require("crypto");
+var import_node_fs = require("fs");
+var import_promises = require("fs/promises");
+var import_node_os = require("os");
+var import_node_path = require("path");
+var import_node_zlib = require("zlib");
 var _TempGzipFile = class _TempGzipFile {
   uuid;
   filePath;
@@ -335,9 +339,9 @@ var _TempGzipFile = class _TempGzipFile {
   readyPromise;
   closedPromise;
   constructor() {
-    this.uuid = (0, import_crypto2.randomUUID)();
-    this.filePath = (0, import_path.join)((0, import_os.tmpdir)(), `apitally-${this.uuid}.gz`);
-    this.writeStream = (0, import_fs.createWriteStream)(this.filePath);
+    this.uuid = (0, import_node_crypto2.randomUUID)();
+    this.filePath = (0, import_node_path.join)((0, import_node_os.tmpdir)(), `apitally-${this.uuid}.gz`);
+    this.writeStream = (0, import_node_fs.createWriteStream)(this.filePath);
     this.readyPromise = new Promise((resolve, reject) => {
       this.writeStream.once("ready", resolve);
       this.writeStream.once("error", reject);
@@ -346,7 +350,7 @@ var _TempGzipFile = class _TempGzipFile {
       this.writeStream.once("close", resolve);
       this.writeStream.once("error", reject);
     });
-    this.gzip = (0, import_zlib.createGzip)();
+    this.gzip = (0, import_node_zlib.createGzip)();
     this.gzip.pipe(this.writeStream);
   }
   get size() {
@@ -355,9 +359,9 @@ var _TempGzipFile = class _TempGzipFile {
   async writeLine(data) {
     await this.readyPromise;
     return new Promise((resolve, reject) => {
-      this.gzip.write(import_buffer.Buffer.concat([
+      this.gzip.write(import_node_buffer.Buffer.concat([
         data,
-        import_buffer.Buffer.from("\n")
+        import_node_buffer.Buffer.from("\n")
       ]), (error) => {
         if (error) {
           reject(error);
@@ -369,7 +373,7 @@ var _TempGzipFile = class _TempGzipFile {
   }
   async getContent() {
     return new Promise((resolve, reject) => {
-      (0, import_fs.readFile)(this.filePath, (error, data) => {
+      (0, import_node_fs.readFile)(this.filePath, (error, data) => {
         if (error) {
           reject(error);
         } else {
@@ -388,7 +392,7 @@ var _TempGzipFile = class _TempGzipFile {
   }
   async delete() {
     await this.close();
-    (0, import_fs.unlinkSync)(this.filePath);
+    await (0, import_promises.unlink)(this.filePath);
   }
 };
 __name(_TempGzipFile, "TempGzipFile");
@@ -399,8 +403,9 @@ var MAX_BODY_SIZE = 5e4;
 var MAX_FILE_SIZE = 1e6;
 var MAX_FILES = 50;
 var MAX_PENDING_WRITES = 100;
-var BODY_TOO_LARGE = import_buffer2.Buffer.from("<body too large>");
-var BODY_MASKED = import_buffer2.Buffer.from("<masked>");
+var MAX_LOG_MSG_LENGTH = 2048;
+var BODY_TOO_LARGE = import_node_buffer2.Buffer.from("<body too large>");
+var BODY_MASKED = import_node_buffer2.Buffer.from("<masked>");
 var MASKED = "******";
 var ALLOWED_CONTENT_TYPES = [
   "application/json",
@@ -455,6 +460,7 @@ var DEFAULT_CONFIG = {
   logResponseHeaders: true,
   logResponseBody: false,
   logException: true,
+  captureLogs: false,
   maskQueryParams: [],
   maskHeaders: [],
   maskBodyFields: [],
@@ -597,7 +603,7 @@ var _RequestLogger = class _RequestLogger {
         try {
           const parsedBody = JSON.parse(bodyData.toString());
           const maskedBody = this.maskBody(parsedBody);
-          item[key].body = import_buffer2.Buffer.from(JSON.stringify(maskedBody));
+          item[key].body = import_node_buffer2.Buffer.from(JSON.stringify(maskedBody));
         } catch {
         }
       }
@@ -609,7 +615,7 @@ var _RequestLogger = class _RequestLogger {
     item.request.url = url.toString();
     return item;
   }
-  logRequest(request, response, error) {
+  logRequest(request, response, error, logs) {
     var _a2, _b, _c;
     if (!this.enabled || this.suspendUntil !== null) return;
     const url = new URL(request.url);
@@ -631,7 +637,7 @@ var _RequestLogger = class _RequestLogger {
       response.size = void 0;
     }
     const item = {
-      uuid: (0, import_crypto3.randomUUID)(),
+      uuid: (0, import_node_crypto3.randomUUID)(),
       request,
       response,
       exception: error && this.config.logException ? {
@@ -641,6 +647,14 @@ var _RequestLogger = class _RequestLogger {
         sentryEventId: getSentryEventId()
       } : void 0
     };
+    if (logs && logs.length > 0) {
+      item.logs = logs.map((log) => ({
+        timestamp: log.timestamp,
+        logger: log.logger,
+        level: log.level,
+        message: truncateLogMessage(log.message)
+      }));
+    }
     this.pendingWrites.push(item);
     if (this.pendingWrites.length > MAX_PENDING_WRITES) {
       this.pendingWrites.shift();
@@ -662,7 +676,8 @@ var _RequestLogger = class _RequestLogger {
             uuid: item.uuid,
             request: skipEmptyValues(item.request),
             response: skipEmptyValues(item.response),
-            exception: item.exception
+            exception: item.exception,
+            logs: item.logs
           };
           [
             finalItem.request.body,
@@ -674,7 +689,7 @@ var _RequestLogger = class _RequestLogger {
               };
             }
           });
-          await this.currentFile.writeLine(import_buffer2.Buffer.from(JSON.stringify(finalItem)));
+          await this.currentFile.writeLine(import_node_buffer2.Buffer.from(JSON.stringify(finalItem)));
         }
       }
     });
@@ -757,18 +772,26 @@ __name(matchPatterns, "matchPatterns");
 function skipEmptyValues(data) {
   return Object.fromEntries(Object.entries(data).filter(([_, v]) => {
     if (v == null || Number.isNaN(v)) return false;
-    if (Array.isArray(v) || import_buffer2.Buffer.isBuffer(v) || typeof v === "string") {
+    if (Array.isArray(v) || import_node_buffer2.Buffer.isBuffer(v) || typeof v === "string") {
       return v.length > 0;
     }
     return true;
   }));
 }
 __name(skipEmptyValues, "skipEmptyValues");
+function truncateLogMessage(msg) {
+  if (msg.length > MAX_LOG_MSG_LENGTH) {
+    const suffix = "... (truncated)";
+    return msg.slice(0, MAX_LOG_MSG_LENGTH - suffix.length) + suffix;
+  }
+  return msg;
+}
+__name(truncateLogMessage, "truncateLogMessage");
 function checkWritableFs() {
   try {
-    const testPath = (0, import_path2.join)((0, import_os2.tmpdir)(), `apitally-${(0, import_crypto3.randomUUID)()}`);
-    (0, import_fs2.writeFileSync)(testPath, "test");
-    (0, import_fs2.unlinkSync)(testPath);
+    const testPath = (0, import_node_path2.join)((0, import_node_os2.tmpdir)(), `apitally-${(0, import_node_crypto3.randomUUID)()}`);
+    (0, import_node_fs2.writeFileSync)(testPath, "test");
+    (0, import_node_fs2.unlinkSync)(testPath);
     return true;
   } catch (error) {
     return false;
@@ -777,7 +800,7 @@ function checkWritableFs() {
 __name(checkWritableFs, "checkWritableFs");
 
 // src/common/validationErrorCounter.ts
-var import_crypto4 = require("crypto");
+var import_node_crypto4 = require("crypto");
 var _ValidationErrorCounter = class _ValidationErrorCounter {
   errorCounts;
   errorDetails;
@@ -821,7 +844,7 @@ var _ValidationErrorCounter = class _ValidationErrorCounter {
       validationError.msg.trim(),
       validationError.type
     ].join("|");
-    return (0, import_crypto4.createHash)("md5").update(hashInput).digest("hex");
+    return (0, import_node_crypto4.createHash)("md5").update(hashInput).digest("hex");
   }
 };
 __name(_ValidationErrorCounter, "ValidationErrorCounter");
@@ -872,7 +895,7 @@ var _ApitallyClient = class _ApitallyClient {
     _ApitallyClient.instance = this;
     this.clientId = clientId;
     this.env = env;
-    this.instanceUuid = (0, import_crypto5.randomUUID)();
+    this.instanceUuid = (0, import_node_crypto5.randomUUID)();
     this.syncDataQueue = [];
     this.requestCounter = new RequestCounter();
     this.requestLogger = new RequestLogger(requestLogging ?? requestLoggingConfig);
@@ -978,7 +1001,7 @@ var _ApitallyClient = class _ApitallyClient {
       this.logger.debug("Sending startup data to Apitally Hub");
       const payload = {
         instance_uuid: this.instanceUuid,
-        message_uuid: (0, import_crypto5.randomUUID)(),
+        message_uuid: (0, import_node_crypto5.randomUUID)(),
         ...this.startupData
       };
       try {
@@ -1000,7 +1023,7 @@ var _ApitallyClient = class _ApitallyClient {
     const newPayload = {
       timestamp: Date.now() / 1e3,
       instance_uuid: this.instanceUuid,
-      message_uuid: (0, import_crypto5.randomUUID)(),
+      message_uuid: (0, import_node_crypto5.randomUUID)(),
       requests: this.requestCounter.getAndResetRequests(),
       validation_errors: this.validationErrorCounter.getAndResetValidationErrors(),
       server_errors: this.serverErrorCounter.getAndResetServerErrors(),
@@ -1183,8 +1206,145 @@ async function teeResponse(response) {
 }
 __name(teeResponse, "teeResponse");
 
+// src/loggers/console.ts
+var import_node_util = require("util");
+var MAX_BUFFER_SIZE = 1e3;
+var isPatched = false;
+var globalLogsContext;
+function patchConsole(logsContext) {
+  globalLogsContext = logsContext;
+  if (isPatched) {
+    return;
+  }
+  const logMethods = [
+    "log",
+    "warn",
+    "error",
+    "info",
+    "debug"
+  ];
+  logMethods.forEach((method) => {
+    const originalMethod = console[method];
+    console[method] = function(...args) {
+      captureLog(method, args);
+      return originalMethod.apply(console, args);
+    };
+  });
+  isPatched = true;
+}
+__name(patchConsole, "patchConsole");
+function captureLog(level, args) {
+  const logs = globalLogsContext == null ? void 0 : globalLogsContext.getStore();
+  if (logs && logs.length < MAX_BUFFER_SIZE) {
+    logs.push({
+      timestamp: Date.now() / 1e3,
+      logger: "console",
+      level,
+      message: (0, import_node_util.format)(...args)
+    });
+  }
+}
+__name(captureLog, "captureLog");
+
+// src/loggers/utils.ts
+var import_node_util2 = require("util");
+function formatMessage(message, ...args) {
+  return [
+    message,
+    ...args
+  ].map(formatArg).filter((arg) => arg !== "").join("\n");
+}
+__name(formatMessage, "formatMessage");
+function removeKeys(obj, keys) {
+  return Object.fromEntries(Object.entries(obj).filter(([key]) => !keys.includes(key)));
+}
+__name(removeKeys, "removeKeys");
+function formatArg(arg) {
+  if (typeof arg === "string") {
+    return arg.trim();
+  }
+  if (arg instanceof Error) {
+    return (0, import_node_util2.format)(arg).trim();
+  }
+  if (arg === void 0 || arg === null || isEmptyObject(arg)) {
+    return "";
+  }
+  try {
+    return JSON.stringify(arg);
+  } catch {
+    return (0, import_node_util2.format)(arg).trim();
+  }
+}
+__name(formatArg, "formatArg");
+function isEmptyObject(obj) {
+  return obj !== null && typeof obj === "object" && Object.getPrototypeOf(obj) === Object.prototype && Object.keys(obj).length === 0;
+}
+__name(isEmptyObject, "isEmptyObject");
+
+// src/loggers/pino.ts
+var originalStreamSym = Symbol.for("apitally.originalStream");
+
+// src/loggers/winston.ts
+var MAX_BUFFER_SIZE2 = 1e3;
+var isPatched2 = false;
+var globalLogsContext2;
+async function patchWinston(logsContext) {
+  var _a2, _b;
+  globalLogsContext2 = logsContext;
+  if (isPatched2) {
+    return;
+  }
+  try {
+    const loggerModule = await import("winston/lib/winston/logger.js");
+    if ((_b = (_a2 = loggerModule.default) == null ? void 0 : _a2.prototype) == null ? void 0 : _b.write) {
+      const originalWrite = loggerModule.default.prototype.write;
+      loggerModule.default.prototype.write = function(info) {
+        captureLog2(info);
+        return originalWrite.call(this, info);
+      };
+    }
+  } catch {
+  }
+  isPatched2 = true;
+}
+__name(patchWinston, "patchWinston");
+function captureLog2(info) {
+  const logs = globalLogsContext2 == null ? void 0 : globalLogsContext2.getStore();
+  if (!logs || !info || logs.length >= MAX_BUFFER_SIZE2) {
+    return;
+  }
+  try {
+    const rest = removeKeys(info, [
+      "timestamp",
+      "level",
+      "message",
+      "splat"
+    ]);
+    const formattedMessage = formatMessage(info.message, rest);
+    if (formattedMessage) {
+      logs.push({
+        timestamp: parseTimestamp(info.timestamp),
+        level: info.level || "info",
+        message: formattedMessage.trim()
+      });
+    }
+  } catch (e) {
+  }
+}
+__name(captureLog2, "captureLog");
+function parseTimestamp(timestamp) {
+  if (timestamp) {
+    const ts = new Date(timestamp).getTime();
+    if (!isNaN(ts)) {
+      return ts / 1e3;
+    }
+  }
+  return Date.now() / 1e3;
+}
+__name(parseTimestamp, "parseTimestamp");
+
 // src/common/packageVersions.ts
-var import_module = require("module");
+var import_node_module = require("module");
 var import_meta = {};
 function getPackageVersion(name) {
   const packageJsonPath = `${name}/package.json`;
@@ -1192,7 +1352,7 @@ function getPackageVersion(name) {
     return require(packageJsonPath).version || null;
   } catch (error) {
     try {
-      const _require = (0, import_module.createRequire)(import_meta.url);
+      const _require = (0, import_node_module.createRequire)(import_meta.url);
       return _require(packageJsonPath).version || null;
     } catch (error2) {
       return null;
@@ -1251,11 +1411,14 @@ function getAppInfo(h3, appVersion) {
 __name(getAppInfo, "getAppInfo");
 
 // src/h3/plugin.ts
+var REQUEST_TIMESTAMP_SYMBOL = Symbol("apitally.requestTimestamp");
+var REQUEST_BODY_SYMBOL = Symbol("apitally.requestBody");
 var jsonHeaders = new Headers({
   "content-type": "application/json;charset=UTF-8"
 });
 var apitallyPlugin = (0, import_h3.definePlugin)((app, config) => {
   const client = new ApitallyClient(config);
+  const logsContext = new import_node_async_hooks.AsyncLocalStorage();
   const setStartupData = /* @__PURE__ */ __name((attempt = 1) => {
     const appInfo = getAppInfo(app, config.appVersion);
     if (appInfo.paths.length > 0 || attempt >= 10) {
@@ -1265,13 +1428,17 @@ var apitallyPlugin = (0, import_h3.definePlugin)((app, config) => {
     }
   }, "setStartupData");
   setTimeout(() => setStartupData(), 500);
+  if (client.requestLogger.config.captureLogs) {
+    patchConsole(logsContext);
+    patchWinston(logsContext);
+  }
   const handleResponse = /* @__PURE__ */ __name(async (event, response, error) => {
     var _a2, _b;
     if (event.req.method.toUpperCase() === "OPTIONS") {
       return response;
     }
-    const startTime = event.context._apitallyRequestTimestamp;
-    const responseTime = startTime ? import_perf_hooks.performance.now() - startTime : 0;
+    const startTime = event.context[REQUEST_TIMESTAMP_SYMBOL];
+    const responseTime = startTime ? import_node_perf_hooks.performance.now() - startTime : 0;
     const path = (_a2 = event.context.matchedRoute) == null ? void 0 : _a2.route;
     const statusCode = (response == null ? void 0 : response.status) || (error == null ? void 0 : error.status) || 500;
     const requestSize = parseContentLength(event.req.headers.get("content-length"));
@@ -1325,33 +1492,35 @@ var apitallyPlugin = (0, import_h3.definePlugin)((app, config) => {
       } else if (error && client.requestLogger.config.logResponseBody) {
         responseBody = Buffer.from(JSON.stringify(error.toJSON()));
       }
+      const logs = logsContext.getStore();
       client.requestLogger.logRequest({
         timestamp: (Date.now() - responseTime) / 1e3,
         method: event.req.method,
         path,
         url: event.req.url,
         headers: convertHeaders(Object.fromEntries(event.req.headers.entries())),
-        size: Number(requestSize),
+        size: requestSize,
         consumer: consumer == null ? void 0 : consumer.identifier,
-        body: event.context._apitallyRequestBody
+        body: event.context[REQUEST_BODY_SYMBOL]
       }, {
         statusCode,
         responseTime: responseTime / 1e3,
         headers: convertHeaders(Object.fromEntries(responseHeaders.entries())),
         size: responseSize,
         body: responseBody
-      });
+      }, (error == null ? void 0 : error.cause) instanceof Error ? error.cause : void 0, logs);
     }
     return newResponse;
   }, "handleResponse");
   app.use((0, import_h3.onRequest)(async (event) => {
-    event.context._apitallyRequestTimestamp = import_perf_hooks.performance.now();
+    logsContext.enterWith([]);
+    event.context[REQUEST_TIMESTAMP_SYMBOL] = import_node_perf_hooks.performance.now();
     const requestContentType = event.req.headers.get("content-type");
     const requestSize = parseContentLength(event.req.headers.get("content-length")) ?? 0;
     if (client.requestLogger.enabled && client.requestLogger.config.logRequestBody && client.requestLogger.isSupportedContentType(requestContentType) && requestSize <= client.requestLogger.maxBodySize) {
       const clonedRequest = event.req.clone();
       const requestBody = Buffer.from(await clonedRequest.arrayBuffer());
-      event.context._apitallyRequestBody = requestBody;
+      event.context[REQUEST_BODY_SYMBOL] = requestBody;
     }
   })).use((0, import_h3.onResponse)((response, event) => {
     if (client.isEnabled()) {