@output.ai/core 0.0.16 → 0.1.1

package/src/worker/tracer/index.test.js

@@ -1,102 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
-import { tmpdir, EOL } from 'node:os';
-import { join } from 'path';
-import { THIS_LIB_NAME } from '#consts';
-
-const createTempDir = () => mkdtempSync( join( tmpdir(), 'output-sdk-trace-' ) );
-
-// Single mocks (configured per-test by mutating the backing objects)
-const mockConfig = { tracing: { enabled: false } };
-vi.mock( '#configs', () => mockConfig );
-
-const mockStorageData = {
-  activityId: 's1',
-  activityType: 'Step 1',
-  workflowId: 'wf1',
-  workflowType: 'prompt',
-  workflowPath: '/workflows/prompt.js',
-  parentWorkflowId: undefined,
-  rootWorkflowId: undefined,
-  rootWorkflowType: undefined
-};
-vi.mock( '../async_storage.js', () => ( {
-  Storage: { load: () => mockStorageData }
-} ) );
-
-vi.mock( './tracer_tree.js', () => ( { buildLogTree: vi.fn() } ) );
-
-describe( 'tracer/index', () => {
-  beforeEach( () => {
-    vi.resetModules();
-    vi.clearAllMocks();
-    vi.useFakeTimers();
-    vi.setSystemTime( new Date( '2020-01-01T00:00:00.000Z' ) );
-  } );
-
-  afterEach( () => {
-    vi.useRealTimers();
-  } );
-
-  it( 'writes a raw log entry and calls buildLogTree (mocked)', async () => {
-    const originalArgv2 = process.argv[2];
-    const tmp = createTempDir();
-    process.argv[2] = tmp;
-
-    mockConfig.tracing.enabled = true;
-
-    const { buildLogTree } = await import( './tracer_tree.js' );
-    const { trace } = await import( './index.js' );
-
-    const input = { foo: 1 };
-    trace( { lib: THIS_LIB_NAME, event: 'workflow_start', input, output: null } );
-
-    expect( buildLogTree ).toHaveBeenCalledTimes( 1 );
-    const logPath = buildLogTree.mock.calls[0][0];
-
-    const raw = readFileSync( logPath, 'utf-8' );
-    const [ firstLine ] = raw.split( EOL );
-    const entry = JSON.parse( firstLine );
-
-    expect( entry ).toMatchObject( {
-      lib: THIS_LIB_NAME,
-      event: 'workflow_start',
-      input,
-      output: null,
-      stepId: 's1',
-      stepName: 'Step 1',
-      workflowId: 'wf1',
-      workflowType: 'prompt',
-      workflowPath: '/workflows/prompt.js'
-    } );
-    expect( typeof entry.timestamp ).toBe( 'number' );
-
-    rmSync( tmp, { recursive: true, force: true } );
-    process.argv[2] = originalArgv2;
-  } );
-
-  it( 'does nothing when tracing is disabled', async () => {
-    const originalArgv2 = process.argv[2];
-    const tmp = createTempDir();
-    process.argv[2] = tmp;
-
-    mockConfig.tracing.enabled = false;
-    const { buildLogTree } = await import( './tracer_tree.js' );
-    const { trace } = await import( './index.js' );
-
-    trace( { lib: THIS_LIB_NAME, event: 'workflow_start', input: {}, output: null } );
-
-    expect( buildLogTree ).not.toHaveBeenCalled();
-
-    rmSync( tmp, { recursive: true, force: true } );
-    process.argv[2] = originalArgv2;
-  } );
-
-  it( 'setupGlobalTracer installs global symbol', async () => {
-    mockConfig.tracing.enabled = false;
-    const { setupGlobalTracer } = await import( './index.js' );
-    setupGlobalTracer();
-    const sym = Symbol.for( '__trace' );
-    expect( typeof globalThis[sym] ).toBe( 'function' );
-  } );
-} );

package/src/worker/tracer/tracer_tree.js

