@motiadev/core 0.3.0-beta.81 → 0.3.1-beta.82

package/dist/src/cron-handler.js

@@ -58,7 +58,7 @@ const setupCronHandlers = (motia) => {
         const task = cron.schedule(cronExpression, async () => {
             const traceId = (0, generate_trace_id_1.generateTraceId)();
             const logger = motia.loggerFactory.create({ traceId, flows, stepName });
-            const tracer = motia.tracerFactory.createTracer(traceId, step, logger);
+            const tracer = await motia.tracerFactory.createTracer(traceId, step, logger);
             try {
                 await (0, call_step_file_1.callStepFile)({ contextInFirstArg: true, step, traceId, tracer, logger }, motia);
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/src/locked-data.d.ts

@@ -8,7 +8,7 @@ type StreamEvent = 'stream-created' | 'stream-removed' | 'stream-updated';
 type StreamWrapper<TData> = (streamName: string, factory: StreamFactory<TData>) => StreamFactory<TData>;
 export declare class LockedData {
     readonly baseDir: string;
-    private readonly streamAdapter;
+    readonly streamAdapter: 'file' | 'memory';
     private readonly printer;
     flows: Record<string, Flow>;
     activeSteps: Step[];

package/dist/src/observability/index.d.ts

@@ -2,7 +2,7 @@ import { Logger } from '../logger';
 import { Step } from '../types';
 import { StateOperation, StreamOperation, TraceError } from './types';
 export interface TracerFactory {
-    createTracer(traceId: string, step: Step, logger: Logger): Tracer;
+    createTracer(traceId: string, step: Step, logger: Logger): Promise<Tracer> | Tracer;
 }
 export interface Tracer {
     end(err?: TraceError): void;

package/dist/src/observability/trace-stream-adapter.d.ts

@@ -0,0 +1,11 @@
+import { FileStreamAdapter } from '../streams/adapters/file-stream-adapter';
+import { BaseStreamItem } from '../types-stream';
+export declare class TraceStreamAdapter<TData> extends FileStreamAdapter<TData> {
+    private state;
+    private isDirty;
+    constructor(filePath: string, streamName: string, streamAdapter: 'file' | 'memory');
+    get(groupId: string, id: string): Promise<BaseStreamItem<TData> | null>;
+    set(groupId: string, id: string, data: TData): Promise<BaseStreamItem<TData>>;
+    delete(groupId: string, id: string): Promise<BaseStreamItem<TData> | null>;
+    getGroup(groupId: string): Promise<BaseStreamItem<TData>[]>;
+}

package/dist/src/observability/trace-stream-adapter.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraceStreamAdapter = void 0;
+const file_stream_adapter_1 = require("../streams/adapters/file-stream-adapter");
+class TraceStreamAdapter extends file_stream_adapter_1.FileStreamAdapter {
+    constructor(filePath, streamName, streamAdapter) {
+        super(filePath ?? '', streamName);
+        this.state = {};
+        this.isDirty = false;
+        if (streamAdapter === 'file') {
+            const state = this._readFile();
+            Object.entries(state).forEach(([key, value]) => {
+                if (typeof value === 'string') {
+                    this.state[key] = JSON.parse(value);
+                }
+                else {
+                    this.state[key] = value;
+                }
+            });
+            setInterval(() => {
+                if (this.isDirty) {
+                    this._writeFile(this.state);
+                    this.isDirty = false;
+                }
+            }, 30000);
+        }
+    }
+    async get(groupId, id) {
+        const key = this._makeKey(groupId, id);
+        return this.state[key] ? this.state[key] : null;
+    }
+    async set(groupId, id, data) {
+        const key = this._makeKey(groupId, id);
+        this.state[key] = data;
+        this.isDirty = true;
+        return { ...data, id };
+    }
+    async delete(groupId, id) {
+        const key = this._makeKey(groupId, id);
+        const value = await this.get(groupId, id);
+        if (value) {
+            delete this.state[key];
+            this.isDirty = true;
+        }
+        return value;
+    }
+    async getGroup(groupId) {
+        return Object.entries(this.state)
+            .filter(([key]) => key.startsWith(groupId))
+            .map(([, value]) => value);
+    }
+}
+exports.TraceStreamAdapter = TraceStreamAdapter;

package/dist/src/observability/tracer.d.ts

@@ -9,6 +9,7 @@ export declare class BaseTracerFactory implements TracerFactory {
     private readonly traceStream;
     private readonly traceGroupStream;
     constructor(traceStream: MotiaStream<Trace>, traceGroupStream: MotiaStream<TraceGroup>);
-    createTracer(traceId: string, step: Step, logger: Logger): StreamTracer;
+    private deleteGroup;
+    createTracer(traceId: string, step: Step, logger: Logger): Promise<StreamTracer>;
 }
 export declare const createTracerFactory: (lockedData: LockedData) => TracerFactory;

package/dist/src/observability/tracer.js

@@ -4,12 +4,23 @@ exports.createTracerFactory = exports.BaseTracerFactory = void 0;
 const create_trace_1 = require("./create-trace");
 const stream_tracer_1 = require("./stream-tracer");
 const trace_manager_1 = require("./trace-manager");
+const trace_stream_adapter_1 = require("./trace-stream-adapter");
+const MAX_TRACE_GROUPS = process.env.MOTIA_MAX_TRACE_GROUPS //
+    ? parseInt(process.env.MOTIA_MAX_TRACE_GROUPS)
+    : 50;
 class BaseTracerFactory {
     constructor(traceStream, traceGroupStream) {
         this.traceStream = traceStream;
         this.traceGroupStream = traceGroupStream;
     }
-    createTracer(traceId, step, logger) {
+    async deleteGroup(group) {
+        const traces = await this.traceStream.getGroup(group.id);
+        for (const trace of traces) {
+            await this.traceStream.delete(group.id, trace.id);
+        }
+        await this.traceGroupStream.delete('default', group.id);
+    }
+    async createTracer(traceId, step, logger) {
         const traceGroup = {
             id: traceId,
             name: step.config.name,
@@ -23,6 +34,15 @@ class BaseTracerFactory {
             status: 'running',
             startTime: Date.now(),
         };
+        const groups = await this.traceGroupStream.getGroup('default');
+        if (groups.length >= MAX_TRACE_GROUPS) {
+            const groupsToDelete = groups
+                .sort((a, b) => a.startTime - b.startTime) // date ascending
+                .slice(0, groups.length - MAX_TRACE_GROUPS + 1);
+            for (const group of groupsToDelete) {
+                await this.deleteGroup(group);
+            }
+        }
         const trace = (0, create_trace_1.createTrace)(traceGroup, step);
         const manager = new trace_manager_1.TraceManager(this.traceStream, this.traceGroupStream, traceGroup, trace);
         return new stream_tracer_1.StreamTracer(manager, traceGroup, trace, logger);
@@ -30,21 +50,25 @@ class BaseTracerFactory {
 }
 exports.BaseTracerFactory = BaseTracerFactory;
 const createTracerFactory = (lockedData) => {
+    const traceStreamName = 'motia-trace';
+    const traceStreamAdapter = new trace_stream_adapter_1.TraceStreamAdapter(lockedData.baseDir, traceStreamName, lockedData.streamAdapter);
     const traceStream = lockedData.createStream({
-        filePath: '__motia.trace',
+        filePath: traceStreamName,
         hidden: true,
         config: {
-            name: 'motia-trace',
-            baseConfig: { storageType: 'default' },
+            name: traceStreamName,
+            baseConfig: { storageType: 'custom', factory: () => traceStreamAdapter },
             schema: null,
         },
     })();
+    const traceGroupName = 'motia-trace-group';
+    const traceGroupStreamAdapter = new trace_stream_adapter_1.TraceStreamAdapter(lockedData.baseDir, traceGroupName, lockedData.streamAdapter);
     const traceGroupStream = lockedData.createStream({
-        filePath: '__motia.trace-group',
+        filePath: traceGroupName,
         hidden: true,
         config: {
-            name: 'motia-trace-group',
-            baseConfig: { storageType: 'default' },
+            name: traceGroupName,
+            baseConfig: { storageType: 'custom', factory: () => traceGroupStreamAdapter },
             schema: null,
         },
     })();

package/dist/src/server.js

@@ -118,7 +118,7 @@ const createServer = (lockedData, eventManager, state, config) => {
             const traceId = (0, generate_trace_id_1.generateTraceId)();
             const { name: stepName, flows } = step.config;
             const logger = loggerFactory.create({ traceId, flows, stepName });
-            const tracer = motia.tracerFactory.createTracer(traceId, step, logger);
+            const tracer = await motia.tracerFactory.createTracer(traceId, step, logger);
             logger.debug('[API] Received request, processing step', { path: req.path });
             const data = {
                 body: req.body,

package/dist/src/streams/adapters/file-stream-adapter.d.ts

@@ -1,4 +1,5 @@
 import { StreamAdapter } from './stream-adapter';
+import { BaseStreamItem } from '../../types-stream';
 export type FileAdapterConfig = {
     filePath: string;
 };
@@ -7,14 +8,14 @@ export declare class FileStreamAdapter<TData> extends StreamAdapter<TData> {
     private readonly streamsDir;
     constructor(filePath: string, streamName: string);
     init(): void;
-    getGroup<T>(groupId: string): Promise<T[]>;
-    get<T>(groupId: string, key: string): Promise<T | null>;
-    set<T>(groupId: string, id: string, value: T): Promise<T & {
+    getGroup(groupId: string): Promise<BaseStreamItem<TData>[]>;
+    get(groupId: string, key: string): Promise<BaseStreamItem<TData> | null>;
+    set(groupId: string, id: string, value: TData): Promise<TData & {
         id: string;
     }>;
-    delete<T>(groupId: string, id: string): Promise<T | null>;
+    delete(groupId: string, id: string): Promise<BaseStreamItem<TData> | null>;
     clear(groupId: string): Promise<void>;
-    private _makeKey;
-    private _readFile;
-    private _writeFile;
+    protected _makeKey(groupId: string, id: string): string;
+    protected _readFile(): Record<string, string>;
+    protected _writeFile(data: unknown): void;
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@motiadev/core",
   "description": "Core functionality for the Motia framework, providing the foundation for building event-driven workflows.",
   "main": "dist/index.js",
-  "version": "0.3.0-beta.81",
+  "version": "0.3.1-beta.82",
   "dependencies": {
     "@amplitude/analytics-node": "^1.3.8",
     "body-parser": "^1.20.3",