rails_spotlight 0.1.6 → 0.2.0

data/lib/rails_spotlight/middlewares/handlers/file_action_handler.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../../support/project'
-
 module RailsSpotlight
   module Middlewares
     module Handlers
@@ -9,7 +7,7 @@ module RailsSpotlight
         def execute
           raise NotFound, 'File not found' unless path_valid?
 
-          File.write(file_path, json_request_body.fetch('content')) if write_mode?
+          File.write(file_path, new_content) if write_mode?
         rescue => e # rubocop:disable Style/RescueStandardError
           raise UnprocessableEntity, e.message
         end
@@ -20,11 +18,16 @@ module RailsSpotlight
           File.read(file_path)
         end
 
+        def new_content
+          json_request_body.fetch('content')
+        end
+
         def json_response_body
           {
             source: text_response_body,
-            project: ::RailsSpotlight::Support::Project.instance.name
-          }
+            changed: write_mode?,
+            project: ::RailsSpotlight.config.project_name
+          }.merge(write_mode? ? { new_content: new_content } : {})
         end
 
         def write_mode?
@@ -40,7 +43,11 @@ module RailsSpotlight
         end
 
         def file_path
-          @file_path ||= Rails.root.join(json_request_body.fetch('file'))
+          @file_path ||= if json_request_body.fetch('file').start_with?(::RailsSpotlight.config.rails_root)
+                           json_request_body.fetch('file')
+                         else
+                           File.join(::RailsSpotlight.config.rails_root, json_request_body.fetch('file'))
+                         end
         end
       end
     end

data/lib/rails_spotlight/middlewares/handlers/meta_action_handler.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RailsSpotlight
+  module Middlewares
+    module Handlers
+      class MetaActionHandler < BaseActionHandler
+        def execute; end
+
+        private
+
+        def json_response_body
+          {
+            events: events,
+            project: ::RailsSpotlight.config.project_name
+          }
+        end
+
+        def id
+          @id ||= request.params['id']
+        end
+
+        def events
+          @events ||= Storage.new(id).read || []
+        end
+      end
+    end
+  end
+end

data/lib/rails_spotlight/middlewares/handlers/sql_action_handler.rb

@@ -1,32 +1,35 @@
 # frozen_string_literal: true
 
-require_relative '../../support/project'
-
 module RailsSpotlight
   module Middlewares
     module Handlers
       class SqlActionHandler < BaseActionHandler
         def execute
-          if ActiveSupport.const_defined?('ExecutionContext')
-            ActiveSupport::Notifications.subscribed(method(:logger), 'sql.active_record', monotonic: true) do
-              ActiveSupport::ExecutionContext.set(rails_spotlight: request_id) do
-                transaction
-              end
-            end
-          else
-            ActiveSupport::Notifications.subscribed(method(:logger), 'sql.active_record') do
-              transaction
-            end
+          validate_project!
+          return transaction unless ActiveSupport.const_defined?('ExecutionContext')
+
+          ActiveSupport::ExecutionContext.set(rails_spotlight: request_id) do
+            transaction
           end
         end
 
         private
 
+        def validate_project!
+          Rails.logger.warn required_projects
+          return if required_projects.blank?
+          return if required_projects.include?(::RailsSpotlight.config.project_name)
+
+          raise UnprocessableEntity, "Check your connetction settings the current query is not allowed to be executed on the #{::RailsSpotlight.config.project_name} project"
+        end
+
         def transaction
           ActiveRecord::Base.transaction do
-            begin
-              self.result = ActiveRecord::Base.connection.exec_query(query)
-            rescue => e
+            begin # rubocop:disable Style/RedundantBegin
+              ActiveSupport::Notifications.subscribed(method(:logger), 'sql.active_record', monotonic: true) do
+                run
+              end
+            rescue => e # rubocop:disable Style/RescueStandardError
               self.error = e
             ensure
               raise ActiveRecord::Rollback unless force_execution?
