refactor: wip

Author: BioPhoton

packages/utils/src/lib/performance-observer.int.test.ts

@@ -178,16 +178,4 @@ describe('PerformanceObserverSink', () => {
 
     expect(sink.getWrittenItems()).toHaveLength(2);
   });
-
-  it('throws error when subscribing with sink that is not open', () => {
-    const closedSink = new MockSink();
-    const observer = new PerformanceObserverSink({
-      sink: closedSink,
-      encodePerfEntry: encode,
-    });
-
-    expect(() => observer.subscribe()).toThrow(
-      'Sink MockSink must be opened before subscribing PerformanceObserver',
-    );
-  });
 });

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

@@ -169,7 +169,7 @@ describe('Profiler Integration', () => {
 
   it('should create proper DevTools payloads for tracks', () => {
     profiler.measure('track-test', (): string => 'result', {
-      success: (result: string) => ({
+      success: result => ({
         properties: [['result', result]],
         tooltipText: 'Track test completed',
       }),
@@ -196,8 +196,8 @@ describe('Profiler Integration', () => {
   });
 
   it('should merge track defaults with measurement options', () => {
-    profiler.measure('sync-op', (): string => 'sync-result', {
-      success: (result: string) => ({
+    profiler.measure('sync-op', () => 'sync-result', {
+      success: result => ({
         properties: [
           ['operation', 'sync'],
           ['result', result],
@@ -279,6 +279,24 @@ describe('Profiler Integration', () => {
       ]),
     );
   });
+
+  it('should not create performance entries when disabled', async () => {
+    profiler.setEnabled(false);
+
+    const syncResult = profiler.measure('disabled-sync', () => 'sync');
+    expect(syncResult).toBe('sync');
+
+    const asyncResult = profiler.measureAsync(
+      'disabled-async',
+      async () => 'async',
+    );
+    await expect(asyncResult).resolves.toBe('async');
+
+    profiler.marker('disabled-marker');
+
+    expect(performance.getEntriesByType('mark')).toHaveLength(0);
+    expect(performance.getEntriesByType('measure')).toHaveLength(0);
+  });
 });
 
 describe('NodeJS Profiler Integration', () => {
@@ -326,8 +344,8 @@ describe('NodeJS Profiler Integration', () => {
   });
 
   it('should disable profiling and close sink', () => {
-    nodejsProfiler.stop();
-    expect(nodejsProfiler.isRunning()).toBe(false);
+    nodejsProfiler.setEnabled(false);
+    expect(nodejsProfiler.isEnabled()).toBe(false);
     expect(mockSink.isClosed()).toBe(true);
     expect(mockSink.close).toHaveBeenCalledTimes(1);
 
@@ -339,10 +357,10 @@ describe('NodeJS Profiler Integration', () => {
   });
 
   it('should re-enable profiling correctly', () => {
-    nodejsProfiler.stop();
-    nodejsProfiler.start();
+    nodejsProfiler.setEnabled(false);
+    nodejsProfiler.setEnabled(true);
 
-    expect(nodejsProfiler.isRunning()).toBe(true);
+    expect(nodejsProfiler.isEnabled()).toBe(true);
     expect(mockSink.isClosed()).toBe(false);
     expect(mockSink.open).toHaveBeenCalledTimes(2);
 
@@ -378,15 +396,15 @@ describe('NodeJS Profiler Integration', () => {
       enabled: true,
     });
 
-    const bufferedStats = bufferedProfiler.getStats();
+    const bufferedStats = bufferedProfiler.stats;
     expect(bufferedStats.state).toBe('running');
     expect(bufferedStats.walOpen).toBe(true);
     expect(bufferedStats.isSubscribed).toBe(true);
     expect(bufferedStats.queued).toBe(0);
     expect(bufferedStats.dropped).toBe(0);
     expect(bufferedStats.written).toBe(0);
 
-    bufferedProfiler.stop();
+    bufferedProfiler.setEnabled(false);
   });
 
   it('should return correct getStats with dropped and written counts', () => {
@@ -402,15 +420,15 @@ describe('NodeJS Profiler Integration', () => {
 
     expect(statsProfiler.measure('test-op', () => 'result')).toBe('result');
 
-    const stats = statsProfiler.getStats();
+    const stats = statsProfiler.stats;
     expect(stats.state).toBe('running');
     expect(stats.walOpen).toBe(true);
     expect(stats.isSubscribed).toBe(true);
     expect(typeof stats.queued).toBe('number');
     expect(typeof stats.dropped).toBe('number');
     expect(typeof stats.written).toBe('number');
 
-    statsProfiler.stop();
+    statsProfiler.setEnabled(false);
   });
 
   it('should provide comprehensive queue statistics via getStats', () => {
@@ -425,7 +443,7 @@ describe('NodeJS Profiler Integration', () => {
     });
 
     // Initial stats should be zero
-    const initialStats = profiler.getStats();
+    const initialStats = profiler.stats;
     expect(initialStats.state).toBe('running');
     expect(initialStats.walOpen).toBe(true);
     expect(initialStats.isSubscribed).toBe(true);
@@ -437,7 +455,7 @@ describe('NodeJS Profiler Integration', () => {
     profiler.measure('operation-1', () => 'result1');
     profiler.measure('operation-2', () => 'result2');
 
-    const statsAfterMeasurements = profiler.getStats();
+    const statsAfterMeasurements = profiler.stats;
 
     // Verify all stats are present and are numbers
     expect(typeof statsAfterMeasurements.queued).toBe('number');
@@ -450,9 +468,9 @@ describe('NodeJS Profiler Integration', () => {
     expect(statsAfterMeasurements.written).toBeGreaterThanOrEqual(0);
 
     // Disable profiler to flush remaining items
-    profiler.stop();
+    profiler.setEnabled(false);
 
-    const finalStats = profiler.getStats();
+    const finalStats = profiler.stats;
     expect(finalStats.state).toBe('idle'); // Should be idle
     expect(finalStats.walOpen).toBe(false); // WAL should be closed when disabled
     expect(finalStats.isSubscribed).toBe(false); // Should not be subscribed when disabled

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

@@ -63,7 +63,7 @@ export type ProfilerOptions<T extends ActionTrackConfigs = ActionTrackConfigs> =
  *
  */
 export class Profiler<T extends ActionTrackConfigs> {
-  #enabled: boolean;
+  #enabled: boolean = false;
   readonly #defaults: ActionTrackEntryPayload;
   readonly tracks: Record<keyof T, ActionTrackEntryPayload> | undefined;
   readonly #ctxOf: ReturnType<typeof measureCtx>;
@@ -77,14 +77,14 @@ export class Profiler<T extends ActionTrackConfigs> {
    * @param options.track - Default track name for measurements
    * @param options.trackGroup - Default track group for organization
    * @param options.color - Default color for track entries
-   * @param options.enabled - Whether profiling is enabled (defaults to CP_PROFILING env var)
+   * @param options.enabled - Whether profiling is enabled (defaults to false)
    *
    */
   constructor(options: ProfilerOptions<T>) {
-    const { tracks, prefix, enabled, ...defaults } = options;
+    const { tracks, prefix, enabled = false, ...defaults } = options;
     const dataType = 'track-entry';
 
-    this.setEnabled(enabled ?? isEnvVarEnabled(PROFILER_ENABLED_ENV_VAR));
+    this.#enabled = enabled;
     this.#defaults = { ...defaults, dataType };
     this.tracks = tracks
       ? setupTracks({ ...defaults, dataType }, tracks)
@@ -284,10 +284,11 @@ export class NodejsProfiler<
       captureBufferedEntries,
       flushThreshold,
       maxQueueSize,
+      enabled,
       ...profilerOptions
     } = options;
-
-    super(profilerOptions);
+    const initialEnabled = enabled ?? isEnvVarEnabled(PROFILER_ENABLED_ENV_VAR);
+    super({ ...profilerOptions, enabled: initialEnabled });
 
     this.#sink = sink;
 
@@ -299,7 +300,7 @@ export class NodejsProfiler<
       maxQueueSize,
     });
 
-    if (super.isEnabled()) {
+    if (initialEnabled) {
       this.#transition('running');
     }
   }
@@ -320,19 +321,14 @@ export class NodejsProfiler<
         break;
 
       case 'running->idle':
+      case 'running->closed':
         super.setEnabled(false);
         this.#performanceObserverSink.unsubscribe();
         this.#sink.close();
         break;
 
       case 'idle->closed':
-        // No resources to clean up when idle
-        break;
-
-      case 'running->closed':
-        super.setEnabled(false);
-        this.#performanceObserverSink.unsubscribe();
-        this.#sink.close();
+        // No-op, was not open
         break;
 
       default:
@@ -342,16 +338,6 @@ export class NodejsProfiler<
     this.#state = next;
   }
 
-  /** Starts profiling (idle → running). */
-  start(): void {
-    this.#transition('running');
-  }
-
-  /** Stops profiling (running → idle). */
-  stop(): void {
-    this.#transition('idle');
-  }
-
   /**
    * Closes profiler and releases resources. Idempotent, safe for exit handlers.
    * **Exit Handler Usage**: Call only this method from process exit handlers.
@@ -366,16 +352,21 @@ export class NodejsProfiler<
   }
 
   /** @returns Whether profiler is in 'running' state */
-  protected isRunning(): boolean {
+  override isEnabled(): boolean {
     return this.#state === 'running';
   }
 
-  protected activeat(): boolean {
-    return this.#state === 'running';
+  /** Enables profiling (start/stop)*/
+  override setEnabled(enabled: boolean): void {
+    if (enabled) {
+      this.#transition('running');
+    } else {
+      this.#transition('idle');
+    }
   }
 
   /** @returns Queue statistics and profiling state for monitoring */
-  getStats() {
+  get stats() {
     return {
       ...this.#performanceObserverSink.getStats(),
       state: this.#state,