@outputai/core 0.10.1-next.fc0a41f.0 → 0.11.0

package/src/worker/telemetry.js

@@ -1,3 +1,4 @@
+import { serializeError } from '#helpers/error_serializer';
 import { createChildLogger } from '#logger';
 import { workerTelemetryIntervalMs } from './configs.js';
 
@@ -18,7 +19,7 @@ export const setupTelemetry = ( { worker } ) => {
         }
       } );
     } catch ( error ) {
-      log.warn( 'Failure', { error: error.message } );
+      log.warn( 'Failure', { error: serializeError( error, { dropKeys: [ 'stack' ] } ) } );
     }
   }, workerTelemetryIntervalMs ).unref();
 };

package/src/worker/temporal_logger.js

@@ -0,0 +1,33 @@
+import { DefaultLogger, makeTelemetryFilterString, Runtime } from '@temporalio/worker';
+import { createChildLogger } from '#logger';
+
+const log = createChildLogger( 'Temporal' );
+const OMITTED_MESSAGES = [ 'Activity failed', 'Workflow failed' ];
+
+const temporalLevelToInternalLevelMap = {
+  TRACE: 'debug',
+  DEBUG: 'debug',
+  INFO: 'info',
+  WARN: 'warn',
+  ERROR: 'error'
+};
+
+export const setupTemporalLogger = () => {
+  const level = process.env.OUTPUT_TEMPORAL_LOG_LEVEL?.toUpperCase() ?? 'INFO';
+
+  Runtime.install( {
+    logger: new DefaultLogger( level, entry => {
+      // Already reported by Output activity logs and traces.
+      if ( OMITTED_MESSAGES.includes( entry.message ) ) {
+        return;
+      }
+      log.log( temporalLevelToInternalLevelMap[entry.level], entry.message, entry.meta );
+    } ),
+    telemetryOptions: {
+      logging: {
+        forward: {},
+        filter: makeTelemetryFilterString( { core: level, other: level } )
+      }
+    }
+  } );
+};

package/src/worker/temporal_logger.spec.js

@@ -0,0 +1,90 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const {
+  defaultLoggerMock,
+  logMock,
+  makeTelemetryFilterStringMock,
+  runtimeInstallMock
+} = vi.hoisted( () => ( {
+  defaultLoggerMock: vi.fn( function ( level, callback ) {
+    this.level = level;
+    this.callback = callback;
+  } ),
+  logMock: { log: vi.fn() },
+  makeTelemetryFilterStringMock: vi.fn().mockReturnValue( 'temporal-filter' ),
+  runtimeInstallMock: vi.fn()
+} ) );
+
+vi.mock( '@temporalio/worker', () => ( {
+  DefaultLogger: defaultLoggerMock,
+  makeTelemetryFilterString: makeTelemetryFilterStringMock,
+  Runtime: { install: runtimeInstallMock }
+} ) );
+vi.mock( '#logger', () => ( { createChildLogger: () => logMock } ) );
+
+import { setupTemporalLogger } from './temporal_logger.js';
+
+describe( 'setupTemporalLogger', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+    vi.stubEnv( 'OUTPUT_TEMPORAL_LOG_LEVEL', undefined );
+  } );
+
+  afterEach( () => {
+    vi.unstubAllEnvs();
+  } );
+
+  it( 'forwards Temporal SDK and Core logs through the application logger', () => {
+    setupTemporalLogger();
+
+    expect( makeTelemetryFilterStringMock ).toHaveBeenCalledWith( { core: 'INFO', other: 'INFO' } );
+    expect( defaultLoggerMock ).toHaveBeenCalledWith( 'INFO', expect.any( Function ) );
+    expect( runtimeInstallMock ).toHaveBeenCalledWith( {
+      logger: expect.any( defaultLoggerMock ),
+      telemetryOptions: {
+        logging: {
+          forward: {},
+          filter: 'temporal-filter'
+        }
+      }
+    } );
+
+    const [ entryCallback ] = defaultLoggerMock.mock.calls[0].slice( 1 );
+    entryCallback( { level: 'WARN', message: 'Worker warning', meta: { taskQueue: 'default' } } );
+
+    expect( logMock.log ).toHaveBeenCalledWith( 'warn', 'Worker warning', { taskQueue: 'default' } );
+  } );
+
+  it.each( [
+    [ 'TRACE', 'debug' ],
+    [ 'DEBUG', 'debug' ],
+    [ 'INFO', 'info' ],
+    [ 'WARN', 'warn' ],
+    [ 'ERROR', 'error' ]
+  ] )( 'maps Temporal %s logs to the %s application level', ( temporalLevel, internalLevel ) => {
+    setupTemporalLogger();
+    const [ entryCallback ] = defaultLoggerMock.mock.calls[0].slice( 1 );
+
+    entryCallback( { level: temporalLevel, message: `${temporalLevel} event`, meta: { source: 'test' } } );
+
+    expect( logMock.log ).toHaveBeenCalledWith( internalLevel, `${temporalLevel} event`, { source: 'test' } );
+  } );
+
+  it( 'applies a case-insensitive configured log level to SDK and Core logs', () => {
+    vi.stubEnv( 'OUTPUT_TEMPORAL_LOG_LEVEL', 'debug' );
+
+    setupTemporalLogger();
+
+    expect( defaultLoggerMock ).toHaveBeenCalledWith( 'DEBUG', expect.any( Function ) );
+    expect( makeTelemetryFilterStringMock ).toHaveBeenCalledWith( { core: 'DEBUG', other: 'DEBUG' } );
+  } );
+
+  it.each( [ 'Activity failed', 'Workflow failed' ] )( 'omits redundant "%s" events', message => {
+    setupTemporalLogger();
+    const [ entryCallback ] = defaultLoggerMock.mock.calls[0].slice( 1 );
+
+    entryCallback( { level: 'WARN', message, meta: { error: new Error( 'failed' ) } } );
+
+    expect( logMock.log ).not.toHaveBeenCalled();
+  } );
+} );

