folkslinux
/
mamba
mirror of https://github.com/mamba-org/mamba.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

wip: (builds, dont run correctly) 

- fixed logging api to match spdlog meaning
- spdlog handler impl
- more applied logging api usage
- source location
This commit is contained in:
Klaim (Joël Lamotte) 2025-07-16 14:36:35 +02:00 committed by Joël Lamotte (Klaim)
parent 716257ac2d
commit 20ba69a17f
18 changed files with 339 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
libmamba/include/mamba/core/context.hpp
View File

@ -273,6 +273,8 @@ namespace mamba
void dump_backtrace_no_guards();
void set_verbosity(int lvl);
[[deprecated("Use `mamba::logging::set_log_level` instead")]]
void set_log_level(log_level level);
/// Setups the required core subsystems for `libmamba`'s high-level operations to work,
@ -283,9 +285,9 @@ namespace mamba
/// @param log_handler
/// Log handler implementation to use once the logging system starts.
/// Ignored if `options.enable_logging == false`.
/// If `options.enable_logging == true and log_handler.has_value() == false`,\
/// If `options.enable_logging == true and log_handler.has_value() == false`,
/// which is the default if this parameter is not specified,
/// then a default implementation-defined log handler implementation will be installed.
/// then a default implementation-defined log handler implementation will be used.
Context(const ContextOptions& options = {}, logging::AnyLogHandler log_handler = {});
~Context();

206
libmamba/include/mamba/core/logging.hpp
View File

