rails_spotlight 0.2.5 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5e36512b12e263c5853279d061fe2760ad7fff28c754c3362f8c848867845477
-  data.tar.gz: cc4696e37e250be0413f0286503f8a63fa18a2c43353114720e9580fa4fc646e
+  metadata.gz: a5160149fb0234c097be7b6facb6373139c39fbba56bd83e70cb6d2cb94091ff
+  data.tar.gz: 5b0f8be5ccdac8e2bd47c9cb6150ee4e13578fbc9807ef8429a8bd4ce2255d06
 SHA512:
-  metadata.gz: dd8e249fcfe8ced528c2f60225b00e8142e93989736d77090b9cc3ad0a9cf8c50dcbc85b9f76f196168ab1e6946f85d594c48935fe0751e8675d612f2d3fffa1
-  data.tar.gz: 925e741a5c6b755deed002c3833da4487a24a530d025177373fa86fca3a5ad2ef84d1730497c7c2ad128a2c9bf526127166252793b056e587ed43ab6a585dbea
+  metadata.gz: 0aec7be167fc2047ccc941d66acc2eb6ebb9b04b2539614fa708b1a89feb5d380f8edda60d7391a612a3e72ff6d5c6ada0ade3f1c920c6c62724ba839cd254df
+  data.tar.gz: b4b99dacc64215beb48c5957decc907b45d1aba46a0f0faac1a4734502dbba4d51bb013bc0be8359247c50aa4c9581d585713f82457e81ae33cafa761b6c1841

data/README.md

@@ -39,15 +39,21 @@ file will be created in `config/rails_spotlight.yml`
   MIDDLEWARE_SKIPPED_PATHS: []
   NOT_ENCODABLE_EVENT_VALUES:
   SKIP_RENDERED_IVARS: []
+  BLOCK_EDITING_FILES: false
+  BLOCK_EDITING_FILES_OUTSIDE_OF_THE_PROJECT: true
+  DIRECTORY_INDEX_IGNORE: ['/.git', '**/*.lock', '**/.DS_Store', '/app/assets/images/**', '/app/assets/fonts/**', '/app/assets/builds/**']
+  RUBOCOP_CONFIG_PATH: '.rubocop.yml'
   # Rest of the configuration is required for ActionCable. It will be disabled automatically in when ActionCable is not available.
-  # LIVE_CONSOLE_ENABLED from version 0.2.3 do not require ActionCable to be enabled.
+  AUTO_MOUNT_ACTION_CABLE: false
+  ACTION_CABLE_MOUNT_PATH: /cable
+  # Required for all action cable features
+  USE_ACTION_CABLE: false
   LIVE_CONSOLE_ENABLED: false
   # Experimental feature.
   REQUEST_COMPLETED_BROADCAST_ENABLED: false
-  AUTO_MOUNT_ACTION_CABLE: false
-  ACTION_CABLE_MOUNT_PATH: /cable
-  BLOCK_EDITING_FILES: false
-  BLOCK_EDITING_FILES_OUTSIDE_OF_THE_PROJECT: true
+  LIVE_LOGS_ENABLED: false
+  DEFAULT_RS_SRC: default
+  FORM_JS_EXECUTION_TOKEN: <%= Digest::MD5.hexdigest(Rails.application.class.respond_to?(:module_parent_name) ? Rails.application.class.module_parent_name : Rails.application.class.parent_name)%>
 ```
 
 ## Additional metrics
@@ -60,6 +66,55 @@ To enable additional rendering metrics like local variables, instance variables,
 <% end %>
 ```
 
