promptfoo 0.120.26 → 0.121.1

package/dist/src/store-Ub2vaGJ1.js

@@ -0,0 +1,228 @@
+import { t as __exportAll } from "./chunk-DEq-mXcV.js";
+import { i as logger } from "./logger-DLcq4dWf.js";
+import { f as spansTable, h as getDb, m as tracesTable } from "./tables-xKANLRBD.js";
+import { asc, eq, lt } from "drizzle-orm";
+//#region src/tracing/store.ts
+var store_exports = /* @__PURE__ */ __exportAll({
+	TraceStore: () => TraceStore,
+	getTraceStore: () => getTraceStore
+});
+const SENSITIVE_ATTRIBUTE_KEYS = [
+	"authorization",
+	"cookie",
+	"set-cookie",
+	"token",
+	"api_key",
+	"apikey",
+	"secret",
+	"password",
+	"passphrase"
+];
+function sanitizeAttributes(attributes) {
+	if (!attributes) return {};
+	const sanitizeValue = (value) => {
+		if (typeof value === "string") return value.length > 400 ? `${value.slice(0, 400)}…` : value;
+		if (Array.isArray(value)) return value.map(sanitizeValue);
+		if (value && typeof value === "object") return sanitizeAttributes(value);
+		return value;
+	};
+	const sanitized = {};
+	for (const [key, value] of Object.entries(attributes)) {
+		const lowerKey = key.toLowerCase();
+		if (SENSITIVE_ATTRIBUTE_KEYS.some((sensitiveKey) => lowerKey.includes(sensitiveKey))) {
+			sanitized[key] = "<redacted>";
+			continue;
+		}
+		sanitized[key] = sanitizeValue(value);
+	}
+	return sanitized;
+}
+function computeDepth(span, spanMap, depthCache) {
+	if (depthCache.has(span.spanId)) return depthCache.get(span.spanId);
+	if (!span.parentSpanId || !spanMap.has(span.parentSpanId)) {
+		depthCache.set(span.spanId, 0);
+		return 0;
+	}
+	const currentDepth = computeDepth(spanMap.get(span.parentSpanId), spanMap, depthCache) + 1;
+	depthCache.set(span.spanId, currentDepth);
+	return currentDepth;
+}
+function deriveSpanKind(span) {
+	const attributes = span.attributes || {};
+	const attributeKind = attributes["span.kind"] || attributes["otel.span.kind"] || attributes["spanKind"];
+	if (typeof attributeKind === "string") return attributeKind.toLowerCase();
+	return "internal";
+}
+var TraceStore = class {
+	db = null;
+	getDatabase() {
+		if (!this.db) {
+			logger.debug("[TraceStore] Initializing database connection");
+			this.db = getDb();
+		}
+		return this.db;
+	}
+	async createTrace(trace) {
+		try {
+			logger.debug(`[TraceStore] Creating trace ${trace.traceId} for evaluation ${trace.evaluationId}`);
+			await this.getDatabase().insert(tracesTable).values({
+				id: crypto.randomUUID(),
+				traceId: trace.traceId,
+				evaluationId: trace.evaluationId,
+				testCaseId: trace.testCaseId,
+				metadata: trace.metadata
+			}).onConflictDoNothing({ target: tracesTable.traceId });
+			logger.debug(`[TraceStore] Successfully created or found existing trace ${trace.traceId}`);
+		} catch (error) {
+			logger.error(`[TraceStore] Failed to create trace: ${error}`);
+			throw error;
+		}
+	}
+	async addSpans(traceId, spans, options) {
+		try {
+			logger.debug(`[TraceStore] Adding ${spans.length} spans to trace ${traceId}`);
+			const db = this.getDatabase();
+			if (options?.skipTraceCheck) logger.debug(`[TraceStore] Skipping trace existence check for OTLP scenario`);
+			else {
+				logger.debug(`[TraceStore] Verifying trace ${traceId} exists`);
+				if ((await db.select().from(tracesTable).where(eq(tracesTable.traceId, traceId)).limit(1)).length === 0) {
+					logger.warn(`[TraceStore] Trace ${traceId} not found, skipping ${spans.length} spans. This may indicate spans arrived before trace was created.`);
+					return {
+						stored: false,
+						reason: `Trace ${traceId} not found`
+					};
+				}
+				logger.debug(`[TraceStore] Trace ${traceId} found, proceeding with span insertion`);
+			}
+			const spanRecords = spans.map((span) => {
+				logger.debug(`[TraceStore] Preparing span ${span.spanId} (${span.name}) for insertion`);
+				return {
+					id: crypto.randomUUID(),
+					traceId,
+					spanId: span.spanId,
+					parentSpanId: span.parentSpanId,
+					name: span.name,
+					startTime: span.startTime,
+					endTime: span.endTime,
+					attributes: span.attributes,
+					statusCode: span.statusCode,
+					statusMessage: span.statusMessage
+				};
+			});
+			await db.insert(spansTable).values(spanRecords);
+			logger.debug(`[TraceStore] Successfully added ${spans.length} spans to trace ${traceId}`);
+			return { stored: true };
+		} catch (error) {
+			logger.error(`[TraceStore] Failed to add spans: ${error}`);
+			throw error;
+		}
+	}
+	async getTracesByEvaluation(evaluationId) {
+		try {
+			logger.debug(`[TraceStore] Fetching traces for evaluation ${evaluationId}`);
+			const db = this.getDatabase();
+			const traces = await db.select().from(tracesTable).where(eq(tracesTable.evaluationId, evaluationId));
+			logger.debug(`[TraceStore] Found ${traces.length} traces for evaluation ${evaluationId}`);
+			const tracesWithSpans = await Promise.all(traces.map(async (trace) => {
+				logger.debug(`[TraceStore] Fetching spans for trace ${trace.traceId}`);
+				const spans = await db.select().from(spansTable).where(eq(spansTable.traceId, trace.traceId));
+				logger.debug(`[TraceStore] Found ${spans.length} spans for trace ${trace.traceId}`);
+				return {
+					...trace,
+					spans
+				};
+			}));
+			logger.debug(`[TraceStore] Returning ${tracesWithSpans.length} traces with spans`);
+			return tracesWithSpans;
+		} catch (error) {
+			logger.error(`[TraceStore] Failed to get traces for evaluation: ${error}`);
+			throw error;
+		}
+	}
+	async getTrace(traceId) {
+		try {
+			logger.debug(`[TraceStore] Fetching trace ${traceId}`);
+			const db = this.getDatabase();
+			const traces = await db.select().from(tracesTable).where(eq(tracesTable.traceId, traceId)).limit(1);
+			if (traces.length === 0) {
+				logger.debug(`[TraceStore] Trace ${traceId} not found`);
+				return null;
+			}
+			const trace = traces[0];
+			logger.debug(`[TraceStore] Found trace ${traceId}, fetching spans`);
+			const spans = await db.select().from(spansTable).where(eq(spansTable.traceId, traceId));
+			logger.debug(`[TraceStore] Found ${spans.length} spans for trace ${traceId}`);
+			return {
+				...trace,
+				spans
+			};
+		} catch (error) {
+			logger.error(`[TraceStore] Failed to get trace: ${error}`);
+			throw error;
+		}
+	}
+	async deleteOldTraces(retentionDays) {
+		try {
+			logger.debug(`[TraceStore] Deleting traces older than ${retentionDays} days`);
+			const db = this.getDatabase();
+			const cutoffTime = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
+			await db.delete(tracesTable).where(lt(tracesTable.createdAt, cutoffTime));
+			logger.debug(`[TraceStore] Successfully deleted traces older than ${retentionDays} days`);
+		} catch (error) {
+			logger.error(`[TraceStore] Failed to delete old traces: ${error}`);
+			throw error;
+		}
+	}
+	async getSpans(traceId, options = {}) {
+		const { earliestStartTime, maxSpans, maxDepth, includeInternalSpans = true, spanFilter, sanitizeAttributes: shouldSanitize = true } = options;
+		try {
+			logger.debug(`[TraceStore] Fetching spans for trace ${traceId}`);
+			const rows = await this.getDatabase().select().from(spansTable).where(eq(spansTable.traceId, traceId)).orderBy(asc(spansTable.startTime));
+			const spanMap = /* @__PURE__ */ new Map();
+			const depthCache = /* @__PURE__ */ new Map();
+			for (const row of rows) {
+				if (earliestStartTime && row.startTime < earliestStartTime) continue;
+				const rawAttributes = row.attributes ?? {};
+				const spanData = {
+					spanId: row.spanId,
+					parentSpanId: row.parentSpanId ?? void 0,
+					name: row.name,
+					startTime: row.startTime,
+					endTime: row.endTime ?? void 0,
+					attributes: shouldSanitize ? sanitizeAttributes(rawAttributes) : rawAttributes,
+					statusCode: row.statusCode ?? void 0,
+					statusMessage: row.statusMessage ?? void 0
+				};
+				const spanKind = deriveSpanKind({
+					...spanData,
+					attributes: rawAttributes
+				});
+				if (!includeInternalSpans && spanKind === "internal") continue;
+				if (spanFilter && spanFilter.length > 0) {
+					if (!spanFilter.some((filterName) => spanData.name.toLowerCase().includes(filterName.toLowerCase()))) continue;
+				}
+				spanMap.set(spanData.spanId, spanData);
+			}
+			let spans = Array.from(spanMap.values());
+			if (maxDepth !== void 0) spans = spans.filter((span) => computeDepth(span, spanMap, depthCache) < maxDepth);
+			if (maxSpans !== void 0) spans = spans.slice(0, maxSpans);
+			logger.debug(`[TraceStore] Returning ${spans.length} spans for trace ${traceId}`);
+			return spans;
+		} catch (error) {
+			logger.error(`[TraceStore] Failed to fetch spans for trace ${traceId}: ${error}`);
+			throw error;
+		}
+	}
+};
+let traceStore = null;
+function getTraceStore() {
+	if (!traceStore) {
+		logger.debug("[TraceStore] Creating new TraceStore instance");
+		traceStore = new TraceStore();
+	}
+	return traceStore;
+}
+//#endregion
+export { store_exports as n, getTraceStore as t };
+
+//# sourceMappingURL=store-Ub2vaGJ1.js.map