@@ -1,85 +0,0 @@
-import { readFileSync, writeFileSync } from 'node:fs';
-import { EOL } from 'os';
-import { THIS_LIB_NAME, TraceEvent } from '#consts';
-
-/**
- * Sorting function that compares two objects and ASC sort them by either .startedAt or, if not present, .timestamp
- *
- * @param {object} a
- * @param {object} b
- * @returns {number} The sorting result [1,-1]
- */
-const timestampAscSort = ( a, b ) => {
-  if ( a.startedAt ) {
-    return a.startedAt > b.startedAt ? 1 : 1;
-  }
-  return a.timestamp > b.timestamp ? 1 : -1;
-};
-
-/**
- * Add a member to an array an sort it. It is a mutating method.
- *
- * @param {array} arr - The arr to be changed
- * @param {any} entry - The entry to be added
- * @param {Function} sorter - The sort function to be used (within .filter)
- */
-const pushSort = ( arr, entry, sorter ) => {
-  arr.push( entry );
-  arr.sort( sorter );
-};
-
-/**
- * Transform the trace file into a tree of events, where nested events are represented as children of parent events.
- * And the events STEP_START/STEP_END and WORKFLOW_START/WORKFLOW_END are combined into single events with start and end timestamps.
- *
- * @param {string} src - The trace src filename
- */
-export const buildLogTree = src => {
-  const content = readFileSync( src, 'utf-8' );
-  const entries = content.split( EOL ).slice( 0, -1 ).map( c => JSON.parse( c ) );
-
-  const stepsMap = new Map();
-  const workflowsMap = new Map();
-
-  // close steps/workflows
-  for ( const entry of entries.filter( e => e.lib === THIS_LIB_NAME ) ) {
-    const { event, workflowId, workflowType, workflowPath, parentWorkflowId, stepId, stepName, input, output, timestamp } = entry;
-
-    const baseEntry = { children: [], startedAt: timestamp, workflowId };
-    if ( [ TraceEvent.EVALUATOR_START, TraceEvent.STEP_START ].includes( event ) ) {
-      const eventName = event === TraceEvent.EVALUATOR_START ? 'evaluator' : 'step';
-      stepsMap.set( `${workflowId}:${stepId}`, { event: eventName, input, stepId, stepName, ...baseEntry } );
-    }
-
-    if ( [ TraceEvent.EVALUATOR_END, TraceEvent.STEP_END ].includes( event ) ) {
-      Object.assign( stepsMap.get( `${workflowId}:${stepId}` ) ?? {}, { output, endedAt: timestamp } );
-    }
-
-    if ( event === TraceEvent.WORKFLOW_START ) {
-      workflowsMap.set( workflowId, { event: 'workflow', input, parentWorkflowId, workflowPath, workflowType, ...baseEntry } );
-    }
-
-    if ( event === TraceEvent.WORKFLOW_END ) {
-      Object.assign( workflowsMap.get( workflowId ) ?? {}, { output, endedAt: timestamp } );
-    }
-  }
-
-  // insert operations inside steps
-  for ( const entry of entries.filter( e => e.lib !== THIS_LIB_NAME ) ) {
-    pushSort( stepsMap.get( `${entry.workflowId}:${entry.stepId}` ).children, entry, timestampAscSort );
-  }
-
-  // insert steps into workflows
-  for ( const step of stepsMap.values() ) {
-    pushSort( workflowsMap.get( step.workflowId ).children, step, timestampAscSort );
-  }
-
-  // insert children workflows
-  for ( const workflow of [ ...workflowsMap.values() ].filter( w => w.parentWorkflowId ) ) {
-    pushSort( workflowsMap.get( workflow.parentWorkflowId ).children, workflow, timestampAscSort );
-  }
-
-  const rootWorkflow = [ ...workflowsMap.values() ].find( w => !w.parentWorkflowId );
-
-  writeFileSync( src.replace( /\.raw$/, '.json' ), JSON.stringify( rootWorkflow, undefined, 2 ), 'utf-8' );
-};

package/src/worker/tracer/tracer_tree.test.js

