noiseless 0.7.1 → 0.8.0

data/lib/noiseless/callbacks.rb

@@ -7,8 +7,6 @@ module Noiseless
     extend ActiveSupport::Concern
 
     included do
-      after_save :update_search_index_on_save
-      after_destroy :remove_from_search_index
       after_commit :update_search_index_on_commit, on: %i[create update]
       after_commit :remove_from_search_index_on_commit, on: :destroy
     end
@@ -28,11 +26,11 @@ module Noiseless
       end
 
       def skip_auto_index
-        previous_value = Thread.current[:noiseless_skip_auto_index]
-        Thread.current[:noiseless_skip_auto_index] = true
+        previous_value = Fiber[:noiseless_skip_auto_index]
+        Fiber[:noiseless_skip_auto_index] = true
         yield
       ensure
-        Thread.current[:noiseless_skip_auto_index] = previous_value
+        Fiber[:noiseless_skip_auto_index] = previous_value
       end
     end
 
@@ -40,7 +38,7 @@ module Noiseless
 
     def should_update_search_index?
       return false unless Noiseless.config.auto_index
-      return false if Thread.current[:noiseless_skip_auto_index]
+      return false if Fiber[:noiseless_skip_auto_index]
       return false unless self.class.auto_index_enabled?
 
       # Only update if we have searchable content
@@ -51,14 +49,6 @@ module Noiseless
       end
     end
 
-    def update_search_index_on_save
-      return unless should_update_search_index?
-
-      update_search_index_async if noiseless_new_record? || (respond_to?(:changed?) && changed?)
-    rescue Noiseless::Error => e
-      handle_search_index_error(e, :update)
-    end
-
     def update_search_index_on_commit
       return unless should_update_search_index?
 
@@ -67,14 +57,6 @@ module Noiseless
       handle_search_index_error(e, :update)
     end
 
-    def remove_from_search_index
-      return unless should_update_search_index?
-
-      remove_from_search_index_async
-    rescue Noiseless::Error => e
-      handle_search_index_error(e, :delete)
-    end
-
     def remove_from_search_index_on_commit
       return unless should_update_search_index?
 
@@ -127,13 +109,5 @@ module Noiseless
         logger.error "Noiseless: Failed to #{operation} search index for #{self.class.name}##{id}: #{error.message}"
       end
     end
-
-    def noiseless_new_record?
-      if respond_to?(:persisted?)
-        !persisted?
-      else
-        !id
-      end
-    end
   end
 end

data/lib/noiseless/connection_manager.rb

@@ -9,8 +9,10 @@ module Noiseless
 
     # Register a named client statically from YAML (boot-time only).
     # request_timeout: :default uses the adapter default, nil disables the deadline.
-    def register(name, adapter:, hosts:, timeout: nil, request_timeout: :default)
-      @configs[name.to_sym] = { adapter: adapter, hosts: hosts, timeout: timeout, request_timeout: request_timeout }
+    # Any other keys (e.g. api_key) are passed to the adapter unchanged.
+    def register(name, adapter:, hosts:, timeout: nil, request_timeout: :default, **options)
+      @configs[name.to_sym] = { adapter: adapter, hosts: hosts, timeout: timeout, request_timeout: request_timeout,
+                                options: options }
     end
 
     # Retrieve a client; defaults to :primary
@@ -20,11 +22,15 @@ module Noiseless
       # Lazy-load the adapter only when actually used
       @clients[name] ||= begin
         config = @configs.fetch(name) { raise "Unknown connection: #{name}" }
-        params = { hosts: config[:hosts] }
+        params = { **config[:options], hosts: config[:hosts] }
         params[:timeout] = config[:timeout] unless config[:timeout].nil?
         params[:request_timeout] = config[:request_timeout] unless config[:request_timeout] == :default
         Adapters.lookup(config[:adapter], **params)
       end
     end
+
+    private
+
+    def instance_variables_to_inspect = instance_variables - %i[@configs]
   end
 end

data/lib/noiseless/controller_runtime.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Noiseless
+  # Runtime tracking for Rails
+  module ControllerRuntime
+    extend ActiveSupport::Concern
+
+    protected
+
+    def append_info_to_payload(payload)
+      super
+      payload[:noiseless_runtime] = noiseless_runtime
+    end
+
+    def cleanup_view_runtime
+      runtime_before_render = noiseless_runtime
+      runtime = super
+      runtime_after_render = noiseless_runtime
+      runtime + runtime_after_render - runtime_before_render
+    end
+
+    private
+
+    def noiseless_runtime
+      ActiveSupport::IsolatedExecutionState[:noiseless_runtime] ||= 0
+    end
+
+    module ClassMethods
+      def log_process_action(payload)
+        messages = super
+        runtime = payload[:noiseless_runtime]
+        messages << ("Noiseless: %.1fms" % runtime) if runtime&.positive?
+        messages
+      end
+    end
+  end
+end

data/lib/noiseless/document_manager.rb

@@ -11,14 +11,7 @@ module Noiseless
       document = build_document
       return false unless document
 
