New maintenance category for newly reported issues

README.adoc

@@ -135,8 +135,12 @@ If the `maintenance` section is present, you will get notified about issues
 related to a specific area (e.g. `area/hibernate-orm`)
 that may be stalled and require intervention from maintainers or reporters.
 
-Issues in "maintenance" notifications will be split in three categories:
+Issues in "maintenance" notifications will be split in several categories:
 
+Reported::
+Issues that just got reported in your area.
++
+Please review, ask for reproducer/information, or plan.
 Feedback Needed::
 Issues with missing reproducer/information.
 +
@@ -164,6 +168,8 @@ participants:
     maintenance:
       labels: ["area/hibernate-orm", "area/hibernate-search", "area/elasticsearch"]
       days: ["MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY"]
+      reported:
+        maxIssues: 5
       feedback:
         needed:
           maxIssues: 4
@@ -182,21 +188,26 @@ Array of Strings, mandatory, no default.
 On which days you wish to get notified about maintenance.
 +
 Array of ``WeekDay``s, mandatory, no default.
+`reported.maxIssues`::
+How many issues, at most, you wish to be included in the "Reported" category
+for each notification.
++
+Integer, mandatory if the `reported` section is present, no default.
 `feedback.needed.maxIssues`::
 How many issues, at most, you wish to be included in the "Feedback needed" category
 for each notification.
 +
-Integer, mandatory, no default.
+Integer, mandatory if the `feedback` section is present, no default.
 `feedback.provided.maxIssues`::
 How many issues, at most, you wish to be included in the "Feedback provided" category
 for each notification.
 +
-Integer, mandatory, no default.
+Integer, mandatory if the `feedback` section is present, no default.
 `stale.maxIssues`::
 How many issues, at most, you wish to be included in the "Stale" category
 for each notification.
 +
-Integer, mandatory, no default.
+Integer, mandatory if the `stale` section is present, no default.
 
 [[participants-stewardship]]
 === Stewardship
@@ -291,6 +302,11 @@ buckets:
     delay: PT0S
     timeout: P3D
   maintenance:
+    reported:
+      delay: PT0S
+      timeout: P1D
+      expiry: P14D
+      ignoreLabels: ["triage/on-ice"]
     feedback:
       labels: ["triage/needs-reproducer"]
       needed:
@@ -328,6 +344,28 @@ How much time to wait after an issue was last notified about
 before including it again in the lottery in the "triage" bucket.
 +
 String in https://en.wikipedia.org/wiki/ISO_8601#Durations[ISO-8601 duration format], mandatory, no default.
++
+`buckets.maintenance.reported.delay`::
+How much time to wait after the creation of an issue
+before including it in the lottery in the "reported" bucket.
++
+String in https://en.wikipedia.org/wiki/ISO_8601#Durations[ISO-8601 duration format], mandatory, no default.
+`buckets.maintenance.reported.timeout`::
+How much time to wait after an issue was last notified about
+before including it again in the lottery in the "reported" bucket.
++
+String in https://en.wikipedia.org/wiki/ISO_8601#Durations[ISO-8601 duration format], mandatory, no default.
++
+`buckets.maintenance.reported.expiry`::
+How much time to wait after the creation of an issue
+before excluding it from the lottery in the "reported" bucket.
++
+String in https://en.wikipedia.org/wiki/ISO_8601#Durations[ISO-8601 duration format], mandatory, no default.
+`buckets.maintenance.reported.ignoreLabels`::
+The labels identifying GitHub issues that should be ignored for the "reported" bucket.
+Issues with one of these labels will never be added to the bucket.
++
+Array of Strings, optional, defaults to an empty array.
 `buckets.maintenance.feedback.labels`::
 The labels identifying GitHub issues for which feedback (a reproducer, more information, ...) was requested.
 +

src/main/java/io/quarkus/github/lottery/LotteryService.java

@@ -7,13 +7,18 @@
 import java.time.ZoneOffset;
 import java.time.ZonedDateTime;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Optional;
+import java.util.Set;
 
 import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.inject.Inject;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import io.quarkus.github.lottery.config.LotteryConfig;
 import io.quarkus.github.lottery.draw.DrawRef;
 import io.quarkus.github.lottery.draw.Lottery;
