datadog 2.7.1 → 2.18.0

data/lib/datadog/profiling/http_transport.rb

@@ -13,43 +13,23 @@ module Datadog
       def initialize(agent_settings:, site:, api_key:, upload_timeout_seconds:)
         @upload_timeout_milliseconds = (upload_timeout_seconds * 1_000).to_i
 
-        validate_agent_settings(agent_settings)
-
         @exporter_configuration =
           if agentless?(site, api_key)
             [:agentless, site, api_key].freeze
           else
-            [:agent, base_url_from(agent_settings)].freeze
+            [:agent, agent_settings.url].freeze
           end
 
-        status, result = validate_exporter(exporter_configuration)
+        status, result = self.class._native_validate_exporter(exporter_configuration)
 
         raise(ArgumentError, "Failed to initialize transport: #{result}") if status == :error
       end
 
       def export(flush)
-        status, result = do_export(
-          exporter_configuration: exporter_configuration,
-          upload_timeout_milliseconds: @upload_timeout_milliseconds,
-
-          # why "timespec"?
-          # libdatadog represents time using POSIX's struct timespec, see
-          # https://www.gnu.org/software/libc/manual/html_node/Time-Types.html
-          # aka it represents the seconds part separate from the nanoseconds part
-          start_timespec_seconds: flush.start.tv_sec,
-          start_timespec_nanoseconds: flush.start.tv_nsec,
-          finish_timespec_seconds: flush.finish.tv_sec,
-          finish_timespec_nanoseconds: flush.finish.tv_nsec,
-
-          pprof_file_name: flush.pprof_file_name,
-          pprof_data: flush.pprof_data,
-          code_provenance_file_name: flush.code_provenance_file_name,
-          code_provenance_data: flush.code_provenance_data,
-
-          tags_as_array: flush.tags_as_array,
-          internal_metadata_json: flush.internal_metadata_json,
-
-          info_json: flush.info_json
+        status, result = self.class._native_do_export(
+          exporter_configuration,
+          @upload_timeout_milliseconds,
+          flush
         )
 
         if status == :ok
@@ -57,7 +37,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"
             )
@@ -67,7 +47,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
@@ -75,69 +55,10 @@ module Datadog
 
       private
 
-      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}/"
-        when Datadog::Core::Configuration::Ext::Agent::UnixSocket::ADAPTER
-          "unix://#{agent_settings.uds_path}"
-        else
-          raise ArgumentError, "Unexpected adapter: #{agent_settings.adapter}"
-        end
-      end
-
-      def validate_agent_settings(agent_settings)
-        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"
-        end
-      end
-
       def agentless?(site, api_key)
         site && api_key && Core::Environment::VariableHelpers.env_to_bool(Profiling::Ext::ENV_AGENTLESS, false)
       end
 
-      def validate_exporter(exporter_configuration)
-        self.class._native_validate_exporter(exporter_configuration)
-      end
-
-      def do_export(
-        exporter_configuration:,
-        upload_timeout_milliseconds:,
-        start_timespec_seconds:,
-        start_timespec_nanoseconds:,
-        finish_timespec_seconds:,
-        finish_timespec_nanoseconds:,
-        pprof_file_name:,
-        pprof_data:,
-        code_provenance_file_name:,
-        code_provenance_data:,
-        tags_as_array:,
-        internal_metadata_json:,
-        info_json:
-      )
-        self.class._native_do_export(
-          exporter_configuration,
-          upload_timeout_milliseconds,
-          start_timespec_seconds,
-          start_timespec_nanoseconds,
-          finish_timespec_seconds,
-          finish_timespec_nanoseconds,
-          pprof_file_name,
-          pprof_data,
-          code_provenance_file_name,
-          code_provenance_data,
-          tags_as_array,
-          internal_metadata_json,
-          info_json,
-        )
-      end
-
       def config_without_api_key
         "#{exporter_configuration[0]}: #{exporter_configuration[1]}"
       end

data/lib/datadog/profiling/load_native_extension.rb

@@ -1,41 +1,9 @@
 # frozen_string_literal: true
 
