chore: introduce instrumentation api (#5385)

src/browserServerImpl.ts

@@ -31,9 +31,9 @@ import { createGuid } from './utils/utils';
 import { SelectorsDispatcher } from './dispatchers/selectorsDispatcher';
 import { Selectors } from './server/selectors';
 import { BrowserContext, Video } from './server/browserContext';
-import { StreamDispatcher, StreamWrapper } from './dispatchers/streamDispatcher';
+import { StreamDispatcher } from './dispatchers/streamDispatcher';
 import { ProtocolLogger } from './server/types';
-import { SdkObject } from './server/sdkObject';
+import { CallMetadata, internalCallMetadata, SdkObject } from './server/instrumentation';
 
 export class BrowserServerLauncherImpl implements BrowserServerLauncher {
   private _browserType: BrowserType;
@@ -43,7 +43,7 @@ export class BrowserServerLauncherImpl implements BrowserServerLauncher {
   }
 
   async launchServer(options: LaunchServerOptions = {}): Promise<BrowserServerImpl> {
-    const browser = await this._browserType.launch({
+    const browser = await this._browserType.launch(internalCallMetadata(), {
       ...options,
       ignoreDefaultArgs: Array.isArray(options.ignoreDefaultArgs) ? options.ignoreDefaultArgs : undefined,
       ignoreAllDefaultArgs: !!options.ignoreDefaultArgs && !Array.isArray(options.ignoreDefaultArgs),
@@ -119,7 +119,7 @@ export class BrowserServerImpl extends EventEmitter implements BrowserServer {
       connection.dispatch(JSON.parse(Buffer.from(message).toString()));
     });
     socket.on('error', () => {});
-    const selectors = new Selectors(this._browser.options.rootSdkObject);
+    const selectors = new Selectors();
     const scope = connection.rootDispatcher();
     const remoteBrowser = new RemoteBrowserDispatcher(scope, this._browser, selectors);
     socket.on('close', () => {
@@ -156,12 +156,12 @@ class ConnectedBrowser extends BrowserDispatcher {
     this._selectors = selectors;
   }
 
-  async newContext(params: channels.BrowserNewContextParams): Promise<{ context: channels.BrowserContextChannel }> {
+  async newContext(params: channels.BrowserNewContextParams, metadata: CallMetadata): Promise<{ context: channels.BrowserContextChannel }> {
     if (params.recordVideo) {
       // TODO: we should create a separate temp directory or accept a launchServer parameter.
       params.recordVideo.dir = this._object.options.downloadsPath!;
     }
-    const result = await super.newContext(params);
+    const result = await super.newContext(params, metadata);
     const dispatcher = result.context as BrowserContextDispatcher;
     dispatcher._object.on(BrowserContext.Events.VideoStarted, (video: Video) => this._sendVideo(dispatcher, video));
     dispatcher._object._setSelectors(this._selectors);
@@ -189,7 +189,7 @@ class ConnectedBrowser extends BrowserDispatcher {
     video._waitForCallbackOnFinish(async () => {
       const readable = fs.createReadStream(video._path);
       await new Promise(f => readable.on('readable', f));
-      const stream = new StreamDispatcher(this._remoteBrowser!._scope, new StreamWrapper(this._object, readable));
+      const stream = new StreamDispatcher(this._remoteBrowser!._scope, readable);
       this._remoteBrowser!._dispatchEvent('video', {
         stream,
         context: contextDispatcher,

src/cli/traceViewer/screenshotGenerator.ts

@@ -74,11 +74,11 @@ export class ScreenshotGenerator {
       const snapshots = action.snapshots || [];
       const snapshotId = snapshots.length ? snapshots[0].snapshotId : undefined;
       const snapshotUrl = this._snapshotServer.snapshotUrl(action.pageId!, snapshotId, action.endTime);
-      console.log('Generating screenshot for ' + action.action); // eslint-disable-line no-console
+      console.log('Generating screenshot for ' + action.method); // eslint-disable-line no-console
       await page.evaluate(snapshotUrl => (window as any).showSnapshot(snapshotUrl), snapshotUrl);
 
       try {
-        const element = await page.$(action.selector || '*[__playwright_target__]');
+        const element = await page.$(action.params.selector || '*[__playwright_target__]');
         if (element) {
           await element.evaluate(e => {
             e.style.backgroundColor = '#ff69b460';

src/dispatchers/androidDispatcher.ts

@@ -18,6 +18,7 @@ import { Dispatcher, DispatcherScope, existingDispatcher } from './dispatcher';
 import { Android, AndroidDevice, SocketBackend } from '../server/android/android';
 import * as channels from '../protocol/channels';
 import { BrowserContextDispatcher } from './browserContextDispatcher';
+import { CallMetadata } from '../server/instrumentation';
 
 export class AndroidDispatcher extends Dispatcher<Android, channels.AndroidInitializer> implements channels.AndroidChannel {
   constructor(scope: DispatcherScope, android: Android) {
@@ -141,7 +142,7 @@ export class AndroidDeviceDispatcher extends Dispatcher<AndroidDevice, channels.
     return { result: (await this._object.shell(params.command)).toString('base64') };
   }
 
-  async open(params: channels.AndroidDeviceOpenParams, metadata?: channels.Metadata): Promise<channels.AndroidDeviceOpenResult> {
+  async open(params: channels.AndroidDeviceOpenParams, metadata: CallMetadata): Promise<channels.AndroidDeviceOpenResult> {
     const socket = await this._object.open(params.command);
     return { socket: new AndroidSocketDispatcher(this._scope, socket) };
   }
@@ -182,11 +183,11 @@ export class AndroidSocketDispatcher extends Dispatcher<SocketBackend, channels.
     });
   }
 
-  async write(params: channels.AndroidSocketWriteParams, metadata?: channels.Metadata): Promise<void> {
+  async write(params: channels.AndroidSocketWriteParams, metadata: CallMetadata): Promise<void> {
     await this._object.write(Buffer.from(params.data, 'base64'));
   }
 
-  async close(params: channels.AndroidSocketCloseParams, metadata?: channels.Metadata): Promise<void> {
+  async close(params: channels.AndroidSocketCloseParams, metadata: CallMetadata): Promise<void> {
     await this._object.close();
   }
 }

src/dispatchers/browserContextDispatcher.ts

@@ -22,6 +22,7 @@ import { RouteDispatcher, RequestDispatcher } from './networkDispatchers';
 import { CRBrowserContext } from '../server/chromium/crBrowser';
 import { CDPSessionDispatcher } from './cdpSessionDispatcher';
 import { RecorderSupplement } from '../server/supplements/recorderSupplement';
+import { CallMetadata } from '../server/instrumentation';
 
 export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channels.BrowserContextInitializer> implements channels.BrowserContextChannel {
   private _context: BrowserContext;
@@ -120,8 +121,8 @@ export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channel
     });
   }
 
-  async storageState(): Promise<channels.BrowserContextStorageStateResult> {
-    return await this._context.storageState();
+  async storageState(params: channels.BrowserContextStorageStateParams, metadata: CallMetadata): Promise<channels.BrowserContextStorageStateResult> {
+    return await this._context.storageState(metadata);
   }
 
   async close(): Promise<void> {

src/dispatchers/browserDispatcher.ts

@@ -21,6 +21,7 @@ import { CDPSessionDispatcher } from './cdpSessionDispatcher';
 import { Dispatcher, DispatcherScope } from './dispatcher';
 import { CRBrowser } from '../server/chromium/crBrowser';
 import { PageDispatcher } from './pageDispatcher';
+import { CallMetadata } from '../server/instrumentation';
 
 export class BrowserDispatcher extends Dispatcher<Browser, channels.BrowserInitializer> implements channels.BrowserChannel {
   constructor(scope: DispatcherScope, browser: Browser) {
@@ -33,10 +34,10 @@ export class BrowserDispatcher extends Dispatcher<Browser, channels.BrowserIniti
     this._dispose();
   }
 
-  async newContext(params: channels.BrowserNewContextParams): Promise<channels.BrowserNewContextResult> {
+  async newContext(params: channels.BrowserNewContextParams, metadata: CallMetadata): Promise<channels.BrowserNewContextResult> {
     const context = await this._object.newContext(params);
     if (params.storageState)
-      await context.setStorageState(params.storageState);
+      await context.setStorageState(metadata, params.storageState);
     return { context: new BrowserContextDispatcher(this._scope, context) };
   }
 

src/dispatchers/browserTypeDispatcher.ts

@@ -19,6 +19,7 @@ import { BrowserDispatcher } from './browserDispatcher';
 import * as channels from '../protocol/channels';
 import { Dispatcher, DispatcherScope } from './dispatcher';
 import { BrowserContextDispatcher } from './browserContextDispatcher';
+import { CallMetadata } from '../server/instrumentation';
 
 export class BrowserTypeDispatcher extends Dispatcher<BrowserType, channels.BrowserTypeInitializer> implements channels.BrowserTypeChannel {
   constructor(scope: DispatcherScope, browserType: BrowserType) {
@@ -28,13 +29,13 @@ export class BrowserTypeDispatcher extends Dispatcher<BrowserType, channels.Brow
     }, true);
   }
 
-  async launch(params: channels.BrowserTypeLaunchParams): Promise<channels.BrowserTypeLaunchResult> {
-    const browser = await this._object.launch(params);
+  async launch(params: channels.BrowserTypeLaunchParams, metadata: CallMetadata): Promise<channels.BrowserTypeLaunchResult> {
+    const browser = await this._object.launch(metadata, params);
     return { browser: new BrowserDispatcher(this._scope, browser) };
   }
 
-  async launchPersistentContext(params: channels.BrowserTypeLaunchPersistentContextParams): Promise<channels.BrowserTypeLaunchPersistentContextResult> {
-    const browserContext = await this._object.launchPersistentContext(params.userDataDir, params);
+  async launchPersistentContext(params: channels.BrowserTypeLaunchPersistentContextParams, metadata: CallMetadata): Promise<channels.BrowserTypeLaunchPersistentContextResult> {
+    const browserContext = await this._object.launchPersistentContext(metadata, params.userDataDir, params);
     return { context: new BrowserContextDispatcher(this._scope, browserContext) };
   }
 }

src/dispatchers/dispatcher.ts

@@ -21,7 +21,7 @@ import { createScheme, Validator, ValidationError } from '../protocol/validator'
 import { assert, createGuid, debugAssert, isUnderTest } from '../utils/utils';
 import { tOptional } from '../protocol/validatorPrimitives';
 import { kBrowserOrContextClosedError } from '../utils/errors';
-import { SdkObject } from '../server/sdkObject';
+import { CallMetadata } from '../server/instrumentation';
 
 export const dispatcherSymbol = Symbol('dispatcher');
 
@@ -39,14 +39,7 @@ export function lookupNullableDispatcher<DispatcherType>(object: any | null): Di
   return object ? lookupDispatcher(object) : undefined;
 }
 
-export type CallMetadata = channels.Metadata & {
-  object: SdkObject;
-  type: string;
-  method: string;
-  params: any;
-};
-
-export class Dispatcher<Type extends SdkObject, Initializer> extends EventEmitter implements channels.Channel {
+export class Dispatcher<Type, Initializer> extends EventEmitter implements channels.Channel {
   private _connection: DispatcherConnection;
   private _isScope: boolean;
   // Parent is always "isScope".
@@ -120,9 +113,9 @@ export class Dispatcher<Type extends SdkObject, Initializer> extends EventEmitte
 }
 
 export type DispatcherScope = Dispatcher<any, any>;
-class Root extends Dispatcher<SdkObject, {}> {
+class Root extends Dispatcher<{}, {}> {
   constructor(connection: DispatcherConnection) {
-    super(connection, new SdkObject(null), '', {}, true, '');
+    super(connection, {}, '', {}, true, '');
   }
 }
 
@@ -186,8 +179,7 @@ export class DispatcherConnection {
       if (typeof (dispatcher as any)[method] !== 'function')
         throw new Error(`Mismatching dispatcher: "${dispatcher._type}" does not implement "${method}"`);
       const callMetadata: CallMetadata = {
-        ...this._validateMetadata(metadata).stack,
-        object: dispatcher._object,
+        ...this._validateMetadata(metadata),
         type: dispatcher._type,
         method,
         params,

src/dispatchers/downloadDispatcher.ts

@@ -17,7 +17,7 @@
 import { Download } from '../server/download';
 import * as channels from '../protocol/channels';
 import { Dispatcher, DispatcherScope } from './dispatcher';
-import { StreamDispatcher, StreamWrapper } from './streamDispatcher';
+import { StreamDispatcher } from './streamDispatcher';
 import * as fs from 'fs';
 import * as util from 'util';
 import { mkdirIfNeeded } from '../utils/utils';
@@ -65,7 +65,7 @@ export class DownloadDispatcher extends Dispatcher<Download, channels.DownloadIn
         try {
           const readable = fs.createReadStream(localPath);
           await new Promise(f => readable.on('readable', f));
-          const stream = new StreamDispatcher(this._scope, new StreamWrapper(this._object, readable));
+          const stream = new StreamDispatcher(this._scope, readable);
           // Resolve with a stream, so that client starts saving the data.
           resolve({ stream });
           // Block the download until the stream is consumed.
@@ -87,7 +87,7 @@ export class DownloadDispatcher extends Dispatcher<Download, channels.DownloadIn
       return {};
     const readable = fs.createReadStream(fileName);
     await new Promise(f => readable.on('readable', f));
-    return { stream: new StreamDispatcher(this._scope, new StreamWrapper(this._object, readable)) };
+    return { stream: new StreamDispatcher(this._scope, readable) };
   }
 
   async failure(): Promise<channels.DownloadFailureResult> {