Finished session volume discount test

data/conf/samples/session_volume_discount_internal/cgrates.json

@@ -1,67 +1,87 @@
 {
- // CGRateS Configuration file
- //
- // Used for sessions/sessions_volume_discount_it_test.go
-
-    "general": {
-        "log_level": 7,
-    },
-
-    "data_db": {
-        "db_type": "*internal",	
+    // CGRateS Configuration file
+    //
+    // Used for sessions/sessions_volume_discount_it_test.go
+   
+       "general": {
+           "log_level": 7,
+       },
+   
+       "data_db": {
+        "db_type": "*internal"
     },
     
+
     "stor_db": {
-        "db_type": "*internal",	
+        "db_type": "*internal"
     },
-
-    "sessions": {
-        "enabled": true,
-        "routes_conns": ["*localhost"],
-        "cdrs_conns": ["*localhost"],
-    },
-
-    "cdrs": {									// CDRs config
-        "enabled": true,
-        "accounts_conns":["*localhost"],
-        "chargers_conns":["*localhost"],
-    },
-
-    "chargers": {
-       "enabled": true,
-       "indexed_selects": false,
-    },
-
-    "rates": {
-        "enabled": true,
-        "rate_indexed_selects": false,
-    },
-
-    "accounts": {
-        "enabled": true,
-        "rates_conns": ["*localhost"],
-        "indexed_selects": false,
-    },
-
-    "loaders": [
-        {
-            "id": "*default",
-            "enabled": true,
-            "tenant": "cgrates.org",
-            "tp_in_dir": "/usr/share/cgrates/tariffplans/sessions_discount_volume",
-            "tp_out_dir": "",
-            "lockfile_path": "",
-        },
-    ],
-
-    "routes": {
-        "enabled": true,
-        "indexed_selects": false,
-        "rates_conns": ["*localhost"],						// connections to RateS
-	    "accounts_conns": ["*localhost"],					// connections to AccountS
-    },
-
-    "admins": {
-        "enabled": true,
-    },
-}
+   
+       "sessions": {
+           "enabled": true,
+           "routes_conns": ["*localhost"],
+           "cdrs_conns": ["*localhost"],
+       },
+   
+       "attributes": {
+           "enabled": true,
+           "indexed_selects": false,
+       },
+   
+       "cdrs": {									// CDRs config
+           "enabled": true,
+           "accounts_conns":["*localhost"],
+           "rates_conns": ["*localhost"],
+           "chargers_conns":["*localhost"],
+           "opts": {								//
+               "*chargerS": {						//
+                   "": true,
+               },
+               "*rateS": {						//
+                   "": true,
+               },
+               "*accountS": {						//
+                   "*string:~*req.Account:ACCOUNT1": true,
+                   "": false,
+               },
+           },   
+       },
+   
+       "chargers": {
+          "enabled": true,
+          "attributes_conns": ["*localhost"],
+          "indexed_selects": false,
+       },
+   
+       "rates": {
+           "enabled": true,
+           "rate_indexed_selects": false,
+       },
+   
+       "accounts": {
+           "enabled": true,
+           "rates_conns": ["*localhost"],
+           "indexed_selects": false,
+       },
+   
+       "loaders": [
+           {
+               "id": "*default",
+               "enabled": true,
+               "tenant": "cgrates.org",
+               "tp_in_dir": "/usr/share/cgrates/tariffplans/sessions_discount_volume",
+               "tp_out_dir": "",
+               "lockfile_path": "",
+           },
+       ],
+   
+       "routes": {
+           "enabled": true,
+           "indexed_selects": false,
+           "rates_conns": ["*localhost"],						// connections to RateS
+           "accounts_conns": ["*localhost"],					// connections to AccountS
+       },
+   
+       "admins": {
+           "enabled": true,
+       },
+   }

data/conf/samples/session_volume_discount_mongo/cgrates.json

@@ -0,0 +1,90 @@
+{
+ // CGRateS Configuration file
+ //
+ // Used for sessions/sessions_volume_discount_it_test.go
+
+    "general": {
+        "log_level": 7,
+    },
+
+    "data_db": {
+        "db_type": "mongo",
+        "db_name": "10",
+        "db_port": 27017,
+    },
+    
+    "stor_db": {
+        "db_type": "mongo",
+        "db_name": "cgrates",
+        "db_port": 27017,
+    },
+
+    "sessions": {
+        "enabled": true,
+        "routes_conns": ["*localhost"],
+        "cdrs_conns": ["*localhost"],
+    },
+
+    "attributes": {
+        "enabled": true,
+        "indexed_selects": false,
+    },
+
+    "cdrs": {									// CDRs config
+        "enabled": true,
+        "accounts_conns":["*localhost"],
+        "rates_conns": ["*localhost"],
+        "chargers_conns":["*localhost"],
+        "opts": {								//
+            "*chargerS": {						//
+                "": true,
+            },
+            "*rateS": {						//
+                "": true,
+            },
+            "*accountS": {						//
+                "*string:~*req.Account:ACCOUNT1": true,
+                "": false,
+            },
+        },   
+    },
+
+    "chargers": {
+       "enabled": true,
+       "attributes_conns": ["*localhost"],
+       "indexed_selects": false,
+    },
+
+    "rates": {
+        "enabled": true,
+        "rate_indexed_selects": false,
+    },
+
+    "accounts": {
+        "enabled": true,
+        "rates_conns": ["*localhost"],
+        "indexed_selects": false,
+    },
+
+    "loaders": [
+        {
+            "id": "*default",
+            "enabled": true,
+            "tenant": "cgrates.org",
+            "tp_in_dir": "/usr/share/cgrates/tariffplans/sessions_discount_volume",
+            "tp_out_dir": "",
+            "lockfile_path": "",
+        },
+    ],
+
+    "routes": {
+        "enabled": true,
+        "indexed_selects": false,
+        "rates_conns": ["*localhost"],						// connections to RateS
+	    "accounts_conns": ["*localhost"],					// connections to AccountS
+    },
+
+    "admins": {
+        "enabled": true,
+    },
+}

