mongoid 6.4.0 → 6.4.7

data/lib/mongoid/persistable/deletable.rb

@@ -64,7 +64,7 @@ module Mongoid
           selector = _parent.atomic_selector
           _root.collection.find(selector).update_one(
               positionally(selector, atomic_deletes),
-              session: session)
+              session: _session)
         end
         true
       end
@@ -80,7 +80,7 @@ module Mongoid
       #
       # @since 4.0.0
       def delete_as_root
-        collection.find(atomic_selector).delete_one(session: session)
+        collection.find(atomic_selector).delete_one(session: _session)
         true
       end
 

data/lib/mongoid/persistable/settable.rb

@@ -25,15 +25,15 @@ module Mongoid
 
             field_and_value_hash = hasherizer(field.split('.'), value)
             field = field_and_value_hash.keys.first.to_s
+            value = field_and_value_hash[field]
 
-            if fields[field] && fields[field].type == Hash && attributes.key?(field)
+            if fields[field] && fields[field].type == Hash && attributes.key?(field) && Hash === value && !value.empty?
               merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
-              value = (attributes[field] || {}).merge(field_and_value_hash[field], &merger)
-              process_attribute(field.to_s, value)
-            else
-              process_attribute(field.to_s, field_and_value_hash[field])
+              value = (attributes[field] || {}).merge(value, &merger)
             end
 
+            process_attribute(field.to_s, value)
+
             unless relations.include?(field.to_s)
               ops[atomic_attribute_name(field)] = attributes[field]
             end

data/lib/mongoid/persistable/updatable.rb

@@ -134,9 +134,9 @@ module Mongoid
           unless updates.empty?
             coll = collection(_root)
             selector = atomic_selector
-            coll.find(selector).update_one(positionally(selector, updates), session: session)
+            coll.find(selector).update_one(positionally(selector, updates), session: _session)
             conflicts.each_pair do |key, value|
-              coll.find(selector).update_one(positionally(selector, { key => value }), session: session)
+              coll.find(selector).update_one(positionally(selector, { key => value }), session: _session)
             end
           end
         end

data/lib/mongoid/persistable/upsertable.rb

@@ -22,7 +22,7 @@ module Mongoid
       def upsert(options = {})
         prepare_upsert(options) do
           collection.find(atomic_selector).update_one(
-              as_attributes, upsert: true, session: session)
+              as_attributes, upsert: true, session: _session)
         end
       end
 

data/lib/mongoid/persistence_context.rb

@@ -107,6 +107,10 @@ module Mongoid
     #
     # @since 6.0.0
     def client
+      client_options = send(:client_options)
+      if client_options[:read].is_a?(Symbol)
+        client_options = client_options.merge(read: {mode: client_options[:read]})
+      end
       @client ||= (client = Clients.with_name(client_name)
                     client = client.use(database_name) if database_name_option
                     client.with(client_options))

data/lib/mongoid/query_cache.rb

@@ -224,14 +224,29 @@ module Mongoid
           unless cursor = cached_cursor
             read_with_retry do
               server = server_selector.select_server(cluster)
-              cursor = CachedCursor.new(view, send_initial_query(server), server)
-              QueryCache.cache_table[cache_key] = cursor
+              result = send_initial_query(server)
+              if result.cursor_id == 0 || result.cursor_id.nil?
+                cursor = CachedCursor.new(view, result, server)
+                QueryCache.cache_table[cache_key] = cursor
+              else
+                cursor = Mongo::Cursor.new(view, result, server)
+              end
             end
           end
-          cursor.each do |doc|
-            yield doc
-          end if block_given?
-          cursor
+
+          if block_given?
+            if limit && limit != -1
+              cursor.to_a[0...limit].each do |doc|
+                yield doc
+              end
+            else
+              cursor.each do |doc|
+                yield doc
+              end
+            end
+          else
+            cursor
+          end
         end
       end
 
@@ -241,10 +256,6 @@ module Mongoid
         if limit
           key = [ collection.namespace, selector, nil, skip, sort, projection, collation  ]
           cursor = QueryCache.cache_table[key]
-          if cursor
-            limited_docs = cursor.to_a[0...limit.abs]
-            cursor.instance_variable_set(:@cached_documents, limited_docs)
-          end
         end
         cursor || QueryCache.cache_table[cache_key]
       end

data/lib/mongoid/railtie.rb

@@ -102,6 +102,23 @@ module Rails
         puts "There is a configuration error with the current mongoid.yml."
         puts e.message
       end
+
+      # Include Controller extension that measures Mongoid runtime
+      # during request processing. The value then appears in Rails'
+      # instrumentation event `process_action.action_controller`.
+      #
+      # The measurement is made via internal Mongo monitoring subscription
+      initializer "mongoid.runtime-metric" do
+        require "mongoid/railties/controller_runtime"
+
+        ActiveSupport.on_load :action_controller do
+          include ::Mongoid::Railties::ControllerRuntime::ControllerExtension
+        end
+
+        Mongo::Monitoring::Global.subscribe Mongo::Monitoring::COMMAND,
+            ::Mongoid::Railties::ControllerRuntime::Collector.new
+      end
+
     end
   end
 end

