Skip to content

TRT-2737: Rewrite test analysis queries to use test_daily_totals and test_cumulative_summaries #3747

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
openshift-merge-bot merged 1 commit into from
Jul 24, 2026
Merged

TRT-2737: Rewrite test analysis queries to use test_daily_totals and test_cumulative_summaries #3747

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion pkg/api/job_runs.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -492,7 +492,7 @@ func jobNamesTestResultFunc(dbc *db.DB, release string) testResultsByJobNameFunc

analyzeSince := time.Now().Add(-14 * 24 * time.Hour)

q := dbc.DB.Raw(query.QueryTestAnalysis, analyzeSince, testName, jobNames, release)
q := dbc.DB.Raw(query.QueryTestAnalysis, analyzeSince, release, release, testName, jobNames)
if q.Error != nil {
return nil, q.Error
}
Expand Down
239 changes: 119 additions & 120 deletions pkg/api/test_analysis.go
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,71 +1,104 @@
package api

import (
"strings"
"time"

"cloud.google.com/go/civil"
log "github.com/sirupsen/logrus"
"gorm.io/gorm"

"github.com/openshift/sippy/pkg/db"
"github.com/openshift/sippy/pkg/filter"
)

const testAnalysisLookbackDays = 14

type CountByDate struct {
Date string `json:"date"`
Group string `json:"group"`
PassPercentage float64 `json:"pass_percentage"`
FlakePercentage float64 `json:"flake_percentage"`
FailPercentage float64 `json:"fail_percentage"`
Runs int `json:"runs"`
Passes int `json:"passes"`
Flakes int `json:"flakes"`
Failures int `json:"failures"`
Date civil.Date `json:"date"`

@neisw neisw Jul 22, 2026

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Is this deployed on staging? Looks as though CountByDate is returned externally

Claude noted the following and it seems worth double checking

- civil.Date serializes as {"year":2026,"month":7,"day":22} by default
- API clients expect "2026-07-22" string format
- This breaks API compatibility

@mstaeble mstaeble Jul 22, 2026

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Verified locally against staging. civil.Date implements MarshalJSON/UnmarshalJSON and serializes as "2026-07-08" (standard YYYY-MM-DD string), not as a struct. All three endpoints (/overall, /jobs, /variants)
return the same string format as before. No API compatibility change.

Group string `json:"group"`
PassPercentage float64 `json:"pass_percentage"`
FlakePercentage float64 `json:"flake_percentage"`
FailPercentage float64 `json:"fail_percentage"`
Runs int `json:"runs"`
Passes int `json:"passes"`
Flakes int `json:"flakes"`
Failures int `json:"failures"`
}

