datadog 2.45.0 → 2.47.0

data/lib/datadog/tracing/context_provider.rb

@@ -21,6 +21,14 @@ module Datadog
       def context=(ctx)
         ctx.otel_thread_context = @otel_thread_context if ctx.respond_to?(:otel_thread_context=)
 
+        if (otel_thread_context = @otel_thread_context)
+          if (trace = ctx&.active_trace)
+            otel_thread_context.update_from_trace_op(trace)
+          else
+            otel_thread_context.clear
+          end
+        end
+
         @context.local = ctx
       end
 

data/lib/datadog/tracing/contrib/ethon/easy_patch.rb

@@ -7,6 +7,7 @@ require_relative "../../metadata/ext"
 require_relative "../http"
 require_relative "ext"
 require_relative "../http_annotation_helper"
+require_relative "../utils/quantization/http"
 
 module Datadog
   module Tracing
@@ -111,7 +112,7 @@ module Datadog
               )
               datadog_trace = Tracing.active_trace
 
-              datadog_tag_request
+              datadog_tag_request(uri)
 
               if Tracing::Distributed::PropagationPolicy.enabled?(
                 global_config: datadog_configuration,
@@ -131,12 +132,17 @@ module Datadog
 
             attr_reader :datadog_configuration
 
-            def datadog_tag_request
+            def datadog_tag_request(uri)
               span = @datadog_span
               span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
               method = Ext::NOT_APPLICABLE_METHOD
               method = @datadog_method.to_s if instance_variable_defined?(:@datadog_method) && !@datadog_method.nil?
-              span.resource = method
+              path = uri&.path
+              span.resource = Contrib::Utils::Quantization::HTTP.client_resource(
+                method,
+                path,
+                enabled: Datadog.configuration.tracing.http_client_resource_name_quantize
+              )
 
               if datadog_configuration[:peer_service]
                 span.set_tag(
@@ -153,10 +159,9 @@ module Datadog
 
               span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
 
-              uri = try_parse_uri
               return unless uri
 
-              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, uri.path)
+              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, path)
               span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, method)
               span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, uri.host)
               span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, uri.port)

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

@@ -8,6 +8,7 @@ require_relative "../http"
 require_relative "../analytics"
 require_relative "ext"
 require_relative "../http_annotation_helper"
+require_relative "../utils/quantization/http"
 
 module Datadog
   module Tracing
@@ -117,7 +118,13 @@ module Datadog
           end
 
           def annotate!(span, datum)
-            span.resource = datum[:method].to_s.upcase
+            http_method = datum[:method].to_s.upcase
+            path = datum[:path]
+            span.resource = Contrib::Utils::Quantization::HTTP.client_resource(
+              http_method,
+              path,
+              enabled: Datadog.configuration.tracing.http_client_resource_name_quantize
+            )
             span.service = service_name(datum[:host], @options)
             span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
             span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
@@ -139,8 +146,8 @@ module Datadog
             # Set analytics sample rate
             Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
 
-            span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, datum[:path])
-            span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, datum[:method].to_s.upcase)
+            span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, path)
+            span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, http_method)
             span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, datum[:host])
             span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, datum[:port])
             span.set_tags(

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

@@ -7,6 +7,7 @@ require_relative "../http"
 require_relative "../analytics"
 require_relative "ext"
 require_relative "../http_annotation_helper"
+require_relative "../utils/quantization/http"
 require_relative "../../../core/telemetry/logger"
 
 module Datadog
@@ -45,7 +46,8 @@ module Datadog
 
           # rubocop:disable Metrics/AbcSize
           def annotate!(span, env, options)
-            span.resource = resource_name(env)
+            path = env[:url].path
+            span.resource = resource_name(env, path)
             span.service = service_name(env[:url].host, options)
             span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
             span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
@@ -69,7 +71,7 @@ module Datadog
               Contrib::Analytics.set_sample_rate(span, options[:analytics_sample_rate])
             end
 
-            span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, env[:url].path)
+            span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, path)
             span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, env[:method].to_s.upcase)
             span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, env[:url].host)
             span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, env[:url].port)
@@ -103,8 +105,12 @@ module Datadog
             Contrib::HTTP.inject(trace, env[:request_headers])
           end
 