@@ -34,16 +37,27 @@ module RailsSpotlight
           end
         end
 
-        attr_accessor :result
-        attr_accessor :error
+        def run
+          return self.result = ActiveRecord::Base.connection.exec_query(query) if connection_options.blank? || !ActiveRecord::Base.respond_to?(:connects_to)
+
+          connections = ActiveRecord::Base.connects_to(**connection_options)
+
+          adapter = connections.find { |c| c.role == use['role'] && c.shard.to_s == use['shard'] }
+          raise UnprocessableEntity, "Connection not found for role: `#{use["role"]}` and shard: `#{use["shard"]}`" if adapter.blank?
+
+          self.result = adapter.connection.exec_query(query)
+        end
+
+        attr_accessor :result, :error
 
         def json_response_body
           {
+            query: query,
             result: result,
             logs: logs,
-            error: error.inspect,
+            error: error.present? ? error.inspect : nil,
             query_mode: force_execution? ? 'force' : 'default',
-            project: ::RailsSpotlight::Support::Project.instance.name
+            project: ::RailsSpotlight.config.project_name
           }
         end
 
@@ -61,6 +75,25 @@ module RailsSpotlight
           @query ||= json_request_body.fetch('query')
         end
 
+        def raw_options
+          @raw_options ||= json_request_body.fetch('options', {}) || {}
+        end
+
+        def required_projects
+          @required_projects ||= raw_options.fetch('projects', [])
+        end
+
+        def use
+          @use ||= { 'shard' => 'default', 'role' => 'reading' }.merge(raw_options.fetch('use', {}))
+        end
+
+        def connection_options
+          @connection_options ||= raw_options
+                                  .symbolize_keys
+                                  .slice(:database, :shards)
+                                  .reject { |_, v| v.nil? || (!v.is_a?(TrueClass) && !v.is_a?(FalseClass) && v.empty?) } # TODO: Check for each rails version
+        end
+
         def force_execution?
           @force_execution ||= json_request_body['mode'] == 'force'
         end

data/lib/rails_spotlight/middlewares/handlers/verify_action_handler.rb

@@ -18,7 +18,10 @@ module RailsSpotlight
             body: request.body.read,
             content_type: request.content_type,
             request_method: request.request_method,
-            version: request.get_header('HTTP_X_RAILS_SPOTLIGHT')
+            version: request.get_header('HTTP_X_RAILS_SPOTLIGHT'),
+            current_gem_version: ::RailsSpotlight::VERSION,
+            project: ::RailsSpotlight.config.project_name,
+            action_cable_path: defined?(ActionCable) ? ActionCable&.server&.config&.mount_path : nil
           }
         end
       end

data/lib/rails_spotlight/middlewares/header_marker.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'rack/contrib/response_headers'
+require_relative 'concerns/skip_request_paths'
+
+module RailsSpotlight
+  module Middlewares
+    class HeaderMarker
+      include ::RailsSpotlight::Middlewares::SkipRequestPaths
+
+      def initialize(app, app_config)
+        @app = app
+        @app_config = app_config
+      end
+
+      def call(env)
+        request_path = env['PATH_INFO']
+        middleware = Rack::ResponseHeaders.new(app) do |headers|
+          headers['X-Rails-Spotlight-Version'] = RailsSpotlight::VERSION unless skip?(request_path)
+        end
+        middleware.call(env)
+      end
+
+      private
+
+      attr_reader :app, :app_config
+
+      def default_skip_paths
+        %w[/__better_errors]
+      end
+    end
+  end
+end

