datadog 2.43.0 → 2.44.0

data/ext/datadog_profiling_native_extension/private_vm_api_access.h

@@ -45,6 +45,7 @@ uint64_t native_thread_id_for(VALUE thread);
 void ddtrace_thread_list(VALUE result_array);
 bool is_thread_alive(VALUE thread);
 VALUE thread_name_for(VALUE thread);
+void self_test_thread_name_for(void);
 
 int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, frame_info *stack_buffer);
 

data/ext/datadog_profiling_native_extension/profiling.c

@@ -103,6 +103,7 @@ void DDTRACE_EXPORT Init_datadog_profiling_native_extension(void) {
 }
 
 static VALUE native_working_p(DDTRACE_UNUSED VALUE _self) {
+  self_test_thread_name_for();
   self_test_clock_id();
   self_test_current_fiber_for();
   self_test_mn_enabled();

data/ext/datadog_profiling_native_extension/stack_recorder.c

@@ -539,10 +539,6 @@ static VALUE _native_serialize(DDTRACE_UNUSED VALUE _self, VALUE recorder_instan
   stack_recorder_state *state;
   TypedData_Get_Struct(recorder_instance, stack_recorder_state, &stack_recorder_typed_data, state);
 
-  ddog_Timespec finish_timestamp = system_epoch_now_timespec();
-  // Need to do this while still holding the Global VM Lock; see comments on method for why
-  serializer_set_start_timestamp_for_next_profile(state, finish_timestamp);
-
   if (state->thread_context_collector_instance != Qnil) {
     thread_context_collector_on_serialize(state->thread_context_collector_instance);
   }
@@ -555,6 +551,10 @@ static VALUE _native_serialize(DDTRACE_UNUSED VALUE _self, VALUE recorder_instan
   heap_recorder_prepare_iteration(state->heap_recorder);
   long heap_iteration_prep_time_ns = monotonic_wall_time_now_ns(DO_NOT_RAISE_ON_FAILURE) - heap_iteration_prep_start_time_ns;
 
+  ddog_Timespec finish_timestamp = system_epoch_now_timespec();
+  // Need to do this while still holding the Global VM Lock; see comments on method for why
+  serializer_set_start_timestamp_for_next_profile(state, finish_timestamp);
+
   // We'll release the Global VM Lock while we're calling serialize, so that the Ruby VM can continue to work while this
   // is pending
   call_serialize_without_gvl_arguments args = {

data/ext/datadog_profiling_native_extension/time_helpers.h

@@ -7,9 +7,9 @@
 #include "extconf.h"
 #include "ruby_helpers.h"
 
-#define SECONDS_AS_NS(value) (value * 1000 * 1000 * 1000L)
-#define MILLIS_AS_NS(value) (value * 1000 * 1000L)
-#define MICROS_AS_NS(value) (value * 1000L)
+#define SECONDS_AS_NS(value) ((value) * 1000L * 1000L * 1000L)
+#define MILLIS_AS_NS(value)  ((value) * 1000L * 1000L)
+#define MICROS_AS_NS(value)  ((value) * 1000L)
 
 typedef enum { RAISE_ON_FAILURE, DO_NOT_RAISE_ON_FAILURE } raise_on_failure_setting;
 

data/ext/libdatadog_api/di.c

@@ -2,6 +2,9 @@
 
 #include "datadog_ruby_common.h"
 
+// rb_iseq is CRuby-specific
+#ifndef TRUFFLERUBY
+
 // Prototypes for Ruby functions declared in internal Ruby headers.
 // rb_iseqw_new wraps an internal iseq pointer into a Ruby-visible
 // RubyVM::InstructionSequence object.
@@ -207,7 +210,9 @@ void di_init(VALUE datadog_module) {
   rb_define_singleton_method(di_module, "enter_probe", enter_probe, 0);
   rb_define_singleton_method(di_module, "leave_probe", leave_probe, 0);
   rb_define_singleton_method(di_module, "hash?", is_hash, 1);
-#ifdef HAVE_RB_ISEQ_TYPE
-  rb_define_singleton_method(di_module, "iseq_type", iseq_type, 1);
-#endif
+  #ifdef HAVE_RB_ISEQ_TYPE
+    rb_define_singleton_method(di_module, "iseq_type", iseq_type, 1);
+  #endif
 }
+
+#endif // TRUFFLERUBY

data/ext/libdatadog_api/extconf.rb

@@ -24,7 +24,7 @@ end
 if ENV["DD_NO_EXTENSION"].to_s.strip.downcase == "true"
   skip_building_extension!("the `DD_NO_EXTENSION` environment variable is/was set to `true` during installation")
 end
-skip_building_extension!("current Ruby VM is not supported") if RUBY_ENGINE != "ruby"
+skip_building_extension!("current Ruby VM is not supported") unless %w[ruby truffleruby].include?(RUBY_ENGINE)
 skip_building_extension!("Microsoft Windows is not supported") if Gem.win_platform?
 
 libdatadog_issue = Datadog::LibdatadogExtconfHelpers.load_libdatadog_or_get_issue

data/ext/libdatadog_api/feature_flags.c

@@ -13,6 +13,7 @@
 // Forward declarations
 static VALUE configuration_new(VALUE klass, VALUE json_str);
 static void configuration_free(void *ptr);
+static VALUE configuration_get_observe_full_evaluation_data(VALUE self);
 static VALUE configuration_get_assignment(
   VALUE self, VALUE flag_key, VALUE expected_type, VALUE context);
 
@@ -94,6 +95,7 @@ void feature_flags_init(VALUE core_module) {
   rb_undef_alloc_func(configuration_class);
   rb_define_singleton_method(configuration_class, "new", configuration_new, 1);
   rb_define_method(configuration_class, "get_assignment", configuration_get_assignment, 3);
+  rb_define_method(configuration_class, "observe_full_evaluation_data", configuration_get_observe_full_evaluation_data, 0);
 
   rb_gc_register_address(&resolution_details_class);
   resolution_details_class = rb_define_class_under(feature_flags_module, "ResolutionDetails", rb_cObject);
@@ -137,6 +139,12 @@ static VALUE configuration_new(VALUE klass, VALUE json_str) {
   return TypedData_Wrap_Struct(klass, &configuration_data_type, result.ok);
 }
 
+static VALUE configuration_get_observe_full_evaluation_data(VALUE self) {
+  ddog_ffe_Handle_Configuration configuration =
+    (ddog_ffe_Handle_Configuration)rb_check_typeddata(self, &configuration_data_type);
+  return ddog_ffe_configuration_get_observe_full_evaluation_data(configuration) ? Qtrue : Qfalse;
+}
+
 static void configuration_free(void *ptr) {
   ddog_ffe_Handle_Configuration config = (ddog_ffe_Handle_Configuration)ptr;
   ddog_ffe_configuration_drop(&config);

data/ext/libdatadog_api/init.c

@@ -25,7 +25,9 @@ void DDTRACE_EXPORT Init_libdatadog_api(void) {
   library_config_init(core_module);
   ddsketch_init(core_module);
   feature_flags_init(core_module);
-  di_init(datadog_module);
+  #ifndef TRUFFLERUBY
+    di_init(datadog_module);
+  #endif
 
   VALUE tracing_module = rb_define_module_under(datadog_module, "Tracing");
   trace_exporter_init(tracing_module);

data/ext/libdatadog_api/otel_thread_context.c

@@ -4,7 +4,12 @@
 #include "datadog_ruby_common.h"
 #include "otel_thread_context.h"
 
-#ifdef __linux__
+// Relies on a :fiber_switch TracePoint that TruffleRuby does not support yet
+#if defined(__linux__) && !defined(TRUFFLERUBY)
+  #define OTEL_THREAD_CONTEXT_SUPPORTED
+#endif
+
+#ifdef OTEL_THREAD_CONTEXT_SUPPORTED
   #include <datadog/otel-thread-ctx.h>
   extern __thread const uint8_t *otel_thread_ctx_v1;
 
@@ -32,18 +37,18 @@ static VALUE native_read(VALUE _self);
 void otel_thread_context_init(VALUE tracing_module) {
   fiber_context_slot = rb_intern("__dd_otel_fiber_context");
 
-  VALUE otel_thread_context_module = rb_define_module_under(tracing_module, "OTelThreadContext");
+  VALUE otel_thread_context_class = rb_define_class_under(tracing_module, "OTelThreadContext", rb_cObject);
 
-  rb_define_singleton_method(otel_thread_context_module, "_native_enable", native_enable, 0);
-  rb_define_singleton_method(otel_thread_context_module, "_native_set", native_set, 3);
-  rb_define_singleton_method(otel_thread_context_module, "_native_clear", native_clear, 0);
-  rb_define_singleton_method(otel_thread_context_module, "_native_supported?", native_supported_p, 0);
+  rb_define_method(otel_thread_context_class, "_native_enable", native_enable, 0);
+  rb_define_method(otel_thread_context_class, "_native_set", native_set, 3);
+  rb_define_method(otel_thread_context_class, "_native_clear", native_clear, 0);
+  rb_define_method(otel_thread_context_class, "_native_supported?", native_supported_p, 0);
 
-  VALUE testing_module = rb_define_module_under(otel_thread_context_module, "Testing");
+  VALUE testing_module = rb_define_module_under(otel_thread_context_class, "Testing");
   rb_define_singleton_method(testing_module, "_native_read", native_read, 0);
 }
 
-#ifdef __linux__
+#ifdef OTEL_THREAD_CONTEXT_SUPPORTED
   static ddog_ThreadContextHandle *get_fiber_handle_for(VALUE thread) {
     VALUE obj = rb_thread_local_aref(thread, fiber_context_slot);
 
@@ -56,6 +61,22 @@ void otel_thread_context_init(VALUE tracing_module) {
     return get_fiber_handle_for(rb_thread_current());
   }
 
+  static void pack_span_id(VALUE id, uint8_t bytes[8]) {
+    // Tracing::Utils.next_id caps generated span IDs at (1 << 62) - 1, which fits
+    // in a Fixnum on 64-bit Ruby. Packing them directly avoids rb_integer_pack's
+    // generic conversion and format checks on each context update.
+    // https://github.com/DataDog/dd-trace-rb/blob/0b10368e0a2940c1f4d50c9739b9973b4f8bc32a/lib/datadog/tracing/utils.rb#L20-L37
+    if (FIXNUM_P(id)) {
+      uint64_t number = (uint64_t) FIX2LONG(id);
+      for (int i = 7; i >= 0; i--) {
+        bytes[i] = (uint8_t) number;
+        number >>= 8;
+      }
+    } else {
+      rb_integer_pack(id, bytes, 1, sizeof(uint64_t), 0, INTEGER_PACK_BIG_ENDIAN);
+    }
+  }
+
   static void store_current_fiber_handle(ddog_ThreadContextHandle *handle) {
     VALUE obj = TypedData_Wrap_Struct(rb_cObject, &otel_ctx_handle_t, handle);
     rb_thread_local_aset(rb_thread_current(), fiber_context_slot, obj);
@@ -137,7 +158,7 @@ void otel_thread_context_init(VALUE tracing_module) {
 #endif
 
 static VALUE native_enable(DDTRACE_UNUSED VALUE _self) {
-  #ifdef __linux__
+  #ifdef OTEL_THREAD_CONTEXT_SUPPORTED
     if (otel_context_enabled) return Qtrue;
     otel_context_enabled = true;
 
@@ -163,7 +184,7 @@ static VALUE native_enable(DDTRACE_UNUSED VALUE _self) {
 }
 
 static VALUE native_supported_p(DDTRACE_UNUSED VALUE _self) {
-  #ifdef __linux__
+  #ifdef OTEL_THREAD_CONTEXT_SUPPORTED
     return Qtrue;
   #else
     return Qfalse;
@@ -176,17 +197,17 @@ static VALUE native_set(
     DDTRACE_UNUSED VALUE span_id,
     DDTRACE_UNUSED VALUE local_root_span_id
   ) {
-  #ifdef __linux__
+  #ifdef OTEL_THREAD_CONTEXT_SUPPORTED
     if (!otel_context_enabled) return Qfalse;
 
     uint8_t trace_id_bytes[16];
     uint8_t span_id_bytes[8];
     uint8_t local_root_span_id_bytes[8];
 
-    const int BIG_ENDIAN_PACK_FLAGS = INTEGER_PACK_MSWORD_FIRST | INTEGER_PACK_BIG_ENDIAN;
-    rb_integer_pack(trace_id, trace_id_bytes, sizeof(trace_id_bytes), 1, 0, BIG_ENDIAN_PACK_FLAGS);
-    rb_integer_pack(span_id, span_id_bytes, sizeof(span_id_bytes), 1, 0, BIG_ENDIAN_PACK_FLAGS);
-    rb_integer_pack(local_root_span_id, local_root_span_id_bytes, sizeof(local_root_span_id_bytes), 1, 0, BIG_ENDIAN_PACK_FLAGS);
+    // Note: We use 2 words of size 8, as `rb_integer_pack` has a fast path for it (vs 16 bytes of size 1)
+    rb_integer_pack(trace_id, trace_id_bytes, 2, sizeof(uint64_t), 0, INTEGER_PACK_BIG_ENDIAN);
+    pack_span_id(span_id, span_id_bytes);
+    pack_span_id(local_root_span_id, local_root_span_id_bytes);
 
     ddog_ThreadContextHandle *handle = get_current_fiber_handle();
 
@@ -207,7 +228,7 @@ static VALUE native_set(
 }
 
 static VALUE native_clear(DDTRACE_UNUSED VALUE _self) {
-  #ifdef __linux__
+  #ifdef OTEL_THREAD_CONTEXT_SUPPORTED
     if (!otel_context_enabled) return Qfalse;
 
     ddog_ThreadContextHandle *detached = ddog_otel_thread_ctx_detach();
@@ -220,7 +241,7 @@ static VALUE native_clear(DDTRACE_UNUSED VALUE _self) {
 }
 
 static VALUE native_read(DDTRACE_UNUSED VALUE _self) {
-  #ifdef __linux__
+  #ifdef OTEL_THREAD_CONTEXT_SUPPORTED
     const uint8_t *raw = otel_thread_ctx_v1;
     if (!raw) return Qnil;
 

data/ext/libdatadog_extconf_helpers.rb

@@ -2,6 +2,7 @@
 
 require "rubygems"
 require "pathname"
+require "shellwords"
 
 module Datadog
   # Contains a bunch of shared helpers that get used during building of extensions that link to libdatadog
@@ -10,7 +11,7 @@ module Datadog
   module LibdatadogExtconfHelpers
     # Used to make sure the correct gem version gets loaded, as extconf.rb does not get run with "bundle exec" and thus
     # may see multiple libdatadog versions. See https://github.com/DataDog/dd-trace-rb/pull/2531 for the horror story.
-    LIBDATADOG_VERSION = "~> 40.0.0.2.0"
+    LIBDATADOG_VERSION = "~> 44.0.1.1.0"
 
     # Used as an workaround for a limitation with how dynamic linking works in environments where the datadog gem and
     # libdatadog are moved after the extension gets compiled.
@@ -116,7 +117,10 @@ module Datadog
       extconf_folder:,
       libdatadog_pkgconfig_folder: Libdatadog.pkgconfig_folder,
       gem_dir: Gem.dir,
-      logger: Logging
+      logger: Logging,
+      target_incflags: $INCFLAGS,
+      target_ldflags: $LDFLAGS,
+      target_libs: $libs
     )
       return unless libdatadog_pkgconfig_folder
 
@@ -124,10 +128,9 @@ module Datadog
       libdir = "#{libdatadog_pkgconfig_folder}/../../lib"
       includedir = "#{libdatadog_pkgconfig_folder}/../../include"
 
-      # Set mkmf global variables
-      $INCFLAGS << " -I#{includedir}"
-      $LDFLAGS << " -L#{libdir} -Wl,-rpath,#{libdir}"
-      $libs << " -ldatadog_profiling"
+      target_incflags << " -I#{Shellwords.escape(includedir)}"
+      target_ldflags << " -L#{Shellwords.escape(libdir)} -Wl,-rpath,#{Shellwords.escape(libdir)}"
+      target_libs << " -ldatadog_profiling"
 
       # Add extra relative rpaths using $ORIGIN to handle environments where gems are moved after installation.
       # The excessive escaping is needed to get these special characters through Make and the shell untouched.
@@ -141,10 +144,12 @@ module Datadog
           libdatadog_pkgconfig_folder: libdatadog_pkgconfig_folder,
         ),
       ]
-      extra_relative_rpaths.each { |folder| $LDFLAGS << " -Wl,-rpath,$$$\\\\{ORIGIN\\}/#{folder}" }
+      extra_relative_rpaths.each { |folder| target_ldflags << " -Wl,-rpath,$$$\\\\{ORIGIN\\}/#{Shellwords.escape(folder)}" }
 
-      logger.message("linking with libdatadog (include=#{includedir}, lib=#{libdir})\n")
-      logger.message("[datadog] $LDFLAGS were set to: #{$LDFLAGS.inspect}\n")
+      # includedir/libdir/ldflags might have a `%` in there and `logger.message` bottoms out on `printf` so we need to
+      # use the `message("%s", ...)` format otherwise the logger will complain
+      logger.message("%s", "linking with libdatadog (include=#{includedir}, lib=#{libdir})\n")
+      logger.message("%s", "[datadog] $LDFLAGS were set to: #{target_ldflags.inspect}\n")
 
       true
     end

data/lib/datadog/ai_guard/component.rb

@@ -1,37 +1,46 @@
 # frozen_string_literal: true
 
-require_relative "api_client"
+require "json"
+
+require_relative "ext"
+require_relative "http_client"
 require_relative "evaluation"
 require_relative "evaluation/request"
+require_relative "evaluation/response"
+require_relative "evaluation/client"
 require_relative "evaluation/result"
+require_relative "evaluation/outcome"
 require_relative "evaluation/no_op_result"
 require_relative "evaluation/message"
 require_relative "evaluation/tool_call"
 require_relative "evaluation/content_part"
-require_relative "evaluation/content_builder"
-require_relative "ext"
+require_relative "evaluation/message_builder"
+require_relative "redaction"
+require_relative "redaction/result"
+require_relative "redaction/replacements"
+require_relative "metrics/telemetry"
 
 module Datadog
   module AIGuard
     # Component for API Guard product
     class Component
-      attr_reader :api_client, :logger, :telemetry
+      attr_reader :http_client, :logger, :telemetry
 
       def self.build(settings, logger:, telemetry:)
         return unless settings.respond_to?(:ai_guard) && settings.ai_guard.enabled
 
-        api_client = APIClient.new(
+        http_client = HTTPClient.new(
           endpoint: settings.ai_guard.endpoint,
           api_key: settings.api_key,
           application_key: settings.ai_guard.app_key,
           timeout: settings.ai_guard.timeout_ms / 1_000
         )
 
-        new(api_client, logger: logger, telemetry: telemetry)
+        new(http_client, logger: logger, telemetry: telemetry)
       end
 
-      def initialize(api_client, logger:, telemetry:)
-        @api_client = api_client
+      def initialize(http_client, logger:, telemetry:)
+        @http_client = http_client
         @logger = logger
         @telemetry = telemetry
       end

data/lib/datadog/ai_guard/configuration/ext.rb

@@ -6,6 +6,8 @@ module Datadog
       # This module contains constants for AI Guard component
       module Ext
         ENV_AI_GUARD_ENABLED = "DD_AI_GUARD_ENABLED"
+        ENV_AI_GUARD_REDACTION_ENABLED = "DD_AI_GUARD_REDACTION_ENABLED"
+
         ENV_AI_GUARD_ENDPOINT = "DD_AI_GUARD_ENDPOINT"
         ENV_AI_GUARD_TIMEOUT = "DD_AI_GUARD_TIMEOUT"
         ENV_AI_GUARD_MAX_CONTENT_SIZE = "DD_AI_GUARD_MAX_CONTENT_SIZE"

data/lib/datadog/ai_guard/configuration.rb

@@ -34,6 +34,19 @@ module Datadog
                 o.default false
               end
 
+              # Redact sensitive data from evaluated messages.
+              #
+              # When enabled, values flagged by AI Guard are replaced before the messages are
+              # stored in the span or returned to the caller. Disable to skip redaction entirely.
+              #
+              # @default `DD_AI_GUARD_REDACTION_ENABLED`, otherwise `true`
+              # @return [Boolean]
+              option :redaction_enabled do |o|
+                o.type :bool
+                o.env Ext::ENV_AI_GUARD_REDACTION_ENABLED
+                o.default true
+              end
+
               define_method(:instrument) do |integration_name|
                 return unless enabled # steep:ignore
 

data/lib/datadog/ai_guard/contrib/ruby_llm/chat_instrumentation.rb

@@ -4,74 +4,67 @@ module Datadog
   module AIGuard
     module Contrib
       module RubyLLM
-        # module that gets prepended to RubyLLM::Chat
+        # Protects tool calls before RubyLLM executes them locally
+        #
+        # @api private
         module ChatInstrumentation
-          class << self
-            def evaluate!(messages)
-              ai_guard_messages = messages.flat_map do |message|
-                if message.tool_call?
-                  message.tool_calls.map do |tool_call_id, tool_call|
-                    AIGuard.assistant(id: tool_call_id, tool_name: tool_call.name, arguments: tool_call.arguments.to_s)
-                  end
-                elsif message.tool_result?
-                  build_ai_guard_tool(message)
-                else
-                  build_ai_guard_message(message)
-                end
-              end
+          private
 
-              AIGuard.evaluate(*ai_guard_messages)
-            end
-
-            private
+          def provider_completion(usage_recorder:, stream_tracker: nil, &block)
+            @_datadog_ai_guard_evaluate = true
+            super
+          ensure
+            @_datadog_ai_guard_evaluate = false
+          end
 
-            def build_ai_guard_message(message)
-              content = message.content
+          def preprocessed_messages(list = messages)
+            return super unless @_datadog_ai_guard_evaluate
 
-              case content
-              when ::RubyLLM::Content
-                AIGuard.message(role: message.role) do |m|
-                  m.text(content.text.to_s) if content.text
+            adapter = MessageAdapter.new(list)
 
-                  # Calling attachment.for_llm triggers lazy loading of file contents.
-                  # The result is memoized, so providers won't re-read.
-                  content.attachments.each do |attachment|
-                    case attachment.type
-                    when :image
-                      m.image_url(attachment.for_llm)
-                    when :text
-                      m.text(attachment.for_llm)
-                    end
-                    # Skip :pdf, :audio, :video, :unknown — not supported by AIGuard
-                  end
-                end
-              else
-                AIGuard.message(role: message.role, content: content)
-              end
+            begin
+              converted_messages = adapter.to_ai_guard
+            rescue JSON::JSONError
+              Metrics::Telemetry.report_error
+              return super
+            rescue => e
+              AIGuard.telemetry&.report(e, description: "AI Guard: Failed to convert RubyLLM messages")
+              return super
             end
 
-            def build_ai_guard_tool(message)
-              content = message.content
-              # Tools can return Content or Content::Raw objects (e.g. with attachments),
-              # but AIGuard.tool expects a String. Extract text when content is a Content object.
-              case content
-              when ::RubyLLM::Content
-                content = content.text.to_s
-              end
-              AIGuard.tool(tool_call_id: message.tool_call_id, content: content)
+            evaluation = AIGuard.evaluate(*converted_messages)
+
+            begin
+              redacted_messages = adapter.apply_redactions(evaluation.messages)
+            rescue JSON::JSONError => e
+              AIGuard.telemetry&.report(e, description: "AI Guard: Failed to apply RubyLLM redaction")
+              return super
             end
+
+            super(redacted_messages)
           end
 
-          def complete(&block)
-            Datadog::AIGuard::Contrib::RubyLLM::ChatInstrumentation.evaluate!(messages)
+          def execute_pending_tool_calls(response)
+            response_index = messages.index { |message| message == response }
+            return super unless response_index
 
-            super
-          end
+            adapter = MessageAdapter.new(messages)
+            begin
+              converted_messages = adapter.to_ai_guard
+            rescue JSON::JSONError
+              Metrics::Telemetry.report_error
+              return super
+            end
 
-          def handle_tool_calls(response, &block)
-            Datadog::AIGuard::Contrib::RubyLLM::ChatInstrumentation.evaluate!(messages)
+            evaluation = AIGuard.evaluate(*converted_messages)
+            begin
+              redacted_messages = adapter.apply_redactions(evaluation.messages)
+            rescue JSON::JSONError => e
+              AIGuard.telemetry&.report(e, description: "AI Guard: Failed to apply RubyLLM redaction")
+              return super
+            end
 
-            super
+            super(redacted_messages[response_index])
           end
         end
       end

data/lib/datadog/ai_guard/contrib/ruby_llm/integration.rb

@@ -11,7 +11,7 @@ module Datadog
         class Integration
           include Datadog::AIGuard::Contrib::Integration
 
-          MINIMUM_VERSION = Gem::Version.new("1.0.0")
+          MINIMUM_VERSION = Gem::Version.new("2.0.0")
 
           register_as :ruby_llm, auto_patch: false
 

data/lib/datadog/ai_guard/contrib/ruby_llm/message_adapter.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "redaction_change_set"
+
+module Datadog
+  module AIGuard
+    module Contrib
+      module RubyLLM
+        # RubyLLM messages paired with their AI Guard representation
+        #
+        # @api private
+        class MessageAdapter
+          def initialize(messages)
+            @ruby_llm_messages = messages
+          end
+
+          def to_ai_guard
+            @ai_guard_messages ||= @ruby_llm_messages.map { |message| build_ai_guard_message(message) }
+          end
+
+          def apply_redactions(redacted_messages)
+            ai_guard_messages = to_ai_guard
+            return @ruby_llm_messages if redacted_messages == ai_guard_messages
+
+            @ruby_llm_messages.each_with_index.map do |message, index|
+              original_message = ai_guard_messages[index]
+              redacted_message = redacted_messages[index]
+              next message if redacted_message == original_message
+
+              RedactionChangeSet.new(original_message, redacted_message).apply_to(message)
+            end
+          end
+
+          private
+
+          def build_ai_guard_message(message)
+            builder = Evaluation::MessageBuilder.new
+
+            # NOTE: Hash block arguments are misinterpreted by Steep after `nil.to_h`
+            # steep:ignore:start
+            message.tool_calls.to_h.each do |id, tool_call|
+              builder.tool_call(name: tool_call.name, id: id, arguments: tool_call.arguments)
+            end
+            # steep:ignore:end
+
+            if message.attachments.empty?
+              content = message.content
+            else
+              builder.text(message.content) if message.content && !message.content.empty?
+
+              message.attachments.each do |attachment|
+                next if attachment.provider_file?
+
+                case attachment.type
+                when :text
+                  builder.text(attachment.content)
+                when :image
+                  # NOTE: Local images are Base64-encoded here by `#for_llm`
+                  #       and again when RubyLLM builds the provider request
+                  url = attachment.url? ? attachment.source.to_s : attachment.for_llm
+                  builder.image_url(url)
+                end
+              end
+
+              content = builder.content
+            end
+
+            Evaluation::Message.new(
+              role: message.role, content: content, tool_calls: builder.tool_calls, tool_call_id: message.tool_call_id
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/ai_guard/contrib/ruby_llm/patcher.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "message_adapter"
 require_relative "chat_instrumentation"
 
 module Datadog