internal/libhive: Add line numbering for shared client log segments

Add line number tracking to shared client log segments to enable proper highlighting in the UI. Adds a line counting algorithm to convert byte positions to line numbers and enhances related data structures.

Author: danceratopz

internal/libhive/api.go

@@ -500,6 +500,47 @@ func (api *simAPI) startClient(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	// Check if this is a reference to a shared client
+	if clientConfig.SharedClientID != "" {
+		// This is a reference to a shared client - get the shared client info
+		sharedClient, err := api.tm.GetSharedClient(suiteID, clientConfig.SharedClientID)
+		if err != nil {
+			slog.Error("API: shared client not found", "sharedClientId", clientConfig.SharedClientID, "error", err)
+			serveError(w, err, http.StatusNotFound)
+			return
+		}
+
+		// Create a reference to the shared client in this test
+		clientInfo := &ClientInfo{
+			ID:             sharedClient.ID,
+			IP:             sharedClient.IP,
+			Name:           sharedClient.Name,
+			InstantiatedAt: sharedClient.InstantiatedAt,
+			LogFile:        sharedClient.LogFile,
+			IsShared:       true,
+			SharedClientID: clientConfig.SharedClientID,
+			LogPosition:    sharedClient.LogPosition,
+			SuiteID:        suiteID, // Make sure this is properly set
+		}
+		
+		slog.Debug("Created shared client reference", 
+			"nodeID", clientConfig.SharedClientID,
+			"name", sharedClient.Name,
+			"isShared", true,
+			"logPosition", sharedClient.LogPosition,
+			"logFile", sharedClient.LogFile)
+
+		// Register the node with the test
+		api.tm.RegisterNode(testID, clientConfig.SharedClientID, clientInfo)
+
+		// Return success with the node info
+		slog.Info("API: shared client registered with test", "suite", suiteID, "test", testID, 
+			"sharedClientId", clientConfig.SharedClientID, "container", sharedClient.ID[:8])
+		serveJSON(w, &simapi.StartNodeResponse{ID: sharedClient.ID, IP: sharedClient.IP})
+		return
+	}
+
+	// Normal client startup flow
 	// Get the client name.
 	clientDef, err := api.checkClient(&clientConfig)
 	if err != nil {

internal/libhive/data.go

@@ -162,9 +162,11 @@ type TestResult struct {
 
 // ClientLogSegment represents a segment of a client log file
 type ClientLogSegment struct {
-	Start    int64  `json:"start"`    // Starting offset in log file
-	End      int64  `json:"end"`      // Ending offset in log file
-	ClientID string `json:"clientId"` // ID of the client
+	Start     int64  `json:"start"`     // Starting byte offset in log file
+	End       int64  `json:"end"`       // Ending byte offset in log file
+	StartLine int    `json:"startLine"` // Starting line number
+	EndLine   int    `json:"endLine"`   // Ending line number
+	ClientID  string `json:"clientId"`  // ID of the client
 }
 
 type TestLogOffsets struct {
@@ -181,10 +183,10 @@ type ClientInfo struct {
 	LogFile        string    `json:"logFile"` //Absolute path to the logfile.
 
 	// Fields for shared client support
-	IsShared     bool  `json:"isShared"`     // Indicates if this client is shared across tests
-	LogPosition  int64 `json:"logPosition"`  // Current position in log file for shared clients
-	SuiteID      TestSuiteID `json:"suiteId,omitempty"` // Suite ID for shared clients
-	SharedClientID string    `json:"sharedClientId,omitempty"` // ID of the shared client (if this is a reference)
+	IsShared       bool        `json:"isShared"`                 // Indicates if this client is shared across tests
+	LogPosition    int64       `json:"logPosition"`              // Current position in log file for shared clients
+	SuiteID        TestSuiteID `json:"suiteId,omitempty"`        // Suite ID for shared clients
+	SharedClientID string      `json:"sharedClientId,omitempty"` // ID of the shared client (if this is a reference)
 
 	wait func()
 }

internal/libhive/testmanager.go

@@ -672,11 +672,29 @@ func (manager *TestManager) EndTest(suiteID TestSuiteID, testID TestID, result *
 				continue
 			}
 
-			// Create log segment for this test
+			slog.Debug("Processing shared client logs",
+				"testID", testID,
+				"nodeID", nodeID,
+				"clientName", clientInfo.Name,
+				"startPosition", clientInfo.LogPosition,
+				"endPosition", currentPosition)
+
+			// Count lines in the log segment to determine line numbers
+			startLine, endLine, err := manager.countLinesInSegment(clientInfo.LogFile, clientInfo.LogPosition, currentPosition)
+			if err != nil {
+				slog.Error("could not count lines in client log segment", "err", err)
+				// If we can't count lines, use 1 to indicate the beginning of the file
+				startLine = 1
+				endLine = 1
+			}
+
+			// Create log segment for this test with both byte offsets and line numbers
 			result.ClientLogs[nodeID] = &ClientLogSegment{
-				Start:    clientInfo.LogPosition,
-				End:      currentPosition,
-				ClientID: clientInfo.ID,
+				Start:     clientInfo.LogPosition,
+				End:       currentPosition,
+				StartLine: startLine,
+				EndLine:   endLine,
+				ClientID:  clientInfo.ID,
 			}
 
 			// Extract log segment to a dedicated file for hiveview
@@ -933,6 +951,82 @@ func (manager *TestManager) UnpauseNode(testID TestID, nodeID string) error {
 	return nil
 }
 
+// countLinesInSegment counts the number of lines in a file segment between startByte and endByte.
+// Returns the starting and ending line numbers (1-based).
+func (manager *TestManager) countLinesInSegment(filePath string, startByte, endByte int64) (int, int, error) {
+	// Ensure we have the full path to the log file
+	fullPath := filePath
+	if !filepath.IsAbs(fullPath) {
+		fullPath = filepath.Join(manager.config.LogDir, filePath)
+	}
+	slog.Debug("Opening log file", "path", fullPath)
+
+	// Open the log file
+	file, err := os.Open(fullPath)
+	if err != nil {
+		return 1, 1, err
+	}
+	defer file.Close()
+
+	// Count lines up to the start position to get the starting line number
+	startLine := 1
+	if startByte > 0 {
+		buffer := make([]byte, startByte)
+		_, err = file.Read(buffer)
+		if err != nil && err != io.EOF {
+			return 1, 1, err
+		}
+
+		// Count newlines in the buffer
+		for _, b := range buffer {
+			if b == '\n' {
+				startLine++
+			}
+		}
+	}
+
+	// Now count lines in the segment to determine the ending line number
+	bufferSize := endByte - startByte
+	if bufferSize <= 0 {
+		return startLine, startLine, nil
+	}
+
+	// Seek to the start position
+	_, err = file.Seek(startByte, 0)
+	if err != nil {
+		return startLine, startLine, err
+	}
+
+	// Read the segment
+	buffer := make([]byte, bufferSize)
+	_, err = file.Read(buffer)
+	if err != nil && err != io.EOF {
+		return startLine, startLine, err
+	}
+
+	// Count newlines in the segment
+	endLine := startLine
+	for _, b := range buffer {
+		if b == '\n' {
+			endLine++
+		}
+	}
+
+	// Adjust endLine to fix the off-by-1 issue (the actual line with content rather than the next line)
+	if endLine > startLine {
+		endLine--
+	}
+
+	slog.Debug("Counted lines in segment",
+		"file", filePath,
+		"startByte", startByte,
+		"endByte", endByte,
+		"startLine", startLine,
+		"endLine", endLine)
+
+	return startLine, endLine, nil
+}
+
 // writeSuiteFile writes the simulation result to the log directory.
 // List of build arguments to exclude from result JSON for security/privacy
 var excludedBuildArgs = map[string]bool{

internal/simapi/simapi.go

@@ -11,10 +11,11 @@ type TestRequest struct {
 
 // NodeConfig contains the launch parameters for a client container.
 type NodeConfig struct {
-	Client      string            `json:"client"`
-	Networks    []string          `json:"networks"`
-	Environment map[string]string `json:"environment"`
-	IsShared    bool              `json:"isShared,omitempty"` // Whether this client is shared across tests
+	Client         string            `json:"client"`
+	Networks       []string          `json:"networks"`
+	Environment    map[string]string `json:"environment"`
+	IsShared       bool              `json:"isShared,omitempty"`       // Whether this client is shared across tests
+	SharedClientID string            `json:"sharedClientId,omitempty"` // If set, this is a reference to an existing shared client
 }
 
 // StartNodeResponse is returned by the client startup endpoint.
@@ -29,6 +30,14 @@ type NodeResponse struct {
 	Name string `json:"name"`
 }
 
+// NodeInfo contains information about a client node to register with a test.
+type NodeInfo struct {
+	ID             string `json:"id"`                       // Container ID
+	Name           string `json:"name"`                     // Client name/type
+	IsShared       bool   `json:"isShared"`                 // Whether this is a shared client
+	SharedClientID string `json:"sharedClientId,omitempty"` // ID of the shared client in the suite
+}
+
 type ExecRequest struct {
 	Command []string `json:"command"`
 }