datadog 2.2.0 → 2.4.0

data/lib/datadog/profiling/component.rb

@@ -8,7 +8,7 @@ module Datadog
       # * 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:) # rubocop:disable Metrics/MethodLength
-        return [nil, { profiling_enabled: false }] unless settings.profiling.enabled
+        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.
@@ -27,9 +27,9 @@ module Datadog
         # On the other hand, if datadog/core is loaded by a different product and no general `require 'datadog'` is
         # 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'
+        require_relative "../profiling"
 
-        return [nil, { profiling_enabled: false }] unless Profiling.supported?
+        return [nil, {profiling_enabled: false}] unless Profiling.supported?
 
         # Activate forking extensions
         Profiling::Tasks::Setup.new.run
@@ -47,7 +47,7 @@ module Datadog
         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
+          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,
@@ -61,6 +61,8 @@ module Datadog
           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),
         )
 
         internal_metadata = {
@@ -72,14 +74,13 @@ module Datadog
         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, interval: upload_period_seconds)
-        crashtracker = build_crashtracker(settings, transport)
-        profiler = Profiling::Profiler.new(worker: worker, scheduler: scheduler, optional_crashtracker: crashtracker)
+        profiler = Profiling::Profiler.new(worker: worker, scheduler: scheduler)
 
         if dir_interruption_workaround_enabled?(settings, no_signals_workaround_enabled)
           Datadog::Profiling::Ext::DirMonkeyPatches.apply!
         end
 
-        [profiler, { profiling_enabled: true }]
+        [profiler, {profiling_enabled: true}]
       end
 
       private_class_method def self.build_thread_context_collector(settings, recorder, optional_tracer, timeline_enabled)
@@ -89,6 +90,8 @@ module Datadog
           tracer: optional_tracer,
           endpoint_collection_enabled: settings.profiling.advanced.endpoint.collection.enabled,
           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,
         )
       end
 
@@ -116,28 +119,6 @@ module Datadog
           )
       end
 
-      private_class_method def self.build_crashtracker(settings, transport)
-        return unless settings.profiling.advanced.experimental_crash_tracking_enabled
-
-        # By default, the transport is an instance of HttpTransport, which validates the configuration and makes
-        # it available for us to use here.
-        # But we support overriding the transport with a user-specific one, which may e.g. write stuff to a file,
-        # and thus can't really provide a valid configuration to talk to a Datadog agent. Thus, in this situation,
-        # we can't use the crashtracker, even if enabled.
-        unless transport.respond_to?(:exporter_configuration)
-          Datadog.logger.warn(
-            'Cannot enable profiling crash tracking as a custom settings.profiling.exporter.transport is configured'
-          )
-          return
-        end
-
-        Datadog::Profiling::Crashtracker.new(
-          exporter_configuration: transport.exporter_configuration,
-          tags: Datadog::Profiling::TagBuilder.call(settings: settings),
-          upload_timeout_seconds: settings.profiling.upload.timeout_seconds,
-        )
-      end
-
       private_class_method def self.enable_gc_profiling?(settings)
         return false unless settings.profiling.advanced.gc_enabled
 
@@ -146,19 +127,19 @@ module Datadog
         # 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')
+        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.'
+            "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.')
+        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.'
+            "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
 
@@ -182,11 +163,11 @@ module Datadog
         # 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'
+        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.'
+            "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
@@ -196,26 +177,26 @@ module Datadog
         # 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')
+        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.'
+            "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.')
+        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.'
+            "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')
+        Datadog.logger.debug("Enabled allocation profiling")
 
         true
       end
@@ -225,33 +206,33 @@ module Datadog
 
         return false unless heap_profiling_enabled
 
-        if RUBY_VERSION.start_with?('2.') && RUBY_VERSION < '2.7'
+        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.'
+            "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'
+        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 '\
+            "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).'
+            "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'
+            "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!'
+          "recommended, and will increase overhead!"
         )
 
         true
