ArmarXFileLogger.cpp

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX 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/>.
 *
 * @package    ArmarXCore::ArmarXObjects::ArmarXFileLogger
 * @author     Mirko Waechter ( mirko dot waechter at kit dot edu )
 * @date       2017
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#include "ArmarXFileLogger.h"
 
#include <boost/format.hpp>
#include <boost/range/adaptor/reversed.hpp>
 
#include <ArmarXCore/core/system/ArmarXDataPath.h>
#include <ArmarXCore/core/util/FileSystemPathBuilder.h>
#include <ArmarXCore/core/util/StringHelpers.h>
#include <ArmarXCore/util/CPPUtility/filesystem.h>
 
namespace armarx
{
 
    ArmarXFileLoggerPropertyDefinitions::ArmarXFileLoggerPropertyDefinitions(std::string prefix) :
        armarx::ComponentPropertyDefinitions(prefix)
    {
        //defineRequiredProperty<std::string>("PropertyName", "Description");
        defineOptionalProperty<int>("MaxLogFileCount",
                                    100,
                                    "Number of log files to keep before starting to delete old "
                                    "files. If zero, no file will be deleted.");
        defineOptionalProperty<std::string>(
            "LogFileName", "ArmarXLog", "Logfilename without ending");
        defineOptionalProperty<std::string>("LogFileEnding", "log", "Logfilename  ending");
        defineOptionalProperty<std::string>(
            "LogDir",
            "",
            "If set, log will be stored in this path. If not set, log will be stored "
            "in $ARMARX_USER_CONFIG_DIR/log/ (or $HOME/.armarx/log/ if $ARMARX_USER_CONFIG_DIR is "
            "not set).");
        defineOptionalProperty<std::string>("LogTopicName", "Log", "Name of the topic to be used");
        defineOptionalProperty<bool>(
            "SplitByApplication", true, "Create additional log files for each application");
    }
 
    void
    ArmarXFileLogger::onInitComponent()
    {
        std::string directoryStr;
        if (getProperty<std::string>("LogDir").isSet())
        {
            directoryStr = getProperty<std::string>("LogDir").getValue();
            ArmarXDataPath::ReplaceEnvVars(directoryStr);
        }
        else if (const char* workspace = std::getenv("ARMARX_USER_CONFIG_DIR"))
        {
            directoryStr = (std::filesystem::path(workspace) / "log").string();
        }
        else
        {
            directoryStr = std::string("$HOME/.armarx/log/");
            ArmarXDataPath::ReplaceEnvVars(directoryStr);
        }
 
        auto directory = remove_trailing_separator(directoryStr);
        ARMARX_DEBUG << "Checking " << directory.string();
        if (!std::filesystem::exists(directory))
        {
            ARMARX_INFO << "Log path not found - creating it: " << directory.string();
            std::error_code errcode;
            std::filesystem::create_directories(directory, errcode);
            if (errcode)
            {
                ARMARX_ERROR << "Creating directories failed: " << errcode.message();
                return;
            }
        }
 
        auto ending = getProperty<std::string>("LogFileEnding").getValue();
        auto fileBasename = getProperty<std::string>("LogFileName").getValue();
        auto filename = getNextLogFileNameAndDeleteOldFiles(
            directoryStr, getProperty<int>("MaxLogFileCount").getValue(), fileBasename, ending);
 
 
        if (getProperty<bool>("SplitByApplication").getValue())
        {
            auto filePath = std::filesystem::path(filename);
            directory /= filePath.stem();
            if (!std::filesystem::exists(directory))
            {
                ARMARX_INFO << "Log path not found - creating it: " << directory;
                std::error_code errcode;
                std::filesystem::create_directories(directory, errcode);
                if (errcode)
                {
                    ARMARX_ERROR << "Creating directories failed: " << errcode.message();
                    return;
                }
            }
            applicationsLogFileBasePath =
                directory.string() + "/" + filePath.stem().string() + "-%1%." + ending;
        }
 
        //    FileSystemPathBuilder builder(getProperty<std::string>("LogFileName").getValue());
        auto logfilePath = std::filesystem::path(directoryStr) / std::filesystem::path(filename);
        fileStream.open(logfilePath.string().c_str(), std::ofstream::out);
        if (!fileStream.is_open())
        {
            ARMARX_ERROR << "Failed to open " << logfilePath.string();
            return;
        }
        ARMARX_INFO << "Logging to " << logfilePath.string();
        fileStream << "Log starting at " << IceUtil::Time::now().toDateTime() << ", "
                   << "with log name " << filename << "\n";
        usingTopic(getProperty<std::string>("LogTopicName").getValue());
    }
 
    void
    ArmarXFileLogger::onConnectComponent()
    {
    }
 
    void
    ArmarXFileLogger::onDisconnectComponent()
    {
        std::unique_lock lock(mutex);
        fileStream << std::flush;
        fileStream.close();
        applicationFileStreams.clear();
    }
 
    void
    ArmarXFileLogger::onExitComponent()
    {
    }
 
    armarx::PropertyDefinitionsPtr
    ArmarXFileLogger::createPropertyDefinitions()
    {
        return armarx::PropertyDefinitionsPtr(
            new ArmarXFileLoggerPropertyDefinitions(getConfigIdentifier()));
    }
 
