ddtrace 1.12.1 → 1.23.2

data/lib/datadog/profiling/component.rb

@@ -7,8 +7,8 @@ module Datadog
       # Passing in a `nil` tracer is supported and will disable the following profiling features:
       # * Code Hotspots panel in the trace viewer, as well as scoping a profile down to a span
       # * Endpoint aggregation in the profiler UX, including normalization (resource per endpoint call)
-      def self.build_profiler_component(settings:, agent_settings:, optional_tracer:)
-        return unless settings.profiling.enabled
+      def self.build_profiler_component(settings:, agent_settings:, optional_tracer:) # rubocop:disable Metrics/MethodLength
+        return [nil, { profiling_enabled: false }] unless settings.profiling.enabled
 
         # Workaround for weird dependency direction: the Core::Configuration::Components class currently has a
         # dependency on individual products, in this case the Profiler.
@@ -28,91 +28,75 @@ module Datadog
         # done, then profiling may not be loaded, and thus to avoid this issue we do a require here (which is a
         # no-op if profiling is already loaded).
         require_relative '../profiling'
-        return unless Profiling.supported?
 
-        unless defined?(Profiling::Tasks::Setup)
-          # In #1545 a user reported a NameError due to this constant being uninitialized
-          # I've documented my suspicion on why that happened in
-          # https://github.com/DataDog/dd-trace-rb/issues/1545#issuecomment-856049025
-          #
-          # > Thanks for the info! It seems to feed into my theory: there's two moments in the code where we check if
-          # > profiler is "supported": 1) when loading ddtrace (inside preload) and 2) when starting the profile
-          # > after Datadog.configure gets run.
-          # > The problem is that the code assumes that both checks 1) and 2) will always reach the same conclusion:
-          # > either profiler is supported, or profiler is not supported.
-          # > In the problematic case, it looks like in your case check 1 decides that profiler is not
-          # > supported => doesn't load it, and then check 2 decides that it is => assumes it is loaded and tries to
-          # > start it.
-          #
-          # I was never able to validate if this was the issue or why exactly .supported? would change its mind BUT
-          # just in case it happens again, I've left this check which avoids breaking the user's application AND
-          # would instead direct them to report it to us instead, so that we can investigate what's wrong.
-          #
-          # TODO: As of June 2021, most checks in .supported? are related to the google-protobuf gem; so it's
-          # very likely that it was the origin of the issue we saw. Thus, if, as planned we end up moving away from
-          # protobuf OR enough time has passed and no users saw the issue again, we can remove this check altogether.
-          Datadog.logger.error(
-            'Profiling was marked as supported and enabled, but setup task was not loaded properly. ' \
-            'Please report this at https://github.com/DataDog/dd-trace-rb/blob/master/CONTRIBUTING.md#found-a-bug'
-          )
-
-          return
-        end
+        return [nil, { profiling_enabled: false }] unless Profiling.supported?
 
-        # Load extensions needed to support some of the Profiling features
+        # Activate forking extensions
         Profiling::Tasks::Setup.new.run
 
         # NOTE: Please update the Initialization section of ProfilingDevelopment.md with any changes to this method
 
