added rate limits for the gateway

application/src/main/java/org/thingsboard/server/controller/TenantProfileController.java

@@ -138,6 +138,9 @@ public class TenantProfileController extends BaseController {
                     "      \"transportDeviceMsgRateLimit\": \"20:1,600:60\",\n" +
                     "      \"transportDeviceTelemetryMsgRateLimit\": \"20:1,600:60\",\n" +
                     "      \"transportDeviceTelemetryDataPointsRateLimit\": \"20:1,600:60\",\n" +
+                    "      \"transportGatewayMsgRateLimit\": \"20:1,600:60\",\n" +
+                    "      \"transportGatewayTelemetryMsgRateLimit\": \"20:1,600:60\",\n" +
+                    "      \"transportGatewayTelemetryDataPointsRateLimit\": \"20:1,600:60\",\n" +
                     "      \"maxTransportMessages\": 10000000,\n" +
                     "      \"maxTransportDataPoints\": 10000000,\n" +
                     "      \"maxREExecutions\": 4000000,\n" +

common/data/src/main/java/org/thingsboard/server/common/data/limit/LimitedApi.java

@@ -40,6 +40,7 @@ public enum LimitedApi {
     TWO_FA_VERIFICATION_CODE_CHECK(false, true),
     TRANSPORT_MESSAGES_PER_TENANT("transport messages", true),
     TRANSPORT_MESSAGES_PER_DEVICE("transport messages per device", false),
+    TRANSPORT_MESSAGES_PER_GATEWAY("transport messages per gateway", false),
     EMAILS("emails sending", true);
 
     private Function<DefaultTenantProfileConfiguration, String> configExtractor;

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

@@ -47,6 +47,9 @@ public class DefaultTenantProfileConfiguration implements TenantProfileConfigura
     private String transportDeviceMsgRateLimit;
     private String transportDeviceTelemetryMsgRateLimit;
     private String transportDeviceTelemetryDataPointsRateLimit;
+    private String transportGatewayMsgRateLimit;
+    private String transportGatewayTelemetryMsgRateLimit;
+    private String transportGatewayTelemetryDataPointsRateLimit;
 
     private String tenantEntityExportRateLimit;
     private String tenantEntityImportRateLimit;

common/data/src/main/java/org/thingsboard/server/common/data/util/TbPair.java

@@ -23,4 +23,8 @@ import lombok.Data;
 public class TbPair<S, T> {
     private S first;
     private T second;
+
+    public static <S, T> TbPair<S, T> of(S first, T second) {
+        return new TbPair<>(first, second);
+    }
 }

common/proto/src/main/proto/queue.proto

@@ -96,6 +96,8 @@ message SessionInfoProto {
   int64 deviceProfileIdLSB = 13;
   int64 customerIdMSB = 14;
   int64 customerIdLSB = 15;
+  optional int64 gatewayIdMSB = 16;
+  optional int64 gatewayIdLSB = 17;
 }
 
 enum SessionEvent {

common/transport/mqtt/src/main/java/org/thingsboard/server/transport/mqtt/session/AbstractGatewayDeviceSessionContext.java

@@ -59,6 +59,8 @@ public abstract class AbstractGatewayDeviceSessionContext<T extends AbstractGate
                 .setDeviceType(deviceInfo.getDeviceType())
                 .setGwSessionIdMSB(parent.getSessionId().getMostSignificantBits())
                 .setGwSessionIdLSB(parent.getSessionId().getLeastSignificantBits())
+                .setGatewayIdMSB(parent.gateway.getDeviceId().getId().getMostSignificantBits())
+                .setGatewayIdLSB(parent.gateway.getDeviceId().getId().getLeastSignificantBits())
                 .setDeviceProfileIdMSB(deviceInfo.getDeviceProfileId().getId().getMostSignificantBits())
                 .setDeviceProfileIdLSB(deviceInfo.getDeviceProfileId().getId().getLeastSignificantBits())
                 .build());

common/transport/transport-api/src/main/java/org/thingsboard/server/common/transport/limits/DefaultTransportRateLimitService.java

@@ -26,6 +26,7 @@ import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.tenant.profile.DefaultTenantProfileConfiguration;
 import org.thingsboard.server.common.data.tenant.profile.TenantProfileData;
+import org.thingsboard.server.common.data.util.TbPair;
 import org.thingsboard.server.common.transport.TransportTenantProfileCache;
 import org.thingsboard.server.common.transport.profile.TenantProfileUpdateResult;
 import org.thingsboard.server.queue.util.TbTransportComponent;
@@ -39,6 +40,10 @@ import java.util.concurrent.ConcurrentMap;
 import java.util.function.BiConsumer;
 import java.util.function.Function;
 
+import static org.thingsboard.server.common.transport.limits.TransportLimitsType.DEVICE_LIMITS;
+import static org.thingsboard.server.common.transport.limits.TransportLimitsType.GATEWAY_LIMITS;
+import static org.thingsboard.server.common.transport.limits.TransportLimitsType.TENANT_LIMITS;
+
 @Service
 @TbTransportComponent
 @Slf4j
@@ -47,8 +52,10 @@ public class DefaultTransportRateLimitService implements TransportRateLimitServi
     private final static DummyTransportRateLimit ALLOW = new DummyTransportRateLimit();
     private final ConcurrentMap<TenantId, Boolean> tenantAllowed = new ConcurrentHashMap<>();
     private final ConcurrentMap<TenantId, Set<DeviceId>> tenantDevices = new ConcurrentHashMap<>();
+    private final ConcurrentMap<TenantId, Set<DeviceId>> tenantGateways = new ConcurrentHashMap<>();
     private final ConcurrentMap<TenantId, EntityTransportRateLimits> perTenantLimits = new ConcurrentHashMap<>();
     private final ConcurrentMap<DeviceId, EntityTransportRateLimits> perDeviceLimits = new ConcurrentHashMap<>();
+    private final ConcurrentMap<DeviceId, EntityTransportRateLimits> perGatewayLimits = new ConcurrentHashMap<>();
     private final Map<InetAddress, InetAddressRateLimitStats> ipMap = new ConcurrentHashMap<>();
 
     private final TransportTenantProfileCache tenantProfileCache;
@@ -65,15 +72,20 @@ public class DefaultTransportRateLimitService implements TransportRateLimitServi
     }
 
     @Override
-    public EntityType checkLimits(TenantId tenantId, DeviceId deviceId, int dataPoints) {
+    public TbPair<EntityType, Boolean> checkLimits(TenantId tenantId, DeviceId gatewayId, DeviceId deviceId, int dataPoints) {
         if (!tenantAllowed.getOrDefault(tenantId, Boolean.TRUE)) {
-            return EntityType.API_USAGE_STATE;
+            return TbPair.of(EntityType.API_USAGE_STATE, false);
         }
         if (!checkEntityRateLimit(dataPoints, getTenantRateLimits(tenantId))) {
-            return EntityType.TENANT;
+            return TbPair.of(EntityType.TENANT, false);
+        }
+
+        if (gatewayId != null && !checkEntityRateLimit(dataPoints, getGatewayRateLimits(tenantId, gatewayId))) {
+            return TbPair.of(EntityType.DEVICE, true);
         }
+
         if (!checkEntityRateLimit(dataPoints, getDeviceRateLimits(tenantId, deviceId))) {
-            return EntityType.DEVICE;
+            return TbPair.of(EntityType.DEVICE, false);
         }
         return null;
     }
@@ -89,24 +101,27 @@ public class DefaultTransportRateLimitService implements TransportRateLimitServi
     @Override
     public void update(TenantProfileUpdateResult update) {
         log.info("Received tenant profile update: {}", update.getProfile());
-        EntityTransportRateLimits tenantRateLimitPrototype = createRateLimits(update.getProfile(), true);
-        EntityTransportRateLimits deviceRateLimitPrototype = createRateLimits(update.getProfile(), false);
+        EntityTransportRateLimits tenantRateLimitPrototype = createRateLimits(update.getProfile(), TENANT_LIMITS);
+        EntityTransportRateLimits deviceRateLimitPrototype = createRateLimits(update.getProfile(), DEVICE_LIMITS);
+        EntityTransportRateLimits gatewayRateLimitPrototype = createRateLimits(update.getProfile(), GATEWAY_LIMITS);
         for (TenantId tenantId : update.getAffectedTenants()) {
-            mergeLimits(tenantId, tenantRateLimitPrototype, perTenantLimits::get, perTenantLimits::put);
-            getTenantDevices(tenantId).forEach(deviceId -> {
-                mergeLimits(deviceId, deviceRateLimitPrototype, perDeviceLimits::get, perDeviceLimits::put);
-            });
+            update(tenantId, tenantRateLimitPrototype, deviceRateLimitPrototype, gatewayRateLimitPrototype);
         }
     }
 
     @Override
     public void update(TenantId tenantId) {
-        EntityTransportRateLimits tenantRateLimitPrototype = createRateLimits(tenantProfileCache.get(tenantId), true);
-        EntityTransportRateLimits deviceRateLimitPrototype = createRateLimits(tenantProfileCache.get(tenantId), false);
+        EntityTransportRateLimits tenantRateLimitPrototype = createRateLimits(tenantProfileCache.get(tenantId), TENANT_LIMITS);
+        EntityTransportRateLimits deviceRateLimitPrototype = createRateLimits(tenantProfileCache.get(tenantId), DEVICE_LIMITS);
+        EntityTransportRateLimits gatewayRateLimitPrototype = createRateLimits(tenantProfileCache.get(tenantId), GATEWAY_LIMITS);
+        update(tenantId, tenantRateLimitPrototype, deviceRateLimitPrototype, gatewayRateLimitPrototype);
+    }
+
+    private void update(TenantId tenantId, EntityTransportRateLimits tenantRateLimitPrototype,
+                        EntityTransportRateLimits deviceRateLimitPrototype, EntityTransportRateLimits gatewayRateLimitPrototype) {
         mergeLimits(tenantId, tenantRateLimitPrototype, perTenantLimits::get, perTenantLimits::put);
-        getTenantDevices(tenantId).forEach(deviceId -> {
-            mergeLimits(deviceId, deviceRateLimitPrototype, perDeviceLimits::get, perDeviceLimits::put);
-        });
+        getTenantDevices(tenantId).forEach(deviceId -> mergeLimits(deviceId, deviceRateLimitPrototype, perDeviceLimits::get, perDeviceLimits::put));
+        getTenantGateways(tenantId).forEach(deviceId -> mergeLimits(deviceId, gatewayRateLimitPrototype, perGatewayLimits::get, perGatewayLimits::put));
     }
 
     @Override
@@ -233,15 +248,34 @@ public class DefaultTransportRateLimitService implements TransportRateLimitServi
         }
     }
 
