convex-tracer 0.1.0 → 0.1.2

package/src/component/lib.ts

@@ -2,15 +2,16 @@
  * Internal mutations for managing traces, spans, and logs.
  * These are called automatically by the tracing system to persist data immediately.
  */
+import { paginationOptsValidator } from "convex/server";
 import { v } from "convex/values";
 import type { Id } from "./_generated/dataModel.js";
 import { mutation, query, type MutationCtx } from "./_generated/server.js";
-import schema, {
+import {
   severityValidator,
   sourceValidator,
   statusValidator,
 } from "./schema.js";
-import { vCompleteTrace } from "./types.js";
+import { vCompleteTrace, vPaginatedTraces } from "./types.js";
 
 // ============================================================================
 // Trace Operations
@@ -26,6 +27,7 @@ export const createTrace = mutation({
     sampleRate: v.number(),
     metadata: v.optional(v.record(v.string(), v.any())),
     source: sourceValidator,
+    userId: v.union(v.literal("anonymous"), v.string()),
   },
   returns: v.id("traces"),
   handler: async (ctx, args): Promise<Id<"traces">> => {
@@ -34,6 +36,7 @@ export const createTrace = mutation({
       sampleRate: args.sampleRate,
       updatedAt: Date.now(),
       metadata: args.metadata,
+      userId: args.userId,
     });
   },
 });
@@ -305,34 +308,75 @@ export const getTrace = query({
 export const listTraces = query({
   args: {
     status: v.optional(statusValidator),
-    limit: v.optional(v.number()),
     userId: v.optional(v.string()),
+    paginationOpts: paginationOptsValidator,
   },
-  returns: v.array(
-    schema.tables.traces.validator.extend({
-      _id: v.id("traces"),
-      _creationTime: v.number(),
-    }),
-  ),
-  handler: async (ctx, { status, limit, userId }) => {
-    const query =
-      status && !userId
-        ? ctx.db
-            .query("traces")
-            .withIndex("by_status", (q) => q.eq("status", status))
-        : !status && userId
-          ? ctx.db
-              .query("traces")
-              .withIndex("by_userId", (q) => q.eq("userId", userId))
-          : status && userId
-            ? ctx.db
-                .query("traces")
-                .withIndex("by_status_and_userId", (q) =>
-                  q.eq("status", status).eq("userId", userId),
-                )
-            : ctx.db.query("traces");
-
-    return await query.order("desc").take(limit ?? 100);
+  returns: vPaginatedTraces,
+  handler: async (ctx, { status, userId, paginationOpts }) => {
+    const query = ctx.db.query("traces");
+
+    if (status && !userId) {
+      return await query
+        .withIndex("by_status", (q) => q.eq("status", status))
+        .order("desc")
+        .paginate(paginationOpts);
+    } else if (!status && userId) {
+      return await query
+        .withIndex("by_userId", (q) => q.eq("userId", userId))
+        .order("desc")
+        .paginate(paginationOpts);
+    } else if (status && userId) {
+      return await query
+        .withIndex("by_status_and_userId", (q) =>
+          q.eq("status", status).eq("userId", userId),
+        )
+        .order("desc")
+        .paginate(paginationOpts);
+    }
+
+    return await query.order("desc").paginate(paginationOpts);
+  },
+});
+
+export const searchTraces = query({
+  args: {
+    functionName: v.string(),
+    userId: v.optional(v.string()),
+    status: v.optional(statusValidator),
+    paginationOpts: paginationOptsValidator,
+  },
+  returns: vPaginatedTraces,
+  handler: async (ctx, { functionName, paginationOpts, userId, status }) => {
+    const query = ctx.db.query("traces");
+
+    if (userId && !status) {
+      return await query
+        .withSearchIndex("by_function_name", (q) =>
+          q.search("functionName", functionName).eq("userId", userId),
+        )
+        .paginate(paginationOpts);
+    } else if (status && !userId) {
+      return await query
+        .withSearchIndex("by_function_name", (q) =>
+          q.search("functionName", functionName).eq("status", status),
+        )
+        .paginate(paginationOpts);
+    } else if (userId && status) {
+      return await query
+        .withSearchIndex("by_function_name", (q) =>
+          q
+            .search("functionName", functionName)
+            .eq("userId", userId)
+            .eq("status", status),
+        )
+        .paginate(paginationOpts);
+    }
+
+    return await query
+      .withSearchIndex("by_function_name", (q) =>
+        q.search("functionName", functionName),
+      )
+      .paginate(paginationOpts);
   },
 });
 

package/src/component/schema.ts

@@ -25,11 +25,16 @@ export default defineSchema({
     preserve: v.optional(v.boolean()),
     updatedAt: v.number(),
     metadata: v.optional(v.record(v.string(), v.any())),
+    functionName: v.optional(v.string()),
     userId: v.optional(v.string()),
   })
     .index("by_status", ["status"])
     .index("by_userId", ["userId"])
-    .index("by_status_and_userId", ["status", "userId"]),
+    .index("by_status_and_userId", ["status", "userId"])
+    .searchIndex("by_function_name", {
+      searchField: "functionName",
+      filterFields: ["status", "userId"],
+    }),
 
   spans: defineTable({
     traceId: v.id("traces"),

package/src/component/types.ts

@@ -1,3 +1,4 @@
+import { paginationResultValidator } from "convex/server";
 import { v, type Infer } from "convex/values";
 import schema from "./schema";
 
@@ -6,6 +7,8 @@ export const vTrace = schema.tables.traces.validator.extend({
   _creationTime: v.number(),
 });
 
+export const vPaginatedTraces = paginationResultValidator(vTrace);
+
 export const vSpan = schema.tables.spans.validator
   .omit("parentSpanId")
   .omit("traceId")
@@ -36,3 +39,4 @@ export type Span = Infer<typeof vSpan>;
 export type Log = Infer<typeof vLog>;
 export type SpanWithLogs = Infer<typeof vSpanWithLogs>;
 export type CompleteTrace = Infer<typeof vCompleteTrace>;
+export type paginatedTraces = Infer<typeof vPaginatedTraces>;