add bz, operator, and sig mappings

main.go

@@ -31,10 +31,13 @@ var (
 )
 
 type RawData struct {
-	ByAll       map[string]util.AggregateTestResult
-	ByJob       map[string]util.AggregateTestResult
-	ByPlatform  map[string]util.AggregateTestResult
-	BySig       map[string]util.AggregateTestResult
+	ByAll      map[string]util.AggregateTestResult
+	ByJob      map[string]util.AggregateTestResult
+	ByPlatform map[string]util.AggregateTestResult
+	BySig      map[string]util.AggregateTestResult
+	// ByBugzillaComponent has keys that are a best guess of the bugzilla component which is causing the failing test.
+	ByBugzillaComponent map[string]util.AggregateTestResult
+
 	JobRuns     map[string]util.JobRunResult
 	JobDetails  []testgrid.JobDetails
 	BugFailures map[string]util.Bug
@@ -621,18 +624,21 @@ func (a *Analyzer) prepareTestReport(prev bool) {
 	byPlatform := util.GenerateSortedResults(a.RawData.ByPlatform, a.Options.MinTestRuns, a.Options.TestSuccessThreshold)
 	byJob := util.GenerateSortedResults(a.RawData.ByJob, a.Options.MinTestRuns, a.Options.TestSuccessThreshold)
 	bySig := util.GenerateSortedResults(a.RawData.BySig, a.Options.MinTestRuns, a.Options.TestSuccessThreshold)
+	byBugzillaComponent := util.GenerateSortedResults(a.RawData.ByBugzillaComponent, a.Options.MinTestRuns, a.Options.TestSuccessThreshold)
 
 	filteredFailureGroups := util.FilterFailureGroups(a.RawData.JobRuns, a.Options.FailureClusterThreshold)
 	jobPassRate := util.ComputeJobPassRate(a.RawData.JobRuns)
 
 	bugFailureCounts := util.GenerateSortedBugFailureCounts(a.RawData.BugFailures)
 
 	a.Report = util.TestReport{
-		Release:            a.Release,
-		All:                byAll,
-		ByPlatform:         byPlatform,
-		ByJob:              byJob,
-		BySig:              bySig,
+		Release:             a.Release,
+		All:                 byAll,
+		ByPlatform:          byPlatform,
+		ByJob:               byJob,
+		BySig:               bySig,
+		ByBugzillaComponent: byBugzillaComponent,
+
 		FailureGroups:      filteredFailureGroups,
 		JobPassRate:        jobPassRate,
 		Timestamp:          a.LastUpdateTime,
@@ -847,12 +853,13 @@ func (s *Server) refresh(w http.ResponseWriter, req *http.Request) {
 
 	for k, analyzer := range s.analyzers {
 		analyzer.RawData = RawData{
-			ByAll:       make(map[string]util.AggregateTestResult),
-			ByJob:       make(map[string]util.AggregateTestResult),
-			ByPlatform:  make(map[string]util.AggregateTestResult),
-			BySig:       make(map[string]util.AggregateTestResult),
-			JobRuns:     make(map[string]util.JobRunResult),
-			BugFailures: make(map[string]util.Bug),
+			ByAll:               make(map[string]util.AggregateTestResult),
+			ByJob:               make(map[string]util.AggregateTestResult),
+			ByPlatform:          make(map[string]util.AggregateTestResult),
+			BySig:               make(map[string]util.AggregateTestResult),
+			ByBugzillaComponent: make(map[string]util.AggregateTestResult),
+			JobRuns:             make(map[string]util.JobRunResult),
+			BugFailures:         make(map[string]util.Bug),
 		}
 
 		analyzer.loadData([]string{analyzer.Release}, analyzer.Options.LocalData)
@@ -971,12 +978,13 @@ func (s *Server) detailed(w http.ResponseWriter, req *http.Request) {
 		Release: release,
 		Options: opt,
 		RawData: RawData{
-			ByAll:       make(map[string]util.AggregateTestResult),
-			ByJob:       make(map[string]util.AggregateTestResult),
-			ByPlatform:  make(map[string]util.AggregateTestResult),
-			BySig:       make(map[string]util.AggregateTestResult),
-			JobRuns:     make(map[string]util.JobRunResult),
-			BugFailures: make(map[string]util.Bug),
+			ByAll:               make(map[string]util.AggregateTestResult),
+			ByJob:               make(map[string]util.AggregateTestResult),
+			ByPlatform:          make(map[string]util.AggregateTestResult),
+			BySig:               make(map[string]util.AggregateTestResult),
+			ByBugzillaComponent: make(map[string]util.AggregateTestResult),
+			JobRuns:             make(map[string]util.JobRunResult),
+			BugFailures:         make(map[string]util.Bug),
 		},
 	}
 	analyzer.loadData([]string{release}, s.options.LocalData)
@@ -991,12 +999,13 @@ func (s *Server) detailed(w http.ResponseWriter, req *http.Request) {
 		Release: release,
 		Options: &optCopy,
 		RawData: RawData{
-			ByAll:       make(map[string]util.AggregateTestResult),
-			ByJob:       make(map[string]util.AggregateTestResult),
-			ByPlatform:  make(map[string]util.AggregateTestResult),
-			BySig:       make(map[string]util.AggregateTestResult),
-			JobRuns:     make(map[string]util.JobRunResult),
-			BugFailures: make(map[string]util.Bug),
+			ByAll:               make(map[string]util.AggregateTestResult),
+			ByJob:               make(map[string]util.AggregateTestResult),
+			ByPlatform:          make(map[string]util.AggregateTestResult),
+			BySig:               make(map[string]util.AggregateTestResult),
+			ByBugzillaComponent: make(map[string]util.AggregateTestResult),
+			JobRuns:             make(map[string]util.JobRunResult),
+			BugFailures:         make(map[string]util.Bug),
 		},
 	}
 	prevAnalyzer.loadData([]string{release}, s.options.LocalData)
@@ -1094,12 +1103,13 @@ func (o *Options) Run() error {
 		analyzer := Analyzer{
 			Options: o,
 			RawData: RawData{
-				ByAll:       make(map[string]util.AggregateTestResult),
-				ByJob:       make(map[string]util.AggregateTestResult),
-				ByPlatform:  make(map[string]util.AggregateTestResult),
-				BySig:       make(map[string]util.AggregateTestResult),
-				JobRuns:     make(map[string]util.JobRunResult),
-				BugFailures: make(map[string]util.Bug),
+				ByAll:               make(map[string]util.AggregateTestResult),
+				ByJob:               make(map[string]util.AggregateTestResult),
+				ByPlatform:          make(map[string]util.AggregateTestResult),
+				BySig:               make(map[string]util.AggregateTestResult),
+				ByBugzillaComponent: make(map[string]util.AggregateTestResult),
+				JobRuns:             make(map[string]util.JobRunResult),
+				BugFailures:         make(map[string]util.Bug),
 			},
 		}
 
@@ -1119,12 +1129,13 @@ func (o *Options) Run() error {
 				Release: release,
 				Options: o,
 				RawData: RawData{
-					ByAll:       make(map[string]util.AggregateTestResult),
-					ByJob:       make(map[string]util.AggregateTestResult),
-					ByPlatform:  make(map[string]util.AggregateTestResult),
-					BySig:       make(map[string]util.AggregateTestResult),
-					JobRuns:     make(map[string]util.JobRunResult),
-					BugFailures: make(map[string]util.Bug),
+					ByAll:               make(map[string]util.AggregateTestResult),
+					ByJob:               make(map[string]util.AggregateTestResult),
+					ByPlatform:          make(map[string]util.AggregateTestResult),
+					BySig:               make(map[string]util.AggregateTestResult),
+					ByBugzillaComponent: make(map[string]util.AggregateTestResult),
+					JobRuns:             make(map[string]util.JobRunResult),
+					BugFailures:         make(map[string]util.Bug),
 				},
 			}
 			analyzer.loadData([]string{release}, o.LocalData)
@@ -1140,12 +1151,13 @@ func (o *Options) Run() error {
 				Release: release,
 				Options: &optCopy,
 				RawData: RawData{
-					ByAll:       make(map[string]util.AggregateTestResult),
-					ByJob:       make(map[string]util.AggregateTestResult),
-					ByPlatform:  make(map[string]util.AggregateTestResult),
-					BySig:       make(map[string]util.AggregateTestResult),
-					JobRuns:     make(map[string]util.JobRunResult),
-					BugFailures: make(map[string]util.Bug),
+					ByAll:               make(map[string]util.AggregateTestResult),
+					ByJob:               make(map[string]util.AggregateTestResult),
+					ByPlatform:          make(map[string]util.AggregateTestResult),
+					BySig:               make(map[string]util.AggregateTestResult),
+					ByBugzillaComponent: make(map[string]util.AggregateTestResult),
+					JobRuns:             make(map[string]util.JobRunResult),
+					BugFailures:         make(map[string]util.Bug),
 				},
 			}
 			analyzer.loadData([]string{release}, o.LocalData)

pkg/util/components.go

@@ -0,0 +1,160 @@
+package util
+
+import (
+	"fmt"
+
+	"github.com/openshift/sippy/pkg/util/sets"
+)
+
+var (
+	ValidBugzillaComponents = sets.NewString(
+		"apiserver-auth",
+		"assisted-installer",
+		"Bare Metal Hardware Provisioning",
+		"Build",
+		"Cloud Compute",
+		"Cloud Credential Operator",
+		"Cluster Loader",
+		"Cluster Version Operator",
+		"CNF Platform Validation",
+		"Compliance Operator",
+		"config-operator",
+		"Console Kubevirt Plugin",
+		"Console Metal3 Plugin",
+		"Console Storage Plugin",
+		"Containers",
+		"crc",
+		"Dev Console",
+		"DNS",
+		"Documentation",
+		"Etcd",
+		"Federation",
+		"File Integrity Operator",
+		"Fuse",
+		"Hawkular",
+		"ibm-roks-toolkit",
+		"Image",
+		"Image Registry",
+		"Insights Operator",
+		"Installer",
+		"ISV Operators",
+		"Jenkins",
+		"kata-containers",
+		"kube-apiserver",
+		"kube-controller-manager",
+		"kube-scheduler",
+		"kube-storage-version-migrator",
+		"Logging",
+		"Machine Config Operator",
+		"Management Console",
+		"Metering Operator",
+		"Migration Tooling",
+		"Monitoring",
+		"Multi-Arch",
+		"Multi-cluster-management",
+		"Networking",
+		"Node",
+		"Node Feature Discovery Operator",
+		"Node Tuning Operator",
+		"oauth-apiserver",
+		"oauth-proxy",
+		"oc",
+		"OLM",
+		"openshift-apiserver",
+		"openshift-controller-manager",
+		"Operator SDK",
+		"Performance Addon Operator",
+		"Reference Architecture",
+		"Registry Console",
+		"Release",
+		"RHCOS",
+		"RHMI Monitoring",
+		"Routing",
+		"Samples",
+		"Security",
+		"Service Broker",
+		"Service Catalog",
+		"service-ca",
+		"Special Resources Operator",
+		"Storage",
+		"Templates",
+		"Test Infrastructure",
+		"Unknown",
+		"Windows Containers",
+	)
+
+	OperatorToBugzillaComponent = map[string]string{}
+
+	// SigToBugzillaComponent holds `sig-foo` (from '[sig-foo]' label in a test) as keys and maps them to the "most correct" BZ component
+	SigToBugzillaComponent = map[string]string{}
+)
+
+func init() {
+	Must(addOperatorMapping("authentication", "apiserver-auth"))
+	Must(addOperatorMapping("cloud-credential", "Cloud Credential Operator"))
+	Must(addOperatorMapping("cluster-autoscaler", "Cloud Compute"))
+	Must(addOperatorMapping("config-operator", "config-operator"))
+	Must(addOperatorMapping("console", "foo"))
+	Must(addOperatorMapping("csi-snapshot-controller", "Storage"))
+	Must(addOperatorMapping("dns", "DNS"))
+	Must(addOperatorMapping("etcd", "Etcd"))
+	Must(addOperatorMapping("ingress", "Routing"))
+	Must(addOperatorMapping("image-registry", "Image Registry"))
+	Must(addOperatorMapping("insights", "Insights Operator"))
+	Must(addOperatorMapping("kube-apiserver", "kube-apiserver"))
+	Must(addOperatorMapping("kube-controller-manager", "kube-controller-manager"))
+	Must(addOperatorMapping("kube-scheduler", "kube-scheduler"))
+	Must(addOperatorMapping("kube-storage-version-migrator", "kube-storage-version-migrator"))
+	Must(addOperatorMapping("machine-api", "Cloud Compute"))
+	Must(addOperatorMapping("machine-approver", "Cloud Compute"))
+	Must(addOperatorMapping("machine-config", "Machine Config Operator"))
+	Must(addOperatorMapping("marketplace", "OLM"))
+	Must(addOperatorMapping("monitoring", "Monitoring"))
+	Must(addOperatorMapping("network", "Networking"))
+	Must(addOperatorMapping("node-tuning", "Node Tuning Operator"))
+	Must(addOperatorMapping("openshift-apiserver", "openshift-apiserver"))
+	Must(addOperatorMapping("openshift-controller-manager", "openshift-controller-manager"))
+	Must(addOperatorMapping("openshift-samples", "Samples"))
+	Must(addOperatorMapping("operator-lifecycle-manager", "OLM"))
+	Must(addOperatorMapping("operator-lifecycle-manager-catalog", "OLM"))
+	Must(addOperatorMapping("operator-lifecycle-manager-packageserver", "OLM"))
+	Must(addOperatorMapping("service-ca", "service-ca"))
+	Must(addOperatorMapping("storage", "Storage"))
+
+	Must(addOperatorMapping("sig-cli", "oc"))
+	Must(addOperatorMapping("sig-api-machinery", "kube-apiserver"))
+	Must(addOperatorMapping("sig-apps", "kube-controller-manager"))
+	Must(addOperatorMapping("sig-arch", "Unknown"))
+	Must(addOperatorMapping("sig-auth", "apiserver-auth"))
+	Must(addOperatorMapping("sig-builds", "Build"))
+	Must(addOperatorMapping("sig-cli", "oc"))
+	Must(addOperatorMapping("sig-cluster-lifecycle", "Unknown"))
+	Must(addOperatorMapping("sig-devex", "Build"))
+	Must(addOperatorMapping("sig-imageregistry", "Image Registry"))
+	Must(addOperatorMapping("sig-network", "Networking"))
+	Must(addOperatorMapping("sig-node", "Node"))
+	Must(addOperatorMapping("sig-operator", "OLM"))
+	Must(addOperatorMapping("sig-storage", "Storage"))
+}
+
+func Must(err error) {
+	if err != nil {
+		panic(err)
+	}
+}
+
+func addOperatorMapping(operator, bugzillaComponent string) error {
+	if !ValidBugzillaComponents.Has(bugzillaComponent) {
+		return fmt.Errorf("%q is not a valid bugzilla component")
+	}
+	OperatorToBugzillaComponent[operator] = bugzillaComponent
+	return nil
+}
+
+func addSigMapping(sig, bugzillaComponent string) error {
+	if !ValidBugzillaComponents.Has(bugzillaComponent) {
+		return fmt.Errorf("%q is not a valid bugzilla component")
+	}
+	SigToBugzillaComponent[sig] = bugzillaComponent
+	return nil
+}

pkg/util/utils.go

@@ -2,6 +2,7 @@ package util
 
 import (
 	"fmt"
+
 	//	"io/ioutil"
 	"encoding/json"
 	"math"
@@ -54,17 +55,19 @@ var (
 )
 
 type TestReport struct {
-	Release                   string                               `json:"release"`
-	All                       map[string]SortedAggregateTestResult `json:"all"`
-	ByPlatform                map[string]SortedAggregateTestResult `json:"byPlatform`
-	ByJob                     map[string]SortedAggregateTestResult `json:"byJob`
-	BySig                     map[string]SortedAggregateTestResult `json:"bySig`
-	FailureGroups             []JobRunResult                       `json:"failureGroups"`
-	JobPassRate               []JobResult                          `json:"jobPassRate"`
-	Timestamp                 time.Time                            `json:"timestamp"`
-	TopFailingTestsWithBug    []*TestResult                        `json:"topFailingTestsWithBug"`
-	TopFailingTestsWithoutBug []*TestResult                        `json:"topFailingTestsWithoutBug"`
-	BugsByFailureCount        []Bug                                `json:"bugsByFailureCount"`
+	Release             string                               `json:"release"`
+	All                 map[string]SortedAggregateTestResult `json:"all"`
+	ByPlatform          map[string]SortedAggregateTestResult `json:"byPlatform`
+	ByJob               map[string]SortedAggregateTestResult `json:"byJob`
+	BySig               map[string]SortedAggregateTestResult `json:"bySig`
+	ByBugzillaComponent map[string]SortedAggregateTestResult `json:"byBugzillaComponent`
+
+	FailureGroups             []JobRunResult `json:"failureGroups"`
+	JobPassRate               []JobResult    `json:"jobPassRate"`
+	Timestamp                 time.Time      `json:"timestamp"`
+	TopFailingTestsWithBug    []*TestResult  `json:"topFailingTestsWithBug"`
+	TopFailingTestsWithoutBug []*TestResult  `json:"topFailingTestsWithoutBug"`
+	BugsByFailureCount        []Bug          `json:"bugsByFailureCount"`
 }
 
 type SortedAggregateTestResult struct {
@@ -83,6 +86,7 @@ type AggregateTestResult struct {
 
 type TestResult struct {
 	Name           string  `json:"name"`
+	Sig            string  `json:"sig"`
 	Successes      int     `json:"successes"`
 	Failures       int     `json:"failures"`
 	Flakes         int     `json:"flakes"`
@@ -101,6 +105,9 @@ type JobRunResult struct {
 	HasUnknownFailures bool     `json:"hasUnknownFailures"`
 	Succeeded          bool     `json:"succeeded"`
 
+	// FailingComponents holds a list of the components whose tests failed (not flaked, failed) in this JobRun
+	FailingBugzillaComponents []string `json:"failingComponents"`
+
 	// SetupStatus can be "", "Success", "Failure"
 	SetupStatus      string          `json:"setupStatus"`
 	InstallOperators []OperatorState `json:"installOperators"`