ddtrace 1.16.0 → 1.18.0

data/lib/datadog/appsec/processor/rule_loader.rb

@@ -47,6 +47,13 @@ module Datadog
             data
           end
 
+          def load_exclusions(ip_passlist: [])
+            exclusions = []
+            exclusions << [passlist_exclusions(ip_passlist)] if ip_passlist.any?
+
+            exclusions
+          end
+
           private
 
           def denylist_data(id, denylist)
@@ -56,6 +63,59 @@ module Datadog
               'data' => denylist.map { |v| { 'value' => v.to_s, 'expiration' => 2**63 } }
             }
           end
+
+          def passlist_exclusions(ip_passlist) # rubocop:disable Metrics/MethodLength
+            case ip_passlist
+            when Array
+              pass = ip_passlist
+              monitor = []
+            when Hash
+              pass = ip_passlist[:pass]
+              monitor = ip_passlist[:monitor]
+            else
+              pass = []
+              monitor = []
+            end
+
+            exclusions = []
+
+            exclusions << {
+              'conditions' => [
+                {
+                  'operator' => 'ip_match',
+                  'parameters' => {
+                    'inputs' => [
+                      {
+                        'address' => 'http.client_ip'
+                      }
+                    ],
+                    'list' => pass
+                  }
+                }
+              ],
+              'id' => SecureRandom.uuid,
+            }
+
+            exclusions << {
+              'conditions' => [
+                {
+                  'operator' => 'ip_match',
+                  'parameters' => {
+                    'inputs' => [
+                      {
+                        'address' => 'http.client_ip'
+                      }
+                    ],
+                    'list' => monitor
+                  }
+                }
+              ],
+              'id' => SecureRandom.uuid,
+              'on_match' => 'monitor'
+            }
+
+            exclusions
+          end
         end
       end
     end

data/lib/datadog/appsec/remote.rb

@@ -12,15 +12,17 @@ module Datadog
       class NoRulesError < StandardError; end
 
       class << self
