elasticsearch_record 1.8.2 → 3.0.0

data/lib/active_record/connection_adapters/elasticsearch_adapter.rb

@@ -22,23 +22,23 @@ gem 'elasticsearch'
 require 'elasticsearch'
 
 module ActiveRecord # :nodoc:
-  module ConnectionHandling # :nodoc:
-    def elasticsearch_adapter_class
-      ConnectionAdapters::ElasticsearchAdapter
-    end
-
-    def elasticsearch_connection(config)
-      elasticsearch_adapter_class.new(config)
-    end
-  end
-
   module ConnectionAdapters # :nodoc:
     class ElasticsearchAdapter < AbstractAdapter
+      include Elasticsearch::UnsupportedImplementation
+      include Elasticsearch::Quoting
+      include Elasticsearch::DatabaseStatements
+      include Elasticsearch::SchemaStatements
+      include Elasticsearch::TableStatements
+      include Elasticsearch::Transactions
+
       # defines the *Elasticsearch* adapter name.
-      ADAPTER_NAME = "Elasticsearch"
+      # @return [String]
+      ADAPTER_NAME = "Elasticsearch".freeze
 
       # defines the Elasticsearch 'base' structure, which is always included but cannot be resolved through mappings ...
-      BASE_STRUCTURE = [
+      # - see @ https://www.elastic.co/guide/en/elasticsearch/reference/current/mapping-fields.html
+      # @return [Hash]
+      METADATA_FIELDS = [
         { 'name' => '_id', 'type' => 'keyword', 'meta' => { 'primary_key' => 'true' } },
         { 'name' => '_index', 'type' => 'keyword', 'virtual' => true },
         { 'name' => '_score', 'type' => 'float', 'virtual' => true },
@@ -46,17 +46,10 @@ module ActiveRecord # :nodoc:
         { 'name' => '_ignored', 'type' => 'boolean', 'virtual' => true }
       ].freeze
 
-      include Elasticsearch::UnsupportedImplementation
-      include Elasticsearch::Quoting
-      include Elasticsearch::DatabaseStatements
-      include Elasticsearch::SchemaStatements
-      include Elasticsearch::TableStatements
-      include Elasticsearch::Transactions
-
       class << self
-        def base_structure_keys
+        def metadata_keys
           # using a class_variable to not reinitialize for descendants
-          @@base_structure_keys ||= BASE_STRUCTURE.map { |struct| struct['name'] }.freeze
+          @@metadata_keys ||= METADATA_FIELDS.map { |struct| struct['name'] }.freeze
         end
 
         def new_client(config)
@@ -65,7 +58,7 @@ module ActiveRecord # :nodoc:
           # add rails logger manually, if +:log+ is true
           client_config[:logger] = logger if client_config.delete(:log)
 
-          # build an return new client
+          # build and return new client
           ::Elasticsearch::Client.new(client_config)
         rescue ::Elastic::Transport::Transport::Errors::Unauthorized
           raise ::ActiveRecord::DatabaseConnectionError.username_error(config[:user])
@@ -129,20 +122,22 @@ module ActiveRecord # :nodoc:
         end
       end
 
+      # -- TYPE MAP -- DO NOT insert before this line (*initialize_type_map* needs to be rewritten)
       # reinitialize the constant with new types
       TYPE_MAP = ActiveRecord::Type::HashLookupTypeMap.new.tap { |m| initialize_type_map(m) }
 
       # define native types - which will be used for schema-dumping
+      # @return [Hash]
       NATIVE_DATABASE_TYPES = {
         primary_key: { name: 'long' }, # maybe this hae to changed to 'keyword'
         string:   { name: 'keyword' },
         blob:     { name: 'binary' },
         datetime: { name: 'date' },
         bigint:   { name: 'long' },
-        json:     { name: 'object' }
-      }.merge(
-        TYPE_MAP.keys.map { |key| [key.to_sym, { name: key }] }.to_h
-      )
+        json:     { name: 'object' },
+
+        **TYPE_MAP.keys.map { |key| [key.to_sym, { name: key }] }.to_h
+      }.freeze
 
       def initialize(...)
         super
