sourcemod-central: core/Logger.cpp@4dc3d723c490

     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>

    41 Logger g_Logger;

    43 /**

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

    45  */

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

    48 									  const char *value,

    49 									  ConfigSource source,

    50 									  char *error,

    51 									  size_t maxlength)

    52 {

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

    54 	{

    55 		bool state;

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

    58 		{

    59 			state = true;

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

    61 			state = false;

    62 		} else {

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

    64 			return ConfigResult_Reject;

    65 		}

    67 		if (source == ConfigSource_Console)

    68 		{

    69 			state ? EnableLogging() : DisableLogging();

    70 		} else {

    71 			m_InitialState = state;

    72 		}

    74 		return ConfigResult_Accept;

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

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

    77 		{

    78 			m_Mode = LoggingMode_Daily;

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

    80 			m_Mode = LoggingMode_PerMap;

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

    82 			m_Mode = LoggingMode_Game;

    83 		} else {

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

    85 			return ConfigResult_Reject;

    86 		}

    88 		return ConfigResult_Accept;

    89 	}

    91 	return ConfigResult_Ignore;

    92 }

    94 void Logger::OnSourceModStartup(bool late)

    95 {

    96 	InitLogger(m_Mode);

    97 }

    99 void Logger::OnSourceModAllShutdown()

   100 {

   101 	CloseLogger();

   102 }

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

   105 {

   106 	MapChange(mapName);

   107 }

   109 void Logger::_NewMapFile()

   110 {

   111 	if (!m_Active)

   112 	{

   113 		return;

   114 	}

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

   117 	_CloseFile();

   119 	char _filename[256];

   120 	int i = 0;

   122 	time_t t;

   123 	GetAdjustedTime(&t);

   124 	tm *curtime = localtime(&t);

   126 	while (true)

   127 	{

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

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

   130 		if (!fp)

   131 		{

   132 			break;

   133 		}

   134 		fclose(fp);

   135 		i++;

   136 	}

   137 	m_NrmFileName.assign(_filename);

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

   140 	if (!fp)

   141 	{

   142 		char error[255];

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

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

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

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

   147 		m_Active = false;

   148 		return;

   149 	} else {

   150 		char date[32];

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

   152 		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);

   153 		fclose(fp);

   154 	}

   155 }

   157 void Logger::_CloseFile()

   158 {

   159 	if (!m_Active)

   160 	{

   161 		return;

   162 	}

   164 	FILE *fp = NULL;

   165 	if (!m_NrmFileName.empty())

   166 	{

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

   168 		if (fp)

   169 		{

   170 			fseek(fp, 0, SEEK_END);

   171 			LogMessage("Log file closed.");

   172 			fclose(fp);

   173 		}

   174 		m_NrmFileName.clear();

   175 	}

   177 	if (!m_ErrMapStart)

   178 	{

   179 		return;

   180 	}

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

   182 	if (fp)

   183 	{

   184 		fseek(fp, 0, SEEK_END);

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

   186 		fclose(fp);

   187 	}

   188 	m_ErrFileName.clear();

   189 }

   191 void Logger::InitLogger(LoggingMode mode)

   192 {

   193 	m_Mode = mode;

   194 	m_Active = m_InitialState;

   196 	time_t t;

   197 	GetAdjustedTime(&t);

   198 	tm *curtime = localtime(&t);

   199 	m_CurDay = curtime->tm_mday;

   201 	char _filename[256];

   202 	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);

   203 	m_ErrFileName.assign(_filename);

   205 	switch (m_Mode)

   206 	{

   207 	case LoggingMode_PerMap:

   208 		{

   209 			if (!m_Active)

   210 			{

   211 				m_DelayedStart = true;

   212 			}

   213 			break;

   214 		}

   215 	case LoggingMode_Daily:

   216 		{

   217 			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);

   218 			m_NrmFileName.assign(_filename);

   219 			m_DailyPrintHdr = true;

   220 			break;

   221 		}

   222 	default:

   223 		{

   224 			/* do nothing... */

   225 			break;

   226 		}

   227 	}

   228 }

   230 void Logger::CloseLogger()

   231 {

   232 	_CloseFile();

   233 }

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

   236 {

   237 	if (!m_Active)

   238 	{

   239 		return;

   240 	}

   242 	va_list ap;

   243 	va_start(ap, msg);

   244 	LogToOpenFileEx(fp, msg, ap);

   245 	va_end(ap);

   246 }

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

   249 {

   250 	if (!m_Active)

   251 	{

   252 		return;

   253 	}

   255 	va_list ap;

   256 	va_start(ap, msg);

   257 	LogToFileOnlyEx(fp, msg, ap);

   258 	va_end(ap);

   259 }

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

   262 {

   263 	if (!m_Active)

   264 	{

   265 		return;

   266 	}

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

   270 	char buffer[3072];

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

   273 	char date[32];

   274 	time_t t;

   275 	GetAdjustedTime(&t);

   276 	tm *curtime = localtime(&t);

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

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

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

   282 	{

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

   284 	}

   285 }

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

   288 {

   289 	if (!m_Active)

   290 	{

   291 		return;

   292 	}

   294 	char buffer[3072];

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

   297 	char date[32];

   298 	time_t t;

   299 	GetAdjustedTime(&t);

   300 	tm *curtime = localtime(&t);

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

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

   304 	fflush(fp);

   305 }

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

   308 {

   309 	if (!m_Active)

   310 	{

   311 		return;

   312 	}

   314 	if (m_Mode == LoggingMode_Game)

   315 	{

   316 		va_list ap;

   317 		va_start(ap, vafmt);

   318 		_PrintToGameLog(vafmt, ap);

   319 		va_end(ap);

   320 		return;

   321 	}

   323 	if (m_DelayedStart)

   324 	{

   325 		m_DelayedStart = false;

   326 		_NewMapFile();

   327 	}

   329 	time_t t;

   330 	GetAdjustedTime(&t);

   331 	tm *curtime = localtime(&t);

   333 	FILE *fp = NULL;

   334 	if (m_Mode == LoggingMode_PerMap)

   335 	{

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

   337 		if (!fp)

   338 		{

   339 			_NewMapFile();

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

   341 			if (!fp)

   342 			{

   343 				goto print_error;

   344 			}

   345 		}

   346 	} else {

   347 		if (m_CurDay != curtime->tm_mday)

   348 		{

   349 			char _filename[256];

   350 			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);

   351 			m_NrmFileName.assign(_filename);

   352 			m_CurDay = curtime->tm_mday;

   353 			m_DailyPrintHdr = true;

   354 		}

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

   356 	}

   358 	if (fp)

   359 	{

   360 		if (m_DailyPrintHdr)

   361 		{

   362 			char date[32];

   363 			m_DailyPrintHdr = false;

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

   365 			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);

   366 	 	}

   367 		va_list ap;

   368 		va_start(ap, vafmt);

   369 		LogToOpenFileEx(fp, vafmt, ap);

   370 		va_end(ap);

   371 		fclose(fp);

   372 	} else {

   373 		goto print_error;

   374 	}

   376 	return;

   377 print_error:

   378 	char error[255];

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

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

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

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

   383 	m_Active = false;

   384 }

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

   387 {

   388 	va_list ap;

   389 	va_start(ap, vafmt);

   390 	LogErrorEx(vafmt, ap);

   391 	va_end(ap);

   392 }

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

   395 {

   396 	if (!m_Active)

   397 	{

   398 		return;

   399 	}

   401 	time_t t;

   402 	GetAdjustedTime(&t);

   403 	tm *curtime = localtime(&t);

   405 	if (curtime->tm_mday != m_CurDay)

   406 	{

   407 		char _filename[256];

   408 		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);

   409 		m_ErrFileName.assign(_filename);

   410 		m_CurDay = curtime->tm_mday;

   411 		m_ErrMapStart = false;

   412 	}

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

   415 	if (fp)

   416 	{

   417 		if (!m_ErrMapStart)

   418 		{

   419 			char date[32];

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

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

   422 			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);

   423 			m_ErrMapStart = true;

   424 		}

   425 		LogToOpenFileEx(fp, vafmt, ap);

   426 		fclose(fp);

   427 	}

   428 	else

   429 	{

   430 		char error[255];

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

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

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

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

   435 		m_Active = false;

   436 		return;

   437 	}

   438 }

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

   441 {

   442 	m_CurMapName.assign(mapname);

   444 	switch (m_Mode)

   445 	{

   446 	case LoggingMode_Daily:

   447 		{

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

   449 			break;

   450 		}

   451 	case LoggingMode_PerMap:

   452 		{

   453 			_NewMapFile();

   454 			break;

   455 		}

   456 	default:

   457 		{

   458 			/* Do nothing... */

   459 			break;

   460 		}

   461 	}

   463 	if (m_ErrMapStart)

   464 	{

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

   466 	}

   467 	m_ErrMapStart = false;

   468 }

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

   471 {

   472 	char msg[3072];

   473 	size_t len;

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

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

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

   479 	msg[len] = '\0';

   481 	Engine_LogPrintWrapper(msg);

   482 }

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

   485 {

   486 	switch (type)

   487 	{

   488 	case LogType_Normal:

   489 		{

   490 			return m_NrmFileName.c_str();

   491 		}

   492 	case LogType_Error:

   493 		{

   494 			return m_ErrFileName.c_str();

   495 		}

   496 	default:

   497 		{

   498 			return "";

   499 		}

   500 	}

   501 }

   503 LoggingMode Logger::GetLoggingMode() const

   504 {

   505 	return m_Mode;

   506 }

   508 void Logger::EnableLogging()

   509 {

   510 	if (m_Active)

   511 	{

   512 		return;

   513 	}

   514 	m_Active = true;

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

   516 }

   518 void Logger::DisableLogging()

   519 {

   520 	if (!m_Active)

   521 	{

   522 		return;

   523 	}

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

   525 	m_Active = false;

   526 }

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

   529 {

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

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

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

   533 	 */

   535 	va_list ap;

   536 	char path[PLATFORM_MAX_PATH];

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

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

   541 	if (fp)

   542 	{

   543 		m_Active = true;

   544 		va_start(ap, msg);

   545 		LogToOpenFileEx(fp, msg, ap);

   546 		va_end(ap);

   547 		m_Active = false;

   548 		fclose(fp);

   549 	}

   550 }

   552 bool g_in_game_log_hook = false;

   554 void Engine_LogPrintWrapper(const char *msg)

   555 {

   556 	if (g_in_game_log_hook)

   557 	{

   558 		ENGINE_CALL(LogPrint)(msg);

   559 	}

   560 	else

   561 	{

   562 		engine->LogPrint(msg);

   563 	}

   564 }

author	Nicholas Hastings <skamonkey@gmail.com>
	Tue Jan 22 23:18:27 2013 -0500 (2013-01-22)
changeset 3749	4dc3d723c490
parent 3630	b72450a8be42
child 3791	47e1ee9cea86
permissions	-rw-r--r--