deepline 0.3.89 → 0.3.91

package/dist/bundling-sources/shared_libs/monitors/signal-radars/inbound-queue-ack-probe.ts

@@ -0,0 +1,94 @@
+import { getVercelOidcToken } from '@vercel/oidc';
+
+import { SIGNAL_RADAR_INBOUND_TOPIC } from '@deepline/monitors/signal-radars/inbound-queue';
+
+// Must match the function key in apps/deepline-api/vercel.json. Vercel Queue's push-trigger
+// adapter derives the consumer group from this path. Deriving rather than
+// copying the encoded value makes the transformation reviewable and testable.
+export const SIGNAL_RADAR_INBOUND_TRIGGER_PATH =
+  'src/app/api/queues/signal-radar-inbound/route.ts';
+
+const DEEPLINE_API_PROJECT_ROOT = 'apps/deepline-api/';
+
+export function vercelQueueConsumerGroupForFunctionPath(functionPath: string) {
+  return functionPath
+    .replaceAll('_', '__')
+    .replaceAll('/', '_S')
+    .replaceAll('.', '_D');
+}
+
+export const SIGNAL_RADAR_INBOUND_CONSUMER_GROUP =
+  vercelQueueConsumerGroupForFunctionPath(
+    SIGNAL_RADAR_INBOUND_TRIGGER_PATH.replace(DEEPLINE_API_PROJECT_ROOT, ''),
+  );
+
+export type SignalRadarInboundQueueMessageState =
+  | 'acknowledged'
+  | 'available'
+  | 'in_flight'
+  | 'not_found';
+
+type ProbeDependencies = {
+  fetch?: typeof fetch;
+  getOidcToken?: () => Promise<string>;
+};
+
+type ProbeInput = {
+  messageId: string;
+  region: string | undefined;
+  deploymentId: string | undefined;
+};
+
+function requiredRuntimeValue(name: string, value: string | undefined) {
+  if (value?.trim()) return value.trim();
+  throw new Error(
+    `${name} is required for the Vercel Queue acknowledgement probe.`,
+  );
+}
+
+/**
+ * Peeks at the exact message in Vercel's push-consumer group without leasing,
+ * acknowledging, or otherwise changing it. A 410 is the direct proof that
+ * the consumer successfully acknowledged this message.
+ */
+export async function signalRadarInboundQueueMessageState(
+  input: ProbeInput,
+  dependencies: ProbeDependencies = {},
+): Promise<SignalRadarInboundQueueMessageState> {
+  const region = requiredRuntimeValue('VERCEL_REGION', input.region);
+  const deploymentId = requiredRuntimeValue(
+    'VERCEL_DEPLOYMENT_ID',
+    input.deploymentId,
+  );
+  const requestFetch = dependencies.fetch ?? fetch;
+  const getToken = dependencies.getOidcToken ?? getVercelOidcToken;
+  const response = await requestFetch(
+    `https://${region}.vercel-queue.com/api/v3/topic/${encodeURIComponent(
+      SIGNAL_RADAR_INBOUND_TOPIC,
+    )}/consumer/${encodeURIComponent(
+      SIGNAL_RADAR_INBOUND_CONSUMER_GROUP,
+    )}/id/${encodeURIComponent(input.messageId)}`,
+    {
+      method: 'POST',
+      headers: {
+        authorization: `Bearer ${await getToken()}`,
+        accept: 'multipart/mixed',
+        // Vercel documents zero as a non-leasing peek. This probe must never
+        // become a competing consumer or acknowledge an unprocessed message.
+        'vqs-visibility-timeout-seconds': '0',
+        'vqs-deployment-id': deploymentId,
+      },
+    },
+  );
+
+  if (response.status === 410) return 'acknowledged';
+  if (response.status === 409) return 'in_flight';
+  if (response.status === 404) return 'not_found';
+  if (response.status === 200) return 'available';
+
+  throw new Error(
+    `Vercel Queue acknowledgement probe failed with HTTP ${response.status}: ${(
+      await response.text()
+    ).slice(0, 500)}`,
+  );
+}

package/dist/bundling-sources/shared_libs/monitors/signal-radars/inbound-queue-delivery.ts

