SILKIT-1379: Experimental internal metrics dashboard

SilKit/source/core/vasio/VAsioRegistry.cpp

@@ -333,7 +333,7 @@ void VAsioRegistry::SetupMetrics()
 
     if (_vasioConfig->experimental.metrics.collectFromRemote)
     {
-        auto metricsReceiver = std::make_unique<VSilKit::MetricsReceiver>(nullptr, processor);
+        auto metricsReceiver = std::make_unique<VSilKit::MetricsReceiver>(nullptr, *this);
 
         SilKit::Core::SupplementalData supplementalData;
         supplementalData[SilKit::Core::Discovery::controllerType] =
@@ -416,6 +416,9 @@ void VAsioRegistry::OnMetricsUpdate(const std::string& participantName, const VS
         Log::Info(GetLogger(), "Metric Update: {} {} {} {} ({})", data.name, data.kind, data.value, data.timestamp,
                   participantName);
     }
+
+    dynamic_cast<VSilKit::MetricsProcessor&>(*_metricsProcessor).OnMetricsUpdate(participantName, metricsUpdate);
+    _registryEventListener->OnMetricsUpdate("", participantName, metricsUpdate);
 }
 
 

SilKit/source/core/vasio/VAsioRegistry.hpp

@@ -60,6 +60,8 @@ struct IRegistryEventListener
     virtual void OnServiceDiscoveryEvent(
         const std::string& simulationName, const std::string& participantName,
         const SilKit::Core::Discovery::ServiceDiscoveryEvent& serviceDiscoveryEvent) = 0;
+    virtual void OnMetricsUpdate(const std::string& simulationName, const std::string& origin,
+                                 const VSilKit::MetricsUpdate& metricsUpdate) = 0;
 };
 
 class VAsioRegistry

SilKit/source/dashboard/Client/DashboardSystemApiClient.hpp

@@ -160,6 +160,10 @@ class DashboardSystemApiClient : public oatpp::web::client::ApiClient
     // bulk update of a simulation
     API_CALL("POST", "system-service/v1.1/simulations/{simulationId}", updateSimulation, PATH(UInt64, simulationId),
              BODY_DTO(Object<BulkSimulationDto>, simulation))
+
+    // bulk update of simulation metrics
+    API_CALL("POST", "system-service/v1.1/simulations/{simulationId}/metrics", updateSimulationMetrics,
+             PATH(UInt64, simulationId), BODY_DTO(oatpp::Vector<Object<MetricDataDto>>, simulation))
 };
 
 } // namespace Dashboard

SilKit/source/dashboard/Client/DashboardSystemServiceClient.cpp

@@ -215,6 +215,14 @@ void DashboardSystemServiceClient::SetSimulationEnd(oatpp::UInt64 simulationId,
     Log(response, "setting simulation end");
 }
 
+void DashboardSystemServiceClient::UpdateSimulationMetrics(oatpp::UInt64 simulationId,
+                                                           oatpp::Object<MetricsUpdateDto> metrics)
+{
+    auto response = _dashboardSystemApiClient->updateSimulationMetrics(simulationId, metrics->metrics);
+    Log(response, "updating simulation metrics");
+}
+
+
 void DashboardSystemServiceClient::Log(std::shared_ptr<oatpp::web::client::RequestExecutor::Response> response,
                                        const std::string& message)
 {

SilKit/source/dashboard/Client/DashboardSystemServiceClient.hpp

@@ -108,6 +108,8 @@ class DashboardSystemServiceClient : public IDashboardSystemServiceClient
 
     void SetSimulationEnd(oatpp::UInt64 simulationId, oatpp::Object<SimulationEndDto> simulation) override;
 
+    void UpdateSimulationMetrics(oatpp::UInt64 simulationId, oatpp::Object<MetricsUpdateDto> metrics) override;
+
 private:
     void Log(std::shared_ptr<oatpp::web::client::RequestExecutor::Response> response, const std::string& message);
 

SilKit/source/dashboard/Client/IDashboardSystemServiceClient.hpp

@@ -108,6 +108,8 @@ class IDashboardSystemServiceClient
                                                  oatpp::Object<SystemStatusDto> systemStatus) = 0;
 
     virtual void SetSimulationEnd(oatpp::UInt64 simulationId, oatpp::Object<SimulationEndDto> simulation) = 0;
+
+    virtual void UpdateSimulationMetrics(oatpp::UInt64 simulationId, oatpp::Object<MetricsUpdateDto> metrics) = 0;
 };
 
 } // namespace Dashboard

SilKit/source/dashboard/DashboardInstance.cpp

@@ -260,6 +260,13 @@ struct EventQueueWorkerThread
                 }
                 break;
 
+                case SilKitEventType::OnMetricUpdate:
+                {
+                    const auto &data = event.GetMetricsUpdate();
+                    eventHandler->OnMetricsUpdate(simulationId, data.first, data.second);
+                }
+                break;
+
                 default:
                 {
                     Log::Error(logger, "Dashboard: unexpected SilKitEventType");
@@ -551,5 +558,16 @@ void DashboardInstance::OnServiceDiscoveryEvent(
         SilKitEvent{simulationName, ServiceData{serviceDiscoveryEvent.type, serviceDiscoveryEvent.serviceDescriptor}});
 }
 
