qs.TgtXferStats[arn][Large] = XferStats{
			Avg:  v.XferRateLrg.Avg,
			Curr: lcurrTgt,
			Peak: math.Max(v.XferRateLrg.Peak, lcurrTgt),
		}
		qs.TgtXferStats[arn][Small] = XferStats{
			Avg:  v.XferRateSml.Avg,
			Curr: scurrTgt,
			Peak: math.Max(v.XferRateSml.Peak, scurrTgt),
		}
		if tcount > 0 {
			qs.TgtXferStats[arn][Total] = XferStats{
				Avg:  (v.XferRateLrg.Avg + v.XferRateSml.Avg) / float64(tcount),

				err = msgp.WrapError(err, "Avg")
				return
			}
			for zb0003 > 0 {
				zb0003--
				field, err = dc.ReadMapKeyPtr()
				if err != nil {
					err = msgp.WrapError(err, "Avg")
					return
				}
				switch msgp.UnsafeString(field) {
				case "Count":
					z.Avg.Count, err = dc.ReadFloat64()
					if err != nil {
						err = msgp.WrapError(err, "Avg", "Count")
						return
					}

}

type latencyStat struct {
	lastmin lastMinuteLatency
	curr    time.Duration
	avg     time.Duration
	peak    time.Duration
	N       int64
}

func (l *latencyStat) update(d time.Duration) {
	l.lastmin.add(d)
	l.N++
	if d > l.peak {
		l.peak = d
	}
	l.curr = l.lastmin.getTotal().avg()
	l.avg = time.Duration((int64(l.avg)*(l.N-1) + int64(l.curr)) / l.N)
}

| `minio_node_if_rx_bytes_avg`  | Bytes received on the interface in 60s (avg) since uptime. |
| `minio_node_if_rx_bytes_max`  | Bytes received on the interface in 60s (max) since uptime. |
| `minio_node_if_rx_errors`     | Receive errors in 60s.                                     |
| `minio_node_if_rx_errors_avg` | Receive errors in 60s (avg).                               |

        System.out.printf("Buffer Cache Performance: %d allocs, %d releases in %.2f ms%n", allocations.get(), releases.get(),
                overallTimeMs);
        System.out.printf("  Avg allocation time: %.2f ns%n", avgAllocTimeNs);
        System.out.printf("  Avg release time: %.2f ns%n", avgReleaseTimeNs);

        // Verify O(1) performance - should be reasonably fast (allowing for JVM overhead)

	})

	if requireAvgMax {
		avgName := MetricName(fmt.Sprintf("%s_avg", name))
		avgHelp := fmt.Sprintf("%s (avg)", help)
		metrics = append(metrics, MetricV2{
			Description:    getResourceMetricDescription(subSys, avgName, avgHelp),
			Value:          math.Round(rm.Avg*100) / 100,
			VariableLabels: cloneMSS(rm.Labels),
		})

		maxName := MetricName(fmt.Sprintf("%s_max", name))

import org.opensearch.search.aggregations.bucket.histogram.Histogram;
import org.opensearch.search.aggregations.bucket.terms.Terms;
import org.opensearch.search.aggregations.metrics.Avg;
import org.opensearch.search.aggregations.metrics.Cardinality;

import jakarta.annotation.Resource;

/**
 * Service class for managing search logs and related analytics.
 *

			metric.TotalDowntime = epHealth.offlineDuration
			metric.LastOnline = epHealth.lastOnline
			metric.Online = epHealth.Online
			metric.Latency = madmin.LatencyStat{
				Curr: epHealth.latency.curr,
				Avg:  epHealth.latency.avg,
				Max:  epHealth.latency.peak,
			}
		}
		m[dID] = metric
	}
	return m
}

func (srs *SRStatus) updateXferRate(sz int64, duration time.Duration) {
	if sz > minLargeObjSize {

		// Return empty metrics when not configured.
		return Metrics{}
	}
	o.serviceMetrics.Lock()
	defer o.serviceMetrics.Unlock()
	l := &o.serviceMetrics.lastFullMinute
	var avg float64
	if l.successRequestCount > 0 {
		avg = l.rttMsSum / float64(l.successRequestCount)
	}
	now := time.Now().UTC()
	return Metrics{
		LastReachableSecs:   now.Sub(o.serviceMetrics.LastCheckSuccess).Seconds(),

    //                                                                            ========

    protected AvgAggregationBuilder regAvgA(String name, String field) {
        AvgAggregationBuilder builder = AggregationBuilders.avg(name).field(field);
        regA(builder);
        return builder;
    }

    protected MaxAggregationBuilder regMaxA(String name, String field) {