search-engine-for-typesense 30.1.5 → 30.1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae511da617970ab104c22bde9c151ed099d9eb9c55909d9bc34f328ea56ac5f4
-  data.tar.gz: 49d4de291b6239a7f70e6bd93de83ef175916d7c403029d7a7382189fe90b9d7
+  metadata.gz: 52454481281edd904b9d0a3b68e191b6c8499426194b37f81e47f9fdc1a62435
+  data.tar.gz: 6adbd869d14f77faabf6ea10c42bc9f141d247a713ea016e97ab4188ce31564c
 SHA512:
-  metadata.gz: ba3c5e26e351975c5c967954b3f20e0fe14f438aab7126672c1b9ad42ec1bbc15c224f5412a5d0cd778e237451af23a8a4e237731ab2c9bc2e2dabb3650256e9
-  data.tar.gz: 82766d2a92e2f2a3a81f430d066254ff83b14966a3cce4b7171102979c07e0fe53925e2aa118075b6c679f8dd0881364d5c5d681c4c56e9c819b6ecb5aceaea1
+  metadata.gz: '08c22e27bf1e8c039d453584c34af900c4e50b7b55efbad70a29854e8154dfa5353ccb24095f991aaa9ae38bb55cf9a799a5a183e07344a63f4b050c0cf5a23f'
+  data.tar.gz: b54156dde160147eb1463d1c108f38c15436a52fcf3958f7462f7acaa49b1b844525aa971f4c1bdd4de482962f21935463ff26c4cb332a6ecd1f90e2da43b105

data/lib/search_engine/base/model_dsl.rb

@@ -8,6 +8,8 @@ module SearchEngine
     module ModelDsl
       extend ActiveSupport::Concern
 
+      EMBEDDING_SUFFIX = '_embedding'
+
       class_methods do
         # Get or set the Typesense collection name for this model.
         #
@@ -282,6 +284,183 @@ module SearchEngine
         end
       end
 
+      class_methods do
+        # Declare a vector embedding field with automatic name resolution, model
+        # inference, and source-field validation.
+        #
+        # @param name [Symbol, String, nil] field name (auto-derived when omitted)
+        # @param from [Array<Symbol>, nil] source attribute names to embed from
+        # @param suffix [Boolean] append `_embedding` to the field name (default: true)
+        # @param model [String, nil] embedding model override (per-field)
+        # @param api_key [String, nil] API key for remote embedding providers
+        # @param num_dim [Integer, nil] vector dimensions for external embeddings
+        # @param hnsw [Hash, nil] HNSW index tuning parameters
+        # @param model_config [Hash, nil] extra model_config overrides
+        # @return [void]
+        def embedding(name = nil, from: nil, suffix: true, model: nil,
+                      api_key: nil, num_dim: nil, hnsw: nil, model_config: nil)
+          resolved_name = __se_resolve_embedding_name(name, from: from, suffix: suffix, num_dim: num_dim)
+          resolved_sym = resolved_name.to_sym
+
+          __se_check_embedding_duplicate!(resolved_sym)
+
+          external = from.nil? && num_dim
+          from_fields = external ? nil : __se_infer_embedding_from(resolved_name, from)
+
+          __se_validate_embedding_sources!(from_fields) if from_fields
+
+          vector_opts = {}
+
+          if external
+            vector_opts[:num_dim] = Integer(num_dim)
+          else
+            resolved_model = __se_resolve_embedding_model(model)
+            vector_opts[:embed] = __se_build_embed_hash(
+              from_fields, resolved_model,
+              api_key: api_key, model_config: model_config
+            )
+          end
+
+          vector_opts[:hnsw_params] = hnsw if hnsw
+
+          attribute(resolved_name, :vector)
+          @attribute_options ||= {}
+          @attribute_options[resolved_sym] = (@attribute_options[resolved_sym] || {}).merge(vector_opts)
+
+          __se_store_embedding_metadata!(
+            resolved_sym, from: from_fields,
+            model: external ? nil : resolved_model,
+            external: external ? true : false,
+            num_dim: num_dim
+          )
+        end
+
+        private
+
+        # Resolve the canonical field name for an embedding declaration.
+        # @return [String]
+        def __se_resolve_embedding_name(name, from:, suffix:, num_dim:)
+          if name.nil?
+            if from
+              "#{self.name.demodulize.underscore}#{EMBEDDING_SUFFIX}"
+            elsif num_dim
+              raise ArgumentError,
+                    'External embedding (num_dim: without from:) requires an explicit field name'
+            else
+              raise ArgumentError,
+                    'embedding requires at least one of: a field name, from: sources, or num_dim: for external vectors'
+            end
+          else
+            n = name.to_s
+            if suffix && !n.end_with?(EMBEDDING_SUFFIX)
+              "#{n}#{EMBEDDING_SUFFIX}"
+            else
+              n
+            end
+          end
+        end
+
+        # Infer `from:` source fields when not explicitly provided.
+        # @return [Array<Symbol>]
+        def __se_infer_embedding_from(resolved_name, from)
+          if from
+            Array(from).map(&:to_sym)
+          else
+            bare = resolved_name.to_s.delete_suffix(EMBEDDING_SUFFIX)
+            if bare.empty?
+              raise ArgumentError,
+                    "Cannot infer from: for embedding '#{resolved_name}'; provide from: explicitly"
+            end
+
+            [bare.to_sym]
+          end
+        end
+
+        # Validate that all source fields exist and are string-typed.
+        # @raise [ArgumentError]
+        def __se_validate_embedding_sources!(from_fields)
+          attrs = @attributes || {}
+          from_fields.each do |field|
+            unless attrs.key?(field)
+              raise ArgumentError,
+                    "embedding from: references undeclared attribute :#{field}. " \
+                    'Declare it with `attribute` before the `embedding` call.'
+            end
+
+            ts_type = __se_typesense_type_for(attrs[field])
+            next if %w[string string[]].include?(ts_type)
+
+            raise ArgumentError,
+                  "embedding from: field :#{field} must be string-typed " \
+                  "(got :#{attrs[field]} -> \"#{ts_type}\"). " \
+                  'Typesense only auto-embeds text fields.'
+          end
+        end
+
+        # Resolve the embedding model with fallback to global config.
+        # @return [String]
+        # @raise [SearchEngine::Errors::ConfigurationError]
+        def __se_resolve_embedding_model(per_field_model)
+          return per_field_model if per_field_model && !per_field_model.to_s.strip.empty?
+
+          global = SearchEngine.config.embedding.model
+          return global if global && !global.to_s.strip.empty?
+
+          raise SearchEngine::Errors::ConfigurationError.new(
+            'No embedding model configured. Set `model:` on the embedding declaration ' \
+            'or set `SearchEngine.config.embedding.model` globally.',
+            hint: "Add `config.embedding.model = 'ts/all-MiniLM-L12-v2'` to your SearchEngine initializer.",
+            doc: 'https://typesense.org/docs/30.1/api/vector-search.html#option-b-auto-embedding-generation-within-typesense'
+          )
+        end
+
+        # Build the Typesense `embed` hash for auto-embedding fields.
+        # @return [Hash]
+        def __se_build_embed_hash(from_fields, model_name, api_key: nil, model_config: nil)
+          mc = {}
+
+          global_mc = SearchEngine.config.embedding.model_config
+          mc.merge!(global_mc) if global_mc.is_a?(Hash)
+          mc.merge!(model_config) if model_config.is_a?(Hash)
+          mc[:model_name] = model_name
+
+          resolved_api_key = api_key || SearchEngine.config.embedding.api_key
+          mc[:api_key] = resolved_api_key if resolved_api_key && !resolved_api_key.to_s.strip.empty?
+
+          { from: from_fields.map(&:to_s), model_config: mc }
+        end
+
+        # Raise on duplicate embedding field names.
+        def __se_check_embedding_duplicate!(resolved_sym)
+          return unless (@embeddings_config || {}).key?(resolved_sym)
+
+          raise ArgumentError, "Duplicate embedding field :#{resolved_sym} already declared"
+        end
+
+        # Store embedding metadata for downstream consumers (mapper, indexer, compiler).
+        def __se_store_embedding_metadata!(resolved_sym, from:, model:, external:, num_dim:)
+          @embeddings_config ||= {}
+          @embeddings_config[resolved_sym] = {
+            field_name: resolved_sym.to_s,
+            from: from,
+            model: model,
+            external: external,
+            num_dim: num_dim
+          }.compact
+        end
+
+        # Minimal type resolution for validation (mirrors Schema.typesense_type_for).
+        def __se_typesense_type_for(type_descriptor)
+          if type_descriptor.is_a?(Array) && type_descriptor.size == 1
+            inner = type_descriptor.first
+            mapped = SearchEngine::Schema::TYPE_MAPPING[inner.to_s.downcase.to_sym] || inner.to_s
+            return "#{mapped}[]"
+          end
+
+          SearchEngine::Schema::TYPE_MAPPING[type_descriptor.to_s.downcase.to_sym] || type_descriptor.to_s
+        end
+      end
+
       class_methods do
         # Validate whether an attribute name is a valid Ruby reader method name
         # (skip dotted names and other invalid identifiers).
@@ -415,6 +594,14 @@ module SearchEngine
         end
       end
 
+      class_methods do
+        # Read-only view of declared embedding metadata for this class.
+        # @return [Hash{Symbol=>Hash}] frozen hash keyed by embedding field name
+        def embeddings_config
+          (@embeddings_config || {}).dup.freeze
+        end
+      end
+
       class_methods do
         # Configure schema retention policy for this collection.
         # @param keep_last [Integer] how many previous physicals to keep after swap
@@ -444,6 +631,9 @@ module SearchEngine
           parent_retention = @schema_retention || {}
           subclass.instance_variable_set(:@schema_retention, parent_retention.dup)
 
+          parent_embeddings = @embeddings_config || {}
+          subclass.instance_variable_set(:@embeddings_config, parent_embeddings.dup)
+
           parent_joins = @joins_config || {}
           subclass.instance_variable_set(:@joins_config, parent_joins.dup.freeze)
 

data/lib/search_engine/config.rb

@@ -251,6 +251,10 @@ module SearchEngine
       attr_accessor :include_error_messages
       # @return [Boolean] also emit legacy event aliases where applicable
       attr_accessor :emit_legacy_event_aliases
+      # @return [Boolean] when true (default), float arrays inside +vector_query+
+      #   strings are replaced with +[<N dims>]+ in logs and telemetry payloads.
+      #   Set to +false+ to see raw vectors for debugging.
+      attr_accessor :redact_vectors
 
       def initialize
         super()
@@ -260,6 +264,7 @@ module SearchEngine
         @max_message_length = 200
         @include_error_messages = false
         @emit_legacy_event_aliases = true
+        @redact_vectors = true
       end
     end
 
@@ -321,6 +326,30 @@ module SearchEngine
       end
     end
 
+    # Lightweight nested configuration for global embedding defaults.
+    # Provides a default model, optional API key, and extra model_config
+    # used by the Schema DSL when compiling auto-embedding fields.
+    class EmbeddingConfig
+      # @return [String, nil] default embedding model name (e.g. "ts/all-MiniLM-L12-v2")
+      attr_accessor :model
+      # @return [String, nil] API key for remote embedding providers (e.g. OpenAI)
+      attr_accessor :api_key
+      # @return [Hash, nil] extra model_config passed to Typesense embed block
+      attr_accessor :model_config
+      # @return [Float] tolerance for vector search weights sum validation.
+      #   Weights must sum to ~1.0 within this tolerance. With many small weights
+      #   floating-point drift can exceed the default. Adjust via
+      #   +config.embedding.weights_sum_tolerance = 0.05+.
+      attr_accessor :weights_sum_tolerance
+
+      def initialize
+        @model = nil
+        @api_key = nil
+        @model_config = nil
+        @weights_sum_tolerance = 0.01
+      end
+    end
+
     # Create a new configuration with defaults, optionally hydrated from ENV.
     #
     # @param env [#[]] environment-like object (defaults to ::ENV)
@@ -360,6 +389,7 @@ module SearchEngine
       @selection = SelectionConfig.new
       @presets = PresetsConfig.new
       @curation = CurationConfig.new
+      @embedding = EmbeddingConfig.new
       @default_console_model = nil
       # Path may be relative to Rails.root or absolute. Set nil/false to disable.
       @search_engine_models = 'app/search_engine'
@@ -438,6 +468,12 @@ module SearchEngine
       @curation ||= CurationConfig.new
     end
 
+    # Expose global embedding configuration.
+    # @return [SearchEngine::Config::EmbeddingConfig]
+    def embedding
+      @embedding ||= EmbeddingConfig.new
+    end
+
     # Expose observability/logging configuration.
     # @return [SearchEngine::Config::ObservabilityConfig]
     def observability
@@ -657,6 +693,7 @@ module SearchEngine
         selection: selection_hash_for_to_h,
         presets: presets_hash_for_to_h,
         curation: curation_hash_for_to_h,
+        embedding: embedding_hash_for_to_h,
         relation_print_materializes: relation_print_materializes ? true : false
       }
     end
@@ -666,6 +703,7 @@ module SearchEngine
     def to_h_redacted
       redacted = to_h.dup
       redacted[:api_key] = '[REDACTED]' unless string_blank?(api_key)
+      redacted[:embedding] = redacted[:embedding].merge(api_key: '[REDACTED]') unless string_blank?(embedding.api_key)
       redacted
     end
 
@@ -726,7 +764,8 @@ module SearchEngine
         log_format: observability.log_format,
         max_message_length: observability.max_message_length,
         include_error_messages: observability.include_error_messages ? true : false,
-        emit_legacy_event_aliases: observability.emit_legacy_event_aliases ? true : false
+        emit_legacy_event_aliases: observability.emit_legacy_event_aliases ? true : false,
+        redact_vectors: observability.redact_vectors ? true : false
       }
     end
 
@@ -752,6 +791,15 @@ module SearchEngine
       }
     end
 
+    def embedding_hash_for_to_h
+      {
+        model: embedding.model,
+        api_key: embedding.api_key,
+        model_config: embedding.model_config,
+        weights_sum_tolerance: embedding.weights_sum_tolerance
+      }
+    end
+
     def default_strict_fields
       if defined?(::Rails)
         !::Rails.env.production?

data/lib/search_engine/errors.rb

@@ -259,6 +259,12 @@ module SearchEngine
     #   raise SearchEngine::Errors::InvalidOverrideTag, 'InvalidOverrideTag: "" is invalid. Use non-blank strings that match the allowed pattern.'
     class InvalidOverrideTag < Error; end
 
+    # Raised when a required configuration value is missing or invalid.
+    #
+    # Typical cause: embedding model not set in either the per-field `model:`
+    # kwarg or the global `SearchEngine.config.embedding.model`.
+    class ConfigurationError < Error; end
+
     # Raised when an option value is invalid or unsupported for a public API.
     #
     # Used by DSL methods to fail fast with actionable hints.
@@ -286,5 +292,20 @@ module SearchEngine
     #     details: { total_hits: 12_000, max: 10_000, collection: 'products' }
     #   )
     class HitLimitExceeded < Error; end
+
+    # Raised when vector search DSL receives invalid inputs.
+    #
+    # Typical causes: unknown embedding field, mutually exclusive query modes,
+    # invalid alpha range, or malformed vector arrays.
+    #
+    # @example
+    #   raise SearchEngine::Errors::InvalidVectorQuery.new(
+    #     'InvalidVectorQuery: query: and id: are mutually exclusive',
+    #     hint: 'Provide only one of query:, id:, or queries:',
+    #     doc: 'https://nikita-shkoda.mintlify.app/projects/search-engine-for-typesense/v30.1/vector-search'
+    #   )
+    class InvalidVectorQuery < Error
+      DOC_URL = 'https://nikita-shkoda.mintlify.app/projects/search-engine-for-typesense/v30.1/vector-search'
+    end
   end
 end

data/lib/search_engine/instrumentation.rb

@@ -38,8 +38,8 @@ module SearchEngine
         optional: %i[duration_ms]
       },
       'search_engine.grouping.compile' => {
-        required: %i[field],
-        optional: %i[collection limit missing_values duration_ms]
+        required: %i[group_by],
+        optional: %i[collection group_limit missing_values duration_ms]
       },
       'search_engine.joins.compile' => {
         required: %i[collection],
@@ -116,7 +116,7 @@ module SearchEngine
       },
       'search_engine.vector.compile' => {
         required: %i[],
-        optional: %i[collection query_vector_present dims hybrid_weight ann_params_present duration_ms]
+        optional: %i[collection field mode k query_vector_present dims hybrid_weight ann_params_present duration_ms]
       },
       'search_engine.hits.limit' => {
         required: %i[],

data/lib/search_engine/logging_subscriber.rb

@@ -294,9 +294,12 @@ module SearchEngine
         parts << "[#{short}]"
         parts << "id=#{cid}"
         parts << "coll=#{collection}" if collection
+        parts << "mode=#{p[:mode] || SearchEngine::Logging::FormatHelpers::DASH}"
+        parts << "field=#{p[:field] || SearchEngine::Logging::FormatHelpers::DASH}"
+        parts << "k=#{p[:k] || SearchEngine::Logging::FormatHelpers::DASH}"
         parts << "qvec=#{SearchEngine::Logging::FormatHelpers.display_or_dash(p, :query_vector_present)}"
         parts << "dims=#{p[:dims] || SearchEngine::Logging::FormatHelpers::DASH}"
-        parts << "hybrid=#{p[:hybrid_weight] || SearchEngine::Logging::FormatHelpers::DASH}"
+        parts << "alpha=#{p[:hybrid_weight] || SearchEngine::Logging::FormatHelpers::DASH}"
         parts << "ann=#{SearchEngine::Logging::FormatHelpers.display_or_dash(p, :ann_params_present)}"
         parts << "dur=#{duration}ms"
         parts.join(' ')
@@ -336,7 +339,7 @@ module SearchEngine
           h['radius_bucket'] = p[:radius_bucket] if p.key?(:radius_bucket)
           h
         when 'search_engine.vector.compile'
-          keys = %i[query_vector_present dims hybrid_weight ann_params_present]
+          keys = %i[field mode k query_vector_present dims hybrid_weight ann_params_present]
           keys.each_with_object({}) { |k, h| h[k.to_s] = p[k] if p.key?(k) }
         when 'search_engine.hits.limit'
           keys = %i[early_limit validate_max applied_strategy triggered total_hits]

data/lib/search_engine/mapper.rb

@@ -320,11 +320,15 @@ module SearchEngine
     class Compiled
       attr_reader :klass
 
-      def initialize(klass:, map_proc:, schema_fields:, types_by_field:, options: {})
+      def initialize(klass:, map_proc:, schema_fields:, types_by_field:,
+                     auto_embedding_fields: Set.new, external_embedding_dims: {},
+                     options: {})
         @klass = klass
         @map_proc = map_proc
         @schema_fields = schema_fields.freeze # Array of field names (String)
         @types_by_field = types_by_field.freeze # { "field" => "int64" }
+        @auto_embedding_fields = auto_embedding_fields.freeze # Set<String> — server-generated fields
+        @external_embedding_dims = external_embedding_dims.freeze # { "field" => num_dim }
         # Allow all schema fields; treat required as schema fields minus optional attributes
         @allowed_keys = @schema_fields.map(&:to_sym).to_set.freeze
         @required_keys = compute_required_keys
@@ -360,6 +364,7 @@ module SearchEngine
           hash[:id] = computed_id
           hash[:doc_updated_at] = now_i
 
+          strip_auto_embedding_fields!(hash)
           normalize_optional_blank_strings!(hash)
 
           # Populate hidden flags
@@ -458,6 +463,17 @@ module SearchEngine
         end
       end
 
+      # Remove auto-embedding fields from the document payload.
+      # Typesense generates these server-side; including them would cause errors.
+      def strip_auto_embedding_fields!(doc)
+        return if @auto_embedding_fields.empty?
+
+        @auto_embedding_fields.each do |name|
+          doc.delete(name.to_sym)
+          doc.delete(name.to_s)
+        end
+      end
+
       # Normalize empty-string values for optional fields to nil.
       def normalize_optional_blank_strings!(doc)
         return if @__optional_blank_targets__.empty?
@@ -554,6 +570,10 @@ module SearchEngine
 
           required.delete(fname.to_sym)
         end
+
+        # Auto-embedding fields are generated server-side; never require them in documents
+        @auto_embedding_fields.each { |name| required.delete(name.to_sym) }
+
         required.freeze
       end
 
@@ -593,6 +613,8 @@ module SearchEngine
           return [true, nil, nil] if value.is_a?(Array) && value.all? { |v| v.is_a?(String) }
 
           [false, nil, invalid_type_message(field, 'Array<String>', value)]
+        when 'float[]'
+          validate_float_array(value, field)
         else
           # Unknown/opaque type: accept
           [true, nil, nil]
@@ -634,6 +656,20 @@ module SearchEngine
         end
       end
 
+      def validate_float_array(value, field)
+        unless value.is_a?(Array) && value.all? { |v| v.is_a?(Numeric) }
+          return [false, nil, invalid_type_message(field, 'Array<Float>', value)]
+        end
+
+        expected_dim = @external_embedding_dims[field]
+        if expected_dim && value.size != expected_dim
+          msg = "Dimension mismatch for field :#{field} (expected #{expected_dim}, got #{value.size})."
+          return [false, nil, msg]
+        end
+
+        [true, nil, nil]
+      end
+
       def string_integer?(v)
         v.is_a?(String) && v.match?(/^[-+]?\d+$/)
       end
@@ -749,6 +785,8 @@ module SearchEngine
           types_by_field[f[:name].to_s] = f[:type].to_s
         end
 
+        auto_embedding_fields, external_embedding_dims = partition_embedding_fields(klass)
+
         mapper_cfg = SearchEngine.config&.mapper
         coercions_cfg = mapper_cfg&.coercions || {}
         options = {
@@ -763,10 +801,32 @@ module SearchEngine
           map_proc: dsl[:map],
           schema_fields: fields,
           types_by_field: types_by_field,
+          auto_embedding_fields: auto_embedding_fields,
+          external_embedding_dims: external_embedding_dims,
           options: options
         )
       end
 
+      # Partition embeddings_config into auto-embedding field names and
+      # external embedding field-name-to-dimension mapping.
+      # @return [Array(Set<String>, Hash{String=>Integer})]
+      def partition_embedding_fields(klass)
+        embeddings = klass.respond_to?(:embeddings_config) ? klass.embeddings_config : {}
+        auto_fields = Set.new
+        external_dims = {}
+
+        embeddings.each do |sym, meta|
+          name = (meta[:field_name] || sym).to_s
+          if meta[:external]
+            external_dims[name] = meta[:num_dim].to_i if meta[:num_dim]
+          else
+            auto_fields << name
+          end
+        end
+
+        [auto_fields, external_dims]
+      end
+
       def mapper_dsl_for(klass)
         return unless klass.instance_variable_defined?(:@__mapper_dsl__)
 

data/lib/search_engine/observability.rb

@@ -12,9 +12,11 @@ module SearchEngine
 
     # Whitelisted search parameter keys to include in payload excerpts.
     PARAM_WHITELIST = %i[
-      q query_by include_fields exclude_fields per_page page infix filter_by group_by group_limit group_missing_values
+      q query_by include_fields exclude_fields per_page page infix filter_by sort_by
+      group_by group_limit group_missing_values
       facet_by max_facet_values facet_query
       num_typos drop_tokens_threshold prioritize_exact_match query_by_weights
+      vector_query
     ].freeze
 
     # Maximum length for `q` values before truncation.
@@ -58,6 +60,8 @@ module SearchEngine
           result[:q] = truncate_q(val)
         when :filter_by
           result[:filter_by] = redact_filter_by(val)
+        when :vector_query
+          result[:vector_query] = redact_vector_query(val)
         else
           result[key] = redact_simple_value(val)
         end
@@ -106,6 +110,25 @@ module SearchEngine
       masked.gsub(/\b\d+(?:\.\d+)?\b/, '***')
     end
 
+    # Internal: Redact raw float arrays in a vector_query string while
+    # preserving the structural tokens (field name, k, alpha, etc.).
+    # Replaces `[0.1,0.2,...]` with `[<N dims>]`.
+    #
+    # Disable via +config.observability.redact_vectors = false+ to see
+    # raw vectors (useful for debugging).
+    #
+    # @param vq [String]
+    # @return [String]
+    def self.redact_vector_query(vq)
+      return vq unless vq.is_a?(String)
+      return vq if SearchEngine.config.observability.redact_vectors == false
+
+      vq.gsub(/\[(-?\d+(?:\.\d+)?(?:\s*,\s*-?\d+(?:\.\d+?))*)\]/) do
+        dims = Regexp.last_match(1).split(',').size
+        "[<#{dims} dims>]"
+      end
+    end
+
     # Build a filtered URL/common options hash for payloads.
     # @param url_opts [Hash]
     # @return [Hash]
@@ -157,6 +180,6 @@ module SearchEngine
     end
 
     private_class_method :redact_params_hash, :redact_simple_value, :truncate_q,
-                         :redact_string, :redact_filter_by
+                         :redact_string, :redact_filter_by, :redact_vector_query
   end
 end

data/lib/search_engine/otel.rb

@@ -130,8 +130,8 @@ module SearchEngine
         assign_attr(span, 'se.node_count', p[:node_count]) if p.key?(:node_count)
         assign_attr(span, 'se.join_count', p[:join_count]) if p.key?(:join_count)
         assign_attr(span, 'se.groups_count', p[:groups_count]) if p.key?(:groups_count)
-        assign_attr(span, 'se.group_by', p[:field] || p[:group_by]) if p.key?(:field) || p.key?(:group_by)
-        assign_attr(span, 'se.group_limit', p[:limit] || p[:group_limit]) if p.key?(:limit) || p.key?(:group_limit)
+        assign_attr(span, 'se.group_by', p[:group_by]) if p.key?(:group_by)
+        assign_attr(span, 'se.group_limit', p[:group_limit]) if p.key?(:group_limit)
         return unless p.key?(:missing_values) || p.key?(:group_missing_values)
 
         assign_attr(span, 'se.group_missing_values', p[:missing_values] || p[:group_missing_values])
@@ -142,7 +142,14 @@ module SearchEngine
            deleted_count searches_count fields_changed_count added_count removed_count in_sync].each do |k|
           assign_attr(span, "se.#{k}", p[k]) if p.key?(k)
         end
-        # New event attributes (redacted/summarized)
+        apply_feature_detail_attributes(span, p)
+        apply_vector_attributes(span, p)
+        %i[early_limit validate_max applied_strategy triggered total_hits].each do |k|
+          assign_attr(span, "se.#{k}", p[k]) if p.key?(k)
+        end
+      end
+
+      def apply_feature_detail_attributes(span, p)
         %i[fields_count queries_count max_facet_values sort_flags conflicts].each do |k|
           assign_attr(span, "se.#{k}", p[k]) if p.key?(k)
         end
@@ -161,12 +168,17 @@ module SearchEngine
         %i[sort_mode radius_bucket].each do |k|
           assign_attr(span, "se.#{k}", p[k]) if p.key?(k)
         end
+      end
+
+      def apply_vector_attributes(span, p)
+        return unless p.key?(:query_vector_present)
+
+        assign_attr(span, 'se.vector.field', p[:field]) if p.key?(:field)
+        assign_attr(span, 'se.vector.mode', p[:mode]&.to_s) if p.key?(:mode)
+        assign_attr(span, 'se.vector.k', p[:k]) if p.key?(:k)
         %i[query_vector_present dims hybrid_weight ann_params_present].each do |k|
           assign_attr(span, "se.#{k}", p[k]) if p.key?(k)
         end
-        %i[early_limit validate_max applied_strategy triggered total_hits].each do |k|
-          assign_attr(span, "se.#{k}", p[k]) if p.key?(k)
-        end
       end
 
       def apply_params_preview(span, payload)