libi2ncommon: (reinhard) integrated "logfunc" and "tracing" from connd.

[libi2ncommon] / src / tracefunc.cpp

/** @file
 * @brief implementation of tracing functionality.
 *
 * @copyright © Copyright 2008 by Intra2net AG
 * @license commercial
 *
 * info@intra2net.com
 *
 * @note This module is not thread safe!
 * @todo make this module thread safe (only useful when we can use threads...)
 */

#include "tracefunc.hpp"

#include <list>
#include <vector>
#include <sstream>


namespace I2n
{
namespace Tracer
{

using Logger::GlobalLogger;


namespace
{

typedef std::list< ScopeTracker* > ScopeTrackerList;

ScopeTrackerList scope_tracker_list;


std::vector< std::string > indents;


/**
 * @brief ensures indent level string to exist up to the desired level.
 * @param level the desired indent level.
 */
void ensure_indent_level(int level)
{
   while (indents.size() <= level)
   {
      indents.push_back( indents.back() + "  " );
   }
} // eo ensure_indent_level(int)


/**
 * @brief module initializer.
 */
class __Initializer
{
   public:
      __Initializer()
      {
         // pre initialize indent strings:
         indents.clear();
         indents.reserve(10);
         indents.push_back("");
         for(int i=10; i-->0;)
         {
            indents.push_back( indents.back() + "  " );
         }
      }
} __initializer;


} // eo namespace <anonymous>


/*
** implementation of ScopeTracker
*/

/**
 * @brief constructor. initializes object with a source location and emits a ENTER message.
 * @param loc the source location.
 *
 * the message is indented according to the current depth of nested ScopeTracker instances.
 */
ScopeTracker::ScopeTracker(
    const SourceLocation& loc)
: Location(loc)
, Depth(0)
, FuncDepth(0)
{
   if (!scope_tracker_list.empty())
   {
      ScopeTracker* last_tracker= scope_tracker_list.back();
      if (Location)
      {
         if (last_tracker->Location
             && last_tracker->Location.File == Location.File
             && last_tracker->Location.FunctionName == Location.FunctionName)
         {
            FuncDepth= last_tracker->FuncDepth+1;
         }
      }
      Depth= last_tracker->Depth + 1;
   }
   ensure_indent_level(Depth);
   scope_tracker_list.push_back(this);
   {
      std::ostringstream ostr;
      if (Location.FunctionName.empty())
      {
         ostr << "<unknown> (global scope?)";
      }
      else
      {
         ostr << Location.FunctionName;
         if (FuncDepth>0)
         {
            ostr << "#" << FuncDepth+1;
         }
      }
      Tag= ostr.str();
   }
   // spit a message
   if (Logger::has_log_level(Logger::LogLevel::Debug))
   {
      GlobalLogger.debug() << indents[Depth] << "ENTER " << Tag;
   }
} // eo ScopeTrcaker::ScopeTracker(const SourceLocation&)


/**
 * @brief destructor. emits a LEAVE message.
 *
 *
 */
ScopeTracker::~ScopeTracker()
{
   // spit a message
   if (Logger::has_log_level(Logger::LogLevel::Debug))
   {
      GlobalLogger.debug() << indents[Depth] << "LEAVE " << Tag;
   }
   if (scope_tracker_list.empty())
   {
      return;
   }
   if (scope_tracker_list.back() == this)
   {
      scope_tracker_list.pop_back();
   }
   else
   {
      // oh hell, this should never be the case!
      //TODO
      GlobalLogger.error() << "inconsistency detected in scope tracker";
   }
} // eo ScopeTracker::~ScopeTracker()




} // eo namespace Tracer
} // eo namespace I2n