debug 1.6.1 → 1.9.1

data/lib/debug/dap_custom/traceInspector.rb

@@ -0,0 +1,336 @@
+module DEBUGGER__
+  module DAP_TraceInspector
+    class MultiTracer < Tracer
+      def initialize ui, evts, trace_params, max_log_size: nil, **kw
+        @evts = evts
+        @log = []
+        @trace_params = trace_params
+        if max_log_size
+          @max_log_size = max_log_size
+        else
+          @max_log_size = 50000
+        end
+        @dropped_trace_cnt = 0
+        super(ui, **kw)
+        @type = 'multi'
+        @name = 'TraceInspector'
+      end
+  
+      attr_accessor :dropped_trace_cnt
+      attr_reader :log
+  
+      def setup
+        @tracer = TracePoint.new(*@evts){|tp|
+          next if skip?(tp)
+  
+          case tp.event
+          when :call, :c_call, :b_call
+            if @trace_params
+              params = parameters_info tp
+            end
+            append(call_trace_log(tp, params: params))
+          when :return, :c_return, :b_return
+            return_str = DEBUGGER__.safe_inspect(tp.return_value, short: true, max_length: 4096)
+            append(call_trace_log(tp, return_str: return_str))
+          when :line
+            append(line_trace_log(tp))
+          end
+        }
+      end
+
+      def parameters_info tp
+        b = tp.binding
+        tp.parameters.map{|_type, name|
+          begin
+            { name: name, value: DEBUGGER__.safe_inspect(b.local_variable_get(name), short: true, max_length: 4096) }
+          rescue NameError, TypeError
+            nil
+          end
+        }.compact
+      end
+  
+      def call_identifier_str tp
+        if tp.defined_class
+          minfo(tp)
+        else
+          "block"
+        end
+      end
+  
+      def append log
+        if @log.size >= @max_log_size
+          @dropped_trace_cnt += 1
+          @log.shift
+        end
+        @log << log
+      end
+  
+      def call_trace_log tp, return_str: nil, params: nil
+        log = {
+          depth: DEBUGGER__.frame_depth,
+          name: call_identifier_str(tp),
+          threadId: Thread.current.instance_variable_get(:@__thread_client_id),
+          location: {
+            path: tp.path,
+            line: tp.lineno
+          }
+        }
+        log[:returnValue] = return_str if return_str
+        log[:parameters] = params if params && params.size > 0
+        log
+      end
+  
+      def line_trace_log tp
+        {
+          depth: DEBUGGER__.frame_depth,
+          threadId: Thread.current.instance_variable_get(:@__thread_client_id),
+          location: {
+            path: tp.path,
+            line: tp.lineno
+          }
+        }
+      end
+  
+      def skip? tp
+        super || !@evts.include?(tp.event)
+      end
+
+      def skip_with_pattern?(tp)
+        super && !tp.method_id&.match?(@pattern)
+      end
+    end
+
+    class Custom_Recorder < ThreadClient::Recorder
+      def initialize max_log_size: nil
+        if max_log_size
+          @max_log_size = max_log_size
+        else
+          @max_log_size = 50000
+        end
+        @dropped_trace_cnt = 0
+        super()
+      end
+
+      attr_accessor :dropped_trace_cnt
+
+      def append frames
+        if @log.size >= @max_log_size
+          @dropped_trace_cnt += 1
+          @log.shift
+        end
+        @log << frames
+      end
+    end
+
+    module Custom_UI_DAP
+      def custom_dap_request_rdbgTraceInspector(req)
+        @q_msg << req
+      end
+    end
+
+    module Custom_Session
+      def process_trace_cmd req
+        cmd = req.dig('arguments', 'subCommand')
+        case cmd
+        when 'enable'
+          events = req.dig('arguments', 'events')
+          evts = []
+          trace_params = false
+          filter = req.dig('arguments', 'filterRegExp')
+          max_log_size = req.dig('arguments', 'maxLogSize')
+          events.each{|evt|
+            case evt
+            when 'traceLine'
+              evts << :line
+            when 'traceCall'
+              evts << :call
+              evts << :b_call
+            when 'traceReturn'
+              evts << :return
+              evts << :b_return
+            when 'traceParams'
+              trace_params = true
+            when 'traceClanguageCall'
+              evts << :c_call
+            when 'traceClanguageReturn'
+              evts << :c_return
+            else
+              raise "unknown trace type #{evt}"
+            end
+          }
+          add_tracer MultiTracer.new @ui, evts, trace_params, max_log_size: max_log_size, pattern: filter
+          @ui.respond req, {}
+        when 'disable'
+          if t = find_multi_trace
+            t.disable
+          end
+          @ui.respond req, {}
+        when 'collect'
+          logs = []
+          if t = find_multi_trace
+            logs = t.log
+            if t.dropped_trace_cnt > 0
+              @ui.puts "Return #{logs.size} traces and #{t.dropped_trace_cnt} traces are dropped"
+            else
+              @ui.puts "Return #{logs.size} traces"
+            end
+            t.dropped_trace_cnt = 0
+          end
+          @ui.respond req, logs: logs
+        else
+          raise "Unknown trace sub command #{cmd}"
+        end
+        return :retry
+      end
+
+      def find_multi_trace
+        @tracers.values.each{|t|
+          if t.type == 'multi'
+            return t
+          end
+        }
+        return nil
+      end
+
+      def process_record_cmd req
+        cmd = req.dig('arguments', 'subCommand')
+        case cmd
+        when 'enable'
+          @tc << [:dap, :rdbgTraceInspector, req]
+        when 'disable'
+          @tc << [:dap, :rdbgTraceInspector, req]
+        when 'step'
+          tid = req.dig('arguments', 'threadId')
+          count = req.dig('arguments', 'count')
+          if tc = find_waiting_tc(tid)
+            @ui.respond req, {}
+            tc << [:step, :in, count]
+          else
+            fail_response req
+          end
+        when 'stepBack'
+          tid = req.dig('arguments', 'threadId')
+          count = req.dig('arguments', 'count')
+          if tc = find_waiting_tc(tid)
+            @ui.respond req, {}
+            tc << [:step, :back, count]
+          else
+            fail_response req
+          end
+        when 'collect'
+          tid = req.dig('arguments', 'threadId')
+          if tc = find_waiting_tc(tid)
+            tc << [:dap, :rdbgTraceInspector, req]
+          else
+            fail_response req
+          end
+        else
+          raise "Unknown record sub command #{cmd}"
+        end
+      end
+
+      def custom_dap_request_rdbgTraceInspector(req)
+        cmd = req.dig('arguments', 'command')
+        case cmd
+        when 'trace'
+          process_trace_cmd req
+        when 'record'
+          process_record_cmd req
+        else
+          raise "Unknown command #{cmd}"
+        end
+      end
+
+      def custom_dap_request_event_rdbgTraceInspector(req, result)
+        cmd = req.dig('arguments', 'command')
+        case cmd
+        when 'record'
+          process_event_record_cmd(req, result)
+        else
+          raise "Unknown command #{cmd}"
+        end
+      end
+
+      def process_event_record_cmd(req, result)
+        cmd = req.dig('arguments', 'subCommand')
+        case cmd
+        when 'enable'
+          @ui.respond req, {}
+        when 'disable'
+          @ui.respond req, {}
+        when 'collect'
+          cnt = result.delete :dropped_trace_cnt
+          if cnt > 0
+            @ui.puts "Return #{result[:logs].size} traces and #{cnt} traces are dropped"
+          else
+            @ui.puts "Return #{result[:logs].size} traces"
+          end
+          @ui.respond req, result
+        else
+          raise "Unknown command #{cmd}"
+        end
+      end
+    end
+
+    module Custom_ThreadClient
+      def custom_dap_request_rdbgTraceInspector(req)
+        cmd = req.dig('arguments', 'command')
+        case cmd
+        when 'record'
+          process_record_cmd(req)
+        else
+          raise "Unknown command #{cmd}"
+        end
+      end
+
+      def process_record_cmd(req)
+        cmd = req.dig('arguments', 'subCommand')
+        case cmd
+        when 'enable'
+          size = req.dig('arguments', 'maxLogSize')
+          @recorder = Custom_Recorder.new max_log_size: size
+          @recorder.enable
+          event! :protocol_result, :rdbgTraceInspector, req
+        when 'disable'
+          if @recorder&.enabled?
+            @recorder.disable
+          end
+          @recorder = nil
+          event! :protocol_result, :rdbgTraceInspector, req
+        when 'collect'
+          logs = []
+          log_index = nil
+          trace_cnt = 0
+          unless @recorder.nil?
+            log_index = @recorder.log_index
+            @recorder.log.each{|frames|
+              crt_frame = frames[0]
+              log = {
+                name: crt_frame.name,
+                location: {
+                  path: crt_frame.location.path,
+                  line: crt_frame.location.lineno,
+                },
+                depth: crt_frame.frame_depth
+              }
+              if params = crt_frame.iseq_parameters_info
+                log[:parameters] = params
+              end
+              if return_str = crt_frame.return_str
+                log[:returnValue] = return_str
+              end
+              logs << log
+            }
+            trace_cnt = @recorder.dropped_trace_cnt
+            @recorder.dropped_trace_cnt = 0
+          end
+          event! :protocol_result, :rdbgTraceInspector, req, logs: logs, stoppedIndex: log_index, dropped_trace_cnt: trace_cnt
+        else
+          raise "Unknown command #{cmd}"
+        end
+      end
+    end
+
+    ::DEBUGGER__::SESSION.extend_feature session: Custom_Session, thread_client: Custom_ThreadClient, ui: Custom_UI_DAP
+  end
+end