@@ -163,15 +158,27 @@ module ActiveRecord # :nodoc:
       end
 
       def schema_migration # :nodoc:
-        ElasticsearchRecord::SchemaMigration.new(self)
+        ElasticsearchRecord::SchemaMigration.new(pool)
+      end
+
+      def internal_metadata # :nodoc:
+        ElasticsearchRecord::InternalMetadata.new(pool)
+      end
+
+      # since rails 7.2 the migration context is resolved through the connection pool -
+      # provided here as connection method again (used by +#assume_migrated_upto_version+)
+      def migration_context # :nodoc:
+        pool.migration_context
       end
 
       # provide a table_name_prefix from the configuration to create & restrict schema creation
+      # HINT: This is not an official setting and only introduced to ElasticsearchRecord.
       def table_name_prefix
         @config.fetch(:table_name_prefix, '')
       end
 
       # provide a table_name_suffix from the configuration to create & restrict schema creation
+      # HINT: This is not an official setting and only introduced to ElasticsearchRecord.
       def table_name_suffix
         @config.fetch(:table_name_suffix, '')
       end
@@ -188,7 +195,7 @@ module ActiveRecord # :nodoc:
       end
 
       # Does this adapter support transactions in general?
-      # HINT: This is +NOT* an official setting and only introduced to ElasticsearchRecord
+      # HINT: This is not an official setting and only introduced to ElasticsearchRecord.
       def supports_transactions?
         false
       end
@@ -229,51 +236,69 @@ module ActiveRecord # :nodoc:
         NATIVE_DATABASE_TYPES
       end
 
-      # calls the +elasticsearch-api+ endpoints by provided namespace and action.
-      # if a block was provided it'll yield the response.body and returns the blocks result.
-      # otherwise it will return the response itself...
-      # @param [Symbol] namespace - the API namespace (e.g. indices, nodes, sql, ...)
-      # @param [Symbol] action - the API action to call in tha namespace
-      # @param [Hash] arguments - action arguments
+      # calls the +elasticsearch-api+ endpoints by provided gate and returns a response object.
+      # @param [Symbol,String] gate - the API namespace & action gate (e.g. 'indices.get','cluster.health', :bulk, ...)
+      # @param [Hash] arguments - gate arguments
       # @param [String (frozen)] name - the logging name
-      # @param [Boolean] async - send async (default: false) - currently not supported
-      # @param [Boolean] log - send log to instrumenter (default: true)
+      # @param [Boolean] async - send async (default: false) - NOT supported!
+      # @param [Boolean] allow_retry - allows to retry a possible failing query (default: false)
+      # @param [Boolean] materialize_transactions - materializes transactions (default: false) - NOT supported!
       # @return [Elasticsearch::API::Response, Object]
-      def api(namespace, action, arguments = {}, name = 'API', async: false, log: true)
+      def api(gate, arguments = {}, name = 'API', async: false, allow_retry: false, materialize_transactions: false)
+        raise ::ArgumentError, "ElasticsearchRecord API call is now using a single `gate` instead of providing `namespace & action`.\n'core' namespace must not provided (only provide action symbol) - any other must be provided as string (e.g. 'nodes.stats')" if arguments.is_a?(Symbol)
         raise ::StandardError, 'ASYNC api calls are not supported' if async
 
-        # resolve the API target
-        target = namespace == :core ? raw_connection : raw_connection.__send__(namespace)
-
-        __send__(:log, "#{namespace}.#{action}", arguments, name, async: async, log: log) do
-          response = ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-            target.__send__(action, arguments)
-          end
-
-          if response.is_a?(::Elasticsearch::API::Response)
-            # reverse information for the LogSubscriber - shows the 'query-time' in the logs
-            # this works, since we use a referenced hash ...
-            arguments[:_qt] = response['took']
+        # drop 'core.' prefix, if provided
+        if gate.is_a?(String) && gate[0..4] == 'core.'
+          # add deprecation warning
+          ::ActiveRecord.deprecator.warn(<<~MSG)
+            Providing the 'core.' namespace prefix in the `gate` parameter is deprecated and will be removed in a future version.
+            Please provide only the action symbol (e.g.:bulk) or the full namespace and action as a string (e.g.'nodes.stats')
+          MSG
+
+          # IMPORTANT: only strip the *prefix* - a +gsub+ would also replace any later occurrence
+          # (e.g. 'core.score.thing' would become :sthing)
+          gate = gate.delete_prefix('core.').to_sym
+        end
 
