@forgehive/task 0.2.2 → 0.2.4

package/dist/test/listen-execution-records.test.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+describe('Task.listenExecutionRecords', () => {
+    let mockListener;
+    let consoleErrorSpy;
+    beforeEach(() => {
+        mockListener = jest.fn();
+        consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
+        // Clear any existing global listener
+        index_1.Task.globalListener = undefined;
+    });
+    afterEach(() => {
+        // Clean up global listener after each test
+        index_1.Task.globalListener = undefined;
+        consoleErrorSpy.mockRestore();
+    });
+    describe('static listenExecutionRecords method', () => {
+        it('should set global listener', () => {
+            index_1.Task.listenExecutionRecords(mockListener);
+            expect(index_1.Task.globalListener).toBe(mockListener);
+        });
+        it('should replace existing global listener', () => {
+            const firstListener = jest.fn();
+            const secondListener = jest.fn();
+            index_1.Task.listenExecutionRecords(firstListener);
+            expect(index_1.Task.globalListener).toBe(firstListener);
+            index_1.Task.listenExecutionRecords(secondListener);
+            expect(index_1.Task.globalListener).toBe(secondListener);
+        });
+    });
+    describe('global listener execution', () => {
+        it('should call global listener when task is executed via safeRun', async () => {
+            index_1.Task.listenExecutionRecords(mockListener);
+            const schema = new index_1.Schema({
+                value: index_1.Schema.number()
+            });
+            const testTask = (0, index_1.createTask)({
+                schema,
+                boundaries: {},
+                fn: async (input) => ({ result: input.value * 2 })
+            });
+            await testTask.safeRun({ value: 5 });
+            await new Promise(resolve => process.nextTick(resolve));
+            expect(mockListener).toHaveBeenCalledTimes(1);
+            expect(mockListener).toHaveBeenCalledWith(expect.objectContaining({
+                input: { value: 5 },
+                output: { result: 10 },
+                type: 'success'
+            }));
+        });
+        it('should call global listener when task is executed via run', async () => {
+            index_1.Task.listenExecutionRecords(mockListener);
+            const schema = new index_1.Schema({
+                value: index_1.Schema.number()
+            });
+            const testTask = (0, index_1.createTask)({
+                schema,
+                boundaries: {},
+                fn: async (input) => ({ result: input.value * 2 })
+            });
+            await testTask.run({ value: 3 });
+            await new Promise(resolve => process.nextTick(resolve));
+            expect(mockListener).toHaveBeenCalledTimes(1);
+            expect(mockListener).toHaveBeenCalledWith(expect.objectContaining({
+                input: { value: 3 },
+                output: { result: 6 },
+                type: 'success'
+            }));
+        });
+        it('should call global listener when task fails', async () => {
+            index_1.Task.listenExecutionRecords(mockListener);
+            const schema = new index_1.Schema({});
+            const errorTask = (0, index_1.createTask)({
+                schema,
+                boundaries: {},
+                fn: async () => {
+                    throw new Error('Test error');
+                }
+            });
+            await errorTask.safeRun({});
+            await new Promise(resolve => process.nextTick(resolve));
+            expect(mockListener).toHaveBeenCalledTimes(1);
+            expect(mockListener).toHaveBeenCalledWith(expect.objectContaining({
+                input: {},
+                error: 'Test error',
+                type: 'error'
+            }));
+        });
+        it('should call both instance and global listeners', async () => {
+            const instanceListener = jest.fn();
+            index_1.Task.listenExecutionRecords(mockListener);
+            const schema = new index_1.Schema({
+                value: index_1.Schema.number()
+            });
+            const testTask = (0, index_1.createTask)({
+                schema,
+                boundaries: {},
+                fn: async (input) => ({ result: input.value * 2 })
+            });
+            testTask.addListener(instanceListener);
+            await testTask.safeRun({ value: 7 });
+            await new Promise(resolve => process.nextTick(resolve));
+            expect(instanceListener).toHaveBeenCalledTimes(1);
+            expect(mockListener).toHaveBeenCalledTimes(1);
+            const expectedRecord = expect.objectContaining({
+                input: { value: 7 },
+                output: { result: 14 },
+                type: 'success'
+            });
+            expect(instanceListener).toHaveBeenCalledWith(expectedRecord);
+            expect(mockListener).toHaveBeenCalledWith(expectedRecord);
+        });
+        it('should work when no global listener is set', async () => {
+            // No global listener set
+            const schema = new index_1.Schema({
+                value: index_1.Schema.number()
+            });
+            const testTask = (0, index_1.createTask)({
+                schema,
+                boundaries: {},
+                fn: async (input) => ({ result: input.value * 2 })
+            });
+            // Should not throw error
+            await expect(testTask.safeRun({ value: 1 })).resolves.toBeDefined();
+        });
+    });
+    describe('async listener support', () => {
+        it('should support async global listeners', async () => {
+            const asyncListener = jest.fn().mockImplementation(async (_record) => {
+                await new Promise(resolve => setTimeout(resolve, 10));
+                return Promise.resolve();
+            });
+            index_1.Task.listenExecutionRecords(asyncListener);
+            const schema = new index_1.Schema({
+                value: index_1.Schema.number()
+            });
+            const testTask = (0, index_1.createTask)({
+                schema,
+                boundaries: {},
+                fn: async (input) => ({ result: input.value * 2 })
+            });
+            await testTask.safeRun({ value: 4 });
+            await new Promise(resolve => process.nextTick(resolve));
+            expect(asyncListener).toHaveBeenCalledTimes(1);
+            expect(asyncListener).toHaveBeenCalledWith(expect.objectContaining({
+                input: { value: 4 },
+                output: { result: 8 },
+                type: 'success'
+            }));
+        });
+        it('should handle long-running async listeners without blocking task execution', async () => {
+            const slowListener = jest.fn().mockImplementation(async () => {
+                await new Promise(resolve => setTimeout(resolve, 100)); // 100ms
+            });
+            index_1.Task.listenExecutionRecords(slowListener);
+            const schema = new index_1.Schema({
+                value: index_1.Schema.number()
+            });
+            const testTask = (0, index_1.createTask)({
+                schema,
+                boundaries: {},
+                fn: async (input) => ({ result: input.value * 2 })
+            });
+            const startTime = Date.now();
+            await testTask.safeRun({ value: 1 });
+            const endTime = Date.now();
+            // Task should complete quickly without waiting for listener
+            expect(endTime - startTime).toBeLessThan(50); // Should complete in under 50ms
+            // Wait for next tick to ensure listener was called
+            await new Promise(resolve => process.nextTick(resolve));
+            expect(slowListener).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('error handling', () => {
+        it('should catch and log listener errors without affecting task execution', async () => {
+            const errorListener = jest.fn().mockImplementation(() => {
+                throw new Error('Listener error');
+            });
+            index_1.Task.listenExecutionRecords(errorListener);
+            const schema = new index_1.Schema({
+                value: index_1.Schema.number()
+            });
+            const testTask = (0, index_1.createTask)({
+                schema,
+                boundaries: {},
+                fn: async (input) => ({ result: input.value * 2 })
+            });
+            const [result, error] = await testTask.safeRun({ value: 5 });
+            await new Promise(resolve => process.nextTick(resolve));
+            // Task should complete successfully despite listener error
+            expect(result).toEqual({ result: 10 });
+            expect(error).toBeNull();
+            // Listener should have been called
+            expect(errorListener).toHaveBeenCalledTimes(1);
+            // Error should have been logged
+            expect(consoleErrorSpy).toHaveBeenCalledWith('ExecutionRecord listener error:', expect.any(Error));
+        });
+        it('should catch and log async listener errors', async () => {
+            const asyncErrorListener = jest.fn().mockImplementation(async () => {
+                throw new Error('Async listener error');
+            });
+            index_1.Task.listenExecutionRecords(asyncErrorListener);
+            const schema = new index_1.Schema({
+                value: index_1.Schema.number()
+            });
+            const testTask = (0, index_1.createTask)({
+                schema,
+                boundaries: {},
+                fn: async (input) => ({ result: input.value * 2 })
+            });
+            const [result, error] = await testTask.safeRun({ value: 3 });
+            // Wait a bit for the async error to be logged
+            await new Promise(resolve => setTimeout(resolve, 50));
+            // Task should complete successfully
+            expect(result).toEqual({ result: 6 });
+            expect(error).toBeNull();
+            // Error should have been logged
+            expect(consoleErrorSpy).toHaveBeenCalledWith('ExecutionRecord listener error:', expect.any(Error));
+        });
+    });
+});
+//# sourceMappingURL=listen-execution-records.test.js.map

package/dist/test/listen-execution-records.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"listen-execution-records.test.js","sourceRoot":"","sources":["../../src/test/listen-execution-records.test.ts"],"names":[],"mappings":"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"}

package/dist/test/metrics-collection.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=metrics-collection.test.d.ts.map

package/dist/test/metrics-collection.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics-collection.test.d.ts","sourceRoot":"","sources":["../../src/test/metrics-collection.test.ts"],"names":[],"mappings":""}

package/dist/test/metrics-collection.test.js

@@ -0,0 +1,409 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+const schema_1 = require("@forgehive/schema");
+describe('Metrics Collection Tests', () => {
+    describe('setMetrics boundary functionality and validation', () => {
+        it('should validate metrics with correct structure', () => {
+            const validMetric = { type: 'business', name: 'user_count', value: 42 };
+            expect((0, index_1.validateMetric)(validMetric)).toBe(true);
+            const performanceMetric = { type: 'performance', name: 'response_time', value: 150.5 };
+            expect((0, index_1.validateMetric)(performanceMetric)).toBe(true);
+            const errorMetric = { type: 'error', name: 'failed_requests', value: 0 };
+            expect((0, index_1.validateMetric)(errorMetric)).toBe(true);
+        });
+        it('should reject invalid metric structures', () => {
+            expect((0, index_1.validateMetric)(null)).toBe(false);
+            expect((0, index_1.validateMetric)(undefined)).toBe(false);
+            expect((0, index_1.validateMetric)({})).toBe(false);
+            expect((0, index_1.validateMetric)({ type: 'business' })).toBe(false); // missing name and value
+            expect((0, index_1.validateMetric)({ name: 'test', value: 1 })).toBe(false); // missing type
+            expect((0, index_1.validateMetric)({ type: 'business', name: 'test' })).toBe(false); // missing value
+        });
+        it('should reject metrics with invalid types', () => {
+            expect((0, index_1.validateMetric)({ type: '', name: 'test', value: 1 })).toBe(false); // empty type
+            expect((0, index_1.validateMetric)({ type: 123, name: 'test', value: 1 })).toBe(false); // numeric type
+            expect((0, index_1.validateMetric)({ type: 'business', name: '', value: 1 })).toBe(false); // empty name
+            expect((0, index_1.validateMetric)({ type: 'business', name: 123, value: 1 })).toBe(false); // numeric name
+            expect((0, index_1.validateMetric)({ type: 'business', name: 'test', value: 'not-a-number' })).toBe(false); // string value
+            expect((0, index_1.validateMetric)({ type: 'business', name: 'test', value: NaN })).toBe(false); // NaN value
+            expect((0, index_1.validateMetric)({ type: 'business', name: 'test', value: Infinity })).toBe(false); // Infinity value
+        });
+        it('should create valid metrics using createMetric helper', () => {
+            const metric = (0, index_1.createMetric)('performance', 'api_response_time', 250);
+            expect(metric).toEqual({
+                type: 'performance',
+                name: 'api_response_time',
+                value: 250
+            });
+            expect((0, index_1.validateMetric)(metric)).toBe(true);
+        });
+        it('should throw error when creating metric with invalid data', () => {
+            expect(() => (0, index_1.createMetric)('', 'test', 1)).toThrow('Invalid metric');
+            expect(() => (0, index_1.createMetric)('business', '', 1)).toThrow('Invalid metric');
+            expect(() => (0, index_1.createMetric)('business', 'test', NaN)).toThrow('Invalid metric');
+            expect(() => (0, index_1.createMetric)('business', 'test', Infinity)).toThrow('Invalid metric');
+        });
+    });
+    describe('Metrics accumulation and storage in execution records', () => {
+        it('should collect single metric in execution record', async () => {
+            var _a;
+            const task = (0, index_1.createTask)({
+                name: 'single-metric-test',
+                schema: new schema_1.Schema({ input: schema_1.Schema.string() }),
+                boundaries: {},
+                fn: async ({ input }, { setMetrics }) => {
+                    await setMetrics({
+                        type: 'business',
+                        name: 'items_processed',
+                        value: 1
+                    });
+                    return { result: input.toUpperCase() };
+                }
+            });
+            const [result, error, record] = await task.safeRun({ input: 'test' });
+            expect(error).toBeNull();
+            expect(result).toEqual({ result: 'TEST' });
+            expect(record.metrics).toHaveLength(1);
+            expect((_a = record.metrics) === null || _a === void 0 ? void 0 : _a[0]).toEqual({
+                type: 'business',
+                name: 'items_processed',
+                value: 1
+            });
+        });
+        it('should accumulate multiple metrics in execution record', async () => {
+            const task = (0, index_1.createTask)({
+                name: 'multiple-metrics-test',
+                schema: new schema_1.Schema({ count: schema_1.Schema.number() }),
+                boundaries: {},
+                fn: async ({ count }, { setMetrics }) => {
+                    await setMetrics({ type: 'business', name: 'input_count', value: count });
+                    await setMetrics({ type: 'performance', name: 'processing_time', value: 150 });
+                    await setMetrics({ type: 'error', name: 'error_count', value: 0 });
+                    return { processed: count * 2 };
+                }
+            });
+            const [result, error, record] = await task.safeRun({ count: 5 });
+            expect(error).toBeNull();
+            expect(result).toEqual({ processed: 10 });
+            expect(record.metrics).toHaveLength(3);
+            expect(record.metrics).toEqual(expect.arrayContaining([
+                { type: 'business', name: 'input_count', value: 5 },
+                { type: 'performance', name: 'processing_time', value: 150 },
+                { type: 'error', name: 'error_count', value: 0 }
+            ]));
+        });
+        it('should allow duplicate metric names with different values', async () => {
+            const task = (0, index_1.createTask)({
+                name: 'duplicate-metrics-test',
+                schema: new schema_1.Schema({ iterations: schema_1.Schema.number() }),
+                boundaries: {},
+                fn: async ({ iterations }, { setMetrics }) => {
+                    for (let i = 0; i < iterations; i++) {
+                        await setMetrics({
+                            type: 'performance',
+                            name: 'iteration_time',
+                            value: (i + 1) * 10
+                        });
+                    }
+                    return { completed: iterations };
+                }
+            });
+            const [result, error, record] = await task.safeRun({ iterations: 3 });
+            expect(error).toBeNull();
+            expect(result).toEqual({ completed: 3 });
+            expect(record.metrics).toHaveLength(3);
+            expect(record.metrics).toEqual([
+                { type: 'performance', name: 'iteration_time', value: 10 },
+                { type: 'performance', name: 'iteration_time', value: 20 },
+                { type: 'performance', name: 'iteration_time', value: 30 }
+            ]);
+        });
+        it('should collect metrics from boundaries and main function', async () => {
+            const task = (0, index_1.createTask)({
+                name: 'boundary-metrics-test',
+                schema: new schema_1.Schema({ input: schema_1.Schema.string() }),
+                boundaries: {
+                    processData: async (data) => {
+                        return data.length;
+                    }
+                },
+                fn: async ({ input }, { processData, setMetrics }) => {
+                    await setMetrics({ type: 'business', name: 'requests', value: 1 });
+                    const length = await processData(input);
+                    await setMetrics({ type: 'business', name: 'input_length', value: length });
+                    return { length };
+                }
+            });
+            const [result, error, record] = await task.safeRun({ input: 'hello world' });
+            expect(error).toBeNull();
+            expect(result).toEqual({ length: 11 });
+            expect(record.metrics).toHaveLength(2);
+            expect(record.metrics).toEqual(expect.arrayContaining([
+                { type: 'business', name: 'requests', value: 1 },
+                { type: 'business', name: 'input_length', value: 11 }
+            ]));
+        });
+    });
+    describe('Metrics behavior in error scenarios', () => {
+        it('should preserve metrics collected before error occurs', async () => {
+            const task = (0, index_1.createTask)({
+                name: 'error-metrics-test',
+                schema: new schema_1.Schema({ shouldFail: schema_1.Schema.boolean() }),
+                boundaries: {},
+                fn: async ({ shouldFail }, { setMetrics }) => {
+                    await setMetrics({ type: 'business', name: 'attempt_count', value: 1 });
+                    await setMetrics({ type: 'performance', name: 'preparation_time', value: 50 });
+                    if (shouldFail) {
+                        await setMetrics({ type: 'error', name: 'failure_count', value: 1 });
+                        throw new Error('Intentional failure');
+                    }
+                    return { success: true };
+                }
+            });
+            const [result, error, record] = await task.safeRun({ shouldFail: true });
+            expect(result).toBeNull();
+            expect(error).not.toBeNull();
+            expect(record.type).toBe('error');
+            expect(record.metrics).toHaveLength(3);
+            expect(record.metrics).toEqual(expect.arrayContaining([
+                { type: 'business', name: 'attempt_count', value: 1 },
+                { type: 'performance', name: 'preparation_time', value: 50 },
+                { type: 'error', name: 'failure_count', value: 1 }
+            ]));
+        });
+        it('should handle boundary errors while preserving metrics', async () => {
+            const task = (0, index_1.createTask)({
+                name: 'boundary-error-metrics-test',
+                schema: new schema_1.Schema({ input: schema_1.Schema.string() }),
+                boundaries: {
+                    failingBoundary: async (data) => {
+                        throw new Error(`Boundary failed for: ${data}`);
+                    }
+                },
+                fn: async ({ input }, { failingBoundary, setMetrics }) => {
+                    await setMetrics({ type: 'business', name: 'attempts', value: 1 });
+                    try {
+                        await failingBoundary(input);
+                    }
+                    catch (error) {
+                        await setMetrics({ type: 'error', name: 'boundary_failures', value: 1 });
+                        throw error;
+                    }
+                    return { success: true };
+                }
+            });
+            const [result, error, record] = await task.safeRun({ input: 'test' });
+            expect(result).toBeNull();
+            expect(error).not.toBeNull();
+            expect(record.type).toBe('error');
+            expect(record.metrics).toHaveLength(2);
+            expect(record.metrics).toEqual(expect.arrayContaining([
+                { type: 'business', name: 'attempts', value: 1 },
+                { type: 'error', name: 'boundary_failures', value: 1 }
+            ]));
+        });
+        it('should reject invalid metrics and continue execution', async () => {
+            const task = (0, index_1.createTask)({
+                name: 'invalid-metrics-test',
+                schema: new schema_1.Schema({ input: schema_1.Schema.string() }),
+                boundaries: {},
+                fn: async ({ input }, { setMetrics }) => {
+                    // Valid metric should be stored
+                    await setMetrics({ type: 'business', name: 'valid_metric', value: 1 });
+                    // Invalid metrics should be rejected but not crash the task
+                    try {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        await setMetrics({ type: '', name: 'invalid', value: 1 });
+                    }
+                    catch (error) {
+                        // Expected to fail validation
+                    }
+                    try {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        await setMetrics({ type: 'business', name: 'invalid', value: NaN });
+                    }
+                    catch (error) {
+                        // Expected to fail validation
+                    }
+                    // Another valid metric should still work
+                    await setMetrics({ type: 'performance', name: 'final_metric', value: 100 });
+                    return { result: input };
+                }
+            });
+            const [result, error, record] = await task.safeRun({ input: 'test' });
+            expect(error).toBeNull();
+            expect(result).toEqual({ result: 'test' });
+            expect(record.metrics).toHaveLength(2); // Only valid metrics should be stored
+            expect(record.metrics).toEqual(expect.arrayContaining([
+                { type: 'business', name: 'valid_metric', value: 1 },
+                { type: 'performance', name: 'final_metric', value: 100 }
+            ]));
+        });
+    });
+    describe('Metrics behavior during replay', () => {
+        it('should preserve original metrics during replay', async () => {
+            var _a;
+            const task = (0, index_1.createTask)({
+                name: 'replay-metrics-test',
+                schema: new schema_1.Schema({ input: schema_1.Schema.string() }),
+                boundaries: {
+                    dataFetch: async (query) => {
+                        return `data-for-${query}`;
+                    }
+                },
+                fn: async ({ input }, { dataFetch, setMetrics }) => {
+                    await setMetrics({ type: 'business', name: 'queries', value: 1 });
+                    const data = await dataFetch(input);
+                    await setMetrics({ type: 'performance', name: 'data_size', value: data.length });
+                    return { data };
+                }
+            });
+            // First run to get original execution
+            const [originalResult, originalError, originalRecord] = await task.safeRun({ input: 'test' });
+            expect(originalError).toBeNull();
+            expect(originalResult).toEqual({ data: 'data-for-test' });
+            expect(originalRecord.metrics).toHaveLength(2);
+            // Replay the execution
+            const [replayResult, replayError, replayRecord] = await task.safeReplay(originalRecord, { boundaries: {} });
+            expect(replayError).toBeNull();
+            expect(replayResult).toEqual({ data: 'data-for-test' });
+            // Replay should preserve original metrics and may add new ones
+            expect((_a = replayRecord.metrics) === null || _a === void 0 ? void 0 : _a.length).toBeGreaterThanOrEqual(2);
+            // Original metrics should be included
+            expect(replayRecord.metrics).toEqual(expect.arrayContaining([
+                { type: 'business', name: 'queries', value: 1 },
+                { type: 'performance', name: 'data_size', value: 13 }
+            ]));
+        });
+        it('should allow new metrics during replay execution', async () => {
+            var _a, _b;
+            const task = (0, index_1.createTask)({
+                name: 'replay-new-metrics-test',
+                schema: new schema_1.Schema({ mode: schema_1.Schema.string() }),
+                boundaries: {
+                    operation: async (mode) => {
+                        return `result-${mode}`;
+                    }
+                },
+                fn: async ({ mode }, { operation, setMetrics }) => {
+                    if (mode === 'original') {
+                        await setMetrics({ type: 'business', name: 'original_run', value: 1 });
+                    }
+                    else if (mode === 'replay') {
+                        await setMetrics({ type: 'business', name: 'replay_run', value: 1 });
+                    }
+                    const result = await operation(mode);
+                    await setMetrics({ type: 'performance', name: 'execution_count', value: 1 });
+                    return { result };
+                }
+            });
+            // Original run
+            const [, originalError, originalRecord] = await task.safeRun({ mode: 'original' });
+            expect(originalError).toBeNull();
+            expect(originalRecord.metrics).toHaveLength(2);
+            // Modify the record for replay to change the mode
+            const modifiedRecord = Object.assign(Object.assign({}, originalRecord), { input: { mode: 'replay' } });
+            // Replay with different mode
+            const [, replayError, replayRecord] = await task.safeReplay(modifiedRecord, { boundaries: {} });
+            expect(replayError).toBeNull();
+            expect((_a = replayRecord.metrics) === null || _a === void 0 ? void 0 : _a.length).toBeGreaterThanOrEqual(2);
+            // Should have both original metrics and new replay metrics
+            const metricNames = ((_b = replayRecord.metrics) === null || _b === void 0 ? void 0 : _b.map(m => m.name)) || [];
+            expect(metricNames).toContain('execution_count');
+        });
+    });
+    describe('Performance metrics and complex scenarios', () => {
+        it('should handle high-frequency metric collection', async () => {
+            var _a;
+            const task = (0, index_1.createTask)({
+                name: 'high-frequency-metrics-test',
+                schema: new schema_1.Schema({ count: schema_1.Schema.number() }),
+                boundaries: {},
+                fn: async ({ count }, { setMetrics }) => {
+                    for (let i = 0; i < count; i++) {
+                        await setMetrics({
+                            type: 'performance',
+                            name: 'iteration',
+                            value: i
+                        });
+                    }
+                    return { completed: count };
+                }
+            });
+            const [result, error, record] = await task.safeRun({ count: 100 });
+            expect(error).toBeNull();
+            expect(result).toEqual({ completed: 100 });
+            expect(record.metrics).toHaveLength(100);
+            // Verify all metrics were collected correctly
+            (_a = record.metrics) === null || _a === void 0 ? void 0 : _a.forEach((metric, index) => {
+                expect(metric).toEqual({
+                    type: 'performance',
+                    name: 'iteration',
+                    value: index
+                });
+            });
+        });
+        it('should support different metric types in complex workflow', async () => {
+            var _a, _b, _c, _d;
+            const task = (0, index_1.createTask)({
+                name: 'complex-workflow-metrics-test',
+                schema: new schema_1.Schema({
+                    userId: schema_1.Schema.string(),
+                    operations: schema_1.Schema.array(schema_1.Schema.string())
+                }),
+                boundaries: {
+                    validateUser: async (userId) => {
+                        return userId.length > 0;
+                    },
+                    processOperation: async (operation) => {
+                        return `processed-${operation}`;
+                    }
+                },
+                fn: async ({ userId, operations }, { validateUser, processOperation, setMetrics }) => {
+                    // Business metrics
+                    await setMetrics({ type: 'business', name: 'user_requests', value: 1 });
+                    await setMetrics({ type: 'business', name: 'operation_count', value: operations.length });
+                    const startTime = Date.now();
+                    // Validate user
+                    const isValid = await validateUser(userId);
+                    if (!isValid) {
+                        await setMetrics({ type: 'error', name: 'validation_failures', value: 1 });
+                        throw new Error('Invalid user');
+                    }
+                    // Process operations
+                    const results = [];
+                    for (const operation of operations) {
+                        const result = await processOperation(operation);
+                        results.push(result);
+                        await setMetrics({ type: 'business', name: 'operations_processed', value: 1 });
+                    }
+                    // Performance metrics
+                    const duration = Date.now() - startTime;
+                    await setMetrics({ type: 'performance', name: 'total_processing_time', value: duration });
+                    await setMetrics({ type: 'performance', name: 'avg_operation_time', value: duration / operations.length });
+                    // Success metrics
+                    await setMetrics({ type: 'business', name: 'successful_requests', value: 1 });
+                    await setMetrics({ type: 'error', name: 'error_count', value: 0 });
+                    return { userId, results, processingTime: duration };
+                }
+            });
+            const [result, error, record] = await task.safeRun({
+                userId: 'user123',
+                operations: ['op1', 'op2', 'op3']
+            });
+            expect(error).toBeNull();
+            expect(result === null || result === void 0 ? void 0 : result.userId).toBe('user123');
+            expect(result === null || result === void 0 ? void 0 : result.results).toEqual(['processed-op1', 'processed-op2', 'processed-op3']);
+            // Should have collected multiple types of metrics
+            expect((_a = record.metrics) === null || _a === void 0 ? void 0 : _a.length).toBeGreaterThanOrEqual(8);
+            const businessMetrics = ((_b = record.metrics) === null || _b === void 0 ? void 0 : _b.filter(m => m.type === 'business')) || [];
+            const performanceMetrics = ((_c = record.metrics) === null || _c === void 0 ? void 0 : _c.filter(m => m.type === 'performance')) || [];
+            const errorMetrics = ((_d = record.metrics) === null || _d === void 0 ? void 0 : _d.filter(m => m.type === 'error')) || [];
+            expect(businessMetrics.length).toBeGreaterThanOrEqual(5);
+            expect(performanceMetrics.length).toBeGreaterThanOrEqual(2);
+            expect(errorMetrics.length).toBeGreaterThanOrEqual(1);
+        });
+    });
+});
+//# sourceMappingURL=metrics-collection.test.js.map