feat: Add :conndebug command which shows connection debug info

dimonomid · dimonomid · commit 9bae82966703 · 2025-06-08T16:45:46.000+03:00
It will be even more useful once we add support for external ssh, to
easily see how exactly Nerdlog is trying to connect to logstreams.
diff --git a/README.md b/README.md
@@ -316,7 +316,9 @@ can be done from the Menu too, or using a keyboard shortcut `Alt+Ctrl+R` or
 
 `:disconnect` Disconnect from all logstreams
 
-`:debug` Show debug info for the last query
+`:conndebug` or `:cdebug` Show debug info for the current logstream connections
+
+`:querydebug` or `:qdebug` or just `:debug` Show debug info for the last query
 
 `:version` or `:about` Show version info
 
diff --git a/cmd/nerdlog/cmdline.go b/cmd/nerdlog/cmdline.go
@@ -170,7 +170,10 @@ func (app *nerdlogApp) handleCmd(cmd string) {
 			refreshIndex: true,
 		})
 
-	case "debug":
+	case "conndebug", "cdebug":
+		app.mainView.showConnDebugInfo()
+
+	case "querydebug", "qdebug", "debug":
 		app.mainView.showLastQueryDebugInfo()
 
 	case "version", "about":
diff --git a/cmd/nerdlog/main_view.go b/cmd/nerdlog/main_view.go
@@ -1036,6 +1036,10 @@ func (mv *MainView) applyHMState(lsmanState *core.LStreamsManagerState) {
 
 		for _, logstream := range logstreams {
 			connDetails := lsmanState.ConnDetailsByLStream[logstream]
+			if connDetails.Err == "" {
+				continue
+			}
+
 			sb.WriteString("\n")
 			sb.WriteString(fmt.Sprintf("%s: %s", logstream, connDetails.Err))
 		}
@@ -1346,6 +1350,61 @@ func (mv *MainView) showLastQueryDebugInfo() {
 	})
 }
 
