elasticsearch_record 1.0.0

data/lib/elasticsearch_record/extensions/relation.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ElasticsearchRecord
+  module Extensions
+    module Relation
+      def self.extended(base)
+        base.extend ::ElasticsearchRecord::Relation::CoreMethods
+        base.extend ::ElasticsearchRecord::Relation::CalculationMethods
+        base.extend ::ElasticsearchRecord::Relation::QueryMethods
+        base.extend ::ElasticsearchRecord::Relation::ResultMethods
+        base.extend ::ElasticsearchRecord::Relation::ValueMethods
+      end
+    end
+  end
+end

data/lib/elasticsearch_record/gem_version.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ElasticsearchRecord
+  # Returns the version of the currently loaded module as a <tt>Gem::Version</tt>
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 1
+    MINOR = 0
+    TINY  = 0
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end

data/lib/elasticsearch_record/instrumentation/controller_runtime.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/attr_internal'
+
+module ElasticsearchRecord
+  module Instrumentation
+    # Hooks into ActionController to display ElasticsearchRecord runtime
+    # @see https://github.com/rails/rails/blob/master/activerecord/lib/active_record/railties/controller_runtime.rb
+    #
+    module ControllerRuntime
+      extend ActiveSupport::Concern
+
+      protected
+
+      attr_internal :elasticsearch_record_runtime
+
+      def cleanup_view_runtime
+        elasticsearch_rt_before_render    = ElasticsearchRecord::Instrumentation::LogSubscriber.reset_runtime
+        runtime                           = super
+        elasticsearch_rt_after_render     = ElasticsearchRecord::Instrumentation::LogSubscriber.reset_runtime
+        self.elasticsearch_record_runtime = elasticsearch_rt_before_render + elasticsearch_rt_after_render
+        runtime - elasticsearch_rt_after_render
+      end
+
+      def append_info_to_payload(payload)
+        super
+        payload[:elasticsearch_record_runtime] = (elasticsearch_record_runtime || 0) + ElasticsearchRecord::Instrumentation::LogSubscriber.reset_runtime
+      end
+
+      module ClassMethods
+        def log_process_action(payload)
+          messages, elasticsearch_runtime = super, payload[:elasticsearch_record_runtime]
+          messages << ("ElasticsearchRecord: %.1fms" % elasticsearch_runtime.to_f) if elasticsearch_runtime
+          messages
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch_record/instrumentation/log_subscriber.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module ElasticsearchRecord
+  module Instrumentation
+    # attach to ElasticsearchRecord related events
+    class LogSubscriber < ActiveSupport::LogSubscriber
+
+      IGNORE_PAYLOAD_NAMES = ["SCHEMA", "EXPLAIN"]
+
+      def self.runtime=(value)
+        Thread.current["elasticsearch_record_runtime"] = value
+      end
+
+      def self.runtime
+        Thread.current["elasticsearch_record_runtime"] ||= 0
+      end
+
+      def self.reset_runtime
+        rt, self.runtime = runtime, 0
+        rt
+      end
+
+      # Intercept `search.elasticsearch` events, and display them in the Rails log
+      #
+      def query(event)
+        self.class.runtime += event.duration
+        return unless logger.debug?
+
+        payload = event.payload
+        return if IGNORE_PAYLOAD_NAMES.include?(payload[:name])
+
+        name = if payload[:async]
+                 "ASYNC #{payload[:name]} (#{payload[:lock_wait].round(1)}ms) (execution time #{event.duration.round(1)}ms)"
+               else
+                 "#{payload[:name]} (#{event.duration.round(1)}ms)"
+               end
+        name  = "CACHE #{name}" if payload[:cached]
+
+        name = "#{name} (took: #{payload[:arguments][:_qt].round(1)}ms)" if payload[:arguments][:_qt]
+
+        query  = payload[:arguments].except(:index, :_qt).inspect.gsub(/:(\w+)=>/, '\1: ').presence || '-'
+
+        # final coloring
+        name = color(name, CYAN, true)
+        query  = color(query, gate_color(payload[:gate]), true) if colorize_logging
+
+        debug "  #{name} #{query}"
+      end
+
+      private
+
+      def gate_color(gate)
+        case gate
+        when 'core.search', 'core.msearch'
+          BLUE
+        when 'core.delete', 'core.delete_by_query'
+          RED
+        when 'core.create'
+          GREEN
+        when 'core.update', 'core.update_by_query'
+          YELLOW
+        else
+          MAGENTA
+        end
+      end
+    end
+  end
+end
+
+ElasticsearchRecord::Instrumentation::LogSubscriber.attach_to :elasticsearch_record

