datadog 2.45.0 → 2.47.0

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

@@ -4,6 +4,7 @@ require "json"
 require_relative "trace_formatter"
 require_relative "statistics"
 require_relative "span_events_negotiation"
+require_relative "native/telemetry"
 
 module Datadog
   module Tracing
@@ -49,6 +50,16 @@ module Datadog
 
           attr_reader :logger, :url
 
+          def telemetry=(client)
+            @send_mutex.synchronize do
+              if (reporter = @telemetry)
+                reporter.client = client
+              elsif @exporter
+                @telemetry = Telemetry.new(client)
+              end
+            end
+          end
+
           # @param agent_settings [Datadog::Core::Configuration::AgentSettingsResolver::AgentSettings]
           #   Agent connection settings, including the request timeout.
           # @param logger [Logger]
@@ -58,6 +69,7 @@ module Datadog
             end
 
             @logger = logger
+            @telemetry = nil
 
             # Serializes native sends and is held across a fork. See the
             # fork-safety note below.
@@ -226,6 +238,7 @@ module Datadog
                   @exporter&._native_close
                 ensure
                   @fork_hooks = nil
+                  @telemetry = nil
                   @exporter = nil
                   hooks.each do |stage, block|
                     Core::Utils::AtForkMonkeyPatch.remove_at_fork(stage, block)
@@ -285,7 +298,9 @@ module Datadog
               exporter = @exporter
               raise "Native transport has been closed" if exporter.nil?
 
-              exporter._native_send_traces(chunks, native_events_supported)
+              exporter._native_send_traces(chunks, native_events_supported) do |observations|
+                @telemetry&.record(observations)
+              end
             end
 
             # Update statistics from the response

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Transport
+      class Telemetry
+        # Observation schema: Symbol keys with non-negative Integer values.
+        # COUNTS maps per-send count deltas to [metric name, additional tags].
+        # :bytes_sent is one successful payload's byte-size distribution sample;
+        # record each payload separately rather than summing its samples.
+        # :responses_count requires :status_code; omit both when the code is unknown.
+        # Missing and zero measurements emit nothing. All metrics use namespace
+        # "tracers" and common: true; trace_* metrics gain src_library:<source>, while
+        # span metrics keep their source-free tags.
+        COUNTS = {
+          requests_count: ["trace_api.requests", []],
+          errors_network: ["trace_api.errors", ["type:network"]],
+          errors_timeout: ["trace_api.errors", ["type:timeout"]],
+          errors_status_code: ["trace_api.errors", ["type:status_code"]],
+          chunks_sent: ["trace_chunks_sent", []],
+          chunks_dropped_serialization_error: ["trace_chunks_dropped", ["reason:serialization_error"]],
+          chunks_dropped_send_failure: ["trace_chunks_dropped", ["reason:send_failure"]],
+          chunks_dropped_payload_too_large: ["trace_chunks_dropped", ["reason:payload_too_large"]],
+          spans_enqueued_for_serialization: ["spans_enqueued_for_serialization", []],
+          spans_dropped_serialization_error: ["spans_dropped", ["reason:serialization_error"]],
+          spans_dropped_api_error: ["spans_dropped", ["reason:api_error"]],
+          spans_dropped_payload_too_large: ["spans_dropped", ["reason:payload_too_large"]],
+        }.freeze #: Hash[Symbol, [String, Array[String]]]
+
+        attr_writer :client
+
+        def initialize(client, source:)
+          @client = client
+          @source_tags = ["src_library:#{source}"]
+          @counts = COUNTS.map do |key, (name, tags)|
+            [key, name, name.start_with?("trace_") ? @source_tags + tags : tags]
+          end
+        end
+
+        def record(observations)
+          client = @client
+          return unless client.enabled?
+
+          @counts.each do |key, name, tags|
+            value = observations.fetch(key, 0)
+            client.inc("tracers", name, value, tags: tags) if value > 0
+          end
+          bytes = observations.fetch(:bytes_sent, 0)
+          client.distribution("tracers", "trace_api.bytes", bytes, tags: @source_tags) if bytes > 0
+          responses = observations.fetch(:responses_count, 0)
+          if responses > 0
+            client.inc("tracers", "trace_api.responses", responses,
+              tags: @source_tags + ["status_code:#{observations.fetch(:status_code)}"],)
+          end
+          nil
+        rescue
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -6,6 +6,7 @@ require_relative "../../core/transport/request"
 require_relative "../../core/transport/transport"
 require_relative "../../core/utils/enumerable_compat"
 require_relative "http/client"
