Enhance CQL performance monitoring with interface implementation and refactoring

- Introduced interfaces for QueryProfiler and NPlusOneDetector to standardize performance monitoring components.
- Refactored the Monitor class to improve dependency injection and initialization logic.
- Updated SQL utility methods to be class methods for better accessibility.
- Removed deprecated performance components and streamlined the overall structure for improved maintainability.
- Enhanced error handling and logging for SQL operations, ensuring clearer output and better debugging capabilities.

Author: eliasjpr

src/alter_table.cr

@@ -67,12 +67,14 @@ module CQL
     # drop_column(:age)
     # ```
     def drop_column(column : Symbol)
-      col = @table.columns[column]
+      col = @table.columns[column]?
+      if col.nil?
+        Log.error { "Column #{column} does not exist in table #{@table}" }
+        return
+      end
+
       @table.columns.delete(column)
       @actions << Expression::DropColumn.new(col.name.to_s)
-    rescue exception
-      @table.columns[column] = col.not_nil!
-      Log.error { "Column #{column} does not exist in table #{@table}" }
     end
 
     # Renames a column in the table.

src/configure/enviroment_strategy.cr

@@ -56,7 +56,6 @@ module CQL::Configure
   class DevelopmentStrategy < EnvironmentStrategy
     def apply(config : Config) : Nil
       # === 📊 PERFORMANCE ===
-      config.monitor_performance = true
       config.pool_size = 5
       config.pool.size = 5
       config.pool.initial_size = 2

src/performance/config.cr

@@ -93,8 +93,12 @@ module CQL::Performance
     property reporting = Reporting.new
     property cache = Cache.new
 
-    def initialize(&)
-      yield self if block_given?
+    def initialize(&block : self -> _)
+      block.call(self)
+    end
+
+    def initialize
+      # Default initialization without block
     end
 
     # Convenience methods

src/performance/interfaces.cr

@@ -0,0 +1,23 @@
+# Interface modules for performance monitoring components
+
+module CQL::Performance
+  module QueryProfilerInterface
+    abstract def record_query(sql : String, params : Array(DB::Any),
+                              execution_time : Time::Span,
+                              rows_affected : Int64? = nil,
+                              error : String? = nil) : Void
+    abstract def statistics
+    abstract def slowest_queries(limit : Int32) : Array(QueryData)
+    abstract def issues : Array(Issue)
+    abstract def clear : Void
+  end
+
+  module NPlusOneDetectorInterface
+    abstract def record_query(sql : String) : Void
+    abstract def start_relation_loading(relation_name : String, parent_model : String) : Void
+    abstract def end_relation_loading : Void
+    abstract def patterns
+    abstract def issues : Array(Issue)
+    abstract def clear : Void
+  end
+end

src/performance/monitor.cr

@@ -8,29 +8,9 @@ require "./sql_formatter"
 require "./query_profiler"
 require "./n_plus_one_detector"
 require "./unified_report_generator"
+require "./interfaces"
 
 module CQL::Performance
-  # Component interfaces for dependency injection
-  abstract class QueryProfilerInterface
-    abstract def record_query(sql : String, params : Array(DB::Any),
-                              execution_time : Time::Span,
-                              rows_affected : Int64? = nil,
-                              error : String? = nil) : Void
-    abstract def statistics
-    abstract def slowest_queries(limit : Int32) : Array(QueryData)
-    abstract def issues : Array(Issue)
-    abstract def clear : Void
-  end
-
-  abstract class NPlusOneDetectorInterface
-    abstract def record_query(sql : String) : Void
-    abstract def start_relation_loading(relation_name : String, parent_model : String) : Void
-    abstract def end_relation_loading : Void
-    abstract def patterns
-    abstract def issues : Array(Issue)
-    abstract def clear : Void
-  end
-
   # Monitor with dependency injection
   class Monitor
     include TimingUtils
@@ -45,16 +25,18 @@ module CQL::Performance
     @start_time : Time = Time.utc
     @context : String? = nil
 
-    def initialize(@config : Config = Config.from_env,
-                   @profiler : QueryProfilerInterface? = nil,
-                   @detector : NPlusOneDetectorInterface? = nil,
-                   @sql_formatter : SQLFormatter? = nil,
-                   @report_generator : UnifiedReportGenerator? = nil)
-      # Use provided components or create defaults
-      @profiler ||= QueryProfiler.new(@config.profiling) if @config.profiling.enabled?
-      @detector ||= NPlusOneDetector.new(@config.detection) if @config.detection.enabled?
-      @sql_formatter ||= create_sql_formatter
-      @report_generator ||= UnifiedReportGenerator.new
+    def initialize(
+      config : Config = Config.from_env,
+      profiler : QueryProfilerInterface? = nil,
+      detector : NPlusOneDetectorInterface? = nil,
+      sql_formatter : SQLFormatter? = nil,
+      report_generator : UnifiedReportGenerator? = nil,
+    )
+      @config = config
+      @profiler = profiler || (config.profiling.enabled? ? QueryProfiler.new(config.profiling).as(QueryProfilerInterface) : nil)
+      @detector = detector || (config.detection.enabled? ? NPlusOneDetector.new(config.detection).as(NPlusOneDetectorInterface) : nil)
+      @sql_formatter = sql_formatter || create_sql_formatter
+      @report_generator = report_generator || UnifiedReportGenerator.new
     end
 
     # Main monitoring methods

