sourcemod-central: core/Logger.cpp@46c76edb0875

     1 /**

     2  * vim: set ts=4 :

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

     4  * SourceMod

     5  * Copyright (C) 2004-2008 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 "sm_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, SVN_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, SVN_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 	if (!m_Active)

   383 	{

   384 		return;

   385 	}

   387 	time_t t;

   388 	GetAdjustedTime(&t);

   389 	tm *curtime = localtime(&t);

   391 	if (curtime->tm_mday != m_CurDay)

   392 	{

   393 		char _filename[256];

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

   395 		m_ErrFileName.assign(_filename);

   396 		m_CurDay = curtime->tm_mday;

   397 		m_ErrMapStart = false;

   398 	}

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

   401 	if (fp)

   402 	{

   403 		if (!m_ErrMapStart)

   404 		{

   405 			char date[32];

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

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

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

   409 			m_ErrMapStart = true;

   410 		}

   411 		va_list ap;

   412 		va_start(ap, vafmt);

   413 		LogToOpenFileEx(fp, vafmt, ap);

   414 		va_end(ap);

   415 		fclose(fp);

   416 	}

   417 	else

   418 	{

   419 		char error[255];

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

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

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

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

   424 		m_Active = false;

   425 		return;

   426 	}

   427 }

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

   430 {

   431 	m_CurMapName.assign(mapname);

   433 	switch (m_Mode)

   434 	{

   435 	case LoggingMode_Daily:

   436 		{

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

   438 			break;

   439 		}

   440 	case LoggingMode_PerMap:

   441 		{

   442 			_NewMapFile();

   443 			break;

   444 		}

   445 	default:

   446 		{

   447 			/* Do nothing... */

   448 			break;

   449 		}

   450 	}

   452 	if (m_ErrMapStart)

   453 	{

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

   455 	}

   456 	m_ErrMapStart = false;

   457 }

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

   460 {

   461 	char msg[3072];

   462 	size_t len;

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

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

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

   468 	msg[len] = '\0';

   470 	Engine_LogPrintWrapper(msg);

   471 }

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

   474 {

   475 	switch (type)

   476 	{

   477 	case LogType_Normal:

   478 		{

   479 			return m_NrmFileName.c_str();

   480 		}

   481 	case LogType_Error:

   482 		{

   483 			return m_ErrFileName.c_str();

   484 		}

   485 	default:

   486 		{

   487 			return "";

   488 		}

   489 	}

   490 }

   492 LoggingMode Logger::GetLoggingMode() const

   493 {

   494 	return m_Mode;

   495 }

   497 void Logger::EnableLogging()

   498 {

   499 	if (m_Active)

   500 	{

   501 		return;

   502 	}

   503 	m_Active = true;

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

   505 }

   507 void Logger::DisableLogging()

   508 {

   509 	if (!m_Active)

   510 	{

   511 		return;

   512 	}

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

   514 	m_Active = false;

   515 }

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

   518 {

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

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

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

   522 	 */

   524 	va_list ap;

   525 	char path[PLATFORM_MAX_PATH];

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

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

   530 	if (fp)

   531 	{

   532 		m_Active = true;

   533 		va_start(ap, msg);

   534 		LogToOpenFileEx(fp, msg, ap);

   535 		va_end(ap);

   536 		m_Active = false;

   537 		fclose(fp);

   538 	}

   539 }

   541 bool g_in_game_log_hook = false;

   543 void Engine_LogPrintWrapper(const char *msg)

   544 {

   545 	if (g_in_game_log_hook)

   546 	{

   547 		ENGINE_CALL(LogPrint)(msg);

   548 	}

   549 	else

   550 	{

   551 		engine->LogPrint(msg);

   552 	}

   553 }

author	David Anderson <dvander@alliedmods.net>
	Wed Feb 25 20:25:20 2009 -0500 (2009-02-25)
changeset 2613	46c76edb0875
parent 2475	297d0a773483
child 2726	c96f3fab8211
permissions	-rw-r--r--