@motiadev/core 0.14.0-beta.165-516298 → 0.14.0-beta.165-454838

package/dist/src/observability/create-trace.d.ts

@@ -0,0 +1,4 @@
+import type { Step } from '../types';
+import type { Trace, TraceGroup } from './types';
+export declare const createTrace: (traceGroup: TraceGroup, step: Step) => Trace;
+//# sourceMappingURL=create-trace.d.ts.map

package/dist/src/observability/create-trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-trace.d.ts","sourceRoot":"","sources":["../../../src/observability/create-trace.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,UAAU,CAAA;AACpC,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEhD,eAAO,MAAM,WAAW,GAAI,YAAY,UAAU,EAAE,MAAM,IAAI,UAkB7D,CAAA"}

package/dist/src/observability/create-trace.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTrace = void 0;
+const crypto_1 = require("crypto");
+const createTrace = (traceGroup, step) => {
+    const id = (0, crypto_1.randomUUID)();
+    const trace = {
+        id,
+        name: step.config.name,
+        correlationId: traceGroup.correlationId,
+        parentTraceId: traceGroup.id,
+        status: 'running',
+        startTime: Date.now(),
+        endTime: undefined,
+        entryPoint: { type: step.config.type, stepName: step.config.name },
+        events: [],
+    };
+    traceGroup.metadata.totalSteps++;
+    traceGroup.metadata.activeSteps++;
+    return trace;
+};
+exports.createTrace = createTrace;

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

@@ -0,0 +1,4 @@
+import type { ObservabilityAdapter, Tracer } from '../adapters/interfaces/observability-adapter.interface';
+export type { ObservabilityAdapter, Tracer };
+export type TracerFactory = ObservabilityAdapter;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/observability/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,EAAE,MAAM,wDAAwD,CAAA;AAE1G,YAAY,EAAE,oBAAoB,EAAE,MAAM,EAAE,CAAA;AAC5C,MAAM,MAAM,aAAa,GAAG,oBAAoB,CAAA"}

package/dist/src/observability/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,10 @@
+import type { Tracer } from '.';
+export declare class NoTracer implements Tracer {
+    end(): Promise<void>;
+    stateOperation(): Promise<void>;
+    emitOperation(): Promise<void>;
+    streamOperation(): Promise<void>;
+    clear(): void;
+    child(): this;
+}
+//# sourceMappingURL=no-tracer.d.ts.map

package/dist/src/observability/no-tracer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-tracer.d.ts","sourceRoot":"","sources":["../../../src/observability/no-tracer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,CAAA;AAE/B,qBAAa,QAAS,YAAW,MAAM;IAC/B,GAAG;IAGH,cAAc;IAGd,aAAa;IAGb,eAAe;IAGrB,KAAK;IACL,KAAK;CAGN"}

package/dist/src/observability/no-tracer.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoTracer = void 0;
+class NoTracer {
+    async end() {
+        return Promise.resolve();
+    }
+    async stateOperation() {
+        return Promise.resolve();
+    }
+    async emitOperation() {
+        return Promise.resolve();
+    }
+    async streamOperation() {
+        return Promise.resolve();
+    }
+    clear() { }
+    child() {
+        return this;
+    }
+}
+exports.NoTracer = NoTracer;

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

