debugger_replay 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 05e538193555af9b38c46655099ed40a6cf70a789acd8a13267b69018d8e8b24
+  data.tar.gz: dd054040cf7f6f70c2c598e0ecd18823a18f6f05366cd662132d72be8122b97f
+SHA512:
+  metadata.gz: e517f19aa71fc87d26f8012b74f0bc54d8f737aba7c6daad00e9b29f61f39fc72a917cf4b54f62ed2872d253e3496dcb4dc6e2a3af28e02c586e75e4de1a6b16
+  data.tar.gz: d4bfd7c7f913cd30e440b7f84c5dcb451c05069d8b310048c79e4525dd87aa401feaf486ed68b59a818c4e704bd348b13672fa634ad3063db36866c1bfdc0496

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ted Nguyen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,41 @@
+# debugger_replay
+
+Hot-reload and replay requests during debugging. Edit code, type `r`, see changes instantly.
+
+https://github.com/user-attachments/assets/8908892d-ed77-48eb-9fd7-d6b4f0743185
+
+## Compare
+
+| Steps | Without debugger_replay    | With debugger_replay |
+|-------|----------------------------|----------------------|
+| 1     | Hit breakpoint             | Hit breakpoint       |
+| 2     | Edit code                  | Edit code            |
+| 3     | Type `c` to continue       | Type `r`             |
+| 4     | Switch to browser, refresh | Breakpoint hit again |
+| 5     | Breakpoint hit again       |                      |
+
+## Use cases
+
+Replays HTTP requests, ActiveJob jobs, ActionMailer deliveries, Rake tasks
+
+## Installation
+
+```ruby
+group :development do
+  gem "debugger_replay"
+end
+```
+
+## Commands
+
+| Command | Description                          |
+|---------|--------------------------------------|
+| `r`     | Reload code + auto-continue + replay |
+
+## How it works
+
+Middleware captures request details. `r` triggers `Rails.application.reloader.reload!`, queues replay, auto-continues. After current request completes, replays with fresh code.
+
+## License
+
+MIT

data/lib/debugger_replay/core/capture.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module DebuggerReplay
+  class << self
+    attr_accessor :last_request, :last_job, :last_mailer, :last_rake
+    attr_accessor :current_context
+
+    def capture_request!(env)
+      @current_context = :request
+      @last_request = {
+        method: env["REQUEST_METHOD"],
+        path: env["PATH_INFO"],
+        query_string: env["QUERY_STRING"],
+        content_type: env["CONTENT_TYPE"],
+        body: read_body(env),
+        headers: extract_headers(env),
+        cookies: env["HTTP_COOKIE"],
+        host: env["HTTP_HOST"],
+        timestamp: defined?(Time.current) ? Time.current : Time.now
+      }
+    end
+
+    def capture_job!(job)
+      @current_context = :job
+      @last_job = {
+        class: job.class,
+        arguments: job.arguments,
+        job_id: job.job_id,
+        queue_name: job.queue_name,
+        timestamp: defined?(Time.current) ? Time.current : Time.now
+      }
+    end
+
+    def capture_mailer!(mailer_class, action, args)
+      @current_context = :mailer
+      @last_mailer = {
+        class: mailer_class.to_s,
+        action: action.to_s,
+        arguments: args,
+        timestamp: defined?(Time.current) ? Time.current : Time.now
+      }
+    end
+
+    def capture_rake!(task_name, args)
+      @current_context = :rake
+      @last_rake = {
+        task_name: task_name,
+        arguments: args,
+        timestamp: defined?(Time.current) ? Time.current : Time.now
+      }
+    end
+  end
+end

