datadog 2.12.1 → 2.19.0

data/ext/datadog_profiling_native_extension/heap_recorder.h

@@ -34,7 +34,7 @@ typedef struct {
 
   // The class of the object that we're tracking.
   // NOTE: This is optional and will be set to NULL if not set.
-  char* class;
+  ddog_prof_ManagedStringId class;
 
   // The GC allocation gen in which we saw this object being allocated.
   //
@@ -59,7 +59,7 @@ typedef struct {
 } heap_recorder_iteration_data;
 
 // Initialize a new heap recorder.
-heap_recorder* heap_recorder_new(void);
+heap_recorder* heap_recorder_new(ddog_prof_ManagedStringStorage string_storage);
 
 // Free a previously initialized heap recorder.
 void heap_recorder_free(heap_recorder *heap_recorder);
@@ -164,10 +164,6 @@ VALUE heap_recorder_state_snapshot(heap_recorder *heap_recorder);
 
 // v--- TEST-ONLY APIs ---v
 
-// Assert internal hashing logic is valid for the provided locations and its
-// corresponding internal representations in heap recorder.
-void heap_recorder_testonly_assert_hash_matches(ddog_prof_Slice_Location locations);
-
 // Returns a Ruby string with a representation of internal data helpful to
 // troubleshoot issues such as unexpected test failures.
 VALUE heap_recorder_testonly_debug(heap_recorder *heap_recorder);
@@ -177,3 +173,5 @@ VALUE heap_recorder_testonly_is_object_recorded(heap_recorder *heap_recorder, VA
 
 // Used to ensure that a GC actually triggers an update of the objects
 void heap_recorder_testonly_reset_last_update(heap_recorder *heap_recorder);
+
+void heap_recorder_testonly_benchmark_intern(heap_recorder *heap_recorder, ddog_CharSlice string, int times, bool use_all);

data/ext/datadog_profiling_native_extension/http_transport.c

@@ -4,6 +4,7 @@
 #include "helpers.h"
 #include "libdatadog_helpers.h"
 #include "ruby_helpers.h"
+#include "encoded_profile.h"
 
 // Used to report profiling data to Datadog.
 // This file implements the native bits of the Datadog::Profiling::HttpTransport class
@@ -14,32 +15,22 @@ static VALUE error_symbol = Qnil; // :error in Ruby
 static VALUE library_version_string = Qnil;
 
 typedef struct {
-  ddog_prof_Exporter *exporter;
-  ddog_prof_Exporter_Request_BuildResult *build_result;
+  ddog_prof_ProfileExporter *exporter;
+  ddog_prof_Request_Result *build_result;
   ddog_CancellationToken *cancel_token;
-  ddog_prof_Exporter_SendResult result;
+  ddog_prof_Result_HttpStatus result;
   bool send_ran;
 } call_exporter_without_gvl_arguments;
 
 static inline ddog_ByteSlice byte_slice_from_ruby_string(VALUE string);
 static VALUE _native_validate_exporter(VALUE self, VALUE exporter_configuration);
-static ddog_prof_Exporter_NewResult create_exporter(VALUE exporter_configuration, VALUE tags_as_array);
-static VALUE handle_exporter_failure(ddog_prof_Exporter_NewResult exporter_result);
+static ddog_prof_ProfileExporter_Result create_exporter(VALUE exporter_configuration, VALUE tags_as_array);
+static VALUE handle_exporter_failure(ddog_prof_ProfileExporter_Result exporter_result);
 static VALUE _native_do_export(
   VALUE self,
   VALUE exporter_configuration,
   VALUE upload_timeout_milliseconds,
-  VALUE start_timespec_seconds,
-  VALUE start_timespec_nanoseconds,
-  VALUE finish_timespec_seconds,
-  VALUE finish_timespec_nanoseconds,
-  VALUE pprof_file_name,
-  VALUE pprof_data,
-  VALUE code_provenance_file_name,
-  VALUE code_provenance_data,
-  VALUE tags_as_array,
-  VALUE internal_metadata_json,
-  VALUE info_json
+  VALUE flush
 );
 static void *call_exporter_without_gvl(void *call_args);
 static void interrupt_exporter_call(void *cancel_token);
@@ -48,7 +39,7 @@ void http_transport_init(VALUE profiling_module) {
   VALUE http_transport_class = rb_define_class_under(profiling_module, "HttpTransport", rb_cObject);
 
   rb_define_singleton_method(http_transport_class, "_native_validate_exporter",  _native_validate_exporter, 1);
-  rb_define_singleton_method(http_transport_class, "_native_do_export",  _native_do_export, 13);
+  rb_define_singleton_method(http_transport_class, "_native_do_export",  _native_do_export, 3);
 
   ok_symbol = ID2SYM(rb_intern_const("ok"));
   error_symbol = ID2SYM(rb_intern_const("error"));
@@ -65,14 +56,14 @@ static inline ddog_ByteSlice byte_slice_from_ruby_string(VALUE string) {
 
 static VALUE _native_validate_exporter(DDTRACE_UNUSED VALUE _self, VALUE exporter_configuration) {
   ENFORCE_TYPE(exporter_configuration, T_ARRAY);
-  ddog_prof_Exporter_NewResult exporter_result = create_exporter(exporter_configuration, rb_ary_new());
+  ddog_prof_ProfileExporter_Result exporter_result = create_exporter(exporter_configuration, rb_ary_new());
 
   VALUE failure_tuple = handle_exporter_failure(exporter_result);
   if (!NIL_P(failure_tuple)) return failure_tuple;
 
   // We don't actually need the exporter for now -- we just wanted to validate that we could create it with the
   // settings we were given
-  ddog_prof_Exporter_drop(exporter_result.ok);
+  ddog_prof_Exporter_drop(&exporter_result.ok);
 
   return rb_ary_new_from_args(2, ok_symbol, Qnil);
 }
@@ -84,26 +75,21 @@ static ddog_prof_Endpoint endpoint_from(VALUE exporter_configuration) {
   ENFORCE_TYPE(exporter_working_mode, T_SYMBOL);
   ID working_mode = SYM2ID(exporter_working_mode);
 
-  ID agentless_id = rb_intern("agentless");
-  ID agent_id = rb_intern("agent");
-
-  if (working_mode != agentless_id && working_mode != agent_id) {
-    rb_raise(rb_eArgError, "Failed to initialize transport: Unexpected working mode, expected :agentless or :agent");
-  }
-
-  if (working_mode == agentless_id) {
+  if (working_mode == rb_intern("agentless")) {
     VALUE site = rb_ary_entry(exporter_configuration, 1);
     VALUE api_key = rb_ary_entry(exporter_configuration, 2);
 
     return ddog_prof_Endpoint_agentless(char_slice_from_ruby_string(site), char_slice_from_ruby_string(api_key));
-  } else { // agent_id
+  } else if (working_mode == rb_intern("agent")) {
     VALUE base_url = rb_ary_entry(exporter_configuration, 1);
 
     return ddog_prof_Endpoint_agent(char_slice_from_ruby_string(base_url));
+  } else {
+    rb_raise(rb_eArgError, "Failed to initialize transport: Unexpected working mode, expected :agentless or :agent");
   }
 }
 
-static ddog_prof_Exporter_NewResult create_exporter(VALUE exporter_configuration, VALUE tags_as_array) {
+static ddog_prof_ProfileExporter_Result create_exporter(VALUE exporter_configuration, VALUE tags_as_array) {
   ENFORCE_TYPE(exporter_configuration, T_ARRAY);
   ENFORCE_TYPE(tags_as_array, T_ARRAY);
 
@@ -117,7 +103,7 @@ static ddog_prof_Exporter_NewResult create_exporter(VALUE exporter_configuration
   ddog_CharSlice library_version = char_slice_from_ruby_string(library_version_string);
   ddog_CharSlice profiling_family = DDOG_CHARSLICE_C("ruby");
 
-  ddog_prof_Exporter_NewResult exporter_result =
+  ddog_prof_ProfileExporter_Result exporter_result =
     ddog_prof_Exporter_new(library_name, library_version, profiling_family, &tags, endpoint);
 
   ddog_Vec_Tag_drop(tags);
@@ -125,8 +111,12 @@ static ddog_prof_Exporter_NewResult create_exporter(VALUE exporter_configuration
   return exporter_result;
 }
 
-static VALUE handle_exporter_failure(ddog_prof_Exporter_NewResult exporter_result) {
-  return exporter_result.tag == DDOG_PROF_EXPORTER_NEW_RESULT_OK ?
+static void validate_token(ddog_CancellationToken token, const char *file, int line) {
+  if (token.inner == NULL) rb_raise(rb_eRuntimeError, "Unexpected: Validation token was empty at %s:%d", file, line);
+}
+
+static VALUE handle_exporter_failure(ddog_prof_ProfileExporter_Result exporter_result) {
+  return exporter_result.tag == DDOG_PROF_PROFILE_EXPORTER_RESULT_OK_HANDLE_PROFILE_EXPORTER ?
     Qnil :
     rb_ary_new_from_args(2, error_symbol, get_error_details_and_drop(&exporter_result.err));
 }
@@ -134,39 +124,37 @@ static VALUE handle_exporter_failure(ddog_prof_Exporter_NewResult exporter_resul
 // Note: This function handles a bunch of libdatadog dynamically-allocated objects, so it MUST not use any Ruby APIs
 // which can raise exceptions, otherwise the objects will be leaked.
 static VALUE perform_export(
-  ddog_prof_Exporter *exporter,
-  ddog_Timespec start,
-  ddog_Timespec finish,
+  ddog_prof_ProfileExporter *exporter,
+  ddog_prof_EncodedProfile *profile,
   ddog_prof_Exporter_Slice_File files_to_compress_and_export,
-  ddog_prof_Exporter_Slice_File files_to_export_unmodified,
-  ddog_Vec_Tag *additional_tags,
   ddog_CharSlice internal_metadata,
   ddog_CharSlice info
 ) {
-  ddog_prof_ProfiledEndpointsStats *endpoints_stats = NULL; // Not in use yet
-  ddog_prof_Exporter_Request_BuildResult build_result = ddog_prof_Exporter_Request_build(
+  ddog_prof_Request_Result build_result = ddog_prof_Exporter_Request_build(
     exporter,
-    start,
-    finish,
+    profile,
     files_to_compress_and_export,
-    files_to_export_unmodified,
-    additional_tags,
-    endpoints_stats,
+    /* files_to_export_unmodified: */ ddog_prof_Exporter_Slice_File_empty(),
+    /* optional_additional_tags: */ NULL,
     &internal_metadata,
     &info
   );
 
-  if (build_result.tag == DDOG_PROF_EXPORTER_REQUEST_BUILD_RESULT_ERR) {
+  if (build_result.tag == DDOG_PROF_REQUEST_RESULT_ERR_HANDLE_REQUEST) {
     ddog_prof_Exporter_drop(exporter);
     return rb_ary_new_from_args(2, error_symbol, get_error_details_and_drop(&build_result.err));
   }
 
-  ddog_CancellationToken *cancel_token = ddog_CancellationToken_new();
+  ddog_CancellationToken cancel_token_request = ddog_CancellationToken_new();
+  ddog_CancellationToken cancel_token_interrupt = ddog_CancellationToken_clone(&cancel_token_request);
+
+  validate_token(cancel_token_request, __FILE__, __LINE__);
+  validate_token(cancel_token_interrupt, __FILE__, __LINE__);
 
   // We'll release the Global VM Lock while we're calling send, so that the Ruby VM can continue to work while this
   // is pending
   call_exporter_without_gvl_arguments args =
-    {.exporter = exporter, .build_result = &build_result, .cancel_token = cancel_token, .send_ran = false};
+    {.exporter = exporter, .build_result = &build_result, .cancel_token = &cancel_token_request, .send_ran = false};
 
   // We use rb_thread_call_without_gvl2 instead of rb_thread_call_without_gvl as the gvl2 variant never raises any
   // exceptions.
@@ -183,14 +171,15 @@ static VALUE perform_export(
   int pending_exception = 0;
 
   while (!args.send_ran && !pending_exception) {
-    rb_thread_call_without_gvl2(call_exporter_without_gvl, &args, interrupt_exporter_call, cancel_token);
+    rb_thread_call_without_gvl2(call_exporter_without_gvl, &args, interrupt_exporter_call, &cancel_token_interrupt);
 
     // To make sure we don't leak memory, we never check for pending exceptions if send ran
     if (!args.send_ran) pending_exception = check_if_pending_exception();
   }
 
   // Cleanup exporter and token, no longer needed
-  ddog_CancellationToken_drop(cancel_token);
+  ddog_CancellationToken_drop(&cancel_token_request);
+  ddog_CancellationToken_drop(&cancel_token_interrupt);
   ddog_prof_Exporter_drop(exporter);
 
   if (pending_exception) {
@@ -203,10 +192,10 @@ static VALUE perform_export(
 
   // The request itself does not need to be freed as libdatadog takes ownership of it as part of sending.
 
-  ddog_prof_Exporter_SendResult result = args.result;
+  ddog_prof_Result_HttpStatus result = args.result;
 
-  return result.tag == DDOG_PROF_EXPORTER_SEND_RESULT_HTTP_RESPONSE ?
-    rb_ary_new_from_args(2, ok_symbol, UINT2NUM(result.http_response.code)) :
+  return result.tag == DDOG_PROF_RESULT_HTTP_STATUS_OK_HTTP_STATUS ?
+    rb_ary_new_from_args(2, ok_symbol, UINT2NUM(result.ok.code)) :
     rb_ary_new_from_args(2, error_symbol, get_error_details_and_drop(&result.err));
 }
 
@@ -214,26 +203,19 @@ static VALUE _native_do_export(
   DDTRACE_UNUSED VALUE _self,
   VALUE exporter_configuration,
   VALUE upload_timeout_milliseconds,
-  VALUE start_timespec_seconds,
-  VALUE start_timespec_nanoseconds,
-  VALUE finish_timespec_seconds,
-  VALUE finish_timespec_nanoseconds,
-  VALUE pprof_file_name,
-  VALUE pprof_data,
-  VALUE code_provenance_file_name,
-  VALUE code_provenance_data,
-  VALUE tags_as_array,
-  VALUE internal_metadata_json,
-  VALUE info_json
+  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 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);
+
   ENFORCE_TYPE(upload_timeout_milliseconds, T_FIXNUM);
-  ENFORCE_TYPE(start_timespec_seconds, T_FIXNUM);
-  ENFORCE_TYPE(start_timespec_nanoseconds, T_FIXNUM);
-  ENFORCE_TYPE(finish_timespec_seconds, T_FIXNUM);
-  ENFORCE_TYPE(finish_timespec_nanoseconds, T_FIXNUM);
-  ENFORCE_TYPE(pprof_file_name, T_STRING);
-  ENFORCE_TYPE(pprof_data, T_STRING);
+  enforce_encoded_profile_instance(encoded_profile);
   ENFORCE_TYPE(code_provenance_file_name, T_STRING);
+  ENFORCE_TYPE(tags_as_array, T_ARRAY);
   ENFORCE_TYPE(internal_metadata_json, T_STRING);
   ENFORCE_TYPE(info_json, T_STRING);
 
@@ -243,23 +225,9 @@ static VALUE _native_do_export(
 
   uint64_t timeout_milliseconds = NUM2ULONG(upload_timeout_milliseconds);
 
-  ddog_Timespec start =
-    {.seconds = NUM2LONG(start_timespec_seconds), .nanoseconds = NUM2UINT(start_timespec_nanoseconds)};
-  ddog_Timespec finish =
-    {.seconds = NUM2LONG(finish_timespec_seconds), .nanoseconds = NUM2UINT(finish_timespec_nanoseconds)};
-
   int to_compress_length = have_code_provenance ? 1 : 0;
   ddog_prof_Exporter_File to_compress[to_compress_length];
-  int already_compressed_length = 1; // pprof
-  ddog_prof_Exporter_File already_compressed[already_compressed_length];
-
   ddog_prof_Exporter_Slice_File files_to_compress_and_export = {.ptr = to_compress, .len = to_compress_length};
-  ddog_prof_Exporter_Slice_File files_to_export_unmodified = {.ptr = already_compressed, .len = already_compressed_length};
-
-  already_compressed[0] = (ddog_prof_Exporter_File) {
-    .name = char_slice_from_ruby_string(pprof_file_name),
-    .file = byte_slice_from_ruby_string(pprof_data),
-  };
 
   if (have_code_provenance) {
     to_compress[0] = (ddog_prof_Exporter_File) {
@@ -268,32 +236,28 @@ static VALUE _native_do_export(
     };
   }
 
-  ddog_Vec_Tag *null_additional_tags = NULL;
   ddog_CharSlice internal_metadata = char_slice_from_ruby_string(internal_metadata_json);
   ddog_CharSlice info = char_slice_from_ruby_string(info_json);
 
-  ddog_prof_Exporter_NewResult exporter_result = create_exporter(exporter_configuration, tags_as_array);
+  ddog_prof_ProfileExporter_Result exporter_result = create_exporter(exporter_configuration, tags_as_array);
   // Note: Do not add anything that can raise exceptions after this line, as otherwise the exporter memory will leak
 
   VALUE failure_tuple = handle_exporter_failure(exporter_result);
   if (!NIL_P(failure_tuple)) return failure_tuple;
 
-  ddog_prof_MaybeError timeout_result = ddog_prof_Exporter_set_timeout(exporter_result.ok, timeout_milliseconds);
-  if (timeout_result.tag == DDOG_PROF_OPTION_ERROR_SOME_ERROR) {
+  ddog_VoidResult timeout_result = ddog_prof_Exporter_set_timeout(&exporter_result.ok, timeout_milliseconds);
+  if (timeout_result.tag == DDOG_VOID_RESULT_ERR) {
     // NOTE: Seems a bit harsh to fail the upload if we can't set a timeout. OTOH, this is only expected to fail
     // if the exporter is not well built. Because such a situation should already be caught above I think it's
     // preferable to leave this here as a virtually unreachable exception rather than ignoring it.
-    ddog_prof_Exporter_drop(exporter_result.ok);
-    return rb_ary_new_from_args(2, error_symbol, get_error_details_and_drop(&timeout_result.some));
+    ddog_prof_Exporter_drop(&exporter_result.ok);
+    return rb_ary_new_from_args(2, error_symbol, get_error_details_and_drop(&timeout_result.err));
   }
 
   return perform_export(
-    exporter_result.ok,
-    start,
-    finish,
+    &exporter_result.ok,
+    to_ddog_prof_EncodedProfile(encoded_profile),
     files_to_compress_and_export,
-    files_to_export_unmodified,
-    null_additional_tags,
     internal_metadata,
     info
   );
@@ -310,5 +274,7 @@ static void *call_exporter_without_gvl(void *call_args) {
 
 // Called by Ruby when it wants to interrupt call_exporter_without_gvl above, e.g. when the app wants to exit cleanly
 static void interrupt_exporter_call(void *cancel_token) {
+  // TODO: False here can mean two things: it was already cancelled OR it failed to cancel.
+  // Would be nice to change libdatadog to be able to distinguish between them...
   ddog_CancellationToken_cancel((ddog_CancellationToken *) cancel_token);
 }

data/ext/datadog_profiling_native_extension/libdatadog_helpers.c

@@ -60,3 +60,25 @@ size_t read_ddogerr_string_and_drop(ddog_Error *error, char *string, size_t capa
   ddog_Error_drop(error);
   return error_msg_size;
 }
+
+ddog_prof_ManagedStringId intern_or_raise(ddog_prof_ManagedStringStorage string_storage, ddog_CharSlice string) {
+  if (string.len == 0) return (ddog_prof_ManagedStringId) { 0 }; // Id 0 is always an empty string, no need to ask
+
+  ddog_prof_ManagedStringStorageInternResult intern_result = ddog_prof_ManagedStringStorage_intern(string_storage, string);
+  if (intern_result.tag == DDOG_PROF_MANAGED_STRING_STORAGE_INTERN_RESULT_ERR) {
+    rb_raise(rb_eRuntimeError, "Failed to intern string: %"PRIsVALUE, get_error_details_and_drop(&intern_result.err));
+  }
+  return intern_result.ok;
+}
+
+void intern_all_or_raise(
+  ddog_prof_ManagedStringStorage string_storage,
+  ddog_prof_Slice_CharSlice strings,
+  ddog_prof_ManagedStringId *output_ids,
+  uintptr_t output_ids_size
+) {
+  ddog_prof_MaybeError result = ddog_prof_ManagedStringStorage_intern_all(string_storage, strings, output_ids, output_ids_size);
+  if (result.tag == DDOG_PROF_OPTION_ERROR_SOME_ERROR) {
+    rb_raise(rb_eRuntimeError, "Failed to intern_all: %"PRIsVALUE, get_error_details_and_drop(&result.some));
+  }
+}

data/ext/datadog_profiling_native_extension/libdatadog_helpers.h

@@ -18,8 +18,11 @@ size_t read_ddogerr_string_and_drop(ddog_Error *error, char *string, size_t capa
 const char *ruby_value_type_to_string(enum ruby_value_type type);
 ddog_CharSlice ruby_value_type_to_char_slice(enum ruby_value_type type);
 
-// Returns a dynamically allocated string from the provided char slice.
-// WARN: The returned string must be explicitly freed with ruby_xfree.
-static inline char* string_from_char_slice(ddog_CharSlice slice) {
-  return ruby_strndup(slice.ptr, slice.len);
-}
+ddog_prof_ManagedStringId intern_or_raise(ddog_prof_ManagedStringStorage string_storage, ddog_CharSlice string);
+
+void intern_all_or_raise(
+  ddog_prof_ManagedStringStorage string_storage,
+  ddog_prof_Slice_CharSlice strings,
+  ddog_prof_ManagedStringId *output_ids,
+  uintptr_t output_ids_size
+);

data/ext/datadog_profiling_native_extension/private_vm_api_access.c

@@ -212,21 +212,6 @@ uint64_t native_thread_id_for(VALUE thread) {
   #endif
 }
 
-// Returns the stack depth by using the same approach as rb_profile_frames and backtrace_each: get the positions
-// of the end and current frame pointers and subtracting them.
-ptrdiff_t stack_depth_for(VALUE thread) {
-  const rb_execution_context_t *ec = thread_struct_from_object(thread)->ec;
-  const rb_control_frame_t *cfp = ec->cfp, *end_cfp = RUBY_VM_END_CONTROL_FRAME(ec);
-
-  if (end_cfp == NULL) return 0;
-
-  // Skip dummy frame, as seen in `backtrace_each` (`vm_backtrace.c`) and our custom rb_profile_frames
-  // ( https://github.com/ruby/ruby/blob/4bd38e8120f2fdfdd47a34211720e048502377f1/vm_backtrace.c#L890-L914 )
-  end_cfp = RUBY_VM_NEXT_CONTROL_FRAME(end_cfp);
-
-  return end_cfp <= cfp ? 0 : end_cfp - cfp - 1;
-}
-
 // This was renamed in Ruby 3.2
 #if !defined(ccan_list_for_each) && defined(list_for_each)
   #define ccan_list_for_each list_for_each
@@ -312,6 +297,7 @@ VALUE thread_name_for(VALUE thread) {
 // to support our custom rb_profile_frames (see below)
 // Modifications:
 // * Support int first_lineno for Ruby 3.2.0+ (https://github.com/ruby/ruby/pull/6430)
+// * Validate iseq and pos before calling `rb_iseq_line_no` as a safety measure (see comment below for details)
 //
 // `node_id` gets used depending on Ruby VM compilation settings (USE_ISEQ_NODE_ID being defined).
 // To avoid getting false "unused argument" warnings in setups where it's not used, we need to do this weird dance
@@ -358,6 +344,18 @@ calc_pos(const rb_iseq_t *iseq, const VALUE *pc, int *lineno, int *node_id)
             __builtin_trap();
         }
 #endif
+
+        // In PROF-11475 we spotted a crash when calling `rb_iseq_line_no` from this method.
+        // We were only able to reproduce this issue on Ruby 2.6 and 2.7, not 2.5 or the 3.x series (tried 3.0, 3.2 and 3.4).
+        // Note that going out of bounds doesn't crash every time, as usual with C we may just read garbage or get lucky.
+        //
+        // For those problematic Rubies, we observed that when we try to take a sample in the middle of processing the
+        // VM `LEAVE` instruction, the value of `n` can violate the documented assumptions above and be
+        // `n > ISEQ_BODY(iseq)->iseq_size)`.
+        //
+        // To work around this and any other potential issues, we validate here that the bytecode position is sane.
+        if (RB_UNLIKELY(n < 0 || n > ISEQ_BODY(iseq)->iseq_size)) return 0;
+
         if (lineno) *lineno = rb_iseq_line_no(iseq, pos);
 #ifdef USE_ISEQ_NODE_ID
         if (node_id) *node_id = rb_iseq_node_id(iseq, pos);
@@ -402,6 +400,9 @@ calc_lineno(const rb_iseq_t *iseq, const VALUE *pc)
 // * Add frame_flags.same_frame and logic to skip redoing work if the buffer already contains the same data we're collecting
 // * Skipped use of rb_callable_method_entry_t (cme) for Ruby frames as it doesn't impact us.
 // * Imported fix from https://github.com/ruby/ruby/pull/8280 to keep us closer to upstream
+// * Added potential fix for https://github.com/ruby/ruby/pull/13643 (this one is a just-in-case, unclear if it happens
+//   for ddtrace)
+// * Reversed order of iteration to better enable caching
 //
 // What is rb_profile_frames?
 // `rb_profile_frames` is a Ruby VM debug API added for use by profilers for sampling the stack trace of a Ruby thread.
@@ -437,6 +438,16 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, frame_info *st
     // support sampling any thread (including the current) passed as an argument
     rb_thread_t *th = thread_struct_from_object(thread);
     const rb_execution_context_t *ec = th->ec;
+
+    // As of this writing, we don't support profiling with MN enabled, and this only happens in that mode, but as we
+    // probably want to experiment with it in the future, I've decided to import https://github.com/ruby/ruby/pull/9310
+    // here.
+    if (ec == NULL) return 0;
+
+    // I suspect this won't happen for ddtrace, but just-in-case we've imported a potential fix for
+    // https://github.com/ruby/ruby/pull/13643 by assuming that these can be NULL/zero with the cfp being non-NULL yet.
+    if (ec->vm_stack == NULL || ec->vm_stack_size == 0) return 0;
+
     const rb_control_frame_t *cfp = ec->cfp, *end_cfp = RUBY_VM_END_CONTROL_FRAME(ec);
     #ifndef NO_JIT_RETURN
       const rb_control_frame_t *top = cfp;
@@ -454,11 +465,6 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, frame_info *st
     // it from https://github.com/ruby/ruby/pull/7116 in a "just in case" kind of mindset.
     if (cfp == NULL) return 0;
 
-    // As of this writing, we don't support profiling with MN enabled, and this only happens in that mode, but as we
-    // probably want to experiment with it in the future, I've decided to import https://github.com/ruby/ruby/pull/9310
-    // here.
-    if (ec == NULL) return 0;
-
     // Fix: Skip dummy frame that shows up in main thread.
     //
     // According to a comment in `backtrace_each` (`vm_backtrace.c`), there's two dummy frames that we should ignore
@@ -475,7 +481,20 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, frame_info *st
     // See comment on `record_placeholder_stack_in_native_code` for a full explanation of what this means (and why we don't just return 0)
     if (end_cfp <= cfp) return PLACEHOLDER_STACK_IN_NATIVE_CODE;
 
-    for (i=0; i<limit && cfp != end_cfp; cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp)) {
+    // This is the position just after the top of the stack -- e.g. where a new frame pushed on the stack would end up.
+    const rb_control_frame_t *top_sentinel = RUBY_VM_NEXT_CONTROL_FRAME(cfp);
+
+    // We iterate the stack from bottom (beginning of thread) to the top (currently-active frame). This is different
+    // from upstream rb_profile_frames, but actually matches what `backtrace_each` does (yes, different Ruby VM APIs
+    // iterate in different directions).
+    // We do this to better take advantage of the `same_frame` caching mechanism: By starting from the bottom of the
+    // stack towards the top, we can usually keep most of the stack intact when the code is only going up and down
+    // a few methods at the top. Before this change, the cache was really only useful if between samples the app had
+    // not moved from the current stack, as adding or removing one frame would invalidate the existing cache (because
+    // every position would shift).
+    cfp = RUBY_VM_NEXT_CONTROL_FRAME(end_cfp);
+
+    for (i=0; i<limit && cfp != top_sentinel; cfp = RUBY_VM_NEXT_CONTROL_FRAME(cfp)) {
         if (cfp->iseq && !cfp->pc) {
           // Fix: Do nothing -- this frame should not be used
           //
@@ -561,6 +580,7 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, frame_info *st
 
                 stack_buffer[i].as.native_frame.caching_cme = (VALUE)cme;
                 stack_buffer[i].as.native_frame.method_id = cme->def->original_id;
+                stack_buffer[i].as.native_frame.function = cme->def->body.cfunc.func;
                 stack_buffer[i].is_ruby_frame = false;
                 i++;
             }

data/ext/datadog_profiling_native_extension/private_vm_api_access.h

@@ -18,16 +18,19 @@ typedef struct {
   rb_nativethread_id_t owner;
 } current_gvl_owner;
 
+// If a sample is kept around for later use, some of its fields need marking. Remember to
+// update the marking code in `sampling_buffer_mark` if new fields are added.
 typedef struct {
   union {
     struct {
-      VALUE iseq;
-      void *caching_pc; // For caching only
+      VALUE iseq; // Needs marking if kept around
+      void *caching_pc; // For caching validation/invalidation only (does not need marking)
       int line;
     } ruby_frame;
     struct {
-      VALUE caching_cme; // For caching only
+      VALUE caching_cme; // For caching validation/invalidation only (does not need marking)
       ID method_id;
+      void *function;
     } native_frame;
   } as;
   bool is_ruby_frame : 1;
@@ -38,7 +41,6 @@ rb_nativethread_id_t pthread_id_for(VALUE thread);
 bool is_current_thread_holding_the_gvl(void);
 current_gvl_owner gvl_owner(void);
 uint64_t native_thread_id_for(VALUE thread);
-ptrdiff_t stack_depth_for(VALUE thread);
 void ddtrace_thread_list(VALUE result_array);
 bool is_thread_alive(VALUE thread);
 VALUE thread_name_for(VALUE thread);

data/ext/datadog_profiling_native_extension/profiling.c

@@ -20,6 +20,7 @@ void collectors_dynamic_sampling_rate_init(VALUE profiling_module);
 void collectors_idle_sampling_helper_init(VALUE profiling_module);
 void collectors_stack_init(VALUE profiling_module);
 void collectors_thread_context_init(VALUE profiling_module);
+void encoded_profile_init(VALUE profiling_module);
 void http_transport_init(VALUE profiling_module);
 void stack_recorder_init(VALUE profiling_module);
 
@@ -61,6 +62,7 @@ void DDTRACE_EXPORT Init_datadog_profiling_native_extension(void) {
   collectors_idle_sampling_helper_init(profiling_module);
   collectors_stack_init(profiling_module);
   collectors_thread_context_init(profiling_module);
+  encoded_profile_init(profiling_module);
   http_transport_init(profiling_module);
   stack_recorder_init(profiling_module);
   unsafe_api_calls_check_init();

data/ext/datadog_profiling_native_extension/ruby_helpers.c

@@ -103,16 +103,6 @@ void raise_syserr(
   }
 }
 
-char* ruby_strndup(const char *str, size_t size) {
-  char *dup;
-
-  dup = xmalloc(size + 1);
-  memcpy(dup, str, size);
-  dup[size] = '\0';
-
-  return dup;
-}
-
 static VALUE _id2ref(VALUE obj_id) {
   // Call ::ObjectSpace._id2ref natively. It will raise if the id is no longer valid
   return rb_funcall(module_object_space, _id2ref_id, 1, obj_id);
@@ -122,9 +112,7 @@ static VALUE _id2ref_failure(DDTRACE_UNUSED VALUE _unused1, DDTRACE_UNUSED VALUE
   return Qfalse;
 }
 
-// Native wrapper to get an object ref from an id. Returns true on success and
-// writes the ref to the value pointer parameter if !NULL. False if id doesn't
-// reference a valid object (in which case value is not changed).
+// See notes on header for important details
 bool ruby_ref_from_id(VALUE obj_id, VALUE *value) {
   // Call ::ObjectSpace._id2ref natively. It will raise if the id is no longer valid
   // so we need to call it via rb_rescue2

data/ext/datadog_profiling_native_extension/ruby_helpers.h

@@ -67,20 +67,12 @@ NORETURN(void raise_syserr(
   const char *function_name
 ));
 
-// Alternative to ruby_strdup that takes a size argument.
-// Similar to C's strndup but slightly less smart as size is expected to
-// be smaller or equal to the real size of str (minus null termination if it
-// exists).
-// A new string will be returned with size+1 bytes and last byte set to '\0'.
-// The returned string must be freed explicitly.
-//
-// WARN: Cannot be used during GC or outside the GVL.
-char* ruby_strndup(const char *str, size_t size);
-
 // Native wrapper to get an object ref from an id. Returns true on success and
 // writes the ref to the value pointer parameter if !NULL. False if id doesn't
 // reference a valid object (in which case value is not changed).
-bool ruby_ref_from_id(size_t id, VALUE *value);
+//
+// Note: GVL can be released and other threads may get to run before this method returns
+bool ruby_ref_from_id(VALUE obj_id, VALUE *value);
 
 // Native wrapper to get the approximate/estimated current size of the passed
 // object.