rails_spotlight 0.1.7 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 507c2c676db5d30d6af1ec0f505e067f16c53514dfd875cd4554041304d95b87
-  data.tar.gz: 8c990b6ec150e2a6c9e7b8e0c581d5b1e74987e5502907e847218a78d6324103
+  metadata.gz: 41eb3756c5f0405d7811d039c0953ac3a62b993486a4fc2e2085686c8c9cd54b
+  data.tar.gz: fd0d5d64ff53a660ade6867f05c152e36cd228ccb02b1d9006c3e4be8ed8e6cd
 SHA512:
-  metadata.gz: c36b1e95facd5d437c4685a7ba66a02e45eaf152d8e4fc607468fffef5fad8d7fb9c15ed1b760feaa1501b1b2c8a27bd61166917083da90ccb5cf64529530a6c
-  data.tar.gz: d1439a47bedd079561dcecb4a8f1f8cde964eea6555da2dc0e16e330bac2b89abc9e0f90a2a499bf50c1939e1b1e64a0622209a14affa1d951abb76ad4c9732a
+  metadata.gz: d3159584ad8395c2ea3a17fb969cd9a50c94a120c0db950ff11db8d52ce3357f443c7944a23dc8dc3521844f98e6cdc30da288f53a08e6308f8722c53a85907b
+  data.tar.gz: 2057d0386f21959a19b229ca2f3b4e46db2a0270d1c8f1262f551363eeda54c7127bc3b78c1c209b6e949a62dc2ce1c82989b17650eaa7c6dc02bb99874f3389

data/.rubocop.yml

@@ -10,6 +10,7 @@ AllCops:
     - "exe/**/*"
     - "tmp/**/*"
     - "extensions/**/*"
+    - "spec/**/*"
 
 Style/StringLiterals:
   Enabled: true

data/Guardfile

@@ -4,6 +4,7 @@ guard :rspec, cmd: 'rspec' do
   watch(%r{^lib/(.+).rb$})      { |m| "spec/lib/#{m[1]}_spec.rb" }
   watch(%r{^spec/(.+).rb$})     { |m| "spec/#{m[1]}.rb" }
   watch('spec/spec_helper.rb')  { 'spec' }
+  watch('spec/rails_helper.rb') { 'spec' }
   watch('Gemfile')
 end
 

data/README.md

@@ -19,12 +19,44 @@ end
 
 ## Configuration
 
-environment variables
+Generate configuration file by running:
 
+```bash
+rails rails_spotlight:generate_config 
 ```
-RAILS_SPOTLIGHT_PROJECT=MyProjectName
+
+file will be created in `config/rails_spotlight.yml`
+
+### Configuration options
+
+```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
 ```
 
+## Troubleshooting
+
+Known issue:
+
+Authentication error when using: 
+  - Specific authentication method and action cable
+  - AUTO_MOUNT_ACTION_CABLE: true
+
+Solution:
+  - Set AUTO_MOUNT_ACTION_CABLE: false
+  - Add manually `mount ActionCable.server => '/cable'` to `config/routes.rb` with proper authentication method
+
 ## Testing
 
 To run tests for all versions of Rails and Ruby, run:
@@ -35,19 +67,9 @@ docker-compose up
 
 ## Usage
 
-## Development
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/pniemczyk/rails_spotlight. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/rails_spotlight/blob/master/CODE_OF_CONDUCT.md).
+Gem is created for the Chrome extension [Rails Spotlight](https://chrome.google.com/webstore/detail/rails-spotlight/kfacifkandemkdemkliponofajohhnbp?hl=en-US), but it can be used for any purpose.
 
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
-## Code of Conduct
-
-Everyone interacting in the RailsSpotlight project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/pniemczyk/rails_spotlight/blob/master/CODE_OF_CONDUCT.md).
-
-
-check https://github.com/alexrudall/ruby-openai

data/chrome_ext_private_policy.md

