std::lock_guard<std::mutex> lock(mutex_);

// Skip if already initialized (check inside lock to prevent TOCTOU race)

if (initialized_) {

return;

}

try {

// Acquire GIL for Python API calls

py::gil_scoped_acquire gil;

// Import the logging module

py::module_ logging_module = py::module_::import("mssql_python.logging");

// Get the logger instance

py::object logger_obj = logging_module.attr("logger");

// Cache the logger object pointer

// NOTE: We don't increment refcount because pybind11 py::object manages

// lifetime and the logger is a module-level singleton that persists for

// program lifetime. Adding Py_INCREF here would cause a memory leak

// since we never Py_DECREF.

cached_logger_ = logger_obj.ptr();

// Get initial log level

py::object level_obj = logger_obj.attr("level");

int level = level_obj.cast<int>();

cached_level_.store(level, std::memory_order_relaxed);

initialized_ = true;

} catch (const py::error_already_set& e) {

// Failed to initialize - log to stderr and continue

// (logging will be disabled but won't crash)

std::cerr << "LoggerBridge initialization failed: " << e.what() << std::endl;

initialized_ = false;

} catch (const std::exception& e) {

std::cerr << "LoggerBridge initialization failed: " << e.what() << std::endl;

initialized_ = false;

}

// Update the cached level atomically

// This is lock-free and can be called from any thread

cached_level_.store(level, std::memory_order_relaxed);

// Use a stack buffer for most messages (4KB should be enough)

char buffer[4096];

// Format the message using safe std::vsnprintf (C++11 standard)

// std::vsnprintf with size parameter is the recommended safe alternative

// It always null-terminates and never overflows the buffer

// DevSkim: ignore DS185832 - std::vsnprintf with explicit size is safe

va_list args_copy;

va_copy(args_copy, args);

int result = std::vsnprintf(buffer, sizeof(buffer), format, args_copy);

va_end(args_copy);

if (result < 0) {

// Error during formatting

return "[Formatting error]";

}

if (result < static_cast<int>(sizeof(buffer))) {

// Message fit in buffer (vsnprintf guarantees null-termination)

return std::string(buffer, std::min(static_cast<size_t>(result), sizeof(buffer) - 1));

}

// Message was truncated - allocate larger buffer

// (This should be rare for typical log messages)

std::vector<char> large_buffer(result + 1);

va_copy(args_copy, args);

// Use std::vsnprintf with explicit size for safety (C++11 standard)

// This is the recommended safe alternative to vsprintf

// DevSkim: ignore DS185832 - std::vsnprintf with size is safe

int final_result = std::vsnprintf(large_buffer.data(), large_buffer.size(), format, args_copy);

va_end(args_copy);

// Ensure null termination even if formatting fails

if (final_result < 0 || final_result >= static_cast<int>(large_buffer.size())) {

large_buffer[large_buffer.size() - 1] = '\0';

}

return std::string(large_buffer.data());

// Fast level check (should already be done by macro, but double-check)

if (!isLoggable(level)) {

return;

}

// Check if initialized

if (!initialized_ || !cached_logger_) {

return;

}

// Format the message

va_list args;

va_start(args, format);

std::string message = formatMessage(format, args);

va_end(args);

// Extract filename from path

const char* filename = extractFilename(file);

// Format the complete log message with [DDBC] prefix for CSV parsing

// File and line number are handled by the Python formatter (in Location

// column) Use std::ostringstream for type-safe, buffer-overflow-free string

// building

std::ostringstream oss;

oss << "[DDBC] " << message;

std::string complete_message = oss.str();

// Warn if message exceeds reasonable size (critical for troubleshooting)

constexpr size_t MAX_LOG_SIZE = 4095; // Keep same limit for consistency

if (complete_message.size() > MAX_LOG_SIZE) {

// Use stderr to notify about truncation (logging may be the truncated

// call itself)

std::cerr << "[MSSQL-Python] Warning: Log message truncated from "

<< complete_message.size() << " bytes to " << MAX_LOG_SIZE << " bytes at " << file

<< ":" << line << std::endl;

complete_message.resize(MAX_LOG_SIZE);

}

// Lock for Python call (minimize critical section)

std::lock_guard<std::mutex> lock(mutex_);

try {

// Acquire GIL for Python API call

py::gil_scoped_acquire gil;

// Get the logger object

py::handle logger_handle(cached_logger_);

py::object logger_obj = py::reinterpret_borrow<py::object>(logger_handle);

// Get the underlying Python logger to create LogRecord with correct

// filename/lineno

py::object py_logger = logger_obj.attr("_logger");

// Call makeRecord to create a LogRecord with correct attributes

py::object record =

py_logger.attr("makeRecord")(py_logger.attr("name"), // name

py::int_(level), // level

py::str(filename), // pathname (just filename)

py::int_(line), // lineno

py::str(complete_message.c_str()), // msg

py::tuple(), // args

py::none(), // exc_info

py::str(filename), // func (use filename as func name)

py::none() // extra

);

// Call handle() to process the record through filters and handlers

py_logger.attr("handle")(record);

} catch (const py::error_already_set& e) {

// Python error during logging - ignore to prevent cascading failures

// (Logging errors should not crash the application)

(void)e; // Suppress unused variable warning

} catch (const std::exception& e) {

// Standard C++ exception - ignore

(void)e;

} catch (...) {

// Catch-all for unknown exceptions (non-standard exceptions, corrupted

// state, etc.) Logging must NEVER crash the application

}