Thread safety when calling fetch_relation #568

Activity

1. madejejej commented on Jun 10, 2024

   

   madejejej

   on Jun 10, 2024

   Author

   More actions

   FYI we use the following monkey-patch to fix this behavior:

   # frozen_string_literal: true
   
   # Open access to the IdentityCache::Cached module
   IdentityCache.public_constant(:Cached)
   
   module IdentityCache
     module Cached
       module Recursive
         # Monkey-patch to allow for thread-safe loading of associations
         class Association
           def initialize(name, reflection:)
             super
             @dehydrated_variable_name = :"@dehydrated_#{name}"
             @hydration_mutex = Mutex.new
           end
   
           def read(record)
             assoc = record.association(name)
   
             if !assoc.loaded? && assoc.target.blank? && (record.send(:loaded_by_idc?) || assoc.klass.should_use_cache?)
               if record.instance_variable_defined?(records_variable_name)
                 record.instance_variable_get(records_variable_name)
               elsif record.instance_variable_defined?(dehydrated_variable_name)
                 hydrate_safely(record, assoc)
               else
                 assoc.load_target
               end
             else
               assoc.load_target
             end
           end
   
           private
   
           # Synchronizes access to the association with a mutex to prevent removing an ivar twice, which raises an error
           def hydrate_safely(record, assoc)
             @hydration_mutex.synchronize do
               if record.instance_variable_defined?(records_variable_name)
                 # Another thread may have already hydrated the association - do an early return in this case
                 record.instance_variable_get(records_variable_name)
               else
                 dehydrated_target = record.instance_variable_get(dehydrated_variable_name)
                 association_target = hydrate_association_target(assoc.klass, dehydrated_target)
                 record.remove_instance_variable(dehydrated_variable_name)
                 set_with_inverse(record, association_target)
               end
             end
           end
         end
       end
     end
   end

   But perhaps it would be easier to keep the dehydration status on the Association itself and get rid of using remove_instance_variable
2. merouaneamqor

   added a commit that references this issue on Sep 18, 2025

   Make recursive association hydration thread-safe (Shopify#568)

   b921944