Merge branch 'feature/calculated-fields' into feature/calculated-fields-table

application/src/main/java/org/thingsboard/server/actors/ActorSystemContext.java

@@ -104,6 +104,7 @@ import org.thingsboard.server.queue.discovery.DiscoveryService;
 import org.thingsboard.server.queue.discovery.PartitionService;
 import org.thingsboard.server.queue.discovery.TbServiceInfoProvider;
 import org.thingsboard.server.service.apiusage.TbApiUsageStateService;
+import org.thingsboard.server.service.cf.CalculatedFieldExecutionService;
 import org.thingsboard.server.service.component.ComponentDiscoveryService;
 import org.thingsboard.server.service.edge.rpc.EdgeRpcService;
 import org.thingsboard.server.service.entitiy.entityview.TbEntityViewService;
@@ -507,6 +508,11 @@ public class ActorSystemContext {
     @Getter
     private EntityService entityService;
 
+    @Lazy
+    @Autowired(required = false)
+    @Getter
+    private CalculatedFieldExecutionService calculatedFieldExecutionService;
+
     @Value("${actors.session.max_concurrent_sessions_per_device:1}")
     @Getter
     private long maxConcurrentSessionsPerDevice;

application/src/main/java/org/thingsboard/server/actors/app/AppActor.java

@@ -36,6 +36,7 @@ import org.thingsboard.server.common.data.page.PageDataIterable;
 import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent;
 import org.thingsboard.server.common.msg.MsgType;
 import org.thingsboard.server.common.msg.TbActorMsg;
+import org.thingsboard.server.common.msg.ToCalculatedFieldSystemMsg;
 import org.thingsboard.server.common.msg.aware.TenantAwareMsg;
 import org.thingsboard.server.common.msg.plugin.ComponentLifecycleMsg;
 import org.thingsboard.server.common.msg.queue.QueueToRuleEngineMsg;
@@ -111,6 +112,17 @@ public class AppActor extends ContextAwareActor {
             case SESSION_TIMEOUT_MSG:
                 ctx.broadcastToChildrenByType(msg, EntityType.TENANT);
                 break;
+            case CF_INIT_MSG:
+            case CF_LINK_INIT_MSG:
+            case CF_STATE_RESTORE_MSG:
+            case CF_UPDATE_MSG:
+                onToCalculatedFieldSystemActorMsg((ToCalculatedFieldSystemMsg) msg, true);
+                break;
+            case CF_TELEMETRY_MSG:
+            case CF_LINKED_TELEMETRY_MSG:
+            case CF_ENTITY_UPDATE_MSG:
+                onToCalculatedFieldSystemActorMsg((ToCalculatedFieldSystemMsg) msg, false);
+                break;
             default:
                 return false;
         }
@@ -175,6 +187,19 @@ public class AppActor extends ContextAwareActor {
         }
     }
 
