rails_action_tracker 0.1.0

data/lib/rails_action_tracker/tracker.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+require 'set'
+require 'logger'
+require 'fileutils'
+
+module RailsActionTracker
+  class Tracker
+    THREAD_KEY = :rails_action_tracker_logs
+
+    class << self
+      attr_accessor :config, :custom_logger
+
+      def configure(options = {})
+        @config = {
+          print_to_rails_log: true,
+          write_to_file: false,
+          log_file_path: nil,
+          services: [],
+          ignored_tables: %w[pg_attribute pg_index pg_class pg_namespace pg_type ar_internal_metadata
+                             schema_migrations],
+          ignored_controllers: [],
+          ignored_actions: {}
+        }.merge(options)
+
+        setup_custom_logger if @config[:write_to_file] && @config[:log_file_path]
+      end
+
+      def start_tracking
+        Thread.current[THREAD_KEY] = {
+          read: Set.new,
+          write: Set.new,
+          captured_logs: [],
+          controller: nil,
+          action: nil
+        }
+        subscribe_to_sql_notifications
+        subscribe_to_logger
+      end
+
+      def stop_tracking
+        unsubscribe_from_sql_notifications
+        unsubscribe_from_logger
+        logs = Thread.current[THREAD_KEY] || { read: Set.new, write: Set.new, captured_logs: [], controller: nil,
+                                               action: nil }
+        Thread.current[THREAD_KEY] = nil
+        logs
+      end
+
+      def print_summary
+        logs = Thread.current[THREAD_KEY]
+        return unless logs
+
+        # Check if this controller/action should be ignored
+        return if should_ignore_controller_action?(logs[:controller], logs[:action])
+
+        services_accessed = detect_services(logs[:captured_logs])
+        read_models = logs[:read].to_a.uniq.sort
+        write_models = logs[:write].to_a.uniq.sort
+
+        controller_action = "#{logs[:controller]}##{logs[:action]}" if logs[:controller] && logs[:action]
+
+        # Generate outputs with and without colors
+        colored_output = format_summary(read_models, write_models, services_accessed, controller_action, true)
+        plain_output = format_summary(read_models, write_models, services_accessed, controller_action, false)
+
+        log_output(colored_output, plain_output)
+      end
+
+      private
+
+      def should_ignore_controller_action?(controller, action)
+        return false unless config && controller && action
+
+        # Check if entire controller is ignored
+        ignored_controllers = config[:ignored_controllers] || []
+        return true if ignored_controllers.include?(controller)
+
+        # Check controller-specific action ignores
+        ignored_actions = config[:ignored_actions] || {}
+
+        # Handle flexible controller/action filtering
+        ignored_actions.each do |pattern_controller, actions|
+          # Match controller name (exact match or empty string for all controllers)
+          next unless pattern_controller.empty? || pattern_controller == controller
+
+          # If actions is empty array or nil, ignore entire controller
+          return true if actions.nil? || (actions.is_a?(Array) && actions.empty?)
+
+          # Check specific actions
+          return true if actions.is_a?(Array) && actions.include?(action)
+        end
+
+        false
+      end
+
+      def setup_custom_logger
+        return unless config[:log_file_path]
+
+        log_dir = File.dirname(config[:log_file_path])
+        FileUtils.mkdir_p(log_dir) unless Dir.exist?(log_dir)
+
+        @custom_logger = Logger.new(config[:log_file_path])
+        @custom_logger.formatter = proc do |severity, datetime, _progname, msg|
+          "[#{datetime.strftime('%Y-%m-%d %H:%M:%S')}] #{severity}: #{msg}\n"
+        end
+      end
+
+      def log_query(sql)
+        logs = Thread.current[THREAD_KEY]
+        return unless logs
+
+        return unless (match = sql.match(/(FROM|INTO|UPDATE|INSERT INTO)\s+["']?(\w+)["']?/i))
+
+        table = match[2]
+
+        # Skip ignored tables (case insensitive)
+        ignored_tables = config&.dig(:ignored_tables) || %w[pg_attribute pg_index pg_class pg_namespace
+                                                            pg_type ar_internal_metadata schema_migrations]
+        return if ignored_tables.map(&:downcase).include?(table.downcase)
+
+        if sql =~ /\A\s*SELECT/i
+          logs[:read] << table
+        else
+          logs[:write] << table
+        end
+      end
+
+      def log_message(message)
+        logs = Thread.current[THREAD_KEY]
+        return unless logs
+
+        logs[:captured_logs] << message
+      end
+
+      def detect_services(captured_logs)
+        services_accessed = []
+        default_service_patterns = [
+          { name: 'Pusher', pattern: /pusher/i },
+          { name: 'Honeybadger', pattern: /honeybadger/i },
+          { name: 'Redis', pattern: /redis/i },
+          { name: 'Sidekiq', pattern: /sidekiq/i },
+          { name: 'ActionMailer', pattern: /mail|email/i },
+          { name: 'HTTP', pattern: /http|api/i }
+        ]
+
+        service_patterns = config&.dig(:services) || default_service_patterns
+
+        captured_logs.each do |line|
+          service_patterns.each do |service_config|
+            if service_config.is_a?(Hash)
+              services_accessed << service_config[:name] if line.match?(service_config[:pattern])
+            elsif service_config.is_a?(String)
+              services_accessed << service_config if line.downcase.include?(service_config.downcase)
+            end
+          end
+        end
+
+        services_accessed.uniq
+      end
+
+      # rubocop:disable Style/OptionalBooleanParameter
+      def format_summary(read_models, write_models, services, controller_action = nil, colorize = true)
+        colors = setup_colors(colorize)
+        max_rows = [read_models.size, write_models.size, services.size].max
+
+        return format_empty_summary(controller_action, colors) if max_rows.zero?
+
+        padded_arrays = pad_arrays_to_max_length(read_models, write_models, services, max_rows)
+        column_widths = calculate_column_widths(padded_arrays[:read], padded_arrays[:write], padded_arrays[:services])
+
+        build_table(padded_arrays, column_widths, controller_action, colors, max_rows)
+      end
+      # rubocop:enable Style/OptionalBooleanParameter
+
+      def setup_colors(colorize)
+        return { green: '', red: '', blue: '', yellow: '', reset: '' } unless colorize
+        return default_colors unless rails_colorized?
+
+        {
+          green: fetch_rails_color('GREEN', "\e[32m"),
+          red: fetch_rails_color('RED', "\e[31m"),
+          blue: fetch_rails_color('BLUE', "\e[34m"),
+          yellow: fetch_rails_color('YELLOW', "\e[33m"),
+          reset: fetch_rails_color('CLEAR', "\e[0m")
+        }
+      end
+
+      def default_colors
+        { green: '', red: '', blue: '', yellow: '', reset: '' }
+      end
+
+      def rails_colorized?
+        defined?(Rails) && Rails.logger.respond_to?(:colorize_logging) && Rails.logger.colorize_logging
+      end
+
+      def fetch_rails_color(color_name, fallback)
+        if defined?(ActiveSupport::LogSubscriber.const_get(color_name))
+          ActiveSupport::LogSubscriber.const_get(color_name)
+        else
+          fallback
+        end
+      end
+
+      def format_empty_summary(controller_action, colors)
+        header = controller_action ? "#{colors[:yellow]}#{controller_action}#{colors[:reset]}: " : ''
+        "#{header}No models or services accessed during this request.\n"
+      end
+
+      def pad_arrays_to_max_length(read_models, write_models, services, max_rows)
+        {
+          read: read_models + [''] * (max_rows - read_models.size),
+          write: write_models + [''] * (max_rows - write_models.size),
+          services: services + [''] * (max_rows - services.size)
+        }
+      end
+
+      def calculate_column_widths(read_models, write_models, services)
+        {
+          read: [read_models.map(&:length).max || 0, 'Models Read'.length].max,
+          write: [write_models.map(&:length).max || 0, 'Models Written'.length].max,
+          services: [services.map(&:length).max || 0, 'Services Accessed'.length].max
+        }
+      end
+
+      def build_table(arrays, widths, controller_action, colors, max_rows)
+        separator = build_separator(widths)
+        header = controller_action ? "#{colors[:yellow]}#{controller_action}#{colors[:reset]} - " : ''
+
+        table = "#{header}Models and Services accessed during request:\n"
+        table += "#{separator}\n"
+        table += build_header_row(widths, colors)
+        table += "#{separator}\n"
+        table += build_data_rows(arrays, widths, max_rows)
+        table + "#{separator}\n"
+      end
+
+      def build_separator(widths)
+        "+#{'-' * (widths[:read] + 2)}+#{'-' * (widths[:write] + 2)}+#{'-' * (widths[:services] + 2)}+"
+      end
+
+      def build_header_row(widths, colors)
+        read_header = "#{colors[:green]}#{'Models Read'.ljust(widths[:read])}#{colors[:reset]}"
+        write_header = "#{colors[:red]}#{'Models Written'.ljust(widths[:write])}#{colors[:reset]}"
+        services_header = "#{colors[:blue]}#{'Services Accessed'.ljust(widths[:services])}#{colors[:reset]}"
+
+        "| #{read_header} | #{write_header} | #{services_header} |\n"
+      end
+
+      def build_data_rows(arrays, widths, max_rows)
+        table = ''
+        max_rows.times do |i|
+          read_cell = arrays[:read][i].ljust(widths[:read])
+          write_cell = arrays[:write][i].ljust(widths[:write])
+          services_cell = arrays[:services][i].ljust(widths[:services])
+          table += "| #{read_cell} | #{write_cell} | #{services_cell} |\n"
+        end
+        table
+      end
+
+      def log_output(colored_output, plain_output)
+        if config.nil?
+          Rails.logger.info "\n#{colored_output}" if defined?(Rails)
+        else
+          Rails.logger.info "\n#{colored_output}" if config[:print_to_rails_log] && defined?(Rails)
+
+          custom_logger.info "\n#{plain_output}" if config[:write_to_file] && custom_logger
+        end
+      end
+
+      def subscribe_to_sql_notifications
+        @subscribe_to_sql_notifications ||= ActiveSupport::Notifications
+                                            .subscribe('sql.active_record') do |_name, _start, _finish, _id, payload|
+          sql = payload[:sql]
+          log_query(sql) unless sql.include?('SCHEMA')
+        end
+      end
+
+      def unsubscribe_from_sql_notifications
+        ActiveSupport::Notifications.unsubscribe(@sql_subscriber) if @sql_subscriber
+        @sql_subscriber = nil
+      end
+
+      def subscribe_to_logger
+        return unless defined?(Rails)
+
+        @subscribe_to_logger ||= ActiveSupport::Notifications.subscribe(/.*/) do |name, _start, _finish, _id, payload|
+          next if name.include?('sql.active_record')
+
+          # Capture controller and action information
+          if name == 'process_action.action_controller'
+            logs = Thread.current[THREAD_KEY]
+            if logs
+              logs[:controller] = payload[:controller]
+              logs[:action] = payload[:action]
+            end
+          end
+
+          message = case name
+                    when 'process_action.action_controller'
+                      "Controller: #{payload[:controller]}##{payload[:action]}"
+                    when 'render_template.action_view'
+                      "Template: #{payload[:identifier]}"
+                    else
+                      payload.to_s
+                    end
+
+          log_message(message) if message && !message.empty?
+        end
+      end
+
+      def unsubscribe_from_logger
+        ActiveSupport::Notifications.unsubscribe(@logger_subscriber) if @logger_subscriber
+        @logger_subscriber = nil
+      end
+    end
+  end
+end

data/lib/rails_action_tracker/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RailsActionTracker
+  VERSION = '0.1.0'
+end

data/lib/rails_action_tracker.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'rails_action_tracker/version'
+require_relative 'rails_action_tracker/tracker'
+require_relative 'rails_action_tracker/middleware'
+
+module RailsActionTracker
+  class Error < StandardError; end
+end
+
+require_relative 'rails_action_tracker/railtie' if defined?(Rails) && defined?(Rails::Railtie)

data/script/test-all

@@ -0,0 +1,65 @@
+#!/bin/bash
+
+set -e
+
+echo "🚀 Testing Rails Action Tracker across all Rails versions..."
+echo
+
+# Colors for output
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Track results
+PASSED=()
+FAILED=()
+
+# Rails versions to test
+RAILS_VERSIONS=(
+  "rails-5.0"
+  "rails-5.1" 
+  "rails-5.2"
+  "rails-6.0"
+  "rails-6.1"
+  "rails-7.0"
+  "rails-7.1"
+  "rails-8.0"
+)
+
+echo -e "${YELLOW}Installing Appraisal gemfiles...${NC}"
+bundle exec appraisal install
+echo
+
+for rails_version in "${RAILS_VERSIONS[@]}"; do
+  echo -e "${YELLOW}Testing $rails_version...${NC}"
+  
+  if bundle exec appraisal $rails_version rake test; then
+    echo -e "${GREEN}✅ $rails_version PASSED${NC}"
+    PASSED+=($rails_version)
+  else
+    echo -e "${RED}❌ $rails_version FAILED${NC}"
+    FAILED+=($rails_version)
+  fi
+  echo
+done
+
+echo "========================================="
+echo "📊 SUMMARY:"
+echo "========================================="
+echo -e "${GREEN}✅ PASSED (${#PASSED[@]}):${NC}"
+for version in "${PASSED[@]}"; do
+  echo "  - $version"
+done
+
+if [ ${#FAILED[@]} -ne 0 ]; then
+  echo -e "${RED}❌ FAILED (${#FAILED[@]}):${NC}"
+  for version in "${FAILED[@]}"; do
+    echo "  - $version"
+  done
+  echo
+  exit 1
+else
+  echo -e "${GREEN}🎉 All Rails versions passed!${NC}"
+  echo
+fi

data/sig/rails_action_tracker.rbs

@@ -0,0 +1,4 @@
+module RailsActionTracker
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: rails_action_tracker
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Deepak Mahakale
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: A Rails gem that provides detailed tracking of model read/write operations
+  and service usage during controller action execution, with configurable logging
+  options.
+email:
+- deepakmahakale@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- Appraisals
+- CHANGELOG.md
+- CONTRIBUTING.md
+- DEVELOPMENT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/generators/rails_action_tracker/install_generator.rb
+- lib/generators/rails_action_tracker/templates/initializer.rb
+- lib/rails_action_tracker.rb
+- lib/rails_action_tracker/middleware.rb
+- lib/rails_action_tracker/railtie.rb
+- lib/rails_action_tracker/tracker.rb
+- lib/rails_action_tracker/version.rb
+- script/test-all
+- sig/rails_action_tracker.rbs
+homepage: https://github.com/deepakmahakale/rails_action_tracker
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/deepakmahakale/rails_action_tracker
+  source_code_uri: https://github.com/deepakmahakale/rails_action_tracker
+  changelog_uri: https://github.com/deepakmahakale/rails_action_tracker/blob/master/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Track ActiveRecord model operations and service usage during Rails action
+  calls
+test_files: []