datadog 2.17.0 → 2.37.0

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

@@ -4,9 +4,10 @@ module Datadog
   module Profiling
     # Monkey patches needed for profiler features and compatibility
     module Ext
-      # All Ruby versions as of this writing have bugs in the dir class implementation, causing issues such as
+      # Ruby versions before 3.4 have bugs in the `Dir` class implementation, causing issues such as
       # https://github.com/DataDog/dd-trace-rb/issues/3450 .
-      # See also https://bugs.ruby-lang.org/issues/20586 for more details.
+      # This was fixed upstream in https://bugs.ruby-lang.org/issues/20586 but we use this monkey patch to work around
+      # the issue on legacy versions (it gets applied by `Datadog::Profiling::Component`).
       #
       # This monkey patch for the Ruby `Dir` class works around these bugs for affected Ruby versions by temporarily
       # blocking the profiler from interrupting system calls.
@@ -27,9 +28,13 @@ module Datadog
         end
       end
 
-      if RUBY_VERSION.start_with?("2.")
+      if RubyVersion.is?("< 3")
         # Monkey patches for Dir.singleton_class (Ruby 2 version). See DirMonkeyPatches above for more details.
         module DirClassMonkeyPatches
+          # Steep: Workaround that defines args and block only for Ruby 2.x.
+          # @type var args: ::Array[any]
+          # @type var block: ^(?) -> any | nil
+
           def [](*args, &block)
             Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
             super
@@ -148,6 +153,11 @@ module Datadog
       else
         # Monkey patches for Dir.singleton_class (Ruby 3 version). See DirMonkeyPatches above for more details.
         module DirClassMonkeyPatches
+          # Steep: Workaround that defines args, kwargs and block only for Ruby 3.x.
+          # @type var args: ::Array[any]
+          # @type var kwargs: ::Hash[::Symbol, any]
+          # @type var block: ^(?) -> any | nil
+
           def [](*args, **kwargs, &block)
             Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
             super
@@ -260,9 +270,13 @@ module Datadog
         end
       end
 
-      if RUBY_VERSION.start_with?("2.")
+      if RubyVersion.is?("< 3")
         # Monkey patches for Dir (Ruby 2 version). See DirMonkeyPatches above for more details.
         module DirInstanceMonkeyPatches
+          # Steep: Workaround that defines args and block only for Ruby 2.x.
+          # @type var args: ::Array[any]
+          # @type var block: ^(?) -> any | nil
+
           # See note on methods that yield above.
           def each(*args, &block)
             if block
@@ -286,7 +300,7 @@ module Datadog
             end
           end
 
-          unless RUBY_VERSION.start_with?("2.5.") # This is Ruby 2.6+
+          if RubyVersion.is?(">= 2.6.0") # This method is Ruby 2.6+
             # See note on methods that yield above.
             def each_child(*args, &block)
               if block
@@ -336,6 +350,11 @@ module Datadog
       else
         # Monkey patches for Dir (Ruby 3 version). See DirMonkeyPatches above for more details.
         module DirInstanceMonkeyPatches
+          # Steep: Workaround that defines args, kwargs and block only for Ruby 3.x.
+          # @type var args: ::Array[any]
+          # @type var kwargs: ::Hash[::Symbol, any]
+          # @type var block: ^(?) -> any | nil
+
           # See note on methods that yield above.
           def each(*args, **kwargs, &block)
             if block

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Profiling
+    module Ext
+      # The profiler gathers data by sending `SIGPROF` unix signals to Ruby application threads.
+      #
+      # When using `Kernel#exec` on Linux, it can happen that a signal sent before calling `exec` arrives after
+      # the new process is running, causing it to fail with the `Profiling timer expired` error message.
+      # To avoid this, the profiler installs a monkey patch on `Kernel#exec` to stop profiling before actually
+      # calling `exec`.
+      # This monkey patch is available for Ruby 2.7+; let us know if you need it on earlier Rubies.
+      # For more details see https://github.com/DataDog/dd-trace-rb/issues/5101 .
+      module ExecMonkeyPatch
+        def self.apply!
+          ::Object.prepend(ObjectMonkeyPatch)
+
+          true
+        end
+
+        module ObjectMonkeyPatch
+          private
+
+          def exec(...)
+            Datadog.send(:components, allow_initialization: false)&.profiler&.shutdown!(report_last_profile: false)
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/profiling/ext.rb

@@ -6,26 +6,13 @@ module Datadog
       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"
 