@@ -0,0 +1,60 @@
+import {
+  classifyInboundFailure,
+  inboundBackoffSeconds,
+} from '@deepline/monitors/signal-radars/inbound-dead-letter';
+import type { SignalRadarInboundMessage } from '@deepline/monitors/signal-radars/inbound-message';
+
+export class SignalRadarInboundDeliveryError extends Error {
+  readonly cause_error: unknown;
+
+  constructor(cause: unknown) {
+    super(cause instanceof Error ? cause.message : String(cause));
+    this.name = 'SignalRadarInboundDeliveryError';
+    this.cause_error = cause;
+  }
+}
+
+export async function handleSignalRadarInboundDelivery(input: {
+  message: SignalRadarInboundMessage;
+  metadata: { deliveryCount: number; messageId?: string };
+  maxDeliveries: number;
+  runWorker: (
+    message: SignalRadarInboundMessage,
+    metadata: { deliveryCount: number; messageId?: string },
+  ) => Promise<unknown>;
+  recordDeadLetter: (input: {
+    message: SignalRadarInboundMessage;
+    error: unknown;
+    deliveryCount: number;
+  }) => Promise<void>;
+}) {
+  try {
+    await input.runWorker(input.message, input.metadata);
+  } catch (error) {
+    if (
+      classifyInboundFailure(error) === 'permanent' &&
+      input.metadata.deliveryCount > input.maxDeliveries
+    ) {
+      try {
+        await input.recordDeadLetter({
+          message: input.message,
+          error,
+          deliveryCount: input.metadata.deliveryCount,
+        });
+        return;
+      } catch (recordError) {
+        throw new SignalRadarInboundDeliveryError(recordError);
+      }
+    }
+    throw new SignalRadarInboundDeliveryError(error);
+  }
+}
+
+export function signalRadarInboundRetry(input: {
+  error: unknown;
+  deliveryCount: number;
+}) {
+  // This function intentionally does no I/O. Vercel's retry callback is
+  // synchronous; terminal persistence belongs in the awaited handler above.
+  return { afterSeconds: inboundBackoffSeconds(input.deliveryCount) };
+}

package/dist/bundling-sources/shared_libs/monitors/signal-radars/inbound-queue.ts

@@ -0,0 +1,60 @@
+import { send as vercelQueueSend } from '@vercel/queue';
+import type { SignalRadarInboundMessage } from '@deepline/monitors/signal-radars/inbound-message';
+import { isTestOnlyRuntime } from '../../play-runtime/runtime-env';
+
+// Durable Vercel Queues front-queue for Monitor inbound webhook events.
+// The receiver produces onto this topic (auth -> enqueue -> 200); the air-gapped
+// worker at apps/deepline-api/src/app/api/queues/signal-radar-inbound/route.ts consumes it and runs
+// the full ingestion machinery. See docs/provider-monitor-playbook.md.
+export const SIGNAL_RADAR_INBOUND_TOPIC = 'signal-radar-inbound';
+
+// Retention set to the Vercel Queues maximum (7 days). This is the ceiling on
+// the worst Neon/Convex outage the buffer can survive: while downstream is down,
+// the receiver still returns 200 and the message sits here, redelivering until it
+// drains or expires. Sized to exceed any tolerable Neon outage window.
+export const SIGNAL_RADAR_INBOUND_RETENTION_SECONDS = 604_800;
+
+export type SignalRadarInboundSendOptions = {
+  idempotencyKey?: string;
+  /**
+   * Test-runtime delivery driver. The public receiver may set this only after
+   * proving the request is synthetic and test-authorized. It exercises the
+   * same queue worker locally, where Vercel Queues cannot mint its OIDC token.
+   */
+  inlineTestWorker?: boolean;
+  runInlineTestWorker?: (message: SignalRadarInboundMessage) => Promise<unknown>;
+};
+
+// Publish onto the inbound topic. `idempotencyKey` is the Neon-free provider
+// event key (belt-and-suspenders publish-side dedupe within the message TTL;
+// the real guarantee is the worker's consumer-side dedupe on the same grain).
+export async function send(
+  message: SignalRadarInboundMessage,
+  options?: SignalRadarInboundSendOptions,
+) {
+  if (options?.inlineTestWorker) {
+    if (!isTestOnlyRuntime()) {
+      throw new Error(
+        'The synthetic inbound queue driver is unavailable outside a test runtime.',
+      );
+    }
+    // The owning app supplies its real worker; packages cannot import app routes.
+    if (!options.runInlineTestWorker) {
+      throw new Error('The synthetic inbound queue driver requires an app worker.');
+    }
+    const result = await options.runInlineTestWorker(message);
+    return {
+      messageId: `test-inline:${options.idempotencyKey ?? crypto.randomUUID()}`,
+      // The test-only driver executes Tier 2 synchronously. Preserve its
+      // outcome for the synthetic receiver so a Gauntlet can assert a billing
+      // suspension without changing the real provider-facing queue contract.
+      result,
+    };
+  }
+  return vercelQueueSend(SIGNAL_RADAR_INBOUND_TOPIC, message, {
+    retentionSeconds: SIGNAL_RADAR_INBOUND_RETENTION_SECONDS,
+    ...(options?.idempotencyKey
+      ? { idempotencyKey: options.idempotencyKey }
+      : {}),
+  });
+}

