routes-analyzer 0.1.1 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0df5dfa530f0ff7771563a035f35bd225a1b7d20e01c87aa626c87fa60a94a4
-  data.tar.gz: 1683d8d3a06202ce56e266bdd20b0d8805a08fc9eac68d9041be507fe78b367a
+  metadata.gz: 79618d6dca3b9246b8023943d2863bc985e3d9674fd56e51aec84ad0c10ebf62
+  data.tar.gz: 07043a67f3c6011aacc34097476444e45c7749ed8134bd71b48bb29ffe47cdff
 SHA512:
-  metadata.gz: ddec876f42e606cca4f39b24ff3c2d442ae1d4ec635de8e6abba2434be1ca22629abe98a24750c048559ce67de9ec7c6042bb8481f8a87790508fcda5e28165d
-  data.tar.gz: 867674e3c3c49f0ed810d78b6871092261b815e5f6fe696de450973cadd9de6dd8ecdf7e759af0867245a8a2e92bba5612657f0f623110744d4db72dd5ea3f0e
+  metadata.gz: 86f3904c67a101f44776d2d583c1f818340b5f79218a9ac0297a3eca2045faaff4142218cdb8e8a1bc4ec68ac122918aa237845dd2ad8a068a4ee2a45804058b
+  data.tar.gz: 43bf9d60f739f769efe4bd35a628a30537298226da1b5b8457f98e726168718361f292663eaa47a1d811baac744d489278a0a969bcb0e13f3792c791be5a9b78

data/README.md

@@ -1,10 +1,13 @@
 # Routes::Analyzer
 
