metrics

var (
	// Request metrics
	RequestsTotal = prometheus.NewCounterVec(
		prometheus.CounterOpts{
			Name: "proxy_requests_total",
			Help: "Total number of requests by ecosystem and status",
		},
		[]string{"ecosystem", "status"},
	)

	RequestDuration = prometheus.NewHistogramVec(
		prometheus.HistogramOpts{
			Name:    "proxy_request_duration_seconds",
			Help:    "Request duration in seconds",
			Buckets: prometheus.DefBuckets,
		},
		[]string{"ecosystem", "status"},
	)

	// Cache metrics
	CacheHits = prometheus.NewCounterVec(
		prometheus.CounterOpts{
			Name: "proxy_cache_hits_total",
			Help: "Total number of cache hits by ecosystem and kind (artifact or metadata)",
		},
		[]string{"ecosystem", "kind"},
	)

	CacheMisses = prometheus.NewCounterVec(
		prometheus.CounterOpts{
			Name: "proxy_cache_misses_total",
			Help: "Total number of cache misses by ecosystem and kind (artifact or metadata)",
		},
		[]string{"ecosystem", "kind"},
	)

	MetadataServedBytes = prometheus.NewCounterVec(
		prometheus.CounterOpts{
			Name: "proxy_metadata_cache_served_bytes_total",
			Help: "Total metadata bytes served from the metadata cache, by ecosystem",
		},
		[]string{"ecosystem"},
	)

	CacheSize = prometheus.NewGauge(
		prometheus.GaugeOpts{
			Name: "proxy_cache_size_bytes",
			Help: "Total size of cached artifacts in bytes",
		},
	)

	CachedArtifacts = prometheus.NewGauge(
		prometheus.GaugeOpts{
			Name: "proxy_cached_artifacts_total",
			Help: "Total number of cached artifacts",
		},
	)

	ArtifactsEvicted = prometheus.NewCounterVec(
		prometheus.CounterOpts{
			Name: "proxy_artifacts_evicted_total",
			Help: "Total number of cached artifacts evicted, by reason (lru or retention) and ecosystem",
		},
		[]string{"reason", "ecosystem"},
	)

	MetadataEvicted = prometheus.NewCounterVec(
		prometheus.CounterOpts{
			Name: "proxy_metadata_evicted_total",
			Help: "Total number of cached metadata documents evicted by the size limit, by ecosystem",
		},
		[]string{"ecosystem"},
	)

	// Upstream metrics
	UpstreamFetchDuration = prometheus.NewHistogramVec(
		prometheus.HistogramOpts{
			Name:    "proxy_upstream_fetch_duration_seconds",
			Help:    "Upstream fetch duration in seconds",
			Buckets: []float64{.1, .25, .5, 1, 2.5, 5, 10, 30},
		},
		[]string{"ecosystem"},
	)

	UpstreamErrors = prometheus.NewCounterVec(
		prometheus.CounterOpts{
			Name: "proxy_upstream_errors_total",
			Help: "Total number of upstream fetch errors by type",
		},
		[]string{"ecosystem", "error_type"},
	)

	// Circuit breaker metrics
	CircuitBreakerState = prometheus.NewGaugeVec(
		prometheus.GaugeOpts{
			Name: "proxy_circuit_breaker_state",
			Help: "Circuit breaker state (0=closed, 1=half-open, 2=open)",
		},
		[]string{"registry"},
	)

	CircuitBreakerTrips = prometheus.NewCounterVec(
		prometheus.CounterOpts{
			Name: "proxy_circuit_breaker_trips_total",
			Help: "Total number of circuit breaker trips",
		},
		[]string{"registry"},
	)

	UpstreamRateLimitHolds = prometheus.NewCounterVec(
		prometheus.CounterOpts{
			Name: "proxy_upstream_rate_limit_holds_total",
			Help: "Holds placed on an upstream host after it rate limited the proxy",
		},
		[]string{"host"},
	)

	// Storage metrics
	StorageOperationDuration = prometheus.NewHistogramVec(
		prometheus.HistogramOpts{
			Name:    "proxy_storage_operation_duration_seconds",
			Help:    "Storage operation duration in seconds",
			Buckets: []float64{.001, .005, .01, .025, .05, .1, .25, .5, 1},
		},
		[]string{"operation"},
	)

	StorageErrors = prometheus.NewCounterVec(
		prometheus.CounterOpts{
			Name: "proxy_storage_errors_total",
			Help: "Total number of storage errors by operation",
		},
		[]string{"operation"},
	)

	// Active requests
	ActiveRequests = prometheus.NewGauge(
		prometheus.GaugeOpts{
			Name: "proxy_active_requests",
			Help: "Number of currently active requests",
		},
	)

	IntegrityFailures = prometheus.NewCounterVec(
		prometheus.CounterOpts{
			Name: "proxy_integrity_failures_total",
			Help: "Cached artifacts that failed hash verification on read",
		},
		[]string{"ecosystem"},
	)

	HealthProbeFailures = prometheus.NewCounterVec(
		prometheus.CounterOpts{
			Name: "proxy_health_probe_failures_total",
			Help: "Total number of storage health probe failures, by step (write|size|read|verify|delete).",
		},
		[]string{"step"},
	)

	// Per-ecosystem gauges, derived from the database rather than incremented
	// in the request path, and refreshed on the same tick as the cache gauges
	// above.
	EcosystemDownloadedBytes = prometheus.NewGaugeVec(
		prometheus.GaugeOpts{
			Name: "proxy_ecosystem_downloaded_bytes",
			Help: "Accumulated bytes served from cache per ecosystem (cache hits x artifact size)",
		},
		[]string{"ecosystem"},
	)

	EcosystemDownloads = prometheus.NewGaugeVec(
		prometheus.GaugeOpts{
			Name: "proxy_ecosystem_artifact_downloads",
			Help: "Accumulated artifact downloads served from cache per ecosystem",
		},
		[]string{"ecosystem"},
	)

	EcosystemCacheSize = prometheus.NewGaugeVec(
		prometheus.GaugeOpts{
			Name: "proxy_ecosystem_cache_size_bytes",
			Help: "Size of cached artifacts per ecosystem in bytes",
		},
		[]string{"ecosystem"},
	)

	EcosystemCachedArtifacts = prometheus.NewGaugeVec(
		prometheus.GaugeOpts{
			Name: "proxy_ecosystem_cached_artifacts",
			Help: "Number of cached artifacts per ecosystem",
		},
		[]string{"ecosystem"},
	)

	EcosystemPackages = prometheus.NewGaugeVec(
		prometheus.GaugeOpts{
			Name: "proxy_ecosystem_packages",
			Help: "Number of known packages per ecosystem",
		},
		[]string{"ecosystem"},
	)

	EcosystemVersions = prometheus.NewGaugeVec(
		prometheus.GaugeOpts{
			Name: "proxy_ecosystem_versions",
			Help: "Number of known package versions per ecosystem",
		},
		[]string{"ecosystem"},
	)

	// Metadata cache gauges, derived from the metadata_cache table on the
	// same tick as the per-ecosystem gauges above.
	MetadataCacheSize = prometheus.NewGaugeVec(
		prometheus.GaugeOpts{
			Name: "proxy_metadata_cache_size_bytes",
			Help: "Size of cached metadata documents per ecosystem in bytes",
		},
		[]string{"ecosystem"},
	)

	MetadataCacheEntries = prometheus.NewGaugeVec(
		prometheus.GaugeOpts{
			Name: "proxy_metadata_cache_entries",
			Help: "Number of cached metadata documents per ecosystem",
		},
		[]string{"ecosystem"},
	)

	ResponseBytes = prometheus.NewCounterVec(
		prometheus.CounterOpts{
			Name: "proxy_response_bytes_total",
			Help: "Total response body bytes written to clients, by ecosystem",
		},
		[]string{"ecosystem"},
	)

	ClientRequests = prometheus.NewCounterVec(
		prometheus.CounterOpts{
			Name: "proxy_client_requests_total",
			Help: "Total requests by client tool, as identified from the User-Agent",
		},
		[]string{"client"},
	)

	ClientResponseBytes = prometheus.NewCounterVec(
		prometheus.CounterOpts{
			Name: "proxy_client_response_bytes_total",
			Help: "Total response body bytes written to clients, by client tool",
		},
		[]string{"client"},
	)

	// Scanning metrics
	ScanDuration = prometheus.NewHistogramVec(
		prometheus.HistogramOpts{
			Name:    "proxy_scan_duration_seconds",
			Help:    "Pre-cache artifact scan duration in seconds, by ecosystem and scanner",
			Buckets: prometheus.DefBuckets,
		},
		[]string{"ecosystem", "scanner"},
	)

	ScanBlocked = prometheus.NewCounterVec(
		prometheus.CounterOpts{
			Name: "proxy_scan_blocked_total",
			Help: "Total number of artifacts blocked by a pre-cache scan, by ecosystem and scanner",
		},
		[]string{"ecosystem", "scanner"},
	)

	ScanErrors = prometheus.NewCounterVec(
		prometheus.CounterOpts{
			Name: "proxy_scan_errors_total",
			Help: "Total number of pre-cache scan errors, by ecosystem, scanner, and error type",
		},
		[]string{"ecosystem", "scanner", "error_type"},
	)
)