MQL Plus Enhanced Debugging Support – library MetaTrader 5

Here you can see how a permanent integration would look like, this is useful for different cases. One scenario could be if you are debugging different asset types and run into issues, depending on symbol specifications. Another scenario would be when building a GUI and having performance or function integration issues. 

Again some output from the example code:

Example LibDebug_Integrated.mq5:

#property version   "1.01"
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//  Additional options for LIB_DEBUG
//
//      LIB_DEBUG_MQLAPI_TRACE
//
//          MQL API function call tracing support. This will log calls to MQL built-in functions.
//          "LIB_DEBUG_MQLAPI_TRACE" will enable this feature. You will get trace output, if you have
//          LIB_DEBUG built-in tracing for the particular function enabled. - See example below on how to
//          integrate tracing of a function.
//
//          Functions for which tracing is activated, see description below, will now
//          also log calls to MQL-API functions. The error code and return type will be logged.
//
//
//      !!! IMPORTANT NOTE !!!
//
//          MQL-API-Function tracing is incompatible with the standard library from MQL.
//          You will receive compiler errors, if activated and using standard-library.
//
//          If you wish to do so anyways, move forward to "Custom Integration" below
//          to learn how you could do it anyways.
//
//
//      LIMITATION when using LIB_DEBUG_MQLAPI_TRACE
//
//          If you are callling an MQL function on global scope, you must do so before
//          including lib_debug.mqh.
//
//          Example:
//
//              // Global MQL function calls must happen before "#include lib_debug"
//              const string files  = TerminalInfoString(TERMINAL_DATA_PATH) + "\MQL5\files\";
//              const uint ticks    = GetTickCount();
//
//              // Include lib_debug
//              #define LIB_MQLAPI_TRACE
//              #include <MQLpluslib_debug.mqh>
//
//          These global calls will not be tracked.
//



/////////////////////////////////////////
//
// Include the library
//

// Debugging domain
#define LIB_DEBUG
// Additional options
//#define LIB_DEBUG_AUTOENABLE
//#define LIB_DEBUG_LOGFILE
//#define LIB_DEBUG_NO_JOURNAL_OUTPUT
//#define LIB_DEBUG_MQLAPI_TRACE


// Tracing domain
//#define LIB_MQLAPI_TRACE
// Additional options
//#define LIB_MQLAPI_TRACE_PERFORMANCE
//#define LIB_MQLAPI_TRACE_SHOW_PARAMS
//#define LIB_MQLAPI_TRACE_SHOW_RESULT

// Performance domain
//#define LIB_PERF_PROFILING

// File inclusion
//#include "lib_debug_CustomConfig.mqh"
#include <MQLplus/lib_debug.mqh>





///////////////////////////////////////////////////////////////////////
//
// In OnInit you can see a simple usage of the debugging macros.
//

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
    //////////////////////////////////////////////////////////////
    //
    // Simple output macros
    //

    // Some initial debug message
    DBG_MSG("Example how to use lib_debug.mqh as project integrated version.");

    // Output details about current program
    //  Available in debugging and runtime
    printf("%s", DBG_STR_EX45_FILEINFO);

    // Keep this message also in runtime builds
    DBG_MSG_PERSIST("Persistent message in debug and runtime (Runtime is without debug details)");

    // Return
    return(INIT_SUCCEEDED);
}



///////////////////////////////////////////////////////////////////////
//
// In OnDeinit we will use full tracing of the function call.
//
//  First we define some helpers for compile time code
//  inclusion selection. This will make it easy to enable/disable
//  function tracing as needed.
//
//  To do this, first a macro is defined which will be used as a
//  switch (defined = trace function) (not defined = disable tracing)
//
//  We can collect these "switches" at top of file for a better overview
//  Also we could wrap them into a condition, so that they will only be
//  defined when debugging is enabled.
//
//  Example:
//  #ifdef LIB_DEBUG
//      #define DBG_TRACE_EXPERT_MAIN_ONDEINIT
//
//  #endif

// En/Disable function tracing by commenting following macro:
#define DBG_TRACE_EXPERT_MAIN_ONDEINIT


// Now we define the helper macros which will be used inside
//  the functions body.

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
/////////////////////////////////////
// Function debug trace code
#ifdef DBG_TRACE_EXPERT_MAIN_ONDEINIT
    #undef DBG_TRACE_EXPERT_MAIN_ONDEINIT
    #define DBG_TRACE_EXPERT_MAIN_ONDEINIT(x) x
    #define DBG_TRACE_EXPERT_MAIN_ONDEINIT_RETURN       DBG_MSG_TRACE_RETURN

#else
    #define DBG_TRACE_EXPERT_MAIN_ONDEINIT(x)
    #define DBG_TRACE_EXPERT_MAIN_ONDEINIT_RETURN       DBG_MSG_NOTRACE_RETURN

