es-elasticity 0.2.11 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 58ea71d50e68bd34f58ea88ebf80197f1fc04083
-  data.tar.gz: 740f4b8b9bc70011fa146245bf2b5f30600f77cd
+  metadata.gz: c7bc6c25943feeda4da146553b189c61bbdad216
+  data.tar.gz: 9f07d0aa831e187b094481e96178fce66c923139
 SHA512:
-  metadata.gz: 0d9f5f2c133c66e27725e8e95051c780a407900f19ad278feae655de91305054e807bfa9fe87b591e57f991540d745790cf4f075f3cfd35f7c3d11c6150f09c2
-  data.tar.gz: ac2228701bf716f8febb33027a75640477b46cd276f47cdaeb1ffee4eed25ad7649588d9e4dd07f37756d576eb775efaab4bf796f5743c4469c6ef888b50d16b
+  metadata.gz: 5d9109393c9161297e7a103d821f0a91599b8dae175174b228380f82d3db975a9d3d32902cc5ea671da301bc90f8d4705db4ed232ef019d0427c82bf49f032dd
+  data.tar.gz: bc7fb37f2ded19d2dd98e636a2f346aa078b3bee37c4e49ff3d46278b3d6e1f1d0407e385f04f344887b9bafd6f2b6c8f667fc983f972c5e6ab6725719b4c7be

data/.gitignore

@@ -13,3 +13,4 @@
 *.a
 mkmf.log
 *.log
+.DS_Store

data/.travis.yml

@@ -1,7 +1,11 @@
 language: ruby
+before_install:
+  - gem update bundler
 rvm:
   - 2.1.1
-  - 2.0.0
+  - 2.1.2
+  - 2.1.3
+  - 2.1.4
 services:
   - elasticsearch
 env:

data/elasticity.gemspec

@@ -26,6 +26,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "oj"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "codeclimate-test-reporter"
+  spec.add_development_dependency "redis"
 
   spec.add_dependency "activesupport", "~> 4.0"
   spec.add_dependency "activemodel",   "~> 4.0"

data/lib/elasticity.rb

@@ -1,5 +1,33 @@
-require "elasticity_base"
-require "elasticity/index"
-require "elasticity/document"
-require "elasticity/search"
-require "elasticity/multi_search"
+require "rubygems"
+require "bundler/setup"
+Bundler.setup
+
+require "active_support"
+require "active_support/core_ext"
+require "active_model"
+require "elasticsearch"
+
+module Elasticity
+  autoload :Bulk,               "elasticity/bulk"
+  autoload :Config,             "elasticity/config"
+  autoload :Document,           "elasticity/document"
+  autoload :InstrumentedClient, "elasticity/instrumented_client"
+  autoload :LogSubscriber,      "elasticity/log_subscriber"
+  autoload :MultiSearch,        "elasticity/multi_search"
+  autoload :Search,             "elasticity/search"
+  autoload :Strategies,         "elasticity/strategies"
+
+  def self.configure
+    @config = Config.new
+    yield(@config)
+  end
+
+  def self.config
+    return @config if defined?(@config)
+    @config = Config.new
+  end
+end
+
+if defined?(Rails)
+  require "elasticity/railtie"
+end

data/lib/elasticity/bulk.rb

@@ -0,0 +1,53 @@
+module Elasticity
+  class Bulk
+    def initialize(client)
+      @client     = client
+      @operations = []
+    end
+
+    def index(index_name, type, id, attributes)
+      @operations << { index: { _index: index_name, _type: type, _id: id, data: attributes }}
+    end
+
+    def delete(index_name, type, id)
+      @operations << { delete: { _index: index_name, _type: type, _id: id }}
+    end
+
+    def execute
+      @client.bulk(body: @operations)
+    end
+
+    class Index < Bulk
+      def initialize(client, index_name)
+        super(client)
+        @index_name = index_name
+      end
+
+      def index(type, id, attributes)
+        super(@index_name, type, id, attributes)
+      end
+
+      def delete(type, id)
+        super(@index_name, type, id)
+      end
+    end
+
+    class Alias < Bulk
+      def initialize(client, update_alias, delete_indexes)
+        super(client)
+        @update_alias   = update_alias
+        @delete_indexes = delete_indexes
+      end
+
+      def index(type, id, attributes)
+        super(@update_alias, type, id, attributes)
+      end
+
+      def delete(type, id)
+        @delete_indexes.each do |index|
+          super(index, type, id)
+        end
+      end
+    end
+  end
+end