-        if enable_new_profiler?(settings)
-          recorder = Datadog::Profiling::StackRecorder.new(
-            cpu_time_enabled: RUBY_PLATFORM.include?('linux'), # Only supported on Linux currently
-            alloc_samples_enabled: false, # Always disabled for now -- work in progress
-          )
-          collector = Datadog::Profiling::Collectors::CpuAndWallTimeWorker.new(
-            recorder: recorder,
-            max_frames: settings.profiling.advanced.max_frames,
-            tracer: optional_tracer,
-            endpoint_collection_enabled: settings.profiling.advanced.endpoint.collection.enabled,
-            gc_profiling_enabled: enable_gc_profiling?(settings),
-            allocation_counting_enabled: settings.profiling.advanced.allocation_counting_enabled,
-            no_signals_workaround_enabled: no_signals_workaround_enabled?(settings),
-          )
-        else
-          load_pprof_support
+        no_signals_workaround_enabled = no_signals_workaround_enabled?(settings)
+        timeline_enabled = settings.profiling.advanced.timeline_enabled
+        allocation_profiling_enabled = enable_allocation_profiling?(settings)
+        heap_sample_every = get_heap_sample_every(settings)
+        heap_profiling_enabled = enable_heap_profiling?(settings, allocation_profiling_enabled, heap_sample_every)
+        heap_size_profiling_enabled = enable_heap_size_profiling?(settings, heap_profiling_enabled)
+
+        overhead_target_percentage = valid_overhead_target(settings.profiling.advanced.overhead_target_percentage)
+        upload_period_seconds = [60, settings.profiling.advanced.upload_period_seconds].max
+
+        recorder = Datadog::Profiling::StackRecorder.new(
+          cpu_time_enabled: RUBY_PLATFORM.include?('linux'), # Only supported on Linux currently
+          alloc_samples_enabled: allocation_profiling_enabled,
+          heap_samples_enabled: heap_profiling_enabled,
+          heap_size_enabled: heap_size_profiling_enabled,
+          heap_sample_every: heap_sample_every,
+          timeline_enabled: timeline_enabled,
+        )
+        thread_context_collector = build_thread_context_collector(settings, recorder, optional_tracer, timeline_enabled)
+        worker = Datadog::Profiling::Collectors::CpuAndWallTimeWorker.new(
+          gc_profiling_enabled: enable_gc_profiling?(settings),
+          no_signals_workaround_enabled: no_signals_workaround_enabled,
+          thread_context_collector: thread_context_collector,
+          dynamic_sampling_rate_overhead_target_percentage: overhead_target_percentage,
+          allocation_profiling_enabled: allocation_profiling_enabled,
+        )
 
-          recorder = build_profiler_old_recorder(settings)
-          collector = build_profiler_oldstack_collector(settings, recorder, optional_tracer)
-        end
+        internal_metadata = {
+          no_signals_workaround_enabled: no_signals_workaround_enabled,
+          timeline_enabled: timeline_enabled,
+          heap_sample_every: heap_sample_every,
+        }.freeze
 
-        exporter = build_profiler_exporter(settings, recorder)
+        exporter = build_profiler_exporter(settings, recorder, worker, internal_metadata: internal_metadata)
         transport = build_profiler_transport(settings, agent_settings)
-        scheduler = Profiling::Scheduler.new(exporter: exporter, transport: transport)
+        scheduler = Profiling::Scheduler.new(exporter: exporter, transport: transport, interval: upload_period_seconds)
 
-        Profiling::Profiler.new([collector], scheduler)
+        [Profiling::Profiler.new(worker: worker, scheduler: scheduler), { profiling_enabled: true }]
       end
 
-      private_class_method def self.build_profiler_old_recorder(settings)
-        Profiling::OldRecorder.new([Profiling::Events::StackSample], settings.profiling.advanced.max_events)
+      private_class_method def self.build_thread_context_collector(settings, recorder, optional_tracer, timeline_enabled)
+        Datadog::Profiling::Collectors::ThreadContext.new(
+          recorder: recorder,
+          max_frames: settings.profiling.advanced.max_frames,
+          tracer: optional_tracer,
+          endpoint_collection_enabled: settings.profiling.advanced.endpoint.collection.enabled,
+          timeline_enabled: timeline_enabled,
+        )
       end
 
-      private_class_method def self.build_profiler_exporter(settings, recorder)
+      private_class_method def self.build_profiler_exporter(settings, recorder, worker, internal_metadata:)
+        info_collector = Profiling::Collectors::Info.new(settings)
         code_provenance_collector =
           (Profiling::Collectors::CodeProvenance.new if settings.profiling.advanced.code_provenance_enabled)
 
