apitally 0.25.8 → 1.0.0-beta.1

package/dist/common/requestLogger.d.cts

@@ -1,85 +0,0 @@
-import { Buffer } from 'node:buffer';
-import { IncomingHttpHeaders, OutgoingHttpHeaders } from 'node:http';
-import { SpanData } from './spanCollector.cjs';
-import { TempGzipFile } from './tempGzipFile.cjs';
-import '@opentelemetry/sdk-trace-base';
-
-type Request = {
-    timestamp: number;
-    method: string;
-    path?: string;
-    url: string;
-    headers: [string, string][];
-    size?: number;
-    consumer?: string;
-    body?: Buffer;
-};
-type Response = {
-    statusCode: number;
-    responseTime: number;
-    headers: [string, string][];
-    size?: number;
-    body?: Buffer;
-};
-type LogRecord = {
-    timestamp: number;
-    logger?: string;
-    level: string;
-    message: string;
-};
-type RequestLoggingConfig = {
-    enabled: boolean;
-    logQueryParams: boolean;
-    logRequestHeaders: boolean;
-    logRequestBody: boolean;
-    logResponseHeaders: boolean;
-    logResponseBody: boolean;
-    logException: boolean;
-    captureLogs: boolean;
-    captureTraces: boolean;
-    maskQueryParams: RegExp[];
-    maskHeaders: RegExp[];
-    maskBodyFields: RegExp[];
-    maskRequestBodyCallback?: (request: Request) => Buffer | null | undefined;
-    maskResponseBodyCallback?: (request: Request, response: Response) => Buffer | null | undefined;
-    excludePaths: RegExp[];
-    excludeCallback?: (request: Request, response: Response) => boolean;
-};
-declare class RequestLogger {
-    config: RequestLoggingConfig;
-    enabled: boolean;
-    suspendUntil: number | null;
-    private pendingWrites;
-    private currentFile;
-    private files;
-    private maintainIntervalId?;
-    private maintainInProgress;
-    private lock;
-    constructor(config?: Partial<RequestLoggingConfig>);
-    get maxBodySize(): number;
-    private shouldExcludePath;
-    private shouldExcludeUserAgent;
-    private shouldMaskQueryParam;
-    private shouldMaskHeader;
-    private shouldMaskBodyField;
-    private getContentType;
-    private hasSupportedContentType;
-    isSupportedContentType(contentType?: string | string[] | null): boolean;
-    private static isHttps;
-    private maskQueryParams;
-    private maskHeaders;
-    private maskBody;
-    private applyMasking;
-    logRequest(request: Request, response: Response, error?: Error, logs?: LogRecord[], spans?: SpanData[], traceId?: string): void;
-    writeToFile(): Promise<void>;
-    getFile(): TempGzipFile | undefined;
-    retryFileLater(file: TempGzipFile): void;
-    rotateFile(): Promise<void>;
-    maintain(): Promise<void>;
-    clear(): Promise<void>;
-    close(): Promise<void>;
-}
-declare function convertHeaders(headers: Headers | IncomingHttpHeaders | OutgoingHttpHeaders | Record<string, string | string[] | number | undefined> | undefined): [string, string][];
-declare function convertBody(body: any, contentType?: string | null): Buffer<any> | undefined;
-
-export { type LogRecord, type Request, RequestLogger, type RequestLoggingConfig, type Response, convertBody, convertHeaders, RequestLogger as default };

package/dist/common/requestLogger.d.ts

