@obsunified/collector 2.0.1

package/src/lib/identity-index/types.ts

@@ -0,0 +1,196 @@
+import type { ActionConfidence } from "@obsunified/types/constants";
+
+export type CausalConfidence = ActionConfidence;
+
+export interface SpanRef {
+	traceId: string;
+	spanId: string;
+	parentSpanId: string | null;
+	serviceName: string | null;
+	spanName: string;
+	statusCode: number;
+	statusMessage: string | null;
+	startTime: string;
+	durationMs: number;
+	interactionId: string | null;
+}
+
+export interface LogRef {
+	logId: string;
+	traceId: string | null;
+	spanId: string | null;
+	serviceName: string | null;
+	loggerName: string | null;
+	severity: string;
+	message: string;
+	occurredAt: string;
+	interactionId: string | null;
+}
+
+export interface UsageEventRef {
+	eventId: string;
+	eventType: string;
+	eventName: string;
+	pagePath: string | null;
+	severity: string | null;
+	occurredAt: string;
+	interactionId: string | null;
+	sessionId: string | null;
+}
+
+export interface AICallRef {
+	callId: string;
+	traceId: string | null;
+	modelName: string;
+	provider: string;
+	totalCostUsd: number | null;
+	occurredAt: string;
+	interactionId: string | null;
+}
+
+export interface MetricExemplarRef {
+	id: string;
+	pointId: string;
+	seriesId: string;
+	metricName: string;
+	serviceName: string | null;
+	traceId: string | null;
+	spanId: string | null;
+	tsNs: string;
+	value: number;
+	receivedAt: string;
+}
+
+export interface ReplayRef {
+	sessionId: string;
+	firstChunkAt: string;
+	lastChunkAt: string;
+	chunkCount: number;
+	eventsCount: number;
+}
+
+export interface ReplayRow {
+	session_id: string;
+	first_chunk_at: string;
+	last_chunk_at: string;
+	chunk_count: number;
+	events_count: number;
+}
+
+export interface EntityManifest {
+	spans: SpanRef[];
+	logs: LogRef[];
+	usageEvents: UsageEventRef[];
+	aiCalls: AICallRef[];
+	metricExemplars: MetricExemplarRef[];
+	replay: ReplayRef | null;
+}
+
+export interface ActionRef {
+	id: string;
+	projectId: string;
+	rootActionId: string;
+	causedByActionId: string | null;
+	actorType: string;
+	actorId: string | null;
+	actionKind: string;
+	name: string | null;
+	status: string;
+	startedAt: string;
+	endedAt: string | null;
+	durationMs: number | null;
+	traceId: string | null;
+	spanId: string | null;
+	sessionId: string | null;
+	interactionId: string | null;
+	userId: string | null;
+	agentRunId: string | null;
+	stepId: string | null;
+	toolCallId: string | null;
+	promptVersion: string | null;
+	modelName: string | null;
+	provider: string | null;
+	totalCostUsd: number | null;
+	causalConfidence: CausalConfidence;
+	attrsJson: string | null;
+}
+
+export interface AgentRunRef {
+	id: string;
+	projectId: string;
+	agentId: string;
+	agentName: string;
+	agentVersion: string;
+	goal: string | null;
+	outcome: string | null;
+	autonomyLevel: string;
+	status: string;
+	errorMessage: string | null;
+	totalCostUsd: number | null;
+	totalDurationMs: number | null;
+	metadataJson: string | null;
+}
+
+export interface ToolCallRef {
+	id: string;
+	actionId: string;
+	projectId: string;
+	toolName: string;
+	argsHash: string;
+	resultHash: string;
+	errorType: string | null;
+	sideEffect: number;
+	approvalState: string | null;
+	argsRedacted: string | null;
+	resultRedacted: string | null;
+	mcpAuditJson: string | null;
+	mutationBeforeJson: string | null;
+	mutationAfterJson: string | null;
+	mutationDiffJson: string | null;
+	mutationArtifactId: string | null;
+}
+
+export interface RetrievalEventRef {
+	id: string;
+	actionId: string;
+	projectId: string;
+	retrieverName: string;
+	queryHash: string;
+	documentsJson: string | null;
+	totalResults: number;
+	maxRelevanceScore: number | null;
+	durationMs: number | null;
+}
+
+export interface EvalResultRef {
+	id: string;
+	actionId: string;
+	projectId: string;
+	evaluatorName: string;
+	evaluatorVersion: string;
+	score: number | null;
+	passed: number;
+	reasoning: string | null;
+	rubricJson: string | null;
+}
+
+export interface ArtifactRef {
+	id: string;
+	actionId: string;
+	projectId: string;
+	artifactName: string;
+	artifactType: string;
+	storageRef: string | null;
+	sizeBytes: number | null;
+	sha256Hash: string | null;
+	contentPreview: string | null;
+}
+
+export interface EntityManifestExtended extends EntityManifest {
+	actions: ActionRef[];
+	agentRuns: AgentRunRef[];
+	toolCalls: ToolCallRef[];
+	retrievalEvents: RetrievalEventRef[];
+	evalResults: EvalResultRef[];
+	artifacts: ArtifactRef[];
+}

package/src/lib/identity-index/user-lookup.ts

