Adding --log-diffs-include-activity-ids

Author: thomasjm

src/libmain/loggers.cc

@@ -3,10 +3,43 @@
 #include "nix/util/environment-variables.hh"
 #include "nix/main/progress-bar.hh"
 
+#include <sstream>
+
 namespace nix {
 
 LogFormat defaultLogFormat = LogFormat::raw;
 
+std::optional<std::set<ActivityType>> diffActivitiesToInclude = std::nullopt;
+
+static void parseActivityIds(const std::string & activityIdsStr)
+{
+    if (activityIdsStr.empty()) {
+        diffActivitiesToInclude = std::nullopt;
+        return;
+    }
+
+    std::set<ActivityType> activityTypes;
+    std::stringstream ss(activityIdsStr);
+    std::string item;
+
+    while (std::getline(ss, item, ',')) {
+        // Trim whitespace
+        item.erase(item.find_last_not_of(" \t\n\r\f\v") + 1);
+        item.erase(0, item.find_first_not_of(" \t\n\r\f\v"));
+
+        if (!item.empty()) {
+            try {
+                int activityTypeInt = std::stoi(item);
+                activityTypes.insert(static_cast<ActivityType>(activityTypeInt));
+            } catch (const std::exception& e) {
+                throw Error("invalid activity type '%s' in activity IDs list", item);
+            }
+        }
+    }
+
+    diffActivitiesToInclude = activityTypes;
+}
+
 LogFormat parseLogFormat(const std::string & logFormatStr)
 {
     if (logFormatStr == "raw" || getEnv("NIX_GET_COMPLETIONS"))
@@ -15,8 +48,15 @@ LogFormat parseLogFormat(const std::string & logFormatStr)
         return LogFormat::rawWithLogs;
     else if (logFormatStr == "internal-json")
         return LogFormat::internalJSON;
-    else if (logFormatStr == "diffs")
+    else if (logFormatStr == "diffs") {
+        diffActivitiesToInclude = std::nullopt;
         return LogFormat::diffs;
+    }
+    else if (logFormatStr.starts_with("diffs;")) {
+        std::string activityIdsPart = logFormatStr.substr(6);
+        parseActivityIds(activityIdsPart);
+        return LogFormat::diffs;
+    }
     else if (logFormatStr == "bar")
         return LogFormat::bar;
     else if (logFormatStr == "bar-with-logs")
@@ -34,7 +74,7 @@ std::unique_ptr<Logger> makeDefaultLogger()
     case LogFormat::internalJSON:
         return makeJSONLogger(getStandardError());
     case LogFormat::diffs:
-        return makeDiffLogger(getStandardError());
+        return makeDiffLogger(getStandardError(), diffActivitiesToInclude);
     case LogFormat::bar:
         return makeProgressBar();
     case LogFormat::barWithLogs: {

src/libutil/include/nix/util/logging-diffs.hh

@@ -10,10 +10,12 @@
 #include <list>
 #include <map>
 #include <optional>
+#include <set>
 
 namespace nix {
 
 std::unique_ptr<Logger> makeDiffLogger(Descriptor fd);
+std::unique_ptr<Logger> makeDiffLogger(Descriptor fd, std::optional<std::set<ActivityType>> activity_types_to_include);
 
 struct ActivityState {
     bool isComplete;
@@ -45,6 +47,7 @@ struct NixMessage {
 
 struct NixBuildState {
     std::map<ActivityId, ActivityState> activities;
+    std::set<ActivityId> ignored_activites;
     std::list<NixMessage> messages;
 };
 

src/libutil/logging-diffs.cc

@@ -91,6 +91,7 @@ static void posToJson(json & json, std::shared_ptr<const Pos> pos)
 
 struct DiffLogger : Logger {
     Descriptor fd;
+    std::optional<std::set<ActivityType>> activity_types_to_include;
 
     Sync<NixBuildState> state;
     json last_sent;
@@ -99,8 +100,9 @@ struct DiffLogger : Logger {
     std::atomic_bool exited;
     std::thread printerThread;
 
-    DiffLogger(Descriptor fd)
+    DiffLogger(Descriptor fd, std::optional<std::set<ActivityType>> activity_types_to_include)
         : fd(fd)
+        , activity_types_to_include(activity_types_to_include)
         , last_sent(nullptr)
         , exitPeriodicAction(false)
         , exited(false)
@@ -209,30 +211,49 @@ struct DiffLogger : Logger {
         const std::string & s, const Fields & fields, ActivityId parent) override
     {
         ActivityState as(type, s, fields, parent);
+
         auto state_(state.lock());
-        state_->activities.insert(std::pair<ActivityId, ActivityState>(act, as));
+
+        if (!activity_types_to_include || activity_types_to_include->contains(type)) {
+            state_->activities.insert(std::pair<ActivityId, ActivityState>(act, as));
+        } else {
+            state_->ignored_activites.insert(act);
+        }
     }
 
     void stopActivity(ActivityId act) override
     {
         auto state_(state.lock());
-        try { state_->activities.at(act).isComplete = true; }
-        catch (const std::out_of_range& oor) { }
+
+        if (activity_types_to_include && state_->ignored_activites.contains(act)) {
+            state_->ignored_activites.erase(act);
+        } else {
+            try { state_->activities.at(act).isComplete = true; }
+            catch (const std::out_of_range& oor) { }
+        }
     }
 
     void result(ActivityId act, ResultType type, const Fields & fields) override
     {
         auto state_(state.lock());
-        try { state_->activities.at(act).fields = fields; }
-        catch (const std::out_of_range& oor) {
-            Logger::writeToStdout("Failed to look up result of type " + std::to_string(static_cast<int>(type)));
+
+        if (!activity_types_to_include || !state_->ignored_activites.contains(act)) {
+            try { state_->activities.at(act).fields = fields; }
+            catch (const std::out_of_range& oor) {
+                Logger::writeToStdout("Failed to look up activity " + std::to_string(static_cast<int>(type)) + " to write result of type " + std::to_string(static_cast<int>(type)));
+            }
         }
     }
 };
 
+std::unique_ptr<Logger> makeDiffLogger(Descriptor fd, std::optional<std::set<ActivityType>> activity_types_to_include)
+{
+    return std::make_unique<DiffLogger>(fd, activity_types_to_include);
+}
+
 std::unique_ptr<Logger> makeDiffLogger(Descriptor fd)
 {
-    return std::make_unique<DiffLogger>(fd);
+    return std::make_unique<DiffLogger>(fd, std::nullopt);
 }
 
 }