refactor(logger): give each component library its own logger

ci/check_symbols.sh

@@ -100,6 +100,28 @@ for sym in "${required_symbols[@]}"; do
     fi
 done
 
+# The logger keeps one instance per component library only while its state stays hidden --
+# nothing fails to build or test if it becomes visible, since glibc silently merges it back
+# into one via STB_GNU_UNIQUE. Assert it's absent from the dynamic symbol table.
+logger_state_symbols=(
+    "cuopt::default_logger()"
+    "cuopt::global_log_buffer()"
+    "cuopt::reset_default_logger()"
+)
+
+demangled_dyn_syms="$(readelf --dyn-syms --wide "${LIBRARY}" | awk '$7 != "UND" { print $8 }' | c++filt)"
+
+for sym in "${logger_state_symbols[@]}"; do
+    echo "Checking that logger state '${sym}' is NOT exported..."
+    if grep -qF "${sym}" <<< "${demangled_dyn_syms}"; then
+        echo "ERROR: Logger state '${sym}' is exported from ${LIBRARY}."
+        echo "ERROR: Per-component loggers silently collapse into one shared instance when this"
+        echo "ERROR: state is visible. Check that cpp/src/utilities/logger.hpp's namespace is not"
+        echo "ERROR: marked CUOPT_EXPORT and that hidden visibility is still set on the target."
+        failed=1
+    fi
+done
+
 if [[ "${failed}" -ne 0 ]]; then
     exit 1
 fi

cpp/CMakeLists.txt

@@ -648,6 +648,13 @@ target_compile_definitions(cuopt_objs
   PUBLIC CUSPARSE_ENABLE_EXPERIMENTAL_API
 )
 
+# Lets callers reach routing's logger through init_component_logger_t. Also set below on
+# cuopt and cuopt_static: $<TARGET_OBJECTS:...> does not carry INTERFACE properties, and
+# consumers such as cuopt_cli and the tests link those, not cuopt_objs.
+if(NOT SKIP_ROUTING_BUILD)
+  target_compile_definitions(cuopt_objs PUBLIC CUOPT_HAS_ROUTING)
+endif()
+
 target_compile_options(cuopt_objs
         PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:${CUOPT_CXX_FLAGS}>"
         "$<$<COMPILE_LANGUAGE:CUDA>:${CUOPT_CUDA_FLAGS}>"
@@ -811,6 +818,9 @@ if (BUILD_TESTS)
             "CUOPT_LOG_ACTIVE_LEVEL=RAPIDS_LOGGER_LOG_LEVEL_${LIBCUOPT_LOGGING_LEVEL}"
             CUSPARSE_ENABLE_EXPERIMENTAL_API
     )
+    if(NOT SKIP_ROUTING_BUILD)
+        target_compile_definitions(cuopt_static PUBLIC CUOPT_HAS_ROUTING)
+    endif()
     target_link_libraries(cuopt_static PRIVATE $<TARGET_FILE:PSLP>)
     add_dependencies(cuopt_static PSLP)
     target_link_libraries(cuopt_static PRIVATE $<TARGET_FILE:KaMinPar::KaMinPar>)
@@ -869,6 +879,9 @@ target_compile_definitions(cuopt
         "CUOPT_LOG_ACTIVE_LEVEL=RAPIDS_LOGGER_LOG_LEVEL_${LIBCUOPT_LOGGING_LEVEL}"
         CUSPARSE_ENABLE_EXPERIMENTAL_API
 )
