es-elasticity 0.13.5 → 1.0.0.jhumphreys

data/lib/elasticity/bulk.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Elasticity
   class Bulk
     def initialize(client)
@@ -5,16 +7,16 @@ module Elasticity
       @operations = []
     end
 
-    def index(index_name, type, id, attributes)
-      @operations << { index: { _index: index_name, _type: type, _id: id, data: attributes }}
+    def index(index_name, id, attributes)
+      @operations << { index: { _index: index_name, _id: id, data: attributes }}
     end
 
-    def update(index_name, type, id, attributes)
-      @operations << { update: { _index: index_name, _type: type, _id: id, data: attributes }}
+    def update(index_name, id, attributes)
+      @operations << { update: { _index: index_name, _id: id, data: attributes }}
     end
 
-    def delete(index_name, type, id)
-      @operations << { delete: { _index: index_name, _type: type, _id: id }}
+    def delete(index_name, id)
+      @operations << { delete: { _index: index_name, _id: id }}
     end
 
     def execute
@@ -27,16 +29,16 @@ module Elasticity
         @index_name = index_name
       end
 
-      def index(type, id, attributes)
-        super(@index_name, type, id, attributes)
+      def index(id, attributes)
+        super(@index_name, id, attributes)
       end
 
-      def update(type, id, attributes)
-        super(@index_name, type, id, attributes)
+      def update(id, attributes)
+        super(@index_name, id, attributes)
       end
 
-      def delete(type, id)
-        super(@index_name, type, id)
+      def delete(id)
+        super(@index_name, id)
       end
     end
 
@@ -47,17 +49,17 @@ module Elasticity
         @delete_indexes = delete_indexes
       end
 
-      def index(type, id, attributes)
-        super(@update_alias, type, id, attributes)
+      def index(id, attributes)
+        super(@update_alias, id, attributes)
       end
 
-      def update(type, id, attributes)
-        super(@update_alias, type, id, attributes)
+      def update(id, attributes)
+        super(@update_alias, id, attributes)
       end
 
-      def delete(type, id)
+      def delete(id)
         @delete_indexes.each do |index|
-          super(index, type, id)
+          super(index, id)
         end
       end
     end

data/lib/elasticity/config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Elasticity
   class Config
     def client=(client)

data/lib/elasticity/document.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Elasticity
   class Document < BaseDocument
     IndexMapper.set_delegates(singleton_class, :mapper)

data/lib/elasticity/index_config.rb

@@ -1,18 +1,21 @@
+# frozen_string_literal: true
+
 module Elasticity
   class IndexConfig
     class SubclassError < StandardError; end
 
-    SUBCLASSES_WARNING = "Indices created in Elasticsearch 6.0.0 or later may only contain a single mapping type. " +
+    SUBCLASSES_WARNING = "Indices created in Elasticsearch 6.0.0 or later may only contain a single mapping type. "\
       "Therefore, doument-type based inheritance has been disabled by Elasticity"
-    SUBCLASSES_ERROR = "Mapping types have been completely removed in Elasticsearch 7.0.0. " +
+    SUBCLASSES_ERROR = "Mapping types have been completely removed in Elasticsearch 7.0.0. "\
       "Therefore, doument-type based inheritance has been disabled by Elasticity"
-    VERSION_FOR_SUBCLASS_WARNING = "6.0.0".freeze
-    VERSION_FOR_SUBCLASS_ERROR = "7.0.0".freeze
+    VERSION_FOR_SUBCLASS_WARNING = "6.0.0"
+    VERSION_FOR_SUBCLASS_ERROR = "7.0.0"
     ATTRS = [
       :index_base_name, :document_type, :mapping, :strategy, :subclasses,
       :settings, :use_new_timestamp_format, :include_type_name_on_create
     ].freeze
     VALIDATABLE_ATTRS = [:index_base_name, :document_type, :strategy].freeze
+    DEPRECATED_ATTRS = [:use_new_timestamp_format, :include_type_name_on_create].freeze
 
     attr_accessor(*ATTRS)
 
@@ -23,6 +26,7 @@ module Elasticity
       @elasticity_config = elasticity_config
       yield(self)
       subclasses_warning_or_exception
+      warn_deprecated_config
       validate!
     end
 
@@ -38,9 +42,10 @@ module Elasticity
 
     def definition
       return @definition if defined?(@definition)