+    private void onToCalculatedFieldSystemActorMsg(ToCalculatedFieldSystemMsg msg, boolean priority) {
+        getOrCreateTenantActor(msg.getTenantId()).ifPresentOrElse(tenantActor -> {
+            if (priority) {
+                tenantActor.tellWithHighPriority(msg);
+            } else {
+                tenantActor.tell(msg);
+            }
+        }, () -> {
+            msg.getCallback().onSuccess();
+        });
+    }
+
+
     private void onToDeviceActorMsg(TenantAwareMsg msg, boolean priority) {
         getOrCreateTenantActor(msg.getTenantId()).ifPresentOrElse(tenantActor -> {
             if (priority) {

application/src/main/java/org/thingsboard/server/actors/calculatedField/CalculatedFieldEntityActor.java

@@ -0,0 +1,65 @@
+/**
+ * Copyright © 2016-2024 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.actors.calculatedField;
+
+import lombok.extern.slf4j.Slf4j;
+import org.thingsboard.server.actors.ActorSystemContext;
+import org.thingsboard.server.actors.TbActorCtx;
+import org.thingsboard.server.actors.TbActorException;
+import org.thingsboard.server.actors.service.ContextAwareActor;
+import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.msg.TbActorMsg;
+
+@Slf4j
+public class CalculatedFieldEntityActor extends ContextAwareActor {
+
+    private final CalculatedFieldEntityMessageProcessor processor;
+
+    CalculatedFieldEntityActor(ActorSystemContext systemContext, TenantId tenantId, EntityId entityId) {
+        super(systemContext);
+        this.processor = new CalculatedFieldEntityMessageProcessor(systemContext, tenantId, entityId);
+    }
+
+    @Override
+    public void init(TbActorCtx ctx) throws TbActorException {
+        super.init(ctx);
+        log.debug("[{}][{}] Starting CF entity actor.", processor.tenantId, processor.entityId);
+        try {
+            processor.init(ctx);
+            log.debug("[{}][{}] CF entity actor started.", processor.tenantId, processor.entityId);
+        } catch (Exception e) {
+            log.warn("[{}][{}] Unknown failure", processor.tenantId, processor.entityId, e);
+            throw new TbActorException("Failed to initialize device actor", e);
+        }
+    }
+
+    @Override
+    protected boolean doProcess(TbActorMsg msg) {
+        switch (msg.getMsgType()) {
+            case CF_STATE_RESTORE_MSG:
+                processor.process((CalculatedFieldStateRestoreMsg) msg);
+                break;
+            case CF_ENTITY_TELEMETRY_MSG:
+                processor.process((EntityCalculatedFieldTelemetryMsg) msg);
+                break;
+            default:
+                return false;
+        }
+        return true;
+    }
+
+}

application/src/main/java/org/thingsboard/server/actors/calculatedField/CalculatedFieldEntityActorCreator.java

@@ -0,0 +1,49 @@
+/**
+ * Copyright © 2016-2024 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.actors.calculatedField;
+
+import org.thingsboard.server.actors.ActorSystemContext;
+import org.thingsboard.server.actors.TbActor;
+import org.thingsboard.server.actors.TbActorId;
+import org.thingsboard.server.actors.TbEntityActorId;
+import org.thingsboard.server.actors.device.DeviceActor;
+import org.thingsboard.server.actors.service.ContextBasedCreator;
+import org.thingsboard.server.common.data.id.DeviceId;
+import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
+
+public class CalculatedFieldEntityActorCreator extends ContextBasedCreator {
+
+    private final TenantId tenantId;
+    private final EntityId entityId;
+
+    public CalculatedFieldEntityActorCreator(ActorSystemContext context, TenantId tenantId, EntityId entityId) {
+        super(context);
+        this.tenantId = tenantId;
+        this.entityId = entityId;
+    }
+
+    @Override
+    public TbActorId createActorId() {
+        return new TbEntityActorId(entityId);
+    }
+
+    @Override
+    public TbActor createActor() {
+        return new CalculatedFieldEntityActor(context, tenantId, entityId);
+    }
+
+}

application/src/main/java/org/thingsboard/server/actors/calculatedField/CalculatedFieldEntityMessageProcessor.java

@@ -0,0 +1,199 @@
+/**
+ * Copyright © 2016-2024 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.actors.calculatedField;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.thingsboard.server.actors.ActorSystemContext;
+import org.thingsboard.server.actors.TbActorCtx;
+import org.thingsboard.server.actors.shared.AbstractContextAwareMsgProcessor;
+import org.thingsboard.server.common.data.AttributeScope;
+import org.thingsboard.server.common.data.cf.configuration.ArgumentType;
+import org.thingsboard.server.common.data.cf.configuration.ReferencedEntityKey;
+import org.thingsboard.server.common.data.id.CalculatedFieldId;
+import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.gen.transport.TransportProtos.AttributeScopeProto;
+import org.thingsboard.server.gen.transport.TransportProtos.AttributeValueProto;
+import org.thingsboard.server.gen.transport.TransportProtos.CalculatedFieldTelemetryMsgProto;
+import org.thingsboard.server.gen.transport.TransportProtos.TsKvProto;
+import org.thingsboard.server.service.cf.CalculatedFieldExecutionService;
+import org.thingsboard.server.service.cf.CalculatedFieldResult;
+import org.thingsboard.server.service.cf.ctx.CalculatedFieldEntityCtxId;
+import org.thingsboard.server.service.cf.ctx.state.ArgumentEntry;
+import org.thingsboard.server.service.cf.ctx.state.CalculatedFieldCtx;
+import org.thingsboard.server.service.cf.ctx.state.CalculatedFieldState;
+import org.thingsboard.server.service.cf.ctx.state.SingleValueArgumentEntry;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+
+/**
+ * @author Andrew Shvayka
+ */
+@Slf4j
+public class CalculatedFieldEntityMessageProcessor extends AbstractContextAwareMsgProcessor {
+    // (1 for result persistence + 1 for the state persistence )
+    public static final int CALLBACKS_PER_CF = 2;
+
+    final TenantId tenantId;
+    final EntityId entityId;
+    final CalculatedFieldExecutionService cfService;
+
+    TbActorCtx ctx;
+    Map<CalculatedFieldId, CalculatedFieldState> states = new HashMap<>();
+
+    CalculatedFieldEntityMessageProcessor(ActorSystemContext systemContext, TenantId tenantId, EntityId entityId) {
+        super(systemContext);
+        this.tenantId = tenantId;
+        this.entityId = entityId;
+        this.cfService = systemContext.getCalculatedFieldExecutionService();
+    }
+
+    void init(TbActorCtx ctx) {
+        this.ctx = ctx;
+    }
+
+    public void process(CalculatedFieldStateRestoreMsg msg) {
+        states.put(msg.getId().cfId(), msg.getState());
+    }
+
+    public void process(EntityCalculatedFieldTelemetryMsg msg) {
+        var proto = msg.getProto();
+        var numberOfCallbacks = CALLBACKS_PER_CF * (msg.getEntityIdFields().size() + msg.getProfileIdFields().size());
+        MultipleTbCallback callback = new MultipleTbCallback(numberOfCallbacks, msg.getCallback());
+        List<CalculatedFieldId> cfIdList = getCalculatedFieldIds(proto);
+        Set<CalculatedFieldId> cfIdSet = new HashSet<>(cfIdList);
+        for (var ctx : msg.getEntityIdFields()) {
+            process(ctx, proto, cfIdSet, cfIdList, callback);
+        }
+        for (var ctx : msg.getProfileIdFields()) {
+            process(ctx, proto, cfIdSet, cfIdList, callback);
+        }
+    }
+
+    private void process(CalculatedFieldCtx ctx, CalculatedFieldTelemetryMsgProto proto, Set<CalculatedFieldId> cfIds, List<CalculatedFieldId> cfIdList, MultipleTbCallback callback) {
+        if (cfIds.contains(ctx.getCfId())) {
+            callback.onSuccess(CALLBACKS_PER_CF);
+        } else {
+            if (proto.getTsDataCount() > 0) {
+                processTelemetry(ctx, proto, cfIdList, callback);
+            } else if (proto.getAttrDataCount() > 0) {
+                processAttributes(ctx, proto, cfIdList, callback);
+            } else {
+                callback.onSuccess(CALLBACKS_PER_CF);
+            }
+        }
+    }
+
+    @SneakyThrows
+    private void processTelemetry(CalculatedFieldCtx ctx, CalculatedFieldTelemetryMsgProto proto, List<CalculatedFieldId> cfIdList, MultipleTbCallback callback) {
+        processArgumentValuesUpdate(ctx, cfIdList, callback, mapToArguments(ctx, proto.getTsDataList()));
+    }
+
+    @SneakyThrows
+    private void processAttributes(CalculatedFieldCtx ctx, CalculatedFieldTelemetryMsgProto proto, List<CalculatedFieldId> cfIdList, MultipleTbCallback callback) {
+        processArgumentValuesUpdate(ctx, cfIdList, callback, mapToArguments(ctx, proto.getScope(), proto.getAttrDataList()));
+    }
+
+    private void processArgumentValuesUpdate(CalculatedFieldCtx ctx, List<CalculatedFieldId> cfIdList, MultipleTbCallback callback,
+                                             Map<String, ArgumentEntry> newArgValues) throws InterruptedException, ExecutionException, TimeoutException {
+        if (newArgValues.isEmpty()) {
+            callback.onSuccess(CALLBACKS_PER_CF);
+        }
+        CalculatedFieldState state = getOrInitState(ctx);
+        if (state.updateState(newArgValues)) {
+            if (state.isReady()) {
+                CalculatedFieldResult calculationResult = state.performCalculation(ctx).get(5, TimeUnit.SECONDS);
+                cfIdList = new ArrayList<>(cfIdList);
+                cfIdList.add(ctx.getCfId());
+                cfService.pushMsgToRuleEngine(tenantId, entityId, calculationResult, cfIdList, callback);
+            } else {
+                callback.onSuccess(); // State was updated but no calculation performed;
+            }
+            cfService.pushStateToStorage(new CalculatedFieldEntityCtxId(tenantId, ctx.getCfId(), entityId), state, callback);
+        } else {
+            callback.onSuccess(CALLBACKS_PER_CF);
+        }
+    }
+
+    @SneakyThrows
+    private CalculatedFieldState getOrInitState(CalculatedFieldCtx ctx) {
+        CalculatedFieldState state = states.get(ctx.getCfId());
+        if (state != null) {
+            return state;
+        } else {
+            ListenableFuture<CalculatedFieldState> stateFuture = systemContext.getCalculatedFieldExecutionService().fetchStateFromDb(ctx, entityId);
+            // Ugly but necessary. We do not expect to often fetch data from DB. Only once per <Entity, CalculatedField> pair lifetime.
+            // This call happens while processing the CF pack from the queue consumer. So the timeout should be relatively low.
+            // Alternatively, we can fetch the state outside the actor system and push separate command to create this actor,
+            // but this will significantly complicate the code.
+            state = stateFuture.get(1, TimeUnit.MINUTES);
+            states.put(ctx.getCfId(), state);
+        }
+        return state;
+    }
+
+    private Map<String, ArgumentEntry> mapToArguments(CalculatedFieldCtx ctx, List<TsKvProto> data) {
+        Map<String, ArgumentEntry> arguments = new HashMap<>();
+        var argNames = ctx.getMainEntityArguments();
+        for (TsKvProto item : data) {
+            ReferencedEntityKey key = new ReferencedEntityKey(item.getKv().getKey(), ArgumentType.TS_LATEST, null);
+            String argName = argNames.get(key);
+            if (argName != null) {
+                arguments.put(argName, new SingleValueArgumentEntry(item));
+            }
+            key = new ReferencedEntityKey(item.getKv().getKey(), ArgumentType.TS_ROLLING, null);
+            argName = argNames.get(key);
+            if (argName != null) {
+                arguments.put(argName, new SingleValueArgumentEntry(item));
+            }
+        }
+        return arguments;
+    }
+
+    private Map<String, ArgumentEntry> mapToArguments(CalculatedFieldCtx ctx, AttributeScopeProto scope, List<AttributeValueProto> attrDataList) {
+        Map<String, ArgumentEntry> arguments = new HashMap<>();
+        var argNames = ctx.getMainEntityArguments();
+        for (AttributeValueProto item : attrDataList) {
+            ReferencedEntityKey key = new ReferencedEntityKey(item.getKey(), ArgumentType.ATTRIBUTE, AttributeScope.valueOf(scope.name()));
+            String argName = argNames.get(key);
+            if (argName != null) {
+                arguments.put(argName, new SingleValueArgumentEntry(item));
+            }
+        }
+        return arguments;
+    }
+
+    private static List<CalculatedFieldId> getCalculatedFieldIds(CalculatedFieldTelemetryMsgProto proto) {
+        List<CalculatedFieldId> cfIds = new LinkedList<>();
+        for (var cfId : proto.getPreviousCalculatedFieldsList()) {
+            cfIds.add(new CalculatedFieldId(new UUID(cfId.getCalculatedFieldIdMSB(), cfId.getCalculatedFieldIdLSB())));
+        }
+        return cfIds;
+    }
+}

application/src/main/java/org/thingsboard/server/actors/calculatedField/CalculatedFieldLinkedTelemetryMsg.java

@@ -0,0 +1,40 @@
+/**
+ * Copyright © 2016-2024 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.actors.calculatedField;
+
+import lombok.Data;
+import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.msg.MsgType;
+import org.thingsboard.server.common.msg.ToCalculatedFieldSystemMsg;
+import org.thingsboard.server.common.msg.queue.TbCallback;
+import org.thingsboard.server.gen.transport.TransportProtos.CalculatedFieldLinkedTelemetryMsgProto;
+import org.thingsboard.server.gen.transport.TransportProtos.CalculatedFieldTelemetryMsgProto;
+
+@Data
+public class CalculatedFieldLinkedTelemetryMsg implements ToCalculatedFieldSystemMsg {
+
+    private final TenantId tenantId;
+    private final EntityId entityId;
+    private final CalculatedFieldLinkedTelemetryMsgProto proto;
+    private final TbCallback callback;
+
+
+    @Override
+    public MsgType getMsgType() {
+        return MsgType.CF_LINKED_TELEMETRY_MSG;
+    }
+}

application/src/main/java/org/thingsboard/server/actors/calculatedField/CalculatedFieldManagerActor.java

@@ -0,0 +1,84 @@
+/**
+ * Copyright © 2016-2024 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.actors.calculatedField;
+
+import lombok.extern.slf4j.Slf4j;
+import org.thingsboard.server.actors.ActorSystemContext;
+import org.thingsboard.server.actors.TbActorCtx;
+import org.thingsboard.server.actors.TbActorException;
+import org.thingsboard.server.actors.service.ContextAwareActor;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.msg.TbActorMsg;
+import org.thingsboard.server.common.msg.cf.CalculatedFieldInitMsg;
+import org.thingsboard.server.common.msg.cf.CalculatedFieldLinkInitMsg;
+
+/**
+ * Created by ashvayka on 15.03.18.
+ */
+@Slf4j
+public class CalculatedFieldManagerActor extends ContextAwareActor {
+
+    private final CalculatedFieldManagerMessageProcessor processor;
+
+    public CalculatedFieldManagerActor(ActorSystemContext systemContext, TenantId tenantId) {
+        super(systemContext);
+        this.processor = new CalculatedFieldManagerMessageProcessor(systemContext, tenantId);
+    }
+
+    @Override
+    public void init(TbActorCtx ctx) throws TbActorException {
+        super.init(ctx);
+        log.debug("[{}] Starting CF manager actor.", processor.tenantId);
+        try {
+            processor.init(ctx);
+            log.debug("[{}] CF manager actor started.", processor.tenantId);
+        } catch (Exception e) {
+            log.warn("[{}] Unknown failure", processor.tenantId, e);
+            throw new TbActorException("Failed to initialize manager actor", e);
+        }
+    }
+
+    @Override
+    protected boolean doProcess(TbActorMsg msg) {
+        switch (msg.getMsgType()) {
+            case PARTITION_CHANGE_MSG:
+                ctx.broadcastToChildren(msg, true); // TODO
+                break;
+            case CF_INIT_MSG:
+                processor.onFieldInitMsg((CalculatedFieldInitMsg) msg);
+                break;
+            case CF_LINK_INIT_MSG:
+                processor.onLinkInitMsg((CalculatedFieldLinkInitMsg) msg);
+                break;
+            case CF_STATE_RESTORE_MSG:
+                processor.onStateRestoreMsg((CalculatedFieldStateRestoreMsg) msg);
+                break;
+            case CF_UPDATE_MSG:
+//                processor.onToCalculatedFieldSystemActorMsg((ToCalculatedFieldSystemMsg) msg);
+                break;
+            case CF_TELEMETRY_MSG:
+                processor.onTelemetryMsg((CalculatedFieldTelemetryMsg) msg);
+                break;
+            case CF_LINKED_TELEMETRY_MSG:
+            case CF_ENTITY_UPDATE_MSG:
+//                processor.onToCalculatedFieldSystemActorMsg((ToCalculatedFieldSystemMsg) msg);
+                break;
+            default:
+                return false;
+        }
+        return true;
+    }
+}

application/src/main/java/org/thingsboard/server/actors/calculatedField/CalculatedFieldManagerActorCreator.java

@@ -0,0 +1,46 @@
+/**
+ * Copyright © 2016-2024 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.actors.calculatedField;
+
+import org.thingsboard.server.actors.ActorSystemContext;
+import org.thingsboard.server.actors.TbActor;
+import org.thingsboard.server.actors.TbActorId;
+import org.thingsboard.server.actors.TbEntityActorId;
+import org.thingsboard.server.actors.TbStringActorId;
+import org.thingsboard.server.actors.service.ContextBasedCreator;
+import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
+
+public class CalculatedFieldManagerActorCreator extends ContextBasedCreator {
+
+    private final TenantId tenantId;
+
+    public CalculatedFieldManagerActorCreator(ActorSystemContext context, TenantId tenantId) {
+        super(context);
+        this.tenantId = tenantId;
+    }
+
+    @Override
+    public TbActorId createActorId() {
+        return new TbStringActorId("CFM|" + tenantId);
+    }
+
+    @Override
+    public TbActor createActor() {
+        return new CalculatedFieldManagerActor(context, tenantId);
+    }
+
+}

application/src/main/java/org/thingsboard/server/actors/calculatedField/CalculatedFieldManagerMessageProcessor.java

@@ -0,0 +1,149 @@
+/**
+ * Copyright © 2016-2024 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.actors.calculatedField;
+
+import lombok.extern.slf4j.Slf4j;
+import org.thingsboard.server.actors.ActorSystemContext;
+import org.thingsboard.server.actors.TbActorCtx;
+import org.thingsboard.server.actors.TbActorRef;
+import org.thingsboard.server.actors.TbCalculatedFieldEntityActorId;
+import org.thingsboard.server.actors.service.DefaultActorService;
+import org.thingsboard.server.actors.shared.AbstractContextAwareMsgProcessor;
+import org.thingsboard.server.common.data.cf.CalculatedField;
+import org.thingsboard.server.common.data.cf.CalculatedFieldLink;
+import org.thingsboard.server.common.data.id.AssetId;
+import org.thingsboard.server.common.data.id.CalculatedFieldId;
+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.msg.cf.CalculatedFieldInitMsg;
+import org.thingsboard.server.common.msg.cf.CalculatedFieldLinkInitMsg;
+import org.thingsboard.server.service.cf.ctx.state.CalculatedFieldCtx;
+import org.thingsboard.server.service.profile.TbAssetProfileCache;
+import org.thingsboard.server.service.profile.TbDeviceProfileCache;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+
+/**
+ * @author Andrew Shvayka
+ */
+@Slf4j
+public class CalculatedFieldManagerMessageProcessor extends AbstractContextAwareMsgProcessor {
+
+    private final Map<CalculatedFieldId, CalculatedField> calculatedFields = new HashMap<>();
+    private final Map<EntityId, List<CalculatedFieldCtx>> entityIdCalculatedFields = new ConcurrentHashMap<>();
+    private final ConcurrentMap<EntityId, List<CalculatedFieldLink>> entityIdCalculatedFieldLinks = new ConcurrentHashMap<>();
+
+    private final TbAssetProfileCache assetProfileCache;
+    private final TbDeviceProfileCache deviceProfileCache;
+
+    protected TbActorCtx ctx;
+    final TenantId tenantId;
+
+    CalculatedFieldManagerMessageProcessor(ActorSystemContext systemContext, TenantId tenantId) {
+        super(systemContext);
+        this.assetProfileCache = systemContext.getAssetProfileCache();
+        this.deviceProfileCache = systemContext.getDeviceProfileCache();
+        this.tenantId = tenantId;
+    }
+
+    void init(TbActorCtx ctx) {
+        this.ctx = ctx;
+    }
+
+    public void onFieldInitMsg(CalculatedFieldInitMsg msg) {
+        var cf = msg.getCf();
+        calculatedFields.put(cf.getId(), cf);
+        // We use copy on write lists to safely pass the reference to another actor for the iteration.
+        // Alternative approach would be to use any list but avoid modifications to the list (change the complete map value instead)
+        entityIdCalculatedFields.computeIfAbsent(cf.getEntityId(), id -> new CopyOnWriteArrayList<>())
+                .add(new CalculatedFieldCtx(cf, systemContext.getTbelInvokeService()));
+        msg.getCallback().onSuccess();
+    }
+
+    public void onLinkInitMsg(CalculatedFieldLinkInitMsg msg) {
+        var link = msg.getLink();
+        // We use copy on write lists to safely pass the reference to another actor for the iteration.
+        // Alternative approach would be to use any list but avoid modifications to the list (change the complete map value instead)
+        entityIdCalculatedFieldLinks.computeIfAbsent(link.getEntityId(), id -> new CopyOnWriteArrayList<>()).add(link);
+        msg.getCallback().onSuccess();
+    }
+
+    public void onStateRestoreMsg(CalculatedFieldStateRestoreMsg msg) {
+        if (calculatedFields.containsKey(msg.getId().cfId())) {
+            getOrCreateActor(msg.getId().entityId()).tell(msg);
+        } else {
+            // TODO: remove state from storage
+        }
+    }
+
+    public void onTelemetryMsg(CalculatedFieldTelemetryMsg msg) {
+        EntityId entityId = msg.getEntityId();
+        var proto = msg.getProto();
+        // process all cfs related to entity, or it's profile;
+        var entityIdFields = getCalculatedFieldsByEntityId(entityId);
+        var profileIdFields = getCalculatedFieldsByEntityId(getProfileId(tenantId, entityId));
+        //TODO: Transfer only 'part' of the original callback.
+        getOrCreateActor(entityId).tell(new EntityCalculatedFieldTelemetryMsg(msg, entityIdFields, profileIdFields, msg.getCallback()));
+        // process all links (if any);
+        var links = getCalculatedFieldLinksByEntityId(entityId);
+    }
+
+    private List<CalculatedFieldCtx> getCalculatedFieldsByEntityId(EntityId entityId) {
+        if (entityId == null) {
+            return Collections.emptyList();
+        }
+        var result = entityIdCalculatedFields.get(entityId);
+        if (result == null) {
+            result = Collections.emptyList();
+        }
+        return result;
+    }
+
+    private List<CalculatedFieldLink> getCalculatedFieldLinksByEntityId(EntityId entityId) {
+        if (entityId == null) {
+            return Collections.emptyList();
+        }
+        var result = entityIdCalculatedFieldLinks.get(entityId);
+        if (result == null) {
+            result = Collections.emptyList();
+        }
+        return result;
+    }
+
+    private EntityId getProfileId(TenantId tenantId, EntityId entityId) {
+        return switch (entityId.getEntityType()) {
+            case ASSET -> assetProfileCache.get(tenantId, (AssetId) entityId).getId();
+            case DEVICE -> deviceProfileCache.get(tenantId, (DeviceId) entityId).getId();
+            default -> null;
+        };
+    }
+
+    protected TbActorRef getOrCreateActor(EntityId entityId) {
+        return ctx.getOrCreateChildActor(new TbCalculatedFieldEntityActorId(entityId),
+                () -> DefaultActorService.CF_ENTITY_DISPATCHER_NAME,
+                () -> new CalculatedFieldEntityActorCreator(systemContext, tenantId, entityId),
+                () -> true);
+    }
+
+}

application/src/main/java/org/thingsboard/server/actors/calculatedField/CalculatedFieldStateRestoreMsg.java

@@ -0,0 +1,40 @@
+/**
+ * Copyright © 2016-2024 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.actors.calculatedField;
+
+import lombok.Data;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.msg.MsgType;
+import org.thingsboard.server.common.msg.ToCalculatedFieldSystemMsg;
+import org.thingsboard.server.service.cf.ctx.CalculatedFieldEntityCtxId;
+import org.thingsboard.server.service.cf.ctx.state.CalculatedFieldState;
+
+@Data
+public class CalculatedFieldStateRestoreMsg implements ToCalculatedFieldSystemMsg {
+
+    private final CalculatedFieldEntityCtxId id;
+    private final CalculatedFieldState state;
+
+    @Override
+    public MsgType getMsgType() {
+        return MsgType.CF_STATE_RESTORE_MSG;
+    }
+
+    @Override
+    public TenantId getTenantId() {
+        return id.tenantId();
+    }
+}

application/src/main/java/org/thingsboard/server/actors/calculatedField/CalculatedFieldTelemetryMsg.java

@@ -0,0 +1,39 @@
+/**
+ * Copyright © 2016-2024 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.actors.calculatedField;
+
+import lombok.Data;
+import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.msg.MsgType;
+import org.thingsboard.server.common.msg.ToCalculatedFieldSystemMsg;
+import org.thingsboard.server.common.msg.queue.TbCallback;
+import org.thingsboard.server.gen.transport.TransportProtos.CalculatedFieldTelemetryMsgProto;
+
+@Data
+public class CalculatedFieldTelemetryMsg implements ToCalculatedFieldSystemMsg {
+
+    private final TenantId tenantId;
+    private final EntityId entityId;
+    private final CalculatedFieldTelemetryMsgProto proto;
+    private final TbCallback callback;
+
+
+    @Override
+    public MsgType getMsgType() {
+        return MsgType.CF_TELEMETRY_MSG;
+    }
+}

application/src/main/java/org/thingsboard/server/actors/calculatedField/EntityCalculatedFieldTelemetryMsg.java

@@ -0,0 +1,55 @@
+/**
+ * Copyright © 2016-2024 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.actors.calculatedField;
+
+import lombok.Data;
+import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.msg.MsgType;
+import org.thingsboard.server.common.msg.ToCalculatedFieldSystemMsg;
+import org.thingsboard.server.common.msg.queue.TbCallback;
+import org.thingsboard.server.gen.transport.TransportProtos.CalculatedFieldTelemetryMsgProto;
+import org.thingsboard.server.service.cf.ctx.state.CalculatedFieldCtx;
+
+import java.util.List;
+
+@Data
+public class EntityCalculatedFieldTelemetryMsg implements ToCalculatedFieldSystemMsg {
+
+    private final TenantId tenantId;
+    private final EntityId entityId;
+    private final CalculatedFieldTelemetryMsgProto proto;
+    private final List<CalculatedFieldCtx> entityIdFields;
+    private final List<CalculatedFieldCtx> profileIdFields;
+    private final TbCallback callback;
+
+    public EntityCalculatedFieldTelemetryMsg(CalculatedFieldTelemetryMsg msg,
+                                             List<CalculatedFieldCtx> entityIdFields,
+                                             List<CalculatedFieldCtx> profileIdFields,
+                                             TbCallback callback) {
+        this.tenantId = msg.getTenantId();
+        this.entityId = msg.getEntityId();
+        this.proto = msg.getProto();
+        this.entityIdFields = entityIdFields;
+        this.profileIdFields = profileIdFields;
+        this.callback = callback;
+    }
+
+    @Override
+    public MsgType getMsgType() {
+        return MsgType.CF_ENTITY_TELEMETRY_MSG;
+    }
+}

application/src/main/java/org/thingsboard/server/actors/calculatedField/MultipleTbCallback.java

@@ -0,0 +1,49 @@
+/**
+ * Copyright © 2016-2024 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.actors.calculatedField;
+
+import org.thingsboard.server.common.msg.queue.TbCallback;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class MultipleTbCallback implements TbCallback {
+
+    private final AtomicInteger counter;
+    private final TbCallback callback;
+
+    public MultipleTbCallback(int count, TbCallback callback) {
+        this.counter = new AtomicInteger(count);
+        this.callback = callback;
+    }
+
+    @Override
+    public void onSuccess() {
+        if (counter.decrementAndGet() <= 0) {
+            callback.onSuccess();
+        }
+    }
+
+    public void onSuccess(int number) {
+        if (counter.addAndGet(-number) <= 0) {
+            callback.onSuccess();
+        }
+    }
+
+    @Override
+    public void onFailure(Throwable t) {
+        callback.onFailure(t);
+    }
+}

application/src/main/java/org/thingsboard/server/actors/service/DefaultActorService.java

@@ -49,6 +49,8 @@ public class DefaultActorService extends TbApplicationEventListener<PartitionCha
     public static final String TENANT_DISPATCHER_NAME = "tenant-dispatcher";
     public static final String DEVICE_DISPATCHER_NAME = "device-dispatcher";
     public static final String RULE_DISPATCHER_NAME = "rule-dispatcher";
+    public static final String CF_MANAGER_DISPATCHER_NAME = "cf-manager-dispatcher";
+    public static final String CF_ENTITY_DISPATCHER_NAME = "cf-entity-dispatcher";
 
     @Autowired
     private ActorSystemContext actorContext;
@@ -78,6 +80,13 @@ public class DefaultActorService extends TbApplicationEventListener<PartitionCha
     @Value("${actors.system.rule_dispatcher_pool_size:8}")
     private int ruleDispatcherSize;
 
+    @Value("${actors.system.cfm_dispatcher_pool_size:2}")
+    private int calculatedFieldManagerDispatcherSize;
+
+    @Value("${actors.system.cfe_dispatcher_pool_size:8}")
+    private int calculatedFieldEntityDispatcherSize;
+
+
     @PostConstruct
     public void initActorSystem() {
         log.info("Initializing actor system.");
@@ -89,6 +98,8 @@ public class DefaultActorService extends TbApplicationEventListener<PartitionCha
         system.createDispatcher(TENANT_DISPATCHER_NAME, initDispatcherExecutor(TENANT_DISPATCHER_NAME, tenantDispatcherSize));
         system.createDispatcher(DEVICE_DISPATCHER_NAME, initDispatcherExecutor(DEVICE_DISPATCHER_NAME, deviceDispatcherSize));
         system.createDispatcher(RULE_DISPATCHER_NAME, initDispatcherExecutor(RULE_DISPATCHER_NAME, ruleDispatcherSize));
+        system.createDispatcher(CF_MANAGER_DISPATCHER_NAME, initDispatcherExecutor(CF_MANAGER_DISPATCHER_NAME, calculatedFieldManagerDispatcherSize));
+        system.createDispatcher(CF_ENTITY_DISPATCHER_NAME, initDispatcherExecutor(CF_ENTITY_DISPATCHER_NAME, calculatedFieldEntityDispatcherSize));
 
         actorContext.setActorSystem(system);
 

application/src/main/java/org/thingsboard/server/actors/tenant/TenantActor.java

@@ -26,6 +26,8 @@ import org.thingsboard.server.actors.TbActorNotRegisteredException;
 import org.thingsboard.server.actors.TbActorRef;
 import org.thingsboard.server.actors.TbEntityActorId;
 import org.thingsboard.server.actors.TbEntityTypeActorIdPredicate;
+import org.thingsboard.server.actors.TbStringActorId;
+import org.thingsboard.server.actors.calculatedField.CalculatedFieldManagerActorCreator;
 import org.thingsboard.server.actors.device.DeviceActorCreator;
 import org.thingsboard.server.actors.ruleChain.RuleChainManagerActor;
 import org.thingsboard.server.actors.service.ContextBasedCreator;
@@ -44,6 +46,7 @@ import org.thingsboard.server.common.msg.MsgType;
 import org.thingsboard.server.common.msg.TbActorMsg;
 import org.thingsboard.server.common.msg.TbActorStopReason;
 import org.thingsboard.server.common.msg.TbMsg;
+import org.thingsboard.server.common.msg.ToCalculatedFieldSystemMsg;
 import org.thingsboard.server.common.msg.aware.DeviceAwareMsg;
 import org.thingsboard.server.common.msg.aware.RuleChainAwareMsg;
 import org.thingsboard.server.common.msg.plugin.ComponentLifecycleMsg;
@@ -64,8 +67,8 @@ public class TenantActor extends RuleChainManagerActor {
     private boolean isRuleEngine;
     private boolean isCore;
     private ApiUsageState apiUsageState;
-
     private Set<DeviceId> deletedDevices;
+    private TbActorRef cfActor;
 
     private TenantActor(ActorSystemContext systemContext, TenantId tenantId) {
         super(systemContext, tenantId);
@@ -95,6 +98,11 @@ public class TenantActor extends RuleChainManagerActor {
                             } else {
                                 log.info("[{}] Skip init of the rule chains due to API limits", tenantId);
                             }
+                            //TODO: IM - extend API usage to have CF Exec Enabled? Not in 4.0;
+                            cfActor = ctx.getOrCreateChildActor(new TbStringActorId("CFM|" + tenantId),
+                                    () -> DefaultActorService.CF_MANAGER_DISPATCHER_NAME,
+                                    () -> new CalculatedFieldManagerActorCreator(systemContext, tenantId),
+                                    () -> true);
                         } catch (Exception e) {
                             log.info("Failed to check ApiUsage \"ReExecEnabled\"!!!", e);
                             cantFindTenant = true;
@@ -159,12 +167,31 @@ public class TenantActor extends RuleChainManagerActor {
             case RULE_CHAIN_TO_RULE_CHAIN_MSG:
                 onRuleChainMsg((RuleChainAwareMsg) msg);
                 break;
+            case CF_INIT_MSG:
+            case CF_LINK_INIT_MSG:
+            case CF_STATE_RESTORE_MSG:
+            case CF_UPDATE_MSG:
+                onToCalculatedFieldSystemActorMsg((ToCalculatedFieldSystemMsg) msg, true);
+                break;
+            case CF_TELEMETRY_MSG:
+            case CF_LINKED_TELEMETRY_MSG:
+            case CF_ENTITY_UPDATE_MSG:
+                onToCalculatedFieldSystemActorMsg((ToCalculatedFieldSystemMsg) msg, false);
+                break;
             default:
                 return false;
         }
         return true;
     }
 
+    private void onToCalculatedFieldSystemActorMsg(ToCalculatedFieldSystemMsg msg, boolean priority) {
+        if (priority) {
+            cfActor.tellWithHighPriority(msg);
+        } else {
+            cfActor.tell(msg);
+        }
+    }
+
     private boolean isMyPartition(EntityId entityId) {
         return systemContext.resolve(ServiceType.TB_CORE, tenantId, entityId).isMyPartition();
     }

application/src/main/java/org/thingsboard/server/service/cf/CalculatedFieldCache.java

@@ -15,7 +15,6 @@
  */
 package org.thingsboard.server.service.cf;
 
-import org.thingsboard.script.api.tbel.TbelInvokeService;
 import org.thingsboard.server.common.data.cf.CalculatedField;
 import org.thingsboard.server.common.data.cf.CalculatedFieldLink;
 import org.thingsboard.server.common.data.id.CalculatedFieldId;
@@ -42,6 +41,10 @@ public interface CalculatedFieldCache {
 
     Set<EntityId> getEntitiesByProfile(TenantId tenantId, EntityId entityId);
 
+    void evictProfile(TenantId tenantId, EntityId entityId);
+
+    void evictEntity(TenantId tenantId, EntityId entityId);
+
     void addCalculatedField(TenantId tenantId, CalculatedFieldId calculatedFieldId);
 
     void updateCalculatedField(TenantId tenantId, CalculatedFieldId calculatedFieldId);

application/src/main/java/org/thingsboard/server/service/cf/CalculatedFieldExecutionService.java

@@ -15,13 +15,22 @@
  */
 package org.thingsboard.server.service.cf;
 
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.ListenableFuture;
 import org.thingsboard.rule.engine.api.AttributesSaveRequest;
 import org.thingsboard.rule.engine.api.TimeseriesSaveRequest;
+import org.thingsboard.server.common.data.id.CalculatedFieldId;
+import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.kv.TimeseriesSaveResult;
 import org.thingsboard.server.common.msg.queue.TbCallback;
 import org.thingsboard.server.gen.transport.TransportProtos.CalculatedFieldEntityUpdateMsgProto;
+import org.thingsboard.server.gen.transport.TransportProtos.CalculatedFieldLinkedTelemetryMsgProto;
+import org.thingsboard.server.gen.transport.TransportProtos.CalculatedFieldTelemetryMsgProto;
 import org.thingsboard.server.gen.transport.TransportProtos.ComponentLifecycleMsgProto;
-import org.thingsboard.server.service.cf.telemetry.CalculatedFieldTelemetryUpdateRequest;
+import org.thingsboard.server.service.cf.ctx.CalculatedFieldEntityCtxId;
+import org.thingsboard.server.service.cf.ctx.state.CalculatedFieldCtx;
+import org.thingsboard.server.service.cf.ctx.state.CalculatedFieldState;
 
 import java.util.List;
 
@@ -29,12 +38,17 @@ public interface CalculatedFieldExecutionService {
 
     /**
      * Filter CFs based on the request entity. Push to the queue if any matching CF exist;
-     * @param request - telemetry save request;
-     * @param request - telemetry save result;
+     *
+     * @param request  - telemetry save request;
+     * @param callback
      */
-    void pushRequestToQueue(TimeseriesSaveRequest request, TimeseriesSaveResult result);
+    void pushRequestToQueue(TimeseriesSaveRequest request, TimeseriesSaveResult result, FutureCallback<Void> callback);
 
-    void pushRequestToQueue(AttributesSaveRequest request, List<Long> result);
+    void pushRequestToQueue(AttributesSaveRequest request, List<Long> result, FutureCallback<Void> callback);
+
+    void pushStateToStorage(CalculatedFieldEntityCtxId stateId, CalculatedFieldState state, TbCallback callback);
+
+    ListenableFuture<CalculatedFieldState> fetchStateFromDb(CalculatedFieldCtx ctx, EntityId entityId);
 
 //    void pushEntityUpdateMsg(TransportProtos.CalculatedFieldEntityUpdateMsgProto proto, TbCallback callback);
 
@@ -42,10 +56,12 @@ public interface CalculatedFieldExecutionService {
 
     void onCalculatedFieldLifecycleMsg(ComponentLifecycleMsgProto proto, TbCallback callback);
 
-    void onTelemetryUpdate(CalculatedFieldTelemetryUpdateRequest calculatedFieldTelemetryUpdateRequest);
+    void onTelemetryUpdate(CalculatedFieldTelemetryMsgProto proto, TbCallback callback);
 
-//    void onTelemetryUpdateMsg(TransportProtos.TelemetryUpdateMsgProto proto);
+    void onTelemetryUpdate(CalculatedFieldLinkedTelemetryMsgProto proto, TbCallback callback);
 
     void onEntityUpdateMsg(CalculatedFieldEntityUpdateMsgProto proto, TbCallback callback);
 
+    void pushMsgToRuleEngine(TenantId tenantId, EntityId entityId, CalculatedFieldResult calculationResult, List<CalculatedFieldId> cfIds, TbCallback callback);
+
 }

application/src/main/java/org/thingsboard/server/service/cf/CalculatedFieldInitService.java

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

application/src/main/java/org/thingsboard/server/service/cf/DefaultCalculatedFieldCache.java

@@ -22,15 +22,22 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 import org.thingsboard.script.api.tbel.TbelInvokeService;
+import org.thingsboard.server.actors.ActorSystemContext;
+import org.thingsboard.server.common.data.Device;
+import org.thingsboard.server.common.data.EntityType;
+import org.thingsboard.server.common.data.asset.Asset;
 import org.thingsboard.server.common.data.cf.CalculatedField;
 import org.thingsboard.server.common.data.cf.CalculatedFieldLink;
 import org.thingsboard.server.common.data.cf.configuration.CalculatedFieldConfiguration;
+import org.thingsboard.server.common.data.id.AssetId;
 import org.thingsboard.server.common.data.id.AssetProfileId;
 import org.thingsboard.server.common.data.id.CalculatedFieldId;
+import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.data.id.DeviceProfileId;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.PageDataIterable;
+import org.thingsboard.server.common.msg.cf.CalculatedFieldInitMsg;
 import org.thingsboard.server.dao.asset.AssetService;
 import org.thingsboard.server.dao.cf.CalculatedFieldService;
 import org.thingsboard.server.dao.device.DeviceService;
@@ -172,6 +179,33 @@ public class DefaultCalculatedFieldCache implements CalculatedFieldCache {
         return entities;
     }
 
+    @Override
+    public void evictProfile(TenantId tenantId, EntityId entityId) {
+        log.debug("[{}] evict entity profile from cache.", entityId);
+        profileEntities.remove(entityId);
+    }
+
+    @Override
+    public void evictEntity(TenantId tenantId, EntityId entityId) {
+        calculatedFieldFetchLock.lock();
+        try {
+            profileEntities.forEach((profile, entityIds) -> entityIds.remove(entityId));
+            if (EntityType.ASSET.equals(entityId.getEntityType())) {
+                Asset asset = assetService.findAssetById(tenantId, (AssetId) entityId);
+                if (asset != null) {
+                    profileEntities.computeIfAbsent(asset.getAssetProfileId(), profileId -> new HashSet<>()).add(entityId);
+                }
+            } else {
+                Device device = deviceService.findDeviceById(tenantId, (DeviceId) entityId);
+                if (device != null) {
+                    profileEntities.computeIfAbsent(device.getDeviceProfileId(), profileId -> new HashSet<>()).add(entityId);
+                }
+            }
+        } finally {
+            calculatedFieldFetchLock.unlock();
+        }
+    }
+
     @Override
     public void addCalculatedField(TenantId tenantId, CalculatedFieldId calculatedFieldId) {
         calculatedFieldFetchLock.lock();

application/src/main/java/org/thingsboard/server/service/cf/DefaultCalculatedFieldExecutionService.java

@@ -17,7 +17,6 @@ package org.thingsboard.server.service.cf;
 
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.node.ObjectNode;
-import com.google.common.collect.Lists;
 import com.google.common.util.concurrent.FutureCallback;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
@@ -36,12 +35,12 @@ import org.thingsboard.common.util.ThingsBoardExecutors;
 import org.thingsboard.rule.engine.api.AttributesSaveRequest;
 import org.thingsboard.rule.engine.api.TimeseriesSaveRequest;
 import org.thingsboard.server.cluster.TbClusterService;
+import org.thingsboard.server.common.data.AttributeScope;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.cf.CalculatedField;
 import org.thingsboard.server.common.data.cf.CalculatedFieldLink;
 import org.thingsboard.server.common.data.cf.CalculatedFieldType;
 import org.thingsboard.server.common.data.cf.configuration.Argument;
-import org.thingsboard.server.common.data.cf.configuration.ArgumentType;
 import org.thingsboard.server.common.data.cf.configuration.OutputType;
 import org.thingsboard.server.common.data.id.AssetId;
 import org.thingsboard.server.common.data.id.CalculatedFieldId;
@@ -62,7 +61,6 @@ import org.thingsboard.server.common.data.kv.StringDataEntry;
 import org.thingsboard.server.common.data.kv.TimeseriesSaveResult;
 import org.thingsboard.server.common.data.kv.TsKvEntry;
 import org.thingsboard.server.common.data.msg.TbMsgType;
-import org.thingsboard.server.common.data.page.PageDataIterable;
 import org.thingsboard.server.common.msg.TbMsg;
 import org.thingsboard.server.common.msg.TbMsgMetaData;
 import org.thingsboard.server.common.msg.queue.ServiceType;
@@ -72,14 +70,17 @@ import org.thingsboard.server.common.util.ProtoUtils;
 import org.thingsboard.server.dao.attributes.AttributesService;
 import org.thingsboard.server.dao.cf.CalculatedFieldService;
 import org.thingsboard.server.dao.timeseries.TimeseriesService;
+import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.gen.transport.TransportProtos.AttributeScopeProto;
+import org.thingsboard.server.gen.transport.TransportProtos.AttributeValueProto;
 import org.thingsboard.server.gen.transport.TransportProtos.CalculatedFieldEntityUpdateMsgProto;
-import org.thingsboard.server.gen.transport.TransportProtos.CalculatedFieldIdProto;
+import org.thingsboard.server.gen.transport.TransportProtos.CalculatedFieldLinkedTelemetryMsgProto;
 import org.thingsboard.server.gen.transport.TransportProtos.CalculatedFieldTelemetryMsgProto;
 import org.thingsboard.server.gen.transport.TransportProtos.ComponentLifecycleEvent;
 import org.thingsboard.server.gen.transport.TransportProtos.ComponentLifecycleMsgProto;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCalculatedFieldMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCalculatedFieldNotificationMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.TsKvProto;
 import org.thingsboard.server.queue.TbQueueCallback;
 import org.thingsboard.server.queue.TbQueueMsgMetadata;
 import org.thingsboard.server.service.cf.ctx.CalculatedFieldEntityCtx;
@@ -92,7 +93,9 @@ import org.thingsboard.server.service.cf.ctx.state.ScriptCalculatedFieldState;
 import org.thingsboard.server.service.cf.ctx.state.SimpleCalculatedFieldState;
 import org.thingsboard.server.service.cf.ctx.state.SingleValueArgumentEntry;
 import org.thingsboard.server.service.cf.ctx.state.TsRollingArgumentEntry;
+import org.thingsboard.server.service.cf.telemetry.CalculatedFieldAttributeUpdateRequest;
 import org.thingsboard.server.service.cf.telemetry.CalculatedFieldTelemetryUpdateRequest;
+import org.thingsboard.server.service.cf.telemetry.CalculatedFieldTimeSeriesUpdateRequest;
 import org.thingsboard.server.service.partition.AbstractPartitionBasedService;
 import org.thingsboard.server.service.profile.TbAssetProfileCache;
 import org.thingsboard.server.service.profile.TbDeviceProfileCache;
@@ -102,12 +105,13 @@ import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Optional;
 import java.util.Set;
 import java.util.UUID;
-import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutionException;
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 import java.util.function.Supplier;
@@ -161,7 +165,6 @@ public class DefaultCalculatedFieldExecutionService extends AbstractPartitionBas
                 Math.max(4, Runtime.getRuntime().availableProcessors()), "calculated-field"));
         calculatedFieldCallbackExecutor = MoreExecutors.listeningDecorator(ThingsBoardExecutors.newWorkStealingPool(
                 Math.max(4, Runtime.getRuntime().availableProcessors()), "calculated-field-callback"));
-        scheduledExecutor.submit(() -> states.putAll(stateService.restoreStates()));
     }
 
     @PreDestroy
@@ -186,22 +189,22 @@ public class DefaultCalculatedFieldExecutionService extends AbstractPartitionBas
     }
 
     @Override
-    public void pushRequestToQueue(TimeseriesSaveRequest request, TimeseriesSaveResult result) {
+    public void pushRequestToQueue(TimeseriesSaveRequest request, TimeseriesSaveResult result, FutureCallback<Void> callback) {
         var tenantId = request.getTenantId();
         var entityId = request.getEntityId();
         //TODO: 1. check that request entity has calculated fields for entity or profile. If yes - push to corresponding partitions;
         //TODO: 2. check that request entity has calculated field links. If yes - push to corresponding partitions;
         //TODO: in 1 and 2 we should do the check as quick as possible. Should we also check the field/link keys?;
         checkEntityAndPushToQueue(tenantId, entityId, cf -> cf.matches(request.getEntries()), cf -> cf.linkMatches(entityId, request.getEntries()),
-                () -> toCalculatedFieldTelemetryMsgProto(request, result), request.getCallback());
+                () -> toCalculatedFieldTelemetryMsgProto(request, result), callback);
     }
 
     @Override
-    public void pushRequestToQueue(AttributesSaveRequest request, List<Long> result) {
+    public void pushRequestToQueue(AttributesSaveRequest request, List<Long> result, FutureCallback<Void> callback) {
         var tenantId = request.getTenantId();
         var entityId = request.getEntityId();
         checkEntityAndPushToQueue(tenantId, entityId, cf -> cf.matches(request.getEntries(), request.getScope()), cf -> cf.linkMatches(entityId, request.getEntries(), request.getScope()),
-                () -> toCalculatedFieldTelemetryMsgProto(request, result), request.getCallback());
+                () -> toCalculatedFieldTelemetryMsgProto(request, result), callback);
     }
 
     private void checkEntityAndPushToQueue(TenantId tenantId, EntityId entityId,
@@ -235,63 +238,82 @@ public class DefaultCalculatedFieldExecutionService extends AbstractPartitionBas
     }
 
     @Override
-    protected Map<TopicPartitionInfo, List<ListenableFuture<?>>> onAddedPartitions(Set<TopicPartitionInfo> addedPartitions) {
-        var result = new HashMap<TopicPartitionInfo, List<ListenableFuture<?>>>();
-        PageDataIterable<CalculatedField> cfs = new PageDataIterable<>(calculatedFieldService::findAllCalculatedFields, initFetchPackSize);
-        Map<TopicPartitionInfo, List<CalculatedFieldEntityCtxId>> tpiTargetEntityMap = new HashMap<>();
-
-        for (CalculatedField cf : cfs) {
-
-            Consumer<EntityId> resolvePartition = entityId -> {
-                TopicPartitionInfo tpi;
-                try {
-                    tpi = partitionService.resolve(ServiceType.TB_RULE_ENGINE, cf.getTenantId(), entityId);
-                    if (addedPartitions.contains(tpi) && states.keySet().stream().noneMatch(ctxId -> ctxId.cfId().equals(cf.getId()))) {
-                        tpiTargetEntityMap.computeIfAbsent(tpi, k -> new ArrayList<>()).add(new CalculatedFieldEntityCtxId(cf.getId(), entityId));
-                    }
-                } catch (Exception e) {
-                    log.warn("Failed to resolve partition for CalculatedFieldEntityCtxId: entityId=[{}], tenantId=[{}]. Reason: {}",
-                            entityId, cf.getTenantId(), e.getMessage());
-                }
-            };
-
-            EntityId cfEntityId = cf.getEntityId();
-            if (isProfileEntity(cfEntityId)) {
-                calculatedFieldCache.getEntitiesByProfile(cf.getTenantId(), cfEntityId).forEach(resolvePartition);
-            } else {
-                resolvePartition.accept(cfEntityId);
-            }
+    public ListenableFuture<CalculatedFieldState> fetchStateFromDb(CalculatedFieldCtx ctx, EntityId entityId) {
+        Map<String, ListenableFuture<ArgumentEntry>> argFutures = new HashMap<>();
+        for (var entry : ctx.getArguments().entrySet()) {
+            var argEntityId = entry.getValue().getRefEntityId() != null ? entry.getValue().getRefEntityId() : entityId;
+            var argValueFuture = fetchKvEntry(ctx.getTenantId(), argEntityId, entry.getValue());
+            argFutures.put(entry.getKey(), argValueFuture);
         }
-
-        for (var entry : tpiTargetEntityMap.entrySet()) {
-            for (List<CalculatedFieldEntityCtxId> partition : Lists.partition(entry.getValue(), 1000)) {
-                log.info("[{}] Submit task for CalculatedFields: {}", entry.getKey(), partition.size());
-                var future = calculatedFieldExecutor.submit(() -> {
-                    try {
-                        for (CalculatedFieldEntityCtxId ctxId : partition) {
-                            restoreState(ctxId.cfId(), ctxId.entityId());
-                        }
-                    } catch (Throwable t) {
-                        log.error("Unexpected exception while restoring CalculatedField states", t);
-                        throw t;
-                    }
-                });
-                result.computeIfAbsent(entry.getKey(), k -> new ArrayList<>()).add(future);
-            }
-        }
-        return result;
+        return Futures.whenAllComplete(argFutures.values()).call(() -> {
+            var result = createStateByType(ctx.getCfType());
+            result.updateState(argFutures.entrySet().stream()
+                    .collect(Collectors.toMap(
+                            Entry::getKey, // Keep the key as is
+                            entry -> {
+                                try {
+                                    // Resolve the future to get the value
+                                    return entry.getValue().get();
+                                } catch (ExecutionException | InterruptedException e) {
+                                    throw new RuntimeException("Error getting future result for key: " + entry.getKey(), e);
+                                }
+                            }
+                    )));
+            return result;
+        }, calculatedFieldCallbackExecutor);
     }
 
-    private void restoreState(CalculatedFieldId calculatedFieldId, EntityId entityId) {
-        CalculatedFieldEntityCtxId ctxId = new CalculatedFieldEntityCtxId(calculatedFieldId, entityId);
-        CalculatedFieldEntityCtx restoredCtx = stateService.restoreState(ctxId);
+    @Override
+    public void pushStateToStorage(CalculatedFieldEntityCtxId stateId, CalculatedFieldState state, TbCallback callback) {
+        stateService.persistState(stateId, state, callback);
+    }
 
-        if (restoredCtx != null) {
-            states.put(ctxId, restoredCtx);
-            log.info("Restored state for CalculatedField [{}]", calculatedFieldId);
-        } else {
-            log.warn("No state found for CalculatedField [{}], entity [{}].", calculatedFieldId, entityId);
-        }
+    @Override
+    protected Map<TopicPartitionInfo, List<ListenableFuture<?>>> onAddedPartitions(Set<TopicPartitionInfo> addedPartitions) {
+        var result = new HashMap<TopicPartitionInfo, List<ListenableFuture<?>>>();
+//        PageDataIterable<CalculatedField> cfs = new PageDataIterable<>(calculatedFieldService::findAllCalculatedFields, initFetchPackSize);
+//        Map<TopicPartitionInfo, List<CalculatedFieldEntityCtxId>> tpiTargetEntityMap = new HashMap<>();
+//
+//        for (CalculatedField cf : cfs) {
+//
+//            Consumer<EntityId> resolvePartition = entityId -> {
+//                TopicPartitionInfo tpi;
+//                try {
+//                    tpi = partitionService.resolve(ServiceType.TB_RULE_ENGINE, cf.getTenantId(), entityId);
+//                    if (addedPartitions.contains(tpi) && states.keySet().stream().noneMatch(ctxId -> ctxId.cfId().equals(cf.getId()))) {
+//                        tpiTargetEntityMap.computeIfAbsent(tpi, k -> new ArrayList<>()).add(new CalculatedFieldEntityCtxId(cf.getId(), entityId));
+//                    }
+//                } catch (Exception e) {
+//                    log.warn("Failed to resolve partition for CalculatedFieldEntityCtxId: entityId=[{}], tenantId=[{}]. Reason: {}",
+//                            entityId, cf.getTenantId(), e.getMessage());
+//                }
+//            };
+//
+//            EntityId cfEntityId = cf.getEntityId();
+//            if (isProfileEntity(cfEntityId)) {
+//                calculatedFieldCache.getEntitiesByProfile(cf.getTenantId(), cfEntityId).forEach(resolvePartition);
+//            } else {
+//                resolvePartition.accept(cfEntityId);
+//            }
+//        }
+//
+//        for (var entry : tpiTargetEntityMap.entrySet()) {
+//            for (List<CalculatedFieldEntityCtxId> partition : Lists.partition(entry.getValue(), 1000)) {
+//                log.info("[{}] Submit task for CalculatedFields: {}", entry.getKey(), partition.size());
+//                var future = calculatedFieldExecutor.submit(() -> {
+//                    try {
+//                        for (CalculatedFieldEntityCtxId ctxId : partition) {
+//                            restoreState(ctxId.cfId(), ctxId.entityId());
+//                        }
+//                    } catch (Throwable t) {
+//                        log.error("Unexpected exception while restoring CalculatedField states", t);
+//                        throw t;
+//                    }
+//                });
+//                result.computeIfAbsent(entry.getKey(), k -> new ArrayList<>()).add(future);
+//            }
+//        }
+        return result;
     }
 
     @Override
@@ -334,7 +356,7 @@ public class DefaultCalculatedFieldExecutionService extends AbstractPartitionBas
                         initializeStateForEntity(calculatedFieldCtx, entityId, callback);
                     }
                     case ASSET_PROFILE, DEVICE_PROFILE -> {
-                        log.info("Initializing state for all entities in profile: tenantICalculatedFieldMsgProtod=[{}], profileId=[{}]", tenantId, entityId);
+                        log.info("Initializing state for all entities in profile: tenantId=[{}], profileId=[{}]", tenantId, entityId);
                         Map<String, Argument> commonArguments = calculatedFieldCtx.getArguments().entrySet().stream()
                                 .filter(entry -> entry.getValue().getRefEntityId() != null)
                                 .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
@@ -401,8 +423,9 @@ public class DefaultCalculatedFieldExecutionService extends AbstractPartitionBas
     }
 
     @Override
-    public void onTelemetryUpdate(CalculatedFieldTelemetryUpdateRequest request) {
+    public void onTelemetryUpdate(CalculatedFieldTelemetryMsgProto proto, TbCallback callback) {
         try {
+            CalculatedFieldTelemetryUpdateRequest request = fromProto(proto);
             EntityId entityId = request.getEntityId();
 
             if (supportedReferencedEntities.contains(entityId.getEntityType())) {
@@ -418,15 +441,12 @@ public class DefaultCalculatedFieldExecutionService extends AbstractPartitionBas
                     processCalculatedFieldLinks(request, tpiStatesToUpdate);
                     if (!tpiStatesToUpdate.isEmpty()) {
                         tpiStatesToUpdate.forEach((topicPartitionInfo, ctxIds) -> {
-                            TransportProtos.TelemetryUpdateMsgProto telemetryUpdateMsgProto = buildTelemetryUpdateMsgProto(request, ctxIds);
-                            clusterService.pushMsgToRuleEngine(topicPartitionInfo, UUID.randomUUID(), TransportProtos.ToRuleEngineMsg.newBuilder()
-                                    .setCfTelemetryUpdateMsg(telemetryUpdateMsgProto).build(), null);
+                            CalculatedFieldLinkedTelemetryMsgProto linkedTelemetryMsgProto = buildLinkedTelemetryMsgProto(proto, ctxIds);
+                            clusterService.pushMsgToCalculatedFields(topicPartitionInfo, UUID.randomUUID(), ToCalculatedFieldMsg.newBuilder().setLinkedTelemetryMsg(linkedTelemetryMsgProto).build(), null);
                         });
                     }
                 } else {
-                    TransportProtos.TelemetryUpdateMsgProto telemetryUpdateMsgProto = buildTelemetryUpdateMsgProto(request);
-                    clusterService.pushMsgToRuleEngine(tpi, UUID.randomUUID(), TransportProtos.ToRuleEngineMsg.newBuilder()
-                            .setCfTelemetryUpdateMsg(telemetryUpdateMsgProto).build(), null);
+                    clusterService.pushMsgToCalculatedFields(tpi, UUID.randomUUID(), ToCalculatedFieldMsg.newBuilder().setTelemetryMsg(proto).build(), null);
                 }
             }
         } catch (Exception e) {
@@ -475,41 +495,41 @@ public class DefaultCalculatedFieldExecutionService extends AbstractPartitionBas
             }
         } else {
             List<CalculatedFieldEntityCtxId> ctxIds = tpiStates.computeIfAbsent(targetEntityTpi, k -> new ArrayList<>());
-            ctxIds.add(new CalculatedFieldEntityCtxId(ctx.getCfId(), targetEntity));
+            ctxIds.add(new CalculatedFieldEntityCtxId(ctx.getTenantId(), ctx.getCfId(), targetEntity));
         }
     }
 
-//    @Override
-//    public void onTelemetryUpdateMsg(TransportProtos.TelemetryUpdateMsgProto proto) {
-//        try {
-//            CalculatedFieldTelemetryUpdateRequest request = fromProto(proto);
-//
-//            if (proto.getLinksList().isEmpty()) {
-//                onTelemetryUpdate(request);
-//                return;
-//            }
-//
-//            proto.getLinksList().forEach(ctxIdProto -> {
-//                CalculatedFieldId calculatedFieldId = new CalculatedFieldId(new UUID(ctxIdProto.getCalculatedFieldIdMSB(), ctxIdProto.getCalculatedFieldIdLSB()));
-//                CalculatedFieldCtx ctx = calculatedFieldCache.getCalculatedFieldCtx(calculatedFieldId, tbelInvokeService);
-//
-//                Map<String, KvEntry> updatedTelemetry = request.getMappedTelemetry(ctx, request.getEntityId());
-//                if (!updatedTelemetry.isEmpty()) {
-//                    EntityId targetEntityId = EntityIdFactory.getByTypeAndUuid(ctxIdProto.getEntityType(), new UUID(ctxIdProto.getEntityIdMSB(), ctxIdProto.getEntityIdLSB()));
-//                    executeTelemetryUpdate(ctx, targetEntityId, request.getPreviousCalculatedFieldIds(), updatedTelemetry);
-//                }
-//            });
-//        } catch (Exception e) {
-//            log.trace("Failed to process telemetry update msg: [{}]", proto, e);
-//        }
-//    }
+    @Override
+    public void onTelemetryUpdate(CalculatedFieldLinkedTelemetryMsgProto proto, TbCallback callback) {
+        try {
+            CalculatedFieldTelemetryUpdateRequest request = fromProto(proto.getMsg());
+
+            if (proto.getLinksList().isEmpty()) {
+                onTelemetryUpdate(proto, callback);
+                return;
+            }
+
+            proto.getLinksList().forEach(ctxIdProto -> {
+                CalculatedFieldId calculatedFieldId = new CalculatedFieldId(new UUID(ctxIdProto.getCalculatedFieldIdMSB(), ctxIdProto.getCalculatedFieldIdLSB()));
+                CalculatedFieldCtx ctx = calculatedFieldCache.getCalculatedFieldCtx(calculatedFieldId);
+
+                Map<String, KvEntry> updatedTelemetry = request.getMappedTelemetry(ctx, request.getEntityId());
+                if (!updatedTelemetry.isEmpty()) {
+                    EntityId targetEntityId = EntityIdFactory.getByTypeAndUuid(ctxIdProto.getEntityType(), new UUID(ctxIdProto.getEntityIdMSB(), ctxIdProto.getEntityIdLSB()));
+                    executeTelemetryUpdate(ctx, targetEntityId, request.getPreviousCalculatedFieldIds(), updatedTelemetry);
+                }
+            });
+        } catch (Exception e) {
+            log.trace("Failed to process telemetry update msg: [{}]", proto, e);
+        }
+    }
 
     private void executeTelemetryUpdate(CalculatedFieldCtx cfCtx, EntityId entityId, List<CalculatedFieldId> previousCalculatedFieldIds, Map<String, KvEntry> updatedTelemetry) {
         log.info("Received telemetry update msg: tenantId=[{}], entityId=[{}], calculatedFieldId=[{}]", cfCtx.getTenantId(), entityId, cfCtx.getCfId());
         Map<String, ArgumentEntry> argumentValues = updatedTelemetry.entrySet().stream()
                 .collect(Collectors.toMap(Map.Entry::getKey, entry -> ArgumentEntry.createSingleValueArgument(entry.getValue())));
 
-        updateOrInitializeState(cfCtx, entityId, argumentValues, previousCalculatedFieldIds);
+//        updateOrInitializeState(cfCtx, entityId, argumentValues, previousCalculatedFieldIds);
     }
 
     @Override
@@ -553,9 +573,6 @@ public class DefaultCalculatedFieldExecutionService extends AbstractPartitionBas
 
     private void clearState(CalculatedFieldId calculatedFieldId, EntityId entityId) {
         log.warn("Executing clearState, calculatedFieldId=[{}], entityId=[{}]", calculatedFieldId, entityId);
-        CalculatedFieldEntityCtxId ctxId = new CalculatedFieldEntityCtxId(calculatedFieldId, entityId);
-        states.remove(ctxId);
-        stateService.removeState(ctxId);
     }
 
     private void initializeStateForEntityByProfile(EntityId entityId, EntityId profileId, TbCallback callback) {
@@ -585,7 +602,7 @@ public class DefaultCalculatedFieldExecutionService extends AbstractPartitionBas
         Futures.addCallback(Futures.allAsList(futures), new FutureCallback<>() {
             @Override
             public void onSuccess(List<ArgumentEntry> results) {
-                updateOrInitializeState(calculatedFieldCtx, entityId, argumentValues, new ArrayList<>());
+//                updateOrInitializeState(calculatedFieldCtx, entityId, argumentValues, new ArrayList<>());
                 callback.onSuccess();
             }
 
@@ -597,96 +614,83 @@ public class DefaultCalculatedFieldExecutionService extends AbstractPartitionBas
         }, calculatedFieldCallbackExecutor);
     }
 
-    private void updateOrInitializeState(CalculatedFieldCtx calculatedFieldCtx, EntityId entityId, Map<String, ArgumentEntry> argumentValues, List<CalculatedFieldId> previousCalculatedFieldIds) {
-        CalculatedFieldId cfId = calculatedFieldCtx.getCfId();
-        Map<String, ArgumentEntry> argumentsMap = new HashMap<>(argumentValues);
-
-        CalculatedFieldEntityCtxId entityCtxId = new CalculatedFieldEntityCtxId(cfId, entityId);
-
-        states.compute(entityCtxId, (ctxId, ctx) -> {
-            CalculatedFieldEntityCtx calculatedFieldEntityCtx = ctx != null ? ctx : fetchCalculatedFieldEntityState(ctxId, calculatedFieldCtx.getCfType());
-
-            CompletableFuture<Void> updateFuture = new CompletableFuture<>();
-
-            Consumer<CalculatedFieldState> performUpdateState = (state) -> {
-                if (state.updateState(argumentsMap)) {
-                    calculatedFieldEntityCtx.setState(state);
-                    stateService.persistState(entityCtxId, calculatedFieldEntityCtx);
-                    Map<String, ArgumentEntry> arguments = state.getArguments();
-                    boolean allArgsPresent = arguments.keySet().containsAll(calculatedFieldCtx.getArguments().keySet()) &&
-                            !arguments.containsValue(SingleValueArgumentEntry.EMPTY) && !arguments.containsValue(TsRollingArgumentEntry.EMPTY);
-                    if (allArgsPresent) {
-                        performCalculation(calculatedFieldCtx, state, entityId, previousCalculatedFieldIds);
-                    }
-                    log.info("Successfully updated state: calculatedFieldId=[{}], entityId=[{}]", calculatedFieldCtx.getCfId(), entityId);
-                }
-                updateFuture.complete(null);
-            };
-
-            CalculatedFieldState state = calculatedFieldEntityCtx.getState();
-
-            boolean allKeysPresent = argumentsMap.keySet().containsAll(calculatedFieldCtx.getArguments().keySet());
-            boolean requiresTsRollingUpdate = calculatedFieldCtx.getArguments().values().stream()
-                    .anyMatch(argument -> ArgumentType.TS_ROLLING.equals(argument.getRefEntityKey().getType()) && state.getArguments().get(argument.getRefEntityKey().getKey()) == null);
-
-            if (!allKeysPresent || requiresTsRollingUpdate) {
-                Map<String, Argument> missingArguments = calculatedFieldCtx.getArguments().entrySet().stream()
-                        .filter(entry -> !argumentsMap.containsKey(entry.getKey()) || (ArgumentType.TS_ROLLING.equals(entry.getValue().getRefEntityKey().getType()) && state.getArguments().get(entry.getKey()) == null))
-                        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
-
-                fetchArguments(calculatedFieldCtx.getTenantId(), entityId, missingArguments, argumentsMap::putAll)
-                        .addListener(() -> performUpdateState.accept(state),
-                                calculatedFieldCallbackExecutor);
-            } else {
-                performUpdateState.accept(state);
-            }
-
-            try {
-                updateFuture.join();
-            } catch (Exception e) {
-                log.trace("Failed to update state for ctxId [{}].", ctxId, e);
-                throw new RuntimeException("Failed to update or initialize state.", e);
-            }
-
-            return calculatedFieldEntityCtx;
-        });
-    }
-
-    private void performCalculation(CalculatedFieldCtx calculatedFieldCtx, CalculatedFieldState state, EntityId entityId, List<CalculatedFieldId> previousCalculatedFieldIds) {
-        ListenableFuture<CalculatedFieldResult> resultFuture = state.performCalculation(calculatedFieldCtx);
-        Futures.addCallback(resultFuture, new FutureCallback<>() {
-            @Override
-            public void onSuccess(CalculatedFieldResult result) {
-                if (result != null) {
-                    pushMsgToRuleEngine(calculatedFieldCtx.getTenantId(), calculatedFieldCtx.getCfId(), entityId, result, previousCalculatedFieldIds);
-                }
-            }
-
-            @Override
-            public void onFailure(Throwable t) {
-                log.warn("[{}] Failed to perform calculation. entityId: [{}]", calculatedFieldCtx.getCfId(), entityId, t);
-            }
-        }, MoreExecutors.directExecutor());
-    }
+//    private void updateOrInitializeState(CalculatedFieldCtx calculatedFieldCtx, EntityId entityId, Map<String, ArgumentEntry> argumentValues, List<CalculatedFieldId> previousCalculatedFieldIds) {
+//        CalculatedFieldId cfId = calculatedFieldCtx.getCfId();
+//        Map<String, ArgumentEntry> argumentsMap = new HashMap<>(argumentValues);
+//
+//        CalculatedFieldEntityCtxId entityCtxId = new CalculatedFieldEntityCtxId(cfId, entityId);
+//
+//        states.compute(entityCtxId, (ctxId, ctx) -> {
+//            CalculatedFieldEntityCtx calculatedFieldEntityCtx = ctx != null ? ctx : fetchCalculatedFieldEntityState(ctxId, calculatedFieldCtx.getCfType());
+//
+//            CompletableFuture<Void> updateFuture = new CompletableFuture<>();
+//
+//            Consumer<CalculatedFieldState> performUpdateState = (state) -> {
+//                if (state.updateState(argumentsMap)) {
+//                    calculatedFieldEntityCtx.setState(state);
+//                    stateService.persistState(entityCtxId, calculatedFieldEntityCtx);
+//                    Map<String, ArgumentEntry> arguments = state.getArguments();
+//                    boolean allArgsPresent = arguments.keySet().containsAll(calculatedFieldCtx.getArguments().keySet()) &&
+//                            !arguments.containsValue(SingleValueArgumentEntry.EMPTY) && !arguments.containsValue(TsRollingArgumentEntry.EMPTY);
+//                    if (allArgsPresent) {
+//                        performCalculation(calculatedFieldCtx, state, entityId, previousCalculatedFieldIds);
+//                    }
+//                    log.info("Successfully updated state: calculatedFieldId=[{}], entityId=[{}]", calculatedFieldCtx.getCfId(), entityId);
+//                }
+//                updateFuture.complete(null);
+//            };
+//
+//            CalculatedFieldState state = calculatedFieldEntityCtx.getState();
+//
+//            boolean allKeysPresent = argumentsMap.keySet().containsAll(calculatedFieldCtx.getArguments().keySet());
+//            boolean requiresTsRollingUpdate = calculatedFieldCtx.getArguments().values().stream()
+//                    .anyMatch(argument -> ArgumentType.TS_ROLLING.equals(argument.getRefEntityKey().getType()) && state.getArguments().get(argument.getRefEntityKey().getKey()) == null);
+//
+//            if (!allKeysPresent || requiresTsRollingUpdate) {
+//                Map<String, Argument> missingArguments = calculatedFieldCtx.getArguments().entrySet().stream()
+//                        .filter(entry -> !argumentsMap.containsKey(entry.getKey()) || (ArgumentType.TS_ROLLING.equals(entry.getValue().getRefEntityKey().getType()) && state.getArguments().get(entry.getKey()) == null))
+//                        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+//
+//                fetchArguments(calculatedFieldCtx.getTenantId(), entityId, missingArguments, argumentsMap::putAll)
+//                        .addListener(() -> performUpdateState.accept(state),
+//                                calculatedFieldCallbackExecutor);
+//            } else {
+//                performUpdateState.accept(state);
+//            }
+//
+//            try {
+//                updateFuture.join();
+//            } catch (Exception e) {
+//                log.trace("Failed to update state for ctxId [{}].", ctxId, e);
+//                throw new RuntimeException("Failed to update or initialize state.", e);
+//            }
+//
+//            return calculatedFieldEntityCtx;
+//        });
+//    }
 
-    private void pushMsgToRuleEngine(TenantId tenantId, CalculatedFieldId calculatedFieldId, EntityId originatorId, CalculatedFieldResult calculatedFieldResult, List<CalculatedFieldId> previousCalculatedFieldIds) {
+    @Override
+    public void pushMsgToRuleEngine(TenantId tenantId, EntityId entityId, CalculatedFieldResult calculatedFieldResult, List<CalculatedFieldId> cfIds, TbCallback callback) {
         try {
             OutputType type = calculatedFieldResult.getType();
             TbMsgType msgType = OutputType.ATTRIBUTES.equals(type) ? TbMsgType.POST_ATTRIBUTES_REQUEST : TbMsgType.POST_TELEMETRY_REQUEST;
             TbMsgMetaData md = OutputType.ATTRIBUTES.equals(type) ? new TbMsgMetaData(Map.of(SCOPE, calculatedFieldResult.getScope().name())) : TbMsgMetaData.EMPTY;
             ObjectNode payload = createJsonPayload(calculatedFieldResult);
-            if (previousCalculatedFieldIds != null && previousCalculatedFieldIds.contains(calculatedFieldId)) {
-                throw new IllegalArgumentException("Calculated field [" + calculatedFieldId.getId() + "] refers to itself, causing an infinite loop.");
-            }
-            List<CalculatedFieldId> calculatedFieldIds = previousCalculatedFieldIds != null
-                    ? new ArrayList<>(previousCalculatedFieldIds)
-                    : new ArrayList<>();
-            calculatedFieldIds.add(calculatedFieldId);
-            TbMsg msg = TbMsg.newMsg().type(msgType).originator(originatorId).previousCalculatedFieldIds(calculatedFieldIds).metaData(md).data(JacksonUtil.writeValueAsString(payload)).build();
-            clusterService.pushMsgToRuleEngine(tenantId, originatorId, msg, null);
-            log.info("Pushed message to rule engine: originatorId=[{}]", originatorId);
+            TbMsg msg = TbMsg.newMsg().type(msgType).originator(entityId).previousCalculatedFieldIds(cfIds).metaData(md).data(JacksonUtil.writeValueAsString(payload)).build();
+            clusterService.pushMsgToRuleEngine(tenantId, entityId, msg, new TbQueueCallback() {
+                @Override
+                public void onSuccess(TbQueueMsgMetadata metadata) {
+                    callback.onSuccess();
+                    log.trace("[{}][{}] Pushed message to rule engine: {} ", tenantId, entityId, msg);
+                }
+
+                @Override
+                public void onFailure(Throwable t) {
+                    callback.onFailure(t);
+                }
+            });
         } catch (Exception e) {
-            log.warn("[{}] Failed to push message to rule engine. CalculatedFieldResult: {}", originatorId, calculatedFieldResult, e);
+            log.warn("[{}][{}] Failed to push message to rule engine. CalculatedFieldResult: {}", tenantId, entityId, calculatedFieldResult, e);
         }
     }
 
@@ -753,23 +757,6 @@ public class DefaultCalculatedFieldExecutionService extends AbstractPartitionBas
         return Futures.transform(tsRollingFuture, tsRolling -> tsRolling == null ? TsRollingArgumentEntry.EMPTY : ArgumentEntry.createTsRollingArgument(tsRolling), calculatedFieldCallbackExecutor);
     }
 
-//    private TransportProtos.CalculatedFieldEntityCtxIdProto toProto(CalculatedFieldEntityCtxId ctxId) {
-//        return TransportProtos.CalculatedFieldEntityCtxIdProto.newBuilder()
-//                .setCalculatedFieldIdMSB(ctxId.cfId().getId().getMostSignificantBits())
-//                .setCalculatedFieldIdLSB(ctxId.cfId().getId().getLeastSignificantBits())
-//                .setEntityType(ctxId.entityId().getEntityType().name())
-//                .setEntityIdMSB(ctxId.entityId().getId().getMostSignificantBits())
-//                .setEntityIdLSB(ctxId.entityId().getId().getLeastSignificantBits())
-//                .build();
-//    }
-//
-//    private TransportProtos.CalculatedFieldIdProto toProto(CalculatedFieldId cfId) {
-//        return TransportProtos.CalculatedFieldIdProto.newBuilder()
-//                .setCalculatedFieldIdMSB(cfId.getId().getMostSignificantBits())
-//                .setCalculatedFieldIdLSB(cfId.getId().getLeastSignificantBits())
-//                .build();
-//    }
-
     private KvEntry createDefaultKvEntry(Argument argument) {
         String key = argument.getRefEntityKey().getKey();
         String defaultValue = argument.getDefaultValue();
@@ -782,15 +769,6 @@ public class DefaultCalculatedFieldExecutionService extends AbstractPartitionBas
         return new StringDataEntry(key, defaultValue);
     }
 
-    private CalculatedFieldEntityCtx fetchCalculatedFieldEntityState(CalculatedFieldEntityCtxId entityCtxId, CalculatedFieldType cfType) {
-        CalculatedFieldEntityCtx state = stateService.restoreState(entityCtxId);
-
-        if (state == null) {
-            return new CalculatedFieldEntityCtx(entityCtxId, createStateByType(cfType));
-        }
-        return state;
-    }
-
     private ObjectNode createJsonPayload(CalculatedFieldResult calculatedFieldResult) {
         ObjectNode payload = JacksonUtil.newObjectNode();
         Map<String, Object> resultMap = calculatedFieldResult.getResultMap();
@@ -821,22 +799,28 @@ public class DefaultCalculatedFieldExecutionService extends AbstractPartitionBas
         ToCalculatedFieldMsg.Builder msg = ToCalculatedFieldMsg.newBuilder();
 
         CalculatedFieldTelemetryMsgProto.Builder telemetryMsg = buildTelemetryMsgProto(request.getTenantId(), request.getEntityId(), request.getPreviousCalculatedFieldIds());
-        for (TsKvEntry entry : request.getEntries()) {
-            telemetryMsg.addTsData(ProtoUtils.toTsKvProto(entry));
+        List<TsKvEntry> entries = request.getEntries();
+        List<Long> versions = result.getVersions();
+        for (int i = 0; i < entries.size(); i++) {
+            long tsVersion = versions.get(i);
+            TsKvProto tsProto = ProtoUtils.toTsKvProto(entries.get(i)).toBuilder().setVersion(tsVersion).build();
+            telemetryMsg.addTsData(tsProto);
         }
         msg.setTelemetryMsg(telemetryMsg.build());
 
         return msg.build();
     }
 
-    private ToCalculatedFieldMsg toCalculatedFieldTelemetryMsgProto(AttributesSaveRequest request, List<Long> result) {
-        //TODO: IM Use result in both methods to update the versions of telemetry/attributes.
+    private ToCalculatedFieldMsg toCalculatedFieldTelemetryMsgProto(AttributesSaveRequest request, List<Long> versions) {
         ToCalculatedFieldMsg.Builder msg = ToCalculatedFieldMsg.newBuilder();
 
         CalculatedFieldTelemetryMsgProto.Builder telemetryMsg = buildTelemetryMsgProto(request.getTenantId(), request.getEntityId(), request.getPreviousCalculatedFieldIds());
         telemetryMsg.setScope(AttributeScopeProto.valueOf(request.getScope().name()));
-        for (AttributeKvEntry entry : request.getEntries()) {
-            telemetryMsg.addAttrData(ProtoUtils.toProto(entry));
+        List<AttributeKvEntry> entries = request.getEntries();
+        for (int i = 0; i < entries.size(); i++) {
+            long attrVersion = versions.get(i);
+            AttributeValueProto attrProto = ProtoUtils.toProto(entries.get(i)).toBuilder().setVersion(attrVersion).build();
+            telemetryMsg.addAttrData(attrProto);
         }
         msg.setTelemetryMsg(telemetryMsg.build());
 
@@ -853,16 +837,69 @@ public class DefaultCalculatedFieldExecutionService extends AbstractPartitionBas
         telemetryMsg.setEntityIdMSB(entityId.getId().getMostSignificantBits());
         telemetryMsg.setEntityIdLSB(entityId.getId().getLeastSignificantBits());
 
-        for (CalculatedFieldId cfId : calculatedFieldIds) {
-            CalculatedFieldIdProto.Builder calculatedFieldIdProto = CalculatedFieldIdProto.newBuilder();
-            calculatedFieldIdProto.setCalculatedFieldIdMSB(cfId.getId().getMostSignificantBits());
-            calculatedFieldIdProto.setCalculatedFieldIdLSB(cfId.getId().getLeastSignificantBits());
-            telemetryMsg.addPreviousCalculatedFields(calculatedFieldIdProto.build());
+        if(calculatedFieldIds != null) {
+            for (CalculatedFieldId cfId : calculatedFieldIds) {
+                telemetryMsg.addPreviousCalculatedFields(toProto(cfId));
+            }
         }
 
         return telemetryMsg;
     }
 
+    private CalculatedFieldLinkedTelemetryMsgProto buildLinkedTelemetryMsgProto(CalculatedFieldTelemetryMsgProto telemetryProto, List<CalculatedFieldEntityCtxId> links) {
+        TransportProtos.CalculatedFieldLinkedTelemetryMsgProto.Builder builder = TransportProtos.CalculatedFieldLinkedTelemetryMsgProto.newBuilder();
+        builder.setMsg(telemetryProto);
+        for (CalculatedFieldEntityCtxId link : links) {
+            builder.addLinks(toProto(link));
+        }
+        return builder.build();
+    }
+
+    private TransportProtos.CalculatedFieldEntityCtxIdProto toProto(CalculatedFieldEntityCtxId ctxId) {
+        return TransportProtos.CalculatedFieldEntityCtxIdProto.newBuilder()
+                .setCalculatedFieldIdMSB(ctxId.cfId().getId().getMostSignificantBits())
+                .setCalculatedFieldIdLSB(ctxId.cfId().getId().getLeastSignificantBits())
+                .setEntityType(ctxId.entityId().getEntityType().name())
+                .setEntityIdMSB(ctxId.entityId().getId().getMostSignificantBits())
+                .setEntityIdLSB(ctxId.entityId().getId().getLeastSignificantBits())
+                .build();
+    }
+
+    private TransportProtos.CalculatedFieldIdProto toProto(CalculatedFieldId cfId) {
+        return TransportProtos.CalculatedFieldIdProto.newBuilder()
+                .setCalculatedFieldIdMSB(cfId.getId().getMostSignificantBits())
+                .setCalculatedFieldIdLSB(cfId.getId().getLeastSignificantBits())
+                .build();
+    }
+
+    private CalculatedFieldTelemetryUpdateRequest fromProto(CalculatedFieldTelemetryMsgProto proto) {
+        TenantId tenantId = TenantId.fromUUID(new UUID(proto.getTenantIdMSB(), proto.getTenantIdLSB()));
+        EntityId entityId = EntityIdFactory.getByTypeAndUuid(proto.getEntityType(), new UUID(proto.getEntityIdMSB(), proto.getEntityIdLSB()));
+
+        if (!proto.getTsDataList().isEmpty()) {
+            List<TsKvEntry> updatedTelemetry = proto.getTsDataList().stream()
+                    .map(ProtoUtils::fromProto)
+                    .toList();
+            return new CalculatedFieldTimeSeriesUpdateRequest(
+                    tenantId, entityId, updatedTelemetry,
+                    proto.getPreviousCalculatedFieldsList().stream()
+                            .map(cfIdProto -> new CalculatedFieldId(
+                                    new UUID(cfIdProto.getCalculatedFieldIdMSB(), cfIdProto.getCalculatedFieldIdLSB())))
+                            .toList());
+        } else {
+            AttributeScope scope = AttributeScope.valueOf(proto.getScope().name());
+            List<AttributeKvEntry> updatedTelemetry = proto.getAttrDataList().stream()
+                    .map(ProtoUtils::fromProto)
+                    .toList();
+            return new CalculatedFieldAttributeUpdateRequest(
+                    tenantId, entityId, scope, updatedTelemetry,
+                    proto.getPreviousCalculatedFieldsList().stream()
+                            .map(cfIdProto -> new CalculatedFieldId(
+                                    new UUID(cfIdProto.getCalculatedFieldIdMSB(), cfIdProto.getCalculatedFieldIdLSB())))
+                            .toList());
+        }
+    }
+
     private static TbQueueCallback wrap(FutureCallback<Void> callback) {
         if (callback != null) {
             return new FutureCallbackWrapper(callback);

application/src/main/java/org/thingsboard/server/service/cf/DefaultCalculatedFieldInitService.java

@@ -0,0 +1,64 @@
+/**
+ * Copyright © 2016-2024 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.service.cf;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+import org.thingsboard.server.actors.ActorSystemContext;
+import org.thingsboard.server.actors.calculatedField.CalculatedFieldStateRestoreMsg;
+import org.thingsboard.server.common.data.cf.CalculatedField;
+import org.thingsboard.server.common.data.cf.CalculatedFieldLink;
+import org.thingsboard.server.common.data.page.PageDataIterable;
+import org.thingsboard.server.common.msg.cf.CalculatedFieldInitMsg;
+import org.thingsboard.server.common.msg.cf.CalculatedFieldLinkInitMsg;
+import org.thingsboard.server.dao.cf.CalculatedFieldService;
+import org.thingsboard.server.queue.util.AfterStartUp;
+import org.thingsboard.server.queue.util.TbRuleEngineComponent;
+import org.thingsboard.server.service.cf.ctx.CalculatedFieldStateService;
+
+@Service
+@TbRuleEngineComponent
+@RequiredArgsConstructor
+public class DefaultCalculatedFieldInitService implements CalculatedFieldInitService {
+
+    private final CalculatedFieldService calculatedFieldService;
+    private final CalculatedFieldStateService stateService;
+    private final ActorSystemContext actorSystemContext;
+
+    @Value("${calculated_fields.init_fetch_pack_size:50000}")
+    @Getter
+    private int initFetchPackSize;
+
+    @AfterStartUp(order = AfterStartUp.CF_INIT_SERVICE)
+    public void initCalculatedFieldDefinitions() {
+        PageDataIterable<CalculatedField> cfs = new PageDataIterable<>(calculatedFieldService::findAllCalculatedFields, initFetchPackSize);
+        cfs.forEach(cf -> actorSystemContext.tell(new CalculatedFieldInitMsg(cf.getTenantId(), cf)));
+        PageDataIterable<CalculatedFieldLink> cfls = new PageDataIterable<>(calculatedFieldService::findAllCalculatedFieldLinks, initFetchPackSize);
+        cfls.forEach(link -> actorSystemContext.tell(new CalculatedFieldLinkInitMsg(link.getTenantId(), link)));
+        //TODO: combine with the DefaultCalculatedFieldCache.
+
+    }
+
+    @AfterStartUp(order = AfterStartUp.CF_STATE_RESTORE_SERVICE)
+    public void initCalculatedFieldStates() {
+        stateService.restoreStates().forEach((k, v) -> actorSystemContext.tell(new CalculatedFieldStateRestoreMsg(k, v)));
+    }
+
+
+
+}

application/src/main/java/org/thingsboard/server/service/cf/ctx/CalculatedFieldEntityCtxId.java

@@ -17,6 +17,7 @@ package org.thingsboard.server.service.cf.ctx;
 
 import org.thingsboard.server.common.data.id.CalculatedFieldId;
 import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
 
-public record CalculatedFieldEntityCtxId(CalculatedFieldId cfId, EntityId entityId) {
+public record CalculatedFieldEntityCtxId(TenantId tenantId, CalculatedFieldId cfId, EntityId entityId) {
 }

application/src/main/java/org/thingsboard/server/service/cf/ctx/CalculatedFieldStateService.java

@@ -15,15 +15,18 @@
  */
 package org.thingsboard.server.service.cf.ctx;
 
+import org.thingsboard.server.common.msg.queue.TbCallback;
+import org.thingsboard.server.service.cf.ctx.state.CalculatedFieldState;
+
 import java.util.Map;
 
 public interface CalculatedFieldStateService {
 
-    Map<CalculatedFieldEntityCtxId, CalculatedFieldEntityCtx> restoreStates();
+    Map<CalculatedFieldEntityCtxId, CalculatedFieldState> restoreStates();
 
-    CalculatedFieldEntityCtx restoreState(CalculatedFieldEntityCtxId ctxId);
+    CalculatedFieldState restoreState(CalculatedFieldEntityCtxId ctxId);
 
-    void persistState(CalculatedFieldEntityCtxId ctxId, CalculatedFieldEntityCtx state);
+    void persistState(CalculatedFieldEntityCtxId stateId, CalculatedFieldState state, TbCallback callback);
 
     void removeState(CalculatedFieldEntityCtxId ctxId);
 

application/src/main/java/org/thingsboard/server/service/cf/ctx/state/BaseCalculatedFieldState.java

@@ -66,4 +66,9 @@ public abstract class BaseCalculatedFieldState implements CalculatedFieldState {
         return stateUpdated;
     }
 
+    @Override
+    public boolean isReady() {
+        //TODO: IM
+        return true;
+    }
 }

application/src/main/java/org/thingsboard/server/service/cf/ctx/state/CalculatedFieldCtx.java

@@ -31,6 +31,7 @@ import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.kv.AttributeKvEntry;
 import org.thingsboard.server.common.data.kv.TsKvEntry;
 import org.thingsboard.server.common.data.util.TbPair;
+import org.thingsboard.server.gen.transport.TransportProtos.TsKvProto;
 
 import java.util.ArrayList;
 import java.util.HashMap;

application/src/main/java/org/thingsboard/server/service/cf/ctx/state/CalculatedFieldState.java

@@ -44,4 +44,6 @@ public interface CalculatedFieldState {
 
     ListenableFuture<CalculatedFieldResult> performCalculation(CalculatedFieldCtx ctx);
 
+    @JsonIgnore
+    boolean isReady();
 }

application/src/main/java/org/thingsboard/server/service/cf/ctx/state/RocksDBStateService.java

@@ -19,6 +19,7 @@ import lombok.RequiredArgsConstructor;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
 import org.springframework.stereotype.Service;
 import org.thingsboard.common.util.JacksonUtil;
+import org.thingsboard.server.common.msg.queue.TbCallback;
 import org.thingsboard.server.service.cf.RocksDBService;
 import org.thingsboard.server.service.cf.ctx.CalculatedFieldEntityCtx;
 import org.thingsboard.server.service.cf.ctx.CalculatedFieldEntityCtxId;
@@ -36,24 +37,25 @@ public class RocksDBStateService implements CalculatedFieldStateService {
     private final RocksDBService rocksDBService;
 
     @Override
-    public Map<CalculatedFieldEntityCtxId, CalculatedFieldEntityCtx> restoreStates() {
+    public Map<CalculatedFieldEntityCtxId, CalculatedFieldState> restoreStates() {
         return rocksDBService.getAll().entrySet().stream()
                 .collect(Collectors.toMap(
                         entry -> JacksonUtil.fromString(entry.getKey(), CalculatedFieldEntityCtxId.class),
-                        entry -> JacksonUtil.fromString(entry.getValue(), CalculatedFieldEntityCtx.class)
+                        entry -> JacksonUtil.fromString(entry.getValue(), CalculatedFieldState.class)
                 ));
     }
 
     @Override
-    public CalculatedFieldEntityCtx restoreState(CalculatedFieldEntityCtxId ctxId) {
+    public CalculatedFieldState restoreState(CalculatedFieldEntityCtxId ctxId) {
         return Optional.ofNullable(rocksDBService.get(JacksonUtil.writeValueAsString(ctxId)))
-                .map(storedState -> JacksonUtil.fromString(storedState, CalculatedFieldEntityCtx.class))
+                .map(storedState -> JacksonUtil.fromString(storedState, CalculatedFieldState.class))
                 .orElse(null);
     }
 
     @Override
-    public void persistState(CalculatedFieldEntityCtxId ctxId, CalculatedFieldEntityCtx state) {
-        rocksDBService.put(JacksonUtil.writeValueAsString(ctxId), JacksonUtil.writeValueAsString(state));
+    public void persistState(CalculatedFieldEntityCtxId stateId, CalculatedFieldState state, TbCallback callback){
+        rocksDBService.put(JacksonUtil.writeValueAsString(stateId), JacksonUtil.writeValueAsString(state));
+        callback.onSuccess();
     }
 
     @Override

application/src/main/java/org/thingsboard/server/service/cf/ctx/state/SingleValueArgumentEntry.java

@@ -21,6 +21,10 @@ import lombok.NoArgsConstructor;
 import org.thingsboard.server.common.data.kv.AttributeKvEntry;
 import org.thingsboard.server.common.data.kv.KvEntry;
 import org.thingsboard.server.common.data.kv.TsKvEntry;
+import org.thingsboard.server.common.util.KvProtoUtil;
+import org.thingsboard.server.common.util.ProtoUtils;
+import org.thingsboard.server.gen.transport.TransportProtos.AttributeValueProto;
+import org.thingsboard.server.gen.transport.TransportProtos.TsKvProto;
 
 @Data
 @NoArgsConstructor
@@ -34,6 +38,18 @@ public class SingleValueArgumentEntry implements ArgumentEntry {
 
     private Long version;
 
+    public SingleValueArgumentEntry(TsKvProto entry) {
+        this.ts = entry.getTs();
+        this.version = entry.getVersion();
+        this.value = ProtoUtils.fromProto(entry).getValue();
+    }
+
+    public SingleValueArgumentEntry(AttributeValueProto entry) {
+        this.ts = entry.getLastUpdateTs();
+        this.version = entry.getVersion();
+        this.value = ProtoUtils.fromProto(entry).getValue();
+    }
+
     public SingleValueArgumentEntry(KvEntry entry) {
         if (entry instanceof TsKvEntry tsKvEntry) {
             this.ts = tsKvEntry.getTs();

application/src/main/java/org/thingsboard/server/service/entitiy/EntityStateSourcingListener.java

@@ -33,7 +33,6 @@ import org.thingsboard.server.common.data.Tenant;
 import org.thingsboard.server.common.data.TenantProfile;
 import org.thingsboard.server.common.data.asset.Asset;
 import org.thingsboard.server.common.data.audit.ActionType;
-import org.thingsboard.server.common.data.cf.CalculatedField;
 import org.thingsboard.server.common.data.edge.Edge;
 import org.thingsboard.server.common.data.edge.EdgeEvent;
 import org.thingsboard.server.common.data.id.DeviceId;
@@ -88,7 +87,7 @@ public class EntityStateSourcingListener {
             case ASSET -> {
                 onAssetUpdate(event.getEntity(), event.getOldEntity());
             }
-            case ASSET_PROFILE, ENTITY_VIEW, NOTIFICATION_RULE -> {
+            case ASSET_PROFILE, ENTITY_VIEW, NOTIFICATION_RULE, CALCULATED_FIELD -> {
                 tbClusterService.broadcastEntityStateChangeEvent(tenantId, entityId, lifecycleEvent);
             }
             case RULE_CHAIN -> {
@@ -123,9 +122,6 @@ public class EntityStateSourcingListener {
                 ApiUsageState apiUsageState = (ApiUsageState) event.getEntity();
                 tbClusterService.onApiStateChange(apiUsageState, null);
             }
-            case CALCULATED_FIELD -> {
-                onCalculatedFieldUpdate(event.getEntity(), event.getOldEntity());
-            }
             default -> {
             }
         }
@@ -150,7 +146,7 @@ public class EntityStateSourcingListener {
                 Asset asset = (Asset) event.getEntity();
                 tbClusterService.onAssetDeleted(tenantId, asset, null);
             }
-            case ASSET_PROFILE, ENTITY_VIEW, CUSTOMER, EDGE, NOTIFICATION_RULE -> {
+            case ASSET_PROFILE, ENTITY_VIEW, CUSTOMER, EDGE, NOTIFICATION_RULE, CALCULATED_FIELD -> {
                 tbClusterService.broadcastEntityStateChangeEvent(tenantId, entityId, ComponentLifecycleEvent.DELETED);
             }
             case NOTIFICATION_REQUEST -> {
@@ -191,10 +187,6 @@ public class EntityStateSourcingListener {
                 TbResourceInfo tbResource = (TbResourceInfo) event.getEntity();
                 tbClusterService.onResourceDeleted(tbResource, null);
             }
-            case CALCULATED_FIELD -> {
-                CalculatedField calculatedField = (CalculatedField) event.getEntity();
-                tbClusterService.onCalculatedFieldDeleted(tenantId, calculatedField, null);
-            }
             default -> {
             }
         }
@@ -275,15 +267,6 @@ public class EntityStateSourcingListener {
         }
     }
 
-    private void onCalculatedFieldUpdate(Object entity, Object oldEntity) {
-        CalculatedField calculatedField = (CalculatedField) entity;
-        CalculatedField oldCalculatedField = null;
-        if (oldEntity instanceof CalculatedField) {
-            oldCalculatedField = (CalculatedField) oldEntity;
-        }
-        tbClusterService.onCalculatedFieldUpdated(calculatedField, oldCalculatedField);
-    }
-
     private void pushAssignedFromNotification(Tenant currentTenant, TenantId newTenantId, Device assignedDevice) {
         String data = JacksonUtil.toString(JacksonUtil.valueToTree(assignedDevice));
         if (data != null) {

application/src/main/java/org/thingsboard/server/service/install/DefaultSystemDataLoaderService.java

@@ -69,6 +69,7 @@ import org.thingsboard.server.common.data.kv.BasicTsKvEntry;
 import org.thingsboard.server.common.data.kv.BooleanDataEntry;
 import org.thingsboard.server.common.data.kv.DoubleDataEntry;
 import org.thingsboard.server.common.data.kv.LongDataEntry;
+import org.thingsboard.server.common.data.kv.TimeseriesSaveResult;
 import org.thingsboard.server.common.data.mobile.app.MobileApp;
 import org.thingsboard.server.common.data.page.PageDataIterable;
 import org.thingsboard.server.common.data.page.PageLink;
@@ -98,9 +99,9 @@ import org.thingsboard.server.dao.device.DeviceCredentialsService;
 import org.thingsboard.server.dao.device.DeviceProfileService;
 import org.thingsboard.server.dao.device.DeviceService;
 import org.thingsboard.server.dao.exception.DataValidationException;
+import org.thingsboard.server.dao.mobile.MobileAppDao;
 import org.thingsboard.server.dao.notification.NotificationSettingsService;
 import org.thingsboard.server.dao.notification.NotificationTargetService;
-import org.thingsboard.server.dao.mobile.MobileAppDao;
 import org.thingsboard.server.dao.queue.QueueService;
 import org.thingsboard.server.dao.rule.RuleChainService;
 import org.thingsboard.server.dao.settings.AdminSettingsService;
@@ -308,7 +309,7 @@ public class DefaultSystemDataLoaderService implements SystemDataLoaderService {
             jwtSettingsService.saveJwtSettings(jwtSettings);
         }
 
-        List<MobileApp> mobiles = mobileAppDao.findByTenantId(TenantId.SYS_TENANT_ID, null, new PageLink(Integer.MAX_VALUE,0)).getData();
+        List<MobileApp> mobiles = mobileAppDao.findByTenantId(TenantId.SYS_TENANT_ID, null, new PageLink(Integer.MAX_VALUE, 0)).getData();
         if (CollectionUtils.isNotEmpty(mobiles)) {
             mobiles.stream()
                     .filter(mobileApp -> !validateKeyLength(mobileApp.getAppSecret()))
@@ -571,7 +572,7 @@ public class DefaultSystemDataLoaderService implements SystemDataLoaderService {
 
     private void save(DeviceId deviceId, String key, boolean value) {
         if (persistActivityToTelemetry) {
-            ListenableFuture<Integer> saveFuture = tsService.save(
+            ListenableFuture<TimeseriesSaveResult> saveFuture = tsService.save(
                     TenantId.SYS_TENANT_ID,
                     deviceId,
                     Collections.singletonList(new BasicTsKvEntry(System.currentTimeMillis(), new BooleanDataEntry(key, value))), 0L);

application/src/main/java/org/thingsboard/server/service/queue/DefaultTbCalculatedFieldConsumerService.java

@@ -28,6 +28,8 @@ import org.springframework.stereotype.Service;
 import org.thingsboard.common.util.DonAsynchron;
 import org.thingsboard.common.util.ThingsBoardExecutors;
 import org.thingsboard.server.actors.ActorSystemContext;
+import org.thingsboard.server.actors.calculatedField.CalculatedFieldLinkedTelemetryMsg;
+import org.thingsboard.server.actors.calculatedField.CalculatedFieldTelemetryMsg;
 import org.thingsboard.server.common.data.id.CalculatedFieldId;
 import org.thingsboard.server.common.data.id.EntityIdFactory;
 import org.thingsboard.server.common.data.id.TenantId;
@@ -36,6 +38,8 @@ import org.thingsboard.server.common.msg.queue.ServiceType;
 import org.thingsboard.server.common.msg.queue.TbCallback;
 import org.thingsboard.server.dao.tenant.TbTenantProfileCache;
 import org.thingsboard.server.gen.transport.TransportProtos;
+import org.thingsboard.server.gen.transport.TransportProtos.CalculatedFieldLinkedTelemetryMsgProto;
+import org.thingsboard.server.gen.transport.TransportProtos.CalculatedFieldTelemetryMsgProto;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCalculatedFieldMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCalculatedFieldNotificationMsg;
 import org.thingsboard.server.queue.TbQueueConsumer;
@@ -52,10 +56,17 @@ import org.thingsboard.server.service.profile.TbAssetProfileCache;
 import org.thingsboard.server.service.profile.TbDeviceProfileCache;
 import org.thingsboard.server.service.queue.consumer.MainQueueConsumerManager;
 import org.thingsboard.server.service.queue.processing.AbstractConsumerService;
+import org.thingsboard.server.service.queue.processing.IdMsgPair;
 import org.thingsboard.server.service.security.auth.jwt.settings.JwtSettingsService;
 
 import java.util.List;
 import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
 
 @Service
 @TbRuleEngineComponent
@@ -132,7 +143,46 @@ public class DefaultTbCalculatedFieldConsumerService extends AbstractConsumerSer
     }
 
     private void processMsgs(List<TbProtoQueueMsg<ToCalculatedFieldMsg>> msgs, TbQueueConsumer<TbProtoQueueMsg<ToCalculatedFieldMsg>> consumer, CalculatedFieldQueueConfig config) throws Exception {
-
+        List<IdMsgPair<ToCalculatedFieldMsg>> orderedMsgList = msgs.stream().map(msg -> new IdMsgPair<>(UUID.randomUUID(), msg)).toList();
+        ConcurrentMap<UUID, TbProtoQueueMsg<ToCalculatedFieldMsg>> pendingMap = orderedMsgList.stream().collect(
+                Collectors.toConcurrentMap(IdMsgPair::getUuid, IdMsgPair::getMsg));
+        CountDownLatch processingTimeoutLatch = new CountDownLatch(1);
+        TbPackProcessingContext<TbProtoQueueMsg<ToCalculatedFieldMsg>> ctx = new TbPackProcessingContext<>(
+                processingTimeoutLatch, pendingMap, new ConcurrentHashMap<>());
+        PendingMsgHolder<ToCalculatedFieldMsg> pendingMsgHolder = new PendingMsgHolder<>();
+        Future<?> packSubmitFuture = consumersExecutor.submit(() -> {
+            orderedMsgList.forEach((element) -> {
+                UUID id = element.getUuid();
+                TbProtoQueueMsg<ToCalculatedFieldMsg> msg = element.getMsg();
+                log.trace("[{}] Creating main callback for message: {}", id, msg.getValue());
+                TbCallback callback = new TbPackCallback<>(id, ctx);
+                try {
+                    ToCalculatedFieldMsg toCfMsg = msg.getValue();
+                    pendingMsgHolder.setMsg(toCfMsg);
+                    if (toCfMsg.hasTelemetryMsg()) {
+                        log.trace("[{}] Forwarding regular telemetry message for processing {}", id, toCfMsg.getTelemetryMsg());
+                        forwardToActorSystem(toCfMsg.getTelemetryMsg(), callback);
+                    } else if (toCfMsg.hasLinkedTelemetryMsg()) {
+                        log.trace("[{}] Forwarding linked telemetry message for processing {}", id, toCfMsg.getLinkedTelemetryMsg());
+                        forwardToActorSystem(toCfMsg.getLinkedTelemetryMsg(), callback);
+                    }
+                } catch (Throwable e) {
+                    log.warn("[{}] Failed to process message: {}", id, msg, e);
+                    callback.onFailure(e);
+                }
+            });
+        });
+        if (!processingTimeoutLatch.await(packProcessingTimeout, TimeUnit.MILLISECONDS)) {
+            if (!packSubmitFuture.isDone()) {
+                packSubmitFuture.cancel(true);
+                log.info("Timeout to process message: {}", pendingMsgHolder.getMsg());
+            }
+            if (log.isDebugEnabled()) {
+                ctx.getAckMap().forEach((id, msg) -> log.debug("[{}] Timeout to process message: {}", id, msg.getValue()));
+            }
+            ctx.getFailedMap().forEach((id, msg) -> log.warn("[{}] Failed to process message: {}", id, msg.getValue()));
+        }
+        consumer.commit();
     }
 
     @Override
@@ -164,14 +214,14 @@ public class DefaultTbCalculatedFieldConsumerService extends AbstractConsumerSer
     protected void handleNotification(UUID id, TbProtoQueueMsg<ToCalculatedFieldNotificationMsg> msg, TbCallback callback) {
         ToCalculatedFieldNotificationMsg toCfNotification = msg.getValue();
         if (toCfNotification.hasComponentLifecycle()) {
-            forwardToCalculatedFieldService(toCfNotification.getComponentLifecycle(), callback);
+            forwardToActorSystem(toCfNotification.getComponentLifecycle(), callback);
         } else if (toCfNotification.hasEntityUpdateMsg()) {
-            forwardToCalculatedFieldService(toCfNotification.getEntityUpdateMsg(), callback);
+            forwardToActorSystem(toCfNotification.getEntityUpdateMsg(), callback);
         }
         callback.onSuccess();
     }
 
-//    private void processEntityProfileUpdateMsg(TransportProtos.EntityProfileUpdateMsgProto profileUpdateMsg) {
+    //    private void processEntityProfileUpdateMsg(TransportProtos.EntityProfileUpdateMsgProto profileUpdateMsg) {
 //        var tenantId = toTenantId(profileUpdateMsg.getTenantIdMSB(), profileUpdateMsg.getTenantIdLSB());
 //        var entityId = EntityIdFactory.getByTypeAndUuid(profileUpdateMsg.getEntityType(), new UUID(profileUpdateMsg.getEntityIdMSB(), profileUpdateMsg.getEntityIdLSB()));
 //        var oldProfile = EntityIdFactory.getByTypeAndUuid(profileUpdateMsg.getEntityProfileType(), new UUID(profileUpdateMsg.getOldProfileIdMSB(), profileUpdateMsg.getOldProfileIdLSB()));
@@ -193,7 +243,21 @@ public class DefaultTbCalculatedFieldConsumerService extends AbstractConsumerSer
 //        }
 //    }
 //
-    private void forwardToCalculatedFieldService(TransportProtos.ComponentLifecycleMsgProto msg, TbCallback callback) {
+
+    private void forwardToActorSystem(CalculatedFieldTelemetryMsgProto msg, TbCallback callback) {
+        var tenantId = toTenantId(msg.getTenantIdMSB(), msg.getTenantIdLSB());
+        var entityId = EntityIdFactory.getByTypeAndUuid(msg.getEntityType(), new UUID(msg.getEntityIdMSB(), msg.getEntityIdLSB()));
+        actorContext.tell(new CalculatedFieldTelemetryMsg(tenantId, entityId, msg, callback));
+    }
+
+    private void forwardToActorSystem(CalculatedFieldLinkedTelemetryMsgProto linkedMsg, TbCallback callback) {
+        var msg = linkedMsg.getMsg();
+        var tenantId = toTenantId(msg.getTenantIdMSB(), msg.getTenantIdLSB());
+        var entityId = EntityIdFactory.getByTypeAndUuid(msg.getEntityType(), new UUID(msg.getEntityIdMSB(), msg.getEntityIdLSB()));
+        actorContext.tell(new CalculatedFieldLinkedTelemetryMsg(tenantId, entityId, linkedMsg, callback));
+    }
+
+    private void forwardToActorSystem(TransportProtos.ComponentLifecycleMsgProto msg, TbCallback callback) {
         var tenantId = toTenantId(msg.getTenantIdMSB(), msg.getTenantIdLSB());
         var calculatedFieldId = new CalculatedFieldId(new UUID(msg.getEntityIdMSB(), msg.getEntityIdLSB()));
         ListenableFuture<?> future = calculatedFieldsExecutor.submit(() -> calculatedFieldExecutionService.onCalculatedFieldLifecycleMsg(msg, callback));
@@ -205,7 +269,7 @@ public class DefaultTbCalculatedFieldConsumerService extends AbstractConsumerSer
                 });
     }
 
-    private void forwardToCalculatedFieldService(TransportProtos.CalculatedFieldEntityUpdateMsgProto msg, TbCallback callback) {
+    private void forwardToActorSystem(TransportProtos.CalculatedFieldEntityUpdateMsgProto msg, TbCallback callback) {
         var tenantId = toTenantId(msg.getTenantIdMSB(), msg.getTenantIdLSB());
         var entityId = EntityIdFactory.getByTypeAndUuid(msg.getEntityType(), new UUID(msg.getEntityIdMSB(), msg.getEntityIdLSB()));
         ListenableFuture<?> future = calculatedFieldsExecutor.submit(() -> calculatedFieldExecutionService.onEntityUpdateMsg(msg, callback));

application/src/main/java/org/thingsboard/server/service/queue/DefaultTbClusterService.java

@@ -38,12 +38,10 @@ import org.thingsboard.server.common.data.TbResourceInfo;
 import org.thingsboard.server.common.data.Tenant;
 import org.thingsboard.server.common.data.TenantProfile;
 import org.thingsboard.server.common.data.asset.Asset;
-import org.thingsboard.server.common.data.cf.CalculatedField;
 import org.thingsboard.server.common.data.edge.EdgeEventActionType;
 import org.thingsboard.server.common.data.edge.EdgeEventType;
 import org.thingsboard.server.common.data.id.AssetId;
 import org.thingsboard.server.common.data.id.AssetProfileId;
-import org.thingsboard.server.common.data.id.CalculatedFieldId;
 import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.data.id.DeviceProfileId;
 import org.thingsboard.server.common.data.id.EdgeId;
@@ -347,6 +345,13 @@ public class DefaultTbClusterService implements TbClusterService {
         toCoreMsgs.incrementAndGet();
     }
 
+    @Override
+    public void pushMsgToCalculatedFields(TopicPartitionInfo tpi, UUID msgId, ToCalculatedFieldMsg msg, TbQueueCallback callback) {
+        log.trace("PUSHING msg: {} to:{}", msg, tpi);
+        producerProvider.getCalculatedFieldsMsgProducer().send(tpi, new TbProtoQueueMsg<>(msgId, msg), callback);
+        toRuleEngineNfs.incrementAndGet(); // TODO: add separate counter when we will have new ServiceType.CALCULATED_FIELDS
+    }
+
     @Override
     public void pushNotificationToCalculatedFields(TenantId tenantId, EntityId entityId, ToCalculatedFieldNotificationMsg msg, TbQueueCallback callback) {
         TopicPartitionInfo tpi = partitionService.resolve(CALCULATED_FIELD_QUEUE_KEY, entityId);
@@ -409,7 +414,7 @@ public class DefaultTbClusterService implements TbClusterService {
     public void onDeviceDeleted(TenantId tenantId, Device device, TbQueueCallback callback) {
         DeviceId deviceId = device.getId();
         gatewayNotificationsService.onDeviceDeleted(device);
-        handleProfileEntityEvent(tenantId, deviceId, device.getDeviceProfileId(), false, true);
+        handleCalculatedFieldEntityDeleted(tenantId, deviceId, device.getDeviceProfileId());
         broadcastEntityDeleteToTransport(tenantId, deviceId, device.getName(), callback);
         sendDeviceStateServiceEvent(tenantId, deviceId, false, false, true);
         broadcastEntityStateChangeEvent(tenantId, deviceId, ComponentLifecycleEvent.DELETED);
@@ -418,7 +423,7 @@ public class DefaultTbClusterService implements TbClusterService {
     @Override
     public void onAssetDeleted(TenantId tenantId, Asset asset, TbQueueCallback callback) {
         AssetId assetId = asset.getId();
-        handleProfileEntityEvent(tenantId, assetId, asset.getAssetProfileId(), true, true);
+        handleCalculatedFieldEntityDeleted(tenantId, assetId, asset.getAssetProfileId());
         broadcastEntityStateChangeEvent(tenantId, assetId, ComponentLifecycleEvent.DELETED);
     }
 
@@ -653,13 +658,13 @@ public class DefaultTbClusterService implements TbClusterService {
             }
             boolean deviceProfileChanged = !device.getDeviceProfileId().equals(old.getDeviceProfileId());
             if (deviceProfileChanged) {
-                handleEntityProfileUpdatedEvent(device.getTenantId(), device.getId(), old.getDeviceProfileId(), device.getDeviceProfileId());
+                handleCalculatedFieldEntityUpdated(device.getTenantId(), device.getId(), old.getDeviceProfileId(), device.getDeviceProfileId());
             }
             if (deviceNameChanged || deviceProfileChanged) {
                 pushMsgToCore(new DeviceNameOrTypeUpdateMsg(device.getTenantId(), device.getId(), device.getName(), device.getType()), null);
             }
         } else {
-            handleProfileEntityEvent(device.getTenantId(), device.getId(), device.getDeviceProfileId(), true, false);
+            handleCalculatedFieldEntityAdded(device.getTenantId(), device.getId(), device.getDeviceProfileId());
         }
         broadcastEntityStateChangeEvent(device.getTenantId(), device.getId(), created ? ComponentLifecycleEvent.CREATED : ComponentLifecycleEvent.UPDATED);
         sendDeviceStateServiceEvent(device.getTenantId(), device.getId(), created, !created, false);
@@ -673,10 +678,10 @@ public class DefaultTbClusterService implements TbClusterService {
         if (old != null) {
             boolean assetTypeChanged = !asset.getType().equals(old.getType());
             if (assetTypeChanged) {
-                handleEntityProfileUpdatedEvent(asset.getTenantId(), asset.getId(), old.getAssetProfileId(), asset.getAssetProfileId());
+                handleCalculatedFieldEntityUpdated(asset.getTenantId(), asset.getId(), old.getAssetProfileId(), asset.getAssetProfileId());
             }
         } else {
-            handleProfileEntityEvent(asset.getTenantId(), asset.getId(), asset.getAssetProfileId(), true, false);
+            handleCalculatedFieldEntityAdded(asset.getTenantId(), asset.getId(), asset.getAssetProfileId());
         }
         broadcastEntityStateChangeEvent(asset.getTenantId(), asset.getId(), created ? ComponentLifecycleEvent.CREATED : ComponentLifecycleEvent.UPDATED);
     }
@@ -809,52 +814,41 @@ public class DefaultTbClusterService implements TbClusterService {
         }
     }
 
-    @Override
-    public void onCalculatedFieldUpdated(CalculatedField calculatedField, CalculatedField oldCalculatedField) {
-        var created = oldCalculatedField == null;
-        broadcastEntityStateChangeEvent(calculatedField.getTenantId(), calculatedField.getId(), created ? ComponentLifecycleEvent.CREATED : ComponentLifecycleEvent.UPDATED);
+    private void handleCalculatedFieldEntityAdded(TenantId tenantId, EntityId entityId, EntityId newProfileId) {
+        handleCalculatedFieldEntityUpdateEvent(tenantId, entityId, null, newProfileId, true, false, false);
     }
 
-    @Override
-    public void onCalculatedFieldDeleted(TenantId tenantId, CalculatedField calculatedField, TbQueueCallback callback) {
-        CalculatedFieldId calculatedFieldId = calculatedField.getId();
-        broadcastEntityStateChangeEvent(tenantId, calculatedFieldId, ComponentLifecycleEvent.DELETED);
+    private void handleCalculatedFieldEntityUpdated(TenantId tenantId, EntityId entityId, EntityId oldProfileId, EntityId newProfileId) {
+        handleCalculatedFieldEntityUpdateEvent(tenantId, entityId, oldProfileId, newProfileId, false, true, true);
     }
 
-    private void handleEntityProfileUpdatedEvent(TenantId tenantId, EntityId entityId, EntityId oldProfileId, EntityId newProfileId) {
-        TransportProtos.EntityProfileUpdateMsgProto.Builder builder = TransportProtos.EntityProfileUpdateMsgProto.newBuilder();
-        builder.setTenantIdMSB(tenantId.getId().getMostSignificantBits());
-        builder.setTenantIdLSB(tenantId.getId().getLeastSignificantBits());
-        builder.setEntityType(entityId.getEntityType().name());
-        builder.setEntityIdMSB(entityId.getId().getMostSignificantBits());
-        builder.setEntityIdLSB(entityId.getId().getLeastSignificantBits());
-        builder.setEntityProfileType(newProfileId.getEntityType().name());
-        builder.setOldProfileIdMSB(oldProfileId.getId().getMostSignificantBits());
-        builder.setOldProfileIdLSB(oldProfileId.getId().getLeastSignificantBits());
-        builder.setNewProfileIdMSB(newProfileId.getId().getMostSignificantBits());
-        builder.setNewProfileIdLSB(newProfileId.getId().getLeastSignificantBits());
-        TransportProtos.EntityProfileUpdateMsgProto msg = builder.build();
-
-        broadcastToCore(ToCoreNotificationMsg.newBuilder().setEntityProfileUpdateMsg(msg).build());
-        pushMsgToCore(tenantId, entityId, ToCoreMsg.newBuilder().setEntityProfileUpdateMsg(msg).build(), null);
+    private void handleCalculatedFieldEntityDeleted(TenantId tenantId, EntityId entityId, EntityId oldProfileId) {
+        handleCalculatedFieldEntityUpdateEvent(tenantId, entityId, oldProfileId, null, false, false, true);
     }
 
-    private void handleProfileEntityEvent(TenantId tenantId, EntityId entityId, EntityId profileId, boolean added, boolean deleted) {
-        TransportProtos.ProfileEntityMsgProto.Builder builder = TransportProtos.ProfileEntityMsgProto.newBuilder();
+    private void handleCalculatedFieldEntityUpdateEvent(TenantId tenantId, EntityId entityId, EntityId oldProfileId, EntityId newProfileId, boolean added, boolean updated, boolean deleted) {
+        TransportProtos.CalculatedFieldEntityUpdateMsgProto.Builder builder = TransportProtos.CalculatedFieldEntityUpdateMsgProto.newBuilder();
         builder.setTenantIdMSB(tenantId.getId().getMostSignificantBits());
         builder.setTenantIdLSB(tenantId.getId().getLeastSignificantBits());
         builder.setEntityType(entityId.getEntityType().name());
         builder.setEntityIdMSB(entityId.getId().getMostSignificantBits());
         builder.setEntityIdLSB(entityId.getId().getLeastSignificantBits());
-        builder.setEntityProfileType(profileId.getEntityType().name());
-        builder.setProfileIdMSB(profileId.getId().getMostSignificantBits());
-        builder.setProfileIdLSB(profileId.getId().getLeastSignificantBits());
+        if (oldProfileId != null) {
+            builder.setEntityProfileType(oldProfileId.getEntityType().name());
+            builder.setOldProfileIdMSB(oldProfileId.getId().getMostSignificantBits());
+            builder.setOldProfileIdLSB(oldProfileId.getId().getLeastSignificantBits());
+        }
+        if (newProfileId != null) {
+            builder.setEntityProfileType(newProfileId.getEntityType().name());
+            builder.setNewProfileIdMSB(newProfileId.getId().getMostSignificantBits());
+            builder.setNewProfileIdLSB(newProfileId.getId().getLeastSignificantBits());
+        }
         builder.setAdded(added);
+        builder.setUpdated(updated);
         builder.setDeleted(deleted);
-        TransportProtos.ProfileEntityMsgProto msg = builder.build();
+        TransportProtos.CalculatedFieldEntityUpdateMsgProto msg = builder.build();
 
-        broadcastToCore(ToCoreNotificationMsg.newBuilder().setProfileEntityMsg(msg).build());
-        pushMsgToCore(tenantId, entityId, ToCoreMsg.newBuilder().setProfileEntityMsg(msg).build(), null);
+        pushNotificationToCalculatedFields(tenantId, entityId, ToCalculatedFieldNotificationMsg.newBuilder().setEntityUpdateMsg(msg).build(), null);
     }
 
 }

application/src/main/java/org/thingsboard/server/service/queue/DefaultTbCoreConsumerService.java

@@ -39,8 +39,6 @@ import org.thingsboard.server.common.data.event.ErrorEvent;
 import org.thingsboard.server.common.data.event.Event;
 import org.thingsboard.server.common.data.event.LifecycleEvent;
 import org.thingsboard.server.common.data.id.DeviceId;
-import org.thingsboard.server.common.data.id.EntityId;
-import org.thingsboard.server.common.data.id.EntityIdFactory;
 import org.thingsboard.server.common.data.id.NotificationRequestId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.id.UserId;
@@ -88,7 +86,6 @@ import org.thingsboard.server.queue.provider.TbCoreQueueFactory;
 import org.thingsboard.server.queue.util.TbCoreComponent;
 import org.thingsboard.server.service.apiusage.TbApiUsageStateService;
 import org.thingsboard.server.service.cf.CalculatedFieldCache;
-import org.thingsboard.server.service.cf.CalculatedFieldExecutionService;
 import org.thingsboard.server.service.notification.NotificationSchedulerService;
 import org.thingsboard.server.service.ota.OtaPackageStateService;
 import org.thingsboard.server.service.profile.TbAssetProfileCache;
@@ -110,7 +107,6 @@ import org.thingsboard.server.service.ws.notification.sub.NotificationRequestUpd
 import org.thingsboard.server.service.ws.notification.sub.NotificationUpdate;
 
 import java.util.List;
-import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
@@ -153,14 +149,12 @@ public class DefaultTbCoreConsumerService extends AbstractConsumerService<ToCore
     private final TbImageService imageService;
     private final RuleEngineCallService ruleEngineCallService;
     private final TbCoreConsumerStats stats;
-    private final CalculatedFieldExecutionService calculatedFieldExecutionService;
 
     private MainQueueConsumerManager<TbProtoQueueMsg<ToCoreMsg>, CoreQueueConfig> mainConsumer;
     private QueueConsumerManager<TbProtoQueueMsg<ToUsageStatsServiceMsg>> usageStatsConsumer;
     private QueueConsumerManager<TbProtoQueueMsg<ToOtaPackageStateServiceMsg>> firmwareStatesConsumer;
 
     private volatile ListeningExecutorService deviceActivityEventsExecutor;
-    private volatile ListeningExecutorService calculatedFieldsExecutor;
 
     public DefaultTbCoreConsumerService(TbCoreQueueFactory tbCoreQueueFactory,
                                         ActorSystemContext actorContext,
@@ -183,7 +177,6 @@ public class DefaultTbCoreConsumerService extends AbstractConsumerService<ToCore
                                         NotificationRuleProcessor notificationRuleProcessor,
                                         TbImageService imageService,
                                         RuleEngineCallService ruleEngineCallService,
-                                        CalculatedFieldExecutionService calculatedFieldExecutionService,
                                         CalculatedFieldCache calculatedFieldCache) {
         super(actorContext, tenantProfileCache, deviceProfileCache, assetProfileCache, calculatedFieldCache, apiUsageStateService, partitionService,
                 eventPublisher, jwtSettingsService);
@@ -200,14 +193,12 @@ public class DefaultTbCoreConsumerService extends AbstractConsumerService<ToCore
         this.imageService = imageService;
         this.ruleEngineCallService = ruleEngineCallService;
         this.queueFactory = tbCoreQueueFactory;
-        this.calculatedFieldExecutionService = calculatedFieldExecutionService;
     }
 
     @PostConstruct
     public void init() {
         super.init("tb-core");
         this.deviceActivityEventsExecutor = MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor(ThingsBoardThreadFactory.forName("tb-core-device-activity-events-executor")));
-        this.calculatedFieldsExecutor = MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor(ThingsBoardThreadFactory.forName("tb-core-calculated-fields-executor")));
 
         this.mainConsumer = MainQueueConsumerManager.<TbProtoQueueMsg<ToCoreMsg>, CoreQueueConfig>builder()
                 .queueKey(new QueueKey(ServiceType.TB_CORE))
@@ -269,7 +260,7 @@ public class DefaultTbCoreConsumerService extends AbstractConsumerService<ToCore
         CountDownLatch processingTimeoutLatch = new CountDownLatch(1);
         TbPackProcessingContext<TbProtoQueueMsg<ToCoreMsg>> ctx = new TbPackProcessingContext<>(
                 processingTimeoutLatch, pendingMap, new ConcurrentHashMap<>());
-        PendingMsgHolder pendingMsgHolder = new PendingMsgHolder();
+        PendingMsgHolder<ToCoreMsg> pendingMsgHolder = new PendingMsgHolder<>();
         Future<?> packSubmitFuture = consumersExecutor.submit(() -> {
             orderedMsgList.forEach((element) -> {
                 UUID id = element.getUuid();
@@ -278,7 +269,7 @@ public class DefaultTbCoreConsumerService extends AbstractConsumerService<ToCore
                 TbCallback callback = new TbPackCallback<>(id, ctx);
                 try {
                     ToCoreMsg toCoreMsg = msg.getValue();
-                    pendingMsgHolder.setToCoreMsg(toCoreMsg);
+                    pendingMsgHolder.setMsg(toCoreMsg);
                     if (toCoreMsg.hasToSubscriptionMgrMsg()) {
                         log.trace("[{}] Forwarding message to subscription manager service {}", id, toCoreMsg.getToSubscriptionMgrMsg());
                         forwardToSubMgrService(toCoreMsg.getToSubscriptionMgrMsg(), callback);
@@ -319,12 +310,6 @@ public class DefaultTbCoreConsumerService extends AbstractConsumerService<ToCore
                         forwardToEventService(toCoreMsg.getErrorEventMsg(), callback);
                     } else if (toCoreMsg.hasLifecycleEventMsg()) {
                         forwardToEventService(toCoreMsg.getLifecycleEventMsg(), callback);
-                    } else if (toCoreMsg.hasCalculatedFieldMsg()) {
-                        forwardToCalculatedFieldService(toCoreMsg.getCalculatedFieldMsg(), callback);
-                    } else if (toCoreMsg.hasEntityProfileUpdateMsg()) {
-                        forwardToCalculatedFieldService(toCoreMsg.getEntityProfileUpdateMsg(), callback);
-                    } else if (toCoreMsg.hasProfileEntityMsg()) {
-                        forwardToCalculatedFieldService(toCoreMsg.getProfileEntityMsg(), callback);
                     }
                 } catch (Throwable e) {
                     log.warn("[{}] Failed to process message: {}", id, msg, e);
@@ -335,8 +320,7 @@ public class DefaultTbCoreConsumerService extends AbstractConsumerService<ToCore
         if (!processingTimeoutLatch.await(packProcessingTimeout, TimeUnit.MILLISECONDS)) {
             if (!packSubmitFuture.isDone()) {
                 packSubmitFuture.cancel(true);
-                ToCoreMsg lastSubmitMsg = pendingMsgHolder.getToCoreMsg();
-                log.info("Timeout to process message: {}", lastSubmitMsg);
+                log.info("Timeout to process message: {}", pendingMsgHolder.getMsg());
             }
             if (log.isDebugEnabled()) {
                 ctx.getAckMap().forEach((id, msg) -> log.debug("[{}] Timeout to process message: {}", id, msg.getValue()));
@@ -346,12 +330,6 @@ public class DefaultTbCoreConsumerService extends AbstractConsumerService<ToCore
         consumer.commit();
     }
 
-    private static class PendingMsgHolder {
-        @Getter
-        @Setter
-        private volatile ToCoreMsg toCoreMsg;
-    }
-
     @Override
     protected ServiceType getServiceType() {
         return ServiceType.TB_CORE;
@@ -413,10 +391,6 @@ public class DefaultTbCoreConsumerService extends AbstractConsumerService<ToCore
             callback.onSuccess();
         } else if (toCoreNotification.hasResourceCacheInvalidateMsg()) {
             forwardToResourceService(toCoreNotification.getResourceCacheInvalidateMsg(), callback);
-        } else if (toCoreNotification.hasEntityProfileUpdateMsg()) {
-            processEntityProfileUpdateMsg(toCoreNotification.getEntityProfileUpdateMsg());
-        } else if (toCoreNotification.hasProfileEntityMsg()) {
-            processProfileEntityMsg(toCoreNotification.getProfileEntityMsg());
         }
         if (statsEnabled) {
             stats.log(toCoreNotification);
@@ -535,28 +509,6 @@ public class DefaultTbCoreConsumerService extends AbstractConsumerService<ToCore
         callback.onSuccess();
     }
 
-    private void processEntityProfileUpdateMsg(TransportProtos.EntityProfileUpdateMsgProto profileUpdateMsg) {
-        var tenantId = toTenantId(profileUpdateMsg.getTenantIdMSB(), profileUpdateMsg.getTenantIdLSB());
-        var entityId = EntityIdFactory.getByTypeAndUuid(profileUpdateMsg.getEntityType(), new UUID(profileUpdateMsg.getEntityIdMSB(), profileUpdateMsg.getEntityIdLSB()));
-        var oldProfile = EntityIdFactory.getByTypeAndUuid(profileUpdateMsg.getEntityProfileType(), new UUID(profileUpdateMsg.getOldProfileIdMSB(), profileUpdateMsg.getOldProfileIdLSB()));
-        var newProfile = EntityIdFactory.getByTypeAndUuid(profileUpdateMsg.getEntityProfileType(), new UUID(profileUpdateMsg.getNewProfileIdMSB(), profileUpdateMsg.getNewProfileIdLSB()));
-        calculatedFieldCache.getEntitiesByProfile(tenantId, oldProfile).remove(entityId);
-        calculatedFieldCache.getEntitiesByProfile(tenantId, newProfile).add(entityId);
-    }
-
-    private void processProfileEntityMsg(TransportProtos.ProfileEntityMsgProto profileEntityMsg) {
-        var tenantId = toTenantId(profileEntityMsg.getTenantIdMSB(), profileEntityMsg.getTenantIdLSB());
-        var entityId = EntityIdFactory.getByTypeAndUuid(profileEntityMsg.getEntityType(), new UUID(profileEntityMsg.getEntityIdMSB(), profileEntityMsg.getEntityIdLSB()));
-        var profileId = EntityIdFactory.getByTypeAndUuid(profileEntityMsg.getEntityProfileType(), new UUID(profileEntityMsg.getProfileIdMSB(), profileEntityMsg.getProfileIdLSB()));
-        boolean added = profileEntityMsg.getAdded();
-        Set<EntityId> entitiesByProfile = calculatedFieldCache.getEntitiesByProfile(tenantId, profileId);
-        if (added) {
-            entitiesByProfile.add(entityId);
-        } else {
-            entitiesByProfile.remove(entityId);
-        }
-    }
-
     private void forwardToSubMgrService(SubscriptionMgrMsgProto msg, TbCallback callback) {
         if (msg.hasSubEvent()) {
             TbEntitySubEventProto subEvent = msg.getSubEvent();

application/src/main/java/org/thingsboard/server/service/queue/DefaultTbEdgeConsumerService.java

@@ -137,7 +137,7 @@ public class DefaultTbEdgeConsumerService extends AbstractConsumerService<ToEdge
         CountDownLatch processingTimeoutLatch = new CountDownLatch(1);
         TbPackProcessingContext<TbProtoQueueMsg<ToEdgeMsg>> ctx = new TbPackProcessingContext<>(
                 processingTimeoutLatch, pendingMap, new ConcurrentHashMap<>());
-        PendingMsgHolder pendingMsgHolder = new PendingMsgHolder();
+        PendingMsgHolder<ToEdgeMsg> pendingMsgHolder = new PendingMsgHolder<>();
         Future<?> submitFuture = consumersExecutor.submit(() -> {
             orderedMsgList.forEach((element) -> {
                 UUID id = element.getUuid();
@@ -145,7 +145,7 @@ public class DefaultTbEdgeConsumerService extends AbstractConsumerService<ToEdge
                 TbCallback callback = new TbPackCallback<>(id, ctx);
                 try {
                     ToEdgeMsg toEdgeMsg = msg.getValue();
-                    pendingMsgHolder.setToEdgeMsg(toEdgeMsg);
+                    pendingMsgHolder.setMsg(toEdgeMsg);
                     if (toEdgeMsg.hasEdgeNotificationMsg()) {
                         pushNotificationToEdge(toEdgeMsg.getEdgeNotificationMsg(), 0, packProcessingRetries, callback);
                     }
@@ -161,20 +161,13 @@ public class DefaultTbEdgeConsumerService extends AbstractConsumerService<ToEdge
         if (!processingTimeoutLatch.await(packProcessingTimeout, TimeUnit.MILLISECONDS)) {
             if (!submitFuture.isDone()) {
                 submitFuture.cancel(true);
-                ToEdgeMsg lastSubmitMsg = pendingMsgHolder.getToEdgeMsg();
-                log.info("Timeout to process message: {}", lastSubmitMsg);
+                log.info("Timeout to process message: {}", pendingMsgHolder.getMsg());
             }
             ctx.getFailedMap().forEach((id, msg) -> log.warn("[{}] Failed to process message: {}", id, msg.getValue()));
         }
         consumer.commit();
     }
 
-    private static class PendingMsgHolder {
-        @Getter
-        @Setter
-        private volatile ToEdgeMsg toEdgeMsg;
-    }
-
     @Override
     protected ServiceType getServiceType() {
         return ServiceType.TB_CORE;

application/src/main/java/org/thingsboard/server/service/queue/PendingMsgHolder.java

@@ -0,0 +1,24 @@
+/**
+ * Copyright © 2016-2024 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.service.queue;
+
+import lombok.Getter;
+import lombok.Setter;
+
+public class PendingMsgHolder<T> {
+    @Getter @Setter
+    private volatile T msg;
+}

application/src/main/java/org/thingsboard/server/service/queue/processing/AbstractConsumerService.java

@@ -178,12 +178,16 @@ public abstract class AbstractConsumerService<N extends com.google.protobuf.Gene
             }
         } else if (EntityType.DEVICE_PROFILE.equals(componentLifecycleMsg.getEntityId().getEntityType())) {
             deviceProfileCache.evict(tenantId, new DeviceProfileId(componentLifecycleMsg.getEntityId().getId()));
+            calculatedFieldCache.evictProfile(tenantId, new DeviceProfileId(componentLifecycleMsg.getEntityId().getId()));
         } else if (EntityType.DEVICE.equals(componentLifecycleMsg.getEntityId().getEntityType())) {
             deviceProfileCache.evict(tenantId, new DeviceId(componentLifecycleMsg.getEntityId().getId()));
+            calculatedFieldCache.evictEntity(tenantId, new DeviceId(componentLifecycleMsg.getEntityId().getId()));
         } else if (EntityType.ASSET_PROFILE.equals(componentLifecycleMsg.getEntityId().getEntityType())) {
             assetProfileCache.evict(tenantId, new AssetProfileId(componentLifecycleMsg.getEntityId().getId()));
+            calculatedFieldCache.evictProfile(tenantId, new AssetProfileId(componentLifecycleMsg.getEntityId().getId()));
         } else if (EntityType.ASSET.equals(componentLifecycleMsg.getEntityId().getEntityType())) {
             assetProfileCache.evict(tenantId, new AssetId(componentLifecycleMsg.getEntityId().getId()));
+            calculatedFieldCache.evictEntity(tenantId, new AssetId(componentLifecycleMsg.getEntityId().getId()));
         } else if (EntityType.ENTITY_VIEW.equals(componentLifecycleMsg.getEntityId().getEntityType())) {
             actorContext.getTbEntityViewService().onComponentLifecycleMsg(componentLifecycleMsg);
         } else if (EntityType.API_USAGE_STATE.equals(componentLifecycleMsg.getEntityId().getEntityType())) {

application/src/main/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManager.java

@@ -28,14 +28,12 @@ import org.thingsboard.server.common.msg.queue.QueueToRuleEngineMsg;
 import org.thingsboard.server.common.msg.queue.RuleEngineException;
 import org.thingsboard.server.common.msg.queue.RuleNodeInfo;
 import org.thingsboard.server.common.msg.queue.ServiceType;
-import org.thingsboard.server.common.msg.queue.TbCallback;
 import org.thingsboard.server.common.msg.queue.TbMsgCallback;
 import org.thingsboard.server.common.msg.queue.TopicPartitionInfo;
 import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineMsg;
 import org.thingsboard.server.queue.TbQueueConsumer;
 import org.thingsboard.server.queue.common.TbProtoQueueMsg;
 import org.thingsboard.server.queue.discovery.QueueKey;
-import org.thingsboard.server.service.cf.CalculatedFieldExecutionService;
 import org.thingsboard.server.service.queue.TbMsgPackCallback;
 import org.thingsboard.server.service.queue.TbMsgPackProcessingContext;
 import org.thingsboard.server.service.queue.TbRuleEngineConsumerStats;
@@ -65,18 +63,14 @@ public class TbRuleEngineQueueConsumerManager extends MainQueueConsumerManager<T
     private final TbRuleEngineConsumerContext ctx;
     private final TbRuleEngineConsumerStats stats;
 
-    private final CalculatedFieldExecutionService calculatedFieldExecutionService;
-
     @Builder(builderMethodName = "create") // not to conflict with super.builder()
     public TbRuleEngineQueueConsumerManager(TbRuleEngineConsumerContext ctx,
                                             QueueKey queueKey,
                                             ExecutorService consumerExecutor,
                                             ScheduledExecutorService scheduler,
-                                            ExecutorService taskExecutor,
-                                            CalculatedFieldExecutionService calculatedFieldExecutionService) {
+                                            ExecutorService taskExecutor) {
         super(queueKey, null, null, ctx.getQueueFactory()::createToRuleEngineMsgConsumer, consumerExecutor, scheduler, taskExecutor);
         this.ctx = ctx;
-        this.calculatedFieldExecutionService = calculatedFieldExecutionService;
         this.stats = new TbRuleEngineConsumerStats(queueKey, ctx.getStatsFactory());
     }
 
@@ -178,12 +172,6 @@ public class TbRuleEngineQueueConsumerManager extends MainQueueConsumerManager<T
         try {
             if (!toRuleEngineMsg.getTbMsg().isEmpty()) {
                 forwardToRuleEngineActor(config.getName(), tenantId, toRuleEngineMsg, callback);
-            } else if (toRuleEngineMsg.hasCfTelemetryUpdateMsg()) {
-                calculatedFieldExecutionService.onTelemetryUpdateMsg(toRuleEngineMsg.getCfTelemetryUpdateMsg());
-            } else if (toRuleEngineMsg.hasEntityProfileUpdateMsg()) {
-                calculatedFieldExecutionService.onEntityProfileChangedMsg(toRuleEngineMsg.getEntityProfileUpdateMsg(), TbCallback.EMPTY);
-            } else if (toRuleEngineMsg.hasProfileEntityMsg()) {
-                calculatedFieldExecutionService.onProfileEntityMsg(toRuleEngineMsg.getProfileEntityMsg(), TbCallback.EMPTY);
             } else {
                 callback.onSuccess();
             }

application/src/main/java/org/thingsboard/server/service/telemetry/DefaultTelemetrySubscriptionService.java

@@ -51,7 +51,6 @@ import org.thingsboard.server.dao.timeseries.TimeseriesService;
 import org.thingsboard.server.dao.util.KvUtils;
 import org.thingsboard.server.service.apiusage.TbApiUsageStateService;
 import org.thingsboard.server.service.cf.CalculatedFieldExecutionService;
-import org.thingsboard.server.service.cf.telemetry.CalculatedFieldAttributeUpdateRequest;
 import org.thingsboard.server.service.entitiy.entityview.TbEntityViewService;
 import org.thingsboard.server.service.subscription.TbSubscriptionUtils;
 
@@ -148,7 +147,7 @@ public class DefaultTelemetrySubscriptionService extends AbstractSubscriptionSer
             resultFuture = tsService.saveWithoutLatest(tenantId, entityId, request.getEntries(), request.getTtl());
         }
         DonAsynchron.withCallback(resultFuture, result -> {
-            calculatedFieldExecutionService.pushRequestToQueue(request, result);
+            calculatedFieldExecutionService.pushRequestToQueue(request, result, request.getCallback());
         }, safeCallback(request.getCallback()), tsCallBackExecutor);
         addWsCallback(resultFuture, success -> onTimeSeriesUpdate(tenantId, entityId, request.getEntries()));
         if (request.isSaveLatest() && !request.isOnlyLatest()) {
@@ -168,10 +167,9 @@ public class DefaultTelemetrySubscriptionService extends AbstractSubscriptionSer
         log.trace("Executing saveInternal [{}]", request);
         ListenableFuture<List<Long>> saveFuture = attrService.save(request.getTenantId(), request.getEntityId(), request.getScope(), request.getEntries());
         DonAsynchron.withCallback(saveFuture, result -> {
-            calculatedFieldExecutionService.pushRequestToQueue(request, result);
+            calculatedFieldExecutionService.pushRequestToQueue(request, result, request.getCallback());
         }, safeCallback(request.getCallback()), tsCallBackExecutor);
         addWsCallback(saveFuture, success -> onAttributesUpdate(request.getTenantId(), request.getEntityId(), request.getScope().name(), request.getEntries(), request.isNotifyDevice()));
-        addCallback(saveFuture, success -> calculatedFieldExecutionService.onTelemetryUpdate(new CalculatedFieldAttributeUpdateRequest(request)), tsCallBackExecutor);
     }
 
     @Override

application/src/main/resources/thingsboard.yml

@@ -441,6 +441,8 @@ actors:
     device_dispatcher_pool_size: "${ACTORS_SYSTEM_DEVICE_DISPATCHER_POOL_SIZE:4}" # Thread pool size for actor system dispatcher that process messages for device actors
     rule_dispatcher_pool_size: "${ACTORS_SYSTEM_RULE_DISPATCHER_POOL_SIZE:8}" # Thread pool size for actor system dispatcher that process messages for rule engine (chain/node) actors
     edge_dispatcher_pool_size: "${ACTORS_SYSTEM_EDGE_DISPATCHER_POOL_SIZE:4}" # Thread pool size for actor system dispatcher that process messages for edge actors
+    cfm_dispatcher_pool_size: "${ACTORS_SYSTEM_CFM_DISPATCHER_POOL_SIZE:2}" # Thread pool size for actor system dispatcher that process messages for CalculatedField manager actors
+    cfe_dispatcher_pool_size: "${ACTORS_SYSTEM_CFE_DISPATCHER_POOL_SIZE:8}" # Thread pool size for actor system dispatcher that process messages for CalculatedField entity actors
   tenant:
     create_components_on_init: "${ACTORS_TENANT_CREATE_COMPONENTS_ON_INIT:true}" # Create components in initialization
   session:

application/src/test/resources/application-test.properties

@@ -35,6 +35,8 @@ sql.events.batch_threads=2
 actors.system.tenant_dispatcher_pool_size=4
 actors.system.device_dispatcher_pool_size=8
 actors.system.rule_dispatcher_pool_size=12
+actors.system.cfm_dispatcher_pool_size=2
+actors.system.cfe_dispatcher_pool_size=2
 transport.sessions.report_timeout=10000
 queue.transport_api.request_poll_interval=5
 queue.transport_api.response_poll_interval=5

common/actor/src/main/java/org/thingsboard/server/actors/TbCalculatedFieldEntityActorId.java

@@ -0,0 +1,56 @@
+/**
+ * Copyright © 2016-2024 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.actors;
+
+import lombok.Getter;
+import org.thingsboard.server.common.data.EntityType;
+import org.thingsboard.server.common.data.id.EntityId;
+
+import java.util.Objects;
+
+public class TbCalculatedFieldEntityActorId implements TbActorId {
+
+    @Getter
+    private final EntityId entityId;
+
+    public TbCalculatedFieldEntityActorId(EntityId entityId) {
+        this.entityId = entityId;
+    }
+
+    @Override
+    public String toString() {
+        return entityId.getEntityType() + "|" + entityId.getId();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        TbCalculatedFieldEntityActorId that = (TbCalculatedFieldEntityActorId) o;
+        return entityId.equals(that.entityId);
+    }
+
+    @Override
+    public int hashCode() {
+        // Magic number to ensure that the hash does not match with the hash of other actor id - (TbEntityActorId)
+        return 42 + Objects.hash(entityId);
+    }
+
+    @Override
+    public EntityType getEntityType() {
+        return entityId.getEntityType();
+    }
+}

common/cluster-api/src/main/java/org/thingsboard/server/cluster/TbClusterService.java

@@ -22,7 +22,6 @@ import org.thingsboard.server.common.data.TbResourceInfo;
 import org.thingsboard.server.common.data.Tenant;
 import org.thingsboard.server.common.data.TenantProfile;
 import org.thingsboard.server.common.data.asset.Asset;
-import org.thingsboard.server.common.data.cf.CalculatedField;
 import org.thingsboard.server.common.data.edge.EdgeEventActionType;
 import org.thingsboard.server.common.data.edge.EdgeEventType;
 import org.thingsboard.server.common.data.id.EdgeId;
@@ -40,6 +39,7 @@ import org.thingsboard.server.common.msg.queue.TopicPartitionInfo;
 import org.thingsboard.server.common.msg.rpc.FromDeviceRpcResponse;
 import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.gen.transport.TransportProtos.RestApiCallResponseMsgProto;
+import org.thingsboard.server.gen.transport.TransportProtos.ToCalculatedFieldMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCoreMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCoreNotificationMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToEdgeMsg;
@@ -79,6 +79,8 @@ public interface TbClusterService extends TbQueueClusterService {
 
     void pushMsgToCalculatedFields(TenantId tenantId, EntityId entityId, TransportProtos.ToCalculatedFieldMsg msg, TbQueueCallback callback);
 
+    void pushMsgToCalculatedFields(TopicPartitionInfo tpi, UUID msgId, ToCalculatedFieldMsg msg, TbQueueCallback callback);
+
     void pushNotificationToCalculatedFields(TenantId tenantId, EntityId entityId, TransportProtos.ToCalculatedFieldNotificationMsg msg, TbQueueCallback callback);
 
     void broadcastEntityStateChangeEvent(TenantId tenantId, EntityId entityId, ComponentLifecycleEvent state);
@@ -125,8 +127,4 @@ public interface TbClusterService extends TbQueueClusterService {
 
     void sendNotificationMsgToEdge(TenantId tenantId, EdgeId edgeId, EntityId entityId, String body, EdgeEventType type, EdgeEventActionType action, EdgeId sourceEdgeId);
 
-    void onCalculatedFieldUpdated(CalculatedField calculatedField, CalculatedField oldCalculatedField);
-
-    void onCalculatedFieldDeleted(TenantId tenantId, CalculatedField calculatedField, TbQueueCallback callback);
-
 }

common/data/src/main/java/org/thingsboard/server/common/data/cf/configuration/ReferencedEntityKey.java

@@ -27,4 +27,6 @@ public class ReferencedEntityKey {
     private ArgumentType type;
     private AttributeScope scope;
 
+
+
 }

common/message/src/main/java/org/thingsboard/server/common/msg/MsgType.java

@@ -133,7 +133,16 @@ public enum MsgType {
      * Messages that are sent to and from edge session to start edge synchronization process
      */
     EDGE_SYNC_REQUEST_TO_EDGE_SESSION_MSG,
-    EDGE_SYNC_RESPONSE_FROM_EDGE_SESSION_MSG;
+    EDGE_SYNC_RESPONSE_FROM_EDGE_SESSION_MSG,
+
+    CF_INIT_MSG, // Sent to init particular calculated field;
+    CF_LINK_INIT_MSG, // Sent to init particular calculated field;
+    CF_STATE_RESTORE_MSG,// Sent to init particular calculated field entity state;
+    CF_TELEMETRY_MSG,
+    CF_ENTITY_TELEMETRY_MSG,
+    CF_LINKED_TELEMETRY_MSG,
+    CF_UPDATE_MSG,
+    CF_ENTITY_UPDATE_MSG;
 
     @Getter
     private final boolean ignoreOnStart;

common/message/src/main/java/org/thingsboard/server/common/msg/ToCalculatedFieldSystemMsg.java

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

common/message/src/main/java/org/thingsboard/server/common/msg/cf/CalculatedFieldInitMsg.java

@@ -0,0 +1,34 @@
+/**
+ * Copyright © 2016-2024 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.msg.cf;
+
+import lombok.Data;
+import org.thingsboard.server.common.data.cf.CalculatedField;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.msg.MsgType;
+import org.thingsboard.server.common.msg.ToCalculatedFieldSystemMsg;
+
+@Data
+public class CalculatedFieldInitMsg implements ToCalculatedFieldSystemMsg {
+
+    private final TenantId tenantId;
+    private final CalculatedField cf;
+
+    @Override
+    public MsgType getMsgType() {
+        return MsgType.CF_INIT_MSG;
+    }
+}

common/message/src/main/java/org/thingsboard/server/common/msg/cf/CalculatedFieldLinkInitMsg.java

@@ -0,0 +1,34 @@
+/**
+ * Copyright © 2016-2024 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.msg.cf;
+
+import lombok.Data;
+import org.thingsboard.server.common.data.cf.CalculatedFieldLink;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.msg.MsgType;
+import org.thingsboard.server.common.msg.ToCalculatedFieldSystemMsg;
+
+@Data
+public class CalculatedFieldLinkInitMsg implements ToCalculatedFieldSystemMsg {
+
+    private final TenantId tenantId;
+    private final CalculatedFieldLink link;
+
+    @Override
+    public MsgType getMsgType() {
+        return MsgType.CF_LINK_INIT_MSG;
+    }
+}

common/proto/src/main/java/org/thingsboard/server/common/util/ProtoUtils.java

@@ -58,6 +58,7 @@ import org.thingsboard.server.common.data.id.TenantProfileId;
 import org.thingsboard.server.common.data.kv.AttributeKey;
 import org.thingsboard.server.common.data.kv.AttributeKvEntry;
 import org.thingsboard.server.common.data.kv.BaseAttributeKvEntry;
+import org.thingsboard.server.common.data.kv.BasicTsKvEntry;
 import org.thingsboard.server.common.data.kv.BooleanDataEntry;
 import org.thingsboard.server.common.data.kv.DoubleDataEntry;
 import org.thingsboard.server.common.data.kv.JsonDataEntry;
@@ -628,12 +629,28 @@ public class ProtoUtils {
         return new BaseAttributeKvEntry(entry, proto.getLastUpdateTs(), proto.hasVersion() ? proto.getVersion() : null);
     }
 
+    public static TsKvEntry fromProto(TransportProtos.TsKvProto proto) {
+        TransportProtos.KeyValueProto kvProto = proto.getKv();
+        String key = kvProto.getKey();
+        KvEntry entry = switch (kvProto.getType()) {
+            case BOOLEAN_V -> new BooleanDataEntry(key, kvProto.getBoolV());
+            case LONG_V -> new LongDataEntry(key, kvProto.getLongV());
+            case DOUBLE_V -> new DoubleDataEntry(key, kvProto.getDoubleV());
+            case STRING_V -> new StringDataEntry(key, kvProto.getStringV());
+            case JSON_V -> new JsonDataEntry(key, kvProto.getJsonV());
+            default -> null;
+        };
+        return new BasicTsKvEntry(proto.getTs(), entry, proto.hasVersion() ? proto.getVersion() : null);
+    }
+
     public static TransportProtos.TsKvProto toTsKvProto(TsKvEntry tsKvEntry) {
-        return TransportProtos.TsKvProto.newBuilder()
+        var builder = TransportProtos.TsKvProto.newBuilder()
                 .setTs(tsKvEntry.getTs())
-                .setKv(toKeyValueProto(tsKvEntry))
-                .setVersion(tsKvEntry.getVersion())
-                .build();
+                .setKv(toKeyValueProto(tsKvEntry));
+        if (tsKvEntry.getVersion() != null) {
+            builder.setVersion(tsKvEntry.getVersion());
+        }
+        return builder.build();
     }
 
     public static TransportProtos.KeyValueProto toKeyValueProto(KvEntry kvEntry) {

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

@@ -1591,8 +1591,6 @@ message ToCoreMsg {
   DeviceConnectProto deviceConnectMsg = 50;
   DeviceDisconnectProto deviceDisconnectMsg = 51;
   DeviceInactivityProto deviceInactivityMsg = 52;
-//  CalculatedFieldMsgProto calculatedFieldMsg = 53;
-//  EntityProfileUpdateMsgProto entityProfileUpdateMsg = 54;
 }
 
 /* High priority messages with low latency are handled by ThingsBoard Core Service separately */
@@ -1612,8 +1610,6 @@ message ToCoreNotificationMsg {
   FromEdgeSyncResponseMsgProto fromEdgeSyncResponse = 12 [deprecated = true];
   ResourceCacheInvalidateMsg resourceCacheInvalidateMsg = 13;
   RestApiCallResponseMsgProto restApiCallResponseMsg = 50;
-//  EntityProfileUpdateMsgProto entityProfileUpdateMsg = 51;
-//  ProfileEntityMsgProto profileEntityMsg = 52;
 }
 
 /* Messages to Edge queue that are handled by ThingsBoard Core Service */

common/queue/src/main/java/org/thingsboard/server/queue/util/AfterStartUp.java

@@ -38,6 +38,10 @@ public @interface AfterStartUp {
     int ACTOR_SYSTEM = 9;
     int REGULAR_SERVICE = 10;
 
+    int CF_INIT_SERVICE = 10;
+    int CF_STATE_RESTORE_SERVICE = 11;
+    int CF_CONSUMER_SERVICE = 12;
+
     int BEFORE_TRANSPORT_SERVICE = Integer.MAX_VALUE - 1001;
     int TRANSPORT_SERVICE = Integer.MAX_VALUE - 1000;
     int AFTER_TRANSPORT_SERVICE = Integer.MAX_VALUE - 999;

dao/src/main/java/org/thingsboard/server/dao/sql/cf/DefaultNativeCalculatedFieldRepository.java

@@ -77,7 +77,7 @@ public class DefaultNativeCalculatedFieldRepository implements NativeCalculatedF
                 String name = (String) row.get("name");
                 int configurationVersion = (int) row.get("configuration_version");
                 JsonNode configuration = JacksonUtil.toJsonNode((String) row.get("configuration"));
-                long version = (long) row.get("version");
+                long version = row.get("version") != null ? (long) row.get("version") : 0;
                 Object externalIdObj = row.get("external_id");
 
                 CalculatedField calculatedField = new CalculatedField();

dao/src/test/java/org/thingsboard/server/dao/service/EntityServiceTest.java

@@ -46,6 +46,7 @@ import org.thingsboard.server.common.data.kv.DoubleDataEntry;
 import org.thingsboard.server.common.data.kv.KvEntry;
 import org.thingsboard.server.common.data.kv.LongDataEntry;
 import org.thingsboard.server.common.data.kv.StringDataEntry;
+import org.thingsboard.server.common.data.kv.TimeseriesSaveResult;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.query.ApiUsageStateFilter;
 import org.thingsboard.server.common.data.query.AssetSearchQueryFilter;
@@ -1824,7 +1825,7 @@ public class EntityServiceTest extends AbstractServiceTest {
             }
         }
 
-        List<ListenableFuture<Integer>> timeseriesFutures = new ArrayList<>();
+        List<ListenableFuture<TimeseriesSaveResult>> timeseriesFutures = new ArrayList<>();
         for (int i = 0; i < devices.size(); i++) {
             Device device = devices.get(i);
             timeseriesFutures.add(saveLongTimeseries(device.getId(), "temperature", temperatures.get(i)));
@@ -2430,7 +2431,7 @@ public class EntityServiceTest extends AbstractServiceTest {
         return attributesService.save(SYSTEM_TENANT_ID, entityId, scope, Collections.singletonList(attr));
     }
 
-    private ListenableFuture<Integer> saveLongTimeseries(EntityId entityId, String key, Double value) {
+    private ListenableFuture<TimeseriesSaveResult> saveLongTimeseries(EntityId entityId, String key, Double value) {
         TsKvEntity tsKv = new TsKvEntity();
         tsKv.setStrKey(key);
         tsKv.setDoubleValue(value);

dao/src/test/resources/application-test.properties

@@ -145,6 +145,8 @@ sql.events.batch_threads=2
 actors.system.tenant_dispatcher_pool_size=4
 actors.system.device_dispatcher_pool_size=8
 actors.system.rule_dispatcher_pool_size=12
+actors.system.cfm_dispatcher_pool_size=2
+actors.system.cfe_dispatcher_pool_size=2
 transport.sessions.report_timeout=10000
 queue.transport_api.request_poll_interval=5
 queue.transport_api.response_poll_interval=5