@output.ai/core 0.0.16 → 0.1.0

package/src/tracing/index.public.spec.js

@@ -0,0 +1,86 @@
+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';
+
+const createTempDir = () => mkdtempSync( join( tmpdir(), 'output-sdk-trace-' ) );
+
+// Async storage mock to drive parent ids
+
+const mockStorageData = { parentId: undefined, traceId: 'trace-1', traceHelm: 'tests' };
+vi.mock( '#async_storage', () => ( { Storage: { load: () => mockStorageData } } ) );
+
+vi.mock( './tracer_tree.js', () => ( { buildLogTree: vi.fn() } ) );
+
+describe( 'Tracing (public namespace)', () => {
+  beforeEach( () => {
+    vi.resetModules();
+    vi.clearAllMocks();
+    vi.useFakeTimers();
+    vi.setSystemTime( new Date( '2020-01-01T00:00:00.000Z' ) );
+    process.env.TRACING_ENABLED = '1';
+  } );
+
+  afterEach( () => {
+    vi.useRealTimers();
+    delete process.env.TRACING_ENABLED;
+  } );
+
+  it( 'addEventStart writes a start entry', async () => {
+    const originalArgv2 = process.argv[2];
+    const tmp = createTempDir();
+    process.argv[2] = tmp;
+
+    const { Tracing } = await import( './index.js' );
+    Tracing.addEventStart( { id: '1', kind: 'evaluator', name: 'start', details: { a: 1 } } );
+
+    const { buildLogTree } = await import( './tracer_tree.js' );
+    const logPath = buildLogTree.mock.calls[0][0];
+    const raw = readFileSync( logPath, 'utf-8' );
+    const firstLine = raw.split( EOL )[0];
+    const entry = JSON.parse( firstLine );
+    expect( entry ).toMatchObject( { phase: 'start', kind: 'evaluator', name: 'start', id: '1', details: { a: 1 } } );
+
+    rmSync( tmp, { recursive: true, force: true } );
+    process.argv[2] = originalArgv2;
+  } );
+
+  it( 'addEventEnd writes an end entry', async () => {
+    const originalArgv2 = process.argv[2];
+    const tmp = createTempDir();
+    process.argv[2] = tmp;
+
+    const { Tracing } = await import( './index.js' );
+    Tracing.addEventEnd( { id: '1', details: { ok: true } } );
+
+    const { buildLogTree } = await import( './tracer_tree.js' );
+    const logPath = buildLogTree.mock.calls[0][0];
+    const raw = readFileSync( logPath, 'utf-8' );
+    const firstLine = raw.split( EOL )[0];
+    const entry = JSON.parse( firstLine );
+    expect( entry ).toMatchObject( { phase: 'end', id: '1', details: { ok: true } } );
+
+    rmSync( tmp, { recursive: true, force: true } );
+    process.argv[2] = originalArgv2;
+  } );
+
+  it( 'addEventError writes an error entry', async () => {
+    const originalArgv2 = process.argv[2];
+    const tmp = createTempDir();
+    process.argv[2] = tmp;
+
+    const { Tracing } = await import( './index.js' );
+    const error = new Error( 'boom' );
+    Tracing.addEventError( { id: '1', details: error } );
+
+    const { buildLogTree } = await import( './tracer_tree.js' );
+    const logPath = buildLogTree.mock.calls[0][0];
+    const raw = readFileSync( logPath, 'utf-8' );
+    const firstLine = raw.split( EOL )[0];
+    const entry = JSON.parse( firstLine );
+    expect( entry.phase ).toBe( 'error' );
+
+    rmSync( tmp, { recursive: true, force: true } );
+    process.argv[2] = originalArgv2;
+  } );
+} );

package/src/tracing/tracer_tree.js

