routes-analyzer 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79618d6dca3b9246b8023943d2863bc985e3d9674fd56e51aec84ad0c10ebf62
-  data.tar.gz: 07043a67f3c6011aacc34097476444e45c7749ed8134bd71b48bb29ffe47cdff
+  metadata.gz: 3cae3e4dca655b13929955c6357b4351607dd32ae29331c643666e6d05562e32
+  data.tar.gz: 3b533755ae2bc4b810708ac9d705085f5467c3cb94714a458baa6aaa8f5eaebf
 SHA512:
-  metadata.gz: 86f3904c67a101f44776d2d583c1f818340b5f79218a9ac0297a3eca2045faaff4142218cdb8e8a1bc4ec68ac122918aa237845dd2ad8a068a4ee2a45804058b
-  data.tar.gz: 43bf9d60f739f769efe4bd35a628a30537298226da1b5b8457f98e726168718361f292663eaa47a1d811baac744d489278a0a969bcb0e13f3792c791be5a9b78
+  metadata.gz: d47e92d852c70f7ce7108777532aea5f5650f562fe31607d522b178bc206ed8430f713408cb8e28989d38ff8c66c3c5f64bf4ac87407e928bff9f450b7189255
+  data.tar.gz: d3c981912a2b4894895f4f19d80842d878f6aa1edb1ec157a34e05d54e8ef67cd7c490ed055ef7d1bfd8187277e0f4d7eb923d52d127669eeaedcdcf3dea8a03

data/README.md

