ddtrace 1.12.1 → 1.14.0

data/lib/datadog/tracing/correlation.rb

@@ -1,5 +1,6 @@
 require_relative 'utils'
 require_relative 'metadata/ext'
+require_relative '../core/logging/ext'
 
 module Datadog
   module Tracing
@@ -14,6 +15,7 @@ module Datadog
         LOG_ATTR_SPAN_ID = 'dd.span_id'.freeze
         LOG_ATTR_TRACE_ID = 'dd.trace_id'.freeze
         LOG_ATTR_VERSION = 'dd.version'.freeze
+        LOG_ATTR_SOURCE = 'ddsource'.freeze
 
         attr_reader \
           :env,
@@ -23,7 +25,6 @@ module Datadog
           :span_resource,
           :span_service,
           :span_type,
-          :trace_id,
           :trace_name,
           :trace_resource,
           :trace_service,
@@ -59,28 +60,44 @@ module Datadog
           @version = Core::Utils::SafeDup.frozen_dup(version || Datadog.configuration.version)
         end
 
+        def to_h
+          @to_h ||= {
+            # Adds IDs as tags to log output
+            dd: {
+              # To preserve precision during JSON serialization, use strings for large numbers
+              env: env.to_s,
+              service: service.to_s,
+              version: version.to_s,
+              trace_id: trace_id.to_s,
+              span_id: span_id.to_s
+            },
+            ddsource: Core::Logging::Ext::DD_SOURCE
+          }
+        end
+
+        # This method (#to_log_format) implements an algorithm by prefixing keys for nested values
+        # but the algorithm makes the constants implicit. Hence, we use it for validation during test.
         def to_log_format
           @log_format ||= begin
             attributes = []
             attributes << "#{LOG_ATTR_ENV}=#{env}" unless env.nil?
             attributes << "#{LOG_ATTR_SERVICE}=#{service}"
             attributes << "#{LOG_ATTR_VERSION}=#{version}" unless version.nil?
-            attributes << "#{LOG_ATTR_TRACE_ID}=#{logging_trace_id}"
+            attributes << "#{LOG_ATTR_TRACE_ID}=#{trace_id}"
             attributes << "#{LOG_ATTR_SPAN_ID}=#{span_id}"
+            attributes << "#{LOG_ATTR_SOURCE}=#{Core::Logging::Ext::DD_SOURCE}"
             attributes.join(' ')
           end
         end
 
