mongoid 5.4.1 → 7.4.0

data/lib/mongoid/query_cache.rb

@@ -1,22 +1,30 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 module Mongoid
 
   # A cache of database queries on a per-request basis.
-  #
-  # @since 4.0.0
   module QueryCache
-    class << self
+    # @api private
+    LEGACY_WARNING = <<~DOC
+      You are using the legacy Mongoid query cache which has known issues.
+      Please upgrade the `mongo' gem to at least 2.14.0 to use the improved driver query cache.
+      Refer to: https://docs.mongodb.com/mongoid/current/tutorials/mongoid-queries/#the-improved-driver-query-cache
+    DOC
 
+    class << self
       # Get the cached queries.
       #
       # @example Get the cached queries from the current thread.
       #   QueryCache.cache_table
       #
       # @return [ Hash ] The hash of cached queries.
-      #
-      # @since 4.0.0
+      # @api private
       def cache_table
-        Thread.current["[mongoid]:query_cache"] ||= {}
+        if defined?(Mongo::QueryCache)
+          raise NotImplementedError, "Mongoid does not expose driver's query cache table"
+        else
+          Thread.current["[mongoid]:query_cache"] ||= {}
+        end
       end
 
       # Clear the query cache.
@@ -25,10 +33,12 @@ module Mongoid
       #   QueryCache.clear_cache
       #
       # @return [ nil ] Always nil.
-      #
-      # @since 4.0.0
       def clear_cache
-        Thread.current["[mongoid]:query_cache"] = nil
+        if defined?(Mongo::QueryCache)
+          Mongo::QueryCache.clear
+        else
+          Thread.current["[mongoid]:query_cache"] = nil
+        end
       end
 
       # Set whether the cache is enabled.
@@ -37,10 +47,12 @@ module Mongoid
       #   QueryCache.enabled = true
       #
       # @param [ true, false ] value The enabled value.
-      #
-      # @since 4.0.0
       def enabled=(value)
-        Thread.current["[mongoid]:query_cache:enabled"] = value
+        if defined?(Mongo::QueryCache)
+          Mongo::QueryCache.enabled = value
+        else
+          Thread.current["[mongoid]:query_cache:enabled"] = value
+        end
       end
 
       # Is the query cache enabled on the current thread?
@@ -49,10 +61,12 @@ module Mongoid
       #   QueryCache.enabled?
       #
       # @return [ true, false ] If the cache is enabled.
-      #
-      # @since 4.0.0
       def enabled?
-        !!Thread.current["[mongoid]:query_cache:enabled"]
+        if defined?(Mongo::QueryCache)
+          Mongo::QueryCache.enabled?
+        else
+          !!Thread.current["[mongoid]:query_cache:enabled"]
+        end
       end
 
       # Execute the block while using the query cache.
@@ -61,14 +75,22 @@ module Mongoid
       #   QueryCache.cache { collection.find }
       #
       # @return [ Object ] The result of the block.
-      #
-      # @since 4.0.0
-      def cache
-        enabled = QueryCache.enabled?
-        QueryCache.enabled = true
-        yield
-      ensure
-        QueryCache.enabled = enabled
+      def cache(&block)
+        if defined?(Mongo::QueryCache)
+          Mongo::QueryCache.cache(&block)
+        else
+          @legacy_query_cache_warned ||= begin
+            Mongoid.logger.warn(LEGACY_WARNING)
+            true
+          end
+          enabled = QueryCache.enabled?
+          QueryCache.enabled = true
+          begin
+            yield
+          ensure
+            QueryCache.enabled = enabled
+          end
+        end
       end
 
       # Execute the block with the query cache disabled.
@@ -77,54 +99,59 @@ module Mongoid
       #   QueryCache.uncached { collection.find }
       #
       # @return [ Object ] The result of the block.
-      def uncached
-        enabled = QueryCache.enabled?
-        QueryCache.enabled = false
-        yield
-      ensure
-        QueryCache.enabled = enabled
+      def uncached(&block)
+        if defined?(Mongo::QueryCache)
+          Mongo::QueryCache.uncached(&block)
+        else
+          enabled = QueryCache.enabled?
+          QueryCache.enabled = false
+          begin
+            yield
+          ensure
+            QueryCache.enabled = enabled
+          end
+        end
       end
     end
 
-    # The middleware to be added to a rack application in order to activate the
-    # query cache.
-    #
-    # @since 4.0.0
-    class Middleware
+    if defined?(Mongo::QueryCache::Middleware)
+      Middleware = Mongo::QueryCache::Middleware
+    else
+      # The middleware to be added to a rack application in order to activate the
+      # query cache.
+      class Middleware
 
-      # Instantiate the middleware.
-      #
-      # @example Create the new middleware.
-      #   Middleware.new(app)
-      #
-      # @param [ Object ] app The rack applciation stack.
-      #
-      # @since 4.0.0
-      def initialize(app)
-        @app = app
-      end
+        # Instantiate the middleware.
+        #
+        # @example Create the new middleware.
+        #   Middleware.new(app)
+        #
+        # @param [ Object ] app The rack application stack.
+        def initialize(app)
+          @app = app
+        end
 
-      # Execute the request, wrapping in a query cache.
-      #
-      # @example Execute the request.
-      #   middleware.call(env)
-      #
-      # @param [ Object ] env The environment.
-      #
-      # @return [ Object ] The result of the call.
-      #
-      # @since 4.0.0
-      def call(env)
-        QueryCache.cache { @app.call(env) }
-      ensure
-        QueryCache.clear_cache
+        # Execute the request, wrapping in a query cache.
+        #
+        # @example Execute the request.
+        #   middleware.call(env)
+        #
+        # @param [ Object ] env The environment.
+        #
+        # @return [ Object ] The result of the call.
+        def call(env)
+          QueryCache.cache do
+            @app.call(env)
+          end
+        ensure
+          QueryCache.clear_cache
+        end
       end
     end
 
     # A Cursor that attempts to load documents from memory first before hitting
     # the database if the same query has already been executed.
-    #
-    # @since 5.0.0
+    # @deprecated This class is only used with driver versions 2.13 and lower.
     class CachedCursor < Mongo::Cursor
 
       # We iterate over the cached documents if they exist already in the
@@ -134,11 +161,11 @@ module Mongoid
       #   cursor.each do |doc|
       #     # ...
       #   end
-      #
-      # @since 5.0.0
       def each
         if @cached_documents
-          @cached_documents.each{ |doc| yield doc }
+          @cached_documents.each do |doc|
+            yield doc
+          end
         else
           super
         end
@@ -150,8 +177,6 @@ module Mongoid
       #   cursor.inspect
       #
       # @return [ String ] A string representation of a +Cursor+ instance.
-      #
-      # @since 2.0.0
       def inspect
         "#<Mongoid::QueryCache::CachedCursor:0x#{object_id} @view=#{@view.inspect}>"
       end
@@ -159,39 +184,37 @@ module Mongoid
       private
 
       def process(result)
-        @remaining -= result.returned_count if limited?
-        @cursor_id = result.cursor_id
-        @coll_name ||= result.namespace.sub("#{database.name}.", '') if result.namespace
-        documents = result.documents
-        (@cached_documents ||= []).concat(documents)
+        documents = super
+        if @cursor_id.zero? && !@after_first_batch
+          @cached_documents ||= []
+          @cached_documents.concat(documents)
+        end
+        @after_first_batch = true
         documents
       end
     end
 
-    # Included to add behaviour for clearing out the query cache on certain
+    # Included to add behavior for clearing out the query cache on certain
     # operations.
-    #
-    # @since 4.0.0
+    # @deprecated This module is only used with driver versions 2.13 and lower.
     module Base
 
       def alias_query_cache_clear(*method_names)
         method_names.each do |method_name|
-          class_eval <<-CODE, __FILE__, __LINE__ + 1
-              def #{method_name}_with_clear_cache(*args)
-                QueryCache.clear_cache
-                #{method_name}_without_clear_cache(*args)
-              end
-            CODE
+          define_method("#{method_name}_with_clear_cache") do |*args|
+            QueryCache.clear_cache
+            send("#{method_name}_without_clear_cache", *args)
+          end
 
-          alias_method_chain method_name, :clear_cache
+          alias_method "#{method_name}_without_clear_cache", method_name
+          alias_method method_name, "#{method_name}_with_clear_cache"
         end
       end
     end
 
     # Contains enhancements to the Mongo::Collection::View in order to get a
     # cached cursor or a regular cursor on iteration.
-    #
-    # @since 5.0.0
+    # @deprecated This module is only used with driver versions 2.13 and lower.
     module View
       extend ActiveSupport::Concern
 
@@ -214,38 +237,45 @@ module Mongoid
       #   view.each do |doc|
       #     # ...
       #   end
-      #
-      # @since 5.0.0
       def each
-        if system_collection? || !QueryCache.enabled?
+        if system_collection? || !QueryCache.enabled? || (respond_to?(:write?, true) && write?)
           super
         else
-          unless cursor = cached_cursor
-            server = read_or_server_selector.select_server(cluster)
-            cursor = CachedCursor.new(view, send_initial_query(server), server)
-            QueryCache.cache_table[cache_key] = cursor
+          @cursor = nil
+          unless @cursor = cached_cursor
+            session = client.send(:get_session, @options)
+            read_with_retry(session, server_selector) do |server|
+              result = send_initial_query(server, session)
+              if result.cursor_id == 0 || result.cursor_id.nil?
+                @cursor = CachedCursor.new(view, result, server, session: session)
+                QueryCache.cache_table[cache_key] = @cursor
+              else
+                @cursor = Mongo::Cursor.new(view, result, server, session: session)
+              end
+            end
+          end
+          if block_given?
+            if limit
+              @cursor.to_a[0...limit].each do |doc|
+                yield doc
+              end
+            else
+              @cursor.each do |doc|
+                yield doc
+              end
+            end
+          else
+            @cursor.to_enum
           end
-          cursor.each do |doc|
-            yield doc
-          end if block_given?
-          cursor
         end
       end
 
       private
 
-      def read_or_server_selector
-        respond_to?(:server_selector, true) ? server_selector : read
-      end
-
       def cached_cursor
         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
@@ -255,13 +285,12 @@ module Mongoid
       end
 
       def system_collection?
-        collection.namespace =~ /^system./
+        collection.name.start_with?('system.')
       end
     end
 
-    # Adds behaviour to the query cache for collections.
-    #
-    # @since 5.0.0
+    # Adds behavior to the query cache for collections.
+    # @deprecated This module is only used with driver versions 2.13 and lower.
     module Collection
       extend ActiveSupport::Concern
 
@@ -280,6 +309,8 @@ module Mongoid
   end
 end
 
-Mongo::Collection.__send__(:include, Mongoid::QueryCache::Collection)
-Mongo::Collection::View.__send__(:include, Mongoid::QueryCache::View)
-Mongoid::Document.__send__(:include, Mongoid::QueryCache::Document)
+unless defined?(Mongo::QueryCache)
+  Mongo::Collection.__send__(:include, Mongoid::QueryCache::Collection)
+  Mongo::Collection::View.__send__(:include, Mongoid::QueryCache::View)
+  Mongoid::Document.__send__(:include, Mongoid::QueryCache::Document)
+end

data/lib/mongoid/railtie.rb

@@ -1,5 +1,5 @@
-# encoding: utf-8
-require "mongoid/railties/document"
+# frozen_string_literal: true
+
 require "rails"
 require "rails/mongoid"
 
@@ -7,8 +7,6 @@ module Rails
   module Mongoid
 
     # Hooks Mongoid into Rails 3 and higher.
-    #
-    # @since 2.0.0
     class Railtie < Rails::Railtie
 
       # Mapping of rescued exceptions to HTTP responses
@@ -17,8 +15,6 @@ module Rails
       #   railtie.rescue_responses
       #
       # @ return [Hash] rescued responses
-      #
-      # @since 2.4.3
       def self.rescue_responses
         {
           "Mongoid::Errors::DocumentNotFound" => :not_found,
@@ -41,17 +37,13 @@ module Rails
       # @example Set up configuration in the Rails app.
       #   module MyApplication
       #     class Application < Rails::Application
-      #       config.mongoid.logger = Logger.new($stdout, :warn)
+      #       config.mongoid.logger = Logger.new(STDERR, :warn)
       #     end
       #   end
-      #
-      # @since 2.0.0
       config.mongoid = ::Mongoid::Config
 
       # Initialize Mongoid. This will look for a mongoid.yml in the config
       # directory and configure mongoid appropriately.
-      #
-      # @since 2.0.0
       initializer "mongoid.load-config" do
         config_file = Rails.root.join("config", "mongoid.yml")
         if config_file.file?
@@ -71,8 +63,6 @@ module Rails
 
       # Set the proper error types for Rails. DocumentNotFound errors should be
       # 404s and not 500s, validation errors are 422s.
-      #
-      # @since 2.0.0
       config.after_initialize do
         unless config.action_dispatch.rescue_responses
           ActionDispatch::ShowExceptions.rescue_responses.update(Railtie.rescue_responses)
@@ -85,8 +75,6 @@ module Rails
       #
       # This will happen for every request in development, once in other
       # environments.
-      #
-      # @since 2.0.0
       initializer "mongoid.preload-models" do |app|
         config.to_prepare do
           ::Rails::Mongoid.preload_models(app)
@@ -97,12 +85,27 @@ module Rails
       # code, so we have no way in the intitializer to know if we are
       # generating a mongoid.yml. So instead of failing, we catch all the
       # errors and print them out.
-      #
-      # @since 3.0.0
       def handle_configuration_error(e)
         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,88 @@
+# frozen_string_literal: true
+
+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/railties/database.rake

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 load 'mongoid/tasks/database.rake'
 
 namespace :db do
@@ -58,13 +60,20 @@ namespace :db do
   end
 
   unless Rake::Task.task_defined?("db:create_indexes")
+    desc "Create indexes specified in Mongoid models"
     task :create_indexes => "mongoid:create_indexes"
   end
 
   unless Rake::Task.task_defined?("db:remove_indexes")
+    desc "Remove indexes specified in Mongoid models"
     task :remove_indexes => "mongoid:remove_indexes"
   end
 
+  unless Rake::Task.task_defined?("db:shard_collections")
+    desc "Shard collections with shard keys specified in Mongoid models"
+    task :shard_collections => "mongoid:shard_collections"
+  end
+
   namespace :mongoid do
     task :load_models do
       ::Rails.application.eager_load! if defined?(::Rails)

data/lib/mongoid/reloadable.rb

@@ -1,9 +1,8 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 module Mongoid
 
-  # This module handles reloading behaviour of documents.
-  #
-  # @since 4.0.0
+  # This module handles reloading behavior of documents.
   module Reloadable
 
     # Reloads the +Document+ attributes from the database. If the document has
@@ -16,11 +15,14 @@ module Mongoid
     # @raise [ Errors::DocumentNotFound ] If the document was deleted.
     #
     # @return [ Document ] The document, reloaded.
-    #
-    # @since 1.0.0
     def reload
+      if @atomic_selector
+        # Clear atomic_selector cache for sharded clusters. MONGOID-5076
+        remove_instance_variable('@atomic_selector')
+      end
+
       reloaded = _reload
-      if Mongoid.raise_not_found_error && reloaded.empty?
+      if Mongoid.raise_not_found_error && (reloaded.nil? || reloaded.empty?)
         raise Errors::DocumentNotFound.new(self.class, _id, _id)
       end
       @attributes = reloaded
@@ -37,14 +39,12 @@ module Mongoid
     private
 
     # Reload the document, determining if it's embedded or not and what
-    # behaviour to use.
+    # behavior to use.
     #
     # @example Reload the document.
     #   document._reload
     #
     # @return [ Hash ] The reloaded attributes.
-    #
-    # @since 2.3.2
     def _reload
       embedded? ? reload_embedded_document : reload_root_document
     end
@@ -55,10 +55,8 @@ module Mongoid
     #   document.reload_root_document
     #
     # @return [ Hash ] The reloaded attributes.
-    #
-    # @since 2.3.2
     def reload_root_document
-      {}.merge(collection.find(_id: _id).read(mode: :primary).first || {})
+      {}.merge(collection.find(atomic_selector, session: _session).read(mode: :primary).first || {})
     end
 
     # Reload the embedded document.
@@ -67,11 +65,9 @@ module Mongoid
     #   document.reload_embedded_document
     #
     # @return [ Hash ] The reloaded attributes.
-    #
-    # @since 2.3.2
     def reload_embedded_document
       extract_embedded_attributes({}.merge(
-        _root.collection.find(_id: _root._id).read(mode: :primary).first
+        collection(_root).find(_root.atomic_selector, session: _session).read(mode: :primary).first
       ))
     end
 
@@ -82,9 +78,8 @@ module Mongoid
     #
     # @param [ Hash ] attributes The document in the db.
     #
-    # @return [ Hash ] The document's extracted attributes.
-    #
-    # @since 2.3.2
+    # @return [ Hash | nil ] The document's extracted attributes or nil if the
+    #   document doesn't exist.
     def extract_embedded_attributes(attributes)
       atomic_position.split(".").inject(attributes) do |attrs, part|
         attrs = attrs[part =~ /\d/ ? part.to_i : part]