+require_relative "http/telemetry"
 require_relative "serializable_trace"
 require_relative "span_events_negotiation"
 require_relative "trace_formatter"
@@ -26,6 +27,30 @@ module Datadog
 
         # Traces request
         class Request < Datadog::Core::Transport::Request
+          attr_reader :http_status, :http_success
+          attr_writer :capture_telemetry
+
+          def initialize(parcel = nil)
+            super
+            @http_status = nil
+            @http_success = nil
+            @capture_telemetry = false
+          end
+
+          # Built-in adapters return integer codes. Custom status inspection is
+          # best-effort: telemetry must not change trace delivery.
+          def capture_status(response)
+            return unless @capture_telemetry
+
+            if response.respond_to?(:code)
+              code = response.code
+              @http_status = code if code.is_a?(Integer) && code.between?(100, 999)
+            end
+            @http_success = response.ok? if @http_status.nil? && response.respond_to?(:ok?)
+            nil
+          rescue
+            nil
+          end
         end
 
         # Traces response
@@ -48,44 +73,65 @@ module Datadog
           #
           # @param encoder [Datadog::Core::Encoding::Encoder]
           # @param logger [Datadog::Core::Logger]
-          # @param max_size [String] maximum acceptable payload size
-          def initialize(encoder, logger:, native_events_supported:, max_size: DEFAULT_MAX_PAYLOAD_SIZE)
+          # @param native_events_supported [Boolean] whether to encode native span events
+          # @param max_size [Integer] maximum acceptable payload size in bytes
+          # @param telemetry [HTTP::Telemetry::Batch, nil] optional per-send accounting batch
+          def initialize(encoder, logger:, native_events_supported:, max_size: DEFAULT_MAX_PAYLOAD_SIZE, telemetry: nil)
             @encoder = encoder
             @logger = logger
             @native_events_supported = native_events_supported
             @max_size = max_size
+            @batch = telemetry
           end
 
           # Encodes a list of traces in chunks.
           # Before serializing, all traces are normalized. Trace nesting is not changed.
           #
           # @param traces [Enumerable<Trace>] list of traces
-          # @return [Enumerable[Array[Bytes,Integer]]] list of encoded chunks: each containing a byte array and
-          #   number of traces
+          # @return [Enumerable<Array>] tuples of encoded bytes and trace count,
+          #   plus span count when telemetry accounting is enabled
           def encode_in_chunks(traces)
+            span_counts = [] if @batch
             encoded_traces = Core::Utils::EnumerableCompat.filter_map(traces) do |trace|
-              encode_one(trace)
+              encoded = encode_one(trace)
+              span_counts << trace.length if encoded && span_counts
+              encoded
             end
 
             Datadog::Core::Chunker.chunk_by_size(encoded_traces, max_size).map do |chunk|
-              [encoder.join(chunk), chunk.size]
+              payload = [join(chunk), chunk.size]
+              payload << span_counts.shift(chunk.size).sum if span_counts
+              payload
             end
           end
 
           private
 
+          def join(chunk)
+            encoder.join(chunk)
+          rescue
+            @batch&.serialization_failed
+            raise
+          end
+
           def encode_one(trace)
-            encoded = Encoder.encode_trace(
-              encoder,
-              trace,
-              logger: logger,
-              native_events_supported: @native_events_supported
-            )
+            encoded = begin
+              Encoder.encode_trace(
+                encoder,
+                trace,
+                logger: logger,
+                native_events_supported: @native_events_supported
+              )
+            rescue
+              @batch&.serialization_failed
+              raise
+            end
 
             if encoded.size > max_size
               # This single trace is too large, we can't flush it
               logger.debug { "Dropping trace. Payload too large: '#{trace.inspect}'" }
               Datadog.health_metrics.transport_trace_too_large(1)