data/lib/debug/frame_info.rb

@@ -147,6 +147,15 @@ module DEBUGGER__
       end
     end
 
+    def iseq_parameters_info
+      case frame_type
+      when :block, :method
+        parameters_info
+      else
+        nil
+      end
+    end
+
     def parameters_info
       vars = iseq.parameters_symbols
       vars.map{|var|

data/lib/debug/irb_integration.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'irb'
+
+module DEBUGGER__
+  module IrbPatch
+    def evaluate(line, line_no)
+      SESSION.send(:restart_all_threads)
+      super
+      # This is to communicate with the test framework so it can feed the next input
+      puts "INTERNAL_INFO: {}" if ENV['RUBY_DEBUG_TEST_UI'] == 'terminal'
+    ensure
+      SESSION.send(:stop_all_threads)
+    end
+  end
+
+  class ThreadClient
+    def activate_irb_integration
+      IRB.setup(location, argv: [])
+      workspace = IRB::WorkSpace.new(current_frame&.binding || TOPLEVEL_BINDING)
+      irb = IRB::Irb.new(workspace)
+      IRB.conf[:MAIN_CONTEXT] = irb.context
+      IRB::Debug.setup(irb)
+      IRB::Context.prepend(IrbPatch)
+    end
+  end
+end

data/lib/debug/local.rb

@@ -13,23 +13,28 @@ module DEBUGGER__
       false
     end
 
-    def activate session, on_fork: false
-      unless CONFIG[:no_sigint_hook]
-        prev_handler = trap(:SIGINT){
-          if session.active?
-            ThreadClient.current.on_trap :SIGINT
-          end
-        }
-        session.intercept_trap_sigint_start prev_handler
-      end
+    def activate_sigint
+      prev_handler = trap(:SIGINT){
+        if SESSION.active?
+          ThreadClient.current.on_trap :SIGINT
+        end
+      }
+      SESSION.intercept_trap_sigint_start prev_handler
     end
 
-    def deactivate
+    def deactivate_sigint
       if SESSION.intercept_trap_sigint?
         prev = SESSION.intercept_trap_sigint_end
         trap(:SIGINT, prev)
       end
+    end
+
+    def activate session, on_fork: false
+      activate_sigint unless CONFIG[:no_sigint_hook]
+    end
 
+    def deactivate
+      deactivate_sigint
       @console.deactivate
     end
 
@@ -42,6 +47,7 @@ module DEBUGGER__
     end
 
     def quit n
+      yield
       exit n
     end
 

data/lib/debug/prelude.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-return if defined?(::DEBUGGER__)
+return if ENV['RUBY_DEBUG_ENABLE'] == '0'
+return if defined?(::DEBUGGER__::Session)
 
 # Put the following line in your login script (e.g. ~/.bash_profile) with modified path:
 #

data/lib/debug/server.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'socket'
-require 'etc'
 require_relative 'config'
 require_relative 'version'
 
@@ -22,6 +21,7 @@ module DEBUGGER__
 
     class Terminate < StandardError; end
     class GreetingError < StandardError; end
+    class RetryConnection < StandardError; end
 
     def deactivate
       @reader_thread.raise Terminate
@@ -78,6 +78,8 @@ module DEBUGGER__
           next
         rescue Terminate
           raise # should catch at outer scope
+        rescue RetryConnection
+          next
         rescue => e
           DEBUGGER__.warn "ReaderThreadError: #{e}"
           pp e.backtrace
@@ -128,8 +130,10 @@ module DEBUGGER__
     def greeting
       case g = @sock.gets
       when /^info cookie:\s+(.*)$/
+        require 'etc'
+
         check_cookie $1
-        @sock.puts "PID: #{Process.pid}, $0: #{$0}"
+        @sock.puts "PID: #{Process.pid}, $0: #{$0}, session_name: #{CONFIG[:session_name]}"
         @sock.puts "debug #{VERSION} on #{RUBY_DESCRIPTION}"
         @sock.puts "uname: #{Etc.uname.inspect}"
         @sock.close
@@ -140,11 +144,14 @@ module DEBUGGER__
 
         # TODO: protocol version
         if v != VERSION
-          raise GreetingError, "Incompatible version (server:#{VERSION} and client:#{$1})"
+          @sock.puts msg = "out DEBUGGER: Incompatible version (server:#{VERSION} and client:#{$1})"
+          raise GreetingError, msg
         end
         parse_option(params)
 
-        puts "DEBUGGER (client): Connected. PID:#{Process.pid}, $0:#{$0}"
+        session_name = CONFIG[:session_name]
+        session_name_str = ", session_name:#{session_name}" if session_name
+        puts "DEBUGGER (client): Connected. PID:#{Process.pid}, $0:#{$0}#{session_name_str}"
         puts "DEBUGGER (client): Type `Ctrl-C` to enter the debug console." unless @need_pause_at_first
         puts
 
@@ -157,16 +164,13 @@ module DEBUGGER__
         @need_pause_at_first = false
         dap_setup @sock.read($1.to_i)
 
-      when /^GET \/.* HTTP\/1.1/
+      when /^GET\s\/json\sHTTP\/1.1/, /^GET\s\/json\/version\sHTTP\/1.1/, /^GET\s\/\w{8}-\w{4}-\w{4}-\w{4}-\w{12}\sHTTP\/1.1/
+        # The reason for not using @uuid here is @uuid is nil if users run debugger without `--open=chrome`.
+
         require_relative 'server_cdp'
 
         self.extend(UI_CDP)
-        @repl = false
-        @need_pause_at_first = false
-        CONFIG.set_config no_color: true
-
-        @ws_server = UI_CDP::WebSocketServer.new(@sock)
-        @ws_server.handshake
+        send_chrome_response g
       else
         raise GreetingError, "Unknown greeting message: #{g}"
       end
@@ -174,17 +178,17 @@ module DEBUGGER__
 
     def process
       while true
-        DEBUGGER__.info "sleep IO.select"
-        r = IO.select([@sock])
-        DEBUGGER__.info "wakeup IO.select"
+        DEBUGGER__.debug{ "sleep IO.select" }
+        _r = IO.select([@sock])
+        DEBUGGER__.debug{ "wakeup IO.select" }
 
         line = @session.process_group.sync do
           unless IO.select([@sock], nil, nil, 0)
-            DEBUGGER__.info "UI_Server can not read"
+            DEBUGGER__.debug{ "UI_Server can not read" }
             break :can_not_read
           end
           @sock.gets&.chomp.tap{|line|
-            DEBUGGER__.info "UI_Server received: #{line}"
+            DEBUGGER__.debug{ "UI_Server received: #{line}" }
           }
         end
 
@@ -340,12 +344,12 @@ module DEBUGGER__
         if @repl
           raise "not in subsession, but received: #{line.inspect}" unless @session.in_subsession?
           line = "input #{Process.pid}"
-          DEBUGGER__.info "send: #{line}"
+          DEBUGGER__.debug{ "send: #{line}" }
           s.puts line
         end
         sleep 0.01 until @q_msg
         @q_msg.pop.tap{|msg|
-          DEBUGGER__.info "readline: #{msg.inspect}"
+          DEBUGGER__.debug{ "readline: #{msg.inspect}" }
         }
       end || 'continue')
 
