datadog 2.40.0 → 2.41.0

data/ext/libdatadog_api/trace_exporter.c

@@ -1,6 +1,16 @@
 #include <ruby.h>
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+#include <ruby/encoding.h>
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
 #include <ruby/thread.h>
+#include <limits.h>
 #include <stdbool.h>
+#include <string.h>
 #include <datadog/data-pipeline.h>
 #include <datadog/shared-runtime.h>
 
@@ -12,8 +22,12 @@
  * Forward declarations
  * ======================================================================== */
 
-/* Internal: convert a Ruby Span to a Rust ddog_TracerSpan* (caller owns) */
-static ddog_TracerSpan *convert_ruby_span_to_rust(VALUE span);
+typedef struct {
+  ddog_TracerSpan *span;
+} raw_span_owner;
+
+/* Internal: convert a Ruby Span into the supplied raw Rust span owner */
+static void convert_ruby_span_to_rust(VALUE span, raw_span_owner *owner);
 
 /* TracerSpan methods */
 static VALUE _native_from_span(VALUE klass, VALUE span);
@@ -51,9 +65,15 @@ static ID at_duration_id;
 static ID at_status_id;
 static ID at_meta_id;
 static ID at_metrics_id;
+static ID at_metastruct_id;
 
 /* Method IDs for time / integer operations */
 static ID id_duration_method;
+static ID id_to_h;
+static ID id_negative_p;
+
+/* Resolved lazily because AppSec may load after this extension. */
+static VALUE serializable_backtrace_class = Qnil;
 
 /* Response class (loaded from Ruby) */
 static VALUE response_class       = Qnil;
