remove legacy tags, always pass vector

17 files changed, 191 insertions, 171 deletions

diff --git a/storage/src/tests/common/metricstest.cpp b/storage/src/tests/common/metricstest.cpp
index 9d2f566f770..867d132031e 100644
--- a/storage/src/tests/common/metricstest.cpp
+++ b/storage/src/tests/common/metricstest.cpp
@@ -97,7 +97,7 @@ void MetricsTest::setUp() {
     _metricManager.reset(new metrics::MetricManager(
             std::unique_ptr<metrics::MetricManager::Timer>(
                 new MetricClock(*_clock))));
-    _topSet.reset(new metrics::MetricSet("vds", "", ""));
+    _topSet.reset(new metrics::MetricSet("vds", {}, ""));
     {
         metrics::MetricLockGuard guard(_metricManager->getMetricLock());
         _metricManager->registerMetric(guard, *_topSet);
diff --git a/storage/src/tests/storageserver/statereportertest.cpp b/storage/src/tests/storageserver/statereportertest.cpp
index f4bf7685225..d0cdf41823b 100644
--- a/storage/src/tests/storageserver/statereportertest.cpp
+++ b/storage/src/tests/storageserver/statereportertest.cpp
@@ -88,7 +88,7 @@ void StateReporterTest::setUp() {
     _metricManager.reset(new metrics::MetricManager(
             std::unique_ptr<metrics::MetricManager::Timer>(
                 new MetricClock(*_clock))));
-    _topSet.reset(new metrics::MetricSet("vds", "", ""));
+    _topSet.reset(new metrics::MetricSet("vds", {}, ""));
     {
         metrics::MetricLockGuard guard(_metricManager->getMetricLock());
         _metricManager->registerMetric(guard, *_topSet);
diff --git a/storage/src/vespa/storage/bucketdb/bucketmanagermetrics.cpp b/storage/src/vespa/storage/bucketdb/bucketmanagermetrics.cpp
index b95fb6b814c..a0f5f2f7ec9 100644
--- a/storage/src/vespa/storage/bucketdb/bucketmanagermetrics.cpp
+++ b/storage/src/vespa/storage/bucketdb/bucketmanagermetrics.cpp
@@ -10,12 +10,12 @@ using vespalib::IllegalStateException;
 using vespalib::make_string;
 
 DataStoredMetrics::DataStoredMetrics(const std::string& name, metrics::MetricSet* owner)
-    : metrics::MetricSet(name, "partofsum yamasdefault", "", owner),
-      buckets("buckets", "", "buckets managed", this),
-      docs("docs", "", "documents stored", this),
-      bytes("bytes", "", "bytes stored", this),
-      active("activebuckets", "", "Number of active buckets on the node", this),
-      ready("readybuckets", "", "Number of ready buckets on the node", this)
+    : metrics::MetricSet(name, {{"partofsum"},{"yamasdefault"}}, "", owner),
+      buckets("buckets", {}, "buckets managed", this),
+      docs("docs", {}, "documents stored", this),
+      bytes("bytes", {}, "bytes stored", this),
+      active("activebuckets", {}, "Number of active buckets on the node", this),
+      ready("readybuckets", {}, "Number of ready buckets on the node", this)
 {
     docs.logOnlyIfSet();
     bytes.logOnlyIfSet();
@@ -26,15 +26,15 @@ DataStoredMetrics::DataStoredMetrics(const std::string& name, metrics::MetricSet
 DataStoredMetrics::~DataStoredMetrics() { }
 
 BucketManagerMetrics::BucketManagerMetrics()
-    : metrics::MetricSet("datastored", "", ""),
+    : metrics::MetricSet("datastored", {}, ""),
       disks(),
-      total("alldisks", "sum", "Sum of data stored metrics for all disks", this),
-      simpleBucketInfoRequestSize("simplebucketinforeqsize", "",
+      total("alldisks", {{"sum"}}, "Sum of data stored metrics for all disks", this),
+      simpleBucketInfoRequestSize("simplebucketinforeqsize", {},
             "Amount of buckets returned in simple bucket info requests",
             this),
-      fullBucketInfoRequestSize("fullbucketinforeqsize", "",
+      fullBucketInfoRequestSize("fullbucketinforeqsize", {},
             "Amount of distributors answered at once in full bucket info requests.", this),
-      fullBucketInfoLatency("fullbucketinfolatency", "",
+      fullBucketInfoLatency("fullbucketinfolatency", {},
             "Amount of time spent to process a full bucket info request", this)
 { }
 
diff --git a/storage/src/vespa/storage/bucketdb/storagebucketdbinitializer.cpp b/storage/src/vespa/storage/bucketdb/storagebucketdbinitializer.cpp
index d553b41de7c..84352df5ec9 100644
--- a/storage/src/vespa/storage/bucketdb/storagebucketdbinitializer.cpp
+++ b/storage/src/vespa/storage/bucketdb/storagebucketdbinitializer.cpp
@@ -93,26 +93,26 @@ StorageBucketDBInitializer::System::getBucketDatabase(document::BucketSpace buck
 }
 
 StorageBucketDBInitializer::Metrics::Metrics(framework::Component& component)
-    : metrics::MetricSet("dbinit", "",
+    : metrics::MetricSet("dbinit", {},
                          "Metrics for the storage bucket database initializer"),
-      _wrongDisk("wrongdisk", "",
+      _wrongDisk("wrongdisk", {},
               "Number of buckets found on non-ideal disk.", this),
-      _insertedCount("insertedcount", "",
+      _insertedCount("insertedcount", {},
               "Number of buckets inserted into database in list step.", this),
-      _joinedCount("joinedcount", "",
+      _joinedCount("joinedcount", {},
               "Number of buckets found in list step already found "
               "(added from other disks).", this),
-      _infoReadCount("infocount", "",
+      _infoReadCount("infocount", {},
               "Number of buckets we have read bucket information from.", this),
-      _infoSetByLoad("infosetbyload", "",
+      _infoSetByLoad("infosetbyload", {},
               "Number of buckets we did not need to request bucket info for "
               "due to load already having updated them.", this),
-      _dirsListed("dirslisted", "",
+      _dirsListed("dirslisted", {},
               "Directories listed in list step of initialization.", this),
       _startTime(component.getClock()),
-      _listLatency("listlatency", "",
+      _listLatency("listlatency", {},
               "Time used until list phase is done. (in ms)", this),
-      _initLatency("initlatency", "",
+      _initLatency("initlatency", {},
               "Time used until initialization is complete. (in ms)", this)
 {
     component.registerMetric(*this);
diff --git a/storage/src/vespa/storage/distributor/distributormetricsset.cpp b/storage/src/vespa/storage/distributor/distributormetricsset.cpp
index 761c5c45889..b7725559b1d 100644
--- a/storage/src/vespa/storage/distributor/distributormetricsset.cpp
+++ b/storage/src/vespa/storage/distributor/distributormetricsset.cpp
@@ -8,7 +8,7 @@ namespace storage {
 using metrics::MetricSet;
 
 DistributorMetricSet::DistributorMetricSet(const metrics::LoadTypeSet& lt)
-    : MetricSet("distributor", "distributor", ""),
+    : MetricSet("distributor", {{"distributor"}}, ""),
       puts(lt, PersistenceOperationMetricSet("puts"), this),
       updates(lt, PersistenceOperationMetricSet("updates"), this),
       update_puts(lt, PersistenceOperationMetricSet("update_puts"), this),
@@ -19,18 +19,20 @@ DistributorMetricSet::DistributorMetricSet(const metrics::LoadTypeSet& lt)
       stats(lt, PersistenceOperationMetricSet("stats"), this),
       multioperations(lt, PersistenceOperationMetricSet("multioperations"), this),
       visits(lt, VisitorMetricSet(), this),
-      stateTransitionTime("state_transition_time", "",
+      stateTransitionTime("state_transition_time", {},
               "Time it takes to complete a cluster state transition. If a "
               "state transition is preempted before completing, its elapsed "
               "time is counted as part of the total time spent for the final, "
               "completed state transition", this),
-      recoveryModeTime("recoverymodeschedulingtime", "",
+      recoveryModeTime("recoverymodeschedulingtime", {},
               "Time spent scheduling operations in recovery mode "
               "after receiving new cluster state", this),
-      docsStored("docsstored", "logdefault yamasdefault",
+      docsStored("docsstored",
+              {{"logdefault"},{"yamasdefault"}},
               "Number of documents stored in all buckets controlled by "
               "this distributor", this),
-      bytesStored("bytesstored", "logdefault yamasdefault",
+      bytesStored("bytesstored",
+              {{"logdefault"},{"yamasdefault"}},
               "Number of bytes stored in all buckets controlled by "
               "this distributor", this)
 {
diff --git a/storage/src/vespa/storage/distributor/idealstatemetricsset.cpp b/storage/src/vespa/storage/distributor/idealstatemetricsset.cpp
index 6d9607f2cd9..d72f4a80ef4 100644
--- a/storage/src/vespa/storage/distributor/idealstatemetricsset.cpp
+++ b/storage/src/vespa/storage/distributor/idealstatemetricsset.cpp
@@ -5,11 +5,17 @@ namespace storage {
 
 namespace distributor {
 
-OperationMetricSet::OperationMetricSet(const std::string& name, const std::string& tags, const std::string& description, MetricSet* owner)
+OperationMetricSet::OperationMetricSet(const std::string& name, metrics::Metric::Tags tags, const std::string& description, MetricSet* owner)
     : MetricSet(name, tags, description, owner),
-      pending("pending", "logdefault yamasdefault", "The number of operations pending", this),
-      ok("done_ok", "logdefault yamasdefault", "The number of operations successfully performed", this),
-      failed("done_failed", "logdefault yamasdefault", "The number of operations that failed", this)
+      pending("pending",
+              {{"logdefault"},{"yamasdefault"}},
+              "The number of operations pending", this),
+      ok("done_ok",
+         {{"logdefault"},{"yamasdefault"}},
+         "The number of operations successfully performed", this),
+      failed("done_failed",
+             {{"logdefault"},{"yamasdefault"}},
+             "The number of operations that failed", this)
 { }
 
 OperationMetricSet::~OperationMetricSet() { }
@@ -19,47 +25,58 @@ IdealStateMetricSet::createOperationMetrics() {
     typedef IdealStateOperation ISO;
     operations.resize(ISO::OPERATION_COUNT);
     operations[ISO::DELETE_BUCKET] = std::shared_ptr<OperationMetricSet>(
-            new OperationMetricSet("delete_bucket", "logdefault yamasdefault",
+            new OperationMetricSet("delete_bucket",
+                                   {{"logdefault"},{"yamasdefault"}},
                                    "Operations to delete excess buckets on storage nodes", this));
     operations[ISO::MERGE_BUCKET] = std::shared_ptr<OperationMetricSet>(
-            new OperationMetricSet("merge_bucket", "logdefault yamasdefault",
+            new OperationMetricSet("merge_bucket",
+                                   {{"logdefault"},{"yamasdefault"}},
                                    "Operations to merge buckets that are out of sync", this));
     operations[ISO::SPLIT_BUCKET] = std::shared_ptr<OperationMetricSet>(
-            new OperationMetricSet("split_bucket", "logdefault yamasdefault",
+            new OperationMetricSet("split_bucket",
+                                   {{"logdefault"},{"yamasdefault"}},
                                    "Operations to split buckets that are larger than the configured size", this));
     operations[ISO::JOIN_BUCKET] = std::shared_ptr<OperationMetricSet>(
-            new OperationMetricSet("join_bucket", "logdefault yamasdefault",
+            new OperationMetricSet("join_bucket",
+                                   {{"logdefault"},{"yamasdefault"}},
                                    "Operations to join buckets that in sum are smaller than the configured size", this));
     operations[ISO::SET_BUCKET_STATE] = std::shared_ptr<OperationMetricSet>(
             new OperationMetricSet("set_bucket_state",
-                                   "logdefault yamasdefault",
+                                   {{"logdefault"},{"yamasdefault"}},
                                    "Operations to set active/ready state for bucket copies", this));
     operations[ISO::GARBAGE_COLLECTION] = std::shared_ptr<OperationMetricSet>(
             new OperationMetricSet("garbage_collection",
-                                   "logdefault yamasdefault",
+                                   {{"logdefault"},{"yamasdefault"}},
                                    "Operations to garbage collect data from buckets", this));
 }
 
 IdealStateMetricSet::IdealStateMetricSet()
-    : MetricSet("idealstate", "idealstate", "Statistics for ideal state generation"),
-      idealstate_diff("idealstate_diff", "logdefault yamasdefault",
+    : MetricSet("idealstate", {{"idealstate"}}, "Statistics for ideal state generation"),
+      idealstate_diff("idealstate_diff",
+            {{"logdefault"},{"yamasdefault"}},
             "A number representing the current difference from the ideal "
             "state. This is a number that decreases steadily as the system "
             "is getting closer to the ideal state", this),
-      buckets_toofewcopies("buckets_toofewcopies", "logdefault yamasdefault",
+      buckets_toofewcopies("buckets_toofewcopies",
+            {{"logdefault"},{"yamasdefault"}},
             "The number of buckets the distributor controls that have less "
             "than the desired redundancy", this),
-      buckets_toomanycopies("buckets_toomanycopies", "logdefault yamasdefault",
+      buckets_toomanycopies("buckets_toomanycopies",
+            {{"logdefault"},{"yamasdefault"}},
             "The number of buckets the distributor controls that have more "
             "than the desired redundancy", this),
-      buckets("buckets", "logdefault yamasdefault", "The number of buckets the distributor controls", this),
-      buckets_notrusted("buckets_notrusted", "logdefault yamasdefault",
+      buckets("buckets",
+            {{"logdefault"},{"yamasdefault"}},
+            "The number of buckets the distributor controls", this),
+      buckets_notrusted("buckets_notrusted",
+            {{"logdefault"},{"yamasdefault"}},
             "The number of buckets that have no trusted copies.", this),
-      buckets_rechecking("buckets_rechecking", "logdefault yamasdefault",
+      buckets_rechecking("buckets_rechecking",
+            {{"logdefault"},{"yamasdefault"}},
             "The number of buckets that we are rechecking for "
             "ideal state operations", this),
-      startOperationsLatency("start_operations_latency", "", "Time used in startOperations()", this),
-      nodesPerMerge("nodes_per_merge", "", "The number of nodes involved in a single merge operation.", this)
+      startOperationsLatency("start_operations_latency", {}, "Time used in startOperations()", this),
+      nodesPerMerge("nodes_per_merge", {}, "The number of nodes involved in a single merge operation.", this)
 {
     createOperationMetrics();
 }
diff --git a/storage/src/vespa/storage/distributor/idealstatemetricsset.h b/storage/src/vespa/storage/distributor/idealstatemetricsset.h
index cd88ab672d3..7bb472b4a2c 100644
--- a/storage/src/vespa/storage/distributor/idealstatemetricsset.h
+++ b/storage/src/vespa/storage/distributor/idealstatemetricsset.h
@@ -15,7 +15,7 @@ public:
     metrics::LongCountMetric ok;
     metrics::LongCountMetric failed;
 
-    OperationMetricSet(const std::string& name, const std::string& tags, const std::string& description, MetricSet* owner);
+    OperationMetricSet(const std::string& name, metrics::Metric::Tags tags, const std::string& description, MetricSet* owner);
     ~OperationMetricSet();
 };
 
diff --git a/storage/src/vespa/storage/distributor/persistence_operation_metric_set.cpp b/storage/src/vespa/storage/distributor/persistence_operation_metric_set.cpp
index 30fa2797ef4..d3ae5d547ed 100644
--- a/storage/src/vespa/storage/distributor/persistence_operation_metric_set.cpp
+++ b/storage/src/vespa/storage/distributor/persistence_operation_metric_set.cpp
@@ -10,24 +10,24 @@ namespace storage {
 using metrics::MetricSet;
 
 PersistenceFailuresMetricSet::PersistenceFailuresMetricSet(MetricSet* owner)
-    : MetricSet("failures", "", "Detailed failure statistics", owner),
-      sum("total", "logdefault yamasdefault", "Sum of all failures", this),
-      notready("notready", "", "The number of operations discarded because distributor was not ready", this),
-      notconnected("notconnected", "", "The number of operations discarded because there were no available storage nodes to send to", this),
-      wrongdistributor("wrongdistributor", "", "The number of operations discarded because they were sent to the wrong distributor", this),
-      safe_time_not_reached("safe_time_not_reached", "",
+    : MetricSet("failures", {}, "Detailed failure statistics", owner),
+      sum("total", {{"logdefault"},{"yamasdefault"}}, "Sum of all failures", this),
+      notready("notready", {}, "The number of operations discarded because distributor was not ready", this),
+      notconnected("notconnected", {}, "The number of operations discarded because there were no available storage nodes to send to", this),
+      wrongdistributor("wrongdistributor", {}, "The number of operations discarded because they were sent to the wrong distributor", this),
+      safe_time_not_reached("safe_time_not_reached", {},
                             "The number of operations that were transiently"
                             " failed due to them arriving before the safe "
                             "time point for bucket ownership handovers has "
                             "passed", this),
-      storagefailure("storagefailure", "", "The number of operations that failed in storage", this),
-      timeout("timeout", "", "The number of operations that failed because the operation timed out towards storage", this),
-      busy("busy", "", "The number of messages from storage that failed because the storage node was busy", this),
-      inconsistent_bucket("inconsistent_bucket", "",
+      storagefailure("storagefailure", {}, "The number of operations that failed in storage", this),
+      timeout("timeout", {}, "The number of operations that failed because the operation timed out towards storage", this),
+      busy("busy", {}, "The number of messages from storage that failed because the storage node was busy", this),
+      inconsistent_bucket("inconsistent_bucket", {},
                           "The number of operations failed due to buckets "
                           "being in an inconsistent state or not found", this),
-      notfound("notfound", "", "The number of operations that failed because the document did not exist", this),
-      concurrent_mutations("concurrent_mutations", "", "The number of operations that were transiently failed due "
+      notfound("notfound", {}, "The number of operations that failed because the document did not exist", this),
+      concurrent_mutations("concurrent_mutations", {}, "The number of operations that were transiently failed due "
                            "to a mutating operation already being in progress for its document ID", this)
 {
     sum.addMetricToSum(notready);
@@ -55,9 +55,9 @@ PersistenceFailuresMetricSet::clone(std::vector<Metric::UP>& ownerList, CopyType
 }
 
 PersistenceOperationMetricSet::PersistenceOperationMetricSet(const std::string& name, MetricSet* owner)
-    : MetricSet(name, "", vespalib::make_string("Statistics for the %s command", name.c_str()), owner),
-      latency("latency", "yamasdefault", vespalib::make_string("The average latency of %s operations", name.c_str()), this),
-      ok("ok", "logdefault yamasdefault", vespalib::make_string("The number of successful %s operations performed", name.c_str()), this),
+    : MetricSet(name, {}, vespalib::make_string("Statistics for the %s command", name.c_str()), owner),
+      latency("latency", {{"yamasdefault"}}, vespalib::make_string("The average latency of %s operations", name.c_str()), this),
+      ok("ok", {{"logdefault"},{"yamasdefault"}}, vespalib::make_string("The number of successful %s operations performed", name.c_str()), this),
       failures(this)
 { }
 
diff --git a/storage/src/vespa/storage/distributor/visitormetricsset.cpp b/storage/src/vespa/storage/distributor/visitormetricsset.cpp
index 999ab2d577f..84b1174962c 100644
--- a/storage/src/vespa/storage/distributor/visitormetricsset.cpp
+++ b/storage/src/vespa/storage/distributor/visitormetricsset.cpp
@@ -10,13 +10,13 @@ using metrics::MetricSet;
 
 VisitorMetricSet::VisitorMetricSet(MetricSet* owner)
     : PersistenceOperationMetricSet("visitor", owner),
-      buckets_per_visitor("buckets_per_visitor", "",
+      buckets_per_visitor("buckets_per_visitor", {},
                           "The number of sub buckets visited as part of a "
                           "single client visitor command", this),
-      docs_per_visitor("docs_per_visitor", "",
+      docs_per_visitor("docs_per_visitor", {},
                        "The number of documents visited on content nodes as "
                        "part of a single client visitor command", this),
-      bytes_per_visitor("bytes_per_visitor", "",
+      bytes_per_visitor("bytes_per_visitor", {},
                         "The number of bytes visited on content nodes as part "
                         "of a single client visitor command", this)
 {
diff --git a/storage/src/vespa/storage/persistence/filestorage/filestormetrics.cpp b/storage/src/vespa/storage/persistence/filestorage/filestormetrics.cpp
index 52d95e9a3ed..0be046b2e9e 100644
--- a/storage/src/vespa/storage/persistence/filestorage/filestormetrics.cpp
+++ b/storage/src/vespa/storage/persistence/filestorage/filestormetrics.cpp
@@ -10,11 +10,11 @@ using metrics::MetricSet;
 using metrics::LoadTypeSet;
 
 FileStorThreadMetrics::Op::Op(const std::string& id, const std::string& name, MetricSet* owner)
-    : MetricSet(id, "", name + " load in filestor thread", owner),
+    : MetricSet(id, {}, name + " load in filestor thread", owner),
       _name(name),
-      count("count", "yamasdefault", "Number of requests processed.", this),
-      latency("latency", "yamasdefault", "Latency of successful requests.", this),
-      failed("failed", "yamasdefault", "Number of failed requests.", this)
+      count("count", {{"yamasdefault"}}, "Number of requests processed.", this),
+      latency("latency", {{"yamasdefault"}}, "Latency of successful requests.", this),
+      failed("failed", {{"yamasdefault"}}, "Number of failed requests.", this)
 { }
 
 FileStorThreadMetrics::Op::~Op() = default;
@@ -34,7 +34,7 @@ FileStorThreadMetrics::Op::clone(std::vector<Metric::UP>& ownerList,
 template <typename BaseOp>
 FileStorThreadMetrics::OpWithRequestSize<BaseOp>::OpWithRequestSize(const std::string& id, const std::string& name, MetricSet* owner)
         : BaseOp(id, name, owner),
-          request_size("request_size", "", "Size of requests, in bytes", this)
+          request_size("request_size", {}, "Size of requests, in bytes", this)
 {
 }
 
@@ -59,8 +59,9 @@ FileStorThreadMetrics::OpWithRequestSize<BaseOp>::clone(
 
 FileStorThreadMetrics::OpWithNotFound::OpWithNotFound(const std::string& id, const std::string& name, MetricSet* owner)
     : Op(id, name, owner),
-      notFound("not_found", "", "Number of requests that could not be "
-               "completed due to source document not found.", this)
+      notFound("not_found", {},
+               "Number of requests that could not be completed due to source document not found.",
+               this)
 { }
 
 FileStorThreadMetrics::OpWithNotFound::~OpWithNotFound() = default;
@@ -81,7 +82,7 @@ FileStorThreadMetrics::OpWithNotFound::clone(std::vector<Metric::UP>& ownerList,
 
 FileStorThreadMetrics::Update::Update(MetricSet* owner)
     : OpWithRequestSize("update", "Update", owner),
-      latencyRead("latency_read", "", "Latency of the source read in the request.", this)
+      latencyRead("latency_read", {}, "Latency of the source read in the request.", this)
 { }
 
 FileStorThreadMetrics::Update::~Update() = default;
@@ -100,7 +101,7 @@ FileStorThreadMetrics::Update::clone(std::vector<Metric::UP>& ownerList,
 
 FileStorThreadMetrics::Visitor::Visitor(MetricSet* owner)
     : Op("visit", "Visit", owner),
-      documentsPerIterate("docs", "", "Number of entries read per iterate call", this)
+      documentsPerIterate("docs", {}, "Number of entries read per iterate call", this)
 { }
 
 FileStorThreadMetrics::Visitor::~Visitor() = default;
@@ -118,9 +119,9 @@ FileStorThreadMetrics::Visitor::clone(std::vector<Metric::UP>& ownerList,
 }
 
 FileStorThreadMetrics::FileStorThreadMetrics(const std::string& name, const std::string& desc, const LoadTypeSet& lt)
-    : MetricSet(name, "filestor partofsum", desc),
-      operations("operations", "", "Number of operations processed.", this),
-      failedOperations("failedoperations", "", "Number of operations throwing exceptions.", this),
+    : MetricSet(name, {{"filestor"},{"partofsum"}}, desc),
+      operations("operations", {}, "Number of operations processed.", this),
+      failedOperations("failedoperations", {}, "Number of operations throwing exceptions.", this),
       put(lt, OpWithRequestSize<Op>("put", "Put"), this),
       get(lt, OpWithRequestSize<OpWithNotFound>("get", "Get"), this),
       remove(lt, OpWithRequestSize<OpWithNotFound>("remove", "Remove"), this),
@@ -128,13 +129,13 @@ FileStorThreadMetrics::FileStorThreadMetrics(const std::string& name, const std:
       statBucket(lt, Op("stat_bucket", "Stat bucket"), this),
       update(lt, Update(), this),
       revert(lt, OpWithNotFound("revert", "Revert"), this),
-      createIterator("createiterator", "", this),
+      createIterator("createiterator", {}, this),
       visit(lt, Visitor(), this),
       multiOp(lt, Op("multioperations", "The number of multioperations that have been created"), this),
       createBuckets("createbuckets", "Number of buckets that has been created.", this),
       deleteBuckets("deletebuckets", "Number of buckets that has been deleted.", this),
       repairs("bucketverified", "Number of times buckets have been checked.", this),
-      repairFixed("bucketfixed", "", "Number of times bucket has been fixed because of corruption", this),
+      repairFixed("bucketfixed", {}, "Number of times bucket has been fixed because of corruption", this),
       recheckBucketInfo("recheckbucketinfo",
                         "Number of times bucket info has been explicitly "
                         "rechecked due to buckets being marked modified by "
@@ -151,24 +152,24 @@ FileStorThreadMetrics::FileStorThreadMetrics(const std::string& name, const std:
       mergeBuckets("mergebuckets", "Number of times buckets have been merged.", this),
       getBucketDiff("getbucketdiff", "Number of getbucketdiff commands that have been processed.", this),
       applyBucketDiff("applybucketdiff", "Number of applybucketdiff commands that have been processed.", this),
-      bytesMerged("bytesmerged", "", "Total number of bytes merged into this node.", this),
-      getBucketDiffReply("getbucketdiffreply", "", "Number of getbucketdiff replies that have been processed.", this),
-      applyBucketDiffReply("applybucketdiffreply", "", "Number of applybucketdiff replies that have been processed.", this),
-      mergeLatencyTotal("mergelatencytotal", "",
+      bytesMerged("bytesmerged", {}, "Total number of bytes merged into this node.", this),
+      getBucketDiffReply("getbucketdiffreply", {}, "Number of getbucketdiff replies that have been processed.", this),
+      applyBucketDiffReply("applybucketdiffreply", {}, "Number of applybucketdiff replies that have been processed.", this),
+      mergeLatencyTotal("mergelatencytotal", {},
              "Latency of total merge operation, from master node receives "
              "it, until merge is complete and master node replies.", this),
-      mergeMetadataReadLatency("mergemetadatareadlatency", "",
+      mergeMetadataReadLatency("mergemetadatareadlatency", {},
              "Latency of time used in a merge step to check metadata of "
              "current node to see what data it has.", this),
-      mergeDataReadLatency("mergedatareadlatency", "",
+      mergeDataReadLatency("mergedatareadlatency", {},
              "Latency of time used in a merge step to read data other "
              "nodes need.", this),
-      mergeDataWriteLatency("mergedatawritelatency", "",
+      mergeDataWriteLatency("mergedatawritelatency", {},
             "Latency of time used in a merge step to write data needed to "
             "current node.", this),
-      mergeAverageDataReceivedNeeded("mergeavgdatareceivedneeded", "", "Amount of data transferred from previous node "
+      mergeAverageDataReceivedNeeded("mergeavgdatareceivedneeded", {}, "Amount of data transferred from previous node "
                                      "in chain that we needed to apply locally.", this),
-      batchingSize("batchingsize", "", "Number of operations batched per bucket (only counts "
+      batchingSize("batchingsize", {}, "Number of operations batched per bucket (only counts "
                    "batches of size > 1)", this)
 { }
 
@@ -176,9 +177,9 @@ FileStorThreadMetrics::~FileStorThreadMetrics() = default;
 
 FileStorStripeMetrics::FileStorStripeMetrics(const std::string& name, const std::string& description,
                                              const LoadTypeSet& loadTypes)
-    : MetricSet(name, "partofsum", description),
+    : MetricSet(name, {{"partofsum"}}, description),
       averageQueueWaitingTime(loadTypes,
-                              metrics::DoubleAverageMetric("averagequeuewait", "",
+                              metrics::DoubleAverageMetric("averagequeuewait", {},
                                                            "Average time an operation spends in input queue."),
                               this)
 {
@@ -188,19 +189,19 @@ FileStorStripeMetrics::~FileStorStripeMetrics() = default;
 
 FileStorDiskMetrics::FileStorDiskMetrics(const std::string& name, const std::string& description,
                                          const metrics::LoadTypeSet& loadTypes, MetricSet* owner)
-    : MetricSet(name, "partofsum", description, owner),
-      sumThreads("allthreads", "sum", "", this),
-      sumStripes("allstripes", "sum", "", this),
+    : MetricSet(name, {{"partofsum"}}, description, owner),
+      sumThreads("allthreads", {{"sum"}}, "", this),
+      sumStripes("allstripes", {{"sum"}}, "", this),
       averageQueueWaitingTime(loadTypes,
-                              metrics::DoubleAverageMetric("averagequeuewait", "",
+                              metrics::DoubleAverageMetric("averagequeuewait", {},
                                                            "Average time an operation spends in input queue."),
                               this),
-      queueSize("queuesize", "", "Size of input message queue.", this),
-      pendingMerges("pendingmerge", "", "Number of buckets currently being merged.", this),
-      waitingForLockHitRate("waitingforlockrate", "",
+      queueSize("queuesize", {}, "Size of input message queue.", this),
+      pendingMerges("pendingmerge", {}, "Number of buckets currently being merged.", this),
+      waitingForLockHitRate("waitingforlockrate", {},
               "Amount of times a filestor thread has needed to wait for "
               "lock to take next message in queue.", this),
-      lockWaitTime("lockwaittime", "", "Amount of time waiting used waiting for lock.", this)
+      lockWaitTime("lockwaittime", {}, "Amount of time waiting used waiting for lock.", this)
 {
     pendingMerges.unsetOnZeroValue();
     waitingForLockHitRate.unsetOnZeroValue();
@@ -236,11 +237,11 @@ FileStorDiskMetrics::initDiskMetrics(const LoadTypeSet& loadTypes, uint32_t numS
 }
 
 FileStorMetrics::FileStorMetrics(const LoadTypeSet&)
-    : MetricSet("filestor", "filestor", ""),
-      sum("alldisks", "sum", "", this),
-      directoryEvents("directoryevents", "", "Number of directory events received.", this),
-      partitionEvents("partitionevents", "", "Number of partition events received.", this),
-      diskEvents("diskevents", "", "Number of disk events received.", this)
+    : MetricSet("filestor", {{"filestor"}}, ""),
+      sum("alldisks", {{"sum"}}, "", this),
+      directoryEvents("directoryevents", {}, "Number of directory events received.", this),
+      partitionEvents("partitionevents", {}, "Number of partition events received.", this),
+      diskEvents("diskevents", {}, "Number of disk events received.", this)
 { }
 
 FileStorMetrics::~FileStorMetrics() = default;
diff --git a/storage/src/vespa/storage/storageserver/bouncer_metrics.cpp b/storage/src/vespa/storage/storageserver/bouncer_metrics.cpp
index 2ee39ad22ec..c0fac35263e 100644
--- a/storage/src/vespa/storage/storageserver/bouncer_metrics.cpp
+++ b/storage/src/vespa/storage/storageserver/bouncer_metrics.cpp
@@ -5,12 +5,12 @@
 namespace storage {
 
 BouncerMetrics::BouncerMetrics()
-    : MetricSet("bouncer", "", "Metrics for Bouncer component", nullptr),
-      clock_skew_aborts("clock_skew_aborts", "", "Number of client operations that were aborted due to "
+    : MetricSet("bouncer", {}, "Metrics for Bouncer component", nullptr),
+      clock_skew_aborts("clock_skew_aborts", {}, "Number of client operations that were aborted due to "
                         "clock skew between sender and receiver exceeding acceptable range", this)
 {
 }
 
 BouncerMetrics::~BouncerMetrics() = default;
 
-}
\ No newline at end of file
+}
diff --git a/storage/src/vespa/storage/storageserver/changedbucketownershiphandler.cpp b/storage/src/vespa/storage/storageserver/changedbucketownershiphandler.cpp
index 166aa25bc68..66e0209d4b7 100644
--- a/storage/src/vespa/storage/storageserver/changedbucketownershiphandler.cpp
+++ b/storage/src/vespa/storage/storageserver/changedbucketownershiphandler.cpp
@@ -89,10 +89,10 @@ allDistributorsDownInState(const lib::ClusterState& state) {
 }
 
 ChangedBucketOwnershipHandler::Metrics::Metrics(metrics::MetricSet* owner)
-    : metrics::MetricSet("changedbucketownershiphandler", "", "", owner),
-      averageAbortProcessingTime("avg_abort_processing_time", "", "Average time spent aborting operations for changed buckets", this),
-      idealStateOpsAborted("ideal_state_ops_aborted", "", "Number of outdated ideal state operations aborted", this),
-      externalLoadOpsAborted("external_load_ops_aborted", "", "Number of outdated external load operations aborted", this)
+    : metrics::MetricSet("changedbucketownershiphandler", {}, "", owner),
+      averageAbortProcessingTime("avg_abort_processing_time", {}, "Average time spent aborting operations for changed buckets", this),
+      idealStateOpsAborted("ideal_state_ops_aborted", {}, "Number of outdated ideal state operations aborted", this),
+      externalLoadOpsAborted("external_load_ops_aborted", {}, "Number of outdated external load operations aborted", this)
 {}
 ChangedBucketOwnershipHandler::Metrics::~Metrics() { }
 
diff --git a/storage/src/vespa/storage/storageserver/communicationmanagermetrics.cpp b/storage/src/vespa/storage/storageserver/communicationmanagermetrics.cpp
index 5d2caddb200..5f2bed07f66 100644
--- a/storage/src/vespa/storage/storageserver/communicationmanagermetrics.cpp
+++ b/storage/src/vespa/storage/storageserver/communicationmanagermetrics.cpp
@@ -7,24 +7,24 @@ using namespace metrics;
 namespace storage {
 
 CommunicationManagerMetrics::CommunicationManagerMetrics(const LoadTypeSet& loadTypes, MetricSet* owner)
-    : MetricSet("communication", "", "Metrics for the communication manager", owner),
-      queueSize("messagequeue", "", "Size of input message queue.", this),
+    : MetricSet("communication", {}, "Metrics for the communication manager", owner),
+      queueSize("messagequeue", {}, "Size of input message queue.", this),
       messageProcessTime(loadTypes,
-                         DoubleAverageMetric("messageprocesstime", "",
+                         DoubleAverageMetric("messageprocesstime", {},
                                              "Time transport thread uses to process a single message"),
                          this),
       exceptionMessageProcessTime(loadTypes,
-                                  DoubleAverageMetric("exceptionmessageprocesstime", "",
+                                  DoubleAverageMetric("exceptionmessageprocesstime", {},
                                                       "Time transport thread uses to process a single message "
                                                       "that fails with an exception thrown into communication manager"),
                                   this),
-      failedDueToTooLittleMemory("toolittlememory", "", "Number of messages failed due to too little memory available", this),
-      convertToStorageAPIFailures("convertfailures", "",
+      failedDueToTooLittleMemory("toolittlememory", {}, "Number of messages failed due to too little memory available", this),
+      convertToStorageAPIFailures("convertfailures", {},
                                   "Number of messages that failed to get converted to storage API messages", this),
-      bucketSpaceMappingFailures("bucket_space_mapping_failures", "",
+      bucketSpaceMappingFailures("bucket_space_mapping_failures", {},
                                  "Number of messages that could not be resolved to a known bucket space", this),
-      sendCommandLatency("sendcommandlatency", "", "Average ms used to send commands to MBUS", this),
-      sendReplyLatency("sendreplylatency", "", "Average ms used to send replies to MBUS", this)
+      sendCommandLatency("sendcommandlatency", {}, "Average ms used to send commands to MBUS", this),
+      sendReplyLatency("sendreplylatency", {}, "Average ms used to send replies to MBUS", this)
 {
 }
 
diff --git a/storage/src/vespa/storage/storageserver/mergethrottler.cpp b/storage/src/vespa/storage/storageserver/mergethrottler.cpp
index a9d54c196c9..92ed01ca5d9 100644
--- a/storage/src/vespa/storage/storageserver/mergethrottler.cpp
+++ b/storage/src/vespa/storage/storageserver/mergethrottler.cpp
@@ -67,26 +67,26 @@ MergeThrottler::ChainedMergeState::ChainedMergeState(const api::StorageMessage::
 MergeThrottler::ChainedMergeState::~ChainedMergeState() {}
 
 MergeThrottler::Metrics::Metrics(metrics::MetricSet* owner)
-    : metrics::MetricSet("mergethrottler", "", "", owner),
-      averageQueueWaitingTime("averagequeuewaitingtime", "", "Average time a merge spends in the throttler queue", this),
-      bounced_due_to_back_pressure("bounced_due_to_back_pressure", "", "Number of merges bounced due to resource exhaustion back-pressure", this),
+    : metrics::MetricSet("mergethrottler", {}, "", owner),
+      averageQueueWaitingTime("averagequeuewaitingtime", {}, "Average time a merge spends in the throttler queue", this),
+      bounced_due_to_back_pressure("bounced_due_to_back_pressure", {}, "Number of merges bounced due to resource exhaustion back-pressure", this),
       chaining("mergechains", this),
       local("locallyexecutedmerges", this)
 { }
 MergeThrottler::Metrics::~Metrics() {}
 
 MergeThrottler::MergeFailureMetrics::MergeFailureMetrics(metrics::MetricSet* owner)
-    : metrics::MetricSet("failures", "", "Detailed failure statistics", owner),
-      sum("total", "", "Sum of all failures", this),
-      notready("notready", "", "The number of merges discarded because distributor was not ready", this),
-      timeout("timeout", "", "The number of merges that failed because they timed out towards storage", this),
-      aborted("aborted", "", "The number of merges that failed because the storage node was (most likely) shutting down", this),
-      wrongdistribution("wrongdistribution", "", "The number of merges that were discarded (flushed) because they were initiated at an older cluster state than the current", this),
-      bucketnotfound("bucketnotfound", "", "The number of operations that failed because the bucket did not exist", this),
-      busy("busy", "", "The number of merges that failed because the storage node was busy", this),
-      exists("exists", "", "The number of merges that were rejected due to a merge operation for their bucket already being processed", this),
-      rejected("rejected", "", "The number of merges that were rejected", this),
-      other("other", "", "The number of other failures", this)
+    : metrics::MetricSet("failures", {}, "Detailed failure statistics", owner),
+      sum("total", {}, "Sum of all failures", this),
+      notready("notready", {}, "The number of merges discarded because distributor was not ready", this),
+      timeout("timeout", {}, "The number of merges that failed because they timed out towards storage", this),
+      aborted("aborted", {}, "The number of merges that failed because the storage node was (most likely) shutting down", this),
+      wrongdistribution("wrongdistribution", {}, "The number of merges that were discarded (flushed) because they were initiated at an older cluster state than the current", this),
+      bucketnotfound("bucketnotfound", {}, "The number of operations that failed because the bucket did not exist", this),
+      busy("busy", {}, "The number of merges that failed because the storage node was busy", this),
+      exists("exists", {}, "The number of merges that were rejected due to a merge operation for their bucket already being processed", this),
+      rejected("rejected", {}, "The number of merges that were rejected", this),
+      other("other", {}, "The number of other failures", this)
 {
     sum.addMetricToSum(notready);
     sum.addMetricToSum(timeout);
@@ -102,8 +102,8 @@ MergeThrottler::MergeFailureMetrics::~MergeFailureMetrics() { }
 
 
 MergeThrottler::MergeOperationMetrics::MergeOperationMetrics(const std::string& name, metrics::MetricSet* owner)
-    : metrics::MetricSet(name, "", vespalib::make_string("Statistics for %s", name.c_str()), owner),
-      ok("ok", "", vespalib::make_string("The number of successful merges for '%s'", name.c_str()), this),
+    : metrics::MetricSet(name, {}, vespalib::make_string("Statistics for %s", name.c_str()), owner),
+      ok("ok", {}, vespalib::make_string("The number of successful merges for '%s'", name.c_str()), this),
       failures(this)
 {
 }
diff --git a/storage/src/vespa/storage/storageserver/storagemetricsset.cpp b/storage/src/vespa/storage/storageserver/storagemetricsset.cpp
index fde33d524b8..4ea9a9f9296 100644
--- a/storage/src/vespa/storage/storageserver/storagemetricsset.cpp
+++ b/storage/src/vespa/storage/storageserver/storagemetricsset.cpp
@@ -6,39 +6,39 @@
 namespace storage {
 
 MessageMemoryUseMetricSet::MessageMemoryUseMetricSet(metrics::MetricSet* owner)
-    : metrics::MetricSet("message_memory_use", "memory", "Message use from storage messages", owner),
-      total("total", "memory", "Message use from storage messages", this),
-      lowpri("lowpri", "memory", "Message use from low priority storage messages", this),
-      normalpri("normalpri", "memory", "Message use from normal priority storage messages", this),
-      highpri("highpri", "memory", "Message use from high priority storage messages", this),
-      veryhighpri("veryhighpri", "memory", "Message use from very high priority storage messages", this)
+    : metrics::MetricSet("message_memory_use", {{"memory"}}, "Message use from storage messages", owner),
+      total("total", {{"memory"}}, "Message use from storage messages", this),
+      lowpri("lowpri", {{"memory"}}, "Message use from low priority storage messages", this),
+      normalpri("normalpri", {{"memory"}}, "Message use from normal priority storage messages", this),
+      highpri("highpri", {{"memory"}}, "Message use from high priority storage messages", this),
+      veryhighpri("veryhighpri", {{"memory"}}, "Message use from very high priority storage messages", this)
 { }
 MessageMemoryUseMetricSet::~MessageMemoryUseMetricSet() {}
 
 DocumentSerializationMetricSet::DocumentSerializationMetricSet(metrics::MetricSet* owner)
-    : metrics::MetricSet("document_serialization", "docserialization",
+    : metrics::MetricSet("document_serialization", {{"docserialization"}},
             "Counts of document serialization of various types", owner),
       usedCachedSerializationCount(
-            "cached_serialization_count", "docserialization",
+            "cached_serialization_count", {{"docserialization"}},
             "Number of times we didn't need to serialize the document as "
             "we already had serialized version cached", this),
       compressedDocumentCount(
-            "compressed_serialization_count", "docserialization",
+            "compressed_serialization_count", {{"docserialization"}},
             "Number of times we compressed document when serializing",
             this),
       compressionDidntHelpCount(
-            "compressed_didnthelp_count", "docserialization",
+            "compressed_didnthelp_count", {{"docserialization"}},
             "Number of times we compressed document when serializing, but "
             "the compressed version was bigger, so it was dumped", this),
       uncompressableCount(
-            "uncompressable_serialization_count", "docserialization",
+            "uncompressable_serialization_count", {{"docserialization"}},
             "Number of times we didn't attempt compression as document "
             "had already been tagged uncompressable", this),
       serializedUncompressed(
-            "uncompressed_serialization_count", "docserialization",
+            "uncompressed_serialization_count", {{"docserialization"}},
             "Number of times we serialized a document uncompressed", this),
       inputWronglySerialized(
-            "input_wrongly_serialized_count", "docserialization",
+            "input_wrongly_serialized_count", {{"docserialization"}},
             "Number of times we reserialized a document because the "
             "compression it had in cache did not match what was configured",
             this)
@@ -46,11 +46,11 @@ DocumentSerializationMetricSet::DocumentSerializationMetricSet(metrics::MetricSe
 DocumentSerializationMetricSet::~DocumentSerializationMetricSet() { }
 
 StorageMetricSet::StorageMetricSet()
-    : metrics::MetricSet("server", "memory",
+    : metrics::MetricSet("server", {{"memory"}},
           "Metrics for VDS applications"),
-      memoryUse("memoryusage", "memory", "", this),
+      memoryUse("memoryusage", {{"memory"}}, "", this),
       memoryUse_messages(this),
-      memoryUse_visiting("memoryusage_visiting", "memory",
+      memoryUse_visiting("memoryusage_visiting", {{"memory"}},
             "Message use from visiting", this),
       documentSerialization(this)
 { }
diff --git a/storage/src/vespa/storage/visiting/visitormetrics.cpp b/storage/src/vespa/storage/visiting/visitormetrics.cpp
index e6903dc6f11..191f9fabc60 100644
--- a/storage/src/vespa/storage/visiting/visitormetrics.cpp
+++ b/storage/src/vespa/storage/visiting/visitormetrics.cpp
@@ -7,26 +7,26 @@
 namespace storage {
 
 VisitorMetrics::VisitorMetrics()
-    : metrics::MetricSet("visitor", "visitor", ""),
-      queueSize("cv_queuesize", "", "Size of create visitor queue", this),
-      queueSkips("cv_skipqueue", "",
+    : metrics::MetricSet("visitor", {{"visitor"}}, ""),
+      queueSize("cv_queuesize", {}, "Size of create visitor queue", this),
+      queueSkips("cv_skipqueue", {},
               "Number of times we could skip queue as we had free visitor "
               "spots", this),
-      queueFull("cv_queuefull", "",
+      queueFull("cv_queuefull", {},
               "Number of create visitor messages failed as queue is full",
               this),
-      queueWaitTime("cv_queuewaittime", "",
+      queueWaitTime("cv_queuewaittime", {},
               "Milliseconds waiting in create visitor queue, for visitors "
               "that was added to visitor queue but scheduled later", this),
-      queueTimeoutWaitTime("cv_queuetimeoutwaittime", "",
+      queueTimeoutWaitTime("cv_queuetimeoutwaittime", {},
               "Milliseconds waiting in create visitor queue, for visitors "
               "that timed out while in the visitor quueue", this),
-      queueEvictedWaitTime("cv_queueevictedwaittime", "",
+      queueEvictedWaitTime("cv_queueevictedwaittime", {},
               "Milliseconds waiting in create visitor queue, for visitors "
               "that was evicted from queue due to higher priority visitors "
               "coming", this),
       threads(),
-      sum("allthreads", "sum", "", this)
+      sum("allthreads", {{"sum"}}, "", this)
 {
     queueSize.unsetOnZeroValue();
 }
diff --git a/storage/src/vespa/storage/visiting/visitorthreadmetrics.h b/storage/src/vespa/storage/visiting/visitorthreadmetrics.h
index 991674eaec1..c21fe09cdb4 100644
--- a/storage/src/vespa/storage/visiting/visitorthreadmetrics.h
+++ b/storage/src/vespa/storage/visiting/visitorthreadmetrics.h
@@ -33,68 +33,68 @@ struct VisitorThreadMetrics : public metrics::MetricSet
     VisitorThreadMetrics(const std::string& name,
                          const std::string& desc,
                          const metrics::LoadTypeSet& loadTypes)
-        : metrics::MetricSet(name, "visitor partofsum thread", desc),
-          queueSize("queuesize", "",
+        : metrics::MetricSet(name, {{"visitor"},{"partofsum"},{"thread"}}, desc),
+          queueSize("queuesize", {},
                   "Size of input message queue.", this),
           averageQueueWaitingTime(
                   loadTypes,
                   DOUBLE("averagequeuewait",
-                         "",
+                         {},
                          "Average time an operation spends in input queue."),
                   this),
           averageVisitorLifeTime(
                   loadTypes,
                   DOUBLE("averagevisitorlifetime",
-                         "",
+                         {},
                          "Average lifetime of a visitor"),
                   this),
           averageVisitorCreationTime(
                   loadTypes,
                   DOUBLE("averagevisitorcreationtime",
-                         "",
+                         {},
                          "Average time spent creating a visitor instance"),
                   this),
           averageMessageSendTime(
                   loadTypes,
                   DOUBLE("averagemessagesendtime",
-                         "",
+                         {},
                          "Average time it takes for messages to be sent to "
                          "their target (and be replied to)"),
                   this),
           averageProcessingTime(
                   loadTypes,
                   DOUBLE("averageprocessingtime",
-                         "",
+                         {},
                          "Average time visitor uses in handleDocuments() call"),
                   this),
           createdVisitors(
                   loadTypes,
                   COUNT("created",
-                        "",
+                        {},
                         "Number of visitors created."),
                   this),
           abortedVisitors(
                   loadTypes,
                   COUNT("aborted",
-                        "",
+                        {},
                         "Number of visitors aborted."),
                   this),
           completedVisitors(
                   loadTypes,
                   COUNT("completed",
-                        "",
+                        {},
                         "Number of visitors completed"),
                   this),
           failedVisitors(
                   loadTypes,
                   COUNT("failed",
-                        "",
+                        {},
                         "Number of visitors failed"),
                   this),
           visitorDestinationFailureReplies(
                 loadTypes,
                 COUNT("destination_failure_replies",
-                      "",
+                      {},
                       "Number of failure replies received from "
                       "the visitor destination"),
                 this)