deepline 0.3.89 → 0.3.90

package/dist/bundling-sources/shared_libs/observability/log-metadata.ts

@@ -0,0 +1,160 @@
+import 'server-only';
+
+import { workUnitAsyncStorage } from 'next/dist/server/app-render/work-unit-async-storage.external';
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+export type LogMetadata = Record<string, unknown>;
+
+type RequestStoreLike = {
+  headers?: unknown;
+  url?: { pathname?: string; search?: string };
+};
+
+const storage = new AsyncLocalStorage<LogMetadata>();
+const CONSOLE_METHODS = ['log', 'info', 'warn', 'error', 'debug'] as const;
+const LOG_REQUEST_ID_HEADER = 'x-deepline-request-id';
+const LOG_REQUEST_PATH_HEADER = 'x-deepline-request-path';
+const LOG_REQUEST_METHOD_HEADER = 'x-deepline-request-method';
+
+let isPatched = false;
+
+function isPlainRecord(value: unknown): value is Record<string, unknown> {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+function normalizeText(value: string | null | undefined): string | null {
+  if (!value) return null;
+  const trimmed = String(value).trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function safeHeaderValue(container: unknown, key: string): string | null {
+  if (!container || typeof container !== 'object') return null;
+  if (
+    'then' in (container as Record<string, unknown>) &&
+    typeof (container as { then: unknown }).then === 'function'
+  ) {
+    return null;
+  }
+  const getter = (container as { get?: (name: string) => unknown }).get;
+  if (typeof getter !== 'function') return null;
+  try {
+    const value = getter.call(container, key);
+    return normalizeText(typeof value === 'string' ? value : null);
+  } catch {
+    return null;
+  }
+}
+
+function getRequestStoreFromNext(): unknown {
+  try {
+    return workUnitAsyncStorage.getStore?.() as unknown;
+  } catch {
+    return null;
+  }
+}
+
+function getRequestMetadataFromHeaders(): Record<string, string> | null {
+  const requestStore = getRequestStoreFromNext() as RequestStoreLike | null;
+  if (!requestStore?.headers) return null;
+
+  const requestHeaders = requestStore.headers;
+  const requestId = normalizeText(
+    safeHeaderValue(requestHeaders, LOG_REQUEST_ID_HEADER) ??
+      safeHeaderValue(requestHeaders, 'x-vercel-id') ??
+      safeHeaderValue(requestHeaders, 'x-request-id'),
+  );
+  const requestPath =
+    normalizeText(safeHeaderValue(requestHeaders, LOG_REQUEST_PATH_HEADER)) ??
+    ((): string | null => {
+      const pathFromStore =
+        requestStore.url &&
+        typeof requestStore.url === 'object' &&
+        'pathname' in requestStore.url
+          ? String(requestStore.url.pathname ?? '').trim()
+          : '';
+      return normalizeText(pathFromStore);
+    })();
+  const requestMethod =
+    normalizeText(safeHeaderValue(requestHeaders, LOG_REQUEST_METHOD_HEADER)) ??
+    null;
+  const vercelRequestId = normalizeText(
+    safeHeaderValue(requestHeaders, 'x-vercel-id'),
+  );
+
+  if (!requestId && !requestPath && !requestMethod && !vercelRequestId) {
+    return null;
+  }
+
+  const metadata: Record<string, string> = {};
+  if (requestId) {
+    metadata.request_id = requestId;
+    metadata.requestId = requestId;
+  }
+  if (requestPath) metadata.request_path = requestPath;
+  if (requestMethod) metadata.request_method = requestMethod;
+  if (vercelRequestId) {
+    metadata.vercel_request_id = vercelRequestId;
+    metadata.vercelRequestId = vercelRequestId;
+  }
+  return metadata;
+}
+
+function getActiveLogMetadata(): LogMetadata {
+  const contextMetadata = storage.getStore();
+  const requestMetadata = getRequestMetadataFromHeaders();
+
+  if (!contextMetadata && requestMetadata) return requestMetadata;
+  if (!requestMetadata) return contextMetadata ?? {};
+  return { ...requestMetadata, ...contextMetadata };
+}
+
+function mergeLogArgs(args: unknown[], metadata: LogMetadata): unknown[] {
+  if (args.length === 0) return [metadata];
+  const last = args[args.length - 1];
+  if (isPlainRecord(last)) {
+    return [...args.slice(0, -1), { ...metadata, ...last }];
+  }
+  return [...args, metadata];
+}
+
+function patchConsoleWithMetadata(): void {
+  if (isPatched) return;
+  isPatched = true;
+  const consoleRef = console as unknown as Record<
+    (typeof CONSOLE_METHODS)[number],
+    (...args: unknown[]) => void
+  >;
+
+  for (const method of CONSOLE_METHODS) {
+    const original = consoleRef[method].bind(console);
+    consoleRef[method] = ((...args: unknown[]) => {
+      const metadata = getActiveLogMetadata();
+      if (!metadata || Object.keys(metadata).length === 0) {
+        original(...args);
+        return;
+      }
+      original(...mergeLogArgs(args, metadata));
+    }) as (...args: unknown[]) => void;
+  }
+}
+
+export function setLogMetadata(metadata: LogMetadata): void {
+  patchConsoleWithMetadata();
+  const current = storage.getStore() ?? {};
+  storage.enterWith({ ...current, ...metadata });
+}
+
+export function withLogMetadata<T>(metadata: LogMetadata, fn: () => T): T {
+  patchConsoleWithMetadata();
+  const current = storage.getStore() ?? {};
+  return storage.run({ ...current, ...metadata }, fn);
+}
+
+export function getCurrentRequestMetadata(): LogMetadata {
+  return getActiveLogMetadata();
+}
+
+patchConsoleWithMetadata();

package/dist/bundling-sources/shared_libs/observability/request-context.ts

@@ -0,0 +1,68 @@
+import { randomUUID } from 'node:crypto';
+
+const REQUEST_ID_PREFIX = 'req_';
+
+export type RequestLogMetadata = Record<string, unknown>;
+
+export type RequestLike = {
+  method: string;
+  headers: { get(name: string): string | null };
+  nextUrl?: { pathname: string };
+  url?: string;
+};
+
+function normalizeText(value: string | null | undefined): string | null {
+  if (!value) return null;
+  const trimmed = String(value).trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function resolveRequestPath(req: RequestLike): string {
+  if (req.nextUrl?.pathname) return req.nextUrl.pathname;
+  if (req.url) {
+    try {
+      return new URL(req.url).pathname;
+    } catch {
+      return String(req.url);
+    }
+  }
+  return '(unknown)';
+}
+
+function resolveRequestId(
+  req: RequestLike,
+  requestId: string | null | undefined,
+): string {
+  const explicit = normalizeText(requestId);
+  if (explicit) return explicit;
+  const vercelRequestId = normalizeText(req.headers.get('x-vercel-id'));
+  if (vercelRequestId) return vercelRequestId;
+  return `${REQUEST_ID_PREFIX}${randomUUID().replace(/-/g, '').slice(0, 12)}`;
+}
+
+export function buildRequestLogMetadata(
+  req: RequestLike,
+  input: {
+    requestId?: string | null;
+    requestPath?: string | null;
+    requestMethod?: string | null;
+    extraMetadata?: RequestLogMetadata;
+  } = {},
+): RequestLogMetadata {
+  const resolvedRequestId = resolveRequestId(req, input.requestId);
+  const vercelRequestId = normalizeText(req.headers.get('x-vercel-id'));
+  const resolvedRequestPath =
+    normalizeText(input.requestPath) ?? resolveRequestPath(req);
+  const resolvedRequestMethod =
+    normalizeText(input.requestMethod) ?? req.method.toUpperCase();
+
+  return {
+    request_id: resolvedRequestId,
+    requestId: resolvedRequestId,
+    request_path: resolvedRequestPath,
+    request_method: resolvedRequestMethod,
+    ...(vercelRequestId ? { vercel_request_id: vercelRequestId } : {}),
+    ...(vercelRequestId ? { vercelRequestId } : {}),
+    ...(input.extraMetadata ?? {}),
+  };
+}