proc

type CollectErrors struct {
	// Read is incremented every time GetMetrics() returns an error.
	// This means we failed to load even the basics for the process,
	// and not just because it disappeared on us.
	Read int
	// Partial is incremented every time we're unable to collect
	// some metrics (e.g. I/O) for a tracked proc, but we're still able
	// to get the basic stuff like cmdline and core stats.
	Partial int
}

type Counts struct {
	CPUUserTime           float64
	CPUSystemTime         float64
	ReadBytes             uint64
	WriteBytes            uint64
	MajorPageFaults       uint64
	MinorPageFaults       uint64
	CtxSwitchVoluntary    uint64
	CtxSwitchNonvoluntary uint64
}

type Delta Counts

type FS struct {
	procfs.FS
	BootTime   uint64
	MountPoint string
	// contains filtered or unexported fields
}

type Filedesc struct {
	// Open is the count of open file descriptors, -1 if unknown.
	Open int64
	// Limit is the fd soft limit for the process.
	Limit uint64
}

type Group struct {
	Counts
	States
	Wchans map[string]int
	Procs  int
	Memory
	OldestStartTime time.Time
	OpenFDs         uint64
	WorstFDratio    float64
	NumThreads      uint64
	Threads         []Threads
}

type GroupByName map[string]Group

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

type ID struct {
	// UNIX process id
	Pid int
	// The time the process started after system boot, the value is expressed
	// in clock ticks.
	StartTimeRel uint64
}

type IDInfo struct {
	ID
	Static
	Metrics
	Threads []Thread
}

type Iter interface {
	// Next returns true if the iterator is not exhausted.
	Next() bool
	// Close releases any resources the iterator uses.
	Close() error
	// The iterator satisfies the Proc interface.
	Proc
}

type Memory struct {
	ResidentBytes uint64
	VirtualBytes  uint64
	VmSwapBytes   uint64
}

type Metrics struct {
	Counts
	Memory
	Filedesc
	NumThreads uint64
	States
	Wchan string
}

type Proc interface {
	// GetPid() returns the POSIX PID (process id).  They may be reused over time.
	GetPid() int
	// GetProcID() returns (pid,starttime), which can be considered a unique process id.
	GetProcID() (ID, error)
	// GetStatic() returns various details read from files under /proc/<pid>/.  Technically
	// name may not be static, but we'll pretend it is.
	GetStatic() (Static, error)
	// GetMetrics() returns various metrics read from files under /proc/<pid>/.
	// It returns an error on complete failure.  Otherwise, it returns metrics
	// and 0 on complete success, 1 if some (like I/O) couldn't be read.
	GetMetrics() (Metrics, int, error)
	GetStates() (States, error)
	GetWchan() (string, error)
	GetCounts() (Counts, int, error)
	GetThreads() ([]Thread, error)
}

type Source interface {
	// AllProcs returns all the processes in this source at this moment in time.
	AllProcs() Iter
}

type States struct {
	Running  int
	Sleeping int
	Waiting  int
	Zombie   int
	Other    int
}

type Static struct {
	Name         string
	Cmdline      []string
	ParentPid    int
	StartTime    time.Time
	EffectiveUID int
}

type Thread struct {
	ThreadID
	ThreadName string
	Counts
	Wchan string
	States
}

type ThreadID ID

type ThreadUpdate struct {
	// ThreadName is the name of the thread based on field of stat.
	ThreadName string
	// Latest is how much the counts increased since last cycle.
	Latest Delta
}

type Threads struct {
	Name       string
	NumThreads int
	Counts
}

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

type Update struct {
	// GroupName is the name given by the namer to the process.
	GroupName string
	// Latest is how much the counts increased since last cycle.
	Latest Delta
	// Memory is the current memory usage.
	Memory
	// Filedesc is the current fd usage/limit.
	Filedesc
	// Start is the time the process started.
	Start time.Time
	// NumThreads is the number of threads.
	NumThreads uint64
	// States is how many processes are in which run state.
	States
	// Wchans is how many threads are in each non-zero wchan.
	Wchans map[string]int
	// Threads are the thread updates for this process, if the Tracker
	// has trackThreads==true.
	Threads []ThreadUpdate
}