+
       @definition = {
         settings: merge_settings,
-        mappings: { @document_type => @mapping.nil? ? {} : @mapping.deep_stringify_keys }
+        mappings: @mapping.nil? ? {} : @mapping.deep_stringify_keys
       }
       subclasses.each do |doc_type, subclass|
         @definition[:mappings][doc_type] = subclass.constantize.mapping
@@ -80,6 +85,15 @@ module Elasticity
       @elasticity_config.settings.merge(settings || {})
     end
 
+    def warn_deprecated_config
+      DEPRECATED_ATTRS.each do |attr|
+        ActiveSupport::Deprecation.warn(
+          "#{attr} is deprecated and will be "\
+          "removed in the next major release."
+        ) if public_send(attr).present?
+      end
+    end
+
     def subclasses_warning_or_exception
       return if subclasses.nil? || subclasses.empty?
       raise(SubclassError.new(SUBCLASSES_ERROR)) if es_version_meets_or_exceeds?(VERSION_FOR_SUBCLASS_ERROR)

data/lib/elasticity/index_mapper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Elasticity
   class IndexMapper
     def self.set_delegates(obj, to)
@@ -84,7 +86,7 @@ module Elasticity
 
     # Index the given document
     def index_document(id, document_hash)
-      @strategy.index_document(document_type, id, document_hash)
+      @strategy.index_document(id, document_hash)
     end
 
     # Searches the index using the parameters provided in the body hash, following the same
@@ -99,25 +101,25 @@ module Elasticity
 
     # Fetches one specific document from the index by ID.
     def get(id)
-      doc = @strategy.get_document(document_type, id)
-      @document_klass.new(doc["_source"].merge(_id: doc['_id'])) if doc.present?
+      doc = @strategy.get_document(id)
+      @document_klass.new(doc["_source"].merge(_id: doc["_id"])) if doc.present?
     end
 
     # Removes one specific document from the index.
     def delete(id)
-      @strategy.delete_document(document_type, id)
+      @strategy.delete_document(id)
     end
 
     # Removes entries based on a search
     def delete_by_search(search)
-      @strategy.delete_by_query(document_type, search.body)
+      @strategy.delete_by_query(search.body)
     end
 
     # Bulk index the provided documents
     def bulk_index(documents)
       @strategy.bulk do |b|
         documents.each do |doc|
-          b.index(document_type, doc._id, doc.to_document)
+          b.index(doc._id, doc.to_document)
         end
       end
     end
@@ -127,7 +129,6 @@ module Elasticity
       @strategy.bulk do |b|
         documents.each do |doc|
           b.update(
-            document_type,
             doc[:_id],
             { doc: { doc[:attr_name] => doc[:attr_value] } }
           )
@@ -139,7 +140,7 @@ module Elasticity
     def bulk_delete(ids)
       @strategy.bulk do |b|
         ids.each do |id|
-          b.delete(document_type, id)
+          b.delete(id)
         end
       end
     end
@@ -156,7 +157,7 @@ module Elasticity
 
       if hit["highlight"]
         highlighted_attrs = hit["highlight"].each_with_object({}) do |(name, v), attrs|
-          name = name.gsub(/\..*\z/, '')
+          name = name.gsub(/\..*\z/, "")
 
           attrs[name] ||= v
         end

data/lib/elasticity/instrumented_client.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Elasticity
   class InstrumentedClient
     INDICES_METHODS = %w(exists create delete get_settings get_mapping flush refresh get_alias get_aliases put_alias delete_alias exists_alias update_aliases)

data/lib/elasticity/log_subscriber.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/subscriber"
 require "active_support/log_subscriber"
 

data/lib/elasticity/multi_search.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Elasticity
   class MultiSearch
     def initialize(msearch_args = {})

data/lib/elasticity/multi_search_response_parser.rb

@@ -1,3 +1,6 @@
+
+# frozen_string_literal: true
+
 module Elasticity
   class MultiSearchResponseParser
     class UnknownError < StandardError; end

data/lib/elasticity/railtie.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require "elasticity/log_subscriber"
 
 module Elasticity
   class Railtie < Rails::Railtie
-    initializer 'elasticity.initialize_logging' do
+    initializer "elasticity.initialize_logging" do
       LogSubscriber.attach_to(:elasticity)
     end
   end