-# This file is used to load the profiling native extension. It works in two steps:
-#
-# 1. Load the datadog_profiling_loader extension. This extension will be used to load the actual extension, but in
-#    a special way that avoids exposing native-level code symbols. See `datadog_profiling_loader.c` for more details.
-#
-# 2. Use the Datadog::Profiling::Loader exposed by the datadog_profiling_loader extension to load the actual
-#    profiling native extension.
-#
-# All code on this file is on-purpose at the top-level; this makes it so this file is executed only once,
-# the first time it gets required, to avoid any issues with the native extension being initialized more than once.
-
 begin
-  require "datadog_profiling_loader.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
+  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})"
 end
-
-extension_name = "datadog_profiling_native_extension.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
-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
-  candidate_path = "#{extension_dir}/#{file_name}"
-  if File.exist?(candidate_path)
-    full_file_path = candidate_path
-  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}"
-
-status, result = Datadog::Profiling::Loader._native_load(full_file_path, init_function_name)
-
-raise "Failure to load #{extension_name} due to #{result}" if status == :error

data/lib/datadog/profiling/profiler.rb

@@ -50,6 +50,8 @@ module Datadog
           "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")
 
         # 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.

data/lib/datadog/profiling/scheduler.rb

@@ -37,6 +37,7 @@ module Datadog
         @exporter = exporter
         @transport = transport
         @profiler_failed = false
+        @stop_requested = false
 
         # Workers::Async::Thread settings
         self.fork_policy = fork_policy
@@ -67,6 +68,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: "Profiling::Scheduler thread error")
         raise
       ensure
         Datadog.logger.debug("#flush was interrupted or failed before it could complete") if interrupted
@@ -88,7 +90,7 @@ module Datadog
       end
 
       def work_pending?
-        !profiler_failed && exporter.can_flush?
+        !profiler_failed && exporter.can_flush? && (run_loop? || !stop_requested?)
       end
 
       def reset_after_fork
@@ -132,14 +134,20 @@ module Datadog
         begin
           transport.export(flush)
         rescue => e
-          Datadog.logger.error(
+          Datadog.logger.warn(
             "Unable to report profile. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
           )
           Datadog::Core::Telemetry::Logger.report(e, description: "Unable to report profile")
         end
 
+        @stop_requested = !run_loop?
+
         true
       end
+
+      def stop_requested?
+        @stop_requested
+      end
     end
   end
 end

data/lib/datadog/profiling/stack_recorder.rb

@@ -23,7 +23,7 @@ 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,
@@ -60,31 +60,31 @@ module Datadog
       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_pprof, profile_stats = result
+          start, finish, encoded_profile, profile_stats = result
 
           Datadog.logger.debug { "Encoded profile covering #{start.iso8601} to #{finish.iso8601}" }
 
-          [start, finish, encoded_pprof, profile_stats]
+          [start, finish, encoded_profile, profile_stats]
         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_pprof = result
+          _start, _finish, encoded_profile = result
 
-          encoded_pprof
+          encoded_profile
         else
           error_message = result
 

data/lib/datadog/profiling/tag_builder.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../core/tag_builder"
 require_relative "../core/utils"
-require_relative "../core/environment/git"
 
 module Datadog
   module Profiling
@@ -11,49 +11,13 @@ module Datadog
 
       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,
-        # TODO: If profiling is extracted and its version diverges from the datadog gem, this is inaccurate.
-        #       Update if this ever occurs.
-        profiler_version: Core::Environment::Identity.gem_datadog_version,
-        runtime_engine: Core::Environment::Identity.lang_engine,
-        runtime_id: Core::Environment::Identity.id,
-        runtime_platform: Core::Environment::Identity.lang_platform,
-        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
+        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_PLATFORM => runtime_platform,
-          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
-
-        # Make sure everything is an utf-8 string, to avoid encoding issues in native code/libddprof/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
+        )
+        Core::Utils.encode_tags(hash)
       end
     end
   end

data/lib/datadog/profiling/tasks/setup.rb

@@ -19,6 +19,7 @@ module Datadog
               "Profiler extensions unavailable. Cause: #{e.class.name} #{e.message} " \
               "Location: #{Array(e.backtrace).first}"
             end
+            Datadog::Core::Telemetry::Logger.report(e, description: "Profiler extensions unavailable")
           end
         end
 
@@ -33,6 +34,7 @@ module Datadog
               "Error during post-fork hooks. Cause: #{e.class.name} #{e.message} " \
               "Location: #{Array(e.backtrace).first}"
             end
+            Datadog::Core::Telemetry::Logger.report(e, description: "Error during post-fork hooks")
           end
         end
       end

