func (p *ProcessStatSample) collectNumThreads(proc *process.Process) {
defer func() {
if e := recover(); e != nil {
log.Warnf("Recovered from panic on Number of Threads collection. Maybe unsupported on this platform.")
}
}()
numThreads, err := proc.NumThreads()
if err != nil {
log.Warnf("Error encountered collecting thread count stats: %s", err)
} else {
p.NumThreads += numThreads
}
}
func (p *ProcessStatSample) collectOpenFiles(proc *process.Process) {
defer func() {
if e := recover(); e != nil {
log.Warnf("Recovered from panic on Open Files collection. Maybe unsupported on this platform.")
}
}()
openFiles, err := proc.OpenFiles()
if err != nil {
log.Warnf("Error encountered collecting open files stats: %s", err)
} else {
p.OpenFiles = append(p.OpenFiles, openFiles...)
}
}
func (p *ProcessStatSample) collectCPUPercent(proc *process.Process) {
defer func() {
if e := recover(); e != nil {
log.Warnf("Recovered from panic on CPU Percent collection. Maybe unsupported on this platform.")
}
}()
// Use 0 interval to get difference since the last call
cpuPercent, err := proc.CPUPercent(0 * time.Second)
if err != nil {
log.Warnf("Error encountered collecting CPU percent: %s", err)
} else {
p.CPUPercent += cpuPercent
}
}
func (p *ProcessStatSample) collectIOCounters(proc *process.Process) {
defer func() {
if e := recover(); e != nil {
log.Warnf("Recovered from panic on IO counters collection. Maybe unsupported on this platform.")
}
}()
iocnt, err := proc.IOCounters()
if err != nil {
log.Warnf("Error encountered collecting I/O stats: %s", err)
} else {
src := reflect.ValueOf(iocnt).Elem()
dest := reflect.ValueOf(&p.IOCounters).Elem()
sum(&src, &dest)
}
}
func (p *ProcessStatSample) collectCPUTimes(proc *process.Process) {
defer func() {
if e := recover(); e != nil {
log.Warnf("Recovered from panic on CPU times collection. Maybe unsupported on this platform.")
}
}()
cputimes, err := proc.CPUTimes()
if err != nil {
log.Warnf("Error encountered collecting CPU stats: %s", err)
} else {
src := reflect.ValueOf(cputimes).Elem()
dest := reflect.ValueOf(&p.CPUTimes).Elem()
sum(&src, &dest)
}
}
func (p *ProcessStatSample) collectMemInfo(proc *process.Process) {
defer func() {
if e := recover(); e != nil {
log.Warnf("Recovered from panic on memory stats collection. Maybe unsupported on this platform.")
}
}()
meminfo, err := proc.MemoryInfo()
if err != nil {
log.Warnf("Error encountered collecting memory stats: %s", err)
} else {
src := reflect.ValueOf(meminfo).Elem()
dest := reflect.ValueOf(&p.Memory).Elem()
sum(&src, &dest)
}
}