more data

Author: oontvoo

lldb/include/lldb/Core/Telemetry.h

@@ -151,16 +151,6 @@ template <typename Info> struct ScopedDispatcher {
     debugger = debugger;
   }
 
-
-  template typename<T>
-      T GetIfEnable(llvm::unique_function<T(TelemetryManager*)> callable,
-                                   T default_value) {
-    TelemetryManager *manager = TelemetryManager::GetInstanceIfEnabled();
-    if (!manager)
-      return default_value;
-    return callable(manager);
-  }
-
   void SetDebugger(Debugger *debugger) { debugger = debugger; }
 
   void SetFinalCallback(llvm::unique_function<void(Info *info)> final_callback) {

lldb/source/Interpreter/CommandInterpreter.cpp

@@ -1886,16 +1886,18 @@ bool CommandInterpreter::HandleCommand(const char *command_line,
                                        CommandReturnObject &result,
                                        bool force_repeat_command) {
   lldb_private::telemetry::ScopedDispatcher<
-      lldb_private::telemetry:CommandInfo> helper;
-  const int command_id = helper.GetIfEnable<int>([](lldb_private::telemetry::TelemetryManager* ins){
-    return ins->MakeNextCommandId(); }, 0);
+      lldb_private::telemetry:CommandInfo> helper(m_debugger);
+  lldb_private::telemetry::TelemetryManager *ins = lldb_private::telemetry::TelemetryManager::GetInstanceOrDummy();
+  const int command_id = ins->MakeNextCommandId();
+
 
   std::string command_string(command_line);
   std::string original_command_string(command_string);
   std::string real_original_command_string(command_string);
+  std::string parsed_command_args;
+  CommandObject *cmd_obj = nullptr;
 
-  helper.DispatchIfEnable([&](lldb_private::telemetry:CommandInfo* info,
-                              lldb_private::telemetry::TelemetryManager* ins){
+  helper.DispatchIfEnable([&](lldb_private::telemetry:CommandInfo* info){
     info.command_id = command_id;
     if (Target* target = GetExecutionContext().GetTargetPtr()) {
       // If we have a target attached to this command, then get the UUID.
@@ -1905,6 +1907,26 @@ bool CommandInterpreter::HandleCommand(const char *command_line,
     }
     if (ins->GetConfig()->m_collect_original_command)
       info.original_command = original_command_string;
+    // The rest (eg., command_name, args, etc) hasn't been parsed yet;
+    // Those will be collected by the on-exit-callback.
+  });
+
+  helper.DispatchOnExit([&](lldb_private::telemetry:CommandInfo* info) {
+    // TODO: this is logging the time the command-handler finishes.
+    // But we may want a finer-grain durations too?
+    // (ie., the execute_time recorded below?)
+
+    info.command_id = command_id;
+    llvm::StringRef command_name =
+        cmd_obj ? cmd_obj->GetCommandName() : "<not found>";
+    info.command_name = command_name.str();
+    info.ret_status = result.GetStatus();
+    if (llvm::StringRef error_data = result.GetErrorData();
+      !error_data.empty())
+      info.error_data = error_data.str();
+
+    if (ins->GetConfig()->m_collect_original_command)
+      info.args = parsed_command_args;
   });
 
   Log *log = GetLog(LLDBLog::Commands);
@@ -2011,7 +2033,7 @@ bool CommandInterpreter::HandleCommand(const char *command_line,
   // From 1 above, we can determine whether the Execute function wants raw
   // input or not.
 
-  CommandObject *cmd_obj = ResolveCommandImpl(command_string, result);
+  cmd_obj = ResolveCommandImpl(command_string, result);
 
   // We have to preprocess the whole command string for Raw commands, since we
   // don't know the structure of the command.  For parsed commands, we only
@@ -2073,37 +2095,36 @@ bool CommandInterpreter::HandleCommand(const char *command_line,
     if (add_to_history)
       m_command_history.AppendString(original_command_string);
 
-    std::string remainder;
     const std::size_t actual_cmd_name_len = cmd_obj->GetCommandName().size();
     if (actual_cmd_name_len < command_string.length())
-      remainder = command_string.substr(actual_cmd_name_len);
+      parsed_command_args = command_string.substr(actual_cmd_name_len);
 
     // Remove any initial spaces
-    size_t pos = remainder.find_first_not_of(k_white_space);
+    size_t pos = parsed_command_args.find_first_not_of(k_white_space);
     if (pos != 0 && pos != std::string::npos)
-      remainder.erase(0, pos);
+      parsed_command_args.erase(0, pos);
 
     LLDB_LOGF(
         log, "HandleCommand, command line after removing command name(s): '%s'",
-        remainder.c_str());
+        parsed_command_args.c_str());
 
     // To test whether or not transcript should be saved, `transcript_item` is
     // used instead of `GetSaveTranscript()`. This is because the latter will
     // fail when the command is "settings set interpreter.save-transcript true".
     if (transcript_item) {
       transcript_item->AddStringItem("commandName", cmd_obj->GetCommandName());
-      transcript_item->AddStringItem("commandArguments", remainder);
+      transcript_item->AddStringItem("commandArguments", parsed_command_args);
     }
 
     ElapsedTime elapsed(execute_time);
     cmd_obj->SetOriginalCommandString(real_original_command_string);
     // Set the indent to the position of the command in the command line.
-    pos = real_original_command_string.rfind(remainder);
+    pos = real_original_command_string.rfind(parsed_command_args);
     std::optional<uint16_t> indent;
     if (pos != std::string::npos)
       indent = pos;
     result.SetDiagnosticIndent(indent);
-    cmd_obj->Execute(remainder.c_str(), result);
+    cmd_obj->Execute(parsed_command_args.c_str(), result);
   }
 
   LLDB_LOGF(log, "HandleCommand, command %s",