deepline 0.3.88 → 0.3.90

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

@@ -0,0 +1,73 @@
+import type { ProviderMonitorPostDeployGuidance } from '@deepline/monitors/provider-monitor-capability';
+
+// Client-safe provider setup metadata. Provider monitor definitions reference
+// these exact objects, while the integrations dialog reads them directly.
+export const VECTOR_POST_DEPLOY_GUIDANCE = {
+  title: 'Connect Vector to this monitor',
+  steps: [
+    'In Vector, open the segment named in this monitor setup.',
+    'Add a webhook endpoint using {{callback_url}}, then select contact.visited.',
+    'Enable the webhook action on the segment and send a Vector test event.',
+  ],
+  event_type: 'contact.visited',
+  documentation: [
+    {
+      label: 'Vector SiteID action integration guide',
+      url: 'https://learn.vector.co/articles/2260541690-building-an-action-integration-for-siteid',
+    },
+  ],
+  payload_example: {
+    type: 'contact.visited',
+    externalId: 'contact_123',
+    companyDomain: 'example.com',
+  },
+} as const satisfies ProviderMonitorPostDeployGuidance;
+
+export const RB2B_POST_DEPLOY_GUIDANCE = {
+  title: 'Connect RB2B to this monitor',
+  steps: [
+    'In RB2B, open Integrations and choose Webhook.',
+    'Paste {{callback_url}} as the single webhook URL and save.',
+    "Use RB2B's Send a Test Event action to verify the connection.",
+  ],
+  documentation: [
+    {
+      label: 'RB2B webhook setup guide',
+      url: 'https://support.rb2b.com/en/articles/8976614-setup-guide-webhook',
+    },
+  ],
+  payload_example: {
+    'LinkedIn URL': 'https://www.linkedin.com/in/example',
+    Website: 'https://example.com',
+  },
+} as const satisfies ProviderMonitorPostDeployGuidance;
+
+export const SNITCHER_POST_DEPLOY_GUIDANCE = {
+  title: 'Install Deepline Analytics',
+  steps: [
+    'Create the tracker code in Deepline, then paste it in your site’s document head.',
+    'Confirm cookie consent before persistent tracking when your privacy policy requires it.',
+  ],
+  documentation: [
+    {
+      label: 'Deepline Analytics setup guide',
+      url: 'https://docs.snitcher.com/powered-by-snitcher/radar/installation',
+    },
+  ],
+  payload_example: {
+    session_uuid: '00000000-0000-4000-8000-000000000001',
+    start_time: '2026-01-01T00:00:00.000Z',
+    last_activity: '2026-01-01T00:01:00.000Z',
+    engagement_time: 60,
+    user_properties: { $uuid: 'deepline-test-visitor' },
+    events: [
+      { event_name: '$pageview', created_at: '2026-01-01T00:00:00.000Z' },
+    ],
+  },
+} as const satisfies ProviderMonitorPostDeployGuidance;
+
+export const TRACKING_PROVIDER_POST_DEPLOY_GUIDANCE = {
+  vector: VECTOR_POST_DEPLOY_GUIDANCE,
+  rb2b: RB2B_POST_DEPLOY_GUIDANCE,
+  snitcher: SNITCHER_POST_DEPLOY_GUIDANCE,
+} as const;

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

@@ -0,0 +1,81 @@
+import { TRACKING_PROVIDER_POST_DEPLOY_GUIDANCE } from '@deepline/monitors/tracking-provider-guidance';
+import {
+  ANALYTICS_INTEGRATION_SLUG,
+  ANALYTICS_PUBLIC_TOOL,
+} from '@deepline/monitors/analytics-public';
+
+export const TRACKING_PROVIDER_INTEGRATIONS = {
+  vector: {
+    provider: 'vector',
+    displayName: 'Vector',
+    tool: 'vector.visitor_events',
+    monitorKey: 'vector-high-intent-visitors',
+  },
+  rb2b: {
+    provider: 'rb2b',
+    displayName: 'RB2B',
+    tool: 'rb2b.visitor_events',
+    monitorKey: 'rb2b-website-visitors',
+  },
+  [ANALYTICS_INTEGRATION_SLUG]: {
+    provider: 'snitcher',
+    displayName: 'Deepline Analytics',
+    // Used only by the server-side monitor adapter to resolve upstream wiring.
+    tool: 'snitcher.website_sessions',
+    publicTool: ANALYTICS_PUBLIC_TOOL,
+    monitorKey: 'snitcher-website-sessions',
+  },
+} as const;
+
+export type TrackingProviderIntegration =
+  (typeof TRACKING_PROVIDER_INTEGRATIONS)[keyof typeof TRACKING_PROVIDER_INTEGRATIONS] & {
+    docsUrl: string;
+    docsLabel: string;
+  };
+
+export function getTrackingProviderIntegration(
+  provider: string,
+): TrackingProviderIntegration | null {
+  const integration =
+    TRACKING_PROVIDER_INTEGRATIONS[
+      provider as keyof typeof TRACKING_PROVIDER_INTEGRATIONS
+    ];
+  if (!integration) return null;
+  const docs =
+    TRACKING_PROVIDER_POST_DEPLOY_GUIDANCE[
+      integration.provider as keyof typeof TRACKING_PROVIDER_POST_DEPLOY_GUIDANCE
+    ]?.documentation[0];
+  if (!docs) return null;
+  return { ...integration, docsUrl: docs.url, docsLabel: docs.label };
+}
+
+export function trackingProviderWebhookSetup(
+  provider: string,
+  webhookEndpoint: string,
+): {
+  webhook_endpoint: string;
+  event_type?: 'contact.visited';
+  instructions: string[];
+} | null {
+  const integration = getTrackingProviderIntegration(
+    provider === 'snitcher' ? ANALYTICS_INTEGRATION_SLUG : provider,
+  );
+  const guidance = integration
+    ? TRACKING_PROVIDER_POST_DEPLOY_GUIDANCE[
+        integration.provider as keyof typeof TRACKING_PROVIDER_POST_DEPLOY_GUIDANCE
+      ]
+    : null;
+  if (!guidance) return null;
+  return {
+    webhook_endpoint: webhookEndpoint,
+    ...('event_type' in guidance && guidance.event_type === 'contact.visited'
+      ? { event_type: guidance.event_type }
+      : {}),
+    // The dialog shows the URL in a dedicated copy target, so retain its
+    // compact `webhook_endpoint` wording while deriving every step from the
+    // same metadata used by CLI/API guidance.
+    instructions: guidance.steps.map((step) =>
+      step.replaceAll('{{callback_url}}', 'webhook_endpoint'),
+    ),
+  };
+}

package/dist/bundling-sources/shared_libs/monitors/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "incremental": false,
+    "noEmit": true,
+    "types": ["node"]
+  },
+  "include": ["./**/*.ts"],
+  "exclude": ["node_modules"]
+}

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