[llvm]Add a simple Telemetry framework

llvm/docs/Telemetry.rst

@@ -8,16 +8,12 @@ Telemetry framework in LLVM
 .. toctree::
    :hidden:
 
-===========================
-Telemetry framework in LLVM
-===========================
-
 Objective
 =========
 
 Provides a common framework in LLVM for collecting various usage and performance
 metrics.
-It is located at ``llvm/Telemetry/Telemetry.h``
+It is located at ``llvm/Telemetry/Telemetry.h``.
 
 Characteristics
 ---------------
@@ -93,13 +89,13 @@ To use Telemetry in your tool, you need to provide a concrete implementation of
 
   class JsonSerializer : public Serializer {
   public:
-    json::Object *getOutputObject() { return object.get(); }
+    json::Object *getOutputObject() { return Out.get(); }
 
     llvm::Error init() override {
-      if (started)
+      if (Started)
         return createStringError("Serializer already in use");
       started = true;
-      object = std::make_unique<json::Object>();
+      Out = std::make_unique<json::Object>();
       return Error::success();
     }
 
@@ -112,71 +108,71 @@ To use Telemetry in your tool, you need to provide a concrete implementation of
       writeHelper(KeyName, Value);
     }
 
-    void write(StringRef KeyName, size_t Value) override {
+    void write(StringRef KeyName, unsigned long long Value) override {
       writeHelper(KeyName, Value);
     }
     void write(StringRef KeyName, StringRef Value) override {
       writeHelper(KeyName, Value);
     }
 
     void write(StringRef KeyName,
-               const std::map<std::string, std::string>& Value) override {
+               const std::map<std::string, std::string> &Value) override {
       json::Object Inner;
-      for (auto kv : Value) {
-        Inner.try_emplace(kv.first, kv.second);
+      for (auto KV : Value) {
+        Inner.try_emplace(KV.first, KV.second);
       }
       writeHelper(KeyName, json::Value(std::move(Inner)));
     }
 
     Error finalize() override {
-      if (!started)
+      if (!Started)
         return createStringError("Serializer not currently in use");
-      started = false;
+      Started = false;
       return Error::success();
     }
 
   private:
     template <typename T> void writeHelper(StringRef Name, T Value) {
       assert(started && "serializer not started");
-      object->try_emplace(Name, Value);
+      Out->try_emplace(Name, Value);
     }
-    bool started = false;
-    std::unique_ptr<json::Object> object;
+    bool Started = false;
+    std::unique_ptr<json::Object> Out;
   };
 
   class MyManager : public telemery::Manager {
   public:
-  static std::unique_ptr<MyManager> createInstatnce(telemetry::Config* config) {
+  static std::unique_ptr<MyManager> createInstatnce(telemetry::Config *config) {
     // If Telemetry is not enabled, then just return null;
     if (!config->EnableTelemetry) return nullptr;
 
     return std::make_unique<MyManager>();
   }
   MyManager() = default;
 
-  Error dispatch(TelemetryInfo* Entry) const override {
+  Error dispatch(TelemetryInfo *Entry) const override {
     Entry->SessionId = SessionId;
     emitToAllDestinations(Entry);
   }
 
-  void addDestination(std::unique_ptr<Destination> dest) override {
-    destinations.push_back(std::move(dest));
+  void addDestination(std::unique_ptr<Destination> Dest) override {
+    destinations.push_back(std::move(Dest));
   }
 
   // You can also define additional instrumentation points.
-  void logStartup(TelemetryInfo* Entry) {
+  void logStartup(TelemetryInfo *Entry) {
     // Add some additional data to entry.
     Entry->Msg = "Some message";
     dispatch(Entry);
   }
 
-  void logAdditionalPoint(TelemetryInfo* Entry) {
+  void logAdditionalPoint(TelemetryInfo  Entry) {
     // .... code here
   }
 
   private:
-    void emitToAllDestinations(const TelemetryInfo* Entry) {
-      for (Destination* Dest : Destinations) {
+    void emitToAllDestinations(const TelemetryInfo *Entry) {
+      for (Destination *Dest : Destinations) {
         Dest->receiveEntry(Entry);
       }
     }
@@ -187,31 +183,31 @@ To use Telemetry in your tool, you need to provide a concrete implementation of
 
   class MyDestination : public telemetry::Destination {
   public:
-    Error receiveEntry(const TelemetryInfo* Entry) override {
-      if (Error err = serializer.init()) {
-        return err;
+    Error receiveEntry(const TelemetryInfo *Entry) override {
+      if (Error Err = Serializer.init()) {
+        return Err;
       }
-      Entry->serialize(serializer);
-      if (Error err = serializer.finalize()) {
-        return err;
+      Entry->serialize(Serializer);
+      if (Error Err = Serializer.finalize()) {
+        return Err;
       }
 
-      json::Object copied = *serializer.getOutputObject();
-      // Send the `copied` object to wherever.
+      json::Object Copied = *Serializer.getOutputObject();
+      // Send the `Copied` object to wherever.
       return Error::success();
     }
 
   private:
-    JsonSerializer serializer;
+    JsonSerializer Serializer;
   };
 
   // This defines a custom TelemetryInfo that has an additional Msg field.
   struct MyTelemetryInfo : public telemetry::TelemetryInfo {
     std::string Msg;
 
-    Error serialize(Serializer& serializer) const override {
+    Error serialize(Serializer& Serializer) const override {
       TelemetryInfo::serialize(serializer);
-      serializer.writeString("MyMsg", Msg);
+      Serializer.writeString("MyMsg", Msg);
     }
 
     // Note: implement getKind() and classof() to support dyn_cast operations.
@@ -230,11 +226,11 @@ Logging the tool init-process:
   auto Manager = MyManager::createInstance(&MyConfig);
 
 
-  // Any other tool's init code can go here
+  // Any other tool's init code can go here.
   // ...
 
   // Finally, take a snapshot of the time now so we know how long it took the
-  // init process to finish
+  // init process to finish.
   auto EndTime = std::chrono::time_point<std::chrono::steady_clock>::now();
   MyTelemetryInfo Entry;
 

llvm/include/llvm/Telemetry/Telemetry.h

@@ -1,4 +1,4 @@
-//===- llvm/Telemetry/Telemetry.h - Telemetry -------------------*- C++ -*-===//
+//===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 ///
 /// \file
-/// This file provides the basic framework for Telemetry
+/// This file provides the basic framework for Telemetry.
 /// Refer to its documentation at llvm/docs/Telemetry.rst for more details.
 //===---------------------------------------------------------------------===//
 
@@ -27,14 +27,14 @@ namespace telemetry {
 
 class Serializer {
 public:
-  virtual llvm::Error init() = 0;
+  virtual Error init() = 0;
   virtual void write(StringRef KeyName, bool Value) = 0;
   virtual void write(StringRef KeyName, int Value) = 0;
-  virtual void write(StringRef KeyName, size_t Value) = 0;
+  virtual void write(StringRef KeyName, unsigned long long Value) = 0;
   virtual void write(StringRef KeyName, StringRef Value) = 0;
   virtual void write(StringRef KeyName,
                      const std::map<std::string, std::string> &Value) = 0;
-  virtual llvm::Error finalize() = 0;
+  virtual Error finalize() = 0;
 };
 
 /// Configuration for the Manager class.
@@ -79,7 +79,7 @@ struct TelemetryInfo {
   //
   // Note: a tool could have multiple sessions running at once, in which
   // case, these shall be multiple sets of TelemetryInfo with multiple unique
-  // ids.
+  // IDs.
   //
   // Different usages can assign different types of IDs to this field.
   std::string SessionId;

llvm/unittests/Telemetry/TelemetryTest.cpp

@@ -49,13 +49,13 @@ struct TestContext {
 
 class JsonSerializer : public Serializer {
 public:
-  json::Object *getOutputObject() { return object.get(); }
+  json::Object *getOutputObject() { return Out.get(); }
 
   llvm::Error init() override {
-    if (started)
+    if (Started)
       return createStringError("Serializer already in use");
-    started = true;
-    object = std::make_unique<json::Object>();
+    Started = true;
+    Out = std::make_unique<json::Object>();
     return Error::success();
   }
 
@@ -67,7 +67,7 @@ class JsonSerializer : public Serializer {
     writeHelper(KeyName, Value);
   }
 
-  void write(StringRef KeyName, size_t Value) override {
+  void write(StringRef KeyName, unsigned long long Value) override {
     writeHelper(KeyName, Value);
   }
   void write(StringRef KeyName, StringRef Value) override {
@@ -77,36 +77,36 @@ class JsonSerializer : public Serializer {
   void write(StringRef KeyName,
              const std::map<std::string, std::string> &Value) override {
     json::Object Inner;
-    for (auto kv : Value) {
-      Inner.try_emplace(kv.first, kv.second);
+    for (auto KV : Value) {
+      Inner.try_emplace(KV.first, KV.second);
     }
     writeHelper(KeyName, json::Value(std::move(Inner)));
   }
 
   llvm::Error finalize() override {
-    if (!started)
+    if (!Started)
       return createStringError("Serializer not currently in use");
-    started = false;
+    Started = false;
     return Error::success();
   }
 
 private:
   template <typename T> void writeHelper(StringRef Name, T Value) {
-    assert(started && "serializer not started");
-    object->try_emplace(Name, Value);
+    assert(Started && "serializer not started");
+    Out->try_emplace(Name, Value);
   }
-  bool started = false;
-  std::unique_ptr<json::Object> object;
+  bool Started = false;
+  std::unique_ptr<json::Object> Out;
 };
 
 class StringSerializer : public Serializer {
 public:
   const std::string &getString() { return Buffer; }
 
   llvm::Error init() override {
-    if (started)
+    if (Started)
       return createStringError("Serializer already in use");
-    started = true;
+    Started = true;
     Buffer.clear();
     return Error::success();
   }
@@ -119,41 +119,41 @@ class StringSerializer : public Serializer {
     writeHelper(KeyName, Value);
   }
 
-  void write(StringRef KeyName, size_t Value) override {
+  void write(StringRef KeyName, unsigned long long Value) override {
     writeHelper(KeyName, Value);
   }
   void write(StringRef KeyName, StringRef Value) override {
-    assert(started && "serializer not started");
+    writeHelper(KeyName, Value);
   }
 
   void write(StringRef KeyName,
              const std::map<std::string, std::string> &Value) override {
     std::string Inner;
-    for (auto kv : Value) {
-      writeHelper(StringRef(kv.first), StringRef(kv.second), &Inner);
+    for (auto KV : Value) {
+      writeHelper(StringRef(KV.first), StringRef(KV.second), &Inner);
     }
     writeHelper(KeyName, StringRef(Inner));
   }
 
   llvm::Error finalize() override {
-    if (!started)
+    if (!Started)
       return createStringError("Serializer not currently in use");
-    started = false;
+    Started = false;
     return Error::success();
   }
 
 private:
   template <typename T>
   void writeHelper(StringRef Name, T Value, std::string *Buff) {
-    assert(started && "serializer not started");
+    assert(Started && "serializer not started");
     Buff->append((Name + ":" + llvm::Twine(Value) + "\n").str());
   }
 
   template <typename T> void writeHelper(StringRef Name, T Value) {
     writeHelper(Name, Value, &Buffer);
   }
 
-  bool started = false;
+  bool Started = false;
   std::string Buffer;
 };