apitally 0.17.4 → 0.18.1

package/dist/nestjs/index.cjs

@@ -7,6 +7,9 @@ var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -11020,272 +11023,217 @@ var require_cjs = __commonJS({
   }
 });
 
-// src/nestjs/index.ts
-var nestjs_exports = {};
-__export(nestjs_exports, {
-  setConsumer: () => setConsumer,
-  useApitally: () => useApitally2
-});
-module.exports = __toCommonJS(nestjs_exports);
-var import_common = require("@nestjs/common");
-var import_rxjs = __toESM(require_cjs(), 1);
-
-// src/express/middleware.ts
-var import_perf_hooks = require("perf_hooks");
-
-// src/common/client.ts
-var import_crypto5 = require("crypto");
-var import_fetch_retry = __toESM(require("fetch-retry"), 1);
-
 // src/common/consumerRegistry.ts
-var consumerFromStringOrObject = /* @__PURE__ */ __name((consumer) => {
-  var _a3, _b;
-  if (typeof consumer === "string") {
-    consumer = String(consumer).trim().substring(0, 128);
-    return consumer ? {
-      identifier: consumer
-    } : null;
-  } else {
-    consumer.identifier = String(consumer.identifier).trim().substring(0, 128);
-    consumer.name = (_a3 = consumer.name) == null ? void 0 : _a3.trim().substring(0, 64);
-    consumer.group = (_b = consumer.group) == null ? void 0 : _b.trim().substring(0, 64);
-    return consumer.identifier ? consumer : null;
-  }
-}, "consumerFromStringOrObject");
-var _ConsumerRegistry = class _ConsumerRegistry {
-  consumers;
-  updated;
-  constructor() {
-    this.consumers = /* @__PURE__ */ new Map();
-    this.updated = /* @__PURE__ */ new Set();
-  }
-  addOrUpdateConsumer(consumer) {
-    if (!consumer || !consumer.name && !consumer.group) {
-      return;
-    }
-    const existing = this.consumers.get(consumer.identifier);
-    if (!existing) {
-      this.consumers.set(consumer.identifier, consumer);
-      this.updated.add(consumer.identifier);
-    } else {
-      if (consumer.name && consumer.name !== existing.name) {
-        existing.name = consumer.name;
-        this.updated.add(consumer.identifier);
-      }
-      if (consumer.group && consumer.group !== existing.group) {
-        existing.group = consumer.group;
-        this.updated.add(consumer.identifier);
+var consumerFromStringOrObject, _ConsumerRegistry, ConsumerRegistry;
+var init_consumerRegistry = __esm({
+  "src/common/consumerRegistry.ts"() {
+    "use strict";
+    consumerFromStringOrObject = /* @__PURE__ */ __name((consumer) => {
+      var _a3, _b;
+      if (typeof consumer === "string") {
+        consumer = String(consumer).trim().substring(0, 128);
+        return consumer ? {
+          identifier: consumer
+        } : null;
+      } else {
+        consumer.identifier = String(consumer.identifier).trim().substring(0, 128);
+        consumer.name = (_a3 = consumer.name) == null ? void 0 : _a3.trim().substring(0, 64);
+        consumer.group = (_b = consumer.group) == null ? void 0 : _b.trim().substring(0, 64);
+        return consumer.identifier ? consumer : null;
+      }
+    }, "consumerFromStringOrObject");
+    _ConsumerRegistry = class _ConsumerRegistry {
+      consumers;
+      updated;
+      constructor() {
+        this.consumers = /* @__PURE__ */ new Map();
+        this.updated = /* @__PURE__ */ new Set();
+      }
+      addOrUpdateConsumer(consumer) {
+        if (!consumer || !consumer.name && !consumer.group) {
+          return;
+        }
+        const existing = this.consumers.get(consumer.identifier);
+        if (!existing) {
+          this.consumers.set(consumer.identifier, consumer);
+          this.updated.add(consumer.identifier);
+        } else {
+          if (consumer.name && consumer.name !== existing.name) {
+            existing.name = consumer.name;
+            this.updated.add(consumer.identifier);
+          }
+          if (consumer.group && consumer.group !== existing.group) {
+            existing.group = consumer.group;
+            this.updated.add(consumer.identifier);
+          }
+        }
       }
-    }
-  }
-  getAndResetUpdatedConsumers() {
-    const data = [];
-    this.updated.forEach((identifier) => {
-      const consumer = this.consumers.get(identifier);
-      if (consumer) {
-        data.push(consumer);
+      getAndResetUpdatedConsumers() {
+        const data = [];
+        this.updated.forEach((identifier) => {
+          const consumer = this.consumers.get(identifier);
+          if (consumer) {
+            data.push(consumer);
+          }
+        });
+        this.updated.clear();
+        return data;
       }
-    });
-    this.updated.clear();
-    return data;
+    };
+    __name(_ConsumerRegistry, "ConsumerRegistry");
+    ConsumerRegistry = _ConsumerRegistry;
   }
-};
-__name(_ConsumerRegistry, "ConsumerRegistry");
-var ConsumerRegistry = _ConsumerRegistry;
+});
 
 // src/common/logging.ts
-var import_winston = require("winston");
-var getLogger = /* @__PURE__ */ __name(() => {
-  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}`)),
-    transports: [
-      new import_winston.transports.Console()
-    ]
-  });
-}, "getLogger");
+var import_winston, getLogger;
+var init_logging = __esm({
+  "src/common/logging.ts"() {
+    "use strict";
+    import_winston = require("winston");
+    getLogger = /* @__PURE__ */ __name(() => {
+      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}`)),
+        transports: [
+          new import_winston.transports.Console()
+        ]
+      });
+    }, "getLogger");
+  }
+});
 
 // src/common/paramValidation.ts
 function isValidClientId(clientId) {
   const regexExp = /^[0-9a-f]{8}-[0-9a-f]{4}-[4][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
   return regexExp.test(clientId);
 }
-__name(isValidClientId, "isValidClientId");
 function isValidEnv(env) {
   const regexExp = /^[\w-]{1,32}$/;
   return regexExp.test(env);
 }
-__name(isValidEnv, "isValidEnv");
+var init_paramValidation = __esm({
+  "src/common/paramValidation.ts"() {
+    "use strict";
+    __name(isValidClientId, "isValidClientId");
+    __name(isValidEnv, "isValidEnv");
+  }
+});
 
 // src/common/requestCounter.ts
-var _RequestCounter = class _RequestCounter {
-  requestCounts;
-  requestSizeSums;
-  responseSizeSums;
-  responseTimes;
-  requestSizes;
-  responseSizes;
-  constructor() {
-    this.requestCounts = /* @__PURE__ */ new Map();
-    this.requestSizeSums = /* @__PURE__ */ new Map();
-    this.responseSizeSums = /* @__PURE__ */ new Map();
-    this.responseTimes = /* @__PURE__ */ new Map();
-    this.requestSizes = /* @__PURE__ */ new Map();
-    this.responseSizes = /* @__PURE__ */ new Map();
-  }
-  getKey(requestInfo) {
-    return [
-      requestInfo.consumer || "",
-      requestInfo.method.toUpperCase(),
-      requestInfo.path,
-      requestInfo.statusCode
-    ].join("|");
-  }
-  addRequest(requestInfo) {
-    const key = this.getKey(requestInfo);
-    this.requestCounts.set(key, (this.requestCounts.get(key) || 0) + 1);
-    if (!this.responseTimes.has(key)) {
-      this.responseTimes.set(key, /* @__PURE__ */ new Map());
-    }
-    const responseTimeMap = this.responseTimes.get(key);
-    const responseTimeMsBin = Math.floor(requestInfo.responseTime / 10) * 10;
-    responseTimeMap.set(responseTimeMsBin, (responseTimeMap.get(responseTimeMsBin) || 0) + 1);
-    if (requestInfo.requestSize !== void 0) {
-      requestInfo.requestSize = Number(requestInfo.requestSize);
-      this.requestSizeSums.set(key, (this.requestSizeSums.get(key) || 0) + requestInfo.requestSize);
-      if (!this.requestSizes.has(key)) {
-        this.requestSizes.set(key, /* @__PURE__ */ new Map());
-      }
-      const requestSizeMap = this.requestSizes.get(key);
-      const requestSizeKbBin = Math.floor(requestInfo.requestSize / 1e3);
-      requestSizeMap.set(requestSizeKbBin, (requestSizeMap.get(requestSizeKbBin) || 0) + 1);
-    }
-    if (requestInfo.responseSize !== void 0) {
-      requestInfo.responseSize = Number(requestInfo.responseSize);
-      this.responseSizeSums.set(key, (this.responseSizeSums.get(key) || 0) + requestInfo.responseSize);
-      if (!this.responseSizes.has(key)) {
-        this.responseSizes.set(key, /* @__PURE__ */ new Map());
-      }
-      const responseSizeMap = this.responseSizes.get(key);
-      const responseSizeKbBin = Math.floor(requestInfo.responseSize / 1e3);
-      responseSizeMap.set(responseSizeKbBin, (responseSizeMap.get(responseSizeKbBin) || 0) + 1);
-    }
-  }
-  getAndResetRequests() {
-    const data = [];
-    this.requestCounts.forEach((count, key) => {
-      const [consumer, method, path, statusCodeStr] = key.split("|");
-      const responseTimes = this.responseTimes.get(key) || /* @__PURE__ */ new Map();
-      const requestSizes = this.requestSizes.get(key) || /* @__PURE__ */ new Map();
-      const responseSizes = this.responseSizes.get(key) || /* @__PURE__ */ new Map();
-      data.push({
-        consumer: consumer || null,
-        method,
-        path,
-        status_code: parseInt(statusCodeStr),
-        request_count: count,
-        request_size_sum: this.requestSizeSums.get(key) || 0,
-        response_size_sum: this.responseSizeSums.get(key) || 0,
-        response_times: Object.fromEntries(responseTimes),
-        request_sizes: Object.fromEntries(requestSizes),
-        response_sizes: Object.fromEntries(responseSizes)
-      });
-    });
-    this.requestCounts.clear();
-    this.requestSizeSums.clear();
-    this.responseSizeSums.clear();
-    this.responseTimes.clear();
-    this.requestSizes.clear();
-    this.responseSizes.clear();
-    return data;
+var _RequestCounter, RequestCounter;
+var init_requestCounter = __esm({
+  "src/common/requestCounter.ts"() {
+    "use strict";
+    _RequestCounter = class _RequestCounter {
+      requestCounts;
+      requestSizeSums;
+      responseSizeSums;
+      responseTimes;
+      requestSizes;
+      responseSizes;
+      constructor() {
+        this.requestCounts = /* @__PURE__ */ new Map();
+        this.requestSizeSums = /* @__PURE__ */ new Map();
+        this.responseSizeSums = /* @__PURE__ */ new Map();
+        this.responseTimes = /* @__PURE__ */ new Map();
+        this.requestSizes = /* @__PURE__ */ new Map();
+        this.responseSizes = /* @__PURE__ */ new Map();
+      }
+      getKey(requestInfo) {
+        return [
+          requestInfo.consumer || "",
+          requestInfo.method.toUpperCase(),
+          requestInfo.path,
+          requestInfo.statusCode
+        ].join("|");
+      }
+      addRequest(requestInfo) {
+        const key = this.getKey(requestInfo);
+        this.requestCounts.set(key, (this.requestCounts.get(key) || 0) + 1);
+        if (!this.responseTimes.has(key)) {
+          this.responseTimes.set(key, /* @__PURE__ */ new Map());
+        }
+        const responseTimeMap = this.responseTimes.get(key);
+        const responseTimeMsBin = Math.floor(requestInfo.responseTime / 10) * 10;
+        responseTimeMap.set(responseTimeMsBin, (responseTimeMap.get(responseTimeMsBin) || 0) + 1);
+        if (requestInfo.requestSize !== void 0) {
+          requestInfo.requestSize = Number(requestInfo.requestSize);
+          this.requestSizeSums.set(key, (this.requestSizeSums.get(key) || 0) + requestInfo.requestSize);
+          if (!this.requestSizes.has(key)) {
+            this.requestSizes.set(key, /* @__PURE__ */ new Map());
+          }
+          const requestSizeMap = this.requestSizes.get(key);
+          const requestSizeKbBin = Math.floor(requestInfo.requestSize / 1e3);
+          requestSizeMap.set(requestSizeKbBin, (requestSizeMap.get(requestSizeKbBin) || 0) + 1);
+        }
+        if (requestInfo.responseSize !== void 0) {
+          requestInfo.responseSize = Number(requestInfo.responseSize);
+          this.responseSizeSums.set(key, (this.responseSizeSums.get(key) || 0) + requestInfo.responseSize);
+          if (!this.responseSizes.has(key)) {
+            this.responseSizes.set(key, /* @__PURE__ */ new Map());
+          }
+          const responseSizeMap = this.responseSizes.get(key);
+          const responseSizeKbBin = Math.floor(requestInfo.responseSize / 1e3);
+          responseSizeMap.set(responseSizeKbBin, (responseSizeMap.get(responseSizeKbBin) || 0) + 1);
+        }
+      }
+      getAndResetRequests() {
+        const data = [];
+        this.requestCounts.forEach((count, key) => {
+          const [consumer, method, path, statusCodeStr] = key.split("|");
+          const responseTimes = this.responseTimes.get(key) || /* @__PURE__ */ new Map();
+          const requestSizes = this.requestSizes.get(key) || /* @__PURE__ */ new Map();
+          const responseSizes = this.responseSizes.get(key) || /* @__PURE__ */ new Map();
+          data.push({
+            consumer: consumer || null,
+            method,
+            path,
+            status_code: parseInt(statusCodeStr),
+            request_count: count,
+            request_size_sum: this.requestSizeSums.get(key) || 0,
+            response_size_sum: this.responseSizeSums.get(key) || 0,
+            response_times: Object.fromEntries(responseTimes),
+            request_sizes: Object.fromEntries(requestSizes),
+            response_sizes: Object.fromEntries(responseSizes)
+          });
+        });
+        this.requestCounts.clear();
+        this.requestSizeSums.clear();
+        this.responseSizeSums.clear();
+        this.responseTimes.clear();
+        this.requestSizes.clear();
+        this.responseSizes.clear();
+        return data;
+      }
+    };
+    __name(_RequestCounter, "RequestCounter");
+    RequestCounter = _RequestCounter;
   }
-};
-__name(_RequestCounter, "RequestCounter");
-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");
+});
 
 // 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
-        });
+var sentry;
+var init_sentry = __esm({
+  "src/common/sentry.ts"() {
+    "use strict";
+    (async () => {
+      try {
+        sentry = await import("@sentry/node");
+      } catch (e) {
       }
-    });
-    this.errorCounts.clear();
-    this.errorDetails.clear();
-    return data;
+    })();
+    __name(getSentryEventId, "getSentryEventId");
   }
