apitally 0.6.0 → 0.7.0

package/dist/koa/index.js

@@ -0,0 +1,619 @@
+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/common/client.ts
+import { randomUUID } from "crypto";
+import fetchRetry from "fetch-retry";
+
+// 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;
+  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 = 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 = 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.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: 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: 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
+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/koa/middleware.ts
+var useApitally = /* @__PURE__ */ __name((app, config) => {
+  const client = new ApitallyClient(config);
+  const middleware = getMiddleware(client);
+  app.use(middleware);
+  setTimeout(() => {
+    client.setAppInfo(getAppInfo(app, config.appVersion));
+  }, 1e3);
+}, "useApitally");
+var getMiddleware = /* @__PURE__ */ __name((client) => {
+  return async (ctx, next) => {
+    let path;
+    let statusCode;
+    const startTime = performance.now();
+    try {
+      await next();
+    } catch (error) {
+      path = getPath(ctx);
+      statusCode = error.statusCode || error.status || 500;
+      if (path && statusCode === 500 && error instanceof Error) {
+        client.serverErrorCounter.addServerError({
+          consumer: getConsumer(ctx),
+          method: ctx.request.method,
+          path,
+          type: error.name,
+          msg: error.message,
+          traceback: error.stack || ""
+        });
+      }
+      throw error;
+    } finally {
+      if (!path) {
+        path = getPath(ctx);
+      }
+      if (path) {
+        try {
+          client.requestCounter.addRequest({
+            consumer: getConsumer(ctx),
+            method: ctx.request.method,
+            path,
+            statusCode: statusCode || ctx.response.status,
+            responseTime: performance.now() - startTime,
+            requestSize: ctx.request.length,
+            responseSize: ctx.response.length
+          });
+        } catch (error) {
+          client.logger.error("Error while logging request in Apitally middleware.", {
+            context: ctx,
+            error
+          });
+        }
+      }
+    }
+  };
+}, "getMiddleware");
+var getPath = /* @__PURE__ */ __name((ctx) => {
+  return ctx._matchedRoute || ctx.routePath;
+}, "getPath");
+var getConsumer = /* @__PURE__ */ __name((ctx) => {
+  if (ctx.state.apitallyConsumer) {
+    return String(ctx.state.apitallyConsumer);
+  } else if (ctx.state.consumerIdentifier) {
+    return String(ctx.state.consumerIdentifier);
+  }
+  return null;
+}, "getConsumer");
+var getAppInfo = /* @__PURE__ */ __name((app, appVersion) => {
+  const versions = [
+    [
+      "nodejs",
+      process.version.replace(/^v/, "")
+    ]
+  ];
+  const koaVersion = getPackageVersion("koa");
+  const apitallyVersion = getPackageVersion("../..");
+  if (koaVersion) {
+    versions.push([
+      "koa",
+      koaVersion
+    ]);
+  }
+  if (apitallyVersion) {
+    versions.push([
+      "apitally",
+      apitallyVersion
+    ]);
+  }
+  if (appVersion) {
+    versions.push([
+      "app",
+      appVersion
+    ]);
+  }
+  return {
+    paths: listEndpoints(app),
+    versions: Object.fromEntries(versions),
+    client: "js:koa"
+  };
+}, "getAppInfo");
+var isKoaRouterMiddleware = /* @__PURE__ */ __name((middleware) => {
+  return typeof middleware === "function" && middleware.router && Array.isArray(middleware.router.stack);
+}, "isKoaRouterMiddleware");
+var listEndpoints = /* @__PURE__ */ __name((app) => {
+  const endpoints = [];
+  app.middleware.forEach((middleware) => {
+    if (isKoaRouterMiddleware(middleware)) {
+      middleware.router.stack.forEach((layer) => {
+        if (layer.methods && layer.methods.length > 0) {
+          layer.methods.forEach((method) => {
+            if (![
+              "HEAD",
+              "OPTIONS"
+            ].includes(method.toUpperCase())) {
+              endpoints.push({
+                method: method.toUpperCase(),
+                path: layer.path
+              });
+            }
+          });
+        }
+      });
+    }
+  });
+  return endpoints;
+}, "listEndpoints");
+export {
+  useApitally
+};
+//# sourceMappingURL=index.js.map