fix: Don't log if --json or --quiet

libmamba/include/mamba/core/context.hpp

@@ -65,10 +65,18 @@ namespace mamba
     class Logger;
     class Context;
 
+    struct OutputParams : LoggingParams
+    {
+        bool json{ false };
+        bool quiet{ false };
+        int verbosity{ 0 };
+    };
+
     struct ContextOptions
     {
         bool enable_logging = false;
         bool enable_signal_handling = false;
+        std::optional<OutputParams> output_params = {};
     };
 
     // Context singleton class
@@ -78,12 +86,7 @@ namespace mamba
 
         static void use_default_signal_handler(bool val);
 
-        struct OutputParams : LoggingParams
-        {
-            bool json{ false };
-            bool quiet{ false };
-            int verbosity{ 0 };
-        };
+        using OutputParams = mamba::OutputParams;
 
         struct GraphicsParams
         {

libmamba/include/mamba/core/logging.hpp

@@ -694,6 +694,13 @@ namespace mamba
             auto unsafe_get() const -> const std::remove_pointer_t<P>*;
             ///@}
 
+            /** `true` if the log handler instance is the same for both.
+             */
+            ///@{
+            friend bool operator==(const AnyLogHandler&, const AnyLogHandler&) = default;
+            friend bool operator!=(const AnyLogHandler&, const AnyLogHandler&) = default;
+            ///@}
+
         private:
 
             struct Interface;
@@ -792,16 +799,21 @@ namespace mamba
 
         /** Changes the logging system configuration.
 
-            If a log handler is registered, this function calls `AnyLogHandler::set_params` with the
-            same arguments.
+            If a log handler is registered and `update_log_handler` is `true`,
+            this function calls `AnyLogHandler::set_params` with the same arguments.
             @see `mamba::logging:LogHandler` and @see `mamba::logging::AnyLogHandler` for details.
 
             This call is thread safe as long as the log handler implementation fulfills the
             thread-safety requirements, @see `mamba::logging::LogHandler`.
 
+            Warning: `update_log_handler = false` should only be used when implementing
+            other operations that need to update the params and then update the log handler
+            themselves, separately.
+
             @returns The previous configuration of the logging system.
         */
-        auto set_logging_params(LoggingParams new_params) -> LoggingParams;
+        auto set_logging_params(LoggingParams new_params, bool update_log_handler = true)
+            -> LoggingParams;
 
         // TODO: potential performance improvement: log(record_generator, log_level) where
         // record_generator is a callable which generates the log record but is only called AFTER we
@@ -882,7 +894,7 @@ namespace mamba
         auto log_backtrace() -> void;
 
         /** Sends the log records in the backtrace history to the implementation's logging sinks,
-            but without filtering the logging level of the log records.
+            but with filtering the logging level of the log records as if they were logged now.
 
             If a log handler is registered, this function calls
            `AnyLogHandler::log_backtrace_no_guards`, otherwise this function will do nothing.
@@ -1024,6 +1036,9 @@ namespace mamba::logging
 
     inline auto enable_backtrace(size_t records_buffer_size) -> void
     {
+        auto params = get_logging_params();
+        params.log_backtrace = records_buffer_size;
+        set_logging_params(params, false);
         call_log_handler_if_existing(&AnyLogHandler::enable_backtrace, records_buffer_size);
     }
 

libmamba/include/mamba/core/logging_tools.hpp

@@ -3,6 +3,8 @@
 // Distributed under the terms of the BSD 3-Clause License.
 //
 // The full license is in the file LICENSE, distributed with this software.
+#ifndef MAMBA_CORE_LOGGING_TOOLS_HPP
+#define MAMBA_CORE_LOGGING_TOOLS_HPP
 
 #include <atomic>
 #include <concepts>
@@ -25,6 +27,18 @@ namespace mamba::logging
         { out.flush() };
     };
 
+    /** Transforms a source location into a human-readable string ready for logging purpose. */
+    inline auto as_log(const std::source_location& location) -> std::string
+    {
+        return fmt::format(
+            "{}:{}:{} {}",
+            location.file_name(),
+            location.line(),
+            location.column(),
+            location.function_name()
+        );
+    }
+
     namespace details
     {
         inline auto queue_push(std::deque<LogRecord>& queue, size_t max_elements, LogRecord record)
@@ -37,6 +51,21 @@ namespace mamba::logging
             }
         }
 
