QueryWise 0.2.0

data/lib/query_optimizer_client/client.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require 'httparty'
+require 'json'
+
+module QueryOptimizerClient
+  class Client
+    include HTTParty
+
+    def initialize(config)
+      @config = config
+      @config.validate!
+      
+      self.class.base_uri(@config.api_url)
+      self.class.default_timeout(@config.timeout)
+    end
+
+    def analyze_queries(queries)
+      return nil unless @config.enabled?
+      
+      validate_queries!(queries)
+      
+      with_retry do
+        response = self.class.post('/analyze',
+          headers: headers,
+          body: { queries: format_queries(queries) }.to_json
+        )
+        
+        handle_response(response)
+      end
+    end
+
+    def analyze_for_ci(queries, threshold: nil)
+      return { 'data' => { 'passed' => true, 'score' => 100 } } unless @config.enabled?
+      
+      threshold ||= @config.default_threshold
+      validate_queries!(queries)
+      validate_threshold!(threshold)
+      
+      with_retry do
+        response = self.class.post('/analyze_ci',
+          headers: headers,
+          body: { 
+            queries: format_queries(queries),
+            threshold_score: threshold 
+          }.to_json
+        )
+        
+        handle_response(response)
+      end
+    end
+
+    def health_check
+      response = self.class.get('/health', headers: basic_headers)
+      handle_response(response)
+    end
+
+    def create_api_key(app_name)
+      response = self.class.post('/api_keys',
+        headers: basic_headers,
+        body: { app_name: app_name }.to_json
+      )
+      
+      handle_response(response)
+    end
+
+    private
+
+    def headers
+      basic_headers.merge('X-API-Key' => @config.api_key)
+    end
+
+    def basic_headers
+      { 'Content-Type' => 'application/json' }
+    end
+
+    def format_queries(queries)
+      queries.map do |query|
+        {
+          sql: extract_sql(query),
+          duration_ms: extract_duration(query)
+        }.compact
+      end
+    end
+
+    def extract_sql(query)
+      case query
+      when Hash
+        query[:sql] || query['sql']
+      when String
+        query
+      else
+        query.to_s
+      end
+    end
+
+    def extract_duration(query)
+      return nil unless query.is_a?(Hash)
+      
+      duration = query[:duration_ms] || query['duration_ms']
+      duration&.to_f&.round(2)
+    end
+
+    def validate_queries!(queries)
+      raise ValidationError, "Queries must be an array" unless queries.is_a?(Array)
+      raise ValidationError, "At least one query is required" if queries.empty?
+      raise ValidationError, "Maximum #{@config.batch_size} queries allowed" if queries.length > @config.batch_size
+      
+      queries.each_with_index do |query, index|
+        sql = extract_sql(query)
+        raise ValidationError, "Query #{index + 1}: SQL is required" if sql.blank?
+        raise ValidationError, "Query #{index + 1}: SQL too long (max 10000 chars)" if sql.length > 10000
+      end
+    end
+
+    def validate_threshold!(threshold)
+      unless threshold.is_a?(Numeric) && threshold >= 0 && threshold <= 100
+        raise ValidationError, "Threshold must be a number between 0 and 100"
+      end
+    end
+
+    def handle_response(response)
+      case response.code
+      when 200
+        JSON.parse(response.body)
+      when 400
+        raise ValidationError, parse_error_message(response)
+      when 401
+        raise AuthenticationError, "Invalid API key"
+      when 429
+        raise RateLimitError, "Rate limit exceeded"
+      when 500..599
+        raise APIError, "Server error: #{response.code}"
+      else
+        raise APIError, "Unexpected response: #{response.code}"
+      end
+    rescue JSON::ParserError => e
+      raise APIError, "Invalid JSON response: #{e.message}"
+    end
+
+    def parse_error_message(response)
+      body = JSON.parse(response.body)
+      body['error'] || body['errors']&.join(', ') || 'Unknown error'
+    rescue JSON::ParserError
+      "HTTP #{response.code}: #{response.body}"
+    end
+
+    def with_retry(&block)
+      retries = 0
+      
+      begin
+        yield
+      rescue RateLimitError => e
+        if @config.rate_limit_retry && retries < @config.retries
+          wait_time = 2 ** retries
+          @config.logger&.warn("Rate limited, waiting #{wait_time} seconds...")
+          sleep(wait_time)
+          retries += 1
+          retry
+        else
+          raise e
+        end
+      rescue Net::TimeoutError, Errno::ECONNREFUSED => e
+        if retries < @config.retries
+          wait_time = 2 ** retries
+          @config.logger&.warn("Connection error, retrying in #{wait_time} seconds...")
+          sleep(wait_time)
+          retries += 1
+          retry
+        else
+          raise APIError, "Connection failed after #{@config.retries} retries: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/query_optimizer_client/configuration.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module QueryOptimizerClient
+  class Configuration
+    attr_accessor :api_url, :api_key, :enabled, :timeout, :retries, :logger,
+                  :rate_limit_retry, :default_threshold, :batch_size
+
+    def initialize
+      @api_url = ENV.fetch('QUERY_OPTIMIZER_API_URL', 'http://localhost:3000/api/v1')
+      @api_key = ENV['QUERY_OPTIMIZER_API_KEY']
+      @enabled = ENV.fetch('QUERY_OPTIMIZER_ENABLED', 'false') == 'true'
+      @timeout = ENV.fetch('QUERY_OPTIMIZER_TIMEOUT', '30').to_i
+      @retries = ENV.fetch('QUERY_OPTIMIZER_RETRIES', '3').to_i
+      @rate_limit_retry = ENV.fetch('QUERY_OPTIMIZER_RATE_LIMIT_RETRY', 'true') == 'true'
+      @default_threshold = ENV.fetch('QUERY_OPTIMIZER_THRESHOLD', '80').to_i
+      @batch_size = ENV.fetch('QUERY_OPTIMIZER_BATCH_SIZE', '50').to_i
+      @logger = defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
+    end
+
+    def enabled?
+      @enabled && @api_key.present?
+    end
+
+    def valid?
+      api_key.present? && api_url.present?
+    end
+
+    def validate!
+      raise ValidationError, "API key is required" unless api_key.present?
+      raise ValidationError, "API URL is required" unless api_url.present?
+      raise ValidationError, "Invalid API URL format" unless valid_url?(api_url)
+    end
+
+    private
+
+    def valid_url?(url)
+      uri = URI.parse(url)
+      uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS)
+    rescue URI::InvalidURIError
+      false
+    end
+  end
+end