@ -17,6 +17,7 @@
#include <typeindex>
#include <utility>
#include <vector>
#include <source_location>
namespace mamba
{
@ -29,7 +30,10 @@ namespace mamba
warn,
err,
critical,
off
// Special values:
off,
all
};
struct LoggingParams
@ -42,17 +46,35 @@ namespace mamba
enum class log_source // "source" isnt the best way to put it, maybe channel? component? sink?
{
libmamba,
libmamba, // default
libcurl,
libsolv
};
/// @returns The name of the specified log source as an UTF-8 null-terminated string.
constexpr auto name_of(log_source source) -> const char*;
inline constexpr auto name_of(log_source source) -> const char*
{
switch (source)
{
case log_source::libmamba:
return "libmamba";
case log_source::libcurl:
return "libcurl";
case log_source::libsolv:
return "libsolv";
}
// TODO(c++23): std::unreachable();
assert(false);
return "unknown";
}
/// @returns All `log_source` values as a range.
constexpr auto all_log_sources() -> std::initializer_list<log_source>;
inline constexpr auto all_log_sources() -> std::initializer_list<log_source>
{
return { log_source::libmamba, log_source::libcurl, log_source::libsolv };
}
namespace logging
{
@ -62,13 +84,14 @@ namespace mamba
struct LogRecord
{
std::string message; // THINK: cool be made lazy if it was a function instead
std::string message; // THINK: could be made lazy if it was a function instead
log_level level;
log_source source;
std::source_location location;
};
// NOTE: it might make more sense to talka bout sinks than sources when it comes to the
// NOTE: it might make more sense to talk about sinks than sources when it comes to the
// implementation
template <typename T>
@ -84,6 +107,8 @@ namespace mamba
{
// REQUIREMENT: all the following operations must be thread-safe
// TODO: how to make sure calls are noexcepts?
//
handler.start_log_handling(params, sources);
@ -99,23 +124,26 @@ namespace mamba
//
handler.log(log_record);
// log stacktrace in all sources
handler.log_stacktrace();
// enable buffering a provided number of log records, dont log until `log_backtrace()` is called
handler.enable_backtrace(size_t(42));
// log stacktrace only in specific source
handler.log_stacktrace(source);
// disable log buffering
handler.disable_backtrace();
// log stacktrace in all sources
handler.log_stacktrace_no_guards();
// log buffered records
handler.log_backtrace();
// log stacktrace only in specific source
handler.log_stacktrace_no_guards(source);
// log buffered records without filtering
handler.log_backtrace_no_guards();
// flush all sources
handler.flush();
// flush only a specific source
handler.flush(std::optional<log_source>{});
// when a log's record is equal or higher than the specified level, flush
handler.set_flush_threshold(log_level::all);
};
template <typename T>
@ -173,16 +201,28 @@ namespace mamba
///
/// Pre-condition: `has_value() == true`
auto log_stacktrace(std::optional<log_source> source = {}) noexcept -> void;
auto enable_backtrace(size_t record_buffer_size) -> void;
///
/// Pre-condition: `has_value() == true`
auto log_stacktrace_no_guards(std::optional<log_source> source = {}) noexcept -> void;
auto disable_backtrace() -> void;
///
/// Pre-condition: `has_value() == true`
auto log_backtrace() noexcept -> void;
///
/// Pre-condition: `has_value() == true`
auto log_backtrace_no_guards() noexcept -> void;
///
/// Pre-condition: `has_value() == true`
auto flush(std::optional<log_source> source = {}) noexcept -> void;
///
/// Pre-condition: `has_value() == true`
auto set_flush_threshold(log_level threshold_level) noexcept -> void;
/// @returns `true` if there is an handler object stored in `this`, `false` otherwise.
auto has_value() const noexcept -> bool;
@ -212,6 +252,8 @@ namespace mamba
////////////////////////////////////////////////////////////////////////////////
// Logging System API
// not thread-safe
auto stop_logging() -> AnyLogHandler;
// not thread-safe
auto
@ -237,13 +279,24 @@ namespace mamba
auto log(LogRecord record) noexcept -> void;
// as thread-safe as handler's implementation if set
auto log_stacktrace(std::optional<log_source> source = {}) noexcept -> void;
auto enable_backtrace(size_t records_buffer_size) -> void;
// as thread-safe as handler's implementation if set
auto disable_backtrace() -> void;
// as thread-safe as handler's implementation if set
auto log_backtrace() noexcept -> void;
// as thread-safe as handler's implementation if set
auto log_backtrace_no_guards() noexcept -> void;
// as thread-safe as handler's implementation if set
auto flush_logs(std::optional<log_source> source = {}) noexcept -> void;
// as thread-safe as handler's implementation if set
auto log_stacktrace_no_guards(std::optional<log_source> source = {}) noexcept -> void;
auto set_flush_threshold(log_level threshold_level) noexcept -> void;
///////////////////////////////////////////////////////
// MIGT DISAPPEAR SOON
@ -251,7 +304,7 @@ namespace mamba
{
public:
MessageLogger(log_level level);
MessageLogger(log_level level, std::source_location location = std::source_location::current());
~MessageLogger();
std::stringstream& stream()
@ -268,8 +321,9 @@ namespace mamba
log_level m_level;
std::stringstream m_stream;
std::source_location m_location;
static void emit(const std::string& msg, const log_level& level);
static void emit(LogRecord log_record);
};
}
}
@ -298,31 +352,19 @@ namespace mamba::logging
{
// NOTE: the following definitions are inline for performance reasons.
inline constexpr auto name_of(log_source source) -> const char*
// not thread-safe
inline auto stop_logging() -> AnyLogHandler
{
switch (source)
{
case log_source::libmamba:
return "libmamba";
case log_source::libcurl:
return "libcurl";
case log_source::libsolv:
return "libsolv";
}
// TODO(c++23): std::unreachable();
return "unknown";
return set_log_handler({});
}
inline constexpr auto all_log_sources() -> std::initializer_list<log_source>
{
return { log_source::libmamba, log_source::libcurl, log_source::libsolv };
}
// TODO: find a better name?
template <typename Func, typename... Args>
requires std::invocable<Func, AnyLogHandler&, Args...>
auto call_log_handler_if_existing(Func&& func, Args&&... args) -> void
auto call_log_handler_if_existing(Func&& func, Args&&... args)
noexcept(noexcept(std::invoke(std::forward<Func>(func), get_log_handler(), std::forward<Args>(args)...)))
-> void
{
// TODO: consider enabling for user to specify that no check is needed (one less branch)
if (auto& log_handler = get_log_handler())
@ -337,10 +379,27 @@ namespace mamba::logging
call_log_handler_if_existing(&AnyLogHandler::log, std::move(record));
}
// as thread-safe as handler's implementation
inline auto log_stacktrace(std::optional<log_source> source) noexcept -> void
inline auto enable_backtrace(size_t records_buffer_size) -> void
{
call_log_handler_if_existing(&AnyLogHandler::log_stacktrace, std::move(source));
call_log_handler_if_existing(&AnyLogHandler::enable_backtrace, records_buffer_size);
}
// as thread-safe as handler's implementation if set
inline auto disable_backtrace() -> void
{
call_log_handler_if_existing(&AnyLogHandler::disable_backtrace);
}
// as thread-safe as handler's implementation if set
inline auto log_backtrace() noexcept -> void
{
call_log_handler_if_existing(&AnyLogHandler::log_backtrace);
}
// as thread-safe as handler's implementation if set
inline auto log_backtrace_no_guards() noexcept -> void
{
call_log_handler_if_existing(&AnyLogHandler::log_backtrace_no_guards);
}
// as thread-safe as handler's implementation
@ -349,12 +408,12 @@ namespace mamba::logging
call_log_handler_if_existing(&AnyLogHandler::flush, std::move(source));
}
// as thread-safe as handler's implementation
inline auto log_stacktrace_no_guards(std::optional<log_source> source) noexcept -> void
inline auto set_flush_threshold(log_level threshold_level) noexcept -> void
{
call_log_handler_if_existing(&AnyLogHandler::log_stacktrace_no_guards, std::move(source));
call_log_handler_if_existing(&AnyLogHandler::set_flush_threshold, threshold_level);
}
//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
@ -368,9 +427,12 @@ namespace mamba::logging
virtual void set_log_level(log_level new_level) = 0;
virtual void set_params(LoggingParams new_params) = 0;
virtual void log(LogRecord record) noexcept = 0;
virtual void log_stacktrace(std::optional<log_source> source) noexcept = 0;
virtual void log_stacktrace_no_guards(std::optional<log_source> source) noexcept = 0;
virtual void enable_backtrace(size_t record_buffer_size) = 0;
virtual void disable_backtrace() = 0;
virtual void log_backtrace() noexcept = 0;
virtual void log_backtrace_no_guards() noexcept = 0;
virtual void flush(std::optional<log_source> source) noexcept = 0;
virtual void set_flush_threshold(log_level threshold_level) noexcept = 0;
virtual std::type_index type_id() const = 0;
};
@ -422,14 +484,24 @@ namespace mamba::logging
as_ref(object).log(std::move(record));
}
void log_stacktrace(std::optional<log_source> source) noexcept override
void enable_backtrace(size_t records_buffer_size) override
{
as_ref(object).log_stacktrace(std::move(source));
as_ref(object).enable_backtrace(records_buffer_size);
}
void log_stacktrace_no_guards(std::optional<log_source> source) noexcept override
void disable_backtrace() override
{
as_ref(object).log_stacktrace_no_guards(std::move(source));
as_ref(object).disable_backtrace();
}
void log_backtrace() noexcept override
{
as_ref(object).log_backtrace();
}
void log_backtrace_no_guards() noexcept override
{
as_ref(object).log_backtrace_no_guards();
}
void flush(std::optional<log_source> source) noexcept override
@ -437,6 +509,12 @@ namespace mamba::logging
as_ref(object).flush(std::move(source));
}
void set_flush_threshold(log_level threshold_level) noexcept override
{
as_ref(object).set_flush_threshold(threshold_level);
}
std::type_index type_id() const override
{
return typeid(object);
@ -520,18 +598,28 @@ namespace mamba::logging
m_storage->log(std::move(record));
}
inline auto AnyLogHandler::log_stacktrace(std::optional<log_source> source) noexcept -> void
inline auto AnyLogHandler::enable_backtrace(size_t record_buffer_size) -> void
{
assert(m_storage);
m_storage->log_stacktrace_no_guards(std::move(source));
m_storage->enable_backtrace(record_buffer_size);
}
inline auto
AnyLogHandler::log_stacktrace_no_guards(std::optional<log_source> source) noexcept
-> void
inline auto AnyLogHandler::disable_backtrace() -> void
{
assert(m_storage);
m_storage->log_stacktrace_no_guards(std::move(source));
m_storage->disable_backtrace();
}
inline auto AnyLogHandler::log_backtrace() noexcept -> void
{
assert(m_storage);
m_storage->log_backtrace();
}
inline auto AnyLogHandler::log_backtrace_no_guards() noexcept -> void
{
assert(m_storage);
m_storage->log_backtrace_no_guards();
}
inline auto AnyLogHandler::flush(std::optional<log_source> source) noexcept -> void
@ -540,6 +628,12 @@ namespace mamba::logging
m_storage->flush(std::move(source));
}
inline auto AnyLogHandler::set_flush_threshold(log_level threshold_level) noexcept -> void
{
assert(m_storage);
m_storage->set_flush_threshold(threshold_level);
}
inline auto AnyLogHandler::has_value() const noexcept -> bool
{
return m_storage ? true : false;

32
libmamba/include/mamba/core/logging_spdlog.hpp
View File

@ -8,18 +8,22 @@
#define MAMBA_CORE_LOGGING_SPDLOG_HPP
#include <memory>
#include <mamba/core/tasksync.hpp>
#include <mamba/core/logging.hpp>
#include <vector>
#include <spdlog/common.h>
#include <mamba/core/logging.hpp>
namespace mamba
{
class TaskSynchronizer;
// THINK: add namespace?
inline auto convert_log_level(log_level l) -> spdlog::level::level_enum
inline constexpr auto to_spdlog(log_level level) -> spdlog::level::level_enum
{
return static_cast<spdlog::level::level_enum>(l);
static_assert(sizeof(log_level) == sizeof(spdlog::level::level_enum));
static_assert(static_cast<int>(log_level::all) == static_cast<int>(spdlog::level::level_enum::n_levels));
return static_cast<spdlog::level::level_enum>(level);
}
class LogHandler_spdlog
@ -40,15 +44,23 @@ namespace mamba
auto log(logging::LogRecord record) -> void;
auto log_stacktrace(std::optional<log_source> source = {}) -> void;
auto log_stacktrace_no_guards(std::optional<log_source> source = {}) -> void;
auto enable_backtrace(size_t record_buffer_size) -> void;
auto disable_backtrace() -> void;
auto log_backtrace() noexcept -> void;
auto log_backtrace_no_guards() noexcept -> void;
auto flush(std::optional<log_source> source = {}) -> void;
auto set_flush_threshold(log_level threshold_level) noexcept -> void;
private:
struct Impl;
std::unique_ptr<Impl> pimpl;
class ScopedLogger;
std::vector<ScopedLogger> loggers;
std::unique_ptr<TaskSynchronizer> tasksync = std::make_unique<TaskSynchronizer>();
// THINK: consider only using spdlog to get the loggers
auto default_logger() -> ScopedLogger&;
auto get_logger(log_source source) -> ScopedLogger&;
};
static_assert(logging::LogHandler<LogHandler_spdlog>);

2
libmamba/include/mamba/core/progress_bar.hpp
View File

@ -17,7 +17,7 @@ namespace mamba
class ProgressBar;
struct ProgressBarOptions;
// TODO: find a way to define it here without
// impoorting spdlog and modst of the STL.
// importing spdlog and most of the STL.
class ProgressBarRepr;
enum ProgressBarMode

18
libmamba/src/api/configuration.cpp
View File

@ -11,11 +11,11 @@
#include <nlohmann/json.hpp>
#include <reproc++/run.hpp>
#include <spdlog/spdlog.h>
#include "mamba/api/configuration.hpp"
#include "mamba/api/install.hpp"
#include "mamba/core/fsutil.hpp"
#include "mamba/core/logging.hpp"
#include "mamba/core/output.hpp"
#include "mamba/core/package_fetcher.hpp"
#include "mamba/core/util.hpp"
@ -2194,12 +2194,12 @@ namespace mamba
void Configuration::load()
{
spdlog::set_level(spdlog::level::n_levels);
spdlog::flush_on(spdlog::level::n_levels);
logging::set_log_level(log_level::all);
logging::set_flush_threshold(log_level::all);
// Hard-coded value assuming it's enough to store the logs emitted
// before setting the log level, flushing the backtrace and setting
// its new capacity
spdlog::enable_backtrace(500);
logging::enable_backtrace(500);
LOG_DEBUG << "Loading configuration";
@ -2229,19 +2229,19 @@ namespace mamba
exit(0);
}
m_context.set_log_level(m_context.output_params.logging_level);
m_context.set_log_level(m_context.output_params.logging_level); // TODO remove that function from Context
spdlog::apply_all([&](std::shared_ptr<spdlog::logger> l) { l->flush(); });
spdlog::flush_on(spdlog::level::off);
logging::flush_logs();
logging::set_flush_threshold(log_level::off);
m_context.dump_backtrace_no_guards();
if (m_context.output_params.log_backtrace > 0)
{
spdlog::enable_backtrace(m_context.output_params.log_backtrace);
logging::enable_backtrace(m_context.output_params.log_backtrace);
}
else
{
spdlog::disable_backtrace();
logging::disable_backtrace();
}
}

