datadog 2.21.0 → 2.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e804b0ea5131eba47b865f95a6540c84a2c20e061a9d25a9bf1f2841895c46c6
-  data.tar.gz: 7c7b61bb061c943aad519ede1f4900351db8b79e7111368c3d85f23ac73fafb8
+  metadata.gz: 495f03c8c90a6786ec765ac781553fe5197d9511586a41964382b73bb69ccca9
+  data.tar.gz: 81c46a4063b395a010ad1a028289b74c2d55bdaa6dff36ce61085d066a9b1a19
 SHA512:
-  metadata.gz: 669cc7248fe15fbd07ab98e71d20e3ec97d644b27ef43be9b7fe7b047c60bd8794c903db3cfe1f4580f7877f7a1491f5028743a618e649930ff10d14756ae820
-  data.tar.gz: e5a2e28ebcc390f1e2277299b883946c4f0baec35754216bbea4da4df437fa06e8c2b6cc0aa5f7847256e0b500903076a19ec7456c7979e7759fc7a4fb8836d3
+  metadata.gz: 2d4ab14bf55177e33f186c762b5156dd8cb8c17471c6277e1e0d1bce444212c98d221e00a2150fb3358203c898bb40fe431e9ebca0ef8fd22feec80758f8e922
+  data.tar.gz: 505dd3f5f5a08a18a95aef5cb7ae979c63bee58b22d36b8d77b21b0b5998ef775ec8c437895633355664a5ac0c31a9c2624b73ef08b63fa4154712508411b172

data/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 ## [Unreleased]
 
