datadog 2.7.1 → 2.18.0

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

@@ -14,7 +14,10 @@ module Datadog
       #
       # This class acts both as a collector (collecting data) as well as a recorder (records/serializes it)
       class CodeProvenance
-        def initialize(standard_library_path: RbConfig::CONFIG.fetch("rubylibdir"))
+        def initialize(
+          standard_library_path: RbConfig::CONFIG.fetch("rubylibdir"),
+          ruby_native_filename: Datadog::Profiling::Collectors::Stack._native_ruby_native_filename
+        )
           @libraries_by_name = {}
           @libraries_by_path = {}
           @seen_files = Set.new
@@ -26,6 +29,7 @@ module Datadog
               name: "stdlib",
               version: RUBY_VERSION,
               path: standard_library_path,
+              extra_path: ruby_native_filename,
             )
           )
         end
@@ -37,12 +41,8 @@ module Datadog
           self
         end
 
-        def generate
-          seen_libraries
-        end
-
         def generate_json
-          JSON.fast_generate(v1: seen_libraries.to_a)
+          JSON.generate(v1: seen_libraries.to_a)
         end
 
         private
@@ -79,7 +79,15 @@ module Datadog
           loaded_specs.each do |spec|
             next if libraries_by_name.key?(spec.name)
 
-            record_library(Library.new(kind: "library", name: spec.name, version: spec.version, path: spec.gem_dir))
+            record_library(
+              Library.new(
+                kind: "library",
+                name: spec.name,
+                version: spec.version,
+                path: spec.gem_dir,
+                extra_path: (spec.extension_dir if spec.extensions.any?),
+              )
+            )
             recorded_library = true
           end
 
@@ -110,11 +118,12 @@ module Datadog
         class Library
           attr_reader :kind, :name, :version
 
-          def initialize(kind:, name:, version:, path:)
+          def initialize(kind:, name:, version:, path:, extra_path: nil)
+            extra_path = nil if extra_path&.empty?
             @kind = kind.freeze
             @name = name.dup.freeze
             @version = version.to_s.dup.freeze
-            @paths = [path.dup.freeze].freeze
+            @paths = [path.dup.freeze, extra_path.dup.freeze].compact.freeze
             freeze
           end
 

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

@@ -33,6 +33,9 @@ module Datadog
             Datadog.logger.warn(
               "Profiling dynamic sampling rate disabled. This should only be used for testing, and will increase overhead!"
             )
+            Datadog::Core::Telemetry::Logger.error(
+              "Profiling dynamic sampling rate disabled. This should only be used for testing, and will increase overhead!"
+            )
           end
 
           self.class._native_initialize(
@@ -77,6 +80,7 @@ module Datadog
                 "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
               )
               on_failure_proc&.call
+              Datadog::Core::Telemetry::Logger.report(e, description: "CpuAndWallTimeWorker thread error", pii_safe: true)
             end
             @worker_thread.name = self.class.name # Repeated from above to make sure thread gets named asap
             @worker_thread.thread_variable_set(:fork_safe, true)

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

@@ -41,6 +41,7 @@ module Datadog
                 "IdleSamplingHelper thread error. " \
                 "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
               )
+              Datadog::Core::Telemetry::Logger.report(e, description: "IdleSamplingHelper thread error", pii_safe: true)
             end
             @worker_thread.name = self.class.name # Repeated from above to make sure thread gets named asap
             @worker_thread.thread_variable_set(:fork_safe, true)

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

@@ -31,6 +31,9 @@ module Datadog
         # Instead of trying to figure out real process start time by checking
         # /proc or some other complex/non-portable way, approximate start time
         # by time of requirement of this file.
+        #
+        # Note: this does not use Core::Utils::Time.now because this constant
+        # gets initialized before a user has a chance to configure the library.
         START_TIME = Time.now.utc.freeze
 
         def collect_platform_info

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

@@ -21,7 +21,8 @@ module Datadog
           endpoint_collection_enabled:,
           timeline_enabled:,
           waiting_for_gvl_threshold_ns:,