package/dist/bundling-sources/shared_libs/monitors/snitcher-install-validation.ts

@@ -1,6 +1,6 @@
 import { lookup } from 'node:dns/promises';
 import { isIP } from 'node:net';
-import { DEEPLINE_ANALYTICS_BROWSER_OBJECT } from '@/lib/analytics/public';
+import { DEEPLINE_ANALYTICS_BROWSER_OBJECT } from '@deepline/monitors/analytics-public';
 
 export type SnitcherInstallationCheck = {
   domain: string;

package/dist/bundling-sources/shared_libs/monitors/snitcher-ip2company.ts

@@ -1,8 +1,8 @@
 import { createHmac, randomUUID } from 'node:crypto';
 import { isIP } from 'node:net';
-import { internal } from '@convex/_generated/api';
+import { internal } from '@deepline/convex-client/function-references';
 import { hasSnitcherSessionIdentity } from '@deepline/ingestion-v2/snitcher-session-identity';
-import { getRequiredInternalConvexClient } from '@/lib/convex/internal-client';
+import { getRequiredInternalConvexClient } from '@deepline/convex-client/internal-client';
 
 export { hasSnitcherSessionIdentity };
 

package/dist/bundling-sources/shared_libs/monitors/snitcher-radar.ts

@@ -1,5 +1,5 @@
 import { buildProviderWebhookCallbackUrl } from '@deepline/monitors/provider-webhook-monitor-runtime';
-import { DEEPLINE_ANALYTICS_BROWSER_OBJECT } from '@/lib/analytics/public';
+import { DEEPLINE_ANALYTICS_BROWSER_OBJECT } from '@deepline/monitors/analytics-public';
 
 const SNITCHER_RADAR_API_URL = 'https://api.snitcher.com/radar/operator/v1';
 const SNITCHER_INTERNAL_IDENTIFIER_PREFIX = 'dlr1_';

package/dist/bundling-sources/shared_libs/monitors/tracking-provider-integrations.ts

@@ -2,7 +2,7 @@ import { TRACKING_PROVIDER_POST_DEPLOY_GUIDANCE } from '@deepline/monitors/track
 import {
   ANALYTICS_INTEGRATION_SLUG,
   ANALYTICS_PUBLIC_TOOL,
-} from '@/lib/analytics/public';
+} from '@deepline/monitors/analytics-public';
 
 export const TRACKING_PROVIDER_INTEGRATIONS = {
   vector: {

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

@@ -0,0 +1,13 @@
+/**
+ * True while running inside a production build — Vercel/CI `next build` (where
+ * `CI=1`) and the prebuilt-artifact scripts, plus the prerender phase (where
+ * `NEXT_PHASE` is set). Use it to silence high-volume per-operation diagnostics
+ * that flood the build log with no build-time signal; they still emit at runtime
+ * and in local dev for Axiom/perf debugging.
+ */
+export function isBuildContext(): boolean {
+  return (
+    process.env.CI === '1' ||
+    process.env.NEXT_PHASE === 'phase-production-build'
+  );
+}

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 ?? {}),
+  };
+}