    std::vector<std::string>
    ArmarXFileLogger::getDirListOrderedByDate(const std::string& dir) const
    {
        std::vector<std::string> result;
        namespace fs = std::filesystem;
        fs::path someDir(dir);
        fs::directory_iterator end_iter;
 
        using result_set_t = std::multimap<std::filesystem::file_time_type, fs::path>;
        result_set_t result_set;
 
        if (fs::exists(someDir) && fs::is_directory(someDir))
        {
            for (fs::directory_iterator dir_iter(someDir); dir_iter != end_iter; ++dir_iter)
            {
                if (fs::is_regular_file(dir_iter->status()))
                {
                    result_set.insert(
                        result_set_t::value_type(fs::last_write_time(dir_iter->path()), *dir_iter));
                }
            }
        }
        for (auto& elem : boost::adaptors::reverse(result_set))
        {
            result.push_back(elem.second.string());
        }
        return result;
    }
 
    std::string
    ArmarXFileLogger::getNextLogFileNameAndDeleteOldFiles(const std::string& dir,
                                                          int maxLogFileCount,
                                                          const std::string& fileBasename,
                                                          const std::string& fileNameEnding) const
    {
        auto files = getDirListOrderedByDate(dir);
        //    ARMARX_INFO << files;
        std::string connectorString = "-";
        const boost::regex e(fileBasename + connectorString + "([0-9]+)\\.");
        int trials = 0;
        int highestNumber = 0;
        for (auto file : files)
        {
            boost::match_results<std::string::const_iterator> what;
            file = std::filesystem::path(file).filename().string();
            ARMARX_DEBUG << file;
            bool found_match = boost::regex_search(file, what, e);
            if (found_match)
            {
                for (size_t i = 1; i < what.size(); i += 2)
                {
                    std::string numberStr = what[i];
                    int number = atoi(numberStr.c_str());
                    highestNumber = std::max(number, highestNumber);
                    //                ARMARX_INFO << "testing number " << number << VAROUT( trials) << VAROUT(highestNumber);
                    auto filenameCandidate = fileBasename + connectorString +
                                             ValueToString(number) + "." + fileNameEnding;
                    if (std::filesystem::exists(dir + "/" + filenameCandidate))
                    {
                        //                    ARMARX_INFO << "File exists " << VAROUT(filenameCandidate) << VAROUT(trials);
                        if (trials >= maxLogFileCount && maxLogFileCount > 0)
                        {
                            ARMARX_VERBOSE << "Deleting old log " << filenameCandidate;
                            std::filesystem::remove(dir + "/" + filenameCandidate);
                        }
                    }
                    trials++;
                }
            }
        }
        highestNumber++;
        return fileBasename + connectorString + ValueToString(highestNumber) + "." + fileNameEnding;
    }
 
    std::string
    ArmarXFileLogger::getDefaultName() const
    {
        return "ArmarXFileLogger";
    }
 
    void
    armarx::ArmarXFileLogger::writeLog(const LogMessage& msg, const Ice::Current&)
    {
        std::string catStr;
 
        if (!msg.tag.empty())
        {
            catStr = "[" + msg.tag + "]: ";
        }
        else
        {
            catStr = "[" + LogSender::CropFunctionName(msg.function) + "]: ";
        }
        IceUtil::Time time = IceUtil::Time::microSeconds(msg.time);
        std::unique_lock lock(mutex);
        if (!fileStream.is_open())
        {
            return;
        }
 
        std::string logLevel;
        switch (msg.type)
        {
            case armarx::MessageType::eUNDEFINED:
                logLevel = "UNDEFINED";
                break;
            case armarx::MessageType::eDEBUG:
                logLevel = "DEBUG";
                break;
            case armarx::MessageType::eVERBOSE:
                logLevel = "VERBOSE";
                break;
            case armarx::MessageType::eINFO:
                logLevel = "INFO";
                break;
            case armarx::MessageType::eIMPORTANT:
                logLevel = "IMPORTANT";
                break;
            case armarx::MessageType::eWARN:
                logLevel = "WARN";
                break;
            case armarx::MessageType::eERROR:
                logLevel = "ERROR";
                break;
            case armarx::MessageType::eFATAL:
                logLevel = "FATAL";
                break;
            case armarx::MessageType::eLogLevelCount:
                logLevel = "LogLevelCount";
                break;
        }
 
        std::stringstream newLines;
        newLines << "[" + time.toDateTime().substr(time.toDateTime().find(' ') + 1) + "]" + "[" +
                        msg.who + "]" + catStr + "[" + logLevel + "]";
        newLines << msg.what << "\n";
        fileStream << newLines.str();
        if (getProperty<bool>("SplitByApplication").getValue())
        {
            auto it = applicationFileStreams.find(msg.who);
            if (it == applicationFileStreams.end())
            {
                auto filepath = boost::format(applicationsLogFileBasePath) % msg.who;
                it = applicationFileStreams
                         .emplace(msg.who,
                                  std::shared_ptr<std::ofstream>(
                                      new std::ofstream(filepath.str().c_str())))
                         .first;
                //            it = applicationFileStreams.find(msg.who);
                if (!it->second->is_open())
                {
                    ARMARX_WARNING << "Failed to open for logging: " << filepath.str();
                    return;
                }
            }
 
            *(it->second) << newLines.str();
        }
    }
} // namespace armarx