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

Author: thomasjm

src/libmain/common-args.cc

@@ -71,6 +71,14 @@ MixCommonArgs::MixCommonArgs(const std::string & programName)
         .handler = {[](std::string format) { setLogFormat(format); }},
     });
 
+    addFlag({
+        .longName = "log-diffs-include-activity-ids",
+        .description = "Comma-separated list of activity IDs to include when using 'diffs' logging.",
+        .category = loggingCategory,
+        .labels = {"diffs-include-activity-ids"},
+        .handler = {[](std::string format) { setLogDiffsIncludeActivityIds(format); }},
+    });
+
     addFlag({
         .longName = "max-jobs",
         .shortName = 'j',

src/libmain/include/nix/main/loggers.hh

@@ -17,4 +17,6 @@ enum class LogFormat {
 void setLogFormat(const std::string & logFormatStr);
 void setLogFormat(const LogFormat & logFormat);
 
+void setLogDiffsIncludeActivityIds(const std::string & activityIdsStr);
+
 } // namespace nix

src/libmain/loggers.cc

@@ -3,10 +3,14 @@
 #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;
+
 LogFormat parseLogFormat(const std::string & logFormatStr)
 {
     if (logFormatStr == "raw" || getEnv("NIX_GET_COMPLETIONS"))
@@ -34,7 +38,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: {
@@ -58,4 +62,37 @@ void setLogFormat(const LogFormat & logFormat)
     logger = makeDefaultLogger();
 }
 
+void setLogDiffsIncludeActivityIds(const std::string & activityIdsStr)
+{
+    if (activityIdsStr.empty()) {
+        diffActivitiesToInclude = std::nullopt;
+    } else {
+        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;
+    }
+
+    // If we're currently using diffs format, recreate the logger with the new filter
+    if (defaultLogFormat == LogFormat::diffs) {
+        logger = makeDefaultLogger();
+    }
+}
+
 } // namespace nix

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);
 }
 
 }