#endif
/////////////////////////////////////
void OnDeinit(const int reason)
{
    /////////////////////////////////////
    //
    // TOP of function body
    //
    // Here the tracing code gets included, this is mandatory for tracing to work.
    // The switching macro can also be used to include additional
    // debugging code, if any is required, see example below.
    DBG_TRACE_EXPERT_MAIN_ONDEINIT(
        DBG_MSG_TRACE_BEGIN;

        // Additional details can be added here, as required.
        // For example to trace the inputs to this function, we can add
        DBG_MSG_VAR(reason);

        // Or whatever we would like to add.
        );

        // Additionally the macro "PERF_COUNTER_BEGIN" must be added.
        // It is mandatory to complete the "return" macro, irrespective of it
        // being used or not. (Any insertions will be removed for runtime builds,
        // if "LIB_PERF_PROFILING" is not defined)
        PERF_COUNTER_BEGIN;

    //
    // This concludes the functions head
    //  control code required for tracing.
    //  If tracing is disabled for this function,
    //  all additional code will be stripped at
    //  compile time.
    //
    //  Now follows the actual functions body:
    /////////////////////////////////////


    // Local init

        int     some_int_val    = 3;
        string  some_string     = "I dont know";

        /////////////////////////////////////
        //
        // As an example, here the local variables
        //  are printed, but only if tracing is enbaled.
        //  In contrast to the usage of macros in OnInit, where
        //  the macros were not wrapped in the
        //  Trace-Enable-Disable macro.
        //
        DBG_TRACE_EXPERT_MAIN_ONDEINIT(
            DBG_MSG_VAR(some_int_val);
            DBG_MSG_VAR(some_string);
            );


    // Destroy timer

        EventKillTimer();



    /////////////////////////////////////
    //
    // EXITING/RETURNING from the fucntions body.
    //
    // A return statement is mandatory, no matter the functions signature.
    // This will inform the debug library about the functions ending/exiting.
    //
    //  The special function "OnDeinit" will auto-resolve the deinit reason
    //  and show the state of the _StopFlag/IsStopped() variable.
    //  This is automatically inserted and needs no extra care taking.
    //
    DBG_TRACE_EXPERT_MAIN_ONDEINIT_RETURN;
}



///////////////////////////////////////////////////////////////////////
//
// In OnTick we will use full tracing of the function call as
//  shown with OnDeinit, and we will integrate global performance
//  counters as well. This will give output of the runtime used by
//  this function.
//
//  Since the tracing has already been exlained, here is a
//  stripped version, showing the raw requirements for a full trace.
//
//  Short outline.
//  - First define the enable/disable macros.
//  - Then include the head required inside the body.
//  - Use the return macro at all exit points of the function.
//
//  To enable tracing for this function, same procedure as
//  with OnDeinit applies.
//  Again, this could be collected at top of file for better oversight.

// Turn on tracing
#define DBG_TRACE_EXPERT_MAIN_ONTICK


//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
/////////////////////////////////////
// Function debug trace code
#ifdef DBG_TRACE_EXPERT_MAIN_ONTICK
    #undef DBG_TRACE_EXPERT_MAIN_ONTICK
    #define DBG_TRACE_EXPERT_MAIN_ONTICK(x) x
    #define DBG_TRACE_EXPERT_MAIN_ONTICK_RETURN         DBG_MSG_TRACE_RETURN

#else
    #define DBG_TRACE_EXPERT_MAIN_ONTICK(x)
    #define DBG_TRACE_EXPERT_MAIN_ONTICK_RETURN         DBG_MSG_NOTRACE_RETURN

#endif
/////////////////////////////////////
void OnTick()
{
DBG_TRACE_EXPERT_MAIN_ONTICK(
    DBG_MSG_TRACE_BEGIN;
    );
PERF_COUNTER_BEGIN;

    // Local init
    int some_var = MathRand();
    DBG_MSG_VAR(some_var);


    // Some random check operation
    if((some_var % 2) == 0)
    {
        call_sub_function();
        call_sub2_function();
        call_obj_function();
    }


    // Some eventual exit at annother point inside the functions body
    if((some_var % 2048) == 0)
    { DBG_TRACE_EXPERT_MAIN_ONTICK_RETURN; }


    // Return
    DBG_TRACE_EXPERT_MAIN_ONTICK_RETURN;
}