@@ -2,15 +2,15 @@
 
 [![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.
+A Ruby on Rails plugin that tracks and analyzes controller action usage in your application. It uses Redis to store action access patterns and provides insights into which controller actions 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
+- **Controller Action Tracking**: Automatically tracks which controller actions are accessed and how often
+- **Method-Agnostic Tracking**: Actions are tracked by controller#action regardless of HTTP method (GET, POST, etc.)
 - **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
+- **Comprehensive Reporting**: Shows both used and unused controller actions
 - **Rake Tasks**: Easy-to-use commands for viewing statistics and managing data
 
 ## Installation
@@ -41,10 +41,10 @@ Routes::Analyzer.configure do |config|
   # Redis connection URL
   config.redis_url = ENV['REDIS_URL'] || 'redis://localhost:6379/0'
   
-  # Redis key prefix for storing route usage data
+  # Redis key prefix for storing action usage data
   config.redis_key_prefix = 'routes_analyzer'
   
-  # Timeframe for route usage analysis in days
+  # Timeframe for action usage analysis in days
   config.timeframe = 30
 end
 ```
@@ -59,38 +59,39 @@ Alternatively, you can create the configuration file manually in `config/initial
 
 ## Usage
 
-Once installed and configured, the middleware will automatically start tracking route usage. No additional code changes are required.
+Once installed and configured, the middleware will automatically start tracking controller action usage. No additional code changes are required.
 
 ### Rake Tasks
 
-#### View Route Usage Statistics
+#### View Controller Action Usage Statistics
 
 ```bash
 bundle exec rake routes:analyzer:usage
 ```
 
 This command shows:
-- All routes defined in your `routes.rb` file
-- Usage count for each route in the specified timeframe
+- All controller actions available in your application
+- Usage count for each action in the specified timeframe
 - Last access timestamp
-- Summary statistics (total, used, unused routes)
+- Summary statistics (total, used, unused actions)
 
 Example output:
 ```
-Routes Usage Analysis (30 days)
+Controller Action Usage Analysis (30 days)
 ================================================================================
 
-COUNT    ROUTE                                    METHOD          CONTROLLER#ACTION    LAST ACCESSED
+COUNT    CONTROLLER#ACTION                        METHOD          LAST ACCESSED
 --------------------------------------------------------------------------------
-45       /users                                   GET             users#index          2025-06-18 14:30
-23       /users/:id                              GET             users#show           2025-06-18 12:15
-12       /posts                                   GET             posts#index          2025-06-17 09:45
-0        /admin/reports                           GET             admin/reports#index  Never
-0        /api/v1/health                          GET             api/v1/health#check  Never
-
-Total routes: 5
-Used routes: 3
-Unused routes: 2
+45       users#index                              GET             2025-06-18 14:30
+23       users#show                               GET             2025-06-18 12:15
+12       posts#index                              GET             2025-06-17 09:45
+5        posts#create                             POST            2025-06-16 16:20
+0        admin/reports#index                      GET             Never
+0        api/v1/health#check                      GET             Never
+
+Total actions: 6
+Used actions: 4
+Unused actions: 2
 ```
 
 #### Clear Usage Data
@@ -99,7 +100,7 @@ Unused routes: 2
 bundle exec rake routes:analyzer:clear
 ```
 
-Removes all stored route usage data from Redis.
+Removes all stored controller action usage data from Redis.
 
 #### Check Configuration
 
@@ -112,13 +113,13 @@ Displays current configuration and tests Redis connectivity.
 ## How It Works
 
 1. **Middleware Integration**: The plugin automatically adds middleware to your Rails application
-2. **Route Filtering**: Only routes explicitly defined in `routes.rb` are tracked. This ensures that:
+2. **Controller Action Filtering**: Only controller actions from defined routes 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
+   - Only legitimate application controller actions are analyzed
+3. **Request Tracking**: Each valid HTTP request is analyzed to extract controller and action information
 4. **Redis Storage**: Usage data is stored in Redis with the following structure:
-   - Route path and HTTP method
+   - Controller name and action name
    - Access count within the timeframe
    - Last access timestamp
 5. **Data Expiration**: Redis keys automatically expire after the configured timeframe plus a buffer period
@@ -133,35 +134,36 @@ The middleware uses Rails' routing system to determine if a route is valid:
 
 This approach ensures that only routes you've intentionally defined are included in the usage analysis.
 
-## Parameterized Route Handling
+## Controller Action Tracking
 
-The gem intelligently handles routes with parameters by tracking them under their route pattern rather than individual parameter values:
+The gem tracks usage by controller and action rather than by specific URL paths. This provides more meaningful insights into which parts of your application are being used:
 
-- **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
+- **Route Definition**: `resources :users` in `routes.rb`
+- **Actual Requests**: `GET /users/123`, `GET /users/456`, `POST /users/789/update`
+- **Tracked As**: Separate entries for `users#show` and `users#update` actions
 
-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.
+This means that accessing different user IDs (e.g., `/users/123`, `/users/456`, `/users/789`) will all be counted under the same `users#show` action, giving you a clear picture of which controller actions are being utilized.
 
 **Example Output:**
 ```
-COUNT    ROUTE                   METHOD    CONTROLLER#ACTION
+COUNT    CONTROLLER#ACTION       METHOD    LAST ACCESSED
 --------------------------------------------------------------
-15       /users/:id             GET       users#show
-8        /users/:id/profile     GET       users#profile
-23       /posts/:id             GET       posts#show
+15       users#show              GET       2025-06-18 14:30
+8        users#update            PATCH     2025-06-18 12:15
+23       posts#show              GET       2025-06-17 09:45
 ```
 
-This grouping provides much more meaningful insights into which route patterns are being used in your application.
+This grouping provides much more meaningful insights into which parts of your application are being used.
 
 ## Data Structure
 
-For each tracked route, the following data is stored in Redis:
+For each tracked controller action, the following data is stored in Redis:
 
 ```ruby
 {
-  route: "/users/:id",           # Route pattern
-  method: "GET",                 # HTTP method
+  controller: "users",           # Controller name
+  action: "show",                # Action name
+  method: "GET",                 # HTTP method (for reference)
   count: 15,                     # Number of accesses
   last_accessed: 1718721600      # Unix timestamp
 }

data/lib/routes/analyzer/middleware.rb

@@ -38,7 +38,7 @@ module Routes
 
         return unless route_info
 
-        redis_key = build_redis_key(route_info[:route], route_info[:method])
+        redis_key = build_redis_key(route_info[:controller], route_info[:action])
         current_time = Time.current
 
         configuration.redis_client.multi do |redis|
@@ -48,8 +48,9 @@ module Routes
           # Update last accessed timestamp
           redis.hset(redis_key, "last_accessed", current_time.to_i)
 
-          # Set route and method info (in case it's the first time)
-          redis.hset(redis_key, "route", route_info[:route])
+          # Set controller#action and method info (in case it's the first time)
+          redis.hset(redis_key, "controller", route_info[:controller])
+          redis.hset(redis_key, "action", route_info[:action])
           redis.hset(redis_key, "method", route_info[:method])
 
           # Set expiration based on timeframe (add some buffer)
@@ -94,17 +95,10 @@ module Routes
           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)
-
-          # Fallback to actual path if pattern not found
-          route_path ||= request.path_info
-
           {
-            route: route_path,
-            method: method,
             controller: controller_name,
-            action: action
+            action: action,
+            method: method
           }
         end
       rescue => e
@@ -112,25 +106,8 @@ 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('/', ':')}"
+      def build_redis_key(controller, action)
+        "#{configuration.redis_key_prefix}:#{controller}##{action}"
       end
 
       def configuration

data/lib/routes/analyzer/route_usage_tracker.rb

@@ -9,7 +9,7 @@ module Routes
       def get_usage_stats
         cutoff_time = @configuration.timeframe.days.ago.to_i
 
-        # Get all route keys
+        # Get all controller#action keys
         pattern = "#{@configuration.redis_key_prefix}:*"
         keys = @redis.keys(pattern)
 
@@ -24,7 +24,8 @@ module Routes
           next if last_accessed && last_accessed < cutoff_time
 
           usage_stats << {
-            route: route_data["route"],
+            controller: route_data["controller"],
+            action: route_data["action"],
             method: route_data["method"],
             count: route_data["count"]&.to_i || 0,
             last_accessed: last_accessed ? Time.at(last_accessed) : nil
@@ -35,54 +36,59 @@ module Routes
         usage_stats.sort_by { |stat| -stat[:count] }
       end
 
-      def get_all_defined_routes
+      def get_all_defined_actions
         return [] unless defined?(Rails) && Rails.application
 
-        Rails.application.routes.routes.map do |route|
-          {
-            route: route.path.spec.to_s.gsub(/\(\.:format\)$/, ""),
-            method: route.verb,
+        actions = []
+        Rails.application.routes.routes.each do |route|
+          next unless route.defaults[:controller] && route.defaults[:action]
+
+          actions << {
             controller: route.defaults[:controller],
             action: route.defaults[:action],
+            method: route.verb,
+            route: route.path.spec.to_s.gsub(/\(\.:format\)$/, ""),
             name: route.name
           }
-        end.compact.uniq { |r| [ r[:route], r[:method] ] }
+        end
+
+        # Remove duplicates based on controller#action (not method-specific)
+        actions.uniq { |a| "#{a[:controller]}##{a[:action]}" }
       end
 
-      def merge_with_defined_routes(usage_stats)
-        defined_routes = get_all_defined_routes
-        usage_by_route_method = usage_stats.index_by { |stat| "#{stat[:method]}:#{stat[:route]}" }
+      def merge_with_defined_actions(usage_stats)
+        defined_actions = get_all_defined_actions
+        usage_by_action = usage_stats.index_by { |stat| "#{stat[:controller]}##{stat[:action]}" }
 
-        merged_routes = []
+        merged_actions = []
 
-        defined_routes.each do |defined_route|
-          route_key = "#{defined_route[:method]}:#{defined_route[:route]}"
-          usage_stat = usage_by_route_method[route_key]
+        defined_actions.each do |defined_action|
+          action_key = "#{defined_action[:controller]}##{defined_action[:action]}"
+          usage_stat = usage_by_action[action_key]
 
           if usage_stat
-            merged_routes << defined_route.merge(usage_stat)
+            merged_actions << defined_action.merge(usage_stat)
           else
-            merged_routes << defined_route.merge(
+            merged_actions << defined_action.merge(
               count: 0,
               last_accessed: nil
             )
           end
         end
 
-        # Add any tracked routes that aren't in the defined routes (in case of dynamic routes)
+        # Add any tracked actions that aren't in the defined actions (in case of dynamic actions)
         usage_stats.each do |usage_stat|
-          route_key = "#{usage_stat[:method]}:#{usage_stat[:route]}"
-          unless defined_routes.any? { |dr| "#{dr[:method]}:#{dr[:route]}" == route_key }
-            merged_routes << usage_stat.merge(
-              controller: nil,
-              action: nil,
+          action_key = "#{usage_stat[:controller]}##{usage_stat[:action]}"
+          unless defined_actions.any? { |da| "#{da[:controller]}##{da[:action]}" == action_key }
+            merged_actions << usage_stat.merge(
+              route: nil,
               name: nil
             )
           end
         end
 
-        # Sort by count (descending), then by route name
-        merged_routes.sort_by { |route| [ -route[:count], route[:route] ] }
+        # Sort by count (descending), then by controller#action name
+        merged_actions.sort_by { |action| [ -action[:count], "#{action[:controller]}##{action[:action]}" ] }
       end
     end
   end

data/lib/routes/analyzer/version.rb

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

data/lib/tasks/routes/analyzer_tasks.rake

@@ -1,60 +1,59 @@
 namespace :routes do
   namespace :analyzer do
-    desc "Show routes usage statistics"
+    desc "Show controller action usage statistics"
     task usage: :environment do
       begin
         config = Routes::Analyzer.configuration
         tracker = Routes::Analyzer::RouteUsageTracker.new(config)
 
-        puts "Routes Usage Analysis (#{config.timeframe} days)"
+        puts "Controller Action Usage Analysis (#{config.timeframe} days)"
         puts "=" * 80
         puts
 
         if config.valid?
           usage_stats = tracker.get_usage_stats
-          merged_routes = tracker.merge_with_defined_routes(usage_stats)
+          merged_actions = tracker.merge_with_defined_actions(usage_stats)
         else
-          puts "Warning: Redis not configured. Showing defined routes only."
+          puts "Warning: Redis not configured. Showing defined actions only."
           puts
-          merged_routes = tracker.get_all_defined_routes.map do |route|
-            route.merge(count: 0, last_accessed: nil)
+          merged_actions = tracker.get_all_defined_actions.map do |action|
+            action.merge(count: 0, last_accessed: nil)
           end
         end
 
-        if merged_routes.empty?
-          puts "No routes found."
+        if merged_actions.empty?
+          puts "No controller actions found."
           next
         end
 
         # Print header
-        printf "%-8s %-40s %-15s %-20s %s\n", "COUNT", "ROUTE", "METHOD", "CONTROLLER#ACTION", "LAST ACCESSED"
+        printf "%-8s %-40s %-15s %s\n", "COUNT", "CONTROLLER#ACTION", "METHOD", "LAST ACCESSED"
         puts "-" * 80
 
-        merged_routes.each do |route|
-          controller_action = if route[:controller] && route[:action]
-            "#{route[:controller]}##{route[:action]}"
+        merged_actions.each do |action|
+          controller_action = if action[:controller] && action[:action]
+            "#{action[:controller]}##{action[:action]}"
           else
             "N/A"
           end
 
-          last_accessed = if route[:last_accessed]
-            route[:last_accessed].strftime("%Y-%m-%d %H:%M")
+          last_accessed = if action[:last_accessed]
+            action[:last_accessed].strftime("%Y-%m-%d %H:%M")
           else
             "Never"
           end
 
-          printf "%-8d %-40s %-15s %-20s %s\n",
-                 route[:count],
-                 route[:route].to_s[0, 40],
-                 route[:method],
-                 controller_action[0, 20],
+          printf "%-8d %-40s %-15s %s\n",
+                 action[:count],
+                 controller_action[0, 40],
+                 action[:method],
                  last_accessed
         end
 
         puts
-        puts "Total routes: #{merged_routes.count}"
-        puts "Used routes: #{merged_routes.count { |r| r[:count] > 0 }}"
-        puts "Unused routes: #{merged_routes.count { |r| r[:count] == 0 }}"
+        puts "Total actions: #{merged_actions.count}"
+        puts "Used actions: #{merged_actions.count { |a| a[:count] > 0 }}"
+        puts "Unused actions: #{merged_actions.count { |a| a[:count] == 0 }}"
 
       rescue => e
         puts "Error: #{e.message}"
@@ -69,7 +68,7 @@ namespace :routes do
       end
     end
 
-    desc "Clear all routes usage data"
+    desc "Clear all controller action usage data"
     task clear: :environment do
       begin
         config = Routes::Analyzer.configuration
@@ -79,9 +78,9 @@ namespace :routes do
 
         if keys.any?
           redis.del(*keys)
-          puts "Cleared #{keys.count} route usage records."
+          puts "Cleared #{keys.count} controller action usage records."
         else
-          puts "No route usage data found to clear."
+          puts "No controller action usage data found to clear."
         end
 
       rescue => e

metadata

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