@@ -0,0 +1,17 @@
+import type { RedisClientType } from 'redis';
+import { StreamAdapter } from '../adapters/interfaces/stream-adapter.interface';
+import type { BaseStreamItem, StateStreamEvent, StateStreamEventChannel } from '../types-stream';
+export declare class RedisTraceStreamAdapter<TData> extends StreamAdapter<TData> {
+    private client;
+    private readonly keyPrefix;
+    private ttl;
+    constructor(streamName: string, client: RedisClientType, ttl?: number);
+    private makeGroupKey;
+    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>[]>;
+    send<T>(channel: StateStreamEventChannel, event: StateStreamEvent<T>): Promise<void>;
+    clear(groupId: string): Promise<void>;
+}
+//# sourceMappingURL=redis-trace-stream-adapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"redis-trace-stream-adapter.d.ts","sourceRoot":"","sources":["../../../src/observability/redis-trace-stream-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,OAAO,CAAA;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,iDAAiD,CAAA;AAC/E,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAA;AAIhG,qBAAa,uBAAuB,CAAC,KAAK,CAAE,SAAQ,aAAa,CAAC,KAAK,CAAC;IACtE,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAyB;IACnD,OAAO,CAAC,GAAG,CAAQ;gBAEP,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,GAAG,GAAE,MAA0B;IAMxF,OAAO,CAAC,YAAY;IAId,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IAMvE,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;IAiB7E,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IAa1E,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,CAAC;IAc3D,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,uBAAuB,EAAE,KAAK,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAOpF,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAI5C"}

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisTraceStreamAdapter = void 0;
+const stream_adapter_interface_1 = require("../adapters/interfaces/stream-adapter.interface");
+const TRACE_TTL_SECONDS = 3 * 24 * 60 * 60;
+class RedisTraceStreamAdapter extends stream_adapter_interface_1.StreamAdapter {
+    constructor(streamName, client, ttl = TRACE_TTL_SECONDS) {
+        super(streamName);
+        this.keyPrefix = 'motia:trace:';
+        this.client = client;
+        this.ttl = ttl;
+    }
+    makeGroupKey(groupId) {
+        return `${this.keyPrefix}${groupId}`;
+    }
+    async get(groupId, id) {
+        const hashKey = this.makeGroupKey(groupId);
+        const value = await this.client.hGet(hashKey, id);
+        return value ? JSON.parse(value) : null;
+    }
+    async set(groupId, id, data) {
+        const hashKey = this.makeGroupKey(groupId);
+        const item = { ...data, id };
+        const itemJson = JSON.stringify(item);
+        const existed = await this.client.hExists(hashKey, id);
+        const eventType = existed ? 'update' : 'create';
+        await Promise.all([
+            this.client.hSet(hashKey, id, itemJson),
+            this.send({ groupId, id }, { type: eventType, data: item }),
+            this.client.expire(hashKey, this.ttl),
+        ]);
+        return item;
+    }
+    async delete(groupId, id) {
+        const hashKey = this.makeGroupKey(groupId);
+        const value = await this.client.hGet(hashKey, id);
+        if (!value)
+            return null;
+        const item = JSON.parse(value);
+        await Promise.all([this.client.hDel(hashKey, id), this.send({ groupId, id }, { type: 'delete', data: item })]);
+        return item;
+    }
+    async getGroup(groupId) {
+        const hashKey = this.makeGroupKey(groupId);
+        const values = await this.client.hGetAll(hashKey);
+        const items = Object.values(values).map((v) => JSON.parse(v));
+        const sortDesc = (a, b) => {
+            const aTime = a.startTime || 0;
+            const bTime = b.startTime || 0;
+            return aTime - bTime;
+        };
+        return items.sort(sortDesc);
+    }
+    async send(channel, event) {
+        const channelKey = channel.id
+            ? `${this.keyPrefix}events:${this.streamName}:${channel.groupId}:${channel.id}`
+            : `${this.keyPrefix}events:${this.streamName}:${channel.groupId}`;
+        await this.client.publish(channelKey, JSON.stringify(event));
+    }
+    async clear(groupId) {
+        const hashKey = this.makeGroupKey(groupId);
+        await this.client.del(hashKey);
+    }
+}
+exports.RedisTraceStreamAdapter = RedisTraceStreamAdapter;

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

