searchkick_bharthur 0.0.1

data/lib/searchkick/logging.rb

@@ -0,0 +1,185 @@
+# based on https://gist.github.com/mnutt/566725
+require "active_support/core_ext/module/attr_internal"
+
+module Searchkick
+  module QueryWithInstrumentation
+    def execute_search
+      name = searchkick_klass ? "#{searchkick_klass.name} Search" : "Search"
+      event = {
+        name: name,
+        query: params
+      }
+      ActiveSupport::Notifications.instrument("search.searchkick", event) do
+        super
+      end
+    end
+  end
+
+  module IndexWithInstrumentation
+    def store(record)
+      event = {
+        name: "#{record.searchkick_klass.name} Store",
+        id: search_id(record)
+      }
+      if Searchkick.callbacks_value == :bulk
+        super
+      else
+        ActiveSupport::Notifications.instrument("request.searchkick", event) do
+          super
+        end
+      end
+    end
+
+    def remove(record)
+      name = record && record.searchkick_klass ? "#{record.searchkick_klass.name} Remove" : "Remove"
+      event = {
+        name: name,
+        id: search_id(record)
+      }
+      if Searchkick.callbacks_value == :bulk
+        super
+      else
+        ActiveSupport::Notifications.instrument("request.searchkick", event) do
+          super
+        end
+      end
+    end
+
+    def import(records)
+      if records.any?
+        event = {
+          name: "#{records.first.searchkick_klass.name} Import",
+          count: records.size
+        }
+        ActiveSupport::Notifications.instrument("request.searchkick", event) do
+          super(records)
+        end
+      end
+    end
+  end
+
+  module SearchkickWithInstrumentation
+    def multi_search(searches)
+      event = {
+        name: "Multi Search",
+        body: searches.flat_map { |q| [q.params.except(:body).to_json, q.body.to_json] }.map { |v| "#{v}\n" }.join
+      }
+      ActiveSupport::Notifications.instrument("multi_search.searchkick", event) do
+        super
+      end
+    end
+
+    def perform_items(items)
+      if callbacks_value == :bulk
+        event = {
+          name: "Bulk",
+          count: items.size
+        }
+        ActiveSupport::Notifications.instrument("request.searchkick", event) do
+          super
+        end
+      else
+        super
+      end
+    end
+  end
+
+  # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/log_subscriber.rb
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def self.runtime=(value)
+      Thread.current[:searchkick_runtime] = value
+    end
+
+    def self.runtime
+      Thread.current[:searchkick_runtime] ||= 0
+    end
+
+    def self.reset_runtime
+      rt = runtime
+      self.runtime = 0
+      rt
+    end
+
+    def search(event)
+      self.class.runtime += event.duration
+      return unless logger.debug?
+
+      payload = event.payload
+      name = "#{payload[:name]} (#{event.duration.round(1)}ms)"
+      type = payload[:query][:type]
+      index = payload[:query][:index].is_a?(Array) ? payload[:query][:index].join(",") : payload[:query][:index]
+
+      # no easy way to tell which host the client will use
+      host = Searchkick.client.transport.hosts.first
+      debug "  #{color(name, YELLOW, true)}  curl #{host[:protocol]}://#{host[:host]}:#{host[:port]}/#{CGI.escape(index)}#{type ? "/#{type.map { |t| CGI.escape(t) }.join(',')}" : ''}/_search?pretty -d '#{payload[:query][:body].to_json}'"
+    end
+
+    def request(event)
+      self.class.runtime += event.duration
+      return unless logger.debug?
+
+      payload = event.payload
+      name = "#{payload[:name]} (#{event.duration.round(1)}ms)"
+
+      debug "  #{color(name, YELLOW, true)}  #{payload.except(:name).to_json}"
+    end
+
+    def multi_search(event)
+      self.class.runtime += event.duration
+      return unless logger.debug?
+
+      payload = event.payload
+      name = "#{payload[:name]} (#{event.duration.round(1)}ms)"
+
+      # no easy way to tell which host the client will use
+      host = Searchkick.client.transport.hosts.first
+      debug "  #{color(name, YELLOW, true)}  curl #{host[:protocol]}://#{host[:host]}:#{host[:port]}/_msearch?pretty -d '#{payload[:body]}'"
+    end
+  end
+
+  # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/railties/controller_runtime.rb
+  module ControllerRuntime
+    extend ActiveSupport::Concern
+
+    protected
+
+    attr_internal :searchkick_runtime
+
+    def process_action(action, *args)
+      # We also need to reset the runtime before each action
+      # because of queries in middleware or in cases we are streaming
+      # and it won't be cleaned up by the method below.
+      Searchkick::LogSubscriber.reset_runtime
+      super
+    end
+
+    def cleanup_view_runtime
+      searchkick_rt_before_render = Searchkick::LogSubscriber.reset_runtime
+      runtime = super
+      searchkick_rt_after_render = Searchkick::LogSubscriber.reset_runtime
+      self.searchkick_runtime = searchkick_rt_before_render + searchkick_rt_after_render
+      runtime - searchkick_rt_after_render
+    end
+
+    def append_info_to_payload(payload)
+      super
+      payload[:searchkick_runtime] = (searchkick_runtime || 0) + Searchkick::LogSubscriber.reset_runtime
+    end
+
+    module ClassMethods
+      def log_process_action(payload)
+        messages = super
+        runtime = payload[:searchkick_runtime]
+        messages << ("Searchkick: %.1fms" % runtime.to_f) if runtime.to_f > 0
+        messages
+      end
+    end
+  end
+end
+Searchkick::Query.send(:prepend, Searchkick::QueryWithInstrumentation)
+Searchkick::Index.send(:prepend, Searchkick::IndexWithInstrumentation)
+Searchkick.singleton_class.send(:prepend, Searchkick::SearchkickWithInstrumentation)
+Searchkick::LogSubscriber.attach_to :searchkick
+ActiveSupport.on_load(:action_controller) do
+  include Searchkick::ControllerRuntime
+end

