apitally 0.11.5 → 0.13.0

package/dist/hono/middleware.js

@@ -191,6 +191,108 @@ import { unlinkSync as unlinkSync2, writeFileSync } from "fs";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join2 } from "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
+import { createHash } from "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 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
 import { Buffer as Buffer2 } from "buffer";
 import { randomUUID } from "crypto";
@@ -313,6 +415,7 @@ var DEFAULT_CONFIG = {
   logRequestBody: false,
   logResponseHeaders: true,
   logResponseBody: false,
+  logException: true,
   maskQueryParams: [],
   maskHeaders: [],
   excludePaths: []
@@ -385,7 +488,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);
@@ -433,7 +536,13 @@ var _RequestLogger = class _RequestLogger {
     const item = {
       uuid: randomUUID2(),
       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,
@@ -563,104 +672,6 @@ function checkWritableFs() {
 }
 __name(checkWritableFs, "checkWritableFs");
 
-// src/common/serverErrorCounter.ts
-import { createHash } from "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 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
 import { createHash as createHash2 } from "crypto";
 var _ValidationErrorCounter = class _ValidationErrorCounter {
@@ -746,7 +757,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)`);
@@ -1001,6 +1012,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/hono/middleware.ts
 var useApitally = /* @__PURE__ */ __name((app, config) => {
   const client = new ApitallyClient(config);
@@ -1021,7 +1051,7 @@ var getMiddleware = /* @__PURE__ */ __name((client) => {
     let response;
     const responseTime = performance.now() - startTime;
     const [responseSize, newResponse] = await measureResponseSize(c.res);
-    const requestSize = c.req.header("Content-Length");
+    const requestSize = parseContentLength(c.req.header("content-length"));
     const consumer = getConsumer(c);
     client.consumerRegistry.addOrUpdateConsumer(consumer);
     client.requestCounter.addRequest({
@@ -1084,7 +1114,7 @@ var getMiddleware = /* @__PURE__ */ __name((client) => {
         headers: convertHeaders(c.res.headers),
         size: responseSize,
         body: responseBody
-      });
+      }, c.error);
     }
     c.res = response;
   };