[~] Fix cache freshness for time zones and mutable values

Author: skcc321

lib/mongoid/attributes.rb

@@ -181,6 +181,45 @@ def demongoized_cache
     end
     private :demongoized_cache
 
+    # Demongoize and cache a raw field value together with any metadata needed
+    # to determine whether the cached value remains valid.
+    #
+    # Set and Range demongoize into objects that are distinct from their raw
+    # Array or Hash values, so retain a deep copy to detect in-place raw-value
+    # mutations. Time and DateTime demongoization depends on the configured
+    # UTC behavior and the current thread's time zone, so retain that context.
+    #
+    # @param [ Hash ] cache The document's demongoized value cache.
+    # @param [ String ] name The field name.
+    # @param [ Object ] raw The raw field value.
+    # @param [ Field ] field The field definition.
+    # @param [ true | false ] track_raw_content Whether to snapshot raw content.
+    # @param [ true | false ] track_time_zone Whether to retain time zone context.
+    #
+    # @return [ Object ] The demongoized field value.
+    #
+    # @api private
+    def cache_demongoized_value(cache, name, raw, field, track_raw_content, track_time_zone)
+      if track_time_zone
+        use_utc = Mongoid::Config.use_utc?
+        time_zone = use_utc ? nil : ::Time.zone
+      end
+
+      demongoized = process_raw_attribute(name, raw, field)
+
+      cache[name] =
+        if track_raw_content
+          [ raw, demongoized, raw.__deep_copy__ ]
+        elsif track_time_zone
+          [ raw, demongoized, use_utc, time_zone ]
+        else
+          [ raw, demongoized ]
+        end
+
+      demongoized
+    end
+    private :cache_demongoized_value
+
     # Lazily allocate projector cache to avoid document initialization overhead.
     #
     # @return [ Concurrent::Map | nil ] The cache map when caching is enabled.

lib/mongoid/fields.rb

@@ -703,6 +703,8 @@ def create_field_getter(name, meth, field)
         object_id_field = (name == :_id || name == "_id") && field.object_id_field?
         boolean_field = field_type == Mongoid::Boolean
         fast_raw_field = FAST_RAW_FIELD_TYPES.include?(field_type) || boolean_field
+        track_raw_content = field_type == Set || field_type == Range
+        track_time_zone = field_type == Time || field_type == DateTime
 
         generated_methods.module_eval do
           re_define_method(meth) do
@@ -729,19 +731,25 @@ def create_field_getter(name, meth, field)
               cache = demongoized_cache
 
               if value = cache[name]
-                if value[0].equal?(raw)
+                cache_valid = value[0].equal?(raw)
+
+                if cache_valid && track_raw_content
+                  cache_valid = value[2] == raw
+                elsif cache_valid && track_time_zone
+                  use_utc = Mongoid::Config.use_utc?
+                  time_zone = use_utc ? nil : ::Time.zone
+                  cache_valid = value[2] == use_utc && value[3] == time_zone
+                end
+
+                if cache_valid
                   demongoized_value = value[1]
                   attribute_will_change!(name_string) if track_resizable
                   demongoized_value
                 else
-                  demongoized = process_raw_attribute(name_string, raw, field)
-                  cache[name] = [raw, demongoized]
-                  demongoized
+                  cache_demongoized_value(cache, name, raw, field, track_raw_content, track_time_zone)
                 end
               else
-                demongoized = process_raw_attribute(name_string, raw, field)
-                cache[name] = [raw, demongoized]
-                demongoized
+                cache_demongoized_value(cache, name, raw, field, track_raw_content, track_time_zone)
               end
             else
               # Caching disabled - use original behavior

spec/mongoid/fields/performance_spec.rb

@@ -113,6 +113,20 @@
         stats = AllocationStats.trace { 10.times { band.decibels } }
         expect(stats.new_allocations.size).to eq(0)
       end
+
+      it 'achieves zero allocations for Set fields' do
+        set_band_class = Class.new do
+          include Mongoid::Document
+          store_in collection: 'bands'
+          field :genres, type: Set
+        end
+        stub_const('SetBand', set_band_class)
+
+        band = SetBand.new(genres: Set.new(%w[rock metal]))
+        band.genres # warm up
+        stats = AllocationStats.trace { 10.times { band.genres } }
+        expect(stats.new_allocations.size).to eq(0)
+      end
     end
 
     context 'field access after setter' do
@@ -212,6 +226,52 @@
       end
     end
 
+    context 'timezone-dependent caching' do
+      config_override :use_utc, false
+
+      let(:time_zone_class) do
+        Class.new do
+          include Mongoid::Document
+          field :occurred_at, type: Time
+          field :scheduled_at, type: DateTime
+        end
+      end
+
+      before do
+        stub_const('TimeZoneCacheTest', time_zone_class)
+      end
+
+      it 'refreshes a cached Time when Time.zone changes' do
+        document = TimeZoneCacheTest.new(occurred_at: Time.utc(2024, 1, 1, 12))
+
+        utc = Time.use_zone('UTC') { document.occurred_at }
+        pacific = Time.use_zone('Pacific Time (US & Canada)') { document.occurred_at }
+        utc_again = Time.use_zone('UTC') { document.occurred_at }
+
+        expect(utc.time_zone.name).to eq('UTC')
+        expect(utc.hour).to eq(12)
+        expect(pacific.time_zone.name).to eq('Pacific Time (US & Canada)')
+        expect(pacific.hour).to eq(4)
+        expect(utc_again.time_zone.name).to eq('UTC')
+        expect(utc_again.hour).to eq(12)
+      end
+
+      it 'refreshes a cached DateTime when Time.zone changes' do
+        document = TimeZoneCacheTest.new(scheduled_at: Time.utc(2024, 1, 1, 12))
+
+        utc = Time.use_zone('UTC') { document.scheduled_at }
+        pacific = Time.use_zone('Pacific Time (US & Canada)') { document.scheduled_at }
+        utc_again = Time.use_zone('UTC') { document.scheduled_at }
+
+        expect(utc.offset).to eq(0)
+        expect(utc.hour).to eq(12)
+        expect(pacific.offset).to eq(Rational(-8, 24))
+        expect(pacific.hour).to eq(4)
+        expect(utc_again.offset).to eq(0)
+        expect(utc_again.hour).to eq(12)
+      end
+    end
+
     context 'database persistence' do
       before { band.save! }
 
@@ -328,6 +388,29 @@
         expect(band.tags).to eq({ 'genre' => 'jazz', 'era' => '80s' })
       end
 
+      it 'gets fresh Set and Range values after in-place raw attribute mutation' do
+        raw_mutation_class = Class.new do
+          include Mongoid::Document
+          field :genres, type: Set
+          field :decibels, type: Range
+        end
+        stub_const('RawMutationCacheTest', raw_mutation_class)
+
+        document = RawMutationCacheTest.new(
+          genres: Set.new(%w[rock metal]),
+          decibels: (50..120)
+        )
+
+        expect(document.genres).to eq(Set.new(%w[rock metal]))
+        expect(document.decibels).to eq(50..120)
+
+        document.attributes['genres'] << 'jazz'
+        document.attributes['decibels']['max'] = 130
+
+        expect(document.genres).to eq(Set.new(%w[rock metal jazz]))
+        expect(document.decibels).to eq(50..130)
+      end
+
       it 'clears cache when attribute is removed' do
         band.name # cache it
         expect(band.name).to eq('Test Band')