data/lib/debugger_replay/core/replay.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module DebuggerReplay
+  class << self
+    attr_accessor :pending_replay, :pending_job, :pending_mailer, :pending_rake
+
+    def replay!
+      case current_context
+      when :job then last_job ? replay_job! : puts("No job captured.")
+      when :mailer then last_mailer ? replay_mailer! : puts("No mailer captured.")
+      when :rake then last_rake ? replay_rake! : puts("No rake task captured.")
+      when :request then last_request ? replay_request! : puts("No request captured.")
+      else puts "No request, job, mailer, or rake task captured."
+      end
+      nil
+    end
+
+    def replay_request!
+      @pending_replay = last_request.dup
+      reload_and_queue!("request")
+    end
+
+    def replay_job!
+      @pending_job = last_job.dup
+      reload_and_queue!("job")
+    end
+
+    def replay_mailer!
+      @pending_mailer = last_mailer.dup
+      reload_and_queue!("mailer")
+    end
+
+    def replay_rake!
+      @pending_rake = last_rake.dup
+      reload_and_queue!("rake")
+    end
+
+    def execute_pending_request!
+      return unless @pending_replay
+      req = @pending_replay
+      @pending_replay = nil
+      puts "\n=> Replaying: #{req[:method]} #{req[:path]}"
+      Rails.application.call(build_env(req))
+    end
+
+    def execute_pending_job!
+      return unless @pending_job
+      job = @pending_job
+      @pending_job = nil
+      puts "\n=> Replaying: #{job[:class]}#perform(#{format_args(job[:arguments])})"
+      job[:class].perform_now(*job[:arguments])
+    end
+
+    def execute_pending_mailer!
+      return unless @pending_mailer
+      mailer = @pending_mailer
+      @pending_mailer = nil
+      puts "\n=> Replaying: #{mailer[:class]}##{mailer[:action]}(#{format_args(mailer[:arguments])})"
+      mailer[:class].constantize.send(mailer[:action], *mailer[:arguments]).deliver_now
+    end
+
+    def execute_pending_rake!
+      return unless @pending_rake
+      rake = @pending_rake
+      @pending_rake = nil
+      puts "\n=> Replaying: rake #{rake[:task_name]}[#{rake[:arguments].join(',')}]"
+      task = Rake::Task[rake[:task_name]]
+      task.reenable
+      task.invoke(*rake[:arguments])
+    end
+
+    private
+
+    def reload_and_queue!(type)
+      puts "\n=> Reloading code..."
+      Rails.application.reloader.reload!
+      puts "=> #{type.capitalize} replay queued."
+    end
+  end
+end

data/lib/debugger_replay/helpers/env_builder.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module DebuggerReplay
+  class << self
+    private
+
+    def build_env(req)
+      url = req[:path]
+      url += "?#{req[:query_string]}" if req[:query_string]&.length&.positive?
+      env = Rack::MockRequest.env_for(url, method: req[:method], input: req[:body],
+        "CONTENT_TYPE" => req[:content_type], "HTTP_HOST" => req[:host] || "localhost")
+      req[:headers].each { |k, v| env["HTTP_#{k.upcase.tr('-', '_')}"] = v }
+      env["HTTP_COOKIE"] = req[:cookies] if req[:cookies]&.length&.positive?
+      env
+    end
+  end
+end

data/lib/debugger_replay/helpers/formatter.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module DebuggerReplay
+  class << self
+    private
+
+    def format_args(args)
+      args.map(&:inspect).join(", ")
+    end
+  end
+end

data/lib/debugger_replay/helpers/request_parser.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module DebuggerReplay
+  class << self
+    private
+
+    def read_body(env)
+      return nil unless env["rack.input"]
+      body = env["rack.input"].read
+      env["rack.input"].rewind
+      body&.length&.positive? ? body : nil
+    end
+
+    def extract_headers(env)
+      env.select { |k, _| k.start_with?("HTTP_") && !%w[HTTP_COOKIE HTTP_HOST].include?(k) }
+         .transform_keys { |k| k.delete_prefix("HTTP_").split("_").map(&:capitalize).join("-") }
+    end
+  end
+end

data/lib/debugger_replay/setup/callbacks.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module DebuggerReplay
+  class MailerSubscriber
+    def call(name, started, finished, unique_id, payload)
+      mailer_class = payload[:mailer].to_s.split("#").first
+      action = payload[:action].to_s
+      DebuggerReplay.capture_mailer!(mailer_class, action, payload[:args] || [])
+    end
+  end
+
+  module JobReplayCallback
+    def self.included(base)
+      base.class_eval do
+        after_perform do
+          DebuggerReplay.execute_pending_job!
+        end
+      end
+    end
+  end
+end

data/lib/debugger_replay/setup/middleware.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DebuggerReplay
+  class RequestCapture
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      path = env["PATH_INFO"]
+      DebuggerReplay.capture_request!(env) unless IGNORED_PATHS.any? { |p| path.start_with?(p) }
+      @app.call(env)
+    end
+  end
+
+  class ReplayExecutor
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      result = @app.call(env)
+      DebuggerReplay.execute_pending_request!
+      result
+    end
+  end
+end

