@outputai/core 0.4.1-dev.56c13a8.0 → 0.4.1-dev.6555a2c.0

package/src/interface/workflow.spec.js

@@ -1,7 +1,10 @@
+import { Signal } from '#consts';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { z } from 'zod';
 
 const inWorkflowContextMock = vi.hoisted( () => vi.fn( () => true ) );
+const defineSignalMock = vi.hoisted( () => vi.fn( name => name ) );
+const setHandlerMock = vi.hoisted( () => vi.fn() );
 const traceDestinationsStepMock = vi.fn().mockResolvedValue( { local: '/tmp/trace' } );
 const executeChildMock = vi.fn().mockResolvedValue( undefined );
 const continueAsNewMock = vi.fn().mockResolvedValue( undefined );
@@ -41,7 +44,16 @@ vi.mock( '@temporalio/workflow', () => ( {
   workflowInfo: workflowInfoMock,
   uuid4: () => '550e8400e29b41d4a716446655440000',
   ParentClosePolicy: { TERMINATE: 'TERMINATE', ABANDON: 'ABANDON' },
-  continueAsNew: continueAsNewMock
+  ChildWorkflowFailure: class ChildWorkflowFailure extends Error {
+    constructor( message, cause ) {
+      super( message );
+      this.name = 'ChildWorkflowFailure';
+      this.cause = cause;
+    }
+  },
+  continueAsNew: continueAsNewMock,
+  defineSignal: ( ...args ) => defineSignalMock( ...args ),
+  setHandler: ( ...args ) => setHandlerMock( ...args )
 } ) );
 
 vi.mock( '#consts', async importOriginal => {
@@ -53,10 +65,17 @@ vi.mock( '#consts', async importOriginal => {
   };
 } );
 
+const emptyAggregations = {
+  cost: { total: 0 },
+  tokens: { total: 0 },
+  httpRequests: { total: 0 }
+};
+
 describe( 'workflow()', () => {
   beforeEach( () => {
     vi.clearAllMocks();
     inWorkflowContextMock.mockReturnValue( true );
+    defineSignalMock.mockImplementation( name => name );
     workflowInfoMock.mockReturnValue( { ...workflowInfoReturn } );
     workflowInfoReturn.memo = {};
     proxyActivitiesMock.mockImplementation( () => {
@@ -217,7 +236,7 @@ describe( 'workflow()', () => {
   } );
 
   describe( 'root workflow (in workflow context)', () => {
-    it( 'calls getTraceDestinations, returns { output, trace } and assigns executionContext to memo', async () => {
+    it( 'calls getTraceDestinations, returns root trace data and assigns executionContext to memo', async () => {
       const { workflow } = await import( './workflow.js' );
 
       const wf = workflow( {
@@ -232,7 +251,9 @@ describe( 'workflow()', () => {
       expect( traceDestinationsStepMock ).toHaveBeenCalledTimes( 1 );
       expect( result ).toEqual( {
         output: { v: 42 },
-        trace: { destinations: { local: '/tmp/trace' } }
+        trace: { destinations: { local: '/tmp/trace' } },
+        attributes: [],
+        aggregations: emptyAggregations
       } );
       const memo = workflowInfoMock().memo;
       expect( memo.executionContext ).toEqual( {
@@ -243,6 +264,68 @@ describe( 'workflow()', () => {
       } );
     } );
 
+    it( 'collects attribute signals and returns aggregated attributes', async () => {
+      const { workflow } = await import( './workflow.js' );
+      const { Attribute } = await import( '#trace_attribute' );
+      const handlers = { addAttribute: () => {} };
+      setHandlerMock.mockImplementation( ( signalName, handler ) => {
+        if ( signalName === Signal.ADD_ATTRIBUTE ) {
+          handlers.addAttribute = handler;
+        }
+      } );
+
+      const httpRequest = {
+        type: Attribute.HTTPRequestCount.TYPE,
+        url: 'https://api.example.test/items',
+        requestId: 'req-1'
+      };
+      const httpCost = {
+        type: Attribute.HTTPRequestCost.TYPE,
+        url: 'https://api.example.test/items',
+        requestId: 'req-1',
+        total: 2.5
+      };
+      const llmUsage = {
+        type: Attribute.LLMUsage.TYPE,
+        modelId: 'gpt-4o',
+        total: 0.25,
+        usage: [
+          { type: 'input', ppm: 5, amount: 20_000, total: 0.1 },
+          { type: 'output', ppm: 30, amount: 5_000, total: 0.15 }
+        ],
+        tokensUsed: 25_000
+      };
+
+      const wf = workflow( {
+        name: 'attr_wf',
+        description: 'Attributes',
+        inputSchema: z.object( {} ),
+        outputSchema: z.object( { ok: z.boolean() } ),
+        fn: async () => {
+          handlers.addAttribute( httpRequest );
+          handlers.addAttribute( httpCost );
+          handlers.addAttribute( llmUsage );
+          return { ok: true };
+        }
+      } );
+
+      const result = await wf( {} );
+      expect( result ).toEqual( {
+        output: { ok: true },
+        trace: { destinations: { local: '/tmp/trace' } },
+        attributes: [ httpRequest, httpCost, llmUsage ],
+        aggregations: {
+          cost: { total: 2.75 },
+          tokens: {
+            total: 25_000,
+            input: 20_000,
+            output: 5_000
+          },
+          httpRequests: { total: 1 }
+        }
+      } );
+    } );
+
     it( 'sets executionContext.disableTrace when options.disableTrace is true', async () => {
       const { workflow } = await import( './workflow.js' );
 
@@ -261,7 +344,7 @@ describe( 'workflow()', () => {
   } );
 
   describe( 'child workflow (memo.executionContext already set)', () => {
-    it( 'does not call getTraceDestinations and returns plain output', async () => {
+    it( 'does not call getTraceDestinations and returns an internal output envelope', async () => {
       workflowInfoMock.mockReturnValue( {
         ...workflowInfoReturn,
         memo: { executionContext: { workflowId: 'parent-1', workflowName: 'parent_wf' } }
@@ -278,7 +361,7 @@ describe( 'workflow()', () => {
 
       const result = await wf( {} );
       expect( traceDestinationsStepMock ).not.toHaveBeenCalled();
-      expect( result ).toEqual( { x: 'child' } );
+      expect( result ).toEqual( { output: { x: 'child' }, attributes: [] } );
     } );
   } );
 
@@ -381,6 +464,7 @@ describe( 'workflow()', () => {
     it( 'calls executeChild with correct args and TERMINATE when not detached', async () => {
       const { workflow } = await import( './workflow.js' );
       const { ParentClosePolicy } = await import( '@temporalio/workflow' );
+      executeChildMock.mockResolvedValueOnce( { output: {}, attributes: [] } );
 
       const wf = workflow( {
         name: 'parent_wf',
@@ -408,6 +492,7 @@ describe( 'workflow()', () => {
     it( 'uses ABANDON when extra.detached is true', async () => {
       const { workflow } = await import( './workflow.js' );
       const { ParentClosePolicy } = await import( '@temporalio/workflow' );
+      executeChildMock.mockResolvedValueOnce( { output: {}, attributes: [] } );
 
       const wf = workflow( {
         name: 'detach_wf',
@@ -428,6 +513,7 @@ describe( 'workflow()', () => {
 
     it( 'passes empty args when input is null/omitted', async () => {
       const { workflow } = await import( './workflow.js' );
+      executeChildMock.mockResolvedValueOnce( { output: {}, attributes: [] } );
 
       const wf = workflow( {
         name: 'no_input_wf',
@@ -445,11 +531,96 @@ describe( 'workflow()', () => {
         args: []
       } ) );
     } );
+
+    it( 'returns child output and merges child attributes into the root result', async () => {
+      const { workflow } = await import( './workflow.js' );
+      const { Attribute } = await import( '#trace_attribute' );
+      const childAttribute = {
+        type: Attribute.LLMUsage.TYPE,
+        modelId: 'gpt-4o',
+        total: 0.4,
+        tokensUsed: 20,
+        usage: [
+          { type: 'input', ppm: 10, amount: 20, total: 0.4 }
+        ]
+      };
+      executeChildMock.mockResolvedValueOnce( {
+        output: { child: 'ok' },
+        attributes: [ childAttribute ]
+      } );
+
+      const wf = workflow( {
+        name: 'merge_child_wf',
+        description: 'Merge child attributes',
+        inputSchema: z.object( {} ),
+        outputSchema: z.object( { child: z.string() } ),
+        async fn() {
+          return this.startWorkflow( 'child_wf', { id: 1 } );
+        }
+      } );
+
+      const result = await wf( {} );
+      expect( result ).toEqual( {
+        output: { child: 'ok' },
+        trace: { destinations: { local: '/tmp/trace' } },
+        attributes: [ childAttribute ],
+        aggregations: {
+          cost: { total: 0.4 },
+          tokens: {
+            total: 20,
+            input: 20
+          },
+          httpRequests: { total: 0 }
+        }
+      } );
+    } );
+
+    it( 'merges child error attributes before rethrowing to root metadata', async () => {
+      const { workflow } = await import( './workflow.js' );
+      const { ChildWorkflowFailure } = await import( '@temporalio/workflow' );
+      const { METADATA_ACCESS_SYMBOL } = await import( '#consts' );
+      const { Attribute } = await import( '#trace_attribute' );
+      const childAttribute = {
+        type: Attribute.HTTPRequestCost.TYPE,
+        url: 'https://api.example.test',
+        requestId: 'req-child',
+        total: 2
+      };
+      const childError = new ChildWorkflowFailure( 'child failed', {
+        message: 'Child workflow execution failed',
+        details: [ { attributes: [ childAttribute ] } ]
+      } );
+      executeChildMock.mockRejectedValueOnce( childError );
+
+      const wf = workflow( {
+        name: 'child_error_wf',
+        description: 'Child error attributes',
+        inputSchema: z.object( {} ),
+        outputSchema: z.object( {} ),
+        async fn() {
+          await this.startWorkflow( 'child_wf', { id: 1 } );
+          return {};
+        }
+      } );
+
+      await expect( wf( {} ) ).rejects.toThrow( 'child failed' );
+      expect( childError[METADATA_ACCESS_SYMBOL] ).toEqual( {
+        attributes: [ childAttribute ],
+        trace: { destinations: { local: '/tmp/trace' } },
+        aggregations: {
+          cost: { total: 2 },
+          tokens: { total: 0 },
+          httpRequests: { total: 0 }
+        }
+      } );
+    } );
   } );
 
   describe( 'error handling (root workflow)', () => {
-    it( 'rethrows error from fn and rejects with same message', async () => {
+    it( 'rethrows error from fn with trace attributes and aggregation metadata', async () => {
       const { workflow } = await import( './workflow.js' );
+      const { METADATA_ACCESS_SYMBOL } = await import( '#consts' );
+      const error = new Error( 'workflow failed' );
 
       const wf = workflow( {
         name: 'err_wf',
@@ -457,11 +628,16 @@ describe( 'workflow()', () => {
         inputSchema: z.object( {} ),
         outputSchema: z.object( {} ),
         fn: async () => {
-          throw new Error( 'workflow failed' );
+          throw error;
         }
       } );
 
       await expect( wf( {} ) ).rejects.toThrow( 'workflow failed' );
+      expect( error[METADATA_ACCESS_SYMBOL] ).toEqual( {
+        trace: { destinations: { local: '/tmp/trace' } },
+        attributes: [],
+        aggregations: emptyAggregations
+      } );
     } );
   } );
 } );

package/src/interface/workflow_context.js

@@ -7,11 +7,12 @@ export class Context {
    * Builds a new context instance
    * @param {object} options - Arguments to build a new context instance
    * @param {string} workflowId
+   * @param {string} runId
    * @param {function} continueAsNew
    * @param {function} isContinueAsNewSuggested
    * @returns {object} context
    */
-  static build( { workflowId, continueAsNew, isContinueAsNewSuggested } ) {
+  static build( { workflowId, runId, continueAsNew, isContinueAsNewSuggested } ) {
     return {
       /**
        * Control namespace: This object adds functions to interact with Temporal flow mechanisms
@@ -24,7 +25,8 @@ export class Context {
        * Info namespace: abstracts workflowInfo()
        */
       info: {
-        workflowId
+        workflowId,
+        runId
       }
     };
   }

package/src/tracing/processors/local/index.js

@@ -1,9 +1,11 @@
-import { appendFileSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { appendFileSync, mkdirSync, readdirSync, readFileSync, rmSync, createWriteStream } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'url';
 import buildTraceTree from '../../tools/build_trace_tree.js';
-import { safeFormatJSON } from '../../tools/utils.js';
 import { EOL } from 'node:os';
+import { JsonStreamStringify } from 'json-stream-stringify';
+
+import { pipeline } from 'stream/promises';
 
 const __dirname = dirname( fileURLToPath( import.meta.url ) );
 
@@ -109,7 +111,7 @@ export const init = () => {
  * @param {object} args.executionContext - Execution info: workflowId, workflowName, startTime
  * @returns {void}
  */
-export const exec = ( { entry, executionContext } ) => {
+export const exec = async ( { entry, executionContext } ) => {
   const { workflowId, workflowName, startTime } = executionContext;
   const tempFilePath = createTempFilePath( executionContext );
   addEntry( entry, tempFilePath );
@@ -126,7 +128,11 @@ export const exec = ( { entry, executionContext } ) => {
   const path = join( dir, buildTraceFilename( { startTime, workflowId } ) );
 
   mkdirSync( dir, { recursive: true } );
-  writeFileSync( path, safeFormatJSON( content ) + EOL, 'utf-8' );
+
+  await pipeline(
+    new JsonStreamStringify( content ),
+    createWriteStream( path )
+  );
 };
 
 /**

package/src/tracing/processors/local/index.spec.js

@@ -1,5 +1,4 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { EOL } from 'node:os';
 
 // In-memory fs mock store
 const store = { files: new Map() };
@@ -12,6 +11,7 @@ const appendFileSyncMock = vi.fn( ( path, data ) => {
 const readFileSyncMock = vi.fn( path => store.files.get( path ) ?? '' );
 const readdirSyncMock = vi.fn( () => [] );
 const rmSyncMock = vi.fn();
+const createWriteStreamMock = vi.fn( path => ( { path } ) );
 
 vi.mock( 'node:fs', () => ( {
   mkdirSync: mkdirSyncMock,
@@ -19,9 +19,36 @@ vi.mock( 'node:fs', () => ( {
   appendFileSync: appendFileSyncMock,
   readFileSync: readFileSyncMock,
   readdirSync: readdirSyncMock,
-  rmSync: rmSyncMock
+  rmSync: rmSyncMock,
+  createWriteStream: createWriteStreamMock
 } ) );
 
+const pipelineMock = vi.fn( async ( source, destination ) => {
+  const chunks = [];
+  for await ( const chunk of source ) {
+    chunks.push( Buffer.isBuffer( chunk ) ? chunk : Buffer.from( chunk ) );
+  }
+  store.files.set( destination.path, Buffer.concat( chunks ).toString( 'utf8' ) );
+} );
+vi.mock( 'node:stream/promises', () => ( { pipeline: pipelineMock } ) );
+
+vi.mock( 'json-stream-stringify', async () => {
+  const { Readable } = await import( 'node:stream' );
+  return {
+    JsonStreamStringify: class extends Readable {
+      constructor( body ) {
+        super();
+        this.body = body;
+      }
+
+      _read() {
+        this.push( JSON.stringify( this.body ) );
+        this.push( null );
+      }
+    }
+  };
+} );
+
 const buildTraceTreeMock = vi.fn( entries => ( { count: entries.length } ) );
 vi.mock( '../../tools/build_trace_tree.js', () => ( { default: buildTraceTreeMock } ) );
 
@@ -58,17 +85,18 @@ describe( 'tracing/processors/local', () => {
     const workflowId = 'id1';
     const ctx = { executionContext: { workflowId, workflowName: 'WF', startTime } };
 
-    exec( { ...ctx, entry: rootStart( workflowId, startTime ) } );
-    exec( { ...ctx, entry: childTick( 'child-1', startTime + 1 ) } );
-    exec( { ...ctx, entry: rootEnd( workflowId, startTime + 2 ) } );
+    await exec( { ...ctx, entry: rootStart( workflowId, startTime ) } );
+    await exec( { ...ctx, entry: childTick( 'child-1', startTime + 1 ) } );
+    await exec( { ...ctx, entry: rootEnd( workflowId, startTime + 2 ) } );
 
     expect( buildTraceTreeMock ).toHaveBeenCalledTimes( 1 );
     expect( buildTraceTreeMock.mock.calls[0][0] ).toHaveLength( 3 );
 
-    expect( writeFileSyncMock ).toHaveBeenCalledTimes( 1 );
-    const [ writtenPath, content ] = writeFileSyncMock.mock.calls[0];
+    expect( createWriteStreamMock ).toHaveBeenCalledTimes( 1 );
+    expect( pipelineMock ).toHaveBeenCalledTimes( 1 );
+    const [ writtenPath ] = createWriteStreamMock.mock.calls[0];
     expect( writtenPath ).toMatch( /\/tmp\/project\/logs\/runs\/WF\// );
-    expect( JSON.parse( content.trim() ).count ).toBe( 3 );
+    expect( JSON.parse( store.files.get( writtenPath ) ).count ).toBe( 3 );
   } );
 
   it( 'exec(): does not build or write on non-flush entries', async () => {
@@ -79,11 +107,13 @@ describe( 'tracing/processors/local', () => {
     const workflowId = 'id1';
     const ctx = { executionContext: { workflowId, workflowName: 'WF', startTime } };
 
-    exec( { ...ctx, entry: rootStart( workflowId, startTime ) } );
-    exec( { ...ctx, entry: childTick( 'child-1', startTime + 1 ) } );
+    await exec( { ...ctx, entry: rootStart( workflowId, startTime ) } );
+    await exec( { ...ctx, entry: childTick( 'child-1', startTime + 1 ) } );
 
     expect( buildTraceTreeMock ).not.toHaveBeenCalled();
     expect( writeFileSyncMock ).not.toHaveBeenCalled();
+    expect( createWriteStreamMock ).not.toHaveBeenCalled();
+    expect( pipelineMock ).not.toHaveBeenCalled();
   } );
 
   it( 'exec(): flushes on error action before root end', async () => {
@@ -94,12 +124,13 @@ describe( 'tracing/processors/local', () => {
     const workflowId = 'id1';
     const ctx = { executionContext: { workflowId, workflowName: 'WF', startTime } };
 
-    exec( { ...ctx, entry: rootStart( workflowId, startTime ) } );
-    exec( { ...ctx, entry: { id: 'step-1', action: 'error', timestamp: startTime + 1 } } );
+    await exec( { ...ctx, entry: rootStart( workflowId, startTime ) } );
+    await exec( { ...ctx, entry: { id: 'step-1', action: 'error', timestamp: startTime + 1 } } );
 
     expect( buildTraceTreeMock ).toHaveBeenCalledTimes( 1 );
     expect( buildTraceTreeMock.mock.calls[0][0] ).toHaveLength( 2 );
-    expect( writeFileSyncMock ).toHaveBeenCalledTimes( 1 );
+    expect( createWriteStreamMock ).toHaveBeenCalledTimes( 1 );
+    expect( pipelineMock ).toHaveBeenCalledTimes( 1 );
   } );
 
   it( 'getDestination(): returns absolute path under callerDir logs', async () => {
@@ -128,11 +159,11 @@ describe( 'tracing/processors/local', () => {
     const workflowId = 'id1';
     const ctx = { executionContext: { workflowId, workflowName: 'WF', startTime } };
 
-    exec( { ...ctx, entry: rootStart( workflowId, startTime ) } );
-    exec( { ...ctx, entry: rootEnd( workflowId, startTime + 1 ) } );
+    await exec( { ...ctx, entry: rootStart( workflowId, startTime ) } );
+    await exec( { ...ctx, entry: rootEnd( workflowId, startTime + 1 ) } );
 
-    expect( writeFileSyncMock ).toHaveBeenCalledTimes( 1 );
-    const [ writtenPath ] = writeFileSyncMock.mock.calls[0];
+    expect( createWriteStreamMock ).toHaveBeenCalledTimes( 1 );
+    const [ writtenPath ] = createWriteStreamMock.mock.calls[0];
 
     expect( writtenPath ).not.toContain( '/host/path/logs' );
     expect( writtenPath ).toMatch( /\/tmp\/project\/logs\/runs\/WF\// );
@@ -164,15 +195,15 @@ describe( 'tracing/processors/local', () => {
     const workflowName = 'test-workflow';
     const ctx = { executionContext: { workflowId, workflowName, startTime } };
 
-    exec( { ...ctx, entry: rootStart( workflowId, startTime ) } );
-    exec( { ...ctx, entry: rootEnd( workflowId, startTime + 1 ) } );
+    await exec( { ...ctx, entry: rootStart( workflowId, startTime ) } );
+    await exec( { ...ctx, entry: rootEnd( workflowId, startTime + 1 ) } );
 
     const destination = getDestination( { startTime, workflowId, workflowName } );
 
-    const [ writtenPath, payload ] = writeFileSyncMock.mock.calls[0];
+    const [ writtenPath ] = createWriteStreamMock.mock.calls[0];
     expect( writtenPath ).not.toContain( '/Users/ben/project' );
     expect( writtenPath ).toMatch( /\/tmp\/project\/logs\/runs\/test-workflow\// );
-    expect( payload.endsWith( EOL ) ).toBe( true );
+    expect( JSON.parse( store.files.get( writtenPath ) ).count ).toBe( 2 );
 
     expect( destination ).toBe( '/Users/ben/project/logs/runs/test-workflow/2020-01-02-03-04-05-678Z_workflow-id-123.json' );
   } );

package/src/tracing/processors/s3/index.js

@@ -1,10 +1,9 @@
 import { upload } from './s3_client.js';
 import { getRedisClient } from './redis_client.js';
 import buildTraceTree from '../../tools/build_trace_tree.js';
-import { EOL } from 'node:os';
 import { loadEnv, getVars } from './configs.js';
 import { createChildLogger } from '#logger';
-import { safeFormatJSON } from '../../tools/utils.js';
+import { JsonStreamStringify } from 'json-stream-stringify';
 
 const log = createChildLogger( 'S3 Processor' );
 
@@ -100,9 +99,10 @@ export const exec = async ( { entry, executionContext } ) => {
     log.warn( 'Incomplete trace file discarded', { workflowId, error: 'incomplete_trace_file' } );
     return;
   }
+
   await upload( {
     key: getS3Key( { workflowId, workflowName, startTime } ),
-    content: safeFormatJSON( content ) + EOL
+    content: new JsonStreamStringify( content )
   } );
   await bustEntries( cacheKey );
 };

package/src/tracing/processors/s3/index.spec.js

@@ -27,6 +27,31 @@ vi.mock( './s3_client.js', () => ( { upload: uploadMock } ) );
 const buildTraceTreeMock = vi.fn( entries => ( { count: entries.length } ) );
 vi.mock( '../../tools/build_trace_tree.js', () => ( { default: buildTraceTreeMock } ) );
 
+vi.mock( 'json-stream-stringify', async () => {
+  const { Readable } = await import( 'node:stream' );
+  return {
+    JsonStreamStringify: class extends Readable {
+      constructor( body ) {
+        super();
+        this.body = body;
+      }
+
+      _read() {
+        this.push( JSON.stringify( this.body ) );
+        this.push( null );
+      }
+    }
+  };
+} );
+
+const streamToString = async stream => {
+  const chunks = [];
+  for await ( const chunk of stream ) {
+    chunks.push( Buffer.isBuffer( chunk ) ? chunk : Buffer.from( chunk ) );
+  }
+  return Buffer.concat( chunks ).toString( 'utf8' );
+};
+
 describe( 'tracing/processors/s3', () => {
   beforeEach( () => {
     vi.useFakeTimers();
@@ -74,7 +99,7 @@ describe( 'tracing/processors/s3', () => {
     expect( uploadMock ).toHaveBeenCalledTimes( 1 );
     const { key, content } = uploadMock.mock.calls[0][0];
     expect( key ).toMatch( /^WF\/2020\/01\/02\// );
-    expect( JSON.parse( content.trim() ).count ).toBe( 3 );
+    expect( JSON.parse( await streamToString( content ) ).count ).toBe( 3 );
     expect( delMock ).toHaveBeenCalledTimes( 1 );
     expect( delMock ).toHaveBeenCalledWith( 'traces/WF/id1' );
   } );

package/src/tracing/processors/s3/s3_client.js

@@ -1,4 +1,5 @@
-import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
+import { S3Client } from '@aws-sdk/client-s3';
+import { Upload } from '@aws-sdk/lib-storage';
 import { getVars } from './configs.js';
 
 const state = { s3Client: null };
@@ -21,7 +22,14 @@ const getS3Client = () => {
  * Upload given file to S3
  * @param {object} args
  * @param {string} key - S3 file key
- * @param {string} content - File content
+ * @param {string|import('node:stream').Readable} content - File content
  */
 export const upload = ( { key, content } ) =>
-  getS3Client().send( new PutObjectCommand( { Bucket: getVars().remoteS3Bucket, Key: key, Body: content } ) );
+  new Upload( {
+    client: getS3Client(),
+    params: {
+      Bucket: getVars().remoteS3Bucket,
+      Key: key,
+      Body: content
+    }
+  } ).done();

package/src/tracing/processors/s3/s3_client.spec.js

@@ -9,24 +9,27 @@ vi.mock( '#utils', () => ( {
 const getVarsMock = vi.fn();
 vi.mock( './configs', () => ( { getVars: () => getVarsMock() } ) );
 
-const sendMock = vi.fn();
 const ctorState = { args: null };
 class S3ClientMock {
   constructor( args ) {
     ctorState.args = args;
-  } send = sendMock;
-}
-class PutObjectCommandMock {
-  constructor( input ) {
-    this.input = input;
   }
 }
-
 vi.mock( '@aws-sdk/client-s3', () => ( {
-  S3Client: S3ClientMock,
-  PutObjectCommand: PutObjectCommandMock
+  S3Client: S3ClientMock
 } ) );
 
+const uploadDoneMock = vi.fn();
+const uploadCtorState = { args: [] };
+class UploadMock {
+  constructor( args ) {
+    uploadCtorState.args.push( args );
+  }
+
+  done = uploadDoneMock;
+}
+vi.mock( '@aws-sdk/lib-storage', () => ( { Upload: UploadMock } ) );
+
 async function loadModule() {
   vi.resetModules();
   return import( './s3_client.js' );
@@ -35,6 +38,9 @@ async function loadModule() {
 describe( 'tracing/processors/s3/s3_client', () => {
   beforeEach( () => {
     vi.clearAllMocks();
+    ctorState.args = null;
+    uploadCtorState.args = [];
+    uploadDoneMock.mockResolvedValue( undefined );
     getVarsMock.mockReturnValue( {
       awsRegion: 'us-east-1',
       awsAccessKeyId: 'id',
@@ -48,15 +54,21 @@ describe( 'tracing/processors/s3/s3_client', () => {
 
     await upload( { key: 'wf/key.json', content: '{"a":1}' } );
 
-    expect( ctorState.args ).toEqual( { region: 'us-east-1', credentials: { secretAccessKey: 'sek', accessKeyId: 'id' } } );
-    expect( sendMock ).toHaveBeenCalledTimes( 1 );
-    const cmd = sendMock.mock.calls[0][0];
-    expect( cmd ).toBeInstanceOf( PutObjectCommandMock );
-    expect( cmd.input ).toEqual( { Bucket: 'bucket', Key: 'wf/key.json', Body: '{"a":1}' } );
+    expect( ctorState.args ).toEqual( {
+      region: 'us-east-1',
+      credentials: { secretAccessKey: 'sek', accessKeyId: 'id' }
+    } );
+    expect( uploadCtorState.args ).toHaveLength( 1 );
+    expect( uploadCtorState.args[0] ).toEqual( {
+      client: expect.any( S3ClientMock ),
+      params: { Bucket: 'bucket', Key: 'wf/key.json', Body: '{"a":1}' }
+    } );
+    expect( uploadDoneMock ).toHaveBeenCalledTimes( 1 );
 
     // subsequent upload uses cached client
     await upload( { key: 'wf/key2.json', content: '{}' } );
-    expect( sendMock ).toHaveBeenCalledTimes( 2 );
+    expect( uploadCtorState.args ).toHaveLength( 2 );
+    expect( uploadDoneMock ).toHaveBeenCalledTimes( 2 );
   } );
 } );
 

package/src/tracing/tools/build_trace_tree.js

@@ -62,7 +62,7 @@ export default entries => {
     if ( action === EventAction.START ) {
       Object.assign( node, { input: details, startedAt: timestamp, kind, name } );
     } else if ( action === EventAction.ADD_ATTR ) {
-      node.attributes[details.name] = details.value;
+      node.attributes[details.type] = details;
     } else if ( action === EventAction.END ) {
       Object.assign( node, { output: details, endedAt: timestamp } );
     } else if ( action === EventAction.ERROR ) {