diff --git a/application/src/main/java/org/thingsboard/server/actors/ActorSystemContext.java b/application/src/main/java/org/thingsboard/server/actors/ActorSystemContext.java
index 26c82a33de..61d9586095 100644
--- a/application/src/main/java/org/thingsboard/server/actors/ActorSystemContext.java
+++ b/application/src/main/java/org/thingsboard/server/actors/ActorSystemContext.java
@@ -32,6 +32,7 @@ import org.springframework.stereotype.Component;
 import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.rule.engine.api.DeviceStateManager;
 import org.thingsboard.rule.engine.api.MailService;
+import org.thingsboard.rule.engine.api.MqttClientSettings;
 import org.thingsboard.rule.engine.api.NotificationCenter;
 import org.thingsboard.rule.engine.api.SmsService;
 import org.thingsboard.rule.engine.api.notification.SlackService;
@@ -639,6 +640,10 @@ public class ActorSystemContext {
     @Getter
     private long cfCalculationResultTimeout;
 
+    @Autowired
+    @Getter
+    private MqttClientSettings mqttClientSettings;
+
     @Getter
     @Setter
     private TbActorSystem actorSystem;
diff --git a/application/src/main/java/org/thingsboard/server/actors/ruleChain/DefaultTbContext.java b/application/src/main/java/org/thingsboard/server/actors/ruleChain/DefaultTbContext.java
index 033e10ca9a..3fb28aee38 100644
--- a/application/src/main/java/org/thingsboard/server/actors/ruleChain/DefaultTbContext.java
+++ b/application/src/main/java/org/thingsboard/server/actors/ruleChain/DefaultTbContext.java
@@ -23,14 +23,15 @@ import org.bouncycastle.util.Arrays;
 import org.thingsboard.common.util.DebugModeUtil;
 import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.common.util.ListeningExecutor;
+import org.thingsboard.rule.engine.api.DeviceStateManager;
 import org.thingsboard.rule.engine.api.MailService;
+import org.thingsboard.rule.engine.api.MqttClientSettings;
 import org.thingsboard.rule.engine.api.NotificationCenter;
 import org.thingsboard.rule.engine.api.RuleEngineAlarmService;
 import org.thingsboard.rule.engine.api.RuleEngineApiUsageStateService;
 import org.thingsboard.rule.engine.api.RuleEngineAssetProfileCache;
 import org.thingsboard.rule.engine.api.RuleEngineCalculatedFieldQueueService;
 import org.thingsboard.rule.engine.api.RuleEngineDeviceProfileCache;
-import org.thingsboard.rule.engine.api.DeviceStateManager;
 import org.thingsboard.rule.engine.api.RuleEngineRpcService;
 import org.thingsboard.rule.engine.api.RuleEngineTelemetryService;
 import org.thingsboard.rule.engine.api.ScriptEngine;
@@ -1010,13 +1011,17 @@ public class DefaultTbContext implements TbContext {
         return mainCtx.getAuditLogService();
     }
 
+    @Override
+    public MqttClientSettings getMqttClientSettings() {
+        return mainCtx.getMqttClientSettings();
+    }
+
     private TbMsgMetaData getActionMetaData(RuleNodeId ruleNodeId) {
         TbMsgMetaData metaData = new TbMsgMetaData();
         metaData.putValue("ruleNodeId", ruleNodeId.toString());
         return metaData;
     }
 
-
     @Override
     public void schedule(Runnable runnable, long delay, TimeUnit timeUnit) {
         mainCtx.getScheduler().schedule(runnable, delay, timeUnit);
diff --git a/application/src/main/java/org/thingsboard/server/config/mqtt/MqttClientRetransmissionSettingsComponent.java b/application/src/main/java/org/thingsboard/server/config/mqtt/MqttClientRetransmissionSettingsComponent.java
new file mode 100644
index 0000000000..33e9358d2b
--- /dev/null
+++ b/application/src/main/java/org/thingsboard/server/config/mqtt/MqttClientRetransmissionSettingsComponent.java
@@ -0,0 +1,37 @@
+/**
+ * Copyright © 2016-2025 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.config.mqtt;
+
+import jakarta.validation.constraints.PositiveOrZero;
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.validation.annotation.Validated;
+
+@Data
+@Validated
+@Configuration
+@ConfigurationProperties(prefix = "mqtt.client.retransmission")
+public class MqttClientRetransmissionSettingsComponent {
+
+    @PositiveOrZero
+    private int maxAttempts;
+    @PositiveOrZero
+    private long initialDelayMillis;
+    @PositiveOrZero
+    private double jitterFactor;
+
+}
diff --git a/application/src/main/java/org/thingsboard/server/config/mqtt/MqttClientSettingsComponent.java b/application/src/main/java/org/thingsboard/server/config/mqtt/MqttClientSettingsComponent.java
new file mode 100644
index 0000000000..25df212925
--- /dev/null
+++ b/application/src/main/java/org/thingsboard/server/config/mqtt/MqttClientSettingsComponent.java
@@ -0,0 +1,47 @@
+/**
+ * Copyright © 2016-2025 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.config.mqtt;
+
+import lombok.EqualsAndHashCode;
+import lombok.RequiredArgsConstructor;
+import lombok.ToString;
+import org.springframework.context.annotation.Configuration;
+import org.thingsboard.rule.engine.api.MqttClientSettings;
+
+@ToString
+@EqualsAndHashCode
+@Configuration
+@RequiredArgsConstructor
+public class MqttClientSettingsComponent implements MqttClientSettings {
+
+    private final MqttClientRetransmissionSettingsComponent retransmissionSettingsComponent;
+
+    @Override
+    public int getRetransmissionMaxAttempts() {
+        return retransmissionSettingsComponent.getMaxAttempts();
+    }
+
+    @Override
+    public long getRetransmissionInitialDelayMillis() {
+        return retransmissionSettingsComponent.getInitialDelayMillis();
+    }
+
+    @Override
+    public double getRetransmissionJitterFactor() {
+        return retransmissionSettingsComponent.getJitterFactor();
+    }
+
+}
diff --git a/application/src/main/java/org/thingsboard/server/controller/AlarmController.java b/application/src/main/java/org/thingsboard/server/controller/AlarmController.java
index a83e9e446e..dd8d883145 100644
--- a/application/src/main/java/org/thingsboard/server/controller/AlarmController.java
+++ b/application/src/main/java/org/thingsboard/server/controller/AlarmController.java
@@ -157,7 +157,7 @@ public class AlarmController extends BaseController {
     @PreAuthorize("hasAnyAuthority('TENANT_ADMIN', 'CUSTOMER_USER')")
     @RequestMapping(value = "/alarm/{alarmId}", method = RequestMethod.DELETE)
     @ResponseBody
-    public Boolean deleteAlarm(@Parameter(description = ALARM_ID_PARAM_DESCRIPTION) @PathVariable(ALARM_ID) String strAlarmId) throws ThingsboardException {
+    public boolean deleteAlarm(@Parameter(description = ALARM_ID_PARAM_DESCRIPTION) @PathVariable(ALARM_ID) String strAlarmId) throws ThingsboardException {
         checkParameter(ALARM_ID, strAlarmId);
         AlarmId alarmId = new AlarmId(toUUID(strAlarmId));
         Alarm alarm = checkAlarmId(alarmId, Operation.DELETE);
diff --git a/application/src/main/java/org/thingsboard/server/controller/SystemInfoController.java b/application/src/main/java/org/thingsboard/server/controller/SystemInfoController.java
index 4ee86871d6..29f4daa783 100644
--- a/application/src/main/java/org/thingsboard/server/controller/SystemInfoController.java
+++ b/application/src/main/java/org/thingsboard/server/controller/SystemInfoController.java
@@ -42,6 +42,7 @@ import org.thingsboard.server.common.data.settings.UserSettings;
 import org.thingsboard.server.common.data.settings.UserSettingsType;
 import org.thingsboard.server.common.data.tenant.profile.DefaultTenantProfileConfiguration;
 import org.thingsboard.server.dao.mobile.QrCodeSettingService;
+import org.thingsboard.server.dao.trendz.TrendzSettingsService;
 import org.thingsboard.server.queue.util.TbCoreComponent;
 import org.thingsboard.server.service.security.model.SecurityUser;
 import org.thingsboard.server.service.security.model.UserPrincipal;
@@ -87,6 +88,9 @@ public class SystemInfoController extends BaseController {
     @Autowired
     private DebugModeRateLimitsConfig debugModeRateLimitsConfig;
 
+    @Autowired
+    private TrendzSettingsService trendzSettingsService;
+
     @PostConstruct
     public void init() {
         JsonNode info = buildInfoObject();
@@ -158,6 +162,7 @@ public class SystemInfoController extends BaseController {
             }
             systemParams.setMaxArgumentsPerCF(tenantProfileConfiguration.getMaxArgumentsPerCF());
             systemParams.setMaxDataPointsPerRollingArg(tenantProfileConfiguration.getMaxDataPointsPerRollingArg());
+            systemParams.setTrendzSettings(trendzSettingsService.findTrendzSettings(currentUser.getTenantId()));
         }
         systemParams.setMobileQrEnabled(Optional.ofNullable(qrCodeSettingService.findQrCodeSettings(TenantId.SYS_TENANT_ID))
                 .map(QrCodeSettings::getQrCodeConfig).map(QRCodeConfig::isShowOnHomePage)
diff --git a/application/src/main/java/org/thingsboard/server/controller/TrendzController.java b/application/src/main/java/org/thingsboard/server/controller/TrendzController.java
new file mode 100644
index 0000000000..8261071670
--- /dev/null
+++ b/application/src/main/java/org/thingsboard/server/controller/TrendzController.java
@@ -0,0 +1,80 @@
+/**
+ * Copyright © 2016-2025 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.controller;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.data.trendz.TrendzSettings;
+import org.thingsboard.server.config.annotations.ApiOperation;
+import org.thingsboard.server.dao.trendz.TrendzSettingsService;
+import org.thingsboard.server.queue.util.TbCoreComponent;
+import org.thingsboard.server.service.security.model.SecurityUser;
+import org.thingsboard.server.service.security.permission.Operation;
+import org.thingsboard.server.service.security.permission.Resource;
+
+import static org.thingsboard.server.controller.ControllerConstants.MARKDOWN_CODE_BLOCK_END;
+import static org.thingsboard.server.controller.ControllerConstants.MARKDOWN_CODE_BLOCK_START;
+import static org.thingsboard.server.controller.ControllerConstants.NEW_LINE;
+import static org.thingsboard.server.controller.ControllerConstants.TENANT_AUTHORITY_PARAGRAPH;
+import static org.thingsboard.server.controller.ControllerConstants.TENANT_OR_CUSTOMER_AUTHORITY_PARAGRAPH;
+
+@RestController
+@TbCoreComponent
+@RequiredArgsConstructor
+@RequestMapping("/api")
+public class TrendzController extends BaseController {
+
+    private final TrendzSettingsService trendzSettingsService;
+
+    @ApiOperation(value = "Save Trendz settings (saveTrendzSettings)",
+            notes = "Saves Trendz settings for this tenant.\n" + NEW_LINE +
+                    "Here is an example of the Trendz settings:\n" +
+                    MARKDOWN_CODE_BLOCK_START +
+                    "{\n" +
+                    "  \"enabled\": true,\n" +
+                    "  \"baseUrl\": \"https://some.domain.com:18888/also_necessary_prefix\"\n" +
+                    "}" +
+                    MARKDOWN_CODE_BLOCK_END +
+                    TENANT_AUTHORITY_PARAGRAPH)
+    @PostMapping("/trendz/settings")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN')")
+    public TrendzSettings saveTrendzSettings(@RequestBody TrendzSettings trendzSettings,
+                                             @AuthenticationPrincipal SecurityUser user) throws ThingsboardException {
+        accessControlService.checkPermission(user, Resource.ADMIN_SETTINGS, Operation.WRITE);
+        TenantId tenantId = user.getTenantId();
+        trendzSettingsService.saveTrendzSettings(tenantId, trendzSettings);
+        return trendzSettings;
+    }
+
+    @ApiOperation(value = "Get Trendz Settings (getTrendzSettings)",
+            notes = "Retrieves Trendz settings for this tenant." +
+                    TENANT_OR_CUSTOMER_AUTHORITY_PARAGRAPH)
+    @GetMapping("/trendz/settings")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN', 'CUSTOMER_USER')")
+    public TrendzSettings getTrendzSettings(@AuthenticationPrincipal SecurityUser user) {
+        TenantId tenantId = user.getTenantId();
+        return trendzSettingsService.findTrendzSettings(tenantId);
+    }
+
+}
diff --git a/application/src/main/java/org/thingsboard/server/service/entitiy/AbstractTbEntityService.java b/application/src/main/java/org/thingsboard/server/service/entitiy/AbstractTbEntityService.java
index e9ee7202a7..476a4ef5ca 100644
--- a/application/src/main/java/org/thingsboard/server/service/entitiy/AbstractTbEntityService.java
+++ b/application/src/main/java/org/thingsboard/server/service/entitiy/AbstractTbEntityService.java
@@ -17,10 +17,8 @@ package org.thingsboard.server.service.entitiy;
 
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
-import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Value;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.core.env.Environment;
 import org.thingsboard.server.cluster.TbClusterService;
@@ -31,16 +29,10 @@ import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityIdFactory;
 import org.thingsboard.server.dao.alarm.AlarmService;
-import org.thingsboard.server.dao.asset.AssetProfileService;
-import org.thingsboard.server.dao.asset.AssetService;
 import org.thingsboard.server.dao.customer.CustomerService;
-import org.thingsboard.server.dao.device.DeviceProfileService;
-import org.thingsboard.server.dao.device.DeviceService;
 import org.thingsboard.server.dao.edge.EdgeService;
 import org.thingsboard.server.dao.entity.EntityService;
 import org.thingsboard.server.dao.model.ModelConstants;
-import org.thingsboard.server.dao.tenant.TenantService;
-import org.thingsboard.server.service.executors.DbCallbackExecutorService;
 import org.thingsboard.server.service.sync.vc.EntitiesVersionControlService;
 import org.thingsboard.server.service.telemetry.AlarmSubscriptionService;
 
@@ -55,12 +47,6 @@ public abstract class AbstractTbEntityService {
     @Autowired
     private Environment env;
 
-    @Value("${server.log_controller_error_stack_trace}")
-    @Getter
-    private boolean logControllerErrorStackTrace;
-
-    @Autowired
-    protected DbCallbackExecutorService dbExecutor;
     @Autowired(required = false)
     protected TbLogEntityActionService logEntityActionService;
     @Autowired(required = false)
diff --git a/application/src/main/java/org/thingsboard/server/service/entitiy/alarm/DefaultTbAlarmService.java b/application/src/main/java/org/thingsboard/server/service/entitiy/alarm/DefaultTbAlarmService.java
index 4766d8e039..5a1dee3bb5 100644
--- a/application/src/main/java/org/thingsboard/server/service/entitiy/alarm/DefaultTbAlarmService.java
+++ b/application/src/main/java/org/thingsboard/server/service/entitiy/alarm/DefaultTbAlarmService.java
@@ -190,11 +190,24 @@ public class DefaultTbAlarmService extends AbstractTbEntityService implements Tb
     }
 
     @Override
-    public Boolean delete(Alarm alarm, User user) {
-        TenantId tenantId = alarm.getTenantId();
-        logEntityActionService.logEntityAction(tenantId, alarm.getOriginator(), alarm, alarm.getCustomerId(),
-                ActionType.ALARM_DELETE, user, alarm.getId());
-        return alarmSubscriptionService.deleteAlarm(tenantId, alarm.getId());
+    public boolean delete(Alarm alarm, User user) {
+        var tenantId = alarm.getTenantId();
+        var alarmId = alarm.getId();
+        var alarmOriginator = alarm.getOriginator();
+
+        boolean deleted;
+        try {
+            deleted = alarmSubscriptionService.deleteAlarm(tenantId, alarmId);
+        } catch (Exception e) {
+            logEntityActionService.logEntityAction(tenantId, emptyId(alarmOriginator.getEntityType()), ActionType.ALARM_DELETE, user, e, alarmId);
+            throw e;
+        }
+
+        if (deleted) {
+            logEntityActionService.logEntityAction(tenantId, alarmOriginator, alarm, alarm.getCustomerId(), ActionType.ALARM_DELETE, user, alarmId);
+        }
+
+        return deleted;
     }
 
     private static long getOrDefault(long ts) {
diff --git a/application/src/main/java/org/thingsboard/server/service/entitiy/alarm/TbAlarmService.java b/application/src/main/java/org/thingsboard/server/service/entitiy/alarm/TbAlarmService.java
index 11b5c864ac..c034c39561 100644
--- a/application/src/main/java/org/thingsboard/server/service/entitiy/alarm/TbAlarmService.java
+++ b/application/src/main/java/org/thingsboard/server/service/entitiy/alarm/TbAlarmService.java
@@ -43,5 +43,6 @@ public interface TbAlarmService {
 
     void unassignDeletedUserAlarms(TenantId tenantId, UserId userId, String userTitle, List<UUID> alarms, long unassignTs);
 
-    Boolean delete(Alarm alarm, User user);
+    boolean delete(Alarm alarm, User user);
+
 }
diff --git a/application/src/main/java/org/thingsboard/server/service/entitiy/ota/DefaultTbOtaPackageService.java b/application/src/main/java/org/thingsboard/server/service/entitiy/ota/DefaultTbOtaPackageService.java
index fca015671e..af8bbeb669 100644
--- a/application/src/main/java/org/thingsboard/server/service/entitiy/ota/DefaultTbOtaPackageService.java
+++ b/application/src/main/java/org/thingsboard/server/service/entitiy/ota/DefaultTbOtaPackageService.java
@@ -86,7 +86,7 @@ public class DefaultTbOtaPackageService extends AbstractTbEntityService implemen
             otaPackage.setContentType(contentType);
             otaPackage.setData(ByteBuffer.wrap(data));
             otaPackage.setDataSize((long) data.length);
-            OtaPackageInfo savedOtaPackage = otaPackageService.saveOtaPackage(otaPackage);
+            OtaPackageInfo savedOtaPackage = new OtaPackageInfo(otaPackageService.saveOtaPackage(otaPackage));
             logEntityActionService.logEntityAction(tenantId, savedOtaPackage.getId(), savedOtaPackage, null, actionType, user);
             return savedOtaPackage;
         } catch (Exception e) {
diff --git a/application/src/main/java/org/thingsboard/server/service/security/permission/SysAdminPermissions.java b/application/src/main/java/org/thingsboard/server/service/security/permission/SysAdminPermissions.java
index e64f5b49dd..6bd7aacf54 100644
--- a/application/src/main/java/org/thingsboard/server/service/security/permission/SysAdminPermissions.java
+++ b/application/src/main/java/org/thingsboard/server/service/security/permission/SysAdminPermissions.java
@@ -23,7 +23,7 @@ import org.thingsboard.server.common.data.id.UserId;
 import org.thingsboard.server.common.data.security.Authority;
 import org.thingsboard.server.service.security.model.SecurityUser;
 
-@Component(value="sysAdminPermissions")
+@Component(value = "sysAdminPermissions")
 public class SysAdminPermissions extends AbstractPermissions {
 
     public SysAdminPermissions() {
diff --git a/application/src/main/java/org/thingsboard/server/service/telemetry/DefaultAlarmSubscriptionService.java b/application/src/main/java/org/thingsboard/server/service/telemetry/DefaultAlarmSubscriptionService.java
index 7a5a563e68..fd9d8b7141 100644
--- a/application/src/main/java/org/thingsboard/server/service/telemetry/DefaultAlarmSubscriptionService.java
+++ b/application/src/main/java/org/thingsboard/server/service/telemetry/DefaultAlarmSubscriptionService.java
@@ -115,7 +115,7 @@ public class DefaultAlarmSubscriptionService extends AbstractSubscriptionService
     }
 
     @Override
-    public Boolean deleteAlarm(TenantId tenantId, AlarmId alarmId) {
+    public boolean deleteAlarm(TenantId tenantId, AlarmId alarmId) {
         AlarmApiCallResult result = alarmService.delAlarm(tenantId, alarmId);
         onAlarmDeleted(result);
         return result.isSuccessful();
diff --git a/application/src/main/resources/thingsboard.yml b/application/src/main/resources/thingsboard.yml
index 3ad08d858a..02eed7bbe4 100644
--- a/application/src/main/resources/thingsboard.yml
+++ b/application/src/main/resources/thingsboard.yml
@@ -644,6 +644,9 @@ cache:
     mobileSecretKey:
       timeToLiveInMinutes: "${CACHE_MOBILE_SECRET_KEY_TTL:2}" # QR secret key cache TTL
       maxSize: "${CACHE_MOBILE_SECRET_KEY_MAX_SIZE:10000}" # 0 means the cache is disabled
+    trendzSettings:
+      timeToLiveInMinutes: "${CACHE_SPECS_TRENDZ_SETTINGS_TTL:1440}" # Trendz settings cache TTL
+      maxSize: "${CACHE_SPECS_TRENDZ_SETTINGS_MAX_SIZE:10000}" # 0 means the cache is disabled
 
   # Deliberately placed outside the 'specs' group above
   notificationRules:
@@ -1636,6 +1639,12 @@ queue:
         - key: max.poll.records
           # Max poll records for edqs.state topic
           value: "${TB_QUEUE_KAFKA_EDQS_STATE_MAX_POLL_RECORDS:512}"
+    # If you override any default Kafka topic name using environment variables, you must also specify the related consumer properties
+    # for the new topic in `consumer-properties-per-topic-inline`. Otherwise, the topic will not inherit its expected configuration (e.g., max.poll.records, timeouts, etc).
+    # Each entry sets a single property for a specific topic. To define multiple properties for a topic, repeat the topic key.
+    # Format: "topic1:key=value;topic1:key=value;topic2:key=value"
+    # Example: tb_core_updated:max.poll.records=10;tb_core_updated:bootstrap.servers=kafka1:9092,kafka2:9092;tb_edge_updated:auto.offset.reset=latest
+    consumer-properties-per-topic-inline: "${TB_QUEUE_KAFKA_CONSUMER_PROPERTIES_PER_TOPIC_INLINE:}"
     other-inline: "${TB_QUEUE_KAFKA_OTHER_PROPERTIES:}" # In this section you can specify custom parameters (semicolon separated) for Kafka consumer/producer/admin # Example "metrics.recording.level:INFO;metrics.sample.window.ms:30000"
     other: # DEPRECATED. In this section, you can specify custom parameters for Kafka consumer/producer and expose the env variables to configure outside
     #  - key: "request.timeout.ms" # refer to https://docs.confluent.io/platform/current/installation/configuration/producer-configs.html#producerconfigs_request.timeout.ms
@@ -1960,3 +1969,27 @@ mobileApp:
   googlePlayLink: "${TB_MOBILE_APP_GOOGLE_PLAY_LINK:https://play.google.com/store/apps/details?id=org.thingsboard.demo.app}"
   # Link to App Store for Thingsboard Live mobile application
   appStoreLink: "${TB_MOBILE_APP_APP_STORE_LINK:https://apps.apple.com/us/app/thingsboard-live/id1594355695}"
+
+mqtt:
+  # MQTT client configuration parameters
+  client:
+    # Parameters that control the retransmission mechanism.
+    # This mechanism only applies to the handling of MQTT Publish, Subscribe, Unsubscribe and Pubrel messages.
+    # With the updated default settings:
+    #   - After sending the message, wait approximately 5000 ms (± jitter) for the 1st attempt.
+    #   - The 2nd attempt will occur after roughly 5000 * 2 = 10,000 ms (± jitter).
+    #   - The 3rd attempt will occur after roughly 5000 * 4 = 20,000 ms (± jitter).
+    #   - The 4th "attempt" will not actually perform a retransmission.
+    #     Instead, the system will detect that the maximum number of attempts has been reached and drop the pending message.
+    retransmission:
+      # Maximum number of retransmission attempts allowed.
+      # If the attempt count exceeds this value, retransmissions will stop and the pending message will be dropped.
+      max_attempts: "${TB_MQTT_CLIENT_RETRANSMISSION_MAX_ATTEMPTS:3}"
+      # Base delay (in milliseconds) before the first retransmission attempt, measured from the moment the message is sent.
+      # Subsequent delays are calculated using exponential backoff.
+      # This base delay is also used as the reference value for applying jitter.
+      initial_delay_millis: "${TB_MQTT_CLIENT_RETRANSMISSION_INITIAL_DELAY_MILLIS:5000}"
+      # Jitter factor applied to the calculated retransmission delay.
+      # The actual delay is randomized within a range defined by multiplying the base delay by a factor between (1 - jitter_factor) and (1 + jitter_factor).
+      # For example, a jitter_factor of 0.15 means the actual delay may vary by up to ±15% of the base delay.
+      jitter_factor: "${TB_MQTT_CLIENT_RETRANSMISSION_JITTER_FACTOR:0.15}"
diff --git a/application/src/test/java/org/thingsboard/server/controller/AlarmControllerTest.java b/application/src/test/java/org/thingsboard/server/controller/AlarmControllerTest.java
index d80c8a6ba5..8a49d34d20 100644
--- a/application/src/test/java/org/thingsboard/server/controller/AlarmControllerTest.java
+++ b/application/src/test/java/org/thingsboard/server/controller/AlarmControllerTest.java
@@ -15,6 +15,7 @@
  */
 package org.thingsboard.server.controller;
 
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.JsonNode;
 import lombok.extern.slf4j.Slf4j;
@@ -57,6 +58,8 @@ import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 
 import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.is;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
 
 @Slf4j
@@ -308,6 +311,21 @@ public class AlarmControllerTest extends AbstractControllerTest {
         testNotifyEntityNever(alarm.getId(), alarm);
     }
 
+    @Test
+    public void testDeleteNonExistentAlarm() throws Exception {
+        loginTenantAdmin();
+
+        var nonExistentAlarmId = Uuids.timeBased();
+
+        Mockito.reset(tbClusterService, auditLogService);
+
+        doDelete("/api/alarm/" + nonExistentAlarmId)
+                .andExpect(status().isNotFound())
+                .andExpect(statusReason(is("Alarm with id [" + nonExistentAlarmId + "] is not found")));
+
+        verifyNoInteractions(tbClusterService, auditLogService);
+    }
+
     @Test
     public void testClearAlarmViaCustomer() throws Exception {
         loginCustomerUser();
@@ -634,12 +652,12 @@ public class AlarmControllerTest extends AbstractControllerTest {
 
         doDelete("/api/user/" + savedUser.getId().getId()).andExpect(status().isOk());
 
-         Awaitility.await().atMost(TIMEOUT, TimeUnit.SECONDS).untilAsserted(() -> {
-             AlarmInfo alarmInfo = doGet("/api/alarm/info/" + alarmId.getId(), AlarmInfo.class);
-             Assert.assertNotNull(alarmInfo);
-             Assert.assertNull(alarmInfo.getAssigneeId());
-             Assert.assertTrue(alarmInfo.getAssignTs() >= afterAssignmentTs);
-         });
+        Awaitility.await().atMost(TIMEOUT, TimeUnit.SECONDS).untilAsserted(() -> {
+            AlarmInfo alarmInfo = doGet("/api/alarm/info/" + alarmId.getId(), AlarmInfo.class);
+            Assert.assertNotNull(alarmInfo);
+            Assert.assertNull(alarmInfo.getAssigneeId());
+            Assert.assertTrue(alarmInfo.getAssignTs() >= afterAssignmentTs);
+        });
     }
 
     @Test
diff --git a/application/src/test/java/org/thingsboard/server/controller/OtaPackageControllerTest.java b/application/src/test/java/org/thingsboard/server/controller/OtaPackageControllerTest.java
index e8bb65dd49..3fc839996c 100644
--- a/application/src/test/java/org/thingsboard/server/controller/OtaPackageControllerTest.java
+++ b/application/src/test/java/org/thingsboard/server/controller/OtaPackageControllerTest.java
@@ -216,7 +216,7 @@ public class OtaPackageControllerTest extends AbstractControllerTest {
         Assert.assertEquals(CHECKSUM_ALGORITHM, savedFirmware.getChecksumAlgorithm().name());
         Assert.assertEquals(CHECKSUM, savedFirmware.getChecksum());
 
-        testNotifyEntityAllOneTime(savedFirmware, savedFirmware.getId(), savedFirmware.getId(),
+        testNotifyEntityAllOneTime(new OtaPackageInfo(savedFirmware), savedFirmware.getId(), savedFirmware.getId(),
                 savedTenant.getId(), tenantAdmin.getCustomerId(), tenantAdmin.getId(), tenantAdmin.getEmail(),
                 ActionType.UPDATED);
     }
diff --git a/application/src/test/java/org/thingsboard/server/controller/TrendzControllerTest.java b/application/src/test/java/org/thingsboard/server/controller/TrendzControllerTest.java
new file mode 100644
index 0000000000..115b895521
--- /dev/null
+++ b/application/src/test/java/org/thingsboard/server/controller/TrendzControllerTest.java
@@ -0,0 +1,77 @@
+/**
+ * Copyright © 2016-2025 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.controller;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.thingsboard.server.common.data.trendz.TrendzSettings;
+import org.thingsboard.server.dao.service.DaoSqlTest;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+@DaoSqlTest
+public class TrendzControllerTest extends AbstractControllerTest {
+
+    private final String trendzUrl = "https://some.domain.com:18888/also_necessary_prefix";
+
+    @Before
+    public void setUp() throws Exception {
+        loginTenantAdmin();
+
+        TrendzSettings trendzSettings = new TrendzSettings();
+        trendzSettings.setEnabled(true);
+        trendzSettings.setBaseUrl(trendzUrl);
+
+        doPost("/api/trendz/settings", trendzSettings).andExpect(status().isOk());
+    }
+
+    @Test
+    public void testTrendzSettingsWhenTenant() throws Exception {
+        loginTenantAdmin();
+
+        TrendzSettings trendzSettings = doGet("/api/trendz/settings", TrendzSettings.class);
+
+        assertThat(trendzSettings).isNotNull();
+        assertThat(trendzSettings.isEnabled()).isTrue();
+        assertThat(trendzSettings.getBaseUrl()).isEqualTo(trendzUrl);
+
+        String updatedUrl = "https://some.domain.com:18888/tenant_trendz";
+        trendzSettings.setBaseUrl(updatedUrl);
+
+        doPost("/api/trendz/settings", trendzSettings).andExpect(status().isOk());
+
+        TrendzSettings updatedTrendzSettings = doGet("/api/trendz/settings", TrendzSettings.class);
+        assertThat(updatedTrendzSettings).isEqualTo(trendzSettings);
+    }
+
+    @Test
+    public void testTrendzSettingsWhenCustomer() throws Exception {
+        loginCustomerUser();
+
+        TrendzSettings newTrendzSettings = new TrendzSettings();
+        newTrendzSettings.setEnabled(true);
+        newTrendzSettings.setBaseUrl("https://some.domain.com:18888/customer_trendz");
+
+        doPost("/api/trendz/settings", newTrendzSettings).andExpect(status().isForbidden());
+
+        TrendzSettings fetchedTrendzSettings = doGet("/api/trendz/settings", TrendzSettings.class);
+        assertThat(fetchedTrendzSettings).isNotNull();
+        assertThat(fetchedTrendzSettings.isEnabled()).isTrue();
+        assertThat(fetchedTrendzSettings.getBaseUrl()).isEqualTo(trendzUrl);
+    }
+
+}
diff --git a/application/src/test/java/org/thingsboard/server/service/entitiy/alarm/DefaultTbAlarmServiceTest.java b/application/src/test/java/org/thingsboard/server/service/entitiy/alarm/DefaultTbAlarmServiceTest.java
index ac85b48bc1..670ab390ac 100644
--- a/application/src/test/java/org/thingsboard/server/service/entitiy/alarm/DefaultTbAlarmServiceTest.java
+++ b/application/src/test/java/org/thingsboard/server/service/entitiy/alarm/DefaultTbAlarmServiceTest.java
@@ -15,15 +15,12 @@
  */
 package org.thingsboard.server.service.entitiy.alarm;
 
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import com.fasterxml.jackson.databind.node.ObjectNode;
-import lombok.extern.slf4j.Slf4j;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.mock.mockito.MockBean;
-import org.springframework.boot.test.mock.mockito.SpyBean;
-import org.springframework.test.context.ContextConfiguration;
-import org.springframework.test.context.TestPropertySource;
-import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;
 import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.server.cluster.TbClusterService;
 import org.thingsboard.server.common.data.User;
@@ -35,6 +32,9 @@ import org.thingsboard.server.common.data.alarm.AlarmInfo;
 import org.thingsboard.server.common.data.audit.ActionType;
 import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.id.AlarmId;
+import org.thingsboard.server.common.data.id.CustomerId;
+import org.thingsboard.server.common.data.id.DeviceId;
+import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.id.UserId;
 import org.thingsboard.server.dao.alarm.AlarmService;
@@ -47,7 +47,6 @@ import org.thingsboard.server.dao.edge.EdgeService;
 import org.thingsboard.server.dao.entity.EntityService;
 import org.thingsboard.server.dao.tenant.TenantService;
 import org.thingsboard.server.service.entitiy.TbLogEntityActionService;
-import org.thingsboard.server.service.executors.DbCallbackExecutorService;
 import org.thingsboard.server.service.security.permission.AccessControlService;
 import org.thingsboard.server.service.sync.vc.EntitiesVersionControlService;
 import org.thingsboard.server.service.telemetry.AlarmSubscriptionService;
@@ -55,58 +54,57 @@ import org.thingsboard.server.service.telemetry.AlarmSubscriptionService;
 import java.util.List;
 import java.util.UUID;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.Mockito.when;
 
-@Slf4j
-@RunWith(SpringRunner.class)
-@ContextConfiguration(classes = DefaultTbAlarmService.class)
-@TestPropertySource(properties = {
-        "server.log_controller_error_stack_trace=false"
-})
-public class DefaultTbAlarmServiceTest {
+@SpringJUnitConfig(DefaultTbAlarmService.class)
+class DefaultTbAlarmServiceTest {
 
     @MockBean
-    protected DbCallbackExecutorService dbExecutor;
+    TbLogEntityActionService logEntityActionService;
     @MockBean
-    protected TbLogEntityActionService logEntityActionService;
+    EdgeService edgeService;
     @MockBean
-    protected EdgeService edgeService;
+    AlarmService alarmService;
     @MockBean
-    protected AlarmService alarmService;
+    TbAlarmCommentService alarmCommentService;
     @MockBean
-    protected TbAlarmCommentService alarmCommentService;
+    AlarmSubscriptionService alarmSubscriptionService;
     @MockBean
-    protected AlarmSubscriptionService alarmSubscriptionService;
+    CustomerService customerService;
     @MockBean
-    protected CustomerService customerService;
+    TbClusterService tbClusterService;
     @MockBean
-    protected TbClusterService tbClusterService;
+    EntitiesVersionControlService vcService;
     @MockBean
-    private EntitiesVersionControlService vcService;
+    AccessControlService accessControlService;
     @MockBean
-    private AccessControlService accessControlService;
+    TenantService tenantService;
     @MockBean
-    private TenantService tenantService;
+    AssetService assetService;
     @MockBean
-    private AssetService assetService;
+    DeviceService deviceService;
     @MockBean
-    private DeviceService deviceService;
+    AssetProfileService assetProfileService;
     @MockBean
-    private AssetProfileService assetProfileService;
+    DeviceProfileService deviceProfileService;
     @MockBean
-    private DeviceProfileService deviceProfileService;
-    @MockBean
-    private EntityService entityService;
-    @SpyBean
+    EntityService entityService;
+
+    @Autowired
     DefaultTbAlarmService service;
 
+    TenantId tenantId = TenantId.fromUUID(Uuids.timeBased());
+    CustomerId customerId = new CustomerId(Uuids.timeBased());
+
     @Test
-    public void testSave() throws ThingsboardException {
+    void testSave() throws ThingsboardException {
         var alarm = new AlarmInfo();
         when(alarmSubscriptionService.createAlarm(any())).thenReturn(AlarmApiCallResult.builder()
                 .successful(true)
@@ -115,45 +113,99 @@ public class DefaultTbAlarmServiceTest {
                 .build());
         service.save(alarm, new User());
 
-        verify(logEntityActionService, times(1)).logEntityAction(any(), any(), any(), any(), eq(ActionType.ADDED), any());
-        verify(alarmSubscriptionService, times(1)).createAlarm(any());
+        verify(logEntityActionService).logEntityAction(any(), any(), any(), any(), eq(ActionType.ADDED), any());
+        verify(alarmSubscriptionService).createAlarm(any());
     }
 
     @Test
-    public void testAck() throws ThingsboardException {
+    void testAck() throws ThingsboardException {
         var alarm = new Alarm();
         when(alarmSubscriptionService.acknowledgeAlarm(any(), any(), anyLong()))
                 .thenReturn(AlarmApiCallResult.builder().successful(true).modified(true).alarm(new AlarmInfo()).build());
         service.ack(alarm, new User(new UserId(UUID.randomUUID())));
 
-        verify(alarmCommentService, times(1)).saveAlarmComment(any(), any(), any());
-        verify(logEntityActionService, times(1)).logEntityAction(any(), any(), any(), any(), eq(ActionType.ALARM_ACK), any());
-        verify(alarmSubscriptionService, times(1)).acknowledgeAlarm(any(), any(), anyLong());
+        verify(alarmCommentService).saveAlarmComment(any(), any(), any());
+        verify(logEntityActionService).logEntityAction(any(), any(), any(), any(), eq(ActionType.ALARM_ACK), any());
+        verify(alarmSubscriptionService).acknowledgeAlarm(any(), any(), anyLong());
     }
 
     @Test
-    public void testClear() throws ThingsboardException {
+    void testClear() throws ThingsboardException {
         var alarm = new Alarm();
         alarm.setAcknowledged(true);
         when(alarmSubscriptionService.clearAlarm(any(), any(), anyLong(), any()))
                 .thenReturn(AlarmApiCallResult.builder().successful(true).cleared(true).alarm(new AlarmInfo()).build());
         service.clear(alarm, new User(new UserId(UUID.randomUUID())));
 
-        verify(alarmCommentService, times(1)).saveAlarmComment(any(), any(), any());
-        verify(logEntityActionService, times(1)).logEntityAction(any(), any(), any(), any(), eq(ActionType.ALARM_CLEAR), any());
-        verify(alarmSubscriptionService, times(1)).clearAlarm(any(), any(), anyLong(), any());
+        verify(alarmCommentService).saveAlarmComment(any(), any(), any());
+        verify(logEntityActionService).logEntityAction(any(), any(), any(), any(), eq(ActionType.ALARM_CLEAR), any());
+        verify(alarmSubscriptionService).clearAlarm(any(), any(), anyLong(), any());
     }
 
     @Test
-    public void testDelete() {
-        service.delete(new Alarm(), new User());
+    void testDelete_deleteApiReturnsTrue_shouldLogActionAndReturnTrue() {
+        // GIVEN
+        var alarmOriginator = new DeviceId(Uuids.timeBased());
+
+        var alarm = new Alarm(new AlarmId(Uuids.timeBased()));
+        alarm.setTenantId(tenantId);
+        alarm.setCustomerId(customerId);
+        alarm.setOriginator(alarmOriginator);
+
+        var user = new User();
+
+        when(alarmSubscriptionService.deleteAlarm(tenantId, alarm.getId())).thenReturn(true);
 
-        verify(logEntityActionService, times(1)).logEntityAction(any(), any(), any(), any(), eq(ActionType.ALARM_DELETE), any(), any());
-        verify(alarmSubscriptionService, times(1)).deleteAlarm(any(), any());
+        // WHEN
+        boolean actual = service.delete(alarm, user);
+
+        assertThat(actual).isTrue();
+        verify(logEntityActionService).logEntityAction(tenantId, alarmOriginator, alarm, alarm.getCustomerId(), ActionType.ALARM_DELETE, user, alarm.getId());
+        verify(alarmSubscriptionService).deleteAlarm(tenantId, alarm.getId());
     }
 
     @Test
-    public void testUnassignAlarm() throws ThingsboardException {
+    void testDelete_deleteApiReturnsFalse_shouldNotLogActionAndReturnFalse() {
+        // GIVEN
+        var alarm = new Alarm(new AlarmId(Uuids.timeBased()));
+        alarm.setTenantId(tenantId);
+
+        var user = new User();
+
+        // WHEN
+        boolean actual = service.delete(alarm, user);
+
+        assertThat(actual).isFalse();
+        verifyNoInteractions(logEntityActionService);
+        verify(alarmSubscriptionService).deleteAlarm(tenantId, alarm.getId());
+    }
+
+    @Test
+    void testDelete_deleteApiThrowsException_shouldLogFailedActionAndRethrow() {
+        // GIVEN
+        var alarmOriginator = new DeviceId(Uuids.timeBased());
+
+        var alarm = new Alarm(new AlarmId(Uuids.timeBased()));
+        alarm.setTenantId(tenantId);
+        alarm.setOriginator(alarmOriginator);
+
+        var user = new User();
+
+        var exception = new RuntimeException("failed to delete alarm");
+
+        when(alarmSubscriptionService.deleteAlarm(tenantId, alarm.getId())).thenThrow(exception);
+
+        // WHEN-THEN
+        assertThatThrownBy(() -> service.delete(alarm, user))
+                .isInstanceOf(RuntimeException.class)
+                .hasMessage("failed to delete alarm");
+
+        verify(logEntityActionService).logEntityAction(tenantId, new DeviceId(EntityId.NULL_UUID), ActionType.ALARM_DELETE, user, exception, alarm.getId());
+        verify(alarmSubscriptionService).deleteAlarm(tenantId, alarm.getId());
+    }
+
+    @Test
+    void testUnassignAlarm() throws ThingsboardException {
         AlarmInfo alarm = new AlarmInfo();
         alarm.setId(new AlarmId(UUID.randomUUID()));
         when(alarmSubscriptionService.unassignAlarm(any(), any(), anyLong()))
@@ -174,12 +226,11 @@ public class DefaultTbAlarmServiceTest {
                 .comment(commentNode)
                 .build();
 
-        verify(alarmCommentService, times(1))
-                .saveAlarmComment(eq(alarm), eq(expectedAlarmComment), eq(user));
+        verify(alarmCommentService).saveAlarmComment(eq(alarm), eq(expectedAlarmComment), eq(user));
     }
 
     @Test
-    public void testUnassignDeletedUserAlarms() throws ThingsboardException {
+    void testUnassignDeletedUserAlarms() throws ThingsboardException {
         AlarmInfo alarm = new AlarmInfo();
         alarm.setId(new AlarmId(UUID.randomUUID()));
 
@@ -189,7 +240,7 @@ public class DefaultTbAlarmServiceTest {
         User user = new User();
         user.setEmail("testEmail@gmail.com");
         user.setId(new UserId(UUID.randomUUID()));
-        service.unassignDeletedUserAlarms(new TenantId(UUID.randomUUID()), user.getId(), user.getTitle(), List.of(alarm.getUuidId()), System.currentTimeMillis());
+        service.unassignDeletedUserAlarms(tenantId, user.getId(), user.getTitle(), List.of(alarm.getUuidId()), System.currentTimeMillis());
 
         ObjectNode commentNode = JacksonUtil.newObjectNode();
         commentNode.put("subtype", "ASSIGN");
@@ -200,9 +251,7 @@ public class DefaultTbAlarmServiceTest {
                 .comment(commentNode)
                 .build();
 
-        verify(alarmCommentService, times(1))
-                .saveAlarmComment(eq(alarm), eq(expectedAlarmComment), eq(null));
+        verify(alarmCommentService).saveAlarmComment(eq(alarm), eq(expectedAlarmComment), eq(null));
     }
 
-
 }
diff --git a/common/dao-api/src/main/java/org/thingsboard/server/dao/trendz/TrendzSettingsService.java b/common/dao-api/src/main/java/org/thingsboard/server/dao/trendz/TrendzSettingsService.java
new file mode 100644
index 0000000000..31f9495345
--- /dev/null
+++ b/common/dao-api/src/main/java/org/thingsboard/server/dao/trendz/TrendzSettingsService.java
@@ -0,0 +1,29 @@
+/**
+ * Copyright © 2016-2025 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.dao.trendz;
+
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.data.trendz.TrendzSettings;
+
+public interface TrendzSettingsService {
+
+    void saveTrendzSettings(TenantId tenantId, TrendzSettings settings);
+
+    TrendzSettings findTrendzSettings(TenantId tenantId);
+
+    void deleteTrendzSettings(TenantId tenantId);
+
+}
diff --git a/common/data/src/main/java/org/thingsboard/server/common/data/CacheConstants.java b/common/data/src/main/java/org/thingsboard/server/common/data/CacheConstants.java
index 35f69e1544..5b167c88a2 100644
--- a/common/data/src/main/java/org/thingsboard/server/common/data/CacheConstants.java
+++ b/common/data/src/main/java/org/thingsboard/server/common/data/CacheConstants.java
@@ -35,6 +35,7 @@ public class CacheConstants {
     public static final String DEVICE_PROFILE_CACHE = "deviceProfiles";
     public static final String NOTIFICATION_SETTINGS_CACHE = "notificationSettings";
     public static final String SENT_NOTIFICATIONS_CACHE = "sentNotifications";
+    public static final String TRENDZ_SETTINGS_CACHE = "trendzSettings";
 
     public static final String ASSET_PROFILE_CACHE = "assetProfiles";
     public static final String ATTRIBUTES_CACHE = "attributes";
diff --git a/common/data/src/main/java/org/thingsboard/server/common/data/SystemParams.java b/common/data/src/main/java/org/thingsboard/server/common/data/SystemParams.java
index b1ef4d7f22..fe3eb4e4d8 100644
--- a/common/data/src/main/java/org/thingsboard/server/common/data/SystemParams.java
+++ b/common/data/src/main/java/org/thingsboard/server/common/data/SystemParams.java
@@ -17,6 +17,7 @@ package org.thingsboard.server.common.data;
 
 import com.fasterxml.jackson.databind.JsonNode;
 import lombok.Data;
+import org.thingsboard.server.common.data.trendz.TrendzSettings;
 
 import java.util.List;
 
@@ -37,4 +38,5 @@ public class SystemParams {
     String calculatedFieldDebugPerTenantLimitsConfiguration;
     long maxArgumentsPerCF;
     long maxDataPointsPerRollingArg;
+    TrendzSettings trendzSettings;
 }
diff --git a/common/data/src/main/java/org/thingsboard/server/common/data/TbProperty.java b/common/data/src/main/java/org/thingsboard/server/common/data/TbProperty.java
index 98fd521ea3..a72bd6d085 100644
--- a/common/data/src/main/java/org/thingsboard/server/common/data/TbProperty.java
+++ b/common/data/src/main/java/org/thingsboard/server/common/data/TbProperty.java
@@ -15,14 +15,16 @@
  */
 package org.thingsboard.server.common.data;
 
+import lombok.AllArgsConstructor;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
-/**
- * Created by ashvayka on 25.09.18.
- */
 @Data
+@NoArgsConstructor
+@AllArgsConstructor
 public class TbProperty {
 
     private String key;
     private String value;
+
 }
diff --git a/common/data/src/main/java/org/thingsboard/server/common/data/trendz/TrendzSettings.java b/common/data/src/main/java/org/thingsboard/server/common/data/trendz/TrendzSettings.java
new file mode 100644
index 0000000000..3c3b49399c
--- /dev/null
+++ b/common/data/src/main/java/org/thingsboard/server/common/data/trendz/TrendzSettings.java
@@ -0,0 +1,26 @@
+/**
+ * Copyright © 2016-2025 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.trendz;
+
+import lombok.Data;
+
+@Data
+public class TrendzSettings {
+
+    private boolean enabled;
+    private String baseUrl;
+
+}
diff --git a/common/queue/src/main/java/org/thingsboard/server/queue/kafka/TbKafkaSettings.java b/common/queue/src/main/java/org/thingsboard/server/queue/kafka/TbKafkaSettings.java
index 82b5af179f..06ccfe3a69 100644
--- a/common/queue/src/main/java/org/thingsboard/server/queue/kafka/TbKafkaSettings.java
+++ b/common/queue/src/main/java/org/thingsboard/server/queue/kafka/TbKafkaSettings.java
@@ -15,6 +15,7 @@
  */
 package org.thingsboard.server.queue.kafka;
 
+import jakarta.annotation.PostConstruct;
 import jakarta.annotation.PreDestroy;
 import lombok.Getter;
 import lombok.Setter;
@@ -36,7 +37,8 @@ import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.data.TbProperty;
 import org.thingsboard.server.queue.util.PropertyUtils;
 
-import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Properties;
@@ -138,15 +140,26 @@ public class TbKafkaSettings {
     @Value("${queue.kafka.other-inline:}")
     private String otherInline;
 
+    @Value("${queue.kafka.consumer-properties-per-topic-inline:}")
+    private String consumerPropertiesPerTopicInline;
+
     @Deprecated
     @Setter
     private List<TbProperty> other;
 
     @Setter
-    private Map<String, List<TbProperty>> consumerPropertiesPerTopic = Collections.emptyMap();
+    private Map<String, List<TbProperty>> consumerPropertiesPerTopic = new HashMap<>();
 
     private volatile AdminClient adminClient;
 
+    @PostConstruct
+    public void initInlineTopicProperties() {
+        Map<String, List<TbProperty>> inlineProps = parseTopicPropertyList(consumerPropertiesPerTopicInline);
+        if (!inlineProps.isEmpty()) {
+            consumerPropertiesPerTopic.putAll(inlineProps);
+        }
+    }
+
     public Properties toConsumerProps(String topic) {
         Properties props = toProps();
         props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, servers);
@@ -245,6 +258,27 @@ public class TbKafkaSettings {
         return props;
     }
 
+    private Map<String, List<TbProperty>> parseTopicPropertyList(String inlineProperties) {
+        Map<String, List<String>> grouped = PropertyUtils.getGroupedProps(inlineProperties);
+        Map<String, List<TbProperty>> result = new HashMap<>();
+
+        grouped.forEach((topic, entries) -> {
+            Map<String, String> merged = new LinkedHashMap<>();
+            for (String entry : entries) {
+                String[] kv = entry.split("=", 2);
+                if (kv.length == 2) {
+                    merged.put(kv[0].trim(), kv[1].trim());
+                }
+            }
+            List<TbProperty> props = merged.entrySet().stream()
+                    .map(e -> new TbProperty(e.getKey(), e.getValue()))
+                    .toList();
+            result.put(topic, props);
+        });
+
+        return result;
+    }
+
     @PreDestroy
     private void destroy() {
         if (adminClient != null) {
diff --git a/common/queue/src/main/java/org/thingsboard/server/queue/util/PropertyUtils.java b/common/queue/src/main/java/org/thingsboard/server/queue/util/PropertyUtils.java
index 6030eb278d..629ee29f6f 100644
--- a/common/queue/src/main/java/org/thingsboard/server/queue/util/PropertyUtils.java
+++ b/common/queue/src/main/java/org/thingsboard/server/queue/util/PropertyUtils.java
@@ -17,7 +17,9 @@ package org.thingsboard.server.queue.util;
 
 import org.thingsboard.server.common.data.StringUtils;
 
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.function.Function;
 
@@ -38,6 +40,21 @@ public class PropertyUtils {
         return configs;
     }
 
+    public static Map<String, List<String>> getGroupedProps(String properties) {
+        Map<String, List<String>> configs = new HashMap<>();
+        if (StringUtils.isNotEmpty(properties)) {
+            for (String property : properties.split(";")) {
+                if (StringUtils.isNotEmpty(property)) {
+                    int delimiterPosition = property.indexOf(":");
+                    String topic = property.substring(0, delimiterPosition).trim();
+                    String value = property.substring(delimiterPosition + 1).trim();
+                    configs.computeIfAbsent(topic, k -> new ArrayList<>()).add(value);
+                }
+            }
+        }
+        return configs;
+    }
+
     public static Map<String, String> getProps(Map<String, String> defaultProperties, String propertiesStr) {
         return getProps(defaultProperties, propertiesStr, PropertyUtils::getProps);
     }
diff --git a/common/queue/src/test/java/org/thingsboard/server/queue/kafka/TbKafkaSettingsTest.java b/common/queue/src/test/java/org/thingsboard/server/queue/kafka/TbKafkaSettingsTest.java
index 5cdebc3996..ad026c63aa 100644
--- a/common/queue/src/test/java/org/thingsboard/server/queue/kafka/TbKafkaSettingsTest.java
+++ b/common/queue/src/test/java/org/thingsboard/server/queue/kafka/TbKafkaSettingsTest.java
@@ -33,6 +33,12 @@ import static org.mockito.Mockito.spy;
         "queue.type=kafka",
         "queue.kafka.bootstrap.servers=localhost:9092",
         "queue.kafka.other-inline=metrics.recording.level:INFO;metrics.sample.window.ms:30000",
+        "queue.kafka.consumer-properties-per-topic-inline=" +
+                "tb_core_updated:max.poll.records=10;" +
+                "tb_core_updated:enable.auto.commit=true;" +
+                "tb_core_updated:bootstrap.servers=kafka1:9092,kafka2:9092;" +
+                "tb_edge_updated:max.poll.records=5;" +
+                "tb_edge_updated:auto.offset.reset=latest"
 })
 class TbKafkaSettingsTest {
 
@@ -79,4 +85,16 @@ class TbKafkaSettingsTest {
         Mockito.verify(settings).configureSSL(any());
     }
 
-}
\ No newline at end of file
+    @Test
+    void givenMultipleTopicsInInlineConfig_whenParsed_thenEachTopicGetsExpectedProperties() {
+        Properties coreProps = settings.toConsumerProps("tb_core_updated");
+        assertThat(coreProps.getProperty("max.poll.records")).isEqualTo("10");
+        assertThat(coreProps.getProperty("enable.auto.commit")).isEqualTo("true");
+        assertThat(coreProps.getProperty("bootstrap.servers")).isEqualTo("kafka1:9092,kafka2:9092");
+
+        Properties edgeProps = settings.toConsumerProps("tb_edge_updated");
+        assertThat(edgeProps.getProperty("max.poll.records")).isEqualTo("5");
+        assertThat(edgeProps.getProperty("auto.offset.reset")).isEqualTo("latest");
+    }
+
+}
diff --git a/dao/src/main/java/org/thingsboard/server/dao/tenant/TenantServiceImpl.java b/dao/src/main/java/org/thingsboard/server/dao/tenant/TenantServiceImpl.java
index 1dbca5af12..8c40ca3e14 100644
--- a/dao/src/main/java/org/thingsboard/server/dao/tenant/TenantServiceImpl.java
+++ b/dao/src/main/java/org/thingsboard/server/dao/tenant/TenantServiceImpl.java
@@ -44,6 +44,7 @@ import org.thingsboard.server.dao.service.PaginatedRemover;
 import org.thingsboard.server.dao.service.Validator;
 import org.thingsboard.server.dao.service.validator.TenantDataValidator;
 import org.thingsboard.server.dao.settings.AdminSettingsService;
+import org.thingsboard.server.dao.trendz.TrendzSettingsService;
 import org.thingsboard.server.dao.usagerecord.ApiUsageStateService;
 import org.thingsboard.server.dao.user.UserService;
 
@@ -81,6 +82,8 @@ public class TenantServiceImpl extends AbstractCachedEntityService<TenantId, Ten
     @Autowired
     private QrCodeSettingService qrCodeSettingService;
     @Autowired
+    private TrendzSettingsService trendzSettingsService;
+    @Autowired
     private TenantDataValidator tenantValidator;
     @Autowired
     protected TbTransactionalCache<TenantId, Boolean> existsTenantCache;
@@ -163,9 +166,10 @@ public class TenantServiceImpl extends AbstractCachedEntityService<TenantId, Ten
         Validator.validateId(tenantId, id -> INCORRECT_TENANT_ID + id);
 
         userService.deleteAllByTenantId(tenantId);
+        notificationSettingsService.deleteNotificationSettings(tenantId);
+        trendzSettingsService.deleteTrendzSettings(tenantId);
         adminSettingsService.deleteAdminSettingsByTenantId(tenantId);
         qrCodeSettingService.deleteByTenantId(tenantId);
-        notificationSettingsService.deleteNotificationSettings(tenantId);
 
         tenantDao.removeById(tenantId, tenantId.getId());
         publishEvictEvent(new TenantEvictEvent(tenantId, true));
diff --git a/dao/src/main/java/org/thingsboard/server/dao/trendz/DefaultTrendzSettingsService.java b/dao/src/main/java/org/thingsboard/server/dao/trendz/DefaultTrendzSettingsService.java
new file mode 100644
index 0000000000..730d98cb6a
--- /dev/null
+++ b/dao/src/main/java/org/thingsboard/server/dao/trendz/DefaultTrendzSettingsService.java
@@ -0,0 +1,69 @@
+/**
+ * Copyright © 2016-2025 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.dao.trendz;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.stereotype.Service;
+import org.thingsboard.common.util.JacksonUtil;
+import org.thingsboard.server.common.data.AdminSettings;
+import org.thingsboard.server.common.data.CacheConstants;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.data.trendz.TrendzSettings;
+import org.thingsboard.server.dao.settings.AdminSettingsService;
+
+import java.util.Optional;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class DefaultTrendzSettingsService implements TrendzSettingsService {
+
+    private final AdminSettingsService adminSettingsService;
+
+    private static final String SETTINGS_KEY = "trendz";
+
+    @CacheEvict(cacheNames = CacheConstants.TRENDZ_SETTINGS_CACHE, key = "#tenantId")
+    @Override
+    public void saveTrendzSettings(TenantId tenantId, TrendzSettings settings) {
+        AdminSettings adminSettings = Optional.ofNullable(adminSettingsService.findAdminSettingsByTenantIdAndKey(tenantId, SETTINGS_KEY))
+                .orElseGet(() -> {
+                    AdminSettings newAdminSettings = new AdminSettings();
+                    newAdminSettings.setTenantId(tenantId);
+                    newAdminSettings.setKey(SETTINGS_KEY);
+                    return newAdminSettings;
+                });
+        adminSettings.setJsonValue(JacksonUtil.valueToTree(settings));
+        adminSettingsService.saveAdminSettings(tenantId, adminSettings);
+    }
+
+    @Cacheable(cacheNames = CacheConstants.TRENDZ_SETTINGS_CACHE, key = "#tenantId")
+    @Override
+    public TrendzSettings findTrendzSettings(TenantId tenantId) {
+        return Optional.ofNullable(adminSettingsService.findAdminSettingsByTenantIdAndKey(tenantId, SETTINGS_KEY))
+                .map(adminSettings -> JacksonUtil.treeToValue(adminSettings.getJsonValue(), TrendzSettings.class))
+                .orElseGet(TrendzSettings::new);
+    }
+
+    @CacheEvict(cacheNames = CacheConstants.TRENDZ_SETTINGS_CACHE, key = "#tenantId")
+    @Override
+    public void deleteTrendzSettings(TenantId tenantId) {
+        adminSettingsService.deleteAdminSettingsByTenantIdAndKey(tenantId, SETTINGS_KEY);
+    }
+
+}
diff --git a/dao/src/test/resources/application-test.properties b/dao/src/test/resources/application-test.properties
index a1bb335ad0..a44303107c 100644
--- a/dao/src/test/resources/application-test.properties
+++ b/dao/src/test/resources/application-test.properties
@@ -108,6 +108,9 @@ cache.specs.qrCodeSettings.maxSize=10000
 cache.specs.mobileSecretKey.timeToLiveInMinutes=1440
 cache.specs.mobileSecretKey.maxSize=10000
 
+cache.specs.trendzSettings.timeToLiveInMinutes=1440
+cache.specs.trendzSettings.maxSize=10000
+
 redis.connection.host=localhost
 redis.connection.port=6379
 redis.connection.db=0
diff --git a/edqs/src/main/resources/edqs.yml b/edqs/src/main/resources/edqs.yml
index 1cc32a4230..6e6e975d68 100644
--- a/edqs/src/main/resources/edqs.yml
+++ b/edqs/src/main/resources/edqs.yml
@@ -148,7 +148,11 @@ queue:
         - key: max.poll.records
           # Max poll records for edqs.state topic
           value: "${TB_QUEUE_KAFKA_EDQS_STATE_MAX_POLL_RECORDS:512}"
-
+    # If you override any default Kafka topic name using environment variables, you must also specify the related consumer properties
+    # for the new topic in `consumer-properties-per-topic-inline`. Otherwise, the topic will not inherit its expected configuration (e.g., max.poll.records, timeouts, etc).
+    # Format: "topic1:key1=value1,key2=value2;topic2:key=value"
+    # Example: "tb_core_modified.notifications:max.poll.records=10;tb_edge_modified:max.poll.records=10,enable.auto.commit=true"
+    consumer-properties-per-topic-inline: "${TB_QUEUE_KAFKA_CONSUMER_PROPERTIES_PER_TOPIC_INLINE:}"
     other-inline: "${TB_QUEUE_KAFKA_OTHER_PROPERTIES:}" # In this section you can specify custom parameters (semicolon separated) for Kafka consumer/producer/admin # Example "metrics.recording.level:INFO;metrics.sample.window.ms:30000"
     other: # DEPRECATED. In this section, you can specify custom parameters for Kafka consumer/producer and expose the env variables to configure outside
     #  - key: "request.timeout.ms" # refer to https://docs.confluent.io/platform/current/installation/configuration/producer-configs.html#producerconfigs_request.timeout.ms
diff --git a/msa/black-box-tests/src/test/java/org/thingsboard/server/msa/ContainerTestSuite.java b/msa/black-box-tests/src/test/java/org/thingsboard/server/msa/ContainerTestSuite.java
index f2e721bdcb..e00b0828c9 100644
--- a/msa/black-box-tests/src/test/java/org/thingsboard/server/msa/ContainerTestSuite.java
+++ b/msa/black-box-tests/src/test/java/org/thingsboard/server/msa/ContainerTestSuite.java
@@ -55,8 +55,8 @@ public class ContainerTestSuite {
     private static final String TB_JS_EXECUTOR_LOG_REGEXP = ".*template started.*";
     private static final Duration CONTAINER_STARTUP_TIMEOUT = Duration.ofSeconds(400);
 
-    private  DockerComposeContainer<?> testContainer;
-    private  ThingsBoardDbInstaller installTb;
+    private DockerComposeContainer<?> testContainer;
+    private ThingsBoardDbInstaller installTb;
     private boolean isActive;
 
     private static ContainerTestSuite containerTestSuite;
@@ -194,7 +194,7 @@ public class ContainerTestSuite {
             setActive(true);
         } catch (Exception e) {
             log.error("Failed to create test container", e);
-            fail("Failed to create test container");
+            fail("Failed to create test container", e);
         }
     }
 
@@ -263,7 +263,7 @@ public class ContainerTestSuite {
             log.info("Trying to delete temp dir {}", targetDir);
             FileUtils.deleteDirectory(new File(targetDir));
         } catch (IOException e) {
-            log.error("Can't delete temp directory " + targetDir, e);
+            log.error("Can't delete temp directory {}", targetDir, e);
         }
     }
 
@@ -286,8 +286,8 @@ public class ContainerTestSuite {
             FileUtils.writeStringToFile(file, outputContent, StandardCharsets.UTF_8);
             assertThat(FileUtils.readFileToString(file, StandardCharsets.UTF_8), is(outputContent));
         } catch (IOException e) {
-            log.error("failed to update file " + sourceFilename, e);
-            fail("failed to update file");
+            log.error("failed to update file {}", sourceFilename, e);
+            fail("failed to update file", e);
         }
     }
 
diff --git a/msa/black-box-tests/src/test/java/org/thingsboard/server/msa/connectivity/MqttClientTest.java b/msa/black-box-tests/src/test/java/org/thingsboard/server/msa/connectivity/MqttClientTest.java
index ebdfb4e3c9..1b1ed9bf0f 100644
--- a/msa/black-box-tests/src/test/java/org/thingsboard/server/msa/connectivity/MqttClientTest.java
+++ b/msa/black-box-tests/src/test/java/org/thingsboard/server/msa/connectivity/MqttClientTest.java
@@ -42,7 +42,6 @@ import org.thingsboard.mqtt.MqttClient;
 import org.thingsboard.mqtt.MqttClientCallback;
 import org.thingsboard.mqtt.MqttClientConfig;
 import org.thingsboard.mqtt.MqttHandler;
-import org.thingsboard.server.common.data.DataConstants;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.DeviceProfile;
 import org.thingsboard.server.common.data.DeviceProfileProvisionType;
@@ -82,7 +81,6 @@ import java.util.concurrent.TimeoutException;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.testng.Assert.assertNotNull;
 import static org.testng.Assert.fail;
-import static org.thingsboard.server.common.data.DataConstants.DEVICE;
 import static org.thingsboard.server.common.data.DataConstants.SHARED_SCOPE;
 import static org.thingsboard.server.msa.prototypes.DevicePrototypes.defaultDevicePrototype;
 
@@ -301,7 +299,7 @@ public class MqttClientTest extends AbstractContainerTest {
 
         assertThat(Objects.requireNonNull(requestFromServer).getMessage()).isEqualTo("{\"method\":\"getValue\",\"params\":true}");
 
-        Integer requestId = Integer.valueOf(Objects.requireNonNull(requestFromServer).getTopic().substring("v1/devices/me/rpc/request/".length()));
+        int requestId = Integer.parseInt(Objects.requireNonNull(requestFromServer).getTopic().substring("v1/devices/me/rpc/request/".length()));
         JsonObject clientResponse = new JsonObject();
         clientResponse.addProperty("response", "someResponse");
         // Send a response to the server's RPC request
@@ -340,7 +338,7 @@ public class MqttClientTest extends AbstractContainerTest {
 
         assertThat(Objects.requireNonNull(requestFromServer).getMessage()).isEqualTo("{\"method\":\"getValue\",\"params\":true}");
 
-        Integer requestId = Integer.valueOf(Objects.requireNonNull(requestFromServer).getTopic().substring("v1/devices/me/rpc/request/".length()));
+        int requestId = Integer.parseInt(Objects.requireNonNull(requestFromServer).getTopic().substring("v1/devices/me/rpc/request/".length()));
         JsonObject clientResponse = new JsonObject();
         clientResponse.addProperty("response", "someResponse");
         // Send a response to the server's RPC request
@@ -520,13 +518,13 @@ public class MqttClientTest extends AbstractContainerTest {
         mqttClient.on("/provision/response", listener, MqttQoS.AT_LEAST_ONCE).get(3 * timeoutMultiplier, TimeUnit.SECONDS);
         TimeUnit.SECONDS.sleep(2 * timeoutMultiplier);
         assertThat(subAckResult[0]).isNotNull();
-        assertThat(MqttReasonCodes.SubAck.GRANTED_QOS_1.equals(subAckResult[0]));
+        assertThat(MqttReasonCodes.SubAck.GRANTED_QOS_1).isEqualTo(subAckResult[0]);
 
         subAckResult[0] = null;
         mqttClient.on("v1/devices/me/attributes", listener, MqttQoS.AT_LEAST_ONCE).get(3 * timeoutMultiplier, TimeUnit.SECONDS);
         TimeUnit.SECONDS.sleep(2 * timeoutMultiplier);
         assertThat(subAckResult[0]).isNotNull();
-        assertThat(MqttReasonCodes.SubAck.TOPIC_FILTER_INVALID.equals(subAckResult[0]));
+        assertThat(MqttReasonCodes.SubAck.TOPIC_FILTER_INVALID).isEqualTo(subAckResult[0]);
 
         testRestClient.deleteDeviceIfExists(device.getId());
         updateDeviceProfileWithProvisioningStrategy(deviceProfile, DeviceProfileProvisionType.DISABLED);
@@ -596,7 +594,7 @@ public class MqttClientTest extends AbstractContainerTest {
                 .await()
                 .alias("Check device disconnect.")
                 .atMost(TIMEOUT*timeoutMultiplier, TimeUnit.SECONDS)
-                .until(() -> returnCodeByteValue.size() > 0);
+                .until(() -> !returnCodeByteValue.isEmpty());
 
         assertThat(returnCodeByteValueSecondClient).isEmpty();
         assertThat(returnCodeByteValue).isNotEmpty();
@@ -663,7 +661,7 @@ public class MqttClientTest extends AbstractContainerTest {
                 .stream()
                 .filter(RuleChain::isRoot)
                 .findFirst();
-        if (!defaultRuleChain.isPresent()) {
+        if (defaultRuleChain.isEmpty()) {
             fail("Root rule chain wasn't found");
         }
         return defaultRuleChain.get().getId();
@@ -717,6 +715,7 @@ public class MqttClientTest extends AbstractContainerTest {
         clientConfig.setClientId("MQTT client from test");
         clientConfig.setUsername(username);
         clientConfig.setProtocolVersion(mqttVersion);
+        clientConfig.setRetransmissionConfig(new MqttClientConfig.RetransmissionConfig(3, 5000L, 0.15d)); // same as defaults in thingsboard.yml as of time of this writing
         MqttClient mqttClient = MqttClient.create(clientConfig, listener, handlerExecutor);
         if (connect) {
             mqttClient.connect(TRANSPORT_HOST, TRANSPORT_PORT).get();
diff --git a/msa/black-box-tests/src/test/java/org/thingsboard/server/msa/connectivity/MqttGatewayClientTest.java b/msa/black-box-tests/src/test/java/org/thingsboard/server/msa/connectivity/MqttGatewayClientTest.java
index cc587fbbd5..fd9d4f557d 100644
--- a/msa/black-box-tests/src/test/java/org/thingsboard/server/msa/connectivity/MqttGatewayClientTest.java
+++ b/msa/black-box-tests/src/test/java/org/thingsboard/server/msa/connectivity/MqttGatewayClientTest.java
@@ -39,7 +39,6 @@ import org.thingsboard.common.util.ThingsBoardThreadFactory;
 import org.thingsboard.mqtt.MqttClient;
 import org.thingsboard.mqtt.MqttClientConfig;
 import org.thingsboard.mqtt.MqttHandler;
-import org.thingsboard.server.common.data.DataConstants;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.StringUtils;
 import org.thingsboard.server.common.data.id.DeviceId;
@@ -65,7 +64,6 @@ import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.thingsboard.server.common.data.DataConstants.DEVICE;
 import static org.thingsboard.server.common.data.DataConstants.SHARED_SCOPE;
 import static org.thingsboard.server.msa.prototypes.DevicePrototypes.defaultGatewayPrototype;
 
@@ -76,7 +74,6 @@ public class MqttGatewayClientTest extends AbstractContainerTest {
     private MqttClient mqttClient;
     private Device createdDevice;
     private MqttMessageListener listener;
-    private JsonParser jsonParser = new JsonParser();
 
     AbstractListeningExecutor handlerExecutor;
 
@@ -100,7 +97,7 @@ public class MqttGatewayClientTest extends AbstractContainerTest {
     }
 
     @AfterMethod
-    public void removeGateway()  {
+    public void removeGateway() {
         testRestClient.deleteDeviceIfExists(this.gatewayDevice.getId());
         testRestClient.deleteDeviceIfExists(this.createdDevice.getId());
         this.listener = null;
@@ -197,7 +194,7 @@ public class MqttGatewayClientTest extends AbstractContainerTest {
         mqttClient.publish("v1/gateway/attributes/request", Unpooled.wrappedBuffer(requestData.toString().getBytes())).get();
         event = listener.getEvents().poll(10 * timeoutMultiplier, TimeUnit.SECONDS);
 
-        JsonObject responseData = jsonParser.parse(Objects.requireNonNull(event).getMessage()).getAsJsonObject();
+        JsonObject responseData = JsonParser.parseString(Objects.requireNonNull(event).getMessage()).getAsJsonObject();
         assertThat(responseData.has("value")).isTrue();
         assertThat(responseData.get("value").getAsString()).isEqualTo(sharedAttributes.get("attr1").getAsString());
 
@@ -213,7 +210,7 @@ public class MqttGatewayClientTest extends AbstractContainerTest {
         mqttClient.on("v1/gateway/attributes/response", listener, MqttQoS.AT_LEAST_ONCE).get();
         mqttClient.publish("v1/gateway/attributes/request", Unpooled.wrappedBuffer(requestData.toString().getBytes())).get();
         event = listener.getEvents().poll(10 * timeoutMultiplier, TimeUnit.SECONDS);
-        responseData = jsonParser.parse(Objects.requireNonNull(event).getMessage()).getAsJsonObject();
+        responseData = JsonParser.parseString(Objects.requireNonNull(event).getMessage()).getAsJsonObject();
 
         assertThat(responseData.has("values")).isTrue();
         assertThat(responseData.get("values").getAsJsonObject().get("attr1").getAsString()).isEqualTo(sharedAttributes.get("attr1").getAsString());
@@ -231,7 +228,7 @@ public class MqttGatewayClientTest extends AbstractContainerTest {
         mqttClient.on("v1/gateway/attributes/response", listener, MqttQoS.AT_LEAST_ONCE).get();
         mqttClient.publish("v1/gateway/attributes/request", Unpooled.wrappedBuffer(requestData.toString().getBytes())).get();
         event = listener.getEvents().poll(10 * timeoutMultiplier, TimeUnit.SECONDS);
-        responseData = jsonParser.parse(Objects.requireNonNull(event).getMessage()).getAsJsonObject();
+        responseData = JsonParser.parseString(Objects.requireNonNull(event).getMessage()).getAsJsonObject();
 
         assertThat(responseData.has("values")).isTrue();
         assertThat(responseData.get("values").getAsJsonObject().get("attr1").getAsString()).isEqualTo(sharedAttributes.get("attr1").getAsString());
@@ -390,7 +387,7 @@ public class MqttGatewayClientTest extends AbstractContainerTest {
         mqttClient.publish("v1/gateway/attributes/request", Unpooled.wrappedBuffer(gatewayAttributesRequest.toString().getBytes())).get();
         MqttEvent clientAttributeEvent = listener.getEvents().poll(10 * timeoutMultiplier, TimeUnit.SECONDS);
         assertThat(clientAttributeEvent).isNotNull();
-        JsonObject responseMessage = new JsonParser().parse(Objects.requireNonNull(clientAttributeEvent).getMessage()).getAsJsonObject();
+        JsonObject responseMessage = JsonParser.parseString(Objects.requireNonNull(clientAttributeEvent).getMessage()).getAsJsonObject();
 
         assertThat(responseMessage.get("id").getAsInt()).isEqualTo(messageId);
         assertThat(responseMessage.get("device").getAsString()).isEqualTo(createdDevice.getName());
@@ -427,6 +424,7 @@ public class MqttGatewayClientTest extends AbstractContainerTest {
         clientConfig.setOwnerId(getOwnerId());
         clientConfig.setClientId("MQTT client from test");
         clientConfig.setUsername(deviceCredentials.getCredentialsId());
+        clientConfig.setRetransmissionConfig(new MqttClientConfig.RetransmissionConfig(3, 5000L, 0.15d)); // same as defaults in thingsboard.yml as of time of this writing
         MqttClient mqttClient = MqttClient.create(clientConfig, listener, handlerExecutor);
         mqttClient.connect("localhost", 1883).get();
         return mqttClient;
diff --git a/msa/vc-executor/src/main/resources/tb-vc-executor.yml b/msa/vc-executor/src/main/resources/tb-vc-executor.yml
index bb7f607ca0..7d1166e512 100644
--- a/msa/vc-executor/src/main/resources/tb-vc-executor.yml
+++ b/msa/vc-executor/src/main/resources/tb-vc-executor.yml
@@ -124,6 +124,11 @@ queue:
     #      tb_rule_engine.sq:
     #        - key: max.poll.records
     #          value: "${TB_QUEUE_KAFKA_SQ_MAX_POLL_RECORDS:1024}"
+    # If you override any default Kafka topic name using environment variables, you must also specify the related consumer properties
+    # for the new topic in `consumer-properties-per-topic-inline`. Otherwise, the topic will not inherit its expected configuration (e.g., max.poll.records, timeouts, etc).
+    # Format: "topic1:key1=value1,key2=value2;topic2:key=value"
+    # Example: "tb_core_modified.notifications:max.poll.records=10;tb_edge_modified:max.poll.records=10,enable.auto.commit=true"
+    consumer-properties-per-topic-inline: "${TB_QUEUE_KAFKA_CONSUMER_PROPERTIES_PER_TOPIC_INLINE:}"
     other-inline: "${TB_QUEUE_KAFKA_OTHER_PROPERTIES:}" # In this section you can specify custom parameters (semicolon separated) for Kafka consumer/producer/admin # Example "metrics.recording.level:INFO;metrics.sample.window.ms:30000"
     other: # DEPRECATED. In this section you can specify custom parameters for Kafka consumer/producer and expose the env variables to configure outside
     #  - key: "request.timeout.ms" # refer to https://docs.confluent.io/platform/current/installation/configuration/producer-configs.html#producerconfigs_request.timeout.ms
diff --git a/netty-mqtt/pom.xml b/netty-mqtt/pom.xml
index fb3f88fd9e..fa0c4e3fe3 100644
--- a/netty-mqtt/pom.xml
+++ b/netty-mqtt/pom.xml
@@ -87,6 +87,26 @@
             <artifactId>awaitility</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.testcontainers</groupId>
+            <artifactId>testcontainers</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.testcontainers</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>software.xdev</groupId>
+            <artifactId>testcontainers-junit4-mock</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.testcontainers</groupId>
+            <artifactId>hivemq</artifactId>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>
diff --git a/netty-mqtt/src/main/java/org/thingsboard/mqtt/MaxRetransmissionsReachedException.java b/netty-mqtt/src/main/java/org/thingsboard/mqtt/MaxRetransmissionsReachedException.java
new file mode 100644
index 0000000000..3d483dd541
--- /dev/null
+++ b/netty-mqtt/src/main/java/org/thingsboard/mqtt/MaxRetransmissionsReachedException.java
@@ -0,0 +1,24 @@
+/**
+ * Copyright © 2016-2025 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.mqtt;
+
+public class MaxRetransmissionsReachedException extends RuntimeException {
+
+    public MaxRetransmissionsReachedException(String message) {
+        super(message);
+    }
+
+}
diff --git a/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttChannelHandler.java b/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttChannelHandler.java
index ad976c848a..9686a2b1d7 100644
--- a/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttChannelHandler.java
+++ b/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttChannelHandler.java
@@ -57,7 +57,7 @@ final class MqttChannelHandler extends SimpleChannelInboundHandler<MqttMessage>
     }
 
     @Override
-    protected void channelRead0(ChannelHandlerContext ctx, MqttMessage msg) throws Exception {
+    protected void channelRead0(ChannelHandlerContext ctx, MqttMessage msg) {
         if (msg.decoderResult().isSuccess()) {
             switch (msg.fixedHeader().messageType()) {
                 case CONNACK:
@@ -120,6 +120,7 @@ final class MqttChannelHandler extends SimpleChannelInboundHandler<MqttMessage>
                 this.client.getClientConfig().getUsername(),
                 this.client.getClientConfig().getPassword() != null ? this.client.getClientConfig().getPassword().getBytes(CharsetUtil.UTF_8) : null
         );
+        log.debug("{} Sending CONNECT", client.getClientConfig().getOwnerId());
         ctx.channel().writeAndFlush(new MqttConnectMessage(fixedHeader, variableHeader, payload));
     }
 
@@ -173,6 +174,7 @@ final class MqttChannelHandler extends SimpleChannelInboundHandler<MqttMessage>
     }
 
     private void handleConack(Channel channel, MqttConnAckMessage message) {
+        log.debug("{} Handling CONNACK", client.getClientConfig().getOwnerId());
         switch (message.variableHeader().connectReturnCode()) {
             case CONNECTION_ACCEPTED:
                 this.connectFuture.setSuccess(new MqttConnectResult(true, MqttConnectReturnCode.CONNECTION_ACCEPTED, channel.closeFuture()));
@@ -219,9 +221,9 @@ final class MqttChannelHandler extends SimpleChannelInboundHandler<MqttMessage>
         }
         pendingSubscription.onSubackReceived();
         for (MqttPendingSubscription.MqttPendingHandler handler : pendingSubscription.getHandlers()) {
-            MqttSubscription subscription = new MqttSubscription(pendingSubscription.getTopic(), handler.getHandler(), handler.isOnce());
+            MqttSubscription subscription = new MqttSubscription(pendingSubscription.getTopic(), handler.handler(), handler.once());
             this.client.getSubscriptions().put(pendingSubscription.getTopic(), subscription);
-            this.client.getHandlerToSubscription().put(handler.getHandler(), subscription);
+            this.client.getHandlerToSubscription().put(handler.handler(), subscription);
         }
         this.client.getPendingSubscribeTopics().remove(pendingSubscription.getTopic());
 
@@ -282,17 +284,16 @@ final class MqttChannelHandler extends SimpleChannelInboundHandler<MqttMessage>
     }
 
     private void handlePuback(MqttPubAckMessage message) {
-        MqttPendingPublish pendingPublish = this.client.getPendingPublishes().get(message.variableHeader().messageId());
-        if (pendingPublish == null) {
-            return;
-        }
-        pendingPublish.getFuture().setSuccess(null);
-        pendingPublish.onPubackReceived();
-        this.client.getPendingPublishes().remove(message.variableHeader().messageId());
-        pendingPublish.getPayload().release();
-        if (this.client.getCallback() != null) {
-            this.client.getCallback().onPubAck(message);
-        }
+        log.trace("{} Handling PUBACK", client.getClientConfig().getOwnerId());
+        client.getPendingPublishes().computeIfPresent(message.variableHeader().messageId(), (__, pendingPublish) -> {
+            pendingPublish.getFuture().setSuccess(null);
+            pendingPublish.onPubackReceived();
+            pendingPublish.getPayload().release();
+            if (client.getCallback() != null) {
+                client.getCallback().onPubAck(message);
+            }
+            return null;
+        });
     }
 
     private void handlePubrec(Channel channel, MqttMessage message) {
@@ -335,6 +336,7 @@ final class MqttChannelHandler extends SimpleChannelInboundHandler<MqttMessage>
     }
 
     private void handleDisconnect(MqttMessage message) {
+        log.debug("{} Handling DISCONNECT", client.getClientConfig().getOwnerId());
         if (this.client.getCallback() != null) {
             this.client.getCallback().onDisconnect(message);
         }
diff --git a/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttClient.java b/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttClient.java
index db0459e08a..4d845320e8 100644
--- a/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttClient.java
+++ b/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttClient.java
@@ -184,7 +184,7 @@ public interface MqttClient {
      * @param config The config object to use while looking for settings
      * @param defaultHandler The handler for incoming messages that do not match any topic subscriptions
      */
-    static MqttClient create(MqttClientConfig config, MqttHandler defaultHandler, ListeningExecutor handlerExecutor){
+    static MqttClient create(MqttClientConfig config, MqttHandler defaultHandler, ListeningExecutor handlerExecutor) {
         return new MqttClientImpl(config, defaultHandler, handlerExecutor);
     }
 
diff --git a/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttClientConfig.java b/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttClientConfig.java
index 41df077d71..24feb3e58e 100644
--- a/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttClientConfig.java
+++ b/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttClientConfig.java
@@ -47,6 +47,26 @@ public final class MqttClientConfig {
     private long reconnectDelay = 1L;
     private int maxBytesInMessage = 8092;
 
+    @Getter
+    @Setter
+    private RetransmissionConfig retransmissionConfig;
+
+    public record RetransmissionConfig(int maxAttempts, long initialDelayMillis, double jitterFactor) {
+
+        public RetransmissionConfig {
+            if (maxAttempts < 0) {
+                throw new IllegalArgumentException("Max retransmission attempts (maxAttempts) must be zero or greater, but was " + maxAttempts);
+            }
+            if (initialDelayMillis < 0) {
+                throw new IllegalArgumentException("Initial retransmission delay (initialDelayMillis) must be zero or greater, but was " + initialDelayMillis);
+            }
+            if (jitterFactor < 0) {
+                throw new IllegalArgumentException("Jitter factor (jitterFactor) must be zero or greater, but was " + jitterFactor);
+            }
+        }
+
+    }
+
     public MqttClientConfig() {
         this(null);
     }
diff --git a/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttClientImpl.java b/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttClientImpl.java
index 47eae565dc..ee07752db3 100644
--- a/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttClientImpl.java
+++ b/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttClientImpl.java
@@ -17,6 +17,7 @@ package org.thingsboard.mqtt;
 
 import com.google.common.collect.HashMultimap;
 import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
 import io.netty.bootstrap.Bootstrap;
 import io.netty.buffer.ByteBuf;
 import io.netty.channel.Channel;
@@ -384,8 +385,33 @@ final class MqttClientImpl implements MqttClient {
         MqttFixedHeader fixedHeader = new MqttFixedHeader(MqttMessageType.PUBLISH, false, qos, retain, 0);
         MqttPublishVariableHeader variableHeader = new MqttPublishVariableHeader(topic, getNewMessageId().messageId());
         MqttPublishMessage message = new MqttPublishMessage(fixedHeader, variableHeader, payload);
-        MqttPendingPublish pendingPublish = new MqttPendingPublish(variableHeader.packetId(), future,
-                payload.retain(), message, qos, () -> !pendingPublishes.containsKey(variableHeader.packetId()));
+
+        final var pendingPublish = MqttPendingPublish.builder()
+                .messageId(variableHeader.packetId())
+                .future(future)
+                .payload(payload.retain())
+                .message(message)
+                .qos(qos)
+                .ownerId(clientConfig.getOwnerId())
+                .retransmissionConfig(clientConfig.getRetransmissionConfig())
+                .pendingOperation(new PendingOperation() {
+                    @Override
+                    public boolean isCancelled() {
+                        return !pendingPublishes.containsKey(variableHeader.packetId());
+                    }
+
+                    @Override
+                    public void onMaxRetransmissionAttemptsReached() {
+                        pendingPublishes.computeIfPresent(variableHeader.packetId(), (__, pendingPublish) -> {
+                            var message = "Unable to deliver publish message due to max retransmission attempts (%s) being reached for client '%s' on topic '%s' (message ID: %d)"
+                                    .formatted(clientConfig.getRetransmissionConfig().maxAttempts(), clientConfig.getClientId(), topic, variableHeader.packetId());
+                            pendingPublish.getFuture().tryFailure(new MaxRetransmissionsReachedException(message));
+                            pendingPublish.getPayload().release();
+                            return null;
+                        });
+                    }
+                }).build();
+
         this.pendingPublishes.put(pendingPublish.getMessageId(), pendingPublish);
         ChannelFuture channelFuture = this.sendAndFlushPacket(message);
 
@@ -499,9 +525,30 @@ final class MqttClientImpl implements MqttClient {
         MqttSubscribePayload payload = new MqttSubscribePayload(Collections.singletonList(subscription));
         MqttSubscribeMessage message = new MqttSubscribeMessage(fixedHeader, variableHeader, payload);
 
-        final MqttPendingSubscription pendingSubscription = new MqttPendingSubscription(future, topic, message,
-                () -> !pendingSubscriptions.containsKey(variableHeader.messageId()));
-        pendingSubscription.addHandler(handler, once);
+        final var pendingSubscription = MqttPendingSubscription.builder()
+                .future(future)
+                .topic(topic)
+                .handlers(Sets.newHashSet(new MqttPendingSubscription.MqttPendingHandler(handler, once)))
+                .subscribeMessage(message)
+                .ownerId(clientConfig.getOwnerId())
+                .retransmissionConfig(clientConfig.getRetransmissionConfig())
+                .pendingOperation(new PendingOperation() {
+                    @Override
+                    public boolean isCancelled() {
+                        return !pendingSubscriptions.containsKey(variableHeader.messageId());
+                    }
+
+                    @Override
+                    public void onMaxRetransmissionAttemptsReached() {
+                        pendingSubscriptions.computeIfPresent(variableHeader.messageId(), (__, pendingSubscription) -> {
+                            var message = "Unable to deliver subscribe message due to max retransmission attempts (%s) being reached for client '%s' on topic '%s' (message ID: %d)"
+                                    .formatted(clientConfig.getRetransmissionConfig().maxAttempts(), clientConfig.getClientId(), topic, variableHeader.messageId());
+                            pendingSubscription.getFuture().tryFailure(new MaxRetransmissionsReachedException(message));
+                            return null;
+                        });
+                    }
+                }).build();
+
         this.pendingSubscriptions.put(variableHeader.messageId(), pendingSubscription);
         this.pendingSubscribeTopics.add(topic);
         pendingSubscription.setSent(this.sendAndFlushPacket(message) != null); //If not sent, we will send it when the connection is opened
@@ -518,8 +565,29 @@ final class MqttClientImpl implements MqttClient {
             MqttUnsubscribePayload payload = new MqttUnsubscribePayload(Collections.singletonList(topic));
             MqttUnsubscribeMessage message = new MqttUnsubscribeMessage(fixedHeader, variableHeader, payload);
 
-            MqttPendingUnsubscription pendingUnsubscription = new MqttPendingUnsubscription(promise, topic, message,
-                    () -> !pendingServerUnsubscribes.containsKey(variableHeader.messageId()));
+            final var pendingUnsubscription = MqttPendingUnsubscription.builder()
+                    .future(promise)
+                    .topic(topic)
+                    .unsubscribeMessage(message)
+                    .ownerId(clientConfig.getOwnerId())
+                    .retransmissionConfig(clientConfig.getRetransmissionConfig())
+                    .pendingOperation(new PendingOperation() {
+                        @Override
+                        public boolean isCancelled() {
+                            return !pendingServerUnsubscribes.containsKey(variableHeader.messageId());
+                        }
+
+                        @Override
+                        public void onMaxRetransmissionAttemptsReached() {
+                            pendingServerUnsubscribes.computeIfPresent(variableHeader.messageId(), (__, pendingUnsubscription) -> {
+                                var message = "Unable to deliver unsubscribe message due to max retransmission attempts (%s) being reached for client '%s' on topic '%s' (message ID: %d)"
+                                        .formatted(clientConfig.getRetransmissionConfig().maxAttempts(), clientConfig.getClientId(), topic, variableHeader.messageId());
+                                pendingUnsubscription.getFuture().tryFailure(new MaxRetransmissionsReachedException(message));
+                                return null;
+                            });
+                        }
+                    }).build();
+
             this.pendingServerUnsubscribes.put(variableHeader.messageId(), pendingUnsubscription);
             pendingUnsubscription.startRetransmissionTimer(this.eventLoop.next(), this::sendAndFlushPacket);
 
diff --git a/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttConnectResult.java b/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttConnectResult.java
index 911bc1d395..67757d2a7a 100644
--- a/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttConnectResult.java
+++ b/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttConnectResult.java
@@ -17,7 +17,9 @@ package org.thingsboard.mqtt;
 
 import io.netty.channel.ChannelFuture;
 import io.netty.handler.codec.mqtt.MqttConnectReturnCode;
+import lombok.ToString;
 
+@ToString
 @SuppressWarnings({"WeakerAccess", "unused"})
 public final class MqttConnectResult {
 
@@ -42,4 +44,5 @@ public final class MqttConnectResult {
     public ChannelFuture getCloseFuture() {
         return closeFuture;
     }
+
 }
diff --git a/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttPendingPublish.java b/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttPendingPublish.java
index e8c3ef35f7..1846bdb12b 100644
--- a/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttPendingPublish.java
+++ b/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttPendingPublish.java
@@ -21,9 +21,13 @@ import io.netty.handler.codec.mqtt.MqttMessage;
 import io.netty.handler.codec.mqtt.MqttPublishMessage;
 import io.netty.handler.codec.mqtt.MqttQoS;
 import io.netty.util.concurrent.Promise;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
 
 import java.util.function.Consumer;
 
+@Getter(AccessLevel.PACKAGE)
 final class MqttPendingPublish {
 
     private final int messageId;
@@ -32,80 +36,126 @@ final class MqttPendingPublish {
     private final MqttPublishMessage message;
     private final MqttQoS qos;
 
+    @Getter(AccessLevel.NONE)
     private final RetransmissionHandler<MqttPublishMessage> publishRetransmissionHandler;
+    @Getter(AccessLevel.NONE)
     private final RetransmissionHandler<MqttMessage> pubrelRetransmissionHandler;
 
+    @Setter(AccessLevel.PACKAGE)
     private boolean sent = false;
 
-    MqttPendingPublish(int messageId, Promise<Void> future, ByteBuf payload, MqttPublishMessage message, MqttQoS qos, PendingOperation operation) {
+    private MqttPendingPublish(
+            int messageId,
+            Promise<Void> future,
+            ByteBuf payload,
+            MqttPublishMessage message,
+            MqttQoS qos,
+            String ownerId,
+            MqttClientConfig.RetransmissionConfig retransmissionConfig,
+            PendingOperation pendingOperation
+    ) {
         this.messageId = messageId;
         this.future = future;
         this.payload = payload;
         this.message = message;
         this.qos = qos;
 
-        this.publishRetransmissionHandler = new RetransmissionHandler<>(operation);
-        this.publishRetransmissionHandler.setOriginalMessage(message);
-        this.pubrelRetransmissionHandler = new RetransmissionHandler<>(operation);
-    }
-
-    int getMessageId() {
-        return messageId;
-    }
-
-    Promise<Void> getFuture() {
-        return future;
-    }
-
-    ByteBuf getPayload() {
-        return payload;
-    }
-
-    boolean isSent() {
-        return sent;
-    }
-
-    void setSent(boolean sent) {
-        this.sent = sent;
-    }
-
-    MqttPublishMessage getMessage() {
-        return message;
-    }
-
-    MqttQoS getQos() {
-        return qos;
+        publishRetransmissionHandler = new RetransmissionHandler<>(retransmissionConfig, pendingOperation, ownerId);
+        publishRetransmissionHandler.setOriginalMessage(message);
+        pubrelRetransmissionHandler = new RetransmissionHandler<>(retransmissionConfig, pendingOperation, ownerId);
     }
 
     void startPublishRetransmissionTimer(EventLoop eventLoop, Consumer<Object> sendPacket) {
-        this.publishRetransmissionHandler.setHandle(((fixedHeader, originalMessage) ->
-                sendPacket.accept(new MqttPublishMessage(fixedHeader, originalMessage.variableHeader(), this.payload.retain()))));
-        this.publishRetransmissionHandler.start(eventLoop);
+        publishRetransmissionHandler.setHandler(((fixedHeader, originalMessage) ->
+                sendPacket.accept(new MqttPublishMessage(fixedHeader, originalMessage.variableHeader(), payload.retain()))));
+        publishRetransmissionHandler.start(eventLoop);
     }
 
     void onPubackReceived() {
-        this.publishRetransmissionHandler.stop();
+        publishRetransmissionHandler.stop();
     }
 
     void setPubrelMessage(MqttMessage pubrelMessage) {
-        this.pubrelRetransmissionHandler.setOriginalMessage(pubrelMessage);
+        pubrelRetransmissionHandler.setOriginalMessage(pubrelMessage);
     }
 
     void startPubrelRetransmissionTimer(EventLoop eventLoop, Consumer<Object> sendPacket) {
-        this.pubrelRetransmissionHandler.setHandle((fixedHeader, originalMessage) ->
+        pubrelRetransmissionHandler.setHandler((fixedHeader, originalMessage) ->
                 sendPacket.accept(new MqttMessage(fixedHeader, originalMessage.variableHeader())));
-        this.pubrelRetransmissionHandler.start(eventLoop);
+        pubrelRetransmissionHandler.start(eventLoop);
     }
 
     void onPubcompReceived() {
-        this.pubrelRetransmissionHandler.stop();
+        pubrelRetransmissionHandler.stop();
     }
 
     void onChannelClosed() {
-        this.publishRetransmissionHandler.stop();
-        this.pubrelRetransmissionHandler.stop();
+        publishRetransmissionHandler.stop();
+        pubrelRetransmissionHandler.stop();
         if (payload != null) {
             payload.release();
         }
     }
+
+    static Builder builder() {
+        return new Builder();
+    }
+
+    static class Builder {
+
+        private int messageId;
+        private Promise<Void> future;
+        private ByteBuf payload;
+        private MqttPublishMessage message;
+        private MqttQoS qos;
+        private String ownerId;
+        private MqttClientConfig.RetransmissionConfig retransmissionConfig;
+        private PendingOperation pendingOperation;
+
+        Builder messageId(int messageId) {
+            this.messageId = messageId;
+            return this;
+        }
+
+        Builder future(Promise<Void> future) {
+            this.future = future;
+            return this;
+        }
+
+        Builder payload(ByteBuf payload) {
+            this.payload = payload;
+            return this;
+        }
+
+        Builder message(MqttPublishMessage message) {
+            this.message = message;
+            return this;
+        }
+
+        Builder qos(MqttQoS qos) {
+            this.qos = qos;
+            return this;
+        }
+
+        Builder ownerId(String ownerId) {
+            this.ownerId = ownerId;
+            return this;
+        }
+
+        Builder retransmissionConfig(MqttClientConfig.RetransmissionConfig retransmissionConfig) {
+            this.retransmissionConfig = retransmissionConfig;
+            return this;
+        }
+
+        Builder pendingOperation(PendingOperation pendingOperation) {
+            this.pendingOperation = pendingOperation;
+            return this;
+        }
+
+        MqttPendingPublish build() {
+            return new MqttPendingPublish(messageId, future, payload, message, qos, ownerId, retransmissionConfig, pendingOperation);
+        }
+
+    }
+
 }
diff --git a/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttPendingSubscription.java b/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttPendingSubscription.java
index af5d53a06c..7b2ba613cb 100644
--- a/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttPendingSubscription.java
+++ b/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttPendingSubscription.java
@@ -18,90 +18,123 @@ package org.thingsboard.mqtt;
 import io.netty.channel.EventLoop;
 import io.netty.handler.codec.mqtt.MqttSubscribeMessage;
 import io.netty.util.concurrent.Promise;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
 
 import java.util.HashSet;
 import java.util.Set;
 import java.util.function.Consumer;
 
+import static java.util.Objects.requireNonNullElseGet;
+
+@Getter(AccessLevel.PACKAGE)
 final class MqttPendingSubscription {
 
     private final Promise<Void> future;
     private final String topic;
-    private final Set<MqttPendingHandler> handlers = new HashSet<>();
+    private final Set<MqttPendingHandler> handlers;
     private final MqttSubscribeMessage subscribeMessage;
 
+    @Getter(AccessLevel.NONE)
     private final RetransmissionHandler<MqttSubscribeMessage> retransmissionHandler;
 
+    @Setter(AccessLevel.PACKAGE)
     private boolean sent = false;
 
-    MqttPendingSubscription(Promise<Void> future, String topic, MqttSubscribeMessage message, PendingOperation operation) {
+    private MqttPendingSubscription(
+            Promise<Void> future,
+            String topic,
+            Set<MqttPendingHandler> handlers,
+            MqttSubscribeMessage subscribeMessage,
+            String ownerId,
+            MqttClientConfig.RetransmissionConfig retransmissionConfig,
+            PendingOperation operation
+    ) {
         this.future = future;
         this.topic = topic;
-        this.subscribeMessage = message;
+        this.handlers = requireNonNullElseGet(handlers, HashSet::new);
+        this.subscribeMessage = subscribeMessage;
 
-        this.retransmissionHandler = new RetransmissionHandler<>(operation);
-        this.retransmissionHandler.setOriginalMessage(message);
+        retransmissionHandler = new RetransmissionHandler<>(retransmissionConfig, operation, ownerId);
+        retransmissionHandler.setOriginalMessage(subscribeMessage);
     }
 
-    Promise<Void> getFuture() {
-        return future;
-    }
+    record MqttPendingHandler(MqttHandler handler, boolean once) {}
 
-    String getTopic() {
-        return topic;
+    void addHandler(MqttHandler handler, boolean once) {
+        handlers.add(new MqttPendingHandler(handler, once));
     }
 
-    boolean isSent() {
-        return sent;
+    void startRetransmitTimer(EventLoop eventLoop, Consumer<Object> sendPacket) {
+        if (sent) { // If the packet is sent, we can start the retransmission timer
+            retransmissionHandler.setHandler((fixedHeader, originalMessage) ->
+                    sendPacket.accept(new MqttSubscribeMessage(fixedHeader, originalMessage.variableHeader(), originalMessage.payload())));
+            retransmissionHandler.start(eventLoop);
+        }
     }
 
-    void setSent(boolean sent) {
-        this.sent = sent;
+    void onSubackReceived() {
+        retransmissionHandler.stop();
     }
 
-    MqttSubscribeMessage getSubscribeMessage() {
-        return subscribeMessage;
+    void onChannelClosed() {
+        retransmissionHandler.stop();
     }
 
-    void addHandler(MqttHandler handler, boolean once) {
-        this.handlers.add(new MqttPendingHandler(handler, once));
+    static Builder builder() {
+        return new Builder();
     }
 
-    Set<MqttPendingHandler> getHandlers() {
-        return handlers;
-    }
+    static class Builder {
 
-    void startRetransmitTimer(EventLoop eventLoop, Consumer<Object> sendPacket) {
-        if (this.sent) { //If the packet is sent, we can start the retransmit timer
-            this.retransmissionHandler.setHandle((fixedHeader, originalMessage) ->
-                    sendPacket.accept(new MqttSubscribeMessage(fixedHeader, originalMessage.variableHeader(), originalMessage.payload())));
-            this.retransmissionHandler.start(eventLoop);
+        private Promise<Void> future;
+        private String topic;
+        private Set<MqttPendingHandler> handlers;
+        private MqttSubscribeMessage subscribeMessage;
+        private String ownerId;
+        private PendingOperation pendingOperation;
+        private MqttClientConfig.RetransmissionConfig retransmissionConfig;
+
+        Builder future(Promise<Void> future) {
+            this.future = future;
+            return this;
         }
-    }
 
-    void onSubackReceived() {
-        this.retransmissionHandler.stop();
-    }
+        Builder topic(String topic) {
+            this.topic = topic;
+            return this;
+        }
 
-    final class MqttPendingHandler {
-        private final MqttHandler handler;
-        private final boolean once;
+        Builder handlers(Set<MqttPendingHandler> handlers) {
+            this.handlers = handlers;
+            return this;
+        }
 
-        MqttPendingHandler(MqttHandler handler, boolean once) {
-            this.handler = handler;
-            this.once = once;
+        Builder subscribeMessage(MqttSubscribeMessage subscribeMessage) {
+            this.subscribeMessage = subscribeMessage;
+            return this;
         }
 
-        MqttHandler getHandler() {
-            return handler;
+        Builder ownerId(String ownerId) {
+            this.ownerId = ownerId;
+            return this;
         }
 
-        boolean isOnce() {
-            return once;
+        Builder retransmissionConfig(MqttClientConfig.RetransmissionConfig retransmissionConfig) {
+            this.retransmissionConfig = retransmissionConfig;
+            return this;
+        }
+
+        Builder pendingOperation(PendingOperation pendingOperation) {
+            this.pendingOperation = pendingOperation;
+            return this;
+        }
+
+        MqttPendingSubscription build() {
+            return new MqttPendingSubscription(future, topic, handlers, subscribeMessage, ownerId, retransmissionConfig, pendingOperation);
         }
-    }
 
-    void onChannelClosed() {
-        this.retransmissionHandler.stop();
     }
+
 }
diff --git a/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttPendingUnsubscription.java b/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttPendingUnsubscription.java
index 9cb3bd2f8d..8bc23292f8 100644
--- a/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttPendingUnsubscription.java
+++ b/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttPendingUnsubscription.java
@@ -18,43 +18,96 @@ package org.thingsboard.mqtt;
 import io.netty.channel.EventLoop;
 import io.netty.handler.codec.mqtt.MqttUnsubscribeMessage;
 import io.netty.util.concurrent.Promise;
+import lombok.AccessLevel;
+import lombok.Getter;
 
 import java.util.function.Consumer;
 
-final class MqttPendingUnsubscription{
+@Getter(AccessLevel.PACKAGE)
+final class MqttPendingUnsubscription {
 
     private final Promise<Void> future;
     private final String topic;
 
+    @Getter(AccessLevel.NONE)
     private final RetransmissionHandler<MqttUnsubscribeMessage> retransmissionHandler;
 
-    MqttPendingUnsubscription(Promise<Void> future, String topic, MqttUnsubscribeMessage unsubscribeMessage, PendingOperation operation) {
+    private MqttPendingUnsubscription(
+            Promise<Void> future,
+            String topic,
+            MqttUnsubscribeMessage unsubscribeMessage,
+            String ownerId,
+            MqttClientConfig.RetransmissionConfig retransmissionConfig,
+            PendingOperation operation
+    ) {
         this.future = future;
         this.topic = topic;
 
-        this.retransmissionHandler = new RetransmissionHandler<>(operation);
-        this.retransmissionHandler.setOriginalMessage(unsubscribeMessage);
+        retransmissionHandler = new RetransmissionHandler<>(retransmissionConfig, operation, ownerId);
+        retransmissionHandler.setOriginalMessage(unsubscribeMessage);
     }
 
-    Promise<Void> getFuture() {
-        return future;
+    void startRetransmissionTimer(EventLoop eventLoop, Consumer<Object> sendPacket) {
+        retransmissionHandler.setHandler((fixedHeader, originalMessage) ->
+                sendPacket.accept(new MqttUnsubscribeMessage(fixedHeader, originalMessage.variableHeader(), originalMessage.payload())));
+        retransmissionHandler.start(eventLoop);
     }
 
-    String getTopic() {
-        return topic;
+    void onUnsubackReceived() {
+        retransmissionHandler.stop();
     }
 
-    void startRetransmissionTimer(EventLoop eventLoop, Consumer<Object> sendPacket) {
-        this.retransmissionHandler.setHandle((fixedHeader, originalMessage) ->
-                sendPacket.accept(new MqttUnsubscribeMessage(fixedHeader, originalMessage.variableHeader(), originalMessage.payload())));
-        this.retransmissionHandler.start(eventLoop);
+    void onChannelClosed() {
+        retransmissionHandler.stop();
     }
 
-    void onUnsubackReceived(){
-        this.retransmissionHandler.stop();
+    static Builder builder() {
+        return new Builder();
     }
 
-    void onChannelClosed(){
-        this.retransmissionHandler.stop();
+    static class Builder {
+
+        private Promise<Void> future;
+        private String topic;
+        private MqttUnsubscribeMessage unsubscribeMessage;
+        private String ownerId;
+        private PendingOperation pendingOperation;
+        private MqttClientConfig.RetransmissionConfig retransmissionConfig;
+
+        Builder future(Promise<Void> future) {
+            this.future = future;
+            return this;
+        }
+
+        Builder topic(String topic) {
+            this.topic = topic;
+            return this;
+        }
+
+        Builder unsubscribeMessage(MqttUnsubscribeMessage unsubscribeMessage) {
+            this.unsubscribeMessage = unsubscribeMessage;
+            return this;
+        }
+
+        Builder ownerId(String ownerId) {
+            this.ownerId = ownerId;
+            return this;
+        }
+
+        Builder retransmissionConfig(MqttClientConfig.RetransmissionConfig retransmissionConfig) {
+            this.retransmissionConfig = retransmissionConfig;
+            return this;
+        }
+
+        Builder pendingOperation(PendingOperation pendingOperation) {
+            this.pendingOperation = pendingOperation;
+            return this;
+        }
+
+        MqttPendingUnsubscription build() {
+            return new MqttPendingUnsubscription(future, topic, unsubscribeMessage, ownerId, retransmissionConfig, pendingOperation);
+        }
+
     }
+
 }
diff --git a/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttPingHandler.java b/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttPingHandler.java
index 70a4992d72..3fc2c6246e 100644
--- a/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttPingHandler.java
+++ b/netty-mqtt/src/main/java/org/thingsboard/mqtt/MqttPingHandler.java
@@ -42,12 +42,11 @@ final class MqttPingHandler extends ChannelInboundHandlerAdapter {
     }
 
     @Override
-    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
-        if (!(msg instanceof MqttMessage)) {
+    public void channelRead(ChannelHandlerContext ctx, Object msg) {
+        if (!(msg instanceof MqttMessage message)) {
             ctx.fireChannelRead(msg);
             return;
         }
-        MqttMessage message = (MqttMessage) msg;
         if (message.fixedHeader().messageType() == MqttMessageType.PINGREQ) {
             this.handlePingReq(ctx.channel());
         } else if (message.fixedHeader().messageType() == MqttMessageType.PINGRESP) {
@@ -61,28 +60,29 @@ final class MqttPingHandler extends ChannelInboundHandlerAdapter {
     public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
         super.userEventTriggered(ctx, evt);
 
-        if (evt instanceof IdleStateEvent) {
-            IdleStateEvent event = (IdleStateEvent) evt;
+        if (evt instanceof IdleStateEvent event) {
             switch (event.state()) {
                 case READER_IDLE:
                     log.debug("[{}] No reads were performed for specified period for channel {}", event.state(), ctx.channel().id());
-                    this.sendPingReq(ctx.channel());
+                    this.sendPingReq(ctx.channel(), event);
                     break;
                 case WRITER_IDLE:
                     log.debug("[{}] No writes were performed for specified period for channel {}", event.state(), ctx.channel().id());
-                    this.sendPingReq(ctx.channel());
+                    this.sendPingReq(ctx.channel(), event);
                     break;
             }
         }
     }
 
-    private void sendPingReq(Channel channel) {
+    private void sendPingReq(Channel channel, IdleStateEvent idleEvent) {
         log.trace("[{}] Sending ping request", channel.id());
         MqttFixedHeader fixedHeader = new MqttFixedHeader(MqttMessageType.PINGREQ, false, MqttQoS.AT_MOST_ONCE, false, 0);
         channel.writeAndFlush(new MqttMessage(fixedHeader));
 
         if (this.pingRespTimeout == null) {
+            log.trace("[{}] Scheduling disconnect due to {}", channel.id(), idleEvent);
             this.pingRespTimeout = channel.eventLoop().schedule(() -> {
+                log.trace("[{}] Sending disconnect due to {}", channel.id(), idleEvent);
                 MqttFixedHeader fixedHeader2 = new MqttFixedHeader(MqttMessageType.DISCONNECT, false, MqttQoS.AT_MOST_ONCE, false, 0);
                 channel.writeAndFlush(new MqttMessage(fixedHeader2)).addListener(ChannelFutureListener.CLOSE);
                 //TODO: what do when the connection is closed ?
@@ -99,6 +99,7 @@ final class MqttPingHandler extends ChannelInboundHandlerAdapter {
     private void handlePingResp(Channel channel) {
         log.trace("[{}] Handling ping response", channel.id());
         if (this.pingRespTimeout != null && !this.pingRespTimeout.isCancelled() && !this.pingRespTimeout.isDone()) {
+            log.trace("[{}] Cancelling disconnect due to idle event because ping response was received", channel.id());
             this.pingRespTimeout.cancel(true);
             this.pingRespTimeout = null;
         }
diff --git a/netty-mqtt/src/main/java/org/thingsboard/mqtt/PendingOperation.java b/netty-mqtt/src/main/java/org/thingsboard/mqtt/PendingOperation.java
index b859b216e6..07e472abb3 100644
--- a/netty-mqtt/src/main/java/org/thingsboard/mqtt/PendingOperation.java
+++ b/netty-mqtt/src/main/java/org/thingsboard/mqtt/PendingOperation.java
@@ -17,6 +17,8 @@ package org.thingsboard.mqtt;
 
 public interface PendingOperation {
 
-    boolean isCanceled();
+    boolean isCancelled();
+
+    void onMaxRetransmissionAttemptsReached();
 
 }
diff --git a/netty-mqtt/src/main/java/org/thingsboard/mqtt/RetransmissionHandler.java b/netty-mqtt/src/main/java/org/thingsboard/mqtt/RetransmissionHandler.java
index b0d9ba9002..1778abc593 100644
--- a/netty-mqtt/src/main/java/org/thingsboard/mqtt/RetransmissionHandler.java
+++ b/netty-mqtt/src/main/java/org/thingsboard/mqtt/RetransmissionHandler.java
@@ -18,66 +18,119 @@ package org.thingsboard.mqtt;
 import io.netty.channel.EventLoop;
 import io.netty.handler.codec.mqtt.MqttFixedHeader;
 import io.netty.handler.codec.mqtt.MqttMessage;
+import io.netty.handler.codec.mqtt.MqttMessageIdVariableHeader;
 import io.netty.handler.codec.mqtt.MqttMessageType;
+import io.netty.handler.codec.mqtt.MqttPublishVariableHeader;
 import io.netty.handler.codec.mqtt.MqttQoS;
 import io.netty.util.concurrent.ScheduledFuture;
 import lombok.RequiredArgsConstructor;
+import lombok.Setter;
+import lombok.extern.slf4j.Slf4j;
 
+import java.util.concurrent.ThreadLocalRandom;
 import java.util.concurrent.TimeUnit;
 import java.util.function.BiConsumer;
 
+@Slf4j
 @RequiredArgsConstructor
 final class RetransmissionHandler<T extends MqttMessage> {
 
-    private volatile boolean stopped;
+    private final MqttClientConfig.RetransmissionConfig config;
     private final PendingOperation pendingOperation;
+
+    private volatile boolean stopped;
     private ScheduledFuture<?> timer;
-    private int timeout = 10;
+    private int attemptCount = 0;
+
+    @Setter
     private BiConsumer<MqttFixedHeader, T> handler;
+
+    // the three fields below are used for logging only
+    private final String ownerId;
+    private String originalMessageId;
+    private long totalWaitingTimeMillis;
+
     private T originalMessage;
 
+    void setOriginalMessage(T originalMessage) {
+        this.originalMessage = originalMessage;
+        var variableHeader = originalMessage.variableHeader();
+        if (variableHeader instanceof MqttMessageIdVariableHeader messageIdVariableHeader) {
+            originalMessageId = String.valueOf(messageIdVariableHeader.messageId());
+        } else if (variableHeader instanceof MqttPublishVariableHeader publishVariableHeader) {
+            originalMessageId = String.valueOf(publishVariableHeader.packetId());
+        } else {
+            originalMessageId = "N/A";
+        }
+    }
+
     void start(EventLoop eventLoop) {
         if (eventLoop == null) {
             throw new NullPointerException("eventLoop");
         }
-        if (this.handler == null) {
+        if (handler == null) {
             throw new NullPointerException("handler");
         }
-        this.timeout = 10;
-        this.startTimer(eventLoop);
+        log.debug("{}MessageID[{}] Starting retransmission handler", ownerId, originalMessageId);
+        startTimer(eventLoop);
     }
 
     private void startTimer(EventLoop eventLoop) {
-        if (stopped || pendingOperation.isCanceled()) {
+        if (stopped || pendingOperation.isCancelled()) {
             return;
         }
-        this.timer = eventLoop.schedule(() -> {
-            if (stopped || pendingOperation.isCanceled()) {
+
+        // Calculate the base delay using exponential backoff.
+        // For attemptCount == 0, delay = initial delay; for each subsequent attempt, the base delay doubles.
+        long baseDelay = config.initialDelayMillis() * (long) Math.pow(2, attemptCount);
+        // Apply jitter: random factor between (1 - jitterFactor) and (1 + jitterFactor).
+        double minFactor = 1.0 - config.jitterFactor();
+        double maxFactor = 1.0 + config.jitterFactor();
+        double randomFactor = config.jitterFactor() == 0 ? 1 : ThreadLocalRandom.current().nextDouble(minFactor, maxFactor);
+        long delayMillisWithJitter = (long) (baseDelay * randomFactor);
+        totalWaitingTimeMillis += delayMillisWithJitter;
+
+        timer = eventLoop.schedule(() -> {
+            if (stopped || pendingOperation.isCancelled()) {
                 return;
             }
-            this.timeout += 5;
-            boolean isDup = this.originalMessage.fixedHeader().isDup();
-            if (this.originalMessage.fixedHeader().messageType() == MqttMessageType.PUBLISH && this.originalMessage.fixedHeader().qosLevel() != MqttQoS.AT_MOST_ONCE) {
-                isDup = true;
+
+            attemptCount++;
+            if (attemptCount > config.maxAttempts()) {
+                log.debug(
+                        "{}MessageID[{}] Gave up after {} retransmission attempts; waited a total of {} ms without receiving acknowledgement",
+                        ownerId, originalMessageId, config.maxAttempts(), totalWaitingTimeMillis
+                );
+                stop();
+                pendingOperation.onMaxRetransmissionAttemptsReached();
+                return;
             }
-            MqttFixedHeader fixedHeader = new MqttFixedHeader(this.originalMessage.fixedHeader().messageType(), isDup, this.originalMessage.fixedHeader().qosLevel(), this.originalMessage.fixedHeader().isRetain(), this.originalMessage.fixedHeader().remainingLength());
-            handler.accept(fixedHeader, originalMessage);
+
+            log.debug("{}MessageID[{}] Retransmission attempt #{} out of {}", ownerId, originalMessageId, attemptCount, config.maxAttempts());
+
+            var originalFixedHeader = originalMessage.fixedHeader();
+            var newFixedHeader = new MqttFixedHeader(
+                    originalFixedHeader.messageType(),
+                    isDup(originalFixedHeader),
+                    originalFixedHeader.qosLevel(),
+                    originalFixedHeader.isRetain(),
+                    originalFixedHeader.remainingLength()
+            );
+            handler.accept(newFixedHeader, originalMessage);
             startTimer(eventLoop);
-        }, timeout, TimeUnit.SECONDS);
+        }, delayMillisWithJitter, TimeUnit.MILLISECONDS);
+    }
+
+    private static boolean isDup(MqttFixedHeader originalFixedHeader) {
+        return originalFixedHeader.isDup() || (originalFixedHeader.messageType() == MqttMessageType.PUBLISH && originalFixedHeader.qosLevel() != MqttQoS.AT_MOST_ONCE);
     }
 
     void stop() {
+        log.debug("{}MessageID[{}] Stopping retransmission handler", ownerId, originalMessageId);
         stopped = true;
-        if (this.timer != null) {
-            this.timer.cancel(true);
+        if (timer != null) {
+            timer.cancel(true);
         }
     }
 
-    void setHandle(BiConsumer<MqttFixedHeader, T> runnable) {
-        this.handler = runnable;
-    }
-
-    void setOriginalMessage(T originalMessage) {
-        this.originalMessage = originalMessage;
-    }
 }
diff --git a/netty-mqtt/src/test/java/org/thingsboard/mqtt/MqttClientTest.java b/netty-mqtt/src/test/java/org/thingsboard/mqtt/MqttClientTest.java
new file mode 100644
index 0000000000..1481b354ee
--- /dev/null
+++ b/netty-mqtt/src/test/java/org/thingsboard/mqtt/MqttClientTest.java
@@ -0,0 +1,210 @@
+/**
+ * Copyright © 2016-2025 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.mqtt;
+
+import com.google.common.util.concurrent.Futures;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.PooledByteBufAllocator;
+import io.netty.handler.codec.mqtt.MqttConnectReturnCode;
+import io.netty.handler.codec.mqtt.MqttMessageType;
+import io.netty.handler.codec.mqtt.MqttQoS;
+import io.netty.util.ResourceLeakDetector;
+import io.netty.util.concurrent.Future;
+import io.netty.util.concurrent.Promise;
+import lombok.extern.slf4j.Slf4j;
+import org.awaitility.Awaitility;
+import org.awaitility.core.ConditionTimeoutException;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.testcontainers.hivemq.HiveMQContainer;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+import org.testcontainers.utility.DockerImageName;
+import org.thingsboard.common.util.AbstractListeningExecutor;
+
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@Slf4j
+@Testcontainers
+class MqttClientTest {
+
+    final int randomPort = 0;
+
+    @Container
+    HiveMQContainer broker = new HiveMQContainer(DockerImageName.parse("hivemq/hivemq-ce").withTag("2025.2"));
+
+    MqttTestProxy proxy;
+
+    MqttClient client;
+
+    AbstractListeningExecutor handlerExecutor;
+
+    @BeforeAll
+    static void init() {
+        ResourceLeakDetector.setLevel(ResourceLeakDetector.Level.PARANOID);
+    }
+
+    @BeforeEach
+    void setup() {
+        handlerExecutor = new AbstractListeningExecutor() {
+            @Override
+            protected int getThreadPollSize() {
+                return 1;
+            }
+        };
+        handlerExecutor.init();
+    }
+
+    @AfterEach
+    void cleanup() {
+        if (client != null) {
+            client.disconnect();
+            client = null;
+        }
+        if (proxy != null) {
+            proxy.stop();
+            proxy = null;
+        }
+        handlerExecutor.destroy();
+        handlerExecutor = null;
+    }
+
+    @Test
+    void testConnectToBroker() {
+        // GIVEN
+        var clientConfig = new MqttClientConfig();
+        clientConfig.setOwnerId("Test[ConnectToBroker]");
+        clientConfig.setClientId("connect");
+
+        client = MqttClient.create(clientConfig, null, handlerExecutor);
+
+        // WHEN
+        Promise<MqttConnectResult> connectFuture = client.connect(broker.getHost(), broker.getMqttPort());
+
+        // THEN
+        assertThat(connectFuture).isNotNull();
+
+        Awaitility.await("waiting for client to connect")
+                .atMost(Duration.ofSeconds(10L))
+                .until(connectFuture::isDone);
+
+        assertThat(connectFuture.isSuccess()).isTrue();
+
+        MqttConnectResult actualConnectResult = connectFuture.getNow();
+        assertThat(actualConnectResult).isNotNull();
+        assertThat(actualConnectResult.isSuccess()).isTrue();
+        assertThat(actualConnectResult.getReturnCode()).isEqualTo(MqttConnectReturnCode.CONNECTION_ACCEPTED);
+
+        assertThat(client.isConnected()).isTrue();
+    }
+
+    @Test
+    void testDisconnectDueToKeepAliveIfNoActivity() {
+        // GIVEN
+        proxy = MqttTestProxy.builder()
+                .localPort(randomPort)
+                .brokerHost(broker.getHost())
+                .brokerPort(broker.getMqttPort())
+                .brokerToClientInterceptor(msg -> msg.fixedHeader().messageType() != MqttMessageType.PINGRESP) // drop all ping responses to simulate broker down
+                .build();
+
+        int idleTimeoutSeconds = 2;
+
+        var clientConfig = new MqttClientConfig();
+        clientConfig.setOwnerId("Test[KeepAliveDisconnect]");
+        clientConfig.setClientId("no-activity-disconnect");
+        clientConfig.setTimeoutSeconds(idleTimeoutSeconds);
+        clientConfig.setReconnect(false); // disable auto reconnect
+        client = MqttClient.create(clientConfig, null, handlerExecutor);
+
+        // WHEN-THEN
+        connect(broker.getHost(), proxy.getPort());
+
+        // no activity...
+
+        Awaitility.await("waiting for client to disconnect")
+                .pollDelay(Duration.ofSeconds(idleTimeoutSeconds * 2)) // 2 seconds to wait for the first idle event and then 2 seconds for scheduled disconnect to fire
+                .atMost(Duration.ofSeconds(10))
+                .untilAsserted(() -> assertThat(client.isConnected()).isFalse());
+    }
+
+    @Test
+    void testRetransmission() {
+        // GIVEN
+        proxy = MqttTestProxy.builder()
+                .localPort(randomPort)
+                .brokerHost(broker.getHost())
+                .brokerPort(broker.getMqttPort())
+                .brokerToClientInterceptor(msg -> msg.fixedHeader().messageType() != MqttMessageType.PUBACK) // drop all pubacks to allow retransmission to happen
+                .build();
+
+        // create client
+        var clientConfig = new MqttClientConfig();
+        clientConfig.setOwnerId("Test[Retransmission]");
+        clientConfig.setClientId("retransmission");
+        clientConfig.setRetransmissionConfig(new MqttClientConfig.RetransmissionConfig(1, 1000L, 0d));
+        client = MqttClient.create(clientConfig, null, handlerExecutor);
+
+        // connect to a broker
+        connect(broker.getHost(), proxy.getPort());
+
+        // subscribe to a topic
+        String topic = "test-topic";
+        List<ByteBuf> receivedMessages = Collections.synchronizedList(new ArrayList<>(2));
+        Future<Void> subscribeFuture = client.on(topic, (__, payload) -> {
+            receivedMessages.add(payload);
+            return Futures.immediateVoidFuture();
+        });
+        Awaitility.await("waiting for client to subscribe to a topic")
+                .atMost(Duration.ofSeconds(10L))
+                .until(subscribeFuture::isDone);
+
+        // WHEN
+        // publish a message
+        ByteBuf message = PooledByteBufAllocator.DEFAULT.buffer().writeBytes("test message".getBytes(StandardCharsets.UTF_8));
+        client.publish(topic, message, MqttQoS.AT_LEAST_ONCE);
+
+        // THEN
+        // wait enough time so that retransmission happens and stops
+        // if retransmission works incorrectly waiting 10 seconds allows for additional retransmissions to happen
+        try {
+            Awaitility.await("wait up to 10s, stop early if too many messages")
+                    .atMost(Duration.ofSeconds(10L))
+                    .pollInterval(Duration.ofMillis(100))
+                    .until(() -> receivedMessages.size() > 2);
+        } catch (ConditionTimeoutException __) {
+            // didn't exceed 2 messages
+        }
+
+        assertThat(receivedMessages).size().describedAs("incorrect number of messages received, expected 2 (original plus one retransmitted)").isEqualTo(2);
+    }
+
+    private void connect(String host, int port) {
+        Promise<MqttConnectResult> connectFuture = client.connect(host, port);
+        Awaitility.await("waiting for client to connect")
+                .atMost(Duration.ofSeconds(10L))
+                .until(connectFuture::isSuccess);
+    }
+
+}
diff --git a/netty-mqtt/src/test/java/org/thingsboard/mqtt/MqttPingHandlerTest.java b/netty-mqtt/src/test/java/org/thingsboard/mqtt/MqttPingHandlerTest.java
deleted file mode 100644
index 83e3b1c8d5..0000000000
--- a/netty-mqtt/src/test/java/org/thingsboard/mqtt/MqttPingHandlerTest.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/**
- * Copyright © 2016-2025 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.mqtt;
-
-import io.netty.channel.Channel;
-import io.netty.channel.ChannelFuture;
-import io.netty.channel.ChannelFutureListener;
-import io.netty.channel.ChannelHandlerContext;
-import io.netty.channel.DefaultEventLoop;
-import io.netty.handler.timeout.IdleStateEvent;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-
-import java.util.concurrent.TimeUnit;
-
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.after;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-class MqttPingHandlerTest {
-
-    static final int KEEP_ALIVE_SECONDS = 0;
-    static final int PROCESS_SEND_DISCONNECT_MSG_TIME_MS = 500;
-
-    MqttPingHandler mqttPingHandler;
-
-    @BeforeEach
-    void setUp() {
-        mqttPingHandler = new MqttPingHandler(KEEP_ALIVE_SECONDS);
-    }
-
-    @Test
-    void givenChannelReaderIdleState_whenNoPingResponse_thenDisconnectClient() throws Exception {
-        ChannelHandlerContext ctx = mock(ChannelHandlerContext.class);
-        Channel channel = mock(Channel.class);
-        when(ctx.channel()).thenReturn(channel);
-        when(channel.eventLoop()).thenReturn(new DefaultEventLoop());
-        ChannelFuture channelFuture = mock(ChannelFuture.class);
-        when(channel.writeAndFlush(any())).thenReturn(channelFuture);
-
-        mqttPingHandler.userEventTriggered(ctx, IdleStateEvent.FIRST_READER_IDLE_STATE_EVENT);
-        verify(
-                channelFuture,
-                after(TimeUnit.SECONDS.toMillis(KEEP_ALIVE_SECONDS) + PROCESS_SEND_DISCONNECT_MSG_TIME_MS)
-        ).addListener(eq(ChannelFutureListener.CLOSE));
-    }
-}
\ No newline at end of file
diff --git a/netty-mqtt/src/test/java/org/thingsboard/mqtt/MqttTestProxy.java b/netty-mqtt/src/test/java/org/thingsboard/mqtt/MqttTestProxy.java
new file mode 100644
index 0000000000..4a10fc3bfb
--- /dev/null
+++ b/netty-mqtt/src/test/java/org/thingsboard/mqtt/MqttTestProxy.java
@@ -0,0 +1,202 @@
+/**
+ * Copyright © 2016-2025 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.mqtt;
+
+import io.netty.bootstrap.Bootstrap;
+import io.netty.bootstrap.ServerBootstrap;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInitializer;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.SimpleChannelInboundHandler;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.SocketChannel;
+import io.netty.channel.socket.nio.NioServerSocketChannel;
+import io.netty.channel.socket.nio.NioSocketChannel;
+import io.netty.handler.codec.mqtt.MqttDecoder;
+import io.netty.handler.codec.mqtt.MqttEncoder;
+import io.netty.handler.codec.mqtt.MqttMessage;
+import io.netty.util.ReferenceCountUtil;
+import lombok.extern.slf4j.Slf4j;
+
+import java.net.InetSocketAddress;
+import java.util.function.Predicate;
+
+@Slf4j
+public class MqttTestProxy {
+
+    private final EventLoopGroup bossGroup;
+    private final EventLoopGroup workerGroup;
+
+    private Channel clientToProxyChannel;
+    private Channel proxyToBrokerChannel;
+
+    private final int assignedPort;
+
+    private boolean stopped;
+
+    private final Predicate<MqttMessage> brokerToClientInterceptor;
+
+    private MqttTestProxy(Builder builder) {
+        log.info("Starting MQTT proxy...");
+
+        brokerToClientInterceptor = builder.brokerToClientInterceptor != null ? builder.brokerToClientInterceptor : msg -> true;
+        bossGroup = new NioEventLoopGroup(1);
+        workerGroup = new NioEventLoopGroup(1);
+
+        ServerBootstrap proxyBootstrap = new ServerBootstrap();
+        proxyBootstrap.group(bossGroup, workerGroup)
+                .channel(NioServerSocketChannel.class)
+                .childHandler(new ChannelInitializer<SocketChannel>() {
+                    @Override
+                    protected void initChannel(SocketChannel channel) {
+                        clientToProxyChannel = channel;
+                        clientToProxyChannel.config().setAutoRead(false); // do not accept data before we connected to a broker
+
+                        connectToBroker(builder.brokerHost, builder.brokerPort).addListener(future -> {
+                            if (future.isSuccess()) {
+                                clientToProxyChannel.pipeline().addLast("mqttDecoder", new MqttDecoder());
+                                clientToProxyChannel.pipeline().addLast("mqttToBroker", new MqttRelayHandler(proxyToBrokerChannel, null));
+                                clientToProxyChannel.pipeline().addLast("mqttEncoder", MqttEncoder.INSTANCE);
+
+                                clientToProxyChannel.config().setAutoRead(true); // start accepting data for a client
+                            } else {
+                                log.error("Failed to connect to broker", future.cause());
+                                clientToProxyChannel.close();
+                            }
+                        });
+                    }
+                });
+
+        try {
+            Channel proxyChannel = proxyBootstrap.bind(builder.localPort).sync().channel();
+            assignedPort = ((InetSocketAddress) proxyChannel.localAddress()).getPort();
+        } catch (Exception e) {
+            log.error("Failed to start MQTT proxy", e);
+            throw new RuntimeException("Failed to start MQTT proxy", e);
+        }
+
+        log.info("MQTT proxy started on port {}", assignedPort);
+    }
+
+    private ChannelFuture connectToBroker(String brokerHost, int brokerPort) {
+        Bootstrap proxyToBrokerBootstrap = new Bootstrap();
+        proxyToBrokerBootstrap.group(workerGroup)
+                .channel(NioSocketChannel.class)
+                .handler(new ChannelInitializer<SocketChannel>() {
+                    @Override
+                    protected void initChannel(SocketChannel channel) {
+                        proxyToBrokerChannel = channel;
+                        proxyToBrokerChannel.pipeline().addLast(new MqttDecoder());
+                        proxyToBrokerChannel.pipeline().addLast("mqttToClient", new MqttRelayHandler(clientToProxyChannel, brokerToClientInterceptor));
+                        proxyToBrokerChannel.pipeline().addLast(MqttEncoder.INSTANCE);
+                    }
+                });
+        return proxyToBrokerBootstrap.connect(brokerHost, brokerPort);
+    }
+
+    private static class MqttRelayHandler extends SimpleChannelInboundHandler<MqttMessage> {
+
+        private final Channel targetChannel;
+        private final Predicate<MqttMessage> interceptor;
+
+        private MqttRelayHandler(Channel targetChannel, Predicate<MqttMessage> interceptor) {
+            this.targetChannel = targetChannel;
+            this.interceptor = interceptor;
+        }
+
+        @Override
+        protected void channelRead0(ChannelHandlerContext ctx, MqttMessage msg) {
+            log.debug("Received message: {}", msg.fixedHeader().messageType());
+            if (interceptor == null || interceptor.test(msg)) {
+                if (targetChannel.isActive()) {
+                    targetChannel.writeAndFlush(ReferenceCountUtil.retain(msg));
+                }
+            } else {
+                log.info("Dropping message: {}", msg.fixedHeader().messageType());
+            }
+        }
+
+    }
+
+    public void stop() {
+        if (stopped) {
+            log.info("MQTT proxy was already stopped");
+            return;
+        }
+
+        stopped = true;
+
+        log.info("Stopping MQTT proxy...");
+
+        if (clientToProxyChannel != null) {
+            clientToProxyChannel.close();
+        }
+        if (proxyToBrokerChannel != null) {
+            proxyToBrokerChannel.close();
+        }
+        if (bossGroup != null) {
+            bossGroup.shutdownGracefully();
+        }
+        if (workerGroup != null) {
+            workerGroup.shutdownGracefully();
+        }
+
+        log.info("MQTT proxy stopped");
+    }
+
+    public int getPort() {
+        return assignedPort;
+    }
+
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    public static class Builder {
+
+        private int localPort;
+        private String brokerHost;
+        private int brokerPort;
+        private Predicate<MqttMessage> brokerToClientInterceptor;
+
+        public Builder localPort(int localPort) {
+            this.localPort = localPort;
+            return this;
+        }
+
+        public Builder brokerHost(String brokerHost) {
+            this.brokerHost = brokerHost;
+            return this;
+        }
+
+        public Builder brokerPort(int brokerPort) {
+            this.brokerPort = brokerPort;
+            return this;
+        }
+
+        public Builder brokerToClientInterceptor(Predicate<MqttMessage> interceptor) {
+            this.brokerToClientInterceptor = interceptor;
+            return this;
+        }
+
+        public MqttTestProxy build() {
+            return new MqttTestProxy(this);
+        }
+
+    }
+}
diff --git a/netty-mqtt/src/test/java/org/thingsboard/mqtt/integration/MqttIntegrationTest.java b/netty-mqtt/src/test/java/org/thingsboard/mqtt/integration/MqttIntegrationTest.java
deleted file mode 100644
index db177c84b6..0000000000
--- a/netty-mqtt/src/test/java/org/thingsboard/mqtt/integration/MqttIntegrationTest.java
+++ /dev/null
@@ -1,151 +0,0 @@
-/**
- * Copyright © 2016-2025 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.mqtt.integration;
-
-import io.netty.buffer.Unpooled;
-import io.netty.channel.EventLoopGroup;
-import io.netty.channel.nio.NioEventLoopGroup;
-import io.netty.handler.codec.mqtt.MqttMessageType;
-import io.netty.handler.codec.mqtt.MqttQoS;
-import io.netty.util.concurrent.Future;
-import io.netty.util.concurrent.Promise;
-import lombok.extern.slf4j.Slf4j;
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.parallel.ResourceLock;
-import org.thingsboard.common.util.AbstractListeningExecutor;
-import org.thingsboard.mqtt.MqttClient;
-import org.thingsboard.mqtt.MqttClientConfig;
-import org.thingsboard.mqtt.MqttConnectResult;
-import org.thingsboard.mqtt.integration.server.MqttServer;
-
-import java.nio.charset.StandardCharsets;
-import java.util.List;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-
-@ResourceLock("port8885") // test MQTT server port
-@Slf4j
-public class MqttIntegrationTest {
-
-    static final String MQTT_HOST = "localhost";
-    static final int KEEPALIVE_TIMEOUT_SECONDS = 2;
-    static final long RECONNECT_DELAY_SECONDS = 10L;
-
-    EventLoopGroup eventLoopGroup;
-    MqttServer mqttServer;
-
-    MqttClient mqttClient;
-
-    AbstractListeningExecutor handlerExecutor;
-
-    @BeforeEach
-    public void init() throws Exception {
-        this.handlerExecutor = new AbstractListeningExecutor() {
-            @Override
-            protected int getThreadPollSize() {
-                return 4;
-            }
-        };
-        handlerExecutor.init();
-
-        this.eventLoopGroup = new NioEventLoopGroup();
-
-        this.mqttServer = new MqttServer();
-        this.mqttServer.init();
-    }
-
-    @AfterEach
-    public void destroy() throws InterruptedException {
-        if (this.mqttClient != null) {
-            this.mqttClient.disconnect();
-        }
-        if (this.mqttServer != null) {
-            this.mqttServer.shutdown();
-        }
-        if (this.eventLoopGroup != null) {
-            this.eventLoopGroup.shutdownGracefully(0, 0, TimeUnit.MILLISECONDS);
-        }
-        if (this.handlerExecutor != null) {
-            this.handlerExecutor.destroy();
-        }
-    }
-
-    @Test
-    public void givenActiveMqttClient_whenNoActivityForKeepAliveTimeout_thenDisconnectClient() throws Throwable {
-        //given
-        this.mqttClient = initClient();
-
-        log.warn("Sending publish messages...");
-        CountDownLatch latch = new CountDownLatch(3);
-        for (int i = 0; i < 3; i++) {
-            Thread.sleep(30);
-            Future<Void> pubFuture = publishMsg();
-            pubFuture.addListener(future -> latch.countDown());
-        }
-
-        log.warn("Waiting for messages acknowledgments...");
-        boolean awaitResult = latch.await(10, TimeUnit.SECONDS);
-        Assertions.assertTrue(awaitResult);
-        log.warn("Messages are delivered successfully...");
-
-        //when
-        log.warn("Starting idle period...");
-        Thread.sleep(5000);
-
-        //then
-        List<MqttMessageType> allReceivedEvents = this.mqttServer.getEventsFromClient();
-        long disconnectCount = allReceivedEvents.stream().filter(type -> type == MqttMessageType.DISCONNECT).count();
-
-        Assertions.assertEquals(1, disconnectCount);
-    }
-
-    private Future<Void> publishMsg() {
-        return this.mqttClient.publish(
-                "test/topic",
-                Unpooled.wrappedBuffer("payload".getBytes(StandardCharsets.UTF_8)),
-                MqttQoS.AT_MOST_ONCE);
-    }
-
-    private MqttClient initClient() throws Exception {
-        MqttClientConfig config = new MqttClientConfig();
-        config.setOwnerId("MqttIntegrationTest");
-        config.setTimeoutSeconds(KEEPALIVE_TIMEOUT_SECONDS);
-        config.setReconnectDelay(RECONNECT_DELAY_SECONDS);
-        MqttClient client = MqttClient.create(config, null, handlerExecutor);
-        client.setEventLoop(this.eventLoopGroup);
-        Promise<MqttConnectResult> connectFuture = client.connect(MQTT_HOST, this.mqttServer.getMqttPort());
-
-        String hostPort = MQTT_HOST + ":" + this.mqttServer.getMqttPort();
-        MqttConnectResult result;
-        try {
-            result = connectFuture.get(10, TimeUnit.SECONDS);
-        } catch (TimeoutException ex) {
-            connectFuture.cancel(true);
-            client.disconnect();
-            throw new RuntimeException(String.format("Failed to connect to MQTT server at %s.", hostPort));
-        }
-        if (!result.isSuccess()) {
-            connectFuture.cancel(true);
-            client.disconnect();
-            throw new RuntimeException(String.format("Failed to connect to MQTT server at %s. Result code is: %s", hostPort, result.getReturnCode()));
-        }
-        return client;
-    }
-}
\ No newline at end of file
diff --git a/netty-mqtt/src/test/java/org/thingsboard/mqtt/integration/server/MqttServer.java b/netty-mqtt/src/test/java/org/thingsboard/mqtt/integration/server/MqttServer.java
deleted file mode 100644
index ca4fb677dc..0000000000
--- a/netty-mqtt/src/test/java/org/thingsboard/mqtt/integration/server/MqttServer.java
+++ /dev/null
@@ -1,84 +0,0 @@
-/**
- * Copyright © 2016-2025 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.mqtt.integration.server;
-
-import io.netty.bootstrap.ServerBootstrap;
-import io.netty.channel.Channel;
-import io.netty.channel.ChannelInitializer;
-import io.netty.channel.ChannelOption;
-import io.netty.channel.ChannelPipeline;
-import io.netty.channel.EventLoopGroup;
-import io.netty.channel.nio.NioEventLoopGroup;
-import io.netty.channel.socket.SocketChannel;
-import io.netty.channel.socket.nio.NioServerSocketChannel;
-import io.netty.handler.codec.mqtt.MqttDecoder;
-import io.netty.handler.codec.mqtt.MqttEncoder;
-import io.netty.handler.codec.mqtt.MqttMessageType;
-import lombok.Getter;
-import lombok.extern.slf4j.Slf4j;
-
-import java.util.List;
-import java.util.concurrent.CopyOnWriteArrayList;
-
-@Slf4j
-public class MqttServer {
-
-    @Getter
-    private final List<MqttMessageType> eventsFromClient = new CopyOnWriteArrayList<>();
-    @Getter
-    private final int mqttPort = 8885;
-
-    private Channel serverChannel;
-    private EventLoopGroup bossGroup;
-    private EventLoopGroup workerGroup;
-
-    public void init() throws Exception {
-        log.info("Starting MQTT server on port {}...", mqttPort);
-        bossGroup = new NioEventLoopGroup();
-        workerGroup = new NioEventLoopGroup();
-        ServerBootstrap b = new ServerBootstrap();
-        b.group(bossGroup, workerGroup)
-                .channel(NioServerSocketChannel.class)
-                .childHandler(new ChannelInitializer<SocketChannel>() {
-                    @Override
-                    protected void initChannel(SocketChannel ch) throws Exception {
-                        ChannelPipeline pipeline = ch.pipeline();
-                        pipeline.addLast("decoder", new MqttDecoder(65536));
-                        pipeline.addLast("encoder", MqttEncoder.INSTANCE);
-
-                        MqttTransportHandler handler = new MqttTransportHandler(eventsFromClient);
-
-                        pipeline.addLast(handler);
-                        ch.closeFuture().addListener(handler);
-                    }
-                })
-                .childOption(ChannelOption.SO_KEEPALIVE, true);
-
-        serverChannel = b.bind(mqttPort).sync().channel();
-        log.info("Mqtt transport started!");
-    }
-
-    public void shutdown() throws InterruptedException {
-        log.info("Stopping MQTT transport!");
-        try {
-            serverChannel.close().sync();
-        } finally {
-            workerGroup.shutdownGracefully();
-            bossGroup.shutdownGracefully();
-        }
-        log.info("MQTT transport stopped!");
-    }
-}
diff --git a/netty-mqtt/src/test/java/org/thingsboard/mqtt/integration/server/MqttTransportHandler.java b/netty-mqtt/src/test/java/org/thingsboard/mqtt/integration/server/MqttTransportHandler.java
deleted file mode 100644
index 5c433d7069..0000000000
--- a/netty-mqtt/src/test/java/org/thingsboard/mqtt/integration/server/MqttTransportHandler.java
+++ /dev/null
@@ -1,141 +0,0 @@
-/**
- * Copyright © 2016-2025 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.mqtt.integration.server;
-
-import io.netty.channel.ChannelHandlerContext;
-import io.netty.channel.ChannelInboundHandlerAdapter;
-import io.netty.handler.codec.mqtt.MqttConnAckMessage;
-import io.netty.handler.codec.mqtt.MqttConnAckVariableHeader;
-import io.netty.handler.codec.mqtt.MqttConnectMessage;
-import io.netty.handler.codec.mqtt.MqttConnectReturnCode;
-import io.netty.handler.codec.mqtt.MqttFixedHeader;
-import io.netty.handler.codec.mqtt.MqttMessage;
-import io.netty.handler.codec.mqtt.MqttMessageIdVariableHeader;
-import io.netty.handler.codec.mqtt.MqttMessageType;
-import io.netty.handler.codec.mqtt.MqttPubAckMessage;
-import io.netty.handler.codec.mqtt.MqttPublishMessage;
-import io.netty.util.ReferenceCountUtil;
-import io.netty.util.concurrent.Future;
-import io.netty.util.concurrent.GenericFutureListener;
-import lombok.extern.slf4j.Slf4j;
-
-import java.util.List;
-import java.util.UUID;
-
-import static io.netty.handler.codec.mqtt.MqttMessageType.CONNACK;
-import static io.netty.handler.codec.mqtt.MqttMessageType.CONNECT;
-import static io.netty.handler.codec.mqtt.MqttMessageType.DISCONNECT;
-import static io.netty.handler.codec.mqtt.MqttMessageType.PINGREQ;
-import static io.netty.handler.codec.mqtt.MqttMessageType.PUBACK;
-import static io.netty.handler.codec.mqtt.MqttMessageType.PUBLISH;
-import static io.netty.handler.codec.mqtt.MqttQoS.AT_MOST_ONCE;
-
-@Slf4j
-public class MqttTransportHandler extends ChannelInboundHandlerAdapter implements GenericFutureListener<Future<? super Void>> {
-
-    private final List<MqttMessageType> eventsFromClient;
-    private final UUID sessionId;
-
-    MqttTransportHandler(List<MqttMessageType> eventsFromClient) {
-        this.sessionId = UUID.randomUUID();
-        this.eventsFromClient = eventsFromClient;
-    }
-
-    @Override
-    public void channelRead(ChannelHandlerContext ctx, Object msg) {
-        log.trace("[{}] Processing msg: {}", sessionId, msg);
-        try {
-            if (msg instanceof MqttMessage) {
-                MqttMessage message = (MqttMessage) msg;
-                if (message.decoderResult().isSuccess()) {
-                    processMqttMsg(ctx, message);
-                } else {
-                    log.error("[{}] Message decoding failed: {}", sessionId, message.decoderResult().cause().getMessage());
-                    ctx.close();
-                }
-            } else {
-                log.debug("[{}] Received non mqtt message: {}", sessionId, msg.getClass().getSimpleName());
-                ctx.close();
-            }
-        } finally {
-            ReferenceCountUtil.safeRelease(msg);
-        }
-    }
-
-    void processMqttMsg(ChannelHandlerContext ctx, MqttMessage msg) {
-        if (msg.fixedHeader() == null) {
-            ctx.close();
-            return;
-        }
-        switch (msg.fixedHeader().messageType()) {
-            case CONNECT:
-                eventsFromClient.add(CONNECT);
-                processConnect(ctx, (MqttConnectMessage) msg);
-                break;
-            case DISCONNECT:
-                eventsFromClient.add(DISCONNECT);
-                ctx.close();
-                break;
-            case PUBLISH:
-                // QoS 0 and 1 supported only here
-                eventsFromClient.add(PUBLISH);
-                MqttPublishMessage mqttPubMsg = (MqttPublishMessage) msg;
-                ack(ctx, mqttPubMsg.variableHeader().packetId());
-                break;
-            case PINGREQ:
-                // We will not handle PINGREQ and will not send any PINGRESP to simulate the MQTT server is down
-                eventsFromClient.add(PINGREQ);
-                break;
-            default:
-                break;
-        }
-    }
-
-    void processConnect(ChannelHandlerContext ctx, MqttConnectMessage msg) {
-        String userName = msg.payload().userName();
-        String clientId = msg.payload().clientIdentifier();
-
-        log.warn("[{}][{}] Processing connect msg for client: {}!", sessionId, userName, clientId);
-        ctx.writeAndFlush(createMqttConnAckMsg(msg));
-    }
-
-    private MqttConnAckMessage createMqttConnAckMsg(MqttConnectMessage msg) {
-        MqttFixedHeader mqttFixedHeader =
-                new MqttFixedHeader(CONNACK, false, AT_MOST_ONCE, false, 0);
-        MqttConnAckVariableHeader mqttConnAckVariableHeader =
-                new MqttConnAckVariableHeader(MqttConnectReturnCode.CONNECTION_ACCEPTED, !msg.variableHeader().isCleanSession());
-        return new MqttConnAckMessage(mqttFixedHeader, mqttConnAckVariableHeader);
-    }
-
-    private void ack(ChannelHandlerContext ctx, int msgId) {
-        if (msgId > 0) {
-            ctx.writeAndFlush(createMqttPubAckMsg(msgId));
-        }
-    }
-
-    public static MqttPubAckMessage createMqttPubAckMsg(int requestId) {
-        MqttFixedHeader mqttFixedHeader =
-                new MqttFixedHeader(PUBACK, false, AT_MOST_ONCE, false, 0);
-        MqttMessageIdVariableHeader mqttMsgIdVariableHeader =
-                MqttMessageIdVariableHeader.from(requestId);
-        return new MqttPubAckMessage(mqttFixedHeader, mqttMsgIdVariableHeader);
-    }
-
-    @Override
-    public void operationComplete(Future<? super Void> future) {
-        log.trace("[{}] Channel closed!", sessionId);
-    }
-}
diff --git a/netty-mqtt/src/test/resources/junit-platform.properties b/netty-mqtt/src/test/resources/junit-platform.properties
deleted file mode 100644
index f2ed301920..0000000000
--- a/netty-mqtt/src/test/resources/junit-platform.properties
+++ /dev/null
@@ -1,3 +0,0 @@
-junit.jupiter.execution.parallel.enabled = true
-junit.jupiter.execution.parallel.mode.default = concurrent
-junit.jupiter.execution.parallel.mode.classes.default = concurrent
diff --git a/pom.xml b/pom.xml
index 3f8631a17b..6082745758 100755
--- a/pom.xml
+++ b/pom.xml
@@ -1973,6 +1973,12 @@
                 <version>${testcontainers.version}</version>
                 <scope>test</scope>
             </dependency>
+            <dependency>
+                <groupId>org.testcontainers</groupId>
+                <artifactId>hivemq</artifactId>
+                <version>${testcontainers.version}</version>
+                <scope>test</scope>
+            </dependency>
             <dependency>
                 <groupId>org.springframework.data</groupId>
                 <artifactId>spring-data-redis</artifactId>
diff --git a/rule-engine/rule-engine-api/src/main/java/org/thingsboard/rule/engine/api/MqttClientSettings.java b/rule-engine/rule-engine-api/src/main/java/org/thingsboard/rule/engine/api/MqttClientSettings.java
new file mode 100644
index 0000000000..4ac05b57d0
--- /dev/null
+++ b/rule-engine/rule-engine-api/src/main/java/org/thingsboard/rule/engine/api/MqttClientSettings.java
@@ -0,0 +1,26 @@
+/**
+ * Copyright © 2016-2025 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.rule.engine.api;
+
+public interface MqttClientSettings {
+
+    int getRetransmissionMaxAttempts();
+
+    long getRetransmissionInitialDelayMillis();
+
+    double getRetransmissionJitterFactor();
+
+}
diff --git a/rule-engine/rule-engine-api/src/main/java/org/thingsboard/rule/engine/api/RuleEngineAlarmService.java b/rule-engine/rule-engine-api/src/main/java/org/thingsboard/rule/engine/api/RuleEngineAlarmService.java
index 20f2342ebe..48fda3b781 100644
--- a/rule-engine/rule-engine-api/src/main/java/org/thingsboard/rule/engine/api/RuleEngineAlarmService.java
+++ b/rule-engine/rule-engine-api/src/main/java/org/thingsboard/rule/engine/api/RuleEngineAlarmService.java
@@ -70,7 +70,7 @@ public interface RuleEngineAlarmService {
     AlarmApiCallResult unassignAlarm(TenantId tenantId, AlarmId alarmId, long assignTs);
 
     // Other API
-    Boolean deleteAlarm(TenantId tenantId, AlarmId alarmId);
+    boolean deleteAlarm(TenantId tenantId, AlarmId alarmId);
 
     ListenableFuture<Alarm> findAlarmByIdAsync(TenantId tenantId, AlarmId alarmId);
 
@@ -99,4 +99,5 @@ public interface RuleEngineAlarmService {
     PageData<AlarmData> findAlarmDataByQueryForEntities(TenantId tenantId, AlarmDataQuery query, Collection<EntityId> orderedEntityIds);
 
     PageData<EntitySubtype> findAlarmTypesByTenantId(TenantId tenantId, PageLink pageLink);
+
 }
diff --git a/rule-engine/rule-engine-api/src/main/java/org/thingsboard/rule/engine/api/TbContext.java b/rule-engine/rule-engine-api/src/main/java/org/thingsboard/rule/engine/api/TbContext.java
index b66c9e13d5..7989b8f9ce 100644
--- a/rule-engine/rule-engine-api/src/main/java/org/thingsboard/rule/engine/api/TbContext.java
+++ b/rule-engine/rule-engine-api/src/main/java/org/thingsboard/rule/engine/api/TbContext.java
@@ -416,4 +416,9 @@ public interface TbContext {
     EventService getEventService();
 
     AuditLogService getAuditLogService();
+
+    // Configuration parameters for the MQTT client that is used in the MQTT node and Azure IoT hub node
+
+    MqttClientSettings getMqttClientSettings();
+
 }
diff --git a/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/mqtt/TbMqttNode.java b/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/mqtt/TbMqttNode.java
index 4d99951e1a..28a9e1ff4b 100644
--- a/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/mqtt/TbMqttNode.java
+++ b/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/mqtt/TbMqttNode.java
@@ -26,6 +26,7 @@ import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.mqtt.MqttClient;
 import org.thingsboard.mqtt.MqttClientConfig;
 import org.thingsboard.mqtt.MqttConnectResult;
+import org.thingsboard.rule.engine.api.MqttClientSettings;
 import org.thingsboard.rule.engine.api.RuleNode;
 import org.thingsboard.rule.engine.api.TbContext;
 import org.thingsboard.rule.engine.api.TbNodeConfiguration;
@@ -126,6 +127,13 @@ public class TbMqttNode extends TbAbstractExternalNode {
         }
         config.setCleanSession(this.mqttNodeConfiguration.isCleanSession());
 
+        MqttClientSettings mqttClientSettings = ctx.getMqttClientSettings();
+        config.setRetransmissionConfig(new MqttClientConfig.RetransmissionConfig(
+                mqttClientSettings.getRetransmissionMaxAttempts(),
+                mqttClientSettings.getRetransmissionInitialDelayMillis(),
+                mqttClientSettings.getRetransmissionJitterFactor()
+        ));
+
         prepareMqttClientConfig(config);
         MqttClient client = getMqttClient(ctx, config);
         client.setEventLoop(ctx.getSharedEventLoop());
diff --git a/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/profile/AlarmRuleState.java b/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/profile/AlarmRuleState.java
index 81c8f8154c..a2a714a6df 100644
--- a/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/profile/AlarmRuleState.java
+++ b/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/profile/AlarmRuleState.java
@@ -88,12 +88,6 @@ class AlarmRuleState {
     }
 
     public boolean validateAttrUpdate(Set<AlarmConditionFilterKey> changedKeys) {
-        //If the attribute was updated, but no new telemetry arrived - we ignore this until new telemetry is there.
-        for (AlarmConditionFilterKey key : entityKeys) {
-            if (key.getType().equals(AlarmConditionKeyType.TIME_SERIES)) {
-                return false;
-            }
-        }
         for (AlarmConditionFilterKey key : changedKeys) {
             if (entityKeys.contains(key)) {
                 return true;
diff --git a/rule-engine/rule-engine-components/src/test/java/org/thingsboard/rule/engine/mqtt/TbMqttNodeTest.java b/rule-engine/rule-engine-components/src/test/java/org/thingsboard/rule/engine/mqtt/TbMqttNodeTest.java
index f6ccfbca6f..bf650af8bb 100644
--- a/rule-engine/rule-engine-components/src/test/java/org/thingsboard/rule/engine/mqtt/TbMqttNodeTest.java
+++ b/rule-engine/rule-engine-components/src/test/java/org/thingsboard/rule/engine/mqtt/TbMqttNodeTest.java
@@ -40,6 +40,7 @@ import org.thingsboard.mqtt.MqttClient;
 import org.thingsboard.mqtt.MqttClientConfig;
 import org.thingsboard.mqtt.MqttConnectResult;
 import org.thingsboard.rule.engine.AbstractRuleNodeUpgradeTest;
+import org.thingsboard.rule.engine.api.MqttClientSettings;
 import org.thingsboard.rule.engine.api.TbContext;
 import org.thingsboard.rule.engine.api.TbNode;
 import org.thingsboard.rule.engine.api.TbNodeConfiguration;
@@ -80,6 +81,7 @@ import static org.mockito.BDDMockito.spy;
 import static org.mockito.BDDMockito.then;
 import static org.mockito.BDDMockito.willAnswer;
 import static org.mockito.BDDMockito.willReturn;
+import static org.mockito.Mockito.lenient;
 
 @ExtendWith(MockitoExtension.class)
 public class TbMqttNodeTest extends AbstractRuleNodeUpgradeTest {
@@ -106,6 +108,22 @@ public class TbMqttNodeTest extends AbstractRuleNodeUpgradeTest {
     protected void setUp() {
         mqttNode = spy(new TbMqttNode());
         mqttNodeConfig = new TbMqttNodeConfiguration().defaultConfiguration();
+        lenient().when(ctxMock.getMqttClientSettings()).thenReturn(new MqttClientSettings() {
+            @Override
+            public int getRetransmissionMaxAttempts() {
+                return 3;
+            }
+
+            @Override
+            public long getRetransmissionInitialDelayMillis() {
+                return 5000L;
+            }
+
+            @Override
+            public double getRetransmissionJitterFactor() {
+                return 0.15;
+            }
+        });
     }
 
     @Test
diff --git a/rule-engine/rule-engine-components/src/test/java/org/thingsboard/rule/engine/profile/TbDeviceProfileNodeTest.java b/rule-engine/rule-engine-components/src/test/java/org/thingsboard/rule/engine/profile/TbDeviceProfileNodeTest.java
index 7ecb1b2ad8..5163e21c05 100644
--- a/rule-engine/rule-engine-components/src/test/java/org/thingsboard/rule/engine/profile/TbDeviceProfileNodeTest.java
+++ b/rule-engine/rule-engine-components/src/test/java/org/thingsboard/rule/engine/profile/TbDeviceProfileNodeTest.java
@@ -58,6 +58,8 @@ import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.data.id.DeviceProfileId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.kv.AttributeKvEntry;
+import org.thingsboard.server.common.data.kv.TsKvEntry;
+import org.thingsboard.server.common.data.kv.TsKvEntryAggWrapper;
 import org.thingsboard.server.common.data.msg.TbMsgType;
 import org.thingsboard.server.common.data.query.BooleanFilterPredicate;
 import org.thingsboard.server.common.data.query.DynamicValue;
@@ -65,6 +67,7 @@ import org.thingsboard.server.common.data.query.DynamicValueSourceType;
 import org.thingsboard.server.common.data.query.EntityKeyValueType;
 import org.thingsboard.server.common.data.query.FilterPredicateValue;
 import org.thingsboard.server.common.data.query.NumericFilterPredicate;
+import org.thingsboard.server.common.data.query.NumericFilterPredicate.NumericOperation;
 import org.thingsboard.server.common.msg.TbMsg;
 import org.thingsboard.server.common.msg.TbMsgDataType;
 import org.thingsboard.server.common.msg.TbMsgMetaData;
@@ -72,6 +75,7 @@ import org.thingsboard.server.dao.attributes.AttributesService;
 import org.thingsboard.server.dao.device.DeviceService;
 import org.thingsboard.server.dao.model.sql.AttributeKvCompositeKey;
 import org.thingsboard.server.dao.model.sql.AttributeKvEntity;
+import org.thingsboard.server.dao.model.sqlts.ts.TsKvEntity;
 import org.thingsboard.server.dao.timeseries.TimeseriesService;
 
 import java.math.BigDecimal;
@@ -81,15 +85,22 @@ import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
+import java.util.Set;
 import java.util.TreeMap;
 import java.util.UUID;
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Stream;
 
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.anySet;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
+import static org.thingsboard.server.common.data.device.profile.AlarmConditionKeyType.ATTRIBUTE;
+import static org.thingsboard.server.common.data.device.profile.AlarmConditionKeyType.TIME_SERIES;
+import static org.thingsboard.server.common.data.query.NumericFilterPredicate.NumericOperation.GREATER;
+import static org.thingsboard.server.common.data.query.NumericFilterPredicate.NumericOperation.LESS;
 
 @ExtendWith(MockitoExtension.class)
 public class TbDeviceProfileNodeTest extends AbstractRuleNodeUpgradeTest {
@@ -170,32 +181,16 @@ public class TbDeviceProfileNodeTest extends AbstractRuleNodeUpgradeTest {
         DeviceProfile deviceProfile = new DeviceProfile();
         DeviceProfileData deviceProfileData = new DeviceProfileData();
 
-        AlarmConditionFilter highTempFilter = new AlarmConditionFilter();
-        highTempFilter.setKey(new AlarmConditionFilterKey(AlarmConditionKeyType.TIME_SERIES, "temperature"));
-        highTempFilter.setValueType(EntityKeyValueType.NUMERIC);
-        NumericFilterPredicate highTemperaturePredicate = new NumericFilterPredicate();
-        highTemperaturePredicate.setOperation(NumericFilterPredicate.NumericOperation.GREATER);
-        highTemperaturePredicate.setValue(new FilterPredicateValue<>(30.0));
-        highTempFilter.setPredicate(highTemperaturePredicate);
-        AlarmCondition alarmCondition = new AlarmCondition();
-        alarmCondition.setCondition(Collections.singletonList(highTempFilter));
+        AlarmCondition alarmCreateCondition = getNumericAlarmCondition(TIME_SERIES, "temperature", GREATER, 30.0);
         AlarmRule alarmRule = new AlarmRule();
-        alarmRule.setCondition(alarmCondition);
+        alarmRule.setCondition(alarmCreateCondition);
         DeviceProfileAlarm dpa = new DeviceProfileAlarm();
         dpa.setId("highTemperatureAlarmID");
         dpa.setAlarmType("highTemperatureAlarm");
         dpa.setCreateRules(new TreeMap<>(Collections.singletonMap(AlarmSeverity.CRITICAL, alarmRule)));
 
-        AlarmConditionFilter lowTempFilter = new AlarmConditionFilter();
-        lowTempFilter.setKey(new AlarmConditionFilterKey(AlarmConditionKeyType.TIME_SERIES, "temperature"));
-        lowTempFilter.setValueType(EntityKeyValueType.NUMERIC);
-        NumericFilterPredicate lowTemperaturePredicate = new NumericFilterPredicate();
-        lowTemperaturePredicate.setOperation(NumericFilterPredicate.NumericOperation.LESS);
-        lowTemperaturePredicate.setValue(new FilterPredicateValue<>(10.0));
-        lowTempFilter.setPredicate(lowTemperaturePredicate);
         AlarmRule clearRule = new AlarmRule();
-        AlarmCondition clearCondition = new AlarmCondition();
-        clearCondition.setCondition(Collections.singletonList(lowTempFilter));
+        AlarmCondition clearCondition = getNumericAlarmCondition(TIME_SERIES, "temperature", LESS, 10.0);
         clearRule.setCondition(clearCondition);
         dpa.setClearRule(clearRule);
 
@@ -261,25 +256,11 @@ public class TbDeviceProfileNodeTest extends AbstractRuleNodeUpgradeTest {
         DeviceProfile deviceProfile = new DeviceProfile();
         DeviceProfileData deviceProfileData = new DeviceProfileData();
 
-        AlarmConditionFilter tempFilter = new AlarmConditionFilter();
-        tempFilter.setKey(new AlarmConditionFilterKey(AlarmConditionKeyType.TIME_SERIES, "temperature"));
-        tempFilter.setValueType(EntityKeyValueType.NUMERIC);
-        NumericFilterPredicate temperaturePredicate = new NumericFilterPredicate();
-        temperaturePredicate.setOperation(NumericFilterPredicate.NumericOperation.GREATER);
-        temperaturePredicate.setValue(new FilterPredicateValue<>(30.0));
-        tempFilter.setPredicate(temperaturePredicate);
-        AlarmCondition alarmTempCondition = new AlarmCondition();
-        alarmTempCondition.setCondition(Collections.singletonList(tempFilter));
+        AlarmCondition alarmTempCondition = getNumericAlarmCondition(TIME_SERIES, "temperature", GREATER, 30.0);
         AlarmRule alarmTempRule = new AlarmRule();
         alarmTempRule.setCondition(alarmTempCondition);
 
-        AlarmConditionFilter highTempFilter = new AlarmConditionFilter();
-        highTempFilter.setKey(new AlarmConditionFilterKey(AlarmConditionKeyType.TIME_SERIES, "temperature"));
-        highTempFilter.setValueType(EntityKeyValueType.NUMERIC);
-        NumericFilterPredicate highTemperaturePredicate = new NumericFilterPredicate();
-        highTemperaturePredicate.setOperation(NumericFilterPredicate.NumericOperation.GREATER);
-        highTemperaturePredicate.setValue(new FilterPredicateValue<>(50.0));
-        highTempFilter.setPredicate(highTemperaturePredicate);
+        AlarmConditionFilter highTempFilter = getAlarmConditionFilter(TIME_SERIES, "temperature", GREATER, 50.0);
         AlarmCondition alarmHighTempCondition = new AlarmCondition();
         alarmHighTempCondition.setCondition(Collections.singletonList(highTempFilter));
         AlarmRule alarmHighTempRule = new AlarmRule();
@@ -401,10 +382,10 @@ public class TbDeviceProfileNodeTest extends AbstractRuleNodeUpgradeTest {
         alarmEnabledFilter.setPredicate(alarmEnabledPredicate);
 
         AlarmConditionFilter temperatureFilter = new AlarmConditionFilter();
-        temperatureFilter.setKey(new AlarmConditionFilterKey(AlarmConditionKeyType.TIME_SERIES, "temperature"));
+        temperatureFilter.setKey(new AlarmConditionFilterKey(TIME_SERIES, "temperature"));
         temperatureFilter.setValueType(EntityKeyValueType.NUMERIC);
         NumericFilterPredicate temperaturePredicate = new NumericFilterPredicate();
-        temperaturePredicate.setOperation(NumericFilterPredicate.NumericOperation.GREATER);
+        temperaturePredicate.setOperation(GREATER);
         temperaturePredicate.setValue(new FilterPredicateValue<>(20.0, null, null));
         temperatureFilter.setPredicate(temperaturePredicate);
 
@@ -494,10 +475,10 @@ public class TbDeviceProfileNodeTest extends AbstractRuleNodeUpgradeTest {
         alarmEnabledFilter.setPredicate(alarmEnabledPredicate);
 
         AlarmConditionFilter temperatureFilter = new AlarmConditionFilter();
-        temperatureFilter.setKey(new AlarmConditionFilterKey(AlarmConditionKeyType.TIME_SERIES, "temperature"));
+        temperatureFilter.setKey(new AlarmConditionFilterKey(TIME_SERIES, "temperature"));
         temperatureFilter.setValueType(EntityKeyValueType.NUMERIC);
         NumericFilterPredicate temperaturePredicate = new NumericFilterPredicate();
-        temperaturePredicate.setOperation(NumericFilterPredicate.NumericOperation.GREATER);
+        temperaturePredicate.setOperation(GREATER);
         temperaturePredicate.setValue(new FilterPredicateValue<>(20.0, null, null));
         temperatureFilter.setPredicate(temperaturePredicate);
 
@@ -576,10 +557,10 @@ public class TbDeviceProfileNodeTest extends AbstractRuleNodeUpgradeTest {
                 Futures.immediateFuture(Collections.singletonList(entry));
 
         AlarmConditionFilter highTempFilter = new AlarmConditionFilter();
-        highTempFilter.setKey(new AlarmConditionFilterKey(AlarmConditionKeyType.TIME_SERIES, "temperature"));
+        highTempFilter.setKey(new AlarmConditionFilterKey(TIME_SERIES, "temperature"));
         highTempFilter.setValueType(EntityKeyValueType.NUMERIC);
         NumericFilterPredicate highTemperaturePredicate = new NumericFilterPredicate();
-        highTemperaturePredicate.setOperation(NumericFilterPredicate.NumericOperation.GREATER);
+        highTemperaturePredicate.setOperation(GREATER);
         highTemperaturePredicate.setValue(new FilterPredicateValue<>(
                 0.0,
                 null,
@@ -670,10 +651,10 @@ public class TbDeviceProfileNodeTest extends AbstractRuleNodeUpgradeTest {
                 Futures.immediateFuture(Arrays.asList(entry, alarmDelayAttributeKvEntry));
 
         AlarmConditionFilter highTempFilter = new AlarmConditionFilter();
-        highTempFilter.setKey(new AlarmConditionFilterKey(AlarmConditionKeyType.TIME_SERIES, "temperature"));
+        highTempFilter.setKey(new AlarmConditionFilterKey(TIME_SERIES, "temperature"));
         highTempFilter.setValueType(EntityKeyValueType.NUMERIC);
         NumericFilterPredicate highTemperaturePredicate = new NumericFilterPredicate();
-        highTemperaturePredicate.setOperation(NumericFilterPredicate.NumericOperation.GREATER);
+        highTemperaturePredicate.setOperation(GREATER);
         highTemperaturePredicate.setValue(new FilterPredicateValue<>(
                 0.0,
                 null,
@@ -805,10 +786,10 @@ public class TbDeviceProfileNodeTest extends AbstractRuleNodeUpgradeTest {
                 Futures.immediateFuture(Optional.empty());
 
         AlarmConditionFilter highTempFilter = new AlarmConditionFilter();
-        highTempFilter.setKey(new AlarmConditionFilterKey(AlarmConditionKeyType.TIME_SERIES, "temperature"));
+        highTempFilter.setKey(new AlarmConditionFilterKey(TIME_SERIES, "temperature"));
         highTempFilter.setValueType(EntityKeyValueType.NUMERIC);
         NumericFilterPredicate highTemperaturePredicate = new NumericFilterPredicate();
-        highTemperaturePredicate.setOperation(NumericFilterPredicate.NumericOperation.GREATER);
+        highTemperaturePredicate.setOperation(GREATER);
         highTemperaturePredicate.setValue(new FilterPredicateValue<>(
                 0.0,
                 null,
@@ -937,10 +918,10 @@ public class TbDeviceProfileNodeTest extends AbstractRuleNodeUpgradeTest {
                 Futures.immediateFuture(Arrays.asList(entry, alarmDelayAttributeKvEntry));
 
         AlarmConditionFilter highTempFilter = new AlarmConditionFilter();
-        highTempFilter.setKey(new AlarmConditionFilterKey(AlarmConditionKeyType.TIME_SERIES, "temperature"));
+        highTempFilter.setKey(new AlarmConditionFilterKey(TIME_SERIES, "temperature"));
         highTempFilter.setValueType(EntityKeyValueType.NUMERIC);
         NumericFilterPredicate highTemperaturePredicate = new NumericFilterPredicate();
-        highTemperaturePredicate.setOperation(NumericFilterPredicate.NumericOperation.GREATER);
+        highTemperaturePredicate.setOperation(GREATER);
         highTemperaturePredicate.setValue(new FilterPredicateValue<>(
                 0.0,
                 null,
@@ -1065,10 +1046,10 @@ public class TbDeviceProfileNodeTest extends AbstractRuleNodeUpgradeTest {
                 Futures.immediateFuture(Optional.empty());
 
         AlarmConditionFilter highTempFilter = new AlarmConditionFilter();
-        highTempFilter.setKey(new AlarmConditionFilterKey(AlarmConditionKeyType.TIME_SERIES, "temperature"));
+        highTempFilter.setKey(new AlarmConditionFilterKey(TIME_SERIES, "temperature"));
         highTempFilter.setValueType(EntityKeyValueType.NUMERIC);
         NumericFilterPredicate highTemperaturePredicate = new NumericFilterPredicate();
-        highTemperaturePredicate.setOperation(NumericFilterPredicate.NumericOperation.GREATER);
+        highTemperaturePredicate.setOperation(GREATER);
         highTemperaturePredicate.setValue(new FilterPredicateValue<>(
                 0.0,
                 null,
@@ -1182,10 +1163,10 @@ public class TbDeviceProfileNodeTest extends AbstractRuleNodeUpgradeTest {
                 Futures.immediateFuture(Collections.singletonList(entry));
 
         AlarmConditionFilter highTempFilter = new AlarmConditionFilter();
-        highTempFilter.setKey(new AlarmConditionFilterKey(AlarmConditionKeyType.TIME_SERIES, "temperature"));
+        highTempFilter.setKey(new AlarmConditionFilterKey(TIME_SERIES, "temperature"));
         highTempFilter.setValueType(EntityKeyValueType.NUMERIC);
         NumericFilterPredicate highTemperaturePredicate = new NumericFilterPredicate();
-        highTemperaturePredicate.setOperation(NumericFilterPredicate.NumericOperation.GREATER);
+        highTemperaturePredicate.setOperation(GREATER);
         highTemperaturePredicate.setValue(new FilterPredicateValue<>(
                 0.0,
                 null,
@@ -1299,10 +1280,10 @@ public class TbDeviceProfileNodeTest extends AbstractRuleNodeUpgradeTest {
                 Futures.immediateFuture(Collections.singletonList(entry));
 
         AlarmConditionFilter highTempFilter = new AlarmConditionFilter();
-        highTempFilter.setKey(new AlarmConditionFilterKey(AlarmConditionKeyType.TIME_SERIES, "temperature"));
+        highTempFilter.setKey(new AlarmConditionFilterKey(TIME_SERIES, "temperature"));
         highTempFilter.setValueType(EntityKeyValueType.NUMERIC);
         NumericFilterPredicate highTemperaturePredicate = new NumericFilterPredicate();
-        highTemperaturePredicate.setOperation(NumericFilterPredicate.NumericOperation.GREATER);
+        highTemperaturePredicate.setOperation(GREATER);
         highTemperaturePredicate.setValue(new FilterPredicateValue<>(
                 0.0,
                 null,
@@ -1395,10 +1376,10 @@ public class TbDeviceProfileNodeTest extends AbstractRuleNodeUpgradeTest {
                 Futures.immediateFuture(Collections.singletonList(entryActiveSchedule));
 
         AlarmConditionFilter highTempFilter = new AlarmConditionFilter();
-        highTempFilter.setKey(new AlarmConditionFilterKey(AlarmConditionKeyType.TIME_SERIES, "temperature"));
+        highTempFilter.setKey(new AlarmConditionFilterKey(TIME_SERIES, "temperature"));
         highTempFilter.setValueType(EntityKeyValueType.NUMERIC);
         NumericFilterPredicate highTemperaturePredicate = new NumericFilterPredicate();
-        highTemperaturePredicate.setOperation(NumericFilterPredicate.NumericOperation.GREATER);
+        highTemperaturePredicate.setOperation(GREATER);
         highTemperaturePredicate.setValue(new FilterPredicateValue<>(
                 0.0,
                 null,
@@ -1492,10 +1473,10 @@ public class TbDeviceProfileNodeTest extends AbstractRuleNodeUpgradeTest {
                 Futures.immediateFuture(Collections.singletonList(entryInactiveSchedule));
 
         AlarmConditionFilter highTempFilter = new AlarmConditionFilter();
-        highTempFilter.setKey(new AlarmConditionFilterKey(AlarmConditionKeyType.TIME_SERIES, "temperature"));
+        highTempFilter.setKey(new AlarmConditionFilterKey(TIME_SERIES, "temperature"));
         highTempFilter.setValueType(EntityKeyValueType.NUMERIC);
         NumericFilterPredicate highTemperaturePredicate = new NumericFilterPredicate();
-        highTemperaturePredicate.setOperation(NumericFilterPredicate.NumericOperation.GREATER);
+        highTemperaturePredicate.setOperation(GREATER);
         highTemperaturePredicate.setValue(new FilterPredicateValue<>(
                 0.0,
                 null,
@@ -1593,10 +1574,10 @@ public class TbDeviceProfileNodeTest extends AbstractRuleNodeUpgradeTest {
                 Futures.immediateFuture(Optional.of(entry));
 
         AlarmConditionFilter lowTempFilter = new AlarmConditionFilter();
-        lowTempFilter.setKey(new AlarmConditionFilterKey(AlarmConditionKeyType.TIME_SERIES, "temperature"));
+        lowTempFilter.setKey(new AlarmConditionFilterKey(TIME_SERIES, "temperature"));
         lowTempFilter.setValueType(EntityKeyValueType.NUMERIC);
         NumericFilterPredicate lowTempPredicate = new NumericFilterPredicate();
-        lowTempPredicate.setOperation(NumericFilterPredicate.NumericOperation.LESS);
+        lowTempPredicate.setOperation(LESS);
         lowTempPredicate.setValue(
                 new FilterPredicateValue<>(
                         20.0,
@@ -1679,10 +1660,10 @@ public class TbDeviceProfileNodeTest extends AbstractRuleNodeUpgradeTest {
                 Futures.immediateFuture(Optional.of(entry));
 
         AlarmConditionFilter lowTempFilter = new AlarmConditionFilter();
-        lowTempFilter.setKey(new AlarmConditionFilterKey(AlarmConditionKeyType.TIME_SERIES, "temperature"));
+        lowTempFilter.setKey(new AlarmConditionFilterKey(TIME_SERIES, "temperature"));
         lowTempFilter.setValueType(EntityKeyValueType.NUMERIC);
         NumericFilterPredicate lowTempPredicate = new NumericFilterPredicate();
-        lowTempPredicate.setOperation(NumericFilterPredicate.NumericOperation.LESS);
+        lowTempPredicate.setOperation(LESS);
         lowTempPredicate.setValue(
                 new FilterPredicateValue<>(
                         32.0,
@@ -1769,10 +1750,10 @@ public class TbDeviceProfileNodeTest extends AbstractRuleNodeUpgradeTest {
                 Futures.immediateFuture(Optional.of(entry));
 
         AlarmConditionFilter lowTempFilter = new AlarmConditionFilter();
-        lowTempFilter.setKey(new AlarmConditionFilterKey(AlarmConditionKeyType.TIME_SERIES, "temperature"));
+        lowTempFilter.setKey(new AlarmConditionFilterKey(TIME_SERIES, "temperature"));
         lowTempFilter.setValueType(EntityKeyValueType.NUMERIC);
         NumericFilterPredicate lowTempPredicate = new NumericFilterPredicate();
-        lowTempPredicate.setOperation(NumericFilterPredicate.NumericOperation.GREATER);
+        lowTempPredicate.setOperation(GREATER);
         lowTempPredicate.setValue(
                 new FilterPredicateValue<>(
                         0.0,
@@ -1865,10 +1846,10 @@ public class TbDeviceProfileNodeTest extends AbstractRuleNodeUpgradeTest {
                 Futures.immediateFuture(Optional.of(entry));
 
         AlarmConditionFilter lowTempFilter = new AlarmConditionFilter();
-        lowTempFilter.setKey(new AlarmConditionFilterKey(AlarmConditionKeyType.TIME_SERIES, "temperature"));
+        lowTempFilter.setKey(new AlarmConditionFilterKey(TIME_SERIES, "temperature"));
         lowTempFilter.setValueType(EntityKeyValueType.NUMERIC);
         NumericFilterPredicate lowTempPredicate = new NumericFilterPredicate();
-        lowTempPredicate.setOperation(NumericFilterPredicate.NumericOperation.GREATER);
+        lowTempPredicate.setOperation(GREATER);
         lowTempPredicate.setValue(
                 new FilterPredicateValue<>(
                         0.0,
@@ -1942,6 +1923,10 @@ public class TbDeviceProfileNodeTest extends AbstractRuleNodeUpgradeTest {
     }
 
     private void registerCreateAlarmMock(AlarmApiCallResult a, boolean created) {
+        registerCreateAlarmMock(a, created, false);
+    }
+
+    private void registerCreateAlarmMock(AlarmApiCallResult a, boolean created, boolean cleared) {
         when(a).thenAnswer(invocationOnMock -> {
             AlarmInfo alarm = new AlarmInfo(new Alarm(new AlarmId(UUID.randomUUID())));
             AlarmModificationRequest request = invocationOnMock.getArgument(0);
@@ -1950,6 +1935,7 @@ public class TbDeviceProfileNodeTest extends AbstractRuleNodeUpgradeTest {
                     .successful(true)
                     .created(created)
                     .modified(true)
+                    .cleared(cleared)
                     .alarm(alarm)
                     .build();
         });
@@ -1981,6 +1967,100 @@ public class TbDeviceProfileNodeTest extends AbstractRuleNodeUpgradeTest {
 
     }
 
+    @Test
+    public void testAlarmCreateWithAttrAndTsCondition() throws Exception {
+        init();
+
+        DeviceProfile deviceProfile = new DeviceProfile();
+        DeviceProfileData deviceProfileData = new DeviceProfileData();
+
+        AlarmConditionFilter filter = getAlarmConditionFilter(TIME_SERIES, "temperature", GREATER, 30.0);
+        AlarmConditionFilter filter2 = getAlarmConditionFilter(ATTRIBUTE, "battery", LESS, 10.0);
+        AlarmCondition alarmCondition = new AlarmCondition();
+        alarmCondition.setCondition(List.of(filter, filter2));
+        AlarmRule createRule = new AlarmRule();
+        createRule.setCondition(alarmCondition);
+
+        AlarmConditionFilter filter3 = getAlarmConditionFilter(TIME_SERIES, "temperature", LESS, 10.0);
+        AlarmConditionFilter filter4 = getAlarmConditionFilter(ATTRIBUTE, "battery", GREATER, 50.0);
+        AlarmCondition clearCondition = new AlarmCondition();
+        clearCondition.setCondition(List.of(filter3, filter4));
+        AlarmRule clearRule = new AlarmRule();
+        clearRule.setCondition(clearCondition);
+
+        DeviceProfileAlarm dpa = new DeviceProfileAlarm();
+        dpa.setId("highTemperatureAlarmID");
+        dpa.setAlarmType("highTemperatureAlarm");
+        dpa.setCreateRules(new TreeMap<>(Collections.singletonMap(AlarmSeverity.CRITICAL, createRule)));
+        dpa.setClearRule(clearRule);
+
+        deviceProfileData.setAlarms(Collections.singletonList(dpa));
+        deviceProfile.setProfileData(deviceProfileData);
+
+        ListenableFuture<List<TsKvEntry>> tsKvList =
+                Futures.immediateFuture(Collections.singletonList(getTsKvEntry("temperature", 35L)));
+        ListenableFuture<List<AttributeKvEntry>> attrList =
+                Futures.immediateFuture(Collections.emptyList());
+
+        Mockito.when(cache.get(tenantId, deviceId)).thenReturn(deviceProfile);
+        Mockito.when(timeseriesService.findLatest(tenantId, deviceId, Collections.singleton("temperature")))
+                .thenReturn(tsKvList);
+        Mockito.when(attributesService.find(eq(tenantId), eq(deviceId), any(), anySet()))
+                .thenReturn(attrList);
+        Mockito.when(alarmService.findLatestActiveByOriginatorAndType(tenantId, deviceId, "highTemperatureAlarm")).thenReturn(null);
+        registerCreateAlarmMock(alarmService.createAlarm(any()), true);
+
+        TbMsg theMsg = TbMsg.newMsg()
+                .type(TbMsgType.ALARM)
+                .originator(deviceId)
+                .copyMetaData(TbMsgMetaData.EMPTY)
+                .data(TbMsg.EMPTY_STRING)
+                .build();
+        when(ctx.newMsg(any(), any(TbMsgType.class), any(), any(), any(), Mockito.anyString())).thenReturn(theMsg);
+
+        // send attribute
+        ObjectNode data = JacksonUtil.newObjectNode();
+        data.put("battery", 8);
+        TbMsg msg = TbMsg.newMsg()
+                .type(TbMsgType.POST_ATTRIBUTES_REQUEST)
+                .originator(deviceId)
+                .copyMetaData(TbMsgMetaData.EMPTY)
+                .dataType(TbMsgDataType.JSON)
+                .data(JacksonUtil.toString(data))
+                .build();
+        node.onMsg(ctx, msg);
+        verify(ctx).tellSuccess(msg);
+        verify(ctx).enqueueForTellNext(theMsg, "Alarm Created");
+        verify(ctx, Mockito.never()).tellFailure(Mockito.any(), Mockito.any());
+    }
+
+    private TsKvEntry getTsKvEntry(String key, Long value) {
+        TsKvEntity tsKv = new TsKvEntity();
+        tsKv.setKey(10);
+        tsKv.setLongValue(value);
+        tsKv.setStrKey(key);
+        tsKv.setTs(System.currentTimeMillis());
+        return tsKv.toData();
+    }
+
+    private AlarmCondition getNumericAlarmCondition(AlarmConditionKeyType alarmConditionKeyType, String key, NumericOperation operation, Double value) {
+        AlarmConditionFilter filter = getAlarmConditionFilter(alarmConditionKeyType, key, operation, value);
+        AlarmCondition alarmCondition = new AlarmCondition();
+        alarmCondition.setCondition(Collections.singletonList(filter));
+        return alarmCondition;
+    }
+
+    private AlarmConditionFilter getAlarmConditionFilter(AlarmConditionKeyType alarmConditionKeyType, String key, NumericOperation operation, Double value) {
+        AlarmConditionFilter filter = new AlarmConditionFilter();
+        filter.setKey(new AlarmConditionFilterKey(alarmConditionKeyType, key));
+        filter.setValueType(EntityKeyValueType.NUMERIC);
+        NumericFilterPredicate highTemperaturePredicate = new NumericFilterPredicate();
+        highTemperaturePredicate.setOperation(operation);
+        highTemperaturePredicate.setValue(new FilterPredicateValue<>(value));
+        filter.setPredicate(highTemperaturePredicate);
+        return filter;
+    }
+
     @Override
     protected TbNode getTestNode() {
         return node;
diff --git a/transport/coap/src/main/resources/tb-coap-transport.yml b/transport/coap/src/main/resources/tb-coap-transport.yml
index f60a6bd47e..0c5d160625 100644
--- a/transport/coap/src/main/resources/tb-coap-transport.yml
+++ b/transport/coap/src/main/resources/tb-coap-transport.yml
@@ -310,6 +310,11 @@ queue:
       sasl.config: "${TB_QUEUE_KAFKA_CONFLUENT_SASL_JAAS_CONFIG:org.apache.kafka.common.security.plain.PlainLoginModule required username=\"CLUSTER_API_KEY\" password=\"CLUSTER_API_SECRET\";}"
       # Protocol used to communicate with brokers. Valid values are: PLAINTEXT, SSL, SASL_PLAINTEXT, SASL_SSL
       security.protocol: "${TB_QUEUE_KAFKA_CONFLUENT_SECURITY_PROTOCOL:SASL_SSL}"
+    # If you override any default Kafka topic name using environment variables, you must also specify the related consumer properties
+    # for the new topic in `consumer-properties-per-topic-inline`. Otherwise, the topic will not inherit its expected configuration (e.g., max.poll.records, timeouts, etc).
+    # Format: "topic1:key1=value1,key2=value2;topic2:key=value"
+    # Example: "tb_core_modified.notifications:max.poll.records=10;tb_edge_modified:max.poll.records=10,enable.auto.commit=true"
+    consumer-properties-per-topic-inline: "${TB_QUEUE_KAFKA_CONSUMER_PROPERTIES_PER_TOPIC_INLINE:}"
     other-inline: "${TB_QUEUE_KAFKA_OTHER_PROPERTIES:}" # In this section you can specify custom parameters (semicolon separated) for Kafka consumer/producer/admin # Example "metrics.recording.level:INFO;metrics.sample.window.ms:30000"
     other: # DEPRECATED. In this section you can specify custom parameters for Kafka consumer/producer and expose the env variables to configure outside
     #  - key: "request.timeout.ms" # refer to https://docs.confluent.io/platform/current/installation/configuration/producer-configs.html#producerconfigs_request.timeout.ms
diff --git a/transport/http/src/main/resources/tb-http-transport.yml b/transport/http/src/main/resources/tb-http-transport.yml
index c921f9f9ae..81f4719e45 100644
--- a/transport/http/src/main/resources/tb-http-transport.yml
+++ b/transport/http/src/main/resources/tb-http-transport.yml
@@ -259,6 +259,11 @@ queue:
       sasl.config: "${TB_QUEUE_KAFKA_CONFLUENT_SASL_JAAS_CONFIG:org.apache.kafka.common.security.plain.PlainLoginModule required username=\"CLUSTER_API_KEY\" password=\"CLUSTER_API_SECRET\";}"
       # Protocol used to communicate with brokers. Valid values are: PLAINTEXT, SSL, SASL_PLAINTEXT, SASL_SSL
       security.protocol: "${TB_QUEUE_KAFKA_CONFLUENT_SECURITY_PROTOCOL:SASL_SSL}"
+    # If you override any default Kafka topic name using environment variables, you must also specify the related consumer properties
+    # for the new topic in `consumer-properties-per-topic-inline`. Otherwise, the topic will not inherit its expected configuration (e.g., max.poll.records, timeouts, etc).
+    # Format: "topic1:key1=value1,key2=value2;topic2:key=value"
+    # Example: "tb_core_modified.notifications:max.poll.records=10;tb_edge_modified:max.poll.records=10,enable.auto.commit=true"
+    consumer-properties-per-topic-inline: "${TB_QUEUE_KAFKA_CONSUMER_PROPERTIES_PER_TOPIC_INLINE:}"
     other-inline: "${TB_QUEUE_KAFKA_OTHER_PROPERTIES:}" # In this section you can specify custom parameters (semicolon separated) for Kafka consumer/producer/admin # Example "metrics.recording.level:INFO;metrics.sample.window.ms:30000"
     other: # DEPRECATED. In this section you can specify custom parameters for Kafka consumer/producer and expose the env variables to configure outside
     #  - key: "request.timeout.ms" # refer to https://docs.confluent.io/platform/current/installation/configuration/producer-configs.html#producerconfigs_request.timeout.ms
diff --git a/transport/lwm2m/src/main/resources/tb-lwm2m-transport.yml b/transport/lwm2m/src/main/resources/tb-lwm2m-transport.yml
index 85e865e60e..2c62a35dbb 100644
--- a/transport/lwm2m/src/main/resources/tb-lwm2m-transport.yml
+++ b/transport/lwm2m/src/main/resources/tb-lwm2m-transport.yml
@@ -360,6 +360,11 @@ queue:
       sasl.config: "${TB_QUEUE_KAFKA_CONFLUENT_SASL_JAAS_CONFIG:org.apache.kafka.common.security.plain.PlainLoginModule required username=\"CLUSTER_API_KEY\" password=\"CLUSTER_API_SECRET\";}"
       # Protocol used to communicate with brokers. Valid values are: PLAINTEXT, SSL, SASL_PLAINTEXT, SASL_SSL
       security.protocol: "${TB_QUEUE_KAFKA_CONFLUENT_SECURITY_PROTOCOL:SASL_SSL}"
+    # If you override any default Kafka topic name using environment variables, you must also specify the related consumer properties
+    # for the new topic in `consumer-properties-per-topic-inline`. Otherwise, the topic will not inherit its expected configuration (e.g., max.poll.records, timeouts, etc).
+    # Format: "topic1:key1=value1,key2=value2;topic2:key=value"
+    # Example: "tb_core_modified.notifications:max.poll.records=10;tb_edge_modified:max.poll.records=10,enable.auto.commit=true"
+    consumer-properties-per-topic-inline: "${TB_QUEUE_KAFKA_CONSUMER_PROPERTIES_PER_TOPIC_INLINE:}"
     other-inline: "${TB_QUEUE_KAFKA_OTHER_PROPERTIES:}" # In this section you can specify custom parameters (semicolon separated) for Kafka consumer/producer/admin # Example "metrics.recording.level:INFO;metrics.sample.window.ms:30000"
     other: # DEPRECATED. In this section you can specify custom parameters for Kafka consumer/producer and expose the env variables to configure outside
     #  - key: "request.timeout.ms" # refer to https://docs.confluent.io/platform/current/installation/configuration/producer-configs.html#producerconfigs_request.timeout.ms
diff --git a/transport/mqtt/src/main/resources/tb-mqtt-transport.yml b/transport/mqtt/src/main/resources/tb-mqtt-transport.yml
index a6ca2f1a6e..51f9a17005 100644
--- a/transport/mqtt/src/main/resources/tb-mqtt-transport.yml
+++ b/transport/mqtt/src/main/resources/tb-mqtt-transport.yml
@@ -293,6 +293,11 @@ queue:
       sasl.config: "${TB_QUEUE_KAFKA_CONFLUENT_SASL_JAAS_CONFIG:org.apache.kafka.common.security.plain.PlainLoginModule required username=\"CLUSTER_API_KEY\" password=\"CLUSTER_API_SECRET\";}"
       # Protocol used to communicate with brokers. Valid values are: PLAINTEXT, SSL, SASL_PLAINTEXT, SASL_SSL
       security.protocol: "${TB_QUEUE_KAFKA_CONFLUENT_SECURITY_PROTOCOL:SASL_SSL}"
+    # If you override any default Kafka topic name using environment variables, you must also specify the related consumer properties
+    # for the new topic in `consumer-properties-per-topic-inline`. Otherwise, the topic will not inherit its expected configuration (e.g., max.poll.records, timeouts, etc).
+    # Format: "topic1:key1=value1,key2=value2;topic2:key=value"
+    # Example: "tb_core_modified.notifications:max.poll.records=10;tb_edge_modified:max.poll.records=10,enable.auto.commit=true"
+    consumer-properties-per-topic-inline: "${TB_QUEUE_KAFKA_CONSUMER_PROPERTIES_PER_TOPIC_INLINE:}"
     other-inline: "${TB_QUEUE_KAFKA_OTHER_PROPERTIES:}" # In this section you can specify custom parameters (semicolon separated) for Kafka consumer/producer/admin # Example "metrics.recording.level:INFO;metrics.sample.window.ms:30000"
     other: # DEPRECATED. In this section you can specify custom parameters for Kafka consumer/producer and expose the env variables to configure outside
     #  - key: "request.timeout.ms" # refer to https://docs.confluent.io/platform/current/installation/configuration/producer-configs.html#producerconfigs_request.timeout.ms
diff --git a/transport/snmp/src/main/resources/tb-snmp-transport.yml b/transport/snmp/src/main/resources/tb-snmp-transport.yml
index 6848e8af26..f4811b3326 100644
--- a/transport/snmp/src/main/resources/tb-snmp-transport.yml
+++ b/transport/snmp/src/main/resources/tb-snmp-transport.yml
@@ -239,6 +239,11 @@ queue:
       sasl.config: "${TB_QUEUE_KAFKA_CONFLUENT_SASL_JAAS_CONFIG:org.apache.kafka.common.security.plain.PlainLoginModule required username=\"CLUSTER_API_KEY\" password=\"CLUSTER_API_SECRET\";}"
       # Protocol used to communicate with brokers. Valid values are: PLAINTEXT, SSL, SASL_PLAINTEXT, SASL_SSL
       security.protocol: "${TB_QUEUE_KAFKA_CONFLUENT_SECURITY_PROTOCOL:SASL_SSL}"
+    # If you override any default Kafka topic name using environment variables, you must also specify the related consumer properties
+    # for the new topic in `consumer-properties-per-topic-inline`. Otherwise, the topic will not inherit its expected configuration (e.g., max.poll.records, timeouts, etc).
+    # Format: "topic1:key1=value1,key2=value2;topic2:key=value"
+    # Example: "tb_core_modified.notifications:max.poll.records=10;tb_edge_modified:max.poll.records=10,enable.auto.commit=true"
+    consumer-properties-per-topic-inline: "${TB_QUEUE_KAFKA_CONSUMER_PROPERTIES_PER_TOPIC_INLINE:}"
     other-inline: "${TB_QUEUE_KAFKA_OTHER_PROPERTIES:}" # In this section you can specify custom parameters (semicolon separated) for Kafka consumer/producer/admin # Example "metrics.recording.level:INFO;metrics.sample.window.ms:30000"
     other: # DEPRECATED. In this section you can specify custom parameters for Kafka consumer/producer and expose the env variables to configure outside
     #  - key: "request.timeout.ms" # refer to https://docs.confluent.io/platform/current/installation/configuration/producer-configs.html#producerconfigs_request.timeout.ms
diff --git a/ui-ngx/src/app/core/auth/auth.models.ts b/ui-ngx/src/app/core/auth/auth.models.ts
index e5cc1424ab..142d845cf4 100644
--- a/ui-ngx/src/app/core/auth/auth.models.ts
+++ b/ui-ngx/src/app/core/auth/auth.models.ts
@@ -16,6 +16,7 @@
 
 import { AuthUser, User } from '@shared/models/user.model';
 import { UserSettings } from '@shared/models/user-settings.models';
+import { TrendzSettings } from '@shared/models/trendz-settings.models';
 
 export interface SysParamsState {
   userTokenAccessEnabled: boolean;
@@ -32,6 +33,7 @@ export interface SysParamsState {
   maxArgumentsPerCF: number;
   ruleChainDebugPerTenantLimitsConfiguration?: string;
   calculatedFieldDebugPerTenantLimitsConfiguration?: string;
+  trendzSettings: TrendzSettings;
 }
 
 export interface SysParams extends SysParamsState {
diff --git a/ui-ngx/src/app/core/auth/auth.reducer.ts b/ui-ngx/src/app/core/auth/auth.reducer.ts
index 3ecf70074c..fde778284d 100644
--- a/ui-ngx/src/app/core/auth/auth.reducer.ts
+++ b/ui-ngx/src/app/core/auth/auth.reducer.ts
@@ -17,6 +17,7 @@
 import { AuthPayload, AuthState } from './auth.models';
 import { AuthActions, AuthActionTypes } from './auth.actions';
 import { initialUserSettings, UserSettings } from '@shared/models/user-settings.models';
+import { initialTrendzSettings } from '@shared/models/trendz-settings.models';
 import { unset } from '@core/utils';
 
 const emptyUserAuthState: AuthPayload = {
@@ -34,7 +35,8 @@ const emptyUserAuthState: AuthPayload = {
   maxArgumentsPerCF: 0,
   maxDataPointsPerRollingArg: 0,
   maxDebugModeDurationMinutes: 0,
-  userSettings: initialUserSettings
+  userSettings: initialUserSettings,
+  trendzSettings: initialTrendzSettings
 };
 
 export const initialState: AuthState = {
diff --git a/ui-ngx/src/app/core/http/public-api.ts b/ui-ngx/src/app/core/http/public-api.ts
index 997689d98e..c28d80d173 100644
--- a/ui-ngx/src/app/core/http/public-api.ts
+++ b/ui-ngx/src/app/core/http/public-api.ts
@@ -47,3 +47,4 @@ export * from './user.service';
 export * from './user-settings.service';
 export * from './widget.service';
 export * from './usage-info.service';
+export * from './trendz-settings.service'
diff --git a/ui-ngx/src/app/core/http/trendz-settings.service.ts b/ui-ngx/src/app/core/http/trendz-settings.service.ts
new file mode 100644
index 0000000000..82f6973e25
--- /dev/null
+++ b/ui-ngx/src/app/core/http/trendz-settings.service.ts
@@ -0,0 +1,39 @@
+///
+/// Copyright © 2016-2025 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.
+///
+
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { TrendzSettings } from '@shared/models/trendz-settings.models';
+import { defaultHttpOptionsFromConfig, RequestConfig } from '@core/http/http-utils';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class TrendzSettingsService {
+
+  constructor(
+    private http: HttpClient
+  ) {}
+
+  public getTrendzSettings(config?: RequestConfig): Observable<TrendzSettings> {
+    return this.http.get<TrendzSettings>(`/api/trendz/settings`, defaultHttpOptionsFromConfig(config))
+  }
+
+  public saveTrendzSettings(trendzSettings: TrendzSettings, config?: RequestConfig): Observable<TrendzSettings> {
+    return this.http.post<TrendzSettings>(`/api/trendz/settings`, trendzSettings, defaultHttpOptionsFromConfig(config))
+  }
+}
diff --git a/ui-ngx/src/app/core/services/menu.models.ts b/ui-ngx/src/app/core/services/menu.models.ts
index 4775a3a771..607c5c6dff 100644
--- a/ui-ngx/src/app/core/services/menu.models.ts
+++ b/ui-ngx/src/app/core/services/menu.models.ts
@@ -104,7 +104,8 @@ export enum MenuId {
   features = 'features',
   otaUpdates = 'otaUpdates',
   version_control = 'version_control',
-  api_usage = 'api_usage'
+  api_usage = 'api_usage',
+  trendz_settings = 'trendz_settings'
 }
 
 declare type MenuFilter = (authState: AuthState) => boolean;
@@ -684,6 +685,17 @@ export const menuSectionMap = new Map<MenuId, MenuSection>([
       path: '/usage',
       icon: 'insert_chart'
     }
+  ],
+  [
+    MenuId.trendz_settings,
+    {
+      id: MenuId.trendz_settings,
+      name: 'admin.trendz',
+      fullName: 'admin.trendz-settings',
+      type: 'link',
+      path: '/settings/trendz',
+      icon: 'trendz-settings'
+    }
   ]
 ]);
 
@@ -843,7 +855,8 @@ const defaultUserMenuMap = new Map<Authority, MenuReference[]>([
           {id: MenuId.home_settings},
           {id: MenuId.notification_settings},
           {id: MenuId.repository_settings},
-          {id: MenuId.auto_commit_settings}
+          {id: MenuId.auto_commit_settings},
+          {id: MenuId.trendz_settings}
         ]
       },
       {
@@ -946,7 +959,7 @@ const defaultHomeSectionMap = new Map<Authority, HomeSectionReference[]>([
       },
       {
         name: 'admin.system-settings',
-        places: [MenuId.home_settings, MenuId.resources_library, MenuId.repository_settings, MenuId.auto_commit_settings]
+        places: [MenuId.home_settings, MenuId.resources_library, MenuId.repository_settings, MenuId.auto_commit_settings, MenuId.trendz_settings]
       }
     ]
   ],
diff --git a/ui-ngx/src/app/modules/home/models/services.map.ts b/ui-ngx/src/app/modules/home/models/services.map.ts
index e4bbc15936..517b219904 100644
--- a/ui-ngx/src/app/modules/home/models/services.map.ts
+++ b/ui-ngx/src/app/modules/home/models/services.map.ts
@@ -52,6 +52,7 @@ import { UiSettingsService } from '@core/http/ui-settings.service';
 import { UsageInfoService } from '@core/http/usage-info.service';
 import { EventService } from '@core/http/event.service';
 import { AuditLogService } from '@core/http/audit-log.service';
+import { TrendzSettingsService } from '@core/http/trendz-settings.service';
 
 export const ServicesMap = new Map<string, Type<any>>(
   [
@@ -91,6 +92,7 @@ export const ServicesMap = new Map<string, Type<any>>(
    ['usageInfoService', UsageInfoService],
    ['notificationService', NotificationService],
    ['eventService', EventService],
-   ['auditLogService', AuditLogService]
+   ['auditLogService', AuditLogService],
+   ['trendzSettingsService', TrendzSettingsService]
   ]
 );
diff --git a/ui-ngx/src/app/modules/home/pages/admin/admin-routing.module.ts b/ui-ngx/src/app/modules/home/pages/admin/admin-routing.module.ts
index 8bd724de4a..2836224a9a 100644
--- a/ui-ngx/src/app/modules/home/pages/admin/admin-routing.module.ts
+++ b/ui-ngx/src/app/modules/home/pages/admin/admin-routing.module.ts
@@ -46,6 +46,7 @@ import { ScadaSymbolData } from '@home/pages/scada-symbol/scada-symbol-editor.mo
 import { MenuId } from '@core/services/menu.models';
 import { catchError } from 'rxjs/operators';
 import { JsLibraryTableConfigResolver } from '@home/pages/admin/resource/js-library-table-config.resolver';
+import { TrendzSettingsComponent } from '@home/pages/admin/trendz-settings.component';
 
 export const scadaSymbolResolver: ResolveFn<ScadaSymbolData> =
   (route: ActivatedRouteSnapshot,
@@ -349,6 +350,18 @@ const routes: Routes = [
           }
         }
       },
+      {
+        path: 'trendz',
+        component: TrendzSettingsComponent,
+        canDeactivate: [ConfirmOnExitGuard],
+        data: {
+          auth: [Authority.TENANT_ADMIN],
+          title: 'admin.trendz-settings',
+          breadcrumb: {
+            menuId: MenuId.trendz_settings
+          }
+        }
+      },
       {
         path: 'security-settings',
         redirectTo: '/security-settings/general'
diff --git a/ui-ngx/src/app/modules/home/pages/admin/admin.module.ts b/ui-ngx/src/app/modules/home/pages/admin/admin.module.ts
index 63878ebac9..a5f18122fd 100644
--- a/ui-ngx/src/app/modules/home/pages/admin/admin.module.ts
+++ b/ui-ngx/src/app/modules/home/pages/admin/admin.module.ts
@@ -37,6 +37,7 @@ import { OAuth2Module } from '@home/pages/admin/oauth2/oauth2.module';
 import { JsLibraryTableHeaderComponent } from '@home/pages/admin/resource/js-library-table-header.component';
 import { JsResourceComponent } from '@home/pages/admin/resource/js-resource.component';
 import { NgxFlowModule } from '@flowjs/ngx-flow';
+import { TrendzSettingsComponent } from '@home/pages/admin/trendz-settings.component';
 
 @NgModule({
   declarations:
@@ -55,7 +56,8 @@ import { NgxFlowModule } from '@flowjs/ngx-flow';
       QueueComponent,
       RepositoryAdminSettingsComponent,
       AutoCommitAdminSettingsComponent,
-      TwoFactorAuthSettingsComponent
+      TwoFactorAuthSettingsComponent,
+      TrendzSettingsComponent
     ],
   imports: [
     CommonModule,
diff --git a/ui-ngx/src/app/modules/home/pages/admin/trendz-settings.component.html b/ui-ngx/src/app/modules/home/pages/admin/trendz-settings.component.html
new file mode 100644
index 0000000000..45ba62dace
--- /dev/null
+++ b/ui-ngx/src/app/modules/home/pages/admin/trendz-settings.component.html
@@ -0,0 +1,51 @@
+<!--
+
+    Copyright © 2016-2025 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.
+
+-->
+<div>
+  <mat-card appearance="outlined" class="settings-card">
+    <mat-card-header>
+      <mat-card-title>
+        <span class="mat-headline-5" translate>admin.trendz-settings</span>
+      </mat-card-title>
+      <span class="flex-1"></span>
+      <div tb-help="trendzSettings"></div>
+    </mat-card-header>
+    <mat-progress-bar color="warn" mode="indeterminate" *ngIf="isLoading$ | async">
+    </mat-progress-bar>
+    <div style="height: 4px;" *ngIf="!(isLoading$ | async)"></div>
+    <mat-card-content>
+      <form [formGroup]="trendzSettingsForm" (ngSubmit)="save()">
+        <fieldset [disabled]="isLoading$ | async">
+          <section class="tb-trendz-section flex flex-col gt-sm:flex-row">
+            <mat-form-field class="tb-trendz-url mat-block flex-1" subscriptSizing="dynamic">
+              <mat-label translate>admin.trendz-url</mat-label>
+              <input matInput formControlName="trendzUrl">
+            </mat-form-field>
+            <mat-checkbox class="flex flex-1" formControlName="isTrendzEnabled">
+              {{ 'admin.trendz-enable' | translate }}
+            </mat-checkbox>
+          </section>
+          <div class="flex w-full flex-row flex-wrap items-center justify-end">
+            <button mat-button mat-raised-button color="primary" [disabled]="(isLoading$ | async) || trendzSettingsForm.invalid || !trendzSettingsForm.dirty" type="submit">
+              {{'action.save' | translate}}
+            </button>
+          </div>
+        </fieldset>
+      </form>
+    </mat-card-content>
+  </mat-card>
+</div>
diff --git a/ui-ngx/src/app/modules/home/pages/admin/trendz-settings.component.scss b/ui-ngx/src/app/modules/home/pages/admin/trendz-settings.component.scss
new file mode 100644
index 0000000000..cbb8e698bd
--- /dev/null
+++ b/ui-ngx/src/app/modules/home/pages/admin/trendz-settings.component.scss
@@ -0,0 +1,36 @@
+/**
+ * Copyright © 2016-2025 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.
+ */
+ @import "../../../../../scss/constants";
+
+:host {
+  .mat-mdc-card-header {
+    min-height: 64px;
+  }
+
+  .tb-trendz-section {
+    margin: 16px 0;
+  }
+
+  .tb-trendz-url {
+      @media #{$mat-gt-sm} {
+        padding-right: 12px;
+      }
+
+      @media #{$mat-lt-md} {
+        padding-bottom: 12px;
+      }
+  }
+}
diff --git a/ui-ngx/src/app/modules/home/pages/admin/trendz-settings.component.ts b/ui-ngx/src/app/modules/home/pages/admin/trendz-settings.component.ts
new file mode 100644
index 0000000000..c7f5846063
--- /dev/null
+++ b/ui-ngx/src/app/modules/home/pages/admin/trendz-settings.component.ts
@@ -0,0 +1,94 @@
+///
+/// Copyright © 2016-2025 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.
+///
+
+import { Component, OnInit, DestroyRef } from '@angular/core';
+import { PageComponent } from '@shared/components/page.component';
+import { HasConfirmForm } from '@core/guards/confirm-on-exit.guard';
+import { FormBuilder, FormGroup, Validators } from '@angular/forms';
+import { TrendzSettingsService } from '@core/http/trendz-settings.service';
+import { TrendzSettings } from '@shared/models/trendz-settings.models';
+import { isDefinedAndNotNull } from '@core/utils';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+
+@Component({
+  selector: 'tb-trendz-settings',
+  templateUrl: './trendz-settings.component.html',
+  styleUrls: ['./trendz-settings.component.scss', './settings-card.scss']
+})
+export class TrendzSettingsComponent extends PageComponent implements OnInit, HasConfirmForm {
+
+  trendzSettingsForm: FormGroup;
+
+  constructor(private fb: FormBuilder,
+              private trendzSettingsService: TrendzSettingsService,
+              private destroyRef: DestroyRef) {
+    super();
+  }
+
+  ngOnInit() {
+    this.trendzSettingsForm = this.fb.group({
+      trendzUrl: [null, [Validators.pattern(/^(https?:\/\/)[^\s/$.?#].[^\s]*$/i)]],
+      isTrendzEnabled: [false]
+    });
+
+    this.trendzSettingsService.getTrendzSettings().subscribe((trendzSettings) => {
+      this.setTrendzSettings(trendzSettings);
+    });
+
+    this.trendzSettingsForm.get('isTrendzEnabled').valueChanges
+          .pipe(takeUntilDestroyed(this.destroyRef))
+          .subscribe((enabled: boolean) => this.toggleUrlRequired(enabled));
+  }
+
+  toggleUrlRequired(enabled: boolean) {
+    const trendzUrlControl = this.trendzSettingsForm.get('trendzUrl')!;
+
+    if (enabled) {
+      trendzUrlControl.addValidators(Validators.required);
+    } else {
+      trendzUrlControl.removeValidators(Validators.required);
+    }
+
+    trendzUrlControl.updateValueAndValidity();
+  }
+
+  setTrendzSettings(trendzSettings: TrendzSettings) {
+    this.trendzSettingsForm.reset({
+      trendzUrl: trendzSettings?.baseUrl,
+      isTrendzEnabled: trendzSettings?.enabled ?? false
+    });
+
+    this.toggleUrlRequired(this.trendzSettingsForm.get('isTrendzEnabled').value);
+  }
+
+  confirmForm(): FormGroup {
+    return this.trendzSettingsForm;
+  }
+
+  save(): void {
+    const trendzUrl = this.trendzSettingsForm.get('trendzUrl').value;
+    const isTrendzEnabled =   this.trendzSettingsForm.get('isTrendzEnabled').value;
+
+    const trendzSettings: TrendzSettings = {
+      baseUrl: trendzUrl,
+      enabled: isTrendzEnabled
+    };
+
+    this.trendzSettingsService.saveTrendzSettings(trendzSettings).subscribe(() => {
+      this.setTrendzSettings(trendzSettings);
+    })
+  }
+}
diff --git a/ui-ngx/src/app/shared/models/constants.ts b/ui-ngx/src/app/shared/models/constants.ts
index af576882b8..3f424b35bd 100644
--- a/ui-ngx/src/app/shared/models/constants.ts
+++ b/ui-ngx/src/app/shared/models/constants.ts
@@ -200,6 +200,7 @@ export const HelpLinks = {
     mobileQrCode: `${helpBaseUrl}/docs${docPlatformPrefix}/user-guide/ui/mobile-qr-code/`,
     calculatedField: `${helpBaseUrl}/docs${docPlatformPrefix}/user-guide/calculated-fields/`,
     timewindowSettings: `${helpBaseUrl}/docs${docPlatformPrefix}/user-guide/dashboards/#time-window`,
+    trendzSettings: `${helpBaseUrl}/docs/trendz/`
   }
 };
 /* eslint-enable max-len */
diff --git a/ui-ngx/src/app/shared/models/icon.models.ts b/ui-ngx/src/app/shared/models/icon.models.ts
index c9de8ec3da..6643bd9c7f 100644
--- a/ui-ngx/src/app/shared/models/icon.models.ts
+++ b/ui-ngx/src/app/shared/models/icon.models.ts
@@ -62,7 +62,19 @@ export const svgIcons: {[key: string]: string} = {
     '4.6760606 4.678212,7.3604329 7.3397982,4.6839955 4.6657413,2.0041717 6.6653477,2.2309572e-4 9.3360035,2.6766286 11.997681,' +
     '0 14.659287,2.6765011 Z m -5.332255,4.0079963 1.999613,2.003945 -7.99844,8.0158157 -1.9996133,-2.004017 z m 1.676684,4.3522483 ' +
     '1.999613,2.0039454 -6.6654242,6.679793 -1.9996133,-2.003874 z m 2.988987,7.0033574 -1.999544,-2.003945 -4.6658108,4.675848 ' +
-    '1.9996128,2.004015 z"/></svg>'
+    '1.9996128,2.004015 z"/></svg>',
+  'trendz-settings': '<svg viewBox="0 0 25 17"><path fill-rule="evenodd" clip-rule="evenodd" d="M7.04334 0.28949H12.2804V5.7615L11.5894 ' +
+    '6.4537L10.4605 5.32674L7.04334 8.73801V0.28949ZM7.04334 10.0127V11.0075L7.54073 10.5093L7.04334 10.0127ZM7.04334 ' +
+    '12.2649V13.2424L7.53209 12.7545L7.04334 12.2649ZM18.3903 13.243V12.2646L17.901 12.7546L18.3903 13.243ZM18.3903 ' +
+    '11.0079V10.0123L17.8925 10.5093L18.3903 11.0079ZM18.3903 8.73841V3.34443H13.1532V5.76189L13.8438 6.45362L14.9727 ' +
+    '5.32661L17.0542 7.40453L18.3903 8.73841ZM24.8335 1.16233H19.2631V13.8185H24.8335V1.16233ZM0.833481 5.52653H6.1705V13.8185H0.833481V5.52653Z"/>' +
+    '<path fill-rule="evenodd" clip-rule="evenodd" d="M14.9729 6.55688L15.819 7.40149L14.6876 8.53099L15.8137 9.65905L16.947 ' +
+    '8.52767L17.7931 9.37227L16.6583 10.5051L17.7844 11.6331L16.6669 12.7526L17.7931 13.8768L16.947 14.7214L15.8223 13.5986L14.6962 ' +
+    '14.7267L15.819 15.8476L14.973 16.6921L13.8516 15.5727L12.7169 16.7094L11.5821 15.5727L10.4607 16.6921L9.61465 15.8476L10.7375 ' +
+    '14.7267L9.61134 13.5985L8.48664 14.7213L7.64059 13.8767L8.76673 12.7525L7.64928 11.6331L8.77533 10.5051L7.64059 9.37227L8.48664 ' +
+    '8.52767L9.61993 9.65905L10.7461 8.53103L9.61465 7.40158L10.4607 6.55697L11.5907 7.68499L12.7169 6.55688L13.843 7.68494L14.9729 ' +
+    '6.55688ZM12.7169 8.24609L13.5629 9.0907L10.1787 12.4691L9.33268 11.6245L12.7169 8.24609ZM13.4262 10.0805L14.2723 10.9251L11.4521 ' +
+    '13.7404L10.6061 12.8958L13.4262 10.0805ZM14.6909 13.0321L13.8449 12.1875L11.8708 14.1583L12.7168 15.0029L14.6909 13.0321Z"/></svg>'
 };
 
 export const svgIconsUrl: { [key: string]: string } = {
diff --git a/ui-ngx/src/app/shared/models/public-api.ts b/ui-ngx/src/app/shared/models/public-api.ts
index 53e4bb286e..9f7470523e 100644
--- a/ui-ngx/src/app/shared/models/public-api.ts
+++ b/ui-ngx/src/app/shared/models/public-api.ts
@@ -62,3 +62,4 @@ export * from './window-message.model';
 export * from './usage.models';
 export * from './query/query.models';
 export * from './regex.constants';
+export * from './trendz-settings.models'
diff --git a/ui-ngx/src/app/shared/models/trendz-settings.models.ts b/ui-ngx/src/app/shared/models/trendz-settings.models.ts
new file mode 100644
index 0000000000..e09797bd7e
--- /dev/null
+++ b/ui-ngx/src/app/shared/models/trendz-settings.models.ts
@@ -0,0 +1,25 @@
+///
+/// Copyright © 2016-2025 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.
+///
+
+export interface TrendzSettings {
+  baseUrl: string,
+  enabled: boolean
+}
+
+export const initialTrendzSettings: TrendzSettings = {
+  baseUrl: null,
+  enabled: false
+}
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 b160a44b0e..8255d4e10b 100644
--- a/ui-ngx/src/assets/locale/locale.constant-en_US.json
+++ b/ui-ngx/src/assets/locale/locale.constant-en_US.json
@@ -545,7 +545,11 @@
         "slack-settings": "Slack settings",
         "mobile-settings": "Mobile settings",
         "firebase-service-account-file": "Firebase service account credentials JSON file",
-        "select-firebase-service-account-file": "Drag and drop your Firebase service account credentials file or "
+        "select-firebase-service-account-file": "Drag and drop your Firebase service account credentials file or ",
+        "trendz": "Trendz",
+        "trendz-settings": "Trendz settings",
+        "trendz-url": "Trendz URL",
+        "trendz-enable": "Enable Trendz"
       },
     "alarm": {
         "alarm": "Alarm",