Merge pull request #35 from ycrash/hotfix/platform-mismatch

hotfix/platform mismatch

Author: ycrash

go.mod

@@ -73,7 +73,7 @@ require (
 	github.com/yusufpapurcu/wmi v1.2.4 // indirect
 	golang.org/x/net v0.45.0 // indirect
 	golang.org/x/oauth2 v0.27.0 // indirect
-	golang.org/x/sys v0.36.0 // indirect
+	golang.org/x/sys v0.36.0
 	golang.org/x/term v0.35.0 // indirect
 	golang.org/x/text v0.29.0 // indirect
 	golang.org/x/time v0.7.0 // indirect

internal/agent/m3/m3.go

@@ -250,16 +250,6 @@ func (m3 *M3App) captureAndTransmit(pids map[int]string, endpoint string) {
 			}
 		}
 
-		// Eagerly resolve the .NET helper path once per cycle when any .NET
-		// targets exist, so failures surface early rather than per-capture.
-		if len(dotnetPIDs) > 0 {
-			if resolved, err := config.ResolveDotnetToolPath(); err != nil {
-				logger.Warn().Err(err).Msg(".NET helper not found - .NET captures will fail")
-			} else if config.GlobalConfig.DotnetToolPath == "" {
-				config.GlobalConfig.DotnetToolPath = resolved
-			}
-		}
-
 		if m3.AsyncDotNetGCCapture != nil {
 			// Reconcile creates/updates async GC capture sessions for current .NET PIDs.
 			// In the per-PID loop below, uploadDotnetGCM3 reads and uploads artifacts from

internal/agent/ondemand/ondemand.go

@@ -289,13 +289,6 @@ Ignored errors: %v
 	appRuntime := config.GetAppRuntime(pid)
 
 	if appRuntime == "dotnet" {
-		// Eagerly resolve the .NET helper path so failures surface early,
-		// before any capture goroutines are launched.
-		if resolved, err := config.ResolveDotnetToolPath(); err != nil {
-			logger.Warn().Err(err).Msg(".NET helper not found - .NET captures will fail")
-		} else if config.GlobalConfig.DotnetToolPath == "" {
-			config.GlobalConfig.DotnetToolPath = resolved
-		}
 		// ------------------------------------------------------------------------------
 		//   				.NET runtime captures
 		// ------------------------------------------------------------------------------

internal/capture/dotnet_gc.go

@@ -96,7 +96,7 @@ func (d *DotnetGC) CaptureToFile() (*os.File, error) {
 	}
 
 	// Execute the dotnet tool and capture output
-	file, err := executeDotnetTool(args, fmt.Sprintf(dotnetGCOutputPath, d.Pid))
+	file, err := executeDotnetTool(d.Pid, args, fmt.Sprintf(dotnetGCOutputPath, d.Pid))
 	if err != nil {
 		return nil, fmt.Errorf("failed to capture .NET GC events: %w", err)
 	}

internal/capture/dotnet_gc_async.go

@@ -121,7 +121,7 @@ func (d *DotnetGCAsync) ensureStartedLocked(pid int, appName string) error {
 	}
 
 	args := []string{"-gc", strconv.Itoa(pid), d.baseDir, "-1"}
-	cmd, err := startDotnetToolInBackground(args, executils.DirHooker{Dir: d.baseDir})
+	cmd, err := startDotnetToolInBackground(pid, args, executils.DirHooker{Dir: d.baseDir})
 	if err != nil {
 		return err
 	}

internal/capture/dotnet_heap.go

@@ -49,7 +49,7 @@ func (d *DotnetHeap) CaptureToFile() (*os.File, error) {
 	}
 
 	// Execute the dotnet tool and capture output
-	file, err := executeDotnetTool(args, fmt.Sprintf(dotnetHeapOutputPath, d.Pid))
+	file, err := executeDotnetTool(d.Pid, args, fmt.Sprintf(dotnetHeapOutputPath, d.Pid))
 	if err != nil {
 		return nil, fmt.Errorf("failed to capture .NET heap statistics: %w", err)
 	}

internal/capture/dotnet_thread.go

@@ -49,7 +49,7 @@ func (d *DotnetThread) CaptureToFile() (*os.File, error) {
 	}
 
 	// Execute the dotnet tool and capture output
-	file, err := executeDotnetTool(args, fmt.Sprintf(dotnetThreadOutputPath, d.Pid))
+	file, err := executeDotnetTool(d.Pid, args, fmt.Sprintf(dotnetThreadOutputPath, d.Pid))
 	if err != nil {
 		return nil, fmt.Errorf("failed to capture .NET thread dump: %w", err)
 	}

internal/capture/dotnet_tool_selector_others.go

@@ -0,0 +1,10 @@
+//go:build !windows
+
+package capture
+
+func detectTargetArch(pid int) (string, error) {
+	// pid is unused on non-Windows;
+	// kept to match the Windows signature, discarded here to silence unusedparams lint
+	_ = pid
+	return "", nil
+}

internal/capture/dotnet_tool_selector_windows.go

@@ -0,0 +1,35 @@
+//go:build windows
+
+package capture
+
+import (
+	"os"
+
+	"golang.org/x/sys/windows"
+)
+
+func detectTargetArch(pid int) (string, error) {
+	h, err := windows.OpenProcess(windows.PROCESS_QUERY_LIMITED_INFORMATION, false, uint32(pid))
+	if err != nil {
+		return "", err
+	}
+	defer windows.CloseHandle(h)
+
+	var targetWow64 bool
+	if err = windows.IsWow64Process(h, &targetWow64); err != nil {
+		return "", err
+	}
+
+	// On 32-bit Windows, everything is x86.
+	if isOS64Bit() {
+		if targetWow64 {
+			return "x86", nil
+		}
+		return "x64", nil
+	}
+	return "x86", nil
+}
+
+func isOS64Bit() bool {
+	return os.Getenv("PROCESSOR_ARCHITEW6432") != "" || os.Getenv("PROCESSOR_ARCHITECTURE") == "AMD64"
+}

internal/capture/dotnet_utils.go

@@ -26,6 +26,15 @@ var knownDotnetToolErrors = []dotnetToolFriendlyError{
 	},
 }
 
+const DotnetSourceUserOverride = "user-override"
+const DotnetSourceArchMatched = "arch-matched"
+const DotnetSourceDefault = "default"
+
+type DotnetToolResolution struct {
+	Path   string
+	Source string // "user-override", "arch-matched", "default"
+}
+
 // wrapDotnetToolStartError wraps a command-start error, appending a
 // user-friendly message when the error matches a known pattern. The original
 // error message is always preserved for debugging.
@@ -39,30 +48,61 @@ func wrapDotnetToolStartError(err error, cmdArgs []string) error {
 	return fmt.Errorf("failed to start dotnet tool %v: %w", cmdArgs, err)
 }
 
-// ensureDotnetToolResolved lazily resolves DotnetToolPath if it was not set
-// during validation (e.g. when runtime was auto-detected rather than explicit).
-func ensureDotnetToolResolved() (string, error) {
-	if path := config.GlobalConfig.DotnetToolPath; path != "" {
-		return path, nil
+func resolveDotnetToolForPid(pid int) (DotnetToolResolution, error) {
+	// user override
+	if config.GlobalConfig.DotnetToolPath != "" {
+		resolvedPath, err := config.ResolveDotnetToolOverride()
+		if err != nil {
+			return DotnetToolResolution{}, err
+		}
+		return DotnetToolResolution{Path: resolvedPath, Source: DotnetSourceUserOverride}, nil
 	}
-	resolved, err := config.ResolveDotnetToolPath()
-	if err != nil {
-		return "", err
+
+	// arch matched
+	arch, detectErr := detectTargetArch(pid)
+	if detectErr != nil {
+		logger.Warn().Err(detectErr).Int("pid", pid).Msg("could not detect target arch")
+	}
+	if arch != "" {
+		name := config.DotnetToolNameForArch(arch)
+		if p, ok := config.FindDotnetToolNearYcOrPath(name); ok {
+			return DotnetToolResolution{Path: p, Source: DotnetSourceArchMatched}, nil
+		}
+
+		return DotnetToolResolution{}, fmt.Errorf(".NET tool for PID %d (%s) not found. expected %s next to yc or on PATH", pid, arch, name)
+	}
+
+	// No arch info — fall back to default tool name
+	if p, ok := config.FindDotnetToolNearYcOrPath(config.DefaultDotnetToolName); ok {
+		if detectErr != nil {
+			logger.Warn().
+				Err(detectErr).
+				Int("pid", pid).
+				Str("path", p).
+				Msg("using legacy .NET tool path because target arch detection failed")
+		}
+		return DotnetToolResolution{Path: p, Source: DotnetSourceDefault}, nil
+	}
+
+	if detectErr != nil {
+		return DotnetToolResolution{}, fmt.Errorf(
+			".NET tool path %q not found near yc or on PATH (target arch detection for PID %d failed: %w)",
+			config.DefaultDotnetToolName, pid, detectErr)
 	}
-	config.GlobalConfig.DotnetToolPath = resolved
-	return resolved, nil
+	return DotnetToolResolution{}, fmt.Errorf(
+		".NET tool path %q not found near yc or on PATH", config.DefaultDotnetToolName)
 }
 
-// executeDotnetTool runs the configured .NET helper executable with the given arguments
+// executeDotnetTool runs the configured .NET tool executable with the given arguments
 // and captures the output to a file. Returns the file handle and any error.
-func executeDotnetTool(args []string, outputPath string) (*os.File, error) {
-	toolPath, err := ensureDotnetToolResolved()
+func executeDotnetTool(pid int, args []string, outputPath string) (*os.File, error) {
+	toolResolution, err := resolveDotnetToolForPid(pid)
 	if err != nil {
 		return nil, err
 	}
 
 	// Build the command: [toolPath, args...]
-	cmdArgs := append([]string{toolPath}, args...)
+	cmdArgs := append([]string{toolResolution.Path}, args...)
 
 	logger.Log("Executing dotnet tool: %v", cmdArgs)
 
@@ -144,15 +184,15 @@ func executeDotnetTool(args []string, outputPath string) (*os.File, error) {
 	return file, nil
 }
 
-// startDotnetToolInBackground starts the configured .NET helper executable with the
+// startDotnetToolInBackground starts the configured .NET tool executable with the
 // given arguments and returns the running command handle without waiting.
-func startDotnetToolInBackground(args []string, hookers ...executils.Hooker) (executils.CmdManager, error) {
-	toolPath, err := ensureDotnetToolResolved()
+func startDotnetToolInBackground(pid int, args []string, hookers ...executils.Hooker) (executils.CmdManager, error) {
+	toolResolution, err := resolveDotnetToolForPid(pid)
 	if err != nil {
 		return nil, err
 	}
 
-	cmdArgs := append([]string{toolPath}, args...)
+	cmdArgs := append([]string{toolResolution.Path}, args...)
 	logger.Log("Starting dotnet tool in background: %v", cmdArgs)
 
 	cmd, err := executils.CommandStartInBackground(cmdArgs, hookers...)