sourcemod-central: core/Logger.cpp@bf1faf4a16c9

     1 /**

     2  * vim: set ts=4 sw=4 :

     3  * =============================================================================

     4  * SourceMod

     5  * Copyright (C) 2004-2009 AlliedModders LLC.  All rights reserved.

     6  * =============================================================================

     7  *

     8  * This program is free software; you can redistribute it and/or modify it under

     9  * the terms of the GNU General Public License, version 3.0, as published by the

    10  * Free Software Foundation.

    11  *

    12  * This program is distributed in the hope that it will be useful, but WITHOUT

    13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

    14  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more

    15  * details.

    16  *

    17  * You should have received a copy of the GNU General Public License along with

    18  * this program.  If not, see <http://www.gnu.org/licenses/>.

    19  *

    20  * As a special exception, AlliedModders LLC gives you permission to link the

    21  * code of this program (as well as its derivative works) to "Half-Life 2," the

    22  * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software

    23  * by the Valve Corporation.  You must obey the GNU General Public License in

    24  * all respects for all other code used.  Additionally, AlliedModders LLC grants

    25  * this exception to all derivative works.  AlliedModders LLC defines further

    26  * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),

    27  * or <http://www.sourcemod.net/license.php>.

    28  *

    29  * Version: $Id$

    30  */

    32 #include <time.h>

    33 #include "sourcemod.h"

    34 #include "sourcemm_api.h"

    35 #include "sm_stringutil.h"

    36 #include "Logger.h"

    37 #include "LibrarySys.h"

    38 #include "TimerSys.h"

    39 #include <sourcemod_version.h>

    40 #include "logic_bridge.h"

    42 Logger g_Logger;

    44 SH_DECL_HOOK1_void(IVEngineServer, LogPrint, SH_NOATTRIB, false, const char *);

    46 /**

    47  * :TODO: This should be creating the log folder if it doesn't exist

    48  */

    50 ConfigResult Logger::OnSourceModConfigChanged(const char *key,

    51 									  const char *value,

    52 									  ConfigSource source,

    53 									  char *error,

    54 									  size_t maxlength)

    55 {

    56 	if (strcasecmp(key, "Logging") == 0)

    57 	{

    58 		bool state;

    60 		if (strcasecmp(value, "on") == 0)

    61 		{

    62 			state = true;

    63 		} else if (strcasecmp(value, "off") == 0) {

    64 			state = false;

    65 		} else {

    66 			UTIL_Format(error, maxlength, "Invalid value: must be \"on\" or \"off\"");

    67 			return ConfigResult_Reject;

    68 		}

    70 		if (source == ConfigSource_Console)

    71 		{

    72 			state ? EnableLogging() : DisableLogging();

    73 		} else {

    74 			m_InitialState = state;

    75 		}

    77 		return ConfigResult_Accept;

    78 	} else if (strcasecmp(key, "LogMode") == 0) {

    79 		if (strcasecmp(value, "daily") == 0)

    80 		{

    81 			m_Mode = LoggingMode_Daily;

    82 		} else if (strcasecmp(value, "map") == 0) {

    83 			m_Mode = LoggingMode_PerMap;

    84 		} else if (strcasecmp(value, "game") == 0) {

    85 			m_Mode = LoggingMode_Game;

    86 		} else {

    87 			UTIL_Format(error, maxlength, "Invalid value: must be [daily|map|game]");

    88 			return ConfigResult_Reject;

    89 		}

    91 		return ConfigResult_Accept;

    92 	}

    94 	return ConfigResult_Ignore;

    95 }

    97 static void HookLogPrint(const char *message)

    98 {

    99 	g_in_game_log_hook = true;

   100 	bool stopped = logicore.OnLogPrint(message);

   101 	g_in_game_log_hook = false;

   103 	if (stopped)

   104 		RETURN_META(MRES_SUPERCEDE);

   105 }

   107 void Logger::OnSourceModStartup(bool late)

   108 {

   109 	InitLogger(m_Mode);

   111 	SH_ADD_HOOK_STATICFUNC(IVEngineServer, LogPrint, engine, HookLogPrint, false);

   112 }

   114 void Logger::OnSourceModAllShutdown()

   115 {

   116 	CloseLogger();

   117 	SH_REMOVE_HOOK_STATICFUNC(IVEngineServer, LogPrint, engine, HookLogPrint, false);

   118 }

   120 void Logger::OnSourceModLevelChange(const char *mapName)

   121 {

   122 	MapChange(mapName);

   123 }

   125 void Logger::_NewMapFile()

   126 {

   127 	if (!m_Active)

   128 	{

   129 		return;

   130 	}

   132 	/* Append "Log file closed" to previous log file */

   133 	_CloseFile();

   135 	char _filename[256];

   136 	int i = 0;

   138 	time_t t;

   139 	GetAdjustedTime(&t);

   140 	tm *curtime = localtime(&t);

   142 	while (true)

   143 	{

   144 		g_SourceMod.BuildPath(Path_SM, _filename, sizeof(_filename), "logs/L%02d%02d%03d.log", curtime->tm_mon + 1, curtime->tm_mday, i);

   145 		FILE *fp = fopen(_filename, "r");

   146 		if (!fp)

   147 		{

   148 			break;

   149 		}

   150 		fclose(fp);

   151 		i++;

   152 	}

   153 	m_NrmFileName.assign(_filename);

   155 	FILE *fp = fopen(m_NrmFileName.c_str(), "w");

   156 	if (!fp)

   157 	{

   158 		char error[255];

   159 		g_LibSys.GetPlatformError(error, sizeof(error));

   160 		LogFatal("[SM] Unexpected fatal logging error (file \"%s\")", m_NrmFileName.c_str());

   161 		LogFatal("[SM] Platform returned error: \"%s\"", error);

   162 		LogFatal("[SM] Logging has been disabled.");

   163 		m_Active = false;

   164 		return;

   165 	} else {

   166 		char date[32];

   167 		strftime(date, sizeof(date), "%m/%d/%Y - %H:%M:%S", curtime);

   168 		fprintf(fp, "L %s: SourceMod log file started (file \"L%02d%02d%03d.log\") (Version \"%s\")\n", date, curtime->tm_mon + 1, curtime->tm_mday, i, SM_VERSION_STRING);

   169 		fclose(fp);

   170 	}

   171 }

   173 void Logger::_CloseFile()

   174 {

   175 	if (!m_Active)

   176 	{

   177 		return;

   178 	}

   180 	FILE *fp = NULL;

   181 	if (!m_NrmFileName.empty())

   182 	{

   183 		fp = fopen(m_NrmFileName.c_str(), "r+");

   184 		if (fp)

   185 		{

   186 			fseek(fp, 0, SEEK_END);

   187 			LogMessage("Log file closed.");

   188 			fclose(fp);

   189 		}

   190 		m_NrmFileName.clear();

   191 	}

   193 	if (!m_ErrMapStart)

   194 	{

   195 		return;

   196 	}

   197 	fp = fopen(m_ErrFileName.c_str(), "r+");

   198 	if (fp)

   199 	{

   200 		fseek(fp, 0, SEEK_END);

   201 		LogError("Error log file session closed.");

   202 		fclose(fp);

   203 	}

   204 	m_ErrFileName.clear();

   205 }

   207 void Logger::InitLogger(LoggingMode mode)

   208 {

   209 	m_Mode = mode;

   210 	m_Active = m_InitialState;

   212 	time_t t;

   213 	GetAdjustedTime(&t);

   214 	tm *curtime = localtime(&t);

   215 	m_CurDay = curtime->tm_mday;

   217 	char _filename[256];

   218 	g_SourceMod.BuildPath(Path_SM, _filename, sizeof(_filename), "logs/errors_%04d%02d%02d.log", curtime->tm_year + 1900, curtime->tm_mon + 1, curtime->tm_mday);

   219 	m_ErrFileName.assign(_filename);

   221 	switch (m_Mode)

   222 	{

   223 	case LoggingMode_PerMap:

   224 		{

   225 			if (!m_Active)

   226 			{

   227 				m_DelayedStart = true;

   228 			}

   229 			break;

   230 		}

   231 	case LoggingMode_Daily:

   232 		{

   233 			g_SourceMod.BuildPath(Path_SM, _filename, sizeof(_filename), "logs/L%04d%02d%02d.log", curtime->tm_year + 1900, curtime->tm_mon + 1, curtime->tm_mday);

   234 			m_NrmFileName.assign(_filename);

   235 			m_DailyPrintHdr = true;

   236 			break;

   237 		}

   238 	default:

   239 		{

   240 			/* do nothing... */

   241 			break;

   242 		}

   243 	}

   244 }

   246 void Logger::CloseLogger()

   247 {

   248 	_CloseFile();

   249 }

   251 void Logger::LogToOpenFile(FILE *fp, const char *msg, ...)

   252 {

   253 	if (!m_Active)

   254 	{

   255 		return;

   256 	}

   258 	va_list ap;

   259 	va_start(ap, msg);

   260 	LogToOpenFileEx(fp, msg, ap);

   261 	va_end(ap);

   262 }

   264 void Logger::LogToFileOnly(FILE *fp, const char *msg, ...)

   265 {

   266 	if (!m_Active)

   267 	{

   268 		return;

   269 	}

   271 	va_list ap;

   272 	va_start(ap, msg);

   273 	LogToFileOnlyEx(fp, msg, ap);

   274 	va_end(ap);

   275 }

   277 void Logger::LogToOpenFileEx(FILE *fp, const char *msg, va_list ap)

   278 {

   279 	if (!m_Active)

   280 	{

   281 		return;

   282 	}

   284 	static ConVar *sv_logecho = icvar->FindVar("sv_logecho");

   286 	char buffer[3072];

   287 	UTIL_FormatArgs(buffer, sizeof(buffer), msg, ap);

   289 	char date[32];

   290 	time_t t;

   291 	GetAdjustedTime(&t);

   292 	tm *curtime = localtime(&t);

   293 	strftime(date, sizeof(date), "%m/%d/%Y - %H:%M:%S", curtime);

   295 	fprintf(fp, "L %s: %s\n", date, buffer);

   297 	if (!sv_logecho || sv_logecho->GetBool())

   298 	{

   299 		g_SMAPI->ConPrintf("L %s: %s\n", date, buffer);

   300 	}

   301 }

   303 void Logger::LogToFileOnlyEx(FILE *fp, const char *msg, va_list ap)

   304 {

   305 	if (!m_Active)

   306 	{

   307 		return;

   308 	}

   310 	char buffer[3072];

   311 	UTIL_FormatArgs(buffer, sizeof(buffer), msg, ap);

   313 	char date[32];

   314 	time_t t;

   315 	GetAdjustedTime(&t);

   316 	tm *curtime = localtime(&t);

   317 	strftime(date, sizeof(date), "%m/%d/%Y - %H:%M:%S", curtime);

   319 	fprintf(fp, "L %s: %s\n", date, buffer);

   320 	fflush(fp);

   321 }

   323 void Logger::LogMessage(const char *vafmt, ...)

   324 {

   325 	va_list ap;

   326 	va_start(ap, vafmt);

   327 	LogMessageEx(vafmt, ap);

   328 	va_end(ap);

   329 }

   331 void Logger::LogMessageEx(const char *vafmt, va_list ap)

   332 {

   333 	if (!m_Active)

   334 	{

   335 		return;

   336 	}

   338 	if (m_Mode == LoggingMode_Game)

   339 	{

   340 		_PrintToGameLog(vafmt, ap);

   341 		return;

   342 	}

   344 	if (m_DelayedStart)

   345 	{

   346 		m_DelayedStart = false;

   347 		_NewMapFile();

   348 	}

   350 	time_t t;

   351 	GetAdjustedTime(&t);

   352 	tm *curtime = localtime(&t);

   354 	FILE *fp = NULL;

   355 	if (m_Mode == LoggingMode_PerMap)

   356 	{

   357 		fp = fopen(m_NrmFileName.c_str(), "a+");

   358 		if (!fp)

   359 		{

   360 			_NewMapFile();

   361 			fp = fopen(m_NrmFileName.c_str(), "a+");

   362 			if (!fp)

   363 			{

   364 				goto print_error;

   365 			}

   366 		}

   367 	} else {

   368 		if (m_CurDay != curtime->tm_mday)

   369 		{

   370 			char _filename[256];

   371 			g_SourceMod.BuildPath(Path_SM, _filename, sizeof(_filename), "logs/L%04d%02d%02d.log", curtime->tm_year + 1900, curtime->tm_mon + 1, curtime->tm_mday);

   372 			m_NrmFileName.assign(_filename);

   373 			m_CurDay = curtime->tm_mday;

   374 			m_DailyPrintHdr = true;

   375 		}

   376 		fp = fopen(m_NrmFileName.c_str(), "a+");

   377 	}

   379 	if (fp)

   380 	{

   381 		if (m_DailyPrintHdr)

   382 		{

   383 			char date[32];

   384 			m_DailyPrintHdr = false;

   385 			strftime(date, sizeof(date), "%m/%d/%Y - %H:%M:%S", curtime);

   386 			fprintf(fp, "L %s: SourceMod log file session started (file \"L%04d%02d%02d.log\") (Version \"%s\")\n", date, curtime->tm_year + 1900, curtime->tm_mon + 1, curtime->tm_mday, SM_VERSION_STRING);

   387 	 	}

   388 		LogToOpenFileEx(fp, vafmt, ap);

   389 		fclose(fp);

   390 	} else {

   391 		goto print_error;

   392 	}

   394 	return;

   395 print_error:

   396 	char error[255];

   397 	g_LibSys.GetPlatformError(error, sizeof(error));

   398 	LogFatal("[SM] Unexpected fatal logging error (file \"%s\")", m_NrmFileName.c_str());

   399 	LogFatal("[SM] Platform returned error: \"%s\"", error);

   400 	LogFatal("[SM] Logging has been disabled.");

   401 	m_Active = false;

   402 }

   404 void Logger::LogError(const char *vafmt, ...)

   405 {

   406 	va_list ap;

   407 	va_start(ap, vafmt);

   408 	LogErrorEx(vafmt, ap);

   409 	va_end(ap);

   410 }

   412 void Logger::LogErrorEx(const char *vafmt, va_list ap)

   413 {

   414 	if (!m_Active)

   415 	{

   416 		return;

   417 	}

   419 	time_t t;

   420 	GetAdjustedTime(&t);

   421 	tm *curtime = localtime(&t);

   423 	if (curtime->tm_mday != m_CurDay)

   424 	{

   425 		char _filename[256];

   426 		g_SourceMod.BuildPath(Path_SM, _filename, sizeof(_filename), "logs/errors_%04d%02d%02d.log", curtime->tm_year + 1900, curtime->tm_mon + 1, curtime->tm_mday);

   427 		m_ErrFileName.assign(_filename);

   428 		m_CurDay = curtime->tm_mday;

   429 		m_ErrMapStart = false;

   430 	}

   432 	FILE *fp = fopen(m_ErrFileName.c_str(), "a+");

   433 	if (fp)

   434 	{

   435 		if (!m_ErrMapStart)

   436 		{

   437 			char date[32];

   438 			strftime(date, sizeof(date), "%m/%d/%Y - %H:%M:%S", curtime);

   439 			fprintf(fp, "L %s: SourceMod error session started\n", date);

   440 			fprintf(fp, "L %s: Info (map \"%s\") (file \"errors_%04d%02d%02d.log\")\n", date, m_CurMapName.c_str(), curtime->tm_year + 1900, curtime->tm_mon + 1, curtime->tm_mday);

   441 			m_ErrMapStart = true;

   442 		}

   443 		LogToOpenFileEx(fp, vafmt, ap);

   444 		fclose(fp);

   445 	}

   446 	else

   447 	{

   448 		char error[255];

   449 		g_LibSys.GetPlatformError(error, sizeof(error));

   450 		LogFatal("[SM] Unexpected fatal logging error (file \"%s\")", m_NrmFileName.c_str());

   451 		LogFatal("[SM] Platform returned error: \"%s\"", error);

   452 		LogFatal("[SM] Logging has been disabled.");

   453 		m_Active = false;

   454 		return;

   455 	}

   456 }

   458 void Logger::MapChange(const char *mapname)

   459 {

   460 	m_CurMapName.assign(mapname);

   462 	switch (m_Mode)

   463 	{

   464 	case LoggingMode_Daily:

   465 		{

   466 			LogMessage("-------- Mapchange to %s --------", mapname);

   467 			break;

   468 		}

   469 	case LoggingMode_PerMap:

   470 		{

   471 			_NewMapFile();

   472 			break;

   473 		}

   474 	default:

   475 		{

   476 			/* Do nothing... */

   477 			break;

   478 		}

   479 	}

   481 	if (m_ErrMapStart)

   482 	{

   483 		LogError("Error log file session closed.");

   484 	}

   485 	m_ErrMapStart = false;

   486 }

   488 void Logger::_PrintToGameLog(const char *fmt, va_list ap)

   489 {

   490 	char msg[3072];

   491 	size_t len;

   493 	len = vsnprintf(msg, sizeof(msg)-2, fmt, ap);

   494 	len = (len >= sizeof(msg)) ? (sizeof(msg) - 2) : len;

   496 	msg[len++] = '\n';

   497 	msg[len] = '\0';

   499 	Engine_LogPrintWrapper(msg);

   500 }

   502 const char *Logger::GetLogFileName(LogType type) const

   503 {

   504 	switch (type)

   505 	{

   506 	case LogType_Normal:

   507 		{

   508 			return m_NrmFileName.c_str();

   509 		}

   510 	case LogType_Error:

   511 		{

   512 			return m_ErrFileName.c_str();

   513 		}

   514 	default:

   515 		{

   516 			return "";

   517 		}

   518 	}

   519 }

   521 LoggingMode Logger::GetLoggingMode() const

   522 {

   523 	return m_Mode;

   524 }

   526 void Logger::EnableLogging()

   527 {

   528 	if (m_Active)

   529 	{

   530 		return;

   531 	}

   532 	m_Active = true;

   533 	LogMessage("[SM] Logging enabled manually by user.");

   534 }

   536 void Logger::DisableLogging()

   537 {

   538 	if (!m_Active)

   539 	{

   540 		return;

   541 	}

   542 	LogMessage("[SM] Logging disabled manually by user.");

   543 	m_Active = false;

   544 }

   546 void Logger::LogFatal(const char *msg, ...)

   547 {

   548 	/* :TODO: make this print all pretty-like

   549 	 * In fact, the pretty log printing function should be abstracted.

   550 	 * It's already implemented twice which is bad.

   551 	 */

   553 	va_list ap;

   554 	char path[PLATFORM_MAX_PATH];

   556 	g_SourceMod.BuildPath(Path_Game, path, sizeof(path), "sourcemod_fatal.log");

   558 	FILE *fp = fopen(path, "at");

   559 	if (fp)

   560 	{

   561 		m_Active = true;

   562 		va_start(ap, msg);

   563 		LogToOpenFileEx(fp, msg, ap);

   564 		va_end(ap);

   565 		m_Active = false;

   566 		fclose(fp);

   567 	}

   568 }

   570 bool g_in_game_log_hook = false;

   572 void Engine_LogPrintWrapper(const char *msg)

   573 {

   574 	if (g_in_game_log_hook)

   575 	{

   576 		ENGINE_CALL(LogPrint)(msg);

   577 	}

   578 	else

   579 	{

   580 		engine->LogPrint(msg);

   581 	}

   582 }

author	Nicholas Hastings <skamonkey@gmail.com>
	Sat Mar 16 13:31:35 2013 -0400 (2013-03-16)
changeset 3813	bf1faf4a16c9
parent 3791	47e1ee9cea86
child 3819	d17aed3d46bf
permissions	-rw-r--r--