Skip to content

Modern Docker Management, Designed for Everyone

4.4 KB
Raw Blame
// 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)
}