ddtrace 1.20.0 → 1.23.0

data/ext/{ddtrace_profiling_native_extension → datadog_profiling_native_extension}/collectors_thread_context.c

@@ -82,6 +82,9 @@ static ID at_id_id;           // id of :@id in Ruby
 static ID at_resource_id;     // id of :@resource in Ruby
 static ID at_root_span_id;    // id of :@root_span in Ruby
 static ID at_type_id;         // id of :@type in Ruby
+static ID at_otel_values_id;  // id of :@otel_values in Ruby
+static ID at_parent_span_id_id; // id of :@parent_span_id in Ruby
+static ID at_datadog_trace_id;  // id of :@datadog_trace in Ruby
 
 // Contains state for a single ThreadContext instance
 struct thread_context_collector_state {
@@ -114,6 +117,8 @@ struct thread_context_collector_state {
   monotonic_to_system_epoch_state time_converter_state;
   // Used to identify the main thread, to give it a fallback name
   VALUE main_thread;
+  // Used when extracting trace identifiers from otel spans. Lazily initialized.
+  VALUE otel_current_span_key;
 
   struct stats {
     // Track how many garbage collection samples we've taken.
@@ -212,12 +217,20 @@ static long thread_id_for(VALUE thread);
 static VALUE _native_stats(VALUE self, VALUE collector_instance);
 static VALUE _native_gc_tracking(VALUE self, VALUE collector_instance);
 static void trace_identifiers_for(struct thread_context_collector_state *state, VALUE thread, struct trace_identifiers *trace_identifiers_result);
-static bool should_collect_resource(VALUE root_span_type);
+static bool should_collect_resource(VALUE root_span);
 static VALUE _native_reset_after_fork(DDTRACE_UNUSED VALUE self, VALUE collector_instance);
 static VALUE thread_list(struct thread_context_collector_state *state);
 static VALUE _native_sample_allocation(DDTRACE_UNUSED VALUE self, VALUE collector_instance, VALUE sample_weight, VALUE new_object);
 static VALUE _native_new_empty_thread(VALUE self);
 static ddog_CharSlice ruby_value_type_to_class_name(enum ruby_value_type type);
+static void ddtrace_otel_trace_identifiers_for(
+  struct thread_context_collector_state *state,
+  VALUE *active_trace,
+  VALUE *root_span,
+  VALUE *numeric_span_id,
+  VALUE active_span,
+  VALUE otel_values
+);
 
 void collectors_thread_context_init(VALUE profiling_module) {
   VALUE collectors_module = rb_define_module_under(profiling_module, "Collectors");
@@ -255,6 +268,9 @@ void collectors_thread_context_init(VALUE profiling_module) {
   at_resource_id = rb_intern_const("@resource");
   at_root_span_id = rb_intern_const("@root_span");
   at_type_id = rb_intern_const("@type");
+  at_otel_values_id = rb_intern_const("@otel_values");
+  at_parent_span_id_id = rb_intern_const("@parent_span_id");
+  at_datadog_trace_id = rb_intern_const("@datadog_trace");
 
   gc_profiling_init();
 }
@@ -282,6 +298,7 @@ static void thread_context_collector_typed_data_mark(void *state_ptr) {
   st_foreach(state->hash_map_per_thread_context, hash_map_per_thread_context_mark, 0 /* unused */);
   rb_gc_mark(state->thread_list_buffer);
   rb_gc_mark(state->main_thread);
+  rb_gc_mark(state->otel_current_span_key);
 }
 
 static void thread_context_collector_typed_data_free(void *state_ptr) {
@@ -334,6 +351,7 @@ static VALUE _native_new(VALUE klass) {
   state->allocation_type_enabled = true;
   state->time_converter_state = (monotonic_to_system_epoch_state) MONOTONIC_TO_SYSTEM_EPOCH_INITIALIZER;
   state->main_thread = rb_thread_main();
+  state->otel_current_span_key = Qnil;
   state->gc_tracking.wall_time_at_previous_gc_ns = INVALID_TIME;
   state->gc_tracking.wall_time_at_last_flushed_gc_event_ns = 0;
 
@@ -603,11 +621,14 @@ bool thread_context_collector_on_gc_finish(VALUE self_instance) {
   // Let the caller know if it should schedule a flush or not. Returning true every time would cause a lot of overhead
   // on the application (see GC tracking introduction at the top of the file), so instead we try to accumulate a few
   // samples first.
-  bool finished_major_gc = gc_profiling_has_major_gc_finished();
   bool over_flush_time_treshold =
     (wall_time_at_finish_ns - state->gc_tracking.wall_time_at_last_flushed_gc_event_ns) >= TIME_BETWEEN_GC_EVENTS_NS;
 
-  return finished_major_gc || over_flush_time_treshold;
+  if (over_flush_time_treshold) {
+    return true;
+  } else {
+    return gc_profiling_has_major_gc_finished();
+  }
 }
 
 // This function gets called after one or more GC work steps (calls to on_gc_start/on_gc_finish).
@@ -917,6 +938,7 @@ static VALUE _native_inspect(DDTRACE_UNUSED VALUE _self, VALUE collector_instanc
   ));
   rb_str_concat(result, rb_sprintf(" main_thread=%"PRIsVALUE, state->main_thread));
   rb_str_concat(result, rb_sprintf(" gc_tracking=%"PRIsVALUE, gc_tracking_as_ruby_hash(state)));
+  rb_str_concat(result, rb_sprintf(" otel_current_span_key=%"PRIsVALUE, state->otel_current_span_key));
 
   return result;
 }
@@ -1104,10 +1126,19 @@ static void trace_identifiers_for(struct thread_context_collector_state *state,
 
   VALUE root_span = rb_ivar_get(active_trace, at_root_span_id /* @root_span */);
   VALUE active_span = rb_ivar_get(active_trace, at_active_span_id /* @active_span */);
-  if (root_span == Qnil || active_span == Qnil) return;
+  // Note: On Ruby 3.x `rb_attr_get` is exactly the same as `rb_ivar_get`. For Ruby 2.x, the difference is that
+  // `rb_ivar_get` can trigger "warning: instance variable @otel_values not initialized" if warnings are enabled and
+  // opentelemetry is not in use, whereas `rb_attr_get` does the lookup without generating the warning.
+  VALUE otel_values = rb_attr_get(active_trace, at_otel_values_id /* @otel_values */);
+
+  VALUE numeric_span_id = Qnil;
+
+  if (otel_values != Qnil) ddtrace_otel_trace_identifiers_for(state, &active_trace, &root_span, &numeric_span_id, active_span, otel_values);
+
+  if (root_span == Qnil || (active_span == Qnil && numeric_span_id == Qnil)) return;
 
   VALUE numeric_local_root_span_id = rb_ivar_get(root_span, at_id_id /* @id */);
-  VALUE numeric_span_id = rb_ivar_get(active_span, at_id_id /* @id */);
+  if (active_span != Qnil && numeric_span_id == Qnil) numeric_span_id = rb_ivar_get(active_span, at_id_id /* @id */);
   if (numeric_local_root_span_id == Qnil || numeric_span_id == Qnil) return;
 
   trace_identifiers_result->local_root_span_id = NUM2ULL(numeric_local_root_span_id);
@@ -1115,10 +1146,7 @@ static void trace_identifiers_for(struct thread_context_collector_state *state,
 
   trace_identifiers_result->valid = true;
 
-  if (!state->endpoint_collection_enabled) return;
-
-  VALUE root_span_type = rb_ivar_get(root_span, at_type_id /* @type */);
-  if (root_span_type == Qnil || !should_collect_resource(root_span_type)) return;
+  if (!state->endpoint_collection_enabled || !should_collect_resource(root_span)) return;
 
   VALUE trace_resource = rb_ivar_get(active_trace, at_resource_id /* @resource */);
   if (RB_TYPE_P(trace_resource, T_STRING)) {
@@ -1129,21 +1157,32 @@ static void trace_identifiers_for(struct thread_context_collector_state *state,
   }
 }
 
-// We only collect the resource for spans of types:
+// We opt-in to collecting the resource for spans of types:
 // * 'web', for web requests
-// * proxy', used by the rack integration with request_queuing: true (e.g. also represents a web request)
+// * 'proxy', used by the rack integration with request_queuing: true (e.g. also represents a web request)
+// * 'worker', used for sidekiq and similar background job processors
 //
-// NOTE: Currently we're only interested in HTTP service endpoints. Over time, this list may be expanded.
+// Over time, this list may be expanded.
 // Resources MUST NOT include personal identifiable information (PII); this should not be the case with
 // ddtrace integrations, but worth mentioning just in case :)
-static bool should_collect_resource(VALUE root_span_type) {
+static bool should_collect_resource(VALUE root_span) {
+  VALUE root_span_type = rb_ivar_get(root_span, at_type_id /* @type */);
+  if (root_span_type == Qnil) return false;
   ENFORCE_TYPE(root_span_type, T_STRING);
 
   int root_span_type_length = RSTRING_LEN(root_span_type);
   const char *root_span_type_value = StringValuePtr(root_span_type);
 
-  return (root_span_type_length == strlen("web") && (memcmp("web", root_span_type_value, strlen("web")) == 0)) ||
+  bool is_web_request =
+    (root_span_type_length == strlen("web") && (memcmp("web", root_span_type_value, strlen("web")) == 0)) ||
     (root_span_type_length == strlen("proxy") && (memcmp("proxy", root_span_type_value, strlen("proxy")) == 0));
+
+  if (is_web_request) return true;
+
+  bool is_worker_request =
+    (root_span_type_length == strlen("worker") && (memcmp("worker", root_span_type_value, strlen("worker")) == 0));
+
+  return is_worker_request;
 }
 
 // After the Ruby VM forks, this method gets called in the child process to clean up any leftover state from the parent.
@@ -1299,3 +1338,65 @@ static ddog_CharSlice ruby_value_type_to_class_name(enum ruby_value_type type) {
                   default: return DDOG_CHARSLICE_C("(VM Internal, Missing class)");
   }
 }
+
+static VALUE get_otel_current_span_key(struct thread_context_collector_state *state) {
+  if (state->otel_current_span_key == Qnil) {
+    VALUE datadog_module = rb_const_get(rb_cObject, rb_intern("Datadog"));
+    VALUE opentelemetry_module = rb_const_get(datadog_module, rb_intern("OpenTelemetry"));
+    VALUE api_module = rb_const_get(opentelemetry_module, rb_intern("API"));
+    VALUE context_module = rb_const_get(api_module, rb_intern_const("Context"));
+    VALUE current_span_key = rb_const_get(context_module, rb_intern_const("CURRENT_SPAN_KEY"));
+
+    if (current_span_key == Qnil) {
+      rb_raise(rb_eRuntimeError, "Unexpected: Missing Datadog::OpenTelemetry::API::Context::CURRENT_SPAN_KEY");
+    }
+
+    state->otel_current_span_key = current_span_key;
+  }
+
+  return state->otel_current_span_key;
+}
+
+// This method gets used when ddtrace is being used indirectly via the otel APIs. Information gets stored slightly
+// differently, and this codepath handles it.
+static void ddtrace_otel_trace_identifiers_for(
+  struct thread_context_collector_state *state,
+  VALUE *active_trace,
+  VALUE *root_span,
+  VALUE *numeric_span_id,
+  VALUE active_span,
+  VALUE otel_values
+) {
+  VALUE resolved_numeric_span_id =
+    active_span == Qnil ?
+      // For traces started from otel spans, the span id will be empty, and the @parent_span_id has the right value
+      rb_ivar_get(*active_trace, at_parent_span_id_id /* @parent_span_id */) :
+      // Regular span created by ddtrace
+      rb_ivar_get(active_span, at_id_id /* @id */);
+
+  if (resolved_numeric_span_id == Qnil) return;
+
+  VALUE otel_current_span_key = get_otel_current_span_key(state);
+  VALUE current_trace = *active_trace;
+
+  // ddtrace uses a different structure when spans are created from otel, where each otel span will have a unique ddtrace
+  // trace and span representing it. Each ddtrace trace is then connected to the previous otel span, forming a linked
+  // list. The local root span is going to be the trace/span we find at the end of this linked list.
+  while (otel_values != Qnil) {
+    VALUE otel_span = rb_hash_lookup(otel_values, otel_current_span_key);
+    if (otel_span == Qnil) break;
+    VALUE next_trace = rb_ivar_get(otel_span, at_datadog_trace_id);
+    if (next_trace == Qnil) break;
+
+    current_trace = next_trace;
+    otel_values = rb_ivar_get(current_trace, at_otel_values_id /* @otel_values */);
+  }
+
+  // We found the last trace in the linked list. This contains the local root span
+  VALUE resolved_root_span = rb_ivar_get(current_trace, at_root_span_id /* @root_span */);
+  if (resolved_root_span == Qnil) return;
+
+  *root_span = resolved_root_span;
+  *active_trace = current_trace;
+  *numeric_span_id = resolved_numeric_span_id;
+}

data/ext/{ddtrace_profiling_native_extension → datadog_profiling_native_extension}/extconf.rb

@@ -100,7 +100,7 @@ add_compiler_flag '-Wno-declaration-after-statement'
 add_compiler_flag '-Werror-implicit-function-declaration'
 
 # The native extension is not intended to expose any symbols/functions for other native libraries to use;
-# the sole exception being `Init_ddtrace_profiling_native_extension` which needs to be visible for Ruby to call it when
+# the sole exception being `Init_datadog_profiling_native_extension` which needs to be visible for Ruby to call it when
 # it `dlopen`s the library.
 #
 # By setting this compiler flag, we tell it to assume that everything is private unless explicitly stated.
@@ -237,7 +237,7 @@ Logging.message("[ddtrace] After pkg-config $LDFLAGS were set to: #{$LDFLAGS.ins
 # This makes it easier for development (avoids "oops I forgot to rebuild when I switched my Ruby") and ensures that
 # the wrong library is never loaded.
 # When requiring, we need to use the exact same string, including the version and the platform.
-EXTENSION_NAME = "ddtrace_profiling_native_extension.#{RUBY_VERSION}_#{RUBY_PLATFORM}".freeze
+EXTENSION_NAME = "datadog_profiling_native_extension.#{RUBY_VERSION}_#{RUBY_PLATFORM}".freeze
 
 if Datadog::Profiling::NativeExtensionHelpers::CAN_USE_MJIT_HEADER
   mjit_header_file_name = "rb_mjit_min_header-#{RUBY_VERSION}.h"

data/ext/{ddtrace_profiling_native_extension → datadog_profiling_native_extension}/heap_recorder.c

@@ -10,6 +10,13 @@
   #define CAN_APPLY_GC_FORCE_RECYCLE_BUG_WORKAROUND
 #endif
 
+// Minimum age (in GC generations) of heap objects we want to include in heap
+// recorder iterations. Object with age 0 represent objects that have yet to undergo
+// a GC and, thus, may just be noise/trash at instant of iteration and are usually not
+// relevant for heap profiles as the great majority should be trivially reclaimed
+// during the next GC.
+#define ITERATION_MIN_AGE 1
+
 // A compact representation of a stacktrace frame for a heap allocation.
 typedef struct {
   char *name;
@@ -137,6 +144,11 @@ struct heap_recorder {
   // mutation of the data so iteration can occur without acquiring a lock.
   // NOTE: Contrary to object_records, this table has no ownership of its data.
   st_table *object_records_snapshot;
+  // The GC gen/epoch/count in which we prepared the current iteration.
+  //
+  // This enables us to calculate the age of iterated objects in the above snapshot by
+  // comparing it against an object's alloc_gen.
+  size_t iteration_gen;
 
   // Data for a heap recording that was started but not yet ended
   recording active_recording;
@@ -146,6 +158,13 @@ struct heap_recorder {
 
   // Sampling state
   uint num_recordings_skipped;
+
+  struct stats_last_update {
+    size_t objects_alive;
+    size_t objects_dead;
+    size_t objects_skipped;
+    size_t objects_frozen;
+  } stats_last_update;
 };
 static heap_record* get_or_create_heap_record(heap_recorder*, ddog_prof_Slice_Location);
 static void cleanup_heap_record_if_unused(heap_recorder*, heap_record*);
@@ -353,11 +372,16 @@ void heap_recorder_prepare_iteration(heap_recorder *heap_recorder) {
     return;
   }
 
+  heap_recorder->iteration_gen = rb_gc_count();
+
   if (heap_recorder->object_records_snapshot != NULL) {
     // we could trivially handle this but we raise to highlight and catch unexpected usages.
     rb_raise(rb_eRuntimeError, "New heap recorder iteration prepared without the previous one having been finished.");
   }
 
+  // Reset last update stats, we'll be building them from scratch during the st_foreach call below
+  heap_recorder->stats_last_update = (struct stats_last_update) {};
+
   st_foreach(heap_recorder->object_records, st_object_record_update, (st_data_t) heap_recorder);
 
   heap_recorder->object_records_snapshot = st_copy(heap_recorder->object_records);
@@ -413,6 +437,22 @@ bool heap_recorder_for_each_live_object(
   return true;
 }
 
+VALUE heap_recorder_state_snapshot(heap_recorder *heap_recorder) {
+  VALUE arguments[] = {
+    ID2SYM(rb_intern("num_object_records")), /* => */ LONG2NUM(heap_recorder->object_records->num_entries),
+    ID2SYM(rb_intern("num_heap_records")),   /* => */ LONG2NUM(heap_recorder->heap_records->num_entries),
+
+    // Stats as of last update
+    ID2SYM(rb_intern("last_update_objects_alive")), /* => */ LONG2NUM(heap_recorder->stats_last_update.objects_alive),
+    ID2SYM(rb_intern("last_update_objects_dead")), /* => */ LONG2NUM(heap_recorder->stats_last_update.objects_dead),
+    ID2SYM(rb_intern("last_update_objects_skipped")), /* => */ LONG2NUM(heap_recorder->stats_last_update.objects_skipped),
+    ID2SYM(rb_intern("last_update_objects_frozen")), /* => */ LONG2NUM(heap_recorder->stats_last_update.objects_frozen),
+  };
+  VALUE hash = rb_hash_new();
+  for (long unsigned int i = 0; i < VALUE_COUNT(arguments); i += 2) rb_hash_aset(hash, arguments[i], arguments[i+1]);
+  return hash;
+}
+
 void heap_recorder_testonly_assert_hash_matches(ddog_prof_Slice_Location locations) {
   heap_stack *stack = heap_stack_new(locations);
   heap_record_key stack_based_key = (heap_record_key) {
@@ -459,6 +499,13 @@ static int st_object_record_entry_free(DDTRACE_UNUSED st_data_t key, st_data_t v
   return ST_DELETE;
 }
 
+// Check to see if an object should not be included in a heap recorder iteration.
+// This centralizes the checking logic to ensure it's equally applied between
+// preparation and iteration codepaths.
+static inline bool should_exclude_from_iteration(object_record *obj_record) {
+  return obj_record->object_data.gen_age < ITERATION_MIN_AGE;
+}
+
 static int st_object_record_update(st_data_t key, st_data_t value, st_data_t extra_arg) {
   long obj_id = (long) key;
   object_record *record = (object_record*) value;
@@ -466,9 +513,24 @@ static int st_object_record_update(st_data_t key, st_data_t value, st_data_t ext
 
   VALUE ref;
 
+  size_t iteration_gen = recorder->iteration_gen;
+  size_t alloc_gen = record->object_data.alloc_gen;
+  // Guard against potential overflows given unsigned types here.
+  record->object_data.gen_age = alloc_gen < iteration_gen ? iteration_gen - alloc_gen : 0;
+
+  if (should_exclude_from_iteration(record)) {
+    // If an object won't be included in the current iteration, there's
+    // no point checking for liveness or updating its size, so exit early.
+    // NOTE: This means that there should be an equivalent check during actual
+    //       iteration otherwise we'd iterate/expose stale object data.
+    recorder->stats_last_update.objects_skipped++;
+    return ST_CONTINUE;
+  }
+
   if (!ruby_ref_from_id(LONG2NUM(obj_id), &ref)) {
     // Id no longer associated with a valid ref. Need to delete this object record!
     on_committed_object_record_cleanup(recorder, record);
+    recorder->stats_last_update.objects_dead++;
     return ST_DELETE;
   }
 
@@ -503,6 +565,7 @@ static int st_object_record_update(st_data_t key, st_data_t value, st_data_t ext
       RB_FL_SET(ref, RUBY_FL_SEEN_OBJ_ID);
 
       on_committed_object_record_cleanup(recorder, record);
+      recorder->stats_last_update.objects_dead++;
       return ST_DELETE;
     }
 
@@ -516,6 +579,11 @@ static int st_object_record_update(st_data_t key, st_data_t value, st_data_t ext
     record->object_data.is_frozen = RB_OBJ_FROZEN(ref);
   }
 
+  recorder->stats_last_update.objects_alive++;
+  if (record->object_data.is_frozen) {
+    recorder->stats_last_update.objects_frozen++;
+  }
+
   return ST_CONTINUE;
 }
 
@@ -525,8 +593,16 @@ static int st_object_records_iterate(DDTRACE_UNUSED st_data_t key, st_data_t val
   const heap_stack *stack = record->heap_record->stack;
   iteration_context *context = (iteration_context*) extra;
 
-  ddog_prof_Location *locations = context->heap_recorder->reusable_locations;
+  const heap_recorder *recorder = context->heap_recorder;
+
+  if (should_exclude_from_iteration(record)) {
+    // Skip objects that should not be included in iteration
+    // NOTE: This matches the short-circuiting condition in st_object_record_update
+    //       and prevents iteration over stale objects.
+    return ST_CONTINUE;
+  }
 
+  ddog_prof_Location *locations = recorder->reusable_locations;
   for (uint16_t i = 0; i < stack->frames_len; i++) {
     const heap_frame *frame = &stack->frames[i];
     ddog_prof_Location *location = &locations[i];
@@ -725,9 +801,10 @@ void object_record_free(object_record *record) {
 
 VALUE object_record_inspect(object_record *record) {
   heap_frame top_frame = record->heap_record->stack->frames[0];
-  VALUE inspect = rb_sprintf("obj_id=%ld weight=%d size=%zu location=%s:%d alloc_gen=%zu ",
-      record->obj_id, record->object_data.weight, record->object_data.size, top_frame.filename,
-      (int) top_frame.line, record->object_data.alloc_gen);
+  live_object_data object_data = record->object_data;
+  VALUE inspect = rb_sprintf("obj_id=%ld weight=%d size=%zu location=%s:%d alloc_gen=%zu gen_age=%zu frozen=%d ",
+      record->obj_id, object_data.weight, object_data.size, top_frame.filename,
+      (int) top_frame.line, object_data.alloc_gen, object_data.gen_age, object_data.is_frozen);
 
   const char *class = record->object_data.class;
   if (class != NULL) {

data/ext/{ddtrace_profiling_native_extension → datadog_profiling_native_extension}/heap_recorder.h

@@ -27,7 +27,9 @@ typedef struct live_object_data {
   //          could be seen as being representative of 50 objects.
   unsigned int weight;
 
-  // Size of this object on last flush/update.
+  // Size of this object in memory.
+  // NOTE: This only gets updated during heap_recorder_prepare_iteration and only
+  //       for those objects that meet the minimum iteration age requirements.
   size_t size;
 
   // The class of the object that we're tracking.
@@ -39,6 +41,10 @@ typedef struct live_object_data {
   // This enables us to calculate the age of this object in terms of GC executions.
   size_t alloc_gen;
 
+  // The age of this object in terms of GC generations.
+  // NOTE: This only gets updated during heap_recorder_prepare_iteration
+  size_t gen_age;
+
   // Whether this object was previously seen as being frozen. If this is the case,
   // we'll skip any further size updates since frozen objects are supposed to be
   // immutable.
@@ -144,6 +150,11 @@ bool heap_recorder_for_each_live_object(
     bool (*for_each_callback)(heap_recorder_iteration_data data, void* extra_arg),
     void *for_each_callback_extra_arg);
 
+// Return a Ruby hash containing a snapshot of this recorder's interesting state at calling time.
+// WARN: This allocates in the Ruby VM and therefore should not be called without the
+//       VM lock or during GC.
+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

data/ext/{ddtrace_profiling_native_extension → datadog_profiling_native_extension}/http_transport.c

@@ -30,7 +30,7 @@ inline static 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_Endpoint endpoint_from(VALUE exporter_configuration);
+static ddog_prof_Endpoint endpoint_from(VALUE exporter_configuration);
 static ddog_Vec_Tag convert_tags(VALUE tags_as_array);
 static void safely_log_failure_to_process_tag(ddog_Vec_Tag tags, VALUE err_details);
 static VALUE _native_do_export(
@@ -46,17 +46,17 @@ static VALUE _native_do_export(
   VALUE code_provenance_file_name,
   VALUE code_provenance_data,
   VALUE tags_as_array,
-  VALUE internal_metadata_json
+  VALUE internal_metadata_json,
+  VALUE info_json
 );
 static void *call_exporter_without_gvl(void *call_args);
 static void interrupt_exporter_call(void *cancel_token);
-static VALUE ddtrace_version(void);
 
 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, 12);
+  rb_define_singleton_method(http_transport_class, "_native_do_export",  _native_do_export, 13);
 
   ok_symbol = ID2SYM(rb_intern_const("ok"));
   error_symbol = ID2SYM(rb_intern_const("error"));
@@ -94,7 +94,7 @@ static ddog_prof_Exporter_NewResult create_exporter(VALUE exporter_configuration
 
   // This needs to be called BEFORE convert_tags since it can raise an exception and thus cause the ddog_Vec_Tag
   // to be leaked.
-  ddog_Endpoint endpoint = endpoint_from(exporter_configuration);
+  ddog_prof_Endpoint endpoint = endpoint_from(exporter_configuration);
 
   ddog_Vec_Tag tags = convert_tags(tags_as_array);
 
@@ -116,7 +116,7 @@ static VALUE handle_exporter_failure(ddog_prof_Exporter_NewResult exporter_resul
     rb_ary_new_from_args(2, error_symbol, get_error_details_and_drop(&exporter_result.err));
 }
 
-static ddog_Endpoint endpoint_from(VALUE exporter_configuration) {
+static ddog_prof_Endpoint endpoint_from(VALUE exporter_configuration) {
   ENFORCE_TYPE(exporter_configuration, T_ARRAY);
 
   ID working_mode = SYM2ID(rb_ary_entry(exporter_configuration, 0)); // SYM2ID verifies its input so we can do this safely
@@ -131,12 +131,12 @@ static ddog_Endpoint endpoint_from(VALUE exporter_configuration) {
     ENFORCE_TYPE(site, T_STRING);
     ENFORCE_TYPE(api_key, T_STRING);
 
-    return ddog_Endpoint_agentless(char_slice_from_ruby_string(site), char_slice_from_ruby_string(api_key));
+    return ddog_prof_Endpoint_agentless(char_slice_from_ruby_string(site), char_slice_from_ruby_string(api_key));
   } else { // agent_id
     VALUE base_url = rb_ary_entry(exporter_configuration, 1);
     ENFORCE_TYPE(base_url, T_STRING);
 
-    return ddog_Endpoint_agent(char_slice_from_ruby_string(base_url));
+    return ddog_prof_Endpoint_agent(char_slice_from_ruby_string(base_url));
   }
 }
 
@@ -208,6 +208,7 @@ static VALUE perform_export(
   ddog_prof_Exporter_Slice_File files_to_export_unmodified,
   ddog_Vec_Tag *additional_tags,
   ddog_CharSlice internal_metadata,
+  ddog_CharSlice info,
   uint64_t timeout_milliseconds
 ) {
   ddog_prof_ProfiledEndpointsStats *endpoints_stats = NULL; // Not in use yet
@@ -220,6 +221,7 @@ static VALUE perform_export(
     additional_tags,
     endpoints_stats,
     &internal_metadata,
+    &info,
     timeout_milliseconds
   );
 
@@ -290,7 +292,8 @@ static VALUE _native_do_export(
   VALUE code_provenance_file_name,
   VALUE code_provenance_data,
   VALUE tags_as_array,
-  VALUE internal_metadata_json
+  VALUE internal_metadata_json,
+  VALUE info_json
 ) {
   ENFORCE_TYPE(upload_timeout_milliseconds, T_FIXNUM);
   ENFORCE_TYPE(start_timespec_seconds, T_FIXNUM);
@@ -301,6 +304,7 @@ static VALUE _native_do_export(
   ENFORCE_TYPE(pprof_data, T_STRING);
   ENFORCE_TYPE(code_provenance_file_name, T_STRING);
   ENFORCE_TYPE(internal_metadata_json, T_STRING);
+  ENFORCE_TYPE(info_json, T_STRING);
 
   // Code provenance can be disabled and in that case will be set to nil
   bool have_code_provenance = !NIL_P(code_provenance_data);
@@ -335,6 +339,7 @@ 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);
   // Note: Do not add anything that can raise exceptions after this line, as otherwise the exporter memory will leak
@@ -350,6 +355,7 @@ static VALUE _native_do_export(
     files_to_export_unmodified,
     null_additional_tags,
     internal_metadata,
+    info,
     timeout_milliseconds
   );
 }
@@ -367,13 +373,3 @@ static void *call_exporter_without_gvl(void *call_args) {
 static void interrupt_exporter_call(void *cancel_token) {
   ddog_CancellationToken_cancel((ddog_CancellationToken *) cancel_token);
 }
-
-static VALUE ddtrace_version(void) {
-  VALUE ddtrace_module = rb_const_get(rb_cObject, rb_intern("DDTrace"));
-  ENFORCE_TYPE(ddtrace_module, T_MODULE);
-  VALUE version_module = rb_const_get(ddtrace_module, rb_intern("VERSION"));
-  ENFORCE_TYPE(version_module, T_MODULE);
-  VALUE version_string = rb_const_get(version_module, rb_intern("STRING"));
-  ENFORCE_TYPE(version_string, T_STRING);
-  return version_string;
-}

data/ext/{ddtrace_profiling_native_extension → datadog_profiling_native_extension}/native_extension_helpers.rb

@@ -15,7 +15,7 @@ module Datadog
       # The MJIT header was introduced on 2.6 and removed on 3.3; for other Rubies we rely on debase-ruby_core_source
       CAN_USE_MJIT_HEADER = RUBY_VERSION.start_with?('2.6', '2.7', '3.0.', '3.1.', '3.2.')
 
-      LIBDATADOG_VERSION = '~> 5.0.0.1.0'
+      LIBDATADOG_VERSION = '~> 7.0.0.1.0'
 
       def self.fail_install_if_missing_extension?
         ENV[ENV_FAIL_INSTALL_IF_MISSING_EXTENSION].to_s.strip.downcase == 'true'
@@ -29,7 +29,7 @@ module Datadog
       # native extension), we need to add a "runpath" -- a list of folders to search for libdatadog.
       #
       # This runpath gets hardcoded at native library linking time. You can look at it using the `readelf` tool in
-      # Linux: e.g. `readelf -d ddtrace_profiling_native_extension.2.7.3_x86_64-linux.so`.
+      # Linux: e.g. `readelf -d datadog_profiling_native_extension.2.7.3_x86_64-linux.so`.
       #
       # In older versions of ddtrace, we only set as runpath an absolute path to libdatadog.
       # (This gets set automatically by the call
@@ -305,8 +305,8 @@ module Datadog
           no_binaries_for_current_platform = explain_issue(
             'the `libdatadog` gem installed on your system is missing binaries for your',
             'platform variant.',
-            "(Your platform: `#{Gem::Platform.local}`)",
-            '(Available binaries: ',
+            "(Your platform: `#{Libdatadog.current_platform}`)",
+            '(Available binaries:',
             "`#{Libdatadog.available_binaries.join('`, `')}`)",
             suggested: CONTACT_SUPPORT,
           )

data/ext/{ddtrace_profiling_native_extension → datadog_profiling_native_extension}/private_vm_api_access.c

@@ -876,3 +876,17 @@ static inline int ddtrace_imemo_type(VALUE imemo) {
     return NULL;
   }
 #endif
+
+// This is used to workaround a VM bug. See "handle_sampling_signal" in "collectors_cpu_and_wall_time_worker" for details.
+#ifdef NO_POSTPONED_TRIGGER
+  void *objspace_ptr_for_gc_finalize_deferred_workaround(void) {
+    rb_vm_t *vm =
+      #ifndef NO_GET_VM // TODO: Inline GET_VM below once we drop support in dd-trace-rb 2.x for < Ruby 2.5
+        GET_VM();
+      #else
+        thread_struct_from_object(rb_thread_current())->vm;
+      #endif
+
+    return vm->objspace;
+  }
+#endif

data/ext/{ddtrace_profiling_native_extension → datadog_profiling_native_extension}/private_vm_api_access.h

@@ -55,3 +55,7 @@ void self_test_mn_enabled(void);
 
 // Provides more specific information on what kind an imemo is
 const char *imemo_kind(VALUE imemo);
+
+#ifdef NO_POSTPONED_TRIGGER
+  void *objspace_ptr_for_gc_finalize_deferred_workaround(void);
+#endif

data/ext/{ddtrace_profiling_native_extension → datadog_profiling_native_extension}/profiling.c

@@ -38,7 +38,7 @@ static VALUE _native_enforce_success(DDTRACE_UNUSED VALUE _self, VALUE syserr_er
 static void *trigger_enforce_success(void *trigger_args);
 static VALUE _native_malloc_stats(DDTRACE_UNUSED VALUE _self);
 
-void DDTRACE_EXPORT Init_ddtrace_profiling_native_extension(void) {
+void DDTRACE_EXPORT Init_datadog_profiling_native_extension(void) {
   VALUE datadog_module = rb_define_module("Datadog");
   VALUE profiling_module = rb_define_module_under(datadog_module, "Profiling");
   VALUE native_extension_module = rb_define_module_under(profiling_module, "NativeExtension");

data/ext/{ddtrace_profiling_native_extension → datadog_profiling_native_extension}/ruby_helpers.c

@@ -255,3 +255,13 @@ VALUE ruby_safe_inspect(VALUE obj) {
     return rb_str_new_cstr("(Not inspectable)");
   }
 }
+
+VALUE ddtrace_version(void) {
+  VALUE ddtrace_module = rb_const_get(rb_cObject, rb_intern("DDTrace"));
+  ENFORCE_TYPE(ddtrace_module, T_MODULE);
+  VALUE version_module = rb_const_get(ddtrace_module, rb_intern("VERSION"));
+  ENFORCE_TYPE(version_module, T_MODULE);
+  VALUE version_string = rb_const_get(version_module, rb_intern("STRING"));
+  ENFORCE_TYPE(version_string, T_STRING);
+  return version_string;
+}