datadog 2.22.0 → 2.24.0

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

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require_relative '../../core/configuration/ext'
+
+module Datadog
+  module OpenTelemetry
+    module Configuration
+      module Settings
+        def self.extended(base)
+          base = base.singleton_class unless base.is_a?(Class)
+          add_settings!(base)
+        end
+
+        def self.normalize_temporality_preference(env_var_name)
+          proc do |value|
+            if value && value.to_s.downcase != 'delta' && value.to_s.downcase != 'cumulative'
+              Datadog.logger.warn("#{env_var_name}=#{value} is not supported. Using delta instead.")
+              'delta'
+            else
+              value
+            end
+          end
+        end
+
+        def self.normalize_protocol(env_var_name)
+          proc do |value|
+            if value && value.to_s.downcase != 'http/protobuf'
+              Datadog.logger.warn("#{env_var_name}=#{value} is not supported. Using http/protobuf instead.")
+            end
+            'http/protobuf'
+          end
+        end
+
+        def self.headers_parser(env_var_name)
+          lambda do |value|
+            return {} if value.nil? || value.empty?
+
+            headers = {}
+            header_items = value.split(',')
+            header_items.each do |key_value|
+              key, header_value = key_value.split('=', 2)
+              # If header is malformed, return an empty hash
+              if key.nil? || header_value.nil?
+                Datadog.logger.warn("#{env_var_name} has malformed header: #{key_value.inspect}")
+                return {}
+              end
+
+              key.strip!
+              header_value.strip!
+              if key.empty? || header_value.empty?
+                Datadog.logger.warn("#{env_var_name} has empty key or value in: #{key_value.inspect}")
+                return {}
+              end
+
+              headers[key] = header_value
+            end
+            headers
+          end
+        end
+
+        def self.add_settings!(base)
+          base.class_eval do
+            settings :opentelemetry do
+              settings :exporter do
+                option :protocol do |o|
+                  o.type :string
+                  o.setter(&Settings.normalize_protocol('OTEL_EXPORTER_OTLP_PROTOCOL'))
+                  o.env 'OTEL_EXPORTER_OTLP_PROTOCOL'
+                  o.default 'http/protobuf'
+                end
+
+                option :timeout_millis do |o|
+                  o.type :int
+                  o.env 'OTEL_EXPORTER_OTLP_TIMEOUT'
+                  o.default 10_000
+                end
+
+                option :headers do |o|
+                  o.type :hash
+                  o.env 'OTEL_EXPORTER_OTLP_HEADERS'
+                  o.default { {} }
+                  o.env_parser(&Settings.headers_parser('OTEL_EXPORTER_OTLP_HEADERS'))
+                end
+
+                option :endpoint do |o|
+                  o.type :string, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_ENDPOINT'
+                  o.default nil
+                end
+              end
+
+              settings :metrics do
+                # Metrics-specific options default to nil to detect unset state.
+                # If a metrics-specific env var (e.g., OTEL_EXPORTER_OTLP_METRICS_TIMEOUT) is not set,
+                # we fall back to the general OTLP env var (e.g., OTEL_EXPORTER_OTLP_TIMEOUT) per OpenTelemetry spec.
+                option :enabled do |o|
+                  o.type :bool
+                  o.env 'DD_METRICS_OTEL_ENABLED'
+                  o.default false
+                end
+
+                option :exporter do |o|
+                  o.type :string
+                  o.env 'OTEL_METRICS_EXPORTER'
+                  o.default 'otlp'
+                end
+
+                option :export_interval_millis do |o|
+                  o.type :int
+                  o.env 'OTEL_METRIC_EXPORT_INTERVAL'
+                  o.default 10_000
+                end
+
+                option :export_timeout_millis do |o|
+                  o.type :int
+                  o.env 'OTEL_METRIC_EXPORT_TIMEOUT'
+                  o.default 7_500
+                end
+
+                option :temporality_preference do |o|
+                  o.type :string
+                  o.env 'OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE'
+                  o.default 'delta'
+                  o.setter(&Settings.normalize_temporality_preference('OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE'))
+                end
+
+                option :endpoint do |o|
+                  o.type :string, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_METRICS_ENDPOINT'
+                  o.default nil
+                end
+
+                option :headers do |o|
+                  o.type :hash, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_METRICS_HEADERS'
+                  o.default nil
+                  o.env_parser(&Settings.headers_parser('OTEL_EXPORTER_OTLP_METRICS_HEADERS'))
+                end
+
+                option :timeout_millis do |o|
+                  o.type :int, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_METRICS_TIMEOUT'
+                  o.default 10000
+                end
+
+                option :protocol do |o|
+                  o.type :string, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_METRICS_PROTOCOL'
+                  o.default "http/protobuf"
+                  o.setter(&Settings.normalize_protocol('OTEL_EXPORTER_OTLP_METRICS_PROTOCOL'))
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/metrics.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require_relative '../core/configuration/ext'
+
+module Datadog
+  module OpenTelemetry
+    class Metrics
+      EXPORTER_NONE = 'none'
+
+      def self.initialize!(components)
+        new(components).configure_metrics_sdk
+        true
+      rescue => exc
+        components.logger.error("Failed to initialize OpenTelemetry metrics: #{exc.class}: #{exc}: #{exc.backtrace.join("\n")}")
+        false
+      end
+
+      def initialize(components)
+        @logger = components.logger
+        @settings = components.settings
+        @agent_host = components.agent_settings.hostname
+        @agent_ssl = components.agent_settings.ssl
+      end
+
+      def configure_metrics_sdk
+        provider = ::OpenTelemetry.meter_provider
+        provider.shutdown if provider.is_a?(::OpenTelemetry::SDK::Metrics::MeterProvider)
+
+        # The OpenTelemetry SDK defaults to cumulative temporality, but Datadog prefers delta temporality.
+        # Here is an example of how this config is applied: https://github.com/open-telemetry/opentelemetry-ruby/blob/1933d4c18e5f5e45c53fa9e902e58aa91e85cc38/metrics_sdk/lib/opentelemetry/sdk/metrics/aggregation/sum.rb#L14
+        if DATADOG_ENV['OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE'].nil?
+          ENV['OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE'] = 'delta' # rubocop:disable CustomCops/EnvUsageCop
+        end
+
+        resource = create_resource
+        provider = ::OpenTelemetry::SDK::Metrics::MeterProvider.new(resource: resource)
+        configure_metric_reader(provider)
+        ::OpenTelemetry.meter_provider = provider
+      end
+
+      private
+
+      def create_resource
+        resource_attributes = {}
+        resource_attributes['host.name'] = Datadog::Core::Environment::Socket.hostname if @settings.tracing.report_hostname
+
+        @settings.tags&.each do |key, value|
+          otel_key = case key
+          when 'service' then 'service.name'
+          when 'env' then 'deployment.environment'
+          when 'version' then 'service.version'
+          else key
+          end
+          resource_attributes[otel_key] = value
+        end
+
+        resource_attributes['service.name'] = @settings.service_without_fallback || resource_attributes['service.name'] || Datadog::Core::Environment::Ext::FALLBACK_SERVICE_NAME
+        resource_attributes['deployment.environment'] = @settings.env if @settings.env
+        resource_attributes['service.version'] = @settings.version if @settings.version
+
+        ::OpenTelemetry::SDK::Resources::Resource.create(resource_attributes)
+      end
+
+      def configure_metric_reader(provider)
+        exporter_name = @settings.opentelemetry.metrics.exporter
+        return if exporter_name == EXPORTER_NONE
+
+        configure_otlp_exporter(provider)
+      rescue => e
+        @logger.warn("Failed to configure OTLP metrics exporter:  #{e.class}: #{e}")
+      end
+
+      def default_metrics_endpoint
+        "#{@agent_ssl ? "https" : "http"}://#{@agent_host}:4318/v1/metrics"
+      end
+
+      def configure_otlp_exporter(provider)
+        require 'opentelemetry/exporter/otlp_metrics'
+        require_relative 'sdk/metrics_exporter'
+
+        metrics_config = @settings.opentelemetry.metrics
+        endpoint = get_metrics_config_with_fallback(
+          option_name: :endpoint,
+          computed_default: default_metrics_endpoint
+        )
+        timeout = get_metrics_config_with_fallback(option_name: :timeout_millis)
+        headers = get_metrics_config_with_fallback(option_name: :headers)
+        # OpenTelemetry SDK only supports http/protobuf protocol.
+        # TODO: Add support for http/json and grpc.
+        # protocol = get_metrics_config_with_fallback(option_name: :protocol)
+        exporter = Datadog::OpenTelemetry::SDK::MetricsExporter.new(
+          endpoint: endpoint,
+          timeout: timeout / 1000.0,
+          headers: headers
+        )
+
+        reader = ::OpenTelemetry::SDK::Metrics::Export::PeriodicMetricReader.new(
+          exporter: exporter,
+          export_interval_millis: metrics_config.export_interval_millis,
+          export_timeout_millis: metrics_config.export_timeout_millis
+        )
+        provider.add_metric_reader(reader)
+      rescue LoadError => e
+        @logger.warn("Could not load OTLP metrics exporter:  #{e.class}: #{e}")
+      end
+
+      # Returns metrics config value if explicitly set, otherwise falls back to exporter config or computed default value.
+      def get_metrics_config_with_fallback(option_name:, computed_default: nil)
+        if @settings.opentelemetry.metrics.using_default?(option_name)
+          @settings.opentelemetry.exporter.public_send(option_name) || computed_default
+        else
+          @settings.opentelemetry.metrics.public_send(option_name)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/sdk/configurator.rb