-  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;
+});
+
+// src/common/serverErrorCounter.ts
 function truncateExceptionMessage(msg) {
   if (msg.length <= MAX_MSG_LENGTH) {
     return msg;
@@ -11294,7 +11242,6 @@ function truncateExceptionMessage(msg) {
   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;
@@ -11311,413 +11258,155 @@ function truncateExceptionStackTrace(stack) {
   }
   return truncatedLines.join("\n");
 }
-__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 _TempGzipFile = class _TempGzipFile {
-  uuid;
-  filePath;
-  gzip;
-  writeStream;
-  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.readyPromise = new Promise((resolve, reject) => {
-      this.writeStream.once("ready", resolve);
-      this.writeStream.once("error", reject);
-    });
-    this.closedPromise = new Promise((resolve, reject) => {
-      this.writeStream.once("close", resolve);
-      this.writeStream.once("error", reject);
-    });
-    this.gzip = (0, import_zlib.createGzip)();
-    this.gzip.pipe(this.writeStream);
-  }
-  get size() {
-    return this.writeStream.bytesWritten;
-  }
-  async writeLine(data) {
-    await this.readyPromise;
-    return new Promise((resolve, reject) => {
-      this.gzip.write(import_buffer.Buffer.concat([
-        data,
-        import_buffer.Buffer.from("\n")
-      ]), (error) => {
-        if (error) {
-          reject(error);
-        } else {
-          resolve();
-        }
-      });
-    });
-  }
-  async getContent() {
-    return new Promise((resolve, reject) => {
-      (0, import_fs.readFile)(this.filePath, (error, data) => {
-        if (error) {
-          reject(error);
-        } else {
-          resolve(data);
-        }
-      });
-    });
-  }
-  async close() {
-    await new Promise((resolve) => {
-      this.gzip.end(() => {
-        resolve();
-      });
-    });
-    await this.closedPromise;
-  }
-  async delete() {
-    await this.close();
-    (0, import_fs.unlinkSync)(this.filePath);
-  }
-};
-__name(_TempGzipFile, "TempGzipFile");
-var TempGzipFile = _TempGzipFile;
-
-// src/common/requestLogger.ts
-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 MASKED = "******";
-var ALLOWED_CONTENT_TYPES = [
-  "application/json",
-  "application/problem+json",
-  "application/vnd.api+json",
-  "text/plain"
-];
-var EXCLUDE_PATH_PATTERNS = [
-  /\/_?healthz?$/i,
-  /\/_?health[_-]?checks?$/i,
-  /\/_?heart[_-]?beats?$/i,
-  /\/ping$/i,
-  /\/ready$/i,
-  /\/live$/i
-];
-var EXCLUDE_USER_AGENT_PATTERNS = [
-  /health[-_ ]?check/i,
-  /microsoft-azure-application-lb/i,
-  /googlehc/i,
-  /kube-probe/i
-];
-var MASK_QUERY_PARAM_PATTERNS = [
-  /auth/i,
-  /api-?key/i,
-  /secret/i,
-  /token/i,
-  /password/i,
-  /pwd/i
-];
-var MASK_HEADER_PATTERNS = [
-  /auth/i,
-  /api-?key/i,
-  /secret/i,
-  /token/i,
-  /cookie/i
-];
-var MASK_BODY_FIELD_PATTERNS = [
-  /password/i,
-  /pwd/i,
-  /token/i,
-  /secret/i,
-  /auth/i,
-  /card[-_ ]?number/i,
-  /ccv/i,
-  /ssn/i
-];
-var DEFAULT_CONFIG = {
-  enabled: false,
-  logQueryParams: true,
-  logRequestHeaders: false,
-  logRequestBody: false,
-  logResponseHeaders: true,
-  logResponseBody: false,
-  logException: true,
-  maskQueryParams: [],
-  maskHeaders: [],
-  maskBodyFields: [],
-  excludePaths: []
-};
-var _RequestLogger = class _RequestLogger {
-  config;
-  enabled;
-  suspendUntil = null;
-  pendingWrites = [];
-  currentFile = null;
-  files = [];
-  maintainIntervalId;
-  lock = new import_async_lock.default();
-  constructor(config) {
-    this.config = {
-      ...DEFAULT_CONFIG,
-      ...config
-    };
-    this.enabled = this.config.enabled && checkWritableFs();
-    if (this.enabled) {
-      this.maintainIntervalId = setInterval(() => {
-        this.maintain();
-      }, 1e3);
-    }
-  }
-  get maxBodySize() {
-    return MAX_BODY_SIZE;
-  }
-  shouldExcludePath(urlPath) {
-    const patterns = [
-      ...this.config.excludePaths,
-      ...EXCLUDE_PATH_PATTERNS
-    ];
-    return matchPatterns(urlPath, patterns);
-  }
-  shouldExcludeUserAgent(userAgent) {
-    return userAgent ? matchPatterns(userAgent, EXCLUDE_USER_AGENT_PATTERNS) : false;
-  }
-  shouldMaskQueryParam(name) {
-    const patterns = [
-      ...this.config.maskQueryParams,
-      ...MASK_QUERY_PARAM_PATTERNS
-    ];
-    return matchPatterns(name, patterns);
-  }
-  shouldMaskHeader(name) {
-    const patterns = [
-      ...this.config.maskHeaders,
-      ...MASK_HEADER_PATTERNS
-    ];
-    return matchPatterns(name, patterns);
-  }
-  shouldMaskBodyField(name) {
-    const patterns = [
-      ...this.config.maskBodyFields,
-      ...MASK_BODY_FIELD_PATTERNS
-    ];
-    return matchPatterns(name, patterns);
-  }
-  hasSupportedContentType(headers) {
-    var _a3;
-    const contentType = (_a3 = headers.find(([k]) => k.toLowerCase() === "content-type")) == null ? void 0 : _a3[1];
-    return this.isSupportedContentType(contentType);
-  }
-  hasJsonContentType(headers) {
-    var _a3;
-    const contentType = (_a3 = headers.find(([k]) => k.toLowerCase() === "content-type")) == null ? void 0 : _a3[1];
-    return contentType ? /\bjson\b/i.test(contentType) : null;
-  }
-  isSupportedContentType(contentType) {
-    return typeof contentType === "string" && ALLOWED_CONTENT_TYPES.some((t) => contentType.startsWith(t));
-  }
-  maskQueryParams(search) {
-    const params = new URLSearchParams(search);
-    for (const [key] of params) {
-      if (this.shouldMaskQueryParam(key)) {
-        params.set(key, MASKED);
-      }
-    }
-    return params.toString();
-  }
-  maskHeaders(headers) {
-    return headers.map(([k, v]) => [
-      k,
-      this.shouldMaskHeader(k) ? MASKED : v
-    ]);
-  }
-  maskBody(data) {
-    if (typeof data === "object" && data !== null && !Array.isArray(data)) {
-      const result = {};
-      for (const [key, value] of Object.entries(data)) {
-        if (typeof value === "string" && this.shouldMaskBodyField(key)) {
-          result[key] = MASKED;
-        } else {
-          result[key] = this.maskBody(value);
-        }
-      }
-      return result;
-    }
-    if (Array.isArray(data)) {
-      return data.map((item) => this.maskBody(item));
-    }
-    return data;
-  }
-  applyMasking(item) {
-    if (this.config.maskRequestBodyCallback && item.request.body && item.request.body !== BODY_TOO_LARGE) {
-      try {
-        const maskedBody = this.config.maskRequestBodyCallback(item.request);
-        item.request.body = maskedBody ?? BODY_MASKED;
-      } catch {
-        item.request.body = void 0;
-      }
-    }
-    if (this.config.maskResponseBodyCallback && item.response.body && item.response.body !== BODY_TOO_LARGE) {
-      try {
-        const maskedBody = this.config.maskResponseBodyCallback(item.request, item.response);
-        item.response.body = maskedBody ?? BODY_MASKED;
-      } catch {
-        item.response.body = void 0;
-      }
-    }
-    if (item.request.body && item.request.body.length > MAX_BODY_SIZE) {
-      item.request.body = BODY_TOO_LARGE;
-    }
-    if (item.response.body && item.response.body.length > MAX_BODY_SIZE) {
-      item.response.body = BODY_TOO_LARGE;
-    }
-    for (const key of [
-      "request",
-      "response"
-    ]) {
-      const bodyData = item[key].body;
-      if (!bodyData || bodyData === BODY_TOO_LARGE || bodyData === BODY_MASKED) {
-        continue;
+var import_crypto, MAX_MSG_LENGTH, MAX_STACKTRACE_LENGTH, _ServerErrorCounter, ServerErrorCounter;
+var init_serverErrorCounter = __esm({
+  "src/common/serverErrorCounter.ts"() {
+    "use strict";
+    import_crypto = require("crypto");
+    init_sentry();
+    MAX_MSG_LENGTH = 2048;
+    MAX_STACKTRACE_LENGTH = 65536;
+    _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");
       }
-      const headers = item[key].headers;
-      const hasJsonContent = this.hasJsonContentType(headers);
-      if (hasJsonContent === null || hasJsonContent) {
-        try {
-          const parsedBody = JSON.parse(bodyData.toString());
-          const maskedBody = this.maskBody(parsedBody);
-          item[key].body = import_buffer2.Buffer.from(JSON.stringify(maskedBody));
-        } catch {
-        }
-      }
-    }
-    item.request.headers = this.config.logRequestHeaders ? this.maskHeaders(item.request.headers) : [];
-    item.response.headers = this.config.logResponseHeaders ? this.maskHeaders(item.response.headers) : [];
-    const url = new URL(item.request.url);
-    url.search = this.config.logQueryParams ? this.maskQueryParams(url.search) : "";
-    item.request.url = url.toString();
-    return item;
-  }
-  logRequest(request, response, error) {
-    var _a3, _b, _c;
-    if (!this.enabled || this.suspendUntil !== null) return;
-    const url = new URL(request.url);
-    const path = request.path ?? url.pathname;
-    const userAgent = (_a3 = request.headers.find(([k]) => k.toLowerCase() === "user-agent")) == null ? void 0 : _a3[1];
-    if (this.shouldExcludePath(path) || this.shouldExcludeUserAgent(userAgent) || (((_c = (_b = this.config).excludeCallback) == null ? void 0 : _c.call(_b, request, response)) ?? false)) {
-      return;
-    }
-    if (!this.config.logRequestBody || !this.hasSupportedContentType(request.headers)) {
-      request.body = void 0;
-    }
-    if (!this.config.logResponseBody || !this.hasSupportedContentType(response.headers)) {
-      response.body = void 0;
-    }
-    if (request.size !== void 0 && request.size < 0) {
-      request.size = void 0;
-    }
-    if (response.size !== void 0 && response.size < 0) {
-      response.size = void 0;
-    }
-    const item = {
-      uuid: (0, import_crypto3.randomUUID)(),
-      request,
-      response,
-      exception: error && this.config.logException ? {
-        type: error.name,
-        message: truncateExceptionMessage(error.message),
-        stacktrace: truncateExceptionStackTrace(error.stack || ""),
-        sentryEventId: getSentryEventId()
-      } : void 0
     };
-    this.pendingWrites.push(item);
-    if (this.pendingWrites.length > MAX_PENDING_WRITES) {
-      this.pendingWrites.shift();
-    }
+    __name(_ServerErrorCounter, "ServerErrorCounter");
+    ServerErrorCounter = _ServerErrorCounter;
+    __name(truncateExceptionMessage, "truncateExceptionMessage");
+    __name(truncateExceptionStackTrace, "truncateExceptionStackTrace");
   }
-  async writeToFile() {
-    if (!this.enabled || this.pendingWrites.length === 0) {
-      return;
-    }
-    return this.lock.acquire("file", async () => {
-      if (!this.currentFile) {
-        this.currentFile = new TempGzipFile();
-      }
-      while (this.pendingWrites.length > 0) {
-        let item = this.pendingWrites.shift();
-        if (item) {
-          item = this.applyMasking(item);
-          const finalItem = {
-            uuid: item.uuid,
-            request: skipEmptyValues(item.request),
-            response: skipEmptyValues(item.response),
-            exception: item.exception
-          };
-          [
-            finalItem.request.body,
-            finalItem.response.body
-          ].forEach((body) => {
-            if (body) {
-              body.toJSON = function() {
-                return this.toString("base64");
-              };
+});
+
+// src/common/tempGzipFile.ts
+var import_buffer, import_crypto2, import_fs, import_os, import_path, import_zlib, _TempGzipFile, TempGzipFile;
+var init_tempGzipFile = __esm({
+  "src/common/tempGzipFile.ts"() {
+    "use strict";
+    import_buffer = require("buffer");
+    import_crypto2 = require("crypto");
+    import_fs = require("fs");
+    import_os = require("os");
+    import_path = require("path");
+    import_zlib = require("zlib");
+    _TempGzipFile = class _TempGzipFile {
+      uuid;
+      filePath;
+      gzip;
+      writeStream;
+      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.readyPromise = new Promise((resolve, reject) => {
+          this.writeStream.once("ready", resolve);
+          this.writeStream.once("error", reject);
+        });
+        this.closedPromise = new Promise((resolve, reject) => {
+          this.writeStream.once("close", resolve);
+          this.writeStream.once("error", reject);
+        });
+        this.gzip = (0, import_zlib.createGzip)();
+        this.gzip.pipe(this.writeStream);
+      }
+      get size() {
+        return this.writeStream.bytesWritten;
+      }
+      async writeLine(data) {
+        await this.readyPromise;
+        return new Promise((resolve, reject) => {
+          this.gzip.write(import_buffer.Buffer.concat([
+            data,
+            import_buffer.Buffer.from("\n")
+          ]), (error) => {
+            if (error) {
+              reject(error);
+            } else {
+              resolve();
             }
           });
-          await this.currentFile.writeLine(import_buffer2.Buffer.from(JSON.stringify(finalItem)));
-        }
+        });
       }
-    });
-  }
-  getFile() {
-    return this.files.shift();
-  }
-  retryFileLater(file) {
-    this.files.unshift(file);
-  }
-  async rotateFile() {
-    return this.lock.acquire("file", async () => {
-      if (this.currentFile) {
-        await this.currentFile.close();
-        this.files.push(this.currentFile);
-        this.currentFile = null;
+      async getContent() {
+        return new Promise((resolve, reject) => {
+          (0, import_fs.readFile)(this.filePath, (error, data) => {
+            if (error) {
+              reject(error);
+            } else {
+              resolve(data);
+            }
+          });
+        });
       }
-    });
-  }
-  async maintain() {
-    await this.writeToFile();
-    if (this.currentFile && this.currentFile.size > MAX_FILE_SIZE) {
-      await this.rotateFile();
-    }
-    while (this.files.length > MAX_FILES) {
-      const file = this.files.shift();
-      file == null ? void 0 : file.delete();
-    }
-    if (this.suspendUntil !== null && this.suspendUntil < Date.now()) {
-      this.suspendUntil = null;
-    }
-  }
-  async clear() {
-    this.pendingWrites = [];
-    await this.rotateFile();
-    this.files.forEach((file) => {
-      file.delete();
-    });
-    this.files = [];
-  }
-  async close() {
-    this.enabled = false;
-    await this.clear();
-    if (this.maintainIntervalId) {
-      clearInterval(this.maintainIntervalId);
-    }
+      async close() {
+        await new Promise((resolve) => {
+          this.gzip.end(() => {
+            resolve();
+          });
+        });
+        await this.closedPromise;
+      }
+      async delete() {
+        await this.close();
+        (0, import_fs.unlinkSync)(this.filePath);
+      }
+    };
+    __name(_TempGzipFile, "TempGzipFile");
+    TempGzipFile = _TempGzipFile;
   }
-};
-__name(_RequestLogger, "RequestLogger");
-var RequestLogger = _RequestLogger;
+});
+
+// src/common/requestLogger.ts
 function convertHeaders(headers) {
   if (headers instanceof Headers) {
     return Array.from(headers.entries());
@@ -11740,7 +11429,6 @@ function convertHeaders(headers) {
     ];
   });
 }
-__name(convertHeaders, "convertHeaders");
 function convertBody(body, contentType) {
   if (!body || !contentType) {
     return;
@@ -11760,7 +11448,6 @@ function convertBody(body, contentType) {
     return;
   }
 }
-__name(convertBody, "convertBody");
 function isValidJsonString(body) {
   if (typeof body !== "string") {
     return false;
@@ -11772,13 +11459,11 @@ function isValidJsonString(body) {
     return false;
   }
 }
-__name(isValidJsonString, "isValidJsonString");
 function matchPatterns(value, patterns) {
   return patterns.some((pattern) => {
     return pattern.test(value);
   });
 }
-__name(matchPatterns, "matchPatterns");
 function skipEmptyValues(data) {
   return Object.fromEntries(Object.entries(data).filter(([_, v]) => {
     if (v == null || Number.isNaN(v)) return false;
@@ -11788,7 +11473,6 @@ function skipEmptyValues(data) {
     return true;
   }));
 }
-__name(skipEmptyValues, "skipEmptyValues");
 function checkWritableFs() {
   try {
     const testPath = (0, import_path2.join)((0, import_os2.tmpdir)(), `apitally-${(0, import_crypto3.randomUUID)()}`);
@@ -11799,333 +11483,703 @@ function checkWritableFs() {
     return false;
   }
 }
-__name(checkWritableFs, "checkWritableFs");
-
-// src/common/validationErrorCounter.ts
-var import_crypto4 = require("crypto");
-var _ValidationErrorCounter = class _ValidationErrorCounter {
-  errorCounts;
-  errorDetails;
-  constructor() {
-    this.errorCounts = /* @__PURE__ */ new Map();
-    this.errorDetails = /* @__PURE__ */ new Map();
-  }
-  addValidationError(validationError) {
-    const key = this.getKey(validationError);
-    if (!this.errorDetails.has(key)) {
-      this.errorDetails.set(key, validationError);
-    }
-    this.errorCounts.set(key, (this.errorCounts.get(key) || 0) + 1);
-  }
-  getAndResetValidationErrors() {
-    const data = [];
-    this.errorCounts.forEach((count, key) => {
-      const validationError = this.errorDetails.get(key);
-      if (validationError) {
-        data.push({
-          consumer: validationError.consumer || null,
-          method: validationError.method,
-          path: validationError.path,
-          loc: validationError.loc.split("."),
-          msg: validationError.msg,
-          type: validationError.type,
-          error_count: count
-        });
+var import_async_lock, import_buffer2, import_crypto3, import_fs2, import_os2, import_path2, MAX_BODY_SIZE, MAX_FILE_SIZE, MAX_FILES, MAX_PENDING_WRITES, BODY_TOO_LARGE, BODY_MASKED, MASKED, ALLOWED_CONTENT_TYPES, EXCLUDE_PATH_PATTERNS, EXCLUDE_USER_AGENT_PATTERNS, MASK_QUERY_PARAM_PATTERNS, MASK_HEADER_PATTERNS, MASK_BODY_FIELD_PATTERNS, DEFAULT_CONFIG, _RequestLogger, RequestLogger;
+var init_requestLogger = __esm({
+  "src/common/requestLogger.ts"() {
+    "use strict";
+    import_async_lock = __toESM(require("async-lock"), 1);
+    import_buffer2 = require("buffer");
+    import_crypto3 = require("crypto");
+    import_fs2 = require("fs");
+    import_os2 = require("os");
+    import_path2 = require("path");
+    init_sentry();
+    init_serverErrorCounter();
+    init_tempGzipFile();
+    MAX_BODY_SIZE = 5e4;
+    MAX_FILE_SIZE = 1e6;
+    MAX_FILES = 50;
+    MAX_PENDING_WRITES = 100;
+    BODY_TOO_LARGE = import_buffer2.Buffer.from("<body too large>");
+    BODY_MASKED = import_buffer2.Buffer.from("<masked>");
+    MASKED = "******";
+    ALLOWED_CONTENT_TYPES = [
+      "application/json",
+      "application/problem+json",
+      "application/vnd.api+json",
+      "text/plain"
+    ];
+    EXCLUDE_PATH_PATTERNS = [
+      /\/_?healthz?$/i,
+      /\/_?health[_-]?checks?$/i,
+      /\/_?heart[_-]?beats?$/i,
+      /\/ping$/i,
+      /\/ready$/i,
+      /\/live$/i
+    ];
+    EXCLUDE_USER_AGENT_PATTERNS = [
+      /health[-_ ]?check/i,
+      /microsoft-azure-application-lb/i,
+      /googlehc/i,
+      /kube-probe/i
+    ];
+    MASK_QUERY_PARAM_PATTERNS = [
+      /auth/i,
+      /api-?key/i,
+      /secret/i,
+      /token/i,
+      /password/i,
+      /pwd/i
+    ];
+    MASK_HEADER_PATTERNS = [
+      /auth/i,
+      /api-?key/i,
+      /secret/i,
+      /token/i,
+      /cookie/i
+    ];
+    MASK_BODY_FIELD_PATTERNS = [
+      /password/i,
+      /pwd/i,
+      /token/i,
+      /secret/i,
+      /auth/i,
+      /card[-_ ]?number/i,
+      /ccv/i,
+      /ssn/i
+    ];
+    DEFAULT_CONFIG = {
+      enabled: false,
+      logQueryParams: true,
+      logRequestHeaders: false,
+      logRequestBody: false,
+      logResponseHeaders: true,
+      logResponseBody: false,
+      logException: true,
+      maskQueryParams: [],
+      maskHeaders: [],
+      maskBodyFields: [],
+      excludePaths: []
+    };
+    _RequestLogger = class _RequestLogger {
+      config;
+      enabled;
+      suspendUntil = null;
+      pendingWrites = [];
+      currentFile = null;
+      files = [];
+      maintainIntervalId;
+      lock = new import_async_lock.default();
+      constructor(config) {
+        this.config = {
+          ...DEFAULT_CONFIG,
+          ...config
+        };
+        this.enabled = this.config.enabled && checkWritableFs();
+        if (this.enabled) {
+          this.maintainIntervalId = setInterval(() => {
+            this.maintain();
+          }, 1e3);
+        }
       }
-    });
-    this.errorCounts.clear();
-    this.errorDetails.clear();
-    return data;
-  }
-  getKey(validationError) {
-    const hashInput = [
-      validationError.consumer || "",
-      validationError.method.toUpperCase(),
-      validationError.path,
-      validationError.loc,
-      validationError.msg.trim(),
-      validationError.type
-    ].join("|");
-    return (0, import_crypto4.createHash)("md5").update(hashInput).digest("hex");
-  }
-};
-__name(_ValidationErrorCounter, "ValidationErrorCounter");
-var ValidationErrorCounter = _ValidationErrorCounter;
-
-// src/common/client.ts
-var SYNC_INTERVAL = 6e4;
-var INITIAL_SYNC_INTERVAL = 1e4;
-var INITIAL_SYNC_INTERVAL_DURATION = 36e5;
-var MAX_QUEUE_TIME = 36e5;
-var _a;
-var HTTPError = (_a = class extends Error {
-  response;
-  constructor(response) {
-    const reason = response.status ? `status code ${response.status}` : "an unknown error";
-    super(`Request failed with ${reason}`);
-    this.response = response;
-  }
-}, __name(_a, "HTTPError"), _a);
-var _ApitallyClient = class _ApitallyClient {
-  clientId;
-  env;
-  instanceUuid;
-  syncDataQueue;
-  syncIntervalId;
-  startupData;
-  startupDataSent = false;
-  enabled = true;
-  requestCounter;
-  requestLogger;
-  validationErrorCounter;
-  serverErrorCounter;
-  consumerRegistry;
-  logger;
-  constructor({ clientId, env = "dev", requestLogging, requestLoggingConfig, logger }) {
-    if (_ApitallyClient.instance) {
-      throw new Error("Apitally client is already initialized");
-    }
-    if (!isValidClientId(clientId)) {
-      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)`);
-    }
-    if (requestLoggingConfig && !requestLogging) {
-      console.warn("requestLoggingConfig is deprecated, use requestLogging instead.");
-    }
-    _ApitallyClient.instance = this;
-    this.clientId = clientId;
-    this.env = env;
-    this.instanceUuid = (0, import_crypto5.randomUUID)();
-    this.syncDataQueue = [];
-    this.requestCounter = new RequestCounter();
-    this.requestLogger = new RequestLogger(requestLogging ?? requestLoggingConfig);
-    this.validationErrorCounter = new ValidationErrorCounter();
-    this.serverErrorCounter = new ServerErrorCounter();
-    this.consumerRegistry = new ConsumerRegistry();
-    this.logger = logger ?? getLogger();
-    this.startSync();
-    this.handleShutdown = this.handleShutdown.bind(this);
-  }
-  static getInstance() {
-    if (!_ApitallyClient.instance) {
-      throw new Error("Apitally client is not initialized");
-    }
-    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();
-    await this.requestLogger.close();
-    _ApitallyClient.instance = void 0;
-  }
-  getHubUrlPrefix() {
-    const baseURL = process.env.APITALLY_HUB_BASE_URL || "https://hub.apitally.io";
-    const version = "v2";
-    return `${baseURL}/${version}/${this.clientId}/${this.env}/`;
-  }
-  async sendData(url, payload) {
-    const fetchWithRetry = (0, import_fetch_retry.default)(fetch, {
-      retries: 3,
-      retryDelay: 1e3,
-      retryOn: [
-        408,
-        429,
-        500,
-        502,
-        503,
-        504
-      ]
-    });
-    const response = await fetchWithRetry(this.getHubUrlPrefix() + url, {
-      method: "POST",
-      body: JSON.stringify(payload),
-      headers: {
-        "Content-Type": "application/json"
+      get maxBodySize() {
+        return MAX_BODY_SIZE;
       }
-    });
-    if (!response.ok) {
-      throw new HTTPError(response);
-    }
-  }
-  startSync() {
-    this.sync();
-    this.syncIntervalId = setInterval(() => {
-      this.sync();
-    }, INITIAL_SYNC_INTERVAL);
-    setTimeout(() => {
-      clearInterval(this.syncIntervalId);
-      this.syncIntervalId = setInterval(() => {
-        this.sync();
-      }, SYNC_INTERVAL);
-    }, INITIAL_SYNC_INTERVAL_DURATION);
-  }
-  async sync() {
-    try {
-      const promises = [
-        this.sendSyncData(),
-        this.sendLogData()
-      ];
-      if (!this.startupDataSent) {
-        promises.push(this.sendStartupData());
+      shouldExcludePath(urlPath) {
+        const patterns = [
+          ...this.config.excludePaths,
+          ...EXCLUDE_PATH_PATTERNS
+        ];
+        return matchPatterns(urlPath, patterns);
       }
-      await Promise.all(promises);
-    } catch (error) {
-      this.logger.error("Error while syncing with Apitally Hub", {
-        error
-      });
-    }
-  }
-  stopSync() {
-    if (this.syncIntervalId) {
-      clearInterval(this.syncIntervalId);
-      this.syncIntervalId = void 0;
-    }
-  }
-  setStartupData(data) {
-    this.startupData = data;
-    this.startupDataSent = false;
-    this.sendStartupData();
-  }
-  async sendStartupData() {
-    if (this.startupData) {
-      this.logger.debug("Sending startup data to Apitally Hub");
-      const payload = {
-        instance_uuid: this.instanceUuid,
-        message_uuid: (0, import_crypto5.randomUUID)(),
-        ...this.startupData
-      };
-      try {
-        await this.sendData("startup", payload);
-        this.startupDataSent = true;
-      } catch (error) {
-        const handled = this.handleHubError(error);
-        if (!handled) {
-          this.logger.error(error.message);
-          this.logger.debug("Error while sending startup data to Apitally Hub (will retry)", {
-            error
-          });
-        }
+      shouldExcludeUserAgent(userAgent) {
+        return userAgent ? matchPatterns(userAgent, EXCLUDE_USER_AGENT_PATTERNS) : false;
       }
-    }
-  }
-  async sendSyncData() {
-    this.logger.debug("Synchronizing data with Apitally Hub");
-    const newPayload = {
-      timestamp: Date.now() / 1e3,
-      instance_uuid: this.instanceUuid,
-      message_uuid: (0, import_crypto5.randomUUID)(),
-      requests: this.requestCounter.getAndResetRequests(),
-      validation_errors: this.validationErrorCounter.getAndResetValidationErrors(),
-      server_errors: this.serverErrorCounter.getAndResetServerErrors(),
-      consumers: this.consumerRegistry.getAndResetUpdatedConsumers()
-    };
-    this.syncDataQueue.push(newPayload);
-    let i = 0;
-    while (this.syncDataQueue.length > 0) {
-      const payload = this.syncDataQueue.shift();
-      if (payload) {
-        try {
-          if (Date.now() - payload.timestamp * 1e3 <= MAX_QUEUE_TIME) {
-            if (i > 0) {
-              await this.randomDelay();
-            }
-            await this.sendData("sync", payload);
-            i += 1;
-          }
-        } catch (error) {
-          const handled = this.handleHubError(error);
-          if (!handled) {
-            this.logger.debug("Error while synchronizing data with Apitally Hub (will retry)", {
-              error
-            });
-            this.syncDataQueue.push(payload);
-            break;
+      shouldMaskQueryParam(name) {
+        const patterns = [
+          ...this.config.maskQueryParams,
+          ...MASK_QUERY_PARAM_PATTERNS
+        ];
+        return matchPatterns(name, patterns);
+      }
+      shouldMaskHeader(name) {
+        const patterns = [
+          ...this.config.maskHeaders,
+          ...MASK_HEADER_PATTERNS
+        ];
+        return matchPatterns(name, patterns);
+      }
+      shouldMaskBodyField(name) {
+        const patterns = [
+          ...this.config.maskBodyFields,
+          ...MASK_BODY_FIELD_PATTERNS
+        ];
+        return matchPatterns(name, patterns);
+      }
+      hasSupportedContentType(headers) {
+        var _a3;
+        const contentType = (_a3 = headers.find(([k]) => k.toLowerCase() === "content-type")) == null ? void 0 : _a3[1];
+        return this.isSupportedContentType(contentType);
+      }
+      hasJsonContentType(headers) {
+        var _a3;
+        const contentType = (_a3 = headers.find(([k]) => k.toLowerCase() === "content-type")) == null ? void 0 : _a3[1];
+        return contentType ? /\bjson\b/i.test(contentType) : null;
+      }
+      isSupportedContentType(contentType) {
+        return typeof contentType === "string" && ALLOWED_CONTENT_TYPES.some((t) => contentType.startsWith(t));
+      }
+      maskQueryParams(search) {
+        const params = new URLSearchParams(search);
+        for (const [key] of params) {
+          if (this.shouldMaskQueryParam(key)) {
+            params.set(key, MASKED);
           }
         }
+        return params.toString();
       }
-    }
-  }
-  async sendLogData() {
-    this.logger.debug("Sending request log data to Apitally Hub");
-    await this.requestLogger.rotateFile();
-    const fetchWithRetry = (0, import_fetch_retry.default)(fetch, {
-      retries: 3,
-      retryDelay: 1e3,
-      retryOn: [
-        408,
-        429,
-        500,
-        502,
-        503,
-        504
-      ]
-    });
-    let i = 0;
-    let logFile;
-    while (logFile = this.requestLogger.getFile()) {
-      if (i > 0) {
-        await this.randomDelay();
+      maskHeaders(headers) {
+        return headers.map(([k, v]) => [
+          k,
+          this.shouldMaskHeader(k) ? MASKED : v
+        ]);
       }
-      try {
-        const response = await fetchWithRetry(`${this.getHubUrlPrefix()}log?uuid=${logFile.uuid}`, {
-          method: "POST",
-          body: await logFile.getContent()
-        });
-        if (response.status === 402 && response.headers.has("Retry-After")) {
-          const retryAfter = parseInt(response.headers.get("Retry-After") ?? "0");
-          if (retryAfter > 0) {
-            this.requestLogger.suspendUntil = Date.now() + retryAfter * 1e3;
-            this.requestLogger.clear();
-            return;
+      maskBody(data) {
+        if (typeof data === "object" && data !== null && !Array.isArray(data)) {
+          const result = {};
+          for (const [key, value] of Object.entries(data)) {
+            if (typeof value === "string" && this.shouldMaskBodyField(key)) {
+              result[key] = MASKED;
+            } else {
+              result[key] = this.maskBody(value);
+            }
           }
+          return result;
         }
-        if (!response.ok) {
-          throw new HTTPError(response);
+        if (Array.isArray(data)) {
+          return data.map((item) => this.maskBody(item));
         }
-        logFile.delete();
-      } catch (error) {
-        this.requestLogger.retryFileLater(logFile);
-        break;
+        return data;
       }
-      i++;
-      if (i >= 10) break;
-    }
+      applyMasking(item) {
+        if (this.config.maskRequestBodyCallback && item.request.body && item.request.body !== BODY_TOO_LARGE) {
+          try {
+            const maskedBody = this.config.maskRequestBodyCallback(item.request);
+            item.request.body = maskedBody ?? BODY_MASKED;
+          } catch {
+            item.request.body = void 0;
+          }
+        }
+        if (this.config.maskResponseBodyCallback && item.response.body && item.response.body !== BODY_TOO_LARGE) {
+          try {
+            const maskedBody = this.config.maskResponseBodyCallback(item.request, item.response);
+            item.response.body = maskedBody ?? BODY_MASKED;
+          } catch {
+            item.response.body = void 0;
+          }
+        }
+        if (item.request.body && item.request.body.length > MAX_BODY_SIZE) {
+          item.request.body = BODY_TOO_LARGE;
+        }
+        if (item.response.body && item.response.body.length > MAX_BODY_SIZE) {
+          item.response.body = BODY_TOO_LARGE;
+        }
+        for (const key of [
+          "request",
+          "response"
+        ]) {
+          const bodyData = item[key].body;
+          if (!bodyData || bodyData === BODY_TOO_LARGE || bodyData === BODY_MASKED) {
+            continue;
+          }
+          const headers = item[key].headers;
+          const hasJsonContent = this.hasJsonContentType(headers);
+          if (hasJsonContent === null || hasJsonContent) {
+            try {
+              const parsedBody = JSON.parse(bodyData.toString());
+              const maskedBody = this.maskBody(parsedBody);
+              item[key].body = import_buffer2.Buffer.from(JSON.stringify(maskedBody));
+            } catch {
+            }
+          }
+        }
+        item.request.headers = this.config.logRequestHeaders ? this.maskHeaders(item.request.headers) : [];
+        item.response.headers = this.config.logResponseHeaders ? this.maskHeaders(item.response.headers) : [];
+        const url = new URL(item.request.url);
+        url.search = this.config.logQueryParams ? this.maskQueryParams(url.search) : "";
+        item.request.url = url.toString();
+        return item;
+      }
+      logRequest(request, response, error) {
+        var _a3, _b, _c;
+        if (!this.enabled || this.suspendUntil !== null) return;
+        const url = new URL(request.url);
+        const path = request.path ?? url.pathname;
+        const userAgent = (_a3 = request.headers.find(([k]) => k.toLowerCase() === "user-agent")) == null ? void 0 : _a3[1];
+        if (this.shouldExcludePath(path) || this.shouldExcludeUserAgent(userAgent) || (((_c = (_b = this.config).excludeCallback) == null ? void 0 : _c.call(_b, request, response)) ?? false)) {
+          return;
+        }
+        if (!this.config.logRequestBody || !this.hasSupportedContentType(request.headers)) {
+          request.body = void 0;
+        }
+        if (!this.config.logResponseBody || !this.hasSupportedContentType(response.headers)) {
+          response.body = void 0;
+        }
+        if (request.size !== void 0 && request.size < 0) {
+          request.size = void 0;
+        }
+        if (response.size !== void 0 && response.size < 0) {
+          response.size = void 0;
+        }
+        const item = {
+          uuid: (0, import_crypto3.randomUUID)(),
+          request,
+          response,
+          exception: error && this.config.logException ? {
+            type: error.name,
+            message: truncateExceptionMessage(error.message),
+            stacktrace: truncateExceptionStackTrace(error.stack || ""),
+            sentryEventId: getSentryEventId()
+          } : void 0
+        };
+        this.pendingWrites.push(item);
+        if (this.pendingWrites.length > MAX_PENDING_WRITES) {
+          this.pendingWrites.shift();
+        }
+      }
+      async writeToFile() {
+        if (!this.enabled || this.pendingWrites.length === 0) {
+          return;
+        }
+        return this.lock.acquire("file", async () => {
+          if (!this.currentFile) {
+            this.currentFile = new TempGzipFile();
+          }
+          while (this.pendingWrites.length > 0) {
+            let item = this.pendingWrites.shift();
+            if (item) {
+              item = this.applyMasking(item);
+              const finalItem = {
+                uuid: item.uuid,
+                request: skipEmptyValues(item.request),
+                response: skipEmptyValues(item.response),
+                exception: item.exception
+              };
+              [
+                finalItem.request.body,
+                finalItem.response.body
+              ].forEach((body) => {
+                if (body) {
+                  body.toJSON = function() {
+                    return this.toString("base64");
+                  };
+                }
+              });
+              await this.currentFile.writeLine(import_buffer2.Buffer.from(JSON.stringify(finalItem)));
+            }
+          }
+        });
+      }
+      getFile() {
+        return this.files.shift();
+      }
+      retryFileLater(file) {
+        this.files.unshift(file);
+      }
+      async rotateFile() {
+        return this.lock.acquire("file", async () => {
+          if (this.currentFile) {
+            await this.currentFile.close();
+            this.files.push(this.currentFile);
+            this.currentFile = null;
+          }
+        });
+      }
+      async maintain() {
+        await this.writeToFile();
+        if (this.currentFile && this.currentFile.size > MAX_FILE_SIZE) {
+          await this.rotateFile();
+        }
+        while (this.files.length > MAX_FILES) {
+          const file = this.files.shift();
+          file == null ? void 0 : file.delete();
+        }
+        if (this.suspendUntil !== null && this.suspendUntil < Date.now()) {
+          this.suspendUntil = null;
+        }
+      }
+      async clear() {
+        this.pendingWrites = [];
+        await this.rotateFile();
+        this.files.forEach((file) => {
+          file.delete();
+        });
+        this.files = [];
+      }
+      async close() {
+        this.enabled = false;
+        await this.clear();
+        if (this.maintainIntervalId) {
+          clearInterval(this.maintainIntervalId);
+        }
+      }
+    };
+    __name(_RequestLogger, "RequestLogger");
+    RequestLogger = _RequestLogger;
+    __name(convertHeaders, "convertHeaders");
+    __name(convertBody, "convertBody");
+    __name(isValidJsonString, "isValidJsonString");
+    __name(matchPatterns, "matchPatterns");
+    __name(skipEmptyValues, "skipEmptyValues");
+    __name(checkWritableFs, "checkWritableFs");
+  }
+});
+
+// src/common/validationErrorCounter.ts
+var import_crypto4, _ValidationErrorCounter, ValidationErrorCounter;
+var init_validationErrorCounter = __esm({
+  "src/common/validationErrorCounter.ts"() {
+    "use strict";
+    import_crypto4 = require("crypto");
+    _ValidationErrorCounter = class _ValidationErrorCounter {
+      errorCounts;
+      errorDetails;
+      constructor() {
+        this.errorCounts = /* @__PURE__ */ new Map();
+        this.errorDetails = /* @__PURE__ */ new Map();
+      }
+      addValidationError(validationError) {
+        const key = this.getKey(validationError);
+        if (!this.errorDetails.has(key)) {
+          this.errorDetails.set(key, validationError);
+        }
+        this.errorCounts.set(key, (this.errorCounts.get(key) || 0) + 1);
+      }
+      getAndResetValidationErrors() {
+        const data = [];
+        this.errorCounts.forEach((count, key) => {
+          const validationError = this.errorDetails.get(key);
+          if (validationError) {
+            data.push({
+              consumer: validationError.consumer || null,
+              method: validationError.method,
+              path: validationError.path,
+              loc: validationError.loc.split("."),
+              msg: validationError.msg,
+              type: validationError.type,
+              error_count: count
+            });
+          }
+        });
+        this.errorCounts.clear();
+        this.errorDetails.clear();
+        return data;
+      }
+      getKey(validationError) {
+        const hashInput = [
+          validationError.consumer || "",
+          validationError.method.toUpperCase(),
+          validationError.path,
+          validationError.loc,
+          validationError.msg.trim(),
+          validationError.type
+        ].join("|");
+        return (0, import_crypto4.createHash)("md5").update(hashInput).digest("hex");
+      }
+    };
+    __name(_ValidationErrorCounter, "ValidationErrorCounter");
+    ValidationErrorCounter = _ValidationErrorCounter;
   }
-  handleHubError(error) {
-    if (error instanceof HTTPError) {
-      if (error.response.status === 404) {
-        this.logger.error(`Invalid Apitally client ID: '${this.clientId}'`);
+});
+
+// src/common/client.ts
+var import_crypto5, import_fetch_retry, SYNC_INTERVAL, INITIAL_SYNC_INTERVAL, INITIAL_SYNC_INTERVAL_DURATION, MAX_QUEUE_TIME, _a, HTTPError, _ApitallyClient, ApitallyClient;
+var init_client = __esm({
+  "src/common/client.ts"() {
+    "use strict";
+    import_crypto5 = require("crypto");
+    import_fetch_retry = __toESM(require("fetch-retry"), 1);
+    init_consumerRegistry();
+    init_logging();
+    init_paramValidation();
+    init_requestCounter();
+    init_requestLogger();
+    init_serverErrorCounter();
+    init_validationErrorCounter();
+    SYNC_INTERVAL = 6e4;
+    INITIAL_SYNC_INTERVAL = 1e4;
+    INITIAL_SYNC_INTERVAL_DURATION = 36e5;
+    MAX_QUEUE_TIME = 36e5;
+    HTTPError = (_a = class extends Error {
+      response;
+      constructor(response) {
+        const reason = response.status ? `status code ${response.status}` : "an unknown error";
+        super(`Request failed with ${reason}`);
+        this.response = response;
+      }
+    }, __name(_a, "HTTPError"), _a);
+    _ApitallyClient = class _ApitallyClient {
+      clientId;
+      env;
+      instanceUuid;
+      syncDataQueue;
+      syncIntervalId;
+      startupData;
+      startupDataSent = false;
+      enabled = true;
+      requestCounter;
+      requestLogger;
+      validationErrorCounter;
+      serverErrorCounter;
+      consumerRegistry;
+      logger;
+      constructor({ clientId, env = "dev", requestLogging, requestLoggingConfig, logger }) {
+        if (_ApitallyClient.instance) {
+          throw new Error("Apitally client is already initialized");
+        }
+        if (!isValidClientId(clientId)) {
+          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)`);
+        }
+        if (requestLoggingConfig && !requestLogging) {
+          console.warn("requestLoggingConfig is deprecated, use requestLogging instead.");
+        }
+        _ApitallyClient.instance = this;
+        this.clientId = clientId;
+        this.env = env;
+        this.instanceUuid = (0, import_crypto5.randomUUID)();
+        this.syncDataQueue = [];
+        this.requestCounter = new RequestCounter();
+        this.requestLogger = new RequestLogger(requestLogging ?? requestLoggingConfig);
+        this.validationErrorCounter = new ValidationErrorCounter();
+        this.serverErrorCounter = new ServerErrorCounter();
+        this.consumerRegistry = new ConsumerRegistry();
+        this.logger = logger ?? getLogger();
+        this.startSync();
+        this.handleShutdown = this.handleShutdown.bind(this);
+      }
+      static getInstance() {
+        if (!_ApitallyClient.instance) {
+          throw new Error("Apitally client is not initialized");
+        }
+        return _ApitallyClient.instance;
+      }
+      isEnabled() {
+        return this.enabled;
+      }
+      static async shutdown() {
+        if (_ApitallyClient.instance) {
+          await _ApitallyClient.instance.handleShutdown();
+        }
+      }
+      async handleShutdown() {
         this.enabled = false;
         this.stopSync();
-        return true;
+        await this.sendSyncData();
+        await this.sendLogData();
+        await this.requestLogger.close();
+        _ApitallyClient.instance = void 0;
+      }
+      getHubUrlPrefix() {
+        const baseURL = process.env.APITALLY_HUB_BASE_URL || "https://hub.apitally.io";
+        const version = "v2";
+        return `${baseURL}/${version}/${this.clientId}/${this.env}/`;
+      }
+      async sendData(url, payload) {
+        const fetchWithRetry = (0, import_fetch_retry.default)(fetch, {
+          retries: 3,
+          retryDelay: 1e3,
+          retryOn: [
+            408,
+            429,
+            500,
+            502,
+            503,
+            504
+          ]
+        });
+        const response = await fetchWithRetry(this.getHubUrlPrefix() + url, {
+          method: "POST",
+          body: JSON.stringify(payload),
+          headers: {
+            "Content-Type": "application/json"
+          }
+        });
+        if (!response.ok) {
+          throw new HTTPError(response);
+        }
       }
-      if (error.response.status === 422) {
-        this.logger.error("Received validation error from Apitally Hub");
-        return true;
+      startSync() {
+        this.sync();
+        this.syncIntervalId = setInterval(() => {
+          this.sync();
+        }, INITIAL_SYNC_INTERVAL);
+        setTimeout(() => {
+          clearInterval(this.syncIntervalId);
+          this.syncIntervalId = setInterval(() => {
+            this.sync();
+          }, SYNC_INTERVAL);
+        }, INITIAL_SYNC_INTERVAL_DURATION);
+      }
+      async sync() {
+        try {
+          const promises = [
+            this.sendSyncData(),
+            this.sendLogData()
+          ];
+          if (!this.startupDataSent) {
+            promises.push(this.sendStartupData());
+          }
+          await Promise.all(promises);
+        } catch (error) {
+          this.logger.error("Error while syncing with Apitally Hub", {
+            error
+          });
+        }
       }
-    }
-    return false;
-  }
-  async randomDelay() {
-    const delay = 100 + Math.random() * 400;
-    await new Promise((resolve) => setTimeout(resolve, delay));
+      stopSync() {
+        if (this.syncIntervalId) {
+          clearInterval(this.syncIntervalId);
+          this.syncIntervalId = void 0;
+        }
+      }
+      setStartupData(data) {
+        this.startupData = data;
+        this.startupDataSent = false;
+        this.sendStartupData();
+      }
+      async sendStartupData() {
+        if (this.startupData) {
+          this.logger.debug("Sending startup data to Apitally Hub");
+          const payload = {
+            instance_uuid: this.instanceUuid,
+            message_uuid: (0, import_crypto5.randomUUID)(),
+            ...this.startupData
+          };
+          try {
+            await this.sendData("startup", payload);
+            this.startupDataSent = true;
+          } catch (error) {
+            const handled = this.handleHubError(error);
+            if (!handled) {
+              this.logger.error(error.message);
+              this.logger.debug("Error while sending startup data to Apitally Hub (will retry)", {
+                error
+              });
+            }
+          }
+        }
+      }
+      async sendSyncData() {
+        this.logger.debug("Synchronizing data with Apitally Hub");
+        const newPayload = {
+          timestamp: Date.now() / 1e3,
+          instance_uuid: this.instanceUuid,
+          message_uuid: (0, import_crypto5.randomUUID)(),
+          requests: this.requestCounter.getAndResetRequests(),
+          validation_errors: this.validationErrorCounter.getAndResetValidationErrors(),
+          server_errors: this.serverErrorCounter.getAndResetServerErrors(),
+          consumers: this.consumerRegistry.getAndResetUpdatedConsumers()
+        };
+        this.syncDataQueue.push(newPayload);
+        let i = 0;
+        while (this.syncDataQueue.length > 0) {
+          const payload = this.syncDataQueue.shift();
+          if (payload) {
+            try {
+              if (Date.now() - payload.timestamp * 1e3 <= MAX_QUEUE_TIME) {
+                if (i > 0) {
+                  await this.randomDelay();
+                }
+                await this.sendData("sync", payload);
+                i += 1;
+              }
+            } catch (error) {
+              const handled = this.handleHubError(error);
+              if (!handled) {
+                this.logger.debug("Error while synchronizing data with Apitally Hub (will retry)", {
+                  error
+                });
+                this.syncDataQueue.push(payload);
+                break;
+              }
+            }
+          }
+        }
+      }
+      async sendLogData() {
+        this.logger.debug("Sending request log data to Apitally Hub");
+        await this.requestLogger.rotateFile();
+        const fetchWithRetry = (0, import_fetch_retry.default)(fetch, {
+          retries: 3,
+          retryDelay: 1e3,
+          retryOn: [
+            408,
+            429,
+            500,
+            502,
+            503,
+            504
+          ]
+        });
+        let i = 0;
+        let logFile;
+        while (logFile = this.requestLogger.getFile()) {
+          if (i > 0) {
+            await this.randomDelay();
+          }
+          try {
+            const response = await fetchWithRetry(`${this.getHubUrlPrefix()}log?uuid=${logFile.uuid}`, {
+              method: "POST",
+              body: await logFile.getContent()
+            });
+            if (response.status === 402 && response.headers.has("Retry-After")) {
+              const retryAfter = parseInt(response.headers.get("Retry-After") ?? "0");
+              if (retryAfter > 0) {
+                this.requestLogger.suspendUntil = Date.now() + retryAfter * 1e3;
+                this.requestLogger.clear();
+                return;
+              }
+            }
+            if (!response.ok) {
+              throw new HTTPError(response);
+            }
+            logFile.delete();
+          } catch (error) {
+            this.requestLogger.retryFileLater(logFile);
+            break;
+          }
+          i++;
+          if (i >= 10) break;
+        }
+      }
+      handleHubError(error) {
+        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;
+          }
+          if (error.response.status === 422) {
+            this.logger.error("Received validation error from Apitally Hub");
+            return true;
+          }
+        }
+        return false;
+      }
+      async randomDelay() {
+        const delay = 100 + Math.random() * 400;
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    };
+    __name(_ApitallyClient, "ApitallyClient");
+    __publicField(_ApitallyClient, "instance");
+    ApitallyClient = _ApitallyClient;
   }
-};
-__name(_ApitallyClient, "ApitallyClient");
-__publicField(_ApitallyClient, "instance");
-var ApitallyClient = _ApitallyClient;
+});
 
 // src/common/headers.ts
 function parseContentLength(contentLength) {
@@ -12144,11 +12198,14 @@ function parseContentLength(contentLength) {
   }
   return void 0;
 }
-__name(parseContentLength, "parseContentLength");
+var init_headers = __esm({
+  "src/common/headers.ts"() {
+    "use strict";
+    __name(parseContentLength, "parseContentLength");
+  }
+});
 
 // src/common/packageVersions.ts
-var import_module = require("module");
-var import_meta = {};
 function getPackageVersion(name) {
   const packageJsonPath = `${name}/package.json`;
   try {
@@ -12162,176 +12219,190 @@ function getPackageVersion(name) {
     }
   }
 }
-__name(getPackageVersion, "getPackageVersion");
+var import_module, import_meta;
+var init_packageVersions = __esm({
+  "src/common/packageVersions.ts"() {
+    "use strict";
+    import_module = require("module");
+    import_meta = {};
+    __name(getPackageVersion, "getPackageVersion");
+  }
+});
 
 // src/express/utils.js
-var regExpToParseExpressPathRegExp = /^\/\^\\?\/?(?:(:?[\w\\.-]*(?:\\\/:?[\w\\.-]*)*)|(\(\?:\\?\/?\([^)]+\)\)))\\\/.*/;
-var regExpToReplaceExpressPathRegExpParams = /\(\?:\\?\/?\([^)]+\)\)/;
-var regexpExpressParamRegexp = /\(\?:\\?\\?\/?\([^)]+\)\)/g;
-var regexpExpressPathParamRegexp = /(:[^)]+)\([^)]+\)/g;
-var EXPRESS_ROOT_PATH_REGEXP_VALUE = "/^\\/?(?=\\/|$)/i";
-var STACK_ITEM_VALID_NAMES = [
-  "router",
-  "bound dispatch",
-  "mounted_app"
-];
-var getRouterInfo = /* @__PURE__ */ __name(function(app) {
-  var _a3, _b;
-  if (app.stack) {
-    return {
-      stack: app.stack,
-      version: "v4"
-    };
-  } else if ((_a3 = app._router) == null ? void 0 : _a3.stack) {
-    return {
-      stack: app._router.stack,
-      version: "v4"
-    };
-  } else if ((_b = app.router) == null ? void 0 : _b.stack) {
-    return {
-      stack: app.router.stack,
-      version: "v5"
-    };
-  }
-  return {
-    stack: null,
-    version: "v4"
-  };
-}, "getRouterInfo");
-var getRouteMethods = /* @__PURE__ */ __name(function(route) {
-  let methods = Object.keys(route.methods);
-  methods = methods.filter((method) => method !== "_all");
-  methods = methods.map((method) => method.toUpperCase());
-  return methods;
-}, "getRouteMethods");
-var getRouteMiddlewares = /* @__PURE__ */ __name(function(route) {
-  return route.stack.map((item) => {
-    return item.handle.name || "anonymous";
-  });
-}, "getRouteMiddlewares");
-var hasParams = /* @__PURE__ */ __name(function(expressPathRegExp) {
-  return regexpExpressParamRegexp.test(expressPathRegExp);
-}, "hasParams");
-var parseExpressRoute = /* @__PURE__ */ __name(function(route, basePath) {
-  const paths = [];
-  if (Array.isArray(route.path)) {
-    paths.push(...route.path);
-  } else {
-    paths.push(route.path);
-  }
-  const endpoints = paths.map((path) => {
-    const completePath = basePath && path === "/" ? basePath : `${basePath}${path}`;
-    const endpoint = {
-      path: completePath.replace(regexpExpressPathParamRegexp, "$1"),
-      methods: getRouteMethods(route),
-      middlewares: getRouteMiddlewares(route)
-    };
-    return endpoint;
-  });
-  return endpoints;
-}, "parseExpressRoute");
-var parseExpressPathRegExp = /* @__PURE__ */ __name(function(expressPathRegExp, keys) {
-  let parsedRegExp = expressPathRegExp.toString();
-  let expressPathRegExpExec = regExpToParseExpressPathRegExp.exec(parsedRegExp);
-  let paramIndex = 0;
-  while (hasParams(parsedRegExp)) {
-    const paramName = keys[paramIndex].name;
-    const paramId = `:${paramName}`;
-    parsedRegExp = parsedRegExp.replace(regExpToReplaceExpressPathRegExpParams, (str) => {
-      if (str.startsWith("(?:\\/")) {
-        return `\\/${paramId}`;
-      }
-      return paramId;
-    });
-    paramIndex++;
-  }
-  if (parsedRegExp !== expressPathRegExp.toString()) {
-    expressPathRegExpExec = regExpToParseExpressPathRegExp.exec(parsedRegExp);
-  }
-  return expressPathRegExpExec[1].replace(/\\\//g, "/");
-}, "parseExpressPathRegExp");
-var parseExpressPath = /* @__PURE__ */ __name(function(expressPath, params) {
-  let result = expressPath;
-  for (const [paramName, paramValue] of Object.entries(params)) {
-    result = result.replace(paramValue, `:${paramName}`);
-  }
-  return result;
-}, "parseExpressPath");
-var parseEndpoints = /* @__PURE__ */ __name(function(app, basePath, endpoints) {
-  const routerInfo = getRouterInfo(app);
-  const stack = routerInfo.stack;
-  const version = routerInfo.version;
-  endpoints = endpoints || [];
-  basePath = basePath || "";
-  if (!stack) {
-    if (endpoints.length) {
-      endpoints = addEndpoints(endpoints, [
-        {
-          path: basePath,
-          methods: [],
-          middlewares: []
+var regExpToParseExpressPathRegExp, regExpToReplaceExpressPathRegExpParams, regexpExpressParamRegexp, regexpExpressPathParamRegexp, EXPRESS_ROOT_PATH_REGEXP_VALUE, STACK_ITEM_VALID_NAMES, getRouterInfo, getRouteMethods, getRouteMiddlewares, hasParams, parseExpressRoute, parseExpressPathRegExp, parseExpressPath, parseEndpoints, addEndpoints, parseStack, getEndpoints;
+var init_utils = __esm({
+  "src/express/utils.js"() {
+    "use strict";
+    regExpToParseExpressPathRegExp = /^\/\^\\?\/?(?:(:?[\w\\.-]*(?:\\\/:?[\w\\.-]*)*)|(\(\?:\\?\/?\([^)]+\)\)))\\\/.*/;
+    regExpToReplaceExpressPathRegExpParams = /\(\?:\\?\/?\([^)]+\)\)/;
+    regexpExpressParamRegexp = /\(\?:\\?\\?\/?\([^)]+\)\)/g;
+    regexpExpressPathParamRegexp = /(:[^)]+)\([^)]+\)/g;
+    EXPRESS_ROOT_PATH_REGEXP_VALUE = "/^\\/?(?=\\/|$)/i";
+    STACK_ITEM_VALID_NAMES = [
+      "router",
+      "bound dispatch",
+      "mounted_app"
+    ];
+    getRouterInfo = /* @__PURE__ */ __name(function(app) {
+      var _a3, _b;
+      if (app.stack) {
+        return {
+          stack: app.stack,
+          version: "v4"
+        };
+      } else if ((_a3 = app._router) == null ? void 0 : _a3.stack) {
+        return {
+          stack: app._router.stack,
+          version: "v4"
+        };
+      } else if ((_b = app.router) == null ? void 0 : _b.stack) {
+        return {
+          stack: app.router.stack,
+          version: "v5"
+        };
+      }
+      return {
+        stack: null,
+        version: "v4"
+      };
+    }, "getRouterInfo");
+    getRouteMethods = /* @__PURE__ */ __name(function(route) {
+      let methods = Object.keys(route.methods);
+      methods = methods.filter((method) => method !== "_all");
+      methods = methods.map((method) => method.toUpperCase());
+      return methods;
+    }, "getRouteMethods");
+    getRouteMiddlewares = /* @__PURE__ */ __name(function(route) {
+      return route.stack.map((item) => {
+        return item.handle.name || "anonymous";
+      });
+    }, "getRouteMiddlewares");
+    hasParams = /* @__PURE__ */ __name(function(expressPathRegExp) {
+      return regexpExpressParamRegexp.test(expressPathRegExp);
+    }, "hasParams");
+    parseExpressRoute = /* @__PURE__ */ __name(function(route, basePath) {
+      const paths = [];
+      if (Array.isArray(route.path)) {
+        paths.push(...route.path);
+      } else {
+        paths.push(route.path);
+      }
+      const endpoints = paths.map((path) => {
+        const completePath = basePath && path === "/" ? basePath : `${basePath}${path}`;
+        const endpoint = {
+          path: completePath.replace(regexpExpressPathParamRegexp, "$1"),
+          methods: getRouteMethods(route),
+          middlewares: getRouteMiddlewares(route)
+        };
+        return endpoint;
+      });
+      return endpoints;
+    }, "parseExpressRoute");
+    parseExpressPathRegExp = /* @__PURE__ */ __name(function(expressPathRegExp, keys) {
+      let parsedRegExp = expressPathRegExp.toString();
+      let expressPathRegExpExec = regExpToParseExpressPathRegExp.exec(parsedRegExp);
+      let paramIndex = 0;
+      while (hasParams(parsedRegExp)) {
+        const paramName = keys[paramIndex].name;
+        const paramId = `:${paramName}`;
+        parsedRegExp = parsedRegExp.replace(regExpToReplaceExpressPathRegExpParams, (str) => {
+          if (str.startsWith("(?:\\/")) {
+            return `\\/${paramId}`;
+          }
+          return paramId;
+        });
+        paramIndex++;
+      }
+      if (parsedRegExp !== expressPathRegExp.toString()) {
+        expressPathRegExpExec = regExpToParseExpressPathRegExp.exec(parsedRegExp);
+      }
+      return expressPathRegExpExec[1].replace(/\\\//g, "/");
+    }, "parseExpressPathRegExp");
+    parseExpressPath = /* @__PURE__ */ __name(function(expressPath, params) {
+      let result = expressPath;
+      for (const [paramName, paramValue] of Object.entries(params)) {
+        result = result.replace(paramValue, `:${paramName}`);
+      }
+      return result;
+    }, "parseExpressPath");
+    parseEndpoints = /* @__PURE__ */ __name(function(app, basePath, endpoints) {
+      const routerInfo = getRouterInfo(app);
+      const stack = routerInfo.stack;
+      const version = routerInfo.version;
+      endpoints = endpoints || [];
+      basePath = basePath || "";
+      if (!stack) {
+        if (endpoints.length) {
+          endpoints = addEndpoints(endpoints, [
+            {
+              path: basePath,
+              methods: [],
+              middlewares: []
+            }
+          ]);
         }
-      ]);
-    }
-  } else {
-    endpoints = parseStack(stack, basePath, endpoints, version);
-  }
-  return endpoints;
-}, "parseEndpoints");
-var addEndpoints = /* @__PURE__ */ __name(function(currentEndpoints, endpointsToAdd) {
-  endpointsToAdd.forEach((newEndpoint) => {
-    const existingEndpoint = currentEndpoints.find((endpoint) => endpoint.path === newEndpoint.path);
-    if (existingEndpoint !== void 0) {
-      const newMethods = newEndpoint.methods.filter((method) => !existingEndpoint.methods.includes(method));
-      existingEndpoint.methods = existingEndpoint.methods.concat(newMethods);
-    } else {
-      currentEndpoints.push(newEndpoint);
-    }
-  });
-  return currentEndpoints;
-}, "addEndpoints");
-var parseStack = /* @__PURE__ */ __name(function(stack, basePath, endpoints, version) {
-  stack.forEach((stackItem) => {
-    if (stackItem.route) {
-      const newEndpoints = parseExpressRoute(stackItem.route, basePath);
-      endpoints = addEndpoints(endpoints, newEndpoints);
-    } else if (STACK_ITEM_VALID_NAMES.includes(stackItem.name)) {
-      let newBasePath = basePath;
-      if (version === "v4") {
-        const isExpressPathRegExp = regExpToParseExpressPathRegExp.test(stackItem.regexp);
-        if (isExpressPathRegExp) {
-          const parsedPath = parseExpressPathRegExp(stackItem.regexp, stackItem.keys);
-          newBasePath += `/${parsedPath}`;
-        } else if (!stackItem.path && stackItem.regexp && stackItem.regexp.toString() !== EXPRESS_ROOT_PATH_REGEXP_VALUE) {
-          const regExpPath = `RegExp(${stackItem.regexp})`;
-          newBasePath += `/${regExpPath}`;
-        }
-      } else if (version === "v5") {
-        if (!stackItem.path) {
-          return;
-        } else if (stackItem.path !== "/") {
-          newBasePath += stackItem.path.startsWith("/") ? stackItem.path : `/${stackItem.path}`;
+      } else {
+        endpoints = parseStack(stack, basePath, endpoints, version);
+      }
+      return endpoints;
+    }, "parseEndpoints");
+    addEndpoints = /* @__PURE__ */ __name(function(currentEndpoints, endpointsToAdd) {
+      endpointsToAdd.forEach((newEndpoint) => {
+        const existingEndpoint = currentEndpoints.find((endpoint) => endpoint.path === newEndpoint.path);
+        if (existingEndpoint !== void 0) {
+          const newMethods = newEndpoint.methods.filter((method) => !existingEndpoint.methods.includes(method));
+          existingEndpoint.methods = existingEndpoint.methods.concat(newMethods);
+        } else {
+          currentEndpoints.push(newEndpoint);
         }
-      }
-      endpoints = parseEndpoints(stackItem.handle, newBasePath, endpoints);
-    }
-  });
-  return endpoints;
-}, "parseStack");
-var getEndpoints = /* @__PURE__ */ __name(function(app, basePath) {
-  const endpoints = parseEndpoints(app);
-  const standardHttpMethods = [
-    "GET",
-    "POST",
-    "PUT",
-    "DELETE",
-    "PATCH"
-  ];
-  return endpoints.flatMap((route) => route.methods.filter((method) => standardHttpMethods.includes(method.toUpperCase())).map((method) => ({
-    method,
-    path: (basePath + route.path).replace(/\/\//g, "/")
-  })));
-}, "getEndpoints");
+      });
+      return currentEndpoints;
+    }, "addEndpoints");
+    parseStack = /* @__PURE__ */ __name(function(stack, basePath, endpoints, version) {
+      stack.forEach((stackItem) => {
+        if (stackItem.route) {
+          const newEndpoints = parseExpressRoute(stackItem.route, basePath);
+          endpoints = addEndpoints(endpoints, newEndpoints);
+        } else if (STACK_ITEM_VALID_NAMES.includes(stackItem.name)) {
+          let newBasePath = basePath;
+          if (version === "v4") {
+            const isExpressPathRegExp = regExpToParseExpressPathRegExp.test(stackItem.regexp);
+            if (isExpressPathRegExp) {
+              const parsedPath = parseExpressPathRegExp(stackItem.regexp, stackItem.keys);
+              newBasePath += `/${parsedPath}`;
+            } else if (!stackItem.path && stackItem.regexp && stackItem.regexp.toString() !== EXPRESS_ROOT_PATH_REGEXP_VALUE) {
+              const regExpPath = `RegExp(${stackItem.regexp})`;
+              newBasePath += `/${regExpPath}`;
+            }
+          } else if (version === "v5") {
+            if (!stackItem.path) {
+              return;
+            } else if (stackItem.path !== "/") {
+              newBasePath += stackItem.path.startsWith("/") ? stackItem.path : `/${stackItem.path}`;
+            }
+          }
+          endpoints = parseEndpoints(stackItem.handle, newBasePath, endpoints);
+        }
+      });
+      return endpoints;
+    }, "parseStack");
+    getEndpoints = /* @__PURE__ */ __name(function(app, basePath) {
+      const endpoints = parseEndpoints(app);
+      const standardHttpMethods = [
+        "GET",
+        "POST",
+        "PUT",
+        "DELETE",
+        "PATCH"
+      ];
+      return endpoints.flatMap((route) => route.methods.filter((method) => standardHttpMethods.includes(method.toUpperCase())).map((method) => ({
+        method,
+        path: (basePath + route.path).replace(/\/\//g, "/")
+      })));
+    }, "getEndpoints");
+  }
+});
 
 // src/express/middleware.ts
 function useApitally(app, config) {
@@ -12348,7 +12419,6 @@ function useApitally(app, config) {
   }, "setStartupData");
   setTimeout(() => setStartupData(), 500);
 }
-__name(useApitally, "useApitally");
 function getMiddleware(app, client) {
   let errorHandlerConfigured = false;
   return (req, res, next) => {
@@ -12467,7 +12537,6 @@ function getMiddleware(app, client) {
     }
   };
 }
-__name(getMiddleware, "getMiddleware");
 function getRoutePath(req) {
   if (!req.route) {
     return;
@@ -12481,7 +12550,6 @@ function getRoutePath(req) {
   }
   return req.route.path;
 }
-__name(getRoutePath, "getRoutePath");
 function getRouterPath(stack, baseUrl) {
   var _a3;
   const routerPaths = [];
@@ -12508,11 +12576,9 @@ function getRouterPath(stack, baseUrl) {
   }
   return routerPaths.filter((path) => path !== "/").join("");
 }
-__name(getRouterPath, "getRouterPath");
 function setConsumer(req, consumer) {
   req.apitallyConsumer = consumer || void 0;
 }
-__name(setConsumer, "setConsumer");
 function getConsumer(req) {
   if (req.apitallyConsumer) {
     return consumerFromStringOrObject(req.apitallyConsumer);
@@ -12522,7 +12588,6 @@ function getConsumer(req) {
   }
   return null;
 }
-__name(getConsumer, "getConsumer");
 function extractExpressValidatorErrors(responseBody) {
   try {
     const errors = [];
@@ -12542,7 +12607,6 @@ function extractExpressValidatorErrors(responseBody) {
     return [];
   }
 }
-__name(extractExpressValidatorErrors, "extractExpressValidatorErrors");
 function extractCelebrateErrors(responseBody) {
   try {
     const errors = [];
@@ -12564,7 +12628,6 @@ function extractCelebrateErrors(responseBody) {
     return [];
   }
 }
-__name(extractCelebrateErrors, "extractCelebrateErrors");
 function extractNestValidationErrors(responseBody) {
   try {
     const errors = [];
@@ -12582,12 +12645,10 @@ function extractNestValidationErrors(responseBody) {
     return [];
   }
 }
-__name(extractNestValidationErrors, "extractNestValidationErrors");
 function subsetJoiMessage(message, key) {
   const messageWithKey = message.split(". ").find((message2) => message2.includes(`"${key}"`));
   return messageWithKey ? messageWithKey : message;
 }
-__name(subsetJoiMessage, "subsetJoiMessage");
 function getAppInfo(app, basePath, appVersion) {
   const versions = [
     [
@@ -12628,9 +12689,298 @@ function getAppInfo(app, basePath, appVersion) {
     client: "js:express"
   };
 }
-__name(getAppInfo, "getAppInfo");
+var import_perf_hooks;
+var init_middleware = __esm({
+  "src/express/middleware.ts"() {
+    "use strict";
+    import_perf_hooks = require("perf_hooks");
+    init_client();
+    init_consumerRegistry();
+    init_headers();
+    init_packageVersions();
+    init_requestLogger();
+    init_utils();
+    __name(useApitally, "useApitally");
+    __name(getMiddleware, "getMiddleware");
+    __name(getRoutePath, "getRoutePath");
+    __name(getRouterPath, "getRouterPath");
+    __name(setConsumer, "setConsumer");
+    __name(getConsumer, "getConsumer");
+    __name(extractExpressValidatorErrors, "extractExpressValidatorErrors");
+    __name(extractCelebrateErrors, "extractCelebrateErrors");
+    __name(extractNestValidationErrors, "extractNestValidationErrors");
+    __name(subsetJoiMessage, "subsetJoiMessage");
+    __name(getAppInfo, "getAppInfo");
+  }
+});
+
+// src/express/index.ts
+var express_exports = {};
+__export(express_exports, {
+  setConsumer: () => setConsumer,
+  useApitally: () => useApitally
+});
+var init_express = __esm({
+  "src/express/index.ts"() {
+    "use strict";
+    init_middleware();
+  }
+});
+
+// src/fastify/plugin.ts
+function getAppInfo2(routes, appVersion) {
+  const versions = [
+    [
+      "nodejs",
+      process.version.replace(/^v/, "")
+    ]
+  ];
+  const fastifyVersion = getPackageVersion("fastify");
+  const nestjsVersion = getPackageVersion("@nestjs/core");
+  const apitallyVersion = getPackageVersion("../..");
+  if (fastifyVersion) {
+    versions.push([
+      "fastify",
+      fastifyVersion
+    ]);
+  }
+  if (nestjsVersion) {
+    versions.push([
+      "nestjs",
+      nestjsVersion
+    ]);
+  }
+  if (apitallyVersion) {
+    versions.push([
+      "apitally",
+      apitallyVersion
+    ]);
+  }
+  if (appVersion) {
+    versions.push([
+      "app",
+      appVersion
+    ]);
+  }
+  return {
+    paths: routes,
+    versions: Object.fromEntries(versions),
+    client: "js:fastify"
+  };
+}
+function setConsumer2(request, consumer) {
+  request.apitallyConsumer = consumer || void 0;
+}
+function getConsumer2(request) {
+  if (request.apitallyConsumer) {
+    return consumerFromStringOrObject(request.apitallyConsumer);
+  } else if (request.consumerIdentifier) {
+    process.emitWarning("The consumerIdentifier property on the request object is deprecated. Use apitallyConsumer instead.", "DeprecationWarning");
+    return consumerFromStringOrObject(request.consumerIdentifier);
+  }
+  return null;
+}
+function getResponseTime(reply) {
+  if (reply.elapsedTime !== void 0) {
+    return reply.elapsedTime;
+  } else if (reply.getResponseTime !== void 0) {
+    return reply.getResponseTime();
+  }
+  return 0;
+}
+function extractAjvErrors(message) {
+  try {
+    const regex = /(?<=^|, )((?:headers|params|query|querystring|body)[/.][^ ]+)(?= )/g;
+    const matches = [];
+    let match;
+    while ((match = regex.exec(message)) !== null) {
+      matches.push({
+        match: match[0],
+        index: match.index
+      });
+    }
+    return matches.map((m, i) => {
+      const endIndex = i + 1 < matches.length ? matches[i + 1].index - 2 : message.length;
+      const matchSplit = m.match.split(/[/.]/);
+      if (matchSplit[0] === "querystring") {
+        matchSplit[0] = "query";
+      }
+      return {
+        loc: matchSplit.join("."),
+        msg: message.substring(m.index, endIndex),
+        type: ""
+      };
+    });
+  } catch (error) {
+    return [];
+  }
+}
+function extractNestValidationErrors2(message) {
+  try {
+    return message.filter((msg) => typeof msg === "string").map((msg) => ({
+      loc: "",
+      msg,
+      type: ""
+    }));
+  } catch (error) {
+    return [];
+  }
+}
+var import_fastify_plugin, apitallyPlugin, plugin_default;
+var init_plugin = __esm({
+  "src/fastify/plugin.ts"() {
+    "use strict";
+    import_fastify_plugin = __toESM(require("fastify-plugin"), 1);
+    init_client();
+    init_consumerRegistry();
+    init_headers();
+    init_packageVersions();
+    init_requestLogger();
+    apitallyPlugin = /* @__PURE__ */ __name(async (fastify, config) => {
+      const client = new ApitallyClient(config);
+      const routes = [];
+      fastify.decorateRequest("apitallyConsumer", null);
+      fastify.decorateRequest("consumerIdentifier", null);
+      fastify.decorateReply("payload", null);
+      fastify.addHook("onRoute", (routeOptions) => {
+        const methods = Array.isArray(routeOptions.method) ? routeOptions.method : [
+          routeOptions.method
+        ];
+        methods.forEach((method) => {
+          if (![
+            "HEAD",
+            "OPTIONS"
+          ].includes(method.toUpperCase())) {
+            routes.push({
+              method: method.toUpperCase(),
+              path: routeOptions.url
+            });
+          }
+        });
+      });
+      fastify.addHook("onReady", () => {
+        client.setStartupData(getAppInfo2(routes, config.appVersion));
+      });
+      fastify.addHook("onClose", async () => {
+        await client.handleShutdown();
+      });
+      fastify.addHook("onSend", (request, reply, payload, done) => {
+        const contentType = reply.getHeader("content-type");
+        if (client.requestLogger.isSupportedContentType(contentType)) {
+          reply.payload = payload;
+        }
+        done();
+      });
+      fastify.addHook("onError", (request, reply, error, done) => {
+        if (!error.statusCode || error.statusCode === 500) {
+          reply.serverError = error;
+        }
+        done();
+      });
+      fastify.addHook("onResponse", (request, reply, done) => {
+        var _a3;
+        if (client.isEnabled() && request.method.toUpperCase() !== "OPTIONS") {
+          const consumer = getConsumer2(request);
+          const path = "routeOptions" in request ? request.routeOptions.url : request.routerPath;
+          const requestSize = parseContentLength(request.headers["content-length"]);
+          const responseSize = parseContentLength(reply.getHeader("content-length"));
+          const responseTime = getResponseTime(reply);
+          client.consumerRegistry.addOrUpdateConsumer(consumer);
+          client.requestCounter.addRequest({
+            consumer: consumer == null ? void 0 : consumer.identifier,
+            method: request.method,
+            path,
+            statusCode: reply.statusCode,
+            responseTime,
+            requestSize,
+            responseSize
+          });
+          if ((reply.statusCode === 400 || reply.statusCode === 422) && reply.payload) {
+            try {
+              const parsedPayload = JSON.parse(reply.payload);
+              const validationErrors = [];
+              if ((!parsedPayload.code || parsedPayload.code === "FST_ERR_VALIDATION") && typeof parsedPayload.message === "string") {
+                validationErrors.push(...extractAjvErrors(parsedPayload.message));
+              } else if (Array.isArray(parsedPayload.message)) {
+                validationErrors.push(...extractNestValidationErrors2(parsedPayload.message));
+              }
+              validationErrors.forEach((error) => {
+                client.validationErrorCounter.addValidationError({
+                  consumer: consumer == null ? void 0 : consumer.identifier,
+                  method: request.method,
+                  path,
+                  ...error
+                });
+              });
+            } catch (error) {
+            }
+          }
+          if (reply.statusCode === 500 && reply.serverError) {
+            client.serverErrorCounter.addServerError({
+              consumer: consumer == null ? void 0 : consumer.identifier,
+              method: request.method,
+              path,
+              type: reply.serverError.name,
+              msg: reply.serverError.message,
+              traceback: reply.serverError.stack || ""
+            });
+          }
+          if (client.requestLogger.enabled) {
+            client.requestLogger.logRequest({
+              timestamp: Date.now() / 1e3,
+              method: request.method,
+              path,
+              url: `${request.protocol}://${request.host ?? request.hostname}${request.originalUrl ?? request.url}`,
+              headers: convertHeaders(request.headers),
+              size: Number(requestSize),
+              consumer: consumer == null ? void 0 : consumer.identifier,
+              body: convertBody(request.body, request.headers["content-type"])
+            }, {
+              statusCode: reply.statusCode,
+              responseTime: responseTime / 1e3,
+              headers: convertHeaders(reply.getHeaders()),
+              size: Number(responseSize),
+              body: convertBody(reply.payload, (_a3 = reply.getHeader("content-type")) == null ? void 0 : _a3.toString())
+            }, reply.serverError);
+          }
+        }
+        done();
+      });
+    }, "apitallyPlugin");
+    __name(getAppInfo2, "getAppInfo");
+    __name(setConsumer2, "setConsumer");
+    __name(getConsumer2, "getConsumer");
+    __name(getResponseTime, "getResponseTime");
+    __name(extractAjvErrors, "extractAjvErrors");
+    __name(extractNestValidationErrors2, "extractNestValidationErrors");
+    plugin_default = (0, import_fastify_plugin.default)(apitallyPlugin, {
+      name: "apitally"
+    });
+  }
+});
+
+// src/fastify/index.ts
+var fastify_exports = {};
+__export(fastify_exports, {
+  apitallyPlugin: () => plugin_default,
+  setConsumer: () => setConsumer2
+});
+var init_fastify = __esm({
+  "src/fastify/index.ts"() {
+    "use strict";
+    init_plugin();
+  }
+});
 
 // src/nestjs/index.ts
+var nestjs_exports = {};
+__export(nestjs_exports, {
+  setConsumer: () => setConsumer3,
+  useApitally: () => useApitally2
+});
+module.exports = __toCommonJS(nestjs_exports);
+var import_common = require("@nestjs/common");
+var import_rxjs = __toESM(require_cjs(), 1);
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -12638,22 +12988,48 @@ function _ts_decorate(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate, "_ts_decorate");
-function useApitally2(app, config) {
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+var setConsumerFn = null;
+async function useApitally2(app, config) {
   const httpAdapter = app.getHttpAdapter();
-  const expressInstance = httpAdapter.getInstance();
-  useApitally(expressInstance, config);
-  app.useGlobalInterceptors(new ApitallyInterceptor());
+  const instance = httpAdapter.getInstance();
+  const platform = httpAdapter.constructor.name.toLowerCase().includes("fastify") ? "fastify" : "express";
+  if (platform === "express") {
+    const { useApitally: useApitally3, setConsumer: setConsumer4 } = await Promise.resolve().then(() => (init_express(), express_exports));
+    setConsumerFn = setConsumer4;
+    useApitally3(instance, config);
+  } else if (platform === "fastify") {
+    const { apitallyPlugin: apitallyPlugin2, setConsumer: setConsumer4 } = await Promise.resolve().then(() => (init_fastify(), fastify_exports));
+    setConsumerFn = setConsumer4;
+    await instance.register(apitallyPlugin2, config);
+  }
+  app.useGlobalInterceptors(new ApitallyInterceptor(platform));
 }
 __name(useApitally2, "useApitally");
+function setConsumer3(request, consumer) {
+  if (setConsumerFn) {
+    setConsumerFn(request, consumer);
+  }
+}
+__name(setConsumer3, "setConsumer");
 var _a2;
 var ApitallyInterceptor = (_a2 = class {
+  platform;
+  constructor(platform) {
+    this.platform = platform;
+  }
   intercept(context, next) {
     return next.handle().pipe((0, import_rxjs.catchError)((exception) => {
       if (context.getType() === "http") {
         const ctx = context.switchToHttp();
         const res = ctx.getResponse();
-        if (res.locals) {
+        if (this.platform === "express" && res.locals) {
           res.locals.serverError = exception;
+        } else if (this.platform === "fastify" && (!exception.statusCode || exception.statusCode === 500)) {
+          res.serverError = exception;
         }
       }
       return (0, import_rxjs.throwError)(() => exception);
@@ -12661,7 +13037,11 @@ var ApitallyInterceptor = (_a2 = class {
   }
 }, __name(_a2, "ApitallyInterceptor"), _a2);
 ApitallyInterceptor = _ts_decorate([
-  (0, import_common.Injectable)()
+  (0, import_common.Injectable)(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    String
+  ])
 ], ApitallyInterceptor);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {