nel/src/misc/log.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010-2019  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #include "stdmisc.h"
  18
  19 #include "nel/misc/log.h"
  20
  21 #ifdef NL_OS_WINDOWS
  22 #       include <process.h>
  23 #else
  24 #       include <unistd.h>
  25 #endif
  26
  27 #include "nel/misc/displayer.h"
  28 #include "nel/misc/log.h"
  29 #include "nel/misc/debug.h"
  30 #include "nel/misc/path.h"
  31
  32 using namespace std;
  33
  34 #ifdef DEBUG_NEW
  35         #define new DEBUG_NEW
  36 #endif
  37
  38 namespace NLMISC
  39 {
  40
  41 string *CLog::_ProcessName = NULL;
  42
  43 CLog::CLog( TLogType logType) : _LogType (logType), _FileName(NULL), _Line(-1), _FuncName(NULL), _Mutex("LOG"+toString((uint)logType)), _PosSet(false)
  44 {
  45 }
  46
  47 void CLog::setDefaultProcessName ()
  48 {
  49         if (_ProcessName == NULL)
  50         {
  51                 _ProcessName = (string *)INelContext::getInstance().getSingletonPointer("NLMISC::CLog::_ProcessName");
  52                 if (_ProcessName == NULL)
  53                 {
  54                         _ProcessName = new string;
  55                         INelContext::getInstance().setSingletonPointer("NLMISC::CLog::_ProcessName", _ProcessName);
  56                 }
  57         }
  58
  59 #ifdef NL_OS_WINDOWS
  60         if ((*_ProcessName).empty())
  61         {
  62                 wchar_t name[1024];
  63                 GetModuleFileNameW(NULL, name, 1023);
  64                 (*_ProcessName) = CFile::getFilename(wideToUtf8(name));
  65         }
  66 #else
  67         if ((*_ProcessName).empty())
  68         {
  69                 *_ProcessName = "<Unknown>";
  70         }
  71 #endif
  72 }
  73
  74 void CLog::setProcessName (const std::string &processName)
  75 {
  76         if (_ProcessName == NULL)
  77         {
  78                 _ProcessName = (string *)INelContext::getInstance().getSingletonPointer("NLMISC::CLog::_ProcessName");
  79                 if (_ProcessName == NULL)
  80                 {
  81                         _ProcessName = new string;
  82                         INelContext::getInstance().setSingletonPointer("NLMISC::CLog::_ProcessName", _ProcessName);
  83                 }
  84         }
  85
  86         // keep only filename without path
  87         *_ProcessName = CFile::getFilename(processName);
  88 }
  89
  90 void CLog::setPosition (sint line, const char *fileName, const char *funcName)
  91 {
  92         if ( !noDisplayer() )
  93         {
  94                 _Mutex.enter();
  95                 _PosSet++;
  96                 _FileName = fileName;
  97                 _Line = line;
  98                 _FuncName = funcName;
  99         }
 100 }
 101
 102 /// Symetric to setPosition(). Automatically called by display...(). Do not call if noDisplayer().
 103 void CLog::unsetPosition()
 104 {
 105         nlassert( !noDisplayer() );
 106
 107         if ( _PosSet > 0 )
 108         {
 109                 _FileName = NULL;
 110                 _Line = -1;
 111                 _FuncName = NULL;
 112                 _PosSet--;
 113                 _Mutex.leave(); // needs setPosition() to have been called
 114         }
 115 }
 116
 117
 118 void CLog::addDisplayer (IDisplayer *displayer, bool bypassFilter)
 119 {
 120         if (displayer == NULL)
 121         {
 122                 // Can't nlwarning because recursive call
 123                 printf ("Trying to add a NULL displayer\n");
 124                 return;
 125         }
 126
 127         if (bypassFilter)
 128         {
 129                 CDisplayers::iterator idi = std::find (_BypassFilterDisplayers.begin (), _BypassFilterDisplayers.end (), displayer);
 130                 if (idi == _BypassFilterDisplayers.end ())
 131                 {
 132                         _BypassFilterDisplayers.push_back (displayer);
 133                 }
 134                 else
 135                 {
 136                         nlwarning ("LOG: Couldn't add the displayer, it was already added");
 137                 }
 138         }
 139         else
 140         {
 141                 CDisplayers::iterator idi = std::find (_Displayers.begin (), _Displayers.end (), displayer);
 142                 if (idi == _Displayers.end ())
 143                 {
 144                         _Displayers.push_back (displayer);
 145                 }
 146                 else
 147                 {
 148                         nlwarning ("LOG: Couldn't add the displayer, it was already added");
 149                 }
 150         }
 151 }
 152
 153 void CLog::removeDisplayer (IDisplayer *displayer)
 154 {
 155         if (displayer == NULL)
 156         {
 157                 nlwarning ("LOG: Trying to remove a NULL displayer");
 158                 return;
 159         }
 160
 161         CDisplayers::iterator idi = std::find (_Displayers.begin (), _Displayers.end (), displayer);
 162         if (idi != _Displayers.end ())
 163         {
 164                 _Displayers.erase (idi);
 165         }
 166
 167         idi = std::find (_BypassFilterDisplayers.begin (), _BypassFilterDisplayers.end (), displayer);
 168         if (idi != _BypassFilterDisplayers.end ())
 169         {
 170                 _BypassFilterDisplayers.erase (idi);
 171         }
 172
 173 }
 174
 175 void CLog::removeDisplayer (const char *displayerName)
 176 {
 177         if (displayerName == NULL || displayerName[0] == '\0')
 178         {
 179                 nlwarning ("LOG: Trying to remove an empty displayer name");
 180                 return;
 181         }
 182
 183         CDisplayers::iterator idi;
 184         for (idi = _Displayers.begin (); idi != _Displayers.end ();)
 185         {
 186                 if ((*idi)->DisplayerName == displayerName)
 187                 {
 188                         idi = _Displayers.erase (idi);
 189                 }
 190                 else
 191                 {
 192                         idi++;
 193                 }
 194         }
 195
 196         for (idi = _BypassFilterDisplayers.begin (); idi != _BypassFilterDisplayers.end ();)
 197         {
 198                 if ((*idi)->DisplayerName == displayerName)
 199                 {
 200                         idi = _BypassFilterDisplayers.erase (idi);
 201                 }
 202                 else
 203                 {
 204                         idi++;
 205                 }
 206         }
 207 }
 208
 209 IDisplayer *CLog::getDisplayer (const char *displayerName)
 210 {
 211         if (displayerName == NULL || displayerName[0] == '\0')
 212         {
 213                 nlwarning ("LOG: Trying to get an empty displayer name");
 214                 return NULL;
 215         }
 216
 217         CDisplayers::iterator idi;
 218         for (idi = _Displayers.begin (); idi != _Displayers.end (); idi++)
 219         {
 220                 if ((*idi)->DisplayerName == displayerName)
 221                 {
 222                         return *idi;
 223                 }
 224         }
 225         for (idi = _BypassFilterDisplayers.begin (); idi != _BypassFilterDisplayers.end (); idi++)
 226         {
 227                 if ((*idi)->DisplayerName == displayerName)
 228                 {
 229                         return *idi;
 230                 }
 231         }
 232         return NULL;
 233 }
 234
 235 /*
 236  * Returns true if the specified displayer is attached to the log object
 237  */
 238 bool CLog::attached(IDisplayer *displayer) const
 239 {
 240         return (find( _Displayers.begin(), _Displayers.end(), displayer ) != _Displayers.end()) ||
 241                         (find( _BypassFilterDisplayers.begin(), _BypassFilterDisplayers.end(), displayer ) != _BypassFilterDisplayers.end());
 242 }
 243
 244
 245 void CLog::displayString (const char *str)
 246 {
 247         const char *disp = NULL;
 248         TDisplayInfo localargs, *args = NULL;
 249
 250         setDefaultProcessName ();
 251
 252         if(strchr(str,'\n') == NULL)
 253         {
 254                 if (TempString.empty())
 255                 {
 256                         time (&TempArgs.Date);
 257                         TempArgs.LogType = _LogType;
 258                         TempArgs.ProcessName = *_ProcessName;
 259                         TempArgs.ThreadId = getThreadId();
 260                         TempArgs.FileName = _FileName;
 261                         TempArgs.Line = _Line;
 262                         TempArgs.FuncName = _FuncName;
 263                         TempArgs.CallstackAndLog.clear();
 264
 265                         TempString = str;
 266                 }
 267                 else
 268                 {
 269                         TempString += str;
 270                 }
 271                 return;
 272         }
 273         else
 274         {
 275                 if (TempString.empty())
 276                 {
 277                         time (&localargs.Date);
 278                         localargs.LogType = _LogType;
 279                         localargs.ProcessName = *_ProcessName;
 280                         localargs.ThreadId = getThreadId();
 281                         localargs.FileName = _FileName;
 282                         localargs.Line = _Line;
 283                         localargs.FuncName = _FuncName;
 284                         localargs.CallstackAndLog.clear();
 285
 286                         disp = str;
 287                         args = &localargs;
 288                 }
 289                 else
 290                 {
 291                         TempString += str;
 292                         disp = TempString.c_str();
 293                         args = &TempArgs;
 294                 }
 295         }
 296
 297         // send to all bypass filter displayers
 298         for (CDisplayers::iterator idi=_BypassFilterDisplayers.begin(); idi!=_BypassFilterDisplayers.end(); idi++ )
 299         {
 300                 (*idi)->display( *args, disp );
 301         }
 302
 303         // get the log at the last minute to be sure to have everything
 304         if(args->LogType == LOG_ERROR || args->LogType == LOG_ASSERT)
 305         {
 306                 getCallStackAndLog (args->CallstackAndLog, 4);
 307         }
 308
 309         if (passFilter (disp))
 310         {
 311                 // Send to the attached displayers
 312                 for (CDisplayers::iterator idi=_Displayers.begin(); idi!=_Displayers.end(); idi++ )
 313                 {
 314                         (*idi)->display( *args, disp );
 315                 }
 316         }
 317         TempString.clear();
 318         unsetPosition();
 319 }
 320
 321
 322 /*
 323  * Display the string with decoration and final new line to all attached displayers
 324  */
 325 #ifdef NL_OS_WINDOWS
 326 void CLog::_displayNL (const char *format, ...)
 327 #else
 328 void CLog::displayNL (const char *format, ...)
 329 #endif
 330 {
 331         if ( noDisplayer() )
 332         {
 333                 return;
 334         }
 335
 336         char *str;
 337         NLMISC_CONVERT_VARGS (str, format, 1024/*NLMISC::MaxCStringSize*/);
 338
 339         if (strlen(str)<1024/*NLMISC::MaxCStringSize*/-1)
 340                 strcat (str, "\n");
 341         else
 342                 str[1024/*NLMISC::MaxCStringSize*/-2] = '\n';
 343
 344         displayString (str);
 345 }
 346
 347 /*
 348  * Display the string with decoration to all attached displayers
 349  */
 350 #ifdef NL_OS_WINDOWS
 351 void CLog::_display (const char *format, ...)
 352 #else
 353 void CLog::display (const char *format, ...)
 354 #endif
 355 {
 356         if ( noDisplayer() )
 357         {
 358                 return;
 359         }
 360
 361         char *str;
 362         NLMISC_CONVERT_VARGS (str, format, 1024/*NLMISC::MaxCStringSize*/);
 363
 364         displayString (str);
 365 }
 366
 367 void CLog::displayRawString (const char *str)
 368 {
 369         const char *disp = NULL;
 370         TDisplayInfo localargs, *args = NULL;
 371
 372         setDefaultProcessName ();
 373
 374         if(strchr(str,'\n') == NULL)
 375         {
 376                 if (TempString.empty())
 377                 {
 378                         localargs.Date = 0;
 379                         localargs.LogType = CLog::LOG_NO;
 380                         localargs.ProcessName.clear();
 381                         localargs.ThreadId = 0;
 382                         localargs.FileName = NULL;
 383                         localargs.Line = -1;
 384                         localargs.CallstackAndLog.clear();
 385
 386                         TempString = str;
 387                 }
 388                 else
 389                 {
 390                         TempString += str;
 391                 }
 392                 return;
 393         }
 394         else
 395         {
 396                 if (TempString.empty())
 397                 {
 398                         localargs.Date = 0;
 399                         localargs.LogType = CLog::LOG_NO;
 400                         localargs.ProcessName.clear();
 401                         localargs.ThreadId = 0;
 402                         localargs.FileName = NULL;
 403                         localargs.Line = -1;
 404                         localargs.CallstackAndLog.clear();
 405
 406                         disp = str;
 407                         args = &localargs;
 408                 }
 409                 else
 410                 {
 411                         TempString += str;
 412                         disp = TempString.c_str();
 413                         args = &TempArgs;
 414                 }
 415         }
 416
 417         // send to all bypass filter displayers
 418         for (CDisplayers::iterator idi=_BypassFilterDisplayers.begin(); idi!=_BypassFilterDisplayers.end(); idi++ )
 419         {
 420                 (*idi)->display( *args, disp );
 421         }
 422
 423         // get the log at the last minute to be sure to have everything
 424         if(args->LogType == LOG_ERROR || args->LogType == LOG_ASSERT)
 425         {
 426                 getCallStackAndLog (args->CallstackAndLog, 4);
 427         }
 428
 429         if ( passFilter( disp ) )
 430         {
 431                 // Send to the attached displayers
 432                 for ( CDisplayers::iterator idi=_Displayers.begin(); idi!=_Displayers.end(); idi++ )
 433                 {
 434                         (*idi)->display( *args, disp );
 435                 }
 436         }
 437         TempString.clear();
 438         unsetPosition();
 439 }
 440
 441 /*
 442  * Display a string (and nothing more) to all attached displayers
 443  */
 444 #ifdef NL_OS_WINDOWS
 445 void CLog::_displayRawNL( const char *format, ... )
 446 #else
 447 void CLog::displayRawNL( const char *format, ... )
 448 #endif
 449 {
 450         if ( noDisplayer() )
 451         {
 452                 return;
 453         }
 454
 455         char *str;
 456         NLMISC_CONVERT_VARGS (str, format, 1024/*NLMISC::MaxCStringSize*/);
 457
 458         if (strlen(str)<1024/*NLMISC::MaxCStringSize*/-1)
 459                 strcat (str, "\n");
 460         else
 461                 str[1024/*NLMISC::MaxCStringSize*/-2] = '\n';
 462
 463         displayRawString(str);
 464 }
 465
 466 /*
 467  * Display a string (and nothing more) to all attached displayers
 468  */
 469 #ifdef NL_OS_WINDOWS
 470 void CLog::_displayRaw( const char *format, ... )
 471 #else
 472 void CLog::displayRaw( const char *format, ... )
 473 #endif
 474 {
 475         if ( noDisplayer() )
 476         {
 477                 return;
 478         }
 479
 480         char *str;
 481         NLMISC_CONVERT_VARGS (str, format, 1024/*NLMISC::MaxCStringSize*/);
 482
 483         displayRawString(str);
 484 }
 485
 486
 487 #ifdef NL_OS_WINDOWS
 488 void CLog::_forceDisplayRaw (const char *format, ...)
 489 #else
 490 void CLog::forceDisplayRaw (const char *format, ...)
 491 #endif
 492 {
 493         if ( noDisplayer() )
 494         {
 495                 return;
 496         }
 497
 498         char *str;
 499         NLMISC_CONVERT_VARGS (str, format, 1024/*NLMISC::MaxCStringSize*/);
 500
 501         TDisplayInfo args;
 502         CDisplayers::iterator idi;
 503
 504         // send to all bypass filter displayers
 505         for (idi=_BypassFilterDisplayers.begin(); idi!=_BypassFilterDisplayers.end(); idi++ )
 506         {
 507                 (*idi)->display( args, str );
 508         }
 509
 510         // Send to the attached displayers
 511         for ( idi=_Displayers.begin(); idi!=_Displayers.end(); idi++ )
 512         {
 513                 (*idi)->display( args, str );
 514         }
 515 }
 516
 517
 518
 519 /*
 520  * Returns true if the string must be logged, according to the current filter
 521  */
 522 bool CLog::passFilter( const char *filter )
 523 {
 524         bool yes = _PositiveFilter.empty();
 525
 526         bool found;
 527         list<string>::iterator ilf;
 528
 529         // 1. Positive filter
 530         for ( ilf=_PositiveFilter.begin(); ilf!=_PositiveFilter.end(); ++ilf )
 531         {
 532                 found = ( strstr( filter, (*ilf).c_str() ) != NULL );
 533                 if ( found )
 534                 {
 535                         yes = true; // positive filter passed (no need to check another one)
 536                         break;
 537                 }
 538                 // else try the next one
 539         }
 540         if ( ! yes )
 541         {
 542                 return false; // positive filter not passed
 543         }
 544
 545         // 2. Negative filter
 546         for ( ilf=_NegativeFilter.begin(); ilf!=_NegativeFilter.end(); ++ilf )
 547         {
 548                 found = ( strstr( filter, (*ilf).c_str() ) != NULL );
 549                 if ( found )
 550                 {
 551                         return false; // negative filter not passed (no need to check another one)
 552                 }
 553         }
 554         return true; // negative filter passed
 555 }
 556
 557
 558 /*
 559  * Removes a filter by name. Returns true if it was found.
 560  */
 561 void CLog::removeFilter( const char *filterstr )
 562 {
 563         if (filterstr == NULL)
 564         {
 565                 _PositiveFilter.clear();
 566                 _NegativeFilter.clear();
 567                 //displayNL ("CLog::addNegativeFilter('%s')", filterstr);
 568         }
 569         else
 570         {
 571                 _PositiveFilter.remove( filterstr );
 572                 _NegativeFilter.remove( filterstr );
 573                 //displayNL ("CLog::removeFilter('%s')", filterstr);
 574         }
 575 }
 576
 577 void CLog::displayFilter( CLog &log )
 578 {
 579         std::list<std::string>::iterator it;
 580         log.displayNL ("Positive Filter(s):");
 581         for (it = _PositiveFilter.begin (); it != _PositiveFilter.end (); it++)
 582         {
 583                 log.displayNL ("'%s'", (*it).c_str());
 584         }
 585         log.displayNL ("Negative Filter(s):");
 586         for (it = _NegativeFilter.begin (); it != _NegativeFilter.end (); it++)
 587         {
 588                 log.displayNL ("'%s'", (*it).c_str());
 589         }
 590 }
 591
 592 void CLog::addPositiveFilter( const char *filterstr )
 593 {
 594         //displayNL ("CLog::addPositiveFilter('%s')", filterstr);
 595         _PositiveFilter.push_back( filterstr );
 596 }
 597
 598 void CLog::addNegativeFilter( const char *filterstr )
 599 {
 600         //displayNL ("CLog::addNegativeFilter('%s')", filterstr);
 601         _NegativeFilter.push_back( filterstr );
 602 }
 603
 604 void CLog::resetFilters()
 605 {
 606         //displayNL ("CLog::resetFilter()");
 607         _PositiveFilter.clear();
 608         _NegativeFilter.clear();
 609 }
 610
 611 /// Do not call this unless you know why you're doing it, it kills the debug/log system!
 612 void CLog::releaseProcessName()
 613 {
 614         if (INelContext::isContextInitialised())
 615         {
 616                 INelContext::getInstance().releaseSingletonPointer("NLMISC::CLog::_ProcessName", _ProcessName);
 617         }
 618
 619         if (_ProcessName)
 620         {
 621                 delete _ProcessName;
 622                 _ProcessName = NULL;
 623         }
 624 }
 625
 626 } // NLMISC
 627