+## Experimental features
+Live logs requires action cable to be enabled. 
+
+USE_ACTION_CABLE: true
+LIVE_LOGS_ENABLED: true
+
+When you want to use different sources for the cable logs you need to update `cable.yml` file. 
+
+```yaml
+development:
+  adapter: redis
+  url: redis://localhost:6379/1
+```
+**Note:** Redis is required for live logs. so just add it to your Gemfile and run `bundle install`
+
+modify yor `development.rb` file 
+
+```ruby
+config.action_cable.allowed_request_origins = ['chrome-extension://chjfnpmbgdbipfogflkhleaceacndaop' ]
+aeblfdkhhhdcdjpifhhbdiojplfjncoa
+chjfnpmbgdbipfogflkhleaceacndaop
+```
+
+Now just run your servers with environment variable RS_SRC=my_source_name
+like `RS_SRC=sidekiq bundle exec sidekiq -C config/sidekiq.yml`
+or `RS_SRC=web bundle exec puma -C config/puma.rb`
+
+---
+
+Forms (Filling forms with scenarios)
+
+To be able use full potential of the forms you need to generate partial that helps with js code injection.
+
+Just use `rails rails_spotlight:inject_js_partial` and inject partial to your layout file as instructed in past generation message.
+setup your `FORM_JS_EXECUTION_TOKEN` or use pregnerated one in your extension settings.
+
+# Advanced log configuration 
+You can add to your Initializers `config/initializers/rails_spotlight.rb` file with the additional configuration for the logger.
+
+```ruby
+  unless Rails.env.production?
+    # Publish logs to the spotlight (only when implementation is based on the Rails.logger)
+    defined?(Logger) && Logger&.extend(RailsSpotlight::LogInterceptor)
+    # Publish Hutch logs to the spotlight
+    defined?(Hutch::Logging) && Hutch::Logging.logger&.extend(RailsSpotlight::LogInterceptor)
+  end
+```
+
+
 ## Troubleshooting
 
 Known issue:

data/lib/rails_spotlight/app_notifications.rb

@@ -87,7 +87,9 @@ module RailsSpotlight
       # send_file.action_controller: Triggered when a file is sent as a response.
       # redirect_to.action_controller: Triggered when a redirect response is sent.
       # halted_callback.action_controller: Triggered when a filter or callback halts the request.
-      # render_collection.action_view: This event is triggered when a collection is rendered using a partial. It includes details about the collection being rendered, such as the collection name and the partial being used to render each item.
+      # render_collection.action_view: This event is triggered when a collection is rendered using a partial.
+      #                                It includes details about the collection being rendered,
+      #                                such as the collection name and the partial being used to render each item.
     end
 
     def subscribe(event_name)

data/lib/rails_spotlight/channels/handlers/live_console_handler.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative '../../rails_command_executor'
+
+module RailsSpotlight
+  module Channels
+    module Handlers
+      class LiveConsoleHandler
+        TYPE = 'console'
+
+        def initialize(data)
+          @data = data
+        end
+
+        attr_reader :data
+
+        def call
+          return unless ::RailsSpotlight.config.live_console_enabled?
+          return unless data['type'] == TYPE
+
+          command = data['command']
+          inspect_types = data['inspect_types']
+          for_project = Array(data['project'])
+
+          raise_project_mismatch_error!(for_project) if for_project.present? && !for_project.include?(project)
+
+          execute_command(command, inspect_types)
+        end
+
+        def executor
+          @executor ||= ::RailsSpotlight::RailsCommandExecutor.new
+        end
+
+        def raise_project_mismatch_error!(for_project)
+          raise ::RailsSpotlight::Channels::Handlers::ResponseError.new(
+            "Project mismatch, The command was intended for the #{for_project} project. This is #{project} project",
+            code: :project_mismatch
+          )
+        end
+
+        def execute_command(command, inspect_types)
+          RailsSpotlight.config.logger && RailsSpotlight.config.logger.info("Executing command: #{command}") # rubocop:disable Style/SafeNavigation
+
+          executor.execute(command)
+          if executor.execution_successful?
+            {
+              payload: { result: executor.result_as_json(inspect_types: inspect_types) },
+            }
+          else
+            {
+              payload: { failed: executor.result_as_json }
+            }
+          end
+        rescue => e # rubocop:disable Style/RescueStandardError
+          { error: e.message }
+        end
+
+        def project
+          ::RailsSpotlight.config.project_name
+        end
+      end
+    end
+  end
+end

