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

This change modifies the issue generator to report individual failed jobs within a workflow run. This provides direct links to the relevant logs for faster debugging.

- Filters for strictly 'failure' conclusions, ignoring noise like 'timed_out'.
- Supports deterministic bulleted lists when multiple jobs fail.
- Adds explicit prefix text to reports for improved clarity.
- Includes unit tests for filtering logic and template rendering.

Author: vyagh

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

@@ -0,0 +1,5 @@
+change_type: enhancement
+component: issuegenerator
+note: "Link to all failing jobs in GitHub Actions instead of general workflow run."
+issues: [1183]
+subtext:

issuegenerator/internal/github/client.go

@@ -24,6 +24,7 @@ import (
 	"net/http"
 	"os"
 	"regexp"
+	"sort"
 	"strconv"
 	"strings"
 
@@ -52,23 +53,25 @@ const (
 	issueBodyTemplate  = `
 Auto-generated report for ${jobName} job build.
 
-Link to failed build: ${linkToBuild}
+Failing job(s): ${linkToBuild}
 Commit: ${commit}
 PR: ${prNumber}
 
 ### Component(s)
 ${component}
 
+The following tests failed:
 ${failedTests}
 
 **Note**: Information about any subsequent build failures that happen while
 this issue is open, will be added as comments with more information to this issue.
 `
 	issueCommentTemplate = `
-Link to latest failed build: ${linkToBuild}
+Failing job(s): ${linkToBuild}
 Commit: ${commit}
 PR: ${prNumber}
 
+The following tests failed:
 ${failedTests}
 `
 	prCommentTemplate = `@${prAuthor} some tests are failing on main after these changes.  
@@ -208,11 +211,10 @@ func (c *Client) GetExistingIssue(ctx context.Context, module string) *github.Is
 // information about the latest failure. This method is expected to be
 // called only if there's an existing open Issue for the current job.
 func (c *Client) CommentOnIssue(ctx context.Context, r report.Report, issue *github.Issue) *github.IssueComment {
-	// Get commit message and extract PR number
 	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,
@@ -231,7 +233,6 @@ func (c *Client) CommentOnIssue(ctx context.Context, r report.Report, issue *git
 		c.handleBadResponses(response)
 	}
 
-	// Also comment on the PR with a link to this comment
 	if prNumber > 0 && issueComment != nil && issueComment.HTMLURL != nil {
 		if prAuthor := c.GetPRAuthor(ctx, prNumber); prAuthor != "" {
 			_ = c.CommentOnPR(ctx, prNumber, prAuthor, *issueComment.HTMLURL)
@@ -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 {
+				fmt.Fprintf(&sb, "\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" {
+				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 {
@@ -404,10 +470,9 @@ func (c *Client) CommentOnPR(ctx context.Context, prNumber int, prAuthor string,
 }
 
 func (c *Client) extractPRNumberFromCommitMessage(commitMsg string) int {
-	// Only consider the first line of the commit message.
 	firstLine := strings.SplitN(commitMsg, "\n", 2)[0]
 
-	// cases matched :
+	// Cases matched:
 	// - (#123)
 	// - Merge pull request #123
 	// - (#123): some description
@@ -438,11 +503,10 @@ func (c *Client) CreateIssue(ctx context.Context, r report.Report) *github.Issue
 	trimmedModule := trimModule(c.envVariables[githubOwner], c.envVariables[githubRepository], r.Module)
 	title := strings.Replace(issueTitleTemplate, "${module}", trimmedModule, 1)
 
-	// Get commit message and extract PR number
 	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()
@@ -465,7 +529,6 @@ func (c *Client) CreateIssue(ctx context.Context, r report.Report) *github.Issue
 		c.handleBadResponses(response)
 	}
 
-	// After creating the issue, also comment on the PR  with a link to the created issue
 	if prNumber > 0 && issue != nil && issue.HTMLURL != nil {
 		if prAuthor := c.GetPRAuthor(ctx, prNumber); prAuthor != "" {
 			_ = c.CommentOnPR(ctx, prNumber, prAuthor, *issue.HTMLURL)

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"
@@ -116,13 +118,14 @@ func TestTemplateExpansion(t *testing.T) {
 			expected: `
 Auto-generated report for ` + "`test-ci`" + ` job build.
 
-Link to failed build: https://github.com/test-org/test-repo/actions/runs/555555
+Failing job(s): https://github.com/test-org/test-repo/actions/runs/555555
 Commit: abcde12
 PR: N/A
 
 ### Component(s)
 ` + "package1" + `
 
+The following tests failed:
 #### Test Failures
 -  ` + "`TestFailure`" + `
 ` + "```" + `
@@ -140,10 +143,11 @@ this issue is open, will be added as comments with more information to this issu
 			name:     "issue comment template",
 			template: issueCommentTemplate,
 			expected: `
-Link to latest failed build: https://github.com/test-org/test-repo/actions/runs/555555
+Failing job(s): https://github.com/test-org/test-repo/actions/runs/555555
 Commit: abcde12
 PR: N/A
 
+The following tests failed:
 #### Test Failures
 -  ` + "`TestFailure`" + `
 ` + "```" + `
@@ -159,7 +163,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 +402,123 @@ 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:  "no failures found",
+			runID: 123,
+			mockResponse: `{"jobs": [
+				{"id": 1, "name": "Success Job", "conclusion": "success", "html_url": "http://job/1"}
+			]}`,
+			expected: map[string]string{},
+		},
+		{
+			name:  "timed_out jobs are excluded",
+			runID: 123,
+			mockResponse: `{"jobs": [
+				{"id": 1, "name": "Failed Job", "conclusion": "failure", "html_url": "http://job/1"},
+				{"id": 2, "name": "Timed out Job", "conclusion": "timed_out", "html_url": "http://job/2"}
+			]}`,
+			expected: map[string]string{"Failed Job": "http://job/1"},
+		},
+	}
+
+	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",
+				},
+			}
+
+			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)
+			}
+		})
+	}
+}
+
+func TestMultiJobTemplateExpansion(t *testing.T) {
+	envVariables := map[string]string{
+		githubWorkflow:   "test-ci",
+		githubServerURL:  "https://github.com",
+		githubOwner:      "test-org",
+		githubRepository: "test-repo",
+		githubRunID:      "555555",
+		githubSHAKey:     "abcde12345",
+	}
+
+	report := report.Report{
+		Module: "test-module",
+	}
+
+	t.Run("single failed job link", func(t *testing.T) {
+		mockResponse := &github.Jobs{Jobs: []*github.WorkflowJob{
+			{Name: github.Ptr("Job A"), Conclusion: github.Ptr("failure"), HTMLURL: github.Ptr("http://job/a")},
+		}}
+		mockedHTTPClient := newMockHTTPClient(t, mock.GetReposActionsRunsJobsByOwnerByRepoByRunId, mockResponse, 0)
+		client := newTestClient(t, mockedHTTPClient)
+		client.envVariables = envVariables
+
+		expand := templateHelper(context.Background(), client, envVariables, report, 0)
+		result := expand("linkToBuild")
+
+		assert.Equal(t, "http://job/a", result)
+	})
+
+	t.Run("multiple failed jobs list", func(t *testing.T) {
+		mockResponse := &github.Jobs{Jobs: []*github.WorkflowJob{
+			{Name: github.Ptr("Job A"), Conclusion: github.Ptr("failure"), HTMLURL: github.Ptr("http://job/a")},
+			{Name: github.Ptr("Job B"), Conclusion: github.Ptr("failure"), HTMLURL: github.Ptr("http://job/b")},
+		}}
+		mockedHTTPClient := newMockHTTPClient(t, mock.GetReposActionsRunsJobsByOwnerByRepoByRunId, mockResponse, 0)
+		client := newTestClient(t, mockedHTTPClient)
+		client.envVariables = envVariables
+
+		expand := templateHelper(context.Background(), client, envVariables, report, 0)
+		assert.Equal(t, "\n- [`Job A`](http://job/a)\n- [`Job B`](http://job/b)", expand("linkToBuild"))
+	})
+}