Posted in ColdFusion | Posted on 09-17-2009 | 4,921 views
A reader posted an interesting comment to my ColdFusion Exception Handling Guide. He had modified his error handling to store the errors in a database. This allowed him to look at history exception information, do trending, etc. But he ran into trouble trying to remove the stack trace from the exception object. Here is an example of that.
Imagine a simple onError like so:
2 <cfargument name="exception" required="true">
3 <cfargument name="eventname" type="string" required="true">
4 <cfset structDelete(arguments.exception, "stacktrace")>
5 <cfdump var="#exception#">
6 <cfabort>
7</cffunction>
Doing this causes the error handler itself to barf out: cannot remove properties from a java object. While I knew that Exceptions were Java objects, I had always assumed that when ColdFusion got to it, it was a normal struct. When you cfdump it, you see a struct, which is very different from the normal Java object dump. However, you can see that it is not if you check the class name:
This returns coldfusion.runtime.UndefinedVariableException whereas a "real" structure would return coldfusion.runtime.Struct. Ok, so this implies that cfdump recognizes the ColdFusion exception and massages the output a bit. What happens if we try to duplicate the structure?
2<cfset structDelete(ex, "stacktrace")>
3<cfdump var="#ex#">
Unfortunately this returns the exact same error: cannot remove properties from a java object. So we still have a Java object after the duplicate. No surprise there I guess, but if cfdump had a 'hack' for ColdFusion exceptions I thought perhaps duplicate might.
I then tried this variation:
2<cfloop item="key" collection="#arguments.exception#">
3 <cfset newEx[key] = duplicate(arguments.exception[key])>
4</cfloop>
5
6<cfdump var="#newEx#">
7<cfdump var="#newex.getClass().getName()#">
And bam - that did it. So at the key level the values came over correctly. And just to be sure, I then did this:
And bam - that worked perfectly.
Of course, this may be overkill. If you are inserting the values from the exception object into the database, you can simply do the left in your cfquery. So for example, this is fine:
I'm not modifying the actual Exception object, just the result of getting the string value.
I did notice a caveat: The structs inside of Error remain as java objects (discovered while tryign to delete Error.RootCause.StackTrace).
I'm assuming I could just not add RootCause on the original copy, and loop it in using your method as an update after to further trim. Or, when I hit that key during the original copy, do an inner loop to build the contents of the key there.
I all probably seems excessive, but on just a query error, there four stacks and makes the error considerably longer than it needs to be. I feel it's akin to clearing a stack of papers off your desk, rather than just working around it all day.
<CFSET newError = structNew()>
<CFLOOP ITEM="key" COLLECTION="#Error#">
<CFIF key IS NOT "StackTrace">
<cfset newError[key] = duplicate(Error[key])>
</CFIF>
<CFIF key IS "RootCause">
<CFSET RootCause = structNew()>
<CFLOOP ITEM="key1" COLLECTION="#Error.RootCause#">
<CFIF ListFind("Cause,RootCause", key1) GT 0>
<CFSET temp = structNew()>
<CFLOOP ITEM="key2" COLLECTION="#Error.RootCause["#key1#"]#">
<CFIF key2 IS NOT "StackTrace">
<CFSET temp[key2] = duplicate(Error.RootCause["#key1#"][key2])>
</CFIF>
</CFLOOP>
<CFSET RootCause[key1] = temp>
<CFELSEIF key1 IS NOT "StackTrace">
<CFSET RootCause[key1] = duplicate(Error.RootCause[key1])>
</CFIF>
</CFLOOP>
<CFSET newError[key] = RootCause>
</CFIF>
</CFLOOP>
<cfset var s = serializeJSON(arguments.exception)>
<cfset var newEx = deserializeJSON(s)>
This gives you a vanilla struct. So you can manipulate as you will.
<CFSET tempError = serializeJSON(Error)>
<CFSET newError = deserializeJSON(tempError)>
<CFLOOP LIST="newError,newError.RootCause,newError.RootCause.Cause,newError.RootCause.RootCause" INDEX="i">
<CFIF StructKeyExists( Evaluate(i), "StackTrace" )>
<CFSET temp = StructDelete( Evaluate(i), "StackTrace")>
</CFIF>
</CFLOOP>
<cftry>
<cfthrow object="#arguments.exception#">
<cfcatch type="any">
<cfset var jsonData = serializeJSON({
'url' = url,
'form' = form,
'session' = session,
'cgi' = cgi,
'exception' = arguments.exception,
'application' = application,
'server' = server
})>
</cfcatch>
</cftry>
I can then save the whole thing in the database. This will serialize the stack trace as well.
'exception' = arguments.exception -> 'exception' = cfcatch
An obvious solution to this problem might be to make a copy of the structs, loop over their keys to remove any non-serializable members and then call serializeJSON over them.
<cffunction name="getSerializableObjectCopy" access="private" returntype="any">
<cfargument name="o" type="any" required="yes">
<cfscript>
var objectCopy = isStruct(arguments.o)? {} : [];
var sLen = isStruct(arguments.o)? structCount(arguments.o) : arrayLen(arguments.o);
if (isStruct(arguments.o)) {
var keyList = structKeyList(arguments.o);
}
for (var i = 1; i lte sLen; i++) {
local.keyOrIndex = isStruct(arguments.o)? listGetAt(keyList, i) : i;
local.value = arguments.o[local.keyOrIndex];
if (isStruct(local.value)) {
local.meta = getMetaData(local.value);
if (structKeyExists(local.meta, 'type') and local.meta.type is 'component') {
objectCopy[local.keyOrIndex] = '<#local.meta.fullName#>';
continue;
}
}
objectCopy[local.keyOrIndex] = (isStruct(local.value) or isArray(local.value))?
getSerializableObjectCopy(local.value, objectCopy) : (
isStruct(local.value)
or isSimpleValue(local.value)
or isArray(local.value)
)? local.value : '<unserializable value>';
}
return objectCopy;
</cfscript>
</cffunction>
<cffunction name="getSerializableObjectCopy" access="private" output="yes" returntype="any">
<cfargument name="o" type="any" required="yes">
<cfscript>
if (isStruct(arguments.o)) {
local.objectCopy = {};
local.keys = structKeyArray(arguments.o);
local.sLen = arrayLen(local.keys);
} else {
local.objectCopy = [];
local.sLen = arrayLen(arguments.o);
}
for (var i = 1; i lte local.sLen; i++) {
local.keyOrIndex = isStruct(arguments.o)? local.keys[i] : i;
local.value = arguments.o[local.keyOrIndex];
if (isStruct(local.value)) {
local.meta = getMetaData(local.value);
if (structKeyExists(local.meta, 'type') and local.meta.type is 'component') {
local.objectCopy[local.keyOrIndex] = '<#local.meta.fullName#>';
continue;
}
}
local.objectCopy[local.keyOrIndex] = (isStruct(local.value) or isArray(local.value))?
getSerializableObjectCopy(local.value, local.objectCopy) : (
isStruct(local.value)
or isSimpleValue(local.value)
or isArray(local.value)
)? local.value : '<unserializable value>';
}
return local.objectCopy;
</cfscript>
</cffunction>
[Add Comment] [Subscribe to Comments]