data/lib/datadog/profiling.rb

@@ -78,8 +78,11 @@ module Datadog
     end
 
     private_class_method def self.replace_noop_allocation_count
-      def self.allocation_count # rubocop:disable Lint/NestedMethodDefinition (On purpose!)
-        Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_allocation_count
+      class << self
+        remove_method :allocation_count
+        def allocation_count
+          Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_allocation_count
+        end
       end
     end
 
@@ -146,6 +149,7 @@ module Datadog
       require_relative 'profiling/collectors/thread_context'
       require_relative 'profiling/stack_recorder'
       require_relative 'profiling/exporter'
+      require_relative 'profiling/encoded_profile'
       require_relative 'profiling/flush'
       require_relative 'profiling/scheduler'
       require_relative 'profiling/tasks/setup'

data/lib/datadog/tracing/analytics.rb

@@ -16,7 +16,7 @@ module Datadog
         def set_measured(span_op, value = true)
           return if span_op.nil?
 
-          value = value == true || value == 1 ? 1 : 0 # rubocop:disable Style/MultipleComparison
+          value = value == true || value == 1 ? 1 : 0
           span_op.set_metric(Metadata::Ext::Analytics::TAG_MEASURED, value)
         end
       end

data/lib/datadog/tracing/component.rb

@@ -6,6 +6,7 @@ require_relative 'sync_writer'
 require_relative 'sampling/span/rule_parser'
 require_relative 'sampling/span/sampler'
 require_relative 'diagnostics/environment_logger'
+require_relative 'contrib/component'
 
 module Datadog
   module Tracing
@@ -49,6 +50,7 @@ module Datadog
         Tracing::Tracer.new(
           default_service: settings.service,
           enabled: settings.tracing.enabled,
+          logger: logger,
           trace_flush: trace_flush,
           sampler: sampler_delegator,
           span_sampler: build_span_sampler(settings),
@@ -73,18 +75,11 @@ module Datadog
           return sampler
         end
 
-        # AppSec events are sent to the backend using traces.
-        # Standalone ASM billing means that we don't want to charge clients for APM traces,
-        # so we want to send the minimum amount of traces possible (idealy only traces that contains security events),
-        # but for features such as API Security, we need to send at least one trace per minute,
-        # to keep the service alive on the backend side.
-        if settings.appsec.standalone.enabled
-          post_sampler = Tracing::Sampling::RuleSampler.new(
-            [Tracing::Sampling::SimpleRule.new(sample_rate: 1.0)],
-            rate_limiter: Datadog::Core::TokenBucket.new(1.0 / 60, 1.0),
-            default_sample_rate: 1.0 / 60
-          )
-        end
+        # APM Disablement means that we don't want to send traces that only contains APM data.
+        # Other products can then put the sampling priority to MANUAL_KEEP if they want to keep traces.
+        # (e.g.: AppSec will MANUAL_KEEP traces with AppSec events) and clients will be billed only for those traces.
+        # But to keep the service alive on the backend side, we need to send one trace per minute.
+        post_sampler = build_rate_limit_post_sampler(seconds: 60) unless settings.apm.tracing.enabled
 
         # Sampling rules are provided
         if (rules = settings.tracing.sampling.rules)
@@ -196,6 +191,15 @@ module Datadog
         end
       end
 
+      # Build a post-sampler that limits the rate of traces to one per `seconds`.
+      # E.g.: `build_rate_limit_post_sampler(seconds: 60)` will limit the rate to one trace per minute.
+      def build_rate_limit_post_sampler(seconds:)
+        Tracing::Sampling::RuleSampler.new(
+          rate_limiter: Datadog::Core::TokenBucket.new(1.0 / seconds, 1.0),
+          default_sample_rate: 1.0
+        )
+      end
+
       def build_test_mode_trace_flush(settings)
         # If context flush behavior is provided, use it instead.
         settings.tracing.test_mode.trace_flush || build_trace_flush(settings)

data/lib/datadog/tracing/configuration/ext.rb

@@ -12,10 +12,12 @@ module Datadog
         ENV_OTEL_TRACES_EXPORTER = 'OTEL_TRACES_EXPORTER'
         ENV_HEADER_TAGS = 'DD_TRACE_HEADER_TAGS'
         ENV_TRACE_ID_128_BIT_GENERATION_ENABLED = 'DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED'
+        ENV_NATIVE_SPAN_EVENTS = 'DD_TRACE_NATIVE_SPAN_EVENTS'
 
         # @public_api
         module SpanAttributeSchema
           ENV_GLOBAL_DEFAULT_SERVICE_NAME_ENABLED = 'DD_TRACE_REMOVE_INTEGRATION_SERVICE_NAMES_ENABLED'
+          ENV_PEER_SERVICE_DEFAULTS_ENABLED = 'DD_TRACE_PEER_SERVICE_DEFAULTS_ENABLED'
           ENV_PEER_SERVICE_MAPPING = 'DD_TRACE_PEER_SERVICE_MAPPING'
         end
 
@@ -40,8 +42,13 @@ module Datadog
           # W3C Trace Context
           PROPAGATION_STYLE_TRACE_CONTEXT = 'tracecontext'
 
+          # W3C Baggage
+          # @see https://www.w3.org/TR/baggage/
+          PROPAGATION_STYLE_BAGGAGE = 'baggage'
+
           PROPAGATION_STYLE_SUPPORTED = [PROPAGATION_STYLE_DATADOG, PROPAGATION_STYLE_B3_MULTI_HEADER,
-                                         PROPAGATION_STYLE_B3_SINGLE_HEADER, PROPAGATION_STYLE_TRACE_CONTEXT].freeze
+                                         PROPAGATION_STYLE_B3_SINGLE_HEADER, PROPAGATION_STYLE_TRACE_CONTEXT,
+                                         PROPAGATION_STYLE_BAGGAGE].freeze
 
           # Sets both extract and inject propagation style tho the provided value.
           # Has lower precedence than `DD_TRACE_PROPAGATION_STYLE_INJECT` or

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

