datadog 2.31.0 → 2.33.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1328115b16393f9d96152ad1d94cb6190c307d8dd5df341087ffe21e2212ec9b
-  data.tar.gz: f408b1437ae55de02488433b637c868bce087289ea5fc8af4aa808cfc4ee3b73
+  metadata.gz: ff1c01535f382bb6e3de5b529bf8ec30a6deda1d1c4aba3450bb21dbd80407bf
+  data.tar.gz: 966a01b956c9df2cd8d451df9175b66e0dbae3b7b3da7732ea998c7adca70442
 SHA512:
-  metadata.gz: faf8598916d674b5da3b3ab57c013060f9ecf92b939d69a51528a81e495d07340e9a8a0ba70bf9498f6d8c303a32c08d3fbf971759199ff35b47f34a25d88b0a
-  data.tar.gz: f7629d50a2537e08c9ceb5da1e81c25b788401c2992a3a70a2f2b29e2a44a3cbda7d2e621a316953202f5a068fa3ec201a4810d01b1b27ee4bab5bd1592a9bbd
+  metadata.gz: c2d4111c1b0526122be94729577ba54d1e85fb08f2cd1ae74495d9de5bd805cb883b39c872187a5a10f2d4f67a3153d6bce2dda8192e75f4b0e808c9ab9b6a79
+  data.tar.gz: 413cb6dc25ca7b8a79e9e85b152bfd4eed649f72ca5275a46203e30c12f893914337cbd8e5136767588b67f81eadefdc839a5a4aafebbdf5cc17e7d089798886

data/ext/datadog_profiling_native_extension/clock_id.h

@@ -4,10 +4,18 @@
 #include <time.h>
 #include <ruby.h>
 
+#ifdef __APPLE__
+  #include <mach/mach.h>
+  // On macOS, we use a mach_port_t to identify threads for CPU time queries
+  typedef mach_port_t cpu_time_id_t;
+#else
+  typedef clockid_t cpu_time_id_t;
+#endif
+
 // Contains the operating-system specific identifier needed to fetch CPU-time, and a flag to indicate if we failed to fetch it
 typedef struct {
   bool valid;
-  clockid_t clock_id;
+  cpu_time_id_t clock_id;
 } thread_cpu_time_id;
 
 // Contains the current cpu time, and a flag to indicate if we failed to fetch it

data/ext/datadog_profiling_native_extension/clock_id_from_mach.c