data/lib/elasticsearch_record/instrumentation/railtie.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ElasticsearchRecord
+  module Instrumentation
+    class Railtie < ::Rails::Railtie
+      initializer "elasticsearch_record.instrumentation" do |_app|
+        require 'elasticsearch_record/instrumentation/log_subscriber'
+        require 'elasticsearch_record/instrumentation/controller_runtime'
+
+        ActiveSupport.on_load(:action_controller) do
+          include ElasticsearchRecord::Instrumentation::ControllerRuntime
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch_record/instrumentation.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ElasticsearchRecord
+  module Instrumentation
+    extend ActiveSupport::Autoload
+
+    autoload :ControllerRuntime
+    autoload :LogSubscriber
+    autoload :Railtie
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  # load Instrumentation
+  require 'elasticsearch_record/instrumentation/railtie'
+  require 'elasticsearch_record/instrumentation/log_subscriber'
+end

data/lib/elasticsearch_record/model_schema.rb

@@ -0,0 +1,43 @@
+module ElasticsearchRecord
+  module ModelSchema
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :index_base_name, instance_writer: false, default: nil
+    end
+
+    module ClassMethods
+      # Guesses the table name, but does not decorate it with prefix and suffix information.
+      def undecorated_table_name(model_name)
+        # check the 'index_base_name' first, so +table_name_prefix+ & +table_name_suffix+ can still be used
+        index_base_name || super(model_name)
+      end
+
+      # returns an array with columns names, that are not virtual (and not a base structure).
+      # so this is a array of real document (+_source+) attributes of the index.
+      # @return [Array<String>]
+      def source_column_names
+        @source_column_names ||= columns.reject(&:virtual).map(&:name) - ActiveRecord::ConnectionAdapters::ElasticsearchAdapter.base_structure_keys
+      end
+
+      # returns an array with columns names, that are searchable (also includes nested )
+      def searchable_column_names
+        @searchable_column_names ||= columns.reject(&:virtual).reduce([]) { |m, column|
+          m << column.name
+          m += column.fields if column.fields?
+          m
+        }
+      end
+
+      # clears schema-related instance variables.
+      # @see ActiveRecord::ModelSchema::ClassMethods#reload_schema_from_cache
+      def reload_schema_from_cache
+        # we also need to clear our custom-defined variables
+        @source_column_names     = nil
+        @searchable_column_names = nil
+
+        super
+      end
+    end
+  end
+end

