sourcemod/core/Logger.cpp

/**
 * vim: set ts=4 sw=4 :
 * =============================================================================
 * SourceMod
 * Copyright (C) 2004-2009 AlliedModders LLC.  All rights reserved.
 * =============================================================================
 *
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, version 3.0, as published by the
 * Free Software Foundation.
 * 
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * As a special exception, AlliedModders LLC gives you permission to link the
 * code of this program (as well as its derivative works) to "Half-Life 2," the
 * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
 * by the Valve Corporation.  You must obey the GNU General Public License in
 * all respects for all other code used.  Additionally, AlliedModders LLC grants
 * this exception to all derivative works.  AlliedModders LLC defines further
 * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
 * or <http://www.sourcemod.net/license.php>.
 *
 * Version: $Id$
 */

#include <time.h>
#include "sourcemod.h"
#include "sourcemm_api.h"
#include "sm_stringutil.h"
#include "Logger.h"
#include "LibrarySys.h"
#include "TimerSys.h"
#include <sourcemod_version.h>

Logger g_Logger;

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

ConfigResult Logger::OnSourceModConfigChanged(const char *key, 
									  const char *value, 
									  ConfigSource source,
									  char *error, 
									  size_t maxlength)
{
	if (strcasecmp(key, "Logging") == 0)
	{
		bool state;

		if (strcasecmp(value, "on") == 0)
		{
			state = true;
		} else if (strcasecmp(value, "off") == 0) {
			state = false;
		} else {
			UTIL_Format(error, maxlength, "Invalid value: must be \"on\" or \"off\"");
			return ConfigResult_Reject;
		}

		if (source == ConfigSource_Console)
		{
			state ? EnableLogging() : DisableLogging();
		} else {
			m_InitialState = state;
		}

		return ConfigResult_Accept;
	} else if (strcasecmp(key, "LogMode") == 0) {
		if (strcasecmp(value, "daily") == 0) 
		{
			m_Mode = LoggingMode_Daily;
		} else if (strcasecmp(value, "map") == 0) {
			m_Mode = LoggingMode_PerMap;
		} else if (strcasecmp(value, "game") == 0) {
			m_Mode = LoggingMode_Game;
		} else {
			UTIL_Format(error, maxlength, "Invalid value: must be [daily|map|game]");
			return ConfigResult_Reject;
		}

		return ConfigResult_Accept;
	}

	return ConfigResult_Ignore;
}

void Logger::OnSourceModStartup(bool late)
{
	InitLogger(m_Mode);
}

void Logger::OnSourceModAllShutdown()
{
	CloseLogger();
}

void Logger::OnSourceModLevelChange(const char *mapName)
{
	MapChange(mapName);
}

void Logger::_NewMapFile()
{
	if (!m_Active)
	{
		return;
	}

	/* Append "Log file closed" to previous log file */
	_CloseFile();
	
	char _filename[256];
	int i = 0;

	time_t t;
	GetAdjustedTime(&t);
	tm *curtime = localtime(&t);

	while (true)
	{
		g_SourceMod.BuildPath(Path_SM, _filename, sizeof(_filename), "logs/L%02d%02d%03d.log", curtime->tm_mon + 1, curtime->tm_mday, i);
		FILE *fp = fopen(_filename, "r");
		if (!fp)
		{
			break;
		}
		fclose(fp);
		i++;
	}
	m_NrmFileName.assign(_filename);

	FILE *fp = fopen(m_NrmFileName.c_str(), "w");
	if (!fp)
	{
		char error[255];
		g_LibSys.GetPlatformError(error, sizeof(error));
		LogFatal("[SM] Unexpected fatal logging error (file \"%s\")", m_NrmFileName.c_str());
		LogFatal("[SM] Platform returned error: \"%s\"", error);
		LogFatal("[SM] Logging has been disabled.");
		m_Active = false;
		return;
	} else {
		char date[32];
		strftime(date, sizeof(date), "%m/%d/%Y - %H:%M:%S", curtime);
		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);
		fclose(fp);
	}
}

