Refactoring of DAO layer to support rate limiting by tenant

@@ -143,6 +143,9 @@ cassandra:
     concurrent_limit: "${CASSANDRA_QUERY_CONCURRENT_LIMIT:1000}"
     concurrent_limit: "${CASSANDRA_QUERY_CONCURRENT_LIMIT:1000}"
     permit_max_wait_time: "${PERMIT_MAX_WAIT_TIME:120000}"
     permit_max_wait_time: "${PERMIT_MAX_WAIT_TIME:120000}"
     rate_limit_print_interval_ms: "${CASSANDRA_QUERY_RATE_LIMIT_PRINT_MS:10000}"
     rate_limit_print_interval_ms: "${CASSANDRA_QUERY_RATE_LIMIT_PRINT_MS:10000}"
+    tenant_rate_limits:
+      enabled: "${CASSANDRA_QUERY_TENANT_RATE_LIMITS_ENABLED:false}"
+      configuration: "${CASSANDRA_QUERY_TENANT_RATE_LIMITS_VALUE:1000:1,30000:60}"
 
 
 # SQL configuration parameters
 # SQL configuration parameters
 sql:
 sql:

@@ -61,6 +61,10 @@
             <artifactId>logback-classic</artifactId>
             <artifactId>logback-classic</artifactId>
         </dependency>
         </dependency>
         <dependency>
         <dependency>
+            <groupId>com.github.vladimir-bukhtoyarov</groupId>
+            <artifactId>bucket4j-core</artifactId>
+        </dependency>
+        <dependency>
             <groupId>com.google.protobuf</groupId>
             <groupId>com.google.protobuf</groupId>
             <artifactId>protobuf-java</artifactId>
             <artifactId>protobuf-java</artifactId>
             <scope>provided</scope>
             <scope>provided</scope>

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * limitations under the License.
  */
  */
-package org.thingsboard.server.common.transport.service;
+package org.thingsboard.server.common.msg.tools;
 
 
 import io.github.bucket4j.Bandwidth;
 import io.github.bucket4j.Bandwidth;
 import io.github.bucket4j.Bucket4j;
 import io.github.bucket4j.Bucket4j;
@@ -25,10 +25,10 @@ import java.time.Duration;
 /**
 /**
  * Created by ashvayka on 22.10.18.
  * Created by ashvayka on 22.10.18.
  */
  */
-class TbTransportRateLimits {
+public class TbRateLimits {
     private final LocalBucket bucket;
     private final LocalBucket bucket;
 
 
-    public TbTransportRateLimits(String limitsConfiguration) {
+    public TbRateLimits(String limitsConfiguration) {
         LocalBucketBuilder builder = Bucket4j.builder();
         LocalBucketBuilder builder = Bucket4j.builder();
         boolean initialized = false;
         boolean initialized = false;
         for (String limitSrc : limitsConfiguration.split(",")) {
         for (String limitSrc : limitsConfiguration.split(",")) {
@@ -46,7 +46,7 @@ class TbTransportRateLimits {
 
 
     }
     }
 
 
-    boolean tryConsume() {
+    public boolean tryConsume() {
         return bucket.tryConsume(1);
         return bucket.tryConsume(1);
     }
     }
 
 

@@ -99,10 +99,6 @@
             <groupId>com.google.protobuf</groupId>
             <groupId>com.google.protobuf</groupId>
             <artifactId>protobuf-java</artifactId>
             <artifactId>protobuf-java</artifactId>
         </dependency>
         </dependency>
-        <dependency>
-            <groupId>com.github.vladimir-bukhtoyarov</groupId>
-            <artifactId>bucket4j-core</artifactId>
-        </dependency>
     </dependencies>
     </dependencies>
 
 
     <build>
     <build>

@@ -20,6 +20,7 @@ import org.springframework.beans.factory.annotation.Value;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.msg.tools.TbRateLimits;
 import org.thingsboard.server.common.transport.SessionMsgListener;
 import org.thingsboard.server.common.transport.SessionMsgListener;
 import org.thingsboard.server.common.transport.TransportService;
 import org.thingsboard.server.common.transport.TransportService;
 import org.thingsboard.server.common.transport.TransportServiceCallback;
 import org.thingsboard.server.common.transport.TransportServiceCallback;
@@ -58,8 +59,8 @@ public abstract class AbstractTransportService implements TransportService {
     private ConcurrentMap<UUID, SessionMetaData> sessions = new ConcurrentHashMap<>();
     private ConcurrentMap<UUID, SessionMetaData> sessions = new ConcurrentHashMap<>();
 
 
     //TODO: Implement cleanup of this maps.
     //TODO: Implement cleanup of this maps.
-    private ConcurrentMap<TenantId, TbTransportRateLimits> perTenantLimits = new ConcurrentHashMap<>();
-    private ConcurrentMap<DeviceId, TbTransportRateLimits> perDeviceLimits = new ConcurrentHashMap<>();
+    private ConcurrentMap<TenantId, TbRateLimits> perTenantLimits = new ConcurrentHashMap<>();
+    private ConcurrentMap<DeviceId, TbRateLimits> perDeviceLimits = new ConcurrentHashMap<>();
 
 
     @Override
     @Override
     public void registerAsyncSession(TransportProtos.SessionInfoProto sessionInfo, SessionMsgListener listener) {
     public void registerAsyncSession(TransportProtos.SessionInfoProto sessionInfo, SessionMsgListener listener) {
@@ -204,7 +205,7 @@ public abstract class AbstractTransportService implements TransportService {
             return true;
             return true;
         }
         }
         TenantId tenantId = new TenantId(new UUID(sessionInfo.getTenantIdMSB(), sessionInfo.getTenantIdLSB()));
         TenantId tenantId = new TenantId(new UUID(sessionInfo.getTenantIdMSB(), sessionInfo.getTenantIdLSB()));
-        TbTransportRateLimits rateLimits = perTenantLimits.computeIfAbsent(tenantId, id -> new TbTransportRateLimits(perTenantLimitsConf));
+        TbRateLimits rateLimits = perTenantLimits.computeIfAbsent(tenantId, id -> new TbRateLimits(perTenantLimitsConf));
         if (!rateLimits.tryConsume()) {
         if (!rateLimits.tryConsume()) {
             if (callback != null) {
             if (callback != null) {
                 callback.onError(new TbRateLimitsException(EntityType.TENANT));
                 callback.onError(new TbRateLimitsException(EntityType.TENANT));
@@ -215,7 +216,7 @@ public abstract class AbstractTransportService implements TransportService {
             return false;
             return false;
         }
         }
         DeviceId deviceId = new DeviceId(new UUID(sessionInfo.getDeviceIdMSB(), sessionInfo.getDeviceIdLSB()));
         DeviceId deviceId = new DeviceId(new UUID(sessionInfo.getDeviceIdMSB(), sessionInfo.getDeviceIdLSB()));
-        rateLimits = perDeviceLimits.computeIfAbsent(deviceId, id -> new TbTransportRateLimits(perDevicesLimitsConf));
+        rateLimits = perDeviceLimits.computeIfAbsent(deviceId, id -> new TbRateLimits(perDevicesLimitsConf));
         if (!rateLimits.tryConsume()) {
         if (!rateLimits.tryConsume()) {
             if (callback != null) {
             if (callback != null) {
                 callback.onError(new TbRateLimitsException(EntityType.DEVICE));
                 callback.onError(new TbRateLimitsException(EntityType.DEVICE));
@@ -271,8 +272,8 @@ public abstract class AbstractTransportService implements TransportService {
     public void init() {
     public void init() {
         if (rateLimitEnabled) {
         if (rateLimitEnabled) {
             //Just checking the configuration parameters
             //Just checking the configuration parameters
-            new TbTransportRateLimits(perTenantLimitsConf);
-            new TbTransportRateLimits(perDevicesLimitsConf);
+            new TbRateLimits(perTenantLimitsConf);
+            new TbRateLimits(perDevicesLimitsConf);
         }
         }
         this.schedulerExecutor = Executors.newSingleThreadScheduledExecutor();
         this.schedulerExecutor = Executors.newSingleThreadScheduledExecutor();
         this.transportCallbackExecutor = new ThreadPoolExecutor(0, 20, 60L, TimeUnit.SECONDS, new SynchronousQueue<>());
         this.transportCallbackExecutor = new ThreadPoolExecutor(0, 20, 60L, TimeUnit.SECONDS, new SynchronousQueue<>());

@@ -16,20 +16,21 @@
 package org.thingsboard.server.dao;
 package org.thingsboard.server.dao;
 
 
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListenableFuture;
+import org.thingsboard.server.common.data.id.TenantId;
 
 
 import java.util.List;
 import java.util.List;
 import java.util.UUID;
 import java.util.UUID;
 
 
 public interface Dao<T> {
 public interface Dao<T> {
 
 
-    List<T> find();
+    List<T> find(TenantId tenantId);
 
 
-    T findById(UUID id);
+    T findById(TenantId tenantId, UUID id);
 
 
-    ListenableFuture<T> findByIdAsync(UUID id);
+    ListenableFuture<T> findByIdAsync(TenantId tenantId, UUID id);
 
 
-    T save(T t);
+    T save(TenantId tenantId, T t);
 
 
-    boolean removeById(UUID id);
+    boolean removeById(TenantId tenantId, UUID id);
 
 
 }
 }

@@ -33,9 +33,9 @@ public interface AlarmDao extends Dao<Alarm> {
 
 
     ListenableFuture<Alarm> findLatestByOriginatorAndType(TenantId tenantId, EntityId originator, String type);
     ListenableFuture<Alarm> findLatestByOriginatorAndType(TenantId tenantId, EntityId originator, String type);
 
 
-    ListenableFuture<Alarm> findAlarmByIdAsync(UUID key);
+    ListenableFuture<Alarm> findAlarmByIdAsync(TenantId tenantId, UUID key);
 
 
-    Alarm save(Alarm alarm);
+    Alarm save(TenantId tenantId, Alarm alarm);
 
 
-    ListenableFuture<List<AlarmInfo>> findAlarms(AlarmQuery query);
+    ListenableFuture<List<AlarmInfo>> findAlarms(TenantId tenantId, AlarmQuery query);
 }
 }

@@ -35,17 +35,17 @@ public interface AlarmService {
 
 
     Alarm createOrUpdateAlarm(Alarm alarm);
     Alarm createOrUpdateAlarm(Alarm alarm);
 
 
-    ListenableFuture<Boolean> ackAlarm(AlarmId alarmId, long ackTs);
+    ListenableFuture<Boolean> ackAlarm(TenantId tenantId, AlarmId alarmId, long ackTs);
 
 
-    ListenableFuture<Boolean> clearAlarm(AlarmId alarmId, JsonNode details, long ackTs);
+    ListenableFuture<Boolean> clearAlarm(TenantId tenantId, AlarmId alarmId, JsonNode details, long ackTs);
 
 
-    ListenableFuture<Alarm> findAlarmByIdAsync(AlarmId alarmId);
+    ListenableFuture<Alarm> findAlarmByIdAsync(TenantId tenantId, AlarmId alarmId);
 
 
-    ListenableFuture<AlarmInfo> findAlarmInfoByIdAsync(AlarmId alarmId);
+    ListenableFuture<AlarmInfo> findAlarmInfoByIdAsync(TenantId tenantId, AlarmId alarmId);
 
 
-    ListenableFuture<TimePageData<AlarmInfo>> findAlarms(AlarmQuery query);
+    ListenableFuture<TimePageData<AlarmInfo>> findAlarms(TenantId tenantId, AlarmQuery query);
 
 
-    AlarmSeverity findHighestAlarmSeverity(EntityId entityId, AlarmSearchStatus alarmSearchStatus,
+    AlarmSeverity findHighestAlarmSeverity(TenantId tenantId, EntityId entityId, AlarmSearchStatus alarmSearchStatus,
                                            AlarmStatus alarmStatus);
                                            AlarmStatus alarmStatus);
 
 
     ListenableFuture<Alarm> findLatestByOriginatorAndType(TenantId tenantId, EntityId originator, String type);
     ListenableFuture<Alarm> findLatestByOriginatorAndType(TenantId tenantId, EntityId originator, String type);

@@ -91,7 +91,7 @@ public class BaseAlarmService extends AbstractEntityService implements AlarmServ
 
 
     @Override
     @Override
     public Alarm createOrUpdateAlarm(Alarm alarm) {
     public Alarm createOrUpdateAlarm(Alarm alarm) {
-        alarmDataValidator.validate(alarm);
+        alarmDataValidator.validate(alarm, Alarm::getTenantId);
         try {
         try {
             if (alarm.getStartTs() == 0L) {
             if (alarm.getStartTs() == 0L) {
                 alarm.setStartTs(System.currentTimeMillis());
                 alarm.setStartTs(System.currentTimeMillis());
@@ -120,7 +120,7 @@ public class BaseAlarmService extends AbstractEntityService implements AlarmServ
 
 
     private Alarm createAlarm(Alarm alarm) throws InterruptedException, ExecutionException {
     private Alarm createAlarm(Alarm alarm) throws InterruptedException, ExecutionException {
         log.debug("New Alarm : {}", alarm);
         log.debug("New Alarm : {}", alarm);
-        Alarm saved = alarmDao.save(alarm);
+        Alarm saved = alarmDao.save(alarm.getTenantId(), alarm);
         createAlarmRelations(saved);
         createAlarmRelations(saved);
         return saved;
         return saved;
     }
     }
@@ -129,17 +129,17 @@ public class BaseAlarmService extends AbstractEntityService implements AlarmServ
         if (alarm.isPropagate()) {
         if (alarm.isPropagate()) {
             EntityRelationsQuery query = new EntityRelationsQuery();
             EntityRelationsQuery query = new EntityRelationsQuery();
             query.setParameters(new RelationsSearchParameters(alarm.getOriginator(), EntitySearchDirection.TO, Integer.MAX_VALUE));
             query.setParameters(new RelationsSearchParameters(alarm.getOriginator(), EntitySearchDirection.TO, Integer.MAX_VALUE));
-            List<EntityId> parentEntities = relationService.findByQuery(query).get().stream().map(r -> r.getFrom()).collect(Collectors.toList());
+            List<EntityId> parentEntities = relationService.findByQuery(alarm.getTenantId(), query).get().stream().map(EntityRelation::getFrom).collect(Collectors.toList());
             for (EntityId parentId : parentEntities) {
             for (EntityId parentId : parentEntities) {
-                createAlarmRelation(parentId, alarm.getId(), alarm.getStatus(), true);
+                createAlarmRelation(alarm.getTenantId(), parentId, alarm.getId(), alarm.getStatus(), true);
             }
             }
         }
         }
-        createAlarmRelation(alarm.getOriginator(), alarm.getId(), alarm.getStatus(), true);
+        createAlarmRelation(alarm.getTenantId(), alarm.getOriginator(), alarm.getId(), alarm.getStatus(), true);
     }
     }
 
 
     private ListenableFuture<Alarm> updateAlarm(Alarm update) {
     private ListenableFuture<Alarm> updateAlarm(Alarm update) {
-        alarmDataValidator.validate(update);
-        return getAndUpdate(update.getId(), new Function<Alarm, Alarm>() {
+        alarmDataValidator.validate(update, Alarm::getTenantId);
+        return getAndUpdate(update.getTenantId(), update.getId(), new Function<Alarm, Alarm>() {
             @Nullable
             @Nullable
             @Override
             @Override
             public Alarm apply(@Nullable Alarm alarm) {
             public Alarm apply(@Nullable Alarm alarm) {
@@ -157,7 +157,7 @@ public class BaseAlarmService extends AbstractEntityService implements AlarmServ
         AlarmStatus newStatus = newAlarm.getStatus();
         AlarmStatus newStatus = newAlarm.getStatus();
         boolean oldPropagate = oldAlarm.isPropagate();
         boolean oldPropagate = oldAlarm.isPropagate();
         boolean newPropagate = newAlarm.isPropagate();
         boolean newPropagate = newAlarm.isPropagate();
-        Alarm result = alarmDao.save(merge(oldAlarm, newAlarm));
+        Alarm result = alarmDao.save(newAlarm.getTenantId(), merge(oldAlarm, newAlarm));
         if (!oldPropagate && newPropagate) {
         if (!oldPropagate && newPropagate) {
             try {
             try {
                 createAlarmRelations(result);
                 createAlarmRelations(result);
@@ -172,8 +172,8 @@ public class BaseAlarmService extends AbstractEntityService implements AlarmServ
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<Boolean> ackAlarm(AlarmId alarmId, long ackTime) {
-        return getAndUpdate(alarmId, new Function<Alarm, Boolean>() {
+    public ListenableFuture<Boolean> ackAlarm(TenantId tenantId, AlarmId alarmId, long ackTime) {
+        return getAndUpdate(tenantId, alarmId, new Function<Alarm, Boolean>() {
             @Nullable
             @Nullable
             @Override
             @Override
             public Boolean apply(@Nullable Alarm alarm) {
             public Boolean apply(@Nullable Alarm alarm) {
@@ -184,7 +184,7 @@ public class BaseAlarmService extends AbstractEntityService implements AlarmServ
                     AlarmStatus newStatus = oldStatus.isCleared() ? AlarmStatus.CLEARED_ACK : AlarmStatus.ACTIVE_ACK;
                     AlarmStatus newStatus = oldStatus.isCleared() ? AlarmStatus.CLEARED_ACK : AlarmStatus.ACTIVE_ACK;
                     alarm.setStatus(newStatus);
                     alarm.setStatus(newStatus);
                     alarm.setAckTs(ackTime);
                     alarm.setAckTs(ackTime);
-                    alarmDao.save(alarm);
+                    alarmDao.save(alarm.getTenantId(), alarm);
                     updateRelations(alarm, oldStatus, newStatus);
                     updateRelations(alarm, oldStatus, newStatus);
                     return true;
                     return true;
                 }
                 }
@@ -193,8 +193,8 @@ public class BaseAlarmService extends AbstractEntityService implements AlarmServ
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<Boolean> clearAlarm(AlarmId alarmId, JsonNode details, long clearTime) {
-        return getAndUpdate(alarmId, new Function<Alarm, Boolean>() {
+    public ListenableFuture<Boolean> clearAlarm(TenantId tenantId, AlarmId alarmId, JsonNode details, long clearTime) {
+        return getAndUpdate(tenantId, alarmId, new Function<Alarm, Boolean>() {
             @Nullable
             @Nullable
             @Override
             @Override
             public Boolean apply(@Nullable Alarm alarm) {
             public Boolean apply(@Nullable Alarm alarm) {
@@ -208,7 +208,7 @@ public class BaseAlarmService extends AbstractEntityService implements AlarmServ
                     if (details != null) {
                     if (details != null) {
                         alarm.setDetails(details);
                         alarm.setDetails(details);
                     }
                     }
-                    alarmDao.save(alarm);
+                    alarmDao.save(alarm.getTenantId(), alarm);
                     updateRelations(alarm, oldStatus, newStatus);
                     updateRelations(alarm, oldStatus, newStatus);
                     return true;
                     return true;
                 }
                 }
@@ -217,21 +217,21 @@ public class BaseAlarmService extends AbstractEntityService implements AlarmServ
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<Alarm> findAlarmByIdAsync(AlarmId alarmId) {
+    public ListenableFuture<Alarm> findAlarmByIdAsync(TenantId tenantId, AlarmId alarmId) {
         log.trace("Executing findAlarmById [{}]", alarmId);
         log.trace("Executing findAlarmById [{}]", alarmId);
         validateId(alarmId, "Incorrect alarmId " + alarmId);
         validateId(alarmId, "Incorrect alarmId " + alarmId);
-        return alarmDao.findAlarmByIdAsync(alarmId.getId());
+        return alarmDao.findAlarmByIdAsync(tenantId, alarmId.getId());
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<AlarmInfo> findAlarmInfoByIdAsync(AlarmId alarmId) {
+    public ListenableFuture<AlarmInfo> findAlarmInfoByIdAsync(TenantId tenantId, AlarmId alarmId) {
         log.trace("Executing findAlarmInfoByIdAsync [{}]", alarmId);
         log.trace("Executing findAlarmInfoByIdAsync [{}]", alarmId);
         validateId(alarmId, "Incorrect alarmId " + alarmId);
         validateId(alarmId, "Incorrect alarmId " + alarmId);
-        return Futures.transformAsync(alarmDao.findAlarmByIdAsync(alarmId.getId()),
+        return Futures.transformAsync(alarmDao.findAlarmByIdAsync(tenantId, alarmId.getId()),
                 a -> {
                 a -> {
                     AlarmInfo alarmInfo = new AlarmInfo(a);
                     AlarmInfo alarmInfo = new AlarmInfo(a);
                     return Futures.transform(
                     return Futures.transform(
-                            entityService.fetchEntityNameAsync(alarmInfo.getOriginator()), originatorName -> {
+                            entityService.fetchEntityNameAsync(tenantId, alarmInfo.getOriginator()), originatorName -> {
                                 alarmInfo.setOriginatorName(originatorName);
                                 alarmInfo.setOriginatorName(originatorName);
                                 return alarmInfo;
                                 return alarmInfo;
                             }
                             }
@@ -240,14 +240,14 @@ public class BaseAlarmService extends AbstractEntityService implements AlarmServ
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<TimePageData<AlarmInfo>> findAlarms(AlarmQuery query) {
-        ListenableFuture<List<AlarmInfo>> alarms = alarmDao.findAlarms(query);
+    public ListenableFuture<TimePageData<AlarmInfo>> findAlarms(TenantId tenantId, AlarmQuery query) {
+        ListenableFuture<List<AlarmInfo>> alarms = alarmDao.findAlarms(tenantId, query);
         if (query.getFetchOriginator() != null && query.getFetchOriginator().booleanValue()) {
         if (query.getFetchOriginator() != null && query.getFetchOriginator().booleanValue()) {
             alarms = Futures.transformAsync(alarms, input -> {
             alarms = Futures.transformAsync(alarms, input -> {
                 List<ListenableFuture<AlarmInfo>> alarmFutures = new ArrayList<>(input.size());
                 List<ListenableFuture<AlarmInfo>> alarmFutures = new ArrayList<>(input.size());
                 for (AlarmInfo alarmInfo : input) {
                 for (AlarmInfo alarmInfo : input) {
                     alarmFutures.add(Futures.transform(
                     alarmFutures.add(Futures.transform(
-                            entityService.fetchEntityNameAsync(alarmInfo.getOriginator()), originatorName -> {
+                            entityService.fetchEntityNameAsync(tenantId, alarmInfo.getOriginator()), originatorName -> {
                                 if (originatorName == null) {
                                 if (originatorName == null) {
                                     originatorName = "Deleted";
                                     originatorName = "Deleted";
                                 }
                                 }
@@ -269,7 +269,7 @@ public class BaseAlarmService extends AbstractEntityService implements AlarmServ
     }
     }
 
 
     @Override
     @Override
-    public AlarmSeverity findHighestAlarmSeverity(EntityId entityId, AlarmSearchStatus alarmSearchStatus,
+    public AlarmSeverity findHighestAlarmSeverity(TenantId tenantId, EntityId entityId, AlarmSearchStatus alarmSearchStatus,
                                                   AlarmStatus alarmStatus) {
                                                   AlarmStatus alarmStatus) {
         TimePageLink nextPageLink = new TimePageLink(100);
         TimePageLink nextPageLink = new TimePageLink(100);
         boolean hasNext = true;
         boolean hasNext = true;
@@ -279,7 +279,7 @@ public class BaseAlarmService extends AbstractEntityService implements AlarmServ
             query = new AlarmQuery(entityId, nextPageLink, alarmSearchStatus, alarmStatus, false);
             query = new AlarmQuery(entityId, nextPageLink, alarmSearchStatus, alarmStatus, false);
             List<AlarmInfo> alarms;
             List<AlarmInfo> alarms;
             try {
             try {
-                alarms = alarmDao.findAlarms(query).get();
+                alarms = alarmDao.findAlarms(tenantId, query).get();
             } catch (ExecutionException | InterruptedException e) {
             } catch (ExecutionException | InterruptedException e) {
                 log.warn("Failed to find highest alarm severity. EntityId: [{}], AlarmSearchStatus: [{}], AlarmStatus: [{}]",
                 log.warn("Failed to find highest alarm severity. EntityId: [{}], AlarmSearchStatus: [{}], AlarmStatus: [{}]",
                         entityId, alarmSearchStatus, alarmStatus);
                         entityId, alarmSearchStatus, alarmStatus);
@@ -312,14 +312,14 @@ public class BaseAlarmService extends AbstractEntityService implements AlarmServ
         }
         }
     }
     }
 
 
-    private void deleteRelation(EntityRelation alarmRelation) throws ExecutionException, InterruptedException {
+    private void deleteRelation(TenantId tenantId, EntityRelation alarmRelation) throws ExecutionException, InterruptedException {
         log.debug("Deleting Alarm relation: {}", alarmRelation);
         log.debug("Deleting Alarm relation: {}", alarmRelation);
-        relationService.deleteRelationAsync(alarmRelation).get();
+        relationService.deleteRelationAsync(tenantId, alarmRelation).get();
     }
     }
 
 
-    private void createRelation(EntityRelation alarmRelation) throws ExecutionException, InterruptedException {
+    private void createRelation(TenantId tenantId, EntityRelation alarmRelation) throws ExecutionException, InterruptedException {
         log.debug("Creating Alarm relation: {}", alarmRelation);
         log.debug("Creating Alarm relation: {}", alarmRelation);
-        relationService.saveRelationAsync(alarmRelation).get();
+        relationService.saveRelationAsync(tenantId, alarmRelation).get();
     }
     }
 
 
     private Alarm merge(Alarm existing, Alarm alarm) {
     private Alarm merge(Alarm existing, Alarm alarm) {
@@ -344,10 +344,10 @@ public class BaseAlarmService extends AbstractEntityService implements AlarmServ
 
 
     private void updateRelations(Alarm alarm, AlarmStatus oldStatus, AlarmStatus newStatus) {
     private void updateRelations(Alarm alarm, AlarmStatus oldStatus, AlarmStatus newStatus) {
         try {
         try {
-            List<EntityRelation> relations = relationService.findByToAsync(alarm.getId(), RelationTypeGroup.ALARM).get();
+            List<EntityRelation> relations = relationService.findByToAsync(alarm.getTenantId(), alarm.getId(), RelationTypeGroup.ALARM).get();
             Set<EntityId> parents = relations.stream().map(EntityRelation::getFrom).collect(Collectors.toSet());
             Set<EntityId> parents = relations.stream().map(EntityRelation::getFrom).collect(Collectors.toSet());
             for (EntityId parentId : parents) {
             for (EntityId parentId : parents) {
-                updateAlarmRelation(parentId, alarm.getId(), oldStatus, newStatus);
+                updateAlarmRelation(alarm.getTenantId(), parentId, alarm.getId(), oldStatus, newStatus);
             }
             }
         } catch (ExecutionException | InterruptedException e) {
         } catch (ExecutionException | InterruptedException e) {
             log.warn("[{}] Failed to update relations. Old status: [{}], New status: [{}]", alarm.getId(), oldStatus, newStatus);
             log.warn("[{}] Failed to update relations. Old status: [{}], New status: [{}]", alarm.getId(), oldStatus, newStatus);
@@ -355,39 +355,39 @@ public class BaseAlarmService extends AbstractEntityService implements AlarmServ
         }
         }
     }
     }
 
 
-    private void createAlarmRelation(EntityId entityId, EntityId alarmId, AlarmStatus status, boolean createAnyRelation) {
+    private void createAlarmRelation(TenantId tenantId, EntityId entityId, EntityId alarmId, AlarmStatus status, boolean createAnyRelation) {
         try {
         try {
             if (createAnyRelation) {
             if (createAnyRelation) {
-                createRelation(new EntityRelation(entityId, alarmId, ALARM_RELATION_PREFIX + AlarmSearchStatus.ANY.name(), RelationTypeGroup.ALARM));
+                createRelation(tenantId, new EntityRelation(entityId, alarmId, ALARM_RELATION_PREFIX + AlarmSearchStatus.ANY.name(), RelationTypeGroup.ALARM));
             }
             }
-            createRelation(new EntityRelation(entityId, alarmId, ALARM_RELATION_PREFIX + status.name(), RelationTypeGroup.ALARM));
-            createRelation(new EntityRelation(entityId, alarmId, ALARM_RELATION_PREFIX + status.getClearSearchStatus().name(), RelationTypeGroup.ALARM));
-            createRelation(new EntityRelation(entityId, alarmId, ALARM_RELATION_PREFIX + status.getAckSearchStatus().name(), RelationTypeGroup.ALARM));
+            createRelation(tenantId, new EntityRelation(entityId, alarmId, ALARM_RELATION_PREFIX + status.name(), RelationTypeGroup.ALARM));
+            createRelation(tenantId, new EntityRelation(entityId, alarmId, ALARM_RELATION_PREFIX + status.getClearSearchStatus().name(), RelationTypeGroup.ALARM));
+            createRelation(tenantId, new EntityRelation(entityId, alarmId, ALARM_RELATION_PREFIX + status.getAckSearchStatus().name(), RelationTypeGroup.ALARM));
         } catch (ExecutionException | InterruptedException e) {
         } catch (ExecutionException | InterruptedException e) {
             log.warn("[{}] Failed to create relation. Status: [{}]", alarmId, status);
             log.warn("[{}] Failed to create relation. Status: [{}]", alarmId, status);
             throw new RuntimeException(e);
             throw new RuntimeException(e);
         }
         }
     }
     }
 
 
-    private void deleteAlarmRelation(EntityId entityId, EntityId alarmId, AlarmStatus status) {
+    private void deleteAlarmRelation(TenantId tenantId, EntityId entityId, EntityId alarmId, AlarmStatus status) {
         try {
         try {
-            deleteRelation(new EntityRelation(entityId, alarmId, ALARM_RELATION_PREFIX + status.name(), RelationTypeGroup.ALARM));
-            deleteRelation(new EntityRelation(entityId, alarmId, ALARM_RELATION_PREFIX + status.getClearSearchStatus().name(), RelationTypeGroup.ALARM));
-            deleteRelation(new EntityRelation(entityId, alarmId, ALARM_RELATION_PREFIX + status.getAckSearchStatus().name(), RelationTypeGroup.ALARM));
+            deleteRelation(tenantId, new EntityRelation(entityId, alarmId, ALARM_RELATION_PREFIX + status.name(), RelationTypeGroup.ALARM));
+            deleteRelation(tenantId, new EntityRelation(entityId, alarmId, ALARM_RELATION_PREFIX + status.getClearSearchStatus().name(), RelationTypeGroup.ALARM));
+            deleteRelation(tenantId, new EntityRelation(entityId, alarmId, ALARM_RELATION_PREFIX + status.getAckSearchStatus().name(), RelationTypeGroup.ALARM));
         } catch (ExecutionException | InterruptedException e) {
         } catch (ExecutionException | InterruptedException e) {
             log.warn("[{}] Failed to delete relation. Status: [{}]", alarmId, status);
             log.warn("[{}] Failed to delete relation. Status: [{}]", alarmId, status);
             throw new RuntimeException(e);
             throw new RuntimeException(e);
         }
         }
     }
     }
 
 
-    private void updateAlarmRelation(EntityId entityId, EntityId alarmId, AlarmStatus oldStatus, AlarmStatus newStatus) {
-        deleteAlarmRelation(entityId, alarmId, oldStatus);
-        createAlarmRelation(entityId, alarmId, newStatus, false);
+    private void updateAlarmRelation(TenantId tenantId, EntityId entityId, EntityId alarmId, AlarmStatus oldStatus, AlarmStatus newStatus) {
+        deleteAlarmRelation(tenantId, entityId, alarmId, oldStatus);
+        createAlarmRelation(tenantId, entityId, alarmId, newStatus, false);
     }
     }
 
 
-    private <T> ListenableFuture<T> getAndUpdate(AlarmId alarmId, Function<Alarm, T> function) {
+    private <T> ListenableFuture<T> getAndUpdate(TenantId tenantId, AlarmId alarmId, Function<Alarm, T> function) {
         validateId(alarmId, "Alarm id should be specified!");
         validateId(alarmId, "Alarm id should be specified!");
-        ListenableFuture<Alarm> entity = alarmDao.findAlarmByIdAsync(alarmId.getId());
+        ListenableFuture<Alarm> entity = alarmDao.findAlarmByIdAsync(tenantId, alarmId.getId());
         return Futures.transform(entity, function, readResultsProcessingExecutor);
         return Futures.transform(entity, function, readResultsProcessingExecutor);
     }
     }
 
 
@@ -395,7 +395,7 @@ public class BaseAlarmService extends AbstractEntityService implements AlarmServ
             new DataValidator<Alarm>() {
             new DataValidator<Alarm>() {
 
 
                 @Override
                 @Override
-                protected void validateDataImpl(Alarm alarm) {
+                protected void validateDataImpl(TenantId tenantId, Alarm alarm) {
                     if (StringUtils.isEmpty(alarm.getType())) {
                     if (StringUtils.isEmpty(alarm.getType())) {
                         throw new DataValidationException("Alarm type should be specified!");
                         throw new DataValidationException("Alarm type should be specified!");
                     }
                     }
@@ -411,7 +411,7 @@ public class BaseAlarmService extends AbstractEntityService implements AlarmServ
                     if (alarm.getTenantId() == null) {
                     if (alarm.getTenantId() == null) {
                         throw new DataValidationException("Alarm should be assigned to tenant!");
                         throw new DataValidationException("Alarm should be assigned to tenant!");
                     } else {
                     } else {
-                        Tenant tenant = tenantDao.findById(alarm.getTenantId().getId());
+                        Tenant tenant = tenantDao.findById(alarm.getTenantId(), alarm.getTenantId().getId());
                         if (tenant == null) {
                         if (tenant == null) {
                             throw new DataValidationException("Alarm is referencing to non-existent tenant!");
                             throw new DataValidationException("Alarm is referencing to non-existent tenant!");
                         }
                         }

@@ -73,9 +73,9 @@ public class CassandraAlarmDao extends CassandraAbstractModelDao<AlarmEntity, Al
     }
     }
 
 
     @Override
     @Override
-    public Alarm save(Alarm alarm) {
+    public Alarm save(TenantId tenantId, Alarm alarm) {
         log.debug("Save asset [{}] ", alarm);
         log.debug("Save asset [{}] ", alarm);
-        return super.save(alarm);
+        return super.save(tenantId, alarm);
     }
     }
 
 
     @Override
     @Override
@@ -88,11 +88,11 @@ public class CassandraAlarmDao extends CassandraAbstractModelDao<AlarmEntity, Al
         query.and(eq(ALARM_TYPE_PROPERTY, type));
         query.and(eq(ALARM_TYPE_PROPERTY, type));
         query.limit(1);
         query.limit(1);
         query.orderBy(QueryBuilder.asc(ModelConstants.ALARM_TYPE_PROPERTY), QueryBuilder.desc(ModelConstants.ID_PROPERTY));
         query.orderBy(QueryBuilder.asc(ModelConstants.ALARM_TYPE_PROPERTY), QueryBuilder.desc(ModelConstants.ID_PROPERTY));
-        return findOneByStatementAsync(query);
+        return findOneByStatementAsync(tenantId, query);
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<List<AlarmInfo>> findAlarms(AlarmQuery query) {
+    public ListenableFuture<List<AlarmInfo>> findAlarms(TenantId tenantId, AlarmQuery query) {
         log.trace("Try to find alarms by entity [{}], searchStatus [{}], status [{}] and pageLink [{}]", query.getAffectedEntityId(), query.getSearchStatus(), query.getStatus(), query.getPageLink());
         log.trace("Try to find alarms by entity [{}], searchStatus [{}], status [{}] and pageLink [{}]", query.getAffectedEntityId(), query.getSearchStatus(), query.getStatus(), query.getPageLink());
         EntityId affectedEntity = query.getAffectedEntityId();
         EntityId affectedEntity = query.getAffectedEntityId();
         String searchStatusName;
         String searchStatusName;
@@ -104,12 +104,12 @@ public class CassandraAlarmDao extends CassandraAbstractModelDao<AlarmEntity, Al
             searchStatusName = query.getStatus().name();
             searchStatusName = query.getStatus().name();
         }
         }
         String relationType = BaseAlarmService.ALARM_RELATION_PREFIX + searchStatusName;
         String relationType = BaseAlarmService.ALARM_RELATION_PREFIX + searchStatusName;
-        ListenableFuture<List<EntityRelation>> relations = relationDao.findRelations(affectedEntity, relationType, RelationTypeGroup.ALARM, EntityType.ALARM, query.getPageLink());
+        ListenableFuture<List<EntityRelation>> relations = relationDao.findRelations(tenantId, affectedEntity, relationType, RelationTypeGroup.ALARM, EntityType.ALARM, query.getPageLink());
         return Futures.transformAsync(relations, input -> {
         return Futures.transformAsync(relations, input -> {
             List<ListenableFuture<AlarmInfo>> alarmFutures = new ArrayList<>(input.size());
             List<ListenableFuture<AlarmInfo>> alarmFutures = new ArrayList<>(input.size());
             for (EntityRelation relation : input) {
             for (EntityRelation relation : input) {
                 alarmFutures.add(Futures.transform(
                 alarmFutures.add(Futures.transform(
-                        findAlarmByIdAsync(relation.getTo().getId()),
+                        findAlarmByIdAsync(tenantId, relation.getTo().getId()),
                         AlarmInfo::new));
                         AlarmInfo::new));
             }
             }
             return Futures.successfulAsList(alarmFutures);
             return Futures.successfulAsList(alarmFutures);
@@ -117,11 +117,11 @@ public class CassandraAlarmDao extends CassandraAbstractModelDao<AlarmEntity, Al
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<Alarm> findAlarmByIdAsync(UUID key) {
+    public ListenableFuture<Alarm> findAlarmByIdAsync(TenantId tenantId, UUID key) {
         log.debug("Get alarm by id {}", key);
         log.debug("Get alarm by id {}", key);
         Select.Where query = select().from(ALARM_BY_ID_VIEW_NAME).where(eq(ModelConstants.ID_PROPERTY, key));
         Select.Where query = select().from(ALARM_BY_ID_VIEW_NAME).where(eq(ModelConstants.ID_PROPERTY, key));
         query.limit(1);
         query.limit(1);
         log.trace("Execute query {}", query);
         log.trace("Execute query {}", query);
-        return findOneByStatementAsync(query);
+        return findOneByStatementAsync(tenantId, query);
     }
     }
 }
 }

@@ -18,6 +18,7 @@ package org.thingsboard.server.dao.asset;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListenableFuture;
 import org.thingsboard.server.common.data.EntitySubtype;
 import org.thingsboard.server.common.data.EntitySubtype;
 import org.thingsboard.server.common.data.asset.Asset;
 import org.thingsboard.server.common.data.asset.Asset;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.dao.Dao;
 import org.thingsboard.server.dao.Dao;
 
 
@@ -37,7 +38,7 @@ public interface AssetDao extends Dao<Asset> {
      * @param asset the asset object
      * @param asset the asset object
      * @return saved asset object
      * @return saved asset object
      */
      */
-    Asset save(Asset asset);
+    Asset save(TenantId tenantId, Asset asset);
 
 
     /**
     /**
      * Find assets by tenantId and page link.
      * Find assets by tenantId and page link.

@@ -30,19 +30,19 @@ import java.util.Optional;
 
 
 public interface AssetService {
 public interface AssetService {
 
 
-    Asset findAssetById(AssetId assetId);
+    Asset findAssetById(TenantId tenantId, AssetId assetId);
 
 
-    ListenableFuture<Asset> findAssetByIdAsync(AssetId assetId);
+    ListenableFuture<Asset> findAssetByIdAsync(TenantId tenantId, AssetId assetId);
 
 
     Asset findAssetByTenantIdAndName(TenantId tenantId, String name);
     Asset findAssetByTenantIdAndName(TenantId tenantId, String name);
 
 
     Asset saveAsset(Asset asset);
     Asset saveAsset(Asset asset);
 
 
-    Asset assignAssetToCustomer(AssetId assetId, CustomerId customerId);
+    Asset assignAssetToCustomer(TenantId tenantId, AssetId assetId, CustomerId customerId);
 
 
-    Asset unassignAssetFromCustomer(AssetId assetId);
+    Asset unassignAssetFromCustomer(TenantId tenantId, AssetId assetId);
 
 
-    void deleteAsset(AssetId assetId);
+    void deleteAsset(TenantId tenantId, AssetId assetId);
 
 
     TextPageData<Asset> findAssetsByTenantId(TenantId tenantId, TextPageLink pageLink);
     TextPageData<Asset> findAssetsByTenantId(TenantId tenantId, TextPageLink pageLink);
 
 
@@ -60,7 +60,7 @@ public interface AssetService {
 
 
     void unassignCustomerAssets(TenantId tenantId, CustomerId customerId);
     void unassignCustomerAssets(TenantId tenantId, CustomerId customerId);
 
 
-    ListenableFuture<List<Asset>> findAssetsByQuery(AssetSearchQuery query);
+    ListenableFuture<List<Asset>> findAssetsByQuery(TenantId tenantId, AssetSearchQuery query);
 
 
     ListenableFuture<List<EntitySubtype>> findAssetTypesByTenantId(TenantId tenantId);
     ListenableFuture<List<EntitySubtype>> findAssetTypesByTenantId(TenantId tenantId);
 }
 }

@@ -86,17 +86,17 @@ public class BaseAssetService extends AbstractEntityService implements AssetServ
     private CacheManager cacheManager;
     private CacheManager cacheManager;
 
 
     @Override
     @Override
-    public Asset findAssetById(AssetId assetId) {
+    public Asset findAssetById(TenantId tenantId, AssetId assetId) {
         log.trace("Executing findAssetById [{}]", assetId);
         log.trace("Executing findAssetById [{}]", assetId);
         validateId(assetId, INCORRECT_ASSET_ID + assetId);
         validateId(assetId, INCORRECT_ASSET_ID + assetId);
-        return assetDao.findById(assetId.getId());
+        return assetDao.findById(tenantId, assetId.getId());
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<Asset> findAssetByIdAsync(AssetId assetId) {
+    public ListenableFuture<Asset> findAssetByIdAsync(TenantId tenantId, AssetId assetId) {
         log.trace("Executing findAssetById [{}]", assetId);
         log.trace("Executing findAssetById [{}]", assetId);
         validateId(assetId, INCORRECT_ASSET_ID + assetId);
         validateId(assetId, INCORRECT_ASSET_ID + assetId);
-        return assetDao.findByIdAsync(assetId.getId());
+        return assetDao.findByIdAsync(tenantId, assetId.getId());
     }
     }
 
 
     @Cacheable(cacheNames = ASSET_CACHE, key = "{#tenantId, #name}")
     @Cacheable(cacheNames = ASSET_CACHE, key = "{#tenantId, #name}")
@@ -112,31 +112,31 @@ public class BaseAssetService extends AbstractEntityService implements AssetServ
     @Override
     @Override
     public Asset saveAsset(Asset asset) {
     public Asset saveAsset(Asset asset) {
         log.trace("Executing saveAsset [{}]", asset);
         log.trace("Executing saveAsset [{}]", asset);
-        assetValidator.validate(asset);
-        return assetDao.save(asset);
+        assetValidator.validate(asset, Asset::getTenantId);
+        return assetDao.save(asset.getTenantId(), asset);
     }
     }
 
 
     @Override
     @Override
-    public Asset assignAssetToCustomer(AssetId assetId, CustomerId customerId) {
-        Asset asset = findAssetById(assetId);
+    public Asset assignAssetToCustomer(TenantId tenantId, AssetId assetId, CustomerId customerId) {
+        Asset asset = findAssetById(tenantId, assetId);
         asset.setCustomerId(customerId);
         asset.setCustomerId(customerId);
         return saveAsset(asset);
         return saveAsset(asset);
     }
     }
 
 
     @Override
     @Override
-    public Asset unassignAssetFromCustomer(AssetId assetId) {
-        Asset asset = findAssetById(assetId);
+    public Asset unassignAssetFromCustomer(TenantId tenantId, AssetId assetId) {
+        Asset asset = findAssetById(tenantId, assetId);
         asset.setCustomerId(null);
         asset.setCustomerId(null);
         return saveAsset(asset);
         return saveAsset(asset);
     }
     }
 
 
     @Override
     @Override
-    public void deleteAsset(AssetId assetId) {
+    public void deleteAsset(TenantId tenantId, AssetId assetId) {
         log.trace("Executing deleteAsset [{}]", assetId);
         log.trace("Executing deleteAsset [{}]", assetId);
         validateId(assetId, INCORRECT_ASSET_ID + assetId);
         validateId(assetId, INCORRECT_ASSET_ID + assetId);
-        deleteEntityRelations(assetId);
+        deleteEntityRelations(tenantId, assetId);
 
 
-        Asset asset = assetDao.findById(assetId.getId());
+        Asset asset = assetDao.findById(tenantId, assetId.getId());
         try {
         try {
             List<EntityView> entityViews = entityViewService.findEntityViewsByTenantIdAndEntityIdAsync(asset.getTenantId(), assetId).get();
             List<EntityView> entityViews = entityViewService.findEntityViewsByTenantIdAndEntityIdAsync(asset.getTenantId(), assetId).get();
             if (entityViews != null && !entityViews.isEmpty()) {
             if (entityViews != null && !entityViews.isEmpty()) {
@@ -153,7 +153,7 @@ public class BaseAssetService extends AbstractEntityService implements AssetServ
         Cache cache = cacheManager.getCache(ASSET_CACHE);
         Cache cache = cacheManager.getCache(ASSET_CACHE);
         cache.evict(list);
         cache.evict(list);
 
 
-        assetDao.removeById(assetId.getId());
+        assetDao.removeById(tenantId, assetId.getId());
     }
     }
 
 
     @Override
     @Override
@@ -187,7 +187,7 @@ public class BaseAssetService extends AbstractEntityService implements AssetServ
     public void deleteAssetsByTenantId(TenantId tenantId) {
     public void deleteAssetsByTenantId(TenantId tenantId) {
         log.trace("Executing deleteAssetsByTenantId, tenantId [{}]", tenantId);
         log.trace("Executing deleteAssetsByTenantId, tenantId [{}]", tenantId);
         validateId(tenantId, INCORRECT_TENANT_ID + tenantId);
         validateId(tenantId, INCORRECT_TENANT_ID + tenantId);
-        tenantAssetsRemover.removeEntities(tenantId);
+        tenantAssetsRemover.removeEntities(tenantId, tenantId);
     }
     }
 
 
     @Override
     @Override
@@ -225,24 +225,24 @@ public class BaseAssetService extends AbstractEntityService implements AssetServ
         log.trace("Executing unassignCustomerAssets, tenantId [{}], customerId [{}]", tenantId, customerId);
         log.trace("Executing unassignCustomerAssets, tenantId [{}], customerId [{}]", tenantId, customerId);
         validateId(tenantId, INCORRECT_TENANT_ID + tenantId);
         validateId(tenantId, INCORRECT_TENANT_ID + tenantId);
         validateId(customerId, INCORRECT_CUSTOMER_ID + customerId);
         validateId(customerId, INCORRECT_CUSTOMER_ID + customerId);
-        new CustomerAssetsUnassigner(tenantId).removeEntities(customerId);
+        customerAssetsUnasigner.removeEntities(tenantId, customerId);
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<List<Asset>> findAssetsByQuery(AssetSearchQuery query) {
-        ListenableFuture<List<EntityRelation>> relations = relationService.findByQuery(query.toEntitySearchQuery());
+    public ListenableFuture<List<Asset>> findAssetsByQuery(TenantId tenantId, AssetSearchQuery query) {
+        ListenableFuture<List<EntityRelation>> relations = relationService.findByQuery(tenantId, query.toEntitySearchQuery());
         ListenableFuture<List<Asset>> assets = Futures.transformAsync(relations, r -> {
         ListenableFuture<List<Asset>> assets = Futures.transformAsync(relations, r -> {
             EntitySearchDirection direction = query.toEntitySearchQuery().getParameters().getDirection();
             EntitySearchDirection direction = query.toEntitySearchQuery().getParameters().getDirection();
             List<ListenableFuture<Asset>> futures = new ArrayList<>();
             List<ListenableFuture<Asset>> futures = new ArrayList<>();
             for (EntityRelation relation : r) {
             for (EntityRelation relation : r) {
                 EntityId entityId = direction == EntitySearchDirection.FROM ? relation.getTo() : relation.getFrom();
                 EntityId entityId = direction == EntitySearchDirection.FROM ? relation.getTo() : relation.getFrom();
                 if (entityId.getEntityType() == EntityType.ASSET) {
                 if (entityId.getEntityType() == EntityType.ASSET) {
-                    futures.add(findAssetByIdAsync(new AssetId(entityId.getId())));
+                    futures.add(findAssetByIdAsync(tenantId, new AssetId(entityId.getId())));
                 }
                 }
             }
             }
             return Futures.successfulAsList(futures);
             return Futures.successfulAsList(futures);
         });
         });
-        assets = Futures.transform(assets, (Function<List<Asset>, List<Asset>>)assetList ->
+        assets = Futures.transform(assets, assetList ->
             assetList == null ? Collections.emptyList() : assetList.stream().filter(asset -> query.getAssetTypes().contains(asset.getType())).collect(Collectors.toList())
             assetList == null ? Collections.emptyList() : assetList.stream().filter(asset -> query.getAssetTypes().contains(asset.getType())).collect(Collectors.toList())
         );
         );
         return assets;
         return assets;
@@ -254,7 +254,7 @@ public class BaseAssetService extends AbstractEntityService implements AssetServ
         validateId(tenantId, INCORRECT_TENANT_ID + tenantId);
         validateId(tenantId, INCORRECT_TENANT_ID + tenantId);
         ListenableFuture<List<EntitySubtype>> tenantAssetTypes = assetDao.findTenantAssetTypesAsync(tenantId.getId());
         ListenableFuture<List<EntitySubtype>> tenantAssetTypes = assetDao.findTenantAssetTypesAsync(tenantId.getId());
         return Futures.transform(tenantAssetTypes,
         return Futures.transform(tenantAssetTypes,
-                (Function<List<EntitySubtype>, List<EntitySubtype>>) assetTypes -> {
+                assetTypes -> {
                     assetTypes.sort(Comparator.comparing(EntitySubtype::getType));
                     assetTypes.sort(Comparator.comparing(EntitySubtype::getType));
                     return assetTypes;
                     return assetTypes;
                 });
                 });
@@ -264,7 +264,7 @@ public class BaseAssetService extends AbstractEntityService implements AssetServ
             new DataValidator<Asset>() {
             new DataValidator<Asset>() {
 
 
                 @Override
                 @Override
-                protected void validateCreate(Asset asset) {
+                protected void validateCreate(TenantId tenantId, Asset asset) {
                     assetDao.findAssetsByTenantIdAndName(asset.getTenantId().getId(), asset.getName()).ifPresent(
                     assetDao.findAssetsByTenantIdAndName(asset.getTenantId().getId(), asset.getName()).ifPresent(
                             d -> {
                             d -> {
                                 throw new DataValidationException("Asset with such name already exists!");
                                 throw new DataValidationException("Asset with such name already exists!");
@@ -273,7 +273,7 @@ public class BaseAssetService extends AbstractEntityService implements AssetServ
                 }
                 }
 
 
                 @Override
                 @Override
-                protected void validateUpdate(Asset asset) {
+                protected void validateUpdate(TenantId tenantId, Asset asset) {
                     assetDao.findAssetsByTenantIdAndName(asset.getTenantId().getId(), asset.getName()).ifPresent(
                     assetDao.findAssetsByTenantIdAndName(asset.getTenantId().getId(), asset.getName()).ifPresent(
                             d -> {
                             d -> {
                                 if (!d.getId().equals(asset.getId())) {
                                 if (!d.getId().equals(asset.getId())) {
@@ -284,7 +284,7 @@ public class BaseAssetService extends AbstractEntityService implements AssetServ
                 }
                 }
 
 
                 @Override
                 @Override
-                protected void validateDataImpl(Asset asset) {
+                protected void validateDataImpl(TenantId tenantId, Asset asset) {
                     if (StringUtils.isEmpty(asset.getType())) {
                     if (StringUtils.isEmpty(asset.getType())) {
                         throw new DataValidationException("Asset type should be specified!");
                         throw new DataValidationException("Asset type should be specified!");
                     }
                     }
@@ -294,7 +294,7 @@ public class BaseAssetService extends AbstractEntityService implements AssetServ
                     if (asset.getTenantId() == null) {
                     if (asset.getTenantId() == null) {
                         throw new DataValidationException("Asset should be assigned to tenant!");
                         throw new DataValidationException("Asset should be assigned to tenant!");
                     } else {
                     } else {
-                        Tenant tenant = tenantDao.findById(asset.getTenantId().getId());
+                        Tenant tenant = tenantDao.findById(tenantId, asset.getTenantId().getId());
                         if (tenant == null) {
                         if (tenant == null) {
                             throw new DataValidationException("Asset is referencing to non-existent tenant!");
                             throw new DataValidationException("Asset is referencing to non-existent tenant!");
                         }
                         }
@@ -302,7 +302,7 @@ public class BaseAssetService extends AbstractEntityService implements AssetServ
                     if (asset.getCustomerId() == null) {
                     if (asset.getCustomerId() == null) {
                         asset.setCustomerId(new CustomerId(NULL_UUID));
                         asset.setCustomerId(new CustomerId(NULL_UUID));
                     } else if (!asset.getCustomerId().getId().equals(NULL_UUID)) {
                     } else if (!asset.getCustomerId().getId().equals(NULL_UUID)) {
-                        Customer customer = customerDao.findById(asset.getCustomerId().getId());
+                        Customer customer = customerDao.findById(tenantId, asset.getCustomerId().getId());
                         if (customer == null) {
                         if (customer == null) {
                             throw new DataValidationException("Can't assign asset to non-existent customer!");
                             throw new DataValidationException("Can't assign asset to non-existent customer!");
                         }
                         }
@@ -314,35 +314,29 @@ public class BaseAssetService extends AbstractEntityService implements AssetServ
             };
             };
 
 
     private PaginatedRemover<TenantId, Asset> tenantAssetsRemover =
     private PaginatedRemover<TenantId, Asset> tenantAssetsRemover =
-            new PaginatedRemover<TenantId, Asset>() {
+        new PaginatedRemover<TenantId, Asset>() {
 
 
-                @Override
-                protected List<Asset> findEntities(TenantId id, TextPageLink pageLink) {
-                    return assetDao.findAssetsByTenantId(id.getId(), pageLink);
-                }
-
-                @Override
-                protected void removeEntity(Asset entity) {
-                    deleteAsset(new AssetId(entity.getId().getId()));
-                }
-            };
+            @Override
+            protected List<Asset> findEntities(TenantId tenantId, TenantId id, TextPageLink pageLink) {
+                return assetDao.findAssetsByTenantId(id.getId(), pageLink);
+            }
 
 
-    class CustomerAssetsUnassigner extends PaginatedRemover<CustomerId, Asset> {
+            @Override
+            protected void removeEntity(TenantId tenantId, Asset entity) {
+                deleteAsset(tenantId, new AssetId(entity.getId().getId()));
+            }
+        };
 
 
-        private TenantId tenantId;
-
-        CustomerAssetsUnassigner(TenantId tenantId) {
-            this.tenantId = tenantId;
-        }
+    private PaginatedRemover<CustomerId, Asset> customerAssetsUnasigner = new PaginatedRemover<CustomerId, Asset>() {
 
 
         @Override
         @Override
-        protected List<Asset> findEntities(CustomerId id, TextPageLink pageLink) {
+        protected List<Asset> findEntities(TenantId tenantId, CustomerId id, TextPageLink pageLink) {
             return assetDao.findAssetsByTenantIdAndCustomerId(tenantId.getId(), id.getId(), pageLink);
             return assetDao.findAssetsByTenantIdAndCustomerId(tenantId.getId(), id.getId(), pageLink);
         }
         }
 
 
         @Override
         @Override
-        protected void removeEntity(Asset entity) {
-            unassignAssetFromCustomer(new AssetId(entity.getId().getId()));
+        protected void removeEntity(TenantId tenantId, Asset entity) {
+            unassignAssetFromCustomer(tenantId, new AssetId(entity.getId().getId()));
         }
         }
-    }
+    };
 }
 }

@@ -28,6 +28,7 @@ import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.data.EntitySubtype;
 import org.thingsboard.server.common.data.EntitySubtype;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.asset.Asset;
 import org.thingsboard.server.common.data.asset.Asset;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.model.EntitySubtypeEntity;
 import org.thingsboard.server.dao.model.EntitySubtypeEntity;
@@ -77,19 +78,19 @@ public class CassandraAssetDao extends CassandraAbstractSearchTextDao<AssetEntit
     }
     }
 
 
     @Override
     @Override
-    public Asset save(Asset domain) {
-        Asset savedAsset = super.save(domain);
+    public Asset save(TenantId tenantId, Asset domain) {
+        Asset savedAsset = super.save(tenantId, domain);
         EntitySubtype entitySubtype = new EntitySubtype(savedAsset.getTenantId(), EntityType.ASSET, savedAsset.getType());
         EntitySubtype entitySubtype = new EntitySubtype(savedAsset.getTenantId(), EntityType.ASSET, savedAsset.getType());
         EntitySubtypeEntity entitySubtypeEntity = new EntitySubtypeEntity(entitySubtype);
         EntitySubtypeEntity entitySubtypeEntity = new EntitySubtypeEntity(entitySubtype);
         Statement saveStatement = cluster.getMapper(EntitySubtypeEntity.class).saveQuery(entitySubtypeEntity);
         Statement saveStatement = cluster.getMapper(EntitySubtypeEntity.class).saveQuery(entitySubtypeEntity);
-        executeWrite(saveStatement);
+        executeWrite(tenantId, saveStatement);
         return savedAsset;
         return savedAsset;
     }
     }
 
 
     @Override
     @Override
     public List<Asset> findAssetsByTenantId(UUID tenantId, TextPageLink pageLink) {
     public List<Asset> findAssetsByTenantId(UUID tenantId, TextPageLink pageLink) {
         log.debug("Try to find assets by tenantId [{}] and pageLink [{}]", tenantId, pageLink);
         log.debug("Try to find assets by tenantId [{}] and pageLink [{}]", tenantId, pageLink);
-        List<AssetEntity> assetEntities = findPageWithTextSearch(ASSET_BY_TENANT_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
+        List<AssetEntity> assetEntities = findPageWithTextSearch(new TenantId(tenantId), ASSET_BY_TENANT_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
                 Collections.singletonList(eq(ASSET_TENANT_ID_PROPERTY, tenantId)), pageLink);
                 Collections.singletonList(eq(ASSET_TENANT_ID_PROPERTY, tenantId)), pageLink);
 
 
         log.trace("Found assets [{}] by tenantId [{}] and pageLink [{}]", assetEntities, tenantId, pageLink);
         log.trace("Found assets [{}] by tenantId [{}] and pageLink [{}]", assetEntities, tenantId, pageLink);
@@ -99,7 +100,7 @@ public class CassandraAssetDao extends CassandraAbstractSearchTextDao<AssetEntit
     @Override
     @Override
     public List<Asset> findAssetsByTenantIdAndType(UUID tenantId, String type, TextPageLink pageLink) {
     public List<Asset> findAssetsByTenantIdAndType(UUID tenantId, String type, TextPageLink pageLink) {
         log.debug("Try to find assets by tenantId [{}], type [{}] and pageLink [{}]", tenantId, type, pageLink);
         log.debug("Try to find assets by tenantId [{}], type [{}] and pageLink [{}]", tenantId, type, pageLink);
-        List<AssetEntity> assetEntities = findPageWithTextSearch(ASSET_BY_TENANT_BY_TYPE_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
+        List<AssetEntity> assetEntities = findPageWithTextSearch(new TenantId(tenantId), ASSET_BY_TENANT_BY_TYPE_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
                 Arrays.asList(eq(ASSET_TYPE_PROPERTY, type),
                 Arrays.asList(eq(ASSET_TYPE_PROPERTY, type),
                         eq(ASSET_TENANT_ID_PROPERTY, tenantId)), pageLink);
                         eq(ASSET_TENANT_ID_PROPERTY, tenantId)), pageLink);
         log.trace("Found assets [{}] by tenantId [{}], type [{}] and pageLink [{}]", assetEntities, tenantId, type, pageLink);
         log.trace("Found assets [{}] by tenantId [{}], type [{}] and pageLink [{}]", assetEntities, tenantId, type, pageLink);
@@ -112,13 +113,13 @@ public class CassandraAssetDao extends CassandraAbstractSearchTextDao<AssetEntit
         Select.Where query = select.where();
         Select.Where query = select.where();
         query.and(eq(ASSET_TENANT_ID_PROPERTY, tenantId));
         query.and(eq(ASSET_TENANT_ID_PROPERTY, tenantId));
         query.and(in(ID_PROPERTY, assetIds));
         query.and(in(ID_PROPERTY, assetIds));
-        return findListByStatementAsync(query);
+        return findListByStatementAsync(new TenantId(tenantId), query);
     }
     }
 
 
     @Override
     @Override
     public List<Asset> findAssetsByTenantIdAndCustomerId(UUID tenantId, UUID customerId, TextPageLink pageLink) {
     public List<Asset> findAssetsByTenantIdAndCustomerId(UUID tenantId, UUID customerId, TextPageLink pageLink) {
         log.debug("Try to find assets by tenantId [{}], customerId[{}] and pageLink [{}]", tenantId, customerId, pageLink);
         log.debug("Try to find assets by tenantId [{}], customerId[{}] and pageLink [{}]", tenantId, customerId, pageLink);
-        List<AssetEntity> assetEntities = findPageWithTextSearch(ASSET_BY_CUSTOMER_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
+        List<AssetEntity> assetEntities = findPageWithTextSearch(new TenantId(tenantId), ASSET_BY_CUSTOMER_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
                 Arrays.asList(eq(ASSET_CUSTOMER_ID_PROPERTY, customerId),
                 Arrays.asList(eq(ASSET_CUSTOMER_ID_PROPERTY, customerId),
                         eq(ASSET_TENANT_ID_PROPERTY, tenantId)),
                         eq(ASSET_TENANT_ID_PROPERTY, tenantId)),
                 pageLink);
                 pageLink);
@@ -130,7 +131,7 @@ public class CassandraAssetDao extends CassandraAbstractSearchTextDao<AssetEntit
     @Override
     @Override
     public List<Asset> findAssetsByTenantIdAndCustomerIdAndType(UUID tenantId, UUID customerId, String type, TextPageLink pageLink) {
     public List<Asset> findAssetsByTenantIdAndCustomerIdAndType(UUID tenantId, UUID customerId, String type, TextPageLink pageLink) {
         log.debug("Try to find assets by tenantId [{}], customerId [{}], type [{}] and pageLink [{}]", tenantId, customerId, type, pageLink);
         log.debug("Try to find assets by tenantId [{}], customerId [{}], type [{}] and pageLink [{}]", tenantId, customerId, type, pageLink);
-        List<AssetEntity> assetEntities = findPageWithTextSearch(ASSET_BY_CUSTOMER_BY_TYPE_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
+        List<AssetEntity> assetEntities = findPageWithTextSearch(new TenantId(tenantId), ASSET_BY_CUSTOMER_BY_TYPE_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
                 Arrays.asList(eq(ASSET_TYPE_PROPERTY, type),
                 Arrays.asList(eq(ASSET_TYPE_PROPERTY, type),
                         eq(ASSET_CUSTOMER_ID_PROPERTY, customerId),
                         eq(ASSET_CUSTOMER_ID_PROPERTY, customerId),
                         eq(ASSET_TENANT_ID_PROPERTY, tenantId)),
                         eq(ASSET_TENANT_ID_PROPERTY, tenantId)),
@@ -148,7 +149,7 @@ public class CassandraAssetDao extends CassandraAbstractSearchTextDao<AssetEntit
         query.and(eq(ASSET_TENANT_ID_PROPERTY, tenantId));
         query.and(eq(ASSET_TENANT_ID_PROPERTY, tenantId));
         query.and(eq(ASSET_CUSTOMER_ID_PROPERTY, customerId));
         query.and(eq(ASSET_CUSTOMER_ID_PROPERTY, customerId));
         query.and(in(ID_PROPERTY, assetIds));
         query.and(in(ID_PROPERTY, assetIds));
-        return findListByStatementAsync(query);
+        return findListByStatementAsync(new TenantId(tenantId), query);
     }
     }
 
 
     @Override
     @Override
@@ -157,7 +158,7 @@ public class CassandraAssetDao extends CassandraAbstractSearchTextDao<AssetEntit
         Select.Where query = select.where();
         Select.Where query = select.where();
         query.and(eq(ASSET_TENANT_ID_PROPERTY, tenantId));
         query.and(eq(ASSET_TENANT_ID_PROPERTY, tenantId));
         query.and(eq(ASSET_NAME_PROPERTY, assetName));
         query.and(eq(ASSET_NAME_PROPERTY, assetName));
-        AssetEntity assetEntity = (AssetEntity) findOneByStatement(query);
+        AssetEntity assetEntity = (AssetEntity) findOneByStatement(new TenantId(tenantId), query);
         return Optional.ofNullable(DaoUtil.getData(assetEntity));
         return Optional.ofNullable(DaoUtil.getData(assetEntity));
     }
     }
 
 
@@ -168,7 +169,7 @@ public class CassandraAssetDao extends CassandraAbstractSearchTextDao<AssetEntit
         query.and(eq(ENTITY_SUBTYPE_TENANT_ID_PROPERTY, tenantId));
         query.and(eq(ENTITY_SUBTYPE_TENANT_ID_PROPERTY, tenantId));
         query.and(eq(ENTITY_SUBTYPE_ENTITY_TYPE_PROPERTY, EntityType.ASSET));
         query.and(eq(ENTITY_SUBTYPE_ENTITY_TYPE_PROPERTY, EntityType.ASSET));
         query.setConsistencyLevel(cluster.getDefaultReadConsistencyLevel());
         query.setConsistencyLevel(cluster.getDefaultReadConsistencyLevel());
-        ResultSetFuture resultSetFuture = executeAsyncRead(query);
+        ResultSetFuture resultSetFuture = executeAsyncRead(new TenantId(tenantId), query);
         return Futures.transform(resultSetFuture, new Function<ResultSet, List<EntitySubtype>>() {
         return Futures.transform(resultSetFuture, new Function<ResultSet, List<EntitySubtype>>() {
             @Nullable
             @Nullable
             @Override
             @Override

@@ -17,6 +17,7 @@ package org.thingsboard.server.dao.attributes;
 
 
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListenableFuture;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.kv.AttributeKvEntry;
 import org.thingsboard.server.common.data.kv.AttributeKvEntry;
 
 
 import java.util.Collection;
 import java.util.Collection;
@@ -28,13 +29,13 @@ import java.util.Optional;
  */
  */
 public interface AttributesDao {
 public interface AttributesDao {
 
 
-    ListenableFuture<Optional<AttributeKvEntry>> find(EntityId entityId, String attributeType, String attributeKey);
+    ListenableFuture<Optional<AttributeKvEntry>> find(TenantId tenantId, EntityId entityId, String attributeType, String attributeKey);
 
 
-    ListenableFuture<List<AttributeKvEntry>> find(EntityId entityId, String attributeType, Collection<String> attributeKey);
+    ListenableFuture<List<AttributeKvEntry>> find(TenantId tenantId, EntityId entityId, String attributeType, Collection<String> attributeKey);
 
 
-    ListenableFuture<List<AttributeKvEntry>> findAll(EntityId entityId, String attributeType);
+    ListenableFuture<List<AttributeKvEntry>> findAll(TenantId tenantId, EntityId entityId, String attributeType);
 
 
-    ListenableFuture<Void> save(EntityId entityId, String attributeType, AttributeKvEntry attribute);
+    ListenableFuture<Void> save(TenantId tenantId, EntityId entityId, String attributeType, AttributeKvEntry attribute);
 
 
-    ListenableFuture<List<Void>> removeAll(EntityId entityId, String attributeType, List<String> keys);
+    ListenableFuture<List<Void>> removeAll(TenantId tenantId, EntityId entityId, String attributeType, List<String> keys);
 }
 }

@@ -17,6 +17,7 @@ package org.thingsboard.server.dao.attributes;
 
 
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListenableFuture;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.kv.AttributeKvEntry;
 import org.thingsboard.server.common.data.kv.AttributeKvEntry;
 
 
 import java.util.Collection;
 import java.util.Collection;
@@ -28,13 +29,13 @@ import java.util.Optional;
  */
  */
 public interface AttributesService {
 public interface AttributesService {
 
 
-    ListenableFuture<Optional<AttributeKvEntry>> find(EntityId entityId, String scope, String attributeKey);
+    ListenableFuture<Optional<AttributeKvEntry>> find(TenantId tenantId, EntityId entityId, String scope, String attributeKey);
 
 
-    ListenableFuture<List<AttributeKvEntry>> find(EntityId entityId, String scope, Collection<String> attributeKeys);
+    ListenableFuture<List<AttributeKvEntry>> find(TenantId tenantId, EntityId entityId, String scope, Collection<String> attributeKeys);
 
 
-    ListenableFuture<List<AttributeKvEntry>> findAll(EntityId entityId, String scope);
+    ListenableFuture<List<AttributeKvEntry>> findAll(TenantId tenantId, EntityId entityId, String scope);
 
 
-    ListenableFuture<List<Void>> save(EntityId entityId, String scope, List<AttributeKvEntry> attributes);
+    ListenableFuture<List<Void>> save(TenantId tenantId, EntityId entityId, String scope, List<AttributeKvEntry> attributes);
 
 
-    ListenableFuture<List<Void>> removeAll(EntityId entityId, String scope, List<String> attributeKeys);
+    ListenableFuture<List<Void>> removeAll(TenantId tenantId, EntityId entityId, String scope, List<String> attributeKeys);
 }
 }

@@ -21,6 +21,7 @@ import com.google.common.util.concurrent.ListenableFuture;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.kv.AttributeKvEntry;
 import org.thingsboard.server.common.data.kv.AttributeKvEntry;
 import org.thingsboard.server.dao.exception.IncorrectParameterException;
 import org.thingsboard.server.dao.exception.IncorrectParameterException;
 import org.thingsboard.server.dao.service.Validator;
 import org.thingsboard.server.dao.service.Validator;
@@ -39,40 +40,40 @@ public class BaseAttributesService implements AttributesService {
     private AttributesDao attributesDao;
     private AttributesDao attributesDao;
 
 
     @Override
     @Override
-    public ListenableFuture<Optional<AttributeKvEntry>> find(EntityId entityId, String scope, String attributeKey) {
+    public ListenableFuture<Optional<AttributeKvEntry>> find(TenantId tenantId, EntityId entityId, String scope, String attributeKey) {
         validate(entityId, scope);
         validate(entityId, scope);
         Validator.validateString(attributeKey, "Incorrect attribute key " + attributeKey);
         Validator.validateString(attributeKey, "Incorrect attribute key " + attributeKey);
-        return attributesDao.find(entityId, scope, attributeKey);
+        return attributesDao.find(tenantId, entityId, scope, attributeKey);
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<List<AttributeKvEntry>> find(EntityId entityId, String scope, Collection<String> attributeKeys) {
+    public ListenableFuture<List<AttributeKvEntry>> find(TenantId tenantId, EntityId entityId, String scope, Collection<String> attributeKeys) {
         validate(entityId, scope);
         validate(entityId, scope);
         attributeKeys.forEach(attributeKey -> Validator.validateString(attributeKey, "Incorrect attribute key " + attributeKey));
         attributeKeys.forEach(attributeKey -> Validator.validateString(attributeKey, "Incorrect attribute key " + attributeKey));
-        return attributesDao.find(entityId, scope, attributeKeys);
+        return attributesDao.find(tenantId, entityId, scope, attributeKeys);
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<List<AttributeKvEntry>> findAll(EntityId entityId, String scope) {
+    public ListenableFuture<List<AttributeKvEntry>> findAll(TenantId tenantId, EntityId entityId, String scope) {
         validate(entityId, scope);
         validate(entityId, scope);
-        return attributesDao.findAll(entityId, scope);
+        return attributesDao.findAll(tenantId, entityId, scope);
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<List<Void>> save(EntityId entityId, String scope, List<AttributeKvEntry> attributes) {
+    public ListenableFuture<List<Void>> save(TenantId tenantId, EntityId entityId, String scope, List<AttributeKvEntry> attributes) {
         validate(entityId, scope);
         validate(entityId, scope);
         attributes.forEach(attribute -> validate(attribute));
         attributes.forEach(attribute -> validate(attribute));
         List<ListenableFuture<Void>> futures = Lists.newArrayListWithExpectedSize(attributes.size());
         List<ListenableFuture<Void>> futures = Lists.newArrayListWithExpectedSize(attributes.size());
         for (AttributeKvEntry attribute : attributes) {
         for (AttributeKvEntry attribute : attributes) {
-            futures.add(attributesDao.save(entityId, scope, attribute));
+            futures.add(attributesDao.save(tenantId, entityId, scope, attribute));
         }
         }
         return Futures.allAsList(futures);
         return Futures.allAsList(futures);
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<List<Void>> removeAll(EntityId entityId, String scope, List<String> keys) {
+    public ListenableFuture<List<Void>> removeAll(TenantId tenantId, EntityId entityId, String scope, List<String> keys) {
         validate(entityId, scope);
         validate(entityId, scope);
-        return attributesDao.removeAll(entityId, scope, keys);
+        return attributesDao.removeAll(tenantId, entityId, scope, keys);
     }
     }
 
 
     private static void validate(EntityId id, String scope) {
     private static void validate(EntityId id, String scope) {

@@ -28,6 +28,7 @@ import com.google.common.util.concurrent.ListenableFuture;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
 import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.kv.AttributeKvEntry;
 import org.thingsboard.server.common.data.kv.AttributeKvEntry;
 import org.thingsboard.server.common.data.kv.BaseAttributeKvEntry;
 import org.thingsboard.server.common.data.kv.BaseAttributeKvEntry;
 import org.thingsboard.server.dao.model.ModelConstants;
 import org.thingsboard.server.dao.model.ModelConstants;
@@ -73,22 +74,22 @@ public class CassandraBaseAttributesDao extends CassandraAbstractAsyncDao implem
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<Optional<AttributeKvEntry>> find(EntityId entityId, String attributeType, String attributeKey) {
+    public ListenableFuture<Optional<AttributeKvEntry>> find(TenantId tenantId, EntityId entityId, String attributeType, String attributeKey) {
         Select.Where select = select().from(ATTRIBUTES_KV_CF)
         Select.Where select = select().from(ATTRIBUTES_KV_CF)
                 .where(eq(ENTITY_TYPE_COLUMN, entityId.getEntityType()))
                 .where(eq(ENTITY_TYPE_COLUMN, entityId.getEntityType()))
                 .and(eq(ENTITY_ID_COLUMN, entityId.getId()))
                 .and(eq(ENTITY_ID_COLUMN, entityId.getId()))
                 .and(eq(ATTRIBUTE_TYPE_COLUMN, attributeType))
                 .and(eq(ATTRIBUTE_TYPE_COLUMN, attributeType))
                 .and(eq(ATTRIBUTE_KEY_COLUMN, attributeKey));
                 .and(eq(ATTRIBUTE_KEY_COLUMN, attributeKey));
         log.trace("Generated query [{}] for entityId {} and key {}", select, entityId, attributeKey);
         log.trace("Generated query [{}] for entityId {} and key {}", select, entityId, attributeKey);
-        return Futures.transform(executeAsyncRead(select), (Function<? super ResultSet, ? extends Optional<AttributeKvEntry>>) input ->
+        return Futures.transform(executeAsyncRead(tenantId, select), (Function<? super ResultSet, ? extends Optional<AttributeKvEntry>>) input ->
                         Optional.ofNullable(convertResultToAttributesKvEntry(attributeKey, input.one()))
                         Optional.ofNullable(convertResultToAttributesKvEntry(attributeKey, input.one()))
                 , readResultsProcessingExecutor);
                 , readResultsProcessingExecutor);
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<List<AttributeKvEntry>> find(EntityId entityId, String attributeType, Collection<String> attributeKeys) {
+    public ListenableFuture<List<AttributeKvEntry>> find(TenantId tenantId, EntityId entityId, String attributeType, Collection<String> attributeKeys) {
         List<ListenableFuture<Optional<AttributeKvEntry>>> entries = new ArrayList<>();
         List<ListenableFuture<Optional<AttributeKvEntry>>> entries = new ArrayList<>();
-        attributeKeys.forEach(attributeKey -> entries.add(find(entityId, attributeType, attributeKey)));
+        attributeKeys.forEach(attributeKey -> entries.add(find(tenantId, entityId, attributeType, attributeKey)));
         return Futures.transform(Futures.allAsList(entries), (Function<List<Optional<AttributeKvEntry>>, ? extends List<AttributeKvEntry>>) input -> {
         return Futures.transform(Futures.allAsList(entries), (Function<List<Optional<AttributeKvEntry>>, ? extends List<AttributeKvEntry>>) input -> {
             List<AttributeKvEntry> result = new ArrayList<>();
             List<AttributeKvEntry> result = new ArrayList<>();
             input.stream().filter(opt -> opt.isPresent()).forEach(opt -> result.add(opt.get()));
             input.stream().filter(opt -> opt.isPresent()).forEach(opt -> result.add(opt.get()));
@@ -98,19 +99,19 @@ public class CassandraBaseAttributesDao extends CassandraAbstractAsyncDao implem
 
 
 
 
     @Override
     @Override
-    public ListenableFuture<List<AttributeKvEntry>> findAll(EntityId entityId, String attributeType) {
+    public ListenableFuture<List<AttributeKvEntry>> findAll(TenantId tenantId, EntityId entityId, String attributeType) {
         Select.Where select = select().from(ATTRIBUTES_KV_CF)
         Select.Where select = select().from(ATTRIBUTES_KV_CF)
                 .where(eq(ENTITY_TYPE_COLUMN, entityId.getEntityType()))
                 .where(eq(ENTITY_TYPE_COLUMN, entityId.getEntityType()))
                 .and(eq(ENTITY_ID_COLUMN, entityId.getId()))
                 .and(eq(ENTITY_ID_COLUMN, entityId.getId()))
                 .and(eq(ATTRIBUTE_TYPE_COLUMN, attributeType));
                 .and(eq(ATTRIBUTE_TYPE_COLUMN, attributeType));
         log.trace("Generated query [{}] for entityId {} and attributeType {}", select, entityId, attributeType);
         log.trace("Generated query [{}] for entityId {} and attributeType {}", select, entityId, attributeType);
-        return Futures.transform(executeAsyncRead(select), (Function<? super ResultSet, ? extends List<AttributeKvEntry>>) input ->
+        return Futures.transform(executeAsyncRead(tenantId, select), (Function<? super ResultSet, ? extends List<AttributeKvEntry>>) input ->
                         convertResultToAttributesKvEntryList(input)
                         convertResultToAttributesKvEntryList(input)
                 , readResultsProcessingExecutor);
                 , readResultsProcessingExecutor);
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<Void> save(EntityId entityId, String attributeType, AttributeKvEntry attribute) {
+    public ListenableFuture<Void> save(TenantId tenantId, EntityId entityId, String attributeType, AttributeKvEntry attribute) {
         BoundStatement stmt = getSaveStmt().bind();
         BoundStatement stmt = getSaveStmt().bind();
         stmt.setString(0, entityId.getEntityType().name());
         stmt.setString(0, entityId.getEntityType().name());
         stmt.setUUID(1, entityId.getId());
         stmt.setUUID(1, entityId.getId());
@@ -137,26 +138,26 @@ public class CassandraBaseAttributesDao extends CassandraAbstractAsyncDao implem
             stmt.setToNull(8);
             stmt.setToNull(8);
         }
         }
         log.trace("Generated save stmt [{}] for entityId {} and attributeType {} and attribute", stmt, entityId, attributeType, attribute);
         log.trace("Generated save stmt [{}] for entityId {} and attributeType {} and attribute", stmt, entityId, attributeType, attribute);
-        return getFuture(executeAsyncWrite(stmt), rs -> null);
+        return getFuture(executeAsyncWrite(tenantId, stmt), rs -> null);
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<List<Void>> removeAll(EntityId entityId, String attributeType, List<String> keys) {
+    public ListenableFuture<List<Void>> removeAll(TenantId tenantId, EntityId entityId, String attributeType, List<String> keys) {
         List<ListenableFuture<Void>> futures = keys
         List<ListenableFuture<Void>> futures = keys
                 .stream()
                 .stream()
-                .map(key -> delete(entityId, attributeType, key))
+                .map(key -> delete(tenantId, entityId, attributeType, key))
                 .collect(Collectors.toList());
                 .collect(Collectors.toList());
         return Futures.allAsList(futures);
         return Futures.allAsList(futures);
     }
     }
 
 
-    private ListenableFuture<Void> delete(EntityId entityId, String attributeType, String key) {
+    private ListenableFuture<Void> delete(TenantId tenantId, EntityId entityId, String attributeType, String key) {
         Statement delete = QueryBuilder.delete().all().from(ModelConstants.ATTRIBUTES_KV_CF)
         Statement delete = QueryBuilder.delete().all().from(ModelConstants.ATTRIBUTES_KV_CF)
                 .where(eq(ENTITY_TYPE_COLUMN, entityId.getEntityType()))
                 .where(eq(ENTITY_TYPE_COLUMN, entityId.getEntityType()))
                 .and(eq(ENTITY_ID_COLUMN, entityId.getId()))
                 .and(eq(ENTITY_ID_COLUMN, entityId.getId()))
                 .and(eq(ATTRIBUTE_TYPE_COLUMN, attributeType))
                 .and(eq(ATTRIBUTE_TYPE_COLUMN, attributeType))
                 .and(eq(ATTRIBUTE_KEY_COLUMN, key));
                 .and(eq(ATTRIBUTE_KEY_COLUMN, key));
         log.debug("Remove request: {}", delete.toString());
         log.debug("Remove request: {}", delete.toString());
-        return getFuture(executeAsyncWrite(delete), rs -> null);
+        return getFuture(executeAsyncWrite(tenantId, delete), rs -> null);
     }
     }
 
 
     private PreparedStatement getSaveStmt() {
     private PreparedStatement getSaveStmt() {

@@ -128,7 +128,7 @@ public class AuditLogServiceImpl implements AuditLogService {
                 entityName = entity.getName();
                 entityName = entity.getName();
             } else {
             } else {
                 try {
                 try {
-                    entityName = entityService.fetchEntityNameAsync(entityId).get();
+                    entityName = entityService.fetchEntityNameAsync(tenantId, entityId).get();
                 } catch (Exception ex) {}
                 } catch (Exception ex) {}
             }
             }
             if (e != null) {
             if (e != null) {
@@ -315,7 +315,7 @@ public class AuditLogServiceImpl implements AuditLogService {
         AuditLog auditLogEntry = createAuditLogEntry(tenantId, entityId, entityName, customerId, userId, userName,
         AuditLog auditLogEntry = createAuditLogEntry(tenantId, entityId, entityName, customerId, userId, userName,
                 actionType, actionData, actionStatus, actionFailureDetails);
                 actionType, actionData, actionStatus, actionFailureDetails);
         log.trace("Executing logAction [{}]", auditLogEntry);
         log.trace("Executing logAction [{}]", auditLogEntry);
-        auditLogValidator.validate(auditLogEntry);
+        auditLogValidator.validate(auditLogEntry, AuditLog::getTenantId);
         List<ListenableFuture<Void>> futures = Lists.newArrayListWithExpectedSize(INSERTS_PER_ENTRY);
         List<ListenableFuture<Void>> futures = Lists.newArrayListWithExpectedSize(INSERTS_PER_ENTRY);
         futures.add(auditLogDao.savePartitionsByTenantId(auditLogEntry));
         futures.add(auditLogDao.savePartitionsByTenantId(auditLogEntry));
         futures.add(auditLogDao.saveByTenantId(auditLogEntry));
         futures.add(auditLogDao.saveByTenantId(auditLogEntry));
@@ -331,7 +331,7 @@ public class AuditLogServiceImpl implements AuditLogService {
     private DataValidator<AuditLog> auditLogValidator =
     private DataValidator<AuditLog> auditLogValidator =
             new DataValidator<AuditLog>() {
             new DataValidator<AuditLog>() {
                 @Override
                 @Override
-                protected void validateDataImpl(AuditLog auditLog) {
+                protected void validateDataImpl(TenantId tenantId, AuditLog auditLog) {
                     if (auditLog.getEntityId() == null) {
                     if (auditLog.getEntityId() == null) {
                         throw new DataValidationException("Entity Id should be specified!");
                         throw new DataValidationException("Entity Id should be specified!");
                     }
                     }

@@ -32,6 +32,7 @@ import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.data.audit.AuditLog;
 import org.thingsboard.server.common.data.audit.AuditLog;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.EntityId;
 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.common.data.id.UserId;
 import org.thingsboard.server.common.data.page.TimePageLink;
 import org.thingsboard.server.common.data.page.TimePageLink;
 import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.DaoUtil;
@@ -142,7 +143,7 @@ public class CassandraAuditLogDao extends CassandraAbstractSearchTimeDao<AuditLo
         long partition = toPartitionTs(LocalDate.now().atStartOfDay().toInstant(ZoneOffset.UTC).toEpochMilli());
         long partition = toPartitionTs(LocalDate.now().atStartOfDay().toInstant(ZoneOffset.UTC).toEpochMilli());
         BoundStatement stmt = getSaveByTenantStmt().bind();
         BoundStatement stmt = getSaveByTenantStmt().bind();
         stmt = setSaveStmtVariables(stmt, auditLog, partition);
         stmt = setSaveStmtVariables(stmt, auditLog, partition);
-        return getFuture(executeAsyncWrite(stmt), rs -> null);
+        return getFuture(executeAsyncWrite(auditLog.getTenantId(), stmt), rs -> null);
     }
     }
 
 
     @Override
     @Override
@@ -151,7 +152,7 @@ public class CassandraAuditLogDao extends CassandraAbstractSearchTimeDao<AuditLo
 
 
         BoundStatement stmt = getSaveByTenantIdAndEntityIdStmt().bind();
         BoundStatement stmt = getSaveByTenantIdAndEntityIdStmt().bind();
         stmt = setSaveStmtVariables(stmt, auditLog, -1);
         stmt = setSaveStmtVariables(stmt, auditLog, -1);
-        return getFuture(executeAsyncWrite(stmt), rs -> null);
+        return getFuture(executeAsyncWrite(auditLog.getTenantId(), stmt), rs -> null);
     }
     }
 
 
     @Override
     @Override
@@ -160,7 +161,7 @@ public class CassandraAuditLogDao extends CassandraAbstractSearchTimeDao<AuditLo
 
 
         BoundStatement stmt = getSaveByTenantIdAndCustomerIdStmt().bind();
         BoundStatement stmt = getSaveByTenantIdAndCustomerIdStmt().bind();
         stmt = setSaveStmtVariables(stmt, auditLog, -1);
         stmt = setSaveStmtVariables(stmt, auditLog, -1);
-        return getFuture(executeAsyncWrite(stmt), rs -> null);
+        return getFuture(executeAsyncWrite(auditLog.getTenantId(), stmt), rs -> null);
     }
     }
 
 
     @Override
     @Override
@@ -169,11 +170,11 @@ public class CassandraAuditLogDao extends CassandraAbstractSearchTimeDao<AuditLo
 
 
         BoundStatement stmt = getSaveByTenantIdAndUserIdStmt().bind();
         BoundStatement stmt = getSaveByTenantIdAndUserIdStmt().bind();
         stmt = setSaveStmtVariables(stmt, auditLog, -1);
         stmt = setSaveStmtVariables(stmt, auditLog, -1);
-        return getFuture(executeAsyncWrite(stmt), rs -> null);
+        return getFuture(executeAsyncWrite(auditLog.getTenantId(), stmt), rs -> null);
     }
     }
 
 
     private BoundStatement setSaveStmtVariables(BoundStatement stmt, AuditLog auditLog, long partition) {
     private BoundStatement setSaveStmtVariables(BoundStatement stmt, AuditLog auditLog, long partition) {
-         stmt.setUUID(0, auditLog.getId().getId())
+        stmt.setUUID(0, auditLog.getId().getId())
                 .setUUID(1, auditLog.getTenantId().getId())
                 .setUUID(1, auditLog.getTenantId().getId())
                 .setUUID(2, auditLog.getCustomerId().getId())
                 .setUUID(2, auditLog.getCustomerId().getId())
                 .setUUID(3, auditLog.getEntityId().getId())
                 .setUUID(3, auditLog.getEntityId().getId())
@@ -200,7 +201,7 @@ public class CassandraAuditLogDao extends CassandraAbstractSearchTimeDao<AuditLo
         BoundStatement stmt = getPartitionInsertStmt().bind();
         BoundStatement stmt = getPartitionInsertStmt().bind();
         stmt = stmt.setUUID(0, auditLog.getTenantId().getId())
         stmt = stmt.setUUID(0, auditLog.getTenantId().getId())
                 .setLong(1, partition);
                 .setLong(1, partition);
-        return getFuture(executeAsyncWrite(stmt), rs -> null);
+        return getFuture(executeAsyncWrite(auditLog.getTenantId(), stmt), rs -> null);
     }
     }
 
 
     private PreparedStatement getSaveByTenantStmt() {
     private PreparedStatement getSaveByTenantStmt() {
@@ -249,7 +250,7 @@ public class CassandraAuditLogDao extends CassandraAbstractSearchTimeDao<AuditLo
             columnsList.add(ModelConstants.AUDIT_LOG_PARTITION_PROPERTY);
             columnsList.add(ModelConstants.AUDIT_LOG_PARTITION_PROPERTY);
         }
         }
         StringJoiner values = new StringJoiner(",");
         StringJoiner values = new StringJoiner(",");
-        for (int i=0;i<columnsList.size();i++) {
+        for (int i = 0; i < columnsList.size(); i++) {
             values.add("?");
             values.add("?");
         }
         }
         String statementString = INSERT_INTO + cfName + " (" + String.join(",", columnsList) + ") VALUES (" + values.toString() + ")";
         String statementString = INSERT_INTO + cfName + " (" + String.join(",", columnsList) + ") VALUES (" + values.toString() + ")";
@@ -274,7 +275,7 @@ public class CassandraAuditLogDao extends CassandraAbstractSearchTimeDao<AuditLo
     @Override
     @Override
     public List<AuditLog> findAuditLogsByTenantIdAndEntityId(UUID tenantId, EntityId entityId, TimePageLink pageLink) {
     public List<AuditLog> findAuditLogsByTenantIdAndEntityId(UUID tenantId, EntityId entityId, TimePageLink pageLink) {
         log.trace("Try to find audit logs by tenant [{}], entity [{}] and pageLink [{}]", tenantId, entityId, pageLink);
         log.trace("Try to find audit logs by tenant [{}], entity [{}] and pageLink [{}]", tenantId, entityId, pageLink);
-        List<AuditLogEntity> entities = findPageWithTimeSearch(AUDIT_LOG_BY_ENTITY_ID_CF,
+        List<AuditLogEntity> entities = findPageWithTimeSearch(new TenantId(tenantId), AUDIT_LOG_BY_ENTITY_ID_CF,
                 Arrays.asList(eq(ModelConstants.AUDIT_LOG_TENANT_ID_PROPERTY, tenantId),
                 Arrays.asList(eq(ModelConstants.AUDIT_LOG_TENANT_ID_PROPERTY, tenantId),
                         eq(ModelConstants.AUDIT_LOG_ENTITY_TYPE_PROPERTY, entityId.getEntityType()),
                         eq(ModelConstants.AUDIT_LOG_ENTITY_TYPE_PROPERTY, entityId.getEntityType()),
                         eq(ModelConstants.AUDIT_LOG_ENTITY_ID_PROPERTY, entityId.getId())),
                         eq(ModelConstants.AUDIT_LOG_ENTITY_ID_PROPERTY, entityId.getId())),
@@ -286,7 +287,7 @@ public class CassandraAuditLogDao extends CassandraAbstractSearchTimeDao<AuditLo
     @Override
     @Override
     public List<AuditLog> findAuditLogsByTenantIdAndCustomerId(UUID tenantId, CustomerId customerId, TimePageLink pageLink) {
     public List<AuditLog> findAuditLogsByTenantIdAndCustomerId(UUID tenantId, CustomerId customerId, TimePageLink pageLink) {
         log.trace("Try to find audit logs by tenant [{}], customer [{}] and pageLink [{}]", tenantId, customerId, pageLink);
         log.trace("Try to find audit logs by tenant [{}], customer [{}] and pageLink [{}]", tenantId, customerId, pageLink);
-        List<AuditLogEntity> entities = findPageWithTimeSearch(AUDIT_LOG_BY_CUSTOMER_ID_CF,
+        List<AuditLogEntity> entities = findPageWithTimeSearch(new TenantId(tenantId), AUDIT_LOG_BY_CUSTOMER_ID_CF,
                 Arrays.asList(eq(ModelConstants.AUDIT_LOG_TENANT_ID_PROPERTY, tenantId),
                 Arrays.asList(eq(ModelConstants.AUDIT_LOG_TENANT_ID_PROPERTY, tenantId),
                         eq(ModelConstants.AUDIT_LOG_CUSTOMER_ID_PROPERTY, customerId.getId())),
                         eq(ModelConstants.AUDIT_LOG_CUSTOMER_ID_PROPERTY, customerId.getId())),
                 pageLink);
                 pageLink);
@@ -297,7 +298,7 @@ public class CassandraAuditLogDao extends CassandraAbstractSearchTimeDao<AuditLo
     @Override
     @Override
     public List<AuditLog> findAuditLogsByTenantIdAndUserId(UUID tenantId, UserId userId, TimePageLink pageLink) {
     public List<AuditLog> findAuditLogsByTenantIdAndUserId(UUID tenantId, UserId userId, TimePageLink pageLink) {
         log.trace("Try to find audit logs by tenant [{}], user [{}] and pageLink [{}]", tenantId, userId, pageLink);
         log.trace("Try to find audit logs by tenant [{}], user [{}] and pageLink [{}]", tenantId, userId, pageLink);
-        List<AuditLogEntity> entities = findPageWithTimeSearch(AUDIT_LOG_BY_USER_ID_CF,
+        List<AuditLogEntity> entities = findPageWithTimeSearch(new TenantId(tenantId), AUDIT_LOG_BY_USER_ID_CF,
                 Arrays.asList(eq(ModelConstants.AUDIT_LOG_TENANT_ID_PROPERTY, tenantId),
                 Arrays.asList(eq(ModelConstants.AUDIT_LOG_TENANT_ID_PROPERTY, tenantId),
                         eq(ModelConstants.AUDIT_LOG_USER_ID_PROPERTY, userId.getId())),
                         eq(ModelConstants.AUDIT_LOG_USER_ID_PROPERTY, userId.getId())),
                 pageLink);
                 pageLink);
@@ -339,7 +340,7 @@ public class CassandraAuditLogDao extends CassandraAbstractSearchTimeDao<AuditLo
         if (cursor.isFull() || !cursor.hasNextPartition()) {
         if (cursor.isFull() || !cursor.hasNextPartition()) {
             return cursor.getData();
             return cursor.getData();
         } else {
         } else {
-            cursor.addData(findPageWithTimeSearch(AUDIT_LOG_BY_TENANT_ID_CF,
+            cursor.addData(findPageWithTimeSearch(new TenantId(cursor.getTenantId()), AUDIT_LOG_BY_TENANT_ID_CF,
                     Arrays.asList(eq(ModelConstants.AUDIT_LOG_TENANT_ID_PROPERTY, cursor.getTenantId()),
                     Arrays.asList(eq(ModelConstants.AUDIT_LOG_TENANT_ID_PROPERTY, cursor.getTenantId()),
                             eq(ModelConstants.AUDIT_LOG_PARTITION_PROPERTY, cursor.getNextPartition())),
                             eq(ModelConstants.AUDIT_LOG_PARTITION_PROPERTY, cursor.getNextPartition())),
                     cursor.getPageLink()));
                     cursor.getPageLink()));
@@ -352,7 +353,7 @@ public class CassandraAuditLogDao extends CassandraAbstractSearchTimeDao<AuditLo
                 .where(eq(ModelConstants.AUDIT_LOG_TENANT_ID_PROPERTY, tenantId));
                 .where(eq(ModelConstants.AUDIT_LOG_TENANT_ID_PROPERTY, tenantId));
         select.and(QueryBuilder.gte(ModelConstants.PARTITION_COLUMN, minPartition));
         select.and(QueryBuilder.gte(ModelConstants.PARTITION_COLUMN, minPartition));
         select.and(QueryBuilder.lte(ModelConstants.PARTITION_COLUMN, maxPartition));
         select.and(QueryBuilder.lte(ModelConstants.PARTITION_COLUMN, maxPartition));
-        return executeRead(select);
+        return executeRead(new TenantId(tenantId), select);
     }
     }
 
 
 }
 }

@@ -16,6 +16,7 @@
 package org.thingsboard.server.dao.cache;
 package org.thingsboard.server.dao.cache;
 
 
 import org.springframework.cache.interceptor.KeyGenerator;
 import org.springframework.cache.interceptor.KeyGenerator;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.security.DeviceCredentials;
 import org.thingsboard.server.common.data.security.DeviceCredentials;
 import org.thingsboard.server.dao.device.DeviceCredentialsService;
 import org.thingsboard.server.dao.device.DeviceCredentialsService;
 
 
@@ -28,9 +29,10 @@ public class PreviousDeviceCredentialsIdKeyGenerator implements KeyGenerator {
     @Override
     @Override
     public Object generate(Object o, Method method, Object... objects) {
     public Object generate(Object o, Method method, Object... objects) {
         DeviceCredentialsService deviceCredentialsService = (DeviceCredentialsService) o;
         DeviceCredentialsService deviceCredentialsService = (DeviceCredentialsService) o;
-        DeviceCredentials deviceCredentials = (DeviceCredentials) objects[0];
+        TenantId tenantId = (TenantId) objects[0];
+        DeviceCredentials deviceCredentials = (DeviceCredentials) objects[1];
         if (deviceCredentials.getDeviceId() != null) {
         if (deviceCredentials.getDeviceId() != null) {
-            DeviceCredentials oldDeviceCredentials = deviceCredentialsService.findDeviceCredentialsByDeviceId(deviceCredentials.getDeviceId());
+            DeviceCredentials oldDeviceCredentials = deviceCredentialsService.findDeviceCredentialsByDeviceId(tenantId, deviceCredentials.getDeviceId());
             if (oldDeviceCredentials != null) {
             if (oldDeviceCredentials != null) {
                 return oldDeviceCredentials.getCredentialsId();
                 return oldDeviceCredentials.getCredentialsId();
             }
             }

@@ -25,6 +25,8 @@ import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.common.data.id.ComponentDescriptorId;
 import org.thingsboard.server.common.data.id.ComponentDescriptorId;
+import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.TextPageData;
 import org.thingsboard.server.common.data.page.TextPageData;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.common.data.plugin.ComponentDescriptor;
 import org.thingsboard.server.common.data.plugin.ComponentDescriptor;
@@ -49,50 +51,50 @@ public class BaseComponentDescriptorService implements ComponentDescriptorServic
     private ComponentDescriptorDao componentDescriptorDao;
     private ComponentDescriptorDao componentDescriptorDao;
 
 
     @Override
     @Override
-    public ComponentDescriptor saveComponent(ComponentDescriptor component) {
-        componentValidator.validate(component);
-        Optional<ComponentDescriptor> result = componentDescriptorDao.saveIfNotExist(component);
+    public ComponentDescriptor saveComponent(TenantId tenantId, ComponentDescriptor component) {
+        componentValidator.validate(component, data -> new TenantId(EntityId.NULL_UUID));
+        Optional<ComponentDescriptor> result = componentDescriptorDao.saveIfNotExist(tenantId, component);
         if (result.isPresent()) {
         if (result.isPresent()) {
             return result.get();
             return result.get();
         } else {
         } else {
-            return componentDescriptorDao.findByClazz(component.getClazz());
+            return componentDescriptorDao.findByClazz(tenantId, component.getClazz());
         }
         }
     }
     }
 
 
     @Override
     @Override
-    public ComponentDescriptor findById(ComponentDescriptorId componentId) {
+    public ComponentDescriptor findById(TenantId tenantId, ComponentDescriptorId componentId) {
         Validator.validateId(componentId, "Incorrect component id for search request.");
         Validator.validateId(componentId, "Incorrect component id for search request.");
-        return componentDescriptorDao.findById(componentId);
+        return componentDescriptorDao.findById(tenantId, componentId);
     }
     }
 
 
     @Override
     @Override
-    public ComponentDescriptor findByClazz(String clazz) {
+    public ComponentDescriptor findByClazz(TenantId tenantId, String clazz) {
         Validator.validateString(clazz, "Incorrect clazz for search request.");
         Validator.validateString(clazz, "Incorrect clazz for search request.");
-        return componentDescriptorDao.findByClazz(clazz);
+        return componentDescriptorDao.findByClazz(tenantId, clazz);
     }
     }
 
 
     @Override
     @Override
-    public TextPageData<ComponentDescriptor> findByTypeAndPageLink(ComponentType type, TextPageLink pageLink) {
+    public TextPageData<ComponentDescriptor> findByTypeAndPageLink(TenantId tenantId, ComponentType type, TextPageLink pageLink) {
         Validator.validatePageLink(pageLink, "Incorrect PageLink object for search plugin components request.");
         Validator.validatePageLink(pageLink, "Incorrect PageLink object for search plugin components request.");
-        List<ComponentDescriptor> components = componentDescriptorDao.findByTypeAndPageLink(type, pageLink);
+        List<ComponentDescriptor> components = componentDescriptorDao.findByTypeAndPageLink(tenantId, type, pageLink);
         return new TextPageData<>(components, pageLink);
         return new TextPageData<>(components, pageLink);
     }
     }
 
 
     @Override
     @Override
-    public TextPageData<ComponentDescriptor> findByScopeAndTypeAndPageLink(ComponentScope scope, ComponentType type, TextPageLink pageLink) {
+    public TextPageData<ComponentDescriptor> findByScopeAndTypeAndPageLink(TenantId tenantId, ComponentScope scope, ComponentType type, TextPageLink pageLink) {
         Validator.validatePageLink(pageLink, "Incorrect PageLink object for search plugin components request.");
         Validator.validatePageLink(pageLink, "Incorrect PageLink object for search plugin components request.");
-        List<ComponentDescriptor> components = componentDescriptorDao.findByScopeAndTypeAndPageLink(scope, type, pageLink);
+        List<ComponentDescriptor> components = componentDescriptorDao.findByScopeAndTypeAndPageLink(tenantId, scope, type, pageLink);
         return new TextPageData<>(components, pageLink);
         return new TextPageData<>(components, pageLink);
     }
     }
 
 
     @Override
     @Override
-    public void deleteByClazz(String clazz) {
+    public void deleteByClazz(TenantId tenantId, String clazz) {
         Validator.validateString(clazz, "Incorrect clazz for delete request.");
         Validator.validateString(clazz, "Incorrect clazz for delete request.");
-        componentDescriptorDao.deleteByClazz(clazz);
+        componentDescriptorDao.deleteByClazz(tenantId, clazz);
     }
     }
 
 
     @Override
     @Override
-    public boolean validate(ComponentDescriptor component, JsonNode configuration) {
+    public boolean validate(TenantId tenantId, ComponentDescriptor component, JsonNode configuration) {
         JsonValidator validator = JsonSchemaFactory.byDefault().getValidator();
         JsonValidator validator = JsonSchemaFactory.byDefault().getValidator();
         try {
         try {
             if (!component.getConfigurationDescriptor().has("schema")) {
             if (!component.getConfigurationDescriptor().has("schema")) {
@@ -109,7 +111,7 @@ public class BaseComponentDescriptorService implements ComponentDescriptorServic
     private DataValidator<ComponentDescriptor> componentValidator =
     private DataValidator<ComponentDescriptor> componentValidator =
             new DataValidator<ComponentDescriptor>() {
             new DataValidator<ComponentDescriptor>() {
                 @Override
                 @Override
-                protected void validateDataImpl(ComponentDescriptor plugin) {
+                protected void validateDataImpl(TenantId tenantId, ComponentDescriptor plugin) {
                     if (plugin.getType() == null) {
                     if (plugin.getType() == null) {
                         throw new DataValidationException("Component type should be specified!.");
                         throw new DataValidationException("Component type should be specified!.");
                     }
                     }

@@ -23,6 +23,7 @@ import com.datastax.driver.core.utils.UUIDs;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
 import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.data.id.ComponentDescriptorId;
 import org.thingsboard.server.common.data.id.ComponentDescriptorId;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.common.data.plugin.ComponentDescriptor;
 import org.thingsboard.server.common.data.plugin.ComponentDescriptor;
 import org.thingsboard.server.common.data.plugin.ComponentScope;
 import org.thingsboard.server.common.data.plugin.ComponentScope;
@@ -62,10 +63,10 @@ public class CassandraBaseComponentDescriptorDao extends CassandraAbstractSearch
     }
     }
 
 
     @Override
     @Override
-    public Optional<ComponentDescriptor> saveIfNotExist(ComponentDescriptor component) {
+    public Optional<ComponentDescriptor> saveIfNotExist(TenantId tenantId, ComponentDescriptor component) {
         ComponentDescriptorEntity entity = new ComponentDescriptorEntity(component);
         ComponentDescriptorEntity entity = new ComponentDescriptorEntity(component);
         log.debug("Save component entity [{}]", entity);
         log.debug("Save component entity [{}]", entity);
-        Optional<ComponentDescriptor> result = saveIfNotExist(entity);
+        Optional<ComponentDescriptor> result = saveIfNotExist(tenantId, entity);
         if (log.isTraceEnabled()) {
         if (log.isTraceEnabled()) {
             log.trace("Saved result: [{}] for component entity [{}]", result.isPresent(), result.orElse(null));
             log.trace("Saved result: [{}] for component entity [{}]", result.isPresent(), result.orElse(null));
         } else {
         } else {
@@ -75,9 +76,9 @@ public class CassandraBaseComponentDescriptorDao extends CassandraAbstractSearch
     }
     }
 
 
     @Override
     @Override
-    public ComponentDescriptor findById(ComponentDescriptorId componentId) {
+    public ComponentDescriptor findById(TenantId tenantId, ComponentDescriptorId componentId) {
         log.debug("Search component entity by id [{}]", componentId);
         log.debug("Search component entity by id [{}]", componentId);
-        ComponentDescriptor componentDescriptor = super.findById(componentId.getId());
+        ComponentDescriptor componentDescriptor = super.findById(tenantId, componentId.getId());
         if (log.isTraceEnabled()) {
         if (log.isTraceEnabled()) {
             log.trace("Search result: [{}] for component entity [{}]", componentDescriptor != null, componentDescriptor);
             log.trace("Search result: [{}] for component entity [{}]", componentDescriptor != null, componentDescriptor);
         } else {
         } else {
@@ -87,11 +88,11 @@ public class CassandraBaseComponentDescriptorDao extends CassandraAbstractSearch
     }
     }
 
 
     @Override
     @Override
-    public ComponentDescriptor findByClazz(String clazz) {
+    public ComponentDescriptor findByClazz(TenantId tenantId, String clazz) {
         log.debug("Search component entity by clazz [{}]", clazz);
         log.debug("Search component entity by clazz [{}]", clazz);
         Select.Where query = select().from(getColumnFamilyName()).where(eq(ModelConstants.COMPONENT_DESCRIPTOR_CLASS_PROPERTY, clazz));
         Select.Where query = select().from(getColumnFamilyName()).where(eq(ModelConstants.COMPONENT_DESCRIPTOR_CLASS_PROPERTY, clazz));
         log.trace("Execute query [{}]", query);
         log.trace("Execute query [{}]", query);
-        ComponentDescriptorEntity entity = findOneByStatement(query);
+        ComponentDescriptorEntity entity = findOneByStatement(tenantId, query);
         if (log.isTraceEnabled()) {
         if (log.isTraceEnabled()) {
             log.trace("Search result: [{}] for component entity [{}]", entity != null, entity);
             log.trace("Search result: [{}] for component entity [{}]", entity != null, entity);
         } else {
         } else {
@@ -101,9 +102,9 @@ public class CassandraBaseComponentDescriptorDao extends CassandraAbstractSearch
     }
     }
 
 
     @Override
     @Override
-    public List<ComponentDescriptor> findByTypeAndPageLink(ComponentType type, TextPageLink pageLink) {
+    public List<ComponentDescriptor> findByTypeAndPageLink(TenantId tenantId, ComponentType type, TextPageLink pageLink) {
         log.debug("Try to find component by type [{}] and pageLink [{}]", type, pageLink);
         log.debug("Try to find component by type [{}] and pageLink [{}]", type, pageLink);
-        List<ComponentDescriptorEntity> entities = findPageWithTextSearch(ModelConstants.COMPONENT_DESCRIPTOR_BY_TYPE_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
+        List<ComponentDescriptorEntity> entities = findPageWithTextSearch(tenantId, ModelConstants.COMPONENT_DESCRIPTOR_BY_TYPE_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
                 Arrays.asList(eq(ModelConstants.COMPONENT_DESCRIPTOR_TYPE_PROPERTY, type)), pageLink);
                 Arrays.asList(eq(ModelConstants.COMPONENT_DESCRIPTOR_TYPE_PROPERTY, type)), pageLink);
         if (log.isTraceEnabled()) {
         if (log.isTraceEnabled()) {
             log.trace(SEARCH_RESULT, Arrays.toString(entities.toArray()));
             log.trace(SEARCH_RESULT, Arrays.toString(entities.toArray()));
@@ -114,9 +115,9 @@ public class CassandraBaseComponentDescriptorDao extends CassandraAbstractSearch
     }
     }
 
 
     @Override
     @Override
-    public List<ComponentDescriptor> findByScopeAndTypeAndPageLink(ComponentScope scope, ComponentType type, TextPageLink pageLink) {
+    public List<ComponentDescriptor> findByScopeAndTypeAndPageLink(TenantId tenantId, ComponentScope scope, ComponentType type, TextPageLink pageLink) {
         log.debug("Try to find component by scope [{}] and type [{}] and pageLink [{}]", scope, type, pageLink);
         log.debug("Try to find component by scope [{}] and type [{}] and pageLink [{}]", scope, type, pageLink);
-        List<ComponentDescriptorEntity> entities = findPageWithTextSearch(ModelConstants.COMPONENT_DESCRIPTOR_BY_SCOPE_TYPE_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
+        List<ComponentDescriptorEntity> entities = findPageWithTextSearch(tenantId, ModelConstants.COMPONENT_DESCRIPTOR_BY_SCOPE_TYPE_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
                 Arrays.asList(eq(ModelConstants.COMPONENT_DESCRIPTOR_TYPE_PROPERTY, type),
                 Arrays.asList(eq(ModelConstants.COMPONENT_DESCRIPTOR_TYPE_PROPERTY, type),
                         eq(ModelConstants.COMPONENT_DESCRIPTOR_SCOPE_PROPERTY, scope.name())), pageLink);
                         eq(ModelConstants.COMPONENT_DESCRIPTOR_SCOPE_PROPERTY, scope.name())), pageLink);
         if (log.isTraceEnabled()) {
         if (log.isTraceEnabled()) {
@@ -127,34 +128,34 @@ public class CassandraBaseComponentDescriptorDao extends CassandraAbstractSearch
         return DaoUtil.convertDataList(entities);
         return DaoUtil.convertDataList(entities);
     }
     }
 
 
-    public boolean removeById(UUID key) {
+    public boolean removeById(TenantId tenantId, UUID key) {
         Statement delete = QueryBuilder.delete().all().from(ModelConstants.COMPONENT_DESCRIPTOR_BY_ID).where(eq(ModelConstants.ID_PROPERTY, key));
         Statement delete = QueryBuilder.delete().all().from(ModelConstants.COMPONENT_DESCRIPTOR_BY_ID).where(eq(ModelConstants.ID_PROPERTY, key));
         log.debug("Remove request: {}", delete.toString());
         log.debug("Remove request: {}", delete.toString());
-        return executeWrite(delete).wasApplied();
+        return executeWrite(tenantId, delete).wasApplied();
     }
     }
 
 
     @Override
     @Override
-    public void deleteById(ComponentDescriptorId id) {
+    public void deleteById(TenantId tenantId, ComponentDescriptorId id) {
         log.debug("Delete plugin meta-data entity by id [{}]", id);
         log.debug("Delete plugin meta-data entity by id [{}]", id);
-        boolean result = removeById(id.getId());
+        boolean result = removeById(tenantId, id.getId());
         log.debug("Delete result: [{}]", result);
         log.debug("Delete result: [{}]", result);
     }
     }
 
 
     @Override
     @Override
-    public void deleteByClazz(String clazz) {
+    public void deleteByClazz(TenantId tenantId, String clazz) {
         log.debug("Delete plugin meta-data entity by id [{}]", clazz);
         log.debug("Delete plugin meta-data entity by id [{}]", clazz);
         Statement delete = QueryBuilder.delete().all().from(getColumnFamilyName()).where(eq(ModelConstants.COMPONENT_DESCRIPTOR_CLASS_PROPERTY, clazz));
         Statement delete = QueryBuilder.delete().all().from(getColumnFamilyName()).where(eq(ModelConstants.COMPONENT_DESCRIPTOR_CLASS_PROPERTY, clazz));
         log.debug("Remove request: {}", delete.toString());
         log.debug("Remove request: {}", delete.toString());
-        ResultSet resultSet = executeWrite(delete);
+        ResultSet resultSet = executeWrite(tenantId, delete);
         log.debug("Delete result: [{}]", resultSet.wasApplied());
         log.debug("Delete result: [{}]", resultSet.wasApplied());
     }
     }
 
 
-    private Optional<ComponentDescriptor> saveIfNotExist(ComponentDescriptorEntity entity) {
+    private Optional<ComponentDescriptor> saveIfNotExist(TenantId tenantId, ComponentDescriptorEntity entity) {
         if (entity.getId() == null) {
         if (entity.getId() == null) {
             entity.setId(UUIDs.timeBased());
             entity.setId(UUIDs.timeBased());
         }
         }
 
 
-        ResultSet rs = executeRead(QueryBuilder.insertInto(getColumnFamilyName())
+        ResultSet rs = executeRead(tenantId, QueryBuilder.insertInto(getColumnFamilyName())
                 .value(ModelConstants.ID_PROPERTY, entity.getId())
                 .value(ModelConstants.ID_PROPERTY, entity.getId())
                 .value(ModelConstants.COMPONENT_DESCRIPTOR_NAME_PROPERTY, entity.getName())
                 .value(ModelConstants.COMPONENT_DESCRIPTOR_NAME_PROPERTY, entity.getName())
                 .value(ModelConstants.COMPONENT_DESCRIPTOR_CLASS_PROPERTY, entity.getClazz())
                 .value(ModelConstants.COMPONENT_DESCRIPTOR_CLASS_PROPERTY, entity.getClazz())

@@ -16,6 +16,7 @@
 package org.thingsboard.server.dao.component;
 package org.thingsboard.server.dao.component;
 
 
 import org.thingsboard.server.common.data.id.ComponentDescriptorId;
 import org.thingsboard.server.common.data.id.ComponentDescriptorId;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.common.data.plugin.ComponentDescriptor;
 import org.thingsboard.server.common.data.plugin.ComponentDescriptor;
 import org.thingsboard.server.common.data.plugin.ComponentScope;
 import org.thingsboard.server.common.data.plugin.ComponentScope;
@@ -30,18 +31,18 @@ import java.util.Optional;
  */
  */
 public interface ComponentDescriptorDao extends Dao<ComponentDescriptor> {
 public interface ComponentDescriptorDao extends Dao<ComponentDescriptor> {
 
 
-    Optional<ComponentDescriptor> saveIfNotExist(ComponentDescriptor component);
+    Optional<ComponentDescriptor> saveIfNotExist(TenantId tenantId, ComponentDescriptor component);
 
 
-    ComponentDescriptor findById(ComponentDescriptorId componentId);
+    ComponentDescriptor findById(TenantId tenantId, ComponentDescriptorId componentId);
 
 
-    ComponentDescriptor findByClazz(String clazz);
+    ComponentDescriptor findByClazz(TenantId tenantId, String clazz);
 
 
-    List<ComponentDescriptor> findByTypeAndPageLink(ComponentType type, TextPageLink pageLink);
+    List<ComponentDescriptor> findByTypeAndPageLink(TenantId tenantId, ComponentType type, TextPageLink pageLink);
 
 
-    List<ComponentDescriptor> findByScopeAndTypeAndPageLink(ComponentScope scope, ComponentType type, TextPageLink pageLink);
+    List<ComponentDescriptor> findByScopeAndTypeAndPageLink(TenantId tenantId, ComponentScope scope, ComponentType type, TextPageLink pageLink);
 
 
-    void deleteById(ComponentDescriptorId componentId);
+    void deleteById(TenantId tenantId, ComponentDescriptorId componentId);
 
 
-    void deleteByClazz(String clazz);
+    void deleteByClazz(TenantId tenantId, String clazz);
 
 
 }
 }

@@ -17,6 +17,7 @@ package org.thingsboard.server.dao.component;
 
 
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.JsonNode;
 import org.thingsboard.server.common.data.id.ComponentDescriptorId;
 import org.thingsboard.server.common.data.id.ComponentDescriptorId;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.TextPageData;
 import org.thingsboard.server.common.data.page.TextPageData;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.common.data.plugin.ComponentDescriptor;
 import org.thingsboard.server.common.data.plugin.ComponentDescriptor;
@@ -28,18 +29,18 @@ import org.thingsboard.server.common.data.plugin.ComponentType;
  */
  */
 public interface ComponentDescriptorService {
 public interface ComponentDescriptorService {
 
 
-    ComponentDescriptor saveComponent(ComponentDescriptor component);
+    ComponentDescriptor saveComponent(TenantId tenantId, ComponentDescriptor component);
 
 
-    ComponentDescriptor findById(ComponentDescriptorId componentId);
+    ComponentDescriptor findById(TenantId tenantId, ComponentDescriptorId componentId);
 
 
-    ComponentDescriptor findByClazz(String clazz);
+    ComponentDescriptor findByClazz(TenantId tenantId, String clazz);
 
 
-    TextPageData<ComponentDescriptor> findByTypeAndPageLink(ComponentType type, TextPageLink pageLink);
+    TextPageData<ComponentDescriptor> findByTypeAndPageLink(TenantId tenantId, ComponentType type, TextPageLink pageLink);
 
 
-    TextPageData<ComponentDescriptor> findByScopeAndTypeAndPageLink(ComponentScope scope, ComponentType type, TextPageLink pageLink);
+    TextPageData<ComponentDescriptor> findByScopeAndTypeAndPageLink(TenantId tenantId, ComponentScope scope, ComponentType type, TextPageLink pageLink);
 
 
-    boolean validate(ComponentDescriptor component, JsonNode configuration);
+    boolean validate(TenantId tenantId, ComponentDescriptor component, JsonNode configuration);
 
 
-    void deleteByClazz(String clazz);
+    void deleteByClazz(TenantId tenantId, String clazz);
 
 
 }
 }

@@ -19,6 +19,7 @@ import com.datastax.driver.core.querybuilder.Select;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
 import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.data.Customer;
 import org.thingsboard.server.common.data.Customer;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.model.ModelConstants;
 import org.thingsboard.server.dao.model.ModelConstants;
@@ -36,6 +37,7 @@ import static com.datastax.driver.core.querybuilder.QueryBuilder.select;
 import static org.thingsboard.server.dao.model.ModelConstants.CUSTOMER_BY_TENANT_AND_TITLE_VIEW_NAME;
 import static org.thingsboard.server.dao.model.ModelConstants.CUSTOMER_BY_TENANT_AND_TITLE_VIEW_NAME;
 import static org.thingsboard.server.dao.model.ModelConstants.CUSTOMER_TENANT_ID_PROPERTY;
 import static org.thingsboard.server.dao.model.ModelConstants.CUSTOMER_TENANT_ID_PROPERTY;
 import static org.thingsboard.server.dao.model.ModelConstants.CUSTOMER_TITLE_PROPERTY;
 import static org.thingsboard.server.dao.model.ModelConstants.CUSTOMER_TITLE_PROPERTY;
+
 @Component
 @Component
 @Slf4j
 @Slf4j
 @NoSqlDao
 @NoSqlDao
@@ -54,9 +56,9 @@ public class CassandraCustomerDao extends CassandraAbstractSearchTextDao<Custome
     @Override
     @Override
     public List<Customer> findCustomersByTenantId(UUID tenantId, TextPageLink pageLink) {
     public List<Customer> findCustomersByTenantId(UUID tenantId, TextPageLink pageLink) {
         log.debug("Try to find customers by tenantId [{}] and pageLink [{}]", tenantId, pageLink);
         log.debug("Try to find customers by tenantId [{}] and pageLink [{}]", tenantId, pageLink);
-        List<CustomerEntity> customerEntities = findPageWithTextSearch(ModelConstants.CUSTOMER_BY_TENANT_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
+        List<CustomerEntity> customerEntities = findPageWithTextSearch(new TenantId(tenantId), ModelConstants.CUSTOMER_BY_TENANT_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
                 Arrays.asList(eq(ModelConstants.CUSTOMER_TENANT_ID_PROPERTY, tenantId)),
                 Arrays.asList(eq(ModelConstants.CUSTOMER_TENANT_ID_PROPERTY, tenantId)),
-                pageLink); 
+                pageLink);
         log.trace("Found customers [{}] by tenantId [{}] and pageLink [{}]", customerEntities, tenantId, pageLink);
         log.trace("Found customers [{}] by tenantId [{}] and pageLink [{}]", customerEntities, tenantId, pageLink);
         return DaoUtil.convertDataList(customerEntities);
         return DaoUtil.convertDataList(customerEntities);
     }
     }
@@ -67,7 +69,7 @@ public class CassandraCustomerDao extends CassandraAbstractSearchTextDao<Custome
         Select.Where query = select.where();
         Select.Where query = select.where();
         query.and(eq(CUSTOMER_TENANT_ID_PROPERTY, tenantId));
         query.and(eq(CUSTOMER_TENANT_ID_PROPERTY, tenantId));
         query.and(eq(CUSTOMER_TITLE_PROPERTY, title));
         query.and(eq(CUSTOMER_TITLE_PROPERTY, title));
-        CustomerEntity customerEntity = findOneByStatement(query);
+        CustomerEntity customerEntity = findOneByStatement(new TenantId(tenantId), query);
         Customer customer = DaoUtil.getData(customerEntity);
         Customer customer = DaoUtil.getData(customerEntity);
         return Optional.ofNullable(customer);
         return Optional.ofNullable(customer);
     }
     }

@@ -16,6 +16,7 @@
 package org.thingsboard.server.dao.customer;
 package org.thingsboard.server.dao.customer;
 
 
 import org.thingsboard.server.common.data.Customer;
 import org.thingsboard.server.common.data.Customer;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.dao.Dao;
 import org.thingsboard.server.dao.Dao;
 
 
@@ -34,7 +35,7 @@ public interface CustomerDao extends Dao<Customer> {
      * @param customer the customer object
      * @param customer the customer object
      * @return saved customer object
      * @return saved customer object
      */
      */
-    Customer save(Customer customer);
+    Customer save(TenantId tenantId, Customer customer);
     
     
     /**
     /**
      * Find customers by tenant id and page link.
      * Find customers by tenant id and page link.

@@ -26,15 +26,15 @@ import java.util.Optional;
 
 
 public interface CustomerService {
 public interface CustomerService {
 
 
-    Customer findCustomerById(CustomerId customerId);
+    Customer findCustomerById(TenantId tenantId, CustomerId customerId);
 
 
     Optional<Customer> findCustomerByTenantIdAndTitle(TenantId tenantId, String title);
     Optional<Customer> findCustomerByTenantIdAndTitle(TenantId tenantId, String title);
 
 
-    ListenableFuture<Customer> findCustomerByIdAsync(CustomerId customerId);
+    ListenableFuture<Customer> findCustomerByIdAsync(TenantId tenantId, CustomerId customerId);
 
 
     Customer saveCustomer(Customer customer);
     Customer saveCustomer(Customer customer);
 
 
-    void deleteCustomer(CustomerId customerId);
+    void deleteCustomer(TenantId tenantId, CustomerId customerId);
 
 
     Customer findOrCreatePublicCustomer(TenantId tenantId);
     Customer findOrCreatePublicCustomer(TenantId tenantId);
 
 

@@ -77,10 +77,10 @@ public class CustomerServiceImpl extends AbstractEntityService implements Custom
     private DashboardService dashboardService;
     private DashboardService dashboardService;
 
 
     @Override
     @Override
-    public Customer findCustomerById(CustomerId customerId) {
+    public Customer findCustomerById(TenantId tenantId, CustomerId customerId) {
         log.trace("Executing findCustomerById [{}]", customerId);
         log.trace("Executing findCustomerById [{}]", customerId);
         Validator.validateId(customerId, INCORRECT_CUSTOMER_ID + customerId);
         Validator.validateId(customerId, INCORRECT_CUSTOMER_ID + customerId);
-        return customerDao.findById(customerId.getId());
+        return customerDao.findById(tenantId, customerId.getId());
     }
     }
 
 
     @Override
     @Override
@@ -91,36 +91,36 @@ public class CustomerServiceImpl extends AbstractEntityService implements Custom
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<Customer> findCustomerByIdAsync(CustomerId customerId) {
+    public ListenableFuture<Customer> findCustomerByIdAsync(TenantId tenantId, CustomerId customerId) {
         log.trace("Executing findCustomerByIdAsync [{}]", customerId);
         log.trace("Executing findCustomerByIdAsync [{}]", customerId);
         validateId(customerId, INCORRECT_CUSTOMER_ID + customerId);
         validateId(customerId, INCORRECT_CUSTOMER_ID + customerId);
-        return customerDao.findByIdAsync(customerId.getId());
+        return customerDao.findByIdAsync(tenantId, customerId.getId());
     }
     }
 
 
     @Override
     @Override
     public Customer saveCustomer(Customer customer) {
     public Customer saveCustomer(Customer customer) {
         log.trace("Executing saveCustomer [{}]", customer);
         log.trace("Executing saveCustomer [{}]", customer);
-        customerValidator.validate(customer);
-        Customer savedCustomer = customerDao.save(customer);
-        dashboardService.updateCustomerDashboards(savedCustomer.getId());
+        customerValidator.validate(customer, Customer::getTenantId);
+        Customer savedCustomer = customerDao.save(customer.getTenantId(), customer);
+        dashboardService.updateCustomerDashboards(savedCustomer.getTenantId(), savedCustomer.getId());
         return savedCustomer;
         return savedCustomer;
     }
     }
 
 
     @Override
     @Override
-    public void deleteCustomer(CustomerId customerId) {
+    public void deleteCustomer(TenantId tenantId, CustomerId customerId) {
         log.trace("Executing deleteCustomer [{}]", customerId);
         log.trace("Executing deleteCustomer [{}]", customerId);
         Validator.validateId(customerId, INCORRECT_CUSTOMER_ID + customerId);
         Validator.validateId(customerId, INCORRECT_CUSTOMER_ID + customerId);
-        Customer customer = findCustomerById(customerId);
+        Customer customer = findCustomerById(tenantId, customerId);
         if (customer == null) {
         if (customer == null) {
             throw new IncorrectParameterException("Unable to delete non-existent customer.");
             throw new IncorrectParameterException("Unable to delete non-existent customer.");
         }
         }
-        dashboardService.unassignCustomerDashboards(customerId);
+        dashboardService.unassignCustomerDashboards(tenantId, customerId);
         entityViewService.unassignCustomerEntityViews(customer.getTenantId(), customerId);
         entityViewService.unassignCustomerEntityViews(customer.getTenantId(), customerId);
         assetService.unassignCustomerAssets(customer.getTenantId(), customerId);
         assetService.unassignCustomerAssets(customer.getTenantId(), customerId);
         deviceService.unassignCustomerDevices(customer.getTenantId(), customerId);
         deviceService.unassignCustomerDevices(customer.getTenantId(), customerId);
         userService.deleteCustomerUsers(customer.getTenantId(), customerId);
         userService.deleteCustomerUsers(customer.getTenantId(), customerId);
-        deleteEntityRelations(customerId);
-        customerDao.removeById(customerId.getId());
+        deleteEntityRelations(tenantId, customerId);
+        customerDao.removeById(tenantId, customerId.getId());
     }
     }
 
 
     @Override
     @Override
@@ -139,7 +139,7 @@ public class CustomerServiceImpl extends AbstractEntityService implements Custom
             } catch (IOException e) {
             } catch (IOException e) {
                 throw new IncorrectParameterException("Unable to create public customer.", e);
                 throw new IncorrectParameterException("Unable to create public customer.", e);
             }
             }
-            return customerDao.save(publicCustomer);
+            return customerDao.save(tenantId, publicCustomer);
         }
         }
     }
     }
 
 
@@ -156,14 +156,14 @@ public class CustomerServiceImpl extends AbstractEntityService implements Custom
     public void deleteCustomersByTenantId(TenantId tenantId) {
     public void deleteCustomersByTenantId(TenantId tenantId) {
         log.trace("Executing deleteCustomersByTenantId, tenantId [{}]", tenantId);
         log.trace("Executing deleteCustomersByTenantId, tenantId [{}]", tenantId);
         Validator.validateId(tenantId, "Incorrect tenantId " + tenantId);
         Validator.validateId(tenantId, "Incorrect tenantId " + tenantId);
-        customersByTenantRemover.removeEntities(tenantId);
+        customersByTenantRemover.removeEntities(tenantId, tenantId);
     }
     }
 
 
     private DataValidator<Customer> customerValidator =
     private DataValidator<Customer> customerValidator =
             new DataValidator<Customer>() {
             new DataValidator<Customer>() {
 
 
                 @Override
                 @Override
-                protected void validateCreate(Customer customer) {
+                protected void validateCreate(TenantId tenantId, Customer customer) {
                     customerDao.findCustomersByTenantIdAndTitle(customer.getTenantId().getId(), customer.getTitle()).ifPresent(
                     customerDao.findCustomersByTenantIdAndTitle(customer.getTenantId().getId(), customer.getTitle()).ifPresent(
                             c -> {
                             c -> {
                                 throw new DataValidationException("Customer with such title already exists!");
                                 throw new DataValidationException("Customer with such title already exists!");
@@ -172,7 +172,7 @@ public class CustomerServiceImpl extends AbstractEntityService implements Custom
                 }
                 }
 
 
                 @Override
                 @Override
-                protected void validateUpdate(Customer customer) {
+                protected void validateUpdate(TenantId tenantId, Customer customer) {
                     customerDao.findCustomersByTenantIdAndTitle(customer.getTenantId().getId(), customer.getTitle()).ifPresent(
                     customerDao.findCustomersByTenantIdAndTitle(customer.getTenantId().getId(), customer.getTitle()).ifPresent(
                             c -> {
                             c -> {
                                 if (!c.getId().equals(customer.getId())) {
                                 if (!c.getId().equals(customer.getId())) {
@@ -183,7 +183,7 @@ public class CustomerServiceImpl extends AbstractEntityService implements Custom
                 }
                 }
 
 
                 @Override
                 @Override
-                protected void validateDataImpl(Customer customer) {
+                protected void validateDataImpl(TenantId tenantId, Customer customer) {
                     if (StringUtils.isEmpty(customer.getTitle())) {
                     if (StringUtils.isEmpty(customer.getTitle())) {
                         throw new DataValidationException("Customer title should be specified!");
                         throw new DataValidationException("Customer title should be specified!");
                     }
                     }
@@ -196,7 +196,7 @@ public class CustomerServiceImpl extends AbstractEntityService implements Custom
                     if (customer.getTenantId() == null) {
                     if (customer.getTenantId() == null) {
                         throw new DataValidationException("Customer should be assigned to tenant!");
                         throw new DataValidationException("Customer should be assigned to tenant!");
                     } else {
                     } else {
-                        Tenant tenant = tenantDao.findById(customer.getTenantId().getId());
+                        Tenant tenant = tenantDao.findById(tenantId, customer.getTenantId().getId());
                         if (tenant == null) {
                         if (tenant == null) {
                             throw new DataValidationException("Customer is referencing to non-existent tenant!");
                             throw new DataValidationException("Customer is referencing to non-existent tenant!");
                         }
                         }
@@ -208,13 +208,13 @@ public class CustomerServiceImpl extends AbstractEntityService implements Custom
             new PaginatedRemover<TenantId, Customer>() {
             new PaginatedRemover<TenantId, Customer>() {
 
 
                 @Override
                 @Override
-                protected List<Customer> findEntities(TenantId id, TextPageLink pageLink) {
+                protected List<Customer> findEntities(TenantId tenantId, TenantId id, TextPageLink pageLink) {
                     return customerDao.findCustomersByTenantId(id.getId(), pageLink);
                     return customerDao.findCustomersByTenantId(id.getId(), pageLink);
                 }
                 }
 
 
                 @Override
                 @Override
-                protected void removeEntity(Customer entity) {
-                    deleteCustomer(new CustomerId(entity.getUuidId()));
+                protected void removeEntity(TenantId tenantId, Customer entity) {
+                    deleteCustomer(tenantId, new CustomerId(entity.getUuidId()));
                 }
                 }
             };
             };
 }
 }

@@ -23,6 +23,7 @@ import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.data.DashboardInfo;
 import org.thingsboard.server.common.data.DashboardInfo;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.CustomerId;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.common.data.page.TimePageLink;
 import org.thingsboard.server.common.data.page.TimePageLink;
 import org.thingsboard.server.common.data.relation.EntityRelation;
 import org.thingsboard.server.common.data.relation.EntityRelation;
@@ -64,7 +65,7 @@ public class CassandraDashboardInfoDao extends CassandraAbstractSearchTextDao<Da
     @Override
     @Override
     public List<DashboardInfo> findDashboardsByTenantId(UUID tenantId, TextPageLink pageLink) {
     public List<DashboardInfo> findDashboardsByTenantId(UUID tenantId, TextPageLink pageLink) {
         log.debug("Try to find dashboards by tenantId [{}] and pageLink [{}]", tenantId, pageLink);
         log.debug("Try to find dashboards by tenantId [{}] and pageLink [{}]", tenantId, pageLink);
-        List<DashboardInfoEntity> dashboardEntities = findPageWithTextSearch(DASHBOARD_BY_TENANT_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
+        List<DashboardInfoEntity> dashboardEntities = findPageWithTextSearch(new TenantId(tenantId), DASHBOARD_BY_TENANT_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
                 Collections.singletonList(eq(DASHBOARD_TENANT_ID_PROPERTY, tenantId)),
                 Collections.singletonList(eq(DASHBOARD_TENANT_ID_PROPERTY, tenantId)),
                 pageLink);
                 pageLink);
 
 
@@ -76,12 +77,12 @@ public class CassandraDashboardInfoDao extends CassandraAbstractSearchTextDao<Da
     public ListenableFuture<List<DashboardInfo>> findDashboardsByTenantIdAndCustomerId(UUID tenantId, UUID customerId, TimePageLink pageLink) {
     public ListenableFuture<List<DashboardInfo>> findDashboardsByTenantIdAndCustomerId(UUID tenantId, UUID customerId, TimePageLink pageLink) {
         log.debug("Try to find dashboards by tenantId [{}], customerId[{}] and pageLink [{}]", tenantId, customerId, pageLink);
         log.debug("Try to find dashboards by tenantId [{}], customerId[{}] and pageLink [{}]", tenantId, customerId, pageLink);
 
 
-        ListenableFuture<List<EntityRelation>> relations = relationDao.findRelations(new CustomerId(customerId), EntityRelation.CONTAINS_TYPE, RelationTypeGroup.DASHBOARD, EntityType.DASHBOARD, pageLink);
+        ListenableFuture<List<EntityRelation>> relations = relationDao.findRelations(new TenantId(tenantId), new CustomerId(customerId), EntityRelation.CONTAINS_TYPE, RelationTypeGroup.DASHBOARD, EntityType.DASHBOARD, pageLink);
 
 
         return Futures.transformAsync(relations, input -> {
         return Futures.transformAsync(relations, input -> {
             List<ListenableFuture<DashboardInfo>> dashboardFutures = new ArrayList<>(input.size());
             List<ListenableFuture<DashboardInfo>> dashboardFutures = new ArrayList<>(input.size());
             for (EntityRelation relation : input) {
             for (EntityRelation relation : input) {
-                dashboardFutures.add(findByIdAsync(relation.getTo().getId()));
+                dashboardFutures.add(findByIdAsync(new TenantId(tenantId), relation.getTo().getId()));
             }
             }
             return Futures.successfulAsList(dashboardFutures);
             return Futures.successfulAsList(dashboardFutures);
         });
         });

@@ -16,6 +16,7 @@
 package org.thingsboard.server.dao.dashboard;
 package org.thingsboard.server.dao.dashboard;
 
 
 import org.thingsboard.server.common.data.Dashboard;
 import org.thingsboard.server.common.data.Dashboard;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.dao.Dao;
 import org.thingsboard.server.dao.Dao;
 
 
 /**
 /**
@@ -29,6 +30,6 @@ public interface DashboardDao extends Dao<Dashboard> {
      * @param dashboard the dashboard object
      * @param dashboard the dashboard object
      * @return saved dashboard object
      * @return saved dashboard object
      */
      */
-    Dashboard save(Dashboard dashboard);
+    Dashboard save(TenantId tenantId, Dashboard dashboard);
 
 
 }
 }

@@ -28,21 +28,21 @@ import org.thingsboard.server.common.data.page.TimePageLink;
 
 
 public interface DashboardService {
 public interface DashboardService {
     
     
-    Dashboard findDashboardById(DashboardId dashboardId);
+    Dashboard findDashboardById(TenantId tenantId, DashboardId dashboardId);
 
 
-    ListenableFuture<Dashboard> findDashboardByIdAsync(DashboardId dashboardId);
+    ListenableFuture<Dashboard> findDashboardByIdAsync(TenantId tenantId, DashboardId dashboardId);
 
 
-    DashboardInfo findDashboardInfoById(DashboardId dashboardId);
+    DashboardInfo findDashboardInfoById(TenantId tenantId, DashboardId dashboardId);
 
 
-    ListenableFuture<DashboardInfo> findDashboardInfoByIdAsync(DashboardId dashboardId);
+    ListenableFuture<DashboardInfo> findDashboardInfoByIdAsync(TenantId tenantId, DashboardId dashboardId);
 
 
     Dashboard saveDashboard(Dashboard dashboard);
     Dashboard saveDashboard(Dashboard dashboard);
 
 
-    Dashboard assignDashboardToCustomer(DashboardId dashboardId, CustomerId customerId);
+    Dashboard assignDashboardToCustomer(TenantId tenantId, DashboardId dashboardId, CustomerId customerId);
 
 
-    Dashboard unassignDashboardFromCustomer(DashboardId dashboardId, CustomerId customerId);
+    Dashboard unassignDashboardFromCustomer(TenantId tenantId, DashboardId dashboardId, CustomerId customerId);
 
 
-    void deleteDashboard(DashboardId dashboardId);
+    void deleteDashboard(TenantId tenantId, DashboardId dashboardId);
 
 
     TextPageData<DashboardInfo> findDashboardsByTenantId(TenantId tenantId, TextPageLink pageLink);
     TextPageData<DashboardInfo> findDashboardsByTenantId(TenantId tenantId, TextPageLink pageLink);
 
 
@@ -50,8 +50,8 @@ public interface DashboardService {
 
 
     ListenableFuture<TimePageData<DashboardInfo>> findDashboardsByTenantIdAndCustomerId(TenantId tenantId, CustomerId customerId, TimePageLink pageLink);
     ListenableFuture<TimePageData<DashboardInfo>> findDashboardsByTenantIdAndCustomerId(TenantId tenantId, CustomerId customerId, TimePageLink pageLink);
 
 
-    void unassignCustomerDashboards(CustomerId customerId);
+    void unassignCustomerDashboards(TenantId tenantId, CustomerId customerId);
 
 
-    void updateCustomerDashboards(CustomerId customerId);
+    void updateCustomerDashboards(TenantId tenantId, CustomerId customerId);
 
 
 }
 }

@@ -69,44 +69,44 @@ public class DashboardServiceImpl extends AbstractEntityService implements Dashb
     private CustomerDao customerDao;
     private CustomerDao customerDao;
 
 
     @Override
     @Override
-    public Dashboard findDashboardById(DashboardId dashboardId) {
+    public Dashboard findDashboardById(TenantId tenantId, DashboardId dashboardId) {
         log.trace("Executing findDashboardById [{}]", dashboardId);
         log.trace("Executing findDashboardById [{}]", dashboardId);
         Validator.validateId(dashboardId, INCORRECT_DASHBOARD_ID + dashboardId);
         Validator.validateId(dashboardId, INCORRECT_DASHBOARD_ID + dashboardId);
-        return dashboardDao.findById(dashboardId.getId());
+        return dashboardDao.findById(tenantId, dashboardId.getId());
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<Dashboard> findDashboardByIdAsync(DashboardId dashboardId) {
+    public ListenableFuture<Dashboard> findDashboardByIdAsync(TenantId tenantId, DashboardId dashboardId) {
         log.trace("Executing findDashboardByIdAsync [{}]", dashboardId);
         log.trace("Executing findDashboardByIdAsync [{}]", dashboardId);
         validateId(dashboardId, INCORRECT_DASHBOARD_ID + dashboardId);
         validateId(dashboardId, INCORRECT_DASHBOARD_ID + dashboardId);
-        return dashboardDao.findByIdAsync(dashboardId.getId());
+        return dashboardDao.findByIdAsync(tenantId, dashboardId.getId());
     }
     }
 
 
     @Override
     @Override
-    public DashboardInfo findDashboardInfoById(DashboardId dashboardId) {
+    public DashboardInfo findDashboardInfoById(TenantId tenantId, DashboardId dashboardId) {
         log.trace("Executing findDashboardInfoById [{}]", dashboardId);
         log.trace("Executing findDashboardInfoById [{}]", dashboardId);
         Validator.validateId(dashboardId, INCORRECT_DASHBOARD_ID + dashboardId);
         Validator.validateId(dashboardId, INCORRECT_DASHBOARD_ID + dashboardId);
-        return dashboardInfoDao.findById(dashboardId.getId());
+        return dashboardInfoDao.findById(tenantId, dashboardId.getId());
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<DashboardInfo> findDashboardInfoByIdAsync(DashboardId dashboardId) {
+    public ListenableFuture<DashboardInfo> findDashboardInfoByIdAsync(TenantId tenantId, DashboardId dashboardId) {
         log.trace("Executing findDashboardInfoByIdAsync [{}]", dashboardId);
         log.trace("Executing findDashboardInfoByIdAsync [{}]", dashboardId);
         validateId(dashboardId, INCORRECT_DASHBOARD_ID + dashboardId);
         validateId(dashboardId, INCORRECT_DASHBOARD_ID + dashboardId);
-        return dashboardInfoDao.findByIdAsync(dashboardId.getId());
+        return dashboardInfoDao.findByIdAsync(tenantId, dashboardId.getId());
     }
     }
 
 
     @Override
     @Override
     public Dashboard saveDashboard(Dashboard dashboard) {
     public Dashboard saveDashboard(Dashboard dashboard) {
         log.trace("Executing saveDashboard [{}]", dashboard);
         log.trace("Executing saveDashboard [{}]", dashboard);
-        dashboardValidator.validate(dashboard);
-        return dashboardDao.save(dashboard);
+        dashboardValidator.validate(dashboard, DashboardInfo::getTenantId);
+        return dashboardDao.save(dashboard.getTenantId(), dashboard);
     }
     }
     
     
     @Override
     @Override
-    public Dashboard assignDashboardToCustomer(DashboardId dashboardId, CustomerId customerId) {
-        Dashboard dashboard = findDashboardById(dashboardId);
-        Customer customer = customerDao.findById(customerId.getId());
+    public Dashboard assignDashboardToCustomer(TenantId tenantId, DashboardId dashboardId, CustomerId customerId) {
+        Dashboard dashboard = findDashboardById(tenantId, dashboardId);
+        Customer customer = customerDao.findById(tenantId, customerId.getId());
         if (customer == null) {
         if (customer == null) {
             throw new DataValidationException("Can't assign dashboard to non-existent customer!");
             throw new DataValidationException("Can't assign dashboard to non-existent customer!");
         }
         }
@@ -115,7 +115,7 @@ public class DashboardServiceImpl extends AbstractEntityService implements Dashb
         }
         }
         if (dashboard.addAssignedCustomer(customer)) {
         if (dashboard.addAssignedCustomer(customer)) {
             try {
             try {
-                createRelation(new EntityRelation(customerId, dashboardId, EntityRelation.CONTAINS_TYPE, RelationTypeGroup.DASHBOARD));
+                createRelation(tenantId, new EntityRelation(customerId, dashboardId, EntityRelation.CONTAINS_TYPE, RelationTypeGroup.DASHBOARD));
             } catch (ExecutionException | InterruptedException e) {
             } catch (ExecutionException | InterruptedException e) {
                 log.warn("[{}] Failed to create dashboard relation. Customer Id: [{}]", dashboardId, customerId);
                 log.warn("[{}] Failed to create dashboard relation. Customer Id: [{}]", dashboardId, customerId);
                 throw new RuntimeException(e);
                 throw new RuntimeException(e);
@@ -127,15 +127,15 @@ public class DashboardServiceImpl extends AbstractEntityService implements Dashb
     }
     }
 
 
     @Override
     @Override
-    public Dashboard unassignDashboardFromCustomer(DashboardId dashboardId, CustomerId customerId) {
-        Dashboard dashboard = findDashboardById(dashboardId);
-        Customer customer = customerDao.findById(customerId.getId());
+    public Dashboard unassignDashboardFromCustomer(TenantId tenantId, DashboardId dashboardId, CustomerId customerId) {
+        Dashboard dashboard = findDashboardById(tenantId, dashboardId);
+        Customer customer = customerDao.findById(tenantId, customerId.getId());
         if (customer == null) {
         if (customer == null) {
             throw new DataValidationException("Can't unassign dashboard from non-existent customer!");
             throw new DataValidationException("Can't unassign dashboard from non-existent customer!");
         }
         }
         if (dashboard.removeAssignedCustomer(customer)) {
         if (dashboard.removeAssignedCustomer(customer)) {
             try {
             try {
-                deleteRelation(new EntityRelation(customerId, dashboardId, EntityRelation.CONTAINS_TYPE, RelationTypeGroup.DASHBOARD));
+                deleteRelation(tenantId, new EntityRelation(customerId, dashboardId, EntityRelation.CONTAINS_TYPE, RelationTypeGroup.DASHBOARD));
             } catch (ExecutionException | InterruptedException e) {
             } catch (ExecutionException | InterruptedException e) {
                 log.warn("[{}] Failed to delete dashboard relation. Customer Id: [{}]", dashboardId, customerId);
                 log.warn("[{}] Failed to delete dashboard relation. Customer Id: [{}]", dashboardId, customerId);
                 throw new RuntimeException(e);
                 throw new RuntimeException(e);
@@ -146,8 +146,8 @@ public class DashboardServiceImpl extends AbstractEntityService implements Dashb
         }
         }
     }
     }
 
 
-    private Dashboard updateAssignedCustomer(DashboardId dashboardId, Customer customer) {
-        Dashboard dashboard = findDashboardById(dashboardId);
+    private Dashboard updateAssignedCustomer(TenantId tenantId, DashboardId dashboardId, Customer customer) {
+        Dashboard dashboard = findDashboardById(tenantId, dashboardId);
         if (dashboard.updateAssignedCustomer(customer)) {
         if (dashboard.updateAssignedCustomer(customer)) {
             return saveDashboard(dashboard);
             return saveDashboard(dashboard);
         } else {
         } else {
@@ -155,22 +155,22 @@ public class DashboardServiceImpl extends AbstractEntityService implements Dashb
         }
         }
     }
     }
 
 
-    private void deleteRelation(EntityRelation dashboardRelation) throws ExecutionException, InterruptedException {
+    private void deleteRelation(TenantId tenantId, EntityRelation dashboardRelation) throws ExecutionException, InterruptedException {
         log.debug("Deleting Dashboard relation: {}", dashboardRelation);
         log.debug("Deleting Dashboard relation: {}", dashboardRelation);
-        relationService.deleteRelationAsync(dashboardRelation).get();
+        relationService.deleteRelationAsync(tenantId, dashboardRelation).get();
     }
     }
 
 
-    private void createRelation(EntityRelation dashboardRelation) throws ExecutionException, InterruptedException {
+    private void createRelation(TenantId tenantId, EntityRelation dashboardRelation) throws ExecutionException, InterruptedException {
         log.debug("Creating Dashboard relation: {}", dashboardRelation);
         log.debug("Creating Dashboard relation: {}", dashboardRelation);
-        relationService.saveRelationAsync(dashboardRelation).get();
+        relationService.saveRelationAsync(tenantId, dashboardRelation).get();
     }
     }
 
 
     @Override
     @Override
-    public void deleteDashboard(DashboardId dashboardId) {
+    public void deleteDashboard(TenantId tenantId, DashboardId dashboardId) {
         log.trace("Executing deleteDashboard [{}]", dashboardId);
         log.trace("Executing deleteDashboard [{}]", dashboardId);
         Validator.validateId(dashboardId, INCORRECT_DASHBOARD_ID + dashboardId);
         Validator.validateId(dashboardId, INCORRECT_DASHBOARD_ID + dashboardId);
-        deleteEntityRelations(dashboardId);
-        dashboardDao.removeById(dashboardId.getId());
+        deleteEntityRelations(tenantId, dashboardId);
+        dashboardDao.removeById(tenantId, dashboardId.getId());
     }
     }
 
 
     @Override
     @Override
@@ -186,7 +186,7 @@ public class DashboardServiceImpl extends AbstractEntityService implements Dashb
     public void deleteDashboardsByTenantId(TenantId tenantId) {
     public void deleteDashboardsByTenantId(TenantId tenantId) {
         log.trace("Executing deleteDashboardsByTenantId, tenantId [{}]", tenantId);
         log.trace("Executing deleteDashboardsByTenantId, tenantId [{}]", tenantId);
         Validator.validateId(tenantId, INCORRECT_TENANT_ID + tenantId);
         Validator.validateId(tenantId, INCORRECT_TENANT_ID + tenantId);
-        tenantDashboardsRemover.removeEntities(tenantId);
+        tenantDashboardsRemover.removeEntities(tenantId, tenantId);
     }
     }
 
 
     @Override
     @Override
@@ -207,10 +207,10 @@ public class DashboardServiceImpl extends AbstractEntityService implements Dashb
     }
     }
 
 
     @Override
     @Override
-    public void unassignCustomerDashboards(CustomerId customerId) {
+    public void unassignCustomerDashboards(TenantId tenantId, CustomerId customerId) {
         log.trace("Executing unassignCustomerDashboards, customerId [{}]", customerId);
         log.trace("Executing unassignCustomerDashboards, customerId [{}]", customerId);
         Validator.validateId(customerId, "Incorrect customerId " + customerId);
         Validator.validateId(customerId, "Incorrect customerId " + customerId);
-        Customer customer = customerDao.findById(customerId.getId());
+        Customer customer = customerDao.findById(tenantId, customerId.getId());
         if (customer == null) {
         if (customer == null) {
             throw new DataValidationException("Can't unassign dashboards from non-existent customer!");
             throw new DataValidationException("Can't unassign dashboards from non-existent customer!");
         }
         }
@@ -218,10 +218,10 @@ public class DashboardServiceImpl extends AbstractEntityService implements Dashb
     }
     }
 
 
     @Override
     @Override
-    public void updateCustomerDashboards(CustomerId customerId) {
+    public void updateCustomerDashboards(TenantId tenantId, CustomerId customerId) {
         log.trace("Executing updateCustomerDashboards, customerId [{}]", customerId);
         log.trace("Executing updateCustomerDashboards, customerId [{}]", customerId);
         Validator.validateId(customerId, "Incorrect customerId " + customerId);
         Validator.validateId(customerId, "Incorrect customerId " + customerId);
-        Customer customer = customerDao.findById(customerId.getId());
+        Customer customer = customerDao.findById(tenantId, customerId.getId());
         if (customer == null) {
         if (customer == null) {
             throw new DataValidationException("Can't update dashboards for non-existent customer!");
             throw new DataValidationException("Can't update dashboards for non-existent customer!");
         }
         }
@@ -231,14 +231,14 @@ public class DashboardServiceImpl extends AbstractEntityService implements Dashb
     private DataValidator<Dashboard> dashboardValidator =
     private DataValidator<Dashboard> dashboardValidator =
             new DataValidator<Dashboard>() {
             new DataValidator<Dashboard>() {
                 @Override
                 @Override
-                protected void validateDataImpl(Dashboard dashboard) {
+                protected void validateDataImpl(TenantId tenantId, Dashboard dashboard) {
                     if (StringUtils.isEmpty(dashboard.getTitle())) {
                     if (StringUtils.isEmpty(dashboard.getTitle())) {
                         throw new DataValidationException("Dashboard title should be specified!");
                         throw new DataValidationException("Dashboard title should be specified!");
                     }
                     }
                     if (dashboard.getTenantId() == null) {
                     if (dashboard.getTenantId() == null) {
                         throw new DataValidationException("Dashboard should be assigned to tenant!");
                         throw new DataValidationException("Dashboard should be assigned to tenant!");
                     } else {
                     } else {
-                        Tenant tenant = tenantDao.findById(dashboard.getTenantId().getId());
+                        Tenant tenant = tenantDao.findById(tenantId, dashboard.getTenantId().getId());
                         if (tenant == null) {
                         if (tenant == null) {
                             throw new DataValidationException("Dashboard is referencing to non-existent tenant!");
                             throw new DataValidationException("Dashboard is referencing to non-existent tenant!");
                         }
                         }
@@ -250,13 +250,13 @@ public class DashboardServiceImpl extends AbstractEntityService implements Dashb
             new PaginatedRemover<TenantId, DashboardInfo>() {
             new PaginatedRemover<TenantId, DashboardInfo>() {
         
         
         @Override
         @Override
-        protected List<DashboardInfo> findEntities(TenantId id, TextPageLink pageLink) {
+        protected List<DashboardInfo> findEntities(TenantId tenantId, TenantId id, TextPageLink pageLink) {
             return dashboardInfoDao.findDashboardsByTenantId(id.getId(), pageLink);
             return dashboardInfoDao.findDashboardsByTenantId(id.getId(), pageLink);
         }
         }
 
 
         @Override
         @Override
-        protected void removeEntity(DashboardInfo entity) {
-            deleteDashboard(new DashboardId(entity.getUuidId()));
+        protected void removeEntity(TenantId tenantId, DashboardInfo entity) {
+            deleteDashboard(tenantId, new DashboardId(entity.getUuidId()));
         }
         }
     };
     };
     
     
@@ -280,7 +280,7 @@ public class DashboardServiceImpl extends AbstractEntityService implements Dashb
 
 
         @Override
         @Override
         protected void removeEntity(DashboardInfo entity) {
         protected void removeEntity(DashboardInfo entity) {
-            unassignDashboardFromCustomer(new DashboardId(entity.getUuidId()), this.customer.getId());
+            unassignDashboardFromCustomer(customer.getTenantId(), new DashboardId(entity.getUuidId()), this.customer.getId());
         }
         }
         
         
     }
     }
@@ -305,7 +305,7 @@ public class DashboardServiceImpl extends AbstractEntityService implements Dashb
 
 
         @Override
         @Override
         protected void removeEntity(DashboardInfo entity) {
         protected void removeEntity(DashboardInfo entity) {
-            updateAssignedCustomer(new DashboardId(entity.getUuidId()), this.customer);
+            updateAssignedCustomer(customer.getTenantId(), new DashboardId(entity.getUuidId()), this.customer);
         }
         }
 
 
     }
     }

@@ -18,6 +18,7 @@ package org.thingsboard.server.dao.device;
 import com.datastax.driver.core.querybuilder.Select.Where;
 import com.datastax.driver.core.querybuilder.Select.Where;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
 import org.springframework.stereotype.Component;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.security.DeviceCredentials;
 import org.thingsboard.server.common.data.security.DeviceCredentials;
 import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.model.ModelConstants;
 import org.thingsboard.server.dao.model.ModelConstants;
@@ -46,23 +47,23 @@ public class CassandraDeviceCredentialsDao extends CassandraAbstractModelDao<Dev
     }
     }
 
 
     @Override
     @Override
-    public DeviceCredentials findByDeviceId(UUID deviceId) {
+    public DeviceCredentials findByDeviceId(TenantId tenantId, UUID deviceId) {
         log.debug("Try to find device credentials by deviceId [{}] ", deviceId);
         log.debug("Try to find device credentials by deviceId [{}] ", deviceId);
         Where query = select().from(ModelConstants.DEVICE_CREDENTIALS_BY_DEVICE_COLUMN_FAMILY_NAME)
         Where query = select().from(ModelConstants.DEVICE_CREDENTIALS_BY_DEVICE_COLUMN_FAMILY_NAME)
                 .where(eq(ModelConstants.DEVICE_CREDENTIALS_DEVICE_ID_PROPERTY, deviceId));
                 .where(eq(ModelConstants.DEVICE_CREDENTIALS_DEVICE_ID_PROPERTY, deviceId));
         log.trace("Execute query {}", query);
         log.trace("Execute query {}", query);
-        DeviceCredentialsEntity deviceCredentialsEntity = findOneByStatement(query);
+        DeviceCredentialsEntity deviceCredentialsEntity = findOneByStatement(tenantId, query);
         log.trace("Found device credentials [{}] by deviceId [{}]", deviceCredentialsEntity, deviceId);
         log.trace("Found device credentials [{}] by deviceId [{}]", deviceCredentialsEntity, deviceId);
         return DaoUtil.getData(deviceCredentialsEntity);
         return DaoUtil.getData(deviceCredentialsEntity);
     }
     }
     
     
     @Override
     @Override
-    public DeviceCredentials findByCredentialsId(String credentialsId) {
+    public DeviceCredentials findByCredentialsId(TenantId tenantId, String credentialsId) {
         log.debug("Try to find device credentials by credentialsId [{}] ", credentialsId);
         log.debug("Try to find device credentials by credentialsId [{}] ", credentialsId);
         Where query = select().from(ModelConstants.DEVICE_CREDENTIALS_BY_CREDENTIALS_ID_COLUMN_FAMILY_NAME)
         Where query = select().from(ModelConstants.DEVICE_CREDENTIALS_BY_CREDENTIALS_ID_COLUMN_FAMILY_NAME)
                 .where(eq(ModelConstants.DEVICE_CREDENTIALS_CREDENTIALS_ID_PROPERTY, credentialsId));
                 .where(eq(ModelConstants.DEVICE_CREDENTIALS_CREDENTIALS_ID_PROPERTY, credentialsId));
         log.trace("Execute query {}", query);
         log.trace("Execute query {}", query);
-        DeviceCredentialsEntity deviceCredentialsEntity = findOneByStatement(query);
+        DeviceCredentialsEntity deviceCredentialsEntity = findOneByStatement(tenantId, query);
         log.trace("Found device credentials [{}] by credentialsId [{}]", deviceCredentialsEntity, credentialsId);
         log.trace("Found device credentials [{}] by credentialsId [{}]", deviceCredentialsEntity, credentialsId);
         return DaoUtil.getData(deviceCredentialsEntity);
         return DaoUtil.getData(deviceCredentialsEntity);
     }
     }

@@ -28,6 +28,7 @@ import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.EntitySubtype;
 import org.thingsboard.server.common.data.EntitySubtype;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.EntityType;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.model.EntitySubtypeEntity;
 import org.thingsboard.server.dao.model.EntitySubtypeEntity;
@@ -77,19 +78,19 @@ public class CassandraDeviceDao extends CassandraAbstractSearchTextDao<DeviceEnt
     }
     }
 
 
     @Override
     @Override
-    public Device save(Device domain) {
-        Device savedDevice = super.save(domain);
+    public Device save(TenantId tenantId, Device domain) {
+        Device savedDevice = super.save(tenantId, domain);
         EntitySubtype entitySubtype = new EntitySubtype(savedDevice.getTenantId(), EntityType.DEVICE, savedDevice.getType());
         EntitySubtype entitySubtype = new EntitySubtype(savedDevice.getTenantId(), EntityType.DEVICE, savedDevice.getType());
         EntitySubtypeEntity entitySubtypeEntity = new EntitySubtypeEntity(entitySubtype);
         EntitySubtypeEntity entitySubtypeEntity = new EntitySubtypeEntity(entitySubtype);
         Statement saveStatement = cluster.getMapper(EntitySubtypeEntity.class).saveQuery(entitySubtypeEntity);
         Statement saveStatement = cluster.getMapper(EntitySubtypeEntity.class).saveQuery(entitySubtypeEntity);
-        executeWrite(saveStatement);
+        executeWrite(tenantId, saveStatement);
         return savedDevice;
         return savedDevice;
     }
     }
 
 
     @Override
     @Override
     public List<Device> findDevicesByTenantId(UUID tenantId, TextPageLink pageLink) {
     public List<Device> findDevicesByTenantId(UUID tenantId, TextPageLink pageLink) {
         log.debug("Try to find devices by tenantId [{}] and pageLink [{}]", tenantId, pageLink);
         log.debug("Try to find devices by tenantId [{}] and pageLink [{}]", tenantId, pageLink);
-        List<DeviceEntity> deviceEntities = findPageWithTextSearch(DEVICE_BY_TENANT_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
+        List<DeviceEntity> deviceEntities = findPageWithTextSearch(new TenantId(tenantId), DEVICE_BY_TENANT_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
                 Collections.singletonList(eq(DEVICE_TENANT_ID_PROPERTY, tenantId)), pageLink);
                 Collections.singletonList(eq(DEVICE_TENANT_ID_PROPERTY, tenantId)), pageLink);
 
 
         log.trace("Found devices [{}] by tenantId [{}] and pageLink [{}]", deviceEntities, tenantId, pageLink);
         log.trace("Found devices [{}] by tenantId [{}] and pageLink [{}]", deviceEntities, tenantId, pageLink);
@@ -99,7 +100,7 @@ public class CassandraDeviceDao extends CassandraAbstractSearchTextDao<DeviceEnt
     @Override
     @Override
     public List<Device> findDevicesByTenantIdAndType(UUID tenantId, String type, TextPageLink pageLink) {
     public List<Device> findDevicesByTenantIdAndType(UUID tenantId, String type, TextPageLink pageLink) {
         log.debug("Try to find devices by tenantId [{}], type [{}] and pageLink [{}]", tenantId, type, pageLink);
         log.debug("Try to find devices by tenantId [{}], type [{}] and pageLink [{}]", tenantId, type, pageLink);
-        List<DeviceEntity> deviceEntities = findPageWithTextSearch(DEVICE_BY_TENANT_BY_TYPE_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
+        List<DeviceEntity> deviceEntities = findPageWithTextSearch(new TenantId(tenantId), DEVICE_BY_TENANT_BY_TYPE_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
                 Arrays.asList(eq(DEVICE_TYPE_PROPERTY, type),
                 Arrays.asList(eq(DEVICE_TYPE_PROPERTY, type),
                         eq(DEVICE_TENANT_ID_PROPERTY, tenantId)), pageLink);
                         eq(DEVICE_TENANT_ID_PROPERTY, tenantId)), pageLink);
         log.trace("Found devices [{}] by tenantId [{}], type [{}] and pageLink [{}]", deviceEntities, tenantId, type, pageLink);
         log.trace("Found devices [{}] by tenantId [{}], type [{}] and pageLink [{}]", deviceEntities, tenantId, type, pageLink);
@@ -113,13 +114,13 @@ public class CassandraDeviceDao extends CassandraAbstractSearchTextDao<DeviceEnt
         Select.Where query = select.where();
         Select.Where query = select.where();
         query.and(eq(DEVICE_TENANT_ID_PROPERTY, tenantId));
         query.and(eq(DEVICE_TENANT_ID_PROPERTY, tenantId));
         query.and(in(ID_PROPERTY, deviceIds));
         query.and(in(ID_PROPERTY, deviceIds));
-        return findListByStatementAsync(query);
+        return findListByStatementAsync(new TenantId(tenantId), query);
     }
     }
 
 
     @Override
     @Override
     public List<Device> findDevicesByTenantIdAndCustomerId(UUID tenantId, UUID customerId, TextPageLink pageLink) {
     public List<Device> findDevicesByTenantIdAndCustomerId(UUID tenantId, UUID customerId, TextPageLink pageLink) {
         log.debug("Try to find devices by tenantId [{}], customerId[{}] and pageLink [{}]", tenantId, customerId, pageLink);
         log.debug("Try to find devices by tenantId [{}], customerId[{}] and pageLink [{}]", tenantId, customerId, pageLink);
-        List<DeviceEntity> deviceEntities = findPageWithTextSearch(DEVICE_BY_CUSTOMER_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
+        List<DeviceEntity> deviceEntities = findPageWithTextSearch(new TenantId(tenantId), DEVICE_BY_CUSTOMER_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
                 Arrays.asList(eq(DEVICE_CUSTOMER_ID_PROPERTY, customerId),
                 Arrays.asList(eq(DEVICE_CUSTOMER_ID_PROPERTY, customerId),
                         eq(DEVICE_TENANT_ID_PROPERTY, tenantId)),
                         eq(DEVICE_TENANT_ID_PROPERTY, tenantId)),
                 pageLink);
                 pageLink);
@@ -131,7 +132,7 @@ public class CassandraDeviceDao extends CassandraAbstractSearchTextDao<DeviceEnt
     @Override
     @Override
     public List<Device> findDevicesByTenantIdAndCustomerIdAndType(UUID tenantId, UUID customerId, String type, TextPageLink pageLink) {
     public List<Device> findDevicesByTenantIdAndCustomerIdAndType(UUID tenantId, UUID customerId, String type, TextPageLink pageLink) {
         log.debug("Try to find devices by tenantId [{}], customerId [{}], type [{}] and pageLink [{}]", tenantId, customerId, type, pageLink);
         log.debug("Try to find devices by tenantId [{}], customerId [{}], type [{}] and pageLink [{}]", tenantId, customerId, type, pageLink);
-        List<DeviceEntity> deviceEntities = findPageWithTextSearch(DEVICE_BY_CUSTOMER_BY_TYPE_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
+        List<DeviceEntity> deviceEntities = findPageWithTextSearch(new TenantId(tenantId), DEVICE_BY_CUSTOMER_BY_TYPE_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
                 Arrays.asList(eq(DEVICE_TYPE_PROPERTY, type),
                 Arrays.asList(eq(DEVICE_TYPE_PROPERTY, type),
                         eq(DEVICE_CUSTOMER_ID_PROPERTY, customerId),
                         eq(DEVICE_CUSTOMER_ID_PROPERTY, customerId),
                         eq(DEVICE_TENANT_ID_PROPERTY, tenantId)),
                         eq(DEVICE_TENANT_ID_PROPERTY, tenantId)),
@@ -149,7 +150,7 @@ public class CassandraDeviceDao extends CassandraAbstractSearchTextDao<DeviceEnt
         query.and(eq(DEVICE_TENANT_ID_PROPERTY, tenantId));
         query.and(eq(DEVICE_TENANT_ID_PROPERTY, tenantId));
         query.and(eq(DEVICE_CUSTOMER_ID_PROPERTY, customerId));
         query.and(eq(DEVICE_CUSTOMER_ID_PROPERTY, customerId));
         query.and(in(ID_PROPERTY, deviceIds));
         query.and(in(ID_PROPERTY, deviceIds));
-        return findListByStatementAsync(query);
+        return findListByStatementAsync(new TenantId(tenantId), query);
     }
     }
 
 
     @Override
     @Override
@@ -158,7 +159,7 @@ public class CassandraDeviceDao extends CassandraAbstractSearchTextDao<DeviceEnt
         Select.Where query = select.where();
         Select.Where query = select.where();
         query.and(eq(DEVICE_TENANT_ID_PROPERTY, tenantId));
         query.and(eq(DEVICE_TENANT_ID_PROPERTY, tenantId));
         query.and(eq(DEVICE_NAME_PROPERTY, deviceName));
         query.and(eq(DEVICE_NAME_PROPERTY, deviceName));
-        return Optional.ofNullable(DaoUtil.getData(findOneByStatement(query)));
+        return Optional.ofNullable(DaoUtil.getData(findOneByStatement(new TenantId(tenantId), query)));
     }
     }
 
 
     @Override
     @Override
@@ -168,7 +169,7 @@ public class CassandraDeviceDao extends CassandraAbstractSearchTextDao<DeviceEnt
         query.and(eq(ENTITY_SUBTYPE_TENANT_ID_PROPERTY, tenantId));
         query.and(eq(ENTITY_SUBTYPE_TENANT_ID_PROPERTY, tenantId));
         query.and(eq(ENTITY_SUBTYPE_ENTITY_TYPE_PROPERTY, EntityType.DEVICE));
         query.and(eq(ENTITY_SUBTYPE_ENTITY_TYPE_PROPERTY, EntityType.DEVICE));
         query.setConsistencyLevel(cluster.getDefaultReadConsistencyLevel());
         query.setConsistencyLevel(cluster.getDefaultReadConsistencyLevel());
-        ResultSetFuture resultSetFuture = executeAsyncRead(query);
+        ResultSetFuture resultSetFuture = executeAsyncRead(new TenantId(tenantId), query);
         return Futures.transform(resultSetFuture, new Function<ResultSet, List<EntitySubtype>>() {
         return Futures.transform(resultSetFuture, new Function<ResultSet, List<EntitySubtype>>() {
             @Nullable
             @Nullable
             @Override
             @Override

@@ -15,6 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.device;
 package org.thingsboard.server.dao.device;
 
 
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.security.DeviceCredentials;
 import org.thingsboard.server.common.data.security.DeviceCredentials;
 import org.thingsboard.server.dao.Dao;
 import org.thingsboard.server.dao.Dao;
 
 
@@ -28,10 +29,11 @@ public interface DeviceCredentialsDao extends Dao<DeviceCredentials> {
     /**
     /**
      * Save or update device credentials object
      * Save or update device credentials object
      *
      *
+     * @param tenantId the device tenant id
      * @param deviceCredentials the device credentials object
      * @param deviceCredentials the device credentials object
      * @return saved device credentials object
      * @return saved device credentials object
      */
      */
-    DeviceCredentials save(DeviceCredentials deviceCredentials);
+    DeviceCredentials save(TenantId tenantId, DeviceCredentials deviceCredentials);
 
 
     /**
     /**
      * Find device credentials by device id.
      * Find device credentials by device id.
@@ -39,7 +41,7 @@ public interface DeviceCredentialsDao extends Dao<DeviceCredentials> {
      * @param deviceId the device id
      * @param deviceId the device id
      * @return the device credentials object
      * @return the device credentials object
      */
      */
-    DeviceCredentials findByDeviceId(UUID deviceId);
+    DeviceCredentials findByDeviceId(TenantId tenantId, UUID deviceId);
 
 
     /**
     /**
      * Find device credentials by credentials id.
      * Find device credentials by credentials id.
@@ -47,6 +49,6 @@ public interface DeviceCredentialsDao extends Dao<DeviceCredentials> {
      * @param credentialsId the credentials id
      * @param credentialsId the credentials id
      * @return the device credentials object
      * @return the device credentials object
      */
      */
-    DeviceCredentials findByCredentialsId(String credentialsId);
+    DeviceCredentials findByCredentialsId(TenantId tenantId, String credentialsId);
 
 
 }
 }

@@ -16,17 +16,18 @@
 package org.thingsboard.server.dao.device;
 package org.thingsboard.server.dao.device;
 
 
 import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.data.id.DeviceId;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.security.DeviceCredentials;
 import org.thingsboard.server.common.data.security.DeviceCredentials;
 
 
 public interface DeviceCredentialsService {
 public interface DeviceCredentialsService {
 
 
-    DeviceCredentials findDeviceCredentialsByDeviceId(DeviceId deviceId);
+    DeviceCredentials findDeviceCredentialsByDeviceId(TenantId tenantId, DeviceId deviceId);
 
 
     DeviceCredentials findDeviceCredentialsByCredentialsId(String credentialsId);
     DeviceCredentials findDeviceCredentialsByCredentialsId(String credentialsId);
 
 
-    DeviceCredentials updateDeviceCredentials(DeviceCredentials deviceCredentials);
+    DeviceCredentials updateDeviceCredentials(TenantId tenantId, DeviceCredentials deviceCredentials);
 
 
-    DeviceCredentials createDeviceCredentials(DeviceCredentials deviceCredentials);
+    DeviceCredentials createDeviceCredentials(TenantId tenantId, DeviceCredentials deviceCredentials);
 
 
-    void deleteDeviceCredentials(DeviceCredentials deviceCredentials);
+    void deleteDeviceCredentials(TenantId tenantId, DeviceCredentials deviceCredentials);
 }
 }

@@ -24,6 +24,8 @@ import org.springframework.stereotype.Service;
 import org.springframework.util.StringUtils;
 import org.springframework.util.StringUtils;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.id.DeviceId;
 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.security.DeviceCredentials;
 import org.thingsboard.server.common.data.security.DeviceCredentials;
 import org.thingsboard.server.common.data.security.DeviceCredentialsType;
 import org.thingsboard.server.common.data.security.DeviceCredentialsType;
 import org.thingsboard.server.common.msg.EncryptionUtil;
 import org.thingsboard.server.common.msg.EncryptionUtil;
@@ -45,38 +47,38 @@ public class DeviceCredentialsServiceImpl implements DeviceCredentialsService {
     private DeviceService deviceService;
     private DeviceService deviceService;
 
 
     @Override
     @Override
-    public DeviceCredentials findDeviceCredentialsByDeviceId(DeviceId deviceId) {
+    public DeviceCredentials findDeviceCredentialsByDeviceId(TenantId tenantId, DeviceId deviceId) {
         log.trace("Executing findDeviceCredentialsByDeviceId [{}]", deviceId);
         log.trace("Executing findDeviceCredentialsByDeviceId [{}]", deviceId);
         validateId(deviceId, "Incorrect deviceId " + deviceId);
         validateId(deviceId, "Incorrect deviceId " + deviceId);
-        return deviceCredentialsDao.findByDeviceId(deviceId.getId());
+        return deviceCredentialsDao.findByDeviceId(tenantId, deviceId.getId());
     }
     }
 
 
     @Override
     @Override
-    @Cacheable(cacheNames = DEVICE_CREDENTIALS_CACHE, unless="#result == null")
+    @Cacheable(cacheNames = DEVICE_CREDENTIALS_CACHE, unless = "#result == null")
     public DeviceCredentials findDeviceCredentialsByCredentialsId(String credentialsId) {
     public DeviceCredentials findDeviceCredentialsByCredentialsId(String credentialsId) {
         log.trace("Executing findDeviceCredentialsByCredentialsId [{}]", credentialsId);
         log.trace("Executing findDeviceCredentialsByCredentialsId [{}]", credentialsId);
         validateString(credentialsId, "Incorrect credentialsId " + credentialsId);
         validateString(credentialsId, "Incorrect credentialsId " + credentialsId);
-        return deviceCredentialsDao.findByCredentialsId(credentialsId);
+        return deviceCredentialsDao.findByCredentialsId(new TenantId(EntityId.NULL_UUID), credentialsId);
     }
     }
 
 
     @Override
     @Override
-    @CacheEvict(cacheNames = DEVICE_CREDENTIALS_CACHE, keyGenerator="previousDeviceCredentialsId", beforeInvocation = true)
-    public DeviceCredentials updateDeviceCredentials(DeviceCredentials deviceCredentials) {
-        return saveOrUpdate(deviceCredentials);
+    @CacheEvict(cacheNames = DEVICE_CREDENTIALS_CACHE, keyGenerator = "previousDeviceCredentialsId", beforeInvocation = true)
+    public DeviceCredentials updateDeviceCredentials(TenantId tenantId, DeviceCredentials deviceCredentials) {
+        return saveOrUpdate(tenantId, deviceCredentials);
     }
     }
 
 
     @Override
     @Override
-    public DeviceCredentials createDeviceCredentials(DeviceCredentials deviceCredentials) {
-        return saveOrUpdate(deviceCredentials);
+    public DeviceCredentials createDeviceCredentials(TenantId tenantId, DeviceCredentials deviceCredentials) {
+        return saveOrUpdate(tenantId, deviceCredentials);
     }
     }
 
 
-    private DeviceCredentials saveOrUpdate(DeviceCredentials deviceCredentials) {
+    private DeviceCredentials saveOrUpdate(TenantId tenantId, DeviceCredentials deviceCredentials) {
         if (deviceCredentials.getCredentialsType() == DeviceCredentialsType.X509_CERTIFICATE) {
         if (deviceCredentials.getCredentialsType() == DeviceCredentialsType.X509_CERTIFICATE) {
             formatCertData(deviceCredentials);
             formatCertData(deviceCredentials);
         }
         }
         log.trace("Executing updateDeviceCredentials [{}]", deviceCredentials);
         log.trace("Executing updateDeviceCredentials [{}]", deviceCredentials);
-        credentialsValidator.validate(deviceCredentials);
-        return deviceCredentialsDao.save(deviceCredentials);
+        credentialsValidator.validate(deviceCredentials, id -> tenantId);
+        return deviceCredentialsDao.save(tenantId, deviceCredentials);
     }
     }
 
 
     private void formatCertData(DeviceCredentials deviceCredentials) {
     private void formatCertData(DeviceCredentials deviceCredentials) {
@@ -87,37 +89,37 @@ public class DeviceCredentialsServiceImpl implements DeviceCredentialsService {
     }
     }
 
 
     @Override
     @Override
-    @CacheEvict(cacheNames = DEVICE_CREDENTIALS_CACHE, key="#deviceCredentials.credentialsId")
-    public void deleteDeviceCredentials(DeviceCredentials deviceCredentials) {
+    @CacheEvict(cacheNames = DEVICE_CREDENTIALS_CACHE, key = "#deviceCredentials.credentialsId")
+    public void deleteDeviceCredentials(TenantId tenantId, DeviceCredentials deviceCredentials) {
         log.trace("Executing deleteDeviceCredentials [{}]", deviceCredentials);
         log.trace("Executing deleteDeviceCredentials [{}]", deviceCredentials);
-        deviceCredentialsDao.removeById(deviceCredentials.getUuidId());
+        deviceCredentialsDao.removeById(tenantId, deviceCredentials.getUuidId());
     }
     }
 
 
     private DataValidator<DeviceCredentials> credentialsValidator =
     private DataValidator<DeviceCredentials> credentialsValidator =
             new DataValidator<DeviceCredentials>() {
             new DataValidator<DeviceCredentials>() {
 
 
                 @Override
                 @Override
-                protected void validateCreate(DeviceCredentials deviceCredentials) {
-                    DeviceCredentials existingCredentialsEntity = deviceCredentialsDao.findByCredentialsId(deviceCredentials.getCredentialsId());
+                protected void validateCreate(TenantId tenantId, DeviceCredentials deviceCredentials) {
+                    DeviceCredentials existingCredentialsEntity = deviceCredentialsDao.findByCredentialsId(tenantId, deviceCredentials.getCredentialsId());
                     if (existingCredentialsEntity != null) {
                     if (existingCredentialsEntity != null) {
                         throw new DataValidationException("Create of existent device credentials!");
                         throw new DataValidationException("Create of existent device credentials!");
                     }
                     }
                 }
                 }
 
 
                 @Override
                 @Override
-                protected void validateUpdate(DeviceCredentials deviceCredentials) {
-                    DeviceCredentials existingCredentials = deviceCredentialsDao.findById(deviceCredentials.getUuidId());
+                protected void validateUpdate(TenantId tenantId, DeviceCredentials deviceCredentials) {
+                    DeviceCredentials existingCredentials = deviceCredentialsDao.findById(tenantId, deviceCredentials.getUuidId());
                     if (existingCredentials == null) {
                     if (existingCredentials == null) {
                         throw new DataValidationException("Unable to update non-existent device credentials!");
                         throw new DataValidationException("Unable to update non-existent device credentials!");
                     }
                     }
-                    DeviceCredentials sameCredentialsId = deviceCredentialsDao.findByCredentialsId(deviceCredentials.getCredentialsId());
+                    DeviceCredentials sameCredentialsId = deviceCredentialsDao.findByCredentialsId(tenantId, deviceCredentials.getCredentialsId());
                     if (sameCredentialsId != null && !sameCredentialsId.getUuidId().equals(deviceCredentials.getUuidId())) {
                     if (sameCredentialsId != null && !sameCredentialsId.getUuidId().equals(deviceCredentials.getUuidId())) {
                         throw new DataValidationException("Specified credentials are already registered!");
                         throw new DataValidationException("Specified credentials are already registered!");
                     }
                     }
                 }
                 }
 
 
                 @Override
                 @Override
-                protected void validateDataImpl(DeviceCredentials deviceCredentials) {
+                protected void validateDataImpl(TenantId tenantId, DeviceCredentials deviceCredentials) {
                     if (deviceCredentials.getDeviceId() == null) {
                     if (deviceCredentials.getDeviceId() == null) {
                         throw new DataValidationException("Device credentials should be assigned to device!");
                         throw new DataValidationException("Device credentials should be assigned to device!");
                     }
                     }
@@ -127,7 +129,7 @@ public class DeviceCredentialsServiceImpl implements DeviceCredentialsService {
                     if (StringUtils.isEmpty(deviceCredentials.getCredentialsId())) {
                     if (StringUtils.isEmpty(deviceCredentials.getCredentialsId())) {
                         throw new DataValidationException("Device credentials id should be specified!");
                         throw new DataValidationException("Device credentials id should be specified!");
                     }
                     }
-                    Device device = deviceService.findDeviceById(deviceCredentials.getDeviceId());
+                    Device device = deviceService.findDeviceById(tenantId, deviceCredentials.getDeviceId());
                     if (device == null) {
                     if (device == null) {
                         throw new DataValidationException("Can't assign device credentials to non-existent device!");
                         throw new DataValidationException("Can't assign device credentials to non-existent device!");
                     }
                     }

@@ -18,6 +18,7 @@ package org.thingsboard.server.dao.device;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListenableFuture;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.EntitySubtype;
 import org.thingsboard.server.common.data.EntitySubtype;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.dao.Dao;
 import org.thingsboard.server.dao.Dao;
 
 
@@ -37,7 +38,7 @@ public interface DeviceDao extends Dao<Device> {
      * @param device the device object
      * @param device the device object
      * @return saved device object
      * @return saved device object
      */
      */
-    Device save(Device device);
+    Device save(TenantId tenantId, Device device);
 
 
     /**
     /**
      * Find devices by tenantId and page link.
      * Find devices by tenantId and page link.

@@ -29,19 +29,19 @@ import java.util.List;
 
 
 public interface DeviceService {
 public interface DeviceService {
     
     
-    Device findDeviceById(DeviceId deviceId);
+    Device findDeviceById(TenantId tenantId, DeviceId deviceId);
 
 
-    ListenableFuture<Device> findDeviceByIdAsync(DeviceId deviceId);
+    ListenableFuture<Device> findDeviceByIdAsync(TenantId tenantId, DeviceId deviceId);
 
 
     Device findDeviceByTenantIdAndName(TenantId tenantId, String name);
     Device findDeviceByTenantIdAndName(TenantId tenantId, String name);
 
 
     Device saveDevice(Device device);
     Device saveDevice(Device device);
 
 
-    Device assignDeviceToCustomer(DeviceId deviceId, CustomerId customerId);
+    Device assignDeviceToCustomer(TenantId tenantId, DeviceId deviceId, CustomerId customerId);
 
 
-    Device unassignDeviceFromCustomer(DeviceId deviceId);
+    Device unassignDeviceFromCustomer(TenantId tenantId, DeviceId deviceId);
 
 
-    void deleteDevice(DeviceId deviceId);
+    void deleteDevice(TenantId tenantId, DeviceId deviceId);
 
 
     TextPageData<Device> findDevicesByTenantId(TenantId tenantId, TextPageLink pageLink);
     TextPageData<Device> findDevicesByTenantId(TenantId tenantId, TextPageLink pageLink);
 
 
@@ -59,7 +59,7 @@ public interface DeviceService {
 
 
     void unassignCustomerDevices(TenantId tenantId, CustomerId customerId);
     void unassignCustomerDevices(TenantId tenantId, CustomerId customerId);
 
 
-    ListenableFuture<List<Device>> findDevicesByQuery(DeviceSearchQuery query);
+    ListenableFuture<List<Device>> findDevicesByQuery(TenantId tenantId, DeviceSearchQuery query);
 
 
     ListenableFuture<List<EntitySubtype>> findDeviceTypesByTenantId(TenantId tenantId);
     ListenableFuture<List<EntitySubtype>> findDeviceTypesByTenantId(TenantId tenantId);
 
 

@@ -96,17 +96,17 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
     private CacheManager cacheManager;
     private CacheManager cacheManager;
 
 
     @Override
     @Override
-    public Device findDeviceById(DeviceId deviceId) {
+    public Device findDeviceById(TenantId tenantId, DeviceId deviceId) {
         log.trace("Executing findDeviceById [{}]", deviceId);
         log.trace("Executing findDeviceById [{}]", deviceId);
         validateId(deviceId, INCORRECT_DEVICE_ID + deviceId);
         validateId(deviceId, INCORRECT_DEVICE_ID + deviceId);
-        return deviceDao.findById(deviceId.getId());
+        return deviceDao.findById(tenantId, deviceId.getId());
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<Device> findDeviceByIdAsync(DeviceId deviceId) {
+    public ListenableFuture<Device> findDeviceByIdAsync(TenantId tenantId, DeviceId deviceId) {
         log.trace("Executing findDeviceById [{}]", deviceId);
         log.trace("Executing findDeviceById [{}]", deviceId);
         validateId(deviceId, INCORRECT_DEVICE_ID + deviceId);
         validateId(deviceId, INCORRECT_DEVICE_ID + deviceId);
-        return deviceDao.findByIdAsync(deviceId.getId());
+        return deviceDao.findByIdAsync(tenantId, deviceId.getId());
     }
     }
 
 
     @Cacheable(cacheNames = DEVICE_CACHE, key = "{#tenantId, #name}")
     @Cacheable(cacheNames = DEVICE_CACHE, key = "{#tenantId, #name}")
@@ -122,38 +122,38 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
     @Override
     @Override
     public Device saveDevice(Device device) {
     public Device saveDevice(Device device) {
         log.trace("Executing saveDevice [{}]", device);
         log.trace("Executing saveDevice [{}]", device);
-        deviceValidator.validate(device);
-        Device savedDevice = deviceDao.save(device);
+        deviceValidator.validate(device, Device::getTenantId);
+        Device savedDevice = deviceDao.save(device.getTenantId(), device);
         if (device.getId() == null) {
         if (device.getId() == null) {
             DeviceCredentials deviceCredentials = new DeviceCredentials();
             DeviceCredentials deviceCredentials = new DeviceCredentials();
             deviceCredentials.setDeviceId(new DeviceId(savedDevice.getUuidId()));
             deviceCredentials.setDeviceId(new DeviceId(savedDevice.getUuidId()));
             deviceCredentials.setCredentialsType(DeviceCredentialsType.ACCESS_TOKEN);
             deviceCredentials.setCredentialsType(DeviceCredentialsType.ACCESS_TOKEN);
             deviceCredentials.setCredentialsId(RandomStringUtils.randomAlphanumeric(20));
             deviceCredentials.setCredentialsId(RandomStringUtils.randomAlphanumeric(20));
-            deviceCredentialsService.createDeviceCredentials(deviceCredentials);
+            deviceCredentialsService.createDeviceCredentials(device.getTenantId(), deviceCredentials);
         }
         }
         return savedDevice;
         return savedDevice;
     }
     }
 
 
     @Override
     @Override
-    public Device assignDeviceToCustomer(DeviceId deviceId, CustomerId customerId) {
-        Device device = findDeviceById(deviceId);
+    public Device assignDeviceToCustomer(TenantId tenantId, DeviceId deviceId, CustomerId customerId) {
+        Device device = findDeviceById(tenantId, deviceId);
         device.setCustomerId(customerId);
         device.setCustomerId(customerId);
         return saveDevice(device);
         return saveDevice(device);
     }
     }
 
 
     @Override
     @Override
-    public Device unassignDeviceFromCustomer(DeviceId deviceId) {
-        Device device = findDeviceById(deviceId);
+    public Device unassignDeviceFromCustomer(TenantId tenantId, DeviceId deviceId) {
+        Device device = findDeviceById(tenantId, deviceId);
         device.setCustomerId(null);
         device.setCustomerId(null);
         return saveDevice(device);
         return saveDevice(device);
     }
     }
 
 
     @Override
     @Override
-    public void deleteDevice(DeviceId deviceId) {
+    public void deleteDevice(TenantId tenantId, DeviceId deviceId) {
         log.trace("Executing deleteDevice [{}]", deviceId);
         log.trace("Executing deleteDevice [{}]", deviceId);
         validateId(deviceId, INCORRECT_DEVICE_ID + deviceId);
         validateId(deviceId, INCORRECT_DEVICE_ID + deviceId);
 
 
-        Device device = deviceDao.findById(deviceId.getId());
+        Device device = deviceDao.findById(tenantId, deviceId.getId());
         try {
         try {
             List<EntityView> entityViews = entityViewService.findEntityViewsByTenantIdAndEntityIdAsync(device.getTenantId(), deviceId).get();
             List<EntityView> entityViews = entityViewService.findEntityViewsByTenantIdAndEntityIdAsync(device.getTenantId(), deviceId).get();
             if (entityViews != null && !entityViews.isEmpty()) {
             if (entityViews != null && !entityViews.isEmpty()) {
@@ -164,11 +164,11 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
             throw new RuntimeException("Exception while finding entity views for deviceId [" + deviceId + "]", e);
             throw new RuntimeException("Exception while finding entity views for deviceId [" + deviceId + "]", e);
         }
         }
 
 
-        DeviceCredentials deviceCredentials = deviceCredentialsService.findDeviceCredentialsByDeviceId(deviceId);
+        DeviceCredentials deviceCredentials = deviceCredentialsService.findDeviceCredentialsByDeviceId(tenantId, deviceId);
         if (deviceCredentials != null) {
         if (deviceCredentials != null) {
-            deviceCredentialsService.deleteDeviceCredentials(deviceCredentials);
+            deviceCredentialsService.deleteDeviceCredentials(tenantId, deviceCredentials);
         }
         }
-        deleteEntityRelations(deviceId);
+        deleteEntityRelations(tenantId, deviceId);
 
 
         List<Object> list = new ArrayList<>();
         List<Object> list = new ArrayList<>();
         list.add(device.getTenantId());
         list.add(device.getTenantId());
@@ -176,7 +176,7 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
         Cache cache = cacheManager.getCache(DEVICE_CACHE);
         Cache cache = cacheManager.getCache(DEVICE_CACHE);
         cache.evict(list);
         cache.evict(list);
 
 
-        deviceDao.removeById(deviceId.getId());
+        deviceDao.removeById(tenantId, deviceId.getId());
     }
     }
 
 
     @Override
     @Override
@@ -211,7 +211,7 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
     public void deleteDevicesByTenantId(TenantId tenantId) {
     public void deleteDevicesByTenantId(TenantId tenantId) {
         log.trace("Executing deleteDevicesByTenantId, tenantId [{}]", tenantId);
         log.trace("Executing deleteDevicesByTenantId, tenantId [{}]", tenantId);
         validateId(tenantId, INCORRECT_TENANT_ID + tenantId);
         validateId(tenantId, INCORRECT_TENANT_ID + tenantId);
-        tenantDevicesRemover.removeEntities(tenantId);
+        tenantDevicesRemover.removeEntities(tenantId, tenantId);
     }
     }
 
 
     @Override
     @Override
@@ -250,19 +250,19 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
         log.trace("Executing unassignCustomerDevices, tenantId [{}], customerId [{}]", tenantId, customerId);
         log.trace("Executing unassignCustomerDevices, tenantId [{}], customerId [{}]", tenantId, customerId);
         validateId(tenantId, INCORRECT_TENANT_ID + tenantId);
         validateId(tenantId, INCORRECT_TENANT_ID + tenantId);
         validateId(customerId, INCORRECT_CUSTOMER_ID + customerId);
         validateId(customerId, INCORRECT_CUSTOMER_ID + customerId);
-        new CustomerDevicesUnassigner(tenantId).removeEntities(customerId);
+        customerDeviceUnasigner.removeEntities(tenantId, customerId);
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<List<Device>> findDevicesByQuery(DeviceSearchQuery query) {
-        ListenableFuture<List<EntityRelation>> relations = relationService.findByQuery(query.toEntitySearchQuery());
+    public ListenableFuture<List<Device>> findDevicesByQuery(TenantId tenantId, DeviceSearchQuery query) {
+        ListenableFuture<List<EntityRelation>> relations = relationService.findByQuery(tenantId, query.toEntitySearchQuery());
         ListenableFuture<List<Device>> devices = Futures.transformAsync(relations, r -> {
         ListenableFuture<List<Device>> devices = Futures.transformAsync(relations, r -> {
             EntitySearchDirection direction = query.toEntitySearchQuery().getParameters().getDirection();
             EntitySearchDirection direction = query.toEntitySearchQuery().getParameters().getDirection();
             List<ListenableFuture<Device>> futures = new ArrayList<>();
             List<ListenableFuture<Device>> futures = new ArrayList<>();
             for (EntityRelation relation : r) {
             for (EntityRelation relation : r) {
                 EntityId entityId = direction == EntitySearchDirection.FROM ? relation.getTo() : relation.getFrom();
                 EntityId entityId = direction == EntitySearchDirection.FROM ? relation.getTo() : relation.getFrom();
                 if (entityId.getEntityType() == EntityType.DEVICE) {
                 if (entityId.getEntityType() == EntityType.DEVICE) {
-                    futures.add(findDeviceByIdAsync(new DeviceId(entityId.getId())));
+                    futures.add(findDeviceByIdAsync(tenantId, new DeviceId(entityId.getId())));
                 }
                 }
             }
             }
             return Futures.successfulAsList(futures);
             return Futures.successfulAsList(futures);
@@ -285,7 +285,7 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
         validateId(tenantId, INCORRECT_TENANT_ID + tenantId);
         validateId(tenantId, INCORRECT_TENANT_ID + tenantId);
         ListenableFuture<List<EntitySubtype>> tenantDeviceTypes = deviceDao.findTenantDeviceTypesAsync(tenantId.getId());
         ListenableFuture<List<EntitySubtype>> tenantDeviceTypes = deviceDao.findTenantDeviceTypesAsync(tenantId.getId());
         return Futures.transform(tenantDeviceTypes,
         return Futures.transform(tenantDeviceTypes,
-                (Function<List<EntitySubtype>, List<EntitySubtype>>) deviceTypes -> {
+                deviceTypes -> {
                     deviceTypes.sort(Comparator.comparing(EntitySubtype::getType));
                     deviceTypes.sort(Comparator.comparing(EntitySubtype::getType));
                     return deviceTypes;
                     return deviceTypes;
                 });
                 });
@@ -295,7 +295,7 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
             new DataValidator<Device>() {
             new DataValidator<Device>() {
 
 
                 @Override
                 @Override
-                protected void validateCreate(Device device) {
+                protected void validateCreate(TenantId tenantId, Device device) {
                     deviceDao.findDeviceByTenantIdAndName(device.getTenantId().getId(), device.getName()).ifPresent(
                     deviceDao.findDeviceByTenantIdAndName(device.getTenantId().getId(), device.getName()).ifPresent(
                             d -> {
                             d -> {
                                 throw new DataValidationException("Device with such name already exists!");
                                 throw new DataValidationException("Device with such name already exists!");
@@ -304,7 +304,7 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
                 }
                 }
 
 
                 @Override
                 @Override
-                protected void validateUpdate(Device device) {
+                protected void validateUpdate(TenantId tenantId, Device device) {
                     deviceDao.findDeviceByTenantIdAndName(device.getTenantId().getId(), device.getName()).ifPresent(
                     deviceDao.findDeviceByTenantIdAndName(device.getTenantId().getId(), device.getName()).ifPresent(
                             d -> {
                             d -> {
                                 if (!d.getUuidId().equals(device.getUuidId())) {
                                 if (!d.getUuidId().equals(device.getUuidId())) {
@@ -315,7 +315,7 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
                 }
                 }
 
 
                 @Override
                 @Override
-                protected void validateDataImpl(Device device) {
+                protected void validateDataImpl(TenantId tenantId, Device device) {
                     if (StringUtils.isEmpty(device.getType())) {
                     if (StringUtils.isEmpty(device.getType())) {
                         throw new DataValidationException("Device type should be specified!");
                         throw new DataValidationException("Device type should be specified!");
                     }
                     }
@@ -325,7 +325,7 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
                     if (device.getTenantId() == null) {
                     if (device.getTenantId() == null) {
                         throw new DataValidationException("Device should be assigned to tenant!");
                         throw new DataValidationException("Device should be assigned to tenant!");
                     } else {
                     } else {
-                        Tenant tenant = tenantDao.findById(device.getTenantId().getId());
+                        Tenant tenant = tenantDao.findById(device.getTenantId(), device.getTenantId().getId());
                         if (tenant == null) {
                         if (tenant == null) {
                             throw new DataValidationException("Device is referencing to non-existent tenant!");
                             throw new DataValidationException("Device is referencing to non-existent tenant!");
                         }
                         }
@@ -333,7 +333,7 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
                     if (device.getCustomerId() == null) {
                     if (device.getCustomerId() == null) {
                         device.setCustomerId(new CustomerId(NULL_UUID));
                         device.setCustomerId(new CustomerId(NULL_UUID));
                     } else if (!device.getCustomerId().getId().equals(NULL_UUID)) {
                     } else if (!device.getCustomerId().getId().equals(NULL_UUID)) {
-                        Customer customer = customerDao.findById(device.getCustomerId().getId());
+                        Customer customer = customerDao.findById(device.getTenantId(), device.getCustomerId().getId());
                         if (customer == null) {
                         if (customer == null) {
                             throw new DataValidationException("Can't assign device to non-existent customer!");
                             throw new DataValidationException("Can't assign device to non-existent customer!");
                         }
                         }
@@ -345,36 +345,29 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
             };
             };
 
 
     private PaginatedRemover<TenantId, Device> tenantDevicesRemover =
     private PaginatedRemover<TenantId, Device> tenantDevicesRemover =
-            new PaginatedRemover<TenantId, Device>() {
+        new PaginatedRemover<TenantId, Device>() {
 
 
-                @Override
-                protected List<Device> findEntities(TenantId id, TextPageLink pageLink) {
-                    return deviceDao.findDevicesByTenantId(id.getId(), pageLink);
-                }
-
-                @Override
-                protected void removeEntity(Device entity) {
-                    deleteDevice(new DeviceId(entity.getUuidId()));
-                }
-            };
-
-    private class CustomerDevicesUnassigner extends PaginatedRemover<CustomerId, Device> {
+            @Override
+            protected List<Device> findEntities(TenantId tenantId, TenantId id, TextPageLink pageLink) {
+                return deviceDao.findDevicesByTenantId(id.getId(), pageLink);
+            }
 
 
-        private TenantId tenantId;
+            @Override
+            protected void removeEntity(TenantId tenantId, Device entity) {
+                deleteDevice(tenantId, new DeviceId(entity.getUuidId()));
+            }
+        };
 
 
-        CustomerDevicesUnassigner(TenantId tenantId) {
-            this.tenantId = tenantId;
-        }
+    private PaginatedRemover<CustomerId, Device> customerDeviceUnasigner = new PaginatedRemover<CustomerId, Device>() {
 
 
         @Override
         @Override
-        protected List<Device> findEntities(CustomerId id, TextPageLink pageLink) {
+        protected List<Device> findEntities(TenantId tenantId, CustomerId id, TextPageLink pageLink) {
             return deviceDao.findDevicesByTenantIdAndCustomerId(tenantId.getId(), id.getId(), pageLink);
             return deviceDao.findDevicesByTenantIdAndCustomerId(tenantId.getId(), id.getId(), pageLink);
         }
         }
 
 
         @Override
         @Override
-        protected void removeEntity(Device entity) {
-            unassignDeviceFromCustomer(new DeviceId(entity.getUuidId()));
+        protected void removeEntity(TenantId tenantId, Device entity) {
+            unassignDeviceFromCustomer(tenantId, new DeviceId(entity.getUuidId()));
         }
         }
-
-    }
+    };
 }
 }

@@ -18,6 +18,7 @@ package org.thingsboard.server.dao.entity;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.dao.relation.RelationService;
 import org.thingsboard.server.dao.relation.RelationService;
 
 
 @Slf4j
 @Slf4j
@@ -26,9 +27,9 @@ public abstract class AbstractEntityService {
     @Autowired
     @Autowired
     protected RelationService relationService;
     protected RelationService relationService;
 
 
-    protected void deleteEntityRelations(EntityId entityId) {
+    protected void deleteEntityRelations(TenantId tenantId, EntityId entityId) {
         log.trace("Executing deleteEntityRelations [{}]", entityId);
         log.trace("Executing deleteEntityRelations [{}]", entityId);
-        relationService.deleteEntityRelations(entityId);
+        relationService.deleteEntityRelations(tenantId, entityId);
     }
     }
 
 
 }
 }

@@ -69,42 +69,42 @@ public class BaseEntityService extends AbstractEntityService implements EntitySe
     private RuleChainService ruleChainService;
     private RuleChainService ruleChainService;
 
 
     @Override
     @Override
-    public void deleteEntityRelations(EntityId entityId) {
-        super.deleteEntityRelations(entityId);
+    public void deleteEntityRelations(TenantId tenantId, EntityId entityId) {
+        super.deleteEntityRelations(tenantId, entityId);
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<String> fetchEntityNameAsync(EntityId entityId) {
+    public ListenableFuture<String> fetchEntityNameAsync(TenantId tenantId, EntityId entityId) {
         log.trace("Executing fetchEntityNameAsync [{}]", entityId);
         log.trace("Executing fetchEntityNameAsync [{}]", entityId);
         ListenableFuture<String> entityName;
         ListenableFuture<String> entityName;
         ListenableFuture<? extends HasName> hasName;
         ListenableFuture<? extends HasName> hasName;
         switch (entityId.getEntityType()) {
         switch (entityId.getEntityType()) {
             case ASSET:
             case ASSET:
-                hasName = assetService.findAssetByIdAsync(new AssetId(entityId.getId()));
+                hasName = assetService.findAssetByIdAsync(tenantId, new AssetId(entityId.getId()));
                 break;
                 break;
             case DEVICE:
             case DEVICE:
-                hasName = deviceService.findDeviceByIdAsync(new DeviceId(entityId.getId()));
+                hasName = deviceService.findDeviceByIdAsync(tenantId, new DeviceId(entityId.getId()));
                 break;
                 break;
             case ENTITY_VIEW:
             case ENTITY_VIEW:
-                hasName = entityViewService.findEntityViewByIdAsync(new EntityViewId(entityId.getId()));
+                hasName = entityViewService.findEntityViewByIdAsync(tenantId, new EntityViewId(entityId.getId()));
                 break;
                 break;
             case TENANT:
             case TENANT:
-                hasName = tenantService.findTenantByIdAsync(new TenantId(entityId.getId()));
+                hasName = tenantService.findTenantByIdAsync(tenantId, new TenantId(entityId.getId()));
                 break;
                 break;
             case CUSTOMER:
             case CUSTOMER:
-                hasName = customerService.findCustomerByIdAsync(new CustomerId(entityId.getId()));
+                hasName = customerService.findCustomerByIdAsync(tenantId, new CustomerId(entityId.getId()));
                 break;
                 break;
             case USER:
             case USER:
-                hasName = userService.findUserByIdAsync(new UserId(entityId.getId()));
+                hasName = userService.findUserByIdAsync(tenantId, new UserId(entityId.getId()));
                 break;
                 break;
             case DASHBOARD:
             case DASHBOARD:
-                hasName = dashboardService.findDashboardInfoByIdAsync(new DashboardId(entityId.getId()));
+                hasName = dashboardService.findDashboardInfoByIdAsync(tenantId, new DashboardId(entityId.getId()));
                 break;
                 break;
             case ALARM:
             case ALARM:
-                hasName = alarmService.findAlarmByIdAsync(new AlarmId(entityId.getId()));
+                hasName = alarmService.findAlarmByIdAsync(tenantId, new AlarmId(entityId.getId()));
                 break;
                 break;
             case RULE_CHAIN:
             case RULE_CHAIN:
-                hasName = ruleChainService.findRuleChainByIdAsync(new RuleChainId(entityId.getId()));
+                hasName = ruleChainService.findRuleChainByIdAsync(tenantId, new RuleChainId(entityId.getId()));
                 break;
                 break;
             default:
             default:
                 throw new IllegalStateException("Not Implemented!");
                 throw new IllegalStateException("Not Implemented!");

@@ -17,11 +17,12 @@ package org.thingsboard.server.dao.entity;
 
 
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListenableFuture;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
 
 
 public interface EntityService {
 public interface EntityService {
 
 
-    ListenableFuture<String> fetchEntityNameAsync(EntityId entityId);
+    ListenableFuture<String> fetchEntityNameAsync(TenantId tenantId, EntityId entityId);
 
 
-    void deleteEntityRelations(EntityId entityId);
+    void deleteEntityRelations(TenantId tenantId, EntityId entityId);
 
 
 }
 }

@@ -28,6 +28,7 @@ import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.data.EntitySubtype;
 import org.thingsboard.server.common.data.EntitySubtype;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.EntityView;
 import org.thingsboard.server.common.data.EntityView;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.model.EntitySubtypeEntity;
 import org.thingsboard.server.dao.model.EntitySubtypeEntity;
@@ -82,12 +83,12 @@ public class CassandraEntityViewDao extends CassandraAbstractSearchTextDao<Entit
     }
     }
 
 
     @Override
     @Override
-    public EntityView save(EntityView domain) {
-        EntityView savedEntityView = super.save(domain);
+    public EntityView save(TenantId tenantId, EntityView domain) {
+        EntityView savedEntityView = super.save(domain.getTenantId(), domain);
         EntitySubtype entitySubtype = new EntitySubtype(savedEntityView.getTenantId(), EntityType.ENTITY_VIEW, savedEntityView.getType());
         EntitySubtype entitySubtype = new EntitySubtype(savedEntityView.getTenantId(), EntityType.ENTITY_VIEW, savedEntityView.getType());
         EntitySubtypeEntity entitySubtypeEntity = new EntitySubtypeEntity(entitySubtype);
         EntitySubtypeEntity entitySubtypeEntity = new EntitySubtypeEntity(entitySubtype);
         Statement saveStatement = cluster.getMapper(EntitySubtypeEntity.class).saveQuery(entitySubtypeEntity);
         Statement saveStatement = cluster.getMapper(EntitySubtypeEntity.class).saveQuery(entitySubtypeEntity);
-        executeWrite(saveStatement);
+        executeWrite(tenantId, saveStatement);
         return savedEntityView;
         return savedEntityView;
     }
     }
 
 
@@ -95,7 +96,7 @@ public class CassandraEntityViewDao extends CassandraAbstractSearchTextDao<Entit
     public List<EntityView> findEntityViewsByTenantId(UUID tenantId, TextPageLink pageLink) {
     public List<EntityView> findEntityViewsByTenantId(UUID tenantId, TextPageLink pageLink) {
         log.debug("Try to find entity views by tenantId [{}] and pageLink [{}]", tenantId, pageLink);
         log.debug("Try to find entity views by tenantId [{}] and pageLink [{}]", tenantId, pageLink);
         List<EntityViewEntity> entityViewEntities =
         List<EntityViewEntity> entityViewEntities =
-                findPageWithTextSearch(ENTITY_VIEW_BY_TENANT_AND_SEARCH_TEXT_CF,
+                findPageWithTextSearch(new TenantId(tenantId), ENTITY_VIEW_BY_TENANT_AND_SEARCH_TEXT_CF,
                 Collections.singletonList(eq(TENANT_ID_PROPERTY, tenantId)), pageLink);
                 Collections.singletonList(eq(TENANT_ID_PROPERTY, tenantId)), pageLink);
         log.trace("Found entity views [{}] by tenantId [{}] and pageLink [{}]",
         log.trace("Found entity views [{}] by tenantId [{}] and pageLink [{}]",
                 entityViewEntities, tenantId, pageLink);
                 entityViewEntities, tenantId, pageLink);
@@ -106,7 +107,7 @@ public class CassandraEntityViewDao extends CassandraAbstractSearchTextDao<Entit
     public List<EntityView> findEntityViewsByTenantIdAndType(UUID tenantId, String type, TextPageLink pageLink) {
     public List<EntityView> findEntityViewsByTenantIdAndType(UUID tenantId, String type, TextPageLink pageLink) {
         log.debug("Try to find entity views by tenantId [{}], type [{}] and pageLink [{}]", tenantId, type, pageLink);
         log.debug("Try to find entity views by tenantId [{}], type [{}] and pageLink [{}]", tenantId, type, pageLink);
         List<EntityViewEntity> entityViewEntities =
         List<EntityViewEntity> entityViewEntities =
-                findPageWithTextSearch(ENTITY_VIEW_BY_TENANT_BY_TYPE_AND_SEARCH_TEXT_CF,
+                findPageWithTextSearch(new TenantId(tenantId), ENTITY_VIEW_BY_TENANT_BY_TYPE_AND_SEARCH_TEXT_CF,
                         Arrays.asList(eq(ENTITY_VIEW_TYPE_PROPERTY, type),
                         Arrays.asList(eq(ENTITY_VIEW_TYPE_PROPERTY, type),
                                 eq(TENANT_ID_PROPERTY, tenantId)), pageLink);
                                 eq(TENANT_ID_PROPERTY, tenantId)), pageLink);
         log.trace("Found entity views [{}] by tenantId [{}], type [{}] and pageLink [{}]",
         log.trace("Found entity views [{}] by tenantId [{}], type [{}] and pageLink [{}]",
@@ -119,14 +120,14 @@ public class CassandraEntityViewDao extends CassandraAbstractSearchTextDao<Entit
         Select.Where query = select().from(ENTITY_VIEW_BY_TENANT_AND_NAME).where();
         Select.Where query = select().from(ENTITY_VIEW_BY_TENANT_AND_NAME).where();
         query.and(eq(ENTITY_VIEW_TENANT_ID_PROPERTY, tenantId));
         query.and(eq(ENTITY_VIEW_TENANT_ID_PROPERTY, tenantId));
         query.and(eq(ENTITY_VIEW_NAME_PROPERTY, name));
         query.and(eq(ENTITY_VIEW_NAME_PROPERTY, name));
-        return Optional.ofNullable(DaoUtil.getData(findOneByStatement(query)));
+        return Optional.ofNullable(DaoUtil.getData(findOneByStatement(new TenantId(tenantId), query)));
     }
     }
 
 
     @Override
     @Override
     public List<EntityView> findEntityViewsByTenantIdAndCustomerId(UUID tenantId, UUID customerId, TextPageLink pageLink) {
     public List<EntityView> findEntityViewsByTenantIdAndCustomerId(UUID tenantId, UUID customerId, TextPageLink pageLink) {
         log.debug("Try to find entity views by tenantId [{}], customerId[{}] and pageLink [{}]",
         log.debug("Try to find entity views by tenantId [{}], customerId[{}] and pageLink [{}]",
                 tenantId, customerId, pageLink);
                 tenantId, customerId, pageLink);
-        List<EntityViewEntity> entityViewEntities = findPageWithTextSearch(
+        List<EntityViewEntity> entityViewEntities = findPageWithTextSearch(new TenantId(tenantId),
                 ENTITY_VIEW_BY_TENANT_AND_CUSTOMER_CF,
                 ENTITY_VIEW_BY_TENANT_AND_CUSTOMER_CF,
                 Arrays.asList(eq(CUSTOMER_ID_PROPERTY, customerId), eq(TENANT_ID_PROPERTY, tenantId)),
                 Arrays.asList(eq(CUSTOMER_ID_PROPERTY, customerId), eq(TENANT_ID_PROPERTY, tenantId)),
                 pageLink);
                 pageLink);
@@ -139,7 +140,7 @@ public class CassandraEntityViewDao extends CassandraAbstractSearchTextDao<Entit
     public List<EntityView> findEntityViewsByTenantIdAndCustomerIdAndType(UUID tenantId, UUID customerId, String type, TextPageLink pageLink) {
     public List<EntityView> findEntityViewsByTenantIdAndCustomerIdAndType(UUID tenantId, UUID customerId, String type, TextPageLink pageLink) {
         log.debug("Try to find entity views by tenantId [{}], customerId[{}], type [{}] and pageLink [{}]",
         log.debug("Try to find entity views by tenantId [{}], customerId[{}], type [{}] and pageLink [{}]",
                 tenantId, customerId, type, pageLink);
                 tenantId, customerId, type, pageLink);
-        List<EntityViewEntity> entityViewEntities = findPageWithTextSearch(
+        List<EntityViewEntity> entityViewEntities = findPageWithTextSearch(new TenantId(tenantId),
                 ENTITY_VIEW_BY_TENANT_AND_CUSTOMER_AND_TYPE_CF,
                 ENTITY_VIEW_BY_TENANT_AND_CUSTOMER_AND_TYPE_CF,
                 Arrays.asList(eq(DEVICE_TYPE_PROPERTY, type), eq(CUSTOMER_ID_PROPERTY, customerId), eq(TENANT_ID_PROPERTY, tenantId)),
                 Arrays.asList(eq(DEVICE_TYPE_PROPERTY, type), eq(CUSTOMER_ID_PROPERTY, customerId), eq(TENANT_ID_PROPERTY, tenantId)),
                 pageLink);
                 pageLink);
@@ -154,7 +155,7 @@ public class CassandraEntityViewDao extends CassandraAbstractSearchTextDao<Entit
         Select.Where query = select().from(ENTITY_VIEW_BY_TENANT_AND_ENTITY_ID_CF).where();
         Select.Where query = select().from(ENTITY_VIEW_BY_TENANT_AND_ENTITY_ID_CF).where();
         query.and(eq(TENANT_ID_PROPERTY, tenantId));
         query.and(eq(TENANT_ID_PROPERTY, tenantId));
         query.and(eq(ENTITY_ID_COLUMN, entityId));
         query.and(eq(ENTITY_ID_COLUMN, entityId));
-        return findListByStatementAsync(query);
+        return findListByStatementAsync(new TenantId(tenantId), query);
     }
     }
 
 
     @Override
     @Override
@@ -164,7 +165,7 @@ public class CassandraEntityViewDao extends CassandraAbstractSearchTextDao<Entit
         query.and(eq(ENTITY_SUBTYPE_TENANT_ID_PROPERTY, tenantId));
         query.and(eq(ENTITY_SUBTYPE_TENANT_ID_PROPERTY, tenantId));
         query.and(eq(ENTITY_SUBTYPE_ENTITY_TYPE_PROPERTY, EntityType.ENTITY_VIEW));
         query.and(eq(ENTITY_SUBTYPE_ENTITY_TYPE_PROPERTY, EntityType.ENTITY_VIEW));
         query.setConsistencyLevel(cluster.getDefaultReadConsistencyLevel());
         query.setConsistencyLevel(cluster.getDefaultReadConsistencyLevel());
-        ResultSetFuture resultSetFuture = executeAsyncRead(query);
+        ResultSetFuture resultSetFuture = executeAsyncRead(new TenantId(tenantId), query);
         return Futures.transform(resultSetFuture, new Function<ResultSet, List<EntitySubtype>>() {
         return Futures.transform(resultSetFuture, new Function<ResultSet, List<EntitySubtype>>() {
             @Nullable
             @Nullable
             @Override
             @Override

@@ -19,6 +19,7 @@ import com.google.common.util.concurrent.ListenableFuture;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.EntitySubtype;
 import org.thingsboard.server.common.data.EntitySubtype;
 import org.thingsboard.server.common.data.EntityView;
 import org.thingsboard.server.common.data.EntityView;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.dao.Dao;
 import org.thingsboard.server.dao.Dao;
 
 
@@ -37,7 +38,7 @@ public interface EntityViewDao extends Dao<EntityView> {
      * @param entityView the entity-view object
      * @param entityView the entity-view object
      * @return saved entity-view object
      * @return saved entity-view object
      */
      */
-    EntityView save(EntityView entityView);
+    EntityView save(TenantId tenantId, EntityView entityView);
 
 
     /**
     /**
      * Find entity views by tenantId and page link.
      * Find entity views by tenantId and page link.

@@ -18,6 +18,7 @@ package org.thingsboard.server.dao.entityview;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListenableFuture;
 import org.thingsboard.server.common.data.EntitySubtype;
 import org.thingsboard.server.common.data.EntitySubtype;
 import org.thingsboard.server.common.data.EntityView;
 import org.thingsboard.server.common.data.EntityView;
+import org.thingsboard.server.common.data.Tenant;
 import org.thingsboard.server.common.data.entityview.EntityViewSearchQuery;
 import org.thingsboard.server.common.data.entityview.EntityViewSearchQuery;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityId;
@@ -35,13 +36,13 @@ public interface EntityViewService {
 
 
     EntityView saveEntityView(EntityView entityView);
     EntityView saveEntityView(EntityView entityView);
 
 
-    EntityView assignEntityViewToCustomer(EntityViewId entityViewId, CustomerId customerId);
+    EntityView assignEntityViewToCustomer(TenantId tenantId, EntityViewId entityViewId, CustomerId customerId);
 
 
-    EntityView unassignEntityViewFromCustomer(EntityViewId entityViewId);
+    EntityView unassignEntityViewFromCustomer(TenantId tenantId, EntityViewId entityViewId);
 
 
     void unassignCustomerEntityViews(TenantId tenantId, CustomerId customerId);
     void unassignCustomerEntityViews(TenantId tenantId, CustomerId customerId);
 
 
-    EntityView findEntityViewById(EntityViewId entityViewId);
+    EntityView findEntityViewById(TenantId tenantId, EntityViewId entityViewId);
 
 
     EntityView findEntityViewByTenantIdAndName(TenantId tenantId, String name);
     EntityView findEntityViewByTenantIdAndName(TenantId tenantId, String name);
 
 
@@ -53,13 +54,13 @@ public interface EntityViewService {
 
 
     TextPageData<EntityView> findEntityViewsByTenantIdAndCustomerIdAndType(TenantId tenantId, CustomerId customerId, TextPageLink pageLink, String type);
     TextPageData<EntityView> findEntityViewsByTenantIdAndCustomerIdAndType(TenantId tenantId, CustomerId customerId, TextPageLink pageLink, String type);
 
 
-    ListenableFuture<List<EntityView>> findEntityViewsByQuery(EntityViewSearchQuery query);
+    ListenableFuture<List<EntityView>> findEntityViewsByQuery(TenantId tenantId, EntityViewSearchQuery query);
 
 
-    ListenableFuture<EntityView> findEntityViewByIdAsync(EntityViewId entityViewId);
+    ListenableFuture<EntityView> findEntityViewByIdAsync(TenantId tenantId, EntityViewId entityViewId);
 
 
     ListenableFuture<List<EntityView>> findEntityViewsByTenantIdAndEntityIdAsync(TenantId tenantId, EntityId entityId);
     ListenableFuture<List<EntityView>> findEntityViewsByTenantIdAndEntityIdAsync(TenantId tenantId, EntityId entityId);
 
 
-    void deleteEntityView(EntityViewId entityViewId);
+    void deleteEntityView(TenantId tenantId, EntityViewId entityViewId);
 
 
     void deleteEntityViewsByTenantId(TenantId tenantId);
     void deleteEntityViewsByTenantId(TenantId tenantId);
 
 

@@ -95,23 +95,23 @@ public class EntityViewServiceImpl extends AbstractEntityService implements Enti
     @Override
     @Override
     public EntityView saveEntityView(EntityView entityView) {
     public EntityView saveEntityView(EntityView entityView) {
         log.trace("Executing save entity view [{}]", entityView);
         log.trace("Executing save entity view [{}]", entityView);
-        entityViewValidator.validate(entityView);
-        EntityView savedEntityView = entityViewDao.save(entityView);
+        entityViewValidator.validate(entityView, EntityView::getTenantId);
+        EntityView savedEntityView = entityViewDao.save(entityView.getTenantId(), entityView);
         return savedEntityView;
         return savedEntityView;
     }
     }
 
 
     @CacheEvict(cacheNames = ENTITY_VIEW_CACHE, key = "{#entityViewId}")
     @CacheEvict(cacheNames = ENTITY_VIEW_CACHE, key = "{#entityViewId}")
     @Override
     @Override
-    public EntityView assignEntityViewToCustomer(EntityViewId entityViewId, CustomerId customerId) {
-        EntityView entityView = findEntityViewById(entityViewId);
+    public EntityView assignEntityViewToCustomer(TenantId tenantId, EntityViewId entityViewId, CustomerId customerId) {
+        EntityView entityView = findEntityViewById(tenantId, entityViewId);
         entityView.setCustomerId(customerId);
         entityView.setCustomerId(customerId);
         return saveEntityView(entityView);
         return saveEntityView(entityView);
     }
     }
 
 
     @CacheEvict(cacheNames = ENTITY_VIEW_CACHE, key = "{#entityViewId}")
     @CacheEvict(cacheNames = ENTITY_VIEW_CACHE, key = "{#entityViewId}")
     @Override
     @Override
-    public EntityView unassignEntityViewFromCustomer(EntityViewId entityViewId) {
-        EntityView entityView = findEntityViewById(entityViewId);
+    public EntityView unassignEntityViewFromCustomer(TenantId tenantId, EntityViewId entityViewId) {
+        EntityView entityView = findEntityViewById(tenantId, entityViewId);
         entityView.setCustomerId(null);
         entityView.setCustomerId(null);
         return saveEntityView(entityView);
         return saveEntityView(entityView);
     }
     }
@@ -121,15 +121,15 @@ public class EntityViewServiceImpl extends AbstractEntityService implements Enti
         log.trace("Executing unassignCustomerEntityViews, tenantId [{}], customerId [{}]", tenantId, customerId);
         log.trace("Executing unassignCustomerEntityViews, tenantId [{}], customerId [{}]", tenantId, customerId);
         validateId(tenantId, INCORRECT_TENANT_ID + tenantId);
         validateId(tenantId, INCORRECT_TENANT_ID + tenantId);
         validateId(customerId, INCORRECT_CUSTOMER_ID + customerId);
         validateId(customerId, INCORRECT_CUSTOMER_ID + customerId);
-        new CustomerEntityViewsUnAssigner(tenantId).removeEntities(customerId);
+        customerEntityViewsUnAssigner.removeEntities(tenantId, customerId);
     }
     }
 
 
     @Cacheable(cacheNames = ENTITY_VIEW_CACHE, key = "{#entityViewId}")
     @Cacheable(cacheNames = ENTITY_VIEW_CACHE, key = "{#entityViewId}")
     @Override
     @Override
-    public EntityView findEntityViewById(EntityViewId entityViewId) {
+    public EntityView findEntityViewById(TenantId tenantId, EntityViewId entityViewId) {
         log.trace("Executing findEntityViewById [{}]", entityViewId);
         log.trace("Executing findEntityViewById [{}]", entityViewId);
         validateId(entityViewId, INCORRECT_ENTITY_VIEW_ID + entityViewId);
         validateId(entityViewId, INCORRECT_ENTITY_VIEW_ID + entityViewId);
-        return entityViewDao.findById(entityViewId.getId());
+        return entityViewDao.findById(tenantId, entityViewId.getId());
     }
     }
 
 
     @Cacheable(cacheNames = ENTITY_VIEW_CACHE, key = "{#tenantId, #name}")
     @Cacheable(cacheNames = ENTITY_VIEW_CACHE, key = "{#tenantId, #name}")
@@ -187,15 +187,15 @@ public class EntityViewServiceImpl extends AbstractEntityService implements Enti
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<List<EntityView>> findEntityViewsByQuery(EntityViewSearchQuery query) {
-        ListenableFuture<List<EntityRelation>> relations = relationService.findByQuery(query.toEntitySearchQuery());
+    public ListenableFuture<List<EntityView>> findEntityViewsByQuery(TenantId tenantId, EntityViewSearchQuery query) {
+        ListenableFuture<List<EntityRelation>> relations = relationService.findByQuery(tenantId, query.toEntitySearchQuery());
         ListenableFuture<List<EntityView>> entityViews = Futures.transformAsync(relations, r -> {
         ListenableFuture<List<EntityView>> entityViews = Futures.transformAsync(relations, r -> {
             EntitySearchDirection direction = query.toEntitySearchQuery().getParameters().getDirection();
             EntitySearchDirection direction = query.toEntitySearchQuery().getParameters().getDirection();
             List<ListenableFuture<EntityView>> futures = new ArrayList<>();
             List<ListenableFuture<EntityView>> futures = new ArrayList<>();
             for (EntityRelation relation : r) {
             for (EntityRelation relation : r) {
                 EntityId entityId = direction == EntitySearchDirection.FROM ? relation.getTo() : relation.getFrom();
                 EntityId entityId = direction == EntitySearchDirection.FROM ? relation.getTo() : relation.getFrom();
                 if (entityId.getEntityType() == EntityType.ENTITY_VIEW) {
                 if (entityId.getEntityType() == EntityType.ENTITY_VIEW) {
-                    futures.add(findEntityViewByIdAsync(new EntityViewId(entityId.getId())));
+                    futures.add(findEntityViewByIdAsync(tenantId, new EntityViewId(entityId.getId())));
                 }
                 }
             }
             }
             return Futures.successfulAsList(futures);
             return Futures.successfulAsList(futures);
@@ -213,10 +213,10 @@ public class EntityViewServiceImpl extends AbstractEntityService implements Enti
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<EntityView> findEntityViewByIdAsync(EntityViewId entityViewId) {
+    public ListenableFuture<EntityView> findEntityViewByIdAsync(TenantId tenantId, EntityViewId entityViewId) {
         log.trace("Executing findEntityViewById [{}]", entityViewId);
         log.trace("Executing findEntityViewById [{}]", entityViewId);
         validateId(entityViewId, INCORRECT_ENTITY_VIEW_ID + entityViewId);
         validateId(entityViewId, INCORRECT_ENTITY_VIEW_ID + entityViewId);
-        return entityViewDao.findByIdAsync(entityViewId.getId());
+        return entityViewDao.findByIdAsync(tenantId, entityViewId.getId());
     }
     }
 
 
     @Override
     @Override
@@ -253,21 +253,21 @@ public class EntityViewServiceImpl extends AbstractEntityService implements Enti
 
 
     @CacheEvict(cacheNames = ENTITY_VIEW_CACHE, key = "{#entityViewId}")
     @CacheEvict(cacheNames = ENTITY_VIEW_CACHE, key = "{#entityViewId}")
     @Override
     @Override
-    public void deleteEntityView(EntityViewId entityViewId) {
+    public void deleteEntityView(TenantId tenantId, EntityViewId entityViewId) {
         log.trace("Executing deleteEntityView [{}]", entityViewId);
         log.trace("Executing deleteEntityView [{}]", entityViewId);
         validateId(entityViewId, INCORRECT_ENTITY_VIEW_ID + entityViewId);
         validateId(entityViewId, INCORRECT_ENTITY_VIEW_ID + entityViewId);
-        deleteEntityRelations(entityViewId);
-        EntityView entityView = entityViewDao.findById(entityViewId.getId());
+        deleteEntityRelations(tenantId, entityViewId);
+        EntityView entityView = entityViewDao.findById(tenantId, entityViewId.getId());
         cacheManager.getCache(ENTITY_VIEW_CACHE).evict(Arrays.asList(entityView.getTenantId(), entityView.getEntityId()));
         cacheManager.getCache(ENTITY_VIEW_CACHE).evict(Arrays.asList(entityView.getTenantId(), entityView.getEntityId()));
         cacheManager.getCache(ENTITY_VIEW_CACHE).evict(Arrays.asList(entityView.getTenantId(), entityView.getName()));
         cacheManager.getCache(ENTITY_VIEW_CACHE).evict(Arrays.asList(entityView.getTenantId(), entityView.getName()));
-        entityViewDao.removeById(entityViewId.getId());
+        entityViewDao.removeById(tenantId, entityViewId.getId());
     }
     }
 
 
     @Override
     @Override
     public void deleteEntityViewsByTenantId(TenantId tenantId) {
     public void deleteEntityViewsByTenantId(TenantId tenantId) {
         log.trace("Executing deleteEntityViewsByTenantId, tenantId [{}]", tenantId);
         log.trace("Executing deleteEntityViewsByTenantId, tenantId [{}]", tenantId);
         validateId(tenantId, INCORRECT_TENANT_ID + tenantId);
         validateId(tenantId, INCORRECT_TENANT_ID + tenantId);
-        tenantEntityViewRemover.removeEntities(tenantId);
+        tenantEntityViewRemover.removeEntities(tenantId, tenantId);
     }
     }
 
 
     @Override
     @Override
@@ -286,7 +286,7 @@ public class EntityViewServiceImpl extends AbstractEntityService implements Enti
             new DataValidator<EntityView>() {
             new DataValidator<EntityView>() {
 
 
                 @Override
                 @Override
-                protected void validateCreate(EntityView entityView) {
+                protected void validateCreate(TenantId tenantId, EntityView entityView) {
                     entityViewDao.findEntityViewByTenantIdAndName(entityView.getTenantId().getId(), entityView.getName())
                     entityViewDao.findEntityViewByTenantIdAndName(entityView.getTenantId().getId(), entityView.getName())
                             .ifPresent(e -> {
                             .ifPresent(e -> {
                                 throw new DataValidationException("Entity view with such name already exists!");
                                 throw new DataValidationException("Entity view with such name already exists!");
@@ -294,7 +294,7 @@ public class EntityViewServiceImpl extends AbstractEntityService implements Enti
                 }
                 }
 
 
                 @Override
                 @Override
-                protected void validateUpdate(EntityView entityView) {
+                protected void validateUpdate(TenantId tenantId, EntityView entityView) {
                     entityViewDao.findEntityViewByTenantIdAndName(entityView.getTenantId().getId(), entityView.getName())
                     entityViewDao.findEntityViewByTenantIdAndName(entityView.getTenantId().getId(), entityView.getName())
                             .ifPresent(e -> {
                             .ifPresent(e -> {
                                 if (!e.getUuidId().equals(entityView.getUuidId())) {
                                 if (!e.getUuidId().equals(entityView.getUuidId())) {
@@ -304,7 +304,7 @@ public class EntityViewServiceImpl extends AbstractEntityService implements Enti
                 }
                 }
 
 
                 @Override
                 @Override
-                protected void validateDataImpl(EntityView entityView) {
+                protected void validateDataImpl(TenantId tenantId, EntityView entityView) {
                     if (StringUtils.isEmpty(entityView.getType())) {
                     if (StringUtils.isEmpty(entityView.getType())) {
                         throw new DataValidationException("Entity View type should be specified!");
                         throw new DataValidationException("Entity View type should be specified!");
                     }
                     }
@@ -314,7 +314,7 @@ public class EntityViewServiceImpl extends AbstractEntityService implements Enti
                     if (entityView.getTenantId() == null) {
                     if (entityView.getTenantId() == null) {
                         throw new DataValidationException("Entity view should be assigned to tenant!");
                         throw new DataValidationException("Entity view should be assigned to tenant!");
                     } else {
                     } else {
-                        Tenant tenant = tenantDao.findById(entityView.getTenantId().getId());
+                        Tenant tenant = tenantDao.findById(tenantId, entityView.getTenantId().getId());
                         if (tenant == null) {
                         if (tenant == null) {
                             throw new DataValidationException("Entity view is referencing to non-existent tenant!");
                             throw new DataValidationException("Entity view is referencing to non-existent tenant!");
                         }
                         }
@@ -322,7 +322,7 @@ public class EntityViewServiceImpl extends AbstractEntityService implements Enti
                     if (entityView.getCustomerId() == null) {
                     if (entityView.getCustomerId() == null) {
                         entityView.setCustomerId(new CustomerId(NULL_UUID));
                         entityView.setCustomerId(new CustomerId(NULL_UUID));
                     } else if (!entityView.getCustomerId().getId().equals(NULL_UUID)) {
                     } else if (!entityView.getCustomerId().getId().equals(NULL_UUID)) {
-                        Customer customer = customerDao.findById(entityView.getCustomerId().getId());
+                        Customer customer = customerDao.findById(tenantId, entityView.getCustomerId().getId());
                         if (customer == null) {
                         if (customer == null) {
                             throw new DataValidationException("Can't assign entity view to non-existent customer!");
                             throw new DataValidationException("Can't assign entity view to non-existent customer!");
                         }
                         }
@@ -333,36 +333,27 @@ public class EntityViewServiceImpl extends AbstractEntityService implements Enti
                 }
                 }
             };
             };
 
 
-    private PaginatedRemover<TenantId, EntityView> tenantEntityViewRemover =
-            new PaginatedRemover<TenantId, EntityView>() {
-
-                @Override
-                protected List<EntityView> findEntities(TenantId id, TextPageLink pageLink) {
-                    return entityViewDao.findEntityViewsByTenantId(id.getId(), pageLink);
-                }
-
-                @Override
-                protected void removeEntity(EntityView entity) {
-                    deleteEntityView(new EntityViewId(entity.getUuidId()));
-                }
-            };
-
-    private class CustomerEntityViewsUnAssigner extends PaginatedRemover<CustomerId, EntityView> {
-
-        private TenantId tenantId;
+    private PaginatedRemover<TenantId, EntityView> tenantEntityViewRemover = new PaginatedRemover<TenantId, EntityView>() {
+        @Override
+        protected List<EntityView> findEntities(TenantId tenantId, TenantId id, TextPageLink pageLink) {
+            return entityViewDao.findEntityViewsByTenantId(id.getId(), pageLink);
+        }
 
 
-        CustomerEntityViewsUnAssigner(TenantId tenantId) {
-            this.tenantId = tenantId;
+        @Override
+        protected void removeEntity(TenantId tenantId, EntityView entity) {
+            deleteEntityView(tenantId, new EntityViewId(entity.getUuidId()));
         }
         }
+    };
 
 
+    private PaginatedRemover<CustomerId, EntityView> customerEntityViewsUnAssigner = new PaginatedRemover<CustomerId, EntityView>() {
         @Override
         @Override
-        protected List<EntityView> findEntities(CustomerId id, TextPageLink pageLink) {
+        protected List<EntityView> findEntities(TenantId tenantId, CustomerId id, TextPageLink pageLink) {
             return entityViewDao.findEntityViewsByTenantIdAndCustomerId(tenantId.getId(), id.getId(), pageLink);
             return entityViewDao.findEntityViewsByTenantIdAndCustomerId(tenantId.getId(), id.getId(), pageLink);
         }
         }
 
 
         @Override
         @Override
-        protected void removeEntity(EntityView entity) {
-            unassignEntityViewFromCustomer(new EntityViewId(entity.getUuidId()));
+        protected void removeEntity(TenantId tenantId, EntityView entity) {
+            unassignEntityViewFromCustomer(tenantId, new EntityViewId(entity.getUuidId()));
         }
         }
-    }
+    };
 }
 }

@@ -40,19 +40,19 @@ public class BaseEventService implements EventService {
 
 
     @Override
     @Override
     public Event save(Event event) {
     public Event save(Event event) {
-        eventValidator.validate(event);
-        return eventDao.save(event);
+        eventValidator.validate(event, Event::getTenantId);
+        return eventDao.save(event.getTenantId(), event);
     }
     }
 
 
     @Override
     @Override
     public ListenableFuture<Event> saveAsync(Event event) {
     public ListenableFuture<Event> saveAsync(Event event) {
-        eventValidator.validate(event);
+        eventValidator.validate(event, Event::getTenantId);
         return eventDao.saveAsync(event);
         return eventDao.saveAsync(event);
     }
     }
 
 
     @Override
     @Override
     public Optional<Event> saveIfNotExists(Event event) {
     public Optional<Event> saveIfNotExists(Event event) {
-        eventValidator.validate(event);
+        eventValidator.validate(event, Event::getTenantId);
         if (StringUtils.isEmpty(event.getUid())) {
         if (StringUtils.isEmpty(event.getUid())) {
             throw new DataValidationException("Event uid should be specified!.");
             throw new DataValidationException("Event uid should be specified!.");
         }
         }
@@ -97,7 +97,7 @@ public class BaseEventService implements EventService {
     private DataValidator<Event> eventValidator =
     private DataValidator<Event> eventValidator =
             new DataValidator<Event>() {
             new DataValidator<Event>() {
                 @Override
                 @Override
-                protected void validateDataImpl(Event event) {
+                protected void validateDataImpl(TenantId tenantId, Event event) {
                     if (event.getEntityId() == null) {
                     if (event.getEntityId() == null) {
                         throw new DataValidationException("Entity id should be specified!.");
                         throw new DataValidationException("Entity id should be specified!.");
                     }
                     }

@@ -64,7 +64,7 @@ public class CassandraBaseEventDao extends CassandraAbstractSearchTimeDao<EventE
     }
     }
 
 
     @Override
     @Override
-    public Event save(Event event) {
+    public Event save(TenantId tenantId, Event event) {
         try {
         try {
             return saveAsync(event).get();
             return saveAsync(event).get();
         } catch (InterruptedException | ExecutionException e) {
         } catch (InterruptedException | ExecutionException e) {
@@ -85,7 +85,7 @@ public class CassandraBaseEventDao extends CassandraAbstractSearchTimeDao<EventE
         if (StringUtils.isEmpty(event.getUid())) {
         if (StringUtils.isEmpty(event.getUid())) {
             event.setUid(event.getId().toString());
             event.setUid(event.getId().toString());
         }
         }
-        ListenableFuture<Optional<Event>> optionalSave = saveAsync(new EventEntity(event), false);
+        ListenableFuture<Optional<Event>> optionalSave = saveAsync(event.getTenantId(), new EventEntity(event), false);
         return Futures.transform(optionalSave, opt -> opt.orElse(null));
         return Futures.transform(optionalSave, opt -> opt.orElse(null));
     }
     }
 
 
@@ -98,7 +98,7 @@ public class CassandraBaseEventDao extends CassandraAbstractSearchTimeDao<EventE
         if (event.getId() == null) {
         if (event.getId() == null) {
             event.setId(new EventId(UUIDs.timeBased()));
             event.setId(new EventId(UUIDs.timeBased()));
         }
         }
-        return save(new EventEntity(event), true);
+        return save(event.getTenantId(), new EventEntity(event), true);
     }
     }
 
 
     @Override
     @Override
@@ -111,7 +111,7 @@ public class CassandraBaseEventDao extends CassandraAbstractSearchTimeDao<EventE
                 .and(eq(ModelConstants.EVENT_TYPE_PROPERTY, eventType))
                 .and(eq(ModelConstants.EVENT_TYPE_PROPERTY, eventType))
                 .and(eq(ModelConstants.EVENT_UID_PROPERTY, eventUid));
                 .and(eq(ModelConstants.EVENT_UID_PROPERTY, eventUid));
         log.trace("Execute query [{}]", query);
         log.trace("Execute query [{}]", query);
-        EventEntity entity = findOneByStatement(query);
+        EventEntity entity = findOneByStatement(new TenantId(tenantId), query);
         if (log.isTraceEnabled()) {
         if (log.isTraceEnabled()) {
             log.trace("Search result: [{}] for event entity [{}]", entity != null, entity);
             log.trace("Search result: [{}] for event entity [{}]", entity != null, entity);
         } else {
         } else {
@@ -123,7 +123,7 @@ public class CassandraBaseEventDao extends CassandraAbstractSearchTimeDao<EventE
     @Override
     @Override
     public List<Event> findEvents(UUID tenantId, EntityId entityId, TimePageLink pageLink) {
     public List<Event> findEvents(UUID tenantId, EntityId entityId, TimePageLink pageLink) {
         log.trace("Try to find events by tenant [{}], entity [{}]and pageLink [{}]", tenantId, entityId, pageLink);
         log.trace("Try to find events by tenant [{}], entity [{}]and pageLink [{}]", tenantId, entityId, pageLink);
-        List<EventEntity> entities = findPageWithTimeSearch(EVENT_BY_ID_VIEW_NAME,
+        List<EventEntity> entities = findPageWithTimeSearch(new TenantId(tenantId), EVENT_BY_ID_VIEW_NAME,
                 Arrays.asList(eq(ModelConstants.EVENT_TENANT_ID_PROPERTY, tenantId),
                 Arrays.asList(eq(ModelConstants.EVENT_TENANT_ID_PROPERTY, tenantId),
                         eq(ModelConstants.EVENT_ENTITY_TYPE_PROPERTY, entityId.getEntityType()),
                         eq(ModelConstants.EVENT_ENTITY_TYPE_PROPERTY, entityId.getEntityType()),
                         eq(ModelConstants.EVENT_ENTITY_ID_PROPERTY, entityId.getId())),
                         eq(ModelConstants.EVENT_ENTITY_ID_PROPERTY, entityId.getId())),
@@ -135,7 +135,7 @@ public class CassandraBaseEventDao extends CassandraAbstractSearchTimeDao<EventE
     @Override
     @Override
     public List<Event> findEvents(UUID tenantId, EntityId entityId, String eventType, TimePageLink pageLink) {
     public List<Event> findEvents(UUID tenantId, EntityId entityId, String eventType, TimePageLink pageLink) {
         log.trace("Try to find events by tenant [{}], entity [{}], type [{}] and pageLink [{}]", tenantId, entityId, eventType, pageLink);
         log.trace("Try to find events by tenant [{}], entity [{}], type [{}] and pageLink [{}]", tenantId, entityId, eventType, pageLink);
-        List<EventEntity> entities = findPageWithTimeSearch(EVENT_BY_TYPE_AND_ID_VIEW_NAME,
+        List<EventEntity> entities = findPageWithTimeSearch(new TenantId(tenantId), EVENT_BY_TYPE_AND_ID_VIEW_NAME,
                 Arrays.asList(eq(ModelConstants.EVENT_TENANT_ID_PROPERTY, tenantId),
                 Arrays.asList(eq(ModelConstants.EVENT_TENANT_ID_PROPERTY, tenantId),
                         eq(ModelConstants.EVENT_ENTITY_TYPE_PROPERTY, entityId.getEntityType()),
                         eq(ModelConstants.EVENT_ENTITY_TYPE_PROPERTY, entityId.getEntityType()),
                         eq(ModelConstants.EVENT_ENTITY_ID_PROPERTY, entityId.getId()),
                         eq(ModelConstants.EVENT_ENTITY_ID_PROPERTY, entityId.getId()),
@@ -158,19 +158,19 @@ public class CassandraBaseEventDao extends CassandraAbstractSearchTimeDao<EventE
         query.and(eq(ModelConstants.EVENT_TYPE_PROPERTY, eventType));
         query.and(eq(ModelConstants.EVENT_TYPE_PROPERTY, eventType));
         query.limit(limit);
         query.limit(limit);
         query.orderBy(QueryBuilder.desc(ModelConstants.EVENT_TYPE_PROPERTY), QueryBuilder.desc(ModelConstants.ID_PROPERTY));
         query.orderBy(QueryBuilder.desc(ModelConstants.EVENT_TYPE_PROPERTY), QueryBuilder.desc(ModelConstants.ID_PROPERTY));
-        List<EventEntity> entities = findListByStatement(query);
+        List<EventEntity> entities = findListByStatement(new TenantId(tenantId), query);
         return DaoUtil.convertDataList(entities);
         return DaoUtil.convertDataList(entities);
     }
     }
 
 
-    private Optional<Event> save(EventEntity entity, boolean ifNotExists) {
+    private Optional<Event> save(TenantId tenantId, EventEntity entity, boolean ifNotExists) {
         try {
         try {
-            return saveAsync(entity, ifNotExists).get();
+            return saveAsync(tenantId, entity, ifNotExists).get();
         } catch (InterruptedException | ExecutionException e) {
         } catch (InterruptedException | ExecutionException e) {
             throw new IllegalStateException("Could not save EventEntity", e);
             throw new IllegalStateException("Could not save EventEntity", e);
         }
         }
     }
     }
 
 
-    private ListenableFuture<Optional<Event>> saveAsync(EventEntity entity, boolean ifNotExists) {
+    private ListenableFuture<Optional<Event>> saveAsync(TenantId tenantId, EventEntity entity, boolean ifNotExists) {
         if (entity.getId() == null) {
         if (entity.getId() == null) {
             entity.setId(UUIDs.timeBased());
             entity.setId(UUIDs.timeBased());
         }
         }
@@ -185,7 +185,7 @@ public class CassandraBaseEventDao extends CassandraAbstractSearchTimeDao<EventE
         if (ifNotExists) {
         if (ifNotExists) {
             insert = insert.ifNotExists();
             insert = insert.ifNotExists();
         }
         }
-        ResultSetFuture resultSetFuture = executeAsyncWrite(insert);
+        ResultSetFuture resultSetFuture = executeAsyncWrite(tenantId, insert);
         return Futures.transform(resultSetFuture, rs -> {
         return Futures.transform(resultSetFuture, rs -> {
             if (rs.wasApplied()) {
             if (rs.wasApplied()) {
                 return Optional.of(DaoUtil.getData(entity));
                 return Optional.of(DaoUtil.getData(entity));

@@ -18,6 +18,7 @@ package org.thingsboard.server.dao.event;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListenableFuture;
 import org.thingsboard.server.common.data.Event;
 import org.thingsboard.server.common.data.Event;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.TimePageLink;
 import org.thingsboard.server.common.data.page.TimePageLink;
 import org.thingsboard.server.dao.Dao;
 import org.thingsboard.server.dao.Dao;
 
 
@@ -36,7 +37,7 @@ public interface EventDao extends Dao<Event> {
      * @param event the event object
      * @param event the event object
      * @return saved event object
      * @return saved event object
      */
      */
-    Event save(Event event);
+    Event save(TenantId tenantId, Event event);
 
 
     /**
     /**
      * Save or update event object async
      * Save or update event object async

@@ -27,6 +27,7 @@ import com.datastax.driver.core.TypeCodec;
 import com.datastax.driver.core.exceptions.CodecNotFoundException;
 import com.datastax.driver.core.exceptions.CodecNotFoundException;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.dao.cassandra.CassandraCluster;
 import org.thingsboard.server.dao.cassandra.CassandraCluster;
 import org.thingsboard.server.dao.model.type.AuthorityCodec;
 import org.thingsboard.server.dao.model.type.AuthorityCodec;
 import org.thingsboard.server.dao.model.type.ComponentLifecycleStateCodec;
 import org.thingsboard.server.dao.model.type.ComponentLifecycleStateCodec;
@@ -84,37 +85,37 @@ public abstract class CassandraAbstractDao {
         }
         }
     }
     }
 
 
-    protected ResultSet executeRead(Statement statement) {
-        return execute(statement, defaultReadLevel);
+    protected ResultSet executeRead(TenantId tenantId, Statement statement) {
+        return execute(tenantId, statement, defaultReadLevel);
     }
     }
 
 
-    protected ResultSet executeWrite(Statement statement) {
-        return execute(statement, defaultWriteLevel);
+    protected ResultSet executeWrite(TenantId tenantId, Statement statement) {
+        return execute(tenantId, statement, defaultWriteLevel);
     }
     }
 
 
-    protected ResultSetFuture executeAsyncRead(Statement statement) {
-        return executeAsync(statement, defaultReadLevel);
+    protected ResultSetFuture executeAsyncRead(TenantId tenantId, Statement statement) {
+        return executeAsync(tenantId, statement, defaultReadLevel);
     }
     }
 
 
-    protected ResultSetFuture executeAsyncWrite(Statement statement) {
-        return executeAsync(statement, defaultWriteLevel);
+    protected ResultSetFuture executeAsyncWrite(TenantId tenantId, Statement statement) {
+        return executeAsync(tenantId, statement, defaultWriteLevel);
     }
     }
 
 
-    private ResultSet execute(Statement statement, ConsistencyLevel level) {
+    private ResultSet execute(TenantId tenantId, Statement statement, ConsistencyLevel level) {
         if (log.isDebugEnabled()) {
         if (log.isDebugEnabled()) {
             log.debug("Execute cassandra statement {}", statementToString(statement));
             log.debug("Execute cassandra statement {}", statementToString(statement));
         }
         }
-        return executeAsync(statement, level).getUninterruptibly();
+        return executeAsync(tenantId, statement, level).getUninterruptibly();
     }
     }
 
 
-    private ResultSetFuture executeAsync(Statement statement, ConsistencyLevel level) {
+    private ResultSetFuture executeAsync(TenantId tenantId, Statement statement, ConsistencyLevel level) {
         if (log.isDebugEnabled()) {
         if (log.isDebugEnabled()) {
             log.debug("Execute cassandra async statement {}", statementToString(statement));
             log.debug("Execute cassandra async statement {}", statementToString(statement));
         }
         }
         if (statement.getConsistencyLevel() == null) {
         if (statement.getConsistencyLevel() == null) {
             statement.setConsistencyLevel(level);
             statement.setConsistencyLevel(level);
         }
         }
-        return rateLimiter.submit(new CassandraStatementTask(getSession(), statement));
+        return rateLimiter.submit(new CassandraStatementTask(tenantId, getSession(), statement));
     }
     }
 
 
     private static String statementToString(Statement statement) {
     private static String statementToString(Statement statement) {

@@ -27,6 +27,7 @@ import com.google.common.base.Function;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListenableFuture;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.dao.Dao;
 import org.thingsboard.server.dao.Dao;
 import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.model.BaseEntity;
 import org.thingsboard.server.dao.model.BaseEntity;
@@ -56,11 +57,11 @@ public abstract class CassandraAbstractModelDao<E extends BaseEntity<D>, D> exte
         return cluster.getMapper(getColumnFamilyClass());
         return cluster.getMapper(getColumnFamilyClass());
     }
     }
 
 
-    protected List<E> findListByStatement(Statement statement) {
+    protected List<E> findListByStatement(TenantId tenantId, Statement statement) {
         List<E> list = Collections.emptyList();
         List<E> list = Collections.emptyList();
         if (statement != null) {
         if (statement != null) {
             statement.setConsistencyLevel(cluster.getDefaultReadConsistencyLevel());
             statement.setConsistencyLevel(cluster.getDefaultReadConsistencyLevel());
-            ResultSet resultSet = executeRead(statement);
+            ResultSet resultSet = executeRead(tenantId, statement);
             Result<E> result = getMapper().map(resultSet);
             Result<E> result = getMapper().map(resultSet);
             if (result != null) {
             if (result != null) {
                 list = result.all();
                 list = result.all();
@@ -69,10 +70,10 @@ public abstract class CassandraAbstractModelDao<E extends BaseEntity<D>, D> exte
         return list;
         return list;
     }
     }
 
 
-    protected ListenableFuture<List<D>> findListByStatementAsync(Statement statement) {
+    protected ListenableFuture<List<D>> findListByStatementAsync(TenantId tenantId, Statement statement) {
         if (statement != null) {
         if (statement != null) {
             statement.setConsistencyLevel(cluster.getDefaultReadConsistencyLevel());
             statement.setConsistencyLevel(cluster.getDefaultReadConsistencyLevel());
-            ResultSetFuture resultSetFuture = executeAsyncRead(statement);
+            ResultSetFuture resultSetFuture = executeAsyncRead(tenantId, statement);
             return Futures.transform(resultSetFuture, new Function<ResultSet, List<D>>() {
             return Futures.transform(resultSetFuture, new Function<ResultSet, List<D>>() {
                 @Nullable
                 @Nullable
                 @Override
                 @Override
@@ -90,11 +91,11 @@ public abstract class CassandraAbstractModelDao<E extends BaseEntity<D>, D> exte
         return Futures.immediateFuture(Collections.emptyList());
         return Futures.immediateFuture(Collections.emptyList());
     }
     }
 
 
-    protected E findOneByStatement(Statement statement) {
+    protected E findOneByStatement(TenantId tenantId, Statement statement) {
         E object = null;
         E object = null;
         if (statement != null) {
         if (statement != null) {
             statement.setConsistencyLevel(cluster.getDefaultReadConsistencyLevel());
             statement.setConsistencyLevel(cluster.getDefaultReadConsistencyLevel());
-            ResultSet resultSet = executeRead(statement);
+            ResultSet resultSet = executeRead(tenantId, statement);
             Result<E> result = getMapper().map(resultSet);
             Result<E> result = getMapper().map(resultSet);
             if (result != null) {
             if (result != null) {
                 object = result.one();
                 object = result.one();
@@ -103,10 +104,10 @@ public abstract class CassandraAbstractModelDao<E extends BaseEntity<D>, D> exte
         return object;
         return object;
     }
     }
 
 
-    protected ListenableFuture<D> findOneByStatementAsync(Statement statement) {
+    protected ListenableFuture<D> findOneByStatementAsync(TenantId tenantId, Statement statement) {
         if (statement != null) {
         if (statement != null) {
             statement.setConsistencyLevel(cluster.getDefaultReadConsistencyLevel());
             statement.setConsistencyLevel(cluster.getDefaultReadConsistencyLevel());
-            ResultSetFuture resultSetFuture = executeAsyncRead(statement);
+            ResultSetFuture resultSetFuture = executeAsyncRead(tenantId, statement);
             return Futures.transform(resultSetFuture, new Function<ResultSet, D>() {
             return Futures.transform(resultSetFuture, new Function<ResultSet, D>() {
                 @Nullable
                 @Nullable
                 @Override
                 @Override
@@ -128,16 +129,16 @@ public abstract class CassandraAbstractModelDao<E extends BaseEntity<D>, D> exte
         return getMapper().saveQuery(dto);
         return getMapper().saveQuery(dto);
     }
     }
 
 
-    protected EntityResultSet<E> saveWithResult(E entity) {
+    protected EntityResultSet<E> saveWithResult(TenantId tenantId, E entity) {
         log.debug("Save entity {}", entity);
         log.debug("Save entity {}", entity);
         if (entity.getId() == null) {
         if (entity.getId() == null) {
             entity.setId(UUIDs.timeBased());
             entity.setId(UUIDs.timeBased());
         } else if (isDeleteOnSave()) {
         } else if (isDeleteOnSave()) {
-            removeById(entity.getId());
+            removeById(tenantId, entity.getId());
         }
         }
         Statement saveStatement = getSaveQuery(entity);
         Statement saveStatement = getSaveQuery(entity);
         saveStatement.setConsistencyLevel(cluster.getDefaultWriteConsistencyLevel());
         saveStatement.setConsistencyLevel(cluster.getDefaultWriteConsistencyLevel());
-        ResultSet resultSet = executeWrite(saveStatement);
+        ResultSet resultSet = executeWrite(tenantId, saveStatement);
         return new EntityResultSet<>(resultSet, entity);
         return new EntityResultSet<>(resultSet, entity);
     }
     }
 
 
@@ -146,7 +147,7 @@ public abstract class CassandraAbstractModelDao<E extends BaseEntity<D>, D> exte
     }
     }
 
 
     @Override
     @Override
-    public D save(D domain) {
+    public D save(TenantId tenantId, D domain) {
         E entity;
         E entity;
         try {
         try {
             entity = getColumnFamilyClass().getConstructor(domain.getClass()).newInstance(domain);
             entity = getColumnFamilyClass().getConstructor(domain.getClass()).newInstance(domain);
@@ -156,48 +157,39 @@ public abstract class CassandraAbstractModelDao<E extends BaseEntity<D>, D> exte
         }
         }
         entity = updateSearchTextIfPresent(entity);
         entity = updateSearchTextIfPresent(entity);
         log.debug("Saving entity {}", entity);
         log.debug("Saving entity {}", entity);
-        entity = saveWithResult(entity).getEntity();
+        entity = saveWithResult(tenantId, entity).getEntity();
         return DaoUtil.getData(entity);
         return DaoUtil.getData(entity);
     }
     }
 
 
     @Override
     @Override
-    public D findById(UUID key) {
+    public D findById(TenantId tenantId, UUID key) {
         log.debug("Get entity by key {}", key);
         log.debug("Get entity by key {}", key);
         Select.Where query = select().from(getColumnFamilyName()).where(eq(ModelConstants.ID_PROPERTY, key));
         Select.Where query = select().from(getColumnFamilyName()).where(eq(ModelConstants.ID_PROPERTY, key));
         log.trace("Execute query {}", query);
         log.trace("Execute query {}", query);
-        E entity = findOneByStatement(query);
+        E entity = findOneByStatement(tenantId, query);
         return DaoUtil.getData(entity);
         return DaoUtil.getData(entity);
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<D> findByIdAsync(UUID key) {
+    public ListenableFuture<D> findByIdAsync(TenantId tenantId, UUID key) {
         log.debug("Get entity by key {}", key);
         log.debug("Get entity by key {}", key);
         Select.Where query = select().from(getColumnFamilyName()).where(eq(ModelConstants.ID_PROPERTY, key));
         Select.Where query = select().from(getColumnFamilyName()).where(eq(ModelConstants.ID_PROPERTY, key));
         log.trace("Execute query {}", query);
         log.trace("Execute query {}", query);
-        return findOneByStatementAsync(query);
+        return findOneByStatementAsync(tenantId, query);
     }
     }
 
 
     @Override
     @Override
-    public boolean removeById(UUID key) {
+    public boolean removeById(TenantId tenantId, UUID key) {
         Statement delete = QueryBuilder.delete().all().from(getColumnFamilyName()).where(eq(ModelConstants.ID_PROPERTY, key));
         Statement delete = QueryBuilder.delete().all().from(getColumnFamilyName()).where(eq(ModelConstants.ID_PROPERTY, key));
         log.debug("Remove request: {}", delete.toString());
         log.debug("Remove request: {}", delete.toString());
-        return executeWrite(delete).wasApplied();
+        return executeWrite(tenantId, delete).wasApplied();
     }
     }
 
 
     @Override
     @Override
-    public List<D> find() {
+    public List<D> find(TenantId tenantId) {
         log.debug("Get all entities from column family {}", getColumnFamilyName());
         log.debug("Get all entities from column family {}", getColumnFamilyName());
-        List<E> entities = findListByStatement(QueryBuilder.select().all().from(getColumnFamilyName()).setConsistencyLevel(cluster.getDefaultReadConsistencyLevel()));
+        List<E> entities = findListByStatement(tenantId, QueryBuilder.select().all().from(getColumnFamilyName()).setConsistencyLevel(cluster.getDefaultReadConsistencyLevel()));
         return DaoUtil.convertDataList(entities);
         return DaoUtil.convertDataList(entities);
     }
     }
-
-    protected static <T> Function<BaseEntity<T>, T> toDataFunction() {
-        return new Function<BaseEntity<T>, T>() {
-            @Nullable
-            @Override
-            public T apply(@Nullable BaseEntity<T> entity) {
-                return entity != null ? entity.toData() : null;
-            }
-        };
-    }
+    
 }
 }

@@ -21,6 +21,7 @@ import com.datastax.driver.core.querybuilder.Select;
 import com.datastax.driver.core.querybuilder.Select.Where;
 import com.datastax.driver.core.querybuilder.Select.Where;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.StringUtils;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.dao.model.ModelConstants;
 import org.thingsboard.server.dao.model.ModelConstants;
 import org.thingsboard.server.dao.model.SearchTextEntity;
 import org.thingsboard.server.dao.model.SearchTextEntity;
@@ -43,38 +44,38 @@ public abstract class CassandraAbstractSearchTextDao<E extends SearchTextEntity<
         return entity;
         return entity;
     }
     }
 
 
-    protected List<E> findPageWithTextSearch(String searchView, List<Clause> clauses, TextPageLink pageLink) {
+    protected List<E> findPageWithTextSearch(TenantId tenantId, String searchView, List<Clause> clauses, TextPageLink pageLink) {
         Select select = select().from(searchView);
         Select select = select().from(searchView);
         Where query = select.where();
         Where query = select.where();
         for (Clause clause : clauses) {
         for (Clause clause : clauses) {
             query.and(clause);
             query.and(clause);
-        }       
+        }
         query.limit(pageLink.getLimit());
         query.limit(pageLink.getLimit());
         if (!StringUtils.isEmpty(pageLink.getTextOffset())) {
         if (!StringUtils.isEmpty(pageLink.getTextOffset())) {
             query.and(eq(ModelConstants.SEARCH_TEXT_PROPERTY, pageLink.getTextOffset()));
             query.and(eq(ModelConstants.SEARCH_TEXT_PROPERTY, pageLink.getTextOffset()));
             query.and(QueryBuilder.lt(ModelConstants.ID_PROPERTY, pageLink.getIdOffset()));
             query.and(QueryBuilder.lt(ModelConstants.ID_PROPERTY, pageLink.getIdOffset()));
-            List<E> result = findListByStatement(query);
+            List<E> result = findListByStatement(tenantId, query);
             if (result.size() < pageLink.getLimit()) {
             if (result.size() < pageLink.getLimit()) {
                 select = select().from(searchView);
                 select = select().from(searchView);
                 query = select.where();
                 query = select.where();
                 for (Clause clause : clauses) {
                 for (Clause clause : clauses) {
                     query.and(clause);
                     query.and(clause);
-                }      
+                }
                 query.and(QueryBuilder.gt(ModelConstants.SEARCH_TEXT_PROPERTY, pageLink.getTextOffset()));
                 query.and(QueryBuilder.gt(ModelConstants.SEARCH_TEXT_PROPERTY, pageLink.getTextOffset()));
                 if (!StringUtils.isEmpty(pageLink.getTextSearch())) {
                 if (!StringUtils.isEmpty(pageLink.getTextSearch())) {
                     query.and(QueryBuilder.lt(ModelConstants.SEARCH_TEXT_PROPERTY, pageLink.getTextSearchBound()));
                     query.and(QueryBuilder.lt(ModelConstants.SEARCH_TEXT_PROPERTY, pageLink.getTextSearchBound()));
                 }
                 }
                 int limit = pageLink.getLimit() - result.size();
                 int limit = pageLink.getLimit() - result.size();
                 query.limit(limit);
                 query.limit(limit);
-                result.addAll(findListByStatement(query));
+                result.addAll(findListByStatement(tenantId, query));
             }
             }
             return result;
             return result;
         } else if (!StringUtils.isEmpty(pageLink.getTextSearch())) {
         } else if (!StringUtils.isEmpty(pageLink.getTextSearch())) {
             query.and(QueryBuilder.gte(ModelConstants.SEARCH_TEXT_PROPERTY, pageLink.getTextSearch()));
             query.and(QueryBuilder.gte(ModelConstants.SEARCH_TEXT_PROPERTY, pageLink.getTextSearch()));
             query.and(QueryBuilder.lt(ModelConstants.SEARCH_TEXT_PROPERTY, pageLink.getTextSearchBound()));
             query.and(QueryBuilder.lt(ModelConstants.SEARCH_TEXT_PROPERTY, pageLink.getTextSearchBound()));
-            return findListByStatement(query);
+            return findListByStatement(tenantId, query);
         } else {
         } else {
-            return findListByStatement(query);
+            return findListByStatement(tenantId, query);
         }
         }
     }
     }
 
 

@@ -21,6 +21,7 @@ import com.datastax.driver.core.querybuilder.QueryBuilder;
 import com.datastax.driver.core.querybuilder.Select;
 import com.datastax.driver.core.querybuilder.Select;
 import com.datastax.driver.core.querybuilder.Select.Where;
 import com.datastax.driver.core.querybuilder.Select.Where;
 import com.datastax.driver.core.utils.UUIDs;
 import com.datastax.driver.core.utils.UUIDs;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.TimePageLink;
 import org.thingsboard.server.common.data.page.TimePageLink;
 import org.thingsboard.server.dao.model.BaseEntity;
 import org.thingsboard.server.dao.model.BaseEntity;
 import org.thingsboard.server.dao.model.ModelConstants;
 import org.thingsboard.server.dao.model.ModelConstants;
@@ -35,24 +36,24 @@ import static com.datastax.driver.core.querybuilder.QueryBuilder.select;
 public abstract class CassandraAbstractSearchTimeDao<E extends BaseEntity<D>, D> extends CassandraAbstractModelDao<E, D> {
 public abstract class CassandraAbstractSearchTimeDao<E extends BaseEntity<D>, D> extends CassandraAbstractModelDao<E, D> {
 
 
 
 
-    protected List<E> findPageWithTimeSearch(String searchView, List<Clause> clauses, TimePageLink pageLink) {
-        return findPageWithTimeSearch(searchView, clauses, Collections.emptyList(), pageLink);
+    protected List<E> findPageWithTimeSearch(TenantId tenantId, String searchView, List<Clause> clauses, TimePageLink pageLink) {
+        return findPageWithTimeSearch(tenantId, searchView, clauses, Collections.emptyList(), pageLink);
     }
     }
 
 
-    protected List<E> findPageWithTimeSearch(String searchView, List<Clause> clauses, Ordering ordering, TimePageLink pageLink) {
-        return findPageWithTimeSearch(searchView, clauses, Collections.singletonList(ordering), pageLink);
+    protected List<E> findPageWithTimeSearch(TenantId tenantId, String searchView, List<Clause> clauses, Ordering ordering, TimePageLink pageLink) {
+        return findPageWithTimeSearch(tenantId, searchView, clauses, Collections.singletonList(ordering), pageLink);
     }
     }
 
 
-    protected List<E> findPageWithTimeSearch(String searchView, List<Clause> clauses, List<Ordering> topLevelOrderings, TimePageLink pageLink) {
-        return findPageWithTimeSearch(searchView, clauses, topLevelOrderings, pageLink, ModelConstants.ID_PROPERTY);
+    protected List<E> findPageWithTimeSearch(TenantId tenantId, String searchView, List<Clause> clauses, List<Ordering> topLevelOrderings, TimePageLink pageLink) {
+        return findPageWithTimeSearch(tenantId, searchView, clauses, topLevelOrderings, pageLink, ModelConstants.ID_PROPERTY);
     }
     }
 
 
-    protected List<E> findPageWithTimeSearch(String searchView, List<Clause> clauses, TimePageLink pageLink, String idColumn) {
-        return findPageWithTimeSearch(searchView, clauses, Collections.emptyList(), pageLink, idColumn);
+    protected List<E> findPageWithTimeSearch(TenantId tenantId, String searchView, List<Clause> clauses, TimePageLink pageLink, String idColumn) {
+        return findPageWithTimeSearch(tenantId, searchView, clauses, Collections.emptyList(), pageLink, idColumn);
     }
     }
 
 
-    protected List<E> findPageWithTimeSearch(String searchView, List<Clause> clauses, List<Ordering> topLevelOrderings, TimePageLink pageLink, String idColumn) {
-        return findListByStatement(buildQuery(searchView, clauses, topLevelOrderings, pageLink, idColumn));
+    protected List<E> findPageWithTimeSearch(TenantId tenantId, String searchView, List<Clause> clauses, List<Ordering> topLevelOrderings, TimePageLink pageLink, String idColumn) {
+        return findListByStatement(tenantId, buildQuery(searchView, clauses, topLevelOrderings, pageLink, idColumn));
     }
     }
 
 
     public static Where buildQuery(String searchView, List<Clause> clauses, TimePageLink pageLink, String idColumn) {
     public static Where buildQuery(String searchView, List<Clause> clauses, TimePageLink pageLink, String idColumn) {

@@ -22,11 +22,16 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Component;
 import org.springframework.stereotype.Component;
+import org.thingsboard.server.common.data.EntityType;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.msg.tools.TbRateLimits;
 import org.thingsboard.server.dao.util.AbstractBufferedRateExecutor;
 import org.thingsboard.server.dao.util.AbstractBufferedRateExecutor;
 import org.thingsboard.server.dao.util.AsyncTaskContext;
 import org.thingsboard.server.dao.util.AsyncTaskContext;
 import org.thingsboard.server.dao.util.NoSqlAnyDao;
 import org.thingsboard.server.dao.util.NoSqlAnyDao;
 
 
 import javax.annotation.PreDestroy;
 import javax.annotation.PreDestroy;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
 
 
 /**
 /**
  * Created by ashvayka on 24.10.18.
  * Created by ashvayka on 24.10.18.
@@ -42,17 +47,19 @@ public class CassandraBufferedRateExecutor extends AbstractBufferedRateExecutor<
             @Value("${cassandra.query.permit_max_wait_time}") long maxWaitTime,
             @Value("${cassandra.query.permit_max_wait_time}") long maxWaitTime,
             @Value("${cassandra.query.dispatcher_threads:2}") int dispatcherThreads,
             @Value("${cassandra.query.dispatcher_threads:2}") int dispatcherThreads,
             @Value("${cassandra.query.callback_threads:2}") int callbackThreads,
             @Value("${cassandra.query.callback_threads:2}") int callbackThreads,
-            @Value("${cassandra.query.poll_ms:50}") long pollMs) {
-        super(queueLimit, concurrencyLimit, maxWaitTime, dispatcherThreads, callbackThreads, pollMs);
+            @Value("${cassandra.query.poll_ms:50}") long pollMs,
+            @Value("${cassandra.query.tenant_rate_limits.enabled}") boolean tenantRateLimitsEnabled,
+            @Value("${cassandra.query.tenant_rate_limits.configuration}") String tenantRateLimitsConfiguration) {
+        super(queueLimit, concurrencyLimit, maxWaitTime, dispatcherThreads, callbackThreads, pollMs, tenantRateLimitsEnabled, tenantRateLimitsConfiguration);
     }
     }
 
 
     @Scheduled(fixedDelayString = "${cassandra.query.rate_limit_print_interval_ms}")
     @Scheduled(fixedDelayString = "${cassandra.query.rate_limit_print_interval_ms}")
     public void printStats() {
     public void printStats() {
-        log.info("Permits queueSize [{}] totalAdded [{}] totalLaunched [{}] totalReleased [{}] totalFailed [{}] totalExpired [{}] totalRejected [{}] currBuffer [{}] ",
+        log.info("Permits queueSize [{}] totalAdded [{}] totalLaunched [{}] totalReleased [{}] totalFailed [{}] totalExpired [{}] totalRejected [{}] totalRateLimited [{}] currBuffer [{}] ",
                 getQueueSize(),
                 getQueueSize(),
                 totalAdded.getAndSet(0), totalLaunched.getAndSet(0), totalReleased.getAndSet(0),
                 totalAdded.getAndSet(0), totalLaunched.getAndSet(0), totalReleased.getAndSet(0),
                 totalFailed.getAndSet(0), totalExpired.getAndSet(0), totalRejected.getAndSet(0),
                 totalFailed.getAndSet(0), totalExpired.getAndSet(0), totalRejected.getAndSet(0),
-                concurrencyLevel.get());
+                totalRateLimited.getAndSet(0), concurrencyLevel.get());
     }
     }
 
 
     @PreDestroy
     @PreDestroy

@@ -18,6 +18,7 @@ package org.thingsboard.server.dao.nosql;
 import com.datastax.driver.core.Session;
 import com.datastax.driver.core.Session;
 import com.datastax.driver.core.Statement;
 import com.datastax.driver.core.Statement;
 import lombok.Data;
 import lombok.Data;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.dao.util.AsyncTask;
 import org.thingsboard.server.dao.util.AsyncTask;
 
 
 /**
 /**
@@ -26,6 +27,7 @@ import org.thingsboard.server.dao.util.AsyncTask;
 @Data
 @Data
 public class CassandraStatementTask implements AsyncTask {
 public class CassandraStatementTask implements AsyncTask {
 
 
+    private final TenantId tenantId;
     private final Session session;
     private final Session session;
     private final Statement statement;
     private final Statement statement;
 
 

@@ -29,6 +29,7 @@ import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityIdFactory;
 import org.thingsboard.server.common.data.id.EntityIdFactory;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.TimePageLink;
 import org.thingsboard.server.common.data.page.TimePageLink;
 import org.thingsboard.server.common.data.relation.EntityRelation;
 import org.thingsboard.server.common.data.relation.EntityRelation;
 import org.thingsboard.server.common.data.relation.RelationTypeGroup;
 import org.thingsboard.server.common.data.relation.RelationTypeGroup;
@@ -83,45 +84,45 @@ public class BaseRelationDao extends CassandraAbstractAsyncDao implements Relati
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<List<EntityRelation>> findAllByFrom(EntityId from, RelationTypeGroup typeGroup) {
+    public ListenableFuture<List<EntityRelation>> findAllByFrom(TenantId tenantId, EntityId from, RelationTypeGroup typeGroup) {
         BoundStatement stmt = getFindAllByFromStmt().bind()
         BoundStatement stmt = getFindAllByFromStmt().bind()
                 .setUUID(0, from.getId())
                 .setUUID(0, from.getId())
                 .setString(1, from.getEntityType().name())
                 .setString(1, from.getEntityType().name())
                 .set(2, typeGroup, relationTypeGroupCodec);
                 .set(2, typeGroup, relationTypeGroupCodec);
-        return executeAsyncRead(from, stmt);
+        return executeAsyncRead(tenantId, from, stmt);
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<List<EntityRelation>> findAllByFromAndType(EntityId from, String relationType, RelationTypeGroup typeGroup) {
+    public ListenableFuture<List<EntityRelation>> findAllByFromAndType(TenantId tenantId, EntityId from, String relationType, RelationTypeGroup typeGroup) {
         BoundStatement stmt = getFindAllByFromAndTypeStmt().bind()
         BoundStatement stmt = getFindAllByFromAndTypeStmt().bind()
                 .setUUID(0, from.getId())
                 .setUUID(0, from.getId())
                 .setString(1, from.getEntityType().name())
                 .setString(1, from.getEntityType().name())
                 .set(2, typeGroup, relationTypeGroupCodec)
                 .set(2, typeGroup, relationTypeGroupCodec)
                 .setString(3, relationType);
                 .setString(3, relationType);
-        return executeAsyncRead(from, stmt);
+        return executeAsyncRead(tenantId, from, stmt);
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<List<EntityRelation>> findAllByTo(EntityId to, RelationTypeGroup typeGroup) {
+    public ListenableFuture<List<EntityRelation>> findAllByTo(TenantId tenantId, EntityId to, RelationTypeGroup typeGroup) {
         BoundStatement stmt = getFindAllByToStmt().bind()
         BoundStatement stmt = getFindAllByToStmt().bind()
                 .setUUID(0, to.getId())
                 .setUUID(0, to.getId())
                 .setString(1, to.getEntityType().name())
                 .setString(1, to.getEntityType().name())
                 .set(2, typeGroup, relationTypeGroupCodec);
                 .set(2, typeGroup, relationTypeGroupCodec);
-        return executeAsyncRead(to, stmt);
+        return executeAsyncRead(tenantId, to, stmt);
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<List<EntityRelation>> findAllByToAndType(EntityId to, String relationType, RelationTypeGroup typeGroup) {
+    public ListenableFuture<List<EntityRelation>> findAllByToAndType(TenantId tenantId, EntityId to, String relationType, RelationTypeGroup typeGroup) {
         BoundStatement stmt = getFindAllByToAndTypeStmt().bind()
         BoundStatement stmt = getFindAllByToAndTypeStmt().bind()
                 .setUUID(0, to.getId())
                 .setUUID(0, to.getId())
                 .setString(1, to.getEntityType().name())
                 .setString(1, to.getEntityType().name())
                 .set(2, typeGroup, relationTypeGroupCodec)
                 .set(2, typeGroup, relationTypeGroupCodec)
                 .setString(3, relationType);
                 .setString(3, relationType);
-        return executeAsyncRead(to, stmt);
+        return executeAsyncRead(tenantId, to, stmt);
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<Boolean> checkRelation(EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup) {
+    public ListenableFuture<Boolean> checkRelation(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup) {
         BoundStatement stmt = getCheckRelationStmt().bind()
         BoundStatement stmt = getCheckRelationStmt().bind()
                 .setUUID(0, from.getId())
                 .setUUID(0, from.getId())
                 .setString(1, from.getEntityType().name())
                 .setString(1, from.getEntityType().name())
@@ -129,11 +130,11 @@ public class BaseRelationDao extends CassandraAbstractAsyncDao implements Relati
                 .setString(3, to.getEntityType().name())
                 .setString(3, to.getEntityType().name())
                 .set(4, typeGroup, relationTypeGroupCodec)
                 .set(4, typeGroup, relationTypeGroupCodec)
                 .setString(5, relationType);
                 .setString(5, relationType);
-        return getFuture(executeAsyncRead(stmt), rs -> rs != null ? rs.one() != null : false);
+        return getFuture(executeAsyncRead(tenantId, stmt), rs -> rs != null ? rs.one() != null : false);
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<EntityRelation> getRelation(EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup) {
+    public ListenableFuture<EntityRelation> getRelation(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup) {
         BoundStatement stmt = getCheckRelationStmt().bind()
         BoundStatement stmt = getCheckRelationStmt().bind()
                 .setUUID(0, from.getId())
                 .setUUID(0, from.getId())
                 .setString(1, from.getEntityType().name())
                 .setString(1, from.getEntityType().name())
@@ -141,24 +142,24 @@ public class BaseRelationDao extends CassandraAbstractAsyncDao implements Relati
                 .setString(3, to.getEntityType().name())
                 .setString(3, to.getEntityType().name())
                 .set(4, typeGroup, relationTypeGroupCodec)
                 .set(4, typeGroup, relationTypeGroupCodec)
                 .setString(5, relationType);
                 .setString(5, relationType);
-        return getFuture(executeAsyncRead(stmt), rs -> rs != null ? getEntityRelation(rs.one()) : null);
+        return getFuture(executeAsyncRead(tenantId, stmt), rs -> rs != null ? getEntityRelation(rs.one()) : null);
     }
     }
 
 
     @Override
     @Override
-    public boolean saveRelation(EntityRelation relation) {
-        BoundStatement stmt = getSaveRelationStatement(relation);
-        ResultSet rs = executeWrite(stmt);
+    public boolean saveRelation(TenantId tenantId, EntityRelation relation) {
+        BoundStatement stmt = getSaveRelationStatement(tenantId, relation);
+        ResultSet rs = executeWrite(tenantId, stmt);
         return rs.wasApplied();
         return rs.wasApplied();
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<Boolean> saveRelationAsync(EntityRelation relation) {
-        BoundStatement stmt = getSaveRelationStatement(relation);
-        ResultSetFuture future = executeAsyncWrite(stmt);
+    public ListenableFuture<Boolean> saveRelationAsync(TenantId tenantId, EntityRelation relation) {
+        BoundStatement stmt = getSaveRelationStatement(tenantId, relation);
+        ResultSetFuture future = executeAsyncWrite(tenantId, stmt);
         return getBooleanListenableFuture(future);
         return getBooleanListenableFuture(future);
     }
     }
 
 
-    private BoundStatement getSaveRelationStatement(EntityRelation relation) {
+    private BoundStatement getSaveRelationStatement(TenantId tenantId, EntityRelation relation) {
         BoundStatement stmt = getSaveStmt().bind()
         BoundStatement stmt = getSaveStmt().bind()
                 .setUUID(0, relation.getFrom().getId())
                 .setUUID(0, relation.getFrom().getId())
                 .setString(1, relation.getFrom().getEntityType().name())
                 .setString(1, relation.getFrom().getEntityType().name())
@@ -171,30 +172,30 @@ public class BaseRelationDao extends CassandraAbstractAsyncDao implements Relati
     }
     }
 
 
     @Override
     @Override
-    public boolean deleteRelation(EntityRelation relation) {
-        return deleteRelation(relation.getFrom(), relation.getTo(), relation.getType(), relation.getTypeGroup());
+    public boolean deleteRelation(TenantId tenantId, EntityRelation relation) {
+        return deleteRelation(tenantId, relation.getFrom(), relation.getTo(), relation.getType(), relation.getTypeGroup());
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<Boolean> deleteRelationAsync(EntityRelation relation) {
-        return deleteRelationAsync(relation.getFrom(), relation.getTo(), relation.getType(), relation.getTypeGroup());
+    public ListenableFuture<Boolean> deleteRelationAsync(TenantId tenantId, EntityRelation relation) {
+        return deleteRelationAsync(tenantId, relation.getFrom(), relation.getTo(), relation.getType(), relation.getTypeGroup());
     }
     }
 
 
     @Override
     @Override
-    public boolean deleteRelation(EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup) {
-        BoundStatement stmt = getDeleteRelationStatement(from, to, relationType, typeGroup);
-        ResultSet rs = executeWrite(stmt);
+    public boolean deleteRelation(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup) {
+        BoundStatement stmt = getDeleteRelationStatement(tenantId, from, to, relationType, typeGroup);
+        ResultSet rs = executeWrite(tenantId, stmt);
         return rs.wasApplied();
         return rs.wasApplied();
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<Boolean> deleteRelationAsync(EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup) {
-        BoundStatement stmt = getDeleteRelationStatement(from, to, relationType, typeGroup);
-        ResultSetFuture future = executeAsyncWrite(stmt);
+    public ListenableFuture<Boolean> deleteRelationAsync(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup) {
+        BoundStatement stmt = getDeleteRelationStatement(tenantId, from, to, relationType, typeGroup);
+        ResultSetFuture future = executeAsyncWrite(tenantId, stmt);
         return getBooleanListenableFuture(future);
         return getBooleanListenableFuture(future);
     }
     }
 
 
-    private BoundStatement getDeleteRelationStatement(EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup) {
+    private BoundStatement getDeleteRelationStatement(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup) {
         BoundStatement stmt = getDeleteStmt().bind()
         BoundStatement stmt = getDeleteStmt().bind()
                 .setUUID(0, from.getId())
                 .setUUID(0, from.getId())
                 .setString(1, from.getEntityType().name())
                 .setString(1, from.getEntityType().name())
@@ -206,26 +207,26 @@ public class BaseRelationDao extends CassandraAbstractAsyncDao implements Relati
     }
     }
 
 
     @Override
     @Override
-    public boolean deleteOutboundRelations(EntityId entity) {
+    public boolean deleteOutboundRelations(TenantId tenantId, EntityId entity) {
         BoundStatement stmt = getDeleteAllByEntityStmt().bind()
         BoundStatement stmt = getDeleteAllByEntityStmt().bind()
                 .setUUID(0, entity.getId())
                 .setUUID(0, entity.getId())
                 .setString(1, entity.getEntityType().name());
                 .setString(1, entity.getEntityType().name());
-        ResultSet rs = executeWrite(stmt);
+        ResultSet rs = executeWrite(tenantId, stmt);
         return rs.wasApplied();
         return rs.wasApplied();
     }
     }
 
 
 
 
     @Override
     @Override
-    public ListenableFuture<Boolean> deleteOutboundRelationsAsync(EntityId entity) {
+    public ListenableFuture<Boolean> deleteOutboundRelationsAsync(TenantId tenantId, EntityId entity) {
         BoundStatement stmt = getDeleteAllByEntityStmt().bind()
         BoundStatement stmt = getDeleteAllByEntityStmt().bind()
                 .setUUID(0, entity.getId())
                 .setUUID(0, entity.getId())
                 .setString(1, entity.getEntityType().name());
                 .setString(1, entity.getEntityType().name());
-        ResultSetFuture future = executeAsyncWrite(stmt);
+        ResultSetFuture future = executeAsyncWrite(tenantId, stmt);
         return getBooleanListenableFuture(future);
         return getBooleanListenableFuture(future);
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<List<EntityRelation>> findRelations(EntityId from, String relationType, RelationTypeGroup typeGroup, EntityType childType, TimePageLink pageLink) {
+    public ListenableFuture<List<EntityRelation>> findRelations(TenantId tenantId, EntityId from, String relationType, RelationTypeGroup typeGroup, EntityType childType, TimePageLink pageLink) {
         Select.Where query = CassandraAbstractSearchTimeDao.buildQuery(ModelConstants.RELATION_BY_TYPE_AND_CHILD_TYPE_VIEW_NAME,
         Select.Where query = CassandraAbstractSearchTimeDao.buildQuery(ModelConstants.RELATION_BY_TYPE_AND_CHILD_TYPE_VIEW_NAME,
                 Arrays.asList(eq(ModelConstants.RELATION_FROM_ID_PROPERTY, from.getId()),
                 Arrays.asList(eq(ModelConstants.RELATION_FROM_ID_PROPERTY, from.getId()),
                         eq(ModelConstants.RELATION_FROM_TYPE_PROPERTY, from.getEntityType().name()),
                         eq(ModelConstants.RELATION_FROM_TYPE_PROPERTY, from.getEntityType().name()),
@@ -241,7 +242,7 @@ public class BaseRelationDao extends CassandraAbstractAsyncDao implements Relati
                                 QueryBuilder.asc(ModelConstants.RELATION_TO_TYPE_PROPERTY)
                                 QueryBuilder.asc(ModelConstants.RELATION_TO_TYPE_PROPERTY)
                 ),
                 ),
                 pageLink, ModelConstants.RELATION_TO_ID_PROPERTY);
                 pageLink, ModelConstants.RELATION_TO_ID_PROPERTY);
-        return getFuture(executeAsyncRead(query), this::getEntityRelations);
+        return getFuture(executeAsyncRead(tenantId, query), this::getEntityRelations);
     }
     }
 
 
     private PreparedStatement getSaveStmt() {
     private PreparedStatement getSaveStmt() {
@@ -347,9 +348,9 @@ public class BaseRelationDao extends CassandraAbstractAsyncDao implements Relati
         return EntityIdFactory.getByTypeAndUuid(row.getString(typeColumn), row.getUUID(uuidColumn));
         return EntityIdFactory.getByTypeAndUuid(row.getString(typeColumn), row.getUUID(uuidColumn));
     }
     }
 
 
-    private ListenableFuture<List<EntityRelation>> executeAsyncRead(EntityId from, BoundStatement stmt) {
+    private ListenableFuture<List<EntityRelation>> executeAsyncRead(TenantId tenantId, EntityId from, BoundStatement stmt) {
         log.debug("Generated query [{}] for entity {}", stmt, from);
         log.debug("Generated query [{}] for entity {}", stmt, from);
-        return getFuture(executeAsyncRead(stmt), rs -> getEntityRelations(rs));
+        return getFuture(executeAsyncRead(tenantId, stmt), rs -> getEntityRelations(rs));
     }
     }
 
 
     private ListenableFuture<Boolean> getBooleanListenableFuture(ResultSetFuture rsFuture) {
     private ListenableFuture<Boolean> getBooleanListenableFuture(ResultSetFuture rsFuture) {

@@ -26,7 +26,9 @@ import org.springframework.cache.annotation.Cacheable;
 import org.springframework.cache.annotation.Caching;
 import org.springframework.cache.annotation.Caching;
 import org.springframework.stereotype.Service;
 import org.springframework.stereotype.Service;
 import org.springframework.util.StringUtils;
 import org.springframework.util.StringUtils;
+import org.thingsboard.server.common.data.Tenant;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.relation.EntityRelation;
 import org.thingsboard.server.common.data.relation.EntityRelation;
 import org.thingsboard.server.common.data.relation.EntityRelationInfo;
 import org.thingsboard.server.common.data.relation.EntityRelationInfo;
 import org.thingsboard.server.common.data.relation.EntityRelationsQuery;
 import org.thingsboard.server.common.data.relation.EntityRelationsQuery;
@@ -66,27 +68,27 @@ public class BaseRelationService implements RelationService {
     private CacheManager cacheManager;
     private CacheManager cacheManager;
 
 
     @Override
     @Override
-    public ListenableFuture<Boolean> checkRelation(EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup) {
+    public ListenableFuture<Boolean> checkRelation(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup) {
         log.trace("Executing checkRelation [{}][{}][{}][{}]", from, to, relationType, typeGroup);
         log.trace("Executing checkRelation [{}][{}][{}][{}]", from, to, relationType, typeGroup);
         validate(from, to, relationType, typeGroup);
         validate(from, to, relationType, typeGroup);
-        return relationDao.checkRelation(from, to, relationType, typeGroup);
+        return relationDao.checkRelation(tenantId, from, to, relationType, typeGroup);
     }
     }
 
 
     @Cacheable(cacheNames = RELATIONS_CACHE, key = "{#from, #to, #relationType, #typeGroup}")
     @Cacheable(cacheNames = RELATIONS_CACHE, key = "{#from, #to, #relationType, #typeGroup}")
     @Override
     @Override
-    public EntityRelation getRelation(EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup) {
+    public EntityRelation getRelation(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup) {
         try {
         try {
-            return getRelationAsync(from, to, relationType, typeGroup).get();
+            return getRelationAsync(tenantId, from, to, relationType, typeGroup).get();
         } catch (InterruptedException | ExecutionException e) {
         } catch (InterruptedException | ExecutionException e) {
             throw new RuntimeException(e);
             throw new RuntimeException(e);
         }
         }
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<EntityRelation> getRelationAsync(EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup) {
+    public ListenableFuture<EntityRelation> getRelationAsync(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup) {
         log.trace("Executing EntityRelation [{}][{}][{}][{}]", from, to, relationType, typeGroup);
         log.trace("Executing EntityRelation [{}][{}][{}][{}]", from, to, relationType, typeGroup);
         validate(from, to, relationType, typeGroup);
         validate(from, to, relationType, typeGroup);
-        return relationDao.getRelation(from, to, relationType, typeGroup);
+        return relationDao.getRelation(tenantId, from, to, relationType, typeGroup);
     }
     }
 
 
     @Caching(evict = {
     @Caching(evict = {
@@ -97,10 +99,10 @@ public class BaseRelationService implements RelationService {
             @CacheEvict(cacheNames = RELATIONS_CACHE, key = "{#relation.to, #relation.type, #relation.typeGroup, 'TO'}")
             @CacheEvict(cacheNames = RELATIONS_CACHE, key = "{#relation.to, #relation.type, #relation.typeGroup, 'TO'}")
     })
     })
     @Override
     @Override
-    public boolean saveRelation(EntityRelation relation) {
+    public boolean saveRelation(TenantId tenantId, EntityRelation relation) {
         log.trace("Executing saveRelation [{}]", relation);
         log.trace("Executing saveRelation [{}]", relation);
         validate(relation);
         validate(relation);
-        return relationDao.saveRelation(relation);
+        return relationDao.saveRelation(tenantId, relation);
     }
     }
 
 
     @Caching(evict = {
     @Caching(evict = {
@@ -111,10 +113,10 @@ public class BaseRelationService implements RelationService {
             @CacheEvict(cacheNames = RELATIONS_CACHE, key = "{#relation.to, #relation.type, #relation.typeGroup, 'TO'}")
             @CacheEvict(cacheNames = RELATIONS_CACHE, key = "{#relation.to, #relation.type, #relation.typeGroup, 'TO'}")
     })
     })
     @Override
     @Override
-    public ListenableFuture<Boolean> saveRelationAsync(EntityRelation relation) {
+    public ListenableFuture<Boolean> saveRelationAsync(TenantId tenantId, EntityRelation relation) {
         log.trace("Executing saveRelationAsync [{}]", relation);
         log.trace("Executing saveRelationAsync [{}]", relation);
         validate(relation);
         validate(relation);
-        return relationDao.saveRelationAsync(relation);
+        return relationDao.saveRelationAsync(tenantId, relation);
     }
     }
 
 
     @Caching(evict = {
     @Caching(evict = {
@@ -125,10 +127,10 @@ public class BaseRelationService implements RelationService {
             @CacheEvict(cacheNames = RELATIONS_CACHE, key = "{#relation.to, #relation.type, #relation.typeGroup, 'TO'}")
             @CacheEvict(cacheNames = RELATIONS_CACHE, key = "{#relation.to, #relation.type, #relation.typeGroup, 'TO'}")
     })
     })
     @Override
     @Override
-    public boolean deleteRelation(EntityRelation relation) {
+    public boolean deleteRelation(TenantId tenantId, EntityRelation relation) {
         log.trace("Executing deleteRelation [{}]", relation);
         log.trace("Executing deleteRelation [{}]", relation);
         validate(relation);
         validate(relation);
-        return relationDao.deleteRelation(relation);
+        return relationDao.deleteRelation(tenantId, relation);
     }
     }
 
 
     @Caching(evict = {
     @Caching(evict = {
@@ -139,10 +141,10 @@ public class BaseRelationService implements RelationService {
             @CacheEvict(cacheNames = RELATIONS_CACHE, key = "{#relation.to, #relation.type, #relation.typeGroup, 'TO'}")
             @CacheEvict(cacheNames = RELATIONS_CACHE, key = "{#relation.to, #relation.type, #relation.typeGroup, 'TO'}")
     })
     })
     @Override
     @Override
-    public ListenableFuture<Boolean> deleteRelationAsync(EntityRelation relation) {
+    public ListenableFuture<Boolean> deleteRelationAsync(TenantId tenantId, EntityRelation relation) {
         log.trace("Executing deleteRelationAsync [{}]", relation);
         log.trace("Executing deleteRelationAsync [{}]", relation);
         validate(relation);
         validate(relation);
-        return relationDao.deleteRelationAsync(relation);
+        return relationDao.deleteRelationAsync(tenantId, relation);
     }
     }
 
 
     @Caching(evict = {
     @Caching(evict = {
@@ -153,10 +155,10 @@ public class BaseRelationService implements RelationService {
             @CacheEvict(cacheNames = RELATIONS_CACHE, key = "{#to, #relationType, #typeGroup, 'TO'}")
             @CacheEvict(cacheNames = RELATIONS_CACHE, key = "{#to, #relationType, #typeGroup, 'TO'}")
     })
     })
     @Override
     @Override
-    public boolean deleteRelation(EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup) {
+    public boolean deleteRelation(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup) {
         log.trace("Executing deleteRelation [{}][{}][{}][{}]", from, to, relationType, typeGroup);
         log.trace("Executing deleteRelation [{}][{}][{}][{}]", from, to, relationType, typeGroup);
         validate(from, to, relationType, typeGroup);
         validate(from, to, relationType, typeGroup);
-        return relationDao.deleteRelation(from, to, relationType, typeGroup);
+        return relationDao.deleteRelation(tenantId, from, to, relationType, typeGroup);
     }
     }
 
 
     @Caching(evict = {
     @Caching(evict = {
@@ -167,69 +169,69 @@ public class BaseRelationService implements RelationService {
             @CacheEvict(cacheNames = RELATIONS_CACHE, key = "{#to, #relationType, #typeGroup, 'TO'}")
             @CacheEvict(cacheNames = RELATIONS_CACHE, key = "{#to, #relationType, #typeGroup, 'TO'}")
     })
     })
     @Override
     @Override
-    public ListenableFuture<Boolean> deleteRelationAsync(EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup) {
+    public ListenableFuture<Boolean> deleteRelationAsync(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup) {
         log.trace("Executing deleteRelationAsync [{}][{}][{}][{}]", from, to, relationType, typeGroup);
         log.trace("Executing deleteRelationAsync [{}][{}][{}][{}]", from, to, relationType, typeGroup);
         validate(from, to, relationType, typeGroup);
         validate(from, to, relationType, typeGroup);
-        return relationDao.deleteRelationAsync(from, to, relationType, typeGroup);
+        return relationDao.deleteRelationAsync(tenantId, from, to, relationType, typeGroup);
     }
     }
 
 
     @Override
     @Override
-    public void deleteEntityRelations(EntityId entityId) {
+    public void deleteEntityRelations(TenantId tenantId, EntityId entityId) {
         try {
         try {
-            deleteEntityRelationsAsync(entityId).get();
+            deleteEntityRelationsAsync(tenantId, entityId).get();
         } catch (InterruptedException | ExecutionException e) {
         } catch (InterruptedException | ExecutionException e) {
             throw new RuntimeException(e);
             throw new RuntimeException(e);
         }
         }
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<Void> deleteEntityRelationsAsync(EntityId entityId) {
+    public ListenableFuture<Void> deleteEntityRelationsAsync(TenantId tenantId, EntityId entityId) {
         Cache cache = cacheManager.getCache(RELATIONS_CACHE);
         Cache cache = cacheManager.getCache(RELATIONS_CACHE);
         log.trace("Executing deleteEntityRelationsAsync [{}]", entityId);
         log.trace("Executing deleteEntityRelationsAsync [{}]", entityId);
         validate(entityId);
         validate(entityId);
         List<ListenableFuture<List<EntityRelation>>> inboundRelationsList = new ArrayList<>();
         List<ListenableFuture<List<EntityRelation>>> inboundRelationsList = new ArrayList<>();
         for (RelationTypeGroup typeGroup : RelationTypeGroup.values()) {
         for (RelationTypeGroup typeGroup : RelationTypeGroup.values()) {
-            inboundRelationsList.add(relationDao.findAllByTo(entityId, typeGroup));
+            inboundRelationsList.add(relationDao.findAllByTo(tenantId, entityId, typeGroup));
         }
         }
 
 
         ListenableFuture<List<List<EntityRelation>>> inboundRelations = Futures.allAsList(inboundRelationsList);
         ListenableFuture<List<List<EntityRelation>>> inboundRelations = Futures.allAsList(inboundRelationsList);
 
 
         List<ListenableFuture<List<EntityRelation>>> outboundRelationsList = new ArrayList<>();
         List<ListenableFuture<List<EntityRelation>>> outboundRelationsList = new ArrayList<>();
         for (RelationTypeGroup typeGroup : RelationTypeGroup.values()) {
         for (RelationTypeGroup typeGroup : RelationTypeGroup.values()) {
-            outboundRelationsList.add(relationDao.findAllByFrom(entityId, typeGroup));
+            outboundRelationsList.add(relationDao.findAllByFrom(tenantId, entityId, typeGroup));
         }
         }
 
 
         ListenableFuture<List<List<EntityRelation>>> outboundRelations = Futures.allAsList(outboundRelationsList);
         ListenableFuture<List<List<EntityRelation>>> outboundRelations = Futures.allAsList(outboundRelationsList);
 
 
         ListenableFuture<List<Boolean>> inboundDeletions = Futures.transformAsync(inboundRelations,
         ListenableFuture<List<Boolean>> inboundDeletions = Futures.transformAsync(inboundRelations,
                 relations -> {
                 relations -> {
-                    List<ListenableFuture<Boolean>> results = deleteRelationGroupsAsync(relations, cache, true);
+                    List<ListenableFuture<Boolean>> results = deleteRelationGroupsAsync(tenantId, relations, cache, true);
                     return Futures.allAsList(results);
                     return Futures.allAsList(results);
                 });
                 });
 
 
         ListenableFuture<List<Boolean>> outboundDeletions = Futures.transformAsync(outboundRelations,
         ListenableFuture<List<Boolean>> outboundDeletions = Futures.transformAsync(outboundRelations,
                 relations -> {
                 relations -> {
-                    List<ListenableFuture<Boolean>> results = deleteRelationGroupsAsync(relations, cache, false);
+                    List<ListenableFuture<Boolean>> results = deleteRelationGroupsAsync(tenantId, relations, cache, false);
                     return Futures.allAsList(results);
                     return Futures.allAsList(results);
                 });
                 });
 
 
         ListenableFuture<List<List<Boolean>>> deletionsFuture = Futures.allAsList(inboundDeletions, outboundDeletions);
         ListenableFuture<List<List<Boolean>>> deletionsFuture = Futures.allAsList(inboundDeletions, outboundDeletions);
 
 
-        return Futures.transform(Futures.transformAsync(deletionsFuture, (deletions) -> relationDao.deleteOutboundRelationsAsync(entityId)), result -> null);
+        return Futures.transform(Futures.transformAsync(deletionsFuture, (deletions) -> relationDao.deleteOutboundRelationsAsync(tenantId, entityId)), result -> null);
     }
     }
 
 
-    private List<ListenableFuture<Boolean>> deleteRelationGroupsAsync(List<List<EntityRelation>> relations, Cache cache, boolean deleteFromDb) {
+    private List<ListenableFuture<Boolean>> deleteRelationGroupsAsync(TenantId tenantId, List<List<EntityRelation>> relations, Cache cache, boolean deleteFromDb) {
         List<ListenableFuture<Boolean>> results = new ArrayList<>();
         List<ListenableFuture<Boolean>> results = new ArrayList<>();
         for (List<EntityRelation> relationList : relations) {
         for (List<EntityRelation> relationList : relations) {
-            relationList.forEach(relation -> results.add(deleteAsync(cache, relation, deleteFromDb)));
+            relationList.forEach(relation -> results.add(deleteAsync(tenantId, cache, relation, deleteFromDb)));
         }
         }
         return results;
         return results;
     }
     }
 
 
-    private ListenableFuture<Boolean> deleteAsync(Cache cache, EntityRelation relation, boolean deleteFromDb) {
+    private ListenableFuture<Boolean> deleteAsync(TenantId tenantId, Cache cache, EntityRelation relation, boolean deleteFromDb) {
         cacheEviction(relation, cache);
         cacheEviction(relation, cache);
         if (deleteFromDb) {
         if (deleteFromDb) {
-            return relationDao.deleteRelationAsync(relation);
+            return relationDao.deleteRelationAsync(tenantId, relation);
         } else {
         } else {
             return Futures.immediateFuture(false);
             return Futures.immediateFuture(false);
         }
         }
@@ -272,18 +274,18 @@ public class BaseRelationService implements RelationService {
 
 
     @Cacheable(cacheNames = RELATIONS_CACHE, key = "{#from, #typeGroup, 'FROM'}")
     @Cacheable(cacheNames = RELATIONS_CACHE, key = "{#from, #typeGroup, 'FROM'}")
     @Override
     @Override
-    public List<EntityRelation> findByFrom(EntityId from, RelationTypeGroup typeGroup) {
+    public List<EntityRelation> findByFrom(TenantId tenantId, EntityId from, RelationTypeGroup typeGroup) {
         validate(from);
         validate(from);
         validateTypeGroup(typeGroup);
         validateTypeGroup(typeGroup);
         try {
         try {
-            return relationDao.findAllByFrom(from, typeGroup).get();
+            return relationDao.findAllByFrom(tenantId, from, typeGroup).get();
         } catch (InterruptedException | ExecutionException e) {
         } catch (InterruptedException | ExecutionException e) {
             throw new RuntimeException(e);
             throw new RuntimeException(e);
         }
         }
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<List<EntityRelation>> findByFromAsync(EntityId from, RelationTypeGroup typeGroup) {
+    public ListenableFuture<List<EntityRelation>> findByFromAsync(TenantId tenantId, EntityId from, RelationTypeGroup typeGroup) {
         log.trace("Executing findByFrom [{}][{}]", from, typeGroup);
         log.trace("Executing findByFrom [{}][{}]", from, typeGroup);
         validate(from);
         validate(from);
         validateTypeGroup(typeGroup);
         validateTypeGroup(typeGroup);
@@ -298,7 +300,7 @@ public class BaseRelationService implements RelationService {
         if (fromCache != null) {
         if (fromCache != null) {
             return Futures.immediateFuture(fromCache);
             return Futures.immediateFuture(fromCache);
         } else {
         } else {
-            ListenableFuture<List<EntityRelation>> relationsFuture = relationDao.findAllByFrom(from, typeGroup);
+            ListenableFuture<List<EntityRelation>> relationsFuture = relationDao.findAllByFrom(tenantId, from, typeGroup);
             Futures.addCallback(relationsFuture,
             Futures.addCallback(relationsFuture,
                     new FutureCallback<List<EntityRelation>>() {
                     new FutureCallback<List<EntityRelation>>() {
                         @Override
                         @Override
@@ -313,16 +315,16 @@ public class BaseRelationService implements RelationService {
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<List<EntityRelationInfo>> findInfoByFrom(EntityId from, RelationTypeGroup typeGroup) {
+    public ListenableFuture<List<EntityRelationInfo>> findInfoByFrom(TenantId tenantId, EntityId from, RelationTypeGroup typeGroup) {
         log.trace("Executing findInfoByFrom [{}][{}]", from, typeGroup);
         log.trace("Executing findInfoByFrom [{}][{}]", from, typeGroup);
         validate(from);
         validate(from);
         validateTypeGroup(typeGroup);
         validateTypeGroup(typeGroup);
-        ListenableFuture<List<EntityRelation>> relations = relationDao.findAllByFrom(from, typeGroup);
+        ListenableFuture<List<EntityRelation>> relations = relationDao.findAllByFrom(tenantId, from, typeGroup);
         return Futures.transformAsync(relations,
         return Futures.transformAsync(relations,
                 relations1 -> {
                 relations1 -> {
                     List<ListenableFuture<EntityRelationInfo>> futures = new ArrayList<>();
                     List<ListenableFuture<EntityRelationInfo>> futures = new ArrayList<>();
                     relations1.forEach(relation ->
                     relations1.forEach(relation ->
-                            futures.add(fetchRelationInfoAsync(relation,
+                            futures.add(fetchRelationInfoAsync(tenantId, relation,
                                     EntityRelation::getTo,
                                     EntityRelation::getTo,
                                     EntityRelationInfo::setToName))
                                     EntityRelationInfo::setToName))
                     );
                     );
@@ -332,37 +334,37 @@ public class BaseRelationService implements RelationService {
 
 
     @Cacheable(cacheNames = RELATIONS_CACHE, key = "{#from, #relationType, #typeGroup, 'FROM'}")
     @Cacheable(cacheNames = RELATIONS_CACHE, key = "{#from, #relationType, #typeGroup, 'FROM'}")
     @Override
     @Override
-    public List<EntityRelation> findByFromAndType(EntityId from, String relationType, RelationTypeGroup typeGroup) {
+    public List<EntityRelation> findByFromAndType(TenantId tenantId, EntityId from, String relationType, RelationTypeGroup typeGroup) {
         try {
         try {
-            return findByFromAndTypeAsync(from, relationType, typeGroup).get();
+            return findByFromAndTypeAsync(tenantId, from, relationType, typeGroup).get();
         } catch (InterruptedException | ExecutionException e) {
         } catch (InterruptedException | ExecutionException e) {
             throw new RuntimeException(e);
             throw new RuntimeException(e);
         }
         }
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<List<EntityRelation>> findByFromAndTypeAsync(EntityId from, String relationType, RelationTypeGroup typeGroup) {
+    public ListenableFuture<List<EntityRelation>> findByFromAndTypeAsync(TenantId tenantId, EntityId from, String relationType, RelationTypeGroup typeGroup) {
         log.trace("Executing findByFromAndType [{}][{}][{}]", from, relationType, typeGroup);
         log.trace("Executing findByFromAndType [{}][{}][{}]", from, relationType, typeGroup);
         validate(from);
         validate(from);
         validateType(relationType);
         validateType(relationType);
         validateTypeGroup(typeGroup);
         validateTypeGroup(typeGroup);
-        return relationDao.findAllByFromAndType(from, relationType, typeGroup);
+        return relationDao.findAllByFromAndType(tenantId, from, relationType, typeGroup);
     }
     }
 
 
     @Cacheable(cacheNames = RELATIONS_CACHE, key = "{#to, #typeGroup, 'TO'}")
     @Cacheable(cacheNames = RELATIONS_CACHE, key = "{#to, #typeGroup, 'TO'}")
     @Override
     @Override
-    public List<EntityRelation> findByTo(EntityId to, RelationTypeGroup typeGroup) {
+    public List<EntityRelation> findByTo(TenantId tenantId, EntityId to, RelationTypeGroup typeGroup) {
         validate(to);
         validate(to);
         validateTypeGroup(typeGroup);
         validateTypeGroup(typeGroup);
         try {
         try {
-            return relationDao.findAllByTo(to, typeGroup).get();
+            return relationDao.findAllByTo(tenantId, to, typeGroup).get();
         } catch (InterruptedException | ExecutionException e) {
         } catch (InterruptedException | ExecutionException e) {
             throw new RuntimeException(e);
             throw new RuntimeException(e);
         }
         }
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<List<EntityRelation>> findByToAsync(EntityId to, RelationTypeGroup typeGroup) {
+    public ListenableFuture<List<EntityRelation>> findByToAsync(TenantId tenantId, EntityId to, RelationTypeGroup typeGroup) {
         log.trace("Executing findByTo [{}][{}]", to, typeGroup);
         log.trace("Executing findByTo [{}][{}]", to, typeGroup);
         validate(to);
         validate(to);
         validateTypeGroup(typeGroup);
         validateTypeGroup(typeGroup);
@@ -377,7 +379,7 @@ public class BaseRelationService implements RelationService {
         if (fromCache != null) {
         if (fromCache != null) {
             return Futures.immediateFuture(fromCache);
             return Futures.immediateFuture(fromCache);
         } else {
         } else {
-            ListenableFuture<List<EntityRelation>> relationsFuture = relationDao.findAllByTo(to, typeGroup);
+            ListenableFuture<List<EntityRelation>> relationsFuture = relationDao.findAllByTo(tenantId, to, typeGroup);
             Futures.addCallback(relationsFuture,
             Futures.addCallback(relationsFuture,
                     new FutureCallback<List<EntityRelation>>() {
                     new FutureCallback<List<EntityRelation>>() {
                         @Override
                         @Override
@@ -392,16 +394,16 @@ public class BaseRelationService implements RelationService {
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<List<EntityRelationInfo>> findInfoByTo(EntityId to, RelationTypeGroup typeGroup) {
+    public ListenableFuture<List<EntityRelationInfo>> findInfoByTo(TenantId tenantId, EntityId to, RelationTypeGroup typeGroup) {
         log.trace("Executing findInfoByTo [{}][{}]", to, typeGroup);
         log.trace("Executing findInfoByTo [{}][{}]", to, typeGroup);
         validate(to);
         validate(to);
         validateTypeGroup(typeGroup);
         validateTypeGroup(typeGroup);
-        ListenableFuture<List<EntityRelation>> relations = relationDao.findAllByTo(to, typeGroup);
+        ListenableFuture<List<EntityRelation>> relations = relationDao.findAllByTo(tenantId, to, typeGroup);
         return Futures.transformAsync(relations,
         return Futures.transformAsync(relations,
                 relations1 -> {
                 relations1 -> {
                     List<ListenableFuture<EntityRelationInfo>> futures = new ArrayList<>();
                     List<ListenableFuture<EntityRelationInfo>> futures = new ArrayList<>();
                     relations1.forEach(relation ->
                     relations1.forEach(relation ->
-                            futures.add(fetchRelationInfoAsync(relation,
+                            futures.add(fetchRelationInfoAsync(tenantId, relation,
                                     EntityRelation::getFrom,
                                     EntityRelation::getFrom,
                                     EntityRelationInfo::setFromName))
                                     EntityRelationInfo::setFromName))
                     );
                     );
@@ -409,10 +411,10 @@ public class BaseRelationService implements RelationService {
                 });
                 });
     }
     }
 
 
-    private ListenableFuture<EntityRelationInfo> fetchRelationInfoAsync(EntityRelation relation,
+    private ListenableFuture<EntityRelationInfo> fetchRelationInfoAsync(TenantId tenantId, EntityRelation relation,
                                                                         Function<EntityRelation, EntityId> entityIdGetter,
                                                                         Function<EntityRelation, EntityId> entityIdGetter,
                                                                         BiConsumer<EntityRelationInfo, String> entityNameSetter) {
                                                                         BiConsumer<EntityRelationInfo, String> entityNameSetter) {
-        ListenableFuture<String> entityName = entityService.fetchEntityNameAsync(entityIdGetter.apply(relation));
+        ListenableFuture<String> entityName = entityService.fetchEntityNameAsync(tenantId, entityIdGetter.apply(relation));
         return Futures.transform(entityName, entityName1 -> {
         return Futures.transform(entityName, entityName1 -> {
             EntityRelationInfo entityRelationInfo1 = new EntityRelationInfo(relation);
             EntityRelationInfo entityRelationInfo1 = new EntityRelationInfo(relation);
             entityNameSetter.accept(entityRelationInfo1, entityName1);
             entityNameSetter.accept(entityRelationInfo1, entityName1);
@@ -422,25 +424,25 @@ public class BaseRelationService implements RelationService {
 
 
     @Cacheable(cacheNames = RELATIONS_CACHE, key = "{#to, #relationType, #typeGroup, 'TO'}")
     @Cacheable(cacheNames = RELATIONS_CACHE, key = "{#to, #relationType, #typeGroup, 'TO'}")
     @Override
     @Override
-    public List<EntityRelation> findByToAndType(EntityId to, String relationType, RelationTypeGroup typeGroup) {
+    public List<EntityRelation> findByToAndType(TenantId tenantId, EntityId to, String relationType, RelationTypeGroup typeGroup) {
         try {
         try {
-            return findByToAndTypeAsync(to, relationType, typeGroup).get();
+            return findByToAndTypeAsync(tenantId, to, relationType, typeGroup).get();
         } catch (InterruptedException | ExecutionException e) {
         } catch (InterruptedException | ExecutionException e) {
             throw new RuntimeException(e);
             throw new RuntimeException(e);
         }
         }
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<List<EntityRelation>> findByToAndTypeAsync(EntityId to, String relationType, RelationTypeGroup typeGroup) {
+    public ListenableFuture<List<EntityRelation>> findByToAndTypeAsync(TenantId tenantId, EntityId to, String relationType, RelationTypeGroup typeGroup) {
         log.trace("Executing findByToAndType [{}][{}][{}]", to, relationType, typeGroup);
         log.trace("Executing findByToAndType [{}][{}][{}]", to, relationType, typeGroup);
         validate(to);
         validate(to);
         validateType(relationType);
         validateType(relationType);
         validateTypeGroup(typeGroup);
         validateTypeGroup(typeGroup);
-        return relationDao.findAllByToAndType(to, relationType, typeGroup);
+        return relationDao.findAllByToAndType(tenantId, to, relationType, typeGroup);
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<List<EntityRelation>> findByQuery(EntityRelationsQuery query) {
+    public ListenableFuture<List<EntityRelation>> findByQuery(TenantId tenantId, EntityRelationsQuery query) {
         log.trace("Executing findByQuery [{}]", query);
         log.trace("Executing findByQuery [{}]", query);
         RelationsSearchParameters params = query.getParameters();
         RelationsSearchParameters params = query.getParameters();
         final List<EntityTypeFilter> filters = query.getFilters();
         final List<EntityTypeFilter> filters = query.getFilters();
@@ -451,7 +453,7 @@ public class BaseRelationService implements RelationService {
         int maxLvl = params.getMaxLevel() > 0 ? params.getMaxLevel() : Integer.MAX_VALUE;
         int maxLvl = params.getMaxLevel() > 0 ? params.getMaxLevel() : Integer.MAX_VALUE;
 
 
         try {
         try {
-            ListenableFuture<Set<EntityRelation>> relationSet = findRelationsRecursively(params.getEntityId(), params.getDirection(), params.getRelationTypeGroup(), maxLvl, new ConcurrentHashMap<>());
+            ListenableFuture<Set<EntityRelation>> relationSet = findRelationsRecursively(tenantId, params.getEntityId(), params.getDirection(), params.getRelationTypeGroup(), maxLvl, new ConcurrentHashMap<>());
             return Futures.transform(relationSet, input -> {
             return Futures.transform(relationSet, input -> {
                 List<EntityRelation> relations = new ArrayList<>();
                 List<EntityRelation> relations = new ArrayList<>();
                 if (filters == null || filters.isEmpty()) {
                 if (filters == null || filters.isEmpty()) {
@@ -472,15 +474,15 @@ public class BaseRelationService implements RelationService {
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<List<EntityRelationInfo>> findInfoByQuery(EntityRelationsQuery query) {
+    public ListenableFuture<List<EntityRelationInfo>> findInfoByQuery(TenantId tenantId, EntityRelationsQuery query) {
         log.trace("Executing findInfoByQuery [{}]", query);
         log.trace("Executing findInfoByQuery [{}]", query);
-        ListenableFuture<List<EntityRelation>> relations = findByQuery(query);
+        ListenableFuture<List<EntityRelation>> relations = findByQuery(tenantId, query);
         EntitySearchDirection direction = query.getParameters().getDirection();
         EntitySearchDirection direction = query.getParameters().getDirection();
         return Futures.transformAsync(relations,
         return Futures.transformAsync(relations,
                 relations1 -> {
                 relations1 -> {
                     List<ListenableFuture<EntityRelationInfo>> futures = new ArrayList<>();
                     List<ListenableFuture<EntityRelationInfo>> futures = new ArrayList<>();
                     relations1.forEach(relation ->
                     relations1.forEach(relation ->
-                            futures.add(fetchRelationInfoAsync(relation,
+                            futures.add(fetchRelationInfoAsync(tenantId, relation,
                                     relation2 -> direction == EntitySearchDirection.FROM ? relation2.getTo() : relation2.getFrom(),
                                     relation2 -> direction == EntitySearchDirection.FROM ? relation2.getTo() : relation2.getFrom(),
                                     (EntityRelationInfo relationInfo, String entityName) -> {
                                     (EntityRelationInfo relationInfo, String entityName) -> {
                                         if (direction == EntitySearchDirection.FROM) {
                                         if (direction == EntitySearchDirection.FROM) {
@@ -567,7 +569,7 @@ public class BaseRelationService implements RelationService {
         }
         }
     }
     }
 
 
-    private ListenableFuture<Set<EntityRelation>> findRelationsRecursively(final EntityId rootId, final EntitySearchDirection direction,
+    private ListenableFuture<Set<EntityRelation>> findRelationsRecursively(final TenantId tenantId, final EntityId rootId, final EntitySearchDirection direction,
                                                                            RelationTypeGroup relationTypeGroup, int lvl,
                                                                            RelationTypeGroup relationTypeGroup, int lvl,
                                                                            final ConcurrentHashMap<EntityId, Boolean> uniqueMap) throws Exception {
                                                                            final ConcurrentHashMap<EntityId, Boolean> uniqueMap) throws Exception {
         if (lvl == 0) {
         if (lvl == 0) {
@@ -575,7 +577,7 @@ public class BaseRelationService implements RelationService {
         }
         }
         lvl--;
         lvl--;
         //TODO: try to remove this blocking operation
         //TODO: try to remove this blocking operation
-        Set<EntityRelation> children = new HashSet<>(findRelations(rootId, direction, relationTypeGroup).get());
+        Set<EntityRelation> children = new HashSet<>(findRelations(tenantId, rootId, direction, relationTypeGroup).get());
         Set<EntityId> childrenIds = new HashSet<>();
         Set<EntityId> childrenIds = new HashSet<>();
         for (EntityRelation childRelation : children) {
         for (EntityRelation childRelation : children) {
             log.trace("Found Relation: {}", childRelation);
             log.trace("Found Relation: {}", childRelation);
@@ -594,7 +596,7 @@ public class BaseRelationService implements RelationService {
         }
         }
         List<ListenableFuture<Set<EntityRelation>>> futures = new ArrayList<>();
         List<ListenableFuture<Set<EntityRelation>>> futures = new ArrayList<>();
         for (EntityId entityId : childrenIds) {
         for (EntityId entityId : childrenIds) {
-            futures.add(findRelationsRecursively(entityId, direction, relationTypeGroup, lvl, uniqueMap));
+            futures.add(findRelationsRecursively(tenantId, entityId, direction, relationTypeGroup, lvl, uniqueMap));
         }
         }
         //TODO: try to remove this blocking operation
         //TODO: try to remove this blocking operation
         List<Set<EntityRelation>> relations = Futures.successfulAsList(futures).get();
         List<Set<EntityRelation>> relations = Futures.successfulAsList(futures).get();
@@ -602,15 +604,15 @@ public class BaseRelationService implements RelationService {
         return Futures.immediateFuture(children);
         return Futures.immediateFuture(children);
     }
     }
 
 
-    private ListenableFuture<List<EntityRelation>> findRelations(final EntityId rootId, final EntitySearchDirection direction, RelationTypeGroup relationTypeGroup) {
+    private ListenableFuture<List<EntityRelation>> findRelations(final TenantId tenantId, final EntityId rootId, final EntitySearchDirection direction, RelationTypeGroup relationTypeGroup) {
         ListenableFuture<List<EntityRelation>> relations;
         ListenableFuture<List<EntityRelation>> relations;
         if (relationTypeGroup == null) {
         if (relationTypeGroup == null) {
             relationTypeGroup = RelationTypeGroup.COMMON;
             relationTypeGroup = RelationTypeGroup.COMMON;
         }
         }
         if (direction == EntitySearchDirection.FROM) {
         if (direction == EntitySearchDirection.FROM) {
-            relations = findByFromAsync(rootId, relationTypeGroup);
+            relations = findByFromAsync(tenantId, rootId, relationTypeGroup);
         } else {
         } else {
-            relations = findByToAsync(rootId, relationTypeGroup);
+            relations = findByToAsync(tenantId, rootId, relationTypeGroup);
         }
         }
         return relations;
         return relations;
     }
     }

@@ -18,6 +18,7 @@ package org.thingsboard.server.dao.relation;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListenableFuture;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.TimePageLink;
 import org.thingsboard.server.common.data.page.TimePageLink;
 import org.thingsboard.server.common.data.relation.EntityRelation;
 import org.thingsboard.server.common.data.relation.EntityRelation;
 import org.thingsboard.server.common.data.relation.RelationTypeGroup;
 import org.thingsboard.server.common.data.relation.RelationTypeGroup;
@@ -29,34 +30,34 @@ import java.util.List;
  */
  */
 public interface RelationDao {
 public interface RelationDao {
 
 
-    ListenableFuture<List<EntityRelation>> findAllByFrom(EntityId from, RelationTypeGroup typeGroup);
+    ListenableFuture<List<EntityRelation>> findAllByFrom(TenantId tenantId, EntityId from, RelationTypeGroup typeGroup);
 
 
-    ListenableFuture<List<EntityRelation>> findAllByFromAndType(EntityId from, String relationType, RelationTypeGroup typeGroup);
+    ListenableFuture<List<EntityRelation>> findAllByFromAndType(TenantId tenantId, EntityId from, String relationType, RelationTypeGroup typeGroup);
 
 
-    ListenableFuture<List<EntityRelation>> findAllByTo(EntityId to, RelationTypeGroup typeGroup);
+    ListenableFuture<List<EntityRelation>> findAllByTo(TenantId tenantId, EntityId to, RelationTypeGroup typeGroup);
 
 
-    ListenableFuture<List<EntityRelation>> findAllByToAndType(EntityId to, String relationType, RelationTypeGroup typeGroup);
+    ListenableFuture<List<EntityRelation>> findAllByToAndType(TenantId tenantId, EntityId to, String relationType, RelationTypeGroup typeGroup);
 
 
-    ListenableFuture<Boolean> checkRelation(EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup);
+    ListenableFuture<Boolean> checkRelation(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup);
 
 
-    ListenableFuture<EntityRelation> getRelation(EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup);
+    ListenableFuture<EntityRelation> getRelation(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup);
 
 
-    boolean saveRelation(EntityRelation relation);
+    boolean saveRelation(TenantId tenantId, EntityRelation relation);
 
 
-    ListenableFuture<Boolean> saveRelationAsync(EntityRelation relation);
+    ListenableFuture<Boolean> saveRelationAsync(TenantId tenantId, EntityRelation relation);
 
 
-    boolean deleteRelation(EntityRelation relation);
+    boolean deleteRelation(TenantId tenantId, EntityRelation relation);
 
 
-    ListenableFuture<Boolean> deleteRelationAsync(EntityRelation relation);
+    ListenableFuture<Boolean> deleteRelationAsync(TenantId tenantId, EntityRelation relation);
 
 
-    boolean deleteRelation(EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup);
+    boolean deleteRelation(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup);
 
 
-    ListenableFuture<Boolean> deleteRelationAsync(EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup);
+    ListenableFuture<Boolean> deleteRelationAsync(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup);
 
 
-    boolean deleteOutboundRelations(EntityId entity);
+    boolean deleteOutboundRelations(TenantId tenantId, EntityId entity);
 
 
-    ListenableFuture<Boolean> deleteOutboundRelationsAsync(EntityId entity);
+    ListenableFuture<Boolean> deleteOutboundRelationsAsync(TenantId tenantId, EntityId entity);
 
 
-    ListenableFuture<List<EntityRelation>> findRelations(EntityId from, String relationType, RelationTypeGroup typeGroup, EntityType toType, TimePageLink pageLink);
+    ListenableFuture<List<EntityRelation>> findRelations(TenantId tenantId, EntityId from, String relationType, RelationTypeGroup typeGroup, EntityType toType, TimePageLink pageLink);
 
 
 }
 }

@@ -17,6 +17,7 @@ package org.thingsboard.server.dao.relation;
 
 
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListenableFuture;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.relation.EntityRelation;
 import org.thingsboard.server.common.data.relation.EntityRelation;
 import org.thingsboard.server.common.data.relation.EntityRelationInfo;
 import org.thingsboard.server.common.data.relation.EntityRelationInfo;
 import org.thingsboard.server.common.data.relation.EntityRelationsQuery;
 import org.thingsboard.server.common.data.relation.EntityRelationsQuery;
@@ -30,51 +31,51 @@ import java.util.concurrent.ExecutionException;
  */
  */
 public interface RelationService {
 public interface RelationService {
 
 
-    ListenableFuture<Boolean> checkRelation(EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup);
+    ListenableFuture<Boolean> checkRelation(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup);
 
 
-    EntityRelation getRelation(EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup);
+    EntityRelation getRelation(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup);
 
 
-    ListenableFuture<EntityRelation> getRelationAsync(EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup);
+    ListenableFuture<EntityRelation> getRelationAsync(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup);
 
 
-    boolean saveRelation(EntityRelation relation);
+    boolean saveRelation(TenantId tenantId, EntityRelation relation);
 
 
-    ListenableFuture<Boolean> saveRelationAsync(EntityRelation relation);
+    ListenableFuture<Boolean> saveRelationAsync(TenantId tenantId, EntityRelation relation);
 
 
-    boolean deleteRelation(EntityRelation relation);
+    boolean deleteRelation(TenantId tenantId, EntityRelation relation);
 
 
-    ListenableFuture<Boolean> deleteRelationAsync(EntityRelation relation);
+    ListenableFuture<Boolean> deleteRelationAsync(TenantId tenantId, EntityRelation relation);
 
 
-    boolean deleteRelation(EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup);
+    boolean deleteRelation(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup);
 
 
-    ListenableFuture<Boolean> deleteRelationAsync(EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup);
+    ListenableFuture<Boolean> deleteRelationAsync(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup);
 
 
-    void deleteEntityRelations(EntityId entity);
+    void deleteEntityRelations(TenantId tenantId, EntityId entity);
 
 
-    ListenableFuture<Void> deleteEntityRelationsAsync(EntityId entity);
+    ListenableFuture<Void> deleteEntityRelationsAsync(TenantId tenantId, EntityId entity);
 
 
-    List<EntityRelation> findByFrom(EntityId from, RelationTypeGroup typeGroup);
+    List<EntityRelation> findByFrom(TenantId tenantId, EntityId from, RelationTypeGroup typeGroup);
 
 
-    ListenableFuture<List<EntityRelation>> findByFromAsync(EntityId from, RelationTypeGroup typeGroup);
+    ListenableFuture<List<EntityRelation>> findByFromAsync(TenantId tenantId, EntityId from, RelationTypeGroup typeGroup);
 
 
-    ListenableFuture<List<EntityRelationInfo>> findInfoByFrom(EntityId from, RelationTypeGroup typeGroup);
+    ListenableFuture<List<EntityRelationInfo>> findInfoByFrom(TenantId tenantId, EntityId from, RelationTypeGroup typeGroup);
 
 
-    List<EntityRelation> findByFromAndType(EntityId from, String relationType, RelationTypeGroup typeGroup);
+    List<EntityRelation> findByFromAndType(TenantId tenantId, EntityId from, String relationType, RelationTypeGroup typeGroup);
 
 
-    ListenableFuture<List<EntityRelation>> findByFromAndTypeAsync(EntityId from, String relationType, RelationTypeGroup typeGroup);
+    ListenableFuture<List<EntityRelation>> findByFromAndTypeAsync(TenantId tenantId, EntityId from, String relationType, RelationTypeGroup typeGroup);
 
 
-    List<EntityRelation> findByTo(EntityId to, RelationTypeGroup typeGroup);
+    List<EntityRelation> findByTo(TenantId tenantId, EntityId to, RelationTypeGroup typeGroup);
 
 
-    ListenableFuture<List<EntityRelation>> findByToAsync(EntityId to, RelationTypeGroup typeGroup);
+    ListenableFuture<List<EntityRelation>> findByToAsync(TenantId tenantId, EntityId to, RelationTypeGroup typeGroup);
 
 
-    ListenableFuture<List<EntityRelationInfo>> findInfoByTo(EntityId to, RelationTypeGroup typeGroup);
+    ListenableFuture<List<EntityRelationInfo>> findInfoByTo(TenantId tenantId, EntityId to, RelationTypeGroup typeGroup);
 
 
-    List<EntityRelation> findByToAndType(EntityId to, String relationType, RelationTypeGroup typeGroup);
+    List<EntityRelation> findByToAndType(TenantId tenantId, EntityId to, String relationType, RelationTypeGroup typeGroup);
 
 
-    ListenableFuture<List<EntityRelation>> findByToAndTypeAsync(EntityId to, String relationType, RelationTypeGroup typeGroup);
+    ListenableFuture<List<EntityRelation>> findByToAndTypeAsync(TenantId tenantId, EntityId to, String relationType, RelationTypeGroup typeGroup);
 
 
-    ListenableFuture<List<EntityRelation>> findByQuery(EntityRelationsQuery query);
+    ListenableFuture<List<EntityRelation>> findByQuery(TenantId tenantId, EntityRelationsQuery query);
 
 
-    ListenableFuture<List<EntityRelationInfo>> findInfoByQuery(EntityRelationsQuery query);
+    ListenableFuture<List<EntityRelationInfo>> findInfoByQuery(TenantId tenantId, EntityRelationsQuery query);
 
 
 //    TODO: This method may be useful for some validations in the future
 //    TODO: This method may be useful for some validations in the future
 //    ListenableFuture<Boolean> checkRecursiveRelation(EntityId from, EntityId to);
 //    ListenableFuture<Boolean> checkRecursiveRelation(EntityId from, EntityId to);

@@ -67,11 +67,11 @@ public class BaseRuleChainService extends AbstractEntityService implements RuleC
 
 
     @Override
     @Override
     public RuleChain saveRuleChain(RuleChain ruleChain) {
     public RuleChain saveRuleChain(RuleChain ruleChain) {
-        ruleChainValidator.validate(ruleChain);
-        RuleChain savedRuleChain = ruleChainDao.save(ruleChain);
+        ruleChainValidator.validate(ruleChain, RuleChain::getTenantId);
+        RuleChain savedRuleChain = ruleChainDao.save(ruleChain.getTenantId(), ruleChain);
         if (ruleChain.isRoot() && ruleChain.getId() == null) {
         if (ruleChain.isRoot() && ruleChain.getId() == null) {
             try {
             try {
-                createRelation(new EntityRelation(savedRuleChain.getTenantId(), savedRuleChain.getId(),
+                createRelation(ruleChain.getTenantId(), new EntityRelation(savedRuleChain.getTenantId(), savedRuleChain.getId(),
                         EntityRelation.CONTAINS_TYPE, RelationTypeGroup.RULE_CHAIN));
                         EntityRelation.CONTAINS_TYPE, RelationTypeGroup.RULE_CHAIN));
             } catch (ExecutionException | InterruptedException e) {
             } catch (ExecutionException | InterruptedException e) {
                 log.warn("[{}] Failed to create tenant to root rule chain relation. from: [{}], to: [{}]",
                 log.warn("[{}] Failed to create tenant to root rule chain relation. from: [{}], to: [{}]",
@@ -83,20 +83,20 @@ public class BaseRuleChainService extends AbstractEntityService implements RuleC
     }
     }
 
 
     @Override
     @Override
-    public boolean setRootRuleChain(RuleChainId ruleChainId) {
-        RuleChain ruleChain = ruleChainDao.findById(ruleChainId.getId());
+    public boolean setRootRuleChain(TenantId tenantId, RuleChainId ruleChainId) {
+        RuleChain ruleChain = ruleChainDao.findById(tenantId, ruleChainId.getId());
         if (!ruleChain.isRoot()) {
         if (!ruleChain.isRoot()) {
             RuleChain previousRootRuleChain = getRootTenantRuleChain(ruleChain.getTenantId());
             RuleChain previousRootRuleChain = getRootTenantRuleChain(ruleChain.getTenantId());
             if (!previousRootRuleChain.getId().equals(ruleChain.getId())) {
             if (!previousRootRuleChain.getId().equals(ruleChain.getId())) {
                 try {
                 try {
-                    deleteRelation(new EntityRelation(previousRootRuleChain.getTenantId(), previousRootRuleChain.getId(),
+                    deleteRelation(tenantId, new EntityRelation(previousRootRuleChain.getTenantId(), previousRootRuleChain.getId(),
                             EntityRelation.CONTAINS_TYPE, RelationTypeGroup.RULE_CHAIN));
                             EntityRelation.CONTAINS_TYPE, RelationTypeGroup.RULE_CHAIN));
                     previousRootRuleChain.setRoot(false);
                     previousRootRuleChain.setRoot(false);
-                    ruleChainDao.save(previousRootRuleChain);
-                    createRelation(new EntityRelation(ruleChain.getTenantId(), ruleChain.getId(),
+                    ruleChainDao.save(tenantId, previousRootRuleChain);
+                    createRelation(tenantId, new EntityRelation(ruleChain.getTenantId(), ruleChain.getId(),
                             EntityRelation.CONTAINS_TYPE, RelationTypeGroup.RULE_CHAIN));
                             EntityRelation.CONTAINS_TYPE, RelationTypeGroup.RULE_CHAIN));
                     ruleChain.setRoot(true);
                     ruleChain.setRoot(true);
-                    ruleChainDao.save(ruleChain);
+                    ruleChainDao.save(tenantId, ruleChain);
                     return true;
                     return true;
                 } catch (ExecutionException | InterruptedException e) {
                 } catch (ExecutionException | InterruptedException e) {
                     log.warn("[{}] Failed to set root rule chain, ruleChainId: [{}]", ruleChainId);
                     log.warn("[{}] Failed to set root rule chain, ruleChainId: [{}]", ruleChainId);
@@ -108,9 +108,9 @@ public class BaseRuleChainService extends AbstractEntityService implements RuleC
     }
     }
 
 
     @Override
     @Override
-    public RuleChainMetaData saveRuleChainMetaData(RuleChainMetaData ruleChainMetaData) {
+    public RuleChainMetaData saveRuleChainMetaData(TenantId tenantId, RuleChainMetaData ruleChainMetaData) {
         Validator.validateId(ruleChainMetaData.getRuleChainId(), "Incorrect rule chain id.");
         Validator.validateId(ruleChainMetaData.getRuleChainId(), "Incorrect rule chain id.");
-        RuleChain ruleChain = findRuleChainById(ruleChainMetaData.getRuleChainId());
+        RuleChain ruleChain = findRuleChainById(tenantId, ruleChainMetaData.getRuleChainId());
         if (ruleChain == null) {
         if (ruleChain == null) {
             return null;
             return null;
         }
         }
@@ -130,9 +130,9 @@ public class BaseRuleChainService extends AbstractEntityService implements RuleC
             }
             }
         }
         }
 
 
-        List<RuleNode> existingRuleNodes = getRuleChainNodes(ruleChainMetaData.getRuleChainId());
+        List<RuleNode> existingRuleNodes = getRuleChainNodes(tenantId, ruleChainMetaData.getRuleChainId());
         for (RuleNode existingNode : existingRuleNodes) {
         for (RuleNode existingNode : existingRuleNodes) {
-            deleteEntityRelations(existingNode.getId());
+            deleteEntityRelations(tenantId, existingNode.getId());
             Integer index = ruleNodeIndexMap.get(existingNode.getId());
             Integer index = ruleNodeIndexMap.get(existingNode.getId());
             if (index != null) {
             if (index != null) {
                 toAddOrUpdate.add(ruleChainMetaData.getNodes().get(index));
                 toAddOrUpdate.add(ruleChainMetaData.getNodes().get(index));
@@ -142,9 +142,9 @@ public class BaseRuleChainService extends AbstractEntityService implements RuleC
         }
         }
         for (RuleNode node : toAddOrUpdate) {
         for (RuleNode node : toAddOrUpdate) {
             node.setRuleChainId(ruleChain.getId());
             node.setRuleChainId(ruleChain.getId());
-            RuleNode savedNode = ruleNodeDao.save(node);
+            RuleNode savedNode = ruleNodeDao.save(tenantId, node);
             try {
             try {
-                createRelation(new EntityRelation(ruleChainMetaData.getRuleChainId(), savedNode.getId(),
+                createRelation(tenantId, new EntityRelation(ruleChainMetaData.getRuleChainId(), savedNode.getId(),
                         EntityRelation.CONTAINS_TYPE, RelationTypeGroup.RULE_CHAIN));
                         EntityRelation.CONTAINS_TYPE, RelationTypeGroup.RULE_CHAIN));
             } catch (ExecutionException | InterruptedException e) {
             } catch (ExecutionException | InterruptedException e) {
                 log.warn("[{}] Failed to create rule chain to rule node relation. from: [{}], to: [{}]",
                 log.warn("[{}] Failed to create rule chain to rule node relation. from: [{}], to: [{}]",
@@ -156,7 +156,7 @@ public class BaseRuleChainService extends AbstractEntityService implements RuleC
             ruleNodeIndexMap.put(savedNode.getId(), index);
             ruleNodeIndexMap.put(savedNode.getId(), index);
         }
         }
         for (RuleNode node : toDelete) {
         for (RuleNode node : toDelete) {
-            deleteRuleNode(node.getId());
+            deleteRuleNode(tenantId, node.getId());
         }
         }
         RuleNodeId firstRuleNodeId = null;
         RuleNodeId firstRuleNodeId = null;
         if (ruleChainMetaData.getFirstNodeIndex() != null) {
         if (ruleChainMetaData.getFirstNodeIndex() != null) {
@@ -165,7 +165,7 @@ public class BaseRuleChainService extends AbstractEntityService implements RuleC
         if ((ruleChain.getFirstRuleNodeId() != null && !ruleChain.getFirstRuleNodeId().equals(firstRuleNodeId))
         if ((ruleChain.getFirstRuleNodeId() != null && !ruleChain.getFirstRuleNodeId().equals(firstRuleNodeId))
                 || (ruleChain.getFirstRuleNodeId() == null && firstRuleNodeId != null)) {
                 || (ruleChain.getFirstRuleNodeId() == null && firstRuleNodeId != null)) {
             ruleChain.setFirstRuleNodeId(firstRuleNodeId);
             ruleChain.setFirstRuleNodeId(firstRuleNodeId);
-            ruleChainDao.save(ruleChain);
+            ruleChainDao.save(tenantId, ruleChain);
         }
         }
         if (ruleChainMetaData.getConnections() != null) {
         if (ruleChainMetaData.getConnections() != null) {
             for (NodeConnectionInfo nodeConnection : ruleChainMetaData.getConnections()) {
             for (NodeConnectionInfo nodeConnection : ruleChainMetaData.getConnections()) {
@@ -173,7 +173,7 @@ public class BaseRuleChainService extends AbstractEntityService implements RuleC
                 EntityId to = nodes.get(nodeConnection.getToIndex()).getId();
                 EntityId to = nodes.get(nodeConnection.getToIndex()).getId();
                 String type = nodeConnection.getType();
                 String type = nodeConnection.getType();
                 try {
                 try {
-                    createRelation(new EntityRelation(from, to, type, RelationTypeGroup.RULE_NODE));
+                    createRelation(tenantId, new EntityRelation(from, to, type, RelationTypeGroup.RULE_NODE));
                 } catch (ExecutionException | InterruptedException e) {
                 } catch (ExecutionException | InterruptedException e) {
                     log.warn("[{}] Failed to create rule node relation. from: [{}], to: [{}]", from, to);
                     log.warn("[{}] Failed to create rule node relation. from: [{}], to: [{}]", from, to);
                     throw new RuntimeException(e);
                     throw new RuntimeException(e);
@@ -186,7 +186,7 @@ public class BaseRuleChainService extends AbstractEntityService implements RuleC
                 EntityId to = nodeToRuleChainConnection.getTargetRuleChainId();
                 EntityId to = nodeToRuleChainConnection.getTargetRuleChainId();
                 String type = nodeToRuleChainConnection.getType();
                 String type = nodeToRuleChainConnection.getType();
                 try {
                 try {
-                    createRelation(new EntityRelation(from, to, type, RelationTypeGroup.RULE_NODE, nodeToRuleChainConnection.getAdditionalInfo()));
+                    createRelation(tenantId, new EntityRelation(from, to, type, RelationTypeGroup.RULE_NODE, nodeToRuleChainConnection.getAdditionalInfo()));
                 } catch (ExecutionException | InterruptedException e) {
                 } catch (ExecutionException | InterruptedException e) {
                     log.warn("[{}] Failed to create rule node to rule chain relation. from: [{}], to: [{}]", from, to);
                     log.warn("[{}] Failed to create rule node to rule chain relation. from: [{}], to: [{}]", from, to);
                     throw new RuntimeException(e);
                     throw new RuntimeException(e);
@@ -194,19 +194,19 @@ public class BaseRuleChainService extends AbstractEntityService implements RuleC
             }
             }
         }
         }
 
 
-        return loadRuleChainMetaData(ruleChainMetaData.getRuleChainId());
+        return loadRuleChainMetaData(tenantId, ruleChainMetaData.getRuleChainId());
     }
     }
 
 
     @Override
     @Override
-    public RuleChainMetaData loadRuleChainMetaData(RuleChainId ruleChainId) {
+    public RuleChainMetaData loadRuleChainMetaData(TenantId tenantId, RuleChainId ruleChainId) {
         Validator.validateId(ruleChainId, "Incorrect rule chain id.");
         Validator.validateId(ruleChainId, "Incorrect rule chain id.");
-        RuleChain ruleChain = findRuleChainById(ruleChainId);
+        RuleChain ruleChain = findRuleChainById(tenantId, ruleChainId);
         if (ruleChain == null) {
         if (ruleChain == null) {
             return null;
             return null;
         }
         }
         RuleChainMetaData ruleChainMetaData = new RuleChainMetaData();
         RuleChainMetaData ruleChainMetaData = new RuleChainMetaData();
         ruleChainMetaData.setRuleChainId(ruleChainId);
         ruleChainMetaData.setRuleChainId(ruleChainId);
-        List<RuleNode> ruleNodes = getRuleChainNodes(ruleChainId);
+        List<RuleNode> ruleNodes = getRuleChainNodes(tenantId, ruleChainId);
         Map<RuleNodeId, Integer> ruleNodeIndexMap = new HashMap<>();
         Map<RuleNodeId, Integer> ruleNodeIndexMap = new HashMap<>();
         for (RuleNode node : ruleNodes) {
         for (RuleNode node : ruleNodes) {
             ruleNodeIndexMap.put(node.getId(), ruleNodes.indexOf(node));
             ruleNodeIndexMap.put(node.getId(), ruleNodes.indexOf(node));
@@ -217,7 +217,7 @@ public class BaseRuleChainService extends AbstractEntityService implements RuleC
         }
         }
         for (RuleNode node : ruleNodes) {
         for (RuleNode node : ruleNodes) {
             int fromIndex = ruleNodeIndexMap.get(node.getId());
             int fromIndex = ruleNodeIndexMap.get(node.getId());
-            List<EntityRelation> nodeRelations = getRuleNodeRelations(node.getId());
+            List<EntityRelation> nodeRelations = getRuleNodeRelations(tenantId, node.getId());
             for (EntityRelation nodeRelation : nodeRelations) {
             for (EntityRelation nodeRelation : nodeRelations) {
                 String type = nodeRelation.getType();
                 String type = nodeRelation.getType();
                 if (nodeRelation.getTo().getEntityType() == EntityType.RULE_NODE) {
                 if (nodeRelation.getTo().getEntityType() == EntityType.RULE_NODE) {
@@ -234,54 +234,54 @@ public class BaseRuleChainService extends AbstractEntityService implements RuleC
     }
     }
 
 
     @Override
     @Override
-    public RuleChain findRuleChainById(RuleChainId ruleChainId) {
+    public RuleChain findRuleChainById(TenantId tenantId, RuleChainId ruleChainId) {
         Validator.validateId(ruleChainId, "Incorrect rule chain id for search request.");
         Validator.validateId(ruleChainId, "Incorrect rule chain id for search request.");
-        return ruleChainDao.findById(ruleChainId.getId());
+        return ruleChainDao.findById(tenantId, ruleChainId.getId());
     }
     }
 
 
     @Override
     @Override
-    public RuleNode findRuleNodeById(RuleNodeId ruleNodeId) {
+    public RuleNode findRuleNodeById(TenantId tenantId, RuleNodeId ruleNodeId) {
         Validator.validateId(ruleNodeId, "Incorrect rule node id for search request.");
         Validator.validateId(ruleNodeId, "Incorrect rule node id for search request.");
-        return ruleNodeDao.findById(ruleNodeId.getId());
+        return ruleNodeDao.findById(tenantId, ruleNodeId.getId());
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<RuleChain> findRuleChainByIdAsync(RuleChainId ruleChainId) {
+    public ListenableFuture<RuleChain> findRuleChainByIdAsync(TenantId tenantId, RuleChainId ruleChainId) {
         Validator.validateId(ruleChainId, "Incorrect rule chain id for search request.");
         Validator.validateId(ruleChainId, "Incorrect rule chain id for search request.");
-        return ruleChainDao.findByIdAsync(ruleChainId.getId());
+        return ruleChainDao.findByIdAsync(tenantId, ruleChainId.getId());
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<RuleNode> findRuleNodeByIdAsync(RuleNodeId ruleNodeId) {
+    public ListenableFuture<RuleNode> findRuleNodeByIdAsync(TenantId tenantId, RuleNodeId ruleNodeId) {
         Validator.validateId(ruleNodeId, "Incorrect rule node id for search request.");
         Validator.validateId(ruleNodeId, "Incorrect rule node id for search request.");
-        return ruleNodeDao.findByIdAsync(ruleNodeId.getId());
+        return ruleNodeDao.findByIdAsync(tenantId, ruleNodeId.getId());
     }
     }
 
 
     @Override
     @Override
     public RuleChain getRootTenantRuleChain(TenantId tenantId) {
     public RuleChain getRootTenantRuleChain(TenantId tenantId) {
         Validator.validateId(tenantId, "Incorrect tenant id for search request.");
         Validator.validateId(tenantId, "Incorrect tenant id for search request.");
-        List<EntityRelation> relations = relationService.findByFrom(tenantId, RelationTypeGroup.RULE_CHAIN);
+        List<EntityRelation> relations = relationService.findByFrom(tenantId, tenantId, RelationTypeGroup.RULE_CHAIN);
         if (relations != null && !relations.isEmpty()) {
         if (relations != null && !relations.isEmpty()) {
             EntityRelation relation = relations.get(0);
             EntityRelation relation = relations.get(0);
             RuleChainId ruleChainId = new RuleChainId(relation.getTo().getId());
             RuleChainId ruleChainId = new RuleChainId(relation.getTo().getId());
-            return findRuleChainById(ruleChainId);
+            return findRuleChainById(tenantId, ruleChainId);
         } else {
         } else {
             return null;
             return null;
         }
         }
     }
     }
 
 
     @Override
     @Override
-    public List<RuleNode> getRuleChainNodes(RuleChainId ruleChainId) {
+    public List<RuleNode> getRuleChainNodes(TenantId tenantId, RuleChainId ruleChainId) {
         Validator.validateId(ruleChainId, "Incorrect rule chain id for search request.");
         Validator.validateId(ruleChainId, "Incorrect rule chain id for search request.");
-        List<EntityRelation> relations = getRuleChainToNodeRelations(ruleChainId);
-        List<RuleNode> ruleNodes = relations.stream().map(relation -> ruleNodeDao.findById(relation.getTo().getId())).collect(Collectors.toList());
+        List<EntityRelation> relations = getRuleChainToNodeRelations(tenantId, ruleChainId);
+        List<RuleNode> ruleNodes = relations.stream().map(relation -> ruleNodeDao.findById(tenantId, relation.getTo().getId())).collect(Collectors.toList());
         return ruleNodes;
         return ruleNodes;
     }
     }
 
 
     @Override
     @Override
-    public List<EntityRelation> getRuleNodeRelations(RuleNodeId ruleNodeId) {
+    public List<EntityRelation> getRuleNodeRelations(TenantId tenantId, RuleNodeId ruleNodeId) {
         Validator.validateId(ruleNodeId, "Incorrect rule node id for search request.");
         Validator.validateId(ruleNodeId, "Incorrect rule node id for search request.");
-        return relationService.findByFrom(ruleNodeId, RelationTypeGroup.RULE_NODE);
+        return relationService.findByFrom(tenantId, ruleNodeId, RelationTypeGroup.RULE_NODE);
     }
     }
 
 
     @Override
     @Override
@@ -293,60 +293,60 @@ public class BaseRuleChainService extends AbstractEntityService implements RuleC
     }
     }
 
 
     @Override
     @Override
-    public void deleteRuleChainById(RuleChainId ruleChainId) {
+    public void deleteRuleChainById(TenantId tenantId, RuleChainId ruleChainId) {
         Validator.validateId(ruleChainId, "Incorrect rule chain id for delete request.");
         Validator.validateId(ruleChainId, "Incorrect rule chain id for delete request.");
-        RuleChain ruleChain = ruleChainDao.findById(ruleChainId.getId());
+        RuleChain ruleChain = ruleChainDao.findById(tenantId, ruleChainId.getId());
         if (ruleChain != null && ruleChain.isRoot()) {
         if (ruleChain != null && ruleChain.isRoot()) {
             throw new DataValidationException("Deletion of Root Tenant Rule Chain is prohibited!");
             throw new DataValidationException("Deletion of Root Tenant Rule Chain is prohibited!");
         }
         }
-        checkRuleNodesAndDelete(ruleChainId);
+        checkRuleNodesAndDelete(tenantId, ruleChainId);
     }
     }
 
 
     @Override
     @Override
     public void deleteRuleChainsByTenantId(TenantId tenantId) {
     public void deleteRuleChainsByTenantId(TenantId tenantId) {
         Validator.validateId(tenantId, "Incorrect tenant id for delete rule chains request.");
         Validator.validateId(tenantId, "Incorrect tenant id for delete rule chains request.");
-        tenantRuleChainsRemover.removeEntities(tenantId);
+        tenantRuleChainsRemover.removeEntities(tenantId, tenantId);
     }
     }
 
 
-    private void checkRuleNodesAndDelete(RuleChainId ruleChainId) {
-        List<EntityRelation> nodeRelations = getRuleChainToNodeRelations(ruleChainId);
+    private void checkRuleNodesAndDelete(TenantId tenantId, RuleChainId ruleChainId) {
+        List<EntityRelation> nodeRelations = getRuleChainToNodeRelations(tenantId, ruleChainId);
         for (EntityRelation relation : nodeRelations) {
         for (EntityRelation relation : nodeRelations) {
-            deleteRuleNode(relation.getTo());
+            deleteRuleNode(tenantId, relation.getTo());
         }
         }
-        deleteEntityRelations(ruleChainId);
-        ruleChainDao.removeById(ruleChainId.getId());
+        deleteEntityRelations(tenantId, ruleChainId);
+        ruleChainDao.removeById(tenantId, ruleChainId.getId());
     }
     }
 
 
-    private List<EntityRelation> getRuleChainToNodeRelations(RuleChainId ruleChainId) {
-        return relationService.findByFrom(ruleChainId, RelationTypeGroup.RULE_CHAIN);
+    private List<EntityRelation> getRuleChainToNodeRelations(TenantId tenantId, RuleChainId ruleChainId) {
+        return relationService.findByFrom(tenantId, ruleChainId, RelationTypeGroup.RULE_CHAIN);
     }
     }
 
 
-    private void deleteRuleNode(EntityId entityId) {
-        deleteEntityRelations(entityId);
-        ruleNodeDao.removeById(entityId.getId());
+    private void deleteRuleNode(TenantId tenantId, EntityId entityId) {
+        deleteEntityRelations(tenantId, entityId);
+        ruleNodeDao.removeById(tenantId, entityId.getId());
     }
     }
 
 
-    private void createRelation(EntityRelation relation) throws ExecutionException, InterruptedException {
+    private void createRelation(TenantId tenantId, EntityRelation relation) throws ExecutionException, InterruptedException {
         log.debug("Creating relation: {}", relation);
         log.debug("Creating relation: {}", relation);
-        relationService.saveRelation(relation);
+        relationService.saveRelation(tenantId, relation);
     }
     }
 
 
-    private void deleteRelation(EntityRelation relation) throws ExecutionException, InterruptedException {
+    private void deleteRelation(TenantId tenantId, EntityRelation relation) throws ExecutionException, InterruptedException {
         log.debug("Deleting relation: {}", relation);
         log.debug("Deleting relation: {}", relation);
-        relationService.deleteRelation(relation);
+        relationService.deleteRelation(tenantId, relation);
     }
     }
 
 
     private DataValidator<RuleChain> ruleChainValidator =
     private DataValidator<RuleChain> ruleChainValidator =
             new DataValidator<RuleChain>() {
             new DataValidator<RuleChain>() {
                 @Override
                 @Override
-                protected void validateDataImpl(RuleChain ruleChain) {
+                protected void validateDataImpl(TenantId tenantId, RuleChain ruleChain) {
                     if (StringUtils.isEmpty(ruleChain.getName())) {
                     if (StringUtils.isEmpty(ruleChain.getName())) {
                         throw new DataValidationException("Rule chain name should be specified!.");
                         throw new DataValidationException("Rule chain name should be specified!.");
                     }
                     }
                     if (ruleChain.getTenantId() == null || ruleChain.getTenantId().isNullUid()) {
                     if (ruleChain.getTenantId() == null || ruleChain.getTenantId().isNullUid()) {
                         throw new DataValidationException("Rule chain should be assigned to tenant!");
                         throw new DataValidationException("Rule chain should be assigned to tenant!");
                     }
                     }
-                    Tenant tenant = tenantDao.findById(ruleChain.getTenantId().getId());
+                    Tenant tenant = tenantDao.findById(tenantId, ruleChain.getTenantId().getId());
                     if (tenant == null) {
                     if (tenant == null) {
                         throw new DataValidationException("Rule chain is referencing to non-existent tenant!");
                         throw new DataValidationException("Rule chain is referencing to non-existent tenant!");
                     }
                     }
@@ -363,13 +363,13 @@ public class BaseRuleChainService extends AbstractEntityService implements RuleC
             new PaginatedRemover<TenantId, RuleChain>() {
             new PaginatedRemover<TenantId, RuleChain>() {
 
 
                 @Override
                 @Override
-                protected List<RuleChain> findEntities(TenantId id, TextPageLink pageLink) {
+                protected List<RuleChain> findEntities(TenantId tenantId, TenantId id, TextPageLink pageLink) {
                     return ruleChainDao.findRuleChainsByTenantId(id.getId(), pageLink);
                     return ruleChainDao.findRuleChainsByTenantId(id.getId(), pageLink);
                 }
                 }
 
 
                 @Override
                 @Override
-                protected void removeEntity(RuleChain entity) {
-                    checkRuleNodesAndDelete(entity.getId());
+                protected void removeEntity(TenantId tenantId, RuleChain entity) {
+                    checkRuleNodesAndDelete(tenantId, entity.getId());
                 }
                 }
             };
             };
 }
 }

@@ -17,6 +17,7 @@ package org.thingsboard.server.dao.rule;
 
 
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
 import org.springframework.stereotype.Component;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.common.data.rule.RuleChain;
 import org.thingsboard.server.common.data.rule.RuleChain;
 import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.DaoUtil;
@@ -51,7 +52,7 @@ public class CassandraRuleChainDao extends CassandraAbstractSearchTextDao<RuleCh
     @Override
     @Override
     public List<RuleChain> findRuleChainsByTenantId(UUID tenantId, TextPageLink pageLink) {
     public List<RuleChain> findRuleChainsByTenantId(UUID tenantId, TextPageLink pageLink) {
         log.debug("Try to find rule chains by tenantId [{}] and pageLink [{}]", tenantId, pageLink);
         log.debug("Try to find rule chains by tenantId [{}] and pageLink [{}]", tenantId, pageLink);
-        List<RuleChainEntity> ruleChainEntities = findPageWithTextSearch(RULE_CHAIN_BY_TENANT_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
+        List<RuleChainEntity> ruleChainEntities = findPageWithTextSearch(new TenantId(tenantId), RULE_CHAIN_BY_TENANT_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME,
                 Collections.singletonList(eq(RULE_CHAIN_TENANT_ID_PROPERTY, tenantId)),
                 Collections.singletonList(eq(RULE_CHAIN_TENANT_ID_PROPERTY, tenantId)),
                 pageLink);
                 pageLink);
 
 

@@ -36,29 +36,29 @@ public interface RuleChainService {
 
 
     RuleChain saveRuleChain(RuleChain ruleChain);
     RuleChain saveRuleChain(RuleChain ruleChain);
 
 
-    boolean setRootRuleChain(RuleChainId ruleChainId);
+    boolean setRootRuleChain(TenantId tenantId, RuleChainId ruleChainId);
 
 
-    RuleChainMetaData saveRuleChainMetaData(RuleChainMetaData ruleChainMetaData);
+    RuleChainMetaData saveRuleChainMetaData(TenantId tenantId, RuleChainMetaData ruleChainMetaData);
 
 
-    RuleChainMetaData loadRuleChainMetaData(RuleChainId ruleChainId);
+    RuleChainMetaData loadRuleChainMetaData(TenantId tenantId, RuleChainId ruleChainId);
 
 
-    RuleChain findRuleChainById(RuleChainId ruleChainId);
+    RuleChain findRuleChainById(TenantId tenantId, RuleChainId ruleChainId);
 
 
-    RuleNode findRuleNodeById(RuleNodeId ruleNodeId);
+    RuleNode findRuleNodeById(TenantId tenantId, RuleNodeId ruleNodeId);
 
 
-    ListenableFuture<RuleChain> findRuleChainByIdAsync(RuleChainId ruleChainId);
+    ListenableFuture<RuleChain> findRuleChainByIdAsync(TenantId tenantId, RuleChainId ruleChainId);
 
 
-    ListenableFuture<RuleNode> findRuleNodeByIdAsync(RuleNodeId ruleNodeId);
+    ListenableFuture<RuleNode> findRuleNodeByIdAsync(TenantId tenantId, RuleNodeId ruleNodeId);
 
 
     RuleChain getRootTenantRuleChain(TenantId tenantId);
     RuleChain getRootTenantRuleChain(TenantId tenantId);
 
 
-    List<RuleNode> getRuleChainNodes(RuleChainId ruleChainId);
+    List<RuleNode> getRuleChainNodes(TenantId tenantId, RuleChainId ruleChainId);
 
 
-    List<EntityRelation> getRuleNodeRelations(RuleNodeId ruleNodeId);
+    List<EntityRelation> getRuleNodeRelations(TenantId tenantId, RuleNodeId ruleNodeId);
 
 
     TextPageData<RuleChain> findTenantRuleChains(TenantId tenantId, TextPageLink pageLink);
     TextPageData<RuleChain> findTenantRuleChains(TenantId tenantId, TextPageLink pageLink);
 
 
-    void deleteRuleChainById(RuleChainId ruleChainId);
+    void deleteRuleChainById(TenantId tenantId, RuleChainId ruleChainId);
 
 
     void deleteRuleChainsByTenantId(TenantId tenantId);
     void deleteRuleChainsByTenantId(TenantId tenantId);
 
 

@@ -19,70 +19,73 @@ import com.fasterxml.jackson.databind.JsonNode;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.validator.routines.EmailValidator;
 import org.apache.commons.validator.routines.EmailValidator;
 import org.thingsboard.server.common.data.BaseData;
 import org.thingsboard.server.common.data.BaseData;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.dao.exception.DataValidationException;
 import org.thingsboard.server.dao.exception.DataValidationException;
 
 
 import java.util.HashSet;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Iterator;
 import java.util.Set;
 import java.util.Set;
+import java.util.function.Function;
 
 
 @Slf4j
 @Slf4j
 public abstract class DataValidator<D extends BaseData<?>> {
 public abstract class DataValidator<D extends BaseData<?>> {
 
 
     private static EmailValidator emailValidator = EmailValidator.getInstance();
     private static EmailValidator emailValidator = EmailValidator.getInstance();
-    
-    public void validate(D data) {
+
+    public void validate(D data, Function<D, TenantId> tenantIdFunction) {
         try {
         try {
             if (data == null) {
             if (data == null) {
                 throw new DataValidationException("Data object can't be null!");
                 throw new DataValidationException("Data object can't be null!");
             }
             }
-            validateDataImpl(data);
+            TenantId tenantId = tenantIdFunction.apply(data);
+            validateDataImpl(tenantId, data);
             if (data.getId() == null) {
             if (data.getId() == null) {
-                validateCreate(data);
+                validateCreate(tenantId, data);
             } else {
             } else {
-                validateUpdate(data);
+                validateUpdate(tenantId, data);
             }
             }
         } catch (DataValidationException e) {
         } catch (DataValidationException e) {
             log.error("Data object is invalid: [{}]", e.getMessage());
             log.error("Data object is invalid: [{}]", e.getMessage());
             throw e;
             throw e;
         }
         }
     }
     }
-    
-    protected void validateDataImpl(D data) {
+
+    protected void validateDataImpl(TenantId tenantId, D data) {
     }
     }
-    
-    protected void validateCreate(D data) {
+
+    protected void validateCreate(TenantId tenantId, D data) {
     }
     }
 
 
-    protected void validateUpdate(D data) {
+    protected void validateUpdate(TenantId tenantId, D data) {
     }
     }
-    
+
     protected boolean isSameData(D existentData, D actualData) {
     protected boolean isSameData(D existentData, D actualData) {
         return actualData.getId() != null && existentData.getId().equals(actualData.getId());
         return actualData.getId() != null && existentData.getId().equals(actualData.getId());
     }
     }
-    
+
     protected static void validateEmail(String email) {
     protected static void validateEmail(String email) {
         if (!emailValidator.isValid(email)) {
         if (!emailValidator.isValid(email)) {
             throw new DataValidationException("Invalid email address format '" + email + "'!");
             throw new DataValidationException("Invalid email address format '" + email + "'!");
         }
         }
     }
     }
-    
+
     protected static void validateJsonStructure(JsonNode expectedNode, JsonNode actualNode) {
     protected static void validateJsonStructure(JsonNode expectedNode, JsonNode actualNode) {
-        Set<String> expectedFields = new HashSet<>();        
+        Set<String> expectedFields = new HashSet<>();
         Iterator<String> fieldsIterator = expectedNode.fieldNames();
         Iterator<String> fieldsIterator = expectedNode.fieldNames();
         while (fieldsIterator.hasNext()) {
         while (fieldsIterator.hasNext()) {
             expectedFields.add(fieldsIterator.next());
             expectedFields.add(fieldsIterator.next());
         }
         }
-        
-        Set<String> actualFields = new HashSet<>();        
+
+        Set<String> actualFields = new HashSet<>();
         fieldsIterator = actualNode.fieldNames();
         fieldsIterator = actualNode.fieldNames();
         while (fieldsIterator.hasNext()) {
         while (fieldsIterator.hasNext()) {
             actualFields.add(fieldsIterator.next());
             actualFields.add(fieldsIterator.next());
         }
         }
-        
+
         if (!expectedFields.containsAll(actualFields) || !actualFields.containsAll(expectedFields)) {
         if (!expectedFields.containsAll(actualFields) || !actualFields.containsAll(expectedFields)) {
             throw new DataValidationException("Provided json structure is different from stored one '" + actualNode + "'!");
             throw new DataValidationException("Provided json structure is different from stored one '" + actualNode + "'!");
         }
         }
-        
+
         for (String field : actualFields) {
         for (String field : actualFields) {
             if (!actualNode.get(field).isTextual()) {
             if (!actualNode.get(field).isTextual()) {
                 throw new DataValidationException("Provided json structure can't contain non-text values '" + actualNode + "'!");
                 throw new DataValidationException("Provided json structure can't contain non-text values '" + actualNode + "'!");

@@ -16,6 +16,7 @@
 package org.thingsboard.server.dao.service;
 package org.thingsboard.server.dao.service;
 
 
 import org.thingsboard.server.common.data.id.IdBased;
 import org.thingsboard.server.common.data.id.IdBased;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.TextPageLink;
 import org.thingsboard.server.common.data.page.TextPageLink;
 
 
 import java.util.List;
 import java.util.List;
@@ -25,13 +26,13 @@ public abstract class PaginatedRemover<I, D extends IdBased<?>> {
 
 
     private static final int DEFAULT_LIMIT = 100;
     private static final int DEFAULT_LIMIT = 100;
 
 
-    public void removeEntities(I id) {
+    public void removeEntities(TenantId tenantId, I id) {
         TextPageLink pageLink = new TextPageLink(DEFAULT_LIMIT);
         TextPageLink pageLink = new TextPageLink(DEFAULT_LIMIT);
         boolean hasNext = true;
         boolean hasNext = true;
         while (hasNext) {
         while (hasNext) {
-            List<D> entities = findEntities(id, pageLink);
+            List<D> entities = findEntities(tenantId, id, pageLink);
             for (D entity : entities) {
             for (D entity : entities) {
-                removeEntity(entity);
+                removeEntity(tenantId, entity);
             }
             }
             hasNext = entities.size() == pageLink.getLimit();
             hasNext = entities.size() == pageLink.getLimit();
             if (hasNext) {
             if (hasNext) {
@@ -42,8 +43,8 @@ public abstract class PaginatedRemover<I, D extends IdBased<?>> {
         }
         }
     }
     }
 
 
-    protected abstract List<D> findEntities(I id, TextPageLink pageLink);
+    protected abstract List<D> findEntities(TenantId tenantId,I id, TextPageLink pageLink);
 
 
-    protected abstract void removeEntity(D entity);
+    protected abstract void removeEntity(TenantId tenantId, D entity);
 
 
 }
 }

@@ -16,6 +16,7 @@
 package org.thingsboard.server.dao.settings;
 package org.thingsboard.server.dao.settings;
 
 
 import org.thingsboard.server.common.data.AdminSettings;
 import org.thingsboard.server.common.data.AdminSettings;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.dao.Dao;
 import org.thingsboard.server.dao.Dao;
 
 
 public interface AdminSettingsDao extends Dao<AdminSettings> {
 public interface AdminSettingsDao extends Dao<AdminSettings> {
@@ -26,7 +27,7 @@ public interface AdminSettingsDao extends Dao<AdminSettings> {
      * @param adminSettings the admin settings object
      * @param adminSettings the admin settings object
      * @return saved admin settings object
      * @return saved admin settings object
      */
      */
-    AdminSettings save(AdminSettings adminSettings);
+    AdminSettings save(TenantId tenantId, AdminSettings adminSettings);
     
     
     /**
     /**
      * Find admin settings by key.
      * Find admin settings by key.
@@ -34,6 +35,6 @@ public interface AdminSettingsDao extends Dao<AdminSettings> {
      * @param key the key
      * @param key the key
      * @return the admin settings object
      * @return the admin settings object
      */
      */
-    AdminSettings findByKey(String key);
+    AdminSettings findByKey(TenantId tenantId, String key);
 
 
 }
 }

@@ -17,13 +17,14 @@ package org.thingsboard.server.dao.settings;
 
 
 import org.thingsboard.server.common.data.AdminSettings;
 import org.thingsboard.server.common.data.AdminSettings;
 import org.thingsboard.server.common.data.id.AdminSettingsId;
 import org.thingsboard.server.common.data.id.AdminSettingsId;
+import org.thingsboard.server.common.data.id.TenantId;
 
 
 public interface AdminSettingsService {
 public interface AdminSettingsService {
 
 
-    AdminSettings findAdminSettingsById(AdminSettingsId adminSettingsId);
+    AdminSettings findAdminSettingsById(TenantId tenantId, AdminSettingsId adminSettingsId);
 
 
-    AdminSettings findAdminSettingsByKey(String key);
+    AdminSettings findAdminSettingsByKey(TenantId tenantId, String key);
     
     
-    AdminSettings saveAdminSettings(AdminSettings adminSettings);
+    AdminSettings saveAdminSettings(TenantId tenantId, AdminSettings adminSettings);
     
     
 }
 }