a python client stack trace logger for Evemu More...

#include "PyTraceLog.h"

Public Member Functions
	PyTraceLog (const char *path, bool toConsole=false, bool toFile=false)
	The constructor of the python stack trace logger. More...

	~PyTraceLog ()
	the destructor.... nothing special More...

bool	logTrace (PyTuple &tuple)
	logTrace is the function what its all about. More...

Protected Member Functions
void	_logInternStringMessage (PyRep *packet)

void	_logInternBufferMessage (PyRep *packet)

void	_logInternBufferPacket (PyRep *packet)

void	_logInternMessage (const char *str,...)
	intern function for handling logger related messages More...

void	_setLogColor (uint32 color)
	Internal function to set the console output color. More...

Private Attributes
FILE *	mFout

bool	mInitialized

bool	mLogToConsole

bool	mLogToFile

Detailed Description

a python client stack trace logger for Evemu

The PyTraceLog class processes the alert messages into a readable message, because its part of the development system it should be used by non developers.

Author: Captnoord

Date: December 2008

Definition at line 74 of file PyTraceLog.h.

Constructor & Destructor Documentation

PyTraceLog::PyTraceLog	(	const char *	path,
		bool	toConsole = `false`,
		bool	toFile = `false`
	)

inline

The constructor of the python stack trace logger.

Parameters

[in]	path	The path to the file including the file extension (basic for now).
[in]	toConsole	When want to have the output written to the console pass true.
[in]	toFile	When want to have the output written to the specified file pass true.

Definition at line 85 of file PyTraceLog.h.

References mFout, mInitialized, and mLogToConsole.

         : mFout(NULL),
           mInitialized(false),
           mLogToConsole(toConsole),
           mLogToFile(toFile)
 #ifdef HAVE_WINDOWS_H
           ,mStderrHandle(NULL),
           mStdoutHandle(NULL)
 #endif /* HAVE_WINDOWS_H */
     {
         if (toFile == true)
         {
             mFout = fopen(path, "w+");
             if (mFout == NULL)
                 printf("[error]PyTraceLog: sorry initializing the output file failed\n");
         }
 
 #ifdef HAVE_WINDOWS_H
         // get error handle
         if (mLogToConsole == true)
         {
             mStderrHandle = GetStdHandle(STD_ERROR_HANDLE);
             mStdoutHandle = GetStdHandle(STD_OUTPUT_HANDLE);
         }
 #endif /* HAVE_WINDOWS_H */
         mInitialized = true;
     }

PyTraceLog::~PyTraceLog ( )

inline

the destructor.... nothing special

Definition at line 116 of file PyTraceLog.h.

References mFout, and mLogToFile.

     {
         if (mLogToFile == true && mFout != NULL)
         {
             fflush(mFout);
             fclose(mFout);
         }
     }

Member Function Documentation

void PyTraceLog::_logInternBufferMessage ( PyRep * packet )

inlineprotected

Definition at line 213 of file PyTraceLog.h.

References PyRep::AsBuffer(), PyBuffer::content(), mFout, mLogToConsole, mLogToFile, and PyBuffer::size().

     {
         PyBuffer & msg = *packet->AsBuffer();
         if (mLogToConsole == true)
         {
             fwrite(&msg.content()[0], msg.size(), 1, stdout);
             fputc('\n', stdout);
         }
 
         if (mLogToFile == true)
         {
             fwrite(&msg.content()[0], msg.size(), 1, mFout);
             fputc('\n', mFout);
         }
     }

Here is the call graph for this function:

void PyTraceLog::_logInternBufferPacket ( PyRep * packet )

inlineprotected

Definition at line 230 of file PyTraceLog.h.

References PyRep::AsString(), PyString::content(), PyRep::GetType(), mFout, mLogToConsole, mLogToFile, and PyRep::PyTypeString.