void Logger::_CloseFile()
{
	if (!m_Active)
	{
		return;
	}

	FILE *fp = NULL;
	if (!m_NrmFileName.empty())
	{
		fp = fopen(m_NrmFileName.c_str(), "r+");
		if (fp)
		{
			fseek(fp, 0, SEEK_END);
			LogMessage("Log file closed.");
			fclose(fp);
		}
		m_NrmFileName.clear();
	}

	if (!m_ErrMapStart)
	{
		return;
	}
	fp = fopen(m_ErrFileName.c_str(), "r+");
	if (fp)
	{
		fseek(fp, 0, SEEK_END);
		LogError("Error log file session closed.");
		fclose(fp);
	}
	m_ErrFileName.clear();
}

void Logger::InitLogger(LoggingMode mode)
{
	m_Mode = mode;
	m_Active = m_InitialState;

	time_t t;
	GetAdjustedTime(&t);
	tm *curtime = localtime(&t);
	m_CurDay = curtime->tm_mday;

	char _filename[256];
	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);
	m_ErrFileName.assign(_filename);

	switch (m_Mode)
	{
	case LoggingMode_PerMap:
		{
			if (!m_Active)
			{
				m_DelayedStart = true;
			}
			break;
		}
	case LoggingMode_Daily:
		{
			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);
			m_NrmFileName.assign(_filename);
			m_DailyPrintHdr = true;
			break;
		}
	default:
		{
			/* do nothing... */
			break;
		}
	}
}

void Logger::CloseLogger()
{
	_CloseFile();
}

void Logger::LogToOpenFile(FILE *fp, const char *msg, ...)
{
	if (!m_Active)
	{
		return;
	}

	va_list ap;
	va_start(ap, msg);
	LogToOpenFileEx(fp, msg, ap);
	va_end(ap);
}

void Logger::LogToFileOnly(FILE *fp, const char *msg, ...)
{
	if (!m_Active)
	{
		return;
	}

	va_list ap;
	va_start(ap, msg);
	LogToFileOnlyEx(fp, msg, ap);
	va_end(ap);
}

void Logger::LogToOpenFileEx(FILE *fp, const char *msg, va_list ap)
{
	if (!m_Active)
	{
		return;
	}

	char buffer[3072];
	UTIL_FormatArgs(buffer, sizeof(buffer), msg, ap);

	char date[32];
	time_t t;
	GetAdjustedTime(&t);
	tm *curtime = localtime(&t);
	strftime(date, sizeof(date), "%m/%d/%Y - %H:%M:%S", curtime);

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

void Logger::LogToFileOnlyEx(FILE *fp, const char *msg, va_list ap)
{
	if (!m_Active)
	{
		return;
	}

	char buffer[3072];
	UTIL_FormatArgs(buffer, sizeof(buffer), msg, ap);

	char date[32];
	time_t t;
	GetAdjustedTime(&t);
	tm *curtime = localtime(&t);
	strftime(date, sizeof(date), "%m/%d/%Y - %H:%M:%S", curtime);

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

void Logger::LogMessage(const char *vafmt, ...)
{
	if (!m_Active)
	{
		return;
	}

	if (m_Mode == LoggingMode_Game)
	{
		va_list ap;
		va_start(ap, vafmt);
		_PrintToGameLog(vafmt, ap);
		va_end(ap);
		return;
	}

	if (m_DelayedStart)
	{
		m_DelayedStart = false;
		_NewMapFile();
	}

	time_t t;
	GetAdjustedTime(&t);
	tm *curtime = localtime(&t);

	FILE *fp = NULL;
	if (m_Mode == LoggingMode_PerMap)
	{
		fp = fopen(m_NrmFileName.c_str(), "a+");
		if (!fp)
		{
			_NewMapFile();
			fp = fopen(m_NrmFileName.c_str(), "a+");
			if (!fp)
			{
				goto print_error;
			}
		}
	} else {
		if (m_CurDay != curtime->tm_mday)
		{
			char _filename[256];
			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);
			m_NrmFileName.assign(_filename);
			m_CurDay = curtime->tm_mday;
			m_DailyPrintHdr = true;
		}
		fp = fopen(m_NrmFileName.c_str(), "a+");
	}

	if (fp)
	{
		if (m_DailyPrintHdr)
		{
			char date[32];
			m_DailyPrintHdr = false;
			strftime(date, sizeof(date), "%m/%d/%Y - %H:%M:%S", curtime);
			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);
	 	}
		va_list ap;
		va_start(ap, vafmt);
		LogToOpenFileEx(fp, vafmt, ap);
		va_end(ap);
		fclose(fp);
	} else {
		goto print_error;
	}

	return;
print_error:
	char error[255];
	g_LibSys.GetPlatformError(error, sizeof(error));
	LogFatal("[SM] Unexpected fatal logging error (file \"%s\")", m_NrmFileName.c_str());
	LogFatal("[SM] Platform returned error: \"%s\"", error);
	LogFatal("[SM] Logging has been disabled.");
	m_Active = false;
}