-          otel_context_enabled:
+          otel_context_enabled:,
+          native_filenames_enabled:
         )
           tracer_context_key = safely_extract_context_key_from(tracer)
           self.class._native_initialize(
@@ -33,6 +34,7 @@ module Datadog
             timeline_enabled: timeline_enabled,
             waiting_for_gvl_threshold_ns: waiting_for_gvl_threshold_ns,
             otel_context_enabled: otel_context_enabled,
+            native_filenames_enabled: validate_native_filenames(native_filenames_enabled),
           )
         end
 
@@ -44,6 +46,7 @@ module Datadog
           timeline_enabled: false,
           waiting_for_gvl_threshold_ns: 10_000_000,
           otel_context_enabled: false,
+          native_filenames_enabled: true,
           **options
         )
           new(
@@ -54,13 +57,14 @@ module Datadog
             timeline_enabled: timeline_enabled,
             waiting_for_gvl_threshold_ns: waiting_for_gvl_threshold_ns,
             otel_context_enabled: otel_context_enabled,
+            native_filenames_enabled: native_filenames_enabled,
             **options,
           )
         end
 
         def inspect
           # Compose Ruby's default inspect with our custom inspect for the native parts
-          result = super()
+          result = super
           result[-1] = "#{self.class._native_inspect(self)}>"
           result
         end
@@ -81,6 +85,17 @@ module Datadog
           context = provider.instance_variable_get(:@context)
           context&.instance_variable_get(:@key)
         end
+
+        def validate_native_filenames(native_filenames_enabled)
+          if native_filenames_enabled && !Datadog::Profiling::Collectors::Stack._native_filenames_available?
+            Datadog.logger.debug(
+              "Native filenames are enabled, but the required dladdr API was not available. Disabling native filenames."
+            )
+            false
+          else
+            native_filenames_enabled
+          end
+        end
       end
     end
   end

data/lib/datadog/profiling/component.rb

@@ -4,10 +4,13 @@ module Datadog
   module Profiling
     # Responsible for wiring up the Profiler for execution
     module Component
+      ALLOCATION_WITH_RACTORS_ONLY_ONCE = Datadog::Core::Utils::OnlyOnce.new
+      private_constant :ALLOCATION_WITH_RACTORS_ONLY_ONCE
+
       # 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
+      # * Profiling 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:) # rubocop:disable Metrics/MethodLength
+      def self.build_profiler_component(settings:, agent_settings:, optional_tracer:, logger:) # 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
@@ -36,14 +39,14 @@ module Datadog
 
         # NOTE: Please update the Initialization section of ProfilingDevelopment.md with any changes to this method
 
-        no_signals_workaround_enabled = no_signals_workaround_enabled?(settings)
+        no_signals_workaround_enabled = no_signals_workaround_enabled?(settings, logger)
         timeline_enabled = settings.profiling.advanced.timeline_enabled
-        allocation_profiling_enabled = enable_allocation_profiling?(settings)
+        allocation_profiling_enabled = enable_allocation_profiling?(settings, logger)
         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)
+        heap_profiling_enabled = enable_heap_profiling?(settings, allocation_profiling_enabled, heap_sample_every, logger)
+        heap_size_profiling_enabled = enable_heap_size_profiling?(settings, heap_profiling_enabled, logger)
 
-        overhead_target_percentage = valid_overhead_target(settings.profiling.advanced.overhead_target_percentage)
+        overhead_target_percentage = valid_overhead_target(settings.profiling.advanced.overhead_target_percentage, logger)
         upload_period_seconds = [60, settings.profiling.advanced.upload_period_seconds].max
 
         recorder = Datadog::Profiling::StackRecorder.new(
@@ -57,13 +60,13 @@ module Datadog
         )
         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),
+          gc_profiling_enabled: enable_gc_profiling?(settings, logger),
           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,
           allocation_counting_enabled: settings.profiling.advanced.allocation_counting_enabled,
-          gvl_profiling_enabled: enable_gvl_profiling?(settings),
+          gvl_profiling_enabled: enable_gvl_profiling?(settings, logger),
         )
 
         internal_metadata = {
@@ -93,6 +96,7 @@ module Datadog
           timeline_enabled: timeline_enabled,
           waiting_for_gvl_threshold_ns: settings.profiling.advanced.waiting_for_gvl_threshold_ns,
           otel_context_enabled: settings.profiling.advanced.preview_otel_context_enabled,
+          native_filenames_enabled: settings.profiling.advanced.native_filenames_enabled,
         )
       end
 