///////////////////////////////////////////////////////////////////////
//
// In call_sub_function we will use full tracing of the function call.
//
//  This example shows the difference for a function with
//  a return value.
//
//  Take notice of the used macros. - It is required to use a
//  different return macro for this type of function call.
//
//  Instead of using the macro "DBG_MSG_TRACE_RETURN" and "DBG_MSG_NOTRACE_RETURN"
//  here the macros "DBG_MSG_TRACE_RETURN_VAR(x)" and "DBG_MSG_NOTRACE_RETURN_VAR(x)"
//  are used.
//
//  IMPORTANT NOTICE:
//      Calling the macro with the parameter "NULL" requires!!! a cast operation.
//      (This functions return value is "int", "const int" or "int" doesnt make a difference)
//
//      Example:
//      DBG_MSG_TRACE_RETURN_VAR((int)NULL);
//
//      This cast operation can be included in the macro definition itself, like this:
//      #define DBG_TRACE_EXPERT_MAIN_CALL_SUB_FUNCTION_RETURN(x) DBG_MSG_TRACE_RETURN_VAR((int)x)
//      #define DBG_TRACE_EXPERT_MAIN_CALL_SUB_FUNCTION_RETURN(x) DBG_MSG_NOTRACE_RETURN_VAR(x)
//
//      or inside the function using the custom defined macro:
//      DBG_TRACE_EXPERT_MAIN_CALL_SUB_FUNCTION_RETURN((int)NULL);
//
//      See second function example below.
//      Here the cast operation is inside the functions body.
//
//  NOTE on CAST-Operation:
//      The runtime macro does not require the cast operation.
//      You should include the cast-operation as shown in second example. If it is included
//      in the functions body, it will be also part of the runtime-code and not being stripped
//      from your code by the library.
//
// Again the enbale trace macro needs to be defined, so tracing
//  is enabled.

// Enable tracing of this function
#define DBG_TRACE_EXPERT_MAIN_CALL_SUB_FUNCTION

//+------------------------------------------------------------------+
//| Example function with return value                               |
//+------------------------------------------------------------------+
/////////////////////////////////////
// Function debug trace code
#ifdef DBG_TRACE_EXPERT_MAIN_CALL_SUB_FUNCTION
    #undef DBG_TRACE_EXPERT_MAIN_CALL_SUB_FUNCTION
    #define DBG_TRACE_EXPERT_MAIN_CALL_SUB_FUNCTION(x) x
    #define DBG_TRACE_EXPERT_MAIN_CALL_SUB_FUNCTION_RETURN(x) DBG_MSG_TRACE_RETURN_VAR(x)

#else
    #define DBG_TRACE_EXPERT_MAIN_CALL_SUB_FUNCTION(x)
    #define DBG_TRACE_EXPERT_MAIN_CALL_SUB_FUNCTION_RETURN(x) DBG_MSG_NOTRACE_RETURN_VAR(x)

#endif
/////////////////////////////////////
const int call_sub_function()
{
DBG_TRACE_EXPERT_MAIN_CALL_SUB_FUNCTION(
    DBG_MSG_TRACE_BEGIN;
    );
PERF_COUNTER_BEGIN;

    // Do some stuff
    if(MathRand() == 5)
    { DBG_TRACE_EXPERT_MAIN_CALL_SUB_FUNCTION_RETURN(5); }

    // Return
    DBG_TRACE_EXPERT_MAIN_CALL_SUB_FUNCTION_RETURN((int)NULL);
}



// Enable tracing of this function
#define DBG_TRACE_EXPERT_MAIN_CALL_SUB2_FUNCTION

//+------------------------------------------------------------------+
//| Example function with return value                               |
//+------------------------------------------------------------------+
/////////////////////////////////////
// Function debug trace code
#ifdef DBG_TRACE_EXPERT_MAIN_CALL_SUB2_FUNCTION
    #undef DBG_TRACE_EXPERT_MAIN_CALL_SUB2_FUNCTION
    #define DBG_TRACE_EXPERT_MAIN_CALL_SUB2_FUNCTION(x) x
    #define DBG_TRACE_EXPERT_MAIN_CALL_SUB2_FUNCTION_RETURN(x) DBG_MSG_TRACE_RETURN_VAR((int)x)

#else
    #define DBG_TRACE_EXPERT_MAIN_CALL_SUB2_FUNCTION(x)
    #define DBG_TRACE_EXPERT_MAIN_CALL_SUB2_FUNCTION_RETURN(x) DBG_MSG_NOTRACE_RETURN_VAR(x)

#endif
/////////////////////////////////////
const int call_sub2_function()
{
DBG_TRACE_EXPERT_MAIN_CALL_SUB2_FUNCTION(
    DBG_MSG_TRACE_BEGIN;
    );
PERF_COUNTER_BEGIN;

    // Do some stuff
    if(MathRand() == 12)
    { DBG_TRACE_EXPERT_MAIN_CALL_SUB2_FUNCTION_RETURN(12); }

    // Return
    DBG_TRACE_EXPERT_MAIN_CALL_SUB2_FUNCTION_RETURN(NULL);
}







// A local class
class CObj
{
    public:
    int test;

    CObj() :
        test(NULL)
    { };

    CObj(const CObj& p_in)
    {
        test = p_in.test;
        printf("%s", "COPY");
    };


};

