sunspot_rails 1.2.1 → 1.3.0.rc6

data/lib/sunspot/rails/log_subscriber.rb

@@ -0,0 +1,33 @@
+module Sunspot
+  module Rails
+    class LogSubscriber < ActiveSupport::LogSubscriber
+      def self.runtime=(value)
+        Thread.current["sorl_runtime"] = value
+      end
+
+      def self.runtime
+        Thread.current["sorl_runtime"] ||= 0
+      end
+
+      def self.reset_runtime
+        rt, self.runtime = runtime, 0
+        rt
+      end
+
+      def request(event)
+        self.class.runtime += event.duration
+        return unless logger.debug?
+
+        name = '%s (%.1fms)' % ["SOLR Request", event.duration]
+
+        # produces: path=/select parameters={fq: ["type:Tag"], q: rossi, fl: * score, qf: tag_name_text, defType: dismax, start: 0, rows: 20}
+        parameters = event.payload[:parameters].map { |k, v| "#{k}: #{color(v, BOLD, true)}" }.join(', ')
+        request = "path=#{event.payload[:path]} parameters={#{parameters}}"
+
+        debug "  #{color(name, GREEN, true)}  [ #{request} ]"
+      end
+    end
+  end
+end
+
+Sunspot::Rails::LogSubscriber.attach_to :rsolr

data/lib/sunspot/rails/railtie.rb

@@ -11,6 +11,16 @@ module Sunspot
         ActiveSupport.on_load(:action_controller) do
           include(Sunspot::Rails::RequestLifecycle)
         end
+        require 'sunspot/rails/log_subscriber'
+        RSolr::Connection.module_eval{ include Sunspot::Rails::SolrInstrumentation }
+      end
+
+      # Expose database runtime to controller for logging.
+      initializer "sunspot_rails.log_runtime" do |app|
+        require "sunspot/rails/railties/controller_runtime"
+        ActiveSupport.on_load(:action_controller) do
+          include Sunspot::Rails::Railties::ControllerRuntime
+        end
       end
 
       rake_tasks do

data/lib/sunspot/rails/railties/controller_runtime.rb

@@ -0,0 +1,36 @@
+module Sunspot
+  module Rails
+    module Railties
+      module ControllerRuntime
+        extend ActiveSupport::Concern
+
+        protected
+
+        attr_internal :solr_runtime
+
+        def cleanup_view_runtime
+          # TODO only if solr is connected? if not call to super
+
+          solr_rt_before_render = Sunspot::Rails::LogSubscriber.reset_runtime
+          runtime = super
+          solr_rt_after_render = Sunspot::Rails::LogSubscriber.reset_runtime
+          self.solr_runtime = solr_rt_before_render + solr_rt_after_render
+          runtime - solr_rt_after_render
+        end
+
+        def append_info_to_payload(payload)
+          super
+          payload[:solr_runtime] = solr_runtime
+        end
+
+        module ClassMethods
+          def log_process_action(payload)
+            messages, solr_runtime = super, payload[:solr_runtime]
+            messages << ("Solr: %.1fms" % solr_runtime.to_f) if solr_runtime
+            messages
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/rails/searchable.rb

@@ -36,6 +36,13 @@ module Sunspot #:nodoc:
         #   Automatically remove models from the Solr index when they are
         #   destroyed. <b>Setting this option to +false+ is not recommended
         #   </b>(see the README).
+        # :if<Mixed>::
+        #   Only index models in Solr if the method, proc or string evaluates
+        #   to true (e.g. <code>:if => :should_index?</code> or <code>:if =>
+        #   proc { |model| model.foo > 2 }</code>).  Models that do not match
+        #   the constraint will be removed from the index upon save.  Multiple
+        #   constraints can be specified by passing an array (e.g. <code>:if =>
+        #   [:method1, :method2]</code>).
         # :ignore_attribute_changes_of<Array>::
         #   Define attributes, that should not trigger a reindex of that
         #   object. Usual suspects are updated_at or counters.
@@ -44,6 +51,13 @@ module Sunspot #:nodoc:
         #   to load required associations when indexing. See ActiveRecord's 
         #   documentation on eager-loading for examples on how to set this
         #   Default: [] 
+        # :unless<Mixed>::
+        #   Only index models in Solr if the method, proc or string evaluates
+        #   to false (e.g. <code>:unless => :should_not_index?</code> or <code>
+        #   :unless => proc { |model| model.foo <= 2 }</code>).  Models that do
+        #   not match the constraint will be removed from the index upon save.
+        #   Multiple constraints can be specified by passing an array (e.g.
+        #   <code>:unless => [:method1, :method2]</code>).
         #
         # ==== Example
         #
@@ -67,11 +81,11 @@ module Sunspot #:nodoc:
             extend ClassMethods
             include InstanceMethods
 
-            class_inheritable_hash :sunspot_options
-            
+            class_attribute :sunspot_options
+
             unless options[:auto_index] == false
