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.
