Documentation

Index

Constants

View Source
const (
	RLIMIT_CPU        int32 = 0
	RLIMIT_FSIZE      int32 = 1
	RLIMIT_DATA       int32 = 2
	RLIMIT_STACK      int32 = 3
	RLIMIT_CORE       int32 = 4
	RLIMIT_RSS        int32 = 5
	RLIMIT_NPROC      int32 = 6
	RLIMIT_NOFILE     int32 = 7
	RLIMIT_MEMLOCK    int32 = 8
	RLIMIT_AS         int32 = 9
	RLIMIT_LOCKS      int32 = 10
	RLIMIT_SIGPENDING int32 = 11
	RLIMIT_MSGQUEUE   int32 = 12
	RLIMIT_NICE       int32 = 13
	RLIMIT_RTPRIO     int32 = 14
	RLIMIT_RTTIME     int32 = 15
)

    Resource limit constants are from /usr/include/x86_64-linux-gnu/bits/resource.h from libc6-dev package in Ubuntu 16.10

    View Source
    const (
    	PrioProcess = 0   // linux/resource.h
    	ClockTicks  = 100 // C.sysconf(C._SC_CLK_TCK)
    )

    Variables

    View Source
    var (
    	ErrorNoChildren        = errors.New("process does not have children")
    	ErrorProcessNotRunning = errors.New("process does not exist")
    )
    View Source
    var PageSize = uint64(os.Getpagesize())

    Functions

    func PidExists

    func PidExists(pid int32) (bool, error)

    func PidExistsWithContext

    func PidExistsWithContext(ctx context.Context, pid int32) (bool, error)

    func Pids

    func Pids() ([]int32, error)

      Pids returns a slice of process ID list which are running now.

      func PidsWithContext

      func PidsWithContext(ctx context.Context) ([]int32, error)

      Types

      type IOCountersStat

      type IOCountersStat struct {
      	ReadCount  uint64 `json:"readCount"`
      	WriteCount uint64 `json:"writeCount"`
      	ReadBytes  uint64 `json:"readBytes"`
      	WriteBytes uint64 `json:"writeBytes"`
      }

      func (IOCountersStat) String

      func (i IOCountersStat) String() string

      type MemoryInfoExStat

      type MemoryInfoExStat struct {
      	RSS    uint64 `json:"rss"`    // bytes
      	VMS    uint64 `json:"vms"`    // bytes
      	Shared uint64 `json:"shared"` // bytes
      	Text   uint64 `json:"text"`   // bytes
      	Lib    uint64 `json:"lib"`    // bytes
      	Data   uint64 `json:"data"`   // bytes
      	Dirty  uint64 `json:"dirty"`  // bytes
      }

        MemoryInfoExStat is different between OSes

        func (MemoryInfoExStat) String

        func (m MemoryInfoExStat) String() string

        type MemoryInfoStat

        type MemoryInfoStat struct {
        	RSS    uint64 `json:"rss"`    // bytes
        	VMS    uint64 `json:"vms"`    // bytes
        	HWM    uint64 `json:"hwm"`    // bytes
        	Data   uint64 `json:"data"`   // bytes
        	Stack  uint64 `json:"stack"`  // bytes
        	Locked uint64 `json:"locked"` // bytes
        	Swap   uint64 `json:"swap"`   // bytes
        }

        func (MemoryInfoStat) String

        func (m MemoryInfoStat) String() string

        type MemoryMapsStat

        type MemoryMapsStat struct {
        	Path         string `json:"path"`
        	Rss          uint64 `json:"rss"`
        	Size         uint64 `json:"size"`
        	Pss          uint64 `json:"pss"`
        	SharedClean  uint64 `json:"sharedClean"`
        	SharedDirty  uint64 `json:"sharedDirty"`
        	PrivateClean uint64 `json:"privateClean"`
        	PrivateDirty uint64 `json:"privateDirty"`
        	Referenced   uint64 `json:"referenced"`
        	Anonymous    uint64 `json:"anonymous"`
        	Swap         uint64 `json:"swap"`
        }

        func (MemoryMapsStat) String

        func (m MemoryMapsStat) String() string

          String returns JSON value of the process.

          type NumCtxSwitchesStat

          type NumCtxSwitchesStat struct {
          	Voluntary   int64 `json:"voluntary"`
          	Involuntary int64 `json:"involuntary"`
          }

          func (NumCtxSwitchesStat) String

          func (p NumCtxSwitchesStat) String() string

          type OpenFilesStat

          type OpenFilesStat struct {
          	Path string `json:"path"`
          	Fd   uint64 `json:"fd"`
          }

          func (OpenFilesStat) String

          func (o OpenFilesStat) String() string

          type PageFaultsStat

          type PageFaultsStat struct {
          	MinorFaults      uint64 `json:"minorFaults"`
          	MajorFaults      uint64 `json:"majorFaults"`
          	ChildMinorFaults uint64 `json:"childMinorFaults"`
          	ChildMajorFaults uint64 `json:"childMajorFaults"`
          }

          type Process

          type Process struct {
          	Pid int32 `json:"pid"`
          	// contains filtered or unexported fields
          }

          func NewProcess

          func NewProcess(pid int32) (*Process, error)

            NewProcess creates a new Process instance, it only stores the pid and checks that the process exists. Other method on Process can be used to get more information about the process. An error will be returned if the process does not exist.

            func NewProcessWithContext

            func NewProcessWithContext(ctx context.Context, pid int32) (*Process, error)

            func Processes

            func Processes() ([]*Process, error)

              Processes returns a slice of pointers to Process structs for all currently running processes.

              func ProcessesWithContext

              func ProcessesWithContext(ctx context.Context) ([]*Process, error)

              func (*Process) Background

              func (p *Process) Background() (bool, error)

                Background returns true if the process is in background, false otherwise.

                func (*Process) BackgroundWithContext

                func (p *Process) BackgroundWithContext(ctx context.Context) (bool, error)

                func (*Process) CPUAffinity

                func (p *Process) CPUAffinity() ([]int32, error)

                  CPUAffinity returns CPU affinity of the process.

                  func (*Process) CPUAffinityWithContext

                  func (p *Process) CPUAffinityWithContext(ctx context.Context) ([]int32, error)

                  func (*Process) CPUPercent

                  func (p *Process) CPUPercent() (float64, error)

                    CPU_Percent returns how many percent of the CPU time this process uses

                    func (*Process) CPUPercentWithContext

                    func (p *Process) CPUPercentWithContext(ctx context.Context) (float64, error)

                    func (*Process) Children

                    func (p *Process) Children() ([]*Process, error)

                      Children returns the children of the process represented as a slice of pointers to Process type.

                      func (*Process) ChildrenWithContext

                      func (p *Process) ChildrenWithContext(ctx context.Context) ([]*Process, error)

                      func (*Process) Cmdline

                      func (p *Process) Cmdline() (string, error)

                        Cmdline returns the command line arguments of the process as a string with each argument separated by 0x20 ascii character.

                        func (*Process) CmdlineSlice

                        func (p *Process) CmdlineSlice() ([]string, error)

                          CmdlineSlice returns the command line arguments of the process as a slice with each element being an argument.

                          func (*Process) CmdlineSliceWithContext

                          func (p *Process) CmdlineSliceWithContext(ctx context.Context) ([]string, error)

                          func (*Process) CmdlineWithContext

                          func (p *Process) CmdlineWithContext(ctx context.Context) (string, error)

                          func (*Process) Connections

                          func (p *Process) Connections() ([]net.ConnectionStat, error)

                            Connections returns a slice of net.ConnectionStat used by the process. This returns all kind of the connection. This means TCP, UDP or UNIX.

                            func (*Process) ConnectionsMax

                            func (p *Process) ConnectionsMax(max int) ([]net.ConnectionStat, error)

                              Connections returns a slice of net.ConnectionStat used by the process at most `max`.

                              func (*Process) ConnectionsMaxWithContext

                              func (p *Process) ConnectionsMaxWithContext(ctx context.Context, max int) ([]net.ConnectionStat, error)

                              func (*Process) ConnectionsWithContext

                              func (p *Process) ConnectionsWithContext(ctx context.Context) ([]net.ConnectionStat, error)

                              func (*Process) CreateTime

                              func (p *Process) CreateTime() (int64, error)

                                CreateTime returns created time of the process in milliseconds since the epoch, in UTC.

                                func (*Process) CreateTimeWithContext

                                func (p *Process) CreateTimeWithContext(ctx context.Context) (int64, error)

                                func (*Process) Cwd

                                func (p *Process) Cwd() (string, error)

                                  Cwd returns current working directory of the process.

                                  func (*Process) CwdWithContext

                                  func (p *Process) CwdWithContext(ctx context.Context) (string, error)

                                  func (*Process) Exe

                                  func (p *Process) Exe() (string, error)

                                    Exe returns executable path of the process.

                                    func (*Process) ExeWithContext

                                    func (p *Process) ExeWithContext(ctx context.Context) (string, error)

                                    func (*Process) Foreground

                                    func (p *Process) Foreground() (bool, error)

                                      Foreground returns true if the process is in foreground, false otherwise.

                                      func (*Process) ForegroundWithContext

                                      func (p *Process) ForegroundWithContext(ctx context.Context) (bool, error)

                                      func (*Process) Gids

                                      func (p *Process) Gids() ([]int32, error)

                                        Gids returns group ids of the process as a slice of the int

                                        func (*Process) GidsWithContext

                                        func (p *Process) GidsWithContext(ctx context.Context) ([]int32, error)

                                        func (*Process) Groups

                                        func (p *Process) Groups() ([]int32, error)

                                          Groups returns all group IDs(include supplementary groups) of the process as a slice of the int

                                          func (*Process) GroupsWithContext

                                          func (p *Process) GroupsWithContext(ctx context.Context) ([]int32, error)

                                          func (*Process) IOCounters

                                          func (p *Process) IOCounters() (*IOCountersStat, error)

                                            IOCounters returns IO Counters.

                                            func (*Process) IOCountersWithContext

                                            func (p *Process) IOCountersWithContext(ctx context.Context) (*IOCountersStat, error)

                                            func (*Process) IOnice

                                            func (p *Process) IOnice() (int32, error)

                                              IOnice returns process I/O nice value (priority).

                                              func (*Process) IOniceWithContext

                                              func (p *Process) IOniceWithContext(ctx context.Context) (int32, error)

                                              func (*Process) IsRunning

                                              func (p *Process) IsRunning() (bool, error)

                                                IsRunning returns whether the process is still running or not.

                                                func (*Process) IsRunningWithContext

                                                func (p *Process) IsRunningWithContext(ctx context.Context) (bool, error)

                                                func (*Process) Kill

                                                func (p *Process) Kill() error

                                                  Kill sends SIGKILL to the process.

                                                  func (*Process) KillWithContext

                                                  func (p *Process) KillWithContext(ctx context.Context) error

                                                  func (*Process) MemoryInfo

                                                  func (p *Process) MemoryInfo() (*MemoryInfoStat, error)

                                                    MemoryInfo returns generic process memory information, such as RSS and VMS.

                                                    func (*Process) MemoryInfoEx

                                                    func (p *Process) MemoryInfoEx() (*MemoryInfoExStat, error)

                                                      MemoryInfoEx returns platform-specific process memory information.

                                                      func (*Process) MemoryInfoExWithContext

                                                      func (p *Process) MemoryInfoExWithContext(ctx context.Context) (*MemoryInfoExStat, error)

                                                      func (*Process) MemoryInfoWithContext

                                                      func (p *Process) MemoryInfoWithContext(ctx context.Context) (*MemoryInfoStat, error)

                                                      func (*Process) MemoryMaps

                                                      func (p *Process) MemoryMaps(grouped bool) (*[]MemoryMapsStat, error)

                                                        MemoryMaps get memory maps from /proc/(pid)/smaps

                                                        func (*Process) MemoryMapsWithContext

                                                        func (p *Process) MemoryMapsWithContext(ctx context.Context, grouped bool) (*[]MemoryMapsStat, error)

                                                        func (*Process) MemoryPercent

                                                        func (p *Process) MemoryPercent() (float32, error)

                                                          MemoryPercent returns how many percent of the total RAM this process uses

                                                          func (*Process) MemoryPercentWithContext

                                                          func (p *Process) MemoryPercentWithContext(ctx context.Context) (float32, error)

                                                          func (*Process) Name

                                                          func (p *Process) Name() (string, error)

                                                            Name returns name of the process.

                                                            func (*Process) NameWithContext

                                                            func (p *Process) NameWithContext(ctx context.Context) (string, error)

                                                            func (*Process) NetIOCounters

                                                            func (p *Process) NetIOCounters(pernic bool) ([]net.IOCountersStat, error)

                                                              NetIOCounters returns NetIOCounters of the process.

                                                              func (*Process) NetIOCountersWithContext

                                                              func (p *Process) NetIOCountersWithContext(ctx context.Context, pernic bool) ([]net.IOCountersStat, error)

                                                              func (*Process) Nice

                                                              func (p *Process) Nice() (int32, error)

                                                                Nice returns a nice value (priority).

                                                                func (*Process) NiceWithContext

                                                                func (p *Process) NiceWithContext(ctx context.Context) (int32, error)

                                                                func (*Process) NumCtxSwitches

                                                                func (p *Process) NumCtxSwitches() (*NumCtxSwitchesStat, error)

                                                                  NumCtxSwitches returns the number of the context switches of the process.

                                                                  func (*Process) NumCtxSwitchesWithContext

                                                                  func (p *Process) NumCtxSwitchesWithContext(ctx context.Context) (*NumCtxSwitchesStat, error)

                                                                  func (*Process) NumFDs

                                                                  func (p *Process) NumFDs() (int32, error)

                                                                    NumFDs returns the number of File Descriptors used by the process.

                                                                    func (*Process) NumFDsWithContext

                                                                    func (p *Process) NumFDsWithContext(ctx context.Context) (int32, error)

                                                                    func (*Process) NumThreads

                                                                    func (p *Process) NumThreads() (int32, error)

                                                                      NumThreads returns the number of threads used by the process.

                                                                      func (*Process) NumThreadsWithContext

                                                                      func (p *Process) NumThreadsWithContext(ctx context.Context) (int32, error)

                                                                      func (*Process) OpenFiles

                                                                      func (p *Process) OpenFiles() ([]OpenFilesStat, error)

                                                                        OpenFiles returns a slice of OpenFilesStat opend by the process. OpenFilesStat includes a file path and file descriptor.

                                                                        func (*Process) OpenFilesWithContext

                                                                        func (p *Process) OpenFilesWithContext(ctx context.Context) ([]OpenFilesStat, error)

                                                                        func (*Process) PageFaults

                                                                        func (p *Process) PageFaults() (*PageFaultsStat, error)

                                                                          PageFaultsInfo returns the process's page fault counters.

                                                                          func (*Process) PageFaultsWithContext

                                                                          func (p *Process) PageFaultsWithContext(ctx context.Context) (*PageFaultsStat, error)

                                                                          func (*Process) Parent

                                                                          func (p *Process) Parent() (*Process, error)

                                                                            Parent returns parent Process of the process.

                                                                            func (*Process) ParentWithContext

                                                                            func (p *Process) ParentWithContext(ctx context.Context) (*Process, error)

                                                                            func (*Process) Percent

                                                                            func (p *Process) Percent(interval time.Duration) (float64, error)

                                                                              If interval is 0, return difference from last call(non-blocking). If interval > 0, wait interval sec and return diffrence between start and end.

                                                                              func (*Process) PercentWithContext

                                                                              func (p *Process) PercentWithContext(ctx context.Context, interval time.Duration) (float64, error)

                                                                              func (*Process) Ppid

                                                                              func (p *Process) Ppid() (int32, error)

                                                                                Ppid returns Parent Process ID of the process.

                                                                                func (*Process) PpidWithContext

                                                                                func (p *Process) PpidWithContext(ctx context.Context) (int32, error)

                                                                                func (*Process) Resume

                                                                                func (p *Process) Resume() error

                                                                                  Resume sends SIGCONT to the process.

                                                                                  func (*Process) ResumeWithContext

                                                                                  func (p *Process) ResumeWithContext(ctx context.Context) error

                                                                                  func (*Process) Rlimit

                                                                                  func (p *Process) Rlimit() ([]RlimitStat, error)

                                                                                    Rlimit returns Resource Limits.

                                                                                    func (*Process) RlimitUsage

                                                                                    func (p *Process) RlimitUsage(gatherUsed bool) ([]RlimitStat, error)

                                                                                      RlimitUsage returns Resource Limits. If gatherUsed is true, the currently used value will be gathered and added to the resulting RlimitStat.

                                                                                      func (*Process) RlimitUsageWithContext

                                                                                      func (p *Process) RlimitUsageWithContext(ctx context.Context, gatherUsed bool) ([]RlimitStat, error)

                                                                                      func (*Process) RlimitWithContext

                                                                                      func (p *Process) RlimitWithContext(ctx context.Context) ([]RlimitStat, error)

                                                                                      func (*Process) SendSignal

                                                                                      func (p *Process) SendSignal(sig syscall.Signal) error

                                                                                        SendSignal sends a unix.Signal to the process.

                                                                                        func (*Process) SendSignalWithContext

                                                                                        func (p *Process) SendSignalWithContext(ctx context.Context, sig syscall.Signal) error

                                                                                        func (*Process) Status

                                                                                        func (p *Process) Status() (string, error)

                                                                                          Status returns the process status. Return value could be one of these. R: Running S: Sleep T: Stop I: Idle Z: Zombie W: Wait L: Lock The character is same within all supported platforms.

                                                                                          func (*Process) StatusWithContext

                                                                                          func (p *Process) StatusWithContext(ctx context.Context) (string, error)

                                                                                          func (Process) String

                                                                                          func (p Process) String() string

                                                                                          func (*Process) Suspend

                                                                                          func (p *Process) Suspend() error

                                                                                            Suspend sends SIGSTOP to the process.

                                                                                            func (*Process) SuspendWithContext

                                                                                            func (p *Process) SuspendWithContext(ctx context.Context) error

                                                                                            func (*Process) Terminal

                                                                                            func (p *Process) Terminal() (string, error)

                                                                                              Terminal returns a terminal which is associated with the process.

                                                                                              func (*Process) TerminalWithContext

                                                                                              func (p *Process) TerminalWithContext(ctx context.Context) (string, error)

                                                                                              func (*Process) Terminate

                                                                                              func (p *Process) Terminate() error

                                                                                                Terminate sends SIGTERM to the process.

                                                                                                func (*Process) TerminateWithContext

                                                                                                func (p *Process) TerminateWithContext(ctx context.Context) error

                                                                                                func (*Process) Tgid

                                                                                                func (p *Process) Tgid() (int32, error)

                                                                                                  Tgid returns thread group id of the process.

                                                                                                  func (*Process) TgidWithContext

                                                                                                  func (p *Process) TgidWithContext(ctx context.Context) (int32, error)

                                                                                                  func (*Process) Threads

                                                                                                  func (p *Process) Threads() (map[int32]*cpu.TimesStat, error)

                                                                                                  func (*Process) ThreadsWithContext

                                                                                                  func (p *Process) ThreadsWithContext(ctx context.Context) (map[int32]*cpu.TimesStat, error)

                                                                                                  func (*Process) Times

                                                                                                  func (p *Process) Times() (*cpu.TimesStat, error)

                                                                                                    Times returns CPU times of the process.

                                                                                                    func (*Process) TimesWithContext

                                                                                                    func (p *Process) TimesWithContext(ctx context.Context) (*cpu.TimesStat, error)

                                                                                                    func (*Process) Uids

                                                                                                    func (p *Process) Uids() ([]int32, error)

                                                                                                      Uids returns user ids of the process as a slice of the int

                                                                                                      func (*Process) UidsWithContext

                                                                                                      func (p *Process) UidsWithContext(ctx context.Context) ([]int32, error)

                                                                                                      func (*Process) Username

                                                                                                      func (p *Process) Username() (string, error)

                                                                                                        Username returns a username of the process.

                                                                                                        func (*Process) UsernameWithContext

                                                                                                        func (p *Process) UsernameWithContext(ctx context.Context) (string, error)

                                                                                                        type RlimitStat

                                                                                                        type RlimitStat struct {
                                                                                                        	Resource int32  `json:"resource"`
                                                                                                        	Soft     int32  `json:"soft"` //TODO too small. needs to be uint64
                                                                                                        	Hard     int32  `json:"hard"` //TODO too small. needs to be uint64
                                                                                                        	Used     uint64 `json:"used"`
                                                                                                        }

                                                                                                        func (RlimitStat) String

                                                                                                        func (r RlimitStat) String() string

                                                                                                        type SignalInfoStat

                                                                                                        type SignalInfoStat struct {
                                                                                                        	PendingProcess uint64 `json:"pending_process"`
                                                                                                        	PendingThread  uint64 `json:"pending_thread"`
                                                                                                        	Blocked        uint64 `json:"blocked"`
                                                                                                        	Ignored        uint64 `json:"ignored"`
                                                                                                        	Caught         uint64 `json:"caught"`
                                                                                                        }