[llvm] [llvm]Add a simple Telemetry framework (PR #102323)

[James Henderson via llvm-commits]

================
@@ -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;
----------------
jh7370 wrote:

I'm not convinced this is a particularly useful overload, especially given it's a pure virtual one, so every downstream tool will need to implement it. The reason I think it's unhelpful is that it uses `std::map`, which, in my experience, is rarely the right tool for the job. `std::unordered_map` is much more common outside of LLVM and within LLVM, I'd expect types like `DenseMap` to be preferred.

I think for this to be useful, the serializer needs to support any map-like type, via a template method of some variety. Exactly how it would best work is a little unclear to me. In our downstream version, we have a concrete method that takes a `std::unordered_map<std::string, T>`, which in turn calls `startObject`/`endObject` virtual methods (implemented in the concrete Serializer subclasses) before iterating over the map type and calling `write` for each entry in the map. This has worked for our needs, but I don't know if it will be flexible enough for the needs of LLVM. A similar approach is taken for array-like types like `std::vector<T>` (but using `startArray`/`endArray` methods instead and providing key-less overloads of the `write` methods).

https://github.com/llvm/llvm-project/pull/102323