@@ -361,7 +365,7 @@ module DEBUGGER__
       Process.kill(TRAP_SIGNAL, Process.pid)
     end
 
-    def quit n
+    def quit n, &_b
       # ignore n
       sock do |s|
         s.puts "quit"
@@ -395,6 +399,7 @@ module DEBUGGER__
           raise "Specify digits for port number"
         end
       end
+      @uuid = nil # for CDP
 
       super()
     end
@@ -402,14 +407,14 @@ module DEBUGGER__
     def chrome_setup
       require_relative 'server_cdp'
 
-      unless @chrome_pid = UI_CDP.setup_chrome(@local_addr.inspect_sockaddr)
-        DEBUGGER__.warn <<~EOS
-          With Chrome browser, type the following URL in the address-bar:
+      @uuid = SecureRandom.uuid
+      @chrome_pid = UI_CDP.setup_chrome(@local_addr.inspect_sockaddr, @uuid)
+      DEBUGGER__.warn <<~EOS
+        With Chrome browser, type the following URL in the address-bar:
 
-             devtools://devtools/bundled/inspector.html?v8only=true&panel=sources&ws=#{@local_addr.inspect_sockaddr}/#{SecureRandom.uuid}
+           devtools://devtools/bundled/inspector.html?v8only=true&panel=sources&noJavaScriptCompletion=true&ws=#{@local_addr.inspect_sockaddr}/#{@uuid}
 
-          EOS
-      end
+        EOS
     end
 
     def accept
@@ -434,7 +439,7 @@ module DEBUGGER__
           #
           EOS
 
-          case CONFIG[:open_frontend]
+          case CONFIG[:open]
           when 'chrome'
             chrome_setup
           when 'vscode'
@@ -491,7 +496,7 @@ module DEBUGGER__
       end
 
       ::DEBUGGER__.warn "Debugger can attach via UNIX domain socket (#{@sock_path})"
-      vscode_setup @sock_path if CONFIG[:open_frontend] == 'vscode'
+      vscode_setup @sock_path if CONFIG[:open] == 'vscode'
 
       begin
         Socket.unix_server_loop @sock_path do |sock, client|