@mastra/upstash 0.2.2-alpha.6 → 0.2.2-alpha.8

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/upstash@0.2.2-alpha.6 build /home/runner/work/mastra/mastra/stores/upstash
+> @mastra/upstash@0.2.2-alpha.8 build /home/runner/work/mastra/mastra/stores/upstash
 > tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.4.0
 TSC Build start
-TSC ⚡️ Build success in 9094ms
+TSC ⚡️ Build success in 8689ms
 DTS Build start
 CLI Target: es2022
 Analysis will use the bundled TypeScript version 5.8.2
 Writing package typings: /home/runner/work/mastra/mastra/stores/upstash/dist/_tsup-dts-rollup.d.ts
 Analysis will use the bundled TypeScript version 5.8.2
 Writing package typings: /home/runner/work/mastra/mastra/stores/upstash/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 10401ms
+DTS ⚡️ Build success in 10613ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-ESM dist/index.js 21.62 KB
-ESM ⚡️ Build success in 704ms
-CJS dist/index.cjs 21.72 KB
-CJS ⚡️ Build success in 703ms
+ESM dist/index.js 24.02 KB
+ESM ⚡️ Build success in 1171ms
+CJS dist/index.cjs 24.11 KB
+CJS ⚡️ Build success in 1172ms

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @mastra/upstash
 
+## 0.2.2-alpha.8
+
+### Patch Changes
+
+- b7c1319: Upstash getTraces method
+- Updated dependencies [8df4a77]
+  - @mastra/core@0.8.0-alpha.8
+
+## 0.2.2-alpha.7
+
+### Patch Changes
+
+- Updated dependencies [febc8a6]
+  - @mastra/core@0.8.0-alpha.7
+
 ## 0.2.2-alpha.6
 
 ### Patch Changes

package/dist/_tsup-dts-rollup.d.cts

@@ -44,7 +44,7 @@ declare class UpstashStore extends MastraStorage {
     }): Promise<void>;
     getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
     private transformEvalRecord;
-    getTraces(_input: {
+    getTraces({ name, scope, page, perPage, attributes, filters, }?: {
         name?: string;
         scope?: string;
         page: number;
@@ -52,6 +52,7 @@ declare class UpstashStore extends MastraStorage {
         attributes?: Record<string, string>;
         filters?: Record<string, any>;
     }): Promise<any[]>;
+    private parseJSON;
     private redis;
     constructor(config: UpstashConfig);
     private getKey;

package/dist/_tsup-dts-rollup.d.ts

@@ -44,7 +44,7 @@ declare class UpstashStore extends MastraStorage {
     }): Promise<void>;
     getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
     private transformEvalRecord;
-    getTraces(_input: {
+    getTraces({ name, scope, page, perPage, attributes, filters, }?: {
         name?: string;
         scope?: string;
         page: number;
@@ -52,6 +52,7 @@ declare class UpstashStore extends MastraStorage {
         attributes?: Record<string, string>;
         filters?: Record<string, any>;
     }): Promise<any[]>;
+    private parseJSON;
     private redis;
     constructor(config: UpstashConfig);
     private getKey;

package/dist/index.cjs

@@ -34,7 +34,7 @@ var UpstashStore = class extends storage.MastraStorage {
               return parsedTestInfo && typeof parsedTestInfo === "object" && "testPath" in parsedTestInfo;
             }
             return typeof record.test_info === "object" && "testPath" in record.test_info;
-          } catch (_e) {
+          } catch {
             return false;
           }
         });
@@ -47,7 +47,7 @@ var UpstashStore = class extends storage.MastraStorage {
               return !(parsedTestInfo && typeof parsedTestInfo === "object" && "testPath" in parsedTestInfo);
             }
             return !(typeof record.test_info === "object" && "testPath" in record.test_info);
-          } catch (_e) {
+          } catch {
             return true;
           }
         });