+        inline auto should_be_emitted(const LogRecord& record, log_level current_level) -> bool
+        {
+            switch (current_level)
+            {
+                case log_level::off:
+                    return false;
+
+                case log_level::all:
+                    return true;
+
+                default:
+                    return record.level >= current_level;
+            }
+        }
+
         /** Backtrace feature implementation in it's most basic form.
 
             This is the simplest implementation for a backtrace feature
@@ -67,14 +96,15 @@ namespace mamba::logging
             */
             auto push_if_enabled(LogRecord& record) -> bool
             {
-                if (not is_enabled())
+                if (is_enabled())
+                {
+                    queue_push(backtrace, backtrace_max, std::move(record));
+                    return true;
+                }
+                else
                 {
                     return false;
                 }
-
-                queue_push(backtrace, backtrace_max, std::move(record));
-
-                return true;
             }
 
             /** Changes the number of log records kept in the backtrace history.
@@ -138,17 +168,6 @@ namespace mamba::logging
             }
         };
 
-        inline auto as_log(const std::source_location& location) -> std::string
-        {
-            return fmt::format(
-                "{}:{}:{} {}",
-                location.file_name(),
-                location.line(),
-                location.column(),
-                location.function_name()
-            );
-        }
-
         struct log_to_stream_options
         {
             bool with_location = false;
@@ -158,9 +177,8 @@ namespace mamba::logging
         log_to_stream(OutputStream auto& out, const LogRecord& record, log_to_stream_options options = {})
             -> OutputStream auto&
         {
-            auto location_str = options.with_location
-                                    ? fmt::format(" ({})", details::as_log(record.location))
-                                    : std::string{};
+            auto location_str = options.with_location ? fmt::format(" ({})", as_log(record.location))
+                                                      : std::string{};
 
             out << fmt::format(
                 "\n{} {}{} : {}",
@@ -234,7 +252,13 @@ namespace mamba::logging
 
         auto enable_backtrace(size_t record_buffer_size) -> void;
         auto disable_backtrace() -> void;
-        auto log_backtrace() -> void;
+
+        /** @see `AnyLogHandler::log_backtrace()`
+
+            @param filter_current_level If `true`, will filter out log records that would not
+                                        pass the log level filter if they were emitted right now.
+        */
+        auto log_backtrace(bool filter_current_level = false) -> void;
         auto log_backtrace_no_guards() -> void;
 
         auto flush(std::optional<log_source> source = {}) -> void;
@@ -245,12 +269,14 @@ namespace mamba::logging
         ////////////////////////////////////////////
         // History api - thread-safe
 
-        /** @returns A copy of the current log record history.
+        /** Captures the currently stored sequence of `LogRecord`.
+            @param   `and_clear` Will also clear the existing history if `true`.
+            @returns A copy of the current log record history.
                      The value should be considered immediately obsolete
                      as new log records could be pushed concurrently.
                      The returned history will be empty if `is_started()` == false.
         */
-        auto capture_history() const -> std::vector<LogRecord>;
+        auto capture_history(bool and_clear = false) const -> std::vector<LogRecord>;
 
         /** Clears the internal history.
 
@@ -343,7 +369,13 @@ namespace mamba::logging
 
         auto enable_backtrace(size_t record_buffer_size) -> void;
         auto disable_backtrace() -> void;
-        auto log_backtrace() -> void;
+
+        /** @see `AnyLogHandler::log_backtrace()`
+
+            @param filter_current_level If `true`, will filter out log records that would not
+                                        pass the log level filter if they were emitted right now.
+        */
+        auto log_backtrace(bool filter_current_level = false) -> void;
         auto log_backtrace_no_guards() -> void;
 
         auto flush(std::optional<log_source> source = {}) -> void;