-        private
-
-        def logging_trace_id
-          @logging_trace_id ||=
-            if Datadog.configuration.tracing.trace_id_128_bit_logging_enabled &&
-                !Tracing::Utils::TraceId.to_high_order(@trace_id).zero?
-              Kernel.format('%032x', trace_id)
-            else
-              Tracing::Utils::TraceId.to_low_order(@trace_id)
-            end
+        # DEV-2.0: This public method was returning an Integer, but with 128 bit trace id it would return a String.
+        def trace_id
+          if Datadog.configuration.tracing.trace_id_128_bit_logging_enabled &&
+              !Tracing::Utils::TraceId.to_high_order(@trace_id).zero?
+            Kernel.format('%032x', @trace_id)
+          else
+            Tracing::Utils::TraceId.to_low_order(@trace_id)
+          end
         end
       end
 

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

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'json'
+require 'rbconfig'
+require_relative '../../core/diagnostics/environment_logger'
+
+module Datadog
+  module Tracing
+    module Diagnostics
+      # Collects and logs Tracing diagnostic and error information
+      module EnvironmentLogger
+        extend Core::Diagnostics::EnvironmentLogging
+
+        def self.collect_and_log!(responses: nil)
+          log_once! do
+            env_data = EnvironmentCollector.collect_config!
+            log_configuration!('TRACING', env_data.to_json)
+
+            if responses
+              err_data = EnvironmentCollector.collect_errors!(responses)
+              err_data.reject! { |_, v| v.nil? } # Remove empty values from hash output
+              log_error!('TRACING', 'Agent Error', err_data.to_json) unless err_data.empty?
+            end
+          end
+        rescue => e
+          logger.warn("Failed to collect tracing environment information: #{e} Location: #{Array(e.backtrace).first}")
+        end
+      end
+
+      # Collects environment information for Tracing diagnostic logging
+      module EnvironmentCollector
+        class << self
+          def collect_config!
+            {
+              enabled: enabled,
+              agent_url: agent_url,
+              analytics_enabled: analytics_enabled,
+              sample_rate: sample_rate,
+              sampling_rules: sampling_rules,
+              integrations_loaded: integrations_loaded,
+              partial_flushing_enabled: partial_flushing_enabled,
+              priority_sampling_enabled: priority_sampling_enabled,
+              **instrumented_integrations_settings
+            }
+          end
+
+          def collect_errors!(responses)
+            {
+              agent_error: agent_error(responses)
+            }
+          end
+
+          # @return [Boolean, nil]
+          def enabled
+            !!Datadog.configuration.tracing.enabled
+          end
+
+          # @return [String, nil] target agent URL for trace flushing
+          def agent_url
+            # Retrieve the effect agent URL, regardless of how it was configured
+            transport = Tracing.send(:tracer).writer.transport
+
+            # return `nil` with IO transport
+            return unless transport.respond_to?(:client)
+
+            adapter = transport.client.api.adapter
+            adapter.url
+          end
+
+          # Error returned by Datadog agent during a tracer flush attempt
+          # @return [String] concatenated list of transport errors
+          def agent_error(responses)
+            error_responses = responses.reject(&:ok?)
+
+            return nil if error_responses.empty?
+
+            error_responses.map(&:inspect).join(',')
+          end
+
+          # @return [Boolean, nil] analytics enabled in configuration
+          def analytics_enabled
+            !!Datadog.configuration.tracing.analytics.enabled
+          end
+
+          # @return [Numeric, nil] tracer sample rate configured
+          def sample_rate
+            sampler = Datadog.configuration.tracing.sampler
+            return nil unless sampler
+
+            sampler.sample_rate(nil) rescue nil
+          end
+
+          # DEV: We currently only support SimpleRule instances.
+          # DEV: These are the most commonly used rules.
+          # DEV: We should expand support for other rules in the future,
+          # DEV: although it is tricky to serialize arbitrary rules.
+          #
+          # @return [Hash, nil] sample rules configured
+          def sampling_rules
+            sampler = Datadog.configuration.tracing.sampler
+            return nil unless sampler.is_a?(Tracing::Sampling::PrioritySampler) &&
+              sampler.priority_sampler.is_a?(Tracing::Sampling::RuleSampler)
+
+            sampler.priority_sampler.rules.map do |rule|
+              next unless rule.is_a?(Tracing::Sampling::SimpleRule)
+
+              {
+                name: rule.matcher.name,
+                service: rule.matcher.service,
+                sample_rate: rule.sampler.sample_rate(nil)
+              }
+            end.compact
+          end
+
+          # Concatenated list of integrations activated, with their gem version.
+          # Example: "rails@6.0.3,rack@2.2.3"
+          #
+          # @return [String, nil]
+          def integrations_loaded
+            integrations = instrumented_integrations
+            return if integrations.empty?
+
+            integrations.map { |name, integration| "#{name}@#{integration.class.version}" }.join(',')
+          end
+
+          # @return [Boolean, nil] partial flushing enabled in configuration
+          def partial_flushing_enabled
+            !!Datadog.configuration.tracing.partial_flush.enabled
+          end
+
+          # @return [Boolean, nil] priority sampling enabled in configuration
+          def priority_sampling_enabled
+            !!Datadog.configuration.tracing.priority_sampling
+          end
+
+          private
+
+          def instrumented_integrations
+            Datadog.configuration.tracing.instrumented_integrations
+          end
+
+          # Capture all active integration settings into "integrationName_settingName: value" entries.
+          def instrumented_integrations_settings
+            instrumented_integrations.flat_map do |name, integration|
+              integration.configuration.to_h.flat_map do |setting, value|
+                next [] if setting == :tracer # Skip internal Ruby objects
+
+                # Convert value to a string to avoid custom #to_json
+                # handlers possibly causing errors.
+                [[:"integration_#{name}_#{setting}", value.to_s]]
+              end
+            end.to_h
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datadog
   module Tracing
     module Diagnostics
@@ -7,25 +9,25 @@ module Datadog
         module Health
           # Metrics
           module Metrics
