diff --git a/common/remotedatasourcefetcher/root.go b/common/remotedatasourcefetcher/root.go
index 22f0aa0c..bfd2c99f 100644
--- a/common/remotedatasourcefetcher/root.go
+++ b/common/remotedatasourcefetcher/root.go
@@ -8,7 +8,6 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
-	"fmt"
 	"net/http"
 	"sync"
 	"time"
@@ -21,7 +20,9 @@ import (
 	"akvorado/common/reporter"
 )
 
-// ProviderFunc is the callback function to call when a datasource is refreshed  implementZ.
+// ProviderFunc is the callback function to call when a datasource is refreshed.
+// The error returned is used for metrics. One should avoid having too many
+// different errors.
 type ProviderFunc func(ctx context.Context, name string, source RemoteDataSource) (int, error)
 
 // Component represents a remote data source fetcher.
@@ -49,9 +50,27 @@ func New[T interface{}](r *reporter.Reporter, provider ProviderFunc, dataType st
 	return &c, nil
 }
 
-// Fetch retrieves data from a configured RemoteDataSource, and returns a list of results
-// decoded from JSON to generic type.
-// Fetch should be used in UpdateRemoteDataSource implementations to update internal data from results.
+var (
+	// ErrBuildRequest is triggered when we cannot build an HTTP request
+	ErrBuildRequest = errors.New("cannot build HTTP request")
+	// ErrFetchDataSource is triggered when we cannot fetch the data source
+	ErrFetchDataSource = errors.New("cannot fetch data source")
+	// ErrStatusCode is triggered if status code is not 200
+	ErrStatusCode = errors.New("unexpected HTTP status code")
+	// ErrJSONDecode is triggered for any decoding issue
+	ErrJSONDecode = errors.New("cannot decode JSON")
+	// ErrMapResult is triggered when we cannot map the JSON result to the expected structure
+	ErrMapResult = errors.New("cannot map JSON")
+	// ErrJQExecute is triggered when we cannot execute the jq filter
+	ErrJQExecute = errors.New("cannot execute jq filter")
+	// ErrEmpty is triggered if the results are empty
+	ErrEmpty = errors.New("empty result")
+)
+
+// Fetch retrieves data from a configured RemoteDataSource, and returns a list
+// of results decoded from JSON to generic type. Fetch should be used in
+// UpdateRemoteDataSource implementations to update internal data from results.
+// It outputs errors without details because they are used for metrics.
 func (c *Component[T]) Fetch(ctx context.Context, name string, source RemoteDataSource) ([]T, error) {
 	var results []T
 	l := c.r.With().Str("name", name).Str("url", source.URL).Logger()
@@ -61,31 +80,30 @@ func (c *Component[T]) Fetch(ctx context.Context, name string, source RemoteData
 		Proxy: http.ProxyFromEnvironment,
 	}}
 	req, err := http.NewRequestWithContext(ctx, source.Method, source.URL, nil)
+	if err != nil {
+		l.Err(err).Msg("unable to build new request")
+		return results, ErrBuildRequest
+	}
 	for headerName, headerValue := range source.Headers {
 		req.Header.Set(headerName, headerValue)
 	}
 	req.Header.Set("accept", "application/json")
-	if err != nil {
-		l.Err(err).Msg("unable to build new request")
-		return results, fmt.Errorf("unable to build new request: %w", err)
-	}
 	resp, err := client.Do(req)
 	if err != nil {
 		l.Err(err).Msg("unable to fetch data source")
-		return results, fmt.Errorf("unable to fetch data source: %w", err)
+		return results, ErrFetchDataSource
 	}
 	defer resp.Body.Close()
 	if resp.StatusCode != 200 {
-		err := fmt.Errorf("unexpected status code %d: %s", resp.StatusCode, resp.Status)
-		l.Error().Msg(err.Error())
-		return results, err
+		l.Error().Int("status", resp.StatusCode).Msg("unexpected status code")
+		return results, ErrStatusCode
 	}
 	reader := bufio.NewReader(resp.Body)
 	decoder := json.NewDecoder(reader)
 	var got interface{}
 	if err := decoder.Decode(&got); err != nil {
 		l.Err(err).Msg("cannot decode JSON output")
-		return results, fmt.Errorf("cannot decode JSON output: %w", err)
+		return results, ErrJSONDecode
 	}
 
 	iter := source.Transform.Query.RunWithContext(ctx, got)
@@ -96,7 +114,7 @@ func (c *Component[T]) Fetch(ctx context.Context, name string, source RemoteData
 		}
 		if err, ok := v.(error); ok {
 			l.Err(err).Msg("cannot execute jq filter")
-			return results, fmt.Errorf("cannot execute jq filter: %w", err)
+			return results, ErrJQExecute
 		}
 		var result T
 		config := &mapstructure.DecoderConfig{
@@ -110,14 +128,13 @@ func (c *Component[T]) Fetch(ctx context.Context, name string, source RemoteData
 		}
 		if err := decoder.Decode(v); err != nil {
 			l.Err(err).Msgf("cannot map returned value for %#v", v)
-			return results, fmt.Errorf("cannot map returned value: %w", err)
+			return results, ErrMapResult
 		}
 		results = append(results, result)
 	}
 	if len(results) == 0 {
-		err := errors.New("empty results")
-		l.Error().Msg(err.Error())
-		return results, err
+		l.Error().Msg("empty result")
+		return results, ErrEmpty
 	}
 	return results, nil
 }