+      # WARNING: This should not be used, only for internal testing
+      ENV_AGENTLESS = "DD_PROFILING_AGENTLESS" # rubocop:disable CustomCops/EnvStringValidationCop
       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_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"
-
-          CODE_PROVENANCE_FILENAME = "code-provenance.json"
         end
       end
     end

data/lib/datadog/profiling/flush.rb

@@ -6,32 +6,44 @@ module Datadog
   module Profiling
     # Entity class used to represent metadata for a given profile
     class Flush
-      attr_reader \
-        :start,
-        :finish,
-        :encoded_profile,
-        :code_provenance_file_name,
-        :code_provenance_data,
-        :tags_as_array,
-        :internal_metadata_json,
-        :info_json
+      attr_reader :start #: ::Time
+      attr_reader :finish #: ::Time
+      attr_reader :encoded_profile #: Datadog::Profiling::EncodedProfile
+      attr_reader :code_provenance_data #: ::String?
+      attr_reader :metrics #: ::String
+      attr_reader :tags_as_array #: Array[[::String, ::String]]
+      attr_reader :process_tags #: ::String
+      attr_reader :internal_metadata_json #: ::String
+      attr_reader :info_json #: ::String
 
+      # @rbs start: ::Time
+      # @rbs finish: ::Time
+      # @rbs encoded_profile: Datadog::Profiling::EncodedProfile
+      # @rbs code_provenance_data: ::String?
+      # @rbs metrics: Array[[::String, ::Numeric]]
+      # @rbs tags_as_array: Array[[::String, ::String]]
+      # @rbs process_tags: ::String
+      # @rbs internal_metadata: ::Hash[::Symbol, ::String | bool | ::Numeric]
+      # @rbs info_json: ::String
+      # @rbs return: void
       def initialize(
         start:,
         finish:,
         encoded_profile:,
-        code_provenance_file_name:,
         code_provenance_data:,
+        metrics:,
         tags_as_array:,
+        process_tags:,
         internal_metadata:,
         info_json:
       )
         @start = start
         @finish = finish
         @encoded_profile = encoded_profile
-        @code_provenance_file_name = code_provenance_file_name
         @code_provenance_data = code_provenance_data
+        @metrics = JSON.generate(metrics)
         @tags_as_array = tags_as_array
+        @process_tags = process_tags
         @internal_metadata_json = JSON.generate(internal_metadata)
         @info_json = info_json
       end

data/lib/datadog/profiling/http_transport.rb

@@ -8,16 +8,27 @@ module Datadog
     # Used to report profiling data to Datadog.
     # Methods prefixed with _native_ are implemented in `http_transport.c`
     class HttpTransport
-      attr_reader :exporter_configuration
+      # @rbs @exporter_configuration: exporter_configuration_array
 
-      def initialize(agent_settings:, site:, api_key:, upload_timeout_seconds:)
-        @upload_timeout_milliseconds = (upload_timeout_seconds * 1_000).to_i
+      attr_reader :exporter_configuration #: exporter_configuration_array
 
-        @exporter_configuration =
+      # @rbs agent_settings: Datadog::Core::Configuration::AgentSettings
+      # @rbs site: ::String?
+      # @rbs api_key: ::String?
+      # @rbs upload_timeout_seconds: ::Integer
+      # @rbs use_system_dns: bool
+      # @rbs return: void
+      def initialize(agent_settings:, site:, api_key:, upload_timeout_seconds:, use_system_dns:)
+        timeout_milliseconds = (upload_timeout_seconds * 1_000).to_i
+
+        # 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
+            [:agentless, timeout_milliseconds, use_system_dns, site, api_key].freeze
           else
-            [:agent, agent_settings.url].freeze
+            [:agent, timeout_milliseconds, use_system_dns, agent_settings.url].freeze
           end
 
         status, result = self.class._native_validate_exporter(exporter_configuration)
@@ -25,10 +36,10 @@ module Datadog
         raise(ArgumentError, "Failed to initialize transport: #{result}") if status == :error
       end
 
+      #: (Datadog::Profiling::Flush) -> bool
       def export(flush)
         status, result = self.class._native_do_export(
           exporter_configuration,
-          @upload_timeout_milliseconds,
           flush
         )
 
@@ -37,7 +48,7 @@ module Datadog
             Datadog.logger.debug("Successfully reported profiling data")
             true
           else