@@ -101,7 +121,7 @@ static void tracer_span_dfree(void *ptr) {
  */
 typedef struct {
   ddog_TraceExporter       *exporter;
-  const ddog_SharedRuntime *runtime;
+  const ddog_ForkSafeRuntime *runtime;
 } trace_exporter_t;
 
 static const rb_data_type_t trace_exporter_typed_data = {
@@ -305,31 +325,320 @@ static int metrics_iter_cb(VALUE key, VALUE value, VALUE arg) {
   return ST_CONTINUE;
 }
 
-/*
- * Emit a warning while a raw ddog_TracerSpan is held.
- *
- * log_warning calls into Ruby (Datadog.logger.warn), which can raise or be
- * interrupted. A non-local exit here would leak rust_span (it is not yet
- * owned by any chunk), so run the call under rb_protect and, on a pending
- * jump, free rust_span before re-raising with rb_jump_tag.
- */
-static void log_warning_owning_span(ddog_TracerSpan *rust_span, VALUE message) {
+typedef struct {
+  ddog_TracerValueToken *tokens;
+  size_t len;
+  size_t capacity;
+  st_table *active;
+  uint8_t **scratch;
+  size_t scratch_len;
+  size_t scratch_capacity;
+} structured_value_ctx;
+
+static ddog_TracerValueToken *append_structured_value_token(
+    structured_value_ctx *ctx, uint8_t kind) {
+  if (ctx->len == ctx->capacity) {
+    size_t capacity = ctx->capacity == 0 ? 16 : ctx->capacity * 2;
+    if (capacity < ctx->capacity || capacity > SIZE_MAX / sizeof(*ctx->tokens)) {
+      rb_raise(rb_eNoMemError, "meta_struct token buffer is too large");
+    }
+    REALLOC_N(ctx->tokens, ddog_TracerValueToken, capacity);
+    ctx->capacity = capacity;
+  }
+
+  ddog_TracerValueToken *token = &ctx->tokens[ctx->len++];
+  *token = (ddog_TracerValueToken){0};
+  token->kind = kind;
+  return token;
+}
+
+static const uint8_t *copy_structured_value_bytes(
+    structured_value_ctx *ctx, VALUE string, size_t len) {
+  if (len == 0) return (const uint8_t *)"";
+
+  if (ctx->scratch_len == ctx->scratch_capacity) {
+    size_t capacity = ctx->scratch_capacity == 0 ? 8 : ctx->scratch_capacity * 2;
+    if (capacity < ctx->scratch_capacity || capacity > SIZE_MAX / sizeof(*ctx->scratch)) {
+      rb_raise(rb_eNoMemError, "meta_struct scratch buffer is too large");
+    }
+    REALLOC_N(ctx->scratch, uint8_t *, capacity);
+    ctx->scratch_capacity = capacity;
+  }
+
+  uint8_t *copy = ruby_xmalloc(len);
+  ctx->scratch[ctx->scratch_len++] = copy;
+  /* ruby_xmalloc may trigger GC, so retrieve the Ruby buffer only after it
+   * returns and do not call Ruby again before the copy completes. */
+  memcpy(copy, RSTRING_PTR(string), len);
+  return copy;
+}
+
+static void free_structured_value_ctx(structured_value_ctx *ctx) {
+  if (ctx->active != NULL) st_free_table(ctx->active);
+  for (size_t i = 0; i < ctx->scratch_len; i++) {
+    ruby_xfree(ctx->scratch[i]);
+  }
+  ruby_xfree(ctx->scratch);
+  ruby_xfree(ctx->tokens);
+}
+
+static VALUE resolve_serializable_backtrace_class(void) {
+  if (serializable_backtrace_class != Qnil) return serializable_backtrace_class;
+
+  ID datadog_id = rb_intern("Datadog");
+  ID appsec_id = rb_intern("AppSec");
+  ID actions_handler_id = rb_intern("ActionsHandler");
+  ID backtrace_id = rb_intern("SerializableBacktrace");
+  if (!rb_const_defined(rb_cObject, datadog_id)) return Qnil;
+  VALUE datadog = rb_const_get(rb_cObject, datadog_id);
+  if (!rb_const_defined(datadog, appsec_id)) return Qnil;
+  VALUE appsec = rb_const_get(datadog, appsec_id);
+  if (!rb_const_defined(appsec, actions_handler_id)) return Qnil;
+  VALUE actions_handler = rb_const_get(appsec, actions_handler_id);
+  if (!rb_const_defined(actions_handler, backtrace_id)) return Qnil;
+
+  serializable_backtrace_class = rb_const_get(actions_handler, backtrace_id);
+  rb_global_variable(&serializable_backtrace_class);
+  return serializable_backtrace_class;
+}
+
+static void append_structured_value(VALUE value, unsigned int depth,
+                                    structured_value_ctx *ctx);
+
+typedef struct {
+  structured_value_ctx *ctx;
+  unsigned int depth;
+} structured_hash_ctx;
+
+static int append_structured_hash_entry(VALUE key, VALUE value, VALUE arg) {
+  structured_hash_ctx *hash_ctx = (structured_hash_ctx *)arg;
+  append_structured_value(key, hash_ctx->depth, hash_ctx->ctx);
+  append_structured_value(value, hash_ctx->depth, hash_ctx->ctx);
+  return ST_CONTINUE;
+}
+
+static VALUE utf8_string(VALUE value) {
+  VALUE string = RB_TYPE_P(value, T_SYMBOL) ? rb_sym2str(value) : value;
+  string = rb_str_export_to_enc(string, rb_utf8_encoding());
+  if (rb_enc_str_coderange(string) == ENC_CODERANGE_BROKEN) {
+    rb_raise(rb_eEncodingError, "meta_struct string is not valid UTF-8");
+  }
+  return string;
+}
+
+static void append_structured_value(VALUE value, unsigned int depth,
+                                    structured_value_ctx *ctx) {
+  if (value == Qnil) {
+    append_structured_value_token(ctx, DDOG_TRACER_VALUE_NIL);
+    return;
+  }
+  if (value == Qtrue || value == Qfalse) {
+    ddog_TracerValueToken *token =
+        append_structured_value_token(ctx, DDOG_TRACER_VALUE_BOOL);
+    token->bool_value = value == Qtrue ? 1 : 0;
+    return;
+  }
+  if (RB_TYPE_P(value, T_FIXNUM) || RB_TYPE_P(value, T_BIGNUM)) {
+    if (RTEST(rb_funcall(value, id_negative_p, 0))) {
+      ddog_TracerValueToken *token =
+          append_structured_value_token(ctx, DDOG_TRACER_VALUE_I64);
+      token->i64_value = NUM2LL(value);
+    } else {
+      ddog_TracerValueToken *token =
+          append_structured_value_token(ctx, DDOG_TRACER_VALUE_U64);
+      token->u64_value = NUM2ULL(value);
+    }
+    return;
+  }
+  if (RB_TYPE_P(value, T_FLOAT)) {
+    ddog_TracerValueToken *token =
+        append_structured_value_token(ctx, DDOG_TRACER_VALUE_F64);
+    token->f64_value = RFLOAT_VALUE(value);
+    return;
+  }
+  if (RB_TYPE_P(value, T_STRING) || RB_TYPE_P(value, T_SYMBOL)) {
+    bool binary = RB_TYPE_P(value, T_STRING) &&
+        rb_enc_get_index(value) == rb_ascii8bit_encindex();
+    VALUE string = binary ? value : utf8_string(value);
+    size_t len = (size_t)RSTRING_LEN(string);
+    ddog_TracerValueToken *token = append_structured_value_token(
+        ctx, binary ? DDOG_TRACER_VALUE_BINARY : DDOG_TRACER_VALUE_STRING);
+    token->bytes = (ddog_ByteSlice){
+      .ptr = copy_structured_value_bytes(ctx, string, len),
+      .len = len,
+    };
+    return;
+  }
+
+  VALUE backtrace_class = resolve_serializable_backtrace_class();
+  if (backtrace_class != Qnil && rb_obj_is_kind_of(value, backtrace_class)) {
+    append_structured_value(rb_funcall(value, id_to_h, 0), depth, ctx);
+    return;
+  }
+
+  if (!RB_TYPE_P(value, T_ARRAY) && !RB_TYPE_P(value, T_HASH)) {
+    rb_raise(rb_eTypeError, "unsupported meta_struct value type: %s",
+             rb_obj_classname(value));
+  }
+  if (depth >= 64) {
+    rb_raise(rb_eArgError, "meta_struct value exceeds maximum depth of 64");
+  }
+  if (st_lookup(ctx->active, (st_data_t)value, NULL)) {
+    rb_raise(rb_eArgError, "meta_struct value contains a cycle");
+  }
+  st_insert(ctx->active, (st_data_t)value, 1);
+
+  size_t length = RB_TYPE_P(value, T_ARRAY) ? (size_t)RARRAY_LEN(value) : RHASH_SIZE(value);
+  if (length > UINT32_MAX) {
+    rb_raise(rb_eArgError, "meta_struct container exceeds u32::MAX entries");
+  }
+  ddog_TracerValueToken *token = append_structured_value_token(
+      ctx, RB_TYPE_P(value, T_ARRAY) ? DDOG_TRACER_VALUE_ARRAY : DDOG_TRACER_VALUE_MAP);
+  token->child_count = (uint32_t)length;
+
+  if (RB_TYPE_P(value, T_ARRAY)) {
+    for (size_t i = 0; i < length; i++) {
+      append_structured_value(rb_ary_entry(value, (long)i), depth + 1, ctx);
+    }
+  } else {
+    structured_hash_ctx hash_ctx = {.ctx = ctx, .depth = depth + 1};
+    rb_hash_foreach(value, append_structured_hash_entry, (VALUE)&hash_ctx);
+  }
+  st_delete(ctx->active, (st_data_t *)&value, NULL);
+}
+
+typedef struct {
+  const uint8_t *key;
+  size_t key_len;
+  structured_value_ctx value;
+} prepared_metastruct_entry;
+
+typedef struct {
+  prepared_metastruct_entry *entries;
+  size_t len;
+  size_t capacity;
+} prepared_metastruct;
+
+static void free_prepared_metastruct(prepared_metastruct *prepared) {
+  for (size_t i = 0; i < prepared->len; i++) {
+    free_structured_value_ctx(&prepared->entries[i].value);
+  }
+  ruby_xfree(prepared->entries);
+  *prepared = (prepared_metastruct){0};
+}
+
+static prepared_metastruct_entry *append_prepared_metastruct_entry(
+    prepared_metastruct *prepared) {
+  if (prepared->len == prepared->capacity) {
+    size_t capacity = prepared->capacity == 0 ? 4 : prepared->capacity * 2;
+    if (capacity < prepared->capacity || capacity > SIZE_MAX / sizeof(*prepared->entries)) {
+      rb_raise(rb_eNoMemError, "meta_struct entry buffer is too large");
+    }
+    REALLOC_N(prepared->entries, prepared_metastruct_entry, capacity);
+    prepared->capacity = capacity;
+  }
+
+  prepared_metastruct_entry *entry = &prepared->entries[prepared->len++];
+  *entry = (prepared_metastruct_entry){0};
+  entry->value.active = st_init_numtable();
+  return entry;
+}
+
+typedef struct {
+  prepared_metastruct *prepared;
+  long skipped;
+} metastruct_prepare_ctx;
+
+static int prepare_metastruct_iter_cb(VALUE key, VALUE value, VALUE arg) {
+  metastruct_prepare_ctx *ctx = (metastruct_prepare_ctx *)arg;
+
+  /* The agent meta_struct contract requires string keys. Accept symbols as a
+   * Ruby convenience, but do not encode other key types differently from the
+   * native tracer implementations. */
+  if (RB_TYPE_P(key, T_SYMBOL)) {
+    key = rb_sym2str(key);
+  } else if (!RB_TYPE_P(key, T_STRING)) {
+    ctx->skipped++;
+    return ST_CONTINUE;
+  }
+
+  key = utf8_string(key);
+  prepared_metastruct_entry *entry =
+      append_prepared_metastruct_entry(ctx->prepared);
+  entry->key_len = (size_t)RSTRING_LEN(key);
+  entry->key = copy_structured_value_bytes(
+      &entry->value, key, entry->key_len);
+  append_structured_value(value, 0, &entry->value);
+
+  return ST_CONTINUE;
+}
+
+typedef struct {
+  VALUE span;
+  prepared_metastruct *prepared;
+} prepare_metastruct_call;
+
+static VALUE prepare_metastruct_body(VALUE arg) {
+  prepare_metastruct_call *call = (prepare_metastruct_call *)arg;
+  VALUE metastruct = rb_ivar_get(call->span, at_metastruct_id);
+  if (metastruct == Qnil) return Qnil;
+
+  VALUE values = rb_funcall(metastruct, id_to_h, 0);
+  Check_Type(values, T_HASH);
+  if (RHASH_SIZE(values) == 0) return Qnil;
+
+  metastruct_prepare_ctx ctx = {.prepared = call->prepared, .skipped = 0};
+  rb_hash_foreach(values, prepare_metastruct_iter_cb, (VALUE)&ctx);
+  if (ctx.skipped > 0) {
+    log_warning(rb_sprintf(
+        "Native trace exporter: skipped %ld meta_struct entries with non-string keys",
+        ctx.skipped));
+  }
+  return Qnil;
+}
+
+/* Prepare stable token storage before allocating the Rust span. Any Ruby
+ * callback or non-local exit is contained here, where deterministic cleanup
+ * does not need to account for Rust span ownership. */
+static void prepare_metastruct(VALUE span, prepared_metastruct *prepared) {
+  prepare_metastruct_call call = {.span = span, .prepared = prepared};
   int state = 0;
-  rb_protect(log_warning, message, &state);
+  rb_protect(prepare_metastruct_body, (VALUE)&call, &state);
   if (state) {
-    ddog_tracer_span_free(rust_span);
+    free_prepared_metastruct(prepared);
     rb_jump_tag(state);
   }
 }
 
+static void set_prepared_metastruct(
+    ddog_TracerSpan *span, prepared_metastruct *prepared) {
+  for (size_t i = 0; i < prepared->len; i++) {
+    prepared_metastruct_entry *entry = &prepared->entries[i];
+    ddog_Slice_TracerValueToken tokens = {
+      .ptr = entry->value.tokens,
+      .len = entry->value.len,
+    };
+    ddog_CharSlice key = {
+      .ptr = (const char *)entry->key,
+      .len = entry->key_len,
+    };
+    ddog_TraceExporterError *err =
+        ddog_tracer_span_set_meta_struct(span, key, tokens);
+    if (err != NULL) {
+      free_prepared_metastruct(prepared);
+      check_exporter_error("Failed to set span meta_struct", err);
+    }
+  }
+  free_prepared_metastruct(prepared);
+}
 /* ========================================================================
- * Internal: convert a Ruby Span -> ddog_TracerSpan*
+ * Internal: convert a Ruby Span into a raw_span_owner
  *
- * The returned pointer is Rust-heap-allocated.  Ownership is transferred
- * to the caller (either wrap it in TypedData or push it into trace chunks).
+ * The caller keeps its ensure handler active until the span is either wrapped
+ * in TypedData or consumed by a trace chunk.
  * ======================================================================== */
 
-static ddog_TracerSpan *convert_ruby_span_to_rust(VALUE span) {
+static void convert_ruby_span_to_rust(VALUE span, raw_span_owner *owner) {
   /* 1. Read Ruby ivars */
   VALUE rb_name      = rb_ivar_get(span, at_name_id);
   VALUE rb_service   = rb_ivar_get(span, at_service_id);
@@ -340,12 +649,12 @@ static ddog_TracerSpan *convert_ruby_span_to_rust(VALUE span) {
   VALUE rb_trace_id  = rb_ivar_get(span, at_trace_id_id);
   VALUE rb_status    = rb_ivar_get(span, at_status_id);
 
-  /* 2. Convert scalars */
-  ddog_CharSlice name_s     = char_slice_from_ruby_string(rb_name);
-  ddog_CharSlice service_s  = nullable_char_slice(rb_service);
-  ddog_CharSlice resource_s = nullable_char_slice(rb_resource);
-  ddog_CharSlice type_s     = nullable_char_slice(rb_type);
+  ENFORCE_TYPE(rb_name, T_STRING);
+  if (rb_service != Qnil) ENFORCE_TYPE(rb_service, T_STRING);
+  if (rb_resource != Qnil) ENFORCE_TYPE(rb_resource, T_STRING);
+  if (rb_type != Qnil) ENFORCE_TYPE(rb_type, T_STRING);
 
+  /* 2. Convert scalars that may call Ruby. */
   uint64_t span_id   = NUM2ULL(rb_span_id);
   uint64_t parent_id = NUM2ULL(rb_parent_id);
   int32_t  error_val = NUM2INT(rb_status);
@@ -369,7 +678,18 @@ static ddog_TracerSpan *convert_ruby_span_to_rust(VALUE span) {
     if (dur != Qnil) duration_ns = (int64_t)(NUM2DBL(dur) * 1e9);
   }
 
-  /* 3. Create Rust span */
+  /* Structured-value normalisation can call Ruby code. Snapshot it before
+   * borrowing scalar string pointers or allocating the Rust span. */
+  prepared_metastruct metastruct = {0};
+  prepare_metastruct(span, &metastruct);
+
+  /* No Ruby calls may occur between borrowing these pointers and span_new. */
+  ddog_CharSlice name_s     = char_slice_from_ruby_string(rb_name);
+  ddog_CharSlice service_s  = nullable_char_slice(rb_service);
+  ddog_CharSlice resource_s = nullable_char_slice(rb_resource);
+  ddog_CharSlice type_s     = nullable_char_slice(rb_type);
+
+  /* 3. Create Rust span and immediately consume the stable prepared values. */
   ddog_TracerSpanFields fields = {
     .service        = service_s,
     .name           = name_s,
@@ -384,22 +704,20 @@ static ddog_TracerSpan *convert_ruby_span_to_rust(VALUE span) {
     .error          = error_val,
   };
 
-  ddog_TracerSpan *rust_span = NULL;
-  ddog_TraceExporterError *err = ddog_tracer_span_new(&rust_span, &fields);
+  ddog_TraceExporterError *err = ddog_tracer_span_new(&owner->span, &fields);
+  if (err != NULL) free_prepared_metastruct(&metastruct);
   check_exporter_error("Failed to create TracerSpan", err);
+  set_prepared_metastruct(owner->span, &metastruct);
 
   /* 4. Populate meta and metrics */
-  hash_iter_ctx ctx = {.span = rust_span, .error = NULL, .skipped = 0};
+  hash_iter_ctx ctx = {.span = owner->span, .error = NULL, .skipped = 0};
 
   VALUE rb_meta = rb_ivar_get(span, at_meta_id);
   if (RB_TYPE_P(rb_meta, T_HASH) && RHASH_SIZE(rb_meta) > 0) {
     rb_hash_foreach(rb_meta, meta_iter_cb, (VALUE)&ctx);
-    if (ctx.error != NULL) {
-      ddog_tracer_span_free(rust_span);
-      check_exporter_error("Failed to set span meta", ctx.error);
-    }
+    check_exporter_error("Failed to set span meta", ctx.error);
     if (ctx.skipped > 0) {
-      log_warning_owning_span(rust_span, rb_sprintf(
+      log_warning(rb_sprintf(
           "Native trace exporter: skipped %ld non-string meta entries",
           ctx.skipped));
       ctx.skipped = 0;
@@ -409,28 +727,49 @@ static ddog_TracerSpan *convert_ruby_span_to_rust(VALUE span) {
   VALUE rb_metrics = rb_ivar_get(span, at_metrics_id);
   if (RB_TYPE_P(rb_metrics, T_HASH) && RHASH_SIZE(rb_metrics) > 0) {
     rb_hash_foreach(rb_metrics, metrics_iter_cb, (VALUE)&ctx);
-    if (ctx.error != NULL) {
-      ddog_tracer_span_free(rust_span);
-      check_exporter_error("Failed to set span metric", ctx.error);
-    }
+    check_exporter_error("Failed to set span metric", ctx.error);
     if (ctx.skipped > 0) {
-      log_warning_owning_span(rust_span, rb_sprintf(
+      log_warning(rb_sprintf(
           "Native trace exporter: skipped %ld non-numeric metrics entries",
           ctx.skipped));
     }
   }
 
-  return rust_span;
+}
+
+static VALUE free_raw_span(VALUE arg) {
+  raw_span_owner *owner = (raw_span_owner *)arg;
+  if (owner->span != NULL) {
+    ddog_tracer_span_free(owner->span);
+    owner->span = NULL;
+  }
+  return Qnil;
 }
 
 /* ========================================================================
  * TracerSpan._native_from_span
  * ======================================================================== */
 
+typedef struct {
+  VALUE span;
+  raw_span_owner owner;
+} wrap_span_ctx;
+
+static VALUE convert_and_wrap_span(VALUE arg) {
+  wrap_span_ctx *ctx = (wrap_span_ctx *)arg;
+  convert_ruby_span_to_rust(ctx->span, &ctx->owner);
+
+  VALUE wrapped = TypedData_Wrap_Struct(
+      tracer_span_class, &tracer_span_typed_data, ctx->owner.span);
+  ctx->owner.span = NULL;
+  return wrapped;
+}
+
 static VALUE _native_from_span(DDTRACE_UNUSED VALUE klass, VALUE span) {
-  ddog_TracerSpan *rust_span = convert_ruby_span_to_rust(span);
-  return TypedData_Wrap_Struct(tracer_span_class, &tracer_span_typed_data,
-                               rust_span);
+  wrap_span_ctx ctx = {.span = span, .owner = {.span = NULL}};
+  return rb_ensure(
+      convert_and_wrap_span, (VALUE)&ctx,
+      free_raw_span, (VALUE)&ctx.owner);
 }
 
 /* ========================================================================
@@ -516,17 +855,27 @@ static VALUE _native_exporter_new(
   if (rb_service              != Qnil) ENFORCE_TYPE(rb_service,              T_STRING);
   if (rb_version              != Qnil) ENFORCE_TYPE(rb_version,              T_STRING);
 
-  /* Phase 2: create config (cleanup on error) */
+  /* Phase 2: configure before creating the separately-owned runtime. */
   ddog_TraceExporterConfig *config = NULL;
   ddog_trace_exporter_config_new(&config);
 
+  set_config_field(config, ddog_trace_exporter_config_set_url,               rb_url,                   "url");
+  set_config_field(config, ddog_trace_exporter_config_set_tracer_version,    rb_tracer_version,        "tracer_version");
+  set_config_field(config, ddog_trace_exporter_config_set_language,          rb_language,              "language");
+  set_config_field(config, ddog_trace_exporter_config_set_lang_version,      rb_language_version,      "language_version");
+  set_config_field(config, ddog_trace_exporter_config_set_lang_interpreter,  rb_language_interpreter,  "language_interpreter");
+  set_config_field(config, ddog_trace_exporter_config_set_hostname,          rb_hostname,              "hostname");
+  set_config_field(config, ddog_trace_exporter_config_set_env,               rb_env,                   "env");
+  set_config_field(config, ddog_trace_exporter_config_set_service,           rb_service,               "service");
+  set_config_field(config, ddog_trace_exporter_config_set_version,           rb_version,               "version");
+
   /*
    * Create a SharedRuntime and attach it to the config before building the
    * exporter.  The exporter holds a clone of the runtime's Arc; we keep our
    * own handle in the wrapper to drive fork-safety hooks and to free it when
    * the exporter is collected.
    */
-  const ddog_SharedRuntime *runtime = NULL;
+  const ddog_ForkSafeRuntime *runtime = NULL;
   ddog_SharedRuntimeFFIError *rt_err = ddog_shared_runtime_new(&runtime);
   if (rt_err != NULL) {
     ddog_trace_exporter_config_free(config);
@@ -534,13 +883,13 @@ static VALUE _native_exporter_new(
   }
 
   /*
-   * Const asymmetry: ddog_shared_runtime_new yields a `const ddog_SharedRuntime *`
+   * Const asymmetry: ddog_shared_runtime_new yields a `const ddog_ForkSafeRuntime *`
    * but the setter takes a non-const pointer.  The setter only clones the Arc,
    * so casting away const here is safe.
    */
   {
     ddog_TraceExporterError *attach_err = ddog_trace_exporter_config_set_shared_runtime(
-        config, (ddog_SharedRuntime *)runtime);
+        config, (ddog_ForkSafeRuntime *)runtime);
     if (attach_err != NULL) {
       ddog_trace_exporter_config_free(config);
       ddog_shared_runtime_free(runtime);
@@ -548,16 +897,6 @@ static VALUE _native_exporter_new(
     }
   }
 
-  set_config_field(config, ddog_trace_exporter_config_set_url,               rb_url,                   "url");
-  set_config_field(config, ddog_trace_exporter_config_set_tracer_version,    rb_tracer_version,        "tracer_version");
-  set_config_field(config, ddog_trace_exporter_config_set_language,          rb_language,              "language");
-  set_config_field(config, ddog_trace_exporter_config_set_lang_version,      rb_language_version,      "language_version");
-  set_config_field(config, ddog_trace_exporter_config_set_lang_interpreter,  rb_language_interpreter,  "language_interpreter");
-  set_config_field(config, ddog_trace_exporter_config_set_hostname,          rb_hostname,              "hostname");
-  set_config_field(config, ddog_trace_exporter_config_set_env,               rb_env,                   "env");
-  set_config_field(config, ddog_trace_exporter_config_set_service,           rb_service,               "service");
-  set_config_field(config, ddog_trace_exporter_config_set_version,           rb_version,               "version");
-
   /* Phase 3: build the exporter from the config */
   ddog_TraceExporter *exporter = NULL;
   ddog_TraceExporterError *err = ddog_trace_exporter_new(&exporter, config);
@@ -703,6 +1042,7 @@ typedef struct {
   const ddog_TraceExporter *exporter;
   VALUE                     traces;
   long                      trace_count;
+  raw_span_owner            span_owner;
   ddog_TracerTraceChunks   *chunks;  /* NULL after send consumes it */
 } send_traces_ctx;
 
@@ -727,20 +1067,13 @@ static VALUE build_and_send_traces(VALUE arg) {
         ddog_tracer_trace_chunks_begin_chunk(ctx->chunks, (size_t)span_count);
     check_exporter_error("Failed to begin trace chunk", begin_err);
     for (long j = 0; j < span_count; j++) {
-      VALUE rb_span = rb_ary_entry(chunk_spans, j);
-
-      /* convert_ruby_span_to_rust may raise (type errors, etc.).
-       * rb_ensure guarantees chunks is freed in that case. */
-      ddog_TracerSpan *rust_span = convert_ruby_span_to_rust(rb_span);
-
-      /* push_span consumes rust_span (ownership transferred to chunks).
-       * The error path should be unreachable: push only fails if no chunk was
-       * started (we always call begin_chunk above) or if the handle is NULL.
-       * Raise rather than swallow, so that if a future libdatadog change makes
-       * it reachable we find out loudly instead of silently sending a
-       * truncated chunk. rb_ensure frees chunks on the raise. */
+      convert_ruby_span_to_rust(
+          rb_ary_entry(chunk_spans, j), &ctx->span_owner);
+
       ddog_TraceExporterError *push_err =
-          ddog_tracer_trace_chunks_push_span(ctx->chunks, rust_span);
+          ddog_tracer_trace_chunks_push_span(ctx->chunks, ctx->span_owner.span);
+      /* push_span consumes the span on every path. */
+      ctx->span_owner.span = NULL;
       check_exporter_error("Failed to push span into trace chunk", push_err);
     }
   }
@@ -834,11 +1167,12 @@ static VALUE build_and_send_traces(VALUE arg) {
 }
 
 /*
- * Ensure: free chunks if they haven't been consumed by the send yet.
+ * Ensure: free the current raw span and any chunks not consumed by the send.
  * This runs whether build_and_send_traces returned normally or raised.
  */
-static VALUE free_chunks_if_needed(VALUE arg) {
+static VALUE free_send_resources(VALUE arg) {
   send_traces_ctx *ctx = (send_traces_ctx *)arg;
+  free_raw_span((VALUE)&ctx->span_owner);
   if (ctx->chunks != NULL) {
     ddog_tracer_trace_chunks_free(ctx->chunks);
     ctx->chunks = NULL;
@@ -877,12 +1211,13 @@ static VALUE _native_send_traces(VALUE self, VALUE traces) {
     .exporter    = wrapper->exporter,
     .traces      = traces,
     .trace_count = trace_count,
+    .span_owner  = {.span = NULL},
     .chunks      = chunks,
   };
 
   return rb_ensure(
       build_and_send_traces, (VALUE)&ctx,
-      free_chunks_if_needed, (VALUE)&ctx);
+      free_send_resources, (VALUE)&ctx);
 }
 
 /* ========================================================================
@@ -957,9 +1292,12 @@ void trace_exporter_init(VALUE tracing_module) {
   at_status_id     = rb_intern("@status");
   at_meta_id       = rb_intern("@meta");
   at_metrics_id    = rb_intern("@metrics");
+  at_metastruct_id = rb_intern("@metastruct");
 
   /* Methods */
   id_duration_method = rb_intern("duration");
+  id_to_h            = rb_intern("to_h");
+  id_negative_p      = rb_intern("negative?");
 
   /* Response.new */
   id_new = rb_intern("new");

data/ext/libdatadog_extconf_helpers.rb

@@ -10,7 +10,7 @@ module Datadog
   module LibdatadogExtconfHelpers
     # Used to make sure the correct gem version gets loaded, as extconf.rb does not get run with "bundle exec" and thus
     # may see multiple libdatadog versions. See https://github.com/DataDog/dd-trace-rb/pull/2531 for the horror story.
-    LIBDATADOG_VERSION = "~> 36.0.0.1.0"
+    LIBDATADOG_VERSION = "~> 40.0.0.1.0"
 
     # Used as an workaround for a limitation with how dynamic linking works in environments where the datadog gem and
     # libdatadog are moved after the extension gets compiled.

data/lib/datadog/ai_guard/api_client.rb

@@ -32,7 +32,7 @@ module Datadog
           "DD-AI-GUARD-VERSION": Datadog::VERSION::STRING,
           "DD-AI-GUARD-SOURCE": "SDK",
           "DD-AI-GUARD-LANGUAGE": "ruby",
-          "content-type": "application/json"
+          "content-type": "application/json",
         }.freeze
       end