-            # raise timeouts
-            raise(ActiveRecord::StatementTimeout, "Elasticsearch api request failed due a timeout") if response['timed_out']
+        # PLEASE NOTE: Don't remove the +statistics+ assignment here.
+        # - this is required as referenced hash for the instrumentation
+        log(gate, arguments, name, async: async, statistics: (statistics = {})) do
+          with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
+            response = ::ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+              # determinate the correct target from the provided gate
+              if gate.is_a?(Symbol) || !gate.include?('.')
+                conn.__send__(gate, arguments)
+              else
+                namespace, action = gate.split('.')
+                conn.__send__(namespace).__send__(action, arguments)
+              end
+            end
+
+            # marks the connection as verified (an AbstractAdapter method, which is used to decide how errors and connections are handled)
+            verified!
+
+            if response.is_a?(::Elasticsearch::API::Response)
+              # reverse information for the LogSubscriber - shows the 'query-time' in the logs
+              # this works, since we use a referenced hash ...
+              statistics[:took] = response['took']
+
+              # raise timeouts
+              raise(::ActiveRecord::StatementTimeout, "Elasticsearch api request failed due a timeout") if response['timed_out']
+            end
+
+            # return response
+            response
           end
-
-          response
         end
       end
 
-      private
-
-      def connect
-        @raw_connection = self.class.new_client(@connection_parameters)
-      rescue ::ActiveRecord::ConnectionNotEstablished => ex
-        raise ex.set_pool(@pool)
-      end
-
       def reconnect
-        @raw_connection = nil
-        connect
+        @lock.synchronize do
+          # no need to 'close' a connection for +::Elasticsearch::Client+ / +::Elastic::Transport+
+          @raw_connection = nil
+          connect
+        end
       end
 
       def active?
@@ -283,62 +308,94 @@ module ActiveRecord # :nodoc:
       # Disconnects from the database if already connected.
       # Otherwise, this method does nothing.
       def disconnect!
-        super
-        @raw_connection = nil
+        @lock.synchronize do
+          super
+          # no need to 'close' a connection for +::Elasticsearch::Client+ / +::Elastic::Transport+
+          @raw_connection = nil
+        end
       end
 
       alias :reset! :reconnect!
 
+      private
+
+      def connect
+        @raw_connection = self.class.new_client(@connection_parameters)
+      rescue ::ActiveRecord::ConnectionNotEstablished => ex
+        raise ex.set_pool(@pool)
+      end
+
       def type_map
         TYPE_MAP
       end
 
+      # OVERWRITE - to support +::ActiveRecord::StatementTimeout+ as possible retry.
+      # IMPORTANT: From the point ES supports transactions (+#supports_transactions?+) this must be redefined with a *super* call.
+      def retryable_query_error?(exception)
+        exception.is_a?(::ActiveRecord::StatementTimeout) || exception.is_a?(::ActiveRecord::Deadlocked) || exception.is_a?(::ActiveRecord::LockWaitTimeout)
+      end
+
       # catch Elasticsearch Transport-errors to be treated as +StatementInvalid+ (the original message is still readable ...)
       def translate_exception(exception, message:, sql:, binds:)
         case exception
         when ::Elastic::Transport::Transport::Errors::ClientClosedRequest
-          ::ActiveRecord::QueryCanceled.new(message, sql: sql, binds: binds)
+          ::ActiveRecord::QueryCanceled.new(message, sql: sql, binds: binds, connection_pool: @pool)
         when ::Elastic::Transport::Transport::Errors::RequestTimeout