// Enable tracing of this function
#define DBG_TRACE_EXPERT_MAIN_CALL_OBJ_FUNCTION


//+------------------------------------------------------------------+
//| Example function with return object                              |
//+------------------------------------------------------------------+
/////////////////////////////////////
// Function debug trace code
#ifdef DBG_TRACE_EXPERT_MAIN_CALL_OBJ_FUNCTION
    #undef DBG_TRACE_EXPERT_MAIN_CALL_OBJ_FUNCTION
    #define DBG_TRACE_EXPERT_MAIN_CALL_OBJ_FUNCTION(x) x
    #define DBG_TRACE_EXPERT_MAIN_CALL_OBJ_FUNCTION_RETURN(x) DBG_MSG_TRACE_RETURN_VAR(x)

#else
    #define DBG_TRACE_EXPERT_MAIN_CALL_OBJ_FUNCTION(x)
    #define DBG_TRACE_EXPERT_MAIN_CALL_OBJ_FUNCTION_RETURN(x) DBG_MSG_NOTRACE_RETURN_VAR(x)

#endif
/////////////////////////////////////
CObj call_obj_function()
{
DBG_TRACE_EXPERT_MAIN_CALL_OBJ_FUNCTION(
    DBG_MSG_TRACE_BEGIN;
    );
PERF_COUNTER_BEGIN;

    // Local init
    CObj    test_obj;
    CObj*   test_ptr = new CObj();
    Print("1");

    DBG_TRACE_EXPERT_MAIN_CALL_OBJ_FUNCTION(
        DBG_MSG_VAR(1);
        DBG_MSG_VAR(test_obj);
        DBG_MSG_VAR(test_ptr);
        );

    // Do some stuff
    if(MathRand() == 12)
    { DBG_TRACE_EXPERT_MAIN_CALL_OBJ_FUNCTION_RETURN(test_obj); }

    // Return
    DBG_TRACE_EXPERT_MAIN_CALL_OBJ_FUNCTION_RETURN(test_obj);
}

---

Advanced debugging

Some additional advanced debugging macros to support more complex situations.

Output of the example code:

Example LibDebug_Advanced.mq5:

#property version   "1.01"
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//  Advanced debugging
//
//  Example of more complex debugging situations.
//






/////////////////////////////////////////
//
// Include the library
//

// Debugging domain
#define LIB_DEBUG
// Additional options
//#define LIB_DEBUG_AUTOENABLE
//#define LIB_DEBUG_LOGFILE
//#define LIB_DEBUG_NO_JOURNAL_OUTPUT
//#define LIB_DEBUG_MQLAPI_TRACE


// Tracing domain
//#define LIB_MQLAPI_TRACE
// Additional options
//#define LIB_MQLAPI_TRACE_PERFORMANCE
//#define LIB_MQLAPI_TRACE_SHOW_PARAMS
//#define LIB_MQLAPI_TRACE_SHOW_RESULT

// Performance domain
//#define LIB_PERF_PROFILING

// File inclusion
//#include "lib_debug_CustomConfig.mqh"
#include <MQLplus/lib_debug.mqh>





///////////////////////////////////////////////////////////////////////
//
// In OnInit you can see a simple usage of the debugging macros.
//

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
    //////////////////////////////////////////////////////////////
    //
    // Simple output macros
    //

    // Some initial debug message
    DBG_MSG("Example how to use lib_debug.mqh");

    // Output details about current program
    //  Available in debugging and runtime
    printf("%s", DBG_STR_EX45_FILEINFO);

    // Keep this message also in runtime builds
    DBG_MSG_PERSIST("Persistent message in debug and runtime (Runtime is without debug details)");

    // Activate chart events
    ChartSetInteger(ChartID(), CHART_EVENT_MOUSE_MOVE, true);

    // Return
    return(INIT_SUCCEEDED);
}



//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
/////////////////////////////////////
// Function debug trace code
#ifdef DBG_TRACE_EXPERT_MAIN_ONDEINIT
    #undef DBG_TRACE_EXPERT_MAIN_ONDEINIT
    #define DBG_TRACE_EXPERT_MAIN_ONDEINIT(x) x
    #define DBG_TRACE_EXPERT_MAIN_ONDEINIT_RETURN       DBG_MSG_TRACE_RETURN

#else
    #define DBG_TRACE_EXPERT_MAIN_ONDEINIT(x)
    #define DBG_TRACE_EXPERT_MAIN_ONDEINIT_RETURN       DBG_MSG_NOTRACE_RETURN

