Automating performance analysis with YSlow and PhantomJS

Exclusive offer: get 50% off this eBook here
PhantomJS Cookbook

PhantomJS Cookbook — Save 50%

Over 70 recipes to help boost the productivity of your applications using real-world testing with PhantomJS with this book and ebook

$25.99    $13.00
by Rob Friesel | June 2014 | Cookbooks Open Source Web Development

This article by Rob Friesel, author of the PhantomJS Cookbook, demonstrates how to set up an automated performance analysis task on a continuous integration server (for example, Jenkins CI) using PhantomJS and the YSlow library.

(For more resources related to this topic, see here.)

Getting ready

To run this article, the phantomjs binary will need to be accessible to the continuous integration server, which may not necessarily share the same permissions or PATH as our user. We will also need a target URL.

We will use the PhantomJS port of the YSlow library to execute the performance analysis on our target web page. The YSlow library must be installed somewhere on the filesystem that is accessible to the continuous integration server. For our example, we have placed the yslow.js script in the tmp directory of the jenkins user's home directory.

To find the jenkins user's home directory on a POSIX-compatible system, first switch to that user using the following command:

sudo su - jenkins

Then print the home directory to the console using the following command:

echo $HOME

We will need to have a continuous integration server set up where we can configure the jobs that will execute our automated performance analyses. The example that follows will use the open source Jenkins CI server.

Jenkins CI is too large a subject to introduce here, but this article does not assume any working knowledge of it. For information about Jenkins CI, including basic installation or usage instructions, or to obtain a copy for your platform, visit the project website at http://jenkins-ci.org/.

Our article uses version 1.552.

The combination of PhantomJS and YSlow is in no way unique to Jenkins CI. The example aims to provide a clear illustration of automated performance testing that can easily be adapted to any number of continuous integration server environments.

The article also uses several plugins on Jenkins CI to help facilitate our automated testing. These plugins include:

  • Environment Injector Plugin

  • JUnit Attachments Plugin

  • TAP Plugin

  • xUnit Plugin