package/dist/src/{tables-D-NSwNIb.js → tables-5EvT_Bwn.js}

@@ -1,16 +1,15 @@
-import { _ as getEnvBool, g as getConfigDirectoryPath, i as logger_default } from "./logger-w8Ozp0Td.js";
-import { g as ResultFailureReason } from "./types-DMVjYLpx.js";
+import { _ as getEnvBool, g as getConfigDirectoryPath, i as logger } from "./logger-CT3IKMKA.js";
+import { g as ResultFailureReason } from "./types-CLKiCBW3.js";
 import * as path$1 from "path";
 import { relations, sql } from "drizzle-orm";
 import Database from "better-sqlite3";
 import { drizzle } from "drizzle-orm/better-sqlite3";
 import { DefaultLogger } from "drizzle-orm/logger";
 import { index, integer, primaryKey, real, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
-
 //#region src/database/index.ts
 var DrizzleLogWriter = class {
 	write(message) {
-		if (getEnvBool("PROMPTFOO_ENABLE_DATABASE_LOGS", false)) logger_default.debug(`Drizzle: ${message}`);
+		if (getEnvBool("PROMPTFOO_ENABLE_DATABASE_LOGS", false)) logger.debug(`Drizzle: ${message}`);
 	}
 };
 let dbInstance = null;
@@ -29,19 +28,18 @@ function getDb() {
 		if (!isMemoryDb && !getEnvBool("PROMPTFOO_DISABLE_WAL_MODE", false)) try {
 			sqliteInstance.pragma("journal_mode = WAL");
 			const result = sqliteInstance.prepare("PRAGMA journal_mode").get();
-			if (result.journal_mode.toLowerCase() === "wal") logger_default.debug("Successfully enabled SQLite WAL mode");
-			else logger_default.warn(`Failed to enable WAL mode (got '${result.journal_mode}'). Database performance may be reduced. This can happen on network filesystems. Set PROMPTFOO_DISABLE_WAL_MODE=true to suppress this warning.`);
+			if (result.journal_mode.toLowerCase() === "wal") logger.debug("Successfully enabled SQLite WAL mode");
+			else logger.warn(`Failed to enable WAL mode (got '${result.journal_mode}'). Database performance may be reduced. This can happen on network filesystems. Set PROMPTFOO_DISABLE_WAL_MODE=true to suppress this warning.`);
 			sqliteInstance.pragma("wal_autocheckpoint = 1000");
 			sqliteInstance.pragma("synchronous = NORMAL");
 		} catch (err) {
-			logger_default.warn(`Error configuring SQLite WAL mode: ${err}. Database will use default journal mode. Performance may be reduced. This can happen on network filesystems or certain containerized environments. Set PROMPTFOO_DISABLE_WAL_MODE=true to suppress this warning.`);
+			logger.warn(`Error configuring SQLite WAL mode: ${err}. Database will use default journal mode. Performance may be reduced. This can happen on network filesystems or certain containerized environments. Set PROMPTFOO_DISABLE_WAL_MODE=true to suppress this warning.`);
 		}
 		const drizzleLogger = new DefaultLogger({ writer: new DrizzleLogWriter() });
 		dbInstance = drizzle(sqliteInstance, { logger: drizzleLogger });
 	}
 	return dbInstance;
 }
