Background
One of
the clients I work with had been experiencing some issues for a while surrounding web service timeouts. It's been a little challenging to work through
the problems due to limitations in
the diagnostic information available from one of
the applications, but I learned some interesting things while troubleshooting
the problem which don't seem to have been discussed much in
the community so I thought I'd share my findings.
In
the scenario we have BizTalk trying to make calls to a .net web service which was exposed as a WSE 2 endpoint. In
the process BizTalk will try to make a large number of
concurrent web service calls to
the application, and
the backend application has more than enough infrastructure and capability to handle
the load.
We have configured
the <ConnectionManagement> section of
the BizTalk configuration file to support up to 100
concurrent connections from each of our 2 BizTalk send servers to
the web servers of
the application.
The problem we were facing was that
the BizTalk side was reporting a significant number of timeouts when calling
the web service.
One of
the biggest issues was
the challenge of being able to correlate a message from BizTalk to
the IIS log in
the .net application and
the custom logs in
the application especially when there was a fairly large number of servers hosting
the web services. However
the key moment came when we were able to identify a specific call which had taken 40 seconds to execute on
the server (yes a long time I know but that's a different story!). Anyway we were able to identify that this had timed out on
the BizTalk side. Based on
the normal 2 minute timeout we knew something unexpected was going on.
From here I decided to do some experimentation and I wanted to start outside of BizTalk because my hunch was this was not a BizTalk behaviour but something which was being highlighted by BizTalk because of our large load.
Server-side - Sample Web Service
To begin with I created a sample web service. Nothing special just a vanilla asmx web service hosted in IIS6 on Windows 2003 Standard Edition.
The web service is just a hello world style web service as shown in
the below picture.
The only key feature is that
the server side web method has a 30 second sleep in it and will trace out some information before and after
the thread is set to sleep.
In
the configuration for this web service there again is nothing special it's pretty much
the most plain simple web service you could build.
Client-Side
To begin looking at what was happening with our example I created a number of different ways to consume
the web service.
SoapHttpClientProtocol Example
I created a small application which would use a normal proxy generated to call
the web service. It would iterate around a loop and make calls using
the begin/end methods so I can do this asynchronously. I would do a loop of 20 calls with
the ConnectionManager configuration section supporting only 5
concurrent connections to
the server.
<connectionManagement>
<remove address="*"/>
<add address = "*" maxconnection = "12" />
<add address = "http://<ServerName>" maxconnection = "5" />
</connectionManagement>
</system.net>
The below picture shows an example of
the service calling code, key points are:
I have configured
the timeout of 40 seconds for
the proxy
I am using
the asynchronous methods on
the proxy to call
the web service
The Test
I would run
the client and execute 21 calls to
the web service.
The Results
Below is
the client side trace showing what's happening on
the client.
In
the below diagram is
the web service side trace showing what's happening on
the server
Some observations on
the results are:
All of
the calls were successful from
the clients perspective
You could see
the next call starting on
the server as soon as
the previous one had completed
Calls took significantly longer than 40 seconds from
the start of our call to
the return. In fact call 20 took 2 minutes and 30 seconds from
the perspective of my code to execute even though I had set
the timeout to 40 seconds
WSE 2 Sample
In
the second example I used
the exact same code to call
the web service again with a single exception that I modified
the web service proxy to derive from WebServiceClient protocol which is part of WSE 2 (using SP3).
The below picture shows
the basic code and
the key points are:
I have configured
the timeout of 40 seconds for
the proxy
I am using
the asynchronous methods on
the proxy to call
the web service
The Test
This test would execute 21 calls from
the client to
the web service.
The Results
The below trace is from
the client side:
The below trace is from
the server side:
Some observations on
the trace results for this scenario are:
With call 4 if you look at
the server side trace it did not start executing on
the server for a number of seconds after
the other 4 initial calls which were accepted by
the server. I re-ran
the test and this happened a couple of times and not on most others so at this point I'm just putting this down to something unexpected happening on
the development machine and we will leave this observation out of scope of this article.
You can see that
the client side trace statement executed almost immediately in all cases
All calls after
the initial few calls would timeout
On
the client side
the calls that did timeout; timed out in a longer duration than
the 40 seconds we set as
the timeout
You can see that as calls were completing on
the server
the next calls were starting to come through
The calls that timed out on
the client did actually connect to
the server and their server side execution completed successfully
Elaboration on
the findings
Based on
the above observations I have drawn
the below sequence diagram to illustrate conceptually what is happening. Everything except
the final web service object is on
the client side of
the call. In
the diagram below I've put two notes on
the Web Service Proxy to show
the two different places where
the different base classes seem to start their timeout counters.
From
the earlier samples we can work out that
the timeout counter for
the WSE web service proxy starts before
the one for
the SoapHttpClientProtocol proxy and
the WSE one includes
the time to get a connection from
the pool; whereas
the Soap proxy timeout just covers
the method execution.
One interesting observation is if we rerun
the above sample and increase
the number of calls from 21 to 100,000 then for
the WSE sample we will see a similar pattern where everything after
the first few calls will timeout on
the client as soon as it makes a connection to
the server whereas
the soap proxy will happily plug away and process all of
the calls without a single timeout. I have actually set
the sample running overnight and this did happen.
At this point you are probably thinking
the same thoughts I was at
the time about
the differences in behaviour and which is right and why are they different? I'm not sure there is a definitive answer to this in
the documentation, or at least not that I could find! I think you just have to consider that they are different and they could have different effects depending on your messaging solution.
In lots of situations this is just not an issue as your
concurrent requests doesn't get to
the situation where you end up throttling
the web service calls on
the client side, however this is definitely more common with an integration broker such as BizTalk where you often have high throughput requirements.
Some of
the considerations you should make
Based on this behaviour you should be aware of
the following:
In a .net application if you are making lots of
concurrent web service calls from an application in an asynchronous manner your user may thing they are experiencing poor performance but you think your web service is working well.
The problem could be that
the client will have a default of 2 connections to remote servers so you should bear this in mind
When you are developing a BizTalk solution or a .net solution with
the WSE 2 stack you may experience timeouts under load and throttling
the number of connections using
the max connections element in
the configuration file will not help you
For an application using WSE2 or SoapHttpClientProtocol an expired timeout will not throw an error until after a connection to
the server has been made so you should consider this in your transaction and durability patterns
Our Work Around
In
the short term for our specific scenario we know that we can handle this by just increasing our timeout value. There is only a specific small window when we get lots of
concurrent traffic that causes this scenario so we should be able to increase
the timeout to take into consideration
the additional client side wait, and on
the odd occasion where we do get a timeout
the BizTalk send port retry will handle this.
What was causing our original problem was that for that short window we were getting a lot of retries which significantly increased
the load on our send servers and highlighted
the issue.
Longer Term Solution
As a longer term solution this really gives us more ammunition to argue a migration to WCF.
The application we are calling has some factors which limit
the protocols we can use but with WCF we would have more control on
the various timeout options because in WCF you can configure specific parts of
the timeout.
Summary
I've had this blog post on my to do list for ages but hopefully it will be useful to some people to just understand this behaviour and to possibly help you with some performance issues you may have. I do not believe there is too much in
the way of documentation particularly around WSE2 and ASMX in this area so again another bit of ammunition for migrating to WCF.
I'll try to do a follow up post with
the sample for WCF to show how this changes things.