data/lib/rails_spotlight/middlewares/main_request_handler.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module RailsSpotlight
+  module Middlewares
+    class MainRequestHandler
+      def initialize(app)
+        @app = app
+      end
+
+      attr_reader :app
+
+      def call(env)
+        app_request = AppRequest.new env['action_dispatch.request_id']
+        app_request.current!
+        app.call(env)
+      rescue StandardError => e
+        if defined?(ActionDispatch::ExceptionWrapper)
+          wrapper = if ActionDispatch::ExceptionWrapper.method_defined? :env
+                      ActionDispatch::ExceptionWrapper.new(env, e)
+                    else
+                      ActionDispatch::ExceptionWrapper.new(env['action_dispatch.backtrace_cleaner'], e)
+                    end
+          app_request.events.push(*Event.events_for_exception(wrapper))
+        else
+          app_request.events.push(*Event.events_for_exception(e))
+        end
+        raise
+      ensure
+        Storage.new(app_request.id).write(app_request.events.to_json) unless app_request.events.empty?
+      end
+    end
+  end
+end

data/lib/rails_spotlight/middlewares/request_completed.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative 'concerns/skip_request_paths'
+
+module RailsSpotlight
+  module Middlewares
+    class RequestCompleted
+      include ::RailsSpotlight::Middlewares::SkipRequestPaths
+
+      def initialize(app, app_config)
+        @app = app
+        @app_config = app_config
+      end
+
+      def call(env)
+        if skip?(env['PATH_INFO']) || (env['HTTP_CONNECTION'] == 'Upgrade' && env['HTTP_UPGRADE'] == 'websocket')
+          app.call(env)
+        else
+          status, headers, body = app.call(env)
+          publish_event(status, headers, env)
+          [status, headers, body]
+        end
+      rescue => e # rubocop:disable Style/RescueStandardError
+        ::RailsSpotlight.config.logger.error "Error in RailsSpotlight::Middlewares::RequestCompletedHandler instrumentation: #{e.message}"
+        app.call(env)
+      end
+
+      private
+
+      attr_reader :app, :app_config
+
+      def rails_spotlight_request_id
+        Thread.current[:rails_spotlight_request_id]&.id
+      end
+
+      def publish_event(status, _headers, env)
+        return if status < 100
+        return unless rails_spotlight_request_id
+
+        request = ActionDispatch::Request.new(env)
+
+        host, url = host_and_url(env)
+        ActionCable.server.broadcast(
+          'rails_spotlight_request_completed_channel',
+          {
+            rails_spotlight_version: RailsSpotlight::VERSION,
+            id: rails_spotlight_request_id,
+            http_method: env['REQUEST_METHOD'],
+            host: host,
+            url: url,
+            format: request.format.symbol,
+            controller: request.path_parameters[:controller],
+            action: request.path_parameters[:action]
+          }
+        )
+      end
+
+      def host_and_url(env)
+        scheme = env['rack.url_scheme']
+        host = env['HTTP_HOST']
+        path = env['PATH_INFO']
+        query_string = env['QUERY_STRING']
+
+        host_url = "#{scheme}://#{host}"
+        full_url = "#{host_url}#{path}"
+        full_url += "?#{query_string}" unless query_string.empty?
+        [host_url, full_url]
+      end
+    end
+  end
+end

data/lib/rails_spotlight/middlewares/request_handler.rb

@@ -5,6 +5,7 @@ require_relative 'handlers/file_action_handler'
 require_relative 'handlers/sql_action_handler'
 require_relative 'handlers/verify_action_handler'
 require_relative 'handlers/not_found_action_handler'
+require_relative 'handlers/meta_action_handler'
 
 module RailsSpotlight
   module Middlewares
@@ -31,6 +32,7 @@ module RailsSpotlight
         when 'file' then Handlers::FileActionHandler.new(*args).call
         when 'sql' then Handlers::SqlActionHandler.new(*args).call
         when 'verify' then Handlers::VerifyActionHandler.new(*args).call
+        when 'meta' then Handlers::MetaActionHandler.new(*args).call
         else
           Handlers::NotFoundActionHandler.new(*args).call
         end

data/lib/rails_spotlight/middlewares.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module RailsSpotlight
+  module Middlewares
+    autoload :RequestHandler,     'rails_spotlight/middlewares/request_handler'
+    autoload :RequestCompleted,   'rails_spotlight/middlewares/request_completed'
+    autoload :HeaderMarker,       'rails_spotlight/middlewares/header_marker'
+    autoload :MainRequestHandler, 'rails_spotlight/middlewares/main_request_handler'
+  end
+end

