How to Debug Selenium Tests using Telemetry Logs

The application development industry has revolutionized a lot with the integration of various new technologies. For instance, in the modern generation, application developers can use test automation to automatically conduct multiple test instances at the same time. It is also possible to integrate various modern technologies like continuous integration and continuous development to further improve the coordination between the application development and testing teams. While implementing automation testing, the app developers must be aware of various bugs and errors that might arise in the core framework of the application. Regression testing is another important parameter that helps application developers to ensure that frequent updates do not break the functioning of the app.

So, with this article, we are going to understand how application developers can debug their Selenium test cases using telemetry logs. We will also discuss some of the best practices that can allow app developers to utilize the full potential of Selenium testing.

Exploring Selenium and Automation Testing

Modern applications consist of thousands of different elements that need to be verified individually and also as a combined interface. So, it is almost impossible to conduct these processes with manual testing as it will take several months to complete. On the other hand, automation testing can help developers to complete all of these processes within a few days. In this process, the system will utilize a text file for supplying the required data to emulate human interactions. Based on these communications, the system will generate a detailed test report showing the usability and user interactivity of the application undergoing the development process.

Whenever we are on the topic of automation testing, Selenium is one of the most common names that come into our minds. This is because while using Selenium, the application developers can initiate automation testing on web applications. Selenium is a test suite that is open source and has multiple tools for initiating automation tests on web apps. JavaScript is the principal programming language that drives the complete infrastructure of Selenium. Now let us understand some of the primary tools present under the Selenium test suit:

• The Selenium WebDriver is the most important component in the suit as it allows the application developers to run the test cases on a specific element of the web app. This tool is also useful for executing the test cases in the native environment of the browser. Moreover for completing all of these functions, WebDriver does not require a dedicated test engine.

• The Selenium IDE is useful for initiating and executing codeless automation testing on web applications. Using this tool, the app developers can interact with the application to generate automated test cases in real-time.

• In case the app development project requires the manual creation of automation test scripts, the Selenium client API will be useful for this purpose. Using this tool, the app developers can choose any of their preferred programming languages like Python, Ruby, and JavaScript for creating the automation test scripts.

• Finally, the Selenium Grid focuses on improving the efficiency of the automation test cases with the integration of parallel test execution. This modern testing feature can initiate multiple test instances on different configurations and machines at the same time using the concept of a hub communicating with multiple nodes represented by web elements.

Need for Test Debugging and Regression Testing

The modern application infrastructure is very complex and unstable in certain instances. So, the app developers have to focus on the test debugging and troubleshooting process to ensure that all the elements are working correctly. This process becomes even more important when the application developers are working with apps that undergo frequent updates. This is because, in such applications, the new elements often break the functioning of the existing elements. The efficient way to eliminate such instances is the integration of regression testing. The App developers can further improve the efficiency of regression testing with the integration of automation testing.

Exploring LambdaTest

LambdaTest is a cloud-based platform for executing automation testing on web applications. While using LambdaTest, the application developers can run the selenium test cases on thousands of different browser instances at the same time.  Using this platform, app developers can generate highly accurate test cases by integrating multiple instances from real devices, emulators, and simulators. Using LambdaTest, the app developers can execute parallel test execution through a standalone mode. This mode will connect to the Selenium server where all the tests are executed in the form of multiple requests.

For tracing this request, the developers can use Selenium 4 and open telemetry integration. The benefit of this process is that it provides greater visibility for tracing the requests and all the event logs for each request. So the app developers can monitor a request life cycle and store important data about multiple critical operations. This information also allows the app developers to identify issues and optimize the performance of the app.

Let us now understand how the LambdaTest real device cloud benefits Selenium testing:

• Using this platform, it is possible to run automation test cases on more than 3000+ real devices and browsers at the same time.

• LambdaTest provides stable support for legacy devices and older versions of modern browsers. So, the application developers can improve the compatibility of their applications using these instances.

• It is possible to integrate telemetry logs with LambdaTest real device cloud for debugging and troubleshooting the Selenium test cases.

• After the execution of the testing process, LambdaTest generates highly intuitive and simple test reports. It also integrates multiple screenshots, videos (editing videos), and test logs to improve the bug detection and highlighting process.

• LambdaTest also supports the integration of various modern technologies like Agile Methodologies, various plugins, tools, and dependencies for improving the efficiency and quality of the application.