@@ -0,0 +1,39 @@
+## Privacy Policy for the Rails Spotlight Chrome Extension
+
+**Last Updated:** October 18, 2023
+
+### 1. Introduction
+
+Thank you for choosing Rails Spotlight Chrome Extension. We value your privacy and strive to protect your personal information. This Privacy Policy outlines how we collect, use, and share your data.
+
+### 2. Data Collection
+
+We collect data strictly for the purpose of subscription and payment processing. No unnecessary information is harvested.
+
+### 3. Use of Data
+
+Your data will be used for:
+- Processing your subscription.
+- Facilitating payments.
+- Conducting anonymous analytics to improve our services.
+- If you give your consent, for sending newsletters and promotional materials.
+
+### 4. Consent
+
+By using Rails Spotlight, you agree to the collection and use of information in accordance with this policy. Should we decide to use your information for newsletter or promotional purposes, we will seek your explicit consent.
+
+### 5. Data Sharing
+
+We do not sell or share your data with third parties for their promotional purposes. Data may only be shared with third parties that facilitate our service provision, such as payment processors.
+
+### 6. Data Security
+
+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
+
+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
+
+If you have any questions or suggestions about our Privacy Policy, do not hesitate to contact us.

data/docker-compose.yml

@@ -5,10 +5,6 @@ services:
      - 'docker-variables.env'
     build: .
     command: bundle exec rubocop
-  spec-unit:
-    env_file:
-     - 'docker-variables.env'
-    build: .
   spec-rails-5.2:
     env_file:
      - 'docker-variables.env'

data/fake_spec_res/rails_spotlight_spec.rb

@@ -21,7 +21,7 @@ RSpec.describe DummyController, type: :request do # rubocop:disable Metrics/Bloc
       post '/__rails_spotlight/file.json', params: { file: file, mode: :write, content: content }.to_json
 
       expect(response).to be_successful
-      expect(response.body).to eq({ source: content }.to_json)
+      expect(response.body).to eq({ source: content, changed: true, project: 'App', new_content: 'TEST' }.to_json)
       expect(File.read(Rails.root.join(file))).to eq content
     end
 
@@ -33,14 +33,14 @@ RSpec.describe DummyController, type: :request do # rubocop:disable Metrics/Bloc
     it 'serve a sql result' do
       post '/__rails_spotlight/sql.json', params: { query: 'select sqlite_version();' }.to_json
       expect(response).to be_successful
-      expect(JSON.parse(response.body).keys).to eq(%w[result logs])
+      expect(JSON.parse(response.body).keys).to eq(%w[query result logs error query_mode project])
     end
   end
 
-  context 'meta_request specs' do
+  context 'meta request specs' do
     before do
       # clean up meta_request files
-      FileUtils.rm_rf(Rails.root.join('tmp', 'data', 'meta_request'))
+      FileUtils.rm_rf(Rails.root.join('tmp', 'data', 'rails_spotlight'))
       get '/'
       @request_id = response.headers['X-Request-Id']
     end
@@ -52,15 +52,15 @@ RSpec.describe DummyController, type: :request do # rubocop:disable Metrics/Bloc
     end
 
     it 'should have a meta_request version header' do
-      expect(response.headers['X-Meta-Request-Version']).to eq(MetaRequest::VERSION)
+      expect(response.headers['X-Rails-Spotlight-Version']).to eq(RailsSpotlight::VERSION)
     end
 
     it 'should create a request file' do
-      expect(Dir[Rails.root.join('tmp/data/meta_request/*.json')].size).to eq(1)
+      expect(Dir[Rails.root.join('tmp/data/rails_spotlight/*.json')].size).to eq(1)
     end
 
-    it 'should serve a meta_request' do
-      get "/__meta_request/#{request_id}.json"
+    it 'should serve a meta request' do
+      get "/__rails_spotlight/meta.json?id=#{request_id}"
       expect(response).to be_successful
     end
   end