@@ -1,85 +0,0 @@
-import { Buffer } from 'node:buffer';
-import { IncomingHttpHeaders, OutgoingHttpHeaders } from 'node:http';
-import { SpanData } from './spanCollector.js';
-import { TempGzipFile } from './tempGzipFile.js';
-import '@opentelemetry/sdk-trace-base';
-
-type Request = {
-    timestamp: number;
-    method: string;
-    path?: string;
-    url: string;
-    headers: [string, string][];
-    size?: number;
-    consumer?: string;
-    body?: Buffer;
-};
-type Response = {
-    statusCode: number;
-    responseTime: number;
-    headers: [string, string][];
-    size?: number;
-    body?: Buffer;
-};
-type LogRecord = {
-    timestamp: number;
-    logger?: string;
-    level: string;
-    message: string;
-};
-type RequestLoggingConfig = {
-    enabled: boolean;
-    logQueryParams: boolean;
-    logRequestHeaders: boolean;
-    logRequestBody: boolean;
-    logResponseHeaders: boolean;
-    logResponseBody: boolean;
-    logException: boolean;
-    captureLogs: boolean;
-    captureTraces: boolean;
-    maskQueryParams: RegExp[];
-    maskHeaders: RegExp[];
-    maskBodyFields: RegExp[];
-    maskRequestBodyCallback?: (request: Request) => Buffer | null | undefined;
-    maskResponseBodyCallback?: (request: Request, response: Response) => Buffer | null | undefined;
-    excludePaths: RegExp[];
-    excludeCallback?: (request: Request, response: Response) => boolean;
-};
-declare class RequestLogger {
-    config: RequestLoggingConfig;
-    enabled: boolean;
-    suspendUntil: number | null;
-    private pendingWrites;
-    private currentFile;
-    private files;
-    private maintainIntervalId?;
-    private maintainInProgress;
-    private lock;
-    constructor(config?: Partial<RequestLoggingConfig>);
-    get maxBodySize(): number;
-    private shouldExcludePath;
-    private shouldExcludeUserAgent;
-    private shouldMaskQueryParam;
-    private shouldMaskHeader;
-    private shouldMaskBodyField;
-    private getContentType;
-    private hasSupportedContentType;
-    isSupportedContentType(contentType?: string | string[] | null): boolean;
-    private static isHttps;
-    private maskQueryParams;
-    private maskHeaders;
-    private maskBody;
-    private applyMasking;
-    logRequest(request: Request, response: Response, error?: Error, logs?: LogRecord[], spans?: SpanData[], traceId?: string): void;
-    writeToFile(): Promise<void>;
-    getFile(): TempGzipFile | undefined;
-    retryFileLater(file: TempGzipFile): void;
-    rotateFile(): Promise<void>;
-    maintain(): Promise<void>;
-    clear(): Promise<void>;
-    close(): Promise<void>;
-}
-declare function convertHeaders(headers: Headers | IncomingHttpHeaders | OutgoingHttpHeaders | Record<string, string | string[] | number | undefined> | undefined): [string, string][];
-declare function convertBody(body: any, contentType?: string | null): Buffer<any> | undefined;
-
-export { type LogRecord, type Request, RequestLogger, type RequestLoggingConfig, type Response, convertBody, convertHeaders, RequestLogger as default };

package/dist/common/requestLogger.js