data/lib/debugger_replay/setup/railtie.rb

@@ -0,0 +1,32 @@
+module DebuggerReplay
+  class Railtie < Rails::Railtie
+    initializer "debugger_replay.setup", after: :load_config_initializers do
+      next unless Rails.env.development?
+
+      # Request middleware
+      Rails.application.config.middleware.insert_before(0, DebuggerReplay::RequestCapture)
+      Rails.application.config.middleware.use(DebuggerReplay::ReplayExecutor)
+
+      # Job support
+      DebuggerReplay.subscribe_to_jobs!
+      ActiveSupport.on_load(:active_job) do
+        include DebuggerReplay::JobReplayCallback
+      end
+
+      # Mailer support
+      DebuggerReplay.subscribe_to_mailers!
+
+      # Rake support
+      DebuggerReplay.instrument_rake_tasks!
+
+      # Define `r` shortcut at top level
+      Object.send(:define_method, :r) do
+        DebuggerReplay.replay!
+        if defined?(DEBUGGER__::SESSION)
+          DEBUGGER__::SESSION.add_preset_commands("replay", ["c"], kick: false, continue: true)
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/debugger_replay/setup/subscriptions.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DebuggerReplay
+  class << self
+    def subscribe_to_jobs!
+      return unless defined?(ActiveSupport::Notifications)
+      ActiveSupport::Notifications.subscribe("perform_start.active_job") { |*, payload| capture_job!(payload[:job]) }
+    end
+
+    def subscribe_to_mailers!
+      return unless defined?(ActiveSupport::Notifications)
+      ActiveSupport::Notifications.subscribe("process.action_mailer", MailerSubscriber.new)
+      ActiveSupport::Notifications.subscribe("deliver.action_mailer") { |*, _| execute_pending_mailer! }
+    end
+
+    def instrument_rake_tasks!
+      return unless defined?(Rake::Task)
+      Rake::Task.class_eval do
+        alias_method :original_execute, :execute
+        def execute(args = nil)
+          DebuggerReplay.capture_rake!(name, args&.to_a || [])
+          original_execute(args).tap { DebuggerReplay.execute_pending_rake! }
+        end
+      end
+    end
+  end
+end

data/lib/debugger_replay/version.rb

@@ -0,0 +1,3 @@
+module DebuggerReplay
+  VERSION = "0.1.0"
+end

data/lib/debugger_replay.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "debugger_replay/version"
+
+# helpers/ - Private utility methods
+require_relative "debugger_replay/helpers/env_builder"
+require_relative "debugger_replay/helpers/request_parser"
+require_relative "debugger_replay/helpers/formatter"
+
+# core/ - Main logic
+require_relative "debugger_replay/core/capture"
+require_relative "debugger_replay/core/replay"
+
+# setup/ - Rails integration
+require_relative "debugger_replay/setup/subscriptions"
+require_relative "debugger_replay/setup/middleware"
+require_relative "debugger_replay/setup/callbacks"
+
+module DebuggerReplay
+  IGNORED_PATHS = %w[/cable /assets /rails/ /logo /avatar /banner].freeze
+end
+
+require_relative "debugger_replay/setup/railtie" if defined?(Rails::Railtie)

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: debugger_replay
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nguyen Vu
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-01-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Replay HTTP requests, ActiveJob jobs, ActionMailer deliveries, and Rake
+  tasks with hot-reloaded code at debugger breakpoints.
+email:
+- ''
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/debugger_replay.rb
+- lib/debugger_replay/core/capture.rb
+- lib/debugger_replay/core/replay.rb
+- lib/debugger_replay/helpers/env_builder.rb
+- lib/debugger_replay/helpers/formatter.rb
+- lib/debugger_replay/helpers/request_parser.rb
+- lib/debugger_replay/setup/callbacks.rb
+- lib/debugger_replay/setup/middleware.rb
+- lib/debugger_replay/setup/railtie.rb
+- lib/debugger_replay/setup/subscriptions.rb
+- lib/debugger_replay/version.rb
+homepage: https://github.com/tednguyendev/debugger_replay
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/tednguyendev/debugger_replay
+  source_code_uri: https://github.com/tednguyendev/debugger_replay
+  changelog_uri: https://github.com/tednguyendev/debugger_replay/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Hot-reload and replay requests during debugging
+test_files: []