datadog 2.46.0 → 2.48.0

data/lib/datadog/tracing/contrib/utils/quantization/http.rb

@@ -20,6 +20,96 @@ module Datadog
 
             module_function
 
+            def client_resource(method, path, enabled:)
+              return method unless enabled && path
+
+              resource = method.dup
+              resource << (+" ").force_encoding(resource.encoding)
+              quantized_path = quantize_path(decode_path(path))
+              resource << quantized_path.force_encoding(resource.encoding)
+            end
+
+            def decode_path(path)
+              decoded = String.new(encoding: Encoding::BINARY)
+              index = 0
+
+              while index < path.bytesize
+                byte = path.getbyte(index)
+                break unless byte
+
+                if byte == 37 && index + 2 < path.bytesize
+                  high_byte = path.getbyte(index + 1)
+                  low_byte = path.getbyte(index + 2)
+                  if high_byte && low_byte
+                    high = decode_hex_byte(high_byte)
+                    low = decode_hex_byte(low_byte)
+                    if high && low
+                      decoded << high * 16 + low
+                      index += 3
+                      next
+                    end
+                  end
+                end
+
+                decoded << byte
+                index += 1
+              end
+
+              decoded.force_encoding(path.encoding)
+            end
+
+            def quantize_path(path)
+              slash = (+"/").force_encoding(path.encoding)
+              normalized = if path.getbyte(0) == 47
+                path
+              else
+                String.new(encoding: path.encoding) << slash << path
+              end
+
+              output = String.new(encoding: path.encoding)
+              index = 1
+              replacements = 0
+
+              while index < normalized.bytesize
+                segment_end = index
+                allowed = 0
+                digits = 0
+                specials = 0
+
+                while segment_end < normalized.bytesize && normalized.getbyte(segment_end) != 47
+                  byte = normalized.getbyte(segment_end)
+                  break unless byte
+
+                  if byte.between?(48, 57)
+                    digits += 1
+                  elsif byte.between?(65, 90) || byte.between?(97, 122) || byte == 45 || byte == 95
+                    allowed += 1
+                  else
+                    specials += 1
+                  end
+                  segment_end += 1
+                end
+
+                output << slash
+                segment = normalized.byteslice(index, segment_end - index) || String.new(encoding: path.encoding)
+                if normalized.getbyte(index) == 118 && allowed == 1 && digits > 0 && specials.zero?
+                  output << segment
+                elsif specials > 0 || digits > 0
+                  output << (+"*").force_encoding(path.encoding)
+                  replacements += 1
+                else
+                  output << segment
+                end
+
+                index = segment_end + 1
+              end
+
+              return normalized.dup if replacements.zero?
+
+              output << slash if normalized.getbyte(normalized.bytesize - 1) == 47
+              output
+            end
+
             def url(url, options = {})
               url!(url, options)
             rescue
@@ -118,6 +208,18 @@ module Datadog
 
             private_class_method :collect_query
 
+            def decode_hex_byte(byte)
+              if byte.between?(48, 57)
+                byte - 48
+              elsif byte.between?(65, 70)
+                byte - 55
+              elsif byte.between?(97, 102)
+                byte - 87
+              end
+            end
+
+            private_class_method :decode_hex_byte
+
             # Scans over the query string and obfuscates sensitive data by
             # replacing matches with an opaque value
             def obfuscate_query(query, options = {})

data/lib/datadog/tracing/contrib/waterdrop/middleware.rb

@@ -14,7 +14,7 @@ module Datadog
 
               if trace_op && Datadog::Tracing::Distributed::PropagationPolicy.enabled?(
                 global_config: configuration,
-                trace: trace_op
+                trace: trace_op,
               )
                 WaterDrop.inject(trace_op.to_digest, message[:headers] ||= {})
               end
@@ -23,7 +23,7 @@ module Datadog
                 Datadog::DataStreams.set_produce_checkpoint(
                   type: "kafka",
                   destination: message[:topic],
-                  auto_instrumentation: true
+                  auto_instrumentation: true,
                 ) do |key, value|
                   message[:headers] ||= {}
                   message[:headers][key] = value

data/lib/datadog/tracing/contrib/waterdrop.rb