#endif
/////////////////////////////////////
void OnDeinit(const int reason)
{
DBG_TRACE_EXPERT_MAIN_ONDEINIT(
    DBG_MSG_TRACE_BEGIN;
    DBG_MSG_VAR(reason);
    );
    PERF_COUNTER_BEGIN;

    // Local init

        int     some_int_val    = 3;
        string  some_string     = "I dont know";

        DBG_TRACE_EXPERT_MAIN_ONDEINIT(
            DBG_MSG_VAR(some_int_val);
            DBG_MSG_VAR(some_string);
            );


    // Destroy timer

        EventKillTimer();

    // Return
    DBG_TRACE_EXPERT_MAIN_ONDEINIT_RETURN;
}




///////////////////////////////////////////////////////////////////////
//
// In OnTick we will use additional debug-break and
//  loop tracing macros as wel las some DBG_MSG_EVAL_* statements
//

// Turn on tracing
#define DBG_TRACE_EXPERT_MAIN_ONTICK


//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
/////////////////////////////////////
// Function debug trace code
#ifdef DBG_TRACE_EXPERT_MAIN_ONTICK
    #undef DBG_TRACE_EXPERT_MAIN_ONTICK
    #define DBG_TRACE_EXPERT_MAIN_ONTICK(x) x
    #define DBG_TRACE_EXPERT_MAIN_ONTICK_RETURN         DBG_MSG_TRACE_RETURN

#else
    #define DBG_TRACE_EXPERT_MAIN_ONTICK(x)
    #define DBG_TRACE_EXPERT_MAIN_ONTICK_RETURN         DBG_MSG_NOTRACE_RETURN

#endif
/////////////////////////////////////
void OnTick()
{
DBG_TRACE_EXPERT_MAIN_ONTICK(
    DBG_MSG_TRACE_BEGIN;

    // DebugBreak by call-counter condition
    //  This macro will DebugBreak if the call-counter
    //  of this function has reached a given value.
    //
    // This macro is only available, if tracing
    //  for this function is enabled.
    DBG_BREAK_CALL_COUNTER(25);

    );
PERF_COUNTER_BEGIN;

    // Local init
    MathSrand(GetTickCount());
    int some_var = MathRand();


    //////////////////////////////////////////////////////////
    //
    // Analyze the run of a simple loop
    //
    //  These macros can only be used once per
    //  function body or scope { }
    //
    DBG_TRACE_LOOP_BEGIN;
    for(int cnt = NULL; (cnt < 500) && !_StopFlag; cnt++)
    {
        DBG_TRACE_LOOP_START;

            /* Have your code here */

            some_var = MathRand();

        DBG_TRACE_LOOP_FINISH;
    }
    DBG_TRACE_LOOP_END;



    //////////////////////////////////////////////////////////
    //
    // Analyze the run of a nested loop
    //
    //  Here we will use explizit IDs to identify
    //  each loop.
    //
    DBG_TRACE_LOOP_BEGIN_ID(outer_loop);
    for(int cnt = NULL; (cnt < 25) && !_StopFlag; cnt++)
    {
        DBG_TRACE_LOOP_START_ID(outer_loop);

            /* Have your code here */
            some_var = MathRand();

            DBG_TRACE_LOOP_BEGIN_ID(inner_loop);
            while(DBG_MSG_EVAL_IF_CMNT((some_var % 1024) == 0, StringFormat("Outer loop counter: %i", cnt), (some_var % 1024) != 0))
            {
                DBG_TRACE_LOOP_START_ID(inner_loop);

                /* Have your code here */
                some_var = MathRand();

                DBG_TRACE_LOOP_FINISH_ID(inner_loop);
            }
            DBG_TRACE_LOOP_END_ID(inner_loop);


        DBG_TRACE_LOOP_FINISH_ID(outer_loop);
    }
    DBG_TRACE_LOOP_END_ID(outer_loop);




    // Some eventual exit at annother point inside the functions body
    some_var = MathRand();

    if(DBG_MSG_EVAL_CMNT("Going to alternate exit??", (some_var % 2048) == 0))
    { DBG_TRACE_EXPERT_MAIN_ONTICK_RETURN; }


    // Here is a simple debug break on condition
    DBG_BREAK_IF(some_var == 256);


    // Return
    DBG_TRACE_EXPERT_MAIN_ONTICK_RETURN;
}



///////////////////////////////////////////////////////////////////////
//
// In OnChartEvent we will use some advanced break-point conditions
//
//  Following macros will be used
//
//      DBG_BREAK_CONDITION_CREATE(x, y)
//      DBG_BREAK_CONDITION_ACTIVATE(x, y)
//      DBG_BREAK_CONDITION_DEACTIVATE(x, y)
//      DBG_BREAK_CONDITION_ON_ID(x)
//      DBG_BREAK_CONDITION_ON_ID_RESET(x)
//
// With these macros we can create complex break conditions
//  across the whole program, tese are not bound to the local function.
//  It is possible to have some part of the code create a break-condition,
//  but do the actual break at some totally unrelated point in the code.
//
//  Of course, the breakpoint will only work if it is after the
//  condition has been met. Or, with the next, repetitive call of the
//  function.
//
//  Following example shal demonstratte the usage
//


