apitally 0.11.5 → 0.13.0

package/dist/express/index.cjs

@@ -213,14 +213,116 @@ var RequestCounter = _RequestCounter;
 // src/common/requestLogger.ts
 var import_async_lock = __toESM(require("async-lock"), 1);
 var import_buffer2 = require("buffer");
-var import_crypto2 = require("crypto");
+var import_crypto3 = require("crypto");
 var import_fs2 = require("fs");
 var import_os2 = require("os");
 var import_path2 = require("path");
 
+// src/common/sentry.ts
+var sentry;
+(async () => {
+  try {
+    sentry = await import("@sentry/node");
+  } catch (e) {
+  }
+})();
+function getSentryEventId() {
+  if (sentry && sentry.lastEventId) {
+    return sentry.lastEventId();
+  }
+  return void 0;
+}
+__name(getSentryEventId, "getSentryEventId");
+
+// src/common/serverErrorCounter.ts
+var import_crypto = require("crypto");
+var MAX_MSG_LENGTH = 2048;
+var MAX_STACKTRACE_LENGTH = 65536;
+var _ServerErrorCounter = class _ServerErrorCounter {
+  errorCounts;
+  errorDetails;
+  sentryEventIds;
+  constructor() {
+    this.errorCounts = /* @__PURE__ */ new Map();
+    this.errorDetails = /* @__PURE__ */ new Map();
+    this.sentryEventIds = /* @__PURE__ */ new Map();
+  }
+  addServerError(serverError) {
+    const key = this.getKey(serverError);
+    if (!this.errorDetails.has(key)) {
+      this.errorDetails.set(key, serverError);
+    }
+    this.errorCounts.set(key, (this.errorCounts.get(key) || 0) + 1);
+    const sentryEventId = getSentryEventId();
+    if (sentryEventId) {
+      this.sentryEventIds.set(key, sentryEventId);
+    }
+  }
+  getAndResetServerErrors() {
+    const data = [];
+    this.errorCounts.forEach((count, key) => {
+      const serverError = this.errorDetails.get(key);
+      if (serverError) {
+        data.push({
+          consumer: serverError.consumer || null,
+          method: serverError.method,
+          path: serverError.path,
+          type: serverError.type,
+          msg: truncateExceptionMessage(serverError.msg),
+          traceback: truncateExceptionStackTrace(serverError.traceback),
+          sentry_event_id: this.sentryEventIds.get(key) || null,
+          error_count: count
+        });
+      }
+    });
+    this.errorCounts.clear();
+    this.errorDetails.clear();
+    return data;
+  }
+  getKey(serverError) {
+    const hashInput = [
+      serverError.consumer || "",
+      serverError.method.toUpperCase(),
+      serverError.path,
+      serverError.type,
+      serverError.msg.trim(),
+      serverError.traceback.trim()
+    ].join("|");
+    return (0, import_crypto.createHash)("md5").update(hashInput).digest("hex");
+  }
+};
+__name(_ServerErrorCounter, "ServerErrorCounter");
+var ServerErrorCounter = _ServerErrorCounter;
+function truncateExceptionMessage(msg) {
+  if (msg.length <= MAX_MSG_LENGTH) {
+    return msg;
+  }
+  const suffix = "... (truncated)";
+  const cutoff = MAX_MSG_LENGTH - suffix.length;
+  return msg.substring(0, cutoff) + suffix;
+}
+__name(truncateExceptionMessage, "truncateExceptionMessage");
+function truncateExceptionStackTrace(stack) {
+  const suffix = "... (truncated) ...";
+  const cutoff = MAX_STACKTRACE_LENGTH - suffix.length;
+  const lines = stack.trim().split("\n");
+  const truncatedLines = [];
+  let length = 0;
+  for (const line of lines) {
+    if (length + line.length + 1 > cutoff) {
+      truncatedLines.push(suffix);
+      break;
+    }
+    truncatedLines.push(line);
+    length += line.length + 1;
+  }
+  return truncatedLines.join("\n");
+}
+__name(truncateExceptionStackTrace, "truncateExceptionStackTrace");
+
 // src/common/tempGzipFile.ts
 var import_buffer = require("buffer");
-var import_crypto = require("crypto");
+var import_crypto2 = require("crypto");
 var import_fs = require("fs");
 var import_os = require("os");
 var import_path = require("path");
