From 2b4bb35b208176bae864dc67ab3a65530f0ee933 Mon Sep 17 00:00:00 2001 From: vadim Date: Mon, 22 Sep 2025 12:28:49 +0200 Subject: [PATCH 1/6] feat: add build tag nometrics and centralize Prometheus imports Introduced a nometrics build tag with two alternative implementations: a no-op stub when metrics are disabled and the full Prometheus-backed implementation when enabled. Removed scattered Prometheus imports across the codebase. Centralized all metric definitions and Prometheus types under pkg/metrics with local aliases to ensure the rest of the project depends only on this package. This makes it possible to build and run the project without pulling in Prometheus (via -tags nometrics), while keeping metrics fully functional by default and isolating Prometheus-specific code in a single place. --- .gitignore | 1 + go.mod | 2 +- pkg/accounting/metrics.go | 91 +++++---- pkg/api/api.go | 4 +- pkg/api/metrics.go | 52 +++--- pkg/api/router.go | 6 +- pkg/hive/metrics.go | 51 +++-- pkg/log/logger.go | 3 +- pkg/log/metrics.go | 21 +-- pkg/metrics/collectors.go | 26 +++ pkg/metrics/metrics.go | 95 ++++++++-- pkg/metrics/metrics_test.go | 32 ++-- pkg/metrics/noop.go | 175 ++++++++++++++++++ pkg/metrics/types.go | 109 +++++++++++ pkg/node/chain.go | 4 +- pkg/node/metrics.go | 23 ++- pkg/node/node.go | 16 +- pkg/node/statestore.go | 2 +- pkg/p2p/libp2p/internal/handshake/metrics.go | 31 ++-- pkg/p2p/libp2p/internal/reacher/metrics.go | 11 +- pkg/p2p/libp2p/libp2p.go | 12 +- pkg/p2p/libp2p/metrics.go | 63 ++++--- pkg/pingpong/metrics.go | 19 +- pkg/postage/batchstore/metrics.go | 15 +- pkg/postage/listener/listener.go | 4 +- pkg/postage/listener/metrics.go | 47 +++-- pkg/pss/metrics.go | 11 +- pkg/puller/metrics.go | 23 ++- pkg/pullsync/metrics.go | 49 +++-- pkg/pusher/metrics.go | 25 ++- pkg/pushsync/metrics.go | 79 ++++---- pkg/retrieval/metrics.go | 52 +++--- pkg/salud/metrics.go | 47 +++-- pkg/settlement/pseudosettle/metrics.go | 27 ++- pkg/settlement/swap/metrics.go | 27 ++- pkg/sharky/metrics.go | 59 +++--- pkg/shed/metrics.go | 51 +++-- pkg/status/status.go | 21 +-- pkg/status/status_test.go | 3 + pkg/storage/cache/metrics.go | 11 +- pkg/storageincentives/metrics.go | 67 ++++--- pkg/storer/internal/transaction/metrics.go | 13 +- .../internal/transaction/transaction.go | 9 +- pkg/storer/metrics.go | 95 +++++----- pkg/storer/storer.go | 23 ++- pkg/topology/kademlia/metrics.go | 91 +++++---- pkg/topology/lightnode/metrics.go | 15 +- pkg/transaction/wrapped/metrics.go | 63 ++++--- 48 files changed, 1060 insertions(+), 716 deletions(-) create mode 100644 pkg/metrics/collectors.go create mode 100644 pkg/metrics/noop.go create mode 100644 pkg/metrics/types.go diff --git a/.gitignore b/.gitignore index b7b0629ab25..c30463f8e68 100644 --- a/.gitignore +++ b/.gitignore @@ -2,6 +2,7 @@ /.idea /.vscode /tmp +vendor # Compiled Object files, Static and Dynamic libs (Shared Objects) *.o diff --git a/go.mod b/go.mod index dfd5fbd4a5e..bbd9c8f1f84 100644 --- a/go.mod +++ b/go.mod @@ -141,7 +141,7 @@ require ( github.com/pelletier/go-toml v1.8.0 // indirect github.com/pkg/errors v0.9.1 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect - github.com/prometheus/client_model v0.6.1 // indirect + github.com/prometheus/client_model v0.6.1 github.com/prometheus/common v0.62.0 github.com/prometheus/procfs v0.15.1 // indirect github.com/prometheus/statsd_exporter v0.22.7 // indirect diff --git a/pkg/accounting/metrics.go b/pkg/accounting/metrics.go index e38bdbbd989..18cba809866 100644 --- a/pkg/accounting/metrics.go +++ b/pkg/accounting/metrics.go @@ -6,169 +6,168 @@ package accounting import ( m "github.com/ethersphere/bee/v2/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 - TotalDebitedAmount prometheus.Counter - TotalCreditedAmount prometheus.Counter - DebitEventsCount prometheus.Counter - CreditEventsCount prometheus.Counter - AccountingDisconnectsEnforceRefreshCount prometheus.Counter - AccountingRefreshAttemptCount prometheus.Counter - AccountingNonFatalRefreshFailCount prometheus.Counter - AccountingDisconnectsOverdrawCount prometheus.Counter - AccountingDisconnectsGhostOverdrawCount prometheus.Counter - AccountingDisconnectsReconnectCount prometheus.Counter - AccountingBlocksCount prometheus.Counter - AccountingReserveCount prometheus.Counter - TotalOriginatedCreditedAmount prometheus.Counter - OriginatedCreditEventsCount prometheus.Counter - SettleErrorCount prometheus.Counter - PaymentAttemptCount prometheus.Counter - PaymentErrorCount prometheus.Counter - ErrTimeOutOfSyncAlleged prometheus.Counter - ErrTimeOutOfSyncRecent prometheus.Counter - ErrTimeOutOfSyncInterval prometheus.Counter - ErrRefreshmentBelowExpected prometheus.Counter - ErrRefreshmentAboveExpected prometheus.Counter + TotalDebitedAmount m.Counter + TotalCreditedAmount m.Counter + DebitEventsCount m.Counter + CreditEventsCount m.Counter + AccountingDisconnectsEnforceRefreshCount m.Counter + AccountingRefreshAttemptCount m.Counter + AccountingNonFatalRefreshFailCount m.Counter + AccountingDisconnectsOverdrawCount m.Counter + AccountingDisconnectsGhostOverdrawCount m.Counter + AccountingDisconnectsReconnectCount m.Counter + AccountingBlocksCount m.Counter + AccountingReserveCount m.Counter + TotalOriginatedCreditedAmount m.Counter + OriginatedCreditEventsCount m.Counter + SettleErrorCount m.Counter + PaymentAttemptCount m.Counter + PaymentErrorCount m.Counter + ErrTimeOutOfSyncAlleged m.Counter + ErrTimeOutOfSyncRecent m.Counter + ErrTimeOutOfSyncInterval m.Counter + ErrRefreshmentBelowExpected m.Counter + ErrRefreshmentAboveExpected m.Counter } func newMetrics() metrics { subsystem := "accounting" return metrics{ - TotalDebitedAmount: prometheus.NewCounter(prometheus.CounterOpts{ + TotalDebitedAmount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_debited_amount", Help: "Amount of BZZ debited to peers (potential income of the node)", }), - TotalCreditedAmount: prometheus.NewCounter(prometheus.CounterOpts{ + TotalCreditedAmount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_credited_amount", Help: "Amount of BZZ credited to peers (potential cost of the node)", }), - DebitEventsCount: prometheus.NewCounter(prometheus.CounterOpts{ + DebitEventsCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "debit_events_count", Help: "Number of occurrences of BZZ debit events towards peers", }), - CreditEventsCount: prometheus.NewCounter(prometheus.CounterOpts{ + CreditEventsCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "credit_events_count", Help: "Number of occurrences of BZZ credit events towards peers", }), - AccountingDisconnectsEnforceRefreshCount: prometheus.NewCounter(prometheus.CounterOpts{ + AccountingDisconnectsEnforceRefreshCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "disconnects_enforce_refresh_count", Help: "Number of occurrences of peers disconnected based on failed refreshment attempts", }), - AccountingRefreshAttemptCount: prometheus.NewCounter(prometheus.CounterOpts{ + AccountingRefreshAttemptCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "refresh_attempt_count", Help: "Number of attempts of refresh op", }), - AccountingNonFatalRefreshFailCount: prometheus.NewCounter(prometheus.CounterOpts{ + AccountingNonFatalRefreshFailCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "non_fatal_refresh_fail_count", Help: "Number of occurrences of refreshments failing for peers because of peer timestamp ahead of ours", }), - AccountingDisconnectsOverdrawCount: prometheus.NewCounter(prometheus.CounterOpts{ + AccountingDisconnectsOverdrawCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "disconnects_overdraw_count", Help: "Number of occurrences of peers disconnected based on payment thresholds", }), - AccountingDisconnectsGhostOverdrawCount: prometheus.NewCounter(prometheus.CounterOpts{ + AccountingDisconnectsGhostOverdrawCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "disconnects_ghost_overdraw_count", Help: "Number of occurrences of peers disconnected based on undebitable requests thresholds", }), - AccountingDisconnectsReconnectCount: prometheus.NewCounter(prometheus.CounterOpts{ + AccountingDisconnectsReconnectCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "disconnects_reconnect_count", Help: "Number of occurrences of peers disconnected based on early attempt to reconnect", }), - AccountingBlocksCount: prometheus.NewCounter(prometheus.CounterOpts{ + AccountingBlocksCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "accounting_blocks_count", Help: "Number of occurrences of temporarily skipping a peer to avoid crossing their disconnect thresholds", }), - AccountingReserveCount: prometheus.NewCounter(prometheus.CounterOpts{ + AccountingReserveCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "accounting_reserve_count", Help: "Number of reserve calls", }), - TotalOriginatedCreditedAmount: prometheus.NewCounter(prometheus.CounterOpts{ + TotalOriginatedCreditedAmount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_originated_credited_amount", Help: "Amount of BZZ credited to peers (potential cost of the node) for originated traffic", }), - OriginatedCreditEventsCount: prometheus.NewCounter(prometheus.CounterOpts{ + OriginatedCreditEventsCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "originated_credit_events_count", Help: "Number of occurrences of BZZ credit events as originator towards peers", }), - SettleErrorCount: prometheus.NewCounter(prometheus.CounterOpts{ + SettleErrorCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "settle_error_count", Help: "Number of errors occurring in settle method", }), - PaymentErrorCount: prometheus.NewCounter(prometheus.CounterOpts{ + PaymentErrorCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "payment_error_count", Help: "Number of errors occurring during payment op", }), - PaymentAttemptCount: prometheus.NewCounter(prometheus.CounterOpts{ + PaymentAttemptCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "payment_attempt_count", Help: "Number of attempts of payment op", }), - ErrRefreshmentBelowExpected: prometheus.NewCounter(prometheus.CounterOpts{ + ErrRefreshmentBelowExpected: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "refreshment_below_expected", Help: "Number of times the peer received a refreshment that is below expected", }), - ErrRefreshmentAboveExpected: prometheus.NewCounter(prometheus.CounterOpts{ + ErrRefreshmentAboveExpected: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "refreshment_above_expected", Help: "Number of times the peer received a refreshment that is above expected", }), - ErrTimeOutOfSyncAlleged: prometheus.NewCounter(prometheus.CounterOpts{ + ErrTimeOutOfSyncAlleged: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "time_out_of_sync_alleged", Help: "Number of times the timestamps from peer were decreasing", }), - ErrTimeOutOfSyncRecent: prometheus.NewCounter(prometheus.CounterOpts{ + ErrTimeOutOfSyncRecent: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "time_out_of_sync_recent", Help: "Number of times the timestamps from peer differed from our measurement by more than 2 seconds", }), - ErrTimeOutOfSyncInterval: prometheus.NewCounter(prometheus.CounterOpts{ + ErrTimeOutOfSyncInterval: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "time_out_of_sync_interval", @@ -178,6 +177,6 @@ func newMetrics() metrics { } // Metrics returns the prometheus Collector for the accounting service. -func (a *Accounting) Metrics() []prometheus.Collector { +func (a *Accounting) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(a.metrics) } diff --git a/pkg/api/api.go b/pkg/api/api.go index e3419ccdb38..cddf2d0bc78 100644 --- a/pkg/api/api.go +++ b/pkg/api/api.go @@ -36,6 +36,7 @@ import ( "github.com/ethersphere/bee/v2/pkg/gsoc" "github.com/ethersphere/bee/v2/pkg/jsonhttp" "github.com/ethersphere/bee/v2/pkg/log" + m "github.com/ethersphere/bee/v2/pkg/metrics" "github.com/ethersphere/bee/v2/pkg/p2p" "github.com/ethersphere/bee/v2/pkg/pingpong" "github.com/ethersphere/bee/v2/pkg/postage" @@ -62,7 +63,6 @@ import ( "github.com/go-playground/validator/v10" "github.com/gorilla/mux" "github.com/hashicorp/go-multierror" - "github.com/prometheus/client_golang/prometheus" "golang.org/x/sync/semaphore" ) @@ -164,7 +164,7 @@ type Service struct { accesscontrol accesscontrol.Controller postageContract postagecontract.Interface probe *Probe - metricsRegistry *prometheus.Registry + metricsRegistry m.MetricsRegistererGatherer stakingContract staking.Contract Options diff --git a/pkg/api/metrics.go b/pkg/api/metrics.go index 4f27142dfab..0a1cfcc8164 100644 --- a/pkg/api/metrics.go +++ b/pkg/api/metrics.go @@ -11,8 +11,6 @@ import ( "github.com/ethersphere/bee/v2" m "github.com/ethersphere/bee/v2/pkg/metrics" - "github.com/prometheus/client_golang/prometheus" - "github.com/prometheus/client_golang/prometheus/collectors" ) const bytesInKB = 1000 @@ -23,35 +21,35 @@ type metrics struct { // all metrics fields must be exported // to be able to return them by Metrics() // using reflection - RequestCount prometheus.Counter - ResponseDuration prometheus.Histogram - PingRequestCount prometheus.Counter - ResponseCodeCounts *prometheus.CounterVec + RequestCount m.Counter + ResponseDuration m.Histogram + PingRequestCount m.Counter + ResponseCodeCounts m.CounterMetricVector - ContentApiDuration *prometheus.HistogramVec - UploadSpeed *prometheus.HistogramVec - DownloadSpeed *prometheus.HistogramVec + ContentApiDuration m.HistogramMetricVector + UploadSpeed m.HistogramMetricVector + DownloadSpeed m.HistogramMetricVector } func newMetrics() metrics { subsystem := "api" return metrics{ - RequestCount: prometheus.NewCounter(prometheus.CounterOpts{ + RequestCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "request_count", Help: "Number of API requests.", }), - ResponseDuration: prometheus.NewHistogram(prometheus.HistogramOpts{ + ResponseDuration: m.NewHistogram(m.HistogramOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "response_duration_seconds", Help: "Histogram of API response durations.", Buckets: []float64{0.01, 0.1, 0.25, 0.5, 1, 2.5, 5, 10}, }), - ResponseCodeCounts: prometheus.NewCounterVec( - prometheus.CounterOpts{ + ResponseCodeCounts: m.NewCounterVec( + m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "response_code_count", @@ -59,21 +57,21 @@ func newMetrics() metrics { }, []string{"code", "method"}, ), - ContentApiDuration: prometheus.NewHistogramVec(prometheus.HistogramOpts{ + ContentApiDuration: m.NewHistogramVec(m.HistogramOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "content_api_duration", Help: "Histogram of file upload API response durations.", Buckets: []float64{0.5, 1, 2.5, 5, 10, 30, 60}, }, []string{"filesize", "method"}), - UploadSpeed: prometheus.NewHistogramVec(prometheus.HistogramOpts{ + UploadSpeed: m.NewHistogramVec(m.HistogramOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "upload_speed", Help: "Histogram of upload speed in B/s.", Buckets: []float64{0.25, 0.5, 0.75, 1, 1.25, 1.5, 1.75, 2, 2.5, 3, 4, 5}, }, []string{"endpoint", "mode"}), - DownloadSpeed: prometheus.NewHistogramVec(prometheus.HistogramOpts{ + DownloadSpeed: m.NewHistogramVec(m.HistogramOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "download_speed", @@ -94,13 +92,13 @@ func toFileSizeBucket(bytes int64) int64 { return fileSizeBucketsKBytes[len(fileSizeBucketsKBytes)-1] * bytesInKB } -func (s *Service) Metrics() []prometheus.Collector { +func (s *Service) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(s.metrics) } // StatusMetrics exposes metrics that are exposed on the status protocol. -func (s *Service) StatusMetrics() []prometheus.Collector { - return []prometheus.Collector{ +func (s *Service) StatusMetrics() []m.Collector { + return []m.Collector{ s.metrics.UploadSpeed, s.metrics.DownloadSpeed, } @@ -166,20 +164,20 @@ func (rw *responseWriter) WriteHeader(code int) { rw.wroteHeader = true } -func newDebugMetrics() (r *prometheus.Registry) { - r = prometheus.NewRegistry() +func newDebugMetrics() (r m.MetricsRegistererGatherer) { + r = m.NewRegistry() // register standard metrics r.MustRegister( - collectors.NewProcessCollector(collectors.ProcessCollectorOpts{ + m.NewProcessCollector(m.ProcessCollectorOpts{ Namespace: m.Namespace, }), - collectors.NewGoCollector(), - prometheus.NewGauge(prometheus.GaugeOpts{ + m.NewGoCollector(), + m.NewGauge(m.GaugeOpts{ Namespace: m.Namespace, Name: "info", Help: "Bee information.", - ConstLabels: prometheus.Labels{ + ConstLabels: m.Labels{ "version": bee.Version, }, }), @@ -188,10 +186,10 @@ func newDebugMetrics() (r *prometheus.Registry) { return r } -func (s *Service) MetricsRegistry() *prometheus.Registry { +func (s *Service) MetricsRegistry() m.MetricsRegistererGatherer { return s.metricsRegistry } -func (s *Service) MustRegisterMetrics(cs ...prometheus.Collector) { +func (s *Service) MustRegisterMetrics(cs ...m.Collector) { s.metricsRegistry.MustRegister(cs...) } diff --git a/pkg/api/router.go b/pkg/api/router.go index 13a782bcd77..6b286fd3467 100644 --- a/pkg/api/router.go +++ b/pkg/api/router.go @@ -13,11 +13,11 @@ import ( "github.com/ethersphere/bee/v2/pkg/jsonhttp" "github.com/ethersphere/bee/v2/pkg/log/httpaccess" + m "github.com/ethersphere/bee/v2/pkg/metrics" "github.com/ethersphere/bee/v2/pkg/swarm" "github.com/felixge/fgprof" "github.com/gorilla/handlers" "github.com/gorilla/mux" - "github.com/prometheus/client_golang/prometheus/promhttp" "resenje.org/web" ) @@ -126,9 +126,9 @@ func (s *Service) mountTechnicalDebug() { s.router.Path("/metrics").Handler(web.ChainHandlers( httpaccess.NewHTTPAccessSuppressLogHandler(), - web.FinalHandler(promhttp.InstrumentMetricHandler( + web.FinalHandler(m.InstrumentMetricHandler( s.metricsRegistry, - promhttp.HandlerFor(s.metricsRegistry, promhttp.HandlerOpts{}), + m.HandlerFor(s.metricsRegistry, m.HandlerOpts{}), )), )) diff --git a/pkg/hive/metrics.go b/pkg/hive/metrics.go index 62e9f5e482b..7d3da10cf78 100644 --- a/pkg/hive/metrics.go +++ b/pkg/hive/metrics.go @@ -6,98 +6,97 @@ package hive import ( m "github.com/ethersphere/bee/v2/pkg/metrics" - "github.com/prometheus/client_golang/prometheus" ) type metrics struct { - BroadcastPeers prometheus.Counter - BroadcastPeersPeers prometheus.Counter - BroadcastPeersSends prometheus.Counter + BroadcastPeers m.Counter + BroadcastPeersPeers m.Counter + BroadcastPeersSends m.Counter - PeersHandler prometheus.Counter - PeersHandlerPeers prometheus.Counter - UnreachablePeers prometheus.Counter + PeersHandler m.Counter + PeersHandlerPeers m.Counter + UnreachablePeers m.Counter - PingTime prometheus.Histogram - PingFailureTime prometheus.Histogram + PingTime m.Histogram + PingFailureTime m.Histogram - PeerConnectAttempts prometheus.Counter - PeerUnderlayErr prometheus.Counter - StorePeerErr prometheus.Counter - ReachablePeers prometheus.Counter + PeerConnectAttempts m.Counter + PeerUnderlayErr m.Counter + StorePeerErr m.Counter + ReachablePeers m.Counter } func newMetrics() metrics { subsystem := "hive" return metrics{ - BroadcastPeers: prometheus.NewCounter(prometheus.CounterOpts{ + BroadcastPeers: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "broadcast_peers_count", Help: "Number of calls to broadcast peers.", }), - BroadcastPeersPeers: prometheus.NewCounter(prometheus.CounterOpts{ + BroadcastPeersPeers: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "broadcast_peers_peer_count", Help: "Number of peers to be sent.", }), - BroadcastPeersSends: prometheus.NewCounter(prometheus.CounterOpts{ + BroadcastPeersSends: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "broadcast_peers_message_count", Help: "Number of individual peer gossip messages sent.", }), - PeersHandler: prometheus.NewCounter(prometheus.CounterOpts{ + PeersHandler: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "peers_handler_count", Help: "Number of peer messages received.", }), - PeersHandlerPeers: prometheus.NewCounter(prometheus.CounterOpts{ + PeersHandlerPeers: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "peers_handler_peers_count", Help: "Number of peers received in peer messages.", }), - UnreachablePeers: prometheus.NewCounter(prometheus.CounterOpts{ + UnreachablePeers: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "unreachable_peers_count", Help: "Number of peers that are unreachable.", }), - PingTime: prometheus.NewHistogram(prometheus.HistogramOpts{ + PingTime: m.NewHistogram(m.HistogramOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "ping_time", Help: "The time spent for pings.", }), - PingFailureTime: prometheus.NewHistogram(prometheus.HistogramOpts{ + PingFailureTime: m.NewHistogram(m.HistogramOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "fail_ping_time", Help: "The time spent for unsuccessful pings.", }), - PeerConnectAttempts: prometheus.NewCounter(prometheus.CounterOpts{ + PeerConnectAttempts: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "peer_attempt_count", Help: "Number of attempts made to check peer reachability.", }), - PeerUnderlayErr: prometheus.NewCounter(prometheus.CounterOpts{ + PeerUnderlayErr: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "peer_underlay_err_count", Help: "Number of errors extracting peer underlay.", }), - StorePeerErr: prometheus.NewCounter(prometheus.CounterOpts{ + StorePeerErr: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "store_peer_err_count", Help: "Number of peers that could not be stored.", }), - ReachablePeers: prometheus.NewCounter(prometheus.CounterOpts{ + ReachablePeers: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "reachable_peers_count", @@ -106,6 +105,6 @@ func newMetrics() metrics { } } -func (s *Service) Metrics() []prometheus.Collector { +func (s *Service) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(s.metrics) } diff --git a/pkg/log/logger.go b/pkg/log/logger.go index f40ffd59916..e4b4daec54b 100644 --- a/pkg/log/logger.go +++ b/pkg/log/logger.go @@ -15,7 +15,6 @@ import ( m "github.com/ethersphere/bee/v2/pkg/metrics" "github.com/hashicorp/go-multierror" - "github.com/prometheus/client_golang/prometheus" ) var _ Logger = (*logger)(nil) @@ -166,7 +165,7 @@ type logger struct { } // Metrics implements metrics.Collector interface. -func (l *logger) Metrics() []prometheus.Collector { +func (l *logger) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(l.metrics) } diff --git a/pkg/log/metrics.go b/pkg/log/metrics.go index 2691868921a..27a6cf94c3b 100644 --- a/pkg/log/metrics.go +++ b/pkg/log/metrics.go @@ -6,16 +6,15 @@ package log import ( m "github.com/ethersphere/bee/v2/pkg/metrics" - "github.com/prometheus/client_golang/prometheus" ) // metrics groups various metrics counters for statistical reasons. type metrics struct { - ErrorCount prometheus.Counter - WarnCount prometheus.Counter - InfoCount prometheus.Counter - DebugCount prometheus.Counter - TraceCount prometheus.Counter + ErrorCount m.Counter + WarnCount m.Counter + InfoCount m.Counter + DebugCount m.Counter + TraceCount m.Counter } // Fire implements Hook interface. @@ -40,31 +39,31 @@ func newLogMetrics() *metrics { const subsystem = "log" return &metrics{ - ErrorCount: prometheus.NewCounter(prometheus.CounterOpts{ + ErrorCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "error_count", Help: "Number ERROR log messages.", }), - WarnCount: prometheus.NewCounter(prometheus.CounterOpts{ + WarnCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "warn_count", Help: "Number WARN log messages.", }), - InfoCount: prometheus.NewCounter(prometheus.CounterOpts{ + InfoCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "info_count", Help: "Number INFO log messages.", }), - DebugCount: prometheus.NewCounter(prometheus.CounterOpts{ + DebugCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "debug_count", Help: "Number DEBUG log messages.", }), - TraceCount: prometheus.NewCounter(prometheus.CounterOpts{ + TraceCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "trace_count", diff --git a/pkg/metrics/collectors.go b/pkg/metrics/collectors.go new file mode 100644 index 00000000000..9f5f799209d --- /dev/null +++ b/pkg/metrics/collectors.go @@ -0,0 +1,26 @@ +// 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 metrics + +import ( + "reflect" +) + +func PrometheusCollectorsFromFields(i interface{}) (cs []Collector) { + v := reflect.Indirect(reflect.ValueOf(i)) + for i := 0; i < v.NumField(); i++ { + if !v.Field(i).CanInterface() { + continue + } + + u, ok := v.Field(i).Interface().(Collector) + if !ok { + continue + } + cs = append(cs, u) + + } + return cs +} diff --git a/pkg/metrics/metrics.go b/pkg/metrics/metrics.go index cbe2ae20c58..bcd9fcd8e68 100644 --- a/pkg/metrics/metrics.go +++ b/pkg/metrics/metrics.go @@ -2,31 +2,94 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build !nometrics +// +build !nometrics + package metrics import ( - "reflect" + "fmt" + "io" + "net/http" + exporter "contrib.go.opencensus.io/exporter/prometheus" "github.com/prometheus/client_golang/prometheus" + "github.com/prometheus/client_golang/prometheus/collectors" + "github.com/prometheus/client_golang/prometheus/promhttp" + "github.com/prometheus/common/expfmt" ) -// Namespace is prefixed before every metric. If it is changed, it must be done -// before any metrics collector is registered. -var Namespace = "bee" +func NewCounter(opts CounterOpts) Counter { + return prometheus.NewCounter(opts) +} + +func NewEncoder(w io.Writer, format expfmt.Format, options ...expfmt.EncoderOption) expfmt.Encoder { + return expfmt.NewEncoder(w, format, options...) +} + +func NewFormat(t expfmt.FormatType) expfmt.Format { + return expfmt.NewFormat(t) +} + +func NewGoCollector() Collector { + return collectors.NewGoCollector() +} + +func NewGaugeVec(opts GaugeOpts, names []string) GaugeMetricVector { + return prometheus.NewGaugeVec(opts, names) +} +func NewGauge(opts GaugeOpts) Gauge { + return prometheus.NewGauge(opts) +} + +func NewHistogram(opts HistogramOpts) Histogram { + return prometheus.NewHistogram(opts) +} + +func NewHistogramVec(opts HistogramOpts, names []string) HistogramMetricVector { + return prometheus.NewHistogramVec(opts, names) +} -type Collector interface { - Metrics() []prometheus.Collector +func NewCounterVec(opts CounterOpts, names []string) CounterMetricVector { + return prometheus.NewCounterVec(opts, names) } -func PrometheusCollectorsFromFields(i interface{}) (cs []prometheus.Collector) { - v := reflect.Indirect(reflect.ValueOf(i)) - for i := 0; i < v.NumField(); i++ { - if !v.Field(i).CanInterface() { - continue - } - if u, ok := v.Field(i).Interface().(prometheus.Collector); ok { - cs = append(cs, u) - } +func NewRegistry() MetricsRegistererGatherer { + return prometheus.NewRegistry() +} + +func NewProcessCollector(opts ProcessCollectorOpts) Collector { + return collectors.NewProcessCollector(opts) +} + +func NewSummary(opts SummaryOpts) Summary { + return prometheus.NewSummary(opts) +} + +func InstrumentMetricHandler(reg MetricsRegistererGatherer, handler http.Handler) http.Handler { + return promhttp.InstrumentMetricHandler(reg, handler) +} + +func HandlerFor(reg MetricsRegistererGatherer, opts HandlerOpts) http.Handler { + return promhttp.HandlerFor(reg, opts) +} + +func NewExporter(o ExporterOptions) error { + if o.Registry == nil { + return ErrNilRegistry + } + r, ok := o.Registry.(*prometheus.Registry) + if !ok { + return fmt.Errorf("invalid exporter type: %T", o.Registry) } - return cs + opts := exporter.Options{ + Namespace: o.Namespace, + Registry: r, + } + _, err := exporter.NewExporter(opts) + return err +} + +func MustRegister(cs ...Collector) { + prometheus.MustRegister(cs...) } diff --git a/pkg/metrics/metrics_test.go b/pkg/metrics/metrics_test.go index 65029836e69..a71be9305b1 100644 --- a/pkg/metrics/metrics_test.go +++ b/pkg/metrics/metrics_test.go @@ -2,32 +2,34 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build !nometrics +// +build !nometrics + package metrics_test import ( "strings" "testing" - "github.com/ethersphere/bee/v2/pkg/metrics" - "github.com/prometheus/client_golang/prometheus" + m "github.com/ethersphere/bee/v2/pkg/metrics" ) func TestPrometheusCollectorsFromFields(t *testing.T) { t.Parallel() s := newService() - collectors := metrics.PrometheusCollectorsFromFields(s) + collectors := m.PrometheusCollectorsFromFields(s) if l := len(collectors); l != 2 { t.Fatalf("got %v collectors %+v, want 2", l, collectors) } - m1 := collectors[0].(prometheus.Metric).Desc().String() + m1 := collectors[0].(m.Metric).Desc().String() if !strings.Contains(m1, "api_request_count") { t.Errorf("unexpected metric %s", m1) } - m2 := collectors[1].(prometheus.Metric).Desc().String() + m2 := collectors[1].(m.Metric).Desc().String() if !strings.Contains(m2, "api_response_duration_seconds") { t.Errorf("unexpected metric %s", m2) } @@ -35,31 +37,31 @@ func TestPrometheusCollectorsFromFields(t *testing.T) { type service struct { // valid metrics - RequestCount prometheus.Counter - ResponseDuration prometheus.Histogram + RequestCount m.Counter + ResponseDuration m.Histogram // invalid metrics - unexportedCount prometheus.Counter - UninitializedCount prometheus.Counter + unexportedCount m.Counter + UninitializedCount m.Counter } func newService() *service { subsystem := "api" return &service{ - RequestCount: prometheus.NewCounter(prometheus.CounterOpts{ - Namespace: metrics.Namespace, + RequestCount: m.NewCounter(m.CounterOpts{ + Namespace: m.Namespace, Subsystem: subsystem, Name: "request_count", Help: "Number of API requests.", }), - ResponseDuration: prometheus.NewHistogram(prometheus.HistogramOpts{ - Namespace: metrics.Namespace, + ResponseDuration: m.NewHistogram(m.HistogramOpts{ + Namespace: m.Namespace, Subsystem: subsystem, Name: "response_duration_seconds", Help: "Histogram of API response durations.", Buckets: []float64{0.01, 0.1, 0.25, 0.5, 1, 2.5, 5, 10}, }), - unexportedCount: prometheus.NewCounter(prometheus.CounterOpts{ - Namespace: metrics.Namespace, + unexportedCount: m.NewCounter(m.CounterOpts{ + Namespace: m.Namespace, Subsystem: subsystem, Name: "unexported_count", Help: "This metrics should not be discoverable by metrics.PrometheusCollectorsFromFields.", diff --git a/pkg/metrics/noop.go b/pkg/metrics/noop.go new file mode 100644 index 00000000000..d664f3cdd7e --- /dev/null +++ b/pkg/metrics/noop.go @@ -0,0 +1,175 @@ +//go:build nometrics +// +build nometrics + +// 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 metrics + +import ( + "io" + "net/http" +) + +type counterNoop struct{} + +func (c counterNoop) Desc() *Desc { return &Desc{} } +func (c counterNoop) Write(_ *MetricDTO) error { return nil } +func (c counterNoop) Describe(_ chan<- *Desc) { return } +func (c counterNoop) Collect(_ chan<- Metric) { return } +func (c counterNoop) Inc() { return } +func (c counterNoop) Add(_ float64) { return } + +func NewCounter(_ CounterOpts) Counter { + return &counterNoop{} +} + +var _ CounterMetricVector = (*counterVecNoop)(nil) + +type counterVecNoop struct{} + +func (c counterVecNoop) WithLabelValues(lvs ...string) Counter { + return NewCounter(CounterOpts{}) +} + +func NewCounterVec(opts CounterOpts, names []string) CounterMetricVector { + return &counterVecNoop{} +} + +type gaugeNoop struct{} + +func (g gaugeNoop) Desc() *Desc { return &Desc{} } +func (g gaugeNoop) Write(_ *MetricDTO) error { return nil } +func (g gaugeNoop) Describe(_ chan<- *Desc) { return } +func (g gaugeNoop) Collect(_ chan<- Metric) { return } +func (g gaugeNoop) Set(_ float64) { return } +func (g gaugeNoop) Inc() { return } +func (g gaugeNoop) Dec() { return } +func (g gaugeNoop) Add(_ float64) { return } +func (g gaugeNoop) Sub(_ float64) { return } +func (g gaugeNoop) SetToCurrentTime() { return } + +func NewGauge(_ GaugeOpts) Gauge { + return &gaugeNoop{} +} + +var _ GaugeMetricVector = (*gaugeVecNoop)(nil) + +type gaugeVecNoop struct{} + +func (g gaugeVecNoop) WithLabelValues(lvs ...string) Gauge { + return NewGauge(GaugeOpts{}) +} + +func NewGaugeVec(opts GaugeOpts, names []string) GaugeMetricVector { + return &gaugeVecNoop{} +} + +var _ Histogram = (*histogramNoop)(nil) + +type histogramNoop struct{} + +func (h histogramNoop) Desc() *Desc { return &Desc{} } +func (h histogramNoop) Write(_ *MetricDTO) error { return nil } +func (h histogramNoop) Describe(_ chan<- *Desc) { return } +func (h histogramNoop) Collect(_ chan<- Metric) { return } +func (h histogramNoop) Observe(_ float64) { return } + +func NewHistogram(_ HistogramOpts) Histogram { + return &histogramNoop{} +} + +var _ HistogramMetricVector = (*histogramVecNoop)(nil) + +type histogramVecNoop struct{} + +func (h histogramVecNoop) Describe(descs chan<- *Desc) { return } +func (h histogramVecNoop) Collect(metrics chan<- Metric) { return } +func (h histogramVecNoop) WithLabelValues(lvs ...string) Observer { + return NewHistogram(HistogramOpts{}) +} + +func NewHistogramVec(opts HistogramOpts, names []string) HistogramMetricVector { + return &histogramVecNoop{} +} + +var _ Summary = (*summaryNoop)(nil) + +type summaryNoop struct{} + +func (s summaryNoop) Desc() *Desc { return &Desc{} } +func (s summaryNoop) Write(_ *MetricDTO) error { return nil } +func (s summaryNoop) Describe(_ chan<- *Desc) { return } +func (s summaryNoop) Collect(_ chan<- Metric) { return } +func (s summaryNoop) Observe(_ float64) { return } + +func NewSummary(_ SummaryOpts) Summary { + return &summaryNoop{} +} + +var _ Collector = (*collectorNoop)(nil) + +type collectorNoop struct{} + +func (c collectorNoop) Describe(_ chan<- *Desc) { return } +func (c collectorNoop) Collect(_ chan<- Metric) { return } + +func NewGoCollector() Collector { + return &collectorNoop{} +} + +func NewProcessCollector(opts ProcessCollectorOpts) Collector { + return &collectorNoop{} +} + +var _ MetricsRegistererGatherer = (*registryNoop)(nil) + +type registryNoop struct{} + +func (r registryNoop) Register(collector Collector) error { + return nil +} + +func (r registryNoop) Unregister(collector Collector) bool { + return true +} + +func (r registryNoop) MustRegister(collector ...Collector) { return } +func (r registryNoop) Gather() ([]*MetricFamily, error) { + return []*MetricFamily{}, nil +} + +func NewRegistry() MetricsRegistererGatherer { + return ®istryNoop{} +} + +func NewExporter(o ExporterOptions) error { + return nil +} + +func MustRegister(_ ...Collector) { + // pass +} + +func InstrumentMetricHandler(_ MetricsRegistererGatherer, h http.Handler) http.Handler { + return h +} + +func HandlerFor(_ MetricsRegistererGatherer, _ HandlerOpts) http.Handler { + return http.HandlerFunc(func(_ http.ResponseWriter, _ *http.Request) { return }) +} + +var _ Encoder = (*encoderNoop)(nil) + +type encoderNoop struct{} + +func (e encoderNoop) Encode(family *MetricFamily) error { return nil } + +func NewEncoder(w io.Writer, format Format, options ...EncoderOption) Encoder { + return &encoderNoop{} +} + +func NewFormat(t FormatType) Format { + return `` +} diff --git a/pkg/metrics/types.go b/pkg/metrics/types.go new file mode 100644 index 00000000000..841a57986f8 --- /dev/null +++ b/pkg/metrics/types.go @@ -0,0 +1,109 @@ +// 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 metrics + +import ( + "github.com/prometheus/client_golang/prometheus" + "github.com/prometheus/client_golang/prometheus/collectors" + "github.com/prometheus/client_golang/prometheus/promhttp" + + dto "github.com/prometheus/client_model/go" + "github.com/prometheus/common/expfmt" +) + +type MetricsError string + +func (e MetricsError) Error() string { + return string(e) +} + +const ( + // Namespace is prefixed before every metric. If it is changed, it must be done + // before any metrics collector is registered. + Namespace = "bee" + + TypeTextPlain = expfmt.TypeTextPlain + + ErrNilRegistry = MetricsError("nil registry") +) + +// Prometheus Vector type interfaces +type ( + MetricsCollector interface { + Metrics() []prometheus.Collector + } + + GaugeMetricVector interface { + WithLabelValues(lvs ...string) Gauge + } + + HistogramMetricVector interface { + WithLabelValues(lvs ...string) Observer + Describe(chan<- *Desc) + Collect(chan<- Metric) + } + + CounterMetricVector interface { + WithLabelValues(lvs ...string) Counter + } + + MetricsRegistererGatherer interface { + Gather() ([]*MetricFamily, error) + MetricsRegisterer + } + + MetricsRegisterer interface { + MustRegister(...Collector) + Register(Collector) error + Unregister(Collector) bool + } +) + +// Prometheus types aliases +type ( + Collector = prometheus.Collector + Registry = prometheus.Registry + Observer = prometheus.Observer + Labels = prometheus.Labels + Metric = prometheus.Metric + Desc = prometheus.Desc + + Counter = prometheus.Counter + CounterOpts = prometheus.CounterOpts + CounterVec = CounterMetricVector + + Gauge = prometheus.Gauge + GaugeVec = GaugeMetricVector + GaugeVecOpts = prometheus.GaugeVecOpts + GaugeOpts = prometheus.GaugeOpts + + Histogram = prometheus.Histogram + HistogramOpts = prometheus.HistogramOpts + HistogramVec = HistogramMetricVector + HistogramVecOpts = prometheus.HistogramVecOpts + + Summary = prometheus.Summary + SummaryOpts = prometheus.SummaryOpts + SummaryVec = prometheus.SummaryVec + + ProcessCollectorOpts = collectors.ProcessCollectorOpts + HandlerOpts = promhttp.HandlerOpts + + MetricDTO = dto.Metric + MetricFamily = dto.MetricFamily + + Encoder = expfmt.Encoder + Format = expfmt.Format + FormatType = expfmt.FormatType + EncoderOption = expfmt.EncoderOption +) + +// The goroutine leak `go.opencensus.io/stats/view.(*worker).start` appears solely because of +// importing the `exporter.Options` type from `go.opencensus.io` package +// (either directly or transitively). +type ExporterOptions struct { + Namespace string + Registry MetricsRegistererGatherer +} diff --git a/pkg/node/chain.go b/pkg/node/chain.go index c1f00dd61bc..77ac19d1f17 100644 --- a/pkg/node/chain.go +++ b/pkg/node/chain.go @@ -21,6 +21,7 @@ import ( "github.com/ethersphere/bee/v2/pkg/config" "github.com/ethersphere/bee/v2/pkg/crypto" "github.com/ethersphere/bee/v2/pkg/log" + m "github.com/ethersphere/bee/v2/pkg/metrics" "github.com/ethersphere/bee/v2/pkg/p2p/libp2p" "github.com/ethersphere/bee/v2/pkg/postage/postagecontract" "github.com/ethersphere/bee/v2/pkg/settlement" @@ -32,7 +33,6 @@ import ( "github.com/ethersphere/bee/v2/pkg/storage" "github.com/ethersphere/bee/v2/pkg/transaction" "github.com/ethersphere/bee/v2/pkg/transaction/wrapped" - "github.com/prometheus/client_golang/prometheus" ) const ( @@ -346,7 +346,7 @@ type noOpChainBackend struct { chainID int64 } -func (m noOpChainBackend) Metrics() []prometheus.Collector { +func (m noOpChainBackend) Metrics() []m.Collector { return nil } diff --git a/pkg/node/metrics.go b/pkg/node/metrics.go index a161c39ffe7..b5211c895a3 100644 --- a/pkg/node/metrics.go +++ b/pkg/node/metrics.go @@ -5,24 +5,23 @@ package node import ( - "github.com/ethersphere/bee/v2/pkg/metrics" - "github.com/prometheus/client_golang/prometheus" + m "github.com/ethersphere/bee/v2/pkg/metrics" ) type nodeMetrics struct { // WarmupDuration measures time in seconds for the node warmup to complete - WarmupDuration prometheus.Histogram + WarmupDuration m.Histogram // FullSyncDuration measures time in seconds for the full sync to complete - FullSyncDuration prometheus.Histogram + FullSyncDuration m.Histogram } func newMetrics() nodeMetrics { subsystem := "init" return nodeMetrics{ - WarmupDuration: prometheus.NewHistogram( - prometheus.HistogramOpts{ - Namespace: metrics.Namespace, + WarmupDuration: m.NewHistogram( + m.HistogramOpts{ + Namespace: m.Namespace, Subsystem: subsystem, Name: "warmup_duration_seconds", Help: "Duration in seconds for node warmup to complete", @@ -30,9 +29,9 @@ func newMetrics() nodeMetrics { Buckets: []float64{10, 20, 25, 30, 35, 40, 45, 50, 60, 70, 90, 120, 180, 240, 300, 350, 380, 400, 420, 440, 460, 480, 550, 600}, }, ), - FullSyncDuration: prometheus.NewHistogram( - prometheus.HistogramOpts{ - Namespace: metrics.Namespace, + FullSyncDuration: m.NewHistogram( + m.HistogramOpts{ + Namespace: m.Namespace, Subsystem: subsystem, Name: "full_sync_duration_minutes", Help: "Duration in minutes for node full sync to complete", @@ -45,6 +44,6 @@ func newMetrics() nodeMetrics { } } -func getMetrics(nodeMetrics nodeMetrics) []prometheus.Collector { - return metrics.PrometheusCollectorsFromFields(nodeMetrics) +func getMetrics(nodeMetrics nodeMetrics) []m.Collector { + return m.PrometheusCollectorsFromFields(nodeMetrics) } diff --git a/pkg/node/node.go b/pkg/node/node.go index 67d185a55c5..5f8794a0c9a 100644 --- a/pkg/node/node.go +++ b/pkg/node/node.go @@ -36,6 +36,7 @@ import ( "github.com/ethersphere/bee/v2/pkg/hive" "github.com/ethersphere/bee/v2/pkg/log" "github.com/ethersphere/bee/v2/pkg/metrics" + m "github.com/ethersphere/bee/v2/pkg/metrics" "github.com/ethersphere/bee/v2/pkg/p2p" "github.com/ethersphere/bee/v2/pkg/p2p/libp2p" "github.com/ethersphere/bee/v2/pkg/pingpong" @@ -78,7 +79,6 @@ import ( "github.com/ethersphere/bee/v2/pkg/util/syncutil" "github.com/hashicorp/go-multierror" ma "github.com/multiformats/go-multiaddr" - "github.com/prometheus/client_golang/prometheus" "golang.org/x/crypto/sha3" "golang.org/x/sync/errgroup" ) @@ -648,7 +648,7 @@ func NewBee( } } - var registry *prometheus.Registry + var registry m.MetricsRegistererGatherer if apiService != nil { registry = apiService.MetricsRegistry() @@ -979,7 +979,7 @@ func NewBee( validStamp := postage.ValidStamp(batchStore) // metrics exposed on the status protocol - statusMetricsRegistry := prometheus.NewRegistry() + statusMetricsRegistry := m.NewRegistry() if localStore != nil { statusMetricsRegistry.MustRegister(localStore.StatusMetrics()...) } @@ -1282,20 +1282,20 @@ func NewBee( apiService.MustRegisterMetrics(lightNodes.Metrics()...) apiService.MustRegisterMetrics(hive.Metrics()...) - if bs, ok := batchStore.(metrics.Collector); ok { + if bs, ok := batchStore.(metrics.MetricsCollector); ok { apiService.MustRegisterMetrics(bs.Metrics()...) } - if ls, ok := eventListener.(metrics.Collector); ok { + if ls, ok := eventListener.(metrics.MetricsCollector); ok { apiService.MustRegisterMetrics(ls.Metrics()...) } - if pssServiceMetrics, ok := pssService.(metrics.Collector); ok { + if pssServiceMetrics, ok := pssService.(metrics.MetricsCollector); ok { apiService.MustRegisterMetrics(pssServiceMetrics.Metrics()...) } - if swapBackendMetrics, ok := chainBackend.(metrics.Collector); ok { + if swapBackendMetrics, ok := chainBackend.(metrics.MetricsCollector); ok { apiService.MustRegisterMetrics(swapBackendMetrics.Metrics()...) } - if l, ok := logger.(metrics.Collector); ok { + if l, ok := logger.(metrics.MetricsCollector); ok { apiService.MustRegisterMetrics(l.Metrics()...) } apiService.MustRegisterMetrics(pseudosettleService.Metrics()...) diff --git a/pkg/node/statestore.go b/pkg/node/statestore.go index 626848cf88e..b5009e08b6a 100644 --- a/pkg/node/statestore.go +++ b/pkg/node/statestore.go @@ -21,7 +21,7 @@ import ( // InitStateStore will initialize the stateStore with the given path to the // data directory. When given an empty directory path, the function will instead // initialize an in-memory state store that will not be persisted. -func InitStateStore(logger log.Logger, dataDir string, cacheCapacity uint64) (storage.StateStorerManager, metrics.Collector, error) { +func InitStateStore(logger log.Logger, dataDir string, cacheCapacity uint64) (storage.StateStorerManager, metrics.MetricsCollector, error) { if dataDir == "" { logger.Warning("using in-mem state store, no node state will be persisted") } else { diff --git a/pkg/p2p/libp2p/internal/handshake/metrics.go b/pkg/p2p/libp2p/internal/handshake/metrics.go index c8177d3f93e..0c60d337687 100644 --- a/pkg/p2p/libp2p/internal/handshake/metrics.go +++ b/pkg/p2p/libp2p/internal/handshake/metrics.go @@ -6,17 +6,16 @@ package handshake import ( m "github.com/ethersphere/bee/v2/pkg/metrics" - "github.com/prometheus/client_golang/prometheus" ) -// metrics groups handshake related prometheus counters. +// metrics groups handshake related m counters. type metrics struct { - SynRx prometheus.Counter - SynRxFailed prometheus.Counter - SynAckTx prometheus.Counter - SynAckTxFailed prometheus.Counter - AckRx prometheus.Counter - AckRxFailed prometheus.Counter + SynRx m.Counter + SynRxFailed m.Counter + SynAckTx m.Counter + SynAckTxFailed m.Counter + AckRx m.Counter + AckRxFailed m.Counter } // newMetrics is a convenient constructor for creating new metrics. @@ -24,37 +23,37 @@ func newMetrics() metrics { const subsystem = "handshake" return metrics{ - SynRx: prometheus.NewCounter(prometheus.CounterOpts{ + SynRx: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "syn_rx", Help: "The number of syn messages that were successfully read.", }), - SynRxFailed: prometheus.NewCounter(prometheus.CounterOpts{ + SynRxFailed: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "syn_rx_failed", Help: "The number of syn messages that were unsuccessfully read.", }), - SynAckTx: prometheus.NewCounter(prometheus.CounterOpts{ + SynAckTx: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "syn_ack_tx", Help: "The number of syn-ack messages that were successfully written.", }), - SynAckTxFailed: prometheus.NewCounter(prometheus.CounterOpts{ + SynAckTxFailed: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "syn_ack_tx_failed", Help: "The number of syn-ack messages that were unsuccessfully written.", }), - AckRx: prometheus.NewCounter(prometheus.CounterOpts{ + AckRx: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "ack_rx", Help: "The number of ack messages that were successfully read.", }), - AckRxFailed: prometheus.NewCounter(prometheus.CounterOpts{ + AckRxFailed: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "ack_rx_failed", @@ -63,7 +62,7 @@ func newMetrics() metrics { } } -// Metrics returns set of prometheus collectors. -func (s *Service) Metrics() []prometheus.Collector { +// Metrics returns set of m collectors. +func (s *Service) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(s.metrics) } diff --git a/pkg/p2p/libp2p/internal/reacher/metrics.go b/pkg/p2p/libp2p/internal/reacher/metrics.go index a6019ba4a4e..f8008096a17 100644 --- a/pkg/p2p/libp2p/internal/reacher/metrics.go +++ b/pkg/p2p/libp2p/internal/reacher/metrics.go @@ -6,25 +6,24 @@ package reacher import ( m "github.com/ethersphere/bee/v2/pkg/metrics" - "github.com/prometheus/client_golang/prometheus" ) type metrics struct { - Pings *prometheus.CounterVec - PingTime *prometheus.HistogramVec + Pings m.CounterMetricVector + PingTime m.HistogramMetricVector } func newMetrics() metrics { subsystem := "reacher" return metrics{ - Pings: prometheus.NewCounterVec(prometheus.CounterOpts{ + Pings: m.NewCounterVec(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "pings", Help: "Ping counter.", }, []string{"status"}), - PingTime: prometheus.NewHistogramVec(prometheus.HistogramOpts{ + PingTime: m.NewHistogramVec(m.HistogramOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "ping_timer", @@ -33,6 +32,6 @@ func newMetrics() metrics { } } -func (s *reacher) Metrics() []prometheus.Collector { +func (s *reacher) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(s.metrics) } diff --git a/pkg/p2p/libp2p/libp2p.go b/pkg/p2p/libp2p/libp2p.go index 8020b381708..9735eb1d998 100644 --- a/pkg/p2p/libp2p/libp2p.go +++ b/pkg/p2p/libp2p/libp2p.go @@ -48,14 +48,11 @@ import ( libp2pping "github.com/libp2p/go-libp2p/p2p/protocol/ping" "github.com/libp2p/go-libp2p/p2p/transport/tcp" ws "github.com/libp2p/go-libp2p/p2p/transport/websocket" - ma "github.com/multiformats/go-multiaddr" "github.com/multiformats/go-multistream" "go.uber.org/atomic" - ocprom "contrib.go.opencensus.io/exporter/prometheus" - m2 "github.com/ethersphere/bee/v2/pkg/metrics" - "github.com/prometheus/client_golang/prometheus" + m "github.com/ethersphere/bee/v2/pkg/metrics" ) // loggerName is the tree path name of the logger for this package. @@ -129,7 +126,7 @@ type Options struct { ValidateOverlay bool hostFactory func(...libp2p.Option) (host.Host, error) HeadersRWTimeout time.Duration - Registry *prometheus.Registry + Registry m.MetricsRegistererGatherer } func New(ctx context.Context, signer beecrypto.Signer, networkID uint64, overlay swarm.Address, addr string, ab addressbook.Putter, storer storage.StateStorer, lightNodes *lightnode.Container, logger log.Logger, tracer *tracing.Tracer, o Options) (*Service, error) { @@ -176,9 +173,8 @@ func New(ctx context.Context, signer beecrypto.Signer, networkID uint64, overlay if o.Registry != nil { rcmgr.MustRegisterWith(o.Registry) } - - _, err = ocprom.NewExporter(ocprom.Options{ - Namespace: m2.Namespace, + err = m.NewExporter(m.ExporterOptions{ + Namespace: m.Namespace, Registry: o.Registry, }) if err != nil { diff --git a/pkg/p2p/libp2p/metrics.go b/pkg/p2p/libp2p/metrics.go index 378ec26f6b0..210f6cef4e8 100644 --- a/pkg/p2p/libp2p/metrics.go +++ b/pkg/p2p/libp2p/metrics.go @@ -6,112 +6,111 @@ package libp2p import ( m "github.com/ethersphere/bee/v2/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 - CreatedConnectionCount prometheus.Counter - HandledConnectionCount prometheus.Counter - CreatedStreamCount prometheus.Counter - ClosedStreamCount prometheus.Counter - StreamResetCount prometheus.Counter - HandledStreamCount prometheus.Counter - BlocklistedPeerCount prometheus.Counter - BlocklistedPeerErrCount prometheus.Counter - DisconnectCount prometheus.Counter - ConnectBreakerCount prometheus.Counter - UnexpectedProtocolReqCount prometheus.Counter - KickedOutPeersCount prometheus.Counter - StreamHandlerErrResetCount prometheus.Counter - HeadersExchangeDuration prometheus.Histogram + CreatedConnectionCount m.Counter + HandledConnectionCount m.Counter + CreatedStreamCount m.Counter + ClosedStreamCount m.Counter + StreamResetCount m.Counter + HandledStreamCount m.Counter + BlocklistedPeerCount m.Counter + BlocklistedPeerErrCount m.Counter + DisconnectCount m.Counter + ConnectBreakerCount m.Counter + UnexpectedProtocolReqCount m.Counter + KickedOutPeersCount m.Counter + StreamHandlerErrResetCount m.Counter + HeadersExchangeDuration m.Histogram } func newMetrics() metrics { subsystem := "libp2p" return metrics{ - CreatedConnectionCount: prometheus.NewCounter(prometheus.CounterOpts{ + CreatedConnectionCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "created_connection_count", Help: "Number of initiated outgoing libp2p connections.", }), - HandledConnectionCount: prometheus.NewCounter(prometheus.CounterOpts{ + HandledConnectionCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "handled_connection_count", Help: "Number of handled incoming libp2p connections.", }), - CreatedStreamCount: prometheus.NewCounter(prometheus.CounterOpts{ + CreatedStreamCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "created_stream_count", Help: "Number of initiated outgoing libp2p streams.", }), - ClosedStreamCount: prometheus.NewCounter(prometheus.CounterOpts{ + ClosedStreamCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "closed_stream_count", Help: "Number of closed outgoing libp2p streams.", }), - StreamResetCount: prometheus.NewCounter(prometheus.CounterOpts{ + StreamResetCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "stream_reset_count", Help: "Number of outgoing libp2p streams resets.", }), - HandledStreamCount: prometheus.NewCounter(prometheus.CounterOpts{ + HandledStreamCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "handled_stream_count", Help: "Number of handled incoming libp2p streams.", }), - BlocklistedPeerCount: prometheus.NewCounter(prometheus.CounterOpts{ + BlocklistedPeerCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "blocklisted_peer_count", Help: "Number of peers we've blocklisted.", }), - BlocklistedPeerErrCount: prometheus.NewCounter(prometheus.CounterOpts{ + BlocklistedPeerErrCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "blocklisted_peer_err_count", Help: "Number of peers we've been unable to blocklist.", }), - DisconnectCount: prometheus.NewCounter(prometheus.CounterOpts{ + DisconnectCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "disconnect_count", Help: "Number of peers we've disconnected from (initiated locally).", }), - ConnectBreakerCount: prometheus.NewCounter(prometheus.CounterOpts{ + ConnectBreakerCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "connect_breaker_count", Help: "Number of times we got a closed breaker while connecting to another peer.", }), - UnexpectedProtocolReqCount: prometheus.NewCounter(prometheus.CounterOpts{ + UnexpectedProtocolReqCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "unexpected_protocol_request_count", Help: "Number of requests the peer is not expecting.", }), - KickedOutPeersCount: prometheus.NewCounter(prometheus.CounterOpts{ + KickedOutPeersCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "kickedout_peers_count", Help: "Number of total kicked-out peers.", }), - StreamHandlerErrResetCount: prometheus.NewCounter(prometheus.CounterOpts{ + StreamHandlerErrResetCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "stream_handler_error_reset_count", Help: "Number of total stream handler error resets.", }), - HeadersExchangeDuration: prometheus.NewHistogram(prometheus.HistogramOpts{ + HeadersExchangeDuration: m.NewHistogram(m.HistogramOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "headers_exchange_duration", @@ -120,13 +119,13 @@ func newMetrics() metrics { } } -func (s *Service) Metrics() []prometheus.Collector { +func (s *Service) Metrics() []m.Collector { return append(m.PrometheusCollectorsFromFields(s.metrics), s.handshakeService.Metrics()...) } // StatusMetrics exposes metrics that are exposed on the status protocol. -func (s *Service) StatusMetrics() []prometheus.Collector { - return []prometheus.Collector{ +func (s *Service) StatusMetrics() []m.Collector { + return []m.Collector{ s.metrics.HeadersExchangeDuration, } } diff --git a/pkg/pingpong/metrics.go b/pkg/pingpong/metrics.go index 155b3abdb8e..7cd38937480 100644 --- a/pkg/pingpong/metrics.go +++ b/pkg/pingpong/metrics.go @@ -6,42 +6,41 @@ package pingpong import ( m "github.com/ethersphere/bee/v2/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 - PingSentCount prometheus.Counter - PongSentCount prometheus.Counter - PingReceivedCount prometheus.Counter - PongReceivedCount prometheus.Counter + PingSentCount m.Counter + PongSentCount m.Counter + PingReceivedCount m.Counter + PongReceivedCount m.Counter } func newMetrics() metrics { subsystem := "pingpong" return metrics{ - PingSentCount: prometheus.NewCounter(prometheus.CounterOpts{ + PingSentCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "ping_sent_count", Help: "Number ping requests sent.", }), - PongSentCount: prometheus.NewCounter(prometheus.CounterOpts{ + PongSentCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "pong_sent_count", Help: "Number of pong responses sent.", }), - PingReceivedCount: prometheus.NewCounter(prometheus.CounterOpts{ + PingReceivedCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "ping_received_count", Help: "Number ping requests received.", }), - PongReceivedCount: prometheus.NewCounter(prometheus.CounterOpts{ + PongReceivedCount: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "pong_received_count", @@ -50,6 +49,6 @@ func newMetrics() metrics { } } -func (s *Service) Metrics() []prometheus.Collector { +func (s *Service) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(s.metrics) } diff --git a/pkg/postage/batchstore/metrics.go b/pkg/postage/batchstore/metrics.go index de78aa5ef54..fd7ca9e8c6d 100644 --- a/pkg/postage/batchstore/metrics.go +++ b/pkg/postage/batchstore/metrics.go @@ -6,32 +6,31 @@ package batchstore import ( m "github.com/ethersphere/bee/v2/pkg/metrics" - "github.com/prometheus/client_golang/prometheus" ) type metrics struct { - Commitment prometheus.Gauge - Radius prometheus.Gauge - UnreserveDuration *prometheus.HistogramVec + Commitment m.Gauge + Radius m.Gauge + UnreserveDuration m.HistogramMetricVector } func newMetrics() metrics { subsystem := "batchstore" return metrics{ - Commitment: prometheus.NewGauge(prometheus.GaugeOpts{ + Commitment: m.NewGauge(m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "commitment", Help: "Sum of all batches' commitment.", }), - Radius: prometheus.NewGauge(prometheus.GaugeOpts{ + Radius: m.NewGauge(m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "radius", Help: "Radius of responsibility observed by the batchstore.", }), - UnreserveDuration: prometheus.NewHistogramVec(prometheus.HistogramOpts{ + UnreserveDuration: m.NewHistogramVec(m.HistogramOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "unreserve_duration", @@ -40,6 +39,6 @@ func newMetrics() metrics { } } -func (s *store) Metrics() []prometheus.Collector { +func (s *store) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(s.metrics) } diff --git a/pkg/postage/listener/listener.go b/pkg/postage/listener/listener.go index d9d52b2c5a1..56ef4303a35 100644 --- a/pkg/postage/listener/listener.go +++ b/pkg/postage/listener/listener.go @@ -17,11 +17,11 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/ethersphere/bee/v2/pkg/log" + m "github.com/ethersphere/bee/v2/pkg/metrics" "github.com/ethersphere/bee/v2/pkg/postage" "github.com/ethersphere/bee/v2/pkg/postage/batchservice" "github.com/ethersphere/bee/v2/pkg/transaction" "github.com/ethersphere/bee/v2/pkg/util/syncutil" - "github.com/prometheus/client_golang/prometheus" ) // loggerName is the tree path name of the logger for this package. @@ -413,7 +413,7 @@ type priceUpdateEvent struct { Price *big.Int } -func totalTimeMetric(metric prometheus.Counter, start time.Time) { +func totalTimeMetric(metric m.Counter, start time.Time) { totalTime := time.Since(start) metric.Add(float64(totalTime)) } diff --git a/pkg/postage/listener/metrics.go b/pkg/postage/listener/metrics.go index 8fb7b639884..3045edec1a4 100644 --- a/pkg/postage/listener/metrics.go +++ b/pkg/postage/listener/metrics.go @@ -6,28 +6,27 @@ package listener import ( m "github.com/ethersphere/bee/v2/pkg/metrics" - "github.com/prometheus/client_golang/prometheus" ) type metrics struct { // aggregate events handled - EventsProcessed prometheus.Counter - EventErrors prometheus.Counter - PagesProcessed prometheus.Counter + EventsProcessed m.Counter + EventErrors m.Counter + PagesProcessed m.Counter // individual event counters - CreatedCounter prometheus.Counter - TopupCounter prometheus.Counter - DepthCounter prometheus.Counter - PriceCounter prometheus.Counter + CreatedCounter m.Counter + TopupCounter m.Counter + DepthCounter m.Counter + PriceCounter m.Counter // total calls to chain backend - BackendCalls prometheus.Counter - BackendErrors prometheus.Counter + BackendCalls m.Counter + BackendErrors m.Counter // processing durations - PageProcessDuration prometheus.Counter - EventProcessDuration prometheus.Counter + PageProcessDuration m.Counter + EventProcessDuration m.Counter } func newMetrics() metrics { @@ -35,19 +34,19 @@ func newMetrics() metrics { return metrics{ // aggregate events handled - EventsProcessed: prometheus.NewCounter(prometheus.CounterOpts{ + EventsProcessed: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "events_processed", Help: "total events processed", }), - EventErrors: prometheus.NewCounter(prometheus.CounterOpts{ + EventErrors: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "event_errors", Help: "total event errors while processing", }), - PagesProcessed: prometheus.NewCounter(prometheus.CounterOpts{ + PagesProcessed: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "pages_processed", @@ -55,28 +54,28 @@ func newMetrics() metrics { }), // individual event counters - CreatedCounter: prometheus.NewCounter(prometheus.CounterOpts{ + CreatedCounter: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "created_events", Help: "total batch created events processed", }), - TopupCounter: prometheus.NewCounter(prometheus.CounterOpts{ + TopupCounter: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "topup_events", Help: "total batch topup events handled", }), - DepthCounter: prometheus.NewCounter(prometheus.CounterOpts{ + DepthCounter: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "depth_events", Help: "total batch depth change events handled", }), - PriceCounter: prometheus.NewCounter(prometheus.CounterOpts{ + PriceCounter: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "price_events", @@ -84,13 +83,13 @@ func newMetrics() metrics { }), // total call - BackendCalls: prometheus.NewCounter(prometheus.CounterOpts{ + BackendCalls: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "backend_calls", Help: "total chain backend calls", }), - BackendErrors: prometheus.NewCounter(prometheus.CounterOpts{ + BackendErrors: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "backend_errors", @@ -98,14 +97,14 @@ func newMetrics() metrics { }), // processing durations - PageProcessDuration: prometheus.NewCounter(prometheus.CounterOpts{ + PageProcessDuration: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "page_duration", Help: "how long it took to process a page", }), - EventProcessDuration: prometheus.NewCounter(prometheus.CounterOpts{ + EventProcessDuration: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "event_duration", @@ -114,6 +113,6 @@ func newMetrics() metrics { } } -func (l *listener) Metrics() []prometheus.Collector { +func (l *listener) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(l.metrics) } diff --git a/pkg/pss/metrics.go b/pkg/pss/metrics.go index 108f516215f..20803cf3b50 100644 --- a/pkg/pss/metrics.go +++ b/pkg/pss/metrics.go @@ -6,25 +6,24 @@ package pss import ( m "github.com/ethersphere/bee/v2/pkg/metrics" - "github.com/prometheus/client_golang/prometheus" ) type metrics struct { - TotalMessagesSentCounter prometheus.Counter - MessageMiningDuration prometheus.Gauge + TotalMessagesSentCounter m.Counter + MessageMiningDuration m.Gauge } func newMetrics() metrics { subsystem := "pss" return metrics{ - TotalMessagesSentCounter: prometheus.NewCounter(prometheus.CounterOpts{ + TotalMessagesSentCounter: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_message_sent", Help: "Total messages sent.", }), - MessageMiningDuration: prometheus.NewGauge(prometheus.GaugeOpts{ + MessageMiningDuration: m.NewGauge(m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "mining_duration", @@ -33,6 +32,6 @@ func newMetrics() metrics { } } -func (s *pss) Metrics() []prometheus.Collector { +func (s *pss) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(s.metrics) } diff --git a/pkg/puller/metrics.go b/pkg/puller/metrics.go index bfa546f26e0..5af973da09e 100644 --- a/pkg/puller/metrics.go +++ b/pkg/puller/metrics.go @@ -6,46 +6,45 @@ package puller import ( m "github.com/ethersphere/bee/v2/pkg/metrics" - "github.com/prometheus/client_golang/prometheus" ) type metrics struct { - SyncWorkerIterCounter prometheus.Counter // counts the number of syncing iterations - SyncWorkerCounter prometheus.Gauge // count number of syncing jobs - SyncedCounter *prometheus.CounterVec // number of synced chunks - SyncWorkerErrCounter prometheus.Counter // count number of errors - MaxUintErrCounter prometheus.Counter // how many times we got maxuint as topmost + SyncWorkerIterCounter m.Counter // counts the number of syncing iterations + SyncWorkerCounter m.Gauge // count number of syncing jobs + SyncedCounter m.CounterMetricVector // number of synced chunks + SyncWorkerErrCounter m.Counter // count number of errors + MaxUintErrCounter m.Counter // how many times we got maxuint as topmost } func newMetrics() metrics { subsystem := "puller" return metrics{ - SyncWorkerIterCounter: prometheus.NewCounter(prometheus.CounterOpts{ + SyncWorkerIterCounter: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "worker_iterations", Help: "Total worker iterations.", }), - SyncWorkerCounter: prometheus.NewGauge(prometheus.GaugeOpts{ + SyncWorkerCounter: m.NewGauge(m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "worker", Help: "Total active worker jobs.", }), - SyncedCounter: prometheus.NewCounterVec(prometheus.CounterOpts{ + SyncedCounter: m.NewCounterVec(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "synced_chunks", Help: "Total synced chunks.", }, []string{"type"}), - SyncWorkerErrCounter: prometheus.NewCounter(prometheus.CounterOpts{ + SyncWorkerErrCounter: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "worker_errors", Help: "Total worker errors.", }), - MaxUintErrCounter: prometheus.NewCounter(prometheus.CounterOpts{ + MaxUintErrCounter: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "max_uint_errors", @@ -54,6 +53,6 @@ func newMetrics() metrics { } } -func (p *Puller) Metrics() []prometheus.Collector { +func (p *Puller) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(p.metrics) } diff --git a/pkg/pullsync/metrics.go b/pkg/pullsync/metrics.go index 57e26916c93..b594249de00 100644 --- a/pkg/pullsync/metrics.go +++ b/pkg/pullsync/metrics.go @@ -6,89 +6,88 @@ package pullsync import ( m "github.com/ethersphere/bee/v2/pkg/metrics" - "github.com/prometheus/client_golang/prometheus" ) type metrics struct { - Offered prometheus.Counter // number of chunks offered - Wanted prometheus.Counter // number of chunks wanted - MissingChunks prometheus.Counter // number of reserve get errs - ReceivedZeroAddress prometheus.Counter // number of delivered chunks with invalid address - ReceivedInvalidChunk prometheus.Counter // number of delivered chunks with invalid address - Delivered prometheus.Counter // number of chunk deliveries - SentOffered prometheus.Counter // number of chunks offered - SentWanted prometheus.Counter // number of chunks wanted - Sent prometheus.Counter // number of chunks sent - DuplicateRuid prometheus.Counter // number of duplicate RUID requests we got - LastReceived *prometheus.CounterVec // last timestamp of the received chunks per bin + Offered m.Counter // number of chunks offered + Wanted m.Counter // number of chunks wanted + MissingChunks m.Counter // number of reserve get errs + ReceivedZeroAddress m.Counter // number of delivered chunks with invalid address + ReceivedInvalidChunk m.Counter // number of delivered chunks with invalid address + Delivered m.Counter // number of chunk deliveries + SentOffered m.Counter // number of chunks offered + SentWanted m.Counter // number of chunks wanted + Sent m.Counter // number of chunks sent + DuplicateRuid m.Counter // number of duplicate RUID requests we got + LastReceived m.CounterMetricVector // last timestamp of the received chunks per bin } func newMetrics() metrics { subsystem := "pullsync" return metrics{ - Offered: prometheus.NewCounter(prometheus.CounterOpts{ + Offered: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "chunks_offered", Help: "Total chunks offered.", }), - Wanted: prometheus.NewCounter(prometheus.CounterOpts{ + Wanted: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "chunks_wanted", Help: "Total chunks wanted.", }), - MissingChunks: prometheus.NewCounter(prometheus.CounterOpts{ + MissingChunks: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "missing_chunks", Help: "Total reserve get errors.", }), - ReceivedZeroAddress: prometheus.NewCounter(prometheus.CounterOpts{ + ReceivedZeroAddress: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "received_zero_address", Help: "Total chunks delivered with zero address and no chunk data.", }), - ReceivedInvalidChunk: prometheus.NewCounter(prometheus.CounterOpts{ + ReceivedInvalidChunk: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "received_invalid_chunks", Help: "Total invalid chunks delivered.", }), - Delivered: prometheus.NewCounter(prometheus.CounterOpts{ + Delivered: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "chunks_delivered", Help: "Total chunks delivered.", }), - SentOffered: prometheus.NewCounter(prometheus.CounterOpts{ + SentOffered: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "chunks_sent_offered", Help: "Total chunks offered to peers.", }), - SentWanted: prometheus.NewCounter(prometheus.CounterOpts{ + SentWanted: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "chunks_sent_wanted", Help: "Total chunks wanted by peers.", }), - Sent: prometheus.NewCounter(prometheus.CounterOpts{ + Sent: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "chunks_sent", Help: "Total chunks sent.", }), - DuplicateRuid: prometheus.NewCounter(prometheus.CounterOpts{ + DuplicateRuid: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "duplicate_ruids", Help: "Total duplicate RUIDs.", }), - LastReceived: prometheus.NewCounterVec( - prometheus.CounterOpts{ + LastReceived: m.NewCounterVec( + m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "last_received", @@ -97,6 +96,6 @@ func newMetrics() metrics { } } -func (s *Syncer) Metrics() []prometheus.Collector { +func (s *Syncer) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(s.metrics) } diff --git a/pkg/pusher/metrics.go b/pkg/pusher/metrics.go index 0a92951b42b..c0689906503 100644 --- a/pkg/pusher/metrics.go +++ b/pkg/pusher/metrics.go @@ -6,48 +6,47 @@ package pusher import ( m "github.com/ethersphere/bee/v2/pkg/metrics" - "github.com/prometheus/client_golang/prometheus" ) type metrics struct { - TotalToPush prometheus.Counter - TotalSynced prometheus.Counter - TotalErrors prometheus.Counter - MarkAndSweepTime prometheus.Histogram - SyncTime prometheus.Histogram - ErrorTime prometheus.Histogram + TotalToPush m.Counter + TotalSynced m.Counter + TotalErrors m.Counter + MarkAndSweepTime m.Histogram + SyncTime m.Histogram + ErrorTime m.Histogram } func newMetrics() metrics { subsystem := "pusher" return metrics{ - TotalToPush: prometheus.NewCounter(prometheus.CounterOpts{ + TotalToPush: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_to_push", Help: "Total chunks to push (chunks may be repeated).", }), - TotalSynced: prometheus.NewCounter(prometheus.CounterOpts{ + TotalSynced: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_synced", Help: "Total chunks synced successfully with valid receipts.", }), - TotalErrors: prometheus.NewCounter(prometheus.CounterOpts{ + TotalErrors: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_errors", Help: "Total errors encountered.", }), - SyncTime: prometheus.NewHistogram(prometheus.HistogramOpts{ + SyncTime: m.NewHistogram(m.HistogramOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "sync_time", Help: "Histogram of time spent to sync a chunk.", Buckets: []float64{0.1, 0.25, 0.5, 1, 2.5, 5, 10, 60}, }), - ErrorTime: prometheus.NewHistogram(prometheus.HistogramOpts{ + ErrorTime: m.NewHistogram(m.HistogramOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "error_time", @@ -57,6 +56,6 @@ func newMetrics() metrics { } } -func (s *Service) Metrics() []prometheus.Collector { +func (s *Service) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(s.metrics) } diff --git a/pkg/pushsync/metrics.go b/pkg/pushsync/metrics.go index 7f4f5884bf0..6c6fc0180f6 100644 --- a/pkg/pushsync/metrics.go +++ b/pkg/pushsync/metrics.go @@ -6,124 +6,123 @@ package pushsync import ( m "github.com/ethersphere/bee/v2/pkg/metrics" - "github.com/prometheus/client_golang/prometheus" ) type metrics struct { - TotalSent prometheus.Counter - TotalReceived prometheus.Counter - TotalHandlerErrors prometheus.Counter - TotalRequests prometheus.Counter - TotalSendAttempts prometheus.Counter - TotalFailedSendAttempts prometheus.Counter - TotalOutgoing prometheus.Counter - TotalOutgoingErrors prometheus.Counter - InvalidStampErrors prometheus.Counter - StampValidationTime *prometheus.HistogramVec - Forwarder prometheus.Counter - Storer prometheus.Counter - TotalHandlerTime *prometheus.HistogramVec - PushToPeerTime *prometheus.HistogramVec + TotalSent m.Counter + TotalReceived m.Counter + TotalHandlerErrors m.Counter + TotalRequests m.Counter + TotalSendAttempts m.Counter + TotalFailedSendAttempts m.Counter + TotalOutgoing m.Counter + TotalOutgoingErrors m.Counter + InvalidStampErrors m.Counter + StampValidationTime m.HistogramMetricVector + Forwarder m.Counter + Storer m.Counter + TotalHandlerTime m.HistogramMetricVector + PushToPeerTime m.HistogramMetricVector - ReceiptDepth *prometheus.CounterVec - ShallowReceiptDepth *prometheus.CounterVec - ShallowReceipt prometheus.Counter + ReceiptDepth m.CounterMetricVector + ShallowReceiptDepth m.CounterMetricVector + ShallowReceipt m.Counter } func newMetrics() metrics { subsystem := "pushsync" return metrics{ - TotalSent: prometheus.NewCounter(prometheus.CounterOpts{ + TotalSent: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_sent", Help: "Total chunks sent.", }), - TotalReceived: prometheus.NewCounter(prometheus.CounterOpts{ + TotalReceived: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_received", Help: "Total chunks received.", }), - TotalHandlerErrors: prometheus.NewCounter(prometheus.CounterOpts{ + TotalHandlerErrors: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_handler_errors", Help: "Total no of error occurred while handling an incoming delivery (either while storing or forwarding).", }), - TotalRequests: prometheus.NewCounter(prometheus.CounterOpts{ + TotalRequests: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_requests", Help: "Total no of requests to push a chunk into the network (from origin nodes or not).", }), - TotalSendAttempts: prometheus.NewCounter(prometheus.CounterOpts{ + TotalSendAttempts: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_send_attempts", Help: "Total no of attempts to push chunk.", }), - TotalFailedSendAttempts: prometheus.NewCounter(prometheus.CounterOpts{ + TotalFailedSendAttempts: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_failed_send_attempts", Help: "Total no of failed attempts to push chunk.", }), - TotalOutgoing: prometheus.NewCounter(prometheus.CounterOpts{ + TotalOutgoing: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_outgoing", Help: "Total no of chunks requested to be synced (calls on exported PushChunkToClosest)", }), - TotalOutgoingErrors: prometheus.NewCounter(prometheus.CounterOpts{ + TotalOutgoingErrors: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_outgoing_errors", Help: "Total no of errors of entire operation to sync a chunk (multiple attempts included)", }), - InvalidStampErrors: prometheus.NewCounter(prometheus.CounterOpts{ + InvalidStampErrors: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "invalid_stamps", Help: "No of invalid stamp errors.", }), - StampValidationTime: prometheus.NewHistogramVec(prometheus.HistogramOpts{ + StampValidationTime: m.NewHistogramVec(m.HistogramOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "stamp_validation_time", Help: "Time taken to validate stamps.", }, []string{"status"}), - Forwarder: prometheus.NewCounter(prometheus.CounterOpts{ + Forwarder: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "forwarder", Help: "No of times the peer is a forwarder node.", }), - Storer: prometheus.NewCounter(prometheus.CounterOpts{ + Storer: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "storer", Help: "No of times the peer is a storer node.", }), - TotalHandlerTime: prometheus.NewHistogramVec( - prometheus.HistogramOpts{ + TotalHandlerTime: m.NewHistogramVec( + m.HistogramOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_handler_time", Help: "Histogram for time taken for the handler.", }, []string{"status"}, ), - PushToPeerTime: prometheus.NewHistogramVec( - prometheus.HistogramOpts{ + PushToPeerTime: m.NewHistogramVec( + m.HistogramOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "push_peer_time", Help: "Histogram for time taken to push a chunk to a peer.", }, []string{"status"}, ), - ShallowReceiptDepth: prometheus.NewCounterVec( - prometheus.CounterOpts{ + ShallowReceiptDepth: m.NewCounterVec( + m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "shallow_receipt_depth", @@ -131,14 +130,14 @@ func newMetrics() metrics { }, []string{"depth"}, ), - ShallowReceipt: prometheus.NewCounter(prometheus.CounterOpts{ + ShallowReceipt: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "shallow_receipt", Help: "Total shallow receipts.", }), - ReceiptDepth: prometheus.NewCounterVec( - prometheus.CounterOpts{ + ReceiptDepth: m.NewCounterVec( + m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "receipt_depth", @@ -149,6 +148,6 @@ func newMetrics() metrics { } } -func (s *PushSync) Metrics() []prometheus.Collector { +func (s *PushSync) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(s.metrics) } diff --git a/pkg/retrieval/metrics.go b/pkg/retrieval/metrics.go index f987a75b2d6..a897a10d5ee 100644 --- a/pkg/retrieval/metrics.go +++ b/pkg/retrieval/metrics.go @@ -5,8 +5,6 @@ package retrieval import ( - "github.com/prometheus/client_golang/prometheus" - m "github.com/ethersphere/bee/v2/pkg/metrics" ) @@ -15,84 +13,84 @@ type metrics struct { // to be able to return them by Metrics() // using reflection - RequestCounter prometheus.Counter - RequestSuccessCounter prometheus.Counter - RequestFailureCounter prometheus.Counter - RequestDurationTime prometheus.Histogram - RequestAttempts prometheus.Histogram - PeerRequestCounter prometheus.Counter - TotalRetrieved prometheus.Counter - InvalidChunkRetrieved prometheus.Counter - ChunkPrice prometheus.Summary - TotalErrors prometheus.Counter - ChunkRetrieveTime prometheus.Histogram + RequestCounter m.Counter + RequestSuccessCounter m.Counter + RequestFailureCounter m.Counter + RequestDurationTime m.Histogram + RequestAttempts m.Histogram + PeerRequestCounter m.Counter + TotalRetrieved m.Counter + InvalidChunkRetrieved m.Counter + ChunkPrice m.Summary + TotalErrors m.Counter + ChunkRetrieveTime m.Histogram } func newMetrics() metrics { subsystem := "retrieval" return metrics{ - RequestCounter: prometheus.NewCounter(prometheus.CounterOpts{ + RequestCounter: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "request_count", Help: "Number of requests to retrieve chunks.", }), - RequestSuccessCounter: prometheus.NewCounter(prometheus.CounterOpts{ + RequestSuccessCounter: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "request_success_count", Help: "Number of requests which succeeded to retrieve chunk.", }), - RequestFailureCounter: prometheus.NewCounter(prometheus.CounterOpts{ + RequestFailureCounter: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "request_failure_count", Help: "Number of requests which failed to retrieve chunk.", }), - RequestDurationTime: prometheus.NewHistogram(prometheus.HistogramOpts{ + RequestDurationTime: m.NewHistogram(m.HistogramOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "request_duration_time", Help: "Histogram for time taken to complete retrieval request", }), - RequestAttempts: prometheus.NewHistogram(prometheus.HistogramOpts{ + RequestAttempts: m.NewHistogram(m.HistogramOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "request_attempts", Help: "Histogram for total retrieval attempts pre each request.", }), - PeerRequestCounter: prometheus.NewCounter(prometheus.CounterOpts{ + PeerRequestCounter: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "peer_request_count", Help: "Number of request to single peer.", }), - TotalRetrieved: prometheus.NewCounter(prometheus.CounterOpts{ + TotalRetrieved: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_retrieved", Help: "Total chunks retrieved.", }), - InvalidChunkRetrieved: prometheus.NewCounter(prometheus.CounterOpts{ + InvalidChunkRetrieved: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "invalid_chunk_retrieved", Help: "Invalid chunk retrieved from peer.", }), - ChunkPrice: prometheus.NewSummary(prometheus.SummaryOpts{ + ChunkPrice: m.NewSummary(m.SummaryOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "chunk_price", Help: "The price of the chunk that was paid.", }), - TotalErrors: prometheus.NewCounter(prometheus.CounterOpts{ + TotalErrors: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_errors", Help: "Total number of errors while retrieving chunk.", }), - ChunkRetrieveTime: prometheus.NewHistogram(prometheus.HistogramOpts{ + ChunkRetrieveTime: m.NewHistogram(m.HistogramOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "retrieve_chunk_time", @@ -102,13 +100,13 @@ func newMetrics() metrics { } } -func (s *Service) Metrics() []prometheus.Collector { +func (s *Service) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(s.metrics) } // StatusMetrics exposes metrics that are exposed on the status protocol. -func (s *Service) StatusMetrics() []prometheus.Collector { - return []prometheus.Collector{ +func (s *Service) StatusMetrics() []m.Collector { + return []m.Collector{ s.metrics.RequestAttempts, s.metrics.ChunkRetrieveTime, s.metrics.RequestDurationTime, diff --git a/pkg/salud/metrics.go b/pkg/salud/metrics.go index 8ac5abdb517..26c2eb9d323 100644 --- a/pkg/salud/metrics.go +++ b/pkg/salud/metrics.go @@ -6,89 +6,88 @@ package salud import ( m "github.com/ethersphere/bee/v2/pkg/metrics" - "github.com/prometheus/client_golang/prometheus" ) type metrics struct { - AvgDur prometheus.Gauge - PDur prometheus.Gauge - PConns prometheus.Gauge - NetworkRadius prometheus.Gauge - NeighborhoodRadius prometheus.Gauge - Commitment prometheus.Gauge - ReserveSizePercentErr prometheus.Gauge - Healthy prometheus.Counter - Unhealthy prometheus.Counter - NeighborhoodAvgDur prometheus.Gauge - NeighborCount prometheus.Gauge + AvgDur m.Gauge + PDur m.Gauge + PConns m.Gauge + NetworkRadius m.Gauge + NeighborhoodRadius m.Gauge + Commitment m.Gauge + ReserveSizePercentErr m.Gauge + Healthy m.Counter + Unhealthy m.Counter + NeighborhoodAvgDur m.Gauge + NeighborCount m.Gauge } func newMetrics() metrics { subsystem := "salud" return metrics{ - AvgDur: prometheus.NewGauge(prometheus.GaugeOpts{ + AvgDur: m.NewGauge(m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "dur", Help: "Average duration for snapshot response.", }), - PDur: prometheus.NewGauge(prometheus.GaugeOpts{ + PDur: m.NewGauge(m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "pdur", Help: "Percentile of durations for snapshot response.", }), - PConns: prometheus.NewGauge(prometheus.GaugeOpts{ + PConns: m.NewGauge(m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "pconns", Help: "Percentile of connections counts.", }), - NetworkRadius: prometheus.NewGauge(prometheus.GaugeOpts{ + NetworkRadius: m.NewGauge(m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "network_radius", Help: "Most common radius across the connected peers.", }), - NeighborhoodRadius: prometheus.NewGauge(prometheus.GaugeOpts{ + NeighborhoodRadius: m.NewGauge(m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "neighborhood_radius", Help: "Most common radius across the connected peers.", }), - Healthy: prometheus.NewCounter(prometheus.CounterOpts{ + Healthy: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "healthy", Help: "Count of healthy peers.", }), - Unhealthy: prometheus.NewCounter(prometheus.CounterOpts{ + Unhealthy: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "unhealthy", Help: "Count of unhealthy peers.", }), - Commitment: prometheus.NewGauge(prometheus.GaugeOpts{ + Commitment: m.NewGauge(m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "batch_commitment", Help: "Most common batch commitment.", }), - ReserveSizePercentErr: prometheus.NewGauge(prometheus.GaugeOpts{ + ReserveSizePercentErr: m.NewGauge(m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "reserve_size_percentage_err", Help: "Percentage error of the reservesize relative to the network average.", }), // Neighborhood-specific metrics - NeighborhoodAvgDur: prometheus.NewGauge(prometheus.GaugeOpts{ + NeighborhoodAvgDur: m.NewGauge(m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "neighborhood_dur", Help: "Average duration for snapshot response from neighborhood peers.", }), - NeighborCount: prometheus.NewGauge(prometheus.GaugeOpts{ + NeighborCount: m.NewGauge(m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "neighbors", @@ -97,6 +96,6 @@ func newMetrics() metrics { } } -func (s *service) Metrics() []prometheus.Collector { +func (s *service) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(s.metrics) } diff --git a/pkg/settlement/pseudosettle/metrics.go b/pkg/settlement/pseudosettle/metrics.go index 971795cb6a8..32b8174564e 100644 --- a/pkg/settlement/pseudosettle/metrics.go +++ b/pkg/settlement/pseudosettle/metrics.go @@ -6,56 +6,55 @@ package pseudosettle import ( m "github.com/ethersphere/bee/v2/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 - TotalReceivedPseudoSettlements prometheus.Counter - TotalSentPseudoSettlements prometheus.Counter - ReceivedPseudoSettlements prometheus.Counter - SentPseudoSettlements prometheus.Counter - ReceivedPseudoSettlementsErrors prometheus.Counter - SentPseudoSettlementsErrors prometheus.Counter + TotalReceivedPseudoSettlements m.Counter + TotalSentPseudoSettlements m.Counter + ReceivedPseudoSettlements m.Counter + SentPseudoSettlements m.Counter + ReceivedPseudoSettlementsErrors m.Counter + SentPseudoSettlementsErrors m.Counter } func newMetrics() metrics { subsystem := "pseudosettle" return metrics{ - TotalReceivedPseudoSettlements: prometheus.NewCounter(prometheus.CounterOpts{ + TotalReceivedPseudoSettlements: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_received_pseudosettlements", Help: "Amount of time settlements received from peers (income of the node)", }), - TotalSentPseudoSettlements: prometheus.NewCounter(prometheus.CounterOpts{ + TotalSentPseudoSettlements: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_sent_pseudosettlements", Help: "Amount of of time settlements sent to peers (costs paid by the node)", }), - ReceivedPseudoSettlements: prometheus.NewCounter(prometheus.CounterOpts{ + ReceivedPseudoSettlements: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "received_pseudosettlements", Help: "Number of time settlements received from peers", }), - SentPseudoSettlements: prometheus.NewCounter(prometheus.CounterOpts{ + SentPseudoSettlements: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "sent_pseudosettlements", Help: "Number of time settlements sent to peers", }), - ReceivedPseudoSettlementsErrors: prometheus.NewCounter(prometheus.CounterOpts{ + ReceivedPseudoSettlementsErrors: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "received_pseudosettlements_errors", Help: "Errors of time settlements received from peers", }), - SentPseudoSettlementsErrors: prometheus.NewCounter(prometheus.CounterOpts{ + SentPseudoSettlementsErrors: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "sent_pseudosettlements_errorss", @@ -64,6 +63,6 @@ func newMetrics() metrics { } } -func (s *Service) Metrics() []prometheus.Collector { +func (s *Service) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(s.metrics) } diff --git a/pkg/settlement/swap/metrics.go b/pkg/settlement/swap/metrics.go index 2e6fb1a4bb6..a7ab3d13708 100644 --- a/pkg/settlement/swap/metrics.go +++ b/pkg/settlement/swap/metrics.go @@ -6,53 +6,52 @@ package swap import ( m "github.com/ethersphere/bee/v2/pkg/metrics" - "github.com/prometheus/client_golang/prometheus" ) type metrics struct { - TotalReceived prometheus.Counter - TotalSent prometheus.Counter - ChequesReceived prometheus.Counter - ChequesSent prometheus.Counter - ChequesRejected prometheus.Counter - AvailableBalance prometheus.Gauge + TotalReceived m.Counter + TotalSent m.Counter + ChequesReceived m.Counter + ChequesSent m.Counter + ChequesRejected m.Counter + AvailableBalance m.Gauge } func newMetrics() metrics { subsystem := "swap" return metrics{ - TotalReceived: prometheus.NewCounter(prometheus.CounterOpts{ + TotalReceived: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_received", Help: "Amount of tokens received from peers (income of the node)", }), - TotalSent: prometheus.NewCounter(prometheus.CounterOpts{ + TotalSent: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_sent", Help: "Amount of tokens sent to peers (costs paid by the node)", }), - ChequesReceived: prometheus.NewCounter(prometheus.CounterOpts{ + ChequesReceived: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "cheques_received", Help: "Number of cheques received from peers", }), - ChequesSent: prometheus.NewCounter(prometheus.CounterOpts{ + ChequesSent: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "cheques_sent", Help: "Number of cheques sent to peers", }), - ChequesRejected: prometheus.NewCounter(prometheus.CounterOpts{ + ChequesRejected: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "cheques_rejected", Help: "Number of cheques rejected", }), - AvailableBalance: prometheus.NewGauge(prometheus.GaugeOpts{ + AvailableBalance: m.NewGauge(m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "available_balance", @@ -61,6 +60,6 @@ func newMetrics() metrics { } } -func (s *Service) Metrics() []prometheus.Collector { +func (s *Service) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(s.metrics) } diff --git a/pkg/sharky/metrics.go b/pkg/sharky/metrics.go index 53db4675b06..23bf47f0098 100644 --- a/pkg/sharky/metrics.go +++ b/pkg/sharky/metrics.go @@ -6,22 +6,21 @@ package sharky import ( m "github.com/ethersphere/bee/v2/pkg/metrics" - "github.com/prometheus/client_golang/prometheus" ) -// metrics groups sharky related prometheus counters. +// metrics groups sharky related m counters. type metrics struct { - TotalWriteCalls prometheus.Counter - TotalWriteCallsErr prometheus.Counter - TotalReadCalls prometheus.Counter - TotalReadCallsErr prometheus.Counter - TotalReleaseCalls prometheus.Counter - TotalReleaseCallsErr prometheus.Counter - ShardCount prometheus.Gauge - CurrentShardSize *prometheus.GaugeVec - ShardFragmentation *prometheus.GaugeVec - LastAllocatedShardSlot *prometheus.GaugeVec - LastReleasedShardSlot *prometheus.GaugeVec + TotalWriteCalls m.Counter + TotalWriteCallsErr m.Counter + TotalReadCalls m.Counter + TotalReadCallsErr m.Counter + TotalReleaseCalls m.Counter + TotalReleaseCallsErr m.Counter + ShardCount m.Gauge + CurrentShardSize m.GaugeMetricVector + ShardFragmentation m.GaugeMetricVector + LastAllocatedShardSlot m.GaugeMetricVector + LastReleasedShardSlot m.GaugeMetricVector } // newMetrics is a convenient constructor for creating new metrics. @@ -29,50 +28,50 @@ func newMetrics() metrics { const subsystem = "sharky" return metrics{ - TotalWriteCalls: prometheus.NewCounter(prometheus.CounterOpts{ + TotalWriteCalls: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_write_calls", Help: "The total write calls made.", }), - TotalWriteCallsErr: prometheus.NewCounter(prometheus.CounterOpts{ + TotalWriteCallsErr: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_write_calls_err", Help: "The total write calls ended up with error.", }), - TotalReadCalls: prometheus.NewCounter(prometheus.CounterOpts{ + TotalReadCalls: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_read_calls", Help: "The total read calls made.", }), - TotalReadCallsErr: prometheus.NewCounter(prometheus.CounterOpts{ + TotalReadCallsErr: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_read_calls_err", Help: "The total read calls ended up with error.", }), - TotalReleaseCalls: prometheus.NewCounter(prometheus.CounterOpts{ + TotalReleaseCalls: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_release_calls", Help: "The total release calls made.", }), - TotalReleaseCallsErr: prometheus.NewCounter(prometheus.CounterOpts{ + TotalReleaseCallsErr: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_release_calls_err", Help: "The total release calls ended up with error.", }), - ShardCount: prometheus.NewGauge(prometheus.GaugeOpts{ + ShardCount: m.NewGauge(m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "shard_count", Help: "The number of shards.", }), - CurrentShardSize: prometheus.NewGaugeVec( - prometheus.GaugeOpts{ + CurrentShardSize: m.NewGaugeVec( + m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "current_shard_size", @@ -80,8 +79,8 @@ func newMetrics() metrics { }, []string{"current_shard_size"}, ), - ShardFragmentation: prometheus.NewGaugeVec( - prometheus.GaugeOpts{ + ShardFragmentation: m.NewGaugeVec( + m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "shard_fragmentation", @@ -91,8 +90,8 @@ between actual lengths of chunks and the length of slot. `, }, []string{"shard_fragmentation"}, ), - LastAllocatedShardSlot: prometheus.NewGaugeVec( - prometheus.GaugeOpts{ + LastAllocatedShardSlot: m.NewGaugeVec( + m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "last_allocated_shard_slot", @@ -100,8 +99,8 @@ between actual lengths of chunks and the length of slot. }, []string{"shard_slot_no"}, ), - LastReleasedShardSlot: prometheus.NewGaugeVec( - prometheus.GaugeOpts{ + LastReleasedShardSlot: m.NewGaugeVec( + m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "last_released_shard_slot", @@ -112,7 +111,7 @@ between actual lengths of chunks and the length of slot. } } -// Metrics returns set of prometheus collectors. -func (s *Store) Metrics() []prometheus.Collector { +// Metrics returns set of m collectors. +func (s *Store) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(s.metrics) } diff --git a/pkg/shed/metrics.go b/pkg/shed/metrics.go index 58820407c9d..4a53e48866f 100644 --- a/pkg/shed/metrics.go +++ b/pkg/shed/metrics.go @@ -6,98 +6,97 @@ package shed import ( m "github.com/ethersphere/bee/v2/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 - PutCounter prometheus.Counter - PutFailCounter prometheus.Counter - GetCounter prometheus.Counter - GetFailCounter prometheus.Counter - GetNotFoundCounter prometheus.Counter - HasCounter prometheus.Counter - HasFailCounter prometheus.Counter - DeleteCounter prometheus.Counter - DeleteFailCounter prometheus.Counter - IteratorCounter prometheus.Counter - WriteBatchCounter prometheus.Counter - WriteBatchFailCounter prometheus.Counter + PutCounter m.Counter + PutFailCounter m.Counter + GetCounter m.Counter + GetFailCounter m.Counter + GetNotFoundCounter m.Counter + HasCounter m.Counter + HasFailCounter m.Counter + DeleteCounter m.Counter + DeleteFailCounter m.Counter + IteratorCounter m.Counter + WriteBatchCounter m.Counter + WriteBatchFailCounter m.Counter } func newMetrics() metrics { subsystem := "shed" return metrics{ - PutCounter: prometheus.NewCounter(prometheus.CounterOpts{ + PutCounter: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "put_count", Help: "Number of times the PUT operation is done.", }), - PutFailCounter: prometheus.NewCounter(prometheus.CounterOpts{ + PutFailCounter: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "put_fail_count", Help: "Number of times the PUT operation failed.", }), - GetCounter: prometheus.NewCounter(prometheus.CounterOpts{ + GetCounter: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "get_count", Help: "Number of times the GET operation is done.", }), - GetNotFoundCounter: prometheus.NewCounter(prometheus.CounterOpts{ + GetNotFoundCounter: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "get_not_found_count", Help: "Number of times the GET operation could not find key.", }), - GetFailCounter: prometheus.NewCounter(prometheus.CounterOpts{ + GetFailCounter: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "get_fail_count", Help: "Number of times the GET operation is failed.", }), - HasCounter: prometheus.NewCounter(prometheus.CounterOpts{ + HasCounter: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "has_count", Help: "Number of times the HAS operation is done.", }), - HasFailCounter: prometheus.NewCounter(prometheus.CounterOpts{ + HasFailCounter: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "has_fail_count", Help: "Number of times the HAS operation failed.", }), - DeleteCounter: prometheus.NewCounter(prometheus.CounterOpts{ + DeleteCounter: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "delete_count", Help: "Number of times the DELETE operation is done.", }), - DeleteFailCounter: prometheus.NewCounter(prometheus.CounterOpts{ + DeleteFailCounter: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "delete_fail_count", Help: "Number of times the DELETE operation failed.", }), - IteratorCounter: prometheus.NewCounter(prometheus.CounterOpts{ + IteratorCounter: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "iterator_count", Help: "Number of times the ITERATOR operation is done.", }), - WriteBatchCounter: prometheus.NewCounter(prometheus.CounterOpts{ + WriteBatchCounter: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "write_batch_count", Help: "Number of times the WRITE_BATCH operation is done.", }), - WriteBatchFailCounter: prometheus.NewCounter(prometheus.CounterOpts{ + WriteBatchFailCounter: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "write_batch_fail_count", @@ -106,6 +105,6 @@ func newMetrics() metrics { } } -func (s *DB) Metrics() []prometheus.Collector { +func (s *DB) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(s.metrics) } diff --git a/pkg/status/status.go b/pkg/status/status.go index 7fb5e46a592..3fc686fa957 100644 --- a/pkg/status/status.go +++ b/pkg/status/status.go @@ -10,14 +10,13 @@ import ( "strings" "github.com/ethersphere/bee/v2/pkg/log" + m "github.com/ethersphere/bee/v2/pkg/metrics" "github.com/ethersphere/bee/v2/pkg/p2p" "github.com/ethersphere/bee/v2/pkg/p2p/protobuf" "github.com/ethersphere/bee/v2/pkg/postage" "github.com/ethersphere/bee/v2/pkg/status/internal/pb" "github.com/ethersphere/bee/v2/pkg/swarm" "github.com/ethersphere/bee/v2/pkg/topology" - "github.com/prometheus/client_golang/prometheus" - "github.com/prometheus/common/expfmt" ) // loggerName is the tree path name of the logger for this package. @@ -60,12 +59,12 @@ type Service struct { reserve Reserve sync SyncReporter chainState postage.ChainStateGetter - metricsRegistry *prometheus.Registry + metricsRegistry m.MetricsRegistererGatherer } type Metrics struct { - UploadSpeed prometheus.Histogram - DownloadSpeed prometheus.Histogram + UploadSpeed m.Histogram + DownloadSpeed m.Histogram } // NewService creates a new status service. @@ -76,7 +75,7 @@ func NewService( beeMode string, chainState postage.ChainStateGetter, reserve Reserve, - metricsRegistry *prometheus.Registry, + metricsRegistry m.MetricsRegistererGatherer, ) *Service { return &Service{ logger: logger.WithName(loggerName).Register(), @@ -233,13 +232,13 @@ func (s *Service) encodeMetrics() (map[string]string, error) { } metrics := make(map[string]string, len(metricFamilies)) - for _, m := range metricFamilies { + for _, mf := range metricFamilies { var metricsBuilder strings.Builder - encoder := expfmt.NewEncoder(&metricsBuilder, expfmt.NewFormat(expfmt.TypeTextPlain)) - if err := encoder.Encode(m); err != nil { - return nil, fmt.Errorf("encode metric %s: %w", m.GetName(), err) + encoder := m.NewEncoder(&metricsBuilder, m.NewFormat(m.TypeTextPlain)) + if err := encoder.Encode(mf); err != nil { + return nil, fmt.Errorf("encode metric %s: %w", mf.GetName(), err) } - metrics[m.GetName()] = metricsBuilder.String() + metrics[mf.GetName()] = metricsBuilder.String() } return metrics, nil diff --git a/pkg/status/status_test.go b/pkg/status/status_test.go index 09213ec71d4..f1125f8b3b3 100644 --- a/pkg/status/status_test.go +++ b/pkg/status/status_test.go @@ -2,6 +2,9 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build !nometrics +// +build !nometrics + package status_test import ( diff --git a/pkg/storage/cache/metrics.go b/pkg/storage/cache/metrics.go index ec9a6051786..f27e27934df 100644 --- a/pkg/storage/cache/metrics.go +++ b/pkg/storage/cache/metrics.go @@ -6,25 +6,24 @@ package cache import ( m "github.com/ethersphere/bee/v2/pkg/metrics" - "github.com/prometheus/client_golang/prometheus" ) type metrics struct { - CacheHit prometheus.Counter - CacheMiss prometheus.Counter + CacheHit m.Counter + CacheMiss m.Counter } func newMetrics() metrics { subsystem := "storage_cache" return metrics{ - CacheHit: prometheus.NewCounter(prometheus.CounterOpts{ + CacheHit: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "cache_hit", Help: "Total cache hits.", }), - CacheMiss: prometheus.NewCounter(prometheus.CounterOpts{ + CacheMiss: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "cache_miss", @@ -33,6 +32,6 @@ func newMetrics() metrics { } } -func (c *Cache) Metrics() []prometheus.Collector { +func (c *Cache) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(c.metrics) } diff --git a/pkg/storageincentives/metrics.go b/pkg/storageincentives/metrics.go index b376d9d20b2..125af999a05 100644 --- a/pkg/storageincentives/metrics.go +++ b/pkg/storageincentives/metrics.go @@ -6,86 +6,85 @@ package storageincentives import ( m "github.com/ethersphere/bee/v2/pkg/metrics" - "github.com/prometheus/client_golang/prometheus" ) type metrics struct { // phase gauge and counter - CurrentPhase prometheus.Gauge - RevealPhase prometheus.Counter - CommitPhase prometheus.Counter - ClaimPhase prometheus.Counter - Winner prometheus.Counter - NeighborhoodSelected prometheus.Counter - SampleDuration prometheus.Gauge - Round prometheus.Gauge - InsufficientFundsToPlay prometheus.Counter + CurrentPhase m.Gauge + RevealPhase m.Counter + CommitPhase m.Counter + ClaimPhase m.Counter + Winner m.Counter + NeighborhoodSelected m.Counter + SampleDuration m.Gauge + Round m.Gauge + InsufficientFundsToPlay m.Counter // total calls to chain backend - BackendCalls prometheus.Counter - BackendErrors prometheus.Counter + BackendCalls m.Counter + BackendErrors m.Counter // metrics for err processing - ErrReveal prometheus.Counter - ErrCommit prometheus.Counter - ErrClaim prometheus.Counter - ErrWinner prometheus.Counter - ErrCheckIsPlaying prometheus.Counter + ErrReveal m.Counter + ErrCommit m.Counter + ErrClaim m.Counter + ErrWinner m.Counter + ErrCheckIsPlaying m.Counter } func newMetrics() metrics { subsystem := "storageincentives" return metrics{ - CurrentPhase: prometheus.NewGauge(prometheus.GaugeOpts{ + CurrentPhase: m.NewGauge(m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "current_phase", Help: "Enum value of the current phase.", }), - RevealPhase: prometheus.NewCounter(prometheus.CounterOpts{ + RevealPhase: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "reveal_phases", Help: "Count of reveal phases entered.", }), - CommitPhase: prometheus.NewCounter(prometheus.CounterOpts{ + CommitPhase: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "commit_phases", Help: "Count of commit phases entered.", }), - InsufficientFundsToPlay: prometheus.NewCounter(prometheus.CounterOpts{ + InsufficientFundsToPlay: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "insufficient_funds_to_play", Help: "Count of games skipped due to insufficient balance to participate.", }), - ClaimPhase: prometheus.NewCounter(prometheus.CounterOpts{ + ClaimPhase: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "claim_phases", Help: "Count of claim phases entered.", }), - Winner: prometheus.NewCounter(prometheus.CounterOpts{ + Winner: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "winner", Help: "Count of won rounds.", }), - NeighborhoodSelected: prometheus.NewCounter(prometheus.CounterOpts{ + NeighborhoodSelected: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "neighborhood_selected", Help: "Count of the neighborhood being selected.", }), - SampleDuration: prometheus.NewGauge(prometheus.GaugeOpts{ + SampleDuration: m.NewGauge(m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "reserve_sample_duration", Help: "Time taken to produce a reserve sample.", }), - Round: prometheus.NewGauge(prometheus.GaugeOpts{ + Round: m.NewGauge(m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "round", @@ -93,13 +92,13 @@ func newMetrics() metrics { }), // total call - BackendCalls: prometheus.NewCounter(prometheus.CounterOpts{ + BackendCalls: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "backend_calls", Help: "total chain backend calls", }), - BackendErrors: prometheus.NewCounter(prometheus.CounterOpts{ + BackendErrors: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "backend_errors", @@ -107,31 +106,31 @@ func newMetrics() metrics { }), // phase errors - ErrReveal: prometheus.NewCounter(prometheus.CounterOpts{ + ErrReveal: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "reveal_phase_errors", Help: "total reveal phase errors while processing", }), - ErrCommit: prometheus.NewCounter(prometheus.CounterOpts{ + ErrCommit: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "commit_phase_errors", Help: "total commit phase errors while processing", }), - ErrClaim: prometheus.NewCounter(prometheus.CounterOpts{ + ErrClaim: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "claim_phase_errors", Help: "total claim phase errors while processing", }), - ErrWinner: prometheus.NewCounter(prometheus.CounterOpts{ + ErrWinner: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "win_phase_errors", Help: "total win phase while processing", }), - ErrCheckIsPlaying: prometheus.NewCounter(prometheus.CounterOpts{ + ErrCheckIsPlaying: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "is_playing_errors", @@ -141,6 +140,6 @@ func newMetrics() metrics { } // TODO: register metric -func (a *Agent) Metrics() []prometheus.Collector { +func (a *Agent) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(a.metrics) } diff --git a/pkg/storer/internal/transaction/metrics.go b/pkg/storer/internal/transaction/metrics.go index 39434881d8d..abe91c5bbe3 100644 --- a/pkg/storer/internal/transaction/metrics.go +++ b/pkg/storer/internal/transaction/metrics.go @@ -6,12 +6,11 @@ package transaction import ( m "github.com/ethersphere/bee/v2/pkg/metrics" - "github.com/prometheus/client_golang/prometheus" ) type metrics struct { - MethodCalls *prometheus.CounterVec - MethodDuration *prometheus.HistogramVec + MethodCalls m.CounterMetricVector + MethodDuration m.HistogramMetricVector } // newMetrics is a convenient constructor for creating new metrics. @@ -19,8 +18,8 @@ func newMetrics() metrics { const subsystem = "transaction" return metrics{ - MethodCalls: prometheus.NewCounterVec( - prometheus.CounterOpts{ + MethodCalls: m.NewCounterVec( + m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "method_calls", @@ -28,8 +27,8 @@ func newMetrics() metrics { }, []string{"method", "status"}, ), - MethodDuration: prometheus.NewHistogramVec( - prometheus.HistogramOpts{ + MethodDuration: m.NewHistogramVec( + m.HistogramOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "method_duration", diff --git a/pkg/storer/internal/transaction/transaction.go b/pkg/storer/internal/transaction/transaction.go index ae97e06ce3b..e19082d5e4a 100644 --- a/pkg/storer/internal/transaction/transaction.go +++ b/pkg/storer/internal/transaction/transaction.go @@ -31,7 +31,6 @@ import ( "github.com/ethersphere/bee/v2/pkg/storage" "github.com/ethersphere/bee/v2/pkg/storer/internal/chunkstore" "github.com/ethersphere/bee/v2/pkg/swarm" - "github.com/prometheus/client_golang/prometheus" "resenje.org/multex" ) @@ -141,14 +140,14 @@ func (s *store) Run(ctx context.Context, f func(Store) error) error { return trx.Commit() } -// Metrics returns set of prometheus collectors. -func (s *store) Metrics() []prometheus.Collector { +// Metrics returns set of m collectors. +func (s *store) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(s.metrics) } // StatusMetrics exposes metrics that are exposed on the status protocol. -func (s *store) StatusMetrics() []prometheus.Collector { - return []prometheus.Collector{ +func (s *store) StatusMetrics() []m.Collector { + return []m.Collector{ s.metrics.MethodDuration, } } diff --git a/pkg/storer/metrics.go b/pkg/storer/metrics.go index 7b9295ee9f7..60c2ee5d938 100644 --- a/pkg/storer/metrics.go +++ b/pkg/storer/metrics.go @@ -12,27 +12,26 @@ import ( m "github.com/ethersphere/bee/v2/pkg/metrics" "github.com/ethersphere/bee/v2/pkg/storage" "github.com/ethersphere/bee/v2/pkg/swarm" - "github.com/prometheus/client_golang/prometheus" ) -// metrics groups storer related prometheus counters. +// metrics groups storer related m counters. type metrics struct { - MethodCalls *prometheus.CounterVec - MethodCallsDuration *prometheus.HistogramVec - ReserveSize prometheus.Gauge - ReserveSizeWithinRadius prometheus.Gauge - ReserveCleanup prometheus.Counter - StorageRadius prometheus.Gauge - CacheSize prometheus.Gauge - EvictedChunkCount prometheus.Counter - ExpiredChunkCount prometheus.Counter - OverCapTriggerCount prometheus.Counter - ExpiredBatchCount prometheus.Counter - LevelDBStats *prometheus.HistogramVec - ExpiryTriggersCount prometheus.Counter - ExpiryRunsCount prometheus.Counter - - ReserveMissingBatch prometheus.Gauge + MethodCalls m.CounterMetricVector + MethodCallsDuration m.HistogramMetricVector + ReserveSize m.Gauge + ReserveSizeWithinRadius m.Gauge + ReserveCleanup m.Counter + StorageRadius m.Gauge + CacheSize m.Gauge + EvictedChunkCount m.Counter + ExpiredChunkCount m.Counter + OverCapTriggerCount m.Counter + ExpiredBatchCount m.Counter + LevelDBStats m.HistogramMetricVector + ExpiryTriggersCount m.Counter + ExpiryRunsCount m.Counter + + ReserveMissingBatch m.Gauge } // newMetrics is a convenient constructor for creating new metrics. @@ -40,8 +39,8 @@ func newMetrics() metrics { const subsystem = "localstore" return metrics{ - MethodCalls: prometheus.NewCounterVec( - prometheus.CounterOpts{ + MethodCalls: m.NewCounterVec( + m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "method_calls", @@ -49,8 +48,8 @@ func newMetrics() metrics { }, []string{"component", "method", "status"}, ), - MethodCallsDuration: prometheus.NewHistogramVec( - prometheus.HistogramOpts{ + MethodCallsDuration: m.NewHistogramVec( + m.HistogramOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "method_calls_duration", @@ -58,88 +57,88 @@ func newMetrics() metrics { }, []string{"component", "method"}, ), - ReserveSize: prometheus.NewGauge( - prometheus.GaugeOpts{ + ReserveSize: m.NewGauge( + m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "reserve_size", Help: "Number of chunks in reserve.", }, ), - ReserveMissingBatch: prometheus.NewGauge( - prometheus.GaugeOpts{ + ReserveMissingBatch: m.NewGauge( + m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "reserve_missing_batch", Help: "Number of chunks in reserve with missing batches.", }, ), - ReserveSizeWithinRadius: prometheus.NewGauge( - prometheus.GaugeOpts{ + ReserveSizeWithinRadius: m.NewGauge( + m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "reserve_size_within_radius", Help: "Number of chunks in reserve with proximity >= storage radius.", }, ), - ReserveCleanup: prometheus.NewCounter( - prometheus.CounterOpts{ + ReserveCleanup: m.NewCounter( + m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "reserve_cleanup", Help: "Number of cleaned-up expired chunks.", }, ), - StorageRadius: prometheus.NewGauge( - prometheus.GaugeOpts{ + StorageRadius: m.NewGauge( + m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "storage_radius", Help: "Radius of responsibility reserve storage.", }, ), - CacheSize: prometheus.NewGauge( - prometheus.GaugeOpts{ + CacheSize: m.NewGauge( + m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "cache_size", Help: "Number of chunks in cache.", }, ), - EvictedChunkCount: prometheus.NewCounter( - prometheus.CounterOpts{ + EvictedChunkCount: m.NewCounter( + m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "evicted_count", Help: "Number of chunks evicted from reserve.", }, ), - ExpiredChunkCount: prometheus.NewCounter( - prometheus.CounterOpts{ + ExpiredChunkCount: m.NewCounter( + m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "expired_count", Help: "Number of chunks expired from reserve due to stamp expirations.", }, ), - OverCapTriggerCount: prometheus.NewCounter( - prometheus.CounterOpts{ + OverCapTriggerCount: m.NewCounter( + m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "over_cap_trigger_count", Help: "Number of times the reserve was over capacity and triggered an eviction.", }, ), - ExpiredBatchCount: prometheus.NewCounter( - prometheus.CounterOpts{ + ExpiredBatchCount: m.NewCounter( + m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "expired_batch_count", Help: "Number of batches expired, that were processed.", }, ), - LevelDBStats: prometheus.NewHistogramVec( - prometheus.HistogramOpts{ + LevelDBStats: m.NewHistogramVec( + m.HistogramOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "leveldb_stats", @@ -147,16 +146,16 @@ func newMetrics() metrics { }, []string{"counter"}, ), - ExpiryTriggersCount: prometheus.NewCounter( - prometheus.CounterOpts{ + ExpiryTriggersCount: m.NewCounter( + m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "expiry_trigger_count", Help: "Number of batches expiry triggers.", }, ), - ExpiryRunsCount: prometheus.NewCounter( - prometheus.CounterOpts{ + ExpiryRunsCount: m.NewCounter( + m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "expiry_run_count", diff --git a/pkg/storer/storer.go b/pkg/storer/storer.go index 76b35f198ba..117e277d4a3 100644 --- a/pkg/storer/storer.go +++ b/pkg/storer/storer.go @@ -40,7 +40,6 @@ import ( "github.com/ethersphere/bee/v2/pkg/topology" "github.com/ethersphere/bee/v2/pkg/tracing" "github.com/ethersphere/bee/v2/pkg/util/syncutil" - "github.com/prometheus/client_golang/prometheus" "github.com/spf13/afero" "github.com/syndtr/goleveldb/leveldb" "github.com/syndtr/goleveldb/leveldb/filter" @@ -295,7 +294,7 @@ func initDiskRepository( if opts.LdbStats.Load() != nil { go func() { - ldbStats := opts.LdbStats.Load() + ldbStats := opts.LdbStats.Load().Vec logger := log.NewLogger(loggerName).Register() ticker := time.NewTicker(15 * time.Second) defer ticker.Stop() @@ -370,10 +369,14 @@ func initDiskRepository( const lockKeyNewSession string = "new_session" +type HistogramVecBox struct { + Vec m.HistogramMetricVector // или HistogramVec +} + // Options provides a container to configure different things in the storer. type Options struct { // These are options related to levelDB. Currently, the underlying storage used is levelDB. - LdbStats atomic.Pointer[prometheus.HistogramVec] + LdbStats atomic.Pointer[HistogramVecBox] LdbOpenFilesLimit uint64 LdbBlockCacheCapacity uint64 LdbWriteBufferSize uint64 @@ -480,7 +483,7 @@ func New(ctx context.Context, dirPath string, opts *Options) (*DB, error) { lock := multex.New() metrics := newMetrics() - opts.LdbStats.CompareAndSwap(nil, metrics.LevelDBStats) + opts.LdbStats.CompareAndSwap(nil, &HistogramVecBox{metrics.LevelDBStats}) if dirPath == "" { st, dbCloser, err = initInmemRepository() @@ -600,23 +603,23 @@ func (db *DB) ResetReserve(ctx context.Context) error { return db.reserve.Reset(ctx) } -// Metrics returns set of prometheus collectors. -func (db *DB) Metrics() []prometheus.Collector { +// Metrics returns set of m collectors. +func (db *DB) Metrics() []m.Collector { collectors := m.PrometheusCollectorsFromFields(db.metrics) - if v, ok := db.storage.(m.Collector); ok { + if v, ok := db.storage.(m.MetricsCollector); ok { collectors = append(collectors, v.Metrics()...) } return collectors } // StatusMetrics exposes metrics that are exposed on the status protocol. -func (db *DB) StatusMetrics() []prometheus.Collector { - collectors := []prometheus.Collector{ +func (db *DB) StatusMetrics() []m.Collector { + collectors := []m.Collector{ db.metrics.MethodCallsDuration, } type Collector interface { - StatusMetrics() []prometheus.Collector + StatusMetrics() []m.Collector } if v, ok := db.storage.(Collector); ok { diff --git a/pkg/topology/kademlia/metrics.go b/pkg/topology/kademlia/metrics.go index 7fc9a53751e..5fd5054b0c4 100644 --- a/pkg/topology/kademlia/metrics.go +++ b/pkg/topology/kademlia/metrics.go @@ -6,31 +6,30 @@ package kademlia import ( m "github.com/ethersphere/bee/v2/pkg/metrics" - "github.com/prometheus/client_golang/prometheus" ) -// metrics groups kademlia related prometheus counters. +// metrics groups kademlia related m counters. type metrics struct { - PickCalls prometheus.Counter - PickCallsFalse prometheus.Counter - CurrentDepth prometheus.Gauge - CurrentStorageDepth prometheus.Gauge - CurrentlyKnownPeers prometheus.Gauge - CurrentlyConnectedPeers prometheus.Gauge - InternalMetricsFlushTime prometheus.Histogram - InternalMetricsFlushTotalErrors prometheus.Counter - TotalBeforeExpireWaits prometheus.Counter - TotalInboundConnections prometheus.Counter - TotalInboundDisconnections prometheus.Counter - TotalOutboundConnections prometheus.Counter - TotalOutboundConnectionAttempts prometheus.Counter - TotalOutboundConnectionFailedAttempts prometheus.Counter - TotalBootNodesConnectionAttempts prometheus.Counter - StartAddAddressBookOverlaysTime prometheus.Histogram - PeerLatencyEWMA prometheus.Histogram - Blocklist prometheus.Counter - ReachabilityStatus *prometheus.GaugeVec - PeersReachabilityStatus *prometheus.GaugeVec + PickCalls m.Counter + PickCallsFalse m.Counter + CurrentDepth m.Gauge + CurrentStorageDepth m.Gauge + CurrentlyKnownPeers m.Gauge + CurrentlyConnectedPeers m.Gauge + InternalMetricsFlushTime m.Histogram + InternalMetricsFlushTotalErrors m.Counter + TotalBeforeExpireWaits m.Counter + TotalInboundConnections m.Counter + TotalInboundDisconnections m.Counter + TotalOutboundConnections m.Counter + TotalOutboundConnectionAttempts m.Counter + TotalOutboundConnectionFailedAttempts m.Counter + TotalBootNodesConnectionAttempts m.Counter + StartAddAddressBookOverlaysTime m.Histogram + PeerLatencyEWMA m.Histogram + Blocklist m.Counter + ReachabilityStatus m.GaugeMetricVector + PeersReachabilityStatus m.GaugeMetricVector } // newMetrics is a convenient constructor for creating new metrics. @@ -38,116 +37,116 @@ func newMetrics() metrics { const subsystem = "kademlia" return metrics{ - PickCalls: prometheus.NewCounter(prometheus.CounterOpts{ + PickCalls: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "pick_calls", Help: "The number of pick method call made.", }), - PickCallsFalse: prometheus.NewCounter(prometheus.CounterOpts{ + PickCallsFalse: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "pick_calls_false", Help: "The number of pick method call made which returned false.", }), - CurrentDepth: prometheus.NewGauge(prometheus.GaugeOpts{ + CurrentDepth: m.NewGauge(m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "current_depth", Help: "The current value of depth.", }), - CurrentStorageDepth: prometheus.NewGauge(prometheus.GaugeOpts{ + CurrentStorageDepth: m.NewGauge(m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "current_storage_depth", Help: "The current value of storage depth.", }), - CurrentlyKnownPeers: prometheus.NewGauge(prometheus.GaugeOpts{ + CurrentlyKnownPeers: m.NewGauge(m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "currently_known_peers", Help: "Number of currently known peers.", }), - CurrentlyConnectedPeers: prometheus.NewGauge(prometheus.GaugeOpts{ + CurrentlyConnectedPeers: m.NewGauge(m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "currently_connected_peers", Help: "Number of currently connected peers.", }), - InternalMetricsFlushTime: prometheus.NewHistogram(prometheus.HistogramOpts{ + InternalMetricsFlushTime: m.NewHistogram(m.HistogramOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "internal_metrics_flush_time", Help: "The time spent flushing the internal metrics about peers to the state-store.", }), - InternalMetricsFlushTotalErrors: prometheus.NewCounter(prometheus.CounterOpts{ + InternalMetricsFlushTotalErrors: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "internal_metrics_flush_total_errors", Help: "Number of total errors occurred during flushing the internal metrics to the state-store.", }), - TotalBeforeExpireWaits: prometheus.NewCounter(prometheus.CounterOpts{ + TotalBeforeExpireWaits: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_before_expire_waits", Help: "Total before expire waits made.", }), - TotalInboundConnections: prometheus.NewCounter(prometheus.CounterOpts{ + TotalInboundConnections: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_inbound_connections", Help: "Total inbound connections made.", }), - TotalInboundDisconnections: prometheus.NewCounter(prometheus.CounterOpts{ + TotalInboundDisconnections: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_inbound_disconnections", Help: "Total inbound disconnections made.", }), - TotalOutboundConnections: prometheus.NewCounter(prometheus.CounterOpts{ + TotalOutboundConnections: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_outbound_connections", Help: "Total outbound connections made.", }), - TotalOutboundConnectionAttempts: prometheus.NewCounter(prometheus.CounterOpts{ + TotalOutboundConnectionAttempts: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_outbound_connection_attempts", Help: "Total outbound connection attempts made.", }), - TotalOutboundConnectionFailedAttempts: prometheus.NewCounter(prometheus.CounterOpts{ + TotalOutboundConnectionFailedAttempts: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_outbound_connection_failed_attempts", Help: "Total outbound connection failed attempts made.", }), - TotalBootNodesConnectionAttempts: prometheus.NewCounter(prometheus.CounterOpts{ + TotalBootNodesConnectionAttempts: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_bootnodes_connection_attempts", Help: "Total boot-nodes connection attempts made.", }), - StartAddAddressBookOverlaysTime: prometheus.NewHistogram(prometheus.HistogramOpts{ + StartAddAddressBookOverlaysTime: m.NewHistogram(m.HistogramOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "start_add_addressbook_overlays_time", Help: "The time spent adding overlays peers from addressbook on kademlia start.", }), - PeerLatencyEWMA: prometheus.NewHistogram(prometheus.HistogramOpts{ + PeerLatencyEWMA: m.NewHistogram(m.HistogramOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "peer_latency_ewma", Help: "Peer latency EWMA value distribution.", }), - Blocklist: prometheus.NewCounter(prometheus.CounterOpts{ + Blocklist: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "blocklist", Help: "The number of times peers have been blocklisted.", }), - ReachabilityStatus: prometheus.NewGaugeVec( - prometheus.GaugeOpts{ + ReachabilityStatus: m.NewGaugeVec( + m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "reachability_status", @@ -155,8 +154,8 @@ func newMetrics() metrics { }, []string{"reachability_status"}, ), - PeersReachabilityStatus: prometheus.NewGaugeVec( - prometheus.GaugeOpts{ + PeersReachabilityStatus: m.NewGaugeVec( + m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "peers_reachability_status", @@ -167,7 +166,7 @@ func newMetrics() metrics { } } -// Metrics returns set of prometheus collectors. -func (k *Kad) Metrics() []prometheus.Collector { +// Metrics returns set of m collectors. +func (k *Kad) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(k.metrics) } diff --git a/pkg/topology/lightnode/metrics.go b/pkg/topology/lightnode/metrics.go index cea1504f8a9..ee7a9632db2 100644 --- a/pkg/topology/lightnode/metrics.go +++ b/pkg/topology/lightnode/metrics.go @@ -6,13 +6,12 @@ package lightnode import ( m "github.com/ethersphere/bee/v2/pkg/metrics" - "github.com/prometheus/client_golang/prometheus" ) -// metrics groups lightnode related prometheus counters. +// metrics groups lightnode related m counters. type metrics struct { - CurrentlyConnectedPeers prometheus.Gauge - CurrentlyDisconnectedPeers prometheus.Gauge + CurrentlyConnectedPeers m.Gauge + CurrentlyDisconnectedPeers m.Gauge } // newMetrics is a convenient constructor for creating new metrics. @@ -20,13 +19,13 @@ func newMetrics() metrics { const subsystem = "lightnode" return metrics{ - CurrentlyConnectedPeers: prometheus.NewGauge(prometheus.GaugeOpts{ + CurrentlyConnectedPeers: m.NewGauge(m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "currently_connected_peers", Help: "Number of currently connected peers.", }), - CurrentlyDisconnectedPeers: prometheus.NewGauge(prometheus.GaugeOpts{ + CurrentlyDisconnectedPeers: m.NewGauge(m.GaugeOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "currently_disconnected_peers", @@ -34,7 +33,7 @@ func newMetrics() metrics { })} } -// Metrics returns set of prometheus collectors. -func (c *Container) Metrics() []prometheus.Collector { +// Metrics returns set of m collectors. +func (c *Container) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(c.metrics) } diff --git a/pkg/transaction/wrapped/metrics.go b/pkg/transaction/wrapped/metrics.go index a5cfaa554a0..14d0e63824c 100644 --- a/pkg/transaction/wrapped/metrics.go +++ b/pkg/transaction/wrapped/metrics.go @@ -6,117 +6,116 @@ package wrapped import ( m "github.com/ethersphere/bee/v2/pkg/metrics" - "github.com/prometheus/client_golang/prometheus" ) type metrics struct { - TotalRPCCalls prometheus.Counter - TotalRPCErrors prometheus.Counter + TotalRPCCalls m.Counter + TotalRPCErrors m.Counter - TransactionReceiptCalls prometheus.Counter - TransactionCalls prometheus.Counter - BlockNumberCalls prometheus.Counter - BlockHeaderCalls prometheus.Counter - BalanceCalls prometheus.Counter - NonceAtCalls prometheus.Counter - PendingNonceCalls prometheus.Counter - CallContractCalls prometheus.Counter - SuggestGasTipCapCalls prometheus.Counter - EstimateGasCalls prometheus.Counter - SendTransactionCalls prometheus.Counter - FilterLogsCalls prometheus.Counter - ChainIDCalls prometheus.Counter + TransactionReceiptCalls m.Counter + TransactionCalls m.Counter + BlockNumberCalls m.Counter + BlockHeaderCalls m.Counter + BalanceCalls m.Counter + NonceAtCalls m.Counter + PendingNonceCalls m.Counter + CallContractCalls m.Counter + SuggestGasTipCapCalls m.Counter + EstimateGasCalls m.Counter + SendTransactionCalls m.Counter + FilterLogsCalls m.Counter + ChainIDCalls m.Counter } func newMetrics() metrics { subsystem := "eth_backend" return metrics{ - TotalRPCCalls: prometheus.NewCounter(prometheus.CounterOpts{ + TotalRPCCalls: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_rpc_calls", Help: "Count of rpc calls", }), - TotalRPCErrors: prometheus.NewCounter(prometheus.CounterOpts{ + TotalRPCErrors: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "total_rpc_errors", Help: "Count of rpc errors", }), - TransactionCalls: prometheus.NewCounter(prometheus.CounterOpts{ + TransactionCalls: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "calls_transaction", Help: "Count of eth_getTransaction rpc calls", }), - TransactionReceiptCalls: prometheus.NewCounter(prometheus.CounterOpts{ + TransactionReceiptCalls: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "calls_transaction_receipt", Help: "Count of eth_getTransactionReceipt rpc errors", }), - BlockNumberCalls: prometheus.NewCounter(prometheus.CounterOpts{ + BlockNumberCalls: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "calls_block_number", Help: "Count of eth_blockNumber rpc calls", }), - BlockHeaderCalls: prometheus.NewCounter(prometheus.CounterOpts{ + BlockHeaderCalls: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "calls_block_header", Help: "Count of eth_getBlockByNumber (header only) calls", }), - BalanceCalls: prometheus.NewCounter(prometheus.CounterOpts{ + BalanceCalls: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "calls_balance", Help: "Count of eth_getBalance rpc calls", }), - NonceAtCalls: prometheus.NewCounter(prometheus.CounterOpts{ + NonceAtCalls: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "calls_nonce_at", Help: "Count of eth_getTransactionCount (pending false) rpc calls", }), - PendingNonceCalls: prometheus.NewCounter(prometheus.CounterOpts{ + PendingNonceCalls: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "calls_pending_nonce_at", Help: "Count of eth_getTransactionCount (pending true) rpc calls", }), - CallContractCalls: prometheus.NewCounter(prometheus.CounterOpts{ + CallContractCalls: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "calls_eth_call", Help: "Count of eth_call rpc calls", }), - SuggestGasTipCapCalls: prometheus.NewCounter(prometheus.CounterOpts{ + SuggestGasTipCapCalls: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "calls_suggest_gas_tip_cap", Help: "Count of eth_maxPriorityFeePerGas rpc calls", }), - EstimateGasCalls: prometheus.NewCounter(prometheus.CounterOpts{ + EstimateGasCalls: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "calls_estimate_gasprice", Help: "Count of eth_estimateGas rpc calls", }), - SendTransactionCalls: prometheus.NewCounter(prometheus.CounterOpts{ + SendTransactionCalls: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "calls_send_transaction", Help: "Count of eth_sendRawTransaction rpc calls", }), - FilterLogsCalls: prometheus.NewCounter(prometheus.CounterOpts{ + FilterLogsCalls: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "calls_filter_logs", Help: "Count of eth_getLogs rpc calls", }), - ChainIDCalls: prometheus.NewCounter(prometheus.CounterOpts{ + ChainIDCalls: m.NewCounter(m.CounterOpts{ Namespace: m.Namespace, Subsystem: subsystem, Name: "calls_chain_id", @@ -125,6 +124,6 @@ func newMetrics() metrics { } } -func (b *wrappedBackend) Metrics() []prometheus.Collector { +func (b *wrappedBackend) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(b.metrics) } From bd4f428b439c70bdaaaa9b8903001dcd88fa52f3 Mon Sep 17 00:00:00 2001 From: vadim Date: Mon, 22 Sep 2025 13:49:19 +0200 Subject: [PATCH 2/6] fix: isolate opencensus exporter import --- pkg/metrics/exporter/exporter.go | 30 ++++++++++++++++++++++++++++++ pkg/metrics/metrics.go | 18 ------------------ pkg/metrics/types.go | 16 ---------------- pkg/p2p/libp2p/libp2p.go | 3 ++- 4 files changed, 32 insertions(+), 35 deletions(-) create mode 100644 pkg/metrics/exporter/exporter.go diff --git a/pkg/metrics/exporter/exporter.go b/pkg/metrics/exporter/exporter.go new file mode 100644 index 00000000000..f78ed123fc2 --- /dev/null +++ b/pkg/metrics/exporter/exporter.go @@ -0,0 +1,30 @@ +package exporter + +import ( + exporter "contrib.go.opencensus.io/exporter/prometheus" + "github.com/prometheus/client_golang/prometheus" +) + +type MetricsSourcer interface { + MustRegister(...prometheus.Collector) + Register(prometheus.Collector) error + Unregister(prometheus.Collector) bool +} + +// The goroutine leak `go.opencensus.io/stats/view.(*worker).start` appears solely because of +// importing the `exporter.Options` type from `go.opencensus.io` package +// (either directly or transitively). +type ExporterOptions struct { + Namespace string + Registry MetricsSourcer +} + +func NewExporter(o ExporterOptions) error { + r, _ := o.Registry.(*prometheus.Registry) + opts := exporter.Options{ + Namespace: o.Namespace, + Registry: r, + } + _, err := exporter.NewExporter(opts) + return err +} diff --git a/pkg/metrics/metrics.go b/pkg/metrics/metrics.go index bcd9fcd8e68..7567085fa0f 100644 --- a/pkg/metrics/metrics.go +++ b/pkg/metrics/metrics.go @@ -8,11 +8,9 @@ package metrics import ( - "fmt" "io" "net/http" - exporter "contrib.go.opencensus.io/exporter/prometheus" "github.com/prometheus/client_golang/prometheus" "github.com/prometheus/client_golang/prometheus/collectors" "github.com/prometheus/client_golang/prometheus/promhttp" @@ -74,22 +72,6 @@ func HandlerFor(reg MetricsRegistererGatherer, opts HandlerOpts) http.Handler { return promhttp.HandlerFor(reg, opts) } -func NewExporter(o ExporterOptions) error { - if o.Registry == nil { - return ErrNilRegistry - } - r, ok := o.Registry.(*prometheus.Registry) - if !ok { - return fmt.Errorf("invalid exporter type: %T", o.Registry) - } - opts := exporter.Options{ - Namespace: o.Namespace, - Registry: r, - } - _, err := exporter.NewExporter(opts) - return err -} - func MustRegister(cs ...Collector) { prometheus.MustRegister(cs...) } diff --git a/pkg/metrics/types.go b/pkg/metrics/types.go index 841a57986f8..4722d5d0acf 100644 --- a/pkg/metrics/types.go +++ b/pkg/metrics/types.go @@ -13,20 +13,12 @@ import ( "github.com/prometheus/common/expfmt" ) -type MetricsError string - -func (e MetricsError) Error() string { - return string(e) -} - const ( // Namespace is prefixed before every metric. If it is changed, it must be done // before any metrics collector is registered. Namespace = "bee" TypeTextPlain = expfmt.TypeTextPlain - - ErrNilRegistry = MetricsError("nil registry") ) // Prometheus Vector type interfaces @@ -99,11 +91,3 @@ type ( FormatType = expfmt.FormatType EncoderOption = expfmt.EncoderOption ) - -// The goroutine leak `go.opencensus.io/stats/view.(*worker).start` appears solely because of -// importing the `exporter.Options` type from `go.opencensus.io` package -// (either directly or transitively). -type ExporterOptions struct { - Namespace string - Registry MetricsRegistererGatherer -} diff --git a/pkg/p2p/libp2p/libp2p.go b/pkg/p2p/libp2p/libp2p.go index 9735eb1d998..620cb5c68a2 100644 --- a/pkg/p2p/libp2p/libp2p.go +++ b/pkg/p2p/libp2p/libp2p.go @@ -22,6 +22,7 @@ import ( "github.com/ethersphere/bee/v2/pkg/bzz" beecrypto "github.com/ethersphere/bee/v2/pkg/crypto" "github.com/ethersphere/bee/v2/pkg/log" + exporter "github.com/ethersphere/bee/v2/pkg/metrics/exporter" "github.com/ethersphere/bee/v2/pkg/p2p" "github.com/ethersphere/bee/v2/pkg/p2p/libp2p/internal/blocklist" "github.com/ethersphere/bee/v2/pkg/p2p/libp2p/internal/breaker" @@ -173,7 +174,7 @@ func New(ctx context.Context, signer beecrypto.Signer, networkID uint64, overlay if o.Registry != nil { rcmgr.MustRegisterWith(o.Registry) } - err = m.NewExporter(m.ExporterOptions{ + err = exporter.NewExporter(exporter.ExporterOptions{ Namespace: m.Namespace, Registry: o.Registry, }) From 4ce3abbfae0e14cb0a044bbdaa768f78eb22e455 Mon Sep 17 00:00:00 2001 From: vadim Date: Tue, 23 Sep 2025 11:11:42 +0200 Subject: [PATCH 3/6] chore: add missing copyright header --- pkg/metrics/exporter/exporter.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/pkg/metrics/exporter/exporter.go b/pkg/metrics/exporter/exporter.go index f78ed123fc2..28b7d1b9355 100644 --- a/pkg/metrics/exporter/exporter.go +++ b/pkg/metrics/exporter/exporter.go @@ -1,3 +1,7 @@ +// 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 exporter import ( From b4393f5c40d7b79038db5232a73af743e8ce53d2 Mon Sep 17 00:00:00 2001 From: vadim Date: Tue, 23 Sep 2025 19:44:03 +0200 Subject: [PATCH 4/6] fix: add Makefile command; move ExporterOptions to shared type --- Makefile | 8 ++++++-- pkg/metrics/exporter/exporter.go | 17 +++-------------- pkg/metrics/exporter/noop.go | 12 ++++++++++++ pkg/metrics/exporter/types.go | 20 ++++++++++++++++++++ pkg/metrics/noop.go | 4 ---- 5 files changed, 41 insertions(+), 20 deletions(-) create mode 100644 pkg/metrics/exporter/noop.go create mode 100644 pkg/metrics/exporter/types.go diff --git a/Makefile b/Makefile index 01568f1136b..cb33e1bce67 100644 --- a/Makefile +++ b/Makefile @@ -20,6 +20,7 @@ VERSION ?= "$(shell git describe --tags --abbrev=0 | cut -c2-)" COMMIT_HASH ?= "$(shell git describe --long --dirty --always --match "" || true)" CLEAN_COMMIT ?= "$(shell git describe --long --always --match "" || true)" COMMIT_TIME ?= "$(shell git show -s --format=%ct $(CLEAN_COMMIT) || true)" +BUILD_TAGS ?= LDFLAGS ?= -s -w \ -X github.com/ethersphere/bee/v2.version="$(VERSION)" \ -X github.com/ethersphere/bee/v2.commitHash="$(COMMIT_HASH)" \ @@ -31,11 +32,14 @@ LDFLAGS ?= -s -w \ .PHONY: all all: build lint test-race binary -.PHONY: binary +.PHONY: binary binary-nometrics binary: export CGO_ENABLED=0 binary: dist FORCE $(GO) version - $(GO) build -trimpath -ldflags "$(LDFLAGS)" -o dist/bee ./cmd/bee + $(GO) build -trimpath -ldflags "$(LDFLAGS)" -tags "$(BUILD_TAGS)" -o dist/bee ./cmd/bee + +binary-nometrics: + $(MAKE) binary BUILD_TAGS=nometrics dist: mkdir $@ diff --git a/pkg/metrics/exporter/exporter.go b/pkg/metrics/exporter/exporter.go index 28b7d1b9355..c94f218e79a 100644 --- a/pkg/metrics/exporter/exporter.go +++ b/pkg/metrics/exporter/exporter.go @@ -2,6 +2,9 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build !nometrics +// +build !nometrics + package exporter import ( @@ -9,20 +12,6 @@ import ( "github.com/prometheus/client_golang/prometheus" ) -type MetricsSourcer interface { - MustRegister(...prometheus.Collector) - Register(prometheus.Collector) error - Unregister(prometheus.Collector) bool -} - -// The goroutine leak `go.opencensus.io/stats/view.(*worker).start` appears solely because of -// importing the `exporter.Options` type from `go.opencensus.io` package -// (either directly or transitively). -type ExporterOptions struct { - Namespace string - Registry MetricsSourcer -} - func NewExporter(o ExporterOptions) error { r, _ := o.Registry.(*prometheus.Registry) opts := exporter.Options{ diff --git a/pkg/metrics/exporter/noop.go b/pkg/metrics/exporter/noop.go new file mode 100644 index 00000000000..3f80d2ee859 --- /dev/null +++ b/pkg/metrics/exporter/noop.go @@ -0,0 +1,12 @@ +// 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. + +//go:build nometrics +// +build nometrics + +package exporter + +func NewExporter(o ExporterOptions) error { + return nil +} diff --git a/pkg/metrics/exporter/types.go b/pkg/metrics/exporter/types.go new file mode 100644 index 00000000000..965c7e0753d --- /dev/null +++ b/pkg/metrics/exporter/types.go @@ -0,0 +1,20 @@ +// 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 exporter + +import ( + "github.com/prometheus/client_golang/prometheus" +) + +type MetricsSourcer interface { + MustRegister(...prometheus.Collector) + Register(prometheus.Collector) error + Unregister(prometheus.Collector) bool +} + +type ExporterOptions struct { + Namespace string + Registry MetricsSourcer +} diff --git a/pkg/metrics/noop.go b/pkg/metrics/noop.go index d664f3cdd7e..773177aaeda 100644 --- a/pkg/metrics/noop.go +++ b/pkg/metrics/noop.go @@ -144,10 +144,6 @@ func NewRegistry() MetricsRegistererGatherer { return ®istryNoop{} } -func NewExporter(o ExporterOptions) error { - return nil -} - func MustRegister(_ ...Collector) { // pass } From 1e466a2517200ffc8efd39d87e2df58f3f4020ff Mon Sep 17 00:00:00 2001 From: vadim Date: Wed, 24 Sep 2025 19:55:07 +0200 Subject: [PATCH 5/6] chore: remove naming artefacts --- pkg/p2p/libp2p/internal/handshake/metrics.go | 4 ++-- pkg/sharky/metrics.go | 4 ++-- pkg/storer/internal/transaction/transaction.go | 2 +- pkg/storer/metrics.go | 2 +- pkg/storer/storer.go | 4 ++-- 5 files changed, 8 insertions(+), 8 deletions(-) diff --git a/pkg/p2p/libp2p/internal/handshake/metrics.go b/pkg/p2p/libp2p/internal/handshake/metrics.go index 0c60d337687..7b83d7ef7da 100644 --- a/pkg/p2p/libp2p/internal/handshake/metrics.go +++ b/pkg/p2p/libp2p/internal/handshake/metrics.go @@ -8,7 +8,7 @@ import ( m "github.com/ethersphere/bee/v2/pkg/metrics" ) -// metrics groups handshake related m counters. +// metrics groups handshake related prometheus counters. type metrics struct { SynRx m.Counter SynRxFailed m.Counter @@ -62,7 +62,7 @@ func newMetrics() metrics { } } -// Metrics returns set of m collectors. +// Metrics returns set of prometheus collectors. func (s *Service) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(s.metrics) } diff --git a/pkg/sharky/metrics.go b/pkg/sharky/metrics.go index 23bf47f0098..9cebbe24d4c 100644 --- a/pkg/sharky/metrics.go +++ b/pkg/sharky/metrics.go @@ -8,7 +8,7 @@ import ( m "github.com/ethersphere/bee/v2/pkg/metrics" ) -// metrics groups sharky related m counters. +// metrics groups sharky related prometheus counters. type metrics struct { TotalWriteCalls m.Counter TotalWriteCallsErr m.Counter @@ -111,7 +111,7 @@ between actual lengths of chunks and the length of slot. } } -// Metrics returns set of m collectors. +// Metrics returns set of prometheus collectors. func (s *Store) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(s.metrics) } diff --git a/pkg/storer/internal/transaction/transaction.go b/pkg/storer/internal/transaction/transaction.go index e19082d5e4a..5feb68e9969 100644 --- a/pkg/storer/internal/transaction/transaction.go +++ b/pkg/storer/internal/transaction/transaction.go @@ -140,7 +140,7 @@ func (s *store) Run(ctx context.Context, f func(Store) error) error { return trx.Commit() } -// Metrics returns set of m collectors. +// Metrics returns set of prometheus collectors. func (s *store) Metrics() []m.Collector { return m.PrometheusCollectorsFromFields(s.metrics) } diff --git a/pkg/storer/metrics.go b/pkg/storer/metrics.go index 60c2ee5d938..eecfe687bf1 100644 --- a/pkg/storer/metrics.go +++ b/pkg/storer/metrics.go @@ -14,7 +14,7 @@ import ( "github.com/ethersphere/bee/v2/pkg/swarm" ) -// metrics groups storer related m counters. +// metrics groups storer related prometheus counters. type metrics struct { MethodCalls m.CounterMetricVector MethodCallsDuration m.HistogramMetricVector diff --git a/pkg/storer/storer.go b/pkg/storer/storer.go index 117e277d4a3..137ae5eaa3b 100644 --- a/pkg/storer/storer.go +++ b/pkg/storer/storer.go @@ -370,7 +370,7 @@ func initDiskRepository( const lockKeyNewSession string = "new_session" type HistogramVecBox struct { - Vec m.HistogramMetricVector // или HistogramVec + Vec m.HistogramMetricVector } // Options provides a container to configure different things in the storer. @@ -603,7 +603,7 @@ func (db *DB) ResetReserve(ctx context.Context) error { return db.reserve.Reset(ctx) } -// Metrics returns set of m collectors. +// Metrics returns set of prometheus collectors. func (db *DB) Metrics() []m.Collector { collectors := m.PrometheusCollectorsFromFields(db.metrics) if v, ok := db.storage.(m.MetricsCollector); ok { From c0be851fce7b396b4e2851e17f3f5259d4c2843e Mon Sep 17 00:00:00 2001 From: vadim Date: Tue, 7 Oct 2025 15:58:53 +0200 Subject: [PATCH 6/6] chore: goimports --- pkg/hive/pb/hive.pb.go | 3 ++- pkg/manifest/mantaray/persist.go | 1 + pkg/node/node.go | 11 +++++------ pkg/p2p/libp2p/internal/handshake/pb/handshake.pb.go | 3 ++- pkg/p2p/libp2p/internal/headers/pb/headers.pb.go | 3 ++- pkg/p2p/protobuf/internal/pb/test.pb.go | 3 ++- pkg/pingpong/pb/pingpong.pb.go | 3 ++- pkg/pricer/headerutils/utilities.go | 1 + pkg/pricing/pb/pricing.pb.go | 3 ++- pkg/pullsync/pb/pullsync.pb.go | 3 ++- pkg/pushsync/pb/pushsync.pb.go | 3 ++- pkg/resolver/client/ens/ens_integration_test.go | 1 + pkg/retrieval/pb/retrieval.pb.go | 3 ++- pkg/settlement/pseudosettle/pb/pseudosettle.pb.go | 3 ++- pkg/settlement/swap/chequebook/factory.go | 1 + pkg/settlement/swap/swapprotocol/export_test.go | 1 + pkg/settlement/swap/swapprotocol/pb/swap.pb.go | 3 ++- pkg/status/internal/pb/status.pb.go | 3 ++- 18 files changed, 34 insertions(+), 18 deletions(-) diff --git a/pkg/hive/pb/hive.pb.go b/pkg/hive/pb/hive.pb.go index a3f108a0bcb..856d7c1991f 100644 --- a/pkg/hive/pb/hive.pb.go +++ b/pkg/hive/pb/hive.pb.go @@ -5,10 +5,11 @@ package pb import ( fmt "fmt" - proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" + + proto "github.com/gogo/protobuf/proto" ) // Reference imports to suppress errors if they are not otherwise used. diff --git a/pkg/manifest/mantaray/persist.go b/pkg/manifest/mantaray/persist.go index 259785d803c..b59e58fed70 100644 --- a/pkg/manifest/mantaray/persist.go +++ b/pkg/manifest/mantaray/persist.go @@ -7,6 +7,7 @@ package mantaray import ( "context" "errors" + "golang.org/x/sync/errgroup" ) diff --git a/pkg/node/node.go b/pkg/node/node.go index 60f7590e641..575ee44cbeb 100644 --- a/pkg/node/node.go +++ b/pkg/node/node.go @@ -35,7 +35,6 @@ import ( "github.com/ethersphere/bee/v2/pkg/gsoc" "github.com/ethersphere/bee/v2/pkg/hive" "github.com/ethersphere/bee/v2/pkg/log" - "github.com/ethersphere/bee/v2/pkg/metrics" m "github.com/ethersphere/bee/v2/pkg/metrics" "github.com/ethersphere/bee/v2/pkg/p2p" "github.com/ethersphere/bee/v2/pkg/p2p/libp2p" @@ -1282,20 +1281,20 @@ func NewBee( apiService.MustRegisterMetrics(lightNodes.Metrics()...) apiService.MustRegisterMetrics(hive.Metrics()...) - if bs, ok := batchStore.(metrics.MetricsCollector); ok { + if bs, ok := batchStore.(m.MetricsCollector); ok { apiService.MustRegisterMetrics(bs.Metrics()...) } - if ls, ok := eventListener.(metrics.MetricsCollector); ok { + if ls, ok := eventListener.(m.MetricsCollector); ok { apiService.MustRegisterMetrics(ls.Metrics()...) } - if pssServiceMetrics, ok := pssService.(metrics.MetricsCollector); ok { + if pssServiceMetrics, ok := pssService.(m.MetricsCollector); ok { apiService.MustRegisterMetrics(pssServiceMetrics.Metrics()...) } - if swapBackendMetrics, ok := chainBackend.(metrics.MetricsCollector); ok { + if swapBackendMetrics, ok := chainBackend.(m.MetricsCollector); ok { apiService.MustRegisterMetrics(swapBackendMetrics.Metrics()...) } - if l, ok := logger.(metrics.MetricsCollector); ok { + if l, ok := logger.(m.MetricsCollector); ok { apiService.MustRegisterMetrics(l.Metrics()...) } apiService.MustRegisterMetrics(pseudosettleService.Metrics()...) diff --git a/pkg/p2p/libp2p/internal/handshake/pb/handshake.pb.go b/pkg/p2p/libp2p/internal/handshake/pb/handshake.pb.go index 0ae7f00ebf6..799f478429d 100644 --- a/pkg/p2p/libp2p/internal/handshake/pb/handshake.pb.go +++ b/pkg/p2p/libp2p/internal/handshake/pb/handshake.pb.go @@ -5,10 +5,11 @@ package pb import ( fmt "fmt" - proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" + + proto "github.com/gogo/protobuf/proto" ) // Reference imports to suppress errors if they are not otherwise used. diff --git a/pkg/p2p/libp2p/internal/headers/pb/headers.pb.go b/pkg/p2p/libp2p/internal/headers/pb/headers.pb.go index c5652519eed..2efd44854a2 100644 --- a/pkg/p2p/libp2p/internal/headers/pb/headers.pb.go +++ b/pkg/p2p/libp2p/internal/headers/pb/headers.pb.go @@ -5,10 +5,11 @@ package pb import ( fmt "fmt" - proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" + + proto "github.com/gogo/protobuf/proto" ) // Reference imports to suppress errors if they are not otherwise used. diff --git a/pkg/p2p/protobuf/internal/pb/test.pb.go b/pkg/p2p/protobuf/internal/pb/test.pb.go index 2ca5f3d8ac8..660fcb31cc1 100644 --- a/pkg/p2p/protobuf/internal/pb/test.pb.go +++ b/pkg/p2p/protobuf/internal/pb/test.pb.go @@ -5,10 +5,11 @@ package pb import ( fmt "fmt" - proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" + + proto "github.com/gogo/protobuf/proto" ) // Reference imports to suppress errors if they are not otherwise used. diff --git a/pkg/pingpong/pb/pingpong.pb.go b/pkg/pingpong/pb/pingpong.pb.go index 536cbf6a254..0b6656053ab 100644 --- a/pkg/pingpong/pb/pingpong.pb.go +++ b/pkg/pingpong/pb/pingpong.pb.go @@ -5,10 +5,11 @@ package pb import ( fmt "fmt" - proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" + + proto "github.com/gogo/protobuf/proto" ) // Reference imports to suppress errors if they are not otherwise used. diff --git a/pkg/pricer/headerutils/utilities.go b/pkg/pricer/headerutils/utilities.go index a85e56990b4..2576df0c1c8 100644 --- a/pkg/pricer/headerutils/utilities.go +++ b/pkg/pricer/headerutils/utilities.go @@ -7,6 +7,7 @@ package headerutils import ( "encoding/binary" "errors" + "github.com/ethersphere/bee/v2/pkg/p2p" "github.com/ethersphere/bee/v2/pkg/swarm" ) diff --git a/pkg/pricing/pb/pricing.pb.go b/pkg/pricing/pb/pricing.pb.go index 949eba00bb2..02103ee355c 100644 --- a/pkg/pricing/pb/pricing.pb.go +++ b/pkg/pricing/pb/pricing.pb.go @@ -5,10 +5,11 @@ package pb import ( fmt "fmt" - proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" + + proto "github.com/gogo/protobuf/proto" ) // Reference imports to suppress errors if they are not otherwise used. diff --git a/pkg/pullsync/pb/pullsync.pb.go b/pkg/pullsync/pb/pullsync.pb.go index 452ffeeca8d..abe43f47a05 100644 --- a/pkg/pullsync/pb/pullsync.pb.go +++ b/pkg/pullsync/pb/pullsync.pb.go @@ -5,10 +5,11 @@ package pb import ( fmt "fmt" - proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" + + proto "github.com/gogo/protobuf/proto" ) // Reference imports to suppress errors if they are not otherwise used. diff --git a/pkg/pushsync/pb/pushsync.pb.go b/pkg/pushsync/pb/pushsync.pb.go index 352abd774d7..11fa8468607 100644 --- a/pkg/pushsync/pb/pushsync.pb.go +++ b/pkg/pushsync/pb/pushsync.pb.go @@ -5,10 +5,11 @@ package pb import ( fmt "fmt" - proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" + + proto "github.com/gogo/protobuf/proto" ) // Reference imports to suppress errors if they are not otherwise used. diff --git a/pkg/resolver/client/ens/ens_integration_test.go b/pkg/resolver/client/ens/ens_integration_test.go index f5aa9b1d9d7..6170e59448d 100644 --- a/pkg/resolver/client/ens/ens_integration_test.go +++ b/pkg/resolver/client/ens/ens_integration_test.go @@ -12,6 +12,7 @@ import ( "github.com/ethersphere/bee/v2/pkg/resolver/client/ens" "github.com/ethersphere/bee/v2/pkg/swarm" + "github.com/ethersphere/bee/v2/pkg/util/testutil" ) func TestENSIntegration(t *testing.T) { diff --git a/pkg/retrieval/pb/retrieval.pb.go b/pkg/retrieval/pb/retrieval.pb.go index 315d6d363dd..968af48ef44 100644 --- a/pkg/retrieval/pb/retrieval.pb.go +++ b/pkg/retrieval/pb/retrieval.pb.go @@ -5,10 +5,11 @@ package pb import ( fmt "fmt" - proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" + + proto "github.com/gogo/protobuf/proto" ) // Reference imports to suppress errors if they are not otherwise used. diff --git a/pkg/settlement/pseudosettle/pb/pseudosettle.pb.go b/pkg/settlement/pseudosettle/pb/pseudosettle.pb.go index 41d81fbd1c6..b1088896979 100644 --- a/pkg/settlement/pseudosettle/pb/pseudosettle.pb.go +++ b/pkg/settlement/pseudosettle/pb/pseudosettle.pb.go @@ -5,10 +5,11 @@ package pb import ( fmt "fmt" - proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" + + proto "github.com/gogo/protobuf/proto" ) // Reference imports to suppress errors if they are not otherwise used. diff --git a/pkg/settlement/swap/chequebook/factory.go b/pkg/settlement/swap/chequebook/factory.go index f548643bac1..c349f4cddce 100644 --- a/pkg/settlement/swap/chequebook/factory.go +++ b/pkg/settlement/swap/chequebook/factory.go @@ -10,6 +10,7 @@ import ( "math/big" "context" + "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/common" "github.com/ethersphere/bee/v2/pkg/sctx" diff --git a/pkg/settlement/swap/swapprotocol/export_test.go b/pkg/settlement/swap/swapprotocol/export_test.go index 31fc9e6b79f..7a7c31ab773 100644 --- a/pkg/settlement/swap/swapprotocol/export_test.go +++ b/pkg/settlement/swap/swapprotocol/export_test.go @@ -6,6 +6,7 @@ package swapprotocol import ( "context" + "github.com/ethersphere/bee/v2/pkg/p2p" ) diff --git a/pkg/settlement/swap/swapprotocol/pb/swap.pb.go b/pkg/settlement/swap/swapprotocol/pb/swap.pb.go index 5cf6ba49fd9..cf8279f49b1 100644 --- a/pkg/settlement/swap/swapprotocol/pb/swap.pb.go +++ b/pkg/settlement/swap/swapprotocol/pb/swap.pb.go @@ -5,10 +5,11 @@ package pb import ( fmt "fmt" - proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" + + proto "github.com/gogo/protobuf/proto" ) // Reference imports to suppress errors if they are not otherwise used. diff --git a/pkg/status/internal/pb/status.pb.go b/pkg/status/internal/pb/status.pb.go index 225d292ab4c..b22ca9b71c3 100644 --- a/pkg/status/internal/pb/status.pb.go +++ b/pkg/status/internal/pb/status.pb.go @@ -6,10 +6,11 @@ package pb import ( encoding_binary "encoding/binary" fmt "fmt" - proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" + + proto "github.com/gogo/protobuf/proto" ) // Reference imports to suppress errors if they are not otherwise used.