rails_spotlight 0.5.1 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed7177dae7290c4108d3f82dbe6705449358e3b8805219b6780e93924547419e
-  data.tar.gz: e4c0c873e82299d1637e43ef0c844c4444150677b24881ab570e508023f154e2
+  metadata.gz: 1a1028b180c27405b30fc503ed2885835496d23cbbe20043b83ca5f1ec0c0363
+  data.tar.gz: b5eb35ba72c5fc178a3bff967bfc6424af3548899dbaa121642716e2c91a96db
 SHA512:
-  metadata.gz: 0d04a55bf3d180539e32f12dd183ee910e94a543ce81c416dd14b8d9d027ee271bbb099071c8c3b9e921303d14e3d4e4b026619e73ef44b17f762c4e045b54a4
-  data.tar.gz: d0dd1ccb93add3a50cb773d9cc4019aac268363f673a688a8b1c6aea39b33eceea61eee51e8f656a49798e9213b8a2d1c76661a0b2ffe3d3d7301e681149b36d
+  metadata.gz: d2818a4e5b2564c846ae3cdf85765c95e8dbfb1b00088a9491fa21664603ad9255e477c8857dc00466750a4adbfd0daba97fb8bef877e4d7b8d9844c565bd98b
+  data.tar.gz: e69963faff65bfe0ef59c56cd6674ded77261c190d87713f82e0518bbd994910cc8184e284f18bf0e36411aea63bd59b9355b9864c6bec92cc6c98879141bcbb

data/README.md