-
 //#endregion
 //#region src/database/tables.ts
 const promptsTable = sqliteTable("prompts", {
@@ -119,7 +117,7 @@ const evalsToPromptsTable = sqliteTable("evals_to_prompts", {
 	evalIdIdx: index("evals_to_prompts_eval_id_idx").on(t.evalId),
 	promptIdIdx: index("evals_to_prompts_prompt_id_idx").on(t.promptId)
 }));
-const promptsRelations = relations(promptsTable, ({ many }) => ({ evalsToPrompts: many(evalsToPromptsTable) }));
+relations(promptsTable, ({ many }) => ({ evalsToPrompts: many(evalsToPromptsTable) }));
 const evalsToTagsTable = sqliteTable("evals_to_tags", {
 	evalId: text("eval_id").notNull().references(() => evalsTable.id),
 	tagId: text("tag_id").notNull().references(() => tagsTable.id)
@@ -128,8 +126,8 @@ const evalsToTagsTable = sqliteTable("evals_to_tags", {
 	evalIdIdx: index("evals_to_tags_eval_id_idx").on(t.evalId),
 	tagIdIdx: index("evals_to_tags_tag_id_idx").on(t.tagId)
 }));
-const tagsRelations = relations(tagsTable, ({ many }) => ({ evalsToTags: many(evalsToTagsTable) }));
-const evalsToTagsRelations = relations(evalsToTagsTable, ({ one }) => ({
+relations(tagsTable, ({ many }) => ({ evalsToTags: many(evalsToTagsTable) }));
+relations(evalsToTagsTable, ({ one }) => ({
 	eval: one(evalsTable, {
 		fields: [evalsToTagsTable.evalId],
 		references: [evalsTable.id]
@@ -147,7 +145,8 @@ const blobAssetsTable = sqliteTable("blob_assets", {
 	createdAt: integer("created_at").notNull().default(sql`CURRENT_TIMESTAMP`)
 }, (table) => ({
 	providerIdx: index("blob_assets_provider_idx").on(table.provider),
-	createdAtIdx: index("blob_assets_created_at_idx").on(table.createdAt)
+	createdAtIdx: index("blob_assets_created_at_idx").on(table.createdAt),
+	mimeTypeIdx: index("blob_assets_mime_type_idx").on(table.mimeType)
 }));
 const blobReferencesTable = sqliteTable("blob_references", {
 	id: text("id").primaryKey(),
@@ -160,7 +159,8 @@ const blobReferencesTable = sqliteTable("blob_references", {
 	createdAt: integer("created_at").notNull().default(sql`CURRENT_TIMESTAMP`)
 }, (table) => ({
 	blobIdx: index("blob_references_blob_idx").on(table.blobHash),
-	evalIdx: index("blob_references_eval_idx").on(table.evalId)
+	evalIdx: index("blob_references_eval_idx").on(table.evalId),
+	blobCreatedAtIdx: index("blob_references_blob_created_at_idx").on(table.blobHash, table.createdAt)
 }));
 const datasetsTable = sqliteTable("datasets", {
 	id: text("id").primaryKey(),
@@ -175,13 +175,13 @@ const evalsToDatasetsTable = sqliteTable("evals_to_datasets", {
 	evalIdIdx: index("evals_to_datasets_eval_id_idx").on(t.evalId),
 	datasetIdIdx: index("evals_to_datasets_dataset_id_idx").on(t.datasetId)
 }));
-const datasetsRelations = relations(datasetsTable, ({ many }) => ({ evalsToDatasets: many(evalsToDatasetsTable) }));
-const evalsRelations = relations(evalsTable, ({ many }) => ({
+relations(datasetsTable, ({ many }) => ({ evalsToDatasets: many(evalsToDatasetsTable) }));
+relations(evalsTable, ({ many }) => ({
 	evalsToPrompts: many(evalsToPromptsTable),
 	evalsToDatasets: many(evalsToDatasetsTable),
 	evalsToTags: many(evalsToTagsTable)
 }));
-const evalsToPromptsRelations = relations(evalsToPromptsTable, ({ one }) => ({
+relations(evalsToPromptsTable, ({ one }) => ({
 	eval: one(evalsTable, {
 		fields: [evalsToPromptsTable.evalId],
 		references: [evalsTable.id]
@@ -191,7 +191,7 @@ const evalsToPromptsRelations = relations(evalsToPromptsTable, ({ one }) => ({
 		references: [promptsTable.id]
 	})
 }));
-const evalsToDatasetsRelations = relations(evalsToDatasetsTable, ({ one }) => ({
+relations(evalsToDatasetsTable, ({ one }) => ({
 	eval: one(evalsTable, {
 		fields: [evalsToDatasetsTable.evalId],
 		references: [evalsTable.id]
@@ -201,7 +201,7 @@ const evalsToDatasetsRelations = relations(evalsToDatasetsTable, ({ one }) => ({
 		references: [datasetsTable.id]
 	})
 }));
-const configsTable = sqliteTable("configs", {
+sqliteTable("configs", {
 	id: text("id").primaryKey(),
 	createdAt: integer("created_at").notNull().default(sql`CURRENT_TIMESTAMP`),
 	updatedAt: integer("updated_at").notNull().default(sql`CURRENT_TIMESTAMP`),
@@ -212,7 +212,7 @@ const configsTable = sqliteTable("configs", {
 	createdAtIdx: index("configs_created_at_idx").on(table.createdAt),
 	typeIdx: index("configs_type_idx").on(table.type)
 }));
-const modelAuditsTable = sqliteTable("model_audits", {
+sqliteTable("model_audits", {
 	id: text("id").primaryKey(),
 	createdAt: integer("created_at").notNull().default(sql`CURRENT_TIMESTAMP`),
 	updatedAt: integer("updated_at").notNull().default(sql`CURRENT_TIMESTAMP`),
@@ -271,18 +271,18 @@ const spansTable = sqliteTable("spans", {
 	traceIdIdx: index("spans_trace_id_idx").on(table.traceId),
 	spanIdIdx: index("spans_span_id_idx").on(table.spanId)
 }));
-const tracesRelations = relations(tracesTable, ({ one, many }) => ({
+relations(tracesTable, ({ one, many }) => ({
 	eval: one(evalsTable, {
 		fields: [tracesTable.evaluationId],
 		references: [evalsTable.id]
 	}),
 	spans: many(spansTable)
 }));
-const spansRelations = relations(spansTable, ({ one }) => ({ trace: one(tracesTable, {
+relations(spansTable, ({ one }) => ({ trace: one(tracesTable, {
 	fields: [spansTable.traceId],
 	references: [tracesTable.traceId]
 }) }));
-
 //#endregion
 export { evalsTable as a, evalsToTagsTable as c, tagsTable as d, tracesTable as f, evalResultsTable as i, promptsTable as l, getDbSignalPath as m, blobReferencesTable as n, evalsToDatasetsTable as o, getDb as p, datasetsTable as r, evalsToPromptsTable as s, blobAssetsTable as t, spansTable as u };
-//# sourceMappingURL=tables-D-NSwNIb.js.map
+
+//# sourceMappingURL=tables-5EvT_Bwn.js.map