Logger.cpp

Go to the documentation of this file.

#include "Logger.h"

#include <io.h>
#include <fcntl.h>
#include <sys/stat.h>
#include "../Common/server.h"
#include "Networking.h"
#include <fstream>
#include <sstream>

void Logger::Log(const char* msg, Level level, int errorCode)
{
        lastError = msg;
        lastLevel = level;
        lastErrorCode = errorCode;

        SYSTEMTIME st;
        GetLocalTime(&st);
        char timemsg[999];
        sprintf_s(timemsg, 999, "%02i:%02i:%02i.%03i  ", st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
        switch (level)
        {
        case Level::Warn:
                strcat_s(timemsg, 999, "Warning: ");
                break;
        case Level::Debug:
                strcat_s(timemsg, 999, "DEBUG: ");
                break;
        case Level::Error:
                strcat_s(timemsg, 999, "ERROR: ");
                break;
        case Level::Fatal:
                strcat_s(timemsg, 999, "FATAL: ");
                break;
        default:
                break;
        }
        strcat_s(timemsg, 999, msg);
        if (errorCode != 0)
        {
                char errorcodemsg[99];
                sprintf_s(errorcodemsg, 99, " (0x%x)", errorCode);
                strcat_s(timemsg, 999, errorcodemsg);
        }
        strcat_s(timemsg, 999, "\n");

        _write(logfile, timemsg, static_cast<unsigned int>(strlen(timemsg)));

        if (level == Level::Fatal || level == Level::Error || level == Level::Debug)
        {
                SErrorPacket errorPacket = SErrorPacket();
                errorPacket.level = level;
                sprintf_s(errorPacket.entry, 256, "%.255s", msg);
                errorPacket.stackTrace[0] = 0;
                for (int i = 4; i >= 0; i--)
                {
                        strcat_s(errorPacket.stackTrace, 256, callStack[i]);
                        strcat_s(errorPacket.stackTrace, 256, "\n");
                }

                networking->SendErrorReport(&errorPacket);
        }

        if (level == Level::Fatal)
        {
                LogStackTrace();

                std::ifstream t(fileName);
                std::stringstream buffer;
                buffer << t.rdbuf();
                networking->SendTraceFile(buffer.str().c_str());
                networking->Flush();

                if (!DXUTIsWindowed())
                {
                        DXUTToggleFullScreen();
                        SetCursor(LoadCursor(nullptr, IDC_ARROW));
                }
                MessageBoxA(DXUTGetHWND(), msg, "Fatal Exception", MB_ICONERROR | MB_OK);
                networking->Close();
                exit(errorCode);
        }
}

// add to back so newest is on bottom
void Logger::AddToCallStack(const char* msg)
{
        for (int i = 0; i < 4; i++)
                strcpy_s(callStack[i], 80, callStack[i + 1]);

        strcpy_s(callStack[4], 80, msg);
}

// spits them out in the opposite order they were added ... so newest is on top
void Logger::LogStackTrace()
{
        for (int i = 4; i >= 0; i--)
        {
                char line[80];
                sprintf_s(line, 80, " --> %s", callStack[i]);
                Log(line);
        }
}

void Logger::SetNetworkingPointer(Networking* prmNetworking)
{
        networking = prmNetworking;
}

void Logger::RemoveOldFiles(const wchar_t *searchkey, int maxDays)
{
        WIN32_FIND_DATA fd;
        HANDLE h = FindFirstFile(searchkey, &fd);
        if (h == INVALID_HANDLE_VALUE)
        {
                return; // no files found
        }
        SYSTEMTIME st;
        FILETIME ft;
        GetLocalTime(&st);
        SystemTimeToFileTime(&st, &ft);
        while (true)
        {
                LONGLONG diffInTicks = reinterpret_cast<LARGE_INTEGER*>(&ft)->QuadPart - reinterpret_cast<LARGE_INTEGER*>(&fd.ftCreationTime)->QuadPart;
                LONGLONG diffInMillis = diffInTicks / 10000;
                LONGLONG diffInDays = diffInMillis / 86400000;
                if (diffInDays > maxDays)
                        _wremove(fd.cFileName);
                if (!FindNextFile(h, &fd))
                        break;
        }
}

Logger::Logger()
{
        // clean up old logs
        RemoveOldFiles(L"trace_*.log", 7);

        SYSTEMTIME st;
        GetLocalTime(&st);
        sprintf_s(fileName, 99, "trace_%i-%02i-%02i-%02i%02i.log", st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute);
        _sopen_s(&logfile, fileName, _O_RDWR | _O_CREAT | _O_TEXT | _O_APPEND | _O_SEQUENTIAL, SH_DENYWR, S_IWRITE);
        if (logfile == -1)
        {
                MessageBox(DXUTGetHWND(), L"Could not open logfile for writing!", L"Fatal Exception", MB_ICONERROR | MB_OK);
                exit(errno);
        }
        char msg[99];
        sprintf_s(msg, 99, "Logger::ctor Opened logfile \"%s\"", fileName);
        Log(msg);

        for (int i = 0; i < 5; i++)
                callStack[i][0] = 0;
}

Logger::~Logger()
{
        Log("Logger::dtor Closing logfile...");
        _close(logfile);
        logfile = -1;
}