data/lib/elasticity/config.rb

@@ -0,0 +1,28 @@
+module Elasticity
+  class Config
+    def client=(client)
+      @client = Elasticity::InstrumentedClient.new(client)
+    end
+
+    def client
+      return @client if defined?(@client)
+      self.client = Elasticsearch::Client.new
+      @client
+    end
+
+    attr_writer :settings, :namespace, :pretty_json
+
+    def settings
+      return @settings if defined?(@settings)
+      @settings = {}
+    end
+
+    def namespace
+      @namespace
+    end
+
+    def pretty_json
+      @pretty_json || false
+    end
+  end
+end

data/lib/elasticity/document.rb

@@ -2,89 +2,131 @@ module Elasticity
   class Document
     include ::ActiveModel::Model
 
-    # Returns the instance of Elasticity::Index associated with this document.
-    def self.index
-      return @index if @index.present?
-      @index = Index.new(Elasticity.config.client, self.namespaced_index_name)
+    class NotConfigured < StandardError; end
+
+    Config = Struct.new(:index_base_name, :document_type, :mapping, :strategy)
+
+    # Configure the given klass, changing default parameters and resetting
+    # some of the internal state.
+    def self.configure
+      @config = Config.new
+      @config.strategy = Strategies::SingleIndex
+      yield(@config)
+    end
+
+    # Returns the stategy class being used.
+    # Check Elasticity::Strategies for more information.
+    def self.strategy
+      if @config.nil? || @config.strategy.nil?
+        raise NotConfigured, "#{self} has not been configured, make sure you call the configure method"
+      end
+
+      return @strategy if defined?(@strategy)
+
+      if namespace = Elasticity.config.namespace
+        index_base_name = "#{namespace}_#{@config.index_base_name}"
+      end
+
+      @strategy = @config.strategy.new(Elasticity.config.client, index_base_name)
+    end
+
+    # Document type
+    def self.document_type
+      if @config.nil? || @config.document_type.blank?
+        raise NotConfigured, "#{self} has not been configured, make sure you call the configure method"
+      end
+
+      @config.document_type
+    end
+
+    # Document type
+    def self.mapping
+      if @config.nil? || @config.mapping.blank?
+        raise NotConfigured, "#{self} has not been configured, make sure you call the configure method"
+      end
+
+      @config.mapping
     end
 
     # Creates the index for this document
     def self.create_index
-      self.index.create_if_undefined(settings: Elasticity.config.settings, mappings: { document_type => @mappings })
+      self.strategy.create_if_undefined(settings: Elasticity.config.settings, mappings: { document_type => mapping })
     end
 
     # Re-creates the index for this document
     def self.recreate_index
-      self.index.recreate(settings: Elasticity.config.settings, mappings: { document_type => @mappings })
+      self.strategy.recreate(settings: Elasticity.config.settings, mappings: { document_type => mapping })
     end
 
     # Deletes the index
     def self.delete_index
-      self.index.delete
+      self.strategy.delete
     end
 
-    # Sets the index name to something else than the default
-    def self.index_name=(name)
-      @index_name = name
-      @index = nil
+    # Does the index exist?
+    def self.index_exists?
+      !self.strategy.missing?
     end
 
-    # Namespaced index name
-    def self.namespaced_index_name
-      name = @index_name || self.name.underscore.pluralize
-
-      if namespace = Elasticity.config.namespace
-        name = "#{namespace}_#{name}"
-      end
-
-      name
+    # Remap
+    def self.remap!
+      self.strategy.remap(settings: Elasticity.config.settings, mappings: { document_type => mapping })
     end
 
