datadog 2.7.1 → 2.18.0

data/ext/datadog_profiling_native_extension/stack_recorder.h

@@ -13,7 +13,7 @@ typedef struct {
   int64_t timeline_wall_time_ns;
 } sample_values;
 
-typedef struct sample_labels {
+typedef struct {
   ddog_prof_Slice_Label labels;
 
   // This is used to allow the `Collectors::Stack` to modify the existing label, if any. This MUST be NULL or point
@@ -26,6 +26,6 @@ typedef struct sample_labels {
 
 void record_sample(VALUE recorder_instance, ddog_prof_Slice_Location locations, sample_values values, sample_labels labels);
 void record_endpoint(VALUE recorder_instance, uint64_t local_root_span_id, ddog_CharSlice endpoint);
-void track_object(VALUE recorder_instance, VALUE new_object, unsigned int sample_weight, ddog_CharSlice *alloc_class);
+void track_object(VALUE recorder_instance, VALUE new_object, unsigned int sample_weight, ddog_CharSlice alloc_class);
 void recorder_after_gc_step(VALUE recorder_instance);
 VALUE enforce_recorder_instance(VALUE object);

data/ext/datadog_profiling_native_extension/time_helpers.h

@@ -39,7 +39,7 @@ static inline long system_epoch_time_now_ns(raise_on_failure_setting raise_on_fa
 // https://docs.redhat.com/en/documentation/red_hat_enterprise_linux_for_real_time/7/html/reference_guide/sect-posix_clocks#Using_clock_getres_to_compare_clock_resolution
 // We introduce here a separate type for it, so as to make it harder to misuse/more explicit when these timestamps are used
 
-typedef struct coarse_instant {
+typedef struct {
   long timestamp_ns;
 } coarse_instant;
 

data/ext/datadog_profiling_native_extension/unsafe_api_calls_check.c

@@ -0,0 +1,47 @@
+#include <ruby.h>
+#include <ruby/debug.h>
+#include <stdbool.h>
+
+#include "datadog_ruby_common.h"
+#include "unsafe_api_calls_check.h"
+#include "extconf.h"
+
+static bool inside_unsafe_context = false;
+
+#ifndef NO_POSTPONED_TRIGGER
+  static rb_postponed_job_handle_t check_for_unsafe_api_calls_handle;
+#endif
+
+static void check_for_unsafe_api_calls(DDTRACE_UNUSED void *_unused);
+
+void unsafe_api_calls_check_init(void) {
+  #ifndef NO_POSTPONED_TRIGGER
+    int unused_flags = 0;
+
+    check_for_unsafe_api_calls_handle = rb_postponed_job_preregister(unused_flags, check_for_unsafe_api_calls, NULL);
+
+   if (check_for_unsafe_api_calls_handle == POSTPONED_JOB_HANDLE_INVALID) {
+     rb_raise(rb_eRuntimeError, "Failed to register check_for_unsafe_api_calls_handle postponed job (got POSTPONED_JOB_HANDLE_INVALID)");
+   }
+  #endif
+}
+
+void debug_enter_unsafe_context(void) {
+  inside_unsafe_context = true;
+
+  #ifndef NO_POSTPONED_TRIGGER
+    rb_postponed_job_trigger(check_for_unsafe_api_calls_handle);
+  #else
+    rb_postponed_job_register(0, check_for_unsafe_api_calls, NULL);
+  #endif
+}
+
+void debug_leave_unsafe_context(void) {
+  inside_unsafe_context = false;
+}
+
+static void check_for_unsafe_api_calls(DDTRACE_UNUSED void *_unused) {
+  if (inside_unsafe_context) rb_bug(
+    "Datadog Ruby profiler detected callback nested inside sample. Please report this at https://github.com/datadog/dd-trace-rb/blob/master/CONTRIBUTING.md#found-a-bug"
+  );
+}

data/ext/datadog_profiling_native_extension/unsafe_api_calls_check.h

@@ -0,0 +1,31 @@
+#pragma once
+
+// This checker is used to detect accidental thread scheduling switching points happening during profiling sampling.
+//
+// Specifically, when the profiler is sampling, we're never supposed to call into Ruby code (e.g. methods
+// implemented using Ruby code) or allocate Ruby objects.
+// That's because those events introduce thread switch points, and really we don't the VM switching between threads
+// in the middle of the profiler sampling.
+// This includes raising exceptions, unless we're trying to stop the profiler, and even then we must be careful.
+//
+// The above is especially true in situations such as GC profiling or allocation/heap profiling, as in those situations
+// we can even crash the Ruby VM if we switch away at the wrong time.
+//
+// The below APIs can be used to detect these situations. They work by relying on the following observation:
+// in most (all?) thread switch points, Ruby will check for interrupts and run the postponed jobs.
+//
+// Thus, if we set a flag while we're sampling (inside_unsafe_context), trigger the postponed job, and then only unset
+// the flag after sampling, he correct thing to happen is that the postponed job should never see the flag.
+//
+// If, however, we have a bug and there's a thread switch point, our postponed job will see the flag and immediately
+// stop the Ruby VM before further damage happens (and hopefully giving us a stack trace clearly pointing to the culprit).
+
+void unsafe_api_calls_check_init(void);
+
+// IMPORTANT: This method **MUST** only be called from test code, as it causes an immediate hard-crash on the Ruby VM
+// when it detects a potential issue, and that's not something we want for production apps.
+//
+// In the future we may introduce some kind of setting (off by default) to also allow this to be safely be used
+// in production code if needed.
+void debug_enter_unsafe_context(void);
+void debug_leave_unsafe_context(void);

data/ext/libdatadog_api/crashtracker.c

@@ -5,20 +5,14 @@
 
 static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _self);
 static VALUE _native_stop(DDTRACE_UNUSED VALUE _self);
-static void crashtracker_init(VALUE crashtracking_module);
+
+static bool first_init = true;
 
 // Used to report Ruby VM crashes.
 // Once initialized, segfaults will be reported automatically using libdatadog.
 
-void DDTRACE_EXPORT Init_libdatadog_api(void) {
-  VALUE datadog_module = rb_define_module("Datadog");
-  VALUE core_module = rb_define_module_under(datadog_module, "Core");
+void crashtracker_init(VALUE core_module) {
   VALUE crashtracking_module = rb_define_module_under(core_module, "Crashtracking");
-
-  crashtracker_init(crashtracking_module);
-}
-
-void crashtracker_init(VALUE crashtracking_module) {
   VALUE crashtracker_class = rb_define_class_under(crashtracking_module, "Component", rb_cObject);
 
   rb_define_singleton_method(crashtracker_class, "_native_start_or_update_on_fork", _native_start_or_update_on_fork, -1);
@@ -54,6 +48,9 @@ static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUS
   // Tags and endpoint are heap-allocated, so after here we can't raise exceptions otherwise we'll leak this memory
   // Start of exception-free zone to prevent leaks {{
   ddog_Endpoint *endpoint = ddog_endpoint_from_url(char_slice_from_ruby_string(agent_base_url));
+  if (endpoint == NULL) {
+    rb_raise(rb_eRuntimeError, "Failed to create endpoint from agent_base_url: %"PRIsVALUE, agent_base_url);
+  }
   ddog_Vec_Tag tags = convert_tags(tags_as_array);
 
   ddog_crasht_Config config = {
@@ -67,7 +64,7 @@ static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUS
     // "Process.kill('SEGV', Process.pid)" gets run.
     //
     // This actually changed in libdatadog 14, so I could see no issues with `create_alt_stack = true`, but not
-    // overridding what Ruby set up seems a saner default to keep anyway.
+    // overriding what Ruby set up seems a saner default to keep anyway.
     .create_alt_stack = false,
     .use_alt_stack = true,
     .endpoint = endpoint,
@@ -95,17 +92,22 @@ static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUS
     .optional_stdout_filename = {},
   };
 
-  ddog_crasht_Result result =
+  ddog_VoidResult result =
     action == start_action ?
-      ddog_crasht_init(config, receiver_config, metadata) :
+      (first_init ?
+        ddog_crasht_init(config, receiver_config, metadata) :
+        ddog_crasht_reconfigure(config, receiver_config, metadata)
+      ) :
       ddog_crasht_update_on_fork(config, receiver_config, metadata);
 
+  first_init = false;
+
   // Clean up before potentially raising any exceptions
   ddog_Vec_Tag_drop(tags);
   ddog_endpoint_drop(endpoint);
   // }} End of exception-free zone to prevent leaks
 
-  if (result.tag == DDOG_CRASHT_RESULT_ERR) {
+  if (result.tag == DDOG_VOID_RESULT_ERR) {
     rb_raise(rb_eRuntimeError, "Failed to start/update the crash tracker: %"PRIsVALUE, get_error_details_and_drop(&result.err));
   }
 
@@ -113,9 +115,9 @@ static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUS
 }
 
 static VALUE _native_stop(DDTRACE_UNUSED VALUE _self) {
-  ddog_crasht_Result result = ddog_crasht_shutdown();
+  ddog_VoidResult result = ddog_crasht_disable();
 
-  if (result.tag == DDOG_CRASHT_RESULT_ERR) {
+  if (result.tag == DDOG_VOID_RESULT_ERR) {
     rb_raise(rb_eRuntimeError, "Failed to stop the crash tracker: %"PRIsVALUE, get_error_details_and_drop(&result.err));
   }
 

data/ext/libdatadog_api/crashtracker.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "datadog_ruby_common.h"
+
+void crashtracker_init(VALUE core_module);

data/ext/libdatadog_api/datadog_ruby_common.c

@@ -29,10 +29,7 @@ VALUE datadog_gem_version(void) {
 }
 
 static VALUE log_failure_to_process_tag(VALUE err_details) {
-  VALUE datadog_module = rb_const_get(rb_cObject, rb_intern("Datadog"));
-  VALUE logger = rb_funcall(datadog_module, rb_intern("logger"), 0);
-
-  return rb_funcall(logger, rb_intern("warn"), 1, rb_sprintf("Failed to convert tag: %"PRIsVALUE, err_details));
+  return log_warning(rb_sprintf("Failed to convert tag: %"PRIsVALUE, err_details));
 }
 
 __attribute__((warn_unused_result))

data/ext/libdatadog_api/datadog_ruby_common.h

@@ -27,6 +27,9 @@
 #define ENFORCE_BOOLEAN(value) \
   { if (RB_UNLIKELY(value != Qtrue && value != Qfalse)) raise_unexpected_type(value, ADD_QUOTES(value), "true or false", __FILE__, __LINE__, __func__); }
 
+#define ENFORCE_TYPED_DATA(value, type) \
+  { if (RB_UNLIKELY(!rb_typeddata_is_kind_of(value, type))) raise_unexpected_type(value, ADD_QUOTES(value), "TypedData of type " ADD_QUOTES(type), __FILE__, __LINE__, __func__); }
+
 NORETURN(void raise_unexpected_type(VALUE value, const char *value_name, const char *type_name, const char *file, int line, const char* function_name));
 
 // Helper to retrieve Datadog::VERSION::STRING
@@ -38,6 +41,13 @@ static inline ddog_CharSlice char_slice_from_ruby_string(VALUE string) {
   return char_slice;
 }
 
+static inline VALUE log_warning(VALUE warning) {
+  VALUE datadog_module = rb_const_get(rb_cObject, rb_intern("Datadog"));
+  VALUE logger = rb_funcall(datadog_module, rb_intern("logger"), 0);
+
+  return rb_funcall(logger, rb_intern("warn"), 1, warning);
+}
+
 __attribute__((warn_unused_result))
 ddog_Vec_Tag convert_tags(VALUE tags_as_array);
 

data/ext/libdatadog_api/extconf.rb

@@ -72,8 +72,8 @@ if ENV['DDTRACE_DEBUG'] == 'true'
 end
 
 # If we got here, libdatadog is available and loaded
-ENV['PKG_CONFIG_PATH'] = "#{ENV['PKG_CONFIG_PATH']}:#{Libdatadog.pkgconfig_folder}"
-Logging.message("[datadog] PKG_CONFIG_PATH set to #{ENV['PKG_CONFIG_PATH'].inspect}\n")
+ENV['PKG_CONFIG_PATH'] = "#{ENV["PKG_CONFIG_PATH"]}:#{Libdatadog.pkgconfig_folder}"
+Logging.message("[datadog] PKG_CONFIG_PATH set to #{ENV["PKG_CONFIG_PATH"].inspect}\n")
 $stderr.puts("Using libdatadog #{Libdatadog::VERSION} from #{Libdatadog.pkgconfig_folder}")
 
 unless pkg_config('datadog_profiling_with_rpath')

data/ext/libdatadog_api/init.c

@@ -0,0 +1,15 @@
+#include <ruby.h>
+
+#include "datadog_ruby_common.h"
+#include "crashtracker.h"
+#include "process_discovery.h"
+#include "library_config.h"
+
+void DDTRACE_EXPORT Init_libdatadog_api(void) {
+  VALUE datadog_module = rb_define_module("Datadog");
+  VALUE core_module = rb_define_module_under(datadog_module, "Core");
+
+  crashtracker_init(core_module);
+  process_discovery_init(core_module);
+  library_config_init(core_module);
+}

data/ext/libdatadog_api/library_config.c

@@ -0,0 +1,164 @@
+#include <ruby.h>
+#include <datadog/library-config.h>
+
+#include "library_config.h"
+#include "datadog_ruby_common.h"
+
+static VALUE _native_configurator_new(VALUE klass);
+static VALUE _native_configurator_get(VALUE self);
+
+// Used for testing in RSpec
+static VALUE _native_configurator_with_local_path(DDTRACE_UNUSED VALUE _self, VALUE rb_configurator, VALUE path);
+static VALUE _native_configurator_with_fleet_path(DDTRACE_UNUSED VALUE _self, VALUE rb_configurator, VALUE path);
+
+static VALUE config_vec_class = Qnil;
+
+// ddog_Configurator memory management
+static void configurator_free(void *configurator_ptr) {
+  ddog_Configurator *configurator = (ddog_Configurator *)configurator_ptr;
+
+  ddog_library_configurator_drop(configurator);
+}
+
+static const rb_data_type_t configurator_typed_data = {
+  .wrap_struct_name = "Datadog::Core::Configuration::StableConfig::Configurator",
+  .function = {
+    .dfree = configurator_free,
+    .dsize = NULL,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+// ddog_Vec_LibraryConfig memory management
+static void config_vec_free(void *config_vec_ptr) {
+  ddog_Vec_LibraryConfig *config_vec = (ddog_Vec_LibraryConfig *)config_vec_ptr;
+
+  ddog_library_config_drop(*config_vec);
+  ruby_xfree(config_vec_ptr);
+}
+
+static const rb_data_type_t config_vec_typed_data = {
+  .wrap_struct_name = "Datadog::Core::Configuration::StableConfigVec",
+  .function = {
+    .dfree = config_vec_free,
+    .dsize = NULL,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+void library_config_init(VALUE core_module) {
+  rb_global_variable(&config_vec_class);
+  VALUE configuration_module = rb_define_module_under(core_module, "Configuration");
+  VALUE stable_config_module = rb_define_module_under(configuration_module, "StableConfig");
+  VALUE configurator_class = rb_define_class_under(stable_config_module, "Configurator", rb_cObject);
+  config_vec_class = rb_define_class_under(configuration_module, "StableConfigVec", rb_cObject);
+
+  rb_define_alloc_func(configurator_class, _native_configurator_new);
+  rb_define_method(configurator_class, "get", _native_configurator_get, 0);
+
+  // Used for testing in RSpec
+  VALUE testing_module = rb_define_module_under(stable_config_module, "Testing");
+  rb_define_singleton_method(testing_module, "with_local_path", _native_configurator_with_local_path, 2);
+  rb_define_singleton_method(testing_module, "with_fleet_path", _native_configurator_with_fleet_path, 2);
+
+  rb_undef_alloc_func(config_vec_class); // It cannot be created from Ruby code and only serves as an intermediate object for the Ruby GC
+}
+
+static VALUE _native_configurator_new(VALUE klass) {
+  ddog_Configurator *configurator = ddog_library_configurator_new(false, DDOG_CHARSLICE_C("ruby"));
+
+  ddog_library_configurator_with_detect_process_info(configurator);
+
+  return TypedData_Wrap_Struct(klass, &configurator_typed_data, configurator);
+}
+
+static VALUE _native_configurator_with_local_path(DDTRACE_UNUSED VALUE _self, VALUE rb_configurator, VALUE path) {
+  ddog_Configurator *configurator;
+  TypedData_Get_Struct(rb_configurator, ddog_Configurator, &configurator_typed_data, configurator);
+
+  ENFORCE_TYPE(path, T_STRING);
+
+  ddog_library_configurator_with_local_path(configurator, cstr_from_ruby_string(path));
+
+  return Qnil;
+}
+
+static VALUE _native_configurator_with_fleet_path(DDTRACE_UNUSED VALUE _self, VALUE rb_configurator, VALUE path) {
+  ddog_Configurator *configurator;
+  TypedData_Get_Struct(rb_configurator, ddog_Configurator, &configurator_typed_data, configurator);
+
+  ENFORCE_TYPE(path, T_STRING);
+
+  ddog_library_configurator_with_fleet_path(configurator, cstr_from_ruby_string(path));
+
+  return Qnil;
+}
+
+static VALUE _native_configurator_get(VALUE self) {
+  ddog_Configurator *configurator;
+  TypedData_Get_Struct(self, ddog_Configurator, &configurator_typed_data, configurator);
+
+  ddog_Result_VecLibraryConfig configurator_result = ddog_library_configurator_get(configurator);
+
+  if (configurator_result.tag == DDOG_RESULT_VEC_LIBRARY_CONFIG_ERR_VEC_LIBRARY_CONFIG) {
+    ddog_Error err = configurator_result.err;
+    VALUE message = get_error_details_and_drop(&err);
+    if (is_config_loaded()) {
+      log_warning(message);
+    } else {
+      log_warning_without_config(message);
+    }
+    return rb_hash_new();
+  }
+
+  // Wrapping config_vec into a Ruby object enables the Ruby GC to manage its memory
+  // We need to allocate memory for config_vec because once it is out of scope, it will be freed (at the end of this function)
+  // So we cannot reference it with &config_vec
+  // We are doing this in case one of the ruby API raises an exception before the end of this function,
+  // so the allocated memory will still be freed
+  ddog_Vec_LibraryConfig *config_vec = ruby_xmalloc(sizeof(ddog_Vec_LibraryConfig));
+  *config_vec = configurator_result.ok;
+  VALUE config_vec_rb = TypedData_Wrap_Struct(config_vec_class, &config_vec_typed_data, config_vec);
+
+  VALUE local_config_hash = rb_hash_new();
+  VALUE fleet_config_hash = rb_hash_new();
+
+  bool local_config_id_set = false;
+  bool fleet_config_id_set = false;
+  VALUE local_hash = rb_hash_new();
+  VALUE fleet_hash = rb_hash_new();
+  for (uintptr_t i = 0; i < config_vec->len; i++) {
+    ddog_LibraryConfig config = config_vec->ptr[i];
+    VALUE selected_hash;
+    if (config.source == DDOG_LIBRARY_CONFIG_SOURCE_LOCAL_STABLE_CONFIG) {
+      selected_hash = local_config_hash;
+      if (!local_config_id_set) {
+        local_config_id_set = true;
+        if (config.config_id.length > 0) {
+          rb_hash_aset(local_hash, ID2SYM(rb_intern("id")), rb_utf8_str_new_cstr(config.config_id.ptr));
+        }
+      }
+    }
+    else {
+      selected_hash = fleet_config_hash;
+      if (!fleet_config_id_set) {
+        fleet_config_id_set = true;
+        if (config.config_id.length > 0) {
+          rb_hash_aset(fleet_hash, ID2SYM(rb_intern("id")), rb_utf8_str_new_cstr(config.config_id.ptr));
+        }
+      }
+    }
+
+    rb_hash_aset(selected_hash, rb_utf8_str_new_cstr(config.name.ptr), rb_utf8_str_new_cstr(config.value.ptr));
+  }
+
+  rb_hash_aset(local_hash, ID2SYM(rb_intern("config")), local_config_hash);
+  rb_hash_aset(fleet_hash, ID2SYM(rb_intern("config")), fleet_config_hash);
+
+  VALUE result = rb_hash_new();
+  rb_hash_aset(result, ID2SYM(rb_intern("local")), local_hash);
+  rb_hash_aset(result, ID2SYM(rb_intern("fleet")), fleet_hash);
+
+  RB_GC_GUARD(config_vec_rb);
+  return result;
+}

data/ext/libdatadog_api/library_config.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "datadog_ruby_common.h"
+
+void library_config_init(VALUE core_module);
+
+static inline bool is_config_loaded(void) {
+  VALUE datadog_module = rb_const_get(rb_cObject, rb_intern("Datadog"));
+  VALUE is_config_loaded = rb_funcall(datadog_module, rb_intern("configuration?"), 0);
+
+  return is_config_loaded == Qtrue;
+}
+
+static inline VALUE log_warning_without_config(VALUE warning) {
+  VALUE datadog_module = rb_const_get(rb_cObject, rb_intern("Datadog"));
+  VALUE logger = rb_funcall(datadog_module, rb_intern("logger_without_configuration"), 0);
+
+  return rb_funcall(logger, rb_intern("warn"), 1, warning);
+}
+
+static inline ddog_CStr cstr_from_ruby_string(VALUE string) {
+  ENFORCE_TYPE(string, T_STRING);
+  ddog_CStr cstr = {.ptr = RSTRING_PTR(string), .length = RSTRING_LEN(string)};
+  return cstr;
+}

data/ext/libdatadog_api/macos_development.md

@@ -17,9 +17,9 @@ export DD_RUBY_PLATFORM=`ruby -e 'puts Gem::Platform.local.to_s'`
 mkdir -p my-libdatadog-build/$DD_RUBY_PLATFORM
 ```
 
-5. Build libdatadog into this folder: `./build-profiling-ffi.sh my-libdatadog-build/$DD_RUBY_PLATFORM`
-6. Tell the Ruby where to find libdatadog: `export LIBDATADOG_VENDOR_OVERRIDE=/full/path/to/my-libdatadog-build/` (Notice no platform here)
-7. Run `bundle exec rake clean compile`
+5. From inside of the libdatadog repo, build libdatadog into this folder: `./build-profiling-ffi.sh my-libdatadog-build/$DD_RUBY_PLATFORM`
+6. Tell Ruby where to find libdatadog: `export LIBDATADOG_VENDOR_OVERRIDE=/full/path/to/my-libdatadog-build/` (Notice no platform here)
+7. From dd-trace-rb, run `bundle exec rake clean compile`
 
 If you additionally want to run the profiler test suite, also remember to `export DD_PROFILING_MACOS_TESTING=true` and re-run `rake clean compile`.
 

data/ext/libdatadog_api/process_discovery.c

@@ -0,0 +1,112 @@
+#include <errno.h>
+#include <stdlib.h>
+#include <ruby.h>
+#include <datadog/library-config.h>
+
+#include "datadog_ruby_common.h"
+
+static VALUE _native_store_tracer_metadata(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _self);
+static VALUE _native_to_rb_int(DDTRACE_UNUSED VALUE _self, VALUE tracer_memfd);
+static VALUE _native_close_tracer_memfd(DDTRACE_UNUSED VALUE _self, VALUE tracer_memfd, VALUE logger);
+
+static void tracer_memfd_free(void *ptr) {
+  int *fd = (int *)ptr;
+  if (*fd != -1) {
+    close(*fd);
+  }
+  ruby_xfree(ptr);
+}
+
+static const rb_data_type_t tracer_memfd_type = {
+  .wrap_struct_name = "Datadog::Core::ProcessDiscovery::TracerMemfd",
+  .function = {
+    .dfree = tracer_memfd_free,
+    .dsize = NULL,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+void process_discovery_init(VALUE core_module) {
+  VALUE process_discovery_class = rb_define_class_under(core_module, "ProcessDiscovery", rb_cObject);
+  VALUE tracer_memfd_class = rb_define_class_under(process_discovery_class, "TracerMemfd", rb_cObject);
+  rb_undef_alloc_func(tracer_memfd_class); // Class cannot be instantiated from Ruby
+
+  rb_define_singleton_method(process_discovery_class, "_native_store_tracer_metadata", _native_store_tracer_metadata, -1);
+  rb_define_singleton_method(process_discovery_class, "_native_to_rb_int", _native_to_rb_int, 1);
+  rb_define_singleton_method(process_discovery_class, "_native_close_tracer_memfd", _native_close_tracer_memfd, 2);
+}
+
+static VALUE _native_store_tracer_metadata(int argc, VALUE *argv, VALUE self) {
+  VALUE logger;
+  VALUE options;
+  rb_scan_args(argc, argv, "1:", &logger, &options);
+  if (options == Qnil) options = rb_hash_new();
+
+  VALUE schema_version = rb_hash_fetch(options, ID2SYM(rb_intern("schema_version")));
+  VALUE runtime_id = rb_hash_fetch(options, ID2SYM(rb_intern("runtime_id")));
+  VALUE tracer_language = rb_hash_fetch(options, ID2SYM(rb_intern("tracer_language")));
+  VALUE tracer_version = rb_hash_fetch(options, ID2SYM(rb_intern("tracer_version")));
+  VALUE hostname = rb_hash_fetch(options, ID2SYM(rb_intern("hostname")));
+  VALUE service_name = rb_hash_fetch(options, ID2SYM(rb_intern("service_name")));
+  VALUE service_env = rb_hash_fetch(options, ID2SYM(rb_intern("service_env")));
+  VALUE service_version = rb_hash_fetch(options, ID2SYM(rb_intern("service_version")));
+
+  ENFORCE_TYPE(schema_version, T_FIXNUM);
+  ENFORCE_TYPE(runtime_id, T_STRING);
+  ENFORCE_TYPE(tracer_language, T_STRING);
+  ENFORCE_TYPE(tracer_version, T_STRING);
+  ENFORCE_TYPE(hostname, T_STRING);
+  ENFORCE_TYPE(service_name, T_STRING);
+  ENFORCE_TYPE(service_env, T_STRING);
+  ENFORCE_TYPE(service_version, T_STRING);
+
+  ddog_Result_TracerMemfdHandle result = ddog_store_tracer_metadata(
+    (uint8_t) NUM2UINT(schema_version),
+    char_slice_from_ruby_string(runtime_id),
+    char_slice_from_ruby_string(tracer_language),
+    char_slice_from_ruby_string(tracer_version),
+    char_slice_from_ruby_string(hostname),
+    char_slice_from_ruby_string(service_name),
+    char_slice_from_ruby_string(service_env),
+    char_slice_from_ruby_string(service_version)
+  );
+
+  if (result.tag == DDOG_RESULT_TRACER_MEMFD_HANDLE_ERR_TRACER_MEMFD_HANDLE) {
+    rb_funcall(logger, rb_intern("debug"), 1, rb_sprintf("Failed to store the tracer configuration in a memory file descriptor: %"PRIsVALUE, get_error_details_and_drop(&result.err)));
+    return Qnil;
+  }
+
+  // &result.ok is a ddog_TracerMemfdHandle, which is a struct only containing int fd, which is a file descriptor
+  // We should just return the fd
+  int *fd = ruby_xmalloc(sizeof(int));
+
+  *fd = result.ok.fd;
+  VALUE tracer_memfd_class = rb_const_get(self, rb_intern("TracerMemfd"));
+  VALUE tracer_memfd = TypedData_Wrap_Struct(tracer_memfd_class, &tracer_memfd_type, fd);
+  return tracer_memfd;
+}
+
+static VALUE _native_to_rb_int(DDTRACE_UNUSED VALUE _self, VALUE tracer_memfd) {
+  int *fd;
+  TypedData_Get_Struct(tracer_memfd, int, &tracer_memfd_type, fd);
+  return INT2NUM(*fd);
+}
+
+static VALUE _native_close_tracer_memfd(DDTRACE_UNUSED VALUE _self, VALUE tracer_memfd, VALUE logger) {
+  int *fd;
+  TypedData_Get_Struct(tracer_memfd, int, &tracer_memfd_type, fd);
+  if (*fd == -1) {
+    rb_funcall(logger, rb_intern("debug"), 1, rb_sprintf("The tracer configuration memory file descriptor has already been closed"));
+    return Qnil;
+  }
+
+  int close_result = close(*fd);
+  *fd = -1;
+
+  if (close_result == -1) {
+    rb_funcall(logger, rb_intern("debug"), 1, rb_sprintf("Failed to close the tracer configuration memory file descriptor: %s", strerror(errno)));
+    return Qnil;
+  }
+
+  return Qnil;
+}

data/ext/libdatadog_api/process_discovery.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "datadog_ruby_common.h"
+
+void process_discovery_init(VALUE core_module);

data/ext/libdatadog_extconf_helpers.rb

@@ -8,7 +8,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 = '~> 14.1.0.1.0'
+    LIBDATADOG_VERSION = '~> 18.1.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.
@@ -104,7 +104,7 @@ module Datadog
 
     # mkmf sets $PKGCONFIG after the `pkg_config` gets used in extconf.rb. When `pkg_config` is unsuccessful, we use
     # this helper to decide if we can show more specific error message vs a generic "something went wrong".
-    def self.pkg_config_missing?(command: $PKGCONFIG) # rubocop:disable Style/GlobalVars
+    def self.pkg_config_missing?(command: $PKGCONFIG) # standard:disable Style/GlobalVars
       pkg_config_available = command && xsystem("#{command} --version")
 
       pkg_config_available != true