How to optimize this code that read from xml file - asp-classic

Question

We have ther following classic asp code that read from xml file, it shows a poor performance when there are more than 10 concurrent requests to that page , can someone figure out the performance problem in this code( we know one of the the problems which is using fileSystemObject but we do not have alternatives for it!):
set filesys=server.CreateObject("Scripting.FileSystemObject")
if filesys.FileExists(sourcefile) then
set source = Server.CreateObject("Msxml2.DOMDocument")
source.validateOnParse = false
source.resolveExternals = false
source.preserveWhiteSpace = false
source.load(sourcefile)
If source.ParseError.errorCode <> 0 Then
str_head=source.selectSingleNode("/LIST/ITEM/NEWSITEM/HEADLINE//").text
str_by=source.selectSingleNode("//LIST//ITEM//NEWSITEM//PROVIDER//").text
News_date_orig = source.selectSingleNode("/LIST/ITEM/NEWSITEM/CREATED//").text
str_date= formatdatetime(source.selectSingleNode("//LIST//ITEM//NEWSITEM//CREATED//").text,1)
set bodyNode=source.selectSingleNode("/LIST/ITEM/NEWSITEM//BODY//")
styleFile=Server.MapPath("/includes/xsl/template.xsl")
Set style = Server.CreateObject("Msxml2.DOMDocument")
style.validateOnParse = false
style.resolveExternals = false
style.preserveWhiteSpace = false
style.load(styleFile)
news_full = bodyNode.transformNode(style)
if len(news_full) < 10 then
news_full = str_abstract
end if
DiscriptionKeyWord = stripHTMLtags(news_full)
DiscriptionKeyWord=StrCutOff(DiscriptionKeyWord, 200, "...")
headerTitle=str_head
Set style=nothing
Set source = nothing
end if
set filesys= nothing
The following is stripHTMLtags function:
Function stripHTMLtags(HTMLstring)
Set RegularExpressionObject = New RegExp
With RegularExpressionObject
.Pattern = "<[^>]+>"
.IgnoreCase = True
.Global = True
End With
stripHTMLtags = RegularExpressionObject.Replace(HTMLstring, "")
Set RegularExpressionObject = nothing
End Function
UPDATE: I put a timer to show the execution time for the function that read xml file and found that it takes around 3 seconds on the production server while it takes less than 1 second on my PC! What does tht mean?! I'm lost.

Answer 1

Option Explicit
If your scripts don't begin with Option Explict then make that change now. Then fix all the compile errors that show up. Doesn't help performance but when I see evidence that this biggest of all scripting mistakes is being made it just needs mentioning.
FileSystemObject
I doubt the performance problem is a result of the FileSystemObject, all you are doing is creating an instance and testing for the existance of a file. That is hardly likely to cause a problem.
Having said that I would ditch the FileSystemObject anyway. Just let the script throw an error if there is a problem. Use IIS Manager to map 500.100 status codes to an ASP page that presents a friendly "Something bad happened" page to the user. (500.100 is the status of a request when the script throws an exception). Also test the boolean result of the DOM load method, throw an error when parse error is not 0 also. That way you hand over all the ugly exception handling to the 500.100 handling page and your code can remain clean just dealing with the nominal path of the code.
Tidy up the paths
Perhaps there is a reason why you are using "//" a lot in your paths (but inconsistently) but I'm going to assume there isn't so we can simplify some of the paths:
Dim newsItem: Set newsItem = source.selectSingleNode("/LIST/ITEM/NEWSITEM")
Dim str_head: str_head = newsItem .selectSingleNode("HEADLINE").text
Dim str_by: str_by = newsItem .selectSingleNode("PROVIDER").text
Dim News_date_orig: News_date_orig = newsItem .selectSingleNode("CREATED").text
Dim str_date: str_date = formatdatetime(News_date_orig, 1)
Dim bodyNode: Set bodyNode = newsItem.selectSingleNode("BODY")
Cache XSLTemplate
An area where you could gain some real perfomance improvement is to cache the XSL Transform in the application object (which is possible due to XSLTemplate being a free threaded object). Like this:
Dim xslTemplate
If IsObject(Application("xsl_template")) Then
Set xslTemplate = Application("xsl_template")
Else
Set style = Server.CreateObject("Msxml2.FreeThreadedDOMDocument.3.0")
style.async = false
style.validateOnParse = false
style.resolveExternals = false
style.preserveWhiteSpace = false
style.load Server.MapPath("/includes/xsl/template.xsl")
Set xslTemplate = CreateObject("MSXML2.XSLTemplate.3.0")
xslTemplate.stylesheet = xsl
Set Application("template") = xslTemplate
End If
Dim xslProc: Set xslProc = xslTemplate.createProcessor()
xslProc.input = bodyNode
xslProc.transform()
news_full = xslProc.output
The effort to read, parse and compile the XSL transform is only done once in the whole lifetime of the application.
The most likely culprit
To be honest I suspect the most likely culprit is stripHTMLtags. This sounds like a whole load of string handling and the performance of VBScript string handling is poor. Its especially poor when code is not properly optomised to be aware of the string handling performance limitations (e.g. excessive and repeative string concatenations). Its also likely to be where the most actual VBScript occurs which is often the cause of a performance problem.

Answer 2

You can load the XML into a string on application startup and store it in an Application object.
Then, instead of using source.load, use source.loadXML with this string - you will not be accessing the filesystem anymore. See the documentation for loadXML.
Make sure you use a version of MSXML 3.0 or over to use this method.
Server.CreateObject("Msxml2.DOMDocument.6.0")
Update - seeing as you have thousands of these files and you believe it is infeasible to store them in memory in the Application object, you should be using a database to handle the concurrency issues you are seeing. Store the contents of the files keyed to something like their current filename/path - retrieve them from the database and load to a document using the same loadXML mechanism.