refactor: fix lint

Author: BioPhoton

packages/utils/src/lib/profiler/profiler-node.int.test.ts

@@ -1,4 +1,4 @@
-import { MockTraceEventFileSink } from '../../../mocks/sink.mock.js';
+import path from 'node:path';
 import type { PerformanceEntryEncoder } from '../performance-observer.js';
 import { NodejsProfiler } from './profiler-node.js';
 
@@ -10,7 +10,6 @@ describe('NodeJS Profiler Integration', () => {
     return [];
   };
 
-  let mockSink: MockTraceEventFileSink;
   let nodejsProfiler: NodejsProfiler<string>;
   const originalProfilingEnv = process.env.CP_PROFILING;
   const originalDebugEnv = process.env.CP_PROFILER_DEBUG;
@@ -23,13 +22,11 @@ describe('NodeJS Profiler Integration', () => {
     // eslint-disable-next-line functional/immutable-data
     delete process.env.CP_PROFILER_DEBUG;
 
-    mockSink = new MockTraceEventFileSink();
-
     nodejsProfiler = new NodejsProfiler({
       prefix: 'test',
       track: 'test-track',
-      sink: mockSink,
       encodePerfEntry: simpleEncoder,
+      filename: path.join(process.cwd(), 'tmp', 'int', 'utils', 'trace.json'),
       enabled: true,
     });
   });
@@ -55,9 +52,8 @@ describe('NodeJS Profiler Integration', () => {
   });
 
   it('should initialize with sink opened when enabled', () => {
-    expect(mockSink.isClosed()).toBeFalse();
     expect(nodejsProfiler.isEnabled()).toBeTrue();
-    expect(mockSink.open).toHaveBeenCalledOnce();
+    expect(nodejsProfiler.stats.walOpen).toBeTrue();
   });
 
   it('should create performance entries and write to sink', () => {
@@ -75,26 +71,24 @@ describe('NodeJS Profiler Integration', () => {
     ).resolves.toBe('async-result');
   });
 
-  it('should disable profiling and keep sink open', () => {
+  it('should disable profiling and close sink', () => {
     nodejsProfiler.setEnabled(false);
     expect(nodejsProfiler.isEnabled()).toBeFalse();
-    expect(mockSink.isClosed()).toBeFalse();
-    expect(mockSink.close).not.toHaveBeenCalled();
+    expect(nodejsProfiler.stats.walOpen).toBeFalse();
 
     expect(nodejsProfiler.measure('disabled-test', () => 'success')).toBe(
       'success',
     );
-
-    expect(mockSink.getWrittenItems()).toHaveLength(0);
   });
 
   it('should re-enable profiling correctly', () => {
     nodejsProfiler.setEnabled(false);
+    expect(nodejsProfiler.stats.walOpen).toBeFalse();
+
     nodejsProfiler.setEnabled(true);
 
     expect(nodejsProfiler.isEnabled()).toBeTrue();
-    expect(mockSink.isClosed()).toBeFalse();
-    expect(mockSink.open).toHaveBeenCalledTimes(2);
+    expect(nodejsProfiler.stats.walOpen).toBeTrue();
 
     expect(nodejsProfiler.measure('re-enabled-test', () => 42)).toBe(42);
   });
@@ -107,8 +101,14 @@ describe('NodeJS Profiler Integration', () => {
         db: { track: 'Database', color: 'secondary' },
         cache: { track: 'Cache', color: 'primary' },
       },
-      sink: mockSink,
       encodePerfEntry: simpleEncoder,
+      filename: path.join(
+        process.cwd(),
+        'tmp',
+        'int',
+        'utils',
+        'trace-tracks.json',
+      ),
     });
 
     expect(
@@ -124,15 +124,21 @@ describe('NodeJS Profiler Integration', () => {
     const bufferedProfiler = new NodejsProfiler({
       prefix: 'buffered-test',
       track: 'Test',
-      sink: mockSink,
       encodePerfEntry: simpleEncoder,
       captureBufferedEntries: true,
+      filename: path.join(
+        process.cwd(),
+        'tmp',
+        'int',
+        'utils',
+        'trace-buffered.json',
+      ),
       enabled: true,
     });
 
     const bufferedStats = bufferedProfiler.stats;
     expect(bufferedStats.state).toBe('running');
-    expect(bufferedStats.sinkOpen).toBeTrue();
+    expect(bufferedStats.walOpen).toBeTrue();
     expect(bufferedStats.isSubscribed).toBeTrue();
     expect(bufferedStats.queued).toBe(0);
     expect(bufferedStats.dropped).toBe(0);
@@ -145,18 +151,24 @@ describe('NodeJS Profiler Integration', () => {
     const statsProfiler = new NodejsProfiler({
       prefix: 'stats-test',
       track: 'Stats',
-      sink: mockSink,
       encodePerfEntry: simpleEncoder,
       maxQueueSize: 2,
       flushThreshold: 2,
+      filename: path.join(
+        process.cwd(),
+        'tmp',
+        'int',
+        'utils',
+        'trace-stats.json',
+      ),
       enabled: true,
     });
 
     expect(statsProfiler.measure('test-op', () => 'result')).toBe('result');
 
     const stats = statsProfiler.stats;
     expect(stats.state).toBe('running');
-    expect(stats.sinkOpen).toBeTrue();
+    expect(stats.walOpen).toBeTrue();
     expect(stats.isSubscribed).toBeTrue();
     expect(typeof stats.queued).toBe('number');
     expect(typeof stats.dropped).toBe('number');
@@ -169,16 +181,22 @@ describe('NodeJS Profiler Integration', () => {
     const profiler = new NodejsProfiler({
       prefix: 'stats-profiler',
       track: 'Stats',
-      sink: mockSink,
       encodePerfEntry: simpleEncoder,
       maxQueueSize: 3,
       flushThreshold: 2,
+      filename: path.join(
+        process.cwd(),
+        'tmp',
+        'int',
+        'utils',
+        'trace-stats-comprehensive.json',
+      ),
       enabled: true,
     });
 
     const initialStats = profiler.stats;
     expect(initialStats.state).toBe('running');
-    expect(initialStats.sinkOpen).toBeTrue();
+    expect(initialStats.walOpen).toBeTrue();
     expect(initialStats.isSubscribed).toBeTrue();
     expect(initialStats.queued).toBe(0);
     expect(initialStats.dropped).toBe(0);
@@ -193,7 +211,7 @@ describe('NodeJS Profiler Integration', () => {
 
     const finalStats = profiler.stats;
     expect(finalStats.state).toBe('idle');
-    expect(finalStats.sinkOpen).toBeTrue();
+    expect(finalStats.walOpen).toBeFalse();
     expect(finalStats.isSubscribed).toBeFalse();
     expect(finalStats.queued).toBe(0);
 

packages/utils/src/lib/profiler/profiler-node.ts

@@ -1,3 +1,4 @@
+import path from 'node:path';
 import { isEnvVarEnabled } from '../env.js';
 import { subscribeProcessExit } from '../exit-process.js';
 import {
@@ -10,7 +11,7 @@ import type {
   ActionTrackEntryPayload,
   MarkerPayload,
 } from '../user-timing-extensibility-api.type.js';
-import type { AppendableSink } from '../wal.js';
+import { type AppendableSink, WriteAheadLogFile, stringCodec } from '../wal.js';
 import {
   PROFILER_DEBUG_ENV_VAR,
   PROFILER_ENABLED_ENV_VAR,
@@ -30,10 +31,12 @@ export type NodejsProfilerOptions<
 > = ProfilerOptions<Tracks> &
   Omit<PerformanceObserverOptions<DomainEvents>, 'sink'> & {
     /**
-     * Sink for buffering and flushing performance data
+     * File path for the WriteAheadLogFile sink.
+     * If not provided, defaults to `trace.json` in the current working directory.
+     *
+     * @default path.join(process.cwd(), 'trace.json')
      */
-    sink: AppendableSink<DomainEvents>;
-
+    filename?: string;
     /**
      * Name of the environment variable to check for debug mode.
      * When the env var is set to 'true', profiler state transitions create performance marks for debugging.
@@ -47,12 +50,11 @@ export type NodejsProfilerOptions<
  * Performance profiler with automatic process exit handling for buffered performance data.
  *
  * This class extends the base {@link Profiler} with automatic flushing of performance data
- * when the process exits. It accepts a {@link PerformanceObserverSink} that buffers performance
- * entries and ensures they are written out during process termination, even for unexpected exits.
+ * when the process exits. It automatically creates a {@link WriteAheadLogFile} sink that buffers
+ * performance entries and ensures they are written out during process termination, even for unexpected exits.
  *
- * The sink defines the output format for performance data, enabling flexible serialization
- * to various formats such as DevTools TraceEvent JSON, OpenTelemetry protocol buffers,
- * or custom domain-specific formats.
+ * The sink uses a default codec for serializing performance data to JSON format,
+ * enabling compatibility with Chrome DevTools trace file format.
  *
  * The profiler automatically subscribes to the performance observer when enabled and installs
  * exit handlers that flush buffered data on process termination (signals, fatal errors, or normal exit).
@@ -76,27 +78,31 @@ export class NodejsProfiler<
 
   /**
    * Creates a NodejsProfiler instance.
-   * @param options - Configuration with required sink
+   * A WriteAheadLogFile sink is automatically created for buffering performance data.
+   * @param options - Configuration options
    */
   constructor(options: NodejsProfilerOptions<DomainEvents, Tracks>) {
     const {
-      sink,
       encodePerfEntry,
       captureBufferedEntries,
       flushThreshold,
       maxQueueSize,
       enabled,
+      filename,
       debugEnvVar = PROFILER_DEBUG_ENV_VAR,
       ...profilerOptions
     } = options;
     const initialEnabled = enabled ?? isEnvVarEnabled(PROFILER_ENABLED_ENV_VAR);
     super({ ...profilerOptions, enabled: initialEnabled });
 
-    this.#sink = sink;
+    this.#sink = new WriteAheadLogFile({
+      file: filename ?? path.join(process.cwd(), 'trace.json'),
+      codec: stringCodec<DomainEvents>(),
+    });
     this.#debug = isEnvVarEnabled(debugEnvVar);
 
     this.#performanceObserverSink = new PerformanceObserverSink({
-      sink,
+      sink: this.#sink,
       encodePerfEntry,
       captureBufferedEntries,
       flushThreshold,
@@ -155,9 +161,14 @@ export class NodejsProfiler<
    */
   #handleFatalError(
     error: unknown,
-    _kind: 'uncaughtException' | 'unhandledRejection',
+    kind: 'uncaughtException' | 'unhandledRejection',
   ): void {
-    this.marker('Fatal Error', errorToMarkerPayload(error));
+    this.marker(
+      'Fatal Error',
+      errorToMarkerPayload(error, {
+        tooltipText: `${kind} caused fatal error`,
+      }),
+    );
     this.close(); // Ensures buffers flush and sink finalizes
   }
 
@@ -166,7 +177,7 @@ export class NodejsProfiler<
    *
    * State transitions enforce lifecycle invariants:
    * - `idle -> running`: Enables profiling, opens sink, and subscribes to performance observer
-   * - `running -> idle`: Disables profiling and unsubscribes (sink remains open for potential re-enable)
+   * - `running -> idle`: Disables profiling, unsubscribes, and closes sink (sink will be reopened on re-enable)
    * - `running -> closed`: Disables profiling, unsubscribes, and closes sink (irreversible)
    * - `idle -> closed`: Closes sink if it was opened (irreversible)
    *
@@ -191,11 +202,6 @@ export class NodejsProfiler<
         break;
 
       case 'running->idle':
-        super.setEnabled(false);
-        this.#performanceObserverSink.unsubscribe();
-        // DO NOT close sink - it must remain open for potential re-enable
-        break;
-
       case 'running->closed':
         super.setEnabled(false);
         this.#performanceObserverSink.unsubscribe();
@@ -255,7 +261,7 @@ export class NodejsProfiler<
       ...this.#performanceObserverSink.getStats(),
       debug: this.#debug,
       state: this.#state,
-      sinkOpen: !this.#sink.isClosed(),
+      walOpen: !this.#sink.isClosed(),
     };
   }