vbCodeShield Feature Overview

This page provides a feature summary for vbCodeShield. The list below provides a bullet point summary whilst the rest of the page contains more detailed descriptions with links to other relevant pages.

  • Error identification more ..
    • Adds an error trap to every procedure
    • Recognises and accommodates existing error handling logic
    • Produces a variable dump (local, module and global)
    • Parameter content dump
    • Optionally encrypts logged error and context information
    • Adds line numbers to ensure pin-pointing of an error to an individual line of code
  • Error logging more ..
    • Send email directly from error dialog (requires MAPI client)
    • Error details copied to clipboard
    • Error details logged to NT Event log (Windows NT / 2000 only)
  • Error diagnosis ('Intellifix') more ..
    • Optional feature to provide streamlined fault diagnosis and resolution, reducing the support load
    • As soon as a fix or resolution is available and recorded, users encountering an issue will be aware immediately
    • Complete Internet Information Server ASP application provided to allow over the internet on-line error reporting, diagnosis and even fixing
    • Uses HTTP and configurable proxy information, so will bridge firewalls
    • Can use SSL for information transmission
    • Provides real time information to the user about fault status, resolution and fix information
    • Allows users to request notification when a fault is resolved, reducing the load on support staff
    • Provides a Microsoft style knowledge base article containing symptom, resolution and fix information instantly to users without them having to make a support call
    • Provides direct links to fixes and patches when available, allowing instant resolution
  • Exception catching more ..
    • Converts GPFs and other exceptions to run-time errors trapped and logged by normal vbCodeShield error identification and diagnosis features
  • Run-time Call stack monitoring and logging more ..
    • Parameter contents included in call stack detail
  • Run-time debug message output and logging more ..
    • Existing Debug.Print statements automatically converted
  • SourceSafe integration more ..
    • Automatic check-in and version labelling
  • Instance counting to identify objects that do not terminate correctly more ..
    • Identifies 'circular reference' scenarios
    • Identifies precisely which classes are not terminating correctly
  • Extensibility
    • Full source code for Error Handling object provided
    • Can extended compile process with new plugins
    • Can extend user interface with new plugins
    • Can extend the Debugger with new views and monitors
  • Configuration
    • Local error handler, variable and parameter dump code can be fully customised to individual requirements
    • Combinations of features can be saved as 'Plans' which can be re-used across many projects
    • Unlimited number of plans
    • Allows project specific plans
  • Development team support
    • SourceSafe integration
    • Central Plans repository
    • Configuration saved as a related document and therefore is portable with the source code and can be version managed using SourceSafe or other configuration management tool
  • Diagnosis and error handling features switched by registry parameters - minimum of runtime overhead
    • Different components can have specific registry settings to customise error handling behaviour
  • Visual Basic and Visual Basic for Applications Integration
  • Batch Compilation
  • Real-time Debugger

Error Trapping

vbCodeShield automatically adds an error handler to every procedure within your project. The added procedure is not just a 'blind template', but will recognise and accommodate existing in-line and On Error error handlers you have already established. Essentially the logic of your code remains completely un-altered with the Error trapping in place to catch any unexpected run-time errors.

The error trap records key context information to enable the fault to be precisely identified and diagnosed. Context information includes Line number, Procedure name, Module name, component name, component version and variable contents (see Variable dumping below).

Error handling component

In order to decide the action to take in the event of an unexpected run-time error, vbCodeShield (by default - configurable if required) invokes an ActiveX DLL to handle the error. vbCodeShield ships with a comprehensive error handling component but the beauty of this approach is that you are able to enhance, supplement or completely replace the error handler with one of your own.

As the error handler is a separate component and is late bound, you can alter the error handling capabilities for any solution without needing to recompile the source code. This means you can adapt your error handling strategy over time without having to issue a new version of your entire solution.

The error handler is supplied in binary and source code form to allow you to customise and enhance the error handler without having to start from scratch.

Variable dumping

Uniquely amongst products of a similar nature, vbCodeShield allows you to capture and log the contents of the following variables if an unexpected run-time error occurs:

  • Local variables - variables defined within the procedure in which the run-time error occurs
  • Module variables - variables (public or private) defined within the module in which the run-time error occurs
  • Global variables - public variables defined in any public modules within the project in which the unexpected error occurs
  • Parameters - Parameters passed to the procedure in which the run-time error occurs

This information will often make it possible to precisely identify otherwise inexplicable run-time errors as it provides the context in which the error occurred. For sensitive information or projects, vbCodeShield allows you to encrypt the dumped data using a key that you define. Source code for decrypting the data using your defined key is also provided!

Error handling