data/lib/searchkick/middleware.rb

@@ -0,0 +1,12 @@
+require "faraday/middleware"
+
+module Searchkick
+  class Middleware < Faraday::Middleware
+    def call(env)
+      if env[:method] == :get && env[:url].path.to_s.end_with?("/_search")
+        env[:request][:timeout] = Searchkick.search_timeout
+      end
+      @app.call(env)
+    end
+  end
+end

data/lib/searchkick/model.rb

@@ -0,0 +1,105 @@
+module Searchkick
+  module Reindex; end # legacy for Searchjoy
+
+  module Model
+    def searchkick(options = {})
+      raise "Only call searchkick once per model" if respond_to?(:searchkick_index)
+
+      Searchkick.models << self
+
+      class_eval do
+        cattr_reader :searchkick_options, :searchkick_klass
+
+        callbacks = options.key?(:callbacks) ? options[:callbacks] : true
+
+        class_variable_set :@@searchkick_options, options.dup
+        class_variable_set :@@searchkick_klass, self
+        class_variable_set :@@searchkick_callbacks, callbacks
+        class_variable_set :@@searchkick_index, options[:index_name] ||
+          (options[:index_prefix].respond_to?(:call) && proc { [options[:index_prefix].call, model_name.plural, Searchkick.env].compact.join("_") }) ||
+          [options[:index_prefix], model_name.plural, Searchkick.env].compact.join("_")
+
+        class << self
+          def searchkick_search(term = nil, options = {}, &block)
+            searchkick_index.search_model(self, term, options, &block)
+          end
+          alias_method Searchkick.search_method_name, :searchkick_search if Searchkick.search_method_name
+
+          def searchkick_index
+            index = class_variable_get :@@searchkick_index
+            index = index.call if index.respond_to? :call
+            Searchkick::Index.new(index, searchkick_options)
+          end
+
+          def enable_search_callbacks
+            class_variable_set :@@searchkick_callbacks, true
+          end
+
+          def disable_search_callbacks
+            class_variable_set :@@searchkick_callbacks, false
+          end
+
+          def search_callbacks?
+            class_variable_get(:@@searchkick_callbacks) && Searchkick.callbacks?
+          end
+
+          def searchkick_reindex(options = {})
+            unless options[:accept_danger]
+              if (respond_to?(:current_scope) && respond_to?(:default_scoped) && current_scope && current_scope.to_sql != default_scoped.to_sql) ||
+                (respond_to?(:queryable) && queryable != unscoped.with_default_scope)
+                raise Searchkick::DangerousOperation, "Only call reindex on models, not relations. Pass `accept_danger: true` if this is your intention."
+              end
+            end
+            searchkick_index.reindex_scope(searchkick_klass, options)
+          end
+          alias_method :reindex, :searchkick_reindex unless method_defined?(:reindex)
+
+          def clean_indices
+            searchkick_index.clean_indices
+          end
+
+          def searchkick_import(options = {})
+            (options[:index] || searchkick_index).import_scope(searchkick_klass)
+          end
+
+          def searchkick_create_index
+            searchkick_index.create_index
+          end
+
+          def searchkick_index_options
+            searchkick_index.index_options
+          end
+        end
+        extend Searchkick::Reindex # legacy for Searchjoy
+
+        callback_name = callbacks == :async ? :reindex_async : :reindex
+        if respond_to?(:after_commit)
+          after_commit callback_name, if: proc { self.class.search_callbacks? }
+        elsif respond_to?(:after_save)
+          after_save callback_name, if: proc { self.class.search_callbacks? }
+          after_destroy callback_name, if: proc { self.class.search_callbacks? }
+        end
+
+        def reindex
+          self.class.searchkick_index.reindex_record(self)
+        end unless method_defined?(:reindex)
+
+        def reindex_async
+          self.class.searchkick_index.reindex_record_async(self)
+        end unless method_defined?(:reindex_async)
+
+        def similar(options = {})
+          self.class.searchkick_index.similar_record(self, options)
+        end unless method_defined?(:similar)
+
+        def search_data
+          respond_to?(:to_hash) ? to_hash : serializable_hash
+        end unless method_defined?(:search_data)
+
+        def should_index?
+          true
+        end unless method_defined?(:should_index?)
+      end
+    end
+  end
+end