LogManager.hpp

Go to the documentation of this file.

/*
Copyright (c) 2017-2024,
Battelle Memorial Institute; Lawrence Livermore National Security, LLC; Alliance for Sustainable
Energy, LLC.  See the top-level NOTICE for additional details. All rights reserved.
SPDX-License-Identifier: BSD-3-Clause
*/
#pragma once
 
#include "../common/LogBuffer.hpp"
#include "../helics_enums.h"
#include "FederateIdExtra.hpp"
 
#include <atomic>
#include <functional>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
namespace spdlog {
class logger;
}
 
namespace helics {
class LogBuffer;
class helicsCLI11App;
class LogBuffer;
class ActionMessage;
 
class LogManager {
  private:
    std::string logIdentifier;
    std::atomic<int32_t> maxLogLevel{HELICS_LOG_LEVEL_WARNING};
    int32_t consoleLogLevel{HELICS_LOG_LEVEL_WARNING};
    int32_t fileLogLevel{HELICS_LOG_LEVEL_WARNING};
    std::vector<std::pair<GlobalFederateId, std::int32_t>> remoteTargets;
    std::shared_ptr<spdlog::logger> consoleLogger;
    std::shared_ptr<spdlog::logger> fileLogger;
    std::atomic<bool> initialized{false};
    mutable LogBuffer mLogBuffer;  
    std::function<void(int, std::string_view, std::string_view)> loggerFunction;
    std::function<void(ActionMessage&& mm)> mTransmit;
    std::string logFile;  
 
  public:
    std::atomic<bool> forceLoggingFlush{false};
 
    ~LogManager();
 
    void initializeLogging(const std::string& identifier);
 
    bool sendToLogger(int logLevel,
                      std::string_view header,
                      std::string_view message,
                      bool disableRemote = false) const;
    void addLoggingCLI(std::shared_ptr<helicsCLI11App>& app);
 
    void setLogLevel(int32_t level);
    void setLogLevels(int32_t consoleLevel, int32_t fileLevel);
    void logFlush();
 
    void setLoggerFunction(
        std::function<void(int level, std::string_view identifier, std::string_view message)>
            logFunction);
 
    void setTransmitCallback(std::function<void(ActionMessage&& mm)> transmit)
 
    {
        mTransmit = std::move(transmit);
    }
    int getMaxLevel() const { return maxLogLevel.load(); }
    int getFileLevel() const { return fileLogLevel; }
    int getConsoleLevel() const { return consoleLogLevel; }
    void setLoggingFile(std::string_view lfile, const std::string& identifier);
    LogBuffer& getLogBuffer() { return mLogBuffer; }
    void updateRemote(GlobalFederateId destination, int level);
 
  private:
    void updateMaxLogLevel();
};
 
}  // namespace helics