package/src/helpers/aggregations.js

@@ -1,44 +0,0 @@
-import { Attribute } from '#trace_attribute';
-import Decimal from 'decimal.js';
-
-/**
- * @typedef {object} Aggregation
- *
- * @property {object} cost
- * @property {object} cost.total - Total cost
- * @property {object} tokens
- * @property {object} tokens.total - Total tokens used
- * @property {object} tokens.input  - Total input tokens used
- * @property {object} tokens.input_cached - Total cached input tokens used
- * @property {object} tokens.output - Total output tokens used
- * @property {object} tokens.reasoning - Total reasoning tokens used
- * @property {object} httpRequests
- * @property {object} httpRequests.total - Total number of http requests made
- */
-/**
- * Aggregates a collection of Attributes into a object with totals
- *
- * @param {Attribute} attributes
- * @returns {Aggregation} aggregation object
- */
-export const aggregateAttributes = attributes => ( {
-  cost: {
-    total: attributes
-      .filter( a => [ Attribute.HTTPRequestCost.TYPE, Attribute.LLMUsage.TYPE ].includes( a.type ) )
-      .reduce( ( sum, a ) => sum.add( a.total ), Decimal( 0 ) ).toNumber()
-  },
-  tokens: {
-    total: attributes
-      .filter( a => Attribute.LLMUsage.TYPE === a.type )
-      .reduce( ( sum, a ) => sum.add( a.tokensUsed ), Decimal( 0 ) ).toNumber(),
-    ...Object.entries( attributes
-      .filter( a => Attribute.LLMUsage.TYPE === a.type )
-      .flatMap( a => a.usage )
-      .reduce( ( obj, a ) => Object.assign( obj, { [a.type]: ( obj[a.type] ?? Decimal( 0 ) ).add( a.amount ) } ), {} ) )
-      .reduce( ( obj, [ k, v ] ) => Object.assign( obj, { [k]: v.toNumber() } ), {} ) // convert all values to number
-
-  },
-  httpRequests: {
-    total: attributes.filter( a => Attribute.HTTPRequestCount.TYPE === a.type ).length
-  }
-} );

package/src/helpers/aggregations.spec.js

@@ -1,92 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { Attribute } from '#trace_attribute';
-import { aggregateAttributes } from './aggregations.js';
-
-describe( 'aggregateAttributes', () => {
-  it( 'returns zeroed aggregations when there are no attributes', () => {
-    expect( aggregateAttributes( [] ) ).toEqual( {
-      cost: { total: 0 },
-      tokens: { total: 0 },
-      httpRequests: { total: 0 }
-    } );
-  } );
-
-  it( 'aggregates costs, token usage, and HTTP request count by attribute type', () => {
-    const attributes = [
-      {
-        type: Attribute.HTTPRequestCount.TYPE,
-        url: 'https://api.example.test/a',
-        requestId: 'req-1'
-      },
-      {
-        type: Attribute.HTTPRequestCount.TYPE,
-        url: 'https://api.example.test/b',
-        requestId: 'req-2'
-      },
-      {
-        type: Attribute.HTTPRequestCost.TYPE,
-        url: 'https://api.example.test/a',
-        requestId: 'req-1',
-        total: 0.2
-      },
-      {
-        type: Attribute.LLMUsage.TYPE,
-        modelId: 'gpt-4o',
-        total: 0.3,
-        tokensUsed: 120,
-        usage: [
-          { type: 'input', ppm: 1, amount: 100, total: 0.1 },
-          { type: 'output', ppm: 2, amount: 20, total: 0.2 }
-        ]
-      },
-      {
-        type: Attribute.LLMUsage.TYPE,
-        modelId: 'gpt-4o-mini',
-        total: 0.05,
-        tokensUsed: 30,
-        usage: [
-          { type: 'input', ppm: 1, amount: 25, total: 0.025 },
-          { type: 'reasoning', ppm: 5, amount: 5, total: 0.025 }
-        ]
-      },
-      {
-        type: 'unrelated',
-        total: 100,
-        tokensUsed: 100
-      }
-    ];
-
-    expect( aggregateAttributes( attributes ) ).toEqual( {
-      cost: { total: 0.55 },
-      tokens: {
-        total: 150,
-        input: 125,
-        output: 20,
-        reasoning: 5
-      },
-      httpRequests: { total: 2 }
-    } );
-  } );
-
-  it( 'uses LLMUsage.tokensUsed for total tokens instead of summing usage amounts', () => {
-    const attributes = [
-      {
-        type: Attribute.LLMUsage.TYPE,
-        modelId: 'provider-model',
-        total: 0.1,
-        tokensUsed: 42,
-        usage: [
-          { type: 'input', ppm: 1, amount: 10, total: 0.01 },
-          { type: 'output', ppm: 1, amount: 5, total: 0.005 }
-        ]
-      }
-    ];
-
-    expect( aggregateAttributes( attributes ).tokens ).toEqual( {
-      total: 42,
-      input: 10,
-      output: 5
-    } );
-  } );
-} );
-

