swarm, metrics: resolved conflicts

metrics/metrics.go

@@ -35,25 +35,6 @@ func init() {
 			Enabled = true
 		}
 	}
-	//exp.Exp(DefaultRegistry)
-}
-
-// NewResettingTimer creates a new ResettingTimer, either a real one of a NOP stub depending
-// on the metrics flag.
-func NewResettingTimer(name string) metrics.ResettingTimer {
-	if !Enabled {
-		return new(metrics.NilResettingTimer)
-	}
-	return metrics.GetOrRegisterResettingTimer(name, metrics.DefaultRegistry)
-}
-
-// NewGauge creates a new metrics Gauge, either a real one of a NOP stub depending
-// on the metrics flag.
-func NewGauge(name string) metrics.Gauge {
-	if !Enabled {
-		return new(metrics.NilGauge)
-	}
-	return metrics.GetOrRegisterGauge(name, metrics.DefaultRegistry)
 }
 
 // CollectProcessMetrics periodically collects various metrics about the running

swarm/api/api.go

@@ -40,21 +40,21 @@ var hashMatcher = regexp.MustCompile("^[0-9A-Fa-f]{64}")
 
 //setup metrics
 var (
-	apiResolveCount    = metrics.NewCounter("api.resolve.count")
+	apiResolveCount    = metrics.NewRegisteredCounter("api.resolve.count", nil)
-	apiResolveFail     = metrics.NewCounter("api.resolve.fail")
+	apiResolveFail     = metrics.NewRegisteredCounter("api.resolve.fail", nil)
-	apiPutCount        = metrics.NewCounter("api.put.count")
+	apiPutCount        = metrics.NewRegisteredCounter("api.put.count", nil)
-	apiPutFail         = metrics.NewCounter("api.put.fail")
+	apiPutFail         = metrics.NewRegisteredCounter("api.put.fail", nil)
-	apiGetCount        = metrics.NewCounter("api.get.count")
+	apiGetCount        = metrics.NewRegisteredCounter("api.get.count", nil)
-	apiGetNotFound     = metrics.NewCounter("api.get.notfound")
+	apiGetNotFound     = metrics.NewRegisteredCounter("api.get.notfound", nil)
-	apiGetHttp300      = metrics.NewCounter("api.get.http.300")
+	apiGetHttp300      = metrics.NewRegisteredCounter("api.get.http.300", nil)
-	apiModifyCount     = metrics.NewCounter("api.modify.count")
+	apiModifyCount     = metrics.NewRegisteredCounter("api.modify.count", nil)
-	apiModifyFail      = metrics.NewCounter("api.modify.fail")
+	apiModifyFail      = metrics.NewRegisteredCounter("api.modify.fail", nil)
-	apiAddFileCount    = metrics.NewCounter("api.addfile.count")
+	apiAddFileCount    = metrics.NewRegisteredCounter("api.addfile.count", nil)
-	apiAddFileFail     = metrics.NewCounter("api.addfile.fail")
+	apiAddFileFail     = metrics.NewRegisteredCounter("api.addfile.fail", nil)
-	apiRmFileCount     = metrics.NewCounter("api.removefile.count")
+	apiRmFileCount     = metrics.NewRegisteredCounter("api.removefile.count", nil)
-	apiRmFileFail      = metrics.NewCounter("api.removefile.fail")
+	apiRmFileFail      = metrics.NewRegisteredCounter("api.removefile.fail", nil)
-	apiAppendFileCount = metrics.NewCounter("api.appendfile.count")
+	apiAppendFileCount = metrics.NewRegisteredCounter("api.appendfile.count", nil)
-	apiAppendFileFail  = metrics.NewCounter("api.appendfile.fail")
+	apiAppendFileFail  = metrics.NewRegisteredCounter("api.appendfile.fail", nil)
 )
 
 type Resolver interface {

swarm/api/http/error.go

@@ -38,8 +38,8 @@ var templateMap map[int]*template.Template
 
 //metrics variables
 var (
-	htmlCounter = metrics.NewCounter("api.http.errorpage.html.count")
+	htmlCounter = metrics.NewRegisteredCounter("api.http.errorpage.html.count", nil)
-	jsonCounter = metrics.NewCounter("api.http.errorpage.json.count")
+	jsonCounter = metrics.NewRegisteredCounter("api.http.errorpage.json.count", nil)
 )
 
 //parameters needed for formatting the correct HTML page

swarm/api/http/server.go

@@ -45,25 +45,25 @@ import (
 
 //setup metrics
 var (
-	postRawCount     = metrics.NewCounter("api.http.post.raw.count")
+	postRawCount     = metrics.NewRegisteredCounter("api.http.post.raw.count", nil)
-	postRawFail      = metrics.NewCounter("api.http.post.raw.fail")
+	postRawFail      = metrics.NewRegisteredCounter("api.http.post.raw.fail", nil)
-	postFilesCount   = metrics.NewCounter("api.http.post.files.count")
+	postFilesCount   = metrics.NewRegisteredCounter("api.http.post.files.count", nil)
-	postFilesFail    = metrics.NewCounter("api.http.post.files.fail")
+	postFilesFail    = metrics.NewRegisteredCounter("api.http.post.files.fail", nil)
-	deleteCount      = metrics.NewCounter("api.http.delete.count")
+	deleteCount      = metrics.NewRegisteredCounter("api.http.delete.count", nil)
-	deleteFail       = metrics.NewCounter("api.http.delete.fail")
+	deleteFail       = metrics.NewRegisteredCounter("api.http.delete.fail", nil)
-	getCount         = metrics.NewCounter("api.http.get.count")
+	getCount         = metrics.NewRegisteredCounter("api.http.get.count", nil)
-	getFail          = metrics.NewCounter("api.http.get.fail")
+	getFail          = metrics.NewRegisteredCounter("api.http.get.fail", nil)
-	getFileCount     = metrics.NewCounter("api.http.get.file.count")
+	getFileCount     = metrics.NewRegisteredCounter("api.http.get.file.count", nil)
-	getFileNotFound  = metrics.NewCounter("api.http.get.file.notfound")
+	getFileNotFound  = metrics.NewRegisteredCounter("api.http.get.file.notfound", nil)
-	getFileFail      = metrics.NewCounter("api.http.get.file.fail")
+	getFileFail      = metrics.NewRegisteredCounter("api.http.get.file.fail", nil)
-	getFilesCount    = metrics.NewCounter("api.http.get.files.count")
+	getFilesCount    = metrics.NewRegisteredCounter("api.http.get.files.count", nil)
-	getFilesFail     = metrics.NewCounter("api.http.get.files.fail")
+	getFilesFail     = metrics.NewRegisteredCounter("api.http.get.files.fail", nil)
-	getListCount     = metrics.NewCounter("api.http.get.list.count")
+	getListCount     = metrics.NewRegisteredCounter("api.http.get.list.count", nil)
-	getListFail      = metrics.NewCounter("api.http.get.list.fail")
+	getListFail      = metrics.NewRegisteredCounter("api.http.get.list.fail", nil)
-	requestCount     = metrics.NewCounter("http.request.count")
+	requestCount     = metrics.NewRegisteredCounter("http.request.count", nil)
-	htmlRequestCount = metrics.NewCounter("http.request.html.count")
+	htmlRequestCount = metrics.NewRegisteredCounter("http.request.html.count", nil)
-	jsonRequestCount = metrics.NewCounter("http.request.json.count")
+	jsonRequestCount = metrics.NewRegisteredCounter("http.request.json.count", nil)
-	requestTimer     = metrics.NewResettingTimer("http.request.time")
+	requestTimer     = metrics.NewRegisteredResettingTimer("http.request.time", nil)
 )
 
 // ServerConfig is the basic configuration needed for the HTTP server and also

swarm/metrics/flags.go

@@ -22,8 +22,7 @@ import (
 	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/log"
 	gethmetrics "github.com/ethereum/go-ethereum/metrics"
-	metrics "github.com/ethersphere/go-metrics"
+	"github.com/ethereum/go-ethereum/metrics/influxdb"
-	influxdb "github.com/ethersphere/go-metrics-influxdb"
 	"gopkg.in/urfave/cli.v1"
 )
 
@@ -76,7 +75,7 @@ func Setup(ctx *cli.Context) {
 		)
 
 		log.Info("Enabling swarm metrics collection and export")
-		go influxdb.InfluxDBWithTags(metrics.DefaultRegistry, 10*time.Second, endpoint, database, username, password, "swarm.", map[string]string{
+		go influxdb.InfluxDBWithTags(gethmetrics.DefaultRegistry, 10*time.Second, endpoint, database, username, password, "swarm.", map[string]string{
 			"host": hosttag,
 		})
 	}

swarm/network/depo.go

@@ -29,11 +29,11 @@ import (
 
 //metrics variables
 var (
-	syncReceiveCount  = metrics.NewCounter("network.sync.recv.count")
+	syncReceiveCount  = metrics.NewRegisteredCounter("network.sync.recv.count", nil)
-	syncReceiveIgnore = metrics.NewCounter("network.sync.recv.ignore")
+	syncReceiveIgnore = metrics.NewRegisteredCounter("network.sync.recv.ignore", nil)
-	syncSendCount     = metrics.NewCounter("network.sync.send.count")
+	syncSendCount     = metrics.NewRegisteredCounter("network.sync.send.count", nil)
-	syncSendRefused   = metrics.NewCounter("network.sync.send.refused")
+	syncSendRefused   = metrics.NewRegisteredCounter("network.sync.send.refused", nil)
-	syncSendNotFound  = metrics.NewCounter("network.sync.send.notfound")
+	syncSendNotFound  = metrics.NewRegisteredCounter("network.sync.send.notfound", nil)
 )
 
 // Handler for storage/retrieval related protocol requests

swarm/network/hive.go

@@ -41,9 +41,9 @@ import (
 // to keep the nodetable uptodate
 
 var (
-	peersNumGauge     = metrics.NewGauge("network.peers.num")
+	peersNumGauge     = metrics.NewRegisteredGauge("network.peers.num", nil)
-	addPeerCounter    = metrics.NewCounter("network.addpeer.count")
+	addPeerCounter    = metrics.NewRegisteredCounter("network.addpeer.count", nil)
-	removePeerCounter = metrics.NewCounter("network.removepeer.count")
+	removePeerCounter = metrics.NewRegisteredCounter("network.removepeer.count", nil)
 )
 
 type Hive struct {

swarm/network/kademlia/kademlia.go

@@ -25,7 +25,6 @@ import (
 
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/metrics"
-	gometrics "github.com/ethersphere/go-metrics"
 )
 
 //metrics variables
@@ -33,8 +32,8 @@ import (
 //at a certain index. Thus we do that with an array of counters with
 //entry for each index
 var (
-	bucketAddIndexCount []gometrics.Counter
+	bucketAddIndexCount []metrics.Counter
-	bucketRmIndexCount  []gometrics.Counter
+	bucketRmIndexCount  []metrics.Counter
 )
 
 const (
@@ -445,11 +444,11 @@ func (self *Kademlia) String() string {
 //We have to build up the array of counters for each index
 func (self *Kademlia) initMetricsVariables() {
 	//create the arrays
-	bucketAddIndexCount = make([]gometrics.Counter, self.MaxProx+1)
+	bucketAddIndexCount = make([]metrics.Counter, self.MaxProx+1)
-	bucketRmIndexCount = make([]gometrics.Counter, self.MaxProx+1)
+	bucketRmIndexCount = make([]metrics.Counter, self.MaxProx+1)
 	//at each index create a metrics counter
 	for i := 0; i < (self.KadParams.MaxProx + 1); i++ {
-		bucketAddIndexCount[i] = metrics.NewCounter(fmt.Sprintf("network.kademlia.bucket.add.%d.index", i))
+		bucketAddIndexCount[i] = metrics.NewRegisteredCounter(fmt.Sprintf("network.kademlia.bucket.add.%d.index", i), nil)
-		bucketRmIndexCount[i] = metrics.NewCounter(fmt.Sprintf("network.kademlia.bucket.rm.%d.index", i))
+		bucketRmIndexCount[i] = metrics.NewRegisteredCounter(fmt.Sprintf("network.kademlia.bucket.rm.%d.index", i), nil)
 	}
 }

swarm/network/protocol.go

@@ -48,15 +48,15 @@ import (
 
 //metrics variables
 var (
-	storeRequestMsgCounter    = metrics.NewCounter("network.protocol.msg.storerequest.count")
+	storeRequestMsgCounter    = metrics.NewRegisteredCounter("network.protocol.msg.storerequest.count", nil)
-	retrieveRequestMsgCounter = metrics.NewCounter("network.protocol.msg.retrieverequest.count")
+	retrieveRequestMsgCounter = metrics.NewRegisteredCounter("network.protocol.msg.retrieverequest.count", nil)
-	peersMsgCounter           = metrics.NewCounter("network.protocol.msg.peers.count")
+	peersMsgCounter           = metrics.NewRegisteredCounter("network.protocol.msg.peers.count", nil)
-	syncRequestMsgCounter     = metrics.NewCounter("network.protocol.msg.syncrequest.count")
+	syncRequestMsgCounter     = metrics.NewRegisteredCounter("network.protocol.msg.syncrequest.count", nil)
-	unsyncedKeysMsgCounter    = metrics.NewCounter("network.protocol.msg.unsyncedkeys.count")
+	unsyncedKeysMsgCounter    = metrics.NewRegisteredCounter("network.protocol.msg.unsyncedkeys.count", nil)
-	deliverRequestMsgCounter  = metrics.NewCounter("network.protocol.msg.deliverrequest.count")
+	deliverRequestMsgCounter  = metrics.NewRegisteredCounter("network.protocol.msg.deliverrequest.count", nil)
-	paymentMsgCounter         = metrics.NewCounter("network.protocol.msg.payment.count")
+	paymentMsgCounter         = metrics.NewRegisteredCounter("network.protocol.msg.payment.count", nil)
-	invalidMsgCounter         = metrics.NewCounter("network.protocol.msg.invalid.count")
+	invalidMsgCounter         = metrics.NewRegisteredCounter("network.protocol.msg.invalid.count", nil)
-	handleStatusMsgCounter    = metrics.NewCounter("network.protocol.msg.handlestatus.count")
+	handleStatusMsgCounter    = metrics.NewRegisteredCounter("network.protocol.msg.handlestatus.count", nil)
 )
 
 const (

swarm/storage/chunker.go

@@ -67,7 +67,7 @@ var (
 
 //metrics variables
 var (
-	newChunkCounter = metrics.NewCounter("storage.chunks.new")
+	newChunkCounter = metrics.NewRegisteredCounter("storage.chunks.new", nil)
 )
 
 type TreeChunker struct {

swarm/storage/dbstore.go

@@ -41,8 +41,8 @@ import (
 
 //metrics variables
 var (
-	gcCounter            = metrics.NewCounter("storage.db.dbstore.gc.count")
+	gcCounter            = metrics.NewRegisteredCounter("storage.db.dbstore.gc.count", nil)
-	dbStoreDeleteCounter = metrics.NewCounter("storage.db.dbstore.rm.count")
+	dbStoreDeleteCounter = metrics.NewRegisteredCounter("storage.db.dbstore.rm.count", nil)
 )
 
 const (

swarm/storage/localstore.go

@@ -24,7 +24,7 @@ import (
 
 //metrics variables
 var (
-	dbStorePutCounter = metrics.NewCounter("storage.db.dbstore.put.count")
+	dbStorePutCounter = metrics.NewRegisteredCounter("storage.db.dbstore.put.count", nil)
 )
 
 // LocalStore is a combination of inmemory db over a disk persisted db

swarm/storage/memstore.go

@@ -28,8 +28,8 @@ import (
 
 //metrics variables
 var (
-	memstorePutCounter    = metrics.NewCounter("storage.db.memstore.put.count")
+	memstorePutCounter    = metrics.NewRegisteredCounter("storage.db.memstore.put.count", nil)
-	memstoreRemoveCounter = metrics.NewCounter("storage.db.memstore.rm.count")
+	memstoreRemoveCounter = metrics.NewRegisteredCounter("storage.db.memstore.rm.count", nil)
 )
 
 const (

swarm/swarm.go

@@ -50,11 +50,11 @@ import (
 var (
 	startTime          time.Time
 	updateGaugesPeriod = 5 * time.Second
-	startCounter       = metrics.NewCounter("stack,start")
+	startCounter       = metrics.NewRegisteredCounter("stack,start", nil)
-	stopCounter        = metrics.NewCounter("stack,stop")
+	stopCounter        = metrics.NewRegisteredCounter("stack,stop", nil)
-	uptimeGauge        = metrics.NewGauge("stack.uptime")
+	uptimeGauge        = metrics.NewRegisteredGauge("stack.uptime", nil)
-	dbSizeGauge        = metrics.NewGauge("storage.db.chunks.size")
+	dbSizeGauge        = metrics.NewRegisteredGauge("storage.db.chunks.size", nil)
-	cacheSizeGauge     = metrics.NewGauge("storage.db.cache.size")
+	cacheSizeGauge     = metrics.NewRegisteredGauge("storage.db.cache.size", nil)
 )
 
 // the swarm stack
@@ -329,7 +329,7 @@ func (self *Swarm) periodicallyUpdateGauges() {
 	ticker := time.NewTicker(updateGaugesPeriod)
 
 	go func() {
-		for _ = range ticker.C {
+		for range ticker.C {
 			self.updateGauges()
 		}
 	}()