-        Profiling::Exporter.new(pprof_recorder: recorder, code_provenance_collector: code_provenance_collector)
-      end
-
-      private_class_method def self.build_profiler_oldstack_collector(settings, old_recorder, tracer)
-        trace_identifiers_helper = Profiling::TraceIdentifiers::Helper.new(
-          tracer: tracer,
-          endpoint_collection_enabled: settings.profiling.advanced.endpoint.collection.enabled
-        )
-
-        Profiling::Collectors::OldStack.new(
-          old_recorder,
-          trace_identifiers_helper: trace_identifiers_helper,
-          max_frames: settings.profiling.advanced.max_frames
+        Profiling::Exporter.new(
+          pprof_recorder: recorder,
+          worker: worker,
+          info_collector: info_collector,
+          code_provenance_collector: code_provenance_collector,
+          internal_metadata: internal_metadata,
         )
       end
 
@@ -127,29 +111,133 @@ module Datadog
       end
 
       private_class_method def self.enable_gc_profiling?(settings)
-        # See comments on the setting definition for more context on why it exists.
-        if settings.profiling.advanced.force_enable_gc_profiling
-          if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3')
-            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.'
-            )
-          end
+        return false unless settings.profiling.advanced.gc_enabled
+
+        # SEVERE - Only with Ractors
+        # On Ruby versions 3.0 (all), 3.1.0 to 3.1.3, and 3.2.0 to 3.2.2 gc profiling can trigger a VM bug
+        # that causes a segmentation fault during garbage collection of Ractors
+        # (https://bugs.ruby-lang.org/issues/18464). We don't allow enabling gc profiling on such Rubies.
+        # This bug is fixed on Ruby versions 3.1.4, 3.2.3 and 3.3.0.
+        if RUBY_VERSION.start_with?('3.0.') ||
+            (RUBY_VERSION.start_with?('3.1.') && RUBY_VERSION < '3.1.4') ||
+            (RUBY_VERSION.start_with?('3.2.') && RUBY_VERSION < '3.2.3')
+          Datadog.logger.warn(
+            "Current Ruby version (#{RUBY_VERSION}) has a VM bug where enabling GC profiling would cause "\
+            'crashes (https://bugs.ruby-lang.org/issues/18464). GC profiling has been disabled.'
+          )
+          return false
+        elsif RUBY_VERSION.start_with?('3.')
+          Datadog.logger.debug(
+            'In all known versions of Ruby 3.x, using Ractors may result in GC profiling unexpectedly ' \
+            'stopping (https://bugs.ruby-lang.org/issues/19112). Note that this stop has no impact in your ' \
+            'application stability or performance. This does not happen if Ractors are not used.'
+          )
+        end
 
-          true
-        else
-          false
+        true
+      end
+
+      private_class_method def self.get_heap_sample_every(settings)
+        heap_sample_rate = settings.profiling.advanced.experimental_heap_sample_rate
+
+        raise ArgumentError, "Heap sample rate must be a positive integer. Was #{heap_sample_rate}" if heap_sample_rate <= 0
+
+        heap_sample_rate
+      end
+
+      private_class_method def self.enable_allocation_profiling?(settings)
+        return false unless settings.profiling.allocation_enabled
+
+        # Allocation sampling is safe and supported on Ruby 2.x, but has a few caveats on Ruby 3.x.
+
+        # SEVERE - All configurations
+        # Ruby 3.2.0 to 3.2.2 have a bug in the newobj tracepoint (https://bugs.ruby-lang.org/issues/19482,
+        # https://github.com/ruby/ruby/pull/7464) that makes this crash in any configuration. This bug is
+        # fixed on Ruby versions 3.2.3 and 3.3.0.
+        if RUBY_VERSION.start_with?('3.2.') && RUBY_VERSION < '3.2.3'
+          Datadog.logger.warn(
+            'Allocation profiling is not supported in Ruby versions 3.2.0, 3.2.1 and 3.2.2 and will be forcibly '\
+            'disabled. This is due to a VM bug that can lead to crashes (https://bugs.ruby-lang.org/issues/19482). '\
+            'Other Ruby versions do not suffer from this issue.'
+          )
+          return false
+        end
+
+        # SEVERE - Only with Ractors
+        # On Ruby versions 3.0 (all), 3.1.0 to 3.1.3, and 3.2.0 to 3.2.2 allocation profiling can trigger a VM bug
+        # that causes a segmentation fault during garbage collection of Ractors
+        # (https://bugs.ruby-lang.org/issues/18464). We don't recommend using this feature on such Rubies.
+        # This bug is fixed on Ruby versions 3.1.4, 3.2.3 and 3.3.0.
+        if RUBY_VERSION.start_with?('3.0.') ||
+            (RUBY_VERSION.start_with?('3.1.') && RUBY_VERSION < '3.1.4') ||
+            (RUBY_VERSION.start_with?('3.2.') && RUBY_VERSION < '3.2.3')
+          Datadog.logger.warn(
+            "Current Ruby version (#{RUBY_VERSION}) has a VM bug where enabling allocation profiling while using "\
+            'Ractors may cause unexpected issues, including crashes (https://bugs.ruby-lang.org/issues/18464). '\
+            'This does not happen if Ractors are not used.'
+          )
+        # ANNOYANCE - Only with Ractors
+        # On all known versions of Ruby 3.x, due to https://bugs.ruby-lang.org/issues/19112, when a ractor gets
+        # garbage collected, Ruby will disable all active tracepoints, which this feature internally relies on.
+        elsif RUBY_VERSION.start_with?('3.')
+          Datadog.logger.warn(
+            'In all known versions of Ruby 3.x, using Ractors may result in allocation profiling unexpectedly ' \
+            'stopping (https://bugs.ruby-lang.org/issues/19112). Note that this stop has no impact in your ' \
+            'application stability or performance. This does not happen if Ractors are not used.'
+          )
         end
