ddtrace 1.5.2 → 1.6.0

data/ext/ddtrace_profiling_native_extension/stack_recorder.c

@@ -7,7 +7,7 @@
 #include "libdatadog_helpers.h"
 #include "ruby_helpers.h"
 
-// Used to wrap a ddprof_ffi_Profile in a Ruby object and expose Ruby-level serialization APIs
+// Used to wrap a ddog_Profile in a Ruby object and expose Ruby-level serialization APIs
 // This file implements the native bits of the Datadog::Profiling::StackRecorder class
 
 // ---
@@ -24,7 +24,7 @@
 // 2. The thread that serializes and reports profiles, let's call it the **serializer thread**. We enforce that there
 // cannot be more than one thread attempting to serialize profiles at a time.
 //
-// If both the sampler and serializer threads are trying to access the same `ddprof_ffi_Profile` in parallel, we will
+// If both the sampler and serializer threads are trying to access the same `ddog_Profile` in parallel, we will
 // have a concurrency issue. Thus, the StackRecorder has an added mechanism to avoid this.
 //
 // As an additional constraint, the **sampler thread** has absolute priority and must never block while
@@ -32,7 +32,7 @@
 //
 // ### The solution: Keep two profiles at the same time
 //
-// To solve for the constraints above, the StackRecorder keeps two `ddprof_ffi_Profile` profile instances inside itself.
+// To solve for the constraints above, the StackRecorder keeps two `ddog_Profile` profile instances inside itself.
 // They are called the `slot_one_profile` and `slot_two_profile`.
 //
 // Each profile is paired with its own mutex. `slot_one_profile` is protected by `slot_one_mutex` and `slot_two_profile`
@@ -135,10 +135,10 @@ static VALUE stack_recorder_class = Qnil;
 // Contains native state for each instance
 struct stack_recorder_state {
   pthread_mutex_t slot_one_mutex;
-  ddprof_ffi_Profile *slot_one_profile;
+  ddog_Profile *slot_one_profile;
 
   pthread_mutex_t slot_two_mutex;
-  ddprof_ffi_Profile *slot_two_profile;
+  ddog_Profile *slot_two_profile;
 
   short active_slot; // MUST NEVER BE ACCESSED FROM record_sample; this is NOT for the sampler thread to use.
 };