+func (mv *MainView) getConnDebugInfo() string {
+	if mv.curHMState == nil {
+		return "-- No connection info --"
+	}
+
+	cdbs := mv.curHMState.ConnDetailsByLStream
+
+	lstreamNames := make([]string, 0, len(cdbs))
+	for lstreamName := range cdbs {
+		lstreamNames = append(lstreamNames, lstreamName)
+	}
+	sort.Strings(lstreamNames)
+
+	var sb strings.Builder
+
+	for _, lstreamName := range lstreamNames {
+		connDetails := cdbs[lstreamName]
+		if len(connDetails.Messages) > 0 {
+			if sb.Len() > 0 {
+				sb.WriteString("\n")
+			}
+
+			sb.WriteString(fmt.Sprintf("%s connection messages:\n", lstreamName))
+			for _, message := range connDetails.Messages {
+				sb.WriteString(message)
+				sb.WriteString("\n")
+			}
+		}
+
+		if connDetails.Err != "" {
+			if sb.Len() > 0 {
+				sb.WriteString("\n")
+			}
+
+			sb.WriteString(fmt.Sprintf("%s connection error: %s\n", lstreamName, connDetails.Err))
+		}
+	}
+
+	ret := sb.String()
+	if ret == "" {
+		ret = "-- No connection info --"
+	}
+
+	return ret
+}
+
+func (mv *MainView) showConnDebugInfo() {
+	text := mv.getConnDebugInfo()
+
+	mv.showMessagebox("conn_debug_info", "Connection debug info", text, &MessageboxParams{
+		BackgroundColor: tcell.ColorDarkBlue,
+		CopyButton:      true,
+	})
+}
+
 func (mv *MainView) formatLogs() {
 	resp := mv.curLogResp
 	if resp == nil {
diff --git a/cmd/nerdlog/menu.go b/cmd/nerdlog/menu.go
@@ -7,43 +7,49 @@ type menuItem struct {
 
 var mainMenu = []menuItem{
 	{
-		Title: "Back                 <Alt+Left> ",
+		Title: "Back                  <Alt+Left> ",
 		Handler: func(mv *MainView) {
 			mv.params.OnCmd("back", CmdOpts{Internal: true})
 		},
 	},
 	{
-		Title: "Forward              <Alt+Right>",
+		Title: "Forward               <Alt+Right>",
 		Handler: func(mv *MainView) {
 			mv.params.OnCmd("fwd", CmdOpts{Internal: true})
 		},
 	},
 	{
-		Title: "Refresh              <F5>       ",
+		Title: "Refresh               <F5>       ",
 		Handler: func(mv *MainView) {
 			mv.params.OnCmd("refresh", CmdOpts{Internal: true})
 		},
 	},
 	{
-		Title: "Hard refresh         <Shift+F5> ",
+		Title: "Hard refresh          <Shift+F5> ",
 		Handler: func(mv *MainView) {
 			mv.params.OnCmd("refresh!", CmdOpts{Internal: true})
 		},
 	},
 	{
-		Title: "Copy query command   :xclip     ",
+		Title: "Copy query command    :xclip     ",
 		Handler: func(mv *MainView) {
 			mv.params.OnCmd("xclip", CmdOpts{Internal: true})
 		},
 	},
 	{
-		Title: "Query debug info     :debug     ",
+		Title: "Connection debug info :cdebug    ",
 		Handler: func(mv *MainView) {
-			mv.params.OnCmd("debug", CmdOpts{Internal: true})
+			mv.params.OnCmd("cdebug", CmdOpts{Internal: true})
 		},
 	},
 	{
-		Title: "About                :version   ",
+		Title: "Query debug info      :qdebug    ",
+		Handler: func(mv *MainView) {
+			mv.params.OnCmd("qdebug", CmdOpts{Internal: true})
+		},
+	},
+	{
+		Title: "About                 :version   ",
 		Handler: func(mv *MainView) {
 			mv.params.OnCmd("version", CmdOpts{Internal: true})
 		},
diff --git a/core/lstream_client.go b/core/lstream_client.go
@@ -90,6 +90,10 @@ type LStreamClient struct {
 
 	conn *connCtx
 
+	// connDebugMessages contains human-readable messages received from the shell
+	// transport regarding the connection.
+	connDebugMessages []string
+
 	cmdQueue   []lstreamCmd
 	curCmdCtx  *lstreamCmdCtx
 	nextCmdIdx int
@@ -150,8 +154,16 @@ type BusyStage struct {
 }
 
 type ConnDetails struct {
+	// Messages contains human-readable messages received from shell transport
+	// regarding the connection.
+	Messages []string
+
 	// Err is an error message from the last connection attempt.
 	Err string
+
+	// Connected shows whether the connection has already succeeded. Unlike other
+	// fields in this struct, it's set by the LStreamsManager manually.
+	Connected bool
 }
 
 type BootstrapDetails struct {
@@ -350,6 +362,8 @@ func (lsc *LStreamClient) changeState(newState LStreamClientState) {
 	case LStreamClientStateConnecting:
 		// Forget whatever queued command we might have.
 		lsc.cmdQueue = nil
+		// Forget whatever conn debug messages we've accumulated.
+		lsc.connDebugMessages = nil
 
 		// Initiate new connection
 		lsc.numConnAttempts++
@@ -369,6 +383,13 @@ func (lsc *LStreamClient) changeState(newState LStreamClientState) {
 	}
 }
 
+func (lsc *LStreamClient) makeConnDetailsMsg(err string) *ConnDetails {
+	return &ConnDetails{
+		Messages: lsc.connDebugMessages,
+		Err:      err,
+	}
+}
+
 func (lsc *LStreamClient) sendBusyStageUpdate() {
 	upd := lsc.busyStage
 	lsc.sendUpdate(&LStreamClientUpdate{
@@ -400,7 +421,14 @@ func (lsc *LStreamClient) run() {
 	for {
 		select {
 		case upd := <-lsc.connectUpdCh:
-			if dataReq := upd.DataRequest; dataReq != nil {
+			if dbg := upd.DebugInfo; dbg != nil {
+				// Got some debug info about the connection.
+				lsc.connDebugMessages = append(lsc.connDebugMessages, dbg.Message)
+
+				lsc.sendUpdate(&LStreamClientUpdate{
+					ConnDetails: lsc.makeConnDetailsMsg(""),
+				})
+			} else if dataReq := upd.DataRequest; dataReq != nil {
 				// We need some data from the user.
 
 				lsc.sendUpdate(&LStreamClientUpdate{
@@ -412,9 +440,7 @@ func (lsc *LStreamClient) run() {
 				if res.Err != nil {
 					lsc.params.Logger.Errorf("Shell connection failed: %s", res.Err.Error())
 					lsc.sendUpdate(&LStreamClientUpdate{
-						ConnDetails: &ConnDetails{
-							Err: fmt.Sprintf("attempt %d: %s", lsc.numConnAttempts, res.Err.Error()),
-						},
+						ConnDetails: lsc.makeConnDetailsMsg(fmt.Sprintf("attempt %d: %s", lsc.numConnAttempts, res.Err.Error())),
 					})
 
 					lsc.changeState(LStreamClientStateDisconnected)
diff --git a/core/lstreams_manager.go b/core/lstreams_manager.go
@@ -26,8 +26,9 @@ type LStreamsManager struct {
 
 	lscs      map[string]*LStreamClient
 	lscStates map[string]LStreamClientState
-	// lscConnDetails only contains items for lstreams which are in the
-	// LStreamClientStateConnectinConnecting state.
+	// lscConnDetails contains items for all selected lstreams, even after the
+	// connection is done (which is indicated by ConnDetails.Connected being
+	// true).
 	lscConnDetails map[string]ConnDetails
 	// lscBusyStages only contains items for lstreams which are in the
 	// LStreamClientStateConnectedBusy state.
@@ -216,7 +217,9 @@ func (lsman *LStreamsManager) run() {
 					// Maintain lsman.lscConnDetails
 					if upd.State.NewState == LStreamClientStateConnectedIdle ||
 						upd.State.NewState == LStreamClientStateConnectedBusy {
-						delete(lsman.lscConnDetails, upd.Name)
+						cd := lsman.lscConnDetails[upd.Name]
+						cd.Connected = true
+						lsman.lscConnDetails[upd.Name] = cd
 					}
 
 					// Maintain lsman.lscBusyStages
diff --git a/core/shell_transport.go b/core/shell_transport.go
@@ -27,6 +27,10 @@ type ShellConn interface {
 // ShellConnUpdate contains the update from ssh connection. Exactly one
 // field must be non-nil.
 type ShellConnUpdate struct {
+	// Info contains some debugging info about the connection, typically sent
+	// before trying to connect.
+	DebugInfo *ShellConnDebugInfo
+
 	// DataRequest contains request for additional data from the user.
 	DataRequest *ShellConnDataRequest
 
@@ -35,6 +39,13 @@ type ShellConnUpdate struct {
 	Result *ShellConnResult
 }
 
+// ShellConnDebugInfo contains some debugging human-readable info about the
+// connection.
+type ShellConnDebugInfo struct {
+	// Message contains some arbitrary human-readable details about the connection.
+	Message string
+}
+
 // ShellConnResult contains the connection result. If the connection is
 // successful, Conn is non-nil; otherwise, Err is non-nil.
 type ShellConnResult struct {
diff --git a/core/shell_transport_local.go b/core/shell_transport_local.go
@@ -1,6 +1,7 @@
 package core
 
 import (
+	"fmt"
 	"io"
 	"os/exec"
 
@@ -45,9 +46,17 @@ func (s *ShellTransportLocal) doConnect(
 		}
 	}()
 
-	// Start the local shell command
 	// TODO: make it configurable; e.g. it likely won't work on Windows
-	cmd := exec.Command("/bin/sh")
+	shellBin := "/bin/sh"
+
+	resCh <- ShellConnUpdate{
+		DebugInfo: &ShellConnDebugInfo{
+			Message: fmt.Sprintf("Running local shell %s", shellBin),
+		},
+	}
+
+	// Start the local shell command
+	cmd := exec.Command(shellBin)
 	stdin, err := cmd.StdinPipe()
 	if err != nil {
 		res.Err = errors.Annotatef(err, "getting stdin pipe")
diff --git a/core/shell_transport_ssh.go b/core/shell_transport_ssh.go
@@ -44,6 +44,12 @@ func (st *ShellTransportSSH) Connect(resCh chan<- ShellConnUpdate) {
 	go st.doConnect(resCh)
 }
 
+func (st *ShellTransportSSH) makeDebugInfo(message string) *ShellConnDebugInfo {
+	return &ShellConnDebugInfo{
+		Message: message,
+	}
+}
+
 func (st *ShellTransportSSH) doConnect(
 	resCh chan<- ShellConnUpdate,
 ) (res ShellConnResult) {
@@ -61,6 +67,13 @@ func (st *ShellTransportSSH) doConnect(
 
 	connDetails := st.params.ConnDetails
 
+	resCh <- ShellConnUpdate{
+		DebugInfo: st.makeDebugInfo(fmt.Sprintf(
+			"Trying to connect using internal ssh library to addr: %s, user: %s",
+			connDetails.Host.Addr, connDetails.Host.User,
+		)),
+	}
+
 	var sshClient *ssh.Client
 
 	conf, err := st.getClientConfig(resCh, logger, connDetails.Host.User)
@@ -69,6 +82,10 @@ func (st *ShellTransportSSH) doConnect(
 		return res
 	}
 
+	resCh <- ShellConnUpdate{
+		DebugInfo: st.makeDebugInfo(fmt.Sprintf("Got client config: %s", conf.Descr)),
+	}
+
 	if connDetails.Jumphost != nil {
 		logger.Infof("Connecting via jumphost")
 		// Use jumphost
@@ -102,6 +119,11 @@ func (st *ShellTransportSSH) doConnect(
 		}
 	}
 
+	shellBin := "/bin/sh"
+
+	resCh <- ShellConnUpdate{
+		DebugInfo: st.makeDebugInfo(fmt.Sprintf("Connected, creating pipes and starting %s", shellBin)),
+	}
 	logger.Infof("Connected to %s", connDetails.Host.Addr)
 
 	sshSession, err := sshClient.NewSession()
@@ -128,7 +150,7 @@ func (st *ShellTransportSSH) doConnect(
 		return res
 	}
 
-	err = sshSession.Start("/bin/sh")
+	err = sshSession.Start(shellBin)
 	if err != nil {
 		res.Err = errors.Annotatef(err, conf.Descr)
 		return res