data/lib/rails_spotlight/channels/handlers/logs_handler.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RailsSpotlight
+  module Channels
+    module Handlers
+      class LogsHandler
+        TYPE = 'logs'
+
+        def initialize(data)
+          @data = data
+        end
+
+        attr_reader :data
+
+        def call
+          return unless ::RailsSpotlight.config.live_console_enabled?
+          return unless data['type'] == TYPE
+
+          for_project = Array(data['project'])
+          raise_project_mismatch_error!(for_project) if for_project.present? && !for_project.include?(project)
+
+          { payload: data[:payload] }
+        end
+
+        def raise_project_mismatch_error!(for_project)
+          raise ::RailsSpotlight::Channels::Handlers::ResponseError.new(
+            "Project mismatch, Logs from #{for_project} project cannot be forwarded in #{project} project",
+            code: :project_mismatch
+          )
+        end
+
+        def project
+          ::RailsSpotlight.config.project_name
+        end
+      end
+    end
+  end
+end

data/lib/rails_spotlight/channels/handlers.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'handlers/live_console_handler'
+require_relative 'handlers/logs_handler'
+
+module RailsSpotlight
+  module Channels
+    module Handlers
+      ResponseError = Class.new(StandardError) do
+        def initialize(message, code: :error)
+          @code = code
+          super(message)
+        end
+
+        attr_reader :code
+      end
+      TYPES = [LiveConsoleHandler::TYPE, LogsHandler::TYPE].freeze
+
+      def self.handle(data)
+        case data['type']
+        when LiveConsoleHandler::TYPE then LiveConsoleHandler.new(data).call
+        # when LogsHandler::TYPE then LogsHandler.new(data).call
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rails_spotlight/channels/silence_action_cable_broadcaster_logging.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RailsSpotlight
+  module Channels
+    module SilenceActionCableBroadcasterLogging
+      refine ActionCable::Server::Broadcasting::Broadcaster do
+        def broadcast(message)
+          if broadcasting == RailsSpotlight::Channels::SpotlightChannel::SPOTLIGHT_CHANNEL
+            original_logger = server.logger
+            begin
+              # Replace the logger with a no-op logger to silence the log
+              server.logger = ActiveSupport::Logger.new(nil)
+              super(message)
+            ensure
+              # Restore the original logger after broadcasting
+              server.logger = original_logger
+            end
+          else
+            super(message)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/rails_spotlight/channels/spotlight_channel.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative 'handlers'
+# require_relative 'silence_action_cable_broadcaster_logging'
+
+module RailsSpotlight
+  module Channels
+    class SpotlightChannel < ActionCable::Channel::Base
+      def self.broadcast(attrs = {})
+        broadcasting = ::RailsSpotlight::Channels::SPOTLIGHT_CHANNEL
+        message = {
+          type: attrs[:type],
+          code: attrs[:code] || 'ok',
+          project: ::RailsSpotlight.config.project_name,
+          version: ::RailsSpotlight::VERSION,
+          payload: attrs[:payload] || {}
+        }
+        coder = ::ActiveSupport::JSON
+        encoded = coder ? coder.encode(message) : message
+        ActionCable.server.pubsub.broadcast(broadcasting, encoded)
+        # We do not use the following code because it is triggering logs and can cause an infinite loop
+        # ActionCable.server.broadcast(
+        #   ::RailsSpotlight::Channels::SPOTLIGHT_CHANNEL,
+        #   {
+        #     type: attrs[:type],
+        #     code: attrs[:code] || 'ok',
+        #     project: ::RailsSpotlight.config.project_name,
+        #     version: ::RailsSpotlight::VERSION,
+        #     payload: attrs[:payload] || {}
+        #   }
+        # )
+      rescue StandardError => e
+        RailsSpotlight.config.logger.fatal("#{e.message}\n #{e.backtrace.join("\n ")}")
+      end
+
+      def subscribed
+        stream_from ::RailsSpotlight::Channels::SPOTLIGHT_CHANNEL
+        publish({ message: "Your #{project} project is now connected to the spotlight channel.", code: :connected, type: :info })
+      end
+
+      def unsubscribed
+        # Any cleanup needed when channel is unsubscribed
+      end
+
+      def receive(data)
+        return publish({ message: 'Unknown type of request', code: :unknown_type, type: :error }) unless Handlers::TYPES.include?(data['type'])
+
+        result = Handlers.handle(data)
+        publish({ payload: result[:payload], code: result[:code] || :ok, type: data['type'] }) if result[:payload]
+      rescue ::RailsSpotlight::Channels::Handlers::ResponseError => e
+        publish({ message: e.message, code: e.code, type: :error })
+      end
+
+      private
+
+      def publish(data)
+        connection.transmit identifier: @identifier, message: data.merge(project: project, version: version)
+        # we do not use transmit because it is triggering logs and can cause an infinite loop
+        # transmit(data.merge(project: project, version: version))
+      end
+
+      def project
+        ::RailsSpotlight.config.project_name
+      end
+
+      def version
+        ::RailsSpotlight::VERSION
+      end
+    end
+  end
+end