// Create a break condition.
//
//  For global governance of breakpoints,
//  the second parameter is available. If this is set to false,
//  this breakcondition is globally deactivated.
//
DBG_BREAK_CONDITION_CREATE(mouse_event, true);


//+------------------------------------------------------------------+
//| ChartEvent function                                              |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
{
    // We want to debug break on mouse event click.
    //  These macros can be spread over the code, no metter the
    //  actual location. Complex dependencies can be easily debugged
    //  this way. You can reference any group as often as you like.
    //
    //  Also multiple references to the same group will work.
    //  If any of them resolves to true, the breakpoint is activated.
    //  It will stay active until it is being disabled.
    //
    DBG_BREAK_CONDITION_ACTIVATE(mouse_event, id == CHARTEVENT_CLICK);


    // Somewhere else in the code, we would now like to DebugBreak to this condition.
    //  Maybe at the point where we need the break, we dont even have the variable
    //  available to know if the current event is a "CHARTEVENT_OBJECT_CLICK".
    //  So we set the breakpoint like this. - Remember, this can be anywhere in the code.
    //  As soon as the conditon has been met, any mentioning of this macro will
    //  halt execution until it is cleard by "DBG_BREAK_CONDITION_DEACTIVATE"
    //
    DBG_BREAK_CONDITION_ON_ID(mouse_event);


    // Alternatively, you can use the break-reset macro, to clear the break conditon
    //
    DBG_BREAK_CONDITION_ON_ID_RESET(mouse_event);


    // Lets say, we would only want to break, if no tick has arrived since
    //  this event was activated. For this we could now place following code in
    //  OnTick(), maybe directly at the top of the function.
    //
    DBG_BREAK_CONDITION_DEACTIVATE(mouse_event, true);


    // Return
    return;
}

You can customize this library to your personal and project specific needs. Especially if you integrate the library permanently, this might be of interest to you.

But even if not, you can make changes to the library and add additional code to the API-Tracer module, if required.

To do so, go to MQLplus/Lib_debug and find the file lib_debug_CustomConfig.mqh, copy the file and make appropiate changes to it, as required.

Here is the content of this file. – Everything should be documented for you to make che required additions and changes.

#ifndef LIB_DBG_DEBUG_MQLAPI_CUSTOMCONFIG_MQH_INCLUDED
#define LIB_DBG_DEBUG_MQLAPI_CUSTOMCONFIG_MQH_INCLUDED
#property version   "5.10"
/**********************************************************************************
 * No Copyright (C) applied.
 * No Lisence applied.
 *
 * This file is the lib_debug custom config include file.
 *
 **********************************************************************************
 *
 *  Version: 5.10
 *  State: public
 *
 *  File information
 *  ================
 *
*/



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// !!! NOTE !!!
//
//      In case you have reached this file because you would like to exclude some functions from being
//      traced by the library, following suggestion to not edit the distribution-file, you are looking at
//      right now.
//
//
//  Make a copy of this file.
//
//      Copy the file to your project and make your required changes in the copy, instead of this file.
//      It is quite unlikely this file will change much in the future, therefore making copies will
//      not interfere with any updates to lib_debug. - This way you can update to any newer version
//      without loosing your changes.
//
//
//  Handle project specifics
//
//      After making a copy of this file rename it to your convenience.
//      Now change the include in your main project from:
//
//          #include <MQLplus/lib_debug.mqh>
//
//      to >this copied file<, ie:
//
//          #include "my_renamed_lib_debug_CustomConfig.mqh"
//
//      Note the enclosure used, but I guess, since you reached this file, you are familiar with this.
//      Rename it to whatever you like. - You should include the name of the project, (for your future self...)
//      I.E: lib_debug_CustomConfig.mqh >>> lib_debug_MyProjectname.mqh
//
//
//  Use this file for your project
//
//      Now you just use this file as if it were the original include file from the distribution (lib_debug.mqh).
//      Apply your switches and changes as they are required for your project.
//      Integration is seemless and you will have a project specific lib_debug configuration.
//
//      Make changes to this file as required.
//
//
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////





/////////////////////////////////////////////////////////////////////////////////////////////////////
//
// LIB_DEBUG custom project configuration settings
//

//#define LIB_DEBUG
//#define LIB_DEBUG_AUTOENABLE
//#define LIB_DEBUG_LOGFILE
//#define LIB_DEBUG_NO_JOURNAL_OUTPUT
//#define LIB_DEBUG_MQLAPI_TRACE
//#define LIB_MQLAPI_TRACE
#define LIB_MQLAPI_TRACE_CUSTOM_EXTENSION
//#define LIB_PERF_PROFILING


//
/////////////////////////////////////////////////////////////////////////////////////////////////////