data/conf/samples/session_volume_discount_mysql/cgrates.json

@@ -0,0 +1,88 @@
+{
+ // CGRateS Configuration file
+ //
+ // Used for sessions/sessions_volume_discount_it_test.go
+
+    "general": {
+        "log_level": 7,
+    },
+
+    "data_db": {								// database used to store runtime data (eg: accounts, cdr stats)
+        "db_type": "redis",						// data_db type: <redis|mongo>
+        "db_port": 6379, 						// data_db port to reach the database
+        "db_name": "10", 						// data_db database name to connect to
+    },
+    
+    "stor_db": {
+        "db_password": "CGRateS.org",
+    },
+
+    "sessions": {
+        "enabled": true,
+        "routes_conns": ["*localhost"],
+        "cdrs_conns": ["*localhost"],
+    },
+
+    "attributes": {
+        "enabled": true,
+        "indexed_selects": false,
+    },
+
+    "cdrs": {									// CDRs config
+        "enabled": true,
+        "accounts_conns":["*localhost"],
+        "rates_conns": ["*localhost"],
+        "chargers_conns":["*localhost"],
+        "opts": {								//
+            "*chargerS": {						//
+                "": true,
+            },
+            "*rateS": {						//
+                "": true,
+            },
+            "*accountS": {						//
+                "*string:~*req.Account:ACCOUNT1": true,
+                "": false,
+            },
+        },   
+    },
+
+    "chargers": {
+       "enabled": true,
+       "attributes_conns": ["*localhost"],
+       "indexed_selects": false,
+    },
+
+    "rates": {
+        "enabled": true,
+        "rate_indexed_selects": false,
+    },
+
+    "accounts": {
+        "enabled": true,
+        "rates_conns": ["*localhost"],
+        "indexed_selects": false,
+    },
+
+    "loaders": [
+        {
+            "id": "*default",
+            "enabled": true,
+            "tenant": "cgrates.org",
+            "tp_in_dir": "/usr/share/cgrates/tariffplans/sessions_discount_volume",
+            "tp_out_dir": "",
+            "lockfile_path": "",
+        },
+    ],
+
+    "routes": {
+        "enabled": true,
+        "indexed_selects": false,
+        "rates_conns": ["*localhost"],						// connections to RateS
+	    "accounts_conns": ["*localhost"],					// connections to AccountS
+    },
+
+    "admins": {
+        "enabled": true,
+    },
+}

data/tariffplans/sessions_discount_volume/Attributes.csv

@@ -0,0 +1,5 @@
+#Tenant,ID,FilterIDs,Weight,AttributeFilterIDs,Path,Type,Value,Blocker
+
+cgrates.org,ATTR_ACCOUNTS,*string:~*req.Account:ACCOUNT1,10,,*opts.*accountS,*constant,true,false
+
+cgrates.org,ATTR_RATES,,10,,*opts.*rateS,*constant,true,false

data/tariffplans/sessions_discount_volume/Chargers.csv

@@ -1,3 +1,5 @@
 #Tenant,ID,FilterIDs,Weight,RunID,AttributeIDs
-cgrates.org,Raw,,20,raw,*none
-cgrates.org,Default,,10,Default,*none
+
+cgrates.org,CHRG_SUPPLIER,,20,supplier,*constant:*opts.*rateS:true
+
+cgrates.org,CHRG_CUSTOMER,,10,customer,ATTR_ACCOUNTS;ATTR_RATES

data/tariffplans/sessions_discount_volume/RateProfiles.csv

@@ -1,10 +1,10 @@
 #Tenant,ID,FilterIDs,Weights,MinCost,MaxCost,MaxCostStrategy,RateID,RateFilterIDs,RateActivationStart,RateWeights,RateBlocker,RateIntervalStart,RateFixedFee,RateRecurrentFee,RateUnit,RateIncrement
 
-cgrates.org,RP_ABS_BALANCE1,,,,,,RT_ABS1,,"* * * * *",;10,false,0s,,0.01,1s,1s
+cgrates.org,RP_ABS_BALANCE1,,;30,,,,RT_ABS1,,"* * * * *",;10,false,0s,,0.01,1s,1s
 
-cgrates.org,RP_ABS_BALANCE2,,,,,,RT_ABS2,,"* * * * *",;10,false,0s,,0.02,1s,1s
+cgrates.org,RP_ABS_BALANCE2,,;20,,,,RT_ABS2,,"* * * * *",;10,false,0s,,0.02,1s,1s
 
-cgrates.org,RP_CNCRT_BALANCE1,,,,,,RT_CNC1,,"* * * * *",;10,false,0s,,0.1,1s,1s
+cgrates.org,RP_CNCRT_BALANCE1,,;10,,,,RT_CNC1,,"* * * * *",;10,false,0s,,0.1,1s,1s
 
-cgrates.org,RP_ROUTE2,,,,,,RT_ROUTE,,"* * * * *",;10,false,0s,,0.05,1s,1s
+cgrates.org,RP_ROUTE2,,;10,,,,RT_ROUTE,,"* * * * *",;10,false,0s,,0.05,1s,1s
 

engine/cdrs.go

