Update eden logger to support strvec

Summary:
# Context
Adds support for vector<string> inside eden's logger object.

This is done to support a new logEvent.

# Code decisions
Vector<string> is converted to a folly::dynamic via the function folly::toDynamic instead of using the preexisting dynamicMap due to issues with getting the types to play nice. We may want to look at using it for the other fields as well rather than using a homegrown function.

Reviewed By: jdelliot

Differential Revision: D73214290

fbshipit-source-id: 48b3ea0647f444da960bb1eade02f521a05968ed

Author: Alramech

eden/common/telemetry/DynamicEvent.cpp

@@ -70,4 +70,18 @@ void DynamicEvent::addDouble(std::string name, double value) {
   }
 }
 
+void DynamicEvent::addStringVec(
+    std::string name,
+    std::vector<std::string> value) {
+  for (auto& vref : value) {
+    validateUtf8(vref);
+  }
+  auto [iter, inserted] =
+      stringVecs_.emplace(std::move(name), std::move(value));
+  if (!inserted) {
+    throw_<std::logic_error>(
+        "Attempted to insert duplicate string vector: ", iter->first);
+  }
+}
+
 } // namespace facebook::eden

eden/common/telemetry/DynamicEvent.h

@@ -11,6 +11,7 @@
 #include <cstdint>
 #include <string>
 #include <unordered_map>
+#include <vector>
 
 namespace facebook::eden {
 
@@ -19,6 +20,8 @@ class DynamicEvent {
   using IntMap = std::unordered_map<std::string, int64_t>;
   using StringMap = std::unordered_map<std::string, std::string>;
   using DoubleMap = std::unordered_map<std::string, double>;
+  using StringVecMap =
+      std::unordered_map<std::string, std::vector<std::string>>;
 
   DynamicEvent() = default;
   DynamicEvent(const DynamicEvent&) = default;
@@ -38,6 +41,7 @@ class DynamicEvent {
   void addInt(std::string name, int64_t value);
   void addString(std::string name, std::string value);
   void addDouble(std::string name, double value);
+  void addStringVec(std::string name, std::vector<std::string> value);
 
   /**
    * Convenience function that adds boolean values as integer 0 or 1.
@@ -55,14 +59,17 @@ class DynamicEvent {
   const DoubleMap& getDoubleMap() const {
     return doubles_;
   }
+  const StringVecMap& getStringVecMap() const {
+    return stringVecs_;
+  }
 
  private:
   // Due to limitations in the underlying log database, limit the field types to
   // int64_t, double, string, and vector<string>
-  // TODO: add vector<string> support if needed.
   IntMap ints_;
   StringMap strings_;
   DoubleMap doubles_;
+  StringVecMap stringVecs_;
 };
 
 } // namespace facebook::eden

eden/common/telemetry/ScubaStructuredLogger.cpp

@@ -6,10 +6,10 @@
  */
 
 #include "eden/common/telemetry/ScubaStructuredLogger.h"
+#include "eden/common/telemetry/SubprocessScribeLogger.h"
 
 #include <folly/json/json.h>
-
-#include "eden/common/telemetry/SubprocessScribeLogger.h"
+#include "folly/json/DynamicConverter.h"
 
 namespace facebook::eden {
 
@@ -50,6 +50,12 @@ void ScubaStructuredLogger::logDynamicEvent(DynamicEvent event) {
     document["double"] = dynamicMap(doubleMap);
   }
 
+  const auto& stringVecMap = event.getStringVecMap();
+  if (!stringVecMap.empty()) {
+    // Special case handling for array
+    document["normvector"] = folly::toDynamic(stringVecMap);
+  }
+
   scribeLogger_->log(folly::toJson(document));
 }
 

eden/common/telemetry/test/DynamicEventTest.cpp

@@ -83,4 +83,13 @@ TEST(DynamicEventTest, ValidateUtf8) {
   EXPECT_THROW(
       event.addString("test_invalid_utf8", "\xFF\xFF"), std::exception);
 }
+TEST(DynamicEventTest, AddStringVec) {
+  DynamicEvent event;
+  std::vector<std::string> test = {"a", "b", "c"};
+  event.addStringVec("stringvec", test);
+  const auto& stringVecMap = event.getStringVecMap();
+  EXPECT_EQ(stringVecMap.size(), 1);
+  EXPECT_EQ(stringVecMap.at("stringvec"), test);
+  EXPECT_THROW(event.addStringVec("stringvec", {"qq"}), std::logic_error);
+}
 } // namespace facebook::eden

eden/common/telemetry/test/ScubaStructuredLoggerTest.cpp

@@ -56,6 +56,21 @@ struct TypelessTestLogEvent : public TypelessTestEvent {
   }
 };
 
+struct VectorTestLogEvent : public TestEvent {
+  std::vector<std::string> strvec;
+
+  explicit VectorTestLogEvent(std::vector<std::string> strvec)
+      : strvec(std::move(strvec)) {}
+
+  void populate(DynamicEvent& event) const override {
+    event.addStringVec("strvec", strvec);
+  }
+
+  char const* getType() const override {
+    return "vector_test_event";
+  }
+};
+
 struct ScubaStructuredLoggerTest : public ::testing::Test {
   std::shared_ptr<TestScribeLogger> scribe{
       std::make_shared<TestScribeLogger>()};
@@ -138,3 +153,36 @@ TEST_F(
       UnorderedElementsAre("str", "user", "host", "os", "osver"));
 #endif
 }
+
+TEST_F(ScubaStructuredLoggerTest, empty_stringvec_test) {
+  VectorTestLogEvent event({});
+  logger.logEvent(event);
+  EXPECT_EQ(1, scribe->lines.size());
+  const auto& line = scribe->lines[0];
+  auto doc = folly::parseJson(line);
+  EXPECT_TRUE(doc.isObject());
+  EXPECT_THAT(keysOf(doc), UnorderedElementsAre("int", "normal", "normvector"));
+
+  auto normvecs = doc["normvector"];
+  EXPECT_TRUE(normvecs.isObject());
+  EXPECT_THAT(keysOf(normvecs), UnorderedElementsAre("strvec"));
+  EXPECT_TRUE(normvecs["strvec"].empty());
+}
+
+TEST_F(ScubaStructuredLoggerTest, stringvec_test) {
+  VectorTestLogEvent event({"a", "b", "c"});
+  logger.logEvent(event);
+  EXPECT_EQ(1, scribe->lines.size());
+  const auto& line = scribe->lines[0];
+  auto doc = folly::parseJson(line);
+  EXPECT_TRUE(doc.isObject());
+  EXPECT_THAT(keysOf(doc), UnorderedElementsAre("int", "normal", "normvector"));
+
+  auto normvecs = doc["normvector"];
+  EXPECT_TRUE(normvecs.isObject());
+  EXPECT_THAT(keysOf(normvecs), UnorderedElementsAre("strvec"));
+  EXPECT_FALSE(normvecs["strvec"].empty());
+  EXPECT_EQ(normvecs["strvec"][0].asString(), "a");
+  EXPECT_EQ(normvecs["strvec"][1].asString(), "b");
+  EXPECT_EQ(normvecs["strvec"][2].asString(), "c");
+}