/////////////////////////////////////////////////////////////////////////////////////////////////////
//
// MT4/5 API remove function from the MQLAPI tracer
//
//
//  You can exclude any function from the tracer as your project needs it.
//
//  Use DBG_MQLAPI_NOTRACE_*** to remove a function from the tracer module.
//  You can remove any function from the tracer this way.
//
//  See example below.
//
//      For a complete list of all traced functions, see file
//          "MQLplus/lib_debug/lib_debug_mqlapi_tracer_overwrite_macros.mqh"
//

// This will remove 'Alert' function from the tracer module
//#define DBG_MQLAPI_NOTRACE_Alert

// This will remove 'round' function from the tracer module
//#define DBG_MQLAPI_NOTRACE_round


//
/////////////////////////////////////////////////////////////////////////////////////////////////////





/////////////////////////////////////////////////////////////////////////////////////////////////////
//
// LIB_DEBUG customize the API-Tracer to trace your own functions
//
//
//  1. Your function definition must be included first.
//
//      #include "your_custom_function_definitions.mqh"
//
//      // Now include this file instead of "lib_debug.mqh"
//      #include ">this...file<"
//
//
//  2. Inform the library of your custom extensions
//
//      If this is not defined, your custom extensions will not be loaded
//      this way you can turn them on and off as required. You can also
//      define this in your main file, outside of this file. Do so before you
//      include this file.
//      #define LIB_MQLAPI_TRACE_CUSTOM_EXTENSION
//
//
//  3. Write the tracer code as required
//
//      Now add your functions to this class for which you want tracing code to be injected
//      Follow the examle below to see how it is done.
//
//
//
/////////////////////////////////////////////////////////////////////////////////////////////////////