-        CAP_ASM_ACTIVATION                = 1 << 1 # Remote activation via ASM_FEATURES product
-        CAP_ASM_IP_BLOCKING               = 1 << 2 # accept IP blocking data from ASM_DATA product
-        CAP_ASM_DD_RULES                  = 1 << 3 # read ASM rules from ASM_DD product
-        CAP_ASM_EXCLUSIONS                = 1 << 4 # exclusion filters (passlist) via ASM product
-        CAP_ASM_REQUEST_BLOCKING          = 1 << 5 # can block on request info
-        CAP_ASM_RESPONSE_BLOCKING         = 1 << 6 # can block on response info
-        CAP_ASM_USER_BLOCKING             = 1 << 7 # accept user blocking data from ASM_DATA product
-        CAP_ASM_CUSTOM_RULES              = 1 << 8 # accept custom rules
-        CAP_ASM_CUSTOM_BLOCKING_RESPONSE  = 1 << 9 # supports custom http code or redirect sa blocking response
+        CAP_ASM_RESERVED_1                = 1 << 0   # RESERVED
+        CAP_ASM_ACTIVATION                = 1 << 1   # Remote activation via ASM_FEATURES product
+        CAP_ASM_IP_BLOCKING               = 1 << 2   # accept IP blocking data from ASM_DATA product
+        CAP_ASM_DD_RULES                  = 1 << 3   # read ASM rules from ASM_DD product
+        CAP_ASM_EXCLUSIONS                = 1 << 4   # exclusion filters (passlist) via ASM product
+        CAP_ASM_REQUEST_BLOCKING          = 1 << 5   # can block on request info
+        CAP_ASM_RESPONSE_BLOCKING         = 1 << 6   # can block on response info
+        CAP_ASM_USER_BLOCKING             = 1 << 7   # accept user blocking data from ASM_DATA product
+        CAP_ASM_CUSTOM_RULES              = 1 << 8   # accept custom rules
+        CAP_ASM_CUSTOM_BLOCKING_RESPONSE  = 1 << 9   # supports custom http code or redirect sa blocking response
+        CAP_ASM_TRUSTED_IPS               = 1 << 10  # supports trusted ip
 
         # TODO: we need to dynamically add CAP_ASM_ACTIVATION once we support it
         ASM_CAPABILITIES = [
@@ -32,6 +34,7 @@ module Datadog
           CAP_ASM_DD_RULES,
           CAP_ASM_CUSTOM_RULES,
           CAP_ASM_CUSTOM_BLOCKING_RESPONSE,
+          CAP_ASM_TRUSTED_IPS,
         ].freeze
 
         ASM_PRODUCTS = [

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

@@ -330,7 +330,7 @@ module Datadog
             # Caveat 3 (severe):
             # Ruby 3.2.0 to 3.2.2 have a bug in the newobj tracepoint (https://bugs.ruby-lang.org/issues/19482,
             # https://github.com/ruby/ruby/pull/7464) so that's an extra reason why it's not safe on those Rubies.
-            # This bug is fixed on Ruby versions 3.2.2 and 3.3.0.
+            # This bug is fixed on Ruby versions 3.2.3 and 3.3.0.
             #
             # @default `true` on Ruby 2.x and 3.1.4+, 3.2.3+ and 3.3.0+; `false` for Ruby 3.0 and unpatched Rubies.
             option :allocation_counting_enabled do |o|

data/lib/datadog/core/configuration.rb

@@ -273,6 +273,10 @@ module Datadog
       def handle_interrupt_shutdown!
         logger = Datadog.logger
         shutdown_thread = Thread.new { shutdown! }
+        unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3')
+          shutdown_thread.name = Datadog::Core::Configuration.name
+        end
+
         print_message_treshold_seconds = 0.2
 
         slow_shutdown = shutdown_thread.join(print_message_treshold_seconds).nil?

data/lib/datadog/core/remote/worker.rb

@@ -30,6 +30,7 @@ module Datadog
 
           thread = Thread.new { poll(@interval) }
           thread.name = self.class.name unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3')
+          thread.thread_variable_set(:fork_safe, true)
           @thr = thread
 
           @started = true

data/lib/datadog/core/workers/async.rb

@@ -147,6 +147,7 @@ module Datadog
               # rubocop:enable Lint/RescueException
             end
             @worker.name = self.class.name unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3')
+            @worker.thread_variable_set(:fork_safe, true)
 
             nil
           end

data/lib/datadog/kit/enable_core_dumps.rb

@@ -16,11 +16,13 @@ module Datadog
             '(Could not open /proc/sys/kernel/core_pattern)'
           end
 
+        enabled_status = "Maximum size: #{maximum_size} Output pattern: '#{core_pattern}'"
+
         if maximum_size <= 0
           Kernel.warn("[ddtrace] Could not enable core dumps on crash, maximum size is #{maximum_size} (disabled).")
           return
         elsif maximum_size == current_size
-          Kernel.warn('[ddtrace] Core dumps already enabled, nothing to do!')
+          Kernel.warn("[ddtrace] Core dumps already enabled, nothing to do. #{enabled_status}")
           return
         end
 
@@ -35,12 +37,9 @@ module Datadog
         end
 
         if current_size == 0
-          Kernel.warn("[ddtrace] Enabled core dumps. Maximum size: #{maximum_size} Output pattern: '#{core_pattern}'")
+          Kernel.warn("[ddtrace] Enabled core dumps. #{enabled_status}")
         else
-          Kernel.warn(
-            "[ddtrace] Raised core dump limit. Old size: #{current_size} " \
-            "Maximum size: #{maximum_size} Output pattern: '#{core_pattern}'"
-          )
+          Kernel.warn("[ddtrace] Raised core dump limit. Old size: #{current_size} #{enabled_status}")
         end
       end
     end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'trace/span'
+
 module Datadog
   module OpenTelemetry
     module SDK
@@ -76,16 +78,11 @@ module Datadog
         end
 
         def start_datadog_span(span)
-          tags = span.resource.attribute_enumerator.to_h
+          attributes = span.attributes.dup # Dup to allow modification of frozen Hash
 
-          kind = span.kind || 'internal'
-          tags[Tracing::Metadata::Ext::TAG_KIND] = kind
+          name, kwargs = span_arguments(span, attributes)
 
-          datadog_span = Tracing.trace(
-            span.name,
-            tags: tags,
-            start_time: ns_to_time(span.start_timestamp)
-          )
+          datadog_span = Tracing.trace(name, **kwargs)
 
           datadog_span.set_error([nil, span.status.description]) unless span.status.ok?
           datadog_span.set_tags(span.attributes)
@@ -93,6 +90,40 @@ module Datadog
           datadog_span
         end
 
+        # Some special attributes can override Datadog Span fields
+        def span_arguments(span, attributes)
+          if attributes.key?('analytics.event') && (analytics_event = attributes['analytics.event']).respond_to?(:casecmp)
+            attributes[Tracing::Metadata::Ext::Analytics::TAG_SAMPLE_RATE] = analytics_event.casecmp('true') == 0 ? 1 : 0
+          end
+          attributes[Tracing::Metadata::Ext::TAG_KIND] = span.kind || 'internal'
+
+          kwargs = { start_time: ns_to_time(span.start_timestamp) }
+
+          name = if attributes.key?('operation.name')
+                   attributes['operation.name']
+                 elsif (rich_name = Datadog::OpenTelemetry::Trace::Span.enrich_name(span.kind, attributes))
+                   rich_name.downcase
+                 else
+                   span.kind
+                 end
+
+          kwargs[:resource] = attributes.key?('resource.name') ? attributes['resource.name'] : span.name
+          kwargs[:service] = attributes['service.name'] if attributes.key?('service.name')
+          kwargs[:type] = attributes['span.type'] if attributes.key?('span.type')
+
+          attributes.reject! { |key, _| OpenTelemetry::Trace::Span::DATADOG_SPAN_ATTRIBUTE_OVERRIDES.include?(key) }
+
+          # DEV: There's no `flat_map!`; we have to split it into two operations
+          attributes = attributes.map do |key, value|
+            Datadog::OpenTelemetry::Trace::Span.serialize_attribute(key, value)
+          end
+          attributes.flatten!(1)
+
+          kwargs[:tags] = attributes
+
+          [name, kwargs]
+        end
+
         # From nanoseconds, used by OpenTelemetry, to a {Time} object, used by the Datadog Tracer.
         def ns_to_time(timestamp_ns)
           Time.at(timestamp_ns / 1000000000.0)

data/lib/datadog/opentelemetry/sdk/trace/span.rb

@@ -36,6 +36,78 @@ module Datadog
           span.set_error(status.description) if status && status.code == ::OpenTelemetry::Trace::Status::ERROR
         end
 
+        # Serialize values into Datadog span tags and metrics.
+        # Notably, arrays are exploded into many keys, each with
+        # a numeric suffix representing the array index, for example:
+        # `'foo' => ['a','b']` becomes `'foo.0' => 'a', 'foo.1' => 'b'`
+        def self.serialize_attribute(key, value)
+          if value.is_a?(Array)
+            value.flat_map.with_index do |v, idx|
+              serialize_attribute("#{key}.#{idx}", v)
+            end
+          elsif value.is_a?(TrueClass) || value.is_a?(FalseClass)
+            [[key, value.to_s]]
+          else
+            [[key, value]]
+          end
+        end
+
+        # Create a meaningful Datadog operation name from the OpenTelemetry
+        # semantic convention for span kind and span attributes.
+        # @see https://opentelemetry.io/docs/specs/semconv/general/trace/
+
+        # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        def self.enrich_name(kind, attrs)
+          if attrs.key?('http.request.method')
+            return 'http.server.request' if kind == :server
+            return 'http.client.request' if kind == :client
+          end
+
+          return "#{attrs['db.system']}.query" if attrs.key?('db.system') && kind == :client
+
+          if (attrs.key?('messaging.system') || attrs.key?('messaging.operation')) &&
+              [:consumer, :producer, :server, :client].include?(kind)
+
+            return "#{attrs['messaging.system']}.#{attrs['messaging.operation']}"
+          end
+
+          if attrs.key?('rpc.system')
+            if attrs['rpc.system'] == 'aws-api' && kind == :client
+              service = attrs['rpc.service']
+              return "aws.#{service || 'client'}.request"
+            end
+
+            if kind == :client
+              return "#{attrs['rpc.system']}.client.request"
+            elsif kind == :server
+              return "#{attrs['rpc.system']}.server.request"
+            end
+          end
+
+          if attrs.key?('faas.invoked_provider') && attrs.key?('faas.invoked_name') && kind == :client
+            provider = attrs['faas.invoked_provider']
+            name = attrs['faas.invoked_name']
+            return "#{provider}.#{name}.invoke"
+          end
+
+          return "#{attrs['faas.trigger']}.invoke" if attrs.key?('faas.trigger') && kind == :server
+
+          return 'graphql.server.request' if attrs.key?('graphql.operation.type')
+
+          if kind == :server
+            protocol = attrs['network.protocol.name']
+            return protocol ? "#{protocol}.server.request" : 'server.request'
+          end
+
+          if kind == :client
+            protocol = attrs['network.protocol.name']
+            return protocol ? "#{protocol}.client.request" : 'client.request'
+          end
+
+          kind.to_s
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+
         private
 
         def datadog_set_attribute(key)
@@ -46,10 +118,18 @@ module Datadog
           # DEV: Accesses `@attributes` directly, since using `#attributes`
           # DEV: clones the hash, causing unnecessary overhead.
           if @attributes.key?(key)
-            value = @attributes[key]
-            span.set_tag(key, value)
+            # Try to find a richer operation name, unless an explicit override was provided.
+            if !@attributes.key?('operation.name') && (rich_name = Span.enrich_name(kind, @attributes))
+              span.name = rich_name.downcase
+            end
+
+            Span.serialize_attribute(key, @attributes[key]).each do |new_key, value|
+              override_datadog_values(span, new_key, value)
 
-            span.service = value if key == 'service.name'
+              # When an attribute is used to override a Datadog Span property,
+              # it should NOT be set as a Datadog Span tag.
+              span.set_tag(new_key, value) unless DATADOG_SPAN_ATTRIBUTE_OVERRIDES.include?(new_key)
+            end
           else
             span.clear_tag(key)
 
@@ -61,6 +141,25 @@ module Datadog
           end
         end
 
+        # Some special attributes can override Datadog Span fields beyond tags and metrics.
+        # @return [Boolean] true if the key is a Datadog Span override attribute, false otherwise
+        def override_datadog_values(span, key, value)
+          span.name = value if key == 'operation.name'
+          span.resource = value if key == 'resource.name'
+          span.service = value if key == 'service.name'
+          span.type = value if key == 'span.type'
+
+          if key == 'analytics.event' && value.respond_to?(:casecmp)
+            Datadog::Tracing::Analytics.set_sample_rate(
+              span,
+              value.casecmp('true') == 0 ? 1 : 0
+            )
+          end
+        end
+
+        DATADOG_SPAN_ATTRIBUTE_OVERRIDES = ['analytics.event', 'operation.name', 'resource.name', 'service.name',
+                                            'span.type'].freeze
+
         ::OpenTelemetry::SDK::Trace::Span.prepend(self)
       end
     end

data/lib/datadog/opentracer/text_map_propagator.rb

@@ -33,7 +33,8 @@ module Datadog
           carrier[Tracing::Distributed::Datadog::ORIGIN_KEY] = digest.trace_origin
           carrier[Tracing::Distributed::Datadog::PARENT_ID_KEY] = digest.span_id
           carrier[Tracing::Distributed::Datadog::SAMPLING_PRIORITY_KEY] = digest.trace_sampling_priority
-          carrier[Tracing::Distributed::Datadog::TRACE_ID_KEY] = digest.trace_id
+          carrier[Tracing::Distributed::Datadog::TRACE_ID_KEY] =
+            Datadog::Tracing::Utils::TraceId.to_low_order(digest.trace_id)
 
           nil
         end

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

@@ -78,6 +78,7 @@ module Datadog
               end
             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)
           end
 
           true

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