data/lib/rails_spotlight/railtie.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'rails/railtie'
-require 'meta_request'
 
 module RailsSpotlight
   class Railtie < ::Rails::Railtie
@@ -9,20 +8,41 @@ module RailsSpotlight
       insert_middleware unless Rails.env.production?
     end
 
-    # initializer 'rails_spotlight.log_interceptor' do
-    #   Rails.logger&.extend(LogInterceptor)
-    # end
-    #
-    # initializer 'rails_spotlight.subscribe_to_notifications' do
-    #   AppNotifications.subscribe
-    # end
+    initializer 'rails_spotlight.log_interceptor' do
+      Rails.logger&.extend(LogInterceptor) unless Rails.env.production?
+    end
+
+    initializer 'rails_spotlight.subscribe_to_notifications' do
+      AppNotifications.subscribe unless Rails.env.production?
+    end
+
+    initializer 'rails_spotlight.action_cable_setup' do
+      unless Rails.env.production?
+        app.config.after_initialize do
+          existing_origins = Array(app.config.action_cable.allowed_request_origins)
+          app.config.action_cable.allowed_request_origins = existing_origins | [%r{\Achrome-extension://.*\z}]
+
+          require 'rails_spotlight/channels/request_completed_channel' if ::RailsSpotlight.config.request_completed_broadcast_enabled?
+          require 'rails_spotlight/channels/live_console_channel' if ::RailsSpotlight.config.live_console_enabled?
+          Rails.application.routes.draw { mount ActionCable.server => '/cable' } if ::RailsSpotlight.config.auto_mount_action_cable?
+        end
+      end
+    end
 
     def insert_middleware
+      app.middleware.use ::RailsSpotlight::Middlewares::RequestHandler
+
       if defined? ActionDispatch::DebugExceptions
-        app.middleware.insert_before ActionDispatch::DebugExceptions, RailsSpotlight::Middlewares::RequestHandler
+        app.middleware.insert_before ActionDispatch::DebugExceptions, ::RailsSpotlight::Middlewares::HeaderMarker, app.config
       else
-        app.middleware.use RailsSpotlight::Middlewares::RequestHandler
+        app.middleware.use ::RailsSpotlight::Middlewares::HeaderMarker, app.config
       end
+
+      app.middleware.use ::RailsSpotlight::Middlewares::MainRequestHandler
+
+      return unless ::RailsSpotlight.config.request_completed_broadcast_enabled?
+
+      app.middleware.insert_after ::RailsSpotlight::Middlewares::HeaderMarker, RailsSpotlight::Middlewares::RequestCompleted, app.config
     end
 
     def app

data/lib/rails_spotlight/storage.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RailsSpotlight
+  class Storage
+    attr_reader :key
+
+    def initialize(key)
+      @key = key
+    end
+
+    def write(value)
+      FileUtils.mkdir_p dir_path
+      # Use File.binwrite instead File.open(json_file, 'wb') { |file| file.write(value) }
+      File.binwrite(json_file, value)
+      maintain_file_pool(RailsSpotlight.config.storage_pool_size)
+    end
+
+    def read
+      # avoid FileNotFound error
+      File.exist?(json_file) ? File.read(json_file) : '[]'
+    end
+
+    private
+
+    def maintain_file_pool(size)
+      files = Dir["#{dir_path}/*.json"]
+      files = files.sort_by { |f| -file_ctime(f) }
+      (files[size..] || []).each do |file|
+        FileUtils.rm_f(file)
+      end
+    end
+
+    def file_ctime(file)
+      File.stat(file).ctime.to_i
+    rescue Errno::ENOENT
+      0
+    end
+
+    def json_file
+      File.join(dir_path, "#{key}.json")
+    end
+
+    def dir_path
+      @dir_path ||= RailsSpotlight.config.storage_path
+    end
+  end
+end

data/lib/rails_spotlight/utils.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RailsSpotlight
+  module Utils
+    module_function
+
+    def dev_callsite(caller)
+      app_line = caller.detect { |c| c.start_with? RailsSpotlight.config.rails_root }
+      return nil unless app_line
+
+      _, filename, _, line, _, method = app_line.split(/^(.*?)(:(\d+))(:in `(.*)')?$/)
+
+      {
+        filename: sub_source_path(filename),
+        line: line.to_i,
+        method: method
+      }
+    end
+
+    def sub_source_path(path)
+      rails_root = RailsSpotlight.config.rails_root
+      source_path = RailsSpotlight.config.source_path
+      return path if rails_root == source_path
+
+      path.sub(rails_root, source_path)
+    end
+  end
+end

data/lib/rails_spotlight/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsSpotlight
-  VERSION = '0.1.6'
+  VERSION = '0.2.0'
 end

data/lib/rails_spotlight.rb

@@ -1,9 +1,28 @@
 # frozen_string_literal: true
 
-require_relative 'rails_spotlight/version'
-require_relative 'rails_spotlight/middlewares/request_handler'
-
 module RailsSpotlight
+  autoload :VERSION,          'rails_spotlight/version'
+  autoload :Configuration,    'rails_spotlight/configuration'
+  autoload :Storage,          'rails_spotlight/storage'
+  autoload :Event,            'rails_spotlight/event'
+  autoload :AppRequest,       'rails_spotlight/app_request'
+  autoload :Middlewares,      'rails_spotlight/middlewares'
+  autoload :LogInterceptor,   'rails_spotlight/log_interceptor'
+  autoload :AppNotifications, 'rails_spotlight/app_notifications'
+  autoload :Utils,            'rails_spotlight/utils'
+
+  class << self
+    def config
+      @config ||= Configuration.load_config
+    end
+  end
+
+  autoload :Channels, 'rails_spotlight/channels'
 end
 
 require_relative 'rails_spotlight/railtie'
+
+if defined?(Rake)
+  spec = Gem::Specification.find_by_name 'rails_spotlight'
+  load "#{spec.gem_dir}/lib/tasks/init.rake"
+end

data/lib/tasks/init.rake

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'rake'
+
+namespace :rails_spotlight do
+  desc 'Generate rails_spotlight configuration file'
+  task generate_config: :environment do
+    require 'fileutils'
+
+    config_path = Rails.root.join('config', 'rails_spotlight.yml')
+
+    default_config = <<~YAML
+      # Default configuration for RailsSpotlight
+      PROJECT_NAME: <%=Rails.application.class.respond_to?(:module_parent_name) ? Rails.application.class.module_parent_name : Rails.application.class.parent_name%>
+      SOURCE_PATH: <%=Rails.root%>
+      STORAGE_PATH: <%=Rails.root.join('tmp', 'data', 'rails_spotlight')%>
+      STORAGE_POOL_SIZE: 20
+      LOGGER: <%=Logger.new(Rails.root.join('log', 'rails_spotlight.log'))%>
+      MIDDLEWARE_SKIPPED_PATHS: []
+      NOT_ENCODABLE_EVENT_VALUES:
+      # Rest of the configuration is required for ActionCable. It will be disabled automatically in when ActionCable is not available.
+      LIVE_CONSOLE_ENABLED: true
+      REQUEST_COMPLETED_BROADCAST_ENABLED: false
+      AUTO_MOUNT_ACTION_CABLE: true
+      ACTION_CABLE_MOUNT_PATH: /cable
+    YAML
+
+    if File.exist?(config_path)
+      puts 'Config file already exists: config/rails_spotlight.yml'
+    else
+      FileUtils.mkdir_p(File.dirname(config_path))
+      File.write(config_path, default_config)
+      puts 'Created config file: config/rails_spotlight.yml'
+    end
+  end
+end