+              @batch&.record_oversized_drop(trace.length)
 
               return nil
             end
@@ -122,19 +168,40 @@ module Datadog
           include SpanEventsNegotiation
           self.http_client_class = Tracing::Transport::HTTP::Client
 
+          def initialize(apis, default_api, logger:)
+            super
+            @reporter = nil
+          end
+
+          # Reconfiguration can retain this transport, so rebind its reporter to
+          # the new telemetry client. Each later send creates its own accounting batch.
+          def telemetry=(telemetry_client)
+            if (reporter = @reporter)
+              reporter.client = telemetry_client
+            else
+              @reporter = HTTP::Telemetry.new(telemetry_client)
+            end
+          end
+
           def send_traces(traces)
             encoder = current_api.encoder
+            native_events_supported = native_events_supported?
+            batch = @reporter&.batch(traces)
             chunker = Datadog::Tracing::Transport::Traces::Chunker.new(
               encoder,
               logger: logger,
-              native_events_supported: native_events_supported?
+              native_events_supported: native_events_supported,
+              telemetry: batch,
             )
 
-            responses = chunker.encode_in_chunks(traces.lazy).map do |encoded_traces, trace_count|
+            responses = chunker.encode_in_chunks(traces.lazy).map do |encoded_traces, trace_count, span_count|
               request = Request.new(Parcel.new(encoded_traces, trace_count: trace_count))
+              request.capture_telemetry = true if batch
 
               client.send_request(:traces, request).tap do |response|
-                if downgrade?(response)
+                fallback = downgrade?(response)
+                batch&.sent(request, response, trace_count, span_count, encoded_traces.bytesize, fallback: fallback)
+                if fallback
                   downgrade!
                   return send_traces(traces)
                 end

data/lib/datadog/version.rb

@@ -3,7 +3,7 @@
 module Datadog
   module VERSION
     MAJOR = 2
-    MINOR = 45
+    MINOR = 47
     PATCH = 0
     PRE = nil
     BUILD = nil

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: datadog
 version: !ruby/object:Gem::Version
-  version: 2.45.0
+  version: 2.47.0
 platform: ruby
 authors:
 - Datadog, Inc.
@@ -32,7 +32,7 @@ dependencies:
         version: '3.5'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.5.5
+        version: 3.5.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -42,35 +42,35 @@ dependencies:
         version: '3.5'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.5.5
+        version: 3.5.6
 - !ruby/object:Gem::Dependency
   name: libddwaf
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.30.0.0.0
+        version: 1.30.0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.30.0.0.0
+        version: 1.30.0.1.0
 - !ruby/object:Gem::Dependency
   name: libdatadog
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 45.0.0.1.0
+        version: 46.1.0.1.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 45.0.0.1.0
+        version: 46.1.0.1.1
 - !ruby/object:Gem::Dependency
   name: logger
   requirement: !ruby/object:Gem::Requirement
@@ -342,7 +342,6 @@ files:
 - lib/datadog/appsec/thread_safe_ref.rb
 - lib/datadog/appsec/trace_keeper.rb
 - lib/datadog/appsec/utils.rb
-- lib/datadog/appsec/utils/hash_coercion.rb
 - lib/datadog/appsec/utils/http.rb
 - lib/datadog/appsec/utils/http/body.rb
 - lib/datadog/appsec/utils/http/body_reader.rb
@@ -536,6 +535,7 @@ files:
 - lib/datadog/di/boot.rb
 - lib/datadog/di/capture_expression.rb
 - lib/datadog/di/capture_expression_evaluator.rb
+- lib/datadog/di/capture_expression_evaluator/result.rb
 - lib/datadog/di/capture_limits.rb
 - lib/datadog/di/code_tracker.rb
 - lib/datadog/di/component.rb
@@ -549,8 +549,11 @@ files:
 - lib/datadog/di/el/evaluator.rb
 - lib/datadog/di/el/expression.rb
 - lib/datadog/di/error.rb
+- lib/datadog/di/evaluation_failure.rb
 - lib/datadog/di/extensions.rb
 - lib/datadog/di/fatal_exceptions.rb
