Add package monitoring for active domain limits (#1867)

* Add monitoring for package active domain limits

* Reformat action class

* Fix a bunch of nits

* Change native query to HQL

core/src/main/java/google/registry/batch/CheckPackagesComplianceAction.java

@@ -15,8 +15,10 @@ package google.registry.batch;
 
 import static com.google.common.collect.ImmutableList.toImmutableList;
 import static google.registry.persistence.transaction.TransactionManagerFactory.tm;
+import static google.registry.util.DateTimeUtils.END_OF_TIME;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
 import com.google.common.flogger.FluentLogger;
 import com.google.common.primitives.Ints;
 import google.registry.config.RegistryConfig.Config;
@@ -28,8 +30,10 @@ import google.registry.request.Action;
 import google.registry.request.Action.Service;
 import google.registry.request.auth.Auth;
 import google.registry.ui.server.SendEmailUtils;
+import google.registry.util.Clock;
 import java.util.Optional;
 import javax.inject.Inject;
+import org.joda.time.Days;
 
 /**
  * An action that checks all {@link PackagePromotion} objects for compliance with their max create
@@ -44,77 +48,164 @@ public class CheckPackagesComplianceAction implements Runnable {
   public static final String PATH = "/_dr/task/checkPackagesCompliance";
   private static final FluentLogger logger = FluentLogger.forEnclosingClass();
   private final SendEmailUtils sendEmailUtils;
-  private final String packageCreateLimitEmailSubjectText;
-  private final String packageCreateLimitEmailBodyText;
+  private final Clock clock;
+  private final String packageCreateLimitEmailSubject;
+  private final String packageDomainLimitWarningEmailSubject;
+  private final String packageDomainLimitUpgradeEmailSubject;
+  private final String packageCreateLimitEmailBody;
+  private final String packageDomainLimitWarningEmailBody;
+  private final String packageDomainLimitUpgradeEmailBody;
   private final String registrySupportEmail;
+  private static final int THIRTY_DAYS = 30;
+  private static final int FORTY_DAYS = 40;
 
   @Inject
   public CheckPackagesComplianceAction(
       SendEmailUtils sendEmailUtils,
-      @Config("packageCreateLimitEmailSubjectText") String packageCreateLimitEmailSubjectText,
-      @Config("packageCreateLimitEmailBodyText") String packageCreateLimitEmailBodyText,
+      Clock clock,
+      @Config("packageCreateLimitEmailSubject") String packageCreateLimitEmailSubject,
+      @Config("packageDomainLimitWarningEmailSubject") String packageDomainLimitWarningEmailSubject,
+      @Config("packageDomainLimitUpgradeEmailSubject") String packageDomainLimitUpgradeEmailSubject,
+      @Config("packageCreateLimitEmailBody") String packageCreateLimitEmailBody,
+      @Config("packageDomainLimitWarningEmailBody") String packageDomainLimitWarningEmailBody,
+      @Config("packageDomainLimitUpgradeEmailBody") String packageDomainLimitUpgradeEmailBody,
       @Config("registrySupportEmail") String registrySupportEmail) {
     this.sendEmailUtils = sendEmailUtils;
-    this.packageCreateLimitEmailSubjectText = packageCreateLimitEmailSubjectText;
-    this.packageCreateLimitEmailBodyText = packageCreateLimitEmailBodyText;
+    this.clock = clock;
+    this.packageCreateLimitEmailSubject = packageCreateLimitEmailSubject;
+    this.packageDomainLimitWarningEmailSubject = packageDomainLimitWarningEmailSubject;
+    this.packageDomainLimitUpgradeEmailSubject = packageDomainLimitUpgradeEmailSubject;
+    this.packageCreateLimitEmailBody = packageCreateLimitEmailBody;
+    this.packageDomainLimitWarningEmailBody = packageDomainLimitWarningEmailBody;
+    this.packageDomainLimitUpgradeEmailBody = packageDomainLimitUpgradeEmailBody;
     this.registrySupportEmail = registrySupportEmail;
   }
 
   @Override
   public void run() {
-    tm().transact(
-            () -> {
-              ImmutableList<PackagePromotion> packages = tm().loadAllOf(PackagePromotion.class);
-              ImmutableList.Builder<PackagePromotion> packagesOverCreateLimit =
-                  new ImmutableList.Builder<>();
-              for (PackagePromotion packagePromo : packages) {
-                Long creates =
-                    (Long)
-                        tm().query(
-                                "SELECT COUNT(*) FROM DomainHistory WHERE current_package_token ="
-                                    + " :token AND modificationTime >= :lastBilling AND type ="
-                                    + " 'DOMAIN_CREATE'")
-                            .setParameter("token", packagePromo.getToken().getKey().toString())
-                            .setParameter(
-                                "lastBilling", packagePromo.getNextBillingDate().minusYears(1))
-                            .getSingleResult();
-                if (creates > packagePromo.getMaxCreates()) {
-                  int overage = Ints.saturatedCast(creates) - packagePromo.getMaxCreates();
-                  logger.atInfo().log(
-                      "Package with package token %s has exceeded their max domain creation limit"
-                          + " by %d name(s).",
-                      packagePromo.getToken().getKey(), overage);
-                  packagesOverCreateLimit.add(packagePromo);
-                }
-              }
-              if (packagesOverCreateLimit.build().isEmpty()) {
-                logger.atInfo().log("Found no packages over their create limit.");
-              } else {
-                logger.atInfo().log(
-                    "Found %d packages over their create limit.",
-                    packagesOverCreateLimit.build().size());
-                for (PackagePromotion packagePromotion : packagesOverCreateLimit.build()) {
-                  AllocationToken packageToken = tm().loadByKey(packagePromotion.getToken());
-                  Optional<Registrar> registrar =
-                      Registrar.loadByRegistrarIdCached(
-                          packageToken.getAllowedRegistrarIds().iterator().next());
-                  if (registrar.isPresent()) {
-                    String body =
-                        String.format(
-                            packageCreateLimitEmailBodyText,
-                            registrar.get().getRegistrarName(),
-                            packageToken.getToken(),
-                            registrySupportEmail);
-                    sendNotification(
-                        packageToken, packageCreateLimitEmailSubjectText, body, registrar.get());
-                  } else {
-                    logger.atSevere().log(
-                        String.format(
-                            "Could not find registrar for package token %s", packageToken));
-                  }
-                }
-              }
-            });
+    tm().transact(this::checkPackages);
+  }
+
+  private void checkPackages() {
+    ImmutableList<PackagePromotion> packages = tm().loadAllOf(PackagePromotion.class);
+    ImmutableList.Builder<PackagePromotion> packagesOverCreateLimitBuilder =
+        new ImmutableList.Builder<>();
+    ImmutableList.Builder<PackagePromotion> packagesOverActiveDomainsLimitBuilder =
+        new ImmutableList.Builder<>();
+    for (PackagePromotion packagePromo : packages) {
+      Long creates =
+          (Long)
+              tm().query(
+                      "SELECT COUNT(*) FROM DomainHistory WHERE current_package_token ="
+                          + " :token AND modificationTime >= :lastBilling AND type ="
+                          + " 'DOMAIN_CREATE'")
+                  .setParameter("token", packagePromo.getToken().getKey().toString())
+                  .setParameter("lastBilling", packagePromo.getNextBillingDate().minusYears(1))
+                  .getSingleResult();
+      if (creates > packagePromo.getMaxCreates()) {
+        int overage = Ints.saturatedCast(creates) - packagePromo.getMaxCreates();
+        logger.atInfo().log(
+            "Package with package token %s has exceeded their max domain creation limit"
+                + " by %d name(s).",
+            packagePromo.getToken().getKey(), overage);
+        packagesOverCreateLimitBuilder.add(packagePromo);
+      }
+
+      Long activeDomains =
+          tm().query(
+                  "SELECT COUNT(*) FROM Domain WHERE currentPackageToken = :token"
+                      + " AND deletionTime = :endOfTime",
+                  Long.class)
+              .setParameter("token", packagePromo.getToken())
+              .setParameter("endOfTime", END_OF_TIME)
+              .getSingleResult();
+      if (activeDomains > packagePromo.getMaxDomains()) {
+        int overage = Ints.saturatedCast(activeDomains) - packagePromo.getMaxDomains();
+        logger.atInfo().log(
+            "Package with package token %s has exceed their max active domains limit by"
+                + " %d name(s).",
+            packagePromo.getToken().getKey(), overage);
+        packagesOverActiveDomainsLimitBuilder.add(packagePromo);
+      }
+    }
+    handlePackageCreationOverage(packagesOverCreateLimitBuilder.build());
+    handleActiveDomainOverage(packagesOverActiveDomainsLimitBuilder.build());
+  }
+
+  private void handlePackageCreationOverage(ImmutableList<PackagePromotion> overageList) {
+    if (overageList.isEmpty()) {
+      logger.atInfo().log("Found no packages over their create limit.");
+      return;
+    }
+    logger.atInfo().log("Found %d packages over their create limit.", overageList.size());
+    for (PackagePromotion packagePromotion : overageList) {
+      AllocationToken packageToken = tm().loadByKey(packagePromotion.getToken());
+      Optional<Registrar> registrar =
+          Registrar.loadByRegistrarIdCached(
+              Iterables.getOnlyElement(packageToken.getAllowedRegistrarIds()));
+      if (registrar.isPresent()) {
+        String body =
+            String.format(
+                packageCreateLimitEmailBody,
+                registrar.get().getRegistrarName(),
+                packageToken.getToken(),
+                registrySupportEmail);
+        sendNotification(packageToken, packageCreateLimitEmailSubject, body, registrar.get());
+      } else {
+        throw new IllegalStateException(
+            String.format("Could not find registrar for package token %s", packageToken));
+      }
+    }
+  }
+
+  private void handleActiveDomainOverage(ImmutableList<PackagePromotion> overageList) {
+    if (overageList.isEmpty()) {
+      logger.atInfo().log("Found no packages over their active domains limit.");
+      return;
+    }
+    logger.atInfo().log("Found %d packages over their active domains limit.", overageList.size());
+    for (PackagePromotion packagePromotion : overageList) {
+      int daysSinceLastNotification =
+          packagePromotion
+              .getLastNotificationSent()
+              .map(sentDate -> Days.daysBetween(sentDate, clock.nowUtc()).getDays())
+              .orElse(Integer.MAX_VALUE);
+      if (daysSinceLastNotification < THIRTY_DAYS) {
+        // Don't send an email if notification was already sent within the last 30
+        // days
+        continue;
+      } else if (daysSinceLastNotification < FORTY_DAYS) {
+        // Send an upgrade email if last email was between 30 and 40 days ago
+        sendActiveDomainOverageEmail(/* warning= */ false, packagePromotion);
+      } else {
+        // Send a warning email
+        sendActiveDomainOverageEmail(/* warning= */ true, packagePromotion);
+      }
+    }
+  }
+
+  private void sendActiveDomainOverageEmail(boolean warning, PackagePromotion packagePromotion) {
+    String emailSubject =
+        warning ? packageDomainLimitWarningEmailSubject : packageDomainLimitUpgradeEmailSubject;
+    String emailTemplate =
+        warning ? packageDomainLimitWarningEmailBody : packageDomainLimitUpgradeEmailBody;
+    AllocationToken packageToken = tm().loadByKey(packagePromotion.getToken());
+    Optional<Registrar> registrar =
+        Registrar.loadByRegistrarIdCached(
+            Iterables.getOnlyElement(packageToken.getAllowedRegistrarIds()));
+    if (registrar.isPresent()) {
+      String body =
+          String.format(
+              emailTemplate,
+              registrar.get().getRegistrarName(),
+              packageToken.getToken(),
+              registrySupportEmail);
+      sendNotification(packageToken, emailSubject, body, registrar.get());
+      tm().put(packagePromotion.asBuilder().setLastNotificationSent(clock.nowUtc()).build());
+    } else {
+      throw new IllegalStateException(
+          String.format("Could not find registrar for package token %s", packageToken));
+    }
   }
 
   private void sendNotification(

core/src/main/java/google/registry/config/RegistryConfig.java

@@ -1317,15 +1317,41 @@ public final class RegistryConfig {
     }
 
     @Provides
-    @Config("packageCreateLimitEmailSubjectText")
-    public static String providePackageCreateLimitEmailSubjectText(RegistryConfigSettings config) {
-      return config.packageMonitoring.packageCreateLimitEmailSubjectText;
+    @Config("packageCreateLimitEmailSubject")
+    public static String providePackageCreateLimitEmailSubject(RegistryConfigSettings config) {
+      return config.packageMonitoring.packageCreateLimitEmailSubject;
     }
 
     @Provides
-    @Config("packageCreateLimitEmailBodyText")
-    public static String providePackageCreateLimitEmailBodyText(RegistryConfigSettings config) {
-      return config.packageMonitoring.packageCreateLimitEmailBodyText;
+    @Config("packageCreateLimitEmailBody")
+    public static String providePackageCreateLimitEmailBody(RegistryConfigSettings config) {
+      return config.packageMonitoring.packageCreateLimitEmailBody;
+    }
+
+    @Provides
+    @Config("packageDomainLimitWarningEmailSubject")
+    public static String providePackageDomainLimitWarningEmailSubject(
+        RegistryConfigSettings config) {
+      return config.packageMonitoring.packageDomainLimitWarningEmailSubject;
+    }
+
+    @Provides
+    @Config("packageDomainLimitWarningEmailBody")
+    public static String providePackageDomainLimitWarningEmailBody(RegistryConfigSettings config) {
+      return config.packageMonitoring.packageDomainLimitWarningEmailBody;
+    }
+
+    @Provides
+    @Config("packageDomainLimitUpgradeEmailSubject")
+    public static String providePackageDomainLimitUpgradeEmailSubject(
+        RegistryConfigSettings config) {
+      return config.packageMonitoring.packageDomainLimitUpgradeEmailSubject;
+    }
+
+    @Provides
+    @Config("packageDomainLimitUpgradeEmailBody")
+    public static String providePackageDomainLimitUpgradeEmailBody(RegistryConfigSettings config) {
+      return config.packageMonitoring.packageDomainLimitUpgradeEmailBody;
     }
   }
 

core/src/main/java/google/registry/config/RegistryConfigSettings.java

@@ -255,7 +255,11 @@ public class RegistryConfigSettings {
 
   /** Configuration for package compliance monitoring. */
   public static class PackageMonitoring {
-    public String packageCreateLimitEmailSubjectText;
-    public String packageCreateLimitEmailBodyText;
+    public String packageCreateLimitEmailSubject;
+    public String packageCreateLimitEmailBody;
+    public String packageDomainLimitWarningEmailSubject;
+    public String packageDomainLimitWarningEmailBody;
+    public String packageDomainLimitUpgradeEmailSubject;
+    public String packageDomainLimitUpgradeEmailBody;
   }
 }

core/src/main/java/google/registry/config/files/default-config.yaml

@@ -536,9 +536,9 @@ sslCertificateValidation:
 # Configuration options for the package compliance monitoring
 packageMonitoring:
   # Email subject text to notify partners their package has exceeded the limit for domain creates
-  packageCreateLimitEmailSubjectText: "NOTICE: Your Package Is Being Upgraded"
+  packageCreateLimitEmailSubject: "NOTICE: Your package is being upgraded"
   # Email body text template notify partners their package has exceeded the limit for domain creates
-  packageCreateLimitEmailBodyText: >
+  packageCreateLimitEmailBody: >
     Dear %1$s,
     
     We are contacting you to inform you that your package with the package token 
@@ -550,3 +550,37 @@ packageMonitoring:
     
     Regards,
     Example Registry
+
+  # Email subject text to notify partners their package has exceeded the limit for current active domains and warn them their package will be upgraded in 30 days
+  packageDomainLimitWarningEmailSubject: "WARNING: Your package has exceeded the domain limit"
+  # Email body text template to warn partners their package has exceeded the limit for active domains and will be upgraded in 30 days
+  packageDomainLimitWarningEmailBody: >
+    Dear %1$s,
+      
+    We are contacting you to inform you that your package with the package token 
+    %2$s has exceeded its limit for active domains.
+    Your package will be upgraded to the next tier in 30 days if the number of active domains does not return below the limit. 
+
+    If you have any questions or require additional support, please contact us
+    at %3$s.
+
+    Regards,
+    Example Registry
+
+  # Email subject text to notify partners their package has exceeded the limit
+  # for current active domains for more than 30 days and will be upgraded
+  packageDomainLimitUpgradeEmailSubject: "NOTICE: Your package is being upgraded"
+  # Email body text template to warn partners their package has exceeded the
+  # limit for active domains for more than 30 days and will be upgraded
+  packageDomainLimitUpgradeEmailBody: >
+    Dear %1$s,
+    
+    We are contacting you to inform you that your package with the package token 
+    %2$s has exceeded its limit for active domains.
+    Your package will now be upgraded to the next tier. 
+
+    If you have any questions or require additional support, please contact us
+    at %3$s.
+
+    Regards,
+    Example Registry