@@ -188,8 +188,17 @@ func (cdrS *CDRServer) eeSProcessEvent(ctx *context.Context, cgrEv *utils.CGREve
 
 // processEvent processes a CGREvent based on arguments
 // in case of partially executed, both error and evs will be returned
-func (cdrS *CDRServer) processEvent(ctx *context.Context, ev *utils.CGREvent,
-	chrgS, attrS, rateS, acntS, eeS, thdS, stS bool) (evs []*utils.EventWithFlags, err error) {
+func (cdrS *CDRServer) processEvent(ctx *context.Context, ev *utils.CGREvent) (evs []*utils.EventWithFlags, err error) {
+	// making the options
+	var attrS bool
+	if v, has := ev.APIOpts[utils.OptsAttributeS]; !has {
+		if attrS, err = FilterBoolCfgOpts(ctx, ev.Tenant, ev.AsDataProvider(), cdrS.filterS,
+			cdrS.cfg.CdrsCfg().Opts.Attributes); err != nil {
+			return
+		}
+	} else if attrS, err = utils.IfaceAsBool(v); err != nil {
+		return
+	}
 	if attrS {
 		if err = cdrS.attrSProcessEvent(ctx, ev); err != nil {
 			utils.Logger.Warning(
@@ -201,6 +210,14 @@ func (cdrS *CDRServer) processEvent(ctx *context.Context, ev *utils.CGREvent,
 	}
 
 	var cgrEvs []*utils.CGREvent
+	var chrgS bool
+	if v, has := ev.APIOpts[utils.OptsChargerS]; !has {
+		if chrgS, err = FilterBoolCfgOpts(ctx, ev.Tenant, ev.AsDataProvider(), cdrS.filterS, cdrS.cfg.CdrsCfg().Opts.Chargers); err != nil {
+			return
+		}
+	} else if chrgS, err = utils.IfaceAsBool(v); err != nil {
+		return
+	}
 	if chrgS {
 		if cgrEvs, err = cdrS.chrgrSProcessEvent(ctx, ev); err != nil {
 			utils.Logger.Warning(
@@ -215,8 +232,17 @@ func (cdrS *CDRServer) processEvent(ctx *context.Context, ev *utils.CGREvent,
 
 	var partiallyExecuted bool // from here actions are optional and a general error is returned
 
-	if rateS {
-		for _, cgrEv := range cgrEvs {
+	var rateS bool
+	for _, cgrEv := range cgrEvs {
+		if v, has := cgrEv.APIOpts[utils.OptsRateS]; !has {
+			if rateS, err = FilterBoolCfgOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.filterS,
+				cdrS.cfg.CdrsCfg().Opts.Rates); err != nil {
+				return
+			}
+		} else if rateS, err = utils.IfaceAsBool(v); err != nil {
+			return
+		}
+		if rateS {
 			if err := cdrS.rateSCostForEvent(ctx, cgrEv); err != nil {
 				utils.Logger.Warning(
 					fmt.Sprintf("<%s> error: <%s> processing event %+v with %s",
@@ -226,20 +252,41 @@ func (cdrS *CDRServer) processEvent(ctx *context.Context, ev *utils.CGREvent,
 		}
 	}
 
-	if acntS {
-		for _, cgrEv := range cgrEvs {
-			if err := cdrS.accountSDebitEvent(ctx, cgrEv); err != nil {
-				utils.Logger.Warning(
-					fmt.Sprintf("<%s> error: <%s> processing event %+v with %s",
-						utils.CDRs, err.Error(), utils.ToJSON(cgrEv), utils.AccountS))
-				partiallyExecuted = true
+	var acntS bool
+	for _, cgrEv := range cgrEvs {
+		if v, has := ev.APIOpts[utils.OptsAccountS]; !has {
+			if acntS, err = FilterBoolCfgOpts(ctx, cgrEv.Tenant, ev.AsDataProvider(), cdrS.filterS,
+				cdrS.cfg.CdrsCfg().Opts.Accounts); err != nil {
+				return
+			}
+		} else if acntS, err = utils.IfaceAsBool(v); err != nil {
+			return
+		}
+		if acntS {
+
+			if acntS {
+				if err := cdrS.accountSDebitEvent(ctx, cgrEv); err != nil {
+					utils.Logger.Warning(
+						fmt.Sprintf("<%s> error: <%s> processing event %+v with %s",
+							utils.CDRs, err.Error(), utils.ToJSON(cgrEv), utils.AccountS))
+					partiallyExecuted = true
+				}
 			}
 		}
 	}
 
-	if eeS {
-		if len(cdrS.cfg.CdrsCfg().EEsConns) != 0 {
-			for _, cgrEv := range cgrEvs {
+	var export bool
+	if len(cdrS.cfg.CdrsCfg().EEsConns) != 0 {
+		for _, cgrEv := range cgrEvs {
+			if v, has := cgrEv.APIOpts[utils.OptsCDRsExport]; !has {
+				if export, err = FilterBoolCfgOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.filterS,
+					cdrS.cfg.CdrsCfg().Opts.Export); err != nil {
+					return
+				}
+			} else if export, err = utils.IfaceAsBool(v); err != nil {
+				return
+			}
+			if export {
 				evWithOpts := &utils.CGREventWithEeIDs{
 					CGREvent: cgrEv,
 					EeIDs:    cdrS.cfg.CdrsCfg().OnlineCDRExports,
@@ -254,8 +301,17 @@ func (cdrS *CDRServer) processEvent(ctx *context.Context, ev *utils.CGREvent,
 		}
 	}
 
-	if thdS {
-		for _, cgrEv := range cgrEvs {
+	var thdS bool
+	for _, cgrEv := range cgrEvs {
+		if v, has := cgrEv.APIOpts[utils.OptsThresholdS]; !has {
+			if thdS, err = FilterBoolCfgOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.filterS,
+				cdrS.cfg.CdrsCfg().Opts.Thresholds); err != nil {
+				return
+			}
+		} else if thdS, err = utils.IfaceAsBool(v); err != nil {
+			return
+		}
+		if thdS {
 			if err := cdrS.thdSProcessEvent(ctx, cgrEv); err != nil {
 				utils.Logger.Warning(
 					fmt.Sprintf("<%s> error: <%s> processing event %+v with %s",
@@ -265,8 +321,17 @@ func (cdrS *CDRServer) processEvent(ctx *context.Context, ev *utils.CGREvent,
 		}
 	}
 
-	if stS {
-		for _, cgrEv := range cgrEvs {
+	var stS bool
+	for _, cgrEv := range cgrEvs {
+		if v, has := cgrEv.APIOpts[utils.OptsStatS]; !has {
+			if stS, err = FilterBoolCfgOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.filterS,
+				cdrS.cfg.CdrsCfg().Opts.Stats); err != nil {
+				return
+			}
+		} else if stS, err = utils.IfaceAsBool(v); err != nil {
+			return
+		}
+		if stS {
 			if err := cdrS.statSProcessEvent(ctx, cgrEv); err != nil {
 				utils.Logger.Warning(
 					fmt.Sprintf("<%s> error: <%s> processing event %+v with %s",
@@ -279,7 +344,6 @@ func (cdrS *CDRServer) processEvent(ctx *context.Context, ev *utils.CGREvent,
 	if partiallyExecuted {
 		err = utils.ErrPartiallyExecuted
 	}
-
 	return
 }
 
@@ -311,81 +375,14 @@ func (cdrS *CDRServer) V1ProcessEvent(ctx *context.Context, arg *utils.CGREvent,
 	}
 	// end of RPC caching
 
-	// processing options
-	argsDP := arg.AsDataProvider()
-	var acntS bool
-	if v, has := arg.APIOpts[utils.OptsAccountS]; !has {
-		if acntS, err = FilterBoolCfgOpts(ctx, arg.Tenant, argsDP, cdrS.filterS,
-			cdrS.cfg.CdrsCfg().Opts.Accounts); err != nil {
-			return
-		}
-	} else if acntS, err = utils.IfaceAsBool(v); err != nil {
-		return
-	}
-	var attrS bool
-	if v, has := arg.APIOpts[utils.OptsAttributeS]; !has {
-		if attrS, err = FilterBoolCfgOpts(ctx, arg.Tenant, argsDP, cdrS.filterS,
-			cdrS.cfg.CdrsCfg().Opts.Attributes); err != nil {
-			return
-		}
-	} else if attrS, err = utils.IfaceAsBool(v); err != nil {
-		return
-	}
-	var chrgS bool
-	if v, has := arg.APIOpts[utils.OptsChargerS]; !has {
-		if chrgS, err = FilterBoolCfgOpts(ctx, arg.Tenant, argsDP, cdrS.filterS,
-			cdrS.cfg.CdrsCfg().Opts.Chargers); err != nil {
-			return
-		}
-	} else if chrgS, err = utils.IfaceAsBool(v); err != nil {
-		return
-	}
-	var export bool
-	if v, has := arg.APIOpts[utils.OptsCDRsExport]; !has {
-		if export, err = FilterBoolCfgOpts(ctx, arg.Tenant, argsDP, cdrS.filterS,
-			cdrS.cfg.CdrsCfg().Opts.Export); err != nil {
-			return
-		}
-	} else if export, err = utils.IfaceAsBool(v); err != nil {
-		return
-	}
-	var rateS bool
-	if v, has := arg.APIOpts[utils.OptsRateS]; !has {
-		if rateS, err = FilterBoolCfgOpts(ctx, arg.Tenant, argsDP, cdrS.filterS,
-			cdrS.cfg.CdrsCfg().Opts.Rates); err != nil {
-			return
-		}
-	} else if rateS, err = utils.IfaceAsBool(v); err != nil {
-		return
-	}
-	var stS bool
-	if v, has := arg.APIOpts[utils.OptsStatS]; !has {
-		if stS, err = FilterBoolCfgOpts(ctx, arg.Tenant, argsDP, cdrS.filterS,
-			cdrS.cfg.CdrsCfg().Opts.Stats); err != nil {
-			return
-		}
-	} else if stS, err = utils.IfaceAsBool(v); err != nil {
-		return
-	}
-	var thdS bool
-	if v, has := arg.APIOpts[utils.OptsThresholdS]; !has {
-		if thdS, err = FilterBoolCfgOpts(ctx, arg.Tenant, argsDP, cdrS.filterS,
-			cdrS.cfg.CdrsCfg().Opts.Thresholds); err != nil {
-			return
-		}
-	} else if thdS, err = utils.IfaceAsBool(v); err != nil {
-		return
-	}
-	// end of processing options
-
-	if _, err = cdrS.processEvent(ctx, arg,
-		chrgS, attrS, rateS, acntS, export, thdS, stS); err != nil {
+	if _, err = cdrS.processEvent(ctx, arg); err != nil {
 		return
 	}
 	*reply = utils.OK
 	return nil
 }
 
+/*
 // V1ProcessEventWithGet has the same logic with V1ProcessEvent except it adds the proccessed events to the reply
 func (cdrS *CDRServer) V1ProcessEventWithGet(ctx *context.Context, arg *utils.CGREvent, evs *[]*utils.EventWithFlags) (err error) {
 	if arg.ID == "" {
@@ -486,3 +483,5 @@ func (cdrS *CDRServer) V1ProcessEventWithGet(ctx *context.Context, arg *utils.CG
 	*evs = procEvs
 	return nil
 }
+
+*/

general_tests/session_volume_discount_it_test.go

@@ -54,9 +54,10 @@ var (
 		testSessVolDiscAuthorizeEventSortRoutes1Min30Sec,
 		testSessVolDiscAuthorizeEventSortRoutes11Min10Sec,
 		testSessVolDiscAuthorizeEventSortRoutes20Min,
-		testSessVolDiscProcessCDR,
+		testSessVolDiscProcessCDRSupplier,
+		testSessVolDiscProcessCDRCustomer,
 		testSessVolDiscAccountAfterDebiting,
-		testSessVolDiscAuthorizeEventSortRoutes1Min30SecBeforeDebiting,
+		testSessVolDiscAuthorizeEventSortRoutes1Min30SecAfterDebiting,
 		testSessVolDiscStopCgrEngine,
 	}
 )
@@ -183,7 +184,7 @@ func testSessVolDiscAuthorizeEventSortRoutes1Min30Sec(t *testing.T) {
 			utils.OptsRouteS: true,
 		},
 	}
-	// authorize the session
+	// authorize the session for 1m30s
 	var rplyFirst *sessions.V1AuthorizeReply
 	if err := tSessVolDiscBiRPC.Call(context.Background(), utils.SessionSv1AuthorizeEvent,
 		args, &rplyFirst); err != nil {
@@ -233,7 +234,7 @@ func testSessVolDiscAuthorizeEventSortRoutes11Min10Sec(t *testing.T) {
 			utils.OptsRouteS: true,
 		},
 	}
-	// authorize the session
+	// authorize the session for 11m10s
 	var rplyFirst *sessions.V1AuthorizeReply
 	if err := tSessVolDiscBiRPC.Call(context.Background(), utils.SessionSv1AuthorizeEvent,
 		args, &rplyFirst); err != nil {
@@ -283,7 +284,7 @@ func testSessVolDiscAuthorizeEventSortRoutes20Min(t *testing.T) {
 			utils.OptsRouteS: true,
 		},
 	}
-	// authorize the session
+	// authorize the session for 20m
 	var rplyFirst *sessions.V1AuthorizeReply
 	if err := tSessVolDiscBiRPC.Call(context.Background(), utils.SessionSv1AuthorizeEvent,
 		args, &rplyFirst); err != nil {
@@ -293,7 +294,7 @@ func testSessVolDiscAuthorizeEventSortRoutes20Min(t *testing.T) {
 	}
 }
 
-func testSessVolDiscProcessCDR(t *testing.T) {
+func testSessVolDiscProcessCDRSupplier(t *testing.T) {
 	args := utils.CGREvent{
 		Tenant: "cgrates.org",
 		ID:     "TestSSv1ItProcessCDR",
@@ -302,10 +303,37 @@ func testSessVolDiscProcessCDR(t *testing.T) {
 			utils.Destination:  "1002",
 		},
 		APIOpts: map[string]interface{}{
-			utils.OptsChargerS: true,
-			utils.OptsAccountS: true,
-			utils.StartTime:    time.Date(2020, time.January, 7, 16, 60, 0, 0, time.UTC),
-			utils.MetaUsage:    15 * time.Minute,
+			//utils.OptsAttributeS: true,
+			// utils.OptsChargerS: true,
+			//utils.OptsAccountS: true,
+			utils.StartTime: time.Date(2020, time.January, 7, 16, 60, 0, 0, time.UTC),
+			utils.MetaUsage: 15 * time.Minute,
+		},
+	}
+
+	var rply string
+	if err := tSessVolDiscBiRPC.Call(context.Background(), utils.SessionSv1ProcessCDR,
+		args, &rply); err != nil {
+		t.Fatal(err)
+	}
+	if rply != utils.OK {
+		t.Errorf("Unexpected reply: %s", rply)
+	}
+}
+
+func testSessVolDiscProcessCDRCustomer(t *testing.T) {
+	args := utils.CGREvent{
+		Tenant: "cgrates.org",
+		ID:     "TestSSv1ItProcessCDR",
+		Event: map[string]interface{}{
+			utils.Destination: "1002",
+		},
+		APIOpts: map[string]interface{}{
+			// utils.OptsAttributeS: true,
+			// utils.OptsChargerS: true,
+			// utils.OptsAccountS: true,
+			utils.StartTime: time.Date(2020, time.January, 7, 16, 60, 0, 0, time.UTC),
+			utils.MetaUsage: 15 * time.Minute,
 		},
 	}
 
@@ -334,7 +362,7 @@ func testSessVolDiscAccountAfterDebiting(t *testing.T) {
 					},
 				},
 				Type:           "*abstract",
-				Units:          &utils.Decimal{utils.SumDecimalAsBig(&utils.Decimal{utils.NewDecimal(0, 0).Neg(utils.NewDecimal(1, 0).Big)}, utils.NewDecimal(1, 0))},
+				Units:          &utils.Decimal{utils.SumDecimalAsBig(&utils.Decimal{utils.NewDecimal(0, 0).Neg(utils.NewDecimal(1, 0).Big)}, utils.NewDecimal(1, 0))}, // this should be -0
 				RateProfileIDs: []string{"RP_ABS_BALANCE1"},
 			},
 			"ABS_BALANCE2": {
@@ -381,7 +409,7 @@ func testSessVolDiscAccountAfterDebiting(t *testing.T) {
 	}
 }
 
-func testSessVolDiscAuthorizeEventSortRoutes1Min30SecBeforeDebiting(t *testing.T) {
+func testSessVolDiscAuthorizeEventSortRoutes1Min30SecAfterDebiting(t *testing.T) {
 	expected := &sessions.V1AuthorizeReply{
 		RouteProfiles: engine.SortedRoutesList{
 			{
@@ -421,7 +449,7 @@ func testSessVolDiscAuthorizeEventSortRoutes1Min30SecBeforeDebiting(t *testing.T
 			utils.OptsRouteS: true,
 		},
 	}
-	// authorize the session
+	// authorize the session for 1m30s
 	var rplyFirst *sessions.V1AuthorizeReply
 	if err := tSessVolDiscBiRPC.Call(context.Background(), utils.SessionSv1AuthorizeEvent,
 		args, &rplyFirst); err != nil {

services/cgr-engine.go

@@ -212,7 +212,7 @@ func (cgr *CGREngine) InitServices(httpPrfPath string, cpuPrfFl io.Closer, memPr
 		cgr.ldrs, cgr.anzS, dspS, cgr.dmS, cgr.sdbS,
 		NewAdminSv1Service(cgr.cfg, cgr.dmS, cgr.sdbS, cgr.iFilterSCh, cgr.server,
 			iAdminSCh, cgr.cM, cgr.anzS, cgr.srvDep),
-		NewSessionService(cgr.cfg, cgr.dmS, cgr.server, iSessionSCh, cgr.cM, cgr.anzS, cgr.srvDep),
+		NewSessionService(cgr.cfg, cgr.dmS, cgr.iFilterSCh, cgr.server, iSessionSCh, cgr.cM, cgr.anzS, cgr.srvDep),
 		NewAttributeService(cgr.cfg, cgr.dmS, cgr.cacheS, cgr.iFilterSCh, cgr.server, iAttributeSCh,
 			cgr.anzS, dspS, cgr.srvDep),
 		NewChargerService(cgr.cfg, cgr.dmS, cgr.cacheS, cgr.iFilterSCh, cgr.server,

services/sessions.go

@@ -36,18 +36,19 @@ import (
 )
 
 // NewSessionService returns the Session Service
-func NewSessionService(cfg *config.CGRConfig, dm *DataDBService,
+func NewSessionService(cfg *config.CGRConfig, dm *DataDBService, filterSChan chan *engine.FilterS,
 	server *cores.Server, internalChan chan birpc.ClientConnector,
 	connMgr *engine.ConnManager, anz *AnalyzerService,
 	srvDep map[string]*sync.WaitGroup) servmanager.Service {
 	return &SessionService{
-		connChan: internalChan,
-		cfg:      cfg,
-		dm:       dm,
-		server:   server,
-		connMgr:  connMgr,
-		anz:      anz,
-		srvDep:   srvDep,
+		connChan:    internalChan,
+		cfg:         cfg,
+		dm:          dm,
+		filterSChan: filterSChan,
+		server:      server,
+		connMgr:     connMgr,
+		anz:         anz,
+		srvDep:      srvDep,
 	}
 }
 
@@ -82,10 +83,8 @@ func (smg *SessionService) Start(ctx *context.Context, shtDw context.CancelFunc)
 	}
 
 	var datadb *engine.DataManager
-	if smg.dm.IsRunning() {
-		if datadb, err = smg.dm.WaitForDM(ctx); err != nil {
-			return
-		}
+	if datadb, err = smg.dm.WaitForDM(ctx); err != nil {
+		return
 	}
 	smg.Lock()
 	defer smg.Unlock()

sessions/sessions.go

@@ -1567,10 +1567,12 @@ func (sS *SessionS) BiRPCv1AuthorizeEvent(ctx *context.Context,
 	// end of RPC caching
 	var attrS bool
 	if v, has := args.APIOpts[utils.OptsAttributeS]; !has {
-		if attrS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.CGREvent.AsDataProvider(), sS.filterS,
-			sS.cgrCfg.CdrsCfg().Opts.Attributes); err != nil {
-			return
-		}
+		/*
+			if attrS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.CGREvent.AsDataProvider(), sS.filterS,
+				sS.cgrCfg.CdrsCfg().Opts.Attributes); err != nil {
+				return
+			}
+		*/
 	} else if attrS, err = utils.IfaceAsBool(v); err != nil {
 		return
 	}
@@ -1583,10 +1585,12 @@ func (sS *SessionS) BiRPCv1AuthorizeEvent(ctx *context.Context,
 		args.APIOpts = make(map[string]interface{})
 	}
 	if v, has := args.APIOpts[utils.OptsAttributeS]; !has {
-		if attrS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.CGREvent.AsDataProvider(), sS.filterS,
-			sS.cgrCfg.CdrsCfg().Opts.Attributes); err != nil {
-			return
-		}
+		/*
+			if attrS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.CGREvent.AsDataProvider(), sS.filterS,
+				sS.cgrCfg.CdrsCfg().Opts.Attributes); err != nil {
+				return
+			}
+		*/
 	} else if attrS, err = utils.IfaceAsBool(v); err != nil {
 		return
 	}
@@ -1609,10 +1613,12 @@ func (sS *SessionS) BiRPCv1AuthorizeEvent(ctx *context.Context,
 
 	var chrgS bool
 	if v, has := args.APIOpts[utils.OptsChargerS]; !has {
-		if chrgS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.CGREvent.AsDataProvider(), sS.filterS,
-			sS.cgrCfg.CdrsCfg().Opts.Chargers); err != nil {
-			return
-		}
+		/*
+			if chrgS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.CGREvent.AsDataProvider(), sS.filterS,
+				sS.cgrCfg.SessionSCfg().Opts.Chargers); err != nil {
+				return
+			}
+		*/
 	} else if chrgS, err = utils.IfaceAsBool(v); err != nil {
 		return
 	}
@@ -1629,10 +1635,12 @@ func (sS *SessionS) BiRPCv1AuthorizeEvent(ctx *context.Context,
 	}
 	var acntS bool
 	if v, has := args.APIOpts[utils.OptsAccountS]; !has {
-		if acntS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.CGREvent.AsDataProvider(), sS.filterS,
-			sS.cgrCfg.CdrsCfg().Opts.Stats); err != nil {
-			return
-		}
+		/*
+			if acntS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.CGREvent.AsDataProvider(), sS.filterS,
+				sS.cgrCfg.CdrsCfg().Opts.Stats); err != nil {
+				return
+			}
+		*/
 	} else if acntS, err = utils.IfaceAsBool(v); err != nil {
 		return
 	}
@@ -1675,10 +1683,12 @@ func (sS *SessionS) BiRPCv1AuthorizeEvent(ctx *context.Context,
 	}
 	var thdS bool
 	if v, has := args.APIOpts[utils.OptsThresholdS]; !has {
-		if thdS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.CGREvent.AsDataProvider(), sS.filterS,
-			sS.cgrCfg.CdrsCfg().Opts.Thresholds); err != nil {
-			return
-		}
+		/*
+			if thdS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.CGREvent.AsDataProvider(), sS.filterS,
+				sS.cgrCfg.CdrsCfg().Opts.Thresholds); err != nil {
+				return
+			}
+		*/
 	} else if thdS, err = utils.IfaceAsBool(v); err != nil {
 		return
 	}
@@ -1702,10 +1712,12 @@ func (sS *SessionS) BiRPCv1AuthorizeEvent(ctx *context.Context,
 	}
 	var stS bool
 	if v, has := args.APIOpts[utils.OptsStatS]; !has {
-		if stS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.CGREvent.AsDataProvider(), sS.filterS,
-			sS.cgrCfg.CdrsCfg().Opts.Stats); err != nil {
-			return
-		}
+		/*
+			if stS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.CGREvent.AsDataProvider(), sS.filterS,
+				sS.cgrCfg.CdrsCfg().Opts.Stats); err != nil {
+				return
+			}
+		*/
 	} else if stS, err = utils.IfaceAsBool(v); err != nil {
 		return
 	}
@@ -1743,10 +1755,12 @@ func (sS *SessionS) BiRPCv1AuthorizeEventWithDigest(ctx *context.Context,
 	}
 	var attrS bool
 	if v, has := args.APIOpts[utils.OptsAttributeS]; !has {
-		if attrS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.CGREvent.AsDataProvider(), sS.filterS,
-			sS.cgrCfg.CdrsCfg().Opts.Attributes); err != nil {
-			return
-		}
+		/*
+			if attrS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.CGREvent.AsDataProvider(), sS.filterS,
+				sS.cgrCfg.CdrsCfg().Opts.Attributes); err != nil {
+				return
+			}
+		*/
 	} else if attrS, err = utils.IfaceAsBool(v); err != nil {
 		return
 	}
@@ -1759,10 +1773,12 @@ func (sS *SessionS) BiRPCv1AuthorizeEventWithDigest(ctx *context.Context,
 	}
 	var acntS bool
 	if v, has := args.APIOpts[utils.OptsAccountS]; !has {
-		if acntS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.CGREvent.AsDataProvider(), sS.filterS,
-			sS.cgrCfg.CdrsCfg().Opts.Stats); err != nil {
-			return
-		}
+		/*
+			if acntS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.CGREvent.AsDataProvider(), sS.filterS,
+				sS.cgrCfg.CdrsCfg().Opts.Stats); err != nil {
+				return
+			}
+		*/
 	} else if acntS, err = utils.IfaceAsBool(v); err != nil {
 		return
 	}
@@ -1776,10 +1792,12 @@ func (sS *SessionS) BiRPCv1AuthorizeEventWithDigest(ctx *context.Context,
 	}
 	var thdS bool
 	if v, has := args.APIOpts[utils.OptsThresholdS]; !has {
-		if thdS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.CGREvent.AsDataProvider(), sS.filterS,
-			sS.cgrCfg.CdrsCfg().Opts.Thresholds); err != nil {
-			return
-		}
+		/*
+			if thdS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.CGREvent.AsDataProvider(), sS.filterS,
+				sS.cgrCfg.CdrsCfg().Opts.Thresholds); err != nil {
+				return
+			}
+		*/
 	} else if thdS, err = utils.IfaceAsBool(v); err != nil {
 		return
 	}
@@ -1789,10 +1807,12 @@ func (sS *SessionS) BiRPCv1AuthorizeEventWithDigest(ctx *context.Context,
 	}
 	var stS bool
 	if v, has := args.APIOpts[utils.OptsStatS]; !has {
-		if stS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.CGREvent.AsDataProvider(), sS.filterS,
-			sS.cgrCfg.CdrsCfg().Opts.Stats); err != nil {
-			return
-		}
+		/*
+			if stS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.CGREvent.AsDataProvider(), sS.filterS,
+				sS.cgrCfg.CdrsCfg().Opts.Stats); err != nil {
+				return
+			}
+		*/
 	} else if stS, err = utils.IfaceAsBool(v); err != nil {
 		return
 	}
@@ -1840,10 +1860,12 @@ func (sS *SessionS) BiRPCv1InitiateSession(ctx *context.Context,
 
 	var attrS bool
 	if v, has := args.APIOpts[utils.OptsAttributeS]; !has {
-		if attrS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.AsDataProvider(), sS.filterS,
-			sS.cgrCfg.CdrsCfg().Opts.Attributes); err != nil {
-			return
-		}
+		/*
+			if attrS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.AsDataProvider(), sS.filterS,
+				sS.cgrCfg.CdrsCfg().Opts.Attributes); err != nil {
+				return
+			}
+		*/
 	} else if attrS, err = utils.IfaceAsBool(v); err != nil {
 		return
 	}
@@ -1916,10 +1938,12 @@ func (sS *SessionS) BiRPCv1InitiateSession(ctx *context.Context,
 	}
 	var thdS bool
 	if v, has := args.APIOpts[utils.OptsThresholdS]; !has {
-		if thdS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.AsDataProvider(), sS.filterS,
-			sS.cgrCfg.CdrsCfg().Opts.Thresholds); err != nil {
-			return
-		}
+		/*
+			if thdS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.AsDataProvider(), sS.filterS,
+				sS.cgrCfg.CdrsCfg().Opts.Thresholds); err != nil {
+				return
+			}
+		*/
 	} else if thdS, err = utils.IfaceAsBool(v); err != nil {
 		return
 	}
@@ -1939,10 +1963,12 @@ func (sS *SessionS) BiRPCv1InitiateSession(ctx *context.Context,
 	}
 	var stS bool
 	if v, has := args.APIOpts[utils.OptsStatS]; !has {
-		if stS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.AsDataProvider(), sS.filterS,
-			sS.cgrCfg.CdrsCfg().Opts.Stats); err != nil {
-			return
-		}
+		/*
+			if stS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.AsDataProvider(), sS.filterS,
+				sS.cgrCfg.CdrsCfg().Opts.Stats); err != nil {
+				return
+			}
+		*/
 	} else if stS, err = utils.IfaceAsBool(v); err != nil {
 		return
 	}
@@ -2031,10 +2057,12 @@ func (sS *SessionS) BiRPCv1UpdateSession(ctx *context.Context,
 	// end of RPC caching
 	var attrS bool
 	if v, has := args.APIOpts[utils.OptsAttributeS]; !has {
-		if attrS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.AsDataProvider(), sS.filterS,
-			sS.cgrCfg.CdrsCfg().Opts.Attributes); err != nil {
-			return
-		}
+		/*
+			if attrS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.AsDataProvider(), sS.filterS,
+				sS.cgrCfg.CdrsCfg().Opts.Attributes); err != nil {
+				return
+			}
+		*/
 	} else if attrS, err = utils.IfaceAsBool(v); err != nil {
 		return
 	}
@@ -2196,10 +2224,12 @@ func (sS *SessionS) BiRPCv1TerminateSession(ctx *context.Context,
 	}
 	var thdS bool
 	if v, has := args.APIOpts[utils.OptsThresholdS]; !has {
-		if thdS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.AsDataProvider(), sS.filterS,
-			sS.cgrCfg.CdrsCfg().Opts.Thresholds); err != nil {
-			return
-		}
+		/*
+			if thdS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.AsDataProvider(), sS.filterS,
+				sS.cgrCfg.CdrsCfg().Opts.Thresholds); err != nil {
+				return
+			}
+		*/
 	} else if thdS, err = utils.IfaceAsBool(v); err != nil {
 		return
 	}
@@ -2219,10 +2249,12 @@ func (sS *SessionS) BiRPCv1TerminateSession(ctx *context.Context,
 	}
 	var stS bool
 	if v, has := args.APIOpts[utils.OptsStatS]; !has {
-		if stS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.AsDataProvider(), sS.filterS,
-			sS.cgrCfg.CdrsCfg().Opts.Stats); err != nil {
-			return
-		}
+		/*
+			if stS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.AsDataProvider(), sS.filterS,
+				sS.cgrCfg.CdrsCfg().Opts.Stats); err != nil {
+				return
+			}
+		*/
 	} else if stS, err = utils.IfaceAsBool(v); err != nil {
 		return
 	}
@@ -2323,10 +2355,12 @@ func (sS *SessionS) BiRPCv1ProcessMessage(ctx *context.Context,
 
 	var attrS bool
 	if v, has := args.APIOpts[utils.OptsAttributeS]; !has {
-		if attrS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.AsDataProvider(), sS.filterS,
-			sS.cgrCfg.CdrsCfg().Opts.Attributes); err != nil {
-			return
-		}
+		/*
+			if attrS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.AsDataProvider(), sS.filterS,
+				sS.cgrCfg.CdrsCfg().Opts.Attributes); err != nil {
+				return
+			}
+		*/
 	} else if attrS, err = utils.IfaceAsBool(v); err != nil {
 		return
 	}
@@ -2373,10 +2407,12 @@ func (sS *SessionS) BiRPCv1ProcessMessage(ctx *context.Context,
 	}
 	var thdS bool
 	if v, has := args.APIOpts[utils.OptsThresholdS]; !has {
-		if thdS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.AsDataProvider(), sS.filterS,
-			sS.cgrCfg.CdrsCfg().Opts.Thresholds); err != nil {
-			return
-		}
+		/*
+			if thdS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.AsDataProvider(), sS.filterS,
+				sS.cgrCfg.CdrsCfg().Opts.Thresholds); err != nil {
+				return
+			}
+		*/
 	} else if thdS, err = utils.IfaceAsBool(v); err != nil {
 		return
 	}
@@ -2396,10 +2432,12 @@ func (sS *SessionS) BiRPCv1ProcessMessage(ctx *context.Context,
 	}
 	var stS bool
 	if v, has := args.APIOpts[utils.OptsStatS]; !has {
-		if stS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.AsDataProvider(), sS.filterS,
-			sS.cgrCfg.CdrsCfg().Opts.Stats); err != nil {
-			return
-		}
+		/*
+			if stS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.AsDataProvider(), sS.filterS,
+				sS.cgrCfg.CdrsCfg().Opts.Stats); err != nil {
+				return
+			}
+		*/
 	} else if stS, err = utils.IfaceAsBool(v); err != nil {
 		return
 	}
@@ -2465,10 +2503,12 @@ func (sS *SessionS) BiRPCv1ProcessEvent(ctx *context.Context,
 	}
 	var chrgS bool
 	if v, has := args.APIOpts[utils.OptsChargerS]; !has {
-		if chrgS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.AsDataProvider(), sS.filterS,
-			sS.cgrCfg.CdrsCfg().Opts.Chargers); err != nil {
-			return
-		}
+		/*
+			if chrgS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.AsDataProvider(), sS.filterS,
+				sS.cgrCfg.CdrsCfg().Opts.Chargers); err != nil {
+				return
+			}
+		*/
 	} else if chrgS, err = utils.IfaceAsBool(v); err != nil {
 		return
 	}
@@ -2485,10 +2525,12 @@ func (sS *SessionS) BiRPCv1ProcessEvent(ctx *context.Context,
 	// check for *attribute
 	var attrS bool
 	if v, has := args.APIOpts[utils.OptsAttributeS]; !has {
-		if attrS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.AsDataProvider(), sS.filterS,
-			sS.cgrCfg.CdrsCfg().Opts.Attributes); err != nil {
-			return
-		}
+		/*
+			if attrS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.AsDataProvider(), sS.filterS,
+				sS.cgrCfg.CdrsCfg().Opts.Attributes); err != nil {
+				return
+			}
+		*/
 	} else if attrS, err = utils.IfaceAsBool(v); err != nil {
 		return
 	}
@@ -2527,10 +2569,12 @@ func (sS *SessionS) BiRPCv1ProcessEvent(ctx *context.Context,
 	// process thresholds if required
 	var thdS bool
 	if v, has := args.APIOpts[utils.OptsThresholdS]; !has {
-		if thdS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.AsDataProvider(), sS.filterS,
-			sS.cgrCfg.CdrsCfg().Opts.Thresholds); err != nil {
-			return
-		}
+		/*
+			if thdS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.AsDataProvider(), sS.filterS,
+				sS.cgrCfg.CdrsCfg().Opts.Thresholds); err != nil {
+				return
+			}
+		*/
 	} else if thdS, err = utils.IfaceAsBool(v); err != nil {
 		return
 	}
@@ -2558,10 +2602,12 @@ func (sS *SessionS) BiRPCv1ProcessEvent(ctx *context.Context,
 	// process stats if required
 	var stS bool
 	if v, has := args.APIOpts[utils.OptsStatS]; !has {
-		if stS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.AsDataProvider(), sS.filterS,
-			sS.cgrCfg.CdrsCfg().Opts.Stats); err != nil {
-			return
-		}
+		/*
+			if stS, err = engine.FilterBoolCfgOpts(ctx, args.Tenant, args.AsDataProvider(), sS.filterS,
+				sS.cgrCfg.CdrsCfg().Opts.Stats); err != nil {
+				return
+			}
+		*/
 	} else if stS, err = utils.IfaceAsBool(v); err != nil {
 		return
 	}