data/lib/elasticity/search.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Elasticity
   module Search
     def self.build(client, index_name, document_types, body, search_args = {})
@@ -6,7 +8,7 @@ module Elasticity
     end
 
     # Elasticity::Search::Definition is a struct that encapsulates all the data specific to one
-    # ElasticSearch search.
+    # Elasticsearch search.
     class Definition
       attr_accessor :index_name, :document_types, :body
 
@@ -22,20 +24,20 @@ module Elasticity
       end
 
       def to_count_args
-        { index: @index_name, type: @document_types}.tap do |args|
+        { index: @index_name }.tap do |args|
           body = @body.slice(:query)
           args[:body] = body if body.present?
         end
       end
 
       def to_search_args
-        @search_args.merge({ index: @index_name, type: @document_types, body: @body })
+        @search_args.merge({ index: @index_name, body: @body })
       end
 
       def to_msearch_args
         search_body = @search_args.merge(@body)
 
-        { index: @index_name, type: @document_types, search: search_body }
+        { index: @index_name, search: search_body }
       end
     end
 
@@ -186,7 +188,7 @@ module Elasticity
       def search
         return @search if defined?(@search)
         args    = @search_definition.to_search_args
-        args    = args.merge(search_type: ScrollableSearch.search_type, size: @size, scroll: @scroll)
+        args    = args.merge(search_type: :query_then_fetch, size: @size, scroll: @scroll)
         @search = @client.search(args)
       end
     end

data/lib/elasticity/segmented_document.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Elasticity
   class SegmentedDocument < BaseDocument
     # Creates a new segment which behaves almost the same as a Document class dynamically

data/lib/elasticity/strategies/alias_index.rb

@@ -1,25 +1,23 @@
+# frozen_string_literal: true
+
 module Elasticity
   module Strategies
     # This strategy keeps two aliases that might be mapped to the same index or different index, allowing
     # runtime changes by simply atomically updating the aliases. For example, look at the remap method
     # implementation.
     class AliasIndex
-      SNAPSHOT_ERROR_SNIPPET =  "Cannot delete indices that are being snapshotted".freeze
+      SNAPSHOT_ERROR_SNIPPET =  "Cannot delete indices that are being snapshotted"
       RETRYABLE_ERROR_SNIPPETS = [
         SNAPSHOT_ERROR_SNIPPET
       ].freeze
 
       STATUSES = [:missing, :ok]
 
-      def initialize(client, index_base_name, document_type, use_new_timestamp_format = false, include_type_name_on_create = true)
+      def initialize(client, index_base_name, document_type, use_new_timestamp_format = nil, include_type_name_on_create = nil)
         @client       = client
         @main_alias   = index_base_name
         @update_alias = "#{index_base_name}_update"
         @document_type = document_type
-
-        # included for compatibility with v7
-        @use_new_timestamp_format = use_new_timestamp_format
-        @include_type_name_on_create = include_type_name_on_create
       end
 
       def ref_index_name
@@ -60,23 +58,23 @@ module Elasticity
             ]
           })
 
-          @client.index_flush(index: original_index)
-          cursor = @client.search index: original_index, search_type: ScrollableSearch.search_type, scroll: '10m', size: 100
+          @client.index_refresh(index: original_index)
+          cursor = @client.search index: original_index, search_type: :query_then_fetch, scroll: "10m", size: 100
           loop do
-            hits   = cursor['hits']['hits']
+            hits   = cursor["hits"]["hits"]
             break if hits.empty?
 
             # Fetch documents based on the ids that existed when the migration started, to make sure we only migrate
             # documents that haven't been deleted.
             id_docs = hits.map do |hit|
-              { _index: original_index, _type: hit["_type"], _id: hit["_id"] }
+              { _index: original_index, _id: hit["_id"] }
             end
 
             docs = @client.mget(body: { docs: id_docs }, refresh: true)["docs"]
             break if docs.empty?
 
             # Modify document hashes to match the mapping definition so that legacy fields aren't added
-            defined_mapping_fields = index_def[:mappings][docs.first["_type"]]["properties"].keys
+            defined_mapping_fields = index_def[:mappings]["properties"].keys
 
             # Move only documents that still exists on the old index, into the new index.
             ops = []
@@ -84,7 +82,7 @@ module Elasticity
               if doc["found"]
                 legacy_fields = doc["_source"].keys - defined_mapping_fields
                 legacy_fields.each { |field| doc["_source"].delete(field) }