-            METRIC_API_ERRORS = 'datadog.tracer.api.errors'.freeze
-            METRIC_API_REQUESTS = 'datadog.tracer.api.requests'.freeze
-            METRIC_API_RESPONSES = 'datadog.tracer.api.responses'.freeze
-            METRIC_ERROR_CONTEXT_OVERFLOW = 'datadog.tracer.error.context_overflow'.freeze
-            METRIC_ERROR_INSTRUMENTATION_PATCH = 'datadog.tracer.error.instrumentation_patch'.freeze
-            METRIC_ERROR_SPAN_FINISH = 'datadog.tracer.error.span_finish'.freeze
-            METRIC_ERROR_UNFINISHED_SPANS = 'datadog.tracer.error.unfinished_spans'.freeze
-            METRIC_INSTRUMENTATION_PATCHED = 'datadog.tracer.instrumentation_patched'.freeze
-            METRIC_QUEUE_ACCEPTED = 'datadog.tracer.queue.accepted'.freeze
-            METRIC_QUEUE_ACCEPTED_LENGTHS = 'datadog.tracer.queue.accepted_lengths'.freeze
-            METRIC_QUEUE_DROPPED = 'datadog.tracer.queue.dropped'.freeze
-            METRIC_QUEUE_LENGTH = 'datadog.tracer.queue.length'.freeze
-            METRIC_QUEUE_MAX_LENGTH = 'datadog.tracer.queue.max_length'.freeze
-            METRIC_QUEUE_SPANS = 'datadog.tracer.queue.spans'.freeze
-            METRIC_SAMPLING_SERVICE_CACHE_LENGTH = 'datadog.tracer.sampling.service_cache_length'.freeze
-            METRIC_TRACES_FILTERED = 'datadog.tracer.traces.filtered'.freeze
-            METRIC_TRANSPORT_CHUNKED = 'datadog.tracer.transport.chunked'.freeze
-            METRIC_TRANSPORT_TRACE_TOO_LARGE = 'datadog.tracer.transport.trace_too_large'.freeze
-            METRIC_WRITER_CPU_TIME = 'datadog.tracer.writer.cpu_time'.freeze
+            METRIC_API_ERRORS = 'datadog.tracer.api.errors'
+            METRIC_API_REQUESTS = 'datadog.tracer.api.requests'
+            METRIC_API_RESPONSES = 'datadog.tracer.api.responses'
+            METRIC_ERROR_CONTEXT_OVERFLOW = 'datadog.tracer.error.context_overflow'
+            METRIC_ERROR_INSTRUMENTATION_PATCH = 'datadog.tracer.error.instrumentation_patch'
+            METRIC_ERROR_SPAN_FINISH = 'datadog.tracer.error.span_finish'
+            METRIC_ERROR_UNFINISHED_SPANS = 'datadog.tracer.error.unfinished_spans'
+            METRIC_INSTRUMENTATION_PATCHED = 'datadog.tracer.instrumentation_patched'
+            METRIC_QUEUE_ACCEPTED = 'datadog.tracer.queue.accepted'
+            METRIC_QUEUE_ACCEPTED_LENGTHS = 'datadog.tracer.queue.accepted_lengths'
+            METRIC_QUEUE_DROPPED = 'datadog.tracer.queue.dropped'
+            METRIC_QUEUE_LENGTH = 'datadog.tracer.queue.length'
+            METRIC_QUEUE_MAX_LENGTH = 'datadog.tracer.queue.max_length'
+            METRIC_QUEUE_SPANS = 'datadog.tracer.queue.spans'
+            METRIC_SAMPLING_SERVICE_CACHE_LENGTH = 'datadog.tracer.sampling.service_cache_length'
+            METRIC_TRACES_FILTERED = 'datadog.tracer.traces.filtered'
+            METRIC_TRANSPORT_CHUNKED = 'datadog.tracer.transport.chunked'
+            METRIC_TRANSPORT_TRACE_TOO_LARGE = 'datadog.tracer.transport.trace_too_large'
+            METRIC_WRITER_CPU_TIME = 'datadog.tracer.writer.cpu_time'
           end
         end
       end

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

@@ -30,8 +30,8 @@ module Datadog
           return if digest.nil?
 
           # DEV: We need these to be hex encoded
