Merge branch 'feature/nodejs'

Author: mahesh-tier1app

internal/agent/api/action_api.go

@@ -126,7 +126,7 @@ func (s *Server) handleActionAPI(req *ActionRequest, resp *ActionResponse) {
 				if pResult.err == nil {
 					pResult.output = append(pResult.output, pResult.rUrls...)
 				} else {
-					pResult.output = append(pResult.output, err.Error())
+					pResult.output = append(pResult.output, pResult.err.Error())
 				}
 			} else if _, ok := pidAny.(string); ok {
 				pResult.output = append(pResult.output, "Unsupported Operation")
@@ -141,7 +141,7 @@ func (s *Server) handleActionAPI(req *ActionRequest, resp *ActionResponse) {
 			for _, r := range processPidsResults {
 				if r.err != nil {
 					resp.Code = -1
-					resp.Msg = err.Error()
+					resp.Msg = r.err.Error()
 				} else {
 					resp.DashboardReportURLs = r.rUrls
 				}

internal/agent/api/nodejs_api_test.go

@@ -0,0 +1,115 @@
+package api
+
+import (
+	"errors"
+	"os"
+	"strconv"
+	"testing"
+
+	"yc-agent/internal/config"
+)
+
+func TestActionAPIExplicitPidReachesProcessPids(t *testing.T) {
+	saved := config.GlobalConfig
+	t.Cleanup(func() { config.GlobalConfig = saved })
+	config.GlobalConfig.ApiKey = "test-key"
+
+	s := NewServer("localhost", 0)
+	var gotPids []int
+	s.ProcessPids = func(pids []int, pid2Name map[int]string, hd bool, tags string) ([]string, error) {
+		gotPids = append(gotPids, pids...)
+		return []string{"http://dashboard/report/1"}, nil
+	}
+
+	pid := os.Getpid() // a guaranteed-existing PID (validateActionAPIParseResult requires one)
+	req := &ActionRequest{
+		Key:     "test-key",
+		Actions: []string{"capture " + strconv.Itoa(pid)},
+		WaitFor: true, // run synchronously so the assertion sees the result
+	}
+	resp := &ActionResponse{}
+	s.handleActionAPI(req, resp)
+
+	if len(gotPids) != 1 || gotPids[0] != pid {
+		t.Errorf("ProcessPids received %v, want [%d]", gotPids, pid)
+	}
+	if len(resp.DashboardReportURLs) != 1 || resp.DashboardReportURLs[0] != "http://dashboard/report/1" {
+		t.Errorf("DashboardReportURLs = %v, want one report URL", resp.DashboardReportURLs)
+	}
+}
+
+func TestActionAPIProcessPidsErrorSurfaced(t *testing.T) {
+	saved := config.GlobalConfig
+	t.Cleanup(func() { config.GlobalConfig = saved })
+	config.GlobalConfig.ApiKey = "test-key"
+
+	s := NewServer("localhost", 0)
+	s.ProcessPids = func(pids []int, pid2Name map[int]string, hd bool, tags string) ([]string, error) {
+		return nil, errors.New("capture blew up")
+	}
+
+	req := &ActionRequest{
+		Key:     "test-key",
+		Actions: []string{"capture " + strconv.Itoa(os.Getpid())},
+		WaitFor: true,
+	}
+	resp := &ActionResponse{}
+	s.handleActionAPI(req, resp) // must not panic (goroutine nil-deref before the fix)
+
+	if resp.Code != -1 {
+		t.Errorf("resp.Code = %d, want -1 on a capture error", resp.Code)
+	}
+	if resp.Msg != "capture blew up" {
+		t.Errorf("resp.Msg = %q, want the ProcessPids error surfaced verbatim", resp.Msg)
+	}
+}
+
+func TestActionAPIRejectsBadKey(t *testing.T) {
+	saved := config.GlobalConfig
+	t.Cleanup(func() { config.GlobalConfig = saved })
+	config.GlobalConfig.ApiKey = "right-key"
+
+	s := NewServer("localhost", 0)
+	called := false
+	s.ProcessPids = func(pids []int, pid2Name map[int]string, hd bool, tags string) ([]string, error) {
+		called = true
+		return nil, nil
+	}
+	resp := &ActionResponse{}
+	s.handleActionAPI(&ActionRequest{Key: "wrong-key", Actions: []string{"capture 1"}, WaitFor: true}, resp)
+
+	if called {
+		t.Errorf("ProcessPids must not run when the API key is wrong")
+	}
+	if resp.Code != -1 || resp.Msg != "invalid key passed" {
+		t.Errorf("resp = %+v, want Code=-1 Msg=\"invalid key passed\"", resp)
+	}
+}
+
+func TestActionAPIParseActionsDispatch(t *testing.T) {
+	// A numeric id parses straight to that PID (runtime-agnostic — a Node PID
+	// works exactly like a Java one here).
+	result, _, _, err := parseActions([]string{"capture 424242"})
+	if err != nil {
+		t.Fatalf("parseActions numeric: %v", err)
+	}
+	if len(result) != 1 || result[0] != 424242 {
+		t.Errorf("numeric dispatch = %v, want [424242]", result)
+	}
+
+	// A non-numeric token is resolved by command-line substring match via
+	// GetProcessIds — the runtime-agnostic path by which a Node process CAN be
+	// targeted (with a unique token). A sentinel that matches no process yields
+	// nothing.
+	result, _, _, err = parseActions([]string{"capture zzz_no_such_process_token_zzz"})
+	if err != nil {
+		t.Fatalf("parseActions token: %v", err)
+	}
+	if len(result) != 0 {
+		t.Errorf("unmatched token dispatch = %v, want empty", result)
+	}
+
+	if _, _, _, err := parseActions([]string{"capture PROCESS_HIGH_CPU"}); err != nil {
+		t.Fatalf("parseActions PROCESS_HIGH_CPU dispatch errored: %v", err)
+	}
+}

internal/agent/m3/m3.go

@@ -33,6 +33,7 @@ type M3App struct {
 	accessLogM3          *capture.AccessLogM3
 	AsyncDotNetGCCapture *capture.DotnetGCAsync
 	dotnetGCReadySeen    map[int]bool
+	nodeGCTracker        *capture.NodeGCTracker
 }
 
 func NewM3App() *M3App {
@@ -49,6 +50,7 @@ func NewM3App() *M3App {
 		accessLogM3:          accessLogM3,
 		AsyncDotNetGCCapture: capture.NewDotnetGCAsync(dotNetGCBaseDir),
 		dotnetGCReadySeen:    make(map[int]bool),
+		nodeGCTracker:        capture.NewNodeGCTracker(),
 	}
 }
 
@@ -261,7 +263,8 @@ func (m3 *M3App) captureAndTransmit(pids map[int]string, endpoint string) {
 			var gcPath string
 			appRuntime := runtimeByPid[pid]
 
-			if appRuntime == "dotnet" {
+			switch appRuntime {
+			case "dotnet":
 				// High-level flow for .NET GC in M3 mode:
 				// 1) Reconcile() starts/keeps one long-running async Dotnet GC collector per active .NET PID.
 				// 2) In the same RunSingle cycle, uploadDotnetGCM3() reads collector output from session log path.
@@ -275,7 +278,10 @@ func (m3 *M3App) captureAndTransmit(pids map[int]string, endpoint string) {
 
 				logger.Log("uploading dotnet heap stats for pid %d", pid)
 				uploadDotnetHeapM3(endpoint, pid)
-			} else {
+			case "nodejs":
+				logger.Log("Using Node.js runtime for pid %d", pid)
+				gcPath = m3.captureNodeM3(endpoint, pid)
+			default:
 				logger.Log("Using Java runtime for pid %d", pid)
 				logger.Log("uploading gc log for pid %d", pid)
 				gcPath = uploadGCLogM3(endpoint, pid)
@@ -304,6 +310,12 @@ func (m3 *M3App) captureAndTransmit(pids map[int]string, endpoint string) {
 				delete(m3.dotnetGCReadySeen, pid)
 			}
 		}
+
+		// Drop Node.js GC offset state for PIDs no longer monitored, so it does
+		// not leak across process restarts / PID reuse.
+		if m3.nodeGCTracker != nil {
+			m3.nodeGCTracker.RetainOnly(pids)
+		}
 	}
 
 	topResult := <-top
@@ -845,6 +857,67 @@ Resp: %s
 	return gcPath
 }
 
+func (m3 *M3App) captureNodeM3(endpoint string, pid int) string {
+	nodeCtx := capture.ResolveNodeCapture(pid)
+
+	outDir := filepath.Join("yc-node-m3", strconv.Itoa(pid))
+	if err := os.MkdirAll(outDir, 0o755); err != nil {
+		logger.Log("WARNING: failed creating node m3 dir %s: %s", outDir, err)
+		return ""
+	}
+
+	stdoutPath := ""
+	if capture.NodeHasTraceGCFlag(pid) {
+		// ResolveNodeGCStdoutPath (not the raw platform resolver) so a
+		// configured -nodejsGCLogPath is honored here too - this path is used
+		// below to tell uploadAppLogM3 which file to exclude from generic
+		// app-log auto-discovery, not just by NodeGC.Run()'s own capture.
+		if p, err := capture.ResolveNodeGCStdoutPath(pid); err == nil {
+			stdoutPath = p
+		}
+	}
+
+	pidParam := strconv.Itoa(pid)
+
+	// GC log (continuous delta; no dumpGC fallback under M3).
+	nodeGC := &capture.NodeGC{
+		Pid:     pid,
+		Ctx:     nodeCtx,
+		OutDir:  outDir,
+		Tracker: m3.nodeGCTracker,
+		M3:      true,
+	}
+	nodeGC.SetEndpointParam("pid", pidParam)
+	runNodeM3Capture(endpoint, "GC LOG", nodeGC)
+
+	// Process overview
+	nodePO := &capture.NodeProcessOverview{Pid: pid, Ctx: nodeCtx, OutDir: outDir}
+	nodePO.SetEndpointParam("pid", pidParam)
+	runNodeM3Capture(endpoint, "PROCESS OVERVIEW", nodePO)
+
+	// Heap summary (safe every cycle).
+	nodeHS := &capture.NodeHeapSummary{Pid: pid, Ctx: nodeCtx, OutDir: outDir}
+	nodeHS.SetEndpointParam("pid", pidParam)
+	runNodeM3Capture(endpoint, "HDSUB", nodeHS)
+
+	return stdoutPath
+}
+
+func runNodeM3Capture(endpoint, label string, task capture.Task) {
+	ch := capture.GoCapture(endpoint, capture.WrapRun(task))
+	if ch == nil {
+		return
+	}
+	result := <-ch
+	logger.Log(
+		`NODE %s DATA
+Is transmission completed: %t
+Resp: %s
+
+--------------------------------
+`, label, result.Ok, result.Msg)
+}
+
 func uploadDotnetThreadM3(endpoint string, pid int) {
 	dotnetTDCapture := &capture.DotnetThread{
 		Pid: pid,