P7 - All bee metrics to locatore (#83)

* added metrics to localstore
Co-authored-by: Janos Guljas <janos@resenje.org>

pkg/storage/localstore/gc.go

@@ -20,7 +20,6 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/log"
-	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/ethersphere/swarm/shed"
 	"github.com/syndtr/goleveldb/leveldb"
 )
@@ -78,12 +77,11 @@ func (db *DB) collectGarbageWorker() {
 // the rest of the garbage as the batch size limit is reached.
 // This function is called in collectGarbageWorker.
 func (db *DB) collectGarbage() (collectedCount uint64, done bool, err error) {
-	metricName := "localstore/gc"
-	metrics.GetOrRegisterCounter(metricName, nil).Inc(1)
-	defer totalTimeMetric(metricName, time.Now())
+	db.metrics.GCCounter.Inc()
+	defer totalTimeMetric(db.metrics.TotalTimeCollectGarbage, time.Now())
 	defer func() {
 		if err != nil {
-			metrics.GetOrRegisterCounter(metricName+"/error", nil).Inc(1)
+			db.metrics.GCErrorCounter.Inc()
 		}
 	}()
 
@@ -106,7 +104,7 @@ func (db *DB) collectGarbage() (collectedCount uint64, done bool, err error) {
 	if err != nil {
 		return 0, true, err
 	}
-	metrics.GetOrRegisterGauge(metricName+"/gcsize", nil).Update(int64(gcSize))
+	db.metrics.GCSize.Inc()
 
 	done = true
 	err = db.gcIndex.Iterate(func(item shed.Item) (stop bool, err error) {
@@ -114,8 +112,8 @@ func (db *DB) collectGarbage() (collectedCount uint64, done bool, err error) {
 			return true, nil
 		}
 
-		metrics.GetOrRegisterGauge(metricName+"/storets", nil).Update(item.StoreTimestamp)
-		metrics.GetOrRegisterGauge(metricName+"/accessts", nil).Update(item.AccessTimestamp)
+		db.metrics.GCStoreTimeStamps.Set(float64(item.StoreTimestamp))
+		db.metrics.GCStoreAccessTimeStamps.Set(float64(item.AccessTimestamp))
 
 		// delete from retrieve, pull, gc
 		err = db.retrievalDataIndex.DeleteInBatch(batch, item)
@@ -146,13 +144,13 @@ func (db *DB) collectGarbage() (collectedCount uint64, done bool, err error) {
 	if err != nil {
 		return 0, false, err
 	}
-	metrics.GetOrRegisterCounter(metricName+"/collected-count", nil).Inc(int64(collectedCount))
+	db.metrics.GCCollectedCounter.Inc()
 
 	db.gcSize.PutInBatch(batch, gcSize-collectedCount)
 
 	err = db.shed.WriteBatch(batch)
 	if err != nil {
-		metrics.GetOrRegisterCounter(metricName+"/writebatch/err", nil).Inc(1)
+		db.metrics.GCExcludeWriteBatchError.Inc()
 		return 0, false, err
 	}
 	return collectedCount, done, nil
@@ -160,12 +158,11 @@ func (db *DB) collectGarbage() (collectedCount uint64, done bool, err error) {
 
 // removeChunksInExcludeIndexFromGC removed any recently chunks in the exclude Index, from the gcIndex.
 func (db *DB) removeChunksInExcludeIndexFromGC() (err error) {
-	metricName := "localstore/gc/exclude"
-	metrics.GetOrRegisterCounter(metricName, nil).Inc(1)
-	defer totalTimeMetric(metricName, time.Now())
+	db.metrics.GCExcludeCounter.Inc()
+	defer totalTimeMetric(db.metrics.TotalTimeGCExclude, time.Now())
 	defer func() {
 		if err != nil {
-			metrics.GetOrRegisterCounter(metricName+"/error", nil).Inc(1)
+			db.metrics.GCExcludeError.Inc()
 		}
 	}()
 
@@ -219,10 +216,10 @@ func (db *DB) removeChunksInExcludeIndexFromGC() (err error) {
 		return err
 	}
 
-	metrics.GetOrRegisterCounter(metricName+"/excluded-count", nil).Inc(int64(excludedCount))
+	db.metrics.GCExcludeCounter.Inc()
 	err = db.shed.WriteBatch(batch)
 	if err != nil {
-		metrics.GetOrRegisterCounter(metricName+"/writebatch/err", nil).Inc(1)
+		db.metrics.GCExcludeWriteBatchError.Inc()
 		return err
 	}
 

pkg/storage/localstore/localstore.go

@@ -19,13 +19,13 @@ package localstore
 import (
 	"encoding/binary"
 	"errors"
+	"github.com/prometheus/client_golang/prometheus"
 	"os"
 	"runtime/pprof"
 	"sync"
 	"time"
 
 	"github.com/ethereum/go-ethereum/log"
-	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/ethersphere/swarm/chunk"
 	"github.com/ethersphere/swarm/shed"
 	"github.com/ethersphere/swarm/storage/mock"
@@ -126,6 +126,8 @@ type DB struct {
 	// underlaying LevelDB to prevent possible panics from
 	// iterators
 	subscritionsWG sync.WaitGroup
+
+	metrics metrics
 }
 
 // Options struct holds optional parameters for configuring DB.
@@ -175,6 +177,7 @@ func New(path string, baseKey []byte, o *Options) (db *DB, err error) {
 		close:                    make(chan struct{}),
 		collectGarbageWorkerDone: make(chan struct{}),
 		putToGCCheck:             o.PutToGCCheck,
+		metrics:                  newMetrics(),
 	}
 	if db.capacity == 0 {
 		db.capacity = defaultCapacity
@@ -542,7 +545,8 @@ func init() {
 // totalTimeMetric logs a message about time between provided start time
 // and the time when the function is called and sends a resetting timer metric
 // with provided name appended with ".total-time".
-func totalTimeMetric(name string, start time.Time) {
+func totalTimeMetric(metric prometheus.Counter, start time.Time) {
 	totalTime := time.Since(start)
-	metrics.GetOrRegisterResettingTimer(name+"/total-time", nil).Update(totalTime)
+	metric.Add(float64(totalTime))
+
 }

pkg/storage/localstore/metrics.go

+// Copyright 2020 The Swarm Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package localstore
+
+import (
+	m "github.com/ethersphere/bee/pkg/metrics"
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+type metrics struct {
+	// all metrics fields must be exported
+	// to be able to return them by Metrics()
+	// using reflection
+
+	TotalTimeCollectGarbage         prometheus.Counter
+	TotalTimeGCExclude              prometheus.Counter
+	TotalTimeGet                    prometheus.Counter
+	TotalTimeUpdateGC               prometheus.Counter
+	TotalTimeGetMulti               prometheus.Counter
+	TotalTimeHas                    prometheus.Counter
+	TotalTimeHasMulti               prometheus.Counter
+	TotalTimePut                    prometheus.Counter
+	TotalTimeSet                    prometheus.Counter
+	TotalTimeSubscribePullIteration prometheus.Counter
+	TotalTimeSubscribePushIteration prometheus.Counter
+
+	GCCounter                prometheus.Counter
+	GCErrorCounter           prometheus.Counter
+	GCCollectedCounter       prometheus.Counter
+	GCWriteBatchError        prometheus.Counter
+	GCExcludeCounter         prometheus.Counter
+	GCExcludeError           prometheus.Counter
+	GCExcludedCounter        prometheus.Counter
+	GCExcludeWriteBatchError prometheus.Counter
+	GCUpdate                 prometheus.Counter
+	GCUpdateError            prometheus.Counter
+
+	ModeGet                       prometheus.Counter
+	ModeGetFailure                prometheus.Counter
+	ModeGetMulti                  prometheus.Counter
+	ModeGetMultiFailure           prometheus.Counter
+	ModePut                       prometheus.Counter
+	ModePutFailure                prometheus.Counter
+	ModeSet                       prometheus.Counter
+	ModeSetFailure                prometheus.Counter
+	ModeHas                       prometheus.Counter
+	ModeHasFailure                prometheus.Counter
+	ModeHasMulti                  prometheus.Counter
+	ModeHasMultiFailure           prometheus.Counter
+	SubscribePull                 prometheus.Counter
+	SubscribePullStop             prometheus.Counter
+	SubscribePullIteration        prometheus.Counter
+	SubscribePullIterationFailure prometheus.Counter
+	LastPullSubscriptionBinID     prometheus.Counter
+	SubscribePush                 prometheus.Counter
+	SubscribePushIteration        prometheus.Counter
+	SubscribePushIterationDone    prometheus.Counter
+	SubscribePushIterationFailure prometheus.Counter
+
+	GCSize                  prometheus.Gauge
+	GCStoreTimeStamps       prometheus.Gauge
+	GCStoreAccessTimeStamps prometheus.Gauge
+}
+
+func newMetrics() metrics {
+	subsystem := "localstore"
+
+	return metrics{
+		TotalTimeCollectGarbage: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "gc_time",
+			Help:      "Total time taken to collect garbage.",
+		}),
+		TotalTimeGCExclude: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "gc_exclude_index_time",
+			Help:      "Total time taken to exclude gc index.",
+		}),
+		TotalTimeGet: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "get_chunk_time",
+			Help:      "Total time taken to get chunk from DB.",
+		}),
+		TotalTimeUpdateGC: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "in_gc_time",
+			Help:      "Total time taken to in gc.",
+		}),
+		TotalTimeGetMulti: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "get_multi_time",
+			Help:      "Total time taken to get multiple chunks from DB.",
+		}),
+		TotalTimeHas: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "has_time",
+			Help:      "Total time taken to check if the key is present in DB.",
+		}),
+		TotalTimeHasMulti: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "has_multi_time",
+			Help:      "Total time taken to check if multiple keys are present in DB.",
+		}),
+		TotalTimePut: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "put_time",
+			Help:      "Total time taken to put a chunk in DB.",
+		}),
+		TotalTimeSet: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "set_time",
+			Help:      "Total time taken to set chunk in DB.",
+		}),
+		TotalTimeSubscribePullIteration: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "subscribe_pull_iteration_time",
+			Help:      "Total time taken to subsctibe for pull iteration.",
+		}),
+		TotalTimeSubscribePushIteration: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "subscribe_push_iteration_time",
+			Help:      "Total time taken to subscribe for push iteration.",
+		}),
+		GCCounter: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "gc_count",
+			Help:      "Number of times the GC operation is done.",
+		}),
+		GCErrorCounter: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "gc_fail_count",
+			Help:      "Number of times the GC operation failed.",
+		}),
+		GCCollectedCounter: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "gc_collected_count",
+			Help:      "Number of times the GC_COLLECTED operation is done.",
+		}),
+		GCWriteBatchError: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "gc_write_batch_error_count",
+			Help:      "Number of times the GC_WRITE_BATCH operation failed.",
+		}),
+		GCExcludeCounter: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "gc_exclude_count",
+			Help:      "Number of times the GC_EXCLUDE operation is done.",
+		}),
+		GCExcludeError: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "gc_exclude_fail_count",
+			Help:      "Number of times the GC_EXCLUDE operation failed.",
+		}),
+		GCExcludedCounter: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "gc_excluded_count",
+			Help:      "Number of times the GC_EXCLUDED operation is done.",
+		}),
+		GCExcludeWriteBatchError: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "ex_exclude_write_batch_fail_count",
+			Help:      "Number of times the GC_EXCLUDE_WRITE_BATCH operation is failed.",
+		}),
+		GCUpdate: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "gc_update_count",
+			Help:      "Number of times the gc is updated.",
+		}),
+		GCUpdateError: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "fc_update_error_count",
+			Help:      "Number of times the gc update had error.",
+		}),
+
+		ModeGet: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "mode_get_count",
+			Help:      "Number of times MODE_GET is invoked.",
+		}),
+		ModeGetFailure: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "mode_get_failure_count",
+			Help:      "Number of times MODE_GET invocation failed.",
+		}),
+		ModeGetMulti: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "mode_get_multi_count",
+			Help:      "Number of times MODE_MULTI_GET is invoked.",
+		}),
+		ModeGetMultiFailure: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "mode_get_failure_count",
+			Help:      "Number of times MODE_GET invocation failed.",
+		}),
+		ModePut: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "mode_put_count",
+			Help:      "Number of times MODE_PUT is invoked.",
+		}),
+		ModePutFailure: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "mode_put_failure_count",
+			Help:      "Number of times MODE_PUT invocation failed.",
+		}),
+		ModeSet: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "mode_set_count",
+			Help:      "Number of times MODE_SET is invoked.",
+		}),
+		ModeSetFailure: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "mode_set_failure_count",
+			Help:      "Number of times MODE_SET invocation failed.",
+		}),
+		ModeHas: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "mode_has_count",
+			Help:      "Number of times MODE_HAS is invoked.",
+		}),
+		ModeHasFailure: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "mode_has_count",
+			Help:      "Number of times MODE_HAS invocation failed.",
+		}),
+		ModeHasMulti: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "mode_has_multi_count",
+			Help:      "Number of times MODE_HAS_MULTI is invoked.",
+		}),
+		ModeHasMultiFailure: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "mode_has_multi_fail_count",
+			Help:      "Number of times MODE_HAS_MULTI invocation failed.",
+		}),
+		SubscribePull: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "subscribe_pull_count",
+			Help:      "Number of times Subscribe_pULL is invoked.",
+		}),
+		SubscribePullStop: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "subscribe_pull_stop_count",
+			Help:      "Number of times Subscribe_pull_stop is invoked.",
+		}),
+		SubscribePullIteration: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "subscribe_pull_iteration_count",
+			Help:      "Number of times Subscribe_pull_iteration is invoked.",
+		}),
+		SubscribePullIterationFailure: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "subscribe_pull_iteration_fail_count",
+			Help:      "Number of times Subscribe_pull_iteration_fail is invoked.",
+		}),
+		LastPullSubscriptionBinID: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "last_pull_subscription_bin_id_count",
+			Help:      "Number of times LastPullSubscriptionBinID is invoked.",
+		}),
+		SubscribePush: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "subscribe_push_count",
+			Help:      "Number of times SUBSCRIBE_PUSH is invoked.",
+		}),
+		SubscribePushIteration: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "subscribe_push_iteration_count",
+			Help:      "Number of times SUBSCRIBE_PUSH_ITERATION is invoked.",
+		}),
+		SubscribePushIterationDone: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "subscribe_push_iteration_done_count",
+			Help:      "Number of times SUBSCRIBE_PUSH_ITERATION_DONE is invoked.",
+		}),
+		SubscribePushIterationFailure: prometheus.NewCounter(prometheus.CounterOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "subscribe_push_iteration_failure_count",
+			Help:      "Number of times SUBSCRIBE_PUSH_ITERATION_FAILURE is invoked.",
+		}),
+
+		GCSize: prometheus.NewGauge(prometheus.GaugeOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "gc_size",
+			Help:      "Number of elements in Garbage collection index.",
+		}),
+		GCStoreTimeStamps: prometheus.NewGauge(prometheus.GaugeOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "gc_time_stamp",
+			Help:      "Storage timestamp in Garbage collection iteration.",
+		}),
+		GCStoreAccessTimeStamps: prometheus.NewGauge(prometheus.GaugeOpts{
+			Namespace: m.Namespace,
+			Subsystem: subsystem,
+			Name:      "gc_access_time_stamp",
+			Help:      "Access timestamp in Garbage collection iteration.",
+		}),
+	}
+}
+
+func (s *DB) Metrics() []prometheus.Collector {
+	return m.PrometheusCollectorsFromFields(s.metrics)
+}