@@ -30,7 +30,31 @@ module Datadog
           [SpanProcessor.new]
         end
 
-        ::OpenTelemetry::SDK::Configurator.prepend(self)
+        def metrics_configuration_hook
+          components = Datadog.send(:components)
+          return super unless components.settings.opentelemetry.metrics.enabled
+
+          begin
+            require 'opentelemetry-metrics-sdk'
+          rescue LoadError => exc
+            components.logger.warn("Failed to load OpenTelemetry metrics gems: #{exc.class}: #{exc}")
+            return super
+          end
+
+          success = Datadog::OpenTelemetry::Metrics.initialize!(components)
+          super unless success
+        end
+
+        # Prepend to ConfiguratorPatch (not Configurator) so our hook runs first.
+        begin
+          require 'opentelemetry-metrics-sdk' if defined?(OpenTelemetry::SDK) && !defined?(OpenTelemetry::SDK::Metrics::ConfiguratorPatch)
+        rescue LoadError
+        end
+
+        if defined?(::OpenTelemetry::SDK::Metrics::ConfiguratorPatch)
+          ::OpenTelemetry::SDK::Metrics::ConfiguratorPatch.prepend(self) unless ::OpenTelemetry::SDK::Metrics::ConfiguratorPatch.ancestors.include?(self)
+        end
+        ::OpenTelemetry::SDK::Configurator.prepend(self) unless ::OpenTelemetry::SDK::Configurator.ancestors.include?(self)
       end
     end
   end

