Addressed review comments:

 - Use separate entries for Process and Main Executable module
 - Rename for clarity

Author: oontvoo

lldb/include/lldb/Core/Telemetry.h

@@ -55,10 +55,11 @@ struct LLDBConfig : public ::llvm::telemetry::Config {
 // and differ by the last two bits)
 struct LLDBEntryKind : public ::llvm::telemetry::EntryKind {
   // clang-format off
-  static const llvm::telemetry::KindType BaseInfo     = 0b11000000;
-  static const llvm::telemetry::KindType CommandInfo  = 0b11010000;
-  static const llvm::telemetry::KindType DebuggerInfo = 0b11001000;
-  static const llvm::telemetry::KindType TargetInfo   = 0b11000100;
+  static const llvm::telemetry::KindType BaseInfo        = 0b11000000;
+  static const llvm::telemetry::KindType CommandInfo     = 0b11010000;
+  static const llvm::telemetry::KindType DebuggerInfo    = 0b11001000;
+  static const llvm::telemetry::KindType ExecModuleInfo  = 0b11000100;
+  static const llvm::telemetry::KindType ProcessExitInfo = 0b11001100;
   // clang-format on
 };
 
@@ -88,42 +89,6 @@ struct LLDBBaseTelemetryInfo : public llvm::telemetry::TelemetryInfo {
   void serialize(llvm::telemetry::Serializer &serializer) const override;
 };
 
-/// Describes an exit status.
-struct ExitDescription {
-  int exit_code;
-  std::string description;
-};
-
-struct TargetInfo : public LLDBBaseTelemetryInfo {
-  lldb::ModuleSP exec_mod;
-
-  /// The same as the executable-module's UUID.
-  UUID target_uuid;
-  /// PID of the process owned by this target.
-  lldb::pid_t pid;
-  std::string arch_name;
-
-  /// If true, this entry was emitted at the beginning of an event (eg., before
-  /// the executable is loaded). Otherwise, it was emitted at the end of an
-  /// event (eg., after the module and any dependency were loaded.)
-  bool is_start_entry;
-
-  /// Describes the exit of the executable module.
-  std::optional<ExitDescription> exit_desc;
-  TargetInfo() = default;
-
-  llvm::telemetry::KindType getKind() const override {
-    return LLDBEntryKind::TargetInfo;
-  }
-
-  static bool classof(const TelemetryInfo *T) {
-    // Subclasses of this is also acceptable
-    return (T->getKind() & LLDBEntryKind::TargetInfo) ==
-           LLDBEntryKind::TargetInfo;
-  }
-  void serialize(llvm::telemetry::Serializer &serializer) const override;
-};
-
 struct CommandInfo : public LLDBBaseTelemetryInfo {
   /// If the command is/can be associated with a target entry this field
   /// contains that target's UUID. <EMPTY> otherwise.
@@ -190,6 +155,58 @@ struct DebuggerInfo : public LLDBBaseTelemetryInfo {
   void serialize(llvm::telemetry::Serializer &serializer) const override;
 };
 
+struct ExecModuleInfo : public LLDBBaseTelemetryInfo {
+  lldb::ModuleSP exec_mod;
+
+  /// The same as the executable-module's UUID.
+  UUID exec_uuid;
+  /// PID of the process owned by this target.
+  lldb::pid_t pid;
+  std::string arch_name;
+
+  /// If true, this entry was emitted at the beginning of an event (eg., before
+  /// the executable is set). Otherwise, it was emitted at the end of an
+  /// event (eg., after the module and any dependency were loaded.)
+  bool is_start_entry;
+
+  ExecModuleInfo() = default;
+
+  llvm::telemetry::KindType getKind() const override {
+    return LLDBEntryKind::ExecModuleInfo;
+  }
+
+  static bool classof(const TelemetryInfo *T) {
+    // Subclasses of this is also acceptable
+    return (T->getKind() & LLDBEntryKind::ExecModuleInfo) ==
+           LLDBEntryKind::ExecModuleInfo;
+  }
+  void serialize(llvm::telemetry::Serializer &serializer) const override;
+};
+
+/// Describes an exit status.
+struct ExitDescription {
+  int exit_code;
+  std::string description;
+};
+
+struct ProcessExitInfo : public LLDBBaseTelemetryInfo {
+  UUID exec_uuid;
+  lldb::pid_t pid;
+  bool is_start_entry;
+  std::optional<ExitDescription> exit_desc;
+
+  llvm::telemetry::KindType getKind() const override {
+    return LLDBEntryKind::ProcessExitInfo;
+  }
+
+  static bool classof(const TelemetryInfo *T) {
+    // Subclasses of this is also acceptable
+    return (T->getKind() & LLDBEntryKind::ProcessExitInfo) ==
+           LLDBEntryKind::ProcessExitInfo;
+  }
+  void serialize(llvm::telemetry::Serializer &serializer) const override;
+};
+
 /// The base Telemetry manager instance in LLDB.
 /// This class declares additional instrumentation points
 /// applicable to LLDB.

lldb/include/lldb/Target/Target.h

@@ -544,6 +544,8 @@ class Target : public std::enable_shared_from_this<Target>,
     return GetStaticBroadcasterClass();
   }
 
+  UUID GetExecModuleUUID() const { return m_current_exec_mod_uuid; }
+
   // This event data class is for use by the TargetList to broadcast new target
   // notifications.
   class TargetEventData : public EventData {
@@ -1640,6 +1642,8 @@ class Target : public std::enable_shared_from_this<Target>,
 private:
   // Target metrics storage.
   TargetStats m_stats;
+  // The current executable module UUID.
+  UUID m_current_exec_mod_uuid;
 
 public:
   /// Get metrics associated with this target in JSON format.

lldb/source/Core/Telemetry.cpp

@@ -87,13 +87,21 @@ void DebuggerInfo::serialize(Serializer &serializer) const {
   serializer.write("is_exit_entry", is_exit_entry);
 }
 
-void TargetInfo::serialize(Serializer &serializer) const {
+void ExecModuleInfo::serialize(Serializer &serializer) const {
   LLDBBaseTelemetryInfo::serialize(serializer);
 
-  serializer.write("target_uuid", target_uuid.GetAsString());
+  serializer.write("exec_uuid", exec_uuid.GetAsString());
   serializer.write("pid", pid);
   serializer.write("arch_name", arch_name);
   serializer.write("is_start_entry", is_start_entry);
+}
+
+void ProcessExitInfo::serialize(Serializer &serializer) const {
+  LLDBBaseTelemetryInfo::serialize(serializer);
+
+  serializer.write("exec_uuid", exec_uuid.GetAsString());
+  serializer.write("pid", pid);
+  serializer.write("is_start_entry", is_start_entry);
   if (exit_desc.has_value()) {
     serializer.write("exit_code", exit_desc->exit_code);
     serializer.write("exit_desc", exit_desc->description);

lldb/source/Target/Process.cpp

@@ -1065,25 +1065,29 @@ const char *Process::GetExitDescription() {
 bool Process::SetExitStatus(int status, llvm::StringRef exit_string) {
   // Use a mutex to protect setting the exit status.
   std::lock_guard<std::mutex> guard(m_exit_status_mutex);
-  telemetry::ScopedDispatcher<telemetry::TargetInfo> helper;
+  telemetry::ScopedDispatcher<telemetry::ProcessExitInfo> helper;
 
-  // TODO: Find the executable-module's UUID somehow. (Maybe save the UUID in
-  // Target?) We might not have a valid executable-mod anymore.
-  helper.DispatchNow([&](telemetry::TargetInfo *info) {
-    // Check if there is (still) a valid target and get the debugger from it.
-    TargetSP target_sp(Debugger::FindTargetWithProcessID(m_pid));
-    if (target_sp)
-      helper.SetDebugger(&(target_sp->GetDebugger()));
+  // Find the executable-module's UUID, if available.
+  UUID exec_uuid;
+  // Check if there is (still) a valid target and get the debugger and exec_uuid
+  // from it.
+  TargetSP target_sp(Debugger::FindTargetWithProcessID(m_pid));
+  if (target_sp) {
+    helper.SetDebugger(&(target_sp->GetDebugger()));
+    if (ModuleSP exec_mod = target_sp->GetExecutableModule())
+      exec_uuid = exec_mod->GetUUID();
+  }
 
-    // info->target_uuid = target_uuid;
+  helper.DispatchNow([&](telemetry::ProcessExitInfo *info) {
+    info->exec_uuid = exec_uuid;
     info->pid = m_pid;
     info->is_start_entry = true;
+    info->exit_desc = {status, exit_string.str()};
   });
 
-  helper.DispatchOnExit([&](telemetry::TargetInfo *info) {
-    // info->target_uuid = target_uuid;
+  helper.DispatchOnExit([&](telemetry::ProcessExitInfo *info) {
+    info->exec_uuid = exec_uuid;
     info->pid = m_pid;
-    info->exit_desc = {status, exit_string.str()};
   });
 
   Log *log(GetLog(LLDBLog::State | LLDBLog::Process));

lldb/source/Target/Target.cpp

@@ -1560,25 +1560,26 @@ void Target::DidExec() {
 
 void Target::SetExecutableModule(ModuleSP &executable_sp,
                                  LoadDependentFiles load_dependent_files) {
-  telemetry::ScopedDispatcher<telemetry::TargetInfo> helper(&m_debugger);
+  telemetry::ScopedDispatcher<telemetry::ExecModuleInfo> helper(&m_debugger);
   Log *log = GetLog(LLDBLog::Target);
   ClearModules(false);
 
   if (executable_sp) {
+    m_current_exec_mod_uuid = executable_sp->GetUUID();
     lldb::pid_t pid;
     if (ProcessSP proc = GetProcessSP())
       pid = proc->GetID();
-    helper.DispatchNow([&](telemetry::TargetInfo *info) {
+    helper.DispatchNow([&](telemetry::ExecModuleInfo *info) {
       info->exec_mod = executable_sp;
-      info->target_uuid = executable_sp->GetUUID();
+      info->exec_uuid = m_current_exec_mod_uuid;
       info->pid = pid;
       info->arch_name = executable_sp->GetArchitecture().GetArchitectureName();
       info->is_start_entry = true;
     });
 
-    helper.DispatchOnExit([&](telemetry::TargetInfo *info) {
+    helper.DispatchOnExit([&](telemetry::ExecModuleInfo *info) {
       info->exec_mod = executable_sp;
-      info->target_uuid = executable_sp->GetUUID();
+      info->exec_uuid = executable_sp->GetUUID();
       info->pid = pid;
     });