sync code

core/include/services_sdk/interfaces/i_agent_details.h

@@ -46,6 +46,7 @@ public:
     virtual OrchestrationMode getOrchestrationMode()                  const = 0;
     virtual std::string getAccessToken()                              const = 0;
     virtual void loadAccessToken()                                          = 0;
+    virtual bool isOpenAppsecAgent()                                  const = 0;
 
     // OpenSSL
     virtual void setOpenSSLDir(const std::string &openssl_dir)  = 0;

core/include/services_sdk/interfaces/i_env_details.h

@@ -24,6 +24,7 @@ class I_EnvDetails
 public:
     virtual EnvType getEnvType() = 0;
     virtual std::string getToken() = 0;
+    virtual std::string getNameSpace() = 0;
 
 protected:
     virtual ~I_EnvDetails() {}

core/include/services_sdk/interfaces/messaging/messaging_metadata.h

@@ -215,6 +215,18 @@ public:
         return is_to_fog;
     }
 
+    void
+    setSniHostName(const std::string &_host_name)
+    {
+        sni_host_name = _host_name;
+    }
+
+    Maybe<std::string>
+    getSniHostName() const
+    {
+        return sni_host_name;
+    }
+
     template <class Archive>
     void
     serialize(Archive &ar)
@@ -237,6 +249,7 @@ public:
 
 private:
     std::string host_name = "";
+    Maybe<std::string> sni_host_name = genError("SNI host name not set");
     std::string ca_path = "";
     std::string client_cert_path = "";
     std::string client_key_path = "";

core/include/services_sdk/interfaces/mock/mock_agent_details.h

@@ -28,6 +28,7 @@ public:
     MOCK_CONST_METHOD0(getAgentId, std::string());
     MOCK_METHOD0(loadAccessToken, void());
     MOCK_CONST_METHOD0(getAccessToken, std::string());
+    MOCK_CONST_METHOD0(isOpenAppsecAgent, bool());
 
     // OpenSSL
     MOCK_METHOD1(setOpenSSLDir, void(const std::string&));

core/include/services_sdk/resources/agent_details.h

@@ -73,6 +73,7 @@ public:
     Maybe<std::string> getOpenSSLDir()       const;
     std::string getClusterId()               const;
     OrchestrationMode getOrchestrationMode() const;
+    bool isOpenAppsecAgent()                 const;
     std::string getAccessToken()             const;
     void loadAccessToken();
 

core/include/services_sdk/resources/component_is/components_list_impl.h

@@ -165,6 +165,14 @@ public:
         }
 
         registerGlobalValue<std::string>("Executable Name", arg_vec.front());
+
+        auto file_path_end = arg_vec.front().find_last_of("/");
+        auto executable_name = arg_vec.front().substr(file_path_end + 1);
+        auto file_sufix_start = executable_name.find_first_of(".");
+        if (file_sufix_start != std::string::npos) {
+            executable_name = executable_name.substr(0, file_sufix_start);
+        }
+        registerGlobalValue<std::string>("Base Executable Name", executable_name);
     }
 
     void

core/include/services_sdk/resources/debug_flags.h

@@ -76,6 +76,7 @@ DEFINE_FLAG(D_COMPONENT, D_ALL)
             DEFINE_FLAG(D_WAAP_SCORE_BUILDER, D_WAAP)
             DEFINE_FLAG(D_WAAP_ULIMITS, D_WAAP)
             DEFINE_FLAG(D_WAAP_SCANNER, D_WAAP)
+            DEFINE_FLAG(D_WAAP_MODEL_LOGGER, D_WAAP)
             DEFINE_FLAG(D_WAAP_DEEP_PARSER, D_WAAP)
             DEFINE_FLAG(D_WAAP_BASE64, D_WAAP)
             DEFINE_FLAG(D_WAAP_JSON, D_WAAP)
@@ -190,6 +191,7 @@ DEFINE_FLAG(D_COMPONENT, D_ALL)
     DEFINE_FLAG(D_L7_ACCESS_CONTROL, D_COMPONENT)
     DEFINE_FLAG(D_IOT_ACCESS_CONTROL, D_COMPONENT)
     DEFINE_FLAG(D_HORIZON_TELEMETRY, D_COMPONENT)
