method

inspector.Session.on

event: string,
listener: (...args: any[]) => void
): this;

Adds the listener function to the end of the listeners array for the event named eventName. No checks are made to see if the listener has already been added. Multiple calls passing the same combination of eventName and listener will result in the listener being added, and called, multiple times.

server.on('connection', (stream) => {
  console.log('someone connected!');
});

Returns a reference to the EventEmitter, so that calls can be chained.

By default, event listeners are invoked in the order they are added. The emitter.prependListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
@param event

The name of the event.

@param listener

The callback function

event: 'inspectorNotification',
listener: (message: InspectorNotification<object>) => void
): this;

Emitted when any notification from the V8 Inspector is received.

event: 'Runtime.executionContextCreated',
listener: (message: InspectorNotification<ExecutionContextCreatedEventDataType>) => void
): this;

Issued when new execution context is created.

event: 'Runtime.executionContextDestroyed',
listener: (message: InspectorNotification<ExecutionContextDestroyedEventDataType>) => void
): this;

Issued when execution context is destroyed.

event: 'Runtime.executionContextsCleared',
listener: () => void
): this;

Issued when all executionContexts were cleared in browser

event: 'Runtime.exceptionThrown',
listener: (message: InspectorNotification<ExceptionThrownEventDataType>) => void
): this;

Issued when exception was thrown and unhandled.

event: 'Runtime.exceptionRevoked',
listener: (message: InspectorNotification<ExceptionRevokedEventDataType>) => void
): this;

Issued when unhandled exception was revoked.

event: 'Runtime.consoleAPICalled',
listener: (message: InspectorNotification<ConsoleAPICalledEventDataType>) => void
): this;

Issued when console API was called.

event: 'Runtime.inspectRequested',
listener: (message: InspectorNotification<InspectRequestedEventDataType>) => void
): this;

Issued when object should be inspected (for example, as a result of inspect() command line API call).

event: 'Debugger.scriptParsed',
listener: (message: InspectorNotification<ScriptParsedEventDataType>) => void
): this;

Fired when virtual machine parses script. This event is also fired for all known and uncollected scripts upon enabling debugger.

event: 'Debugger.scriptFailedToParse',
listener: (message: InspectorNotification<ScriptFailedToParseEventDataType>) => void
): this;

Fired when virtual machine fails to parse the script.

event: 'Debugger.breakpointResolved',
listener: (message: InspectorNotification<BreakpointResolvedEventDataType>) => void
): this;

Fired when breakpoint is resolved to an actual script and location.

event: 'Debugger.paused',
listener: (message: InspectorNotification<PausedEventDataType>) => void
): this;

Fired when the virtual machine stopped on breakpoint or exception or any other stop criteria.

event: 'Debugger.resumed',
listener: () => void
): this;

Fired when the virtual machine resumed execution.

event: 'Console.messageAdded',
listener: (message: InspectorNotification<MessageAddedEventDataType>) => void
): this;

Issued when new console message is added.

event: 'Profiler.consoleProfileStarted',
listener: (message: InspectorNotification<ConsoleProfileStartedEventDataType>) => void
): this;

Sent when new profile recording is started using console.profile() call.

event: 'Profiler.consoleProfileFinished',
listener: (message: InspectorNotification<ConsoleProfileFinishedEventDataType>) => void
): this;
event: 'HeapProfiler.addHeapSnapshotChunk',
listener: (message: InspectorNotification<AddHeapSnapshotChunkEventDataType>) => void
): this;
event: 'HeapProfiler.resetProfiles',
listener: () => void
): this;
event: 'HeapProfiler.reportHeapSnapshotProgress',
listener: (message: InspectorNotification<ReportHeapSnapshotProgressEventDataType>) => void
): this;
event: 'HeapProfiler.lastSeenObjectId',
listener: (message: InspectorNotification<LastSeenObjectIdEventDataType>) => void
): this;

