datadog 2.39.0 → 2.47.0

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

@@ -19,8 +19,8 @@ module Datadog
           :first_span,
           :trace
 
-        def self.format!(trace)
-          new(trace).format!
+        def self.format!(trace, transport: nil)
+          new(trace).format!(transport: transport)
         end
 
         def initialize(trace)
@@ -32,7 +32,7 @@ module Datadog
         end
 
         # Modifies a trace so suitable for transport
-        def format!
+        def format!(transport: nil)
           return unless trace
           return trace unless root_span
 
@@ -65,10 +65,13 @@ module Datadog
 
           if first_span
             tag_process_tags!
+            tag_sdk_otlp_export!
             tag_git_repository_url!
             tag_git_commit_sha!
           end
 
+          root_span.set_tag("_dd.tracing.transport", transport) if transport && !partial?
+
           trace
         end
 
@@ -213,7 +216,7 @@ module Datadog
         def tag_apm_tracing_disabled!
           return if trace.apm_tracing_enabled
 
-          root_span.set_tag(Tracing::Metadata::Ext::TAG_APM_ENABLED, 0)
+          trace.spans.each { |span| span.set_metric(Tracing::Metadata::Ext::TAG_APM_ENABLED, 0) }
         end
 
         def tag_git_repository_url!
@@ -237,6 +240,13 @@ module Datadog
           )
         end
 
+        # TODO: Revisit when OTLP trace export support lands. The OTLP path sets
+        # `_dd.sdk.otlp_export: "true"` on the OTLP resource, so this tag must not
+        # also be set to "false" on the first span of a chunk exported over OTLP.
+        def tag_sdk_otlp_export!
+          first_span.set_tag(Tracing::Metadata::Ext::TAG_SDK_OTLP_EXPORT, "false")
+        end
+
         private
 
         def partial?

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

@@ -6,7 +6,9 @@ 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"
 
 module Datadog
@@ -25,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
@@ -47,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
@@ -99,7 +146,7 @@ module Datadog
 
           def encode_trace(encoder, trace, logger:, native_events_supported:)
             # Format the trace for transport
-            TraceFormatter.format!(trace)
+            TraceFormatter.format!(trace, transport: "ruby")
 
             # Make the trace serializable
             serializable_trace = SerializableTrace.new(trace, native_events_supported: native_events_supported)
@@ -118,21 +165,43 @@ module Datadog
         # batches of traces into smaller chunks and handles
         # API version downgrade handshake.
         class Transport < Core::Transport::Transport
+          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
@@ -161,28 +230,6 @@ module Datadog
           def stats
             client.stats
           end
-
-          private
-
-          # Queries the agent for native span events serialization support.
-          # This changes how the serialization of span events performed.
-          def native_events_supported?
-            return @native_events_supported if defined?(@native_events_supported)
-
-            # Check for an explicit override
-            option = Datadog.configuration.tracing.native_span_events
-            unless option.nil?
-              @native_events_supported = option
-              return option
-            end
-
-            # Otherwise, check for agent support, to ensure a configuration-less setup.
-            if (res = Datadog.send(:components).agent_info.fetch)
-              @native_events_supported = res.span_events == true
-            else
-              false
-            end
-          end
         end
       end
     end

data/lib/datadog/tracing/writer.rb

@@ -130,7 +130,7 @@ module Datadog
       def stats
         {
           traces_flushed: @traces_flushed,
-          transport: @transport.stats
+          transport: @transport.stats,
         }
       end
 
@@ -173,10 +173,23 @@ module Datadog
       def stop_worker
         @stopped = true
 
-        return if @worker.nil?
+        if @worker
+          @worker.stop
+          @worker = nil
+        end
 
