diff --git a/application/src/main/java/org/thingsboard/server/install/ThingsboardInstallService.java b/application/src/main/java/org/thingsboard/server/install/ThingsboardInstallService.java
index e8339e3202..44d81902a8 100644
--- a/application/src/main/java/org/thingsboard/server/install/ThingsboardInstallService.java
+++ b/application/src/main/java/org/thingsboard/server/install/ThingsboardInstallService.java
@@ -126,6 +126,7 @@ public class ThingsboardInstallService {
                         case "3.6.2":
                             log.info("Upgrading ThingsBoard from version 3.6.2 to 3.6.3 ...");
                             databaseEntitiesUpgradeService.upgradeDatabase("3.6.2");
+                            systemDataLoaderService.updateDefaultNotificationConfigs();
                             //TODO DON'T FORGET to update switch statement in the CacheCleanupService if you need to clear the cache
                             break;
                         default:
diff --git a/application/src/main/java/org/thingsboard/server/service/edge/EdgeContextComponent.java b/application/src/main/java/org/thingsboard/server/service/edge/EdgeContextComponent.java
index a10a48244b..2f157af70e 100644
--- a/application/src/main/java/org/thingsboard/server/service/edge/EdgeContextComponent.java
+++ b/application/src/main/java/org/thingsboard/server/service/edge/EdgeContextComponent.java
@@ -20,6 +20,7 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Component;
 import org.thingsboard.server.cluster.TbClusterService;
+import org.thingsboard.server.common.msg.notification.NotificationRuleProcessor;
 import org.thingsboard.server.dao.asset.AssetProfileService;
 import org.thingsboard.server.dao.asset.AssetService;
 import org.thingsboard.server.dao.attributes.AttributesService;
@@ -149,6 +150,9 @@ public class EdgeContextComponent {
     @Autowired
     private ResourceService resourceService;
 
+    @Autowired
+    private NotificationRuleProcessor notificationRuleProcessor;
+
     @Autowired
     private AlarmEdgeProcessor alarmProcessor;
 
diff --git a/application/src/main/java/org/thingsboard/server/service/edge/rpc/EdgeGrpcService.java b/application/src/main/java/org/thingsboard/server/service/edge/rpc/EdgeGrpcService.java
index d3262039d5..c23fd98d8e 100644
--- a/application/src/main/java/org/thingsboard/server/service/edge/rpc/EdgeGrpcService.java
+++ b/application/src/main/java/org/thingsboard/server/service/edge/rpc/EdgeGrpcService.java
@@ -38,6 +38,7 @@ import org.thingsboard.server.common.data.kv.BasicTsKvEntry;
 import org.thingsboard.server.common.data.kv.BooleanDataEntry;
 import org.thingsboard.server.common.data.kv.LongDataEntry;
 import org.thingsboard.server.common.data.msg.TbMsgType;
+import org.thingsboard.server.common.data.notification.rule.trigger.EdgeConnectionTrigger;
 import org.thingsboard.server.common.msg.TbMsg;
 import org.thingsboard.server.common.msg.TbMsgDataType;
 import org.thingsboard.server.common.msg.TbMsgMetaData;
@@ -263,7 +264,8 @@ public class EdgeGrpcService extends EdgeRpcServiceGrpc.EdgeRpcServiceImplBase i
     }
 
     private void onEdgeConnect(EdgeId edgeId, EdgeGrpcSession edgeGrpcSession) {
-        TenantId tenantId = edgeGrpcSession.getEdge().getTenantId();
+        Edge edge = edgeGrpcSession.getEdge();
+        TenantId tenantId = edge.getTenantId();
         log.info("[{}][{}] edge [{}] connected successfully.", tenantId, edgeGrpcSession.getSessionId(), edgeId);
         sessions.put(edgeId, edgeGrpcSession);
         final Lock newEventLock = sessionNewEventsLocks.computeIfAbsent(edgeId, id -> new ReentrantLock());
@@ -276,7 +278,7 @@ public class EdgeGrpcService extends EdgeRpcServiceGrpc.EdgeRpcServiceImplBase i
         save(tenantId, edgeId, DefaultDeviceStateService.ACTIVITY_STATE, true);
         long lastConnectTs = System.currentTimeMillis();
         save(tenantId, edgeId, DefaultDeviceStateService.LAST_CONNECT_TIME, lastConnectTs);
-        pushRuleEngineMessage(tenantId, edgeId, lastConnectTs, TbMsgType.CONNECT_EVENT);
+        pushRuleEngineMessage(tenantId, edge, lastConnectTs, TbMsgType.CONNECT_EVENT);
         cancelScheduleEdgeEventsCheck(edgeId);
         scheduleEdgeEventsCheck(edgeGrpcSession);
     }
@@ -381,7 +383,8 @@ public class EdgeGrpcService extends EdgeRpcServiceGrpc.EdgeRpcServiceImplBase i
         }
     }
 
