Raymond Camden's Blog Rss

Interesting tidbits on ColdFusion Exceptions

7

Posted in ColdFusion | Posted on 09-17-2009 | 4,751 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:

view plain print about
1<cffunction name="onError" returnType="void" output="false">
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:

view plain print about
1<cfdump var="#exception.getClass().getName()#">

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?

view plain print about
1<cfset var ex = duplicate(arguments.exception)>
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:

view plain print about
1<cfset var newEx = structNew()>
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:

view plain print about
1<cfset newEx.stackTrace = left(newEx.stackTrace, 100)>

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:

view plain print about
1<cfoutput>#left(arguments.exception.stacktrace,10)#</cfoutput>

I'm not modifying the actual Exception object, just the result of getting the string value.

Comments

[Add Comment] [Subscribe to Comments]

Brilliant, and worked pefectly. Thank you.

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.
Ah - so that means the sub parts of the exception obs are also complex. Nice. But yea, you could not copy the root cause, or make the copy code a bit more complex.
This seems to do the trick, drilling down enough to clean up most error dumps. I won't doubt there may be a simplier way yet to do the same thing (hoping the format comes out ok):
<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>
Wonder if you can use serializeJSON() on the object? Not that that would be terribly useful, I'm just curious.
Todd! YOU FREAKING RULE! :) SerializeJSON does indeed work. :)
And even better, get this:

<cfset var s = serializeJSON(arguments.exception)>
<cfset var newEx = deserializeJSON(s)>

This gives you a vanilla struct. So you can manipulate as you will.
I still need my original code for our CF7 server, but this suggestion is working great on our CF8 server. Here's the improved version now:

<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>

[Add Comment] [Subscribe to Comments]