Skip to content

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

feat(trace): add action screenshot and aria snapshot events (#42167)

Pavel Feldmanb4e7c87ce4c7
diff --git a/docs/src/api/class-tracing.md b/docs/src/api/class-tracing.md
index 256ae513a5..d28ce386ae 100644
--- a/docs/src/api/class-tracing.md
+++ b/docs/src/api/class-tracing.md
@@ -148,6 +148,17 @@ a timeline preview.
### option: Tracing.start.snapshots
* since: v1.12
+* langs: js
+- `snapshots` <[boolean]|[Object]>
+ - `dom` ?<[boolean]> Capture DOM snapshot on every action and record network activity. Optional.
+ - `aria` ?<[boolean]> Capture aria snapshot of the page on every action. Optional.
+ - `screen` ?<[boolean]> Capture a screenshot of the page on every action. Optional.
+
+Which snapshots to capture on every action. Passing `true` is a shortcut for `{ dom: true }`.
+
+### option: Tracing.start.snapshots
+* since: v1.12
+* langs: java, python, csharp
- `snapshots` <[boolean]>
If this option is true tracing will
diff --git a/packages/playwright-client/types/types.d.ts b/packages/playwright-client/types/types.d.ts
index 0bc3533eec..ac62bab28e 100644
--- a/packages/playwright-client/types/types.d.ts
+++ b/packages/playwright-client/types/types.d.ts
@@ -23692,11 +23692,24 @@ export interface Tracing {
screenshots?: boolean;
/**
- * If this option is true tracing will
- * - capture DOM snapshot on every action
- * - record network activity
+ * Which snapshots to capture on every action. Passing `true` is a shortcut for `{ dom: true }`.
*/
- snapshots?: boolean;
+ snapshots?: boolean|{
+ /**
+ * Capture DOM snapshot on every action and record network activity. Optional.
+ */
+ dom?: boolean;
+
+ /**
+ * Capture aria snapshot of the page on every action. Optional.
+ */
+ aria?: boolean;
+
+ /**
+ * Capture a screenshot of the page on every action. Optional.
+ */
+ screen?: boolean;
+ };
/**
* Whether to include source files for trace actions.
diff --git a/packages/playwright-core/src/client/channels.d.ts b/packages/playwright-core/src/client/channels.d.ts
index b6bb08cd17..52b5210534 100644
--- a/packages/playwright-core/src/client/channels.d.ts
+++ b/packages/playwright-core/src/client/channels.d.ts
@@ -5047,14 +5047,18 @@ export interface TracingChannel extends TracingEventTarget, Channel {
}
export type TracingTracingStartParams = {
name?: string,
- snapshots?: boolean,
- screenshots?: boolean,
+ snapshotDom?: boolean,
+ snapshotAria?: boolean,
+ snapshotScreen?: boolean,
+ screencast?: boolean,
live?: boolean,
};
export type TracingTracingStartOptions = {
name?: string,
- snapshots?: boolean,
- screenshots?: boolean,
+ snapshotDom?: boolean,
+ snapshotAria?: boolean,
+ snapshotScreen?: boolean,
+ screencast?: boolean,
live?: boolean,
};
export type TracingTracingStartResult = void;
diff --git a/packages/playwright-core/src/client/tracing.ts b/packages/playwright-core/src/client/tracing.ts
index e093c926d0..b0257c5258 100644
--- a/packages/playwright-core/src/client/tracing.ts
+++ b/packages/playwright-core/src/client/tracing.ts
@@ -42,14 +42,17 @@ export class Tracing extends ChannelOwner<channels.TracingChannel> implements ap
super(parent, type, guid, initializer);
}
- async start(options: { name?: string, title?: string, snapshots?: boolean, screenshots?: boolean, sources?: boolean, live?: boolean } = {}) {
+ async start(options: { name?: string, title?: string, snapshots?: boolean | { dom?: boolean, aria?: boolean, screen?: boolean }, screenshots?: boolean, sources?: boolean, live?: boolean } = {}) {
await this._wrapApiCall(async () => {
this._includeSources = !!options.sources;
this._isLive = !!options.live;
+ const snapshots = typeof options.snapshots === 'object' ? options.snapshots : { dom: options.snapshots };
await this._channel.tracingStart({
name: options.name,
- snapshots: options.snapshots,
- screenshots: options.screenshots,
+ snapshotDom: snapshots.dom,
+ snapshotAria: snapshots.aria,
+ snapshotScreen: snapshots.screen,
+ screencast: options.screenshots,
live: options.live,
}, kNoTimeout);
const { traceName } = await this._channel.tracingStartChunk({ name: options.name, title: options.title }, kNoTimeout);
diff --git a/packages/playwright-core/src/server/bidi/bidiInput.ts b/packages/playwright-core/src/server/bidi/bidiInput.ts
index 0dbfc917c7..f9d99f8510 100644
--- a/packages/playwright-core/src/server/bidi/bidiInput.ts
+++ b/packages/playwright-core/src/server/bidi/bidiInput.ts
@@ -60,7 +60,7 @@ export class RawKeyboardImpl implements input.RawKeyboard {
return;
}
try {
- frame = await progress.race(element.contentFrame(progress));
+ frame = await element.contentFrame(progress);
} finally {
element.dispose();
}
diff --git a/packages/playwright-core/src/server/channels.d.ts b/packages/playwright-core/src/server/channels.d.ts
index 48da3163a0..87fec7205b 100644
--- a/packages/playwright-core/src/server/channels.d.ts
+++ b/packages/playwright-core/src/server/channels.d.ts
@@ -5048,14 +5048,18 @@ export interface TracingChannel extends TracingEventTarget, Channel {
}
export type TracingTracingStartParams = {
name?: string,
- snapshots?: boolean,
- screenshots?: boolean,
+ snapshotDom?: boolean,
+ snapshotAria?: boolean,
+ snapshotScreen?: boolean,
+ screencast?: boolean,
live?: boolean,
};
export type TracingTracingStartOptions = {
name?: string,
- snapshots?: boolean,
- screenshots?: boolean,
+ snapshotDom?: boolean,
+ snapshotAria?: boolean,
+ snapshotScreen?: boolean,
+ screencast?: boolean,
live?: boolean,
};
export type TracingTracingStartResult = void;
diff --git a/packages/playwright-core/src/server/debugger.ts b/packages/playwright-core/src/server/debugger.ts
index 32ce4fa5cc..d02555df4f 100644
--- a/packages/playwright-core/src/server/debugger.ts
+++ b/packages/playwright-core/src/server/debugger.ts
@@ -117,7 +117,8 @@ export class Debugger extends SdkObject<DebuggerEventMap> implements Instrumenta
this._muted = muted;
}
- async onBeforeCall(sdkObject: SdkObject, metadata: CallMetadata): Promise<void> {
+ async onBeforeCall(progress: Progress, sdkObject: SdkObject): Promise<void> {
+ const { metadata } = progress;
if (!metadata.internal && metadata.method)
this._ongoingCalls.set(metadata.id, { metadata, sentLogCount: 0, status: 'running' });
if (this._apiCallsEnabled) {
@@ -131,10 +132,11 @@ export class Debugger extends SdkObject<DebuggerEventMap> implements Instrumenta
const pauseBeforeAction = !!this._pauseAt.next && !!metainfo?.pause && (this._pauseBeforeWaitingActions || !metainfo?.isAutoWaiting);
const pauseOnLocation = !!this._pauseAt.location && matchesLocation(metadata, this._pauseAt.location);
if (pauseOnPauseCall || pauseBeforeAction || pauseOnLocation)
- await this._pause(sdkObject, metadata);
+ await this._pause(progress, sdkObject);
}
- async onBeforeInputAction(sdkObject: SdkObject, metadata: CallMetadata, point?: Point): Promise<void> {
+ async onBeforeInputAction(progress: Progress, sdkObject: SdkObject, point?: Point): Promise<void> {
+ const { metadata } = progress;
const call = this._ongoingCalls.get(metadata.id);
if (call) {
call.actionPoint = point;
@@ -148,10 +150,11 @@ export class Debugger extends SdkObject<DebuggerEventMap> implements Instrumenta
const metainfo = getMetainfo(metadata);
const pauseBeforeInput = !!this._pauseAt.next && !!metainfo?.pause && !!metainfo?.isAutoWaiting && !this._pauseBeforeWaitingActions;
if (pauseBeforeInput)
- await this._pause(sdkObject, metadata);
+ await this._pause(progress, sdkObject);
}
- async onAfterCall(sdkObject: SdkObject, metadata: CallMetadata): Promise<void> {
+ async onAfterCall(progress: Progress, sdkObject: SdkObject): Promise<void> {
+ const { metadata } = progress;
const call = this._ongoingCalls.get(metadata.id);
if (!call)
return;
@@ -212,7 +215,8 @@ export class Debugger extends SdkObject<DebuggerEventMap> implements Instrumenta
this.emit(Debugger.Events.ApiCallsUpdated, updates);
}
- private async _pause(sdkObject: SdkObject, metadata: CallMetadata) {
+ private async _pause(progress: Progress, sdkObject: SdkObject) {
+ const { metadata } = progress;
if (this._muted || metadata.internal)
return;
if (this._pausedCall)
diff --git a/packages/playwright-core/src/server/dispatchers/dispatcher.ts b/packages/playwright-core/src/server/dispatchers/dispatcher.ts
index 2ad03db61f..07fda756a7 100644
--- a/packages/playwright-core/src/server/dispatchers/dispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/dispatcher.ts
@@ -352,16 +352,21 @@ export class DispatcherConnection {
log: [],
};
- const controller = dispatcher.createProgressController(callMetadata);
- this._activeProgressControllers.set(callMetadata.id, controller);
+ const beforeController = dispatcher.createProgressController(callMetadata);
+ this._activeProgressControllers.set(callMetadata.id, beforeController);
+ // Be generous with the tracing timeout in case it wants to capture a screenshot, fail silently.
+ await beforeController.run(progress => sdkObject.instrumentation.onBeforeCall(progress, sdkObject), 3000).catch(() => {});
+ this._activeProgressControllers.delete(callMetadata.id);
- await sdkObject.instrumentation.onBeforeCall(sdkObject, callMetadata);
const response: any = { id };
try {
// If the dispatcher has been disposed while running the instrumentation call, error out.
if (this._dispatcherByGuid.get(guid) !== dispatcher)
throw new TargetClosedError(sdkObject.closeReason());
+ const controller = dispatcher.createProgressController(callMetadata);
+ this._activeProgressControllers.set(callMetadata.id, controller);
const result = await controller.run(progress => (dispatcher as any)[method](validParams, progress), validMetadata.timeout);
+ this._activeProgressControllers.delete(callMetadata.id);
const validator = findValidator(dispatcher._type, method, 'Result');
response.result = validator(result, '', this._validatorToWireContext());
callMetadata.result = result;
@@ -384,7 +389,10 @@ export class DispatcherConnection {
callMetadata.error = response.error;
} finally {
callMetadata.endTime = monotonicTime();
- await sdkObject.instrumentation.onAfterCall(sdkObject, callMetadata);
+ const afterController = dispatcher.createProgressController(callMetadata);
+ this._activeProgressControllers.set(callMetadata.id, afterController);
+ // Be generous with the tracing timeout in case it wants to capture a screenshot, fail silently.
+ await afterController.run(progress => sdkObject.instrumentation.onAfterCall(progress, sdkObject), 3000).catch(() => {});
if (metainfo?.slowMo)
await this._doSlowMo(sdkObject);
this._activeProgressControllers.delete(callMetadata.id);
@@ -432,7 +440,8 @@ export class DispatcherConnection {
log: [],
};
this._waitOperations.set(info.waitId, callMetadata);
- await sdkObject.instrumentation.onBeforeCall(sdkObject, callMetadata).catch(() => {});
+ const controller = ProgressController.createForSdkObject(sdkObject, callMetadata);
+ await controller.run(progress => sdkObject.instrumentation.onBeforeCall(progress, sdkObject).catch(() => {}));
return;
}
@@ -448,7 +457,8 @@ export class DispatcherConnection {
originalMetadata.endTime = monotonicTime();
originalMetadata.error = info.error ? { error: { name: 'Error', message: info.error } } : undefined;
this._waitOperations.delete(info.waitId);
- await sdkObject.instrumentation.onAfterCall(sdkObject, originalMetadata).catch(() => {});
+ const controller = ProgressController.createForSdkObject(sdkObject, originalMetadata);
+ await controller.run(progress => sdkObject.instrumentation.onAfterCall(progress, sdkObject).catch(() => {}));
}
}
}
diff --git a/packages/playwright-core/src/server/dom.ts b/packages/playwright-core/src/server/dom.ts
index c46aa5ebed..9d1bc1d73b 100644
--- a/packages/playwright-core/src/server/dom.ts
+++ b/packages/playwright-core/src/server/dom.ts
@@ -454,7 +454,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
if (typeof maybeResult === 'string')
return maybeResult;
const point = roundPoint(maybeResult.point);
- await progress.race(this.instrumentation.onBeforeInputAction(this, progress.metadata, point, maybeResult.box));
+ await this.instrumentation.onBeforeInputAction(progress, this, point, maybeResult.box);
let hitTargetInterceptionHandle: js.JSHandle<HitTargetInterceptionResult> | undefined;
if (force) {
@@ -577,7 +577,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
async _selectOption(progress: Progress, elements: ElementHandle[], values: types.SelectOption[], options: types.CommonActionOptions): Promise<string[] | 'error:notconnected'> {
let resultingOptions: string[] = [];
const result = await this._retryAction(progress, 'select option', async progress => {
- await progress.race(this.instrumentation.onBeforeInputAction(this, progress.metadata));
+ await this.instrumentation.onBeforeInputAction(progress, this);
if (!options.force)
progress.log(` waiting for element to be visible and enabled`);
const optionsToSelect = [...elements, ...values];
@@ -610,7 +610,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
async _fill(progress: Progress, value: string, options: types.CommonActionOptions): Promise<'error:notconnected' | 'done'> {
progress.log(` fill("${value}")`);
return await this._retryAction(progress, 'fill', async progress => {
- await progress.race(this.instrumentation.onBeforeInputAction(this, progress.metadata));
+ await this.instrumentation.onBeforeInputAction(progress, this);
if (!options.force)
progress.log(' waiting for element to be visible, enabled and editable');
const result = await progress.race(this.evaluateInUtility(async ([injected, node, { value, force }]) => {
@@ -744,7 +744,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
if (result === 'error:notconnected' || !result.asElement())
return 'error:notconnected';
const retargeted = result.asElement() as ElementHandle<HTMLInputElement>;
- await progress.race(this.instrumentation.onBeforeInputAction(this, progress.metadata));
+ await this.instrumentation.onBeforeInputAction(progress, this);
if (localPaths || localDirectory) {
const localPathsOrDirectory = localDirectory ? [localDirectory] : localPaths!;
await progress.race(Promise.all((localPathsOrDirectory).map(localPath => (
@@ -785,7 +785,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
async _type(progress: Progress, text: string, options: { delay?: number } & types.StrictOptions): Promise<'error:notconnected' | 'done'> {
progress.log(`elementHandle.type("${text}")`);
- await progress.race(this.instrumentation.onBeforeInputAction(this, progress.metadata));
+ await this.instrumentation.onBeforeInputAction(progress, this);
const result = await this._focus(progress, true /* resetSelectionIfNotFocused */);
if (result !== 'done')
return result;
@@ -801,7 +801,7 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
async _press(progress: Progress, key: string, options: { delay?: number, noWaitAfter?: boolean } & types.StrictOptions): Promise<'error:notconnected' | 'done'> {
progress.log(`elementHandle.press("${key}")`);
- await progress.race(this.instrumentation.onBeforeInputAction(this, progress.metadata));
+ await this.instrumentation.onBeforeInputAction(progress, this);
return this._page.frameManager.waitForSignalsCreatedBy(progress, !options.noWaitAfter, async progress => {
const result = await this._focus(progress, true /* resetSelectionIfNotFocused */);
if (result !== 'done')
diff --git a/packages/playwright-core/src/server/input.ts b/packages/playwright-core/src/server/input.ts
index 74bde697bf..a31ed8684f 100644
--- a/packages/playwright-core/src/server/input.ts
+++ b/packages/playwright-core/src/server/input.ts
@@ -54,7 +54,7 @@ export class Keyboard {
}
async apiDown(progress: Progress, key: string) {
- await progress.race(this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata));
+ await this._page.instrumentation.onBeforeInputAction(progress, this._page);
await this.down(progress, key);
}
@@ -82,7 +82,7 @@ export class Keyboard {
}
async apiUp(progress: Progress, key: string) {
- await progress.race(this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata));
+ await this._page.instrumentation.onBeforeInputAction(progress, this._page);
await this.up(progress, key);
}
@@ -95,7 +95,7 @@ export class Keyboard {
}
async apiInsertText(progress: Progress, text: string) {
- await progress.race(this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata));
+ await this._page.instrumentation.onBeforeInputAction(progress, this._page);
await this.insertText(progress, text);
}
@@ -104,7 +104,7 @@ export class Keyboard {
}
async apiType(progress: Progress, text: string, options?: { delay?: number }) {
- await progress.race(this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata));
+ await this._page.instrumentation.onBeforeInputAction(progress, this._page);
await this.type(progress, text, options);
}
@@ -122,7 +122,7 @@ export class Keyboard {
}
async apiPress(progress: Progress, key: string, options: { delay?: number } = {}) {
- await progress.race(this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata));
+ await this._page.instrumentation.onBeforeInputAction(progress, this._page);
await this.press(progress, key, options);
}
@@ -214,7 +214,7 @@ export class Mouse {
}
async apiMove(progress: Progress, x: number, y: number, options: { steps?: number, forClick?: boolean } = {}) {
- await progress.race(this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata, { x, y }));
+ await this._page.instrumentation.onBeforeInputAction(progress, this._page, { x, y });
await this.move(progress, x, y, options);
}
@@ -232,7 +232,7 @@ export class Mouse {
}
async apiDown(progress: Progress, options: { button?: types.MouseButton, clickCount?: number } = {}) {
- await progress.race(this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata, this._currentPoint()));
+ await this._page.instrumentation.onBeforeInputAction(progress, this._page, this._currentPoint());
await this.down(progress, options);
}
@@ -244,7 +244,7 @@ export class Mouse {
}
async apiUp(progress: Progress, options: { button?: types.MouseButton, clickCount?: number } = {}) {
- await progress.race(this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata, this._currentPoint()));
+ await this._page.instrumentation.onBeforeInputAction(progress, this._page, this._currentPoint());
await this.up(progress, options);
}
@@ -256,7 +256,7 @@ export class Mouse {
}
async apiClick(progress: Progress, x: number, y: number, options: { delay?: number, button?: types.MouseButton, clickCount?: number, steps?: number } = {}) {
- await progress.race(this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata, { x, y }));
+ await this._page.instrumentation.onBeforeInputAction(progress, this._page, { x, y });
await this.click(progress, x, y, options);
}
@@ -289,7 +289,7 @@ export class Mouse {
}
async apiWheel(progress: Progress, deltaX: number, deltaY: number) {
- await progress.race(this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata));
+ await this._page.instrumentation.onBeforeInputAction(progress, this._page);
await this._raw.wheel(progress, this._x, this._y, this._buttons, this._keyboard._modifiers(), deltaX, deltaY);
}
}
@@ -370,7 +370,7 @@ export class Touchscreen {
async apiTap(progress: Progress, x: number, y: number) {
if (!this._page.browserContext._options.hasTouch)
throw new Error('hasTouch must be enabled on the browser context before using the touchscreen.');
- await progress.race(this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata, { x, y }));
+ await this._page.instrumentation.onBeforeInputAction(progress, this._page, { x, y });
await this.tap(progress, x, y);
}
diff --git a/packages/playwright-core/src/server/instrumentation.ts b/packages/playwright-core/src/server/instrumentation.ts
index 449782e268..5b8563874f 100644
--- a/packages/playwright-core/src/server/instrumentation.ts
+++ b/packages/playwright-core/src/server/instrumentation.ts
@@ -29,6 +29,7 @@ import type { APIRequestContext } from './fetch';
import type { Frame } from './frames';
import type { Page, Worker } from './page';
import type { Playwright } from './playwright';
+import type { Progress } from './progress';
import type * as types from './types';
import type { LogName } from '@utils/debugLogger';
@@ -109,10 +110,10 @@ export type CallMetadata = {
export interface Instrumentation {
addListener(listener: InstrumentationListener, context: BrowserContext | APIRequestContext | null, options?: AddListenerOptions): void;
removeListener(listener: InstrumentationListener): void;
- onBeforeCall(sdkObject: SdkObject, metadata: CallMetadata, parentId?: string): Promise<void>;
- onBeforeInputAction(sdkObject: SdkObject, metadata: CallMetadata, point?: types.Point, box?: types.Rect): Promise<void>;
+ onBeforeCall(progress: Progress, sdkObject: SdkObject, parentId?: string): Promise<void>;
+ onBeforeInputAction(progress: Progress, sdkObject: SdkObject, point?: types.Point, box?: types.Rect): Promise<void>;
onCallLog(sdkObject: SdkObject, metadata: CallMetadata, logName: string, message: string): void;
- onAfterCall(sdkObject: SdkObject, metadata: CallMetadata): Promise<void>;
+ onAfterCall(progress: Progress, sdkObject: SdkObject): Promise<void>;
onPageOpen(page: Page): void;
onPageClose(page: Page): void;
onBrowserOpen(browser: Browser): void;
@@ -122,10 +123,10 @@ export interface Instrumentation {
}
export interface InstrumentationListener {
- onBeforeCall?(sdkObject: SdkObject, metadata: CallMetadata, parentId?: string): Promise<void>;
- onBeforeInputAction?(sdkObject: SdkObject, metadata: CallMetadata, point?: types.Point, box?: types.Rect): Promise<void>;
+ onBeforeCall?(progress: Progress, sdkObject: SdkObject, parentId?: string): Promise<void>;
+ onBeforeInputAction?(progress: Progress, sdkObject: SdkObject, point?: types.Point, box?: types.Rect): Promise<void>;
onCallLog?(sdkObject: SdkObject, metadata: CallMetadata, logName: string, message: string): void;
- onAfterCall?(sdkObject: SdkObject, metadata: CallMetadata): Promise<void>;
+ onAfterCall?(progress: Progress, sdkObject: SdkObject): Promise<void>;
onPageOpen?(page: Page): void;
onPageClose?(page: Page): void;
onBrowserOpen?(browser: Browser): void;
@@ -157,14 +158,15 @@ export function createInstrumentation(): Instrumentation {
}
if (!prop.startsWith('on'))
return obj[prop];
- return async (sdkObject: SdkObject, ...params: any[]) => {
+ return async (...params: any[]) => {
+ const sdkObject: SdkObject = params[0] instanceof SdkObject ? params[0] : params[1];
for (const [listener, context] of listeners) {
if (!context || sdkObject.attribution.context === context)
- await (listener as any)[prop]?.(sdkObject, ...params);
+ await (listener as any)[prop]?.(...params);
}
for (const [listener, context] of lastListeners) {
if (!context || sdkObject.attribution.context === context)
- await (listener as any)[prop]?.(sdkObject, ...params);
+ await (listener as any)[prop]?.(...params);
}
};
},
diff --git a/packages/playwright-core/src/server/recorder.ts b/packages/playwright-core/src/server/recorder.ts
index e1461dbab7..7b49dd8dca 100644
--- a/packages/playwright-core/src/server/recorder.ts
+++ b/packages/playwright-core/src/server/recorder.ts
@@ -241,7 +241,7 @@ export class Recorder extends EventEmitter<RecorderEventMap> implements Instrume
// If we are called upon page.pause, we don't have metadatas, populate them.
const pausedDetails = this._debugger.pausedDetails();
if (pausedDetails && !this._currentCallsMetadata.has(pausedDetails.metadata))
- this.onBeforeCall(pausedDetails.sdkObject, pausedDetails.metadata);
+ this._onBeforeCall(pausedDetails.sdkObject, pausedDetails.metadata);
this.emit(RecorderEvent.PausedStateChanged, this._debugger.isPaused());
this._updateUserSources();
this._updateCallLog([...this._currentCallsMetadata.keys()]);
@@ -397,7 +397,11 @@ export class Recorder extends EventEmitter<RecorderEventMap> implements Instrume
page => page.safeNonStallingEvaluateInAllFrames('window.__pw_refreshOverlay()', 'main')));
}
- async onBeforeCall(sdkObject: SdkObject, metadata: CallMetadata) {
+ async onBeforeCall(progress: Progress, sdkObject: SdkObject) {
+ this._onBeforeCall(sdkObject, progress.metadata);
+ }
+
+ private _onBeforeCall(sdkObject: SdkObject, metadata: CallMetadata) {
if (this._omitCallTracking || this._isRecording())
return;
this._currentCallsMetadata.set(metadata, sdkObject);
@@ -409,7 +413,8 @@ export class Recorder extends EventEmitter<RecorderEventMap> implements Instrume
this._highlightedElement = { selector: metadata.params.selector };
}
- async onAfterCall(sdkObject: SdkObject, metadata: CallMetadata) {
+ async onAfterCall(progress: Progress) {
+ const { metadata } = progress;
this._actionPoints.delete(metadata.id);
if (this._omitCallTracking || this._isRecording())
return;
@@ -419,7 +424,8 @@ export class Recorder extends EventEmitter<RecorderEventMap> implements Instrume
this._updateCallLog([metadata]);
}
- async onBeforeInputAction(sdkObject: SdkObject, metadata: CallMetadata, point?: Point): Promise<void> {
+ async onBeforeInputAction(progress: Progress, sdkObject: SdkObject, point?: Point): Promise<void> {
+ const { metadata } = progress;
if (point)
this._actionPoints.set(metadata.id, point);
}
diff --git a/packages/playwright-core/src/server/screencast.ts b/packages/playwright-core/src/server/screencast.ts
index b545b5e731..d38cafaf1d 100644
--- a/packages/playwright-core/src/server/screencast.ts
+++ b/packages/playwright-core/src/server/screencast.ts
@@ -21,8 +21,9 @@ import { Page } from './page';
import { nullProgress } from './progress';
import { ElementHandle } from './dom';
-import type { CallMetadata, InstrumentationListener, SdkObject } from './instrumentation';
+import type { InstrumentationListener, SdkObject } from './instrumentation';
import type * as types from './types';
+import type { Progress } from './progress';
export type ScreencastClient = {
onFrame: (frame: types.ScreencastFrame) => Promise<void> | void;
@@ -157,7 +158,7 @@ export class Screencast implements InstrumentationListener {
await Promise.race(asyncResults);
}
- async onBeforeInputAction(sdkObject: SdkObject, metadata: CallMetadata, point?: types.Point, box?: types.Rect): Promise<void> {
+ async onBeforeInputAction(progress: Progress, sdkObject: SdkObject, point?: types.Point, box?: types.Rect): Promise<void> {
if (!this._actions)
return;
@@ -168,17 +169,18 @@ export class Screencast implements InstrumentationListener {
if (!box && (sdkObject instanceof ElementHandle))
box = await sdkObject.boundingBox(nullProgress) || undefined;
- const actionTitle = renderTitleForCall(metadata);
- const utility = await page.mainFrame().utilityContext();
+ const actionTitle = renderTitleForCall(progress.metadata);
+ const utility = await progress.race(page.mainFrame().utilityContext());
// Run this outside of the progress timer.
- await utility.evaluate(async options => {
+ const injected = await progress.race(utility.injectedScript());
+ await progress.race(utility.evaluate(async options => {
const { injected, duration } = options;
injected.setScreencastAnnotation(options);
await new Promise(f => injected.utils.builtins.setTimeout(f, duration));
injected.setScreencastAnnotation(null);
}, {
- injected: await utility.injectedScript(),
+ injected,
duration: this._actions?.duration ?? 500,
point,
box,
@@ -186,6 +188,6 @@ export class Screencast implements InstrumentationListener {
position: this._actions?.position,
fontSize: this._actions?.fontSize,
cursor: this._actions?.cursor ?? 'pointer',
- }).catch(e => debugLogger.log('error', e));
+ }).catch(e => debugLogger.log('error', e)));
}
}
diff --git a/packages/playwright-core/src/server/trace/recorder/tracing.ts b/packages/playwright-core/src/server/trace/recorder/tracing.ts
index 5fc90c8560..3531681496 100644
--- a/packages/playwright-core/src/server/trace/recorder/tracing.ts
+++ b/packages/playwright-core/src/server/trace/recorder/tracing.ts
@@ -23,7 +23,7 @@ import { assert } from '@isomorphic/assert';
import { monotonicTime } from '@isomorphic/time';
import { ManualPromise } from '@isomorphic/manualPromise';
import { eventsHelper } from '@utils/eventsHelper';
-import { createGuid } from '@utils/crypto';
+import { calculateSha1, createGuid } from '@utils/crypto';
import { removeFolders } from '@utils/fileUtils';
import { SerializedFS } from '@utils/serializedFS';
import { getPlaywrightVersion } from '../../userAgent';
@@ -35,7 +35,7 @@ import { serializeError } from '../../errors';
import { HarRecorder } from '../../har/harRecorder';
import { HarTracer } from '../../har/harTracer';
import { SdkObject } from '../../instrumentation';
-import { Page } from '../../page';
+import { Page, ariaSnapshotJSONForFrame } from '../../page';
import { isAbortError, nullProgress } from '../../progress';
import type { SnapshotterBlob, SnapshotterDelegate } from './snapshotter';
@@ -60,8 +60,10 @@ const version: trace.VERSION = 8;
export type TracerOptions = {
name?: string;
- snapshots?: boolean;
- screenshots?: boolean;
+ snapshotDom?: boolean;
+ snapshotAria?: boolean;
+ snapshotScreen?: boolean;
+ screencast?: boolean;
live?: boolean;
};
@@ -76,7 +78,7 @@ type RecordingState = {
networkSha1s: Set<string>,
traceSha1s: Set<string>,
recording: boolean;
- callIds: Set<string>;
+ callsInProgress: Set<string>;
groupStack: string[];
};
@@ -172,13 +174,13 @@ export class Tracing extends SdkObject implements InstrumentationListener, Snaps
traceSha1s: new Set(),
networkSha1s: new Set(),
recording: false,
- callIds: new Set(),
+ callsInProgress: new Set(),
groupStack: [],
};
this._fs.mkdir(this._state.resourcesDir);
this._fs.writeFile(this._state.networkFile, '');
// Tracing is 10x bigger if we include scripts in every trace.
- if (options.snapshots)
+ if (options.snapshotDom)
this._harTracer.start({ omitScripts: !options.live });
this._started = true;
}
@@ -193,7 +195,7 @@ export class Tracing extends SdkObject implements InstrumentationListener, Snaps
throw new Error('Cannot start a trace chunk while stopping');
this._state.recording = true;
- this._state.callIds.clear();
+ this._state.callsInProgress.clear();
// - Browser context network trace is shared across chunks as it contains resources
// used to serve page snapshots, so make a copy with the new name.
@@ -220,10 +222,10 @@ export class Tracing extends SdkObject implements InstrumentationListener, Snaps
eventsHelper.addEventListener(this._context, BrowserContext.Events.Console, this._onConsoleMessage.bind(this)),
eventsHelper.addEventListener(this._context, BrowserContext.Events.PageError, this._onPageError.bind(this)),
);
- if (this._state.options.screenshots)
+ if (this._state.options.screencast)
this._startScreencast();
this._harTracer.setOmitWebSocketFrames(!!process.env.PLAYWRIGHT_TRACING_NO_WEBSOCKET_FRAMES);
- if (this._state.options.snapshots)
+ if (this._state.options.snapshotDom)
await this._snapshotter?.start(progress);
return { traceName: this._state.traceName };
}
@@ -392,12 +394,12 @@ export class Tracing extends SdkObject implements InstrumentationListener, Snaps
this._context.instrumentation.removeListener(this);
eventsHelper.removeEventListeners(this._eventListeners);
- if (this._state.options.screenshots)
+ if (this._state.options.screencast)
this._stopScreencast();
// We don't need websocket frames outside of the recording window. This also
// stops updating websocket content blobs, which we want to stay unchanged for zipping.
this._harTracer.setOmitWebSocketFrames(true);
- if (this._state.options.snapshots)
+ if (this._state.options.snapshotDom)
this._snapshotter?.stop();
this.flushHarEntries();
@@ -461,56 +463,96 @@ export class Tracing extends SdkObject implements InstrumentationListener, Snaps
return { artifact };
}
- private async _captureSnapshot(snapshotName: string | undefined, sdkObject: SdkObject, metadata: CallMetadata, resetTargets: boolean): Promise<void> {
- if (!snapshotName || !sdkObject.attribution.page)
+ private async _captureSnapshot(progress: Progress, sdkObject: SdkObject, phase: trace.ActionPhase, domSnapshotName: string | undefined): Promise<void> {
+ const page = sdkObject.attribution.page;
+ if (!page)
return;
- await this._snapshotter?.captureSnapshot(sdkObject.attribution.page, metadata.id, snapshotName, resetTargets).catch(() => {});
+
+ if (domSnapshotName) {
+ // Node references are only reset by the first snapshot of the action.
+ const resetTargets = phase === 'before';
+ await this._snapshotter?.captureSnapshot(page, progress.metadata.id, domSnapshotName, resetTargets).catch(() => {});
+ }
+
+ const options = this._state?.options;
+ if (!options?.snapshotScreen && !options?.snapshotAria)
+ return;
+ if (!this._shouldCaptureAtPhase(progress.metadata, phase))
+ return;
+ if (options.snapshotScreen)
+ await this._captureScreenshot(progress, page, phase);
+ if (options.snapshotAria)
+ await this._captureAriaSnapshot(progress, page, phase);
}
- private _shouldCaptureSnapshot(sdkObject: SdkObject, metadata: CallMetadata, phase: 'before' | 'after' | 'input') {
+ private _shouldCaptureDOMSnapshot(sdkObject: SdkObject, metadata: CallMetadata, phase: trace.ActionPhase) {
if (!sdkObject.attribution.page || !this._snapshotter?.started())
- return;
+ return false;
+ return this._shouldCaptureAtPhase(metadata, phase);
+ }
+ private _shouldCaptureAtPhase(metadata: CallMetadata, phase: trace.ActionPhase) {
const metainfo = getMetainfo(metadata);
if (!metainfo?.snapshot)
return false;
switch (phase) {
case 'before': return !metainfo.input || !!metainfo.isAutoWaiting;
- case 'input': return !!metainfo.input;
+ case 'action': return !!metainfo.input;
case 'after': return true;
}
}
- onBeforeCall(sdkObject: SdkObject, metadata: CallMetadata, parentId?: string) {
+ private async _captureScreenshot(progress: Progress, page: Page, phase: trace.ActionPhase): Promise<void> {
+ const buffer = await page.screenshot(progress, { type: 'png' }).catch(() => undefined);
+ if (!buffer || !this._state?.recording)
+ return;
+ const sha1 = calculateSha1(buffer) + '.png';
+ this._appendResource(sha1, buffer);
+ this._appendTraceEvent({ type: 'screenshot', callId: progress.metadata.id, phase, sha1 });
+ }
+
+ private async _captureAriaSnapshot(progress: Progress, page: Page, phase: trace.ActionPhase): Promise<void> {
+ const snapshot = await ariaSnapshotJSONForFrame(progress, page.mainFrame(), undefined, { mode: 'default' }).catch(() => null);
+ if (!snapshot || !this._state?.recording)
+ return;
+ const buffer = Buffer.from(JSON.stringify(snapshot), 'utf8');
+ const sha1 = calculateSha1(buffer) + '.json';
+ this._appendResource(sha1, buffer);
+ this._appendTraceEvent({ type: 'aria-snapshot', callId: progress.metadata.id, phase, sha1 });
+ }
+
+ onBeforeCall(progress: Progress, sdkObject: SdkObject, parentId?: string) {
// IMPORTANT: no awaits in this method, this._appendTraceEvent must be called synchronously.
+ const { metadata } = progress;
const event = createBeforeActionTraceEvent(metadata, parentId ?? this._currentGroupId());
if (!event)
return Promise.resolve();
this._temporarilyDisableThrottling(sdkObject.attribution.page);
- if (this._shouldCaptureSnapshot(sdkObject, metadata, 'before'))
+ if (this._shouldCaptureDOMSnapshot(sdkObject, metadata, 'before'))
event.beforeSnapshot = `before@${metadata.id}`;
- this._state?.callIds.add(metadata.id);
+ this._state?.callsInProgress.add(metadata.id);
this._appendTraceEvent(event);
- return this._captureSnapshot(event.beforeSnapshot, sdkObject, metadata, true);
+ return this._captureSnapshot(progress, sdkObject, 'before', event.beforeSnapshot);
}
- onBeforeInputAction(sdkObject: SdkObject, metadata: CallMetadata, point?: types.Point) {
+ onBeforeInputAction(progress: Progress, sdkObject: SdkObject, point?: types.Point) {
+ const { metadata } = progress;
// IMPORTANT: no awaits in this method, this._appendTraceEvent must be called synchronously.
- if (!this._state?.callIds.has(metadata.id))
+ if (!this._state?.callsInProgress.has(metadata.id))
return Promise.resolve();
const event = createInputActionTraceEvent(metadata, point);
if (!event)
return Promise.resolve();
this._temporarilyDisableThrottling(sdkObject.attribution.page);
- if (this._shouldCaptureSnapshot(sdkObject, metadata, 'input'))
+ if (this._shouldCaptureDOMSnapshot(sdkObject, metadata, 'action'))
event.inputSnapshot = `input@${metadata.id}`;
this._appendTraceEvent(event);
- return this._captureSnapshot(event.inputSnapshot, sdkObject, metadata, false);
+ return this._captureSnapshot(progress, sdkObject, 'action', event.inputSnapshot);
}
onCallLog(sdkObject: SdkObject, metadata: CallMetadata, logName: string, message: string) {
- if (!this._state?.callIds.has(metadata.id))
+ if (!this._state?.callsInProgress.has(metadata.id))
return;
if (metadata.internal)
return;
@@ -521,19 +563,20 @@ export class Tracing extends SdkObject implements InstrumentationListener, Snaps
this._appendTraceEvent(event);
}
- onAfterCall(sdkObject: SdkObject, metadata: CallMetadata) {
+ onAfterCall(progress: Progress, sdkObject: SdkObject) {
// IMPORTANT: no awaits in this method, this._appendTraceEvent must be called synchronously.
- if (!this._state?.callIds.has(metadata.id))
+ const { metadata } = progress;
+ if (!this._state?.callsInProgress.has(metadata.id))
return Promise.resolve();
- this._state?.callIds.delete(metadata.id);
+ this._state?.callsInProgress.delete(metadata.id);
const event = createAfterActionTraceEvent(metadata);
if (!event)
return Promise.resolve();
this._temporarilyDisableThrottling(sdkObject.attribution.page);
- if (this._shouldCaptureSnapshot(sdkObject, metadata, 'after'))
+ if (this._shouldCaptureDOMSnapshot(sdkObject, metadata, 'after'))
event.afterSnapshot = `after@${metadata.id}`;
this._appendTraceEvent(event);
- return this._captureSnapshot(event.afterSnapshot, sdkObject, metadata, false);
+ return this._captureSnapshot(progress, sdkObject, 'after', event.afterSnapshot);
}
onEntryStarted(entry: har.Entry) {
diff --git a/packages/playwright-core/types/types.d.ts b/packages/playwright-core/types/types.d.ts
index 0bc3533eec..ac62bab28e 100644
--- a/packages/playwright-core/types/types.d.ts
+++ b/packages/playwright-core/types/types.d.ts
@@ -23692,11 +23692,24 @@ export interface Tracing {
screenshots?: boolean;
/**
- * If this option is true tracing will
- * - capture DOM snapshot on every action
- * - record network activity
+ * Which snapshots to capture on every action. Passing `true` is a shortcut for `{ dom: true }`.
*/
- snapshots?: boolean;
+ snapshots?: boolean|{
+ /**
+ * Capture DOM snapshot on every action and record network activity. Optional.
+ */
+ dom?: boolean;
+
+ /**
+ * Capture aria snapshot of the page on every action. Optional.
+ */
+ aria?: boolean;
+
+ /**
+ * Capture a screenshot of the page on every action. Optional.
+ */
+ screen?: boolean;
+ };
/**
* Whether to include source files for trace actions.
diff --git a/packages/protocol/spec/tracing.yml b/packages/protocol/spec/tracing.yml
index 499fa9019e..a33e659cce 100644
--- a/packages/protocol/spec/tracing.yml
+++ b/packages/protocol/spec/tracing.yml
@@ -22,8 +22,10 @@ Tracing:
group: configuration
parameters:
name: string?
- snapshots: boolean?
- screenshots: boolean?
+ snapshotDom: boolean?
+ snapshotAria: boolean?
+ snapshotScreen: boolean?
+ screencast: boolean?
live: boolean?
tracingStartChunk:
diff --git a/packages/protocol/src/validator.ts b/packages/protocol/src/validator.ts
index 9e5cd7dcde..cf7181036d 100644
--- a/packages/protocol/src/validator.ts
+++ b/packages/protocol/src/validator.ts
@@ -3037,8 +3037,10 @@ scheme.NameValue = tObject({
scheme.TracingInitializer = tOptional(tObject({}));
scheme.TracingTracingStartParams = tObject({
name: tOptional(tString),
- snapshots: tOptional(tBoolean),
- screenshots: tOptional(tBoolean),
+ snapshotDom: tOptional(tBoolean),
+ snapshotAria: tOptional(tBoolean),
+ snapshotScreen: tOptional(tBoolean),
+ screencast: tOptional(tBoolean),
live: tOptional(tBoolean),
});
scheme.TracingTracingStartResult = tOptional(tObject({}));
diff --git a/packages/trace/src/trace.ts b/packages/trace/src/trace.ts
index 0cb6ae33d1..a7d6ba58d6 100644
--- a/packages/trace/src/trace.ts
+++ b/packages/trace/src/trace.ts
@@ -107,6 +107,22 @@ export type ScreencastFrameTraceEvent = {
frameSwapWallTime?: number,
};
+export type ActionPhase = 'before' | 'action' | 'after';
+
+export type ScreenshotTraceEvent = {
+ type: 'screenshot',
+ callId: string,
+ phase: ActionPhase,
+ sha1: string,
+};
+
+export type AriaSnapshotTraceEvent = {
+ type: 'aria-snapshot',
+ callId: string,
+ phase: ActionPhase,
+ sha1: string,
+};
+
export type BeforeActionTraceEvent = {
type: 'before',
callId: string;
@@ -217,6 +233,8 @@ export type ErrorTraceEvent = {
export type TraceEvent =
ContextCreatedTraceEvent |
ScreencastFrameTraceEvent |
+ ScreenshotTraceEvent |
+ AriaSnapshotTraceEvent |
ActionTraceEvent |
BeforeActionTraceEvent |
InputActionTraceEvent |
diff --git a/tests/library/tracing.spec.ts b/tests/library/tracing.spec.ts
index 3984bc572b..85466e461f 100644
--- a/tests/library/tracing.spec.ts
+++ b/tests/library/tracing.spec.ts
@@ -15,7 +15,7 @@
*/
import fs from 'fs';
-import { jpegjs } from 'playwright-core/lib/utilsBundle';
+import { PNG, jpegjs } from 'playwright-core/lib/utilsBundle';
import path from 'path';
import { browserTest, contextTest as test, expect } from '../config/browserTest';
import { parseTraceRaw } from '../config/utils';
@@ -108,6 +108,51 @@ test('should not collect snapshots by default', async ({ context, page, server }
expect(events.some(e => e.type === 'resource-snapshot')).toBeFalsy();
});
+test('should not collect action screenshots and aria snapshots by default', async ({ context, page, server }, testInfo) => {
+ await context.tracing.start({ snapshots: true });
+ await page.goto(server.PREFIX + '/input/button.html');
+ await page.click('button');
+ await context.tracing.stop({ path: testInfo.outputPath('trace.zip') });
+
+ const { events } = await parseTraceRaw(testInfo.outputPath('trace.zip'));
+ expect(events.some(e => e.type === 'screenshot')).toBeFalsy();
+ expect(events.some(e => e.type === 'aria-snapshot')).toBeFalsy();
+});
+
+test('should collect action screenshots', async ({ context, page, server }, testInfo) => {
+ await context.tracing.start({ snapshots: { screen: true } });
+ await page.goto(server.PREFIX + '/input/button.html');
+ await page.click('button');
+ await context.tracing.stop({ path: testInfo.outputPath('trace.zip') });
+
+ const { events, resources } = await parseTraceRaw(testInfo.outputPath('trace.zip'));
+ const clickCallId = events.find(e => e.type === 'before' && e.method === 'click').callId;
+ const screenshots = events.filter(e => e.type === 'screenshot' && e.callId === clickCallId);
+ expect(screenshots.map(e => e.phase)).toEqual(['before', 'action', 'after']);
+ for (const screenshot of screenshots) {
+ const buffer = resources.get('resources/' + screenshot.sha1);
+ expect(PNG.sync.read(buffer).width).toBeGreaterThan(0);
+ }
+});
+
+test('should collect aria snapshots', async ({ context, page, server }, testInfo) => {
+ await context.tracing.start({ snapshots: { aria: true } });
+ await page.goto(server.PREFIX + '/input/button.html');
+ await page.click('button');
+ await context.tracing.stop({ path: testInfo.outputPath('trace.zip') });
+
+ const { events, resources } = await parseTraceRaw(testInfo.outputPath('trace.zip'));
+ const clickCallId = events.find(e => e.type === 'before' && e.method === 'click').callId;
+ const ariaSnapshots = events.filter(e => e.type === 'aria-snapshot' && e.callId === clickCallId);
+ expect(ariaSnapshots.map(e => e.phase)).toEqual(['before', 'action', 'after']);
+ const hasButton = nodes => nodes.some(node => typeof node === 'object' && (node.role === 'button' && node.name === 'Click target' || hasButton(node.children ?? [])));
+ for (const ariaSnapshot of ariaSnapshots) {
+ expect(ariaSnapshot.sha1).toMatch(/\.json$/);
+ const snapshot = JSON.parse(resources.get('resources/' + ariaSnapshot.sha1).toString());
+ expect(hasButton(snapshot)).toBe(true);
+ }
+});
+
test('can call tracing.group/groupEnd at any time and auto-close', async ({ context, page, server }, testInfo) => {
await context.tracing.group('ignored');
await context.tracing.groupEnd();