A few months ago on a project
the subject
of load testing came up. We were having some serious issues with a
Web application that would start spewing SQL lock errors under somewhat heavy load. These sort
of errors can be tough to catch, precisely because they only occur under load and not during typical development testing. To replicate this error more reliably we needed to put a load on
the application and run it for a while before these SQL errors would flare up. It’s been a while since I’d looked at load testing tools, so I spent a bit
of time looking at different tools and frankly didn’t really find anything that was a good fit. A lot
of tools were either a pain to use, didn’t have
the basic features I needed, or are extravagantly expensive. In
the end I got frustrated enough to build an initially small custom load test solution that then morphed into a more generic library, then gained a console front end and eventually turned into a full blown
Web load testing tool that is now called West Wind WebSurge. I got seriously frustrated looking for tools every time I needed some quick and dirty load testing for an application. If my aim is to just put an application under heavy enough load to find a scalability problem in code, or to simply try and push an application to its limits on
the hardware it’s running I shouldn’t have to have to struggle to set up tests. It should be easy enough to get going in a few minutes, so that
the testing can be set up quickly so that it can be done on a regular basis without a lot
of hassle. And that was
the goal when I started to build out my initial custom load tester into a more widely usable tool. If you’re in a hurry and you want to check it out, you can find more information and download links here: West Wind WebSurge Product Page Walk through Video Download link (zip) Install from Chocolatey Source on GitHub For a more detailed discussion
of the why’s and how’s and some background continue reading. How did I get here? When I started out on this path, I wasn’t planning on building a tool like this myself – but I got frustrated enough looking at what’s out there to think that I can do better than what’s available for
the most common simple load testing scenarios. When we ran into
the SQL lock problems I mentioned, I started looking around what’s available for
Web load testing solutions that would work for our whole team which consisted
of a few developers and a couple
of IT guys both
of which needed to be able to run
the tests. It had been a while since I looked at tools and I figured that by now there should be some good solutions out there, but as it turns out I didn’t really find anything that fit our relatively simple needs without costing an arm and a leg… I spent
the better part
of a day installing and trying various load testing tools and to be frank most
of them were either terrible at what they do, incredibly unfriendly to use, used some terminology I couldn’t even parse, or were extremely expensive (and I mean in
the ‘sell your liver’ range
of expensive). Pick your poison. There are also a number
of online solutions for load testing and they actually looked more promising, but those wouldn’t work well for our scenario as
the application is running inside
of a private VPN with no outside access into
the VPN. Most
of those online solutions also ended up being very pricey as well – presumably because
of the bandwidth required to test over
the open
Web can be enormous. When I asked around on Twitter what people were using– I got mostly… crickets. Several people mentioned Visual Studio Load Test, and most other suggestions pointed to online solutions. I did get a bunch
of responses though with people asking to let them know what I found – apparently I’m not alone when it comes to finding load testing tools that are effective and easy to use. As to Visual Studio,
the higher end skus
of Visual Studio and
the test edition include a
Web load testing tool, which is quite powerful, but there are a number
of issues with that: First it’s tied to Visual Studio so it’s not very portable – you need a VS install. I also find
the test setup and terminology used by
the VS test runner extremely confusing. Heck, it’s complicated enough that there’s even a Pluralsight course on using
the Visual Studio
Web test from Steve Smith. And
of course you need to have one
of the high end Visual Studio Skus, and those are mucho Dinero ($$$) – just for
the load testing that’s rarely an option. Some
of the tools are ultra extensive and let you run analysis tools on
the target serves which is useful, but in most cases – just plain overkill and only distracts from what I tend to be ultimately interested in: Reproducing problems that occur at high load, and finding
the upper limits and ‘what if’ scenarios as load is ramped up increasingly against a site. Yes it’s useful to have
Web app instrumentation, but often that’s not what you’re interested in. I still fondly remember early days
of Web testing when Microsoft had
the WAST (Web Application Stress Tool) tool, which was rather simple – and also somewhat limited – but easily allowed you to create stress tests very quickly. It had some serious limitations (mainly that it didn’t work with SSL), but
the idea behind it was excellent: Create tests quickly and easily and provide a decent engine to run it locally with minimal setup. You could get set up and run tests within a few minutes. Unfortunately, that tool died a quiet death as so many
of Microsoft’s tools that probably were built by an intern and then abandoned, even though there was a lot
of potential and it was actually fairly widely used. Eventually
the tools was no longer downloadable and now it simply doesn’t work anymore on higher end hardware. West Wind
Web Surge – Making Load Testing Quick and Easy So I ended up creating West Wind WebSurge out
of rebellious frustration…
The goal
of WebSurge is to make it drop dead simple to create load tests. It’s super easy to capture sessions either using
the built in capture tool (big props to Eric Lawrence, Telerik and FiddlerCore which made that piece a snap), using
the full version
of Fiddler and exporting sessions, or by manually or programmatically creating text files based on plain HTTP headers to create requests. I’ve been using this tool for 4 months now on a regular basis on various projects as a reality check for performance and scalability and it’s worked extremely well for finding small performance issues. I also use it regularly as a simple URL tester, as it allows me to quickly enter a URL plus headers and content and test that URL and its results along with
the ability to easily save one or more
of those URLs. A few weeks back I made a walk through video that goes over most
of the features
of WebSurge in some detail: Note that
the UI has slightly changed since then, so there are some UI improvements. Most notably
the test results screen has been updated recently to a different layout and to provide more information about each URL in a session at a glance.
The video and
the main WebSurge site has a lot
of info
of basic operations. For
the rest
of this post I’ll talk about a few deeper aspects that may be
of interest while also giving a glance at how WebSurge works. Session Capturing As you would expect, WebSurge works with Sessions
of Urls that are played back under load. Here’s what
the main Session View looks like: You can create session entries manually by individually adding URLs to test (on
the Request tab on
the right) and saving them, or you can capture output from
Web Browsers, Windows Desktop applications that call services, your own applications using
the built in Capture tool. With this tool you can capture anything HTTP -SSL requests and content from
Web pages, AJAX calls, SOAP or REST services – again anything that uses Windows or .NET HTTP APIs. Behind
the scenes
the capture tool uses FiddlerCore so basically anything you can capture with Fiddler you can also capture with
Web Surge Session capture tool. Alternately you can actually use Fiddler as well, and then export
the captured Fiddler trace to a file, which can then be imported into WebSurge. This is a nice way to let somebody capture session without having to actually install WebSurge or for your customers to provide an exact playback scenario for a given set
of URLs that cause a problem perhaps. Note that not all applications work with Fiddler’s proxy unless you configure a proxy. For example, .NET
Web applications that make HTTP calls usually don’t show up in Fiddler by default. For those .NET applications you can explicitly override proxy settings to capture those requests to service calls.
The capture tool also has handy optional filters that allow you to filter by domain, to help block out noise that you typically don’t want to include in your requests. For example, if your pages include links to CDNs, or Google Analytics or social links you typically don’t want to include those in your load test, so by capturing just from a specific domain you are guaranteed content from only that one domain. Additionally you can provide url filters in
the configuration file – filters allow to provide filter strings that if contained in a url will cause requests to be ignored. Again this is useful if you don’t filter by domain but you want to filter out things like static image, css and script files etc. Often you’re not interested in
the load characteristics
of these static and usually cached resources as they just add noise to tests and often skew
the overall url performance results. In my testing I tend to care only about my dynamic requests. SSL Captures require Fiddler Note, that in order to capture SSL requests you’ll have to install
the Fiddler’s SSL certificate.
The easiest way to do this is to install Fiddler and use its SSL configuration options to get
the certificate into
the local certificate store. There’s a document on
the Telerik site that provides
the exact steps to get SSL captures to work with Fiddler and therefore with WebSurge. Session Storage A group
of URLs entered or captured make up a Session. Sessions can be saved and restored easily as they use a very simple text format that simply stored on disk.
The format is slightly customized HTTP header traces separated by a separator line.
The headers are standard HTTP headers except that
the full URL instead
of just
the domain relative path is stored as part
of the 1st HTTP header line for easier parsing. Because it’s just text and uses
the same format that Fiddler uses for exports, it’s super easy to create Sessions by hand manually or under program control writing out to a simple text file. You can see what this format looks like in
the Capture window figure above –
the raw captured format is also what’s stored to disk and what WebSurge parses from.
The only ‘custom’ part
of these headers is that 1st line contains
the full URL instead
of the domain relative path and Host: header.
The rest
of each header are just plain standard HTTP headers with each individual URL isolated by a separator line.
The format used here also uses what Fiddler produces for exports, so it’s easy to exchange or view data either in Fiddler or WebSurge. Urls can also be edited interactively so you can modify
the headers easily as well: Again – it’s just plain HTTP headers so anything you can do with HTTP can be added here. Use it for single URL Testing Incidentally I’ve also found this form as an excellent way to test and replay individual URLs for simple non-load testing purposes. Because you can capture a single or many URLs and store them on disk, this also provides a nice HTTP playground where you can record URLs with their headers, and fire them one at a time or as a session and see results immediately. It’s actually an easy way for REST presentations and I find
the simple UI flow actually easier than using Fiddler natively. Finally you can save one or more URLs as a session for later retrieval. I’m using this more and more for simple URL checks. Overriding Cookies and Domains Speaking
of HTTP headers – you can also overwrite cookies used as part
of the options. One thing that happens with modern
Web applications is that you have session cookies in use for authorization. These cookies tend to expire at some point which would invalidate a test. Using
the Options dialog you can actually override
the cookie: which replaces
the cookie for all requests with
the cookie value specified here. You can capture a valid cookie from a manual HTTP request in your browser and then paste into
the cookie field, to replace
the existing Cookie with
the new one that is now valid. Likewise you can easily replace
the domain so if you captured urls on west-wind.com and now you want to test on localhost you can do that easily easily as well. You could even do something like capture on store.west-wind.com and then test on localhost/store which would also work. Running Load Tests Once you’ve created a Session you can specify
the length
of the test in seconds, and specify
the number
of simultaneous threads to run each session on. Sessions run through each
of the URLs in
the session sequentially by default. One option in
the options list above is that you can also randomize
the URLs so each thread runs requests in a different order. This avoids bunching up URLs initially when tests start as all threads run
the same requests simultaneously which can sometimes skew
the results
of the first few minutes
of a test. While sessions run some progress information is displayed: By default there’s a live view
of requests displayed in a Console-like window. On
the bottom
of the window there’s a running total summary that displays where you’re at in
the test, how many requests have been processed and what
the requests per second count is currently for all requests. Note that for tests that run over a thousand requests a second it’s a good idea to turn off
the console display. While
the console display is nice to see that something is happening and also gives you slight idea what’s happening with actual requests, once a lot
of requests are processed, this UI updating actually adds a lot
of CPU overhead to
the application which may cause
the actual load generated to be reduced. If you are running a 1000 requests a second there’s not much to see anyway as requests roll by way too fast to see individual lines anyway. If you look on
the options panel, there is a NoProgressEvents option that disables
the console display. Note that
the summary display is still updated approximately once a second so you can always tell that
the test is still running. Test Results When
the test is done you get a simple Results display: On
the right you get an overall summary as well as breakdown by each URL in
the session. Both success and failures are highlighted so it’s easy to see what’s breaking in your load test.
The report can be printed or you can also open
the HTML document in your default
Web Browser for printing to PDF or saving
the HTML document to disk.
The list on
the right shows you a partial list
of the URLs that were fired so you can look in detail at
the request and response data.
The list can be filtered by success and failure requests. Each list is partial only (at
the moment) and limited to a max
of 1000 items in order to render reasonably quickly. Each item in
the list can be clicked to see
the full request and response data: This particularly useful for errors so you can quickly see and copy what request data was used and in
the case
of a GET request you can also just click
the link to quickly jump to
the page. For non-GET requests you can find
the URL in
the Session list, and use
the context menu to Test
the URL as configured including any HTTP content data to send. You get to see
the full HTTP request and response as well as a link in
the Request header to go visit
the actual page. Not so useful for a POST as above, but definitely useful for GET requests. Finally you can also get a few charts.
The most useful one is probably
the Request per Second chart which can be accessed from
the Charts menu or shortcut. Here’s what it looks like: Results can also be exported to JSON, XML and HTML. Keep in mind that these files can get very large rather quickly though, so exports can end up taking a while to complete. Command Line Interface WebSurge runs with a small core load engine and this engine is plugged into
the front end application I’ve shown so far. There’s also a command line interface available to run WebSurge from
the Windows command prompt. Using
the command line you can run tests for either an individual URL (similar to AB.exe for example) or a full Session file. By default when it runs WebSurgeCli shows progress every second showing total request count, failures and
the requests per second for
the entire test. A silent option can turn off this progress display and display only
the results.
The command line interface can be useful for build integration which allows checking for failures perhaps or hitting a specific requests per second count etc. It’s also nice to use this as quick and dirty URL test facility similar to
the way you’d use Apache Bench (ab.exe). Unlike ab.exe though, WebSurgeCli supports SSL and makes it much easier to create multi-URL tests using either manual editing or
the WebSurge UI. Current Status Currently West Wind WebSurge is still in Beta status. I’m still adding small new features and tweaking
the UI in an attempt to make it as easy and self-explanatory as possible to run. Documentation for
the UI and specialty features is also still a work in progress. I plan on open-sourcing this product, but it won’t be free. There’s a free version available that provides a limited number
of threads and request URLs to run. A relatively low cost license removes
the thread and request limitations. Pricing info can be found on
the Web site – there’s an introductory price which is $99 at
the moment which I think is reasonable compared to most other for pay solutions out there that are exorbitant by comparison…
The reason code is not available yet is – well,
the UI portion
of the app is a bit embarrassing in its current monolithic state.
The UI started as a very simple interface originally that later got a lot more complex – yeah, that never happens, right? Unless there’s a lot
of interest I don’t foresee re-writing
the UI entirely (which would be ideal), but in
the meantime at least some cleanup is required before I dare to publish it :-).
The code will likely be released with version 1.0. I’m very interested in feedback. Do you think this could be useful to you and provide value over other tools you may or may not have used before? I hope so – it already has provided a ton
of value for me and
the work I do that made
the development worthwhile at this point. You can leave a comment below, or for more extensive discussions you can post a message on
the West Wind Message Board in
the WebSurge section Microsoft MVPs and Insiders get a free License If you’re a Microsoft MVP or a Microsoft Insider you can get a full license for free. Send me a link to your current, official Microsoft profile and I’ll send you a not-for resale license. Send any messages to
[email protected]. Resources For more info on WebSurge and to download it to try it out, use
the following links. West Wind WebSurge Home Download West Wind WebSurge Getting Started with West Wind WebSurge Video© Rick Strahl, West Wind Technologies, 2005-2014Posted in ASP.NET
Tweet
!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0];if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src="//platform.twitter.com/widgets.js";fjs.parentNode.insertBefore(js,fjs);}}(document,"script","twitter-wjs");
(function() {
var po = document.createElement('script'); po.type = 'text/javascript'; po.async = true;
po.src = 'https://apis.google.com/js/plusone.js';
var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(po, s);
})();