-                ops << { index: { _index: new_index, _type: doc["_type"], _id: doc["_id"], data: doc["_source"] } }
+                ops << { index: { _index: new_index, _id: doc["_id"], data: doc["_source"] } }
               end
             end
 
@@ -94,12 +92,12 @@ module Elasticity
             ops = []
             @client.mget(body: { docs: id_docs }, refresh: true)["docs"].each_with_index do |new_doc, idx|
               if docs[idx]["found"] && !new_doc["found"]
-                ops << { delete: { _index: new_index, _type: new_doc["_type"], _id: new_doc["_id"] } }
+                ops << { delete: { _index: new_index, _id: new_doc["_id"] } }
               end
             end
 
             @client.bulk(body: ops) unless ops.empty?
-            cursor = @client.scroll(scroll_id: cursor['_scroll_id'], scroll: '1m', body: { scroll_id: cursor["_scroll_id"] })
+            cursor = @client.scroll(scroll_id: cursor["_scroll_id"], scroll: "1m", body: { scroll_id: cursor["_scroll_id"] })
           end
 
           # Update aliases to only point to the new index.
@@ -130,23 +128,23 @@ module Elasticity
             ]
           })
 
-          @client.index_flush(index: new_index)
-          cursor = @client.search index: new_index, search_type: ScrollableSearch.search_type, scroll: '1m', size: 100
+          @client.index_refresh(index: new_index)
+          cursor = @client.search index: new_index, search_type: :query_then_fetch, scroll: "1m", size: 100
           loop do
-            hits   = cursor['hits']['hits']
+            hits   = cursor["hits"]["hits"]
             break if hits.empty?
 
             # Move all the documents that exists on the new index back to the old index
             ops = []
             hits.each do |doc|
-              ops << { index: { _index: original_index, _type: doc["_type"], _id: doc["_id"], data: doc["_source"] } }
+              ops << { index: { _index: original_index, _id: doc["_id"], data: doc["_source"] } }
             end
 
             @client.bulk(body: ops)
-            cursor = @client.scroll(scroll_id: cursor['_scroll_id'], scroll: '1m')
+            cursor = @client.scroll(scroll_id: cursor["_scroll_id"], scroll: "1m")
           end
 
