apitally
Version:
Simple API monitoring & analytics for REST APIs built with Express, Fastify, NestJS, AdonisJS, Hono, H3, Elysia, Hapi, and Koa.
157 lines • 6.57 kB
JavaScript
;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var middleware_exports = {};
__export(middleware_exports, {
setConsumer: () => setConsumer,
useApitally: () => useApitally
});
module.exports = __toCommonJS(middleware_exports);
var import_node_async_hooks = require("node:async_hooks");
var import_node_perf_hooks = require("node:perf_hooks");
var import_client = require("../common/client.js");
var import_consumerRegistry = require("../common/consumerRegistry.js");
var import_headers = require("../common/headers.js");
var import_requestLogger = require("../common/requestLogger.js");
var import_response = require("../common/response.js");
var import_loggers = require("../loggers/index.js");
var import_utils = require("./utils.js");
function useApitally(app, config) {
const client = new import_client.ApitallyClient(config);
const middleware = getMiddleware(client);
app.use(middleware);
const setStartupData = /* @__PURE__ */ __name((attempt = 1) => {
const appInfo = (0, import_utils.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 import_node_async_hooks.AsyncLocalStorage();
if (client.requestLogger.config.captureLogs) {
(0, import_loggers.patchConsole)(logsContext);
(0, import_loggers.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 = import_node_perf_hooks.performance.now();
await next();
const [newResponse, responsePromise] = (0, import_response.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 = import_node_perf_hooks.performance.now() - startTime;
const requestSize = (0, import_headers.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 = (0, import_response.getResponseJson)(capturedResponse.body);
const validationErrors = (0, import_utils.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: (0, import_requestLogger.convertHeaders)(c.req.header()),
size: requestSize,
consumer: consumer == null ? void 0 : consumer.identifier,
body: requestBody
}, {
statusCode,
responseTime: responseTime / 1e3,
headers: (0, import_requestLogger.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 (0, import_consumerRegistry.consumerFromStringOrObject)(consumer);
}
return null;
}
__name(getConsumer, "getConsumer");
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
setConsumer,
useApitally
});
//# sourceMappingURL=middleware.cjs.map