disable presence logging

state/presence/presence.go

 // The presence package is intended as a replacement for zookeeper ephemeral
 // nodes; the primary difference is that node timeout is unrelated to session
 // timeout, and this allows us to restart a presence-enabled process "silently"
 // (from the perspective of the rest of the system) without dealing with the
 // complication of session re-establishment.
 
 package presence
 
 import (
         "fmt"
@@ skipping 118 matching lines @@
                 // ensure watchers detect the pinger's death as late as possible.
                 if p.tomb.Err() == nil {
                         _, err := p.target.change()
                         p.tomb.Kill(err)
                 }
                 p.tomb.Done()
         }()
         for {
                 select {
                 case <-p.tomb.Dying():
-                        log.Debugf("presence: %s pinger died after %s wait", p.target.path, time.Now().Sub(p.lastPing))
+                        debugf("presence: %s pinger died after %s wait", p.target.path, time.Now().Sub(p.lastPing))
                         return
                 case now := <-p.nextPing():
-                        log.Debugf("presence: %s pinger awakened after %s wait", p.target.path, time.Now().Sub(p.lastPing))
+                        debugf("presence: %s pinger awakened after %s wait", p.target.path, time.Now().Sub(p.lastPing))
                         p.lastPing = now
                         mtime, err := p.target.change()
                         if err != nil {
                                 p.tomb.Kill(err)
                                 return
                         }
-                        log.Debugf("presence: wrote to %s at (zk) %s", p.target.path, mtime)
+                        debugf("presence: wrote to %s at (zk) %s", p.target.path, mtime)
                 }
         }
 }
 
 // nextPing returns a channel that will receive an event when the pinger is next
 // due to fire.
 func (p *Pinger) nextPing() <-chan time.Time {
         next := p.lastPing.Add(p.period)
         wait := next.Sub(time.Now())
         if wait <= 0 {
                 wait = 0
         }
-        log.Debugf("presence: anticipating ping of %s in %s", p.target.path, wait)
+        debugf("presence: anticipating ping of %s in %s", p.target.path, wait)
         return time.After(wait)
 }
 
 // node represents the state of a presence node from a watcher's perspective.
 type node struct {
         conn    *zk.Conn
         path    string
         alive   bool
         timeout time.Duration
 }
@@ skipping 17 matching lines @@
         n.timeout = period * 3
         if firstTime {
                 clock := changeNode{n.conn, "/clock", ""}
                 now, err := clock.change()
                 if err != nil {
                         return err
                 }
                 mtime := stat.MTime()
                 delay := now.Sub(mtime)
                 n.alive = delay < n.timeout
-                log.Debugf(`
+                debugf(`
 presence: initial diagnosis of %s
   now (zk)          %s
   last write (zk)   %s
   apparent delay    %s
   timeout           %s
   alive             %t
 `[1:], n.path, now, mtime, delay, n.timeout, n.alive)
         } else {
                 // If this method is not being run for the first time, we know that
                 // the node has just changed, so we know that it's alive and there's
@@ skipping 323 matching lines @@
                                 continue
                         }
                         select {
                         case <-stop:
                                 return
                         case w.updates <- aliveChange{key, aliveNow}:
                         }
                 }
         }
 }
+
+// Debug, when true, causes detailed presence logs to be generated.
+var Debug = false
+
+// debugf passes its args on to log.Debugf if Debug is true.
+func debugf(format string, args ...interface{}) {
+        if Debug {
+                log.Debugf(format, args...)
+        }
+}