@@ -33,7 +33,7 @@ module Datadog
             propagation_style_inject: tracing.propagation_style_inject,
             propagation_style_extract: tracing.propagation_style_extract,
             propagation_behavior_extract: tracing.propagation_behavior_extract,
-            propagation_extract_first: tracing.propagation_extract_first
+            propagation_extract_first: tracing.propagation_extract_first,
           )
         end
       end

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

@@ -25,7 +25,7 @@ module Datadog
           end
         rescue => e
           logger.warn(
-            "Failed to collect tracing environment information: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
+            "Failed to collect tracing environment information: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}",
           )
         end
       end

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

@@ -35,7 +35,7 @@ module Datadog
 
           if digest.trace_sampling_priority
             sampling_priority = Helpers.clamp_sampling_priority(
-              digest.trace_sampling_priority
+              digest.trace_sampling_priority,
             )
             data[@sampled_key] = sampling_priority.to_s
           end

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

@@ -32,7 +32,7 @@ module Datadog
 
           if digest.trace_sampling_priority
             sampling_priority = Helpers.clamp_sampling_priority(
-              digest.trace_sampling_priority
+              digest.trace_sampling_priority,
             )
             value += "-#{sampling_priority}"
           end

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

@@ -44,7 +44,7 @@ module Datadog
               record_telemetry_metric(
                 "context_header.truncated",
                 1,
-                {"header_style" => "baggage", "truncation_reason" => "baggage_item_count_exceeded"}
+                {"header_style" => "baggage", "truncation_reason" => "baggage_item_count_exceeded"},
               )
               baggage_items = baggage_items.first(DD_TRACE_BAGGAGE_MAX_ITEMS)
             end
@@ -61,7 +61,7 @@ module Datadog
                 record_telemetry_metric(
                   "context_header.truncated",
                   1,
-                  {"header_style" => "baggage", "truncation_reason" => "baggage_byte_count_exceeded"}
+                  {"header_style" => "baggage", "truncation_reason" => "baggage_byte_count_exceeded"},
                 )
                 break # stop adding items when size limit is reached
               end
@@ -99,7 +99,7 @@ module Datadog
 
           TraceDigest.new(
             baggage: baggage,
-            trace_distributed_tags: baggage_tags
+            trace_distributed_tags: baggage_tags,
           )
         end
 

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

@@ -137,7 +137,7 @@ module Datadog
         rescue => e
           set_tags_propagation_error(reason: "encoding_error")
           ::Datadog.logger.warn(
-            "Failed to inject x-datadog-tags: #{e.class}: #{e.message} at #{Array(e.backtrace).first}"
+            "Failed to inject x-datadog-tags: #{e.class}: #{e.message} at #{Array(e.backtrace).first}",
           )
           nil
         end
@@ -164,7 +164,7 @@ module Datadog
         rescue => e
           set_tags_propagation_error(reason: "decoding_error")
           ::Datadog.logger.warn(
-            "Failed to extract x-datadog-tags: #{e.class}: #{e.message} at #{Array(e.backtrace).first}"
+            "Failed to extract x-datadog-tags: #{e.class}: #{e.message} at #{Array(e.backtrace).first}",
           )
           nil
         end
@@ -188,7 +188,7 @@ module Datadog
           ::Datadog.logger.warn(
             "Failed to #{scenario} x-datadog-tags: tags are too large for configured limit (bytesize:#{size} >= " \
               "limit:#{max_length}). This limit can be configured " \
-              "through the DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH environment variable."
+              "through the DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH environment variable.",
           )
 
           true

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

@@ -81,11 +81,11 @@ module Datadog
           rescue => e
             result = nil
             ::Datadog.logger.error(
-              "Error injecting distributed trace data. Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
+              "Error injecting distributed trace data. Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}",
             )
             ::Datadog::Core::Telemetry::Logger.report(
               e,
-              description: "Error injecting distributed trace data with #{propagator.class.name}"
+              description: "Error injecting distributed trace data with #{propagator.class.name}",
             )
           end
 
@@ -149,13 +149,13 @@ module Datadog
                 trace_otel_random_value: tracecontext_digest.trace_otel_random_value,
                 trace_otel_threshold: tracecontext_digest.trace_otel_threshold,
                 trace_otel_unknown_fields: tracecontext_digest.trace_otel_unknown_fields,