data/lib/rails_spotlight/app_notifications.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RailsSpotlight
+  class AppNotifications
+    # these are the specific keys in the cache payload that we display in the
+    # panel view
+    CACHE_KEY_COLUMNS = %i[key hit options type].freeze
+
+    # define this here so we can pass it in to all of our cache subscribe calls
+    CACHE_BLOCK = proc { |*args|
+      name, start, ending, transaction_id, payload = args
+
+      # from http://edgeguides.rubyonrails.org/active_support_instrumentation.html#cache-fetch-hit-active-support
+      #
+      # :super_operation  :fetch is added when a read is used with #fetch
+      #
+      # so if :super_operation is present, we'll use it for the type. otherwise
+      # strip (say) 'cache_delete.active_support' down to 'delete'
+      payload[:type] = payload.delete(:super_operation) || name.sub(/cache_(.*?)\..*$/, '\1')
+
+      # anything that isn't in CACHE_KEY_COLUMNS gets shoved into :options
+      # instead
+      payload[:options] = {}
+      payload.each_key do |k|
+        payload[:options][k] = payload.delete(k) unless k.in? CACHE_KEY_COLUMNS
+      end
+
+      callsite = ::RailsSpotlight::Utils.dev_callsite(caller)
+      payload.merge!(callsite) if callsite
+
+      Event.new(name, start, ending, transaction_id, payload)
+    }
+
+    # sql processing block - used for sql.active_record and sql.sequel
+
+    # HACK: we hardcode the event name to 'sql.active_record' so that the ui will
+    # display sequel events without modification. otherwise the ui would need to
+    # be modified to support a sequel tab (or to change the display name on the
+    # active_record tab when necessary - which maybe makes more sense?)
+    SQL_EVENT_NAME = 'sql.active_record'
+
+    SQL_BLOCK = proc { |*args|
+      _name, start, ending, transaction_id, payload = args
+      callsite = ::RailsSpotlight::Utils.dev_callsite(caller)
+      payload.merge!(callsite) if callsite
+
+      Event.new(SQL_EVENT_NAME, start, ending, transaction_id, payload)
+    }
+
+    VIEW_BLOCK = proc { |*args|
+      name, start, ending, transaction_id, payload = args
+      payload[:identifier] = ::RailsSpotlight::Utils.sub_source_path(payload[:identifier])
+
+      Event.new(name, start, ending, transaction_id, payload)
+    }
+
+    # Subscribe to all events relevant to RailsPanel
+    #
+    def self.subscribe
+      new
+        .subscribe('rsl.notification.log')
+        .subscribe('sql.active_record', &SQL_BLOCK)
+        .subscribe('sql.sequel', &SQL_BLOCK)
+        .subscribe('render_partial.action_view', &VIEW_BLOCK)
+        .subscribe('render_template.action_view', &VIEW_BLOCK)
+        .subscribe('process_action.action_controller.exception')
+        .subscribe('process_action.action_controller') do |*args|
+          name, start, ending, transaction_id, payload = args
+          payload[:status] = '500' if payload[:exception]
+          Event.new(name, start, ending, transaction_id, payload)
+        end
+        .subscribe('cache_read.active_support', &CACHE_BLOCK)
+        .subscribe('cache_generate.active_support', &CACHE_BLOCK)
+        .subscribe('cache_fetch_hit.active_support', &CACHE_BLOCK)
+        .subscribe('cache_write.active_support', &CACHE_BLOCK)
+        .subscribe('cache_delete.active_support', &CACHE_BLOCK)
+        .subscribe('cache_exist?.active_support', &CACHE_BLOCK)
+    end
+
+    def subscribe(event_name)
+      ActiveSupport::Notifications.subscribe(event_name) do |*args|
+        event = block_given? ? yield(*args) : Event.new(*args)
+        AppRequest.current.events << event if AppRequest.current
+      end
+      self
+    end
+  end
+end

data/lib/rails_spotlight/app_request.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RailsSpotlight
+  class AppRequest
+    attr_reader :id, :events
+
+    def initialize(id)
+      @id = id
+      @events = []
+    end
+
+    def self.current
+      Thread.current[:rails_spotlight_request_id]
+    end
+
+    def current!
+      Thread.current[:rails_spotlight_request_id] = self
+    end
+  end
+end