@@ -0,0 +1,137 @@
+import type { SqlDb } from "../sql-db";
+import { FETCH_LIMIT } from "./constants";
+import { mapAi, mapLog, mapSpan, mapUsage } from "./mappers";
+import type { EntityManifest } from "./types";
+
+export async function manifestByUser(
+	db: SqlDb,
+	projectId: string,
+	userId: string,
+	opts: { limit?: number; sessions?: number } = {},
+): Promise<EntityManifest> {
+	const limit = Math.min(opts.limit ?? 100, FETCH_LIMIT);
+	const sessionLimit = Math.max(1, Math.min(opts.sessions ?? 5, 20));
+
+	// Step 1 — resolve user_id → visitor_id. user_profiles is the only
+	// table that owns the user_id ↔ visitor_id binding.
+	const profile = await db
+		.prepare(`SELECT visitor_id FROM user_profiles WHERE user_id = ? LIMIT 1`)
+		.bind(userId)
+		.first<{ visitor_id: string }>();
+	if (!profile) {
+		return {
+			spans: [],
+			logs: [],
+			usageEvents: [],
+			aiCalls: [],
+			metricExemplars: [],
+			replay: null,
+		};
+	}
+
+	// Step 2 — recent session_ids for that visitor. Pull from usage_events
+	// (the table that always carries visitor_id; ai_span_payloads has
+	// user_id directly but only when present in AI traffic).
+	const sessions = await db
+		.prepare(
+			`SELECT DISTINCT session_id, MAX(occurred_at) AS last_at
+				FROM usage_events
+				WHERE project_id = ? AND visitor_id = ? AND session_id IS NOT NULL
+				GROUP BY session_id
+				ORDER BY last_at DESC
+				LIMIT ?`,
+		)
+		.bind(projectId, profile.visitor_id, sessionLimit)
+		.all<{ session_id: string; last_at: string }>();
+	const sessionIds = sessions.results.map((r) => r.session_id);
+	if (sessionIds.length === 0) {
+		return {
+			spans: [],
+			logs: [],
+			usageEvents: [],
+			aiCalls: [],
+			metricExemplars: [],
+			replay: null,
+		};
+	}
+
+	// Step 3 — fan out to each signal table with IN (?, ?, …). D1 caps
+	// bound parameters at 100, so the sessionLimit clamp above (≤20)
+	// keeps us well under.
+	const placeholders = sessionIds.map(() => "?").join(", ");
+	const [spans, logs, usage, aiCalls, replay] = await Promise.all([
+		db
+			.prepare(
+				`SELECT trace_id, span_id, parent_span_id, service_name, span_name,
+						status_code, status_message, start_time, duration_ms, interaction_id
+					FROM telemetry_spans
+					WHERE project_id = ? AND session_id IN (${placeholders})
+					ORDER BY start_time DESC LIMIT ?`,
+			)
+			.bind(projectId, ...sessionIds, limit)
+			.all<Parameters<typeof mapSpan>[0]>(),
+		db
+			.prepare(
+				`SELECT log_id, trace_id, span_id, service_name, logger_name,
+						severity, message, occurred_at, interaction_id, session_id
+					FROM logs
+					WHERE project_id = ? AND session_id IN (${placeholders})
+					ORDER BY occurred_at DESC LIMIT ?`,
+			)
+			.bind(projectId, ...sessionIds, limit)
+			.all<Parameters<typeof mapLog>[0]>(),
+		db
+			.prepare(
+				`SELECT event_id, event_type, event_name, page_path, severity,
+						occurred_at, interaction_id, session_id
+					FROM usage_events
+					WHERE project_id = ? AND session_id IN (${placeholders})
+					ORDER BY occurred_at DESC LIMIT ?`,
+			)
+			.bind(projectId, ...sessionIds, limit)
+			.all<Parameters<typeof mapUsage>[0]>(),
+		db
+			.prepare(
+				`SELECT call_id, trace_id, model_name, provider, total_cost_usd,
+						occurred_at, interaction_id, session_id
+					FROM ai_calls
+					WHERE project_id = ? AND session_id IN (${placeholders})
+					ORDER BY occurred_at DESC LIMIT ?`,
+			)
+			.bind(projectId, ...sessionIds, limit)
+			.all<Parameters<typeof mapAi>[0]>(),
+		// Most recent replay across the user's sessions, if any.
+		db
+			.prepare(
+				`SELECT session_id, first_chunk_at, last_chunk_at, chunk_count, events_count
+					FROM session_replay_metadata
+					WHERE session_id IN (${placeholders})
+					ORDER BY last_chunk_at DESC LIMIT 1`,
+			)
+			.bind(...sessionIds)
+			.first<{
+				session_id: string;
+				first_chunk_at: string;
+				last_chunk_at: string;
+				chunk_count: number;
+				events_count: number;
+			}>(),
+	]);
+
+	return {
+		spans: spans.results.map(mapSpan),
+		logs: logs.results.map(mapLog),
+		usageEvents: usage.results.map(mapUsage),
+		aiCalls: aiCalls.results.map(mapAi),
+		metricExemplars: [],
+		replay: replay
+			? {
+					sessionId: replay.session_id,
+					firstChunkAt: replay.first_chunk_at,
+					lastChunkAt: replay.last_chunk_at,
+					chunkCount: replay.chunk_count,
+					eventsCount: replay.events_count,
+				}
+			: null,
+	};
+}