hoststats

type CGroup struct {
	Scope                 string   `json:"scope"`
	Path                  string   `json:"path"`
	CPUMaxCores           *float64 `json:"cpu_max_cores,omitempty"`
	MemoryMaxBytes        *uint64  `json:"memory_max_bytes,omitempty"`
	MemoryCurrentBaseline uint64   `json:"memory_current_baseline_bytes"`
	MemoryCurrentFinal    uint64   `json:"memory_current_final_bytes"`
	// Code is CodeLimitChanged when a limit moved during the interval.
	Code string `json:"code,omitempty"`
}

type CGroupRaw struct {
	Scope              string
	Path               string
	CPUMaxCores        *float64 // nil means "max", i.e. no quota
	MemoryMaxBytes     *uint64  // nil means "max", i.e. no limit
	MemoryCurrentBytes uint64
}

type Collector struct {
	// contains filtered or unexported fields
}

type Disk struct {
	Device        string   `json:"device"`
	ReadBytes     uint64   `json:"read_bytes"`
	WriteBytes    uint64   `json:"write_bytes"`
	ReadMBPerSec  *float64 `json:"read_mb_per_s,omitempty"`
	WriteMBPerSec *float64 `json:"write_mb_per_s,omitempty"`
	IOTimeMillis  uint64   `json:"io_time_ms"`
	// UtilPercent is the share of the interval the device spent doing IO. See
	// DiskUtilNote: on multi-queue devices it is not saturation.
	UtilPercent *float64 `json:"util_percent,omitempty"`
	// QueueAvg is the average queue depth, from the kernel's weighted IO time.
	QueueAvg *float64 `json:"queue_avg,omitempty"`
	// Appeared marks a device absent at the baseline, so it has no interval.
	Appeared bool `json:"appeared,omitempty"`
	// Code is CodeCounterRewind when the device's counters went backwards.
	Code string `json:"code,omitempty"`
}

type DiskRaw struct {
	ReadSectors  uint64 // field 3
	WriteSectors uint64 // field 7
	IOTicksMS    uint64 // field 10: milliseconds spent doing IO
	WeightedMS   uint64 // field 11: weighted IO milliseconds, i.e. queue integral
}

type FSRaw struct {
	TotalBytes uint64
	AvailBytes uint64
}

type FSUsage struct {
	Path          string `json:"path"`
	TotalBytes    uint64 `json:"total_bytes"`
	AvailBaseline uint64 `json:"avail_baseline_bytes"`
	AvailFinal    uint64 `json:"avail_final_bytes"`
}

type HealthNote struct {
	Key     string
	Message string
}

type Identity struct {
	Hostname string `json:"hostname"`
	// MachineIDHash is sha256(machine-id) truncated to 16 hex characters. The
	// raw id identifies the host to anyone who reads a snapshot, and a
	// truncated hash is enough to tell two hosts apart.
	MachineIDHash string `json:"machine_id_hash"`
	// BootIDHash changes on reboot, which is how a mid-run reboot is caught.
	BootIDHash string `json:"boot_id_hash"`
	PIDNS      string `json:"pid_ns"`
	NetNS      string `json:"net_ns"`
	MntNS      string `json:"mnt_ns"`
	// CgroupNS says which namespace the cgroup values were read from. It is
	// always displayed next to cgroup.scope: scope says which cgroup, this
	// says from where, and neither alone fixes what was measured.
	CgroupNS     string `json:"cgroup_ns"`
	Role         string `json:"role,omitempty"`
	AgentVersion string `json:"agent_version"`
}

type Interval struct {
	BaselineAt time.Time `json:"baseline_at"`
	FinalAt    time.Time `json:"final_at"`
	Seconds    float64   `json:"seconds"`
}

type MemRaw struct {
	TotalBytes     uint64
	AvailableBytes uint64
	CachedBytes    uint64
	DirtyBytes     uint64
	SwapTotalBytes uint64
	SwapFreeBytes  uint64
}

type Memory struct {
	TotalBytes        uint64 `json:"total_bytes"`
	AvailableBaseline uint64 `json:"available_baseline_bytes"`
	AvailableFinal    uint64 `json:"available_final_bytes"`
	CachedBaseline    uint64 `json:"cached_baseline_bytes"`
	CachedFinal       uint64 `json:"cached_final_bytes"`
	DirtyBaseline     uint64 `json:"dirty_baseline_bytes"`
	DirtyFinal        uint64 `json:"dirty_final_bytes"`
	SwapTotalBytes    uint64 `json:"swap_total_bytes"`
	SwapFreeBaseline  uint64 `json:"swap_free_baseline_bytes"`
	SwapFreeFinal     uint64 `json:"swap_free_final_bytes"`
	// PageMajorFaults is the interval delta of pgmajfault: page faults that
	// had to reach the disk, which is what memory pressure feels like.
	PageMajorFaults uint64 `json:"page_major_faults"`
}