-                trace_distributed_tags: distributed_tags
+                trace_distributed_tags: distributed_tags,
               )
             end
           rescue => e
             # TODO: Not to report Telemetry logs for now
             ::Datadog.logger.error(
-              "Error extracting distributed trace data. Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
+              "Error extracting distributed trace data. Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}",
             )
           end
           # Handle baggage after all other styles if present
@@ -171,7 +171,7 @@ module Datadog
             attributes: {
               "reason" => "propagation_behavior_extract",
               "context_headers" => extracted_style_name,
-            }
+            },
           )
           baggage_tags = extracted_trace_digest.trace_distributed_tags&.select { |k, _| k.start_with?("baggage.") }
           baggage_tags = nil if baggage_tags&.empty?
@@ -192,7 +192,7 @@ module Datadog
             if digest
               extracted_trace_digest.merge(
                 baggage: digest.baggage,
-                trace_distributed_tags: digest.trace_distributed_tags
+                trace_distributed_tags: digest.trace_distributed_tags,
               )
             else
               extracted_trace_digest
@@ -207,7 +207,7 @@ module Datadog
           dd_propagator = @propagation_style_extract.find { |propagator| propagator.is_a?(Datadog) }
           if tracecontext_tags&.fetch(
             Tracing::Metadata::Ext::Distributed::TAG_DD_PARENT_ID,
-            Tracing::Metadata::Ext::Distributed::DD_PARENT_ID_DEFAULT
+            Tracing::Metadata::Ext::Distributed::DD_PARENT_ID_DEFAULT,
           ) != Tracing::Metadata::Ext::Distributed::DD_PARENT_ID_DEFAULT
             # tracecontext headers contain a p value, ensure this value is sent to backend
             tracecontext_tags[Tracing::Metadata::Ext::Distributed::TAG_DD_PARENT_ID]

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

@@ -87,7 +87,7 @@ module Datadog
           build_traceparent_string(
             digest.trace_id,
             digest.span_id || 0, # Fall back to zero (invalid) if not present
-            build_trace_flags(digest)
+            build_trace_flags(digest),
           )
         end
 

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

@@ -85,7 +85,7 @@ module Datadog
             outbound_random_value = reconcile_random_value(
               random_value_for(trace_id),
               outbound_threshold,
-              !!trace_kept
+              !!trace_kept,
             )
             self.class.new(
               random_value: format_random_value(outbound_random_value),

data/lib/datadog/tracing/otel_thread_context.rb

@@ -26,7 +26,7 @@ module Datadog
           set(
             trace_id: event_trace_op.id,
             span_id: event_span_op.id,
-            local_root_span_id: event_trace_op.send(:root_span).id
+            local_root_span_id: event_trace_op.send(:root_span).id,
           )
         end
 
@@ -75,14 +75,14 @@ module Datadog
           set(
             trace_id: trace_op.id,
             span_id: active_span.id,
-            local_root_span_id: trace_op.send(:root_span).id
+            local_root_span_id: trace_op.send(:root_span).id,
           )
         elsif trace_op.parent_span_id && trace_op.parent_span_id != 0
           # Active distributed trace context, before first local trace is created
           set(
             trace_id: trace_op.id,
             span_id: trace_op.parent_span_id,
-            local_root_span_id: UNKNOWN_LOCAL_ROOT_SPAN_ID
+            local_root_span_id: UNKNOWN_LOCAL_ROOT_SPAN_ID,
           )
         else
           clear

data/lib/datadog/tracing/pipeline.rb

@@ -51,7 +51,7 @@ module Datadog
         end
       rescue => e
         Datadog.logger.debug(
-          "trace dropped entirely due to `Pipeline.before_flush` error: #{e.class}: #{e.message}"
+          "trace dropped entirely due to `Pipeline.before_flush` error: #{e.class}: #{e.message}",
         )
 
         nil

data/lib/datadog/tracing/remote.rb

@@ -62,6 +62,8 @@ module Datadog
 
           # @type var parsed: Array[[::Datadog::Core::Remote::Configuration::Content, ::Hash[::String, untyped]]]
           parsed = []
+          # @type var unparseable_contents: Array[Datadog::Core::Remote::Configuration::Content]
+          unparseable_contents = []
           repository.contents.each do |content|
             next unless content.path.product == PRODUCT
 
@@ -76,9 +78,8 @@ module Datadog
               # A present but non-object lib_config (e.g. {"lib_config": []}) is a
               # schema violation the customer can fix. Acknowledging it as applied
               # would tell the backend the config was successfully applied when it
-              # was not, and an empty merge would revert active tracing overrides
-              # to their non-RC values. Reject it per content so the malformed
-              # payload is reported errored instead. A null or absent lib_config
+              # was not. Reject it per content so the malformed payload is
+              # reported errored instead. A null or absent lib_config
               # carries no overrides and is left as a no-op.
               lib_config = config["lib_config"]
               if !lib_config.nil? && !lib_config.is_a?(Hash)
@@ -92,6 +93,7 @@ module Datadog
                 description: "Failed to parse APM_TRACING remote config",
               )
               content.errored("#{e.class}: #{e.message}: #{Array(e.backtrace).join("\n")}")