// Include trace code wrapper
#include <MQLplus/lib_debug/lib_debug_mqlapi_definitions.mqh>
#ifdef LIB_MQLAPI_TRACE_CUSTOM_EXTENSION
/////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Custom extension begin
//
#ifdef __MQL5__
    namespace dbg_lib {

#endif

    // API Tracer Object
    class LIB_DBG_MQLAPI_TRACER_CUSTOM_OBJECT
    { public:
    /********************************************************************************************************************************************************************
    *
    *
    *   YOUR CUSTOM CODE BEGINS HERE...
    *
    */


        /////////////////////////////////////////////////////////////////////////////////////////////////////
        //
        // Define the functions you want to trace
        //
        //  Function name must begin with
        //      "dbg_userapi_trace_func_"
        //  and then add your actual function name.
        //
        //
        // Example, this is your function you would like to trace
        //
        //  This function is defined somewhere in before included
        //  include file. "your_custom_function_definitions.mqh"
        //
        //      template <typename T>
        //      bool MyArraySort(T& array[]) { /* your function code body here */ };
        //
        // Important is parameter signatures of the functions
        //  are the same, see below.
        //
        /////////////////////////////////////////////////////////////////////////////////////////////////////





        /////////////////////////////////////////////////////////////////////////////////////////////////////
        //
        // Custom function with a return value
        //

            ////////////////////////////////////////////////////////
            //
            // Define the function wrapper
            //
            //  Wrapper function name must start with
            //  "dbg_userapi_trace_func_"
            //

            // Here we will use a templated function, you could use also normal functions.
            template <typename T>

            // The functino name must begin with "dbg_userapi_trace_func_", followed by your actual function name
            bool dbg_userapi_trace_func_MyArraySort(T& array[])
            {
                // Define the return value of your function
                DBG_USERAPI_RETURN_TYPE(bool);


                // Call the setup-macro for code tracing
                //  Takes in one argument, a name to identify your API.
                DBG_USERAPI_TRACE_SETUP("MyAPI");


                // Load the input parameters onto the tracer output stack,
                //  The macro must be filled with all 8 parameters.
                //  The first parameter is the count of arguments (1-7).
                DBG_USERAPI_PARAMS(1, array, 0, 0, 0, 0, 0, 0);


                // Now call your actual function, just as you would do in your normal code.
                retval = MyArraySort(array);


                // Load the output parameters onto the tracer output stack
                //  The macro must be filled with all 8 parameters.
                //  The first parameter is the count of arguments (1-7).
                DBG_USERAPI_RESULTS(1, array, 0, 0, 0, 0, 0, 0);


                // Output will be printed in case _LastError is not ERR_SUCCES / ERR_NO_ERROR
                //
                // For customization, it is possible to force printing, regardless of _LastError
                //  Insert the macro "DBG_USERAPI_PRINT_PARAMS" for printing input parameters.
                //  Insert the macro "DBG_USERAPI_PRINT_RESULT" for printing results.
                //
                //  If omitted, the default settings will apply.
                //DBG_USERAPI_PRINT_PARAMS;
                //DBG_USERAPI_PRINT_RESULT;


                // Call the finalize-macro for code tracing
                DBG_USERAPI_TRACE_FINALIZE;

                // Return the result from your function
                return(retval);
            };


            ////////////////////////////////////////////////////////
            //
            // Define the function replacement macro
            //
            //  If this is not defined, tracing will be disabled.
            //  The macro takes in one argument.
            //
            //  NOTE
            //      Define this after the wrapper function,
            //      else you will receive a 'Stack overflow'
            //      error.
            //
            #define MyArraySort                         DBG_USERAPI_TRACE_FUNCTION(MyArraySort)


        //
        /////////////////////////////////////////////////////////////////////////////////////////////////////






        /////////////////////////////////////////////////////////////////////////////////////////////////////
        //
        // Custom function of VOID-Type
        //

            ////////////////////////////////////////////////////////
            //
            // Define the function wrapper
            //
            //  Wrapper function name must start with
            //  "dbg_userapi_trace_func_"
            //
            void dbg_userapi_trace_func_MyPersonalVoidFunc(int arg01, int arg02, int arg03, int arg04, int arg05, int arg06, datetime arg07, string& arg08, color arg09, double arg10)
            {
                // Define the return value to be of type void.
                DBG_USERAPI_RETURN_TYPE_VOID;


                // Call the setup-macro for code tracing
                //  Takes in one argument, a name to identify your API
                DBG_USERAPI_TRACE_SETUP("MyAPI");


                // Load the input parameters onto the tracer output stack,
                //  The macro must be filled with all 8 parameters.
                //  The first parameter is the count of arguments.
                //
                //  Note the ordering of calls, the pushing to the stack
                //  is in reverse order, last arguments first.
                //
                //  arg08 is omitted here, because it is used as the output
                //  and therefore not relevant to us as an input to the function.
                //
                DBG_USERAPI_PARAMS(2, arg09, arg10, 0, 0, 0, 0, 0);
                DBG_USERAPI_PARAMS(7, arg01, arg02, arg03, arg04, arg05, arg06, arg07);


                // Some custom code, which will be part of the tracer output.
                // As an example, we will measure the runtime of this function
                // and print the result as part of the output stack.
                ulong runtime = GetMicrosecondCount();

                // Now call your actual function, just as you would do in your normal code.
                MyPersonalVoidFunc(arg01, arg02, arg03, arg04, arg05, arg06, arg07, arg08, arg09, arg10);

                // Finalize runtime measurement
                runtime = GetMicrosecondCount() - runtime;


                // Load the output parameters onto the tracer output stack.
                // Here we will push the result in arg08 from a reference to the output stack
                // In case your function has no output at all, this macro can be omitted.
                //
                // We will add the runtime as well to the output, so we can see the time
                // we measured.
                DBG_USERAPI_RESULTS(2, arg08, runtime, 0, 0, 0, 0, 0);


                // Output will be printed in case _LastError is not ERR_SUCCES / ERR_NO_ERROR
                //
                // For customization, it is possible to force printing, regardless of _LastError
                //  Insert the macro "DBG_USERAPI_PRINT_PARAMS" for printing input parameters.
                //  Insert the macro "DBG_USERAPI_PRINT_RESULT" for printing results.
                //
                //  If omitted, the default will apply.
                DBG_USERAPI_PRINT_PARAMS;
                DBG_USERAPI_PRINT_RESULT;


                // Call the finalize-macro for code tracing
                DBG_USERAPI_TRACE_FINALIZE;

                // Return void
                return;
            };


            ////////////////////////////////////////////////////////
            //
            // Define the function replacement macro
            //
            //  If this is not defined, tracing will be disabled.
            //  The macro takes in one argument.
            //
            //  NOTE
            //      Define this after the wrapper function,
            //      else you will receive a 'Stack overflow'
            //      error.
            //
            #define MyPersonalVoidFunc                  DBG_USERAPI_TRACE_FUNCTION(MyPersonalVoidFunc)



        //
        /////////////////////////////////////////////////////////////////////////////////////////////////////




                                                                                                                                                                       /*
                                                                                                                                                                        *
        ...YOUR CUSTOM CODE ENDS HERE                                                                                                                                   *
                                                                                                                                                                        *
                                                                                                                                                                        *
    *********************************************************************************************************************************************************************/
    };


#ifdef __MQL5__
    };  // Namespace dbg_lib

#endif
//
/////////////////////////////////////////////////////////////////////////////////////////////////////
#endif  // Custom extensions
// Close custom trace wrapper and include distribution library
#include <MQLplus/lib_debug.mqh>

// Include function overwrite macros
#include <MQLplus/lib_debug/lib_debug_mqlapi_tracer_overwrite_macros.mqh>


//
// END Debugging support
//*********************************************************************************************************************************************************/
#endif // LIB_DBG_DEBUG_MQLAPI_CUSTOMCONFIG_MQH_INCLUDED