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

@@ -25,6 +25,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 +49,21 @@ namespace mamba::logging
             }
         }
 
+        inline auto should_be_ignored(const LogRecord& record, log_level current_level) -> bool
+        {
+            switch (current_level)
+            {
+                case log_level::off:
+                    return true;
+
+                case log_level::all:
+                    return false;
+
+                default:
+                    return current_level > record.level;
+            }
+        }
+
         /** Backtrace feature implementation in it's most basic form.
 
             This is the simplest implementation for a backtrace feature
@@ -67,14 +94,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 +166,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 +175,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 +250,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 +267,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 +367,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 +461,7 @@ namespace mamba::logging
     inline auto LogHandler_History::log(LogRecord record) -> void
     {
         assert(pimpl);
-        if (pimpl->current_log_level < record.level)
+        if (details::should_be_ignored(record, pimpl->current_log_level))
         {
             return;
         }
@@ -455,12 +485,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 details::should_be_ignored(log, pimpl->current_log_level))
+            {
+                continue;
+            }
             details::queue_push(synched_data->history, options.max_records_count, std::move(log));
         }
 
@@ -470,7 +504,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 +520,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 +552,7 @@ namespace mamba::logging
         }
     }
 
-    auto LogHandler_History::is_started() const -> bool
+    inline auto LogHandler_History::is_started() const -> bool
     {
         return pimpl != nullptr;
     }
@@ -588,7 +636,7 @@ namespace mamba::logging
         assert(out);
         assert(pimpl);
 
-        if (pimpl->current_log_level > record.level)
+        if (details::should_be_ignored(record, pimpl->current_log_level))
         {
             return;
         }
@@ -625,14 +673,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 details::should_be_ignored(log_record, pimpl->current_log_level))
+            {
+                continue;
+            }
             details::log_to_stream(*out, log_record, { .with_location = pimpl->log_location });
         }
         synched_backtrace->clear();
@@ -644,7 +697,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>

libmamba/include/mamba/core/output.hpp

@@ -129,6 +129,11 @@ namespace mamba
                                                          ///< object to mark it as a success will be
                                                          ///< done once the other changes are
                                                          ///< applied.
+
+        /// Construct a json edit based on the members of a json object by using
+        /// each member as an assignation into the json object that will be edited
+        /// by this resulgint json edit.
+        static auto from_json_object_members(nlohmann::json object) -> JSONEdit;
     };
 
     class Console
@@ -183,11 +188,31 @@ namespace mamba
         */
         void set_json_output(JSONEdit edit);
 
+        /** Assigns the provided json value to the associated location in the json output object.
+            This overload is a shorter version for the 1 location 1 value assignation case
+            which is quite common.
+        */
+        template <class T>
+            requires requires(const T& value) { nlohmann::json{ value }; }
+        void set_json_output(nlohmann::json::json_pointer location, T&& value)
+        {
+            // clang-format off
+            set_json_output({
+                .to_assign{
+                    { std::move(location), std::forward<T>(value) }
+                }
+            });
+            // clang-format on
+        }
+
         /** If json output was requested, calling this before destroying a `Console` instance will
             not lead to a json output.
         */
         void cancel_json_print();
 
+        // FIXME: documentation
+        static void setup_log_handling_for_json();
+
         static void print_buffer(std::ostream& ostream);
 
         const Context& context() const;