+              unparseable_contents << content
             end
           end
 
@@ -117,10 +119,26 @@ module Datadog
           # deterministic merge.
           ordered = applicable.sort_by { |content, config| [-config_priority(config), content.path.config_id] }
           merged = merge_lib_configs(ordered.map { |_content, config| config })
+          # The applicable configs carrying a non-null dynamic_instrumentation_enabled
+          # value: any of their paths can still supply the signal after a later
+          # replacement, so the DI component records them all.
+          # @type var enable_signal_paths: Array[Datadog::Core::Remote::Configuration::Path]
+          enable_signal_paths = Core::Utils::EnumerableCompat.filter_map(ordered) do |pair|
+            content, config = pair
+            lib_config = config["lib_config"]
+            if lib_config.is_a?(Hash) && !lib_config["dynamic_instrumentation_enabled"].nil?
+              content.path
+            end
+          end
 
           # Applied even when the set is empty: an emptied repository (last config
           # removed) reverts the tracing overrides to their non-RC values.
-          apply_lib_config(merged, repository)
+          apply_lib_config(
+            merged,
+            repository,
+            unparseable_contents: unparseable_contents,
+            enable_signal_paths: enable_signal_paths,
+          )
 
           parsed.each { |content, _config| content.applied }
           nil
@@ -205,8 +223,10 @@ module Datadog
         #
         # @param lib_config [Hash[String, untyped]] the lib_config to apply
         # @param repository [Core::Remote::Configuration::Repository, nil] forwarded to DI enablement
+        # @param unparseable_contents [Array<Core::Remote::Configuration::Content>] the APM_TRACING contents that failed to parse
+        # @param enable_signal_paths [Array<Core::Remote::Configuration::Path>] the paths of the applicable configs carrying the field
         # @return [nil]
-        def apply_lib_config(lib_config, repository)
+        def apply_lib_config(lib_config, repository, unparseable_contents:, enable_signal_paths:)
           env_vars = Datadog::Tracing::Configuration::Dynamic::OPTIONS.map do |name, env_var, option|
             value = lib_config[name]
 
@@ -218,13 +238,30 @@ module Datadog
             [env_var, telemetry_value]
           end
 
-          if (di_enabled = lib_config["dynamic_instrumentation_enabled"]) != nil # rubocop:disable Style/NonNilCheck
-            # repository is forwarded so that an enable signal can reconcile DI
-            # against probes delivered in an earlier poll while DI was stopped
-            # (see Datadog::DI::Remote.handle_rc_enablement).
+          di_enabled = lib_config["dynamic_instrumentation_enabled"]
+          # allow_initialization: false because this runs on the remote-config worker
+          # thread, and the default would build the component tree from that thread.
+          components = Datadog.send(:components, allow_initialization: false)
+          di_component = components&.dynamic_instrumentation
+          if di_enabled.nil? && di_component&.rc_enablement_signal_withdrawn?(unparseable_contents)
+            di_enabled = false
+          end
+
+          # Records the parsed carrier paths and the previously recorded paths whose
+          # replacements remain unparseable, on every merge including merges that keep
+          # the DI state.
+          if di_component
+            unparseable_recorded_paths = di_component.rc_enablement_signal_paths.select do |path|
+              unparseable_contents.any? { |content| content.path == path }
+            end
+            di_component.record_rc_enablement_signal_paths(enable_signal_paths + unparseable_recorded_paths)
+          end
+
+          unless di_enabled.nil?
+            # repository is forwarded for the stopped->started replay in
+            # Datadog::DI::Remote.handle_rc_enablement.
             Datadog::DI::Remote.handle_rc_enablement(di_enabled, repository)
 
