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),

// InQueueMetric holds queue stats for replication
type InQueueMetric struct {
	Curr QStat `json:"curr" msg:"cq"`
	Avg  QStat `json:"avg" msg:"aq"`
	Max  QStat `json:"max" msg:"pq"`
}

func (qm InQueueMetric) merge(o InQueueMetric) InQueueMetric {
	return InQueueMetric{
		Curr: qm.Curr.add(o.Curr),
		Avg:  qm.Avg.add(o.Avg),
		Max:  qm.Max.add(o.Max),
	}
}

type queueCache struct {
	srQueueStats InQueueStats

				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)
}

        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)

| `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).                               |

	})

	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.
 *

    //                                                                            ========

    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) {

at\":\"HH:mm\",\"bounds\":{\"min\":\"2019-07-28T11:33:01.690Z\",\"max\":\"2019-07-30T11:33:01.690Z\"}},\"aggType\":\"date_histogram\"},\"y\":[{\"accessor\":1,\"format\":{\"id\":\"number\"},\"params\":{},\"aggType\":\"avg\"}]}},\"aggs\":[{\"id\":\"1\",\"enabled\":true,\"type\":\"avg\",\"schema\":\"metric\",\"params\":{\"field\":\"responseTime\"}},{\"id\":\"2\",\"enabled\":true,\"type\":\"date_histogram\",\"schema\":\"segment\",\"params\":{\"field\":\"requestedAt\",\"timeRange\":{\"from\":\"now-2d...