-        @worker.stop
-        @worker = nil
+        # Stopping a writer is permanent: once `@stopped` is set, `#start`
+        # refuses to spin up a new worker, so this writer (and the transport it
+        # owns) is being discarded for good. Forks do not stop the writer
+        # (`#start` re-creates the worker for the new pid while reusing the same
+        # transport), so this only runs on real teardown/reconfiguration.
+        #
+        # Deterministically release transports that hold native resources
+        # (e.g. the native trace exporter's Rust runtime and process-global
+        # fork hooks) instead of waiting on the GC finalizer. The default HTTP
+        # transport has no `#close` and is left untouched. `#close` is
+        # idempotent, so repeated `#stop` calls are safe.
+        @transport.close if @transport.respond_to?(:close)
 
         true
       end

data/lib/datadog/version.rb

@@ -3,7 +3,7 @@
 module Datadog
   module VERSION
     MAJOR = 2
-    MINOR = 39
+    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.39.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.3
+        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.3
+        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: 36.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: 36.0.0.1.0
+        version: 46.1.0.1.1
 - !ruby/object:Gem::Dependency
   name: logger
   requirement: !ruby/object:Gem::Requirement
@@ -181,12 +181,15 @@ files:
 - ext/libdatadog_api/init.c
 - ext/libdatadog_api/library_config.c
 - ext/libdatadog_api/library_config.h
+- ext/libdatadog_api/otel_thread_context.c
+- ext/libdatadog_api/otel_thread_context.h
 - ext/libdatadog_api/process_discovery.c
 - ext/libdatadog_api/process_discovery.h
+- ext/libdatadog_api/trace_exporter.c
+- ext/libdatadog_api/trace_exporter.h
 - ext/libdatadog_extconf_helpers.rb
 - lib/datadog.rb
 - lib/datadog/ai_guard.rb
-- lib/datadog/ai_guard/api_client.rb
 - lib/datadog/ai_guard/autoload.rb
 - lib/datadog/ai_guard/component.rb
 - lib/datadog/ai_guard/configuration.rb
@@ -200,16 +203,26 @@ files:
 - lib/datadog/ai_guard/contrib/rails/patcher.rb
 - lib/datadog/ai_guard/contrib/ruby_llm/chat_instrumentation.rb
 - lib/datadog/ai_guard/contrib/ruby_llm/integration.rb
+- lib/datadog/ai_guard/contrib/ruby_llm/message_adapter.rb
 - lib/datadog/ai_guard/contrib/ruby_llm/patcher.rb
+- lib/datadog/ai_guard/contrib/ruby_llm/redaction_change_set.rb
 - lib/datadog/ai_guard/evaluation.rb
-- lib/datadog/ai_guard/evaluation/content_builder.rb
+- lib/datadog/ai_guard/evaluation/client.rb
 - lib/datadog/ai_guard/evaluation/content_part.rb
 - lib/datadog/ai_guard/evaluation/message.rb
+- lib/datadog/ai_guard/evaluation/message_builder.rb
 - lib/datadog/ai_guard/evaluation/no_op_result.rb
+- lib/datadog/ai_guard/evaluation/outcome.rb
 - lib/datadog/ai_guard/evaluation/request.rb
+- lib/datadog/ai_guard/evaluation/response.rb
 - lib/datadog/ai_guard/evaluation/result.rb
 - lib/datadog/ai_guard/evaluation/tool_call.rb
 - lib/datadog/ai_guard/ext.rb
+- lib/datadog/ai_guard/http_client.rb
+- lib/datadog/ai_guard/metrics/telemetry.rb
+- lib/datadog/ai_guard/redaction.rb
+- lib/datadog/ai_guard/redaction/replacements.rb
+- lib/datadog/ai_guard/redaction/result.rb
 - lib/datadog/appsec.rb
 - lib/datadog/appsec/actions_handler.rb
 - lib/datadog/appsec/actions_handler/serializable_backtrace.rb
@@ -329,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
@@ -430,6 +442,7 @@ files:
 - lib/datadog/core/tag_builder.rb
 - lib/datadog/core/tag_normalizer.rb
 - lib/datadog/core/telemetry/component.rb
