apitally 0.18.0 → 0.19.0

package/dist/hono/index.cjs

@@ -39,11 +39,12 @@ __export(hono_exports, {
 module.exports = __toCommonJS(hono_exports);
 
 // src/hono/middleware.ts
-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) => {
@@ -103,7 +104,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}`)),
@@ -111,7 +112,8 @@ var getLogger = /* @__PURE__ */ __name(() => {
       new import_winston.transports.Console()
     ]
   });
-}, "getLogger");
+}
+__name(getLogger, "getLogger");
 
 // src/common/paramValidation.ts
 function isValidClientId(clientId) {
@@ -213,11 +215,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;
@@ -236,7 +238,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 {
@@ -278,6 +280,7 @@ var _ServerErrorCounter = class _ServerErrorCounter {
     });
     this.errorCounts.clear();
     this.errorDetails.clear();
+    this.sentryEventIds.clear();
     return data;
   }
   getKey(serverError) {
@@ -289,7 +292,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");
@@ -322,12 +325,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;
@@ -336,9 +340,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);
@@ -347,7 +351,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() {
@@ -356,9 +360,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);
@@ -370,7 +374,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 {
@@ -389,7 +393,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");
@@ -400,8 +404,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",
@@ -456,6 +461,7 @@ var DEFAULT_CONFIG = {
   logResponseHeaders: true,
   logResponseBody: false,
   logException: true,
+  captureLogs: false,
   maskQueryParams: [],
   maskHeaders: [],
   maskBodyFields: [],
@@ -598,7 +604,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 {
         }
       }
@@ -610,7 +616,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);
@@ -632,7 +638,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 ? {
@@ -642,6 +648,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();
@@ -663,7 +677,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,
@@ -675,7 +690,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)));
         }
       }
     });
@@ -758,18 +773,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;
@@ -778,7 +801,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;
@@ -822,7 +845,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");
@@ -873,7 +896,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);
@@ -979,7 +1002,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 {
@@ -1001,7 +1024,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(),
@@ -1193,11 +1216,148 @@ 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/hono/utils.ts
 var import_handler = require("hono/utils/handler");
 
 // 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`;
@@ -1205,7 +1365,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;
@@ -1307,84 +1467,92 @@ function useApitally(app, config) {
 }
 __name(useApitally, "useApitally");
 function getMiddleware(client) {
+  const logsContext = new import_node_async_hooks.AsyncLocalStorage();
+  if (client.requestLogger.config.captureLogs) {
+    patchConsole(logsContext);
+    patchWinston(logsContext);
+  }
   return async (c, next) => {
     if (!client.isEnabled() || c.req.method.toUpperCase() === "OPTIONS") {
       await next();
       return;
     }
-    const timestamp = Date.now() / 1e3;
-    const startTime = import_perf_hooks.performance.now();
-    await next();
-    let response;
-    const responseTime = import_perf_hooks.performance.now() - startTime;
-    const [responseSize, newResponse] = await measureResponseSize(c.res);
-    const requestSize = parseContentLength(c.req.header("content-length"));
-    const consumer = getConsumer(c);
-    client.consumerRegistry.addOrUpdateConsumer(consumer);
-    client.requestCounter.addRequest({
-      consumer: consumer == null ? void 0 : consumer.identifier,
-      method: c.req.method,
-      path: c.req.routePath,
-      statusCode: c.res.status,
-      responseTime,
-      requestSize,
-      responseSize
-    });
-    response = newResponse;
-    if (c.res.status === 400) {
-      const [responseJson, newResponse2] = await getResponseJson(response);
-      const validationErrors = extractZodErrors(responseJson);
-      validationErrors.forEach((error) => {
-        client.validationErrorCounter.addValidationError({
-          consumer: consumer == null ? void 0 : consumer.identifier,
-          method: c.req.method,
-          path: c.req.routePath,
-          ...error
-        });
-      });
-      response = newResponse2;
-    }
-    if (c.error) {
-      client.serverErrorCounter.addServerError({
+    await logsContext.run([], async () => {
+      const timestamp = Date.now() / 1e3;
+      const startTime = import_node_perf_hooks.performance.now();
+      await next();
+      let response;
+      const responseTime = import_node_perf_hooks.performance.now() - startTime;
+      const [responseSize, newResponse] = await measureResponseSize(c.res);
+      const requestSize = parseContentLength(c.req.header("content-length"));
+      const consumer = getConsumer(c);
+      client.consumerRegistry.addOrUpdateConsumer(consumer);
+      client.requestCounter.addRequest({
         consumer: consumer == null ? void 0 : consumer.identifier,
         method: c.req.method,
         path: c.req.routePath,
-        type: c.error.name,
-        msg: c.error.message,
-        traceback: c.error.stack || ""
+        statusCode: c.res.status,
+        responseTime,
+        requestSize,
+        responseSize
       });
-    }
-    if (client.requestLogger.enabled) {
-      let requestBody;
-      let responseBody;
-      let newResponse2 = response;
-      const requestContentType = c.req.header("content-type");
-      const responseContentType = c.res.headers.get("content-type");
-      if (client.requestLogger.config.logRequestBody && client.requestLogger.isSupportedContentType(requestContentType)) {
-        requestBody = Buffer.from(await c.req.arrayBuffer());
-      }
-      if (client.requestLogger.config.logResponseBody && client.requestLogger.isSupportedContentType(responseContentType)) {
-        [responseBody, newResponse2] = await getResponseBody(response);
+      response = newResponse;
+      if (c.res.status === 400) {
+        const [responseJson, newResponse2] = await getResponseJson(response);
+        const validationErrors = extractZodErrors(responseJson);
+        validationErrors.forEach((error) => {
+          client.validationErrorCounter.addValidationError({
+            consumer: consumer == null ? void 0 : consumer.identifier,
+            method: c.req.method,
+            path: c.req.routePath,
+            ...error
+          });
+        });
         response = newResponse2;
       }
-      client.requestLogger.logRequest({
-        timestamp,
-        method: c.req.method,
-        path: c.req.routePath,
-        url: c.req.url,
-        headers: convertHeaders(c.req.header()),
-        size: Number(requestSize),
-        consumer: consumer == null ? void 0 : consumer.identifier,
-        body: requestBody
-      }, {
-        statusCode: c.res.status,
-        responseTime: responseTime / 1e3,
-        headers: convertHeaders(c.res.headers),
-        size: responseSize,
-        body: responseBody
-      }, c.error);
-    }
-    c.res = response;
+      if (c.error) {
+        client.serverErrorCounter.addServerError({
+          consumer: consumer == null ? void 0 : consumer.identifier,
+          method: c.req.method,
+          path: c.req.routePath,
+          type: c.error.name,
+          msg: c.error.message,
+          traceback: c.error.stack || ""
+        });
+      }
+      if (client.requestLogger.enabled) {
+        let requestBody;
+        let responseBody;
+        let newResponse2 = response;
+        const requestContentType = c.req.header("content-type");
+        const responseContentType = c.res.headers.get("content-type");
+        if (client.requestLogger.config.logRequestBody && client.requestLogger.isSupportedContentType(requestContentType)) {
+          requestBody = Buffer.from(await c.req.arrayBuffer());
+        }
+        if (client.requestLogger.config.logResponseBody && client.requestLogger.isSupportedContentType(responseContentType)) {
+          [responseBody, newResponse2] = await getResponseBody(response);
+          response = newResponse2;
+        }
+        const logs = logsContext.getStore();
+        client.requestLogger.logRequest({
+          timestamp,
+          method: c.req.method,
+          path: c.req.routePath,
+          url: c.req.url,
+          headers: convertHeaders(c.req.header()),
+          size: requestSize,
+          consumer: consumer == null ? void 0 : consumer.identifier,
+          body: requestBody
+        }, {
+          statusCode: c.res.status,
+          responseTime: responseTime / 1e3,
+          headers: convertHeaders(c.res.headers),
+          size: responseSize,
+          body: responseBody
+        }, c.error, logs);
+      }
+      c.res = response;
+    });
   };
 }
 __name(getMiddleware, "getMiddleware");