apitally 0.18.1 → 0.20.0

package/dist/koa/middleware.cjs

@@ -37,10 +37,11 @@ __export(middleware_exports, {
   useApitally: () => useApitally
 });
 module.exports = __toCommonJS(middleware_exports);
+var import_node_async_hooks = require("async_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) => {
@@ -100,7 +101,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}`)),
@@ -108,7 +109,8 @@ var getLogger = /* @__PURE__ */ __name(() => {
       new import_winston.transports.Console()
     ]
   });
-}, "getLogger");
+}
+__name(getLogger, "getLogger");
 
 // src/common/paramValidation.ts
 function isValidClientId(clientId) {
@@ -210,11 +212,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;
@@ -233,7 +235,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 {
@@ -275,6 +277,7 @@ var _ServerErrorCounter = class _ServerErrorCounter {
     });
     this.errorCounts.clear();
     this.errorDetails.clear();
+    this.sentryEventIds.clear();
     return data;
   }
   getKey(serverError) {
@@ -286,7 +289,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");
@@ -319,12 +322,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;
@@ -333,9 +337,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);
@@ -344,7 +348,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() {
@@ -353,9 +357,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);
@@ -367,7 +371,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 {
@@ -386,7 +390,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");
@@ -397,8 +401,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",
@@ -453,6 +458,7 @@ var DEFAULT_CONFIG = {
   logResponseHeaders: true,
   logResponseBody: false,
   logException: true,
+  captureLogs: false,
   maskQueryParams: [],
   maskHeaders: [],
   maskBodyFields: [],
@@ -595,7 +601,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 {
         }
       }
@@ -607,7 +613,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);
@@ -629,7 +635,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 ? {
@@ -639,6 +645,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();
@@ -660,7 +674,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,
@@ -672,7 +687,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)));
         }
       }
     });
@@ -724,6 +739,9 @@ var _RequestLogger = class _RequestLogger {
 __name(_RequestLogger, "RequestLogger");
 var RequestLogger = _RequestLogger;
 function convertHeaders(headers) {
+  if (!headers) {
+    return [];
+  }
   if (headers instanceof Headers) {
     return Array.from(headers.entries());
   }
@@ -753,13 +771,13 @@ function convertBody(body, contentType) {
   try {
     if (contentType.startsWith("application/json")) {
       if (isValidJsonString(body)) {
-        return import_buffer2.Buffer.from(body);
+        return import_node_buffer2.Buffer.from(body);
       } else {
-        return import_buffer2.Buffer.from(JSON.stringify(body));
+        return import_node_buffer2.Buffer.from(JSON.stringify(body));
       }
     }
     if (contentType.startsWith("text/") && typeof body === "string") {
-      return import_buffer2.Buffer.from(body);
+      return import_node_buffer2.Buffer.from(body);
     }
   } catch (error) {
     return;
@@ -787,18 +805,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;
@@ -807,7 +833,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;
@@ -831,7 +857,7 @@ var _ValidationErrorCounter = class _ValidationErrorCounter {
           consumer: validationError.consumer || null,
           method: validationError.method,
           path: validationError.path,
-          loc: validationError.loc.split("."),
+          loc: validationError.loc.split(".").filter(Boolean),
           msg: validationError.msg,
           type: validationError.type,
           error_count: count
@@ -847,11 +873,11 @@ var _ValidationErrorCounter = class _ValidationErrorCounter {
       validationError.consumer || "",
       validationError.method.toUpperCase(),
       validationError.path,
-      validationError.loc,
+      validationError.loc.split(".").filter(Boolean),
       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");
@@ -902,7 +928,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);
@@ -1008,7 +1034,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 {
@@ -1030,7 +1056,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(),
@@ -1133,7 +1159,7 @@ __publicField(_ApitallyClient, "instance");
 var ApitallyClient = _ApitallyClient;
 
 // 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`;
@@ -1141,7 +1167,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;
@@ -1150,6 +1176,143 @@ function getPackageVersion(name) {
 }
 __name(getPackageVersion, "getPackageVersion");
 