-              before_save :maybe_mark_for_auto_indexing
-              after_save :maybe_auto_index
+              before_save :mark_for_auto_indexing_or_removal
+              after_save :perform_index_tasks
             end
 
             unless options[:auto_remove] == false
@@ -227,22 +241,31 @@ module Sunspot #:nodoc:
             :batch_size => 50,
             :batch_commit => true,
             :include => self.sunspot_options[:include],
-            :first_id => 0
+            :start => opts.delete(:first_id) || 0
           }.merge(opts)
-
+          find_in_batch_options = {
+            :include => options[:include],
+            :batch_size => options[:batch_size],
+            :start => options[:first_id]
+          }
+          progress_bar = options[:progress_bar]
           if options[:batch_size]
-            counter = 0
-            find_in_batches(:include => options[:include], :batch_size => options[:batch_size]) do |records|
-              solr_benchmark options[:batch_size], counter do
-                Sunspot.index(records)
+            batch_counter = 0
+            find_in_batches(find_in_batch_options) do |records|
+              solr_benchmark options[:batch_size], batch_counter do
+                Sunspot.index(records.select { |model| model.indexable? })
+                Sunspot.commit if options[:batch_commit]
               end
-              Sunspot.commit if options[:batch_commit]
-              counter += 1
+              # track progress
+              progress_bar.increment!(records.length) if progress_bar
+              batch_counter += 1
             end
-            Sunspot.commit unless options[:batch_commit]
           else
-            Sunspot.index!(all(:include => options[:include]))
+            records = all(:include => options[:include]).select { |model| model.indexable? }
+            Sunspot.index!(records)
           end
+          # perform a final commit if not committing in batches
+          Sunspot.commit unless options[:batch_commit]
         end
 
         # 
@@ -388,22 +411,67 @@ module Sunspot #:nodoc:
           end
         end
 
+        def indexable?
+          # options[:if] is not specified or they successfully pass
+          if_passes = self.class.sunspot_options[:if].nil? ||
+                      constraint_passes?(self.class.sunspot_options[:if])
+
+          # options[:unless] is not specified or they successfully pass
+          unless_passes = self.class.sunspot_options[:unless].nil? ||
+                          !constraint_passes?(self.class.sunspot_options[:unless])
+
+          if_passes and unless_passes
+        end
+
         private
 
-        def maybe_mark_for_auto_indexing
-          @marked_for_auto_indexing =
-            if !new_record? && ignore_attributes = self.class.sunspot_options[:ignore_attribute_changes_of]
-              @marked_for_auto_indexing = !(changed.map { |attr| attr.to_sym } - ignore_attributes).blank?
+        def constraint_passes?(constraint)
+          case constraint
+          when Symbol
+            self.__send__(constraint)
+          when String
+            self.__send__(constraint.to_sym)
+          when Enumerable
+            # All constraints must pass
+            constraint.all? { |inner_constraint| constraint_passes?(inner_constraint) }
+          else
+            if constraint.respond_to?(:call) # could be a Proc or anything else that responds to call
+              constraint.call(self)
             else
-              true
+              raise ArgumentError, "Unknown constraint type: #{constraint} (#{constraint.class})"
             end
+          end
+        end
+
+        def mark_for_auto_indexing_or_removal
+          if indexable?
+            # :if/:unless constraints pass or were not present
+
+            @marked_for_auto_indexing =
+              if !new_record? && ignore_attributes = self.class.sunspot_options[:ignore_attribute_changes_of]
+                !(changed.map { |attr| attr.to_sym } - ignore_attributes).blank?
+              else
+                true
+              end
+
+            @marked_for_auto_removal = false
+          else
+            # :if/:unless constraints did not pass; do not auto index and
+            # actually go one step further by removing it from the index
+            @marked_for_auto_indexing = false
+            @marked_for_auto_removal = true
+          end
+
           true
         end
 
-        def maybe_auto_index
+        def perform_index_tasks
           if @marked_for_auto_indexing
             solr_index
             remove_instance_variable(:@marked_for_auto_indexing)
+          elsif @marked_for_auto_removal
+            solr_remove_from_index
+            remove_instance_variable(:@marked_for_auto_removal)
           end
         end
       end

data/lib/sunspot/rails/server.rb

@@ -1,47 +1,15 @@
 module Sunspot
   module Rails
-    class Server < Sunspot::Server
+    class Server < Sunspot::Solr::Server
       # ActiveSupport log levels are integers; this array maps them to the
       # appropriate java.util.logging.Level constant
       LOG_LEVELS = %w(FINE INFO WARNING SEVERE SEVERE INFO)
 
-      def start
-        bootstrap
-        super
-      end
-
-      def run
-        bootstrap
-        super
-      end
-
-      #
-      # Bootstrap a new solr_home by creating all required
-      # directories. 
-      #
-      # ==== Returns
-      #
-      # Boolean:: success
-      #
-      def bootstrap
-        unless @bootstrapped
-          install_solr_home
-          @bootstrapped = true
-        end
-      end
-
-      # 
-      # Directory to store custom libraries for solr
-      #
-      def lib_path
-        File.join( solr_home, 'lib' )
-      end
-
       # 
       # Directory in which to store PID files
       #
       def pid_dir
