diff --git a/agents/agentreq_test.go b/agents/agentreq_test.go
index c404ebad8..235fac2c2 100644
--- a/agents/agentreq_test.go
+++ b/agents/agentreq_test.go
@@ -2066,7 +2066,8 @@ func TestAgReqSetFieldsInCache(t *testing.T) {
 	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := engine.NewDataManager(data, config.CgrConfig().CacheCfg(), nil)
 	filterS := engine.NewFilterS(cfg, nil, dm)
-	engine.NewCacheS(cfg, dm, nil)
+	connMgr := engine.NewConnManager(cfg)
+	engine.NewCacheS(cfg, dm, connMgr, nil)
 	agReq := NewAgentRequest(nil, nil, nil, nil, nil, nil, "cgrates.org", "", filterS, nil)
 	agReq.CGRRequest.Set(&utils.FullPath{Path: utils.AccountField, PathSlice: []string{utils.AccountField}}, utils.NewLeafNode("1001"))
 
@@ -2107,9 +2108,10 @@ func TestAgReqSetFieldsInCacheWithTimeOut(t *testing.T) {
 	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := engine.NewDataManager(data, config.CgrConfig().CacheCfg(), nil)
 	filterS := engine.NewFilterS(cfg, nil, dm)
+	connMgr := engine.NewConnManager(cfg)
 
 	cfg.CacheCfg().Partitions[utils.CacheUCH].TTL = time.Second
-	engine.Cache = engine.NewCacheS(cfg, dm, nil)
+	engine.Cache = engine.NewCacheS(cfg, dm, connMgr, nil)
 	agReq := NewAgentRequest(nil, nil, nil, nil, nil, nil, "cgrates.org", "", filterS, nil)
 	agReq.CGRRequest.Set(&utils.FullPath{Path: utils.AccountField, PathSlice: []string{utils.AccountField}}, utils.NewLeafNode("1001"))
 
diff --git a/apis/accounts_test.go b/apis/accounts_test.go
index 9456e608d..19d8391d3 100644
--- a/apis/accounts_test.go
+++ b/apis/accounts_test.go
@@ -187,7 +187,7 @@ func TestAccountsGetAccountErrorNotFound(t *testing.T) {
 	connMgr := engine.NewConnManager(cfg)
 	dataDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := engine.NewDataManager(dataDB, nil, connMgr)
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, connMgr, nil)
 	engine.Cache = newCache
 	admS := NewAdminSv1(cfg, dm, connMgr, nil)
 	var getRply utils.Account
@@ -212,7 +212,7 @@ func TestAccountsGetAccountErrorGetAccount(t *testing.T) {
 	connMgr := engine.NewConnManager(cfg)
 	dataDB := &engine.DataDBMock{}
 	dm := engine.NewDataManager(dataDB, nil, connMgr)
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, connMgr, nil)
 	engine.Cache = newCache
 	admS := NewAdminSv1(cfg, dm, connMgr, nil)
 	var getRply utils.Account
@@ -434,7 +434,7 @@ func TestAccountsSetGetAccountErrorSetLoadIDs(t *testing.T) {
 	}
 	dm := engine.NewDataManager(dataDB, nil, connMgr)
 	admS := NewAdminSv1(cfg, dm, connMgr, nil)
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, connMgr, nil)
 	engine.Cache = newCache
 	args := &utils.AccountWithAPIOpts{
 		Account: &utils.Account{
@@ -502,7 +502,7 @@ func TestAccountsSetGetAccountErrorCallCache(t *testing.T) {
 	}
 	dm := engine.NewDataManager(dataDB, nil, connMgr)
 	admS := NewAdminSv1(cfg, dm, connMgr, nil)
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, connMgr, nil)
 	engine.Cache = newCache
 	args := &utils.AccountWithAPIOpts{
 		Account: &utils.Account{
@@ -940,7 +940,7 @@ func TestAccountsAccountsForEvent(t *testing.T) {
 	dataDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := engine.NewDataManager(dataDB, nil, connMgr)
 	admS := NewAdminSv1(cfg, dm, connMgr, nil)
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, connMgr, nil)
 	engine.Cache = newCache
 	args := &utils.AccountWithAPIOpts{
 		Account: &utils.Account{
@@ -1087,7 +1087,7 @@ func TestAccountsMaxAbstracts(t *testing.T) {
 	dataDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := engine.NewDataManager(dataDB, nil, connMgr)
 	admS := NewAdminSv1(cfg, dm, connMgr, nil)
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, connMgr, nil)
 	engine.Cache = newCache
 	args := &utils.AccountWithAPIOpts{
 		Account: &utils.Account{
@@ -1280,7 +1280,7 @@ func TestAccountsDebitAbstracts(t *testing.T) {
 	dataDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := engine.NewDataManager(dataDB, nil, connMgr)
 	admS := NewAdminSv1(cfg, dm, connMgr, nil)
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, connMgr, nil)
 	engine.Cache = newCache
 	args := &utils.AccountWithAPIOpts{
 		Account: &utils.Account{
@@ -1472,7 +1472,7 @@ func TestAccountsActionSetBalance(t *testing.T) {
 	dataDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := engine.NewDataManager(dataDB, nil, connMgr)
 	admS := NewAdminSv1(cfg, dm, connMgr, nil)
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, connMgr, nil)
 	engine.Cache = newCache
 	args := &utils.AccountWithAPIOpts{
 		Account: &utils.Account{
diff --git a/apis/cache_test.go b/apis/cache_test.go
index 68d1e97b7..2072f7163 100644
--- a/apis/cache_test.go
+++ b/apis/cache_test.go
@@ -35,7 +35,8 @@ func TestCacheHasItemAndGetItem(t *testing.T) {
 	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	cfg.AdminSCfg().CachesConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}
 	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
-	ch := engine.NewCacheS(cfg, dm, nil)
+	connMgr := engine.NewConnManager(cfg)
+	ch := engine.NewCacheS(cfg, dm, connMgr, nil)
 	ch.SetWithoutReplicate(utils.CacheAttributeProfiles, "cgrates.org:TestGetAttributeProfile", nil, nil, true, utils.NonTransactional)
 	cache := NewCacheSv1(ch)
 
@@ -71,7 +72,8 @@ func TestCacheSetAndRemoveItem(t *testing.T) {
 	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	cfg.AdminSCfg().CachesConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}
 	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
-	ch := engine.NewCacheS(cfg, dm, nil)
+	connMgr := engine.NewConnManager(cfg)
+	ch := engine.NewCacheS(cfg, dm, connMgr, nil)
 	ch.SetWithoutReplicate(utils.CacheAttributeProfiles, "cgrates.org:TestCacheSetAndRemoveItem", nil, nil, true, utils.NonTransactional)
 	cache := NewCacheSv1(ch)
 
@@ -129,7 +131,8 @@ func TestCacheSetAndRemoveItems(t *testing.T) {
 	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	cfg.AdminSCfg().CachesConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}
 	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
-	ch := engine.NewCacheS(cfg, dm, nil)
+	connMgr := engine.NewConnManager(cfg)
+	ch := engine.NewCacheS(cfg, dm, connMgr, nil)
 	ch.SetWithoutReplicate(utils.CacheAttributeProfiles, "cgrates.org:TestCacheSetAndRemoveItems1", nil, nil, true, utils.NonTransactional)
 	ch.SetWithoutReplicate(utils.CacheAttributeProfiles, "cgrates.org:TestCacheSetAndRemoveItems2", nil, nil, true, utils.NonTransactional)
 	ch.SetWithoutReplicate(utils.CacheAttributeProfiles, "cgrates.org:TestCacheSetAndRemoveItems3", nil, nil, true, utils.NonTransactional)
@@ -187,7 +190,8 @@ func TestCacheClear(t *testing.T) {
 	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	cfg.AdminSCfg().CachesConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}
 	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
-	ch := engine.NewCacheS(cfg, dm, nil)
+	connMgr := engine.NewConnManager(cfg)
+	ch := engine.NewCacheS(cfg, dm, connMgr, nil)
 	ch.SetWithoutReplicate(utils.CacheAttributeProfiles, "cgrates.org:TestCacheClearAttributes", nil, nil, true, utils.NonTransactional)
 	ch.SetWithoutReplicate(utils.CacheRateProfiles, "cgrates.org:TestCacheClearRates", nil, nil, true, utils.NonTransactional)
 	cache := NewCacheSv1(ch)
@@ -227,7 +231,8 @@ func TestCacheLoadCache(t *testing.T) {
 	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	cfg.AdminSCfg().CachesConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}
 	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
-	ch := engine.NewCacheS(cfg, dm, nil)
+	connMgr := engine.NewConnManager(cfg)
+	ch := engine.NewCacheS(cfg, dm, connMgr, nil)
 	cache := NewCacheSv1(ch)
 
 	var reply string
@@ -255,7 +260,8 @@ func TestCacheReloadCache(t *testing.T) {
 	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	cfg.AdminSCfg().CachesConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}
 	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
-	ch := engine.NewCacheS(cfg, dm, nil)
+	connMgr := engine.NewConnManager(cfg)
+	ch := engine.NewCacheS(cfg, dm, connMgr, nil)
 	cache := NewCacheSv1(ch)
 
 	var reply string
@@ -283,7 +289,8 @@ func TestGetCacheStats(t *testing.T) {
 	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	cfg.AdminSCfg().CachesConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}
 	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
-	ch := engine.NewCacheS(cfg, dm, nil)
+	connMgr := engine.NewConnManager(cfg)
+	ch := engine.NewCacheS(cfg, dm, connMgr, nil)
 	cache := NewCacheSv1(ch)
 	ch.SetWithoutReplicate(utils.CacheAttributeProfiles, "cgrates.org:TestGetCacheStats", nil, nil, true, utils.NonTransactional)
 	var reply map[string]*ltcache.CacheStats
@@ -306,7 +313,8 @@ func TestPrecacheStatus(t *testing.T) {
 	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	cfg.AdminSCfg().CachesConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}
 	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
-	ch := engine.NewCacheS(cfg, dm, nil)
+	connMgr := engine.NewConnManager(cfg)
+	ch := engine.NewCacheS(cfg, dm, connMgr, nil)
 	cache := NewCacheSv1(ch)
 
 	var reply map[string]string
@@ -332,7 +340,8 @@ func TestHasGroup(t *testing.T) {
 	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	cfg.AdminSCfg().CachesConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}
 	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
-	ch := engine.NewCacheS(cfg, dm, nil)
+	connMgr := engine.NewConnManager(cfg)
+	ch := engine.NewCacheS(cfg, dm, connMgr, nil)
 	cache := NewCacheSv1(ch)
 
 	var reply bool
@@ -358,7 +367,8 @@ func TestGetGroupItemIDs(t *testing.T) {
 	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	cfg.AdminSCfg().CachesConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}
 	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
-	ch := engine.NewCacheS(cfg, dm, nil)
+	connMgr := engine.NewConnManager(cfg)
+	ch := engine.NewCacheS(cfg, dm, connMgr, nil)
 	cache := NewCacheSv1(ch)
 
 	ch.SetWithoutReplicate(utils.CacheAttributeProfiles, "cgrates.org:TestGetCacheStats", nil, []string{"AttrGroup"}, true, utils.NonTransactional)
@@ -388,7 +398,8 @@ func TestRemoveGroup(t *testing.T) {
 	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	cfg.AdminSCfg().CachesConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}
 	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
-	ch := engine.NewCacheS(cfg, dm, nil)
+	connMgr := engine.NewConnManager(cfg)
+	ch := engine.NewCacheS(cfg, dm, connMgr, nil)
 	cache := NewCacheSv1(ch)
 
 	var reply string
@@ -415,7 +426,8 @@ func TestReplicateSet(t *testing.T) {
 	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	cfg.AdminSCfg().CachesConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}
 	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
-	ch := engine.NewCacheS(cfg, dm, nil)
+	connMgr := engine.NewConnManager(cfg)
+	ch := engine.NewCacheS(cfg, dm, connMgr, nil)
 	cache := NewCacheSv1(ch)
 
 	var reply string
@@ -438,7 +450,8 @@ func TestReplicateRemove(t *testing.T) {
 	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	cfg.AdminSCfg().CachesConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}
 	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
-	ch := engine.NewCacheS(cfg, dm, nil)
+	connMgr := engine.NewConnManager(cfg)
+	ch := engine.NewCacheS(cfg, dm, connMgr, nil)
 	cache := NewCacheSv1(ch)
 
 	var reply string
@@ -461,7 +474,8 @@ func TestGetItemExpiryTime(t *testing.T) {
 	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	cfg.AdminSCfg().CachesConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}
 	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
-	ch := engine.NewCacheS(cfg, dm, nil)
+	connMgr := engine.NewConnManager(cfg)
+	ch := engine.NewCacheS(cfg, dm, connMgr, nil)
 	cache := NewCacheSv1(ch)
 
 	var reply time.Time
diff --git a/apis/chargers_test.go b/apis/chargers_test.go
index e9efaa9dd..0971f067a 100644
--- a/apis/chargers_test.go
+++ b/apis/chargers_test.go
@@ -70,7 +70,7 @@ func TestChargerSDmSetChargerProfileErr(t *testing.T) {
 	connMgr := engine.NewConnManager(cfg)
 	dataDB := &engine.DataDBMock{}
 	dm := engine.NewDataManager(dataDB, nil, connMgr)
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, connMgr, nil)
 	engine.Cache = newCache
 	admS := NewAdminSv1(cfg, dm, connMgr, nil)
 	var setRply string
@@ -120,7 +120,7 @@ func TestChargerSSetChargerProfileSetLoadIDsErr(t *testing.T) {
 		},
 	}
 	dm := engine.NewDataManager(dataDB, nil, connMgr)
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, connMgr, nil)
 	engine.Cache = newCache
 	admS := NewAdminSv1(cfg, dm, connMgr, nil)
 	var setRply string
@@ -177,7 +177,7 @@ func TestChargerSSetChargerProfileCallCacheErr(t *testing.T) {
 		},
 	}
 	dm := engine.NewDataManager(dataDB, nil, connMgr)
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, connMgr, nil)
 	engine.Cache = newCache
 	admS := NewAdminSv1(cfg, dm, connMgr, nil)
 	var setRply string
@@ -299,7 +299,7 @@ func TestChargerSSetGetChargerProfileIDsErr(t *testing.T) {
 	}
 	dm := engine.NewDataManager(dataDB, nil, connMgr)
 	admS := NewAdminSv1(cfg, dm, connMgr, nil)
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, connMgr, nil)
 	engine.Cache = newCache
 	var getRply []string
 	err := admS.GetChargerProfileIDs(context.Background(),
@@ -320,7 +320,7 @@ func TestChargerSSetGetChargerProfileIDsErr2(t *testing.T) {
 	dataDB := &engine.DataDBMock{}
 	dm := engine.NewDataManager(dataDB, nil, connMgr)
 	admS := NewAdminSv1(cfg, dm, connMgr, nil)
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, connMgr, nil)
 	engine.Cache = newCache
 	var getRply []string
 	err := admS.GetChargerProfileIDs(context.Background(),
@@ -538,7 +538,7 @@ func TestChargerSRmvChargerProfileErrRemoveChargerProfile(t *testing.T) {
 	connMgr := engine.NewConnManager(cfg)
 	dataDB := &engine.DataDBMock{}
 	dm := engine.NewDataManager(dataDB, nil, connMgr)
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, connMgr, nil)
 	engine.Cache = newCache
 	admS := NewAdminSv1(cfg, dm, connMgr, nil)
 	var rmvRply string
@@ -582,7 +582,7 @@ func TestChargerSRmvChargerProfileErrSetLoadIDs(t *testing.T) {
 		},
 	}
 	dm := engine.NewDataManager(dataDB, nil, connMgr)
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, connMgr, nil)
 	engine.Cache = newCache
 	admS := NewAdminSv1(cfg, dm, connMgr, nil)
 	var rmvRply string
@@ -634,7 +634,7 @@ func TestChargerSRmvChargerProfileErrRemoveCallCache(t *testing.T) {
 		},
 	}
 	dm := engine.NewDataManager(dataDB, nil, connMgr)
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, connMgr, nil)
 	engine.Cache = newCache
 	admS := NewAdminSv1(cfg, dm, connMgr, nil)
 	var rmvRply string
diff --git a/dispatchers/dispatchers_test.go b/dispatchers/dispatchers_test.go
index 9229087f0..665f3edfb 100644
--- a/dispatchers/dispatchers_test.go
+++ b/dispatchers/dispatchers_test.go
@@ -238,10 +238,10 @@ func TestDispatcherServiceAuthorizeEvenError1(t *testing.T) {
 	cacheInit := engine.Cache
 	cfg := config.NewDefaultCGRConfig()
 	dm := engine.NewDataManager(nil, nil, nil)
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	connMgr := engine.NewConnManager(cfg)
+	newCache := engine.NewCacheS(cfg, dm, connMgr, nil)
 	engine.Cache = newCache
 	fltr := &engine.FilterS{}
-	connMgr := &engine.ConnManager{}
 	dsp := NewDispatcherService(dm, cfg, fltr, connMgr)
 	cfg.DispatcherSCfg().AttributeSConns = []string{"connID"}
 	ev := &utils.CGREvent{}
@@ -260,10 +260,10 @@ func TestDispatcherServiceAuthorizeEventError2(t *testing.T) {
 	cacheInit := engine.Cache
 	cfg := config.NewDefaultCGRConfig()
 	dm := engine.NewDataManager(nil, nil, nil)
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	connMgr := engine.NewConnManager(cfg)
+	newCache := engine.NewCacheS(cfg, dm, connMgr, nil)
 	engine.Cache = newCache
 	fltr := &engine.FilterS{}
-	connMgr := &engine.ConnManager{}
 	dsp := NewDispatcherService(dm, cfg, fltr, connMgr)
 	cfg.DispatcherSCfg().AttributeSConns = []string{"connID"}
 	ev := &utils.CGREvent{}
@@ -322,7 +322,7 @@ func TestDispatcherServiceAuthorizeEventError3(t *testing.T) {
 	}
 	value := &lazyDH{dh: dh, cfg: cfg, iPRCCh: chanRPC}
 
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, connMgr, nil)
 	engine.Cache = newCache
 	engine.Cache.SetWithoutReplicate(utils.CacheRPCConnections, "testID",
 		value, nil, true, utils.NonTransactional)
@@ -371,7 +371,7 @@ func TestDispatcherServiceAuthorizeError(t *testing.T) {
 		},
 	}
 	value := &lazyDH{dh: dh, cfg: cfg, iPRCCh: chanRPC}
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, connMgr, nil)
 	engine.Cache = newCache
 	engine.Cache.SetWithoutReplicate(utils.CacheRPCConnections, "testID",
 		value, nil, true, utils.NonTransactional)
@@ -419,7 +419,7 @@ func TestDispatcherServiceAuthorizeError2(t *testing.T) {
 	}
 	value := &lazyDH{dh: dh, cfg: cfg, iPRCCh: chanRPC}
 
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, connMgr, nil)
 	engine.Cache = newCache
 	engine.Cache.SetWithoutReplicate(utils.CacheRPCConnections, "testID",
 		value, nil, true, utils.NonTransactional)
@@ -469,7 +469,7 @@ func TestDispatcherServiceAuthorizeError3(t *testing.T) {
 	}
 	value := &lazyDH{dh: dh, cfg: cfg, iPRCCh: chanRPC}
 
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, connMgr, nil)
 	engine.Cache = newCache
 	engine.Cache.SetWithoutReplicate(utils.CacheRPCConnections, "testID",
 		value, nil, true, utils.NonTransactional)
@@ -966,7 +966,7 @@ func TestDispatcherServiceDispatchDspErrHostNotFound2(t *testing.T) {
 		Weight:         0,
 		Hosts:          nil,
 	}
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, connMng, nil)
 	value, errDsp := newDispatcher(dsp)
 	if errDsp != nil {
 		t.Fatal(errDsp)
@@ -1030,7 +1030,7 @@ func TestDispatcherServiceDispatchDspErrHostNotFound3(t *testing.T) {
 		Weight:         0,
 		Hosts:          nil,
 	}
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, connMgr, nil)
 	engine.Cache = newCache
 
 	err := dm.SetDispatcherProfile(context.TODO(), dsp, false)
@@ -1068,7 +1068,8 @@ func TestDispatchersdispatcherProfileForEventAnySSfalseFirstNotFound(t *testing.
 	cfg := config.NewDefaultCGRConfig()
 	dataDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := engine.NewDataManager(dataDB, cfg.CacheCfg(), nil)
-	engine.Cache = engine.NewCacheS(cfg, dm, nil)
+	connMgr := engine.NewConnManager(cfg)
+	engine.Cache = engine.NewCacheS(cfg, dm, connMgr, nil)
 
 	dS := &DispatcherService{
 		cfg:   cfg,
@@ -1135,8 +1136,9 @@ func TestDispatchersdispatcherProfileForEventAnySSfalseFound(t *testing.T) {
 
 	cfg := config.NewDefaultCGRConfig()
 	dataDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	connMgr := engine.NewConnManager(cfg)
 	dm := engine.NewDataManager(dataDB, cfg.CacheCfg(), nil)
-	engine.Cache = engine.NewCacheS(cfg, dm, nil)
+	engine.Cache = engine.NewCacheS(cfg, dm, connMgr, nil)
 
 	dS := &DispatcherService{
 		cfg:   cfg,
@@ -1203,8 +1205,9 @@ func TestDispatchersdispatcherProfileForEventAnySSfalseNotFound(t *testing.T) {
 
 	cfg := config.NewDefaultCGRConfig()
 	dataDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	connMgr := engine.NewConnManager(cfg)
 	dm := engine.NewDataManager(dataDB, cfg.CacheCfg(), nil)
-	engine.Cache = engine.NewCacheS(cfg, dm, nil)
+	engine.Cache = engine.NewCacheS(cfg, dm, connMgr, nil)
 
 	dS := &DispatcherService{
 		cfg:   cfg,
@@ -1269,8 +1272,9 @@ func TestDispatchersdispatcherProfileForEventAnySStrueNotFound(t *testing.T) {
 
 	cfg := config.NewDefaultCGRConfig()
 	dataDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	connMgr := engine.NewConnManager(cfg)
 	dm := engine.NewDataManager(dataDB, cfg.CacheCfg(), nil)
-	engine.Cache = engine.NewCacheS(cfg, dm, nil)
+	engine.Cache = engine.NewCacheS(cfg, dm, connMgr, nil)
 
 	dS := &DispatcherService{
 		cfg:   cfg,
@@ -1335,8 +1339,9 @@ func TestDispatchersdispatcherProfileForEventAnySStrueBothFound(t *testing.T) {
 
 	cfg := config.NewDefaultCGRConfig()
 	dataDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	connMgr := engine.NewConnManager(cfg)
 	dm := engine.NewDataManager(dataDB, cfg.CacheCfg(), nil)
-	engine.Cache = engine.NewCacheS(cfg, dm, nil)
+	engine.Cache = engine.NewCacheS(cfg, dm, connMgr, nil)
 
 	dS := &DispatcherService{
 		cfg:   cfg,
diff --git a/dispatchers/libdispatcher_test.go b/dispatchers/libdispatcher_test.go
index ee0a267ec..7b6371841 100644
--- a/dispatchers/libdispatcher_test.go
+++ b/dispatchers/libdispatcher_test.go
@@ -472,7 +472,7 @@ func TestLibDispatcherLoadStrategyDispatchCaseCallError(t *testing.T) {
 func TestLibDispatcherLoadStrategyDispatchCaseHostsCastError(t *testing.T) {
 	cacheInit := engine.Cache
 	cfg := config.NewDefaultCGRConfig()
-	newCache := engine.NewCacheS(cfg, nil, nil)
+	newCache := engine.NewCacheS(cfg, nil, nil, nil)
 	engine.Cache = newCache
 	engine.Cache.SetWithoutReplicate(utils.CacheDispatcherLoads, "testID",
 		false, nil, true, utils.NonTransactional)
@@ -528,7 +528,7 @@ func TestLibDispatcherSingleResultDispatcherCastError(t *testing.T) {
 	cacheInit := engine.Cache
 	cfg := config.NewDefaultCGRConfig()
 	dm := engine.NewDataManager(nil, nil, nil)
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, nil, nil)
 	engine.Cache = newCache
 	value := &engine.DispatcherHost{
 		Tenant: "testTenant",
@@ -560,7 +560,7 @@ func TestLibDispatcherBroadcastDispatcherDispatchError1(t *testing.T) {
 	cacheInit := engine.Cache
 	cfg := config.NewDefaultCGRConfig()
 	dm := engine.NewDataManager(nil, nil, nil)
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, nil, nil)
 	engine.Cache = newCache
 	value := &engine.DispatcherHost{
 		Tenant: "testTenant",
@@ -586,7 +586,7 @@ func TestLibDispatcherBroadcastDispatcherDispatchError2(t *testing.T) {
 	cacheInit := engine.Cache
 	cfg := config.NewDefaultCGRConfig()
 	dm := engine.NewDataManager(nil, nil, nil)
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, nil, nil)
 	engine.Cache = newCache
 
 	engine.Cache.SetWithoutReplicate(utils.CacheDispatcherHosts, "testTenant:testID",
@@ -604,7 +604,7 @@ func TestLibDispatcherBroadcastDispatcherDispatchError3(t *testing.T) {
 	cacheInit := engine.Cache
 	cfg := config.NewDefaultCGRConfig()
 	dm := engine.NewDataManager(nil, nil, nil)
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, nil, nil)
 	engine.Cache = newCache
 	value := &engine.DispatcherHost{
 		Tenant: "testTenant",
@@ -646,7 +646,7 @@ func TestLibDispatcherLoadDispatcherCacheError4(t *testing.T) {
 	dataDB := engine.NewInternalDB(nil, nil, nil)
 	dm := engine.NewDataManager(dataDB, nil, connMng)
 
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, connMng, nil)
 	engine.Cache = newCache
 	value := &engine.DispatcherHost{
 		Tenant: "testTenant",
@@ -704,7 +704,7 @@ func TestLibDispatcherLoadDispatcherCacheError5(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 
 	dm := engine.NewDataManager(nil, nil, nil)
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, nil, nil)
 	engine.Cache = newCache
 	value := &engine.DispatcherHost{
 		Tenant: "testTenant",
@@ -745,7 +745,7 @@ func TestLibDispatcherSingleResultDispatcherCase1(t *testing.T) {
 	cacheInit := engine.Cache
 	cfg := config.NewDefaultCGRConfig()
 	dm := engine.NewDataManager(nil, nil, nil)
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, nil, nil)
 	engine.Cache = newCache
 	value := &engine.DispatcherHost{
 		Tenant: "testTenant",
@@ -778,7 +778,7 @@ func TestLibDispatcherSingleResultDispatcherCase2(t *testing.T) {
 	cacheInit := engine.Cache
 	cfg := config.NewDefaultCGRConfig()
 	dm := engine.NewDataManager(nil, nil, nil)
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, nil, nil)
 	engine.Cache = newCache
 	value := &engine.DispatcherHost{
 		Tenant: "testTenant",
@@ -820,7 +820,7 @@ func TestLibDispatcherSingleResultDispatcherCase3(t *testing.T) {
 	}
 	connMng := engine.NewConnManager(cfg)
 	dm := engine.NewDataManager(nil, nil, connMng)
-	newCache := engine.NewCacheS(cfg, dm, nil)
+	newCache := engine.NewCacheS(cfg, dm, connMng, nil)
 	engine.Cache = newCache
 	value := &engine.DispatcherHost{
 		Tenant: "testTenant",
diff --git a/engine/caps_test.go b/engine/caps_test.go
index e32358e2f..49269ead2 100644
--- a/engine/caps_test.go
+++ b/engine/caps_test.go
@@ -140,7 +140,7 @@ func TestCapsStatsGetAverageOnEvict(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	cfg.CacheCfg().Partitions[utils.CacheCapsEvents] = &config.CacheParamCfg{Limit: 2}
 	tmp := Cache
-	Cache = NewCacheS(cfg, nil, cs)
+	Cache = NewCacheS(cfg, nil, nil, cs)
 
 	cs.addSample("1", 10)
 	expAvg := 10.
diff --git a/engine/cdrs_test.go b/engine/cdrs_test.go
index 6c6eb8c28..e00e027ec 100644
--- a/engine/cdrs_test.go
+++ b/engine/cdrs_test.go
@@ -334,7 +334,7 @@ func TestCDRsAttrSProcessEventMock(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -411,7 +411,7 @@ func TestCDRsAttrSProcessEventMockNotFoundErr(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -490,7 +490,7 @@ func TestCDRsAttrSProcessEventMockNotEmptyAF(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -655,7 +655,7 @@ func TestCDRsRateProcessEventMock(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -731,7 +731,7 @@ func TestCDRsAccountProcessEventMock(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -809,7 +809,7 @@ func TestCDRsThdSProcessEventMock(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -879,7 +879,7 @@ func TestCDRsThdSProcessEventMockNotfound(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -948,7 +948,7 @@ func TestCDRsStatSProcessEventMock(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -1018,7 +1018,7 @@ func TestCDRsEESProcessEventMock(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -1092,7 +1092,7 @@ func TestCDRsProcessEventMock(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -1162,7 +1162,7 @@ func TestCDRsProcessEventMockSkipOpts(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -1251,7 +1251,7 @@ func TestCDRsProcessEventMockAttrsErr(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -1312,7 +1312,7 @@ func TestCDRsProcessEventMockAttrsErrBoolOpts(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -1373,7 +1373,7 @@ func TestCDRsProcessEventMockChrgsErr(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -1435,7 +1435,7 @@ func TestCDRsProcessEventMockChrgsErrBoolOpts(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -1497,7 +1497,7 @@ func TestCDRsProcessEventMockRateSErr(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -1559,7 +1559,7 @@ func TestCDRsProcessEventMockRateSErrBoolOpts(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -1621,7 +1621,7 @@ func TestCDRsProcessEventMockAcntsErr(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -1683,7 +1683,7 @@ func TestCDRsProcessEventMockAcntsErrBoolOpts(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -1746,7 +1746,7 @@ func TestCDRsProcessEventMockExportErr(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -1808,7 +1808,7 @@ func TestCDRsProcessEventMockExportErrBoolOpts(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -1870,7 +1870,7 @@ func TestCDRsProcessEventMockThdsErr(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -1932,7 +1932,7 @@ func TestCDRsProcessEventMockThdsErrBoolOpts(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -1994,7 +1994,7 @@ func TestCDRsProcessEventMockStatsErr(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -2056,7 +2056,7 @@ func TestCDRsProcessEventMockStatsErrGetBoolOpts(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -2113,7 +2113,7 @@ func TestCDRsV1ProcessEventMock(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -2189,7 +2189,7 @@ func TestCDRsV1ProcessEventMockErr(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -2268,7 +2268,7 @@ func TestCDRsV1ProcessEventMockCache(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -2349,7 +2349,7 @@ func TestCDRsV1ProcessEventWithGetMockCache(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -2429,7 +2429,7 @@ func TestCDRsV1ProcessEventWithGetMockCacheErr(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -2492,7 +2492,7 @@ func TestCDRsChrgrSProcessEventEmptyChrgrs(t *testing.T) {
 	connMng := NewConnManager(cfg)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -2545,7 +2545,7 @@ func TestCDRsV1ProcessEventCacheGet(t *testing.T) {
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, nil)
 	cgrEv := &utils.CGREvent{
 		Tenant: "cgrates.org",
@@ -2592,7 +2592,7 @@ func TestCDRsV1ProcessEventWithGetCacheGet(t *testing.T) {
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	newCDRSrv := NewCDRServer(cfg, dm, fltrs, nil)
 	cgrEv := &utils.CGREvent{
 		Tenant: "cgrates.org",
diff --git a/engine/connmanager_test.go b/engine/connmanager_test.go
index ae828b21a..25f532991 100644
--- a/engine/connmanager_test.go
+++ b/engine/connmanager_test.go
@@ -47,7 +47,7 @@ func TestCMgetConnNotFound(t *testing.T) {
 
 	db := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(db, cfg.CacheCfg(), cM)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	Cache.SetWithoutReplicate(utils.CacheRPCConnections, connID, nil, nil, true, utils.NonTransactional)
 
 	experr := utils.ErrNotFound
@@ -358,7 +358,7 @@ func TestCMCallErrgetConn(t *testing.T) {
 
 	db := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(db, cfg.CacheCfg(), cM)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	Cache.SetWithoutReplicate(utils.CacheRPCConnections, connID, nil, nil, true, utils.NonTransactional)
 
 	experr := utils.ErrNotFound
@@ -538,7 +538,7 @@ func TestCMReload(t *testing.T) {
 
 	db := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(db, cfg.CacheCfg(), cM)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	Cache.SetWithoutReplicate(utils.CacheRPCConnections, "itmID2",
 		"value of 2nd item", nil, true, utils.NonTransactional)
 
diff --git a/engine/stats_test.go b/engine/stats_test.go
index 24763c027..32801a18f 100644
--- a/engine/stats_test.go
+++ b/engine/stats_test.go
@@ -706,7 +706,7 @@ func TestStatQueueMatchingStatQueuesForEventLocks(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	tmp := Cache
 	defer func() { Cache = tmp }()
-	Cache = NewCacheS(cfg, nil, nil)
+	Cache = NewCacheS(cfg, nil, nil, nil)
 	db := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(db, config.CgrConfig().CacheCfg(), nil)
 	cfg.StatSCfg().StoreInterval = 1
@@ -759,7 +759,7 @@ func TestStatQueueMatchingStatQueuesForEventLocks2(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	tmp := Cache
 	defer func() { Cache = tmp }()
-	Cache = NewCacheS(cfg, nil, nil)
+	Cache = NewCacheS(cfg, nil, nil, nil)
 	db := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(db, config.CgrConfig().CacheCfg(), nil)
 	cfg.StatSCfg().StoreInterval = 1
@@ -831,7 +831,7 @@ func TestStatQueueMatchingStatQueuesForEventLocksBlocker(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	tmp := Cache
 	defer func() { Cache = tmp }()
-	Cache = NewCacheS(cfg, nil, nil)
+	Cache = NewCacheS(cfg, nil, nil,nil)
 	db := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(db, config.CgrConfig().CacheCfg(), nil)
 	cfg.StatSCfg().StoreInterval = 1
@@ -896,7 +896,7 @@ func TestStatQueueMatchingStatQueuesForEventLocks3(t *testing.T) {
 	prfs := make([]*StatQueueProfile, 0)
 	tmp := Cache
 	defer func() { Cache = tmp }()
-	Cache = NewCacheS(cfg, nil, nil)
+	Cache = NewCacheS(cfg, nil, nil, nil)
 	db := &DataDBMock{
 		GetStatQueueProfileDrvF: func(ctx *context.Context, tnt, id string) (*StatQueueProfile, error) {
 			if id == "STS1" {
@@ -950,7 +950,7 @@ func TestStatQueueMatchingStatQueuesForEventLocks4(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	tmp := Cache
 	defer func() { Cache = tmp }()
-	Cache = NewCacheS(cfg, nil, nil)
+	Cache = NewCacheS(cfg, nil, nil, nil)
 	db := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(db, config.CgrConfig().CacheCfg(), nil)
 	cfg.StatSCfg().StoreInterval = 1
@@ -1194,7 +1194,7 @@ func TestStatQueueStoreStatQueueCacheSetErr(t *testing.T) {
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	connMgr = NewConnManager(cfg)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	sS := NewStatService(dm, cfg, filterS, connMgr)
 
@@ -1368,7 +1368,7 @@ func TestStatQueueV1ProcessEventMissingArgs(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	sS := NewStatService(dm, cfg, filterS, nil)
 
@@ -1462,7 +1462,7 @@ func TestStatQueueV1GetQueueIDsOK(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	sS := NewStatService(dm, cfg, filterS, nil)
 
@@ -1548,7 +1548,7 @@ func TestStatQueueV1GetQueueIDsGetKeysForPrefixErr(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := &DataDBMock{}
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	sS := NewStatService(dm, cfg, filterS, nil)
 
@@ -1570,7 +1570,7 @@ func TestStatQueueV1GetStatQueueOK(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	sS := NewStatService(dm, cfg, filterS, nil)
 
@@ -1638,7 +1638,7 @@ func TestStatQueueV1GetStatQueueNotFound(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	sS := NewStatService(dm, cfg, filterS, nil)
 
@@ -1663,7 +1663,7 @@ func TestStatQueueV1GetStatQueueMissingArgs(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	sS := NewStatService(dm, cfg, filterS, nil)
 
@@ -1727,7 +1727,7 @@ func TestStatQueueV1GetStatQueuesForEventOK(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	sS := NewStatService(dm, cfg, filterS, nil)
 
@@ -1808,7 +1808,7 @@ func TestStatQueueV1GetStatQueuesForEventNotFoundErr(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	sS := NewStatService(dm, cfg, filterS, nil)
 
@@ -1861,7 +1861,7 @@ func TestStatQueueV1GetStatQueuesForEventMissingArgs(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	sS := NewStatService(dm, cfg, filterS, nil)
 
@@ -1935,7 +1935,7 @@ func TestStatQueueV1ResetStatQueueOK(t *testing.T) {
 	cfg.StatSCfg().StoreInterval = 1
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	sS := NewStatService(dm, cfg, filterS, nil)
 
@@ -2030,7 +2030,7 @@ func TestStatQueueV1ResetStatQueueNotFoundErr(t *testing.T) {
 	cfg.StatSCfg().StoreInterval = 1
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	sS := NewStatService(dm, cfg, filterS, nil)
 
@@ -2100,7 +2100,7 @@ func TestStatQueueV1ResetStatQueueMissingArgs(t *testing.T) {
 	cfg.StatSCfg().StoreInterval = 1
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	sS := NewStatService(dm, cfg, filterS, nil)
 
@@ -2168,7 +2168,7 @@ func TestStatQueueV1ResetStatQueueUnsupportedMetricType(t *testing.T) {
 	cfg.StatSCfg().StoreInterval = 1
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	sS := NewStatService(dm, cfg, filterS, nil)
 
@@ -2242,7 +2242,7 @@ func TestStatQueueProcessThresholdsOKNoThIDs(t *testing.T) {
 	cfg.StatSCfg().ThresholdSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaThresholds)}
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 
 	filterS := NewFilterS(cfg, nil, dm)
 	sS := NewStatService(dm, cfg, filterS, nil)
@@ -2314,7 +2314,7 @@ func TestStatQueueProcessThresholdsOK(t *testing.T) {
 	cfg.StatSCfg().ThresholdSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaThresholds)}
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -2419,7 +2419,7 @@ func TestStatQueueProcessThresholdsErrPartExec(t *testing.T) {
 	cfg.StatSCfg().ThresholdSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaThresholds)}
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -2505,7 +2505,7 @@ func TestStatQueueV1GetQueueFloatMetricsOK(t *testing.T) {
 	cfg.StatSCfg().StoreInterval = 1
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	sS := NewStatService(dm, cfg, filterS, nil)
 
@@ -2578,7 +2578,7 @@ func TestStatQueueV1GetQueueFloatMetricsErrNotFound(t *testing.T) {
 	cfg.StatSCfg().StoreInterval = 1
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	sS := NewStatService(dm, cfg, filterS, nil)
 
@@ -2646,7 +2646,7 @@ func TestStatQueueV1GetQueueFloatMetricsMissingArgs(t *testing.T) {
 	cfg.StatSCfg().StoreInterval = 1
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	sS := NewStatService(dm, cfg, filterS, nil)
 
@@ -2712,7 +2712,7 @@ func TestStatQueueV1GetQueueFloatMetricsErrGetStats(t *testing.T) {
 
 	cfg := config.NewDefaultCGRConfig()
 	cfg.StatSCfg().StoreInterval = 1
-	Cache = NewCacheS(cfg, nil, nil)
+	Cache = NewCacheS(cfg, nil, nil, nil)
 	filterS := NewFilterS(cfg, nil, nil)
 	sS := NewStatService(nil, cfg, filterS, nil)
 
@@ -2735,7 +2735,7 @@ func TestStatQueueV1GetQueueStringMetricsOK(t *testing.T) {
 	cfg.StatSCfg().StoreInterval = 1
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	sS := NewStatService(dm, cfg, filterS, nil)
 
@@ -2808,7 +2808,7 @@ func TestStatQueueV1GetQueueStringMetricsErrNotFound(t *testing.T) {
 	cfg.StatSCfg().StoreInterval = 1
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	sS := NewStatService(dm, cfg, filterS, nil)
 
@@ -2874,7 +2874,7 @@ func TestStatQueueV1GetQueueStringMetricsMissingArgs(t *testing.T) {
 	cfg.StatSCfg().StoreInterval = 1
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	sS := NewStatService(dm, cfg, filterS, nil)
 
@@ -2940,7 +2940,7 @@ func TestStatQueueV1GetQueueStringMetricsErrGetStats(t *testing.T) {
 
 	cfg := config.NewDefaultCGRConfig()
 	cfg.StatSCfg().StoreInterval = 1
-	Cache = NewCacheS(cfg, nil, nil)
+	Cache = NewCacheS(cfg, nil, nil, nil)
 	filterS := NewFilterS(cfg, nil, nil)
 	sS := NewStatService(nil, cfg, filterS, nil)
 
@@ -2967,7 +2967,7 @@ func TestStatQueueStoreStatQueueStoreIntervalDisabled(t *testing.T) {
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	connMgr = NewConnManager(cfg)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	sS := NewStatService(dm, cfg, filterS, connMgr)
 
@@ -2997,7 +2997,7 @@ func TestStatQueueGetStatQueueOK(t *testing.T) {
 	cfg.StatSCfg().StoreInterval = 1
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	sS := NewStatService(dm, cfg, filterS, nil)
 
@@ -3202,7 +3202,7 @@ func TestStatQueueV1GetStatQueuesForEventProfileIgnoreFilters(t *testing.T) {
 	}
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	sS := NewStatService(dm, cfg, filterS, nil)
 
diff --git a/engine/thresholds_test.go b/engine/thresholds_test.go
index 308f10acc..18c0df195 100644
--- a/engine/thresholds_test.go
+++ b/engine/thresholds_test.go
@@ -1501,7 +1501,7 @@ func TestThresholdsProcessEventMaxHitsDMErr(t *testing.T) {
 	dm := NewDataManager(data, cfg.CacheCfg(), connMgr)
 	filterS := NewFilterS(cfg, nil, dm)
 	tS := NewThresholdService(nil, cfg, filterS, connMgr)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 
 	defer func() {
 		connMgr = tmpCMgr
@@ -1627,7 +1627,7 @@ func TestThresholdsV1ProcessEventOK(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	tS := NewThresholdService(dm, cfg, filterS, nil)
 
@@ -1699,7 +1699,7 @@ func TestThresholdsV1ProcessEventPartExecErr(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	tS := NewThresholdService(dm, cfg, filterS, nil)
 
@@ -1765,7 +1765,7 @@ func TestThresholdsV1ProcessEventMissingArgs(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	tS := NewThresholdService(dm, cfg, filterS, nil)
 
@@ -1849,7 +1849,7 @@ func TestThresholdsV1GetThresholdOK(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	tS := NewThresholdService(dm, cfg, filterS, nil)
 
@@ -1902,7 +1902,7 @@ func TestThresholdsV1GetThresholdNotFoundErr(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	tS := NewThresholdService(dm, cfg, filterS, nil)
 
@@ -1937,7 +1937,7 @@ func TestThresholdMatchingThresholdForEventLocks(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	tmp := Cache
 	defer func() { Cache = tmp }()
-	Cache = NewCacheS(cfg, nil, nil)
+	Cache = NewCacheS(cfg, nil, nil, nil)
 	db := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(db, config.CgrConfig().CacheCfg(), nil)
 	cfg.ThresholdSCfg().StoreInterval = 1
@@ -1997,7 +1997,7 @@ func TestThresholdMatchingThresholdForEventLocks2(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	tmp := Cache
 	defer func() { Cache = tmp }()
-	Cache = NewCacheS(cfg, nil, nil)
+	Cache = NewCacheS(cfg, nil, nil, nil)
 	db := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(db, config.CgrConfig().CacheCfg(), nil)
 	cfg.ThresholdSCfg().StoreInterval = 1
@@ -2069,7 +2069,7 @@ func TestThresholdMatchingThresholdForEventLocksBlocker(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	tmp := Cache
 	defer func() { Cache = tmp }()
-	Cache = NewCacheS(cfg, nil, nil)
+	Cache = NewCacheS(cfg, nil, nil, nil)
 	db := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(db, config.CgrConfig().CacheCfg(), nil)
 	cfg.ThresholdSCfg().StoreInterval = 1
@@ -2136,7 +2136,7 @@ func TestThresholdMatchingThresholdForEventLocks3(t *testing.T) {
 	prfs := make([]*ThresholdProfile, 0)
 	tmp := Cache
 	defer func() { Cache = tmp }()
-	Cache = NewCacheS(cfg, nil, nil)
+	Cache = NewCacheS(cfg, nil, nil, nil)
 	db := &DataDBMock{
 		GetThresholdProfileDrvF: func(ctx *context.Context, tnt, id string) (*ThresholdProfile, error) {
 			if id == "TH1" {
@@ -2192,7 +2192,7 @@ func TestThresholdMatchingThresholdForEventLocks4(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	tmp := Cache
 	defer func() { Cache = tmp }()
-	Cache = NewCacheS(cfg, nil, nil)
+	Cache = NewCacheS(cfg, nil, nil, nil)
 	db := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(db, config.CgrConfig().CacheCfg(), nil)
 	cfg.ThresholdSCfg().StoreInterval = 1
@@ -2250,7 +2250,7 @@ func TestThresholdMatchingThresholdForEventLocks5(t *testing.T) {
 		Cache = tmp
 		config.SetCgrConfig(tmpC)
 	}()
-	Cache = NewCacheS(cfg, nil, nil)
+	Cache = NewCacheS(cfg, nil, nil, nil)
 	db := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(db, config.CgrConfig().CacheCfg(), NewConnManager(cfg))
 	cfg.ThresholdSCfg().StoreInterval = 1
@@ -2430,7 +2430,7 @@ func TestThresholdsV1GetThresholdsForEventOK(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	tS := NewThresholdService(dm, cfg, filterS, nil)
 
@@ -2486,7 +2486,7 @@ func TestThresholdsV1GetThresholdsForEventMissingArgs(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	tS := NewThresholdService(dm, cfg, filterS, nil)
 
@@ -2552,7 +2552,7 @@ func TestThresholdsV1GetThresholdIDsOK(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	tS := NewThresholdService(dm, cfg, filterS, nil)
 
@@ -2612,7 +2612,7 @@ func TestThresholdsV1GetThresholdIDsGetKeysForPrefixErr(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := &DataDBMock{}
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	tS := NewThresholdService(dm, cfg, filterS, nil)
 
@@ -2634,7 +2634,7 @@ func TestThresholdsV1ResetThresholdOK(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	tS := NewThresholdService(dm, cfg, filterS, nil)
 
@@ -2693,7 +2693,7 @@ func TestThresholdsV1ResetThresholdErrNotFound(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	tS := NewThresholdService(dm, cfg, filterS, nil)
 
@@ -2744,7 +2744,7 @@ func TestThresholdsV1ResetThresholdNegativeStoreIntervalOK(t *testing.T) {
 	cfg.ThresholdSCfg().StoreInterval = -1
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	tS := NewThresholdService(dm, cfg, filterS, nil)
 
@@ -2799,7 +2799,7 @@ func TestThresholdsV1ResetThresholdNegativeStoreIntervalErr(t *testing.T) {
 	cfg.ThresholdSCfg().StoreInterval = -1
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	tS := NewThresholdService(nil, cfg, filterS, nil)
 
@@ -2924,7 +2924,7 @@ func TestThresholdsMatchingThresholdsForEventNotFoundErr(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	tS := NewThresholdService(dm, cfg, filterS, nil)
 
@@ -2980,7 +2980,7 @@ func TestThresholdsStoreThresholdCacheSetErr(t *testing.T) {
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	connMgr = NewConnManager(cfg)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	tS := NewThresholdService(dm, cfg, filterS, connMgr)
 
@@ -3011,7 +3011,7 @@ func TestThreholdsMatchingThresholdsForEventDoesNotPass(t *testing.T) {
 	config.SetCgrConfig(cfg)
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	tS := NewThresholdService(dm, cfg, filterS, nil)
 
diff --git a/engine/tpreader_test.go b/engine/tpreader_test.go
index f3584e5cf..2af7a9ba3 100644
--- a/engine/tpreader_test.go
+++ b/engine/tpreader_test.go
@@ -40,7 +40,7 @@ func TestTPReaderCallCacheNoCaching(t *testing.T) {
 	}()
 
 	defaultCfg := config.NewDefaultCGRConfig()
-	Cache = NewCacheS(defaultCfg, nil, nil)
+	Cache = NewCacheS(defaultCfg, nil, nil, nil)
 	cM := NewConnManager(defaultCfg)
 	args := map[string][]string{
 		utils.CacheFilters:   {"cgrates.org:FLTR_ID1", "cgrates.org:FLTR_ID2"},
@@ -67,7 +67,7 @@ func TestTPReaderCallCacheReloadCacheFirstCallErr(t *testing.T) {
 	}()
 
 	defaultCfg := config.NewDefaultCGRConfig()
-	Cache = NewCacheS(defaultCfg, nil, nil)
+	Cache = NewCacheS(defaultCfg, nil, nil, nil)
 	cacheConns := []string{"cacheConn1"}
 	client := make(chan birpc.ClientConnector, 1)
 	mCC := &ccMock{
@@ -133,7 +133,7 @@ func TestTPReaderCallCacheReloadCacheSecondCallErr(t *testing.T) {
 	}()
 
 	defaultCfg := config.NewDefaultCGRConfig()
-	Cache = NewCacheS(defaultCfg, nil, nil)
+	Cache = NewCacheS(defaultCfg, nil, nil, nil)
 	cacheConns := []string{"cacheConn1"}
 	client := make(chan birpc.ClientConnector, 1)
 	mCC := &ccMock{
@@ -214,7 +214,7 @@ func TestTPReaderCallCacheLoadCache(t *testing.T) {
 	}()
 
 	defaultCfg := config.NewDefaultCGRConfig()
-	Cache = NewCacheS(defaultCfg, nil, nil)
+	Cache = NewCacheS(defaultCfg, nil, nil, nil)
 	cacheConns := []string{"cacheConn1"}
 	client := make(chan birpc.ClientConnector, 1)
 	mCC := &ccMock{
@@ -284,7 +284,7 @@ func TestTPReaderCallCacheRemoveItems(t *testing.T) {
 	}()
 
 	defaultCfg := config.NewDefaultCGRConfig()
-	Cache = NewCacheS(defaultCfg, nil, nil)
+	Cache = NewCacheS(defaultCfg, nil, nil, nil)
 	cacheConns := []string{"cacheConn1"}
 	client := make(chan birpc.ClientConnector, 1)
 	mCC := &ccMock{
@@ -354,7 +354,7 @@ func TestTPReaderCallCacheClear(t *testing.T) {
 	}()
 
 	defaultCfg := config.NewDefaultCGRConfig()
-	Cache = NewCacheS(defaultCfg, nil, nil)
+	Cache = NewCacheS(defaultCfg, nil, nil, nil)
 	cacheConns := []string{"cacheConn1"}
 	client := make(chan birpc.ClientConnector, 1)
 	mCC := &ccMock{
diff --git a/engine/z_attributes_test.go b/engine/z_attributes_test.go
index 37dbb75b5..72e648491 100644
--- a/engine/z_attributes_test.go
+++ b/engine/z_attributes_test.go
@@ -4074,7 +4074,7 @@ func TestAttributesattributeProfileForEventNoDBConn(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	dataDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(dataDB, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	alS := &AttributeS{
 		cfg:   cfg,
 		dm:    dm,
@@ -4155,7 +4155,7 @@ func TestAttributesattributeProfileForEventErrNotFound(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	dataDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(dataDB, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	alS := &AttributeS{
 		cfg:   cfg,
 		dm:    dm,
@@ -4193,7 +4193,7 @@ func TestAttributesattributeProfileForEventErrPass(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	dataDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(dataDB, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	alS := &AttributeS{
 		cfg:   cfg,
 		dm:    dm,
@@ -4378,7 +4378,7 @@ func TestAttributesV1ProcessEventMultipleRuns1(t *testing.T) {
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	filterS := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	alS := NewAttributeService(dm, filterS, cfg)
 
 	postpaid := config.NewRSRParsersMustCompile(utils.MetaPostpaid, utils.InfieldSep)
@@ -4488,7 +4488,7 @@ func TestAttributesV1ProcessEventMultipleRuns2(t *testing.T) {
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	filterS := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	alS := NewAttributeService(dm, filterS, cfg)
 
 	postpaid := config.NewRSRParsersMustCompile(utils.MetaPostpaid, utils.InfieldSep)
@@ -5269,7 +5269,7 @@ func TestAttributesAttributeServiceV1PrcssEvPrcssRunsGetIntOptsErr(t *testing.T)
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	filterS := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	alS := NewAttributeService(dm, filterS, cfg)
 	pw := config.NewRSRParsersMustCompile("CGRateS.org", utils.InfieldSep)
 
@@ -5321,7 +5321,7 @@ func TestAttributesAttributeServiceV1PrcssEvProfRunsGetIntOptsErr(t *testing.T)
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	filterS := NewFilterS(cfg, nil, dm)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	alS := NewAttributeService(dm, filterS, cfg)
 	pw := config.NewRSRParsersMustCompile("CGRateS.org", utils.InfieldSep)
 
@@ -5404,7 +5404,7 @@ func TestAttributesProcessEventPasswordAttribute(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	filterS := NewFilterS(cfg, nil, dm)
 	attrS := NewAttributeService(dm, filterS, cfg)
 
@@ -5510,7 +5510,7 @@ func TestAttributesSetAttributeProfilePasswordAttr(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 
 	value := config.NewRSRParsersMustCompile("abcd123", config.CgrConfig().GeneralCfg().RSRSep)
 	attrPrf := &AttributeProfile{
diff --git a/engine/z_loader_it_test.go b/engine/z_loader_it_test.go
index d9ce1100d..9a160e8a3 100644
--- a/engine/z_loader_it_test.go
+++ b/engine/z_loader_it_test.go
@@ -103,7 +103,7 @@ func testLoaderITInitDataDB(t *testing.T) {
 		}
 	}
 	cacheChan := make(chan birpc.ClientConnector, 1)
-	srv, _ := birpc.NewServiceWithMethodsRename(NewCacheS(lCfg, dataDbCsv, nil), "", false, func(key string) (newKey string) {
+	srv, _ := birpc.NewServiceWithMethodsRename(NewCacheS(lCfg, dataDbCsv, nil, nil), "", false, func(key string) (newKey string) {
 		return strings.TrimPrefix(key, "V1")
 	})
 	cacheChan <- srv
diff --git a/engine/z_resources_test.go b/engine/z_resources_test.go
index e68e1c390..42c6c7d66 100644
--- a/engine/z_resources_test.go
+++ b/engine/z_resources_test.go
@@ -3098,7 +3098,7 @@ func TestResourcesStoreResourceErrCache(t *testing.T) {
 	config.SetCgrConfig(cfg)
 	dm := NewDataManager(NewInternalDB(nil, nil, cfg.DataDbCfg().Items), cfg.CacheCfg(), NewConnManager(cfg))
 	rS := NewResourceService(dm, cfg, nil, nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	r := &Resource{
 		Tenant: "cgrates.org",
 		ID:     "RES1",
@@ -3176,7 +3176,7 @@ func TestResourcesProcessThresholdsOK(t *testing.T) {
 
 	cfg := config.NewDefaultCGRConfig()
 	cfg.ResourceSCfg().ThresholdSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaThresholds)}
-	Cache = NewCacheS(cfg, nil, nil)
+	Cache = NewCacheS(cfg, nil, nil, nil)
 
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -3240,7 +3240,7 @@ func TestResourcesProcessThresholdsCallErr(t *testing.T) {
 
 	cfg := config.NewDefaultCGRConfig()
 	cfg.ResourceSCfg().ThresholdSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaThresholds)}
-	Cache = NewCacheS(cfg, nil, nil)
+	Cache = NewCacheS(cfg, nil, nil, nil)
 
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
@@ -3462,7 +3462,7 @@ func TestResourcesV1ResourcesForEventOK(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	rsPrf := &ResourceProfile{
 		Tenant:            "cgrates.org",
 		ID:                "RES1",
@@ -3707,7 +3707,7 @@ func TestResourcesV1ResourcesForEventCacheReplyExists(t *testing.T) {
 	config.SetCgrConfig(cfg)
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	cacheKey := utils.ConcatenatedKey(utils.ResourceSv1GetResourcesForEvent,
 		utils.ConcatenatedKey("cgrates.org", "ResourcesForEventTest"))
 	rsPrf := &ResourceProfile{
@@ -3805,7 +3805,7 @@ func TestResourcesV1ResourcesForEventCacheReplySet(t *testing.T) {
 	config.SetCgrConfig(cfg)
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	cacheKey := utils.ConcatenatedKey(utils.ResourceSv1GetResourcesForEvent,
 		utils.ConcatenatedKey("cgrates.org", "ResourcesForEventTest"))
 	rsPrf := &ResourceProfile{
@@ -3907,7 +3907,7 @@ func TestResourcesV1GetResourceOK(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 
 	rsPrf := &ResourceProfile{
 		Tenant:            "cgrates.org",
@@ -3987,7 +3987,7 @@ func TestResourcesV1GetResourceNotFound(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 
 	rsPrf := &ResourceProfile{
 		Tenant:            "cgrates.org",
@@ -4049,7 +4049,7 @@ func TestResourcesV1GetResourceMissingParameters(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 
 	rsPrf := &ResourceProfile{
 		Tenant:            "cgrates.org",
@@ -4110,7 +4110,7 @@ func TestResourcesV1GetResourceWithConfigOK(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 
 	rsPrf := &ResourceProfile{
 		Tenant:            "cgrates.org",
@@ -4193,7 +4193,7 @@ func TestResourcesV1GetResourceWithConfigNilrPrfOK(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 
 	rsPrf := &ResourceProfile{
 		Tenant:            "cgrates.org",
@@ -4279,7 +4279,7 @@ func TestResourcesV1GetResourceWithConfigNilrPrfProfileNotFound(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 
 	rsPrf := &ResourceProfile{
 		Tenant:            "cgrates.org",
@@ -4343,7 +4343,7 @@ func TestResourcesV1GetResourceWithConfigResourceNotFound(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 
 	rsPrf := &ResourceProfile{
 		Tenant:            "cgrates.org",
@@ -4403,7 +4403,7 @@ func TestResourcesV1GetResourceWithConfigMissingParameters(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 
 	rsPrf := &ResourceProfile{
 		Tenant:            "cgrates.org",
@@ -4462,7 +4462,7 @@ func TestResourcesV1AuthorizeResourcesOK(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 
 	rsPrf := &ResourceProfile{
 		Tenant:            "cgrates.org",
@@ -4516,7 +4516,7 @@ func TestResourcesV1AuthorizeResourcesNotAuthorized(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 
 	rsPrf := &ResourceProfile{
 		Tenant:            "cgrates.org",
@@ -4570,7 +4570,7 @@ func TestResourcesV1AuthorizeResourcesNoMatch(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 
 	rsPrf := &ResourceProfile{
 		Tenant:            "cgrates.org",
@@ -4624,7 +4624,7 @@ func TestResourcesV1AuthorizeResourcesNilCGREvent(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 
 	rsPrf := &ResourceProfile{
 		Tenant:            "cgrates.org",
@@ -4667,7 +4667,7 @@ func TestResourcesV1AuthorizeResourcesMissingUsageID(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 
 	rsPrf := &ResourceProfile{
 		Tenant:            "cgrates.org",
@@ -4720,7 +4720,7 @@ func TestResourcesV1AuthorizeResourcesCacheReplyExists(t *testing.T) {
 	config.SetCgrConfig(cfg)
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	cacheKey := utils.ConcatenatedKey(utils.ResourceSv1AuthorizeResources,
 		utils.ConcatenatedKey("cgrates.org", "EventAuthorizeResource"))
 
@@ -4804,7 +4804,7 @@ func TestResourcesV1AuthorizeResourcesCacheReplySet(t *testing.T) {
 	config.SetCgrConfig(cfg)
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	cacheKey := utils.ConcatenatedKey(utils.ResourceSv1AuthorizeResources,
 		utils.ConcatenatedKey("cgrates.org", "EventAuthorizeResource"))
 
@@ -4890,7 +4890,7 @@ func TestResourcesV1AllocateResourcesOK(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 
 	rsPrf := &ResourceProfile{
 		Tenant:            "cgrates.org",
@@ -4944,7 +4944,7 @@ func TestResourcesV1AllocateResourcesNoMatch(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 
 	rsPrf := &ResourceProfile{
 		Tenant:            "cgrates.org",
@@ -4997,7 +4997,7 @@ func TestResourcesV1AllocateResourcesMissingParameters(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 
 	rsPrf := &ResourceProfile{
 		Tenant:            "cgrates.org",
@@ -5088,7 +5088,7 @@ func TestResourcesV1AllocateResourcesCacheReplyExists(t *testing.T) {
 	config.SetCgrConfig(cfg)
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	cacheKey := utils.ConcatenatedKey(utils.ResourceSv1AllocateResources,
 		utils.ConcatenatedKey("cgrates.org", "EventAllocateResource"))
 
@@ -5172,7 +5172,7 @@ func TestResourcesV1AllocateResourcesCacheReplySet(t *testing.T) {
 	config.SetCgrConfig(cfg)
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	cacheKey := utils.ConcatenatedKey(utils.ResourceSv1AllocateResources,
 		utils.ConcatenatedKey("cgrates.org", "EventAllocateResource"))
 
@@ -5258,7 +5258,7 @@ func TestResourcesV1AllocateResourcesResAllocErr(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 
 	rsPrf := &ResourceProfile{
 		Tenant:            "cgrates.org",
@@ -5312,7 +5312,7 @@ func TestResourcesV1AllocateResourcesProcessThErr(t *testing.T) {
 	cfg.ResourceSCfg().ThresholdSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaThresholds)}
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 
 	rsPrf := &ResourceProfile{
 		Tenant:            "cgrates.org",
@@ -5397,7 +5397,7 @@ func TestResourcesV1ReleaseResourcesOK(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 
 	rsPrf := &ResourceProfile{
 		Tenant:            "cgrates.org",
@@ -5456,7 +5456,7 @@ func TestResourcesV1ReleaseResourcesUsageNotFound(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 
 	rsPrf := &ResourceProfile{
 		Tenant:            "cgrates.org",
@@ -5527,7 +5527,7 @@ func TestResourcesV1ReleaseResourcesNoMatch(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 
 	rsPrf := &ResourceProfile{
 		Tenant:            "cgrates.org",
@@ -5580,7 +5580,7 @@ func TestResourcesV1ReleaseResourcesMissingParameters(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 
 	rsPrf := &ResourceProfile{
 		Tenant:            "cgrates.org",
@@ -5671,7 +5671,7 @@ func TestResourcesV1ReleaseResourcesCacheReplyExists(t *testing.T) {
 	config.SetCgrConfig(cfg)
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	cacheKey := utils.ConcatenatedKey(utils.ResourceSv1ReleaseResources,
 		utils.ConcatenatedKey("cgrates.org", "EventReleaseResource"))
 
@@ -5755,7 +5755,7 @@ func TestResourcesV1ReleaseResourcesCacheReplySet(t *testing.T) {
 	config.SetCgrConfig(cfg)
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	cacheKey := utils.ConcatenatedKey(utils.ResourceSv1ReleaseResources,
 		utils.ConcatenatedKey("cgrates.org", "EventReleaseResource"))
 
@@ -5843,7 +5843,7 @@ func TestResourcesV1ReleaseResourcesProcessThErr(t *testing.T) {
 	cfg.ResourceSCfg().ThresholdSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaThresholds)}
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	ccM := &ccMock{
 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
 			utils.ThresholdSv1ProcessEvent: func(ctx *context.Context, args, reply interface{}) error {
@@ -6476,7 +6476,7 @@ func TestResourcesStartLoop(t *testing.T) {
 // 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 // 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 // 	connMgr = NewConnManager(cfg)
-// 	Cache = NewCacheS(cfg, dm, nil)
+// 	Cache = NewCacheS(cfg, dm, nil,nil)
 
 // 	fltrs := NewFilterS(cfg, nil, dm)
 
@@ -6532,7 +6532,7 @@ func TestResourcesMatchingResourcesForEventCacheSetErr(t *testing.T) {
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	connMgr = NewConnManager(cfg)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	fltrs := NewFilterS(cfg, nil, dm)
 
 	rS := NewResourceService(dm, cfg, fltrs, connMgr)
@@ -6572,7 +6572,7 @@ func TestResourcesMatchingResourcesForEventFinalCacheSetErr(t *testing.T) {
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
 	connMgr = NewConnManager(cfg)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	fltrs := NewFilterS(cfg, nil, dm)
 
 	rsPrf := &ResourceProfile{
@@ -6643,7 +6643,7 @@ func TestResourcesV1ResourcesForEventErrRetrieveUsageID(t *testing.T) {
 	}
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	fltrs := NewFilterS(cfg, nil, dm)
 	rS := NewResourceService(dm, cfg, fltrs, nil)
 
@@ -6680,7 +6680,7 @@ func TestResourcesV1ResourcesForEventErrRetrieveUsageTTL(t *testing.T) {
 	}
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	fltrs := NewFilterS(cfg, nil, dm)
 	rS := NewResourceService(dm, cfg, fltrs, nil)
 
@@ -6717,7 +6717,7 @@ func TestResourcesV1AuthorizeResourcesErrRetrieveUsageID(t *testing.T) {
 	}
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	fltrs := NewFilterS(cfg, nil, dm)
 	rS := NewResourceService(dm, cfg, fltrs, nil)
 
@@ -6754,7 +6754,7 @@ func TestResourcesV1AuthorizeResourcesErrRetrieveUnits(t *testing.T) {
 	}
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	fltrs := NewFilterS(cfg, nil, dm)
 	rS := NewResourceService(dm, cfg, fltrs, nil)
 
@@ -6791,7 +6791,7 @@ func TestResourcesV1AuthorizeResourcesErrRetrieveUsageTTL(t *testing.T) {
 	}
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	fltrs := NewFilterS(cfg, nil, dm)
 	rS := NewResourceService(dm, cfg, fltrs, nil)
 
@@ -6828,7 +6828,7 @@ func TestResourcesV1AllocateResourcesErrRetrieveUsageID(t *testing.T) {
 	}
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	fltrs := NewFilterS(cfg, nil, dm)
 	rS := NewResourceService(dm, cfg, fltrs, nil)
 
@@ -6865,7 +6865,7 @@ func TestResourcesV1AllocateResourcesErrRetrieveUsageTTL(t *testing.T) {
 	}
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	fltrs := NewFilterS(cfg, nil, dm)
 	rS := NewResourceService(dm, cfg, fltrs, nil)
 
@@ -6902,7 +6902,7 @@ func TestResourcesV1AllocateResourcesErrRetrieveUnits(t *testing.T) {
 	}
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	fltrs := NewFilterS(cfg, nil, dm)
 	rS := NewResourceService(dm, cfg, fltrs, nil)
 
@@ -6939,7 +6939,7 @@ func TestResourcesV1ReleaseResourcesErrRetrieveUsageID(t *testing.T) {
 	}
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	fltrs := NewFilterS(cfg, nil, dm)
 	rS := NewResourceService(dm, cfg, fltrs, nil)
 
@@ -6976,7 +6976,7 @@ func TestResourcesV1ReleaseResourcesErrRetrieveUsageTTL(t *testing.T) {
 	}
 	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
 	dm := NewDataManager(data, cfg.CacheCfg(), nil)
-	Cache = NewCacheS(cfg, dm, nil)
+	Cache = NewCacheS(cfg, dm, nil, nil)
 	fltrs := NewFilterS(cfg, nil, dm)
 	rS := NewResourceService(dm, cfg, fltrs, nil)
 
diff --git a/ers/sqs_test.go b/ers/sqs_test.go
index fbe7104da..3aaa1210b 100644
--- a/ers/sqs_test.go
+++ b/ers/sqs_test.go
@@ -537,10 +537,11 @@ func TestSQSERReadMsgError3(t *testing.T) {
 		queueID:   "cgrates_cdrs",
 		session:   nil,
 		poster: ees.NewSQSee(&config.EventExporterCfg{
-			ExportPath: "url",
-			Attempts:   1,
-			EFsConns:   []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaEFs)},
-			Opts:       &config.EventExporterOpts{},
+			ExportPath:     "url",
+			Attempts:       1,
+			FailedPostsDir: utils.MetaNone,
+			EFsConns:       []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaEFs)},
+			Opts:           &config.EventExporterOpts{},
 		}, nil),
 	}
 	awsCfg := aws.Config{Endpoint: aws.String(rdr.Config().SourcePath)}
diff --git a/general_tests/dispatcher_opts_it_test.go b/general_tests/dispatcher_opts_it_test.go
index 3e8fd7cf4..b1582ff3d 100644
--- a/general_tests/dispatcher_opts_it_test.go
+++ b/general_tests/dispatcher_opts_it_test.go
@@ -55,17 +55,18 @@ var (
 		testDispatcherOptsDSPRPCConn,
 		testDispatcherOptsCoreStatus, // self localhost(:2012) CoresV1Status
 
-		testDispatcherOptsAdminSetDispatcherHost4012,
-		testDispatcherOptsCoreStatusHost4012,
+		/*
+			testDispatcherOptsAdminSetDispatcherHost4012,
+			testDispatcherOptsCoreStatusHost4012,
 
-		testDispatcherOptsAdminSetDispatcherProfileDoubleHost,
-		testDispatcherOptsCoreStatusWithRouteID,
+			testDispatcherOptsAdminSetDispatcherProfileDoubleHost,
+			testDispatcherOptsCoreStatusWithRouteID,
 
-		testDispatcherOptsAdminSetDispatcherHostInexistent,
-		testDispatcherOptsCoreStatusWithRouteID2,
-
-		testDispatcherOptsCoreStatusWithoutRouteID,
+			testDispatcherOptsAdminSetDispatcherHostInexistent,
+			testDispatcherOptsCoreStatusWithRouteID2,
 
+			testDispatcherOptsCoreStatusWithoutRouteID,
+		*/
 		testDispatcherOptsDSPStopEngine,
 		testDispatcherOptsAdminStopEngine,
 	}
@@ -116,7 +117,7 @@ func testDispatcherOptsAdminSetDispatcherProfile(t *testing.T) {
 			Tenant: "cgrates.org",
 			RemoteHost: &config.RemoteHost{
 				ID:              "SELF_ENGINE",
-				Address:         "*internal",
+				Address:         "127.0.0.1:2012",
 				Transport:       "*json",
 				ConnectAttempts: 1,
 				Reconnects:      3,
@@ -189,9 +190,9 @@ func testDispatcherOptsCoreStatus(t *testing.T) {
 	var reply map[string]interface{}
 	ev := utils.TenantWithAPIOpts{
 		Tenant: "cgrates.org",
-		APIOpts: map[string]interface{}{
+		/* 	APIOpts: map[string]interface{}{
 			utils.MetaDispatchers: false,
-		},
+		}, */
 	}
 	if err := dspOptsRPC.Call(context.Background(), utils.CoreSv1Status, &ev, &reply); err != nil {
 		t.Error(err)
diff --git a/registrarc/libregistrarc_test.go b/registrarc/libregistrarc_test.go
index dd540f62c..4ab6f8218 100644
--- a/registrarc/libregistrarc_test.go
+++ b/registrarc/libregistrarc_test.go
@@ -158,7 +158,7 @@ func TestRegister(t *testing.T) {
 		t.Fatal(err)
 	}
 	req.RemoteAddr = "127.0.0.1:2356"
-	engine.Cache = engine.NewCacheS(config.CgrConfig(), nil, nil)
+	engine.Cache = engine.NewCacheS(config.CgrConfig(), nil, nil, nil)
 	if rplyID, err := register(req); err != nil {
 		t.Fatal(err)
 	} else if !reflect.DeepEqual(id, *rplyID) {
@@ -232,7 +232,7 @@ func TestRegister(t *testing.T) {
 	}
 	errCfg := config.NewDefaultCGRConfig()
 
-	engine.NewConnManager(errCfg)
+	connMgr := engine.NewConnManager(errCfg)
 	errCfg.CacheCfg().Partitions[utils.CacheDispatcherHosts].Replicate = true
 	errCfg.RPCConns()["errCon"] = &config.RPCConn{
 		Strategy: utils.MetaFirst,
@@ -246,7 +246,7 @@ func TestRegister(t *testing.T) {
 		},
 	}
 	errCfg.CacheCfg().ReplicationConns = []string{"errCon"}
-	engine.Cache = engine.NewCacheS(errCfg, nil, nil)
+	engine.Cache = engine.NewCacheS(errCfg, nil, connMgr, nil)
 	req.Body = io.NopCloser(bytes.NewBuffer(uargsJSON))
 	if _, err := register(req); err != utils.ErrPartiallyExecuted {
 		t.Errorf("Expected error: %s ,received: %v", utils.ErrPartiallyExecuted, err)
@@ -320,7 +320,7 @@ func TestRegister(t *testing.T) {
 	if _, err := register(req); err == nil {
 		t.Errorf("Expected error,received: nil")
 	}
-	engine.Cache = engine.NewCacheS(config.CgrConfig(), nil, nil)
+	engine.Cache = engine.NewCacheS(config.CgrConfig(), nil, nil, nil)
 }
 
 type errRecorder struct{}
@@ -473,7 +473,7 @@ func TestRegisterRegistrarSv1UnregisterRPCHosts(t *testing.T) {
 		t.Fatal(err)
 	}
 	req.RemoteAddr = "127.0.0.1:2356"
-	engine.Cache = engine.NewCacheS(config.CgrConfig(), nil, nil)
+	engine.Cache = engine.NewCacheS(config.CgrConfig(), nil, nil, nil)
 	if rplyID, err := register(req); err != nil {
 		t.Fatal(err)
 	} else if !reflect.DeepEqual(id, *rplyID) {
@@ -514,17 +514,17 @@ func TestRegisterRegistrarSv1UnregisterRPCHostsError(t *testing.T) {
 			},
 		},
 	}
-	engine.NewConnManager(cfg)
+	connMgr := engine.NewConnManager(cfg)
 	cfg.RPCConns()["errCon"] = config.CgrConfig().RPCConns()["errCon"]
 	cfg.CacheCfg().ReplicationConns = []string{"errCon"}
 	cfg.CacheCfg().Partitions[utils.CacheRPCConnections].Replicate = true
-	engine.Cache = engine.NewCacheS(cfg, nil, nil)
+	engine.Cache = engine.NewCacheS(cfg, nil, connMgr, nil)
 	_, err = register(req)
 	if err == nil || err != utils.ErrPartiallyExecuted {
 		t.Fatal(err)
 	}
 	delete(config.CgrConfig().RPCConns(), "errCon")
-	engine.Cache = engine.NewCacheS(config.CgrConfig(), nil, nil)
+	engine.Cache = engine.NewCacheS(config.CgrConfig(), nil, nil, nil)
 }
 
 func TestRegisterRegistrarSv1RegisterRPCHosts(t *testing.T) {
@@ -566,7 +566,7 @@ func TestRegisterRegistrarSv1RegisterRPCHosts(t *testing.T) {
 	} else if !reflect.DeepEqual(id, *rplyID) {
 		t.Errorf("Expected: %q ,received: %q", string(id), string(*rplyID))
 	}
-	engine.Cache = engine.NewCacheS(config.CgrConfig(), nil, nil)
+	engine.Cache = engine.NewCacheS(config.CgrConfig(), nil, nil, nil)
 }
 
 func TestRegisterRegistrarSv1RegisterRPCHostsError(t *testing.T) {
@@ -615,15 +615,15 @@ func TestRegisterRegistrarSv1RegisterRPCHostsError(t *testing.T) {
 			},
 		},
 	}
-	engine.NewConnManager(cfg)
+	connMgr := engine.NewConnManager(cfg)
 	cfg.RPCConns()["errCon1"] = config.CgrConfig().RPCConns()["errCon1"]
 	cfg.CacheCfg().ReplicationConns = []string{"errCon1"}
 	cfg.CacheCfg().Partitions[utils.CacheRPCConnections].Replicate = true
-	engine.Cache = engine.NewCacheS(cfg, nil, nil)
+	engine.Cache = engine.NewCacheS(cfg, nil, connMgr, nil)
 	_, err = register(req)
 	if err == nil || err != utils.ErrPartiallyExecuted {
 		t.Fatal(err)
 	}
 	delete(config.CgrConfig().RPCConns(), "errCon1")
-	engine.Cache = engine.NewCacheS(config.CgrConfig(), nil, nil)
+	engine.Cache = engine.NewCacheS(config.CgrConfig(), nil, nil, nil)
 }
diff --git a/services/accounts_it_test.go b/services/accounts_it_test.go
index 26c1e6e61..922a2ce8e 100644
--- a/services/accounts_it_test.go
+++ b/services/accounts_it_test.go
@@ -39,7 +39,7 @@ func TestAccountSReload(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 
 	shdWg := new(sync.WaitGroup)
-	chS := engine.NewCacheS(cfg, nil, nil)
+	chS := engine.NewCacheS(cfg, nil, nil, nil)
 	filterSChan := make(chan *engine.FilterS, 1)
 	filterSChan <- nil
 	close(chS.GetPrecacheChannel(utils.CacheAccounts))
diff --git a/services/accounts_test.go b/services/accounts_test.go
index 846ca3784..b4de80707 100644
--- a/services/accounts_test.go
+++ b/services/accounts_test.go
@@ -42,7 +42,7 @@ func TestAccountSCoverage(t *testing.T) {
 	db := NewDataDBService(cfg, nil, srvDep)
 	actRPC := make(chan birpc.ClientConnector, 1)
 	anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep)
-	chS := NewCacheService(cfg, db, server, make(chan context.ClientConnector, 1), anz, nil, srvDep)
+	chS := NewCacheService(cfg, db, nil, server, make(chan context.ClientConnector, 1), anz, nil, srvDep)
 	actS := NewAccountService(cfg, db,
 		chS, filterSChan, nil, server, actRPC,
 		anz, srvDep)
diff --git a/services/actions_it_test.go b/services/actions_it_test.go
index 624da08ff..9ba424906 100644
--- a/services/actions_it_test.go
+++ b/services/actions_it_test.go
@@ -39,7 +39,7 @@ func TestActionSReload(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 
 	shdWg := new(sync.WaitGroup)
-	chS := engine.NewCacheS(cfg, nil, nil)
+	chS := engine.NewCacheS(cfg, nil, nil, nil)
 	filterSChan := make(chan *engine.FilterS, 1)
 	filterSChan <- nil
 	close(chS.GetPrecacheChannel(utils.CacheActionProfiles))
diff --git a/services/actions_test.go b/services/actions_test.go
index 0a216bf04..49b873bed 100644
--- a/services/actions_test.go
+++ b/services/actions_test.go
@@ -41,7 +41,7 @@ func TestActionSCoverage(t *testing.T) {
 	db := NewDataDBService(cfg, nil, srvDep)
 	actRPC := make(chan birpc.ClientConnector, 1)
 	anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep)
-	chS := NewCacheService(cfg, db, server, make(chan context.ClientConnector, 1), anz, nil, srvDep)
+	chS := NewCacheService(cfg, db, nil, server, make(chan context.ClientConnector, 1), anz, nil, srvDep)
 	actS := NewActionService(cfg, db,
 		chS, filterSChan, nil, server, actRPC,
 		anz, srvDep)
diff --git a/services/attributes_it_test.go b/services/attributes_it_test.go
index 4afeef054..e353ab776 100644
--- a/services/attributes_it_test.go
+++ b/services/attributes_it_test.go
@@ -39,7 +39,7 @@ func TestAttributeSReload(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 
 	shdWg := new(sync.WaitGroup)
-	chS := engine.NewCacheS(cfg, nil, nil)
+	chS := engine.NewCacheS(cfg, nil, nil, nil)
 	filterSChan := make(chan *engine.FilterS, 1)
 	filterSChan <- nil
 	close(chS.GetPrecacheChannel(utils.CacheAttributeProfiles))
diff --git a/services/attributes_test.go b/services/attributes_test.go
index 7094595b3..5cdd02f77 100644
--- a/services/attributes_test.go
+++ b/services/attributes_test.go
@@ -40,7 +40,7 @@ func TestAttributeSCoverage(t *testing.T) {
 	attrRPC := make(chan birpc.ClientConnector, 1)
 	db := NewDataDBService(cfg, nil, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep)
-	chS := NewCacheService(cfg, db, server, make(chan context.ClientConnector, 1), anz, nil, srvDep)
+	chS := NewCacheService(cfg, db, nil, server, make(chan context.ClientConnector, 1), anz, nil, srvDep)
 	attrS := NewAttributeService(cfg, db, chS, filterSChan, server, attrRPC, anz, &DispatcherService{srvsReload: map[string]chan struct{}{}}, srvDep)
 	if attrS == nil {
 		t.Errorf("\nExpecting <nil>,\n Received <%+v>", utils.ToJSON(attrS))
diff --git a/services/cdrs_it_test.go b/services/cdrs_it_test.go
index c2eca69f8..a93ab4042 100644
--- a/services/cdrs_it_test.go
+++ b/services/cdrs_it_test.go
@@ -41,7 +41,7 @@ func TestCdrsReload(t *testing.T) {
 	filterSChan := make(chan *engine.FilterS, 1)
 	filterSChan <- nil
 	shdWg := new(sync.WaitGroup)
-	chS := engine.NewCacheS(cfg, nil, nil)
+	chS := engine.NewCacheS(cfg, nil, nil, nil)
 
 	close(chS.GetPrecacheChannel(utils.CacheChargerProfiles))
 	close(chS.GetPrecacheChannel(utils.CacheChargerFilterIndexes))
diff --git a/services/chargers_it_test.go b/services/chargers_it_test.go
index e4f55d266..1f3d74705 100644
--- a/services/chargers_it_test.go
+++ b/services/chargers_it_test.go
@@ -41,7 +41,7 @@ func TestChargerSReload(t *testing.T) {
 
 	cfg.AttributeSCfg().Enabled = true
 	shdWg := new(sync.WaitGroup)
-	chS := engine.NewCacheS(cfg, nil, nil)
+	chS := engine.NewCacheS(cfg, nil, nil, nil)
 	close(chS.GetPrecacheChannel(utils.CacheAttributeProfiles))
 	close(chS.GetPrecacheChannel(utils.CacheAttributeFilterIndexes))
 	close(chS.GetPrecacheChannel(utils.CacheChargerProfiles))
diff --git a/services/chargers_test.go b/services/chargers_test.go
index ee19b920b..b1ba99066 100644
--- a/services/chargers_test.go
+++ b/services/chargers_test.go
@@ -40,7 +40,7 @@ func TestChargerSCoverage(t *testing.T) {
 	server := cores.NewServer(nil)
 	db := NewDataDBService(cfg, nil, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep)
-	chS := NewCacheService(cfg, db, server, make(chan context.ClientConnector, 1), anz, nil, srvDep)
+	chS := NewCacheService(cfg, db, nil, server, make(chan context.ClientConnector, 1), anz, nil, srvDep)
 	chrS1 := NewChargerService(cfg, db, chS,
 		filterSChan, server, make(chan birpc.ClientConnector, 1),
 		nil, anz, srvDep)
diff --git a/services/datadb_it_test.go b/services/datadb_it_test.go
index 89d65c457..9123d2560 100644
--- a/services/datadb_it_test.go
+++ b/services/datadb_it_test.go
@@ -40,7 +40,7 @@ func TestDataDBReload(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 
 	shdWg := new(sync.WaitGroup)
-	chS := engine.NewCacheS(cfg, nil, nil)
+	chS := engine.NewCacheS(cfg, nil, nil, nil)
 	filterSChan := make(chan *engine.FilterS, 1)
 	filterSChan <- nil
 	close(chS.GetPrecacheChannel(utils.CacheAttributeProfiles))
diff --git a/services/dispatchers_it_test.go b/services/dispatchers_it_test.go
index d2b30a4b1..a029482e5 100644
--- a/services/dispatchers_it_test.go
+++ b/services/dispatchers_it_test.go
@@ -41,7 +41,7 @@ func TestDispatcherSReload(t *testing.T) {
 
 	cfg.AttributeSCfg().Enabled = true
 	shdWg := new(sync.WaitGroup)
-	chS := engine.NewCacheS(cfg, nil, nil)
+	chS := engine.NewCacheS(cfg, nil, nil, nil)
 	close(chS.GetPrecacheChannel(utils.CacheAttributeProfiles))
 	close(chS.GetPrecacheChannel(utils.CacheAttributeFilterIndexes))
 	close(chS.GetPrecacheChannel(utils.CacheDispatcherProfiles))
diff --git a/services/dispatchers_test.go b/services/dispatchers_test.go
index 407dedb13..83d2e7d74 100644
--- a/services/dispatchers_test.go
+++ b/services/dispatchers_test.go
@@ -41,7 +41,7 @@ func TestDispatcherSCoverage(t *testing.T) {
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	db := NewDataDBService(cfg, nil, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep)
-	chS := NewCacheService(cfg, db, server, make(chan context.ClientConnector, 1), anz, nil, srvDep)
+	chS := NewCacheService(cfg, db, nil, server, make(chan context.ClientConnector, 1), anz, nil, srvDep)
 	srv := NewDispatcherService(cfg, db, chS, filterSChan, server,
 		make(chan birpc.ClientConnector, 1), engine.NewConnManager(cfg), anz, srvDep)
 	if srv.IsRunning() {
diff --git a/services/ees_it_test.go b/services/ees_it_test.go
index 0f1c99a5d..aabb759f9 100644
--- a/services/ees_it_test.go
+++ b/services/ees_it_test.go
@@ -56,7 +56,7 @@ func TestEventExporterSReload(t *testing.T) {
 	srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg.GetReloadChan())
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	db := NewDataDBService(cfg, nil, srvDep)
-	chS := engine.NewCacheS(cfg, nil, nil)
+	chS := engine.NewCacheS(cfg, nil, nil, nil)
 	close(chS.GetPrecacheChannel(utils.CacheAttributeProfiles))
 	close(chS.GetPrecacheChannel(utils.CacheAttributeFilterIndexes))
 	chSCh := make(chan *engine.CacheS, 1)
diff --git a/services/rates_it_test.go b/services/rates_it_test.go
index eaae7c70f..68e77903c 100644
--- a/services/rates_it_test.go
+++ b/services/rates_it_test.go
@@ -46,7 +46,7 @@ func TestRateSReload(t *testing.T) {
 	srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg.GetReloadChan())
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	db := NewDataDBService(cfg, nil, srvDep)
-	chS := engine.NewCacheS(cfg, nil, nil)
+	chS := engine.NewCacheS(cfg, nil, nil, nil)
 	close(chS.GetPrecacheChannel(utils.CacheRateProfiles))
 	close(chS.GetPrecacheChannel(utils.CacheRateProfilesFilterIndexes))
 	close(chS.GetPrecacheChannel(utils.CacheRateFilterIndexes))
diff --git a/services/rates_test.go b/services/rates_test.go
index f6576c84d..6c42188cc 100644
--- a/services/rates_test.go
+++ b/services/rates_test.go
@@ -41,7 +41,7 @@ func TestRateSCoverage(t *testing.T) {
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	db := NewDataDBService(cfg, nil, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep)
-	chS := NewCacheService(cfg, db, server, make(chan context.ClientConnector, 1), anz, nil, srvDep)
+	chS := NewCacheService(cfg, db, nil, server, make(chan context.ClientConnector, 1), anz, nil, srvDep)
 	rS := NewRateService(cfg, chS, filterSChan, db, server, make(chan birpc.ClientConnector, 1), anz, srvDep)
 
 	if rS.IsRunning() {
diff --git a/services/resources_it_test.go b/services/resources_it_test.go
index 5787e5195..74aa878a3 100644
--- a/services/resources_it_test.go
+++ b/services/resources_it_test.go
@@ -44,7 +44,7 @@ func TestResourceSReload(t *testing.T) {
 	filterSChan := make(chan *engine.FilterS, 1)
 	filterSChan <- nil
 	shdWg := new(sync.WaitGroup)
-	chS := engine.NewCacheS(cfg, nil, nil)
+	chS := engine.NewCacheS(cfg, nil, nil, nil)
 	close(chS.GetPrecacheChannel(utils.CacheThresholdProfiles))
 	close(chS.GetPrecacheChannel(utils.CacheThresholds))
 	close(chS.GetPrecacheChannel(utils.CacheThresholdFilterIndexes))
diff --git a/services/resources_test.go b/services/resources_test.go
index 90013b0b4..a8fa07403 100644
--- a/services/resources_test.go
+++ b/services/resources_test.go
@@ -40,7 +40,7 @@ func TestResourceSCoverage(t *testing.T) {
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep)
 	db := NewDataDBService(cfg, nil, srvDep)
-	chS := NewCacheService(cfg, db, server, make(chan context.ClientConnector, 1), anz, nil, srvDep)
+	chS := NewCacheService(cfg, db, nil, server, make(chan context.ClientConnector, 1), anz, nil, srvDep)
 	reS := NewResourceService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep)
 
 	if reS.IsRunning() {
diff --git a/services/routes_it_test.go b/services/routes_it_test.go
index b4246da1f..37885932e 100644
--- a/services/routes_it_test.go
+++ b/services/routes_it_test.go
@@ -43,7 +43,7 @@ func TestRouteSReload(t *testing.T) {
 	filterSChan := make(chan *engine.FilterS, 1)
 	filterSChan <- nil
 	shdWg := new(sync.WaitGroup)
-	chS := engine.NewCacheS(cfg, nil, nil)
+	chS := engine.NewCacheS(cfg, nil, nil, nil)
 	close(chS.GetPrecacheChannel(utils.CacheRouteProfiles))
 	close(chS.GetPrecacheChannel(utils.CacheRouteFilterIndexes))
 	chSCh := make(chan *engine.CacheS, 1)
diff --git a/services/routes_test.go b/services/routes_test.go
index 6ce873af2..13e4ed7f0 100644
--- a/services/routes_test.go
+++ b/services/routes_test.go
@@ -40,7 +40,7 @@ func TestSupplierSCoverage(t *testing.T) {
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	db := NewDataDBService(cfg, nil, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep)
-	chS := NewCacheService(cfg, db, server, make(chan context.ClientConnector, 1), anz, nil, srvDep)
+	chS := NewCacheService(cfg, db, nil, server, make(chan context.ClientConnector, 1), anz, nil, srvDep)
 	supS := NewRouteService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep)
 
 	if supS.IsRunning() {
diff --git a/services/sessions_it_test.go b/services/sessions_it_test.go
index 4b6c26751..e118d9542 100644
--- a/services/sessions_it_test.go
+++ b/services/sessions_it_test.go
@@ -60,7 +60,7 @@ func TestSessionSReload1(t *testing.T) {
 	defer func() {
 		engine.Cache = temporaryCache
 	}()
-	engine.Cache = engine.NewCacheS(cfg, nil, nil)
+	engine.Cache = engine.NewCacheS(cfg, nil, nil, nil)
 	filterSChan := make(chan *engine.FilterS, 1)
 	filterSChan <- nil
 	server := cores.NewServer(nil)
@@ -146,7 +146,7 @@ func TestSessionSReload2(t *testing.T) {
 	cfg.CdrsCfg().Enabled = true
 	filterSChan := make(chan *engine.FilterS, 1)
 	filterSChan <- nil
-	chS := engine.NewCacheS(cfg, nil, nil)
+	chS := engine.NewCacheS(cfg, nil, nil, nil)
 	close(chS.GetPrecacheChannel(utils.CacheChargerProfiles))
 	close(chS.GetPrecacheChannel(utils.CacheChargerFilterIndexes))
 
@@ -192,7 +192,7 @@ func TestSessionSReload3(t *testing.T) {
 	cfg.CdrsCfg().Enabled = true
 	filterSChan := make(chan *engine.FilterS, 1)
 	filterSChan <- nil
-	chS := engine.NewCacheS(cfg, nil, nil)
+	chS := engine.NewCacheS(cfg, nil, nil, nil)
 	close(chS.GetPrecacheChannel(utils.CacheChargerProfiles))
 	close(chS.GetPrecacheChannel(utils.CacheChargerFilterIndexes))
 
diff --git a/services/stats_it_test.go b/services/stats_it_test.go
index 222f4405d..6deecccaa 100644
--- a/services/stats_it_test.go
+++ b/services/stats_it_test.go
@@ -44,7 +44,7 @@ func TestStatSReload(t *testing.T) {
 	filterSChan := make(chan *engine.FilterS, 1)
 	filterSChan <- nil
 	shdWg := new(sync.WaitGroup)
-	chS := engine.NewCacheS(cfg, nil, nil)
+	chS := engine.NewCacheS(cfg, nil, nil, nil)
 	close(chS.GetPrecacheChannel(utils.CacheThresholdProfiles))
 	close(chS.GetPrecacheChannel(utils.CacheThresholds))
 	close(chS.GetPrecacheChannel(utils.CacheThresholdFilterIndexes))
diff --git a/services/stats_test.go b/services/stats_test.go
index 65c4c5e05..2c558eaee 100644
--- a/services/stats_test.go
+++ b/services/stats_test.go
@@ -41,7 +41,7 @@ func TestStatSCoverage(t *testing.T) {
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep)
 	db := NewDataDBService(cfg, nil, srvDep)
-	chS := NewCacheService(cfg, db, server, make(chan context.ClientConnector, 1), anz, nil, srvDep)
+	chS := NewCacheService(cfg, db, nil, server, make(chan context.ClientConnector, 1), anz, nil, srvDep)
 	sS := NewStatService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep)
 	if sS.IsRunning() {
 		t.Errorf("Expected service to be down")
diff --git a/services/thresholds_it_test.go b/services/thresholds_it_test.go
index a22a80567..531b48104 100644
--- a/services/thresholds_it_test.go
+++ b/services/thresholds_it_test.go
@@ -43,7 +43,7 @@ func TestThresholdSReload(t *testing.T) {
 	filterSChan := make(chan *engine.FilterS, 1)
 	filterSChan <- nil
 	shdWg := new(sync.WaitGroup)
-	chS := engine.NewCacheS(cfg, nil, nil)
+	chS := engine.NewCacheS(cfg, nil, nil, nil)
 	close(chS.GetPrecacheChannel(utils.CacheThresholdProfiles))
 	close(chS.GetPrecacheChannel(utils.CacheThresholds))
 	close(chS.GetPrecacheChannel(utils.CacheThresholdFilterIndexes))
@@ -112,7 +112,7 @@ func TestThresholdSReload2(t *testing.T) {
 	filterSChan := make(chan *engine.FilterS, 1)
 	filterSChan <- nil
 	shdWg := new(sync.WaitGroup)
-	chS := engine.NewCacheS(cfg, nil, nil)
+	chS := engine.NewCacheS(cfg, nil, nil, nil)
 	close(chS.GetPrecacheChannel(utils.CacheThresholdProfiles))
 	close(chS.GetPrecacheChannel(utils.CacheThresholds))
 	close(chS.GetPrecacheChannel(utils.CacheThresholdFilterIndexes))
diff --git a/services/thresholds_test.go b/services/thresholds_test.go
index 608c069eb..a5b4c8431 100644
--- a/services/thresholds_test.go
+++ b/services/thresholds_test.go
@@ -39,7 +39,7 @@ func TestThresholdSCoverage(t *testing.T) {
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep)
 	db := NewDataDBService(cfg, nil, srvDep)
-	chS := NewCacheService(cfg, db, server, make(chan context.ClientConnector, 1), anz, nil, srvDep)
+	chS := NewCacheService(cfg, db, nil, server, make(chan context.ClientConnector, 1), anz, nil, srvDep)
 	tS := NewThresholdService(cfg, db, chS, filterSChan, nil, server, make(chan birpc.ClientConnector, 1), anz, srvDep)
 	if tS.IsRunning() {
 		t.Errorf("Expected service to be down")
diff --git a/sessions/sessionscover_test.go b/sessions/sessionscover_test.go
index f36f1d6a3..07e26f685 100644
--- a/sessions/sessionscover_test.go
+++ b/sessions/sessionscover_test.go
@@ -4636,7 +4636,7 @@ func TestSyncSessionsSync(t *testing.T) {
 	sessions := NewSessionS(cfg, dm, nil, connMgr)
 	sessions.aSessions = map[string]*Session{}
 	sessions.cfg.GeneralCfg().ReplyTimeout = 1
-	cacheS := engine.NewCacheS(cfg, nil, nil)
+	cacheS := engine.NewCacheS(cfg, nil, nil, nil)
 	engine.Cache = cacheS
 	engine.SetConnManager(connMgr)
 	sessions.aSessions = map[string]*Session{}