@@ -263,7 +244,7 @@ module Datadog
         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!'
+          "Enabled experimental heap size profiling. This is experimental, not recommended, and will increase overhead!"
         )
 
         true
@@ -271,12 +252,13 @@ module Datadog
 
       private_class_method def self.no_signals_workaround_enabled?(settings) # 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.')
+        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(
             "Ignoring invalid value for profiling no_signals_workaround_enabled setting: #{setting_value.inspect}. " \
-            'Valid options are `true`, `false` or (default) `:auto`.'
+            "Valid options are `true`, `false` or (default) `:auto`."
           )
 
           setting_value = :auto
@@ -286,10 +268,10 @@ module Datadog
           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 ' \
-              'via <https://github.com/datadog/dd-trace-rb/issues/new>!'
+              "(< 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 " \
+              "via <https://github.com/datadog/dd-trace-rb/issues/new>!"
             )
           else
             Datadog.logger.warn('Profiling "no signals" workaround disabled via configuration')
@@ -311,30 +293,30 @@ module Datadog
         # 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
 
-        if Gem.loaded_specs['mysql2'] && incompatible_libmysqlclient_version?(settings)
+        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. ' \
-            'To fix this, upgrade the libmysqlclient in your OS image to version 8.0.0 or above.'
+            "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
         end
 
-        if Gem.loaded_specs['rugged']
+        if Gem.loaded_specs["rugged"]
           Datadog.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>. ' \
-            'Profiling data will have lower quality.'
+            "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>. " \
+            "Profiling data will have lower quality."
           )
           return true
         end
 
-        if (defined?(::PhusionPassenger) || Gem.loaded_specs['passenger']) && incompatible_passenger_version?
+        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.'
+            "installed. Profiling data will have lower quality." \
+            "To fix this, upgrade the passenger gem to version 6.0.19 or above."
           )
           return true
         end
@@ -355,11 +337,11 @@ module Datadog
         return true if settings.profiling.advanced.skip_mysql2_check
 
         Datadog.logger.debug(
-          'Requiring `mysql2` to check if the `libmysqlclient` version it uses is compatible with profiling'
+          "Requiring `mysql2` to check if the `libmysqlclient` version it uses is compatible with profiling"
         )
 
         begin
-          require 'mysql2'
+          require "mysql2"
 
           # 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
@@ -380,18 +362,18 @@ module Datadog
           libmysqlclient_version = Gem::Version.new(info[:version])
 
           compatible =
-            libmysqlclient_version >= Gem::Version.new('8.0.0') ||
+            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 " \
+            "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(
-            'Failed to probe `mysql2` gem information. ' \
+            "Failed to probe `mysql2` gem information. " \
             "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
           )
 
@@ -401,10 +383,10 @@ module Datadog
 
       # See https://github.com/datadog/dd-trace-rb/issues/2976 for details.
       private_class_method def self.incompatible_passenger_version?
-        first_compatible_version = Gem::Version.new('6.0.19')
+        first_compatible_version = Gem::Version.new("6.0.19")
 
-        if Gem.loaded_specs['passenger']
-          Gem.loaded_specs['passenger'].version < first_compatible_version
+        if Gem.loaded_specs["passenger"]
+          Gem.loaded_specs["passenger"].version < first_compatible_version
         elsif defined?(PhusionPassenger::VERSION_STRING)
           Gem::Version.new(PhusionPassenger::VERSION_STRING) < first_compatible_version
         else
@@ -416,8 +398,9 @@ module Datadog
         if overhead_target_percentage > 0 && overhead_target_percentage <= 20
           overhead_target_percentage
         else
+          # TODO: Replace with a warning instead.
           Datadog.logger.error(
-            'Ignoring invalid value for profiling overhead_target_percentage setting: ' \
+            "Ignoring invalid value for profiling overhead_target_percentage setting: " \
             "#{overhead_target_percentage.inspect}. Falling back to default value."
           )
 
@@ -450,18 +433,29 @@ module Datadog
         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'))