9
libmamba/src/core/context.cpp
View File

@ -54,7 +54,7 @@ namespace mamba
void Context::enable_logging(logging::AnyLogHandler log_handler) // THINK: change name? start_logging?
{
if (not logging::get_log_handler())
if (not logging::get_log_handler()) // don't allow replacing one already set; THINK: OR DO WE ALLOW THAT????
{
if (log_handler)
{
@ -111,7 +111,10 @@ namespace mamba
}
}
Context::~Context() = default;
Context::~Context()
{
logging::stop_logging();
}
void Context::set_verbosity(int lvl)
{
@ -314,7 +317,7 @@ namespace mamba
void Context::dump_backtrace_no_guards()
{
logging::log_stacktrace_no_guards(log_source::libmamba);
logging::log_backtrace_no_guards();
}
} // namespace mamba

1
libmamba/src/core/env_lockfile.cpp
View File

@ -4,7 +4,6 @@
//
// The full license is in the file LICENSE, distributed with this software.
#include <spdlog/spdlog.h>
#include <yaml-cpp/yaml.h>
#include "mamba/core/env_lockfile.hpp"

2
libmamba/src/core/error_handling.cpp
View File

@ -10,7 +10,7 @@ namespace mamba
{
if (ec == mamba_error_code::internal_failure)
{
logging::log_stacktrace();
logging::log_backtrace();
}
}

55
libmamba/src/core/logging.cpp
View File

@ -17,9 +17,9 @@
namespace mamba::logging
{
namespace // TODO: STATIC INIT FIASCO!!!
namespace
{
constinit util::synchronized_value<LoggingParams> logging_params;
constinit util::synchronized_value<LoggingParams, std::shared_mutex> logging_params;
// IMPRTANT NOTE:
// The handler MUST NOT be protected from concurrent calls at this level
@ -112,50 +112,61 @@ namespace mamba::logging
}
}
///////////////////////////////////////////////////////////////////
// MessageLogger
namespace
{
constinit std::atomic<bool> message_logger_use_buffer;
using MessageLoggerBuffer = std::vector<std::pair<std::string, log_level>>;
using MessageLoggerBuffer = std::vector<LogRecord>;
constinit util::synchronized_value<MessageLoggerBuffer> message_logger_buffer;
auto make_safe_log_record(std::string_view message, log_level level, std::source_location location)
{
// THINK: maybe remove as much locals as possible to enable optimizations with
// temporaries
// TODO: use fmt or std::format to do the space prepend
const auto secured_message = Console::hide_secrets(message);
auto formatted_message = prepend(secured_message, "", std::string(4, ' ').c_str());
return LogRecord{
.message = std::move(formatted_message), //
.level = level, //
.source = log_source::libmamba, // default logging source, other sources will log
// through other mechanisms
.location = std::move(location) //
};
}
}
MessageLogger::MessageLogger(log_level level)
MessageLogger::MessageLogger(log_level level, std::source_location location)
: m_level(level)
, m_location(std::move(location))
{
}
MessageLogger::~MessageLogger()
{
auto log_record = make_safe_log_record(m_stream.str(), m_level, std::move(m_location));
if (!message_logger_use_buffer && Console::is_available())
{
emit(m_stream.str(), m_level);
emit(std::move(log_record));
}
else
{
message_logger_buffer->push_back({ m_stream.str(), m_level });
message_logger_buffer->push_back(log_record);
}
}
void MessageLogger::emit(const std::string& msg, const log_level& level)
void MessageLogger::emit(LogRecord log_record)
{
// THINK: maybe remove as much locals as possible to enable optimizations with temporaries
// TODO: use fmt or std::format to do the space prepend
const auto secured_message = Console::hide_secrets(msg);
const auto formatted_message = prepend(secured_message, "", std::string(4, ' ').c_str());
logging::log(LogRecord{
.message = formatted_message, //
.level = level, //
.source = log_source::libmamba //
});
logging::log(std::move(log_record));
if (level == log_level::critical and get_log_level() != log_level::off)
if (log_record.level == log_level::critical and get_log_level() != log_level::off) // WARNING:
// THERE
// IS A LOCK HERE!
{
log_stacktrace();
log_backtrace();
}
}
@ -174,13 +185,11 @@ namespace mamba::logging
MessageLoggerBuffer tmp;
message_logger_buffer->swap(tmp);
for (const auto& [msg, level] : tmp)
for (auto& log_record : tmp)
{
emit(msg, level);
emit(std::move(log_record));
}
// TODO impl commented
/*spdlog::apply_all([&](std::shared_ptr<spdlog::logger> l) { l->flush(); });*/
flush_logs();
}

