datadog 2.16.0 → 2.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da587b7c67d38c9ec9730e62603ffecf699d3841978676a06f0fe99506614a3d
-  data.tar.gz: d17d0f78fe1226187aedd815606ce3b450eb6150139c13116ce24082215452dd
+  metadata.gz: 28053ce1bca4cce2032cb068c38e99a56524e6ccecec3068c4d26d1e750f9790
+  data.tar.gz: 29b6b57640638184370c5176e4da94e74c9770bae8afd7884d1c2baea782350d
 SHA512:
-  metadata.gz: 8d40c4f84ca2396f1011bc27eeb5489a1ded2669c47473a838d5b70191c57b3e34beee38abe8c9737d13212bbf07221ec17a0b428023974ec7001465bbfa7745
-  data.tar.gz: '0155923613825e859fb952901a98f2a779a5128b1cb02cf4e3c619fb99b1bf9b4a7428b1e56cb8580103d52cc189a354df9a1db697c5b857a8c318d2a383bdba'
+  metadata.gz: caf719b7c9a2e5ee3f47ad0c3e02670b90b1f76bfa5de56c10f69169c97b827f4b9e81df822e548d1390f152f15e756c54c200e9f35904138e7c672af99ef30b
+  data.tar.gz: eda75252942b8c7d278bab14da78c7752b17b136a3f0bd9ed145512a64b3fb8acb110a8cbbfb280b2bcf7c558409ce83b5d311fce5f019ff34516ceb3883255c

data/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 ## [Unreleased]
 
