apitally 0.11.4 → 0.12.0

package/dist/hono/middleware.cjs

@@ -212,14 +212,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");
@@ -232,16 +334,16 @@ 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) => {
       this.writeStream.once("ready", resolve);
       this.writeStream.once("error", reject);
     });
-    this.closedPromise = new Promise((resolve) => {
+    this.closedPromise = new Promise((resolve, reject) => {
       this.writeStream.once("close", resolve);
-      this.writeStream.once("error", resolve);
+      this.writeStream.once("error", reject);
     });
     this.gzip = (0, import_zlib.createGzip)();
     this.gzip.pipe(this.writeStream);
@@ -339,6 +441,7 @@ var DEFAULT_CONFIG = {
   logRequestBody: false,
   logResponseHeaders: true,
   logResponseBody: false,
+  logException: true,
   maskQueryParams: [],
   maskHeaders: [],
   excludePaths: []
@@ -391,7 +494,10 @@ var _RequestLogger = class _RequestLogger {
   hasSupportedContentType(headers) {
     var _a2;
     const contentType = (_a2 = headers.find(([k]) => k.toLowerCase() === "content-type")) == null ? void 0 : _a2[1];
-    return contentType !== void 0 && ALLOWED_CONTENT_TYPES.some((t) => contentType.startsWith(t));
+    return this.isSupportedContentType(contentType);
+  }
+  isSupportedContentType(contentType) {
+    return typeof contentType === "string" && ALLOWED_CONTENT_TYPES.some((t) => contentType.startsWith(t));
   }
   maskQueryParams(search) {
     const params = new URLSearchParams(search);
@@ -408,7 +514,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);
@@ -419,8 +525,6 @@ var _RequestLogger = class _RequestLogger {
     }
     url.search = this.config.logQueryParams ? this.maskQueryParams(url.search) : "";
     request.url = url.toString();
-    request.headers = this.config.logRequestHeaders ? this.maskHeaders(request.headers) : [];
-    response.headers = this.config.logResponseHeaders ? this.maskHeaders(response.headers) : [];
     if (!this.config.logRequestBody || !this.hasSupportedContentType(request.headers)) {
       request.body = void 0;
     } else if (request.body) {
@@ -453,10 +557,18 @@ 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,
@@ -576,7 +688,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;
@@ -586,104 +698,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 {
@@ -757,6 +771,7 @@ var _ApitallyClient = class _ApitallyClient {
   syncIntervalId;
   startupData;
   startupDataSent = false;
+  enabled = true;
   requestCounter;
   requestLogger;
   validationErrorCounter;
@@ -793,12 +808,16 @@ var _ApitallyClient = class _ApitallyClient {
     }
     return _ApitallyClient.instance;
   }
+  isEnabled() {
+    return this.enabled;
+  }
   static async shutdown() {
     if (_ApitallyClient.instance) {
       await _ApitallyClient.instance.handleShutdown();
     }
   }
   async handleShutdown() {
+    this.enabled = false;
     this.stopSync();
     await this.sendSyncData();
     await this.sendLogData();
@@ -982,6 +1001,7 @@ var _ApitallyClient = class _ApitallyClient {
     if (error instanceof HTTPError) {
       if (error.response.status === 404) {
         this.logger.error(`Invalid Apitally client ID: '${this.clientId}'`);
+        this.enabled = false;
         this.stopSync();
         return true;
       }
@@ -1030,6 +1050,10 @@ var useApitally = /* @__PURE__ */ __name((app, config) => {
 }, "useApitally");
 var getMiddleware = /* @__PURE__ */ __name((client) => {
   return async (c, next) => {
+    if (!client.isEnabled()) {
+      await next();
+      return;
+    }
     const startTime = import_perf_hooks.performance.now();
     await next();
     let response;
@@ -1075,10 +1099,11 @@ var getMiddleware = /* @__PURE__ */ __name((client) => {
       let requestBody;
       let responseBody;
       let newResponse2 = response;
+      const responseContentType = c.res.headers.get("content-type");
       if (client.requestLogger.config.logRequestBody) {
         requestBody = Buffer.from(await c.req.arrayBuffer());
       }
-      if (client.requestLogger.config.logResponseBody) {
+      if (client.requestLogger.config.logResponseBody && client.requestLogger.isSupportedContentType(responseContentType)) {
         [responseBody, newResponse2] = await getResponseBody(response);
         response = newResponse2;
       }
@@ -1097,7 +1122,7 @@ var getMiddleware = /* @__PURE__ */ __name((client) => {
         headers: convertHeaders(c.res.headers),
         size: responseSize,
         body: responseBody
-      });
+      }, c.error);
     }
     c.res = response;
   };