-    # The document type to be used, it's inferred by the class name.
-    def self.document_type
-      return @document_type if defined?(@document_type)
-      @document_type = self.name.demodulize.underscore
+    # Flushes the index, forcing any writes
+    def self.flush_index
+      self.strategy.flush
     end
 
-    # Sets the document type to something different than the default
-    def self.document_type=(document_type)
-      @document_type = document_type
-    end
+    # Creates a instance of a document from a ElasticSearch hit data.
+    def self.from_hit(hit_data)
+      attrs = hit_data["_source"].merge(_id: hit_data['_id'])
+
+      if hit_data["highlight"]
+        highlighted_attrs = attrs.dup
+        attrs_set = Set.new
 
-    # Sets the mapping for this model, which will be used to create the associated index and
-    # generate accessor methods.
-    def self.mappings=(mappings)
-      raise "Can't re-define mappings in runtime" if defined?(@mappings)
-      @mappings = mappings
+        hit_data["highlight"].each do |name, v|
+          name = name.gsub(/\..*\z/, '')
+          next if attrs_set.include?(name)
+          highlighted_attrs[name] = v
+          attrs_set << name
+        end
+
+        highlighted = new(highlighted_attrs)
+      end
+
+      new(attrs.merge(highlighted: highlighted))
     end
 
     # Searches the index using the parameters provided in the body hash, following the same
     # structure Elasticsearch expects.
     # Returns a DocumentSearch object.
     def self.search(body)
-      DocumentSearchProxy.new(Search.new(index, document_type, body), self)
+      search = self.strategy.search(self.document_type, body)
+      Search::DocumentProxy.new(search, self)
     end
 
     # Fetches one specific document from the index by ID.
     def self.get(id)
-      if doc = index.get_document(document_type, id)
+      if doc = self.strategy.get_document(document_type, id)
         new(doc["_source"].merge(_id: doc['_id']))
       end
     end
 
     # Removes one specific document from the index.
     def self.delete(id)
-      index.delete_document(document_type, id)
+      self.strategy.delete_document(document_type, id)
     end
 
     # Removes entries based on a search
     def self.delete_by_search(search)
-      index.delete_by_query(document_type, search.body)
+      self.strategy.delete_by_query(document_type, search.body)
     end
 
     # Bulk index the provided documents
     def self.bulk_index(documents)
-      index.bulk do |b|
+      self.strategy.bulk do |b|
         documents.each do |doc|
           b.index(self.document_type, doc._id, doc.to_document)
         end
@@ -124,7 +166,15 @@ module Elasticity
 
     # Update this object on the index, creating or updating the document.
     def update
-      self.class.index.index_document(self.class.document_type, _id, to_document)
+      self._id, @created = self.class.strategy.index_document(self.class.document_type, _id, to_document)
+    end
+
+    def delete
+      self.class.delete(self._id)
+    end
+
+    def created?
+      @created || false
     end
   end
 end

data/lib/elasticity/instrumented_client.rb

@@ -0,0 +1,35 @@
+module Elasticity
+  class InstrumentedClient
+    def initialize(client)
+      @client = client
+    end
+
+    # Generate wrapper methods for @client.indices
+    %w(exists create delete get_settings get_mapping flush get_alias get_aliases put_alias delete_alias exists_alias update_aliases).each do |method_name|
+      full_name = "index_#{method_name}"
+
+      define_method(full_name) do |*args, &block|
+        instrument(full_name, args) do
+          @client.indices.public_send(method_name, *args, &block)
+        end
+      end
+    end
+
+    # Generate wrapper methods for @client
+    %w(index delete get mget search msearch scroll delete_by_query bulk).each do |method_name|
+      define_method(method_name) do |*args, &block|
+        instrument(method_name, args) do
+          @client.public_send(method_name, *args, &block)
+        end
+      end
+    end
+
+    private
+
+    def instrument(name, args)
+      ActiveSupport::Notifications.instrument("#{name}.elasticity", args: args, backtrace: caller(1)) do
+        yield
+      end
+    end
+  end
+end

