ddtrace 1.13.1 → 1.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77f5ce82c1888cc91b59b92651e262367f416298b668da0ed48ff06ec6f6fb49
-  data.tar.gz: 17857f0840b31f08f505661bf07764c79a507e670ef6d378e8bc2688b6be13eb
+  metadata.gz: ae7238650b45da9d8bf8f5834af2a29153081e798c2c8733c9bffb8768b6c430
+  data.tar.gz: b9bc8f36d37b91d18754892bd8dbc92cd515b9e38caf8561e23b665f14ee5e9e
 SHA512:
-  metadata.gz: cbfce752c4991fe0d71df92527eb3774483dbd4a669d6ff21e3483e2e4dd5caeb0da2a350fb09fd074639c9bdf032dfc166e2e1f60c8493eb98a45e14cf6d523
-  data.tar.gz: 83de702f81507366ac6afdc37b26df8e1b2df8e283a195e5e8ed5088871e0b3f7ab3035519c3cebd1f15e09935c54119e6093e3d3da010429468a6ecb4710841
+  metadata.gz: 4b4cdffa9d4ee39e6763be4a87dbdf3e351fd29915d4eaea45dc9c800543c65c8eb21375138422280cfed5715d8f23e95e58190752af6631c14453d39b29b263
+  data.tar.gz: fbc970e48e5e5038775368618e672ab7b2405cd6ea9b899136b34e9ae776f26a92436087fb0810ef7d66574c2f694cdea03197cf980b08dc35a9defcf4c3dc74

data/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 ## [Unreleased]
 