data/lib/elasticsearch_record/patches/active_record/relation_merger_patch.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'active_record/relation/merger'
+
+module ElasticsearchRecord
+  module Patches
+    module ActiveRecord
+      module RelationMergerPatch
+        def self.included(base)
+          base.send(:prepend, PrependMethods)
+        end
+
+        module PrependMethods
+          def merge
+            # check for relation mismatch - prevent mash up different relations
+            if elasticsearch_relation? && !other_elasticsearch_relation?
+              message = "#{relation.class_name}(##{relation.klass.object_id}) expected, "\
+                "got #{other.inspect} which is an instance of #{other.class}(##{other.class.object_id})"
+              raise ActiveRecord::AssociationTypeMismatch, message
+            end
+
+            # enable & assign elasticsearch merger
+            if other_elasticsearch_relation? && !elasticsearch_relation?
+              assign_elasticsearch_relation!
+            end
+
+            super
+          end
+
+          private
+
+          # return true if this is a elasticsearch enabled relation
+          def elasticsearch_relation?
+            @elasticsearch_relation ||= relation.respond_to?(:kind_value)
+          end
+
+          # return true if the other relation is a elasticsearch enabled relation
+          def other_elasticsearch_relation?
+            @other_elasticsearch_relation ||= other.respond_to?(:kind_value)
+          end
+
+          def merge_single_values
+            super
+
+            # only for enabled elasticsearch relation
+            if elasticsearch_relation?
+              relation.kind_value ||= other.kind_value if other.kind_value.present?
+            end
+          end
+
+          def merge_multi_values
+            super
+
+            # only for enabled elasticsearch relation
+            if elasticsearch_relation?
+              relation.configure_value = relation.configure_value.merge(other.configure_value) if other.configure_value.present?
+            end
+          end
+
+          def merge_clauses
+            super
+
+            # only for enabled elasticsearch relation
+            if elasticsearch_relation?
+              query_clause          = relation.query_clause.merge(other.query_clause)
+              relation.query_clause = query_clause unless query_clause.empty?
+
+              aggs_clause          = relation.aggs_clause.merge(other.aggs_clause)
+              relation.aggs_clause = aggs_clause unless aggs_clause.empty?
+            end
+          end
+
+          def assign_elasticsearch_relation!
+            # sucks, but there is no other solution yet to NOT mess with
+            # ActiveRecord::Delegation::DelegateCache#initialize_relation_delegate_cache
+            relation.extend ElasticsearchRecord::Extensions::Relation
+          end
+        end
+      end
+    end
+  end
+end
+
+# include once only!
+::ActiveRecord::Relation::Merger.include(ElasticsearchRecord::Patches::ActiveRecord::RelationMergerPatch) unless ::ActiveRecord::Relation::Merger.included_modules.include?(ElasticsearchRecord::Patches::ActiveRecord::RelationMergerPatch)

data/lib/elasticsearch_record/patches/arel/select_core_patch.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'arel/nodes/select_core'
+
+module ElasticsearchRecord
+  module Patches
+    module Arel
+      module SelectCorePatch
+        def self.included(base)
+          base.send(:prepend, PrependMethods)
+        end
+
+        module PrependMethods
+          def initialize_copy(other)
+            super
+            @kind    = @kind.clone if @kind
+            @queries = @queries.clone if @queries
+            @aggs    = @aggs.clone if @aggs
+          end
+
+          def hash
+            [
+              super, @kind, @queries, @aggs
+            ].hash
+          end
+
+          def eql?(other)
+            super &&
+              self.kind == other.kind &&
+              self.queries == other.queries &&
+              self.aggs == other.aggs
+          end
+        end
+
+        def kind
+          @kind
+        end
+
+        def kind=(value)
+          @kind = value
+        end
+
+        def queries
+          @queries ||= []
+        end
+
+        def queries=(value)
+          @queries = value
+        end
+
+        def aggs
+          @aggs ||= []
+        end
+
+        def aggs=(value)
+          @aggs = value
+        end
+      end
+    end
+  end
+end
+
+# include once only!
+::Arel::Nodes::SelectCore.include(ElasticsearchRecord::Patches::Arel::SelectCorePatch) unless ::Arel::Nodes::SelectCore.included_modules.include?(ElasticsearchRecord::Patches::Arel::SelectCorePatch)