-        File.join(::Rails.root, 'tmp', 'pids')
+        configuration.pid_dir || File.join(::Rails.root, 'tmp', 'pids')
       end
 
       # 
@@ -59,7 +27,7 @@ module Sunspot
       # String:: data_path
       #
       def solr_data_dir
-        File.join(solr_home, 'data', ::Rails.env)
+        configuration.data_path
       end
 
       # 
@@ -76,6 +44,13 @@ module Sunspot
         configuration.solr_jar || super
       end
 
+      # 
+      # Address on which to run Solr
+      #
+      def bind_address
+        configuration.bind_address
+      end
+
       # 
       # Port on which to run Solr
       #
@@ -126,48 +101,6 @@ module Sunspot
       def configuration
         Sunspot::Rails.configuration
       end
-
-      # 
-      # Directory to store solr config files
-      #
-      # ==== Returns
-      #
-      # String:: config_path
-      #
-      def config_path
-        File.join(solr_home, 'conf')
-      end
-
-      #
-      # Copy default solr configuration files from sunspot
-      # gem to the new solr_home/config directory
-      #
-      # ==== Returns
-      #
-      # Boolean:: success
-      #
-      def install_solr_home
-        unless File.exists?(solr_home)
-          Sunspot::Installer.execute(
-            solr_home,
-            :force => true,
-            :verbose => true
-          )
-        end
-      end
-
-      # 
-      # Create new solr_home, config, log and pid directories
-      #
-      # ==== Returns
-      #
-      # Boolean:: success
-      #
-      def create_solr_directories
-        [solr_data_dir, pid_dir].each do |path|
-          FileUtils.mkdir_p( path )
-        end
-      end
     end
   end
 end

data/lib/sunspot/rails/solr_instrumentation.rb

@@ -0,0 +1,20 @@
+module Sunspot
+  module Rails
+    module SolrInstrumentation
+      extend ActiveSupport::Concern
+
+      included do
+        alias_method_chain :execute, :as_instrumentation
+      end
+
+      module InstanceMethods
+        def execute_with_as_instrumentation(path, params={}, *extra)
+          ActiveSupport::Notifications.instrument("request.rsolr",
+                                                  {:path => path, :parameters => params}) do
+            execute_without_as_instrumentation(path, params, *extra)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/rails/solr_logging.rb

@@ -1,20 +1,21 @@
 module Sunspot
   module Rails
     module SolrLogging
+
       class <<self
         def included(base)
-          base.module_eval { alias_method_chain(:request, :rails_logging) }
+          base.alias_method_chain :execute, :rails_logging
         end
       end
 
-      def request_with_rails_logging(path, params={}, *extra)
+      COMMIT = %r{<commit/>}
 
-        # Set up logging text.
-        body = (params.nil? || params.empty?) ? extra.first : params.inspect
-        action = path[1..-1].capitalize
-        if body == "<commit/>"
-          action = 'Commit'
-          body = ''
+      def execute_with_rails_logging(client, request_context)
+        body = (request_context[:data]||"").dup
+        action = request_context[:path].capitalize
+        if body =~ COMMIT
+          action = "Commit"
+          body = ""
         end
         body = body[0, 800] + '...' if body.length > 800
 
@@ -22,7 +23,7 @@ module Sunspot
         response = nil
         begin
           ms = Benchmark.ms do
-            response = request_without_rails_logging(path, params, *extra)
+            response = execute_without_rails_logging(client, request_context)
           end
           log_name = 'Solr %s (%.1fms)' % [action, ms]
           ::Rails.logger.debug(format_log_entry(log_name, body))
@@ -39,10 +40,10 @@ module Sunspot
 
       def format_log_entry(message, dump = nil)
         @colorize_logging ||= begin
-            ::Rails.application.config.colorize_logging # Rails 3
-          rescue NoMethodError
-            ActiveRecord::Base.colorize_logging # Rails 2
-          end
+          ::Rails.application.config.colorize_logging # Rails 3
+        rescue NoMethodError
+          ActiveRecord::Base.colorize_logging # Rails 2
+        end
         if @colorize_logging
           message_color, dump_color = "4;32;1", "0;1"
           log_entry = "  \e[#{message_color}m#{message}\e[0m   "
@@ -56,8 +57,6 @@ module Sunspot
   end
 end
 
-begin
-  RSolr::Client.module_eval { include(Sunspot::Rails::SolrLogging) }
-rescue NameError # RSolr 0.9.6
-  RSolr::Connection::Base.module_eval { include(Sunspot::Rails::SolrLogging) }
+RSolr::Connection.module_eval do
+  include Sunspot::Rails::SolrLogging
 end