+void DashboardInstance::OnMetricsUpdate(const std::string &simulationName, const std::string &origin,
+                                        const VSilKit::MetricsUpdate &metricsUpdate)
+{
+    Log::Trace(_logger, "DashboardInstance::OnMetricsUpdate: simulationName={} origin={} metricsUpdate={}",
+               simulationName, origin, metricsUpdate);
+
+    std::pair<std::string, VSilKit::MetricsUpdate> data{origin, metricsUpdate};
+
+    _silKitEventQueue->Enqueue(SilKitEvent{simulationName, std::move(data)});
+}
+
 
 } // namespace VSilKit

SilKit/source/dashboard/DashboardInstance.hpp

@@ -71,6 +71,7 @@ class DashboardInstance final
         SilKit::Services::Orchestration::ParticipantStatus const& participantStatus) override;
     void OnServiceDiscoveryEvent(std::string const& simulationName, std::string const& participantName,
                                  SilKit::Core::Discovery::ServiceDiscoveryEvent const& serviceDiscoveryEvent) override;
+    void OnMetricsUpdate(const std::string &simulationName, const std::string &origin, const VSilKit::MetricsUpdate &metricsUpdate) override;
 
 private:
     /// Assigned in OnLoggerCreated

SilKit/source/dashboard/Dto/BulkUpdateDto.hpp

@@ -127,6 +127,31 @@ class BulkSimulationDto : public oatpp::DTO
     }
 };
 
+class MetricDataDto : public oatpp::DTO
+{
+    DTO_INIT(MetricDataDto, DTO)
+
+    DTO_FIELD(Int64, ts);
+    DTO_FIELD(String, pn);
+    DTO_FIELD(String, mn);
+    DTO_FIELD(String, mk);
+    DTO_FIELD(String, mv);
+};
+
+class MetricsUpdateDto : public oatpp::DTO
+{
+    DTO_INIT(MetricsUpdateDto, DTO)
+
+    DTO_FIELD(Vector<Object<MetricDataDto>>, metrics);
+
+    static auto CreateEmpty() -> Wrapper
+    {
+        auto dto = createShared();
+        dto->metrics = Vector<Object<MetricDataDto>>::createShared();
+        return dto;
+    }
+};
+
 } // namespace Dashboard
 } // namespace SilKit
 

SilKit/source/dashboard/Service/ISilKitEventHandler.hpp

@@ -22,6 +22,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
 #pragma once
 
 #include "DashboardBulkUpdate.hpp"
+#include "MetricsDatatypes.hpp"
 
 #include <string>
 
@@ -45,6 +46,9 @@ class ISilKitEventHandler
                                          const Core::ServiceDescriptor& serviceDescriptor) = 0;
 
     virtual void OnBulkUpdate(uint64_t simulationId, const DashboardBulkUpdate& bulkUpdate) = 0;
+
+    virtual void OnMetricsUpdate(uint64_t simulationId, const std::string &origin,
+                                 const VSilKit::MetricsUpdate& metricsUpdate) = 0;
 };
 
 } // namespace Dashboard

SilKit/source/dashboard/Service/ISilKitToOatppMapper.hpp

@@ -40,6 +40,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
 #include "BulkUpdateDto.hpp"
 
 #include "DashboardBulkUpdate.hpp"
+#include "MetricsDatatypes.hpp"
 
 
 namespace SilKit {
@@ -73,6 +74,8 @@ class ISilKitToOatppMapper
     virtual auto CreateBulkServiceInternalDto(const ServiceDescriptor& serviceDescriptor)
         -> Object<BulkServiceInternalDto> = 0;
     virtual auto CreateBulkSimulationDto(const DashboardBulkUpdate& bulkUpdate) -> Object<BulkSimulationDto> = 0;
+    virtual auto CreateMetricsUpdateDto(const std::string origin,
+                                        const VSilKit::MetricsUpdate& metricsUpdate) -> Object<MetricsUpdateDto> = 0;
 };
 } // namespace Dashboard
 } // namespace SilKit

SilKit/source/dashboard/Service/SilKitEvent.hpp

@@ -23,6 +23,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
 
 #include "silkit/services/orchestration/OrchestrationDatatypes.hpp"
 #include "ServiceDatatypes.hpp"
+#include "MetricsDatatypes.hpp"
 
 namespace SilKit {
 namespace Dashboard {
@@ -51,7 +52,8 @@ enum class SilKitEventType
     OnSystemStateChanged,
     OnParticipantStatusChanged,
     OnServiceDiscoveryEvent,
-    OnSimulationEnd
+    OnSimulationEnd,
+    OnMetricUpdate,
 };
 
 template <SilKitEventType id>
@@ -69,12 +71,15 @@ struct SilKitEventTrait;
     { \
     };
 
+using MetricsUpdatePair = std::pair<std::string, VSilKit::MetricsUpdate>;
+
 SILKIT_EVENT(SimulationStart, OnSimulationStart)
 SILKIT_EVENT(Services::Orchestration::ParticipantConnectionInformation, OnParticipantConnected)
 SILKIT_EVENT(Services::Orchestration::SystemState, OnSystemStateChanged)
 SILKIT_EVENT(Services::Orchestration::ParticipantStatus, OnParticipantStatusChanged)
 SILKIT_EVENT(ServiceData, OnServiceDiscoveryEvent)
 SILKIT_EVENT(SimulationEnd, OnSimulationEnd)
+SILKIT_EVENT(MetricsUpdatePair, OnMetricUpdate)
 
 #undef SILKIT_EVENT
 
@@ -183,6 +188,11 @@ class SilKitEvent
         return Get<SimulationEnd>();
     }
 