data/lib/mongoid/railties/controller_runtime.rb

@@ -0,0 +1,86 @@
+module Mongoid
+  module Railties
+    module ControllerRuntime
+
+      # This extension mimics the Rails' internal method to
+      # measure ActiveRecord runtime during request processing.
+      # It appends MongoDB runtime value (`mongoid_runtime`) into payload
+      # of instrumentation event `process_action.action_controller`.
+      module ControllerExtension
+        extend ActiveSupport::Concern
+
+        protected
+
+        attr_internal :mongoid_runtime
+
+        # Reset the runtime before each action.
+        def process_action(action, *args)
+          Collector.reset_runtime
+          super
+        end
+
+        # Override to collect the measurements.
+        def cleanup_view_runtime
+          mongo_rt_before_render = Collector.reset_runtime
+          runtime = super
+          mongo_rt_after_render = Collector.reset_runtime
+          self.mongoid_runtime = mongo_rt_before_render + mongo_rt_after_render
+          runtime - mongo_rt_after_render
+        end
+
+        # Add the measurement to the instrumentation event payload.
+        def append_info_to_payload(payload)
+          super
+          payload[:mongoid_runtime] = (mongoid_runtime || 0) + Collector.reset_runtime
+        end
+
+        module ClassMethods
+
+          # Append MongoDB runtime information to ActionController runtime
+          # log message.
+          def log_process_action(payload)
+            messages = super
+            mongoid_runtime = payload[:mongoid_runtime]
+            messages << ("MongoDB: %.1fms" % mongoid_runtime.to_f) if mongoid_runtime
+            messages
+          end
+
+        end
+
+      end
+
+      # The Collector of MongoDB runtime metric, that subscribes to Mongo
+      # driver command monitoring. Stores the value within a thread-local
+      # variable to provide correct accounting when an application issues
+      # MongoDB operations from background threads.
+      class Collector
+
+        VARIABLE_NAME = "Mongoid.controller_runtime".freeze
+
+        def started _; end
+
+        def _completed e
+          Collector.runtime += e.duration
+        end
+        alias :succeeded :_completed
+        alias :failed :_completed
+
+        def self.runtime
+          Thread.current[VARIABLE_NAME] ||= 0
+        end
+
+        def self.runtime= value
+          Thread.current[VARIABLE_NAME] = value
+        end
+
+        def self.reset_runtime
+          to_now = runtime
+          self.runtime = 0
+          to_now
+        end
+
+      end
+
+    end
+  end
+end

data/lib/mongoid/relations/embedded/batchable.rb

@@ -39,7 +39,7 @@ module Mongoid
           unless docs.empty?
             collection.find(selector).update_one(
               positionally(selector, "$unset" => { path => true }),
-              session: session
+              session: _session
             )
             post_process_batch_remove(docs, :delete)
           end
@@ -60,7 +60,7 @@ module Mongoid
           if !docs.empty?
             collection.find(selector).update_one(
               positionally(selector, "$pullAll" => { path => removals }),
-              session: session
+              session: _session
             )
             post_process_batch_remove(docs, method)
           end
@@ -136,7 +136,7 @@ module Mongoid
           if insertable?
             collection.find(selector).update_one(
                 positionally(selector, '$set' => { path => inserts }),
-                session: session
+                session: _session
             )
             post_process_batch_insert(docs)
           end
@@ -161,7 +161,7 @@ module Mongoid
           if insertable?
             collection.find(selector).update_one(
                 positionally(selector, '$push' => { path => { '$each' => pushes } }),
-                session: session
+                session: _session
             )
             post_process_batch_insert(docs)
           end

data/lib/mongoid/relations/embedded/many.rb

@@ -294,6 +294,29 @@ module Mongoid
           end
         end
 
+        # Shift documents off the relation. This can be a single document or
+        # multiples, and will automatically persist the changes.
+        #
+        # @example Shift a single document.
+        #   relation.shift
+        #
+        # @example Shift multiple documents.
+        #   relation.shift(3)
+        #
+        # @param [ Integer ] count The number of documents to shift, or 1 if not
+        #   provided.
+        #
+        # @return [ Document, Array<Document> ] The shifted document(s).
+        def shift(count = nil)
+          if count
+            if target.size > 0 && docs = target[0, count]
+              docs.each { |doc| delete(doc) }
+            end
+          else
+            delete(target[0])
+          end
+        end
+
         # Substitutes the supplied target documents for the existing documents
         # in the relation.
         #

data/lib/mongoid/relations/many.rb

@@ -213,8 +213,8 @@ module Mongoid
 
       private
 
-      def session
-        base.send(:session)
+      def _session
+        base.send(:_session)
       end
 
       # Find the first object given the supplied attributes or create/initialize it.

