apitally 0.6.1 → 0.8.0

package/dist/express/middleware.js

@@ -0,0 +1,862 @@
+var __defProp = Object.defineProperty;
+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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/express/middleware.ts
+import { performance } from "perf_hooks";
+
+// src/common/client.ts
+import { randomUUID } from "crypto";
+import fetchRetry from "fetch-retry";
+
+// src/common/consumerRegistry.ts
+var consumerFromStringOrObject = /* @__PURE__ */ __name((consumer) => {
+  var _a2, _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 = (_a2 = consumer.name) == null ? void 0 : _a2.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);
+      }
+    }
+  }
+  getAndResetUpdatedConsumers() {
+    const data = [];
+    this.updated.forEach((identifier) => {
+      const consumer = this.consumers.get(identifier);
+      if (consumer) {
+        data.push(consumer);
+      }
+    });
+    this.updated.clear();
+    return data;
+  }
+};
+__name(_ConsumerRegistry, "ConsumerRegistry");
+var ConsumerRegistry = _ConsumerRegistry;
+
+// src/common/logging.ts
+import { createLogger, format, transports } from "winston";
+var getLogger = /* @__PURE__ */ __name(() => {
+  return createLogger({
+    level: process.env.APITALLY_DEBUG ? "debug" : "warn",
+    format: format.combine(format.colorize(), format.timestamp(), format.printf((info) => `${info.timestamp} ${info.level}: ${info.message}`)),
+    transports: [
+      new 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
+import { createHash } from "crypto";
+var MAX_MSG_LENGTH = 2048;
+var MAX_STACKTRACE_LENGTH = 65536;
+var _ServerErrorCounter = class _ServerErrorCounter {
+  errorCounts;
+  errorDetails;
+  sentryEventIds;
+  sentry;
+  constructor() {
+    this.errorCounts = /* @__PURE__ */ new Map();
+    this.errorDetails = /* @__PURE__ */ new Map();
+    this.sentryEventIds = /* @__PURE__ */ new Map();
+    this.tryImportSentry();
+  }
+  addServerError(serverError) {
+    const key = this.getKey(serverError);
+    if (!this.errorDetails.has(key)) {
+      this.errorDetails.set(key, serverError);
+    }
+    this.errorCounts.set(key, (this.errorCounts.get(key) || 0) + 1);
+    this.captureSentryEventId(key);
+  }
+  getAndResetServerErrors() {
+    const data = [];
+    this.errorCounts.forEach((count, key) => {
+      const serverError = this.errorDetails.get(key);
+      if (serverError) {
+        data.push({
+          consumer: serverError.consumer || null,
+          method: serverError.method,
+          path: serverError.path,
+          type: serverError.type,
+          msg: this.getTruncatedMessage(serverError.msg),
+          traceback: this.getTruncatedStack(serverError.traceback),
+          sentry_event_id: this.sentryEventIds.get(key) || null,
+          error_count: count
+        });
+      }
+    });
+    this.errorCounts.clear();
+    this.errorDetails.clear();
+    return data;
+  }
+  getKey(serverError) {
+    const hashInput = [
+      serverError.consumer || "",
+      serverError.method.toUpperCase(),
+      serverError.path,
+      serverError.type,
+      serverError.msg.trim(),
+      serverError.traceback.trim()
+    ].join("|");
+    return createHash("md5").update(hashInput).digest("hex");
+  }
+  getTruncatedMessage(msg) {
+    msg = msg.trim();
+    if (msg.length <= MAX_MSG_LENGTH) {
+      return msg;
+    }
+    const suffix = "... (truncated)";
+    const cutoff = MAX_MSG_LENGTH - suffix.length;
+    return msg.substring(0, cutoff) + suffix;
+  }
+  getTruncatedStack(stack) {
+    const suffix = "... (truncated) ...";
+    const cutoff = MAX_STACKTRACE_LENGTH - suffix.length;
+    const lines = stack.trim().split("\n");
+    const truncatedLines = [];
+    let length = 0;
+    for (const line of lines) {
+      if (length + line.length + 1 > cutoff) {
+        truncatedLines.push(suffix);
+        break;
+      }
+      truncatedLines.push(line);
+      length += line.length + 1;
+    }
+    return truncatedLines.join("\n");
+  }
+  captureSentryEventId(serverErrorKey) {
+    if (this.sentry && this.sentry.lastEventId) {
+      const eventId = this.sentry.lastEventId();
+      if (eventId) {
+        this.sentryEventIds.set(serverErrorKey, eventId);
+      }
+    }
+  }
+  async tryImportSentry() {
+    try {
+      this.sentry = await import("@sentry/node");
+    } catch (e) {
+    }
+  }
+};
+__name(_ServerErrorCounter, "ServerErrorCounter");
+var ServerErrorCounter = _ServerErrorCounter;
+
+// src/common/validationErrorCounter.ts
+import { createHash as createHash2 } from "crypto";
+var _ValidationErrorCounter = class _ValidationErrorCounter {
+  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 createHash2("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;
+  requestCounter;
+  validationErrorCounter;
+  serverErrorCounter;
+  consumerRegistry;
+  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 = randomUUID();
+    this.syncDataQueue = [];
+    this.requestCounter = new RequestCounter();
+    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;
+  }
+  static async shutdown() {
+    if (_ApitallyClient.instance) {
+      await _ApitallyClient.instance.handleShutdown();
+    }
+  }
+  async handleShutdown() {
+    this.stopSync();
+    await this.sendSyncData();
+    _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 = fetchRetry(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.sendSyncData()
+      ];
+      if (!this.startupDataSent) {
+        promises.push(this.sendStartupData());
+      }
+      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: 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 = {
+      time_offset: 0,
+      instance_uuid: this.instanceUuid,
+      message_uuid: randomUUID(),
+      requests: this.requestCounter.getAndResetRequests(),
+      validation_errors: this.validationErrorCounter.getAndResetValidationErrors(),
+      server_errors: this.serverErrorCounter.getAndResetServerErrors(),
+      consumers: this.consumerRegistry.getAndResetUpdatedConsumers()
+    };
+    this.syncDataQueue.push([
+      Date.now(),
+      newPayload
+    ]);
+    const failedItems = [];
+    while (this.syncDataQueue.length > 0) {
+      const queueItem = this.syncDataQueue.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.sendData("sync", payload);
+          }
+        } catch (error) {
+          const handled = this.handleHubError(error);
+          if (!handled) {
+            this.logger.debug("Error while synchronizing data with Apitally Hub (will retry)", {
+              error
+            });
+            failedItems.push(queueItem);
+          }
+        }
+      }
+    }
+    this.syncDataQueue = 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
+import { createRequire } from "module";
+function getPackageVersion(name) {
+  try {
+    const _require = 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.setStartupData(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 = 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 = performance.now() - startTime;
+            const consumer = getConsumer(req);
+            client.consumerRegistry.addOrUpdateConsumer(consumer);
+            client.requestCounter.addRequest({
+              consumer: consumer == null ? void 0 : consumer.identifier,
+              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: consumer == null ? void 0 : consumer.identifier,
+                  method: req.method,
+                  path: req.route.path,
+                  ...error
+                });
+              });
+            }
+            if (res.statusCode === 500 && res.locals.serverError) {
+              const serverError = res.locals.serverError;
+              client.serverErrorCounter.addServerError({
+                consumer: consumer == null ? void 0 : consumer.identifier,
+                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 consumerFromStringOrObject(req.apitallyConsumer);
+  } else if (req.consumerIdentifier) {
+    process.emitWarning("The consumerIdentifier property on the request object is deprecated. Use apitallyConsumer instead.", "DeprecationWarning");
+    return consumerFromStringOrObject(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");
+export {
+  useApitally
+};
+//# sourceMappingURL=middleware.js.map