Replace logging calls with new style

common/docker/client.go

@@ -44,7 +44,7 @@ func NewClient(apiPath string) (*Client, error) {
 func (c *Client) AddObserver(ob ContainerObserver) error {
 	events := make(chan *docker.APIEvents)
 	if err := c.AddEventListener(events); err != nil {
-		Error.Printf("[docker] Unable to add listener to Docker API: %s", err)
+		Log.Errorf("[docker] Unable to add listener to Docker API: %s", err)
 		return err
 	}
 
@@ -63,7 +63,7 @@ func (c *Client) AddObserver(ob ContainerObserver) error {
 // IsContainerNotRunning returns true if we have checked with Docker that the ID is not running
 func (c *Client) IsContainerNotRunning(idStr string) bool {
 	if !IsContainerID(idStr) {
-		Debug.Printf("[docker] '%s' does not seem to be a container id", idStr)
+		Log.Debugf("[docker] '%s' does not seem to be a container id", idStr)
 		return false
 	}
 
@@ -75,6 +75,6 @@ func (c *Client) IsContainerNotRunning(idStr string) bool {
 	if _, notThere := err.(*docker.NoSuchContainer); notThere {
 		return true
 	}
-	Error.Printf("[docker] Could not check container status: %s", err)
+	Log.Errorf("[docker] Could not check container status: %s", err)
 	return false
 }

common/errors.go

@@ -2,13 +2,13 @@ package common
 
 func CheckFatal(e error) {
 	if e != nil {
-		Error.Fatal(e)
+		Log.Fatal(e)
 	}
 }
 
 func CheckWarn(e error) {
 	if e != nil {
-		Warning.Println(e)
+		Log.Warningln(e)
 	}
 }
 

common/logging.go

@@ -35,11 +35,9 @@ var (
 )
 
 var (
-	Debug   *logrus.Logger
-	Info    *logrus.Logger
-	Warning *logrus.Logger
-	Error   *logrus.Logger
-	debugF  bool
+	Log    *logrus.Logger
+	Info   *logrus.Logger
+	debugF bool
 )
 
 func InitLogging(debugHandle io.Writer,
@@ -47,30 +45,13 @@ func InitLogging(debugHandle io.Writer,
 	warningHandle io.Writer,
 	errorHandle io.Writer) {
 
-	Debug = &logrus.Logger{
-		Out:       debugHandle,
-		Formatter: standardTextFormatter,
-		Hooks:     make(logrus.LevelHooks),
-		Level:     logrus.DebugLevel,
-	}
 	Info = &logrus.Logger{
 		Out:       infoHandle,
 		Formatter: standardTextFormatter,
 		Hooks:     make(logrus.LevelHooks),
 		Level:     logrus.InfoLevel,
 	}
-	Warning = &logrus.Logger{
-		Out:       warningHandle,
-		Formatter: standardTextFormatter,
-		Hooks:     make(logrus.LevelHooks),
-		Level:     logrus.WarnLevel,
-	}
-	Error = &logrus.Logger{
-		Out:       errorHandle,
-		Formatter: standardTextFormatter,
-		Hooks:     make(logrus.LevelHooks),
-		Level:     logrus.ErrorLevel,
-	}
+	Log = Info
 }
 
 func InitDefaultLogging(debug bool) {

common/sched_queue.go

@@ -76,7 +76,7 @@ func NewSchedQueue(clock clock.Clock) *SchedQueue {
 // Start starts the scheduled queue
 func (cq *SchedQueue) Start() {
 	go func() {
-		defer func() { Debug.Printf("[sched-q] Quitting (%d calls pending)", len(cq.callablesH)) }()
+		defer func() { Log.Debugf("[sched-q] Quitting (%d calls pending)", len(cq.callablesH)) }()
 
 		var now time.Time
 		timer := cq.clock.Timer(time.Duration(math.MaxInt64))
@@ -116,14 +116,14 @@ func (cq *SchedQueue) Start() {
 
 // Stop stops the scheduled queue
 func (cq *SchedQueue) Stop() {
-	Debug.Printf("[sched-q] Stopping...")
+	Log.Debugf("[sched-q] Stopping...")
 	cq.closeChan <- true
 }
 
 // Add schedules a call.
 // The callable should not modify the scheduled queue in any way.
 func (cq *SchedQueue) Add(c callable, t time.Time) {
-	Debug.Printf("[sched-q] Adding call at %s", t)
+	Log.Debugf("[sched-q] Adding call at %s", t)
 	ce := schedCall{c: c, t: t}
 	cq.schedChan <- &ce
 }

ipam/allocator.go

@@ -718,11 +718,11 @@ func (alloc *Allocator) findOwner(addr address.Address) string {
 // Logging
 
 func (alloc *Allocator) infof(fmt string, args ...interface{}) {
-	common.Info.Printf("[allocator %s] "+fmt, append([]interface{}{alloc.ourName}, args...)...)
+	common.Log.Infof("[allocator %s] "+fmt, append([]interface{}{alloc.ourName}, args...)...)
 }
 func (alloc *Allocator) debugln(args ...interface{}) {
-	common.Debug.Println(append([]interface{}{fmt.Sprintf("[allocator %s]:", alloc.ourName)}, args...)...)
+	common.Log.Debugln(append([]interface{}{fmt.Sprintf("[allocator %s]:", alloc.ourName)}, args...)...)
 }
 func (alloc *Allocator) debugf(fmt string, args ...interface{}) {
-	common.Debug.Printf("[allocator %s] "+fmt, append([]interface{}{alloc.ourName}, args...)...)
+	common.Log.Debugf("[allocator %s] "+fmt, append([]interface{}{alloc.ourName}, args...)...)
 }

ipam/allocator_test.go

@@ -186,9 +186,9 @@ func TestCancel(t *testing.T) {
 
 	// Get some IPs, so each allocator has some space
 	res1, _ := alloc1.Allocate("foo", subnet, nil)
-	common.Debug.Printf("res1 = %s", res1.String())
+	common.Log.Debugf("res1 = %s", res1.String())
 	res2, _ := alloc2.Allocate("bar", subnet, nil)
-	common.Debug.Printf("res2 = %s", res2.String())
+	common.Log.Debugf("res2 = %s", res2.String())
 	if res1 == res2 {
 		require.FailNow(t, "Error: got same ips!")
 	}

ipam/http.go

@@ -13,7 +13,7 @@ import (
 
 func badRequest(w http.ResponseWriter, err error) {
 	http.Error(w, err.Error(), http.StatusBadRequest)
-	common.Warning.Println("[allocator]:", err.Error())
+	common.Log.Warningln("[allocator]:", err.Error())
 }
 
 // HandleHTTP wires up ipams HTTP endpoints to the provided mux.

ipam/http_test.go

@@ -48,13 +48,13 @@ func listenHTTP(alloc *Allocator, subnet address.CIDR) int {
 
 	httpListener, err := net.Listen("tcp", ":0")
 	if err != nil {
-		common.Error.Fatal("Unable to create http listener: ", err)
+		common.Log.Fatal("Unable to create http listener: ", err)
 	}
 
 	go func() {
 		srv := &http.Server{Handler: router}
 		if err := srv.Serve(httpListener); err != nil {
-			common.Error.Fatal("Unable to serve http: ", err)
+			common.Log.Fatal("Unable to serve http: ", err)
 		}
 	}()
 	return httpListener.Addr().(*net.TCPAddr).Port

ipam/ring/ring.go

@@ -217,7 +217,7 @@ func (r *Ring) Merge(gossip Ring) error {
 			switch {
 			case mine.Version >= theirs.Version:
 				if mine.Version == theirs.Version && !mine.Equal(theirs) {
-					common.Debug.Printf("Error merging entries at %s - %v != %v\n", mine.Token, mine, theirs)
+					common.Log.Debugf("Error merging entries at %s - %v != %v\n", mine.Token, mine, theirs)
 					return ErrInvalidEntry
 				}
 				addToResult(*mine)

ipam/ring/ring_test.go

@@ -608,7 +608,7 @@ func TestFuzzRingHard(t *testing.T) {
 
 	addPeer := func() {
 		peer, _ := router.PeerNameFromString(fmt.Sprintf("%02d:%02d:00:00:00:00", nextPeerID/10, nextPeerID%10))
-		common.Debug.Printf("%s: Adding peer", peer)
+		common.Log.Debugf("%s: Adding peer", peer)
 		nextPeerID++
 		peers = append(peers, peer)
 		rings = append(rings, New(start, end, peer))
@@ -658,7 +658,7 @@ func TestFuzzRingHard(t *testing.T) {
 			require.NoError(t, otherRing.Merge(*ring))
 		}
 
-		common.Debug.Printf("%s: transferring from peer %s", otherPeername, peername)
+		common.Log.Debugf("%s: transferring from peer %s", otherPeername, peername)
 		otherRing.Transfer(peername, peername)
 
 		// And now tell everyone about the transfer - rmpeer is
@@ -687,12 +687,12 @@ func TestFuzzRingHard(t *testing.T) {
 			size := address.Subtract(rangeToSplit.End, rangeToSplit.Start)
 			ipInRange := address.Add(rangeToSplit.Start, address.Offset(rand.Intn(int(size))))
 			_, peerToGiveTo, _ := randomPeer(-1)
-			common.Debug.Printf("%s: Granting [%v, %v) to %s", ring.Peer, ipInRange, rangeToSplit.End, peerToGiveTo)
+			common.Log.Debugf("%s: Granting [%v, %v) to %s", ring.Peer, ipInRange, rangeToSplit.End, peerToGiveTo)
 			ring.GrantRangeToHost(ipInRange, rangeToSplit.End, peerToGiveTo)
 
 			// Now 'gossip' this to a random host (note, note could be same host as above)
 			otherIndex, _, otherRing := randomPeer(-1)
-			common.Debug.Printf("%s: 'Gossiping' to %s", ring.Peer, otherRing.Peer)
+			common.Log.Debugf("%s: 'Gossiping' to %s", ring.Peer, otherRing.Peer)
 			require.NoError(t, otherRing.Merge(*ring))
 
 			theRanges[indexWithRanges] = ring.OwnedRanges()
@@ -711,7 +711,7 @@ func TestFuzzRingHard(t *testing.T) {
 		}
 		ring1 := ringsWithEntries[rand.Intn(len(ringsWithEntries))]
 		ring2index, _, ring2 := randomPeer(-1)
-		common.Debug.Printf("%s: 'Gossiping' to %s", ring1.Peer, ring2.Peer)
+		common.Log.Debugf("%s: 'Gossiping' to %s", ring1.Peer, ring2.Peer)
 		require.NoError(t, ring2.Merge(*ring1))
 		theRanges[ring2index] = ring2.OwnedRanges()
 	}

ipam/testutils_test.go

@@ -295,7 +295,7 @@ func (client TestGossipRouterClient) GossipUnicast(dstPeerName router.PeerName,
 	select {
 	case client.router.gossipChans[dstPeerName] <- unicastMessage{sender: client.sender, buf: buf}:
 	default: // drop the message if we cannot send it
-		common.Error.Printf("Dropping message")
+		common.Log.Errorf("Dropping message")
 	}
 	return nil
 }

nameserver/cache.go

@@ -86,7 +86,7 @@ func (e *cacheEntry) getReply(request *dns.Msg, maxLen int, now time.Time) (*dns
 	}
 
 	if e.ReplyLen >= maxLen {
-		Debug.Printf("[cache msgid %d] returning truncated reponse: %d > %d", request.MsgHdr.Id, e.ReplyLen, maxLen)
+		Log.Debugf("[cache msgid %d] returning truncated reponse: %d > %d", request.MsgHdr.Id, e.ReplyLen, maxLen)
 		return makeTruncatedReply(request), nil
 	}
 
@@ -122,7 +122,7 @@ func (e *cacheEntry) setReply(reply *dns.Msg, ttl int, flags uint8, now time.Tim
 	var prevValidUntil time.Time
 	if e.Status == stResolved {
 		if reply != nil {
-			Debug.Printf("[cache msgid %d] replacing response in cache", reply.MsgHdr.Id)
+			Log.Debugf("[cache msgid %d] replacing response in cache", reply.MsgHdr.Id)
 		}
 		prevValidUntil = e.validUntil
 	}
@@ -147,7 +147,7 @@ func (e *cacheEntry) setReply(reply *dns.Msg, ttl int, flags uint8, now time.Tim
 		}
 		e.validUntil = now.Add(time.Second * time.Duration(minTTL))
 	} else {
-		Warning.Printf("[cache] no valid TTL could be calculated")
+		Log.Warningf("[cache] no valid TTL could be calculated")
 	}
 
 	e.Status = stResolved
@@ -323,7 +323,7 @@ func (c *Cache) Get(request *dns.Msg, maxLen int) (reply *dns.Msg, err error) {
 	if ent, found := c.entries[key]; found {
 		reply, err = ent.getReply(request, maxLen, now)
 		if ent.hasExpired(now) {
-			Debug.Printf("[cache msgid %d] expired: removing", request.MsgHdr.Id)
+			Log.Debugf("[cache msgid %d] expired: removing", request.MsgHdr.Id)
 			if ent.index > 0 {
 				heap.Remove(&c.entriesH, ent.index)
 			}
@@ -332,7 +332,7 @@ func (c *Cache) Get(request *dns.Msg, maxLen int) (reply *dns.Msg, err error) {
 		}
 	} else {
 		// we are the first asking for this name: create an entry with no reply... the caller must wait
-		Debug.Printf("[cache msgid %d] addind in pending state", request.MsgHdr.Id)
+		Log.Debugf("[cache msgid %d] addind in pending state", request.MsgHdr.Id)
 		c.entries[key] = newCacheEntry(&question, now)
 	}
 	return
@@ -345,7 +345,7 @@ func (c *Cache) Remove(question *dns.Question) {
 
 	key := cacheKey(*question)
 	if entry, found := c.entries[key]; found {
-		Debug.Printf("[cache] removing %s-response for '%s'", dns.TypeToString[question.Qtype], question.Name)
+		Log.Debugf("[cache] removing %s-response for '%s'", dns.TypeToString[question.Qtype], question.Name)
 		if entry.index > 0 {
 			heap.Remove(&c.entriesH, entry.index)
 		}

nameserver/http.go

@@ -5,17 +5,16 @@ import (
 	"net"
 	"net/http"
 
-	log "github.com/Sirupsen/logrus"
 	"github.com/gorilla/mux"
 	"github.com/miekg/dns"
 	. "github.com/weaveworks/weave/common"
 	"github.com/weaveworks/weave/common/docker"
 )
 
-func httpErrorAndLog(level *log.Logger, w http.ResponseWriter, msg string,
+func httpErrorAndLog(w http.ResponseWriter, msg string,
 	status int, logmsg string, logargs ...interface{}) {
 	http.Error(w, msg, status)
-	level.Printf("[http] "+logmsg, logargs...)
+	Log.Warningf("[http] "+logmsg, logargs...)
 }
 
 func extractFQDN(r *http.Request) (string, string) {
@@ -41,7 +40,7 @@ func ServeHTTP(listener net.Listener, version string, server *DNSServer, dockerC
 
 	muxRouter.Methods("PUT").Path("/name/{id:.+}/{ip:.+}").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		reqError := func(msg string, logmsg string, logargs ...interface{}) {
-			httpErrorAndLog(Warning, w, msg, http.StatusBadRequest, logmsg, logargs...)
+			httpErrorAndLog(w, msg, http.StatusBadRequest, logmsg, logargs...)
 		}
 
 		vars := mux.Vars(r)
@@ -69,7 +68,7 @@ func ServeHTTP(listener net.Listener, version string, server *DNSServer, dockerC
 		if err := server.Zone.AddRecord(idStr, name, ip); err != nil {
 			if _, ok := err.(DuplicateError); !ok {
 				httpErrorAndLog(
-					Error, w, "Internal error", http.StatusInternalServerError,
+					w, "Internal error", http.StatusInternalServerError,
 					"Unexpected error from DB: %s", err)
 				return
 			} // oh, I already know this. whatever.
@@ -89,7 +88,7 @@ func ServeHTTP(listener net.Listener, version string, server *DNSServer, dockerC
 		ip := net.ParseIP(ipStr)
 		if ip == nil {
 			httpErrorAndLog(
-				Warning, w, "Invalid IP in request", http.StatusBadRequest,
+				w, "Invalid IP in request", http.StatusBadRequest,
 				"Invalid IP in request: %s", ipStr)
 			return
 		}
@@ -120,6 +119,6 @@ func ServeHTTP(listener net.Listener, version string, server *DNSServer, dockerC
 	http.Handle("/", muxRouter)
 
 	if err := http.Serve(listener, nil); err != nil {
-		Error.Fatal("[http] Unable to serve http: ", err)
+		Log.Fatal("[http] Unable to serve http: ", err)
 	}
 }

nameserver/mdns_lookup.go

@@ -12,10 +12,10 @@ func mdnsLookup(client *MDNSClient, name string, qtype uint16, insistent bool) (
 
 	for resp := range channel {
 		if err := resp.err; err != nil {
-			Debug.Printf("[mdns] Error for query type %s name %s: %s", dns.TypeToString[qtype], name, err)
+			Log.Debugf("[mdns] Error for query type %s name %s: %s", dns.TypeToString[qtype], name, err)
 			return nil, err
 		}
-		Debug.Printf("[mdns] Got response name for %s-query about name '%s': name '%s', addr '%s'",
+		Log.Debugf("[mdns] Got response name for %s-query about name '%s': name '%s', addr '%s'",
 			dns.TypeToString[qtype], name, resp.name, resp.addr)
 
 		if !insistent {

nameserver/mdns_server.go

@@ -113,7 +113,7 @@ func (s *MDNSServer) makeHandler(qtype uint16, lookup LookupFunc) dns.HandlerFun
 		// answer.
 		remoteAddr := rw.RemoteAddr()
 		if s.addrIsLocal(remoteAddr) && !s.allowLocal {
-			Debug.Printf("[mdns] srv: mDNS query from local host ('%s'): ignored", remoteAddr)
+			Log.Debugf("[mdns] srv: mDNS query from local host ('%s'): ignored", remoteAddr)
 			return
 		}
 
@@ -121,16 +121,16 @@ func (s *MDNSServer) makeHandler(qtype uint16, lookup LookupFunc) dns.HandlerFun
 		if len(r.Answer) == 0 && len(r.Question) > 0 {
 			q := &r.Question[0]
 			if q.Qtype == qtype {
-				Debug.Printf("[mdns msgid %d] srv: trying to answer to mDNS query '%s'", r.MsgHdr.Id, q.Name)
+				Log.Debugf("[mdns msgid %d] srv: trying to answer to mDNS query '%s'", r.MsgHdr.Id, q.Name)
 				if m := lookup(s.zone, r, q); m != nil {
-					Debug.Printf("[mdns msgid %d] srv: found local answer to mDNS query '%s'", r.MsgHdr.Id, q.Name)
+					Log.Debugf("[mdns msgid %d] srv: found local answer to mDNS query '%s'", r.MsgHdr.Id, q.Name)
 					if err := s.sendResponse(m); err != nil {
-						Warning.Printf("[mdns msgid %d] srv: error writing mDNS response to %v", r.MsgHdr.Id, s.sendconn)
+						Log.Warningf("[mdns msgid %d] srv: error writing mDNS response to %v", r.MsgHdr.Id, s.sendconn)
 					} else {
-						Debug.Printf("[mdns msgid %d] srv: response sent: %d answers", r.MsgHdr.Id, len(m.Answer))
+						Log.Debugf("[mdns msgid %d] srv: response sent: %d answers", r.MsgHdr.Id, len(m.Answer))
 					}
 				} else {
-					Debug.Printf("[mdns msgid %d] srv: no local answer for answering mDNS query '%s'",
+					Log.Debugf("[mdns msgid %d] srv: no local answer for answering mDNS query '%s'",
 						r.MsgHdr.Id, q.Name)
 				}
 			}

nameserver/mdns_server_test.go

@@ -59,11 +59,11 @@ func TestServerSimpleQuery(t *testing.T) {
 		require.NoError(t, err)
 		conn, err := net.ListenUDP("udp4", &net.UDPAddr{IP: net.IPv4zero, Port: 0})
 		require.NoError(t, err)
-		Debug.Printf("Sending UDP packet to %s", ipv4Addr)
+		Log.Debugf("Sending UDP packet to %s", ipv4Addr)
 		_, err = conn.WriteTo(buf, ipv4Addr)
 		require.NoError(t, err)
 
-		Debug.Printf("Waiting for response")
+		Log.Debugf("Waiting for response")
 		for {
 			select {
 			case x := <-recvChan:
@@ -80,7 +80,7 @@ func TestServerSimpleQuery(t *testing.T) {
 					return
 				}
 			case <-time.After(100 * time.Millisecond):
-				Debug.Printf("Timeout while waiting for response")
+				Log.Debugf("Timeout while waiting for response")
 				return
 			}
 		}
@@ -96,7 +96,7 @@ func TestServerSimpleQuery(t *testing.T) {
 
 	time.Sleep(100 * time.Millisecond) // Allow for server to get going
 
-	Debug.Printf("Checking that we get 2 IPs fo name '%s' [A]", testRecord1.Name())
+	Log.Debugf("Checking that we get 2 IPs fo name '%s' [A]", testRecord1.Name())
 	sendQuery(testRecord1.Name(), dns.TypeA)
 	if receivedCount != 2 {
 		t.Fatalf("Unexpected result count %d for %s", receivedCount, testRecord1.Name())
@@ -108,13 +108,13 @@ func TestServerSimpleQuery(t *testing.T) {
 		t.Fatalf("Unexpected result %s for %s", receivedAddrs, testRecord1.Name())
 	}
 
-	Debug.Printf("Checking that 'testfail.weave.' [A] gets no answers")
+	Log.Debugf("Checking that 'testfail.weave.' [A] gets no answers")
 	sendQuery("testfail.weave.", dns.TypeA)
 	if receivedCount != 0 {
 		t.Fatalf("Unexpected result count %d for testfail.weave", receivedCount)
 	}
 
-	Debug.Printf("Checking that '%s' [PTR] gets one name", testInAddr1)
+	Log.Debugf("Checking that '%s' [PTR] gets one name", testInAddr1)
 	sendQuery(testInAddr1, dns.TypePTR)
 	if receivedCount != 1 {
 		t.Fatalf("Expected an answer to %s, got %d answers", testInAddr1, receivedCount)

nameserver/mdns_test.go

@@ -37,7 +37,7 @@ func TestClientServerSimpleQuery(t *testing.T) {
 		receivedAddr = nil
 		receivedName = ""
 		receivedCount = 0
-		Debug.Printf("Sending query...")
+		Log.Debugf("Sending query...")
 		switch querytype {
 		case dns.TypeA:
 			r, err := mdnsCli.LookupName(name)
@@ -60,7 +60,7 @@ func TestClientServerSimpleQuery(t *testing.T) {
 
 	time.Sleep(100 * time.Millisecond) // Allow for server to get going
 
-	Debug.Printf("Query: %s dns.TypeA", testRecord1.Name())
+	Log.Debugf("Query: %s dns.TypeA", testRecord1.Name())
 	sendQuery(testRecord1.Name(), dns.TypeA)
 	if receivedCount != 1 {
 		t.Fatalf("Unexpected result count %d for %s", receivedCount, testRecord1.Name())
@@ -69,13 +69,13 @@ func TestClientServerSimpleQuery(t *testing.T) {
 		t.Fatalf("Unexpected result %s for %s", receivedAddr, testRecord1.Name())
 	}
 
-	Debug.Printf("Query: testfail.weave. dns.TypeA")
+	Log.Debugf("Query: testfail.weave. dns.TypeA")
 	sendQuery("testfail.weave.", dns.TypeA)
 	if receivedCount != 0 {
 		t.Fatalf("Unexpected result count %d for testfail.weave", receivedCount)
 	}
 
-	Debug.Printf("Query: %s dns.TypePTR", testInAddr1)
+	Log.Debugf("Query: %s dns.TypePTR", testInAddr1)
 	sendQuery(testInAddr1, dns.TypePTR)
 	if receivedCount != 1 {
 		t.Fatalf("Expected an answer to %s, got %d answers", testInAddr1, receivedCount)
@@ -127,7 +127,7 @@ func TestClientServerInsistentQuery(t *testing.T) {
 		receivedAddrs = nil
 		receivedNames = nil
 		receivedCount = 0
-		Debug.Printf("Sending query...")
+		Log.Debugf("Sending query...")
 		switch querytype {
 		case dns.TypeA:
 			receivedAddrs, err = mdnsCli.InsistentLookupName(name)
@@ -144,25 +144,25 @@ func TestClientServerInsistentQuery(t *testing.T) {
 
 	time.Sleep(100 * time.Millisecond) // Allow for server to get going
 
-	Debug.Printf("Query: %s dns.TypeA", testRecord1.Name())
+	Log.Debugf("Query: %s dns.TypeA", testRecord1.Name())
 	sendQuery(testRecord1.Name(), dns.TypeA)
 	if receivedCount != 2 {
 		t.Fatalf("Unexpected result count %d for %s", receivedCount, testRecord1.Name())
 	}
 
-	Debug.Printf("Query: testfail.weave. dns.TypeA")
+	Log.Debugf("Query: testfail.weave. dns.TypeA")
 	sendQuery("testfail.weave.", dns.TypeA)
 	if receivedCount != 0 {
 		t.Fatalf("Unexpected result count %d for testfail.weave", receivedCount)
 	}
 
-	Debug.Printf("Query: %s dns.TypePTR", testInAddr1)
+	Log.Debugf("Query: %s dns.TypePTR", testInAddr1)
 	sendQuery(testInAddr1, dns.TypePTR)
 	if receivedCount != 1 {
 		t.Fatalf("Expected an answer to %s, got %d answers", testInAddr1, receivedCount)
 	}
 
-	Debug.Printf("Query: %s dns.TypePTR", testInAddr2)
+	Log.Debugf("Query: %s dns.TypePTR", testInAddr2)
 	sendQuery(testInAddr2, dns.TypePTR)
 	if receivedCount != 1 {
 		t.Fatalf("Expected an answer to %s, got %d answers", testInAddr2, receivedCount)

nameserver/mocks_test.go

@@ -19,7 +19,7 @@ const (
 )
 
 // Warn about some methods that some day should be implemented...
-func notImplWarn() { Warning.Printf("Mocked method. Not implemented.") }
+func notImplWarn() { Log.Warningf("Mocked method. Not implemented.") }
 
 // A mocked Zone that always returns the same records
 // * it does not send/receive any mDNS query
@@ -38,7 +38,7 @@ func newMockedZoneWithRecords(zr []ZoneRecord) *mockedZoneWithRecords {
 }
 func (mz *mockedZoneWithRecords) Domain() string { return DefaultLocalDomain }
 func (mz *mockedZoneWithRecords) LookupName(name string) ([]ZoneRecord, error) {
-	Debug.Printf("[mocked zone]: LookupName: returning records %s", mz.records)
+	Log.Debugf("[mocked zone]: LookupName: returning records %s", mz.records)
 	mz.Lock()
 	defer mz.Unlock()
 
@@ -53,7 +53,7 @@ func (mz *mockedZoneWithRecords) LookupName(name string) ([]ZoneRecord, error) {
 }
 
 func (mz *mockedZoneWithRecords) LookupInaddr(inaddr string) ([]ZoneRecord, error) {
-	Debug.Printf("[mocked zone]: LookupInaddr: returning records %s", mz.records)
+	Log.Debugf("[mocked zone]: LookupInaddr: returning records %s", mz.records)
 	mz.Lock()
 	defer mz.Unlock()
 
@@ -243,17 +243,17 @@ func newZoneDbsWithMockedMDns(num int, config ZoneConfig) zoneDbsWithMockedMDns
 	for i := 0; i < num; i++ {
 		res[i] = new(zbmEntry)
 
-		Debug.Printf("[test] Creating mocked mDNS server #%d", i)
+		Log.Debugf("[test] Creating mocked mDNS server #%d", i)
 		res[i].Server = newMockedMDNSServer(nil)
 
-		Debug.Printf("[test] Creating mocked mDNS client #%d", i)
+		Log.Debugf("[test] Creating mocked mDNS client #%d", i)
 		res[i].Client = newMockedMDNSClient([]*mockedMDNSServer{})
 
 		cfg := config
 		cfg.MDNSClient = res[i].Client
 		cfg.MDNSServer = res[i].Server
 
-		Debug.Printf("[test] Creating ZoneDb #%d", i)
+		Log.Debugf("[test] Creating ZoneDb #%d", i)
 		res[i].Zone, _ = NewZoneDb(cfg)
 
 		// link the mDNS server to its zone
@@ -270,7 +270,7 @@ func newZoneDbsWithMockedMDns(num int, config ZoneConfig) zoneDbsWithMockedMDns
 			// this is not what we currently do, but can be convenient in some cases
 			// for finding some bugs...
 			if i != j {
-				Debug.Printf("[test] Linking mocked mDNS client #%d to server #%d", i, j)
+				Log.Debugf("[test] Linking mocked mDNS client #%d to server #%d", i, j)
 				res[i].Client.AddServer(res[j].Server)
 			}
 		}
@@ -389,7 +389,7 @@ func (mf *mockedFallback) Stop() error {
 
 // Run a UDP fallback server
 func runLocalUDPServer(laddr string, handler dns.HandlerFunc) (*dns.Server, string, error) {
-	Debug.Printf("[mocked fallback] Starting fallback UDP server at %s", laddr)
+	Log.Debugf("[mocked fallback] Starting fallback UDP server at %s", laddr)
 	pc, err := net.ListenPacket("udp", laddr)
 	if err != nil {
 		return nil, "", err
@@ -401,13 +401,13 @@ func runLocalUDPServer(laddr string, handler dns.HandlerFunc) (*dns.Server, stri
 		pc.Close()
 	}()
 
-	Debug.Printf("[mocked fallback] Fallback UDP server listening at %s", pc.LocalAddr())
+	Log.Debugf("[mocked fallback] Fallback UDP server listening at %s", pc.LocalAddr())
 	return server, pc.LocalAddr().String(), nil
 }
 
 // Run a TCP fallback server
 func runLocalTCPServer(laddr string, handler dns.HandlerFunc) (*dns.Server, string, error) {
-	Debug.Printf("[mocked fallback] Starting fallback TCP server at %s", laddr)
+	Log.Debugf("[mocked fallback] Starting fallback TCP server at %s", laddr)
 	laddrTCP, err := net.ResolveTCPAddr("tcp", laddr)
 	if err != nil {
 		return nil, "", err
@@ -424,7 +424,7 @@ func runLocalTCPServer(laddr string, handler dns.HandlerFunc) (*dns.Server, stri
 		l.Close()
 	}()
 
-	Debug.Printf("[mocked fallback] Fallback TCP server listening at %s", l.Addr().String())
+	Log.Debugf("[mocked fallback] Fallback TCP server listening at %s", l.Addr().String())
 	return server, l.Addr().String(), nil
 }
 
@@ -442,9 +442,9 @@ func newMockedClock() *mockedClock {
 //       be waiting in channels. So your code should not depend on the channels
 //       for creating new timers. Otherwise, time travelling will not be reliable...
 func (clk *mockedClock) Forward(secs int) {
-	Debug.Printf(">>>>>>> Moving clock forward %d seconds - Time traveling >>>>>>>", secs)
+	Log.Debugf(">>>>>>> Moving clock forward %d seconds - Time traveling >>>>>>>", secs)
 	clk.Add(time.Duration(secs) * time.Second)
-	Debug.Printf("<<<<<<< Time travel finished! We are at %s <<<<<<<", clk.Now())
+	Log.Debugf("<<<<<<< Time travel finished! We are at %s <<<<<<<", clk.Now())
 }
 
 //////////////////////////////////////////////////////////////////

nameserver/server.go

@@ -74,7 +74,7 @@ func (proto dnsProtocol) String() string {
 
 // get a new dns.Client for a protocol
 func (proto dnsProtocol) GetNewClient(bufsize int, timeout time.Duration) *dns.Client {
-	Debug.Printf("[dns] Creating %s DNS client with %s timeout", proto, timeout)
+	Log.Debugf("[dns] Creating %s DNS client with %s timeout", proto, timeout)
 	switch proto {
 	case protTCP:
 		return &dns.Client{Net: "tcp", ReadTimeout: timeout}
@@ -228,7 +228,7 @@ func (s *DNSServer) ActivateAndServe() {
 		Info.Printf("[dns] Listening for DNS on %s (UDP)", s.ListenAddr)
 		err := s.udpSrv.ActivateAndServe()
 		CheckFatal(err)
-		Debug.Printf("[dns] DNS UDP server exiting...")
+		Log.Debugf("[dns] DNS UDP server exiting...")
 	}()
 
 	go func() {
@@ -237,7 +237,7 @@ func (s *DNSServer) ActivateAndServe() {
 		Info.Printf("[dns] Listening for DNS on %s (TCP)", s.ListenAddr)
 		err := s.tcpSrv.ActivateAndServe()
 		CheckFatal(err)
-		Debug.Printf("[dns] DNS TCP server exiting...")
+		Log.Debugf("[dns] DNS TCP server exiting...")
 	}()
 
 	// Waiting for all goroutines to finish (otherwise they die as main routine dies)
@@ -305,7 +305,7 @@ func (s *DNSServer) localHandler(proto dnsProtocol, kind string, qtype uint16,
 
 	return func(w dns.ResponseWriter, r *dns.Msg) {
 		q := r.Question[0]
-		Debug.Printf("[dns msgid %d] %s: %+v", r.MsgHdr.Id, kind, q)
+		Log.Debugf("[dns msgid %d] %s: %+v", r.MsgHdr.Id, kind, q)
 		maxLen := getMaxReplyLen(r, proto)
 
 		// cache a response if the cache is enabled, and observe the name/IP
@@ -324,17 +324,17 @@ func (s *DNSServer) localHandler(proto dnsProtocol, kind string, qtype uint16,
 			reply, err := s.cache.Get(r, maxLen)
 			if err != nil {
 				if err == errNoLocalReplies {
-					Debug.Printf("[dns msgid %d] Cached no-local-replies", r.MsgHdr.Id)
+					Log.Debugf("[dns msgid %d] Cached no-local-replies", r.MsgHdr.Id)
 					fallback(w, r)
 				} else {
-					Debug.Printf("[dns msgid %d] Error from cache: %s", r.MsgHdr.Id, err)
+					Log.Debugf("[dns msgid %d] Error from cache: %s", r.MsgHdr.Id, err)
 					w.WriteMsg(makeDNSFailResponse(r))
 				}
 				return
 			}
 			if reply != nil {
 				reply.Answer = pruneAnswers(shuffleAnswers(reply.Answer), s.maxAnswers)
-				Debug.Printf("[dns msgid %d] Returning reply from cache: %s/%d answers",
+				Log.Debugf("[dns msgid %d] Returning reply from cache: %s/%d answers",
 					r.MsgHdr.Id, dns.RcodeToString[reply.MsgHdr.Rcode], len(reply.Answer))
 				w.WriteMsg(reply)
 				return
@@ -343,7 +343,7 @@ func (s *DNSServer) localHandler(proto dnsProtocol, kind string, qtype uint16,
 
 		// catch unsupported queries
 		if q.Qtype != qtype {
-			Debug.Printf("[dns msgid %d] Unsupported query type %s", r.MsgHdr.Id, dns.TypeToString[q.Qtype])
+			Log.Debugf("[dns msgid %d] Unsupported query type %s", r.MsgHdr.Id, dns.TypeToString[q.Qtype])
 			m := makeDNSFailResponse(r)
 			maybeCache(m, s.negLocalTTL, 0)
 			w.WriteMsg(m)
@@ -360,7 +360,7 @@ func (s *DNSServer) localHandler(proto dnsProtocol, kind string, qtype uint16,
 			m.Authoritative = true
 			maybeCache(m, nullTTL, 0)
 			m.Answer = pruneAnswers(shuffleAnswers(m.Answer), s.maxAnswers)
-			Debug.Printf("[dns msgid %d] Sending response: %s/%d answers [code:%s]",
+			Log.Debugf("[dns msgid %d] Sending response: %s/%d answers [code:%s]",
 				m.MsgHdr.Id, dns.TypeToString[q.Qtype], len(m.Answer), dns.RcodeToString[m.Rcode])
 			w.WriteMsg(m)
 		}
@@ -380,25 +380,25 @@ func (s *DNSServer) notUsHandler(proto dnsProtocol) dns.HandlerFunc {
 		rcopy := r
 		rcopy.SetEdns0(uint16(maxLen), false)
 
-		Debug.Printf("[dns msgid %d] Fallback query: %+v [%s, max:%d bytes]", rcopy.MsgHdr.Id, q, proto, maxLen)
+		Log.Debugf("[dns msgid %d] Fallback query: %+v [%s, max:%d bytes]", rcopy.MsgHdr.Id, q, proto, maxLen)
 		for _, server := range s.Upstream.Servers {
 			reply, _, err := dnsClient.Exchange(rcopy, fmt.Sprintf("%s:%s", server, s.Upstream.Port))
 			if err != nil {
-				Debug.Printf("[dns msgid %d] Network error trying %s (%s)",
+				Log.Debugf("[dns msgid %d] Network error trying %s (%s)",
 					r.MsgHdr.Id, server, err)
 				continue
 			}
 			if reply != nil && reply.Rcode != dns.RcodeSuccess {
-				Debug.Printf("[dns msgid %d] Failure reported by %s for query %s",
+				Log.Debugf("[dns msgid %d] Failure reported by %s for query %s",
 					r.MsgHdr.Id, server, q.Name)
 				continue
 			}
-			Debug.Printf("[dns msgid %d] Given answer by %s for query %s",
+			Log.Debugf("[dns msgid %d] Given answer by %s for query %s",
 				r.MsgHdr.Id, server, q.Name)
 			w.WriteMsg(reply)
 			return
 		}
-		Warning.Printf("[dns msgid %d] Failed lookup for external name %s", r.MsgHdr.Id, q.Name)
+		Log.Warningf("[dns msgid %d] Failed lookup for external name %s", r.MsgHdr.Id, q.Name)
 		w.WriteMsg(makeDNSFailResponse(r))
 	}
 }

nameserver/server_cache_test.go

@@ -24,11 +24,11 @@ func TestServerDbCacheInvalidation(t *testing.T) {
 
 	clk := newMockedClock()
 
-	Debug.Printf("Creating mocked mDNS client and server")
+	Log.Debugf("Creating mocked mDNS client and server")
 	mdnsServer1 := newMockedMDNSServerWithRecord(Record{testName1, net.ParseIP("10.2.2.9"), 0, 0, 0})
 	mdnsCli1 := newMockedMDNSClient([]*mockedMDNSServer{mdnsServer1})
 
-	Debug.Printf("Creating zone database with the mocked mDNS client and server")
+	Log.Debugf("Creating zone database with the mocked mDNS client and server")
 	zoneConfig := ZoneConfig{
 		MDNSServer: mdnsServer1,
 		MDNSClient: mdnsCli1,
@@ -40,7 +40,7 @@ func TestServerDbCacheInvalidation(t *testing.T) {
 	require.NoError(t, err)
 	defer zone.Stop()
 
-	Debug.Printf("Creating a cache")
+	Log.Debugf("Creating a cache")
 	cache, err := NewCache(1024, clk)
 	require.NoError(t, err)
 
@@ -59,7 +59,7 @@ func TestServerDbCacheInvalidation(t *testing.T) {
 	fallback.Start()
 	defer fallback.Stop()
 
-	Debug.Printf("Creating a real DNS server with a mocked cache")
+	Log.Debugf("Creating a real DNS server with a mocked cache")
 	srv, err := NewDNSServer(DNSServerConfig{
 		Zone:              zone,
 		Cache:             cache,
@@ -79,7 +79,7 @@ func TestServerDbCacheInvalidation(t *testing.T) {
 	require.NoError(t, err)
 	require.NotEqual(t, 0, testPort, "invalid listen port")
 
-	Debug.Printf("Adding two IPs to %s", testName1)
+	Log.Debugf("Adding two IPs to %s", testName1)
 	zone.AddRecord(containerID, testName1, net.ParseIP("10.2.2.1"))
 	zone.AddRecord(containerID, testName1, net.ParseIP("10.2.2.2"))
 	q, _ := assertExchange(t, testName1, dns.TypeA, testPort, 2, 2, 0)
@@ -93,7 +93,7 @@ func TestServerDbCacheInvalidation(t *testing.T) {
 
 	// we should have an entry in the cache for this query
 	// if we add another IP, that cache entry should be removed
-	Debug.Printf("Adding a new IP to %s: the cache entry should be removed", testName1)
+	Log.Debugf("Adding a new IP to %s: the cache entry should be removed", testName1)
 	zone.AddRecord(containerID, testName1, net.ParseIP("10.2.2.3"))
 	assertNotInCache(t, cache, q, fmt.Sprintf("after adding a new IP for %s", testName1))
 
@@ -101,10 +101,10 @@ func TestServerDbCacheInvalidation(t *testing.T) {
 	//   first.weave.local  = 10.2.2.1 10.2.2.2 10.2.2.3
 	//   second.weave.local = 10.9.9.1
 
-	Debug.Printf("Querying again (so a cache entry will be created)")
+	Log.Debugf("Querying again (so a cache entry will be created)")
 	q, _ = assertExchange(t, testName1, dns.TypeA, testPort, 3, 4, 0)
 	assertInCache(t, cache, q, "after asking about the name")
-	Debug.Printf("... and removing one of the IP addresses")
+	Log.Debugf("... and removing one of the IP addresses")
 	zone.DeleteRecords(containerID, "", net.ParseIP("10.2.2.2"))
 	assertNotInCache(t, cache, q, "after deleting IP for 10.2.2.2")
 
@@ -113,7 +113,7 @@ func TestServerDbCacheInvalidation(t *testing.T) {
 	//   second.weave.local = 10.9.9.1
 
 	// generate cache responses
-	Debug.Printf("Querying for a raddr")
+	Log.Debugf("Querying for a raddr")
 	qname, _ := assertExchange(t, testName1, dns.TypeA, testPort, 2, 2, 0)
 	qptr, _ := assertExchange(t, "1.2.2.10.in-addr.arpa.", dns.TypePTR, testPort, 1, 1, 0)
 	qotherName, _ := assertExchange(t, testName2, dns.TypeA, testPort, 1, 1, 0)
@@ -126,7 +126,7 @@ func TestServerDbCacheInvalidation(t *testing.T) {
 	assertNotLocalInCache(t, cache, qwrongName, "after asking for a wrong name")
 
 	// now we will check if a removal affects all the responses
-	Debug.Printf("... and removing an IP should invalidate both the cached responses for name and raddr")
+	Log.Debugf("... and removing an IP should invalidate both the cached responses for name and raddr")
 	zone.DeleteRecords(containerID, "", net.ParseIP("10.2.2.1"))
 	assertNotInCache(t, cache, qptr, "after deleting record")
 	assertNotInCache(t, cache, qname, "after deleting record")
@@ -137,7 +137,7 @@ func TestServerDbCacheInvalidation(t *testing.T) {
 	//   second.weave.local = 10.9.9.1
 
 	// generate cache responses
-	Debug.Printf("Querying for a raddr")
+	Log.Debugf("Querying for a raddr")
 	qptr, _ = assertExchange(t, "3.2.2.10.in-addr.arpa.", dns.TypePTR, testPort, 1, 1, 0)
 	qname, _ = assertExchange(t, testName1, dns.TypeA, testPort, 1, 1, 0)
 	qotherName, _ = assertExchange(t, testName2, dns.TypeA, testPort, 1, 1, 0)
@@ -148,7 +148,7 @@ func TestServerDbCacheInvalidation(t *testing.T) {
 	assertInCache(t, cache, qotherPtr, "after asking for second address")
 
 	// let's repeat this, but adding an IP
-	Debug.Printf("... and adding a new IP should invalidate both the cached responses for the name")
+	Log.Debugf("... and adding a new IP should invalidate both the cached responses for the name")
 	zone.AddRecord(containerID, testName1, net.ParseIP("10.2.2.7"))
 	assertNotInCache(t, cache, qname, "after adding a new IP")
 	assertInCache(t, cache, qotherName, "after adding a new IP")
@@ -182,7 +182,7 @@ func TestServerCacheExpiration(t *testing.T) {
 
 	clk := newMockedClock()
 
-	Debug.Printf("Creating 2 zone databases")
+	Log.Debugf("Creating 2 zone databases")
 	zoneConfig := ZoneConfig{
 		RefreshInterval: 0, // no name updates
 		Clock:           clk,
@@ -191,11 +191,11 @@ func TestServerCacheExpiration(t *testing.T) {
 	dbs.Start()
 	defer dbs.Stop()
 
-	Debug.Printf("Creating a cache")
+	Log.Debugf("Creating a cache")
 	cache, err := NewCache(1024, clk)
 	require.NoError(t, err)
 
-	Debug.Printf("Creating a real DNS server for the first zone database and with the cache")
+	Log.Debugf("Creating a real DNS server for the first zone database and with the cache")
 	srv, err := NewDNSServer(DNSServerConfig{
 		Zone:              dbs[0].Zone,
 		Cache:             cache,
@@ -225,7 +225,7 @@ func TestServerCacheExpiration(t *testing.T) {
 	assertNotInCache(t, cache, qName1, fmt.Sprintf("after asking for %s", testName1))
 
 	// We add the IP in the second peer right after
-	Debug.Printf("Adding an IPs to %s in database #2", testName1)
+	Log.Debugf("Adding an IPs to %s in database #2", testName1)
 	dbs[1].Zone.AddRecord(containerID, testName1, net.ParseIP("10.2.2.1"))
 	t.Logf("Zone database #2:\n%s", dbs[1].Zone)
 
@@ -241,7 +241,7 @@ func TestServerCacheExpiration(t *testing.T) {
 	assertNotInCache(t, cache, qName1, fmt.Sprintf("after asking for %s", testName1))
 
 	// We delete the IP in the second peer right after
-	Debug.Printf("Removing the IPs from %s in database #2", testName1)
+	Log.Debugf("Removing the IPs from %s in database #2", testName1)
 	dbs[1].Zone.DeleteRecords(containerID, "", net.ParseIP("10.2.2.1"))
 
 	// Check that we return to the initial state: a neg-local entry in the cache
@@ -269,7 +269,7 @@ func TestServerCacheRefresh(t *testing.T) {
 	Info.Println("TestServerCacheRefresh starting")
 	clk := newMockedClock()
 
-	Debug.Printf("Creating 2 zone databases")
+	Log.Debugf("Creating 2 zone databases")
 	zoneConfig := ZoneConfig{
 		RefreshInterval: refreshInterval,
 		Clock:           clk,
@@ -278,11 +278,11 @@ func TestServerCacheRefresh(t *testing.T) {
 	dbs.Start()
 	defer dbs.Stop()
 
-	Debug.Printf("Creating a cache")
+	Log.Debugf("Creating a cache")
 	cache, err := NewCache(1024, clk)
 	require.NoError(t, err)
 
-	Debug.Printf("Creating a real DNS server for the first zone database and with the cache")
+	Log.Debugf("Creating a real DNS server for the first zone database and with the cache")
 	srv, err := NewDNSServer(DNSServerConfig{
 		Zone:              dbs[0].Zone,
 		Cache:             cache,
@@ -301,7 +301,7 @@ func TestServerCacheRefresh(t *testing.T) {
 	require.NoError(t, err)
 	require.NotEqual(t, 0, testPort, "listen port")
 
-	Debug.Printf("Adding an IPs to %s", testName1)
+	Log.Debugf("Adding an IPs to %s", testName1)
 	dbs[1].Zone.AddRecord(containerID, testName1, net.ParseIP("10.2.2.1"))
 	dbs.Flush() // ensure the immediate refresh is done
 
@@ -317,7 +317,7 @@ func TestServerCacheRefresh(t *testing.T) {
 	clk.Forward(refreshInterval / 2)
 	dbs.Flush()
 
-	Debug.Printf("Adding an IP to %s and to %s", testName1, testName2)
+	Log.Debugf("Adding an IP to %s and to %s", testName1, testName2)
 	dbs[1].Zone.AddRecord(containerID, testName1, net.ParseIP("10.2.2.2"))
 	dbs[1].Zone.AddRecord(containerID, testName2, net.ParseIP("10.9.9.2"))
 

nameserver/zone.go

@@ -111,7 +111,7 @@ func (re *recordEntry) addIPObserver(zro ZoneRecordObserver) {
 func (re *recordEntry) notifyIPObservers() {
 	numObservers := len(re.observers)
 	if numObservers > 0 {
-		Debug.Printf("[zonedb] Notifying %d observers of '%s'", numObservers, re.ip)
+		Log.Debugf("[zonedb] Notifying %d observers of '%s'", numObservers, re.ip)
 		for _, observer := range re.observers {
 			observer()
 		}
@@ -257,7 +257,7 @@ func (n *name) addNameObserver(observer ZoneRecordObserver) {
 func (n *name) notifyNameObservers() {
 	numObservers := len(n.observers)
 	if numObservers > 0 {
-		Debug.Printf("[zonedb] Notifying %d observers of '%s'", numObservers, n.name)
+		Log.Debugf("[zonedb] Notifying %d observers of '%s'", numObservers, n.name)
 		for _, observer := range n.observers {
 			observer()
 		}
@@ -373,7 +373,7 @@ func (ns *nameSet) getNameLastAccess(n string) time.Time {
 // The access time is saved only for locally-introduced records (otherwise it could
 // be lost when names are irrelevant...)
 func (ns *nameSet) touchName(name string, now time.Time) {
-	Debug.Printf("[zonedb] Touching name %s", name)
+	Log.Debugf("[zonedb] Touching name %s", name)
 	n := ns.getName(name, false)
 	if n != nil {
 		n.lastAccessTime = now
@@ -527,11 +527,11 @@ func (zone *ZoneDb) Start() (err error) {
 // Perform a graceful shutdown of the zone database
 func (zone *ZoneDb) Stop() error {
 	if zone.refreshInterval > 0 {
-		Debug.Printf("[zonedb] Closing background updaters...")
+		Log.Debugf("[zonedb] Closing background updaters...")
 		zone.refreshScheds.Stop()
 	}
 
-	Debug.Printf("[zonedb] Exiting mDNS client and server...")
+	Log.Debugf("[zonedb] Exiting mDNS client and server...")
 	zone.mdnsCli.Stop()
 	zone.mdnsSrv.Stop()
 	return nil
@@ -555,7 +555,7 @@ func (zone *ZoneDb) Status() string {
 func (zone *ZoneDb) AddRecord(ident string, name string, ip net.IP) (err error) {
 	zone.mx.Lock()
 	defer zone.mx.Unlock()
-	Debug.Printf("[zonedb] Adding record: '%s'/'%s'[%s]", ident, name, ip)
+	Log.Debugf("[zonedb] Adding record: '%s'/'%s'[%s]", ident, name, ip)
 	record := Record{dns.Fqdn(name), ip, 0, 0, 0}
 	_, err = zone.getNameSet(ident).addIPToName(record, zone.clock.Now())
 	return

nameserver/zone_lookup.go

@@ -63,7 +63,7 @@ func (zone *ZoneDb) LookupName(name string) (res []ZoneRecord, err error) {
 
 	// note: LookupName() is usually called from the mDNS server, so we do not touch the name
 	name = dns.Fqdn(name)
-	Debug.Printf("[zonedb] Looking for name '%s' in local database", name)
+	Log.Debugf("[zonedb] Looking for name '%s' in local database", name)
 	return zone.lookup(name, func(ns *nameSet) []*recordEntry { return ns.getEntriesForName(name) })
 }
 
@@ -78,23 +78,23 @@ func (zone *ZoneDb) LookupInaddr(inaddr string) (res []ZoneRecord, err error) {
 	if err != nil {
 		return nil, newParseError("lookup address", inaddr)
 	}
-	Debug.Printf("[zonedb] Looking for address in local database: '%s' (%s)", revIPv4, inaddr)
+	Log.Debugf("[zonedb] Looking for address in local database: '%s' (%s)", revIPv4, inaddr)
 	return zone.lookup(inaddr, func(ns *nameSet) []*recordEntry { return ns.getEntriesForIP(revIPv4) })
 }
 
 // Perform a domain lookup with mDNS
 func (zone *ZoneDb) domainLookup(target string, lfun ZoneLookupFunc) (res []ZoneRecord, err error) {
 	// no local results have been obtained in the local database: try with a mDNS query
-	Debug.Printf("[zonedb] '%s' not in local database... trying with mDNS", target)
+	Log.Debugf("[zonedb] '%s' not in local database... trying with mDNS", target)
 	lanswers, err := lfun(target)
 	if err != nil {
-		Debug.Printf("[zonedb] mDNS lookup error for '%s': %s", target, err)
+		Log.Debugf("[zonedb] mDNS lookup error for '%s': %s", target, err)
 		return nil, err
 	}
 
 	// if the request has been successful, save the IP in the local database and return the corresponding ZoneRecord
 	// (we do not get the remote ident in the mDNS reply, so we save it in a "remote" ident)
-	Debug.Printf("[zonedb] adding '%s' (obtained with mDNS) to '%s'", lanswers, target)
+	Log.Debugf("[zonedb] adding '%s' (obtained with mDNS) to '%s'", lanswers, target)
 	res = make([]ZoneRecord, len(lanswers))
 	zone.mx.Lock()
 	now := zone.clock.Now()
@@ -104,7 +104,7 @@ func (zone *ZoneDb) domainLookup(target string, lfun ZoneLookupFunc) (res []Zone
 		r, err := remoteIdent.addIPToName(answer, now)
 		if err != nil {
 			zone.mx.Unlock()
-			Warning.Printf("[zonedb] '%s' insertion for %s failed: %s", answer, target, err)
+			Log.Warningf("[zonedb] '%s' insertion for %s failed: %s", answer, target, err)
 			return nil, err
 		}
 		uniq.add(r)
@@ -118,7 +118,7 @@ func (zone *ZoneDb) domainLookup(target string, lfun ZoneLookupFunc) (res []Zone
 // The name can be resolved locally with the local database or with some other resolution method (eg, a mDNS query)
 func (zone *ZoneDb) DomainLookupName(name string) (res []ZoneRecord, err error) {
 	name = dns.Fqdn(name)
-	Debug.Printf("[zonedb] Looking for name '%s' in local(&remote) database", name)
+	Log.Debugf("[zonedb] Looking for name '%s' in local(&remote) database", name)
 
 	zone.mx.Lock()
 	now := zone.clock.Now()
@@ -128,7 +128,7 @@ func (zone *ZoneDb) DomainLookupName(name string) (res []ZoneRecord, err error)
 			// filter the entries with expired TTL
 			// locally introduced entries are never expired: they always have TTL=0
 			if ze.hasExpired(now) {
-				Debug.Printf("[zonedb] '%s': expired entry '%s' ignored: removing", name, ze)
+				Log.Debugf("[zonedb] '%s': expired entry '%s' ignored: removing", name, ze)
 				nameset.deleteNameIP(name, net.IP{})
 			} else {
 				uniq.add(ze)
@@ -141,7 +141,7 @@ func (zone *ZoneDb) DomainLookupName(name string) (res []ZoneRecord, err error)
 	zone.mx.Unlock()
 
 	if len(uniq) > 0 {
-		Debug.Printf("[zonedb] '%s' resolved in local database", name)
+		Log.Debugf("[zonedb] '%s' resolved in local database", name)
 		res = uniq.toSlice()
 	} else {
 		res, err = zone.domainLookup(name, zone.mdnsCli.LookupName)
@@ -163,7 +163,7 @@ func (zone *ZoneDb) DomainLookupInaddr(inaddr string) (res []ZoneRecord, err err
 		return nil, newParseError("lookup address", inaddr)
 	}
 
-	Debug.Printf("[zonedb] Looking for address in local(&remote) database: '%s' (%s)", revIPv4, inaddr)
+	Log.Debugf("[zonedb] Looking for address in local(&remote) database: '%s' (%s)", revIPv4, inaddr)
 
 	zone.mx.Lock()
 	now := zone.clock.Now()
@@ -173,7 +173,7 @@ func (zone *ZoneDb) DomainLookupInaddr(inaddr string) (res []ZoneRecord, err err
 			// filter the entries with expired TTL
 			// locally introduced entries are never expired: they always have TTL=0
 			if ze.hasExpired(now) {
-				Debug.Printf("[zonedb] '%s': expired entry '%s' ignored: removing", revIPv4, ze)
+				Log.Debugf("[zonedb] '%s': expired entry '%s' ignored: removing", revIPv4, ze)
 				nameset.deleteNameIP("", revIPv4.toNetIP())
 			} else {
 				uniq.add(ze)
@@ -186,7 +186,7 @@ func (zone *ZoneDb) DomainLookupInaddr(inaddr string) (res []ZoneRecord, err err
 	zone.mx.Unlock()
 
 	if len(uniq) > 0 {
-		Debug.Printf("[zonedb] '%s' resolved in local database", inaddr)
+		Log.Debugf("[zonedb] '%s' resolved in local database", inaddr)
 		res = uniq.toSlice()
 	} else {
 		res, err = zone.domainLookup(inaddr, zone.mdnsCli.LookupInaddr)
@@ -243,7 +243,7 @@ func (zone *ZoneDb) startUpdatingName(name string) {
 			n.lastRefreshTime = now
 			zone.mx.Unlock()
 
-			Debug.Printf("[zonedb] Creating new immediate refresh request for '%s'", name)
+			Log.Debugf("[zonedb] Creating new immediate refresh request for '%s'", name)
 			zone.refreshScheds.Add(func() time.Time { return zone.updater(name) }, now)
 		} else {
 			zone.mx.Unlock()
@@ -261,7 +261,7 @@ func (zone *ZoneDb) updater(name string) (nextTime time.Time) {
 
 	// if nobody has asked for this name for long time, just forget about it...
 	if !zone.IsNameRelevant(name) || zone.IsNameExpired(name) {
-		Debug.Printf("[zonedb] '%s' seem to be irrelevant now: removing any remote information", name)
+		Log.Debugf("[zonedb] '%s' seem to be irrelevant now: removing any remote information", name)
 		deleteRemoteInfo()
 		return
 	}
@@ -269,7 +269,7 @@ func (zone *ZoneDb) updater(name string) (nextTime time.Time) {
 	// perform the refresh for this name
 	fullName := dns.Fqdn(name)
 	startTime := zone.clock.Now()
-	Debug.Printf("[zonedb] Refreshing name '%s' with mDNS...", fullName)
+	Log.Debugf("[zonedb] Refreshing name '%s' with mDNS...", fullName)
 	res, _ := zone.mdnsCli.InsistentLookupName(fullName)
 	if res != nil && len(res) > 0 {
 		numIps := len(res)
@@ -277,14 +277,14 @@ func (zone *ZoneDb) updater(name string) (nextTime time.Time) {
 		now := zone.clock.Now()
 		added, removed := zone.getNameSet(defaultRemoteIdent).getName(name, true).updateIPs(res, now)
 		zone.mx.Unlock()
-		Debug.Printf("[zonedb] Obtained %d IPs for name '%s' with mDNS: %d added, %d removed",
+		Log.Debugf("[zonedb] Obtained %d IPs for name '%s' with mDNS: %d added, %d removed",
 			numIps, name, added, removed)
 
 		// once the name has been updated, we re-schedule the update
 		nextTime = startTime.Add(zone.refreshInterval)
-		Debug.Printf("[zonedb] Rescheduling update for '%s' in %s", name, nextTime.Sub(zone.clock.Now()))
+		Log.Debugf("[zonedb] Rescheduling update for '%s' in %s", name, nextTime.Sub(zone.clock.Now()))
 	} else {
-		Debug.Printf("[zonedb] nobody knows about '%s'... removing", name)
+		Log.Debugf("[zonedb] nobody knows about '%s'... removing", name)
 		deleteRemoteInfo()
 	}
 	return

nameserver/zone_lookup_test.go

@@ -40,77 +40,77 @@ func TestZoneRefresh(t *testing.T) {
 
 	time.Sleep(100 * time.Millisecond) // allow for server to get going
 
-	Debug.Printf("Adding '%s' to Db #1", name)
+	Log.Debugf("Adding '%s' to Db #1", name)
 	dbs[0].Zone.AddRecord("someident", name, net.ParseIP(addr1))
 
-	Debug.Printf("Checking that the name %s is relevant (as it has been locally inserted) and not remote", name)
+	Log.Debugf("Checking that the name %s is relevant (as it has been locally inserted) and not remote", name)
 	require.True(t, dbs[0].Zone.IsNameRelevant(name), "name relevant")
 	require.True(t, dbs[0].Zone.HasNameLocalInfo(name), "local name info")
 	require.False(t, dbs[0].Zone.HasNameRemoteInfo(name), "remote name info")
 
-	Debug.Printf("Asking for '%s' to Db #1: should get 1 IP from the local database...", name)
+	Log.Debugf("Asking for '%s' to Db #1: should get 1 IP from the local database...", name)
 	res, err := dbs[0].Zone.DomainLookupName(name)
 	require.NoError(t, err)
-	Debug.Printf("Got: %s", res)
+	Log.Debugf("Got: %s", res)
 	t.Logf("Db #1 after the lookup:\n%s", dbs[0].Zone)
 	require.Equal(t, 1, len(res), "lookup result")
 
 	clk.Forward(refreshInterval / 2)
 	dbs.Flush()
-	Debug.Printf("A couple of seconds later, we should still have one IP for that name")
+	Log.Debugf("A couple of seconds later, we should still have one IP for that name")
 	res, err = dbs[0].Zone.DomainLookupName(name)
 	require.NoError(t, err)
 	require.Equal(t, 1, len(res), "lookup result")
 
-	Debug.Printf("And then we add 2 IPs for that name at ZoneDb 2")
+	Log.Debugf("And then we add 2 IPs for that name at ZoneDb 2")
 	clk.Forward(1)
 	dbs.Flush()
-	Debug.Printf("Adding 2 IPs to '%s' in Db #2", name)
+	Log.Debugf("Adding 2 IPs to '%s' in Db #2", name)
 	dbs[1].Zone.AddRecord("someident", name, net.ParseIP(addr2))
 	dbs[1].Zone.AddRecord("someident", name, net.ParseIP(addr3))
 
-	Debug.Printf("Perform a lookup, to ensure the name will be updated in the background...")
+	Log.Debugf("Perform a lookup, to ensure the name will be updated in the background...")
 	dbs[0].Zone.DomainLookupName(name)
 
-	Debug.Printf("Wait for a while, until a refresh is performed...")
+	Log.Debugf("Wait for a while, until a refresh is performed...")
 	clk.Forward(refreshInterval + 1)
 	dbs.Flush()
-	Debug.Printf("A refresh should have been scheduled now: we should have 3 IPs:")
-	Debug.Printf("the first (local) IP and the others obtained from zone2 with a mDNS query")
-	Debug.Printf("Asking for '%s' again... we should have 3 IPs now", name)
+	Log.Debugf("A refresh should have been scheduled now: we should have 3 IPs:")
+	Log.Debugf("the first (local) IP and the others obtained from zone2 with a mDNS query")
+	Log.Debugf("Asking for '%s' again... we should have 3 IPs now", name)
 	res, err = dbs[0].Zone.DomainLookupName(name)
-	Debug.Printf("Got: %s", res)
+	Log.Debugf("Got: %s", res)
 	t.Logf("Db #1 after the second lookup:\n%s", dbs[0].Zone)
 	require.Equal(t, 3, len(res), "lookup result length")
 
-	Debug.Printf("We will not ask for `name` for a while, so it will become irrelevant and will be removed...")
+	Log.Debugf("We will not ask for `name` for a while, so it will become irrelevant and will be removed...")
 	clk.Forward(refreshInterval + relevantTime + 1)
 	dbs.Flush()
 
 	// the name should be irrelevant now, and all remote info should have been
 	// removed from the zone database
-	Debug.Printf("Name '%s' should not be in the remote database in ZoneDb 1", name)
+	Log.Debugf("Name '%s' should not be in the remote database in ZoneDb 1", name)
 	require.False(t, dbs[0].Zone.IsNameRelevant(name), "name still relevant after some inactivity time")
 	require.True(t, dbs[0].Zone.HasNameLocalInfo(name), "local name info")
 	require.False(t, dbs[0].Zone.HasNameRemoteInfo(name), "remote name info")
 
-	Debug.Printf("There is no remote info about this name at zone 1: a new IP appears remotely meanwhile...")
+	Log.Debugf("There is no remote info about this name at zone 1: a new IP appears remotely meanwhile...")
 	clk.Forward(1)
 	dbs.Flush()
 
-	Debug.Printf("Adding '%s' to Db #2", name)
+	Log.Debugf("Adding '%s' to Db #2", name)
 	dbs[1].Zone.AddRecord("someident", name, net.ParseIP(addr4))
 
-	Debug.Printf("When we ask about this name again, we get 4 IPs (1 local, 3 remote)")
-	Debug.Printf("Asking for '%s' again... the first lookup will return only the local results", name)
+	Log.Debugf("When we ask about this name again, we get 4 IPs (1 local, 3 remote)")
+	Log.Debugf("Asking for '%s' again... the first lookup will return only the local results", name)
 	res, err = dbs[0].Zone.DomainLookupName(name)
 	require.Equal(t, 1, len(res), "lookup result length")
-	Debug.Printf("... but a second lookup should return all the results in the network")
+	Log.Debugf("... but a second lookup should return all the results in the network")
 
 	clk.Forward(refreshInterval + 1)
 	dbs.Flush()
 
 	res, err = dbs[0].Zone.DomainLookupName(name)
-	Debug.Printf("Got: %s", res)
+	Log.Debugf("Got: %s", res)
 	require.Equal(t, 4, len(res), "lookup result length")
 }

prog/weavedns/main.go

@@ -79,7 +79,7 @@ func main() {
 		Info.Println("[main] Waiting for mDNS interface", ifaceName, "to come up")
 		iface, err = weavenet.EnsureInterface(ifaceName, wait)
 		if err != nil {
-			Error.Fatal(err)
+			Log.Fatal(err)
 		} else {
 			Info.Println("[main] Interface", ifaceName, "is up")
 		}
@@ -92,22 +92,22 @@ func main() {
 		Info.Println("[main] Waiting for HTTP interface", httpIfaceName, "to come up")
 		httpIface, err := weavenet.EnsureInterface(httpIfaceName, wait)
 		if err != nil {
-			Error.Fatal(err)
+			Log.Fatal(err)
 		}
 		Info.Println("[main] Interface", httpIfaceName, "is up")
 
 		addrs, err := httpIface.Addrs()
 		if err != nil {
-			Error.Fatal(err)
+			Log.Fatal(err)
 		}
 
 		if len(addrs) == 0 {
-			Error.Fatal("[main] No addresses on HTTP interface")
+			Log.Fatal("[main] No addresses on HTTP interface")
 		}
 
 		ip, _, err := net.ParseCIDR(addrs[0].String())
 		if err != nil {
-			Error.Fatal(err)
+			Log.Fatal(err)
 		}
 
 		httpIP = ip.String()
@@ -124,22 +124,22 @@ func main() {
 	}
 	zone, err := weavedns.NewZoneDb(zoneConfig)
 	if err != nil {
-		Error.Fatal("[main] Unable to initialize the Zone database", err)
+		Log.Fatal("[main] Unable to initialize the Zone database", err)
 	}
 	if err := zone.Start(); err != nil {
-		Error.Fatal("[main] Unable to start the Zone database", err)
+		Log.Fatal("[main] Unable to start the Zone database", err)
 	}
 	defer zone.Stop()
 
 	dockerCli, err = docker.NewClient(apiPath)
 	if err != nil {
-		Error.Fatal("[main] Unable to start docker client: ", err)
+		Log.Fatal("[main] Unable to start docker client: ", err)
 	}
 
 	if watch {
 		err := dockerCli.AddObserver(zone)
 		if err != nil {
-			Error.Fatal("[main] Unable to start watcher", err)
+			Log.Fatal("[main] Unable to start watcher", err)
 		}
 	}
 
@@ -158,20 +158,20 @@ func main() {
 	if len(fallback) > 0 {
 		fallbackHost, fallbackPort, err := net.SplitHostPort(fallback)
 		if err != nil {
-			Error.Fatal("[main] Could not parse fallback host and port", err)
+			Log.Fatal("[main] Could not parse fallback host and port", err)
 		}
 		srvConfig.UpstreamCfg = &dns.ClientConfig{Servers: []string{fallbackHost}, Port: fallbackPort}
-		Debug.Printf("[main] DNS fallback at %s:%s", fallbackHost, fallbackPort)
+		Log.Debugf("[main] DNS fallback at %s:%s", fallbackHost, fallbackPort)
 	}
 
 	srv, err := weavedns.NewDNSServer(srvConfig)
 	if err != nil {
-		Error.Fatal("[main] Failed to initialize the WeaveDNS server", err)
+		Log.Fatal("[main] Failed to initialize the WeaveDNS server", err)
 	}
 
 	httpListener, err := net.Listen("tcp", httpAddr)
 	if err != nil {
-		Error.Fatal("[main] Unable to create http listener: ", err)
+		Log.Fatal("[main] Unable to create http listener: ", err)
 	}
 	Info.Println("[main] HTTP API listening on", httpAddr)
 
@@ -180,7 +180,7 @@ func main() {
 
 	err = srv.Start()
 	if err != nil {
-		Error.Fatal("[main] Failed to start the WeaveDNS server: ", err)
+		Log.Fatal("[main] Failed to start the WeaveDNS server: ", err)
 	}
 	srv.ActivateAndServe()
 }

prog/weaveproxy/main.go

@@ -43,7 +43,7 @@ func main() {
 	}
 
 	if c.WithDNS && c.WithoutDNS {
-		Error.Fatalf("Cannot use both '--with-dns' and '--without-dns' flags")
+		Log.Fatalf("Cannot use both '--with-dns' and '--without-dns' flags")
 	}
 
 	if debug {
@@ -55,7 +55,7 @@ func main() {
 
 	p, err := proxy.NewProxy(c)
 	if err != nil {
-		Error.Fatalf("Could not start proxy: %s", err)
+		Log.Fatalf("Could not start proxy: %s", err)
 	}
 
 	p.ListenAndServe()

prog/weaver/main.go

@@ -4,7 +4,6 @@ import (
 	"crypto/sha256"
 	"flag"
 	"fmt"
-	"log"
 	"net"
 	"net/http"
 	"os"
@@ -24,10 +23,6 @@ import (
 var version = "(unreleased version)"
 
 func main() {
-
-	log.SetPrefix(weave.Protocol + " ")
-	log.SetFlags(log.Ldate | log.Ltime | log.Lmicroseconds)
-
 	procs := runtime.NumCPU()
 	// packet sniffing can block an OS thread, so we need one thread
 	// for that plus at least one more.
@@ -84,33 +79,33 @@ func main() {
 		os.Exit(0)
 	}
 
-	log.Println("Command line options:", options())
-	log.Println("Command line peers:", peers)
+	Log.Println("Command line options:", options())
+	Log.Println("Command line peers:", peers)
 
 	var err error
 
 	if ifaceName != "" {
 		config.Iface, err = weavenet.EnsureInterface(ifaceName, wait)
 		if err != nil {
-			log.Fatal(err)
+			Log.Fatal(err)
 		}
 	}
 
 	if routerName == "" {
 		if config.Iface == nil {
-			log.Fatal("Either an interface must be specified with -iface or a name with -name")
+			Log.Fatal("Either an interface must be specified with -iface or a name with -name")
 		}
 		routerName = config.Iface.HardwareAddr.String()
 	}
 	name, err := weave.PeerNameFromUserInput(routerName)
 	if err != nil {
-		log.Fatal(err)
+		Log.Fatal(err)
 	}
 
 	if nickName == "" {
 		nickName, err = os.Hostname()
 		if err != nil {
-			log.Fatal(err)
+			Log.Fatal(err)
 		}
 	}
 
@@ -118,10 +113,10 @@ func main() {
 		password = os.Getenv("WEAVE_PASSWORD")
 	}
 	if password == "" {
-		log.Println("Communication between peers is unencrypted.")
+		Log.Println("Communication between peers is unencrypted.")
 	} else {
 		config.Password = []byte(password)
-		log.Println("Communication between peers is encrypted.")
+		Log.Println("Communication between peers is encrypted.")
 	}
 
 	if prof != "" {
@@ -136,7 +131,7 @@ func main() {
 	config.PeerDiscovery = !noDiscovery
 
 	router := weave.NewRouter(config, name, nickName)
-	log.Println("Our name is", router.Ourself)
+	Log.Println("Our name is", router.Ourself)
 
 	var allocator *ipam.Allocator
 	var defaultSubnet address.CIDR
@@ -145,18 +140,18 @@ func main() {
 		allocator, defaultSubnet = createAllocator(router, iprangeCIDR, ipsubnetCIDR, determineQuorum(peerCount, peers))
 		dockerCli, err = docker.NewClient(apiPath)
 		if err != nil {
-			Error.Fatal("Unable to start docker client: ", err)
+			Log.Fatal("Unable to start docker client: ", err)
 		}
 		if err = dockerCli.AddObserver(allocator); err != nil {
-			Error.Fatal("Unable to start watcher", err)
+			Log.Fatal("Unable to start watcher", err)
 		}
 	} else if peerCount > 0 {
-		log.Fatal("-initpeercount flag specified without -iprange")
+		Log.Fatal("-initpeercount flag specified without -iprange")
 	}
 
 	router.Start()
 	if errors := router.ConnectionMaker.InitiateConnections(peers, false); len(errors) > 0 {
-		log.Fatal(errorMessages(errors))
+		Log.Fatal(errorMessages(errors))
 	}
 
 	// The weave script always waits for a status call to succeed,
@@ -205,17 +200,17 @@ func logFrameFunc(debug bool) weave.LogFrameFunc {
 			}
 		}
 
-		log.Println(parts...)
+		Log.Println(parts...)
 	}
 }
 
 func parseAndCheckCIDR(cidrStr string) address.CIDR {
 	_, cidr, err := address.ParseCIDR(cidrStr)
 	if err != nil {
-		log.Fatal(err)
+		Log.Fatal(err)
 	}
 	if cidr.Size() < ipam.MinSubnetSize {
-		log.Fatalf("Allocation range smaller than minimum size %d: %s", ipam.MinSubnetSize, cidrStr)
+		Log.Fatalf("Allocation range smaller than minimum size %d: %s", ipam.MinSubnetSize, cidrStr)
 	}
 	return cidr
 }
@@ -226,7 +221,7 @@ func createAllocator(router *weave.Router, ipRangeStr string, defaultSubnetStr s
 	if defaultSubnetStr != "" {
 		defaultSubnet = parseAndCheckCIDR(defaultSubnetStr)
 		if !ipRange.Range().Overlaps(defaultSubnet.Range()) {
-			log.Fatalf("Default subnet %s out of bounds: %s", defaultSubnet, ipRange)
+			Log.Fatalf("Default subnet %s out of bounds: %s", defaultSubnet, ipRange)
 		}
 	}
 	allocator := ipam.NewAllocator(router.Ourself.Peer.Name, router.Ourself.Peer.UID, router.Ourself.Peer.NickName, ipRange.Range(), quorum)
@@ -253,7 +248,7 @@ func determineQuorum(initPeerCountFlag int, peers []string) uint {
 	// specify it explicitly if that becomes a problem.
 	clusterSize := uint(len(peers) + 1)
 	quorum := clusterSize/2 + 1
-	log.Println("Assuming quorum size of", quorum)
+	Log.Println("Assuming quorum size of", quorum)
 	return quorum
 }
 
@@ -303,11 +298,11 @@ func handleHTTP(router *weave.Router, httpAddr string, allocator *ipam.Allocator
 	}
 	l, err := net.Listen(protocol, httpAddr)
 	if err != nil {
-		log.Fatal("Unable to create http listener socket: ", err)
+		Log.Fatal("Unable to create http listener socket: ", err)
 	}
 
 	err = http.Serve(l, nil)
 	if err != nil {
-		log.Fatal("Unable to create http server", err)
+		Log.Fatal("Unable to create http server", err)
 	}
 }

proxy/common.go

@@ -20,7 +20,7 @@ var (
 
 func callWeave(args ...string) ([]byte, error) {
 	args = append([]string{"--local"}, args...)
-	Debug.Print("Calling weave", args)
+	Log.Debug("Calling weave", args)
 	cmd := exec.Command("./weave", args...)
 	cmd.Env = []string{"PROCFS=/hostproc", "PATH=/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"}
 	out, err := cmd.CombinedOutput()
@@ -41,14 +41,14 @@ func inspectContainerInPath(client *docker.Client, path string) (*docker.Contain
 	subs := containerIDRegexp.FindStringSubmatch(path)
 	if subs == nil {
 		err := fmt.Errorf("No container id found in request with path %s", path)
-		Warning.Println(err)
+		Log.Warningln(err)
 		return nil, err
 	}
 	containerID := subs[2]
 
 	container, err := client.InspectContainer(containerID)
 	if err != nil {
-		Warning.Printf("Error inspecting container %s: %v", containerID, err)
+		Log.Warningf("Error inspecting container %s: %v", containerID, err)
 	}
 	return container, err
 }

proxy/proxy.go

@@ -47,7 +47,7 @@ func NewProxy(c Config) (*Proxy, error) {
 	p := &Proxy{Config: c}
 
 	if err := p.TLSConfig.loadCerts(); err != nil {
-		Error.Fatalf("Could not configure tls for proxy: %s", err)
+		Log.Fatalf("Could not configure tls for proxy: %s", err)
 	}
 
 	client, err := docker.NewClient(dockerSockUnix)
@@ -94,7 +94,7 @@ func (proxy *Proxy) ListenAndServe() {
 	for _, addr := range proxy.ListenAddrs {
 		listener, normalisedAddr, err := proxy.listen(addr)
 		if err != nil {
-			Error.Fatalf("Cannot listen on %s: %s", addr, err)
+			Log.Fatalf("Cannot listen on %s: %s", addr, err)
 		}
 		listeners = append(listeners, listener)
 		addrs = append(addrs, normalisedAddr)
@@ -113,7 +113,7 @@ func (proxy *Proxy) ListenAndServe() {
 	for range listeners {
 		err := <-errs
 		if err != nil {
-			Error.Fatalf("Serve failed: %s", err)
+			Log.Fatalf("Serve failed: %s", err)
 		}
 	}
 }
@@ -175,7 +175,7 @@ func (proxy *Proxy) listen(protoAndAddr string) (net.Listener, string, error) {
 		}
 
 	default:
-		Error.Fatalf("Invalid protocol format: %q", proto)
+		Log.Fatalf("Invalid protocol format: %q", proto)
 	}
 
 	return listener, fmt.Sprintf("%s://%s", proto, addr), nil

proxy/proxy_intercept.go

@@ -23,7 +23,7 @@ func (proxy *Proxy) Intercept(i interceptor, w http.ResponseWriter, r *http.Requ
 			http.Error(w, err.Error(), http.StatusNotFound)
 		default:
 			http.Error(w, err.Error(), http.StatusInternalServerError)
-			Warning.Print("Error intercepting request: ", err)
+			Log.Warning("Error intercepting request: ", err)
 		}
 		return
 	}
@@ -31,7 +31,7 @@ func (proxy *Proxy) Intercept(i interceptor, w http.ResponseWriter, r *http.Requ
 	conn, err := proxy.Dial()
 	if err != nil {
 		http.Error(w, "Could not connect to target", http.StatusInternalServerError)
-		Warning.Print(err)
+		Log.Warning(err)
 		return
 	}
 	client := httputil.NewClientConn(conn, nil)
@@ -40,13 +40,13 @@ func (proxy *Proxy) Intercept(i interceptor, w http.ResponseWriter, r *http.Requ
 	resp, err := client.Do(r)
 	if err != nil && err != httputil.ErrPersistEOF {
 		http.Error(w, fmt.Sprintf("Could not make request to target: %v", err), http.StatusInternalServerError)
-		Warning.Print("Error forwarding request: ", err)
+		Log.Warning("Error forwarding request: ", err)
 		return
 	}
 	err = i.InterceptResponse(resp)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
-		Warning.Print("Error intercepting response: ", err)
+		Log.Warning("Error intercepting response: ", err)
 		return
 	}
 
@@ -56,7 +56,7 @@ func (proxy *Proxy) Intercept(i interceptor, w http.ResponseWriter, r *http.Requ
 			hdr.Add(k, v)
 		}
 	}
-	Debug.Printf("Response from target: %s %v", resp.Status, w.Header())
+	Log.Debugf("Response from target: %s %v", resp.Status, w.Header())
 
 	if resp.Header.Get("Content-Type") == "application/vnd.docker.raw-stream" {
 		doRawStream(w, resp, client)
@@ -65,7 +65,7 @@ func (proxy *Proxy) Intercept(i interceptor, w http.ResponseWriter, r *http.Requ
 	} else {
 		w.WriteHeader(resp.StatusCode)
 		if _, err := io.Copy(w, resp.Body); err != nil {
-			Warning.Print(err)
+			Log.Warning(err)
 		}
 	}
 }
@@ -80,17 +80,17 @@ func doRawStream(w http.ResponseWriter, resp *http.Response, client *httputil.Cl
 	defer up.Close()
 
 	if _, err := down.Write([]byte("HTTP/1.1 200 OK\n")); err != nil {
-		Warning.Print(err)
+		Log.Warning(err)
 		return
 	}
 
 	if err := resp.Header.Write(down); err != nil {
-		Warning.Print(err)
+		Log.Warning(err)
 		return
 	}
 
 	if _, err := down.Write([]byte("\n")); err != nil {
-		Warning.Print(err)
+		Log.Warning(err)
 		return
 	}
 
@@ -105,13 +105,13 @@ func doRawStream(w http.ResponseWriter, resp *http.Response, client *httputil.Cl
 func copyStream(dst io.Writer, src io.Reader, done chan struct{}) {
 	defer close(done)
 	if _, err := io.Copy(dst, src); err != nil {
-		Warning.Print(err)
+		Log.Warning(err)
 	}
 	if c, ok := dst.(interface {
 		CloseWrite() error
 	}); ok {
 		if err := c.CloseWrite(); err != nil {
-			Warning.Printf("Error closing connection: %s", err)
+			Log.Warningf("Error closing connection: %s", err)
 		}
 	}
 }

proxy/start_container_interceptor.go

@@ -23,7 +23,7 @@ func (i *startContainerInterceptor) InterceptResponse(r *http.Response) error {
 
 	cidrs, ok := i.proxy.weaveCIDRsFromConfig(container.Config)
 	if !ok {
-		Debug.Print("No Weave CIDR, ignoring")
+		Log.Debug("No Weave CIDR, ignoring")
 		return nil
 	}
 	Info.Printf("Attaching container %s with WEAVE_CIDR \"%s\" to weave network", container.ID, strings.Join(cidrs, " "))
@@ -31,7 +31,7 @@ func (i *startContainerInterceptor) InterceptResponse(r *http.Response) error {
 	args = append(args, cidrs...)
 	args = append(args, "--or-die", container.ID)
 	if output, err := callWeave(args...); err != nil {
-		Warning.Printf("Attaching container %s to weave network failed: %s", container.ID, string(output))
+		Log.Warningf("Attaching container %s to weave network failed: %s", container.ID, string(output))
 		return errors.New(string(output))
 	}