@@ -43,6 +43,7 @@ module Datadog
               end
             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)
           end
 
           true

data/lib/datadog/profiling/component.rb

@@ -171,12 +171,11 @@ module Datadog
           return true
         end
 
-        if defined?(::PhusionPassenger)
+        if (defined?(::PhusionPassenger) || Gem.loaded_specs['passenger']) && incompatible_passenger_version?
           Datadog.logger.warn(
-            'Enabling the profiling "no signals" workaround because the passenger web server is in use. ' \
-            'This is needed because passenger is currently incompatible with the normal working mode ' \
-            'of the profiler, as detailed in <https://github.com/DataDog/dd-trace-rb/issues/2976>. ' \
-            'Profiling data will have lower quality.'
+            'Enabling the profiling "no signals" workaround because an incompatible version of the passenger gem is ' \
+            'installed. Profiling data will have lower quality.' \
+            'To fix this, upgrade the passenger gem to version 6.0.19 or above.'
           )
           return true
         end
@@ -237,6 +236,15 @@ module Datadog
           true
         end
       end
+
+      # See https://github.com/datadog/dd-trace-rb/issues/2976 for details.
+      private_class_method def self.incompatible_passenger_version?
+        if Gem.loaded_specs['passenger']
+          Gem.loaded_specs['passenger'].version < Gem::Version.new('6.0.19')
+        else
+          true
+        end
+      end
     end
   end
 end

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

