feat(c-api): add cuOptSetLogCallback

cpp/include/cuopt/mathematical_optimization/constants.h

@@ -146,6 +146,15 @@
 /* @brief QCQP (barrier) scaling hyper-parameters */
 #define CUOPT_QCQP_HYPER_RUIZ_EQUILIBRATION "qcqp_hyper_ruiz_equilibration"
 
+/* @brief Log level constants for cuOptSetLogLevel */
+#define CUOPT_LOG_LEVEL_TRACE    0
+#define CUOPT_LOG_LEVEL_DEBUG    1
+#define CUOPT_LOG_LEVEL_INFO     2
+#define CUOPT_LOG_LEVEL_WARN     3
+#define CUOPT_LOG_LEVEL_ERROR    4
+#define CUOPT_LOG_LEVEL_CRITICAL 5
+#define CUOPT_LOG_LEVEL_OFF      6
+
 /* @brief MIP determinism mode constants */
 #define CUOPT_MODE_OPPORTUNISTIC 0
 #define CUOPT_MODE_DETERMINISTIC 1

cpp/include/cuopt/mathematical_optimization/cuopt_c.h

@@ -823,6 +823,45 @@ cuopt_int_t cuOptGetFloatParameter(cuOptSolverSettings settings,
                                    const char* parameter_name,
                                    cuopt_float_t* parameter_value);
 