@@ -0,0 +1,23 @@
+import type { Logger } from '../logger';
+import type { Step } from '../types';
+import type { Tracer } from '.';
+import type { TraceManager } from './trace-manager';
+import type { StateOperation, StreamOperation, Trace, TraceError, TraceGroup } from './types';
+export declare class StreamTracer implements Tracer {
+    private readonly manager;
+    private readonly traceGroup;
+    private readonly trace;
+    constructor(manager: TraceManager, traceGroup: TraceGroup, trace: Trace, logger: Logger);
+    end(err?: TraceError): Promise<void>;
+    private recomputeTraceGroupStatus;
+    stateOperation(operation: StateOperation, input: unknown): Promise<void>;
+    emitOperation(topic: string, data: unknown, success: boolean): Promise<void>;
+    streamOperation(streamName: string, operation: StreamOperation, input: {
+        groupId: string;
+        id: string;
+        data?: unknown;
+    }): Promise<void>;
+    child(step: Step, logger: Logger): StreamTracer;
+    private addEvent;
+}
+//# sourceMappingURL=stream-tracer.d.ts.map

package/dist/src/observability/stream-tracer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-tracer.d.ts","sourceRoot":"","sources":["../../../src/observability/stream-tracer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AACvC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,UAAU,CAAA;AACpC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,CAAA;AAE/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,KAAK,EAAE,UAAU,EAAc,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzG,qBAAa,YAAa,YAAW,MAAM;IAEvC,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,KAAK;gBAFL,OAAO,EAAE,YAAY,EACrB,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,KAAK,EAC7B,MAAM,EAAE,MAAM;IAaV,GAAG,CAAC,GAAG,CAAC,EAAE,UAAU;YAcZ,yBAAyB;IA+BjC,cAAc,CAAC,SAAS,EAAE,cAAc,EAAE,KAAK,EAAE,OAAO;IASxD,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO;IAU5D,eAAe,CACnB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,eAAe,EAC1B,KAAK,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE;IAkCxD,KAAK,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM;YAOlB,QAAQ;CAOvB"}

package/dist/src/observability/stream-tracer.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamTracer = void 0;
+const create_trace_1 = require("./create-trace");
+class StreamTracer {
+    constructor(manager, traceGroup, trace, logger) {
+        this.manager = manager;
+        this.traceGroup = traceGroup;
+        this.trace = trace;
+        logger.addListener(async (level, msg, args) => {
+            await this.addEvent({
+                type: 'log',
+                timestamp: Date.now(),
+                level,
+                message: msg,
+                metadata: args,
+            });
+        });
+    }
+    async end(err) {
+        if (this.trace.endTime) {
+            return;
+        }
+        this.trace.status = err ? 'failed' : 'completed';
+        this.trace.endTime = Date.now();
+        this.trace.error = err;
+        await this.manager.updateTrace();
+        await this.recomputeTraceGroupStatus();
+        await this.manager.updateTraceGroup();
+    }
+    async recomputeTraceGroupStatus() {
+        const allTracesFromStorage = await this.manager.getAllTracesForGroup();
+        const currentTraceIndex = allTracesFromStorage.findIndex((t) => t.id === this.trace.id);
+        const allTraces = [...allTracesFromStorage];
+        if (currentTraceIndex >= 0) {
+            allTraces[currentTraceIndex] = this.trace;
+        }
+        else {
+            allTraces.push(this.trace);
+        }
+        const completedCount = allTraces.filter((t) => t.status === 'completed').length;
+        const failedCount = allTraces.filter((t) => t.status === 'failed').length;
+        const runningCount = allTraces.filter((t) => t.status === 'running').length;
+        this.traceGroup.metadata.completedSteps = completedCount;
+        this.traceGroup.metadata.activeSteps = runningCount;
+        if (failedCount > 0) {
+            this.traceGroup.status = 'failed';
+        }
+        else if (runningCount === 0 && completedCount > 0) {
+            this.traceGroup.status = 'completed';
+            if (!this.traceGroup.endTime) {
+                this.traceGroup.endTime = Date.now();
+            }
+        }
+        else {
+            this.traceGroup.status = 'running';
+        }
+    }
+    async stateOperation(operation, input) {
+        await this.addEvent({
+            type: 'state',
+            timestamp: Date.now(),
+            operation,
+            data: input,
+        });
+    }
+    async emitOperation(topic, data, success) {
+        await this.addEvent({
+            type: 'emit',
+            timestamp: Date.now(),
+            topic,
+            success,
+            data,
+        });
+    }
+    async streamOperation(streamName, operation, input) {
+        if (operation === 'set') {
+            const lastEvent = this.trace.events[this.trace.events.length - 1];
+            if (lastEvent &&
+                lastEvent.type === 'stream' &&
+                lastEvent.streamName === streamName &&
+                lastEvent.data.groupId === input.groupId &&
+                lastEvent.data.id === input.id) {
+                lastEvent.calls++;
+                lastEvent.data.data = input.data;
+                lastEvent.maxTimestamp = Date.now();
+                this.traceGroup.lastActivity = lastEvent.maxTimestamp;
+                await this.manager.updateTrace();
+                await this.manager.updateTraceGroup();
+                return;
+            }
+        }
+        await this.addEvent({
+            type: 'stream',
+            timestamp: Date.now(),
+            operation,
+            data: input,
+            streamName,
+            calls: 1,
+        });
+    }
+    child(step, logger) {
+        const trace = (0, create_trace_1.createTrace)(this.traceGroup, step);
+        const manager = this.manager.child(trace);
+        return new StreamTracer(manager, this.traceGroup, trace, logger);
+    }
+    async addEvent(event) {
+        this.trace.events.push(event);
+        this.traceGroup.lastActivity = event.timestamp;
+        await this.manager.updateTrace();
+        await this.manager.updateTraceGroup();
+    }
+}
+exports.StreamTracer = StreamTracer;