@@ -1,508 +0,0 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import AsyncLock from "async-lock";
-import { Buffer as Buffer2 } from "node:buffer";
-import { randomUUID } from "node:crypto";
-import { getSentryEventId } from "./sentry.js";
-import { truncateExceptionMessage, truncateExceptionStackTrace } from "./serverErrorCounter.js";
-import { checkWritableFs, TempGzipFile } from "./tempGzipFile.js";
-const MAX_BODY_SIZE = 5e4;
-const MAX_FILE_SIZE = 1e6;
-const MAX_FILES = 50;
-const MAX_PENDING_WRITES = 100;
-const MAX_LOG_MSG_LENGTH = 2048;
-const BODY_TOO_LARGE = Buffer2.from("<body too large>");
-const BODY_MASKED = Buffer2.from("<masked>");
-const MASKED = "******";
-const ALLOWED_CONTENT_TYPES = [
-  "application/json",
-  "application/ld+json",
-  "application/problem+json",
-  "application/vnd.api+json",
-  "application/x-ndjson",
-  "text/plain",
-  "text/html"
-];
-const EXCLUDE_PATH_PATTERNS = [
-  /\/_?healthz?$/i,
-  /\/_?health[_-]?checks?$/i,
-  /\/_?heart[_-]?beats?$/i,
-  /\/ping$/i,
-  /\/ready$/i,
-  /\/live$/i,
-  /\/favicon(?:-[\w-]+)?\.(ico|png|svg)$/,
-  /\/apple-touch-icon(?:-[\w-]+)?\.png$/,
-  /\/robots\.txt$/,
-  /\/sitemap\.xml$/,
-  /\/manifest\.json$/,
-  /\/site\.webmanifest$/,
-  /\/service-worker\.js$/,
-  /\/sw\.js$/,
-  /\/\.well-known\//
-];
-const EXCLUDE_USER_AGENT_PATTERNS = [
-  /health[-_ ]?check/i,
-  /microsoft-azure-application-lb/i,
-  /googlehc/i,
-  /kube-probe/i
-];
-const MASK_QUERY_PARAM_PATTERNS = [
-  /auth/i,
-  /api-?key/i,
-  /secret/i,
-  /token/i,
-  /password/i,
-  /pwd/i
-];
-const MASK_HEADER_PATTERNS = [
-  /auth/i,
-  /api-?key/i,
-  /secret/i,
-  /token/i,
-  /cookie/i
-];
-const MASK_BODY_FIELD_PATTERNS = [
-  /password/i,
-  /pwd/i,
-  /token/i,
-  /secret/i,
-  /auth/i,
-  /card[-_ ]?number/i,
-  /ccv/i,
-  /ssn/i
-];
-const DEFAULT_CONFIG = {
-  enabled: false,
-  logQueryParams: true,
-  logRequestHeaders: false,
-  logRequestBody: false,
-  logResponseHeaders: true,
-  logResponseBody: false,
-  logException: true,
-  captureLogs: false,
-  captureTraces: false,
-  maskQueryParams: [],
-  maskHeaders: [],
-  maskBodyFields: [],
-  excludePaths: []
-};
-const _RequestLogger = class _RequestLogger {
-  config;
-  enabled;
-  suspendUntil = null;
-  pendingWrites = [];
-  currentFile = null;
-  files = [];
-  maintainIntervalId;
-  maintainInProgress = false;
-  lock = new AsyncLock();
-  constructor(config) {
-    this.config = {
-      ...DEFAULT_CONFIG,
-      ...config
-    };
-    this.enabled = this.config.enabled && checkWritableFs();
-    if (this.enabled) {
-      this.maintainIntervalId = setInterval(() => {
-        this.maintain().catch(() => {
-        });
-      }, 1e3);
-    }
-  }
-  get maxBodySize() {
-    return MAX_BODY_SIZE;
-  }
-  shouldExcludePath(urlPath) {
-    const patterns = [
-      ...this.config.excludePaths,
-      ...EXCLUDE_PATH_PATTERNS
-    ];
-    return matchPatterns(urlPath, patterns);
-  }
-  shouldExcludeUserAgent(userAgent) {
-    return userAgent ? matchPatterns(userAgent, EXCLUDE_USER_AGENT_PATTERNS) : false;
-  }
-  shouldMaskQueryParam(name) {
-    const patterns = [
-      ...this.config.maskQueryParams,
-      ...MASK_QUERY_PARAM_PATTERNS
-    ];
-    return matchPatterns(name, patterns);
-  }
-  shouldMaskHeader(name) {
-    const patterns = [
-      ...this.config.maskHeaders,
-      ...MASK_HEADER_PATTERNS
-    ];
-    return matchPatterns(name, patterns);
-  }
-  shouldMaskBodyField(name) {
-    const patterns = [
-      ...this.config.maskBodyFields,
-      ...MASK_BODY_FIELD_PATTERNS
-    ];
-    return matchPatterns(name, patterns);
-  }
-  getContentType(headers) {
-    var _a;
-    return (_a = headers.find(([k]) => k.toLowerCase() === "content-type")) == null ? void 0 : _a[1];
-  }
-  hasSupportedContentType(headers) {
-    const contentType = this.getContentType(headers);
-    return this.isSupportedContentType(contentType);
-  }
-  isSupportedContentType(contentType) {
-    if (Array.isArray(contentType) && contentType.length > 0) {
-      contentType = contentType[0];
-    }
-    return typeof contentType === "string" && ALLOWED_CONTENT_TYPES.some((t) => contentType.startsWith(t));
-  }
-  static isHttps(headers) {
-    return headers.some(([k, v]) => {
-      switch (k.toLowerCase()) {
-        case "x-forwarded-proto":
-        case "x-forwarded-protocol":
-        case "x-forwarded-scheme":
-        case "x-url-scheme":
-        case "x-scheme":
-          return v.split(",")[0].trim().toLowerCase() === "https";
-        case "front-end-https":
-        case "x-forwarded-ssl":
-          return v.toLowerCase() === "on";
-        case "forwarded":
-          return v.split(",")[0].trim().toLowerCase().includes("proto=https");
-        default:
-          return false;
-      }
-    });
-  }
-  maskQueryParams(search) {
-    const params = new URLSearchParams(search);
-    for (const [key] of params) {
-      if (this.shouldMaskQueryParam(key)) {
-        params.set(key, MASKED);
-      }
-    }
-    return params.toString();
-  }
-  maskHeaders(headers) {
-    return headers.map(([k, v]) => [
-      k,
-      this.shouldMaskHeader(k) ? MASKED : v
-    ]);
-  }
-  maskBody(data) {
-    if (typeof data === "object" && data !== null && !Array.isArray(data)) {
-      const result = {};
-      for (const [key, value] of Object.entries(data)) {
-        if (typeof value === "string" && this.shouldMaskBodyField(key)) {
-          result[key] = MASKED;
-        } else {
-          result[key] = this.maskBody(value);
-        }
-      }
-      return result;
-    }
-    if (Array.isArray(data)) {
-      return data.map((item) => this.maskBody(item));
-    }
-    return data;
-  }
-  applyMasking(item) {
-    if (this.config.maskRequestBodyCallback && item.request.body && item.request.body !== BODY_TOO_LARGE) {
-      try {
-        const maskedBody = this.config.maskRequestBodyCallback(item.request);
-        item.request.body = maskedBody ?? BODY_MASKED;
-      } catch {
-        item.request.body = void 0;
-      }
-    }
-    if (this.config.maskResponseBodyCallback && item.response.body && item.response.body !== BODY_TOO_LARGE) {
-      try {
-        const maskedBody = this.config.maskResponseBodyCallback(item.request, item.response);
-        item.response.body = maskedBody ?? BODY_MASKED;
-      } catch {
-        item.response.body = void 0;
-      }
-    }
-    if (item.request.body && item.request.body.length > MAX_BODY_SIZE) {
-      item.request.body = BODY_TOO_LARGE;
-    }
-    if (item.response.body && item.response.body.length > MAX_BODY_SIZE) {
-      item.response.body = BODY_TOO_LARGE;
-    }
-    for (const key of [
-      "request",
-      "response"
-    ]) {
-      const bodyData = item[key].body;
-      if (!bodyData || bodyData === BODY_TOO_LARGE || bodyData === BODY_MASKED) {
-        continue;
-      }
-      try {
-        const contentType = this.getContentType(item[key].headers);
-        if (!contentType || /\bjson\b/i.test(contentType)) {
-          const parsedBody = JSON.parse(bodyData.toString());
-          const maskedBody = this.maskBody(parsedBody);
-          item[key].body = Buffer2.from(JSON.stringify(maskedBody));
-        } else if (/\bndjson\b/i.test(contentType)) {
-          const lines = bodyData.toString().split("\n").filter((line) => line.trim());
-          const maskedLines = lines.map((line) => {
-            try {
-              const parsed = JSON.parse(line);
-              const masked = this.maskBody(parsed);
-              return JSON.stringify(masked);
-            } catch {
-              return line;
-            }
-          });
-          item[key].body = Buffer2.from(maskedLines.join("\n"));
-        }
-      } catch {
-      }
-    }
-    item.request.headers = this.config.logRequestHeaders ? this.maskHeaders(item.request.headers) : [];
-    item.response.headers = this.config.logResponseHeaders ? this.maskHeaders(item.response.headers) : [];
-    const url = new URL(item.request.url);
-    url.search = this.config.logQueryParams ? this.maskQueryParams(url.search) : "";
-    item.request.url = url.toString();
-    return item;
-  }
-  logRequest(request, response, error, logs, spans, traceId) {
-    var _a, _b, _c;
-    if (!this.enabled || this.suspendUntil !== null) return;
-    const url = new URL(request.url);
-    const path = request.path ?? url.pathname;
-    const userAgent = (_a = request.headers.find(([k]) => k.toLowerCase() === "user-agent")) == null ? void 0 : _a[1];
-    if (url.protocol === "http:" && _RequestLogger.isHttps(request.headers)) {
-      url.protocol = "https:";
-      request.url = url.toString();
-    }
-    if (this.shouldExcludePath(path) || this.shouldExcludeUserAgent(userAgent) || (((_c = (_b = this.config).excludeCallback) == null ? void 0 : _c.call(_b, request, response)) ?? false)) {
-      return;
-    }
-    if (!this.config.logRequestBody || !this.hasSupportedContentType(request.headers)) {
-      request.body = void 0;
-    }
-    if (!this.config.logResponseBody || !this.hasSupportedContentType(response.headers)) {
-      response.body = void 0;
-    }
-    if (request.size !== void 0 && request.size < 0) {
-      request.size = void 0;
-    }
-    if (response.size !== void 0 && response.size < 0) {
-      response.size = void 0;
-    }
-    const item = {
-      uuid: randomUUID(),
-      request,
-      response,
-      exception: error && this.config.logException ? {
-        type: error.name,
-        message: truncateExceptionMessage(error.message),
-        stacktrace: truncateExceptionStackTrace(error.stack || ""),
-        sentryEventId: getSentryEventId()
-      } : void 0
-    };
-    if (logs && logs.length > 0) {
-      item.logs = logs.map((log) => ({
-        timestamp: log.timestamp,
-        logger: log.logger,
-        level: log.level,
-        message: truncateLogMessage(log.message)
-      }));
-    }
-    if (spans && spans.length > 0) {
-      item.spans = spans;
-    }
-    if (traceId) {
-      item.traceId = traceId;
-    }
-    this.pendingWrites.push(item);
-    if (this.pendingWrites.length > MAX_PENDING_WRITES) {
-      this.pendingWrites.shift();
-    }
-  }
-  async writeToFile() {
-    if (!this.enabled || this.pendingWrites.length === 0) {
-      return;
-    }
-    return this.lock.acquire("file", async () => {
-      const items = this.pendingWrites;
-      this.pendingWrites = [];
-      if (items.length === 0) {
-        return;
-      }
-      if (!this.currentFile) {
-        this.currentFile = new TempGzipFile("request_logs");
-      }
-      const lines = [];
-      for (let item of items) {
-        item = this.applyMasking(item);
-        const finalItem = {
-          uuid: item.uuid,
-          request: skipEmptyValues(item.request),
-          response: skipEmptyValues(item.response),
-          exception: item.exception,
-          logs: item.logs,
-          spans: item.spans,
-          traceId: item.traceId
-        };
-        [
-          finalItem.request.body,
-          finalItem.response.body
-        ].forEach((body) => {
-          if (body) {
-            body.toJSON = function() {
-              return this.toString("base64");
-            };
-          }
-        });
-        lines.push(Buffer2.from(JSON.stringify(finalItem)));
-      }
-      await this.currentFile.writeLines(lines);
-    });
-  }
-  getFile() {
-    return this.files.shift();
-  }
-  retryFileLater(file) {
-    this.files.unshift(file);
-  }
-  async rotateFile() {
-    return this.lock.acquire("file", async () => {
-      if (this.currentFile) {
-        await this.currentFile.close();
-        this.files.push(this.currentFile);
-        this.currentFile = null;
-      }
-    });
-  }
-  async maintain() {
-    if (this.maintainInProgress) {
-      return;
-    }
-    this.maintainInProgress = true;
-    try {
-      await this.writeToFile();
-      if (this.currentFile && this.currentFile.size > MAX_FILE_SIZE) {
-        await this.rotateFile();
-      }
-      while (this.files.length > MAX_FILES) {
-        const file = this.files.shift();
-        file == null ? void 0 : file.delete();
-      }
-      if (this.suspendUntil !== null && this.suspendUntil < Date.now()) {
-        this.suspendUntil = null;
-      }
-    } finally {
-      this.maintainInProgress = false;
-    }
-  }
-  async clear() {
-    this.pendingWrites = [];
-    await this.rotateFile();
-    this.files.forEach((file) => {
-      file.delete();
-    });
-    this.files = [];
-  }
-  async close() {
-    this.enabled = false;
-    await this.clear();
-    if (this.maintainIntervalId) {
-      clearInterval(this.maintainIntervalId);
-    }
-  }
-};
-__name(_RequestLogger, "RequestLogger");
-let RequestLogger = _RequestLogger;
-function convertHeaders(headers) {
-  if (!headers) {
-    return [];
-  }
-  if (headers instanceof Headers) {
-    return Array.from(headers.entries());
-  }
-  return Object.entries(headers).flatMap(([key, value]) => {
-    if (value === void 0) {
-      return [];
-    }
-    if (Array.isArray(value)) {
-      return value.map((v) => [
-        key,
-        v
-      ]);
-    }
-    return [
-      [
-        key,
-        value.toString()
-      ]
-    ];
-  });
-}
-__name(convertHeaders, "convertHeaders");
-function convertBody(body, contentType) {
-  if (!body || !contentType) {
-    return;
-  }
-  try {
-    if (contentType.startsWith("application/json")) {
-      if (isValidJsonString(body)) {
-        return Buffer2.from(body);
-      } else {
-        return Buffer2.from(JSON.stringify(body));
-      }
-    }
-    if (contentType.startsWith("text/") && typeof body === "string") {
-      return Buffer2.from(body);
-    }
-  } catch (error) {
-    return;
-  }
-}
-__name(convertBody, "convertBody");
-function isValidJsonString(body) {
-  if (typeof body !== "string") {
-    return false;
-  }
-  try {
-    JSON.parse(body);
-    return true;
-  } catch {
-    return false;
-  }
-}
-__name(isValidJsonString, "isValidJsonString");
-function matchPatterns(value, patterns) {
-  return patterns.some((pattern) => {
-    return pattern.test(value);
-  });
-}
-__name(matchPatterns, "matchPatterns");
-function skipEmptyValues(data) {
-  return Object.fromEntries(Object.entries(data).filter(([_, v]) => {
-    if (v == null || Number.isNaN(v)) return false;
-    if (Array.isArray(v) || Buffer2.isBuffer(v) || typeof v === "string") {
-      return v.length > 0;
-    }
-    return true;
-  }));
-}
-__name(skipEmptyValues, "skipEmptyValues");
-function truncateLogMessage(msg) {
-  if (msg.length > MAX_LOG_MSG_LENGTH) {
-    const suffix = "... (truncated)";
-    return msg.slice(0, MAX_LOG_MSG_LENGTH - suffix.length) + suffix;
-  }
-  return msg;
-}
-__name(truncateLogMessage, "truncateLogMessage");
-export {
-  RequestLogger,
-  convertBody,
-  convertHeaders,
-  RequestLogger as default
-};
-//# sourceMappingURL=requestLogger.js.map