+// 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/koa/middleware.ts
 function useApitally(app, config) {
   const client = new ApitallyClient(config);
@@ -1167,77 +1330,85 @@ 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 (ctx, next) => {
-    var _a2;
     if (!client.isEnabled() || ctx.request.method.toUpperCase() === "OPTIONS") {
       await next();
       return;
     }
-    let path;
-    let statusCode;
-    let serverError;
-    const startTime = performance.now();
-    try {
-      await next();
-    } catch (error) {
-      path = getPath(ctx);
-      statusCode = error.statusCode || error.status || 500;
-      if (path && statusCode === 500 && error instanceof Error) {
-        serverError = error;
-        client.serverErrorCounter.addServerError({
-          consumer: (_a2 = getConsumer(ctx)) == null ? void 0 : _a2.identifier,
-          method: ctx.request.method,
-          path,
-          type: error.name,
-          msg: error.message,
-          traceback: error.stack || ""
-        });
-      }
-      throw error;
-    } finally {
-      const responseTime = performance.now() - startTime;
-      const consumer = getConsumer(ctx);
-      client.consumerRegistry.addOrUpdateConsumer(consumer);
-      if (!path) {
+    await logsContext.run([], async () => {
+      var _a2;
+      let path;
+      let statusCode;
+      let serverError;
+      const startTime = performance.now();
+      try {
+        await next();
+      } catch (error) {
         path = getPath(ctx);
-      }
-      if (path) {
-        try {
-          client.requestCounter.addRequest({
-            consumer: consumer == null ? void 0 : consumer.identifier,
+        statusCode = error.statusCode || error.status || 500;
+        if (path && statusCode === 500 && error instanceof Error) {
+          serverError = error;
+          client.serverErrorCounter.addServerError({
+            consumer: (_a2 = getConsumer(ctx)) == null ? void 0 : _a2.identifier,
             method: ctx.request.method,
             path,
-            statusCode: statusCode || ctx.response.status,
-            responseTime,
-            requestSize: ctx.request.length,
-            responseSize: ctx.response.length
-          });
-        } catch (error) {
-          client.logger.error("Error while logging request in Apitally middleware.", {
-            context: ctx,
-            error
+            type: error.name,
+            msg: error.message,
+            traceback: error.stack || ""
           });
         }
+        throw error;
+      } finally {
+        const responseTime = performance.now() - startTime;
+        const consumer = getConsumer(ctx);
+        client.consumerRegistry.addOrUpdateConsumer(consumer);
+        if (!path) {
+          path = getPath(ctx);
+        }
+        if (path) {
+          try {
+            client.requestCounter.addRequest({
+              consumer: consumer == null ? void 0 : consumer.identifier,
+              method: ctx.request.method,
+              path,
+              statusCode: statusCode || ctx.response.status,
+              responseTime,
+              requestSize: ctx.request.length,
+              responseSize: ctx.response.length
+            });
+          } catch (error) {
+            client.logger.error("Error while logging request in Apitally middleware.", {
+              context: ctx,
+              error
+            });
+          }
+        }
+        if (client.requestLogger.enabled) {
+          const logs = logsContext.getStore();
+          client.requestLogger.logRequest({
+            timestamp: Date.now() / 1e3,
+            method: ctx.request.method,
+            path,
+            url: ctx.request.href,
+            headers: convertHeaders(ctx.request.headers),
+            size: ctx.request.length,
+            consumer: consumer == null ? void 0 : consumer.identifier,
+            body: convertBody(ctx.request.body, ctx.request.get("content-type"))
+          }, {
+            statusCode: statusCode || ctx.response.status,
+            responseTime: responseTime / 1e3,
+            headers: convertHeaders(ctx.response.headers),
+            size: ctx.response.length,
+            body: convertBody(ctx.response.body, ctx.response.get("content-type"))
+          }, serverError, logs);
+        }
       }
-      if (client.requestLogger.enabled) {
-        client.requestLogger.logRequest({
-          timestamp: Date.now() / 1e3,
-          method: ctx.request.method,
-          path,
-          url: ctx.request.href,
-          headers: convertHeaders(ctx.request.headers),
-          size: ctx.request.length,
-          consumer: consumer == null ? void 0 : consumer.identifier,
-          body: convertBody(ctx.request.body, ctx.request.get("content-type"))
-        }, {
-          statusCode: statusCode || ctx.response.status,
-          responseTime: responseTime / 1e3,
-          headers: convertHeaders(ctx.response.headers),
-          size: ctx.response.length,
-          body: convertBody(ctx.response.body, ctx.response.get("content-type"))
-        }, serverError);
-      }
-    }
+    });
   };
 }
 __name(getMiddleware, "getMiddleware");