@@ -42,7 +42,7 @@ module Datadog
               #
               # The tracer will try to find distributed headers in the order they are present in the list provided to this option.
               # The first format to have valid data present will be used.
-              #
+              # Baggage style is a special case, as it will always be extracted in addition if present.
               # @default `DD_TRACE_PROPAGATION_STYLE_EXTRACT` environment variable (comma-separated list),
               #   otherwise `['datadog','b3multi','b3']`.
               # @return [Array<String>]
@@ -53,6 +53,7 @@ module Datadog
                   [
                     Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG,
                     Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_TRACE_CONTEXT,
+                    Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_BAGGAGE,
                   ]
                 )
                 o.after_set do |styles|
@@ -74,6 +75,7 @@ module Datadog
                 o.default [
                   Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG,
                   Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_TRACE_CONTEXT,
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_BAGGAGE,
                 ]
                 o.after_set do |styles|
                   # Make values case-insensitive
@@ -186,7 +188,7 @@ module Datadog
               # It is not supported by our backend yet. Do not enable it.
               option :trace_id_128_bit_logging_enabled do |o|
                 o.env Tracing::Configuration::Ext::Correlation::ENV_TRACE_ID_128_BIT_LOGGING_ENABLED
-                o.default false
+                o.default true
                 o.type :bool
               end
 
@@ -249,6 +251,20 @@ module Datadog
                 o.type :bool
               end
 
+              # Forces the tracer to always send span events with the native span events format
+              # regardless of the agent support. This is useful in agent-less setups.
+              #
+              # When set to `nil`, the default, the agent will be queried for
+              # native span events support.
+              #
+              # @default `DD_TRACE_NATIVE_SPAN_EVENTS` environment variable, otherwise `false`
+              # @return [Boolean,nil]
+              option :native_span_events do |o|
+                o.env Tracing::Configuration::Ext::ENV_NATIVE_SPAN_EVENTS
+                o.default nil
+                o.type :bool, nilable: true
+              end
+
               # A custom sampler instance.
               # The object must respect the {Datadog::Tracing::Sampling::Sampler} interface.
               # @default `nil`
@@ -368,22 +384,18 @@ module Datadog
                 end
               end
 
-              # [Continuous Integration Visibility](https://docs.datadoghq.com/continuous_integration/) configuration.
+              # This is only for internal Datadog use via https://github.com/DataDog/datadog-ci-rb . It should not be
+              # used directly.
+              #
+              # DEV-3.0: Make this a non-public API in the next release.
               # @public_api
               settings :test_mode do