+    DEFINE_FLAG(D_PROMETHEUS, D_COMPONENT)
 
 DEFINE_FLAG(D_FLOW, D_ALL)
     DEFINE_FLAG(D_DROP, D_FLOW)

core/include/services_sdk/resources/generic_metric.h

@@ -24,6 +24,7 @@
 #include "i_mainloop.h"
 #include "i_time_get.h"
 #include "i_agent_details.h"
+#include "i_instance_awareness.h"
 #include "i_environment.h"
 #include "i_messaging.h"
 #include "i_rest_api.h"
@@ -52,6 +53,7 @@ class GenericMetric
     Singleton::Consume<I_MainLoop>,
     Singleton::Consume<I_TimeGet>,
     Singleton::Consume<I_AgentDetails>,
+    Singleton::Consume<I_InstanceAwareness>,
     Singleton::Consume<I_Environment>,
     Singleton::Consume<I_Messaging>,
     Singleton::Consume<I_RestApi>,
@@ -111,7 +113,9 @@ private:
 
     void handleMetricStreamSending();
     void generateLog();
+    void generatePrometheus();
     void generateDebug();
+    void generateAiopsLog();
 
     I_MainLoop *i_mainloop;
     I_TimeGet *i_time;

core/include/services_sdk/resources/log_generator.h

@@ -102,6 +102,8 @@ public:
 
     std::string getLogInsteadOfSending();
 
+    void addMarkerSuffix(const std::string &suffix);
+
 private:
     std::chrono::microseconds getCurrentTime() const;
     void loadBaseLogFields();

core/include/services_sdk/resources/metric/average.h

@@ -54,6 +54,12 @@ public:
         return (count > 0) ? double(sum)/count : 0;
     }
 
+    float
+    getValue() const override
+    {
+        return static_cast<float>(getAverage());
+    }
+
     void
     save(cereal::JSONOutputArchive &ar) const override
     {

core/include/services_sdk/resources/metric/counter.h

@@ -44,6 +44,12 @@ public:
         return counter;
     }
 
+    float
+    getValue() const override
+    {
+        return static_cast<float>(counter);
+    }
+
     void
     save(cereal::JSONOutputArchive &ar) const override
     {

core/include/services_sdk/resources/metric/last_reported_value.h

@@ -44,6 +44,12 @@ public:
         return last_reported;
     }
 
+    float
+    getValue() const override
+    {
+        return static_cast<float>(last_reported);
+    }
+
     void
     save(cereal::JSONOutputArchive &ar) const override
     {

core/include/services_sdk/resources/metric/max.h

@@ -56,6 +56,12 @@ public:
         return max;
     }
 
