feat(discovery): Rust-to-Go logging bridge for libdd_discovery

Author: martavicentenavarro

pkg/discovery/module/impl_services_rust_init_linux.go

@@ -0,0 +1,31 @@
+// Unless explicitly stated otherwise all files in this repository are licensed
+// under the Apache License Version 2.0.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2025-present Datadog, Inc.
+
+//go:build dd_discovery_rust && cgo
+
+package module
+
+/*
+#cgo CFLAGS:  -I${SRCDIR}/rust/include
+#cgo LDFLAGS: -L${SRCDIR}/rust -L${SRCDIR}/rust/target/release -ldd_discovery
+
+#include "dd_discovery.h"
+
+extern void goDiscoveryLogCallback(uint32_t level, const char* msg, size_t msg_len);
+
+// cgo does not allow passing the address of an exported Go function (goDiscoveryLogCallback)
+// directly as a function-pointer argument in the cgo preamble.  This thin C wrapper returns
+// the pointer so we can pass it to dd_discovery_init_logger without violating that rule.
+static dd_log_fn getGoLogCallback(void) {
+    return goDiscoveryLogCallback;
+}
+*/
+import "C"
+
+func init() {
+	// All Rust log records are forwarded to the Go logger, which applies its own
+	// level filter.  See dd_discovery_init_logger in ffi.rs for details.
+	C.dd_discovery_init_logger(C.getGoLogCallback())
+}

pkg/discovery/module/impl_services_rust_logger_linux.go

@@ -0,0 +1,43 @@
+// Unless explicitly stated otherwise all files in this repository are licensed
+// under the Apache License Version 2.0.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2025-present Datadog, Inc.
+
+//go:build dd_discovery_rust && cgo
+
+package module
+
+/*
+#cgo CFLAGS: -I${SRCDIR}/rust/include
+#include "dd_discovery.h"
+*/
+import "C"
+
+import (
+	"math"
+
+	"github.com/DataDog/datadog-agent/pkg/util/log"
+)
+
+//export goDiscoveryLogCallback
+func goDiscoveryLogCallback(level C.uint32_t, msg *C.char, msgLen C.size_t) {
+	// Reject nil pointers, empty messages (nothing useful to log), and messages
+	// larger than MaxInt32 to prevent overflow when casting msgLen to C.int below.
+	if msg == nil || msgLen == 0 || msgLen > math.MaxInt32 {
+		return
+	}
+	message := C.GoStringN(msg, C.int(msgLen))
+	// Level mapping mirrors dd_log_fn in dd_discovery.h: 1=Error, 2=Warn, 3=Info, 4=Debug, 5+=Trace.
+	switch level {
+	case 1:
+		_ = log.Errorf("[dd_discovery] %s", message)
+	case 2:
+		_ = log.Warnf("[dd_discovery] %s", message)
+	case 3:
+		log.Infof("[dd_discovery] %s", message)
+	case 4:
+		log.Debugf("[dd_discovery] %s", message)
+	default:
+		log.Tracef("[dd_discovery] %s", message)
+	}
+}

pkg/discovery/module/rust/cbindgen.toml

@@ -29,6 +29,7 @@ include = [
     "dd_tracer_metadata_slice",
     "dd_service",
     "dd_discovery_result",
+    "dd_log_fn",
 ]
 
 [fn]

pkg/discovery/module/rust/include/dd_discovery.h

@@ -12,6 +12,17 @@
 #include <stddef.h>
 #include <stdint.h>
 
+/**
+ * Callback type used to forward Rust log records to the Go logging subsystem.
+ *
+ * Parameters:
+ * - `level`: severity — 1=Error, 2=Warn, 3=Info, 4=Debug, 5=Trace.
+ * - `msg` / `msg_len`: UTF-8 log message (NOT NUL-terminated).
+ *
+ * The pointer is only valid for the duration of the call; do not retain it.
+ */
+typedef void (*dd_log_fn)(uint32_t level, const char *msg, size_t msg_len);
+
 /**
  * Length-delimited byte string — avoids NUL-termination so the Go caller
  * can use `C.GoStringN(data, len)` directly without `strlen`.
@@ -89,6 +100,19 @@ struct dd_discovery_result {
   size_t gpu_pids_len;
 };
 
+/**
+ * Register a Go logging callback. Idempotent: only the first call has effect;
+ * subsequent calls (e.g. from racing goroutines at start-up) are ignored.
+ *
+ * All log levels are forwarded to the callback; the Go side applies its own
+ * level filter so no records are emitted above the configured level.
+ *
+ * # Safety
+ * `callback` must be a valid function pointer that remains valid for the
+ * lifetime of the process.
+ */
+void dd_discovery_init_logger(dd_log_fn callback);
+
 /**
  * Run service discovery and return a heap-allocated result.
  *

pkg/discovery/module/rust/src/ffi.rs

@@ -290,6 +290,72 @@ fn services_response_to_result(resp: ServicesResponse) -> dd_discovery_result {
     }
 }
 
+// ---------------------------------------------------------------------------
+// Logger bridge
+// ---------------------------------------------------------------------------
+
+/// Callback type used to forward Rust log records to the Go logging subsystem.
+///
+/// Parameters:
+/// - `level`: severity — 1=Error, 2=Warn, 3=Info, 4=Debug, 5=Trace.
+/// - `msg` / `msg_len`: UTF-8 log message (NOT NUL-terminated).
+///
+/// The pointer is only valid for the duration of the call; do not retain it.
+pub type dd_log_fn = unsafe extern "C" fn(level: u32, msg: *const c_char, msg_len: usize);
+
+/// Stores the Go log callback set via `dd_discovery_init_logger`. Written once.
+static LOGGER_CALLBACK: std::sync::OnceLock<dd_log_fn> = std::sync::OnceLock::new();
+
+/// Logger backend that forwards records to the registered Go callback.
+struct GoLogger;
+
+impl log::Log for GoLogger {
+    fn enabled(&self, _metadata: &log::Metadata) -> bool {
+        true // All records pass through; Go-side filtering applies.
+    }
+
+    fn log(&self, record: &log::Record) {
+        let Some(&callback) = LOGGER_CALLBACK.get() else {
+            return;
+        };
+        let level: u32 = match record.level() {
+            log::Level::Error => 1,
+            log::Level::Warn => 2,
+            log::Level::Info => 3,
+            log::Level::Debug => 4,
+            log::Level::Trace => 5,
+        };
+        let message = record.args().to_string();
+        // SAFETY: `callback` was registered by the Go runtime and is valid for
+        // the process lifetime. `message` is live for the duration of this call.
+        unsafe { callback(level, message.as_ptr() as *const c_char, message.len()) };
+    }
+
+    fn flush(&self) {}
+}
+
+static GO_LOGGER: GoLogger = GoLogger;
+
+/// Register a Go logging callback. Idempotent: only the first call has effect;
+/// subsequent calls (e.g. from racing goroutines at start-up) are ignored.
+///
+/// All log levels are forwarded to the callback; the Go side applies its own
+/// level filter so no records are emitted above the configured level.
+///
+/// # Safety
+/// `callback` must be a valid function pointer that remains valid for the
+/// lifetime of the process.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn dd_discovery_init_logger(callback: dd_log_fn) {
+    if LOGGER_CALLBACK.set(callback).is_err() {
+        return;
+    }
+    // `set_logger` returns Err if another logger was already registered.
+    if log::set_logger(&GO_LOGGER).is_ok() {
+        log::set_max_level(log::LevelFilter::Trace);
+    }
+}
+
 // ---------------------------------------------------------------------------
 // Exported C ABI functions
 // ---------------------------------------------------------------------------