-            Datadog.logger.error(
+            Datadog.logger.warn(
               "Failed to report profiling data (#{config_without_api_key}): " \
               "server returned unexpected HTTP #{result} status code"
             )
@@ -47,7 +58,7 @@ module Datadog
             false
           end
         else
-          Datadog.logger.error("Failed to report profiling data (#{config_without_api_key}): #{result}")
+          Datadog.logger.warn("Failed to report profiling data (#{config_without_api_key}): #{result}")
           Datadog::Core::Telemetry::Logger.error("Failed to report profiling data")
           false
         end
@@ -55,12 +66,14 @@ module Datadog
 
       private
 
+      #: (::String?, ::String?) -> bool?
       def agentless?(site, api_key)
-        site && api_key && Core::Environment::VariableHelpers.env_to_bool(Profiling::Ext::ENV_AGENTLESS, false)
+        site && api_key && %w[1 true].include?(ENV[Profiling::Ext::ENV_AGENTLESS] || '') # rubocop:disable CustomCops/EnvUsageCop
       end
 
+      #: () -> ::String
       def config_without_api_key
-        "#{exporter_configuration[0]}: #{exporter_configuration[1]}"
+        "#{exporter_configuration[0]}: #{exporter_configuration[3]}"
       end
     end
   end

data/lib/datadog/profiling/load_native_extension.rb

@@ -4,6 +4,6 @@ begin
   require "datadog_profiling_native_extension.#{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 " \
-    "(Details: #{e.message})"
+    "Failed to load the profiling native extension. To fix this, please remove and then reinstall datadog " \
+    "(Details: #{e.class}: #{e.message})"
 end

data/lib/datadog/profiling/profiler.rb

@@ -8,54 +8,73 @@ module Datadog
 
       private
 
-      attr_reader :worker, :scheduler
+      attr_reader :worker #: Datadog::Profiling::Collectors::CpuAndWallTimeWorker
+      attr_reader :scheduler #: Datadog::Profiling::Scheduler
 
       public
 
+      # @rbs worker: Datadog::Profiling::Collectors::CpuAndWallTimeWorker
+      # @rbs scheduler: Datadog::Profiling::Scheduler
+      # @rbs return: void
       def initialize(worker:, scheduler:)
         @worker = worker
         @scheduler = scheduler
       end
 
+      #: () -> void
       def start
         after_fork! do
           worker.reset_after_fork
           scheduler.reset_after_fork
         end
 
-        worker.start(on_failure_proc: proc { component_failed(:worker) })
+        worker.start(
+          on_failure_proc: ->(log_failure: true) do
+            # @type var log_failure: bool
+            component_failed(:worker, log_failure: log_failure)
+          end
+        )
         scheduler.start(on_failure_proc: proc { component_failed(:scheduler) })
       end
 
-      def shutdown!
+      # @rbs report_last_profile: bool
+      # @rbs return: void
+      def shutdown!(report_last_profile: true)
         Datadog.logger.debug("Shutting down profiler")
 
         stop_worker
+        scheduler.disable_reporting unless report_last_profile
         stop_scheduler
       end
 
       private
 
+      #: () -> void
       def stop_worker
         worker.stop
       end
 
+      #: () -> void
       def stop_scheduler
         scheduler.enabled = false
         scheduler.stop(true)
       end
 
-      def component_failed(failed_component)
-        Datadog.logger.warn(
-          "Detected issue with profiler (#{failed_component} component), stopping profiling. " \
-          "See previous log messages for details."
-        )
-
-        # We explicitly not stop the crash tracker in this situation, under the assumption that, if a component failed,
-        # we're operating in a degraded state and crash tracking may still be helpful.
+      # @rbs failed_component: :worker | :scheduler | ::Symbol
+      # @rbs log_failure: bool
+      # @rbs return: void
+      def component_failed(failed_component, log_failure: true)
+        if log_failure
+          Datadog.logger.warn(
+            "Detected issue with profiler (#{failed_component} component), stopping profiling. " \
+            "See previous log messages for details."
+          )
+          Datadog::Core::Telemetry::Logger
+            .error("Detected issue with profiler (#{failed_component} component), stopping profiling")
+        end
 
         if failed_component == :worker
-          scheduler.mark_profiler_failed
+          scheduler.disable_reporting
           stop_scheduler
         elsif failed_component == :scheduler
           stop_worker

data/lib/datadog/profiling/scheduler.rb

@@ -24,7 +24,7 @@ module Datadog
       attr_reader \
         :exporter,
         :transport,
-        :profiler_failed
+        :reporting_disabled
 
       public
 
@@ -36,7 +36,7 @@ module Datadog
       )
         @exporter = exporter
         @transport = transport
-        @profiler_failed = false
+        @reporting_disabled = false
         @stop_requested = false
 
         # Workers::Async::Thread settings