-          ::ActiveRecord::StatementTimeout.new(message, sql: sql, binds: binds)
+          ::ActiveRecord::StatementTimeout.new(message, sql: sql, binds: binds, connection_pool: @pool)
         when ::Elastic::Transport::Transport::Errors::Conflict
-          ::ActiveRecord::RecordNotUnique.new(message, sql: sql, binds: binds)
+          ::ActiveRecord::RecordNotUnique.new(message, sql: sql, binds: binds, connection_pool: @pool)
         when ::Elastic::Transport::Transport::Errors::BadRequest
           if exception.message.match?(/resource_already_exists_exception/)
-            ::ActiveRecord::DatabaseAlreadyExists.new(message, sql: sql, binds: binds)
+            ::ActiveRecord::DatabaseAlreadyExists.new(message, sql: sql, binds: binds, connection_pool: @pool)
           else
-            ::ActiveRecord::StatementInvalid.new(message, sql: sql, binds: binds)
+            ::ActiveRecord::StatementInvalid.new(message, sql: sql, binds: binds, connection_pool: @pool)
           end
         when ::Elastic::Transport::Transport::Errors::Unauthorized
           ::ActiveRecord::DatabaseConnectionError.username_error(@config[:username])
           # must be last 'Elastic' error
         when ::Elastic::Transport::Transport::ServerError
-          ::ActiveRecord::StatementInvalid.new(message, sql: sql, binds: binds)
+          ::ActiveRecord::StatementInvalid.new(message, sql: sql, binds: binds, connection_pool: @pool)
         else
           # just forward the exception ...
           exception
         end
       end
 
-      # provide a custom log instrumenter for elasticsearch subscribers
-      def log(gate, arguments, name, async: false, log: true, &block)
-        if log
-          @instrumenter.instrument(
-            "query.elasticsearch_record",
-            gate:      gate,
-            name:      name,
-            arguments: gate == 'core.msearch' ? arguments.deep_dup : arguments,
-            async:     async) do
-            @lock.synchronize(&block)
-          rescue => e
-            raise translate_exception_class(e, arguments, [])
-          end
-        else
-          begin
-            @lock.synchronize(&block)
-          rescue => e
-            raise translate_exception_class(e, arguments, [])
-          end
-        end
+      # Logs and instruments Elasticsearch operations.
+      #
+      # This method facilitates logging and instrumentation of Elasticsearch queries
+      # by delegating the execution to the instrumenter. It also captures any raised
+      # exceptions during execution, translating them into a domain-specific class.
+      #
+      # Queries are tracked under the "query.elasticsearch_record" event, allowing
+      # listeners or subscribers to analyze the performance and behavior of the
+      # queries.
+      #
+      # A `translate_exception_class` helper is used to ensure that any exceptions
+      # raised are appropriately captured and translated with contextual details.
+      #
+      # @param [Symbol, String] gate the target gate for the Elasticsearch operation,
+      #   representing either a `<namespace>.<action>` or an `core.<action>`.
+      # @param [Hash] arguments the request parameters to be sent for the operation.
+      # @param [String] name a label for the operation, defaulting to 'QUERY'.
+      # @param [Boolean] async whether the operation is asynchronous. Defaults to `false`.
+      # @param [Hash, nil] statistics an optional hash for gathering operation metadata.
+      # @yield [block] the operation block to be executed under logging and instrumentation.
+      # @raise [Exception] any exception encountered during execution, after translation.
+      # @return [void]
+      def log(gate, arguments, name = 'QUERY', async: false, statistics: nil, &block)
+        @instrumenter.instrument(
+          "query.elasticsearch_record",
+          gate: gate,
+          name: name,
+          arguments: arguments,
+          async: async,
+          statistics: statistics,
+          connection: self,
+          &block
+        )
+      rescue => e
+        raise translate_exception_class(e, arguments, [])
       end
 
       # returns a new collector for the Arel visitor.
@@ -348,13 +405,13 @@ module ActiveRecord # :nodoc:
         # so we don't have to check for +prepared_statements+ here.
         # Also, bindings are (currently) not supported.
         # So, we just need a single, simple query collector...