@@ -0,0 +1,73 @@
+#include "extconf.h"
+
+// This file is only compiled on macOS where Mach thread APIs are available;
+// Otherwise we compile clock_id_from_pthread.c (Linux)
+#ifdef HAVE_MACH_THREAD_INFO
+
+#include <pthread.h>
+#include <time.h>
+#include <mach/mach.h>
+#include <mach/thread_info.h>
+
+#include "clock_id.h"
+#include "helpers.h"
+#include "private_vm_api_access.h"
+#include "ruby_helpers.h"
+#include "time_helpers.h"
+
+// Validate that our home-cooked pthread_id_for() matches pthread_self() for the current thread
+void self_test_clock_id(void) {
+  rb_nativethread_id_t expected_pthread_id = pthread_self();
+  rb_nativethread_id_t actual_pthread_id = pthread_id_for(rb_thread_current());
+
+  if (expected_pthread_id != actual_pthread_id) raise_error(rb_eRuntimeError, "pthread_id_for() self-test failed");
+
+  // Also validate that we can get a valid mach thread port for the current thread
+  mach_port_t mach_thread = pthread_mach_thread_np(expected_pthread_id);
+  if (mach_thread == MACH_PORT_NULL) raise_error(rb_eRuntimeError, "pthread_mach_thread_np() self-test failed");
+}
+
+// Safety: This function is assumed never to raise exceptions by callers
+thread_cpu_time_id thread_cpu_time_id_for(VALUE thread) {
+  rb_nativethread_id_t thread_id = pthread_id_for(thread);
+
+  if (thread_id == 0) return (thread_cpu_time_id) {.valid = false};
+
+  mach_port_t mach_thread = pthread_mach_thread_np(thread_id);
+
+  if (mach_thread == MACH_PORT_NULL) {
+    return (thread_cpu_time_id) {.valid = false};
+  }
+
+  return (thread_cpu_time_id) {.valid = true, .clock_id = mach_thread};
+}
+
+thread_cpu_time thread_cpu_time_for(thread_cpu_time_id time_id) {
+  thread_cpu_time error = (thread_cpu_time) {.valid = false};
+
+  if (!time_id.valid) return error;
+
+  // Fast path: clock_gettime(CLOCK_THREAD_CPUTIME_ID) is ~5x cheaper than thread_info()
+  // and gives sub-microsecond precision (vs microsecond), but only measures the calling
+  // thread on macOS (there is no pthread_getcpuclockid() equivalent).
+  if (time_id.clock_id == pthread_mach_thread_np(pthread_self())) {
+    struct timespec ts;
+    if (clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts) == 0) {
+      return (thread_cpu_time) {.valid = true, .result_ns = SECONDS_AS_NS(ts.tv_sec) + ts.tv_nsec};
+    }
+    // Fall through to thread_info on the unlikely failure case.
+  }
+
+  struct thread_basic_info info;
+  mach_msg_type_number_t count = THREAD_BASIC_INFO_COUNT;
+  kern_return_t kr = thread_info(time_id.clock_id, THREAD_BASIC_INFO, (thread_info_t)&info, &count);
+
+  if (kr != KERN_SUCCESS) return error;
+
+  long user_ns = SECONDS_AS_NS(info.user_time.seconds) + MICROS_AS_NS(info.user_time.microseconds);
+  long system_ns = SECONDS_AS_NS(info.system_time.seconds) + MICROS_AS_NS(info.system_time.microseconds);
+
+  return (thread_cpu_time) {.valid = true, .result_ns = user_ns + system_ns};
+}
+
+#endif

data/ext/datadog_profiling_native_extension/clock_id_from_pthread.c

@@ -1,7 +1,7 @@
 #include "extconf.h"
 
 // This file is only compiled on systems where pthread_getcpuclockid() is available;
-// Otherwise we compile clock_id_noop.c
+// Otherwise we compile clock_id_from_mach.c (macOS)
 #ifdef HAVE_PTHREAD_GETCPUCLOCKID
 
 #include <pthread.h>

data/ext/datadog_profiling_native_extension/collectors_cpu_and_wall_time_worker.c

@@ -186,6 +186,11 @@ typedef struct {
     uint64_t gvl_sampling_time_ns_min;
     uint64_t gvl_sampling_time_ns_max;
     uint64_t gvl_sampling_time_ns_total;
+
+    struct vm_metrics {
+      // Total time spent waiting for the GVL
+      uint64_t gvl_waiting_time_ns_total;
+    } vm_metrics;
   } stats;
 } cpu_and_wall_time_worker_state;
 
@@ -1101,6 +1106,7 @@ static VALUE _native_stats(DDTRACE_UNUSED VALUE self, VALUE instance) {
     ID2SYM(rb_intern("gvl_sampling_time_ns_max")),   /* => */ RUBY_NUM_OR_NIL(state->stats.gvl_sampling_time_ns_max, > 0, ULL2NUM),
     ID2SYM(rb_intern("gvl_sampling_time_ns_total")), /* => */ RUBY_NUM_OR_NIL(state->stats.gvl_sampling_time_ns_total, > 0, ULL2NUM),
     ID2SYM(rb_intern("gvl_sampling_time_ns_avg")),   /* => */ RUBY_AVG_OR_NIL(state->stats.gvl_sampling_time_ns_total, state->stats.after_gvl_running),
+    ID2SYM(rb_intern("gvl_waiting_time_ns_total")),  /* => */ state->gvl_profiling_enabled ? ULL2NUM(state->stats.vm_metrics.gvl_waiting_time_ns_total) : Qnil,
   };
   for (long unsigned int i = 0; i < VALUE_COUNT(arguments); i += 2) rb_hash_aset(stats_as_hash, arguments[i], arguments[i+1]);
   return stats_as_hash;