+          libmysqlclient_version < Gem::Version.new("5.0.0") &&
+          header_version >= Gem::Version.new("10.0.0"))
       end
 
       private_class_method def self.dir_interruption_workaround_enabled?(settings, no_signals_workaround_enabled)
-        return false if no_signals_workaround_enabled
-
-        # NOTE: In the future this method will evolve to check for Ruby versions affected and not apply the workaround
-        # when it's not needed but currently all known Ruby versions are affected.
+        return false if no_signals_workaround_enabled || RUBY_VERSION >= "3.4"
 
         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
+
+        # 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
+      end
     end
   end
 end

data/lib/datadog/profiling/exporter.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'ext'
-require_relative 'tag_builder'
+require_relative "ext"
+require_relative "tag_builder"
 
 module Datadog
   module Profiling
@@ -61,7 +61,7 @@ module Datadog
         @last_flush_finish_at = finish
 
         if duration_below_threshold?(start, finish)
-          Datadog.logger.debug('Skipped exporting profiling events as profile duration is below minimum')
+          Datadog.logger.debug("Skipped exporting profiling events as profile duration is below minimum")
           return
         end
 

data/lib/datadog/profiling/ext/dir_monkey_patches.rb

@@ -27,7 +27,7 @@ module Datadog
         end
       end
 
-      if RUBY_VERSION.start_with?('2.')
+      if RUBY_VERSION.start_with?("2.")
         # Monkey patches for Dir.singleton_class (Ruby 2 version). See DirMonkeyPatches above for more details.
         module DirClassMonkeyPatches
           def [](*args, &block)
@@ -260,7 +260,7 @@ module Datadog
         end
       end
 
-      if RUBY_VERSION.start_with?('2.')
+      if RUBY_VERSION.start_with?("2.")
         # Monkey patches for Dir (Ruby 2 version). See DirMonkeyPatches above for more details.
         module DirInstanceMonkeyPatches
           # See note on methods that yield above.
@@ -286,7 +286,7 @@ module Datadog
             end
           end
 
-          unless RUBY_VERSION.start_with?('2.5.') # This is Ruby 2.6+
+          unless RUBY_VERSION.start_with?("2.5.") # This is Ruby 2.6+
             # See note on methods that yield above.
             def each_child(*args, &block)
               if block

data/lib/datadog/profiling/ext.rb

@@ -3,31 +3,31 @@
 module Datadog
   module Profiling
     module Ext
-      ENV_ENABLED = 'DD_PROFILING_ENABLED'
-      ENV_UPLOAD_TIMEOUT = 'DD_PROFILING_UPLOAD_TIMEOUT'
-      ENV_MAX_FRAMES = 'DD_PROFILING_MAX_FRAMES'
-      ENV_AGENTLESS = 'DD_PROFILING_AGENTLESS'
-      ENV_ENDPOINT_COLLECTION_ENABLED = 'DD_PROFILING_ENDPOINT_COLLECTION_ENABLED'
+      ENV_ENABLED = "DD_PROFILING_ENABLED"
+      ENV_UPLOAD_TIMEOUT = "DD_PROFILING_UPLOAD_TIMEOUT"
+      ENV_MAX_FRAMES = "DD_PROFILING_MAX_FRAMES"
+      ENV_AGENTLESS = "DD_PROFILING_AGENTLESS"
+      ENV_ENDPOINT_COLLECTION_ENABLED = "DD_PROFILING_ENDPOINT_COLLECTION_ENABLED"
 
       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'
+          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'
+          PPROF_DEFAULT_FILENAME = "rubyprofile.pprof"
+          CODE_PROVENANCE_FILENAME = "code-provenance.json"
         end
       end
     end

data/lib/datadog/profiling/flush.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'json'
+require "json"
 
 module Datadog
   module Profiling

data/lib/datadog/profiling/http_transport.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../core/transport/ext'
+require_relative "../core/transport/ext"
+require_relative "../core/telemetry/logger"
 
 module Datadog
   module Profiling