Referenced by logTrace().

     {
         // just placement code atm...
         /*PyBuffer & msg = *packet->AsBuffer();
         if (mLogToConsole == true)
         {
             fwrite(&msg.content()[0], msg.size(), 1, stdout);
             fputc('\n', stdout);
         }
 
         if (mLogToFile == true)
         {
             fwrite(&msg.content()[0], msg.size(), 1, mFout);
             fputc('\n', mFout);
         }*/
 
         if (packet->GetType() != PyRep::PyTypeString)
             return;
 
         PyString & msg = *packet->AsString();
         if (mLogToConsole == true)
         {
             fwrite(msg.content().c_str(), msg.content().size(), 1, stdout);
             fputc('\n', stdout);
         }
 
         if (mLogToFile == true)
         {
             fwrite(msg.content().c_str(), msg.content().size(), 1, mFout);
             fputc('\n', mFout);
         }
 
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void PyTraceLog::_logInternMessage	(	const char *	str,
			...
	)

inlineprotected

intern function for handling logger related messages

Parameters

[in] str the format for the output message.

Definition at line 271 of file PyTraceLog.h.

References _setLogColor(), mFout, mLogToConsole, mLogToFile, TNORMAL, and TRED.

Referenced by logTrace().

     {
         va_list ap;
         va_start(ap, str);
 
         _setLogColor(TRED);
         // I know its code duplication....on a small scale
         if (mLogToConsole == true)
         {
             fprintf(stdout, "[PyTrace] ");
             vfprintf(stdout, str, ap);
             putc('\n', stdout);
         }
 
         if (mLogToFile == true)
         {
             fprintf(mFout, "[PyTrace] ");
             vfprintf(mFout, str, ap);
             putc('\n', mFout);
             fflush(mFout);
         }
         _setLogColor(TNORMAL);
         va_end(ap);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void PyTraceLog::_logInternStringMessage ( PyRep * packet )

inlineprotected

Definition at line 199 of file PyTraceLog.h.

References PyRep::AsString(), PyString::content(), mFout, mLogToConsole, and mLogToFile.

     {
         PyString & msg = *packet->AsString();
         if (mLogToConsole == true)
         {
             fprintf(stdout, "%s\n", msg.content().c_str());
         }
 
         if (mLogToFile == true)
         {
             fprintf(mFout, "%s\n", msg.content().c_str());
         }
     }

Here is the call graph for this function:

void PyTraceLog::_setLogColor ( uint32 color )

inlineprotected

Internal function to set the console output color.

Lazy ass function for a developer "toy". We humans like to see some colors.

Parameters

[in] color the color flags / value's for Windows or UNIX, see TRED and the rest on top of this file.

Definition at line 303 of file PyTraceLog.h.

References colorstrings, and TNORMAL.

Referenced by _logInternMessage().

     {
 #ifdef HAVE_WINDOWS_H
         SetConsoleTextAttribute(mStdoutHandle, TNORMAL);
 #else /* !HAVE_WINDOWS_H */
         puts(colorstrings[TNORMAL]);
 #endif /* !HAVE_WINDOWS_H */
     }

Here is the caller graph for this function:

bool PyTraceLog::logTrace ( PyTuple & tuple )

inline

logTrace is the function what its all about.

the logTrace function processes the packet object into the readable text and prints it to the screen and or the output file.

Parameters

[in] tuple tuple contains the packet info of the trace.

Returns: returns true if a success and false if a error is found (no special error handling for now).

Definition at line 133 of file PyTraceLog.h.

References _logInternBufferPacket(), _logInternMessage(), PyTuple::GetItem(), PyRep::IsTuple(), mFout, mInitialized, and mLogToFile.

Referenced by AlertService::Handle_SendClientStackTraceAlert().

     {
         assert(mInitialized && "PyTraceLog isn't initialized");
 
         // base object should be a tuple
         if(tuple.IsTuple() == false)
         {
             _logInternMessage("trace error because the base object isn't a tuple");
             return false;
         }
 
         /* the next part is commented out because the payload of the error message contains similar data */
 
         // the first object should be a tuple
         /*if (tuple[0]->IsTuple() == false)
         {
             _logInternMessage("trace error because the first object within the tuple isn't a tuple");
             return false;
         }
 
         if (mLogToFile)
             fprintf(mFout, "\nStackTraceAlert:\n");
 
         // tuple 0 should contain the error message or something binary
         PyRepTuple& tuple0_0 = tuple[0]->AsTuple();
         //tuple0_0[0] some integer... which I don't care about
         if( tuple0_0[1]->IsString() == true )
         {
             _logInternStringMessage(tuple0_0[1]);
         }
         else if (tuple0_0[1]->IsBuffer() == true)
         {
             _logInternBufferMessage(tuple0_0[1]);
         }
         else
         {
             _logInternMessage("trace log error");
             return false;
         }
 
         if (mLogToFile == true)
         {
             fputc('\n', mFout);
             fflush(mFout);
         }*/
 
         /* python stack trace payload */
         //if (tuple.GetItem(1)->IsString() == true)
         {
             _logInternBufferPacket(tuple.GetItem(1));
         }
 
         if (mLogToFile == true)
         {
             fputc('\n', mFout);
             fflush(mFout);
         }
 
         //tuple[2] should contain a string "Error" but that is a assumption and I am sure it has more stings to give us.
         //tuple[3] gives me for the moment the object None. So its marked as unknown for the moment.
 
         return true;
     }