data/lib/rails_spotlight/channels/live_console_channel.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RailsSpotlight
+  module Channels
+    class LiveConsoleChannel < ActionCable::Channel::Base
+      def subscribed
+        stream_from 'rails_spotlight_live_console_channel'
+        publish({ message: "Welcome to the #{project} project Rails Spotlight Live Console" })
+      end
+
+      def unsubscribed
+        # Any cleanup needed when channel is unsubscribed
+      end
+
+      def receive(data)
+        command = data['command']
+        inspect_types = data['inspect_types']
+        for_project = data['project']
+        return publish({ error: project_mismatch_message(for_project) }) if for_project.present? && for_project != project
+
+        output = execute_command(command, { inspect_types: inspect_types })
+        publish(output)
+      end
+
+      private
+
+      def project_mismatch_message(for_project)
+        "Project mismatch, The command was intended for the #{for_project} project. This is #{project} project"
+      end
+
+      def publish(data)
+        transmit(data.merge(project: project))
+      end
+
+      # TODO: add possibility to change project name via ENV variable or RailsSpotlight config
+      def project
+        ::RailsSpotlight.config.project_name
+      end
+
+      def execute_command(command, opts = {})
+        output_stream = StringIO.new # Create a new StringIO object to capture output
+        inspect_types = opts[:inspect_types]
+        result = nil
+
+        begin
+          original_stdout = $stdout
+          $stdout = output_stream
+          result = eval(command) # rubocop:disable Security/Eval
+        ensure
+          $stdout = original_stdout
+        end
+
+        # result = eval(command)
+        {
+          result: {
+            inspect: result.inspect,
+            raw: result,
+            type: result.class.name,
+            types: result_inspect_types(inspect_types, result),
+            console: output_stream.string
+          }
+        }
+      rescue StandardError => e
+        { error: e.message }
+      end
+
+      def result_inspect_types(inspect_types, result)
+        return {} unless inspect_types
+
+        {
+          root: result.class.name,
+          items: result_types_items(result)
+        }
+      end
+
+      def result_types_items(result)
+        case result
+        when Array
+          # Create a hash with indices as keys and class names as values
+          result.each_with_index.to_h { |element, index| [index.to_s, element.class.name] }
+        when Hash
+          # Create a hash with string keys and class names as values
+          result.transform_keys(&:to_s).transform_values { |value| value.class.name }
+        else
+          # For non-collection types, there are no items
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/rails_spotlight/channels/request_completed_channel.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RailsSpotlight
+  module Channels
+    class RequestCompletedChannel < ActionCable::Channel::Base
+      def subscribed
+        stream_from 'rails_spotlight_request_completed_channel'
+      end
+
+      def unsubscribed
+        # Any cleanup needed when channel is unsubscribed
+      end
+    end
+  end
+end

data/lib/rails_spotlight/channels.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+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)
+  end
+end

data/lib/rails_spotlight/configuration.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'erb'
+
+module RailsSpotlight
+  class Configuration
+    DEFAULT_NOT_ENCODABLE_EVENT_VALUES = {
+      'ActiveRecord' => ['ActiveRecord::ConnectionAdapters::AbstractAdapter'],
+      'ActionDispatch' => ['ActionDispatch::Request', 'ActionDispatch::Response']
+    }.freeze
+
+    attr_reader :project_name, :source_path, :logger, :storage_path, :storage_pool_size, :middleware_skipped_paths,
+                :not_encodable_event_values, :action_cable_mount_path
+
+    def initialize(opts = {}) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      @project_name = opts[:project_name] || detect_project_name
+      @source_path = opts[:source_path] || self.class.rails_root
+      @logger = opts[:logger] || Logger.new(File.join(self.class.rails_root, 'log', 'rails_spotlight.log'))
+      @storage_path = opts[:storage_path] || File.join(self.class.rails_root, 'tmp', 'data', 'rails_spotlight')
+      @storage_pool_size = opts[:storage_pool_size] || 20
+      @live_console_enabled = opts[:live_console_enabled].nil? ? true : is_true?(opts[:live_console_enabled])
+      @request_completed_broadcast_enabled = is_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] || {})
+      @auto_mount_action_cable = opts[:auto_mount_action_cable].nil? ? true : is_true?(opts[:auto_mount_action_cable])
+      @action_cable_mount_path = opts[:action_cable_mount_path] || '/cable'
+    end
+
+    def live_console_enabled
+      @live_console_enabled && action_cable_present?
+    end
+
+    alias live_console_enabled? live_console_enabled
+
+    def request_completed_broadcast_enabled
+      @request_completed_broadcast_enabled && 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?
+    end
+
+    alias auto_mount_action_cable? auto_mount_action_cable
+
+    def action_cable_present?
+      defined?(ActionCable) && true
+    end
+
+    def self.load_config
+      config_file = File.join(rails_root, 'config', 'rails_spotlight.yml')
+      return new unless File.exist?(config_file)
+
+      erb_result = ERB.new(File.read(config_file)).result
+      data = YAML.safe_load(erb_result) || {}
+
+      # Support older versions of Ruby and Rails
+      opts = data.each_with_object({}) do |(key, value), memo|
+        new_key = key.is_a?(String) ? key.downcase.to_sym : key
+        memo[new_key] = value
+      end
+
+      new(opts)
+    end
+
+    def self.rails_root
+      @rails_root ||= (Rails.root.to_s.presence || Dir.pwd).freeze
+    end
+
+    def rails_root
+      self.class.rails_root
+    end
+
+    private
+
+    def is_true?(value)
+      value == true || value == 'true' || value == 1 || value == '1'
+    end
+
+    def detect_project_name
+      return ENV['RAILS_SPOTLIGHT_PROJECT'] if ENV['RAILS_SPOTLIGHT_PROJECT'].present?
+
+      if app_class.respond_to?(:module_parent_name)
+        app_class.module_parent_name
+      else
+        app_class.parent_name
+      end
+    end
+
+    def app_class
+      @app_class ||= Rails.application.class
+    end
+  end
+end

