tessl/maven-org-seleniumhq-selenium--selenium-devtools-v110

Chrome DevTools Protocol (CDP) bindings for Java - version 110, enabling advanced browser automation features like network interception, console event handling, JavaScript execution, and target management.

—

Pending

Overview

Eval results

Files

Event Handling

Name: tessl/maven-org-seleniumhq-selenium--selenium-devtools-v110
Author: tessl

JavaScript console monitoring, exception tracking, and runtime event handling with full Chrome DevTools Protocol v110 integration for comprehensive browser event observation.

Capabilities

Events Domain Wrapper

High-level wrapper for CDP runtime events providing type-safe access to console events and JavaScript exceptions.

/**
 * Events domain wrapper for CDP v110 runtime events
 */
public class v110Events extends Events<ConsoleAPICalled, ExceptionThrown> {
    /**
     * Initialize events domain with DevTools session
     * @param devtools Active DevTools session
     */
    public v110Events(DevTools devtools);
}

Runtime Domain Control

Enable and disable the runtime domain for event monitoring.

/**
 * Enable runtime domain for event monitoring
 * @return Command to enable runtime
 */
protected Command<Void> enableRuntime();

/**
 * Disable runtime domain
 * @return Command to disable runtime  
 */
protected Command<Void> disableRuntime();

Console Event Monitoring

Monitor JavaScript console API calls including console.log, console.error, console.warn, and other console methods.

/**
 * Get console API called events
 * @return Event stream for console API calls
 */
protected Event<ConsoleAPICalled> consoleEvent();

/**
 * Convert CDP console event to Selenium console event
 * @param event CDP console API called event
 * @return Selenium console event
 */
protected ConsoleEvent toConsoleEvent(ConsoleAPICalled event);

Usage Example:

import org.openqa.selenium.devtools.events.ConsoleEvent;
import org.openqa.selenium.devtools.v110.v110Events;

v110Events events = new v110Events(devTools);

// Enable runtime for console monitoring
devTools.send(events.enableRuntime());

// Add console listener
events.addConsoleListener(consoleEvent -> {
    System.out.println("Console Type: " + consoleEvent.getType());
    System.out.println("Timestamp: " + consoleEvent.getTimestamp());
    System.out.println("Messages: " + consoleEvent.getMessages());
});

// Navigate to page that generates console output
driver.get("https://example.com");

Exception Tracking

Monitor JavaScript exceptions and runtime errors with full stack trace information.

/**
 * Get exception thrown events  
 * @return Event stream for JavaScript exceptions
 */
protected Event<ExceptionThrown> exceptionThrownEvent();

/**
 * Convert CDP exception to JavascriptException
 * @param event CDP exception thrown event
 * @return JavaScript exception with stack trace
 */
protected JavascriptException toJsException(ExceptionThrown event);

Usage Example:

import org.openqa.selenium.JavascriptException;
import org.openqa.selenium.devtools.v110.runtime.model.ExceptionThrown;

// Add exception listener
devTools.addListener(events.exceptionThrownEvent(), exceptionEvent -> {
    JavascriptException jsException = events.toJsException(exceptionEvent);
    System.err.println("JavaScript Error: " + jsException.getMessage());
    jsException.printStackTrace();
});

High-Level Event Listeners

Convenient methods for common event monitoring scenarios.

/**
 * Add console event listener with automatic runtime management
 * @param consumer Function to handle console events
 */
public void addConsoleListener(Consumer<ConsoleEvent> consumer);

/**
 * Add JavaScript exception listener  
 * @param consumer Function to handle JavaScript exceptions
 */
public void addJavaScriptExceptionListener(Consumer<JavascriptException> consumer);

CDP Domain Classes

Runtime Domain

Direct access to CDP Runtime domain for low-level runtime operations.

import org.openqa.selenium.devtools.v110.runtime.Runtime;

/**
 * Enable runtime domain
 */
public static Command<Void> enable();

/**
 * Disable runtime domain
 */
public static Command<Void> disable();

/**
 * Console API called event
 */
public static Event<ConsoleAPICalled> consoleAPICalled();

/**
 * Exception thrown event
 */
public static Event<ExceptionThrown> exceptionThrown();

Model Classes

Console Event Models

import org.openqa.selenium.devtools.v110.runtime.model.*;
import org.openqa.selenium.devtools.events.ConsoleEvent;

/**
 * CDP console API called event
 */
public class ConsoleAPICalled {
    /**
     * Console API type (log, error, warn, etc.)
     */
    ConsoleAPICalledType getType();
    
    /**
     * Console arguments as remote objects
     */
    List<RemoteObject> getArgs();
    
    /**
     * Event timestamp
     */
    Timestamp getTimestamp();
    
    /**
     * Execution context ID
     */
    Optional<ExecutionContextId> getExecutionContextId();
}

/**
 * Console API call types
 */