+
+        Datadog.logger.debug('Enabled allocation profiling')
+
+        true
       end
 
-      private_class_method def self.enable_new_profiler?(settings)
-        if settings.profiling.advanced.force_enable_legacy_profiler
+      private_class_method def self.enable_heap_profiling?(settings, allocation_profiling_enabled, heap_sample_rate)
+        heap_profiling_enabled = settings.profiling.advanced.experimental_heap_enabled
+
+        return false unless heap_profiling_enabled
+
+        if RUBY_VERSION.start_with?('2.') && RUBY_VERSION < '2.7'
           Datadog.logger.warn(
-            'Legacy profiler has been force-enabled via configuration. Do not use unless instructed to by support.'
+            'Heap profiling currently relies on features introduced in Ruby 2.7 and will be forcibly disabled. '\
+            'Please upgrade to Ruby >= 2.7 in order to use this feature.'
           )
           return false
         end
 
+        if RUBY_VERSION < '3.1'
+          Datadog.logger.debug(
+            "Current Ruby version (#{RUBY_VERSION}) supports forced object recycling which has a bug that the " \
+            'heap profiler is forced to work around to remain accurate. This workaround requires force-setting '\
+            "the SEEN_OBJ_ID flag on objects that should have it but don't. Full details can be found in " \
+            'https://github.com/DataDog/dd-trace-rb/pull/3360. This workaround should be safe but can be ' \
+            'bypassed by disabling the heap profiler or upgrading to Ruby >= 3.1 where forced object recycling ' \
+            'was completely removed (https://bugs.ruby-lang.org/issues/18290).'
+          )
+        end
+
+        unless allocation_profiling_enabled
+          raise ArgumentError,
+            'Heap profiling requires allocation profiling to be enabled'
+        end
+
+        Datadog.logger.warn(
+          "Enabled experimental heap profiling: heap_sample_rate=#{heap_sample_rate}. This is experimental, not " \
+          'recommended, and will increase overhead!'
+        )
+
+        true
+      end
+
+      private_class_method def self.enable_heap_size_profiling?(settings, heap_profiling_enabled)
+        heap_size_profiling_enabled = settings.profiling.advanced.experimental_heap_size_enabled
+
+        return false unless heap_profiling_enabled && heap_size_profiling_enabled
+
+        Datadog.logger.warn(
+          'Enabled experimental heap size profiling. This is experimental, not recommended, and will increase overhead!'
+        )
+
         true
       end
 
@@ -198,7 +286,7 @@ module Datadog
         if Gem.loaded_specs['mysql2'] && incompatible_libmysqlclient_version?(settings)
           Datadog.logger.warn(
             'Enabling the profiling "no signals" workaround because an incompatible version of the mysql2 gem is ' \
-            'installed. Profiling data will have lower quality.' \
+            'installed. Profiling data will have lower quality. ' \
             'To fix this, upgrade the libmysqlclient in your OS image to version 8.0.0 or above.'
           )
           return true
@@ -214,6 +302,15 @@ module Datadog
           return true
         end
 
+        if (defined?(::PhusionPassenger) || Gem.loaded_specs['passenger']) && incompatible_passenger_version?
+          Datadog.logger.warn(
+            'Enabling the profiling "no signals" workaround because an incompatible version of the passenger gem is ' \
+            'installed. Profiling data will have lower quality.' \
+            'To fix this, upgrade the passenger gem to version 6.0.19 or above.'
+          )
+          return true
+        end
+
         false
       end
 
@@ -236,11 +333,27 @@ module Datadog
         begin
           require 'mysql2'
 
