apitally/dist/hono/middleware.js

Simple API monitoring & analytics for REST APIs built with Express, Fastify, NestJS, AdonisJS, Hono, H3, Elysia, Hapi, and Koa.

var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
import { AsyncLocalStorage } from "node:async_hooks";
import { performance } from "node:perf_hooks";
import { ApitallyClient } from "../common/client.js";
import { consumerFromStringOrObject } from "../common/consumerRegistry.js";
import { parseContentLength } from "../common/headers.js";
import { convertHeaders } from "../common/requestLogger.js";
import { captureResponse, getResponseJson } from "../common/response.js";
import { patchConsole, patchWinston } from "../loggers/index.js";
import { extractZodErrors, getAppInfo } from "./utils.js";
function useApitally(app, config) {
  const client = new ApitallyClient(config);
  const middleware = getMiddleware(client);
  app.use(middleware);
  const setStartupData = /* @__PURE__ */ __name((attempt = 1) => {
    const appInfo = getAppInfo(app, config.appVersion);
    if (appInfo.paths.length > 0 || attempt >= 10) {
      client.setStartupData(appInfo);
      client.startSync();
    } else {
      setTimeout(() => setStartupData(attempt + 1), 500);
    }
  }, "setStartupData");
  setTimeout(() => setStartupData(), 500);
}
__name(useApitally, "useApitally");
function getMiddleware(client) {
  const logsContext = new AsyncLocalStorage();
  if (client.requestLogger.config.captureLogs) {
    patchConsole(logsContext);
    patchWinston(logsContext);
  }
  return async (c, next) => {
    if (!client.isEnabled() || c.req.method.toUpperCase() === "OPTIONS") {
      await next();
      return;
    }
    await logsContext.run([], async () => {
      const timestamp = Date.now() / 1e3;
      const startTime = performance.now();
      await next();
      const [newResponse, responsePromise] = captureResponse(c.res, {
        captureBody: client.requestLogger.enabled && client.requestLogger.config.logResponseBody && client.requestLogger.isSupportedContentType(c.res.headers.get("content-type")) || c.res.status === 400 && c.res.headers.get("content-type") === "application/json",
        maxBodySize: client.requestLogger.maxBodySize
      });
      c.res = newResponse;
      const statusCode = c.res.status;
      const responseHeaders = c.res.headers;
      responsePromise.then(async (capturedResponse) => {
        const responseTime = performance.now() - startTime;
        const requestSize = parseContentLength(c.req.header("content-length"));
        const responseSize = capturedResponse.completed ? capturedResponse.size : void 0;
        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,
          responseTime,
          requestSize,
          responseSize
        });
        if (statusCode === 400 && capturedResponse.body) {
          const responseJson = getResponseJson(capturedResponse.body);
          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
            });
          });
        }
        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 || ""
          });
        }
        if (client.requestLogger.enabled) {
          let requestBody;
          const responseBody = capturedResponse.body;
          const requestContentType = c.req.header("content-type");
          if (client.requestLogger.config.logRequestBody && client.requestLogger.isSupportedContentType(requestContentType)) {
            requestBody = Buffer.from(await c.req.arrayBuffer());
          }
          const logs = logsContext.getStore();
          client.requestLogger.logRequest({
            timestamp,
            method: c.req.method,
            path: c.req.routePath,
            url: c.req.url,
            headers: convertHeaders(c.req.header()),
            size: requestSize,
            consumer: consumer == null ? void 0 : consumer.identifier,
            body: requestBody
          }, {
            statusCode,
            responseTime: responseTime / 1e3,
            headers: convertHeaders(responseHeaders),
            size: responseSize,
            body: responseBody
          }, c.error, logs);
        }
      });
    });
  };
}
__name(getMiddleware, "getMiddleware");
function setConsumer(c, consumer) {
  c.set("apitallyConsumer", consumer || void 0);
}
__name(setConsumer, "setConsumer");
function getConsumer(c) {
  const consumer = c.get("apitallyConsumer");
  if (consumer) {
    return consumerFromStringOrObject(consumer);
  }
  return null;
}
__name(getConsumer, "getConsumer");
export {
  setConsumer,
  useApitally
};
//# sourceMappingURL=middleware.js.map