wip

Author: marcotc

Gemfile

@@ -2,6 +2,7 @@ eval_gemfile("#{RUBY_ENGINE}-#{RUBY_ENGINE_VERSION.split('.').take(2).join('.')}
 
 # gem 'rails', '8.0.1'
 # # gem 'rails', '7.0.8.7'
+# # gem 'rails', '~> 6.1.0'
 # gem 'pg'
 # gem 'lograge'
 # gem 'redis'

gemfiles/ruby_3.4_rails61_postgres_redis.gemfile.lock

@@ -62,9 +62,12 @@ def trace?(event, _payload)
               end
 
               def on_start(span, event, _id, payload)
-                # Fall back to `key` in case new APIs are introduced that don't directly call `normalize_key`.
-                # This is a defensive measure, as of Rails 8, this does not happen.
-                raise "payload[:dd_original_keys] is nil: #{payload[:key]}" if  payload[:dd_original_keys].nil?
+                # Since Rails 8, `dd_original_keys` contains the denormalized key provided by the user.
+                # In previous versions, the denormalized key is stored in the official `key` attribute.
+                # We fall back to `key`, even in Rails 8, as a defensive measure.
+                #
+                # TODO: Remove this raise
+                raise "payload[:dd_original_keys] is nil: #{payload[:key]}" if payload[:dd_original_keys].nil? && ::Rails.version.to_i >= 8
                 key = payload[:dd_original_keys] || payload[:key]
                 store = payload[:store]
 
@@ -99,9 +102,6 @@ def set_cache_key(span, key, multi_key)
                   cache_key = Core::Utils.truncate(resolved_key, Ext::QUANTIZE_CACHE_MAX_KEY_SIZE)
                   span.set_tag(Ext::TAG_CACHE_KEY_MULTI, cache_key)
                 else
-                  # `dd_original_keys` is an Array with one element when `multi_key` is false.
-                  # But if using the fallback `key`, it is a simple scalar value.
-                  key = key.is_a?(Array) ? key[0] : key
                   resolved_key = ::ActiveSupport::Cache.expand_cache_key(key)
                   cache_key = Core::Utils.truncate(resolved_key, Ext::QUANTIZE_CACHE_MAX_KEY_SIZE)
                   span.set_tag(Ext::TAG_CACHE_KEY, cache_key)

gemfiles/ruby_3.4_rails61_trilogy.gemfile.lock

@@ -6,7 +6,7 @@
 
 require 'datadog/tracing/contrib/rails/rails_helper'
 
-RSpec.describe 'Rails cache', execute_in_fork: true do
+RSpec.describe 'Rails cache', execute_in_fork: false do
   include_context 'Rails test application'
 
   before do

lib/datadog/tracing/contrib/active_support/cache/events/cache.rb

@@ -1,25 +1,163 @@
 module ForkableExample
   def finish(reporter)
     # TODO: better name than execute_in_fork?
-    if @metadata[:execute_in_fork]
+    if @metadata[:execute_in_fork] && Process.ppid != 1
       super ? exit(0) : exit(1)
     else
       super
     end
   end
 
+  EXAMPLE_SENTINEL = Module.new
+  MODULE_VALUE = Struct.new(:name)
+
   def run(example_group_instance, reporter)
     if @metadata[:execute_in_fork]
+      reader, writer = IO.pipe
+
+      reader.binmode
+      writer.binmode
+
       pid = fork do
+        reporter.singleton_class.prepend(ForkableExample::Reporter)
+        execution_result.singleton_class.prepend(ForkableExample::ExecutionResult)
+        execution_result.instance_variable_set(:@fork_writer_pipe, writer)
+        reporter.instance_variable_set(:@fork_writer_pipe, writer)
+
+        reporter.instance_variable_set(:@fork_example_sentinel, self)
+
+        reader.close
+
         super
+
+        # writer.puts "Hello from child process"
+        writer.close
       end
 
+      writer.close
+
       _, status = Process.wait2(pid)
+
+      while (read_size = reader.gets)
+        call = Marshal.load(reader.read(Integer(read_size)))
+
+        args = call[:args]
+        args.map! do |arg|
+          if arg == EXAMPLE_SENTINEL
+            self
+          elsif arg.is_a?(MODULE_VALUE)
+            ::Object.const_get(arg.name)
+          elsif arg.is_a?(RSpec::Core::Notifications::ExampleNotification) && arg.example == EXAMPLE_SENTINEL
+            ::RSpec::Core::Notifications::ExampleNotification.for(self)
+          else
+            arg
+          end
+        end
+
+        # puts("call: #{call}")
+
+        if call[:receiver] == :reporter
+          reporter.send(call[:method], *args)
+        elsif call[:receiver] == :execution_result
+          execution_result.send(call[:method], *args)
+        end
+      end
+
+      reader.close
+
       status.success?
     else
       super
     end
   end
+
+  module Reporter
+
+
+      # PUBLIC_INTERNAL_METHODS = [:start, :stop, :publish, :finish, :close_after, :notify, :fail_fast_limit_met?]
+     RSpec::Core::Reporter.instance_methods(false).each do |method|
+      define_method(method) do |*args|
+        original_args = args
+
+
+        unless @fork_instrumenting # Nested calls are skipped, since they will invoked by the first call site
+          begin
+            @fork_instrumenting = true
+
+            args = args.map do |arg|
+              if arg == @fork_example_sentinel
+                EXAMPLE_SENTINEL
+              elsif arg.is_a?(Module)
+                MODULE_VALUE.new(arg.name)
+              elsif arg.is_a?(::RSpec::Core::Notifications::ExampleNotification) && arg.example == @fork_example_sentinel
+                ::RSpec::Core::Notifications::ExampleNotification.send(:new, EXAMPLE_SENTINEL)
+              else
+                arg
+              end
+            end
+
+          # puts({ method: method, args: args })
+
+          dump = Marshal.dump({ receiver: :reporter, method: method, args: args })
+          # Write a header hex int with the size of the next object dump
+          @fork_writer_pipe.write(sprintf("0x%x\n", dump.bytesize))
+          @fork_writer_pipe.write(dump)
+
+            # puts({ method: method, args: args })
+          rescue => e
+            puts "ERRORERRORERROR 1111"
+            puts args
+            puts e
+          end
+        end
+
+        super(*original_args)
+      ensure
+        @fork_instrumenting = false
+      end
+    end
+  end
+
+  module ExecutionResult
+    ::RSpec::Core::Example::ExecutionResult.instance_methods(false).reject{|m|m.end_with?('?')}.each do |method|
+      define_method(method) do |*args|
+        original_args = args
+
+        unless @fork_instrumenting # Nested calls are skipped, since they will invoked by the first call site
+          begin
+            @fork_instrumenting = true
+
+            # args = args.map do |arg|
+            #   if arg == @fork_example_sentinel
+            #     EXAMPLE_SENTINEL
+            #   elsif arg.is_a?(Module)
+            #     MODULE_VALUE.new(arg.name)
+            #   else
+            #     arg
+            #   end
+            # end
+
+            # puts({ method: method, args: args })
+
+            dump = Marshal.dump({ receiver: :execution_result, method: method, args: args })
+            # Write a header hex int with the size of the next object dump
+            @fork_writer_pipe.write(sprintf("0x%x\n", dump.bytesize))
+            @fork_writer_pipe.write(dump)
+
+            # puts({ method: method, args: args })
+          rescue => e
+            puts "ERRORERRORERROR 2222"
+            puts args
+            puts e
+          end
+        end
+
+        super(*original_args)
+      ensure
+        @fork_instrumenting = false
+      end
+    end
+  end
 end
 
 RSpec::Core::Example.prepend(ForkableExample)