debug 1.0.0.beta8 → 1.1.0

data/lib/debug/server_dap.rb

@@ -7,7 +7,7 @@ module DEBUGGER__
     SHOW_PROTOCOL = ENV['RUBY_DEBUG_DAP_SHOW_PROTOCOL'] == '1'
 
     def dap_setup bytes
-      DEBUGGER__.set_config(no_color: true)
+      CONFIG.set_config no_color: true
       @seq = 0
 
       $stderr.puts '[>]' + bytes if SHOW_PROTOCOL
@@ -37,6 +37,7 @@ module DEBUGGER__
                },
              ],
              supportsExceptionFilterOptions: true,
+             supportsStepBack: true,
 
              ## Will be supported
              # supportsExceptionOptions: true,
@@ -50,7 +51,6 @@ module DEBUGGER__
              # supportsBreakpointLocationsRequest:
 
              ## Possible?
-             # supportsStepBack:
              # supportsRestartFrame:
              # supportsCompletionsRequest:
              # completionTriggerCharacters:
@@ -153,8 +153,8 @@ module DEBUGGER__
         when 'setFunctionBreakpoints'
           send_response req
         when 'setExceptionBreakpoints'
-          filters = args.dig('filterOptions').map{|bp_info|
-            case bp_info.dig('filterId')
+          process_filter = ->(filter_id) {
+            case filter_id
             when 'any'
               bp = SESSION.add_catch_breakpoint 'Exception'
             when 'RuntimeError'
@@ -163,10 +163,19 @@ module DEBUGGER__
               bp = nil
             end
             {
-              verifiled: bp ? true : false,
+              verified: bp ? true : false,
               message: bp.inspect,
             }
           }
+
+          filters = args.fetch('filters').map {|filter_id|
+            process_filter.call(filter_id)
+          }
+
+          filters += args.fetch('filterOptions', {}).map{|bp_info|
+            process_filter.call(bp_info.dig('filterId'))
+          }
+
           send_response req, breakpoints: filters
         when 'configurationDone'
           send_response req
@@ -197,6 +206,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'
@@ -212,6 +227,7 @@ module DEBUGGER__
              'evaluate',
              'source'
           @q_msg << req
+
         else
           raise "Unknown request: #{req.inspect}"
         end
@@ -220,7 +236,7 @@ module DEBUGGER__
 
     ## called by the SESSION thread
 
-    def readline
+    def readline prompt
       @q_msg.pop || 'kill!'
     end
 
@@ -281,6 +297,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)
@@ -340,7 +363,7 @@ module DEBUGGER__
               fail_response req
             end
           else
-            raise "Uknown type: #{ref.inspect}"
+            raise "Unknown type: #{ref.inspect}"
           end
         else
           fail_response req
@@ -365,7 +388,6 @@ module DEBUGGER__
         else
           fail_response req, message: 'not found...'
         end
-
         return :retry
       else
         raise "Unknown DAP request: #{req.inspect}"
