CI fix

Author: cretz

temporalio/test/gc_utils.rb

@@ -87,23 +87,25 @@ def find_retaining_path_to(target_id, max_depth: 12, max_visits: 250_000, catego
       [objs, root_of[ids.first]]
     end
 
-    # Print path on stdout.
-    def print_annotated_path(path, root_category:)
-      puts "Retaining path (len=#{path.length}) from ROOT[:#{root_category}] to target:"
-      return if path.empty?
+    # Return string of annotated path
+    def annotated_path(path, root_category:)
+      lines = []
+      lines << "Retaining path (len=#{path.length}) from ROOT[:#{root_category}] to target:"
+      return lines.join("\n") if path.empty?
 
       # First is the root
-      puts "  ROOT[:#{root_category}] #{describe_obj(path.first)}"
+      lines << "  ROOT[:#{root_category}] #{describe_obj(path.first)}"
       # Then edges with labels
       (0...(path.length - 1)).each do |i|
         parent = path[i]
         child  = path[i + 1]
         labels = edge_labels(parent, child)
         labels.each_with_index do |lab, j|
           arrow = (j.zero? ? '    └─' : '      •')
-          puts "#{arrow} via #{lab} → #{describe_obj(child)}"
+          lines << "#{arrow} via #{lab} → #{describe_obj(child)}"
         end
       end
+      lines.join("\n")
     end
 
     private

temporalio/test/worker_workflow_test.rb

@@ -1914,9 +1914,10 @@ class ConfirmGarbageCollectWorkflow < Temporalio::Workflow::Definition
     @initialized_count = 0
     @finalized_count = 0
     @weak_instance = nil
+    @strong_instance = nil
 
     class << self
-      attr_accessor :initialized_count, :finalized_count, :weak_instance
+      attr_accessor :initialized_count, :finalized_count, :weak_instance, :strong_instance
 
       def create_finalizer
         proc { @finalized_count += 1 }
@@ -1926,6 +1927,9 @@ def create_finalizer
     def initialize
       self.class.initialized_count += 1
       self.class.weak_instance = WeakRef.new(self)
+      # Uncomment this to cause test to fail
+      # self.class.strong_instance = self
+
       ObjectSpace.define_finalizer(self, self.class.create_finalizer)
     end
 
@@ -1936,11 +1940,10 @@ def execute
 
   def test_confirm_garbage_collect
     major, minor = RUBY_VERSION.split('.').take(2).map(&:to_i)
-    skip('Only Ruby 3.4+ has predictable eager GC') if major != 3 || minor < 4
+    skip('Only Ruby 3.4+ has somewhat predictable eager GC') if major != 3 || minor < 4
 
     # This test confirms the workflow instance is reliably GC'd when workflow/worker done. To confirm the test fails
-    # when there is still an instance, make a "strong_instance" singleton attribute and assign "self" to it in
-    # initialize and confirm this calls flunk later.
+    # when there is still an instance, uncomment the strong_instance set in the initialize of the workflow.
 
     execute_workflow(ConfirmGarbageCollectWorkflow) do |handle|
       # Wait until it is started
@@ -1950,18 +1953,31 @@ def test_confirm_garbage_collect
       assert_equal 0, ConfirmGarbageCollectWorkflow.finalized_count
     end
 
-    # Perform a GC and confirm gone
-    GC.start
-    begin
-      # Access instance and assert that it fails when a method is called on it as expected
-      instance = ConfirmGarbageCollectWorkflow.weak_instance.__getobj__
-
-      # Print out the path still holding it
-      path, cat = GCUtils.find_retaining_path_to(instance.object_id, max_depth: 12)
-      GCUtils.print_annotated_path(path, root_category: cat)
-      flunk
-    rescue WeakRef::RefError
-      # Expected
+    # Perform a GC and confirm gone. There are cases in Ruby where dead stack slots leave the item around for a bit, so
+    # we check repeatedly for a bit (every 200ms for 10s). We can't use assert_eventually, because path doesn't show
+    # well.
+    start_time = Time.now
+    loop do
+      GC.start
+      # Break if the instance is gone
+      break unless ConfirmGarbageCollectWorkflow.weak_instance.weakref_alive?
+
+      # If this is last iteration, flunk w/ the path
+      if Time.now - start_time > 10
+        instance = ConfirmGarbageCollectWorkflow.weak_instance.__getobj__
+        path, cat = GCUtils.find_retaining_path_to(instance.object_id, max_depth: 12)
+        msg = GCUtils.annotated_path(path, root_category: cat)
+        msg += "\nPath:\n#{path.map { |p| "    Item: #{p}" }.join("\n")}"
+        # Also display any Thread/Fiber backtraces that are in the path
+        path.grep(Thread).each do |thread|
+          msg += "\nThread trace: #{thread.backtrace.join("\n")}"
+        end
+        path.grep(Fiber).each do |fiber|
+          msg += "\nFiber trace: #{fiber.backtrace.join("\n")}"
+        end
+        flunk msg
+      end
+      sleep(0.2)
     end
   end