routes-analyzer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7f58db787f3f902a902e91e34159d5f3faec5df6716e2003f643228d322effad
+  data.tar.gz: 07ddd074b8305ac9af28a058c5ed718ea1016829047a725f1f74628e26ea83c6
+SHA512:
+  metadata.gz: a186755509cd04163bb0c58140970e23613c8f8fae77191f6061c412a5aa479fc99ead4a83f79a5a05178aca51c746973eb8bd51b965fba2c48c8f08c4b0a990
+  data.tar.gz: 2b6fe9f6d24e3937bbab1ebbebe1db3043dbe0af90705a717e0a6507c19d78d39363812a6f3c3d48459e5ef577bb947edc70f893b63fe954d8ae52cd38309b95

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright Gregorio Galante
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,147 @@
+# 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
+- **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
+- **Rake Tasks**: Easy-to-use commands for viewing statistics and managing data
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "routes-analyzer"
+```
+
+And then execute:
+```bash
+$ bundle install
+```
+
+## Configuration
+
+After installation, generate the configuration file:
+
+```bash
+bundle exec rails generate routes:analyzer:install
+```
+
+This will create `config/initializers/routes_analyzer.rb` with the following content:
+
+```ruby
+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
+  config.redis_key_prefix = 'routes_analyzer'
+  
+  # Timeframe for route usage analysis in days
+  config.timeframe = 30
+end
+```
+
+Alternatively, you can create the configuration file manually in `config/initializers/routes_analyzer.rb`.
+
+### Configuration Options
+
+- **redis_url**: The Redis connection URL (required)
+- **redis_key_prefix**: Prefix for Redis keys to avoid conflicts (default: "routes_analyzer")
+- **timeframe**: Number of days to consider for "recent" usage (default: 30)
+
+## Usage
+
+Once installed and configured, the middleware will automatically start tracking route usage. No additional code changes are required.
+
+### Rake Tasks
+
+#### View Route 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
+- Last access timestamp
+- Summary statistics (total, used, unused routes)
+
+Example output:
+```
+Routes Usage Analysis (30 days)
+================================================================================
+
+COUNT    ROUTE                                    METHOD          CONTROLLER#ACTION    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
+```
+
+#### Clear Usage Data
+
+```bash
+bundle exec rake routes:analyzer:clear
+```
+
+Removes all stored route usage data from Redis.
+
+#### Check Configuration
+
+```bash
+bundle exec rake routes:analyzer:config
+```
+
+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:
+   - 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
+
+## Data Structure
+
+For each tracked route, the following data is stored in Redis:
+
+```ruby
+{
+  route: "/users/:id",           # Route pattern
+  method: "GET",                 # HTTP method
+  count: 15,                     # Number of accesses
+  last_accessed: 1718721600      # Unix timestamp
+}
+```
+
+## Requirements
+
+- Ruby on Rails 8.0.2+
+- Redis 5.0+
+
+## Contributing
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a Pull Request
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/setup"
+
+require "bundler/gem_tasks"

data/config/initializers/routes_analyzer.rb.example

@@ -0,0 +1,16 @@
+# Example configuration for Routes Analyzer
+# Copy this file to config/initializers/routes_analyzer.rb in your Rails application
+
+Routes::Analyzer.configure do |config|
+  # Redis connection URL
+  # You can use environment variables to keep this secure
+  config.redis_url = ENV['REDIS_URL'] || 'redis://localhost:6379/0'
+  
+  # Redis key prefix for storing route usage data
+  # This helps avoid conflicts with other Redis data
+  config.redis_key_prefix = 'routes_analyzer'
+  
+  # Timeframe for route usage analysis in days
+  # Only routes accessed within this timeframe will be considered "active"
+  config.timeframe = 30
+end

data/lib/generators/routes/analyzer/install_generator.rb

@@ -0,0 +1,35 @@
+require "rails/generators/base"
+
+module Routes
+  module Analyzer
+    module Generators
+      class InstallGenerator < Rails::Generators::Base
+        desc "Install Routes Analyzer configuration file"
+
+        def self.source_root
+          @source_root ||= File.expand_path("templates", __dir__)
+        end
+
+        def create_configuration_file
+          template "routes_analyzer.rb", "config/initializers/routes_analyzer.rb"
+        end
+
+        def show_instructions
+          say "\n"
+          say "Routes Analyzer has been installed!", :green
+          say "\n"
+          say "Configuration file created at: config/initializers/routes_analyzer.rb"
+          say "\n"
+          say "Next steps:"
+          say "1. Configure your Redis connection in the initializer"
+          say "2. Restart your Rails application"
+          say "3. Use rake tasks to analyze your routes:"
+          say "   - rails routes:analyzer:usage   # Show route usage statistics"
+          say "   - rails routes:analyzer:config  # Check configuration"
+          say "   - rails routes:analyzer:clear   # Clear usage data"
+          say "\n"
+        end
+      end
+    end
+  end
+end

data/lib/generators/routes/analyzer/templates/routes_analyzer.rb

@@ -0,0 +1,21 @@
+# Configuration for Routes Analyzer
+# This plugin tracks route usage in your Rails application using Redis
+
+Routes::Analyzer.configure do |config|
+  # Redis connection URL
+  # You can use environment variables to keep this secure
+  # Examples:
+  #   - redis://localhost:6379/0
+  #   - redis://username:password@localhost:6379/0
+  #   - rediss://localhost:6380/0 (for SSL/TLS)
+  config.redis_url = ENV["REDIS_URL"] || "redis://localhost:6379/0"
+
+  # Redis key prefix for storing route usage data
+  # This helps avoid conflicts with other Redis data in your application
+  config.redis_key_prefix = "routes_analyzer"
+
+  # Timeframe for route usage analysis in days
+  # Only routes accessed within this timeframe will be considered "active"
+  # This also determines how long data is stored in Redis
+  config.timeframe = 30
+end

data/lib/routes/analyzer/configuration.rb

@@ -0,0 +1,35 @@
+module Routes
+  module Analyzer
+    class Configuration
+      attr_accessor :redis_url, :redis_key_prefix, :timeframe
+
+      def initialize
+        @redis_url = nil
+        @redis_key_prefix = "routes_analyzer"
+        @timeframe = 30 # days
+      end
+
+      def redis_client
+        @redis_client ||= Redis.new(url: redis_url) if redis_url
+      end
+
+      def validate!
+        raise "Redis URL must be configured" unless redis_url
+
+        # Test Redis connection
+        redis_client.ping
+      rescue Redis::BaseError => e
+        raise "Failed to connect to Redis: #{e.message}"
+      end
+
+      def valid?
+        return false unless redis_url
+
+        redis_client.ping
+        true
+      rescue Redis::BaseError
+        false
+      end
+    end
+  end
+end

data/lib/routes/analyzer/middleware.rb

@@ -0,0 +1,91 @@
+require "redis"
+
+module Routes
+  module Analyzer
+    class Middleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        status, headers, response = @app.call(env)
+
+        # Track route usage after processing the request
+        track_route_usage(env) if should_track?(env)
+
+        [ status, headers, response ]
+      end
+
+      private
+
+      def should_track?(env)
+        # Only track if configuration is valid and we have a Rails route
+        return false unless Routes::Analyzer.track_usage?
+        return false unless env["action_controller.instance"]
+
+        true
+      rescue => e
+        Rails.logger.warn "Routes::Analyzer: Failed to check tracking conditions: #{e.message}"
+        false
+      end
+
+      def track_route_usage(env)
+        request = Rack::Request.new(env)
+        route_info = extract_route_info(env, request)
+
+        return unless route_info
+
+        redis_key = build_redis_key(route_info[:route], route_info[:method])
+        current_time = Time.current
+
+        configuration.redis_client.multi do |redis|
+          # Increment counter
+          redis.hincrby(redis_key, "count", 1)
+
+          # 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])
+          redis.hset(redis_key, "method", route_info[:method])
+
+          # Set expiration based on timeframe (add some buffer)
+          redis.expire(redis_key, (configuration.timeframe + 7) * 24 * 60 * 60)
+        end
+
+      rescue => e
+        Rails.logger.warn "Routes::Analyzer: Failed to track route usage: #{e.message}"
+      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
+
+          # Build route pattern from request path, removing query parameters
+          route_path = request.path_info
+
+          {
+            route: route_path,
+            method: request.request_method.upcase,
+            controller: controller_name,
+            action: action
+          }
+        end
+      rescue => e
+        Rails.logger.warn "Routes::Analyzer: Failed to extract route info: #{e.message}"
+        nil
+      end
+
+      def build_redis_key(route, method)
+        "#{configuration.redis_key_prefix}:#{method}:#{route.gsub('/', ':')}"
+      end
+
+      def configuration
+        Routes::Analyzer.configuration
+      end
+    end
+  end
+end

data/lib/routes/analyzer/railtie.rb

@@ -0,0 +1,17 @@
+module Routes
+  module Analyzer
+    class Railtie < ::Rails::Railtie
+      initializer "routes_analyzer.configure_middleware" do |app|
+        app.middleware.use Routes::Analyzer::Middleware
+      end
+
+      rake_tasks do
+        load "tasks/routes/analyzer_tasks.rake"
+      end
+
+      generators do
+        require "generators/routes/analyzer/install_generator"
+      end
+    end
+  end
+end

data/lib/routes/analyzer/route_usage_tracker.rb

@@ -0,0 +1,89 @@
+module Routes
+  module Analyzer
+    class RouteUsageTracker
+      def initialize(configuration)
+        @configuration = configuration
+        @redis = configuration.redis_client
+      end
+
+      def get_usage_stats
+        cutoff_time = @configuration.timeframe.days.ago.to_i
+
+        # Get all route keys
+        pattern = "#{@configuration.redis_key_prefix}:*"
+        keys = @redis.keys(pattern)
+
+        usage_stats = []
+
+        keys.each do |key|
+          route_data = @redis.hgetall(key)
+          next if route_data.empty?
+
+          # Filter by timeframe if last_accessed is available
+          last_accessed = route_data["last_accessed"]&.to_i
+          next if last_accessed && last_accessed < cutoff_time
+
+          usage_stats << {
+            route: route_data["route"],
+            method: route_data["method"],
+            count: route_data["count"]&.to_i || 0,
+            last_accessed: last_accessed ? Time.at(last_accessed) : nil
+          }
+        end
+
+        # Sort by count (descending)
+        usage_stats.sort_by { |stat| -stat[:count] }
+      end
+
+      def get_all_defined_routes
+        return [] unless defined?(Rails) && Rails.application
+
+        Rails.application.routes.routes.map do |route|
+          {
+            route: route.path.spec.to_s.gsub(/\(\.:format\)$/, ""),
+            method: route.verb,
+            controller: route.defaults[:controller],
+            action: route.defaults[:action],
+            name: route.name
+          }
+        end.compact.uniq { |r| [ r[:route], r[:method] ] }
+      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]}" }
+
+        merged_routes = []
+
+        defined_routes.each do |defined_route|
+          route_key = "#{defined_route[:method]}:#{defined_route[:route]}"
+          usage_stat = usage_by_route_method[route_key]
+
+          if usage_stat
+            merged_routes << defined_route.merge(usage_stat)
+          else
+            merged_routes << defined_route.merge(
+              count: 0,
+              last_accessed: nil
+            )
+          end
+        end
+
+        # Add any tracked routes that aren't in the defined routes (in case of dynamic routes)
+        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,
+              name: nil
+            )
+          end
+        end
+
+        # Sort by count (descending), then by route name
+        merged_routes.sort_by { |route| [ -route[:count], route[:route] ] }
+      end
+    end
+  end
+end

data/lib/routes/analyzer/version.rb

@@ -0,0 +1,5 @@
+module Routes
+  module Analyzer
+    VERSION = "0.1.0"
+  end
+end

data/lib/routes/analyzer.rb

@@ -0,0 +1,25 @@
+require "routes/analyzer/version"
+require "routes/analyzer/railtie"
+require "routes/analyzer/configuration"
+require "routes/analyzer/middleware"
+require "routes/analyzer/route_usage_tracker"
+
+module Routes
+  module Analyzer
+    class << self
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield(configuration)
+      end
+
+      def track_usage?
+        configuration.valid?
+      rescue
+        false
+      end
+    end
+  end
+end

data/lib/tasks/routes/analyzer_tasks.rake

@@ -0,0 +1,112 @@
+namespace :routes do
+  namespace :analyzer do
+    desc "Show routes 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 "=" * 80
+        puts
+
+        if config.valid?
+          usage_stats = tracker.get_usage_stats
+          merged_routes = tracker.merge_with_defined_routes(usage_stats)
+        else
+          puts "Warning: Redis not configured. Showing defined routes only."
+          puts
+          merged_routes = tracker.get_all_defined_routes.map do |route|
+            route.merge(count: 0, last_accessed: nil)
+          end
+        end
+
+        if merged_routes.empty?
+          puts "No routes found."
+          next
+        end
+
+        # Print header
+        printf "%-8s %-40s %-15s %-20s %s\n", "COUNT", "ROUTE", "METHOD", "CONTROLLER#ACTION", "LAST ACCESSED"
+        puts "-" * 80
+
+        merged_routes.each do |route|
+          controller_action = if route[:controller] && route[:action]
+            "#{route[:controller]}##{route[:action]}"
+          else
+            "N/A"
+          end
+
+          last_accessed = if route[:last_accessed]
+            route[: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],
+                 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 }}"
+
+      rescue => e
+        puts "Error: #{e.message}"
+        puts "Make sure you have configured the routes analyzer properly."
+        puts "Example configuration in config/initializers/routes_analyzer.rb:"
+        puts
+        puts "Routes::Analyzer.configure do |config|"
+        puts "  config.redis_url = 'redis://localhost:6379/0'"
+        puts "  config.redis_key_prefix = 'routes_analyzer'"
+        puts "  config.timeframe = 30"
+        puts "end"
+      end
+    end
+
+    desc "Clear all routes usage data"
+    task clear: :environment do
+      begin
+        config = Routes::Analyzer.configuration
+        redis = config.redis_client
+        pattern = "#{config.redis_key_prefix}:*"
+        keys = redis.keys(pattern)
+
+        if keys.any?
+          redis.del(*keys)
+          puts "Cleared #{keys.count} route usage records."
+        else
+          puts "No route usage data found to clear."
+        end
+
+      rescue => e
+        puts "Error: #{e.message}"
+      end
+    end
+
+    desc "Show configuration"
+    task config: :environment do
+      config = Routes::Analyzer.configuration
+      puts "Routes Analyzer Configuration:"
+      puts "- Redis URL: #{config.redis_url || 'Not configured'}"
+      puts "- Redis Key Prefix: #{config.redis_key_prefix}"
+      puts "- Timeframe: #{config.timeframe} days"
+
+      begin
+        if config.redis_client
+          config.redis_client.ping
+          puts "- Redis Connection: ✓ Connected"
+        else
+          puts "- Redis Connection: ✗ Not configured"
+        end
+      rescue => e
+        puts "- Redis Connection: ✗ Failed (#{e.message})"
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: routes-analyzer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Gregorio Galante
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-06-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.1.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.1.5
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.5.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.5.1
+description: A Rails plugin that automatically tracks route usage patterns and provides
+  insights into which routes are being used and which are not. Uses Redis for efficient
+  storage and includes rake tasks for analysis.
+email:
+- me@gregoriogalante.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- config/initializers/routes_analyzer.rb.example
+- lib/generators/routes/analyzer/install_generator.rb
+- lib/generators/routes/analyzer/templates/routes_analyzer.rb
+- lib/routes/analyzer.rb
+- lib/routes/analyzer/configuration.rb
+- lib/routes/analyzer/middleware.rb
+- lib/routes/analyzer/railtie.rb
+- lib/routes/analyzer/route_usage_tracker.rb
+- lib/routes/analyzer/version.rb
+- lib/tasks/routes/analyzer_tasks.rake
+homepage: https://github.com/gregogalante/routes-analyzer
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/gregogalante/routes-analyzer
+  source_code_uri: https://github.com/gregogalante/routes-analyzer
+  changelog_uri: https://github.com/gregogalante/routes-analyzer/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.1
+signing_key:
+specification_version: 4
+summary: Track and analyze Ruby on Rails route usage with Redis
+test_files: []