@@ -438,8 +460,8 @@ module DEBUGGER__
       when :backtrace
         event! :dap_result, :backtrace, req, {
           stackFrames: @target_frames.map.with_index{|frame, i|
-            path = frame.realpath
-            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
@@ -457,7 +479,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',
@@ -485,6 +515,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
@@ -555,7 +589,7 @@ module DEBUGGER__
         end
         event! :dap_result, :evaluate, req, tid: self.id, **evaluate_result(result)
       else
-        raise "Unkown req: #{args.inspect}"
+        raise "Unknown req: #{args.inspect}"
       end
     end
 

data/lib/debug/session.rb

@@ -1,12 +1,31 @@
 # frozen_string_literal: true
 
 # skip to load debugger for bundle exec
-return if $0.end_with?('bin/bundle') && ARGV.first == 'exec'
+
+if $0.end_with?('bin/bundle') && ARGV.first == 'exec'
+  trace_var(:$0) do |file|
+    trace_var(:$0, nil)
+    if /-r (#{__dir__}\S+)/ =~ ENV['RUBYOPT']
+      lib = $1
+      $LOADED_FEATURES.delete_if{|path| path.start_with?(__dir__)}
+      ENV['RUBY_DEBUG_INITIAL_SUSPEND_PATH'] = file
+      require lib
+      ENV['RUBY_DEBUG_INITIAL_SUSPEND_PATH'] = nil
+    end
+  end
+
+  return
+end
 
 require_relative 'config'
 require_relative 'thread_client'
 require_relative 'source_repository'
 require_relative 'breakpoint'
+require_relative 'tracer'
+
+# To prevent loading old lib/debug.rb in Ruby 2.6 to 3.0
+$LOADED_FEATURES << 'debug.rb'
+require 'debug' # invalidate the $LOADED_FEATURE cache
 
 require 'json' if ENV['RUBY_DEBUG_TEST_MODE']
 
@@ -54,6 +73,7 @@ end
 
 module DEBUGGER__
   PresetCommand = Struct.new(:commands, :source, :auto_continue)
+  class PostmortemError < RuntimeError; end
 
   class Session
     def initialize ui
@@ -65,71 +85,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
       @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 active?
-      @ui ? true : false
+    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
-      @management_threads << @ui.reader_thread if @ui.respond_to? :reader_thread
+    end
+
+    def pop_event
+      @q_evt.pop
     end
 
     def session_server_main
-      while evt = @q_evt.pop
-        # varible `@internal_info` is only used for test
+      while evt = pop_event
+        # variable `@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
@@ -142,10 +216,12 @@ 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 :try_display
@@ -156,14 +232,22 @@ module DEBUGGER__
                 @ui.puts "canceled: #{@displays.pop}"
               end
             end
+            stop_all_threads
+
           when :method_breakpoint, :watch_breakpoint
             bp = ev_args[1]
             if bp
-              add_breakpoint(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
@@ -176,27 +260,24 @@ module DEBUGGER__
         end
       end
     ensure
-      @tp_load_script.disable
-      @tp_thread_begin.disable
-      @bps.each{|k, bp| bp.disable}
-      @th_clients.each{|th, thc| thc.close}
-      @ui = nil
+      deactivate
     end
 
     def add_preset_commands name, cmds, kick: true, continue: true
       cs = cmds.map{|c|
-        c = c.strip.gsub(/\A\s*\#.*/, '').strip
-        c unless c.empty?
-      }.compact
-
-      unless cs.empty?
-        if @preset_command
-          @preset_command.commands += cs
-        else
-          @preset_command = PresetCommand.new(cs, name, continue)
-        end
-        ThreadClient.current.on_init name if kick
+        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
@@ -213,20 +294,26 @@ 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
@@ -234,7 +321,9 @@ module DEBUGGER__
         if @preset_command.commands.empty?
           if @preset_command.auto_continue
             @preset_command = nil
+
             @tc << :continue
+            restart_all_threads
             return
           else
             @preset_command = nil
@@ -246,7 +335,7 @@ module DEBUGGER__
         end
       else
         @ui.puts "INTERNAL_INFO: #{JSON.generate(@internal_info)}" if ENV['RUBY_DEBUG_TEST_MODE']
-        line = @ui.readline
+        line = @ui.readline prompt
       end
 
       case line
@@ -280,27 +369,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'
         cancel_auto_continue
-        @tc << [:step, :in]
+        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'
         cancel_auto_continue
-        @tc << [:step, :next]
+        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'
         cancel_auto_continue
-        @tc << [:step, :finish]
+        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).
@@ -308,6 +407,7 @@ module DEBUGGER__
         if ask 'Really quit?'
           @ui.quit arg.to_i
           @tc << :continue
+          restart_all_threads
         else
           return :retry
         end
@@ -316,7 +416,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!`.
@@ -354,6 +454,8 @@ module DEBUGGER__
       #   * 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
@@ -370,6 +472,7 @@ module DEBUGGER__
 
       # skip
       when 'bv'
+        check_postmortem
         require 'json'
 
         h = Hash.new{|h, k| h[k] = []}
@@ -396,8 +499,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
@@ -408,6 +513,8 @@ 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'
+        check_postmortem
+
         if arg && arg.match?(/\A@\w+/)
           @tc << [:breakpoint, :watch, arg]
         else
@@ -420,15 +527,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
@@ -501,25 +610,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 instance 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>`
@@ -581,10 +722,16 @@ module DEBUGGER__
       when 'pp'
         @tc << [:eval, :pp, arg.to_s]
 
-      # * `e[val] <expr>`
+      # * `eval <expr>`
       #   * Evaluate `<expr>` on the current frame.
-      when 'e', 'eval', 'call'
-        @tc << [:eval, :call, arg]
+      when 'eval', 'call'
+        if arg == nil || arg.empty?
+          show_help 'eval'
+          @ui.puts "\nTo evaluate the variable `#{cmd}`, use `pp #{cmd}` instead."
+          return :retry
+        else
+          @tc << [:eval, :call, arg]
+        end
 
       # * `irb`
       #   * Invoke `irb` on the current frame.
@@ -598,6 +745,105 @@ module DEBUGGER__
         # 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]`
@@ -630,13 +876,28 @@ module DEBUGGER__
         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
@@ -646,21 +907,56 @@ 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]
@@ -682,9 +978,9 @@ module DEBUGGER__
       if CONFIG_SET[key = key.to_sym]
         begin
           if append
-            DEBUGGER__.append_config(key, val)
+            CONFIG.append_config(key, val)
           else
-            DEBUGGER__.set_config({key => val})
+            CONFIG[key] = val
           end
         rescue => e
           @ui.puts e.message
@@ -703,7 +999,7 @@ module DEBUGGER__
 
       when /\Aunset\s+(.+)\z/
         if CONFIG_SET[key = $1.to_sym]
-          DEBUGGER__.set_config({key => nil})
+          CONFIG[key] = nil
         end
         config_show key
 
@@ -758,51 +1054,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 = []
@@ -834,7 +1086,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}
@@ -873,14 +1147,14 @@ module DEBUGGER__
 
       case expr[:sig]
       when /\A(\d+)\z/
-        add_line_breakpoint @tc.location.path, $1.to_i, cond: expr[:if], command: cmd
+        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: expr[:if], command: cmd
+        add_line_breakpoint $1, $2.to_i, cond: cond, command: cmd
       when /\A(.+)([\.\#])(.+)\z/
-        @tc << [:breakpoint, :method, $1, $2, $3, expr[:if], cmd]
+        @tc << [:breakpoint, :method, $1, $2, $3, cond, cmd]
         return :noretry
       when nil
-        add_check_breakpoint expr[:if]
+        add_check_breakpoint cond
       else
         @ui.puts "Unknown breakpoint format: #{arg}"
         @ui.puts
@@ -888,6 +1162,34 @@ 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_catch_breakpoint pat
+      bp = CatchBreakpoint.new(pat)
+      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
@@ -896,17 +1198,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
 
@@ -933,7 +1233,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."
@@ -947,11 +1247,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
@@ -963,8 +1263,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
@@ -972,84 +1271,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
-      DEBUGGER__.info "Load #{iseq.absolute_path || iseq.path}"
-      @sr.add iseq, src
-
-      pending_line_breakpoints do |bp|
-        if bp.path == (iseq.absolute_path || iseq.path)
-          bp.try_activate
-        end
-      end
+    private def running_thread_clients_count
+      @th_clients.count{|th, tc|
+        next if tc.management?
+        next unless tc.running?
+        true
+      }
     end
 
-    # breakpoint management
+    private def waiting_thread_clients
+      @th_clients.map{|th, tc|
+        next if tc.management?
+        next unless tc.waiting?
+        tc
+      }.compact
+    end
 
-    def add_breakpoint bp
-      # don't repeat commands that add breakpoints
-      @repl_prev_line = nil
+    private def stop_all_threads
+      return if running_thread_clients_count == 0
 
-      if @bps.has_key? bp.key
-        unless bp.duplicable?
-          @ui.puts "duplicated breakpoint: #{bp}"
-          bp.disable
-        end
-      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
@@ -1070,23 +1352,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
@@ -1115,10 +1380,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
@@ -1165,18 +1475,18 @@ module DEBUGGER__
   # start methods
 
   def self.start nonstop: false, **kw
-    set_config(kw)
+    CONFIG.set_config(**kw)
 
     unless defined? SESSION
-      require_relative 'console'
-      initialize_session UI_Console.new
+      require_relative 'local'
+      initialize_session UI_LocalConsole.new
     end
 
     setup_initial_suspend unless nonstop
   end
 
-  def self.open host: nil, port: ::DEBUGGER__::CONFIG[:port], sock_path: nil, sock_dir: nil, nonstop: false, **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, nonstop: nonstop
@@ -1186,7 +1496,7 @@ module DEBUGGER__
   end
 
   def self.open_tcp host: nil, port:, nonstop: false, **kw
-    set_config(kw)
+    CONFIG.set_config(**kw)
     require_relative 'server'
 
     if defined? SESSION
@@ -1199,7 +1509,7 @@ module DEBUGGER__
   end
 
   def self.open_unix sock_path: nil, sock_dir: nil, nonstop: false, **kw
-    set_config(kw)
+    CONFIG.set_config(**kw)
     require_relative 'server'
 
     if defined? SESSION
@@ -1214,42 +1524,24 @@ module DEBUGGER__
   # boot utilities
 
   def self.setup_initial_suspend
-    if !::DEBUGGER__::CONFIG[:nonstop]
-      if loc = ::DEBUGGER__.require_location
-        # require 'debug/console' or 'debug'
+    if !CONFIG[:nonstop]
+      case
+      when path = ENV['RUBY_DEBUG_INITIAL_SUSPEND_PATH']
+        add_line_breakpoint path, 0, oneshot: true, hook_call: false
+      when 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, 1, oneshot: true, hook_call: false
+        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__.info "Session start (pid: #{Process.pid})"
       ::DEBUGGER__.const_set(:SESSION, Session.new(ui))
-
-      # default breakpoints
-
-      # ::DEBUGGER__.add_catch_breakpoint 'RuntimeError'
-
-      Binding.module_eval do
-        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, command: cmds
-          true
-        end
-        alias b break
-        # alias bp break
-      end
-
       load_rc
     end
   end
@@ -1258,10 +1550,10 @@ module DEBUGGER__
     [[File.expand_path('~/.rdbgrc'), true],
      [File.expand_path('~/.rdbgrc.rb'), true],
      # ['./.rdbgrc', true], # disable because of security concern
-     [::DEBUGGER__::CONFIG[:init_script], false],
+     [CONFIG[:init_script], false],
      ].each{|(path, rc)|
       next unless path
-      next if rc && ::DEBUGGER__::CONFIG[:no_rc] # ignore rc
+      next if rc && CONFIG[:no_rc] # ignore rc
 
       if File.file? path
         if path.end_with?('.rb')
@@ -1275,62 +1567,12 @@ module DEBUGGER__
     }
 
     # given debug commands
-    if ::DEBUGGER__::CONFIG[:commands]
-      cmds = ::DEBUGGER__::CONFIG[:commands].split(';;')
+    if CONFIG[:commands]
+      cmds = CONFIG[:commands].split(';;')
       ::DEBUGGER__::SESSION.add_preset_commands "commands", cmds, kick: false, continue: false
     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
-    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
     undef method_added
     def method_added mid; end
@@ -1357,14 +1599,6 @@ module DEBUGGER__
     end
   end
 
-  LOG_LEVELS = {
-    UNKNOWN: 0,
-    FATAL:   1,
-    ERROR:   2,
-    WARN:    3,
-    INFO:    4,
-  }.freeze
-
   def self.warn msg
     log :WARN, msg
   end
@@ -1386,4 +1620,97 @@ module DEBUGGER__
       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
+
+class Binding
+  def break pre: nil, do: nil
+    return if !defined?(::DEBUGGER__::SESSION) || !::DEBUGGER__::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, command: cmds
+    self
+  end
+  alias b break
+end
+
+module Kernel
+  if RUBY_VERSION >= '2.7.0'
+    eval <<~RUBY, binding, __FILE__, __LINE__
+      def debugger(...)
+        binding.break(...)
+      end
+    RUBY
+  else
+    def debugger pre: nil, do: nil
+      b = binding
+      b.break pre: pre, do: b.local_variable_get(:do)
+    end
+  end
 end