Debugging Selenium Tests Using Telemetry Logs

For debugging Selenium testing with telemetry logs, the application developers have to follow a simple step and certain prerequisites. So, for the simplicity of the new developers and testers, we have noted down all the steps in chronological order:

1. At first, the app developers have to sign up for a new LambdaTest account. For this, they have to navigate to the official website of LambdaTest and follow the on-screen instructions. They also have to purchase a LambdaTest license as it will grant access to the application testing cloud. The access key and login credentials will be available in the account details of the user. The following code will configure the Telemetry logs with LambdaTest:

import json

from selenium import webdriver

from selenium.webdriver.common.desired_capabilities import DesiredCapabilities

USERNAME = “your_username”

ACCESS_KEY = “your_access_key”

desired_caps = {

    “build”: “Telemetry Logs Example”,

    “name”: “telemetry-test”,

    “platform”: “Windows 10”,

    “browserName”: “Chrome”,

    “version”: “latest”,

    “tunnel”: False,

    “visual”: False,

    “network”: False,

    “console”: False,

    “video”: False,

    “console”: False,

    “telemetry”: True,  # Enable telemetry logs

}

driver = webdriver.Remote(

    command_executor=f”https://{USERNAME}:{ACCESS_KEY}@hub.lambdatest.com/wd/hub”,

    desired_capabilities=desired_caps,

)

driver.get(“https://www.example.com”)

# Perform your test actions here

# Close the browser

driver.quit()

1. The next step in this process is to enable the telemetry logs. This is because the telemetry logs are by default disabled in the Selenium automation. To start this process, you will have to enter the following code in the test interface. You must remember to specify your Selenium version for initiating the test cases.

caps.setCapability(“seTelemetryLogs”, true);

caps.setCapability(“selenium_version”, “4.2.0”);

1. Now, the application developers have to use a 3rd party system for accessing and monitoring the telemetry logs. We would suggest the app developers use Jaeger. This is because Jaeger is an open-source test monitoring system that is distributed as an end-to-end system. So the app developers can easily download this tool from the official website, extract the compressed file, and it will be available in the test script directory of the application testing process.
2. After this, the app developers will have to access and download the telemetry logs of the current test session. These logs will be available in the telemetry logs under the LambdaTest automation dashboard.
3. Now, it is time for the application developers to initiate the Jaeger user interface for visualizing the telemetry logs using the command ‘ jaeger-all-in-one’.
4. The final step in this process is for the application developers to access the local host and upload the downloaded telemetry logs from the LambdaTest automation dashboard. After the app developers have finished all the above setup processes, they will be able to access and monitor the request traces using the Jaeger user interface for all the LambdaTest sessions that will be used for executing Selenium testing.

1. While implementing Selenium debugging using telemetry logs, the application developers can also implement certain practices like cross-referencing with existing test data, isolating faulty elements, and maintaining real-time test logs. After debugging the faulty element of the application, the developer should also re-run the test cases to ensure that the app is free of all errors and is ready to be forwarded to the production process.

A very useful tip for the app developer would be to disable the telemetry logs after completing the debugging. This is because all the logs there are generated during the testing process are usually resource intensive and might harm the test case execution process. In certain cases, these logs often end up slowing the system or completely crashing them.

Finally, we would request the application developers to go through the official documentation of LambdaTest, Jaeger, and Selenium so that they can have a clear idea about all the features that are explained through various sample test cases. Selenium and LambdaTest also provide information about some other common issues that can arise during the test case execution process. So this information will be beneficial when the app developers face these issues during their testing cycle.

Although the telemetry logs provide vital information about debugging Selenium test cases, it requires certain information and experience to understand this data. Familiarity with target browsers and devices can also help the developers interpret the telemetry logs. Finally, this process will vary slightly depending on the chosen programming language.

The Conclusion

The primary motive of this article was to guide the new application testers and developers through the process of debugging advanced Selenium tests with telemetry logs. We also understood how app developers can improve the quality of the application by integrating modern technologies like test automation and regression testing. It is very important to constantly update the information regarding all the new additions and innovations in the segment. This idea will help to improve the app and further create a positive brand image for maintaining its position in this market. Lastly, the app developer should gather adequate data about the requirements of the target users to accordingly customize the app.