To run that demo site, we must have Node.js installed. In a separate terminal, change to the phantomjs-sandbox directory (in the sample code's directory), and start the app with the following command:

node app.js

How to do it…

To execute our automated performance analyses in Jenkins CI, the first thing that we need to do is set up the job as follows:

  1. Select the New Item link in Jenkins CI. Give the new job a name (for example, YSlow Performance Analysis), select Build a free-style software project, and then click on OK.

  2. To ensure that the performance analyses are automated, we enter a Build Trigger for the job. Check off the appropriate Build Trigger and enter details about it. For example, to run the tests every two hours, during business hours, Monday through Friday, check Build periodically and enter the Schedule as H 9-16/2 * * 1-5.

  3. In the Build block, click on Add build step and then click on Execute shell. In the Command text area of the Execute Shell block, enter the shell commands that we would normally type at the command line, for example:

    phantomjs ${HOME}/tmp/yslow.js -i grade -threshold "B" -f junit
    http ://localhost:3000/css-demo > yslow.xml

  4. In the Post-build Actions block, click on Add post-build action and then click on Publish JUnit test result report. In the Test report XMLs field of the Publish JUnit Test Result Report block, enter *.xml.

  5. Lastly, click on Save to persist the changes to this job.

Our performance analysis job should now run automatically according to the specified schedule; however, we can always trigger it manually by navigating to the job in Jenkins CI and clicking on Build Now. After a few of the performance analyses have completed, we can navigate to those jobs in Jenkins CI and see the results shown in the following screenshots:

The landing page for a performance analysis project in Jenkins CI

Note the Test Result Trend graph with the successes and failures.

The Test Result report page for a specific build

Note that the failed tests in the overall analysis are called out and that we can expand specific items to view their details.

The All Tests view of the Test Result report page for a specific build

Note that all tests in the performance analysis are listed here, regardless of whether they passed or failed, and that we can click into a specific test to view its details.

How it works…

The driving principle behind this article is that we want our continuous integration server to periodically and automatically execute the YSlow analyses for us so that we can monitor our website's performance over time. This way, we can see whether our changes are having an effect on overall site performance, receive alerts when performance declines, or even fail builds if we fall below our performance threshold.

The first thing that we do in this article is set up the build job. In our example, we set up a new job that was dedicated to the YSlow performance analysis task. However, these steps could be adapted such that the performance analysis task is added onto an existing multipurpose job.

Next, we configured when our job will run, adding Build Trigger to run the analyses according to a schedule. For our schedule, we selected H 9-16/2 * * 1-5, which runs the analyses every two hours, during business hours, on weekdays.

While the schedule that we used is fine for demonstration purposes, we should carefully consider the needs of our project—chances are that a different Build Trigger will be more appropriate. For example, it may make more sense to select Build after other projects are built, and to have the performance analyses run only after the new code has been committed, built, and deployed to the appropriate QA or staging environment. Another alternative would be to select Poll SCM and to have the performance analyses run only after Jenkins CI detects new changes in source control.

With the schedule configured, we can apply the shell commands necessary for the performance analyses. As noted earlier, the Command text area accepts the text that we would normally type on the command line. Here we type the following:

  • phantomjs: This is for the PhantomJS executable binary

  • ${HOME}/tmp/yslow.js: This is to refer to the copy of the YSlow library accessible to the Jenkins CI user

  • -i grade: This is to indicate that we want the "Grade" level of report detail

  • -threshold "B": This is to indicate that we want to fail builds with an overall grade of "B" or below

  • -f junit: This is to indicate that we want the results output in the JUnit format

  • http://localhost:3000/css-demo: This is typed in as our target URL

  • > yslow.xml: This is to redirect the JUnit-formatted output to that file on the disk

What if PhantomJS isn't on the PATH for the Jenkins CI user? A relatively common problem that we may experience is that, although we have permission on Jenkins CI to set up new build jobs, we are not the server administrator. It is likely that PhantomJS is available on the same machine where Jenkins CI is running, but the jenkins user simply does not have the phantomjs binary on its PATH. In these cases, we should work with the person administering the Jenkins CI server to learn its path. Once we have the PhantomJS path, we can do the following: click on Add build step and then on Inject environment variables; drag-and-drop the Inject environment variables block to ensure that it is above our Execute shell block; in the Properties Content text area, apply the PhantomJS binary's path to the PATH variable, as we would in any other script as follows:

PATH=/path/to/phantomjs/bin:${PATH}

After setting the shell commands to execute, we jump into the Post-build Actions block and instruct Jenkins CI where it can find the JUnit XML reports. As our shell command is redirecting the output into a file that is directly in the workspace, it is sufficient to enter an unqualified *.xml here.

Once we have saved our build job in Jenkins CI, the performance analyses can begin right away! If we are impatient for our first round of results, we can click on Build Now for our job and watch as it executes the initial performance analysis.

As the performance analyses are run, Jenkins CI will accumulate the results on the filesystem, keeping them until they are either manually removed or until a discard policy removes old build information. We can browse these accumulated jobs in the web UI for Jenkins CI, clicking on the Test Result link to drill into them.

There's more…

The first thing that bears expanding upon is that we should be thoughtful about what we use as the target URL for our performance analysis job. The YSlow library expects a single target URL, and as such, it is not prepared to handle a performance analysis job that is otherwise configured to target two or more URLs. As such, we must select a strategy to compensate for this, for example:

  • Pick a representative page: We could manually go through our site and select the single page that we feel best represents the site as a whole. For example, we could pick the page that is "most average" compared to the other pages ("most will perform at about this level"), or the page that is most likely to be the "worst performing" page ("most pages will perform better than this"). With our representative page selected, we can then extrapolate performance for other pages from this specimen.

  • Pick a critical page: We could manually select the single page that is most sensitive to performance. For example, we could pick our site's landing page (for example, "it is critical to optimize performance for first-time visitors"), or a product demo page (for example, "this is where conversions happen, so this is where performance needs to be best"). Again, with our performance-sensitive page selected, we can optimize the general cases around the specific one.

  • Set up multiple performance analysis jobs: If we are not content to extrapolate site performance from a single specimen page, then we could set up multiple performance analysis jobs—one for each page on the site that we want to test. In this way, we could (conceivably) set up an exhaustive performance analysis suite. Unfortunately, the results will not roll up into one; however, once our site is properly tuned, we need to only look for the telltale red ball of a failed build in Jenkins CI.

The second point worth considering is—where do we point PhantomJS and YSlow for the performance analysis? And how does the target URL's environment affect our interpretation of the results? If we are comfortable running our performance analysis against our production deploys, then there is not much else to discuss—we are assessing exactly what needs to be assessed. But if we are analyzing performance in production, then it's already too late—the slow code has already been deployed! If we have a QA or staging environment available to us, then this is potentially better; we can deploy new code to one of these environments for integration and performance testing before putting it in front of the customers. However, these environments are likely to be different from production despite our best efforts. For example, though we may be "doing everything else right", perhaps our staging server causes all traffic to come back from a single hostname, and thus, we cannot properly mimic a CDN, nor can we use cookie-free domains. Do we lower our threshold grade? Do we deactivate or ignore these rules? How can we tell apart the false negatives from the real warnings? We should put some careful thought into this—but don't be disheartened—better to have results that are slightly off than to have no results at all!

Using TAP format

If JUnit formatted results turn out to be unacceptable, there is also a TAP plugin for Jenkins CI. Test Anything Protocol (TAP) is a plain text-based report format that is relatively easy for both humans and machines to read. With the TAP plugin installed in Jenkins CI, we can easily configure our performance analysis job to use it. We would just make the following changes to our build job:

  1. In the Command text area of our Execute shell block, we would enter the following command:

    phantomjs ${HOME}/tmp/yslow.js -i grade -threshold "B" -f tap
    http ://localhost:3000/css-demo > yslow.tap

  2. In the Post-build Actions block, we would select Publish TAP Results instead of Publish JUnit test result report and enter yslow.tap in the Test results text field.

  3. Everything else about using TAP instead of JUnit-formatted results here is basically the same. The job will still run on the schedule we specify, Jenkins CI will still accumulate test results for comparison, and we can still explore the details of an individual test's outcomes. The TAP plugin adds an additional link in the job for us, TAP Extended Test Results, as shown in the following screenshot:

    One thing worth pointing out about using TAP results is that it is much easier to set up a single job to test multiple target URLs within a single website. We can enter multiple tests in the Execute Shell block (separating them with the && operator) and then set our Test Results target to be *.tap. This will conveniently combine the results of all our performance analyses into one.

Summary

In this article, we saw setting up of an automated performance analysis task on a continuous integration server (for example, Jenkins CI) using PhantomJS and the YSlow library.

Resources for Article:


Further resources on this subject:


PhantomJS Cookbook Over 70 recipes to help boost the productivity of your applications using real-world testing with PhantomJS with this book and ebook
Published: June 2014
eBook Price: $25.99
Book Price: $41.99
See more
Select your format and quantity:

About the Author :


Rob Friesel

Rob Friesel is a senior user interface developer and 10-year veteran at Dealer.com, where he develops UI frameworks and toolkits for their enterprise platform. He blogs about and presents on a variety of technologies, but his first love is the front-end. He has contributed as a credited reviewer to several books on JavaScript and one on Clojure. He tweets at @founddramaand blogs at http://blog.founddrama.net/.

Books From Packt


Getting Started with PhantomJS
Getting Started with PhantomJS

Ext JS 4 Plugin and Extension Development
Ext JS 4 Plugin and Extension Development

Instant Zepto.js [Instant]
Instant Zepto.js [Instant]

Ext JS 4 First Look
Ext JS 4 First Look

Node.js Blueprints
Node.js Blueprints

Instant Node.js Starter [Instant]
Instant Node.js Starter [Instant]

 Instant Testing with CasperJS [Instant]
Instant Testing with CasperJS [Instant]

 Instant IntroJs [Instant]
Instant IntroJs [Instant]


Code Download and Errata
Packt Anytime, Anywhere
Register Books
Print Upgrades
eBook Downloads
Video Support
Contact Us
Awards Voting Nominations Previous Winners
Judges Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software
Resources
Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software