Merge pull request #641 from jbenet/rm-prefix-logger

remove prefix logger

core/corehttp/gateway_handler.go

@@ -82,7 +82,6 @@ func (i *gatewayHandler) NewDagReader(nd *dag.Node) (io.Reader, error) {
 
 func (i *gatewayHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	path := r.URL.Path[5:]
-	log := log.Prefix("serving %s", path)
 
 	nd, err := i.ResolvePath(path)
 	if err != nil {

exchange/bitswap/bitswap.go

@@ -173,10 +173,6 @@ func (bs *bitswap) sendWantlistMsgToPeers(ctx context.Context, m bsmsg.BitSwapMe
 		panic("Cant send wantlist to nil peerchan")
 	}
 
-	log := log.Prefix("bitswap(%s).sendWantlistMsgToPeers(%d)", bs.self, len(m.Wantlist()))
-	log.Debugf("begin")
-	defer log.Debugf("end")
-
 	set := pset.New()
 	wg := sync.WaitGroup{}
 	for peerToQuery := range peers {
@@ -216,10 +212,6 @@ func (bs *bitswap) sendWantlistToProviders(ctx context.Context) {
 		return
 	}
 
-	log := log.Prefix("bitswap(%s).sendWantlistToProviders ", bs.self)
-	log.Debugf("begin")
-	defer log.Debugf("end")
-
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 
@@ -233,9 +225,6 @@ func (bs *bitswap) sendWantlistToProviders(ctx context.Context) {
 		go func(k u.Key) {
 			defer wg.Done()
 
-			log := log.Prefix("(entry: %s) ", k)
-			log.Debug("asking dht for providers")
-
 			child, _ := context.WithTimeout(ctx, providerRequestTimeout)
 			providers := bs.network.FindProvidersAsync(child, k, maxProvidersPerRequest)
 			for prov := range providers {
@@ -257,7 +246,6 @@ func (bs *bitswap) sendWantlistToProviders(ctx context.Context) {
 }
 
 func (bs *bitswap) taskWorker(ctx context.Context) {
-	log := log.Prefix("bitswap(%s).taskWorker", bs.self)
 	for {
 		select {
 		case <-ctx.Done():

exchange/bitswap/decision/engine.go

@@ -163,10 +163,6 @@ func (e *Engine) MessageReceived(p peer.ID, m bsmsg.BitSwapMessage) error {
 	e.lock.Lock()
 	defer e.lock.Unlock()
 
-	log := log.Prefix("bitswap.Engine.MessageReceived(%s)", p)
-	log.Debugf("enter. %d entries %d blocks", len(m.Wantlist()), len(m.Blocks()))
-	defer log.Debugf("exit")
-
 	if len(m.Wantlist()) == 0 && len(m.Blocks()) == 0 {
 		log.Info("superfluous message")
 	}

exchange/bitswap/network/ipfs_impl.go

@@ -39,28 +39,23 @@ func (bsnet *impl) SendMessage(
 	p peer.ID,
 	outgoing bsmsg.BitSwapMessage) error {
 
-	log := log.Prefix("bitswap net SendMessage to %s", p)
-
 	// ensure we're connected
 	//TODO(jbenet) move this into host.NewStream?
 	if err := bsnet.host.Connect(ctx, peer.PeerInfo{ID: p}); err != nil {
 		return err
 	}
 
-	log.Debug("opening stream")
 	s, err := bsnet.host.NewStream(ProtocolBitswap, p)
 	if err != nil {
 		return err
 	}
 	defer s.Close()
 
-	log.Debug("sending")
 	if err := outgoing.ToNet(s); err != nil {
 		log.Errorf("error: %s", err)
 		return err
 	}
 
-	log.Debug("sent")
 	return err
 }
 
@@ -69,35 +64,29 @@ func (bsnet *impl) SendRequest(
 	p peer.ID,
 	outgoing bsmsg.BitSwapMessage) (bsmsg.BitSwapMessage, error) {
 
-	log := log.Prefix("bitswap net SendRequest to %s", p)
-
 	// ensure we're connected
 	//TODO(jbenet) move this into host.NewStream?
 	if err := bsnet.host.Connect(ctx, peer.PeerInfo{ID: p}); err != nil {
 		return nil, err
 	}
 
-	log.Debug("opening stream")
 	s, err := bsnet.host.NewStream(ProtocolBitswap, p)
 	if err != nil {
 		return nil, err
 	}
 	defer s.Close()
 
-	log.Debug("sending")
 	if err := outgoing.ToNet(s); err != nil {
 		log.Errorf("error: %s", err)
 		return nil, err
 	}
 
-	log.Debug("sent, now receiveing")
 	incoming, err := bsmsg.FromNet(s)
 	if err != nil {
 		log.Errorf("error: %s", err)
 		return incoming, err
 	}
 
-	log.Debug("received")
 	return incoming, nil
 }
 

p2p/net/swarm/swarm_dial.go

@@ -179,7 +179,6 @@ func (db *dialbackoff) Clear(p peer.ID) {
 // This allows us to use various transport protocols, do NAT traversal/relay,
 // etc. to achive connection.
 func (s *Swarm) Dial(ctx context.Context, p peer.ID) (*Conn, error) {
-	log := log.Prefix("swarm %s dialing %s", s.local, p)
 	if p == s.local {
 		return nil, errors.New("Attempted connection to self!")
 	}

p2p/peer/queue/sync.go

@@ -24,8 +24,6 @@ func NewChanQueue(ctx context.Context, pq PeerQueue) *ChanQueue {
 }
 
 func (cq *ChanQueue) process(ctx context.Context) {
-	log := log.Prefix("<ChanQueue %p>", cq)
-
 	// construct the channels here to be able to use them bidirectionally
 	enqChan := make(chan peer.ID)
 	deqChan := make(chan peer.ID)

routing/dht/dht.go

@@ -97,7 +97,7 @@ func (dht *IpfsDHT) LocalPeer() peer.ID {
 
 // log returns the dht's logger
 func (dht *IpfsDHT) log() eventlog.EventLogger {
-	return log.Prefix("dht(%s)", dht.self)
+	return log // TODO rm
 }
 
 // Connect to a new peer at the given address, ping and add to the routing table

routing/dht/query.go

@@ -84,7 +84,6 @@ func newQueryRunner(ctx context.Context, q *dhtQuery) *dhtQueryRunner {
 }
 
 func (r *dhtQueryRunner) Run(peers []peer.ID) (*dhtQueryResult, error) {
-	log := log.Prefix("dht(%s).Query(%s).Run(%d)", r.query.dht.self, r.query.key, len(peers))
 	r.log = log
 	log.Debug("enter")
 	defer log.Debug("end")
@@ -169,10 +168,6 @@ func (r *dhtQueryRunner) addPeerToQuery(ctx context.Context, next peer.ID) {
 }
 
 func (r *dhtQueryRunner) spawnWorkers(parent ctxgroup.ContextGroup) {
-	log := r.log.Prefix("spawnWorkers")
-	log.Debugf("begin")
-	defer log.Debugf("end")
-
 	for {
 
 		select {
@@ -198,10 +193,6 @@ func (r *dhtQueryRunner) spawnWorkers(parent ctxgroup.ContextGroup) {
 }
 
 func (r *dhtQueryRunner) queryPeer(cg ctxgroup.ContextGroup, p peer.ID) {
-	log := r.log.Prefix("queryPeer(%s)", p)
-	log.Debugf("spawned")
-	defer log.Debugf("finished")
-
 	// make sure we rate limit concurrency.
 	select {
 	case <-r.rateLimit:

routing/dht/routing.go

@@ -73,10 +73,6 @@ func (dht *IpfsDHT) PutValue(ctx context.Context, key u.Key, value []byte) error
 // If the search does not succeed, a multiaddr string of a closer peer is
 // returned along with util.ErrSearchIncomplete
 func (dht *IpfsDHT) GetValue(ctx context.Context, key u.Key) ([]byte, error) {
-	log := dht.log().Prefix("GetValue(%s)", key)
-	log.Debugf("start")
-	defer log.Debugf("end")
-
 	// If we have it local, dont bother doing an RPC!
 	val, err := dht.getLocal(key)
 	if err == nil {
@@ -128,8 +124,6 @@ func (dht *IpfsDHT) GetValue(ctx context.Context, key u.Key) ([]byte, error) {
 
 // Provide makes this node announce that it can provide a value for the given key
 func (dht *IpfsDHT) Provide(ctx context.Context, key u.Key) error {
-	log := dht.log().Prefix("Provide(%s)", key)
-
 	defer log.EventBegin(ctx, "provide", &key).Done()
 
 	// add self locally
@@ -176,8 +170,6 @@ func (dht *IpfsDHT) FindProvidersAsync(ctx context.Context, key u.Key, count int
 }
 
 func (dht *IpfsDHT) findProvidersAsyncRoutine(ctx context.Context, key u.Key, count int, peerOut chan peer.PeerInfo) {
-	log := dht.log().Prefix("FindProviders(%s)", key)
-
 	defer log.EventBegin(ctx, "findProvidersAsync", &key).Done()
 	defer close(peerOut)
 
@@ -201,10 +193,6 @@ func (dht *IpfsDHT) findProvidersAsyncRoutine(ctx context.Context, key u.Key, co
 
 	// setup the Query
 	query := dht.newQuery(key, func(ctx context.Context, p peer.ID) (*dhtQueryResult, error) {
-		log := log.Prefix("Query(%s)", p)
-		log.Debugf("begin")
-		defer log.Debugf("end")
-
 		pmes, err := dht.findProvidersSingle(ctx, p, key)
 		if err != nil {
 			return nil, err

thirdparty/eventlog/log.go

@@ -6,19 +6,34 @@ import (
 	"time"
 
 	"github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
-
-	prelog "github.com/jbenet/go-ipfs/util/prefixlog"
+	"github.com/jbenet/go-ipfs/util" // TODO remove IPFS dependency
 )
 
+// StandardLogger provides API compatibility with standard printf loggers
+// eg. go-logging
+type StandardLogger interface {
+	Critical(args ...interface{})
+	Criticalf(format string, args ...interface{})
+	Debug(args ...interface{})
+	Debugf(format string, args ...interface{})
+	Error(args ...interface{})
+	Errorf(format string, args ...interface{})
+	Fatal(args ...interface{})
+	Fatalf(format string, args ...interface{})
+	Info(args ...interface{})
+	Infof(format string, args ...interface{})
+	Notice(args ...interface{})
+	Noticef(format string, args ...interface{})
+	Panic(args ...interface{})
+	Panicf(format string, args ...interface{})
+	Warning(args ...interface{})
+	Warningf(format string, args ...interface{})
+}
+
 // EventLogger extends the StandardLogger interface to allow for log items
 // containing structured metadata
 type EventLogger interface {
-	prelog.StandardLogger
-
-	// Prefix is like PrefixLogger.Prefix. We override it here
-	// because the type changes (we return EventLogger).
-	// It's what happens when you wrap interfaces.
-	Prefix(fmt string, args ...interface{}) EventLogger
+	StandardLogger
 
 	// Event merges structured data from the provided inputs into a single
 	// machine-readable log event.
@@ -50,22 +65,17 @@ func Logger(system string) EventLogger {
 
 	// TODO if we would like to adjust log levels at run-time. Store this event
 	// logger in a map (just like the util.Logger impl)
-	return &eventLogger{system: system, PrefixLogger: prelog.Logger(system)}
+	return &eventLogger{system: system, StandardLogger: util.Logger(system)}
 }
 
 // eventLogger implements the EventLogger and wraps a go-logging Logger
 type eventLogger struct {
-	prelog.PrefixLogger
+	StandardLogger
 
 	system string
 	// TODO add log-level
 }
 
-func (el *eventLogger) Prefix(fmt string, args ...interface{}) EventLogger {
-	l := el.PrefixLogger.Prefix(fmt, args...)
-	return &eventLogger{system: el.system, PrefixLogger: l}
-}
-
 func (el *eventLogger) EventBegin(ctx context.Context, event string, metadata ...Loggable) DoneCloser {
 	start := time.Now()
 	el.Event(ctx, fmt.Sprintln(event, "Begin"), metadata...)