type Options struct {
	// ProcFS is /proc. Also the required source: New fails without it.
	ProcFS fs.FS
	// SysFS is /sys, used to tell whole devices from partitions.
	SysFS fs.FS
	// EtcFS is /etc, the source of machine-id.
	EtcFS fs.FS
	// CGroupFS is the cgroup2 mount. Defaults to the mount resolved from
	// /proc/self/mountinfo.
	CGroupFS fs.FS
	// CGroupRoot is that mount's absolute path, needed to check that a
	// configured cgroup path does not escape the mount through a symlink.
	CGroupRoot string

	// Statfs, Readlink and EvalSymlinks are syscalls that fs.FS cannot express,
	// so they are injected as functions instead.
	Statfs       func(path string) (FSRaw, error)
	Readlink     func(name string) (string, error)
	EvalSymlinks func(name string) (string, error)
	// Hostname resolves this host's name.
	Hostname func() (string, error)
	// Getenv reads configuration. Injected so tests need no process-global
	// environment.
	Getenv func(key string) string

	// DataDir is the second statfs target, typically the database data
	// directory: the root filesystem filling up and the data volume filling up
	// are different incidents.
	DataDir string
	// Now supplies boundary timestamps.
	Now func() time.Time
}

type PSI struct {
	CPU    PSIResource `json:"cpu"`
	Memory PSIResource `json:"memory"`
	IO     PSIResource `json:"io"`
}

type PSIRaw struct {
	SomeAvg10   float64
	SomeAvg60   float64
	SomeTotalUS uint64
	FullAvg10   float64
	FullAvg60   float64
	FullTotalUS uint64
	// HasFull records whether a full line existed. Kernels before 5.13 have
	// none for cpu, and "absent" must not be rendered as "zero pressure".
	HasFull bool
}

type PSIResource struct {
	SomeAvg10      float64  `json:"some_avg10"`
	SomeAvg60      float64  `json:"some_avg60"`
	SomeStallRatio *float64 `json:"some_stall_ratio,omitempty"`
	FullAvg10      float64  `json:"full_avg10,omitempty"`
	FullAvg60      float64  `json:"full_avg60,omitempty"`
	FullStallRatio *float64 `json:"full_stall_ratio,omitempty"`
}

type Sample struct {
	// Phase is the boundary this sample belongs to.
	Phase runctl.Phase
	// At is the boundary timestamp, taken immediately before the required
	// source so the boundary is one instant rather than the span of all reads.
	At time.Time
	// Identity is captured at both boundaries because a reboot or a swapped
	// host mid-run invalidates every cumulative counter below.
	Identity Identity
	// Mem holds /proc/meminfo converted to bytes.
	Mem MemRaw
	// MajFault is the cumulative pgmajfault counter from /proc/vmstat.
	MajFault uint64
	// HasMajFault distinguishes "zero major faults" from "vmstat unreadable".
	HasMajFault bool
	// Disks holds cumulative /proc/diskstats counters keyed by device.
	Disks map[string]DiskRaw
	// PSI holds pressure counters keyed by "cpu", "memory" and "io".
	PSI map[string]PSIRaw
	// FS holds statfs results keyed by mount path.
	FS map[string]FSRaw
	// CGroup is nil when cgroup reading was skipped.
	CGroup *CGroupRaw
	// CGroupSkip explains a nil CGroup for health reporting: "v1", "no-mount"
	// or "path-rejected:<code>".
	CGroupSkip string
	// Codes lists per-source skips as "not-captured:<source>".
	Codes []string
}

type Section struct {
	Identity    Identity  `json:"identity"`
	Interval    Interval  `json:"interval"`
	Memory      Memory    `json:"memory"`
	Disks       []Disk    `json:"disks,omitempty"`       // sorted by Device
	PSI         *PSI      `json:"psi,omitempty"`         // nil on kernels without PSI
	Filesystems []FSUsage `json:"filesystems,omitempty"` // sorted by Path
	CGroup      *CGroup   `json:"cgroup,omitempty"`      // nil when skipped
	// Partial marks a section that is usable but incomplete. It never fails
	// the run: hoststats is optional, so its worst outcome is a partial run.
	Partial bool `json:"partial,omitempty"`
	// Codes lists this package's stable codes, sorted. Empty means clean.
	Codes []string `json:"codes,omitempty"`
	// contains filtered or unexported fields
}