data/lib/query_optimizer_client/generators/install_generator.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+
+module QueryOptimizerClient
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      desc "Install QueryWise"
+      
+      source_root File.expand_path('templates', __dir__)
+      
+      def create_initializer
+        template 'initializer.rb', 'config/initializers/query_optimizer_client.rb'
+      end
+      
+      def create_job
+        template 'analysis_job.rb', 'app/jobs/query_optimizer_client/analysis_job.rb'
+      end
+      
+      def add_environment_variables
+        environment_template = <<~ENV
+          # Query Optimizer Client Configuration
+          # QUERY_OPTIMIZER_API_URL=http://localhost:3000/api/v1
+          # QUERY_OPTIMIZER_API_KEY=your_api_key_here
+          # QUERY_OPTIMIZER_ENABLED=true
+          # QUERY_OPTIMIZER_THRESHOLD=80
+        ENV
+        
+        append_to_file '.env.example', environment_template
+        
+        if File.exist?('.env')
+          append_to_file '.env', environment_template
+        else
+          create_file '.env', environment_template
+        end
+      end
+      
+      def show_readme
+        readme 'README'
+      end
+    end
+  end
+end

data/lib/query_optimizer_client/generators/templates/README

@@ -0,0 +1,46 @@
+===============================================================================
+
+  QueryWise has been installed!
+
+===============================================================================
+
+Next steps:
+
+1. Set up your environment variables:
+   
+   Add to your .env file:
+   QUERY_OPTIMIZER_API_URL=http://localhost:3000/api/v1
+   QUERY_OPTIMIZER_API_KEY=your_api_key_here
+   QUERY_OPTIMIZER_ENABLED=true
+
+2. Generate an API key (if you don't have one):
+   
+   rails query_optimizer:generate_key["My App Name"]
+
+3. Test your configuration:
+   
+   rails query_optimizer:check
+
+4. Run a sample analysis:
+   
+   rails query_optimizer:analyze
+
+5. Set up CI/CD integration:
+   
+   Add to your CI pipeline:
+   rails query_optimizer:ci[85]
+
+6. Customize the configuration in:
+   
+   config/initializers/query_optimizer_client.rb
+
+7. Optional: Customize the analysis job in:
+   
+   app/jobs/query_optimizer_client/analysis_job.rb
+
+===============================================================================
+
+For more information, visit:
+https://github.com/yourusername/query_optimizer_client
+
+===============================================================================

data/lib/query_optimizer_client/generators/templates/analysis_job.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module QueryOptimizerClient
+  class AnalysisJob < ApplicationJob
+    queue_as :default
+    
+    def perform(queries, endpoint = nil)
+      return unless QueryOptimizerClient.enabled?
+      
+      result = QueryOptimizerClient.analyze_queries(queries)
+      
+      return unless result&.dig('success')
+      
+      data = result['data']
+      score = data['summary']['optimization_score']
+      
+      # Log analysis results
+      log_analysis_results(data, endpoint)
+      
+      # Store results (optional - implement based on your needs)
+      store_analysis_results(data, endpoint) if respond_to?(:store_analysis_results, true)
+      
+      # Send alerts if performance is poor
+      send_alerts(data, endpoint, score) if score < 70
+      
+    rescue => e
+      Rails.logger.error "Query analysis failed: #{e.message}"
+      Rails.logger.error e.backtrace.join("\n") if Rails.env.development?
+    end
+    
+    private
+    
+    def log_analysis_results(data, endpoint)
+      endpoint_info = endpoint ? " on #{endpoint}" : ""
+      
+      Rails.logger.info "Query analysis completed#{endpoint_info}: Score #{data['summary']['optimization_score']}%, #{data['summary']['issues_found']} issues found"
+      
+      # Log N+1 queries
+      if data['n_plus_one']['detected']
+        Rails.logger.warn "N+1 queries detected#{endpoint_info}:"
+        data['n_plus_one']['patterns'].each do |pattern|
+          Rails.logger.warn "  - #{pattern['table']}.#{pattern['column']}: #{pattern['suggestion']}"
+        end
+      end
+      
+      # Log slow queries
+      data['slow_queries'].each do |query|
+        Rails.logger.warn "Slow query#{endpoint_info} (#{query['duration_ms']}ms): #{query['sql'][0..100]}..."
+        query['suggestions'].each do |suggestion|
+          Rails.logger.warn "  💡 #{suggestion}"
+        end
+      end
+      
+      # Log missing indexes
+      data['missing_indexes'].each do |index|
+        Rails.logger.info "Missing index suggestion#{endpoint_info}: #{index['sql']}"
+      end
+    end
+    
+    def send_alerts(data, endpoint, score)
+      endpoint_info = endpoint ? " on #{endpoint}" : ""
+      
+      if score < 50
+        Rails.logger.error "🚨 CRITICAL: Very low performance score (#{score}%)#{endpoint_info}"
+        # Add your critical alerting logic here (Slack, email, etc.)
+      elsif score < 70
+        Rails.logger.warn "⚠️ WARNING: Low performance score (#{score}%)#{endpoint_info}"
+        # Add your warning alerting logic here
+      end
+    end
+    
+    # Optional: Implement this method to store analysis results in your database
+    # def store_analysis_results(data, endpoint)
+    #   PerformanceAnalysis.create!(
+    #     endpoint: endpoint,
+    #     optimization_score: data['summary']['optimization_score'],
+    #     issues_found: data['summary']['issues_found'],
+    #     total_queries: data['summary']['total_queries'],
+    #     analysis_data: data,
+    #     analyzed_at: Time.current
+    #   )
+    # end
+  end
+end

data/lib/query_optimizer_client/generators/templates/initializer.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+QueryOptimizerClient.configure do |config|
+  # API Configuration
+  config.api_url = ENV.fetch('QUERY_OPTIMIZER_API_URL', 'http://localhost:3000/api/v1')
+  config.api_key = ENV['QUERY_OPTIMIZER_API_KEY']
+  config.enabled = ENV.fetch('QUERY_OPTIMIZER_ENABLED', 'false') == 'true'
+  
+  # Request Configuration
+  config.timeout = ENV.fetch('QUERY_OPTIMIZER_TIMEOUT', '30').to_i
+  config.retries = ENV.fetch('QUERY_OPTIMIZER_RETRIES', '3').to_i
+  config.batch_size = ENV.fetch('QUERY_OPTIMIZER_BATCH_SIZE', '50').to_i
+  
+  # Analysis Configuration
+  config.default_threshold = ENV.fetch('QUERY_OPTIMIZER_THRESHOLD', '80').to_i
+  config.rate_limit_retry = ENV.fetch('QUERY_OPTIMIZER_RATE_LIMIT_RETRY', 'true') == 'true'
+  
+  # Logging
+  config.logger = Rails.logger
+end
+
+# Optional: Configure Rails-specific settings
+Rails.application.configure do
+  # Middleware configuration
+  config.query_optimizer_client.min_queries = 3
+  config.query_optimizer_client.min_duration = 10
+  config.query_optimizer_client.skip_paths = ['/assets', '/health', '/api']
+  config.query_optimizer_client.async = true
+  config.query_optimizer_client.job_class = 'QueryOptimizerClient::AnalysisJob'
+end

data/lib/query_optimizer_client/middleware.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module QueryOptimizerClient
+  class Middleware
+    def initialize(app, options = {})
+      @app = app
+      @options = default_options.merge(options)
+      @client = QueryOptimizerClient.client
+    end
+
+    def call(env)
+      return @app.call(env) unless should_monitor?(env)
+
+      queries = []
+      
+      subscription = ActiveSupport::Notifications.subscribe('sql.active_record') do |name, start, finish, id, payload|
+        duration = (finish - start) * 1000
+        
+        next if skip_query?(payload, duration)
+        
+        queries << {
+          sql: payload[:sql],
+          duration_ms: duration.round(2)
+        }
+      end
+
+      status, headers, response = @app.call(env)
+
+      # Analyze queries asynchronously if we have enough
+      if queries.length >= @options[:min_queries]
+        analyze_queries_async(queries, extract_endpoint(env))
+      end
+
+      [status, headers, response]
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscription) if subscription
+    end
+
+    private
+
+    def default_options
+      {
+        min_queries: 3,
+        min_duration: 10,
+        skip_paths: ['/assets', '/health', '/api'],
+        skip_methods: ['OPTIONS', 'HEAD'],
+        async: true,
+        job_class: 'QueryOptimizerClient::AnalysisJob'
+      }
+    end
+
+    def should_monitor?(env)
+      return false unless QueryOptimizerClient.enabled?
+      
+      request = Rack::Request.new(env)
+      
+      # Skip certain paths
+      return false if @options[:skip_paths].any? { |path| request.path.start_with?(path) }
+      
+      # Skip certain methods
+      return false if @options[:skip_methods].include?(request.request_method)
+      
+      true
+    end
+
+    def skip_query?(payload, duration)
+      # Skip schema queries, cache queries, and very fast queries
+      payload[:name] =~ /SCHEMA|CACHE/ || duration < @options[:min_duration]
+    end
+
+    def extract_endpoint(env)
+      request = Rack::Request.new(env)
+      "#{request.request_method} #{request.path}"
+    end
+
+    def analyze_queries_async(queries, endpoint)
+      if @options[:async] && defined?(ActiveJob)
+        job_class = @options[:job_class].constantize
+        job_class.perform_later(queries, endpoint)
+      else
+        analyze_queries_sync(queries, endpoint)
+      end
+    rescue NameError
+      # Fallback to sync if job class doesn't exist
+      analyze_queries_sync(queries, endpoint)
+    end
+
+    def analyze_queries_sync(queries, endpoint)
+      result = @client.analyze_queries(queries)
+      
+      if result&.dig('success')
+        handle_analysis_result(result['data'], endpoint)
+      end
+    rescue => e
+      QueryOptimizerClient.configuration.logger&.error("Query analysis failed: #{e.message}")
+    end
+
+    def handle_analysis_result(data, endpoint)
+      score = data['summary']['optimization_score']
+      
+      # Log issues
+      if data['n_plus_one']['detected']
+        QueryOptimizerClient.configuration.logger&.warn(
+          "N+1 queries detected on #{endpoint}: #{data['n_plus_one']['patterns'].length} patterns"
+        )
+      end
+      
+      data['slow_queries'].each do |query|
+        QueryOptimizerClient.configuration.logger&.warn(
+          "Slow query on #{endpoint} (#{query['duration_ms']}ms): #{query['sql'][0..100]}..."
+        )
+      end
+      
+      # Alert if score is low
+      if score < 60
+        QueryOptimizerClient.configuration.logger&.error(
+          "CRITICAL: Low performance score (#{score}%) on #{endpoint}"
+        )
+      elsif score < 75
+        QueryOptimizerClient.configuration.logger&.warn(
+          "WARNING: Performance score (#{score}%) on #{endpoint}"
+        )
+      end
+    end
+  end
+end

data/lib/query_optimizer_client/railtie.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'rails/railtie'
+
+module QueryOptimizerClient
+  class Railtie < Rails::Railtie
+    railtie_name :query_optimizer_client
+
+    config.query_optimizer_client = ActiveSupport::OrderedOptions.new
+
+    initializer "query_optimizer_client.configure" do |app|
+      QueryOptimizerClient.configure do |config|
+        # Set Rails logger
+        config.logger = Rails.logger
+        
+        # Apply any configuration from Rails config
+        app.config.query_optimizer_client.each do |key, value|
+          config.public_send("#{key}=", value) if config.respond_to?("#{key}=")
+        end
+      end
+    end
+
+    initializer "query_optimizer_client.middleware" do |app|
+      if QueryOptimizerClient.configuration.enabled?
+        app.config.middleware.use QueryOptimizerClient::Middleware
+      end
+    end
+
+    rake_tasks do
+      load "query_optimizer_client/tasks.rake"
+    end
+
+    generators do
+      require "query_optimizer_client/generators/install_generator"
+    end
+  end
+end