package/src/tracing/tools/utils.js

@@ -1,42 +0,0 @@
-import { inspect } from 'node:util';
-
-/**
- * @typedef {object} SerializedError
- * @property {string} name - The error constructor name
- * @property {string} message - The error message
- * @property {string} stack - The error stack trace
- */
-
-/**
- * Recursively Serialize an error object. Navigate using "cause" property.
- *
- * Goes up 10 levels deep.
- *
- * @param {Error} error
- * @returns {SerializedError}
- */
-export const serializeError = ( () => {
-
-  const serializeValue = v => {
-    try {
-      return JSON.parse( JSON.stringify( v ) );
-    } catch {
-      return inspect( v, { depth: 5, breakLength: Infinity, colors: false } );
-    }
-  };
-
-  return ( error, depth = 0 ) => {
-    if ( depth > 10 ) {
-      return { name: 'Error', message: 'Cause chain too deep' };
-    }
-    if ( error instanceof Error ) {
-      return {
-        name: error.constructor.name,
-        message: error.message,
-        stack: error.stack,
-        ...( error.cause !== undefined ? { cause: serializeError( error.cause, depth + 1 ) } : {} )
-      };
-    }
-    return serializeValue( error );
-  };
-} )();

package/src/tracing/tools/utils.spec.js

@@ -1,83 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { serializeError } from './utils.js';
-
-describe( 'serializeError', () => {
-  it( 'serializes basic Error fields', () => {
-    const error = new Error( 'boom' );
-
-    const result = serializeError( error );
-
-    expect( result ).toMatchObject( {
-      name: 'Error',
-      message: 'boom'
-    } );
-    expect( typeof result.stack ).toBe( 'string' );
-    expect( result ).not.toHaveProperty( 'cause' );
-  } );
-
-  it( 'preserves custom error constructor names', () => {
-    class CustomError extends Error {}
-    const error = new CustomError( 'custom boom' );
-
-    expect( serializeError( error ) ).toMatchObject( {
-      name: 'CustomError',
-      message: 'custom boom'
-    } );
-  } );
-
-  it( 'recursively serializes Error causes', () => {
-    const root = new TypeError( 'root failure' );
-    const wrapped = new Error( 'wrapped failure', { cause: root } );
-
-    expect( serializeError( wrapped ) ).toMatchObject( {
-      name: 'Error',
-      message: 'wrapped failure',
-      cause: {
-        name: 'TypeError',
-        message: 'root failure'
-      }
-    } );
-  } );
-
-  it( 'preserves JSON-serializable non-Error causes', () => {
-    const cause = {
-      code: 'bad_input',
-      path: [ 'items', 0, 'title' ],
-      message: 'Expected title'
-    };
-    const error = new Error( 'validation failed', { cause } );
-
-    expect( serializeError( error ) ).toMatchObject( {
-      name: 'Error',
-      message: 'validation failed',
-      cause
-    } );
-  } );
-
-  it( 'falls back to inspect for non-JSON-serializable causes', () => {
-    const cause = { name: 'circular' };
-    cause.self = cause;
-    const error = new Error( 'failed', { cause } );
-
-    const result = serializeError( error );
-
-    expect( result.cause ).toContain( 'circular' );
-    expect( result.cause ).toContain( 'Circular' );
-  } );
-
-  it( 'falls back to inspect for primitive values JSON cannot serialize', () => {
-    expect( serializeError( 1n ) ).toBe( '1n' );
-  } );
-
-  it( 'stops serializing cause chains after the depth limit', () => {
-    const makeErrorChain = depth => depth === 0 ?
-      new Error( 'leaf' ) :
-      new Error( `level ${depth}`, { cause: makeErrorChain( depth - 1 ) } );
-    const getCauseAtDepth = ( error, depth ) => depth === 0 ?
-      error :
-      getCauseAtDepth( error.cause, depth - 1 );
-
-    expect( getCauseAtDepth( serializeError( makeErrorChain( 11 ) ), 11 ) )
-      .toEqual( { name: 'Error', message: 'Cause chain too deep' } );
-  } );
-} );