data/lib/rails_spotlight/channels.rb

@@ -2,7 +2,7 @@
 
 module RailsSpotlight
   module Channels
-    autoload(:LiveConsoleChannel, 'rails_spotlight/channels/live_console_channel') if defined?(ActionCable)
-    autoload(:RequestCompletedChannel, 'rails_spotlight/channels/request_completed_channel') if defined?(ActionCable)
+    SPOTLIGHT_CHANNEL = 'RailsSpotlight::Channels::SpotlightChannel'.freeze
+    autoload(:SpotlightChannel, 'rails_spotlight/channels/spotlight_channel') if defined?(ActionCable)
   end
 end

data/lib/rails_spotlight/configuration.rb

@@ -10,6 +10,10 @@ module RailsSpotlight
       'ActionDispatch' => ['ActionDispatch::Request', 'ActionDispatch::Response']
     }.freeze
 
+    DEFAULT_DIRECTORY_INDEX_IGNORE = %w[
+      /.git **/*.lock **/.DS_Store /app/assets/images/** /app/assets/fonts/** /app/assets/builds/** **/.keep
+    ].freeze
+
     SKIP_RENDERED_IVARS = %i[
       @_routes
       @_config
@@ -32,7 +36,9 @@ module RailsSpotlight
 
     attr_reader :project_name, :source_path, :logger, :storage_path, :storage_pool_size, :middleware_skipped_paths,
                 :not_encodable_event_values, :action_cable_mount_path,
-                :block_editing_files, :block_editing_files_outside_of_the_project, :skip_rendered_ivars
+                :block_editing_files, :block_editing_files_outside_of_the_project, :skip_rendered_ivars,
+                :directory_index_ignore, :rubocop_config_path, :use_action_cable, :default_rs_src,
+                :form_js_execution_token
 
     def initialize(opts = {}) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/AbcSize
       @project_name = opts[:project_name] || detect_project_name
@@ -44,27 +50,38 @@ module RailsSpotlight
       @request_completed_broadcast_enabled = opts[:request_completed_broadcast_enabled].nil? ? false : true?(opts[:request_completed_broadcast_enabled])
       @middleware_skipped_paths = opts[:middleware_skipped_paths] || []
       @not_encodable_event_values = DEFAULT_NOT_ENCODABLE_EVENT_VALUES.merge(opts[:not_encodable_event_values] || {})
+      @use_action_cable = opts[:use_action_cable].nil? ? false : true?(opts[:use_action_cable])
       @auto_mount_action_cable = opts[:auto_mount_action_cable].nil? ? false : true?(opts[:auto_mount_action_cable])
       @action_cable_mount_path = opts[:action_cable_mount_path] || '/cable'
       @block_editing_files = opts[:block_editing_files].nil? ? false : true?(opts[:block_editing_files])
       @block_editing_files_outside_of_the_project = opts[:block_editing_files_outside_of_the_project].nil? ? true : true?(opts[:block_editing_files_outside_of_the_project])
       @skip_rendered_ivars = SKIP_RENDERED_IVARS + (opts[:skip_rendered_ivars] || []).map(&:to_sym)
+      @directory_index_ignore = opts[:directory_index_ignore] || DEFAULT_DIRECTORY_INDEX_IGNORE
+      @rubocop_config_path = opts[:rubocop_config_path] ? File.join(self.class.rails_root, opts[:rubocop_config_path]) : nil
+      @live_logs_enabled = opts[:live_logs_enabled].nil? ? false : true?(opts[:live_logs_enabled])
+      @default_rs_src = opts[:default_rs_src] || 'default'
+      @form_js_execution_token = opts[:form_js_execution_token] || Digest::MD5.hexdigest(detect_project_name)
     end
 
     def live_console_enabled
-      @live_console_enabled && action_cable_present?
+      @live_console_enabled && use_action_cable && action_cable_present?
+    end
+
+    def live_logs_enabled
+      @live_logs_enabled && use_action_cable && action_cable_present?
     end
 
     alias live_console_enabled? live_console_enabled
+    alias live_logs_enabled? live_logs_enabled
 
     def request_completed_broadcast_enabled
-      @request_completed_broadcast_enabled && action_cable_present?
+      @request_completed_broadcast_enabled && use_action_cable && action_cable_present?
     end
 
     alias request_completed_broadcast_enabled? request_completed_broadcast_enabled
 
     def auto_mount_action_cable
-      @auto_mount_action_cable && action_cable_present?
+      @auto_mount_action_cable && use_action_cable && action_cable_present?
     end
 
     alias auto_mount_action_cable? auto_mount_action_cable

data/lib/rails_spotlight/event.rb

@@ -57,8 +57,9 @@ module RailsSpotlight
     def not_encodable?(value)
       ::RailsSpotlight.config.not_encodable_event_values.any? do |module_name, class_names|
         next unless defined?(module_name.constantize)
-
         class_names.any? { |class_name| value.is_a?(class_name.constantize) }
+      rescue => e
+        puts "Error in not_encodable? method: #{e.message}"
       end
     end
 

data/lib/rails_spotlight/log_interceptor.rb

@@ -1,45 +1,53 @@
 # frozen_string_literal: true
 
+require_relative 'channels'
+
 module RailsSpotlight
   module LogInterceptor
-    def debug(message = nil, *args)
-      push_event(:debug, message)
-      super
-    end
+    SEVERITY = %w[debug info warn error fatal unknown].freeze
+    SEVERITY_MAP = { 0 => 'debug', 1 => 'info', 2 => 'warn', 3 => 'error', 4 => 'fatal', 5 => 'unknown' }.freeze
+
+    def add(severity, message = nil, progname = nil)
+      severity ||= 5
+      return true if @logdev.nil? || severity < level
+
+      progname = @progname if progname.nil?
+
+      if message.nil?
+        if block_given?
+          message = yield
+        else
+          message = progname
+          progname = @progname
+        end
+      end
+      return true if _skip_logging?(message)
 
-    def info(message = nil, *args)
-      push_event(:info, message)
-      super
+      _push_event(SEVERITY_MAP[severity], message, progname)
+      super(severity, message, progname) if defined?(super)
+      true
     end
 
-    def warn(message = nil, *args)
-      push_event(:warn, message)
-      super
-    end
+    private
 
-    def error(message = nil, *args)
-      push_event(:error, message)
-      super
-    end
+    def _skip_logging?(message)
+      return false unless ::RailsSpotlight.config.live_console_enabled?
+      return false unless message.is_a?(String)
 
-    def fatal(message = nil, *args)
-      push_event(:fatal, message)
-      super
+      message.include?(::RailsSpotlight::Channels::SPOTLIGHT_CHANNEL)
     end
 
-    def unknown(message = nil, *args)
-      push_event(:unknown, message)
-      super
-    end
+    def _push_event(level, message, progname = nil)
+      callsite = Utils.dev_callsite(caller.drop(1))
+      name = progname.is_a?(String) || progname.is_a?(Symbol) ? progname : nil
+      AppRequest.current.events << Event.new('rsl.notification.log', 0, 0, 0, callsite.merge(message: message, level: level, progname: name)) if AppRequest.current && callsite
 
-    private
+      return unless ::RailsSpotlight.config.live_console_enabled?
+      return if message.blank?
 
-    def push_event(level, message)
-      callsite = AppRequest.current && Utils.dev_callsite(caller.drop(1))
-      if callsite
-        payload = callsite.merge(message: message, level: level)
-        AppRequest.current.events << Event.new('rsl.notification.log', 0, 0, 0, payload)
-      end
+      id = AppRequest.current ? AppRequest.current.id : nil
+      payload = (callsite || {}).merge(msg: message, src: ENV['RS_SRC'] || ::RailsSpotlight.config.default_rs_src, l: level, dt: Time.now.to_f, id: id,  pg: name)
+      ::RailsSpotlight::Channels::SpotlightChannel.broadcast(type: 'logs', payload: payload)
     rescue StandardError => e
       RailsSpotlight.config.logger.fatal("#{e.message}\n #{e.backtrace.join("\n ")}")
     end

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

@@ -7,6 +7,7 @@ module RailsSpotlight
         IncorrectResponseContentType = Class.new(StandardError)
         NotFound = Class.new(StandardError)
         UnprocessableEntity = Class.new(StandardError)
+        Forbidden = Class.new(StandardError)
 
         def initialize(request_id, request, content_type)
           @request_id = request_id
@@ -17,12 +18,15 @@ module RailsSpotlight
         attr_reader :request_id, :request, :content_type
 
         def call
+          validate_project! unless skip_project_validation?
           execute
           response
         rescue NotFound => e
           not_found_response(e.message)
         rescue UnprocessableEntity => e
           unprocessed_response(e.message)
+        rescue Forbidden => e
+          forbidden_response(e.message)
         rescue => e # rubocop:disable Style/RescueStandardError
           internal_server_error_response(e.message)
         end
@@ -31,6 +35,10 @@ module RailsSpotlight
 
         attr_writer :status, :headers
 
+        def skip_project_validation?
+          false
+        end
+
         def headers
           @headers ||= {}
         end
@@ -57,6 +65,10 @@ module RailsSpotlight
           raise 'Invalid JSON'
         end
 
+        def body_fetch(*args)
+          json_request_body.fetch(*args)
+        end
+
         def internal_server_error_response(message)
           response(500, message_to_body(message))
         end
@@ -65,6 +77,10 @@ module RailsSpotlight
           response(422, message_to_body(message))
         end
 
+        def forbidden_response(message)
+          response(403, message_to_body(message))
+        end
+
         def not_found_response(message)
           response(404, message_to_body(message))
         end
@@ -76,7 +92,8 @@ module RailsSpotlight
         def response_headers(headers = {})
           {
             'Content-Type' => content_type == :json ? 'application/json; charset=utf-8' : 'text/plain; charset=utf-8',
-            'X-Rails-Spotlight' => '1.0.0',
+            'X-Rails-Spotlight' => ::RailsSpotlight::VERSION,
+            'X-Rails-Spotlight-Project' => ::RailsSpotlight.config.project_name,
             'X-Request-Id' => request_id
           }.merge(headers)
         end
@@ -85,10 +102,25 @@ module RailsSpotlight
           body = if overridden_body.present?
                    content_type == :json ? overridden_body.to_json : overridden_body
                  else
-                   content_type == :json ? json_response_body.to_json : text_response_body
+                   content_type == :json ? json_response_body.merge({ project: ::RailsSpotlight.config.project_name }).to_json : text_response_body
                  end
           [overridden_status.present? ? overridden_status : status, response_headers(headers), [body]]
         end
+
+        def request_spotlight_version
+          @request_spotlight_version ||= request.get_header('HTTP_X_RAILS_SPOTLIGHT')
+        end
+
+        def request_for_projects
+          @request_for_projects ||= (request.get_header('HTTP_X_FOR_PROJECTS') || '').split(',').map(&:strip)
+        end
+
+        def validate_project!
+          return if request_for_projects.blank?
+          return if request_for_projects.include?(::RailsSpotlight.config.project_name)
+
+          raise Forbidden, "Check your settings the current request is not allowed to be executed on the #{::RailsSpotlight.config.project_name} project"
+        end
       end
     end
   end