-                # Enable test mode. This allows the tracer to collect spans from test runs.
-                #
-                # It also prevents the tracer from collecting spans in a production environment. Only use in a test environment.
-                #
-                # @default `DD_TRACE_TEST_MODE_ENABLED` environment variable, otherwise `false`
-                # @return [Boolean]
                 option :enabled do |o|
                   o.type :bool
                   o.default false
                   o.env Tracing::Configuration::Ext::Test::ENV_MODE_ENABLED
                 end
 
-                # Use async writer in test mode
                 option :async do |o|
                   o.type :bool
                   o.default false

data/lib/datadog/tracing/context_provider.rb

@@ -49,7 +49,7 @@ module Datadog
       # To support multiple tracers simultaneously, each {Datadog::Tracing::FiberLocalContext}
       # instance has its own fiber-local variable.
       def initialize
-        @key = "datadog_context_#{FiberLocalContext.next_instance_id}".to_sym
+        @key = :"datadog_context_#{FiberLocalContext.next_instance_id}"
 
         self.local = Context.new
       end

data/lib/datadog/tracing/contrib/action_cable/integration.rb

@@ -3,7 +3,7 @@
 require_relative '../integration'
 require_relative 'configuration/settings'
 require_relative 'patcher'
-require_relative '../rails/utils'
+require_relative '../../../core/contrib/rails/utils'
 
 module Datadog
   module Tracing
@@ -17,6 +17,9 @@ module Datadog
 
           # @public_api Changing the integration name or integration options can cause breaking changes
           register_as :action_cable, auto_patch: false
+          def self.gem_name
+            'actioncable'
+          end
 
           def self.version
             Gem.loaded_specs['actioncable'] && Gem.loaded_specs['actioncable'].version
@@ -33,7 +36,7 @@ module Datadog
           # enabled by rails integration so should only auto instrument
           # if detected that it is being used without rails
           def auto_instrument?
-            !Contrib::Rails::Utils.railtie_supported?
+            !Core::Contrib::Rails::Utils.railtie_supported?
           end
 
           def new_configuration

data/lib/datadog/tracing/contrib/action_mailer/integration.rb

@@ -3,7 +3,7 @@
 require_relative 'configuration/settings'
 require_relative 'patcher'
 require_relative '../integration'
-require_relative '../rails/utils'
+require_relative '../../../core/contrib/rails/utils'
 
 module Datadog
   module Tracing
@@ -18,6 +18,10 @@ module Datadog
           # @public_api Changing the integration name or integration options can cause breaking changes
           register_as :action_mailer, auto_patch: false
 
+          def self.gem_name
+            'actionmailer'
+          end
+
           def self.version
             Gem.loaded_specs['actionmailer'] && Gem.loaded_specs['actionmailer'].version
           end
@@ -33,7 +37,7 @@ module Datadog
           # enabled by rails integration so should only auto instrument
           # if detected that it is being used without rails
           def auto_instrument?
-            !Contrib::Rails::Utils.railtie_supported?
+            !Core::Contrib::Rails::Utils.railtie_supported?
           end
 
           def new_configuration

data/lib/datadog/tracing/contrib/action_pack/action_controller/instrumentation.rb

@@ -68,6 +68,12 @@ module Datadog
 
                 span.set_tag(Ext::TAG_ROUTE_ACTION, payload.fetch(:action))
                 span.set_tag(Ext::TAG_ROUTE_CONTROLLER, payload.fetch(:controller))
+                if (runtime = payload[:view_runtime])
+                  span.set_tag(Ext::TAG_VIEW_RUNTIME, runtime)
+                end
+                if (runtime = payload[:db_runtime])
+                  span.set_tag(Ext::TAG_DB_RUNTIME, runtime)
+                end
 
                 exception = payload[:exception_object]
                 if exception.nil?
@@ -118,6 +124,15 @@ module Datadog
                   payload[:exception] = [e.class.name, e.message]
                   payload[:exception_object] = e
                   raise e
+                ensure
+                  # Database and view runtime are available for controllers
+                  # deriving from ActionController::Base.
+                  # They are not defined on controllers deriving from
+                  # ActionController::Metal, unless
+                  # ActionController::Instrumentation is explicitly included
+                  # into the controller class.
+                  payload[:db_runtime] = db_runtime if respond_to?(:db_runtime)
+                  payload[:view_runtime] = view_runtime if respond_to?(:view_runtime)
                 end
               # rubocop:enable Lint/RescueException
               ensure