@@ -146,7 +146,7 @@ struct stack_recorder_state {
 // Used to return a pair of values from sampler_lock_active_profile()
 struct active_slot_pair {
   pthread_mutex_t *mutex;
-  ddprof_ffi_Profile *profile;
+  ddog_Profile *profile;
 };
 
 struct call_serialize_without_gvl_arguments {
@@ -154,8 +154,8 @@ struct call_serialize_without_gvl_arguments {
   struct stack_recorder_state *state;
 
   // Set by callee
-  ddprof_ffi_Profile *profile;
-  ddprof_ffi_SerializeResult result;
+  ddog_Profile *profile;
+  ddog_SerializeResult result;
 
   // Set by both
   bool serialize_ran;
@@ -164,15 +164,16 @@ struct call_serialize_without_gvl_arguments {
 static VALUE _native_new(VALUE klass);
 static void stack_recorder_typed_data_free(void *data);
 static VALUE _native_serialize(VALUE self, VALUE recorder_instance);
-static VALUE ruby_time_from(ddprof_ffi_Timespec ddprof_time);
+static VALUE ruby_time_from(ddog_Timespec ddprof_time);
 static void *call_serialize_without_gvl(void *call_args);
 static struct active_slot_pair sampler_lock_active_profile();
 static void sampler_unlock_active_profile(struct active_slot_pair active_slot);
-static ddprof_ffi_Profile *serializer_flip_active_and_inactive_slots(struct stack_recorder_state *state);
+static ddog_Profile *serializer_flip_active_and_inactive_slots(struct stack_recorder_state *state, ddog_Timespec start_timestamp_for_next_profile);
 static VALUE _native_active_slot(DDTRACE_UNUSED VALUE _self, VALUE recorder_instance);
 static VALUE _native_is_slot_one_mutex_locked(DDTRACE_UNUSED VALUE _self, VALUE recorder_instance);
 static VALUE _native_is_slot_two_mutex_locked(DDTRACE_UNUSED VALUE _self, VALUE recorder_instance);
 static VALUE test_slot_mutex_state(VALUE recorder_instance, int slot);
+static ddog_Timespec time_now();
 
 void stack_recorder_init(VALUE profiling_module) {
   stack_recorder_class = rb_define_class_under(profiling_module, "StackRecorder", rb_cObject);
@@ -199,7 +200,7 @@ void stack_recorder_init(VALUE profiling_module) {
   ruby_time_from_id = rb_intern_const("ruby_time_from");
 }
 
-// This structure is used to define a Ruby object that stores a pointer to a ddprof_ffi_Profile instance
+// This structure is used to define a Ruby object that stores a pointer to a ddog_Profile instance
 // See also https://github.com/ruby/ruby/blob/master/doc/extension.rdoc for how this works
 static const rb_data_type_t stack_recorder_typed_data = {
   .wrap_struct_name = "Datadog::Profiling::StackRecorder",
@@ -214,7 +215,7 @@ static const rb_data_type_t stack_recorder_typed_data = {
 static VALUE _native_new(VALUE klass) {
   struct stack_recorder_state *state = ruby_xcalloc(1, sizeof(struct stack_recorder_state));
 
-  ddprof_ffi_Slice_value_type sample_types = {.ptr = enabled_value_types, .len = ENABLED_VALUE_TYPES_COUNT};
+  ddog_Slice_value_type sample_types = {.ptr = enabled_value_types, .len = ENABLED_VALUE_TYPES_COUNT};
 
   state->slot_one_mutex = (pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER;
   state->slot_two_mutex = (pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER;
@@ -227,8 +228,8 @@ static VALUE _native_new(VALUE klass) {
 
   // Note: Don't raise exceptions after this point, since it'll lead to libdatadog memory leaking!
 
-  state->slot_one_profile = ddprof_ffi_Profile_new(sample_types, NULL /* period is optional */, NULL /* start_time is optional */);
-  state->slot_two_profile = ddprof_ffi_Profile_new(sample_types, NULL /* period is optional */, NULL /* start_time is optional */);
+  state->slot_one_profile = ddog_Profile_new(sample_types, NULL /* period is optional */, NULL /* start_time is optional */);
+  state->slot_two_profile = ddog_Profile_new(sample_types, NULL /* period is optional */, NULL /* start_time is optional */);
 
   return TypedData_Wrap_Struct(klass, &stack_recorder_typed_data, state);
 }
@@ -237,10 +238,10 @@ static void stack_recorder_typed_data_free(void *state_ptr) {
   struct stack_recorder_state *state = (struct stack_recorder_state *) state_ptr;
 
   pthread_mutex_destroy(&state->slot_one_mutex);
-  ddprof_ffi_Profile_free(state->slot_one_profile);
+  ddog_Profile_free(state->slot_one_profile);
 
   pthread_mutex_destroy(&state->slot_two_mutex);
-  ddprof_ffi_Profile_free(state->slot_two_profile);
+  ddog_Profile_free(state->slot_two_profile);
 
   ruby_xfree(state);
 }
@@ -267,33 +268,33 @@ static VALUE _native_serialize(DDTRACE_UNUSED VALUE _self, VALUE recorder_instan
     rb_thread_call_without_gvl2(call_serialize_without_gvl, &args, NULL /* No interruption function needed in this case */, NULL /* Not needed */);
   }
 
-  ddprof_ffi_SerializeResult serialized_profile = args.result;
+  ddog_SerializeResult serialized_profile = args.result;
 
-  if (serialized_profile.tag == DDPROF_FFI_SERIALIZE_RESULT_ERR) {
+  if (serialized_profile.tag == DDOG_SERIALIZE_RESULT_ERR) {
     VALUE err_details = ruby_string_from_vec_u8(serialized_profile.err);
-    ddprof_ffi_SerializeResult_drop(serialized_profile);
+    ddog_SerializeResult_drop(serialized_profile);
     return rb_ary_new_from_args(2, error_symbol, err_details);
   }
 
   VALUE encoded_pprof = ruby_string_from_vec_u8(serialized_profile.ok.buffer);
 
-  ddprof_ffi_Timespec ddprof_start = serialized_profile.ok.start;
-  ddprof_ffi_Timespec ddprof_finish = serialized_profile.ok.end;
+  ddog_Timespec ddprof_start = serialized_profile.ok.start;
+  ddog_Timespec ddprof_finish = serialized_profile.ok.end;
 
   // Clean up libdatadog object to avoid leaking in case ruby_time_from raises an exception
-  ddprof_ffi_SerializeResult_drop(serialized_profile);
+  ddog_SerializeResult_drop(serialized_profile);
 
   VALUE start = ruby_time_from(ddprof_start);
   VALUE finish = ruby_time_from(ddprof_finish);
 
-  if (!ddprof_ffi_Profile_reset(args.profile, NULL /* start_time is optional */ )) {
+  if (!ddog_Profile_reset(args.profile, NULL /* start_time is optional */ )) {
     return rb_ary_new_from_args(2, error_symbol, rb_str_new_cstr("Failed to reset profile"));
   }
 
   return rb_ary_new_from_args(2, ok_symbol, rb_ary_new_from_args(3, start, finish, encoded_pprof));
 }
 
-static VALUE ruby_time_from(ddprof_ffi_Timespec ddprof_time) {
+static VALUE ruby_time_from(ddog_Timespec ddprof_time) {
   #ifndef NO_RB_TIME_TIMESPEC_NEW // Modern Rubies
     const int utc = INT_MAX - 1; // From Ruby sources
     struct timespec time = {.tv_sec = ddprof_time.seconds, .tv_nsec = ddprof_time.nanoseconds};
@@ -303,13 +304,13 @@ static VALUE ruby_time_from(ddprof_ffi_Timespec ddprof_time) {
   #endif
 }
 
-void record_sample(VALUE recorder_instance, ddprof_ffi_Sample sample) {
+void record_sample(VALUE recorder_instance, ddog_Sample sample) {
   struct stack_recorder_state *state;
   TypedData_Get_Struct(recorder_instance, struct stack_recorder_state, &stack_recorder_typed_data, state);
 
   struct active_slot_pair active_slot = sampler_lock_active_profile(state);
 
-  ddprof_ffi_Profile_add(active_slot.profile, sample);
+  ddog_Profile_add(active_slot.profile, sample);
 
   sampler_unlock_active_profile(active_slot);
 }
@@ -317,8 +318,10 @@ void record_sample(VALUE recorder_instance, ddprof_ffi_Sample sample) {
 static void *call_serialize_without_gvl(void *call_args) {
   struct call_serialize_without_gvl_arguments *args = (struct call_serialize_without_gvl_arguments *) call_args;
 
-  args->profile = serializer_flip_active_and_inactive_slots(args->state);
-  args->result = ddprof_ffi_Profile_serialize(args->profile, NULL /* end_time is optional */, NULL /* duration_nanos is optional */);
+  ddog_Timespec finish_timestamp = time_now();
+
+  args->profile = serializer_flip_active_and_inactive_slots(args->state, finish_timestamp);
+  args->result = ddog_Profile_serialize(args->profile, &finish_timestamp, NULL /* duration_nanos is optional */);
   args->serialize_ran = true;
 
   return NULL; // Unused
@@ -357,7 +360,7 @@ static void sampler_unlock_active_profile(struct active_slot_pair active_slot) {
   if (error != 0) rb_syserr_fail(error, "Unexpected failure in sampler_unlock_active_profile");
 }
 
-static ddprof_ffi_Profile *serializer_flip_active_and_inactive_slots(struct stack_recorder_state *state) {
+static ddog_Profile *serializer_flip_active_and_inactive_slots(struct stack_recorder_state *state, ddog_Timespec start_timestamp_for_next_profile) {
   int error;
   int previously_active_slot = state->active_slot;
 
@@ -368,6 +371,10 @@ static ddprof_ffi_Profile *serializer_flip_active_and_inactive_slots(struct stac
   pthread_mutex_t *previously_active = (previously_active_slot == 1) ? &state->slot_one_mutex : &state->slot_two_mutex;
   pthread_mutex_t *previously_inactive = (previously_active_slot == 1) ? &state->slot_two_mutex : &state->slot_one_mutex;
 
+  // Before making this profile active, we reset it so that it uses the correct timestamp for its start
+  ddog_Profile *previously_inactive_profile = (previously_active_slot == 1) ? state->slot_two_profile : state->slot_one_profile;
+  if (!ddog_Profile_reset(previously_inactive_profile, &start_timestamp_for_next_profile)) rb_raise(rb_eRuntimeError, "Failed to reset profile");
+
   // Release the lock, thus making this slot active
   error = pthread_mutex_unlock(previously_inactive);
   if (error) rb_syserr_fail(error, "Unexpected failure during serializer_flip_active_and_inactive_slots for previously_inactive");
@@ -420,3 +427,12 @@ static VALUE test_slot_mutex_state(VALUE recorder_instance, int slot) {
     rb_syserr_fail(error, "Unexpected failure when checking mutex state");
   }
 }
+
+// Note that this is using CLOCK_REALTIME (e.g. actual time since unix epoch) and not the CLOCK_MONOTONIC as we use in other parts of the codebase
+static ddog_Timespec time_now() {
+  struct timespec current_time;
+
+  if (clock_gettime(CLOCK_REALTIME, &current_time) != 0) rb_sys_fail("Failed to read CLOCK_REALTIME");
+
+  return (ddog_Timespec) {.seconds = current_time.tv_sec, .nanoseconds = (uint32_t) current_time.tv_nsec};
+}

data/ext/ddtrace_profiling_native_extension/stack_recorder.h

@@ -1,16 +1,16 @@
 #pragma once
 
-#include <ddprof/ffi.h>
+#include <datadog/profiling.h>
 
-// Note: Please DO NOT use `VALUE_STRING` anywhere else, instead use `DDPROF_FFI_CHARSLICE_C`.
+// Note: Please DO NOT use `VALUE_STRING` anywhere else, instead use `DDOG_CHARSLICE_C`.
 // `VALUE_STRING` is only needed because older versions of gcc (4.9.2, used in our Ruby 2.2 CI test images)
 // tripped when compiling `enabled_value_types` using `-std=gnu99` due to the extra cast that is included in
-// `DDPROF_FFI_CHARSLICE_C` with the following error:
+// `DDOG_CHARSLICE_C` with the following error:
 //
 // ```
 // compiling ../../../../ext/ddtrace_profiling_native_extension/stack_recorder.c
 // ../../../../ext/ddtrace_profiling_native_extension/stack_recorder.c:23:1: error: initializer element is not constant
-// static const ddprof_ffi_ValueType enabled_value_types[] = {CPU_TIME_VALUE, CPU_SAMPLES_VALUE, WALL_TIME_VALUE};
+// static const ddog_ValueType enabled_value_types[] = {CPU_TIME_VALUE, CPU_SAMPLES_VALUE, WALL_TIME_VALUE};
 // ^
 // ```
 #define VALUE_STRING(string) {.ptr = "" string, .len = sizeof(string) - 1}
@@ -23,7 +23,7 @@
 #define HEAP_LIVE_SIZE_VALUE    {.type_ = VALUE_STRING("heap-live-size"),    .unit = VALUE_STRING("bytes")}
 #define HEAP_LIVE_SAMPLES_VALUE {.type_ = VALUE_STRING("heap-live-samples"), .unit = VALUE_STRING("count")}
 
-static const ddprof_ffi_ValueType enabled_value_types[] = {
+static const ddog_ValueType enabled_value_types[] = {
   #define CPU_TIME_VALUE_POS 0
   CPU_TIME_VALUE,
   #define CPU_SAMPLES_VALUE_POS 1
@@ -32,7 +32,7 @@ static const ddprof_ffi_ValueType enabled_value_types[] = {
   WALL_TIME_VALUE
 };
 
-#define ENABLED_VALUE_TYPES_COUNT (sizeof(enabled_value_types) / sizeof(ddprof_ffi_ValueType))
+#define ENABLED_VALUE_TYPES_COUNT (sizeof(enabled_value_types) / sizeof(ddog_ValueType))
 
-void record_sample(VALUE recorder_instance, ddprof_ffi_Sample sample);
+void record_sample(VALUE recorder_instance, ddog_Sample sample);
 VALUE enforce_recorder_instance(VALUE object);

data/lib/datadog/appsec/contrib/rack/request_middleware.rb

@@ -114,6 +114,10 @@ module Datadog
 
                 # Ensure these tags reach the backend
                 trace.keep!
+                trace.set_tag(
+                  Datadog::Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER,
+                  Datadog::Tracing::Sampling::Ext::Decision::ASM
+                )
               end
             end
           end

data/lib/datadog/appsec/event.rb

@@ -51,6 +51,7 @@ module Datadog
         end
       end
 
+      # rubocop:disable Metrics/MethodLength
       def self.record_via_span(*events) # rubocop:disable Metrics/AbcSize
         events.group_by { |e| e[:trace] }.each do |trace, event_group|
           unless trace
@@ -59,6 +60,10 @@ module Datadog
           end
 
           trace.keep!
+          trace.set_tag(
+            Datadog::Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER,
+            Datadog::Tracing::Sampling::Ext::Decision::ASM
+          )
 
           # prepare and gather tags to apply
           trace_tags = event_group.each_with_object({}) do |event, tags|
@@ -106,6 +111,7 @@ module Datadog
           end
         end
       end
+      # rubocop:enable Metrics/MethodLength
     end
   end
 end

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

@@ -181,7 +181,7 @@ module Datadog
 
               next unless response && !response.internal_error? && response.service_rates
 
-              sampler.update(response.service_rates)
+              sampler.update(response.service_rates, decision: Tracing::Sampling::Ext::Decision::AGENT_RATE)
             end
           end
 
@@ -251,7 +251,9 @@ module Datadog
               recorder = Datadog::Profiling::StackRecorder.new
               collector = Datadog::Profiling::Collectors::CpuAndWallTimeWorker.new(
                 recorder: recorder,
-                max_frames: settings.profiling.advanced.max_frames
+                max_frames: settings.profiling.advanced.max_frames,
+                tracer: tracer,
+                gc_profiling_enabled: should_enable_gc_profiling?(settings)
               )
             else
               trace_identifiers_helper = Profiling::TraceIdentifiers::Helper.new(
@@ -320,18 +322,6 @@ module Datadog
 
           def build_profiler_transport(settings, agent_settings)
             settings.profiling.exporter.transport ||
-              if settings.profiling.advanced.legacy_transport_enabled
-                require_relative '../../profiling/transport/http'
-
-                Datadog.logger.warn('Using legacy profiling transport. Do not use unless instructed to by support.')
-
-                Profiling::Transport::HTTP.default(
-                  agent_settings: agent_settings,
-                  site: settings.site,
-                  api_key: settings.api_key,
-                  profiling_upload_timeout_seconds: settings.profiling.upload.timeout_seconds
-                )
-              end ||
               Profiling::HttpTransport.new(
                 agent_settings: agent_settings,
                 site: settings.site,
@@ -339,6 +329,22 @@ module Datadog
                 upload_timeout_seconds: settings.profiling.upload.timeout_seconds,
               )
           end
+
+          def should_enable_gc_profiling?(settings)
+            return true if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3')
+
+            # See comments on the setting definition for more context on why it exists.
+            if settings.profiling.advanced.force_enable_gc_profiling
+              Datadog.logger.debug(
+                'Profiling time/resources spent in Garbage Collection force enabled. Do not use Ractors in combination ' \
+                'with this option as profiles will be incomplete.'
+              )
+
+              true
+            else
+              false
+            end
+          end
         end
 
         attr_reader \

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

@@ -234,11 +234,17 @@ module Datadog
             # categorization of stack traces.
             option :code_provenance_enabled, default: true
 
-            # Use legacy transport code instead of HttpTransport. Temporarily added for migration to HttpTransport,
-            # and will be removed soon. Do not use unless instructed to by support.
+            # No longer does anything, and will be removed on dd-trace-rb 2.0.
+            #
+            # This was added as a temporary support option in case of issues with the new `Profiling::HttpTransport` class
+            # but we're now confident it's working nicely so we've removed the old code path.
             option :legacy_transport_enabled do |o|
-              o.default { env_to_bool('DD_PROFILING_LEGACY_TRANSPORT_ENABLED', false) }
-              o.lazy
+              o.on_set do
+                Datadog.logger.warn(
+                  'The profiling.advanced.legacy_transport_enabled setting has been deprecated for removal and no ' \
+                  'longer does anything. Please remove it from your Datadog.configure block.'
+                )
+              end
             end
 
             # Forces enabling the new profiler. We do not yet recommend turning on this option.
@@ -250,6 +256,25 @@ module Datadog
               o.default { env_to_bool('DD_PROFILING_FORCE_ENABLE_NEW', false) }
               o.lazy
             end
+
+            # Forces enabling of profiling of time/resources spent in Garbage Collection.
+            #
+            # Note that setting this to "false" (or not setting it) will not prevent the feature from being
+            # being automatically enabled in the future.
+            #
+            # This toggle was added because, although this feature is safe and enabled by default on Ruby 2.x,
+            # on Ruby 3.x it can break in applications that make use of Ractors due to two Ruby VM bugs:
+            # https://bugs.ruby-lang.org/issues/19112 AND https://bugs.ruby-lang.org/issues/18464.
+            #
+            # If you use Ruby 3.x and your application does not use Ractors (or if your Ruby has been patched), the
+            # feature is fully safe to enable and this toggle can be used to do so.
+            #
+            # We expect that once the above issue is patched, we'll automatically re-enable the feature on fixed Ruby
+            # versions.
+            option :force_enable_gc_profiling do |o|
+              o.default { env_to_bool('DD_PROFILING_FORCE_ENABLE_GC', false) }
+              o.lazy
+            end
           end
 
           # @public_api
@@ -700,6 +725,19 @@ module Datadog
               o.lazy
             end
           end
+
+          # Maximum size for the `x-datadog-tags` distributed trace tags header.
+          #
+          # If the serialized size of distributed trace tags is larger than this value, it will
+          # not be parsed if incoming, nor exported if outgoing. An error message will be logged
+          # in this case.
+          #
+          # @default `DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH` environment variable, otherwise `512`
+          # @return [Integer]
+          option :x_datadog_tags_max_length do |o|
+            o.default { env_to_int(Tracing::Configuration::Ext::Distributed::ENV_X_DATADOG_TAGS_MAX_LENGTH, 512) }
+            o.lazy
+          end
         end
 
         # The `version` tag in Datadog. Use it to enable [Deployment Tracking](https://docs.datadoghq.com/tracing/deployment_tracking/).

data/lib/datadog/core/diagnostics/environment_logger.rb

@@ -106,10 +106,14 @@ module Datadog
           Datadog.configuration.version
         end
 
-        # @return [String] target agent URL for trace flushing
+        # @return [String, nil] target agent URL for trace flushing
         def agent_url
           # Retrieve the effect agent URL, regardless of how it was configured
           transport = Tracing.send(:tracer).writer.transport
+
+          # return `nil` with IO transport
+          return unless transport.respond_to?(:client)
+
           adapter = transport.client.api.adapter
           adapter.url
         end

data/lib/datadog/core/utils/compression.rb

@@ -6,10 +6,13 @@ require 'zlib'
 module Datadog
   module Core
     module Utils
-      # Common database-related utility functions.
+      # Compression/decompression utility functions.
+      #
+      # @deprecated This is no longer used by ddtrace and will be removed in 2.0.
       module Compression
         module_function
 
+        # @deprecated This is no longer used by ddtrace and will be removed in 2.0.
         def gzip(string, level: nil, strategy: nil)
           sio = StringIO.new
           sio.binmode
@@ -19,6 +22,7 @@ module Datadog
           sio.string
         end
 
+        # @deprecated This is no longer used by ddtrace and will be removed in 2.0.
         def gunzip(string, encoding = ::Encoding::ASCII_8BIT)
           sio = StringIO.new(string)
           gz = Zlib::GzipReader.new(sio, encoding: encoding)

data/lib/datadog/core.rb

@@ -1,59 +1,5 @@
 # typed: strict
 
-# TODO: Move these requires to smaller modules.
-#       Would be better to lazy load these; not
-#       all of these components will be used in
-#       every application.
-# require_relative 'core/buffer/cruby'
-# require_relative 'core/buffer/random'
-# require_relative 'core/buffer/thread_safe'
-# require_relative 'core/chunker'
-# require_relative 'core/configuration'
-# require_relative 'core/diagnostics/environment_logger'
-# require_relative 'core/diagnostics/ext'
-# require_relative 'core/diagnostics/health'
-# require_relative 'core/encoding'
-# require_relative 'core/environment/cgroup'
-# require_relative 'core/environment/class_count'
-# require_relative 'core/environment/container'
-# require_relative 'core/environment/ext'
-# require_relative 'core/environment/gc'
-# require_relative 'core/environment/identity'
-# require_relative 'core/environment/socket'
-# require_relative 'core/environment/thread_count'
-# require_relative 'core/environment/variable_helpers'
-# require_relative 'core/environment/vm_cache'
-# require_relative 'core/error'
-# require_relative 'core/event'
-# require_relative 'core/git/ext'
-# require_relative 'core/logger'
-# require_relative 'core/metrics/client'
-# require_relative 'core/metrics/ext'
-# require_relative 'core/metrics/helpers'
-# require_relative 'core/metrics/logging'
-# require_relative 'core/metrics/metric'
-# require_relative 'core/metrics/options'
-# require_relative 'core/pin'
-# require_relative 'core/quantization/hash'
-# require_relative 'core/quantization/http'
-# require_relative 'core/runtime/ext'
-# require_relative 'core/runtime/metrics'
-# require_relative 'core/utils'
-# require_relative 'core/utils/compression'
-# require_relative 'core/utils/database'
-# require_relative 'core/utils/forking'
-# require_relative 'core/utils/object_set'
-# require_relative 'core/utils/only_once'
-# require_relative 'core/utils/sequence'
-# require_relative 'core/utils/string_table'
-# require_relative 'core/utils/time'
-# require_relative 'core/worker'
-# require_relative 'core/workers/async'
-# require_relative 'core/workers/interval_loop'
-# require_relative 'core/workers/polling'
-# require_relative 'core/workers/queue'
-# require_relative 'core/workers/runtime_metrics'
-
 require_relative 'core/extensions'
 
 # We must load core extensions to make certain global APIs

data/lib/datadog/profiling/collectors/cpu_and_wall_time.rb

@@ -11,8 +11,9 @@ module Datadog
       #
       # Methods prefixed with _native_ are implemented in `collectors_cpu_and_wall_time.c`
       class CpuAndWallTime
-        def initialize(recorder:, max_frames:)
-          self.class._native_initialize(self, recorder, max_frames)
+        def initialize(recorder:, max_frames:, tracer:)
+          tracer_context_key = safely_extract_context_key_from(tracer)
+          self.class._native_initialize(self, recorder, max_frames, tracer_context_key)
         end
 
         def inspect
@@ -21,6 +22,15 @@ module Datadog
           result[-1] = "#{self.class._native_inspect(self)}>"
           result
         end
+
+        private
+
+        def safely_extract_context_key_from(tracer)
+          tracer &&
+            tracer.respond_to?(:provider) &&
+            # NOTE: instance_variable_get always works, even on nil -- it just returns nil if the variable doesn't exist
+            tracer.provider.instance_variable_get(:@context).instance_variable_get(:@key)
+        end
       end
     end
   end

data/lib/datadog/profiling/collectors/cpu_and_wall_time_worker.rb

@@ -18,9 +18,11 @@ module Datadog
         def initialize(
           recorder:,
           max_frames:,
-          cpu_and_wall_time_collector: CpuAndWallTime.new(recorder: recorder, max_frames: max_frames)
+          tracer:,
+          gc_profiling_enabled:,
+          cpu_and_wall_time_collector: CpuAndWallTime.new(recorder: recorder, max_frames: max_frames, tracer: tracer)
         )
-          self.class._native_initialize(self, cpu_and_wall_time_collector)
+          self.class._native_initialize(self, cpu_and_wall_time_collector, gc_profiling_enabled)
           @worker_thread = nil
           @failure_exception = nil
           @start_stop_mutex = Mutex.new
@@ -28,7 +30,7 @@ module Datadog
 
         def start
           @start_stop_mutex.synchronize do
-            return if @worker_thread
+            return if @worker_thread && @worker_thread.alive?
 
             Datadog.logger.debug { "Starting thread for: #{self}" }
             @worker_thread = Thread.new do

data/lib/datadog/profiling/exporter.rb

@@ -1,7 +1,6 @@
 # typed: true
 
 require_relative 'ext'
-require_relative '../core/utils/compression'
 require_relative 'tag_builder'
 
 module Datadog
@@ -60,10 +59,9 @@ module Datadog
           start: start,
           finish: finish,
           pprof_file_name: Datadog::Profiling::Ext::Transport::HTTP::PPROF_DEFAULT_FILENAME,
-          pprof_data: Datadog::Core::Utils::Compression.gzip(uncompressed_pprof),
+          pprof_data: uncompressed_pprof.to_s,
           code_provenance_file_name: Datadog::Profiling::Ext::Transport::HTTP::CODE_PROVENANCE_FILENAME,
-          code_provenance_data:
-            (Datadog::Core::Utils::Compression.gzip(uncompressed_code_provenance) if uncompressed_code_provenance),
+          code_provenance_data: uncompressed_code_provenance,
           tags_as_array: Datadog::Profiling::TagBuilder.call(settings: Datadog.configuration).to_a,
         )
       end

data/lib/datadog/profiling/http_transport.rb

@@ -58,7 +58,7 @@ module Datadog
         end
       end
 
-      # Used to log soft failures in `ddprof_ffi_Vec_tag_push` (e.g. we still report the profile in these cases)
+      # Used to log soft failures in `ddog_Vec_tag_push` (e.g. we still report the profile in these cases)
       # Called from native code
       def self.log_failure_to_process_tag(failure_details)
         Datadog.logger.warn("Failed to add tag to profiling request: #{failure_details}")

data/lib/datadog/tracing/configuration/ext.rb

@@ -21,6 +21,7 @@ module Datadog
           PROPAGATION_STYLE_B3_SINGLE_HEADER = 'B3 single header'.freeze
           ENV_PROPAGATION_STYLE_INJECT = 'DD_PROPAGATION_STYLE_INJECT'.freeze
           ENV_PROPAGATION_STYLE_EXTRACT = 'DD_PROPAGATION_STYLE_EXTRACT'.freeze
+          ENV_X_DATADOG_TAGS_MAX_LENGTH = 'DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH'.freeze
         end
 
         # @public_api

data/lib/datadog/tracing/contrib/aws/instrumentation.rb

@@ -33,6 +33,8 @@ module Datadog
             span.name = Ext::SPAN_COMMAND
             span.resource = context.safely(:resource)
 
+            span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
+
             span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
             span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_COMMAND)
 

data/lib/datadog/tracing/contrib/dalli/ext.rb

@@ -17,6 +17,7 @@ module Datadog
           TAG_COMMAND = 'memcached.command'.freeze
           TAG_COMPONENT = 'dalli'.freeze
           TAG_OPERATION_COMMAND = 'command'.freeze
+          TAG_SYSTEM = 'memcached'.freeze
         end
       end
     end

data/lib/datadog/tracing/contrib/dalli/instrumentation.rb

@@ -3,6 +3,7 @@
 require_relative '../../metadata/ext'
 require_relative '../analytics'
 require_relative 'ext'
+require_relative '../ext'
 require_relative 'quantize'
 
 module Datadog
@@ -37,6 +38,9 @@ module Datadog
 
                 span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, hostname)
                 span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, port)
+
+                span.set_tag(Contrib::Ext::DB::TAG_SYSTEM, Ext::TAG_SYSTEM)
+
                 cmd = Quantize.format_command(op, args)
                 span.set_tag(Ext::TAG_COMMAND, cmd)