AsyncFileLogger.h

Go to the documentation of this file.

 
#pragma once
 
#include <trantor/utils/NonCopyable.h>
#include <trantor/utils/Date.h>
#include <trantor/exports.h>
#include <thread>
#include <mutex>
#include <string>
#include <condition_variable>
#include <sstream>
#include <memory>
#include <queue>
 
namespace trantor
{
using StringPtr = std::shared_ptr<std::string>;
using StringPtrQueue = std::queue<StringPtr>;

class TRANTOR_EXPORT AsyncFileLogger : NonCopyable
{
  public:
    void output(const char *msg, const uint64_t len);

    void flush();

    void startLogging();

    void setFileSizeLimit(uint64_t limit)
    {
        sizeLimit_ = limit;
    }

    void setMaxFiles(size_t maxFiles)
    {
        maxFiles_ = maxFiles;
    }

    void setSwitchOnLimitOnly(bool flag = true)
    {
        switchOnLimitOnly_ = flag;
    }

    void setFileName(const std::string &baseName,
                     const std::string &extName = ".log",
                     const std::string &path = "./")
    {
        fileBaseName_ = baseName;
        extName[0] == '.' ? fileExtName_ = extName
                          : fileExtName_ = std::string(".") + extName;
        filePath_ = path;
        if (filePath_.length() == 0)
            filePath_ = "./";
        if (filePath_[filePath_.length() - 1] != '/')
            filePath_ = filePath_ + "/";
    }
    ~AsyncFileLogger();
    AsyncFileLogger();
 
  protected:
    std::mutex mutex_;
    std::condition_variable cond_;
    StringPtr logBufferPtr_;
    StringPtr nextBufferPtr_;
    StringPtrQueue writeBuffers_;
    StringPtrQueue tmpBuffers_;
    void writeLogToFile(const StringPtr buf);
    std::unique_ptr<std::thread> threadPtr_;
    bool stopFlag_{false};
    void logThreadFunc();
    std::string filePath_{"./"};
    std::string fileBaseName_{"trantor"};
    std::string fileExtName_{".log"};
    uint64_t sizeLimit_{20 * 1024 * 1024};
    bool switchOnLimitOnly_{false};  // by default false, will generate new
                                     // file name on each destroy.
    size_t maxFiles_{0};
 
    class LoggerFile : NonCopyable
    {
      public:
        LoggerFile(const std::string &filePath,
                   const std::string &fileBaseName,
                   const std::string &fileExtName,
                   bool switchOnLimitOnly = false,
                   size_t maxFiles = 0);
        ~LoggerFile();
        void writeLog(const StringPtr buf);
        void open();
        void switchLog(bool openNewOne);
        uint64_t getLength();
        explicit operator bool() const
        {
            return fp_ != nullptr;
        }
        void flush();
 
      protected:
        void initFilenameQueue();
        void deleteOldFiles();
 
        FILE *fp_{nullptr};
        Date creationDate_;
        std::string fileFullName_;
        std::string filePath_;
        std::string fileBaseName_;
        std::string fileExtName_;
        static uint64_t fileSeq_;
        bool switchOnLimitOnly_{false};  // by default false, will generate new
                                         // file name on each destroy
 
        size_t maxFiles_{0};
        // store generated filenames
        std::deque<std::string> filenameQueue_;
    };
    std::unique_ptr<LoggerFile> loggerFilePtr_;
 
    uint64_t lostCounter_{0};
    void swapBuffer();
};
 
}  // namespace trantor