+    auto GetMetricsUpdate() const -> const std::pair<std::string, VSilKit::MetricsUpdate>&
+    {
+        return Get<std::pair<std::string, VSilKit::MetricsUpdate>>();
+    }
+
 private:
     template <typename T>
     constexpr SilKitEventType getTypeId() const

SilKit/source/dashboard/Service/SilKitEventHandler.cpp

@@ -111,6 +111,14 @@ void SilKitEventHandler::OnBulkUpdate(uint64_t simulationId, const DashboardBulk
                                                     _silKitToOatppMapper->CreateBulkSimulationDto(bulkUpdate));
 }
 
+void SilKitEventHandler::OnMetricsUpdate(uint64_t simulationId, const std::string& origin,
+                                         const VSilKit::MetricsUpdate& metricsUpdate)
+{
+    _dashboardSystemServiceClient->UpdateSimulationMetrics(
+        simulationId, _silKitToOatppMapper->CreateMetricsUpdateDto(origin, metricsUpdate));
+}
+
+
 void SilKitEventHandler::OnControllerCreated(uint64_t simulationId, const Core::ServiceDescriptor& serviceDescriptor)
 {
     Services::Logging::Debug(_logger, "Dashboard: adding service for simulation {} {}", simulationId,

SilKit/source/dashboard/Service/SilKitEventHandler.hpp

@@ -54,6 +54,9 @@ class SilKitEventHandler : public ISilKitEventHandler
                                  const Core::ServiceDescriptor& serviceDescriptor) override;
     void OnBulkUpdate(uint64_t simulationId, const DashboardBulkUpdate& bulkUpdate) override;
 
+    void OnMetricsUpdate(uint64_t simulationId, const std::string& origin,
+                         const VSilKit::MetricsUpdate& metricsUpdate) override;
+
 private: //methods
     void OnControllerCreated(uint64_t simulationId, const Core::ServiceDescriptor& serviceDescriptor);
     void OnLinkCreated(uint64_t simulationId, const Core::ServiceDescriptor& serviceDescriptor);

SilKit/source/dashboard/Service/SilKitToOatppMapper.cpp

@@ -462,6 +462,39 @@ auto SilKitToOatppMapper::CreateBulkSimulationDto(const DashboardBulkUpdate& bul
     return bulkSimulationDto;
 }
 
+auto SilKitToOatppMapper::CreateMetricsUpdateDto(const std::string origin, const VSilKit::MetricsUpdate& metricsUpdate)
+    -> Object<MetricsUpdateDto>
+{
+    auto dto = MetricsUpdateDto::CreateEmpty();
+    for (const auto& metricData : metricsUpdate.metrics)
+    {
+        auto dataDto = MetricDataDto::createShared();
+        dataDto->ts = metricData.timestamp;
+        dataDto->mn = metricData.name;
+        switch (metricData.kind)
+        {
+        case VSilKit::MetricKind::COUNTER:
+            dataDto->mk = "COUNTER";
+            break;
+        case VSilKit::MetricKind::STATISTIC:
+            dataDto->mk = "STATISTIC";
+            break;
+        case VSilKit::MetricKind::STRING_LIST:
+            dataDto->mk = "STRING_LIST";
+            break;
+        default:
+            dataDto->mk = "UNKNOWN";
+            break;
+        }
+        dataDto->mv = metricData.value;
+        dataDto->pn = origin;
+
+        dto->metrics->emplace_back(std::move(dataDto));
+    }
+    return dto;
+}
+
+
 // SilKitToOatppMapper Private Methods
 
 void SilKitToOatppMapper::ProcessServiceDiscovery(BulkParticipantDto& dto, const ServiceDescriptor& serviceDescriptor)

SilKit/source/dashboard/Service/SilKitToOatppMapper.hpp

@@ -52,6 +52,8 @@ class SilKitToOatppMapper : public ISilKitToOatppMapper
     auto CreateBulkServiceInternalDto(const ServiceDescriptor& serviceDescriptor)
         -> Object<BulkServiceInternalDto> override;
     auto CreateBulkSimulationDto(const DashboardBulkUpdate& bulkUpdate) -> Object<BulkSimulationDto> override;
+    auto CreateMetricsUpdateDto(const std::string origin,
+                                const VSilKit::MetricsUpdate& metricsUpdate) -> Object<MetricsUpdateDto> override;
 
 private:
     void ProcessServiceDiscovery(BulkParticipantDto& dto, const ServiceDescriptor& serviceDescriptor);