-          return true unless defined?(Mysql2::Client) && Mysql2::Client.respond_to?(:info)
+          # The mysql2-aurora gem likes to monkey patch itself in replacement of Mysql2::Client, and uses
+          # `method_missing` to delegate to the original BUT unfortunately does not implement `respond_to_missing?` and
+          # thus our `respond_to?(:info)` below was failing.
+          #
+          # But on the bright side, the gem does stash a reference to the original Mysql2::Client class in a constant,
+          # so if that constant exists, we use that for our probing.
+          mysql2_client_class =
+            if defined?(Mysql2::Aurora::ORIGINAL_CLIENT_CLASS)
+              Mysql2::Aurora::ORIGINAL_CLIENT_CLASS
+            elsif defined?(Mysql2::Client)
+              Mysql2::Client
+            end
 
-          libmysqlclient_version = Gem::Version.new(Mysql2::Client.info[:version])
+          return true unless mysql2_client_class && mysql2_client_class.respond_to?(:info)
 
-          compatible = libmysqlclient_version >= Gem::Version.new('8.0.0')
+          info = mysql2_client_class.info
+          libmysqlclient_version = Gem::Version.new(info[:version])
+
+          compatible =
+            libmysqlclient_version >= Gem::Version.new('8.0.0') ||
+            looks_like_mariadb?(info, libmysqlclient_version)
 
           Datadog.logger.debug(
             "The `mysql2` gem is using #{compatible ? 'a compatible' : 'an incompatible'} version of " \
@@ -258,17 +371,55 @@ module Datadog
         end
       end
 
-      # The old profiler's pprof support conflicts with the ruby-cloud-profiler gem.
+      # See https://github.com/datadog/dd-trace-rb/issues/2976 for details.
+      private_class_method def self.incompatible_passenger_version?
+        if Gem.loaded_specs['passenger']
+          Gem.loaded_specs['passenger'].version < Gem::Version.new('6.0.19')
+        else
+          true
+        end
+      end
+
+      private_class_method def self.valid_overhead_target(overhead_target_percentage)
+        if overhead_target_percentage > 0 && overhead_target_percentage <= 20
+          overhead_target_percentage
+        else
+          Datadog.logger.error(
+            'Ignoring invalid value for profiling overhead_target_percentage setting: ' \
+            "#{overhead_target_percentage.inspect}. Falling back to default value."
+          )
+
+          2.0
+        end
+      end
+
+      # To add just a bit more complexity to our detection code, in https://github.com/DataDog/dd-trace-rb/issues/3334
+      # a user reported that our code was incorrectly flagging the mariadb variant of libmysqlclient as being
+      # incompatible. In fact we have no reports of the mariadb variant needing the "no signals" workaround,
+      # so we flag it as compatible when it's in use.
+      #
+      # A problem is that there doesn't seem to be an obvious way to query the mysql2 gem on which kind of
+      # libmysqlclient it's using, so we detect it by looking at the version.
+      #
+      # The info method for mysql2 with mariadb looks something like this:
+      # `{:id=>30308, :version=>"3.3.8", :header_version=>"11.2.2"}`
+      #
+      # * The version seems to come from https://github.com/mariadb-corporation/mariadb-connector-c and the latest
+      # one is 3.x.
+      # * The header_version is what people usually see as the "mariadb version"
       #
-      # This is not a problem for almost all customers, since we now default everyone to use the new CPU Profiling 2.0
-      # profiler. But the issue was still triggered, because currently we still _load_ both the old and new profiling
-      # code paths.
+      # As a comparison, for libmysql the info looks like:
+      # * `{:id=>80035, :version=>"8.0.35", :header_version=>"8.0.35"}`
       #
-      # To work around this issue, and because we plan on deleting the old profiler soon, rather than poking at the
-      # pprof support code, we only load the conflicting file when the old profiler is in use. This way customers using
-      # the new profiler will not be affected by the issue any longer.
-      private_class_method def self.load_pprof_support
-        require_relative 'pprof/pprof_pb'
+      # Thus our detection is version 4 or older, because libmysqlclient 4 is almost 20 years old so it's most probably
+      # not that one + header_version being 10 or newer, since according to https://endoflife.date/mariadb that's a
+      # sane range for modern mariadb releases.
+      private_class_method def self.looks_like_mariadb?(info, libmysqlclient_version)
+        header_version = Gem::Version.new(info[:header_version]) if info[:header_version]
+
+        !!(header_version &&
+          libmysqlclient_version < Gem::Version.new('5.0.0') &&
+          header_version >= Gem::Version.new('10.0.0'))
       end
     end
   end

data/lib/datadog/profiling/exporter.rb

@@ -22,29 +22,41 @@ module Datadog
         :minimum_duration_seconds,
         :time_provider,
         :last_flush_finish_at,
-        :created_at
+        :created_at,
+        :internal_metadata,
+        :info_json
 
       public
 
       def initialize(
         pprof_recorder:,
+        worker:,
+        info_collector:,
         code_provenance_collector:,
+        internal_metadata:,
         minimum_duration_seconds: PROFILE_DURATION_THRESHOLD_SECONDS,
         time_provider: Time
       )
         @pprof_recorder = pprof_recorder
+        @worker = worker
         @code_provenance_collector = code_provenance_collector
         @minimum_duration_seconds = minimum_duration_seconds
         @time_provider = time_provider
         @last_flush_finish_at = nil
         @created_at = time_provider.now.utc
+        @internal_metadata = internal_metadata
+        # NOTE: At the time of this comment collected info does not change over time so we'll hardcode
+        #       it on startup to prevent serializing the same info on every flush.
+        @info_json = JSON.fast_generate(info_collector.info).freeze
       end
 
       def flush
-        start, finish, uncompressed_pprof = pprof_recorder.serialize
-        @last_flush_finish_at = finish
+        worker_stats = @worker.stats_and_reset_not_thread_safe
+        serialization_result = pprof_recorder.serialize
+        return if serialization_result.nil?
 
-        return if uncompressed_pprof.nil? # We don't want to report empty profiles
+        start, finish, compressed_pprof, profile_stats = serialization_result
+        @last_flush_finish_at = finish
 
         if duration_below_threshold?(start, finish)
           Datadog.logger.debug('Skipped exporting profiling events as profile duration is below minimum')
@@ -57,10 +69,19 @@ module Datadog
           start: start,
           finish: finish,
           pprof_file_name: Datadog::Profiling::Ext::Transport::HTTP::PPROF_DEFAULT_FILENAME,
-          pprof_data: uncompressed_pprof.to_s,
+          pprof_data: compressed_pprof.to_s,
           code_provenance_file_name: Datadog::Profiling::Ext::Transport::HTTP::CODE_PROVENANCE_FILENAME,
           code_provenance_data: uncompressed_code_provenance,
           tags_as_array: Datadog::Profiling::TagBuilder.call(settings: Datadog.configuration).to_a,
+          internal_metadata: internal_metadata.merge(
+            {
+              worker_stats: worker_stats,
+              profile_stats: profile_stats,
+              recorder_stats: pprof_recorder.stats,
+              gc: GC.stat,
+            }
+          ),
+          info_json: info_json,
         )
       end
 

