upkeep-rails 0.1.9 → 0.1.12

data/lib/upkeep/rails.rb

@@ -4,8 +4,8 @@ require "active_support/notifications"
 require_relative "capture/request"
 require_relative "subscriptions/registrar"
 require_relative "rails/configuration"
+require_relative "rails/cluster_guard"
 require_relative "rails/activation_token"
-require_relative "rails/delivery_job"
 require_relative "rails/replay"
 require_relative "rails/action_view_capture"
 require_relative "rails/cable"
@@ -99,8 +99,8 @@ module Upkeep
         nil
       end
 
-      # Dispatches committed application changes through the configured delivery
-      # adapter.
+      # Dispatches committed application changes onto the in-process delivery
+      # dispatcher (or synchronously when config.deliver_inline is set).
       #
       # ControllerRuntime calls this automatically after non-GET actions. Apps
       # usually should not call it from controllers or models.
@@ -122,9 +122,9 @@ module Upkeep
       # Delivers committed application changes immediately in the current
       # process.
       #
-      # This is used by the inline delivery adapter and Active Job worker. Tests
-      # that need deterministic async delivery should use
-      # Upkeep::Rails::Testing instead of calling this directly.
+      # This is used by inline delivery (config.deliver_inline). Tests that
+      # need deterministic async delivery should use Upkeep::Rails::Testing
+      # instead of calling this directly.
       #
       # @param changes [Array<#to_h>] change events to deliver. Defaults to the
       #   current runtime change log.
@@ -142,6 +142,7 @@ module Upkeep
         return true unless configuration.enabled
 
         validate_subscription_store!(environment: environment)
+        validate_cluster_safety!(environment: environment)
         true
       end
 
@@ -160,20 +161,15 @@ module Upkeep
 
       def dispatch_changes(changes)
         payload = {
-          adapter: configuration.delivery_adapter,
-          queue: configuration.delivery_queue,
+          inline: configuration.deliver_inline,
           change_count: changes.size
         }
 
         ActiveSupport::Notifications.instrument(DELIVERY_ENQUEUE, payload) do
-          case configuration.delivery_adapter
-          when :active_job
-            DeliveryJob.perform_later(changes)
-            Delivery::Transport::DispatchReport.new([])
-          when :async
-            delivery_dispatcher.enqueue(changes)
-          when :inline
+          if configuration.deliver_inline
             deliver_changes_now!(changes)
+          else
+            delivery_dispatcher.enqueue(changes)
           end
         end
       end