106
libmamba/src/core/logging_spdlog.cpp
View File

@ -67,7 +67,7 @@ namespace mamba
// Associate the registration of a logger to the lifetime of this object.
// This is used to help with making sure loggers are unregistered once
// their logical owner is destroyed.
class ScopedLogger
class LogHandler_spdlog::ScopedLogger
{
std::shared_ptr<Logger> m_logger;
@ -108,41 +108,119 @@ namespace mamba
ScopedLogger& operator=(const ScopedLogger&) = delete;
};
struct LogHandler_spdlog::Impl
{
std::vector<ScopedLogger> loggers;
TaskSynchronizer tasksync;
};
LogHandler_spdlog::LogHandler_spdlog() = default;
LogHandler_spdlog::~LogHandler_spdlog() = default;
LogHandler_spdlog::LogHandler_spdlog(LogHandler_spdlog&& other) = default;
LogHandler_spdlog& LogHandler_spdlog::operator=(LogHandler_spdlog&& other) = default;
auto LogHandler_spdlog::get_logger(log_source source) -> ScopedLogger&
{
// THINK: consider only using spdlog to get the loggers
const auto logger_idx = static_cast<size_t>(source);
assert(logger_idx > 0 && logger_idx < loggers.size());
auto& logger = loggers[logger_idx];
assert(logger.logger());
return logger;
}
auto LogHandler_spdlog::default_logger() -> ScopedLogger&
{
return get_logger(log_source::libmamba);
}
auto
LogHandler_spdlog::start_log_handling(const LoggingParams params, std::vector<log_source> sources)
-> void
{
pimpl = std::make_unique<Impl>();
assert(tasksync);
const auto main_source = sources.front();
sources.pop_back();
pimpl->loggers.emplace_back(
loggers.emplace_back(
std::make_shared<Logger>(name_of(main_source), params.log_pattern, "\n"),
logger_kind::default_logger
);
MainExecutor::instance().on_close(
pimpl->tasksync.synchronized([this] { pimpl->loggers.front().logger()->flush(); })
tasksync->synchronized([this] { loggers.front().logger()->flush(); })
);
for (const auto source : sources)
{
pimpl->loggers.emplace_back(
std::make_shared<Logger>(name_of(source), params.log_pattern, "")
);
loggers.emplace_back(std::make_shared<Logger>(name_of(source), params.log_pattern, ""));
}
spdlog::set_level(convert_log_level(params.logging_level));
spdlog::set_level(to_spdlog(params.logging_level));
}
auto LogHandler_spdlog::stop_log_handling() -> void
{
loggers.clear();
spdlog::shutdown(); // ? or drop_all?
}
auto LogHandler_spdlog::set_log_level(log_level new_level) -> void
{
spdlog::set_level(to_spdlog(new_level));
}
auto LogHandler_spdlog::set_params(LoggingParams new_params) -> void
{
// TODO: add missing parameters
spdlog::set_level(to_spdlog(new_params.logging_level));
}
auto LogHandler_spdlog::log(const logging::LogRecord record) -> void
{
// THINK: consider only using spdlog to get the loggers
auto logger = get_logger(record.source).logger();
logger->log(
spdlog::source_loc{
record.location.file_name(),
static_cast<int>(record.location.line()), // CRINGE
record.location.function_name(),
},
to_spdlog(record.level),
record.message
);
}
auto LogHandler_spdlog::enable_backtrace(size_t record_buffer_size) -> void
{
spdlog::enable_backtrace(record_buffer_size);
}
auto LogHandler_spdlog::disable_backtrace() -> void
{
spdlog::disable_backtrace();
}
auto LogHandler_spdlog::log_backtrace() noexcept -> void
{
spdlog::dump_backtrace();
}
auto LogHandler_spdlog::log_backtrace_no_guards() noexcept -> void
{
default_logger().logger()->dump_backtrace_no_guards();
}
auto LogHandler_spdlog::set_flush_threshold(log_level threshold_level) noexcept -> void
{
spdlog::flush_on(to_spdlog(threshold_level));
}
auto LogHandler_spdlog::flush(std::optional<log_source> source) -> void
{
if (source)
{
get_logger(source.value()).logger()->flush(); // THINK: consider only using spdlog to get the loggers
}
else
{
spdlog::apply_all([](std::shared_ptr<spdlog::logger> l) { l->flush(); });
}
}
}