@@ -120,7 +124,7 @@ module Datadog
           )
       end
 
-      private_class_method def self.enable_gc_profiling?(settings)
+      private_class_method def self.enable_gc_profiling?(settings, logger)
         return false unless settings.profiling.advanced.gc_enabled
 
         # SEVERE - Only with Ractors
@@ -131,14 +135,14 @@ module Datadog
         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(
+          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 " \
+          logger.debug(
+            "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."
           )
@@ -155,7 +159,7 @@ module Datadog
         heap_sample_rate
       end
 
-      private_class_method def self.enable_allocation_profiling?(settings)
+      private_class_method def self.enable_allocation_profiling?(settings, logger)
         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.
@@ -165,7 +169,7 @@ module Datadog
         # 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(
+          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."
@@ -181,7 +185,7 @@ module Datadog
         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(
+          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."
@@ -190,74 +194,59 @@ module Datadog
         # 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."
-          )
+          ALLOCATION_WITH_RACTORS_ONLY_ONCE.run do
+            logger.info(
+              "Using Ractors may result in allocation profiling " \
+              "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
         end
 
-        Datadog.logger.debug("Enabled allocation profiling")
+        logger.debug("Enabled allocation profiling")
 
         true
       end
 
-      private_class_method def self.enable_heap_profiling?(settings, allocation_profiling_enabled, heap_sample_rate)
+      private_class_method def self.enable_heap_profiling?(settings, allocation_profiling_enabled, heap_sample_rate, logger)
         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(
-            "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)."
+          logger.warn(
+            "Current Ruby version (#{RUBY_VERSION}) cannot support heap profiling due to VM limitations. " \
+            "Please upgrade to Ruby >= 3.1 in order to use this feature. Heap profiling has been disabled."
           )
+          return false
         end
 
         unless allocation_profiling_enabled
-          raise ArgumentError,
-            "Heap profiling requires allocation profiling to be enabled"
+          logger.warn(
+            "Heap profiling was requested but allocation profiling is not enabled. " \
+            "Heap profiling has been disabled."
+          )
+          return false
         end
 
-        Datadog.logger.warn(
-          "Enabled experimental heap profiling: heap_sample_rate=#{heap_sample_rate}. This is experimental, not " \
-          "recommended, and will increase overhead!"
-        )
+        logger.debug("Enabled heap profiling: heap_sample_rate=#{heap_sample_rate}")
 
         true
       end
 
-      private_class_method def self.enable_heap_size_profiling?(settings, heap_profiling_enabled)
+      private_class_method def self.enable_heap_size_profiling?(settings, heap_profiling_enabled, logger)
         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
 
-      private_class_method def self.no_signals_workaround_enabled?(settings) # rubocop:disable Metrics/MethodLength
+      private_class_method def self.no_signals_workaround_enabled?(settings, logger) # rubocop:disable Metrics/MethodLength
         setting_value = settings.profiling.advanced.no_signals_workaround_enabled
-        legacy_ruby_that_should_use_workaround = RUBY_VERSION.start_with?("2.5.")
 
         unless [true, false, :auto].include?(setting_value)
-          # TODO: Replace with a warning instead.
-          Datadog.logger.error(
+          logger.warn(
             "Ignoring invalid value for profiling no_signals_workaround_enabled setting: #{setting_value.inspect}. " \
             "Valid options are `true`, `false` or (default) `:auto`."
           )
@@ -266,23 +255,23 @@ module Datadog
         end
 
         if setting_value == false
-          if legacy_ruby_that_should_use_workaround
-            Datadog.logger.warn(
-              'The profiling "no signals" workaround has been disabled via configuration on a legacy Ruby version ' \
-              "(< 2.6). This is not recommended " \
-              "in production environments, as due to limitations in Ruby APIs, we suspect it may lead to crashes " \
-              "in very rare situations. Please report any issues you run into to Datadog support or " \
+          if RUBY_VERSION.start_with?("2.5.")
+            logger.warn(
+              'The profiling "no signals" workaround has been disabled via configuration on Ruby 2.5. ' \
+              "This is not recommended " \
+              "in production environments, as due to limitations in Ruby APIs, we suspect it may lead to rare crashes " \
+              "Please report any issues you run into to Datadog support or " \
               "via <https://github.com/datadog/dd-trace-rb/issues/new>!"
             )
           else
-            Datadog.logger.warn('Profiling "no signals" workaround disabled via configuration')
+            logger.warn('Profiling "no signals" workaround disabled via configuration')
           end
 
           return false
         end
 
         if setting_value == true
-          Datadog.logger.warn(
+          logger.warn(
             'Profiling "no signals" workaround enabled via configuration. Profiling data will have lower quality.'
           )
 
@@ -292,10 +281,10 @@ module Datadog
         # Setting is in auto mode. Let's probe to see if we should enable it:
 
         # We don't warn users in this situation because "upgrade your Ruby" is not a great warning
-        return true if legacy_ruby_that_should_use_workaround
+        return true if RUBY_VERSION.start_with?("2.5.")
 
-        if Gem.loaded_specs["mysql2"] && incompatible_libmysqlclient_version?(settings)
-          Datadog.logger.warn(
+        if Gem.loaded_specs["mysql2"] && incompatible_libmysqlclient_version?(settings, logger)
+          logger.warn(
             'Enabling the profiling "no signals" workaround because an incompatible version of the mysql2 gem is ' \
             "installed. Profiling data will have lower quality. " \
             "To fix this, upgrade the libmysqlclient in your OS image to version 8.0.0 or above."
@@ -304,7 +293,7 @@ module Datadog
         end
 
         if Gem.loaded_specs["rugged"]
-          Datadog.logger.warn(
+          logger.warn(
             'Enabling the profiling "no signals" workaround because the rugged gem is installed. ' \
             "This is needed because some operations on this gem are currently incompatible with the normal working mode " \
             "of the profiler, as detailed in <https://github.com/datadog/dd-trace-rb/issues/2721>. " \
@@ -314,7 +303,7 @@ module Datadog
         end
 
         if (defined?(::PhusionPassenger) || Gem.loaded_specs["passenger"]) && incompatible_passenger_version?
-          Datadog.logger.warn(
+          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."
@@ -334,10 +323,10 @@ module Datadog
       #
       # The `mysql2` gem's `info` method can be used to determine which `libmysqlclient` version is in use, and thus to
       # detect if it's safe for the profiler to use signals or if we need to employ a fallback.
-      private_class_method def self.incompatible_libmysqlclient_version?(settings)
+      private_class_method def self.incompatible_libmysqlclient_version?(settings, logger)
         return true if settings.profiling.advanced.skip_mysql2_check
 
-        Datadog.logger.debug(
+        logger.debug(
           "Requiring `mysql2` to check if the `libmysqlclient` version it uses is compatible with profiling"
         )
 
@@ -366,14 +355,14 @@ module Datadog
             libmysqlclient_version >= Gem::Version.new("8.0.0") ||
             looks_like_mariadb?(info, libmysqlclient_version)
 
-          Datadog.logger.debug(
+          logger.debug(
             "The `mysql2` gem is using #{compatible ? "a compatible" : "an incompatible"} version of " \
             "the `libmysqlclient` library (#{libmysqlclient_version})"
           )
 
           !compatible
         rescue StandardError, LoadError => e
-          Datadog.logger.warn(
+          logger.warn(
             "Failed to probe `mysql2` gem information. " \
             "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
           )
@@ -395,12 +384,11 @@ module Datadog
         end
       end
 
-      private_class_method def self.valid_overhead_target(overhead_target_percentage)
+      private_class_method def self.valid_overhead_target(overhead_target_percentage, logger)
         if overhead_target_percentage > 0 && overhead_target_percentage <= 20
           overhead_target_percentage
         else
-          # TODO: Replace with a warning instead.
-          Datadog.logger.error(
+          logger.warn(
             "Ignoring invalid value for profiling overhead_target_percentage setting: " \
             "#{overhead_target_percentage.inspect}. Falling back to default value."
           )
@@ -444,18 +432,12 @@ module Datadog
         settings.profiling.advanced.dir_interruption_workaround_enabled
       end
 
-      private_class_method def self.enable_gvl_profiling?(settings)
-        if RUBY_VERSION < "3.2"
-          if settings.profiling.advanced.preview_gvl_enabled
-            Datadog.logger.warn("GVL profiling is currently not supported in Ruby < 3.2 and will not be enabled.")
-          end
-
-          return false
-        end
+      private_class_method def self.enable_gvl_profiling?(settings, logger)
+        return false if RUBY_VERSION < "3.2"
 
         # GVL profiling only makes sense in the context of timeline. We could emit a warning here, but not sure how
         # useful it is -- if a customer disables timeline, there's nowhere to look for GVL profiling anyway!
-        settings.profiling.advanced.timeline_enabled && settings.profiling.advanced.preview_gvl_enabled
+        settings.profiling.advanced.timeline_enabled && settings.profiling.advanced.gvl_enabled
       end
     end
   end

data/lib/datadog/profiling/encoded_profile.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Profiling
+    # This class exists to wrap a ddog_prof_EncodedProfile into a Ruby object
+    #
+    # This class is not empty; all of this class is implemented as native code.
+    class EncodedProfile # rubocop:disable Lint/EmptyClass
+    end
+  end
+end

data/lib/datadog/profiling/exporter.rb

@@ -49,7 +49,7 @@ module Datadog
         @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
+        @info_json = JSON.generate(info_collector.info).freeze
       end
 
       def flush
@@ -57,7 +57,7 @@ module Datadog
         serialization_result = pprof_recorder.serialize
         return if serialization_result.nil?
 
-        start, finish, compressed_pprof, profile_stats = serialization_result
+        start, finish, encoded_profile, profile_stats = serialization_result
         @last_flush_finish_at = finish
 
         if duration_below_threshold?(start, finish)
@@ -70,8 +70,7 @@ module Datadog
         Flush.new(
           start: start,
           finish: finish,
-          pprof_file_name: Datadog::Profiling::Ext::Transport::HTTP::PPROF_DEFAULT_FILENAME,
-          pprof_data: compressed_pprof.to_s,
+          encoded_profile: encoded_profile,
           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,

data/lib/datadog/profiling/ext.rb

@@ -11,22 +11,8 @@ module Datadog
 
       module Transport
         module HTTP
-          FORM_FIELD_TAG_ENV = "env"
-          FORM_FIELD_TAG_HOST = "host"
-          FORM_FIELD_TAG_LANGUAGE = "language"
-          FORM_FIELD_TAG_PID = "process_id"
           FORM_FIELD_TAG_PROFILER_VERSION = "profiler_version"
-          FORM_FIELD_TAG_RUNTIME = "runtime"
-          FORM_FIELD_TAG_RUNTIME_ENGINE = "runtime_engine"
-          FORM_FIELD_TAG_RUNTIME_ID = "runtime-id"
-          FORM_FIELD_TAG_RUNTIME_PLATFORM = "runtime_platform"
-          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"
         end
       end

data/lib/datadog/profiling/flush.rb

@@ -9,10 +9,9 @@ module Datadog
       attr_reader \
         :start,
         :finish,
-        :pprof_file_name,
-        :pprof_data, # gzipped pprof bytes
+        :encoded_profile,
         :code_provenance_file_name,
-        :code_provenance_data, # gzipped json bytes
+        :code_provenance_data,
         :tags_as_array,
         :internal_metadata_json,
         :info_json
@@ -20,8 +19,7 @@ module Datadog
       def initialize(
         start:,
         finish:,
-        pprof_file_name:,
-        pprof_data:,
+        encoded_profile:,
         code_provenance_file_name:,
         code_provenance_data:,
         tags_as_array:,
@@ -30,12 +28,11 @@ module Datadog
       )
         @start = start
         @finish = finish
-        @pprof_file_name = pprof_file_name
-        @pprof_data = pprof_data
+        @encoded_profile = encoded_profile
         @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)
+        @internal_metadata_json = JSON.generate(internal_metadata)
         @info_json = info_json
       end
     end