func GetTestAnalysisOverallFromDB(dbc *db.DB, filters *filter.Filter, release, testName string, reportEnd time.Time) (map[string][]CountByDate, error) {
var rows []CountByDate
jq := dbc.DB.Table("test_analysis_by_job_by_dates").
Select(`test_id,
test_name,
to_date((date at time zone 'UTC')::text, 'YYYY-MM-DD'::text)::text as date,
'overall' as group,
SUM(runs) as runs,
SUM(passes) as passes,
SUM(flakes) as flakes,
SUM(failures) as failures,
SUM(passes) * 100.0 / NULLIF(SUM(runs), 0) AS pass_percentage,
SUM(flakes) * 100.0 / NULLIF(SUM(runs), 0) AS flake_percentage,
SUM(failures) * 100.0 / NULLIF(SUM(runs), 0) AS fail_percentage`).
Joins("JOIN prow_jobs on prow_jobs.name = job_name").
Where("test_analysis_by_job_by_dates.release = ?", release).
Where("test_name = ?", testName).
Where("date >= ?", time.Now().Add(-24*14*time.Hour)).
Order("date ASC").
Group("date, test_id, test_name, test_analysis_by_job_by_dates.release")

var allowedVariants, blockedVariants []string
if filters != nil {
for _, f := range filters.Items {
if f.Field == "variants" {
if f.Not {
blockedVariants = append(blockedVariants, f.Value)
} else {
allowedVariants = append(allowedVariants, f.Value)
}
func extractVariantFilters(filters *filter.Filter) (allowed, blocked []string) {
if filters == nil {
return nil, nil
}
for _, f := range filters.Items {
if f.Field == "variants" {
if f.Not {
blocked = append(blocked, f.Value)
} else {
allowed = append(allowed, f.Value)
}
}
}
return allowed, blocked
}

for _, bv := range blockedVariants {
jq = jq.Where("NOT EXISTS (SELECT 1 FROM variant_combinations WHERE ? = any(variants) AND id = prow_jobs.variant_combination_id)", bv)
func applyVariantCombinationFilters(q *gorm.DB, allowed, blocked []string) *gorm.DB {
for _, bv := range blocked {
q = q.Where("NOT EXISTS (SELECT 1 FROM variant_combinations WHERE ? = ANY(variants) AND id = pj.variant_combination_id)", bv)
}

for _, av := range allowedVariants {
jq = jq.Where("prow_jobs.variant_combination_id IN (SELECT id FROM variant_combinations WHERE ? = any(variants))", av)
for _, av := range allowed {
q = q.Where("EXISTS (SELECT 1 FROM variant_combinations WHERE ? = ANY(variants) AND id = pj.variant_combination_id)", av)
}
return q
}
Comment thread
coderabbitai[bot] marked this conversation as resolved.

var testAnalysisAggColumns = []string{
"SUM(tds.runs) AS runs",
"SUM(tds.successes) AS passes",
"SUM(tds.flakes) AS flakes",
"SUM(tds.failures) AS failures",
"SUM(tds.successes) * 100.0 / NULLIF(SUM(tds.runs), 0) AS pass_percentage",
"SUM(tds.flakes) * 100.0 / NULLIF(SUM(tds.runs), 0) AS flake_percentage",
"SUM(tds.failures) * 100.0 / NULLIF(SUM(tds.runs), 0) AS fail_percentage",
}

// withAggColumns appends the shared test analysis aggregation columns
// to the supplied per-query columns and joins them into a SELECT string.
func withAggColumns(columns ...string) string {
return strings.Join(append(columns, testAnalysisAggColumns...), ", ")
}

func testAnalysisBaseQuery(dbc *db.DB, filters *filter.Filter, release, testName string, since civil.Date) *gorm.DB {
q := dbc.DB.Table("test_daily_totals tds").
Joins("JOIN tests t ON t.id = tds.test_id").
Joins("JOIN prow_jobs pj ON pj.id = tds.prow_job_id").
Where("tds.release = ?", release).
Where("t.name = ?", testName).
Where("tds.date >= ?", since).
Order("tds.date ASC")

allowed, blocked := extractVariantFilters(filters)
return applyVariantCombinationFilters(q, allowed, blocked)
}

func GetTestAnalysisOverallFromDB(dbc *db.DB, filters *filter.Filter, release, testName string, reportEnd time.Time) (map[string][]CountByDate, error) {
endDate := civil.DateOf(reportEnd.UTC())
sinceDate := endDate.AddDays(-testAnalysisLookbackDays)

var rows []CountByDate
jq := testAnalysisBaseQuery(dbc, filters, release, testName, sinceDate).
Select(withAggColumns(
"tds.test_id",
`t.name AS test_name`,
`tds.date AS date`,
`'overall' AS "group"`,
)).
Where("tds.date <= ?", endDate).
Group("tds.date, tds.test_id, t.name, tds.release")

r := jq.Scan(&rows)
if r.Error != nil {
log.WithError(r.Error).Error("error querying test analysis by job")
log.WithError(r.Error).Error("error querying test analysis overall")
return nil, r.Error
}

Expand All @@ -86,48 +119,20 @@ func GetTestAnalysisByJobFromDB(dbc *db.DB, filters *filter.Filter, release, tes
results["overall"] = overall
}

jq := dbc.DB.Table("test_analysis_by_job_by_dates").
Select(`test_id,
test_name,
to_date((date at time zone 'UTC')::text, 'YYYY-MM-DD'::text)::text as date,
prow_jobs.release,
job_name as group,
runs,
passes,
flakes,
failures,
variants,
passes * 100.0 / NULLIF(runs, 0) AS pass_percentage,
flakes * 100.0 / NULLIF(runs, 0) AS flake_percentage,
failures * 100.0 / NULLIF(runs, 0) AS fail_percentage`).
Joins("INNER JOIN prow_jobs on prow_jobs.name = job_name").
Where("prow_jobs.release = ?", release).
Where("test_analysis_by_job_by_dates.release = ?", release).
Where("test_name = ?", testName).
Where("date <= ?", reportEnd).
Where("date >= ?", reportEnd.Add(-24*14*time.Hour)).
Order("date ASC")

var allowedVariants, blockedVariants []string
if filters != nil {
for _, f := range filters.Items {
if f.Field == "variants" {
if f.Not {
blockedVariants = append(blockedVariants, f.Value)
} else {
allowedVariants = append(allowedVariants, f.Value)
}
}
}
}
endDate := civil.DateOf(reportEnd.UTC())
sinceDate := endDate.AddDays(-testAnalysisLookbackDays)

for _, bv := range blockedVariants {
jq = jq.Where("NOT EXISTS (SELECT 1 FROM variant_combinations WHERE ? = any(variants) AND id = prow_jobs.variant_combination_id)", bv)
}

for _, av := range allowedVariants {
jq = jq.Where("prow_jobs.variant_combination_id IN (SELECT id FROM variant_combinations WHERE ? = any(variants))", av)
}
jq := testAnalysisBaseQuery(dbc, filters, release, testName, sinceDate).
Select(withAggColumns(
"tds.test_id",
`t.name AS test_name`,
`tds.date AS date`,
"pj.release",
`pj.name AS "group"`,
"pj.variants",
)).
Where("tds.date <= ?", endDate).
Group("tds.date, tds.test_id, t.name, pj.release, pj.name, pj.variants")

r := jq.Scan(&rows)
if r.Error != nil {
Expand All @@ -154,40 +159,34 @@ func GetTestAnalysisByVariantFromDB(dbc *db.DB, filters *filter.Filter, release,
results["overall"] = overall
}

vq := dbc.DB.Table("prow_test_analysis_by_variant_14d_view").
Where("release = ?", release).
Where("test_name = ?", testName).
Where("date <= ?", reportEnd).
Select(`to_date((date at time zone 'UTC')::text, 'YYYY-MM-DD'::text)::text as date,
variant as group,
runs,
passes,
flakes,
failures,
passes * 100.0 / NULLIF(runs, 0) AS pass_percentage,
flakes * 100.0 / NULLIF(runs, 0) AS flake_percentage,
failures * 100.0 / NULLIF(runs, 0) AS fail_percentage`).
Order("date ASC")

var allowedVariants, blockedVariants []string
if filters != nil {
for _, f := range filters.Items {
if f.Field == "variants" {
if f.Not {
blockedVariants = append(blockedVariants, f.Value)
} else {
allowedVariants = append(allowedVariants, f.Value)
}
}
}

if len(blockedVariants) > 0 {
vq = vq.Where("variant NOT IN ?", blockedVariants)
}

if len(allowedVariants) > 0 {
vq = vq.Where("variant IN ?", allowedVariants)
}
endDate := civil.DateOf(reportEnd.UTC())
sinceDate := endDate.AddDays(-testAnalysisLookbackDays)

inner := dbc.DB.Table("test_daily_totals tds").
Select(withAggColumns(
"tds.test_id",
`t.name AS test_name`,
`tds.date AS date`,
`unnest(vc.variants) AS "group"`,
"tds.release",
)).
Joins("JOIN tests t ON t.id = tds.test_id").
Joins("JOIN prow_jobs pj ON pj.id = tds.prow_job_id").
Joins("JOIN variant_combinations vc ON vc.id = pj.variant_combination_id").
Where("tds.release = ?", release).
Where("t.name = ?", testName).
Where("tds.date >= ?", sinceDate).
Where("tds.date <= ?", endDate).
Group("t.name, t.id, tds.test_id, tds.date, unnest(vc.variants), tds.release").
Order("tds.date ASC")

vq := dbc.DB.Table("(?) AS analysis", inner).Select("*")
allowed, blocked := extractVariantFilters(filters)
if len(blocked) > 0 {
vq = vq.Where(`"group" NOT IN ?`, blocked)
}
if len(allowed) > 0 {
vq = vq.Where(`"group" IN ?`, allowed)
}

r := vq.Scan(&rows)
Expand Down
65 changes: 65 additions & 0 deletions pkg/api/test_analysis_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,65 @@
package api

import (
"testing"

"github.com/stretchr/testify/assert"

"github.com/openshift/sippy/pkg/filter"
)

func TestExtractVariantFilters(t *testing.T) {
tests := []struct {
name string
filters *filter.Filter
expectedAllowed []string
expectedBlocked []string
}{
{
name: "nil filter",
filters: nil,
expectedAllowed: nil,
expectedBlocked: nil,
},
{
name: "no variant filters",
filters: &filter.Filter{Items: []filter.FilterItem{{Field: "name", Value: "test1"}}},
expectedAllowed: nil,
expectedBlocked: nil,
},
{
name: "allowed variants",
filters: &filter.Filter{Items: []filter.FilterItem{
{Field: "variants", Value: "Platform:aws"},
{Field: "variants", Value: "Network:ovn"},
}},
expectedAllowed: []string{"Platform:aws", "Network:ovn"},
expectedBlocked: nil,
},
{
name: "blocked variants",
filters: &filter.Filter{Items: []filter.FilterItem{
{Field: "variants", Value: "Platform:aws", Not: true},
}},
expectedAllowed: nil,
expectedBlocked: []string{"Platform:aws"},
},
{
name: "mixed allowed and blocked",
filters: &filter.Filter{Items: []filter.FilterItem{
{Field: "variants", Value: "Platform:aws"},
{Field: "variants", Value: "Topology:single", Not: true},
{Field: "name", Value: "ignored"},
}},
expectedAllowed: []string{"Platform:aws"},
expectedBlocked: []string{"Topology:single"},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
allowed, blocked := extractVariantFilters(tt.filters)
assert.Equal(t, tt.expectedAllowed, allowed)
assert.Equal(t, tt.expectedBlocked, blocked)
})
}
}
25 changes: 20 additions & 5 deletions pkg/db/query/test_queries.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -66,12 +66,27 @@ const (
GROUP BY bug_tests.test_id`

QueryTestAnalysis = `
select current_successes, current_runs,
SELECT current_successes, current_runs,
current_successes * 100.0 / NULLIF(current_runs, 0) AS current_pass_percentage
from (
select sum(runs) as current_runs, sum(passes) as current_successes
from test_analysis_by_job_by_dates
where date >= ? AND test_name = ? AND job_name IN ? AND release = ?
FROM (
SELECT
SUM(e.prefix_sum_successes - COALESCE(s.prefix_sum_successes, 0)) AS current_successes,
SUM(e.prefix_sum_runs - COALESCE(s.prefix_sum_runs, 0)) AS current_runs
-- e = latest cumulative snapshot for the release
FROM test_cumulative_summaries e
JOIN tests t ON t.id = e.test_id
JOIN prow_jobs pj ON pj.id = e.prow_job_id
-- s = prior-day baseline; the difference e - s gives the windowed totals
LEFT JOIN test_cumulative_summaries s
ON s.test_id = e.test_id
AND s.prow_job_id = e.prow_job_id
AND s.suite_id = e.suite_id
AND s.release = e.release
AND s.date = (?::date - INTERVAL '1 day')::date
WHERE e.date = (SELECT MAX(date) FROM test_cumulative_summaries WHERE release = ?)
AND e.release = ?
AND t.name = ?
AND pj.name IN ?
) t`
Comment thread
coderabbitai[bot] marked this conversation as resolved.
)

Expand Down
Loading