-          def resource_name(env)
-            env[:method].to_s.upcase
+          def resource_name(env, path)
+            Contrib::Utils::Quantization::HTTP.client_resource(
+              env[:method].to_s.upcase,
+              path,
+              enabled: Datadog.configuration.tracing.http_client_resource_name_quantize
+            )
           end
 
           def build_request_options!(env)

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

@@ -34,7 +34,12 @@ module Datadog
                 span.service = service_name(host, request_options, client_config)
                 span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
                 span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
-                span.resource = req.method
+                quantize_resource = Datadog.configuration.tracing.http_client_resource_name_quantize
+                span.resource = Contrib::Utils::Quantization::HTTP.client_resource(
+                  req.method,
+                  quantize_resource ? request_uri_path(req) : nil,
+                  enabled: quantize_resource
+                )
 
                 if Tracing::Distributed::PropagationPolicy.enabled?(
                   pin_config: client_config,
@@ -116,6 +121,16 @@ module Datadog
 
             private
 
+            def request_uri_path(request)
+              uri = request.uri if request.respond_to?(:uri)
+              return uri.path if uri
+              return request.path.split(/[?#]/, 2).first if request.path.start_with?("/")
+
+              URI.parse(request.path).path
+            rescue URI::InvalidURIError
+              nil
+            end
+
             def host_and_port(request)
               if request.respond_to?(:uri) && request.uri
                 [request.uri.host, request.uri.port]

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

@@ -4,6 +4,7 @@ require_relative "../../metadata/ext"
 require_relative "../http"
 require_relative "../analytics"
 require_relative "../http_annotation_helper"
+require_relative "../utils/quantization/http"
 require_relative "../../../core/telemetry/logger"
 
 module Datadog
@@ -74,10 +75,15 @@ module Datadog
 
               http_method = req.header.request_method.upcase
               uri = req.header.request_uri
+              path = uri.path
 
-              span.resource = http_method
+              span.resource = Contrib::Utils::Quantization::HTTP.client_resource(
+                http_method,
+                path,
+                enabled: Datadog.configuration.tracing.http_client_resource_name_quantize
+              )
               span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, http_method)
-              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, uri.path)
+              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, path)
               span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, uri.host)
               span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, uri.port)
 

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

@@ -4,6 +4,7 @@ require_relative "../../metadata/ext"
 require_relative "../http"
 require_relative "../analytics"
 require_relative "../http_annotation_helper"
+require_relative "../utils/quantization/http"
 require_relative "../../../core/telemetry/logger"
 
 module Datadog
@@ -70,17 +71,22 @@ module Datadog
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_REQUEST)
 
+              uri = req.uri
+              path = uri&.path
               if req.verb&.is_a?(String) || req.verb.is_a?(Symbol)
                 http_method = req.verb.to_s.upcase
-                span.resource = http_method
+                span.resource = Contrib::Utils::Quantization::HTTP.client_resource(
+                  http_method,
+                  path,
+                  enabled: Datadog.configuration.tracing.http_client_resource_name_quantize
+                )
                 span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, http_method)
               else
                 logger.debug("service #{req_options[:service_name]} span #{Ext::SPAN_REQUEST} missing request verb")
               end
 
-              if req.uri
-                uri = req.uri
-                span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, uri.path)
+              if uri
+                span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, path)
                 span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, uri.host)
                 span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, uri.port)
 

data/lib/datadog/tracing/contrib/rest_client/request_patch.rb

@@ -6,6 +6,7 @@ require_relative "../../metadata/ext"
 require_relative "../http"
 require_relative "../analytics"
 require_relative "ext"
+require_relative "../utils/quantization/http"
 
 module Datadog
   module Tracing
@@ -38,7 +39,13 @@ module Datadog
 
             def datadog_tag_request(uri, span)
               span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
