This week I’ve decided to promote the Ad for Gurock Software’s SmartInspect on my blog's front page. In this fair review you’ll read why.

The idea behind SmartInspect  is to give you rich tracing abilities from multiple frameworks and languages on one hand, and a rich UI client to view, filter and sift through all the generated data on the other hand.

As a long time user of other logging frameworks like EIF, Log4Net and such, this is a refreshing product. It’s the same difference I find between other open source vs. commercial software out there (like NAnt vs. FinalBuilder as a good example). This product is simply a comprehensive, well though out set of components that help much more than they interfere.

Framework

    

     // Log simple messages, warnings and exceptions 
    
    

     SiAuto.Main.
     LogMessage("Processing Order 48843"); 
    
    

     SiAuto.Main.
     LogError("Connection refused while trying to connect!"); 
    
    

     SiAuto.Main.
     LogException(e); 
    
    

     // Generate call stack information 
    
    

     SiAuto.Main.
     EnterMethod(
     this, "Button1_Click"); 
    
    

     SiAuto.Main.
     LeaveMethod(
     this, "Button1_Click"); 
    
    

     // Log variables values, datasets or any other object 
    
    

     SiAuto.Main.
     LogInt("index", index); 
    
    

     SiAuto.Main.
     LogObject("order", order); 
    
    

     SiAuto.Main.
     LogDataSet("dataSet", dataSet); 
    
    

      
    

The basic scenarios include being able to trace entering and leaving methods, and you have static methods on a main object (called SiAuto.Main) to help you with that. But then the fun begins as you find out you have customer tracing methods for most anything else you’d like, like entering and leaving threads and processes, tracing the properties of a passed in object, tracing images, AppDomains and binary files, everything is out there, ready to be used.

This is the framework you’d have written yourself if you just had the time, but you’d never had the time to write a UI that handles all that wonderful input.

It also comes with Customer code snippets for VS 2005 that can be used to quickly insert that repetitive code, though I’d much rather see a custom tool that instruments/removed the code with such calls (I asked, and they have such a product in planning).

UI

In the UI you can create your own views, each has its own filters (by process, for example) and each can open a different log file, or several log files. You have a custom viewer for images and binary files that you can simply click on to see the “Values” of the traced object. You can also see the StackTrace if you want to, and, the most powerful thing to me was the ability to show the execution of specific threads through the application, each thread showing just the actions under its own context.

That would certainly have clear up many things I’ve encountered in my day to day work, and logging without that kind of UI is much more intensive and bug ridden since you need to have lots of logging in place for thread specific logging. Thanks Gurock!

TCP vs. log tracing

Another bonus is the ability to get “live” logging views using the built in TC tracing in the viewer and the SmartInspect Objects. You don’t need to do anything but write some “Debug” statements to see them show up in the SI viewer immediately by default.

You can of course then change that to using the log files we all know and love, and you can use custom Smart Inspect Trace Listeners to  integrate directly with your own Trace Listeners in existing application code. It just works.

Extensibility

You can actually extend the various classes in the SI Library to create your own UI Filters, Customer Tracers, Levels and more. That’s a big plus because personally I don’t like to be “stuck” with an object model that only lacks some small features to be perfect.

Multiple Sources

The ability to Trace from multiple components or applications, written in different languages is an important one, especially for project which have been going on for more than a couple of years. In that regard, SmartInspect falls short by not allowing to display simultaneous data from multiple sources, not being able to combine several log files into a single view, and not allowing you to watch the full flow of user actions between different applications. That’s a shame because that’s a golden goose for distributed applications..

Help

The guys at Gurock seemed to have spent just as much time on documenting the abilities of  this product as they did building it, and it shows. The help is easy to read and helped me a lot figuring out my first steps using the product. The main UI of the product includes very easy to understand tutorials for beginners on Java , VB.NET, C# and Delphi development with their framework.

Missing

SmartInspect has its flaws, but they mostly fall under the “it would be great if..” department.

For example you can open multiple log files from multiple applications under the same view, but they won’t be sorted by time and date. It would be great if it did, because then you could see a flow of actions between applications(They are planning the ability to view multiple views one next to each other – still not good enough for me).

Also, You can’t use SmartInspect from Visual Basic 6.0(They don’t have a COM Based framework at all) which to me is a big gaping hole – there are a lot of legacy apps out there in VB/FoxPro that would *love* the use of COM in this case, and it does not seem to me to make sense not to have this support(they are not even sure if they will add such support in the future).

Summary

Overall, The fully-baked abilities of SmartInspect along with the impressive UI would be near perfect, but due to the missing features mentioned here, I have to give this product an 8 out of 10, which is still whole lot of functionality in a product that starts at $229 per license.