Add path caching and optimization in Azu router

- Introduced a PathCache struct to optimize path building for frequently requested routes, implementing an LRU caching mechanism.
- Enhanced the router's path method to utilize caching for improved performance, reducing redundant path calculations.
- Added tests for path building optimization, WebSocket upgrade handling, and method cache pre-computation to ensure robust functionality.
- Implemented a clear_path_cache method for cache management, supporting testing and memory optimization.

These changes align with the project's focus on performance and maintainability, enhancing the overall efficiency of the Azu framework.

Author: eliasjpr

spec/azu/router_spec.cr

@@ -37,6 +37,22 @@ class TestEndpoint
   end
 end
 
+struct TestResponse
+  include Azu::Response
+
+  def render
+    "Hello, World!"
+  end
+end
+
+class SimpleEndpoint
+  include Azu::Endpoint(Azu::Request, TestResponse)
+
+  def call : TestResponse
+    TestResponse.new
+  end
+end
+
 describe Azu::Router do
   describe "route registration" do
     it "adds GET endpoint" do
@@ -238,4 +254,218 @@ describe Azu::Router do
       router.should be_a(Azu::Router)
     end
   end
+
+  describe "path building optimization" do
+    it "caches commonly requested paths" do
+      router = Azu::Router.new
+      endpoint = SimpleEndpoint.new
+      router.get("/hello", endpoint)
+
+      # Create a mock context
+      request = HTTP::Request.new("GET", "/hello")
+      io = IO::Memory.new
+      response = HTTP::Server::Response.new(io)
+      context = HTTP::Server::Context.new(request, response)
+
+            # First call should build and cache the path
+      router.process(context)
+      response.close
+
+      # Verify the path is cached by checking internal state
+      # Since path_cache is private, we'll test behavior indirectly
+      io.rewind
+      first_response = io.gets_to_end
+      first_response.should contain("Hello, World!")
+
+            # Second call should use cached path
+      io2 = IO::Memory.new
+      response2 = HTTP::Server::Response.new(io2)
+      context2 = HTTP::Server::Context.new(HTTP::Request.new("GET", "/hello"), response2)
+
+      router.process(context2)
+      response2.close
+      io2.rewind
+      second_response = io2.gets_to_end
+      second_response.should contain("Hello, World!")
+    end
+
+        it "handles WebSocket upgrade paths correctly" do
+      router = Azu::Router.new
+
+      # Register a WebSocket route for testing
+      router.ws("/ws-test", TestChannel)
+
+      # Mock WebSocket request
+      request = HTTP::Request.new("GET", "/ws-test")
+      request.headers["Upgrade"] = "websocket"
+      request.headers["Connection"] = "Upgrade"
+
+      io = IO::Memory.new
+      response = HTTP::Server::Response.new(io)
+      context = HTTP::Server::Context.new(request, response)
+
+      # Should handle WebSocket path building without errors
+      result = router.process(context)
+      # WebSocket routes may return nil or empty string depending on implementation
+      (result.nil? || result == "").should be_true
+    end
+
+    it "pre-computes method cache at initialization" do
+      router = Azu::Router.new
+
+      # Test that common HTTP methods work correctly
+      endpoint = SimpleEndpoint.new
+
+      # Test various HTTP methods
+      %w(GET POST PUT PATCH DELETE).each do |method|
+        router.add("/test-#{method.downcase}", endpoint, Azu::Method.parse(method.downcase))
+
+        request = HTTP::Request.new(method, "/test-#{method.downcase}")
+        io = IO::Memory.new
+        response = HTTP::Server::Response.new(io)
+        context = HTTP::Server::Context.new(request, response)
+
+        result = router.process(context)
+        result.should be_a(String)
+      end
+    end
+
+        it "handles path normalization correctly" do
+      router = Azu::Router.new
+      endpoint = SimpleEndpoint.new
+      router.get("/test", endpoint)
+
+      # Test path with trailing slash
+      request = HTTP::Request.new("GET", "/test/")
+      io = IO::Memory.new
+      response = HTTP::Server::Response.new(io)
+      context = HTTP::Server::Context.new(request, response)
+
+            router.process(context)
+      response.close
+      io.rewind
+      result = io.gets_to_end
+      result.should contain("Hello, World!")
+    end
+
+    it "clears path cache when requested" do
+      router = Azu::Router.new
+      endpoint = SimpleEndpoint.new
+      router.get("/cached-test", endpoint)
+
+      # Make a request to populate cache
+      request = HTTP::Request.new("GET", "/cached-test")
+      io = IO::Memory.new
+      response = HTTP::Server::Response.new(io)
+      context = HTTP::Server::Context.new(request, response)
+
+      router.process(context)
+
+      # Clear the cache
+      router.clear_path_cache
+
+      # Make another request - should still work
+      io2 = IO::Memory.new
+      response2 = HTTP::Server::Response.new(io2)
+      context2 = HTTP::Server::Context.new(HTTP::Request.new("GET", "/cached-test"), response2)
+
+      router.process(context2)
+      response2.close
+      io2.rewind
+      result = io2.gets_to_end
+      result.should contain("Hello, World!")
+    end
+
+    it "handles LRU cache eviction properly" do
+      # This test would need access to internal cache size to be fully effective
+      # For now, we'll test that the router continues to work with many requests
+      router = Azu::Router.new
+      endpoint = SimpleEndpoint.new
+
+      # Add many routes
+      (1..1200).each do |i|
+        router.get("/test#{i}", endpoint)
+      end
+
+      # Make requests to exceed cache size (default 1000)
+      (1..1200).each do |i|
+        request = HTTP::Request.new("GET", "/test#{i}")
+        io = IO::Memory.new
+        response = HTTP::Server::Response.new(io)
+        context = HTTP::Server::Context.new(request, response)
+
+        result = router.process(context)
+        result.should be_a(String)
+      end
+    end
+  end
+
+  describe "original functionality" do
+    it "handles GET requests" do
+      router = Azu::Router.new
+      endpoint = SimpleEndpoint.new
+      router.get("/hello", endpoint)
+
+      request = HTTP::Request.new("GET", "/hello")
+      io = IO::Memory.new
+      response = HTTP::Server::Response.new(io)
+      context = HTTP::Server::Context.new(request, response)
+
+      router.process(context)
+      response.close
+      io.rewind
+      result = io.gets_to_end
+      result.should contain("Hello, World!")
+    end
+
+    it "handles POST requests" do
+      router = Azu::Router.new
+      endpoint = SimpleEndpoint.new
+      router.post("/data", endpoint)
+
+      request = HTTP::Request.new("POST", "/data")
+      io = IO::Memory.new
+      response = HTTP::Server::Response.new(io)
+      context = HTTP::Server::Context.new(request, response)
+
+      router.process(context)
+      response.close
+      io.rewind
+      result = io.gets_to_end
+      result.should contain("Hello, World!")
+    end
+
+    it "handles method override" do
+      router = Azu::Router.new
+      endpoint = SimpleEndpoint.new
+      router.put("/update", endpoint)
+
+      request = HTTP::Request.new("POST", "/update?_method=PUT")
+      io = IO::Memory.new
+      response = HTTP::Server::Response.new(io)
+      context = HTTP::Server::Context.new(request, response)
+
+      router.process(context)
+      response.close
+      io.rewind
+      result = io.gets_to_end
+      result.should contain("Hello, World!")
+    end
+
+    it "handles unknown routes gracefully" do
+      router = Azu::Router.new
+
+      request = HTTP::Request.new("GET", "/unknown")
+      io = IO::Memory.new
+      response = HTTP::Server::Response.new(io)
+      context = HTTP::Server::Context.new(request, response)
+
+      # Should not raise exception, returns nil for 404s
+      result = router.process(context)
+      result.should be_nil
+
+      # Check that the response status is set to 404
+      response.status_code.should eq(404)
+    end
+  end
 end