@@ -25,6 +25,89 @@ group :development do
 end
 ```
 
+## Using gems locally with Gemfile.local (No Git Pollution)
+
+This guide shows you how to use any gem **locally in development** without modifying your app’s main `Gemfile`. It’s perfect for plugin development, debugging, or testing gems privately.
+
+The setup also works with **`puma-dev`** out of the box and ensures your local changes stay out of Git.
+
+---
+
+###  1. Add a bundle Wrapper to Your Shell
+
+Paste this function into your `~/.zshrc`, `~/.bashrc`, or `~/.profile`:
+
+```bash
+bundle() {
+  local gemfile_local="Gemfile.local"
+  local lockfile_local="Gemfile.local.lock"
+  local lockfile_default="Gemfile.lock"
+
+  if [[ "$1" == "install" ]]; then
+    echo "[bundle] Running standard install with Gemfile"
+    command bundle install "${@:2}"
+
+    if [ -f "$gemfile_local" ]; then
+      echo "[bundle] Removing $lockfile_local if it exists"
+      rm -f "$lockfile_local"
+
+      echo "[bundle] Running install with Gemfile.local"
+      BUNDLE_GEMFILE="$gemfile_local" command bundle install "${@:2}"
+    fi
+  else
+    if [ -f "$gemfile_local" ]; then
+      BUNDLE_GEMFILE="$gemfile_local" command bundle "$@"
+    else
+      command bundle "$@"
+    fi
+  fi
+}
+```
+
+### 2. Add the setup script
+
+Paste this function into your `~/.zshrc`, `~/.bashrc`, or `~/.profile`:
+```bash
+setup_local_gemfile() {
+  echo 'export BUNDLE_GEMFILE=Gemfile.local' > .pumaenv
+
+  cat > Gemfile.local <<'RUBY'
+gemfile = File.join(File.dirname(__FILE__), 'Gemfile')
+if File.readable?(gemfile)
+  puts "Loading #{gemfile}..." if $DEBUG
+  instance_eval(File.read(gemfile))
+end
+RUBY
+
+  {
+    echo .pumaenv
+    echo Gemfile.local
+    echo Gemfile.local.lock
+  } >> .git/info/exclude
+
+  echo "[setup] Local Gemfile environment ready!"
+}
+```
+
+### 3. Go to your app folder modify Gemfile.local
+
+Just add your gem like this 
+
+```ruby
+group :development do
+  gem 'rails_spotlight'
+end
+```
+
+### 4. Install all and restart puma.dev if needed
+```bash
+# if you didn't reload you bash/zsh just load rc or profile file here by source {my_file}
+setup_local_gemfile
+bundle install
+puma-dev -stop
+```
+
+
 ## Configuration
 
 Generate configuration file by running:
@@ -51,16 +134,21 @@ file will be created in `config/rails_spotlight.yml`
   RAILS_SPOTLIGHT_PROJECT:
   
   # Prevent from processing and sending some data to the extension
-  MIDDLEWARE_SKIPPED_PATHS: []
+  MIDDLEWARE_SKIPPED_PATHS: ['/rails']
   NOT_ENCODABLE_EVENT_VALUES:
   SKIP_RENDERED_IVARS: []
   
   # Features
+  LOGS_ENABLED: true
+  SIDEKIQ_LOGS_ENABLED: false
   FILE_MANAGER_ENABLED: true
   RUBOCOP_ENABLED: true
   SQL_CONSOLE_ENABLED: true
   IRB_CONSOLE_ENABLED: true
   
+  # Disable ActiveSupport subscriptions
+  DISABLE_ACTIVE_SUPPORT_SUBSCRIPTIONS: []
+  
   # File manager configuration
   BLOCK_EDITING_FILES: false
   BLOCK_EDITING_FILES_OUTSIDE_OF_THE_PROJECT: true
@@ -148,7 +236,36 @@ You can add to your Initializers `config/initializers/rails_spotlight.rb` file w
 
 Known issue:
 
-Authentication error when using: 
+### Stack too deep:
+  
+Usually happens when you have a lot of nested partials or locals containing complex objects.
+  
+Solution:
+    
+- first try to add `render_partial.action_view` and `render_template.action_view` to the `DISABLE_ACTIVE_SUPPORT_SUBSCRIPTIONS` in the config file.
+- if it doesn't help, try to disable more of the subscriptions full list:  
+  * sql.active_record
+  * sql.sequel
+  * render_partial.action_view
+  * render_template.action_view
+  * process_action.action_controller.exception
+  * process_action.action_controller
+  * cache_read.active_support
+  * cache_generate.active_support
+  * cache_fetch_hit.active_support
+  * cache_write.active_support
+  * cache_delete.active_support
+  * cache_exist?.active_support
+  * render_view.locals
+- last you can disable `LOGS_ENABLED` or entire gem via `ENABLED` flag
+- If you are sure what in you app can cause issue you can add it to the `NOT_ENCODABLE_EVENT_VALUES` list in the config file like this:
+```yaml
+  NOT_ENCODABLE_EVENT_VALUES:
+    Lookbook:
+      - Lookbook::Param
+```
+
+### Authentication error when using: 
   - Specific authentication method and action cable
   - AUTO_MOUNT_CABLE: true
 
@@ -188,4 +305,3 @@ Gem is created for the Chrome extension [Rails Spotlight](https://chrome.google.
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
-

data/fake_spec_res/config/rails_spotlight.yml

@@ -21,6 +21,9 @@
   RUBOCOP_ENABLED: true
   SQL_CONSOLE_ENABLED: true
   IRB_CONSOLE_ENABLED: true
+
+  # Disable ActiveSupport subscriptions
+  DISABLE_ACTIVE_SUPPORT_SUBSCRIPTIONS: []
   
   # File manager configuration
   BLOCK_EDITING_FILES: false

data/lib/rails_spotlight/app_notifications.rb

@@ -25,7 +25,7 @@ module RailsSpotlight
         payload[:options][k] = payload.delete(k) unless k.in? CACHE_KEY_COLUMNS
       end
 
-      callsite = ::RailsSpotlight::Utils.dev_callsite(caller)
+      callsite = payload[:original_callsite] || ::RailsSpotlight::Utils.dev_callsite(caller_locations)
       payload.merge!(callsite) if callsite
 
       Event.new(name, start, ending, transaction_id, payload)
@@ -46,7 +46,7 @@ module RailsSpotlight
 
     SQL_BLOCK = proc { |*args|
       _name, start, ending, transaction_id, payload = args
-      callsite = ::RailsSpotlight::Utils.dev_callsite(caller)
+      callsite = payload[:original_callsite] || ::RailsSpotlight::Utils.dev_callsite(caller_locations)
       payload.merge!(callsite) if callsite
 
       Event.new(SQL_EVENT_NAME, start, ending, transaction_id, payload)
@@ -59,13 +59,30 @@ module RailsSpotlight
       Event.new(name, start, ending, transaction_id, payload)
     }
 
+    CONTROLLER_BLOCK = proc { |*args|
+      name, start, ending, transaction_id, payload = args
+      payload[:identifier] = ::RailsSpotlight::Utils.sub_source_path(payload[:identifier])
+      # Payload of redirect_to
+      # { status: 302, location: "http://localhost:3000/posts/new", request: <ActionDispatch::Request:0x00007ff1cb9bd7b8> }
+      # Payload of process_action
+      # { controller: "PostsController", action: "index", params: {"action" => "index", "controller" => "posts"}, format: :html, method: "GET", path: "/posts",
+      #   headers: #<ActionDispatch::Http::Headers:0x0055a67a519b88>, request: #<ActionDispatch::Request:0x00007ff1cb9bd7b8>, response: #<ActionDispatch::Response:0x00007f8521841ec8>,
+      #   status: 200, view_runtime: 46.848, db_runtime: 0.157
+      # }
+      # Payload of send_stream.action_controller
+      # { filename: "subscribers.csv", type: "text/csv", disposition: "attachment" }
+
+      Event.new(name, start, ending, transaction_id, payload)
+    }
+
+
     # Subscribe to all relevant events
     def self.subscribe
       # Skip RailsSpotlight subscriptions during migrations
       return if migrating?
 
       new
-        # .subscribe('rsl.notification.log') # We do not publish events to this channel for now
+        .subscribe('rsl.notification.log') # We do not publish events to this channel for now
         .subscribe('sql.active_record', &SQL_BLOCK)
         .subscribe('sql.sequel', &SQL_BLOCK)
         .subscribe('render_partial.action_view', &VIEW_BLOCK)
@@ -83,6 +100,9 @@ module RailsSpotlight
         .subscribe('cache_delete.active_support', &CACHE_BLOCK)
         .subscribe('cache_exist?.active_support', &CACHE_BLOCK)
         .subscribe('render_view.locals', &VIEW_LOCALS_BLOCK)
+        # .subscribe('start_processing.action_controller', &CONTROLLER_BLOCK)
+        # .subscribe('redirect_to.action_controller', &CONTROLLER_BLOCK)
+        # .subscribe('send_file.action_controller', &CONTROLLER_BLOCK)
 
       # TODO: Consider adding these events
       # start_processing.action_controller: Triggered when a controller action starts processing a request.
@@ -96,12 +116,15 @@ module RailsSpotlight
 
     def self.migrating?
       defined?(Rake) && Rake.application.top_level_tasks.any? do |task|
-        task.start_with?('db:migrate', 'db:schema:load', 'db:rollback')
+        task.start_with?('db:')
       end
     end
 
     def subscribe(event_name)
+      # Look for details about instrumentation => https://guides.rubyonrails.org/active_support_instrumentation.html#railties
       ActiveSupport::Notifications.subscribe(event_name) do |*args|
+        next if ::RailsSpotlight.config.disable_active_support_subscriptions.include?(event_name)
+
         event = block_given? ? yield(*args) : Event.new(*args)
         AppRequest.current.events << event if AppRequest.current
       end

data/lib/rails_spotlight/configuration.rb

@@ -16,6 +16,8 @@ module RailsSpotlight
       'ActionDispatch' => ['ActionDispatch::Request', 'ActionDispatch::Response']
     }.freeze
 
+    MAXIMUM_EVENT_VALUE_SIZE = 100000
+
     DEFAULT_DIRECTORY_INDEX_IGNORE = %w[
       /.git **/*.lock **/.DS_Store /app/assets/images/** /app/assets/fonts/** /app/assets/builds/** **/.keep
     ].freeze
@@ -41,13 +43,15 @@ module RailsSpotlight
     ].freeze
 
     attr_reader :enabled, :project_name, :source_path, :logger, :storage_path, :storage_pool_size, :middleware_skipped_paths,
-                :not_encodable_event_values, :cable_mount_path, :logs_enabled,
+                :not_encodable_event_values, :cable_mount_path, :logs_enabled, :sidekiq_logs_enabled,
                 :file_manager_enabled, :block_editing_files, :block_editing_files_outside_of_the_project, :skip_rendered_ivars,
                 :directory_index_ignore, :rubocop_enabled, :rubocop_config_path, :use_cable, :default_rs_src,
-                :form_js_execution_token, :sql_console_enabled, :irb_console_enabled, :data_access_token
+                :form_js_execution_token, :sql_console_enabled, :irb_console_enabled, :data_access_token,
+                :disable_active_support_subscriptions, :maximum_event_value_size
 
     def initialize(opts = {}) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/AbcSize
       @enabled = bool_val(:enabled, opts, default: false)
+      @sidekiq_logs_enabled = bool_val(:logs_enabled, opts, default: false)
       @logs_enabled = bool_val(:logs_enabled, opts, default: true)
       @project_name = opts[:project_name] || detect_project_name
       @source_path = opts[:source_path] || self.class.rails_root
@@ -65,7 +69,7 @@ module RailsSpotlight
       @block_editing_files_outside_of_the_project = bool_val(:block_editing_files_outside_of_the_project, opts, default: true)
       @file_manager_enabled = bool_val(:file_manager_enabled, opts, default: true)
       @skip_rendered_ivars = SKIP_RENDERED_IVARS + (opts[:skip_rendered_ivars] || []).map(&:to_sym)
-      @directory_index_ignore = opts[:directory_index_ignore] || DEFAULT_DIRECTORY_INDEX_IGNORE
+      @directory_index_ignore = Array(opts[:directory_index_ignore] || DEFAULT_DIRECTORY_INDEX_IGNORE)
       @rubocop_enabled = bool_val(:rubocop_enabled, opts, default: true)
       @rubocop_config_path = opts[:rubocop_config_path] ? File.join(self.class.rails_root, opts[:rubocop_config_path]) : nil
       @cable_logs_enabled = bool_val(:cable_logs_enabled, opts)
@@ -74,6 +78,8 @@ module RailsSpotlight
       @sql_console_enabled = bool_val(:sql_console_enabled, opts, default: true)
       @irb_console_enabled = bool_val(:irb_console_enabled, opts, default: true)
       @data_access_token = opts[:data_access_token].present? ? opts[:data_access_token] : nil
+      @disable_active_support_subscriptions = Array(opts[:disable_active_support_subscriptions] || [])
+      @maximum_event_value_size = opts[:maximum_event_value_size] || MAXIMUM_EVENT_VALUE_SIZE
     end
 
     def cable_console_enabled = @cable_console_enabled && use_cable && action_cable_present?
@@ -82,8 +88,8 @@ module RailsSpotlight
     def auto_mount_cable = @auto_mount_cable && use_cable && action_cable_present?
     def action_cable_present? = defined?(ActionCable) && true
 
-    alias enabled? enabled
     alias logs_enabled? logs_enabled
+    alias sidekiq_logs_enabled? sidekiq_logs_enabled
     alias cable_console_enabled? cable_console_enabled
     alias cable_logs_enabled? cable_logs_enabled
     alias use_cable? use_cable
@@ -94,6 +100,13 @@ module RailsSpotlight
     alias sql_console_enabled? sql_console_enabled
     alias irb_console_enabled? irb_console_enabled
 
+    # We do not recommend using Rails Spotlight in production. However, if you still want to do it, a data_access_token is required
+    def enabled?
+      return enabled unless Rails.env.production?
+
+      enabled && data_access_token.present?
+    end
+
     def self.load_config
       config_file = File.join(rails_root, 'config', 'rails_spotlight.yml')
       return new unless File.exist?(config_file)

data/lib/rails_spotlight/event.rb

@@ -6,14 +6,17 @@ 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'
+    NON_SERIALIZABLE_CLASSES = [Proc, Binding, Method, UnboundMethod, Thread, IO, Class, Module].freeze
 
-    attr_reader :duration
+    attr_reader :duration, :seen_not_encodable
 
     def initialize(name, start, ending, transaction_id, payload)
-      super(name, start, ending, transaction_id, json_encodable(payload))
+      @seen_not_encodable = Set.new
+      raw_payload = json_encodable(payload)
+      raw_payload.merge!(raw_payload[:original_callsite]) if raw_payload[:original_callsite].present? && raw_payload[:filename].blank?
+      super(name, start, ending, transaction_id, raw_payload)
       @duration = 1000.0 * (ending - start)
     rescue # rubocop:disable Lint/RedundantCopDisableDirective, Style/RescueStandardError
       @duration = 0
@@ -36,30 +39,85 @@ module RailsSpotlight
 
     private
 
-    def json_encodable(payload) # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+    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 value.is_a?(Array) && defined?(ActiveRecord::Relation::QueryAttribute) && value.first.is_a?(ActiveRecord::Relation::QueryAttribute)
-          value = value.map(&method(:map_relation_query_attribute))
-        elsif !value.respond_to?(:to_json) || not_encodable?(value)
-          value = NOT_JSON_ENCODABLE
-        end
-
-        begin
-          value.to_json(methods: [:duration])
-          new_value = value
-        rescue # rubocop:disable Lint/RedundantCopDisableDirective, Style/RescueStandardError
-          new_value = NOT_JSON_ENCODABLE
-        end
-        hash[key] = new_value # encode_value(value)
+        hash[key] = encode_json_safe_value(value)
       end.with_indifferent_access
-    rescue # rubocop:disable Lint/RedundantCopDisableDirective, Style/RescueStandardError
+    rescue
       {}
     end
 
+    def not_json_encodable_and_seen(value)
+       seen_not_encodable.add(value.__id__)
+       NOT_JSON_ENCODABLE
+    end
+
+    def encode_json_safe_value(value)
+      return not_json_encodable_and_seen(value) if not_encodable?(value)
+      return NOT_JSON_ENCODABLE unless value.respond_to?(:to_json)
+
+      case value
+      when ActionDispatch::Http::Headers
+        value = value.to_h.select { |k, _| k.upcase == k }
+      when Array
+        value = value.map { |v| encode_json_safe_value(v) rescue NOT_JSON_ENCODABLE }
+      when Hash
+        value = transform_hash(value, deep: true) { |h, k, v| h[k] = encode_json_safe_value(v) }
+      when ActiveRecord::Relation::QueryAttribute
+        map_relation_query_attribute(value)
+      # when ActionController::Parameters
+      #   value = value.to_unsafe_h rescue value.to_h
+      else
+        if defined?(ActiveRecord::Relation::QueryAttribute) && value.is_a?(ActiveRecord::Relation::QueryAttribute)
+          value = map_relation_query_attribute(value)
+        end
+      end
+
+      begin
+        value.to_json(methods: [:duration])
+        value
+      rescue
+        NOT_JSON_ENCODABLE
+      end
+    end
+
+    def transform_hash(original, options = {}, &block)
+      options[:safe_descent] ||= {}.compare_by_identity
+
+      return cached_transformation(original, options) if already_transformed?(original, options)
+
+      new_hash = {}
+      cache_transformation(original, new_hash, options)
+
+      original.each do |key, value|
+        value = deep_transform_value(value, options, &block) if options[:deep]
+        block.call(new_hash, key, value)
+      end
+
+      new_hash
+    end
+
+    def already_transformed?(object, options)
+      options[:safe_descent].key?(object)
+    end
+
+    def cached_transformation(object, options)
+      options[:safe_descent][object]
+    end
+
+    def cache_transformation(original, transformed, options)
+      options[:safe_descent][original] = transformed
+    end
+
+    def deep_transform_value(value, options, &block)
+      return value unless value.is_a?(Hash)
+      return cached_transformation(value, options) if already_transformed?(value, options)
+
+      transform_hash(value, options, &block)
+    end
+
     # ActiveRecord::Relation::QueryAttribute implementation changed in Rails 7.1 it getting binds need to be manually added
     def map_relation_query_attribute(attr)
       {
@@ -74,52 +132,34 @@ module RailsSpotlight
     end
 
     def not_encodable?(value)
+      return true if value_too_large?(value)
+      return true if NON_SERIALIZABLE_CLASSES.any? { |klass| value.is_a?(klass) }
+
       ::RailsSpotlight.config.not_encodable_event_values.any? do |module_name, class_names|
-        next unless safe_constantize(module_name)
+        next true unless safe_constantize(module_name)
 
         class_names.any? do |class_name|
           klass = safe_constantize(class_name)
-          next false unless klass
-
-          value.is_a?(klass)
+          klass && value.is_a?(klass)
         end
       rescue # rubocop:disable Style/RescueStandardError
         true
       end
     end
 
+    def value_too_large?(value)
+      return false unless defined?(ObjectSpace) && defined?(ObjectSpace.memsize_of)
+      return false unless RailsSpotlight.config.maximum_event_value_size
+
+      (ObjectSpace.memsize_of(value) > RailsSpotlight.config.maximum_event_value_size)
+    rescue
+      false
+    end
+
     def safe_constantize(name)
       name.constantize
     rescue NameError
       nil
     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

@@ -62,7 +62,7 @@ module RailsSpotlight
 
       return unless message.is_a?(String)
 
-      callsite = Utils.dev_callsite(caller.drop(1))
+      callsite = Utils.dev_callsite(caller_locations.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:, level: severity, progname: name)) if AppRequest.current

data/lib/rails_spotlight/middlewares/concerns/skip_request_paths.rb

@@ -3,7 +3,7 @@
 module RailsSpotlight
   module Middlewares
     module SkipRequestPaths
-      PATHS_TO_SKIP = %w[/__better_errors /__rails_spotlight /__meta_request /rails].freeze
+      PATHS_TO_SKIP = %w[/__better_errors /__rails_spotlight /__meta_request].freeze
 
       private
 

data/lib/rails_spotlight/middlewares/header_marker.rb

@@ -27,7 +27,7 @@ module RailsSpotlight
 
       attr_reader :app, :app_config
 
-      def default_skip_paths = %w[/__better_errors /__meta_request /rails]
+      def default_skip_paths = %w[/__better_errors /__meta_request]
     end
   end
 end

data/lib/rails_spotlight/notification_extension.rb

@@ -0,0 +1,14 @@
+module RailsSpotlight
+  module NotificationExtension
+    def instrument(name, payload = {}, &block)
+      if payload.is_a?(Hash) && !payload.key?(:original_callsite)
+        callsite = ::RailsSpotlight::Utils.dev_callsite(caller_locations)
+        if callsite && callsite[:filename].present?
+          payload[:original_callsite] = callsite
+        end
+      end
+
+      super(name, payload, &block)
+    end
+  end
+end

data/lib/rails_spotlight/railtie.rb

@@ -16,7 +16,7 @@ module RailsSpotlight
       next unless ::RailsSpotlight.config.logs_enabled?
 
       Rails.logger&.extend(LogInterceptor)
-      defined?(Sidekiq::Logger) && Sidekiq.logger&.extend(LogInterceptor)
+      ::RailsSpotlight.config.sidekiq_logs_enabled? && defined?(Sidekiq::Logger) && Sidekiq.logger&.extend(LogInterceptor)
     end
 
     initializer 'rails_spotlight.subscribe_to_notifications' do

data/lib/rails_spotlight/utils.rb

@@ -4,16 +4,14 @@ 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 `(.*)')?$/)
+    def dev_callsite(caller_locations)
+      loc = caller_locations.detect { |c| c.path.start_with? RailsSpotlight.config.rails_root }
+      return nil unless loc
 
       {
-        filename: sub_source_path(filename),
-        line: line.to_i,
-        method:
+        filename: sub_source_path(loc.path),
+        line: loc.lineno,
+        method: loc.label
       }
     rescue # rubocop:disable Style/RescueStandardError, Lint/SuppressedException
     end

