feat(c-api): add cuOptSetLogCallback

cpp/include/cuopt/mathematical_optimization/cuopt_c.h

@@ -828,6 +828,44 @@ cuopt_int_t cuOptGetFloatParameter(cuOptSolverSettings settings,
                                    const char* parameter_name,
                                    cuopt_float_t* parameter_value);
 
+/**
+ * @brief Type of callback invoked once per standard solver log line.
+ *
+ * Receives the same lines the solver would print to the console — nothing more.
+ * Internal diagnostics (debug and trace messages) are never delivered, and no
+ * severity is reported: the callback exists to display or forward solver
+ * output, not to let callers classify or branch on it.
+ *
+ * @param message  Null-terminated log line without trailing newline.
+ * @param user_data Opaque pointer passed to cuOptSetLogCallback.
+ *
+ * @note Invoked from the calling thread for a local solve, and from an internal
+ *  log-streaming thread when the solve runs on a remote server. Do not call back
+ *  into cuOpt from inside the callback.
+ * @warning Log message formatting is not part of the stable API and may change
+ *  between releases. The callback is intended for display purposes (GUI integration,
+ *  log forwarding, stdout capture) — do not parse message content for programmatic
+ *  control flow.
+ */
+typedef void (*cuOptLogCallback)(const char* message, void* user_data);
+
+/**
+ * @brief Register a callback to receive solver log messages.
+ *
+ * The callback is invoked once per log line. It is called in addition to any
+ * file or console sink already enabled via ``log_to_console`` / ``log_file``
+ * parameters. Pass NULL to remove a previously registered callback.
+ *
+ * @param[in] settings  The solver settings object.
+ * @param[in] callback  Callback function, or NULL to clear.
+ * @param[in] user_data Opaque pointer forwarded to the callback unchanged.
+ *
+ * @return A status code indicating success or failure.
+ */
+cuopt_int_t cuOptSetLogCallback(cuOptSolverSettings settings,
+                                cuOptLogCallback callback,
+                                void* user_data);
+
 /**
  * @brief Type of callback for receiving incumbent MIP solutions with user context.
  *

cpp/src/grpc/client/solve_remote.cpp

@@ -86,13 +86,18 @@ std::unique_ptr<lp_solution_interface_t<i_t, f_t>> solve_lp_remote(
   }
   bool want_console = settings.log_to_console;
   bool want_file    = log_file_stream && log_file_stream->is_open();
-
-  if (want_console || want_file) {
-    config.stream_logs  = true;
-    config.log_callback = [want_console, want_file, &log_file_stream](const std::string& line) {
-      if (want_console) { std::cout << line << std::endl; }
-      if (want_file) { *log_file_stream << line << std::endl; }
-    };
+  // Captured here, not read inside the lambda: the streaming thread carries no
+  // registration of its own.
+  auto user_cb = cuopt::current_log_callback();
+
+  if (want_console || want_file || user_cb.callback) {
+    config.stream_logs = true;
+    config.log_callback =
+      [want_console, want_file, &log_file_stream, user_cb](const std::string& line) {
+        if (want_console) { std::cout << line << std::endl; }
+        if (want_file) { *log_file_stream << line << std::endl; }
+        if (user_cb.callback) { user_cb.callback(line.c_str(), user_cb.user_data); }
+      };
   }
 
   // Create client and connect
@@ -139,13 +144,16 @@ std::unique_ptr<mip_solution_interface_t<i_t, f_t>> solve_mip_remote(
   }
   bool want_console = settings.log_to_console;
   bool want_file    = log_file_stream && log_file_stream->is_open();
-
-  if (want_console || want_file) {
-    config.stream_logs  = true;
-    config.log_callback = [want_console, want_file, &log_file_stream](const std::string& line) {
-      if (want_console) { std::cout << line << std::endl; }
-      if (want_file) { *log_file_stream << line << std::endl; }
-    };
+  auto user_cb      = cuopt::current_log_callback();
+
+  if (want_console || want_file || user_cb.callback) {
+    config.stream_logs = true;
+    config.log_callback =
+      [want_console, want_file, &log_file_stream, user_cb](const std::string& line) {
+        if (want_console) { std::cout << line << std::endl; }
+        if (want_file) { *log_file_stream << line << std::endl; }
+        if (user_cb.callback) { user_cb.callback(line.c_str(), user_cb.user_data); }
+      };
   }
 
   // Check if user has set incumbent callbacks

cpp/src/mip_heuristics/diversity/diversity_manager.cu

@@ -212,7 +212,7 @@ void diversity_manager_t<i_t, f_t>::add_user_given_solutions(
         *problem_ptr->original_problem_ptr, h_original, h_crushed);
       init_sol_assignment = cuopt::device_copy(h_crushed, sol.handle_ptr->get_stream());
 
-#if CUOPT_LOG_ACTIVE_LEVEL <= CUOPT_LOG_LEVEL_DEBUG
+#if CUOPT_LOG_ACTIVE_LEVEL <= RAPIDS_LOGGER_LOG_LEVEL_DEBUG
       const auto& reduced_problem       = *problem_ptr->original_problem_ptr;
       const std::vector<f_t> h_red_obj  = reduced_problem.get_objective_coefficients_host();
       const std::vector<f_t>& h_ori_obj = presolver_ptr->get_original_objective_coefficients();

cpp/src/mip_heuristics/feasibility_jump/feasibility_jump.cu

@@ -946,7 +946,7 @@ i_t fj_t<i_t, f_t>::host_loop(solution_t<i_t, f_t>& solution, i_t climber_idx)
       }
     }
   }
-#if CUOPT_LOG_ACTIVE_LEVEL == CUOPT_LOG_LEVEL_TRACE
+#if CUOPT_LOG_ACTIVE_LEVEL == RAPIDS_LOGGER_LOG_LEVEL_TRACE
   auto h_sol = cuopt::host_copy(solution.assignment, climber_stream);
   static std::set<std::vector<f_t>> solutions_set;
   bool same_sol = solutions_set.count(h_sol) > 0;

cpp/src/pdlp/cuopt_c.cpp

@@ -18,6 +18,8 @@
 #include <pdlp/cuopt_c_internal.hpp>
 #include <utilities/logger.hpp>
 
+#include <optional>
+
 #include <cuopt/mathematical_optimization/io/parser.hpp>
 
 #include <cuopt/version_config.hpp>
@@ -92,6 +94,9 @@ struct solver_settings_handle_t {
   ~solver_settings_handle_t() { delete settings; }
   solver_settings_t<cuopt_int_t, cuopt_float_t>* settings;
   std::vector<std::unique_ptr<cuopt::internals::base_solution_callback_t>> callbacks;
+  // Log callback registered via cuOptSetLogCallback
+  cuOptLogCallback log_callback{nullptr};
+  void* log_callback_user_data{nullptr};
 };
 
 solver_settings_handle_t* get_settings_handle(cuOptSolverSettings settings)
@@ -1043,6 +1048,17 @@ cuopt_int_t cuOptSetMIPSetSolutionCallback(cuOptSolverSettings settings,
   return CUOPT_SUCCESS;
 }
 
+cuopt_int_t cuOptSetLogCallback(cuOptSolverSettings settings,
+                                cuOptLogCallback callback,
+                                void* user_data)
+{
+  if (settings == nullptr) { return CUOPT_INVALID_ARGUMENT; }
+  solver_settings_handle_t* handle = get_settings_handle(settings);
+  handle->log_callback             = callback;
+  handle->log_callback_user_data   = user_data;
+  return CUOPT_SUCCESS;
+}
+
 cuopt_int_t cuOptSetInitialPrimalSolution(cuOptSolverSettings settings,
                                           const cuopt_float_t* primal_solution,
                                           cuopt_int_t num_variables)
@@ -1119,6 +1135,14 @@ cuopt_int_t cuOptSolve(cuOptOptimizationProblem problem,
   if (settings == nullptr) { return CUOPT_INVALID_ARGUMENT; }
   if (solution_ptr == nullptr) { return CUOPT_INVALID_ARGUMENT; }
 
+  // Register the callback for this thread for the duration of the solve.
+  // cuOptLogCallback and log_callback_with_data_t share the same signature.
+  solver_settings_handle_t* handle = get_settings_handle(settings);
+  std::optional<cuopt::scoped_log_callback_t> log_scope;
+  if (handle->log_callback) {
+    log_scope.emplace(handle->log_callback, handle->log_callback_user_data);
+  }
+
   problem_and_stream_view_t* problem_and_stream_view =
     static_cast<problem_and_stream_view_t*>(problem);
 

cpp/src/utilities/logger.cpp

@@ -1,13 +1,18 @@
 /* clang-format off */
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 /* clang-format on */
 
 #include <utilities/logger.hpp>
 #include <utilities/version_info.hpp>
 