data/lib/elasticity/log_subscriber.rb

@@ -0,0 +1,49 @@
+require "active_support/subscriber"
+require "active_support/log_subscriber"
+
+module Elasticity
+  GRAY = "\e[90m"
+
+  class LogSubscriber < ::ActiveSupport::LogSubscriber
+    %w(exists create delete get_settings get_mapping flush get_alias get_aliases put_alias delete_alias exists_alias update_aliases).each do |method_name|
+      define_method("index_#{method_name}") do |event|
+        log_event(event)
+      end
+    end
+
+    %w(index delete get search scroll delete_by_query bulk).each do |method_name|
+      define_method(method_name) do |event|
+        log_event(event)
+      end
+    end
+
+    def multi_search(event)
+      log_event(event)
+    end
+
+    private
+
+    def log_event(event)
+      bt = event.payload[:backtrace]
+
+      if bt.present? && defined?(Rails)
+        bt = Rails.backtrace_cleaner.clean(bt)
+      end
+
+      message = "#{event.transaction_id} #{event.name} #{"%.2f" % event.duration}ms #{MultiJson.dump(event.payload[:args], pretty: Elasticity.config.pretty_json)}"
+
+      if bt = event.payload[:backtrace]
+        bt = Rails.backtrace_cleaner.clean(bt) if defined?(Rails)
+        lines = bt[0,4].map { |l| color(l, GRAY) }.join("\n")
+        message << "\n#{lines}"
+      end
+
+      debug(message)
+
+      exception, message = event.payload[:exception]
+      if exception
+        error("#{event.transaction_id} #{event.name} ERROR #{exception}: #{message}")
+      end
+    end
+  end
+end

data/lib/elasticity/multi_search.rb

@@ -7,19 +7,18 @@ module Elasticity
     end
 
     def add(name, search, documents: nil, active_records: nil)
-      mapper = case
-      when documents && active_records
+      if !documents.nil? && !active_records.nil?
         raise ArgumentError, "you can only pass either :documents or :active_records as an option"
-      when documents
-        Search::DocumentMapper.new(documents)
-      when active_records
-        Search::ActiveRecordMapper.new(active_records)
-      else
+      elsif documents.nil? && active_records.nil?
         raise ArgumentError, "you need to provide either :documents or :active_records as an option"
       end
 
-      @searches[name] = { index: search.index.name, type: search.document_type, search: search.body }
-      @mappers[name]  = mapper
+      @searches[name] = {
+        search_definition: search.search_definition,
+        documents: documents,
+        active_records: active_records
+      }
+
       name
     end
 
@@ -31,18 +30,26 @@ module Elasticity
     private
 
     def fetch
-      bodies = @searches.values.map(&:dup)
+      bodies = @searches.values.map do |hsh|
+        hsh[:search_definition].to_msearch_args
+      end
 
-      response = ActiveSupport::Notifications.instrument("multi_search.elasticity", args: { body: @searches.values }) do
-        Elasticity.config.client.msearch(body: bodies)
+      response = ActiveSupport::Notifications.instrument("multi_search.elasticity", args: { body: bodies }) do
+        Elasticity.config.client.msearch(body: bodies.map(&:dup))
       end
 
       results = {}
 
       @searches.keys.each_with_index do |name, idx|
-        resp          = response["responses"][idx]
-        mapper        = @mappers[name]
-        results[name] = Search::Result.new(resp, mapper)
+        resp = response["responses"][idx]
+        search = @searches[name]
+
+        results[name] = case
+        when search[:documents]
+          resp["hits"]["hits"].map { |hit| search[:documents].from_hit(hit) }
+        when search[:active_records]
+          Search::ActiveRecordProxy.from_hits(search[:active_records], resp["hits"]["hits"])
+        end
       end
 
       results