data/lib/datadog/profiling/ext.rb

@@ -9,18 +9,6 @@ module Datadog
       ENV_AGENTLESS = 'DD_PROFILING_AGENTLESS'
       ENV_ENDPOINT_COLLECTION_ENABLED = 'DD_PROFILING_ENDPOINT_COLLECTION_ENABLED'
 
-      # TODO: Consider removing this once the Ruby-based pprof encoding is removed and replaced by libdatadog
-      module Pprof
-        LABEL_KEY_LOCAL_ROOT_SPAN_ID = 'local root span id'
-        LABEL_KEY_SPAN_ID = 'span id'
-        LABEL_KEY_THREAD_ID = 'thread id'
-        LABEL_KEY_TRACE_ENDPOINT = 'trace endpoint'
-        SAMPLE_VALUE_NO_VALUE = 0
-        VALUE_TYPE_CPU = 'cpu-time'
-        VALUE_TYPE_WALL = 'wall-time'
-        VALUE_UNIT_NANOSECONDS = 'nanoseconds'
-      end
-
       module Transport
         module HTTP
           FORM_FIELD_TAG_ENV = 'env'
@@ -35,6 +23,8 @@ module Datadog
           FORM_FIELD_TAG_RUNTIME_VERSION = 'runtime_version'
           FORM_FIELD_TAG_SERVICE = 'service'
           FORM_FIELD_TAG_VERSION = 'version'
+          TAG_GIT_REPOSITORY_URL = 'git.repository_url'
+          TAG_GIT_COMMIT_SHA = 'git.commit.sha'
 
           PPROF_DEFAULT_FILENAME = 'rubyprofile.pprof'
           CODE_PROVENANCE_FILENAME = 'code-provenance.json'