-    private EntityTransportRateLimits createRateLimits(TenantProfile tenantProfile, boolean tenant) {
+    private EntityTransportRateLimits createRateLimits(TenantProfile tenantProfile, TransportLimitsType limitsType) {
         TenantProfileData profileData = tenantProfile.getProfileData();
         DefaultTenantProfileConfiguration profile = (DefaultTenantProfileConfiguration) profileData.getConfiguration();
         if (profile == null) {
             return new EntityTransportRateLimits(ALLOW, ALLOW, ALLOW);
         } else {
-            TransportRateLimit regularMsgRateLimit = newLimit(tenant ? profile.getTransportTenantMsgRateLimit() : profile.getTransportDeviceMsgRateLimit());
-            TransportRateLimit telemetryMsgRateLimit = newLimit(tenant ? profile.getTransportTenantTelemetryMsgRateLimit() : profile.getTransportDeviceTelemetryMsgRateLimit());
-            TransportRateLimit telemetryDpRateLimit = newLimit(tenant ? profile.getTransportTenantTelemetryDataPointsRateLimit() : profile.getTransportDeviceTelemetryDataPointsRateLimit());
+            TransportRateLimit regularMsgRateLimit;
+            TransportRateLimit telemetryMsgRateLimit;
+            TransportRateLimit telemetryDpRateLimit;
+            switch (limitsType) {
+                case TENANT_LIMITS -> {
+                    regularMsgRateLimit = newLimit(profile.getTransportTenantMsgRateLimit());
+                    telemetryMsgRateLimit = newLimit(profile.getTransportTenantTelemetryMsgRateLimit());
+                    telemetryDpRateLimit = newLimit(profile.getTransportTenantTelemetryDataPointsRateLimit());
+                }
+                case DEVICE_LIMITS -> {
+                    regularMsgRateLimit = newLimit(profile.getTransportDeviceMsgRateLimit());
+                    telemetryMsgRateLimit = newLimit(profile.getTransportDeviceTelemetryMsgRateLimit());
+                    telemetryDpRateLimit = newLimit(profile.getTransportDeviceTelemetryDataPointsRateLimit());
+                }
+                case GATEWAY_LIMITS -> {
+                    regularMsgRateLimit = newLimit(profile.getTransportGatewayMsgRateLimit());
+                    telemetryMsgRateLimit = newLimit(profile.getTransportGatewayTelemetryMsgRateLimit());
+                    telemetryDpRateLimit = newLimit(profile.getTransportGatewayTelemetryDataPointsRateLimit());
+                }
+                default -> throw new IllegalStateException("Unknown limits type: " + limitsType);
+            }
+
             return new EntityTransportRateLimits(regularMsgRateLimit, telemetryMsgRateLimit, telemetryDpRateLimit);
         }
     }
@@ -251,21 +285,31 @@ public class DefaultTransportRateLimitService implements TransportRateLimitServi
     }
 
     private EntityTransportRateLimits getTenantRateLimits(TenantId tenantId) {
-        return perTenantLimits.computeIfAbsent(tenantId, k -> {
-            return createRateLimits(tenantProfileCache.get(tenantId), true);
-        });
+        return perTenantLimits.computeIfAbsent(tenantId, k -> createRateLimits(tenantProfileCache.get(tenantId), TENANT_LIMITS));
     }
 
     private EntityTransportRateLimits getDeviceRateLimits(TenantId tenantId, DeviceId deviceId) {
         return perDeviceLimits.computeIfAbsent(deviceId, k -> {
-            EntityTransportRateLimits limits = createRateLimits(tenantProfileCache.get(tenantId), false);
+            EntityTransportRateLimits limits = createRateLimits(tenantProfileCache.get(tenantId), DEVICE_LIMITS);
             getTenantDevices(tenantId).add(deviceId);
             return limits;
         });
     }
 