-        Arel::Collectors::ElasticsearchQuery.new
+        ::Arel::Collectors::ElasticsearchQuery.new
       end
 
       # returns a new visitor to compile Arel into Elasticsearch Hashes (in this case we use a query object)
       # @return [Arel::Visitors::Elasticsearch]
       def arel_visitor
-        Arel::Visitors::Elasticsearch.new(self)
+        ::Arel::Visitors::Elasticsearch.new(self)
       end
 
       # Builds the result object.
@@ -362,14 +419,22 @@ module ActiveRecord # :nodoc:
       # custom result objects with response-specific data.
       # @return [ElasticsearchRecord::Result]
       def build_result(response, columns: [], column_types: {})
-        ElasticsearchRecord::Result.new(response, columns, column_types)
+        ::ElasticsearchRecord::Result.new(response, columns, column_types)
       end
 
       # register native types
-      ActiveRecord::Type.register(:format_string, ActiveRecord::ConnectionAdapters::Elasticsearch::Type::FormatString, adapter: :elasticsearch)
-      ActiveRecord::Type.register(:multicast_value, ActiveRecord::ConnectionAdapters::Elasticsearch::Type::MulticastValue, adapter: :elasticsearch)
-      ActiveRecord::Type.register(:object, ActiveRecord::ConnectionAdapters::Elasticsearch::Type::Object, adapter: :elasticsearch, override: false)
-      ActiveRecord::Type.register(:range, ActiveRecord::ConnectionAdapters::Elasticsearch::Type::Range, adapter: :elasticsearch)
+      ::ActiveRecord::Type.register(:format_string, ::ActiveRecord::ConnectionAdapters::Elasticsearch::Type::FormatString, adapter: :elasticsearch)
+      ::ActiveRecord::Type.register(:multicast_value, ::ActiveRecord::ConnectionAdapters::Elasticsearch::Type::MulticastValue, adapter: :elasticsearch)
+      ::ActiveRecord::Type.register(:object, ::ActiveRecord::ConnectionAdapters::Elasticsearch::Type::Object, adapter: :elasticsearch, override: false)
+      ::ActiveRecord::Type.register(:range, ::ActiveRecord::ConnectionAdapters::Elasticsearch::Type::Range, adapter: :elasticsearch)
     end
   end
-end
+end
+
+# since rails 7.2 an adapter has to register itself - the former load-by-convention
+# through +ConnectionHandling#elasticsearch_connection+ is gone
+ActiveRecord::ConnectionAdapters.register(
+  'elasticsearch',
+  'ActiveRecord::ConnectionAdapters::ElasticsearchAdapter',
+  'active_record/connection_adapters/elasticsearch_adapter'
+)

data/lib/arel/collectors/elasticsearch_query.rb

@@ -9,6 +9,9 @@ module Arel # :nodoc: all
       # required for ActiveRecord
       attr_accessor :preparable
 
+      # required for ActiveRecord (rails 7.2 marks idempotent queries as retryable)
+      attr_accessor :retryable
+
       # returns the current bind index (default: 1)
       attr_reader :bind_index
 

data/lib/arel/visitors/elasticsearch_query.rb

@@ -122,7 +122,8 @@ module Arel # :nodoc: all
         # IMPORTANT: Since Elasticsearch does not store nil-values in the +_source+ / +doc+ it will NOT return
         # empty / nil columns - instead the nil columns do not exist!!!
         # This is a big mess, because those missing columns are +not+ editable or savable in any way after we initialize the record...
-        # To prevent NOT-accessible attributes, we need to provide the "full-column-definition" to the query.
+        # To prevent NOT-accessible attributes, we need to provide the "full-column-definition" to the query as +default+.
+        # This may be overwritten by the 'visit_Selects'
         resource_klass = o.source.left.instance_variable_get(:@klass)
         claim(:columns, resource_klass.source_column_names) if resource_klass.respond_to?(:source_column_names)
 