1
libmamba/src/core/run.cpp
View File

@ -29,7 +29,6 @@ extern "C"
#include <fmt/ranges.h>
#include <nlohmann/json.hpp>
#include <reproc++/run.hpp>
#include <spdlog/spdlog.h>
#include "mamba/core/context.hpp"
#include "mamba/core/error_handling.hpp"

7
libmamba/src/download/curl.cpp
View File

@ -6,8 +6,7 @@
#include <functional>
#include <spdlog/spdlog.h>
#include "mamba/core/logging.hpp"
#include "mamba/core/util.hpp" // for hide_secrets
#include "mamba/fs/filesystem.hpp" // for fs::exists
#include "mamba/util/environment.hpp"
@ -69,9 +68,7 @@ namespace mamba::download
if (proxy)
{
curl_easy_setopt(handle, CURLOPT_PROXY, proxy->c_str());
// TODO LOG_INFO was used here instead; to be modified later following the new log
// procedure (TBD)
spdlog::info("Using Proxy {}", hide_secrets(*proxy));
LOG_INFO << fmt::format("Using Proxy {}", hide_secrets(*proxy));
}
if (ssl_verify.size())

7
libmamba/src/download/mirror_impl.cpp
View File

@ -4,8 +4,7 @@
//
// The full license is in the file LICENSE, distributed with this software.
#include <spdlog/spdlog.h>
#include "mamba/core/logging.hpp"
#include "mamba/core/output.hpp"
#include "mamba/util/string.hpp"
#include "mamba/util/url.hpp"
@ -124,8 +123,8 @@ namespace mamba::download
}
catch (const nlohmann::detail::parse_error& e)
{
spdlog::error("Could not parse JSON\n{}", value);
spdlog::error("Error message: {}", e.what());
LOG_ERROR << fmt::format("Could not parse JSON\n{}", value);
LOG_ERROR << fmt::format("Error message: {}", e.what());
return nl::json::object();
}
}

