apitally 0.6.0 → 0.7.0

package/dist/express/middleware.cjs

@@ -0,0 +1,835 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/express/middleware.ts
+var middleware_exports = {};
+__export(middleware_exports, {
+  useApitally: () => useApitally
+});
+module.exports = __toCommonJS(middleware_exports);
+var import_perf_hooks = require("perf_hooks");
+
+// src/common/client.ts
+var import_crypto3 = require("crypto");
+var import_fetch_retry = __toESM(require("fetch-retry"), 1);
+
+// 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");
+
+// 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");
+
+// 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;
+  }
+};
+__name(_RequestCounter, "RequestCounter");
+var RequestCounter = _RequestCounter;
+
+// 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;
+  sentry;
+  constructor() {
+    this.errorCounts = /* @__PURE__ */ new Map();
+    this.errorDetails = /* @__PURE__ */ new Map();
+    this.sentryEventIds = /* @__PURE__ */ new Map();
+    this.tryImportSentry();
+  }
+  addServerError(serverError) {
+    const key = this.getKey(serverError);
+    if (!this.errorDetails.has(key)) {
+      this.errorDetails.set(key, serverError);
+    }
+    this.errorCounts.set(key, (this.errorCounts.get(key) || 0) + 1);
+    this.captureSentryEventId(key);
+  }
+  getAndResetServerErrors() {
+    const data = [];
+    this.errorCounts.forEach((count, key) => {
+      const serverError = this.errorDetails.get(key);
+      if (serverError) {
+        data.push({
+          consumer: serverError.consumer || null,
+          method: serverError.method,
+          path: serverError.path,
+          type: serverError.type,
+          msg: this.getTruncatedMessage(serverError.msg),
+          traceback: this.getTruncatedStack(serverError.traceback),
+          sentry_event_id: this.sentryEventIds.get(key) || null,
+          error_count: count
+        });
+      }
+    });
+    this.errorCounts.clear();
+    this.errorDetails.clear();
+    return data;
+  }
+  getKey(serverError) {
+    const hashInput = [
+      serverError.consumer || "",
+      serverError.method.toUpperCase(),
+      serverError.path,
+      serverError.type,
+      serverError.msg.trim(),
+      serverError.traceback.trim()
+    ].join("|");
+    return (0, import_crypto.createHash)("md5").update(hashInput).digest("hex");
+  }
+  getTruncatedMessage(msg) {
+    msg = msg.trim();
+    if (msg.length <= MAX_MSG_LENGTH) {
+      return msg;
+    }
+    const suffix = "... (truncated)";
+    const cutoff = MAX_MSG_LENGTH - suffix.length;
+    return msg.substring(0, cutoff) + suffix;
+  }
+  getTruncatedStack(stack) {
+    const suffix = "... (truncated) ...";
+    const cutoff = MAX_STACKTRACE_LENGTH - suffix.length;
+    const lines = stack.trim().split("\n");
+    const truncatedLines = [];
+    let length = 0;
+    for (const line of lines) {
+      if (length + line.length + 1 > cutoff) {
+        truncatedLines.push(suffix);
+        break;
+      }
+      truncatedLines.push(line);
+      length += line.length + 1;
+    }
+    return truncatedLines.join("\n");
+  }
+  captureSentryEventId(serverErrorKey) {
+    if (this.sentry && this.sentry.lastEventId) {
+      const eventId = this.sentry.lastEventId();
+      if (eventId) {
+        this.sentryEventIds.set(serverErrorKey, eventId);
+      }
+    }
+  }
+  async tryImportSentry() {
+    try {
+      this.sentry = await import("@sentry/node");
+    } catch (e) {
+    }
+  }
+};
+__name(_ServerErrorCounter, "ServerErrorCounter");
+var ServerErrorCounter = _ServerErrorCounter;
+
+// src/common/validationErrorCounter.ts
+var import_crypto2 = 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
+        });
+      }
+    });
+    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_crypto2.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;
+  requestsDataQueue;
+  syncIntervalId;
+  appInfo;
+  appInfoSent = false;
+  requestCounter;
+  validationErrorCounter;
+  serverErrorCounter;
+  logger;
+  constructor({ clientId, env = "dev", logger }) {
+    if (_ApitallyClient.instance) {
+      throw new Error("Apitally client is already initialized");
+    }
+    if (!isValidClientId(clientId)) {
+      throw new Error(`Invalid client ID '${clientId}' (expecting hexadeciaml UUID format)`);
+    }
+    if (!isValidEnv(env)) {
+      throw new Error(`Invalid env '${env}' (expecting 1-32 alphanumeric lowercase characters and hyphens only)`);
+    }
+    _ApitallyClient.instance = this;
+    this.clientId = clientId;
+    this.env = env;
+    this.instanceUuid = (0, import_crypto3.randomUUID)();
+    this.requestsDataQueue = [];
+    this.requestCounter = new RequestCounter();
+    this.validationErrorCounter = new ValidationErrorCounter();
+    this.serverErrorCounter = new ServerErrorCounter();
+    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;
+  }
+  static async shutdown() {
+    if (_ApitallyClient.instance) {
+      await _ApitallyClient.instance.handleShutdown();
+    }
+  }
+  async handleShutdown() {
+    this.stopSync();
+    await this.sendRequestsData();
+    _ApitallyClient.instance = void 0;
+  }
+  getHubUrlPrefix() {
+    const baseURL = process.env.APITALLY_HUB_BASE_URL || "https://hub.apitally.io";
+    const version = "v1";
+    return `${baseURL}/${version}/${this.clientId}/${this.env}/`;
+  }
+  async makeHubRequest(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);
+    }
+  }
+  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.sendRequestsData()
+      ];
+      if (!this.appInfoSent) {
+        promises.push(this.sendAppInfo());
+      }
+      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;
+    }
+  }
+  setAppInfo(appInfo) {
+    this.appInfo = appInfo;
+    this.appInfoSent = false;
+    this.sendAppInfo();
+  }
+  async sendAppInfo() {
+    if (this.appInfo) {
+      this.logger.debug("Sending app info to Apitally Hub");
+      const payload = {
+        instance_uuid: this.instanceUuid,
+        message_uuid: (0, import_crypto3.randomUUID)(),
+        ...this.appInfo
+      };
+      try {
+        await this.makeHubRequest("info", payload);
+        this.appInfoSent = true;
+      } catch (error) {
+        const handled = this.handleHubError(error);
+        if (!handled) {
+          this.logger.error(error.message);
+          this.logger.debug("Error while sending app info to Apitally Hub (will retry)", {
+            error
+          });
+        }
+      }
+    }
+  }
+  async sendRequestsData() {
+    this.logger.debug("Sending requests data to Apitally Hub");
+    const newPayload = {
+      time_offset: 0,
+      instance_uuid: this.instanceUuid,
+      message_uuid: (0, import_crypto3.randomUUID)(),
+      requests: this.requestCounter.getAndResetRequests(),
+      validation_errors: this.validationErrorCounter.getAndResetValidationErrors(),
+      server_errors: this.serverErrorCounter.getAndResetServerErrors()
+    };
+    this.requestsDataQueue.push([
+      Date.now(),
+      newPayload
+    ]);
+    const failedItems = [];
+    while (this.requestsDataQueue.length > 0) {
+      const queueItem = this.requestsDataQueue.shift();
+      if (queueItem) {
+        const [time, payload] = queueItem;
+        try {
+          const timeOffset = Date.now() - time;
+          if (timeOffset <= MAX_QUEUE_TIME) {
+            payload.time_offset = timeOffset / 1e3;
+            await this.makeHubRequest("requests", payload);
+          }
+        } catch (error) {
+          const handled = this.handleHubError(error);
+          if (!handled) {
+            this.logger.debug("Error while sending requests data to Apitally Hub (will retry)", {
+              error
+            });
+            failedItems.push(queueItem);
+          }
+        }
+      }
+    }
+    this.requestsDataQueue = failedItems;
+  }
+  handleHubError(error) {
+    if (error instanceof HTTPError) {
+      if (error.response.status === 404) {
+        this.logger.error(`Invalid Apitally client ID: '${this.clientId}'`);
+        this.stopSync();
+        return true;
+      }
+      if (error.response.status === 422) {
+        this.logger.error("Received validation error from Apitally Hub");
+        return true;
+      }
+    }
+    return false;
+  }
+};
+__name(_ApitallyClient, "ApitallyClient");
+__publicField(_ApitallyClient, "instance");
+var ApitallyClient = _ApitallyClient;
+
+// src/common/packageVersions.ts
+var import_module = require("module");
+var import_meta = {};
+function getPackageVersion(name) {
+  try {
+    const _require = (0, import_module.createRequire)(import_meta.url);
+    return _require(`${name}/package.json`).version || null;
+  } catch (error) {
+    return null;
+  }
+}
+__name(getPackageVersion, "getPackageVersion");
+
+// src/express/listEndpoints.js
+var regExpToParseExpressPathRegExp = /^\/\^\\\/(?:(:?[\w\\.-]*(?:\\\/:?[\w\\.-]*)*)|(\(\?:\(\[\^\\\/]\+\?\)\)))\\\/.*/;
+var regExpToReplaceExpressPathRegExpParams = /\(\?:\(\[\^\\\/]\+\?\)\)/;
+var regexpExpressParamRegexp = /\(\?:\(\[\^\\\/]\+\?\)\)/g;
+var EXPRESS_ROOT_PATH_REGEXP_VALUE = "/^\\/?(?=\\/|$)/i";
+var STACK_ITEM_VALID_NAMES = [
+  "router",
+  "bound dispatch",
+  "mounted_app"
+];
+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,
+      methods: getRouteMethods(route),
+      middlewares: getRouteMiddlewares(route)
+    };
+    return endpoint;
+  });
+  return endpoints;
+}, "parseExpressRoute");
+var parseExpressPath = /* @__PURE__ */ __name(function(expressPathRegExp, params) {
+  let expressPathRegExpExec = regExpToParseExpressPathRegExp.exec(expressPathRegExp);
+  let parsedRegExp = expressPathRegExp.toString();
+  let paramIndex = 0;
+  while (hasParams(parsedRegExp)) {
+    const paramName = params[paramIndex].name;
+    const paramId = `:${paramName}`;
+    parsedRegExp = parsedRegExp.replace(regExpToReplaceExpressPathRegExpParams, paramId);
+    paramIndex++;
+  }
+  if (parsedRegExp !== expressPathRegExp.toString()) {
+    expressPathRegExpExec = regExpToParseExpressPathRegExp.exec(parsedRegExp);
+  }
+  const parsedPath = expressPathRegExpExec[1].replace(/\\\//g, "/");
+  return parsedPath;
+}, "parseExpressPath");
+var parseEndpoints = /* @__PURE__ */ __name(function(app, basePath, endpoints) {
+  const stack = app.stack || app._router && app._router.stack;
+  endpoints = endpoints || [];
+  basePath = basePath || "";
+  if (!stack) {
+    endpoints = addEndpoints(endpoints, [
+      {
+        path: basePath,
+        methods: [],
+        middlewares: []
+      }
+    ]);
+  } else {
+    endpoints = parseStack(stack, basePath, endpoints);
+  }
+  return endpoints;
+}, "parseEndpoints");
+var addEndpoints = /* @__PURE__ */ __name(function(currentEndpoints, endpointsToAdd) {
+  endpointsToAdd.forEach((newEndpoint) => {
+    const existingEndpoint = currentEndpoints.find((item) => item.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) {
+  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)) {
+      const isExpressPathRegexp = regExpToParseExpressPathRegExp.test(stackItem.regexp);
+      let newBasePath = basePath;
+      if (isExpressPathRegexp) {
+        const parsedPath = parseExpressPath(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}`;
+      }
+      endpoints = parseEndpoints(stackItem.handle, newBasePath, endpoints);
+    }
+  });
+  return endpoints;
+}, "parseStack");
+var getEndpoints = /* @__PURE__ */ __name(function(app) {
+  const endpoints = parseEndpoints(app);
+  return endpoints.flatMap((route) => route.methods.filter((method) => ![
+    "HEAD",
+    "OPTIONS"
+  ].includes(method.toUpperCase())).map((method) => ({
+    method,
+    path: route.path
+  })));
+}, "getEndpoints");
+var listEndpoints_default = getEndpoints;
+
+// src/express/middleware.ts
+var useApitally = /* @__PURE__ */ __name((app, config) => {
+  const client = new ApitallyClient(config);
+  const middleware = getMiddleware(app, client);
+  app.use(middleware);
+  setTimeout(() => {
+    client.setAppInfo(getAppInfo(app, config.appVersion));
+  }, 1e3);
+}, "useApitally");
+var getMiddleware = /* @__PURE__ */ __name((app, client) => {
+  const validatorInstalled = getPackageVersion("express-validator") !== null;
+  const celebrateInstalled = getPackageVersion("celebrate") !== null;
+  const nestInstalled = getPackageVersion("@nestjs/core") !== null;
+  const classValidatorInstalled = getPackageVersion("class-validator") !== null;
+  let errorHandlerConfigured = false;
+  return (req, res, next) => {
+    if (!errorHandlerConfigured) {
+      app.use((err, req2, res2, next2) => {
+        res2.locals.serverError = err;
+        next2(err);
+      });
+      errorHandlerConfigured = true;
+    }
+    try {
+      const startTime = import_perf_hooks.performance.now();
+      const originalJson = res.json;
+      res.json = (body) => {
+        res.locals.body = body;
+        return originalJson.call(res, body);
+      };
+      res.on("finish", () => {
+        try {
+          if (req.route) {
+            const responseTime = import_perf_hooks.performance.now() - startTime;
+            const consumer = getConsumer(req);
+            client.requestCounter.addRequest({
+              consumer,
+              method: req.method,
+              path: req.route.path,
+              statusCode: res.statusCode,
+              responseTime,
+              requestSize: req.get("content-length"),
+              responseSize: res.get("content-length")
+            });
+            if ((res.statusCode === 400 || res.statusCode === 422) && res.locals.body) {
+              const validationErrors = [];
+              if (validatorInstalled) {
+                validationErrors.push(...extractExpressValidatorErrors(res.locals.body));
+              }
+              if (celebrateInstalled) {
+                validationErrors.push(...extractCelebrateErrors(res.locals.body));
+              }
+              if (nestInstalled && classValidatorInstalled) {
+                validationErrors.push(...extractNestValidationErrors(res.locals.body));
+              }
+              validationErrors.forEach((error) => {
+                client.validationErrorCounter.addValidationError({
+                  consumer,
+                  method: req.method,
+                  path: req.route.path,
+                  ...error
+                });
+              });
+            }
+            if (res.statusCode === 500 && res.locals.serverError) {
+              const serverError = res.locals.serverError;
+              client.serverErrorCounter.addServerError({
+                consumer,
+                method: req.method,
+                path: req.route.path,
+                type: serverError.name,
+                msg: serverError.message,
+                traceback: serverError.stack || ""
+              });
+            }
+          }
+        } catch (error) {
+          client.logger.error("Error while logging request in Apitally middleware.", {
+            request: req,
+            response: res,
+            error
+          });
+        }
+      });
+    } catch (error) {
+      client.logger.error("Error in Apitally middleware.", {
+        request: req,
+        response: res,
+        error
+      });
+    } finally {
+      next();
+    }
+  };
+}, "getMiddleware");
+var getConsumer = /* @__PURE__ */ __name((req) => {
+  if (req.apitallyConsumer) {
+    return String(req.apitallyConsumer);
+  } else if (req.consumerIdentifier) {
+    return String(req.consumerIdentifier);
+  }
+  return null;
+}, "getConsumer");
+var extractExpressValidatorErrors = /* @__PURE__ */ __name((responseBody) => {
+  const errors = [];
+  if (responseBody && responseBody.errors && Array.isArray(responseBody.errors)) {
+    responseBody.errors.forEach((error) => {
+      if (error.location && error.path && error.msg && error.type) {
+        errors.push({
+          loc: `${error.location}.${error.path}`,
+          msg: error.msg,
+          type: error.type
+        });
+      }
+    });
+  }
+  return errors;
+}, "extractExpressValidatorErrors");
+var extractCelebrateErrors = /* @__PURE__ */ __name((responseBody) => {
+  const errors = [];
+  if (responseBody && responseBody.validation) {
+    Object.values(responseBody.validation).forEach((error) => {
+      if (error.source && error.keys && Array.isArray(error.keys) && error.message) {
+        error.keys.forEach((key) => {
+          errors.push({
+            loc: `${error.source}.${key}`,
+            msg: subsetJoiMessage(error.message, key),
+            type: ""
+          });
+        });
+      }
+    });
+  }
+  return errors;
+}, "extractCelebrateErrors");
+var extractNestValidationErrors = /* @__PURE__ */ __name((responseBody) => {
+  const errors = [];
+  if (responseBody && Array.isArray(responseBody.message)) {
+    responseBody.message.forEach((message) => {
+      errors.push({
+        loc: "",
+        msg: message,
+        type: ""
+      });
+    });
+  }
+  return errors;
+}, "extractNestValidationErrors");
+var subsetJoiMessage = /* @__PURE__ */ __name((message, key) => {
+  const messageWithKey = message.split(". ").find((message2) => message2.includes(`"${key}"`));
+  return messageWithKey ? messageWithKey : message;
+}, "subsetJoiMessage");
+var getAppInfo = /* @__PURE__ */ __name((app, appVersion) => {
+  const versions = [
+    [
+      "nodejs",
+      process.version.replace(/^v/, "")
+    ]
+  ];
+  const expressVersion = getPackageVersion("express");
+  const apitallyVersion = getPackageVersion("../..");
+  if (expressVersion) {
+    versions.push([
+      "express",
+      expressVersion
+    ]);
+  }
+  if (apitallyVersion) {
+    versions.push([
+      "apitally",
+      apitallyVersion
+    ]);
+  }
+  if (appVersion) {
+    versions.push([
+      "app",
+      appVersion
+    ]);
+  }
+  return {
+    paths: listEndpoints_default(app),
+    versions: Object.fromEntries(versions),
+    client: "js:express"
+  };
+}, "getAppInfo");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useApitally
+});
+//# sourceMappingURL=middleware.cjs.map