@@ -63,7 +63,7 @@ var UpstashStore = class extends storage.MastraStorage {
     if (typeof result === "string") {
       try {
         result = JSON.parse(result);
-      } catch (_e) {
+      } catch {
         console.warn("Failed to parse result JSON:");
       }
     }
@@ -71,7 +71,7 @@ var UpstashStore = class extends storage.MastraStorage {
     if (typeof testInfo === "string") {
       try {
         testInfo = JSON.parse(testInfo);
-      } catch (_e) {
+      } catch {
         console.warn("Failed to parse test_info JSON:");
       }
     }
@@ -88,8 +88,82 @@ var UpstashStore = class extends storage.MastraStorage {
       createdAt: typeof record.created_at === "string" ? record.created_at : record.created_at instanceof Date ? record.created_at.toISOString() : (/* @__PURE__ */ new Date()).toISOString()
     };
   }
-  getTraces(_input) {
-    throw new Error("Method not implemented.");
+  async getTraces({
+    name,
+    scope,
+    page = 0,
+    perPage = 100,
+    attributes,
+    filters
+  } = {
+    page: 0,
+    perPage: 100
+  }) {
+    try {
+      const pattern = `${storage.TABLE_TRACES}:*`;
+      const keys = await this.redis.keys(pattern);
+      const traceRecords = await Promise.all(
+        keys.map(async (key) => {
+          const data = await this.redis.get(key);
+          return data;
+        })
+      );
+      let filteredTraces = traceRecords.filter(
+        (record) => record !== null && typeof record === "object"
+      );
+      if (name) {
+        filteredTraces = filteredTraces.filter((record) => record.name?.toLowerCase().startsWith(name.toLowerCase()));
+      }
+      if (scope) {
+        filteredTraces = filteredTraces.filter((record) => record.scope === scope);
+      }
+      if (attributes) {
+        filteredTraces = filteredTraces.filter((record) => {
+          const recordAttributes = record.attributes;
+          if (!recordAttributes) return false;
+          const parsedAttributes = typeof recordAttributes === "string" ? JSON.parse(recordAttributes) : recordAttributes;
+          return Object.entries(attributes).every(([key, value]) => parsedAttributes[key] === value);
+        });
+      }
+      if (filters) {
+        filteredTraces = filteredTraces.filter(
+          (record) => Object.entries(filters).every(([key, value]) => record[key] === value)
+        );
+      }
+      filteredTraces.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+      const start = page * perPage;
+      const end = start + perPage;
+      const paginatedTraces = filteredTraces.slice(start, end);
+      return paginatedTraces.map((record) => ({
+        id: record.id,
+        parentSpanId: record.parentSpanId,
+        traceId: record.traceId,
+        name: record.name,
+        scope: record.scope,
+        kind: record.kind,
+        status: this.parseJSON(record.status),
+        events: this.parseJSON(record.events),
+        links: this.parseJSON(record.links),
+        attributes: this.parseJSON(record.attributes),
+        startTime: record.startTime,
+        endTime: record.endTime,
+        other: this.parseJSON(record.other),
+        createdAt: this.ensureDate(record.createdAt)
+      }));
+    } catch (error) {
+      console.error("Failed to get traces:", error);
+      return [];
+    }
+  }
+  parseJSON(value) {
+    if (typeof value === "string") {
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+    }
+    return value;
   }
   redis;
   constructor(config) {
@@ -319,7 +393,7 @@ var UpstashStore = class extends storage.MastraStorage {
       if (typeof parsedSnapshot === "string") {
         try {
           parsedSnapshot = JSON.parse(w.snapshot);
-        } catch (_e) {
+        } catch {
           console.warn(`Failed to parse snapshot for workflow ${w.workflow_name}:`);
         }
       }

package/dist/index.js

@@ -1,4 +1,4 @@
-import { MastraStorage, TABLE_EVALS, TABLE_MESSAGES, TABLE_WORKFLOW_SNAPSHOT, TABLE_THREADS } from '@mastra/core/storage';
+import { MastraStorage, TABLE_EVALS, TABLE_TRACES, TABLE_MESSAGES, TABLE_WORKFLOW_SNAPSHOT, TABLE_THREADS } from '@mastra/core/storage';
 import { Redis } from '@upstash/redis';
 import { MastraVector } from '@mastra/core/vector';
 import { Index } from '@upstash/vector';
@@ -32,7 +32,7 @@ var UpstashStore = class extends MastraStorage {
               return parsedTestInfo && typeof parsedTestInfo === "object" && "testPath" in parsedTestInfo;
             }
             return typeof record.test_info === "object" && "testPath" in record.test_info;
-          } catch (_e) {
+          } catch {
             return false;
           }
         });
@@ -45,7 +45,7 @@ var UpstashStore = class extends MastraStorage {
               return !(parsedTestInfo && typeof parsedTestInfo === "object" && "testPath" in parsedTestInfo);
             }
             return !(typeof record.test_info === "object" && "testPath" in record.test_info);
-          } catch (_e) {
+          } catch {
             return true;
           }
         });