+- lib/datadog/di/guardrails_telemetry.rb
+- lib/datadog/di/guardrails_telemetry/reason.rb
 - lib/datadog/di/instrumenter.rb
 - lib/datadog/di/logger.rb
 - lib/datadog/di/preload.rb
@@ -566,6 +569,7 @@ files:
 - lib/datadog/di/redactor.rb
 - lib/datadog/di/remote.rb
 - lib/datadog/di/serializer.rb
+- lib/datadog/di/snapshot_event.rb
 - lib/datadog/di/transport/diagnostics.rb
 - lib/datadog/di/transport/http.rb
 - lib/datadog/di/transport/http/diagnostics.rb
@@ -586,6 +590,7 @@ files:
 - lib/datadog/kit/identity.rb
 - lib/datadog/kit/tracing/method_tracer.rb
 - lib/datadog/open_feature.rb
+- lib/datadog/open_feature/activation.rb
 - lib/datadog/open_feature/agentless/configuration_source.rb
 - lib/datadog/open_feature/agentless/parser.rb
 - lib/datadog/open_feature/agentless/response.rb
@@ -605,6 +610,7 @@ files:
 - lib/datadog/open_feature/ext.rb
 - lib/datadog/open_feature/flag_evaluation/aggregator.rb
 - lib/datadog/open_feature/flag_evaluation/writer.rb
+- lib/datadog/open_feature/hooks/evaluation_telemetry_opt_out_hook.rb
 - lib/datadog/open_feature/hooks/flag_eval_evp_hook.rb
 - lib/datadog/open_feature/hooks/flag_eval_metrics_hook.rb
 - lib/datadog/open_feature/hooks/span_enrichment_hook.rb
@@ -1168,6 +1174,7 @@ files:
 - lib/datadog/tracing/transport/http.rb
 - lib/datadog/tracing/transport/http/client.rb
 - lib/datadog/tracing/transport/http/statistics.rb
+- lib/datadog/tracing/transport/http/telemetry.rb
 - lib/datadog/tracing/transport/http/traces.rb
 - lib/datadog/tracing/transport/io.rb
 - lib/datadog/tracing/transport/io/client.rb
@@ -1175,9 +1182,11 @@ files:
 - lib/datadog/tracing/transport/io/traces.rb
 - lib/datadog/tracing/transport/native.rb
 - lib/datadog/tracing/transport/native/response.rb
+- lib/datadog/tracing/transport/native/telemetry.rb
 - lib/datadog/tracing/transport/serializable_trace.rb
 - lib/datadog/tracing/transport/span_events_negotiation.rb
 - lib/datadog/tracing/transport/statistics.rb
+- lib/datadog/tracing/transport/telemetry.rb
 - lib/datadog/tracing/transport/trace_formatter.rb
 - lib/datadog/tracing/transport/traces.rb
 - lib/datadog/tracing/utils.rb
@@ -1190,8 +1199,8 @@ licenses:
 - Apache-2.0
 metadata:
   allowed_push_host: https://rubygems.org
-  changelog_uri: https://github.com/DataDog/dd-trace-rb/blob/v2.45.0/CHANGELOG.md
-  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v2.45.0
+  changelog_uri: https://github.com/DataDog/dd-trace-rb/blob/v2.47.0/CHANGELOG.md
+  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v2.47.0
 post_install_message: 'JRuby support in the datadog gem is deprecated. Details: https://dtdg.co/jruby-deprecation'
 rdoc_options: []
 require_paths:

data/lib/datadog/appsec/utils/hash_coercion.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module AppSec
-    module Utils
-      # A module for coercing arbitrary objects into hashes.
-      module HashCoercion
-        # A best effort to coerce an object to a hash with methods known to various
-        # frameworks with a fallback to standard library.
-        #
-        # @param object [Object] The object to coerce.
-        # @return [Hash, nil] The coerced `Hash` or `nil` if the object is not coercible.
-        def self.coerce(object)
-          return object.as_json if object.respond_to?(:as_json)
-          return object.to_hash if object.respond_to?(:to_hash)
-          return object.to_h if object.respond_to?(:to_h)
-
-          nil
-        end
-      end
-    end
-  end
-end