data/lib/mongoid/relations/referenced/many.rb

@@ -477,7 +477,7 @@ module Mongoid
         # @since 3.0.0
         def persist_delayed(docs, inserts)
           unless docs.empty?
-            collection.insert_many(inserts, session: session)
+            collection.insert_many(inserts, session: _session)
             docs.each do |doc|
               doc.new_record = false
               doc.run_after_callbacks(:create, :save)

data/lib/mongoid/relations/touchable.rb

@@ -31,7 +31,7 @@ module Mongoid
         touches = touch_atomic_updates(field)
         unless touches["$set"].blank?
           selector = atomic_selector
-          _root.collection.find(selector).update_one(positionally(selector, touches), session: session)
+          _root.collection.find(selector).update_one(positionally(selector, touches), session: _session)
         end
         run_callbacks(:touch)
         true

data/lib/mongoid/reloadable.rb

@@ -58,7 +58,7 @@ module Mongoid
     #
     # @since 2.3.2
     def reload_root_document
-      {}.merge(collection.find({ _id: _id }, session: session).read(mode: :primary).first || {})
+      {}.merge(collection.find({ _id: _id }, session: _session).read(mode: :primary).first || {})
     end
 
     # Reload the embedded document.

data/lib/mongoid/scopable.rb

@@ -102,7 +102,7 @@ module Mongoid
       #
       # @since 3.0.0
       def default_scopable?
-        default_scoping? && !Threaded.executing?(:without_default_scope)
+        default_scoping? && !Threaded.without_default_scope?(self)
       end
 
       # Get a queryable, either the last one on the scope stack or a fresh one.
@@ -244,10 +244,10 @@ module Mongoid
       #
       # @since 3.0.0
       def without_default_scope
-        Threaded.begin_execution("without_default_scope")
+        Threaded.begin_without_default_scope(self)
         yield
       ensure
-        Threaded.exit_execution("without_default_scope")
+        Threaded.exit_without_default_scope(self)
       end
 
       private

data/lib/mongoid/tasks/database.rb

@@ -44,7 +44,7 @@ module Mongoid
         models.each do |model|
           unless model.embedded?
             begin
-              model.collection.indexes(session: model.send(:session)).each do |index|
+              model.collection.indexes(session: model.send(:_session)).each do |index|
                 # ignore default index
                 unless index['name'] == '_id_'
                   key = index['key'].symbolize_keys
@@ -77,7 +77,7 @@ module Mongoid
           indexes.each do |index|
             key = index['key'].symbolize_keys
             collection = model.collection
-            collection.indexes(session: model.send(:session)).drop_one(key)
+            collection.indexes(session: model.send(:_session)).drop_one(key)
             logger.info(
               "MONGOID: Removed index '#{index['name']}' on collection " +
               "'#{collection.name}' in database '#{collection.database.name}'."

data/lib/mongoid/threaded.rb

@@ -163,6 +163,30 @@ module Mongoid
       validations_for(document.class).delete_one(document._id)
     end
 
+    # Begin suppressing default scopes for given model on the current thread.
+    #
+    # @example Begin without default scope stack.
+    #   Threaded.begin_without_default_scope(klass)
+    #
+    # @param [ Class ] klass The model to suppress default scoping on.
+    #
+    # @api private
+    def begin_without_default_scope(klass)
+      stack(:without_default_scope).push(klass)
+    end
+
+    # Exit suppressing default scopes for given model on the current thread.
+    #
+    # @example Exit without default scope stack.
+    #   Threaded.exit_without_default_scope(klass)
+    #
+    # @param [ Class ] klass The model to unsuppress default scoping on.
+    #
+    # @api private
+    def exit_without_default_scope(klass)
+      stack(:without_default_scope).delete(klass)
+    end
+
     # Get the global client override.
     #
     # @example Get the global client override.
@@ -247,6 +271,18 @@ module Mongoid
       end
     end
 
+    # Is the given klass' default scope suppressed on the current thread?
+    #
+    # @example Is the given klass' default scope suppressed?
+    #   Threaded.without_default_scope?(klass)
+    #
+    # @param [ Class ] klass The model to check for default scope suppression.
+    #
+    # @api private
+    def without_default_scope?(klass)
+      stack(:without_default_scope).include?(klass)
+    end
+
     # Is the document autosaved on the current thread?
     #
     # @example Is the document autosaved?

data/lib/mongoid/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 module Mongoid
-  VERSION = "6.4.0"
+  VERSION = "6.4.7"
 end

data/lib/rails/generators/mongoid/config/templates/mongoid.yml

@@ -11,6 +11,10 @@ development:
       hosts:
         - localhost:27017
       options:
+        # Note that all options listed below are Ruby driver client options (the mongo gem).
+        # Please refer to the driver documentation of the version of the mongo gem you are using
+        # for the most up-to-date list of options.
+        #
         # Change the default write concern. (default = { w: 1 })
         # write:
         #   w: 1