If heap objects tracking has been started then backend regularly sends a current value for last seen object id and corresponding timestamp. If the were changes in the heap since last event then one or more heapStatsUpdate events will be sent before a new lastSeenObjectId event.

event: 'HeapProfiler.heapStatsUpdate',
listener: (message: InspectorNotification<HeapStatsUpdateEventDataType>) => void
): this;

If heap objects tracking has been started then backend may send update for one or more fragments

event: 'Network.requestWillBeSent',
listener: (message: InspectorNotification<RequestWillBeSentEventDataType>) => void
): this;

Fired when page is about to send HTTP request.

event: 'Network.responseReceived',
listener: (message: InspectorNotification<ResponseReceivedEventDataType>) => void
): this;

Fired when HTTP response is available.

event: 'Network.loadingFailed',
listener: (message: InspectorNotification<LoadingFailedEventDataType>) => void
): this;
event: 'Network.loadingFinished',
listener: (message: InspectorNotification<LoadingFinishedEventDataType>) => void
): this;
event: 'Network.dataReceived',
listener: (message: InspectorNotification<DataReceivedEventDataType>) => void
): this;

Fired when data chunk was received over the network.

event: 'Network.webSocketCreated',
listener: (message: InspectorNotification<WebSocketCreatedEventDataType>) => void
): this;

Fired upon WebSocket creation.

event: 'Network.webSocketClosed',
listener: (message: InspectorNotification<WebSocketClosedEventDataType>) => void
): this;

Fired when WebSocket is closed.

event: 'Network.webSocketHandshakeResponseReceived',
listener: (message: InspectorNotification<WebSocketHandshakeResponseReceivedEventDataType>) => void
): this;

Fired when WebSocket handshake response becomes available.

event: 'NodeRuntime.waitingForDisconnect',
listener: () => void
): this;

This event is fired instead of Runtime.executionContextDestroyed when enabled. It is fired when the Node process finished all code execution and is waiting for all frontends to disconnect.

event: 'NodeRuntime.waitingForDebugger',
listener: () => void
): this;

This event is fired when the runtime is waiting for the debugger. For example, when inspector.waitingForDebugger is called

event: 'NodeTracing.dataCollected',
listener: (message: InspectorNotification<DataCollectedEventDataType>) => void
): this;

Contains an bucket of collected trace events.

event: 'NodeTracing.tracingComplete',
listener: () => void
): this;

Signals that tracing is stopped and there is no trace buffers pending flush, all data were delivered via dataCollected events.

event: 'NodeWorker.attachedToWorker',
listener: (message: InspectorNotification<AttachedToWorkerEventDataType>) => void
): this;

Issued when attached to a worker.

event: 'NodeWorker.detachedFromWorker',
listener: (message: InspectorNotification<DetachedFromWorkerEventDataType>) => void
): this;

Issued when detached from the worker.

event: 'NodeWorker.receivedMessageFromWorker',
listener: (message: InspectorNotification<ReceivedMessageFromWorkerEventDataType>) => void
): this;

Notifies about a new protocol message received from the session (session ID is provided in attachedToWorker notification).

event: 'Target.targetCreated',
listener: (message: InspectorNotification<TargetCreatedEventDataType>) => void
): this;
event: 'Target.attachedToTarget',
listener: (message: InspectorNotification<AttachedToTargetEventDataType>) => void
): this;
event: 'DOMStorage.domStorageItemAdded',
listener: (message: InspectorNotification<DomStorageItemAddedEventDataType>) => void
): this;
event: 'DOMStorage.domStorageItemRemoved',
listener: (message: InspectorNotification<DomStorageItemRemovedEventDataType>) => void
): this;
event: 'DOMStorage.domStorageItemUpdated',
listener: (message: InspectorNotification<DomStorageItemUpdatedEventDataType>) => void
): this;
event: 'DOMStorage.domStorageItemsCleared',
listener: (message: InspectorNotification<DomStorageItemsClearedEventDataType>) => void
): this;