mev-beta/pkg/metrics/metrics.go

// Package metrics provides Prometheus metrics for the MEV bot
package metrics

import (
	"github.com/prometheus/client_golang/prometheus"
	"github.com/prometheus/client_golang/prometheus/promauto"
)

var (
	// Sequencer metrics
	MessagesReceived = promauto.NewCounter(prometheus.CounterOpts{
		Name: "mev_sequencer_messages_received_total",
		Help: "Total number of messages received from Arbitrum sequencer feed",
	})

	TransactionsProcessed = promauto.NewCounter(prometheus.CounterOpts{
		Name: "mev_sequencer_transactions_processed_total",
		Help: "Total number of transactions processed from sequencer",
	})

	ParseErrors = promauto.NewCounter(prometheus.CounterOpts{
		Name: "mev_sequencer_parse_errors_total",
		Help: "Total number of parsing errors",
	})

	ValidationErrors = promauto.NewCounter(prometheus.CounterOpts{
		Name: "mev_sequencer_validation_errors_total",
		Help: "Total number of validation errors",
	})

	DecodeErrors = promauto.NewCounter(prometheus.CounterOpts{
		Name: "mev_sequencer_decode_errors_total",
		Help: "Total number of message decode errors",
	})

	// Swap detection metrics
	SwapsDetected = promauto.NewCounterVec(prometheus.CounterOpts{
		Name: "mev_swaps_detected_total",
		Help: "Total number of swap transactions detected",
	}, []string{"protocol", "version"})

	// Pool discovery metrics
	PoolsDiscovered = promauto.NewCounterVec(prometheus.CounterOpts{
		Name: "mev_pools_discovered_total",
		Help: "Total number of pools discovered",
	}, []string{"protocol"})

	PoolCacheSize = promauto.NewGauge(prometheus.GaugeOpts{
		Name: "mev_pool_cache_size",
		Help: "Current number of pools in cache",
	})

	// Arbitrage metrics
	OpportunitiesFound = promauto.NewCounterVec(prometheus.CounterOpts{
		Name: "mev_opportunities_found_total",
		Help: "Total number of arbitrage opportunities found",
	}, []string{"type"})

	ExecutionsAttempted = promauto.NewCounter(prometheus.CounterOpts{
		Name: "mev_executions_attempted_total",
		Help: "Total number of arbitrage execution attempts",
	})

	ExecutionsSucceeded = promauto.NewCounter(prometheus.CounterOpts{
		Name: "mev_executions_succeeded_total",
		Help: "Total number of successful arbitrage executions",
	})

	ExecutionsFailed = promauto.NewCounterVec(prometheus.CounterOpts{
		Name: "mev_executions_failed_total",
		Help: "Total number of failed arbitrage executions",
	}, []string{"reason"})

	// Profit metrics
	ProfitEarned = promauto.NewGauge(prometheus.GaugeOpts{
		Name: "mev_profit_earned_wei",
		Help: "Total profit earned in wei",
	})

	GasCostTotal = promauto.NewGauge(prometheus.GaugeOpts{
		Name: "mev_gas_cost_total_wei",
		Help: "Total gas cost in wei",
	})

	// Latency metrics
	ProcessingLatency = promauto.NewHistogram(prometheus.HistogramOpts{
		Name:    "mev_processing_latency_seconds",
		Help:    "Time taken to process a transaction",
		Buckets: prometheus.DefBuckets,
	})

	ParseLatency = promauto.NewHistogram(prometheus.HistogramOpts{
		Name:    "mev_parse_latency_seconds",
		Help:    "Time taken to parse a transaction",
		Buckets: []float64{0.001, 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0},
	})

	DetectionLatency = promauto.NewHistogram(prometheus.HistogramOpts{
		Name:    "mev_detection_latency_seconds",
		Help:    "Time taken to detect arbitrage opportunities",
		Buckets: []float64{0.001, 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0},
	})

	ExecutionLatency = promauto.NewHistogram(prometheus.HistogramOpts{
		Name:    "mev_execution_latency_seconds",
		Help:    "Time taken to execute an arbitrage",
		Buckets: []float64{0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0},
	})

	// Connection metrics
	SequencerConnected = promauto.NewGauge(prometheus.GaugeOpts{
		Name: "mev_sequencer_connected",
		Help: "Whether connected to sequencer feed (1 = connected, 0 = disconnected)",
	})

	ReconnectAttempts = promauto.NewCounter(prometheus.CounterOpts{
		Name: "mev_sequencer_reconnect_attempts_total",
		Help: "Total number of sequencer reconnection attempts",
	})

	// RPC metrics (should be minimal after removing blocking calls)
	RPCCalls = promauto.NewCounterVec(prometheus.CounterOpts{
		Name: "mev_rpc_calls_total",
		Help: "Total number of RPC calls made",
	}, []string{"method"})

	RPCErrors = promauto.NewCounterVec(prometheus.CounterOpts{
		Name: "mev_rpc_errors_total",
		Help: "Total number of RPC errors",
	}, []string{"method", "error_type"})

	// Queue metrics
	QueueDepth = promauto.NewGaugeVec(prometheus.GaugeOpts{
		Name: "mev_queue_depth",
		Help: "Current depth of processing queues",
	}, []string{"queue_name"})

	QueueDropped = promauto.NewCounterVec(prometheus.CounterOpts{
		Name: "mev_queue_dropped_total",
		Help: "Total number of items dropped from queues",
	}, []string{"queue_name"})
)

// RecordSwapDetection records a swap detection with protocol information
func RecordSwapDetection(protocol, version string) {
	SwapsDetected.WithLabelValues(protocol, version).Inc()
}

// RecordPoolDiscovery records a pool discovery
func RecordPoolDiscovery(protocol string) {
	PoolsDiscovered.WithLabelValues(protocol).Inc()
}

// RecordOpportunity records an arbitrage opportunity
func RecordOpportunity(oppType string) {
	OpportunitiesFound.WithLabelValues(oppType).Inc()
}

// RecordExecutionFailure records a failed execution
func RecordExecutionFailure(reason string) {
	ExecutionsFailed.WithLabelValues(reason).Inc()
}

// RecordRPCCall records an RPC call
func RecordRPCCall(method string) {
	RPCCalls.WithLabelValues(method).Inc()
}

// RecordRPCError records an RPC error
func RecordRPCError(method, errorType string) {
	RPCErrors.WithLabelValues(method, errorType).Inc()
}

// SetQueueDepth sets the current queue depth
func SetQueueDepth(queueName string, depth int) {
	QueueDepth.WithLabelValues(queueName).Set(float64(depth))
}

// RecordQueueDrop records a dropped item from a queue
func RecordQueueDrop(queueName string) {
	QueueDropped.WithLabelValues(queueName).Inc()
}