-              span.resource = method.to_s.upcase
+              http_method = method.to_s.upcase
+              path = uri.path
+              span.resource = Contrib::Utils::Quantization::HTTP.client_resource(
+                http_method,
+                path,
+                enabled: Datadog.configuration.tracing.http_client_resource_name_quantize
+              )
 
               if datadog_configuration[:peer_service]
                 span.set_tag(
@@ -57,8 +64,8 @@ module Datadog
               # Set analytics sample rate
               Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
 
-              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, uri.path)
-              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, method.to_s.upcase)
+              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, path)
+              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, http_method)
               span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, uri.host)
               span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, uri.port)
               span.set_tags(

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/otel_thread_context.rb

@@ -14,9 +14,11 @@ module Datadog
 
       def self.build(tracing_settings)
         return unless tracing_settings.otel_thread_context_enabled
+        return unless Datadog::Core::LIBDATADOG_API_FAILURE.nil?
 
         instance = new
-        instance if instance.supported? && instance._native_enable
+        instance._native_enable
+        instance
       end
 
       def initialize
@@ -65,10 +67,6 @@ module Datadog
         false
       end
 
-      def supported?
-        Datadog::Core::LIBDATADOG_API_FAILURE.nil? && _native_supported?
-      end
-
       def update_from_trace_op(trace_op)
         active_span = trace_op.active_span
 

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/transport/http/telemetry.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "net/http"
+require_relative "../telemetry"
+
+module Datadog
+  module Tracing
+    module Transport
+      module HTTP
+        class Telemetry < Datadog::Tracing::Transport::Telemetry
+          def initialize(client)
+            super(client, source: "ruby")
+          end
+
+          def batch(traces)
+            return unless @client.enabled? && @client.metrics_manager.enabled
+
+            Batch.new(self, traces)
+          rescue
+            nil
+          end
+
+          class Batch
+            def initialize(reporter, traces)
+              @reporter = reporter
+              @remaining_chunks = traces.length
+              @remaining_spans = traces.sum(&:length)
+              @reporter.record(spans_enqueued_for_serialization: @remaining_spans)
+            end
+
+            def record_oversized_drop(span_count)
+              @remaining_chunks -= 1
+              @remaining_spans -= span_count
+              @reporter.record(chunks_dropped_payload_too_large: 1, spans_dropped_payload_too_large: span_count)
+            end
+
+            def serialization_failed
+              @reporter.record(chunks_dropped_serialization_error: @remaining_chunks,
+                spans_dropped_serialization_error: @remaining_spans,)
+            end
+
+            def sent(request, response, chunks, spans, bytes, fallback:)
+              @reporter.record(requests_count: 1)
+              return if fallback
+
+              @remaining_chunks -= chunks
+              @remaining_spans -= spans
+              observations = {} #: Hash[Symbol, Integer]
+              if (status = request.http_status)
+                observations[:responses_count] = 1
+                observations[:status_code] = status
+              end
+              success = status ? status.between?(200, 299) : request.http_success
+              if success
+                observations[:chunks_sent] = chunks
+                observations[:bytes_sent] = bytes
+              elsif status || success == false
+                observations[:errors_status_code] = 1 if status
+                observations[:chunks_dropped_send_failure] = chunks
+                observations[:spans_dropped_api_error] = spans
+              elsif response.is_a?(Core::Transport::InternalErrorResponse)
+                error = response.error
+                if error.is_a?(ArgumentError) || error.is_a?(TypeError)
+                  observations[:chunks_dropped_serialization_error] = chunks
+                  observations[:spans_dropped_serialization_error] = spans
+                else
+                  observations[:chunks_dropped_send_failure] = chunks
+                  observations[:spans_dropped_api_error] = spans
+                  if error.is_a?(::Timeout::Error) || error.is_a?(Errno::ETIMEDOUT)
+                    observations[:errors_timeout] = 1
+                  elsif network_error?(error)
+                    observations[:errors_network] = 1
+                  end
+                end
+              end
+              @reporter.record(observations)
+            rescue
+              nil
+            end
+
+            private
+
+            def network_error?(error)
+              error.is_a?(SystemCallError) || error.is_a?(IOError) || error.is_a?(SocketError) ||
+                error.is_a?(::Net::ProtocolError) || error.is_a?(::Net::HTTPBadResponse) ||
+                error.is_a?(::Net::HTTPHeaderSyntaxError) ||
+                (defined?(::OpenSSL::SSL::SSLError) && error.is_a?(::OpenSSL::SSL::SSLError))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -51,6 +51,8 @@ module Datadog
 
                 # Query for response
                 http_response = super
+                # Delivery succeeded or failed before service-rate parsing can raise.
+                env.request.capture_status(http_response)
 
                 # Process the response
                 response_options = {trace_count: env.request.parcel.trace_count}.tap do |options|

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "../telemetry"
+
+module Datadog
+  module Tracing
+    module Transport
+      module Native
+        class Telemetry < Datadog::Tracing::Transport::Telemetry
+          def initialize(client)
+            super(client, source: "libdatadog")
+          end
+        end
+      end
+    end
+  end
+end