@@ -65,9 +65,10 @@ module Datadog
       rescue Exception => e # rubocop:disable Lint/RescueException
         Datadog.logger.warn(
           "Profiling::Scheduler thread error. " \
-          "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+          "Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
         )
         on_failure_proc&.call
+        Datadog::Core::Telemetry::Logger.report(e, description: "Profiling::Scheduler thread error")
         raise
       ensure
         Datadog.logger.debug("#flush was interrupted or failed before it could complete") if interrupted
@@ -82,14 +83,15 @@ module Datadog
         true
       end
 
-      # This is called by the Profiler class whenever an issue happened in the profiler. This makes sure that even
-      # if there is data to be flushed, we don't try to flush it.
-      def mark_profiler_failed
-        @profiler_failed = true
+      # Called by the Profiler when it wants to prevent any further reporting,
+      # even if there is data to be flushed.
+      # Used when the profiler failed or we're otherwise in a hurry to shut down.
+      def disable_reporting
+        @reporting_disabled = true
       end
 
       def work_pending?
-        !profiler_failed && exporter.can_flush? && (run_loop? || !stop_requested?)
+        !reporting_disabled && exporter.can_flush? && (run_loop? || !stop_requested?)
       end
 
       def reset_after_fork
@@ -133,8 +135,8 @@ module Datadog
         begin
           transport.export(flush)
         rescue => e
-          Datadog.logger.error(
-            "Unable to report profile. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+          Datadog.logger.warn(
+            "Unable to report profile. Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
           )
           Datadog::Core::Telemetry::Logger.report(e, description: "Unable to report profile")
         end

data/lib/datadog/profiling/sequence_tracker.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../core/utils/forking'
+
+module Datadog
+  module Profiling
+    # Used to generate the `profile_seq` tag, which effectively counts how many profiles we've attempted to report
+    # from a given runtime-id.
+    #
+    # Note that the above implies a few things:
+    # 1. The sequence number only gets incremented when we decide to report a profile and create a `Flush` for it
+    # 2. The `SequenceTracker` must live across profiler reconfigurations and resets, since no matter how many
+    #    profiler instances get created due to reconfiguration, the runtime-id is still the same, so the sequence number
+    #    should be kept and not restarted from 0
+    # 3. The `SequenceTracker` must be reset after a fork, since the runtime-id will change, and we want to start
+    #    counting from 0 again
+    #
+    # This is why this module is implemented as a singleton that we reuse, not as an instance that we recreate.
+    #
+    # Note that this module is not thread-safe, so it's up to the callers to make sure
+    # it's only used by a single thread at a time (which is what the `Profiling::Exporter`)
+    # is doing.
+    module SequenceTracker
+      class << self
+        include Core::Utils::Forking
+
+        def get_next
+          reset! unless defined?(@sequence_number)
+          after_fork! { reset! }
+
+          next_seq = @sequence_number
+          @sequence_number += 1
+          next_seq
+        end
+
+        private
+
+        def reset!
+          @sequence_number = 0
+        end
+      end
+    end
+  end
+end

data/lib/datadog/profiling/stack_recorder.rb

@@ -9,12 +9,10 @@ module Datadog
     # Methods prefixed with _native_ are implemented in `stack_recorder.c`
     class StackRecorder
       def initialize(
-        cpu_time_enabled:,
         alloc_samples_enabled:,
         heap_samples_enabled:,
         heap_size_enabled:,
         heap_sample_every:,
-        timeline_enabled:,
         heap_clean_after_gc_enabled:
       )
         # This mutex works in addition to the fancy C-level mutexes we have in the native side (see the docs there).
@@ -23,44 +21,38 @@ module Datadog
         # This isn't something we expect to happen normally, but because it would break the assumptions of the
         # C-level mutexes (that there is a single serializer thread), we add it here as an extra safeguard against it
         # accidentally happening.
