Runtime Events & Exception Handling

/**
 * Runtime events handler providing console and exception event processing
 * Extends the idealized Events class with CDP v115 specific implementations
 */
public class v115Events extends Events<ConsoleAPICalled, ExceptionThrown> {
    /**
     * Creates events domain with DevTools connection
     * @param devtools DevTools instance for CDP communication
     */
    public v115Events(DevTools devtools);
    
    /**
     * Enable runtime domain for event collection
     * @return Command to enable runtime domain
     */
    protected Command<Void> enableRuntime();
    
    /**
     * Disable runtime domain and stop event collection
     * @return Command to disable runtime domain
     */
    protected Command<Void> disableRuntime();
    
    /**
     * Get console API called event stream
     * @return Event stream for console API calls
     */
    protected Event<ConsoleAPICalled> consoleEvent();
    
    /**
     * Get exception thrown event stream  
     * @return Event stream for JavaScript exceptions
     */
    protected Event<ExceptionThrown> exceptionThrownEvent();
    
    /**
     * Convert CDP console event to idealized ConsoleEvent
     * @param event CDP console API called event
     * @return Idealized console event with converted timestamp and arguments
     */
    protected ConsoleEvent toConsoleEvent(ConsoleAPICalled event);
    
    /**
     * Convert CDP exception event to JavascriptException
     * @param event CDP exception thrown event  
     * @return JavascriptException with stack trace and message
     */
    protected JavascriptException toJsException(ExceptionThrown event);
}

/**
 * Add console event listener (inherited from Events base class)
 * @param listener Consumer to handle console events
 */
public void addConsoleListener(Consumer<ConsoleEvent> listener);

import org.openqa.selenium.devtools.v115.v115Events;
import org.openqa.selenium.devtools.events.ConsoleEvent;

// Create events domain
v115Events events = new v115Events(devTools);

// Listen to all console events
events.addConsoleListener(event -> {
    System.out.println("Console Event:");
    System.out.println("  Type: " + event.getType());
    System.out.println("  Timestamp: " + event.getTimestamp());
    System.out.println("  Messages: " + String.join(", ", event.getMessages()));
    System.out.println("  Args: " + event.getArgs().size() + " arguments");
});

// Navigate to trigger console events
driver.get("https://example.com");
driver.executeScript("console.log('Hello from JavaScript!');");
driver.executeScript("console.warn('Warning message');");
driver.executeScript("console.error('Error message');");

/**
 * Add JavaScript exception listener (inherited from Events base class)
 * @param listener Consumer to handle JavaScript exceptions
 */
public void addJavascriptExceptionListener(Consumer<JavascriptException> listener);

import org.openqa.selenium.JavascriptException;

// Listen to JavaScript exceptions
events.addJavascriptExceptionListener(exception -> {
    System.err.println("JavaScript Exception: " + exception.getMessage());
    
    // Print stack trace
    for (StackTraceElement element : exception.getStackTrace()) {
        System.err.println("  at " + element.getClassName() + "." + 
                          element.getMethodName() + 
                          "(" + element.getFileName() + ":" + 
                          element.getLineNumber() + ")");
    }
});

// Execute JavaScript that throws an exception
driver.executeScript("throw new Error('Something went wrong!');");

/**
 * Disable event listening (inherited from Events base class)
 * Stops runtime domain and clears all listeners
 */
public void disable();

// Events are automatically enabled when listeners are added
events.addConsoleListener(event -> { /* handle */ });

// Manually disable when done
events.disable();

// CDP ConsoleAPICalled -> ConsoleEvent conversion includes:
// - Timestamp conversion from CDP Timestamp to Java Instant
// - Argument conversion from CDP RemoteObject to idealized RemoteObject  
// - Type string preservation (log, warn, error, info, debug, etc.)
// - Message extraction and formatting

// CDP ExceptionThrown -> JavascriptException conversion includes:
// - Message extraction from exception details or remote object description
// - Stack trace construction from CDP CallFrame information
// - Line number and URL preservation
// - Function name mapping when available
// - Fallback stack trace element creation for incomplete data

// Fallback stack trace creation
StackTraceElement element = new StackTraceElement(
    "unknown",                              // className
    "unknown",                              // methodName  
    details.getUrl().orElse("unknown"),     // fileName
    details.getLineNumber()                 // lineNumber
);

// Safe timestamp conversion with current time fallback
private long fromCdpTimestamp(Timestamp timestamp) {
    try {
        return Long.parseLong(timestamp.toString());
    } catch (NumberFormatException e) {
        return System.currentTimeMillis();
    }
}