@@ -62,6 +62,9 @@ module Datadog
           # @see https://opentelemetry.io/docs/concepts/sdk-configuration/general-sdk-configuration/#get_otel__propagators
           PROPAGATION_STYLE_NONE = 'none'
 
+          # Strictly stop at the first successfully serialized style.
+          EXTRACT_FIRST = 'DD_TRACE_PROPAGATION_EXTRACT_FIRST'
+
           ENV_X_DATADOG_TAGS_MAX_LENGTH = 'DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH'
         end
 

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

@@ -63,6 +63,7 @@ module Datadog
                       Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG,
                       Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_MULTI_HEADER,
                       Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_SINGLE_HEADER,
+                      Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_TRACE_CONTEXT,
                     ]
                   )
                   o.after_set do |styles|
@@ -93,7 +94,10 @@ module Datadog
                   o.deprecated_env Tracing::Configuration::Ext::Distributed::ENV_PROPAGATION_STYLE_INJECT_OLD
                   o.env Tracing::Configuration::Ext::Distributed::ENV_PROPAGATION_STYLE_INJECT
                   # DEV-2.0: Change default value to `tracecontext, Datadog`.
-                  o.default [Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG]
+                  o.default [
+                    Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG,
+                    Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_TRACE_CONTEXT,
+                  ]
                   o.after_set do |styles|
                     # Modernize B3 options
                     # DEV-2.0: Can be removed with the removal of deprecated B3 constants.
