blob: 25c11e0b0753bcfdb8e286154f304e144c7e0e4b [file] [log] [blame]
// Copyright (c) HashiCorp, Inc.
// SPDX-License-Identifier: MPL-2.0
//go:build !openbsd
package hostutil
import (
// HostInfo holds all the information that gets captured on the host. The
// set of information captured depends on the host operating system. For more
// information, refer to:
type HostInfo struct {
// Timestamp returns the timestamp in UTC on the collection time.
Timestamp time.Time `json:"timestamp"`
// CPU returns information about the CPU such as family, model, cores, etc.
CPU []cpu.InfoStat `json:"cpu"`
// CPUTimes returns statistics on CPU usage represented in Jiffies.
CPUTimes []cpu.TimesStat `json:"cpu_times"`
// Disk returns statitics on disk usage for all accessible partitions.
Disk []*disk.UsageStat `json:"disk"`
// Host returns general host information such as hostname, platform, uptime,
// kernel version, etc.
Host *HostInfoStat `json:"host"`
// Memory contains statistics about the memory such as total, available, and
// used memory in number of bytes.
Memory *VirtualMemoryStat `json:"memory"`
// CollectHostInfo returns information on the host, which includes general
// host status, CPU, memory, and disk utilization.
// The function does a best-effort capture on the most information possible,
// continuing on capture errors encountered and appending them to a resulting
// multierror.Error that gets returned at the end.
func CollectHostInfo(ctx context.Context) (*HostInfo, error) {
var retErr *multierror.Error
info := &HostInfo{Timestamp: time.Now().UTC()}
if h, err := CollectHostInfoStat(ctx); err != nil {
retErr = multierror.Append(retErr, &HostInfoError{"host", err})
} else {
info.Host = h
if v, err := CollectHostMemory(ctx); err != nil {
retErr = multierror.Append(retErr, &HostInfoError{"memory", err})
} else {
info.Memory = v
parts, err := disk.PartitionsWithContext(ctx, false)
if err != nil {
retErr = multierror.Append(retErr, &HostInfoError{"disk", err})
} else {
var usage []*disk.UsageStat
for i, part := range parts {
u, err := disk.UsageWithContext(ctx, part.Mountpoint)
if err != nil {
retErr = multierror.Append(retErr, &HostInfoError{fmt.Sprintf("disk.%d", i), err})
usage = append(usage, u)
info.Disk = usage
if c, err := cpu.InfoWithContext(ctx); err != nil {
retErr = multierror.Append(retErr, &HostInfoError{"cpu", err})
} else {
info.CPU = c
t, err := cpu.TimesWithContext(ctx, true)
if err != nil {
retErr = multierror.Append(retErr, &HostInfoError{"cpu_times", err})
} else {
info.CPUTimes = t
return info, retErr.ErrorOrNil()
func CollectHostMemory(ctx context.Context) (*VirtualMemoryStat, error) {
m, err := mem.VirtualMemoryWithContext(ctx)
if err != nil {
return nil, err
return &VirtualMemoryStat{
Total: m.Total,
Available: m.Available,
Used: m.Used,
UsedPercent: m.UsedPercent,
Free: m.Free,
Active: m.Active,
Inactive: m.Inactive,
Wired: m.Wired,
Laundry: m.Laundry,
Buffers: m.Buffers,
Cached: m.Cached,
Writeback: m.WriteBack,
Dirty: m.Dirty,
WritebackTmp: m.WriteBackTmp,
Shared: m.Shared,
Slab: m.Slab,
SReclaimable: m.Sreclaimable,
SUnreclaim: m.Sunreclaim,
PageTables: m.PageTables,
SwapCached: m.SwapCached,
CommitLimit: m.CommitLimit,
CommittedAS: m.CommittedAS,
HighTotal: m.HighTotal,
HighFree: m.HighFree,
LowTotal: m.LowTotal,
LowFree: m.LowFree,
SwapTotal: m.SwapTotal,
SwapFree: m.SwapFree,
Mapped: m.Mapped,
VMallocTotal: m.VmallocTotal,
VMallocUsed: m.VmallocUsed,
VMallocChunk: m.VmallocChunk,
HugePagesTotal: m.HugePagesTotal,
HugePagesFree: m.HugePagesFree,
HugePageSize: m.HugePageSize,
}, nil
func CollectHostInfoStat(ctx context.Context) (*HostInfoStat, error) {
h, err := host.InfoWithContext(ctx)
if err != nil {
return nil, err
return &HostInfoStat{
Hostname: h.Hostname,
Uptime: h.Uptime,
BootTime: h.BootTime,
Procs: h.Procs,
OS: h.OS,
Platform: h.Platform,
PlatformFamily: h.PlatformFamily,
PlatformVersion: h.PlatformVersion,
KernelVersion: h.KernelVersion,
KernelArch: h.KernelArch,
VirtualizationSystem: h.VirtualizationSystem,
VirtualizationRole: h.VirtualizationRole,
HostID: h.HostID,
}, nil