+## [2.17.0] - 2025-06-02
+
+### Added
+
+* Tracing: Add support for Rails 8.0. ([#4455][])
+
+### Changed
+
+* Core: Improve tracer error reporting when agent responds with error responses to remote configuration requests ([#4669][])
+* Core: Profiling: Upgrade libdatadog dependency to version 18.1 ([#4577][])
+* Dynamic Instrumentation: Improve UI reporting of application and host status ([#4678][])
+* Tracing: Mark AWS integration spans as errored when AWS requests fail ([#4672][])
+
+### Fixed
+
+* Error Tracking: remove error tracking support on Ruby 2.6 ([#4665][])
+* Profiling: Fix profiling scheduler reporting corner case during shutdown ([#4679][])
+* Tracing: Fix: The `on_error` warning for HTTP instrumentations ([#4673][])
+
 ## [2.16.0] - 2025-05-19
 
 ### Added
@@ -3222,7 +3241,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.16.0...master
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v2.17.0...master
+[2.17.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.16.0...v2.17.0
 [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
@@ -4734,6 +4754,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#4426]: https://github.com/DataDog/dd-trace-rb/issues/4426
 [#4433]: https://github.com/DataDog/dd-trace-rb/issues/4433
 [#4437]: https://github.com/DataDog/dd-trace-rb/issues/4437
+[#4455]: https://github.com/DataDog/dd-trace-rb/issues/4455
 [#4473]: https://github.com/DataDog/dd-trace-rb/issues/4473
 [#4493]: https://github.com/DataDog/dd-trace-rb/issues/4493
 [#4497]: https://github.com/DataDog/dd-trace-rb/issues/4497
@@ -4752,6 +4773,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#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
+[#4577]: https://github.com/DataDog/dd-trace-rb/issues/4577
 [#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
@@ -4767,6 +4789,12 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#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
+[#4665]: https://github.com/DataDog/dd-trace-rb/issues/4665
+[#4669]: https://github.com/DataDog/dd-trace-rb/issues/4669
+[#4672]: https://github.com/DataDog/dd-trace-rb/issues/4672
+[#4673]: https://github.com/DataDog/dd-trace-rb/issues/4673
+[#4678]: https://github.com/DataDog/dd-trace-rb/issues/4678
+[#4679]: https://github.com/DataDog/dd-trace-rb/issues/4679
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot

data/ext/datadog_profiling_native_extension/encoded_profile.c

@@ -38,6 +38,26 @@ VALUE from_ddog_prof_EncodedProfile(ddog_prof_EncodedProfile profile) {
   return TypedData_Wrap_Struct(encoded_profile_class, &encoded_profile_typed_data, state);
 }
 
+static ddog_ByteSlice get_bytes(ddog_prof_EncodedProfile *state) {
+  ddog_prof_Result_ByteSlice raw_bytes = ddog_prof_EncodedProfile_bytes(state);
+  if (raw_bytes.tag == DDOG_PROF_RESULT_BYTE_SLICE_ERR_BYTE_SLICE) {
+    rb_raise(rb_eRuntimeError, "Failed to get bytes from profile: %"PRIsVALUE, get_error_details_and_drop(&raw_bytes.err));
+  }
+  return raw_bytes.ok;
+}
+
+static ddog_prof_EncodedProfile *internal_to_ddog_prof_EncodedProfile(VALUE object) {
+  ddog_prof_EncodedProfile *state;
+  TypedData_Get_Struct(object, ddog_prof_EncodedProfile, &encoded_profile_typed_data, state);
+  return state;
+}
+
+ddog_prof_EncodedProfile *to_ddog_prof_EncodedProfile(VALUE object) {
+  ddog_prof_EncodedProfile *state = internal_to_ddog_prof_EncodedProfile(object);
+  get_bytes(state); // Validate profile is still usable -- if it's not, this will raise an exception
+  return state;
+}
+
 static void encoded_profile_typed_data_free(void *state_ptr) {
   ddog_prof_EncodedProfile *state = (ddog_prof_EncodedProfile *) state_ptr;
 
@@ -49,18 +69,8 @@ static void encoded_profile_typed_data_free(void *state_ptr) {
 }
 
 static VALUE _native_bytes(VALUE self) {
-  ddog_prof_EncodedProfile *state;
-  TypedData_Get_Struct(self, ddog_prof_EncodedProfile, &encoded_profile_typed_data, state);
-
-  return ruby_string_from_vec_u8(state->buffer);
-
-  // TODO: This will be used for libdatadog 17
-  /*ddog_prof_Result_ByteSlice raw_bytes = ddog_prof_EncodedProfile_bytes(state);
-  if (raw_bytes.tag == DDOG_PROF_RESULT_BYTE_SLICE_ERR_BYTE_SLICE) {
-    rb_raise(rb_eRuntimeError, "Failed to get bytes from profile: %"PRIsVALUE, get_error_details_and_drop(&raw_bytes.err));
-  }
-
-  return rb_str_new((const char *) raw_bytes.ok.ptr, raw_bytes.ok.len);*/
+  ddog_ByteSlice bytes = get_bytes(internal_to_ddog_prof_EncodedProfile(self));
+  return rb_str_new((const char *) bytes.ptr, bytes.len);
 }
 
 VALUE enforce_encoded_profile_instance(VALUE object) {

data/ext/datadog_profiling_native_extension/encoded_profile.h

@@ -5,3 +5,4 @@
 
 VALUE from_ddog_prof_EncodedProfile(ddog_prof_EncodedProfile profile);
 VALUE enforce_encoded_profile_instance(VALUE object);
+ddog_prof_EncodedProfile *to_ddog_prof_EncodedProfile(VALUE object);

data/ext/datadog_profiling_native_extension/http_transport.c

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

data/ext/datadog_profiling_native_extension/stack_recorder.c

@@ -363,7 +363,7 @@ static void initialize_profiles(stack_recorder_state *state, ddog_prof_Slice_Val
   ddog_Timespec start_timestamp = system_epoch_now_timespec();
 
   ddog_prof_Profile_NewResult slot_one_profile_result =
-    ddog_prof_Profile_new(sample_types, NULL /* period is optional */, &start_timestamp);
+    ddog_prof_Profile_new(sample_types, NULL /* period is optional */);
 
   if (slot_one_profile_result.tag == DDOG_PROF_PROFILE_NEW_RESULT_ERR) {
     rb_raise(rb_eRuntimeError, "Failed to initialize slot one profile: %"PRIsVALUE, get_error_details_and_drop(&slot_one_profile_result.err));
@@ -372,7 +372,7 @@ static void initialize_profiles(stack_recorder_state *state, ddog_prof_Slice_Val
   state->profile_slot_one = (profile_slot) { .profile = slot_one_profile_result.ok, .start_timestamp = start_timestamp };
 
   ddog_prof_Profile_NewResult slot_two_profile_result =
-    ddog_prof_Profile_new(sample_types, NULL /* period is optional */, &start_timestamp);
+    ddog_prof_Profile_new(sample_types, NULL /* period is optional */);
 
   if (slot_two_profile_result.tag == DDOG_PROF_PROFILE_NEW_RESULT_ERR) {
     // Note: No need to take any special care of slot one, it'll get cleaned up by stack_recorder_typed_data_free
@@ -763,7 +763,6 @@ static void *call_serialize_without_gvl(void *call_args) {
   long serialize_no_gvl_start_time_ns = monotonic_wall_time_now_ns(DO_NOT_RAISE_ON_FAILURE);
 
   profile_slot *slot_now_inactive = serializer_flip_active_and_inactive_slots(args->state);
-
   args->slot = slot_now_inactive;
 
   // Now that we have the inactive profile with all but heap samples, lets fill it with heap data
@@ -772,7 +771,7 @@ static void *call_serialize_without_gvl(void *call_args) {
   args->heap_profile_build_time_ns = monotonic_wall_time_now_ns(DO_NOT_RAISE_ON_FAILURE) - serialize_no_gvl_start_time_ns;
 
   // Note: The profile gets reset by the serialize call
-  args->result = ddog_prof_Profile_serialize(&args->slot->profile, &args->finish_timestamp, NULL /* duration_nanos is optional */, NULL /* start_time is optional */);
+  args->result = ddog_prof_Profile_serialize(&args->slot->profile, &args->slot->start_timestamp, &args->finish_timestamp);
   args->serialize_ran = true;
   args->serialize_no_gvl_time_ns = monotonic_wall_time_now_ns(DO_NOT_RAISE_ON_FAILURE) - serialize_no_gvl_start_time_ns;
 
@@ -949,7 +948,7 @@ static VALUE _native_check_heap_hashes(DDTRACE_UNUSED VALUE _self, VALUE locatio
 }
 
 static void reset_profile_slot(profile_slot *slot, ddog_Timespec start_timestamp) {
-  ddog_prof_Profile_Result reset_result = ddog_prof_Profile_reset(&slot->profile, &start_timestamp);
+  ddog_prof_Profile_Result reset_result = ddog_prof_Profile_reset(&slot->profile);
   if (reset_result.tag == DDOG_PROF_PROFILE_RESULT_ERR) {
     rb_raise(rb_eRuntimeError, "Failed to reset profile: %"PRIsVALUE, get_error_details_and_drop(&reset_result.err));
   }

data/ext/libdatadog_api/crashtracker.c

@@ -6,6 +6,8 @@
 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 bool first_init = true;
+
 // Used to report Ruby VM crashes.
 // Once initialized, segfaults will be reported automatically using libdatadog.
 
@@ -62,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,
@@ -92,9 +94,14 @@ static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUS
 
   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);
@@ -108,7 +115,7 @@ static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUS
 }
 
 static VALUE _native_stop(DDTRACE_UNUSED VALUE _self) {
-  ddog_VoidResult result = ddog_crasht_shutdown();
+  ddog_VoidResult result = ddog_crasht_disable();
 
   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/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_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 = '~> 16.0.1.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.

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Datadog
+  module AppSec
+    module APISecurity
+      # An LRU (Least Recently Used) cache implementation that relies on the
+      # Ruby 1.9+ `Hash` implementation that guarantees insertion order.
+      #
+      # WARNING: This implementation is NOT thread-safe and should be used
+      #          in a single-threaded context.
+      class LRUCache
+        extend Forwardable
+
+        def_delegators :@store, :clear, :empty?
+
+        def initialize(max_size)
+          raise ArgumentError, 'max_size must be an Integer' unless max_size.is_a?(Integer)
+          raise ArgumentError, 'max_size must be greater than 0' if max_size <= 0
+
+          @max_size = max_size
+          @store = {}
+        end
+
+        # NOTE: Accessing a key moves it to the end of the list.
+        def [](key)
+          if (entry = @store.delete(key))
+            @store[key] = entry
+          end
+        end
+
+        # NOTE: If the key exists, it's moved to the end of the list and
+        #       if does not, the given block will be executed and the result
+        #       will be stored (which will add it to the end of the list).
+        def fetch_or_store(key)
+          if (entry = @store.delete(key))
+            return @store[key] = entry
+          end
+
+          # NOTE: evict the oldest entry if store reached the maximum allowed size
+          @store.shift if @store.size >= @max_size
+
+          @store[key] ||= yield
+        end
+      end
+    end
+  end
+end

data/lib/datadog/appsec/api_security.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Datadog
+  module AppSec
+    # A namespace for API Security features.
+    module APISecurity
+    end
+  end
+end

data/lib/datadog/core/buffer/random.rb

@@ -40,7 +40,23 @@ module Datadog
           add_all!(underflow) unless underflow.nil?
 
           # Iteratively replace items, to ensure pseudo-random replacement.
-          overflow.each { |item| replace!(item) } unless overflow.nil?
+          overflow&.each { |item| replace!(item) }
+        end
+
+        def unshift(*items)
+          # TODO The existing concat implementation does not always append
+          # to the end of the buffer - if the buffer is full, a random
+          # item is deleted and the new item is added in the position of
+          # removed item.
+          # Therefore, if we want to preserve the item order, concat
+          # would also need to be changed to maintain order.
+          # With the existing implementation, the idea is to not move
+          # existing items around, which is what sets unshift apart from
+          # concat to begin with.
+          #
+          # Since this method currently delegates to +concat+, it does not
+          # have a matching definition in the thread-safe worker.
+          concat(items)
         end
 
         # Stored items are returned and the local buffer is reset.
@@ -78,7 +94,7 @@ module Datadog
           underflow = nil
           overflow = nil
 
-          overflow_size = @max_size > 0 ? (@items.length + items.length) - @max_size : 0
+          overflow_size = (@max_size > 0) ? (@items.length + items.length) - @max_size : 0
 
           if overflow_size > 0
             # Items will overflow

data/lib/datadog/core/configuration/agent_settings_resolver.rb

@@ -37,8 +37,8 @@ module Datadog
             case adapter
             when Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER
               hostname = self.hostname
-              hostname = "[#{hostname}]" if hostname =~ IPV6_REGEXP
-              "#{ssl ? 'https' : 'http'}://#{hostname}:#{port}/"
+              hostname = "[#{hostname}]" if IPV6_REGEXP.match?(hostname)
+              "#{ssl ? "https" : "http"}://#{hostname}:#{port}/"
             when Datadog::Core::Configuration::Ext::Agent::UnixSocket::ADAPTER
               "unix://#{uds_path}"
             else
@@ -158,7 +158,7 @@ module Datadog
               value: settings.agent.timeout_seconds,
             ),
             try_parsing_as_integer(
-              friendly_name: "#{Datadog::Core::Configuration::Ext::Agent::ENV_DEFAULT_TIMEOUT_SECONDS} "\
+              friendly_name: "#{Datadog::Core::Configuration::Ext::Agent::ENV_DEFAULT_TIMEOUT_SECONDS} " \
                 'environment variable',
               value: ENV[Datadog::Core::Configuration::Ext::Agent::ENV_DEFAULT_TIMEOUT_SECONDS],
             )
@@ -338,13 +338,13 @@ module Datadog
           log_warning(
             'Configuration mismatch: values differ between ' \
             "#{detected_configurations_in_priority_order
-              .map { |config| "#{config.friendly_name} (#{config.value.inspect})" }.join(' and ')}" \
+              .map { |config| "#{config.friendly_name} (#{config.value.inspect})" }.join(" and ")}" \
             ". Using #{detected_configurations_in_priority_order.first.value.inspect} and ignoring other configuration."
           )
         end
 
         def log_warning(message)
-          logger.warn(message) if logger
+          logger&.warn(message)
         end
 
         def http_scheme?(uri)