Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
// Package vulnerability owns vulnerability scanning, persistence, and HTTP routes.
package vulnerability
import (
"context"
"errors"
"log/slog"
"net/http"
"github.com/danielgtaylor/huma/v2"
"github.com/getarcaneapp/arcane/types/v2/features"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/metric"
"github.com/getarcaneapp/arcane/backend/v2/internal/vulnerability/children/ignores"
"github.com/getarcaneapp/arcane/backend/v2/internal/vulnerability/children/query"
"github.com/getarcaneapp/arcane/backend/v2/internal/vulnerability/children/scan"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/handlerutil"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/httpx"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/tracing"
)
type Module struct {
service *VulnerabilityService
}
// New wires vulnerability routes and registers the arcane.vulnerability.* gauges once.
func New(service *VulnerabilityService) *Module {
if service != nil && service.query != nil && service.settingsService != nil {
meter := otel.Meter(tracing.InstrumentationName)
findings, findingsErr := meter.Int64ObservableGauge("arcane.vulnerability.findings",
metric.WithDescription("Vulnerabilities in the latest completed scans of local images by severity"), metric.WithUnit("{vulnerability}"))
scanned, scannedErr := meter.Int64ObservableGauge("arcane.vulnerability.images.scanned",
metric.WithDescription("Local images with a completed vulnerability scan"), metric.WithUnit("{image}"))
actionable, actionableErr := meter.Int64ObservableGauge("arcane.vulnerability.actionable",
metric.WithDescription("Critical and high vulnerabilities that are not ignored"), metric.WithUnit("{vulnerability}"))
err := errors.Join(findingsErr, scannedErr, actionableErr)
if err == nil {
_, err = meter.RegisterCallback(func(ctx context.Context, o metric.Observer) error {
if !service.settingsService.IsFeatureEnabled(ctx, features.VulnerabilityManagement) {
return nil
}
if summary, summaryErr := service.query.GetEnvironmentSummary(ctx); summaryErr != nil {
slog.DebugContext(ctx, "Skipping vulnerability summary metrics", "error", summaryErr)
} else if summary.Summary != nil {
o.ObserveInt64(scanned, int64(summary.ScannedImages))
for severity, n := range map[string]int{
"critical": summary.Summary.Critical, "high": summary.Summary.High, "medium": summary.Summary.Medium,
"low": summary.Summary.Low, "unknown": summary.Summary.Unknown,
} {
o.ObserveInt64(findings, int64(n), metric.WithAttributes(attribute.String("vulnerability.severity", severity)))
}
}
if count, countErr := service.ActionableCountExcludingIgnored(ctx); countErr != nil {
slog.DebugContext(ctx, "Skipping actionable vulnerability metric", "error", countErr)
} else {
o.ObserveInt64(actionable, int64(count))
}
return nil
}, findings, scanned, actionable)
}
if err != nil {
otel.Handle(err)
}
}
return &Module{service: service}
}
func (m *Module) Service() *VulnerabilityService {
if m == nil {
return nil
}
return m.service
}
// RegisterRoutes mounts the vulnerability endpoints behind the vulnerability
// management feature gate. A nil module still registers for OpenAPI generation.
func (m *Module) RegisterRoutes(api huma.API, appCtx handlerutil.ActivityAppContext) {
service := m.Service()
if service == nil {
service = &VulnerabilityService{}
}
featureMiddleware := huma.Middlewares{func(ctx huma.Context, next func(huma.Context)) {
if _, scoped := httpx.EnvironmentScopeFromContext(ctx.Context()); !scoped && service.settingsService != nil {
if err := service.settingsService.RequireFeature(ctx.Context(), features.VulnerabilityManagement); err != nil {
ctx.SetHeader("Content-Type", "application/problem+json")
ctx.SetStatus(http.StatusForbidden)
if writeErr := api.Marshal(ctx.BodyWriter(), "application/json", handlerutil.FeatureDisabledError(features.VulnerabilityManagement)); writeErr != nil {
slog.WarnContext(ctx.Context(), "failed to write feature-disabled response", "error", writeErr)
}
return
}
}
next(ctx)
}}
scan.RegisterRoutes(api, scan.NewHandler(service.scan, appCtx.Context()), featureMiddleware)
query.RegisterRoutes(api, query.NewHandler(service.query), featureMiddleware)
ignores.RegisterRoutes(api, ignores.NewHandler(service.ignores), featureMiddleware)
}