csgrep --warning-rate-limit: stop processing a warning

... if the count of its occurrences exceeds the specified limit

Resolves: #119

Author: kdudka

src/csgrep.cc

@@ -555,6 +555,7 @@ int main(int argc, char *argv[])
             ("drop-scan-props",                                 "do not propagate scan properties")
             ("embed-context,U",     po::value<int>(),           "embed a number of lines of context from the source file for the key event")
             ("prune-events",        po::value<int>(),           "event is preserved if its verbosity level is below the given number")
+            ("warning-rate-limit",  po::value<int>(),           "stop processing a warning if the count of its occurrences exceeds the specified limit")
             ("remove-duplicates,u",                             "remove defects that are not unique by their key event")
             ("set-scan-prop",       po::value<TStringList>(),   "NAME:VALUE pair to override the specified scan property")
             ("strip-path-prefix",   po::value<string>(),        "string prefix to strip from path (applied after all filters)")
@@ -658,6 +659,7 @@ int main(int argc, char *argv[])
         eng = new DuplicateFilter(eng);
 
     if (!chainDecoratorIntArg<EventPrunner>(&eng, vm, "prune-events")
+            || !chainDecoratorIntArg<RateLimitter>(&eng, vm, "warning-rate-limit")
             || !chainDecoratorIntArg<CtxEmbedder>(&eng, vm, "embed-context"))
         // error message already printed, eng already feeed
         return 1;

src/lib/filter.cc

@@ -203,3 +203,78 @@ bool DuplicateFilter::matchDef(const Defect &def)
 
     return d->lookup.insert(evt)./* inserted */second;
 }
+
+
+// /////////////////////////////////////////////////////////////////////////////
+// implementation of RateLimitter
+
+struct RateLimitter::Private {
+    using TKey = std::pair<std::string, std::string>;
+    using TCnt = int;
+    using TMap = std::map<TKey, TCnt>;
+    TMap counter;
+    TCnt rateLimit;
+};
+
+RateLimitter::RateLimitter(AbstractWriter *agent, int rateLimit):
+    AbstractFilter(agent),
+    d(new Private)
+{
+    d->rateLimit = rateLimit;
+}
+
+bool RateLimitter::matchDef(const Defect &def)
+{
+    // resolve the checker/event pair for the key event
+    const DefEvent &evt = def.events[def.keyEventIdx];
+    const Private::TKey key(def.checker, evt.event);
+
+    // increment the counter and get the current value
+    const Private::TCnt cnt = ++d->counter[key];
+
+    // check whether the specified limit is exceeded
+    return (cnt < d->rateLimit);
+}
+
+void RateLimitter::flush()
+{
+    for (const auto &item : d->counter) {
+        const Private::TCnt cnt = item.second;
+        if (cnt < d->rateLimit)
+            // limit not exceeded for this checker/event pair
+            continue;
+
+        // resolve the checker/event pair
+        const Private::TKey &key = item.first;
+        const std::string &checker = key.first;
+        const std::string &keyEvtName = key.second;
+
+        // construct an error event
+        std::ostringstream err, note;
+        err << cnt << " occurrences of " << keyEvtName
+            << " exceeded the specified limit "
+            << d->rateLimit;
+
+        DefEvent evtErr("error[too-many]");
+        evtErr.msg = err.str();
+
+        // construct a note event
+        note << (cnt - d->rateLimit) << " occurrences of "
+            << keyEvtName << " were discarded because of this";
+
+        DefEvent evtNote("note");
+        evtNote.msg = note.str();
+        evtNote.verbosityLevel = /* info */ 1;
+
+        // construct a defect containing the above events
+        Defect def(checker);
+        def.events.push_back(evtErr);
+        def.events.push_back(evtNote);
+
+        // process the newly constructed defect by the chain of writers
+        GenericAbstractFilter::handleDef(def);
+    }
+
+    // forward the call through the chain of writers
+    AbstractFilter::flush();
+}

src/lib/filter.hh

@@ -162,4 +162,19 @@ class DuplicateFilter: public AbstractFilter {
         std::unique_ptr<Private> d;
 };
 
+/// collapses warnings if their count exceeds the specified limit
+class RateLimitter: public AbstractFilter {
+    public:
+        RateLimitter(AbstractWriter *agent, int rateLimit);
+        ~RateLimitter() override = default;
+        void flush() override;
+
+    protected:
+        bool matchDef(const Defect &) override;
+
+    private:
+        struct Private;
+        std::unique_ptr<Private> d;
+};
+
 #endif /* H_GUARD_FILTER_H */

tests/csgrep/0110-warning-rate-limit-args.txt

@@ -0,0 +1 @@
+--mode=json --warning-rate-limit=16