@@ -431,7 +463,7 @@ namespace mamba::logging
     inline auto LogHandler_History::log(LogRecord record) -> void
     {
         assert(pimpl);
-        if (pimpl->current_log_level < record.level)
+        if (not details::should_be_emitted(record, pimpl->current_log_level))
         {
             return;
         }
@@ -455,12 +487,16 @@ namespace mamba::logging
         pimpl->data->backtrace.disable();
     }
 
-    inline auto LogHandler_History::log_backtrace() -> void
+    inline auto LogHandler_History::log_backtrace(bool filter_current_level) -> void
     {
         assert(pimpl);
         auto synched_data = pimpl->data.synchronize();
         for (auto& log : synched_data->backtrace)
         {
+            if (filter_current_level and not details::should_be_emitted(log, pimpl->current_log_level))
+            {
+                continue;
+            }
             details::queue_push(synched_data->history, options.max_records_count, std::move(log));
         }
 
@@ -470,7 +506,8 @@ namespace mamba::logging
     inline auto LogHandler_History::log_backtrace_no_guards() -> void
     {
         assert(pimpl);
-        log_backtrace();  // Similar in this context
+        log_backtrace(true);  // Similar in this context but we want to filter out logs that would
+                              // not pass the level filter now
     }
 
     inline auto LogHandler_History::flush(std::optional<log_source>) -> void
@@ -485,12 +522,25 @@ namespace mamba::logging
         // nothing to do, we keep history, there is no flush
     }
 
-    inline auto LogHandler_History::capture_history() const -> std::vector<LogRecord>
+    inline auto LogHandler_History::capture_history(bool and_clear) const -> std::vector<LogRecord>
     {
         if (pimpl)
         {
             auto synched_data = pimpl->data.synchronize();
-            return std::vector<LogRecord>(synched_data->history.begin(), synched_data->history.end());
+            if (and_clear)
+            {
+                std::vector<LogRecord> result(synched_data->history.size());
+                std::ranges::move(synched_data->history, result.begin());
+                synched_data->history.clear();
+                return result;
+            }
+            else
+            {
+                return std::vector<LogRecord>(
+                    synched_data->history.begin(),
+                    synched_data->history.end()
+                );
+            }
         }
 
         return {};
@@ -504,7 +554,7 @@ namespace mamba::logging
         }
     }
 
-    auto LogHandler_History::is_started() const -> bool
+    inline auto LogHandler_History::is_started() const -> bool
     {
         return pimpl != nullptr;
     }
@@ -588,7 +638,7 @@ namespace mamba::logging
         assert(out);
         assert(pimpl);
 
-        if (pimpl->current_log_level > record.level)
+        if (not details::should_be_emitted(record, pimpl->current_log_level))
         {
             return;
         }
@@ -625,14 +675,19 @@ namespace mamba::logging
     }
 
     template <OutputStream T>
-    inline auto LogHandler_Stream<T>::log_backtrace() -> void
+    inline auto LogHandler_Stream<T>::log_backtrace(bool filter_current_level) -> void
     {
         assert(out);
         assert(pimpl);
 
         auto synched_backtrace = pimpl->backtrace.synchronize();
         for (auto& log_record : *synched_backtrace)
         {
+            if (filter_current_level
+                and not details::should_be_emitted(log_record, pimpl->current_log_level))
+            {
+                continue;
+            }
             details::log_to_stream(*out, log_record, { .with_location = pimpl->log_location });
         }
         synched_backtrace->clear();
@@ -644,7 +699,8 @@ namespace mamba::logging
         assert(out);
         assert(pimpl);
 
-        log_backtrace();  // Similar in this context
+        log_backtrace(true);  // Similar in this context but we want to filter out logs that would
+                              // not pass the level filter now
     }
 
     template <OutputStream T>
@@ -672,3 +728,5 @@ namespace mamba::logging
     }
 
 }
+
+#endif