Let node info for cluster controller be explicit, and not a metric consumer.

14 files changed, 151 insertions, 76 deletions

diff --git a/storage/src/tests/bucketdb/bucketmanagertest.cpp b/storage/src/tests/bucketdb/bucketmanagertest.cpp
index ea3a782d432..e9a9520e8c0 100644
--- a/storage/src/tests/bucketdb/bucketmanagertest.cpp
+++ b/storage/src/tests/bucketdb/bucketmanagertest.cpp
@@ -22,7 +22,7 @@
 #include <vespa/vdslib/state/random.h>
 #include <vespa/vdslib/distribution/distribution.h>
 #include <vespa/vdslib/state/clusterstate.h>
-#include <vespa/vespalib/io/fileutil.h>
+#include <vespa/vespalib/stllike/asciistream.h>
 #include <vespa/vespalib/gtest/gtest.h>
 #include <future>
 
@@ -518,6 +518,20 @@ TEST_F(BucketManagerTest, metrics_are_tracked_per_bucket_space) {
     EXPECT_EQ(0,   global_m->second->ready_buckets.getLast());
 
     verify_db_memory_metrics_present(global_m->second->bucket_db_metrics);
+    using namespace vespalib::jsonstream;
+    vespalib::asciistream ascii;
+    vespalib::JsonStream jsonStream(ascii, false);
+    jsonStream << Object() << "values" << Array();
+    _manager->report(jsonStream);
+    jsonStream << End();
+    EXPECT_EQ(std::string("{\"values\":["
+              "{\"name\":\"vds.datastored.bucket_space.buckets_total\",\"values\":{\"last\":1},\"dimensions\":{\"bucketSpace\":\"global\"}},"
+              "{\"name\":\"vds.datastored.bucket_space.buckets_total\",\"values\":{\"last\":1},\"dimensions\":{\"bucketSpace\":\"default\"}},"
+              "{\"name\":\"vds.datastored.alldisks.docs\",\"values\":{\"last\":250}},"
+              "{\"name\":\"vds.datastored.alldisks.bytes\",\"values\":{\"last\":500}},"
+              "{\"name\":\"vds.datastored.alldisks.buckets\",\"values\":{\"last\":2}}"
+              "]"),
+              std::string(ascii.c_str()));
 }
 
 void
diff --git a/storage/src/tests/storageserver/statemanagertest.cpp b/storage/src/tests/storageserver/statemanagertest.cpp
index 5764460f5bb..d757a83db01 100644
--- a/storage/src/tests/storageserver/statemanagertest.cpp
+++ b/storage/src/tests/storageserver/statemanagertest.cpp
@@ -1,6 +1,5 @@
 // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
-#include <vespa/metrics/metricmanager.h>
 #include <vespa/storageapi/message/bucket.h>
 #include <vespa/storageapi/message/state.h>
 #include <vespa/vdslib/state/cluster_state_bundle.h>
