Logging is the process of recording important information about the execution of an application or automated test. In Selenium automation, logging helps testers understand what happened during test execution, identify the step where a failure occurred, troubleshoot errors, monitor browser actions, and maintain useful execution history.
In a Selenium TestNG framework, logs can record events such as opening the browser, launching the application, entering test data, clicking buttons, navigating between pages, performing validations, passing a test, failing a test, and closing the browser.
A well-designed logging mechanism makes an automation framework easier to debug, maintain, monitor, and support, especially when a large number of tests are executed through Maven, CI/CD pipelines, Jenkins, or other automation environments.
Course Resource: Selenium Training | Register for Course Demo
Logging is the practice of recording messages about the execution of a program or test. These messages provide information about what the application or automation script is doing at different stages.
For example, during a Selenium login test, useful logs may include:
When a test fails, the logs can help identify the last successful step and provide context around the failure.
Logging is especially important in Selenium automation because automated tests may execute many browser interactions without continuous human observation.
Test Execution
|
v
Test Method Starts
|
v
Log Test Start
|
v
Open Browser
|
v
Log Browser Information
|
v
Open Application
|
v
Log Application Navigation
|
v
Perform Selenium Actions
|
v
Log Important Steps
|
v
Validate Expected Result
|
+------------------+
| |
v v
PASS FAIL
| |
v v
Log PASS Log ERROR
| |
+--------+---------+
|
v
Test Report
|
v
Log File
Logging and reporting are related but they serve different purposes.
| Feature | Logging | Reporting |
|---|---|---|
| Main Purpose | Record execution details | Present test execution results |
| Focus | Events and diagnostic information | Pass, fail, skip and execution summary |
| Typical Output | Console or log file | HTML, XML or other report |
| Debugging | Very useful | Useful for result analysis |
| Detailed Steps | Can contain detailed steps | Usually contains summarized results |
| Failure Information | Can record detailed context | Usually displays failure status and details |
Logging frameworks generally provide different levels so that users can control how much information is recorded.
Common levels include:
| Level | Purpose | Typical Example |
|---|---|---|
| TRACE | Very detailed execution information | Low-level diagnostic information |
| DEBUG | Detailed debugging information | Element interaction details |
| INFO | Normal execution information | Application opened |
| WARN | Potential issue or unexpected condition | Optional element unavailable |
| ERROR | An error occurred | Login action failed |
| FATAL | Critical failure | Framework cannot continue |
The exact levels available depend on the logging framework being used.
INFO logging is commonly used for normal and meaningful test execution events.
logger.info("Opening application");
logger.info("Entering username");
logger.info("Clicking login button");
logger.info("Login validation completed");
INFO messages should describe important milestones rather than every minor internal operation.
DEBUG logging is useful when more detailed information is required to diagnose a problem.
logger.debug("Username field located");
logger.debug("Username value entered");
logger.debug("Login button located");
logger.debug("Current URL: " + driver.getCurrentUrl());
Debug logging is especially useful during framework development and troubleshooting.
WARN indicates that something unexpected happened but the test may still be able to continue.
logger.warn("Optional banner was not displayed");
logger.warn("Search result count is lower than expected");
Warnings should not be used for every minor event. They should indicate conditions that deserve attention.
ERROR logging is used when an operation fails or an exception occurs.
logger.error("Login operation failed");
logger.error("Unable to locate username field");
In real frameworks, exception information should also be captured when appropriate.
Java provides a built-in logging API through the java.util.logging package. Selenium Java projects can also use third-party logging frameworks such as Log4j2 or SLF4J with an appropriate logging implementation.
A simple Java logger can be created as follows:
import java.util.logging.Logger;
public class LoginTest {
private static final Logger logger =
Logger.getLogger(LoginTest.class.getName());
public void executeTest() {
logger.info("Starting login test");
}
}
import java.util.logging.Logger;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class SeleniumLoggingExample {
private static final Logger logger =
Logger.getLogger(SeleniumLoggingExample.class.getName());
public void openApplication() {
logger.info("Starting browser");
WebDriver driver = new ChromeDriver();
logger.info("Browser started successfully");
driver.get("https://example.com");
logger.info("Application opened");
driver.quit();
logger.info("Browser closed");
}
}
Logging can be integrated with TestNG test methods and configuration methods.
import java.util.logging.Logger;
import org.testng.annotations.Test;
public class LoginTest {
private static final Logger logger =
Logger.getLogger(LoginTest.class.getName());
@Test
public void loginTest() {
logger.info("Login test started");
logger.info("Opening login page");
logger.info("Entering username");
logger.info("Entering password");
logger.info("Clicking login button");
logger.info("Login test completed");
}
}
TestNG configuration methods are useful locations for logging browser setup and cleanup activities.
import java.util.logging.Logger;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
public class LoginTest {
private static final Logger logger =
Logger.getLogger(LoginTest.class.getName());
@BeforeMethod
public void setup() {
logger.info("Starting test setup");
logger.info("Launching browser");
}
@Test
public void loginTest() {
logger.info("Executing login test");
}
@AfterMethod
public void tearDown() {
logger.info("Starting test cleanup");
logger.info("Closing browser");
}
}
Important WebDriver actions should be logged at meaningful points in the test.
logger.info("Opening login page");
driver.get("https://example.com/login");
logger.info("Entering username");
driver.findElement(By.id("username")).sendKeys("admin");
logger.info("Entering password");
driver.findElement(By.id("password")).sendKeys("admin123");
logger.info("Clicking login button");
driver.findElement(By.id("loginButton")).click();
Logging every single WebDriver operation may create excessive logs. It is generally better to log meaningful business or test steps.
A useful automation framework records when an important test starts and when it finishes.
logger.info("=================================");
logger.info("Login Test Started");
logger.info("Executing login workflow");
logger.info("Login Test Completed");
logger.info("=================================");
Test data can be logged when it helps identify the test execution, but sensitive information should not be exposed.
logger.info("Executing login for user: " + username);Avoid logging passwords, authentication tokens, API keys, session cookies, or other secrets.
// Avoid
logger.info("Password: " + password);
// Better
logger.info("Login password supplied securely for user: " + username);
When debugging navigation problems, recording the current URL can be useful.
logger.info("Current URL: " + driver.getCurrentUrl());This can help identify unexpected redirects, navigation failures, or incorrect application environments.
The current page title can also be recorded.
logger.info("Current page title: " + driver.getTitle());This is particularly useful when validating that the expected page has been opened.
Browser information can be useful when tests are executed across multiple browsers.
logger.info("Starting Chrome browser");
logger.info("Executing login test on Chrome");
For a larger framework, browser information can be captured from configuration or driver capabilities.
Exceptions should be logged with enough context to understand what operation failed.
try {
driver.findElement(By.id("loginButton")).click();
logger.info("Login button clicked successfully");
} catch (Exception e) {
logger.severe("Unable to click login button: " + e.getMessage());
throw e;
}
Re-throwing the exception after logging allows the test framework to correctly identify the test as failed.
try {
logger.info("Opening application");
driver.get("https://example.com");
logger.info("Application opened successfully");
} catch (Exception e) {
logger.severe(
"Application opening failed: " + e.getMessage()
);
throw e;
}
Important element interactions can be recorded before or after the action.
logger.info("Locating username field");
WebElement usernameField =
driver.findElement(By.id("username"));
logger.info("Entering username");
usernameField.sendKeys(username);
logger.info("Username entered successfully");
Assertions can also be surrounded by meaningful log messages.
logger.info("Validating dashboard title");
Assert.assertTrue(
driver.getTitle().contains("Dashboard")
);
logger.info("Dashboard title validation passed");
For failed assertions, the test framework will normally provide failure information, while logging provides additional context around what was being validated.
When a test fails, the log should help answer three questions:
logger.info("Starting login validation");
logger.info("Clicking login button");
try {
driver.findElement(By.id("loginButton")).click();
} catch (Exception e) {
logger.severe(
"Login button click failed: " + e.getMessage()
);
throw e;
}
Logging and screenshots can work together. When an important failure occurs, a framework can capture a screenshot and log its location.
String screenshotPath =
"screenshots/login_failure.png";
logger.severe(
"Login test failed. Screenshot saved at: "
+ screenshotPath
);
The actual screenshot capture is normally implemented through a reusable utility or TestNG listener.
A framework can maintain meaningful status messages for successful and unsuccessful executions.
logger.info("TEST STARTED: Login Test");
logger.info("STEP: Open login page");
logger.info("STEP: Enter username");
logger.info("STEP: Enter password");
logger.info("STEP: Click login");
logger.info("STEP: Validate dashboard");
logger.info("TEST PASSED: Login Test");
Console logging displays messages directly in the IDE or terminal during test execution.
logger.info("Starting Selenium test");
logger.info("Opening application");
logger.info("Test execution completed");
Console logs are useful during local development because the tester can immediately observe execution progress.
For larger frameworks, logs are often stored in files so they can be reviewed after execution.
Java's built-in logging API can use a file handler:
import java.io.IOException;
import java.util.logging.FileHandler;
import java.util.logging.Logger;
public class FileLoggingExample {
private static final Logger logger =
Logger.getLogger(FileLoggingExample.class.getName());
public static void main(String[] args)
throws IOException {
FileHandler handler =
new FileHandler("automation.log");
logger.addHandler(handler);
logger.info("Automation execution started");
}
}
A simple log file might contain entries such as:
INFO: Automation execution started
INFO: Browser launched
INFO: Application opened
INFO: Login page displayed
INFO: Username entered
INFO: Password entered
INFO: Login button clicked
INFO: Dashboard validation started
INFO: Dashboard validation passed
INFO: Browser closed
INFO: Test completed
Log4j2 is a commonly used logging framework in Java applications and automation frameworks. It provides configurable log levels, appenders, formatting, file output, console output, and other logging capabilities.
A typical Selenium framework can use Log4j2 to centralize logging instead of creating logging configuration independently inside every test class.
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
public class LoginTest {
private static final Logger logger =
LogManager.getLogger(LoginTest.class);
public void login() {
logger.info("Login test started");
logger.debug("Opening login page");
logger.info("Entering username");
logger.info("Clicking login button");
logger.info("Login test completed");
}
}
A logging framework normally has two important parts:
Common destinations include:
SLF4J provides a logging abstraction that allows application code to work with a consistent logging API while the underlying logging implementation can be configured separately.
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class LoginTest {
private static final Logger logger =
LoggerFactory.getLogger(LoginTest.class);
public void loginTest() {
logger.info("Login test started");
logger.debug("Preparing login data");
logger.info("Login test completed");
}
}
Logging works very well with the Page Object Model. Page classes can log important actions while test classes focus on business scenarios and validations.
public class LoginPage {
private WebDriver driver;
private By username =
By.id("username");
private By password =
By.id("password");
private By loginButton =
By.id("loginButton");
private static final Logger logger =
Logger.getLogger(LoginPage.class.getName());
public LoginPage(WebDriver driver) {
this.driver = driver;
}
public void login(String user, String pass) {
logger.info("Entering username");
driver.findElement(username).sendKeys(user);
logger.info("Entering password");
driver.findElement(password).sendKeys(pass);
logger.info("Clicking login button");
driver.findElement(loginButton).click();
}
}
Reusable utility classes can also use logging.
public class ScreenshotUtility {
private static final Logger logger =
Logger.getLogger(
ScreenshotUtility.class.getName()
);
public static void saveScreenshot() {
logger.info("Capturing screenshot");
}
}
This makes framework-level operations easier to trace.
A Driver Factory is responsible for creating WebDriver instances. Logging can record browser initialization.
public class DriverFactory {
private static final Logger logger =
Logger.getLogger(DriverFactory.class.getName());
public static WebDriver createDriver(
String browser) {
logger.info(
"Creating WebDriver for: " + browser
);
if (browser.equalsIgnoreCase("chrome")) {
return new ChromeDriver();
}
if (browser.equalsIgnoreCase("firefox")) {
return new FirefoxDriver();
}
throw new IllegalArgumentException(
"Unsupported browser: " + browser
);
}
}
When TestNG Data Providers execute the same test with multiple data sets, logging can help identify which data set is currently being processed.
@DataProvider(name = "users")
public Object[][] users() {
return new Object[][] {
{"admin"},
{"manager"},
{"employee"}
};
}
@Test(dataProvider = "users")
public void loginTest(String username) {
logger.info(
"Executing login test for user: " + username
);
}
Sensitive values such as passwords should not be written into logs.
When tests execute in parallel, logs should contain enough information to identify the test or thread that generated the message.
logger.info(
"Thread: "
+ Thread.currentThread().getId()
+ " - Login test started"
);
This becomes particularly useful when several browser sessions are running at the same time.
TestNG listeners can be used to observe test execution events such as test start, success, failure, and skip events.
A listener can centralize logging instead of adding the same status-handling code to every test class.
import org.testng.ITestListener;
import org.testng.ITestResult;
public class TestListener implements ITestListener {
@Override
public void onTestStart(ITestResult result) {
System.out.println(
"TEST STARTED: "
+ result.getName()
);
}
@Override
public void onTestSuccess(ITestResult result) {
System.out.println(
"TEST PASSED: "
+ result.getName()
);
}
@Override
public void onTestFailure(ITestResult result) {
System.out.println(
"TEST FAILED: "
+ result.getName()
);
}
@Override
public void onTestSkipped(ITestResult result) {
System.out.println(
"TEST SKIPPED: "
+ result.getName()
);
}
}
A listener can be registered using the @Listeners annotation.
import org.testng.annotations.Listeners;
@Listeners(TestListener.class)
public class LoginTest {
@Test
public void loginTest() {
System.out.println("Executing login test");
}
}
public class TestListener
implements ITestListener {
@Override
public void onTestStart(ITestResult result) {
System.out.println(
"Starting: " + result.getName()
);
}
@Override
public void onTestSuccess(ITestResult result) {
System.out.println(
"Passed: " + result.getName()
);
}
@Override
public void onTestFailure(ITestResult result) {
System.out.println(
"Failed: " + result.getName()
);
}
}
Listeners can also access exceptions associated with failed tests.
@Override
public void onTestFailure(ITestResult result) {
Throwable error =
result.getThrowable();
System.out.println(
"Test failed: " + result.getName()
);
if (error != null) {
System.out.println(
"Error: " + error.getMessage()
);
}
}
Logging and reporting complement each other. A test report can show the final result while logs provide additional execution details.
Test Report
|
+-- Login Test - PASS
|
+-- Search Test - FAIL
|
+-- Log File
|
+-- Screenshot
|
+-- Exception
|
+-- Current URL
This structure provides multiple sources of information when diagnosing failures.
A professional automation framework can combine a failure listener, screenshot utility, and logger.
@Override
public void onTestFailure(ITestResult result) {
logger.severe(
"Test failed: " + result.getName()
);
logger.severe(
"Capturing failure screenshot"
);
// Screenshot utility can be called here.
}
When many tests are running, recording the test name makes logs easier to analyze.
logger.info(
"Executing test: " + result.getName()
);
Test names are especially useful in CI/CD pipelines where several test classes may execute together.
Environment information can be recorded at the beginning of a test suite.
logger.info("Environment: QA");
logger.info("Browser: Chrome");
logger.info("Application URL: https://qa.example.com");
Environment logging can help determine whether a failure occurred in QA, staging, or another test environment.
logger.info(
"Browser: Chrome | Environment: QA"
);
logger.info(
"Browser: Firefox | Environment: Stage"
);
This is useful when the same test suite runs across multiple browsers and environments.
logger.info("Starting search test");
logger.info(
"Searching for product: " + searchText
);
driver.findElement(By.id("search"))
.sendKeys(searchText);
logger.info("Clicking search button");
driver.findElement(By.id("searchButton"))
.click();
logger.info("Search results displayed");
logger.info("Opening product page");
logger.info("Selecting product");
logger.info("Adding product to cart");
logger.info("Opening cart");
logger.info("Proceeding to checkout");
logger.info("Selecting payment method");
logger.info("Submitting order");
logger.info("Validating order confirmation");
These business-level logs make a long workflow easier to understand.
In hybrid automation frameworks, logging can be used for both API and UI actions.
logger.info("Sending API request");
logger.info("Validating API response");
logger.info("Opening browser");
logger.info("Launching application");
logger.info("Validating UI result");
When Selenium TestNG tests are executed through Maven, console and file logs can help identify build-level and test-level problems.
mvn testA typical execution flow is:
Maven
|
v
TestNG
|
v
Test Classes
|
v
Selenium WebDriver
|
v
Application
|
v
Logs + Reports
CI/CD environments execute tests without continuous manual observation. Logs therefore become especially important for diagnosing failed builds.
Developer Commit
|
v
CI/CD Pipeline
|
v
Build
|
v
Maven Test
|
v
TestNG
|
v
Selenium Tests
|
v
Logging
|
v
Reports
|
v
Build Result
When Selenium tests execute through Jenkins, logs can help identify failures that occur on the build server but cannot be reproduced immediately on a local machine.
Useful information can include:
Thread information becomes important when TestNG runs tests in parallel.
long threadId =
Thread.currentThread().getId();
logger.info(
"Thread " + threadId
+ " started test execution"
);
Parallel Selenium tests should maintain isolated browser sessions and test data. Logging should also make concurrent execution distinguishable.
Thread 12 -> Chrome -> Login Test
Thread 13 -> Firefox -> Search Test
Thread 14 -> Edge -> Checkout Test
Using thread identifiers, test names, browser names, or other contextual information can make parallel logs easier to understand.
Structured logging means organizing log information in a consistent format so it can be searched and analyzed easily.
TIME | LEVEL | TEST | BROWSER | MESSAGE
10:15 | INFO | LoginTest | Chrome | Test started
10:16 | INFO | LoginTest | Chrome | Login page opened
10:16 | INFO | LoginTest | Chrome | Username entered
10:16 | ERROR | LoginTest | Chrome | Login validation failed
Automation logs should focus on meaningful business actions rather than producing unnecessary low-level noise.
For example:
logger.info("User navigated to checkout");
logger.info("Product added to cart");
logger.info("Shipping information submitted");
logger.info("Payment validation completed");
These messages are generally more useful than logging every internal Java operation.
When an element cannot be located, logging the relevant action can make the problem easier to diagnose.
try {
logger.info("Locating login button");
driver.findElement(
By.id("loginButton")
).click();
} catch (Exception e) {
logger.severe(
"Unable to locate or click login button: "
+ e.getMessage()
);
throw e;
}
Explicit waits can also be associated with meaningful logs.
logger.info("Waiting for dashboard element");
WebDriverWait wait =
new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("dashboard")
)
);
logger.info("Dashboard element is visible");
logger.info("Navigating to login page");
driver.get("https://example.com/login");
logger.info(
"Navigation completed. Current URL: "
+ driver.getCurrentUrl()
);
try {
logger.info("Opening application");
driver.get("https://example.com");
logger.info("Application opened successfully");
} catch (Exception e) {
logger.severe(
"Application navigation failed: "
+ e.getMessage()
);
throw e;
}
Page classes should generally log important user-facing actions rather than exposing unnecessary implementation details.
public void clickLogin() {
logger.info("Clicking Login button");
driver.findElement(loginButton).click();
logger.info("Login button clicked");
}
A Base Test class can centralize common logging configuration and browser lifecycle operations.
public class BaseTest {
protected WebDriver driver;
protected final Logger logger =
Logger.getLogger(
BaseTest.class.getName()
);
@BeforeMethod
public void setup() {
logger.info("Starting browser");
driver = new ChromeDriver();
logger.info("Browser started");
}
@AfterMethod
public void tearDown() {
logger.info("Closing browser");
if (driver != null) {
driver.quit();
}
logger.info("Browser closed");
}
}
A reusable logging utility can provide common logging methods.
public class LogUtility {
private static final Logger logger =
Logger.getLogger(
LogUtility.class.getName()
);
public static void info(String message) {
logger.info(message);
}
public static void warn(String message) {
logger.warning(message);
}
public static void error(String message) {
logger.severe(message);
}
}
Example usage:
LogUtility.info("Opening application");
LogUtility.warn("Optional element not available");
LogUtility.error("Login operation failed");
When a data-driven test fails, the framework should make it possible to identify the data set without exposing sensitive information.
logger.info(
"Executing login test for user: "
+ username
);
For passwords and tokens, log only safe identifiers or masked values when necessary.
Sensitive information should not normally appear in plain text in logs.
String maskedPassword = "********";
logger.info(
"Attempting login for user: "
+ username
);
logger.debug(
"Password supplied: "
+ maskedPassword
);
Never use logs as a place to store secrets.
Common Selenium failures can be accompanied by meaningful log messages.
| Exception | Useful Log Context |
|---|---|
| NoSuchElementException | Element locator and test step |
| TimeoutException | Wait condition and target element |
| ElementClickInterceptedException | Element and click operation |
| StaleElementReferenceException | Element interaction and page state |
| WebDriverException | Browser or driver operation |
try {
logger.info("Waiting for dashboard");
wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("dashboard")
)
);
} catch (TimeoutException e) {
logger.severe(
"Dashboard did not appear within timeout"
);
throw e;
}
try {
logger.info("Locating username field");
driver.findElement(
By.id("username")
).sendKeys(username);
} catch (NoSuchElementException e) {
logger.severe(
"Username field was not found"
);
throw e;
}
| Bad Message | Better Message |
|---|---|
| Started | Login test started |
| Click | Clicking Login button |
| Error | Unable to locate Login button |
| Done | Dashboard validation completed successfully |
| Failed | Login test failed while submitting credentials |
Selenium Test Framework
|
+--------------+--------------+
| | |
v v v
TestNG Page Object Utilities
| | |
+--------------+--------------+
|
v
Logger
|
+-----------+-----------+
| |
v v
Console File
| |
+-----------+-----------+
|
v
Test Analysis
|
+----------+----------+
| |
v v
Reports Debugging
import java.util.logging.Logger;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.Assert;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
public class LoginTest {
private WebDriver driver;
private static final Logger logger =
Logger.getLogger(LoginTest.class.getName());
@BeforeMethod
public void setup() {
logger.info("Starting browser");
driver = new ChromeDriver();
driver.manage().window().maximize();
logger.info("Browser launched successfully");
logger.info("Opening login page");
driver.get("https://example.com/login");
logger.info("Login page opened");
}
@Test
public void loginTest() {
logger.info("Login test started");
logger.info("Entering username");
driver.findElement(
By.id("username")
).sendKeys("admin");
logger.info("Entering password");
driver.findElement(
By.id("password")
).sendKeys("admin123");
logger.info("Clicking login button");
driver.findElement(
By.id("loginButton")
).click();
logger.info("Validating dashboard");
Assert.assertTrue(
driver.getTitle().contains("Dashboard")
);
logger.info("Dashboard validation passed");
logger.info("Login test completed successfully");
}
@AfterMethod
public void tearDown() {
logger.info("Closing browser");
if (driver != null) {
driver.quit();
}
logger.info("Browser closed");
}
}
@Test
public void loginTest() {
logger.info("Login test started");
try {
logger.info("Opening login page");
driver.get(
"https://example.com/login"
);
logger.info("Entering username");
driver.findElement(
By.id("username")
).sendKeys("admin");
logger.info("Entering password");
driver.findElement(
By.id("password")
).sendKeys("admin123");
logger.info("Clicking Login");
driver.findElement(
By.id("loginButton")
).click();
logger.info("Validating dashboard");
Assert.assertTrue(
driver.getTitle().contains("Dashboard")
);
logger.info("Login test passed");
} catch (Exception e) {
logger.severe(
"Login test failed: "
+ e.getMessage()
);
throw e;
}
}
Test Suite Starts
|
v
Log Suite Information
|
v
Create Browser
|
v
Log Browser Information
|
v
Open Application
|
v
Log Navigation
|
v
Execute Page Actions
|
v
Log Important Steps
|
v
Perform Assertions
|
+-------------------+
| |
v v
Success Failure
| |
v v
Log Success Log Error
| |
| Capture Screenshot
| |
+---------+---------+
|
v
Test Report
|
v
Log Archive
A mature Selenium automation framework generally uses logging and reporting together.
| Component | Purpose |
|---|---|
| TestNG | Controls test execution |
| Logger | Records execution information |
| Screenshot Utility | Captures visual evidence |
| Report | Summarizes test results |
| Page Object | Handles page interactions |
| Driver Factory | Creates WebDriver instances |
| CI/CD | Automates test execution |
When a Selenium test fails, a useful debugging sequence is:
Logging is the process of recording important information about test execution, browser actions, application navigation, validations, warnings, and failures.
Logging helps understand test execution, troubleshoot failures, identify failed steps, and analyze automation behavior.
Common levels include TRACE, DEBUG, INFO, WARN, ERROR, and FATAL, depending on the logging framework.
INFO is generally used for normal and meaningful execution events.
DEBUG provides detailed information that is useful during troubleshooting.
ERROR is used when an operation fails or an error occurs.
Yes. Java logging APIs and logging frameworks can write log messages to files.
Log4j2 is a Java logging framework that provides configurable logging capabilities for applications and automation frameworks.
SLF4J is a logging abstraction that provides a common API for application code while allowing a logging implementation to be configured underneath it.
Yes. Logging can be used directly in TestNG test methods and configuration methods, and TestNG listeners can be used for centralized execution-event logging.
A TestNG listener is an interface-based mechanism that allows a framework to react to test execution events such as start, success, failure, and skip.
No. Sensitive credentials should be protected and should not normally be recorded in plain text logs.
Logs can include test names, browser names, and thread information so that concurrent test executions can be distinguished.
Logging records execution details and diagnostic information, while reporting presents test results and execution summaries.
Yes. Page classes can log important page actions while test classes handle test scenarios and assertions.
Yes. Logs are particularly useful for diagnosing automated tests executed on CI/CD servers.
Useful information can include the test name, current action, browser, environment, exception message, current URL, and screenshot location.
Meaningful messages make it easier to understand exactly what happened during test execution.
Excessive logging occurs when unnecessary details are recorded so frequently that the useful information becomes difficult to find.
Use appropriate log levels, meaningful messages, useful execution context, secure handling of sensitive information, and centralized configuration where appropriate.
| Concept | Description |
|---|---|
| Logging | Recording execution information |
| Logger | Component used to create log messages |
| INFO | Normal execution information |
| DEBUG | Detailed troubleshooting information |
| WARN | Potential or unexpected condition |
| ERROR | Failure or error information |
| Appender/Handler | Controls where logs are written |
| Console Log | Displays logs during execution |
| File Log | Stores logs for later analysis |
| TestNG Listener | Captures test execution events |
| Log4j2 | Java logging framework |
| SLF4J | Logging abstraction for Java |
| Screenshot | Visual evidence often captured during failures |
Consider an e-commerce login and checkout workflow. A useful logging sequence could be:
INFO - Test started: CheckoutTest
INFO - Browser: Chrome
INFO - Environment: QA
INFO - Opening application
INFO - Login page displayed
INFO - Entering username
INFO - Submitting login form
INFO - Dashboard displayed
INFO - Searching for product
INFO - Product selected
INFO - Product added to cart
INFO - Opening cart
INFO - Starting checkout
INFO - Shipping information submitted
INFO - Payment page displayed
INFO - Order submitted
INFO - Validating confirmation
INFO - Checkout test passed
INFO - Closing browser
If the checkout fails, the log can instead provide information such as:
INFO - Starting checkout
INFO - Shipping information submitted
INFO - Clicking payment button
ERROR - Payment button could not be clicked
ERROR - Test failed: CheckoutTest
INFO - Capturing failure screenshot
INFO - Browser cleanup started
TestNG Test
|
v
Base Test
|
+-----------+-----------+
| |
v v
Page Objects Utilities
| |
+-----------+-----------+
|
v
Logger
|
+--------+--------+
| |
v v
Console File
| |
+--------+--------+
|
v
Test Analysis
|
+-----------+-----------+
| | |
v v v
Report Screenshot Exception
| | |
+-----------+-----------+
|
v
CI/CD
Logging is an essential part of a professional Selenium automation framework. It records important information about test execution and provides valuable context when tests pass, fail, or behave unexpectedly.
Logging can be implemented using Java's built-in logging API or dedicated logging frameworks such as Log4j2, commonly used through a consistent application logging strategy. Selenium and TestNG actions can be logged at meaningful points throughout the framework.
TestNG listeners can be used to centralize logging for test start, success, failure, and skip events. Logging can also be integrated with Page Object Model, Driver Factory, utilities, Data Providers, screenshots, reports, Maven, Jenkins, and CI/CD pipelines.
A good logging strategy should provide enough information to understand and troubleshoot test execution without creating unnecessary noise or exposing sensitive information.
Logging makes Selenium automation easier to understand, debug, maintain, and monitor. A strong logging implementation records meaningful test steps, browser and environment context, exceptions, failures, and execution status. When combined with TestNG reports, screenshots, Page Object Model, listeners, and CI/CD tools, logging becomes an important part of a scalable Selenium automation framework.
Learn more about Selenium automation and professional testing frameworks:
