noiseless 0.7.1 → 0.8.0

data/lib/noiseless/introspection/query_visualizer.rb

@@ -64,9 +64,9 @@ module Noiseless
         when :yaml
           YAML.dump(ast_node.to_h)
         when :mermaid
-          ast_to_mermaid_flowchart(ast_node)
+          MermaidDiagrams.ast_to_mermaid_flowchart(ast_node)
         when :mermaid_class
-          ast_to_mermaid_class_diagram(ast_node)
+          MermaidDiagrams.ast_to_mermaid_class_diagram(ast_node)
         else
           raise ArgumentError, "Unsupported format: #{format}. Available: :tree, :json, :yaml, :mermaid, :mermaid_class"
         end
@@ -75,7 +75,7 @@ module Noiseless
       def self.explain_query_flow(ast_node, adapter)
         explanation = adapter.explain_query(ast_node)
 
-        flow_diagram = generate_flow_diagram(explanation)
+        flow_diagram = MermaidDiagrams.generate_flow_diagram(explanation)
 
         {
           explanation: explanation,
@@ -230,68 +230,6 @@ module Noiseless
         end
       end
 
-      def self.generate_mermaid_diagram(ast_node)
-        diagram = "graph TD\n".dup
-
-        add_node = lambda do |diagram, node, parent_id, counter|
-          case node
-          when Hash
-            node.each do |key, value|
-              current_id = "N#{counter[:count]}"
-              counter[:count] += 1
-              diagram << "  #{current_id}[#{key}]\n"
-              diagram << "  #{parent_id} --> #{current_id}\n" if parent_id
-              add_node.call(diagram, value, current_id, counter)
-            end
-          when Array
-            node.each_with_index do |item, index|
-              current_id = "N#{counter[:count]}"
-              counter[:count] += 1
-              diagram << "  #{current_id}[Item #{index}]\n"
-              diagram << "  #{parent_id} --> #{current_id}\n" if parent_id
-              add_node.call(diagram, item, current_id, counter)
-            end
-          else
-            current_id = "N#{counter[:count]}"
-            counter[:count] += 1
-            diagram << "  #{current_id}[#{node}]\n"
-            diagram << "  #{parent_id} --> #{current_id}\n" if parent_id
-          end
-        end
-
-        counter = { count: 0 }
-        root_id = "N#{counter[:count]}"
-        counter[:count] += 1
-        diagram << "  #{root_id}[Root]\n"
-
-        add_node.call(diagram, ast_node.to_h, root_id, counter)
-        diagram
-      end
-
-      def self.generate_flow_diagram(explanation)
-        # Create a sequence diagram showing the query execution flow
-        diagram = "sequenceDiagram\n".dup
-        diagram << "    participant Client\n"
-        diagram << "    participant Adapter\n"
-        diagram << "    participant Engine\n"
-
-        explanation[:execution_plan].each do |step|
-          diagram << case step[:description]
-                     when /validate/i
-                       "    Client->>Adapter: #{step[:description]}\n"
-                     when /convert/i, /format/i
-                       "    Adapter->>Adapter: #{step[:description]}\n"
-                     when /execute/i, /query/i
-                       "    Adapter->>Engine: #{step[:description]}\n"
-                     else
-                       "    Engine->>Adapter: #{step[:description]}\n"
-                     end
-        end
-
-        diagram << "    Adapter->>Client: Return results\n"
-        diagram
-      end
-
       def self.format_performance_breakdown(performance)
         performance.map do |metric, value|
           {
@@ -365,169 +303,6 @@ module Noiseless
           node.each { |item| count_recursive(item, complexity) }
         end
       end
-
-      # New methods using your diagram/mermaid gems
-      def self.ast_to_mermaid_flowchart(ast_node)
-        return "# Mermaid diagrams require 'diagrams' and 'mermaid' gems\n# Add to Gemfile: gem 'diagrams'; gem 'mermaid'" unless DIAGRAMS_AVAILABLE
-
-        diagram = Diagrams::FlowchartDiagram.new(version: "1.0")
-
-        # Convert AST structure to flowchart nodes and edges
-        add_ast_node_to_flowchart(diagram, ast_node, "root")
-
-        diagram.to_mermaid
-      end
-
-      def self.ast_to_mermaid_class_diagram(ast_node)
-        return "# Mermaid diagrams require 'diagrams' and 'mermaid' gems\n# Add to Gemfile: gem 'diagrams'; gem 'mermaid'" unless DIAGRAMS_AVAILABLE
-
-        diagram = Diagrams::ClassDiagram.new(version: "1.0")
-
-        # Create a class representation of the AST structure
-        root_class = Diagrams::Elements::ClassEntity.new(
-          name: ast_node.class.name.split("::").last,
-          attributes: ast_node.instance_variables.map do |var|
-            "#{var.to_s.delete('@')}: #{ast_node.instance_variable_get(var).class.name.split('::').last}"
-          end,
-          methods: ast_node.public_methods(false).map { |method| "+#{method}()" }
-        )
-
-        diagram.add_class(root_class)
-
-        # Add child nodes as related classes
-        add_ast_children_to_class_diagram(diagram, ast_node, root_class.name)
-
-        diagram.to_mermaid
-      end
-
-      def self.adapter_capability_matrix_to_mermaid
-        return "# Mermaid diagrams require 'diagrams' and 'mermaid' gems\n# Add to Gemfile: gem 'diagrams'; gem 'mermaid'" unless DIAGRAMS_AVAILABLE
-
-        # Create an ER diagram showing adapter capabilities
-        diagram = Diagrams::ERDiagram.new
-
-        # Add adapter entities
-        diagram.add_entity(
-          name: "ADAPTER",
-          attributes: [
-            { type: "string", name: "type", keys: [:PK] },
-            { type: "string", name: "execution_mode" },
-            { type: "string", name: "engine_name" }
-          ]
-        )
-
-        diagram.add_entity(
-          name: "CAPABILITY",
-          attributes: [
-            { type: "string", name: "name", keys: [:PK] },
-            { type: "string", name: "description" }
-          ]
-        )
-
-        diagram.add_entity(
-          name: "ADAPTER_CAPABILITY",
-          attributes: [
-            { type: "string", name: "adapter_type", keys: %i[PK FK] },
-            { type: "string", name: "capability_name", keys: %i[PK FK] }
-          ]
-        )
-
-        # Add relationships
-        diagram.add_relationship(
-          entity1: "ADAPTER",
-          entity2: "ADAPTER_CAPABILITY",
-          cardinality1: :ONE_ONLY,
-          cardinality2: :ZERO_OR_MORE,
-          label: "has"
-        )
-
-        diagram.add_relationship(
-          entity1: "CAPABILITY",
-          entity2: "ADAPTER_CAPABILITY",
-          cardinality1: :ONE_ONLY,
-          cardinality2: :ZERO_OR_MORE,
-          label: "provided by"
-        )
-
-        diagram.to_mermaid
-      end
-
-      def self.add_ast_node_to_flowchart(diagram, node, node_id)
-        # Add current node
-        flowchart_node = Diagrams::Elements::Node.new(
-          id: node_id,
-          label: node.class.name.split("::").last.to_s
-        )
-        diagram.add_node(flowchart_node)
-
-        # Add child nodes and connect them
-        return unless node.respond_to?(:instance_variables)
-
-        node.instance_variables.each_with_index do |var, _index|
-          child_value = node.instance_variable_get(var)
-
-          if child_value.is_a?(Noiseless::AST::Node)
-            child_id = "#{node_id}_#{var.to_s.delete('@')}"
-            add_ast_node_to_flowchart(diagram, child_value, child_id)
-
-            edge = Diagrams::Elements::Edge.new(
-              source_id: node_id,
-              target_id: child_id,
-              label: var.to_s.delete("@")
-            )
-            diagram.add_edge(edge)
-          elsif child_value.is_a?(Array) && child_value.any?(Noiseless::AST::Node)
-            child_value.each_with_index do |item, item_index|
-              next unless item.is_a?(Noiseless::AST::Node)
-
-              child_id = "#{node_id}_#{var.to_s.delete('@')}_#{item_index}"
-              add_ast_node_to_flowchart(diagram, item, child_id)
-
-              edge = Diagrams::Elements::Edge.new(
-                source_id: node_id,
-                target_id: child_id,
-                label: "#{var.to_s.delete('@')}[#{item_index}]"
-              )
-              diagram.add_edge(edge)
-            end
-          end
-        end
-      end
-
-      def self.add_ast_children_to_class_diagram(diagram, node, parent_class_name)
-        return unless node.respond_to?(:instance_variables)
-
-        node.instance_variables.each do |var|
-          child_value = node.instance_variable_get(var)
-
-          next unless child_value.is_a?(Noiseless::AST::Node)
-
-          child_class_name = child_value.class.name.split("::").last
-
-          # Add child class if not already added
-          unless diagram.classes.any? { |c| c.name == child_class_name }
-            child_class = Diagrams::Elements::ClassEntity.new(
-              name: child_class_name,
-              attributes: child_value.instance_variables.map do |cv|
-                "#{cv.to_s.delete('@')}: #{child_value.instance_variable_get(cv).class.name.split('::').last}"
-              end
-            )
-            diagram.add_class(child_class)
-          end
-
-          # Add relationship
-          relationship = Diagrams::Elements::Relationship.new(
-            source_class_name: parent_class_name,
-            target_class_name: child_class_name,
-            type: "composition",
-            label: var.to_s.delete("@")
-          )
-          diagram.add_relationship(relationship)
-
-          # Recursively add children
-          add_ast_children_to_class_diagram(diagram, child_value, child_class_name)
-        end
-      end
     end
   end
 end

data/lib/noiseless/introspection.rb

@@ -45,7 +45,7 @@ module Noiseless
       # Engine-specific capabilities
       case self.class.name
       when /OpenSearch/
-        capabilities += %i[point_in_time_search search_templates] if respond_to?(:point_in_time_search)
+        capabilities += %i[point_in_time_pagination search_templates] if respond_to?(:each_page)
       when /Typesense/
         capabilities += %i[typo_tolerance faceted_search] if respond_to?(:faceted_search)
       when /Elasticsearch/

data/lib/noiseless/log_subscriber.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Noiseless
+  # Log subscriber for Rails integration
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def search(event)
+      return unless logger.debug?
+
+      indexes = event.payload[:indexes]&.join(", ") || "unknown"
+      duration = event.duration.round(2)
+
+      debug "Noiseless Search (#{duration}ms) indexes=[#{indexes}] #{query_summary(event.payload[:query])}"
+    end
+
+    def bulk(event)
+      return unless logger.debug?
+
+      actions_count = event.payload[:actions_count] || 0
+      duration = event.duration.round(2)
+
+      debug "Noiseless Bulk (#{duration}ms) actions=#{actions_count}"
+    end
+
+    def index_document(event)
+      return unless logger.debug?
+
+      index = event.payload[:index]
+      id = event.payload[:id]
+      duration = event.duration.round(2)
+
+      debug "Noiseless Index Document (#{duration}ms) index=#{index} id=#{id}"
+    end
+
+    def update_document(event)
+      return unless logger.debug?
+
+      index = event.payload[:index]
+      id = event.payload[:id]
+      changes_count = event.payload[:changes_count] || 0
+      duration = event.duration.round(2)
+
+      debug "Noiseless Update Document (#{duration}ms) index=#{index} id=#{id} changes=#{changes_count}"
+    end
+
+    def delete_document(event)
+      return unless logger.debug?
+
+      index = event.payload[:index]
+      id = event.payload[:id]
+      duration = event.duration.round(2)
+
+      debug "Noiseless Delete Document (#{duration}ms) index=#{index} id=#{id}"
+    end
+
+    def create_index(event)
+      return unless logger.debug?
+
+      index = event.payload[:index]
+      duration = event.duration.round(2)
+
+      debug "Noiseless Create Index (#{duration}ms) index=#{index}"
+    end
+
+    def delete_index(event)
+      return unless logger.debug?
+
+      index = event.payload[:index]
+      duration = event.duration.round(2)
+
+      debug "Noiseless Delete Index (#{duration}ms) index=#{index}"
+    end
+
+    private
+
+    def query_summary(query)
+      return "empty" unless query.is_a?(Hash)
+
+      parts = []
+
+      if query[:query]&.dig(:bool, :must)&.any?
+        must_count = query[:query][:bool][:must].size
+        parts << "must:#{must_count}"
+      end
+
+      if query[:query]&.dig(:bool, :filter)&.any?
+        filter_count = query[:query][:bool][:filter].size
+        parts << "filter:#{filter_count}"
+      end
+
+      if query[:sort]&.any?
+        sort_count = query[:sort].size
+        parts << "sort:#{sort_count}"
+      end
+
+      if query[:from] || query[:size]
+        parts << "from:#{query[:from] || 0}"
+        parts << "size:#{query[:size] || 20}"
+      end
+
+      parts.join(" ")
+    end
+  end
+end

data/lib/noiseless/model.rb

@@ -59,8 +59,8 @@ module Noiseless
       self
     end
 
-    def paginate(page: nil, per_page: nil)
-      @builder.paginate(page: page, per_page: per_page)
+    def paginate(**)
+      @builder.paginate(**)
       self
     end
 

data/lib/noiseless/multi_search.rb

@@ -224,12 +224,10 @@ module Noiseless
         next unless model_class.respond_to?(:where)
 
         ids = model_hits.map { |hit| hit["_id"] }
-        loaded_records = model_class.where(id: ids).to_a
+        records_by_id = model_class.where(id: ids).index_by { it.id.to_s }
 
         # Sort by search relevance
-        sorted_records = model_hits.filter_map do |hit|
-          loaded_records.find { |record| record.id.to_s == hit["_id"].to_s }
-        end
+        sorted_records = model_hits.filter_map { |hit| records_by_id[hit["_id"].to_s] }
 
         records[model_key] = sorted_records
       end

data/lib/noiseless/pagination.rb

@@ -75,16 +75,16 @@ module Noiseless
 
       # Encode cursor for API response
       def encode
-        Base64.urlsafe_encode64(JSON.generate({ f: field, v: value, d: direction }))
+        [ActiveSupport::JSON.encode({ f: field, v: value, d: direction })].pack("m0").tr("+/", "-_")
       end
 
       # Decode cursor from API request
       def self.decode(encoded)
         return nil if encoded.blank?
 
-        data = JSON.parse(Base64.urlsafe_decode64(encoded))
+        data = JSON.parse(encoded.tr("-_", "+/").unpack1("m0"))
         new(field: data["f"], value: data["v"], direction: data["d"]&.to_sym || :asc)
-      rescue StandardError
+      rescue ArgumentError, JSON::ParserError
         nil
       end
 

data/lib/noiseless/query_builder.rb

@@ -143,12 +143,13 @@ module Noiseless
     # @param text_query [String] The text query for BM25 matching
     # @param embedding [Array<Float>] The query embedding vector
     # @param field [Symbol] The embedding field name
+    # @param fields [Array<Symbol>] Fields the text query runs against
     # @param text_weight [Float] Weight for text search score (default: 0.5)
     # @param vector_weight [Float] Weight for vector search score (default: 0.5)
     # @param k [Integer] Number of nearest neighbors (default: 10)
-    def hybrid(text_query, embedding, field:, text_weight: 0.5, vector_weight: 0.5, k: 10)
+    def hybrid(text_query, embedding, field:, fields: [], text_weight: 0.5, vector_weight: 0.5, k: 10)
       vector_node = AST::Vector.new(field, embedding, k: k)
-      @hybrid = AST::Hybrid.new(text_query, vector_node, text_weight: text_weight, vector_weight: vector_weight)
+      @hybrid = AST::Hybrid.new(text_query, vector_node, fields:, text_weight:, vector_weight:)
       self
     end
 
@@ -188,8 +189,8 @@ module Noiseless
     # @param on [Hash] Join conditions
     # @param include_fields [Array] Fields to include from joined collection
     # @param strategy [Symbol] Join strategy :left or :inner
-    def join(collection, on:, include_fields: [], strategy: :left)
-      @joins << AST::Join.new(collection, on: on, include_fields: include_fields, strategy: strategy)
+    def join(collection, include_fields: [], strategy: :left)
+      @joins << AST::Join.new(collection, include_fields:, strategy:)
       self
     end
 

data/lib/noiseless/railtie.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require "rails/railtie"
-require_relative "instrumentation"
-require_relative "runtime_reset_middleware"
 
 module Noiseless
   class Railtie < Rails::Railtie

data/lib/noiseless/response/records.rb

@@ -75,8 +75,9 @@ module Noiseless
 
         # Sort records by the order they appear in search results
         sorted_records = []
+        records_by_id = loaded_records.index_by { it.id.to_s }
         hits.each_with_index do |hit, hit_index|
-          record = loaded_records.find { |r| r.id.to_s == hit["_id"].to_s }
+          record = records_by_id[hit["_id"].to_s]
           if record
             sorted_records << record
             @record_hit_map[record] = hit_index

data/lib/noiseless/runtime_reset_middleware.rb

@@ -8,7 +8,7 @@ module Noiseless
 
     def call(env)
       # Reset runtime tracking at the beginning of each request
-      Thread.current[:noiseless_runtime] = 0
+      ActiveSupport::IsolatedExecutionState[:noiseless_runtime] = 0
       @app.call(env)
     end
   end

data/lib/noiseless/search_index_update_job.rb

@@ -31,12 +31,9 @@ module Noiseless
         raise ArgumentError, "Unknown operation: #{operation}"
       end
     rescue StandardError => e
-      if options[:raise_on_error]
-        raise e
-      elsif (logger = Rails.logger)
-        # Log error silently
-        logger.error "Noiseless: Background job failed for #{model_class_name}##{record_id}: #{e.message}"
-      end
+      raise if options[:raise_on_error]
+
+      Rails.logger&.error "Noiseless: Background job failed for #{model_class_name}##{record_id}: #{e.message}"
     end
 
     # Minimal object for deleted records
@@ -58,16 +55,21 @@ module Noiseless
         nil
       end
     end
+
+    # Queued runs raise so the job backend retries instead of recording success.
+    module Queued
+      def perform(model_class_name, record_id, operation, options = {})
+        SearchIndexUpdateJob.perform_now(model_class_name, record_id, operation, options.merge(raise_on_error: true))
+      end
+    end
   end
 
   # ActiveJob integration
   if defined?(ActiveJob::Base)
     class ActiveJobSearchIndexUpdateJob < ActiveJob::Base
-      queue_as :default
+      include SearchIndexUpdateJob::Queued
 
-      def perform(model_class_name, record_id, operation, options = {})
-        SearchIndexUpdateJob.perform_now(model_class_name, record_id, operation, options)
-      end
+      queue_as :default
     end
   end
 
@@ -75,10 +77,7 @@ module Noiseless
   if defined?(Sidekiq)
     class SidekiqSearchIndexUpdateJob
       include Sidekiq::Worker
-
-      def perform(model_class_name, record_id, operation, options = {})
-        SearchIndexUpdateJob.perform_now(model_class_name, record_id, operation, options)
-      end
+      include SearchIndexUpdateJob::Queued
     end
   end
 end

data/lib/noiseless/test_case.rb

@@ -2,7 +2,6 @@
 
 require "minitest"
 require "async"
-require "set" # rubocop:disable Lint/RedundantRequireStatement
 require_relative "test_helper"
 
 module Noiseless

data/lib/noiseless/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Noiseless
-  VERSION = "0.7.1"
+  VERSION = "0.8.0"
 end

data/lib/noiseless.rb

@@ -11,7 +11,6 @@ require "singleton"
 require "async"
 require "async/http/endpoint"
 require "async/http/client"
-require "async/pool"
 require_relative "noiseless/version"
 
 module Noiseless
@@ -96,11 +95,7 @@ module Noiseless
 
     # Register all connections statically from YAML - no runtime registration
     config.connections_config.each do |name, params|
-      adapter_name = params[:adapter]
-      hosts = params[:hosts] || []
-      register_params = { adapter: adapter_name, hosts: hosts, timeout: params[:timeout] }
-      register_params[:request_timeout] = params[:request_timeout] if params.key?(:request_timeout)
-      connections.register(name, **register_params)
+      connections.register(name, **params, hosts: params[:hosts] || [])
     end
   end
 
@@ -123,10 +118,6 @@ module Noiseless
   loader.setup
   loader.eager_load if defined?(Rails) && Rails.respond_to?(:env) && Rails.env.test?
 
-  # Manually require response classes since they're in a subdirectory
-  require_relative "noiseless/response"
-  require_relative "noiseless/response_factory"
-
   # Global registry instance
   def self.registry
     ModelRegistry.instance