Implemented .jfr recordings

Author: SainathKumarParuchuru

internal/agent/ondemand/ondemand.go

@@ -297,6 +297,12 @@ Ignored errors: %v
 	}
 	var nodeExtraCaptures []nodeNamedCapture
 
+	// JFR recording state (see the java runtime case below and the
+	// stop/transmit step at the end of capture).
+	var jfrEnabled bool
+	var jfrFilePath string
+	var jfrStartedAt time.Time
+
 	appRuntime := config.GetAppRuntime(pid)
 
 	switch appRuntime {
@@ -376,6 +382,27 @@ Ignored errors: %v
 		// ------------------------------------------------------------------------------
 		//   				Java runtime captures (default)
 		// ------------------------------------------------------------------------------
+
+		// Start a JFR recording covering the whole capture window, for any
+		// -p <pid> run. It's stopped and transmitted with dt=jfr once every
+		// other artifact has been captured, further down.
+		if pidPassed {
+			jfrFilePath = capture.JFRFileName
+			if len(dockerID) == 0 {
+				if abs, absErr := filepath.Abs(jfrFilePath); absErr == nil {
+					jfrFilePath = abs
+				}
+			}
+
+			if err := capture.StartJFR(pid, config.GlobalConfig.JavaHomePath, jfrFilePath); err != nil {
+				logger.Log("WARNING: failed to start JFR recording: %s", err.Error())
+			} else {
+				jfrEnabled = true
+				jfrStartedAt = time.Now()
+				logger.Log("JFR recording started (name=%s, file=%s)", capture.JFRRecordingName, jfrFilePath)
+			}
+		}
+
 		// Capture gc
 		gc = goCapture(endpoint, capture.WrapRun(&capture.GC{
 			Pid:      pid,
@@ -895,6 +922,31 @@ Resp: %s
 	}
 	logger.Log("Executed custom commands")
 
+	// -------------------------------
+	//     Transmit JFR recording (already auto-stopped, see StartJFR)
+	// -------------------------------
+	if jfrEnabled {
+		// The recording auto-stops JFRCaptureDuration after it started (see
+		// StartJFR), independent of how long the rest of this capture takes.
+		// If everything else finished quickly, wait out the remainder here
+		// so the file is guaranteed to be finalized before we read it. This
+		// is scoped to JFR only - it does not affect the thread dump
+		// capture above, which keeps its normal, unrelated behavior.
+		if remaining := capture.JFRCaptureDuration - time.Since(jfrStartedAt); remaining > 0 {
+			logger.Log("Waiting %s for JFR recording to finish before transmitting...", remaining)
+			time.Sleep(remaining)
+		}
+
+		msg, ok := capture.TransmitJFR(endpoint, jfrFilePath, dockerID)
+		logger.Log(
+			`JFR RECORDING DATA
+Is transmission completed: %t
+Resp: %s
+
+--------------------------------
+`, ok, msg)
+	}
+
 	if config.GlobalConfig.OnlyCapture {
 		return
 	}
@@ -1121,11 +1173,16 @@ func writeMetaInfo(processId int, appName, endpoint, tags string) (msg string, o
 	}
 
 	var ov string
-	osVersion, e := executils.CommandCombinedOutput(executils.OSVersion)
+	var osVersion bytes.Buffer
+	// Uses the timeout-bounded writer variant (CmdTimeout, default 60s):
+	// on Windows this shells out to `systeminfo`, which is known to hang
+	// or run very slowly on some machines, and would otherwise block the
+	// whole capture indefinitely.
+	e = executils.CommandCombinedOutputToWriter(&osVersion, executils.OSVersion)
 	if e != nil {
 		err = fmt.Errorf("osVersion err: %v, previous err: %v", e, err)
 	} else {
-		ov = strings.ReplaceAll(string(osVersion), "\r\n", ", ")
+		ov = strings.ReplaceAll(osVersion.String(), "\r\n", ", ")
 		ov = strings.ReplaceAll(ov, "\n", ", ")
 	}
 	var un string

internal/capture/jfr.go

@@ -0,0 +1,103 @@
+package capture
+
+import (
+	"fmt"
+	"os"
+	"path"
+	"strconv"
+	"time"
+
+	"yc-agent/internal/capture/executils"
+	"yc-agent/internal/logger"
+)
+
+// JFRRecordingName identifies the recording started by StartJFR.
+const JFRRecordingName = "ycJFR"
+
+// JFRFileName is the fixed filename yc-agent uses for the JFR recording it
+// captures in -onlyCapture mode.
+const JFRFileName = "my.jfr"
+
+// JFRCaptureDuration is how long a JFR recording runs for. It's passed as
+// JFR.start's own duration= option, so the JVM auto-stops the recording (and
+// flushes/finalizes the file) on its own - no explicit JFR.stop call needed.
+// The caller (ondemand.FullCapture) waits out this same duration before
+// calling TransmitJFR, in case the rest of the capture finishes sooner, so
+// the file is guaranteed to be finalized by the time it's read.
+const JFRCaptureDuration = 60 * time.Second
+
+// StartJFR starts a JFR recording on the target JVM (pid), writing to
+// filePath. filePath must be an absolute path (or, for a dockerized target, a
+// path inside the container) since the target JVM's own working directory is
+// generally not the same as yc-agent's. The recording auto-stops after
+// JFRCaptureDuration; see TransmitJFR.
+func StartJFR(pid int, javaHome, filePath string) error {
+	cmd := fmt.Sprintf("JFR.start name=%s filename=%s duration=%ds", JFRRecordingName, filePath, int(JFRCaptureDuration.Seconds()))
+	return runJcmd(pid, javaHome, cmd)
+}
+
+// runJcmd runs a jcmd diagnostic command against pid, trying the JDK's jcmd
+// binary first and falling back to jattach, then tmp jattach (mirrors
+// HDSub.executeJcmd).
+func runJcmd(pid int, javaHome, command string) error {
+	out, err := executils.CommandCombinedOutput(
+		executils.Command{path.Join(javaHome, "bin/jcmd"), strconv.Itoa(pid), command},
+		executils.SudoHooker{PID: pid})
+	if err == nil {
+		logger.Log("jcmd %s: %s", command, out)
+		return nil
+	}
+
+	logger.Log("jcmd failed (%v), falling back to jattach for: %s", err, command)
+
+	out, err = executils.CommandCombinedOutput(
+		executils.Command{executils.Executable(), "-p", strconv.Itoa(pid), "-jCmdCaptureMode", command},
+		executils.EnvHooker{"pid": strconv.Itoa(pid)}, executils.SudoHooker{PID: pid})
+	if err == nil {
+		logger.Log("jattach %s: %s", command, out)
+		return nil
+	}
+
+	logger.Log("jattach failed (%v), falling back to tmp jattach for: %s", err, command)
+
+	tempPath, tmpErr := executils.Copy2TempPath()
+	if tmpErr != nil {
+		return fmt.Errorf("failed to run %q: %w (tmp jattach fallback failed: %v)", command, err, tmpErr)
+	}
+
+	out, err = executils.CommandCombinedOutput(
+		executils.Command{tempPath, "-p", strconv.Itoa(pid), "-jCmdCaptureMode", command},
+		executils.EnvHooker{"pid": strconv.Itoa(pid)}, executils.SudoHooker{PID: pid})
+	if err != nil {
+		return fmt.Errorf("failed to run %q: %w, output: %s", command, err, out)
+	}
+	logger.Log("tmp jattach %s: %s", command, out)
+	return nil
+}
+
+// TransmitJFR transmits the JFR recording started by StartJFR (filePath, the
+// same path passed to it) to endpoint with dt=jfr. It assumes the recording
+// has already auto-stopped (StartJFR's duration= option) by the time this
+// runs. If dockerID is set, the recording is copied out of the container to
+// the local, relative JFRFileName first (so it also ends up in the local
+// capture bundle, consistent with how GC logs are handled).
+//
+// The transmission bypasses the -onlyCapture short-circuit in PostData, since
+// the recording needs to reach the yc-receiver regardless of -onlyCapture.
+func TransmitJFR(endpoint, filePath, dockerID string) (msg string, ok bool) {
+	localPath := filePath
+	if len(dockerID) > 0 {
+		localPath = JFRFileName
+		if err := DockerCopy(localPath, dockerID+":"+filePath); err != nil {
+			return fmt.Sprintf("failed to copy JFR recording out of container: %s", err.Error()), false
+		}
+	}
+
+	file, err := os.Open(localPath)
+	if err != nil {
+		return fmt.Sprintf("failed to open JFR recording %s: %s", localPath, err.Error()), false
+	}
+	defer file.Close()
+
+	return PostDataForce(endpoint, "jfr", file)
+}

internal/capture/post.go

@@ -29,6 +29,14 @@ func PostData(endpoint, dt string, file *os.File) (msg string, ok bool) {
 	return PostCustomData(endpoint, "dt="+dt, file)
 }
 
+// PostDataForce behaves like PostData but always transmits over HTTP, ignoring
+// the -onlyCapture short-circuit. It exists for artifacts (e.g. JFR
+// recordings) that must reach the yc-receiver even when the rest of the
+// capture is only zipped locally.
+func PostDataForce(endpoint, dt string, file *os.File) (msg string, ok bool) {
+	return postCustomDataWithPositionFuncWithTimeout(endpoint, "dt="+dt, file, PositionZero, config.GlobalConfig.HttpClientTimeout.Duration(), true)
+}
+
 func PostDataWithTimeout(endpoint, dt string, file *os.File, timeout time.Duration) (msg string, ok bool) {
 	return PostCustomDataWithTimeout(endpoint, "dt="+dt, file, timeout)
 }
@@ -224,7 +232,11 @@ func PostCustomDataWithPositionFunc(endpoint, params string, file *os.File, posi
 }
 
 func PostCustomDataWithPositionFuncWithTimeout(endpoint, params string, file *os.File, position func(file *os.File) error, timeout time.Duration) (msg string, ok bool) {
-	if config.GlobalConfig.OnlyCapture {
+	return postCustomDataWithPositionFuncWithTimeout(endpoint, params, file, position, timeout, false)
+}
+
+func postCustomDataWithPositionFuncWithTimeout(endpoint, params string, file *os.File, position func(file *os.File) error, timeout time.Duration, force bool) (msg string, ok bool) {
+	if config.GlobalConfig.OnlyCapture && !force {
 		msg = "in only capture mode"
 		return
 	}