data/lib/datadog/profiling/flush.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
+require 'json'
+
 module Datadog
   module Profiling
-    # Represents a collection of events of a specific type being flushed.
-    EventGroup = Struct.new(:event_class, :events)
-
     # Entity class used to represent metadata for a given profile
     class Flush
       attr_reader \
@@ -14,7 +13,9 @@ module Datadog
         :pprof_data, # gzipped pprof bytes
         :code_provenance_file_name,
         :code_provenance_data, # gzipped json bytes
-        :tags_as_array
+        :tags_as_array,
+        :internal_metadata_json,
+        :info_json
 
       def initialize(
         start:,
@@ -23,7 +24,9 @@ module Datadog
         pprof_data:,
         code_provenance_file_name:,
         code_provenance_data:,
-        tags_as_array:
+        tags_as_array:,
+        internal_metadata:,
+        info_json:
       )
         @start = start
         @finish = finish
@@ -32,6 +35,8 @@ module Datadog
         @code_provenance_file_name = code_provenance_file_name
         @code_provenance_data = code_provenance_data
         @tags_as_array = tags_as_array
+        @internal_metadata_json = JSON.fast_generate(internal_metadata)
+        @info_json = info_json
       end
     end
   end

data/lib/datadog/profiling/http_transport.rb

@@ -1,3 +1,5 @@
+require_relative '../core/transport/ext'
+
 module Datadog
   module Profiling
     # Used to report profiling data to Datadog.
@@ -40,6 +42,9 @@ module Datadog
           code_provenance_data: flush.code_provenance_data,
 
           tags_as_array: flush.tags_as_array,
+          internal_metadata_json: flush.internal_metadata_json,
+
+          info_json: flush.info_json
         )
 
         if status == :ok
@@ -47,11 +52,14 @@ module Datadog
             Datadog.logger.debug('Successfully reported profiling data')
             true
           else
-            Datadog.logger.error("Failed to report profiling data: server returned unexpected HTTP #{result} status code")
+            Datadog.logger.error(
+              "Failed to report profiling data (#{config_without_api_key}): " \
+              "server returned unexpected HTTP #{result} status code"
+            )
             false
           end
         else
-          Datadog.logger.error("Failed to report profiling data: #{result}")
+          Datadog.logger.error("Failed to report profiling data (#{config_without_api_key}): #{result}")
           false
         end
       end
@@ -66,9 +74,9 @@ module Datadog
 
       def base_url_from(agent_settings)
         case agent_settings.adapter
-        when Datadog::Transport::Ext::HTTP::ADAPTER
+        when Datadog::Core::Transport::Ext::HTTP::ADAPTER
           "#{agent_settings.ssl ? 'https' : 'http'}://#{agent_settings.hostname}:#{agent_settings.port}/"
-        when Datadog::Transport::Ext::UnixSocket::ADAPTER
+        when Datadog::Core::Transport::Ext::UnixSocket::ADAPTER
           "unix://#{agent_settings.uds_path}"
         else
           raise ArgumentError, "Unexpected adapter: #{agent_settings.adapter}"
@@ -76,7 +84,8 @@ module Datadog
       end
 
       def validate_agent_settings(agent_settings)
-        supported_adapters = [Datadog::Transport::Ext::HTTP::ADAPTER, Datadog::Transport::Ext::UnixSocket::ADAPTER]
+        supported_adapters = [Datadog::Core::Transport::Ext::HTTP::ADAPTER,
+                              Datadog::Core::Transport::Ext::UnixSocket::ADAPTER]
         unless supported_adapters.include?(agent_settings.adapter)
           raise ArgumentError,
             "Unsupported transport configuration for profiling: Adapter #{agent_settings.adapter} " \
@@ -109,7 +118,9 @@ module Datadog
         pprof_data:,
         code_provenance_file_name:,
         code_provenance_data:,
-        tags_as_array:
+        tags_as_array:,
+        internal_metadata_json:,
+        info_json:
       )
         self.class._native_do_export(
           exporter_configuration,
@@ -123,8 +134,14 @@ module Datadog
           code_provenance_file_name,
           code_provenance_data,
           tags_as_array,
+          internal_metadata_json,
+          info_json,
         )
       end
+
+      def config_without_api_key
+        [@exporter_configuration[0..1]].to_h
+      end
     end
   end
 end