@@ -142,6 +146,17 @@ module Datadog
                     set_option(:propagation_inject_style, styles)
                   end
                 end
+
+                # Strictly stop at the first successfully serialized style.
+                # This prevents the tracer from enriching the extracted context with information from
+                # other valid propagations styles present in the request.
+                # @default `DD_TRACE_PROPAGATION_EXTRACT_FIRST` environment variable, otherwise `false`.
+                # @return [Boolean]
+                option :propagation_extract_first do |o|
+                  o.env Tracing::Configuration::Ext::Distributed::EXTRACT_FIRST
+                  o.default false
+                  o.type :bool
+                end
               end
 
               # Enable trace collection and span generation.
@@ -177,11 +192,11 @@ module Datadog
 
               # Enable 128 bit trace id generation.
               #
-              # @default `DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED` environment variable, otherwise `false`
+              # @default `DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED` environment variable, otherwise `true`
               # @return [Boolean]
               option :trace_id_128_bit_generation_enabled do |o|
                 o.env Tracing::Configuration::Ext::ENV_TRACE_ID_128_BIT_GENERATION_ENABLED
-                o.default false
+                o.default true
                 o.type :bool
               end
 

data/lib/datadog/tracing/contrib/concurrent_ruby/context_composite_executor_service.rb

@@ -19,7 +19,7 @@ module Datadog
           # post method runs the task within composited executor - in a different thread. The original arguments are
           # captured to be propagated to the composited executor post method
           def post(*args, &task)
-            digest = Tracing.active_trace.to_digest
+            digest = Tracing.active_trace && Tracing.active_trace.to_digest
             executor = @composited_executor.is_a?(Symbol) ? Concurrent.executor(@composited_executor) : @composited_executor
 
             # Pass the original arguments to the composited executor, which

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

@@ -25,6 +25,11 @@ module Datadog
               o.default false
             end
 
