}

type containerStats struct {
	container hcsshim.ContainerProperties
	hcsStats  []hcsshim.NetworkStats
}

func (s fakeNetworkStatsProvider) GetHNSEndpointStats(endpointName string) (*hcsshim.HNSEndpointStats, error) {
	eps := hcsshim.HNSEndpointStats{}
	for _, c := range s.containers {
		for _, stat := range c.hcsStats {
			if endpointName == stat.InstanceId {
				eps = hcsshim.HNSEndpointStats{

	result.InterfaceStats = iStat

	return result
}

func hcsStatToInterfaceStat(hcsStats *hcsshim.HNSEndpointStats, endpointName string) statsapi.InterfaceStats {
	iStat := statsapi.InterfaceStats{
		Name:    endpointName,
		RxBytes: &hcsStats.BytesReceived,
		TxBytes: &hcsStats.BytesSent,
	}
	return iStat
}

		gcStats.PauseEnd = gcStats.PauseEnd[len(gcStats.PauseEnd)-5:]
	}
	if len(gcStats.Pause) > 5 {
		gcStats.Pause = gcStats.Pause[len(gcStats.Pause)-5:]
	}

	props := madmin.ServerProperties{
		Endpoint: addr,
		Uptime:   UTCNow().Unix() - globalBootTime.Unix(),
		Version:  Version,
		CommitID: CommitID,
		Network:  network,
		MemStats: madmin.MemStats{
			Alloc:      memstats.Alloc,

		}
	}

	if w == nil { // when response recorder nil, this is an active request
		hstats.currentS3Requests.Inc(api)
		bh.httpStats[bucket] = hstats
		return
	} // else {
	hstats.currentS3Requests.Dec(api) // decrement this once we have the response recorder.

	hstats.totalS3Requests.Inc(api)
	code := w.StatusCode

	switch {
	case code == 0:
	case code == 499:

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package debug

import (
	"runtime"
	"slices"
	"time"
)

// GCStats collect information about recent garbage collections.
type GCStats struct {
	LastGC         time.Time       // time of last collection
	NumGC          int64           // number of garbage collections

			compute: func(in *statAggregate, out *metricValue) {
				out.kind = metricKindUint64
				out.scalar = in.gcStats.globalsScan
			},
		},
		"/gc/scan/heap:bytes": {
			deps: makeStatDepSet(gcStatsDep),
			compute: func(in *statAggregate, out *metricValue) {
				out.kind = metricKindUint64
				out.scalar = in.gcStats.heapScan
			},
		},
		"/gc/scan/stack:bytes": {
			deps: makeStatDepSet(gcStatsDep),

package debug_test

import (
	"internal/testenv"
	"os"
	"runtime"
	. "runtime/debug"
	"testing"
	"time"
)

func TestReadGCStats(t *testing.T) {
	defer SetGCPercent(SetGCPercent(-1))

	var stats GCStats
	var mstats runtime.MemStats
	var min, max time.Duration

	// First ReadGCStats will allocate, second should not,
	// especially if we follow up with an explicit garbage collection.

pkg reflect, type Type interface, Comparable() bool

# CL 153670043 runtime: add PauseEnd array to MemStats and GCStats, Jens Frederich <******@****.***>
pkg runtime, type MemStats struct, PauseEnd [256]uint64
pkg runtime/debug, type GCStats struct, PauseEnd []time.Time

# CL 136710045 sync/atomic: add Value, Dmitriy Vyukov <******@****.***>
pkg sync/atomic, method (*Value) Load() interface{}

						HeapAlloc:  server.MemStats.HeapAlloc,
					},
					GoMaxProcs:     server.GoMaxProcs,
					NumCPU:         server.NumCPU,
					RuntimeVersion: server.RuntimeVersion,
					GCStats:        server.GCStats,
					MinioEnvVars:   server.MinioEnvVars,
				})
			}

			tls := getTLSInfo()
			isK8s := IsKubernetes()
			isDocker := IsDocker()
			healthInfo.Minio.Info = madmin.MinioInfo{

		{"BuildSetting.Key", Field, 18},
		{"BuildSetting.Value", Field, 18},
		{"FreeOSMemory", Func, 1},
		{"GCStats", Type, 1},
		{"GCStats.LastGC", Field, 1},
		{"GCStats.NumGC", Field, 1},
		{"GCStats.Pause", Field, 1},
		{"GCStats.PauseEnd", Field, 4},
		{"GCStats.PauseQuantiles", Field, 1},
		{"GCStats.PauseTotal", Field, 1},
		{"Module", Type, 12},
		{"Module.Path", Field, 12},
		{"Module.Replace", Field, 12},