public enum ConsoleAPICalledType {
    LOG, DEBUG, INFO, ERROR, WARNING, DIR, DIRXML, TABLE, TRACE, 
    CLEAR, STARTGROUP, STARTGROUPCOLLAPSED, ENDGROUP, ASSERT, 
    PROFILE, PROFILEEND, COUNT, TIMEEND
}

/**
 * Selenium console event (high-level)
 */
public class ConsoleEvent {
    String getType();
    Instant getTimestamp();
    List<Object> getMessages();
    List<RemoteObject> getRawMessages();
}

Exception Event Models

/**
 * CDP exception thrown event
 */
public class ExceptionThrown {
    /**
     * Exception details with stack trace
     */
    ExceptionDetails getExceptionDetails();
    
    /**
     * Event timestamp
     */
    Timestamp getTimestamp();
}

/**
 * JavaScript exception details
 */
public class ExceptionDetails {
    /**
     * Exception message text
     */
    String getText();
    
    /**
     * Source URL where exception occurred
     */
    Optional<String> getUrl();
    
    /**
     * Line number in source
     */
    Integer getLineNumber();
    
    /**
     * Column number in source  
     */
    Integer getColumnNumber();
    
    /**
     * Exception object details
     */
    Optional<RemoteObject> getException();
    
    /**
     * Stack trace information
     */
    Optional<StackTrace> getStackTrace();
}

/**
 * JavaScript stack trace
 */
public class StackTrace {
    /**
     * Stack frame descriptions
     */
    String getDescription();
    
    /**
     * Individual call frames
     */
    List<CallFrame> getCallFrames();
}

/**
 * Individual stack frame
 */
public class CallFrame {
    /**
     * Function name
     */
    String getFunctionName();
    
    /**
     * Source URL
     */
    String getUrl();
    
    /**
     * Line number
     */
    Integer getLineNumber();
    
    /**
     * Column number
     */
    Integer getColumnNumber();
}

Remote Object Models

/**
 * JavaScript remote object representation
 */
public class RemoteObject {
    /**
     * Object type (object, function, undefined, string, number, boolean, symbol, bigint)
     */
    RemoteObjectType getType();
    
    /**
     * Object subtype (array, null, node, regexp, date, map, set, etc.)
     */
    Optional<RemoteObjectSubtype> getSubtype();
    
    /**
     * Object value (for primitive types)
     */
    Optional<Object> getValue();
    
    /**
     * String description of object
     */
    Optional<String> getDescription();
    
    /**
     * Object ID for further operations
     */
    Optional<RemoteObjectId> getObjectId();
}

/**
 * Idealized remote object (Selenium wrapper)
 */
public class org.openqa.selenium.devtools.idealized.runtime.model.RemoteObject {
    String getType();
    Object getValue();
}

Timestamp Models

/**
 * CDP timestamp representation
 */
public class Timestamp {
    /**
     * Convert to JSON number
     */
    Number toJson();
    
    /**
     * String representation
     */
    String toString();
}

Advanced Usage Examples

Comprehensive Console Monitoring

v110Events events = new v110Events(devTools);
devTools.send(events.enableRuntime());

// Monitor all console activity with detailed information
events.addConsoleListener(event -> {
    String logLevel = event.getType();
    Instant timestamp = event.getTimestamp();
    List<Object> messages = event.getMessages();
    
    System.out.printf("[%s] %s: %s%n", 
        timestamp, logLevel, messages);
        
    // Access raw CDP objects for detailed inspection
    List<RemoteObject> rawMessages = event.getRawMessages();
    for (RemoteObject obj : rawMessages) {
        if (obj.getType().toString().equals("object")) {
            System.out.println("Object details: " + obj.getDescription());
        }
    }
});

Exception Monitoring with Stack Traces

devTools.addListener(events.exceptionThrownEvent(), exceptionEvent -> {
    ExceptionDetails details = exceptionEvent.getExceptionDetails();
    
    System.err.println("Exception: " + details.getText());
    System.err.println("Location: " + details.getUrl().orElse("unknown") + 
                       ":" + details.getLineNumber());
    
    // Process stack trace
    details.getStackTrace().ifPresent(stackTrace -> {
        System.err.println("Stack trace:");
        for (CallFrame frame : stackTrace.getCallFrames()) {
            System.err.printf("  at %s (%s:%d:%d)%n",
                frame.getFunctionName(),
                frame.getUrl(), 
                frame.getLineNumber(),
                frame.getColumnNumber());
        }
    });
});

Error Handling

Event monitoring operations may encounter various error conditions:

import org.openqa.selenium.devtools.DevToolsException;

// Handle runtime enablement failures
try {
    devTools.send(events.enableRuntime());
} catch (DevToolsException e) {
    System.err.println("Failed to enable runtime domain: " + e.getMessage());
}

// Handle event listener failures
events.addConsoleListener(event -> {
    try {
        // Process console event
        processConsoleEvent(event);
    } catch (Exception e) {
        System.err.println("Error processing console event: " + e.getMessage());
    }
});

Install with Tessl CLI

npx tessl i tessl/maven-org-seleniumhq-selenium--selenium-devtools-v110

docs