rails_spotlight 0.2.5 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5e36512b12e263c5853279d061fe2760ad7fff28c754c3362f8c848867845477
-  data.tar.gz: cc4696e37e250be0413f0286503f8a63fa18a2c43353114720e9580fa4fc646e
+  metadata.gz: b9eca5a5464ed6e44b8c65f206f96ead18ff5cc73a0f9395b2b5cc863a28b270
+  data.tar.gz: 4bc0b0e190af921c926a1f08bb43954dee8b3aa488d867c885b4af84c3816ab7
 SHA512:
-  metadata.gz: dd8e249fcfe8ced528c2f60225b00e8142e93989736d77090b9cc3ad0a9cf8c50dcbc85b9f76f196168ab1e6946f85d594c48935fe0751e8675d612f2d3fffa1
-  data.tar.gz: 925e741a5c6b755deed002c3833da4487a24a530d025177373fa86fca3a5ad2ef84d1730497c7c2ad128a2c9bf526127166252793b056e587ed43ab6a585dbea
+  metadata.gz: 552d1619a7c990dbce5c52fa883a45bcb5d5d58fa3a81a947fd244badbffcab5516607bb739dc73803d90ababd44755d78b9efe159d6d7d785181cef9e390b59
+  data.tar.gz: 8173b1bfc3514712a350d08c8441552c8091c4b3559357192cde5de84470aee320dc26be1663ca07aa1fcbe7fb48573001d7d9bffce578886b3c5c75302633d3

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,53 @@ 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' ]
+```
+
+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/chrome_ext_private_policy.md

@@ -1,6 +1,6 @@
 ## Privacy Policy for the Rails Spotlight Chrome Extension
 
-**Last Updated:** October 18, 2023
+**Last Updated:** Aug 18, 2024
 
 ### 1. Introduction
 
@@ -30,10 +30,14 @@ We do not sell or share your data with third parties for their promotional purpo
 
 We are committed to ensuring that your information is secure. To prevent unauthorized access or disclosure, we have put in place suitable physical, electronic, and managerial procedures to safeguard and secure the information we collect.
 
-### 7. Changes to This Privacy Policy
+### 7. Subscription and Refund Policy
+
+By purchasing a membership for Rails Spotlight, you gain access to advanced features and contribute to the ongoing development of the tool. Please note that all memberships are non-refundable. Once purchased, no refunds will be issued, so we encourage you to carefully consider your decision before completing the purchase. However, you can cancel your subscription at any time if you no longer wish to use the service. Cancellation will prevent any future charges, but it will not refund the current or past payments.
+
+### 8. Changes to This Privacy Policy
 
 We may update our Privacy Policy from time to time. Thus, we advise you to review this document periodically for any changes. We will notify you of any changes by posting the new Privacy Policy in this location. Changes are effective immediately after they are posted.
 
-### 8. Contact Us
+### 9. Contact Us
 
 If you have any questions or suggestions about our Privacy Policy, do not hesitate to contact us.

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