src/performance/n_plus_one_detector.cr

@@ -5,6 +5,7 @@ require "db"
 require "./utilities"
 require "./config"
 require "./unified_report_generator"
+require "./interfaces"
 
 module CQL::Performance
   # N+1 query pattern data
@@ -20,6 +21,7 @@ module CQL::Performance
 
   # N+1 detector without event system
   class NPlusOneDetector < BasePerformanceComponent
+    include CQL::Performance::NPlusOneDetectorInterface
     @recent_queries : Array(String) = [] of String
     @patterns : Array(NPlusOnePattern) = [] of NPlusOnePattern
     @config : Config::Detection
@@ -34,7 +36,7 @@ module CQL::Performance
       return unless @enabled
       return if should_ignore?(sql)
 
-      normalized = normalize_sql(sql)
+      normalized = SQLUtils.normalize_sql(sql)
       @recent_queries << normalized
 
       # Keep window size manageable
@@ -87,7 +89,7 @@ module CQL::Performance
     end
 
     # Clear all data
-    def clear
+    def clear : Void
       @recent_queries.clear
       @patterns.clear
       reset
@@ -147,7 +149,7 @@ module CQL::Performance
     end
 
     private def log_detection(query : String, count : Int32)
-      Log.warn { "N+1 Query Pattern Detected: #{truncate_sql(query)} (#{count} times)" }
+      Log.warn { "N+1 Query Pattern Detected: #{SQLUtils.truncate_sql(query)} (#{count} times)" }
     end
   end
 end

src/performance/query_profiler.cr

@@ -4,6 +4,7 @@
 require "db"
 require "./utilities"
 require "./config"
+require "./interfaces"
 
 module CQL::Performance
   # Query execution data
@@ -14,6 +15,7 @@ module CQL::Performance
     getter timestamp : Time = Time.utc
     getter rows_affected : Int64?
     getter error : String?
+    @normalized_sql : String?
 
     def initialize(@sql, @params, @execution_time, @rows_affected = nil, @error = nil)
     end
@@ -29,6 +31,7 @@ module CQL::Performance
 
   # Query profiler without event system
   class QueryProfiler < BasePerformanceComponent
+    include CQL::Performance::QueryProfilerInterface
     @queries : Array(QueryData) = [] of QueryData
     @query_stats : Hash(String, StatsTracker) = {} of String => StatsTracker
     @slow_queries : Array(QueryData) = [] of QueryData
@@ -100,7 +103,7 @@ module CQL::Performance
     end
 
     # Clear all data
-    def clear
+    def clear : Void
       @queries.clear
       @query_stats.clear
       @slow_queries.clear
@@ -159,7 +162,7 @@ module CQL::Performance
     private def log_slow_query(query : QueryData)
       severity = query.execution_time > @config.very_slow_threshold ? "VERY SLOW" : "SLOW"
       formatted_time = format_duration(query.execution_time)
-      Log.warn { "#{severity} QUERY (#{formatted_time}): #{truncate_sql(query.sql)}" }
+      Log.warn { "#{severity} QUERY (#{formatted_time}): #{SQLUtils.truncate_sql(query.sql)}" }
     end
   end
 end

src/performance/sql_formatter.cr

@@ -140,7 +140,7 @@ module CQL::Performance
     end
 
     private def colorize_token(token : String) : String
-      return token if token.empty? || token.whitespace?
+      return token if token.empty? || token.each_char.all?(&.whitespace?)
 
       upper = token.upcase
 

src/performance/utilities.cr

@@ -42,23 +42,23 @@ module CQL::Performance
 
   # SQL normalization and formatting
   module SQLUtils
-    def normalize_sql(sql : String) : String
+    def self.normalize_sql(sql : String) : String
       sql.gsub(/\$\d+|\?/, "?")
         .gsub(/\b\d+\b/, "?")
         .gsub(/'.+?'/, "'?'")
         .gsub(/\s+/, " ")
         .strip
     end
 
-    def truncate_sql(sql : String, max_length : Int32 = 100) : String
+    def self.truncate_sql(sql : String, max_length : Int32 = 100) : String
       if sql.size > max_length
         "#{sql[0...max_length]}..."
       else
         sql
       end
     end
 
-    def format_params(params : Array(DB::Any), max_length : Int32 = 50) : String
+    def self.format_params(params : Array(DB::Any), max_length : Int32 = 50) : String
       return "[]" if params.empty?
 
       formatted = params.map do |param|

src/schema.cr

@@ -156,13 +156,11 @@ module CQL
     # schema.exec("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)")
     # ```
     def exec(sql : String)
-      CQL::Performance.benchmark(sql, [] of DB::Any) do
-        if conn = @active_connection
-          conn.exec(sql)
-        else
-          @db.using_connection do |db_conn|
-            db_conn.exec(sql)
-          end
+      if conn = @active_connection
+        conn.exec(sql)
+      else
+        @db.using_connection do |db_conn|
+          db_conn.exec(sql)
         end
       end
     end