1
libmamba/src/solver/libsolv/database.cpp
View File

@ -12,7 +12,6 @@
#include <solv/evr.h>
#include <solv/selection.h>
#include <solv/solver.h>
#include <spdlog/spdlog.h>
#include "mamba/fs/filesystem.hpp"
#include "mamba/solver/libsolv/database.hpp"

11
libmamba/tests/src/core/test_lockfile.cpp
View File

@ -10,13 +10,12 @@
#include <catch2/catch_all.hpp>
#include <reproc++/run.hpp>
#include "mamba/core/logging.hpp"
#include "mamba/core/context.hpp"
#include "mamba/core/util.hpp"
#include "mamba/core/util_scope.hpp"
#include "mamba/fs/filesystem.hpp"
#include "spdlog/spdlog.h"
#ifdef _WIN32
#include <io.h>
@ -47,13 +46,13 @@ namespace mamba
p_tempdir = std::make_unique<TemporaryDirectory>();
tempdir_path = p_tempdir->path();
spdlog::set_level(spdlog::level::trace);
logging::set_log_level(log_level::trace);
}
~LockDirTest()
{
mamba::allow_file_locking(true);
spdlog::set_level(spdlog::level::info);
logging::set_log_level(log_level::info);
}
};
@ -206,12 +205,12 @@ namespace mamba
p_tempfile = std::make_unique<TemporaryFile>();
tempfile_path = p_tempfile->path();
spdlog::set_level(spdlog::level::trace);
logging::set_log_level(log_level::trace);
}
~LockFileTest()
{
spdlog::set_level(spdlog::level::info);
logging::set_log_level(log_level::info);
}
};

