Introduce tag numbering (#112)

* Introduce tag numbering

* Adapt docs

* Adapt metric tests

* Add freely global tags

Author: awegrzyn

README.md

@@ -91,7 +91,7 @@ A metric consist of 5 parameters: name, value, timestamp, verbosity and tags.
 | verbosity      | DEBUG / INFO / PROD                           | no       | INFO           |
 | tags           | vector<unsigned int>                          | no       | -              |
 
-A metric can be constructed by providing required parameters:
+A metric can be constructed by providing required parameters (value and name):
 ```cpp
 Metric{10, "name"}
 ```
@@ -108,7 +108,7 @@ Metrics need to match backends verbosity in order to be sent, eg. backend with `
 
 #### Tags
 Each metric can be tagged with any number of [predefined tags](include/Monitoring/Tags.h).
-In order to do so use `addTags(std::initializer_list<unsigned int>&& tags)` method.
+In order to do so use `addTag(tags::Key, tags::Value)` or `addTag(tags::Key, unsigned short)` methods. The latter method allows assigning numeric value to a tag.
 
 See the example: [examples/2-TaggedMetrics.cxx](examples/2-TaggedMetrics.cxx).
 
@@ -165,7 +165,7 @@ Glabal tags are tags that are added to each metric. The following tags are set t
 - `hostname`
 - `name` - process name
 
-You can add your own global tag by calling `addGlobalTag(std::string name, std::string value)`.
+You can add your own global tag by calling `addGlobalTag(std::string_view key, std::string_view value)` or `addGlobalTag(tags::Key, tags::Value)`.
 
 ### Process monitoring
 ```cpp

examples/2-TaggedMetrics.cxx

@@ -14,12 +14,13 @@ int main() {
   auto monitoring = MonitoringFactory::Get("stdout://");
 
   /// Add global tags
-  monitoring->addGlobalTag("example", "yes");
-  monitoring->addGlobalTag(tags::Subsystem::DPL);
+  monitoring->addGlobalTag("name", "test");
+  monitoring->addGlobalTag(tags::Key::Subsystem, tags::Value::DPL);
 
   // now send an application specific metric with additional tags
   // 10 is the value
   // myMetric is the name of the metric
   // then add predefined tag
-  monitoring->send(Metric{10, "myMetric"}.addTags({tags::Detector::TPC}));
+  monitoring->send(Metric{10, "myMetric"}.addTag(tags::Key::Detector, tags::Value::TPC));
+  monitoring->send(Metric{10, "myMetric"}.addTag(tags::Key::CRU, 123));
 }

examples/4-RateDerivedMetric.cxx

@@ -14,7 +14,7 @@ int main() {
 
   // now send at least two metrics to see the result
   for (int i = 0; i < 101; i += 10) {
-    monitoring->send(Metric{i, "myMetric"}.addTags({tags::Subsystem::Readout}), DerivedMetricMode::RATE);
+    monitoring->send(Metric{i, "myMetric"}.addTag(tags::Key::Subsystem, tags::Value::Readout), DerivedMetricMode::RATE);
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
   }
 }

examples/7-InternalBenchamrk.cxx

@@ -17,10 +17,10 @@ void test(std::unique_ptr<Monitoring>& monitoring) {
 }
 
 void testWithTags(std::unique_ptr<Monitoring>& monitoring) {
-  monitoring->addGlobalTag("benchmark", "yes");
+  monitoring->addGlobalTag("name", "benchmark");
   for (int i = 0; i < 100000; i++) {
-    monitoring->send(Metric{10, "myMetricInt"}.addTags({tags::Detector::TPC}));
-    monitoring->send(Metric{10.10, "myMetricFloat"}.addTags({tags::Subsystem::QC}));
+    monitoring->send(Metric{10, "myMetricInt"}.addTag(tags::Key::Detector, tags::Value::TPC));
+    monitoring->send(Metric{10.10, "myMetricFloat"}.addTag(tags::Key::Subsystem, tags::Value::QC));
   }
 }
 

include/Monitoring/Metric.h

@@ -18,10 +18,15 @@ namespace o2
 namespace monitoring
 {
 
+/// Metric and Backedn verbosity
 enum class Verbosity : short { PROD, INFO, DEBUG };
 
+
+/// Metric types
 enum MetricType { INT = 0, STRING = 1, DOUBLE = 2, UINT64_T = 3 };
 
+class DerivedMetrics;
+
 /// \brief Represents a metric including value, type of the value, name, timestamp and tags
 class Metric
 {
@@ -72,12 +77,19 @@ class Metric
 
     /// Tag list getter
     /// \return         tags
-    const std::vector<unsigned int>& getTags() const;
+    const std::vector<std::pair<int, int>>& getTags() const;
+
+    /// Add user defined tags
+    /// \param key      enum tag key
+    /// \param value 	emum tag value
+    /// \return         r-value to "this" - to be able to chain methods
+    Metric&& addTag(tags::Key key, tags::Value value);
 
     /// Add user defined tags
-    /// \param tags      r-value to vector of tags
+    /// \param key      enum tag key
+    /// \param value    numeric value
     /// \return          r-value to "this" - to be able to chain methods
-    Metric&& addTags(std::vector<unsigned int>&& tags);
+    Metric&& addTag(tags::Key key, unsigned short int number);
 
     /// Verbosity getter
     Verbosity getVerbosity();
@@ -92,6 +104,12 @@ class Metric
     /// Default metric verbosity
     static Verbosity DEFAULT_VERBOSITY;
   protected:
+    /// Allow DerivedMetrics access to setTags
+    friend class o2::monitoring::DerivedMetrics;
+
+    /// Set full vector of tags
+    Metric&& setTags(std::vector<std::pair<int, int>>&& tags);
+
     /// Metric value
     boost::variant< int, std::string, double, uint64_t > mValue;
 
@@ -102,7 +120,7 @@ class Metric
     std::chrono::time_point<std::chrono::system_clock> mTimestamp;
 
     /// Metric tags
-    std::vector<unsigned int> mTags;
+    std::vector<std::pair<int, int>> mTags;
 
     /// Metric verbosity
     Verbosity mVerbosity;

include/Monitoring/Monitoring.h

@@ -81,9 +81,10 @@ class Monitoring
     /// \param value 		tag value
     void addGlobalTag(std::string_view name, std::string_view value);
 
-    /// Adds predefined global tag
-    /// \param tag		tag index (use predefined enums form tag:: namespace)
-    void addGlobalTag(const unsigned int tag);
+    /// Adds global tag
+    /// \param name             tag name
+    /// \param value            tag value
+    void addGlobalTag(tags::Key key, tags::Value value);
 
     /// Returns a metric which will be periodically sent to backends
     /// \param name 		metric name

include/Monitoring/Tags.h

@@ -18,37 +18,43 @@ namespace tags
 {
   using namespace std::string_view_literals; 
 
-  // Detector tag indexes
-  static constexpr std::string_view detectorTag = "detector";
-  enum Detector { ACO = 0 , AD, CPV, EMC, FMD, HMP, MCH, MTR, PHS, PMD, ITS, T0, TOF, TPC, TRD, V0};
-
-  // Subsystem tag indexes
-  static constexpr std::string_view subsystemTag = "subsystem";
-  enum Subsystem { QC = 16, Readout, DPL, CRU };
-
-  // Single tag array
-  static constexpr std::array<std::pair<std::string_view, std::string_view>, 20> TAG_ARRAY = {{
-    {detectorTag, "ACO"sv}, // 0
-    {detectorTag, "AD"sv},  // 1
-    {detectorTag, "CPV"sv}, // 2
-    {detectorTag, "EMC"sv}, // 3
-    {detectorTag, "FMD"sv}, // 4
-    {detectorTag, "HMP"sv}, // 5
-    {detectorTag, "MCH"sv}, // 6
-    {detectorTag, "MTR"sv}, // 7
-    {detectorTag, "PHS"sv}, // 8
-    {detectorTag, "PHS"sv}, // 9
-    {detectorTag, "PMD"sv}, // 10
-    {detectorTag, "ITS"sv}, // 11
-    {detectorTag, "TOF"sv}, // 12
-    {detectorTag, "TPC"sv}, // 13
-    {detectorTag, "TRD"sv}, // 14
-    {detectorTag, "V0"sv},  // 15
-    {subsystemTag, "QC"sv},
-    {subsystemTag, "Readout"sv},
-    {subsystemTag, "DLP"sv},
-    {subsystemTag, "CRU"sv}
+  // Tag keys
+  enum class Key : unsigned short int { Hostname, Rolename, Name, Detector, Subsystem, CRU, FLP, EPN };
+
+  /// Tag keys array
+  static constexpr std::array<std::string_view, 8> TAG_KEY = {
+    "hostname"sv, "rolenane"sv, "name"sv, "detector"sv, "subsystem"sv, "CRU"sv, "FLP"sv, "EPN"sv
+  };
+
+  // Tag values
+  enum class Value : unsigned short int { ACO, AD, CPV, EMC, FMD, HMP, MCH, MTR, PHS, PMD, ITS, T0, TOF, TPC, TRD, V0, QC, Readout, DPL, CRU};
+
+  // Tag value array
+  static constexpr std::array<std::string_view, 20> TAG_VALUE = {{
+    "ACO"sv,
+    "AD"sv,  // 1
+    "CPV"sv, // 2
+    "EMC"sv, // 3
+    "FMD"sv, // 4
+    "HMP"sv, // 5
+    "MCH"sv, // 6
+    "MTR"sv, // 7
+    "PHS"sv, // 8
+    "PHS"sv, // 9
+    "PMD"sv, // 10
+    "ITS"sv, // 11
+    "TOF"sv, // 12
+    "TPC"sv, // 13
+    "TRD"sv, // 14
+    "V0"sv,  // 15
+    "QC"sv,
+    "Readout"sv,
+    "DPL"sv,
+    "CRU"sv
   }};
+  static constexpr std::string_view GetValue(const int value) {
+    return value >= 0 ? TAG_VALUE[value] : std::to_string(0 - value);
+  }
 }
 
 } // namespace monitoring

src/Backends/Flume.cxx

@@ -33,8 +33,8 @@ std::string Flume::metricToJson(const Metric& metric)
     header.put<std::string>("name", metric.getName());
     header.put<std::string>("value_value", boost::lexical_cast<std::string>(metric.getValue()));
 
-    for (const auto& tagIndex : metric.getTags()) {
-      header.put<std::string>("tag_" + std::string(tags::TAG_ARRAY[tagIndex].first.data()), tags::TAG_ARRAY[tagIndex].second.data());
+    for (const auto& [key, value] : metric.getTags()) {
+      header.put<std::string>("tag_" + std::string(tags::TAG_KEY[key].data()), tags::GetValue(value).data());
     }
     event.push_back(std::make_pair("headers", header));
     event.put<std::string>("body", "");
@@ -67,8 +67,8 @@ std::string Flume::metricsToJson(std::string measurement, std::vector<Metric>&&
   boost::property_tree::ptree header = globalHeader;
   header.put<std::string>("timestamp", std::to_string(convertTimestamp(metrics.front().getTimestamp())));
   header.put<std::string>("name", measurement);
-  for (const auto& tagIndex : metrics.front().getTags()) {
-    header.put<std::string>("tag_" + std::string(tags::TAG_ARRAY[tagIndex].first.data()), tags::TAG_ARRAY[tagIndex].second.data());
+  for (const auto& [key, value] : metrics.front().getTags()) {
+    header.put<std::string>("tag_" + std::string(tags::TAG_KEY[key].data()), tags::GetValue(value).data());
   }
   for (auto& metric : metrics) {
     header.put<std::string>("value_" + metric.getName(), boost::lexical_cast<std::string>(metric.getValue()));

src/Backends/InfluxDB.cxx

@@ -97,8 +97,8 @@ std::string InfluxDB::toInfluxLineProtocol(const Metric& metric) {
   escape(name);
   convert << name << "," << tagSet;
 
-  for (const auto& tagIndex : metric.getTags()) {
-    convert << "," << tags::TAG_ARRAY[tagIndex].first << "=" << tags::TAG_ARRAY[tagIndex].second;
+  for (const auto& [key, value] : metric.getTags()) {
+    convert << "," << tags::TAG_KEY[key] << "=" << tags::GetValue(value);
   }
 
   std::string value = boost::lexical_cast<std::string>(metric.getValue());

src/Backends/StdOut.cxx

@@ -47,11 +47,11 @@ void StdOut::send(std::vector<Metric>&& metrics) {
 void StdOut::sendMultiple(std::string measurement, std::vector<Metric>&& metrics)
 {
   std::string metricTags{};
-  for (const auto& tagIndex : metrics.front().getTags()) {
+  for (const auto& [key, value] : metrics.front().getTags()) {
     metricTags += ',';
-    metricTags += tags::TAG_ARRAY[tagIndex].first;
+    metricTags += tags::TAG_KEY[key];
     metricTags += "=";
-    metricTags += tags::TAG_ARRAY[tagIndex].second;
+    metricTags += tags::GetValue(value);
   } 
   for (auto& metric : metrics) {
     mStream << "[METRIC] " << measurement << '/' << metric.getName() << ',' << metric.getType() << ' '
@@ -65,8 +65,8 @@ void StdOut::send(const Metric& metric)
   mStream << "[METRIC] " << metric.getName() << ',' << metric.getType() << " " << metric.getValue()
           << ' ' << convertTimestamp(metric.getTimestamp()) << ' ' << tagString;
 
-  for (const auto& tagIndex : metric.getTags()) {
-    mStream << ',' << tags::TAG_ARRAY[tagIndex].first << "=" << tags::TAG_ARRAY[tagIndex].second;
+  for (const auto& [key, value] : metric.getTags()) {
+    mStream << ',' << tags::TAG_KEY[key] << "=" << tags::GetValue(value);
   }
   mStream << '\n';
 }