+    float
+    getValue() const override
+    {
+        return static_cast<float>(max);
+    }
+
     void
     save(cereal::JSONOutputArchive &ar) const override
     {

core/include/services_sdk/resources/metric/metric_calc.h

@@ -18,21 +18,129 @@
 #error metric/metric_calc.h should not be included directly
 #endif // __GENERIC_METRIC_H_
 
+#include <cmath>
 #include <cereal/archives/json.hpp>
 
 #include "report/report.h"
+#include "customized_cereal_map.h"
 
 class GenericMetric;
 
 enum class MetricType { GAUGE, COUNTER };
 
+struct PrometheusData
+{
+    std::string name;
+    std::string type;
+    std::string desc;
+    std::string label;
+    std::string value;
+};
+
+class AiopsMetricData
+{
+public:
+    AiopsMetricData(
+        const std::string &_name,
+        const std::string &_type,
+        const std::string &_units,
+        const std::string &_description,
+        std::map<std::string, std::string> _resource_attributes,
+        float _value)
+            :
+        name(_name),
+        type(_type),
+        units(_units),
+        description(_description),
+        resource_attributes(_resource_attributes),
+        value(_value)
+    {
+        timestamp = Singleton::Consume<I_TimeGet>::by<GenericMetric>()->getWalltimeStr();
+        asset_id = Singleton::Consume<I_AgentDetails>::by<GenericMetric>()->getAgentId();
+    }
+
+    void
+    serialize(cereal::JSONOutputArchive &ar) const
+    {
+        ar(cereal::make_nvp("Timestamp", timestamp));
+        ar(cereal::make_nvp("MetricName", name));
+        ar(cereal::make_nvp("MetricType", type));
+        ar(cereal::make_nvp("MetricUnit", units));
+        ar(cereal::make_nvp("MetricDescription", description));
+        ar(cereal::make_nvp("MetricValue", value));
+        ar(cereal::make_nvp("ResourceAttributes", resource_attributes));
+        ar(cereal::make_nvp("MetricAttributes", metric_attributes));
+        ar(cereal::make_nvp("AssetID", asset_id));
+    }
+
+    std::string
+    toString() const
+    {
+        std::stringstream ss;
+        {
+            cereal::JSONOutputArchive ar(ss);
+            serialize(ar);
+        }
+        return ss.str();
+    }
+
+    void
+    addMetricAttribute(const std::string &label, const std::string &value)
+    {
+        metric_attributes[label] = value;
+    }
+
+private:
+    std::string timestamp = "";
+    std::string asset_id = "";
+    std::string name;
+    std::string type;
+    std::string units;
+    std::string description;
+    std::map<std::string, std::string> resource_attributes;
+    std::map<std::string, std::string> metric_attributes;
+    float value = 0;
+};
+
+class AiopsMetricList
+{
+public:
+    void
+    addMetrics(const std::vector<AiopsMetricData> &_metrics)
+    {
+        metrics.insert(metrics.end(), _metrics.begin(), _metrics.end());
+    }
+
+    void
+    serialize(cereal::JSONOutputArchive &ar) const
+    {
+        ar(cereal::make_nvp("Metrics", metrics));
+    }
+
+// LCOV_EXCL_START Reason: Tested in unit test (testAIOPSMapMetric), but not detected by coverage
+    std::string
+    toString() const
+    {
+        std::stringstream ss;
+        {
+            cereal::JSONOutputArchive ar(ss);
+            serialize(ar);
+        }
+        return ss.str();
+    }
+// LCOV_EXCL_STOP
+
+private:
+    std::vector<AiopsMetricData> metrics;
+};
+
 class MetricCalc
 {
 public:
     template<typename ... Args>
     MetricCalc(GenericMetric *metric, const std::string &calc_title, const Args & ... args)
     {
-        setMetadata("BaseName", calc_title);
+        setMetricName(calc_title);
         addMetric(metric);
         parseMetadata(args ...);
     }
@@ -47,7 +155,11 @@ public:
     std::string getMetircDescription() const { return getMetadata("Description"); }
     std::string getMetadata(const std::string &metadata) const;
     virtual MetricType getMetricType() const { return MetricType::GAUGE; }
+    virtual std::vector<PrometheusData> getPrometheusMetrics() const;
+    virtual float getValue() const = 0;
+    virtual std::vector<AiopsMetricData> getAiopsMetrics() const;
 
+    void setMetricName(const std::string &name) { setMetadata("BaseName", name); }
     void setMetricDotName(const std::string &name) { setMetadata("DotName", name); }
     void setMetircUnits(const std::string &units) { setMetadata("Units", units); }
     void setMetircDescription(const std::string &description) { setMetadata("Description", description); }
@@ -55,6 +167,7 @@ public:
 
 protected:
     void addMetric(GenericMetric *metric);
+    std::map<std::string, std::string> getBasicLabels() const;
 
     template <typename Metadata, typename ... OtherMetadata>
     void

core/include/services_sdk/resources/metric/metric_map.h

@@ -54,6 +54,37 @@ class MetricMap : public MetricCalc
             return first->second.getMetricType();
         }
 
+        std::vector<PrometheusData>
+        getPrometheusMetrics(const std::string &label, const std::string &name) const
+        {
+            std::vector<PrometheusData> res;
+
+            for (auto &metric : inner_map) {
+                auto sub_res =  metric.second.getPrometheusMetrics();
+                for (auto &sub_metric : sub_res) {
+                    sub_metric.label += "," + label + "=\"" + metric.first + "\"";
+                    sub_metric.name = name;
+                }
+                res.insert(res.end(), sub_res.begin(), sub_res.end());
+            }
+
+            return res;
+        }
+
+        std::vector<AiopsMetricData>
+        getAiopsMetrics(const std::string &label) const
+        {
+            std::vector<AiopsMetricData> aiops_metrics;
+            for (auto &metric : inner_map) {
+                auto metric_data = metric.second.getAiopsMetrics();
+                for (auto &sub_metric : metric_data) {
+                    sub_metric.addMetricAttribute(label,  metric.first);
+                }
+                aiops_metrics.insert(aiops_metrics.end(), metric_data.begin(), metric_data.end());
+            }
+            return aiops_metrics;
+        }
+
         typename std::map<std::string, Metric>::const_iterator begin() const { return inner_map.begin(); }
         typename std::map<std::string, Metric>::const_iterator end() const { return inner_map.end(); }
 
@@ -63,9 +94,17 @@ class MetricMap : public MetricCalc
 
 public:
     template <typename ... Args>
-    MetricMap(GenericMetric *metric, const std::string &title, const Args & ... args)
+    MetricMap(
+        const Metric &sub_metric,
+        GenericMetric *metric,
+        const std::string &l,
+        const std::string &title,
+        const Args & ... args
+    )
             :
-        MetricCalc(metric, title, args ...)
+        MetricCalc(metric, title, args ...),
+        base_metric(sub_metric),
+        label(l)
     {
     }
 
@@ -75,6 +114,14 @@ public:
         if (getMetricType() == MetricType::GAUGE) metric_map.clear();
     }
 
