Skip to content

Playwright is a framework for Web Testing and Automation. It allows testing Chromium, Firefox and WebKit with a single API.

chore: make sure dispatchers work with SdkObjects (#36158)

Dmitry Gozmandf0e0fb88ced
diff --git a/packages/playwright-core/src/server/android/android.ts b/packages/playwright-core/src/server/android/android.ts
index 70a95b720a..b8a4c4772f 100644
--- a/packages/playwright-core/src/server/android/android.ts
+++ b/packages/playwright-core/src/server/android/android.ts
@@ -59,7 +59,6 @@ export interface DeviceBackend {
}
export interface SocketBackend extends EventEmitter {
- guid: string;
write(data: Buffer): Promise<void>;
close(): void;
}
diff --git a/packages/playwright-core/src/server/android/backendAdb.ts b/packages/playwright-core/src/server/android/backendAdb.ts
index 88b7c8896a..b25b5a24f3 100644
--- a/packages/playwright-core/src/server/android/backendAdb.ts
+++ b/packages/playwright-core/src/server/android/backendAdb.ts
@@ -18,7 +18,6 @@ import { EventEmitter } from 'events';
import net from 'net';
import { assert } from '../../utils/isomorphic/assert';
-import { createGuid } from '../utils/crypto';
import { debug } from '../../utilsBundle';
import type { Backend, DeviceBackend, SocketBackend } from './android';
@@ -117,7 +116,6 @@ function encodeMessage(message: string): Buffer {
}
class BufferedSocketWrapper extends EventEmitter implements SocketBackend {
- readonly guid = createGuid();
private _socket: net.Socket;
private _buffer = Buffer.from([]);
private _isSocket = false;
diff --git a/packages/playwright-core/src/server/browserType.ts b/packages/playwright-core/src/server/browserType.ts
index 8564f44081..84f9cdaf12 100644
--- a/packages/playwright-core/src/server/browserType.ts
+++ b/packages/playwright-core/src/server/browserType.ts
@@ -56,6 +56,7 @@ export abstract class BrowserType extends SdkObject {
super(parent, 'browser-type');
this.attribution.browserType = this;
this._name = browserName;
+ this.logName = 'browser';
}
executablePath(): string {
@@ -69,7 +70,6 @@ export abstract class BrowserType extends SdkObject {
async launch(metadata: CallMetadata, options: types.LaunchOptions, protocolLogger?: types.ProtocolLogger): Promise<Browser> {
options = this._validateLaunchOptions(options);
const controller = new ProgressController(metadata, this);
- controller.setLogName('browser');
const browser = await controller.run(progress => {
const seleniumHubUrl = (options as any).__testHookSeleniumRemoteURL || process.env.SELENIUM_REMOTE_URL;
if (seleniumHubUrl)
@@ -82,7 +82,6 @@ export abstract class BrowserType extends SdkObject {
async launchPersistentContext(metadata: CallMetadata, userDataDir: string, options: channels.BrowserTypeLaunchPersistentContextOptions & { timeout: number, cdpPort?: number, internalIgnoreHTTPSErrors?: boolean }): Promise<BrowserContext> {
const launchOptions = this._validateLaunchOptions(options);
const controller = new ProgressController(metadata, this);
- controller.setLogName('browser');
const browser = await controller.run(async progress => {
// Note: Any initial TLS requests will fail since we rely on the Page/Frames initialize which sets ignoreHTTPSErrors.
let clientCertificatesProxy: ClientCertificatesProxy | undefined;
diff --git a/packages/playwright-core/src/server/chromium/chromium.ts b/packages/playwright-core/src/server/chromium/chromium.ts
index 61c4b0cc72..5f7408c80c 100644
--- a/packages/playwright-core/src/server/chromium/chromium.ts
+++ b/packages/playwright-core/src/server/chromium/chromium.ts
@@ -64,7 +64,6 @@ export class Chromium extends BrowserType {
override async connectOverCDP(metadata: CallMetadata, endpointURL: string, options: { slowMo?: number, headers?: types.HeadersArray, timeout: number }) {
const controller = new ProgressController(metadata, this);
- controller.setLogName('browser');
return controller.run(async progress => {
return await this._connectOverCDPInternal(progress, endpointURL, options);
}, options.timeout);
diff --git a/packages/playwright-core/src/server/chromium/crBrowser.ts b/packages/playwright-core/src/server/chromium/crBrowser.ts
index 0557ea11cf..005c422812 100644
--- a/packages/playwright-core/src/server/chromium/crBrowser.ts
+++ b/packages/playwright-core/src/server/chromium/crBrowser.ts
@@ -58,7 +58,7 @@ export class CRBrowser extends Browser {
static async connect(parent: SdkObject, transport: ConnectionTransport, options: BrowserOptions, devtools?: CRDevTools): Promise<CRBrowser> {
// Make a copy in case we need to update `headful` property below.
options = { ...options };
- const connection = new CRConnection(transport, options.protocolLogger, options.browserLogsCollector);
+ const connection = new CRConnection(parent, transport, options.protocolLogger, options.browserLogsCollector);
const browser = new CRBrowser(parent, connection, options);
browser._devtools = devtools;
if (browser.isClank())
diff --git a/packages/playwright-core/src/server/chromium/crConnection.ts b/packages/playwright-core/src/server/chromium/crConnection.ts
index 98c566c82a..0a8d3427fc 100644
--- a/packages/playwright-core/src/server/chromium/crConnection.ts
+++ b/packages/playwright-core/src/server/chromium/crConnection.ts
@@ -15,12 +15,11 @@
* limitations under the License.
*/
-import { EventEmitter } from 'events';
-
import { assert, eventsHelper } from '../../utils';
import { debugLogger } from '../utils/debugLogger';
import { helper } from '../helper';
import { ProtocolError } from '../protocolError';
+import { SdkObject } from '../instrumentation';
import type { RegisteredListener } from '../../utils';
import type { ConnectionTransport, ProtocolRequest, ProtocolResponse } from '../transport';
@@ -37,7 +36,7 @@ export const ConnectionEvents = {
// should ignore.
export const kBrowserCloseMessageId = -9999;
-export class CRConnection extends EventEmitter {
+export class CRConnection extends SdkObject {
private _lastId = 0;
private readonly _transport: ConnectionTransport;
readonly _sessions = new Map<string, CRSession>();
@@ -47,8 +46,8 @@ export class CRConnection extends EventEmitter {
readonly rootSession: CRSession;
_closed = false;
- constructor(transport: ConnectionTransport, protocolLogger: ProtocolLogger, browserLogsCollector: RecentLogsCollector) {
- super();
+ constructor(parent: SdkObject, transport: ConnectionTransport, protocolLogger: ProtocolLogger, browserLogsCollector: RecentLogsCollector) {
+ super(parent, 'cr-connection');
this.setMaxListeners(0);
this._transport = transport;
this._protocolLogger = protocolLogger;
@@ -101,7 +100,7 @@ export class CRConnection extends EventEmitter {
type SessionEventListener = (method: string, params?: Object) => void;
-export class CRSession extends EventEmitter {
+export class CRSession extends SdkObject {
private readonly _connection: CRConnection;
private _eventListener?: SessionEventListener;
private readonly _callbacks = new Map<number, { resolve: (o: any) => void, reject: (e: ProtocolError) => void, error: ProtocolError }>();
@@ -116,7 +115,7 @@ export class CRSession extends EventEmitter {
override once: <T extends keyof Protocol.Events | symbol>(event: T, listener: (payload: T extends symbol ? any : Protocol.Events[T extends keyof Protocol.Events ? T : never]) => void) => this;
constructor(connection: CRConnection, parentSession: CRSession | null, sessionId: string, eventListener?: SessionEventListener) {
- super();
+ super(connection, 'cr-session');
this.setMaxListeners(0);
this._connection = connection;
this._parentSession = parentSession;
@@ -203,19 +202,17 @@ export class CRSession extends EventEmitter {
}
}
-export class CDPSession extends EventEmitter {
+export class CDPSession extends SdkObject {
static Events = {
Event: 'event',
Closed: 'close',
};
- readonly guid: string;
private _session: CRSession;
private _listeners: RegisteredListener[] = [];
constructor(parentSession: CRSession, sessionId: string) {
- super();
- this.guid = `cdp-session@${sessionId}`;
+ super(parentSession, 'cdp-session');
this._session = parentSession.createChildSession(sessionId, (method, params) => this.emit(CDPSession.Events.Event, { method, params }));
this._listeners = [eventsHelper.addEventListener(parentSession, 'Target.detachedFromTarget', (event: Protocol.Target.detachedFromTargetPayload) => {
if (event.sessionId === sessionId)
diff --git a/packages/playwright-core/src/server/dispatchers/androidDispatcher.ts b/packages/playwright-core/src/server/dispatchers/androidDispatcher.ts
index 25398ce05f..fb552b9809 100644
--- a/packages/playwright-core/src/server/dispatchers/androidDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/androidDispatcher.ts
@@ -17,6 +17,8 @@
import { BrowserContextDispatcher } from './browserContextDispatcher';
import { Dispatcher } from './dispatcher';
import { AndroidDevice } from '../android/android';
+import { eventsHelper } from '../utils/eventsHelper';
+import { SdkObject } from '../instrumentation';
import type { RootDispatcher } from './dispatcher';
import type { Android, SocketBackend } from '../android/android';
@@ -145,7 +147,7 @@ export class AndroidDeviceDispatcher extends Dispatcher<AndroidDevice, channels.
async open(params: channels.AndroidDeviceOpenParams, metadata: CallMetadata): Promise<channels.AndroidDeviceOpenResult> {
const socket = await this._object.open(params.command);
- return { socket: new AndroidSocketDispatcher(this, socket) };
+ return { socket: new AndroidSocketDispatcher(this, new SocketSdkObject(this._object, socket)) };
}
async installApk(params: channels.AndroidDeviceInstallApkParams) {
@@ -170,10 +172,33 @@ export class AndroidDeviceDispatcher extends Dispatcher<AndroidDevice, channels.
}
}
-export class AndroidSocketDispatcher extends Dispatcher<SocketBackend, channels.AndroidSocketChannel, AndroidDeviceDispatcher> implements channels.AndroidSocketChannel {
+class SocketSdkObject extends SdkObject implements SocketBackend {
+ private _socket: SocketBackend;
+ private _eventListeners;
+
+ constructor(parent: SdkObject, socket: SocketBackend) {
+ super(parent, 'socket');
+ this._socket = socket;
+ this._eventListeners = [
+ eventsHelper.addEventListener(socket, 'data', data => this.emit('data', data)),
+ eventsHelper.addEventListener(socket, 'close', () => this.emit('close')),
+ ];
+ }
+
+ async write(data: Buffer) {
+ await this._socket.write(data);
+ }
+
+ close() {
+ this._socket.close();
+ eventsHelper.removeEventListeners(this._eventListeners);
+ }
+}
+
+export class AndroidSocketDispatcher extends Dispatcher<SocketSdkObject, channels.AndroidSocketChannel, AndroidDeviceDispatcher> implements channels.AndroidSocketChannel {
_type_AndroidSocket = true;
- constructor(scope: AndroidDeviceDispatcher, socket: SocketBackend) {
+ constructor(scope: AndroidDeviceDispatcher, socket: SocketSdkObject) {
super(scope, socket, 'AndroidSocket', {});
this.addObjectListener('data', (data: Buffer) => this._dispatchEvent('data', { data }));
this.addObjectListener('close', () => {
diff --git a/packages/playwright-core/src/server/dispatchers/dispatcher.ts b/packages/playwright-core/src/server/dispatchers/dispatcher.ts
index ca1db256e9..cc38a398df 100644
--- a/packages/playwright-core/src/server/dispatchers/dispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/dispatcher.ts
@@ -21,7 +21,7 @@ import { ValidationError, createMetadataValidator, findValidator } from '../../
import { LongStandingScope, assert, monotonicTime, rewriteErrorMessage } from '../../utils';
import { isUnderTest } from '../utils/debug';
import { TargetClosedError, isTargetClosedError, serializeError } from '../errors';
-import { SdkObject } from '../instrumentation';
+import { createRootSdkObject, SdkObject } from '../instrumentation';
import { isProtocolError } from '../protocolError';
import { compressCallLog } from '../callLog';
import { methodMetainfo } from '../../utils/isomorphic/protocolMetainfo';
@@ -45,7 +45,7 @@ function maxDispatchersForBucket(gcBucket: string) {
}[gcBucket] ?? 10000;
}
-export class Dispatcher<Type extends { guid: string }, ChannelType, ParentScopeType extends DispatcherScope> extends EventEmitter implements channels.Channel {
+export class Dispatcher<Type extends SdkObject, ChannelType, ParentScopeType extends DispatcherScope> extends EventEmitter implements channels.Channel {
readonly connection: DispatcherConnection;
// Parent is always "isScope".
private _parent: ParentScopeType | undefined;
@@ -162,13 +162,13 @@ export class Dispatcher<Type extends { guid: string }, ChannelType, ParentScopeT
}
}
-export type DispatcherScope = Dispatcher<any, any, any>;
+export type DispatcherScope = Dispatcher<SdkObject, any, any>;
-export class RootDispatcher extends Dispatcher<{ guid: '' }, any, any> {
+export class RootDispatcher extends Dispatcher<SdkObject, any, any> {
private _initialized = false;
constructor(connection: DispatcherConnection, private readonly createPlaywright?: (scope: RootDispatcher, options: channels.RootInitializeParams) => Promise<PlaywrightDispatcher>) {
- super(connection, { guid: '' }, 'Root', {});
+ super(connection, createRootSdkObject(), 'Root', {});
}
async initialize(params: channels.RootInitializeParams): Promise<channels.RootInitializeResult> {
@@ -311,16 +311,16 @@ export class DispatcherConnection {
validMetadata.internal = true;
}
- const sdkObject = dispatcher._object instanceof SdkObject ? dispatcher._object : undefined;
+ const sdkObject = dispatcher._object;
const callMetadata: CallMetadata = {
id: `call@${id}`,
location: validMetadata.location,
title: validMetadata.title,
internal: validMetadata.internal,
stepId: validMetadata.stepId,
- objectId: sdkObject?.guid,
- pageId: sdkObject?.attribution?.page?.guid,
- frameId: sdkObject?.attribution?.frame?.guid,
+ objectId: sdkObject.guid,
+ pageId: sdkObject.attribution?.page?.guid,
+ frameId: sdkObject.attribution?.frame?.guid,
startTime: monotonicTime(),
endTime: 0,
type: dispatcher._type,
@@ -329,7 +329,7 @@ export class DispatcherConnection {
log: [],
};
- if (sdkObject && params?.info?.waitId) {
+ if (params?.info?.waitId) {
// Process logs for waitForNavigation/waitForLoadState/etc.
const info = params.info;
switch (info.phase) {
@@ -356,7 +356,7 @@ export class DispatcherConnection {
}
}
- await sdkObject?.instrumentation.onBeforeCall(sdkObject, callMetadata);
+ await sdkObject.instrumentation.onBeforeCall(sdkObject, callMetadata);
const response: any = { id };
try {
const result = await dispatcher._handleCommand(callMetadata, method, validParams);
@@ -364,24 +364,22 @@ export class DispatcherConnection {
response.result = validator(result, '', this._validatorToWireContext());
callMetadata.result = result;
} catch (e) {
- if (isTargetClosedError(e) && sdkObject) {
+ if (isTargetClosedError(e)) {
const reason = closeReason(sdkObject);
if (reason)
rewriteErrorMessage(e, reason);
} else if (isProtocolError(e)) {
- if (e.type === 'closed') {
- const reason = sdkObject ? closeReason(sdkObject) : undefined;
- e = new TargetClosedError(reason, e.browserLogMessage());
- } else if (e.type === 'crashed') {
+ if (e.type === 'closed')
+ e = new TargetClosedError(closeReason(sdkObject), e.browserLogMessage());
+ else if (e.type === 'crashed')
rewriteErrorMessage(e, 'Target crashed ' + e.browserLogMessage());
- }
}
response.error = serializeError(e);
// The command handler could have set error in the metadata, do not reset it if there was no exception.
callMetadata.error = response.error;
} finally {
callMetadata.endTime = monotonicTime();
- await sdkObject?.instrumentation.onAfterCall(sdkObject, callMetadata);
+ await sdkObject.instrumentation.onAfterCall(sdkObject, callMetadata);
}
if (response.error)
diff --git a/packages/playwright-core/src/server/dispatchers/jsonPipeDispatcher.ts b/packages/playwright-core/src/server/dispatchers/jsonPipeDispatcher.ts
index 75c1c89fad..522df815be 100644
--- a/packages/playwright-core/src/server/dispatchers/jsonPipeDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/jsonPipeDispatcher.ts
@@ -15,15 +15,15 @@
*/
import { Dispatcher } from './dispatcher';
-import { createGuid } from '../utils/crypto';
+import { SdkObject } from '../instrumentation';
import type { LocalUtilsDispatcher } from './localUtilsDispatcher';
import type * as channels from '@protocol/channels';
-export class JsonPipeDispatcher extends Dispatcher<{ guid: string }, channels.JsonPipeChannel, LocalUtilsDispatcher> implements channels.JsonPipeChannel {
+export class JsonPipeDispatcher extends Dispatcher<SdkObject, channels.JsonPipeChannel, LocalUtilsDispatcher> implements channels.JsonPipeChannel {
_type_JsonPipe = true;
constructor(scope: LocalUtilsDispatcher) {
- super(scope, { guid: 'jsonPipe@' + createGuid() }, 'JsonPipe', {});
+ super(scope, new SdkObject(scope._object, 'jsonPipe'), 'JsonPipe', {});
}
async send(params: channels.JsonPipeSendParams): Promise<channels.JsonPipeSendResult> {
diff --git a/packages/playwright-core/src/server/dispatchers/localUtilsDispatcher.ts b/packages/playwright-core/src/server/dispatchers/localUtilsDispatcher.ts
index 5a3dc562df..1a00d8c7f1 100644
--- a/packages/playwright-core/src/server/dispatchers/localUtilsDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/localUtilsDispatcher.ts
@@ -34,13 +34,14 @@ import type * as channels from '@protocol/channels';
import type * as http from 'http';
import type { HTTPRequestParams } from '../utils/network';
-export class LocalUtilsDispatcher extends Dispatcher<{ guid: string }, channels.LocalUtilsChannel, RootDispatcher> implements channels.LocalUtilsChannel {
+export class LocalUtilsDispatcher extends Dispatcher<SdkObject, channels.LocalUtilsChannel, RootDispatcher> implements channels.LocalUtilsChannel {
_type_LocalUtils: boolean;
private _harBackends = new Map<string, HarBackend>();
private _stackSessions = new Map<string, localUtils.StackSession>();
constructor(scope: RootDispatcher, playwright: Playwright) {
const localUtils = new SdkObject(playwright, 'localUtils', 'localUtils');
+ localUtils.logName = 'browser';
const deviceDescriptors = Object.entries(descriptors)
.map(([name, descriptor]) => ({ name, descriptor }));
super(scope, localUtils, 'LocalUtils', {
@@ -82,8 +83,7 @@ export class LocalUtilsDispatcher extends Dispatcher<{ guid: string }, channels.
}
async connect(params: channels.LocalUtilsConnectParams, metadata: CallMetadata): Promise<channels.LocalUtilsConnectResult> {
- const controller = new ProgressController(metadata, this._object as SdkObject);
- controller.setLogName('browser');
+ const controller = new ProgressController(metadata, this._object);
return await controller.run(async progress => {
const wsHeaders = {
'User-Agent': getUserAgent(),
diff --git a/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts b/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts
index 365a323997..b824297c88 100644
--- a/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts
@@ -25,7 +25,7 @@ import { RequestDispatcher } from './networkDispatchers';
import { ResponseDispatcher } from './networkDispatchers';
import { RouteDispatcher, WebSocketDispatcher } from './networkDispatchers';
import { WebSocketRouteDispatcher } from './webSocketRouteDispatcher';
-import { createGuid } from '../utils/crypto';
+import { SdkObject } from '../instrumentation';
import { urlMatches } from '../../utils/isomorphic/urlMatch';
import type { Artifact } from '../artifact';
@@ -403,7 +403,7 @@ export class WorkerDispatcher extends Dispatcher<Worker, channels.WorkerChannel,
}
}
-export class BindingCallDispatcher extends Dispatcher<{ guid: string }, channels.BindingCallChannel, PageDispatcher | BrowserContextDispatcher> implements channels.BindingCallChannel {
+export class BindingCallDispatcher extends Dispatcher<SdkObject, channels.BindingCallChannel, PageDispatcher | BrowserContextDispatcher> implements channels.BindingCallChannel {
_type_BindingCall = true;
private _resolve: ((arg: any) => void) | undefined;
private _reject: ((error: any) => void) | undefined;
@@ -411,7 +411,7 @@ export class BindingCallDispatcher extends Dispatcher<{ guid: string }, channels
constructor(scope: PageDispatcher, name: string, needsHandle: boolean, source: { context: BrowserContext, page: Page, frame: Frame }, args: any[]) {
const frameDispatcher = FrameDispatcher.from(scope.parentScope(), source.frame);
- super(scope, { guid: 'bindingCall@' + createGuid() }, 'BindingCall', {
+ super(scope, new SdkObject(scope._object, 'bindingCall'), 'BindingCall', {
frame: frameDispatcher,
name,
args: needsHandle ? undefined : args.map(serializeResult),
diff --git a/packages/playwright-core/src/server/dispatchers/playwrightDispatcher.ts b/packages/playwright-core/src/server/dispatchers/playwrightDispatcher.ts
index f87f1ca85b..63e2ba997f 100644
--- a/packages/playwright-core/src/server/dispatchers/playwrightDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/playwrightDispatcher.ts
@@ -24,7 +24,7 @@ import { Dispatcher } from './dispatcher';
import { ElectronDispatcher } from './electronDispatcher';
import { LocalUtilsDispatcher } from './localUtilsDispatcher';
import { APIRequestContextDispatcher } from './networkDispatchers';
-import { createGuid } from '../utils/crypto';
+import { SdkObject } from '../instrumentation';
import { eventsHelper } from '../utils/eventsHelper';
import type { RootDispatcher } from './dispatcher';
@@ -62,7 +62,7 @@ export class PlaywrightDispatcher extends Dispatcher<Playwright, channels.Playwr
android,
electron: new ElectronDispatcher(scope, playwright.electron),
utils: playwright.options.isServer ? undefined : new LocalUtilsDispatcher(scope, playwright),
- socksSupport: options.socksProxy ? new SocksSupportDispatcher(scope, options.socksProxy) : undefined,
+ socksSupport: options.socksProxy ? new SocksSupportDispatcher(scope, playwright, options.socksProxy) : undefined,
};
let browserDispatcher: BrowserDispatcher | undefined;
@@ -101,13 +101,13 @@ export class PlaywrightDispatcher extends Dispatcher<Playwright, channels.Playwr
}
}
-class SocksSupportDispatcher extends Dispatcher<{ guid: string }, channels.SocksSupportChannel, RootDispatcher> implements channels.SocksSupportChannel {
+class SocksSupportDispatcher extends Dispatcher<SdkObject, channels.SocksSupportChannel, RootDispatcher> implements channels.SocksSupportChannel {
_type_SocksSupport: boolean;
private _socksProxy: SocksProxy;
private _socksListeners: RegisteredListener[];
- constructor(scope: RootDispatcher, socksProxy: SocksProxy) {
- super(scope, { guid: 'socksSupport@' + createGuid() }, 'SocksSupport', {});
+ constructor(scope: RootDispatcher, parent: SdkObject, socksProxy: SocksProxy) {
+ super(scope, new SdkObject(parent, 'socksSupport'), 'SocksSupport', {});
this._type_SocksSupport = true;
this._socksProxy = socksProxy;
this._socksListeners = [
diff --git a/packages/playwright-core/src/server/dispatchers/streamDispatcher.ts b/packages/playwright-core/src/server/dispatchers/streamDispatcher.ts
index f3a0a413b7..82b5319c59 100644
--- a/packages/playwright-core/src/server/dispatchers/streamDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/streamDispatcher.ts
@@ -16,18 +16,27 @@
import { Dispatcher } from './dispatcher';
import { ManualPromise } from '../../utils/isomorphic/manualPromise';
-import { createGuid } from '../utils/crypto';
+import { SdkObject } from '../instrumentation';
import type { ArtifactDispatcher } from './artifactDispatcher';
import type * as channels from '@protocol/channels';
import type * as stream from 'stream';
-export class StreamDispatcher extends Dispatcher<{ guid: string, stream: stream.Readable }, channels.StreamChannel, ArtifactDispatcher> implements channels.StreamChannel {
+class StreamSdkObject extends SdkObject {
+ readonly stream: stream.Readable;
+
+ constructor(parent: SdkObject, stream: stream.Readable) {
+ super(parent, 'stream');
+ this.stream = stream;
+ }
+}
+
+export class StreamDispatcher extends Dispatcher<StreamSdkObject, channels.StreamChannel, ArtifactDispatcher> implements channels.StreamChannel {
_type_Stream = true;
private _ended: boolean = false;
constructor(scope: ArtifactDispatcher, stream: stream.Readable) {
- super(scope, { guid: 'stream@' + createGuid(), stream }, 'Stream', {});
+ super(scope, new StreamSdkObject(scope._object, stream), 'Stream', {});
// In Node v12.9.0+ we can use readableEnded.
stream.once('end', () => this._ended = true);
stream.once('error', () => this._ended = true);
diff --git a/packages/playwright-core/src/server/dispatchers/webSocketRouteDispatcher.ts b/packages/playwright-core/src/server/dispatchers/webSocketRouteDispatcher.ts
index 9bb05849ae..975f2d2082 100644
--- a/packages/playwright-core/src/server/dispatchers/webSocketRouteDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/webSocketRouteDispatcher.ts
@@ -18,7 +18,7 @@ import { Page } from '../page';
import { Dispatcher } from './dispatcher';
import { PageDispatcher } from './pageDispatcher';
import * as rawWebSocketMockSource from '../../generated/webSocketMockSource';
-import { createGuid } from '../utils/crypto';
+import { SdkObject } from '../instrumentation';
import { urlMatches } from '../../utils/isomorphic/urlMatch';
import { eventsHelper } from '../utils/eventsHelper';
@@ -29,14 +29,14 @@ import type { Frame } from '../frames';
import type * as ws from '@injected/webSocketMock';
import type * as channels from '@protocol/channels';
-export class WebSocketRouteDispatcher extends Dispatcher<{ guid: string }, channels.WebSocketRouteChannel, PageDispatcher | BrowserContextDispatcher> implements channels.WebSocketRouteChannel {
+export class WebSocketRouteDispatcher extends Dispatcher<SdkObject, channels.WebSocketRouteChannel, PageDispatcher | BrowserContextDispatcher> implements channels.WebSocketRouteChannel {
_type_WebSocketRoute = true;
private _id: string;
private _frame: Frame;
private static _idToDispatcher = new Map<string, WebSocketRouteDispatcher>();
constructor(scope: PageDispatcher | BrowserContextDispatcher, id: string, url: string, frame: Frame) {
- super(scope, { guid: 'webSocketRoute@' + createGuid() }, 'WebSocketRoute', { url });
+ super(scope, new SdkObject(scope._object, 'webSocketRoute'), 'WebSocketRoute', { url });
this._id = id;
this._frame = frame;
this._eventListeners.push(
diff --git a/packages/playwright-core/src/server/dispatchers/writableStreamDispatcher.ts b/packages/playwright-core/src/server/dispatchers/writableStreamDispatcher.ts
index 7bd6f1fd74..1595cae757 100644
--- a/packages/playwright-core/src/server/dispatchers/writableStreamDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/writableStreamDispatcher.ts
@@ -17,18 +17,27 @@
import fs from 'fs';
import { Dispatcher } from './dispatcher';
-import { createGuid } from '../utils/crypto';
+import { SdkObject } from '../instrumentation';
import type { BrowserContextDispatcher } from './browserContextDispatcher';
import type * as channels from '@protocol/channels';
-export class WritableStreamDispatcher extends Dispatcher<{ guid: string, streamOrDirectory: fs.WriteStream | string }, channels.WritableStreamChannel, BrowserContextDispatcher> implements channels.WritableStreamChannel {
+class WritableStreamSdkObject extends SdkObject {
+ readonly streamOrDirectory: fs.WriteStream | string;
+ readonly lastModifiedMs: number | undefined;
+
+ constructor(parent: SdkObject, streamOrDirectory: fs.WriteStream | string, lastModifiedMs: number | undefined) {
+ super(parent, 'stream');
+ this.streamOrDirectory = streamOrDirectory;
+ this.lastModifiedMs = lastModifiedMs;
+ }
+}
+
+export class WritableStreamDispatcher extends Dispatcher<WritableStreamSdkObject, channels.WritableStreamChannel, BrowserContextDispatcher> implements channels.WritableStreamChannel {
_type_WritableStream = true;
- private _lastModifiedMs: number | undefined;
constructor(scope: BrowserContextDispatcher, streamOrDirectory: fs.WriteStream | string, lastModifiedMs?: number) {
- super(scope, { guid: 'writableStream@' + createGuid(), streamOrDirectory }, 'WritableStream', {});
- this._lastModifiedMs = lastModifiedMs;
+ super(scope, new WritableStreamSdkObject(scope._object, streamOrDirectory, lastModifiedMs), 'WritableStream', {});
}
async write(params: channels.WritableStreamWriteParams): Promise<channels.WritableStreamWriteResult> {
@@ -50,8 +59,8 @@ export class WritableStreamDispatcher extends Dispatcher<{ guid: string, streamO
throw new Error('Cannot close a directory');
const stream = this._object.streamOrDirectory;
await new Promise<void>(fulfill => stream.end(fulfill));
- if (this._lastModifiedMs)
- await fs.promises.utimes(this.path(), new Date(this._lastModifiedMs), new Date(this._lastModifiedMs));
+ if (this._object.lastModifiedMs)
+ await fs.promises.utimes(this.path(), new Date(this._object.lastModifiedMs), new Date(this._object.lastModifiedMs));
}
path(): string {
diff --git a/packages/playwright-core/src/server/electron/electron.ts b/packages/playwright-core/src/server/electron/electron.ts
index 1602ca8c79..b0c154effa 100644
--- a/packages/playwright-core/src/server/electron/electron.ts
+++ b/packages/playwright-core/src/server/electron/electron.ts
@@ -250,7 +250,7 @@ export class Electron extends SdkObject {
const nodeMatch = await nodeMatchPromise;
const nodeTransport = await WebSocketTransport.connect(progress, nodeMatch[1]);
- const nodeConnection = new CRConnection(nodeTransport, helper.debugProtocolLogger(), browserLogsCollector);
+ const nodeConnection = new CRConnection(this, nodeTransport, helper.debugProtocolLogger(), browserLogsCollector);
// Immediately release exiting process under debug.
debuggerDisconnectPromise.then(() => {
diff --git a/packages/playwright-core/src/server/instrumentation.ts b/packages/playwright-core/src/server/instrumentation.ts
index 076008a31e..9dc29950c8 100644
--- a/packages/playwright-core/src/server/instrumentation.ts
+++ b/packages/playwright-core/src/server/instrumentation.ts
@@ -29,6 +29,7 @@ import type { Page } from './page';
import type { Playwright } from './playwright';
import type { CallMetadata } from '@protocol/callMetadata';
export type { CallMetadata } from '@protocol/callMetadata';
+import type { LogName } from './utils/debugLogger';
export type Attribution = {
playwright: Playwright;
@@ -43,6 +44,7 @@ export class SdkObject extends EventEmitter {
guid: string;
attribution: Attribution;
instrumentation: Instrumentation;
+ logName?: LogName;
constructor(parent: SdkObject, guidPrefix?: string, guid?: string) {
super();
@@ -53,6 +55,13 @@ export class SdkObject extends EventEmitter {
}
}
+export function createRootSdkObject() {
+ const fakeParent = { attribution: {}, instrumentation: createInstrumentation() };
+ const root = new SdkObject(fakeParent as any);
+ root.guid = '';
+ return root;
+}
+
export interface Instrumentation {
addListener(listener: InstrumentationListener, context: BrowserContext | APIRequestContext | null): void;
removeListener(listener: InstrumentationListener): void;
diff --git a/packages/playwright-core/src/server/playwright.ts b/packages/playwright-core/src/server/playwright.ts
index 28fe83d248..26273a258d 100644
--- a/packages/playwright-core/src/server/playwright.ts
+++ b/packages/playwright-core/src/server/playwright.ts
@@ -23,7 +23,7 @@ import { Chromium } from './chromium/chromium';
import { DebugController } from './debugController';
import { Electron } from './electron/electron';
import { Firefox } from './firefox/firefox';
-import { SdkObject, createInstrumentation } from './instrumentation';
+import { SdkObject, createRootSdkObject } from './instrumentation';
import { WebKit } from './webkit/webkit';
import type { BrowserType } from './browserType';
@@ -53,7 +53,7 @@ export class Playwright extends SdkObject {
private _allBrowsers = new Set<Browser>();
constructor(options: PlaywrightOptions) {
- super({ attribution: {}, instrumentation: createInstrumentation() } as any, undefined, 'Playwright');
+ super(createRootSdkObject(), undefined, 'Playwright');
this.options = options;
this.attribution.playwright = this;
this.instrumentation.addListener({
diff --git a/packages/playwright-core/src/server/progress.ts b/packages/playwright-core/src/server/progress.ts
index 16dcc6fb1f..68476ca21d 100644
--- a/packages/playwright-core/src/server/progress.ts
+++ b/packages/playwright-core/src/server/progress.ts
@@ -36,7 +36,7 @@ export class ProgressController {
// Cleanups to be run only in the case of abort.
private _cleanups: (() => any)[] = [];
- private _logName = 'api';
+ private _logName: LogName;
private _state: 'before' | 'running' | 'aborted' | 'finished' = 'before';
private _deadline: number = 0;
private _timeout: number = 0;
@@ -48,6 +48,7 @@ export class ProgressController {
this.metadata = metadata;
this.sdkObject = sdkObject;
this.instrumentation = sdkObject.instrumentation;
+ this._logName = sdkObject.logName || 'api';
this._forceAbortPromise.catch(e => null); // Prevent unhandled promise rejection.
}