When an unexpected runtime error occurs and is trapped by vbCodeShield code, the error handling component is invoked. This component is responsible for logging the error, displaying error information to the user (where appropriate) and even diagnosing and resolving the error on-line.

An example of how the error handler appears to an end user can be found here

Logged information

The information produced by the error handler for logging is formatted as an XML document. If this format is inappropriate for your particular logging requirements, the error handler source code is provided for you to modify as needed.

The error detail recorded by default is as follows :

  • Project Name
  • Project Version
  • Module Name
  • Procedure (routine) Name
  • Line Number
  • Error Number
  • Error Description
  • Variable Dumps (if included)
  • Parameter Dumps (if included)
  • DLL Version information (according to list you specify read from the local registry)
  • Windows product (NT / Window 98 etc.)
  • Windows version
  • Windows build number
  • Windows User Name

Copy to clipboard

The simplest mechanism of error logging copies the error and context information in text form to the clipboard in the event of an unexpected run-time error.

Log to NT Event log

If the error handler is running on Windows NT, error information is recorded in the NT Application event log. The event id of the logged event corresponds to the run-time error number

Send email

If a MAPI client (Outlook, Exchange client) is installed on the local machine, the user is given the option of providing error information via email. The recipient name is read from a local registry value.

On-line error reporting and diagnosis

The supplied error handler comes with the ability to report error information to a web server and to receive back diagnosis and fix information. In order to set up this functionality, the vbCodeShield ASP pages must be installed on a web server.

The advantages of on-line error reporting are numerous. It makes it easy for your users to report and understand errors and the error details are fed straight into a database making them easily accessible to you.

On-line error diagnosis offers you as a software producer a hugely time saving approach to identifying and resolving software faults. Instead of spending time picking the relevant items out of support emails, the precise details describing the context of the error are fed directly to you. Instead of spending time fielding support calls for issues already resolved, you can record the resolution information in the incident database and any new incidents of the problem will have direct access to resolution information and will even be able to automatically obtain the fix if one is available.

Exception catching

Even if you have hand crafted error traps throughout your code and an effective error handling strategy in place, how do you go about identifying exceptions such as GPFs that crash your program? With vbCodeShield, the answer is simple - it converts exceptions into normal runtime errors which can then be trapped and handled by the existing vbCodeShield added error handling mechanisms.

Say goodbye to infuriating GPFs and late nights identifying the cause.

Call stack monitoring

In order to aid in the diagnosis of a problem, vbCodeShield can add call stack monitoring functionality to solution. At startup, your project checks to see if the vbCodeShield Debugger is running - thereby reducing to a minimum any run-time overhead of including the call stack functionality in your code.

The call stack messages are received by the vbCodeShield Debugger, which displays the current call stack in a treeview display in the process view for your application. In the event of an unexpected error the call stack is then available for you to analyse. You can also export the entire stack for future use.

Runtime debug messages

vbCodeShield can add the ability to output debug messages at runtime, allowing you to include useful diagnostic information in your project that can be seen using the vbCodeShield code window at runtime. All Debug.Print statements are automatically converted to runtime debug output requiring no manual intervention. Simply start the vbCodeShield Debugger, run your project and watch the messages appear.

SourceSafe Integration

vbCodeShield offers convenient SourceSafe integration features to make working with vbCodeShield supplemented source code easier. All of the features and optional and configurable on a project by project basis

Version control

vbCodeShield helps you ensure your version control history is complete by automatically checking in your original source code before building and checking in the supplemented code after. Labels can be added to identify the specific version of a project built. These features together ensure that you can never issue a component for which you do not have the source code with correct line numbers.

Instance Counting

A common problem in component programming is having object instances that do not terminate when expected. The most common cause is circular references where 2 object instances have references to each other that prevent them both from terminating. Circular references can cause problems such as ever increasing memory usage and even GPFs.

vbCodeShield adds functionality to your solution to enable object instance creation and termination to be tracked and therefore monitored. The vbCodeShield Debugger will identify any processes that terminate leaving un-terminated object instances and will provide a real time count of running object instances for any given class and also a history of when objects are created and terminated.

At startup, your project checks to see if the vbCodeShield Debugger is running - thereby reducing to a minimum any run-time overhead of including the instance counting functionality in your code.

Batch Compilation

vbCodeShield's Batch Compiler allows you to compile multiple projects using vbCodeShield processing and includes numerous advanced features.

Visual Basic and Visual Basic for Applications Integration

Innovasys vbCodeShield integrates directly into the IDE's of Visual Basic and Visual Basic for Applications, allowing you to easily compile your projects with the advanced functionality vbCodeShield provides.

Real-time Debugger

The vbCodeShield Debugger provides real-time view of the projects you compile using vbCodeShield with it's extended debugging facilities - view debug output messages, call and project stacks, instance counting and more.