+// LCOV_EXCL_START Reason: Covered by printPromeathusMultiMap unit-test, but misdetected by the coverage
+    float
+    getValue() const override
+    {
+        return std::nanf("");
+    }
+// LCOV_EXCL_STOP
+
     void
     save(cereal::JSONOutputArchive &ar) const override
     {
@@ -89,7 +136,9 @@ public:
     {
         std::stringstream string_key;
         string_key << key;
-        auto metric = metric_map.emplace(string_key.str(), Metric(nullptr, string_key.str())).first;
+        auto new_metric = base_metric;
+        new_metric.setMetricName(string_key.str());
+        auto metric = metric_map.emplace(string_key.str(), std::move(new_metric)).first;
         metric->second.report(new_values...);
     }
 
@@ -105,8 +154,22 @@ public:
         return field;
     }
 
+    std::vector<PrometheusData>
+    getPrometheusMetrics() const override
+    {
+        return metric_map.getPrometheusMetrics(label, getMetricName());
+    }
+
+    std::vector<AiopsMetricData>
+    getAiopsMetrics() const
+    {
+        return metric_map.getAiopsMetrics(label);
+    }
+
 private:
     InnerMap metric_map;
+    Metric base_metric;
+    std::string label;
 };
 
 } // namespace MetricCalculations

core/include/services_sdk/resources/metric/min.h

@@ -56,6 +56,12 @@ public:
         return min;
     }
 
+    float
+    getValue() const override
+    {
+        return static_cast<float>(min);
+    }
+
     void
     save(cereal::JSONOutputArchive &ar) const override
     {

core/include/services_sdk/resources/metric/no_reset_counter.h

@@ -41,6 +41,12 @@ public:
         return counter;
     }
 
+    float
+    getValue() const override
+    {
+        return static_cast<float>(counter);
+    }
+
     void
     save(cereal::JSONOutputArchive &ar) const override
     {

core/include/services_sdk/resources/metric/top_values.h

@@ -59,6 +59,12 @@ public:
         values.clear();
     }
 
+    float
+    getValue() const override
+    {
+        return std::nanf("");
+    }
+
     std::vector<T>
     getTopValues() const
     {