Archives/lokinet
2
0
Fork 0
mirror of https://github.com/oxen-io/lokinet.git synced 2024-11-15 12:13:24 +00:00
Code Issues Projects Releases Wiki Activity
07271f9ae7
lokinet/llarp/util/logging.hpp

137 lines
3.7 KiB
C++
Raw Normal View History

Replace logging with oxen-logger Replaces custom logging system with spdlog-based oxen logging. This commit mainly replaces the backend logging with the spdlog-based system, but doesn't (yet) convert all the existing LogWarn, etc. to use the new format-based logging. New logging statements will look like: llarp::log::warning(cat, "blah: {}", val); where `cat` should be set up in each .cpp or cluster of .cpp files, as described in the oxen-logging README. As part of spdlog we get fmt, which gives us nice format strings, where are applied generously in this commit. Making types printable now requires two steps: - add a ToString() method - add this specialization: template <> constexpr inline bool llarp::IsToStringFormattable<llarp::Whatever> = true; This will then allow the type to be printed as a "{}" value in a fmt::format string. This is applied to all our printable types here, and all of the `operator<<` are removed. This commit also: - replaces various uses of `operator<<` to ToString() - replaces various uses of std::stringstream with either fmt::format or plain std::string - Rename some to_string and toString() methods to ToString() for consistency (and to work with fmt) - Replace `stringify(...)` and `make_exception` usage with fmt::format (and remove stringify/make_exception from util/str.hpp).
2022-07-16 00:41:14 +00:00
#pragma once
// Header for making actual log statements such as llarp::log::Info and so on work.
#include <oxen/log.hpp>
omq rpc log subscription respects whether RPC is enabled, removes the log sink otherwise bumps oxen-mq and oxen-logging
2022-09-28 16:37:19 +00:00
#include <oxen/log/ring_buffer_sink.hpp>
Clang format include sorting + CMake - includes are now sorted in consistent, logical order; first step in an attempt to fix the tomfoolery (no relation to Tom) brought in by include-what-you-use - shuffled around some cmake linking to simplify dependency graph - superfluous files removed
2023-10-24 13:18:03 +00:00
#include <array>
#include <string>
#include <string_view>
Replace logging with oxen-logger Replaces custom logging system with spdlog-based oxen logging. This commit mainly replaces the backend logging with the spdlog-based system, but doesn't (yet) convert all the existing LogWarn, etc. to use the new format-based logging. New logging statements will look like: llarp::log::warning(cat, "blah: {}", val); where `cat` should be set up in each .cpp or cluster of .cpp files, as described in the oxen-logging README. As part of spdlog we get fmt, which gives us nice format strings, where are applied generously in this commit. Making types printable now requires two steps: - add a ToString() method - add this specialization: template <> constexpr inline bool llarp::IsToStringFormattable<llarp::Whatever> = true; This will then allow the type to be printed as a "{}" value in a fmt::format string. This is applied to all our printable types here, and all of the `operator<<` are removed. This commit also: - replaces various uses of `operator<<` to ToString() - replaces various uses of std::stringstream with either fmt::format or plain std::string - Rename some to_string and toString() methods to ToString() for consistency (and to work with fmt) - Replace `stringify(...)` and `make_exception` usage with fmt::format (and remove stringify/make_exception from util/str.hpp).
2022-07-16 00:41:14 +00:00
namespace llarp
{
namespace log = oxen::log;
}
Message method implementation continued - tons of surrounding stupid refactoring required
2023-09-29 21:00:13 +00:00
namespace
{
static auto util_cat = llarp::log::Cat("lokinet.util");
} // namespace
Replace logging with oxen-logger Replaces custom logging system with spdlog-based oxen logging. This commit mainly replaces the backend logging with the spdlog-based system, but doesn't (yet) convert all the existing LogWarn, etc. to use the new format-based logging. New logging statements will look like: llarp::log::warning(cat, "blah: {}", val); where `cat` should be set up in each .cpp or cluster of .cpp files, as described in the oxen-logging README. As part of spdlog we get fmt, which gives us nice format strings, where are applied generously in this commit. Making types printable now requires two steps: - add a ToString() method - add this specialization: template <> constexpr inline bool llarp::IsToStringFormattable<llarp::Whatever> = true; This will then allow the type to be printed as a "{}" value in a fmt::format string. This is applied to all our printable types here, and all of the `operator<<` are removed. This commit also: - replaces various uses of `operator<<` to ToString() - replaces various uses of std::stringstream with either fmt::format or plain std::string - Rename some to_string and toString() methods to ToString() for consistency (and to work with fmt) - Replace `stringify(...)` and `make_exception` usage with fmt::format (and remove stringify/make_exception from util/str.hpp).
2022-07-16 00:41:14 +00:00
// Not ready to pollute these deprecation warnings everywhere yet
#if 0
#define LOKINET_LOG_DEPRECATED(Meth) \
[[deprecated("Use formatted log::" #Meth "(cat, fmt, args...) instead")]]
#else
#define LOKINET_LOG_DEPRECATED(Meth)
#endif
// Deprecated loggers (in the top-level llarp namespace):
namespace llarp
{
omq rpc log subscription respects whether RPC is enabled, removes the log sink otherwise bumps oxen-mq and oxen-logging
2022-09-28 16:37:19 +00:00
inline std::shared_ptr<log::RingBufferSink> logRingBuffer = nullptr;
Replace logging with oxen-logger Replaces custom logging system with spdlog-based oxen logging. This commit mainly replaces the backend logging with the spdlog-based system, but doesn't (yet) convert all the existing LogWarn, etc. to use the new format-based logging. New logging statements will look like: llarp::log::warning(cat, "blah: {}", val); where `cat` should be set up in each .cpp or cluster of .cpp files, as described in the oxen-logging README. As part of spdlog we get fmt, which gives us nice format strings, where are applied generously in this commit. Making types printable now requires two steps: - add a ToString() method - add this specialization: template <> constexpr inline bool llarp::IsToStringFormattable<llarp::Whatever> = true; This will then allow the type to be printed as a "{}" value in a fmt::format string. This is applied to all our printable types here, and all of the `operator<<` are removed. This commit also: - replaces various uses of `operator<<` to ToString() - replaces various uses of std::stringstream with either fmt::format or plain std::string - Rename some to_string and toString() methods to ToString() for consistency (and to work with fmt) - Replace `stringify(...)` and `make_exception` usage with fmt::format (and remove stringify/make_exception from util/str.hpp).
2022-07-16 00:41:14 +00:00
namespace log_detail
{
inline log::CategoryLogger legacy_logger = log::Cat("");
template <typename>
struct concat_args_fmt_impl;
template <size_t... I>
struct concat_args_fmt_impl<std::integer_sequence<size_t, I...>>
{
constexpr static std::array<char, sizeof...(I)> format{(I % 2 == 0 ? '{' : '}')...};
};
template <size_t N>
constexpr std::string_view
concat_args_fmt()
{
return std::string_view{
concat_args_fmt_impl<std::make_index_sequence<2 * N>>::format.data(), 2 * N};
}
} // namespace log_detail
template <typename... T>
Avoid ctor inheritance to make diagnostics better Using constructor inheritance DRYs the code, but unfortunately confuses GCC as to where the proper "required from here" location is, which makes debugging formatting errors very difficult. Avoid it (and update oxen-logging to avoid it there as well).
2022-07-18 16:07:33 +00:00
struct LOKINET_LOG_DEPRECATED(Trace) LogTrace : log::trace<T...>
Replace logging with oxen-logger Replaces custom logging system with spdlog-based oxen logging. This commit mainly replaces the backend logging with the spdlog-based system, but doesn't (yet) convert all the existing LogWarn, etc. to use the new format-based logging. New logging statements will look like: llarp::log::warning(cat, "blah: {}", val); where `cat` should be set up in each .cpp or cluster of .cpp files, as described in the oxen-logging README. As part of spdlog we get fmt, which gives us nice format strings, where are applied generously in this commit. Making types printable now requires two steps: - add a ToString() method - add this specialization: template <> constexpr inline bool llarp::IsToStringFormattable<llarp::Whatever> = true; This will then allow the type to be printed as a "{}" value in a fmt::format string. This is applied to all our printable types here, and all of the `operator<<` are removed. This commit also: - replaces various uses of `operator<<` to ToString() - replaces various uses of std::stringstream with either fmt::format or plain std::string - Rename some to_string and toString() methods to ToString() for consistency (and to work with fmt) - Replace `stringify(...)` and `make_exception` usage with fmt::format (and remove stringify/make_exception from util/str.hpp).
2022-07-16 00:41:14 +00:00
{
Avoid ctor inheritance to make diagnostics better Using constructor inheritance DRYs the code, but unfortunately confuses GCC as to where the proper "required from here" location is, which makes debugging formatting errors very difficult. Avoid it (and update oxen-logging to avoid it there as well).
2022-07-18 16:07:33 +00:00
LogTrace(
T&&... args,
const log::slns::source_location& location = log::slns::source_location::current())
: log::trace<T...>::trace{
log_detail::legacy_logger,
log_detail::concat_args_fmt<sizeof...(T)>(),
std::forward<T>(args)...,
location}
{}
Replace logging with oxen-logger Replaces custom logging system with spdlog-based oxen logging. This commit mainly replaces the backend logging with the spdlog-based system, but doesn't (yet) convert all the existing LogWarn, etc. to use the new format-based logging. New logging statements will look like: llarp::log::warning(cat, "blah: {}", val); where `cat` should be set up in each .cpp or cluster of .cpp files, as described in the oxen-logging README. As part of spdlog we get fmt, which gives us nice format strings, where are applied generously in this commit. Making types printable now requires two steps: - add a ToString() method - add this specialization: template <> constexpr inline bool llarp::IsToStringFormattable<llarp::Whatever> = true; This will then allow the type to be printed as a "{}" value in a fmt::format string. This is applied to all our printable types here, and all of the `operator<<` are removed. This commit also: - replaces various uses of `operator<<` to ToString() - replaces various uses of std::stringstream with either fmt::format or plain std::string - Rename some to_string and toString() methods to ToString() for consistency (and to work with fmt) - Replace `stringify(...)` and `make_exception` usage with fmt::format (and remove stringify/make_exception from util/str.hpp).
2022-07-16 00:41:14 +00:00
};
template <typename... T>
Avoid ctor inheritance to make diagnostics better Using constructor inheritance DRYs the code, but unfortunately confuses GCC as to where the proper "required from here" location is, which makes debugging formatting errors very difficult. Avoid it (and update oxen-logging to avoid it there as well).
2022-07-18 16:07:33 +00:00
struct LOKINET_LOG_DEPRECATED(Debug) LogDebug : log::debug<T...>
Replace logging with oxen-logger Replaces custom logging system with spdlog-based oxen logging. This commit mainly replaces the backend logging with the spdlog-based system, but doesn't (yet) convert all the existing LogWarn, etc. to use the new format-based logging. New logging statements will look like: llarp::log::warning(cat, "blah: {}", val); where `cat` should be set up in each .cpp or cluster of .cpp files, as described in the oxen-logging README. As part of spdlog we get fmt, which gives us nice format strings, where are applied generously in this commit. Making types printable now requires two steps: - add a ToString() method - add this specialization: template <> constexpr inline bool llarp::IsToStringFormattable<llarp::Whatever> = true; This will then allow the type to be printed as a "{}" value in a fmt::format string. This is applied to all our printable types here, and all of the `operator<<` are removed. This commit also: - replaces various uses of `operator<<` to ToString() - replaces various uses of std::stringstream with either fmt::format or plain std::string - Rename some to_string and toString() methods to ToString() for consistency (and to work with fmt) - Replace `stringify(...)` and `make_exception` usage with fmt::format (and remove stringify/make_exception from util/str.hpp).
2022-07-16 00:41:14 +00:00
{
Avoid ctor inheritance to make diagnostics better Using constructor inheritance DRYs the code, but unfortunately confuses GCC as to where the proper "required from here" location is, which makes debugging formatting errors very difficult. Avoid it (and update oxen-logging to avoid it there as well).
2022-07-18 16:07:33 +00:00
LogDebug(
T&&... args,
const log::slns::source_location& location = log::slns::source_location::current())
: log::debug<T...>::debug{
log_detail::legacy_logger,
log_detail::concat_args_fmt<sizeof...(T)>(),
std::forward<T>(args)...,
location}
{}
Replace logging with oxen-logger Replaces custom logging system with spdlog-based oxen logging. This commit mainly replaces the backend logging with the spdlog-based system, but doesn't (yet) convert all the existing LogWarn, etc. to use the new format-based logging. New logging statements will look like: llarp::log::warning(cat, "blah: {}", val); where `cat` should be set up in each .cpp or cluster of .cpp files, as described in the oxen-logging README. As part of spdlog we get fmt, which gives us nice format strings, where are applied generously in this commit. Making types printable now requires two steps: - add a ToString() method - add this specialization: template <> constexpr inline bool llarp::IsToStringFormattable<llarp::Whatever> = true; This will then allow the type to be printed as a "{}" value in a fmt::format string. This is applied to all our printable types here, and all of the `operator<<` are removed. This commit also: - replaces various uses of `operator<<` to ToString() - replaces various uses of std::stringstream with either fmt::format or plain std::string - Rename some to_string and toString() methods to ToString() for consistency (and to work with fmt) - Replace `stringify(...)` and `make_exception` usage with fmt::format (and remove stringify/make_exception from util/str.hpp).
2022-07-16 00:41:14 +00:00
};
template <typename... T>
Avoid ctor inheritance to make diagnostics better Using constructor inheritance DRYs the code, but unfortunately confuses GCC as to where the proper "required from here" location is, which makes debugging formatting errors very difficult. Avoid it (and update oxen-logging to avoid it there as well).
2022-07-18 16:07:33 +00:00
struct LOKINET_LOG_DEPRECATED(Info) LogInfo : log::info<T...>
Replace logging with oxen-logger Replaces custom logging system with spdlog-based oxen logging. This commit mainly replaces the backend logging with the spdlog-based system, but doesn't (yet) convert all the existing LogWarn, etc. to use the new format-based logging. New logging statements will look like: llarp::log::warning(cat, "blah: {}", val); where `cat` should be set up in each .cpp or cluster of .cpp files, as described in the oxen-logging README. As part of spdlog we get fmt, which gives us nice format strings, where are applied generously in this commit. Making types printable now requires two steps: - add a ToString() method - add this specialization: template <> constexpr inline bool llarp::IsToStringFormattable<llarp::Whatever> = true; This will then allow the type to be printed as a "{}" value in a fmt::format string. This is applied to all our printable types here, and all of the `operator<<` are removed. This commit also: - replaces various uses of `operator<<` to ToString() - replaces various uses of std::stringstream with either fmt::format or plain std::string - Rename some to_string and toString() methods to ToString() for consistency (and to work with fmt) - Replace `stringify(...)` and `make_exception` usage with fmt::format (and remove stringify/make_exception from util/str.hpp).
2022-07-16 00:41:14 +00:00
{
Avoid ctor inheritance to make diagnostics better Using constructor inheritance DRYs the code, but unfortunately confuses GCC as to where the proper "required from here" location is, which makes debugging formatting errors very difficult. Avoid it (and update oxen-logging to avoid it there as well).
2022-07-18 16:07:33 +00:00
LogInfo(
T&&... args,
const log::slns::source_location& location = log::slns::source_location::current())
: log::info<T...>::info{
log_detail::legacy_logger,
log_detail::concat_args_fmt<sizeof...(T)>(),
std::forward<T>(args)...,
location}
{}
Replace logging with oxen-logger Replaces custom logging system with spdlog-based oxen logging. This commit mainly replaces the backend logging with the spdlog-based system, but doesn't (yet) convert all the existing LogWarn, etc. to use the new format-based logging. New logging statements will look like: llarp::log::warning(cat, "blah: {}", val); where `cat` should be set up in each .cpp or cluster of .cpp files, as described in the oxen-logging README. As part of spdlog we get fmt, which gives us nice format strings, where are applied generously in this commit. Making types printable now requires two steps: - add a ToString() method - add this specialization: template <> constexpr inline bool llarp::IsToStringFormattable<llarp::Whatever> = true; This will then allow the type to be printed as a "{}" value in a fmt::format string. This is applied to all our printable types here, and all of the `operator<<` are removed. This commit also: - replaces various uses of `operator<<` to ToString() - replaces various uses of std::stringstream with either fmt::format or plain std::string - Rename some to_string and toString() methods to ToString() for consistency (and to work with fmt) - Replace `stringify(...)` and `make_exception` usage with fmt::format (and remove stringify/make_exception from util/str.hpp).
2022-07-16 00:41:14 +00:00
};
template <typename... T>
Avoid ctor inheritance to make diagnostics better Using constructor inheritance DRYs the code, but unfortunately confuses GCC as to where the proper "required from here" location is, which makes debugging formatting errors very difficult. Avoid it (and update oxen-logging to avoid it there as well).
2022-07-18 16:07:33 +00:00
struct LOKINET_LOG_DEPRECATED(Warning) LogWarn : log::warning<T...>
Replace logging with oxen-logger Replaces custom logging system with spdlog-based oxen logging. This commit mainly replaces the backend logging with the spdlog-based system, but doesn't (yet) convert all the existing LogWarn, etc. to use the new format-based logging. New logging statements will look like: llarp::log::warning(cat, "blah: {}", val); where `cat` should be set up in each .cpp or cluster of .cpp files, as described in the oxen-logging README. As part of spdlog we get fmt, which gives us nice format strings, where are applied generously in this commit. Making types printable now requires two steps: - add a ToString() method - add this specialization: template <> constexpr inline bool llarp::IsToStringFormattable<llarp::Whatever> = true; This will then allow the type to be printed as a "{}" value in a fmt::format string. This is applied to all our printable types here, and all of the `operator<<` are removed. This commit also: - replaces various uses of `operator<<` to ToString() - replaces various uses of std::stringstream with either fmt::format or plain std::string - Rename some to_string and toString() methods to ToString() for consistency (and to work with fmt) - Replace `stringify(...)` and `make_exception` usage with fmt::format (and remove stringify/make_exception from util/str.hpp).
2022-07-16 00:41:14 +00:00
{
Avoid ctor inheritance to make diagnostics better Using constructor inheritance DRYs the code, but unfortunately confuses GCC as to where the proper "required from here" location is, which makes debugging formatting errors very difficult. Avoid it (and update oxen-logging to avoid it there as well).
2022-07-18 16:07:33 +00:00
LogWarn(
T&&... args,
const log::slns::source_location& location = log::slns::source_location::current())
: log::warning<T...>::warning{
log_detail::legacy_logger,
log_detail::concat_args_fmt<sizeof...(T)>(),
std::forward<T>(args)...,
location}
{}
Replace logging with oxen-logger Replaces custom logging system with spdlog-based oxen logging. This commit mainly replaces the backend logging with the spdlog-based system, but doesn't (yet) convert all the existing LogWarn, etc. to use the new format-based logging. New logging statements will look like: llarp::log::warning(cat, "blah: {}", val); where `cat` should be set up in each .cpp or cluster of .cpp files, as described in the oxen-logging README. As part of spdlog we get fmt, which gives us nice format strings, where are applied generously in this commit. Making types printable now requires two steps: - add a ToString() method - add this specialization: template <> constexpr inline bool llarp::IsToStringFormattable<llarp::Whatever> = true; This will then allow the type to be printed as a "{}" value in a fmt::format string. This is applied to all our printable types here, and all of the `operator<<` are removed. This commit also: - replaces various uses of `operator<<` to ToString() - replaces various uses of std::stringstream with either fmt::format or plain std::string - Rename some to_string and toString() methods to ToString() for consistency (and to work with fmt) - Replace `stringify(...)` and `make_exception` usage with fmt::format (and remove stringify/make_exception from util/str.hpp).
2022-07-16 00:41:14 +00:00
};
template <typename... T>
Avoid ctor inheritance to make diagnostics better Using constructor inheritance DRYs the code, but unfortunately confuses GCC as to where the proper "required from here" location is, which makes debugging formatting errors very difficult. Avoid it (and update oxen-logging to avoid it there as well).
2022-07-18 16:07:33 +00:00
struct LOKINET_LOG_DEPRECATED(Error) LogError : log::error<T...>
Replace logging with oxen-logger Replaces custom logging system with spdlog-based oxen logging. This commit mainly replaces the backend logging with the spdlog-based system, but doesn't (yet) convert all the existing LogWarn, etc. to use the new format-based logging. New logging statements will look like: llarp::log::warning(cat, "blah: {}", val); where `cat` should be set up in each .cpp or cluster of .cpp files, as described in the oxen-logging README. As part of spdlog we get fmt, which gives us nice format strings, where are applied generously in this commit. Making types printable now requires two steps: - add a ToString() method - add this specialization: template <> constexpr inline bool llarp::IsToStringFormattable<llarp::Whatever> = true; This will then allow the type to be printed as a "{}" value in a fmt::format string. This is applied to all our printable types here, and all of the `operator<<` are removed. This commit also: - replaces various uses of `operator<<` to ToString() - replaces various uses of std::stringstream with either fmt::format or plain std::string - Rename some to_string and toString() methods to ToString() for consistency (and to work with fmt) - Replace `stringify(...)` and `make_exception` usage with fmt::format (and remove stringify/make_exception from util/str.hpp).
2022-07-16 00:41:14 +00:00
{
Avoid ctor inheritance to make diagnostics better Using constructor inheritance DRYs the code, but unfortunately confuses GCC as to where the proper "required from here" location is, which makes debugging formatting errors very difficult. Avoid it (and update oxen-logging to avoid it there as well).
2022-07-18 16:07:33 +00:00
LogError(
T&&... args,
const log::slns::source_location& location = log::slns::source_location::current())
: log::error<T...>::error{
log_detail::legacy_logger,
log_detail::concat_args_fmt<sizeof...(T)>(),
std::forward<T>(args)...,
location}
{}
Replace logging with oxen-logger Replaces custom logging system with spdlog-based oxen logging. This commit mainly replaces the backend logging with the spdlog-based system, but doesn't (yet) convert all the existing LogWarn, etc. to use the new format-based logging. New logging statements will look like: llarp::log::warning(cat, "blah: {}", val); where `cat` should be set up in each .cpp or cluster of .cpp files, as described in the oxen-logging README. As part of spdlog we get fmt, which gives us nice format strings, where are applied generously in this commit. Making types printable now requires two steps: - add a ToString() method - add this specialization: template <> constexpr inline bool llarp::IsToStringFormattable<llarp::Whatever> = true; This will then allow the type to be printed as a "{}" value in a fmt::format string. This is applied to all our printable types here, and all of the `operator<<` are removed. This commit also: - replaces various uses of `operator<<` to ToString() - replaces various uses of std::stringstream with either fmt::format or plain std::string - Rename some to_string and toString() methods to ToString() for consistency (and to work with fmt) - Replace `stringify(...)` and `make_exception` usage with fmt::format (and remove stringify/make_exception from util/str.hpp).
2022-07-16 00:41:14 +00:00
};
template <typename... T>
LogTrace(T&&...) -> LogTrace<T...>;
template <typename... T>
LogDebug(T&&...) -> LogDebug<T...>;
template <typename... T>
LogInfo(T&&...) -> LogInfo<T...>;
template <typename... T>
LogWarn(T&&...) -> LogWarn<T...>;
template <typename... T>
LogError(T&&...) -> LogError<T...>;
} // namespace llarp
Reference in New Issue Copy Permalink