CI fix

Author: cretz

.github/workflows/ci.yml

@@ -88,7 +88,7 @@ jobs:
           TEMPORAL_CLOUD_OPS_TEST_NAMESPACE: ${{ vars.TEMPORAL_CLIENT_NAMESPACE }}
           TEMPORAL_CLOUD_OPS_TEST_API_KEY: ${{ secrets.TEMPORAL_CLIENT_CLOUD_API_KEY }}
           TEMPORAL_CLOUD_OPS_TEST_API_VERSION: 2024-05-13-00
-        run: bundle exec rake TESTOPTS="--verbose"
+        run: bundle exec rake compile test TESTOPTS="--verbose --name=/^WorkerWorkflowTest#test_confirm_garbage_collect$/"
 
       - name: Deploy docs
         # Only deploy on main merge, not in PRs

temporalio/test/worker_workflow_test.rb

@@ -2,6 +2,7 @@
 
 require 'base64_codec'
 require 'net/http'
+require 'objspace'
 require 'temporalio/client'
 require 'temporalio/testing'
 require 'temporalio/worker'
@@ -1912,9 +1913,10 @@ def test_fail_workflow_payload_converter
   class ConfirmGarbageCollectWorkflow < Temporalio::Workflow::Definition
     @initialized_count = 0
     @finalized_count = 0
+    @weak_instance = nil
 
     class << self
-      attr_accessor :initialized_count, :finalized_count
+      attr_accessor :initialized_count, :finalized_count, :weak_instance
 
       def create_finalizer
         proc { @finalized_count += 1 }
@@ -1923,6 +1925,7 @@ def create_finalizer
 
     def initialize
       self.class.initialized_count += 1
+      self.class.weak_instance = WeakRef.new(self)
       ObjectSpace.define_finalizer(self, self.class.create_finalizer)
     end
 
@@ -1940,10 +1943,194 @@ def test_confirm_garbage_collect
       assert_equal 0, ConfirmGarbageCollectWorkflow.finalized_count
     end
 
-    # Now with worker shutdown, GC and confirm finalized
-    assert_eventually do
-      GC.start
-      assert_equal 1, ConfirmGarbageCollectWorkflow.finalized_count
+    # 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__
+
+      path, cat = find_retaining_path_to(instance.object_id, max_depth: 12)
+      print_annotated_path(path, root_category: cat)
+      flunk
+    rescue WeakRef::RefError
+      # Expected
+    end
+  end
+
+  # Find one path from any GC root to the object with +target_id+.
+  # Returns [path_array, root_category], where path_array is an array of objects from root..target.
+  def find_retaining_path_to(target_id, max_depth: 12, max_visits: 250_000, category_whitelist: nil)
+    roots = ObjectSpace.reachable_objects_from_root # {category_sym => [objs]}
+    queue   = []
+    seen    = {}
+    parent  = {}    # child_id -> parent_id
+    root_of = {}    # obj_id   -> root_category
+
+    roots.each do |category, objs|
+      next if category_whitelist && !category_whitelist.include?(category)
+
+      objs.each do |o|
+        id = o.__id__
+        next if seen[id]
+
+        seen[id] = true
+        parent[id] = nil
+        root_of[id] = category
+        queue << o
+      end
+    end
+
+    visits = 0
+    depth  = 0
+    level_remaining = queue.length
+    next_level = 0
+
+    found_leaf = nil
+
+    while !queue.empty? && visits < max_visits && depth <= max_depth
+      cur = queue.shift
+      level_remaining -= 1
+      visits += 1
+
+      cid = cur.__id__
+      if cid == target_id
+        found_leaf = cid
+        break
+      end
+
+      children = begin
+        ObjectSpace.reachable_objects_from(cur)
+      rescue StandardError
+        nil
+      end
+
+      if children
+        children.each do |child|
+          chid = child.__id__
+          next if seen[chid]
+
+          seen[chid] = true
+          parent[chid] = cid
+          root_of[chid] ||= root_of[cid]
+          queue << child
+          next_level += 1
+        end
+      end
+
+      next unless level_remaining == 0
+
+      depth += 1
+      level_remaining = next_level
+      next_level = 0
+    end
+
+    return [nil, nil] unless found_leaf
+
+    # Reconstruct path
+    ids = []
+    i = found_leaf
+    while i
+      ids << i
+      i = parent[i]
+    end
+    objs = ids.reverse.map do |id|
+      ObjectSpace._id2ref(id)
+    rescue StandardError
+      id
+    end
+    [objs, root_of[ids.first]]
+  end
+
+  # Label HOW +parent+ holds a reference to +child+ (ivar name, constant, index, etc.).
+  def edge_labels(parent, child)
+    labels = []
+    target = child
+
+    # 1) Instance variables (works for Class/Module too – class ivars are ivars on the Class object)
+    if parent.respond_to?(:instance_variables)
+      parent.instance_variables.each do |ivar|
+        labels << "@#{ivar.to_s.delete('@')}" if parent.instance_variable_get(ivar).equal?(target)
+      rescue StandardError
+      end
+    end
+
+    # 2) Class variables on Module/Class
+    if parent.is_a?(Module)
+      parent.class_variables.each do |cvar|
+        labels << cvar.to_s if parent.class_variable_get(cvar).equal?(target)
+      rescue NameError
+      end
+    end
+
+    # 3) Constants on Module/Class (avoid triggering autoload)
+    if parent.is_a?(Module)
+      parent.constants(false).each do |c|
+        next if parent.respond_to?(:autoload?) && parent.autoload?(c)
+
+        if parent.const_defined?(c, false)
+          v = parent.const_get(c, false)
+          labels << "::#{c}" if v.equal?(target)
+        end
+      rescue NameError, LoadError
+      end
+    end
+
+    # 4) Array elements
+    if parent.is_a?(Array)
+      parent.each_with_index do |v, i|
+        labels << "[#{i}]" if v.equal?(target)
+      end
+    end
+
+    # 5) Hash entries (key or value)
+    if parent.is_a?(Hash)
+      parent.each do |k, v|
+        labels << "{key #{k.inspect}}" if k.equal?(target)
+        labels << "{value for #{k.inspect}}" if v.equal?(target)
+      end
+    end
+
+    # 6) Struct members
+    if parent.is_a?(Struct)
+      parent.members.each do |m|
+        labels << ".#{m}" if parent[m].equal?(target)
+      rescue StandardError
+      end
+    end
+
+    # 7) Fallback for VM internals
+    if labels.empty?
+      begin
+        labels << '(internal)' if parent.is_a?(ObjectSpace::InternalObjectWrapper)
+      rescue StandardError
+      end
+    end
+
+    labels.empty? ? ['(unknown edge)'] : labels
+  end
+
+  def describe_obj(o)
+    cls = (o.is_a?(Module) ? o : o.class)
+    "#<#{cls} 0x#{o.__id__.to_s(16)}>"
+  rescue StandardError
+    o.inspect
+  end
+
+  def print_annotated_path(path, root_category:)
+    puts "Retaining path (len=#{path.length}) from ROOT[:#{root_category}] to target:"
+    return if path.empty?
+
+    # First is the root
+    puts "  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 == 0 ? '    └─' : '      •')
+        puts "#{arrow} via #{lab} → #{describe_obj(child)}"
+      end
     end
   end