+## [1.14.0] - 2023-08-24
+
+### Added
+
+* Cucumber 8.0.0 support, test CI visibility with cucumber versions 6-8 ([#3061][])
+* Tracing: Add `ddsource` to #to_log_format ([#3025][])
+* Core: include peer service configurations in telemetry payload ([#3056][])
+* Tracing: Improve quantization ([#3041][])
+
+### Changed
+
+* Profiling: Disable profiler on Ruby 3.3 due to incompatibility ([#3054][])
+* Core: EnvironmentLogger adjustments ([#3020][], [#3057][])
+
+### Fixed
+
+* Appsec: Fix ASM setting for automated user events. ([#3070][])
+* Tracing: Fix ActiveRecord adapter name for Rails 7 ([#3051][])
+
 ## [1.13.1] - 2023-08-14
 
 ### Fixed
@@ -2515,7 +2534,8 @@ Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v0.3.1
 
 Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 
-[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v1.13.1...master
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v1.14.0...master
+[1.14.0]: https://github.com/DataDog/dd-trace-rb/compare/v1.13.1...1.14.0
 [1.13.1]: https://github.com/DataDog/dd-trace-rb/compare/v1.13.0...1.13.1
 [1.13.0]: https://github.com/DataDog/dd-trace-rb/compare/v1.12.1...v1.13.0
 [1.12.1]: https://github.com/DataDog/dd-trace-rb/compare/v1.12.0...v1.12.1
@@ -3652,12 +3672,21 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#3007]: https://github.com/DataDog/dd-trace-rb/issues/3007
 [#3011]: https://github.com/DataDog/dd-trace-rb/issues/3011
 [#3019]: https://github.com/DataDog/dd-trace-rb/issues/3019
+[#3020]: https://github.com/DataDog/dd-trace-rb/issues/3020
 [#3022]: https://github.com/DataDog/dd-trace-rb/issues/3022
+[#3025]: https://github.com/DataDog/dd-trace-rb/issues/3025
 [#3033]: https://github.com/DataDog/dd-trace-rb/issues/3033
 [#3037]: https://github.com/DataDog/dd-trace-rb/issues/3037
 [#3038]: https://github.com/DataDog/dd-trace-rb/issues/3038
 [#3039]: https://github.com/DataDog/dd-trace-rb/issues/3039
+[#3041]: https://github.com/DataDog/dd-trace-rb/issues/3041
 [#3045]: https://github.com/DataDog/dd-trace-rb/issues/3045
+[#3051]: https://github.com/DataDog/dd-trace-rb/issues/3051
+[#3054]: https://github.com/DataDog/dd-trace-rb/issues/3054
+[#3056]: https://github.com/DataDog/dd-trace-rb/issues/3056
+[#3057]: https://github.com/DataDog/dd-trace-rb/issues/3057
+[#3061]: https://github.com/DataDog/dd-trace-rb/issues/3061
+[#3070]: https://github.com/DataDog/dd-trace-rb/issues/3070
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot

data/ext/ddtrace_profiling_native_extension/native_extension_helpers.rb

@@ -87,6 +87,7 @@ module Datadog
             on_unknown_os? ||
             on_unsupported_cpu_arch? ||
             on_unsupported_ruby_version? ||
+            on_ruby_3_3? ||
             expected_to_use_mjit_but_mjit_is_disabled? ||
             libdatadog_not_available? ||
             libdatadog_not_usable?
@@ -269,6 +270,20 @@ module Datadog
           ruby_version_not_supported if RUBY_VERSION.start_with?('2.1.', '2.2.')
         end
 
+        private_class_method def self.on_ruby_3_3?
+          incompatible_with_3_3 = explain_issue(
+            'the profiler in the current version of ddtrace does not yet support',
+            'Ruby version 3.3.',
+            '(See https://github.com/datadog/dd-trace-rb/issues/3053 for details).',
+            suggested: [
+              'Try upgrading to the latest ddtrace, as this issue may have been',
+              'fixed by now.',
+            ] + CONTACT_SUPPORT,
+          )
+
+          incompatible_with_3_3 if RUBY_VERSION.start_with?('3.3.')
+        end
+
         # On some Rubies, we require the mjit header to be present. If Ruby was installed without MJIT support, we also skip
         # building the extension.
         private_class_method def self.expected_to_use_mjit_but_mjit_is_disabled?

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

@@ -15,6 +15,10 @@ module Datadog
           'safe',
           'extended'
         ].freeze
+        APPSEC_VALID_TRACK_USER_EVENTS_ENABLED_VALUES = [
+          '1',
+          'true'
+        ].concat(APPSEC_VALID_TRACK_USER_EVENTS_MODE).freeze
 
         def self.extended(base)
           base = base.singleton_class unless base.is_a?(Class)
@@ -100,7 +104,7 @@ module Datadog
                     if env_value == 'disabled'
                       false
                     else
-                      ['1', 'true'].include?(env_value.strip.downcase)
+                      APPSEC_VALID_TRACK_USER_EVENTS_ENABLED_VALUES.include?(env_value.strip.downcase)
                     end
                   end
                 end
@@ -112,6 +116,8 @@ module Datadog
                   o.setter do |v|
                     if APPSEC_VALID_TRACK_USER_EVENTS_MODE.include?(v)
                       v
+                    elsif v == 'disabled'
+                      'safe'
                     else
                       Datadog.logger.warn(
                         'The appsec.track_user_events.mode value provided is not supported.' \

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

@@ -110,6 +110,8 @@ module Datadog
           else
             @logger.debug('Profiling is disabled')
           end
+
+          Core::Diagnostics::EnvironmentLogger.collect_and_log!
         end
 
         # Shuts down all the components in use.

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'date'
 require 'json'
 require 'rbconfig'
@@ -5,280 +7,174 @@ require 'rbconfig'
 module Datadog
   module Core
     module Diagnostics
-      # A holistic collection of the environment in which ddtrace is running.
-      # This logger should allow for easy reporting by users to Datadog support.
-      #
-      module EnvironmentLogger
-        class << self
-          # Outputs environment information to {Datadog.logger}.
-          # Executes only once for the lifetime of the program.
-          def log!(transport_responses)
-            return if (defined?(@executed) && @executed) || !log?
-
-            @executed = true
-
-            data = EnvironmentCollector.new.collect!(transport_responses)
-            data.reject! { |_, v| v.nil? } # Remove empty values from hash output
-
-            log_environment!(data.to_json)
-            log_error!('Agent Error'.freeze, data[:agent_error]) if data[:agent_error]
-          rescue => e
-            Datadog.logger.warn("Failed to collect environment information: #{e} Location: #{Array(e.backtrace).first}")
-          end
-
-          private
-
-          def log_environment!(line)
-            Datadog.logger.info("DATADOG CONFIGURATION - #{line}")
-          end
-
-          def log_error!(type, error)
-            Datadog.logger.warn("DATADOG DIAGNOSTIC - #{type}: #{error}")
-          end
-
-          # Are we logging the environment data?
-          def log?
-            startup_logs_enabled = Datadog.configuration.diagnostics.startup_logs.enabled
-            if startup_logs_enabled.nil?
-              !repl? # Suppress logs if we running in a REPL
-            else
-              startup_logs_enabled
-            end
-          end
-
-          REPL_PROGRAM_NAMES = %w[irb pry].freeze
-
-          def repl?
-            REPL_PROGRAM_NAMES.include?($PROGRAM_NAME)
-          end
-        end
-      end
-
-      # Collects environment information for diagnostic logging
-      class EnvironmentCollector
-        # @return [String] current time in ISO8601 format
-        def date
-          DateTime.now.iso8601
-        end
-
-        # Best portable guess of OS information.
-        # @return [String] platform string
-        def os_name
-          RbConfig::CONFIG['host'.freeze]
+      # Base class for EnvironmentLoggers - should allow for easy reporting by users to Datadog support.
+      module EnvironmentLogging
+        def log_configuration!(prefix, data)
+          logger.info("DATADOG CONFIGURATION - #{prefix} - #{data}")
         end
 
-        # @return [String] ddtrace version
-        def version
-          DDTrace::VERSION::STRING
+        def log_error!(prefix, type, error)
+          logger.warn("DATADOG ERROR - #{prefix} - #{type}: #{error}")
         end
 
-        # @return [String] "ruby"
-        def lang
-          Core::Environment::Ext::LANG
-        end
+        protected
 
-        # Supported Ruby language version.
-        # Will be distinct from VM version for non-MRI environments.
-        # @return [String]
-        def lang_version
-          Core::Environment::Ext::LANG_VERSION
+        def logger
+          Datadog.logger
         end
 
-        # @return [String] configured application environment
-        def env
-          Datadog.configuration.env
-        end
+        # If logger should log and hasn't logged already, then output environment configuration and possible errors.
+        def log_once!
+          # Check if already been executed
+          return false if (defined?(@executed) && @executed) || !log?
 
-        # @return [Boolean, nil]
-        def enabled
-          Datadog.configuration.tracing.enabled
-        end
+          yield if block_given?
 
-        # @return [String] configured application service name
-        def service
-          Datadog.configuration.service
+          @executed = true
         end
 
-        # @return [String] configured application version
-        def dd_version
-          Datadog.configuration.version
-        end
-
-        # @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
+        # Are we logging the environment data?
+        def log?
+          startup_logs_enabled = Datadog.configuration.diagnostics.startup_logs.enabled
+          if startup_logs_enabled.nil?
+            !repl? && !rspec? # Suppress logs if we are running in a REPL or rspec
+          else
+            startup_logs_enabled
+          end
         end
 
-        # Error returned by Datadog agent during a tracer flush attempt
-        # @return [String] concatenated list of transport errors
-        def agent_error(transport_responses)
-          error_responses = transport_responses.reject(&:ok?)
+        REPL_PROGRAM_NAMES = %w[irb pry].freeze
 
-          return nil if error_responses.empty?
-
-          error_responses.map(&:inspect).join(','.freeze)
-        end
-
-        # @return [Boolean, nil] debug mode enabled in configuration
-        def debug
-          !!Datadog.configuration.diagnostics.debug
+        def repl?
+          REPL_PROGRAM_NAMES.include?($PROGRAM_NAME)
         end
 
-        # @return [Boolean, nil] analytics enabled in configuration
-        def analytics_enabled
-          !!Datadog.configuration.tracing.analytics.enabled
+        def rspec?
+          $PROGRAM_NAME.end_with?('rspec')
         end
+      end
 
-        # @return [Numeric, nil] tracer sample rate configured
-        def sample_rate
-          sampler = Datadog.configuration.tracing.sampler
-          return nil unless sampler
+      # Collects and logs Core diagnostic information
+      module EnvironmentLogger
+        extend EnvironmentLogging
 
-          sampler.sample_rate(nil) rescue nil
+        def self.collect_and_log!
+          log_once! do
+            data = EnvironmentCollector.collect_config!
+            log_configuration!('CORE', data.to_json)
+          end
+        rescue => e
+          logger.warn("Failed to collect core environment information: #{e} Location: #{Array(e.backtrace).first}")
         end
+      end
 
-        # DEV: We currently only support SimpleRule instances.
-        # DEV: These are the most commonly used rules.
-        # DEV: We should expand support for other rules in the future,
-        # DEV: although it is tricky to serialize arbitrary rules.
-        #
-        # @return [Hash, nil] sample rules configured
-        def sampling_rules
-          sampler = Datadog.configuration.tracing.sampler
-          return nil unless sampler.is_a?(Tracing::Sampling::PrioritySampler) &&
-            sampler.priority_sampler.is_a?(Tracing::Sampling::RuleSampler)
-
-          sampler.priority_sampler.rules.map do |rule|
-            next unless rule.is_a?(Tracing::Sampling::SimpleRule)
-
+      # Collects environment information for Core diagnostic logging
+      module EnvironmentCollector
+        class << self
+          def collect_config!
             {
-              name: rule.matcher.name,
-              service: rule.matcher.service,
-              sample_rate: rule.sampler.sample_rate(nil)
+              date: date,
+              os_name: os_name,
+              version: version,
+              lang: lang,
+              lang_version: lang_version,
+              env: env,
+              service: service,
+              dd_version: dd_version,
+              debug: debug,
+              tags: tags,
+              runtime_metrics_enabled: runtime_metrics_enabled,
+              vm: vm,
+              health_metrics_enabled: health_metrics_enabled
             }
-          end.compact
-        end
-
-        # @return [Hash, nil] concatenated list of global tracer tags configured
-        def tags
-          tags = Datadog.configuration.tags
-          return nil if tags.empty?
+          end
 
-          hash_serializer(tags)
-        end
+          # @return [String] current time in ISO8601 format
+          def date
+            DateTime.now.iso8601
+          end
 
-        # @return [Boolean, nil] runtime metrics enabled in configuration
-        def runtime_metrics_enabled
-          Datadog.configuration.runtime_metrics.enabled
-        end
+          # Best portable guess of OS information.
+          # @return [String] platform string
+          def os_name
+            RbConfig::CONFIG['host']
+          end
 
-        # Concatenated list of integrations activated, with their gem version.
-        # Example: "rails@6.0.3,rack@2.2.3"
-        #
-        # @return [String, nil]
-        def integrations_loaded
-          integrations = instrumented_integrations
-          return if integrations.empty?
+          # @return [String] ddtrace version
+          def version
+            DDTrace::VERSION::STRING
+          end
 
-          integrations.map { |name, integration| "#{name}@#{integration.class.version}" }.join(','.freeze)
-        end
+          # @return [String] "ruby"
+          def lang
+            Core::Environment::Ext::LANG
+          end
 
-        # Ruby VM name and version.
-        # Examples: "ruby-2.7.1", "jruby-9.2.11.1", "truffleruby-20.1.0"
-        # @return [String, nil]
-        def vm
-          # RUBY_ENGINE_VERSION returns the VM version, which
-          # will differ from RUBY_VERSION for non-mri VMs.
-          if defined?(RUBY_ENGINE_VERSION)
-            "#{RUBY_ENGINE}-#{RUBY_ENGINE_VERSION}"
-          else
-            # Ruby < 2.3 doesn't support RUBY_ENGINE_VERSION
-            "#{RUBY_ENGINE}-#{RUBY_VERSION}"
+          # Supported Ruby language version.
+          # Will be distinct from VM version for non-MRI environments.
+          # @return [String]
+          def lang_version
+            Core::Environment::Ext::LANG_VERSION
           end
-        end
 
-        # @return [Boolean, nil] partial flushing enabled in configuration
-        def partial_flushing_enabled
-          !!Datadog.configuration.tracing.partial_flush.enabled
-        end
+          # @return [String] configured application environment
+          def env
+            Datadog.configuration.env
+          end
 
-        # @return [Boolean, nil] priority sampling enabled in configuration
-        def priority_sampling_enabled
-          !!Datadog.configuration.tracing.priority_sampling
-        end
+          # @return [String] configured application service name
+          def service
+            Datadog.configuration.service
+          end
 
-        # @return [Boolean, nil] health metrics enabled in configuration
-        def health_metrics_enabled
-          !!Datadog.configuration.diagnostics.health_metrics.enabled
-        end
+          # @return [String] configured application version
+          def dd_version
+            Datadog.configuration.version
+          end
 
-        def profiling_enabled
-          !!Datadog.configuration.profiling.enabled
-        end
+          # @return [Boolean, nil] debug mode enabled in configuration
+          def debug
+            !!Datadog.configuration.diagnostics.debug
+          end
 
-        # TODO: Populate when automatic log correlation is implemented
-        # def logs_correlation_enabled
-        # end
+          # @return [Hash, nil] concatenated list of global tracer tags configured
+          def tags
+            tags = Datadog.configuration.tags
+            return nil if tags.empty?
 
-        # @return [Hash] environment information available at call time
-        def collect!(transport_responses)
-          {
-            date: date,
-            os_name: os_name,
-            version: version,
-            lang: lang,
-            lang_version: lang_version,
-            env: env,
-            enabled: enabled,
-            service: service,
-            dd_version: dd_version,
-            agent_url: agent_url,
-            agent_error: agent_error(transport_responses),
-            debug: debug,
-            analytics_enabled: analytics_enabled,
-            sample_rate: sample_rate,
-            sampling_rules: sampling_rules,
-            tags: tags,
-            runtime_metrics_enabled: runtime_metrics_enabled,
-            integrations_loaded: integrations_loaded,
-            vm: vm,
-            partial_flushing_enabled: partial_flushing_enabled,
-            priority_sampling_enabled: priority_sampling_enabled,
-            health_metrics_enabled: health_metrics_enabled,
-            profiling_enabled: profiling_enabled,
-            **instrumented_integrations_settings
-          }
-        end
+            hash_serializer(tags)
+          end
 
-        private
+          # @return [Boolean, nil] runtime metrics enabled in configuration
+          def runtime_metrics_enabled
+            Datadog.configuration.runtime_metrics.enabled
+          end
 
-        def instrumented_integrations
-          Datadog.configuration.tracing.instrumented_integrations
-        end
+          # Ruby VM name and version.
+          # Examples: "ruby-2.7.1", "jruby-9.2.11.1", "truffleruby-20.1.0"
+          # @return [String, nil]
+          def vm
+            # RUBY_ENGINE_VERSION returns the VM version, which
+            # will differ from RUBY_VERSION for non-mri VMs.
+            if defined?(RUBY_ENGINE_VERSION)
+              "#{RUBY_ENGINE}-#{RUBY_ENGINE_VERSION}"
+            else
+              # Ruby < 2.3 doesn't support RUBY_ENGINE_VERSION
+              "#{RUBY_ENGINE}-#{RUBY_VERSION}"
+            end
+          end
 
-        # Capture all active integration settings into "integrationName_settingName: value" entries.
-        def instrumented_integrations_settings
-          instrumented_integrations.flat_map do |name, integration|
-            integration.configuration.to_h.flat_map do |setting, value|
-              next [] if setting == :tracer # Skip internal Ruby objects
+          # @return [Boolean, nil] health metrics enabled in configuration
+          def health_metrics_enabled
+            !!Datadog.configuration.diagnostics.health_metrics.enabled
+          end
 
-              # Convert value to a string to avoid custom #to_json
-              # handlers possibly causing errors.
-              [[:"integration_#{name}_#{setting}", value.to_s]]
-            end
-          end.to_h
-        end
+          private
 
-        # Outputs "k1:v1,k2:v2,..."
-        def hash_serializer(h)
-          h.map { |k, v| "#{k}:#{v}" }.join(','.freeze)
+          # Outputs "k1:v1,k2:v2,..."
+          def hash_serializer(h)
+            h.map { |k, v| "#{k}:#{v}" }.join(',')
+          end
         end
       end
     end

data/lib/datadog/core/environment/execution.rb

@@ -10,7 +10,7 @@ module Datadog
           # This can be used to make decisions about when to enable
           # background systems like worker threads or telemetry.
           def development?
-            !!(repl? || test?)
+            !!(repl? || test? || rails_development?)
           end
 
           private
@@ -48,6 +48,16 @@ module Datadog
                 ::Minitest::Unit.class_variable_defined?(:@@installed_at_exit) &&
                 ::Minitest::Unit.class_variable_get(:@@installed_at_exit))
           end
+
+          # A Rails Spring Ruby process is a bit peculiar: the process is agnostic
+          # whether the application is running as a console or server.
+          # Luckily, the Spring gem *must not* be installed in a production environment so
+          # detecting its presence is enough to deduct if this is a development environment.
+          #
+          # @see https://github.com/rails/spring/blob/48b299348ace2188444489a0c216a6f3e9687281/README.md?plain=1#L204-L207
+          def rails_development?
+            defined?(::Spring)
+          end
         end
       end
     end

data/lib/datadog/core/telemetry/collector.rb

@@ -43,11 +43,19 @@ module Datadog
 
         # Forms a hash of standard key value pairs to be sent in the app-started event configuration
         def configurations
+          config = Datadog.configuration
           hash = {
-            DD_AGENT_HOST: Datadog.configuration.agent.host,
+            DD_AGENT_HOST: config.agent.host,
             DD_AGENT_TRANSPORT: agent_transport,
-            DD_TRACE_SAMPLE_RATE: format_configuration_value(Datadog.configuration.tracing.sampling.default_rate),
+            DD_TRACE_SAMPLE_RATE: format_configuration_value(config.tracing.sampling.default_rate),
+            DD_TRACE_REMOVE_INTEGRATION_SERVICE_NAMES_ENABLED: config.tracing.contrib.global_default_service_name.enabled
           }
+          peer_service_mapping_str = ''
+          unless config.tracing.contrib.peer_service_mapping.empty?
+            peer_service_mapping = config.tracing.contrib.peer_service_mapping
+            peer_service_mapping_str = peer_service_mapping.map { |key, value| "#{key}:#{value}" }.join(',')
+          end
+          hash[:DD_TRACE_PEER_SERVICE_MAPPING] = peer_service_mapping_str
           hash.compact!
           hash
         end

data/lib/datadog/profiling/component.rb

@@ -8,6 +8,9 @@ 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
+        require_relative '../profiling/diagnostics/environment_logger'
+        Profiling::Diagnostics::EnvironmentLogger.collect_and_log!
+
         return unless settings.profiling.enabled
 
         # Workaround for weird dependency direction: the Core::Configuration::Components class currently has a
@@ -65,9 +68,11 @@ module Datadog
         # NOTE: Please update the Initialization section of ProfilingDevelopment.md with any changes to this method
 
         no_signals_workaround_enabled = false
+        timeline_enabled = false
 
         if enable_new_profiler?(settings)
           no_signals_workaround_enabled = no_signals_workaround_enabled?(settings)
+          timeline_enabled = settings.profiling.advanced.experimental_timeline_enabled
 
           recorder = Datadog::Profiling::StackRecorder.new(
             cpu_time_enabled: RUBY_PLATFORM.include?('linux'), # Only supported on Linux currently
@@ -81,7 +86,7 @@ module Datadog
             gc_profiling_enabled: enable_gc_profiling?(settings),
             allocation_counting_enabled: settings.profiling.advanced.allocation_counting_enabled,
             no_signals_workaround_enabled: no_signals_workaround_enabled,
-            timeline_enabled: settings.profiling.advanced.experimental_timeline_enabled,
+            timeline_enabled: timeline_enabled,
           )
         else
           load_pprof_support
@@ -90,7 +95,12 @@ module Datadog
           collector = build_profiler_oldstack_collector(settings, recorder, optional_tracer)
         end
 
-        exporter = build_profiler_exporter(settings, recorder, no_signals_workaround_enabled: no_signals_workaround_enabled)
+        internal_metadata = {
+          no_signals_workaround_enabled: no_signals_workaround_enabled,
+          timeline_enabled: timeline_enabled,
+        }.freeze
+
+        exporter = build_profiler_exporter(settings, recorder, internal_metadata: internal_metadata)
         transport = build_profiler_transport(settings, agent_settings)
         scheduler = Profiling::Scheduler.new(exporter: exporter, transport: transport)
 
@@ -101,14 +111,14 @@ module Datadog
         Profiling::OldRecorder.new([Profiling::Events::StackSample], settings.profiling.advanced.max_events)
       end
 
-      private_class_method def self.build_profiler_exporter(settings, recorder, no_signals_workaround_enabled:)
+      private_class_method def self.build_profiler_exporter(settings, recorder, internal_metadata:)
         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,
-          no_signals_workaround_enabled: no_signals_workaround_enabled,
+          internal_metadata: internal_metadata,
         )
       end