data/lib/rails_spotlight/version.rb

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

data/lib/rails_spotlight.rb

@@ -1,16 +1,18 @@
 # frozen_string_literal: true
 
 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'
-  autoload :RenderViewReporter, 'rails_spotlight/render_view_reporter'
+  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 :NotificationExtension, 'rails_spotlight/notification_extension'
+  autoload :AppNotifications,      'rails_spotlight/app_notifications'
+  autoload :Utils,                 'rails_spotlight/utils'
+  autoload :RenderViewReporter,    'rails_spotlight/render_view_reporter'
+
 
   class << self
     def config

data/lib/tasks/init.rake

@@ -33,6 +33,9 @@ namespace :rails_spotlight do # rubocop:disable Metrics/BlockLength
       RUBOCOP_ENABLED: true
       SQL_CONSOLE_ENABLED: true
       IRB_CONSOLE_ENABLED: true
+    
+      # Disable ActiveSupport subscriptions
+      DISABLE_ACTIVE_SUPPORT_SUBSCRIPTIONS: []
       
       # File manager configuration
       BLOCK_EDITING_FILES: false

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rails_spotlight
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.3
 platform: ruby
 authors:
 - Pawel Niemczyk
 bindir: exe
 cert_chain: []
-date: 2025-04-14 00:00:00.000000000 Z
+date: 2025-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack-contrib
@@ -265,6 +265,7 @@ files:
 - lib/rails_spotlight/middlewares/main_request_handler.rb
 - lib/rails_spotlight/middlewares/request_completed.rb
 - lib/rails_spotlight/middlewares/request_handler.rb
+- lib/rails_spotlight/notification_extension.rb
 - lib/rails_spotlight/rails_command_executor.rb
 - lib/rails_spotlight/railtie.rb
 - lib/rails_spotlight/render_view_reporter.rb