data/lib/datadog/opentelemetry/sdk/metrics_exporter.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'opentelemetry/exporter/otlp_metrics'
+
+module Datadog
+  module OpenTelemetry
+    module SDK
+      class MetricsExporter < ::OpenTelemetry::Exporter::OTLP::Metrics::MetricsExporter
+        METRIC_EXPORT_ATTEMPTS = 'otel.metrics_export_attempts'
+        METRIC_EXPORT_SUCCESSES = 'otel.metrics_export_successes'
+        METRIC_EXPORT_FAILURES = 'otel.metrics_export_failures'
+        TELEMETRY_NAMESPACE = 'tracers'
+        TELEMETRY_TAGS = {'protocol' => "http", 'encoding' => 'protobuf'}
+
+        def export(metrics, timeout: nil)
+          telemetry&.inc(TELEMETRY_NAMESPACE, METRIC_EXPORT_ATTEMPTS, 1, tags: TELEMETRY_TAGS)
+          result = super
+          metric_name = (result == 0) ? METRIC_EXPORT_SUCCESSES : METRIC_EXPORT_FAILURES
+          telemetry&.inc(TELEMETRY_NAMESPACE, metric_name, 1, tags: TELEMETRY_TAGS)
+          result
+        rescue => e
+          Datadog.logger.error("Failed to export OpenTelemetry Metrics:  #{e.class}: #{e}")
+          telemetry&.inc(TELEMETRY_NAMESPACE, METRIC_EXPORT_FAILURES, 1, tags: TELEMETRY_TAGS)
+          raise
+        end
+
+        private
+
+        def telemetry
+          Datadog.send(:components).telemetry
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry.rb

@@ -22,6 +22,8 @@ require_relative 'opentelemetry/api/baggage'
 require_relative 'opentelemetry/sdk/configurator' if defined?(OpenTelemetry::SDK)
 require_relative 'opentelemetry/sdk/trace/span' if defined?(OpenTelemetry::SDK)
 
+require_relative 'opentelemetry/metrics' if defined?(OpenTelemetry::SDK::Metrics)
+
 module Datadog
   # Datadog OpenTelemetry integration.
   module OpenTelemetry
@@ -47,6 +49,7 @@ end
 # Currently, this closely translates to Datadog's partial flushing.
 #
 # @see OpenTelemetry::SDK::Trace::SpanProcessor#on_finish
+
 Datadog.configure do |c|
   c.tracing.partial_flush.enabled = true
 end

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