diff --git a/demoexporter/bmp/client.go b/demoexporter/bmp/client.go
index bdf46bc3..59f97022 100644
--- a/demoexporter/bmp/client.go
+++ b/demoexporter/bmp/client.go
@@ -22,7 +22,7 @@ func (c *Component) startBMPClient(ctx context.Context) {
 	conn, err := d.DialContext(ctx, "tcp", c.config.Target)
 	if err != nil {
 		c.r.Err(err).Msg("cannot connect to target")
-		c.metrics.errors.WithLabelValues(err.Error()).Inc()
+		c.metrics.errors.WithLabelValues("cannot connect").Inc()
 		return
 	}
 	c.metrics.connections.Inc()
@@ -116,7 +116,7 @@ func (c *Component) startBMPClient(ctx context.Context) {
 	// Send the packets on the wire
 	if _, err := conn.Write(buf.Bytes()); err != nil {
 		c.r.Err(err).Msg("cannot write BMP message to target")
-		c.metrics.errors.WithLabelValues(err.Error()).Inc()
+		c.metrics.errors.WithLabelValues("cannot write").Inc()
 		return
 	}
 
@@ -135,7 +135,7 @@ func (c *Component) startBMPClient(ctx context.Context) {
 			buf.Write(pkt)
 			if _, err := conn.Write(buf.Bytes()); err != nil && err != io.EOF && !errors.Is(err, syscall.ECONNRESET) && !errors.Is(err, syscall.EPIPE) {
 				c.r.Err(err).Msg("cannot write to remote")
-				c.metrics.errors.WithLabelValues(err.Error()).Inc()
+				c.metrics.errors.WithLabelValues("cannot write").Inc()
 				close(done)
 				return
 			} else if err != nil {
diff --git a/demoexporter/flows/root.go b/demoexporter/flows/root.go
index 7e9020a7..5d24c481 100644
--- a/demoexporter/flows/root.go
+++ b/demoexporter/flows/root.go
@@ -87,7 +87,7 @@ func (c *Component) Start() error {
 			for payload := range payloads {
 				sequenceNumber++
 				if _, err := conn.Write(payload); err != nil {
-					c.metrics.errors.WithLabelValues(err.Error()).Inc()
+					c.metrics.errors.WithLabelValues("cannot write").Inc()
 					errLogger.Err(err).Msg("unable to send UDP payload")
 				} else {
 					c.metrics.sent.WithLabelValues(kind).Inc()
diff --git a/inlet/flow/input/udp/root.go b/inlet/flow/input/udp/root.go
index d5bee048..a2d4ee86 100644
--- a/inlet/flow/input/udp/root.go
+++ b/inlet/flow/input/udp/root.go
@@ -31,7 +31,7 @@ type Input struct {
 		packets       *reporter.CounterVec
 		packetSizeSum *reporter.SummaryVec
 		errors        *reporter.CounterVec
-		inDrops       *reporter.GaugeVec
+		inDrops       *reporter.CounterVec
 	}
 
 	address net.Addr       // listening address, for testing purpoese
@@ -62,7 +62,7 @@ func (configuration *Configuration) New(r *reporter.Reporter, daemon daemon.Comp
 	)
 	input.metrics.packetSizeSum = r.SummaryVec(
 		reporter.SummaryOpts{
-			Name:       "summary_size_bytes",
+			Name:       "size_bytes",
 			Help:       "Summary of packet size.",
 			Objectives: map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.99: 0.001},
 		},
@@ -75,8 +75,8 @@ func (configuration *Configuration) New(r *reporter.Reporter, daemon daemon.Comp
 		},
 		[]string{"listener", "worker"},
 	)
-	input.metrics.inDrops = r.GaugeVec(
-		reporter.GaugeOpts{
+	input.metrics.inDrops = r.CounterVec(
+		reporter.CounterOpts{
 			Name: "in_dropped_packets_total",
 			Help: "Dropped packets due to listen queue full.",
 		},
@@ -156,10 +156,8 @@ func (in *Input) Start() error {
 				if err != nil {
 					errLogger.Err(err).Msg("unable to decode UDP control message")
 				} else {
-					if count < 100 || count%100 == 0 {
-						in.metrics.inDrops.WithLabelValues(listen, worker).Set(
-							float64(oobMsg.Drops))
-					}
+					in.metrics.inDrops.WithLabelValues(listen, worker).Add(
+						float64(oobMsg.Drops))
 				}
 				if oobMsg.Received.IsZero() {
 					oobMsg.Received = time.Now()
diff --git a/inlet/flow/input/udp/root_test.go b/inlet/flow/input/udp/root_test.go
index 3c54047d..3833e896 100644
--- a/inlet/flow/input/udp/root_test.go
+++ b/inlet/flow/input/udp/root_test.go
@@ -38,14 +38,14 @@ func TestUDPInput(t *testing.T) {
 		// Check metrics
 		gotMetrics := r.GetMetrics("akvorado_inlet_flow_input_udp_")
 		expectedMetrics := map[string]string{
-			`bytes_total{exporter="127.0.0.1",listener="127.0.0.1:0",worker="0"}`:                        "12",
-			`packets_total{exporter="127.0.0.1",listener="127.0.0.1:0",worker="0"}`:                      "1",
-			`in_dropped_packets_total{listener="127.0.0.1:0",worker="0"}`:                                "0",
-			`summary_size_bytes_count{exporter="127.0.0.1",listener="127.0.0.1:0",worker="0"}`:           "1",
-			`summary_size_bytes_sum{exporter="127.0.0.1",listener="127.0.0.1:0",worker="0"}`:             "12",
-			`summary_size_bytes{exporter="127.0.0.1",listener="127.0.0.1:0",worker="0",quantile="0.5"}`:  "12",
-			`summary_size_bytes{exporter="127.0.0.1",listener="127.0.0.1:0",worker="0",quantile="0.9"}`:  "12",
-			`summary_size_bytes{exporter="127.0.0.1",listener="127.0.0.1:0",worker="0",quantile="0.99"}`: "12",
+			`bytes_total{exporter="127.0.0.1",listener="127.0.0.1:0",worker="0"}`:                "12",
+			`packets_total{exporter="127.0.0.1",listener="127.0.0.1:0",worker="0"}`:              "1",
+			`in_dropped_packets_total{listener="127.0.0.1:0",worker="0"}`:                        "0",
+			`size_bytes_count{exporter="127.0.0.1",listener="127.0.0.1:0",worker="0"}`:           "1",
+			`size_bytes_sum{exporter="127.0.0.1",listener="127.0.0.1:0",worker="0"}`:             "12",
+			`size_bytes{exporter="127.0.0.1",listener="127.0.0.1:0",worker="0",quantile="0.5"}`:  "12",
+			`size_bytes{exporter="127.0.0.1",listener="127.0.0.1:0",worker="0",quantile="0.9"}`:  "12",
+			`size_bytes{exporter="127.0.0.1",listener="127.0.0.1:0",worker="0",quantile="0.99"}`: "12",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
 			t.Fatalf("Input metrics (-got, +want):\n%s", diff)
diff --git a/outlet/core/metrics.go b/outlet/core/metrics.go
index 25baa6ad..a383e0ca 100644
--- a/outlet/core/metrics.go
+++ b/outlet/core/metrics.go
@@ -69,7 +69,7 @@ func (c *Component) initMetrics() {
 
 	c.metrics.classifierExporterCacheSize = c.r.CounterFunc(
 		reporter.CounterOpts{
-			Name: "classifier_exporter_cache_size_items",
+			Name: "classifier_exporter_cache_items_total",
 			Help: "Number of items in the exporter classifier cache",
 		},
 		func() float64 {
@@ -78,7 +78,7 @@ func (c *Component) initMetrics() {
 	)
 	c.metrics.classifierInterfaceCacheSize = c.r.CounterFunc(
 		reporter.CounterOpts{
-			Name: "classifier_interface_cache_size_items",
+			Name: "classifier_interface_cache_items_total",
 			Help: "Number of items in the interface classifier cache",
 		},
 		func() float64 {
diff --git a/outlet/core/root_test.go b/outlet/core/root_test.go
index 79c2aa5d..14407eda 100644
--- a/outlet/core/root_test.go
+++ b/outlet/core/root_test.go
@@ -149,8 +149,8 @@ func TestCore(t *testing.T) {
 
 		gotMetrics := r.GetMetrics("akvorado_outlet_core_", "-flows_processing_")
 		expectedMetrics := map[string]string{
-			`classifier_exporter_cache_size_items`:                               "0",
-			`classifier_interface_cache_size_items`:                              "0",
+			`classifier_exporter_cache_items_total`:                              "0",
+			`classifier_interface_cache_items_total`:                             "0",
 			`flows_errors_total{error="SNMP cache miss",exporter="192.0.2.142"}`: "1",
 			`flows_errors_total{error="SNMP cache miss",exporter="192.0.2.143"}`: "3",
 			`received_flows_total{exporter="192.0.2.142"}`:                       "1",
@@ -178,8 +178,8 @@ func TestCore(t *testing.T) {
 		time.Sleep(20 * time.Millisecond)
 		gotMetrics = r.GetMetrics("akvorado_outlet_core_", "classifier_", "-flows_processing_", "flows_", "received_", "forwarded_")
 		expectedMetrics = map[string]string{
-			`classifier_exporter_cache_size_items`:                               "0",
-			`classifier_interface_cache_size_items`:                              "0",
+			`classifier_exporter_cache_items_total`:                              "0",
+			`classifier_interface_cache_items_total`:                             "0",
 			`flows_errors_total{error="SNMP cache miss",exporter="192.0.2.142"}`: "1",
 			`flows_errors_total{error="SNMP cache miss",exporter="192.0.2.143"}`: "3",
 			`received_flows_total{exporter="192.0.2.142"}`:                       "2",
@@ -219,8 +219,8 @@ func TestCore(t *testing.T) {
 
 		gotMetrics = r.GetMetrics("akvorado_outlet_core_", "classifier_", "-flows_processing_", "flows_", "forwarded_", "received_")
 		expectedMetrics = map[string]string{
-			`classifier_exporter_cache_size_items`:                                     "0",
-			`classifier_interface_cache_size_items`:                                    "0",
+			`classifier_exporter_cache_items_total`:                                    "0",
+			`classifier_interface_cache_items_total`:                                   "0",
 			`flows_errors_total{error="SNMP cache miss",exporter="192.0.2.142"}`:       "1",
 			`flows_errors_total{error="SNMP cache miss",exporter="192.0.2.143"}`:       "3",
 			`flows_errors_total{error="sampling rate missing",exporter="192.0.2.142"}`: "1",
diff --git a/outlet/flow/decoder/netflow/root.go b/outlet/flow/decoder/netflow/root.go
index 5bc3daa0..99bff4af 100644
--- a/outlet/flow/decoder/netflow/root.go
+++ b/outlet/flow/decoder/netflow/root.go
@@ -34,11 +34,11 @@ type Decoder struct {
 	sampling    map[string]*samplingRateSystem
 
 	metrics struct {
-		errors             *reporter.CounterVec
-		stats              *reporter.CounterVec
-		setRecordsStatsSum *reporter.CounterVec
-		setStatsSum        *reporter.CounterVec
-		templatesStats     *reporter.CounterVec
+		errors    *reporter.CounterVec
+		packets   *reporter.CounterVec
+		records   *reporter.CounterVec
+		sets      *reporter.CounterVec
+		templates *reporter.CounterVec
 	}
 }
 
@@ -55,35 +55,35 @@ func New(r *reporter.Reporter, dependencies decoder.Dependencies) decoder.Decode
 	nd.metrics.errors = nd.r.CounterVec(
 		reporter.CounterOpts{
 			Name: "errors_total",
-			Help: "Netflows processed errors.",
+			Help: "Number of NetFlow errors processed.",
 		},
 		[]string{"exporter", "error"},
 	)
-	nd.metrics.stats = nd.r.CounterVec(
+	nd.metrics.packets = nd.r.CounterVec(
 		reporter.CounterOpts{
-			Name: "flows_total",
-			Help: "Netflows processed.",
+			Name: "packets_total",
+			Help: "Number of NetFlow packets received.",
 		},
 		[]string{"exporter", "version"},
 	)
-	nd.metrics.setRecordsStatsSum = nd.r.CounterVec(
+	nd.metrics.sets = nd.r.CounterVec(
 		reporter.CounterOpts{
-			Name: "flowset_records_sum",
-			Help: "Netflows FlowSets sum of records.",
+			Name: "sets_total",
+			Help: "Number of NetFlow flowsets received.",
 		},
 		[]string{"exporter", "version", "type"},
 	)
-	nd.metrics.setStatsSum = nd.r.CounterVec(
+	nd.metrics.records = nd.r.CounterVec(
 		reporter.CounterOpts{
-			Name: "flowset_sum",
-			Help: "Netflows FlowSets sum.",
+			Name: "records_total",
+			Help: "Number of NetFlow records received.",
 		},
 		[]string{"exporter", "version", "type"},
 	)
-	nd.metrics.templatesStats = nd.r.CounterVec(
+	nd.metrics.templates = nd.r.CounterVec(
 		reporter.CounterOpts{
 			Name: "templates_total",
-			Help: "Netflows Template count.",
+			Help: "Number of NetFlow templates received.",
 		},
 		[]string{"exporter", "version", "obs_domain_id", "template_id", "type"},
 	)
@@ -115,7 +115,7 @@ func (s *templateSystem) AddTemplate(version uint16, obsDomainID uint32, templat
 		typeStr = "template"
 	}
 
-	s.nd.metrics.templatesStats.WithLabelValues(
+	s.nd.metrics.templates.WithLabelValues(
 		s.key,
 		strconv.Itoa(int(version)),
 		strconv.Itoa(int(obsDomainID)),
@@ -220,8 +220,8 @@ func (nd *Decoder) Decode(in decoder.RawFlow, options decoder.Option, bf *schema
 			return 0, fmt.Errorf("NetFlow v5 decoding error: %w", err)
 		}
 		versionStr = "5"
-		nd.metrics.setStatsSum.WithLabelValues(key, versionStr, "PDU").Inc()
-		nd.metrics.setRecordsStatsSum.WithLabelValues(key, versionStr, "PDU").
+		nd.metrics.sets.WithLabelValues(key, versionStr, "PDU").Inc()
+		nd.metrics.records.WithLabelValues(key, versionStr, "PDU").
 			Add(float64(len(packetNFv5.Records)))
 		if options.TimestampSource == pb.RawFlow_TS_NETFLOW_PACKET || options.TimestampSource == pb.RawFlow_TS_NETFLOW_FIRST_SWITCHED {
 			ts = uint64(packetNFv5.UnixSecs)
@@ -267,39 +267,39 @@ func (nd *Decoder) Decode(in decoder.RawFlow, options decoder.Option, bf *schema
 		nd.decodeNFv9IPFIX(version, obsDomainID, flowSets, sampling, ts, sysUptime, options, bf, finalize2)
 	default:
 		nd.errLogger.Warn().Str("exporter", key).Msg("unknown NetFlow version")
-		nd.metrics.stats.WithLabelValues(key, "unknown").
+		nd.metrics.packets.WithLabelValues(key, "unknown").
 			Inc()
 		return 0, errors.New("unkown NetFlow version")
 	}
-	nd.metrics.stats.WithLabelValues(key, versionStr).Inc()
+	nd.metrics.packets.WithLabelValues(key, versionStr).Inc()
 
 	nb := 0
 	for _, fs := range flowSets {
 		switch fsConv := fs.(type) {
 		case netflow.TemplateFlowSet:
-			nd.metrics.setStatsSum.WithLabelValues(key, versionStr, "TemplateFlowSet").
+			nd.metrics.sets.WithLabelValues(key, versionStr, "TemplateFlowSet").
 				Inc()
-			nd.metrics.setRecordsStatsSum.WithLabelValues(key, versionStr, "TemplateFlowSet").
+			nd.metrics.records.WithLabelValues(key, versionStr, "TemplateFlowSet").
 				Add(float64(len(fsConv.Records)))
 		case netflow.IPFIXOptionsTemplateFlowSet:
-			nd.metrics.setStatsSum.WithLabelValues(key, versionStr, "OptionsTemplateFlowSet").
+			nd.metrics.sets.WithLabelValues(key, versionStr, "OptionsTemplateFlowSet").
 				Inc()
-			nd.metrics.setRecordsStatsSum.WithLabelValues(key, versionStr, "OptionsTemplateFlowSet").
+			nd.metrics.records.WithLabelValues(key, versionStr, "OptionsTemplateFlowSet").
 				Add(float64(len(fsConv.Records)))
 		case netflow.NFv9OptionsTemplateFlowSet:
-			nd.metrics.setStatsSum.WithLabelValues(key, versionStr, "OptionsTemplateFlowSet").
+			nd.metrics.sets.WithLabelValues(key, versionStr, "OptionsTemplateFlowSet").
 				Inc()
-			nd.metrics.setRecordsStatsSum.WithLabelValues(key, versionStr, "OptionsTemplateFlowSet").
+			nd.metrics.records.WithLabelValues(key, versionStr, "OptionsTemplateFlowSet").
 				Add(float64(len(fsConv.Records)))
 		case netflow.OptionsDataFlowSet:
-			nd.metrics.setStatsSum.WithLabelValues(key, versionStr, "OptionsDataFlowSet").
+			nd.metrics.sets.WithLabelValues(key, versionStr, "OptionsDataFlowSet").
 				Inc()
-			nd.metrics.setRecordsStatsSum.WithLabelValues(key, versionStr, "OptionsDataFlowSet").
+			nd.metrics.records.WithLabelValues(key, versionStr, "OptionsDataFlowSet").
 				Add(float64(len(fsConv.Records)))
 		case netflow.DataFlowSet:
-			nd.metrics.setStatsSum.WithLabelValues(key, versionStr, "DataFlowSet").
+			nd.metrics.sets.WithLabelValues(key, versionStr, "DataFlowSet").
 				Inc()
-			nd.metrics.setRecordsStatsSum.WithLabelValues(key, versionStr, "DataFlowSet").
+			nd.metrics.records.WithLabelValues(key, versionStr, "DataFlowSet").
 				Add(float64(len(fsConv.Records)))
 			nb += len(fsConv.Records)
 		}
diff --git a/outlet/flow/decoder/netflow/root_test.go b/outlet/flow/decoder/netflow/root_test.go
index 62cdc814..86107deb 100644
--- a/outlet/flow/decoder/netflow/root_test.go
+++ b/outlet/flow/decoder/netflow/root_test.go
@@ -55,9 +55,9 @@ func TestDecode(t *testing.T) {
 	// Check metrics
 	gotMetrics := r.GetMetrics("akvorado_outlet_flow_decoder_netflow_")
 	expectedMetrics := map[string]string{
-		`flows_total{exporter="::ffff:127.0.0.1",version="9"}`:                                                                 "1",
-		`flowset_records_sum{exporter="::ffff:127.0.0.1",type="OptionsTemplateFlowSet",version="9"}`:                           "1",
-		`flowset_sum{exporter="::ffff:127.0.0.1",type="OptionsTemplateFlowSet",version="9"}`:                                   "1",
+		`packets_total{exporter="::ffff:127.0.0.1",version="9"}`:                                                               "1",
+		`records_total{exporter="::ffff:127.0.0.1",type="OptionsTemplateFlowSet",version="9"}`:                                 "1",
+		`sets_total{exporter="::ffff:127.0.0.1",type="OptionsTemplateFlowSet",version="9"}`:                                    "1",
 		`templates_total{exporter="::ffff:127.0.0.1",obs_domain_id="0",template_id="257",type="options_template",version="9"}`: "1",
 	}
 	if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
@@ -79,11 +79,11 @@ func TestDecode(t *testing.T) {
 	// Check metrics
 	gotMetrics = r.GetMetrics("akvorado_outlet_flow_decoder_netflow_")
 	expectedMetrics = map[string]string{
-		`flows_total{exporter="::ffff:127.0.0.1",version="9"}`:                                                                 "2",
-		`flowset_records_sum{exporter="::ffff:127.0.0.1",type="OptionsTemplateFlowSet",version="9"}`:                           "1",
-		`flowset_records_sum{exporter="::ffff:127.0.0.1",type="OptionsDataFlowSet",version="9"}`:                               "4",
-		`flowset_sum{exporter="::ffff:127.0.0.1",type="OptionsTemplateFlowSet",version="9"}`:                                   "1",
-		`flowset_sum{exporter="::ffff:127.0.0.1",type="OptionsDataFlowSet",version="9"}`:                                       "1",
+		`packets_total{exporter="::ffff:127.0.0.1",version="9"}`:                                                               "2",
+		`records_total{exporter="::ffff:127.0.0.1",type="OptionsTemplateFlowSet",version="9"}`:                                 "1",
+		`records_total{exporter="::ffff:127.0.0.1",type="OptionsDataFlowSet",version="9"}`:                                     "4",
+		`sets_total{exporter="::ffff:127.0.0.1",type="OptionsTemplateFlowSet",version="9"}`:                                    "1",
+		`sets_total{exporter="::ffff:127.0.0.1",type="OptionsDataFlowSet",version="9"}`:                                        "1",
 		`templates_total{exporter="::ffff:127.0.0.1",obs_domain_id="0",template_id="257",type="options_template",version="9"}`: "1",
 	}
 	if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
@@ -105,13 +105,13 @@ func TestDecode(t *testing.T) {
 	// Check metrics
 	gotMetrics = r.GetMetrics("akvorado_outlet_flow_decoder_netflow_")
 	expectedMetrics = map[string]string{
-		`flows_total{exporter="::ffff:127.0.0.1",version="9"}`:                                                                 "3",
-		`flowset_records_sum{exporter="::ffff:127.0.0.1",type="OptionsTemplateFlowSet",version="9"}`:                           "1",
-		`flowset_records_sum{exporter="::ffff:127.0.0.1",type="OptionsDataFlowSet",version="9"}`:                               "4",
-		`flowset_records_sum{exporter="::ffff:127.0.0.1",type="TemplateFlowSet",version="9"}`:                                  "1",
-		`flowset_sum{exporter="::ffff:127.0.0.1",type="OptionsTemplateFlowSet",version="9"}`:                                   "1",
-		`flowset_sum{exporter="::ffff:127.0.0.1",type="OptionsDataFlowSet",version="9"}`:                                       "1",
-		`flowset_sum{exporter="::ffff:127.0.0.1",type="TemplateFlowSet",version="9"}`:                                          "1",
+		`packets_total{exporter="::ffff:127.0.0.1",version="9"}`:                                                               "3",
+		`records_total{exporter="::ffff:127.0.0.1",type="OptionsTemplateFlowSet",version="9"}`:                                 "1",
+		`records_total{exporter="::ffff:127.0.0.1",type="OptionsDataFlowSet",version="9"}`:                                     "4",
+		`records_total{exporter="::ffff:127.0.0.1",type="TemplateFlowSet",version="9"}`:                                        "1",
+		`sets_total{exporter="::ffff:127.0.0.1",type="OptionsTemplateFlowSet",version="9"}`:                                    "1",
+		`sets_total{exporter="::ffff:127.0.0.1",type="OptionsDataFlowSet",version="9"}`:                                        "1",
+		`sets_total{exporter="::ffff:127.0.0.1",type="TemplateFlowSet",version="9"}`:                                           "1",
 		`templates_total{exporter="::ffff:127.0.0.1",obs_domain_id="0",template_id="257",type="options_template",version="9"}`: "1",
 		`templates_total{exporter="::ffff:127.0.0.1",obs_domain_id="0",template_id="260",type="template",version="9"}`:         "1",
 	}
@@ -216,20 +216,21 @@ func TestDecode(t *testing.T) {
 	}
 	gotMetrics = r.GetMetrics(
 		"akvorado_outlet_flow_decoder_netflow_",
-		"flows_total",
-		"flowset_",
+		"packets_",
+		"sets_",
+		"records_",
 		"templates_",
 	)
 	expectedMetrics = map[string]string{
-		`flows_total{exporter="::ffff:127.0.0.1",version="9"}`:                                                                 "4",
-		`flowset_records_sum{exporter="::ffff:127.0.0.1",type="DataFlowSet",version="9"}`:                                      "4",
-		`flowset_records_sum{exporter="::ffff:127.0.0.1",type="OptionsDataFlowSet",version="9"}`:                               "4",
-		`flowset_records_sum{exporter="::ffff:127.0.0.1",type="OptionsTemplateFlowSet",version="9"}`:                           "1",
-		`flowset_records_sum{exporter="::ffff:127.0.0.1",type="TemplateFlowSet",version="9"}`:                                  "1",
-		`flowset_sum{exporter="::ffff:127.0.0.1",type="DataFlowSet",version="9"}`:                                              "1",
-		`flowset_sum{exporter="::ffff:127.0.0.1",type="OptionsDataFlowSet",version="9"}`:                                       "1",
-		`flowset_sum{exporter="::ffff:127.0.0.1",type="OptionsTemplateFlowSet",version="9"}`:                                   "1",
-		`flowset_sum{exporter="::ffff:127.0.0.1",type="TemplateFlowSet",version="9"}`:                                          "1",
+		`packets_total{exporter="::ffff:127.0.0.1",version="9"}`:                                                               "4",
+		`records_total{exporter="::ffff:127.0.0.1",type="DataFlowSet",version="9"}`:                                            "4",
+		`records_total{exporter="::ffff:127.0.0.1",type="OptionsDataFlowSet",version="9"}`:                                     "4",
+		`records_total{exporter="::ffff:127.0.0.1",type="OptionsTemplateFlowSet",version="9"}`:                                 "1",
+		`records_total{exporter="::ffff:127.0.0.1",type="TemplateFlowSet",version="9"}`:                                        "1",
+		`sets_total{exporter="::ffff:127.0.0.1",type="DataFlowSet",version="9"}`:                                               "1",
+		`sets_total{exporter="::ffff:127.0.0.1",type="OptionsDataFlowSet",version="9"}`:                                        "1",
+		`sets_total{exporter="::ffff:127.0.0.1",type="OptionsTemplateFlowSet",version="9"}`:                                    "1",
+		`sets_total{exporter="::ffff:127.0.0.1",type="TemplateFlowSet",version="9"}`:                                           "1",
 		`templates_total{exporter="::ffff:127.0.0.1",obs_domain_id="0",template_id="257",type="options_template",version="9"}`: "1",
 		`templates_total{exporter="::ffff:127.0.0.1",obs_domain_id="0",template_id="260",type="template",version="9"}`:         "1",
 	}
diff --git a/outlet/metadata/provider/static/source.go b/outlet/metadata/provider/static/source.go
index f7cde167..6719b074 100644
--- a/outlet/metadata/provider/static/source.go
+++ b/outlet/metadata/provider/static/source.go
@@ -5,6 +5,7 @@ package static
 
 import (
 	"context"
+	"errors"
 
 	"akvorado/common/helpers"
 	"akvorado/common/remotedatasourcefetcher"
@@ -102,7 +103,7 @@ func (p *Provider) UpdateRemoteDataSource(ctx context.Context, name string, sour
 	p.exportersLock.Unlock()
 	exporters, err := helpers.NewSubnetMap[ExporterConfiguration](finalMap)
 	if err != nil {
-		return 0, err
+		return 0, errors.New("cannot create subnetmap")
 	}
 	p.exporters.Swap(exporters)
 	return len(results), nil
diff --git a/outlet/metadata/root.go b/outlet/metadata/root.go
index 656d3023..944b6024 100644
--- a/outlet/metadata/root.go
+++ b/outlet/metadata/root.go
@@ -102,7 +102,7 @@ func New(r *reporter.Reporter, configuration Configuration, dependencies Depende
 		})
 	c.metrics.cacheRefresh = r.Counter(
 		reporter.CounterOpts{
-			Name: "cache_refreshs",
+			Name: "cache_refreshs_total",
 			Help: "Number of entries refreshed in cache.",
 		})
 	c.metrics.providerBusyCount = r.CounterVec(
diff --git a/outlet/metadata/root_test.go b/outlet/metadata/root_test.go
index 939dcf2a..ba4d8a80 100644
--- a/outlet/metadata/root_test.go
+++ b/outlet/metadata/root_test.go
@@ -141,7 +141,7 @@ func TestAutoRefresh(t *testing.T) {
 			`misses_total`:          "1",
 			`size_entries`:          "1",
 			`refresh_runs_total`:    runs,
-			`refreshs`:              "1",
+			`refreshs_total`:        "1",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" && runs == "31" {
 			t.Fatalf("Metrics (-got, +want):\n%s", diff)
diff --git a/outlet/routing/provider/bmp/metrics.go b/outlet/routing/provider/bmp/metrics.go
index 9bbbc310..6dd7e443 100644
--- a/outlet/routing/provider/bmp/metrics.go
+++ b/outlet/routing/provider/bmp/metrics.go
@@ -39,14 +39,14 @@ func (p *Provider) initMetrics() {
 	)
 	p.metrics.peers = p.r.GaugeVec(
 		reporter.GaugeOpts{
-			Name: "peers_total",
+			Name: "peers",
 			Help: "Number of peers up.",
 		},
 		[]string{"exporter"},
 	)
 	p.metrics.routes = p.r.GaugeVec(
 		reporter.GaugeOpts{
-			Name: "routes_total",
+			Name: "routes",
 			Help: "Number of routes up.",
 		},
 		[]string{"exporter"},
@@ -77,7 +77,7 @@ func (p *Provider) initMetrics() {
 			Name: "ignored_updates_total",
 			Help: "Number of ignored BGP updates.",
 		},
-		[]string{"exporter", "reason", "error"},
+		[]string{"exporter", "error"},
 	)
 	p.metrics.panics = p.r.CounterVec(
 		reporter.CounterOpts{
diff --git a/outlet/routing/provider/bmp/root_test.go b/outlet/routing/provider/bmp/root_test.go
index 0ebed8ff..05e3e833 100644
--- a/outlet/routing/provider/bmp/root_test.go
+++ b/outlet/routing/provider/bmp/root_test.go
@@ -90,8 +90,8 @@ func TestBMP(t *testing.T) {
 		expectedMetrics := map[string]string{
 			`received_messages_total{exporter="127.0.0.1",type="initiation"}`: "1",
 			`opened_connections_total{exporter="127.0.0.1"}`:                  "1",
-			`peers_total{exporter="127.0.0.1"}`:                               "0",
-			`routes_total{exporter="127.0.0.1"}`:                              "0",
+			`peers{exporter="127.0.0.1"}`:                                     "0",
+			`routes{exporter="127.0.0.1"}`:                                    "0",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
 			t.Errorf("Metrics (-got, +want):\n%s", diff)
@@ -105,8 +105,8 @@ func TestBMP(t *testing.T) {
 			`received_messages_total{exporter="127.0.0.1",type="initiation"}`:  "1",
 			`received_messages_total{exporter="127.0.0.1",type="termination"}`: "1",
 			`opened_connections_total{exporter="127.0.0.1"}`:                   "1",
-			`peers_total{exporter="127.0.0.1"}`:                                "0",
-			`routes_total{exporter="127.0.0.1"}`:                               "0",
+			`peers{exporter="127.0.0.1"}`:                                      "0",
+			`routes{exporter="127.0.0.1"}`:                                     "0",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
 			t.Errorf("Metrics (-got, +want):\n%s", diff)
@@ -130,8 +130,8 @@ func TestBMP(t *testing.T) {
 				`received_messages_total{exporter="127.0.0.1",type="initiation"}`:  "1",
 				`received_messages_total{exporter="127.0.0.1",type="termination"}`: "1",
 				`opened_connections_total{exporter="127.0.0.1"}`:                   "1",
-				`peers_total{exporter="127.0.0.1"}`:                                "0",
-				`routes_total{exporter="127.0.0.1"}`:                               "0",
+				`peers{exporter="127.0.0.1"}`:                                      "0",
+				`routes{exporter="127.0.0.1"}`:                                     "0",
 			}
 			if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
 				if tries > 0 {
@@ -160,8 +160,8 @@ func TestBMP(t *testing.T) {
 			`received_messages_total{exporter="127.0.0.1",type="route-monitoring"}`:     "8",
 			`received_messages_total{exporter="127.0.0.1",type="statistics-report"}`:    "4",
 			`opened_connections_total{exporter="127.0.0.1"}`:                            "1",
-			`peers_total{exporter="127.0.0.1"}`:                                         "4",
-			`routes_total{exporter="127.0.0.1"}`:                                        "0",
+			`peers{exporter="127.0.0.1"}`:                                               "4",
+			`routes{exporter="127.0.0.1"}`:                                              "0",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
 			t.Errorf("Metrics (-got, +want):\n%s", diff)
@@ -188,8 +188,8 @@ func TestBMP(t *testing.T) {
 			`received_messages_total{exporter="127.0.0.1",type="route-monitoring"}`:     "26",
 			`received_messages_total{exporter="127.0.0.1",type="statistics-report"}`:    "4",
 			`opened_connections_total{exporter="127.0.0.1"}`:                            "1",
-			`peers_total{exporter="127.0.0.1"}`:                                         "4",
-			`routes_total{exporter="127.0.0.1"}`:                                        "18",
+			`peers{exporter="127.0.0.1"}`:                                               "4",
+			`routes{exporter="127.0.0.1"}`:                                              "18",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
 			t.Errorf("Metrics (-got, +want):\n%s", diff)
@@ -245,8 +245,8 @@ func TestBMP(t *testing.T) {
 			`received_messages_total{exporter="127.0.0.1",type="initiation"}`:       "1",
 			`received_messages_total{exporter="127.0.0.1",type="route-monitoring"}`: "17",
 			`opened_connections_total{exporter="127.0.0.1"}`:                        "1",
-			`peers_total{exporter="127.0.0.1"}`:                                     "3",
-			`routes_total{exporter="127.0.0.1"}`:                                    "17",
+			`peers{exporter="127.0.0.1"}`:                                           "3",
+			`routes{exporter="127.0.0.1"}`:                                          "17",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
 			t.Errorf("Metrics (-got, +want):\n%s", diff)
@@ -272,8 +272,8 @@ func TestBMP(t *testing.T) {
 			`received_messages_total{exporter="127.0.0.1",type="route-monitoring"}`:     "25",
 			`received_messages_total{exporter="127.0.0.1",type="statistics-report"}`:    "4",
 			`opened_connections_total{exporter="127.0.0.1"}`:                            "1",
-			`peers_total{exporter="127.0.0.1"}`:                                         "4",
-			`routes_total{exporter="127.0.0.1"}`:                                        "17",
+			`peers{exporter="127.0.0.1"}`:                                               "4",
+			`routes{exporter="127.0.0.1"}`:                                              "17",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
 			t.Errorf("Metrics (-got, +want):\n%s", diff)
@@ -301,8 +301,8 @@ func TestBMP(t *testing.T) {
 			`received_messages_total{exporter="127.0.0.1",type="route-monitoring"}`:       "25",
 			`received_messages_total{exporter="127.0.0.1",type="statistics-report"}`:      "5",
 			`opened_connections_total{exporter="127.0.0.1"}`:                              "1",
-			`peers_total{exporter="127.0.0.1"}`:                                           "3",
-			`routes_total{exporter="127.0.0.1"}`:                                          "14",
+			`peers{exporter="127.0.0.1"}`:                                                 "3",
+			`routes{exporter="127.0.0.1"}`:                                                "14",
 			`removed_peers_total{exporter="127.0.0.1"}`:                                   "1",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
@@ -356,8 +356,8 @@ func TestBMP(t *testing.T) {
 			`received_messages_total{exporter="127.0.0.1",type="route-monitoring"}`:     "25",
 			`received_messages_total{exporter="127.0.0.1",type="statistics-report"}`:    "4",
 			`opened_connections_total{exporter="127.0.0.1"}`:                            "1",
-			`peers_total{exporter="127.0.0.1"}`:                                         "4",
-			`routes_total{exporter="127.0.0.1"}`:                                        "1",
+			`peers{exporter="127.0.0.1"}`:                                               "4",
+			`routes{exporter="127.0.0.1"}`:                                              "1",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
 			t.Errorf("Metrics (-got, +want):\n%s", diff)
@@ -395,8 +395,8 @@ func TestBMP(t *testing.T) {
 			`received_messages_total{exporter="127.0.0.1",type="route-monitoring"}`:     "25",
 			`received_messages_total{exporter="127.0.0.1",type="statistics-report"}`:    "4",
 			`opened_connections_total{exporter="127.0.0.1"}`:                            "1",
-			`peers_total{exporter="127.0.0.1"}`:                                         "4",
-			`routes_total{exporter="127.0.0.1"}`:                                        "10",
+			`peers{exporter="127.0.0.1"}`:                                               "4",
+			`routes{exporter="127.0.0.1"}`:                                              "10",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
 			t.Errorf("Metrics (-got, +want):\n%s", diff)
@@ -448,8 +448,8 @@ func TestBMP(t *testing.T) {
 			`received_messages_total{exporter="127.0.0.1",type="route-monitoring"}`:     "33",
 			`received_messages_total{exporter="127.0.0.1",type="statistics-report"}`:    "4",
 			`opened_connections_total{exporter="127.0.0.1"}`:                            "1",
-			`peers_total{exporter="127.0.0.1"}`:                                         "4",
-			`routes_total{exporter="127.0.0.1"}`:                                        "0",
+			`peers{exporter="127.0.0.1"}`:                                               "4",
+			`routes{exporter="127.0.0.1"}`:                                              "0",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
 			t.Errorf("Metrics (-got, +want):\n%s", diff)
@@ -479,8 +479,8 @@ func TestBMP(t *testing.T) {
 			`received_messages_total{exporter="127.0.0.1",type="route-monitoring"}`:     "3",
 			`received_messages_total{exporter="127.0.0.1",type="statistics-report"}`:    "1",
 			`opened_connections_total{exporter="127.0.0.1"}`:                            "1",
-			`peers_total{exporter="127.0.0.1"}`:                                         "1",
-			`routes_total{exporter="127.0.0.1"}`:                                        "2",
+			`peers{exporter="127.0.0.1"}`:                                               "1",
+			`routes{exporter="127.0.0.1"}`:                                              "2",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
 			t.Errorf("Metrics (-got, +want):\n%s", diff)
@@ -512,7 +512,7 @@ func TestBMP(t *testing.T) {
 		time.Sleep(20 * time.Millisecond)
 		gotMetrics := r.GetMetrics("akvorado_outlet_routing_provider_bmp_", "routes")
 		expectedMetrics := map[string]string{
-			`routes_total{exporter="127.0.0.1"}`: "2",
+			`routes{exporter="127.0.0.1"}`: "2",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
 			t.Errorf("Metrics (-got, +want):\n%s", diff)
@@ -533,7 +533,7 @@ func TestBMP(t *testing.T) {
 		time.Sleep(20 * time.Millisecond)
 		gotMetrics := r.GetMetrics("akvorado_outlet_routing_provider_bmp_", "routes")
 		expectedMetrics := map[string]string{
-			`routes_total{exporter="127.0.0.1"}`: "0",
+			`routes{exporter="127.0.0.1"}`: "0",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
 			t.Errorf("Metrics (-got, +want):\n%s", diff)
@@ -555,7 +555,7 @@ func TestBMP(t *testing.T) {
 		time.Sleep(20 * time.Millisecond)
 		gotMetrics := r.GetMetrics("akvorado_outlet_routing_provider_bmp_", "routes")
 		expectedMetrics := map[string]string{
-			`routes_total{exporter="127.0.0.1"}`: "2",
+			`routes{exporter="127.0.0.1"}`: "2",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
 			t.Errorf("Metrics (-got, +want):\n%s", diff)
@@ -588,7 +588,7 @@ func TestBMP(t *testing.T) {
 		time.Sleep(20 * time.Millisecond)
 		gotMetrics := r.GetMetrics("akvorado_outlet_routing_provider_bmp_", "routes")
 		expectedMetrics := map[string]string{
-			`routes_total{exporter="127.0.0.1"}`: "2",
+			`routes{exporter="127.0.0.1"}`: "2",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
 			t.Errorf("Metrics (-got, +want):\n%s", diff)
@@ -625,8 +625,8 @@ func TestBMP(t *testing.T) {
 			`received_messages_total{exporter="127.0.0.1",type="route-monitoring"}`:     "16",
 			`received_messages_total{exporter="127.0.0.1",type="statistics-report"}`:    "4",
 			`opened_connections_total{exporter="127.0.0.1"}`:                            "1",
-			`peers_total{exporter="127.0.0.1"}`:                                         "4",
-			`routes_total{exporter="127.0.0.1"}`:                                        "0",
+			`peers{exporter="127.0.0.1"}`:                                               "4",
+			`routes{exporter="127.0.0.1"}`:                                              "0",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
 			t.Errorf("Metrics (-got, +want):\n%s", diff)
@@ -658,8 +658,8 @@ func TestBMP(t *testing.T) {
 			`received_messages_total{exporter="127.0.0.1",type="route-monitoring"}`:     "41",
 			`received_messages_total{exporter="127.0.0.1",type="statistics-report"}`:    "4",
 			`opened_connections_total{exporter="127.0.0.1"}`:                            "1",
-			`peers_total{exporter="127.0.0.1"}`:                                         "4",
-			`routes_total{exporter="127.0.0.1"}`:                                        "1",
+			`peers{exporter="127.0.0.1"}`:                                               "4",
+			`routes{exporter="127.0.0.1"}`:                                              "1",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
 			t.Errorf("Metrics (-got, +want):\n%s", diff)
@@ -698,8 +698,8 @@ func TestBMP(t *testing.T) {
 			`received_messages_total{exporter="127.0.0.1",type="route-monitoring"}`:     "41",
 			`received_messages_total{exporter="127.0.0.1",type="statistics-report"}`:    "4",
 			`opened_connections_total{exporter="127.0.0.1"}`:                            "1",
-			`peers_total{exporter="127.0.0.1"}`:                                         "4",
-			`routes_total{exporter="127.0.0.1"}`:                                        "1",
+			`peers{exporter="127.0.0.1"}`:                                               "4",
+			`routes{exporter="127.0.0.1"}`:                                              "1",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
 			t.Errorf("Metrics (-got, +want):\n%s", diff)
@@ -728,8 +728,8 @@ func TestBMP(t *testing.T) {
 			`received_messages_total{exporter="127.0.0.1",type="route-monitoring"}`:     "25",
 			`received_messages_total{exporter="127.0.0.1",type="statistics-report"}`:    "4",
 			`opened_connections_total{exporter="127.0.0.1"}`:                            "1",
-			`peers_total{exporter="127.0.0.1"}`:                                         "4",
-			`routes_total{exporter="127.0.0.1"}`:                                        "17",
+			`peers{exporter="127.0.0.1"}`:                                               "4",
+			`routes{exporter="127.0.0.1"}`:                                              "17",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
 			t.Errorf("Metrics (-got, +want):\n%s", diff)
@@ -788,8 +788,8 @@ func TestBMP(t *testing.T) {
 			`received_messages_total{exporter="127.0.0.1",type="statistics-report"}`:    "1",
 			`opened_connections_total{exporter="127.0.0.1"}`:                            "1",
 			`closed_connections_total{exporter="127.0.0.1"}`:                            "1",
-			`peers_total{exporter="127.0.0.1"}`:                                         "1",
-			`routes_total{exporter="127.0.0.1"}`:                                        "2",
+			`peers{exporter="127.0.0.1"}`:                                               "1",
+			`routes{exporter="127.0.0.1"}`:                                              "2",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
 			t.Errorf("Metrics (-got, +want):\n%s", diff)
@@ -816,8 +816,8 @@ func TestBMP(t *testing.T) {
 			`received_messages_total{exporter="127.0.0.1",type="statistics-report"}`:    "1",
 			`opened_connections_total{exporter="127.0.0.1"}`:                            "1",
 			`closed_connections_total{exporter="127.0.0.1"}`:                            "1",
-			`peers_total{exporter="127.0.0.1"}`:                                         "0",
-			`routes_total{exporter="127.0.0.1"}`:                                        "0",
+			`peers{exporter="127.0.0.1"}`:                                               "0",
+			`routes{exporter="127.0.0.1"}`:                                              "0",
 			`removed_peers_total{exporter="127.0.0.1"}`:                                 "1",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
@@ -843,15 +843,15 @@ func TestBMP(t *testing.T) {
 		send(t, conn, "bmp-reach-unknown-family.pcap")
 		time.Sleep(20 * time.Millisecond)
 		gotMetrics := r.GetMetrics("akvorado_outlet_routing_provider_bmp_", "-locked_duration")
-		ignoredMetric := `ignored_updates_total{error="unknown route family. AFI: 57, SAFI: 65",exporter="127.0.0.1",reason="afi-safi"}`
+		ignoredMetric := `ignored_updates_total{error="afi-safi",exporter="127.0.0.1"}`
 		expectedMetrics := map[string]string{
 			`received_messages_total{exporter="127.0.0.1",type="initiation"}`:           "1",
 			`received_messages_total{exporter="127.0.0.1",type="peer-up-notification"}`: "1",
 			`received_messages_total{exporter="127.0.0.1",type="route-monitoring"}`:     "4",
 			`received_messages_total{exporter="127.0.0.1",type="statistics-report"}`:    "1",
 			`opened_connections_total{exporter="127.0.0.1"}`:                            "1",
-			`peers_total{exporter="127.0.0.1"}`:                                         "1",
-			`routes_total{exporter="127.0.0.1"}`:                                        "2",
+			`peers{exporter="127.0.0.1"}`:                                               "1",
+			`routes{exporter="127.0.0.1"}`:                                              "2",
 			ignoredMetric:                                                               "1",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
@@ -888,8 +888,8 @@ func TestBMP(t *testing.T) {
 			`received_messages_total{exporter="127.0.0.1",type="route-monitoring"}`:     "4",
 			`received_messages_total{exporter="127.0.0.1",type="statistics-report"}`:    "1",
 			`opened_connections_total{exporter="127.0.0.1"}`:                            "1",
-			`peers_total{exporter="127.0.0.1"}`:                                         "2",
-			`routes_total{exporter="127.0.0.1"}`:                                        "2",
+			`peers{exporter="127.0.0.1"}`:                                               "2",
+			`routes{exporter="127.0.0.1"}`:                                              "2",
 			`ignored_nlri_total{exporter="127.0.0.1",type="l2vpn-vpls"}`:                "1",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
@@ -922,8 +922,8 @@ func TestBMP(t *testing.T) {
 			`received_messages_total{exporter="127.0.0.1",type="statistics-report"}`:    "2",
 			`opened_connections_total{exporter="127.0.0.1"}`:                            "2",
 			`closed_connections_total{exporter="127.0.0.1"}`:                            "1",
-			`peers_total{exporter="127.0.0.1"}`:                                         "2",
-			`routes_total{exporter="127.0.0.1"}`:                                        "4",
+			`peers{exporter="127.0.0.1"}`:                                               "2",
+			`routes{exporter="127.0.0.1"}`:                                              "4",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
 			t.Errorf("Metrics (-got, +want):\n%s", diff)
@@ -952,8 +952,8 @@ func TestBMP(t *testing.T) {
 			`received_messages_total{exporter="127.0.0.1",type="statistics-report"}`:    "2",
 			`opened_connections_total{exporter="127.0.0.1"}`:                            "2",
 			`closed_connections_total{exporter="127.0.0.1"}`:                            "1",
-			`peers_total{exporter="127.0.0.1"}`:                                         "1",
-			`routes_total{exporter="127.0.0.1"}`:                                        "2",
+			`peers{exporter="127.0.0.1"}`:                                               "1",
+			`routes{exporter="127.0.0.1"}`:                                              "2",
 			`removed_peers_total{exporter="127.0.0.1"}`:                                 "1",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
@@ -982,8 +982,8 @@ func TestBMP(t *testing.T) {
 			`received_messages_total{exporter="127.0.0.1",type="statistics-report"}`:    "2",
 			`opened_connections_total{exporter="127.0.0.1"}`:                            "2",
 			`closed_connections_total{exporter="127.0.0.1"}`:                            "2",
-			`peers_total{exporter="127.0.0.1"}`:                                         "1",
-			`routes_total{exporter="127.0.0.1"}`:                                        "2",
+			`peers{exporter="127.0.0.1"}`:                                               "1",
+			`routes{exporter="127.0.0.1"}`:                                              "2",
 			`removed_peers_total{exporter="127.0.0.1"}`:                                 "1",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
@@ -1005,8 +1005,8 @@ func TestBMP(t *testing.T) {
 			`received_messages_total{exporter="127.0.0.1",type="statistics-report"}`:    "2",
 			`opened_connections_total{exporter="127.0.0.1"}`:                            "2",
 			`closed_connections_total{exporter="127.0.0.1"}`:                            "2",
-			`peers_total{exporter="127.0.0.1"}`:                                         "0",
-			`routes_total{exporter="127.0.0.1"}`:                                        "0",
+			`peers{exporter="127.0.0.1"}`:                                               "0",
+			`routes{exporter="127.0.0.1"}`:                                              "0",
 			`removed_peers_total{exporter="127.0.0.1"}`:                                 "2",
 		}
 		if diff := helpers.Diff(gotMetrics, expectedMetrics); diff != "" {
@@ -1063,8 +1063,8 @@ func TestBMP(t *testing.T) {
 				`received_messages_total{exporter="127.0.0.1",type="statistics-report"}`:    "4",
 				`opened_connections_total{exporter="127.0.0.1"}`:                            "1",
 				`closed_connections_total{exporter="127.0.0.1"}`:                            "1",
-				`peers_total{exporter="127.0.0.1"}`:                                         "0",
-				`routes_total{exporter="127.0.0.1"}`:                                        "0",
+				`peers{exporter="127.0.0.1"}`:                                               "0",
+				`routes{exporter="127.0.0.1"}`:                                              "0",
 				`removed_peers_total{exporter="127.0.0.1"}`:                                 "4",
 				`removed_partial_peers_total{exporter="127.0.0.1"}`:                         fmt.Sprintf("%d", peerRemovalPartial),
 			}
diff --git a/outlet/routing/provider/bmp/serve.go b/outlet/routing/provider/bmp/serve.go
index fc3a284e..7c1e8690 100644
--- a/outlet/routing/provider/bmp/serve.go
+++ b/outlet/routing/provider/bmp/serve.go
@@ -149,22 +149,22 @@ func (p *Provider) serveConnection(conn *net.TCPConn) error {
 			if ok {
 				switch msgError.ErrorHandling {
 				case bgp.ERROR_HANDLING_SESSION_RESET:
-					p.metrics.ignored.WithLabelValues(exporterStr, "session-reset", err.Error()).Inc()
+					p.metrics.ignored.WithLabelValues(exporterStr, "session-reset").Inc()
 					continue
 				case bgp.ERROR_HANDLING_AFISAFI_DISABLE:
-					p.metrics.ignored.WithLabelValues(exporterStr, "afi-safi", err.Error()).Inc()
+					p.metrics.ignored.WithLabelValues(exporterStr, "afi-safi").Inc()
 					continue
 				case bgp.ERROR_HANDLING_TREAT_AS_WITHDRAW:
 					// This is a pickle. This can be an essential attribute (eg.
 					// AS path) that's malformed or something quite minor for
 					// our own usage (eg. a non-optional attribute), let's skip for now.
-					p.metrics.ignored.WithLabelValues(exporterStr, "treat-as-withdraw", err.Error()).Inc()
+					p.metrics.ignored.WithLabelValues(exporterStr, "treat-as-withdraw").Inc()
 					continue
 				case bgp.ERROR_HANDLING_ATTRIBUTE_DISCARD:
 					// Optional attribute, let's handle it
 				case bgp.ERROR_HANDLING_NONE:
 					// Odd?
-					p.metrics.ignored.WithLabelValues(exporterStr, "none", err.Error()).Inc()
+					p.metrics.ignored.WithLabelValues(exporterStr, "none").Inc()
 					continue
 				}
 			} else {