+#include <algorithm>
+#include <cctype>
+#include <cstdlib>
+#include <optional>
+
 namespace cuopt {
 
 struct buffered_entry {
@@ -82,13 +87,44 @@ rapids_logger::sink_ptr default_sink()
  */
 inline std::string default_pattern() { return "[%Y-%m-%d %H:%M:%S:%f] [%n] [%-6l] %v"; }
 
+/**
+ * @brief Runtime log-level override from the `CUOPT_LOG_LEVEL` environment variable.
+ *
+ * Accepts a level name (case-insensitive): TRACE, DEBUG, INFO, WARN, ERROR, CRITICAL, OFF.
+ * Returns std::nullopt if the variable is unset or holds an unrecognised value.
+ *
+ * @note Statements below the compile-time `CUOPT_LOG_ACTIVE_LEVEL` (default INFO) are
+ *  removed at build time, so raising verbosity above the build level has no effect;
+ *  lowering it (e.g. WARN/ERROR/OFF to suppress output) always works.
+ */
+inline std::optional<rapids_logger::level_enum> env_log_level()
+{
+  const char* env = std::getenv("CUOPT_LOG_LEVEL");
+  if (env == nullptr) { return std::nullopt; }
+  std::string level{env};
+  std::transform(level.begin(), level.end(), level.begin(), [](unsigned char c) {
+    return static_cast<char>(std::toupper(c));
+  });
+  if (level == "TRACE") { return rapids_logger::level_enum::trace; }
+  if (level == "DEBUG") { return rapids_logger::level_enum::debug; }
+  if (level == "INFO") { return rapids_logger::level_enum::info; }
+  if (level == "WARN") { return rapids_logger::level_enum::warn; }
+  if (level == "ERROR") { return rapids_logger::level_enum::error; }
+  if (level == "CRITICAL") { return rapids_logger::level_enum::critical; }
+  if (level == "OFF") { return rapids_logger::level_enum::off; }
+  return std::nullopt;  // unrecognised value: keep the compiled default
+}
+
 /**
  * @brief Returns the default log level for the global logger.
  *
+ * The `CUOPT_LOG_LEVEL` environment variable, when set, overrides the compile-time default.
+ *
  * @return rapids_logger::level_enum The default log level.
  */
 inline rapids_logger::level_enum default_level()
 {
+  if (auto lvl = env_log_level()) { return *lvl; }
 #if CUOPT_LOG_ACTIVE_LEVEL == RAPIDS_LOGGER_LOG_LEVEL_TRACE
   return rapids_logger::level_enum::trace;
 #elif CUOPT_LOG_ACTIVE_LEVEL == RAPIDS_LOGGER_LOG_LEVEL_DEBUG
@@ -137,22 +173,62 @@ void reset_default_logger()
   default_logger().flush_on(rapids_logger::level_enum::debug);
 }
 
-// Guard object whose destructor resets the logger
+static std::mutex g_guard_mutex;
+
+// Guard object whose destructor resets the logger.
 struct logger_config_guard {
   ~logger_config_guard() { cuopt::reset_default_logger(); }
 };
 
 // Weak reference to detect if any init_logger_t instance is still alive
 static std::weak_ptr<logger_config_guard> g_active_guard;
-static std::mutex g_guard_mutex;
+
+// Registration is per-thread, not global: the sink is shared by every solve, so
+// the callback has to be selected by who is logging rather than by who
+// registered last (#1752).
+namespace {
+struct thread_log_callback_t {
+  log_callback_with_data_t callback = nullptr;
+  void* user_data                   = nullptr;
+};
+thread_local thread_log_callback_t t_log_callback;
+}  // namespace
+
+static void user_log_bridge(int lvl, const char* msg)
+{
+  // Standard solver output only; debug/trace are internal diagnostics and must
+  // not reach user code even in a lower-level build.
+  if (lvl < static_cast<int>(rapids_logger::level_enum::info)) { return; }
+
+  const auto& cb = t_log_callback;
+  if (cb.callback) { cb.callback(msg, cb.user_data); }
+}
+
+log_callback_registration_t current_log_callback()
+{
+  return {t_log_callback.callback, t_log_callback.user_data};
+}
+
+scoped_log_callback_t::scoped_log_callback_t(log_callback_with_data_t cb, void* user_data)
+  : prev_callback_(t_log_callback.callback), prev_user_data_(t_log_callback.user_data)
+{
+  t_log_callback.callback  = cb;
+  t_log_callback.user_data = user_data;
+}
+
+scoped_log_callback_t::~scoped_log_callback_t()
+{
+  t_log_callback.callback  = prev_callback_;
+  t_log_callback.user_data = prev_user_data_;
+}
 
 init_logger_t::init_logger_t(std::string log_file, bool log_to_console)
 {
   std::lock_guard<std::mutex> lock(g_guard_mutex);
 
   auto existing_guard = g_active_guard.lock();
   if (existing_guard) {
-    // Reuse existing configuration, just hold a reference to keep it alive
+    // Reuse existing configuration, just hold a reference to keep it alive.
     guard_ = existing_guard;
     return;
   }
@@ -169,6 +245,12 @@ init_logger_t::init_logger_t(std::string log_file, bool log_to_console)
       std::make_shared<rapids_logger::basic_file_sink_mt>(log_file, true));
     cuopt::default_logger().flush_on(rapids_logger::level_enum::debug);
   }
+  auto guard = std::make_shared<logger_config_guard>();
+
+  // Always installed: the bridge no-ops unless the logging thread has a
+  // registration, so delivery no longer depends on which solve built the guard.
+  cuopt::default_logger().sinks().push_back(
+    std::make_shared<rapids_logger::callback_sink_mt>(user_log_bridge));
 
 #if CUOPT_LOG_ACTIVE_LEVEL >= RAPIDS_LOGGER_LOG_LEVEL_INFO
   cuopt::default_logger().set_pattern("%v");
@@ -182,8 +264,6 @@ init_logger_t::init_logger_t(std::string log_file, bool log_to_console)
     cuopt::default_logger().log(entry.level, entry.msg.c_str());
   }
 