package/dist/src/observability/trace-manager.d.ts

@@ -0,0 +1,14 @@
+import type { MotiaStream } from '../types-stream';
+import type { Trace, TraceGroup } from './types';
+export declare class TraceManager {
+    private readonly traceStream;
+    private readonly traceGroupStream;
+    private readonly traceGroup;
+    private readonly trace;
+    constructor(traceStream: MotiaStream<Trace>, traceGroupStream: MotiaStream<TraceGroup>, traceGroup: TraceGroup, trace: Trace);
+    updateTrace(): Promise<void>;
+    updateTraceGroup(): Promise<void>;
+    getAllTracesForGroup(): Promise<Trace[]>;
+    child(trace: Trace): TraceManager;
+}
+//# sourceMappingURL=trace-manager.d.ts.map

package/dist/src/observability/trace-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-manager.d.ts","sourceRoot":"","sources":["../../../src/observability/trace-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAClD,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEhD,qBAAa,YAAY;IAErB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,KAAK;gBAHL,WAAW,EAAE,WAAW,CAAC,KAAK,CAAC,EAC/B,gBAAgB,EAAE,WAAW,CAAC,UAAU,CAAC,EACzC,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,KAAK;IAMzB,WAAW;IAIX,gBAAgB;IAIhB,oBAAoB,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;IAI9C,KAAK,CAAC,KAAK,EAAE,KAAK;CAGnB"}

package/dist/src/observability/trace-manager.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraceManager = void 0;
+class TraceManager {
+    constructor(traceStream, traceGroupStream, traceGroup, trace) {
+        this.traceStream = traceStream;
+        this.traceGroupStream = traceGroupStream;
+        this.traceGroup = traceGroup;
+        this.trace = trace;
+        this.updateTrace().catch(() => { });
+        this.updateTraceGroup().catch(() => { });
+    }
+    async updateTrace() {
+        await this.traceStream.set(this.traceGroup.id, this.trace.id, this.trace);
+    }
+    async updateTraceGroup() {
+        await this.traceGroupStream.set('default', this.traceGroup.id, this.traceGroup);
+    }
+    async getAllTracesForGroup() {
+        return await this.traceStream.getGroup(this.traceGroup.id);
+    }
+    child(trace) {
+        return new TraceManager(this.traceStream, this.traceGroupStream, this.traceGroup, trace);
+    }
+}
+exports.TraceManager = TraceManager;

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

