refactor

Author: Tsche

example/spans.cpp

@@ -1,10 +1,8 @@
 #include <rsl/log>
 
-using enum rsl::logging::LogLevel;
-
 void bar() {
   // TODO
-  rsl::logging::ContextGuard context{"bar", INFO, std::monostate()};
+  RSL_LOG_CONTEXT("bar", rsl::log_level::INFO, x=1, y=2);
   rsl::info("from bar");
 }
 
@@ -19,7 +17,7 @@ int main() {
 
   // rsl::logging::ContextGuard context{INFO, "main"};
   auto x = 42;
-  auto ctx = rsl::log::context("main", INFO);
+  auto ctx = rsl::log::context("main", rsl::log_level::INFO);
   // ctx.extra = ExtraFields{{rsl::_log_impl::Field(^^x).set_ptr(&x)}};
   ctx.enter();
   rsl::error("test error");

include/rsl/log

@@ -1,9 +1,12 @@
 #pragma once
 #include <rsl/logging/_impl/formatter.hpp>
 #include <rsl/logging/_impl/args.hpp>
-#include <rsl/logging/logger.hpp>
+#include <rsl/logging/output.hpp>
 #include <rsl/logging/context.hpp>
 
+#include <rsl/logging/flavor/default.hpp>
+#include <rsl/logging/flavor/null.hpp>
+
 #include <utility>
 
 #include <rsl/kwargs>

include/rsl/logging/_impl/args.hpp

@@ -3,6 +3,7 @@
 #include <ranges>
 
 #include <rsl/logging/field.hpp>
+#include <rsl/util/to_string.hpp>
 
 namespace rsl::logging {
 namespace _impl {
@@ -27,20 +28,24 @@ struct FunctionScope {
   }
 
   template <typename... Ts>
-  static ExtraFields capture_args(Ts&&... args) {
+  static std::array<Field, max_idx> capture_args(Ts&&... args) {
     std::array<Field, max_idx> arguments;
+    std::size_t unnamed_count = 0;
+
     template for (constexpr auto Idx : std::views::iota(0ZU, max_idx)) {
       constexpr static auto param = parameters_of(scope)[Idx];
-      constexpr static auto name  = define_static_string(identifier_of(param));
 
       typename[:type_of(param):]* ptr = nullptr;
       if constexpr (sizeof...(Ts) >= Idx) {
         ptr = args...[Idx];
       }
-      arguments[Idx] = Field(name, ptr);
+
+      arguments[Idx] = Field(has_identifier(param) ? identifier_of(param)
+                                                   : "unnamed_" + rsl::util::utos(unnamed_count++),
+                             ptr);
     }
 
-    return ExtraFields({arguments.begin(), arguments.end()});
+    return arguments;
   }
 };
 }  // namespace rsl::logging

include/rsl/logging/_impl/default_config.hpp

@@ -1,5 +1,5 @@
 #pragma once
-#include <rsl/logging/logger.hpp>
+#include <rsl/logging/flavor/default.hpp>
 #include <rsl/logging/level.hpp>
 #include <rsl/logging/event.hpp>
 

include/rsl/logging/_impl/formatter.hpp

@@ -15,7 +15,6 @@
 #include <rsl/logging/event.hpp>
 #include <rsl/logging/context.hpp>
 #include <rsl/logging/field.hpp>
-#include <rsl/logging/logger.hpp>
 
 namespace rsl::logging {
 namespace _impl {

include/rsl/logging/context.hpp

@@ -83,15 +83,18 @@ extern thread_local Context* current_context;
 
 template <typename T = std::monostate>
 struct ContextGuard : private Context {
-  T extra;
+  T extra_data;
 
   explicit ContextGuard(std::string name,
                         LogLevel min_level,
-                        T extra = {},
                         ExtraFields arguments            = {},
+                        T extra_fields                   = {},
                         rsl::source_location const& sloc = std::source_location::current())
-      : Context(name, min_level, arguments, {}, sloc) {
-    // TODO bind T as ExtraFields
+      : Context(name, min_level, arguments, {}, sloc)
+      , extra_data(extra_fields) {
+    if constexpr (not std::same_as<T, std::monostate>) {
+      extra = ExtraFields(extra_fields);
+    }
     enter<T>();
   }
 
@@ -105,7 +108,6 @@ struct ContextGuard : private Context {
   using Context::enabled_for;
 };
 
-
 namespace _log_impl {
 template <typename T>
 concept has_member_op_co_await = requires(T t) { t.operator co_await(); };

include/rsl/logging/field.hpp

@@ -7,9 +7,9 @@
 #include <meta>
 #include <atomic>
 
-
 #include <rsl/serialize>
 #include <rsl/repr>
+#include <rsl/kwargs>
 
 namespace rsl::logging {
 class Field {
@@ -51,7 +51,7 @@ class Field {
       auto const& control_block = *static_cast<RefCounted const*>(field->ptr);
       // control_block.references++;
       auto val = control_block.references.fetch_add(1);
-      return Field(field->ptr, field->vtable, field->name);
+      return {field->ptr, field->vtable, field->name};
     }
 
     static void destroy(void* p) {
@@ -86,7 +86,7 @@ class Field {
     return &table;
   }
 
-  void* ptr                   = nullptr;
+  void* ptr            = nullptr;
   VTable const* vtable = nullptr;
 
   void destroy() {
@@ -117,10 +117,7 @@ class Field {
   Field(const Field& other) : Field(copy_from(other)) {}
 
   // move constructor
-  Field(Field&& other) noexcept
-      : ptr(other.ptr)
-      , vtable(other.vtable)
-      , name(other.name) {
+  Field(Field&& other) noexcept : ptr(other.ptr), vtable(other.vtable), name(other.name) {
     other.ptr    = nullptr;
     other.vtable = nullptr;
   }
@@ -148,7 +145,7 @@ class Field {
   template <typename T>
     requires(not std::same_as<T, void>)
   Field(std::string_view name, T* value)
-      : ptr(value)
+      : ptr((void*)value)
       , vtable(make_vtable<T, false>())
       , name(name) {}
 
@@ -191,22 +188,26 @@ class Field {
 };
 
 struct ExtraFields {
-  //TODO this could be a span that views memory on the stack and transitions to heap if its elts do
+  // TODO this could be a span that views memory on the stack and transitions to heap if its elts do
   std::vector<Field> fields;
 
   ExtraFields() = default;
+
+  template <std::size_t N>
+  explicit(false) ExtraFields(std::array<Field, N> const& fields) {}
+
   explicit(false) ExtraFields(std::vector<Field> fields) : fields(std::move(fields)) {}
   template <typename T>
-    requires std::is_aggregate_v<std::remove_cvref_t<T>>
-  explicit(false) ExtraFields(T&& kwargs) {
+    requires is_kwargs<T>
+  explicit(false) ExtraFields(T const& kwargs) {
     template for (constexpr auto member : std::define_static_array(
                       nonstatic_data_members_of(^^typename std::remove_cvref_t<T>::type,
                                                 std::meta::access_context::current()))) {
       static constexpr auto name = std::define_static_string(identifier_of(member));
       // we need to clone here
       // the kwargs wrapper will not live long enough, it'll be destroyed
       // after the full expression in which this container is created
-      fields.push_back(Field(name, &kwargs.[:member:]).clone());
+      fields.push_back(Field(name, &kwargs.[:member:]));
     }
   }
 

include/rsl/logging/async_logger.hpp include/rsl/logging/flavor/async.hppinclude/rsl/logging/async_logger.hpp renamed to include/rsl/logging/flavor/async.hpp

@@ -1,4 +1,4 @@
-#include "logger.hpp"
+#include "default.hpp"
 
 namespace rsl::logging {
 struct AsyncLogger : DefaultLogger {

include/rsl/logging/flavor/default.hpp

@@ -0,0 +1,35 @@
+#pragma once
+#include <rsl/logging/event.hpp>
+#include <rsl/logging/output.hpp>
+
+namespace rsl::logging {
+namespace _impl {
+template <LogLevel Level, typename... Args>
+struct FormatString;
+}
+
+struct DefaultLogger {
+  static void context(Metadata const& meta, bool entered, bool async_handover) {
+    if (auto* output = current_output()) {
+      output->context(meta, entered, async_handover);
+    }
+  }
+
+  template <LogLevel Severity, typename... Args>
+  static void emit(Metadata& meta, _impl::FormatString<Severity, Args...> fmt, Args&&... args) {
+    auto message = fmt.make_message(std::forward<Args>(args)...);
+    auto event   = Event{.meta = meta, .text = message};
+    if (auto* output = current_output()) {
+      output->emit(event);
+    }
+  }
+
+  static void set_output(OutputBase& output) {
+    current_output() = &output;
+  }
+
+private:
+  static OutputBase*& current_output();
+};
+
+}  // namespace rsl::logging

include/rsl/logging/flavor/null.hpp

@@ -0,0 +1,17 @@
+#pragma once
+#include <rsl/logging/event.hpp>
+
+namespace rsl::logging {
+namespace _impl {
+template <LogLevel Level, typename... Args>
+struct FormatString;
+}
+
+struct NullLogger {
+  static void context(Metadata const& meta, bool entered, bool async_handover) {}
+
+  template <LogLevel Severity, typename... Args>
+  static void emit(Metadata& meta, _impl::FormatString<Severity, Args...> fmt, Args&&... args) {}
+};
+
+}  // namespace rsl::logging