Core/Log: Rotate logs when maximum size is exceeded, backup name will be "filename".datetime

- This is an addition to 39c2d89

3 files changed, 54 insertions, 45 deletions

diff --git a/src/server/authserver/authserver.conf.dist b/src/server/authserver/authserver.conf.dist
index 67d22c49da1..dda19c3b849 100644
--- a/src/server/authserver/authserver.conf.dist
+++ b/src/server/authserver/authserver.conf.dist
@@ -154,7 +154,7 @@ LoginDatabase.WorkerThreads = 1
 #  Appender config values: Given a appender "name"
 #    Appender.name
 #        Description: Defines 'where to log'
-#        Format:      Type,LogLevel,Flags,optional1,optional2
+#        Format:      Type,LogLevel,Flags,optional1,optional2,optional3
 #
 #                     Type
 #                         0 - (None)
@@ -205,6 +205,13 @@ LoginDatabase.WorkerThreads = 1
 #                          a - (Append)
 #                          w - (Overwrite)
 #
+#                     MaxFileSize: Maximum file size of the log file before creating a new log file
+#                     (read as optional3 if Type = File)
+#                         Size is measured in bytes expressed in a 64-bit unsigned integer.
+#                         Maximum value is 4294967295 (4 gb). Leave blank for no limit.
+#                         NOTE: Does not work with dynamic filenames.
+#                         Example:  536870912 (512 mb)
+#
 
 Appender.Console=1,2,0
 Appender.Auth=2,2,0,Auth.log,w
@@ -250,4 +257,4 @@ Logger.Root=0,3,Console Auth
 Loggers=Root
 
 #
-###################################################################################################
\ No newline at end of file
+###################################################################################################
diff --git a/src/server/shared/Logging/AppenderFile.cpp b/src/server/shared/Logging/AppenderFile.cpp
index c2f1e0c919d..1ed6350f813 100644
--- a/src/server/shared/Logging/AppenderFile.cpp
+++ b/src/server/shared/Logging/AppenderFile.cpp
@@ -18,74 +18,75 @@
 #include "AppenderFile.h"
 #include "Common.h"
 
-AppenderFile::AppenderFile(uint8 id, std::string const& name, LogLevel level, const char* _filename, const char* _logDir, const char* _mode, AppenderFlags _flags, uint64 fileSize)
-    : Appender(id, name, APPENDER_FILE, level, _flags)
-    , filename(_filename)
-    , logDir(_logDir)
-    , mode(_mode)
-    , _fileSize(fileSize)
+AppenderFile::AppenderFile(uint8 id, std::string const& name, LogLevel level, const char* _filename, const char* _logDir, const char* _mode, AppenderFlags _flags, uint64 fileSize):
+    Appender(id, name, APPENDER_FILE, level, _flags),
+    filename(_filename),
+    logDir(_logDir),
+    mode(_mode),
+    maxFileSize(fileSize),
+    fileSize(0)
 {
     dynamicName = std::string::npos != filename.find("%s");
     backup = _flags & APPENDER_FLAGS_MAKE_FILE_BACKUP;
 
-    logfile = !dynamicName ? OpenFile(_filename, _mode, backup) : NULL;
+    logfile = !dynamicName ? OpenFile(_filename, _mode, mode == "w" && backup) : NULL;
 }
 
 AppenderFile::~AppenderFile()
 {
-    if (logfile)
-    {
-        fclose(logfile);
-        logfile = NULL;
-    }
+    CloseFile();
 }
 
 void AppenderFile::_write(LogMessage const& message)
 {
+    bool exceedMaxSize = maxFileSize > 0 && (fileSize + message.Size()) > maxFileSize;
+
     if (dynamicName)
     {
         char namebuf[TRINITY_PATH_MAX];
         snprintf(namebuf, TRINITY_PATH_MAX, filename.c_str(), message.param1.c_str());
-        logfile = OpenFile(namebuf, mode, backup);
-        _fileSize = ftell(logfile);
+        logfile = OpenFile(namebuf, mode, backup || exceedMaxSize);
     }
+	else if (exceedMaxSize)
+        logfile = OpenFile(filename, "w", true);
 
-    if (logfile)
-    {
-        if (!dynamicName && _fileSize + message.Size() > _maxFileSize)
-        {
-            /** @ We assume all log files have a .log extension.
-             If file "gol.log" is at its max capacity, this will spawn a new file, "gol_.log". If that one reaches capacity, it'll spawn "gol__.log", etc.
-            */
-            filename.replace(filename.end() - 3, filename.end(), "_.log");
-            logfile = OpenFile(filename.c_str(), mode, backup);
-            _write(message);
-            return;
-        }
+    if (!logfile)
+        return;
 
-        fprintf(logfile, "%s%s", message.prefix.c_str(), message.text.c_str());
-        fflush(logfile);
-        _fileSize += message.Size();
+    fprintf(logfile, "%s%s", message.prefix.c_str(), message.text.c_str());
+    fflush(logfile);
+    fileSize += message.Size();
 
-        if (dynamicName)
-        {
-            fclose(logfile);
-            logfile = NULL;
-        }
-    }
+    if (dynamicName)
+        CloseFile();
 }
 
 FILE* AppenderFile::OpenFile(std::string const &filename, std::string const &mode, bool backup)
 {
-    if (mode == "w" && backup)
+    std::string fullName(logDir + filename);
+    if (backup)
     {
-        std::string newName(filename);
+        CloseFile();
+        std::string newName(fullName);
         newName.push_back('.');
         newName.append(LogMessage::getTimeStr(time(NULL)));
-        rename(filename.c_str(), newName.c_str()); // no error handling... if we couldn't make a backup, just ignore
+        rename(fullName.c_str(), newName.c_str()); // no error handling... if we couldn't make a backup, just ignore
     }
 
-    FILE* ret = fopen((logDir + filename).c_str(), mode.c_str());
-    _fileSize = ftell(ret);
-    return ret;
+    if (FILE* ret = fopen(fullName.c_str(), mode.c_str()))
+    {
+        fileSize = ftell(ret);
+        return ret;
+    }
+
+    return NULL;
+}
+
+void AppenderFile::CloseFile()
+{
+    if (logfile)
+    {
+        fclose(logfile);
+        logfile = NULL;
+    }
 }
diff --git a/src/server/shared/Logging/AppenderFile.h b/src/server/shared/Logging/AppenderFile.h
index 4f3055bd6be..c15974799e1 100644
--- a/src/server/shared/Logging/AppenderFile.h
+++ b/src/server/shared/Logging/AppenderFile.h
@@ -28,6 +28,7 @@ class AppenderFile: public Appender
         FILE* OpenFile(std::string const& _name, std::string const& _mode, bool _backup);
 
     private:
+        void CloseFile();
         void _write(LogMessage const& message);
         FILE* logfile;
         std::string filename;
@@ -35,8 +36,8 @@ class AppenderFile: public Appender
         std::string mode;
         bool dynamicName;
         bool backup;
-        uint64 _maxFileSize;
-        uint64 _fileSize;
+        uint64 maxFileSize;
+        uint64 fileSize;
 };
 
 #endif