Comprehensive and Flexible

• Active Error recovery for apps and components
• Turns debugging into a straightforward process
• Easy distribution with lightweight royalty free runtime

Product Overview

ActiveError Foundation makes it possible for Visual Basic developers to create truly robust, reliable and supportable applications and components.

How?

ActiveError Foundation's Engine takes an active role in all aspects of managing the consequences of the error, rather than just passively catching the error and logging diagnostics.

The ActiveError Engine collapses the Call Stack with complete control after an error. This process of Active Stack Collapse drives many of Foundation's advanced capabilities including:

• TransActive Error Recovery
• ActiveError Propagation
• Firewalls
• ActiveRetry
• StackSpy

Features

ActiveError Engine

• Active Stack Collapse
  ActiveStack Collapse is the unique process that drives many of Foundation's advanced capabilities.
• TransActive Error Recovery
  TransActive Error Recovery is a structured recovery framework for code stability and reentrancy.

Procedures are handled as transactions encapsulating their own Recovery code. The ActiveError Engine executes Recovery code during Active Stack Collapse, recovering the application to its state before the error.

The TransActive Error Recovery framework lets you reset data, free resources, rollback database transactions, etc.

Your application stays as stable and reentrant as if the error NEVER even happened!

• StackSpy and Diagnostics
  Foundation's StackSpy technology uses stealth to dump the Call Stack during Active Stack Collapse.

This unique technology ensures that call stack diagnostics are always available, accurate, complete and... Free!... because, unlike brute force techniques, StackSpy inflicts no overhead on your application performance!

Foundation's diagnostics are fully extensible, letting you log any and all relevant information in addition to complete details of the Error and Call Stack.

• ActiveError Propagation
  ActiveError Propagation ensures that errors are correctly and safely propagated between Modules and Components of all types.

Your component project can "Throw" intended errors to clients, ActiveError Propagation transmits these errors seamlessly and silently.

Firewalls let you define logical application boundaries that contain the scope of error propagation within distinct parts of your project.

• ActiveRetry
  ActiveRetry can automatically perform a defined number of periodic Retries, helping your application to recover from transient environment or resource problems. ActiveRetry leverages the ActiveError Engine to perform complete and clean Retries, with resources being released and re-acquired afresh.
• Tracing
  Procedure Call Tracing allows you to monitor exact execution paths and sequences through your code, helping to diagnose errors and behaviors caused by Event Cascading, DoEvents calls, Timers, etc. Tracing can be directed to a file or a window, can be configured selectively and can be used at runtime as well as at design time.
• API Errors
  ActiveError Foundation can convert all API errors seamlessly into Visual Basic errors, logging the API result code and its associated error description, then handling and recovering the error normally.
• Exception Handling
  Unhandled exceptions normally crash your application immediately with no chance for recovery or useful diagnostics. Such exceptions can be caused by incorrect API calls, third-party components and the use of advanced Visual Basic techniques. ActiveError Foundation can trap all Exceptions and handle them seamlessly as Visual Basic errors, logging the Exception code and its associated error description, then handling and recovering the error normally.

ActiveError Framework

• ActiveError Templates
  ActiveError Templates define an error handling structure that works in precise combination with the ActiveError Engine. You can create custom Templates that conform to your own layout and naming standards and preferences.
• ActiveError Handlers
  ActiveError Handlers based on ActiveError Templates, effectively create an ActiveError Framework for your project.

The precise way in which the ActiveError Engine handles errors within the framework is configured via ActiveError Properties within the ActiveError Handlers.

• Severity Categorization
  ActiveError Foundation lets you categorize errors by Severity, Cosmetic Errors are Logged silently, Normal Errors are Logged and Recovered, Fatal Errors are Logged and the application allowed to close down tidily.
• Inline Error Handling
  You can use Inline Error Handling to check for expected errors and let ActiveError Foundation pick up the unexpected errors in the normal way. ActiveRetry even allows Inline errors to be retried by configuring for Retry at the Procedure level.
• Seamless Design Time Operation
  ActiveError Foundation operates seamlessly in your project at Design Time keeping execution paths and behavior consistent at design time and at runtime.

Interactive debugging in the Visual Basic IDE is fully preserved and is actually enhanced by the immediate availability of diagnostic data.

ActiveError Foundation Builder

• Comprehensive & Flexible Tool Support
  Foundation Builder automates the fitting of ActiveError Handlers and configuring ActiveError Properties.

Builder is more than a Wizard, it's a Rule driven expert system which creates and maintains the ActiveError Framework for your project.

Builder's Explorer style interface is highly flexible to support the way you want to work, from bulk insertions to fine detail adjustments.

• ActiveError Expert
  Builder's ActiveError Property Expert analyses your project in detail and can automatically maintain the core Properties of the ActiveError Framework.

Property Expert intelligently analyses your project considering Project and Module Types, Instancing, Scope, "WithEvents" and "Implements" statements, etc.

• Smart Line Numbering
  Smart Line Numbering gives you complete control of how Line Numbering is applied, if at all.

Line Numbering pinpoints the exact error line, but carries unavoidable overheads. Smart Line Numbering let you define the exact benefit/overhead trade-off point, and even to change that point at different stages of your development cycle.