+/**
+ * @brief Type of callback invoked once per log line emitted by the solver.
+ *
+ * @param level    Log level (one of CUOPT_LOG_LEVEL_*).
+ * @param message  Null-terminated log line without trailing newline.
+ * @param user_data Opaque pointer passed to cuOptSetLogCallback.
+ *
+ * @note The callback is invoked from the solver thread. Do not call back into
+ *  cuOpt from inside the callback.
+ */
+typedef void (*cuOptLogCallback)(int level, 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 Set the solver log verbosity level.
+ *
+ * @param[in] settings The solver settings object.
+ * @param[in] level    One of CUOPT_LOG_LEVEL_TRACE … CUOPT_LOG_LEVEL_OFF.
+ *
+ * @return A status code indicating success or failure.
+ */
+cuopt_int_t cuOptSetLogLevel(cuOptSolverSettings settings, int level);
+
 /**
  * @brief Type of callback for receiving incumbent MIP solutions with user context.
  *

cpp/src/pdlp/cuopt_c.cpp

@@ -89,6 +89,11 @@ 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};
+  // Log level override registered via cuOptSetLogLevel (-1 = use default)
+  int log_level{-1};
 };
 
 solver_settings_handle_t* get_settings_handle(cuOptSolverSettings settings)
@@ -1069,6 +1074,27 @@ 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 cuOptSetLogLevel(cuOptSolverSettings settings, int level)
+{
+  if (settings == nullptr) { return CUOPT_INVALID_ARGUMENT; }
+  if (level < CUOPT_LOG_LEVEL_TRACE || level > CUOPT_LOG_LEVEL_OFF) {
+    return CUOPT_INVALID_ARGUMENT;
+  }
+  get_settings_handle(settings)->log_level = level;
+  return CUOPT_SUCCESS;
+}
+
 cuopt_int_t cuOptSetInitialPrimalSolution(cuOptSolverSettings settings,
                                           const cuopt_float_t* primal_solution,
                                           cuopt_int_t num_variables)
@@ -1145,6 +1171,29 @@ cuopt_int_t cuOptSolve(cuOptOptimizationProblem problem,
   if (settings == nullptr) { return CUOPT_INVALID_ARGUMENT; }
   if (solution_ptr == nullptr) { return CUOPT_INVALID_ARGUMENT; }
 
+  // Install user log callback / level so init_logger_t inside the solver picks them up.
+  // The RAII guard clears them on scope exit (whether by return or exception).
+  solver_settings_handle_t* handle = get_settings_handle(settings);
+  struct log_scope_guard_t {
+    bool has_callback;
+    bool has_level;
+    ~log_scope_guard_t()
+    {
+      if (has_callback) { cuopt::clear_pending_log_callback(); }
+      if (has_level) { cuopt::clear_pending_log_level(); }
+    }
+  } log_scope{false, false};
+
+  if (handle->log_callback) {
+    // cuOptLogCallback and log_callback_with_data_t share the same signature.
+    cuopt::set_pending_log_callback(handle->log_callback, handle->log_callback_user_data);
+    log_scope.has_callback = true;
+  }
+  if (handle->log_level >= 0) {
+    cuopt::set_pending_log_level(handle->log_level);
+    log_scope.has_level = true;
+  }
+
   problem_and_stream_view_t* problem_and_stream_view =
     static_cast<problem_and_stream_view_t*>(problem);
 

cpp/src/utilities/logger.cpp

@@ -146,6 +146,43 @@ struct logger_config_guard {
 static std::weak_ptr<logger_config_guard> g_active_guard;
 static std::mutex g_guard_mutex;
 
+// Pending user log callback set by the C API before a solve.
+// Accessed under g_guard_mutex.
+static log_callback_with_data_t g_pending_callback      = nullptr;
+static void* g_pending_callback_data                    = nullptr;
+static int g_pending_log_level                          = -1;  // -1 = use compiled default
+
+static void user_log_bridge(int lvl, const char* msg)
+{
+  if (g_pending_callback) { g_pending_callback(lvl, msg, g_pending_callback_data); }
+}
+
+void set_pending_log_callback(log_callback_with_data_t cb, void* user_data)
+{
+  std::lock_guard<std::mutex> lock(g_guard_mutex);
+  g_pending_callback      = cb;
+  g_pending_callback_data = user_data;
+}
+
+void clear_pending_log_callback()
+{
+  std::lock_guard<std::mutex> lock(g_guard_mutex);
+  g_pending_callback      = nullptr;
+  g_pending_callback_data = nullptr;
+}
+
+void set_pending_log_level(int level)
+{
+  std::lock_guard<std::mutex> lock(g_guard_mutex);
+  g_pending_log_level = level;
+}
+
+void clear_pending_log_level()
+{
+  std::lock_guard<std::mutex> lock(g_guard_mutex);
+  g_pending_log_level = -1;
+}
+
 init_logger_t::init_logger_t(std::string log_file, bool log_to_console)
 {
   std::lock_guard<std::mutex> lock(g_guard_mutex);
@@ -169,13 +206,21 @@ 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);
   }
+  if (g_pending_callback) {
+    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");
 #else
   cuopt::default_logger().set_pattern(cuopt::default_pattern());
 #endif
 
+  if (g_pending_log_level >= 0) {
+    cuopt::default_logger().set_level(static_cast<rapids_logger::level_enum>(g_pending_log_level));
+  }
+
   // Extract messages from the global buffer and log to the default logger
   auto buffered_messages = global_log_buffer().drain_all();
   for (const auto& entry : buffered_messages) {

cpp/src/utilities/logger.hpp

@@ -36,6 +36,26 @@ rapids_logger::logger& default_logger();
  */
 void reset_default_logger();
 
+// C-compatible log callback type: void callback(int level, const char* msg, void* user_data)
+// Matches cuOptLogCallback in cuopt_c.h — layout-compatible, no dependency on that header.
+using log_callback_with_data_t = void (*)(int level, const char* message, void* user_data);
+
+/**
+ * @brief Install a user log callback to be picked up by the next init_logger_t.
+ *
+ * Must be called before the init_logger_t that starts the targeted solve.
+ * Protected by the same mutex as init_logger_t so it is safe to call from
+ * any thread, but do not call from inside the callback itself.
+ */
+void set_pending_log_callback(log_callback_with_data_t cb, void* user_data);
+void clear_pending_log_callback();
+
+/**
+ * @brief Override the log level for the next init_logger_t.  Pass -1 to restore the default.
+ */
+void set_pending_log_level(int level);
+void clear_pending_log_level();
+
 // Ref-counted logger initializer
 class init_logger_t {
   // Using shared_ptr for ref-counting