+## [2.22.0] - 2025-10-15
+
+### Added
+
+* Tracing: Add GraphQL error tracking with OpenTelemetry semantics ([#4864][])
+* AppSec: API Security: Add endpoint collection for Rails ([#4919][])
+* AppSec: Updated WAF rules to add support for JWT analysis ([#4907][])
+* AppSec: Enable Remote Configuration capabilities for fingerprinting, trace tagging and user auto-instrumentation ([#4965][])
+* Dynamic Instrumentation: Support `[@duration][]`, `[@return][]` and `[@exception][]` in message templates ([#4914][])
+* Dynamic Instrumentation: Report evaluation errors to the UI ([#4913][])
+* Dynamic Instrumentation: Support conditions for method probes ([#4909][])
+* Dynamic Instrumentation: Capture exceptions raised by instrumented methods in method probes ([#4906][])
+* Dynamic Instrumentation: Add support for probe conditions for line probes ([#4861][])
+
+### Changed
+
+* Core: Upgrade `libdatadog` dependency to 22.0.1 ([#4902][])
+* Tracing: Add `Forwarded` header to the list of headers used for remote IP detection. ([#4969][])
+* AppSec: Update `libbddwaf` to version 1.25.1.0.1 ([#4894][])
+* AppSec: WAF rules can control whether traces are kept or sampled ([#4918][])
+* Dynamic Instrumentation: Evaluate message templates when logging instrumented code ([#4908][])
+
+### Fixed
+
+* Core: Improve locking code for remote configuration worker ([#4957][])
+* Dynamic Instrumentation: Emit a single log event for line probes on exception-raising lines ([#4900][])
+
 ## [2.21.0] - 2025-09-17
 
 ### Added
@@ -3333,7 +3360,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.21.0...master
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v2.22.0...master
+[2.22.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.21.0...v2.22.0
 [2.21.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.20.0...v2.21.0
 [2.20.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.19.0...v2.20.0
 [2.19.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.18.0...v2.19.0
@@ -4929,12 +4957,28 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#4838]: https://github.com/DataDog/dd-trace-rb/issues/4838
 [#4848]: https://github.com/DataDog/dd-trace-rb/issues/4848
 [#4851]: https://github.com/DataDog/dd-trace-rb/issues/4851
+[#4861]: https://github.com/DataDog/dd-trace-rb/issues/4861
 [#4862]: https://github.com/DataDog/dd-trace-rb/issues/4862
 [#4863]: https://github.com/DataDog/dd-trace-rb/issues/4863
+[#4864]: https://github.com/DataDog/dd-trace-rb/issues/4864
 [#4877]: https://github.com/DataDog/dd-trace-rb/issues/4877
 [#4884]: https://github.com/DataDog/dd-trace-rb/issues/4884
 [#4887]: https://github.com/DataDog/dd-trace-rb/issues/4887
 [#4893]: https://github.com/DataDog/dd-trace-rb/issues/4893
+[#4894]: https://github.com/DataDog/dd-trace-rb/issues/4894
+[#4900]: https://github.com/DataDog/dd-trace-rb/issues/4900
+[#4902]: https://github.com/DataDog/dd-trace-rb/issues/4902
+[#4906]: https://github.com/DataDog/dd-trace-rb/issues/4906
+[#4907]: https://github.com/DataDog/dd-trace-rb/issues/4907
+[#4908]: https://github.com/DataDog/dd-trace-rb/issues/4908
+[#4909]: https://github.com/DataDog/dd-trace-rb/issues/4909
+[#4913]: https://github.com/DataDog/dd-trace-rb/issues/4913
+[#4914]: https://github.com/DataDog/dd-trace-rb/issues/4914
+[#4918]: https://github.com/DataDog/dd-trace-rb/issues/4918
+[#4919]: https://github.com/DataDog/dd-trace-rb/issues/4919
+[#4957]: https://github.com/DataDog/dd-trace-rb/issues/4957
+[#4965]: https://github.com/DataDog/dd-trace-rb/issues/4965
+[#4969]: https://github.com/DataDog/dd-trace-rb/issues/4969
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot
@@ -4993,6 +5037,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [@dorner]: https://github.com/dorner
 [@drcapulet]: https://github.com/drcapulet
 [@dudo]: https://github.com/dudo
+[@duration]: https://github.com/duration
 [@e1senh0rn]: https://github.com/e1senh0rn
 [@ecdemis123]: https://github.com/ecdemis123
 [@elliterate]: https://github.com/elliterate
@@ -5001,6 +5046,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [@erict-square]: https://github.com/erict-square
 [@errriclee]: https://github.com/errriclee
 [@evan-waters]: https://github.com/evan-waters
+[@exception]: https://github.com/exception
 [@fledman]: https://github.com/fledman
 [@frsantos]: https://github.com/frsantos
 [@fteem]: https://github.com/fteem
@@ -5058,6 +5104,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [@rahul342]: https://github.com/rahul342
 [@randy-girard]: https://github.com/randy-girard
 [@renchap]: https://github.com/renchap
+[@return]: https://github.com/return
 [@ricbartm]: https://github.com/ricbartm
 [@roccoblues]: https://github.com/roccoblues
 [@rqz13]: https://github.com/rqz13

data/ext/LIBDATADOG_DEVELOPMENT.md

@@ -0,0 +1,60 @@
+# Libdatadog development
+
+These instructions can quickly get outdated, so feel free to open an issue if they're not working (and/or ping @ivoanjo).
+
+## Using libdatadog builds from CI or GitHub
+
+If you're developing inside docker/natively on Linux, you can use libdatadog builds from CI and GitHub.
+
+Here's what to do:
+
+1. Create a folder for extracting libdatadog into based on your ruby platform (for instance inside the dd-trace-rb repo):
+
+```bash
+export DD_RUBY_PLATFORM=`ruby -e 'puts Gem::Platform.local.to_s'`
+echo "Current ruby platform: $DD_RUBY_PLATFORM"
+mkdir -p my-libdatadog-build/$DD_RUBY_PLATFORM
+```
+
+2. Find a libdatadog build from CI or [GitHub releases](https://github.com/DataDog/libdatadog/releases). This should match the Ruby platform seen above.
+3. Extract the libdatadog build into the folder:
+
+```bash
+# In this example the build is in my downloads; notice the use of strip-components to get the correct folder structure
+tar zxvf ~/Downloads/libdatadog-x86_64-unknown-linux-gnu.tar.gz -C my-libdatadog-build/$DD_RUBY_PLATFORM/ --strip-components=1
+# Here's how it should look after
+ls my-libdatadog-build/$DD_RUBY_PLATFORM
+bin  cmake  include  lib  LICENSE  LICENSE-3rdparty.yml  NOTICE
+```
+
+6. Tell Ruby where to find libdatadog: ```export LIBDATADOG_VENDOR_OVERRIDE=`pwd`/my-libdatadog-build/``` (Notice no platform + use of pwd for full path here)
+7. From dd-trace-rb, run `bundle exec rake clean compile`
+8. For incremental builds, usually `bundle exec rake compile` is faster and `clean` is not needed
+
+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`.
+
+## Native development on macOS
+
+As of this writing (August 2025), the libdatadog builds on rubygems.org only support Linux.
+
+We don't officially support using libdatadog for Ruby on other platforms yet, but it is possible to use it for local development on macOS.
+(**Note that you don't need these instructions if you develop inside docker.**)
+
+Here's how you can do so:
+
+1. [Install rust](https://www.rust-lang.org/tools/install)
+2. Install `cbindgen`: `cargo install cbindgen`
+3. Clone [libdatadog](https://github.com/datadog/libdatadog)
+4. Create a folder for building into based on your ruby platform:
+
+```bash
+export DD_RUBY_PLATFORM=`ruby -e 'puts Gem::Platform.local.to_s'`
+mkdir -p my-libdatadog-build/$DD_RUBY_PLATFORM
+```
+
+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=/adjust/this/to/be/the/full/path/to/my-libdatadog-build/` (Notice no platform here)
+7. From dd-trace-rb, run `bundle exec rake clean compile`
+8. For incremental builds, usually `bundle exec rake compile` is faster and `clean` is not needed
+
+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/datadog_profiling_native_extension/collectors_discrete_dynamic_sampler.c

@@ -365,7 +365,7 @@ static const rb_data_type_t sampler_typed_data = {
 };
 
 static VALUE _native_new(VALUE klass) {
-  sampler_state *state = ruby_xcalloc(sizeof(sampler_state), 1);
+  sampler_state *state = ruby_xcalloc(1, sizeof(sampler_state));
 
   long now_ns = monotonic_wall_time_now_ns(DO_NOT_RAISE_ON_FAILURE);
   if (now_ns == 0) {

data/ext/libdatadog_api/ddsketch.c

@@ -0,0 +1,106 @@
+#include <ruby.h>
+#include <datadog/ddsketch.h>
+
+#include "datadog_ruby_common.h"
+
+static VALUE _native_new(VALUE klass);
+static void ddsketch_free(void *ptr);
+static VALUE native_add(VALUE self, VALUE point);
+static VALUE native_add_with_count(VALUE self, VALUE point, VALUE count);
+static VALUE native_count(VALUE self);
+static VALUE native_encode(VALUE self);
+NORETURN(static void raise_ddsketch_error(const char *message, ddog_VoidResult result));
+
+void ddsketch_init(VALUE core_module) {
+  VALUE ddsketch_class = rb_define_class_under(core_module, "DDSketch", rb_cObject);
+
+  rb_define_alloc_func(ddsketch_class, _native_new);
+  rb_define_method(ddsketch_class, "add", native_add, 1);
+  rb_define_method(ddsketch_class, "add_with_count", native_add_with_count, 2);
+  rb_define_method(ddsketch_class, "count", native_count, 0);
+  rb_define_method(ddsketch_class, "encode", native_encode, 0);
+}
+
+// This structure is used to define a Ruby object that stores a pointer to a ddsketch_Handle_DDSketch
+// See also https://github.com/ruby/ruby/blob/master/doc/extension.rdoc for how this works
+static const rb_data_type_t ddsketch_typed_data = {
+  .wrap_struct_name = "Datadog::DDSketch",
+  .function = {
+    .dmark = NULL, // We don't store references to Ruby objects so we don't need to mark any of them
+    .dfree = ddsketch_free,
+    .dsize = NULL, // We don't track memory usage (although it'd be cool if we did!)
+    //.dcompact = NULL, // Not needed -- we don't store references to Ruby objects
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE _native_new(VALUE klass) {
+  ddsketch_Handle_DDSketch *state = ruby_xcalloc(1, sizeof(ddsketch_Handle_DDSketch));
+
+  *state = ddog_ddsketch_new();
+
+  return TypedData_Wrap_Struct(klass, &ddsketch_typed_data, state);
+}
+
+static void ddsketch_free(void *ptr) {
+  ddsketch_Handle_DDSketch *state = (ddsketch_Handle_DDSketch *) ptr;
+  ddog_ddsketch_drop(state);
+  ruby_xfree(ptr);
+}
+
+static void raise_ddsketch_error(const char *message, ddog_VoidResult result) {
+  rb_raise(rb_eRuntimeError, "%s: %"PRIsVALUE, message, get_error_details_and_drop(&result.err));
+}
+
+static VALUE native_add(VALUE self, VALUE point) {
+  ddsketch_Handle_DDSketch *state;
+  TypedData_Get_Struct(self, ddsketch_Handle_DDSketch, &ddsketch_typed_data, state);
+
+  ddog_VoidResult result = ddog_ddsketch_add(state, NUM2DBL(point));
+
+  if (result.tag == DDOG_VOID_RESULT_ERR) raise_ddsketch_error("DDSketch add failed", result);
+
+  return self;
+}
+
+static VALUE native_add_with_count(VALUE self, VALUE point, VALUE count) {
+  ddsketch_Handle_DDSketch *state;
+  TypedData_Get_Struct(self, ddsketch_Handle_DDSketch, &ddsketch_typed_data, state);
+
+  ddog_VoidResult result = ddog_ddsketch_add_with_count(state, NUM2DBL(point), NUM2DBL(count));
+
+  if (result.tag == DDOG_VOID_RESULT_ERR) raise_ddsketch_error("DDSketch add_with_count failed", result);
+
+  return self;
+}
+
+static VALUE native_count(VALUE self) {
+  ddsketch_Handle_DDSketch *state;
+  TypedData_Get_Struct(self, ddsketch_Handle_DDSketch, &ddsketch_typed_data, state);
+
+  double count_out;
+  ddog_VoidResult result = ddog_ddsketch_count(state, &count_out);
+
+  if (result.tag == DDOG_VOID_RESULT_ERR) raise_ddsketch_error("DDSketch count failed", result);
+
+  return DBL2NUM(count_out);
+}
+
+static VALUE native_encode(VALUE self) {
+  ddsketch_Handle_DDSketch *state;
+  TypedData_Get_Struct(self, ddsketch_Handle_DDSketch, &ddsketch_typed_data, state);
+
+  ddog_Vec_U8 encoded = ddog_ddsketch_encode(state);
+
+  // Copy into a Ruby string
+  VALUE bytes = rb_str_new((const char *) encoded.ptr, encoded.len);
+
+  ddog_Vec_U8_drop(encoded);
+
+  // The sketch is consumed by encode; to make this a bit more user-friendly for
+  // a Ruby API (since we can't "kill" the Ruby object), let's re-initialize it so
+  // it can be used again.
+  *state = ddog_ddsketch_new();
+
+  return bytes;
+}

data/ext/libdatadog_api/init.c

@@ -5,6 +5,8 @@
 #include "process_discovery.h"
 #include "library_config.h"
 
+void ddsketch_init(VALUE core_module);
+
 void DDTRACE_EXPORT Init_libdatadog_api(void) {
   VALUE datadog_module = rb_define_module("Datadog");
   VALUE core_module = rb_define_module_under(datadog_module, "Core");
@@ -12,4 +14,5 @@ void DDTRACE_EXPORT Init_libdatadog_api(void) {
   crashtracker_init(core_module);
   process_discovery_init(core_module);
   library_config_init(core_module);
+  ddsketch_init(core_module);
 }

data/ext/libdatadog_api/library_config.c

@@ -11,7 +11,7 @@ static VALUE _native_configurator_get(VALUE self);
 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;
+static VALUE config_logged_result_class = Qnil;
 
 // ddog_Configurator memory management
 static void configurator_free(void *configurator_ptr) {
@@ -29,29 +29,29 @@ static const rb_data_type_t configurator_typed_data = {
   .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_LibraryConfigLoggedResult memory management
+static void config_logged_result_free(void *config_logged_result_ptr) {
+  ddog_LibraryConfigLoggedResult *config_logged_result = (ddog_LibraryConfigLoggedResult *)config_logged_result_ptr;
 
-  ddog_library_config_drop(*config_vec);
-  ruby_xfree(config_vec_ptr);
+  ddog_library_config_drop(*config_logged_result);
+  ruby_xfree(config_logged_result_ptr);
 }
 
-static const rb_data_type_t config_vec_typed_data = {
-  .wrap_struct_name = "Datadog::Core::Configuration::StableConfigVec",
+static const rb_data_type_t config_logged_result_typed_data = {
+  .wrap_struct_name = "Datadog::Core::Configuration::StableConfigLoggedResult",
   .function = {
-    .dfree = config_vec_free,
+    .dfree = config_logged_result_free,
     .dsize = NULL,
   },
   .flags = RUBY_TYPED_FREE_IMMEDIATELY
 };
 
 void library_config_init(VALUE core_module) {
-  rb_global_variable(&config_vec_class);
+  rb_global_variable(&config_logged_result_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);
+  config_logged_result_class = rb_define_class_under(configuration_module, "StableConfigLoggedResult", rb_cObject);
 
   rb_define_alloc_func(configurator_class, _native_configurator_new);
   rb_define_method(configurator_class, "get", _native_configurator_get, 0);
@@ -61,11 +61,12 @@ void library_config_init(VALUE core_module) {
   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
+  rb_undef_alloc_func(config_logged_result_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"));
+  // We always collect debug logs, so if DD_TRACE_DEBUG is set by stable config, we'll be able to log them.
+  ddog_Configurator *configurator = ddog_library_configurator_new(true, DDOG_CHARSLICE_C("ruby"));
 
   ddog_library_configurator_with_detect_process_info(configurator);
 
@@ -98,27 +99,33 @@ 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);
+  // Wrapping config_logged_result into a Ruby object enables the Ruby GC to manage its memory
+  // We need to allocate memory for config_logged_result because once it is out of scope, it will be freed (at the end of this function)
+  // So we cannot reference it with &config_logged_result
+  // 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_LibraryConfigLoggedResult *configurator_logged_result = ruby_xcalloc(1, sizeof(ddog_LibraryConfigLoggedResult));
+  *configurator_logged_result = ddog_library_configurator_get(configurator);
+  VALUE config_logged_result_rb = TypedData_Wrap_Struct(config_logged_result_class, &config_logged_result_typed_data, configurator_logged_result);
 
-  if (configurator_result.tag == DDOG_RESULT_VEC_LIBRARY_CONFIG_ERR_VEC_LIBRARY_CONFIG) {
-    ddog_Error err = configurator_result.err;
+  if (configurator_logged_result->tag == DDOG_LIBRARY_CONFIG_LOGGED_RESULT_ERR) {
+    ddog_Error err = configurator_logged_result->err;
     VALUE message = get_error_details_and_drop(&err);
     if (is_config_loaded()) {
       log_warning(message);
     } else {
       log_warning_without_config(message);
     }
+    RB_GC_GUARD(config_logged_result_rb);
     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 logs = Qnil;
+  if (configurator_logged_result->ok.logs.length > 0) {
+    logs = rb_utf8_str_new_cstr(configurator_logged_result->ok.logs.ptr);
+  }
+
+  ddog_Vec_LibraryConfig config_vec = configurator_logged_result->ok.value;
 
   VALUE local_config_hash = rb_hash_new();
   VALUE fleet_config_hash = rb_hash_new();
@@ -127,8 +134,8 @@ static VALUE _native_configurator_get(VALUE self) {
   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];
+  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;
@@ -156,9 +163,10 @@ static VALUE _native_configurator_get(VALUE self) {
   rb_hash_aset(fleet_hash, ID2SYM(rb_intern("config")), fleet_config_hash);
 
   VALUE result = rb_hash_new();
+  rb_hash_aset(result, ID2SYM(rb_intern("logs")), logs);
   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);
+  RB_GC_GUARD(config_logged_result_rb);
   return result;
 }

data/ext/libdatadog_api/process_discovery.c

@@ -42,7 +42,6 @@ static VALUE _native_store_tracer_metadata(int argc, VALUE *argv, VALUE self) {
   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")));
@@ -50,8 +49,9 @@ static VALUE _native_store_tracer_metadata(int argc, VALUE *argv, VALUE self) {
   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")));
+  VALUE process_tags = rb_hash_fetch(options, ID2SYM(rb_intern("process_tags")));
+  VALUE container_id = rb_hash_fetch(options, ID2SYM(rb_intern("container_id")));
 
-  ENFORCE_TYPE(schema_version, T_FIXNUM);
   ENFORCE_TYPE(runtime_id, T_STRING);
   ENFORCE_TYPE(tracer_language, T_STRING);
   ENFORCE_TYPE(tracer_version, T_STRING);
@@ -59,17 +59,23 @@ static VALUE _native_store_tracer_metadata(int argc, VALUE *argv, VALUE self) {
   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)
-  );
+  ENFORCE_TYPE(process_tags, T_STRING);
+  ENFORCE_TYPE(container_id, T_STRING);
+
+  void* builder = ddog_tracer_metadata_new();
+
+  ddog_tracer_metadata_set(builder, DDOG_METADATA_KIND_RUNTIME_ID, StringValueCStr(runtime_id));
+  ddog_tracer_metadata_set(builder, DDOG_METADATA_KIND_TRACER_LANGUAGE, StringValueCStr(tracer_language));
+  ddog_tracer_metadata_set(builder, DDOG_METADATA_KIND_TRACER_VERSION, StringValueCStr(tracer_version));
+  ddog_tracer_metadata_set(builder, DDOG_METADATA_KIND_HOSTNAME, StringValueCStr(hostname));
+  ddog_tracer_metadata_set(builder, DDOG_METADATA_KIND_SERVICE_NAME, StringValueCStr(service_name));
+  ddog_tracer_metadata_set(builder, DDOG_METADATA_KIND_SERVICE_ENV, StringValueCStr(service_env));
+  ddog_tracer_metadata_set(builder, DDOG_METADATA_KIND_SERVICE_VERSION, StringValueCStr(service_version));
+  ddog_tracer_metadata_set(builder, DDOG_METADATA_KIND_PROCESS_TAGS, StringValueCStr(process_tags));
+  ddog_tracer_metadata_set(builder, DDOG_METADATA_KIND_CONTAINER_ID, StringValueCStr(container_id));
+
+  ddog_Result_TracerMemfdHandle result = ddog_tracer_metadata_store(builder);
+  ddog_tracer_metadata_free(builder);
 
   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)));

data/ext/libdatadog_extconf_helpers.rb

@@ -10,7 +10,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 = '~> 18.1.0.1.0'
+    LIBDATADOG_VERSION = '~> 22.0.1.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.

data/lib/datadog/appsec/api_security/endpoint_collection/grape_route_serializer.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Datadog
+  module AppSec
+    module APISecurity
+      module EndpointCollection
+        # This module serializes Grape routes.
+        module GrapeRouteSerializer
+          module_function
+
+          def serialize(route, path_prefix: '')
+            path = path_prefix + route.pattern.origin
+
+            {
+              type: "REST",
+              resource_name: "#{route.request_method} #{path}",
+              operation_name: "http.request",
+              method: route.request_method,
+              path: path
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/appsec/api_security/endpoint_collection/rails_collector.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative 'rails_route_serializer'
+require_relative 'grape_route_serializer'
+require_relative 'sinatra_route_serializer'
+
+module Datadog
+  module AppSec
+    module APISecurity
+      module EndpointCollection
+        # This class works with a collection of rails routes
+        # and produces an Enumerator that yields serialized endpoints.
+        class RailsCollector
+          def initialize(routes)
+            @routes = routes
+          end
+
+          def to_enum
+            Enumerator.new do |yielder|
+              @routes.each do |route|
+                if route.dispatcher?
+                  yielder.yield RailsRouteSerializer.serialize(route)
+                elsif mounted_grape_app?(route.app.rack_app)
+                  route.app.rack_app.routes.each do |grape_route|
+                    yielder.yield GrapeRouteSerializer.serialize(grape_route, path_prefix: route.path.spec.to_s)
+                  end
+                elsif mounted_sinatra_app?(route.app.rack_app)
+                  route.app.rack_app.routes.each do |method, sinatra_routes|
+                    next if method == 'HEAD'
+
+                    sinatra_routes.each do |sinatra_route, _, _|
+                      yielder.yield SinatraRouteSerializer.serialize(
+                        sinatra_route, method: method, path_prefix: route.path.spec.to_s
+                      )
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          private
+
+          def mounted_grape_app?(rack_app)
+            return false unless defined?(::Grape::API)
+
+            rack_app.is_a?(Class) && rack_app < ::Grape::API
+          end
+
+          def mounted_sinatra_app?(rack_app)
+            return false unless defined?(::Sinatra::Base)
+
+            rack_app.is_a?(Class) && rack_app < ::Sinatra::Base
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/appsec/api_security/endpoint_collection/rails_route_serializer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Datadog
+  module AppSec
+    module APISecurity
+      module EndpointCollection
+        # This module serializes Rails Journey Router routes.
+        module RailsRouteSerializer
+          FORMAT_SUFFIX = "(.:format)"
+
+          module_function
+
+          def serialize(route)
+            method = route.verb.empty? ? "*" : route.verb
+            path = route.path.spec.to_s.delete_suffix(FORMAT_SUFFIX)
+
+            {
+              type: "REST",
+              resource_name: "#{method} #{path}",
+              operation_name: "http.request",
+              method: method,
+              path: path
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/appsec/api_security/endpoint_collection/sinatra_route_serializer.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Datadog
+  module AppSec
+    module APISecurity
+      module EndpointCollection
+        # This module serializes Sinatra routes.
+        module SinatraRouteSerializer
+          module_function
+
+          def serialize(route, method:, path_prefix: '')
+            path = path_prefix + route.safe_string
+
+            {
+              type: "REST",
+              resource_name: "#{method} #{path}",
+              operation_name: "http.request",
+              method: method,
+              path: path
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/appsec/api_security/endpoint_collection.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Datadog
+  module AppSec
+    module APISecurity
+      module EndpointCollection
+      end
+    end
+  end
+end