void Logger::LogError(const char *vafmt, ...)
{
	va_list ap;
	va_start(ap, vafmt);
	LogErrorEx(vafmt, ap);
	va_end(ap);
}

void Logger::LogErrorEx(const char *vafmt, va_list ap)
{
	if (!m_Active)
	{
		return;
	}

	time_t t;
	GetAdjustedTime(&t);
	tm *curtime = localtime(&t);

	if (curtime->tm_mday != m_CurDay)
	{
		char _filename[256];
		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);
		m_ErrFileName.assign(_filename);
		m_CurDay = curtime->tm_mday;
		m_ErrMapStart = false;
	}

	FILE *fp = fopen(m_ErrFileName.c_str(), "a+");
	if (fp)
	{
		if (!m_ErrMapStart)
		{
			char date[32];
			strftime(date, sizeof(date), "%m/%d/%Y - %H:%M:%S", curtime);
			fprintf(fp, "L %s: SourceMod error session started\n", date);
			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);
			m_ErrMapStart = true;
		}
		LogToOpenFileEx(fp, vafmt, ap);
		fclose(fp);
	}
	else
	{
		char error[255];
		g_LibSys.GetPlatformError(error, sizeof(error));
		LogFatal("[SM] Unexpected fatal logging error (file \"%s\")", m_NrmFileName.c_str());
		LogFatal("[SM] Platform returned error: \"%s\"", error);
		LogFatal("[SM] Logging has been disabled.");
		m_Active = false;
		return;
	}
}

void Logger::MapChange(const char *mapname)
{
	m_CurMapName.assign(mapname);

	switch (m_Mode)
	{
	case LoggingMode_Daily:
		{
			LogMessage("-------- Mapchange to %s --------", mapname);
			break;
		}
	case LoggingMode_PerMap:
		{
			_NewMapFile();
			break;
		}
	default:
		{
			/* Do nothing... */
			break;
		}
	}

	if (m_ErrMapStart)
	{
		LogError("Error log file session closed.");
	}
	m_ErrMapStart = false;
}

void Logger::_PrintToGameLog(const char *fmt, va_list ap)
{
	char msg[3072];
	size_t len;

	len = vsnprintf(msg, sizeof(msg)-2, fmt, ap);
	len = (len >= sizeof(msg)) ? (sizeof(msg) - 2) : len;

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

	Engine_LogPrintWrapper(msg);
}

const char *Logger::GetLogFileName(LogType type) const
{
	switch (type)
	{
	case LogType_Normal:
		{
			return m_NrmFileName.c_str();
		}
	case LogType_Error:
		{
			return m_ErrFileName.c_str();
		}
	default:
		{
			return "";
		}
	}
}

LoggingMode Logger::GetLoggingMode() const
{
	return m_Mode;
}

void Logger::EnableLogging()
{
	if (m_Active)
	{
		return;
	}
	m_Active = true;
	LogMessage("[SM] Logging enabled manually by user.");
}

void Logger::DisableLogging()
{
	if (!m_Active)
	{
		return;
	}
	LogMessage("[SM] Logging disabled manually by user.");
	m_Active = false;
}

void Logger::LogFatal(const char *msg, ...)
{
	/* :TODO: make this print all pretty-like
	 * In fact, the pretty log printing function should be abstracted. 
	 * It's already implemented twice which is bad.
	 */

	va_list ap;
	char path[PLATFORM_MAX_PATH];

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

	FILE *fp = fopen(path, "at");
	if (fp)
	{
		m_Active = true;
		va_start(ap, msg);
		LogToOpenFileEx(fp, msg, ap);
		va_end(ap);
		m_Active = false;
		fclose(fp);
	}
}

bool g_in_game_log_hook = false;

void Engine_LogPrintWrapper(const char *msg)
{
	if (g_in_game_log_hook)
	{
		ENGINE_CALL(LogPrint)(msg);
	}
	else
	{
		engine->LogPrint(msg);
	}
}