For .NET capture, the yc-dot-net.exe file was build on 64-bit machine. Due to that if the user is running target process on 32-bit machine then the thread dump and heap data capture was failing. To fix this now generating 2 versions of yc-dot-net.exe file for 32-bit and 64-bit. Enhanced the yc-360 script to automatically read this file based on the OS version.

Author: mahesh-tier1app

internal/capture/dotnet_tool_selector_others.go

@@ -0,0 +1,7 @@
+//go:build !windows
+
+package capture
+
+func resolveDotnetToolByPid(pid int) (string, bool, error) {
+	return "", false, nil
+}

internal/capture/dotnet_tool_selector_windows.go

@@ -0,0 +1,85 @@
+//go:build windows
+
+package capture
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+
+	"golang.org/x/sys/windows"
+	"yc-agent/internal/config"
+)
+
+const (
+	dotnetToolX86 = "yc-dot-net-x86.exe"
+	dotnetToolX64 = "yc-dot-net-x64.exe"
+)
+
+// resolveDotnetToolByPid picks helper binary by target process architecture.
+// Returns (toolPath, true, nil) when selection succeeded.
+// Returns ("", false, nil) when no architecture-specific binary was found.
+func resolveDotnetToolByPid(pid int) (string, bool, error) {
+	targetArch, err := detectWindowsProcessArch(pid)
+	if err != nil {
+		return "", false, nil // non-fatal: caller will use default resolver
+	}
+
+	preferred := dotnetToolX64
+	if targetArch == "x86" {
+		preferred = dotnetToolX86
+	}
+
+	// Search order:
+	// 1) sibling to yc executable
+	// 2) PATH
+	// 3) fallback default name (yc-dot-net.exe)
+	if p, ok := findToolNearYcOrPath(preferred); ok {
+		return p, true, nil
+	}
+	if p, ok := findToolNearYcOrPath(config.DefaultDotnetToolName); ok {
+		return p, true, nil
+	}
+
+	return "", false, fmt.Errorf(".NET helper for target PID %d (%s) not found. expected %s (or %s)", pid, targetArch, preferred, config.DefaultDotnetToolName)
+}
+
+func findToolNearYcOrPath(toolName string) (string, bool) {
+	if exePath, err := os.Executable(); err == nil {
+		candidate := filepath.Join(filepath.Dir(exePath), toolName)
+		if _, statErr := os.Stat(candidate); statErr == nil {
+			return candidate, true
+		}
+	}
+	if resolved, err := exec.LookPath(toolName); err == nil {
+		return resolved, true
+	}
+	return "", false
+}
+
+func detectWindowsProcessArch(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

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"strconv"
 	"strings"
 	"yc-agent/internal/capture/executils"
 	"yc-agent/internal/config"
@@ -53,10 +54,86 @@ func ensureDotnetToolResolved() (string, error) {
 	return resolved, nil
 }
 
+func tryParsePid(value string) (int, bool) {
+	if value == "" {
+		return 0, false
+	}
+	pid, err := strconv.Atoi(value)
+	if err != nil || pid <= 0 {
+		return 0, false
+	}
+	return pid, true
+}
+
+// extractTargetPidFromArgs supports flexible argument ordering, including:
+//   - "-p 1234" / "--pid 1234"
+//   - "-p=1234" / "--pid=1234"
+//   - positional numeric argument (legacy/fallback)
+func extractTargetPidFromArgs(args []string) (int, bool) {
+	// Prefer explicit pid flags first.
+	for i := 0; i < len(args); i++ {
+		arg := strings.TrimSpace(args[i])
+		switch {
+		case arg == "-p" || arg == "--pid":
+			if i+1 < len(args) {
+				if pid, ok := tryParsePid(strings.TrimSpace(args[i+1])); ok {
+					return pid, true
+				}
+			}
+		case strings.HasPrefix(arg, "-p="):
+			if pid, ok := tryParsePid(strings.TrimPrefix(arg, "-p=")); ok {
+				return pid, true
+			}
+		case strings.HasPrefix(arg, "--pid="):
+			if pid, ok := tryParsePid(strings.TrimPrefix(arg, "--pid=")); ok {
+				return pid, true
+			}
+		}
+	}
+
+	// Fallback: first positive integer token in args.
+	for _, arg := range args {
+		if pid, ok := tryParsePid(strings.TrimSpace(arg)); ok {
+			return pid, true
+		}
+	}
+	return 0, false
+}
+
+// resolveDotnetToolForArgs picks the best .NET helper binary for the command:
+//   - If user configured DotnetToolPath explicitly, keep using it.
+//   - Else, if a target PID can be extracted from args, prefer architecture-specific
+//     helper (yc-dot-net-x86.exe / yc-dot-net-x64.exe) and fall back to default resolver.
+func resolveDotnetToolForArgs(args []string) (string, error) {
+	if path := config.GlobalConfig.DotnetToolPath; path != "" {
+		return path, nil
+	}
+
+	// Reuse the canonical pid parsed by config flags first (-p can appear anywhere).
+	if pid, ok := tryParsePid(strings.TrimSpace(config.GlobalConfig.Pid)); ok {
+		if tool, found, err := resolveDotnetToolByPid(pid); err != nil {
+			return "", err
+		} else if found {
+			return tool, nil
+		}
+	}
+
+	// Fallback for direct/internal invocations that bypass GlobalConfig parsing.
+	if pid, ok := extractTargetPidFromArgs(args); ok {
+		if tool, found, err := resolveDotnetToolByPid(pid); err != nil {
+			return "", err
+		} else if found {
+			return tool, nil
+		}
+	}
+
+	return ensureDotnetToolResolved()
+}
+
 // executeDotnetTool runs the configured .NET helper 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()
+	toolPath, err := resolveDotnetToolForArgs(args)
 	if err != nil {
 		return nil, err
 	}
@@ -147,7 +224,7 @@ func executeDotnetTool(args []string, outputPath string) (*os.File, error) {
 // startDotnetToolInBackground starts the configured .NET helper 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()
+	toolPath, err := resolveDotnetToolForArgs(args)
 	if err != nil {
 		return nil, err
 	}