chore: make instrumentation multiplexing proxy-based

src/server/instrumentation.ts

@@ -72,37 +72,17 @@ export interface InstrumentationListener {
   onAfterAction?(result: ActionResult, sdkObject: SdkObject, metadata: CallMetadata): Promise<void>;
 }
 
-export class InstrumentationMultiplexer implements Instrumentation {
-  private _listeners: InstrumentationListener[];
-
-  constructor(listeners: InstrumentationListener[]) {
-    this._listeners = listeners;
-  }
-
-  async onContextCreated(context: BrowserContext): Promise<void> {
-    for (const listener of this._listeners)
-      await listener.onContextCreated?.(context);
-  }
-
-  async onContextWillDestroy(context: BrowserContext): Promise<void> {
-    for (const listener of this._listeners)
-      await listener.onContextWillDestroy?.(context);
-  }
-
-  async onContextDidDestroy(context: BrowserContext): Promise<void> {
-    for (const listener of this._listeners)
-      await listener.onContextDidDestroy?.(context);
-  }
-
-  async onActionCheckpoint(name: string, sdkObject: SdkObject, metadata: CallMetadata): Promise<void> {
-    for (const listener of this._listeners)
-      await listener.onActionCheckpoint?.(name, sdkObject, metadata);
-  }
-
-  async onAfterAction(result: ActionResult, sdkObject: SdkObject, metadata: CallMetadata): Promise<void> {
-    for (const listener of this._listeners)
-      await listener.onAfterAction?.(result, sdkObject, metadata);
-  }
+export function multiplexInstrumentation(listeners: InstrumentationListener[]): Instrumentation {
+  return new Proxy({}, {
+    get: (obj: any, prop: string) => {
+      if (!prop.startsWith('on'))
+        return obj[prop];
+      return async (...params: any[]) => {
+        for (const listener of listeners)
+          await (listener as any)[prop]?.(...params);
+      };
+    },
+  });
 }
 
 export function internalCallMetadata(): CallMetadata {

src/server/playwright.ts

@@ -27,7 +27,7 @@ import { HarTracer } from './supplements/har/harTracer';
 import { InspectorController } from './supplements/inspectorController';
 import { WebKit } from './webkit/webkit';
 import { Registry } from '../utils/registry';
-import { InstrumentationMultiplexer, SdkObject } from './instrumentation';
+import { InstrumentationListener, multiplexInstrumentation, SdkObject } from './instrumentation';
 
 export class Playwright extends SdkObject {
   readonly selectors: Selectors;
@@ -39,11 +39,13 @@ export class Playwright extends SdkObject {
   readonly options: PlaywrightOptions;
 
   constructor(isInternal: boolean) {
-    const instrumentation = new InstrumentationMultiplexer(isInternal ? [] : [
-      new InspectorController(),
-      new Tracer(),
-      new HarTracer()
-    ]);
+    const listeners: InstrumentationListener[] = [];
+    if (!isInternal) {
+      listeners.push(new Tracer());
+      listeners.push(new HarTracer());
+      listeners.push(new InspectorController());
+    }
+    const instrumentation = multiplexInstrumentation(listeners);
     super({ attribution: {}, instrumentation } as any);
     this.options = {
       isInternal,

src/server/supplements/har/harTracer.ts

@@ -42,8 +42,6 @@ export class HarTracer implements InstrumentationListener {
       await contextTracer.flush();
     }
   }
-
-  async onContextDidDestroy(context: BrowserContext): Promise<void> { }
 }
 
 type HarOptions = {

src/server/supplements/inspectorController.ts

@@ -28,6 +28,4 @@ export class InspectorController implements InstrumentationListener {
       });
     }
   }
-  async onContextWillDestroy(context: BrowserContext): Promise<void> {}
-  async onContextDidDestroy(context: BrowserContext): Promise<void> {}
 }

src/trace/tracer.ts

@@ -47,8 +47,6 @@ export class Tracer implements InstrumentationListener {
     this._contextTracers.set(context, contextTracer);
   }
 
-  async onContextWillDestroy(context: BrowserContext): Promise<void> {}
-
   async onContextDidDestroy(context: BrowserContext): Promise<void> {
     const contextTracer = this._contextTracers.get(context);
     if (contextTracer) {