@@ -193,22 +194,54 @@ module Arel # :nodoc: all
         when '*'
           # force return all fields
           # assign(:_source, true)
+        when ::ElasticsearchRecord::Query::COLUMNS_NONE
+          # force return NO fields - metadata fields ('_id', '_score', ...) are not part of the
+          # +_source+ and are always returned on the document level, so they stay accessible.
+          assign(:_source, false)
+
+          # clears the columns claimed by +visit_Arel_Nodes_SelectCore+ - a projection is the only
+          # place that runs late enough to undo them.
+          # HINT: an empty array equals the +Query+ default, so +Result#_results_from_hits+ takes its
+          # "no columns" branch and returns the raw document. Together with the +_source: false+ above
+          # this leaves exactly the metadata fields.
+          claim(:columns, [])
         when ::ActiveRecord::FinderMethods::ONE_AS_ONE
           # force return NO fields
           assign(:_source, false)
+
+          # also clear the columns in the query (which will be forwarded to +ElasticsearchRecord::Result+)
+          # HINT: If future changes rely on the first column value (in this case '1' -> SELECT 1 AS one) this must be fixed within the +ElasticsearchRecord::Result+.
+          # Maybe check on the columns[0] value within the #rows method ...
+          claim(:columns, %w[one])
         else
-          assign(:_source, fields)
-          # also overwrite the columns in the query
+          # IMPORTANT: metadata fields (like '_id' or '_score') are NOT part of the +_source+ node - they
+          # are always returned on the document level. Providing them to the +_source+-filter would create
+          # a filter that never matches, so they must be removed here.
+          source_fields = fields - ActiveRecord::ConnectionAdapters::ElasticsearchAdapter.metadata_keys
+
+          # if ONLY metadata fields were provided we must not resolve any +_source+ at all.
+          assign(:_source, source_fields.presence || false)
+
+          # also overwrite the columns in the query (which will be forwarded to +ElasticsearchRecord::Result+)
+          # HINT: metadata fields must stay within the columns - they are resolved from the document level.
           claim(:columns, fields)
         end
       end
 
       # CUSTOM node by elasticsearch_record
       def visit_Create(o)
-        # sets values
-        if o.values
-          values = collect(o.values) # visit_Arel_Nodes_ValuesList
-          claim(:body, values) if values.present?
+        # detect, if *columns* where provided.
+        # This happens through the +::Arel::InsertManager#insert+ by splitting up the columns & values.
+        values = if o.columns.present?
+                   # IMPORTANT: we do not "visit" the columns & rows here but directly build a final hash.
+                   # o.values.rows.*first* (first) is correct here, since +::Arel::InsertManager#create_values+ will provide all values in a nested Array
+                   collect(Hash[o.columns.map(&:name).zip(o.values.rows.first)])
+                 elsif o.values.present?
+                   collect(o.values)
+                 end
+
+        if values.present?
+          claim(:body, values)
         else
           failed!
         end
@@ -356,9 +389,9 @@ module Arel # :nodoc: all
         self.collector.add_binds(values, o.proc_for_binds)
 
         if o.type == :in
-          assign(:filter, [{ terms: { o.column_name => o.casted_values } }])
+          assign(:filter, [{ terms: { visit(o.left) => o.casted_values } }])
         else
-          assign(:must_not, [{ terms: { o.column_name => o.casted_values } }])
+          assign(:must_not, [{ terms: { visit(o.left) => o.casted_values } }])
         end
       end
 
@@ -454,6 +487,7 @@ module Arel # :nodoc: all
 
       # alias for ATTRIBUTE returns
       alias :visit_Arel_Attributes_Attribute :visit_Struct_Attribute
+      alias :visit_Arel_Attribute :visit_Struct_Attribute
       alias :visit_Arel_Nodes_UnqualifiedColumn :visit_Struct_Attribute
       alias :visit_ActiveModel_Attribute_FromUser :visit_Struct_Attribute
 
@@ -487,6 +521,14 @@ module Arel # :nodoc: all
 
       # alias for ARRAY returns
       alias :visit_Set :visit_Array