@@ -233,7 +335,7 @@ var _TempGzipFile = class _TempGzipFile {
   readyPromise;
   closedPromise;
   constructor() {
-    this.uuid = (0, import_crypto.randomUUID)();
+    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.readyPromise = new Promise((resolve, reject) => {
@@ -340,6 +442,7 @@ var DEFAULT_CONFIG = {
   logRequestBody: false,
   logResponseHeaders: true,
   logResponseBody: false,
+  logException: true,
   maskQueryParams: [],
   maskHeaders: [],
   excludePaths: []
@@ -412,7 +515,7 @@ var _RequestLogger = class _RequestLogger {
       this.shouldMaskHeader(k) ? MASKED : v
     ]);
   }
-  logRequest(request, response) {
+  logRequest(request, response, error) {
     var _a2, _b, _c;
     if (!this.enabled || this.suspendUntil !== null) return;
     const url = new URL(request.url);
@@ -458,9 +561,15 @@ var _RequestLogger = class _RequestLogger {
     request.headers = this.config.logRequestHeaders ? this.maskHeaders(request.headers) : [];
     response.headers = this.config.logResponseHeaders ? this.maskHeaders(response.headers) : [];
     const item = {
-      uuid: (0, import_crypto2.randomUUID)(),
+      uuid: (0, import_crypto3.randomUUID)(),
       request: skipEmptyValues(request),
-      response: skipEmptyValues(response)
+      response: skipEmptyValues(response),
+      exception: error && this.config.logException ? {
+        type: error.name,
+        message: truncateExceptionMessage(error.message),
+        stacktrace: truncateExceptionStackTrace(error.stack || ""),
+        sentryEventId: getSentryEventId()
+      } : null
     };
     [
       item.request.body,
@@ -612,7 +721,7 @@ function skipEmptyValues(data) {
 __name(skipEmptyValues, "skipEmptyValues");
 function checkWritableFs() {
   try {
-    const testPath = (0, import_path2.join)((0, import_os2.tmpdir)(), `apitally-${(0, import_crypto2.randomUUID)()}`);
+    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);
     return true;
@@ -622,104 +731,6 @@ function checkWritableFs() {
 }
 __name(checkWritableFs, "checkWritableFs");
 
-// src/common/serverErrorCounter.ts
-var import_crypto3 = require("crypto");
-var MAX_MSG_LENGTH = 2048;
-var MAX_STACKTRACE_LENGTH = 65536;
-var _ServerErrorCounter = class _ServerErrorCounter {
-  errorCounts;
-  errorDetails;
-  sentryEventIds;
-  sentry;
-  constructor() {
-    this.errorCounts = /* @__PURE__ */ new Map();
-    this.errorDetails = /* @__PURE__ */ new Map();
-    this.sentryEventIds = /* @__PURE__ */ new Map();
-    this.tryImportSentry();
-  }
-  addServerError(serverError) {
-    const key = this.getKey(serverError);
-    if (!this.errorDetails.has(key)) {
-      this.errorDetails.set(key, serverError);
-    }
-    this.errorCounts.set(key, (this.errorCounts.get(key) || 0) + 1);
-    this.captureSentryEventId(key);
-  }
-  getAndResetServerErrors() {
-    const data = [];
-    this.errorCounts.forEach((count, key) => {
-      const serverError = this.errorDetails.get(key);
-      if (serverError) {
-        data.push({
-          consumer: serverError.consumer || null,
-          method: serverError.method,
-          path: serverError.path,
-          type: serverError.type,
-          msg: this.getTruncatedMessage(serverError.msg),
-          traceback: this.getTruncatedStack(serverError.traceback),
-          sentry_event_id: this.sentryEventIds.get(key) || null,
-          error_count: count
-        });
-      }
-    });
-    this.errorCounts.clear();
-    this.errorDetails.clear();
-    return data;
-  }
-  getKey(serverError) {
-    const hashInput = [
-      serverError.consumer || "",
-      serverError.method.toUpperCase(),
-      serverError.path,
-      serverError.type,
-      serverError.msg.trim(),
-      serverError.traceback.trim()
-    ].join("|");
-    return (0, import_crypto3.createHash)("md5").update(hashInput).digest("hex");
-  }
-  getTruncatedMessage(msg) {
-    msg = msg.trim();
-    if (msg.length <= MAX_MSG_LENGTH) {
-      return msg;
-    }
-    const suffix = "... (truncated)";
-    const cutoff = MAX_MSG_LENGTH - suffix.length;
-    return msg.substring(0, cutoff) + suffix;
-  }
-  getTruncatedStack(stack) {
-    const suffix = "... (truncated) ...";
-    const cutoff = MAX_STACKTRACE_LENGTH - suffix.length;
-    const lines = stack.trim().split("\n");
-    const truncatedLines = [];
-    let length = 0;
-    for (const line of lines) {
-      if (length + line.length + 1 > cutoff) {
-        truncatedLines.push(suffix);
-        break;
-      }
-      truncatedLines.push(line);
-      length += line.length + 1;
-    }
-    return truncatedLines.join("\n");
-  }
-  captureSentryEventId(serverErrorKey) {
-    if (this.sentry && this.sentry.lastEventId) {
-      const eventId = this.sentry.lastEventId();
-      if (eventId) {
-        this.sentryEventIds.set(serverErrorKey, eventId);
-      }
-    }
-  }
-  async tryImportSentry() {
-    try {
-      this.sentry = await import("@sentry/node");
-    } catch (e) {
-    }
-  }
-};
-__name(_ServerErrorCounter, "ServerErrorCounter");
-var ServerErrorCounter = _ServerErrorCounter;
-
 // src/common/validationErrorCounter.ts
 var import_crypto4 = require("crypto");
 var _ValidationErrorCounter = class _ValidationErrorCounter {
@@ -805,7 +816,7 @@ var _ApitallyClient = class _ApitallyClient {
       throw new Error("Apitally client is already initialized");
     }
     if (!isValidClientId(clientId)) {
-      throw new Error(`Invalid client ID '${clientId}' (expecting hexadeciaml UUID format)`);
+      throw new Error(`Invalid Apitally client ID '${clientId}' (expecting hexadecimal UUID format)`);
     }
     if (!isValidEnv(env)) {
       throw new Error(`Invalid env '${env}' (expecting 1-32 alphanumeric lowercase characters and hyphens only)`);
@@ -1061,6 +1072,25 @@ function getPackageVersion(name) {
 }
 __name(getPackageVersion, "getPackageVersion");
 
+// src/common/utils.ts
+function parseContentLength(contentLength) {
+  if (contentLength === void 0 || contentLength === null) {
+    return void 0;
+  }
+  if (typeof contentLength === "number") {
+    return contentLength;
+  }
+  if (typeof contentLength === "string") {
+    const parsed = parseInt(contentLength);
+    return isNaN(parsed) ? void 0 : parsed;
+  }
+  if (Array.isArray(contentLength)) {
+    return parseContentLength(contentLength[0]);
+  }
+  return void 0;
+}
+__name(parseContentLength, "parseContentLength");
+
 // src/express/utils.js
 var regExpToParseExpressPathRegExp = /^\/\^\\?\/?(?:(:?[\w\\.-]*(?:\\\/:?[\w\\.-]*)*)|(\(\?:\\?\/?\([^)]+\)\)))\\\/.*/;
 var regExpToReplaceExpressPathRegExpParams = /\(\?:\\?\/?\([^)]+\)\)/;
@@ -1226,6 +1256,8 @@ var getMiddleware = /* @__PURE__ */ __name((app, client) => {
           const path = getRoutePath(req);
           const consumer = getConsumer(req);
           client.consumerRegistry.addOrUpdateConsumer(consumer);
+          const requestSize = parseContentLength(req.get("content-length"));
+          const responseSize = parseContentLength(res.get("content-length"));
           if (path) {
             client.requestCounter.addRequest({
               consumer: consumer == null ? void 0 : consumer.identifier,
@@ -1233,8 +1265,8 @@ var getMiddleware = /* @__PURE__ */ __name((app, client) => {
               path,
               statusCode: res.statusCode,
               responseTime,
-              requestSize: req.get("content-length"),
-              responseSize: res.get("content-length")
+              requestSize,
+              responseSize
             });
             if ((res.statusCode === 400 || res.statusCode === 422) && res.locals.body) {
               let jsonBody;
@@ -1282,16 +1314,16 @@ var getMiddleware = /* @__PURE__ */ __name((app, client) => {
               path,
               url: `${req.protocol}://${req.host}${req.originalUrl}`,
               headers: convertHeaders(req.headers),
-              size: Number(req.get("content-length")),
+              size: requestSize,
               consumer: consumer == null ? void 0 : consumer.identifier,
               body: convertBody(req.body, req.get("content-type"))
             }, {
               statusCode: res.statusCode,
               responseTime: responseTime / 1e3,
               headers: convertHeaders(res.getHeaders()),
-              size: Number(res.get("content-length")),
+              size: responseSize,
               body: convertBody(res.locals.body, res.get("content-type"))
-            });
+            }, res.locals.serverError);
           }
         } catch (error) {
           client.logger.error("Error while logging request in Apitally middleware.", {