@@ -20,10 +19,9 @@ using namespace ::testing;
 
 namespace storage {
 
-struct StateManagerTest : Test {
+struct StateManagerTest : Test, NodeStateReporter {
     std::unique_ptr<TestServiceLayerApp> _node;
     std::unique_ptr<DummyStorageLink> _upper;
-    std::unique_ptr<metrics::MetricManager> _metricManager;
     StateManager* _manager;
     DummyStorageLink* _lower;
 
@@ -42,6 +40,7 @@ struct StateManagerTest : Test {
     std::string get_node_info() const {
         return _manager->getNodeInfo();
     }
+    void report(vespalib::JsonStream &) const override {}
 
     void extract_cluster_state_version_from_host_info(uint32_t& version_out);
 };
@@ -60,11 +59,8 @@ StateManagerTest::SetUp()
     _node = std::make_unique<TestServiceLayerApp>(NodeIndex(2));
     // Clock will increase 1 sec per call.
     _node->getClock().setAbsoluteTimeInSeconds(1);
-    _metricManager = std::make_unique<metrics::MetricManager>();
     _upper = std::make_unique<DummyStorageLink>();
-    _manager = new StateManager(_node->getComponentRegister(),
-                                *_metricManager,
-                                std::make_unique<HostInfo>());
+    _manager = new StateManager(_node->getComponentRegister(), std::make_unique<HostInfo>(), *this, false);
     _lower = new DummyStorageLink();
     _upper->push_back(StorageLink::UP(_manager));
     _upper->push_back(StorageLink::UP(_lower));
@@ -83,7 +79,6 @@ StateManagerTest::TearDown() {
     _upper->flush();
     _upper.reset();
     _node.reset();
-    _metricManager.reset();
 }
 
 void
diff --git a/storage/src/vespa/storage/bucketdb/bucketmanager.cpp b/storage/src/vespa/storage/bucketdb/bucketmanager.cpp
index a3a55ba736e..c8c36f94579 100644
--- a/storage/src/vespa/storage/bucketdb/bucketmanager.cpp
+++ b/storage/src/vespa/storage/bucketdb/bucketmanager.cpp
@@ -17,6 +17,7 @@
 #include <vespa/storageapi/message/state.h>
 #include <vespa/storageapi/message/bucketsplitting.h>
 #include <vespa/storageapi/message/stat.h>
+#include <vespa/metrics/jsonwriter.h>
 #include <vespa/document/bucket/fixed_bucket_spaces.h>
 #include <vespa/vespalib/util/stringfmt.h>
 #include <ranges>
@@ -73,7 +74,8 @@ BucketManager::~BucketManager()
     closeNextLink();
 }
 
-void BucketManager::onClose()
+void
+BucketManager::onClose()
 {
     // Stop internal thread such that we don't send any more messages down.
     if (_thread) {
@@ -155,7 +157,6 @@ struct MetricsUpdater {
 
         constexpr Count() noexcept : docs(0), bytes(0), buckets(0), active(0), ready(0) {}
     };
-
     Count    count;
     uint32_t lowestUsedBit;
 
@@ -197,21 +198,64 @@ struct MetricsUpdater {
 
 }   // End of anonymous namespace
 
+namespace {
+
+void
+output(vespalib::JsonStream & json, vespalib::stringref name, uint64_t value, vespalib::stringref bucketSpace) {
+    using namespace vespalib::jsonstream;
+    json << Object();
+    json << "name" << name;
+    json << "values" << Object() << "last" << value << End();
+    if ( ! bucketSpace.empty()) {
+        json << "dimensions" << Object();
+        json << "bucketSpace" << bucketSpace;
+        json << End();
+    }
+    json << End();
+}
+
+void
+output(vespalib::JsonStream & json, vespalib::stringref name, uint64_t value) {
+    output(json, name, value, "");
+}
+
+MetricsUpdater
+getMetrics(const StorBucketDatabase & db) {
+    MetricsUpdater m;
+    auto guard = db.acquire_read_guard();
+    guard->for_each(std::ref(m));
+    return m;
+}
+
+}
+
+void
+BucketManager::report(vespalib::JsonStream & json) const {
+    MetricsUpdater total;
+    for (const auto& space : _component.getBucketSpaceRepo()) {
+        MetricsUpdater m = getMetrics(space.second->bucketDatabase());
+        output(json, "vds.datastored.bucket_space.buckets_total", m.count.buckets,
+               document::FixedBucketSpaces::to_string(space.first));
+        total.add(m);
+    }
+    const auto & src = total.count;
+    output(json, "vds.datastored.alldisks.docs", src.docs);
+    output(json, "vds.datastored.alldisks.bytes", src.bytes);
+    output(json, "vds.datastored.alldisks.buckets", src.buckets);
+}
+
 StorBucketDatabase::Entry
 BucketManager::getBucketInfo(const document::Bucket &bucket) const
 {
-    StorBucketDatabase::WrappedEntry entry(_component.getBucketDatabase(bucket.getBucketSpace()).get(bucket.getBucketId(), "BucketManager::getBucketInfo"));
-    return *entry;
+    return *_component.getBucketDatabase(bucket.getBucketSpace()).get(bucket.getBucketId(), "BucketManager::getBucketInfo");
 }
 
 void
-BucketManager::updateMetrics()
+BucketManager::updateMetrics() const
 {
     MetricsUpdater total;
     for (const auto& space : _component.getBucketSpaceRepo()) {
-        MetricsUpdater m;
-        auto guard = space.second->bucketDatabase().acquire_read_guard();
-        guard->for_each(std::ref(m));
+        MetricsUpdater m = getMetrics(space.second->bucketDatabase());
         total.add(m);
         auto bm = _metrics->bucket_spaces.find(space.first);
         assert(bm != _metrics->bucket_spaces.end());
@@ -231,14 +275,17 @@ BucketManager::updateMetrics()
     update_bucket_db_memory_usage_metrics();
 }
 
-void BucketManager::update_bucket_db_memory_usage_metrics() {
+
+void
+BucketManager::update_bucket_db_memory_usage_metrics() const {
     for (const auto& space : _component.getBucketSpaceRepo()) {
         auto bm = _metrics->bucket_spaces.find(space.first);
         bm->second->bucket_db_metrics.memory_usage.update(space.second->bucketDatabase().detailed_memory_usage());
     }
 }
 
-void BucketManager::updateMinUsedBits()
+void
+BucketManager::updateMinUsedBits()
 {
     MetricsUpdater m;
     _component.getBucketSpaceRepo().for_each_bucket(std::ref(m));
diff --git a/storage/src/vespa/storage/bucketdb/bucketmanager.h b/storage/src/vespa/storage/bucketdb/bucketmanager.h
index 547ff87dfc0..eea5719ad3b 100644
--- a/storage/src/vespa/storage/bucketdb/bucketmanager.h
+++ b/storage/src/vespa/storage/bucketdb/bucketmanager.h
@@ -13,6 +13,7 @@
 #include <vespa/storage/bucketdb/config-stor-bucketdb.h>
 #include <vespa/storage/common/servicelayercomponent.h>
 #include <vespa/storage/common/storagelinkqueued.h>
+#include <vespa/storage/common/nodestateupdater.h>
 #include <vespa/storageapi/message/bucket.h>
 #include <vespa/storageframework/generic/metric/metricupdatehook.h>
 #include <vespa/storageframework/generic/status/statusreporter.h>
@@ -28,6 +29,7 @@ namespace storage {
 
 class BucketManager : public StorageLink,
                       public framework::StatusReporter,
+                      public NodeStateReporter,
                       private framework::Runnable,
                       private framework::MetricUpdateHook
 {
@@ -37,7 +39,9 @@ public:
     using BucketInfoRequestMap = std::unordered_map<document::BucketSpace, BucketInfoRequestList, document::BucketSpace::hash>;
 
 private:
-    config::ConfigUri _configUri;
+    using ReplyQueue = std::vector<api::StorageReply::SP>;
+    using ConflictingBuckets = std::unordered_set<document::BucketId, document::BucketId::hash>;
+    config::ConfigUri    _configUri;
     BucketInfoRequestMap _bucketInfoRequests;
 
     /**
@@ -49,25 +53,23 @@ private:
     /**
      * Lock kept for access to 3 values below concerning cluster state.
      */
-    std::mutex         _clusterStateLock;
+    std::mutex              _clusterStateLock;
+    mutable std::mutex      _queueProcessingLock;
 
-    mutable std::mutex _queueProcessingLock;
-    using ReplyQueue = std::vector<api::StorageReply::SP>;
-    using ConflictingBuckets = std::unordered_set<document::BucketId, document::BucketId::hash>;
-    ReplyQueue _queuedReplies;
-    ConflictingBuckets _conflictingBuckets;
+    ReplyQueue                            _queuedReplies;
+    ConflictingBuckets                    _conflictingBuckets;
     // The most current cluster state versions that we've observed on the way _down_
     // through the chain, i.e. prior to being enabled on the node.
-    uint32_t _last_cluster_state_version_initiated;
+    uint32_t                              _last_cluster_state_version_initiated;
     // The most current cluster state we've observed on the way _up_ through the
     // chain, i.e. after being enabled on the node.
-    uint32_t _last_cluster_state_version_completed;
-    bool _doneInitialized;
-    size_t _requestsCurrentlyProcessing;
-    ServiceLayerComponent _component;
+    uint32_t                              _last_cluster_state_version_completed;
+    bool                                  _doneInitialized;
+    size_t                                _requestsCurrentlyProcessing;
+    ServiceLayerComponent                 _component;
     std::shared_ptr<BucketManagerMetrics> _metrics;
-    std::unique_ptr<framework::Thread> _thread;
-    std::chrono::milliseconds _simulated_processing_delay;
+    std::unique_ptr<framework::Thread>    _thread;
+    std::chrono::milliseconds             _simulated_processing_delay;
 
     class ScopedQueueDispatchGuard {
         BucketManager& _mgr;
@@ -97,7 +99,7 @@ public:
     void force_db_sweep_and_metric_update() { updateMetrics(); }
 
     bool onUp(const std::shared_ptr<api::StorageMessage>&) override;
-
+    void report(vespalib::JsonStream &writer) const override;
 private:
     friend struct BucketManagerTest;
 
@@ -112,9 +114,9 @@ private:
     void onDoneInit() override { _doneInitialized = true; }
     void onClose() override;
 
-    void updateMetrics();
+    void updateMetrics() const;
     void updateMetrics(const MetricLockGuard &) override { updateMetrics(); }
-    void update_bucket_db_memory_usage_metrics();
+    void update_bucket_db_memory_usage_metrics() const;
     void updateMinUsedBits();
 
     bool onRequestBucketInfo(const std::shared_ptr<api::RequestBucketInfoCommand>&) override;
diff --git a/storage/src/vespa/storage/common/nodestateupdater.h b/storage/src/vespa/storage/common/nodestateupdater.h
index 842828a1b89..3d32b9e4b4b 100644
--- a/storage/src/vespa/storage/common/nodestateupdater.h
+++ b/storage/src/vespa/storage/common/nodestateupdater.h
@@ -25,7 +25,9 @@
 
 #include <string>
 #include <vespa/vdslib/state/nodestate.h>
+#include "vespa/vespalib/util/jsonstream.h"
 
+namespace metrics { class JsonWriter; }
 namespace storage {
 
 namespace lib { class ClusterStateBundle; }
@@ -77,6 +79,12 @@ struct NodeStateUpdater {
     virtual void request_almost_immediate_node_state_replies() = 0;
 };
 
+class NodeStateReporter {
+public:
+    virtual ~NodeStateReporter() = default;
+    virtual void report(vespalib::JsonStream &writer) const = 0;
+};
+
 } // storage
 
 
diff --git a/storage/src/vespa/storage/storageserver/distributornode.cpp b/storage/src/vespa/storage/storageserver/distributornode.cpp
index 45abd34e131..ab80381f5d4 100644
--- a/storage/src/vespa/storage/storageserver/distributornode.cpp
+++ b/storage/src/vespa/storage/storageserver/distributornode.cpp
@@ -39,7 +39,7 @@ DistributorNode::DistributorNode(
         set_storage_chain_builder(std::move(storage_chain_builder));
     }
     try {
-        initialize();
+        initialize(*this);
     } catch (const vespalib::Exception & e) {
         shutdownDistributor();
         throw;
diff --git a/storage/src/vespa/storage/storageserver/distributornode.h b/storage/src/vespa/storage/storageserver/distributornode.h
index 7224abfa59c..5d61c86d48a 100644
--- a/storage/src/vespa/storage/storageserver/distributornode.h
+++ b/storage/src/vespa/storage/storageserver/distributornode.h
@@ -10,6 +10,7 @@
 
 #include "distributornodecontext.h"
 #include "storagenode.h"
+#include "vespa/vespalib/util/jsonstream.h"
 #include <vespa/storage/common/distributorcomponent.h>
 #include <vespa/storageframework/generic/thread/tickingthread.h>
 #include <mutex>
@@ -22,7 +23,8 @@ class IStorageChainBuilder;
 
 class DistributorNode
       : public StorageNode,
-        private UniqueTimeCalculator
+        private UniqueTimeCalculator,
+        private NodeStateReporter
 {
     framework::TickingThreadPool::UP _threadPool;
     std::unique_ptr<distributor::DistributorStripePool> _stripe_pool;
@@ -58,8 +60,9 @@ public:
     void handleConfigChange(vespa::config::content::core::StorVisitordispatcherConfig&);
 
 private:
-    void initializeNodeSpecific() override;
+    void report(vespalib::JsonStream &) const override { /* no-op */ }
     void perform_post_chain_creation_init_steps() override { /* no-op */ }
+    void initializeNodeSpecific() override;
     void createChain(IStorageChainBuilder &builder) override;
     api::Timestamp generate_unique_timestamp() override;
 
diff --git a/storage/src/vespa/storage/storageserver/servicelayernode.cpp b/storage/src/vespa/storage/storageserver/servicelayernode.cpp
index b76e2cca02a..b8fbeb2daf3 100644
--- a/storage/src/vespa/storage/storageserver/servicelayernode.cpp
+++ b/storage/src/vespa/storage/storageserver/servicelayernode.cpp
@@ -39,6 +39,15 @@ ServiceLayerNode::ServiceLayerNode(const config::ConfigUri & configUri, ServiceL
 {
 }
 
+void
+ServiceLayerNode::report(vespalib::JsonStream &writer) const
+{
+    (void) writer;
+    if (_bucket_manager) {
+        _bucket_manager->report(writer);
+    }
+}
+
 void ServiceLayerNode::init()
 {
     assert( ! _init_has_been_called);
@@ -50,7 +59,7 @@ void ServiceLayerNode::init()
     }
 
     try{
-        initialize();
+        initialize(*this);
     } catch (spi::HandledException& e) {
         requestShutdown("Failed to initialize: " + e.getMessage());
         throw;
@@ -164,9 +173,9 @@ ServiceLayerNode::createChain(IStorageChainBuilder &builder)
     auto bucket_manager = std::make_unique<BucketManager>(_configUri, _context.getComponentRegister());
     _bucket_manager = bucket_manager.get();
     builder.add(std::move(bucket_manager));
-    builder.add(std::make_unique<VisitorManager>(_configUri, _context.getComponentRegister(), static_cast<VisitorMessageSessionFactory &>(*this), _externalVisitors));
-    builder.add(std::make_unique<ModifiedBucketChecker>(
-            _context.getComponentRegister(), _persistenceProvider, _configUri));
+    builder.add(std::make_unique<VisitorManager>(_configUri, _context.getComponentRegister(),
+                                                 static_cast<VisitorMessageSessionFactory &>(*this), _externalVisitors));
+    builder.add(std::make_unique<ModifiedBucketChecker>(_context.getComponentRegister(), _persistenceProvider, _configUri));
     auto state_manager = releaseStateManager();
     auto filstor_manager = std::make_unique<FileStorManager>(_configUri, _persistenceProvider, _context.getComponentRegister(),
                                                              getDoneInitializeHandler(), state_manager->getHostInfo());
diff --git a/storage/src/vespa/storage/storageserver/servicelayernode.h b/storage/src/vespa/storage/storageserver/servicelayernode.h
index 4b719a0330b..e308c020856 100644
--- a/storage/src/vespa/storage/storageserver/servicelayernode.h
+++ b/storage/src/vespa/storage/storageserver/servicelayernode.h
@@ -11,8 +11,10 @@
 #include "applicationgenerationfetcher.h"
 #include "servicelayernodecontext.h"
 #include "storagenode.h"
+#include "vespa/vespalib/util/jsonstream.h"
 #include <vespa/storage/visiting/visitormessagesessionfactory.h>
 #include <vespa/storage/common/visitorfactory.h>
+#include <vespa/storage/common/nodestateupdater.h>
 
 namespace storage {
 
@@ -23,18 +25,19 @@ class FileStorManager;
 
 class ServiceLayerNode
         : public StorageNode,
-          private VisitorMessageSessionFactory
+          private VisitorMessageSessionFactory,
+          private NodeStateReporter
 
 {
-    ServiceLayerNodeContext& _context;
-    spi::PersistenceProvider& _persistenceProvider;
-    VisitorFactory::Map _externalVisitors;
+    ServiceLayerNodeContext  & _context;
+    spi::PersistenceProvider & _persistenceProvider;
+    VisitorFactory::Map        _externalVisitors;
 
     // FIXME: Should probably use the fetcher in StorageNode
-    std::unique_ptr<config::ConfigFetcher> _configFetcher;
-    BucketManager* _bucket_manager;
-    FileStorManager* _fileStorManager;
-    bool _init_has_been_called;
+    std::unique_ptr<config::ConfigFetcher>   _configFetcher;
+    BucketManager                          * _bucket_manager;
+    FileStorManager                        * _fileStorManager;
+    bool                                     _init_has_been_called;
 
 public:
     using UP = std::unique_ptr<ServiceLayerNode>;
@@ -55,6 +58,7 @@ public:
     ResumeGuard pause() override;
 
 private:
+    void report(vespalib::JsonStream &writer) const override;
     void subscribeToConfigs() override;
     void initializeNodeSpecific() override;
     void perform_post_chain_creation_init_steps() override;
diff --git a/storage/src/vespa/storage/storageserver/statemanager.cpp b/storage/src/vespa/storage/storageserver/statemanager.cpp
index 76a8cabb515..49957d1d321 100644
--- a/storage/src/vespa/storage/storageserver/statemanager.cpp
+++ b/storage/src/vespa/storage/storageserver/statemanager.cpp
@@ -49,13 +49,13 @@ StateManager::StateManagerMetrics::~StateManagerMetrics() = default;
 using lib::ClusterStateBundle;
 
 StateManager::StateManager(StorageComponentRegister& compReg,
-                           metrics::MetricManager& metricManager,
                            std::unique_ptr<HostInfo> hostInfo,
+                           const NodeStateReporter & reporter,
                            bool testMode)
     : StorageLink("State manager"),
       framework::HtmlStatusReporter("systemstate", "Node and system state"),
       _component(compReg, "statemanager"),
-      _metricManager(metricManager),
+      _nodeStateReporter(reporter),
       _metrics(std::make_unique<StateManagerMetrics>()),
       _stateLock(),
       _stateCond(),
@@ -572,17 +572,10 @@ StateManager::getNodeInfo() const
     vespalib::JsonStream stream(json, true);
     stream << Object();
     { // Print metrics
-        stream << "metrics";
         try {
-            metrics::MetricLockGuard lock(_metricManager.getMetricLock());
-            auto periods(_metricManager.getSnapshotPeriods(lock));
-            if (!periods.empty()) {
-                const metrics::MetricSnapshot& snapshot(_metricManager.getMetricSnapshot(lock, periods[0]));
-                metrics::JsonWriter metricJsonWriter(stream);
-                _metricManager.visit(lock,  snapshot, metricJsonWriter, "fleetcontroller");
-            } else {
-                stream << Object() << "error" << "no snapshot periods" << End();
-            }
+            stream << "metrics" << Object() << "values" << Array();
+            _nodeStateReporter.report(stream);
+            stream << End() << End();
         } catch (vespalib::Exception& e) {
             stream << Object() << "error" << e.getMessage() << End();
         }
diff --git a/storage/src/vespa/storage/storageserver/statemanager.h b/storage/src/vespa/storage/storageserver/statemanager.h
index 3b1291b1c3f..a69675adb1b 100644
--- a/storage/src/vespa/storage/storageserver/statemanager.h
+++ b/storage/src/vespa/storage/storageserver/statemanager.h
@@ -49,7 +49,7 @@ class StateManager : public NodeStateUpdater,
     struct StateManagerMetrics;
 
     StorageComponent                          _component;
-    metrics::MetricManager&                   _metricManager;
+    const NodeStateReporter &                 _nodeStateReporter;
     std::unique_ptr<StateManagerMetrics>      _metrics;
     mutable std::mutex                        _stateLock;
     std::condition_variable                   _stateCond;
@@ -80,8 +80,8 @@ class StateManager : public NodeStateUpdater,
     std::atomic<bool>                         _requested_almost_immediate_node_state_replies;
 
 public:
-    explicit StateManager(StorageComponentRegister&, metrics::MetricManager&,
-                          std::unique_ptr<HostInfo>, bool testMode = false);
+    explicit StateManager(StorageComponentRegister&, std::unique_ptr<HostInfo>,
+                          const NodeStateReporter & reporter, bool testMode);
     ~StateManager() override;
 
     void onOpen() override;
@@ -110,7 +110,6 @@ public:
 
 private:
     struct ExternalStateLock;
-    friend struct ExternalStateLock;
     friend struct StateManagerTest;
 
     void notifyStateListeners();
diff --git a/storage/src/vespa/storage/storageserver/storagenode.cpp b/storage/src/vespa/storage/storageserver/storagenode.cpp
index f0f410d3076..99a879e19db 100644
--- a/storage/src/vespa/storage/storageserver/storagenode.cpp
+++ b/storage/src/vespa/storage/storageserver/storagenode.cpp
@@ -127,7 +127,7 @@ StorageNode::subscribeToConfigs()
 }
 
 void
-StorageNode::initialize()
+StorageNode::initialize(const NodeStateReporter & nodeStateReporter)
 {
     // Avoid racing with concurrent reconfigurations before we've set up the entire
     // node component stack.
@@ -164,8 +164,8 @@ StorageNode::initialize()
     // dead lock detector too, but not before open()
     _stateManager = std::make_unique<StateManager>(
             _context.getComponentRegister(),
-            _context.getComponentRegister().getMetricManager(),
             std::move(_hostInfo),
+            nodeStateReporter,
             _singleThreadedDebugMode);
     _context.getComponentRegister().setNodeStateUpdater(*_stateManager);
 
@@ -176,11 +176,11 @@ StorageNode::initialize()
 
     initializeNodeSpecific();
 
-    _statusMetrics = std::make_unique<StatusMetricConsumer>(
-            _context.getComponentRegister(), _context.getComponentRegister().getMetricManager());
-    _stateReporter = std::make_unique<StateReporter>(
-            _context.getComponentRegister(), _context.getComponentRegister().getMetricManager(),
-            _generationFetcher);
+    _statusMetrics = std::make_unique<StatusMetricConsumer>(_context.getComponentRegister(),
+                                                            _context.getComponentRegister().getMetricManager());
+    _stateReporter = std::make_unique<StateReporter>(_context.getComponentRegister(),
+                                                     _context.getComponentRegister().getMetricManager(),
+                                                     _generationFetcher);
 
     // Start deadlock detector
     _deadLockDetector = std::make_unique<DeadLockDetector>(_context.getComponentRegister());
diff --git a/storage/src/vespa/storage/storageserver/storagenode.h b/storage/src/vespa/storage/storageserver/storagenode.h
index 344181adad5..5a521d7c66c 100644
--- a/storage/src/vespa/storage/storageserver/storagenode.h
+++ b/storage/src/vespa/storage/storageserver/storagenode.h
@@ -43,6 +43,7 @@ class StatusMetricConsumer;
 class StatusWebServer;
 class StorageComponent;
 class StorageLink;
+class NodeStateReporter;
 struct DeadLockDetector;
 struct StorageMetricSet;
 struct StorageNodeContext;
@@ -172,7 +173,7 @@ protected:
      */
     std::unique_ptr<StateManager> releaseStateManager();
 
-    void initialize();
+    void initialize(const NodeStateReporter & reporter);
     virtual void subscribeToConfigs();
     virtual void initializeNodeSpecific() = 0;
     virtual void perform_post_chain_creation_init_steps() = 0;
diff --git a/vespalib/src/vespa/vespalib/util/jsonstream.cpp b/vespalib/src/vespa/vespalib/util/jsonstream.cpp
index e8814ee95f6..86bb8a1a8d1 100644
--- a/vespalib/src/vespa/vespalib/util/jsonstream.cpp
+++ b/vespalib/src/vespa/vespalib/util/jsonstream.cpp
@@ -39,7 +39,7 @@ JsonStream::JsonStream(asciistream& as, bool createIndents)
     push({State::ROOT});
 }
 
-JsonStream::~JsonStream() {}
+JsonStream::~JsonStream() = default;
 
 JsonStream&
 JsonStream::operator<<(stringref value)