[PLUTO-1396] Handle tool errors gracefully

Author: zhamborova

cmd/analyze.go

@@ -11,6 +11,7 @@ import (
 	"net/http"
 	"os"
 	"path/filepath"
+	"strings"
 
 	"codacy/cli-v2/utils"
 
@@ -188,42 +189,33 @@ func getToolName(toolName string, version string) string {
 	return toolName
 }
 
-func runEslintAnalysis(workDirectory string, pathsToCheck []string, autoFix bool, outputFile string, outputFormat string) {
+func runEslintAnalysis(workDirectory string, pathsToCheck []string, autoFix bool, outputFile string, outputFormat string) error {
 	eslint := config.Config.Tools()["eslint"]
 	eslintInstallationDirectory := eslint.InstallDir
 	nodeRuntime := config.Config.Runtimes()["node"]
 	nodeBinary := nodeRuntime.Binaries["node"]
 
-	tools.RunEslint(workDirectory, eslintInstallationDirectory, nodeBinary, pathsToCheck, autoFix, outputFile, outputFormat)
+	return tools.RunEslint(workDirectory, eslintInstallationDirectory, nodeBinary, pathsToCheck, autoFix, outputFile, outputFormat)
 }
 
-func runTrivyAnalysis(workDirectory string, pathsToCheck []string, outputFile string, outputFormat string) {
+func runTrivyAnalysis(workDirectory string, pathsToCheck []string, outputFile string, outputFormat string) error {
 	trivy := config.Config.Tools()["trivy"]
 	trivyBinary := trivy.Binaries["trivy"]
 
-	err := tools.RunTrivy(workDirectory, trivyBinary, pathsToCheck, outputFile, outputFormat)
-	if err != nil {
-		log.Fatalf("Error running Trivy: %v", err)
-	}
+	return tools.RunTrivy(workDirectory, trivyBinary, pathsToCheck, outputFile, outputFormat)
 }
 
-func runPmdAnalysis(workDirectory string, pathsToCheck []string, outputFile string, outputFormat string) {
+func runPmdAnalysis(workDirectory string, pathsToCheck []string, outputFile string, outputFormat string) error {
 	pmd := config.Config.Tools()["pmd"]
 	pmdBinary := pmd.Binaries["pmd"]
 
-	err := tools.RunPmd(workDirectory, pmdBinary, pathsToCheck, outputFile, outputFormat, config.Config)
-	if err != nil {
-		log.Fatalf("Error running PMD: %v", err)
-	}
+	return tools.RunPmd(workDirectory, pmdBinary, pathsToCheck, outputFile, outputFormat, config.Config)
 }
 
-func runPylintAnalysis(workDirectory string, pathsToCheck []string, outputFile string, outputFormat string) {
+func runPylintAnalysis(workDirectory string, pathsToCheck []string, outputFile string, outputFormat string) error {
 	pylint := config.Config.Tools()["pylint"]
 
-	err := tools.RunPylint(workDirectory, pylint, pathsToCheck, outputFile, outputFormat)
-	if err != nil {
-		log.Fatalf("Error running Pylint: %v", err)
-	}
+	return tools.RunPylint(workDirectory, pylint, pathsToCheck, outputFile, outputFormat)
 }
 
 var analyzeCmd = &cobra.Command{
@@ -262,13 +254,22 @@ var analyzeCmd = &cobra.Command{
 			defer os.RemoveAll(tmpDir)
 
 			var sarifOutputs []string
+			failedTools := make(map[string]error)
 			for toolName := range toolsToRun {
 				log.Printf("Running %s...\n", toolName)
 				tmpFile := filepath.Join(tmpDir, fmt.Sprintf("%s.sarif", toolName))
-				runTool(workDirectory, toolName, args, tmpFile)
+				if err := runTool(workDirectory, toolName, args, tmpFile); err != nil {
+					log.Printf("Warning: Tool %s failed: %v\n", toolName, err)
+					failedTools[toolName] = err
+					continue
+				}
 				sarifOutputs = append(sarifOutputs, tmpFile)
 			}
 
+			if len(sarifOutputs) == 0 && len(failedTools) > 0 {
+				log.Fatal("All tools failed to run. No analysis results available.")
+			}
+
 			// create output file tmp file
 			tmpOutputFile := filepath.Join(tmpDir, "merged.sarif")
 
@@ -277,6 +278,22 @@ var analyzeCmd = &cobra.Command{
 				log.Fatalf("Failed to merge SARIF outputs: %v", err)
 			}
 
+			// Add error runs to the merged SARIF
+			if len(failedTools) > 0 {
+				mergedSarif, err := utils.ReadSarifFile(tmpOutputFile)
+				if err != nil {
+					log.Fatalf("Failed to read merged SARIF: %v", err)
+				}
+
+				for toolName, err := range failedTools {
+					utils.AddErrorRun(&mergedSarif, toolName, err.Error())
+				}
+
+				if err := utils.WriteSarifFile(mergedSarif, tmpOutputFile); err != nil {
+					log.Fatalf("Failed to write updated SARIF: %v", err)
+				}
+			}
+
 			if outputFile != "" {
 				// copy tmpOutputFile to outputFile
 				content, err := os.ReadFile(tmpOutputFile)
@@ -293,26 +310,83 @@ var analyzeCmd = &cobra.Command{
 				fmt.Println(string(content))
 			}
 		} else {
-			// Run tools without merging outputs
+			// Create temporary directory for individual tool outputs
+			tmpDir, err := os.MkdirTemp("", "codacy-analysis-*")
+			if err != nil {
+				log.Fatalf("Failed to create temporary directory: %v", err)
+			}
+			defer os.RemoveAll(tmpDir)
+
+			var toolOutputs []string
+			failedTools := make(map[string]error)
 			for toolName := range toolsToRun {
 				log.Printf("Running %s...\n", toolName)
-				runTool(workDirectory, toolName, args, outputFile)
+				tmpFile := filepath.Join(tmpDir, fmt.Sprintf("%s.json", toolName))
+				if err := runTool(workDirectory, toolName, args, tmpFile); err != nil {
+					log.Printf("Warning: Tool %s failed: %v\n", toolName, err)
+					failedTools[toolName] = err
+					continue
+				}
+				toolOutputs = append(toolOutputs, tmpFile)
+			}
+
+			// Create merged output
+			mergedOutput := make(map[string]interface{})
+			mergedOutput["tools"] = make(map[string]interface{})
+			mergedOutput["errors"] = make(map[string]string)
+
+			// Add error information
+			for toolName, err := range failedTools {
+				mergedOutput["errors"].(map[string]string)[toolName] = err.Error()
+			}
+
+			// Add tool outputs
+			for _, toolOutput := range toolOutputs {
+				output, err := os.ReadFile(toolOutput)
+				if err != nil {
+					log.Printf("Warning: Failed to read output from %s: %v\n", filepath.Base(toolOutput), err)
+					continue
+				}
+
+				toolName := strings.TrimSuffix(filepath.Base(toolOutput), ".json")
+				var toolOutput interface{}
+				if err := json.Unmarshal(output, &toolOutput); err != nil {
+					log.Printf("Warning: Failed to parse output from %s as JSON, storing raw output: %v", toolName, err)
+					toolOutput = map[string]interface{}{
+						"raw": string(output),
+					}
+				}
+				mergedOutput["tools"].(map[string]interface{})[toolName] = toolOutput
+			}
+
+			// Write merged output
+			mergedJSON, err := json.MarshalIndent(mergedOutput, "", "  ")
+			if err != nil {
+				log.Fatalf("Failed to marshal merged output: %v", err)
+			}
+
+			if outputFile != "" {
+				if err := os.WriteFile(outputFile, mergedJSON, utils.DefaultFilePerms); err != nil {
+					log.Fatalf("Failed to write merged output: %v", err)
+				}
+			} else {
+				fmt.Println(string(mergedJSON))
 			}
 		}
 	},
 }
 
-func runTool(workDirectory string, toolName string, args []string, outputFile string) {
+func runTool(workDirectory string, toolName string, args []string, outputFile string) error {
 	switch toolName {
 	case "eslint":
-		runEslintAnalysis(workDirectory, args, autoFix, outputFile, outputFormat)
+		return runEslintAnalysis(workDirectory, args, autoFix, outputFile, outputFormat)
 	case "trivy":
-		runTrivyAnalysis(workDirectory, args, outputFile, outputFormat)
+		return runTrivyAnalysis(workDirectory, args, outputFile, outputFormat)
 	case "pmd":
-		runPmdAnalysis(workDirectory, args, outputFile, outputFormat)
+		return runPmdAnalysis(workDirectory, args, outputFile, outputFormat)
 	case "pylint":
-		runPylintAnalysis(workDirectory, args, outputFile, outputFormat)
+		return runPylintAnalysis(workDirectory, args, outputFile, outputFormat)
 	default:
-		log.Printf("Warning: Unsupported tool: %s\n", toolName)
+		return fmt.Errorf("unsupported tool: %s", toolName)
 	}
 }

tools/eslintRunner.go

@@ -2,6 +2,7 @@ package tools
 
 import (
 	"codacy/cli-v2/config"
+	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -10,7 +11,7 @@ import (
 // * Run from the root of the repo we want to analyse
 // * NODE_PATH="<the installed eslint path>/node_modules"
 // * The local installed ESLint should have the @microsoft/eslint-formatter-sarif installed
-func RunEslint(repositoryToAnalyseDirectory string, eslintInstallationDirectory string, nodeBinary string, pathsToCheck []string, autoFix bool, outputFile string, outputFormat string) {
+func RunEslint(repositoryToAnalyseDirectory string, eslintInstallationDirectory string, nodeBinary string, pathsToCheck []string, autoFix bool, outputFile string, outputFormat string) error {
 	eslintInstallationNodeModules := filepath.Join(eslintInstallationDirectory, "node_modules")
 	eslintJsPath := filepath.Join(eslintInstallationNodeModules, ".bin", "eslint")
 
@@ -50,10 +51,14 @@ func RunEslint(repositoryToAnalyseDirectory string, eslintInstallationDirectory
 	nodePathEnv := "NODE_PATH=" + eslintInstallationNodeModules
 	cmd.Env = append(cmd.Env, nodePathEnv)
 
-	// DEBUG
-	// fmt.Println(cmd.Env)
-	// fmt.Println(cmd)
-
-	// TODO eslint returns 1 when it finds errors, so we're not propagating it
-	cmd.Run()
+	// Run the command and handle errors
+	err := cmd.Run()
+	if err != nil {
+		// ESLint returns 1 when it finds errors, which is not a failure
+		if exitErr, ok := err.(*exec.ExitError); ok && exitErr.ExitCode() == 1 {
+			return nil
+		}
+		return fmt.Errorf("failed to run ESLint: %w", err)
+	}
+	return nil
 }

tools/pmdRunner.go

@@ -39,6 +39,9 @@ func RunPmd(repositoryToAnalyseDirectory string, pmdBinary string, pathsToCheck
 	// Format
 	if outputFormat != "" {
 		cmd.Args = append(cmd.Args, "-f", outputFormat)
+	} else {
+		// Default to JSON format if no format specified
+		cmd.Args = append(cmd.Args, "-f", "json")
 	}
 
 	// Output file

utils/sarif.go

@@ -27,8 +27,9 @@ type SarifReport struct {
 }
 
 type Run struct {
-	Tool    Tool     `json:"tool"`
-	Results []Result `json:"results"`
+	Tool        Tool         `json:"tool"`
+	Results     []Result     `json:"results"`
+	Invocations []Invocation `json:"invocations,omitempty"`
 }
 
 type Tool struct {
@@ -80,12 +81,83 @@ type ArtifactLocation struct {
 type Region struct {
 	StartLine   int `json:"startLine"`
 	StartColumn int `json:"startColumn"`
+	EndLine     int `json:"endLine"`
+	EndColumn   int `json:"endColumn"`
+}
+
+type Invocation struct {
+	ExecutionSuccessful bool     `json:"executionSuccessful"`
+	ExitCode            int      `json:"exitCode"`
+	ExitSignalName      string   `json:"exitSignalName"`
+	ExitSignalNumber    int      `json:"exitSignalNumber"`
+	Stderr              Artifact `json:"stderr"`
+}
+
+type Artifact struct {
+	Text string `json:"text"`
 }
 
 type MessageText struct {
 	Text string `json:"text"`
 }
 
+// ReadSarifFile reads a SARIF file and returns its contents
+func ReadSarifFile(file string) (SarifReport, error) {
+	data, err := os.ReadFile(file)
+	if err != nil {
+		return SarifReport{}, fmt.Errorf("failed to read SARIF file: %w", err)
+	}
+
+	var sarif SarifReport
+	if err := json.Unmarshal(data, &sarif); err != nil {
+		return SarifReport{}, fmt.Errorf("failed to parse SARIF file: %w", err)
+	}
+
+	return sarif, nil
+}
+
+// WriteSarifFile writes a SARIF report to a file
+func WriteSarifFile(sarif SarifReport, outputFile string) error {
+	out, err := os.Create(outputFile)
+	if err != nil {
+		return fmt.Errorf("failed to create output file: %w", err)
+	}
+	defer out.Close()
+
+	encoder := json.NewEncoder(out)
+	encoder.SetIndent("", "  ")
+	if err := encoder.Encode(sarif); err != nil {
+		return fmt.Errorf("failed to write SARIF: %w", err)
+	}
+
+	return nil
+}
+
+// AddErrorRun adds an error run to an existing SARIF report
+func AddErrorRun(sarif *SarifReport, toolName string, errorMessage string) {
+	errorRun := Run{
+		Tool: Tool{
+			Driver: Driver{
+				Name:    toolName,
+				Version: "1.0.0",
+			},
+		},
+		Invocations: []Invocation{
+			{
+				ExecutionSuccessful: false,
+				ExitCode:            1,
+				ExitSignalName:      "error",
+				ExitSignalNumber:    1,
+				Stderr: Artifact{
+					Text: errorMessage,
+				},
+			},
+		},
+		Results: []Result{},
+	}
+	sarif.Runs = append(sarif.Runs, errorRun)
+}
+
 // ConvertPylintToSarif converts Pylint JSON output to SARIF format
 func ConvertPylintToSarif(pylintOutput []byte) []byte {
 	var issues []PylintIssue