-          @client.index_flush(index: original_index)
+          @client.index_refresh(index: original_index)
           @client.index_update_aliases(body: {
             actions: [
               { remove: { index: new_index, alias: @main_alias } },
@@ -222,8 +220,8 @@ module Elasticity
         create(index_def)
       end
 
-      def index_document(type, id, attributes)
-        res = @client.index(index: @update_alias, type: type, id: id, body: attributes)
+      def index_document(id, attributes)
+        res = @client.index(index: @update_alias, id: id, body: attributes)
 
         if id = res["_id"]
           [id, res["_shards"] && res["_shards"]["successful"].to_i > 0]
@@ -232,24 +230,24 @@ module Elasticity
         end
       end
 
-      def delete_document(type, id)
+      def delete_document(id)
         ops = (main_indexes | update_indexes).map do |index|
-          { delete: { _index: index, _type: type, _id: id } }
+          { delete: { _index: index, _id: id } }
         end
 
         @client.bulk(body: ops)
       end
 
-      def get_document(type, id)
-        @client.get(index: @main_alias, type: type, id: id)
+      def get_document(id)
+        @client.get(index: @main_alias, id: id)
       end
 
       def search_index
         @main_alias
       end
 
-      def delete_by_query(type, body)
-        @client.delete_by_query(index: @main_alias, type: type, body: body)
+      def delete_by_query(body)
+        @client.delete_by_query(index: @main_alias, body: body)
       end
 
       def bulk
@@ -267,21 +265,21 @@ module Elasticity
       end
 
       def settings
-        @client.index_get_settings(index: @main_alias, type: @document_type).values.first
+        @client.index_get_settings(index: @main_alias).values.first
       rescue Elasticsearch::Transport::Transport::Errors::NotFound
         nil
       end
 
       def mappings
         ActiveSupport::Deprecation.warn(
-          'Elasticity::Strategies::AliasIndex#mappings is deprecated, '\
-          'use mapping instead'
+          "Elasticity::Strategies::AliasIndex#mappings is deprecated, "\
+          "use mapping instead"
         )
         mapping
       end
 
       def mapping
-        @client.index_get_mapping(index: @main_alias, type: @document_type).values.first
+        @client.index_get_mapping(index: @main_alias).values.first
       rescue Elasticsearch::Transport::Transport::Errors::NotFound
         nil
       end
@@ -289,18 +287,13 @@ module Elasticity
       private
 
       def build_index_name
-        ts = String.new
-        if @use_new_timestamp_format == true
-          ts = Time.now.utc.strftime("%Y%m%d%H%M%S%6N")
-        else
-          ts = Time.now.utc.strftime("%Y-%m-%d_%H:%M:%S.%6N")
-        end
+        ts = Time.now.utc.strftime("%Y%m%d%H%M%S%6N")
         "#{@main_alias}-#{ts}"
       end
 
       def create_index(index_def)
         name = build_index_name
-        @client.index_create(index: name, body: index_def, include_type_name: @include_type_name_on_create)
+        @client.index_create(index: name, body: index_def)
         name
       end
 

data/lib/elasticity/strategies/single_index.rb

@@ -1,18 +1,14 @@
+# frozen_string_literal: true
+
 module Elasticity
   module Strategies
     class SingleIndex
       STATUSES = [:missing, :ok]
 
-      def initialize(client, index_name, document_type, use_new_timestamp_format = false, include_type_name_on_create = true)
+      def initialize(client, index_name, document_type, use_new_timestamp_format = nil, include_type_name_on_create = nil)
         @client        = client
         @index_name    = index_name
         @document_type = document_type
-
-        # included for compatibility with v7
-        @include_type_name_on_create = include_type_name_on_create
-
-        # not currently used. included for argument compatiblity with AliasStrategy
-        @use_new_timestamp_format = use_new_timestamp_format
       end
 
       def ref_index_name
@@ -29,7 +25,7 @@ module Elasticity
 
       def create(index_def)
         if missing?
-          @client.index_create(index: @index_name, body: index_def, include_type_name: @include_type_name_on_create)
+          @client.index_create(index: @index_name, body: index_def)
         else
           raise IndexError.new(@index_name, "index already exist")
         end
@@ -52,8 +48,8 @@ module Elasticity
         create(index_def)
       end
 
-      def index_document(type, id, attributes)
-        res = @client.index(index: @index_name, type: type, id: id, body: attributes)
+      def index_document(id, attributes)
+        res = @client.index(index: @index_name, id: id, body: attributes)
 
         if id = res["_id"]
           [id, res["created"]]
@@ -62,20 +58,20 @@ module Elasticity
         end
       end
 
-      def delete_document(type, id)
-        @client.delete(index: @index_name, type: type, id: id)
+      def delete_document(id)
+        @client.delete(index: @index_name, id: id)
       end
 
-      def get_document(type, id)
-        @client.get(index: @index_name, type: type, id: id)
+      def get_document(id)
+        @client.get(index: @index_name, id: id)
       end
 
       def search_index
         @index_name
       end
 
-      def delete_by_query(type, body)
-        @client.delete_by_query(index: @index_name, type: type, body: body)
+      def delete_by_query(body)
+        @client.delete_by_query(index: @index_name, body: body)
       end
 
       def bulk
@@ -85,21 +81,21 @@ module Elasticity
       end
 
       def settings
-        @client.index_get_settings(index: @index_name, type: @document_type).values.first
+        @client.index_get_settings(index: @index_name).values.first
       rescue Elasticsearch::Transport::Transport::Errors::NotFound
         nil
       end
 
       def mappings
         ActiveSupport::Deprecation.warn(
-          'Elasticity::Strategies::SingleIndex#mappings is deprecated, '\
-          'use mapping instead'
+          "Elasticity::Strategies::SingleIndex#mappings is deprecated, "\
+          "use mapping instead"
         )
         mapping
       end
 
       def mapping
-        @client.index_get_mapping(index: @index_name, type: @document_type).values.first
+        @client.index_get_mapping(index: @index_name).values.first
       rescue Elasticsearch::Transport::Transport::Errors::NotFound
         nil
       end

data/lib/elasticity/strategies.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Elasticity
   module Strategies
     class IndexError < StandardError

data/lib/elasticity/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Elasticity
-  VERSION = "0.13.5"
+  VERSION = "1.0.0.jhumphreys"
 end