Add ddog_trace_exporter_send_trace_chunks FFI function

Wire `TracerTraceChunks` to the existing `TraceExporter::send_trace_chunks`
method through a new C-callable function. The chunks are consumed on
call and the agent response is optionally written to an out-parameter.

This completes the span-building FFI surface: callers can now construct
spans via `ddog_tracer_span_*`, group them via
`ddog_tracer_trace_chunks_*`, and send them via
`ddog_trace_exporter_send_trace_chunks` — all without serializing to
msgpack on the caller side.

The `TraceExporter` type alias in `trace_exporter.rs` is widened to
`pub(crate)` to allow cross-module access.

Author: lloeki

libdd-data-pipeline-ffi/src/trace_exporter.rs

@@ -14,7 +14,7 @@ use libdd_data_pipeline::trace_exporter::{
     TraceExporterInputFormat, TraceExporterOutputFormat,
 };
 
-type TraceExporter = GenericTraceExporter<NativeCapabilities>;
+pub(crate) type TraceExporter = GenericTraceExporter<NativeCapabilities>;
 
 use libdd_shared_runtime::SharedRuntime;
 use std::{ptr::NonNull, sync::Arc, time::Duration};

libdd-data-pipeline-ffi/src/tracer.rs

@@ -11,6 +11,8 @@
 //!   into trace chunks ready for export.
 
 use crate::error::{ExporterError, ExporterErrorCode as ErrorCode};
+use crate::response::ExporterResponse;
+use crate::trace_exporter::TraceExporter;
 use crate::{catch_panic, gen_error};
 use libdd_common_ffi::slice::AsBytes;
 use libdd_common_ffi::CharSlice;
@@ -294,6 +296,51 @@ pub unsafe extern "C" fn ddog_tracer_trace_chunks_push_span(
     )
 }
 
+// ---------------------------------------------------------------------------
+// Send trace chunks
+// ---------------------------------------------------------------------------
+
+/// Send trace chunks through a [`TraceExporter`], consuming the chunks.
+///
+/// This calls `TraceExporter::send_trace_chunks` which processes stats,
+/// serializes in the configured output format, and sends to the agent
+/// with retry logic.
+///
+/// On success, if `response_out` is non-null, a heap-allocated
+/// [`ExporterResponse`] is written there.  The caller owns it and must
+/// free it with `ddog_trace_exporter_response_free`.
+///
+/// # Safety
+///
+/// * `exporter` must be a valid `TraceExporter` pointer.
+/// * `chunks` is consumed and must not be used after this call.
+/// * If `response_out` is non-null it must point to valid writable
+///   memory for a `Box<ExporterResponse>`.
+#[no_mangle]
+pub unsafe extern "C" fn ddog_trace_exporter_send_trace_chunks(
+    exporter: Option<&TraceExporter>,
+    chunks: Box<TracerTraceChunks>,
+    response_out: Option<NonNull<Box<ExporterResponse>>>,
+) -> Option<Box<ExporterError>> {
+    let exporter = match exporter {
+        Some(e) => e,
+        None => return gen_error!(ErrorCode::InvalidArgument),
+    };
+
+    catch_panic!(
+        match exporter.send_trace_chunks(chunks.0) {
+            Ok(resp) => {
+                if let Some(out) = response_out {
+                    out.as_ptr().write(Box::new(ExporterResponse::from(resp)));
+                }
+                None
+            }
+            Err(e) => Some(Box::new(ExporterError::from(e))),
+        },
+        gen_error!(ErrorCode::Panic)
+    )
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;