@@ -1141,6 +1147,7 @@ static void reset_stats_not_thread_safe(cpu_and_wall_time_worker_state *state) {
     .cpu_sampling_time_ns_min        = UINT64_MAX,
     .allocation_sampling_time_ns_min = UINT64_MAX,
     .gvl_sampling_time_ns_min        = UINT64_MAX,
+    // Other fields are reset to 0
   };
 }
 
@@ -1399,7 +1406,7 @@ static VALUE _native_resume_signals(DDTRACE_UNUSED VALUE self) {
       // Interesting note: A RUBY_INTERNAL_THREAD_EVENT_RESUMED is guaranteed to be called with the GVL being acquired.
       // (And... I think target_thread will be == rb_thread_current()?)
       //
-      // But we're not sure if we're on the main Ractor yet. The thread context collector actually can actually help here:
+      // But we're not sure if we're on the main Ractor yet. The thread context collector can actually help here:
       // it tags threads it's tracking, so if a thread is tagged then by definition we know that thread belongs to the main
       // Ractor. Thus, if we get a ON_GVL_RUNNING_UNKNOWN result we shouldn't touch any state, but otherwise we're good to go.
 
@@ -1407,19 +1414,22 @@ static VALUE _native_resume_signals(DDTRACE_UNUSED VALUE self) {
         target_thread = gvl_profiling_state_maybe_initialize();
       #endif
 
+      cpu_and_wall_time_worker_state *state = active_sampler_instance_state; // Read from global variable, see "sampler global state safety" note above
+      if (state == NULL) return; // This should not happen, but just in case...
+
       on_gvl_running_result result = thread_context_collector_on_gvl_running(target_thread);
 
-      if (result == ON_GVL_RUNNING_SAMPLE) {
+      if (result.waiting_for_gvl_duration_ns > 0) {
+        state->stats.vm_metrics.gvl_waiting_time_ns_total += (uint64_t) result.waiting_for_gvl_duration_ns;
+      }
+
+      if (result.action == ON_GVL_RUNNING_SAMPLE) {
         #ifndef NO_POSTPONED_TRIGGER
           rb_postponed_job_trigger(after_gvl_running_from_postponed_job_handle);
         #else
           rb_postponed_job_register_one(0, after_gvl_running_from_postponed_job, NULL);
         #endif
-      } else if (result == ON_GVL_RUNNING_DONT_SAMPLE) {
-        cpu_and_wall_time_worker_state *state = active_sampler_instance_state; // Read from global variable, see "sampler global state safety" note above
-
-        if (state == NULL) return; // This should not happen, but just in case...
-
+      } else if (result.action == ON_GVL_RUNNING_DONT_SAMPLE) {
         state->stats.gvl_dont_sample++;
       }
     } else {

data/ext/datadog_profiling_native_extension/collectors_thread_context.c

@@ -1201,7 +1201,11 @@ static int per_thread_context_as_ruby_hash(st_data_t key_thread, st_data_t value
     ID2SYM(rb_intern("thread_id")),                       /* => */ rb_str_new2(thread_context->thread_id),
     ID2SYM(rb_intern("thread_invoke_location")),          /* => */ rb_str_new2(thread_context->thread_invoke_location),
     ID2SYM(rb_intern("thread_cpu_time_id_valid?")),       /* => */ thread_context->thread_cpu_time_id.valid ? Qtrue : Qfalse,
-    ID2SYM(rb_intern("thread_cpu_time_id")),              /* => */ CLOCKID2NUM(thread_context->thread_cpu_time_id.clock_id),
+    #ifdef __APPLE__
+      ID2SYM(rb_intern("thread_cpu_time_id")),              /* => */ ULL2NUM(thread_context->thread_cpu_time_id.clock_id),
+    #else
+      ID2SYM(rb_intern("thread_cpu_time_id")),              /* => */ CLOCKID2NUM(thread_context->thread_cpu_time_id.clock_id),
+    #endif
     ID2SYM(rb_intern("cpu_time_at_previous_sample_ns")),  /* => */ LONG2NUM(thread_context->cpu_time_at_previous_sample_ns),
     ID2SYM(rb_intern("wall_time_at_previous_sample_ns")), /* => */ LONG2NUM(thread_context->wall_time_at_previous_sample_ns),
 
@@ -1924,10 +1928,14 @@ static uint64_t otel_span_id_to_uint(VALUE otel_span_id) {
     intptr_t gvl_waiting_at = gvl_profiling_state_get(thread);
 
     // Thread was not being profiled / not waiting on gvl
-    if (gvl_waiting_at == 0 || gvl_waiting_at == GVL_WAITING_ENABLED_EMPTY) return ON_GVL_RUNNING_UNKNOWN;
+    if (gvl_waiting_at == 0 || gvl_waiting_at == GVL_WAITING_ENABLED_EMPTY) {
+      return (on_gvl_running_result) {.action = ON_GVL_RUNNING_UNKNOWN, .waiting_for_gvl_duration_ns = 0};
+    }
 
     // @ivoanjo: I'm not sure if this can happen -- It means we should've sampled already but haven't gotten the chance yet?
-    if (gvl_waiting_at < 0) return ON_GVL_RUNNING_SAMPLE;
+    if (gvl_waiting_at < 0) {
+      return (on_gvl_running_result) {.action = ON_GVL_RUNNING_SAMPLE, .waiting_for_gvl_duration_ns = 0};
+    }
 
     long waiting_for_gvl_duration_ns = monotonic_wall_time_now_ns(DO_NOT_RAISE_ON_FAILURE) - gvl_waiting_at;
 
@@ -1943,7 +1951,10 @@ static uint64_t otel_span_id_to_uint(VALUE otel_span_id) {
       gvl_profiling_state_set(thread, GVL_WAITING_ENABLED_EMPTY);
     }
 
-    return should_sample ? ON_GVL_RUNNING_SAMPLE : ON_GVL_RUNNING_DONT_SAMPLE;
+    return (on_gvl_running_result) {
+      .action = should_sample ? ON_GVL_RUNNING_SAMPLE : ON_GVL_RUNNING_DONT_SAMPLE,
+      .waiting_for_gvl_duration_ns = waiting_for_gvl_duration_ns,
+    };
   }
 
   __attribute__((warn_unused_result))
@@ -2146,7 +2157,7 @@ static uint64_t otel_span_id_to_uint(VALUE otel_span_id) {
 
     debug_enter_unsafe_context();
 
-    VALUE result = thread_context_collector_on_gvl_running(thread_from_thread_object(thread)) == ON_GVL_RUNNING_SAMPLE ? Qtrue : Qfalse;
+    VALUE result = thread_context_collector_on_gvl_running(thread_from_thread_object(thread)).action == ON_GVL_RUNNING_SAMPLE ? Qtrue : Qfalse;
 
     debug_leave_unsafe_context();
 

data/ext/datadog_profiling_native_extension/collectors_thread_context.h

@@ -2,6 +2,7 @@
 
 #include <ruby.h>
 #include <stdbool.h>
+#include <stdint.h>
 
 #include "gvl_profiling_helper.h"
 
@@ -25,6 +26,11 @@ VALUE enforce_thread_context_collector_instance(VALUE object);
     ON_GVL_RUNNING_UNKNOWN, // Thread is not known, it may not even be from the current Ractor
     ON_GVL_RUNNING_DONT_SAMPLE, // Thread is known, but "Waiting for GVL" period was too small to be sampled
     ON_GVL_RUNNING_SAMPLE, // Thread is known, and "Waiting for GVL" period should be sampled
+  } on_gvl_running_enum;
+
+  typedef struct {
+    on_gvl_running_enum action;
+    long waiting_for_gvl_duration_ns;
   } on_gvl_running_result;
 
   void thread_context_collector_on_gvl_waiting(gvl_profiling_thread thread);

data/ext/datadog_profiling_native_extension/extconf.rb

@@ -69,11 +69,16 @@ $stderr.puts(
 # NOTE: we MUST NOT require 'mkmf' before we check the #skip_building_extension? because the require triggers checks
 # that may fail on an environment not properly setup for building Ruby extensions.
 require "mkmf"
+Datadog::LibdatadogExtconfHelpers.dump_mkmf_log_on_failure!
 
 Logging.message("[datadog] Using compiler:\n")
 xsystem("#{CONFIG["CC"]} -v")
 Logging.message("[datadog] End of compiler information\n")
 
+# We must *never* `append_cflags "-Wall"` or `append_cflags "-Wextra"`, because those add the flag at the end,
+# which then overrides earlier -Wno-* flags from RbConfig::CONFIG["warnflags"], and causes errors if -Werror is added.
+# There is no need to add them anyway, Ruby since 1.9 has RbConfig::CONFIG["warnflags"] starting with "-Wall -Wextra ".
+
 # Because we can't control what compiler versions our customers use, shipping with -Werror by default is a no-go.
 # But we can enable it in CI, so that we quickly spot any new warnings that just got introduced.
 append_cflags "-Werror" if ENV["DATADOG_GEM_CI"] == "true"
@@ -106,10 +111,6 @@ append_cflags "-fvisibility=hidden"
 # Avoid legacy C definitions
 append_cflags "-Wold-style-definition"
 
-# Enable all other compiler warnings
-append_cflags "-Wall"
-append_cflags "-Wextra"
-
 if ENV["DDTRACE_DEBUG"] == "true"
   $defs << "-DDD_DEBUG"
   CONFIG["optflags"] = "-O0"
@@ -128,6 +129,9 @@ if RUBY_PLATFORM.include?("linux")
 
   # Not available on macOS
   $defs << "-DHAVE_CLOCK_MONOTONIC_COARSE"
+elsif RUBY_PLATFORM.include?("darwin")
+  # On macOS, we use Mach thread APIs to get per-thread CPU time
+  $defs << "-DHAVE_MACH_THREAD_INFO"
 end
 
 have_func "malloc_stats"

data/ext/datadog_profiling_native_extension/http_transport.c

@@ -198,15 +198,15 @@ static VALUE _native_do_export(
   VALUE flush
 ) {
   VALUE encoded_profile = rb_funcall(flush, rb_intern("encoded_profile"), 0);
-  VALUE code_provenance_file_name = rb_funcall(flush, rb_intern("code_provenance_file_name"), 0);
   VALUE code_provenance_data = rb_funcall(flush, rb_intern("code_provenance_data"), 0);
+  VALUE metrics_json = rb_funcall(flush, rb_intern("metrics"), 0);
   VALUE tags_as_array = rb_funcall(flush, rb_intern("tags_as_array"), 0);
   VALUE internal_metadata_json = rb_funcall(flush, rb_intern("internal_metadata_json"), 0);
   VALUE info_json = rb_funcall(flush, rb_intern("info_json"), 0);
   VALUE process_tags = rb_funcall(flush, rb_intern("process_tags"), 0);
 
   enforce_encoded_profile_instance(encoded_profile);
-  ENFORCE_TYPE(code_provenance_file_name, T_STRING);
+  ENFORCE_TYPE(metrics_json, T_STRING);
   ENFORCE_TYPE(tags_as_array, T_ARRAY);
   ENFORCE_TYPE(internal_metadata_json, T_STRING);
   ENFORCE_TYPE(info_json, T_STRING);
@@ -216,13 +216,18 @@ static VALUE _native_do_export(
   bool have_code_provenance = !NIL_P(code_provenance_data);
   if (have_code_provenance) ENFORCE_TYPE(code_provenance_data, T_STRING);
 
-  int to_compress_length = have_code_provenance ? 1 : 0;
+  int to_compress_length = 1 + (have_code_provenance ? 1 : 0);
   ddog_prof_Exporter_File to_compress[to_compress_length];
   ddog_prof_Exporter_Slice_File files_to_compress_and_export = {.ptr = to_compress, .len = to_compress_length};
 
+  to_compress[0] = (ddog_prof_Exporter_File) {
+    .name = DDOG_CHARSLICE_C("metrics.json"),
+    .file = byte_slice_from_ruby_string(metrics_json),
+  };
+
   if (have_code_provenance) {
-    to_compress[0] = (ddog_prof_Exporter_File) {
-      .name = char_slice_from_ruby_string(code_provenance_file_name),
+    to_compress[1] = (ddog_prof_Exporter_File) {
+      .name = DDOG_CHARSLICE_C("code-provenance.json"),
       .file = byte_slice_from_ruby_string(code_provenance_data),
     };
   }

data/ext/datadog_profiling_native_extension/stack_recorder.c

@@ -416,7 +416,6 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
   if (options == Qnil) options = rb_hash_new();
 
   VALUE recorder_instance = rb_hash_fetch(options, ID2SYM(rb_intern("self_instance")));
-  VALUE cpu_time_enabled = rb_hash_fetch(options, ID2SYM(rb_intern("cpu_time_enabled")));
   VALUE alloc_samples_enabled = rb_hash_fetch(options, ID2SYM(rb_intern("alloc_samples_enabled")));
   VALUE heap_samples_enabled = rb_hash_fetch(options, ID2SYM(rb_intern("heap_samples_enabled")));
   VALUE heap_size_enabled = rb_hash_fetch(options, ID2SYM(rb_intern("heap_size_enabled")));
@@ -424,7 +423,6 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
   VALUE timeline_enabled = rb_hash_fetch(options, ID2SYM(rb_intern("timeline_enabled")));
   VALUE heap_clean_after_gc_enabled = rb_hash_fetch(options, ID2SYM(rb_intern("heap_clean_after_gc_enabled")));
 
-  ENFORCE_BOOLEAN(cpu_time_enabled);
   ENFORCE_BOOLEAN(alloc_samples_enabled);
   ENFORCE_BOOLEAN(heap_samples_enabled);
   ENFORCE_BOOLEAN(heap_size_enabled);
@@ -440,7 +438,6 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
   heap_recorder_set_sample_rate(state->heap_recorder, NUM2INT(heap_sample_every));
 
   uint8_t requested_values_count = ALL_VALUE_TYPES_COUNT -
-    (cpu_time_enabled == Qtrue ? 0 : 1) -
     (alloc_samples_enabled == Qtrue? 0 : 2) -
     (heap_samples_enabled == Qtrue ? 0 : 1) -
     (heap_size_enabled == Qtrue ? 0 : 1) -
@@ -466,12 +463,9 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
   enabled_sample_types[next_enabled_pos] = DDOG_PROF_SAMPLE_TYPE_WALL_TIME;
   state->position_for[WALL_TIME_VALUE_ID] = next_enabled_pos++;
 
-  if (cpu_time_enabled == Qtrue) {
-    enabled_sample_types[next_enabled_pos] = DDOG_PROF_SAMPLE_TYPE_CPU_TIME;
-    state->position_for[CPU_TIME_VALUE_ID] = next_enabled_pos++;
-  } else {
-    state->position_for[CPU_TIME_VALUE_ID] = next_disabled_pos++;
-  }
+  // CPU_TIME is always enabled
+  enabled_sample_types[next_enabled_pos] = DDOG_PROF_SAMPLE_TYPE_CPU_TIME;
+  state->position_for[CPU_TIME_VALUE_ID] = next_enabled_pos++;
 
   if (alloc_samples_enabled == Qtrue) {
     enabled_sample_types[next_enabled_pos] = DDOG_PROF_SAMPLE_TYPE_ALLOC_SAMPLES;

data/ext/datadog_profiling_native_extension/time_helpers.h

@@ -9,6 +9,7 @@
 
 #define SECONDS_AS_NS(value) (value * 1000 * 1000 * 1000L)
 #define MILLIS_AS_NS(value) (value * 1000 * 1000L)
+#define MICROS_AS_NS(value) (value * 1000L)
 
 typedef enum { RAISE_ON_FAILURE, DO_NOT_RAISE_ON_FAILURE } raise_on_failure_setting;
 

data/ext/libdatadog_api/crashtracker.c

@@ -72,6 +72,8 @@ static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUS
     .endpoint = {.url = char_slice_from_ruby_string(agent_base_url)},
     .resolve_frames = DDOG_CRASHT_STACKTRACE_COLLECTION_ENABLED_WITH_SYMBOLS_IN_RECEIVER,
     .timeout_ms = FIX2INT(upload_timeout_seconds) * 1000,
+    .collect_all_threads = true,
+    .max_threads = 128,
   };
 
   ddog_crasht_Metadata metadata = {

data/ext/libdatadog_api/di.c

@@ -3,7 +3,12 @@
 #include "datadog_ruby_common.h"
 
 // Prototypes for Ruby functions declared in internal Ruby headers.
+// rb_iseqw_new wraps an internal iseq pointer into a Ruby-visible
+// RubyVM::InstructionSequence object.
 VALUE rb_iseqw_new(const void *iseq);
+// rb_iseqw_to_iseq unwraps a RubyVM::InstructionSequence object back
+// to its internal iseq pointer.
+const void *rb_iseqw_to_iseq(VALUE iseqw);
 int rb_objspace_internal_object_p(VALUE obj);
 void rb_objspace_each_objects(
     int (*callback)(void *start, void *end, size_t stride, void *data),
@@ -70,10 +75,53 @@ static VALUE exception_message(DDTRACE_UNUSED VALUE _self, VALUE exception) {
   return rb_ivar_get(exception, id_mesg);
 }
 
+// rb_iseq_type was added in Ruby 3.1 (commit 89a02d89 by Koichi Sasada,
+// 2021-12-19). It returns the iseq type as a Symbol. On Ruby < 3.1 this
+// function does not exist, so have_func('rb_iseq_type') in extconf.rb
+// gates compilation. When unavailable, backfill_registry falls back to
+// the first_lineno == 0 heuristic.
+#ifdef HAVE_RB_ISEQ_TYPE
+VALUE rb_iseq_type(const void *iseq);
+
+/*
+ * call-seq:
+ *   DI.iseq_type(iseq) -> Symbol
+ *
+ * Returns the type of an InstructionSequence as a symbol by calling
+ * the internal rb_iseq_type() function (available since Ruby 3.1).
+ *
+ * This method is only defined when rb_iseq_type is detected at compile
+ * time via have_func in extconf.rb. On Ruby < 3.1 it is not available
+ * and callers must use an alternative (e.g. first_lineno heuristic).
+ *
+ * Possible return values: :top, :method, :block, :class, :rescue,
+ * :ensure, :eval, :main, :plain.
+ *
+ * :top and :main represent whole-file iseqs (from require/load and the
+ * entry point script respectively). Other types represent sub-file
+ * constructs (method definitions, class bodies, blocks, etc.).
+ *
+ * Used by CodeTracker#backfill_registry to distinguish whole-file iseqs
+ * from per-method/block/class iseqs when populating the registry from
+ * the object space.
+ *
+ * @param iseq [RubyVM::InstructionSequence] The instruction sequence
+ * @return [Symbol] The iseq type
+ */
+static VALUE iseq_type(DDTRACE_UNUSED VALUE _self, VALUE iseq_val) {
+  const void *iseq = rb_iseqw_to_iseq(iseq_val);
+  if (!iseq) return Qnil;
+  return rb_iseq_type(iseq);
+}
+#endif
+
 void di_init(VALUE datadog_module) {
   id_mesg = rb_intern("mesg");
 
   VALUE di_module = rb_define_module_under(datadog_module, "DI");
   rb_define_singleton_method(di_module, "all_iseqs", all_iseqs, 0);
   rb_define_singleton_method(di_module, "exception_message", exception_message, 1);
+#ifdef HAVE_RB_ISEQ_TYPE
+  rb_define_singleton_method(di_module, "iseq_type", iseq_type, 1);
+#endif
 }

data/ext/libdatadog_api/extconf.rb

@@ -31,6 +31,11 @@ libdatadog_issue = Datadog::LibdatadogExtconfHelpers.load_libdatadog_or_get_issu
 skip_building_extension!("issue setting up `libdatadog` gem: #{libdatadog_issue}") if libdatadog_issue
 
 require 'mkmf'
+Datadog::LibdatadogExtconfHelpers.dump_mkmf_log_on_failure!
+
+# We must *never* `append_cflags "-Wall"` or `append_cflags "-Wextra"`, because those add the flag at the end,
+# which then overrides earlier -Wno-* flags from RbConfig::CONFIG["warnflags"], and causes errors if -Werror is added.
+# There is no need to add them anyway, Ruby since 1.9 has RbConfig::CONFIG["warnflags"] starting with "-Wall -Wextra ".
 
 # Because we can't control what compiler versions our customers use, shipping with -Werror by default is a no-go.
 # But we can enable it in CI, so that we quickly spot any new warnings that just got introduced.
@@ -64,10 +69,6 @@ append_cflags '-fvisibility=hidden'
 # Avoid legacy C definitions
 append_cflags '-Wold-style-definition'
 
-# Enable all other compiler warnings
-append_cflags '-Wall'
-append_cflags '-Wextra'
-
 if ENV['DDTRACE_DEBUG'] == 'true'
   $defs << '-DDD_DEBUG'
   CONFIG['optflags'] = '-O0'
@@ -89,6 +90,8 @@ Datadog::LibdatadogExtconfHelpers.add_libdatadog_version_define
 # When requiring, we need to use the exact same string, including the version and the platform.
 EXTENSION_NAME = "libdatadog_api.#{RUBY_VERSION[/\d+.\d+/]}_#{RUBY_PLATFORM}".freeze
 
+have_func('rb_iseq_type')
+
 create_makefile(EXTENSION_NAME)
 
 # rubocop:enable Style/GlobalVars

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 = '~> 30.0.0.1.0'
+    LIBDATADOG_VERSION = '~> 33.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.
@@ -170,6 +170,43 @@ module Datadog
     end
     # rubocop:enable Style/GlobalVars
 
+    # When setting up the extension build fails (e.g. a missing header), the actual failure ends up in mkmf.log
+    # and is not printed, which is confusing and complicates debugging. To fix that, this monkey patch actually
+    # prints the failure.
+    def self.dump_mkmf_log_on_failure!
+      # Doesn't work on 2.5/2.6 and not worth extra complexity to support
+      return if RUBY_VERSION < '2.7'
+
+      MakeMakefile.prepend(DumpMkmfLogOnFailure)
+    end
+
+    # rubocop:disable Style/GlobalVars,Style/StderrPuts
+    # See `dump_mkmf_log_on_failure!` for details.
+    module DumpMkmfLogOnFailure
+      def mkmf_failed(path)
+        unless $makefile_created || File.exist?('Makefile')
+          log_path = File.expand_path('mkmf.log')
+          if File.exist?(log_path)
+            # The full log is very verbose so let's grab only the last check which should be the one that failed
+            entries = File.read(log_path).split(/^-{20}$\n?/)
+            last_entry = entries.reverse.find { |e| !e.strip.empty? } || ''
+
+            $stderr.puts(
+              "+------------------------------------------------------------------------------+\n" \
+              "| There was an issue setting up extension build:                               |\n" \
+              "+------------------------------------------------------------------------------+" \
+              "#{last_entry.chomp}" \
+              "+------------------------------------------------------------------------------+\n" \
+              "| Full failure log is at #{log_path}\n" \
+              "+------------------------------------------------------------------------------+\n" \
+            )
+          end
+        end
+        super
+      end
+    end
+    # rubocop:enable Style/GlobalVars,Style/StderrPuts
+
     # Note: This helper is currently only used in the `libdatadog_api/extconf.rb` BUT still lives here to enable testing.
     def self.load_libdatadog_or_get_issue
       try_loading_libdatadog do |exception|

data/lib/datadog/ai_guard/autoload.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+if %w[1 true].include?((Datadog::DATADOG_ENV["DD_AI_GUARD_ENABLED"] || "").downcase)
+  begin
+    require_relative "contrib/auto_instrument"
+    Datadog::AIGuard::Contrib::AutoInstrument.patch_all
+  rescue => e
+    Kernel.warn("[datadog] AI Guard failed to auto-instrument. error: #{e.class}: #{e.message}")
+  end
+end

data/lib/datadog/ai_guard/component.rb

@@ -15,7 +15,7 @@ module Datadog
   module AIGuard
     # Component for API Guard product
     class Component
-      attr_reader :api_client, :logger
+      attr_reader :api_client, :logger, :telemetry
 
       def self.build(settings, logger:, telemetry:)
         return unless settings.respond_to?(:ai_guard) && settings.ai_guard.enabled