Logger.hpp

Go to the documentation of this file.

/*
 * Logger.hpp
 * 
 * Copyright (C) 2022 by RStudio, PBC
 *
 * Unless you have received this program directly from RStudio pursuant to the terms of a commercial license agreement
 * with RStudio, then this program is licensed to you under the following terms:
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 */
 
#ifndef LAUNCHER_PLUGINS_LOGGER_HPP
#define LAUNCHER_PLUGINS_LOGGER_HPP
 
#include <map>
#include <memory>
#include <ostream>
#include <string>
#include <vector>
 
#include <boost/any.hpp>
#include <boost/function.hpp>
#include <Optional.hpp>
 
#include <system/User.hpp>
 
#include <PImpl.hpp>
 
namespace rstudio {
namespace launcher_plugins {
 
class Error;
class ErrorLocation;
 
} // namespace rstudio
} // namespace launcher_plugins
 
namespace rstudio {
namespace launcher_plugins {
namespace logging {
 
class ILogDestination;
 
struct RefreshParams
{
   Optional<launcher_plugins::system::User> newUser;
   bool chownLogDir;
};
 
constexpr char s_delim = ';';
 
enum class LogLevel
{
   OFF = 0,       // No messages will be logged.
   ERR = 1,       // Error messages will be logged.
   WARN = 2,      // Warning and error messages will be logged.
   INFO = 3,      // Info, warning, and error messages will be logged.
   DEBUG = 4      // All messages will be logged.
};
 
typedef std::vector<std::pair<std::string, boost::any>> LogMessageProperties;
 
enum class LogMessageFormatType
{
   PRETTY = 0,   // A human-readable single line log message format
   JSON   = 1    // A JSON format, one JSON object per line
};
 
std::string cleanDelimiters(const std::string& in_str);
 
void setProgramId(const std::string& in_programId);
 
void addLogDestination(const std::shared_ptr<ILogDestination>& in_destination);
 
void addLogDestination(const std::shared_ptr<ILogDestination>& in_destination, const std::string& in_section);
 
bool hasFileLogDestination();
 
bool hasStderrLogDestination();
 
bool isLogLevel(logging::LogLevel level);
 
std::string cleanDelims(const std::string& in_toClean);
 
void logError(const Error& in_error);
 
void logError(const Error& in_error, const ErrorLocation& in_location);
 
void logErrorAsWarning(const Error& in_error);
 
void logErrorAsInfo(const Error& in_error);
 
void logErrorAsDebug(const Error& in_error);
 
void logErrorMessage(const std::string& in_message, const std::string& in_section = std::string());
 
void logErrorMessage(const std::string& in_message, const ErrorLocation& in_loggedFrom);
 
void logErrorMessage(const std::string& in_message,
                     const std::string& in_section,
                     const Optional<LogMessageProperties>& in_properties,
                     const ErrorLocation& in_loggedFrom);
 
void logWarningMessage(const std::string& in_message, const std::string& in_section = std::string());
 
void logWarningMessage(const std::string& in_message, const ErrorLocation& in_loggedFrom);
 
void logWarningMessage(const std::string& in_message,
                       const std::string& in_section,
                       const Optional<LogMessageProperties>& in_properties,
                       const ErrorLocation& in_loggedFrom);
 
void logDebugMessage(const std::string& in_message, const std::string& in_section = std::string());
 
void logDebugMessage(const std::string& in_message, const ErrorLocation& in_loggedFrom);
 
void logDebugMessage(const std::string& in_message,
                     const std::string& in_section,
                     const Optional<LogMessageProperties>& in_properties,
                     const ErrorLocation& in_loggedFrom);
 
void logDebugAction(const boost::function<std::string(Optional<LogMessageProperties>*)>& in_action,
                    const std::string& in_section = std::string());
 
void logInfoMessage(const std::string& in_message, const std::string& in_section = std::string());
 
void logInfoMessage(const std::string& in_message, const ErrorLocation& in_loggedFrom);
 
void logInfoMessage(const std::string& in_message,
                    const std::string& in_section,
                    const Optional<LogMessageProperties>& in_properties,
                    const ErrorLocation& in_loggedFrom);
 
void logPassthroughMessage(const std::string& in_source, const std::string& in_message);
 
void refreshAllLogDestinations(const logging::RefreshParams& in_refreshParams = logging::RefreshParams());
 
void removeLogDestination(const std::string& in_destinationId, const std::string& in_section = std::string());
 
void removeReloadableLogDestinations();
 
 std::ostream& writeError(const Error& in_error, std::ostream& io_os);
std::string writeError(const Error& in_error);
 
} // namespace logging
} // namespace launcher_plugins
} // namespace rstudio
 
#endif