-    private void onEdgeDisconnect(EdgeId edgeId, UUID sessionId) {
+    private void onEdgeDisconnect(Edge edge, UUID sessionId) {
+        EdgeId edgeId = edge.getId();
         log.info("[{}][{}] edge disconnected!", edgeId, sessionId);
         EdgeGrpcSession toRemove = sessions.get(edgeId);
         if (toRemove.getSessionId().equals(sessionId)) {
@@ -397,7 +400,7 @@ public class EdgeGrpcService extends EdgeRpcServiceGrpc.EdgeRpcServiceImplBase i
             save(tenantId, edgeId, DefaultDeviceStateService.ACTIVITY_STATE, false);
             long lastDisconnectTs = System.currentTimeMillis();
             save(tenantId, edgeId, DefaultDeviceStateService.LAST_DISCONNECT_TIME, lastDisconnectTs);
-            pushRuleEngineMessage(toRemove.getEdge().getTenantId(), edgeId, lastDisconnectTs, TbMsgType.DISCONNECT_EVENT);
+            pushRuleEngineMessage(toRemove.getEdge().getTenantId(), edge, lastDisconnectTs, TbMsgType.DISCONNECT_EVENT);
             cancelScheduleEdgeEventsCheck(edgeId);
         } else {
             log.debug("[{}] edge session [{}] is not available anymore, nothing to remove. most probably this session is already outdated!", edgeId, sessionId);
@@ -452,16 +455,24 @@ public class EdgeGrpcService extends EdgeRpcServiceGrpc.EdgeRpcServiceImplBase i
         }
     }
 
-    private void pushRuleEngineMessage(TenantId tenantId, EdgeId edgeId, long ts, TbMsgType msgType) {
+    private void pushRuleEngineMessage(TenantId tenantId, Edge edge, long ts, TbMsgType msgType) {
         try {
+            EdgeId edgeId = edge.getId();
             ObjectNode edgeState = JacksonUtil.newObjectNode();
-            if (msgType.equals(TbMsgType.CONNECT_EVENT)) {
+            boolean isConnected = TbMsgType.CONNECT_EVENT.equals(msgType);
+            if (isConnected) {
                 edgeState.put(DefaultDeviceStateService.ACTIVITY_STATE, true);
                 edgeState.put(DefaultDeviceStateService.LAST_CONNECT_TIME, ts);
             } else {
                 edgeState.put(DefaultDeviceStateService.ACTIVITY_STATE, false);
                 edgeState.put(DefaultDeviceStateService.LAST_DISCONNECT_TIME, ts);
             }
+            ctx.getNotificationRuleProcessor().process(EdgeConnectionTrigger.builder()
+                    .tenantId(tenantId)
+                    .customerId(edge.getCustomerId())
+                    .edgeId(edgeId)
+                    .edgeName(edge.getName())
+                    .connected(isConnected).build());
             String data = JacksonUtil.toString(edgeState);
             TbMsgMetaData md = new TbMsgMetaData();
             if (!persistToTelemetry) {
@@ -470,7 +481,8 @@ public class EdgeGrpcService extends EdgeRpcServiceGrpc.EdgeRpcServiceImplBase i
             TbMsg tbMsg = TbMsg.newMsg(msgType, edgeId, md, TbMsgDataType.JSON, data);
             clusterService.pushMsgToRuleEngine(tenantId, edgeId, tbMsg, null);
         } catch (Exception e) {
-            log.warn("[{}][{}] Failed to push {}", tenantId, edgeId, msgType, e);
+            log.warn("[{}][{}] Failed to push {}", tenantId, edge.getId(), msgType, e);
         }
     }
+
 }
diff --git a/application/src/main/java/org/thingsboard/server/service/edge/rpc/EdgeGrpcSession.java b/application/src/main/java/org/thingsboard/server/service/edge/rpc/EdgeGrpcSession.java
index 5e6f7a263e..98346674ae 100644
--- a/application/src/main/java/org/thingsboard/server/service/edge/rpc/EdgeGrpcSession.java
+++ b/application/src/main/java/org/thingsboard/server/service/edge/rpc/EdgeGrpcSession.java
@@ -35,6 +35,7 @@ import org.thingsboard.server.common.data.kv.AttributeKvEntry;
 import org.thingsboard.server.common.data.kv.BaseAttributeKvEntry;
 import org.thingsboard.server.common.data.kv.LongDataEntry;
 import org.thingsboard.server.common.data.kv.StringDataEntry;
+import org.thingsboard.server.common.data.notification.rule.trigger.EdgeCommunicationFailureTrigger;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageLink;
 import org.thingsboard.server.common.data.page.SortOrder;
@@ -111,7 +112,7 @@ public final class EdgeGrpcSession implements Closeable {
 
     private final UUID sessionId;
     private final BiConsumer<EdgeId, EdgeGrpcSession> sessionOpenListener;
-    private final BiConsumer<EdgeId, UUID> sessionCloseListener;
+    private final BiConsumer<Edge, UUID> sessionCloseListener;
 
     private final EdgeSessionState sessionState = new EdgeSessionState();
 
@@ -137,7 +138,7 @@ public final class EdgeGrpcSession implements Closeable {
     private ScheduledExecutorService sendDownlinkExecutorService;
 
     EdgeGrpcSession(EdgeContextComponent ctx, StreamObserver<ResponseMsg> outputStream, BiConsumer<EdgeId, EdgeGrpcSession> sessionOpenListener,
-                    BiConsumer<EdgeId, UUID> sessionCloseListener, ScheduledExecutorService sendDownlinkExecutorService, int maxInboundMessageSize) {
+                    BiConsumer<Edge, UUID> sessionCloseListener, ScheduledExecutorService sendDownlinkExecutorService, int maxInboundMessageSize) {
         this.sessionId = UUID.randomUUID();
         this.ctx = ctx;
         this.outputStream = outputStream;
@@ -206,7 +207,7 @@ public final class EdgeGrpcSession implements Closeable {
                 connected = false;
                 if (edge != null) {
                     try {
-                        sessionCloseListener.accept(edge.getId(), sessionId);
+                        sessionCloseListener.accept(edge, sessionId);
                     } catch (Exception ignored) {
                     }
                 }
@@ -314,7 +315,7 @@ public final class EdgeGrpcSession implements Closeable {
             } catch (Exception e) {
                 log.error("[{}][{}] Failed to send downlink message [{}]", this.tenantId, this.sessionId, downlinkMsg, e);
                 connected = false;
-                sessionCloseListener.accept(edge.getId(), sessionId);
+                sessionCloseListener.accept(edge, sessionId);
             } finally {
                 downlinkMsgLock.unlock();
             }
@@ -466,15 +467,26 @@ public final class EdgeGrpcSession implements Closeable {
                 if (isConnected() && sessionState.getPendingMsgsMap().values().size() > 0) {
                     List<DownlinkMsg> copy = new ArrayList<>(sessionState.getPendingMsgsMap().values());
                     if (attempt > 1) {
-                        log.warn("[{}][{}] Failed to deliver the batch: {}, attempt: {}", this.tenantId, this.sessionId, copy, attempt);
+                        String error = "Failed to deliver the batch";
+                        String failureMsg = String.format("{%s}: {%s}", error, copy);
+                        if (attempt == 2) {
+                            // Send a failure notification only on the second attempt.
+                            // This ensures that failure alerts are sent just once to avoid redundant notifications.
+                            ctx.getNotificationRuleProcessor().process(EdgeCommunicationFailureTrigger.builder().tenantId(tenantId)
+                                    .edgeId(edge.getId()).customerId(edge.getCustomerId()).edgeName(edge.getName()).failureMsg(failureMsg).error(error).build());
+                        }
+                        log.warn("[{}][{}] {}, attempt: {}", this.tenantId, this.sessionId, failureMsg, attempt);
                     }
                     log.trace("[{}][{}][{}] downlink msg(s) are going to be send.", this.tenantId, this.sessionId, copy.size());
                     for (DownlinkMsg downlinkMsg : copy) {
                         if (this.clientMaxInboundMessageSize != 0 && downlinkMsg.getSerializedSize() > this.clientMaxInboundMessageSize) {
-                            log.error("[{}][{}][{}] Downlink msg size [{}] exceeds client max inbound message size [{}]. Skipping this message. " +
-                                            "Please increase value of CLOUD_RPC_MAX_INBOUND_MESSAGE_SIZE env variable on the edge and restart it." +
-                                            "Message {}", this.tenantId, edge.getId(), this.sessionId, downlinkMsg.getSerializedSize(),
-                                    this.clientMaxInboundMessageSize, downlinkMsg);
+                            String error = String.format("Client max inbound message size [{%s}] is exceeded. Please increase value of CLOUD_RPC_MAX_INBOUND_MESSAGE_SIZE " +
+                                    "env variable on the edge and restart it.", this.clientMaxInboundMessageSize);
+                            String message = String.format("Downlink msg size [{%s}] exceeds client max inbound message size [{%s}]. " +
+                                    "Please increase value of CLOUD_RPC_MAX_INBOUND_MESSAGE_SIZE env variable on the edge and restart it.", downlinkMsg.getSerializedSize(), this.clientMaxInboundMessageSize);
+                            log.error("[{}][{}][{}] {} Message {}", this.tenantId, edge.getId(), this.sessionId, message, downlinkMsg);
+                            ctx.getNotificationRuleProcessor().process(EdgeCommunicationFailureTrigger.builder().tenantId(tenantId)
+                                    .edgeId(edge.getId()).customerId(edge.getCustomerId()).edgeName(edge.getName()).failureMsg(message).error(error).build());
                             sessionState.getPendingMsgsMap().remove(downlinkMsg.getDownlinkMsgId());
                         } else {
                             sendDownlinkMsg(ResponseMsg.newBuilder()
@@ -485,8 +497,12 @@ public final class EdgeGrpcSession implements Closeable {
                     if (attempt < MAX_DOWNLINK_ATTEMPTS) {
                         scheduleDownlinkMsgsPackSend(attempt + 1);
                     } else {
+                        String failureMsg = String.format("Failed to deliver messages: %s", copy);
                         log.warn("[{}][{}] Failed to deliver the batch after {} attempts. Next messages are going to be discarded {}",
                                 this.tenantId, this.sessionId, MAX_DOWNLINK_ATTEMPTS, copy);
+                        ctx.getNotificationRuleProcessor().process(EdgeCommunicationFailureTrigger.builder().tenantId(tenantId).edgeId(edge.getId())
+                                .customerId(edge.getCustomerId()).edgeName(edge.getName()).failureMsg(failureMsg)
+                                .error("Failed to deliver messages after " + MAX_DOWNLINK_ATTEMPTS + " attempts").build());
                         stopCurrentSendDownlinkMsgsTask(false);
                     }
                 } else {
@@ -791,7 +807,10 @@ public final class EdgeGrpcSession implements Closeable {
                 }
             }
         } catch (Exception e) {
+            String failureMsg = String.format("Can't process uplink msg [%s] from edge", uplinkMsg);
             log.error("[{}][{}] Can't process uplink msg [{}]", this.tenantId, this.sessionId, uplinkMsg, e);
+            ctx.getNotificationRuleProcessor().process(EdgeCommunicationFailureTrigger.builder().tenantId(tenantId).edgeId(edge.getId())
+                    .customerId(edge.getCustomerId()).edgeName(edge.getName()).failureMsg(failureMsg).error(e.getMessage()).build());
             return Futures.immediateFailedFuture(e);
         }
         return Futures.allAsList(result);
@@ -815,15 +834,22 @@ public final class EdgeGrpcSession implements Closeable {
                             .setMaxInboundMessageSize(maxInboundMessageSize)
                             .build();
                 }
+                String error = "Failed to validate the edge!";
+                String failureMsg = String.format("{%s} Provided request secret: %s", error, request.getEdgeSecret());
+                ctx.getNotificationRuleProcessor().process(EdgeCommunicationFailureTrigger.builder().tenantId(tenantId).edgeId(edge.getId())
+                        .customerId(edge.getCustomerId()).edgeName(edge.getName()).failureMsg(failureMsg).error(error).build());
                 return ConnectResponseMsg.newBuilder()
                         .setResponseCode(ConnectResponseCode.BAD_CREDENTIALS)
-                        .setErrorMsg("Failed to validate the edge!")
+                        .setErrorMsg(failureMsg)
                         .setConfiguration(EdgeConfiguration.getDefaultInstance()).build();
             } catch (Exception e) {
-                log.error("[{}] Failed to process edge connection!", request.getEdgeRoutingKey(), e);
+                String failureMsg = "Failed to process edge connection!";
+                ctx.getNotificationRuleProcessor().process(EdgeCommunicationFailureTrigger.builder().tenantId(tenantId).edgeId(edge.getId())
+                        .customerId(edge.getCustomerId()).edgeName(edge.getName()).failureMsg(failureMsg).error(e.getMessage()).build());
+                log.error(failureMsg, e);
                 return ConnectResponseMsg.newBuilder()
                         .setResponseCode(ConnectResponseCode.SERVER_UNAVAILABLE)
-                        .setErrorMsg("Failed to process edge connection!")
+                        .setErrorMsg(failureMsg)
                         .setConfiguration(EdgeConfiguration.getDefaultInstance()).build();
             }
         }
diff --git a/application/src/main/java/org/thingsboard/server/service/install/DefaultSystemDataLoaderService.java b/application/src/main/java/org/thingsboard/server/service/install/DefaultSystemDataLoaderService.java
index b9f4dc482f..b20a548d90 100644
--- a/application/src/main/java/org/thingsboard/server/service/install/DefaultSystemDataLoaderService.java
+++ b/application/src/main/java/org/thingsboard/server/service/install/DefaultSystemDataLoaderService.java
@@ -691,7 +691,23 @@ public class DefaultSystemDataLoaderService implements SystemDataLoaderService {
     }
 
     @Override
+    @SneakyThrows
     public void updateDefaultNotificationConfigs() {
+        PageDataIterable<TenantId> tenants = new PageDataIterable<>(tenantService::findTenantsIds, 500);
+        ExecutorService executor = Executors.newFixedThreadPool(Math.max(Runtime.getRuntime().availableProcessors(), 4));
+        log.info("Updating default edge failure notification configs for all tenants");
+        AtomicInteger count = new AtomicInteger();
+        for (TenantId tenantId : tenants) {
+            executor.submit(() -> {
+                notificationSettingsService.updateDefaultNotificationConfigs(tenantId);
+                int n = count.incrementAndGet();
+                if (n % 500 == 0) {
+                    log.info("{} tenants processed", n);
+                }
+            });
+        }
+        executor.shutdown();
+        executor.awaitTermination(Integer.MAX_VALUE, TimeUnit.SECONDS);
         notificationSettingsService.updateDefaultNotificationConfigs(TenantId.SYS_TENANT_ID);
     }
 
diff --git a/application/src/main/java/org/thingsboard/server/service/notification/rule/trigger/EdgeCommunicationFailureTriggerProcessor.java b/application/src/main/java/org/thingsboard/server/service/notification/rule/trigger/EdgeCommunicationFailureTriggerProcessor.java
new file mode 100644
index 0000000000..38d8ae9805
--- /dev/null
+++ b/application/src/main/java/org/thingsboard/server/service/notification/rule/trigger/EdgeCommunicationFailureTriggerProcessor.java
@@ -0,0 +1,62 @@
+/**
+ * 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.service.notification.rule.trigger;
+
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.collections.CollectionUtils;
+import org.springframework.stereotype.Service;
+import org.thingsboard.server.common.data.notification.info.EdgeCommunicationFailureNotificationInfo;
+import org.thingsboard.server.common.data.notification.info.RuleOriginatedNotificationInfo;
+import org.thingsboard.server.common.data.notification.rule.trigger.EdgeCommunicationFailureTrigger;
+import org.thingsboard.server.common.data.notification.rule.trigger.config.EdgeCommunicationFailureNotificationRuleTriggerConfig;
+import org.thingsboard.server.common.data.notification.rule.trigger.config.NotificationRuleTriggerType;
+
+@Service
+@RequiredArgsConstructor
+public class EdgeCommunicationFailureTriggerProcessor implements NotificationRuleTriggerProcessor<EdgeCommunicationFailureTrigger, EdgeCommunicationFailureNotificationRuleTriggerConfig> {
+
+    @Override
+    public boolean matchesFilter(EdgeCommunicationFailureTrigger trigger, EdgeCommunicationFailureNotificationRuleTriggerConfig triggerConfig) {
+        if (CollectionUtils.isNotEmpty(triggerConfig.getEdges())) {
+            return !triggerConfig.getEdges().contains(trigger.getEdgeId().getId());
+        }
+        return true;
+    }
+
+    @Override
+    public RuleOriginatedNotificationInfo constructNotificationInfo(EdgeCommunicationFailureTrigger trigger) {
+        return EdgeCommunicationFailureNotificationInfo.builder()
+                .tenantId(trigger.getTenantId())
+                .edgeId(trigger.getEdgeId())
+                .customerId(trigger.getCustomerId())
+                .edgeName(trigger.getEdgeName())
+                .failureMsg(truncateFailureMsg(trigger.getFailureMsg()))
+                .build();
+    }
+
+    @Override
+    public NotificationRuleTriggerType getTriggerType() {
+        return NotificationRuleTriggerType.EDGE_COMMUNICATION_FAILURE;
+    }
+
+    private String truncateFailureMsg(String input) {
+        int maxLength = 500;
+        if (input != null && input.length() > maxLength) {
+            return input.substring(0, maxLength);
+        }
+        return input;
+    }
+}
diff --git a/application/src/main/java/org/thingsboard/server/service/notification/rule/trigger/EdgeConnectionTriggerProcessor.java b/application/src/main/java/org/thingsboard/server/service/notification/rule/trigger/EdgeConnectionTriggerProcessor.java
new file mode 100644
index 0000000000..ed1ee74622
--- /dev/null
+++ b/application/src/main/java/org/thingsboard/server/service/notification/rule/trigger/EdgeConnectionTriggerProcessor.java
@@ -0,0 +1,60 @@
+/**
+ * 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.service.notification.rule.trigger;
+
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.collections.CollectionUtils;
+import org.springframework.stereotype.Service;
+import org.thingsboard.server.common.data.notification.info.EdgeConnectionNotificationInfo;
+import org.thingsboard.server.common.data.notification.info.RuleOriginatedNotificationInfo;
+import org.thingsboard.server.common.data.notification.rule.trigger.EdgeConnectionTrigger;
+import org.thingsboard.server.common.data.notification.rule.trigger.config.EdgeConnectionNotificationRuleTriggerConfig;
+import org.thingsboard.server.common.data.notification.rule.trigger.config.EdgeConnectionNotificationRuleTriggerConfig.EdgeConnectivityEvent;
+import org.thingsboard.server.common.data.notification.rule.trigger.config.NotificationRuleTriggerType;
+
+@Service
+@RequiredArgsConstructor
+public class EdgeConnectionTriggerProcessor implements NotificationRuleTriggerProcessor<EdgeConnectionTrigger, EdgeConnectionNotificationRuleTriggerConfig> {
+
+    @Override
+    public boolean matchesFilter(EdgeConnectionTrigger trigger, EdgeConnectionNotificationRuleTriggerConfig triggerConfig) {
+        EdgeConnectivityEvent event = trigger.isConnected() ? EdgeConnectivityEvent.CONNECTED : EdgeConnectivityEvent.DISCONNECTED;
+        if (CollectionUtils.isEmpty(triggerConfig.getNotifyOn()) || !triggerConfig.getNotifyOn().contains(event)) {
+            return false;
+        }
+        if (CollectionUtils.isNotEmpty(triggerConfig.getEdges())) {
+            return triggerConfig.getEdges().contains(trigger.getEdgeId().getId());
+        }
+        return true;
+    }
+
+    @Override
+    public RuleOriginatedNotificationInfo constructNotificationInfo(EdgeConnectionTrigger trigger) {
+        return EdgeConnectionNotificationInfo.builder()
+                .eventType(trigger.isConnected() ? "connected" : "disconnected")
+                .tenantId(trigger.getTenantId())
+                .customerId(trigger.getCustomerId())
+                .edgeId(trigger.getEdgeId())
+                .edgeName(trigger.getEdgeName())
+                .build();
+    }
+
+    @Override
+    public NotificationRuleTriggerType getTriggerType() {
+        return NotificationRuleTriggerType.EDGE_CONNECTION;
+    }
+
+}
diff --git a/application/src/main/java/org/thingsboard/server/service/sync/ie/exporting/impl/NotificationRuleExportService.java b/application/src/main/java/org/thingsboard/server/service/sync/ie/exporting/impl/NotificationRuleExportService.java
index 7a7d176f81..35f2489f83 100644
--- a/application/src/main/java/org/thingsboard/server/service/sync/ie/exporting/impl/NotificationRuleExportService.java
+++ b/application/src/main/java/org/thingsboard/server/service/sync/ie/exporting/impl/NotificationRuleExportService.java
@@ -29,6 +29,8 @@ import org.thingsboard.server.common.data.notification.rule.EscalatedNotificatio
 import org.thingsboard.server.common.data.notification.rule.NotificationRule;
 import org.thingsboard.server.common.data.notification.rule.NotificationRuleRecipientsConfig;
 import org.thingsboard.server.common.data.notification.rule.trigger.config.DeviceActivityNotificationRuleTriggerConfig;
+import org.thingsboard.server.common.data.notification.rule.trigger.config.EdgeCommunicationFailureNotificationRuleTriggerConfig;
+import org.thingsboard.server.common.data.notification.rule.trigger.config.EdgeConnectionNotificationRuleTriggerConfig;
 import org.thingsboard.server.common.data.notification.rule.trigger.config.NotificationRuleTriggerConfig;
 import org.thingsboard.server.common.data.notification.rule.trigger.config.RuleEngineComponentLifecycleEventNotificationRuleTriggerConfig;
 import org.thingsboard.server.common.data.sync.ie.EntityExportData;
@@ -65,13 +67,24 @@ public class NotificationRuleExportService<I extends EntityId, E extends Exporta
                 }
                 break;
             }
-            case RULE_ENGINE_COMPONENT_LIFECYCLE_EVENT:
+            case RULE_ENGINE_COMPONENT_LIFECYCLE_EVENT: {
                 RuleEngineComponentLifecycleEventNotificationRuleTriggerConfig triggerConfig = (RuleEngineComponentLifecycleEventNotificationRuleTriggerConfig) ruleTriggerConfig;
                 Set<UUID> ruleChains = triggerConfig.getRuleChains();
                 if (ruleChains != null) {
                     triggerConfig.setRuleChains(toExternalIds(ruleChains, RuleChainId::new, ctx).collect(Collectors.toSet()));
                 }
                 break;
+            }
+            case EDGE_CONNECTION: {
+                EdgeConnectionNotificationRuleTriggerConfig triggerConfig = (EdgeConnectionNotificationRuleTriggerConfig) ruleTriggerConfig;
+                triggerConfig.setEdges(null);
+                break;
+            }
+            case EDGE_COMMUNICATION_FAILURE: {
+                EdgeCommunicationFailureNotificationRuleTriggerConfig triggerConfig = (EdgeCommunicationFailureNotificationRuleTriggerConfig) ruleTriggerConfig;
+                triggerConfig.setEdges(null);
+                break;
+            }
         }
 
         NotificationRuleRecipientsConfig ruleRecipientsConfig = notificationRule.getRecipientsConfig();
diff --git a/application/src/main/java/org/thingsboard/server/service/sync/ie/importing/impl/NotificationRuleImportService.java b/application/src/main/java/org/thingsboard/server/service/sync/ie/importing/impl/NotificationRuleImportService.java
index 72f0fa219e..dd53e5b5bc 100644
--- a/application/src/main/java/org/thingsboard/server/service/sync/ie/importing/impl/NotificationRuleImportService.java
+++ b/application/src/main/java/org/thingsboard/server/service/sync/ie/importing/impl/NotificationRuleImportService.java
@@ -33,6 +33,8 @@ import org.thingsboard.server.common.data.notification.rule.EscalatedNotificatio
 import org.thingsboard.server.common.data.notification.rule.NotificationRule;
 import org.thingsboard.server.common.data.notification.rule.NotificationRuleRecipientsConfig;
 import org.thingsboard.server.common.data.notification.rule.trigger.config.DeviceActivityNotificationRuleTriggerConfig;
+import org.thingsboard.server.common.data.notification.rule.trigger.config.EdgeConnectionNotificationRuleTriggerConfig;
+import org.thingsboard.server.common.data.notification.rule.trigger.config.EdgeCommunicationFailureNotificationRuleTriggerConfig;
 import org.thingsboard.server.common.data.notification.rule.trigger.config.NotificationRuleTriggerConfig;
 import org.thingsboard.server.common.data.notification.rule.trigger.config.NotificationRuleTriggerType;
 import org.thingsboard.server.common.data.notification.rule.trigger.config.RuleEngineComponentLifecycleEventNotificationRuleTriggerConfig;
@@ -86,7 +88,7 @@ public class NotificationRuleImportService extends BaseEntityImportService<Notif
                 }
                 break;
             }
-            case RULE_ENGINE_COMPONENT_LIFECYCLE_EVENT:
+            case RULE_ENGINE_COMPONENT_LIFECYCLE_EVENT: {
                 RuleEngineComponentLifecycleEventNotificationRuleTriggerConfig triggerConfig = (RuleEngineComponentLifecycleEventNotificationRuleTriggerConfig) ruleTriggerConfig;
                 Set<UUID> ruleChains = triggerConfig.getRuleChains();
                 if (ruleChains != null) {
@@ -95,6 +97,17 @@ public class NotificationRuleImportService extends BaseEntityImportService<Notif
                             .collect(Collectors.toSet()));
                 }
                 break;
+            }
+            case EDGE_CONNECTION: {
+                EdgeConnectionNotificationRuleTriggerConfig triggerConfig = (EdgeConnectionNotificationRuleTriggerConfig) ruleTriggerConfig;
+                triggerConfig.setEdges(null);
+                break;
+            }
+            case EDGE_COMMUNICATION_FAILURE: {
+                EdgeCommunicationFailureNotificationRuleTriggerConfig triggerConfig = (EdgeCommunicationFailureNotificationRuleTriggerConfig) ruleTriggerConfig;
+                triggerConfig.setEdges(null);
+                break;
+            }
         }
         if (!triggerType.isTenantLevel()) {
             throw new IllegalArgumentException("Trigger type " + triggerType + " is not available for tenants");
diff --git a/application/src/test/java/org/thingsboard/server/controller/AbstractNotifyEntityTest.java b/application/src/test/java/org/thingsboard/server/controller/AbstractNotifyEntityTest.java
index 44302f08ba..314fe4c28c 100644
--- a/application/src/test/java/org/thingsboard/server/controller/AbstractNotifyEntityTest.java
+++ b/application/src/test/java/org/thingsboard/server/controller/AbstractNotifyEntityTest.java
@@ -154,24 +154,6 @@ public abstract class AbstractNotifyEntityTest extends AbstractWebTest {
         Mockito.reset(tbClusterService, auditLogService);
     }
 
-    protected void testNotifyManyEntityManyTimeMsgToEdgeServiceNever(HasName entity, HasName originator,
-                                                                     TenantId tenantId, CustomerId customerId, UserId userId, String userName,
-                                                                     ActionType actionType, int cntTime, Object... additionalInfo) {
-        EntityId entityId = createEntityId_NULL_UUID(entity);
-        EntityId originatorId = createEntityId_NULL_UUID(originator);
-        testNotificationMsgToEdgeServiceNeverWithActionType(entityId, actionType);
-        ArgumentMatcher<HasName> matcherEntityClassEquals = argument -> argument.getClass().equals(entity.getClass());
-        ArgumentMatcher<EntityId> matcherOriginatorId = argument -> argument.getClass().equals(originatorId.getClass());
-        ArgumentMatcher<CustomerId> matcherCustomerId = customerId == null ?
-                argument -> argument.getClass().equals(CustomerId.class) : argument -> argument.equals(customerId);
-        ArgumentMatcher<UserId> matcherUserId = userId == null ?
-                argument -> argument.getClass().equals(UserId.class) : argument -> argument.equals(userId);
-        testLogEntityActionAdditionalInfo(matcherEntityClassEquals, matcherOriginatorId, tenantId, matcherCustomerId, matcherUserId, userName, actionType, cntTime,
-                extractMatcherAdditionalInfo(additionalInfo));
-        testPushMsgToRuleEngineTime(matcherOriginatorId, tenantId, entity, cntTime);
-        Mockito.reset(tbClusterService, auditLogService);
-    }
-
     protected void testNotifyManyEntityManyTimeMsgToEdgeServiceEntityEqAny(HasName entity, HasName originator,
                                                                            TenantId tenantId, CustomerId customerId, UserId userId, String userName,
                                                                            ActionType actionType,
@@ -624,7 +606,7 @@ public abstract class AbstractNotifyEntityTest extends AbstractWebTest {
     private String entityClassToString(HasName entity) {
         String className = entity.getClass().toString()
                 .substring(entity.getClass().toString().lastIndexOf(".") + 1);
-        List str = className.chars()
+        List<String> str = className.chars()
                 .mapToObj(x -> (Character.isUpperCase(x)) ? "_" + Character.toString(x) : Character.toString(x))
                 .collect(Collectors.toList());
         return String.join("", str).toUpperCase(Locale.ENGLISH).substring(1);
diff --git a/application/src/test/java/org/thingsboard/server/service/limits/RateLimitServiceTest.java b/application/src/test/java/org/thingsboard/server/service/limits/RateLimitServiceTest.java
index afdb38a2ec..2570b80f9f 100644
--- a/application/src/test/java/org/thingsboard/server/service/limits/RateLimitServiceTest.java
+++ b/application/src/test/java/org/thingsboard/server/service/limits/RateLimitServiceTest.java
@@ -69,6 +69,8 @@ public class RateLimitServiceTest {
         profileConfiguration.setCustomerServerRestLimitsConfiguration(rateLimit);
         profileConfiguration.setWsUpdatesPerSessionRateLimit(rateLimit);
         profileConfiguration.setCassandraQueryTenantRateLimitsConfiguration(rateLimit);
+        profileConfiguration.setEdgeEventRateLimits(rateLimit);
+        profileConfiguration.setEdgeEventRateLimitsPerEdge(rateLimit);
         updateTenantProfileConfiguration(profileConfiguration);
 
         for (LimitedApi limitedApi : List.of(
@@ -76,7 +78,9 @@ public class RateLimitServiceTest {
                 LimitedApi.ENTITY_IMPORT,
                 LimitedApi.NOTIFICATION_REQUESTS,
                 LimitedApi.REST_REQUESTS_PER_CUSTOMER,
-                LimitedApi.CASSANDRA_QUERIES
+                LimitedApi.CASSANDRA_QUERIES,
+                LimitedApi.EDGE_EVENTS,
+                LimitedApi.EDGE_EVENTS_PER_EDGE
         )) {
             testRateLimits(limitedApi, max, tenantId);
         }
diff --git a/common/data/src/main/java/org/thingsboard/server/common/data/limit/LimitedApi.java b/common/data/src/main/java/org/thingsboard/server/common/data/limit/LimitedApi.java
index 5f743f626a..980eb880a0 100644
--- a/common/data/src/main/java/org/thingsboard/server/common/data/limit/LimitedApi.java
+++ b/common/data/src/main/java/org/thingsboard/server/common/data/limit/LimitedApi.java
@@ -31,6 +31,8 @@ public enum LimitedApi {
     REST_REQUESTS_PER_CUSTOMER(DefaultTenantProfileConfiguration::getCustomerServerRestLimitsConfiguration, "REST API requests per customer", false),
     WS_UPDATES_PER_SESSION(DefaultTenantProfileConfiguration::getWsUpdatesPerSessionRateLimit, "WS updates per session", true),
     CASSANDRA_QUERIES(DefaultTenantProfileConfiguration::getCassandraQueryTenantRateLimitsConfiguration, "Cassandra queries", true),
+    EDGE_EVENTS(DefaultTenantProfileConfiguration::getEdgeEventRateLimits, "Edge events", true),
+    EDGE_EVENTS_PER_EDGE(DefaultTenantProfileConfiguration::getEdgeEventRateLimitsPerEdge, "Edge events per edge", false),
     PASSWORD_RESET(false, true),
     TWO_FA_VERIFICATION_CODE_SEND(false, true),
     TWO_FA_VERIFICATION_CODE_CHECK(false, true),
diff --git a/common/data/src/main/java/org/thingsboard/server/common/data/notification/NotificationType.java b/common/data/src/main/java/org/thingsboard/server/common/data/notification/NotificationType.java
index 8eb4451e3b..cfc91d8fca 100644
--- a/common/data/src/main/java/org/thingsboard/server/common/data/notification/NotificationType.java
+++ b/common/data/src/main/java/org/thingsboard/server/common/data/notification/NotificationType.java
@@ -28,6 +28,7 @@ public enum NotificationType {
     ENTITIES_LIMIT,
     API_USAGE_LIMIT,
     RULE_NODE,
-    RATE_LIMITS
-
+    RATE_LIMITS,
+    EDGE_CONNECTION,
+    EDGE_COMMUNICATION_FAILURE
 }
diff --git a/common/data/src/main/java/org/thingsboard/server/common/data/notification/info/EdgeCommunicationFailureNotificationInfo.java b/common/data/src/main/java/org/thingsboard/server/common/data/notification/info/EdgeCommunicationFailureNotificationInfo.java
new file mode 100644
index 0000000000..6d0f2ae5f5
--- /dev/null
+++ b/common/data/src/main/java/org/thingsboard/server/common/data/notification/info/EdgeCommunicationFailureNotificationInfo.java
@@ -0,0 +1,66 @@
+/**
+ * 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.data.notification.info;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.thingsboard.server.common.data.id.CustomerId;
+import org.thingsboard.server.common.data.id.EdgeId;
+import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
+
+import java.util.Map;
+
+import static org.thingsboard.server.common.data.util.CollectionsUtil.mapOf;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class EdgeCommunicationFailureNotificationInfo implements RuleOriginatedNotificationInfo {
+
+    private TenantId tenantId;
+    private CustomerId customerId;
+    private EdgeId edgeId;
+    private String edgeName;
+    private String failureMsg;
+
+    @Override
+    public Map<String, String> getTemplateData() {
+        return mapOf(
+                "edgeId", edgeId.toString(),
+                "edgeName", edgeName,
+                "failureMsg", failureMsg
+        );
+    }
+
+    @Override
+    public TenantId getAffectedTenantId() {
+        return tenantId;
+    }
+
+    @Override
+    public CustomerId getAffectedCustomerId() {
+        return customerId;
+    }
+
+    @Override
+    public EntityId getStateEntityId() {
+        return edgeId;
+    }
+}
diff --git a/common/data/src/main/java/org/thingsboard/server/common/data/notification/info/EdgeConnectionNotificationInfo.java b/common/data/src/main/java/org/thingsboard/server/common/data/notification/info/EdgeConnectionNotificationInfo.java
new file mode 100644
index 0000000000..62b1370566
--- /dev/null
+++ b/common/data/src/main/java/org/thingsboard/server/common/data/notification/info/EdgeConnectionNotificationInfo.java
@@ -0,0 +1,66 @@
+/**
+ * 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.data.notification.info;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.thingsboard.server.common.data.id.CustomerId;
+import org.thingsboard.server.common.data.id.EdgeId;
+import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
+
+import java.util.Map;
+
+import static org.thingsboard.server.common.data.util.CollectionsUtil.mapOf;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class EdgeConnectionNotificationInfo implements RuleOriginatedNotificationInfo {
+
+    private String eventType;
+    private TenantId tenantId;
+    private CustomerId customerId;
+    private EdgeId edgeId;
+    private String edgeName;
+
+    @Override
+    public Map<String, String> getTemplateData() {
+        return mapOf(
+                "eventType", eventType,
+                "edgeId", edgeId.toString(),
+                "edgeName", edgeName
+        );
+    }
+
+    @Override
+    public TenantId getAffectedTenantId() {
+        return tenantId;
+    }
+
+    @Override
+    public CustomerId getAffectedCustomerId() {
+        return customerId;
+    }
+
+    @Override
+    public EntityId getStateEntityId() {
+        return edgeId;
+    }
+}
diff --git a/common/data/src/main/java/org/thingsboard/server/common/data/notification/rule/trigger/EdgeCommunicationFailureTrigger.java b/common/data/src/main/java/org/thingsboard/server/common/data/notification/rule/trigger/EdgeCommunicationFailureTrigger.java
new file mode 100644
index 0000000000..6212c22a0d
--- /dev/null
+++ b/common/data/src/main/java/org/thingsboard/server/common/data/notification/rule/trigger/EdgeCommunicationFailureTrigger.java
@@ -0,0 +1,63 @@
+/**
+ * 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.data.notification.rule.trigger;
+
+import lombok.Builder;
+import lombok.Data;
+import org.thingsboard.server.common.data.id.CustomerId;
+import org.thingsboard.server.common.data.id.EdgeId;
+import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.data.notification.rule.trigger.config.NotificationRuleTriggerType;
+
+import java.util.concurrent.TimeUnit;
+
+@Data
+@Builder
+public class EdgeCommunicationFailureTrigger implements NotificationRuleTrigger {
+
+    private final TenantId tenantId;
+    private final CustomerId customerId;
+    private final EdgeId edgeId;
+    private final String edgeName;
+    private final String failureMsg;
+    private final String error;
+
+    @Override
+    public boolean deduplicate() {
+        return true;
+    }
+
+    @Override
+    public String getDeduplicationKey() {
+        return String.join(":", NotificationRuleTrigger.super.getDeduplicationKey(), error);
+    }
+
+    @Override
+    public long getDefaultDeduplicationDuration() {
+        return TimeUnit.MINUTES.toMillis(30);
+    }
+
+    @Override
+    public NotificationRuleTriggerType getType() {
+        return NotificationRuleTriggerType.EDGE_COMMUNICATION_FAILURE;
+    }
+
+    @Override
+    public EntityId getOriginatorEntityId() {
+        return edgeId;
+    }
+}
diff --git a/common/data/src/main/java/org/thingsboard/server/common/data/notification/rule/trigger/EdgeConnectionTrigger.java b/common/data/src/main/java/org/thingsboard/server/common/data/notification/rule/trigger/EdgeConnectionTrigger.java
new file mode 100644
index 0000000000..766338dba6
--- /dev/null
+++ b/common/data/src/main/java/org/thingsboard/server/common/data/notification/rule/trigger/EdgeConnectionTrigger.java
@@ -0,0 +1,62 @@
+/**
+ * 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.data.notification.rule.trigger;
+
+import lombok.Builder;
+import lombok.Data;
+import org.thingsboard.server.common.data.id.CustomerId;
+import org.thingsboard.server.common.data.id.EdgeId;
+import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.data.notification.rule.trigger.config.NotificationRuleTriggerType;
+
+import java.util.concurrent.TimeUnit;
+
+@Data
+@Builder
+public class EdgeConnectionTrigger implements NotificationRuleTrigger {
+
+    private final TenantId tenantId;
+    private final CustomerId customerId;
+    private final EdgeId edgeId;
+    private final boolean connected;
+    private final String edgeName;
+
+    @Override
+    public boolean deduplicate() {
+        return true;
+    }
+
+    @Override
+    public String getDeduplicationKey() {
+        return String.join(":", NotificationRuleTrigger.super.getDeduplicationKey(), String.valueOf(connected));
+    }
+
+    @Override
+    public long getDefaultDeduplicationDuration() {
+        return TimeUnit.MINUTES.toMillis(1);
+    }
+
+    @Override
+    public NotificationRuleTriggerType getType() {
+        return NotificationRuleTriggerType.EDGE_CONNECTION;
+    }
+
+    @Override
+    public EntityId getOriginatorEntityId() {
+        return edgeId;
+    }
+}
diff --git a/common/data/src/main/java/org/thingsboard/server/common/data/notification/rule/trigger/config/EdgeCommunicationFailureNotificationRuleTriggerConfig.java b/common/data/src/main/java/org/thingsboard/server/common/data/notification/rule/trigger/config/EdgeCommunicationFailureNotificationRuleTriggerConfig.java
new file mode 100644
index 0000000000..595b0fa7d5
--- /dev/null
+++ b/common/data/src/main/java/org/thingsboard/server/common/data/notification/rule/trigger/config/EdgeCommunicationFailureNotificationRuleTriggerConfig.java
@@ -0,0 +1,39 @@
+/**
+ * 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.data.notification.rule.trigger.config;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.Set;
+import java.util.UUID;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class EdgeCommunicationFailureNotificationRuleTriggerConfig implements NotificationRuleTriggerConfig {
+
+    private Set<UUID> edges; // if empty - all edges
+
+    @Override
+    public NotificationRuleTriggerType getTriggerType() {
+        return NotificationRuleTriggerType.EDGE_COMMUNICATION_FAILURE;
+    }
+
+}
diff --git a/common/data/src/main/java/org/thingsboard/server/common/data/notification/rule/trigger/config/EdgeConnectionNotificationRuleTriggerConfig.java b/common/data/src/main/java/org/thingsboard/server/common/data/notification/rule/trigger/config/EdgeConnectionNotificationRuleTriggerConfig.java
new file mode 100644
index 0000000000..8c0905cc59
--- /dev/null
+++ b/common/data/src/main/java/org/thingsboard/server/common/data/notification/rule/trigger/config/EdgeConnectionNotificationRuleTriggerConfig.java
@@ -0,0 +1,44 @@
+/**
+ * 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.data.notification.rule.trigger.config;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.Set;
+import java.util.UUID;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class EdgeConnectionNotificationRuleTriggerConfig implements NotificationRuleTriggerConfig {
+
+    private Set<UUID> edges; // if empty - all edges
+    private Set<EdgeConnectivityEvent> notifyOn;
+
+    @Override
+    public NotificationRuleTriggerType getTriggerType() {
+        return NotificationRuleTriggerType.EDGE_CONNECTION;
+    }
+
+    public enum EdgeConnectivityEvent {
+        CONNECTED, DISCONNECTED
+    }
+
+}
diff --git a/common/data/src/main/java/org/thingsboard/server/common/data/notification/rule/trigger/config/NotificationRuleTriggerConfig.java b/common/data/src/main/java/org/thingsboard/server/common/data/notification/rule/trigger/config/NotificationRuleTriggerConfig.java
index 5ffb8a5fe1..15a5e59255 100644
--- a/common/data/src/main/java/org/thingsboard/server/common/data/notification/rule/trigger/config/NotificationRuleTriggerConfig.java
+++ b/common/data/src/main/java/org/thingsboard/server/common/data/notification/rule/trigger/config/NotificationRuleTriggerConfig.java
@@ -36,6 +36,8 @@ import java.io.Serializable;
         @Type(value = EntitiesLimitNotificationRuleTriggerConfig.class, name = "ENTITIES_LIMIT"),
         @Type(value = ApiUsageLimitNotificationRuleTriggerConfig.class, name = "API_USAGE_LIMIT"),
         @Type(value = RateLimitsNotificationRuleTriggerConfig.class, name = "RATE_LIMITS"),
+        @Type(value = EdgeConnectionNotificationRuleTriggerConfig.class, name = "EDGE_CONNECTION"),
+        @Type(value = EdgeCommunicationFailureNotificationRuleTriggerConfig.class, name = "EDGE_COMMUNICATION_FAILURE"),
 })
 public interface NotificationRuleTriggerConfig extends Serializable {
 
diff --git a/common/data/src/main/java/org/thingsboard/server/common/data/notification/rule/trigger/config/NotificationRuleTriggerType.java b/common/data/src/main/java/org/thingsboard/server/common/data/notification/rule/trigger/config/NotificationRuleTriggerType.java
index 6eff7a8114..8469fac752 100644
--- a/common/data/src/main/java/org/thingsboard/server/common/data/notification/rule/trigger/config/NotificationRuleTriggerType.java
+++ b/common/data/src/main/java/org/thingsboard/server/common/data/notification/rule/trigger/config/NotificationRuleTriggerType.java
@@ -26,6 +26,8 @@ public enum NotificationRuleTriggerType {
     ALARM_ASSIGNMENT,
     DEVICE_ACTIVITY,
     RULE_ENGINE_COMPONENT_LIFECYCLE_EVENT,
+    EDGE_CONNECTION,
+    EDGE_COMMUNICATION_FAILURE,
     NEW_PLATFORM_VERSION(false),
     ENTITIES_LIMIT(false),
     API_USAGE_LIMIT(false),
diff --git a/common/data/src/main/java/org/thingsboard/server/common/data/tenant/profile/DefaultTenantProfileConfiguration.java b/common/data/src/main/java/org/thingsboard/server/common/data/tenant/profile/DefaultTenantProfileConfiguration.java
index 1a4df035f5..3fe110de0b 100644
--- a/common/data/src/main/java/org/thingsboard/server/common/data/tenant/profile/DefaultTenantProfileConfiguration.java
+++ b/common/data/src/main/java/org/thingsboard/server/common/data/tenant/profile/DefaultTenantProfileConfiguration.java
@@ -81,6 +81,9 @@ public class DefaultTenantProfileConfiguration implements TenantProfileConfigura
 
     private String cassandraQueryTenantRateLimitsConfiguration;
 
+    private String edgeEventRateLimits;
+    private String edgeEventRateLimitsPerEdge;
+
     private int defaultStorageTtlDays;
     private int alarmsTtlDays;
     private int rpcTtlDays;
diff --git a/common/data/src/main/java/org/thingsboard/server/common/data/util/TemplateUtils.java b/common/data/src/main/java/org/thingsboard/server/common/data/util/TemplateUtils.java
index 3bc2aac1f8..a6b1c11d42 100644
--- a/common/data/src/main/java/org/thingsboard/server/common/data/util/TemplateUtils.java
+++ b/common/data/src/main/java/org/thingsboard/server/common/data/util/TemplateUtils.java
@@ -19,6 +19,7 @@ import org.apache.commons.lang3.StringUtils;
 
 import java.util.Map;
 import java.util.function.UnaryOperator;
+import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 import static com.google.common.base.Strings.nullToEmpty;
@@ -49,7 +50,7 @@ public class TemplateUtils {
                     value = FUNCTIONS.get(function).apply(value);
                 }
             }
-            return value;
+            return Matcher.quoteReplacement(value);
         });
     }
 
diff --git a/dao/src/main/java/org/thingsboard/server/dao/edge/BaseEdgeEventService.java b/dao/src/main/java/org/thingsboard/server/dao/edge/BaseEdgeEventService.java
index 9ea70f6c5a..43c3dc4914 100644
--- a/dao/src/main/java/org/thingsboard/server/dao/edge/BaseEdgeEventService.java
+++ b/dao/src/main/java/org/thingsboard/server/dao/edge/BaseEdgeEventService.java
@@ -19,12 +19,16 @@ import com.google.common.util.concurrent.ListenableFuture;
 import lombok.AllArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
+import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.edge.EdgeEvent;
 import org.thingsboard.server.common.data.id.EdgeId;
 import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.data.limit.LimitedApi;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.TimePageLink;
+import org.thingsboard.server.common.msg.tools.TbRateLimitsException;
 import org.thingsboard.server.dao.service.DataValidator;
+import org.thingsboard.server.dao.util.limits.RateLimitService;
 
 @Service
 @Slf4j
@@ -32,11 +36,17 @@ import org.thingsboard.server.dao.service.DataValidator;
 public class BaseEdgeEventService implements EdgeEventService {
 
     private final EdgeEventDao edgeEventDao;
-
+    private final RateLimitService rateLimitService;
     private final DataValidator<EdgeEvent> edgeEventValidator;
 
     @Override
     public ListenableFuture<Void> saveAsync(EdgeEvent edgeEvent) {
+        if (!rateLimitService.checkRateLimit(LimitedApi.EDGE_EVENTS, edgeEvent.getTenantId())) {
+            throw new TbRateLimitsException(EntityType.TENANT);
+        }
+        if (!rateLimitService.checkRateLimit(LimitedApi.EDGE_EVENTS_PER_EDGE, edgeEvent.getTenantId(), edgeEvent.getEdgeId())) {
+            throw new TbRateLimitsException(EntityType.EDGE);
+        }
         edgeEventValidator.validate(edgeEvent, EdgeEvent::getTenantId);
         return edgeEventDao.saveAsync(edgeEvent);
     }
diff --git a/dao/src/main/java/org/thingsboard/server/dao/notification/DefaultNotificationSettingsService.java b/dao/src/main/java/org/thingsboard/server/dao/notification/DefaultNotificationSettingsService.java
index 59787a01a7..c858eecf62 100644
--- a/dao/src/main/java/org/thingsboard/server/dao/notification/DefaultNotificationSettingsService.java
+++ b/dao/src/main/java/org/thingsboard/server/dao/notification/DefaultNotificationSettingsService.java
@@ -41,6 +41,7 @@ import org.thingsboard.server.common.data.notification.targets.platform.SystemAd
 import org.thingsboard.server.common.data.notification.targets.platform.TenantAdministratorsFilter;
 import org.thingsboard.server.common.data.notification.targets.platform.UsersFilter;
 import org.thingsboard.server.common.data.notification.targets.platform.UsersFilterType;
+import org.thingsboard.server.common.data.notification.template.NotificationTemplate;
 import org.thingsboard.server.common.data.page.PageLink;
 import org.thingsboard.server.common.data.settings.UserSettings;
 import org.thingsboard.server.common.data.settings.UserSettingsType;
@@ -53,6 +54,7 @@ import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.stream.Collectors;
 
 @Service
 @RequiredArgsConstructor
@@ -187,6 +189,8 @@ public class DefaultNotificationSettingsService implements NotificationSettingsS
         defaultNotifications.create(tenantId, DefaultNotifications.alarmComment, tenantAdmins.getId());
         defaultNotifications.create(tenantId, DefaultNotifications.alarmAssignment, affectedUser.getId());
         defaultNotifications.create(tenantId, DefaultNotifications.ruleEngineComponentLifecycleFailure, tenantAdmins.getId());
+        defaultNotifications.create(tenantId, DefaultNotifications.edgeConnection, tenantAdmins.getId());
+        defaultNotifications.create(tenantId, DefaultNotifications.edgeCommunicationFailures, tenantAdmins.getId());
     }
 
     @Override
@@ -198,17 +202,43 @@ public class DefaultNotificationSettingsService implements NotificationSettingsS
             }
 
             NotificationTarget sysAdmins = notificationTargetService.findNotificationTargetsByTenantIdAndUsersFilterType(tenantId, UsersFilterType.SYSTEM_ADMINISTRATORS).stream()
-                    .findFirst().orElseGet(() -> {
-                        return createTarget(tenantId, "System administrators", new SystemAdministratorsFilter(), "All system administrators");
-                    });
+                    .findFirst().orElseGet(() -> createTarget(tenantId, "System administrators", new SystemAdministratorsFilter(), "All system administrators"));
             NotificationTarget affectedTenantAdmins = notificationTargetService.findNotificationTargetsByTenantIdAndUsersFilterType(tenantId, UsersFilterType.AFFECTED_TENANT_ADMINISTRATORS).stream()
-                    .findFirst().orElseGet(() -> {
-                        return createTarget(tenantId, "Affected tenant's administrators", new AffectedTenantAdministratorsFilter(), "");
-                    });
+                    .findFirst().orElseGet(() -> createTarget(tenantId, "Affected tenant's administrators", new AffectedTenantAdministratorsFilter(), ""));
 
             defaultNotifications.create(tenantId, DefaultNotifications.exceededRateLimits, affectedTenantAdmins.getId());
             defaultNotifications.create(tenantId, DefaultNotifications.exceededPerEntityRateLimits, affectedTenantAdmins.getId());
             defaultNotifications.create(tenantId, DefaultNotifications.exceededRateLimitsForSysadmin, sysAdmins.getId());
+        } else {
+            var requiredNotificationTypes = List.of(NotificationType.EDGE_CONNECTION, NotificationType.EDGE_COMMUNICATION_FAILURE);
+            var existingNotificationTypes = notificationTemplateService.findNotificationTemplatesByTenantIdAndNotificationTypes(
+                            tenantId, requiredNotificationTypes, new PageLink(1))
+                    .getData()
+                    .stream()
+                    .map(NotificationTemplate::getNotificationType)
+                    .collect(Collectors.toSet());
+
+            if (existingNotificationTypes.containsAll(requiredNotificationTypes)) {
+                return;
+            }
+
+            NotificationTarget tenantAdmins = notificationTargetService.findNotificationTargetsByTenantIdAndUsersFilterType(tenantId, UsersFilterType.TENANT_ADMINISTRATORS)
+                    .stream()
+                    .findFirst()
+                    .orElseGet(() -> createTarget(tenantId, "Tenant administrators", new TenantAdministratorsFilter(), "Tenant administrators"));
+
+            for (NotificationType type : requiredNotificationTypes) {
+                if (!existingNotificationTypes.contains(type)) {
+                    switch (type) {
+                        case EDGE_CONNECTION:
+                            defaultNotifications.create(tenantId, DefaultNotifications.edgeConnection, tenantAdmins.getId());
+                            break;
+                        case EDGE_COMMUNICATION_FAILURE:
+                            defaultNotifications.create(tenantId, DefaultNotifications.edgeCommunicationFailures, tenantAdmins.getId());
+                            break;
+                    }
+                }
+            }
         }
     }
 
diff --git a/dao/src/main/java/org/thingsboard/server/dao/notification/DefaultNotifications.java b/dao/src/main/java/org/thingsboard/server/dao/notification/DefaultNotifications.java
index 5a78fa9864..1ef0006e87 100644
--- a/dao/src/main/java/org/thingsboard/server/dao/notification/DefaultNotifications.java
+++ b/dao/src/main/java/org/thingsboard/server/dao/notification/DefaultNotifications.java
@@ -40,6 +40,9 @@ import org.thingsboard.server.common.data.notification.rule.trigger.config.Alarm
 import org.thingsboard.server.common.data.notification.rule.trigger.config.ApiUsageLimitNotificationRuleTriggerConfig;
 import org.thingsboard.server.common.data.notification.rule.trigger.config.DeviceActivityNotificationRuleTriggerConfig;
 import org.thingsboard.server.common.data.notification.rule.trigger.config.DeviceActivityNotificationRuleTriggerConfig.DeviceEvent;
+import org.thingsboard.server.common.data.notification.rule.trigger.config.EdgeConnectionNotificationRuleTriggerConfig;
+import org.thingsboard.server.common.data.notification.rule.trigger.config.EdgeConnectionNotificationRuleTriggerConfig.EdgeConnectivityEvent;
+import org.thingsboard.server.common.data.notification.rule.trigger.config.EdgeCommunicationFailureNotificationRuleTriggerConfig;
 import org.thingsboard.server.common.data.notification.rule.trigger.config.EntitiesLimitNotificationRuleTriggerConfig;
 import org.thingsboard.server.common.data.notification.rule.trigger.config.EntityActionNotificationRuleTriggerConfig;
 import org.thingsboard.server.common.data.notification.rule.trigger.config.NewPlatformVersionNotificationRuleTriggerConfig;
@@ -325,6 +328,35 @@ public class DefaultNotifications {
                     .description("Send notification to tenant admins when any Rule chain or Rule node failed to start, update or stop")
                     .build())
             .build();
+    public static final DefaultNotification edgeConnection = DefaultNotification.builder()
+            .name("Edge connection notification")
+            .type(NotificationType.EDGE_CONNECTION)
+            .subject("Edge connection status change")
+            .text("Edge '${edgeName}' is now ${eventType}")
+            .icon("info").color(null)
+            .button("Go to Edge").link("/edgeManagement/instances/${edgeId}")
+            .rule(DefaultRule.builder()
+                    .name("Edge connection status change")
+                    .triggerConfig(EdgeConnectionNotificationRuleTriggerConfig.builder()
+                            .edges(null)
+                            .notifyOn(Set.of(EdgeConnectivityEvent.CONNECTED, EdgeConnectivityEvent.DISCONNECTED))
+                            .build())
+                    .description("Send notification to tenant admins when the connection status between TB and Edge changes")
+                    .build())
+            .build();
+    public static final DefaultNotification edgeCommunicationFailures = DefaultNotification.builder()
+            .name("Edge communication failure notification")
+            .type(NotificationType.EDGE_COMMUNICATION_FAILURE)
+            .subject("Edge '${edgeName}' communication failure occured")
+            .text("Failure message: '${failureMsg}'")
+            .icon("error").color(RED_COLOR)
+            .button("Go to Edge").link("/edgeManagement/instances/${edgeId}")
+            .rule(DefaultRule.builder()
+                    .name("Edge communication failure")
+                    .triggerConfig(EdgeCommunicationFailureNotificationRuleTriggerConfig.builder().edges(null).build())
+                    .description("Send notification to tenant admins when communication failures occur")
+                    .build())
+            .build();
 
     public static final DefaultNotification jwtSigningKeyIssue = DefaultNotification.builder()
             .name("JWT Signing Key issue notification")
@@ -346,7 +378,7 @@ public class DefaultNotifications {
         if (defaultNotification.getRule() != null && targets.length > 0) {
             NotificationRule rule = defaultNotification.toRule(template.getId(), targets);
             rule.setTenantId(tenantId);
-            rule = ruleService.saveNotificationRule(tenantId, rule);
+            ruleService.saveNotificationRule(tenantId, rule);
         }
     }
 
diff --git a/dao/src/test/java/org/thingsboard/server/dao/service/EdgeEventServiceTest.java b/dao/src/test/java/org/thingsboard/server/dao/service/EdgeEventServiceTest.java
index 2a03a1277c..2cc179fae2 100644
--- a/dao/src/test/java/org/thingsboard/server/dao/service/EdgeEventServiceTest.java
+++ b/dao/src/test/java/org/thingsboard/server/dao/service/EdgeEventServiceTest.java
@@ -40,7 +40,7 @@ import java.text.ParseException;
 import java.util.ArrayList;
 import java.util.List;
 
-import static org.apache.commons.lang3.time.DateFormatUtils.ISO_DATETIME_TIME_ZONE_FORMAT;
+import static org.apache.commons.lang3.time.DateFormatUtils.ISO_8601_EXTENDED_DATETIME_FORMAT;
 
 @DaoSqlTest
 public class EdgeEventServiceTest extends AbstractServiceTest {
@@ -56,19 +56,18 @@ public class EdgeEventServiceTest extends AbstractServiceTest {
 
     @Before
     public void before() throws ParseException {
-        timeBeforeStartTime = ISO_DATETIME_TIME_ZONE_FORMAT.parse("2016-11-01T11:30:00Z").getTime();
-        startTime = ISO_DATETIME_TIME_ZONE_FORMAT.parse("2016-11-01T12:00:00Z").getTime();
-        eventTime = ISO_DATETIME_TIME_ZONE_FORMAT.parse("2016-11-01T12:30:00Z").getTime();
-        endTime = ISO_DATETIME_TIME_ZONE_FORMAT.parse("2016-11-01T13:00:00Z").getTime();
-        timeAfterEndTime = ISO_DATETIME_TIME_ZONE_FORMAT.parse("2016-11-01T13:30:30Z").getTime();
+        timeBeforeStartTime = ISO_8601_EXTENDED_DATETIME_FORMAT.parse("2016-11-01T11:30:00").getTime();
+        startTime = ISO_8601_EXTENDED_DATETIME_FORMAT.parse("2016-11-01T12:00:00").getTime();
+        eventTime = ISO_8601_EXTENDED_DATETIME_FORMAT.parse("2016-11-01T12:30:00").getTime();
+        endTime = ISO_8601_EXTENDED_DATETIME_FORMAT.parse("2016-11-01T13:00:00").getTime();
+        timeAfterEndTime = ISO_8601_EXTENDED_DATETIME_FORMAT.parse("2016-11-01T13:30:30").getTime();
     }
 
     @Test
     public void saveEdgeEvent() throws Exception {
         EdgeId edgeId = new EdgeId(Uuids.timeBased());
         DeviceId deviceId = new DeviceId(Uuids.timeBased());
-        TenantId tenantId = new TenantId(Uuids.timeBased());
-        EdgeEvent edgeEvent = generateEdgeEvent(tenantId, edgeId, deviceId, EdgeEventActionType.ADDED);
+        EdgeEvent edgeEvent = generateEdgeEvent(tenantId, edgeId, deviceId);
         edgeEventService.saveAsync(edgeEvent).get();
 
         PageData<EdgeEvent> edgeEvents = edgeEventService.findEdgeEvents(tenantId, edgeId, 0L, null, new TimePageLink(1));
@@ -81,9 +80,11 @@ public class EdgeEventServiceTest extends AbstractServiceTest {
         Assert.assertEquals(saved.getType(), edgeEvent.getType());
         Assert.assertEquals(saved.getAction(), edgeEvent.getAction());
         Assert.assertEquals(saved.getBody(), edgeEvent.getBody());
+
+        edgeEventService.cleanupEvents(1);
     }
 
-    protected EdgeEvent generateEdgeEvent(TenantId tenantId, EdgeId edgeId, EntityId entityId, EdgeEventActionType edgeEventAction) throws IOException {
+    protected EdgeEvent generateEdgeEvent(TenantId tenantId, EdgeId edgeId, EntityId entityId) throws IOException {
         if (tenantId == null) {
             tenantId = TenantId.fromUUID(Uuids.timeBased());
         }
@@ -92,7 +93,7 @@ public class EdgeEventServiceTest extends AbstractServiceTest {
         edgeEvent.setEdgeId(edgeId);
         edgeEvent.setEntityId(entityId.getId());
         edgeEvent.setType(EdgeEventType.DEVICE);
-        edgeEvent.setAction(edgeEventAction);
+        edgeEvent.setAction(EdgeEventActionType.ADDED);
         edgeEvent.setBody(readFromResource("TestJsonData.json"));
         return edgeEvent;
     }
@@ -101,7 +102,6 @@ public class EdgeEventServiceTest extends AbstractServiceTest {
     public void findEdgeEventsByTimeDescOrder() throws Exception {
         EdgeId edgeId = new EdgeId(Uuids.timeBased());
         DeviceId deviceId = new DeviceId(Uuids.timeBased());
-        TenantId tenantId = TenantId.fromUUID(Uuids.timeBased());
 
         List<ListenableFuture<Void>> futures = new ArrayList<>();
         futures.add(saveEdgeEventWithProvidedTime(timeBeforeStartTime, edgeId, deviceId, tenantId));
@@ -133,7 +133,7 @@ public class EdgeEventServiceTest extends AbstractServiceTest {
     }
 
     private ListenableFuture<Void> saveEdgeEventWithProvidedTime(long time, EdgeId edgeId, EntityId entityId, TenantId tenantId) throws Exception {
-        EdgeEvent edgeEvent = generateEdgeEvent(tenantId, edgeId, entityId, EdgeEventActionType.ADDED);
+        EdgeEvent edgeEvent = generateEdgeEvent(tenantId, edgeId, entityId);
         edgeEvent.setId(new EdgeEventId(Uuids.startOf(time)));
         return edgeEventService.saveAsync(edgeEvent);
     }
diff --git a/ui-ngx/src/app/modules/home/components/profile/tenant/default-tenant-profile-configuration.component.html b/ui-ngx/src/app/modules/home/components/profile/tenant/default-tenant-profile-configuration.component.html
index 4c309f5e80..867cd74f3b 100644
--- a/ui-ngx/src/app/modules/home/components/profile/tenant/default-tenant-profile-configuration.component.html
+++ b/ui-ngx/src/app/modules/home/components/profile/tenant/default-tenant-profile-configuration.component.html
@@ -523,7 +523,7 @@
         </mat-panel-description>
       </mat-expansion-panel-header>
       <ng-template matExpansionPanelContent>
-        <div fxFlex fxLayout="row"  fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+        <div fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
           <tb-rate-limits fxFlex formControlName="transportTenantTelemetryDataPointsRateLimit"
                           [type]="rateLimitsType.TENANT_TELEMETRY_DATA_POINTS">
           </tb-rate-limits>
@@ -531,7 +531,7 @@
                           [type]="rateLimitsType.DEVICE_TELEMETRY_DATA_POINTS">
           </tb-rate-limits>
         </div>
-        <div fxFlex fxLayout="row"  fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+        <div fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
           <tb-rate-limits fxFlex formControlName="tenantServerRestLimitsConfiguration"
                           [type]="rateLimitsType.TENANT_SERVER_REST_LIMITS_CONFIGURATION">
           </tb-rate-limits>
@@ -539,7 +539,7 @@
                           [type]="rateLimitsType.CUSTOMER_SERVER_REST_LIMITS_CONFIGURATION">
           </tb-rate-limits>
         </div>
-        <div fxFlex fxLayout="row"  fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+        <div fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
           <tb-rate-limits fxFlex formControlName="tenantEntityExportRateLimit"
                           [type]="rateLimitsType.TENANT_ENTITY_EXPORT_RATE_LIMIT">
           </tb-rate-limits>
@@ -547,7 +547,7 @@
                           [type]="rateLimitsType.TENANT_ENTITY_IMPORT_RATE_LIMIT">
           </tb-rate-limits>
         </div>
-        <div fxFlex fxLayout="row"  fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+        <div fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
           <tb-rate-limits fxFlex formControlName="wsUpdatesPerSessionRateLimit"
                           [type]="rateLimitsType.WS_UPDATE_PER_SESSION_RATE_LIMIT">
           </tb-rate-limits>
@@ -555,7 +555,7 @@
                           [type]="rateLimitsType.CASSANDRA_QUERY_TENANT_RATE_LIMITS_CONFIGURATION">
           </tb-rate-limits>
         </div>
-        <div fxFlex fxLayout="row"  fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+        <div fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
           <tb-rate-limits fxFlex="50" formControlName="tenantNotificationRequestsRateLimit"
                           [type]="rateLimitsType.TENANT_NOTIFICATION_REQUEST_RATE_LIMIT">
           </tb-rate-limits>
@@ -563,6 +563,14 @@
                           [type]="rateLimitsType.TENANT_NOTIFICATION_REQUESTS_PER_RULE_RATE_LIMIT">
           </tb-rate-limits>
         </div>
+        <div fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+          <tb-rate-limits fxFlex="50" formControlName="edgeEventRateLimits"
+                          [type]="rateLimitsType.EDGE_EVENTS_RATE_LIMIT">
+          </tb-rate-limits>
+          <tb-rate-limits fxFlex="50" formControlName="edgeEventRateLimitsPerEdge"
+                          [type]="rateLimitsType.EDGE_EVENTS_PER_EDGE_RATE_LIMIT">
+          </tb-rate-limits>
+        </div>
       </ng-template>
     </mat-expansion-panel>
   </fieldset>
diff --git a/ui-ngx/src/app/modules/home/components/profile/tenant/default-tenant-profile-configuration.component.ts b/ui-ngx/src/app/modules/home/components/profile/tenant/default-tenant-profile-configuration.component.ts
index a0b8770509..0c95324d85 100644
--- a/ui-ngx/src/app/modules/home/components/profile/tenant/default-tenant-profile-configuration.component.ts
+++ b/ui-ngx/src/app/modules/home/components/profile/tenant/default-tenant-profile-configuration.component.ts
@@ -106,7 +106,9 @@ export class DefaultTenantProfileConfigurationComponent implements ControlValueA
       maxWsSubscriptionsPerRegularUser: [null, [Validators.min(0)]],
       maxWsSubscriptionsPerPublicUser: [null, [Validators.min(0)]],
       wsUpdatesPerSessionRateLimit: [null, []],
-      cassandraQueryTenantRateLimitsConfiguration: [null, []]
+      cassandraQueryTenantRateLimitsConfiguration: [null, []],
+      edgeEventRateLimits: [null, []],
+      edgeEventRateLimitsPerEdge: [null, []]
     });
 
     this.defaultTenantProfileConfigurationFormGroup.get('smsEnabled').valueChanges.pipe(
diff --git a/ui-ngx/src/app/modules/home/components/profile/tenant/rate-limits/rate-limits.models.ts b/ui-ngx/src/app/modules/home/components/profile/tenant/rate-limits/rate-limits.models.ts
index 257752f5f4..8924682aa1 100644
--- a/ui-ngx/src/app/modules/home/components/profile/tenant/rate-limits/rate-limits.models.ts
+++ b/ui-ngx/src/app/modules/home/components/profile/tenant/rate-limits/rate-limits.models.ts
@@ -35,7 +35,9 @@ export enum RateLimitsType {
   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_REQUESTS_PER_RULE_RATE_LIMIT = 'TENANT_NOTIFICATION_REQUESTS_PER_RULE_RATE_LIMIT'
+  TENANT_NOTIFICATION_REQUESTS_PER_RULE_RATE_LIMIT = 'TENANT_NOTIFICATION_REQUESTS_PER_RULE_RATE_LIMIT',
+  EDGE_EVENTS_RATE_LIMIT = 'EDGE_EVENTS_RATE_LIMIT',
+  EDGE_EVENTS_PER_EDGE_RATE_LIMIT = 'EDGE_EVENTS_PER_EDGE_RATE_LIMIT'
 }
 
 export const rateLimitsLabelTranslationMap = new Map<RateLimitsType, string>(
@@ -54,6 +56,8 @@ export const rateLimitsLabelTranslationMap = new Map<RateLimitsType, string>(
     [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'],
+    [RateLimitsType.EDGE_EVENTS_RATE_LIMIT, 'tenant-profile.rate-limits.edge-events-rate-limit'],
+    [RateLimitsType.EDGE_EVENTS_PER_EDGE_RATE_LIMIT, 'tenant-profile.rate-limits.edge-events-per-edge-rate-limit'],
   ]
 );
 
@@ -73,6 +77,8 @@ export const rateLimitsDialogTitleTranslationMap = new Map<RateLimitsType, strin
     [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'],
+    [RateLimitsType.EDGE_EVENTS_RATE_LIMIT, 'tenant-profile.rate-limits.edit-edge-events-rate-limit'],
+    [RateLimitsType.EDGE_EVENTS_PER_EDGE_RATE_LIMIT, 'tenant-profile.rate-limits.edit-edge-events-per-edge-rate-limit'],
   ]
 );
 
diff --git a/ui-ngx/src/app/modules/home/pages/notification/rule/rule-notification-dialog.component.html b/ui-ngx/src/app/modules/home/pages/notification/rule/rule-notification-dialog.component.html
index 75495abec7..f4ae83143f 100644
--- a/ui-ngx/src/app/modules/home/pages/notification/rule/rule-notification-dialog.component.html
+++ b/ui-ngx/src/app/modules/home/pages/notification/rule/rule-notification-dialog.component.html
@@ -408,6 +408,67 @@
       </form>
     </mat-step>
 
+    <mat-step [stepControl]="edgeConnectionTemplateForm"
+              *ngIf="ruleNotificationForm.get('triggerType').value === triggerType.EDGE_CONNECTION">
+      <ng-template matStepLabel>{{ 'notification.edge-trigger-settings' | translate }}</ng-template>
+      <form [formGroup]="edgeConnectionTemplateForm">
+        <section formGroupName="triggerConfig">
+          <fieldset class="fields-group tb-margin-before-field">
+            <legend translate>notification.filter</legend>
+            <tb-entity-list
+              formControlName="edges"
+              subscriptSizing="dynamic"
+              labelText="{{'edge.edge-instances' | translate}}"
+              placeholderText="{{ 'edge.edge-instances' | translate }}"
+              hint="{{ 'notification.edge-list-rule-hint' | translate }}"
+              [entityType]="entityType.EDGE">
+            </tb-entity-list>
+            <mat-form-field fxFlex class="mat-block" floatLabel="always">
+              <mat-label translate>notification.notify-on</mat-label>
+              <mat-select formControlName="notifyOn" multiple
+                          placeholder="{{ !edgeConnectionTemplateForm.get('triggerConfig.notifyOn').value?.length ? ('event.all-events' | translate) : '' }}">
+                <mat-option *ngFor="let edgeEvent of edgeConnectionEvents" [value]="edgeEvent">
+                  {{ edgeConnectionEventTranslationMap.get(edgeEvent) | translate }}
+                </mat-option>
+              </mat-select>
+            </mat-form-field>
+          </fieldset>
+        </section>
+      </form>
+      <form [formGroup]="ruleNotificationForm">
+        <section formGroupName="additionalConfig">
+          <mat-form-field class="mat-block">
+            <mat-label translate>notification.description</mat-label>
+            <input matInput formControlName="description">
+          </mat-form-field>
+        </section>
+      </form>
+    </mat-step>
+
+    <mat-step [stepControl]="edgeCommunicationFailureTemplateForm"
+              *ngIf="ruleNotificationForm.get('triggerType').value === triggerType.EDGE_COMMUNICATION_FAILURE">
+      <ng-template matStepLabel>{{ 'notification.edge-trigger-settings' | translate }}</ng-template>
+      <form [formGroup]="edgeCommunicationFailureTemplateForm">
+        <section formGroupName="triggerConfig">
+          <fieldset class="fields-group tb-margin-before-field">
+            <legend translate>notification.filter</legend>
+            <tb-entity-list labelText="{{'edge.edge-instances' | translate}}"
+                            [entityType]="entityType.EDGE"
+                            formControlName="edges">
+            </tb-entity-list>
+          </fieldset>
+        </section>
+      </form>
+      <form [formGroup]="ruleNotificationForm">
+        <section formGroupName="additionalConfig">
+          <mat-form-field class="mat-block">
+            <mat-label translate>notification.description</mat-label>
+            <input matInput formControlName="description">
+          </mat-form-field>
+        </section>
+      </form>
+    </mat-step>
+
     <mat-step *ngIf="ruleNotificationForm.get('triggerType').value === triggerType.ENTITIES_LIMIT"
               [stepControl]="entitiesLimitTemplateForm">
       <ng-template matStepLabel>{{ 'notification.entities-limit-trigger-settings' | translate }}</ng-template>
diff --git a/ui-ngx/src/app/modules/home/pages/notification/rule/rule-notification-dialog.component.ts b/ui-ngx/src/app/modules/home/pages/notification/rule/rule-notification-dialog.component.ts
index 9604670757..34ff605027 100644
--- a/ui-ngx/src/app/modules/home/pages/notification/rule/rule-notification-dialog.component.ts
+++ b/ui-ngx/src/app/modules/home/pages/notification/rule/rule-notification-dialog.component.ts
@@ -68,6 +68,7 @@ import {
 } from '@shared/models/api-usage.models';
 import { LimitedApi, LimitedApiTranslationMap } from '@shared/models/limited-api.models';
 import { StringItemsOption } from '@shared/components/string-items-list.component';
+import { EdgeConnectionEvent, EdgeConnectionEventTranslationMap } from '@shared/models/edge.models';
 
 export interface RuleNotificationDialogData {
   rule?: NotificationRule;
@@ -98,6 +99,8 @@ export class RuleNotificationDialogComponent extends
   apiUsageLimitTemplateForm: FormGroup;
   newPlatformVersionTemplateForm: FormGroup;
   rateLimitsTemplateForm: FormGroup;
+  edgeCommunicationFailureTemplateForm: FormGroup;
+  edgeConnectionTemplateForm: FormGroup;
 
   triggerType = TriggerType;
   triggerTypes: TriggerType[];
@@ -132,6 +135,9 @@ export class RuleNotificationDialogComponent extends
   apiFeatures: ApiFeature[] = Object.values(ApiFeature);
   apiFeatureTranslationMap = ApiFeatureTranslationMap;
 
+  edgeConnectionEvents: EdgeConnectionEvent[] = Object.values(EdgeConnectionEvent);
+  edgeConnectionEventTranslationMap = EdgeConnectionEventTranslationMap;
+
   limitedApis: StringItemsOption[];
 
   entityType = EntityType;
@@ -221,6 +227,19 @@ export class RuleNotificationDialogComponent extends
       }
     });
 
+    this.edgeConnectionTemplateForm = this.fb.group({
+      triggerConfig: this.fb.group({
+        edges: [null],
+        notifyOn: [null]
+      })
+    });
+
+    this.edgeCommunicationFailureTemplateForm = this.fb.group({
+      triggerConfig: this.fb.group({
+        edges: [null]
+      })
+    });
+
     this.alarmTemplateForm = this.fb.group({
       triggerConfig: this.fb.group({
         alarmTypes: [null],
@@ -328,7 +347,9 @@ export class RuleNotificationDialogComponent extends
       [TriggerType.ENTITIES_LIMIT, this.entitiesLimitTemplateForm],
       [TriggerType.API_USAGE_LIMIT, this.apiUsageLimitTemplateForm],
       [TriggerType.NEW_PLATFORM_VERSION, this.newPlatformVersionTemplateForm],
-      [TriggerType.RATE_LIMITS, this.rateLimitsTemplateForm]
+      [TriggerType.RATE_LIMITS, this.rateLimitsTemplateForm],
+      [TriggerType.EDGE_COMMUNICATION_FAILURE, this.edgeCommunicationFailureTemplateForm],
+      [TriggerType.EDGE_CONNECTION, this.edgeConnectionTemplateForm]
     ]);
 
     if (data.isAdd || data.isCopy) {
diff --git a/ui-ngx/src/app/shared/models/edge.models.ts b/ui-ngx/src/app/shared/models/edge.models.ts
index 7187dc8eaa..569b2bec8a 100644
--- a/ui-ngx/src/app/shared/models/edge.models.ts
+++ b/ui-ngx/src/app/shared/models/edge.models.ts
@@ -190,3 +190,15 @@ export enum EdgeInstructionsMethod {
 }
 
 export const edgeVersionAttributeKey = 'edgeVersion';
+
+export enum EdgeConnectionEvent {
+  CONNECTED= 'CONNECTED',
+  DISCONNECTED = 'DISCONNECTED'
+}
+
+export const EdgeConnectionEventTranslationMap = new Map<EdgeConnectionEvent, string>(
+  [
+    [EdgeConnectionEvent.CONNECTED, 'edge.connected'],
+    [EdgeConnectionEvent.DISCONNECTED, 'edge.disconnected']
+  ]
+);
diff --git a/ui-ngx/src/app/shared/models/limited-api.models.ts b/ui-ngx/src/app/shared/models/limited-api.models.ts
index 714441f0b2..d0e2e0cb76 100644
--- a/ui-ngx/src/app/shared/models/limited-api.models.ts
+++ b/ui-ngx/src/app/shared/models/limited-api.models.ts
@@ -24,7 +24,9 @@ export enum LimitedApi {
   WS_UPDATES_PER_SESSION = 'WS_UPDATES_PER_SESSION',
   CASSANDRA_QUERIES = 'CASSANDRA_QUERIES',
   TRANSPORT_MESSAGES_PER_TENANT = 'TRANSPORT_MESSAGES_PER_TENANT',
-  TRANSPORT_MESSAGES_PER_DEVICE = 'TRANSPORT_MESSAGES_PER_DEVICE'
+  TRANSPORT_MESSAGES_PER_DEVICE = 'TRANSPORT_MESSAGES_PER_DEVICE',
+  EDGE_EVENTS = 'EDGE_EVENTS',
+  EDGE_EVENTS_PER_EDGE = 'EDGE_EVENTS_PER_EDGE'
 }
 
 export const LimitedApiTranslationMap = new Map<LimitedApi, string>(
@@ -38,6 +40,8 @@ export const LimitedApiTranslationMap = new Map<LimitedApi, string>(
     [LimitedApi.WS_UPDATES_PER_SESSION, 'api-limit.ws-updates-per-session'],
     [LimitedApi.CASSANDRA_QUERIES, 'api-limit.cassandra-queries'],
     [LimitedApi.TRANSPORT_MESSAGES_PER_TENANT, 'api-limit.transport-messages'],
-    [LimitedApi.TRANSPORT_MESSAGES_PER_DEVICE, 'api-limit.transport-messages-per-device']
+    [LimitedApi.TRANSPORT_MESSAGES_PER_DEVICE, 'api-limit.transport-messages-per-device'],
+    [LimitedApi.EDGE_EVENTS, 'api-limit.edge-events'],
+    [LimitedApi.EDGE_EVENTS_PER_EDGE, 'api-limit.edge-events-per-edge'],
   ]
 );
diff --git a/ui-ngx/src/app/shared/models/notification.models.ts b/ui-ngx/src/app/shared/models/notification.models.ts
index 9943bebf3d..ae945b243c 100644
--- a/ui-ngx/src/app/shared/models/notification.models.ts
+++ b/ui-ngx/src/app/shared/models/notification.models.ts
@@ -474,7 +474,9 @@ export enum NotificationType {
   API_USAGE_LIMIT = 'API_USAGE_LIMIT',
   NEW_PLATFORM_VERSION = 'NEW_PLATFORM_VERSION',
   RULE_NODE = 'RULE_NODE',
-  RATE_LIMITS = 'RATE_LIMITS'
+  RATE_LIMITS = 'RATE_LIMITS',
+  EDGE_CONNECTION = 'EDGE_CONNECTION',
+  EDGE_COMMUNICATION_FAILURE = 'EDGE_COMMUNICATION_FAILURE'
 }
 
 export const NotificationTypeIcons = new Map<NotificationType, string | null>([
@@ -585,6 +587,18 @@ export const NotificationTemplateTypeTranslateMap = new Map<NotificationType, No
       name: 'notification.template-type.rate-limits',
       helpId: 'notification/rate_limits'
     }
+  ],
+  [NotificationType.EDGE_CONNECTION,
+    {
+      name: 'notification.template-type.edge-connection',
+      helpId: 'notification/edge_connection'
+    }
+  ],
+  [NotificationType.EDGE_COMMUNICATION_FAILURE,
+    {
+      name: 'notification.template-type.edge-communication-failure',
+      helpId: 'notification/edge_communication_failure'
+    }
   ]
 ]);
 
@@ -598,7 +612,9 @@ export enum TriggerType {
   ENTITIES_LIMIT = 'ENTITIES_LIMIT',
   API_USAGE_LIMIT = 'API_USAGE_LIMIT',
   NEW_PLATFORM_VERSION = 'NEW_PLATFORM_VERSION',
-  RATE_LIMITS = 'RATE_LIMITS'
+  RATE_LIMITS = 'RATE_LIMITS',
+  EDGE_CONNECTION = 'EDGE_CONNECTION',
+  EDGE_COMMUNICATION_FAILURE = 'EDGE_COMMUNICATION_FAILURE'
 }
 
 export const TriggerTypeTranslationMap = new Map<TriggerType, string>([
@@ -612,6 +628,8 @@ export const TriggerTypeTranslationMap = new Map<TriggerType, string>([
   [TriggerType.API_USAGE_LIMIT, 'notification.trigger.api-usage-limit'],
   [TriggerType.NEW_PLATFORM_VERSION, 'notification.trigger.new-platform-version'],
   [TriggerType.RATE_LIMITS, 'notification.trigger.rate-limits'],
+  [TriggerType.EDGE_CONNECTION, 'notification.trigger.edge-connection'],
+  [TriggerType.EDGE_COMMUNICATION_FAILURE, 'notification.trigger.edge-communication-failure']
 ]);
 
 export interface NotificationUserSettings {
diff --git a/ui-ngx/src/assets/help/en_US/notification/edge_communication_failure.md b/ui-ngx/src/assets/help/en_US/notification/edge_communication_failure.md
new file mode 100644
index 0000000000..712f2b45e7
--- /dev/null
+++ b/ui-ngx/src/assets/help/en_US/notification/edge_communication_failure.md
@@ -0,0 +1,57 @@
+#### Edge communication failure notification templatization
+
+<div class="divider"></div>
+<br/>
+
+Notification subject and message fields support templatization.
+The list of available templatization parameters depends on the template type.
+See the available types and parameters below:
+
+Available template parameters:
+
+* `edgeId` - the edge id as uuid string;
+* `edgeName` - the name of the edge;
+* `failureMsg` - the string representation of the failure, occurred on the Edge;
+
+Parameter names must be wrapped using `${...}`. For example: `${edgeName}`.
+You may also modify the value of the parameter with one of the suffixes:
+
+* `upperCase`, for example - `${edgeName:upperCase}`
+* `lowerCase`, for example - `${edgeName:lowerCase}`
+* `capitalize`, for example - `${edgeName:capitalize}`
+
+<div class="divider"></div>
+
+##### Examples
+
+Let's assume the notification about the failing of processing connection to Edge.
+The following template:
+
+```text
+Edge '${edgeName}' communication failure occurred
+{:copy-code}
+```
+
+will be transformed to:
+
+```text
+Edge 'DatacenterEdge' communication failure occurred
+```
+
+<br/>
+
+The following template:
+
+```text
+Failure message: '${failureMsg}'
+{:copy-code}
+```
+
+will be transformed to:
+
+```text
+Failure message: 'Failed to process edge connection!'
+```
+
+<br>
+<br>
diff --git a/ui-ngx/src/assets/help/en_US/notification/edge_connection.md b/ui-ngx/src/assets/help/en_US/notification/edge_connection.md
new file mode 100644
index 0000000000..37f0ec7573
--- /dev/null
+++ b/ui-ngx/src/assets/help/en_US/notification/edge_connection.md
@@ -0,0 +1,44 @@
+#### Edge connection notification templatization
+
+<div class="divider"></div>
+<br/>
+
+Notification subject and message fields support templatization.
+The list of available templatization parameters depends on the template type.
+See the available types and parameters below:
+
+Available template parameters:
+
+* `edgeId` - the edge id as uuid string;
+* `edgeName` - the name of the edge;
+* `eventType` - the string representation of the connectivity status: connected or disconnected;
+
+Parameter names must be wrapped using `${...}`. For example: `${edgeName}`.
+You may also modify the value of the parameter with one of the suffixes:
+
+* `upperCase`, for example - `${edgeName:upperCase}`
+* `lowerCase`, for example - `${edgeName:lowerCase}`
+* `capitalize`, for example - `${edgeName:capitalize}`
+
+<div class="divider"></div>
+
+##### Examples
+
+Let's assume the notification about the connecting Edge into the ThingsBoard.
+The following template:
+
+```text
+Edge '${edgeName}' is now ${eventType}
+{:copy-code}
+```
+
+will be transformed to:
+
+```text
+Edge 'DatacenterEdge' is now connected
+```
+
+<br/>
+
+<br>
+<br>
diff --git a/ui-ngx/src/assets/help/en_US/notification/rate_limits.md b/ui-ngx/src/assets/help/en_US/notification/rate_limits.md
index 8f6319ad80..d314e681c2 100644
--- a/ui-ngx/src/assets/help/en_US/notification/rate_limits.md
+++ b/ui-ngx/src/assets/help/en_US/notification/rate_limits.md
@@ -11,7 +11,7 @@ Available template parameters:
 
 * `api` - rate-limited API label; one of: 'REST API requests', 'REST API requests per customer', 'transport messages', 
   'transport messages per device', 'Cassandra queries', 'WS updates per session', 'notification requests', 'notification requests per rule',
-  'entity version creation', 'entity version load';
+  'entity version creation', 'entity version load', 'Edge events', 'Edge events per edge';
 * `limitLevelEntityType` - entity type of the limit level entity, e.g. 'Tenant', 'Device', 'Notification rule', 'Customer', etc.;
 * `limitLevelEntityId` - id of the limit level entity;
 * `limitLevelEntityName` - name of the limit level entity;
diff --git a/ui-ngx/src/assets/locale/locale.constant-en_US.json b/ui-ngx/src/assets/locale/locale.constant-en_US.json
index 4160b50024..6e03c5d76c 100644
--- a/ui-ngx/src/assets/locale/locale.constant-en_US.json
+++ b/ui-ngx/src/assets/locale/locale.constant-en_US.json
@@ -856,7 +856,9 @@
         "rest-api-requests-per-customer": "REST API requests per customer",
         "transport-messages": "Transport messages",
         "transport-messages-per-device": "Transport messages per device",
-        "ws-updates-per-session": "WS updates per session"
+        "ws-updates-per-session": "WS updates per session",
+        "edge-events": "Edge events",
+        "edge-events-per-edge": "Edge events per edge"
     },
     "audit-log": {
         "audit": "Audit",
@@ -2037,7 +2039,9 @@
         "missing-related-rule-chains-title": "Edge has missing related rule chain(s)",
         "missing-related-rule-chains-text": "Assigned to edge rule chain(s) use rule nodes that forward message(s) to rule chain(s) that are not assigned to this edge. <br><br> List of missing rule chain(s): <br> {{missingRuleChains}}",
         "upgrade-instructions": "Upgrade Instructions",
-        "widget-datasource-error": "This widget supports only EDGE entity datasource"
+        "widget-datasource-error": "This widget supports only EDGE entity datasource",
+        "connected": "Connected",
+        "disconnected": "Disconnected"
     },
     "edge-event": {
         "type-dashboard": "Dashboard",
@@ -3288,6 +3292,8 @@
         "device-list-rule-hint": "If the field is empty, the trigger will be applied to all devices",
         "device-profiles-list-rule-hint": "If the field is empty, the trigger will be applied to all device profiles",
         "disabled": "Disabled",
+        "edge-trigger-settings": "Edge trigger settings",
+        "edge-list-rule-hint": "If the field is empty, the trigger will be applied to all edge instances",
         "edit-notification-recipients-group": "Edit notification recipients group",
         "edit-notification-template": "Edit notification template",
         "edit-rule": "Edit rule",
@@ -3432,7 +3438,9 @@
             "rule-engine-lifecycle-event": "Rule engine lifecycle event",
             "rule-node": "Rule node",
             "new-platform-version": "New platform version",
-            "rate-limits": "Exceeded rate limits"
+            "rate-limits": "Exceeded rate limits",
+            "edge-communication-failure": "Edge communication failure",
+            "edge-connection": "Edge connection"
         },
         "templates": "Templates",
         "notification-templates": "Notifications / Templates",
@@ -3453,6 +3461,8 @@
             "rule-engine-lifecycle-event": "Rule engine lifecycle event",
             "new-platform-version": "New platform version",
             "rate-limits": "Exceeded rate limits",
+            "edge-connection": "Edge connection",
+            "edge-communication-failure": "Edge communication failure",
             "trigger": "Trigger",
             "trigger-required": "Trigger is required"
         },
@@ -4185,6 +4195,10 @@
             "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",
+            "edit-edge-events-rate-limit": "Edit edge events rate limits",
+            "edit-edge-events-per-edge-rate-limit": "Edit edge events per edge rate limits",
+            "edge-events-rate-limit": "Edge events",
+            "edge-events-per-edge-rate-limit": "Edge events per edge",
             "messages-per": "messages per",
             "not-set": "Not set",
             "number-of-messages": "Number of messages",