Runtime Monitoring Agent

Designed and developed by Zoran M.Todorovic
and Miodrag D.Stojadinovic.

Often while developing an application, programmer needs an information
about a value of specific variable, time needed to execute a piece of code
or just plain info that some function/module has been entered/exited. Most
of these information can be collected using a debugger but, debugger interrupts
normal program execution (critical for communication programs) and doesn’t
give any time related info (for example, how long does it take to execute
an SQL statement or what is the time difference between sending a command
and receiving a response from a device connected to a serial port). Also,
once you build a release version, you lose any debugging capabilities unless
they are hard-coded into the program.

Most often, programmers use dump to file as a way to collect info but
it has several limitations. You cannot view info while program is running,
you lose some or all data if program crashes and it’s very difficult to
find something in a mass of data collected in this way.

That’s were Runtime Monitoring Agent (plain Agent in further
text) comes in !!!

Agent is a separate, stand-alone process which uses Win32 inter
process communication facilities to receive programmer defined messages
coming from a client process via an Agent DLL loaded into the client process.
Agent has an Explorer like user interface. One of the requirements we set
for the Agent was that it can be used with programming environments other
then C++ (for example, Delphi). This is the reason why the Agent is statically
linked with MFC and C++ runtime library (programmer doesn’t need anything
else but the Agent itself to run it on a target computer). Agent DLL
is a non-MFC DLL with a very small footprint. It is used for programming
environments like Delphi. For convenience and for Visual C++ projects,
there is also a C++ Agent LIB library which takes care of dynamically
loading the Agent DLL. It is also very small and will enable a process
to work even if Agent DLL is not found or Agent is not running.

Agent monitors a System — set of executable modules which are
part of a project programmer is working on. Module is either an executable
file or a DLL. Within a System, programmer defines processes. Process
is equivalent to a module (executable or DLL). Process can also be a part
of a module if it is convenient for a programmer (for example a special
worker thread). Each process contains one or more fibers. Fiber
is related to one function, algorithm or any other piece of code programmer
can think of. Each fiber contains one or more messages. Message
is at the lowest level and contains a user defined text (usually built
with a sprintf or CString in order to contain current values of program
variables) and optionally a Win32 error code. It can also contain a source
code file name and a line number from which a message is sent. Agent DLL
automatically adds a timestamp when the message is sent.

Some of the features of the Agent are:

  • Agent can be removed from the screen and left on a taskbar.

  • Stand-alone process requires neither MFC nor C++ runtime  library

  • Monitored session can be saved to disk and loaded later for analysis.

  • Agent can monitor complex projects containing several executables and DLLs.

  • User can select a combination of fibers to watch.

  • Within a list of messages, user can hide a selection of messages.

  • Win32 error codes are automatically expanded by Agent to their symbolic

  • We found Agent very useful for a variety of purposes. Some very difficult
    bugs (related to background worker threads, serial communications and time
    related problems with SQL Server) were eliminated with the help of an Agent.
    We are planning to add new features listed below:

  • Find a message containing line number, (sub)string or error code.

  • Automatically calculate time difference between two selected messages.

  • Automatically start the Agent when a client program starts.

  • Auto save feature.

  • Take it and try it. If you find it useful or if you have any suggestions
    or if you found a bug, please let us know. Agent started as a small utility
    to solve debugging related problems in a multithreaded communication program
    but it behaved so well that we redesigned a user interface and added some
    new features and this is the final result.

    Zip file ( contains the following:



  • Source code for an Agent.lib

  • Demo projects for an EXE and a DLL.

  • Manual in HTML format


    Download Files The zip file is 248K.

    More by Author

    Must Read