@@ -22,6 +22,7 @@ module Datadog
           @libraries_by_path = {}
           @seen_files = Set.new
           @seen_libraries = Set.new
+          @executable_paths = [Gem.bindir, bundler_bin_path].uniq.compact.freeze
 
           record_library(
             Library.new(
@@ -29,7 +30,7 @@ module Datadog
               name: "stdlib",
               version: RUBY_VERSION,
               path: standard_library_path,
-              extra_path: ruby_native_filename,
+              extra_paths: [ruby_native_filename],
             )
           )
         end
@@ -51,7 +52,8 @@ module Datadog
           :libraries_by_name,
           :libraries_by_path,
           :seen_files,
-          :seen_libraries
+          :seen_libraries,
+          :executable_paths
 
         def record_library(library)
           libraries_by_name[library.name] = library
@@ -79,13 +81,20 @@ module Datadog
           loaded_specs.each do |spec|
             next if libraries_by_name.key?(spec.name)
 
+            extra_paths = [(spec.extension_dir if spec.extensions.any?)]
+            spec.executables&.each do |executable|
+              executable_paths.each do |path|
+                extra_paths << File.join(path, executable)
+              end
+            end
+
             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?),
+                extra_paths: extra_paths,
               )
             )
             recorded_library = true
@@ -107,6 +116,30 @@ module Datadog
           end
         end
 
+        # This is intended to mirror bundler's `Bundler.bin_path` with one key difference: the bundler version of the
+        # method **tries to create the path** if it doesn't exist, whereas our version doesn't.
+        #
+        # This "try to create the path" is annoying because creating the path can fail if e.g. the app doesn't have
+        # permissions to do that, see https://github.com/DataDog/dd-trace-rb/issues/5137.
+        # Thus we have our own version that a) Avoids creating the path, and b) Rescues exceptions to avoid any
+        # bundler complaints here impacting the application. (Bundler tends to go "something is wrong, raise!" which
+        # I think makes a lot of sense given how bundler is intended to be used, but for this our kind of "ask a few
+        # questions usage" it's not what we want.)
+        def bundler_bin_path
+          return unless defined?(Bundler)
+
+          path = Bundler.settings[:bin] || "bin"
+          root = Bundler.root
+          result = Pathname.new(path).expand_path(root).expand_path
+          result.to_s
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          Datadog.logger.debug(
+            "CodeProvenance#bundler_bin_path failed. " \
+            "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+          )
+          nil
+        end
+
         # Represents metadata we have for a ruby gem
         #
         # Important note: This class gets encoded to JSON with the built-in JSON gem. But, we've found that in some
@@ -118,17 +151,18 @@ module Datadog
         class Library
           attr_reader :kind, :name, :version
 
-          def initialize(kind:, name:, version:, path:, extra_path: nil)
-            extra_path = nil if extra_path&.empty?
+          def initialize(kind:, name:, version:, path:, extra_paths:)
+            extra_paths = Array(extra_paths).compact.reject(&:empty?).map { |p| p.dup.freeze }
             @kind = kind.freeze
             @name = name.dup.freeze
             @version = version.to_s.dup.freeze
-            @paths = [path.dup.freeze, extra_path.dup.freeze].compact.freeze
+            @paths = [path.dup.freeze, *extra_paths].freeze
             freeze
           end
 
           def to_json(arg = nil)
-            {kind: @kind, name: @name, version: @version, paths: @paths}.to_json(arg)
+            # Steep: https://github.com/ruby/rbs/pull/2691
+            {kind: @kind, name: @name, version: @version, paths: @paths}.to_json(arg) # steep:ignore ArgumentTypeMismatch
           end
 
           def path

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

@@ -82,7 +82,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)
+              Datadog::Core::Telemetry::Logger.report(e, description: "CpuAndWallTimeWorker thread error")
             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,7 +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)
+              Datadog::Core::Telemetry::Logger.report(e, description: "IdleSamplingHelper thread error")
             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

@@ -16,7 +16,8 @@ module Datadog
       class Info
         def initialize(settings)
           @profiler_info = nil
-          @info = {
+          # Steep: https://github.com/soutaro/steep/issues/363
+          @info = { # steep:ignore IncompatibleAssignment
             platform: collect_platform_info,
             runtime: collect_runtime_info,
             application: collect_application_info(settings),

data/lib/datadog/profiling/component.rb

@@ -4,9 +4,6 @@ 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:
       # * 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)
@@ -145,7 +142,7 @@ module Datadog
           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."
+            "application stability or performance. This issue is fixed on Ruby 4."
           )
         end
 
@@ -195,13 +192,11 @@ 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.")
-          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
+          logger.debug(
+            "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 issue is fixed on Ruby 4."
+          )
         end
 
         logger.debug("Enabled allocation profiling")
@@ -220,6 +215,12 @@ module Datadog
             "Please upgrade to Ruby >= 3.1 in order to use this feature. Heap profiling has been disabled."
           )
           return false