+if(NOT SKIP_ROUTING_BUILD)
+    target_compile_definitions(cuopt PUBLIC CUOPT_HAS_ROUTING)
+endif()
 
 if (WRITE_FATBIN)
     file(WRITE "${CUOPT_BINARY_DIR}/fatbin.ld"

cpp/cuopt_cli.cpp

@@ -100,8 +100,14 @@ int run_single_file(const std::string& file_path,
                     cuopt::mathematical_optimization::io::mps_reader_type_t mps_reader,
                     cuopt::mathematical_optimization::solver_settings_t<int, double>& settings)
 {
-  cuopt::init_logger_t log(settings.get_parameter<std::string>(CUOPT_LOG_FILE),
-                           settings.get_parameter<bool>(CUOPT_LOG_TO_CONSOLE));
+  // The solver's logger lives in the solver library, reachable only through its exported
+  // entry point. The CLI's own logger appends rather than truncates, so it does not clear
+  // the file the solver has just opened.
+  const auto log_file    = settings.get_parameter<std::string>(CUOPT_LOG_FILE);
+  const auto log_console = settings.get_parameter<bool>(CUOPT_LOG_TO_CONSOLE);
+
+  cuopt::init_component_logger_t solver_log(log_file, log_console);
+  cuopt::init_logger_t log(log_file, log_console, /*truncate=*/false);
 
   std::string base_filename = file_path.substr(file_path.find_last_of("/\\") + 1);
 

cpp/src/CMakeLists.txt

@@ -4,7 +4,6 @@
 # cmake-format: on
 
 set(UTIL_SRC_FILES ${CMAKE_CURRENT_SOURCE_DIR}/utilities/seed_generator.cu
-                   ${CMAKE_CURRENT_SOURCE_DIR}/utilities/logger.cpp
                    ${CMAKE_CURRENT_SOURCE_DIR}/utilities/version_info.cpp
                    ${CMAKE_CURRENT_SOURCE_DIR}/utilities/timestamp_utils.cpp
                    ${CMAKE_CURRENT_SOURCE_DIR}/utilities/work_unit_scheduler.cpp)

cpp/src/math_optimization/CMakeLists.txt

@@ -9,6 +9,7 @@ list(PREPEND
   ${CMAKE_CURRENT_SOURCE_DIR}/solution_reader.cu
   ${CMAKE_CURRENT_SOURCE_DIR}/solution_writer.cu
   ${CMAKE_CURRENT_SOURCE_DIR}/tic_toc.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/logger_entry.cpp
   )
 
 set(CUOPT_SRC_FILES ${CUOPT_SRC_FILES}

cpp/src/math_optimization/logger_entry.cpp

@@ -0,0 +1,20 @@
+/* clang-format off */
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/* clang-format on */
+
+#include <utilities/logger.hpp>
+
+// Compiled into cuopt_mathopt only, so this reaches mathopt's hidden logger instance.
+namespace cuopt::mathematical_optimization {
+
+std::shared_ptr<void> configure_logging(const std::string& log_file,
+                                        bool log_to_console,
+                                        bool truncate)
+{
+  return cuopt::make_logger_config(log_file, log_to_console, truncate);
+}
+
+}  // namespace cuopt::mathematical_optimization

cpp/src/routing/CMakeLists.txt

@@ -4,6 +4,7 @@
 # cmake-format: on
 
 set(ROUTING_SRC_FILES
+  ${CMAKE_CURRENT_SOURCE_DIR}/logger_entry.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/local_search/compute_insertions.cu
   ${CMAKE_CURRENT_SOURCE_DIR}/ges/squeeze.cu
   ${CMAKE_CURRENT_SOURCE_DIR}/local_search/sliding_window.cu

cpp/src/routing/logger_entry.cpp

@@ -0,0 +1,20 @@
+/* clang-format off */
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/* clang-format on */
+
+#include <utilities/logger.hpp>
+
+// Compiled into cuopt_routing only, so this reaches routing's hidden logger instance.
+namespace cuopt::routing {
+
+std::shared_ptr<void> configure_logging(const std::string& log_file,
+                                        bool log_to_console,
+                                        bool truncate)
+{
+  return cuopt::make_logger_config(log_file, log_to_console, truncate);
+}
+
+}  // namespace cuopt::routing

cpp/src/routing/solve.cu

@@ -16,6 +16,9 @@ template <typename i_t, typename f_t>
 assignment_t<i_t> solve(data_model_view_t<i_t, f_t> const& data_model,
                         solver_settings_t<i_t, f_t> const& settings)
 {
+  // Without this, CUOPT_LOG_ERROR below sinks into the buffer and is never emitted.
+  init_logger_t log("", settings.get_error_logging_mode());
+
   try {
     cuopt::routing::solver_t<i_t, f_t> solver(data_model, settings);
     return solver.solve();