@@ -0,0 +1,83 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { EOL } from 'os';
+
+/**
+ * @typedef {object} NodeEntry
+ * @property {string} id
+ * @property {string} kind
+ * @property {string} name
+ * @property {number} startedAt
+ * @property {number} endedAt
+ * @property {object} [input]
+ * @property {object} [output]
+ * @property {object} [error]
+ * @property {NodeTree[]} children
+ */
+/**
+ * Create a node entry for the tree.
+ *
+ * Properties are sorted the way they should be in the final file, as this makes it easier to read.
+ *
+ * @param {string} id - Node id
+ * @returns {NodeEntry} The entry without any values
+ */
+const createEntry = id => ( {
+  id,
+  kind: '',
+  name: '',
+  startedAt: 0,
+  endedAt: 0,
+  input: undefined,
+  output: undefined,
+  error: undefined,
+  children: []
+} );
+
+/**
+ * Build a tree of nodes from the raw trace file.
+ *
+ * Each node will have: id, name, kind, children, input, output or error, startedAt, endedAt.
+ *
+ * Entries with same id will be combined according to their phase (start, end OR error).
+ * - The details of the start phase becomes input, timestamp becomes startedAt;
+ * - The details of the end phase become output, timestamp becomes endedAt;
+ * - The details of the error phase become error, timestamp becomes endedAt;
+ * - Only start phase's kind and name are used;
+ *
+ *
+ * Children are added according to the parentId of each entry.
+ * The result tree has a single root: the only node without parentId, normally the workflow itself.
+ *
+ * @param {string} src - Full path to the raw log file (NDJSON)
+ * @returns {void}
+ */
+export const buildLogTree = src => {
+  const content = readFileSync( src, 'utf-8' );
+  const lines = content.split( EOL ).filter( l => l.trim().length > 0 );
+  const entries = lines.map( l => JSON.parse( l ) );
+
+  const nodes = new Map();
+  const ensureNode = id => nodes.get( id ) ?? nodes.set( id, createEntry( id ) ).get( id );
+
+  for ( const entry of entries ) {
+    const { kind, id, name, parentId, details, phase, timestamp } = entry;
+    const node = ensureNode( id );
+
+    if ( phase === 'start' ) {
+      Object.assign( node, { input: details, startedAt: timestamp, kind, name } );
+    } else if ( phase === 'end' ) {
+      Object.assign( node, { output: details, endedAt: timestamp } );
+    } else if ( phase === 'error' ) {
+      Object.assign( node, { error: details, endedAt: timestamp } );
+    }
+
+    if ( parentId && phase === 'start' ) {
+      const parent = ensureNode( parentId );
+      parent.children.push( node );
+      parent.children.sort( ( a, b ) => a.startedAt - b.startedAt );
+    }
+  }
+
+  const root = nodes.get( entries.find( e => !e.parentId ).id );
+  writeFileSync( src.replace( /\.raw$/, '.json' ), JSON.stringify( root, undefined, 2 ), 'utf-8' );
+};

package/src/tracing/tracer_tree.spec.js