-            components = Datadog.send(:components, allow_initialization: false)
             di_products = Datadog::DI::Remote.products +
               Datadog::SymbolDatabase::Remote.deferred_products(Datadog.configuration)
 
@@ -236,7 +273,7 @@ module Datadog
               # by DD_DYNAMIC_INSTRUMENTATION_ENABLED=false. Advertising then would
               # report DI as in use when it is not and invite probe configs the
               # tracer must refuse; withdraw the products otherwise.
-              if components&.dynamic_instrumentation&.started?
+              if di_component&.started?
                 components&.remote&.add_products(*di_products)
               else
                 components&.remote&.remove_products(*di_products)
@@ -249,13 +286,7 @@ module Datadog
             Datadog.logger.debug { "APM_TRACING RC: merged dynamic_instrumentation_enabled=#{di_enabled}" }
           end
 
-          # allow_initialization: false because this runs on the remote-config
-          # worker thread. If components haven't been built yet (e.g. during a
-          # teardown/reset window), the default value would synchronously build
-          # the entire component tree from this thread. The &. chain matches the
-          # pattern used by DI::Remote.handle_rc_enablement in the same dispatch
-          # path.
-          Datadog.send(:components, allow_initialization: false)&.telemetry&.client_configuration_change!(env_vars)
+          components&.telemetry&.client_configuration_change!(env_vars)
           nil
         end
 
@@ -269,7 +300,7 @@ module Datadog
 
         def receiver(products = [PRODUCT], &block)
           matcher = Core::Remote::Dispatcher::Matcher::Product.new(products)
-          [Core::Remote::Dispatcher::Receiver.new(matcher, &block)]
+          [Core::Remote::Dispatcher::Receiver.new(matcher, initial_reconcile: true, &block)]
         end
 
         private

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

@@ -68,7 +68,7 @@ module Datadog
               # full control over the sampling decision.
               trace.set_tag(
                 Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER,
-                Sampling::Ext::Decision::MANUAL
+                Sampling::Ext::Decision::MANUAL,
               )
             end
           else

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

@@ -34,7 +34,7 @@ module Datadog
           @matcher.match?(trace)
         rescue => e
           Datadog.logger.error(
-            "Matcher failed. Cause: #{e.class}: #{e.message} Source: #{Array(e.backtrace).first}"
+            "Matcher failed. Cause: #{e.class}: #{e.message} Source: #{Array(e.backtrace).first}",
           )
           Datadog::Core::Telemetry::Logger.report(e, description: "Matcher failed")
           nil

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

@@ -133,7 +133,7 @@ module Datadog
           apply_rule!(trace, rule)
         rescue => e
           Datadog.logger.error(
-            "Rule sampling failed. Cause: #{e.class}: #{e.message} Source: #{Array(e.backtrace).first}"
+            "Rule sampling failed. Cause: #{e.class}: #{e.message} Source: #{Array(e.backtrace).first}",
           )
           Datadog::Core::Telemetry::Logger.report(e, description: "Rule sampling failed")
 

data/lib/datadog/tracing/sampling/span/rule_parser.rb

@@ -29,7 +29,7 @@ module Datadog
               rescue => e
                 Datadog.logger.warn(
                   "Error parsing Span Sampling Rules `#{rules.inspect}`: " \
-                  "#{e.class}: #{e.message} at #{Array(e.backtrace).first}"
+                  "#{e.class}: #{e.message} at #{Array(e.backtrace).first}",
                 )
                 return nil
               end
@@ -61,7 +61,7 @@ module Datadog
                 rescue => e
                   Datadog.logger.warn(
                     "Cannot parse Span Sampling Rule #{hash.inspect}: " \
-                    "#{e.class}: #{e.message} at #{Array(e.backtrace).first}"
+                    "#{e.class}: #{e.message} at #{Array(e.backtrace).first}",
                   )
                   return nil
                 end

data/lib/datadog/tracing/span_operation.rb

@@ -535,7 +535,7 @@ module Datadog
           trace_id: @trace_id,
           links: @links,
           events: @span_events,
-          service_entry: parent.nil? || (service && parent.service != service)
+          service_entry: parent.nil? || (service && parent.service != service),
         )
       end
 

