apitally 0.8.3 → 0.9.0

package/dist/hono/index.cjs

@@ -0,0 +1,783 @@
+"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/hono/index.ts
+var hono_exports = {};
+__export(hono_exports, {
+  useApitally: () => useApitally
+});
+module.exports = __toCommonJS(hono_exports);
+
+// src/hono/middleware.ts
+var import_handler = require("hono/utils/handler");
+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/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
+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;
+  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 = (0, import_crypto3.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 = (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.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: (0, import_crypto3.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: (0, import_crypto3.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
+    ]);
+    let i = 0;
+    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) {
+            if (i > 0) {
+              const waitMs = 100 + Math.random() * 200;
+              await new Promise((resolve) => setTimeout(resolve, waitMs));
+            }
+            payload.time_offset = timeOffset / 1e3;
+            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(queueItem);
+            break;
+          }
+        }
+      }
+    }
+  }
+  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/hono/middleware.ts
+var useApitally = /* @__PURE__ */ __name((app, config) => {
+  const client = new ApitallyClient(config);
+  const middleware = getMiddleware(client);
+  app.use(middleware);
+  setTimeout(() => {
+    client.setStartupData(getAppInfo(app, config.appVersion));
+  }, 1e3);
+}, "useApitally");
+var getMiddleware = /* @__PURE__ */ __name((client) => {
+  const zodInstalled = getPackageVersion("zod") !== null;
+  return async (c, next) => {
+    const startTime = import_perf_hooks.performance.now();
+    await next();
+    let response;
+    const responseTime = import_perf_hooks.performance.now() - startTime;
+    const [responseSize, newResponse] = await measureResponseSize(c.res);
+    const consumer = getConsumer(c);
+    client.consumerRegistry.addOrUpdateConsumer(consumer);
+    client.requestCounter.addRequest({
+      consumer: consumer == null ? void 0 : consumer.identifier,
+      method: c.req.method,
+      path: c.req.routePath,
+      statusCode: c.res.status,
+      responseTime,
+      requestSize: c.req.header("Content-Length"),
+      responseSize
+    });
+    response = newResponse;
+    if (c.res.status === 400 && zodInstalled) {
+      const [responseJson, newResponse2] = await getResponseJson(response);
+      const validationErrors = extractZodErrors(responseJson);
+      validationErrors.forEach((error) => {
+        client.validationErrorCounter.addValidationError({
+          consumer: consumer == null ? void 0 : consumer.identifier,
+          method: c.req.method,
+          path: c.req.routePath,
+          ...error
+        });
+      });
+      response = newResponse2;
+    }
+    if (c.error) {
+      client.serverErrorCounter.addServerError({
+        consumer: consumer == null ? void 0 : consumer.identifier,
+        method: c.req.method,
+        path: c.req.routePath,
+        type: c.error.name,
+        msg: c.error.message,
+        traceback: c.error.stack || ""
+      });
+    }
+    c.res = response;
+  };
+}, "getMiddleware");
+var getConsumer = /* @__PURE__ */ __name((c) => {
+  const consumer = c.get("apitallyConsumer");
+  if (consumer) {
+    return consumerFromStringOrObject(consumer);
+  }
+  return null;
+}, "getConsumer");
+var measureResponseSize = /* @__PURE__ */ __name(async (response) => {
+  const [newResponse1, newResponse2] = await teeResponse(response);
+  let size = 0;
+  if (newResponse2.body) {
+    let done = false;
+    const reader = newResponse2.body.getReader();
+    while (!done) {
+      const result = await reader.read();
+      done = result.done;
+      if (!done && result.value) {
+        size += result.value.byteLength;
+      }
+    }
+  }
+  return [
+    size,
+    newResponse1
+  ];
+}, "measureResponseSize");
+var getResponseJson = /* @__PURE__ */ __name(async (response) => {
+  const contentType = response.headers.get("content-type");
+  if (contentType && contentType.includes("application/json")) {
+    const [newResponse1, newResponse2] = await teeResponse(response);
+    const responseJson = await newResponse2.json();
+    return [
+      responseJson,
+      newResponse1
+    ];
+  }
+  return [
+    null,
+    response
+  ];
+}, "getResponseJson");
+var teeResponse = /* @__PURE__ */ __name(async (response) => {
+  if (!response.body) {
+    return [
+      response,
+      response
+    ];
+  }
+  const [stream1, stream2] = response.body.tee();
+  const newResponse1 = new Response(stream1, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+  const newResponse2 = new Response(stream2, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+  return [
+    newResponse1,
+    newResponse2
+  ];
+}, "teeResponse");
+var extractZodErrors = /* @__PURE__ */ __name((responseJson) => {
+  const errors = [];
+  if (responseJson && responseJson.success === false && responseJson.error && responseJson.error.name === "ZodError") {
+    const zodError = responseJson.error;
+    zodError.issues.forEach((zodIssue) => {
+      errors.push({
+        loc: zodIssue.path.join("."),
+        msg: zodIssue.message,
+        type: zodIssue.code
+      });
+    });
+  }
+  return errors;
+}, "extractZodErrors");
+var getAppInfo = /* @__PURE__ */ __name((app, appVersion) => {
+  const versions = [];
+  if (process.versions.node) {
+    versions.push([
+      "nodejs",
+      process.versions.node
+    ]);
+  }
+  if (process.versions.bun) {
+    versions.push([
+      "bun",
+      process.versions.bun
+    ]);
+  }
+  const honoVersion = getPackageVersion("hono");
+  const apitallyVersion = getPackageVersion("../..");
+  if (honoVersion) {
+    versions.push([
+      "hono",
+      honoVersion
+    ]);
+  }
+  if (apitallyVersion) {
+    versions.push([
+      "apitally",
+      apitallyVersion
+    ]);
+  }
+  if (appVersion) {
+    versions.push([
+      "app",
+      appVersion
+    ]);
+  }
+  return {
+    paths: listEndpoints(app),
+    versions: Object.fromEntries(versions),
+    client: "js:hono"
+  };
+}, "getAppInfo");
+var listEndpoints = /* @__PURE__ */ __name((app) => {
+  const endpoints = [];
+  app.routes.forEach((route) => {
+    if (route.method !== "ALL" && !(0, import_handler.isMiddleware)(route.handler)) {
+      endpoints.push({
+        method: route.method.toUpperCase(),
+        path: route.path
+      });
+    }
+  });
+  return endpoints;
+}, "listEndpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useApitally
+});
+//# sourceMappingURL=index.cjs.map