datadog 2.15.0 → 2.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d17c177691be6204c922253f717344b69cbf2ccf0e6cc51b5d2063e484ffcf9
-  data.tar.gz: fb55233c5db1aa2d80562d7d2a0f7297f4d13b0b1f1c8a3f3a6feec8f15bb947
+  metadata.gz: da587b7c67d38c9ec9730e62603ffecf699d3841978676a06f0fe99506614a3d
+  data.tar.gz: d17d0f78fe1226187aedd815606ce3b450eb6150139c13116ce24082215452dd
 SHA512:
-  metadata.gz: ef69c8e13819833ce2b1a0987ec66a674a15ca029bd4ad0a29703a613c7dd263015ca0018433ac366f69e655fa264a74aa949a1d6b12e30753b249fa8b7d62c2
-  data.tar.gz: 1d44dca02ab71b49b87e371825bbdda696fbd686bc9d24662d5d90c5091c4ddf82226abda23c56da9da8e8274ab06759a90b73fd3eb44cecc081598fd8cc188a
+  metadata.gz: 8d40c4f84ca2396f1011bc27eeb5489a1ded2669c47473a838d5b70191c57b3e34beee38abe8c9737d13212bbf07221ec17a0b428023974ec7001465bbfa7745
+  data.tar.gz: '0155923613825e859fb952901a98f2a779a5128b1cb02cf4e3c619fb99b1bf9b4a7428b1e56cb8580103d52cc189a354df9a1db697c5b857a8c318d2a383bdba'

data/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ## [Unreleased]
 