data/lib/elasticsearch_record/patches/arel/select_manager_patch.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'arel/select_manager'
+require 'arel/nodes/select_configure'
+require 'arel/nodes/select_kind'
+require 'arel/nodes/select_query'
+
+module ElasticsearchRecord
+  module Patches
+    module Arel
+      module SelectManagerPatch
+        def self.included(base)
+          base.send(:prepend, PrependMethods)
+        end
+
+        module PrependMethods
+          def compile_update(*args)
+            arel = super
+            arel.kind(_kind.expr) if _kind.present?
+            arel.query(_query.map(&:expr)) unless _query.empty?
+            arel.configure(_configure.expr) if _configure.present?
+            arel
+          end
+
+          def compile_delete(*args)
+            arel = super
+            arel.kind(_kind.expr) if _kind.present?
+            arel.query(_query.map(&:expr)) unless _query.empty?
+            arel.configure(_configure.expr) if _configure.present?
+            arel
+          end
+        end
+
+        def kind(value)
+          if value
+            @ctx.kind = ::Arel::Nodes::SelectKind.new(value)
+          else
+            @ctx.kind = nil
+          end
+        end
+
+        def _kind
+          @ctx.kind
+        end
+
+        def configure(value)
+          if value
+            @ast.configure = ::Arel::Nodes::SelectConfigure.new(value)
+          else
+            @ast.configure = nil
+          end
+        end
+
+        def _configure
+          @ast.configure
+        end
+
+        def query(value)
+          if value.is_a?(Array)
+            value.each { |val|
+              @ctx.queries << ::Arel::Nodes::SelectQuery.new(val)
+            }
+          else
+            @ctx.queries << ::Arel::Nodes::SelectQuery.new(value)
+          end
+        end
+
+        def _query
+          @ctx.queries
+        end
+
+        def aggs(value)
+          if value.is_a?(Array)
+            value.each { |val|
+              @ctx.aggs << ::Arel::Nodes::SelectAgg.new(val)
+            }
+          else
+            @ctx.aggs << ::Arel::Nodes::SelectAgg.new(value)
+          end
+        end
+
+        def _aggs
+          @ctx.aggs
+        end
+      end
+    end
+  end
+end
+
+# include once only!
+::Arel::SelectManager.include(ElasticsearchRecord::Patches::Arel::SelectManagerPatch) unless ::Arel::SelectManager.included_modules.include?(ElasticsearchRecord::Patches::Arel::SelectManagerPatch)

data/lib/elasticsearch_record/patches/arel/select_statement_patch.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'arel/nodes/select_statement'
+
+module ElasticsearchRecord
+  module Patches
+    module Arel
+      module SelectStatementPatch
+        def self.included(base)
+          base.send(:prepend, PrependMethods)
+        end
+
+        module PrependMethods
+          def initialize_copy(other)
+            super
+            @configure  = @configure&.deep_dup
+          end
+
+          def hash
+            [super, @configure].hash
+          end
+
+          def eql?(other)
+            super && configure == other.configure
+          end
+        end
+
+        def configure
+          @configure
+        end
+
+        def configure=(value)
+          @configure = value
+        end
+      end
+    end
+  end
+end
+
+# include once only!
+::Arel::Nodes::SelectStatement.include(ElasticsearchRecord::Patches::Arel::SelectStatementPatch) unless ::Arel::Nodes::SelectStatement.included_modules.include?(ElasticsearchRecord::Patches::Arel::SelectStatementPatch)

data/lib/elasticsearch_record/patches/arel/update_manager_patch.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'arel/update_manager'
+require 'arel/delete_manager'
+
+require 'arel/nodes/select_configure'
+require 'arel/nodes/select_kind'
+require 'arel/nodes/select_query'
+
+module ElasticsearchRecord
+  module Patches
+    module Arel
+      module UpdateManagerPatch
+        def kind(value)
+          if value
+            @ast.kind = ::Arel::Nodes::SelectKind.new(value)
+          else
+            @ast.kind = nil
+          end
+        end
+
+        def configure(value)
+          if value
+            @ast.configure = ::Arel::Nodes::SelectConfigure.new(value)
+          else
+            @ast.configure = nil
+          end
+        end
+
+        def query(value)
+          if value.is_a?(Array)
+            value.each { |val|
+              @ast.queries << ::Arel::Nodes::SelectQuery.new(val)
+            }
+          else
+            @ast.queries << ::Arel::Nodes::SelectQuery.new(value)
+          end
+        end
+      end
+    end
+  end
+end
+
+# include once only!
+::Arel::UpdateManager.include(ElasticsearchRecord::Patches::Arel::UpdateManagerPatch) unless ::Arel::UpdateManager.included_modules.include?(ElasticsearchRecord::Patches::Arel::UpdateManagerPatch)
+::Arel::DeleteManager.include(ElasticsearchRecord::Patches::Arel::UpdateManagerPatch) unless ::Arel::DeleteManager.included_modules.include?(ElasticsearchRecord::Patches::Arel::UpdateManagerPatch)