@@ -53,17 +54,21 @@ module Datadog
 
         if status == :ok
           if (200..299).cover?(result)
-            Datadog.logger.debug('Successfully reported profiling data')
+            Datadog.logger.debug("Successfully reported profiling data")
             true
           else
             Datadog.logger.error(
               "Failed to report profiling data (#{config_without_api_key}): " \
               "server returned unexpected HTTP #{result} status code"
             )
+            Datadog::Core::Telemetry::Logger.error(
+              "Failed to report profiling data: unexpected HTTP #{result} status code"
+            )
             false
           end
         else
           Datadog.logger.error("Failed to report profiling data (#{config_without_api_key}): #{result}")
+          Datadog::Core::Telemetry::Logger.error("Failed to report profiling data")
           false
         end
       end
@@ -73,7 +78,7 @@ module Datadog
       def base_url_from(agent_settings)
         case agent_settings.adapter
         when Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER
-          "#{agent_settings.ssl ? 'https' : 'http'}://#{agent_settings.hostname}:#{agent_settings.port}/"
+          "#{agent_settings.ssl ? "https" : "http"}://#{agent_settings.hostname}:#{agent_settings.port}/"
         when Datadog::Core::Configuration::Ext::Agent::UnixSocket::ADAPTER
           "unix://#{agent_settings.uds_path}"
         else
@@ -82,12 +87,14 @@ module Datadog
       end
 
       def validate_agent_settings(agent_settings)
-        supported_adapters = [Datadog::Core::Configuration::Ext::Agent::UnixSocket::ADAPTER,
-                              Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER]
+        supported_adapters = [
+          Datadog::Core::Configuration::Ext::Agent::UnixSocket::ADAPTER,
+          Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER
+        ]
         unless supported_adapters.include?(agent_settings.adapter)
           raise ArgumentError,
             "Unsupported transport configuration for profiling: Adapter #{agent_settings.adapter} " \
-                        ' is not supported'
+                        " is not supported"
         end
       end
 
@@ -132,7 +139,7 @@ module Datadog
       end
 
       def config_without_api_key
-        [exporter_configuration[0..1]].to_h
+        "#{exporter_configuration[0]}: #{exporter_configuration[1]}"
       end
     end
   end

data/lib/datadog/profiling/load_native_extension.rb

@@ -15,26 +15,26 @@ begin
   require "datadog_profiling_loader.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
 rescue LoadError => e
   raise LoadError,
-    'Failed to load the profiling loader extension. To fix this, please remove and then reinstall datadog ' \
+    "Failed to load the profiling loader extension. To fix this, please remove and then reinstall datadog " \
     "(Details: #{e.message})"
 end
 
 extension_name = "datadog_profiling_native_extension.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
-file_name = "#{extension_name}.#{RbConfig::CONFIG['DLEXT']}"
+file_name = "#{extension_name}.#{RbConfig::CONFIG["DLEXT"]}"
 full_file_path = "#{__dir__}/../../#{file_name}"
 
 unless File.exist?(full_file_path)
-  extension_dir = Gem.loaded_specs['datadog'].extension_dir
+  extension_dir = Gem.loaded_specs["datadog"].extension_dir
   candidate_path = "#{extension_dir}/#{file_name}"
   if File.exist?(candidate_path)
     full_file_path = candidate_path
-  else # rubocop:disable Style/EmptyElse
+  else
     # We found none of the files. This is unexpected. Let's go ahead anyway, the error is going to be reported further
     # down anyway.
   end
 end
 
-init_function_name = "Init_#{extension_name.split('.').first}"
+init_function_name = "Init_#{extension_name.split(".").first}"
 
 status, result = Datadog::Profiling::Loader._native_load(full_file_path, init_function_name)
 

data/lib/datadog/profiling/preload.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../../datadog'
+require_relative "../../datadog"
 
 Datadog::Profiling.start_if_enabled