-        @no_concurrent_synchronize_mutex = Mutex.new
+        @no_concurrent_serialize_mutex = Mutex.new
 
         self.class._native_initialize(
           self_instance: self,
-          cpu_time_enabled: cpu_time_enabled,
           alloc_samples_enabled: alloc_samples_enabled,
           heap_samples_enabled: heap_samples_enabled,
           heap_size_enabled: heap_size_enabled,
           heap_sample_every: heap_sample_every,
-          timeline_enabled: timeline_enabled,
           heap_clean_after_gc_enabled: heap_clean_after_gc_enabled,
         )
       end
 
       def self.for_testing(
-        cpu_time_enabled: true,
         alloc_samples_enabled: false,
         heap_samples_enabled: false,
         heap_size_enabled: false,
         heap_sample_every: 1,
-        timeline_enabled: false,
         heap_clean_after_gc_enabled: true,
         **options
       )
         new(
-          cpu_time_enabled: cpu_time_enabled,
           alloc_samples_enabled: alloc_samples_enabled,
           heap_samples_enabled: heap_samples_enabled,
           heap_size_enabled: heap_size_enabled,
           heap_sample_every: heap_sample_every,
-          timeline_enabled: timeline_enabled,
           heap_clean_after_gc_enabled: heap_clean_after_gc_enabled,
           **options,
         )
       end
 
       def serialize
-        status, result = @no_concurrent_synchronize_mutex.synchronize { self.class._native_serialize(self) }
+        status, result = @no_concurrent_serialize_mutex.synchronize { self.class._native_serialize(self) }
 
         if status == :ok
           start, finish, encoded_profile, profile_stats = result
@@ -71,15 +63,15 @@ module Datadog
         else
           error_message = result
 
-          Datadog.logger.error("Failed to serialize profiling data: #{error_message}")
-          Datadog::Core::Telemetry::Logger.error("Failed to serialize profiling data")
+          Datadog.logger.warn("Failed to serialize profiling data: #{error_message}")
+          Datadog::Core::Telemetry::Logger.error("Failed to serialize profiling data (#{error_message})")
 
           nil
         end
       end
 
       def serialize!
-        status, result = @no_concurrent_synchronize_mutex.synchronize { self.class._native_serialize(self) }
+        status, result = @no_concurrent_serialize_mutex.synchronize { self.class._native_serialize(self) }
 
         if status == :ok
           _start, _finish, encoded_profile = result

data/lib/datadog/profiling/tag_builder.rb

@@ -1,55 +1,59 @@
 # frozen_string_literal: true
 
-require_relative "../core/utils"
-require_relative "../core/environment/git"
+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:,
-        # Unified service tagging
-        env: settings.env,
-        service: settings.service,
-        version: settings.version,
-        # Other metadata
-        host: Core::Environment::Socket.hostname,
-        language: Core::Environment::Identity.lang,
-        pid: Process.pid.to_s,
-        profiler_version: Core::Environment::Identity.gem_datadog_version,
-        runtime_engine: Core::Environment::Identity.lang_engine,
-        runtime_id: Core::Environment::Identity.id,
-        runtime_version: Core::Environment::Identity.lang_version,
-        git_repository_url: Core::Environment::Git.git_repository_url,
-        git_commit_sha: Core::Environment::Git.git_commit_sha,
-        # User-provided tags
-        user_tags: settings.tags
+        profile_seq:,
+        profiler_version: Core::Environment::Identity.gem_datadog_version
       )
-        tags = {
-          # When changing or adding these, make sure they are kept in sync with
-          # https://docs.google.com/spreadsheets/d/1LOGMf4c4Avbtn36uZ2SWvhIGKRPLM1BoWkUP4JYj7hA/ (Datadog internal link)
-          FORM_FIELD_TAG_HOST => host,
-          FORM_FIELD_TAG_LANGUAGE => language,
-          FORM_FIELD_TAG_PID => pid,
+        hash = Core::TagBuilder.tags(settings).merge(
           FORM_FIELD_TAG_PROFILER_VERSION => profiler_version,
-          FORM_FIELD_TAG_RUNTIME => language, # This is known to be repeated from language, above
-          FORM_FIELD_TAG_RUNTIME_ENGINE => runtime_engine,
-          FORM_FIELD_TAG_RUNTIME_ID => runtime_id,
-          FORM_FIELD_TAG_RUNTIME_VERSION => runtime_version,
-        }
-        tags[FORM_FIELD_TAG_ENV] = env if env
-        tags[FORM_FIELD_TAG_SERVICE] = service if service
-        tags[FORM_FIELD_TAG_VERSION] = version if version
-        tags[TAG_GIT_REPOSITORY_URL] = git_repository_url if git_repository_url
-        tags[TAG_GIT_COMMIT_SHA] = git_commit_sha if git_commit_sha
+          'profile_seq' => profile_seq.to_s,
+        )
 
-        # Make sure everything is an utf-8 string, to avoid encoding issues in native code/further downstream
-        user_tags.merge(tags).map do |key, value|
-          [Datadog::Core::Utils.utf8_encode(key), Datadog::Core::Utils.utf8_encode(value)]
-        end.to_h
+        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
   end