18
libmamba/tests/src/validation/test_tools.cpp
View File

@ -6,9 +6,9 @@
#include <catch2/catch_all.hpp>
#include <nlohmann/json.hpp>
#include <spdlog/spdlog.h>
#include "mamba/core/util.hpp"
#include "mamba/core/logging.hpp"
#include "mamba/util/encoding.hpp"
#include "mamba/validation/tools.hpp"
@ -49,7 +49,7 @@ namespace
REQUIRE(error == 0);
REQUIRE(pk_hex == hex_str(pk_bytes));
spdlog::set_level(spdlog::level::debug);
logging::set_log_level(log_level::debug);
std::array<std::byte, 5> not_even_key;
pk_hex = hex_str(not_even_key);
@ -63,7 +63,7 @@ namespace
REQUIRE(error == 0);
REQUIRE_FALSE(pk_hex == hex_str(pk_bytes));
spdlog::set_level(spdlog::level::info);
logging::set_log_level(log_level::info);
}
TEST_CASE("ed25519_sig_hex_to_bytes")
@ -80,7 +80,7 @@ namespace
REQUIRE(error == 0);
REQUIRE(sig_hex == hex_str(sig_bytes));
spdlog::set_level(spdlog::level::debug);
logging::set_log_level(log_level::debug);
std::array<std::byte, 5> not_even_sig;
sig_hex = hex_str(not_even_sig);
@ -94,7 +94,7 @@ namespace
REQUIRE(error == 0);
REQUIRE_FALSE(sig_hex == hex_str(sig_bytes));
spdlog::set_level(spdlog::level::info);
logging::set_log_level(log_level::info);
}
}
@ -132,20 +132,20 @@ namespace
TEST_CASE_METHOD(VerifyMsg, "wrong_signature")
{
spdlog::set_level(spdlog::level::debug);
logging::set_log_level(log_level::debug);
auto pk_hex = hex_str(pk);
REQUIRE(verify("Some text.", pk_hex, "signature_hex") == 0);
spdlog::set_level(spdlog::level::info);
logging::set_log_level(log_level::info);
}
TEST_CASE_METHOD(VerifyMsg, "wrong_public_key")
{
spdlog::set_level(spdlog::level::debug);
logging::set_log_level(log_level::debug);
auto signature_hex = hex_str(signature);
REQUIRE(verify("Some text.", "pk_hex", signature_hex) == 0);
spdlog::set_level(spdlog::level::info);
logging::set_log_level(log_level::info);
}
}

6
libmamba/tests/src/validation/test_update_framework_v0_6.cpp
View File

@ -8,8 +8,8 @@
#include <catch2/catch_all.hpp>
#include <nlohmann/json.hpp>
#include <spdlog/spdlog.h>
#include "mamba/core/logging.hpp"
#include "mamba/core/fsutil.hpp"
#include "mamba/core/util.hpp"
#include "mamba/util/encoding.hpp"
@ -1188,12 +1188,12 @@ public:
write_role(key_mgr_json, channel_dir->path() / "key_mgr.json");
write_role(pkg_mgr_json, channel_dir->path() / "pkg_mgr.json");
spdlog::set_level(spdlog::level::debug);
logging::set_log_level(log_level::debug);
}
~RepoCheckerT()
{
spdlog::set_level(spdlog::level::warn);
logging::set_log_level(log_level::warn);
}
protected:

1
libmamba/tests/src/validation/test_update_framework_v1.cpp
View File

@ -8,7 +8,6 @@
#include <catch2/catch_all.hpp>
#include <nlohmann/json.hpp>
#include <spdlog/spdlog.h>
#include "mamba/core/fsutil.hpp"
#include "mamba/core/util.hpp"