+- lib/datadog/core/telemetry/configuration_value.rb
 - lib/datadog/core/telemetry/emitter.rb
 - lib/datadog/core/telemetry/event.rb
 - lib/datadog/core/telemetry/event/app_client_configuration_change.rb
@@ -522,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
@@ -535,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
@@ -552,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
@@ -572,8 +590,16 @@ 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
+- lib/datadog/open_feature/agentless/transport.rb
 - lib/datadog/open_feature/component.rb
 - lib/datadog/open_feature/configuration.rb
+- lib/datadog/open_feature/configuration/agentless_endpoint.rb
+- lib/datadog/open_feature/configuration/source.rb
+- lib/datadog/open_feature/configuration/source/resolution.rb
 - lib/datadog/open_feature/evaluation_engine.rb
 - lib/datadog/open_feature/exposures/batch_builder.rb
 - lib/datadog/open_feature/exposures/buffer.rb
@@ -584,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
@@ -1020,6 +1047,7 @@ files:
 - lib/datadog/tracing/contrib/sequel/dataset.rb
 - lib/datadog/tracing/contrib/sequel/ext.rb
 - lib/datadog/tracing/contrib/sequel/integration.rb
+- lib/datadog/tracing/contrib/sequel/jdbc_connection_string.rb
 - lib/datadog/tracing/contrib/sequel/patcher.rb
 - lib/datadog/tracing/contrib/sequel/utils.rb
 - lib/datadog/tracing/contrib/shoryuken/configuration/settings.rb
@@ -1093,13 +1121,16 @@ files:
 - lib/datadog/tracing/distributed/b3_single.rb
 - lib/datadog/tracing/distributed/baggage.rb
 - lib/datadog/tracing/distributed/datadog.rb
-- lib/datadog/tracing/distributed/datadog_tags_codec.rb
 - lib/datadog/tracing/distributed/fetcher.rb
 - lib/datadog/tracing/distributed/helpers.rb
 - lib/datadog/tracing/distributed/none.rb
 - lib/datadog/tracing/distributed/propagation.rb
 - lib/datadog/tracing/distributed/propagation_policy.rb
 - lib/datadog/tracing/distributed/trace_context.rb
+- lib/datadog/tracing/distributed/trace_state.rb
+- lib/datadog/tracing/distributed/trace_state/datadog.rb
+- lib/datadog/tracing/distributed/trace_state/ext.rb
+- lib/datadog/tracing/distributed/trace_state/open_telemetry.rb
 - lib/datadog/tracing/event.rb
 - lib/datadog/tracing/ext.rb
 - lib/datadog/tracing/flush.rb
@@ -1110,6 +1141,7 @@ files:
 - lib/datadog/tracing/metadata/metastruct.rb
 - lib/datadog/tracing/metadata/metastruct_tagging.rb
 - lib/datadog/tracing/metadata/tagging.rb
+- lib/datadog/tracing/otel_thread_context.rb
 - lib/datadog/tracing/pipeline.rb
 - lib/datadog/tracing/pipeline/span_filter.rb
 - lib/datadog/tracing/pipeline/span_processor.rb
@@ -1142,13 +1174,19 @@ 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
 - lib/datadog/tracing/transport/io/response.rb
 - 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
@@ -1161,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.39.0/CHANGELOG.md
-  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v2.39.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/ai_guard/evaluation/content_builder.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module AIGuard
-    module Evaluation
-      # Builder for collecting content parts inside a message block.
-      #
-      # Used via the block form of {Datadog::AIGuard.message}:
-      #
-      #   Datadog::AIGuard.message(role: :user) do |m|
-      #     m.text("What's in this image?")
-      #     m.image_url("https://example.com/img.png")
-      #   end
-      class ContentBuilder
-        attr_reader :parts
-
-        def initialize
-          @parts = []
-        end
-
-        def text(text)
-          @parts << ContentPart::Text.new(text)
-        end
-
-        def image_url(url)
-          @parts << ContentPart::ImageURL.new(url)
-        end
-      end
-    end
-  end
-end

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