data/lib/datadog/tracing/trace_digest.rb

@@ -207,7 +207,7 @@ module Datadog
           trace_otel_threshold: trace_otel_threshold,
           trace_otel_unknown_fields: trace_otel_unknown_fields,
           span_remote: span_remote,
-          baggage: baggage, **field_value_pairs
+          baggage: baggage, **field_value_pairs,
         )
       end
     end

data/lib/datadog/tracing/trace_operation.rb

@@ -266,7 +266,7 @@ module Datadog
           start_time: start_time,
           tags: tags,
           type: type,
-          id: id
+          id: id,
         )
 
         # Start span measurement
@@ -327,7 +327,7 @@ module Datadog
           tags: tags,
           trace_id: trace_id,
           type: type,
-          id: id
+          id: id,
         )
       rescue => e
         logger.debug { "Failed to build new span: #{e.class}: #{e.message}" }
@@ -422,7 +422,7 @@ module Datadog
           trace_otel_threshold: open_telemetry.threshold,
           trace_otel_unknown_fields: open_telemetry.unknown_fields,
           span_remote: @remote_parent && @active_span.nil?,
-          baggage: (@baggage.nil? || @baggage.empty?) ? nil : @baggage
+          baggage: (@baggage.nil? || @baggage.empty?) ? nil : @baggage,
         ).freeze
       end
 
@@ -433,7 +433,7 @@ module Datadog
 
         Correlation::Identifier.new(
           trace_id: @id,
-          span_id: span_id
+          span_id: span_id,
         )
       end
 
@@ -460,7 +460,7 @@ module Datadog
           tags: meta.dup,
           metrics: metrics.dup,
           remote_parent: @remote_parent,
-          distributed_sampling_priority: @distributed_sampling_priority
+          distributed_sampling_priority: @distributed_sampling_priority,
         )
       end
 
@@ -640,7 +640,7 @@ module Datadog
           metrics: metrics,
           root_span_id: (!partial) ? root_span&.id : nil,
           profiling_enabled: @profiling_enabled,
-          apm_tracing_enabled: @apm_tracing_enabled
+          apm_tracing_enabled: @apm_tracing_enabled,
         )
       end
 

data/lib/datadog/tracing/tracer.rb

@@ -59,7 +59,7 @@ module Datadog
         otel_thread_context: nil,
         sampler: Sampling::PrioritySampler.new(
           base_sampler: Sampling::AllSampler.new,
-          post_sampler: Sampling::RuleSampler.new
+          post_sampler: Sampling::RuleSampler.new,
         ),
         span_sampler: Sampling::Span::Sampler.new,
         tags: {},
@@ -80,7 +80,7 @@ module Datadog
         @otel_thread_context = otel_thread_context
 
         @provider = context_provider || DefaultContextProvider.new(
-          otel_thread_context: otel_thread_context
+          otel_thread_context: otel_thread_context,
         )
       end
 
@@ -195,7 +195,7 @@ module Datadog
             tags: tags,
             type: type,
             _trace: trace,
-            id: id
+            id: id,
           )
         end
       end
@@ -406,7 +406,7 @@ module Datadog
             distributed_sampling_priority: !!sampling_priority,
             tracer: self,
             baggage: digest.baggage,
-            auto_finish: auto_finish
+            auto_finish: auto_finish,
           )
         else
           TraceOperation.new(
@@ -416,7 +416,7 @@ module Datadog
             apm_tracing_enabled: apm_tracing_enabled,
             remote_parent: false,
             tracer: self,
-            auto_finish: auto_finish
+            auto_finish: auto_finish,
           )
         end
       end
@@ -516,7 +516,7 @@ module Datadog
             start_time: start_time,
             tags: resolve_tags(tags, service),
             type: type,
-            id: id
+            id: id,
           )
 
           span.start(start_time)

data/lib/datadog/tracing/transport/http/telemetry.rb

@@ -36,7 +36,7 @@ module Datadog
 
             def serialization_failed
               @reporter.record(chunks_dropped_serialization_error: @remaining_chunks,
-                spans_dropped_serialization_error: @remaining_spans,)
+                spans_dropped_serialization_error: @remaining_spans)
             end
 
             def sent(request, response, chunks, spans, bytes, fallback:)