@@ -1,115 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { writeFileSync, readFileSync, rmSync } from 'node:fs';
-import { mkdtempSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'path';
-import { EOL } from 'os';
-import { buildLogTree } from './tracer_tree.js';
-import { THIS_LIB_NAME, TraceEvent } from '#consts';
-
-const createTempDir = () => mkdtempSync( join( tmpdir(), 'output-sdk-trace-tree-' ) );
-
-describe( 'tracer/tracer_tree', () => {
-  it( 'builds a tree JSON from a raw log file', () => {
-    const tmp = createTempDir();
-    const rawPath = join( tmp, 'run-123.raw' );
-
-    const entries = [
-      // root workflow start
-      {
-        lib: THIS_LIB_NAME,
-        event: TraceEvent.WORKFLOW_START,
-        input: { a: 1 },
-        output: null,
-        timestamp: 1000,
-        stepId: undefined,
-        stepName: undefined,
-        workflowId: 'wf1',
-        workflowType: 'prompt',
-        workflowPath: '/workflows/prompt.js',
-        parentWorkflowId: undefined
-      },
-      // step start
-      {
-        lib: THIS_LIB_NAME,
-        event: TraceEvent.STEP_START,
-        input: { x: 1 },
-        output: null,
-        timestamp: 2000,
-        stepId: 's1',
-        stepName: 'Step 1',
-        workflowId: 'wf1',
-        workflowType: 'prompt',
-        workflowPath: '/workflows/prompt.js',
-        parentWorkflowId: undefined
-      },
-      // non-core operation within step
-      {
-        lib: 'tool',
-        event: 'call',
-        input: { y: 2 },
-        output: { y: 3 },
-        timestamp: 3000,
-        stepId: 's1',
-        stepName: 'Step 1',
-        workflowId: 'wf1'
-      },
-      // step end
-      {
-        lib: THIS_LIB_NAME,
-        event: TraceEvent.STEP_END,
-        input: null,
-        output: { done: true },
-        timestamp: 4000,
-        stepId: 's1',
-        stepName: 'Step 1',
-        workflowId: 'wf1',
-        workflowType: 'prompt',
-        workflowPath: '/workflows/prompt.js',
-        parentWorkflowId: undefined
-      },
-      // workflow end
-      {
-        lib: THIS_LIB_NAME,
-        event: TraceEvent.WORKFLOW_END,
-        input: null,
-        output: { ok: true },
-        timestamp: 5000,
-        stepId: undefined,
-        stepName: undefined,
-        workflowId: 'wf1',
-        workflowType: 'prompt',
-        workflowPath: '/workflows/prompt.js',
-        parentWorkflowId: undefined
-      }
-    ];
-
-    writeFileSync( rawPath, entries.map( e => JSON.stringify( e ) ).join( EOL ) + EOL, 'utf-8' );
-
-    buildLogTree( rawPath );
-
-    const tree = JSON.parse( readFileSync( rawPath.replace( /.raw$/, '.json' ), 'utf-8' ) );
-
-    expect( tree.event ).toBe( 'workflow' );
-    expect( tree.workflowId ).toBe( 'wf1' );
-    expect( tree.workflowType ).toBe( 'prompt' );
-    expect( tree.startedAt ).toBe( 1000 );
-    expect( tree.endedAt ).toBe( 5000 );
-    expect( tree.output ).toEqual( { ok: true } );
-    expect( Array.isArray( tree.children ) ).toBe( true );
-    expect( tree.children.length ).toBe( 1 );
-
-    const step = tree.children[0];
-    expect( step.event ).toBe( 'step' );
-    expect( step.stepId ).toBe( 's1' );
-    expect( step.startedAt ).toBe( 2000 );
-    expect( step.endedAt ).toBe( 4000 );
-    expect( step.output ).toEqual( { done: true } );
-    expect( step.children.length ).toBe( 1 );
-    expect( step.children[0].lib ).toBe( 'tool' );
-    expect( step.children[0].timestamp ).toBe( 3000 );
-
-    rmSync( tmp, { recursive: true, force: true } );
-  } );
-} );
-