Keynote’s Keynote Internet Testing Environment, or KITE, is a desktop application for testing the performance of Web sites. While KITE is aimed primarily at Web application developers, it caught my interest as a tool for measuring the performance of an organization’s current or prospective software-as-a-service-based applications.
I tested KITE Version 2.0, which began shipping in August. I used KITE to create scripts of typical operations with a few Web-based SAAS applications, and then ran those scripts both from my local machine and from a collection of Keynote’s global monitoring sites. I was impressed with the granular performance information the product yielded after a short period of use.
To examine and measure rich application functionality-such as through AJAX-I had to make some script modifications as described in Keynote’s online product documentation.
KITE is freely downloadable, and KITE scripts can be run either from the desktop and network on which the software is installed, or through Keynote points of presence in San Francisco; New York; Frankfurt, Germany; London; and Hong Kong. For San Francisco, there’s a second point of presence that measures Web application performance over a DSL link to provide a reading on the impact of a user’s last-mile connection on the test application.
For an additional fee, users can expand their tests to additional locations, as well as configure tests to run remotely at scheduled intervals.
KITE runs on Windows XP or Vista, and uses Internet Explorer 7 for script recording and for local test sessions. According to Keynote, the company has no plans to support other operating systems. However, I was able to perform remote tests using Web browsers other than Internet Explorer by modifying my script settings using KITE’s Script Properties Editor.
KITE in Action
KITE in Action
At its most basic level, KITE enables users to test a particular URL using Keynote’s Web site-the service accesses a given URL from the six points of presence I mentioned above-and provides a breakdown of all the elements on the specified page and how much network time and browser rendering time it took to load those elements.
For scripted site interaction, the KITE desktop application comes into play. The KITE client enables users to create two types of script, those that involve scripting of a real Web browser, called TxP scripts, and those that involve scripting of an emulated browser, called ApP scripts. The ApP scripts incur fewer costs when run on Keynote’s remote points of presence (beyond the six free points), but the TxP scripts are required to test rich, asynchronous Web applications.
For the KITE user interface, Keynote adopted the look of the Microsoft Ribbon UI that debuted in Office 2007. Functionally, however, KITE’s ribbon implementation differs from that in Office in its lack of context sensitivity. Rather, the ribbon shifted between its Script, Edit, Performance, View and Options modes at my command. One nice UI touch was the option KITE offered of displaying Advanced, Default or Simple layouts, which I found helpful as I got up to speed on the application.
I found it very easy to script operations with basic Web applications, such as the Mediawiki wiki server-the process involved hitting the prominent red record button in the upper left corner of the KITE UI, stepping through the site operations I wished while in a standard-looking browser Window and hitting a stop button when I was finished.
From there, I could hit a play button on KITE’s ribbon, and the script would duly step through my recorded operations and offer up a performance report similar to the one provided by Keynote’s Web-based single URL testing option. Unlike that Web-based test, the scripts I ran from the KITE client ran through my local network, which allowed me to compare performance between, for instance, our production LAN and the wireless network we maintain in our lab.
Scripting AJAX-based Web applications was more complicated and required some script tweaking to compensate for the asynchronous operations of these applications. In a basic Web application such as Mediawiki, individual operations are broken up into new page loads, and KITE marks the completion of these operations through messages from the browser that indicate a page has finished loading.
In an AJAX application, network and browser operations occur asynchronously, so it’s necessary to give KITE other markers to indicate that an operation has finished, such as a short period of network inactivity. It’s also possible to insert additional completion conditions to KITE scripts, such as waiting for a particular bit of text to be loaded on a page before moving ahead with the script.
To run one of my scripts from Keynote’s remote network, I navigated to the same site from which I could test a single URL, chose the script option and uploaded my KITE script from my local system. Keynote’s site then ran my script from its six locations and provided performance breakdowns, by location, for each operation in my script. ??
eWEEK Labs Executive Editor Jason Brooks can be reached at [email protected]