pkg/storage/localstore/mode_get.go

@@ -18,11 +18,9 @@ package localstore
 
 import (
 	"context"
-	"fmt"
 	"time"
 
 	"github.com/ethereum/go-ethereum/log"
-	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/ethersphere/swarm/chunk"
 	"github.com/ethersphere/swarm/shed"
 	"github.com/syndtr/goleveldb/leveldb"
@@ -34,14 +32,12 @@ import (
 // Getter Mode. Get is required to implement chunk.Store
 // interface.
 func (db *DB) Get(ctx context.Context, mode chunk.ModeGet, addr chunk.Address) (ch chunk.Chunk, err error) {
-	metricName := fmt.Sprintf("localstore/Get/%s", mode)
-
-	metrics.GetOrRegisterCounter(metricName, nil).Inc(1)
-	defer totalTimeMetric(metricName, time.Now())
+	db.metrics.ModeGet.Inc()
+	defer totalTimeMetric(db.metrics.TotalTimeGet, time.Now())
 
 	defer func() {
 		if err != nil {
-			metrics.GetOrRegisterCounter(metricName+"/error", nil).Inc(1)
+			db.metrics.ModeGetFailure.Inc()
 		}
 	}()
 
@@ -103,14 +99,13 @@ func (db *DB) updateGCItems(items ...shed.Item) {
 			defer func() { <-db.updateGCSem }()
 		}
 
-		metricName := "localstore/updateGC"
-		metrics.GetOrRegisterCounter(metricName, nil).Inc(1)
-		defer totalTimeMetric(metricName, time.Now())
+		db.metrics.GCUpdate.Inc()
+		defer totalTimeMetric(db.metrics.TotalTimeUpdateGC, time.Now())
 
 		for _, item := range items {
 			err := db.updateGC(item)
 			if err != nil {
-				metrics.GetOrRegisterCounter(metricName+"/error", nil).Inc(1)
+				db.metrics.GCUpdateError.Inc()
 				log.Error("localstore update gc", "err", err)
 			}
 		}

pkg/storage/localstore/mode_get_multi.go

@@ -18,10 +18,8 @@ package localstore
 
 import (
 	"context"
-	"fmt"
 	"time"
 
-	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/ethersphere/swarm/chunk"
 	"github.com/ethersphere/swarm/shed"
 	"github.com/syndtr/goleveldb/leveldb"
@@ -32,14 +30,12 @@ import (
 // required by the Getter Mode. GetMulti is required to implement chunk.Store
 // interface.
 func (db *DB) GetMulti(ctx context.Context, mode chunk.ModeGet, addrs ...chunk.Address) (chunks []chunk.Chunk, err error) {
-	metricName := fmt.Sprintf("localstore/GetMulti/%s", mode)
-
-	metrics.GetOrRegisterCounter(metricName, nil).Inc(1)
-	defer totalTimeMetric(metricName, time.Now())
+	db.metrics.ModeGetMulti.Inc()
+	defer totalTimeMetric(db.metrics.TotalTimeGetMulti, time.Now())
 
 	defer func() {
 		if err != nil {
-			metrics.GetOrRegisterCounter(metricName+"/error", nil).Inc(1)
+			db.metrics.ModeGetMultiFailure.Inc()
 		}
 	}()
 

pkg/storage/localstore/mode_has.go

@@ -20,20 +20,18 @@ import (
 	"context"
 	"time"
 
-	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/ethersphere/swarm/chunk"
 )
 
 // Has returns true if the chunk is stored in database.
 func (db *DB) Has(ctx context.Context, addr chunk.Address) (bool, error) {
-	metricName := "localstore/Has"
 
-	metrics.GetOrRegisterCounter(metricName, nil).Inc(1)
-	defer totalTimeMetric(metricName, time.Now())
+	db.metrics.ModeHas.Inc()
+	defer totalTimeMetric(db.metrics.TotalTimeHas, time.Now())
 
 	has, err := db.retrievalDataIndex.Has(addressToItem(addr))
 	if err != nil {
-		metrics.GetOrRegisterCounter(metricName+"/error", nil).Inc(1)
+		db.metrics.ModeHasFailure.Inc()
 	}
 	return has, err
 }
@@ -41,14 +39,13 @@ func (db *DB) Has(ctx context.Context, addr chunk.Address) (bool, error) {
 // HasMulti returns a slice of booleans which represent if the provided chunks
 // are stored in database.
 func (db *DB) HasMulti(ctx context.Context, addrs ...chunk.Address) ([]bool, error) {
-	metricName := "localstore/HasMulti"
 
-	metrics.GetOrRegisterCounter(metricName, nil).Inc(1)
-	defer totalTimeMetric(metricName, time.Now())
+	db.metrics.ModeHasMulti.Inc()
+	defer totalTimeMetric(db.metrics.TotalTimeHasMulti, time.Now())
 
 	have, err := db.retrievalDataIndex.HasMulti(addressesToItems(addrs...)...)
 	if err != nil {
-		metrics.GetOrRegisterCounter(metricName+"/error", nil).Inc(1)
+		db.metrics.ModeHasMultiFailure.Inc()
 	}
 	return have, err
 }

pkg/storage/localstore/mode_put.go

@@ -19,10 +19,8 @@ package localstore
 import (
 	"bytes"
 	"context"
-	"fmt"
 	"time"
 
-	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/ethersphere/swarm/chunk"
 	"github.com/ethersphere/swarm/shed"
 	"github.com/syndtr/goleveldb/leveldb"
@@ -33,14 +31,13 @@ import (
 // Put is required to implement chunk.Store
 // interface.
 func (db *DB) Put(ctx context.Context, mode chunk.ModePut, chs ...chunk.Chunk) (exist []bool, err error) {
-	metricName := fmt.Sprintf("localstore/Put/%s", mode)
 
-	metrics.GetOrRegisterCounter(metricName, nil).Inc(1)
-	defer totalTimeMetric(metricName, time.Now())
+	db.metrics.ModePut.Inc()
+	defer totalTimeMetric(db.metrics.TotalTimePut, time.Now())
 
 	exist, err = db.put(mode, chs...)
 	if err != nil {
-		metrics.GetOrRegisterCounter(metricName+"/error", nil).Inc(1)
+		db.metrics.ModePutFailure.Inc()
 	}
 
 	return exist, err

pkg/storage/localstore/mode_set.go

@@ -19,10 +19,8 @@ package localstore
 import (
 	"context"
 	"errors"
-	"fmt"
 	"time"
 
-	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/ethersphere/swarm/chunk"
 	"github.com/ethersphere/swarm/log"
 	"github.com/syndtr/goleveldb/leveldb"
@@ -33,13 +31,11 @@ import (
 // Set is required to implement chunk.Store
 // interface.
 func (db *DB) Set(ctx context.Context, mode chunk.ModeSet, addrs ...chunk.Address) (err error) {
-	metricName := fmt.Sprintf("localstore/Set/%s", mode)
-
-	metrics.GetOrRegisterCounter(metricName, nil).Inc(1)
-	defer totalTimeMetric(metricName, time.Now())
+	db.metrics.ModePut.Inc()
+	defer totalTimeMetric(db.metrics.TotalTimeSet, time.Now())
 	err = db.set(mode, addrs...)
 	if err != nil {
-		metrics.GetOrRegisterCounter(metricName+"/error", nil).Inc(1)
+		db.metrics.ModePutFailure.Inc()
 	}
 	return err
 }

pkg/storage/localstore/subscription_pull.go

@@ -23,7 +23,6 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/log"
-	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/ethersphere/swarm/chunk"
 	"github.com/ethersphere/swarm/shed"
 	"github.com/syndtr/goleveldb/leveldb"
@@ -38,8 +37,7 @@ import (
 // Make sure that you check the second returned parameter from the channel to stop iteration when its value
 // is false.
 func (db *DB) SubscribePull(ctx context.Context, bin uint8, since, until uint64) (c <-chan chunk.Descriptor, stop func()) {
-	metricName := "localstore/SubscribePull"
-	metrics.GetOrRegisterCounter(metricName, nil).Inc(1)
+	db.metrics.SubscribePull.Inc()
 
 	chunkDescriptors := make(chan chunk.Descriptor)
 	trigger := make(chan struct{}, 1)
@@ -64,7 +62,7 @@ func (db *DB) SubscribePull(ctx context.Context, bin uint8, since, until uint64)
 	db.subscritionsWG.Add(1)
 	go func() {
 		defer db.subscritionsWG.Done()
-		defer metrics.GetOrRegisterCounter(metricName+"/stop", nil).Inc(1)
+		db.metrics.SubscribePullStop.Inc()
 		// close the returned chunk.Descriptor channel at the end to
 		// signal that the subscription is done
 		defer close(chunkDescriptors)
@@ -85,7 +83,7 @@ func (db *DB) SubscribePull(ctx context.Context, bin uint8, since, until uint64)
 				// - last index Item is reached
 				// - subscription stop is called
 				// - context is done
-				metrics.GetOrRegisterCounter(metricName+"/iter", nil).Inc(1)
+				db.metrics.SubscribePullIteration.Inc()
 
 				iterStart := time.Now()
 				var count int
@@ -129,7 +127,7 @@ func (db *DB) SubscribePull(ctx context.Context, bin uint8, since, until uint64)
 					Prefix:            []byte{bin},
 				})
 
-				totalTimeMetric(metricName+"/iter", iterStart)
+				totalTimeMetric(db.metrics.TotalTimeSubscribePullIteration, iterStart)
 
 				if err != nil {
 					if err == errStopSubscription {
@@ -137,7 +135,7 @@ func (db *DB) SubscribePull(ctx context.Context, bin uint8, since, until uint64)
 						// if until is reached
 						return
 					}
-					metrics.GetOrRegisterCounter(metricName+"/iter/error", nil).Inc(1)
+					db.metrics.SubscribePullIterationFailure.Inc()
 					log.Error("localstore pull subscription iteration", "bin", bin, "since", since, "until", until, "err", err)
 					return
 				}
@@ -185,7 +183,7 @@ func (db *DB) SubscribePull(ctx context.Context, bin uint8, since, until uint64)
 // in pull syncing index for a provided bin. If there are no chunks in
 // that bin, 0 value is returned.
 func (db *DB) LastPullSubscriptionBinID(bin uint8) (id uint64, err error) {
-	metrics.GetOrRegisterCounter("localstore/LastPullSubscriptionBinID", nil).Inc(1)
+	db.metrics.LastPullSubscriptionBinID.Inc()
 
 	item, err := db.pullIndex.Last([]byte{bin})
 	if err != nil {

pkg/storage/localstore/subscription_push.go

@@ -23,7 +23,6 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/log"
-	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/ethersphere/swarm/chunk"
 	"github.com/ethersphere/swarm/shed"
 )
@@ -33,8 +32,7 @@ import (
 // the returned channel without any errors. Make sure that you check the second returned parameter
 // from the channel to stop iteration when its value is false.
 func (db *DB) SubscribePush(ctx context.Context) (c <-chan chunk.Chunk, stop func()) {
-	metricName := "localstore/SubscribePush"
-	metrics.GetOrRegisterCounter(metricName, nil).Inc(1)
+	db.metrics.SubscribePush.Inc()
 
 	chunks := make(chan chunk.Chunk)
 	trigger := make(chan struct{}, 1)
@@ -52,7 +50,7 @@ func (db *DB) SubscribePush(ctx context.Context) (c <-chan chunk.Chunk, stop fun
 	db.subscritionsWG.Add(1)
 	go func() {
 		defer db.subscritionsWG.Done()
-		defer metrics.GetOrRegisterCounter(metricName+"/done", nil).Inc(1)
+		db.metrics.SubscribePushIterationDone.Inc()
 		// close the returned chunkInfo channel at the end to
 		// signal that the subscription is done
 		defer close(chunks)
@@ -65,8 +63,8 @@ func (db *DB) SubscribePush(ctx context.Context) (c <-chan chunk.Chunk, stop fun
 				// iterate until:
 				// - last index Item is reached
 				// - subscription stop is called
-				// - context is done
-				metrics.GetOrRegisterCounter(metricName+"/iter", nil).Inc(1)
+				// - context is done.met
+				db.metrics.SubscribePushIteration.Inc()
 
 				iterStart := time.Now()
 				var count int
@@ -103,10 +101,10 @@ func (db *DB) SubscribePush(ctx context.Context) (c <-chan chunk.Chunk, stop fun
 					SkipStartFromItem: true,
 				})
 
-				totalTimeMetric(metricName+"/iter", iterStart)
+				totalTimeMetric(db.metrics.TotalTimeSubscribePushIteration, iterStart)
 
 				if err != nil {
-					metrics.GetOrRegisterCounter(metricName+"/iter/error", nil).Inc(1)
+					db.metrics.SubscribePushIterationFailure.Inc()
 					log.Error("localstore push subscription iteration", "err", err)
 					return
 				}