+[![Gem Version](https://badge.fury.io/rb/routes-analyzer.svg)](https://badge.fury.io/rb/routes-analyzer)
+
 A Ruby on Rails plugin that tracks and analyzes route usage in your application. It uses Redis to store route access patterns and provides insights into which routes are being used and which are not.
 
 ## Features
 
 - **Route Usage Tracking**: Automatically tracks which routes are accessed and how often
+- **Smart Parameter Handling**: Routes with parameters (like `/users/:id`) are properly grouped under a single pattern instead of creating separate entries for each parameter value
 - **Redis Storage**: Uses Redis to store usage statistics efficiently  
 - **Configurable Timeframe**: Set custom analysis periods (default 30 days)
 - **Comprehensive Reporting**: Shows both used and unused routes
@@ -109,12 +112,47 @@ Displays current configuration and tests Redis connectivity.
 ## How It Works
 
 1. **Middleware Integration**: The plugin automatically adds middleware to your Rails application
-2. **Request Tracking**: Each HTTP request is analyzed to extract route information
-3. **Redis Storage**: Usage data is stored in Redis with the following structure:
+2. **Route Filtering**: Only routes explicitly defined in `routes.rb` are tracked. This ensures that:
+   - Undefined routes (404 errors) are not tracked
+   - Catch-all routes that handle unknown paths don't pollute the data
+   - Only legitimate application routes are analyzed
+3. **Request Tracking**: Each valid HTTP request is analyzed to extract route information
+4. **Redis Storage**: Usage data is stored in Redis with the following structure:
    - Route path and HTTP method
    - Access count within the timeframe
    - Last access timestamp
-4. **Data Expiration**: Redis keys automatically expire after the configured timeframe plus a buffer period
+5. **Data Expiration**: Redis keys automatically expire after the configured timeframe plus a buffer period
+
+## Route Detection
+
+The middleware uses Rails' routing system to determine if a route is valid:
+
+- **Path Parameters Check**: Verifies that Rails recognized the route and set path parameters
+- **Route Recognition**: Uses `Rails.application.routes.recognize_path` to confirm the route exists in `routes.rb`
+- **Error Handling**: Gracefully handles routing errors and invalid requests without tracking them
+
+This approach ensures that only routes you've intentionally defined are included in the usage analysis.
+
+## Parameterized Route Handling
+
+The gem intelligently handles routes with parameters by tracking them under their route pattern rather than individual parameter values:
+
+- **Route Definition**: `/users/:id` in `routes.rb`
+- **Actual Requests**: `/users/123`, `/users/456`, `/users/789`
+- **Tracked As**: Single entry for `/users/:id` with combined statistics
+
+This means that accessing `/users/123` three times and `/users/456` two times will show up as 5 total accesses to the `/users/:id` route pattern, not as separate routes.
+
+**Example Output:**
+```
+COUNT    ROUTE                   METHOD    CONTROLLER#ACTION
+--------------------------------------------------------------
+15       /users/:id             GET       users#show
+8        /users/:id/profile     GET       users#profile
+23       /posts/:id             GET       posts#show
+```
+
+This grouping provides much more meaningful insights into which route patterns are being used in your application.
 
 ## Data Structure
 

data/lib/routes/analyzer/middleware.rb

@@ -23,6 +23,9 @@ module Routes
         return false unless Routes::Analyzer.track_usage?
         return false unless env["action_controller.instance"]
 
+        # Check if the route is actually defined in routes.rb
+        return false unless route_defined_in_rails?(env)
+
         true
       rescue => e
         Rails.logger.warn "Routes::Analyzer: Failed to check tracking conditions: #{e.message}"
@@ -57,19 +60,49 @@ module Routes
         Rails.logger.warn "Routes::Analyzer: Failed to track route usage: #{e.message}"
       end
 
+      def route_defined_in_rails?(env)
+        request = Rack::Request.new(env)
+
+        # First check: if Rails didn't set path_parameters, it means the route wasn't recognized
+        # This happens when Rails can't match the request to any defined route
+        path_params = env["action_dispatch.request.path_parameters"]
+        return false unless path_params
+
+        # Second check: verify that Rails can recognize this path/method combination
+        # This ensures the route is actually defined in routes.rb and not just handled by a catch-all
+        route_exists = Rails.application.routes.recognize_path(
+          request.path_info,
+          method: request.request_method.downcase.to_sym
+        )
+
+        return true if route_exists
+        false
+      rescue ActionController::RoutingError, NoMethodError
+        # If recognize_path raises RoutingError, the route is not defined in routes.rb
+        # NoMethodError can occur if the controller/action doesn't exist
+        false
+      rescue => e
+        Rails.logger.warn "Routes::Analyzer: Error checking route definition: #{e.message}"
+        false
+      end
+
       def extract_route_info(env, request)
         # Get the matched route from Rails
         if env["action_controller.instance"]
           controller = env["action_controller.instance"]
           action = controller.action_name
           controller_name = controller.controller_name
+          method = request.request_method.upcase
+
+          # Find the route pattern instead of using the actual path
+          route_path = find_route_pattern(controller_name, action, method)
 
-          # Build route pattern from request path, removing query parameters
-          route_path = request.path_info
+          # Fallback to actual path if pattern not found
+          route_path ||= request.path_info
 
           {
             route: route_path,
-            method: request.request_method.upcase,
+            method: method,
             controller: controller_name,
             action: action
           }
@@ -79,6 +112,23 @@ module Routes
         nil
       end
 
+      def find_route_pattern(controller_name, action, method)
+        return nil unless defined?(Rails) && Rails.application
+
+        Rails.application.routes.routes.each do |route|
+          if route.defaults[:controller] == controller_name &&
+             route.defaults[:action] == action &&
+             route.verb == method
+            return route.path.spec.to_s.gsub(/\(\.:format\)$/, "")
+          end
+        end
+
+        nil
+      rescue => e
+        Rails.logger.warn "Routes::Analyzer: Failed to find route pattern: #{e.message}"
+        nil
+      end
+
       def build_redis_key(route, method)
         "#{configuration.redis_key_prefix}:#{method}:#{route.gsub('/', ':')}"
       end

data/lib/routes/analyzer/version.rb

@@ -1,5 +1,5 @@
 module Routes
   module Analyzer
-    VERSION = "0.1.1"
+    VERSION = "0.1.4"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: routes-analyzer
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.4
 platform: ruby
 authors:
 - Gregorio Galante