+    private EntityTransportRateLimits getGatewayRateLimits(TenantId tenantId, DeviceId deviceId) {
+        return perGatewayLimits.computeIfAbsent(deviceId, k -> {
+            EntityTransportRateLimits limits = createRateLimits(tenantProfileCache.get(tenantId), GATEWAY_LIMITS);
+            getTenantGateways(tenantId).add(deviceId);
+            return limits;
+        });
+    }
+
     private Set<DeviceId> getTenantDevices(TenantId tenantId) {
         return tenantDevices.computeIfAbsent(tenantId, id -> ConcurrentHashMap.newKeySet());
     }
 
+    private Set<DeviceId> getTenantGateways(TenantId tenantId) {
+        return tenantGateways.computeIfAbsent(tenantId, id -> ConcurrentHashMap.newKeySet());
+    }
+
 }

common/transport/transport-api/src/main/java/org/thingsboard/server/common/transport/limits/TransportLimitsType.java

@@ -0,0 +1,20 @@
+/**
+ * Copyright © 2016-2024 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.transport.limits;
+
+public enum TransportLimitsType {
+    TENANT_LIMITS, DEVICE_LIMITS, GATEWAY_LIMITS
+}

common/transport/transport-api/src/main/java/org/thingsboard/server/common/transport/limits/TransportRateLimitService.java

@@ -18,13 +18,14 @@ package org.thingsboard.server.common.transport.limits;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.data.util.TbPair;
 import org.thingsboard.server.common.transport.profile.TenantProfileUpdateResult;
 
 import java.net.InetSocketAddress;
 
 public interface TransportRateLimitService {
 
-    EntityType checkLimits(TenantId tenantId, DeviceId deviceId, int dataPoints);
+    TbPair<EntityType, Boolean> checkLimits(TenantId tenantId, DeviceId gatewayId, DeviceId deviceId, int dataPoints);
 
     void update(TenantProfileUpdateResult update);
 

common/transport/transport-api/src/main/java/org/thingsboard/server/common/transport/service/DefaultTransportService.java

@@ -852,18 +852,27 @@ public class DefaultTransportService extends TransportActivityManager implements
         }
         TenantId tenantId = TenantId.fromUUID(new UUID(sessionInfo.getTenantIdMSB(), sessionInfo.getTenantIdLSB()));
         DeviceId deviceId = new DeviceId(new UUID(sessionInfo.getDeviceIdMSB(), sessionInfo.getDeviceIdLSB()));
+        DeviceId gatewayId = null;
+        if (sessionInfo.hasGatewayIdMSB() && sessionInfo.hasGatewayIdLSB()) {
+            gatewayId = new DeviceId(new UUID(sessionInfo.getGatewayIdMSB(), sessionInfo.getGatewayIdLSB()));
+        }
 
-        EntityType rateLimitedEntityType = rateLimitService.checkLimits(tenantId, deviceId, dataPoints);
-        if (rateLimitedEntityType == null) {
+        var rateLimitedPair = rateLimitService.checkLimits(tenantId, gatewayId, deviceId, dataPoints);
+        if (rateLimitedPair == null) {
             return true;
         } else {
+            var rateLimitedEntityType = rateLimitedPair.getFirst();
             if (callback != null) {
                 callback.onError(new TbRateLimitsException(rateLimitedEntityType));
             }
+
             if (rateLimitedEntityType == EntityType.DEVICE || rateLimitedEntityType == EntityType.TENANT) {
+                LimitedApi limitedApi =
+                        rateLimitedEntityType == EntityType.TENANT ?  LimitedApi.TRANSPORT_MESSAGES_PER_TENANT :
+                                rateLimitedPair.getSecond() ? LimitedApi.TRANSPORT_MESSAGES_PER_GATEWAY : LimitedApi.TRANSPORT_MESSAGES_PER_DEVICE;
                 notificationRuleProcessor.process(RateLimitsTrigger.builder()
                         .tenantId(tenantId)
-                        .api(rateLimitedEntityType == EntityType.DEVICE ? LimitedApi.TRANSPORT_MESSAGES_PER_DEVICE : LimitedApi.TRANSPORT_MESSAGES_PER_TENANT)
+                        .api(limitedApi)
                         .limitLevel(rateLimitedEntityType == EntityType.DEVICE ? deviceId : tenantId)
                         .limitLevelEntityName(rateLimitedEntityType == EntityType.DEVICE ? sessionInfo.getDeviceName() : null)
                         .build());
@@ -933,7 +942,6 @@ public class DefaultTransportService extends TransportActivityManager implements
                     log.trace("ResourceUpdate - [{}] [{}]", id, mdRez);
                     transportCallbackExecutor.submit(() -> mdRez.getListener().onResourceUpdate(msg));
                 });
-
             } else if (toSessionMsg.hasResourceDeleteMsg()) {
                 TransportProtos.ResourceDeleteMsg msg = toSessionMsg.getResourceDeleteMsg();
                 TenantId tenantId = TenantId.fromUUID(new UUID(msg.getTenantIdMSB(), msg.getTenantIdLSB()));

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

@@ -516,6 +516,18 @@
                       [type]="rateLimitsType.DEVICE_TELEMETRY_MESSAGES">
       </tb-rate-limits>
     </div>
+    <div fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+      <tb-rate-limits fxFlex formControlName="transportGatewayMsgRateLimit"
+                      [type]="rateLimitsType.GATEWAY_MESSAGES">
+      </tb-rate-limits>
+      <div fxFlex></div>
+    </div>
+    <div fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+      <tb-rate-limits fxFlex formControlName="transportGatewayTelemetryMsgRateLimit"
+                      [type]="rateLimitsType.GATEWAY_TELEMETRY_MESSAGES">
+      </tb-rate-limits>
+      <div fxFlex></div>
+    </div>
     <mat-expansion-panel class="configuration-panel">
       <mat-expansion-panel-header>
         <mat-panel-description fxLayoutAlign="end" translate>
@@ -531,6 +543,12 @@
                           [type]="rateLimitsType.DEVICE_TELEMETRY_DATA_POINTS">
           </tb-rate-limits>
         </div>
+        <div fxFlex fxLayout="row"  fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+          <tb-rate-limits fxFlex formControlName="transportGatewayTelemetryDataPointsRateLimit"
+                          [type]="rateLimitsType.GATEWAY_TELEMETRY_DATA_POINTS">
+          </tb-rate-limits>
+          <div fxFlex></div>
+        </div>
         <div fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
           <tb-rate-limits fxFlex formControlName="tenantServerRestLimitsConfiguration"
                           [type]="rateLimitsType.TENANT_SERVER_REST_LIMITS_CONFIGURATION">

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

@@ -74,6 +74,9 @@ export class DefaultTenantProfileConfigurationComponent implements ControlValueA
       transportDeviceMsgRateLimit: [null, []],
       transportDeviceTelemetryMsgRateLimit: [null, []],
       transportDeviceTelemetryDataPointsRateLimit: [null, []],
+      transportGatewayMsgRateLimit: [null, []],
+      transportGatewayTelemetryMsgRateLimit: [null, []],
+      transportGatewayTelemetryDataPointsRateLimit: [null, []],
       tenantEntityExportRateLimit: [null, []],
       tenantEntityImportRateLimit: [null, []],
       tenantNotificationRequestsRateLimit: [null, []],

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

@@ -26,6 +26,9 @@ export enum RateLimitsType {
   DEVICE_TELEMETRY_MESSAGES = 'DEVICE_TELEMETRY_MESSAGES',
   DEVICE_TELEMETRY_DATA_POINTS = 'DEVICE_TELEMETRY_DATA_POINTS',
   TENANT_MESSAGES = 'TENANT_MESSAGES',
+  GATEWAY_MESSAGES = 'GATEWAY_MESSAGES',
+  GATEWAY_TELEMETRY_MESSAGES = 'GATEWAY_TELEMETRY_MESSAGES',
+  GATEWAY_TELEMETRY_DATA_POINTS = 'GATEWAY_TELEMETRY_DATA_POINTS',
   TENANT_TELEMETRY_MESSAGES = 'TENANT_TELEMETRY_MESSAGES',
   TENANT_TELEMETRY_DATA_POINTS = 'TENANT_TELEMETRY_DATA_POINTS',
   TENANT_SERVER_REST_LIMITS_CONFIGURATION = 'TENANT_SERVER_REST_LIMITS_CONFIGURATION',
@@ -50,6 +53,9 @@ export const rateLimitsLabelTranslationMap = new Map<RateLimitsType, string>(
     [RateLimitsType.DEVICE_MESSAGES, 'tenant-profile.rate-limits.transport-device-msg'],
     [RateLimitsType.DEVICE_TELEMETRY_MESSAGES, 'tenant-profile.rate-limits.transport-device-telemetry-msg'],
     [RateLimitsType.DEVICE_TELEMETRY_DATA_POINTS, 'tenant-profile.rate-limits.transport-device-telemetry-data-points'],
+    [RateLimitsType.GATEWAY_MESSAGES, 'tenant-profile.rate-limits.transport-gateway-msg'],
+    [RateLimitsType.GATEWAY_TELEMETRY_MESSAGES, 'tenant-profile.rate-limits.transport-gateway-telemetry-msg'],
+    [RateLimitsType.GATEWAY_TELEMETRY_DATA_POINTS, 'tenant-profile.rate-limits.transport-gateway-telemetry-data-points'],
     [RateLimitsType.TENANT_SERVER_REST_LIMITS_CONFIGURATION, 'tenant-profile.rest-requests-for-tenant'],
     [RateLimitsType.CUSTOMER_SERVER_REST_LIMITS_CONFIGURATION, 'tenant-profile.customer-rest-limits'],
     [RateLimitsType.WS_UPDATE_PER_SESSION_RATE_LIMIT, 'tenant-profile.ws-limit-updates-per-session'],
@@ -74,6 +80,9 @@ export const rateLimitsDialogTitleTranslationMap = new Map<RateLimitsType, strin
     [RateLimitsType.DEVICE_TELEMETRY_MESSAGES, 'tenant-profile.rate-limits.edit-transport-device-telemetry-msg-title'],
     [RateLimitsType.DEVICE_TELEMETRY_DATA_POINTS, 'tenant-profile.rate-limits.edit-transport-device-telemetry-data-points-title'],
     [RateLimitsType.TENANT_SERVER_REST_LIMITS_CONFIGURATION, 'tenant-profile.rate-limits.edit-tenant-rest-limits-title'],
+    [RateLimitsType.GATEWAY_MESSAGES, 'tenant-profile.rate-limits.edit-transport-gateway-msg-title'],
+    [RateLimitsType.GATEWAY_TELEMETRY_MESSAGES, 'tenant-profile.rate-limits.edit-transport-gateway-telemetry-msg-title'],
+    [RateLimitsType.GATEWAY_TELEMETRY_DATA_POINTS, 'tenant-profile.rate-limits.edit-transport-gateway-telemetry-data-points-title'],
     [RateLimitsType.CUSTOMER_SERVER_REST_LIMITS_CONFIGURATION, 'tenant-profile.rate-limits.edit-customer-rest-limits-title'],
     [RateLimitsType.WS_UPDATE_PER_SESSION_RATE_LIMIT, 'tenant-profile.rate-limits.edit-ws-limit-updates-per-session-title'],
     [RateLimitsType.CASSANDRA_QUERY_TENANT_RATE_LIMITS_CONFIGURATION, 'tenant-profile.rate-limits.edit-cassandra-tenant-limits-configuration-title'],

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

@@ -4439,6 +4439,9 @@
         "transport-device-msg-rate-limit": "Transport device messages",
         "transport-device-telemetry-msg-rate-limit": "Transport device telemetry messages",
         "transport-device-telemetry-data-points-rate-limit": "Transport device telemetry data points",
+        "transport-gateway-msg-rate-limit": "Transport gateway messages",
+        "transport-gateway-telemetry-msg-rate-limit": "Transport gateway telemetry messages",
+        "transport-gateway-telemetry-data-points-rate-limit": "Transport gateway telemetry data points",
         "tenant-entity-export-rate-limit": "Entity version creation",
         "tenant-entity-import-rate-limit": "Entity version load",
         "tenant-notification-request-rate-limit": "Notification requests",
@@ -4520,6 +4523,9 @@
             "edit-transport-device-msg-title": "Edit transport device messages rate limits",
             "edit-transport-device-telemetry-msg-title": "Edit transport device telemetry messages rate limits",
             "edit-transport-device-telemetry-data-points-title": "Edit transport device telemetry data points rate limits",
+            "edit-transport-gateway-msg-title": "Edit transport gateway messages rate limits",
+            "edit-transport-gateway-telemetry-msg-title": "Edit transport gateway telemetry messages rate limits",
+            "edit-transport-gateway-telemetry-data-points-title": "Edit transport gateway telemetry data points rate limits",
             "edit-tenant-rest-limits-title": "Edit REST requests for tenant rate limits",
             "edit-customer-rest-limits-title": "Edit REST requests for customer rate limits",
             "edit-ws-limit-updates-per-session-title": "Edit WS updates per session rate limits",
@@ -4553,6 +4559,9 @@
             "transport-device-msg": "Transport device messages",
             "transport-device-telemetry-msg": "Transport device telemetry messages",
             "transport-device-telemetry-data-points": "Transport device telemetry data points",
+            "transport-gateway-msg": "Transport gateway messages",
+            "transport-gateway-telemetry-msg": "Transport gateway telemetry messages",
+            "transport-gateway-telemetry-data-points": "Transport gateway telemetry data points",
             "sec": "sec"
         }
     },