Mining/pkg/mining/xmrig_stats.go

package mining

import (
	"context"
	"time"
)

// requestContext, cancel := context.WithTimeout(ctx, statsTimeout)
const statsTimeout = 5 * time.Second

// metrics, err := miner.GetStats(ctx)
// if err == nil { logging.Info("hashrate", logging.Fields{"rate": metrics.Hashrate}) }
func (m *XMRigMiner) GetStats(ctx context.Context) (*PerformanceMetrics, error) {
	// Read state under RLock, then release before HTTP call
	m.mutex.RLock()
	if !m.Running {
		m.mutex.RUnlock()
		return nil, ErrMinerNotRunning(m.Name)
	}
	if m.API == nil || m.API.ListenPort == 0 {
		m.mutex.RUnlock()
		return nil, ErrInternal("miner API not configured or port is zero")
	}
	config := HTTPStatsConfig{
		Host:     m.API.ListenHost,
		Port:     m.API.ListenPort,
		Endpoint: "/2/summary",
	}
	m.mutex.RUnlock()

	// Create request with context and timeout
	requestContext, cancel := context.WithTimeout(ctx, statsTimeout)
	defer cancel()

	// Use the common HTTP stats fetcher
	var summary XMRigSummary
	if err := FetchJSONStats(requestContext, config, &summary); err != nil {
		return nil, err
	}

	// Store the full summary in the miner struct (requires lock)
	m.mutex.Lock()
	m.FullStats = &summary
	m.mutex.Unlock()

	var hashrate int
	if len(summary.Hashrate.Total) > 0 {
		hashrate = int(summary.Hashrate.Total[0])
	}

	// Calculate average difficulty per accepted share
	var avgDifficulty int
	if summary.Results.SharesGood > 0 {
		avgDifficulty = summary.Results.HashesTotal / summary.Results.SharesGood
	}

	return &PerformanceMetrics{
		Hashrate:      hashrate,
		Shares:        summary.Results.SharesGood,
		Rejected:      summary.Results.SharesTotal - summary.Results.SharesGood,
		Uptime:        summary.Uptime,
		Algorithm:     summary.Algo,
		AvgDifficulty: avgDifficulty,
		DiffCurrent:   summary.Results.DiffCurrent,
	}, nil
}