@@ -0,0 +1,115 @@
+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';
+
+const createTempDir = () => mkdtempSync( join( tmpdir(), 'output-sdk-trace-tree-' ) );
+
+describe( 'tracer/tracer_tree', () => {
+  it( 'builds a tree from workflow/step/IO entries with grouping and sorting', () => {
+    const tmp = createTempDir();
+    const rawPath = join( tmp, 'run-123.raw' );
+
+    const entries = [
+      // workflow start
+      { kind: 'workflow', phase: 'start', name: 'wf', id: 'wf', parentId: undefined, details: { a: 1 }, timestamp: 1000 },
+      // evaluator start/stop
+      { kind: 'evaluator', phase: 'start', name: 'eval', id: 'eval', parentId: 'wf', details: { z: 0 }, timestamp: 1500 },
+      { kind: 'evaluator', phase: 'end', name: 'eval', id: 'eval', parentId: 'wf', details: { z: 1 }, timestamp: 1600 },
+      // step1 start
+      { kind: 'step', phase: 'start', name: 'step-1', id: 's1', parentId: 'wf', details: { x: 1 }, timestamp: 2000 },
+      // IO under step1
+      { kind: 'IO', phase: 'start', name: 'test-1', id: 'io1', parentId: 's1', details: { y: 2 }, timestamp: 2300 },
+      // step2 start
+      { kind: 'step', phase: 'start', name: 'step-2', id: 's2', parentId: 'wf', details: { x: 2 }, timestamp: 2400 },
+      // IO under step2
+      { kind: 'IO', phase: 'start', name: 'test-2', id: 'io2', parentId: 's2', details: { y: 3 }, timestamp: 2500 },
+      { kind: 'IO', phase: 'end', name: 'test-2', id: 'io2', parentId: 's2', details: { y: 4 }, timestamp: 2600 },
+      // IO under step1 ends
+      { kind: 'IO', phase: 'end', name: 'test-1', id: 'io1', parentId: 's1', details: { y: 5 }, timestamp: 2700 },
+      // step1 end
+      { kind: 'step', phase: 'end', name: 'step-1', id: 's1', parentId: 'wf', details: { done: true }, timestamp: 2800 },
+      // step2 end
+      { kind: 'step', phase: 'end', name: 'step-2', id: 's2', parentId: 'wf', details: { done: true }, timestamp: 2900 },
+      // workflow end
+      { kind: 'workflow', phase: 'end', name: 'wf', id: 'wf', parentId: undefined, details: { ok: true }, timestamp: 3000 }
+    ];
+
+    writeFileSync( rawPath, entries.map( e => JSON.stringify( e ) ).join( EOL ) + EOL, 'utf-8' );
+
+    buildLogTree( rawPath );
+
+    const jsonText = readFileSync( rawPath.replace( /.raw$/, '.json' ), 'utf-8' );
+
+    const expected = {
+      id: 'wf',
+      kind: 'workflow',
+      name: 'wf',
+      startedAt: 1000,
+      endedAt: 3000,
+      input: { a: 1 },
+      output: { ok: true },
+      children: [
+        {
+          id: 'eval',
+          kind: 'evaluator',
+          name: 'eval',
+          startedAt: 1500,
+          endedAt: 1600,
+          input: { z: 0 },
+          output: { z: 1 },
+          children: []
+        },
+        {
+          id: 's1',
+          kind: 'step',
+          name: 'step-1',
+          startedAt: 2000,
+          endedAt: 2800,
+          input: { x: 1 },
+          output: { done: true },
+          children: [
+            {
+              id: 'io1',
+              kind: 'IO',
+              name: 'test-1',
+              startedAt: 2300,
+              endedAt: 2700,
+              input: { y: 2 },
+              output: { y: 5 },
+              children: []
+            }
+          ]
+        },
+        {
+          id: 's2',
+          kind: 'step',
+          name: 'step-2',
+          startedAt: 2400,
+          endedAt: 2900,
+          input: { x: 2 },
+          output: { done: true },
+          children: [
+            {
+              id: 'io2',
+              kind: 'IO',
+              name: 'test-2',
+              startedAt: 2500,
+              endedAt: 2600,
+              input: { y: 3 },
+              output: { y: 4 },
+              children: []
+            }
+          ]
+        }
+      ]
+    };
+
+    expect( jsonText ).toBe( JSON.stringify( expected, undefined, 2 ) );
+
+    rmSync( tmp, { recursive: true, force: true } );
+  } );
+} );

package/src/tracing/utils.js

@@ -0,0 +1,21 @@
+/**
+ * @typedef {object} SerializedError
+ * @property {string} name - The error constructor name
+ * @property {string} message - The error message
+ * @property {string} stack - The error stack trace
+ */
+
+/**
+ * Serialize an error object.
+ *
+ * If it has ".cause", recursive serialize its cause until finally found an error without it.
+ *
+ * @param {Error} error
+ * @returns {SerializedError}
+ */
+export const serializeError = error =>
+  error.cause ? serializeError( error.cause ) : {
+    name: error.constructor.name,
+    message: error.message,
+    stack: error.stack
+  };

package/src/tracing/utils.spec.js

@@ -0,0 +1,14 @@
+import { describe, it, expect } from 'vitest';
+import { serializeError } from './utils.js';
+
+describe( 'tracing/utils', () => {
+  it( 'serializeError unwraps causes and keeps message/stack', () => {
+    const inner = new Error( 'inner' );
+    const outer = new Error( 'outer', { cause: inner } );
+
+    const out = serializeError( outer );
+    expect( out.name ).toBe( 'Error' );
+    expect( out.message ).toBe( 'inner' );
+    expect( typeof out.stack ).toBe( 'string' );
+  } );
+} );

package/src/worker/index.js

