Notification requests per rule rate limits

application/src/main/java/org/thingsboard/server/service/apiusage/limits/DefaultRateLimitService.java

@@ -15,54 +15,81 @@
  */
 package org.thingsboard.server.service.apiusage.limits;
 
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Caffeine;
+import lombok.Data;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.common.data.StringUtils;
+import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.msg.tools.TbRateLimits;
 import org.thingsboard.server.dao.tenant.TbTenantProfileCache;
 
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
+import javax.annotation.PostConstruct;
+import java.util.concurrent.TimeUnit;
 
 @Service
 @RequiredArgsConstructor
+@Slf4j
 public class DefaultRateLimitService implements RateLimitService {
 
     private final TbTenantProfileCache tenantProfileCache;
+    @Value("${cache.rateLimits.timeToLiveInMinutes:60}")
+    private int rateLimitsTtl;
+    @Value("${cache.rateLimits.maxSize:100000}")
+    private int rateLimitsCacheMaxSize;
 
-    private final Map<LimitedApi, Map<TenantId, TbRateLimits>> rateLimits = new ConcurrentHashMap<>();
+    private Cache<RateLimitKey, TbRateLimits> rateLimits;
+
+    @PostConstruct
+    private void init() {
+        rateLimits = Caffeine.newBuilder()
+                .expireAfterAccess(rateLimitsTtl, TimeUnit.MINUTES)
+                .maximumSize(rateLimitsCacheMaxSize)
+                .build();
+    }
+
+    @Override
+    public boolean checkRateLimit(LimitedApi api, TenantId tenantId) {
+        return checkRateLimit(api, tenantId, tenantId);
+    }
 
     @Override
-    public boolean checkRateLimit(TenantId tenantId, LimitedApi api) {
+    public boolean checkRateLimit(LimitedApi api, TenantId tenantId, EntityId entityId) {
         if (tenantId.isSysTenantId()) {
             return true;
         }
+        RateLimitKey key = new RateLimitKey(api, entityId);
+
         String rateLimitConfig = tenantProfileCache.get(tenantId).getProfileConfiguration()
                 .map(api::getLimitConfig).orElse(null);
-
-        Map<TenantId, TbRateLimits> rateLimits = this.rateLimits.get(api);
         if (StringUtils.isEmpty(rateLimitConfig)) {
-            if (rateLimits != null) {
-                rateLimits.remove(tenantId);
-                if (rateLimits.isEmpty()) {
-                    this.rateLimits.remove(api);
-                }
-            }
+            rateLimits.invalidate(key);
             return true;
         }
+        log.trace("[{}] Checking rate limit for {} ({})", entityId, api, rateLimitConfig);
 
-        if (rateLimits == null) {
-            rateLimits = new ConcurrentHashMap<>();
-            this.rateLimits.put(api, rateLimits);
-        }
-        TbRateLimits rateLimit = rateLimits.get(tenantId);
-        if (rateLimit == null || !rateLimit.getConfiguration().equals(rateLimitConfig)) {
-            rateLimit = new TbRateLimits(rateLimitConfig);
-            rateLimits.put(tenantId, rateLimit);
+        TbRateLimits rateLimit = rateLimits.asMap().compute(key, (k, limit) -> {
+            if (limit == null || !limit.getConfiguration().equals(rateLimitConfig)) {
+                limit = new TbRateLimits(rateLimitConfig);
+                log.trace("[{}] Created new rate limit bucket for {} ({})", entityId, api, rateLimitConfig);
+            }
+            return limit;
+        });
+        boolean success = rateLimit.tryConsume();
+        if (!success) {
+            log.debug("[{}] Rate limit exceeded for {} ({})", entityId, api, rateLimitConfig);
         }
+        return success;
+    }
 
-        return rateLimit.tryConsume();
+    @Data(staticConstructor = "of")
+    private static class RateLimitKey {
+        private final LimitedApi api;
+        private final EntityId entityId;
     }
 
 }

application/src/main/java/org/thingsboard/server/service/apiusage/limits/LimitedApi.java

@@ -25,7 +25,8 @@ public enum LimitedApi {
 
     ENTITY_EXPORT(DefaultTenantProfileConfiguration::getTenantEntityExportRateLimit),
     ENTITY_IMPORT(DefaultTenantProfileConfiguration::getTenantEntityImportRateLimit),
-    NOTIFICATION_REQUEST(DefaultTenantProfileConfiguration::getTenantNotificationRequestsRateLimit);
+    NOTIFICATION_REQUESTS(DefaultTenantProfileConfiguration::getTenantNotificationRequestsRateLimit),
+    NOTIFICATION_REQUESTS_PER_RULE(DefaultTenantProfileConfiguration::getTenantNotificationRequestsPerRuleRateLimit);
 
     private final Function<DefaultTenantProfileConfiguration, String> configExtractor;
 

application/src/main/java/org/thingsboard/server/service/apiusage/limits/RateLimitService.java

@@ -15,10 +15,13 @@
  */
 package org.thingsboard.server.service.apiusage.limits;
 
+import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.TenantId;
 
 public interface RateLimitService {
 
-    boolean checkRateLimit(TenantId tenantId, LimitedApi api);
+    boolean checkRateLimit(LimitedApi api, TenantId tenantId);
+
+    boolean checkRateLimit(LimitedApi api, TenantId tenantId, EntityId entityId);
 
 }

application/src/main/java/org/thingsboard/server/service/notification/DefaultNotificationCenter.java

@@ -107,8 +107,10 @@ public class DefaultNotificationCenter extends AbstractSubscriptionService imple
 
     @Override
     public NotificationRequest processNotificationRequest(TenantId tenantId, NotificationRequest request, Consumer<NotificationRequestStats> callback) {
-        if (!rateLimitService.checkRateLimit(tenantId, LimitedApi.NOTIFICATION_REQUEST)) {
-            throw new TbRateLimitsException(EntityType.TENANT);
+        if (request.getRuleId() == null) {
+            if (!rateLimitService.checkRateLimit(LimitedApi.NOTIFICATION_REQUESTS, tenantId)) {
+                throw new TbRateLimitsException(EntityType.TENANT);
+            }
         }
 
         NotificationTemplate notificationTemplate;
@@ -119,8 +121,10 @@ public class DefaultNotificationCenter extends AbstractSubscriptionService imple
         }
         if (notificationTemplate == null) throw new IllegalArgumentException("Template is missing");
 
+        Set<NotificationDeliveryMethod> deliveryMethods = new HashSet<>();
         List<NotificationTarget> targets = request.getTargets().stream().map(NotificationTargetId::new)
-                .map(id -> notificationTargetService.findNotificationTargetById(tenantId, id)).collect(Collectors.toList());
+                .map(id -> notificationTargetService.findNotificationTargetById(tenantId, id))
+                .collect(Collectors.toList());
 
         NotificationRuleId ruleId = request.getRuleId();
         notificationTemplate.getConfiguration().getDeliveryMethodsTemplates().forEach((deliveryMethod, template) -> {
@@ -128,14 +132,22 @@ public class DefaultNotificationCenter extends AbstractSubscriptionService imple
             try {
                 channels.get(deliveryMethod).check(tenantId);
             } catch (Exception e) {
-                throw new IllegalArgumentException(e.getMessage());
+                if (ruleId == null) {
+                    throw new IllegalArgumentException(e.getMessage());
+                } else {
+                    return; // if originated by rule - just ignore delivery method
+                }
             }
             if (ruleId == null) {
                 if (targets.stream().noneMatch(target -> target.getConfiguration().getType().getSupportedDeliveryMethods().contains(deliveryMethod))) {
                     throw new IllegalArgumentException("Recipients for " + deliveryMethod.getName() + " delivery method not chosen");
                 }
             }
+            deliveryMethods.add(deliveryMethod);
         });
+        if (deliveryMethods.isEmpty()) {
+            throw new IllegalArgumentException("No delivery methods to send notification with");
+        }
 
         if (request.getAdditionalConfig() != null) {
             NotificationRequestConfig config = request.getAdditionalConfig();
@@ -155,6 +167,7 @@ public class DefaultNotificationCenter extends AbstractSubscriptionService imple
         NotificationProcessingContext ctx = NotificationProcessingContext.builder()
                 .tenantId(tenantId)
                 .request(request)
+                .deliveryMethods(deliveryMethods)
                 .template(notificationTemplate)
                 .settings(settings)
                 .build();

application/src/main/java/org/thingsboard/server/service/notification/NotificationProcessingContext.java

@@ -48,20 +48,21 @@ public class NotificationProcessingContext {
     private final NotificationSettings settings;
     @Getter
     private final NotificationRequest request;
-
+    @Getter
+    private final Set<NotificationDeliveryMethod> deliveryMethods;
     @Getter
     private final NotificationTemplate notificationTemplate;
+
     private final Map<NotificationDeliveryMethod, DeliveryMethodNotificationTemplate> templates;
     @Getter
-    private Set<NotificationDeliveryMethod> deliveryMethods;
-    @Getter
     private final NotificationRequestStats stats;
 
-
     @Builder
-    public NotificationProcessingContext(TenantId tenantId, NotificationRequest request, NotificationTemplate template, NotificationSettings settings) {
+    public NotificationProcessingContext(TenantId tenantId, NotificationRequest request, Set<NotificationDeliveryMethod> deliveryMethods,
+                                           NotificationTemplate template, NotificationSettings settings) {
         this.tenantId = tenantId;
         this.request = request;
+        this.deliveryMethods = deliveryMethods;
         this.settings = settings;
         this.notificationTemplate = template;
         this.templates = new EnumMap<>(NotificationDeliveryMethod.class);
@@ -77,7 +78,6 @@ public class NotificationProcessingContext {
                 templates.put(deliveryMethod, template);
             }
         });
-        deliveryMethods = templates.keySet();
     }
 
     public <C extends NotificationDeliveryMethodConfig> C getDeliveryMethodConfig(NotificationDeliveryMethod deliveryMethod) {

application/src/main/java/org/thingsboard/server/service/notification/rule/DefaultNotificationRuleProcessor.java

@@ -41,9 +41,11 @@ import org.thingsboard.server.common.msg.notification.trigger.RuleEngineMsgTrigg
 import org.thingsboard.server.common.msg.plugin.ComponentLifecycleMsg;
 import org.thingsboard.server.common.msg.queue.ServiceType;
 import org.thingsboard.server.dao.notification.NotificationRequestService;
-import org.thingsboard.server.service.notification.rule.cache.NotificationRulesCache;
 import org.thingsboard.server.queue.discovery.PartitionService;
+import org.thingsboard.server.service.apiusage.limits.LimitedApi;
+import org.thingsboard.server.service.apiusage.limits.RateLimitService;
 import org.thingsboard.server.service.executors.NotificationExecutorService;
+import org.thingsboard.server.service.notification.rule.cache.NotificationRulesCache;
 import org.thingsboard.server.service.notification.rule.trigger.NotificationRuleTriggerProcessor;
 import org.thingsboard.server.service.notification.rule.trigger.RuleEngineMsgNotificationRuleTriggerProcessor;
 
@@ -65,6 +67,7 @@ public class DefaultNotificationRuleProcessor implements NotificationRuleProcess
     private final NotificationRulesCache notificationRulesCache;
     private final NotificationRequestService notificationRequestService;
     private final PartitionService partitionService;
+    private final RateLimitService rateLimitService;
     @Autowired @Lazy
     private NotificationCenter notificationCenter;
     private final NotificationExecutorService notificationExecutor;
@@ -119,6 +122,11 @@ public class DefaultNotificationRuleProcessor implements NotificationRuleProcess
         }
 
         if (matchesFilter(trigger, triggerConfig)) {
+            if (!rateLimitService.checkRateLimit(LimitedApi.NOTIFICATION_REQUESTS_PER_RULE, rule.getTenantId(), rule.getId())) {
+                log.debug("[{}] Rate limit for notification requests per rule was exceeded (rule '{}')", rule.getTenantId(), rule.getName());
+                return;
+            }
+
             NotificationInfo notificationInfo = constructNotificationInfo(trigger, triggerConfig);
             rule.getRecipientsConfig().getTargetsTable().forEach((delay, targets) -> {
                 submitNotificationRequest(targets, rule, trigger.getOriginatorEntityId(), notificationInfo, delay);

application/src/main/java/org/thingsboard/server/service/sync/ie/DefaultEntitiesExportImportService.java

@@ -73,7 +73,7 @@ public class DefaultEntitiesExportImportService implements EntitiesExportImportS
 
     @Override
     public <E extends ExportableEntity<I>, I extends EntityId> EntityExportData<E> exportEntity(EntitiesExportCtx<?> ctx, I entityId) throws ThingsboardException {
-        if (!rateLimitService.checkRateLimit(ctx.getTenantId(), LimitedApi.ENTITY_EXPORT)) {
+        if (!rateLimitService.checkRateLimit(LimitedApi.ENTITY_EXPORT, ctx.getTenantId())) {
             throw new ThingsboardException("Rate limit for entities export is exceeded", ThingsboardErrorCode.TOO_MANY_REQUESTS);
         }
 
@@ -85,7 +85,7 @@ public class DefaultEntitiesExportImportService implements EntitiesExportImportS
 
     @Override
     public <E extends ExportableEntity<I>, I extends EntityId> EntityImportResult<E> importEntity(EntitiesImportCtx ctx, EntityExportData<E> exportData) throws ThingsboardException {
-        if (!rateLimitService.checkRateLimit(ctx.getTenantId(), LimitedApi.ENTITY_IMPORT)) {
+        if (!rateLimitService.checkRateLimit(LimitedApi.ENTITY_IMPORT, ctx.getTenantId())) {
             throw new ThingsboardException("Rate limit for entities import is exceeded", ThingsboardErrorCode.TOO_MANY_REQUESTS);
         }
         if (exportData.getEntity() == null || exportData.getEntity().getId() == null) {

application/src/main/resources/thingsboard.yml

@@ -478,10 +478,14 @@ cache:
     entityCount:
       timeToLiveInMinutes: "${CACHE_SPECS_ENTITY_COUNT_TTL:1440}"
       maxSize: "${CACHE_SPECS_ENTITY_COUNT_MAX_SIZE:100000}"
+
   # deliberately placed outside 'specs' group above
   notificationRules:
     timeToLiveInMinutes: "${CACHE_SPECS_NOTIFICATION_RULES_TTL:30}"
     maxSize: "${CACHE_SPECS_NOTIFICATION_RULES_MAX_SIZE:1000}"
+  rateLimits:
+    timeToLiveInMinutes: "${CACHE_SPECS_RATE_LIMITS_TTL:60}"
+    maxSize: "${CACHE_SPECS_RATE_LIMITS_MAX_SIZE:100000}"
 
 #Disable this because it is not required.
 spring.data.redis.repositories.enabled: false

application/src/test/java/org/thingsboard/server/service/notification/NotificationRuleApiTest.java

@@ -23,14 +23,12 @@ import org.junit.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.mock.mockito.SpyBean;
 import org.springframework.data.util.Pair;
-import org.springframework.test.context.TestPropertySource;
 import org.thingsboard.common.util.JacksonUtil;
-import org.thingsboard.rule.engine.debug.TbMsgGeneratorNode;
-import org.thingsboard.rule.engine.debug.TbMsgGeneratorNodeConfiguration;
 import org.thingsboard.server.common.data.DataConstants;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.DeviceProfile;
 import org.thingsboard.server.common.data.EntityType;
+import org.thingsboard.server.common.data.TenantProfile;
 import org.thingsboard.server.common.data.User;
 import org.thingsboard.server.common.data.alarm.Alarm;
 import org.thingsboard.server.common.data.alarm.AlarmSearchStatus;
@@ -43,8 +41,7 @@ import org.thingsboard.server.common.data.device.profile.AlarmConditionKeyType;
 import org.thingsboard.server.common.data.device.profile.AlarmRule;
 import org.thingsboard.server.common.data.device.profile.DeviceProfileAlarm;
 import org.thingsboard.server.common.data.device.profile.SimpleAlarmConditionSpec;
-import org.thingsboard.server.common.data.id.NotificationRuleId;
-import org.thingsboard.server.common.data.id.RuleChainId;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.notification.Notification;
 import org.thingsboard.server.common.data.notification.NotificationDeliveryMethod;
 import org.thingsboard.server.common.data.notification.NotificationRequest;
@@ -59,25 +56,21 @@ import org.thingsboard.server.common.data.notification.rule.trigger.AlarmNotific
 import org.thingsboard.server.common.data.notification.rule.trigger.AlarmNotificationRuleTriggerConfig.AlarmAction;
 import org.thingsboard.server.common.data.notification.rule.trigger.EntityActionNotificationRuleTriggerConfig;
 import org.thingsboard.server.common.data.notification.rule.trigger.NotificationRuleTriggerType;
-import org.thingsboard.server.common.data.notification.rule.trigger.RuleEngineComponentLifecycleEventNotificationRuleTriggerConfig;
 import org.thingsboard.server.common.data.notification.targets.NotificationTarget;
 import org.thingsboard.server.common.data.notification.template.NotificationTemplate;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageLink;
-import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent;
 import org.thingsboard.server.common.data.query.BooleanFilterPredicate;
 import org.thingsboard.server.common.data.query.EntityKeyValueType;
 import org.thingsboard.server.common.data.query.FilterPredicateValue;
-import org.thingsboard.server.common.data.rule.RuleChain;
-import org.thingsboard.server.common.data.rule.RuleChainMetaData;
-import org.thingsboard.server.common.data.rule.RuleNode;
-import org.thingsboard.server.common.data.script.ScriptLanguage;
 import org.thingsboard.server.common.data.security.Authority;
-import org.thingsboard.server.dao.alarm.AlarmService;
+import org.thingsboard.server.common.data.tenant.profile.DefaultTenantProfileConfiguration;
+import org.thingsboard.server.common.data.tenant.profile.TenantProfileData;
 import org.thingsboard.server.dao.notification.NotificationRequestService;
-import org.thingsboard.server.dao.notification.NotificationRuleService;
-import org.thingsboard.server.dao.notification.NotificationTemplateService;
 import org.thingsboard.server.dao.service.DaoSqlTest;
+import org.thingsboard.server.dao.tenant.TenantProfileService;
+import org.thingsboard.server.service.apiusage.limits.LimitedApi;
+import org.thingsboard.server.service.apiusage.limits.RateLimitService;
 import org.thingsboard.server.service.telemetry.AlarmSubscriptionService;
 
 import java.util.ArrayList;
@@ -96,9 +89,6 @@ import static org.awaitility.Awaitility.await;
 import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
 
 @DaoSqlTest
-@TestPropertySource(properties = {
-        "js.evaluator=local"
-})
 public class NotificationRuleApiTest extends AbstractNotificationApiTest {
 
     @SpyBean
@@ -106,18 +96,13 @@ public class NotificationRuleApiTest extends AbstractNotificationApiTest {
     @Autowired
     private NotificationRequestService notificationRequestService;
     @Autowired
-    private NotificationRuleService notificationRuleService;
+    private TenantProfileService tenantProfileService;
     @Autowired
-    private NotificationTemplateService notificationTemplateService;
-
-    @SpyBean
-    private AlarmService alarmService;
+    private RateLimitService rateLimitService;
 
     @Before
     public void beforeEach() throws Exception {
         loginTenantAdmin();
-        notificationRuleService.deleteNotificationRulesByTenantId(tenantId);
-        notificationTemplateService.deleteNotificationTemplatesByTenantId(tenantId);
     }
 
     @Test
@@ -208,7 +193,7 @@ public class NotificationRuleApiTest extends AbstractNotificationApiTest {
 
 
         String alarmType = "myBoolIsTrue";
-        DeviceProfile deviceProfile = createDeviceProfileWithAlarmRules(notificationRule.getId(), alarmType);
+        DeviceProfile deviceProfile = createDeviceProfileWithAlarmRules(alarmType);
         Device device = createDevice("Device 1", deviceProfile.getName(), "1234");
 
         clients.values().forEach(wsClient -> {
@@ -272,7 +257,7 @@ public class NotificationRuleApiTest extends AbstractNotificationApiTest {
         notificationRule.setTriggerType(NotificationRuleTriggerType.ALARM);
 
         String alarmType = "myBoolIsTrue";
-        DeviceProfile deviceProfile = createDeviceProfileWithAlarmRules(notificationRule.getId(), alarmType);
+        DeviceProfile deviceProfile = createDeviceProfileWithAlarmRules(alarmType);
         Device device = createDevice("Device 1", deviceProfile.getName(), "1234");
 
         AlarmNotificationRuleTriggerConfig triggerConfig = new AlarmNotificationRuleTriggerConfig();
@@ -352,7 +337,56 @@ public class NotificationRuleApiTest extends AbstractNotificationApiTest {
         assertThat(ruleInfo.getDeliveryMethods()).containsOnly(deliveryMethods);
     }
 
-    private DeviceProfile createDeviceProfileWithAlarmRules(NotificationRuleId notificationRuleId, String alarmType) {
+    @Test
+    public void testNotificationRequestsPerRuleRateLimits() throws Exception {
+        int notificationRequestsLimit = 10;
+        TenantProfile tenantProfile = tenantProfileService.findDefaultTenantProfile(TenantId.SYS_TENANT_ID);
+        TenantProfileData profileData = tenantProfile.getProfileData();
+        DefaultTenantProfileConfiguration profileConfiguration = (DefaultTenantProfileConfiguration) profileData.getConfiguration();
+        profileConfiguration.setTenantNotificationRequestsPerRuleRateLimit(notificationRequestsLimit + ":300");
+        tenantProfile.setProfileData(profileData);
+        loginSysAdmin();
+        doPost("/api/tenantProfile", tenantProfile).andExpect(status().isOk());
+        loginTenantAdmin();
+
+        NotificationRule rule = new NotificationRule();
+        rule.setName("Device created");
+        rule.setTriggerType(NotificationRuleTriggerType.ENTITY_ACTION);
+        NotificationTemplate template = createNotificationTemplate(NotificationType.ENTITY_ACTION, "Device created", "Device created",
+                NotificationDeliveryMethod.WEB, NotificationDeliveryMethod.SMS);
+        rule.setTemplateId(template.getId());
+        EntityActionNotificationRuleTriggerConfig triggerConfig = new EntityActionNotificationRuleTriggerConfig();
+        triggerConfig.setEntityTypes(Set.of(EntityType.DEVICE));
+        triggerConfig.setCreated(true);
+        rule.setTriggerConfig(triggerConfig);
+        NotificationTarget target = createNotificationTarget(tenantAdminUserId);
+        DefaultNotificationRuleRecipientsConfig recipientsConfig = new DefaultNotificationRuleRecipientsConfig();
+        recipientsConfig.setTriggerType(NotificationRuleTriggerType.ENTITY_ACTION);
+        recipientsConfig.setTargets(List.of(target.getUuidId()));
+        rule.setRecipientsConfig(recipientsConfig);
+        rule = saveNotificationRule(rule);
+
+        for (int i = 0; i < notificationRequestsLimit; i++) {
+            String name = "device " + i;
+            createDevice(name, name);
+        }
+        await().atMost(5, TimeUnit.SECONDS)
+                .untilAsserted(() -> {
+                    assertThat(getMyNotifications(false, 100)).size().isEqualTo(notificationRequestsLimit);
+                });
+        for (int i = 0; i < 5; i++) {
+            String name = "device " + (notificationRequestsLimit + i);
+            createDevice(name, name);
+        }
+
+        boolean rateLimitExceeded = !rateLimitService.checkRateLimit(LimitedApi.NOTIFICATION_REQUESTS_PER_RULE, tenantId, rule.getId());
+        assertThat(rateLimitExceeded).isTrue();
+
+        TimeUnit.SECONDS.sleep(3);
+        assertThat(getMyNotifications(false, 100)).size().isEqualTo(notificationRequestsLimit);
+    }
+
+    private DeviceProfile createDeviceProfileWithAlarmRules(String alarmType) {
         DeviceProfile deviceProfile = createDeviceProfile("For notification rule test");
         deviceProfile.setTenantId(tenantId);
 
@@ -387,41 +421,6 @@ public class NotificationRuleApiTest extends AbstractNotificationApiTest {
         return deviceProfile;
     }
 
-    private RuleChain createEmptyRuleChain(String name) {
-        RuleChain ruleChain = new RuleChain();
-        ruleChain.setName(name);
-        ruleChain.setTenantId(tenantId);
-        ruleChain.setRoot(false);
-        ruleChain.setDebugMode(false);
-        ruleChain = doPost("/api/ruleChain", ruleChain, RuleChain.class);
-
-        RuleChainMetaData metaData = new RuleChainMetaData();
-        metaData.setRuleChainId(ruleChain.getId());
-        metaData.setNodes(List.of());
-        metaData = doPost("/api/ruleChain/metadata", metaData, RuleChainMetaData.class);
-        return ruleChain;
-    }
-
-    private RuleNode addRuleNodeWithError(RuleChainId ruleChainId, String name) {
-        RuleChainMetaData metaData = new RuleChainMetaData();
-        metaData.setRuleChainId(ruleChainId);
-
-        RuleNode generatorNodeWithError = new RuleNode();
-        generatorNodeWithError.setName(name);
-        generatorNodeWithError.setType(TbMsgGeneratorNode.class.getName());
-        TbMsgGeneratorNodeConfiguration generatorNodeConfiguration = new TbMsgGeneratorNodeConfiguration();
-        generatorNodeConfiguration.setScriptLang(ScriptLanguage.JS);
-        generatorNodeConfiguration.setPeriodInSeconds(1000);
-        generatorNodeConfiguration.setMsgCount(1);
-        generatorNodeConfiguration.setJsScript("[return");
-        generatorNodeWithError.setConfiguration(mapper.valueToTree(generatorNodeConfiguration));
-
-        metaData.setNodes(List.of(generatorNodeWithError));
-        metaData.setFirstNodeIndex(0);
-        metaData = doPost("/api/ruleChain/metadata", metaData, RuleChainMetaData.class);
-        return metaData.getNodes().get(0);
-    }
-
     private NotificationRule saveNotificationRule(NotificationRule notificationRule) {
         return doPost("/api/notification/rule", notificationRule, NotificationRule.class);
     }

application/src/test/java/org/thingsboard/server/service/notification/NotificationTemplateApiTest.java

@@ -19,7 +19,6 @@ import com.fasterxml.jackson.core.type.TypeReference;
 import org.apache.commons.lang3.StringUtils;
 import org.junit.Before;
 import org.junit.Test;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.test.web.servlet.ResultActions;
 import org.springframework.test.web.servlet.ResultMatcher;
 import org.thingsboard.server.common.data.id.IdBased;
@@ -30,8 +29,6 @@ import org.thingsboard.server.common.data.notification.template.NotificationTemp
 import org.thingsboard.server.common.data.notification.template.NotificationTemplateConfig;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageLink;
-import org.thingsboard.server.dao.notification.NotificationRuleService;
-import org.thingsboard.server.dao.notification.NotificationTemplateService;
 import org.thingsboard.server.dao.service.DaoSqlTest;
 
 import java.util.List;
@@ -43,16 +40,9 @@ import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.
 @DaoSqlTest
 public class NotificationTemplateApiTest extends AbstractNotificationApiTest {
 
-    @Autowired
-    private NotificationTemplateService templateService;
-    @Autowired
-    private NotificationRuleService notificationRuleService;
-
     @Before
     public void beforeEach() throws Exception {
         loginTenantAdmin();
-        notificationRuleService.deleteNotificationRulesByTenantId(tenantId);
-        templateService.deleteNotificationTemplatesByTenantId(tenantId);
     }
 
     @Test

common/data/src/main/java/org/thingsboard/server/common/data/tenant/profile/DefaultTenantProfileConfiguration.java

@@ -48,6 +48,7 @@ public class DefaultTenantProfileConfiguration implements TenantProfileConfigura
     private String tenantEntityExportRateLimit;
     private String tenantEntityImportRateLimit;
     private String tenantNotificationRequestsRateLimit;
+    private String tenantNotificationRequestsPerRuleRateLimit;
 
     private long maxTransportMessages;
     private long maxTransportDataPoints;

ui-ngx/src/app/modules/home/components/profile/tenant/default-tenant-profile-configuration.component.html

@@ -480,6 +480,9 @@
           <tb-rate-limits fxFlex="50" formControlName="tenantNotificationRequestsRateLimit"
                           [type]="rateLimitsType.TENANT_NOTIFICATION_REQUEST_RATE_LIMIT">
           </tb-rate-limits>
+          <tb-rate-limits fxFlex="50" formControlName="tenantNotificationRequestsPerRuleRateLimit"
+                          [type]="rateLimitsType.TENANT_NOTIFICATION_REQUESTS_PER_RULE_RATE_LIMIT">
+          </tb-rate-limits>
         </div>
       </ng-template>
     </mat-expansion-panel>

ui-ngx/src/app/modules/home/components/profile/tenant/default-tenant-profile-configuration.component.ts

@@ -73,6 +73,7 @@ export class DefaultTenantProfileConfigurationComponent implements ControlValueA
       tenantEntityExportRateLimit: [null, []],
       tenantEntityImportRateLimit: [null, []],
       tenantNotificationRequestsRateLimit: [null, []],
+      tenantNotificationRequestsPerRuleRateLimit: [null, []],
       maxTransportMessages: [null, [Validators.required, Validators.min(0)]],
       maxTransportDataPoints: [null, [Validators.required, Validators.min(0)]],
       maxREExecutions: [null, [Validators.required, Validators.min(0)]],

ui-ngx/src/app/modules/home/components/profile/tenant/rate-limits/rate-limits.models.ts

@@ -34,7 +34,8 @@ export enum RateLimitsType {
   CASSANDRA_QUERY_TENANT_RATE_LIMITS_CONFIGURATION = 'CASSANDRA_QUERY_TENANT_RATE_LIMITS_CONFIGURATION',
   TENANT_ENTITY_EXPORT_RATE_LIMIT = 'TENANT_ENTITY_EXPORT_RATE_LIMIT',
   TENANT_ENTITY_IMPORT_RATE_LIMIT = 'TENANT_ENTITY_IMPORT_RATE_LIMIT',
-  TENANT_NOTIFICATION_REQUEST_RATE_LIMIT = 'TENANT_NOTIFICATION_REQUEST_RATE_LIMIT'
+  TENANT_NOTIFICATION_REQUEST_RATE_LIMIT = 'TENANT_NOTIFICATION_REQUEST_RATE_LIMIT',
+  TENANT_NOTIFICATION_REQUESTS_PER_RULE_RATE_LIMIT = 'TENANT_NOTIFICATION_REQUESTS_PER_RULE_RATE_LIMIT'
 }
 
 export const rateLimitsLabelTranslationMap = new Map<RateLimitsType, string>(
@@ -52,6 +53,7 @@ export const rateLimitsLabelTranslationMap = new Map<RateLimitsType, string>(
     [RateLimitsType.TENANT_ENTITY_EXPORT_RATE_LIMIT, 'tenant-profile.tenant-entity-export-rate-limit'],
     [RateLimitsType.TENANT_ENTITY_IMPORT_RATE_LIMIT, 'tenant-profile.tenant-entity-import-rate-limit'],
     [RateLimitsType.TENANT_NOTIFICATION_REQUEST_RATE_LIMIT, 'tenant-profile.tenant-notification-request-rate-limit'],
+    [RateLimitsType.TENANT_NOTIFICATION_REQUESTS_PER_RULE_RATE_LIMIT, 'tenant-profile.tenant-notification-requests-per-rule-rate-limit'],
   ]
 );
 
@@ -70,6 +72,7 @@ export const rateLimitsDialogTitleTranslationMap = new Map<RateLimitsType, strin
     [RateLimitsType.TENANT_ENTITY_EXPORT_RATE_LIMIT, 'tenant-profile.rate-limits.edit-tenant-entity-export-rate-limit-title'],
     [RateLimitsType.TENANT_ENTITY_IMPORT_RATE_LIMIT, 'tenant-profile.rate-limits.edit-tenant-entity-import-rate-limit-title'],
     [RateLimitsType.TENANT_NOTIFICATION_REQUEST_RATE_LIMIT, 'tenant-profile.rate-limits.edit-tenant-notification-request-rate-limit-title'],
+    [RateLimitsType.TENANT_NOTIFICATION_REQUESTS_PER_RULE_RATE_LIMIT, 'tenant-profile.rate-limits.edit-tenant-notification-requests-per-rule-rate-limit-title'],
   ]
 );
 

ui-ngx/src/app/shared/models/tenant.model.ts

@@ -44,6 +44,7 @@ export interface DefaultTenantProfileConfiguration {
   tenantEntityExportRateLimit?: string;
   tenantEntityImportRateLimit?: string;
   tenantNotificationRequestsRateLimit?: string;
+  tenantNotificationRequestsPerRuleRateLimit?: string;
 
   maxTransportMessages: number;
   maxTransportDataPoints: number;

ui-ngx/src/assets/locale/locale.constant-en_US.json

@@ -3556,6 +3556,7 @@
         "tenant-entity-export-rate-limit": "Entity version creation",
         "tenant-entity-import-rate-limit": "Entity version load",
         "tenant-notification-request-rate-limit": "Notification requests",
+        "tenant-notification-requests-per-rule-rate-limit": "Notification requests per notification rule",
         "max-transport-messages": "Transport messages maximum number",
         "max-transport-messages-required": "Transport messages maximum number is required.",
         "max-transport-messages-range": "Transport messages maximum number can't be negative",
@@ -3629,6 +3630,7 @@
             "edit-tenant-entity-export-rate-limit-title": "Edit entity version creation rate limits",
             "edit-tenant-entity-import-rate-limit-title": "Edit entity version load rate limits",
             "edit-tenant-notification-request-rate-limit-title": "Edit notification requests rate limits",
+            "edit-tenant-notification-requests-per-rule-rate-limit-title": "Edit notification requests per notification rule rate limits",
             "messages-per": "messages per",
             "not-set": "Not set",
             "number-of-messages": "Number of messages",