data/lib/elasticsearch_record/patches/arel/update_statement_patch.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'arel/nodes/update_statement'
+require 'arel/nodes/delete_statement'
+
+module ElasticsearchRecord
+  module Patches
+    module Arel
+      module UpdateStatementPatch
+        def self.included(base)
+          base.send(:prepend, PrependMethods)
+        end
+
+        module PrependMethods
+          def initialize_copy(other)
+            super
+            @configure  = @configure&.deep_dup
+            @queries  = @queries&.clone
+          end
+
+          def hash
+            [super, @configure, @queries].hash
+          end
+
+          def eql?(other)
+            super && kind == other.kind && configure == other.configure && queries == other.queries
+          end
+        end
+
+        def kind
+          @kind
+        end
+
+        def kind=(value)
+          @kind = value
+        end
+
+        def queries
+          @queries ||= []
+        end
+
+        def queries=(value)
+          @queries = value
+        end
+
+        def configure
+          @configure
+        end
+
+        def configure=(value)
+          @configure = value
+        end
+      end
+    end
+  end
+end
+
+# include once only!
+::Arel::Nodes::UpdateStatement.include(ElasticsearchRecord::Patches::Arel::UpdateStatementPatch) unless ::Arel::Nodes::UpdateStatement.included_modules.include?(ElasticsearchRecord::Patches::Arel::UpdateStatementPatch)
+::Arel::Nodes::DeleteStatement.include(ElasticsearchRecord::Patches::Arel::UpdateStatementPatch) unless ::Arel::Nodes::DeleteStatement.included_modules.include?(ElasticsearchRecord::Patches::Arel::UpdateStatementPatch)

data/lib/elasticsearch_record/persistence.rb

@@ -0,0 +1,80 @@
+module ElasticsearchRecord
+  module Persistence
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      # insert a new record into the Elasticsearch index
+      # NOTICE: We don't want to mess up with the Arel-builder - so we send new data directly to the API
+      def _insert_record(values)
+        # values is not a "key=>values"-Hash, but a +ActiveModel::Attribute+ - so we need to resolve the casted values here
+        values = values.transform_values(&:value)
+
+        # if a primary_key (+_id+) was provided, we need to extract this and allocate this to the arguments
+        arguments = if (id = values.delete(self.primary_key)).present?
+                      { id: id }
+                    else
+                      {}
+                    end
+
+        # build new query
+        query = ElasticsearchRecord::Query.new(
+          index:     table_name,
+          type:      ElasticsearchRecord::Query::TYPE_CREATE,
+          body:      values,
+          arguments: arguments,
+          refresh:   true)
+
+        # execute query and build a RAW response
+        response = connection.exec_query(query, "#{self} Create").response
+
+        raise RecordNotSaved unless response['result'] == 'created'
+
+        # return the new id
+        response['_id']
+      end
+
+      # updates a persistent entry in the Elasticsearch index
+      # NOTICE: We don't want to mess up with the Arel-builder - so we send new data directly to the API
+      def _update_record(values, constraints)
+        # values is not a "key=>values"-Hash, but a +ActiveModel::Attribute+ - so we need to resolve the casted values here
+        values = values.transform_values(&:value)
+
+        # build new query
+        query = ElasticsearchRecord::Query.new(
+          index:     table_name,
+          type:      ElasticsearchRecord::Query::TYPE_UPDATE,
+          body:      { doc: values },
+          arguments: { id: constraints['_id'] },
+          refresh:   true)
+
+        # execute query and build a RAW response
+        response = connection.exec_query(query, "#{self} Update").response
+
+        raise RecordNotSaved unless response['result'] == 'updated'
+
+        # return affected rows
+        response['_shards']['total']
+      end
+
+      # removes a persistent entry from the Elasticsearch index
+      # NOTICE: We don't want to mess up with the Arel-builder - so we send new data directly to the API
+      def _delete_record(constraints)
+        # build new query
+        query = ElasticsearchRecord::Query.new(
+          index:     table_name,
+          type:      ElasticsearchRecord::Query::TYPE_DELETE,
+          arguments: { id: constraints[self.primary_key] },
+          refresh:   true)
+
+        # execute query and build a RAW response
+        response = connection.exec_query(query, "#{self} Destroy").response
+
+        raise RecordNotDestroyed unless response['result'] == 'deleted'
+
+        # return affected rows
+        response['_shards']['total']
+      end
+    end
+  end
+end