-  // Create guard and store weak reference for future instances to find
-  auto guard     = std::make_shared<logger_config_guard>();
   g_active_guard = guard;
   guard_         = guard;
 }

cpp/src/utilities/logger.hpp

@@ -38,6 +38,42 @@ rapids_logger::logger& default_logger();
  */
 void reset_default_logger();
 
+// C-compatible log callback type. Matches cuOptLogCallback in cuopt_c.h.
+// Carries no severity by design: a level would become a de-facto public API.
+using log_callback_with_data_t = void (*)(const char* message, void* user_data);
+
+struct log_callback_registration_t {
+  log_callback_with_data_t callback = nullptr;
+  void* user_data                   = nullptr;
+};
+
+/**
+ * @brief The calling thread's current registration, if any.
+ *
+ * For forwarding log lines produced on a thread that carries no registration of
+ * its own, such as the remote-solve log-streaming thread.
+ */
+log_callback_registration_t current_log_callback();
+
+/**
+ * @brief Registers a log callback for the calling thread, for its own lifetime.
+ *
+ * Registration is per-thread so concurrent solves cannot capture each other's
+ * callback. Log lines emitted on other threads are not delivered.
+ */
+class scoped_log_callback_t {
+ public:
+  scoped_log_callback_t(log_callback_with_data_t cb, void* user_data);
+  ~scoped_log_callback_t();
+
+  scoped_log_callback_t(const scoped_log_callback_t&)            = delete;
+  scoped_log_callback_t& operator=(const scoped_log_callback_t&) = delete;
+
+ private:
+  log_callback_with_data_t prev_callback_;
+  void* prev_user_data_;
+};
+
 // Ref-counted logger initializer
 class init_logger_t {
   // Using shared_ptr for ref-counting