@@ -181,8 +177,7 @@ module Upkeep
       def instrument_delivery_enqueue_error(changes, error)
         ActiveSupport::Notifications.instrument(
           DELIVERY_ENQUEUE_ERROR,
-          adapter: configuration.delivery_adapter,
-          queue: configuration.delivery_queue,
+          inline: configuration.deliver_inline,
           change_count: changes.size,
           error_class: error.class.name,
           error_message: error.message
@@ -354,6 +349,52 @@ module Upkeep
           "config.upkeep.subscription_store = :memory in development/test."
       end
 
+      def validate_cluster_safety!(environment:, guard: nil)
+        guard ||= ClusterGuard.new(
+          cable_adapter: resolved_action_cable_adapter,
+          worker_count: detected_worker_count,
+          subscription_store: configuration.subscription_store,
+          environment: environment
+        )
+        return true if guard.problems.empty?
+        raise ConfigurationError, guard.message if guard.error?
+
+        log_cluster_warning(guard.message)
+        true
+      end
+
+      def log_cluster_warning(message)
+        return if @cluster_warning_logged
+
+        @cluster_warning_logged = true
+        if defined?(::Rails) && ::Rails.respond_to?(:logger) && ::Rails.logger
+          ::Rails.logger.warn("[upkeep] #{message}")
+        else
+          warn("[upkeep] #{message}")
+        end
+      end
+
+      def resolved_action_cable_adapter
+        return unless defined?(::ActionCable) && ::ActionCable.respond_to?(:server)
+
+        cable = ::ActionCable.server.config.cable
+        cable && (cable["adapter"] || cable[:adapter])
+      rescue StandardError
+        nil
+      end
+
+      def detected_worker_count
+        puma_worker_count || ENV["WEB_CONCURRENCY"].to_i
+      end
+
+      def puma_worker_count
+        return unless defined?(::Puma) && ::Puma.respond_to?(:cli_config)
+
+        ::Puma.cli_config&.options&.[](:workers)
+      rescue StandardError
+        nil
+      end
+
       def production_environment?(environment)
         environment.to_s == "production"
       end

data/lib/upkeep/runtime.rb

@@ -783,11 +783,13 @@ module Upkeep
         value = super
         return value unless Observation.recording?
 
+        id = primary_key_value(attr_name, value)
         dependency = Dependencies::ActiveRecordAttribute.new(
           table: self.class.table_name,
           model: self.class.name,
-          id: primary_key_value(attr_name, value),
-          attribute: attr_name.to_s
+          id: id,
+          attribute: attr_name.to_s,
+          scope: id.nil? ? upkeep_fresh_record_scope : nil
         )
 
         Observation.record_dependency(dependency)
@@ -806,6 +808,41 @@ module Upkeep
       rescue StandardError
         nil
       end
+
+      def upkeep_fresh_record_scope
+        return nil unless new_record?
+
+        self.class.reflect_on_all_associations(:belongs_to).each_with_object({}) do |reflection, scope|
+          foreign_key = reflection.foreign_key
+          next if foreign_key.is_a?(Array)
+
+          foreign_key = foreign_key.to_s
+          fk_value = upkeep_scope_attribute_value(foreign_key)
+          next if fk_value.nil?
+
+          if reflection.polymorphic?
+            foreign_type = reflection.foreign_type.to_s
+            type_value = upkeep_scope_attribute_value(foreign_type)
+            next if type_value.nil?
+
+            scope[foreign_type] = type_value
+          end
+
+          scope[foreign_key] = fk_value
+        end
+      rescue StandardError
+        nil
+      end
+
+      def upkeep_scope_attribute_value(name)
+        return nil unless @attributes.key?(name)
+
+        value = @attributes.fetch_value(name)
+        case value
+        when true, false, Numeric, String, Symbol
+          value
+        end
+      end
     end
 
     # Hooks `cache_key_with_version` so that any caller (Rails fragment caching,

data/lib/upkeep/shared_streams.rb

@@ -8,8 +8,8 @@ module Upkeep
 
     module_function
 
-    def stream_name(target:, identity_signature:, sharing_signature:)
-      digest = Digest::SHA256.hexdigest([target.kind, target.id, identity_signature, sharing_signature].inspect)[0, 32]
+    def stream_name(target:, identity_signature:, sharing_signature:, deployment_signature:)
+      digest = Digest::SHA256.hexdigest([target.kind, target.id, identity_signature, sharing_signature, deployment_signature].inspect)[0, 32]
       "#{PREFIX}:#{digest}"
     end
 
@@ -47,7 +47,8 @@ module Upkeep
         stream_name(
           target: target,
           identity_signature: identity_signature,
-          sharing_signature: signature_for(recipe)
+          sharing_signature: signature_for(recipe),
+          deployment_signature: deployment_signature_for(graph, frame.id)
         )
       end.uniq.sort
     end
@@ -62,6 +63,19 @@ module Upkeep
       Digest::SHA256.hexdigest(identity_dependencies.map(&:identity_key).sort_by(&:inspect).inspect)[0, 16]
     end
 
+    # Deployment-stable request reads (host, protocol, ...) do not partition viewers, but
+    # their fingerprinted values must still scope the stream: folding them into the name
+    # makes cross-host sharing impossible by construction.
+    def deployment_signature_for(graph, frame_id)
+      deployment_dependencies = graph.contained_node_ids(frame_id)
+        .flat_map { |owner_id| graph.dependencies_for(owner_id) }
+        .select { |dependency| Dependencies.deployment_stable_request?(dependency) }
+        .uniq(&:cache_key)
+      return "none" if deployment_dependencies.empty?
+
+      Digest::SHA256.hexdigest(deployment_dependencies.map(&:identity_key).sort_by(&:inspect).inspect)[0, 16]
+    end
+
     def target_for_frame(frame)
       case frame.payload.fetch(:kind)
       when "render_site"

data/lib/upkeep/subscriptions/active_record_store.rb

@@ -5,7 +5,7 @@ require "active_support/notifications"
 require "securerandom"
 require_relative "active_record_subscription_persistence"
 require_relative "active_registry"
-require_relative "async_durable_writer"
+require_relative "base_store"
 require_relative "json_snapshot"
 require_relative "layered_reverse_index"
 require_relative "persistent_reverse_index"
@@ -14,12 +14,12 @@ require_relative "store"
 
 module Upkeep
   module Subscriptions
-    class ActiveRecordStore
+    class ActiveRecordStore < BaseStore
       LOOKUP_NOTIFICATION = LayeredReverseIndex::LOOKUP_NOTIFICATION
       REGISTER_NOTIFICATION = "register_subscription_store.upkeep"
       ACTIVATE_NOTIFICATION = "activate_subscription_store.upkeep"
       PERSIST_NOTIFICATION = ActiveRecordSubscriptionPersistence::PERSIST_NOTIFICATION
-      DURABILITY_MODE = "async_subscription_row_index_on_subscribe"
+      DURABILITY_MODE = "sync_subscription_row_index_on_subscribe"
       INDEX_DURABILITY = "on_subscribe"
       REQUIRED_SCHEMA = {
         "upkeep_subscriptions" => {
@@ -115,7 +115,6 @@ module Upkeep
           store: "active_record",
           pending_index: pending_registry
         )
-        @durable_writer = AsyncDurableWriter.new { |jobs| persistence.persist_jobs(jobs) }
       end
 
       def self.available?(connect: false)
@@ -170,71 +169,29 @@ module Upkeep
       private_class_method :expected_column_description
 
       def register(subscriber_id:, recorder:, metadata: {}, entries: nil)
-        if ActiveSupport::Notifications.notifier.listening?(REGISTER_NOTIFICATION)
-          payload = { store: "active_record" }
-          ActiveSupport::Notifications.instrument(REGISTER_NOTIFICATION, payload) do
-            register_subscription(subscriber_id, recorder, metadata, entries: entries, payload: payload)
-          end
-        else
-          register_subscription(subscriber_id, recorder, metadata, entries: entries)
+        subscription = with_optional_notification(REGISTER_NOTIFICATION, { store: "active_record" }) do |payload|
+          register_subscription(subscriber_id, recorder, metadata, entries: entries, payload: payload)
         end
+        trim_opportunistically
+        subscription
       end
 
-      def drain = durable_writer.drain
-
       def shutdown
         clear_deferred_index_writes
-        durable_writer.shutdown
       end
 
       def activate(id)
-        if ActiveSupport::Notifications.notifier.listening?(ACTIVATE_NOTIFICATION)
-          payload = { store: "active_record", subscription_id: id }
-          ActiveSupport::Notifications.instrument(ACTIVATE_NOTIFICATION, payload) do
-            activate_subscription(id, payload: payload)
-          end
-        else
-          activate_subscription(id)
+        with_optional_notification(ACTIVATE_NOTIFICATION, { store: "active_record", subscription_id: id }) do |payload|
+          activate_subscription(id, payload: payload)
         end
       end
 
-      def touch(id, now: Time.now)
-        fetch(id)
-        metadata = { "last_seen_at" => now.utc.iso8601 }
-        pending_registry.touch(id, metadata: metadata)
-        active_registry.touch(id, metadata: metadata)
-        activate(id)
-        durable_writer.drain
-        persistence.touch(id, metadata: metadata, now: now)
-      end
-
-      def unregister(ids)
-        ids = Array(ids)
-        pending_registry.unregister(ids)
-        active_registry.unregister(ids)
-        delete_deferred_index_writes(ids)
-        persisted_ids = durable_writer.cancel(ids)
-        persistence.delete(persisted_ids)
-        ids.size
-      end
-
-      def prune_stale!(older_than:)
-        durable_writer.drain
-        stale_ids = persistence.prune_stale!(older_than: older_than)
+      def prune_stale!(older_than: stale_threshold, limit: nil)
+        stale_ids = persistence.prune_stale!(older_than: older_than, limit: limit)
         active_registry.unregister(stale_ids)
         stale_ids.size
       end
 
-      def fetch(id)
-        active_registry.fetch(id) || pending_registry.fetch(id) || persistence.fetch(id)
-      rescue ActiveRecord::RecordNotFound
-        raise NotFound, id
-      end
-
-      def explain(id)
-        fetch(id).explain
-      end
-
       def subscriptions
         persistent_count = persistence.count
         in_memory_subscriptions = (active_registry.subscriptions + pending_registry.subscriptions).to_h do |subscription|
@@ -252,7 +209,6 @@ module Upkeep
 
       def reset
         clear_deferred_index_writes
-        durable_writer.drain
         pending_registry.reset
         active_registry.reset
         persistence.reset
@@ -274,7 +230,27 @@ module Upkeep
 
       private
 
-      attr_reader :subscription_record, :index_record, :shape_index_record, :index_builder, :pending_registry, :active_registry, :persistence, :durable_writer
+      attr_reader :subscription_record, :index_record, :shape_index_record, :index_builder, :pending_registry, :active_registry, :persistence
+
+      def store_label
+        "active_record"
+      end
+
+      def after_touch(id, metadata:, now:)
+        activate(id)
+        persistence.touch(id, metadata: metadata, now: now)
+      end
+
+      def after_unregister(ids)
+        delete_deferred_index_writes(ids)
+        persistence.delete(ids)
+      end
+
+      def fetch_missing(id)
+        persistence.fetch(id)
+      rescue ActiveRecord::RecordNotFound
+        raise NotFound, id
+      end
 
       def register_subscription(subscriber_id, recorder, metadata, entries: nil, payload: nil)
         recorder.flush_pending_dependencies if recorder.respond_to?(:flush_pending_dependencies)
@@ -296,7 +272,7 @@ module Upkeep
         end
 
         pending_registry.register(subscription, entries: entries)
-        durable_writer.enqueue(subscription, entries: entries, operation: :persist_subscription)
+        persist_now(subscription, entries, operation: :persist_subscription)
         defer_index_write(subscription, entries)
         subscription
       end
@@ -312,7 +288,7 @@ module Upkeep
         unless source == :active
           active_registry.register(subscription, entries: entries)
           pending_registry.unregister(id)
-          durable_writer.enqueue(subscription, entries: entries, operation: :persist_index)
+          persist_now(subscription, entries, operation: :persist_index)
         end
 
         if payload
@@ -326,6 +302,25 @@ module Upkeep
         true
       end
 
+      # Synchronous so other processes see the row (registration) and the index
+      # entries (activation) immediately. Persistence failures degrade to
+      # in-process liveness instead of failing the request or the activation.
+      def persist_now(subscription, entries, operation:)
+        persistence.persist_jobs([ActiveRecordSubscriptionPersistence::Job.new(subscription, entries, operation)])
+      rescue StandardError => error
+        warn_persist_failure(subscription, operation, error)
+      end
+
+      def warn_persist_failure(subscription, operation, error)
+        return unless defined?(::Rails) && ::Rails.respond_to?(:logger) && ::Rails.logger
+
+        target = operation == :persist_subscription ? "subscription row" : "index entries"
+        ::Rails.logger.warn(
+          "Upkeep could not persist #{target} for #{subscription.id} " \
+          "(#{error.class}: #{error.message}); the subscription stays live in this process only"
+        )
+      end
+
       def defer_index_write(subscription, entries)
         @deferred_index_mutex.synchronize do
           @deferred_index_writes[subscription.id] = DeferredIndexWrite.new(subscription, entries)
@@ -378,10 +373,6 @@ module Upkeep
           index_builder.entries_for_subscription(subscription)
         end
       end
-
-      def next_subscription_id
-        "subscription-#{SecureRandom.uuid}"
-      end
     end
   end
 end

data/lib/upkeep/subscriptions/active_record_subscription_persistence.rb

@@ -12,6 +12,7 @@ module Upkeep
     class ActiveRecordSubscriptionPersistence
       PERSIST_NOTIFICATION = "persist_subscription_store.upkeep"
       INDEX_ENTRIES_SNAPSHOT_KEY = "__upkeep_index_entries"
+      Job = Data.define(:subscription, :entries, :operation)
 
       def initialize(subscription_record:, index_record:, shape_index_record:, index_builder:)
         @subscription_record = subscription_record
@@ -54,8 +55,10 @@ module Upkeep
         end
       end
 
-      def prune_stale!(older_than:)
-        stale_ids = subscription_record.where(subscription_record.arel_table[:updated_at].lt(older_than)).pluck(:id)
+      def prune_stale!(older_than:, limit: nil)
+        stale = subscription_record.where(subscription_record.arel_table[:updated_at].lt(older_than))
+        stale = stale.order(:updated_at).limit(limit) if limit
+        stale_ids = stale.pluck(:id)
         return [] if stale_ids.empty?
 
         delete(stale_ids)
@@ -254,7 +257,7 @@ module Upkeep
             lookup_attribute: attribute.to_s,
             dependency_table: dependency_key.fetch(:table).to_s,
             dependency_predicate_digest: nil,
-            dependency_metadata_snapshot: nil
+            dependency_metadata_snapshot: dependency_key[:scope] ? dump(scope: dependency_key[:scope]) : nil
           }
         when :active_record_collection_column
           _type, table, attribute = lookup_key

data/lib/upkeep/subscriptions/active_registry.rb

@@ -75,13 +75,6 @@ module Upkeep
           @reverse_index.summary.merge(subscriptions: @subscriptions.size)
         end
       end
-
-      private
-
-      def rebuild_reverse_index!
-        @reverse_index = ReverseIndex.new
-        @subscriptions.each_value { |subscription| @reverse_index.index(subscription) }
-      end
     end
   end
 end

data/lib/upkeep/subscriptions/base_store.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "active_support/notifications"
+
+module Upkeep
+  module Subscriptions
+    # Shared pending -> active registry choreography for the in-memory and
+    # Active Record stores. Subclasses hold the @pending_registry / @active_registry
+    # instances and supply their store-specific tails through the documented hooks.
+    class BaseStore
+      # Opportunistic trim (Solid Cache/Solid Cable style): every TRIM_EVERY
+      # registrations the store deletes at most TRIM_BATCH_LIMIT subscriptions
+      # older than the configured subscription TTL. A deterministic counter is
+      # used instead of rand so the cadence is reproducible in tests.
+      TRIM_EVERY = 100
+      TRIM_BATCH_LIMIT = 500
+      PRUNE_NOTIFICATION = "prune.upkeep"
+      DEFAULT_SUBSCRIPTION_TTL = 24 * 60 * 60
+
+      def touch(id, now: Time.now)
+        fetch(id)
+        metadata = { "last_seen_at" => now.utc.iso8601 }
+        pending_registry.touch(id, metadata: metadata)
+        active_registry.touch(id, metadata: metadata)
+        after_touch(id, metadata: metadata, now: now)
+      end
+
+      def unregister(ids)
+        ids = Array(ids)
+        before_unregister(ids)
+        pending_registry.unregister(ids)
+        active_registry.unregister(ids)
+        after_unregister(ids)
+        ids.size
+      end
+
+      def fetch(id)
+        active_registry.fetch(id) || pending_registry.fetch(id) || fetch_missing(id)
+      end
+
+      def explain(id)
+        fetch(id).explain
+      end
+
+      private
+
+      # Wrap a unit of work in an optional ActiveSupport notification: when a
+      # listener is attached the block runs inside #instrument with the given
+      # payload, otherwise it runs with a nil payload and no instrumentation.
+      def with_optional_notification(notification, payload)
+        if ActiveSupport::Notifications.notifier.listening?(notification)
+          ActiveSupport::Notifications.instrument(notification, payload) do
+            yield payload
+          end
+        else
+          yield nil
+        end
+      end
+
+      # Runs one bounded prune batch every TRIM_EVERY registrations. Failures
+      # never propagate into the registration path: they are logged and the
+      # stale rows stay until the next trim.
+      def trim_opportunistically
+        @trim_registration_count = (@trim_registration_count || 0) + 1
+        return unless (@trim_registration_count % TRIM_EVERY).zero?
+
+        payload = { store: store_label, limit: TRIM_BATCH_LIMIT }
+        ActiveSupport::Notifications.instrument(PRUNE_NOTIFICATION, payload) do
+          payload[:pruned] = prune_stale!(limit: TRIM_BATCH_LIMIT)
+        end
+      rescue StandardError => error
+        warn_trim_failure(error)
+      end
+
+      def warn_trim_failure(error)
+        return unless defined?(::Rails) && ::Rails.respond_to?(:logger) && ::Rails.logger
+
+        ::Rails.logger.warn(
+          "Upkeep opportunistic subscription prune failed " \
+          "(#{error.class}: #{error.message}); stale subscriptions stay until the next trim"
+        )
+      end
+
+      def stale_threshold
+        Time.now - subscription_ttl
+      end
+
+      def subscription_ttl
+        if defined?(Upkeep::Rails) && Upkeep::Rails.respond_to?(:configuration)
+          Upkeep::Rails.configuration.subscription_ttl
+        else
+          DEFAULT_SUBSCRIPTION_TTL
+        end
+      end
+
+      def before_unregister(ids); end
+
+      def after_unregister(ids); end
+
+      def next_subscription_id
+        "subscription-#{SecureRandom.uuid}"
+      end
+    end
+  end
+end

data/lib/upkeep/subscriptions/layered_reverse_index.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
 require "active_support/notifications"
+require_relative "lookup_instrumentation"
 
 module Upkeep
   module Subscriptions
     class LayeredReverseIndex
-      LOOKUP_NOTIFICATION = "lookup_subscription_index.upkeep"
+      include LookupInstrumentation
+
+      LOOKUP_NOTIFICATION = LookupInstrumentation::LOOKUP_NOTIFICATION
 
       def initialize(active_index:, persistent_index:, persistent_count:, store:, pending_index: nil)
         @active_index = active_index
@@ -15,17 +18,6 @@ module Upkeep
         @pending_index = pending_index
       end
 
-      def entries_for(changes)
-        if ActiveSupport::Notifications.notifier.listening?(LOOKUP_NOTIFICATION)
-          payload = { changes: Array(changes).size, store: store }
-          ActiveSupport::Notifications.instrument(LOOKUP_NOTIFICATION, payload) do
-            entries_for_with_payload(changes, payload)
-          end
-        else
-          entries_for_without_payload(changes)
-        end
-      end
-
       def entries_for_without_payload(changes)
         active_entries = active_index.entries_for(changes)
         return persistent_index.entries_for(changes) if active_index.count.zero?
@@ -101,6 +93,10 @@ module Upkeep
 
       attr_reader :active_index, :persistent_index, :persistent_count, :store, :pending_index
 
+      def lookup_store
+        store
+      end
+
       def persistent_subscription_count
         persistent_count.call
       end
@@ -122,7 +118,7 @@ module Upkeep
       def apply_miss_reason(payload, active_entries:, persistent_entries:, pending_entries:)
         return if active_entries.any? || persistent_entries.any?
 
-        payload[:miss_reason] = pending_entries.any? ? "not_activated_yet" : "no_matching_subscriber"
+        payload[:miss_reason] = miss_reason(pending_entries)
       end
     end
   end

data/lib/upkeep/subscriptions/lookup_instrumentation.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "active_support/notifications"
+
+module Upkeep
+  module Subscriptions
+    # Shared lookup instrumentation for the memory and layered reverse indexes:
+    # one notification name, one entries_for dispatch, one miss-reason rule.
+    # Including classes provide #lookup_store, #entries_for_with_payload and
+    # #entries_for_without_payload.
+    module LookupInstrumentation
+      LOOKUP_NOTIFICATION = "lookup_subscription_index.upkeep"
+
+      def entries_for(changes)
+        if ActiveSupport::Notifications.notifier.listening?(LOOKUP_NOTIFICATION)
+          payload = { changes: Array(changes).size, store: lookup_store }
+          ActiveSupport::Notifications.instrument(LOOKUP_NOTIFICATION, payload) do
+            entries_for_with_payload(changes, payload)
+          end
+        else
+          entries_for_without_payload(changes)
+        end
+      end
+
+      private
+
+      def miss_reason(pending_entries)
+        pending_entries.any? ? "not_activated_yet" : "no_matching_subscriber"
+      end
+    end
+  end
+end

data/lib/upkeep/subscriptions/persistent_reverse_index.rb

@@ -188,10 +188,13 @@ module Upkeep
         source = attributes.fetch(:dependency_source).to_sym
         case source
         when :active_record_attribute
+          metadata_snapshot = attributes[:dependency_metadata_snapshot]
+          metadata = metadata_snapshot && JsonSnapshot.load(metadata_snapshot)
           Dependencies::ActiveRecordAttribute.new(
             table: attributes.fetch(:dependency_table),
             id: attributes[:lookup_record_id_snapshot] && JsonSnapshot.load(attributes.fetch(:lookup_record_id_snapshot)),
-            attribute: attributes.fetch(:lookup_attribute)
+            attribute: attributes.fetch(:lookup_attribute),
+            scope: metadata && metadata[:scope]
           )
         when :active_record_collection, :active_record_query
           metadata = JsonSnapshot.load(attributes.fetch(:dependency_metadata_snapshot))