+## [2.16.0] - 2025-05-19
+
+### Added
+
+* Core: Add new configuration precedence value `environment` ([#4610][])
+* Core: Add Source Code Integration (SCI) tags in Telemetry app-started event and in each Remote Config request ([#4653][])
+* Core: Tracing: ErrorTracking: Add automatic reporting of handled errors ([#4604][])
+* AppSec: Integrations: Add session tracking and attacker fingerprinting to `devise` and `rails` ([#4644][], [#4625][])
+* Profiling: Add support for Ruby 3.5.0-preview1 ([#4600][])
+* Tracing: Add warning when `on_error` handler is not a `Proc` ([#4611][])
+* Tracing: Integrations: Add option to serialize MongoDB command as JSON ([#4403][])
+* Tracing: Integrations: Add baggage to `karafka` list of propagation styles ([#4614][])
+
+### Changed
+
+* Tracing: Adjust trace sampling formula ([#4616][])
+* Profiling: Replace `JSON.fast_generate` with `JSON.generate` ([#4602][])
+
+### Fixed
+
+* Core: Fix Ruby warnings when providing a custom time provider ([#4613][])
+* Core: Fix Telemetry configuration in agentless mode to respect the timeout specified for the Agent ([#4590][])
+* Profiling: Fix profiler compatibility with ruby-head (3.5) ([#4656][])
+
+### Removed
+
+* Core: Remove duplicated classes from Telemetry transport ([#4575][])
+
 ## [2.15.0] - 2025-04-17
 
 ### Added
@@ -3194,7 +3222,8 @@ Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v0.3.1
 Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 
 
-[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v2.15.0...master
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v2.16.0...master
+[2.16.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.15.0...v2.16.0
 [2.15.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.14.0...v2.15.0
 [2.14.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.13.0...v2.14.0
 [2.13.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.12.2...v2.13.0
@@ -4696,6 +4725,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#4391]: https://github.com/DataDog/dd-trace-rb/issues/4391
 [#4398]: https://github.com/DataDog/dd-trace-rb/issues/4398
 [#4399]: https://github.com/DataDog/dd-trace-rb/issues/4399
+[#4403]: https://github.com/DataDog/dd-trace-rb/issues/4403
 [#4406]: https://github.com/DataDog/dd-trace-rb/issues/4406
 [#4411]: https://github.com/DataDog/dd-trace-rb/issues/4411
 [#4422]: https://github.com/DataDog/dd-trace-rb/issues/4422
@@ -4721,8 +4751,22 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#4558]: https://github.com/DataDog/dd-trace-rb/issues/4558
 [#4568]: https://github.com/DataDog/dd-trace-rb/issues/4568
 [#4573]: https://github.com/DataDog/dd-trace-rb/issues/4573
+[#4575]: https://github.com/DataDog/dd-trace-rb/issues/4575
 [#4580]: https://github.com/DataDog/dd-trace-rb/issues/4580
 [#4581]: https://github.com/DataDog/dd-trace-rb/issues/4581
+[#4590]: https://github.com/DataDog/dd-trace-rb/issues/4590
+[#4600]: https://github.com/DataDog/dd-trace-rb/issues/4600
+[#4602]: https://github.com/DataDog/dd-trace-rb/issues/4602
+[#4604]: https://github.com/DataDog/dd-trace-rb/issues/4604
+[#4610]: https://github.com/DataDog/dd-trace-rb/issues/4610
+[#4611]: https://github.com/DataDog/dd-trace-rb/issues/4611
+[#4613]: https://github.com/DataDog/dd-trace-rb/issues/4613
+[#4614]: https://github.com/DataDog/dd-trace-rb/issues/4614
+[#4616]: https://github.com/DataDog/dd-trace-rb/issues/4616
+[#4625]: https://github.com/DataDog/dd-trace-rb/issues/4625
+[#4644]: https://github.com/DataDog/dd-trace-rb/issues/4644
+[#4653]: https://github.com/DataDog/dd-trace-rb/issues/4653
+[#4656]: https://github.com/DataDog/dd-trace-rb/issues/4656
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot
@@ -4874,4 +4918,4 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [@y-yagi]: https://github.com/y-yagi
 [@yujideveloper]: https://github.com/yujideveloper
 [@yukimurasawa]: https://github.com/yukimurasawa
-[@zachmccormick]: https://github.com/zachmccormick
+[@zachmccormick]: https://github.com/zachmccormick

data/ext/datadog_profiling_native_extension/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/datadog_profiling_native_extension/datadog_ruby_common.h

@@ -41,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/datadog_profiling_native_extension/extconf.rb

@@ -131,6 +131,9 @@ end
 
 have_func "malloc_stats"
 
+# On Ruby 3.5, we can't ask the object_id from IMEMOs (https://github.com/ruby/ruby/pull/13347)
+$defs << "-DNO_IMEMO_OBJECT_ID" unless RUBY_VERSION < "3.5"
+
 # On Ruby 2.5 and 3.3, this symbol was not visible. It is on 2.6 to 3.2, as well as 3.4+
 $defs << "-DNO_RB_OBJ_INFO" if RUBY_VERSION.start_with?("2.5", "3.3")
 

data/ext/datadog_profiling_native_extension/heap_recorder.c

@@ -314,7 +314,14 @@ void start_heap_allocation_recording(heap_recorder *heap_recorder, VALUE new_obj
     rb_raise(rb_eRuntimeError, "Detected consecutive heap allocation recording starts without end.");
   }
 
-  if (++heap_recorder->num_recordings_skipped < heap_recorder->sample_rate) {
+  if (++heap_recorder->num_recordings_skipped < heap_recorder->sample_rate ||
+      #ifdef NO_IMEMO_OBJECT_ID
+        // On Ruby 3.5, we can't ask the object_id from IMEMOs (https://github.com/ruby/ruby/pull/13347)
+        RB_BUILTIN_TYPE(new_obj) == RUBY_T_IMEMO
+      #else
+        false
+      #endif
+    ) {
     heap_recorder->active_recording = &SKIPPED_RECORD;
     return;
   }

data/ext/libdatadog_api/crashtracker.c

@@ -5,20 +5,12 @@
 
 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);
 
 // 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);

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

@@ -41,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/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,122 @@
+#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);
+
+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);
+
+  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
+}
+
+// TODO: After libdatadog 17.1 release, delete rb_raise, uncomment code and change `DDTRACE_UNUSED VALUE _klass` by `VALUE klass`
+static VALUE _native_configurator_new(DDTRACE_UNUSED 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);
+  */
+
+  rb_raise(rb_eNotImpError, "TODO: Not in use yet, waiting for libdatadog 17.1");
+}
+
+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();
+  // TODO: Uncomment next block after libdatadog 17.1 release
+  /*
+  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;
+    }
+    else {
+      selected_hash = fleet_config_hash;
+    }
+
+    ddog_CStr name = ddog_library_config_name_to_env(config.name);
+    rb_hash_aset(selected_hash, rb_str_new(name.ptr, name.length), rb_str_new(config.value.ptr, config.value.length));
+  }
+  */
+
+  VALUE result = rb_hash_new();
+  rb_hash_aset(result, ID2SYM(rb_intern("local")), local_config_hash);
+  rb_hash_aset(result, ID2SYM(rb_intern("fleet")), fleet_config_hash);
+
+  RB_GC_GUARD(config_vec_rb);
+  return result;
+}

data/ext/libdatadog_api/library_config.h

@@ -0,0 +1,19 @@
+#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);
+}

data/ext/libdatadog_api/process_discovery.c

@@ -0,0 +1,117 @@
+#include <errno.h>
+#include <stdlib.h>
+#include <ruby.h>
+#include <datadog/common.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);
+}
+
+// TODO: Remove DDTRACE_UNUSED and rename _self to self once we have updated libdatadog to 17.1
+static VALUE _native_store_tracer_metadata(int argc, VALUE *argv, DDTRACE_UNUSED 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;
+  */
+
+  rb_raise(rb_eNotImpError, "TODO: Not in use yet, waiting for libdatadog 17.1");
+}
+
+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/lib/datadog/appsec/actions_handler.rb

@@ -33,7 +33,7 @@ module Datadog
         event_category = Ext::EXPLOIT_PREVENTION_EVENT_CATEGORY
         tag_key = Ext::TAG_METASTRUCT_STACK_TRACE
 
-        existing_stack_data = active_span.get_metastruct_tag(tag_key).dup || { event_category => [] }
+        existing_stack_data = active_span.get_metastruct_tag(tag_key).dup || {event_category => []}
         max_stack_traces = Datadog.configuration.appsec.stack_trace.max_stack_traces
         return if max_stack_traces != 0 && existing_stack_data[event_category].count >= max_stack_traces
 
@@ -42,7 +42,8 @@ module Datadog
         active_span.set_metastruct_tag(tag_key, existing_stack_data)
       end
 
-      def generate_schema(_action_params); end
+      def generate_schema(_action_params)
+      end
     end
   end
 end