services/crunchstat/crunchstat.go

   1 package main
   2
   3 import (
   4         "bufio"
   5         "bytes"
   6         "errors"
   7         "flag"
   8         "fmt"
   9         "io"
  10         "io/ioutil"
  11         "log"
  12         "os"
  13         "os/exec"
  14         "os/signal"
  15         "strconv"
  16         "strings"
  17         "syscall"
  18         "time"
  19 )
  20
  21 /*
  22 #include <unistd.h>
  23 #include <sys/types.h>
  24 #include <pwd.h>
  25 #include <stdlib.h>
  26 */
  27 import "C"
  28
  29 // The above block of magic allows us to look up user_hz via _SC_CLK_TCK.
  30
  31 type Cgroup struct {
  32         root   string
  33         parent string
  34         cid    string
  35 }
  36
  37 var childLog = log.New(os.Stderr, "", 0)
  38 var statLog = log.New(os.Stderr, "crunchstat: ", 0)
  39
  40 const (
  41         MaxLogLine = 1 << 14 // Child stderr lines >16KiB will be split
  42 )
  43
  44 func CopyPipeToChildLog(in io.ReadCloser, done chan<- bool) {
  45         reader := bufio.NewReaderSize(in, MaxLogLine)
  46         var prefix string
  47         for {
  48                 line, isPrefix, err := reader.ReadLine()
  49                 if err == io.EOF {
  50                         break
  51                 } else if err != nil {
  52                         statLog.Fatal("error reading child stderr:", err)
  53                 }
  54                 var suffix string
  55                 if isPrefix {
  56                         suffix = "[...]"
  57                 }
  58                 childLog.Print(prefix, string(line), suffix)
  59                 // Set up prefix for following line
  60                 if isPrefix {
  61                         prefix = "[...]"
  62                 } else {
  63                         prefix = ""
  64                 }
  65         }
  66         done <- true
  67         in.Close()
  68 }
  69
  70 func ReadAllOrWarn(in *os.File) ([]byte, error) {
  71         content, err := ioutil.ReadAll(in)
  72         if err != nil {
  73                 statLog.Printf("error reading %s: %s\n", in.Name(), err)
  74         }
  75         return content, err
  76 }
  77
  78 var reportedStatFile = map[string]string{}
  79
  80 // Open the cgroup stats file in /sys/fs corresponding to the target
  81 // cgroup, and return an *os.File. If no stats file is available,
  82 // return nil.
  83 //
  84 // TODO: Instead of trying all options, choose a process in the
  85 // container, and read /proc/PID/cgroup to determine the appropriate
  86 // cgroup root for the given statgroup. (This will avoid falling back
  87 // to host-level stats during container setup and teardown.)
  88 func OpenStatFile(cgroup Cgroup, statgroup string, stat string) (*os.File, error) {
  89         var paths []string
  90         if cgroup.cid != "" {
  91                 // Collect container's stats
  92                 paths = []string{
  93                         fmt.Sprintf("%s/%s/%s/%s/%s", cgroup.root, statgroup, cgroup.parent, cgroup.cid, stat),
  94                         fmt.Sprintf("%s/%s/%s/%s", cgroup.root, cgroup.parent, cgroup.cid, stat),
  95                 }
  96         } else {
  97                 // Collect this host's stats
  98                 paths = []string{
  99                         fmt.Sprintf("%s/%s/%s", cgroup.root, statgroup, stat),
 100                         fmt.Sprintf("%s/%s", cgroup.root, stat),
 101                 }
 102         }
 103         var path string
 104         var file *os.File
 105         var err error
 106         for _, path = range paths {
 107                 file, err = os.Open(path)
 108                 if err == nil {
 109                         break
 110                 } else {
 111                         path = ""
 112                 }
 113         }
 114         if pathWas, ok := reportedStatFile[stat]; !ok || pathWas != path {
 115                 // Log whenever we start using a new/different cgroup
 116                 // stat file for a given statistic. This typically
 117                 // happens 1 to 3 times per statistic, depending on
 118                 // whether we happen to collect stats [a] before any
 119                 // processes have been created in the container and
 120                 // [b] after all contained processes have exited.
 121                 if path == "" {
 122                         statLog.Printf("notice: stats not available: stat %s, statgroup %s, cid %s, parent %s, root %s\n", stat, statgroup, cgroup.cid, cgroup.parent, cgroup.root)
 123                 } else if ok {
 124                         statLog.Printf("notice: stats moved from %s to %s\n", reportedStatFile[stat], path)
 125                 } else {
 126                         statLog.Printf("notice: reading stats from %s\n", path)
 127                 }
 128                 reportedStatFile[stat] = path
 129         }
 130         return file, err
 131 }
 132
 133 func GetContainerNetStats(cgroup Cgroup) (io.Reader, error) {
 134         procsFile, err := OpenStatFile(cgroup, "cpuacct", "cgroup.procs")
 135         if err != nil {
 136                 return nil, err
 137         }
 138         defer procsFile.Close()
 139         reader := bufio.NewScanner(procsFile)
 140         for reader.Scan() {
 141                 taskPid := reader.Text()
 142                 statsFilename := fmt.Sprintf("/proc/%s/net/dev", taskPid)
 143                 stats, err := ioutil.ReadFile(statsFilename)
 144                 if err != nil {
 145                         statLog.Printf("error reading %s: %s\n", statsFilename, err)
 146                         continue
 147                 }
 148                 return strings.NewReader(string(stats)), nil
 149         }
 150         return nil, errors.New("Could not read stats for any proc in container")
 151 }
 152
 153 type IoSample struct {
 154         sampleTime time.Time
 155         txBytes    int64
 156         rxBytes    int64
 157 }
 158
 159 func DoBlkIoStats(cgroup Cgroup, lastSample map[string]IoSample) {
 160         c, err := OpenStatFile(cgroup, "blkio", "blkio.io_service_bytes")
 161         if err != nil {
 162                 return
 163         }
 164         defer c.Close()
 165         b := bufio.NewScanner(c)
 166         var sampleTime = time.Now()
 167         newSamples := make(map[string]IoSample)
 168         for b.Scan() {
 169                 var device, op string
 170                 var val int64
 171                 if _, err := fmt.Sscanf(string(b.Text()), "%s %s %d", &device, &op, &val); err != nil {
 172                         continue
 173                 }
 174                 var thisSample IoSample
 175                 var ok bool
 176                 if thisSample, ok = newSamples[device]; !ok {
 177                         thisSample = IoSample{sampleTime, -1, -1}
 178                 }
 179                 switch op {
 180                 case "Read":
 181                         thisSample.rxBytes = val
 182                 case "Write":
 183                         thisSample.txBytes = val
 184                 }
 185                 newSamples[device] = thisSample
 186         }
 187         for dev, sample := range newSamples {
 188                 if sample.txBytes < 0 || sample.rxBytes < 0 {
 189                         continue
 190                 }
 191                 delta := ""
 192                 if prev, ok := lastSample[dev]; ok {
 193                         delta = fmt.Sprintf(" -- interval %.4f seconds %d write %d read",
 194                                 sample.sampleTime.Sub(prev.sampleTime).Seconds(),
 195                                 sample.txBytes-prev.txBytes,
 196                                 sample.rxBytes-prev.rxBytes)
 197                 }
 198                 statLog.Printf("blkio:%s %d write %d read%s\n", dev, sample.txBytes, sample.rxBytes, delta)
 199                 lastSample[dev] = sample
 200         }
 201 }
 202
 203 type MemSample struct {
 204         sampleTime time.Time
 205         memStat    map[string]int64
 206 }
 207
 208 func DoMemoryStats(cgroup Cgroup) {
 209         c, err := OpenStatFile(cgroup, "memory", "memory.stat")
 210         if err != nil {
 211                 return
 212         }
 213         defer c.Close()
 214         b := bufio.NewScanner(c)
 215         thisSample := MemSample{time.Now(), make(map[string]int64)}
 216         wantStats := [...]string{"cache", "swap", "pgmajfault", "rss"}
 217         for b.Scan() {
 218                 var stat string
 219                 var val int64
 220                 if _, err := fmt.Sscanf(string(b.Text()), "%s %d", &stat, &val); err != nil {
 221                         continue
 222                 }
 223                 thisSample.memStat[stat] = val
 224         }
 225         var outstat bytes.Buffer
 226         for _, key := range wantStats {
 227                 if val, ok := thisSample.memStat[key]; ok {
 228                         outstat.WriteString(fmt.Sprintf(" %d %s", val, key))
 229                 }
 230         }
 231         statLog.Printf("mem%s\n", outstat.String())
 232 }
 233
 234 func DoNetworkStats(cgroup Cgroup, lastSample map[string]IoSample) {
 235         sampleTime := time.Now()
 236         stats, err := GetContainerNetStats(cgroup)
 237         if err != nil {
 238                 return
 239         }
 240
 241         scanner := bufio.NewScanner(stats)
 242         for scanner.Scan() {
 243                 var ifName string
 244                 var rx, tx int64
 245                 words := strings.Fields(scanner.Text())
 246                 if len(words) != 17 {
 247                         // Skip lines with wrong format
 248                         continue
 249                 }
 250                 ifName = strings.TrimRight(words[0], ":")
 251                 if ifName == "lo" || ifName == "" {
 252                         // Skip loopback interface and lines with wrong format
 253                         continue
 254                 }
 255                 if tx, err = strconv.ParseInt(words[9], 10, 64); err != nil {
 256                         continue
 257                 }
 258                 if rx, err = strconv.ParseInt(words[1], 10, 64); err != nil {
 259                         continue
 260                 }
 261                 nextSample := IoSample{}
 262                 nextSample.sampleTime = sampleTime
 263                 nextSample.txBytes = tx
 264                 nextSample.rxBytes = rx
 265                 var delta string
 266                 if prev, ok := lastSample[ifName]; ok {
 267                         interval := nextSample.sampleTime.Sub(prev.sampleTime).Seconds()
 268                         delta = fmt.Sprintf(" -- interval %.4f seconds %d tx %d rx",
 269                                 interval,
 270                                 tx-prev.txBytes,
 271                                 rx-prev.rxBytes)
 272                 }
 273                 statLog.Printf("net:%s %d tx %d rx%s\n", ifName, tx, rx, delta)
 274                 lastSample[ifName] = nextSample
 275         }
 276 }
 277
 278 type CpuSample struct {
 279         hasData    bool // to distinguish the zero value from real data
 280         sampleTime time.Time
 281         user       float64
 282         sys        float64
 283         cpus       int64
 284 }
 285
 286 // Return the number of CPUs available in the container. Return 0 if
 287 // we can't figure out the real number of CPUs.
 288 func GetCpuCount(cgroup Cgroup) int64 {
 289         cpusetFile, err := OpenStatFile(cgroup, "cpuset", "cpuset.cpus")
 290         if err != nil {
 291                 return 0
 292         }
 293         defer cpusetFile.Close()
 294         b, err := ReadAllOrWarn(cpusetFile)
 295         sp := strings.Split(string(b), ",")
 296         cpus := int64(0)
 297         for _, v := range sp {
 298                 var min, max int64
 299                 n, _ := fmt.Sscanf(v, "%d-%d", &min, &max)
 300                 if n == 2 {
 301                         cpus += (max - min) + 1
 302                 } else {
 303                         cpus += 1
 304                 }
 305         }
 306         return cpus
 307 }
 308
 309 func DoCpuStats(cgroup Cgroup, lastSample *CpuSample) {
 310         statFile, err := OpenStatFile(cgroup, "cpuacct", "cpuacct.stat")
 311         if err != nil {
 312                 return
 313         }
 314         defer statFile.Close()
 315         b, err := ReadAllOrWarn(statFile)
 316         if err != nil {
 317                 return
 318         }
 319
 320         nextSample := CpuSample{true, time.Now(), 0, 0, GetCpuCount(cgroup)}
 321         var userTicks, sysTicks int64
 322         fmt.Sscanf(string(b), "user %d\nsystem %d", &userTicks, &sysTicks)
 323         user_hz := float64(C.sysconf(C._SC_CLK_TCK))
 324         nextSample.user = float64(userTicks) / user_hz
 325         nextSample.sys = float64(sysTicks) / user_hz
 326
 327         delta := ""
 328         if lastSample.hasData {
 329                 delta = fmt.Sprintf(" -- interval %.4f seconds %.4f user %.4f sys",
 330                         nextSample.sampleTime.Sub(lastSample.sampleTime).Seconds(),
 331                         nextSample.user-lastSample.user,
 332                         nextSample.sys-lastSample.sys)
 333         }
 334         statLog.Printf("cpu %.4f user %.4f sys %d cpus%s\n",
 335                 nextSample.user, nextSample.sys, nextSample.cpus, delta)
 336         *lastSample = nextSample
 337 }
 338
 339 func PollCgroupStats(cgroup Cgroup, poll int64, stop_poll_chan <-chan bool) {
 340         var lastNetSample = map[string]IoSample{}
 341         var lastDiskSample = map[string]IoSample{}
 342         var lastCpuSample = CpuSample{}
 343
 344         poll_chan := make(chan bool, 1)
 345         go func() {
 346                 // Send periodic poll events.
 347                 poll_chan <- true
 348                 for {
 349                         time.Sleep(time.Duration(poll) * time.Millisecond)
 350                         poll_chan <- true
 351                 }
 352         }()
 353         for {
 354                 select {
 355                 case <-stop_poll_chan:
 356                         return
 357                 case <-poll_chan:
 358                         // Emit stats, then select again.
 359                 }
 360                 DoMemoryStats(cgroup)
 361                 DoCpuStats(cgroup, &lastCpuSample)
 362                 DoBlkIoStats(cgroup, lastDiskSample)
 363                 DoNetworkStats(cgroup, lastNetSample)
 364         }
 365 }
 366
 367 func run(logger *log.Logger) error {
 368
 369         var (
 370                 cgroup_root    string
 371                 cgroup_parent  string
 372                 cgroup_cidfile string
 373                 wait           int64
 374                 poll           int64
 375         )
 376
 377         flag.StringVar(&cgroup_root, "cgroup-root", "", "Root of cgroup tree")
 378         flag.StringVar(&cgroup_parent, "cgroup-parent", "", "Name of container parent under cgroup")
 379         flag.StringVar(&cgroup_cidfile, "cgroup-cid", "", "Path to container id file")
 380         flag.Int64Var(&wait, "wait", 5, "Maximum time (in seconds) to wait for cid file to show up")
 381         flag.Int64Var(&poll, "poll", 1000, "Polling frequency, in milliseconds")
 382
 383         flag.Parse()
 384
 385         if cgroup_root == "" {
 386                 statLog.Fatal("error: must provide -cgroup-root")
 387         }
 388
 389         finish_chan := make(chan bool)
 390         defer close(finish_chan)
 391
 392         var cmd *exec.Cmd
 393
 394         if len(flag.Args()) > 0 {
 395                 // Set up subprocess
 396                 cmd = exec.Command(flag.Args()[0], flag.Args()[1:]...)
 397
 398                 childLog.Println("Running", flag.Args())
 399
 400                 // Child process will use our stdin and stdout pipes
 401                 // (we close our copies below)
 402                 cmd.Stdin = os.Stdin
 403                 cmd.Stdout = os.Stdout
 404
 405                 // Forward SIGINT and SIGTERM to inner process
 406                 sigChan := make(chan os.Signal, 1)
 407                 go func(sig <-chan os.Signal) {
 408                         catch := <-sig
 409                         if cmd.Process != nil {
 410                                 cmd.Process.Signal(catch)
 411                         }
 412                         statLog.Println("notice: caught signal:", catch)
 413                 }(sigChan)
 414                 signal.Notify(sigChan, syscall.SIGTERM)
 415                 signal.Notify(sigChan, syscall.SIGINT)
 416
 417                 // Funnel stderr through our channel
 418                 stderr_pipe, err := cmd.StderrPipe()
 419                 if err != nil {
 420                         statLog.Fatalln("error in StderrPipe:", err)
 421                 }
 422                 go CopyPipeToChildLog(stderr_pipe, finish_chan)
 423
 424                 // Run subprocess
 425                 if err := cmd.Start(); err != nil {
 426                         statLog.Fatalln("error in cmd.Start:", err)
 427                 }
 428
 429                 // Close stdin/stdout in this (parent) process
 430                 os.Stdin.Close()
 431                 os.Stdout.Close()
 432         }
 433
 434         // Read the cid file
 435         var container_id string
 436         if cgroup_cidfile != "" {
 437                 // wait up to 'wait' seconds for the cid file to appear
 438                 ok := false
 439                 var i time.Duration
 440                 for i = 0; i < time.Duration(wait)*time.Second; i += (100 * time.Millisecond) {
 441                         cid, err := ioutil.ReadFile(cgroup_cidfile)
 442                         if err == nil && len(cid) > 0 {
 443                                 ok = true
 444                                 container_id = string(cid)
 445                                 break
 446                         }
 447                         time.Sleep(100 * time.Millisecond)
 448                 }
 449                 if !ok {
 450                         statLog.Println("error reading cid file:", cgroup_cidfile)
 451                 }
 452         }
 453
 454         stop_poll_chan := make(chan bool, 1)
 455         cgroup := Cgroup{cgroup_root, cgroup_parent, container_id}
 456         go PollCgroupStats(cgroup, poll, stop_poll_chan)
 457
 458         // When the child exits, tell the polling goroutine to stop.
 459         defer func() { stop_poll_chan <- true }()
 460
 461         // Wait for CopyPipeToChan to consume child's stderr pipe
 462         <-finish_chan
 463
 464         return cmd.Wait()
 465 }
 466
 467 func main() {
 468         logger := log.New(os.Stderr, "crunchstat: ", 0)
 469         if err := run(logger); err != nil {
 470                 if exiterr, ok := err.(*exec.ExitError); ok {
 471                         // The program has exited with an exit code != 0
 472
 473                         // This works on both Unix and
 474                         // Windows. Although package syscall is
 475                         // generally platform dependent, WaitStatus is
 476                         // defined for both Unix and Windows and in
 477                         // both cases has an ExitStatus() method with
 478                         // the same signature.
 479                         if status, ok := exiterr.Sys().(syscall.WaitStatus); ok {
 480                                 os.Exit(status.ExitStatus())
 481                         }
 482                 } else {
 483                         statLog.Fatalln("error in cmd.Wait:", err)
 484                 }
 485         }
 486 }