+
+      def visit_Arel_Nodes_True(o)
+        true
+      end
+
+      def visit_Arel_Nodes_False(o)
+        false
+      end
     end
   end
 end

data/lib/elasticsearch_record/core.rb

@@ -96,7 +96,7 @@ module ElasticsearchRecord
       # used to create a cacheable statement.
       # This is a 1:1 copy, except that we use our own class +ElasticsearchRecord::StatementCache+
       # see @ ActiveRecord::Core::ClassMethods#cached_find_by_statement
-      def cached_find_by_statement(key, &block)
+      def cached_find_by_statement(connection, key, &block)
         cache = @find_by_statement_cache[connection.prepared_statements]
         cache.compute_if_absent(key) { ElasticsearchRecord::StatementCache.create(connection, &block) }
       end

data/lib/elasticsearch_record/gem_version.rb

@@ -7,9 +7,9 @@ module ElasticsearchRecord
   end
 
   module VERSION
-    MAJOR = 1
-    MINOR = 8
-    TINY  = 2
+    MAJOR = 3
+    MINOR = 0
+    TINY  = 0
     PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")

data/lib/elasticsearch_record/instrumentation/log_subscriber.rb

@@ -37,12 +37,14 @@ module ElasticsearchRecord
                end
         name = "CACHE #{name}" if payload[:cached]
 
-        # nice feature: displays the REAL query-time from elasticsearch response (_qt)
+        # nice feature: displays the REAL query-time from elasticsearch response
         # this is handled through the +::ActiveRecord::ConnectionAdapters::ElasticsearchAdapter#api+ method
-        name = "#{name} (took: #{payload[:arguments][:_qt].round(1)}ms)" if payload[:arguments][:_qt]
+        if payload[:statistics].present?
+          name = "#{name} (took: #{payload[:statistics][:took].round(1)}ms)" if payload[:statistics][:took]
+        end
 
         # build query
-        query = payload[:arguments].except(:_qt).inspect.gsub(/:(\w+)=>/, '\1: ').truncate((payload[:truncate] || 1000), omission: color(' (pruned)', RED))
+        query = payload[:arguments].inspect.gsub(/:(\w+)=>/, '\1: ').truncate((payload[:truncate] || 1000), omission: color(' (pruned)', RED))
 
         # final coloring
         name  = color(name, name_color(payload[:name]), bold: true)
@@ -62,21 +64,21 @@ module ElasticsearchRecord
       end
 
       def gate_color(gate, name)
-        case gate
+        case gate.to_s
           # SELECTS
-        when 'core.get', 'core.mget', 'core.search', 'core.msearch', 'core.count', 'core.exists', 'sql.query'
+        when 'get', 'mget', 'search', 'msearch', 'count', 'exists', 'sql.query'
           BLUE
           # DELETES
-        when 'core.delete', 'core.delete_by_query'
+        when 'delete', 'delete_by_query'
           RED
           # CREATES
-        when 'core.create', 'core.reindex'
+        when 'create', 'reindex'
           GREEN
           # UPDATES
-        when 'core.update', 'core.update_by_query'
+        when 'update', 'update_by_query'
           YELLOW
           # MIXINS
-        when /indices\.\w+/, 'core.bulk', 'core.index'
+        when /indices\.\w+/, 'bulk', 'index'
           if name.end_with?('Pit Delete')
             RED
           else

data/lib/elasticsearch_record/internal_metadata.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "active_record/internal_metadata"
+
+module ElasticsearchRecord
+  class InternalMetadata < ::ActiveRecord::InternalMetadata
+
+    # overwrite method to always disable the internal metadata index.
+    #
+    # Elasticsearch cannot serve the internal metadata table
+    # (see +ElasticsearchAdapter#use_metadata_table?+) - but since rails 7.2 the flag is
+    # resolved through the database config (default: enabled) instead of the adapter,
+    # so a default configuration would suddenly create & write a 'ar_internal_metadata'
+    # index on the cluster.
+    def enabled?
+      false
+    end
+  end
+end