@@ -0,0 +1,19 @@
+import type { LockedData } from '../locked-data';
+import type { Logger } from '../logger';
+import type { Step } from '../types';
+import type { MotiaStream } from '../types-stream';
+import type { TracerFactory } from '.';
+import { StreamTracer } from './stream-tracer';
+import type { Trace, TraceGroup } from './types';
+export declare class BaseTracerFactory implements TracerFactory {
+    private readonly traceStream;
+    private readonly traceGroupStream;
+    constructor(traceStream: MotiaStream<Trace>, traceGroupStream: MotiaStream<TraceGroup>);
+    private getAllGroups;
+    private deleteGroup;
+    clear(): Promise<void>;
+    createTracer(traceId: string, step: Step, logger: Logger): Promise<StreamTracer>;
+    attachToTrace(traceId: string, step: Step, logger: Logger): Promise<StreamTracer>;
+}
+export declare const createTracerFactory: (lockedData: LockedData) => TracerFactory;
+//# sourceMappingURL=tracer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tracer.d.ts","sourceRoot":"","sources":["../../../src/observability/tracer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AACvC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,UAAU,CAAA;AACpC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAClD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,GAAG,CAAA;AAGtC,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAE9C,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEhD,qBAAa,iBAAkB,YAAW,aAAa;IAEnD,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,gBAAgB;gBADhB,WAAW,EAAE,WAAW,CAAC,KAAK,CAAC,EAC/B,gBAAgB,EAAE,WAAW,CAAC,UAAU,CAAC;YAG9C,YAAY;YAIZ,WAAW;IASnB,KAAK;IAQL,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM;IAqBxD,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM;CAYhE;AAED,eAAO,MAAM,mBAAmB,GAAI,YAAY,UAAU,KAAG,aAqC5D,CAAA"}

package/dist/src/observability/tracer.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTracerFactory = exports.BaseTracerFactory = void 0;
+const create_trace_1 = require("./create-trace");
+const redis_trace_stream_adapter_1 = require("./redis-trace-stream-adapter");
+const stream_tracer_1 = require("./stream-tracer");
+const trace_manager_1 = require("./trace-manager");
+class BaseTracerFactory {
+    constructor(traceStream, traceGroupStream) {
+        this.traceStream = traceStream;
+        this.traceGroupStream = traceGroupStream;
+    }
+    async getAllGroups() {
+        return await this.traceGroupStream.getGroup('default');
+    }
+    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 clear() {
+        const groups = await this.getAllGroups();
+        for (const group of groups) {
+            await this.deleteGroup(group);
+        }
+    }
+    async createTracer(traceId, step, logger) {
+        const traceGroup = {
+            id: traceId,
+            name: step.config.name,
+            lastActivity: Date.now(),
+            metadata: {
+                completedSteps: 0,
+                activeSteps: 0,
+                totalSteps: 0,
+            },
+            correlationId: undefined,
+            status: 'running',
+            startTime: Date.now(),
+        };
+        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);
+    }
+    async attachToTrace(traceId, step, logger) {
+        const existingGroup = await this.traceGroupStream.get('default', traceId);
+        if (!existingGroup) {
+            return this.createTracer(traceId, step, logger);
+        }
+        const trace = (0, create_trace_1.createTrace)(existingGroup, step);
+        const manager = new trace_manager_1.TraceManager(this.traceStream, this.traceGroupStream, existingGroup, trace);
+        return new stream_tracer_1.StreamTracer(manager, existingGroup, trace, logger);
+    }
+}
+exports.BaseTracerFactory = BaseTracerFactory;
+const createTracerFactory = (lockedData) => {
+    if (!lockedData.redisClient) {
+        throw new Error('Redis client is required for tracer factory. Please provide a redisClient when creating LockedData.');
+    }
+    const traceStreamName = 'motia-trace';
+    const traceStreamAdapter = new redis_trace_stream_adapter_1.RedisTraceStreamAdapter(traceStreamName, lockedData.redisClient);
+    const traceStream = lockedData.createStream({
+        filePath: traceStreamName,
+        hidden: true,
+        config: {
+            name: traceStreamName,
+            baseConfig: { storageType: 'custom', factory: () => traceStreamAdapter },
+            schema: null,
+        },
+    })();
+    const traceGroupName = 'motia-trace-group';
+    const traceGroupStreamAdapter = new redis_trace_stream_adapter_1.RedisTraceStreamAdapter(traceGroupName, lockedData.redisClient);
+    const traceGroupStream = lockedData.createStream({
+        filePath: traceGroupName,
+        hidden: true,
+        config: {
+            name: traceGroupName,
+            baseConfig: { storageType: 'custom', factory: () => traceGroupStreamAdapter },
+            schema: null,
+        },
+    })();
+    return new BaseTracerFactory(traceStream, traceGroupStream);
+};
+exports.createTracerFactory = createTracerFactory;

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

