Skip to content

Modern Docker Management, Designed for Everyone

perf(vulnerability-service): prefilter list-all scans and inline ignored vuln filtering (#1816)

Kyle Mendelle3fb5d4ceb07
diff --git a/backend/internal/services/vulnerability_service.go b/backend/internal/services/vulnerability_service.go
index c4876e13a..b474209e4 100644
--- a/backend/internal/services/vulnerability_service.go
+++ b/backend/internal/services/vulnerability_service.go
@@ -622,16 +622,33 @@ func (s *VulnerabilityService) ListAllVulnerabilities(ctx context.Context, envID
}, nil
}
- var records []models.VulnerabilityScanRecord
- if err := s.db.WithContext(ctx).
- Select("id", "image_name", "vulnerabilities", "status", "total_count").
+ recordsQuery := s.db.WithContext(ctx).
+ Select("id", "image_name", "vulnerabilities", "total_count").
Where("status = ?", models.ScanStatusCompleted).
- Where("total_count > 0").
- Find(&records).Error; err != nil {
+ Where("total_count > 0")
+ var hasPossibleMatches bool
+ recordsQuery, hasPossibleMatches = applyListAllVulnerabilityRecordPrefiltersInternal(recordsQuery, params.Filters)
+ if !hasPossibleMatches {
+ filtered := pagination.FilterResult[vulnerability.VulnerabilityWithImage]{
+ Items: []vulnerability.VulnerabilityWithImage{},
+ TotalCount: 0,
+ TotalAvailable: 0,
+ }
+ response := pagination.BuildResponseFromFilterResult(filtered, params)
+ return filtered.Items, response, nil
+ }
+
+ var records []models.VulnerabilityScanRecord
+ if err := recordsQuery.Find(&records).Error; err != nil {
return nil, pagination.Response{}, fmt.Errorf("failed to list vulnerability scans: %w", err)
}
- items := make([]vulnerability.VulnerabilityWithImage, 0)
+ ignoredKeys, err := s.getIgnoredVulnerabilityKeySetByEnvironmentInternal(ctx, envID)
+ if err != nil {
+ slog.WarnContext(ctx, "failed to filter ignored vulnerabilities", "error", err)
+ }
+
+ items := make([]vulnerability.VulnerabilityWithImage, 0, estimatedVulnerabilityRecordCountInternal(records))
for _, record := range records {
if len(record.Vulnerabilities) == 0 || record.Vulnerabilities[0] == "" {
continue
@@ -644,6 +661,13 @@ func (s *VulnerabilityService) ListAllVulnerabilities(ctx context.Context, envID
}
for _, vuln := range vulns {
+ if len(ignoredKeys) > 0 {
+ key := vulnerabilityIgnoreKeyInternal(record.ID, vuln.VulnerabilityID, vuln.PkgName, vuln.InstalledVersion)
+ if _, isIgnored := ignoredKeys[key]; isIgnored {
+ continue
+ }
+ }
+
items = append(items, vulnerability.VulnerabilityWithImage{
Vulnerability: vuln,
ImageID: record.ID,
@@ -652,12 +676,6 @@ func (s *VulnerabilityService) ListAllVulnerabilities(ctx context.Context, envID
}
}
- // Filter out ignored vulnerabilities
- items, err := s.filterIgnoredVulnerabilities(ctx, envID, items)
- if err != nil {
- slog.WarnContext(ctx, "failed to filter ignored vulnerabilities", "error", err)
- }
-
config := pagination.Config[vulnerability.VulnerabilityWithImage]{
SearchAccessors: []pagination.SearchAccessor[vulnerability.VulnerabilityWithImage]{
func(item vulnerability.VulnerabilityWithImage) (string, error) { return item.VulnerabilityID, nil },
@@ -730,6 +748,139 @@ func (s *VulnerabilityService) ListAllVulnerabilities(ctx context.Context, envID
return filtered.Items, response, nil
}
+func applyListAllVulnerabilityRecordPrefiltersInternal(query *gorm.DB, filters map[string]string) (*gorm.DB, bool) {
+ if query == nil || len(filters) == 0 {
+ return query, true
+ }
+
+ if severityFilter, ok := filters["severity"]; ok {
+ severityColumns := severityCountColumnsForFilterInternal(severityFilter)
+ if len(severityColumns) == 0 {
+ return query, false
+ }
+
+ parts := make([]string, 0, len(severityColumns))
+ args := make([]any, 0, len(severityColumns))
+ for _, col := range severityColumns {
+ parts = append(parts, col+" > ?")
+ args = append(args, 0)
+ }
+ query = query.Where("("+strings.Join(parts, " OR ")+")", args...)
+ }
+
+ if imageNameFilter, ok := filters["imageName"]; ok {
+ imageNameParts := splitNonEmptyCSVInternal(imageNameFilter)
+ if len(imageNameParts) == 0 {
+ return query, false
+ }
+
+ clauses := make([]string, 0, len(imageNameParts))
+ args := make([]any, 0, len(imageNameParts))
+ for _, part := range imageNameParts {
+ clauses = append(clauses, "LOWER(image_name) LIKE ?")
+ args = append(args, "%"+strings.ToLower(part)+"%")
+ }
+ query = query.Where("("+strings.Join(clauses, " OR ")+")", args...)
+ }
+
+ return query, true
+}
+
+func severityCountColumnsForFilterInternal(value string) []string {
+ parts := splitNonEmptyCSVInternal(value)
+ if len(parts) == 0 {
+ return nil
+ }
+
+ columns := make([]string, 0, len(parts))
+ seen := make(map[string]struct{}, len(parts))
+ for _, part := range parts {
+ var col string
+ switch {
+ case strings.EqualFold(part, string(vulnerability.SeverityCritical)):
+ col = "critical_count"
+ case strings.EqualFold(part, string(vulnerability.SeverityHigh)):
+ col = "high_count"
+ case strings.EqualFold(part, string(vulnerability.SeverityMedium)):
+ col = "medium_count"
+ case strings.EqualFold(part, string(vulnerability.SeverityLow)):
+ col = "low_count"
+ case strings.EqualFold(part, string(vulnerability.SeverityUnknown)):
+ col = "unknown_count"
+ default:
+ continue
+ }
+
+ if _, exists := seen[col]; exists {
+ continue
+ }
+
+ seen[col] = struct{}{}
+ columns = append(columns, col)
+ }
+
+ return columns
+}
+
+func splitNonEmptyCSVInternal(value string) []string {
+ parts := make([]string, 0)
+ for part := range strings.SplitSeq(value, ",") {
+ part = strings.TrimSpace(part)
+ if part == "" {
+ continue
+ }
+ parts = append(parts, part)
+ }
+ return parts
+}
+
+func estimatedVulnerabilityRecordCountInternal(records []models.VulnerabilityScanRecord) int {
+ if len(records) == 0 {
+ return 0
+ }
+
+ total := 0
+ for i := range records {
+ if records[i].TotalCount <= 0 {
+ continue
+ }
+
+ if total > math.MaxInt-records[i].TotalCount {
+ return math.MaxInt
+ }
+ total += records[i].TotalCount
+ }
+
+ return total
+}
+
+func vulnerabilityIgnoreKeyInternal(imageID, vulnerabilityID, pkgName, installedVersion string) string {
+ return imageID + ":" + vulnerabilityID + ":" + pkgName + ":" + installedVersion
+}
+
+func (s *VulnerabilityService) getIgnoredVulnerabilityKeySetByEnvironmentInternal(ctx context.Context, envID string) (map[string]struct{}, error) {
+ if s.db == nil {
+ return nil, nil
+ }
+
+ var ignores []models.VulnerabilityIgnore
+ if err := s.db.WithContext(ctx).Where("environment_id = ?", envID).Find(&ignores).Error; err != nil {
+ return nil, fmt.Errorf("failed to get ignore records: %w", err)
+ }
+
+ if len(ignores) == 0 {
+ return nil, nil
+ }
+
+ ignoredKeys := make(map[string]struct{}, len(ignores))
+ for _, ignore := range ignores {
+ key := vulnerabilityIgnoreKeyInternal(ignore.ImageID, ignore.VulnerabilityID, ignore.PkgName, ignore.InstalledVersion)
+ ignoredKeys[key] = struct{}{}
+ }
+
+ return ignoredKeys, nil
+}
+
func severityRankInternal(severity vulnerability.Severity) int {
switch severity {
case vulnerability.SeverityCritical:
@@ -2854,13 +3005,13 @@ func (s *VulnerabilityService) filterIgnoredVulnerabilitiesForImage(
ignoredKeys := make(map[string]struct{}, len(ignores))
for _, ignore := range ignores {
- key := fmt.Sprintf("%s:%s:%s:%s", ignore.ImageID, ignore.VulnerabilityID, ignore.PkgName, ignore.InstalledVersion)
+ key := vulnerabilityIgnoreKeyInternal(ignore.ImageID, ignore.VulnerabilityID, ignore.PkgName, ignore.InstalledVersion)
ignoredKeys[key] = struct{}{}
}
filtered := make([]vulnerability.Vulnerability, 0, len(vulns))
for _, vuln := range vulns {
- key := fmt.Sprintf("%s:%s:%s:%s", imageID, vuln.VulnerabilityID, vuln.PkgName, vuln.InstalledVersion)
+ key := vulnerabilityIgnoreKeyInternal(imageID, vuln.VulnerabilityID, vuln.PkgName, vuln.InstalledVersion)
if _, isIgnored := ignoredKeys[key]; isIgnored {
continue
}
@@ -3186,38 +3337,3 @@ func (s *VulnerabilityService) GetIgnoreRecordsForImage(ctx context.Context, env
return ignores, nil
}
-
-// filterIgnoredVulnerabilities removes ignored vulnerabilities from the list
-func (s *VulnerabilityService) filterIgnoredVulnerabilities(ctx context.Context, envID string, vulns []vulnerability.VulnerabilityWithImage) ([]vulnerability.VulnerabilityWithImage, error) {
- if s.db == nil || len(vulns) == 0 {
- return vulns, nil
- }
-
- // Get all ignore records for this environment
- var ignores []models.VulnerabilityIgnore
- if err := s.db.WithContext(ctx).Where("environment_id = ?", envID).Find(&ignores).Error; err != nil {
- return nil, fmt.Errorf("failed to get ignore records: %w", err)
- }
-
- if len(ignores) == 0 {
- return vulns, nil
- }
-
- // Build a set of ignored vulnerability keys
- ignoredKeys := make(map[string]struct{}, len(ignores))
- for _, ignore := range ignores {
- key := fmt.Sprintf("%s:%s:%s:%s", ignore.ImageID, ignore.VulnerabilityID, ignore.PkgName, ignore.InstalledVersion)
- ignoredKeys[key] = struct{}{}
- }
-
- // Filter out ignored vulnerabilities
- filtered := make([]vulnerability.VulnerabilityWithImage, 0, len(vulns))
- for _, vuln := range vulns {
- key := fmt.Sprintf("%s:%s:%s:%s", vuln.ImageID, vuln.VulnerabilityID, vuln.PkgName, vuln.InstalledVersion)
- if _, isIgnored := ignoredKeys[key]; !isIgnored {
- filtered = append(filtered, vuln)
- }
- }
-
- return filtered, nil
-}
diff --git a/backend/internal/services/vulnerability_service_test.go b/backend/internal/services/vulnerability_service_test.go
index 48b817909..66d7c5721 100644
--- a/backend/internal/services/vulnerability_service_test.go
+++ b/backend/internal/services/vulnerability_service_test.go
@@ -16,6 +16,7 @@ import (
mounttypes "github.com/docker/docker/api/types/mount"
"github.com/getarcaneapp/arcane/backend/internal/database"
"github.com/getarcaneapp/arcane/backend/internal/models"
+ "github.com/getarcaneapp/arcane/backend/internal/utils/pagination"
"github.com/getarcaneapp/arcane/backend/internal/utils/timeouts"
"github.com/getarcaneapp/arcane/types/vulnerability"
glsqlite "github.com/glebarez/sqlite"
@@ -492,7 +493,7 @@ func setupVulnerabilityScanTestDB(t *testing.T) *database.DB {
dsn := fmt.Sprintf("file:vulnerability-scan-test-%d?mode=memory&cache=shared", time.Now().UnixNano())
db, err := gorm.Open(glsqlite.Open(dsn), &gorm.Config{})
require.NoError(t, err)
- require.NoError(t, db.AutoMigrate(&models.VulnerabilityScanRecord{}))
+ require.NoError(t, db.AutoMigrate(&models.VulnerabilityScanRecord{}, &models.VulnerabilityIgnore{}))
return &database.DB{DB: db}
}
@@ -526,3 +527,120 @@ func TestVulnerabilityService_DeleteScanResultsByImageIDs_EmptyInput(t *testing.
require.NoError(t, svc.DeleteScanResultsByImageIDs(ctx, nil))
require.NoError(t, svc.DeleteScanResultsByImageIDs(ctx, []string{}))
}
+
+func TestSeverityCountColumnsForFilterInternal(t *testing.T) {
+ tests := []struct {
+ name string
+ value string
+ want []string
+ wantNil bool
+ }{
+ {
+ name: "single severity",
+ value: "critical",
+ want: []string{"critical_count"},
+ },
+ {
+ name: "multiple severities and duplicates",
+ value: "high,critical,high,UNKNOWN",
+ want: []string{"high_count", "critical_count", "unknown_count"},
+ },
+ {
+ name: "invalid severities only",
+ value: "foo,bar",
+ want: []string{},
+ },
+ {
+ name: "empty value",
+ value: " , , ",
+ wantNil: true,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got := severityCountColumnsForFilterInternal(tt.value)
+ if tt.wantNil {
+ require.Nil(t, got)
+ return
+ }
+ require.Equal(t, tt.want, got)
+ })
+ }
+}
+
+func TestApplyListAllVulnerabilityRecordPrefiltersInternal_NoPossibleMatches(t *testing.T) {
+ db := setupVulnerabilityScanTestDB(t)
+ base := db.WithContext(context.Background()).Model(&models.VulnerabilityScanRecord{})
+
+ _, ok := applyListAllVulnerabilityRecordPrefiltersInternal(base, map[string]string{"severity": "not-a-severity"})
+ require.False(t, ok)
+
+ _, ok = applyListAllVulnerabilityRecordPrefiltersInternal(base, map[string]string{"imageName": " , "})
+ require.False(t, ok)
+
+ _, ok = applyListAllVulnerabilityRecordPrefiltersInternal(base, map[string]string{
+ "severity": "high,bad",
+ "imageName": "nginx",
+ })
+ require.True(t, ok)
+}
+
+func TestEstimatedVulnerabilityRecordCountInternal(t *testing.T) {
+ records := []models.VulnerabilityScanRecord{
+ {TotalCount: 5},
+ {TotalCount: 0},
+ {TotalCount: -3},
+ {TotalCount: 12},
+ }
+
+ require.Equal(t, 17, estimatedVulnerabilityRecordCountInternal(records))
+}
+
+func TestVulnerabilityService_ListAllVulnerabilities_FiltersIgnoredInline(t *testing.T) {
+ ctx := context.Background()
+ db := setupVulnerabilityScanTestDB(t)
+ svc := &VulnerabilityService{db: db}
+
+ vulns := []vulnerability.Vulnerability{
+ {
+ VulnerabilityID: "CVE-2026-0001",
+ PkgName: "openssl",
+ InstalledVersion: "1.0.0",
+ Severity: vulnerability.SeverityHigh,
+ },
+ }
+ rawVulns, err := json.Marshal(vulns)
+ require.NoError(t, err)
+
+ scan := models.VulnerabilityScanRecord{
+ ID: "sha256:list-all-1",
+ ImageName: "nginx:latest",
+ Status: models.ScanStatusCompleted,
+ ScanTime: time.Now(),
+ HighCount: 1,
+ TotalCount: 1,
+ Vulnerabilities: models.StringSlice{string(rawVulns)},
+ }
+ require.NoError(t, db.Create(&scan).Error)
+
+ reason := "accepted risk"
+ ignore := models.VulnerabilityIgnore{
+ EnvironmentID: "env-1",
+ ImageID: scan.ID,
+ VulnerabilityID: "CVE-2026-0001",
+ PkgName: "openssl",
+ InstalledVersion: "1.0.0",
+ Reason: &reason,
+ CreatedBy: "tester",
+ }
+ require.NoError(t, db.Create(&ignore).Error)
+
+ items, page, err := svc.ListAllVulnerabilities(ctx, "env-1", pagination.QueryParams{
+ PaginationParams: pagination.PaginationParams{Start: 0, Limit: 20},
+ })
+ require.NoError(t, err)
+ require.Empty(t, items)
+ require.Equal(t, int64(0), page.TotalItems)
+ require.Equal(t, int64(0), page.GrandTotalItems)
+}