src/azu/router.cr

@@ -40,10 +40,55 @@ module Azu
     RESOURCES       = %w(connect delete get head options patch post put trace)
     METHOD_OVERRIDE = "_method"
 
+    # Path cache for frequently requested paths
+    # LRU cache with configurable maximum size
+    private struct PathCache
+      DEFAULT_MAX_SIZE = 1000
+
+      def initialize(@max_size : Int32 = DEFAULT_MAX_SIZE)
+        @cache = Hash(String, String).new
+        @access_order = Array(String).new
+      end
+
+      def get(key : String) : String?
+        if cached_path = @cache[key]?
+          # Move to end (most recently used)
+          @access_order.delete(key)
+          @access_order << key
+          cached_path
+        end
+      end
+
+      def set(key : String, value : String) : Nil
+        # Remove if already exists to update position
+        if @cache.has_key?(key)
+          @access_order.delete(key)
+        elsif @cache.size >= @max_size
+          # Remove least recently used
+          if oldest = @access_order.shift?
+            @cache.delete(oldest)
+          end
+        end
+
+        @cache[key] = value
+        @access_order << key
+      end
+
+      def clear : Nil
+        @cache.clear
+        @access_order.clear
+      end
+    end
+
     getter radix : Radix::Tree(Route)
+    private getter path_cache : PathCache
+    private getter method_cache : Hash(String, String)
 
     def initialize
       @radix = Radix::Tree(Route).new