@@ -0,0 +1,75 @@
+import type { StepConfig } from '../types';
+export interface TraceGroup {
+    id: string;
+    correlationId: string | undefined;
+    name: string;
+    status: 'running' | 'completed' | 'failed';
+    startTime: number;
+    endTime?: number;
+    lastActivity: number;
+    metadata: {
+        completedSteps: number;
+        activeSteps: number;
+        totalSteps: number;
+    };
+}
+export type TraceError = {
+    message: string;
+    code?: string | number;
+    stack?: string;
+};
+export interface Trace {
+    id: string;
+    name: string;
+    correlationId?: string;
+    parentTraceId?: string;
+    status: 'running' | 'completed' | 'failed';
+    startTime: number;
+    endTime?: number;
+    error?: TraceError;
+    entryPoint: {
+        type: StepConfig['type'];
+        stepName: string;
+    };
+    events: TraceEvent[];
+}
+export type TraceEvent = StateEvent | EmitEvent | StreamEvent | LogEntry;
+export type StateOperation = 'get' | 'getGroup' | 'set' | 'delete' | 'clear';
+export type StreamOperation = 'get' | 'getGroup' | 'set' | 'delete' | 'clear' | 'send';
+export interface StateEvent {
+    type: 'state';
+    timestamp: number;
+    operation: 'get' | 'getGroup' | 'set' | 'delete' | 'clear';
+    key?: string;
+    duration?: number;
+    data: unknown;
+}
+export interface EmitEvent {
+    type: 'emit';
+    timestamp: number;
+    topic: string;
+    success: boolean;
+    data: unknown;
+}
+export interface StreamEvent {
+    type: 'stream';
+    timestamp: number;
+    operation: StreamOperation;
+    streamName: string;
+    duration?: number;
+    maxTimestamp?: number;
+    data: {
+        groupId: string;
+        id: string;
+        data?: unknown;
+    };
+    calls: number;
+}
+export interface LogEntry {
+    type: 'log';
+    timestamp: number;
+    level: string;
+    message: string;
+    metadata?: unknown;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/observability/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/observability/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAE1C,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAA;IACV,aAAa,EAAE,MAAM,GAAG,SAAS,CAAA;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,SAAS,GAAG,WAAW,GAAG,QAAQ,CAAA;IAC1C,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,YAAY,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE;QACR,cAAc,EAAE,MAAM,CAAA;QACtB,WAAW,EAAE,MAAM,CAAA;QACnB,UAAU,EAAE,MAAM,CAAA;KACnB,CAAA;CACF;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACtB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED,MAAM,WAAW,KAAK;IACpB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,MAAM,EAAE,SAAS,GAAG,WAAW,GAAG,QAAQ,CAAA;IAC1C,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,UAAU,CAAA;IAClB,UAAU,EAAE;QAAE,IAAI,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAA;IAC1D,MAAM,EAAE,UAAU,EAAE,CAAA;CACrB;AAED,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,CAAA;AAExE,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,UAAU,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,CAAA;AAC5E,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,UAAU,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,CAAA;AAEtF,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,OAAO,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,KAAK,GAAG,UAAU,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,CAAA;IAC1D,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,OAAO,CAAA;CACd;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,OAAO,CAAA;IAChB,IAAI,EAAE,OAAO,CAAA;CACd;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,QAAQ,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,eAAe,CAAA;IAC1B,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,CAAA;IACrD,KAAK,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,KAAK,CAAA;IACX,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB"}

package/dist/src/observability/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/pretty-print.d.ts

@@ -0,0 +1,2 @@
+export declare const prettyPrint: (json: Record<string, any>, excludeDetails?: boolean) => void;
+//# sourceMappingURL=pretty-print.d.ts.map

package/dist/src/pretty-print.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pretty-print.d.ts","sourceRoot":"","sources":["../../src/pretty-print.ts"],"names":[],"mappings":"AA0DA,eAAO,MAAM,WAAW,GAAI,MAAM,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,wBAAsB,KAAG,IAW/E,CAAA"}

package/dist/src/pretty-print.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prettyPrint = void 0;
+const picocolors_1 = __importDefault(require("picocolors"));
+const stepTag = (step) => picocolors_1.default.bold(picocolors_1.default.cyan(step));
+const timestampTag = (timestamp) => picocolors_1.default.gray(timestamp);
+const traceIdTag = (traceId) => picocolors_1.default.gray(traceId);
+const levelTags = {
+    error: picocolors_1.default.red('[ERROR]'),
+    info: picocolors_1.default.blue('[INFO]'),
+    warn: picocolors_1.default.yellow('[WARN]'),
+    debug: picocolors_1.default.gray('[DEBUG]'),
+    trace: picocolors_1.default.gray('[TRACE]'),
+};
+const numericTag = (value) => picocolors_1.default.green(value);
+const stringTag = (value) => picocolors_1.default.cyan(value);
+const booleanTag = (value) => picocolors_1.default.blue(value);
+const arrayBrackets = ['[', ']'].map((s) => picocolors_1.default.gray(s));
+const objectBrackets = ['{', '}'].map((s) => picocolors_1.default.gray(s));
+const prettyPrintObject = (obj, depth = 0, parentIsLast = false, prefix = '') => {
+    const tab = prefix + (depth === 0 ? '' : parentIsLast ? '│ ' : '│ ');
+    if (depth > 2) {
+        return `${tab} └ ${picocolors_1.default.gray('[...]')}`;
+    }
+    const entries = Object.entries(obj);
+    return entries
+        .map(([key, value], index) => {
+        const isLast = index === entries.length - 1;
+        const isObject = typeof value === 'object' && value !== null;
+        const prefix = isLast && !isObject ? '└' : '├';
+        if (isObject) {
+            const subObject = prettyPrintObject(value, depth + 1, isLast, tab);
+            const [start, end] = Array.isArray(value) ? arrayBrackets : objectBrackets;
+            return `${tab}${prefix} ${key}: ${start}\n${subObject}\n${tab}${isLast ? '└' : '│'} ${end}`;
+        }
+        let printedValue = value;
+        if (typeof value === 'number') {
+            printedValue = numericTag(String(value));
+        }
+        else if (typeof value === 'boolean') {
+            printedValue = booleanTag(String(value));
+        }
+        else if (typeof value === 'string') {
+            printedValue = stringTag(value);
+        }
+        return `${tab}${prefix} ${key}: ${printedValue}`;
+    })
+        .join('\n');
+};
+const prettyPrint = (json, excludeDetails = false) => {
+    const { time, traceId, msg, flows, level, step, ...details } = json;
+    const levelTag = levelTags[level];
+    const timestamp = timestampTag(`[${new Date(time).toLocaleTimeString()}]`);
+    const objectHasKeys = Object.keys(details).length > 0;
+    console.log(`${timestamp} ${traceIdTag(traceId)} ${levelTag} ${stepTag(step)} ${msg}`);
+    if (objectHasKeys && !excludeDetails) {
+        console.log(prettyPrintObject(details));
+    }
+};
+exports.prettyPrint = prettyPrint;