Function task

Build/trace/index.ts:114–164

(importMetaMain: boolean, importMetaPath: string)

export const dummySpan = createSpan('dummy');

export function task(importMetaMain: boolean, importMetaPath: string) {
  return (fn: (span: Span, onCleanup: (cb: () => Promise<void> | void) => void) => Promise<unknown>, customName?: string) => {
    const taskName = customName ?? basename(importMetaPath, extname(importMetaPath));
    let cleanup: () => Promise<void> | void = noop;
    const onCleanup = (cb: () => void) => {
      cleanup = cb;
    };

    if (importMetaMain) {
      const innerSpan = createSpan(taskName);

      process.on('uncaughtException', (error) => {
        console.error('Uncaught exception:', error);
        process.exit(1);
      });
      process.on('unhandledRejection', (reason) => {
        console.error('Unhandled rejection:', reason);
        process.exit(1);
      });

      innerSpan.traceChildAsync('dummy', (childSpan) => fn(childSpan, onCleanup)).finally(() => {
        innerSpan.stop();
        printTraceResult(innerSpan.traceResult);
        process.nextTick(whyIsNodeRunning);
        process.nextTick(() => process.exit(0));
      });
    }

    let runSpan: Span;
    async function run(parentSpan?: Span | null): Promise<TraceResult> {
      if (parentSpan) {
        runSpan = parentSpan.traceChild(taskName);
      } else {
        runSpan = createSpan(taskName);
      }

      try {
        await fn(runSpan, onCleanup);
      } finally {
        runSpan.stop();
        cleanup();
      }

      return runSpan.traceResult;
    }

    return Object.assign(run, {
      getInternalTraceResult: () => runSpan.traceResult
    });
  };
}

export async function whyIsNodeRunning() {
  if (isCI && process.env.RUNNER_DEBUG === '1') {