sourcemod-central: core/Logger.cpp@07a1b8a8a2ba

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

   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 	char buffer[3072];

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

   271 	char date[32];

   272 	time_t t;

   273 	GetAdjustedTime(&t);

   274 	tm *curtime = localtime(&t);

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

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

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

   279 }

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

   282 {

   283 	if (!m_Active)

   284 	{

   285 		return;

   286 	}

   288 	char buffer[3072];

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

   291 	char date[32];

   292 	time_t t;

   293 	GetAdjustedTime(&t);

   294 	tm *curtime = localtime(&t);

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

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

   298 	fflush(fp);

   299 }

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

   302 {

   303 	if (!m_Active)

   304 	{

   305 		return;

   306 	}

   308 	if (m_Mode == LoggingMode_Game)

   309 	{

   310 		va_list ap;

   311 		va_start(ap, vafmt);

   312 		_PrintToGameLog(vafmt, ap);

   313 		va_end(ap);

   314 		return;

   315 	}

   317 	if (m_DelayedStart)

   318 	{

   319 		m_DelayedStart = false;

   320 		_NewMapFile();

   321 	}

   323 	time_t t;

   324 	GetAdjustedTime(&t);

   325 	tm *curtime = localtime(&t);

   327 	FILE *fp = NULL;

   328 	if (m_Mode == LoggingMode_PerMap)

   329 	{

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

   331 		if (!fp)

   332 		{

   333 			_NewMapFile();

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

   335 			if (!fp)

   336 			{

   337 				goto print_error;

   338 			}

   339 		}

   340 	} else {

   341 		if (m_CurDay != curtime->tm_mday)

   342 		{

   343 			char _filename[256];

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

   345 			m_NrmFileName.assign(_filename);

   346 			m_CurDay = curtime->tm_mday;

   347 			m_DailyPrintHdr = true;

   348 		}

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

   350 	}

   352 	if (fp)

   353 	{

   354 		if (m_DailyPrintHdr)

   355 		{

   356 			char date[32];

   357 			m_DailyPrintHdr = false;

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

   359 			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_FULL_VERSION);

   360 	 	}

   361 		va_list ap;

   362 		va_start(ap, vafmt);

   363 		LogToOpenFileEx(fp, vafmt, ap);

   364 		va_end(ap);

   365 		fclose(fp);

   366 	} else {

   367 		goto print_error;

   368 	}

   370 	return;

   371 print_error:

   372 	char error[255];

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

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

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

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

   377 	m_Active = false;

   378 }

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

   381 {

   382 	va_list ap;

   383 	va_start(ap, vafmt);

   384 	LogErrorEx(vafmt, ap);

   385 	va_end(ap);

   386 }

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

   389 {

   390 	if (!m_Active)

   391 	{

   392 		return;

   393 	}

   395 	time_t t;

   396 	GetAdjustedTime(&t);

   397 	tm *curtime = localtime(&t);

   399 	if (curtime->tm_mday != m_CurDay)

   400 	{

   401 		char _filename[256];

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

   403 		m_ErrFileName.assign(_filename);

   404 		m_CurDay = curtime->tm_mday;

   405 		m_ErrMapStart = false;

   406 	}

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

   409 	if (fp)

   410 	{

   411 		if (!m_ErrMapStart)

   412 		{

   413 			char date[32];

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

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

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

   417 			m_ErrMapStart = true;

   418 		}

   419 		LogToOpenFileEx(fp, vafmt, ap);

   420 		fclose(fp);

   421 	}

   422 	else

   423 	{

   424 		char error[255];

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

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

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

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

   429 		m_Active = false;

   430 		return;

   431 	}

   432 }

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

   435 {

   436 	m_CurMapName.assign(mapname);

   438 	switch (m_Mode)

   439 	{

   440 	case LoggingMode_Daily:

   441 		{

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

   443 			break;

   444 		}

   445 	case LoggingMode_PerMap:

   446 		{

   447 			_NewMapFile();

   448 			break;

   449 		}

   450 	default:

   451 		{

   452 			/* Do nothing... */

   453 			break;

   454 		}

   455 	}

   457 	if (m_ErrMapStart)

   458 	{

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

   460 	}

   461 	m_ErrMapStart = false;

   462 }

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

   465 {

   466 	char msg[3072];

   467 	size_t len;

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

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

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

   473 	msg[len] = '\0';

   475 	Engine_LogPrintWrapper(msg);

   476 }

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

   479 {

   480 	switch (type)

   481 	{

   482 	case LogType_Normal:

   483 		{

   484 			return m_NrmFileName.c_str();

   485 		}

   486 	case LogType_Error:

   487 		{

   488 			return m_ErrFileName.c_str();

   489 		}

   490 	default:

   491 		{

   492 			return "";

   493 		}

   494 	}

   495 }

   497 LoggingMode Logger::GetLoggingMode() const

   498 {

   499 	return m_Mode;

   500 }

   502 void Logger::EnableLogging()

   503 {

   504 	if (m_Active)

   505 	{

   506 		return;

   507 	}

   508 	m_Active = true;

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

   510 }

   512 void Logger::DisableLogging()

   513 {

   514 	if (!m_Active)

   515 	{

   516 		return;

   517 	}

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

   519 	m_Active = false;

   520 }

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

   523 {

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

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

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

   527 	 */

   529 	va_list ap;

   530 	char path[PLATFORM_MAX_PATH];

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

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

   535 	if (fp)

   536 	{

   537 		m_Active = true;

   538 		va_start(ap, msg);

   539 		LogToOpenFileEx(fp, msg, ap);

   540 		va_end(ap);

   541 		m_Active = false;

   542 		fclose(fp);

   543 	}

   544 }

   546 bool g_in_game_log_hook = false;

   548 void Engine_LogPrintWrapper(const char *msg)

   549 {

   550 	if (g_in_game_log_hook)

   551 	{

   552 		ENGINE_CALL(LogPrint)(msg);

   553 	}

   554 	else

   555 	{

   556 		engine->LogPrint(msg);

   557 	}

   558 }

author	Nicholas Hastings <skamonkey@gmail.com>
	Fri Nov 04 10:01:33 2011 -0400 (2011-11-04)
changeset 3438	07a1b8a8a2ba
parent 2784	8903397125e6
child 3501	ba91db6d6c23
permissions	-rw-r--r--