hmon: type-safe tags

examples/cpp_supervised_app/main.cpp

@@ -118,14 +118,14 @@ int main(int argc, char** argv)
 
     auto builder_mon =
         deadline::DeadlineMonitorBuilder()
-            .add_deadline(IdentTag("deadline_1"),
+            .add_deadline(DeadlineTag("deadline_1"),
                           TimeRange(std::chrono::milliseconds(50), std::chrono::milliseconds(150)))
-            .add_deadline(IdentTag("deadline_2"),
+            .add_deadline(DeadlineTag("deadline_2"),
                           TimeRange(std::chrono::milliseconds(2),
                                     std::chrono::milliseconds(20)));  // Not used, only shows
                                                                       // that multiple deadlines can be added
 
-    IdentTag ident("monitor");
+    MonitorTag ident("monitor");
 
     {
         auto hm = HealthMonitorBuilder()
@@ -146,7 +146,7 @@ int main(int argc, char** argv)
 
         auto deadline_mon = std::move(*deadline_monitor_res);
 
-        auto deadline_res = deadline_mon.get_deadline(IdentTag("deadline_1"));
+        auto deadline_res = deadline_mon.get_deadline(DeadlineTag("deadline_1"));
         while (!exitRequested)
         {
             if (stopReportingCheckpoints.load())

examples/rust_supervised_app/src/main.rs

@@ -57,21 +57,21 @@ fn set_process_name() {
 fn main_logic(args: &Args, stop: Arc<AtomicBool>) -> Result<(), Box<dyn std::error::Error>> {
     let mut builder = deadline::DeadlineMonitorBuilder::new();
     builder = builder.add_deadline(
-        &IdentTag::from("deadline1"),
+        DeadlineTag::from("deadline1"),
         TimeRange::new(
             std::time::Duration::from_millis(50),
             std::time::Duration::from_millis(150),
         ),
     );
 
     let mut hm = HealthMonitorBuilder::new()
-        .add_deadline_monitor(&IdentTag::from("mon1"), builder)
+        .add_deadline_monitor(MonitorTag::from("mon1"), builder)
         .with_supervisor_api_cycle(std::time::Duration::from_millis(50))
         .with_internal_processing_cycle(std::time::Duration::from_millis(50))
         .build();
 
     let mon = hm
-        .get_deadline_monitor(&IdentTag::from("mon1"))
+        .get_deadline_monitor(MonitorTag::from("mon1"))
         .expect("Failed to get monitor");
 
     hm.start();
@@ -83,7 +83,7 @@ fn main_logic(args: &Args, stop: Arc<AtomicBool>) -> Result<(), Box<dyn std::err
 
     while !stop.load(Ordering::Relaxed) {
         let mut deadline = mon
-            .get_deadline(&IdentTag::from("deadline1"))
+            .get_deadline(DeadlineTag::from("deadline1"))
             .expect("Failed to get deadline");
 
         let _res = deadline.start();

src/health_monitoring_lib/BUILD

@@ -33,6 +33,7 @@ CC_SOURCES = [
 
 CC_HDRS = [
     "cpp/include/score/hm/common.h",
+    "cpp/include/score/hm/tag.h",
     "cpp/include/score/hm/deadline/deadline_monitor.h",
     "cpp/include/score/hm/health_monitor.h",
 ]

src/health_monitoring_lib/cpp/deadline_monitor.cpp

@@ -24,11 +24,11 @@ using namespace score::hm::deadline;
 FFICode deadline_monitor_builder_create(FFIHandle* deadline_monitor_builder_handle_out);
 FFICode deadline_monitor_builder_destroy(FFIHandle deadline_monitor_builder_handle);
 FFICode deadline_monitor_builder_add_deadline(FFIHandle deadline_monitor_builder_handle,
-                                              const IdentTag* deadline_tag,
+                                              const DeadlineTag* deadline_tag,
                                               uint32_t min_ms,
                                               uint32_t max_ms);
 FFICode deadline_monitor_get_deadline(FFIHandle deadline_monitor_handle,
-                                      const IdentTag* deadline_tag,
+                                      const DeadlineTag* deadline_tag,
                                       FFIHandle* deadline_handle_out);
 FFICode deadline_monitor_destroy(FFIHandle deadline_monitor_handle);
 FFICode deadline_destroy(FFIHandle deadline_handle);
@@ -55,26 +55,26 @@ DeadlineMonitorBuilder::DeadlineMonitorBuilder()
 {
 }
 
-DeadlineMonitorBuilder DeadlineMonitorBuilder::add_deadline(const IdentTag& tag, const TimeRange& range) &&
+DeadlineMonitorBuilder DeadlineMonitorBuilder::add_deadline(const DeadlineTag& deadline_tag, const TimeRange& range) &&
 {
     auto handle = monitor_builder_handler_.as_rust_handle();
     SCORE_LANGUAGE_FUTURECPP_PRECONDITION(handle.has_value());
 
-    auto result{deadline_monitor_builder_add_deadline(handle.value(), &tag, range.min_ms(), range.max_ms())};
+    auto result{deadline_monitor_builder_add_deadline(handle.value(), &deadline_tag, range.min_ms(), range.max_ms())};
     SCORE_LANGUAGE_FUTURECPP_ASSERT(result == kSuccess);
 
     return std::move(*this);
 }
 
 DeadlineMonitor::DeadlineMonitor(FFIHandle handle) : monitor_handle_(handle, &deadline_monitor_destroy) {}
 
-score::cpp::expected<Deadline, score::hm::Error> DeadlineMonitor::get_deadline(const IdentTag& tag)
+score::cpp::expected<Deadline, score::hm::Error> DeadlineMonitor::get_deadline(const DeadlineTag& deadline_tag)
 {
     auto handle = monitor_handle_.as_rust_handle();
     SCORE_LANGUAGE_FUTURECPP_PRECONDITION(handle.has_value());
 
     FFIHandle ret = nullptr;
-    auto result = deadline_monitor_get_deadline(handle.value(), &tag, &ret);
+    auto result = deadline_monitor_get_deadline(handle.value(), &deadline_tag, &ret);
     if (result != kSuccess)
     {
         return score::cpp::unexpected(static_cast<Error>(result));

src/health_monitoring_lib/cpp/health_monitor.cpp

@@ -28,10 +28,10 @@ FFICode health_monitor_builder_build(FFIHandle health_monitor_builder_handle,
                                      uint32_t internal_cycle_ms,
                                      FFIHandle* health_monitor_handle_out);
 FFICode health_monitor_builder_add_deadline_monitor(FFIHandle health_monitor_builder_handle,
-                                                    const IdentTag* monitor_tag,
+                                                    const MonitorTag* monitor_tag,
                                                     FFIHandle deadline_monitor_builder_handle);
 FFICode health_monitor_get_deadline_monitor(FFIHandle health_monitor_handle,
-                                            const IdentTag* monitor_tag,
+                                            const MonitorTag* monitor_tag,
                                             FFIHandle* deadline_monitor_handle_out);
 FFICode health_monitor_start(FFIHandle health_monitor_handle);
 FFICode health_monitor_destroy(FFIHandle health_monitor_handle);
@@ -57,15 +57,15 @@ HealthMonitorBuilder::HealthMonitorBuilder()
 {
 }
 
-HealthMonitorBuilder HealthMonitorBuilder::add_deadline_monitor(const IdentTag& tag,
+HealthMonitorBuilder HealthMonitorBuilder::add_deadline_monitor(const MonitorTag& monitor_tag,
                                                                 DeadlineMonitorBuilder&& monitor) &&
 {
     auto monitor_handle = monitor.drop_by_rust();
     SCORE_LANGUAGE_FUTURECPP_PRECONDITION(monitor_handle.has_value());
     SCORE_LANGUAGE_FUTURECPP_PRECONDITION(health_monitor_builder_handle_.as_rust_handle().has_value());
 
     auto result{health_monitor_builder_add_deadline_monitor(
-        health_monitor_builder_handle_.as_rust_handle().value(), &tag, monitor_handle.value())};
+        health_monitor_builder_handle_.as_rust_handle().value(), &monitor_tag, monitor_handle.value())};
     SCORE_LANGUAGE_FUTURECPP_ASSERT(result == kSuccess);
 
     return std::move(*this);
@@ -110,10 +110,10 @@ HealthMonitor::HealthMonitor(HealthMonitor&& other)
     other.health_monitor_ = nullptr;
 }
 
-score::cpp::expected<DeadlineMonitor, Error> HealthMonitor::get_deadline_monitor(const IdentTag& tag)
+score::cpp::expected<DeadlineMonitor, Error> HealthMonitor::get_deadline_monitor(const MonitorTag& monitor_tag)
 {
     FFIHandle handle{nullptr};
-    auto result{health_monitor_get_deadline_monitor(health_monitor_, &tag, &handle)};
+    auto result{health_monitor_get_deadline_monitor(health_monitor_, &monitor_tag, &handle)};
     if (result != kSuccess)
     {
         return score::cpp::unexpected(static_cast<Error>(result));

src/health_monitoring_lib/cpp/include/score/hm/common.h

@@ -15,7 +15,6 @@
 
 #include <cassert>
 #include <chrono>
-#include <cstdint>
 #include <optional>
 
 namespace score::hm
@@ -88,24 +87,6 @@ enum class Error : internal::FFICode
     Failed
 };
 
-///
-/// Identifier tag used to uniquely identify entities within the health monitoring system.
-///
-class IdentTag
-{
-  public:
-    /// Create a new IdentTag from a C-style string.
-    template <size_t N>
-    explicit IdentTag(const char (&tag)[N]) : tag_(tag), len_(N - 1)
-    {
-    }
-
-  private:
-    /// SAFETY: This has to be FFI compatible with the Rust side representation.
-    const char* const tag_;
-    size_t len_;
-};
-
 ///
 /// Time range representation with minimum and maximum durations in milliseconds.
 ///

src/health_monitoring_lib/cpp/include/score/hm/deadline/deadline_monitor.h

@@ -15,6 +15,7 @@
 
 #include <score/expected.hpp>
 #include <score/hm/common.h>
+#include <score/hm/tag.h>
 #include <functional>
 #include <optional>
 
@@ -47,7 +48,7 @@ class DeadlineMonitorBuilder final : public internal::RustDroppable<DeadlineMoni
     DeadlineMonitorBuilder& operator=(DeadlineMonitorBuilder&&) = delete;
 
     /// Adds a deadline with the given tag and duration range to the monitor.
-    DeadlineMonitorBuilder add_deadline(const IdentTag& tag, const TimeRange& range) &&;
+    DeadlineMonitorBuilder add_deadline(const DeadlineTag& deadline_tag, const TimeRange& range) &&;
 
   protected:
     std::optional<internal::FFIHandle> __drop_by_rust_impl()
@@ -75,7 +76,7 @@ class DeadlineMonitor final
     DeadlineMonitor(DeadlineMonitor&& other) noexcept = default;
     DeadlineMonitor& operator=(DeadlineMonitor&& other) noexcept = default;
 
-    ::score::cpp::expected<Deadline, score::hm::Error> get_deadline(const IdentTag& tag);
+    ::score::cpp::expected<Deadline, score::hm::Error> get_deadline(const DeadlineTag& deadline_tag);
 
   private:
     explicit DeadlineMonitor(internal::FFIHandle handle);

src/health_monitoring_lib/cpp/include/score/hm/health_monitor.h

@@ -15,6 +15,7 @@
 
 #include <score/hm/common.h>
 #include <score/hm/deadline/deadline_monitor.h>
+#include <score/hm/tag.h>
 
 namespace score::hm
 {
@@ -38,7 +39,8 @@ class HealthMonitorBuilder final
     HealthMonitorBuilder& operator=(HealthMonitorBuilder&&) = delete;
 
     /// Adds a deadline monitor to the builder to construct DeadlineMonitor instances during HealthMonitor build.
-    HealthMonitorBuilder add_deadline_monitor(const IdentTag& tag, deadline::DeadlineMonitorBuilder&& monitor) &&;
+    HealthMonitorBuilder add_deadline_monitor(const MonitorTag& monitor_tag,
+                                              deadline::DeadlineMonitorBuilder&& monitor) &&;
 
     /// Sets the cycle duration for supervisor API notifications.
     /// This duration determines how often the health monitor notifies the supervisor that the system is alive.
@@ -69,7 +71,7 @@ class HealthMonitor final
 
     ~HealthMonitor();
 
-    score::cpp::expected<deadline::DeadlineMonitor, Error> get_deadline_monitor(const IdentTag& tag);
+    score::cpp::expected<deadline::DeadlineMonitor, Error> get_deadline_monitor(const MonitorTag& monitor_tag);
 
     void start();
 

src/health_monitoring_lib/cpp/include/score/hm/tag.h

@@ -0,0 +1,54 @@
+/********************************************************************************
+ * Copyright (c) 2026 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Apache License Version 2.0 which is available at
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ ********************************************************************************/
+
+#ifndef SCORE_HM_TAG_H
+#define SCORE_HM_TAG_H
+
+#include <cstddef>
+
+namespace score::hm
+{
+
+/// Common string-based tag.
+class Tag
+{
+  public:
+    /// Create a new tag from a C-style string.
+    template <size_t N>
+    explicit Tag(const char (&tag)[N]) : data_(tag), length_(N - 1)
+    {
+    }
+
+  private:
+    /// SAFETY: This has to be FFI compatible with the Rust side representation.
+    const char* const data_;
+    size_t length_;
+};
+
+/// Monitor tag.
+class MonitorTag : public Tag
+{
+  public:
+    using Tag::Tag;
+};
+
+/// Deadline tag.
+class DeadlineTag : public Tag
+{
+  public:
+    using Tag::Tag;
+};
+
+}  // namespace score::hm
+
+#endif  // SCORE_HM_TAG_H

src/health_monitoring_lib/cpp/tests/health_monitor_test.cpp

@@ -12,6 +12,7 @@
  ********************************************************************************/
 #include "score/hm/health_monitor.h"
 #include "score/hm/common.h"
+#include "score/hm/tag.h"
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
@@ -24,34 +25,37 @@ class HealthMonitorTest : public ::testing::Test
 // For first review round, only single test case to show up API
 TEST_F(HealthMonitorTest, TestName)
 {
-    auto builder_mon = deadline::DeadlineMonitorBuilder()
-                           .add_deadline(IdentTag("deadline_1"),
-                                         TimeRange(std::chrono::milliseconds(100), std::chrono::milliseconds(200)))
-                           .add_deadline(IdentTag("deadline_2"),
-                                         TimeRange(std::chrono::milliseconds(100), std::chrono::milliseconds(200)));
-
-    IdentTag ident("monitor");
+    // Setup deadline monitor construction.
+    const MonitorTag deadline_monitor_tag{"deadline_monitor"};
+    auto deadline_monitor_builder =
+        deadline::DeadlineMonitorBuilder()
+            .add_deadline(DeadlineTag("deadline_1"),
+                          TimeRange(std::chrono::milliseconds(100), std::chrono::milliseconds(200)))
+            .add_deadline(DeadlineTag("deadline_2"),
+                          TimeRange(std::chrono::milliseconds(100), std::chrono::milliseconds(200)));
 
     auto hm = HealthMonitorBuilder()
-                  .add_deadline_monitor(ident, std::move(builder_mon))
+                  .add_deadline_monitor(deadline_monitor_tag, std::move(deadline_monitor_builder))
                   .with_internal_processing_cycle(std::chrono::milliseconds(50))
                   .with_supervisor_api_cycle(std::chrono::milliseconds(50))
                   .build();
 
-    auto deadline_monitor_res = hm.get_deadline_monitor(ident);
+    // Obtain deadline monitor from HMON.
+    auto deadline_monitor_res = hm.get_deadline_monitor(deadline_monitor_tag);
     EXPECT_TRUE(deadline_monitor_res.has_value());
 
     {
-        // Try again to get the same monitor
-        auto deadline_monitor_res = hm.get_deadline_monitor(ident);
+        // Try again to get the same monitor.
+        auto deadline_monitor_res = hm.get_deadline_monitor(deadline_monitor_tag);
         EXPECT_FALSE(deadline_monitor_res.has_value());
     }
 
     auto deadline_mon = std::move(*deadline_monitor_res);
 
+    // Start HMON.
     hm.start();
 
-    auto deadline_res = deadline_mon.get_deadline(IdentTag("deadline_1"));
+    auto deadline_res = deadline_mon.get_deadline(DeadlineTag("deadline_1"));
 
     {
         auto deadline_guard = deadline_res.value().start().value();