debug 1.0.0.beta5 → 1.0.0.rc1

data/lib/debug/server_dap.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'json'
 
 module DEBUGGER__
@@ -5,7 +7,7 @@ module DEBUGGER__
     SHOW_PROTOCOL = ENV['RUBY_DEBUG_DAP_SHOW_PROTOCOL'] == '1'
 
     def dap_setup bytes
-      DEBUGGER__.set_config(use_colorize: false)
+      CONFIG.set_config no_color: true
       @seq = 0
 
       $stderr.puts '[>]' + bytes if SHOW_PROTOCOL
@@ -35,6 +37,7 @@ module DEBUGGER__
                },
              ],
              supportsExceptionFilterOptions: true,
+             supportsStepBack: true,
 
              ## Will be supported
              # supportsExceptionOptions: true,
@@ -48,7 +51,6 @@ module DEBUGGER__
              # supportsBreakpointLocationsRequest:
 
              ## Possible?
-             # supportsStepBack:
              # supportsRestartFrame:
              # supportsCompletionsRequest:
              # completionTriggerCharacters:
@@ -195,6 +197,12 @@ module DEBUGGER__
         when 'pause'
           send_response req
           Process.kill(:SIGINT, Process.pid)
+        when 'reverseContinue'
+          send_response req,
+                        success: false, message: 'cancelled',
+                        result: "Reverse Continue is not supported. Only \"Step back\" is supported."
+        when 'stepBack'
+          @q_msg << req
 
         ## query
         when 'threads'
@@ -210,6 +218,7 @@ module DEBUGGER__
              'evaluate',
              'source'
           @q_msg << req
+
         else
           raise "Unknown request: #{req.inspect}"
         end
@@ -218,7 +227,7 @@ module DEBUGGER__
 
     ## called by the SESSION thread
 
-    def readline
+    def readline prompt
       @q_msg.pop || 'kill!'
     end
 
@@ -279,6 +288,13 @@ module DEBUGGER__
 
     def process_dap_request req
       case req['command']
+      when 'stepBack'
+        if @tc.recorder&.can_step_back?
+          @tc << [:step, :back]
+        else
+          fail_response req, message: 'cancelled'
+        end
+
       when 'stackTrace'
         tid = req.dig('arguments', 'threadId')
         if tc = find_tc(tid)
@@ -363,7 +379,6 @@ module DEBUGGER__
         else
           fail_response req, message: 'not found...'
         end
-
         return :retry
       else
         raise "Unknown DAP request: #{req.inspect}"