+        elsif RUBY_VERSION.start_with?("4.")
+          logger.warn(
+            "Datadog Ruby heap profiler is currently incompatible with Ruby 4. " \
+            "Heap profiling has been disabled."
+          )
+          return false
         end
 
         unless allocation_profiling_enabled

data/lib/datadog/profiling/http_transport.rb

@@ -13,7 +13,10 @@ module Datadog
       def initialize(agent_settings:, site:, api_key:, upload_timeout_seconds:)
         @upload_timeout_milliseconds = (upload_timeout_seconds * 1_000).to_i
 
-        @exporter_configuration =
+        # Steep: multiple issues here
+        # first https://github.com/soutaro/steep/issues/363
+        # then https://github.com/soutaro/steep/issues/1603 (remove the .freeze to see it)
+        @exporter_configuration = # steep:ignore IncompatibleAssignment
           if agentless?(site, api_key)
             [:agentless, site, api_key].freeze
           else

data/lib/datadog/profiling/profiler.rb

@@ -17,6 +17,10 @@ module Datadog
         @scheduler = scheduler
       end
 
+      def enabled?
+        scheduler.running?
+      end
+
       def start
         after_fork! do
           worker.reset_after_fork

data/lib/datadog/profiling/tag_builder.rb

@@ -1,17 +1,48 @@
 # frozen_string_literal: true
 
-require_relative "../core/tag_builder"
-require_relative "../core/utils"
+require_relative '../core/tag_builder'
+require_relative '../core/utils'
+
+require 'set'
 
 module Datadog
   module Profiling
     # Builds a hash of default plus user tags to be included in a profile
+    #
+    # @api private
     module TagBuilder
       include Datadog::Profiling::Ext::Transport::HTTP # Tag name constants
 
+      # When changing or adding profiling-related tags, make sure they are
+      # kept in sync with
+      # https://docs.google.com/spreadsheets/d/1LOGMf4c4Avbtn36uZ2SWvhIGKRPLM1BoWkUP4JYj7hA/
+      # (Datadog internal link).
+      #
+      # For consistency between the different profilers, every tag should be
+      # vetted before it gets reported with a profile, as otherwise it's too
+      # easy to end up with different tags in different languages.
+      ALLOWED_TAGS = Set.new(
+        [
+          'env',
+          'service',
+          'version',
+          'git.commit.sha',
+          'git.repository_url',
+          'host',
+          'language',
+          'runtime',
+          'runtime_engine',
+          'runtime_platform',
+          'runtime_version',
+          'runtime-id',
+          'process_id',
+          'profiler_version',
+          'profile_seq',
+        ]
+      ).freeze
+
       def self.call(
         settings:,
-        # Other metadata
         profile_seq:,
         profiler_version: Core::Environment::Identity.gem_datadog_version
       )
@@ -19,6 +50,8 @@ module Datadog
           FORM_FIELD_TAG_PROFILER_VERSION => profiler_version,
           'profile_seq' => profile_seq.to_s,
         )
+        user_tag_keys = settings.tags.keys
+        hash.keep_if { |tag| user_tag_keys.include?(tag) || ALLOWED_TAGS.include?(tag) }
         Core::Utils.encode_tags(hash)
       end
     end

data/lib/datadog/profiling.rb

@@ -62,8 +62,7 @@ module Datadog
 
     def self.enabled?
       profiler = Datadog.send(:components).profiler
-      # Use .send(...) to avoid exposing the attr_reader as an API to the outside
-      !!profiler&.send(:scheduler)&.running?
+      !!profiler&.enabled?
     end
 
     def self.wait_until_running(timeout_seconds: 5)

data/lib/datadog/single_step_instrument.rb

@@ -15,7 +15,7 @@ end
 
 begin
   require_relative 'auto_instrument'
-  Datadog::SingleStepInstrument::LOADED = true
+  Datadog::SingleStepInstrument.const_set(:LOADED, true)
 rescue StandardError, LoadError => e
   warn "Single step instrumentation failed: #{e.class}:#{e.message}\n\tSource:\n\t#{Array(e.backtrace).join("\n\t")}"
 end