datadog 2.39.0 → 2.41.0

data/ext/datadog_profiling_native_extension/collectors_thread_context.c

@@ -153,6 +153,8 @@ typedef struct {
   VALUE otel_current_span_key;
   // Used to enable native filenames in stack traces
   bool native_filenames_enabled;
+  // Used to include class/module names in method names (e.g. "Foo#bar" instead of "bar")
+  bool show_classes;
   // Used to cache native filename lookup results (Map[void *function_pointer, char *filename])
   st_table *native_filenames_cache;
   // Used to attribute overhead during sampling to this component
@@ -493,7 +495,7 @@ static void thread_context_collector_typed_data_free(void *state_ptr) {
 
   // Important: Remember that we're only guaranteed to see here what's been set in _native_new, aka
   // pointers that have been set NULL there may still be NULL here.
-  if (state->locations.ptr != NULL) ruby_xfree(state->locations.ptr);
+  sample_locations_free(&state->locations);
 
   st_free_table(state->native_filenames_cache);
 
@@ -550,14 +552,13 @@ static VALUE _native_new(VALUE klass) {
   // being leaked.
 
   // Update this when modifying state struct
-  state->locations.ptr = NULL;
-  state->locations.len = 0;
   state->recorder_instance = Qnil;
   state->tracer_context_key = MISSING_TRACER_CONTEXT_KEY;
   VALUE thread_list_buffer = rb_ary_new();
   state->thread_list_buffer = thread_list_buffer;
   state->endpoint_collection_enabled = true;
   state->native_filenames_enabled = false;
+  state->show_classes = false;
   state->native_filenames_cache = st_init_numtable();
   state->otel_context_enabled = OTEL_CONTEXT_ENABLED_FALSE;
   state->otel_context_source = OTEL_CONTEXT_SOURCE_UNKNOWN;
@@ -593,12 +594,14 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
   VALUE waiting_for_gvl_threshold_ns = rb_hash_fetch(options, ID2SYM(rb_intern("waiting_for_gvl_threshold_ns")));
   VALUE otel_context_enabled = rb_hash_fetch(options, ID2SYM(rb_intern("otel_context_enabled")));
   VALUE native_filenames_enabled = rb_hash_fetch(options, ID2SYM(rb_intern("native_filenames_enabled")));
+  VALUE show_classes = rb_hash_fetch(options, ID2SYM(rb_intern("show_classes")));
   VALUE overhead_filename = rb_hash_fetch(options, ID2SYM(rb_intern("overhead_filename")));
 
   ENFORCE_TYPE(max_frames, T_FIXNUM);
   ENFORCE_BOOLEAN(endpoint_collection_enabled);
   ENFORCE_TYPE(waiting_for_gvl_threshold_ns, T_FIXNUM);
   ENFORCE_BOOLEAN(native_filenames_enabled);
+  ENFORCE_BOOLEAN(show_classes);
   ENFORCE_TYPE(overhead_filename, T_STRING);
 
   uint16_t max_frame_int = sampling_buffer_check_max_frames(NUM2INT(max_frames));
@@ -607,12 +610,12 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
   TypedData_Get_Struct(self_instance, thread_context_collector_state, &thread_context_collector_typed_data, state);
 
   // Update this when modifying state struct
-  state->locations.len = max_frame_int;
-  state->locations.ptr = ruby_xcalloc(max_frame_int, sizeof(ddog_prof_Location));
+  sample_locations_initialize(&state->locations, max_frame_int, show_classes == Qtrue);
   state->recorder_instance = enforce_recorder_instance(recorder_instance);
   recorder_install_on_serialize(recorder_instance, self_instance);
   state->endpoint_collection_enabled = (endpoint_collection_enabled == Qtrue);
   state->native_filenames_enabled = (native_filenames_enabled == Qtrue);
+  state->show_classes = (show_classes == Qtrue);
   state->overhead_filename = overhead_filename;
   if (otel_context_enabled == Qfalse || otel_context_enabled == Qnil) {
     state->otel_context_enabled = OTEL_CONTEXT_ENABLED_FALSE;
@@ -949,7 +952,7 @@ bool thread_context_collector_on_gc_finish(VALUE self_instance) {
 
   // Update cpu-time accounting so it doesn't include the cpu-time spent in GC during the next sample.
   // We don't do the same for wall-time, because GC is just like any other reason a thread didn't make
-  // progress -- time always goes forward regardless of the thread making progress on what it wanted. 
+  // progress -- time always goes forward regardless of the thread making progress on what it wanted.
   if (thread_context->cpu_time_at_previous_sample_ns != INVALID_TIME) {
     thread_context->cpu_time_at_previous_sample_ns += gc_cpu_time_elapsed_ns;
   }
@@ -1157,7 +1160,8 @@ static void trigger_sample_for_thread(
       .is_gvl_waiting_state = is_gvl_waiting_state,
     },
     state->native_filenames_enabled,
-    state->native_filenames_cache
+    state->native_filenames_cache,
+    state->show_classes
   );
 }
 
@@ -1329,6 +1333,7 @@ static VALUE _native_inspect(DDTRACE_UNUSED VALUE _self, VALUE collector_instanc
   rb_str_concat(result, rb_sprintf(" stats=%"PRIsVALUE, stats_to_ruby_hash(state, rb_hash_new())));
   rb_str_concat(result, rb_sprintf(" endpoint_collection_enabled=%"PRIsVALUE, state->endpoint_collection_enabled ? Qtrue : Qfalse));
   rb_str_concat(result, rb_sprintf(" native_filenames_enabled=%"PRIsVALUE, state->native_filenames_enabled ? Qtrue : Qfalse));
+  rb_str_concat(result, rb_sprintf(" show_classes=%"PRIsVALUE, state->show_classes ? Qtrue : Qfalse));
   // Note: `st_table_size()` is available from Ruby 3.2+ but not before
   rb_str_concat(result, rb_sprintf(" native_filenames_cache_size=%zu", state->native_filenames_cache->num_entries));
   rb_str_concat(result, rb_sprintf(" otel_context_enabled=%d", state->otel_context_enabled));

data/ext/datadog_profiling_native_extension/crashtracking_runtime_stacks.c

@@ -159,7 +159,7 @@ static void ruby_runtime_stack_callback(
     frame_info *info = &runtime_stack_buffer[i];
 
     if (info->is_ruby_frame) {
-      const void *iseq = (const void *)info->as.ruby_frame.iseq;
+      const rb_iseq_t *iseq = info->as.ruby_frame.iseq;
       ddog_CharSlice function_slice = DDOG_CHARSLICE_C("<unknown>");
       ddog_CharSlice file_slice = DDOG_CHARSLICE_C("<unknown>");
 
@@ -181,9 +181,10 @@ static void ruby_runtime_stack_callback(
       ddog_CharSlice function_slice = DDOG_CHARSLICE_C("<C method>");
       ddog_CharSlice file_slice = DDOG_CHARSLICE_C("<C extension>");
 
-      if (info->as.native_frame.method_id) {
-        const char *method_name = rb_id2name(info->as.native_frame.method_id);
-        if (is_pointer_readable(method_name, 256)) {
+      const rb_callable_method_entry_t *cme = info->cme;
+      if (cme && is_pointer_readable(cme, sizeof_rb_callable_method_entry_t())) {
+        const char *method_name = ddtrace_cme_original_method_name(cme);
+        if (method_name && is_pointer_readable(method_name, 256)) {
           size_t method_name_len = strnlen(method_name, 256);
           if (method_name_len > 0 && method_name_len < 256) {
             function_slice = char_slice_from_cstr(method_name);

data/ext/datadog_profiling_native_extension/datadog_ruby_common.c

@@ -6,19 +6,27 @@
 static ID telemetry_message_id;
 
 void raise_unexpected_type(VALUE value, const char *value_name, const char *type_name, const char *file, int line, const char *function_name) {
-  rb_exc_raise(
-    rb_exc_new_str(
-      rb_eTypeError,
-      rb_sprintf("wrong argument %"PRIsVALUE" for '%s' (expected a %s) at %s:%d:in `%s'",
-        rb_inspect(value),
-        value_name,
-        type_name,
-        file,
-        line,
-        function_name
-      )
+  // All of the below come from `ENFORCE_TYPE` and are constant for their call-site
+  VALUE simple_message = rb_sprintf("wrong argument for '%s' (expected a %s) at %s:%d:in `%s'",
+    value_name,
+    type_name,
+    file,
+    line,
+    function_name
+  );
+  VALUE exception = rb_exc_new_str(
+    rb_eTypeError,
+    rb_sprintf("wrong argument %"PRIsVALUE" for '%s' (expected a %s) at %s:%d:in `%s'",
+      rb_inspect(value),
+      value_name,
+      type_name,
+      file,
+      line,
+      function_name
     )
   );
+  rb_ivar_set(exception, telemetry_message_id, simple_message);
+  rb_exc_raise(exception);
 }
 
 // Raises an exception with separate telemetry-safe and detailed messages.

data/ext/datadog_profiling_native_extension/datadog_ruby_common.h

@@ -5,6 +5,13 @@
 #include <ruby.h>
 #include <datadog/common.h>
 
+// All recommended backward compatible macros for keyword argument functions can be found here:
+// https://github.com/ruby/ruby/blob/master/doc/extension.rdoc#defining-backward-compatible-macros-for-keyword-argument-functions
+#ifndef RB_PASS_KEYWORDS
+/* Only define macros on Ruby <2.7 */
+#define rb_funcallv_kw(o, m, c, v, kw) rb_funcallv(o, m, c, v)
+#endif
+
 // Must be called once during initialization
 void datadog_ruby_common_init(void);
 

data/ext/datadog_profiling_native_extension/extconf.rb

@@ -139,13 +139,6 @@ end
 
 have_func "malloc_stats"
 
-# Used to get native filenames (dladdr1 is preferred, so we only check for the other if not available)
-# Note it's possible none are available
-if have_header("dlfcn.h")
-  (have_struct_member("struct link_map", "l_name", "link.h") && have_func("dladdr1")) ||
-    have_func("dladdr")
-end
-
 # On older Rubies, there was no primitive mutex and condition variable implemented in `thread_sync.rb` (internal)
 $defs << "-DNO_PRIMITIVE_MUTEX_AND_CONDITION_VARIABLE" if RUBY_VERSION < "4"
 
@@ -182,9 +175,18 @@ $defs << "-DUSE_RACTOR_INTERNAL_APIS_DIRECTLY" if RUBY_VERSION < "3.3"
 # On older Rubies, there was no GVL instrumentation API and APIs created to support it
 $defs << "-DNO_GVL_INSTRUMENTATION" if RUBY_VERSION < "3.2"
 
+# On older Rubies, rb_class_attached_object is not available
+$defs << "-DNO_CLASS_ATTACHED_OBJECT" if RUBY_VERSION < "3.2"
+
+# On older Rubies, rb_mod_name allocates (rb_str_dup); use rb_attr_get(__classpath__) instead
+$defs << "-DNO_ALLOC_FREE_MOD_NAME" if RUBY_VERSION < "2.7"
+
 # rb_internal_thread_specific_*()
 $defs << "-DHAVE_RUBY_THREAD_STORAGE_API" if RUBY_VERSION >= "3.3"
 
+# RCLASS_EXT(mod)->permanent_classpath
+$defs << "-DHAVE_PERMANENT_CLASSPATH" if RUBY_VERSION >= "3.3"
+
 # On older Rubies, there was no struct rb_native_thread. See private_vm_api_acccess.c for details.
 $defs << "-DNO_RB_NATIVE_THREAD" if RUBY_VERSION < "3.2"
 
@@ -207,6 +209,9 @@ $defs << "-DNO_THREAD_TID" if RUBY_VERSION < "3.1"
 # On older Rubies, there was no jit_return member on the rb_control_frame_t struct
 $defs << "-DNO_JIT_RETURN" if RUBY_VERSION < "3.1"
 
+# internal/class.h is available since 3.0
+$defs << "-DNO_INTERNAL_CLASS_HEADER_INCLUDE" if RUBY_VERSION < "3"
+
 # On older Rubies, there are no Ractors
 $defs << "-DNO_RACTORS" if RUBY_VERSION < "3"
 

data/ext/datadog_profiling_native_extension/native_extension_helpers.rb

@@ -80,15 +80,15 @@ module Datadog
           "For help solving this issue, please contact Datadog support at",
           "<https://docs.datadoghq.com/help/>.",
           "You can also check out the Continuous Profiler troubleshooting page at",
-          "<https://dtdg.co/ruby-profiler-troubleshooting>."
+          "<https://dtdg.co/ruby-profiler-troubleshooting>.",
         ].freeze
 
         GET_IN_TOUCH = [
-          "Get in touch with us if you're interested in profiling your app!"
+          "Get in touch with us if you're interested in profiling your app!",
         ].freeze
 
         UPGRADE_RUBY = [
-          "Upgrade to a modern Ruby to enable profiling for your app."
+          "Upgrade to a modern Ruby to enable profiling for your app.",
         ].freeze
 
         # Validation for this check is done in extconf.rb because it relies on mkmf