+            option :error_handler do |o|
+              o.type :proc
+              o.default_proc(&Tracing::SpanOperation::Events::DEFAULT_ON_ERROR)
+            end
+
             option :analytics_sample_rate do |o|
               o.type :float
               o.env Ext::ENV_ANALYTICS_SAMPLE_RATE

data/lib/datadog/tracing/contrib/pg/instrumentation.rb

@@ -21,18 +21,24 @@ module Datadog
           # PG::Connection patch methods
           module InstanceMethods
             def exec(sql, *args, &block)
+              return super unless enabled?
+
               trace(Ext::SPAN_EXEC, sql: sql, block: block) do |sql_statement, wrapped_block|
                 super(sql_statement, *args, &wrapped_block)
               end
             end
 
             def exec_params(sql, params, *args, &block)
+              return super unless enabled?
+
               trace(Ext::SPAN_EXEC_PARAMS, sql: sql, block: block) do |sql_statement, wrapped_block|
                 super(sql_statement, params, *args, &wrapped_block)
               end
             end
 
             def exec_prepared(statement_name, params, *args, &block)
+              return super unless enabled?
+
               trace(Ext::SPAN_EXEC_PREPARED, statement_name: statement_name, block: block) do |_, wrapped_block|
                 super(statement_name, params, *args, &wrapped_block)
               end
@@ -40,6 +46,8 @@ module Datadog
 
             # async_exec is an alias to exec
             def async_exec(sql, *args, &block)
+              return super unless enabled?
+
               trace(Ext::SPAN_ASYNC_EXEC, sql: sql, block: block) do |sql_statement, wrapped_block|
                 super(sql_statement, *args, &wrapped_block)
               end
@@ -47,6 +55,8 @@ module Datadog
 
             # async_exec_params is an alias to exec_params
             def async_exec_params(sql, params, *args, &block)
+              return super unless enabled?
+
               trace(Ext::SPAN_ASYNC_EXEC_PARAMS, sql: sql, block: block) do |sql_statement, wrapped_block|
                 super(sql_statement, params, *args, &wrapped_block)
               end
@@ -54,24 +64,32 @@ module Datadog
 
             # async_exec_prepared is an alias to exec_prepared
             def async_exec_prepared(statement_name, params, *args, &block)
+              return super unless enabled?
+
               trace(Ext::SPAN_ASYNC_EXEC_PREPARED, statement_name: statement_name, block: block) do |_, wrapped_block|
                 super(statement_name, params, *args, &wrapped_block)
               end
             end
 
             def sync_exec(sql, *args, &block)
+              return super unless enabled?
+
               trace(Ext::SPAN_SYNC_EXEC, sql: sql, block: block) do |sql_statement, wrapped_block|
                 super(sql_statement, *args, &wrapped_block)
               end
             end
 
             def sync_exec_params(sql, params, *args, &block)
+              return super unless enabled?
+
               trace(Ext::SPAN_SYNC_EXEC_PARAMS, sql: sql, block: block) do |sql_statement, wrapped_block|
                 super(sql_statement, params, *args, &wrapped_block)
               end
             end
 
             def sync_exec_prepared(statement_name, params, *args, &block)
+              return super unless enabled?
+
               trace(Ext::SPAN_SYNC_EXEC_PREPARED, statement_name: statement_name, block: block) do |_, wrapped_block|
                 super(statement_name, params, *args, &wrapped_block)
               end
@@ -81,10 +99,12 @@ module Datadog
 
             def trace(name, sql: nil, statement_name: nil, block: nil)
               service = Datadog.configuration_for(self, :service_name) || datadog_configuration[:service_name]
+              error_handler = datadog_configuration[:error_handler]
               resource = statement_name || sql
 
               Tracing.trace(
                 name,
+                on_error: error_handler,
                 service: service,
                 resource: resource,
                 type: Tracing::Metadata::Ext::SQL::TYPE
@@ -172,6 +192,10 @@ module Datadog
             def comment_propagation
               datadog_configuration[:comment_propagation]
             end
+
+            def enabled?
+              datadog_configuration[:enabled]
+            end
           end
         end
       end

data/lib/datadog/tracing/distributed/datadog.rb

@@ -49,7 +49,6 @@ module Datadog
           build_tags(digest).tap do |tags|
             inject_tags!(tags, data) unless tags.empty?
           end
-
           data
         end