@@ -32,6 +37,7 @@
 @ApplicationScoped
 public class LotteryService {
 
+    private static final Logger log = LoggerFactory.getLogger(LotteryService.class);
     @Inject
     GitHubService gitHubService;
 
@@ -81,7 +87,19 @@ private void doDrawForRepository(GitHubRepository repo, LotteryConfig lotteryCon
         var now = Instant.now(clock);
         var drawRef = new DrawRef(repo.ref(), now);
 
-        Lottery lottery = new Lottery(now, lotteryConfig.buckets());
+        // Note: this map only gives partial information -- some maintainers may not be registered for the lottery.
+        // That's why the information is only used for optimization (to skip issues that we know for sure aren't relevant).
+        var maintainerUsernamesByAreaLabel = new HashMap<String, Set<String>>();
+        for (LotteryConfig.Participant participant : lotteryConfig.participants()) {
+            participant.maintenance().ifPresent(m -> {
+                for (String label : m.labels()) {
+                    maintainerUsernamesByAreaLabel.computeIfAbsent(label, key -> new LinkedHashSet<>())
+                            .add(participant.username());
+                }
+            });
+        }
+
+        Lottery lottery = new Lottery(now, lotteryConfig.buckets(), maintainerUsernamesByAreaLabel);
 
         try (var notifier = notificationService.notifier(drawRef, lotteryConfig.notifications())) {
             var history = historyService.fetch(drawRef, lotteryConfig);

src/main/java/io/quarkus/github/lottery/config/LotteryConfig.java

@@ -58,9 +58,25 @@ public Triage(@JsonProperty(required = true) String label,
         }
 
         public record Maintenance(
+                @JsonProperty(required = true) Reported reported,
                 @JsonProperty(required = true) Feedback feedback,
                 @JsonProperty(required = true) Stale stale) {
 
+            public record Reported(
+                    @JsonUnwrapped @JsonProperty(access = JsonProperty.Access.READ_ONLY) Notification notification,
+                    @JsonProperty(required = true) Duration expiry,
+                    @JsonProperty(required = true) List<String> ignoreLabels) {
+                // https://stackoverflow.com/a/71539100/6692043
+                // Also gives us a less verbose constructor for tests
+                @JsonCreator
+                public Reported(@JsonProperty(required = true) Duration delay,
+                        @JsonProperty(required = true) Duration timeout,
+                        @JsonProperty(required = true) Duration expiry,
+                        @JsonProperty(required = false) List<String> ignoreLabels) {
+                    this(new Notification(delay, timeout), expiry, ignoreLabels == null ? List.of() : ignoreLabels);
+                }
+            }
+
             public record Feedback(
                     @JsonProperty(required = true) List<String> labels,
                     @JsonProperty(required = true) Needed needed,
@@ -141,6 +157,7 @@ public record Maintenance(
                 // TODO default to all labels configured for this user in .github/quarkus-bot.yml
                 @JsonProperty(required = true) List<String> labels,
                 @JsonProperty(required = true) @JsonDeserialize(as = TreeSet.class) Set<DayOfWeek> days,
+                @JsonProperty Optional<Participation> reported,
                 Optional<Feedback> feedback,
                 @JsonProperty Optional<Participation> stale) {
             public record Feedback(

src/main/java/io/quarkus/github/lottery/draw/Lottery.java

@@ -27,14 +27,16 @@ public final class Lottery {
 
     private final Instant now;
     private final LotteryConfig.Buckets config;
+    private final Map<String, Set<String>> maintainerUsernamesByAreaLabel;
     private final Random random;
     private final Triage triage;
     private final Map<String, Maintenance> maintenanceByLabel;
     private final Stewardship stewardship;
 
-    public Lottery(Instant now, LotteryConfig.Buckets config) {
+    public Lottery(Instant now, LotteryConfig.Buckets config, Map<String, Set<String>> maintainerUsernamesByAreaLabel) {
         this.now = now;
         this.config = config;
+        this.maintainerUsernamesByAreaLabel = maintainerUsernamesByAreaLabel;
         this.random = new Random();
         this.triage = new Triage();
         this.maintenanceByLabel = new LinkedHashMap<>();
@@ -46,7 +48,11 @@ Bucket triage() {
     }
 
     Maintenance maintenance(String areaLabel) {
-        return maintenanceByLabel.computeIfAbsent(areaLabel, Maintenance::new);
+        return maintenanceByLabel.computeIfAbsent(areaLabel, this::createMaintenance);
+    }
+
+    private Maintenance createMaintenance(String areaLabel) {
+        return new Maintenance(areaLabel, maintainerUsernamesByAreaLabel.getOrDefault(areaLabel, Set.of()));
     }
 
     Bucket stewardship() {
@@ -105,18 +111,30 @@ void createDraws(GitHubRepository repo, LotteryHistory lotteryHistory, List<Draw
 
     final class Maintenance {
         private final String areaLabel;
+        private final Set<String> maintainerUsernames;
+        private final Bucket reported;
         private final Bucket feedbackNeeded;
         private final Bucket feedbackProvided;
         private final Bucket stale;
 
-        Maintenance(String areaLabel) {
+        Maintenance(String areaLabel, Set<String> maintainerUsernames) {
             this.areaLabel = areaLabel;
+            this.maintainerUsernames = maintainerUsernames;
             String namePrefix = "maintenance - '" + areaLabel + "' - ";
+            reported = new Bucket(namePrefix + "reported");
             feedbackNeeded = new Bucket(namePrefix + "feedbackNeeded");
             feedbackProvided = new Bucket(namePrefix + "feedbackProvided");
             stale = new Bucket(namePrefix + "stale");
         }
 
+        public void addMaintainer(String username) {
+            maintainerUsernames.add(username);
+        }
+
+        Bucket reported() {
+            return reported;
+        }
+
         Bucket feedbackNeeded() {
             return feedbackNeeded;
         }
@@ -131,6 +149,23 @@ Bucket stale() {
 
         void createDraws(GitHubRepository repo, LotteryHistory lotteryHistory, List<Draw> draws,
                 Set<Integer> allWinnings) throws IOException {
+            if (reported.hasParticipation()) {
+                var maxCutoff = now.minus(config.maintenance().reported().notification().delay());
+                var minCutoff = now.minus(config.maintenance().reported().expiry());
+                // Remove duplicates, but preserve order
+                var ignoreLabels = new LinkedHashSet<String>();
+                // Ignore issues with feedback request labels,
+                // since they evidently got some attention from the team already.
+                ignoreLabels.addAll(config.maintenance().feedback().labels());
+                ignoreLabels.addAll(config.maintenance().reported().ignoreLabels());
+                var history = lotteryHistory.reported();
+                draws.add(reported.createDraw(
+                        repo.issuesNeverActedOnByTeamAndCreatedBetween(areaLabel, ignoreLabels, maintainerUsernames, minCutoff,
+                                maxCutoff)
+                                .filter(issue -> history.lastNotificationTimedOutForIssueNumber(issue.number()))
+                                .iterator(),
+                        allWinnings));
+            }
             // Remove duplicates, but preserve order
             Set<String> needFeedbackLabels = new LinkedHashSet<>(config.maintenance().feedback().labels());
             if (feedbackNeeded.hasParticipation()) {

src/main/java/io/quarkus/github/lottery/draw/LotteryReport.java

@@ -20,13 +20,14 @@ public record LotteryReport(
         Optional<ZoneId> timezone,
         Config config,
         Optional<Bucket> triage,
+        Optional<Bucket> reported,
         Optional<Bucket> feedbackNeeded,
         Optional<Bucket> feedbackProvided,
         Optional<Bucket> stale,
         Optional<Bucket> stewardship) {
 
     Stream<Bucket> buckets() {
-        return Stream.of(triage, feedbackNeeded, feedbackProvided, stale, stewardship)
+        return Stream.of(triage, reported, feedbackNeeded, feedbackProvided, stale, stewardship)
                 .filter(Optional::isPresent)
                 .map(Optional::get);
     }
@@ -59,6 +60,7 @@ public record Serialized(
 
     public Serialized serialized() {
         return new Serialized(drawRef.instant(), username, triage.map(Bucket::serialized),
+                reported.map(Bucket::serialized),
                 feedbackNeeded.map(Bucket::serialized),
                 feedbackProvided.map(Bucket::serialized),
                 stale.map(Bucket::serialized),
@@ -69,6 +71,7 @@ public record Serialized(
             Instant instant,
             String username,
             Optional<Bucket.Serialized> triage,
+            Optional<Bucket.Serialized> reported,
             @JsonAlias("reproducerNeeded") Optional<Bucket.Serialized> feedbackNeeded,
             @JsonAlias("reproducerProvided") Optional<Bucket.Serialized> feedbackProvided,
             Optional<Bucket.Serialized> stale,

src/main/java/io/quarkus/github/lottery/draw/Participant.java

@@ -84,6 +84,7 @@ public LotteryReport report(String triageLabel, Set<String> feedbackLabels) {
                         feedbackLabels,
                         maintenance.map(m -> m.labels).orElseGet(Set::of)),
                 triage.map(Participation::issues).map(LotteryReport.Bucket::new),
+                maintenance.flatMap(m -> m.reported).map(Participation::issues).map(LotteryReport.Bucket::new),
                 maintenance.flatMap(m -> m.feedbackNeeded).map(Participation::issues).map(LotteryReport.Bucket::new),
                 maintenance.flatMap(m -> m.feedbackProvided).map(Participation::issues).map(LotteryReport.Bucket::new),
                 maintenance.flatMap(m -> m.stale).map(Participation::issues).map(LotteryReport.Bucket::new),
@@ -92,31 +93,39 @@ public LotteryReport report(String triageLabel, Set<String> feedbackLabels) {
 
     private static final class Maintenance {
         public static Optional<Maintenance> create(String username, LotteryConfig.Participant.Maintenance config) {
+            var reported = config.reported()
+                    .flatMap(p -> Participation.create(username, p));
             var feedbackNeeded = config.feedback().map(LotteryConfig.Participant.Maintenance.Feedback::needed)
                     .flatMap(p -> Participation.create(username, p));
             var feedbackProvided = config.feedback().map(LotteryConfig.Participant.Maintenance.Feedback::provided)
                     .flatMap(p -> Participation.create(username, p));
             var stale = config.stale()
                     .flatMap(p -> Participation.create(username, p));
 
-            if (feedbackNeeded.isEmpty() && feedbackProvided.isEmpty() && stale.isEmpty()) {
+            if (reported.isEmpty() && feedbackNeeded.isEmpty() && feedbackProvided.isEmpty() && stale.isEmpty()) {
                 return Optional.empty();
             }
 
-            return Optional.of(new Maintenance(config.labels(), feedbackNeeded, feedbackProvided, stale));
+            return Optional.of(new Maintenance(username, config.labels(), reported, feedbackNeeded, feedbackProvided, stale));
         }
 
+        private final String username;
         private final Set<String> labels;
 
+        private final Optional<Participation> reported;
         private final Optional<Participation> feedbackNeeded;
         private final Optional<Participation> feedbackProvided;
         private final Optional<Participation> stale;
 
-        private Maintenance(List<String> labels, Optional<Participation> feedbackNeeded,
+        private Maintenance(String username, List<String> labels,
+                Optional<Participation> reported,
+                Optional<Participation> feedbackNeeded,
                 Optional<Participation> feedbackProvided,
                 Optional<Participation> stale) {
+            this.username = username;
             // Remove duplicates, but preserve order
             this.labels = new LinkedHashSet<>(labels);
+            this.reported = reported;
             this.feedbackNeeded = feedbackNeeded;
             this.feedbackProvided = feedbackProvided;
             this.stale = stale;
@@ -125,6 +134,7 @@ private Maintenance(List<String> labels, Optional<Participation> feedbackNeeded,
         public void participate(Lottery lottery) {
             for (String label : labels) {
                 Lottery.Maintenance maintenance = lottery.maintenance(label);
+                reported.ifPresent(maintenance.reported()::participate);
                 feedbackNeeded.ifPresent(maintenance.feedbackNeeded()::participate);
                 feedbackProvided.ifPresent(maintenance.feedbackProvided()::participate);
                 stale.ifPresent(maintenance.stale()::participate);