-          data[@trace_id_key] = digest.trace_id.to_s(16)
-          data[@span_id_key] = digest.span_id.to_s(16)
+          data[@trace_id_key] = format('%032x', digest.trace_id)
+          data[@span_id_key] = format('%016x', digest.span_id)
 
           if digest.trace_sampling_priority
             sampling_priority = Helpers.clamp_sampling_priority(

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

@@ -26,7 +26,7 @@ module Datadog
           return if digest.nil?
 
           # DEV: We need these to be hex encoded
-          value = "#{digest.trace_id.to_s(16)}-#{digest.span_id.to_s(16)}"
+          value = "#{format('%032x', digest.trace_id)}-#{format('%016x', digest.span_id)}"
 
           if digest.trace_sampling_priority
             sampling_priority = Helpers.clamp_sampling_priority(

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

@@ -44,7 +44,15 @@ module Datadog
 
           tracestate, sampling_priority, origin, tags, unknown_fields = extract_tracestate(fetcher[@tracestate_key])
 
-          sampling_priority = parse_priority_sampling(sampled, sampling_priority)
+          sampling_priority = parse_priority_sampling(sampled, sampling_priority) do |decision|
+            case decision
+            when String
+              tags ||= {}
+              tags[Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER] = decision
+            when :drop
+              tags.delete(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER) if tags
+            end
+          end
 
           TraceDigest.new(
             span_id: parent_id,
@@ -160,8 +168,10 @@ module Datadog
             tracestate.chop! # Removes trailing `;` from Datadog trace state string.
 
             if digest.trace_state
+              trace_state = digest.trace_state.strip
+
               # Delete existing `dd=` tracestate fields, if present.
-              vendors = split_tracestate(digest.trace_state)
+              vendors = split_tracestate(trace_state)
               vendors.reject! { |v| v.start_with?('dd=') }
             end
 
@@ -179,13 +189,21 @@ module Datadog
         end
 
         # If any characters in <origin_value> are invalid, replace each invalid character with 0x5F (underscore).
-        # Invalid characters are: characters outside the ASCII range 0x20 to 0x7E, 0x2C (comma), and 0x3D (equals).
+        # Invalid characters are: characters outside the ASCII range 0x20 to 0x7E,
+        # 0x2C (comma), 0x3B (semi-colon), and 0x7E (tilde).
+        # Then, remap 0x3D (equals) to 0x7E (tilde)
         def serialize_origin(value)
           # DEV: It's unlikely that characters will be out of range, as they mostly
           # DEV: come from Datadog-controlled sources.
           # DEV: Trying to `match?` is measurably faster than a `gsub` that does not match.
-          if INVALID_ORIGIN_CHARS.match?(value)
-            value.gsub(INVALID_ORIGIN_CHARS, '_')
+          value = if INVALID_ORIGIN_CHARS.match?(value)
+                    value.gsub(INVALID_ORIGIN_CHARS, '_')
+                  else
+                    value
+                  end
+
+          if REMAP_ORIGIN_CHARS.match?(value)
+            value.gsub(REMAP_ORIGIN_CHARS, '~')
           else
             value
           end
@@ -245,13 +263,15 @@ module Datadog
 
           version, trace_id, parent_id, trace_flags, extra = traceparent.strip.split('-')
 
+          return if version.size != 2 || version[0] < '0' || version[0] > 'f' || version[1] < '0' || version[1] > 'f'
+
           return if version == INVALID_VERSION
 
           # Extra fields are not allowed in version 00, but we have to be lenient for future versions.
           return if version == SPEC_VERSION && extra
 
           # Invalid field sizes
-          return if version.size != 2 || trace_id.size != 32 || parent_id.size != 16 || trace_flags.size != 2
+          return if trace_id.size != 32 || parent_id.size != 16 || trace_flags.size != 2
 
           [Integer(trace_id, 16), Integer(parent_id, 16), Integer(trace_flags, 16)]
         rescue ArgumentError # Conversion to integer failed
@@ -324,20 +344,31 @@ module Datadog
 
         # If `sampled` and `sampling_priority` disagree, `sampled` overrides the decision.
         # @return [Integer] one of the {Datadog::Tracing::Sampling::Ext::Priority} values
+        # @yieldparam the new decision maker (either :drop or a new decision maker String value).
         def parse_priority_sampling(sampled, sampling_priority)
-          # If both fields agree
-          if sampling_priority &&
-              (!Tracing::Sampling::PrioritySampler.sampled?(sampling_priority) && sampled == 0 || # Both drop
-                Tracing::Sampling::PrioritySampler.sampled?(sampling_priority) && sampled == 1) # Both keep
-
-            return sampling_priority # Return the richer `sampling_priority`
+          if sampled == 1
+            if sampling_priority && Tracing::Sampling::PrioritySampler.sampled?(sampling_priority)
+              # Both sampling fields agree.
+              sampling_priority
+            else
+              # Sampling fields disagree.
+              # Let's force the trace to be kept, while also updating the decision maker to ourselves.
+              yield Tracing::Sampling::Ext::Decision::DEFAULT
+              sampled
+            end
+          elsif sampling_priority && !Tracing::Sampling::PrioritySampler.sampled?(sampling_priority)
+            sampling_priority
+          # Both sampling fields agree.
+          else
+            # Sampling fields disagree.
+            # Let's drop the trace and remove the sampling decision tag, as dropped spans don't carry sampling decision.
+            yield :drop
+            sampled
           end
-
-          sampled # Sampled flag trumps `sampling_priority` on conflict
         end
 
         def split_tracestate(tracestate)
-          tracestate.split(/[ \t]*,[ \t]*/)[0..31]
+          tracestate.split(/[ \t]*+,[ \t]*+/)[0..31]
         end
 
         # Version 0xFF is invalid as per spec
@@ -361,10 +392,14 @@ module Datadog
         private_constant :TRACESTATE_VALUE_SIZE_LIMIT
 
         # Replace all characters with `_`, except ASCII characters 0x20-0x7E.
-        # Additionally, `,`, ';', and `=` must also be replaced by `_`.
-        INVALID_ORIGIN_CHARS = /[\u0000-\u0019,;=\u007F-\u{10FFFF}]/.freeze
+        # Additionally, `,`, ';', and `~` must also be replaced by `_`.
+        INVALID_ORIGIN_CHARS = /[\u0000-\u0019,;~\u007F-\u{10FFFF}]/.freeze
         private_constant :INVALID_ORIGIN_CHARS
 
+        # Additionally, remap `=` to `~`
+        REMAP_ORIGIN_CHARS = /=/.freeze
+        private_constant :REMAP_ORIGIN_CHARS
+
         # Replace all characters with `_`, except ASCII characters 0x21-0x7E.
         # Additionally, `,` and `=` must also be replaced by `_`.
         INVALID_TAG_KEY_CHARS = /[\u0000-\u0020,=\u007F-\u{10FFFF}]/.freeze

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

@@ -23,6 +23,10 @@ module Datadog
         # Set this tag to `1.0` if the span is a Service Entry span.
         TAG_TOP_LEVEL = '_dd.top_level'
 
+        # Set to `1.0` if profiling is enabled together with tracing, and `0.0` otherwise
+        # See Datadog-internal "RFC: Identifying which spans have profiling enabled " for details
+        TAG_PROFILING_ENABLED = '_dd.profiling.enabled'
+
         # Defines constants for trace analytics
         # @public_api
         module Analytics
@@ -90,7 +94,10 @@ module Datadog
             INVALID_TAG_CHARACTERS = %r{[^a-z0-9_\-:./]}.freeze
 
             # Normalizes an HTTP header string into a valid tag string.
-            def to_tag(name)
+            #
+            # By default, tags cannot create nested span tag levels:
+            # `allow_nested` allows you to override this behavior.
+            def to_tag(name, allow_nested: false)
               # Tag normalization based on: https://docs.datadoghq.com/getting_started/tagging/#defining-tags.
               #
               # Only the following characters are accepted.
@@ -109,7 +116,7 @@ module Datadog
               # Additional HTTP header normalization.
               #
               # Periods are replaced with an underscore.
-              tag.tr!('.', '_')
+              tag.tr!('.', '_') unless allow_nested
               tag
             end
           end
@@ -178,10 +185,6 @@ module Datadog
         end
 
         # @public_api
-        module SpanAttributeSchema
-          # current span attribute schema version
-          TAG_SCHEMA_VERSION = '_dd.trace_span_attribute_schema'
-        end
       end
     end
   end

data/lib/datadog/tracing/remote.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative '../core/remote/dispatcher'
+require_relative 'configuration/dynamic'
+
+module Datadog
+  module Tracing
+    # Remote configuration declaration
+    module Remote
+      class ReadError < StandardError; end
+
+      class << self
+        PRODUCT = 'APM_TRACING'
+
+        def products
+          [PRODUCT]
+        end
+
+        def capabilities
+          [] # No capabilities advertised
+        end
+
+        def process_config(config, content)
+          lib_config = config['lib_config']
+
+          env_vars = Datadog::Tracing::Configuration::Dynamic::OPTIONS.map do |name, env_var, option|
+            value = lib_config[name]
+
+            # Guard for RBS/Steep
+            raise "option is a #{option.class}, expected Option" unless option.is_a?(Configuration::Dynamic::Option)
+
+            option.call(value)
+
+            [env_var, value]
+          end
+
+          content.applied
+
+          Datadog.send(:components).telemetry.client_configuration_change!(env_vars)
+        rescue => e
+          content.errored("#{e.class.name} #{e.message}: #{Array(e.backtrace).join("\n")}")
+        end
+
+        def receivers
+          receiver do |repository, _changes|
+            # DEV: Filter our by product. Given it will be very common
+            # DEV: we can filter this out before we receive the data in this method.
+            # DEV: Apply this refactor to AppSec as well if implemented.
+            repository.contents.map do |content|
+              case content.path.product
+              when PRODUCT
+                config = parse_content(content)
+                process_config(config, content)
+              end
+            end
+          end
+        end
+
+        def receiver(products = [PRODUCT], &block)
+          matcher = Core::Remote::Dispatcher::Matcher::Product.new(products)
+          [Core::Remote::Dispatcher::Receiver.new(matcher, &block)]
+        end
+
+        private
+
+        def parse_content(content)
+          data = content.data.read
+
+          content.data.rewind
+
+          raise ReadError, 'EOF reached' if data.nil?
+
+          JSON.parse(data)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/sampling/rule_sampler.rb

@@ -48,6 +48,35 @@ module Datadog
                              end
         end
 
+        def self.parse(rules, rate_limit, default_sample_rate)
+          parsed_rules = JSON.parse(rules).map do |rule|
+            sample_rate = rule['sample_rate']
+
+            begin
+              sample_rate = Float(sample_rate)
+            rescue
+              raise "Rule '#{rule.inspect}' does not contain a float property `sample_rate`"
+            end
+
+            kwargs = {
+              name: rule['name'],
+              service: rule['service'],
+              sample_rate: sample_rate,
+            }
+
+            Core::BackportFrom24.hash_compact!(kwargs)
+
+            SimpleRule.new(**kwargs)
+          end
+
+          new(parsed_rules, rate_limit: rate_limit, default_sample_rate: default_sample_rate)
+        rescue => e
+          Datadog.logger.error do
+            "Could not parse trace sampling rules '#{rules}': #{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
+          end
+          nil
+        end
+
         # /RuleSampler's components (it's rate limiter, for example) are
         # not be guaranteed to be size-effect free.
         # It is not possible to guarantee that a call to {#sample?} will

data/lib/datadog/tracing/span_operation.rb

@@ -3,6 +3,7 @@ require 'time'
 require_relative '../core/environment/identity'
 require_relative '../core/utils'
 require_relative '../core/utils/time'
+require_relative '../core/utils/safe_dup'
 
 require_relative 'event'
 require_relative 'metadata'
@@ -434,19 +435,6 @@ module Datadog
         :parent,
         :span
 
-      if RUBY_VERSION < '2.2' # nil.dup only fails in Ruby 2.1
-        # Ensures #initialize can call nil.dup safely
-        module RefineNil
-          refine NilClass do
-            def dup
-              self
-            end
-          end
-        end
-
-        using RefineNil
-      end
-
       # Create a Span from the operation which represents
       # the finalized measurement. We #dup here to prevent
       # mutation by reference; when this span is returned,
@@ -457,8 +445,8 @@ module Datadog
           duration: duration,
           end_time: @end_time,
           id: @id,
-          meta: meta.dup,
-          metrics: metrics.dup,
+          meta: Core::Utils::SafeDup.frozen_or_dup(meta),
+          metrics: Core::Utils::SafeDup.frozen_or_dup(metrics),
           parent_id: @parent_id,
           resource: @resource,
           service: @service,