@@ -61,7 +61,7 @@ var UpstashStore = class extends MastraStorage {
     if (typeof result === "string") {
       try {
         result = JSON.parse(result);
-      } catch (_e) {
+      } catch {
         console.warn("Failed to parse result JSON:");
       }
     }
@@ -69,7 +69,7 @@ var UpstashStore = class extends MastraStorage {
     if (typeof testInfo === "string") {
       try {
         testInfo = JSON.parse(testInfo);
-      } catch (_e) {
+      } catch {
         console.warn("Failed to parse test_info JSON:");
       }
     }
@@ -86,8 +86,82 @@ var UpstashStore = class extends MastraStorage {
       createdAt: typeof record.created_at === "string" ? record.created_at : record.created_at instanceof Date ? record.created_at.toISOString() : (/* @__PURE__ */ new Date()).toISOString()
     };
   }
-  getTraces(_input) {
-    throw new Error("Method not implemented.");
+  async getTraces({
+    name,
+    scope,
+    page = 0,
+    perPage = 100,
+    attributes,
+    filters
+  } = {
+    page: 0,
+    perPage: 100
+  }) {
+    try {
+      const pattern = `${TABLE_TRACES}:*`;
+      const keys = await this.redis.keys(pattern);
+      const traceRecords = await Promise.all(
+        keys.map(async (key) => {
+          const data = await this.redis.get(key);
+          return data;
+        })
+      );
+      let filteredTraces = traceRecords.filter(
+        (record) => record !== null && typeof record === "object"
+      );
+      if (name) {
+        filteredTraces = filteredTraces.filter((record) => record.name?.toLowerCase().startsWith(name.toLowerCase()));
+      }
+      if (scope) {
+        filteredTraces = filteredTraces.filter((record) => record.scope === scope);
+      }
+      if (attributes) {
+        filteredTraces = filteredTraces.filter((record) => {
+          const recordAttributes = record.attributes;
+          if (!recordAttributes) return false;
+          const parsedAttributes = typeof recordAttributes === "string" ? JSON.parse(recordAttributes) : recordAttributes;
+          return Object.entries(attributes).every(([key, value]) => parsedAttributes[key] === value);
+        });
+      }
+      if (filters) {
+        filteredTraces = filteredTraces.filter(
+          (record) => Object.entries(filters).every(([key, value]) => record[key] === value)
+        );
+      }
+      filteredTraces.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+      const start = page * perPage;
+      const end = start + perPage;
+      const paginatedTraces = filteredTraces.slice(start, end);
+      return paginatedTraces.map((record) => ({
+        id: record.id,
+        parentSpanId: record.parentSpanId,
+        traceId: record.traceId,
+        name: record.name,
+        scope: record.scope,
+        kind: record.kind,
+        status: this.parseJSON(record.status),
+        events: this.parseJSON(record.events),
+        links: this.parseJSON(record.links),
+        attributes: this.parseJSON(record.attributes),
+        startTime: record.startTime,
+        endTime: record.endTime,
+        other: this.parseJSON(record.other),
+        createdAt: this.ensureDate(record.createdAt)
+      }));
+    } catch (error) {
+      console.error("Failed to get traces:", error);
+      return [];
+    }
+  }
+  parseJSON(value) {
+    if (typeof value === "string") {
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+    }
+    return value;
   }
   redis;
   constructor(config) {
@@ -317,7 +391,7 @@ var UpstashStore = class extends MastraStorage {
       if (typeof parsedSnapshot === "string") {
         try {
           parsedSnapshot = JSON.parse(w.snapshot);
-        } catch (_e) {
+        } catch {
           console.warn(`Failed to parse snapshot for workflow ${w.workflow_name}:`);
         }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/upstash",
-  "version": "0.2.2-alpha.6",
+  "version": "0.2.2-alpha.8",
   "description": "Upstash provider for Mastra - includes both vector and db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -21,7 +21,7 @@
   "dependencies": {
     "@upstash/redis": "^1.34.5",
     "@upstash/vector": "^1.2.1",
-    "@mastra/core": "^0.8.0-alpha.6"
+    "@mastra/core": "^0.8.0-alpha.8"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.52.1",

package/src/storage/index.ts

@@ -6,6 +6,7 @@ import {
   TABLE_THREADS,
   TABLE_WORKFLOW_SNAPSHOT,
   TABLE_EVALS,
+  TABLE_TRACES,
 } from '@mastra/core/storage';
 import type { TABLE_NAMES, StorageColumn, StorageGetMessagesArg, EvalRow } from '@mastra/core/storage';
 import type { WorkflowRunState } from '@mastra/core/workflows';
@@ -57,7 +58,7 @@ export class UpstashStore extends MastraStorage {
 
             // Handle test_info as an object
             return typeof record.test_info === 'object' && 'testPath' in record.test_info;
-          } catch (_e) {
+          } catch {
             return false;
           }
         });
@@ -74,7 +75,7 @@ export class UpstashStore extends MastraStorage {
 
             // Handle test_info as an object
             return !(typeof record.test_info === 'object' && 'testPath' in record.test_info);
-          } catch (_e) {
+          } catch {
             return true;
           }
         });
@@ -94,7 +95,7 @@ export class UpstashStore extends MastraStorage {
     if (typeof result === 'string') {
       try {
         result = JSON.parse(result);
-      } catch (_e) {
+      } catch {
         console.warn('Failed to parse result JSON:');
       }
     }
@@ -103,7 +104,7 @@ export class UpstashStore extends MastraStorage {
     if (typeof testInfo === 'string') {
       try {
         testInfo = JSON.parse(testInfo);
-      } catch (_e) {
+      } catch {
         console.warn('Failed to parse test_info JSON:');
       }
     }
@@ -127,15 +128,115 @@ export class UpstashStore extends MastraStorage {
     };
   }
 
-  getTraces(_input: {
-    name?: string;
-    scope?: string;
-    page: number;
-    perPage: number;
-    attributes?: Record<string, string>;
-    filters?: Record<string, any>;
-  }): Promise<any[]> {
-    throw new Error('Method not implemented.');
+  async getTraces(
+    {
+      name,
+      scope,
+      page = 0,
+      perPage = 100,
+      attributes,
+      filters,
+    }: {
+      name?: string;
+      scope?: string;
+      page: number;
+      perPage: number;
+      attributes?: Record<string, string>;
+      filters?: Record<string, any>;
+    } = {
+      page: 0,
+      perPage: 100,
+    },
+  ): Promise<any[]> {
+    try {
+      // Get all keys that match the traces table pattern
+      const pattern = `${TABLE_TRACES}:*`;
+      const keys = await this.redis.keys(pattern);
+
+      // Fetch all trace records
+      const traceRecords = await Promise.all(
+        keys.map(async key => {
+          const data = await this.redis.get<Record<string, any>>(key);
+          return data;
+        }),
+      );
+
+      // Filter out nulls and apply filters
+      let filteredTraces = traceRecords.filter(
+        (record): record is Record<string, any> => record !== null && typeof record === 'object',
+      );
+
+      // Apply name filter if provided
+      if (name) {
+        filteredTraces = filteredTraces.filter(record => record.name?.toLowerCase().startsWith(name.toLowerCase()));
+      }
+
+      // Apply scope filter if provided
+      if (scope) {
+        filteredTraces = filteredTraces.filter(record => record.scope === scope);
+      }
+
+      // Apply attributes filter if provided
+      if (attributes) {
+        filteredTraces = filteredTraces.filter(record => {
+          const recordAttributes = record.attributes;
+          if (!recordAttributes) return false;
+
+          // Parse attributes if stored as string
+          const parsedAttributes =
+            typeof recordAttributes === 'string' ? JSON.parse(recordAttributes) : recordAttributes;
+
+          return Object.entries(attributes).every(([key, value]) => parsedAttributes[key] === value);
+        });
+      }
+
+      // Apply custom filters if provided
+      if (filters) {
+        filteredTraces = filteredTraces.filter(record =>
+          Object.entries(filters).every(([key, value]) => record[key] === value),
+        );
+      }
+
+      // Sort traces by creation date (newest first)
+      filteredTraces.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+
+      // Apply pagination
+      const start = page * perPage;
+      const end = start + perPage;
+      const paginatedTraces = filteredTraces.slice(start, end);
+
+      // Transform and return the traces
+      return paginatedTraces.map(record => ({
+        id: record.id,
+        parentSpanId: record.parentSpanId,
+        traceId: record.traceId,
+        name: record.name,
+        scope: record.scope,
+        kind: record.kind,
+        status: this.parseJSON(record.status),
+        events: this.parseJSON(record.events),
+        links: this.parseJSON(record.links),
+        attributes: this.parseJSON(record.attributes),
+        startTime: record.startTime,
+        endTime: record.endTime,
+        other: this.parseJSON(record.other),
+        createdAt: this.ensureDate(record.createdAt),
+      }));
+    } catch (error) {
+      console.error('Failed to get traces:', error);
+      return [];
+    }
+  }
+
+  private parseJSON(value: any): any {
+    if (typeof value === 'string') {
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+    }
+    return value;
   }
 
   private redis: Redis;
@@ -485,7 +586,7 @@ export class UpstashStore extends MastraStorage {
         if (typeof parsedSnapshot === 'string') {
           try {
             parsedSnapshot = JSON.parse(w!.snapshot as string) as WorkflowRunState;
-          } catch (_e) {
+          } catch {
             // If parsing fails, return the raw snapshot string
             console.warn(`Failed to parse snapshot for workflow ${w!.workflow_name}:`);
           }

package/src/storage/upstash.test.ts

@@ -1,8 +1,13 @@
 import { randomUUID } from 'crypto';
-import type { MetricResult, TestInfo } from '@mastra/core/eval';
 import type { MessageType } from '@mastra/core/memory';
 import type { TABLE_NAMES } from '@mastra/core/storage';
-import { TABLE_MESSAGES, TABLE_THREADS, TABLE_WORKFLOW_SNAPSHOT, TABLE_EVALS } from '@mastra/core/storage';
+import {
+  TABLE_MESSAGES,
+  TABLE_THREADS,
+  TABLE_WORKFLOW_SNAPSHOT,
+  TABLE_EVALS,
+  TABLE_TRACES,
+} from '@mastra/core/storage';
 import type { WorkflowRunState } from '@mastra/core/workflows';
 import { describe, it, expect, beforeAll, beforeEach, afterAll, vi } from 'vitest';
 
@@ -55,6 +60,23 @@ const createSampleWorkflowSnapshot = (status: string, createdAt?: Date) => {
   return { snapshot, runId, stepId };
 };
 
+const createSampleTrace = (name: string, scope?: string, attributes?: Record<string, string>) => ({
+  id: `trace-${randomUUID()}`,
+  parentSpanId: `span-${randomUUID()}`,
+  traceId: `trace-${randomUUID()}`,
+  name,
+  scope,
+  kind: 'internal',
+  status: JSON.stringify({ code: 'success' }),
+  events: JSON.stringify([{ name: 'start', timestamp: Date.now() }]),
+  links: JSON.stringify([]),
+  attributes: attributes ? JSON.stringify(attributes) : undefined,
+  startTime: new Date().toISOString(),
+  endTime: new Date().toISOString(),
+  other: JSON.stringify({ custom: 'data' }),
+  createdAt: new Date().toISOString(),
+});
+
 const createSampleEval = (agentName: string, isTest = false) => {
   const testInfo = isTest ? { testPath: 'test/path.ts', testName: 'Test Name' } : undefined;
 
@@ -98,6 +120,7 @@ describe('UpstashStore', () => {
     await store.clearTable({ tableName: TABLE_MESSAGES });
     await store.clearTable({ tableName: TABLE_WORKFLOW_SNAPSHOT });
     await store.clearTable({ tableName: TABLE_EVALS });
+    await store.clearTable({ tableName: TABLE_TRACES });
   });
 
   describe('Table Operations', () => {
@@ -321,6 +344,97 @@ describe('UpstashStore', () => {
     });
   });
 
+  describe('Trace Operations', () => {
+    beforeEach(async () => {
+      await store.clearTable({ tableName: TABLE_TRACES });
+    });
+
+    it('should retrieve traces with filtering and pagination', async () => {
+      // Insert sample traces
+      const trace1 = createSampleTrace('test-trace-1', 'scope1', { env: 'prod' });
+      const trace2 = createSampleTrace('test-trace-2', 'scope1', { env: 'dev' });
+      const trace3 = createSampleTrace('other-trace', 'scope2', { env: 'prod' });
+
+      await store.insert({ tableName: TABLE_TRACES, record: trace1 });
+      await store.insert({ tableName: TABLE_TRACES, record: trace2 });
+      await store.insert({ tableName: TABLE_TRACES, record: trace3 });
+
+      // Test name filter
+      const testTraces = await store.getTraces({ name: 'test-trace', page: 0, perPage: 10 });
+      expect(testTraces).toHaveLength(2);
+      expect(testTraces.map(t => t.name)).toContain('test-trace-1');
+      expect(testTraces.map(t => t.name)).toContain('test-trace-2');
+
+      // Test scope filter
+      const scope1Traces = await store.getTraces({ scope: 'scope1', page: 0, perPage: 10 });
+      expect(scope1Traces).toHaveLength(2);
+      expect(scope1Traces.every(t => t.scope === 'scope1')).toBe(true);
+
+      // Test attributes filter
+      const prodTraces = await store.getTraces({
+        attributes: { env: 'prod' },
+        page: 0,
+        perPage: 10,
+      });
+      expect(prodTraces).toHaveLength(2);
+      expect(prodTraces.every(t => t.attributes.env === 'prod')).toBe(true);
+
+      // Test pagination
+      const pagedTraces = await store.getTraces({ page: 0, perPage: 2 });
+      expect(pagedTraces).toHaveLength(2);
+
+      // Test combined filters
+      const combinedTraces = await store.getTraces({
+        scope: 'scope1',
+        attributes: { env: 'prod' },
+        page: 0,
+        perPage: 10,
+      });
+      expect(combinedTraces).toHaveLength(1);
+      expect(combinedTraces[0].name).toBe('test-trace-1');
+
+      // Verify trace object structure
+      const trace = combinedTraces[0];
+      expect(trace).toHaveProperty('id');
+      expect(trace).toHaveProperty('parentSpanId');
+      expect(trace).toHaveProperty('traceId');
+      expect(trace).toHaveProperty('name');
+      expect(trace).toHaveProperty('scope');
+      expect(trace).toHaveProperty('kind');
+      expect(trace).toHaveProperty('status');
+      expect(trace).toHaveProperty('events');
+      expect(trace).toHaveProperty('links');
+      expect(trace).toHaveProperty('attributes');
+      expect(trace).toHaveProperty('startTime');
+      expect(trace).toHaveProperty('endTime');
+      expect(trace).toHaveProperty('other');
+      expect(trace).toHaveProperty('createdAt');
+
+      // Verify JSON fields are parsed
+      expect(typeof trace.status).toBe('object');
+      expect(typeof trace.events).toBe('object');
+      expect(typeof trace.links).toBe('object');
+      expect(typeof trace.attributes).toBe('object');
+      expect(typeof trace.other).toBe('object');
+    });
+
+    it('should handle empty results', async () => {
+      const traces = await store.getTraces({ page: 0, perPage: 10 });
+      expect(traces).toHaveLength(0);
+    });
+
+    it('should handle invalid JSON in fields', async () => {
+      const trace = createSampleTrace('test-trace');
+      trace.status = 'invalid-json{'; // Intentionally invalid JSON
+
+      await store.insert({ tableName: TABLE_TRACES, record: trace });
+      const traces = await store.getTraces({ page: 0, perPage: 10 });
+
+      expect(traces).toHaveLength(1);
+      expect(traces[0].status).toBe('invalid-json{'); // Should return raw string when JSON parsing fails
+    });
+  });
+
   describe('Workflow Operations', () => {
     const testNamespace = 'test';
     const testWorkflow = 'test-workflow';