sourcemod-central: core/Logger.cpp@8dfaa3d730b5

     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::LogToOpenFileEx(FILE *fp, const char *msg, va_list ap)

   249 {

   250 	if (!m_Active)

   251 	{

   252 		return;

   253 	}

   255 	char buffer[3072];

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

   258 	char date[32];

   259 	time_t t;

   260 	GetAdjustedTime(&t);

   261 	tm *curtime = localtime(&t);

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

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

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

   266 }

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

   269 {

   270 	if (!m_Active)

   271 	{

   272 		return;

   273 	}

   275 	if (m_Mode == LoggingMode_Game)

   276 	{

   277 		va_list ap;

   278 		va_start(ap, vafmt);

   279 		_PrintToGameLog(vafmt, ap);

   280 		va_end(ap);

   281 		return;

   282 	}

   284 	if (m_DelayedStart)

   285 	{

   286 		m_DelayedStart = false;

   287 		_NewMapFile();

   288 	}

   290 	time_t t;

   291 	GetAdjustedTime(&t);

   292 	tm *curtime = localtime(&t);

   294 	FILE *fp = NULL;

   295 	if (m_Mode == LoggingMode_PerMap)

   296 	{

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

   298 		if (!fp)

   299 		{

   300 			_NewMapFile();

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

   302 			if (!fp)

   303 			{

   304 				goto print_error;

   305 			}

   306 		}

   307 	} else {

   308 		if (m_CurDay != curtime->tm_mday)

   309 		{

   310 			char _filename[256];

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

   312 			m_NrmFileName.assign(_filename);

   313 			m_CurDay = curtime->tm_mday;

   314 			m_DailyPrintHdr = true;

   315 		}

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

   317 	}

   319 	if (fp)

   320 	{

   321 		if (m_DailyPrintHdr)

   322 		{

   323 			char date[32];

   324 			m_DailyPrintHdr = false;

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

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

   327 	 	}

   328 		va_list ap;

   329 		va_start(ap, vafmt);

   330 		LogToOpenFileEx(fp, vafmt, ap);

   331 		va_end(ap);

   332 		fclose(fp);

   333 	} else {

   334 		goto print_error;

   335 	}

   337 	return;

   338 print_error:

   339 	char error[255];

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

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

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

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

   344 	m_Active = false;

   345 }

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

   348 {

   349 	if (!m_Active)

   350 	{

   351 		return;

   352 	}

   354 	time_t t;

   355 	GetAdjustedTime(&t);

   356 	tm *curtime = localtime(&t);

   358 	if (curtime->tm_mday != m_CurDay)

   359 	{

   360 		char _filename[256];

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

   362 		m_ErrFileName.assign(_filename);

   363 		m_CurDay = curtime->tm_mday;

   364 		m_ErrMapStart = false;

   365 	}

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

   368 	if (fp)

   369 	{

   370 		if (!m_ErrMapStart)

   371 		{

   372 			char date[32];

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

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

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

   376 			m_ErrMapStart = true;

   377 		}

   378 		va_list ap;

   379 		va_start(ap, vafmt);

   380 		LogToOpenFileEx(fp, vafmt, ap);

   381 		va_end(ap);

   382 		fclose(fp);

   383 	}

   384 	else

   385 	{

   386 		char error[255];

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

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

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

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

   391 		m_Active = false;

   392 		return;

   393 	}

   394 }

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

   397 {

   398 	m_CurMapName.assign(mapname);

   400 	switch (m_Mode)

   401 	{

   402 	case LoggingMode_Daily:

   403 		{

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

   405 			break;

   406 		}

   407 	case LoggingMode_PerMap:

   408 		{

   409 			_NewMapFile();

   410 			break;

   411 		}

   412 	default:

   413 		{

   414 			/* Do nothing... */

   415 			break;

   416 		}

   417 	}

   419 	if (m_ErrMapStart)

   420 	{

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

   422 	}

   423 	m_ErrMapStart = false;

   424 }

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

   427 {

   428 	char msg[3072];

   429 	size_t len;

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

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

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

   435 	msg[len] = '\0';

   437 	Engine_LogPrintWrapper(msg);

   438 }

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

   441 {

   442 	switch (type)

   443 	{

   444 	case LogType_Normal:

   445 		{

   446 			return m_NrmFileName.c_str();

   447 		}

   448 	case LogType_Error:

   449 		{

   450 			return m_ErrFileName.c_str();

   451 		}

   452 	default:

   453 		{

   454 			return "";

   455 		}

   456 	}

   457 }

   459 LoggingMode Logger::GetLoggingMode() const

   460 {

   461 	return m_Mode;

   462 }

   464 void Logger::EnableLogging()

   465 {

   466 	if (m_Active)

   467 	{

   468 		return;

   469 	}

   470 	m_Active = true;

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

   472 }

   474 void Logger::DisableLogging()

   475 {

   476 	if (!m_Active)

   477 	{

   478 		return;

   479 	}

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

   481 	m_Active = false;

   482 }

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

   485 {

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

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

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

   489 	 */

   491 	va_list ap;

   492 	char path[PLATFORM_MAX_PATH];

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

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

   497 	if (fp)

   498 	{

   499 		m_Active = true;

   500 		va_start(ap, msg);

   501 		LogToOpenFileEx(fp, msg, ap);

   502 		va_end(ap);

   503 		m_Active = false;

   504 		fclose(fp);

   505 	}

   506 }

   508 bool g_in_game_log_hook = false;

   510 void Engine_LogPrintWrapper(const char *msg)

   511 {

   512 	if (g_in_game_log_hook)

   513 	{

   514 		ENGINE_CALL(LogPrint)(msg);

   515 	}

   516 	else

   517 	{

   518 		engine->LogPrint(msg);

   519 	}

   520 }

author	David Anderson <dvander@alliedmods.net>
	Sun Nov 16 16:06:18 2008 -0800 (2008-11-16)
changeset 2411	8dfaa3d730b5
parent 2289	44045ead61cd
child 2475	297d0a773483
permissions	-rw-r--r--