+      @path_cache = PathCache.new
+      @method_cache = Hash(String, String).new
+      precompute_method_cache
     end
 
     record Route,
@@ -140,14 +185,59 @@ module Azu
       raise DuplicateRoute.new("http_method: #{method}, path: #{path}, endpoint: #{endpoint}")
     end
 
-    private def path(context)
+    # Pre-compute method cache at startup to avoid repeated downcasing
+    private def precompute_method_cache : Nil
+      RESOURCES.each do |method|
+        @method_cache[method.upcase] = method.downcase
+      end
+
+      # Add common HTTP methods that might not be in RESOURCES
+      %w(HEAD OPTIONS).each do |method|
+        @method_cache[method] = method.downcase
+      end
+    end
+
+    # Optimized path building with caching and efficient string operations
+    private def path(context) : String
+      request = context.request
+      method_str = request.method
+      path_str = request.path
       upgraded = upgrade?(context)
-      String.build do |str|
-        str << "/"
-        str << "ws" if upgraded
-        str << context.request.method.downcase unless upgraded
-        str << context.request.path.rstrip('/')
+
+      # Create cache key for this specific request combination
+      cache_key = if upgraded
+        "ws:#{path_str}"
+      else
+        "#{method_str}:#{path_str}"
+      end
+
+      # Check cache first
+      if cached_path = @path_cache.get(cache_key)
+        return cached_path
+      end
+
+      # Build path efficiently using pre-allocated capacity
+      built_path = if upgraded
+        # WebSocket path: "/ws" + normalized_path
+        normalized_path = path_str.rstrip('/')
+        String.build(capacity: 4 + normalized_path.bytesize) do |str|
+          str << "/ws"
+          str << normalized_path
+        end
+      else
+        # HTTP path: "/" + method + normalized_path
+        normalized_path = path_str.rstrip('/')
+        method_lower = @method_cache[method_str]? || method_str.downcase
+        String.build(capacity: 1 + method_lower.bytesize + normalized_path.bytesize) do |str|
+          str << "/"
+          str << method_lower
+          str << normalized_path
+        end
       end
+
+      # Cache the result for future requests
+      @path_cache.set(cache_key, built_path)
+      built_path
     end
 
     private def method_override(context)
@@ -161,5 +251,10 @@ module Azu
       return unless upgrade.compare("websocket", case_insensitive: true) == 0
       context.request.headers.includes_word?("Connection", "Upgrade")
     end
+
+    # Clear path cache (useful for testing or memory management)
+    def clear_path_cache : Nil
+      @path_cache.clear
+    end
   end
 end