feat(issuegenerator): link to specific failing job instead of workflow run

Author: vyagh

.chloggen/feat_issuegenerator-failed-job-link.yaml

@@ -0,0 +1,16 @@
+# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix'
+change_type: enhancement
+
+# The name of the component, or a single word describing the area of concern, (e.g. crosslink)
+component: issuegenerator
+
+# A brief description of the change.  Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: "Link to specific failing job in GitHub Issues instead of general workflow run."
+
+# One or more tracking issues related to the change
+issues: [1183]
+
+# (Optional) One or more lines of additional information to render under the primary note.
+# These lines will be padded with 2 spaces and then inserted directly into the document.
+# Use pipe (|) for multiline entries.
+subtext:

issuegenerator/internal/github/client.go

@@ -24,6 +24,7 @@ import (
 	"net/http"
 	"os"
 	"regexp"
+	"sort"
 	"strconv"
 	"strings"
 
@@ -212,7 +213,7 @@ func (c *Client) CommentOnIssue(ctx context.Context, r report.Report, issue *git
 	commitMessage := c.getCommitMessage(ctx)
 	prNumber := c.extractPRNumberFromCommitMessage(commitMessage)
 
-	body := os.Expand(issueCommentTemplate, templateHelper(c.envVariables, r, prNumber))
+	body := os.Expand(issueCommentTemplate, templateHelper(ctx, c, c.envVariables, r, prNumber))
 
 	issueComment, response, err := c.client.Issues.CreateComment(
 		ctx,
@@ -261,13 +262,46 @@ func getComponent(module string) string {
 	return module
 }
 
-func templateHelper(env map[string]string, r report.Report, prNumber int) func(string) string {
+func templateHelper(ctx context.Context, c *Client, env map[string]string, r report.Report, prNumber int) func(string) string {
 	return func(param string) string {
 		switch param {
 		case "jobName":
 			return "`" + env[githubWorkflow] + "`"
 		case "linkToBuild":
-			return fmt.Sprintf("%s/%s/%s/actions/runs/%s", env[githubServerURL], env[githubOwner], env[githubRepository], env[githubRunID])
+			runID, err := strconv.ParseInt(env[githubRunID], 10, 64)
+			if err != nil {
+				c.logger.Warn("Failed to parse run ID", zap.Error(err))
+				return c.getRunURL(env[githubRunID])
+			}
+
+			failedJobs, err := c.getFailedJobURLs(ctx, runID)
+			if err != nil {
+				c.logger.Warn("Failed to get failed job URLs", zap.Error(err))
+				return c.getRunURL(strconv.FormatInt(runID, 10))
+			}
+
+			if len(failedJobs) == 0 {
+				return c.getRunURL(strconv.FormatInt(runID, 10))
+			}
+
+			if len(failedJobs) == 1 {
+				for _, url := range failedJobs {
+					return url
+				}
+			}
+
+			// Sort by name for deterministic output
+			names := make([]string, 0, len(failedJobs))
+			for name := range failedJobs {
+				names = append(names, name)
+			}
+			sort.Strings(names)
+
+			var sb strings.Builder
+			for _, name := range names {
+				sb.WriteString(fmt.Sprintf("\n- [`%s`](%s)", name, failedJobs[name]))
+			}
+			return sb.String()
 		case "failedTests":
 			return r.FailedTestsMD()
 		case "component":
@@ -286,6 +320,38 @@ func templateHelper(env map[string]string, r report.Report, prNumber int) func(s
 	}
 }
 
+// getFailedJobURLs fetches the names and URLs of the failed jobs in the current run.
+func (c *Client) getFailedJobURLs(ctx context.Context, runID int64) (map[string]string, error) {
+	failedJobs := make(map[string]string)
+	opts := &github.ListWorkflowJobsOptions{ListOptions: github.ListOptions{PerPage: 100}}
+	for {
+		jobs, resp, err := c.client.Actions.ListWorkflowJobs(ctx, c.envVariables[githubOwner], c.envVariables[githubRepository], runID, opts)
+		if err != nil {
+			return nil, err
+		}
+		for _, job := range jobs.Jobs {
+			if job.GetConclusion() == "failure" || job.GetConclusion() == "timed_out" {
+				failedJobs[job.GetName()] = job.GetHTMLURL()
+			}
+		}
+		if resp.NextPage == 0 {
+			break
+		}
+		opts.Page = resp.NextPage
+	}
+	return failedJobs, nil
+}
+
+// getRunURL returns the generic workflow run URL.
+func (c *Client) getRunURL(runID string) string {
+	return fmt.Sprintf("%s/%s/%s/actions/runs/%s",
+		c.envVariables[githubServerURL],
+		c.envVariables[githubOwner],
+		c.envVariables[githubRepository],
+		runID,
+	)
+}
+
 // shortSha returns the first 7 characters of a full Git commit SHA
 func shortSha(sha string) string {
 	if len(sha) >= 7 {
@@ -442,7 +508,7 @@ func (c *Client) CreateIssue(ctx context.Context, r report.Report) *github.Issue
 	commitMessage := c.getCommitMessage(ctx)
 	prNumber := c.extractPRNumberFromCommitMessage(commitMessage)
 
-	body := os.Expand(issueBodyTemplate, templateHelper(c.envVariables, r, prNumber))
+	body := os.Expand(issueBodyTemplate, templateHelper(ctx, c, c.envVariables, r, prNumber))
 	componentName := getComponent(trimmedModule)
 
 	issueLabels := c.cfg.labelsCopy()

issuegenerator/internal/github/client_test.go

@@ -15,8 +15,10 @@
 package github
 
 import (
+	"context"
 	"encoding/json"
 	"net/http"
+	"net/http/httptest"
 	"os"
 	"path/filepath"
 	"sort"
@@ -159,7 +161,13 @@ PR: N/A
 	require.GreaterOrEqual(t, len(reports), len(tests))
 	for i, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := os.Expand(tt.template, templateHelper(envVariables, reports[i], 0))
+			// Return empty list to test the fallback logic (getRunURL)
+			mockedHTTPClient := newMockHTTPClient(t, mock.GetReposActionsRunsJobsByOwnerByRepoByRunId, &github.Jobs{Jobs: []*github.WorkflowJob{}}, 0)
+			client := newTestClient(t, mockedHTTPClient)
+			// Ensure client env vars match test vars
+			client.envVariables = envVariables
+
+			result := os.Expand(tt.template, templateHelper(context.Background(), client, envVariables, reports[i], 0))
 			assert.Equal(t, tt.expected, result)
 		})
 	}
@@ -392,3 +400,82 @@ func TestExtractPRNumberFromMessage(t *testing.T) {
 		})
 	}
 }
+
+func TestGetFailedJobURLs(t *testing.T) {
+	tests := []struct {
+		name         string
+		runID        int64
+		mockResponse string
+		expected     map[string]string
+		expectErr    bool
+	}{
+		{
+			name:  "single failure found",
+			runID: 123,
+			mockResponse: `{"jobs": [
+				{"id": 1, "name": "Success Job", "conclusion": "success", "html_url": "http://job/1"},
+				{"id": 2, "name": "Failed Job", "conclusion": "failure", "html_url": "http://job/2"}
+			]}`,
+			expected: map[string]string{"Failed Job": "http://job/2"},
+		},
+		{
+			name:  "multiple failures",
+			runID: 123,
+			mockResponse: `{"jobs": [
+				{"id": 1, "name": "Lint", "conclusion": "failure", "html_url": "http://job/1"},
+				{"id": 2, "name": "Test-Linux", "conclusion": "failure", "html_url": "http://job/2"},
+				{"id": 3, "name": "Test-Windows", "conclusion": "success", "html_url": "http://job/3"}
+			]}`,
+			expected: map[string]string{"Lint": "http://job/1", "Test-Linux": "http://job/2"},
+		},
+		{
+			name:  "timed_out treated as failure",
+			runID: 123,
+			mockResponse: `{"jobs": [
+				{"id": 1, "name": "Success Job", "conclusion": "success", "html_url": "http://job/1"},
+				{"id": 2, "name": "Timeout Job", "conclusion": "timed_out", "html_url": "http://job/2"}
+			]}`,
+			expected: map[string]string{"Timeout Job": "http://job/2"},
+		},
+		{
+			name:  "no failures found",
+			runID: 123,
+			mockResponse: `{"jobs": [
+				{"id": 1, "name": "Success Job", "conclusion": "success", "html_url": "http://job/1"}
+			]}`,
+			expected: map[string]string{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+				w.WriteHeader(http.StatusOK)
+				_, err := w.Write([]byte(tt.mockResponse))
+				require.NoError(t, err)
+			}))
+			defer server.Close()
+
+			client := &Client{
+				logger: zaptest.NewLogger(t),
+				envVariables: map[string]string{
+					githubOwner:      testOwner,
+					githubRepository: testRepo,
+					githubServerURL:  "https://github.com",
+				},
+			}
+
+			// Override client base URL to point to mock server
+			c, _ := github.NewClient(nil).WithEnterpriseURLs(server.URL, server.URL)
+			client.client = c
+
+			failedJobs, err := client.getFailedJobURLs(context.Background(), tt.runID)
+			if tt.expectErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				assert.Equal(t, tt.expected, failedJobs)
+			}
+		})
+	}
+}