@@ -6,15 +6,11 @@ import { fileURLToPath } from 'node:url';
 import { worker as workerConfig } from '#configs';
 import { loadActivities, loadWorkflows, createWorkflowsEntryPoint } from './loader.js';
 import { ActivityExecutionInterceptor } from './interceptors/activity.js';
-import { setupGlobalTracer } from './tracer/index.js';
 import { sinks } from './sinks.js';
 import { createCatalog } from './catalog_workflow/index.js';
 
 const __dirname = dirname( fileURLToPath( import.meta.url ) );
 
-// expose the coreTracker so other parts of the SDK can use it
-setupGlobalTracer();
-
 const { address, apiKey, maxActivities, maxWorkflows, namespace, taskQueue, catalogId } = workerConfig;
 
 // Get caller directory from command line arguments

package/src/worker/interceptors/activity.js

@@ -1,8 +1,7 @@
 import { Context } from '@temporalio/activity';
-import { Storage } from '../async_storage.js';
-import { trace } from '../tracer/index.js';
+import { Storage } from '#async_storage';
+import { addEventStart, addEventEnd, addEventError } from '#tracing';
 import { headersToObject } from '../sandboxed_utils.js';
-import { THIS_LIB_NAME } from '#consts';
 import { METADATA_ACCESS_SYMBOL } from '#consts';
 
 /*
@@ -20,22 +19,28 @@ export class ActivityExecutionInterceptor {
   };
 
   async execute( input, next ) {
-    const { workflowExecution: { workflowId }, activityId, activityType, workflowType } = Context.current().info;
+    const { workflowExecution: { workflowId }, activityId, activityType } = Context.current().info;
+    const { traceId, traceHelm } = headersToObject( input.headers );
+    const { type: kind, skipTrace } = this.activities?.[activityType]?.[METADATA_ACCESS_SYMBOL];
 
-    const activityFn = this.activities?.[activityType];
-    const { type: componentType, skipTrace } = activityFn?.[METADATA_ACCESS_SYMBOL];
+    const traceContext = { kind, id: activityId, parentId: workflowId, name: activityType, traceId, traceHelm };
 
-    const context = { workflowId, workflowType, activityId, activityType, ...headersToObject( input.headers ) };
+    if ( !skipTrace ) {
+      addEventStart( { details: input.args[0], ...traceContext } );
+    }
 
-    return Storage.runWithContext( async _ => {
+    // creates a context for the nested tracing
+    try {
+      const output = await Storage.runWithContext( async _ => next( input ), { parentId: activityId, traceId, traceHelm } );
       if ( !skipTrace ) {
-        trace( { lib: THIS_LIB_NAME, event: `${componentType}_start`, input: input.args } );
+        addEventEnd( { details: output, ...traceContext } );
       }
-      const output = await next( input );
+      return output;
+    } catch ( error ) {
       if ( !skipTrace ) {
-        trace( { lib: THIS_LIB_NAME, event: `${componentType}_end`, output } );
+        addEventError( { details: error, ...traceContext } );
       }
-      return output;
-    }, context );
+      throw error;
+    }
   }
 };

package/src/worker/interceptors/workflow.js

@@ -1,5 +1,5 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
-import { workflowInfo } from '@temporalio/workflow';
+import { workflowInfo, proxySinks, ApplicationFailure } from '@temporalio/workflow';
 import { memoToHeaders } from '../sandboxed_utils.js';
 
 /*
@@ -18,6 +18,24 @@ class HeadersInjectionInterceptor {
   }
 };
 
+const sinks = proxySinks();
+
+class WorkflowExecutionInterceptor {
+  async execute( input, next ) {
+    sinks.trace.addWorkflowEventStart( input.args[0] );
+    try {
+      const output = await next( input );
+      // if the workflow is root, the result wraps "output" and "trace" onto an object, this will hide the trace
+      sinks.trace.addWorkflowEventEnd( !workflowInfo().memo.parentId ? output.output : output );
+      return output;
+    } catch ( error ) {
+      sinks.trace.addWorkflowEventError( error );
+      throw new ApplicationFailure( error.message, error.constructor.name );
+    }
+  }
+};
+
 export const interceptors = () => ( {
+  inbound: [ new WorkflowExecutionInterceptor() ],
   outbound: [ new HeadersInjectionInterceptor( workflowInfo().workflowType ) ]
 } );

package/src/worker/loader.js

@@ -1,7 +1,7 @@
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
-import { sendWebhookPost, readTraceFile } from '#internal_activities';
-import { SEND_WEBHOOK_ACTIVITY_NAME, WORKFLOWS_INDEX_FILENAME, READ_TRACE_FILE } from '#consts';
+import { sendWebhook, readTraceFile } from '#internal_activities';
+import { ACTIVITY_SEND_WEBHOOK, ACTIVITY_READ_TRACE_FILE, WORKFLOWS_INDEX_FILENAME } from '#consts';
 import {
   iteratorOverImportedComponents,
   recursiveNavigateWhileCollecting,
@@ -20,8 +20,8 @@ export async function loadActivities( path ) {
   }
 
   // system activities
-  activities[SEND_WEBHOOK_ACTIVITY_NAME] = sendWebhookPost;
-  activities[READ_TRACE_FILE] = readTraceFile;
+  activities[ACTIVITY_SEND_WEBHOOK] = sendWebhook;
+  activities[ACTIVITY_READ_TRACE_FILE] = readTraceFile;
   return activities;
 };
 

package/src/worker/loader.spec.js

@@ -1,18 +1,15 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
-const METADATA_ACCESS_SYMBOL = Symbol( '__metadata' );
-
 vi.mock( '#consts', () => ( {
-  SEND_WEBHOOK_ACTIVITY_NAME: '__internal#sendWebhookPost',
-  READ_TRACE_FILE: '__internal#readTraceFile',
-  WORKFLOWS_INDEX_FILENAME: '__workflows_entrypoint.js',
-  METADATA_ACCESS_SYMBOL
+  ACTIVITY_SEND_WEBHOOK: '__internal#sendWebhook',
+  ACTIVITY_READ_TRACE_FILE: '__internal#readTraceFile',
+  WORKFLOWS_INDEX_FILENAME: '__workflows_entrypoint.js'
 } ) );
 
-const sendWebhookPostMock = vi.fn();
+const sendWebhookMock = vi.fn();
 const readTraceFileMock = vi.fn();
 vi.mock( '#internal_activities', () => ( {
-  sendWebhookPost: sendWebhookPostMock,
+  sendWebhook: sendWebhookMock,
   readTraceFile: readTraceFileMock
 } ) );
 
@@ -41,7 +38,7 @@ describe( 'worker/loader', () => {
 
     const activities = await loadActivities( '/root' );
     expect( activities['/a#Act1'] ).toBeTypeOf( 'function' );
-    expect( activities['__internal#sendWebhookPost'] ).toBe( sendWebhookPostMock );
+    expect( activities['__internal#sendWebhook'] ).toBe( sendWebhookMock );
     expect( activities['__internal#readTraceFile'] ).toBe( readTraceFileMock );
   } );
 

package/src/worker/sinks.js

@@ -1,16 +1,62 @@
-import { Storage } from './async_storage.js';
-import { trace } from './tracer/index.js';
-import { THIS_LIB_NAME } from '#consts';
+import { addEventStart, addEventEnd, addEventError } from '#tracing';
 
+/**
+ * Start a workflow trace event
+ *
+ * @param {function} method - Trace function to call
+ * @param {object} workflowInfo - Temporal workflowInfo object
+ * @param {object} details - Teh details to attach to the event
+ */
+const addWorkflowEvent = ( method, workflowInfo, details ) => {
+  const { workflowId: id, workflowType: name, memo: { parentId, traceId, traceHelm } } = workflowInfo;
+  method( { id, kind: 'workflow', name, details, parentId, traceId, traceHelm } );
+};
+
+/**
+ * Start a trace event with given configuration
+ *
+ * @param {function} method - Trace function to call
+ * @param {object} workflowInfo - Temporal workflowInfo object
+ * @param {object} options - Trace options, like id, kind, name and details
+ */
+const addEvent = ( method, workflowInfo, options ) => {
+  const { id, name, kind, details } = options;
+  const { workflowId, memo: { traceId, traceHelm } } = workflowInfo;
+  method( { id, kind, name, details, parentId: workflowId, traceId, traceHelm } );
+};
+
+// This sink allow for sandbox Temporal environment to send trace logs back to the main thread.
 export const sinks = {
-  // This sink allow for sandbox Temporal environment to send trace logs back to the main thread.
-  log: {
-    trace: {
-      fn( workflowInfo, args ) {
-        const { workflowId, workflowType, memo } = workflowInfo;
-        Storage.runWithContext( _ => trace( { lib: THIS_LIB_NAME, ...args } ), { workflowId, workflowType, ...memo } );
-      },
+  trace: {
+    addWorkflowEventStart: {
+      fn: ( ...args ) => addWorkflowEvent( addEventStart, ...args ),
+      callDuringReplay: false
+    },
+
+    addWorkflowEventEnd: {
+      fn: ( ...args ) => addWorkflowEvent( addEventEnd, ...args ),
+      callDuringReplay: false
+    },
+
+    addWorkflowEventError: {
+      fn: ( ...args ) => addWorkflowEvent( addEventError, ...args ),
       callDuringReplay: false
+    },
+
+    addEventStart: {
+      fn: ( ...args ) => addEvent( addEventStart, ...args ),
+      callDuringReplay: false
+    },
+
+    addEventEnd: {
+      fn: ( ...args ) => addEvent( addEventEnd, ...args ),
+      callDuringReplay: false
+    },
+
+    addEventError: {
+      fn: ( ...args ) => addEvent( addEventError, ...args ),
+      callDuringReplay: false
+
     }
   }
 };

package/src/worker/tracer/index.js

@@ -1,75 +0,0 @@
-import { Storage } from '../async_storage.js';
-import { mkdirSync, existsSync, readdirSync, appendFileSync } from 'node:fs';
-import { join } from 'path';
-import { EOL } from 'os';
-import { buildLogTree } from './tracer_tree.js';
-import { tracing as tracingConfig } from '#configs';
-
-const callerDir = process.argv[2];
-
-/**
- * Appends new information to a file
- *
- * Information has to be a JSON
- *
- * File is encoded in utf-8
- *
- * @param {string} path - The full filename
- * @param {object} json - The content
- */
-const flushEntry = ( path, json ) => appendFileSync( path, JSON.stringify( json ) + EOL, 'utf-8' );
-
-/**
- * Add an event to the execution trace file.
- *
- * Events normally are the result of an operation, either a function call or an IO.
- *
- * @param {object} options
- * @param {string} options.lib - The macro part of the platform that triggered the event
- * @param {string} options.event - The name of the event
- * @param {any} [options.input] - The input of the operation
- * @param {any} [options.output] - The output of the operation
- */
-export function trace( { lib, event, input = undefined, output = undefined } ) {
-  const now = Date.now();
-
-  if ( !tracingConfig.enabled ) {
-    return;
-  }
-
-  const {
-    activityId: stepId,
-    activityType: stepName,
-    workflowId,
-    workflowType,
-    workflowPath,
-    parentWorkflowId,
-    rootWorkflowId,
-    rootWorkflowType
-  } = Storage.load();
-
-  const entry = { event, input, lib, output, parentWorkflowId, stepId, stepName, timestamp: now, workflowId, workflowPath, workflowType };
-
-  // test for rootWorkflow to append to the same file as the parent/grandparent
-  const outputDir = join( callerDir, 'logs', 'runs', rootWorkflowType ?? workflowType );
-  if ( !existsSync( outputDir ) ) {
-    mkdirSync( outputDir, { recursive: true } );
-  }
-
-  const suffix = `-${rootWorkflowId ?? workflowId}.raw`;
-  const logFile = readdirSync( outputDir ).find( f => f.endsWith( suffix ) ) ?? `${new Date( now ).toISOString()}-${suffix}`;
-  const logPath = join( outputDir, logFile );
-
-  flushEntry( logPath, entry );
-  buildLogTree( logPath );
-};
-
-/**
- * Setup the global tracer function, so it is available to be used by other libraries
- *
- * It will be situated in the global object, under Symbol.for('__trace')
- *
- * @returns {object} The assigned globalThis
- */
-export const setupGlobalTracer = () =>
-  Object.defineProperty( globalThis, Symbol.for( '__trace' ), { value: trace, writable: false, enumerable: false, configurable: false } );