data/lib/rails_spotlight/event.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/json'
+require 'active_support/core_ext'
+
+module RailsSpotlight
+  # Subclass of ActiveSupport Event that is JSON encodable
+  #
+  class Event < ActiveSupport::Notifications::Event
+    NOT_JSON_ENCODABLE = 'Not JSON Encodable'
+
+    attr_reader :duration
+
+    def initialize(name, start, ending, transaction_id, payload)
+      super(name, start, ending, transaction_id, json_encodable(payload))
+      @duration = 1000.0 * (ending - start)
+    end
+
+    def self.events_for_exception(exception_wrapper)
+      if defined?(ActionDispatch::ExceptionWrapper)
+        exception = exception_wrapper.exception
+        trace = exception_wrapper.application_trace
+        trace = exception_wrapper.framework_trace if trace.empty?
+      else
+        exception = exception_wrapper
+        trace = exception.backtrace
+      end
+      trace.unshift "#{exception.class} (#{exception.message})"
+      trace.map do |call|
+        Event.new('process_action.action_controller.exception', 0, 0, nil, call: call)
+      end
+    end
+
+    private
+
+    def json_encodable(payload)
+      return {} unless payload.is_a?(Hash)
+
+      transform_hash(payload, deep: true) do |hash, key, value|
+        if value.class.to_s == 'ActionDispatch::Http::Headers'
+          value = value.to_h.select { |k, _| k.upcase == k }
+        elsif not_encodable?(value)
+          value = NOT_JSON_ENCODABLE
+        end
+
+        begin
+          value.to_json(methods: [:duration])
+          new_value = value
+        rescue StandardError
+          new_value = NOT_JSON_ENCODABLE
+        end
+        hash[key] = new_value
+      end.with_indifferent_access
+    end
+
+    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) }
+      end
+    end
+
+    def transform_hash(original, options = {}, &block)
+      options[:safe_descent] ||= {}.compare_by_identity
+
+      # Check if the hash has already been transformed to prevent infinite recursion.
+      return options[:safe_descent][original] if options[:safe_descent].key?(original)
+
+      # Create a new hash to store the transformed values.
+      new_hash = {}
+      # Store the new hash in safe_descent using the original's object_id to mark it as processed.
+      options[:safe_descent][original] = new_hash
+
+      # Iterate over each key-value pair in the original hash.
+      original.each do |key, value|
+        # If deep transformation is required and the value is a hash,
+        # recursively transform it, unless it's already been transformed.
+        if options[:deep] && Hash === value # rubocop:disable Style/CaseEquality
+          value = options[:safe_descent].fetch(value) do
+            transform_hash(value, options, &block)
+          end
+        end
+        # Apply the transformation block to the current key-value pair.
+        block.call(new_hash, key, value)
+      end
+
+      # Return the transformed hash.
+      new_hash
+    end
+  end
+end

data/lib/rails_spotlight/log_interceptor.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RailsSpotlight
+  module LogInterceptor
+    def debug(message = nil, *args)
+      push_event(:debug, message)
+      super
+    end
+
+    def info(message = nil, *args)
+      push_event(:info, message)
+      super
+    end
+
+    def warn(message = nil, *args)
+      push_event(:warn, message)
+      super
+    end
+
+    def error(message = nil, *args)
+      push_event(:error, message)
+      super
+    end
+
+    def fatal(message = nil, *args)
+      push_event(:fatal, message)
+      super
+    end
+
+    def unknown(message = nil, *args)
+      push_event(:unknown, message)
+      super
+    end
+
+    private
+
+    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
+    rescue StandardError => e
+      RailsSpotlight.config.logger.fatal("#{e.message}\n #{e.backtrace.join("\n ")}")
+    end
+  end
+end