-      client = Noiseless.connections.client(@connection)
-      client.index_document(
-        index: index_name,
-        id: document_id,
-        document: document,
-        refresh: refresh,
-        **
-      )
+      await { client.index_document(index: index_name, id: document_id, document: document, refresh: refresh, **) }
     end
 
     def update_document(refresh: false, detect_changes: true, **)
@@ -28,14 +21,7 @@ module Noiseless
         changes = extract_changes
         return false if changes.empty?
 
-        client = Noiseless.connections.client(@connection)
-        client.update_document(
-          index: index_name,
-          id: document_id,
-          changes: changes,
-          refresh: refresh,
-          **
-        )
+        await { client.update_document(index: index_name, id: document_id, changes: changes, refresh: refresh, **) }
       else
         # Fall back to full document update
         index_document(refresh: refresh, **)
@@ -43,35 +29,34 @@ module Noiseless
     end
 
     def delete_document(refresh: false, **)
-      client = Noiseless.connections.client(@connection)
-      client.delete_document(
-        index: index_name,
-        id: document_id,
-        refresh: refresh,
-        **
-      )
+      await { client.delete_document(index: index_name, id: document_id, refresh: refresh, **) }
     end
 
     def document_exists?
-      client = Noiseless.connections.client(@connection)
-      client.document_exists?(
-        index: index_name,
-        id: document_id
-      )
+      await { client.document_exists?(index: index_name, id: document_id) }
     end
 
     private
 
+    def client = Noiseless.connections.client(@connection)
+
+    def await = Sync { yield.wait }
+
     attr_reader :model_instance
 
     def build_document
-      if model_instance.respond_to?(:to_search_document)
-        model_instance.to_search_document
-      elsif model_instance.respond_to?(:to_h)
-        model_instance.to_h
-      elsif model_instance.respond_to?(:attributes)
-        model_instance.attributes
-      end
+      document = if model_instance.respond_to?(:to_search_document)
+                   model_instance.to_search_document
+                 elsif model_instance.respond_to?(:to_h)
+                   model_instance.to_h
+                 elsif model_instance.respond_to?(:attributes)
+                   model_instance.attributes
+                 end
+      document && Embedding.wrap(document, vector_fields)
+    end
+
+    def vector_fields
+      @vector_fields ||= Embedding.vector_fields(model_instance.class)
     end
 
     def document_id
@@ -131,7 +116,7 @@ module Noiseless
         end
       end
 
-      changes
+      Embedding.wrap(changes, vector_fields)
     end
   end
 end

data/lib/noiseless/embedding.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Noiseless
+  # A dense vector document field. Elasticsearch and OpenSearch send it as a
+  # base64 float32 string, which is far smaller and faster to ingest than a
+  # JSON float array; every other encoder sees a plain array.
+  Embedding = Data.define(:values) do
+    def initialize(values:)
+      super(values: AST::Vector.coerce_embedding(values))
+    end
+
+    def to_a = values
+    def as_json(*) = values
+    def to_json(*) = values.to_json(*)
+  end
+
+  class Embedding
+    VECTOR_TYPES = %w[dense_vector knn_vector].freeze
+
+    def self.vector_fields(model_class)
+      return [] unless model_class.respond_to?(:mapping) && model_class.mapping
+
+      properties = MappingDefinitionProcessor.process(model_class.mapping).dig(:mappings, :properties).to_h
+      properties.filter_map { |name, config| name.to_s if VECTOR_TYPES.include?(config[:type].to_s) }
+    end
+
+    def self.wrap(document, fields)
+      return document if fields.empty? || !document.respond_to?(:to_h)
+
+      document.to_h.to_h { |key, value| [key, fields.include?(key.to_s) && value.is_a?(Array) ? new(values: value) : value] }
+    end
+  end
+end

data/lib/noiseless/instrumentation.rb

@@ -33,142 +33,8 @@ module Noiseless
     end
 
     def add_to_runtime(duration)
-      Thread.current[:noiseless_runtime] ||= 0
-      Thread.current[:noiseless_runtime] += duration * 1000 # Convert to milliseconds
-    end
-  end
-
-  # 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
-
-  # Runtime tracking for Rails
-  module ControllerRuntime
-    extend ActiveSupport::Concern
-
-    protected
-
-    def append_info_to_payload(payload)
-      super
-      payload[:noiseless_runtime] = noiseless_runtime
-    end
-
-    def cleanup_view_runtime
-      runtime_before_render = noiseless_runtime
-      runtime = super
-      runtime_after_render = noiseless_runtime
-      runtime + runtime_after_render - runtime_before_render
-    end
-
-    private
-
-    def noiseless_runtime
-      Thread.current[:noiseless_runtime] ||= 0
-    end
-
-    module ClassMethods
-      def log_process_action(payload)
-        messages = super
-        runtime = payload[:noiseless_runtime]
-        messages << ("Noiseless: %.1fms" % runtime) if runtime&.positive?
-        messages
-      end
+      state = ActiveSupport::IsolatedExecutionState
+      state[:noiseless_runtime] = (state[:noiseless_runtime] || 0) + (duration * 1000)
     end
   end
 end

data/lib/noiseless/introspection/mermaid_diagrams.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Noiseless
+  module Introspection
+    # Mermaid renderings of an AST and of a query's execution flow.
+    class MermaidDiagrams
+      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
+
+      # 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.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