@@ -436,8 +451,8 @@ module DEBUGGER__
       when :backtrace
         event! :dap_result, :backtrace, req, {
           stackFrames: @target_frames.map.with_index{|frame, i|
-            path = frame.path
-            ref = frame.file_lines unless File.exist?(path)
+            path = frame.realpath || frame.path
+            ref = frame.file_lines unless path && File.exist?(path)
 
             {
               # id: ??? # filled by SESSION
@@ -455,7 +470,15 @@ module DEBUGGER__
       when :scopes
         fid = args.shift
         frame = @target_frames[fid]
-        lnum = frame.binding ? frame.binding.local_variables.size : 0
+
+        lnum = 
+          if frame.binding
+            frame.binding.local_variables.size
+          elsif vars = frame.local_variables
+            vars.size
+          else
+            0
+          end
 
         event! :dap_result, :scopes, req, scopes: [{
           name: 'Local variables',
@@ -483,6 +506,10 @@ module DEBUGGER__
           vars.unshift variable('%raised', frame.raised_exception) if frame.has_raised_exception
           vars.unshift variable('%return', frame.return_value) if frame.has_return_value
           vars.unshift variable('%self', b.receiver)
+        elsif lvars = frame.local_variables
+          vars = lvars.map{|var, val|
+            variable(var, val)
+          }
         else
           vars = [variable('%self', frame.self)]
           vars.push variable('%raised', frame.raised_exception) if frame.has_raised_exception

data/lib/debug/session.rb

@@ -1,4 +1,5 @@
-
+# frozen_string_literal: true
+
 # skip to load debugger for bundle exec
 return if $0.end_with?('bin/bundle') && ARGV.first == 'exec'
 
@@ -6,6 +7,7 @@ require_relative 'config'
 require_relative 'thread_client'
 require_relative 'source_repository'
 require_relative 'breakpoint'
+require_relative 'tracer'
 
 require 'json' if ENV['RUBY_DEBUG_TEST_MODE']
 
@@ -52,6 +54,9 @@ class RubyVM::InstructionSequence
 end
 
 module DEBUGGER__
+  PresetCommand = Struct.new(:commands, :source, :auto_continue)
+  class PostmortemError < RuntimeError; end
+
   class Session
     def initialize ui
       @ui = ui
@@ -62,59 +67,125 @@ module DEBUGGER__
                 #   "Foo#bar" => MethodBreakpoint
                 #   [:watch, ivar] => WatchIVarBreakpoint
                 #   [:check, expr] => CheckBreakpoint
-      @th_clients = {} # {Thread => ThreadClient}
+      #
+      @tracers = []
+      @th_clients = nil # {Thread => ThreadClient}
       @q_evt = Queue.new
       @displays = []
       @tc = nil
       @tc_id = 0
-      @initial_commands = []
+      @preset_command = nil
+      @postmortem_hook = nil
+      @postmortem = false
+      @thread_stopper = nil
 
       @frame_map = {} # {id => [threadId, frame_depth]} for DAP
       @var_map   = {1 => [:globals], } # {id => ...} for DAP
       @src_map   = {} # {id => src}
 
       @tp_load_script = TracePoint.new(:script_compiled){|tp|
-        unless @management_threads.include? Thread.current
-          ThreadClient.current.on_load tp.instruction_sequence, tp.eval_script
-        end
+        ThreadClient.current.on_load tp.instruction_sequence, tp.eval_script
       }
       @tp_load_script.enable
 
+      activate
+    end
+
+    def active?
+      !@q_evt.closed?
+    end
+
+    def break_at? file, line
+      @bps.has_key? [file, line]
+    end
+
+    def check_forked
+      unless active?
+        # TODO: Support it
+        raise 'DEBUGGER: stop at forked process is not supported yet.'
+      end
+    end
+
+    def activate on_fork: false
       @session_server = Thread.new do
+        Thread.current.name = 'DEBUGGER__::SESSION@server'
         Thread.current.abort_on_exception = true
         session_server_main
       end
 
-      @management_threads = [@session_server]
-      @management_threads << @ui.reader_thread if @ui.respond_to? :reader_thread
-
       setup_threads
 
+      thc = thread_client @session_server
+      thc.is_management
+
+      if on_fork
+        @tp_thread_begin.disable
+        @tp_thread_begin = nil
+        @ui.activate on_fork: true
+      end
+
+      if @ui.respond_to?(:reader_thread) && thc = thread_client(@ui.reader_thread)
+        thc.is_management
+      end
+
       @tp_thread_begin = TracePoint.new(:thread_begin){|tp|
-        unless @management_threads.include?(th = Thread.current)
-          ThreadClient.current.on_thread_begin th
-        end
+        th = Thread.current
+        ThreadClient.current.on_thread_begin th
       }
       @tp_thread_begin.enable
     end
 
+    def deactivate
+      thread_client.deactivate
+      @thread_stopper.disable if @thread_stopper
+      @tp_load_script.disable
+      @tp_thread_begin.disable
+      @bps.each{|k, bp| bp.disable}
+      @th_clients.each{|th, thc| thc.close}
+      @tracers.each{|t| t.disable}
+      @q_evt.close
+      @ui&.deactivate
+      @ui = nil
+    end
+
+    def reset_ui ui
+      @ui.close
+      @ui = ui
+    end
+
+    def pop_event
+      @q_evt.pop
+    end
+
     def session_server_main
-      while evt = @q_evt.pop
+      while evt = pop_event
         # varible `@internal_info` is only used for test
         tc, output, ev, @internal_info, *ev_args = evt
         output.each{|str| @ui.puts str}
 
         case ev
+        when :init
+          wait_command_loop tc
+
         when :load
           iseq, src = ev_args
           on_load iseq, src
           @ui.event :load
           tc << :continue
+
+        when :trace
+          trace_id, msg = ev_args
+          if t = @tracers.find{|t| t.object_id == trace_id}
+            t.puts msg
+          end
+          tc << :continue
+
         when :thread_begin
           th = ev_args.shift
           on_thread_begin th
           @ui.event :thread_begin, th
           tc << :continue
+
         when :suspend
           case ev_args.first
           when :breakpoint
@@ -127,16 +198,14 @@ module DEBUGGER__
           end
 
           if @displays.empty?
+            stop_all_threads
             wait_command_loop tc
           else
             tc << [:eval, :display, @displays]
           end
+
         when :result
           case ev_args.first
-          when :watch
-            bp = ev_args[1]
-            @bps[bp.key] = bp
-            show_bps bp
           when :try_display
             failed_results = ev_args[1]
             if failed_results.size > 0
@@ -145,14 +214,22 @@ module DEBUGGER__
                 @ui.puts "canceled: #{@displays.pop}"
               end
             end
-          when :method_breakpoint
+            stop_all_threads
+
+          when :method_breakpoint, :watch_breakpoint
             bp = ev_args[1]
             if bp
-              @bps[bp.key] = bp
+              add_bp(bp)
               show_bps bp
             else
               # can't make a bp
             end
+          when :trace_pass
+            obj_id = ev_args[1]
+            obj_inspect = ev_args[2]
+            opt = ev_args[3]
+            @tracers << t = ObjectTracer.new(@ui, obj_id, obj_inspect, **opt)
+            @ui.puts "Enable #{t.to_s}"
           else
             # ignore
           end
@@ -165,19 +242,28 @@ module DEBUGGER__
         end
       end
     ensure
-      @bps.each{|k, bp| bp.disable}
-      @th_clients.each{|th, thc| thc.close}
+      deactivate
     end
 
-    def add_initial_commands cmds
-      cmds.each{|c|
-        c.gsub('#.*', '').strip!
-        @initial_commands << c unless c.empty?
-      }
+    def add_preset_commands name, cmds, kick: true, continue: true
+      cs = cmds.map{|c|
+        c.each_line.map{|line|
+          line = line.strip.gsub(/\A\s*\#.*/, '').strip
+          line unless line.empty?
+        }.compact
+      }.flatten.compact
+
+      if @preset_command && !@preset_command.commands.empty?
+        @preset_command.commands += cs
+      else
+        @preset_command = PresetCommand.new(cs, name, continue)
+      end
+
+      ThreadClient.current.on_init name if kick
     end
 
     def source iseq
-      if CONFIG[:use_colorize]
+      if !CONFIG[:no_color]
         @sr.get_colored(iseq)
       else
         @sr.get(iseq)
@@ -190,29 +276,46 @@ module DEBUGGER__
 
     def wait_command_loop tc
       @tc = tc
-      stop_all_threads do
-        loop do
-          case wait_command
-          when :retry
-            # nothing
-          else
-            break
-          end
-        rescue Interrupt
-          retry
+
+      loop do
+        case wait_command
+        when :retry
+          # nothing
+        else
+          break
         end
+      rescue Interrupt
+        @ui.puts "\n^C"
+        retry
+      end
+    end
+
+    def prompt
+      if @postmortem
+        '(rdbg:postmortem) '
+      else
+        '(rdbg) '
       end
-    ensure
-      @tc = nil
     end
 
     def wait_command
-      if @initial_commands.empty?
-        @ui.puts "INTERNAL_INFO: #{JSON.generate(@internal_info)}" if ENV['RUBY_DEBUG_TEST_MODE']
-        line = @ui.readline
+      if @preset_command
+        if @preset_command.commands.empty?
+          if @preset_command.auto_continue
+            @preset_command = nil
+            @tc << :continue
+            return
+          else
+            @preset_command = nil
+            return :retry
+          end
+        else
+          line = @preset_command.commands.shift
+          @ui.puts "(rdbg:#{@preset_command.source}) #{line}"
+        end
       else
-        line = @initial_commands.shift.strip
-        @ui.puts "(rdbg:init) #{line}"
+        @ui.puts "INTERNAL_INFO: #{JSON.generate(@internal_info)}" if ENV['RUBY_DEBUG_TEST_MODE']
+        line = @ui.readline prompt
       end
 
       case line
@@ -246,23 +349,37 @@ module DEBUGGER__
 
       # * `s[tep]`
       #   * Step in. Resume the program until next breakable point.
+      # * `s[tep] <n>`
+      #   * Step in, resume the program at `<n>`th breakable point.
       when 's', 'step'
-        @tc << [:step, :in]
+        cancel_auto_continue
+        check_postmortem
+        step_command :in, arg
 
       # * `n[ext]`
       #   * Step over. Resume the program until next line.
+      # * `n[ext] <n>`
+      #   * Step over, same as `step <n>`.
       when 'n', 'next'
-        @tc << [:step, :next]
+        cancel_auto_continue
+        check_postmortem
+        step_command :next, arg
 
       # * `fin[ish]`
       #   * Finish this frame. Resume the program until the current frame is finished.
+      # * `fin[ish] <n>`
+      #   * Finish frames, same as `step <n>`.
       when 'fin', 'finish'
-        @tc << [:step, :finish]
+        cancel_auto_continue
+        check_postmortem
+        step_command :finish, arg
 
       # * `c[ontinue]`
       #   * Resume the program.
       when 'c', 'continue'
+        cancel_auto_continue
         @tc << :continue
+        restart_all_threads
 
       # * `q[uit]` or `Ctrl-D`
       #   * Finish debugger (with the debuggee process on non-remote debugging).
@@ -270,6 +387,7 @@ module DEBUGGER__
         if ask 'Really quit?'
           @ui.quit arg.to_i
           @tc << :continue
+          restart_all_threads
         else
           return :retry
         end
@@ -278,7 +396,7 @@ module DEBUGGER__
       #   * Same as q[uit] but without the confirmation prompt.
       when 'q!', 'quit!'
         @ui.quit arg.to_i
-        @tc << :continue
+        restart_all_threads
 
       # * `kill`
       #   * Stop the debuggee process with `Kernal#exit!`.
@@ -306,12 +424,18 @@ module DEBUGGER__
       #    * Set breakpoint on the method `<class>#<name>`.
       # * `b[reak] <expr>.<name>`
       #    * Set breakpoint on the method `<expr>.<name>`.
-      # * `b[reak] ... if <expr>`
+      # * `b[reak] ... if: <expr>`
       #   * break if `<expr>` is true at specified location.
-      # * `b[reak] if <expr>`
-      #   * break if `<expr>` is true at any lines.
+      # * `b[reak] ... pre: <command>`
+      #   * break and run `<command>` before stopping.
+      # * `b[reak] ... do: <command>`
+      #   * break and run `<command>`, and continue.
+      # * `b[reak] if: <expr>`
+      #   * break if: `<expr>` is true at any lines.
       #   * Note that this feature is super slow.
       when 'b', 'break'
+        check_postmortem
+
         if arg == nil
           show_bps
           return :retry
@@ -328,6 +452,7 @@ module DEBUGGER__
 
       # skip
       when 'bv'
+        check_postmortem
         require 'json'
 
         h = Hash.new{|h, k| h[k] = []}
@@ -354,8 +479,10 @@ module DEBUGGER__
       # * `catch <Error>`
       #   * Set breakpoint on raising `<Error>`.
       when 'catch'
+        check_postmortem
+
         if arg
-          bp = add_catch_breakpoint arg
+          bp = repl_add_catch_breakpoint arg
           show_bps bp if bp
         else
           show_bps
@@ -366,8 +493,10 @@ module DEBUGGER__
       #   * Stop the execution when the result of current scope's `@ivar` is changed.
       #   * Note that this feature is super slow.
       when 'wat', 'watch'
-        if arg
-          @tc << [:eval, :watch, arg]
+        check_postmortem
+
+        if arg && arg.match?(/\A@\w+/)
+          @tc << [:breakpoint, :watch, arg]
         else
           show_bps
           return :retry
@@ -378,15 +507,17 @@ module DEBUGGER__
       # * `del[ete] <bpnum>`
       #   * delete specified breakpoint.
       when 'del', 'delete'
+        check_postmortem
+
         bp =
         case arg
         when nil
           show_bps
           if ask "Remove all breakpoints?", 'N'
-            delete_breakpoint
+            delete_bp
           end
         when /\d+/
-          delete_breakpoint arg.to_i
+          delete_bp arg.to_i
         else
           nil
         end
@@ -397,8 +528,25 @@ module DEBUGGER__
 
       # * `bt` or `backtrace`
       #   * Show backtrace (frame) information.
+      # * `bt <num>` or `backtrace <num>`
+      #   * Only shows first `<num>` frames.
+      # * `bt /regexp/` or `backtrace /regexp/`
+      #   * Only shows frames with method name or location info that matches `/regexp/`.
+      # * `bt <num> /regexp/` or `backtrace <num> /regexp/`
+      #   * Only shows first `<num>` frames with method name or location info that matches `/regexp/`.
       when 'bt', 'backtrace'
-        @tc << [:show, :backtrace]
+        case arg
+        when /\A(\d+)\z/
+          @tc << [:show, :backtrace, arg.to_i, nil]
+        when /\A\/(.*)\/\z/
+          pattern = $1
+          @tc << [:show, :backtrace, nil, Regexp.compile(pattern)]
+        when /\A(\d+)\s+\/(.*)\/\z/
+          max, pattern = $1, $2
+          @tc << [:show, :backtrace, max.to_i, Regexp.compile(pattern)]
+        else
+          @tc << [:show, :backtrace, nil, nil]
+        end
 
       # * `l[ist]`
       #   * Show current frame's source code.
@@ -442,25 +590,57 @@ module DEBUGGER__
 
         @tc << [:show, :edit, arg]
 
-      # * `i[nfo]`, `i[nfo] l[ocal[s]]`
+      # * `i[nfo]`
+      #    * Show information about current frame (local/instance variables and defined constants).
+      # * `i[nfo] l[ocal[s]]`
       #   * Show information about the current frame (local variables)
       #   * It includes `self` as `%self` and a return value as `%return`.
+      # * `i[nfo] i[var[s]]` or `i[nfo] instance`
+      #   * Show information about insttance variables about `self`.
+      # * `i[nfo] c[onst[s]]` or `i[nfo] constant[s]`
+      #   * Show information about accessible constants except toplevel constants.
+      # * `i[nfo] g[lobal[s]]`
+      #   * Show information about global variables
+      # * `i[nfo] ... </pattern/>`
+      #   * Filter the output with `</pattern/>`.
       # * `i[nfo] th[read[s]]`
       #   * Show all threads (same as `th[read]`).
       when 'i', 'info'
-        case arg
+        if /\/(.+)\/\z/ =~ arg
+          pat = Regexp.compile($1)
+          sub = $~.pre_match.strip
+        else
+          sub = arg
+        end
+
+        case sub
         when nil
-          @tc << [:show, :local]
-        when 'l', /locals?/
-          @tc << [:show, :local]
+          @tc << [:show, :default, pat] # something useful
+        when 'l', /^locals?/
+          @tc << [:show, :locals, pat]
+        when 'i', /^ivars?/i, /^instance[_ ]variables?/i
+          @tc << [:show, :ivars, pat]
+        when 'c', /^consts?/i, /^constants?/i
+          @tc << [:show, :consts, pat]
+        when 'g', /^globals?/i, /^global[_ ]variables?/i
+          @tc << [:show, :globals, pat]
         when 'th', /threads?/
           thread_list
           return :retry
         else
+          @ui.puts "unrecognized argument for info command: #{arg}"
           show_help 'info'
           return :retry
         end
 
+      # * `o[utline]` or `ls`
+      #   * Show you available methods, constants, local variables, and instance variables in the current scope.
+      # * `o[utline] <expr>` or `ls <expr>`
+      #   * Show you available methods and instance variables of the given object.
+      #   * If the object is a class/module, it also lists its constants.
+      when 'outline', 'o', 'ls'
+        @tc << [:show, :outline, arg]
+
       # * `display`
       #   * Show display setting.
       # * `display <expr>`
@@ -481,9 +661,7 @@ module DEBUGGER__
         case arg
         when /(\d+)/
           if @displays[n = $1.to_i]
-            if ask "clear \##{n} #{@displays[n]}?"
-              @displays.delete_at n
-            end
+            @displays.delete_at n
           end
           @tc << [:eval, :display, @displays]
         when nil
@@ -493,28 +671,6 @@ module DEBUGGER__
         end
         return :retry
 
-      # * `trace [on|off]`
-      #   * enable or disable line tracer.
-      when 'trace'
-        case arg
-        when 'on'
-          dir = __dir__
-          @tracer ||= TracePoint.new(:call, :return, :b_call, :b_return, :line, :class, :end){|tp|
-            next if File.dirname(tp.path) == dir
-            next if tp.path == '<internal:trace_point>'
-            # Skip when `JSON.generate` is called during tests
-            next if tp.binding.eval('self').to_s == 'JSON' and ENV['RUBY_DEBUG_TEST_MODE']
-            # next if tp.event != :line
-            @ui.puts pretty_tp(tp)
-          }
-          @tracer.enable
-        when 'off'
-          @tracer && @tracer.disable
-        end
-        enabled = (@tracer && @tracer.enabled?) ? true : false
-        @ui.puts "Trace #{enabled ? 'on' : 'off'}"
-        return :retry
-
       ### Frame control
 
       # * `f[rame]`
@@ -560,6 +716,108 @@ module DEBUGGER__
         end
         @tc << [:eval, :call, 'binding.irb']
 
+        # don't repeat irb command
+        @repl_prev_line = nil
+
+      ### Trace
+      # * `trace`
+      #   * Show available tracers list.
+      # * `trace line`
+      #   * Add a line tracer. It indicates line events.
+      # * `trace call`
+      #   * Add a call tracer. It indicate call/return events.
+      # * `trace exception`
+      #   * Add an exception tracer. It indicates raising exceptions.
+      # * `trace object <expr>`
+      #   * Add an object tracer. It indicates that an object by `<expr>` is passed as a parameter or a receiver on method call.
+      # * `trace ... </pattern/>`
+      #   * Indicates only matched events to `</pattern/>` (RegExp).
+      # * `trace ... into: <file>`
+      #   * Save trace information into: `<file>`.
+      # * `trace off <num>`
+      #   * Disable tracer specified by `<num>` (use `trace` command to check the numbers).
+      # * `trace off [line|call|pass]`
+      #   * Disable all tracers. If `<type>` is provided, disable specified type tracers.
+      when 'trace'
+        if (re = /\s+into:\s*(.+)/) =~ arg
+          into = $1
+          arg.sub!(re, '')
+        end
+
+        if (re = /\s\/(.+)\/\z/) =~ arg
+          pattern = $1
+          arg.sub!(re, '')
+        end
+
+        case arg
+        when nil
+          @ui.puts 'Tracers:'
+          @tracers.each_with_index{|t, i|
+            @ui.puts "* \##{i} #{t}"
+          }
+          @ui.puts
+          return :retry
+
+        when /\Aline\z/
+          @tracers << t = LineTracer.new(@ui, pattern: pattern, into: into)
+          @ui.puts "Enable #{t.to_s}"
+          return :retry
+
+        when /\Acall\z/
+          @tracers << t = CallTracer.new(@ui, pattern: pattern, into: into)
+          @ui.puts "Enable #{t.to_s}"
+          return :retry
+
+        when /\Aexception\z/
+          @tracers << t = ExceptionTracer.new(@ui, pattern: pattern, into: into)
+          @ui.puts "Enable #{t.to_s}"
+          return :retry
+
+        when /\Aobject\s+(.+)/
+          @tc << [:trace, :object, $1.strip, {pattern: pattern, into: into}]
+
+        when /\Aoff\s+(\d+)\z/
+          if t = @tracers[$1.to_i]
+            t.disable
+            @ui.puts "Disable #{t.to_s}"
+          else
+            @ui.puts "Unmatched: #{$1}"
+          end
+          return :retry
+
+        when /\Aoff(\s+(line|call|exception|object))?\z/
+          @tracers.each{|t|
+            if $2.nil? || t.type == $2
+              t.disable
+              @ui.puts "Disable #{t.to_s}"
+            end
+          }
+          return :retry
+
+        else
+          @ui.puts "Unknown trace option: #{arg.inspect}"
+          return :retry
+        end
+
+      # Record
+      # * `record`
+      #   * Show recording status.
+      # * `record [on|off]`
+      #   * Start/Stop recording.
+      # * `step back`
+      #   * Start replay. Step back with the last execution log.
+      #   * `s[tep]` does stepping forward with the last log.
+      # * `step reset`
+      #   * Stop replay .
+      when 'record'
+        case arg
+        when nil, 'on', 'off'
+          @tc << [:record, arg&.to_sym]
+        else
+          @ui.puts "unknown command: #{arg}"
+          return :retry
+        end
+
       ### Thread control
 
       # * `th[read]`
@@ -577,13 +835,43 @@ module DEBUGGER__
         end
         return :retry
 
+      ### Configuration
+      # * `config`
+      #   * Show all configuration with description.
+      # * `config <name>`
+      #   * Show current configuration of <name>.
+      # * `config set <name> <val>` or `config <name> = <val>`
+      #   * Set <name> to <val>.
+      # * `config append <name> <val>` or `config <name> << <val>`
+      #   * Append `<val>` to `<name>` if it is an array.
+      # * `config unset <name>`
+      #   * Set <name> to default.
+      when 'config'
+        config_command arg
+        return :retry
+
+      # * `source <file>`
+      #   * Evaluate lines in `<file>` as debug commands.
+      when 'source'
+        if arg
+          begin
+            cmds = File.readlines(path = File.expand_path(arg))
+            add_preset_commands path, cmds, kick: true, continue: false
+          rescue Errno::ENOENT
+            @ui.puts "File not found: #{arg}"
+          end
+        else
+          show_help 'source'
+        end
+        return :retry
+
       ### Help
 
       # * `h[elp]`
       #   * Show help for all commands.
       # * `h[elp] <command>`
       #   * Show help for the given command.
-      when 'h', 'help'
+      when 'h', 'help', '?'
         if arg
           show_help arg
         else
@@ -593,21 +881,129 @@ module DEBUGGER__
 
       ### END
       else
-        @ui.puts "unknown command: #{line}"
+        @tc << [:eval, :pp, line]
+=begin
         @repl_prev_line = nil
+        @ui.puts "unknown command: #{line}"
+        begin
+          require 'did_you_mean'
+          spell_checker = DidYouMean::SpellChecker.new(dictionary: DEBUGGER__.commands)
+          correction = spell_checker.correct(line.split(/\s/).first || '')
+          @ui.puts "Did you mean? #{correction.join(' or ')}" unless correction.empty?
+        rescue LoadError
+          # Don't use D
+        end
         return :retry
+=end
       end
 
     rescue Interrupt
       return :retry
     rescue SystemExit
       raise
+    rescue PostmortemError => e
+      @ui.puts e.message
+      return :retry
     rescue Exception => e
       @ui.puts "[REPL ERROR] #{e.inspect}"
       @ui.puts e.backtrace.map{|e| '  ' + e}
       return :retry
     end
 
+    def step_command type, arg
+      case arg
+      when nil
+        @tc << [:step, type]
+        restart_all_threads
+      when /\A\d+\z/
+        @tc << [:step, type, arg.to_i]
+        restart_all_threads
+      when /\Aback\z/, /\Areset\z/
+        if type != :in
+          @ui.puts "only `step #{arg}` is supported."
+          :retry
+        else
+          @tc << [:step, arg.to_sym]
+        end
+      else
+        @ui.puts "Unknown option: #{arg}"
+        :retry
+      end
+    end
+
+    def config_show key
+      key = key.to_sym
+      if CONFIG_SET[key]
+        v = CONFIG[key]
+        kv = "#{key} = #{v.nil? ? '(default)' : v.inspect}"
+        desc = CONFIG_SET[key][1]
+        line = "%-30s \# %s" % [kv, desc]
+        if line.size > SESSION.width
+          @ui.puts "\# #{desc}\n#{kv}"
+        else
+          @ui.puts line
+        end
+      else
+        @ui.puts "Unknown configuration: #{key}. 'config' shows all configurations."
+      end
+    end
+
+    def config_set key, val, append: false
+      if CONFIG_SET[key = key.to_sym]
+        begin
+          if append
+            CONFIG.append_config(key, val)
+          else
+            CONFIG[key] = val
+          end
+        rescue => e
+          @ui.puts e.message
+        end
+      end
+
+      config_show key
+    end
+
+    def config_command arg
+      case arg
+      when nil
+        CONFIG_SET.each do |k, _|
+          config_show k
+        end
+
+      when /\Aunset\s+(.+)\z/
+        if CONFIG_SET[key = $1.to_sym]
+          CONFIG[key] = nil
+        end
+        config_show key
+
+      when /\A(\w+)\s*=\s*(.+)\z/
+        config_set $1, $2
+
+      when /\A\s*set\s+(\w+)\s+(.+)\z/
+        config_set $1, $2
+
+      when /\A(\w+)\s*<<\s*(.+)\z/
+        config_set $1, $2, append: true
+
+      when /\A\s*append\s+(\w+)\s+(.+)\z/
+        config_set $1, $2
+
+      when /\A(\w+)\z/
+        config_show $1
+
+      else
+        @ui.puts "Can not parse parameters: #{arg}"
+      end
+    end
+
+
+    def cancel_auto_continue
+      if @preset_command&.auto_continue
+        @preset_command.auto_continue = false
+      end
+    end
+
     def show_help arg
       DEBUGGER__.helps.each{|cat, cs|
         cs.each{|ws, desc|
@@ -632,51 +1028,7 @@ module DEBUGGER__
       end
     end
 
-    def msig klass, receiver
-      if klass.singleton_class?
-        "#{receiver}."
-      else
-        "#{klass}#"
-      end
-    end
-
-    def pretty_tp tp
-      loc = "#{tp.path}:#{tp.lineno}"
-      level = caller.size
-
-      info =
-      case tp.event
-      when :line
-        "line at #{loc}"
-      when :call, :c_call
-        klass = tp.defined_class
-        "#{tp.event} #{msig(klass, tp.self)}#{tp.method_id} at #{loc}"
-      when :return, :c_return
-        klass = tp.defined_class
-        "#{tp.event} #{msig(klass, tp.self)}#{tp.method_id} => #{tp.return_value.inspect} at #{loc}"
-      when :b_call
-        "b_call at #{loc}"
-      when :b_return
-        "b_return => #{tp.return_value} at #{loc}"
-      when :class
-        "class #{tp.self} at #{loc}"
-      when :end
-        "class #{tp.self} end at #{loc}"
-      else
-        "#{tp.event} at #{loc}"
-      end
-
-      case tp.event
-      when :call, :b_call, :return, :b_return, :class, :end
-        level -= 1
-      end
-
-      "Tracing:#{' ' * level} #{info}"
-    rescue => e
-      p e
-      pp e.backtrace
-      exit!
-    end
+    # breakpoint management
 
     def iterate_bps
       deleted_bps = []
@@ -708,7 +1060,29 @@ module DEBUGGER__
       nil
     end
 
-    def delete_breakpoint arg = nil
+    def rehash_bps
+      bps = @bps.values
+      @bps.clear
+      bps.each{|bp|
+        add_bp bp
+      }
+    end
+
+    def add_bp bp
+      # don't repeat commands that add breakpoints
+      @repl_prev_line = nil
+
+      if @bps.has_key? bp.key
+        unless bp.duplicable?
+          @ui.puts "duplicated breakpoint: #{bp}"
+          bp.disable
+        end
+      else
+        @bps[bp.key] = bp
+      end
+    end
+
+    def delete_bp arg = nil
       case arg
       when nil
         @bps.each{|key, bp| bp.delete}
@@ -724,26 +1098,34 @@ module DEBUGGER__
       end
     end
 
-    def repl_add_breakpoint arg
-      arg.strip!
+    BREAK_KEYWORDS = %w(if: do: pre:).freeze
 
-      case arg
-      when /\Aif\s+(.+)\z/
-        cond = $1
-      when /(.+?)\s+if\s+(.+)\z/
-        sig = $1
-        cond = $2
-      else
-        sig = arg
-      end
+    def parse_break arg
+      mode = :sig
+      expr = Hash.new{|h, k| h[k] = []}
+      arg.split(' ').each{|w|
+        if BREAK_KEYWORDS.any?{|pat| w == pat}
+          mode = w[0..-2].to_sym
+        else
+          expr[mode] << w
+        end
+      }
+      expr.default_proc = nil
+      expr.transform_values{|v| v.join(' ')}
+    end
 
-      case sig
+    def repl_add_breakpoint arg
+      expr = parse_break arg.strip
+      cond = expr[:if]
+      cmd = ['break', expr[:pre], expr[:do]] if expr[:pre] || expr[:do]
+
+      case expr[:sig]
       when /\A(\d+)\z/
-        add_line_breakpoint @tc.location.path, $1.to_i, cond: cond
+        add_line_breakpoint @tc.location.path, $1.to_i, cond: cond, command: cmd
       when /\A(.+)[:\s+](\d+)\z/
-        add_line_breakpoint $1, $2.to_i, cond: cond
+        add_line_breakpoint $1, $2.to_i, cond: cond, command: cmd
       when /\A(.+)([\.\#])(.+)\z/
-        @tc << [:breakpoint, :method, $1, $2, $3, cond]
+        @tc << [:breakpoint, :method, $1, $2, $3, cond, cmd]
         return :noretry
       when nil
         add_check_breakpoint cond
@@ -754,6 +1136,29 @@ module DEBUGGER__
       end
     end
 
+    def repl_add_catch_breakpoint arg
+      expr = parse_break arg.strip
+      cond = expr[:if]
+      cmd = ['catch', expr[:pre], expr[:do]] if expr[:pre] || expr[:do]
+
+      bp = CatchBreakpoint.new(expr[:sig], cond: cond, command: cmd)
+      add_bp bp
+    end
+
+    def add_check_breakpoint expr
+      bp = CheckBreakpoint.new(expr)
+      add_bp bp
+    end
+
+    def add_line_breakpoint file, line, **kw
+      file = resolve_path(file)
+      bp = LineBreakpoint.new(file, line, **kw)
+
+      add_bp bp
+    rescue Errno::ENOENT => e
+      @ui.puts e.message
+    end
+
     # threads
 
     def update_thread_list
@@ -762,17 +1167,15 @@ module DEBUGGER__
       unmanaged = []
 
       list.each{|th|
-        case
-        when th == Thread.current
-          # ignore
-        when @management_threads.include?(th)
-          # ignore
-        when @th_clients.has_key?(th)
-          thcs << @th_clients[th]
+        if thc = @th_clients[th]
+          if !thc.management?
+            thcs << thc
+          end
         else
           unmanaged << th
         end
       }
+
       return thcs.sort_by{|thc| thc.id}, unmanaged
     end
 
@@ -799,7 +1202,7 @@ module DEBUGGER__
       thcs, _unmanaged_ths = update_thread_list
 
       if tc = thcs[n]
-        if tc.mode
+        if tc.waiting?
           @tc = tc
         else
           @ui.puts "#{tc.thread} is not controllable yet."
@@ -813,11 +1216,11 @@ module DEBUGGER__
     end
 
     def setup_threads
-      stop_all_threads do
-        Thread.list.each{|th|
-          thread_client_create(th)
-        }
-      end
+      @th_clients = {}
+
+      Thread.list.each{|th|
+        thread_client_create(th)
+      }
     end
 
     def on_thread_begin th
@@ -829,8 +1232,7 @@ module DEBUGGER__
       end
     end
 
-    def thread_client
-      thr = Thread.current
+    def thread_client thr = Thread.current
       if @th_clients.has_key? thr
         @th_clients[thr]
       else
@@ -838,77 +1240,67 @@ module DEBUGGER__
       end
     end
 
-    def stop_all_threads
-      current = Thread.current
+    private def thread_stopper
+      @thread_stopper ||= TracePoint.new(:line) do
+        # run on each thread
+        tc = ThreadClient.current
+        next if tc.management?
+        next unless tc.running?
+        next if tc == @tc
 
-      if Thread.list.size > 1
-        TracePoint.new(:line) do
-          th = Thread.current
-          if current == th || @management_threads.include?(th)
-            next
-          else
-            tc = ThreadClient.current
-            tc.on_pause
-          end
-        end.enable do
-          yield
-        ensure
-          @th_clients.each{|thr, tc|
-            case thr
-            when current, (@tc && @tc.thread)
-              next
-            else
-              tc << :continue if thr != Thread.current
-            end
-          }
-        end
-      else
-        yield
+        tc.on_pause
       end
     end
 
-    ## event
-
-    def on_load iseq, src
-      @sr.add iseq, src
+    private def running_thread_clients_count
+      @th_clients.count{|th, tc|
+        next if tc.management?
+        next unless tc.running?
+        true
+      }
+    end
 
-      pending_line_breakpoints do |bp|
-        if bp.path == (iseq.absolute_path || iseq.path)
-          bp.try_activate
-        end
-      end
+    private def waiting_thread_clients
+      @th_clients.map{|th, tc|
+        next if tc.management?
+        next unless tc.waiting?
+        tc
+      }.compact
     end
 
-    # breakpoint management
+    private def stop_all_threads
+      return if running_thread_clients_count == 0
 
-    def add_breakpoint bp
-      if @bps.has_key? bp.key
-        @ui.puts "duplicated breakpoint: #{bp}"
-      else
-        @bps[bp.key] = bp
-      end
+      stopper = thread_stopper
+      stopper.enable unless stopper.enabled?
     end
 
-    def rehash_bps
-      bps = @bps.values
-      @bps.clear
-      bps.each{|bp|
-        add_breakpoint bp
+    private def restart_all_threads
+      stopper = thread_stopper
+      stopper.disable if stopper.enabled?
+
+      waiting_thread_clients.each{|tc|
+        next if @tc == tc
+        tc << :continue
       }
+      @tc = nil
     end
 
-    def break? file, line
-      @bps.has_key? [file, line]
-    end
+    ## event
 
-    def add_catch_breakpoint arg
-      bp = CatchBreakpoint.new(arg)
-      add_breakpoint bp
-    end
+    def on_load iseq, src
+      DEBUGGER__.info "Load #{iseq.absolute_path || iseq.path}"
+      @sr.add iseq, src
 
-    def add_check_breakpoint expr
-      bp = CheckBreakpoint.new(expr)
-      add_breakpoint bp
+      pending_line_breakpoints = @bps.find_all do |key, bp|
+        LineBreakpoint === bp && !bp.iseq
+      end
+
+      pending_line_breakpoints.each do |_key, bp|
+        if bp.path == (iseq.absolute_path || iseq.path)
+          bp.try_activate
+        end
+      end
     end
 
     def resolve_path file
@@ -929,22 +1321,6 @@ module DEBUGGER__
       raise
     end
 
-    def add_line_breakpoint file, line, **kw
-      file = resolve_path(file)
-      bp = LineBreakpoint.new(file, line, **kw)
-      add_breakpoint bp
-    rescue Errno::ENOENT => e
-      @ui.puts e.message
-    end
-
-    def pending_line_breakpoints
-      @bps.find_all do |key, bp|
-        LineBreakpoint === bp && !bp.iseq
-      end.each do |key, bp|
-        yield bp
-      end
-    end
-
     def method_added tp
       b = tp.binding
       if var_name = b.local_variables.first
@@ -956,7 +1332,7 @@ module DEBUGGER__
           when MethodBreakpoint
             if bp.method.nil?
               if bp.sig_method_name == mid.to_s
-                bp.try_enable(quiet: true)
+                bp.try_enable(added: true)
               end
             end
 
@@ -973,10 +1349,55 @@ module DEBUGGER__
       @ui.width
     end
 
-    def check_forked
-      unless @session_server.status
-        # TODO: Support it
-        raise 'DEBUGGER: stop at forked process is not supported yet.'
+    def check_postmortem
+      if @postmortem
+        raise PostmortemError, "Can not use this command on postmortem mode."
+      end
+    end
+
+    def enter_postmortem_session frames
+      @postmortem = true
+      ThreadClient.current.suspend :postmortem, postmortem_frames: frames
+    ensure
+      @postmortem = false
+    end
+
+    def postmortem=(is_enable)
+      if is_enable
+        unless @postmortem_hook
+          @postmortem_hook = TracePoint.new(:raise){|tp|
+            exc = tp.raised_exception
+            frames = DEBUGGER__.capture_frames(__dir__)
+            exc.instance_variable_set(:@postmortem_frames, frames)
+          }
+          at_exit{
+            @postmortem_hook.disable
+            if CONFIG[:postmortem] && (exc = $!) != nil
+              exc = exc.cause while exc.cause
+
+              begin
+                @ui.puts "Enter postmortem mode with #{exc.inspect}"
+                @ui.puts exc.backtrace.map{|e| '  ' + e}
+                @ui.puts "\n"
+
+                enter_postmortem_session exc.instance_variable_get(:@postmortem_frames)
+              rescue SystemExit
+                exit!
+              rescue Exception => e
+                @ui = STDERR unless @ui
+                @ui.puts "Error while postmortem console: #{e.inspect}"
+              end
+            end
+          }
+        end
+
+        if !@postmortem_hook.enabled?
+          @postmortem_hook.enable
+        end
+      else
+        if @postmortem_hook && @postmortem_hook.enabled?
+          @postmortem_hook.disable
+        end
       end
     end
   end
@@ -1022,44 +1443,71 @@ module DEBUGGER__
 
   # start methods
 
-  def self.console **kw
-    set_config(kw)
-
-    require_relative 'console'
+  def self.start nonstop: false, **kw
+    CONFIG.set_config(**kw)
 
-    initialize_session UI_Console.new
+    unless defined? SESSION
+      require_relative 'local'
+      initialize_session UI_LocalConsole.new
+    end
 
-    @prev_handler = trap(:SIGINT){
-      ThreadClient.current.on_trap :SIGINT
-    }
+    setup_initial_suspend unless nonstop
   end
 
-  def self.open host: nil, port: ::DEBUGGER__::CONFIG[:port], sock_path: nil, sock_dir: nil, **kw
-    set_config(kw)
+  def self.open host: nil, port: CONFIG[:port], sock_path: nil, sock_dir: nil, nonstop: false, **kw
+    CONFIG.set_config(**kw)
 
     if port
-      open_tcp host: host, port: port
+      open_tcp host: host, port: port, nonstop: nonstop
     else
-      open_unix sock_path: sock_path, sock_dir: sock_dir
+      open_unix sock_path: sock_path, sock_dir: sock_dir, nonstop: nonstop
     end
   end
 
-  def self.open_tcp host: nil, port:, **kw
-    set_config(kw)
+  def self.open_tcp host: nil, port:, nonstop: false, **kw
+    CONFIG.set_config(**kw)
     require_relative 'server'
-    initialize_session UI_TcpServer.new(host: host, port: port)
+
+    if defined? SESSION
+      SESSION.reset_ui UI_TcpServer.new(host: host, port: port)
+    else
+      initialize_session UI_TcpServer.new(host: host, port: port)
+    end
+
+    setup_initial_suspend unless nonstop
   end
 
-  def self.open_unix sock_path: nil, sock_dir: nil, **kw
-    set_config(kw)
+  def self.open_unix sock_path: nil, sock_dir: nil, nonstop: false, **kw
+    CONFIG.set_config(**kw)
     require_relative 'server'
-    initialize_session UI_UnixDomainServer.new(sock_dir: sock_dir, sock_path: sock_path)
+
+    if defined? SESSION
+      SESSION.reset_ui UI_UnixDomainServer.new(sock_dir: sock_dir, sock_path: sock_path)
+    else
+      initialize_session UI_UnixDomainServer.new(sock_dir: sock_dir, sock_path: sock_path)
+    end
+
+    setup_initial_suspend unless nonstop
   end
 
   # boot utilities
 
+  def self.setup_initial_suspend
+    if !CONFIG[:nonstop]
+      if loc = ::DEBUGGER__.require_location
+        # require 'debug/start' or 'debug'
+        add_line_breakpoint loc.absolute_path, loc.lineno + 1, oneshot: true, hook_call: false
+      else
+        # -r
+        add_line_breakpoint $0, 0, oneshot: true, hook_call: false
+      end
+    end
+  end
+
   class << self
     define_method :initialize_session do |ui|
+      DEBUGGER__.warn "Session start (pid: #{Process.pid})"
+
       ::DEBUGGER__.const_set(:SESSION, Session.new(ui))
 
       # default breakpoints
@@ -1067,25 +1515,18 @@ module DEBUGGER__
       # ::DEBUGGER__.add_catch_breakpoint 'RuntimeError'
 
       Binding.module_eval do
-        def bp command: nil
-          if command
-            cmds = command.split(";;")
-            SESSION.add_initial_commands cmds
+        def break pre: nil, do: nil
+          return unless SESSION.active?
+
+          if pre || (do_expr = binding.local_variable_get(:do))
+            cmds = ['binding.break', pre, do_expr]
           end
 
-          ::DEBUGGER__.add_line_breakpoint __FILE__, __LINE__ + 1, oneshot: true
+          ::DEBUGGER__.add_line_breakpoint __FILE__, __LINE__ + 1, oneshot: true, command: cmds
           true
         end
-      end
-
-      if !::DEBUGGER__::CONFIG[:nonstop]
-        if loc = ::DEBUGGER__.require_location
-          # require 'debug/console' or 'debug'
-          add_line_breakpoint loc.absolute_path, loc.lineno + 1, oneshot: true, hook_call: false
-        else
-          # -r
-          add_line_breakpoint $0, 1, oneshot: true, hook_call: false
-        end
+        alias b break
+        # alias bp break
       end
 
       load_rc
@@ -1093,80 +1534,30 @@ module DEBUGGER__
   end
 
   def self.load_rc
-    ['./rdbgrc.rb', File.expand_path('~/.rdbgrc.rb')].each{|path|
-      if File.file? path
-        load path
-      end
-    }
-
-    # debug commands file
-    [init_script = ::DEBUGGER__::CONFIG[:init_script],
-     './.rdbgrc',
-     File.expand_path('~/.rdbgrc')].each{|path|
-       next unless path
+    [[File.expand_path('~/.rdbgrc'), true],
+     [File.expand_path('~/.rdbgrc.rb'), true],
+     # ['./.rdbgrc', true], # disable because of security concern
+     [CONFIG[:init_script], false],
+     ].each{|(path, rc)|
+      next unless path
+      next if rc && CONFIG[:no_rc] # ignore rc
 
       if File.file? path
-        ::DEBUGGER__::SESSION.add_initial_commands File.readlines(path)
-      elsif path == init_script
+        if path.end_with?('.rb')
+          load path
+        else
+          ::DEBUGGER__::SESSION.add_preset_commands path, File.readlines(path)
+        end
+      elsif !rc
         warn "Not found: #{path}"
       end
     }
 
     # given debug commands
-    if ::DEBUGGER__::CONFIG[:commands]
-      cmds = ::DEBUGGER__::CONFIG[:commands].split(';;')
-      ::DEBUGGER__::SESSION.add_initial_commands cmds
-    end
-  end
-
-  def self.parse_help
-    helps = Hash.new{|h, k| h[k] = []}
-    desc = cat = nil
-    cmds = []
-
-    File.read(__FILE__).each_line do |line|
-      case line
-      when /\A\s*### (.+)/
-        cat = $1
-        break if $1 == 'END'
-      when /\A      when (.+)/
-        next unless cat
-        next unless desc
-        ws = $1.split(/,\s*/).map{|e| e.gsub('\'', '')}
-        helps[cat] << [ws, desc]
-        desc = nil
-        cmds.concat ws
-      when /\A\s+# (\s*\*.+)/
-        if desc
-          desc << "\n" + $1
-        else
-          desc = $1
-        end
-      end
+    if CONFIG[:commands]
+      cmds = CONFIG[:commands].split(';;')
+      ::DEBUGGER__::SESSION.add_preset_commands "commands", cmds, kick: false, continue: false
     end
-    @commands = cmds
-    @helps = helps
-  end
-
-  def self.helps
-    (defined?(@helps) && @helps) || parse_help
-  end
-
-  def self.commands
-    (defined?(@commands) && @commands) || (parse_help; @commands)
-  end
-
-  def self.help
-    r = []
-    self.helps.each{|cat, cmds|
-      r << "### #{cat}"
-      r << ''
-      cmds.each{|ws, desc|
-        r << desc
-      }
-      r << ''
-    }
-    r.join("\n")
   end
 
   class ::Module
@@ -1194,4 +1585,99 @@ module DEBUGGER__
       str
     end
   end
+
+  LOG_LEVELS = {
+    UNKNOWN: 0,
+    FATAL:   1,
+    ERROR:   2,
+    WARN:    3,
+    INFO:    4,
+  }.freeze
+
+  def self.warn msg
+    log :WARN, msg
+  end
+
+  def self.info msg
+    log :INFO, msg
+  end
+
+  def self.log level, msg
+    lv = LOG_LEVELS[level]
+    config_lv = LOG_LEVELS[CONFIG[:log_level] || :WARN]
+
+    if lv <= config_lv
+      if level == :WARN
+        # :WARN on debugger is general information
+        STDERR.puts "DEBUGGER: #{msg}"
+      else
+        STDERR.puts "DEBUGGER (#{level}): #{msg}"
+      end
+    end
+  end
+
+  module ForkInterceptor
+    def fork(&given_block)
+      return super unless defined?(SESSION) && SESSION.active?
+
+      # before fork
+      if CONFIG[:parent_on_fork]
+        parent_hook = -> child_pid {
+          # Do nothing
+        }
+        child_hook = -> {
+          DEBUGGER__.warn "Detaching after fork from child process #{Process.pid}"
+          SESSION.deactivate
+        }
+      else
+        parent_pid = Process.pid
+
+        parent_hook = -> child_pid {
+          DEBUGGER__.warn "Detaching after fork from parent process #{Process.pid}"
+          SESSION.deactivate
+
+          at_exit{
+            trap(:SIGINT, :IGNORE)
+            Process.waitpid(child_pid)
+          }
+        }
+        child_hook = -> {
+          DEBUGGER__.warn "Attaching after process #{parent_pid} fork to child process #{Process.pid}"
+          SESSION.activate on_fork: true
+        }
+      end
+
+      if given_block
+        new_block = proc {
+          # after fork: child
+          child_hook.call
+          given_block.call
+        }
+        pid = super(&new_block)
+        parent_hook.call(pid)
+        pid
+      else
+        if pid = super
+          # after fork: parent
+          parent_hook.call pid
+        else
+          # after fork: child
+          child_hook.call
+        end
+
+        pid
+      end
+    end
+  end
+
+  class ::Object
+    include ForkInterceptor
+  end
+
+  module ::Process
+    class << self
+      prepend ForkInterceptor
+    end
+  end
 end
+