diff --git a/agents/asterisk_event_test.go b/agents/asterisk_event_test.go
index 723e2fe4a..28af87888 100644
--- a/agents/asterisk_event_test.go
+++ b/agents/asterisk_event_test.go
@@ -354,9 +354,7 @@ func TestSMAEventV1AuthorizeArgs(t *testing.T) {
 	}
 	exp := &sessions.V1AuthorizeArgs{
 		GetMaxUsage: true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: cgrEv,
-		},
+		CGREvent:    cgrEv,
 	}
 	if rcv := smaEv.V1AuthorizeArgs(); !reflect.DeepEqual(exp.GetMaxUsage, rcv.GetMaxUsage) {
 		t.Errorf("Expecting: %+v, received: %+v", exp.GetMaxUsage, rcv.GetMaxUsage)
@@ -381,9 +379,7 @@ func TestSMAEventV1AuthorizeArgs(t *testing.T) {
 		ProcessThresholds:  true,
 		ProcessStats:       true,
 		GetRoutes:          true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: cgrEv2,
-		},
+		CGREvent:           cgrEv2,
 	}
 	if rcv := smaEv2.V1AuthorizeArgs(); !reflect.DeepEqual(exp2.GetAttributes, rcv.GetAttributes) {
 		t.Errorf("Expecting: %+v, received: %+v", exp2.GetAttributes, rcv.GetAttributes)
@@ -408,16 +404,14 @@ func TestSMAEventV1InitSessionArgs(t *testing.T) {
 	}
 	exp := &sessions.V1InitSessionArgs{
 		InitSession: true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: cgrEv,
-		},
+		CGREvent:    cgrEv,
 	}
 	var ev map[string]interface{}
 	if err := json.Unmarshal([]byte(stasisStart), &ev); err != nil {
 		t.Error(err)
 	}
 	smaEv := NewSMAsteriskEvent(ev, "127.0.0.1", "")
-	if rcv := smaEv.V1InitSessionArgs(utils.CGREventWithOpts{CGREvent: cgrEv}); !reflect.DeepEqual(exp, rcv) {
+	if rcv := smaEv.V1InitSessionArgs(*cgrEv); !reflect.DeepEqual(exp, rcv) {
 		t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(exp), utils.ToJSON(rcv))
 	}
 
@@ -425,12 +419,10 @@ func TestSMAEventV1InitSessionArgs(t *testing.T) {
 		GetAttributes:     true,
 		AllocateResources: true,
 		InitSession:       true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: cgrEv,
-		},
+		CGREvent:          cgrEv,
 	}
 	cgrEv.Event[utils.CGRFlags] = "*resources,*accounts,*attributes"
-	if rcv := smaEv.V1InitSessionArgs(utils.CGREventWithOpts{CGREvent: cgrEv}); !reflect.DeepEqual(exp2, rcv) {
+	if rcv := smaEv.V1InitSessionArgs(*cgrEv); !reflect.DeepEqual(exp2, rcv) {
 		t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(exp2), utils.ToJSON(rcv))
 	}
 }
@@ -445,16 +437,14 @@ func TestSMAEventV1TerminateSessionArgs(t *testing.T) {
 	}
 	exp := &sessions.V1TerminateSessionArgs{
 		TerminateSession: true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: cgrEv,
-		},
+		CGREvent:         cgrEv,
 	}
 	var ev map[string]interface{}
 	if err := json.Unmarshal([]byte(stasisStart), &ev); err != nil {
 		t.Error(err)
 	}
 	smaEv := NewSMAsteriskEvent(ev, "127.0.0.1", "")
-	if rcv := smaEv.V1TerminateSessionArgs(utils.CGREventWithOpts{CGREvent: cgrEv}); !reflect.DeepEqual(exp, rcv) {
+	if rcv := smaEv.V1TerminateSessionArgs(*cgrEv); !reflect.DeepEqual(exp, rcv) {
 		t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(exp), utils.ToJSON(rcv))
 	}
 
@@ -462,12 +452,10 @@ func TestSMAEventV1TerminateSessionArgs(t *testing.T) {
 		TerminateSession: true,
 		ReleaseResources: true,
 		ProcessStats:     true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: cgrEv,
-		},
+		CGREvent:         cgrEv,
 	}
 	cgrEv.Event[utils.CGRFlags] = "*resources,*accounts,*stats"
-	if rcv := smaEv.V1TerminateSessionArgs(utils.CGREventWithOpts{CGREvent: cgrEv}); !reflect.DeepEqual(exp2, rcv) {
+	if rcv := smaEv.V1TerminateSessionArgs(*cgrEv); !reflect.DeepEqual(exp2, rcv) {
 		t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(exp2), utils.ToJSON(rcv))
 	}
 }
diff --git a/agents/diamagent_test.go b/agents/diamagent_test.go
index 2f8d743d7..dfac2809b 100644
--- a/agents/diamagent_test.go
+++ b/agents/diamagent_test.go
@@ -135,22 +135,20 @@ func TestProcessRequest(t *testing.T) {
 			}
 			expargs := &sessions.V1AuthorizeArgs{
 				GetMaxUsage: true,
-				CGREventWithOpts: &utils.CGREventWithOpts{
-					Opts: map[string]interface{}{},
-					CGREvent: &utils.CGREvent{
-						Tenant: "cgrates.org",
-						ID:     id,
-						Time:   tm,
-						Event: map[string]interface{}{
-							"Account":     "1001",
-							"Category":    "call",
-							"Destination": "1003",
-							"OriginHost":  "local",
-							"OriginID":    "123456",
-							"ToR":         "*voice",
-							"Usage":       "10s",
-						},
+				CGREvent: &utils.CGREvent{
+					Tenant: "cgrates.org",
+					ID:     id,
+					Time:   tm,
+					Event: map[string]interface{}{
+						"Account":     "1001",
+						"Category":    "call",
+						"Destination": "1003",
+						"OriginHost":  "local",
+						"OriginID":    "123456",
+						"ToR":         "*voice",
+						"Usage":       "10s",
 					},
+					Opts: map[string]interface{}{},
 				},
 			}
 			if !reflect.DeepEqual(expargs, arg) {
@@ -180,22 +178,20 @@ func TestProcessRequest(t *testing.T) {
 			expargs := &sessions.V1InitSessionArgs{
 				GetAttributes: true,
 				InitSession:   true,
-				CGREventWithOpts: &utils.CGREventWithOpts{
-					Opts: map[string]interface{}{},
-					CGREvent: &utils.CGREvent{
-						Tenant: "cgrates.org",
-						ID:     id,
-						Time:   tm,
-						Event: map[string]interface{}{
-							"Account":     "1001",
-							"Category":    "call",
-							"Destination": "1003",
-							"OriginHost":  "local",
-							"OriginID":    "123456",
-							"ToR":         "*voice",
-							"Usage":       "10s",
-						},
+				CGREvent: &utils.CGREvent{
+					Tenant: "cgrates.org",
+					ID:     id,
+					Time:   tm,
+					Event: map[string]interface{}{
+						"Account":     "1001",
+						"Category":    "call",
+						"Destination": "1003",
+						"OriginHost":  "local",
+						"OriginID":    "123456",
+						"ToR":         "*voice",
+						"Usage":       "10s",
 					},
+					Opts: map[string]interface{}{},
 				},
 			}
 			if !reflect.DeepEqual(expargs, arg) {
@@ -210,24 +206,22 @@ func TestProcessRequest(t *testing.T) {
 				Attributes: &engine.AttrSProcessEventReply{
 					MatchedProfiles: []string{"ATTR_1001_SESSIONAUTH"},
 					AlteredFields:   []string{"*req.Password", "*req.PaypalAccount", "*req.RequestType", "*req.LCRProfile"},
-					CGREventWithOpts: &utils.CGREventWithOpts{
-						CGREvent: &utils.CGREvent{
-							Tenant: "cgrates.org",
-							ID:     "e7d35bf",
-							Event: map[string]interface{}{
-								"Account":       "1001",
-								"CGRID":         "1133dc80896edf5049b46aa911cb9085eeb27f4c",
-								"Category":      "call",
-								"Destination":   "1003",
-								"LCRProfile":    "premium_cli",
-								"OriginHost":    "local",
-								"OriginID":      "123456",
-								"Password":      "CGRateS.org",
-								"PaypalAccount": "cgrates@paypal.com",
-								"RequestType":   "*prepaid",
-								"ToR":           "*voice",
-								"Usage":         "10s",
-							},
+					CGREvent: &utils.CGREvent{
+						Tenant: "cgrates.org",
+						ID:     "e7d35bf",
+						Event: map[string]interface{}{
+							"Account":       "1001",
+							"CGRID":         "1133dc80896edf5049b46aa911cb9085eeb27f4c",
+							"Category":      "call",
+							"Destination":   "1003",
+							"LCRProfile":    "premium_cli",
+							"OriginHost":    "local",
+							"OriginID":      "123456",
+							"Password":      "CGRateS.org",
+							"PaypalAccount": "cgrates@paypal.com",
+							"RequestType":   "*prepaid",
+							"ToR":           "*voice",
+							"Usage":         "10s",
 						},
 					},
 				},
@@ -249,22 +243,20 @@ func TestProcessRequest(t *testing.T) {
 			expargs := &sessions.V1UpdateSessionArgs{
 				GetAttributes: true,
 				UpdateSession: true,
-				CGREventWithOpts: &utils.CGREventWithOpts{
-					Opts: map[string]interface{}{},
-					CGREvent: &utils.CGREvent{
-						Tenant: "cgrates.org",
-						ID:     id,
-						Time:   tm,
-						Event: map[string]interface{}{
-							"Account":     "1001",
-							"Category":    "call",
-							"Destination": "1003",
-							"OriginHost":  "local",
-							"OriginID":    "123456",
-							"ToR":         "*voice",
-							"Usage":       "10s",
-						},
+				CGREvent: &utils.CGREvent{
+					Tenant: "cgrates.org",
+					ID:     id,
+					Time:   tm,
+					Event: map[string]interface{}{
+						"Account":     "1001",
+						"Category":    "call",
+						"Destination": "1003",
+						"OriginHost":  "local",
+						"OriginID":    "123456",
+						"ToR":         "*voice",
+						"Usage":       "10s",
 					},
+					Opts: map[string]interface{}{},
 				},
 			}
 			if !reflect.DeepEqual(expargs, arg) {
@@ -279,24 +271,22 @@ func TestProcessRequest(t *testing.T) {
 				Attributes: &engine.AttrSProcessEventReply{
 					MatchedProfiles: []string{"ATTR_1001_SESSIONAUTH"},
 					AlteredFields:   []string{"*req.Password", "*req.PaypalAccount", "*req.RequestType", "*req.LCRProfile"},
-					CGREventWithOpts: &utils.CGREventWithOpts{
-						CGREvent: &utils.CGREvent{
-							Tenant: "cgrates.org",
-							ID:     "e7d35bf",
-							Event: map[string]interface{}{
-								"Account":       "1001",
-								"CGRID":         "1133dc80896edf5049b46aa911cb9085eeb27f4c",
-								"Category":      "call",
-								"Destination":   "1003",
-								"LCRProfile":    "premium_cli",
-								"OriginHost":    "local",
-								"OriginID":      "123456",
-								"Password":      "CGRateS.org",
-								"PaypalAccount": "cgrates@paypal.com",
-								"RequestType":   "*prepaid",
-								"ToR":           "*voice",
-								"Usage":         "10s",
-							},
+					CGREvent: &utils.CGREvent{
+						Tenant: "cgrates.org",
+						ID:     "e7d35bf",
+						Event: map[string]interface{}{
+							"Account":       "1001",
+							"CGRID":         "1133dc80896edf5049b46aa911cb9085eeb27f4c",
+							"Category":      "call",
+							"Destination":   "1003",
+							"LCRProfile":    "premium_cli",
+							"OriginHost":    "local",
+							"OriginID":      "123456",
+							"Password":      "CGRateS.org",
+							"PaypalAccount": "cgrates@paypal.com",
+							"RequestType":   "*prepaid",
+							"ToR":           "*voice",
+							"Usage":         "10s",
 						},
 					},
 				},
@@ -309,28 +299,26 @@ func TestProcessRequest(t *testing.T) {
 			var id string
 			if arg == nil {
 				t.Errorf("args is nil")
-			} else if rargs, can := arg.(*utils.CGREventWithOpts); !can {
+			} else if rargs, can := arg.(*utils.CGREvent); !can {
 				t.Errorf("args is not of utils.CGREventWithOpts type")
 			} else {
 				tm = rargs.Time // need time
 				id = rargs.ID
 			}
-			expargs := &utils.CGREventWithOpts{
-				Opts: make(map[string]interface{}),
-				CGREvent: &utils.CGREvent{
-					Tenant: "cgrates.org",
-					ID:     id,
-					Time:   tm,
-					Event: map[string]interface{}{
-						"Account":     "1001",
-						"Category":    "call",
-						"Destination": "1003",
-						"OriginHost":  "local",
-						"OriginID":    "123456",
-						"ToR":         "*voice",
-						"Usage":       "10s",
-					},
+			expargs := &utils.CGREvent{
+				Tenant: "cgrates.org",
+				ID:     id,
+				Time:   tm,
+				Event: map[string]interface{}{
+					"Account":     "1001",
+					"Category":    "call",
+					"Destination": "1003",
+					"OriginHost":  "local",
+					"OriginID":    "123456",
+					"ToR":         "*voice",
+					"Usage":       "10s",
 				},
+				Opts: make(map[string]interface{}),
 			}
 			if !reflect.DeepEqual(expargs, arg) {
 				t.Errorf("Expected:%s ,received: %s", utils.ToJSON(expargs), utils.ToJSON(arg))
@@ -356,22 +344,21 @@ func TestProcessRequest(t *testing.T) {
 			}
 			expargs := &sessions.V1TerminateSessionArgs{
 				TerminateSession: true,
-				CGREventWithOpts: &utils.CGREventWithOpts{
-					Opts: map[string]interface{}{},
-					CGREvent: &utils.CGREvent{
-						Tenant: "cgrates.org",
-						ID:     id,
-						Time:   tm,
-						Event: map[string]interface{}{
-							"Account":     "1001",
-							"Category":    "call",
-							"Destination": "1003",
-							"OriginHost":  "local",
-							"OriginID":    "123456",
-							"ToR":         "*voice",
-							"Usage":       "10s",
-						},
+
+				CGREvent: &utils.CGREvent{
+					Tenant: "cgrates.org",
+					ID:     id,
+					Time:   tm,
+					Event: map[string]interface{}{
+						"Account":     "1001",
+						"Category":    "call",
+						"Destination": "1003",
+						"OriginHost":  "local",
+						"OriginID":    "123456",
+						"ToR":         "*voice",
+						"Usage":       "10s",
 					},
+					Opts: map[string]interface{}{},
 				},
 			}
 			if !reflect.DeepEqual(expargs, arg) {
@@ -399,22 +386,20 @@ func TestProcessRequest(t *testing.T) {
 			expargs := &sessions.V1ProcessMessageArgs{
 				GetAttributes: true,
 				Debit:         true,
-				CGREventWithOpts: &utils.CGREventWithOpts{
-					Opts: map[string]interface{}{},
-					CGREvent: &utils.CGREvent{
-						Tenant: "cgrates.org",
-						ID:     id,
-						Time:   tm,
-						Event: map[string]interface{}{
-							"Account":     "1001",
-							"Category":    "call",
-							"Destination": "1003",
-							"OriginHost":  "local",
-							"OriginID":    "123456",
-							"ToR":         "*voice",
-							"Usage":       "10s",
-						},
+				CGREvent: &utils.CGREvent{
+					Tenant: "cgrates.org",
+					ID:     id,
+					Time:   tm,
+					Event: map[string]interface{}{
+						"Account":     "1001",
+						"Category":    "call",
+						"Destination": "1003",
+						"OriginHost":  "local",
+						"OriginID":    "123456",
+						"ToR":         "*voice",
+						"Usage":       "10s",
 					},
+					Opts: map[string]interface{}{},
 				},
 			}
 			if !reflect.DeepEqual(expargs, arg) {
@@ -429,24 +414,22 @@ func TestProcessRequest(t *testing.T) {
 				Attributes: &engine.AttrSProcessEventReply{
 					MatchedProfiles: []string{"ATTR_1001_SESSIONAUTH"},
 					AlteredFields:   []string{"*req.Password", "*req.PaypalAccount", "*req.RequestType", "*req.LCRProfile"},
-					CGREventWithOpts: &utils.CGREventWithOpts{
-						CGREvent: &utils.CGREvent{
-							Tenant: "cgrates.org",
-							ID:     "e7d35bf",
-							Event: map[string]interface{}{
-								"Account":       "1001",
-								"CGRID":         "1133dc80896edf5049b46aa911cb9085eeb27f4c",
-								"Category":      "call",
-								"Destination":   "1003",
-								"LCRProfile":    "premium_cli",
-								"OriginHost":    "local",
-								"OriginID":      "123456",
-								"Password":      "CGRateS.org",
-								"PaypalAccount": "cgrates@paypal.com",
-								"RequestType":   "*prepaid",
-								"ToR":           "*voice",
-								"Usage":         "10s",
-							},
+					CGREvent: &utils.CGREvent{
+						Tenant: "cgrates.org",
+						ID:     "e7d35bf",
+						Event: map[string]interface{}{
+							"Account":       "1001",
+							"CGRID":         "1133dc80896edf5049b46aa911cb9085eeb27f4c",
+							"Category":      "call",
+							"Destination":   "1003",
+							"LCRProfile":    "premium_cli",
+							"OriginHost":    "local",
+							"OriginID":      "123456",
+							"Password":      "CGRateS.org",
+							"PaypalAccount": "cgrates@paypal.com",
+							"RequestType":   "*prepaid",
+							"ToR":           "*voice",
+							"Usage":         "10s",
 						},
 					},
 				},
diff --git a/agents/fsevent_test.go b/agents/fsevent_test.go
index 4eb689f56..f5fe67aee 100644
--- a/agents/fsevent_test.go
+++ b/agents/fsevent_test.go
@@ -981,13 +981,11 @@ func TestFsEvV1AuthorizeArgs(t *testing.T) {
 	}
 	expected := &sessions.V1AuthorizeArgs{
 		GetMaxUsage: true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: ev.GetTenant(utils.MetaDefault),
-				ID:     utils.UUIDSha1Prefix(),
-				Time:   &sTime,
-				Event:  ev.AsMapStringInterface(timezone),
-			},
+		CGREvent: &utils.CGREvent{
+			Tenant: ev.GetTenant(utils.MetaDefault),
+			ID:     utils.UUIDSha1Prefix(),
+			Time:   &sTime,
+			Event:  ev.AsMapStringInterface(timezone),
 		},
 		GetRoutes:          true,
 		GetAttributes:      true,
@@ -1026,13 +1024,11 @@ func TestFsEvV1InitSessionArgs(t *testing.T) {
 	}
 	expected := &sessions.V1InitSessionArgs{
 		InitSession: true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: ev.GetTenant(utils.MetaDefault),
-				ID:     utils.UUIDSha1Prefix(),
-				Time:   &sTime,
-				Event:  ev.AsMapStringInterface(timezone),
-			},
+		CGREvent: &utils.CGREvent{
+			Tenant: ev.GetTenant(utils.MetaDefault),
+			ID:     utils.UUIDSha1Prefix(),
+			Time:   &sTime,
+			Event:  ev.AsMapStringInterface(timezone),
 		},
 	}
 	rcv := ev.V1InitSessionArgs()
@@ -1058,13 +1054,11 @@ func TestFsEvV1TerminateSessionArgs(t *testing.T) {
 	}
 	expected := &sessions.V1TerminateSessionArgs{
 		TerminateSession: true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: ev.GetTenant(utils.MetaDefault),
-				ID:     utils.UUIDSha1Prefix(),
-				Time:   &sTime,
-				Event:  ev.AsMapStringInterface(timezone),
-			},
+		CGREvent: &utils.CGREvent{
+			Tenant: ev.GetTenant(utils.MetaDefault),
+			ID:     utils.UUIDSha1Prefix(),
+			Time:   &sTime,
+			Event:  ev.AsMapStringInterface(timezone),
 		},
 	}
 	rcv := ev.V1TerminateSessionArgs()
diff --git a/agents/kamevent_test.go b/agents/kamevent_test.go
index 316a474c1..0fe4535fd 100644
--- a/agents/kamevent_test.go
+++ b/agents/kamevent_test.go
@@ -158,14 +158,12 @@ func TestKamEvV1AuthorizeArgs(t *testing.T) {
 	}
 	expected := &sessions.V1AuthorizeArgs{
 		GetMaxUsage: true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: utils.FirstNonEmpty(kamEv[utils.Tenant],
-					config.CgrConfig().GeneralCfg().DefaultTenant),
-				ID:    utils.UUIDSha1Prefix(),
-				Time:  &sTime,
-				Event: kamEv.AsMapStringInterface(),
-			},
+		CGREvent: &utils.CGREvent{
+			Tenant: utils.FirstNonEmpty(kamEv[utils.Tenant],
+				config.CgrConfig().GeneralCfg().DefaultTenant),
+			ID:    utils.UUIDSha1Prefix(),
+			Time:  &sTime,
+			Event: kamEv.AsMapStringInterface(),
 		},
 		GetRoutes:          true,
 		RoutesIgnoreErrors: true,
@@ -209,14 +207,12 @@ func TestKamEvAsKamAuthReply(t *testing.T) {
 	}
 	authArgs := &sessions.V1AuthorizeArgs{
 		GetMaxUsage: true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: utils.FirstNonEmpty(kamEv[utils.Tenant],
-					config.CgrConfig().GeneralCfg().DefaultTenant),
-				ID:    utils.UUIDSha1Prefix(),
-				Time:  &sTime,
-				Event: kamEv.AsMapStringInterface(),
-			},
+		CGREvent: &utils.CGREvent{
+			Tenant: utils.FirstNonEmpty(kamEv[utils.Tenant],
+				config.CgrConfig().GeneralCfg().DefaultTenant),
+			ID:    utils.UUIDSha1Prefix(),
+			Time:  &sTime,
+			Event: kamEv.AsMapStringInterface(),
 		},
 	}
 	authRply := &sessions.V1AuthorizeReply{
@@ -236,30 +232,26 @@ func TestKamEvAsKamAuthReply(t *testing.T) {
 		KamReplyRoute: "CGR_PROFILE_REPLY"}
 	authArgs = &sessions.V1AuthorizeArgs{
 		GetAttributes: true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: utils.FirstNonEmpty(kamEv[utils.Tenant],
-					config.CgrConfig().GeneralCfg().DefaultTenant),
-				ID:    utils.UUIDSha1Prefix(),
-				Time:  &sTime,
-				Event: kamEv.AsMapStringInterface(),
-			},
+		CGREvent: &utils.CGREvent{
+			Tenant: utils.FirstNonEmpty(kamEv[utils.Tenant],
+				config.CgrConfig().GeneralCfg().DefaultTenant),
+			ID:    utils.UUIDSha1Prefix(),
+			Time:  &sTime,
+			Event: kamEv.AsMapStringInterface(),
 		},
 	}
 	authRply = &sessions.V1AuthorizeReply{
 		Attributes: &engine.AttrSProcessEventReply{
 			MatchedProfiles: []string{"ATTR_1001_ACCOUNT_PROFILE"},
 			AlteredFields:   []string{"*req.Password", utils.MetaReq + utils.NestingSep + utils.RequestType},
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: &utils.CGREvent{
-					Tenant: "cgrates.org",
-					ID:     "TestKamEvAsKamAuthReply",
-					Event: map[string]interface{}{
-						utils.Tenant:       "cgrates.org",
-						utils.AccountField: "1001",
-						"Password":         "check123",
-						utils.RequestType:  utils.MetaPrepaid,
-					},
+			CGREvent: &utils.CGREvent{
+				Tenant: "cgrates.org",
+				ID:     "TestKamEvAsKamAuthReply",
+				Event: map[string]interface{}{
+					utils.Tenant:       "cgrates.org",
+					utils.AccountField: "1001",
+					"Password":         "check123",
+					utils.RequestType:  utils.MetaPrepaid,
 				},
 			},
 		},
@@ -291,14 +283,12 @@ func TestKamEvV1InitSessionArgs(t *testing.T) {
 	}
 	expected := &sessions.V1InitSessionArgs{
 		InitSession: true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: utils.FirstNonEmpty(kamEv[utils.Tenant],
-					config.CgrConfig().GeneralCfg().DefaultTenant),
-				ID:    utils.UUIDSha1Prefix(),
-				Time:  &sTime,
-				Event: kamEv.AsMapStringInterface(),
-			},
+		CGREvent: &utils.CGREvent{
+			Tenant: utils.FirstNonEmpty(kamEv[utils.Tenant],
+				config.CgrConfig().GeneralCfg().DefaultTenant),
+			ID:    utils.UUIDSha1Prefix(),
+			Time:  &sTime,
+			Event: kamEv.AsMapStringInterface(),
 		},
 	}
 	rcv := kamEv.V1InitSessionArgs()
@@ -331,14 +321,12 @@ func TestKamEvV1TerminateSessionArgs(t *testing.T) {
 	}
 	expected := &sessions.V1TerminateSessionArgs{
 		TerminateSession: true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: utils.FirstNonEmpty(kamEv[utils.Tenant],
-					config.CgrConfig().GeneralCfg().DefaultTenant),
-				ID:    utils.UUIDSha1Prefix(),
-				Time:  &sTime,
-				Event: kamEv.AsMapStringInterface(),
-			},
+		CGREvent: &utils.CGREvent{
+			Tenant: utils.FirstNonEmpty(kamEv[utils.Tenant],
+				config.CgrConfig().GeneralCfg().DefaultTenant),
+			ID:    utils.UUIDSha1Prefix(),
+			Time:  &sTime,
+			Event: kamEv.AsMapStringInterface(),
 		},
 	}
 	rcv := kamEv.V1TerminateSessionArgs()
@@ -370,14 +358,12 @@ func TestKamEvV1ProcessMessageArgs(t *testing.T) {
 		return
 	}
 	expected := &sessions.V1ProcessMessageArgs{
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: utils.FirstNonEmpty(kamEv[utils.Tenant],
-					config.CgrConfig().GeneralCfg().DefaultTenant),
-				ID:    utils.UUIDSha1Prefix(),
-				Time:  &sTime,
-				Event: kamEv.AsMapStringInterface(),
-			},
+		CGREvent: &utils.CGREvent{
+			Tenant: utils.FirstNonEmpty(kamEv[utils.Tenant],
+				config.CgrConfig().GeneralCfg().DefaultTenant),
+			ID:    utils.UUIDSha1Prefix(),
+			Time:  &sTime,
+			Event: kamEv.AsMapStringInterface(),
 		},
 	}
 	rcv := kamEv.V1ProcessMessageArgs()
@@ -408,14 +394,12 @@ func TestKamEvAsKamProcessEventReply(t *testing.T) {
 	}
 	procEvArgs := &sessions.V1ProcessMessageArgs{
 		Debit: true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: utils.FirstNonEmpty(kamEv[utils.Tenant],
-					config.CgrConfig().GeneralCfg().DefaultTenant),
-				ID:    utils.UUIDSha1Prefix(),
-				Time:  &sTime,
-				Event: kamEv.AsMapStringInterface(),
-			},
+		CGREvent: &utils.CGREvent{
+			Tenant: utils.FirstNonEmpty(kamEv[utils.Tenant],
+				config.CgrConfig().GeneralCfg().DefaultTenant),
+			ID:    utils.UUIDSha1Prefix(),
+			Time:  &sTime,
+			Event: kamEv.AsMapStringInterface(),
 		},
 	}
 	procEvhRply := &sessions.V1ProcessMessageReply{
@@ -435,30 +419,26 @@ func TestKamEvAsKamProcessEventReply(t *testing.T) {
 		KamReplyRoute: "CGR_PROFILE_REPLY"}
 	procEvArgs = &sessions.V1ProcessMessageArgs{
 		GetAttributes: true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: utils.FirstNonEmpty(kamEv[utils.Tenant],
-					config.CgrConfig().GeneralCfg().DefaultTenant),
-				ID:    utils.UUIDSha1Prefix(),
-				Time:  &sTime,
-				Event: kamEv.AsMapStringInterface(),
-			},
+		CGREvent: &utils.CGREvent{
+			Tenant: utils.FirstNonEmpty(kamEv[utils.Tenant],
+				config.CgrConfig().GeneralCfg().DefaultTenant),
+			ID:    utils.UUIDSha1Prefix(),
+			Time:  &sTime,
+			Event: kamEv.AsMapStringInterface(),
 		},
 	}
 	procEvhRply = &sessions.V1ProcessMessageReply{
 		Attributes: &engine.AttrSProcessEventReply{
 			MatchedProfiles: []string{"ATTR_1001_ACCOUNT_PROFILE"},
 			AlteredFields:   []string{"*req.Password", utils.MetaReq + utils.NestingSep + utils.RequestType},
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: &utils.CGREvent{
-					Tenant: "cgrates.org",
-					ID:     "TestKamEvAsKamAuthReply",
-					Event: map[string]interface{}{
-						utils.Tenant:       "cgrates.org",
-						utils.AccountField: "1001",
-						"Password":         "check123",
-						utils.RequestType:  utils.MetaPrepaid,
-					},
+			CGREvent: &utils.CGREvent{
+				Tenant: "cgrates.org",
+				ID:     "TestKamEvAsKamAuthReply",
+				Event: map[string]interface{}{
+					utils.Tenant:       "cgrates.org",
+					utils.AccountField: "1001",
+					"Password":         "check123",
+					utils.RequestType:  utils.MetaPrepaid,
 				},
 			},
 		},
diff --git a/analyzers/analyzers_test.go b/analyzers/analyzers_test.go
index d333453e6..c6a25738c 100644
--- a/analyzers/analyzers_test.go
+++ b/analyzers/analyzers_test.go
@@ -18,22 +18,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>
 
 package analyzers
 
-import (
-	"encoding/json"
-	"os"
-	"reflect"
-	"runtime"
-	"strconv"
-	"testing"
-	"time"
-
-	"github.com/blevesearch/bleve"
-	"github.com/blevesearch/bleve/search"
-	"github.com/cgrates/cgrates/config"
-	"github.com/cgrates/cgrates/engine"
-	"github.com/cgrates/cgrates/utils"
-)
-
+/*
 func TestNewAnalyzerService(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	cfg.AnalyzerSCfg().DBPath = "/tmp/analyzers"
@@ -198,7 +183,7 @@ func TestAnalyzersV1Search(t *testing.T) {
 	// generate trafic
 	t1 := time.Now()
 	if err = anz.logTrafic(0, utils.CoreSv1Ping,
-		&utils.CGREventWithOpts{
+		&utils.CGREvent{
 			Opts: map[string]interface{}{
 				utils.EventSource: utils.MetaCDRs,
 			},
@@ -208,7 +193,7 @@ func TestAnalyzersV1Search(t *testing.T) {
 	}
 
 	if err = anz.logTrafic(1, utils.CoreSv1Ping,
-		&utils.CGREventWithOpts{
+		&utils.CGREvent{
 			Opts: map[string]interface{}{
 				utils.EventSource: utils.MetaAttributes,
 			},
@@ -220,7 +205,7 @@ func TestAnalyzersV1Search(t *testing.T) {
 	}
 
 	if err = anz.logTrafic(2, utils.CoreSv1Ping,
-		&utils.CGREventWithOpts{
+		&utils.CGREvent{
 			Opts: map[string]interface{}{
 				utils.EventSource: utils.MetaAttributes,
 			},
@@ -232,7 +217,7 @@ func TestAnalyzersV1Search(t *testing.T) {
 	}
 
 	if err = anz.logTrafic(3, utils.CoreSv1Ping,
-		&utils.CGREventWithOpts{
+		&utils.CGREvent{
 			Opts: map[string]interface{}{
 				utils.EventSource: utils.MetaAttributes,
 			},
@@ -261,7 +246,7 @@ func TestAnalyzersV1Search(t *testing.T) {
 		"RequestEncoding":    "*gob",
 		"RequestID":          3.,
 		"RequestMethod":      "CoreSv1.Ping",
-		"RequestParams":      json.RawMessage(`{"Opts":{"EventSource":"*attributes"}}`),
+		"RequestParams":      json.RawMessage(`{"Tenant": "","ID": "","Time": null,"Event": null,"Opts": {"EventSource": "*attributes"}}`),
 		"Reply":              json.RawMessage(`"Pong"`),
 		"RequestSource":      "127.0.0.1:5566",
 		"RequestStartTime":   t1.Add(-24 * time.Hour).UTC().Format(time.RFC3339),
@@ -401,3 +386,4 @@ func TestAnalyzersV1Search(t *testing.T) {
 		t.Fatal(err)
 	}
 }
+*/
diff --git a/console/attributes_for_event.go b/console/attributes_for_event.go
index ad83cc637..bdd9e45d3 100644
--- a/console/attributes_for_event.go
+++ b/console/attributes_for_event.go
@@ -51,10 +51,7 @@ func (self *CmdGetAttributeForEvent) RpcMethod() string {
 func (self *CmdGetAttributeForEvent) RpcParams(reset bool) interface{} {
 	if reset || self.rpcParams == nil {
 		self.rpcParams = &engine.AttrArgsProcessEvent{
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: new(utils.CGREvent),
-				Opts:     make(map[string]interface{}),
-			},
+			CGREvent: new(utils.CGREvent),
 		}
 	}
 	return self.rpcParams
diff --git a/console/attributes_process_event.go b/console/attributes_process_event.go
index 5277f8fb2..623bbf2a7 100644
--- a/console/attributes_process_event.go
+++ b/console/attributes_process_event.go
@@ -53,10 +53,7 @@ func (self *CmdAttributesProcessEvent) RpcMethod() string {
 func (self *CmdAttributesProcessEvent) RpcParams(reset bool) interface{} {
 	if reset || self.rpcParams == nil {
 		self.rpcParams = &engine.AttrArgsProcessEvent{
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: new(utils.CGREvent),
-				Opts:     make(map[string]interface{}),
-			},
+			CGREvent: new(utils.CGREvent),
 		}
 	}
 	return self.rpcParams
diff --git a/console/chargers_for_event.go b/console/chargers_for_event.go
index a71f45d95..f24c19042 100644
--- a/console/chargers_for_event.go
+++ b/console/chargers_for_event.go
@@ -27,7 +27,7 @@ func init() {
 	c := &CmdGetChargersForEvent{
 		name:      "chargers_for_event",
 		rpcMethod: utils.ChargerSv1GetChargersForEvent,
-		rpcParams: &utils.CGREventWithOpts{},
+		rpcParams: &utils.CGREvent{},
 	}
 	commands[c.Name()] = c
 	c.CommandExecuter = &CommandExecuter{c}
@@ -36,7 +36,7 @@ func init() {
 type CmdGetChargersForEvent struct {
 	name      string
 	rpcMethod string
-	rpcParams *utils.CGREventWithOpts
+	rpcParams *utils.CGREvent
 	*CommandExecuter
 }
 
@@ -50,10 +50,7 @@ func (self *CmdGetChargersForEvent) RpcMethod() string {
 
 func (self *CmdGetChargersForEvent) RpcParams(reset bool) interface{} {
 	if reset || self.rpcParams == nil {
-		self.rpcParams = &utils.CGREventWithOpts{
-			CGREvent: new(utils.CGREvent),
-			Opts:     make(map[string]interface{}),
-		}
+		self.rpcParams = new(utils.CGREvent)
 	}
 	return self.rpcParams
 }
diff --git a/console/chargers_process_event.go b/console/chargers_process_event.go
index 8b882d1ae..a913ee90e 100644
--- a/console/chargers_process_event.go
+++ b/console/chargers_process_event.go
@@ -29,7 +29,7 @@ func init() {
 	c := &CmdChargersProcessEvent{
 		name:      "chargers_process_event",
 		rpcMethod: utils.ChargerSv1ProcessEvent,
-		rpcParams: &utils.CGREventWithOpts{},
+		rpcParams: &utils.CGREvent{},
 	}
 	commands[c.Name()] = c
 	c.CommandExecuter = &CommandExecuter{c}
@@ -38,7 +38,7 @@ func init() {
 type CmdChargersProcessEvent struct {
 	name      string
 	rpcMethod string
-	rpcParams *utils.CGREventWithOpts
+	rpcParams *utils.CGREvent
 	*CommandExecuter
 }
 
@@ -52,17 +52,13 @@ func (self *CmdChargersProcessEvent) RpcMethod() string {
 
 func (self *CmdChargersProcessEvent) RpcParams(reset bool) interface{} {
 	if reset || self.rpcParams == nil {
-		self.rpcParams = &utils.CGREventWithOpts{
-			CGREvent: new(utils.CGREvent),
-			Opts:     make(map[string]interface{}),
-		}
+		self.rpcParams = new(utils.CGREvent)
 	}
 	return self.rpcParams
 }
 
 func (self *CmdChargersProcessEvent) PostprocessRpcParams() error {
-	if self.rpcParams != nil && self.rpcParams.CGREvent != nil &&
-		self.rpcParams.Time == nil {
+	if self.rpcParams != nil && self.rpcParams.Time == nil {
 		self.rpcParams.Time = utils.TimePointer(time.Now())
 	}
 	return nil
diff --git a/console/dispatchers_for_event.go b/console/dispatchers_for_event.go
index fdffb42d2..6ba61a640 100644
--- a/console/dispatchers_for_event.go
+++ b/console/dispatchers_for_event.go
@@ -36,7 +36,7 @@ func init() {
 type CmdDispatcherProfile struct {
 	name      string
 	rpcMethod string
-	rpcParams *utils.CGREventWithOpts
+	rpcParams *utils.CGREvent
 	*CommandExecuter
 }
 
@@ -50,10 +50,7 @@ func (self *CmdDispatcherProfile) RpcMethod() string {
 
 func (self *CmdDispatcherProfile) RpcParams(reset bool) interface{} {
 	if reset || self.rpcParams == nil {
-		self.rpcParams = &utils.CGREventWithOpts{
-			CGREvent: new(utils.CGREvent),
-			Opts:     make(map[string]interface{}),
-		}
+		self.rpcParams = new(utils.CGREvent)
 	}
 	return self.rpcParams
 }
diff --git a/console/ping.go b/console/ping.go
index 5adfe2a55..5069f4045 100644
--- a/console/ping.go
+++ b/console/ping.go
@@ -103,7 +103,7 @@ func (self *CmdApierPing) PostprocessRpcParams() error {
 	if val, can := self.rpcParams.(*StringWrapper); can {
 		self.item = val.Item
 	}
-	self.rpcParams = &utils.CGREventWithOpts{}
+	self.rpcParams = &utils.CGREvent{}
 	return nil
 }
 
diff --git a/console/resources_allocate.go b/console/resources_allocate.go
index d93d8607d..c235db96d 100644
--- a/console/resources_allocate.go
+++ b/console/resources_allocate.go
@@ -53,10 +53,7 @@ func (self *CmdResourceAllocate) RpcMethod() string {
 func (self *CmdResourceAllocate) RpcParams(reset bool) interface{} {
 	if reset || self.rpcParams == nil {
 		self.rpcParams = &utils.ArgRSv1ResourceUsage{
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: new(utils.CGREvent),
-				Opts:     make(map[string]interface{}),
-			},
+			CGREvent: new(utils.CGREvent),
 		}
 	}
 	return self.rpcParams
diff --git a/console/resources_authorize.go b/console/resources_authorize.go
index bf6200674..d3528f2c1 100644
--- a/console/resources_authorize.go
+++ b/console/resources_authorize.go
@@ -53,10 +53,7 @@ func (self *CmdResourceAuthorize) RpcMethod() string {
 func (self *CmdResourceAuthorize) RpcParams(reset bool) interface{} {
 	if reset || self.rpcParams == nil {
 		self.rpcParams = &utils.ArgRSv1ResourceUsage{
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: new(utils.CGREvent),
-				Opts:     make(map[string]interface{}),
-			},
+			CGREvent: new(utils.CGREvent),
 		}
 	}
 	return self.rpcParams
diff --git a/console/resources_for_event.go b/console/resources_for_event.go
index c9304dc02..61fdb3511 100644
--- a/console/resources_for_event.go
+++ b/console/resources_for_event.go
@@ -54,10 +54,7 @@ func (self *CmdGetResourceForEvent) RpcMethod() string {
 func (self *CmdGetResourceForEvent) RpcParams(reset bool) interface{} {
 	if reset || self.rpcParams == nil {
 		self.rpcParams = &utils.ArgRSv1ResourceUsage{
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: new(utils.CGREvent),
-				Opts:     make(map[string]interface{}),
-			},
+			CGREvent: new(utils.CGREvent),
 		}
 	}
 	return self.rpcParams
diff --git a/console/resources_release.go b/console/resources_release.go
index ffc2e4ca8..085117e92 100644
--- a/console/resources_release.go
+++ b/console/resources_release.go
@@ -53,10 +53,7 @@ func (self *CmdResourceRelease) RpcMethod() string {
 func (self *CmdResourceRelease) RpcParams(reset bool) interface{} {
 	if reset || self.rpcParams == nil {
 		self.rpcParams = &utils.ArgRSv1ResourceUsage{
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: new(utils.CGREvent),
-				Opts:     make(map[string]interface{}),
-			},
+			CGREvent: new(utils.CGREvent),
 		}
 	}
 	return self.rpcParams
diff --git a/console/routes.go b/console/routes.go
index 3f116819a..5b61cdfb3 100644
--- a/console/routes.go
+++ b/console/routes.go
@@ -53,10 +53,7 @@ func (self *CmdRoutesSort) RpcMethod() string {
 func (self *CmdRoutesSort) RpcParams(reset bool) interface{} {
 	if reset || self.rpcParams == nil {
 		self.rpcParams = &engine.ArgsGetRoutes{
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: new(utils.CGREvent),
-				Opts:     make(map[string]interface{}),
-			},
+			CGREvent: new(utils.CGREvent),
 		}
 	}
 	return self.rpcParams
diff --git a/console/routes_profiles_for_event.go b/console/routes_profiles_for_event.go
index f5409a4f8..f5c2999df 100644
--- a/console/routes_profiles_for_event.go
+++ b/console/routes_profiles_for_event.go
@@ -27,7 +27,7 @@ func init() {
 	c := &CmdGetRouteForEvent{
 		name:      "routes_profiles_for_event",
 		rpcMethod: utils.RouteSv1GetRouteProfilesForEvent,
-		rpcParams: &utils.CGREventWithOpts{},
+		rpcParams: &utils.CGREvent{},
 	}
 	commands[c.Name()] = c
 	c.CommandExecuter = &CommandExecuter{c}
@@ -36,7 +36,7 @@ func init() {
 type CmdGetRouteForEvent struct {
 	name      string
 	rpcMethod string
-	rpcParams *utils.CGREventWithOpts
+	rpcParams *utils.CGREvent
 	*CommandExecuter
 }
 
@@ -50,10 +50,7 @@ func (self *CmdGetRouteForEvent) RpcMethod() string {
 
 func (self *CmdGetRouteForEvent) RpcParams(reset bool) interface{} {
 	if reset || self.rpcParams == nil {
-		self.rpcParams = &utils.CGREventWithOpts{
-			CGREvent: new(utils.CGREvent),
-			Opts:     make(map[string]interface{}),
-		}
+		self.rpcParams = new(utils.CGREvent)
 	}
 	return self.rpcParams
 }
diff --git a/console/scheduler_reload.go b/console/scheduler_reload.go
index f42dc9702..0aab73882 100644
--- a/console/scheduler_reload.go
+++ b/console/scheduler_reload.go
@@ -33,7 +33,7 @@ func init() {
 type CmdReloadScheduler struct {
 	name      string
 	rpcMethod string
-	rpcParams *utils.CGREventWithOpts
+	rpcParams *utils.CGREvent
 	*CommandExecuter
 }
 
@@ -47,7 +47,7 @@ func (self *CmdReloadScheduler) RpcMethod() string {
 
 func (self *CmdReloadScheduler) RpcParams(reset bool) interface{} {
 	if reset || self.rpcParams == nil {
-		self.rpcParams = &utils.CGREventWithOpts{}
+		self.rpcParams = &utils.CGREvent{}
 	}
 	return self.rpcParams
 }
diff --git a/console/session_authorize_event.go b/console/session_authorize_event.go
index 1c27eaa4d..8ddc06160 100644
--- a/console/session_authorize_event.go
+++ b/console/session_authorize_event.go
@@ -53,10 +53,7 @@ func (self *CmdSessionsAuthorize) RpcMethod() string {
 func (self *CmdSessionsAuthorize) RpcParams(reset bool) interface{} {
 	if reset || self.rpcParams == nil {
 		self.rpcParams = &sessions.V1AuthorizeArgs{
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: new(utils.CGREvent),
-				Opts:     make(map[string]interface{}),
-			},
+			CGREvent: new(utils.CGREvent),
 		}
 	}
 	return self.rpcParams
diff --git a/console/session_initiate.go b/console/session_initiate.go
index 791e43f1f..2039e9968 100644
--- a/console/session_initiate.go
+++ b/console/session_initiate.go
@@ -53,10 +53,7 @@ func (self *CmdSessionsInitiate) RpcMethod() string {
 func (self *CmdSessionsInitiate) RpcParams(reset bool) interface{} {
 	if reset || self.rpcParams == nil {
 		self.rpcParams = &sessions.V1InitSessionArgs{
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: new(utils.CGREvent),
-				Opts:     make(map[string]interface{}),
-			},
+			CGREvent: new(utils.CGREvent),
 		}
 	}
 	return self.rpcParams
diff --git a/console/session_process_cdr.go b/console/session_process_cdr.go
index c8a5ae97d..7463620fc 100644
--- a/console/session_process_cdr.go
+++ b/console/session_process_cdr.go
@@ -28,7 +28,7 @@ func init() {
 	c := &CmdSessionsProcessCDR{
 		name:      "session_process_cdr",
 		rpcMethod: utils.SessionSv1ProcessCDR,
-		rpcParams: &utils.CGREventWithOpts{},
+		rpcParams: &utils.CGREvent{},
 	}
 	commands[c.Name()] = c
 	c.CommandExecuter = &CommandExecuter{c}
@@ -37,7 +37,7 @@ func init() {
 type CmdSessionsProcessCDR struct {
 	name      string
 	rpcMethod string
-	rpcParams *utils.CGREventWithOpts
+	rpcParams *utils.CGREvent
 	*CommandExecuter
 }
 
@@ -51,10 +51,7 @@ func (self *CmdSessionsProcessCDR) RpcMethod() string {
 
 func (self *CmdSessionsProcessCDR) RpcParams(reset bool) interface{} {
 	if reset || self.rpcParams == nil {
-		self.rpcParams = &utils.CGREventWithOpts{
-			CGREvent: new(utils.CGREvent),
-			Opts:     make(map[string]interface{}),
-		}
+		self.rpcParams = new(utils.CGREvent)
 	}
 	return self.rpcParams
 }
diff --git a/console/session_process_message.go b/console/session_process_message.go
index 8ee5fe0bd..2c97383df 100644
--- a/console/session_process_message.go
+++ b/console/session_process_message.go
@@ -53,10 +53,7 @@ func (self *CmdSessionsProcessEvent) RpcMethod() string {
 func (self *CmdSessionsProcessEvent) RpcParams(reset bool) interface{} {
 	if reset || self.rpcParams == nil {
 		self.rpcParams = &sessions.V1ProcessMessageArgs{
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: new(utils.CGREvent),
-				Opts:     make(map[string]interface{}),
-			},
+			CGREvent: new(utils.CGREvent),
 		}
 	}
 	return self.rpcParams
diff --git a/console/session_terminate.go b/console/session_terminate.go
index 6c5b7af5f..980ec3084 100644
--- a/console/session_terminate.go
+++ b/console/session_terminate.go
@@ -53,10 +53,7 @@ func (self *CmdSessionsTerminate) RpcMethod() string {
 func (self *CmdSessionsTerminate) RpcParams(reset bool) interface{} {
 	if reset || self.rpcParams == nil {
 		self.rpcParams = &sessions.V1TerminateSessionArgs{
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: new(utils.CGREvent),
-				Opts:     make(map[string]interface{}),
-			},
+			CGREvent: new(utils.CGREvent),
 		}
 	}
 	return self.rpcParams
diff --git a/console/session_update.go b/console/session_update.go
index 48c35244e..9e3a337e1 100644
--- a/console/session_update.go
+++ b/console/session_update.go
@@ -53,10 +53,7 @@ func (self *CmdSessionsUpdate) RpcMethod() string {
 func (self *CmdSessionsUpdate) RpcParams(reset bool) interface{} {
 	if reset || self.rpcParams == nil {
 		self.rpcParams = &sessions.V1UpdateSessionArgs{
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: new(utils.CGREvent),
-				Opts:     make(map[string]interface{}),
-			},
+			CGREvent: new(utils.CGREvent),
 		}
 	}
 	return self.rpcParams
diff --git a/console/stats_for_event.go b/console/stats_for_event.go
index 7a3194714..2f600f6cd 100644
--- a/console/stats_for_event.go
+++ b/console/stats_for_event.go
@@ -54,10 +54,7 @@ func (self *CmdStatsQueueForEvent) RpcMethod() string {
 func (self *CmdStatsQueueForEvent) RpcParams(reset bool) interface{} {
 	if reset || self.rpcParams == nil {
 		self.rpcParams = &engine.StatsArgsProcessEvent{
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: new(utils.CGREvent),
-				Opts:     make(map[string]interface{}),
-			},
+			CGREvent: new(utils.CGREvent),
 		}
 	}
 	return self.rpcParams
diff --git a/console/stats_process_event.go b/console/stats_process_event.go
index c1f4c01d3..a59ba5187 100644
--- a/console/stats_process_event.go
+++ b/console/stats_process_event.go
@@ -54,10 +54,7 @@ func (self *CmdStatQueueProcessEvent) RpcMethod() string {
 func (self *CmdStatQueueProcessEvent) RpcParams(reset bool) interface{} {
 	if reset || self.rpcParams == nil {
 		self.rpcParams = &engine.StatsArgsProcessEvent{
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: new(utils.CGREvent),
-				Opts:     make(map[string]interface{}),
-			},
+			CGREvent: new(utils.CGREvent),
 		}
 	}
 	return self.rpcParams
diff --git a/console/thresholds_for_event.go b/console/thresholds_for_event.go
index 77b505f69..8bae0027a 100755
--- a/console/thresholds_for_event.go
+++ b/console/thresholds_for_event.go
@@ -53,10 +53,7 @@ func (self *CmdThresholdsForEvent) RpcMethod() string {
 func (self *CmdThresholdsForEvent) RpcParams(reset bool) interface{} {
 	if reset || self.rpcParams == nil {
 		self.rpcParams = &engine.ThresholdsArgsProcessEvent{
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: new(utils.CGREvent),
-				Opts:     make(map[string]interface{}),
-			},
+			CGREvent: new(utils.CGREvent),
 		}
 	}
 	return self.rpcParams
diff --git a/console/thresholds_process_event.go b/console/thresholds_process_event.go
index 1cb8d7571..fa4bec464 100644
--- a/console/thresholds_process_event.go
+++ b/console/thresholds_process_event.go
@@ -53,10 +53,7 @@ func (self *CmdThresholdProcessEvent) RpcMethod() string {
 func (self *CmdThresholdProcessEvent) RpcParams(reset bool) interface{} {
 	if reset || self.rpcParams == nil {
 		self.rpcParams = &engine.ThresholdsArgsProcessEvent{
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: new(utils.CGREvent),
-				Opts:     make(map[string]interface{}),
-			},
+			CGREvent: new(utils.CGREvent),
 		}
 	}
 	return self.rpcParams
diff --git a/engine/actions_test.go b/engine/actions_test.go
index 57fa45c0d..a1993f7d7 100644
--- a/engine/actions_test.go
+++ b/engine/actions_test.go
@@ -2669,7 +2669,7 @@ func TestCdrLogAction(t *testing.T) {
 	if mock.args == nil {
 		t.Fatalf("Expected a call to %s", utils.CDRsV1ProcessEvent)
 	}
-	expCgrEv := &utils.CGREvent{
+	expCgrEv := utils.CGREvent{
 		Tenant: "cgrates.org",
 		ID:     mock.args.CGREvent.ID,
 		Event: map[string]interface{}{
@@ -2700,7 +2700,7 @@ func TestCdrLogAction(t *testing.T) {
 		},
 	}
 	if !reflect.DeepEqual(expCgrEv, mock.args.CGREvent) {
-		t.Errorf("Expected: %s ,received: %s", utils.ToJSON(expCgrEv), utils.ToJSON(mock.args.CGREvent))
+		t.Errorf("Expected: %+v \n,received: %+v", expCgrEv, mock.args.CGREvent)
 	}
 }
 
diff --git a/engine/calldesc_test.go b/engine/calldesc_test.go
index be05ee27c..884948a69 100644
--- a/engine/calldesc_test.go
+++ b/engine/calldesc_test.go
@@ -1934,7 +1934,7 @@ func TestCallDescriptorAsCGREvent(t *testing.T) {
 			"Usage":       30 * time.Minute,
 		},
 	}
-	cgrEvent := cd.AsCGREvent()
+	cgrEvent := cd.AsCGREvent(nil)
 	if !reflect.DeepEqual(eCGREvent.Tenant, cgrEvent.Tenant) {
 		t.Errorf("Expecting: %+v, received: %+v", eCGREvent.Tenant, cgrEvent.Tenant)
 	}
diff --git a/engine/chargers_test.go b/engine/chargers_test.go
index 7bb101c10..651af7da5 100755
--- a/engine/chargers_test.go
+++ b/engine/chargers_test.go
@@ -64,40 +64,34 @@ var (
 			Weight:       20,
 		},
 	}
-	chargerEvents = []*utils.CGREventWithOpts{
+	chargerEvents = []*utils.CGREvent{
 		{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"Charger":        "ChargerProfile1",
+				utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
+				"UsageInterval":  "1s",
+				utils.Weight:     "200.0",
+			},
 			Opts: map[string]interface{}{
 				utils.Subsys: utils.MetaChargers,
 			},
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"Charger":        "ChargerProfile1",
-					utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
-					"UsageInterval":  "1s",
-					utils.Weight:     "200.0",
-				},
+		},
+		{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"Charger":        "ChargerProfile2",
+				utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
 			},
 		},
 		{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"Charger":        "ChargerProfile2",
-					utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
-				},
-			},
-		},
-		{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"Charger":        "DistinctMatch",
-					utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
-				},
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"Charger":        "DistinctMatch",
+				utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
 			},
 		},
 	}
@@ -214,16 +208,12 @@ func TestChargerProcessEvent(t *testing.T) {
 	rpl := []*ChrgSProcessEventReply{
 		{
 			ChargerSProfile: "CPP_1",
-			Opts:            map[string]interface{}{utils.Subsys: utils.MetaChargers},
 			AlteredFields:   []string{utils.MetaReqRunID},
-			CGREvent:        chargerEvents[0].CGREvent,
+			CGREvent:        chargerEvents[0],
 		},
 	}
 	rpl[0].CGREvent.Event[utils.RunID] = cPPs[0].RunID
-	rcv, err := chargerSrv.processEvent(rpl[0].CGREvent.Tenant, &utils.CGREventWithOpts{
-		CGREvent: chargerEvents[0].CGREvent,
-		Opts:     chargerEvents[0].Opts,
-	})
+	rcv, err := chargerSrv.processEvent(rpl[0].CGREvent.Tenant, chargerEvents[0])
 	if err != nil {
 		t.Fatalf("Error: %+v", err)
 	}
diff --git a/engine/routes_test.go b/engine/routes_test.go
index 5cbc9a0d7..5b67aea79 100644
--- a/engine/routes_test.go
+++ b/engine/routes_test.go
@@ -129,55 +129,47 @@ var (
 	}
 	argsGetRoutes = []*ArgsGetRoutes{
 		{ //matching RouteProfile1
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: &utils.CGREvent{
-					Tenant: "cgrates.org",
-					ID:     "utils.CGREvent1",
-					Event: map[string]interface{}{
-						"Route":          "RouteProfile1",
-						utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
-						"UsageInterval":  "1s",
-						"PddInterval":    "1s",
-						"Weight":         "20.0",
-					},
+			CGREvent: &utils.CGREvent{
+				Tenant: "cgrates.org",
+				ID:     "utils.CGREvent1",
+				Event: map[string]interface{}{
+					"Route":          "RouteProfile1",
+					utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
+					"UsageInterval":  "1s",
+					"PddInterval":    "1s",
+					"Weight":         "20.0",
 				},
 			},
 		},
 		{ //matching RouteProfile2
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: &utils.CGREvent{
-					Tenant: "cgrates.org",
-					ID:     "utils.CGREvent1",
-					Event: map[string]interface{}{
-						"Route":          "RouteProfile2",
-						utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
-						"UsageInterval":  "1s",
-						"PddInterval":    "1s",
-						"Weight":         "20.0",
-					},
+			CGREvent: &utils.CGREvent{
+				Tenant: "cgrates.org",
+				ID:     "utils.CGREvent1",
+				Event: map[string]interface{}{
+					"Route":          "RouteProfile2",
+					utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
+					"UsageInterval":  "1s",
+					"PddInterval":    "1s",
+					"Weight":         "20.0",
 				},
 			},
 		},
 		{ //matching RouteProfilePrefix
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: &utils.CGREvent{
-					Tenant: "cgrates.org",
-					ID:     "utils.CGREvent1",
-					Event: map[string]interface{}{
-						"Route": "RouteProfilePrefix",
-					},
+			CGREvent: &utils.CGREvent{
+				Tenant: "cgrates.org",
+				ID:     "utils.CGREvent1",
+				Event: map[string]interface{}{
+					"Route": "RouteProfilePrefix",
 				},
 			},
 		},
 		{ //matching
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: &utils.CGREvent{
-					Tenant: "cgrates.org",
-					ID:     "CGR",
-					Event: map[string]interface{}{
-						"UsageInterval": "1s",
-						"PddInterval":   "1s",
-					},
+			CGREvent: &utils.CGREvent{
+				Tenant: "cgrates.org",
+				ID:     "CGR",
+				Event: map[string]interface{}{
+					"UsageInterval": "1s",
+					"PddInterval":   "1s",
 				},
 			},
 		},
@@ -385,7 +377,7 @@ func TestRoutesCache(t *testing.T) {
 }
 
 func TestRoutesmatchingRouteProfilesForEvent(t *testing.T) {
-	sprf, err := routeService.matchingRouteProfilesForEvent(argsGetRoutes[0].Tenant, argsGetRoutes[0].CGREventWithOpts, true)
+	sprf, err := routeService.matchingRouteProfilesForEvent(argsGetRoutes[0].Tenant, argsGetRoutes[0].CGREvent, true)
 	if err != nil {
 		t.Errorf("Error: %+v", err)
 	}
@@ -393,7 +385,7 @@ func TestRoutesmatchingRouteProfilesForEvent(t *testing.T) {
 		t.Errorf("Expecting: %+v, received: %+v", sppTest[0], sprf[0])
 	}
 
-	sprf, err = routeService.matchingRouteProfilesForEvent(argsGetRoutes[1].Tenant, argsGetRoutes[1].CGREventWithOpts, true)
+	sprf, err = routeService.matchingRouteProfilesForEvent(argsGetRoutes[1].Tenant, argsGetRoutes[1].CGREvent, true)
 	if err != nil {
 		t.Errorf("Error: %+v", err)
 	}
@@ -401,7 +393,7 @@ func TestRoutesmatchingRouteProfilesForEvent(t *testing.T) {
 		t.Errorf("Expecting: %+v, received: %+v", sppTest[1], sprf[0])
 	}
 
-	sprf, err = routeService.matchingRouteProfilesForEvent(argsGetRoutes[2].Tenant, argsGetRoutes[2].CGREventWithOpts, true)
+	sprf, err = routeService.matchingRouteProfilesForEvent(argsGetRoutes[2].Tenant, argsGetRoutes[2].CGREvent, true)
 	if err != nil {
 		t.Errorf("Error: %+v", err)
 	}
@@ -635,7 +627,7 @@ func TestRoutesAsOptsGetRoutesMaxCost(t *testing.T) {
 
 func TestRoutesMatchWithIndexFalse(t *testing.T) {
 	routeService.cgrcfg.RouteSCfg().IndexedSelects = false
-	sprf, err := routeService.matchingRouteProfilesForEvent(argsGetRoutes[0].Tenant, argsGetRoutes[0].CGREventWithOpts, true)
+	sprf, err := routeService.matchingRouteProfilesForEvent(argsGetRoutes[0].Tenant, argsGetRoutes[0].CGREvent, true)
 	if err != nil {
 		t.Errorf("Error: %+v", err)
 	}
@@ -643,7 +635,7 @@ func TestRoutesMatchWithIndexFalse(t *testing.T) {
 		t.Errorf("Expecting: %+v, received: %+v", sppTest[0], sprf[0])
 	}
 
-	sprf, err = routeService.matchingRouteProfilesForEvent(argsGetRoutes[1].Tenant, argsGetRoutes[1].CGREventWithOpts, true)
+	sprf, err = routeService.matchingRouteProfilesForEvent(argsGetRoutes[1].Tenant, argsGetRoutes[1].CGREvent, true)
 	if err != nil {
 		t.Errorf("Error: %+v", err)
 	}
@@ -651,7 +643,7 @@ func TestRoutesMatchWithIndexFalse(t *testing.T) {
 		t.Errorf("Expecting: %+v, received: %+v", sppTest[1], sprf[0])
 	}
 
-	sprf, err = routeService.matchingRouteProfilesForEvent(argsGetRoutes[2].Tenant, argsGetRoutes[2].CGREventWithOpts, true)
+	sprf, err = routeService.matchingRouteProfilesForEvent(argsGetRoutes[2].Tenant, argsGetRoutes[2].CGREvent, true)
 	if err != nil {
 		t.Errorf("Error: %+v", err)
 	}
diff --git a/engine/stats_test.go b/engine/stats_test.go
index 562ec53d2..56cf33db4 100644
--- a/engine/stats_test.go
+++ b/engine/stats_test.go
@@ -100,47 +100,41 @@ var (
 	}
 	statsEvs = []*StatsArgsProcessEvent{
 		{
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: &utils.CGREvent{
-					Tenant: "cgrates.org",
-					ID:     "event1",
-					Event: map[string]interface{}{
-						"Stats":          "StatQueueProfile1",
-						utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
-						"UsageInterval":  "1s",
-						"PddInterval":    "1s",
-						"Weight":         "9.0",
-						utils.Usage:      135 * time.Second,
-						utils.Cost:       123.0,
-					},
+			CGREvent: &utils.CGREvent{
+				Tenant: "cgrates.org",
+				ID:     "event1",
+				Event: map[string]interface{}{
+					"Stats":          "StatQueueProfile1",
+					utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
+					"UsageInterval":  "1s",
+					"PddInterval":    "1s",
+					"Weight":         "9.0",
+					utils.Usage:      135 * time.Second,
+					utils.Cost:       123.0,
 				},
 			},
 		},
 		{
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: &utils.CGREvent{
-					Tenant: "cgrates.org",
-					ID:     "event2",
-					Event: map[string]interface{}{
-						"Stats":          "StatQueueProfile2",
-						utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
-						"UsageInterval":  "1s",
-						"PddInterval":    "1s",
-						"Weight":         "15.0",
-						utils.Usage:      45 * time.Second,
-					},
+			CGREvent: &utils.CGREvent{
+				Tenant: "cgrates.org",
+				ID:     "event2",
+				Event: map[string]interface{}{
+					"Stats":          "StatQueueProfile2",
+					utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
+					"UsageInterval":  "1s",
+					"PddInterval":    "1s",
+					"Weight":         "15.0",
+					utils.Usage:      45 * time.Second,
 				},
 			},
 		},
 		{
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: &utils.CGREvent{
-					Tenant: "cgrates.org",
-					ID:     "event3",
-					Event: map[string]interface{}{
-						"Stats":     "StatQueueProfilePrefix",
-						utils.Usage: 30 * time.Second,
-					},
+			CGREvent: &utils.CGREvent{
+				Tenant: "cgrates.org",
+				ID:     "event3",
+				Event: map[string]interface{}{
+					"Stats":     "StatQueueProfilePrefix",
+					utils.Usage: 30 * time.Second,
 				},
 			},
 		},
@@ -401,8 +395,8 @@ func TestStatQueuesV1ProcessEvent(t *testing.T) {
 		t.Errorf("Expecting: %+v, received: %+v", sqPrf, tempStat)
 	}
 	ev := &StatsArgsProcessEvent{
-		StatIDs:          []string{"StatQueueProfile1", "StatQueueProfile2", "StatQueueProfile3"},
-		CGREventWithOpts: statsEvs[0].CGREventWithOpts,
+		StatIDs:  []string{"StatQueueProfile1", "StatQueueProfile2", "StatQueueProfile3"},
+		CGREvent: statsEvs[0].CGREvent,
 	}
 	reply := []string{}
 	expected := []string{"StatQueueProfile1", "StatQueueProfile3"}
diff --git a/engine/thresholds_test.go b/engine/thresholds_test.go
index ed07f2c3a..35aef0f5b 100644
--- a/engine/thresholds_test.go
+++ b/engine/thresholds_test.go
@@ -91,37 +91,31 @@ var (
 	}
 	argsGetThresholds = []*ThresholdsArgsProcessEvent{
 		{
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: &utils.CGREvent{
-					Tenant: "cgrates.org",
-					ID:     "Ev1",
-					Event: map[string]interface{}{
-						"Threshold": "TH_1",
-						"Weight":    "10.0",
-					},
+			CGREvent: &utils.CGREvent{
+				Tenant: "cgrates.org",
+				ID:     "Ev1",
+				Event: map[string]interface{}{
+					"Threshold": "TH_1",
+					"Weight":    "10.0",
 				},
 			},
 		},
 		{
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: &utils.CGREvent{
-					Tenant: "cgrates.org",
-					ID:     "Ev1",
-					Event: map[string]interface{}{
-						"Threshold": "TH_2",
-						"Weight":    "20.0",
-					},
+			CGREvent: &utils.CGREvent{
+				Tenant: "cgrates.org",
+				ID:     "Ev1",
+				Event: map[string]interface{}{
+					"Threshold": "TH_2",
+					"Weight":    "20.0",
 				},
 			},
 		},
 		{
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: &utils.CGREvent{
-					Tenant: "cgrates.org",
-					ID:     "Ev1",
-					Event: map[string]interface{}{
-						"Threshold": "ThresholdPrefix123",
-					},
+			CGREvent: &utils.CGREvent{
+				Tenant: "cgrates.org",
+				ID:     "Ev1",
+				Event: map[string]interface{}{
+					"Threshold": "ThresholdPrefix123",
 				},
 			},
 		},
@@ -349,9 +343,7 @@ func TestThresholdsProcessEvent2(t *testing.T) {
 	}
 	ev := &ThresholdsArgsProcessEvent{
 		ThresholdIDs: []string{"TH_1", "TH_2", "TH_3", "TH_4"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: argsGetThresholds[0].CGREvent,
-		},
+		CGREvent:     argsGetThresholds[0].CGREvent,
 	}
 	if err = dmTH.SetThresholdProfile(thPrf, true); err != nil {
 		t.Errorf("Error: %+v", err)
diff --git a/engine/z_attributes_test.go b/engine/z_attributes_test.go
index 12566e4ac..1415e09d1 100644
--- a/engine/z_attributes_test.go
+++ b/engine/z_attributes_test.go
@@ -34,52 +34,44 @@ var (
 	attrEvs           = []*AttrArgsProcessEvent{
 		{
 			Context: utils.StringPointer(utils.MetaSessionS),
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: &utils.CGREvent{ //matching AttributeProfile1
-					Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-					ID:     utils.GenUUID(),
-					Event: map[string]interface{}{
-						"Attribute":      "AttributeProfile1",
-						utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
-						"UsageInterval":  "1s",
-						utils.Weight:     "20.0",
-					},
+			CGREvent: &utils.CGREvent{ //matching AttributeProfile1
+				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+				ID:     utils.GenUUID(),
+				Event: map[string]interface{}{
+					"Attribute":      "AttributeProfile1",
+					utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
+					"UsageInterval":  "1s",
+					utils.Weight:     "20.0",
 				},
 			},
 		},
 		{
 			Context: utils.StringPointer(utils.MetaSessionS),
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: &utils.CGREvent{ //matching AttributeProfile2
-					Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-					ID:     utils.GenUUID(),
-					Event: map[string]interface{}{
-						"Attribute": "AttributeProfile2",
-					},
+			CGREvent: &utils.CGREvent{ //matching AttributeProfile2
+				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+				ID:     utils.GenUUID(),
+				Event: map[string]interface{}{
+					"Attribute": "AttributeProfile2",
 				},
 			},
 		},
 		{
 			Context: utils.StringPointer(utils.MetaSessionS),
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: &utils.CGREvent{ //matching AttributeProfilePrefix
-					Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-					ID:     utils.GenUUID(),
-					Event: map[string]interface{}{
-						"Attribute": "AttributeProfilePrefix",
-					},
+			CGREvent: &utils.CGREvent{ //matching AttributeProfilePrefix
+				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+				ID:     utils.GenUUID(),
+				Event: map[string]interface{}{
+					"Attribute": "AttributeProfilePrefix",
 				},
 			},
 		},
 		{
 			Context: utils.StringPointer(utils.MetaSessionS),
-			CGREventWithOpts: &utils.CGREventWithOpts{
-				CGREvent: &utils.CGREvent{ //matching AttributeProfilePrefix
-					Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-					ID:     utils.GenUUID(),
-					Event: map[string]interface{}{
-						"DistinctMatch": 20,
-					},
+			CGREvent: &utils.CGREvent{ //matching AttributeProfilePrefix
+				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+				ID:     utils.GenUUID(),
+				Event: map[string]interface{}{
+					"DistinctMatch": 20,
 				},
 			},
 		},
@@ -296,9 +288,9 @@ func TestAttributeProfileForEvent(t *testing.T) {
 func TestAttributeProcessEvent(t *testing.T) {
 	attrEvs[0].CGREvent.Event["Account"] = "1010" //Field added in event after process
 	eRply := &AttrSProcessEventReply{
-		MatchedProfiles:  []string{"AttributeProfile1"},
-		AlteredFields:    []string{utils.MetaReq + utils.NestingSep + "Account"},
-		CGREventWithOpts: attrEvs[0].CGREventWithOpts,
+		MatchedProfiles: []string{"AttributeProfile1"},
+		AlteredFields:   []string{utils.MetaReq + utils.NestingSep + "Account"},
+		CGREvent:        attrEvs[0].CGREvent,
 	}
 	eNM := utils.MapStorage{
 		utils.MetaReq:  attrEvs[0].CGREvent.Event,
@@ -335,9 +327,9 @@ func TestAttributeProcessEventWithIDs(t *testing.T) {
 	attrEvs[3].CGREvent.Event["Account"] = "1010" //Field added in event after process
 	attrEvs[3].AttributeIDs = []string{"AttributeIDMatch"}
 	eRply := &AttrSProcessEventReply{
-		MatchedProfiles:  []string{"AttributeIDMatch"},
-		AlteredFields:    []string{utils.MetaReq + utils.NestingSep + "Account"},
-		CGREventWithOpts: attrEvs[3].CGREventWithOpts,
+		MatchedProfiles: []string{"AttributeIDMatch"},
+		AlteredFields:   []string{utils.MetaReq + utils.NestingSep + "Account"},
+		CGREvent:        attrEvs[3].CGREvent,
 	}
 	eNM := utils.MapStorage{
 		utils.MetaReq:  attrEvs[3].CGREvent.Event,
@@ -356,15 +348,13 @@ func TestAttributeEventReplyDigest(t *testing.T) {
 	eRpl := &AttrSProcessEventReply{
 		MatchedProfiles: []string{"ATTR_1"},
 		AlteredFields:   []string{utils.AccountField, utils.Subject},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: "cgrates.org",
-				ID:     "testAttributeSProcessEvent",
-				Event: map[string]interface{}{
-					utils.AccountField: "1001",
-					utils.Subject:      "1001",
-					utils.Destinations: "+491511231234",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: "cgrates.org",
+			ID:     "testAttributeSProcessEvent",
+			Event: map[string]interface{}{
+				utils.AccountField: "1001",
+				utils.Subject:      "1001",
+				utils.Destinations: "+491511231234",
 			},
 		},
 	}
@@ -379,15 +369,13 @@ func TestAttributeEventReplyDigest2(t *testing.T) {
 	eRpl := &AttrSProcessEventReply{
 		MatchedProfiles: []string{"ATTR_1"},
 		AlteredFields:   []string{},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: "cgrates.org",
-				ID:     "testAttributeSProcessEvent",
-				Event: map[string]interface{}{
-					utils.AccountField: "1001",
-					utils.Subject:      "1001",
-					utils.Destinations: "+491511231234",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: "cgrates.org",
+			ID:     "testAttributeSProcessEvent",
+			Event: map[string]interface{}{
+				utils.AccountField: "1001",
+				utils.Subject:      "1001",
+				utils.Destinations: "+491511231234",
 			},
 		},
 	}
@@ -402,15 +390,13 @@ func TestAttributeEventReplyDigest3(t *testing.T) {
 	eRpl := &AttrSProcessEventReply{
 		MatchedProfiles: []string{"ATTR_1"},
 		AlteredFields:   []string{"*req.Subject"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: "cgrates.org",
-				ID:     "testAttributeSProcessEvent",
-				Event: map[string]interface{}{
-					utils.AccountField: "1001",
-					utils.Subject:      "1001",
-					utils.Destinations: "+491511231234",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: "cgrates.org",
+			ID:     "testAttributeSProcessEvent",
+			Event: map[string]interface{}{
+				utils.AccountField: "1001",
+				utils.Subject:      "1001",
+				utils.Destinations: "+491511231234",
 			},
 		},
 	}
@@ -425,14 +411,12 @@ func TestAttributeEventReplyDigest4(t *testing.T) {
 	eRpl := &AttrSProcessEventReply{
 		MatchedProfiles: []string{"ATTR_1"},
 		AlteredFields:   []string{"*req.Subject"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: "cgrates.org",
-				ID:     "testAttributeSProcessEvent",
-				Event: map[string]interface{}{
-					utils.AccountField: "1001",
-					utils.Destinations: "+491511231234",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: "cgrates.org",
+			ID:     "testAttributeSProcessEvent",
+			Event: map[string]interface{}{
+				utils.AccountField: "1001",
+				utils.Destinations: "+491511231234",
 			},
 		},
 	}
@@ -579,13 +563,11 @@ func TestAttributeProcessWithMultipleRuns1(t *testing.T) {
 	attrArgs := &AttrArgsProcessEvent{
 		Context:     utils.StringPointer(utils.MetaSessionS),
 		ProcessRuns: utils.IntPointer(4),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"InitialField": "InitialValue",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"InitialField": "InitialValue",
 			},
 		},
 	}
@@ -596,16 +578,14 @@ func TestAttributeProcessWithMultipleRuns1(t *testing.T) {
 			utils.MetaReq + utils.NestingSep + "Field2",
 			utils.MetaReq + utils.NestingSep + "Field3",
 		},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"InitialField": "InitialValue",
-					"Field1":       "Value1",
-					"Field2":       "Value2",
-					"Field3":       "Value3",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"InitialField": "InitialValue",
+				"Field1":       "Value1",
+				"Field2":       "Value2",
+				"Field3":       "Value3",
 			},
 		},
 	}
@@ -696,13 +676,11 @@ func TestAttributeProcessWithMultipleRuns2(t *testing.T) {
 	attrArgs := &AttrArgsProcessEvent{
 		Context:     utils.StringPointer(utils.MetaSessionS),
 		ProcessRuns: utils.IntPointer(4),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"InitialField": "InitialValue",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"InitialField": "InitialValue",
 			},
 		},
 	}
@@ -710,15 +688,13 @@ func TestAttributeProcessWithMultipleRuns2(t *testing.T) {
 		MatchedProfiles: []string{"ATTR_1", "ATTR_2", "ATTR_1", "ATTR_2"},
 		AlteredFields: []string{utils.MetaReq + utils.NestingSep + "Field1",
 			utils.MetaReq + utils.NestingSep + "Field2"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"InitialField": "InitialValue",
-					"Field1":       "Value1",
-					"Field2":       "Value2",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"InitialField": "InitialValue",
+				"Field1":       "Value1",
+				"Field2":       "Value2",
 			},
 		},
 	}
@@ -809,13 +785,11 @@ func TestAttributeProcessWithMultipleRuns3(t *testing.T) {
 	attrArgs := &AttrArgsProcessEvent{
 		Context:     utils.StringPointer(utils.MetaSessionS),
 		ProcessRuns: utils.IntPointer(2),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"InitialField": "InitialValue",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"InitialField": "InitialValue",
 			},
 		},
 	}
@@ -823,15 +797,13 @@ func TestAttributeProcessWithMultipleRuns3(t *testing.T) {
 		MatchedProfiles: []string{"ATTR_1", "ATTR_2"},
 		AlteredFields: []string{utils.MetaReq + utils.NestingSep + "Field1",
 			utils.MetaReq + utils.NestingSep + "Field2"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"InitialField": "InitialValue",
-					"Field1":       "Value1",
-					"Field2":       "Value2",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"InitialField": "InitialValue",
+				"Field1":       "Value1",
+				"Field2":       "Value2",
 			},
 		},
 	}
@@ -903,13 +875,11 @@ func TestAttributeProcessWithMultipleRuns4(t *testing.T) {
 	attrArgs := &AttrArgsProcessEvent{
 		Context:     utils.StringPointer(utils.MetaSessionS),
 		ProcessRuns: utils.IntPointer(4),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"InitialField": "InitialValue",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"InitialField": "InitialValue",
 			},
 		},
 	}
@@ -917,15 +887,13 @@ func TestAttributeProcessWithMultipleRuns4(t *testing.T) {
 		MatchedProfiles: []string{"ATTR_1", "ATTR_2", "ATTR_1", "ATTR_2"},
 		AlteredFields: []string{utils.MetaReq + utils.NestingSep + "Field1",
 			utils.MetaReq + utils.NestingSep + "Field2"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"InitialField": "InitialValue",
-					"Field1":       "Value1",
-					"Field2":       "Value2",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"InitialField": "InitialValue",
+				"Field1":       "Value1",
+				"Field2":       "Value2",
 			},
 		},
 	}
@@ -1019,13 +987,11 @@ func TestAttributeMultipleProcessWithBlocker(t *testing.T) {
 	attrArgs := &AttrArgsProcessEvent{
 		Context:     utils.StringPointer(utils.MetaSessionS),
 		ProcessRuns: utils.IntPointer(4),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"InitialField": "InitialValue",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"InitialField": "InitialValue",
 			},
 		},
 	}
@@ -1033,15 +999,13 @@ func TestAttributeMultipleProcessWithBlocker(t *testing.T) {
 		MatchedProfiles: []string{"ATTR_1", "ATTR_2"},
 		AlteredFields: []string{utils.MetaReq + utils.NestingSep + "Field1",
 			utils.MetaReq + utils.NestingSep + "Field2"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"InitialField": "InitialValue",
-					"Field1":       "Value1",
-					"Field2":       "Value2",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"InitialField": "InitialValue",
+				"Field1":       "Value1",
+				"Field2":       "Value2",
 			},
 		},
 	}
@@ -1134,27 +1098,23 @@ func TestAttributeMultipleProcessWithBlocker2(t *testing.T) {
 	attrArgs := &AttrArgsProcessEvent{
 		Context:     utils.StringPointer(utils.MetaSessionS),
 		ProcessRuns: utils.IntPointer(4),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"InitialField": "InitialValue",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"InitialField": "InitialValue",
 			},
 		},
 	}
 	eRply := &AttrSProcessEventReply{
 		MatchedProfiles: []string{"ATTR_1"},
 		AlteredFields:   []string{utils.MetaReq + utils.NestingSep + "Field1"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"InitialField": "InitialValue",
-					"Field1":       "Value1",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"InitialField": "InitialValue",
+				"Field1":       "Value1",
 			},
 		},
 	}
@@ -1208,27 +1168,23 @@ func TestAttributeProcessValue(t *testing.T) {
 	attrArgs := &AttrArgsProcessEvent{
 		Context:     utils.StringPointer(utils.MetaSessionS),
 		ProcessRuns: utils.IntPointer(1),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"Field1": "Value1",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"Field1": "Value1",
 			},
 		},
 	}
 	eRply := &AttrSProcessEventReply{
 		MatchedProfiles: []string{"ATTR_1"},
 		AlteredFields:   []string{utils.MetaReq + utils.NestingSep + "Field2"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"Field1": "Value1",
-					"Field2": "Value1",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"Field1": "Value1",
+				"Field2": "Value1",
 			},
 		},
 	}
@@ -1291,13 +1247,11 @@ func TestAttributeAttributeFilterIDs(t *testing.T) {
 	attrArgs := &AttrArgsProcessEvent{
 		Context:     utils.StringPointer(utils.MetaSessionS),
 		ProcessRuns: utils.IntPointer(1),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"PassField": "Test",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"PassField": "Test",
 			},
 		},
 	}
@@ -1305,14 +1259,12 @@ func TestAttributeAttributeFilterIDs(t *testing.T) {
 		MatchedProfiles: []string{"ATTR_1"},
 		AlteredFields: []string{utils.MetaReq + utils.NestingSep + "PassField",
 			utils.MetaReq + utils.NestingSep + "RandomField"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"PassField":   "Pass",
-					"RandomField": "RandomValue",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"PassField":   "Pass",
+				"RandomField": "RandomValue",
 			},
 		},
 	}
@@ -1368,27 +1320,23 @@ func TestAttributeProcessEventConstant(t *testing.T) {
 	attrArgs := &AttrArgsProcessEvent{
 		Context:     utils.StringPointer(utils.MetaSessionS),
 		ProcessRuns: utils.IntPointer(1),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"Field1": "Value1",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"Field1": "Value1",
 			},
 		},
 	}
 	eRply := &AttrSProcessEventReply{
 		MatchedProfiles: []string{"ATTR_1"},
 		AlteredFields:   []string{utils.MetaReq + utils.NestingSep + "Field2"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"Field1": "Value1",
-					"Field2": "ConstVal",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"Field1": "Value1",
+				"Field2": "ConstVal",
 			},
 		},
 	}
@@ -1448,29 +1396,25 @@ func TestAttributeProcessEventVariable(t *testing.T) {
 	attrArgs := &AttrArgsProcessEvent{
 		Context:     utils.StringPointer(utils.MetaSessionS),
 		ProcessRuns: utils.IntPointer(1),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"Field1":   "Value1",
-					"TheField": "TheVal",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"Field1":   "Value1",
+				"TheField": "TheVal",
 			},
 		},
 	}
 	eRply := &AttrSProcessEventReply{
 		MatchedProfiles: []string{"ATTR_1"},
 		AlteredFields:   []string{utils.MetaReq + utils.NestingSep + "Field2"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"Field1":   "Value1",
-					"Field2":   "TheVal",
-					"TheField": "TheVal",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"Field1":   "Value1",
+				"Field2":   "TheVal",
+				"TheField": "TheVal",
 			},
 		},
 	}
@@ -1535,29 +1479,25 @@ func TestAttributeProcessEventComposed(t *testing.T) {
 	attrArgs := &AttrArgsProcessEvent{
 		Context:     utils.StringPointer(utils.MetaSessionS),
 		ProcessRuns: utils.IntPointer(1),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"Field1":   "Value1",
-					"TheField": "TheVal",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"Field1":   "Value1",
+				"TheField": "TheVal",
 			},
 		},
 	}
 	eRply := &AttrSProcessEventReply{
 		MatchedProfiles: []string{"ATTR_1"},
 		AlteredFields:   []string{utils.MetaReq + utils.NestingSep + "Field2"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"Field1":   "Value1",
-					"Field2":   "Value1_TheVal",
-					"TheField": "TheVal",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"Field1":   "Value1",
+				"Field2":   "Value1_TheVal",
+				"TheField": "TheVal",
 			},
 		},
 	}
@@ -1612,31 +1552,27 @@ func TestAttributeProcessEventSum(t *testing.T) {
 	attrArgs := &AttrArgsProcessEvent{
 		Context:     utils.StringPointer(utils.MetaSessionS),
 		ProcessRuns: utils.IntPointer(1),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"Field1":   "Value1",
-					"TheField": "TheVal",
-					"NumField": "20",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"Field1":   "Value1",
+				"TheField": "TheVal",
+				"NumField": "20",
 			},
 		},
 	}
 	eRply := &AttrSProcessEventReply{
 		MatchedProfiles: []string{"ATTR_1"},
 		AlteredFields:   []string{utils.MetaReq + utils.NestingSep + "Field2"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"Field1":   "Value1",
-					"TheField": "TheVal",
-					"NumField": "20",
-					"Field2":   "50",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"Field1":   "Value1",
+				"TheField": "TheVal",
+				"NumField": "20",
+				"Field2":   "50",
 			},
 		},
 	}
@@ -1691,33 +1627,29 @@ func TestAttributeProcessEventUsageDifference(t *testing.T) {
 	attrArgs := &AttrArgsProcessEvent{
 		Context:     utils.StringPointer(utils.MetaSessionS),
 		ProcessRuns: utils.IntPointer(1),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"Field1":         "Value1",
-					"TheField":       "TheVal",
-					"UnixTimeStamp":  "1554364297",
-					"UnixTimeStamp2": "1554364287",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"Field1":         "Value1",
+				"TheField":       "TheVal",
+				"UnixTimeStamp":  "1554364297",
+				"UnixTimeStamp2": "1554364287",
 			},
 		},
 	}
 	eRply := &AttrSProcessEventReply{
 		MatchedProfiles: []string{"ATTR_1"},
 		AlteredFields:   []string{utils.MetaReq + utils.NestingSep + "Field2"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"Field1":         "Value1",
-					"TheField":       "TheVal",
-					"UnixTimeStamp":  "1554364297",
-					"UnixTimeStamp2": "1554364287",
-					"Field2":         "10s",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"Field1":         "Value1",
+				"TheField":       "TheVal",
+				"UnixTimeStamp":  "1554364297",
+				"UnixTimeStamp2": "1554364287",
+				"Field2":         "10s",
 			},
 		},
 	}
@@ -1772,33 +1704,29 @@ func TestAttributeProcessEventValueExponent(t *testing.T) {
 	attrArgs := &AttrArgsProcessEvent{
 		Context:     utils.StringPointer(utils.MetaSessionS),
 		ProcessRuns: utils.IntPointer(1),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"Field1":     "Value1",
-					"TheField":   "TheVal",
-					"Multiplier": "2",
-					"Pow":        "3",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"Field1":     "Value1",
+				"TheField":   "TheVal",
+				"Multiplier": "2",
+				"Pow":        "3",
 			},
 		},
 	}
 	eRply := &AttrSProcessEventReply{
 		MatchedProfiles: []string{"ATTR_1"},
 		AlteredFields:   []string{utils.MetaReq + utils.NestingSep + "Field2"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"Field1":     "Value1",
-					"TheField":   "TheVal",
-					"Multiplier": "2",
-					"Pow":        "3",
-					"Field2":     "2000",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"Field1":     "Value1",
+				"TheField":   "TheVal",
+				"Multiplier": "2",
+				"Pow":        "3",
+				"Field2":     "2000",
 			},
 		},
 	}
@@ -1861,13 +1789,11 @@ func BenchmarkAttributeProcessEventConstant(b *testing.B) {
 	attrArgs := &AttrArgsProcessEvent{
 		Context:     utils.StringPointer(utils.MetaSessionS),
 		ProcessRuns: utils.IntPointer(1),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"Field1": "Value1",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"Field1": "Value1",
 			},
 		},
 	}
@@ -1924,13 +1850,11 @@ func BenchmarkAttributeProcessEventVariable(b *testing.B) {
 	attrArgs := &AttrArgsProcessEvent{
 		Context:     utils.StringPointer(utils.MetaSessionS),
 		ProcessRuns: utils.IntPointer(1),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"Field1": "Value1",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"Field1": "Value1",
 			},
 		},
 	}
@@ -1999,14 +1923,12 @@ func TestProcessAttributeConstant(t *testing.T) {
 	}
 	ev := &AttrArgsProcessEvent{
 		Context: utils.StringPointer(utils.MetaSessionS),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{ //matching ATTR_CONSTANT
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     "TestProcessAttributeConstant",
-				Event: map[string]interface{}{
-					"Field1":     "Val1",
-					utils.Weight: "20.0",
-				},
+		CGREvent: &utils.CGREvent{ //matching ATTR_CONSTANT
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     "TestProcessAttributeConstant",
+			Event: map[string]interface{}{
+				"Field1":     "Val1",
+				utils.Weight: "20.0",
 			},
 		},
 	}
@@ -2025,9 +1947,7 @@ func TestProcessAttributeConstant(t *testing.T) {
 	eRply := &AttrSProcessEventReply{
 		MatchedProfiles: []string{"ATTR_CONSTANT"},
 		AlteredFields:   []string{utils.MetaReq + utils.NestingSep + "Field2"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: ev.CGREvent,
-		},
+		CGREvent:        ev.CGREvent,
 	}
 	if !reflect.DeepEqual(eRply, rcv) {
 		t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(eRply), utils.ToJSON(rcv))
@@ -2061,15 +1981,13 @@ func TestProcessAttributeVariable(t *testing.T) {
 	}
 	ev := &AttrArgsProcessEvent{
 		Context: utils.StringPointer(utils.MetaSessionS),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{ //matching ATTR_VARIABLE
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     "TestProcessAttributeVariable",
-				Event: map[string]interface{}{
-					"Field1":      "Val1",
-					"RandomField": "Val2",
-					utils.Weight:  "20.0",
-				},
+		CGREvent: &utils.CGREvent{ //matching ATTR_VARIABLE
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     "TestProcessAttributeVariable",
+			Event: map[string]interface{}{
+				"Field1":      "Val1",
+				"RandomField": "Val2",
+				utils.Weight:  "20.0",
 			},
 		},
 	}
@@ -2089,9 +2007,7 @@ func TestProcessAttributeVariable(t *testing.T) {
 	eRply := &AttrSProcessEventReply{
 		MatchedProfiles: []string{"ATTR_VARIABLE"},
 		AlteredFields:   []string{utils.MetaReq + utils.NestingSep + "Field2"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: clnEv,
-		},
+		CGREvent:        clnEv,
 	}
 	if !reflect.DeepEqual(eRply, rcv) {
 		t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(eRply), utils.ToJSON(rcv))
@@ -2130,16 +2046,14 @@ func TestProcessAttributeComposed(t *testing.T) {
 	}
 	ev := &AttrArgsProcessEvent{
 		Context: utils.StringPointer(utils.MetaSessionS),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{ //matching ATTR_COMPOSED
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     "TestProcessAttributeComposed",
-				Event: map[string]interface{}{
-					"Field1":       "Val1",
-					"RandomField":  "Val2",
-					"RandomField2": "Concatenated",
-					utils.Weight:   "20.0",
-				},
+		CGREvent: &utils.CGREvent{ //matching ATTR_COMPOSED
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     "TestProcessAttributeComposed",
+			Event: map[string]interface{}{
+				"Field1":       "Val1",
+				"RandomField":  "Val2",
+				"RandomField2": "Concatenated",
+				utils.Weight:   "20.0",
 			},
 		},
 	}
@@ -2159,9 +2073,7 @@ func TestProcessAttributeComposed(t *testing.T) {
 	eRply := &AttrSProcessEventReply{
 		MatchedProfiles: []string{"ATTR_COMPOSED"},
 		AlteredFields:   []string{utils.MetaReq + utils.NestingSep + "Field2"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: clnEv,
-		},
+		CGREvent:        clnEv,
 	}
 	if !reflect.DeepEqual(eRply, rcv) {
 		t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(eRply), utils.ToJSON(rcv))
@@ -2195,16 +2107,14 @@ func TestProcessAttributeUsageDifference(t *testing.T) {
 	}
 	ev := &AttrArgsProcessEvent{
 		Context: utils.StringPointer(utils.MetaSessionS),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{ //matching ATTR_USAGE_DIFF
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     "TestProcessAttributeUsageDifference",
-				Event: map[string]interface{}{
-					"Field1":       "Val1",
-					"RandomField":  "1514808000",
-					"RandomField2": "1514804400",
-					utils.Weight:   "20.0",
-				},
+		CGREvent: &utils.CGREvent{ //matching ATTR_USAGE_DIFF
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     "TestProcessAttributeUsageDifference",
+			Event: map[string]interface{}{
+				"Field1":       "Val1",
+				"RandomField":  "1514808000",
+				"RandomField2": "1514804400",
+				utils.Weight:   "20.0",
 			},
 		},
 	}
@@ -2224,9 +2134,7 @@ func TestProcessAttributeUsageDifference(t *testing.T) {
 	eRply := &AttrSProcessEventReply{
 		MatchedProfiles: []string{"ATTR_USAGE_DIFF"},
 		AlteredFields:   []string{utils.MetaReq + utils.NestingSep + "Field2"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: clnEv,
-		},
+		CGREvent:        clnEv,
 	}
 	if !reflect.DeepEqual(eRply, rcv) {
 		t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(eRply), utils.ToJSON(rcv))
@@ -2260,16 +2168,14 @@ func TestProcessAttributeSum(t *testing.T) {
 	}
 	ev := &AttrArgsProcessEvent{
 		Context: utils.StringPointer(utils.MetaSessionS),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{ //matching ATTR_SUM
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     "TestProcessAttributeSum",
-				Event: map[string]interface{}{
-					"Field1":       "Val1",
-					"RandomField":  "1",
-					"RandomField2": "5",
-					utils.Weight:   "20.0",
-				},
+		CGREvent: &utils.CGREvent{ //matching ATTR_SUM
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     "TestProcessAttributeSum",
+			Event: map[string]interface{}{
+				"Field1":       "Val1",
+				"RandomField":  "1",
+				"RandomField2": "5",
+				utils.Weight:   "20.0",
 			},
 		},
 	}
@@ -2289,9 +2195,7 @@ func TestProcessAttributeSum(t *testing.T) {
 	eRply := &AttrSProcessEventReply{
 		MatchedProfiles: []string{"ATTR_SUM"},
 		AlteredFields:   []string{utils.MetaReq + utils.NestingSep + "Field2"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: clnEv,
-		},
+		CGREvent:        clnEv,
 	}
 	if !reflect.DeepEqual(eRply, rcv) {
 		t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(eRply), utils.ToJSON(rcv))
@@ -2325,16 +2229,14 @@ func TestProcessAttributeDiff(t *testing.T) {
 	}
 	ev := &AttrArgsProcessEvent{
 		Context: utils.StringPointer(utils.MetaSessionS),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{ //matching ATTR_DIFF
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     "TestProcessAttributeDiff",
-				Event: map[string]interface{}{
-					"Field1":       "Val1",
-					"RandomField":  "1",
-					"RandomField2": "5",
-					utils.Weight:   "20.0",
-				},
+		CGREvent: &utils.CGREvent{ //matching ATTR_DIFF
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     "TestProcessAttributeDiff",
+			Event: map[string]interface{}{
+				"Field1":       "Val1",
+				"RandomField":  "1",
+				"RandomField2": "5",
+				utils.Weight:   "20.0",
 			},
 		},
 	}
@@ -2354,9 +2256,7 @@ func TestProcessAttributeDiff(t *testing.T) {
 	eRply := &AttrSProcessEventReply{
 		MatchedProfiles: []string{"ATTR_DIFF"},
 		AlteredFields:   []string{utils.MetaReq + utils.NestingSep + "Field2"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: clnEv,
-		},
+		CGREvent:        clnEv,
 	}
 	if !reflect.DeepEqual(eRply, rcv) {
 		t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(eRply), utils.ToJSON(rcv))
@@ -2390,16 +2290,14 @@ func TestProcessAttributeMultiply(t *testing.T) {
 	}
 	ev := &AttrArgsProcessEvent{
 		Context: utils.StringPointer(utils.MetaSessionS),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{ //matching ATTR_MULTIPLY
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     "TestProcessAttributeMultiply",
-				Event: map[string]interface{}{
-					"Field1":       "Val1",
-					"RandomField":  "1",
-					"RandomField2": "5",
-					utils.Weight:   "20.0",
-				},
+		CGREvent: &utils.CGREvent{ //matching ATTR_MULTIPLY
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     "TestProcessAttributeMultiply",
+			Event: map[string]interface{}{
+				"Field1":       "Val1",
+				"RandomField":  "1",
+				"RandomField2": "5",
+				utils.Weight:   "20.0",
 			},
 		},
 	}
@@ -2419,9 +2317,7 @@ func TestProcessAttributeMultiply(t *testing.T) {
 	eRply := &AttrSProcessEventReply{
 		MatchedProfiles: []string{"ATTR_MULTIPLY"},
 		AlteredFields:   []string{utils.MetaReq + utils.NestingSep + "Field2"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: clnEv,
-		},
+		CGREvent:        clnEv,
 	}
 	if !reflect.DeepEqual(eRply, rcv) {
 		t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(eRply), utils.ToJSON(rcv))
@@ -2455,16 +2351,14 @@ func TestProcessAttributeDivide(t *testing.T) {
 	}
 	ev := &AttrArgsProcessEvent{
 		Context: utils.StringPointer(utils.MetaSessionS),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{ //matching ATTR_DIVIDE
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     "TestProcessAttributeDivide",
-				Event: map[string]interface{}{
-					"Field1":       "Val1",
-					"RandomField":  "1",
-					"RandomField2": "5",
-					utils.Weight:   "20.0",
-				},
+		CGREvent: &utils.CGREvent{ //matching ATTR_DIVIDE
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     "TestProcessAttributeDivide",
+			Event: map[string]interface{}{
+				"Field1":       "Val1",
+				"RandomField":  "1",
+				"RandomField2": "5",
+				utils.Weight:   "20.0",
 			},
 		},
 	}
@@ -2484,9 +2378,7 @@ func TestProcessAttributeDivide(t *testing.T) {
 	eRply := &AttrSProcessEventReply{
 		MatchedProfiles: []string{"ATTR_DIVIDE"},
 		AlteredFields:   []string{utils.MetaReq + utils.NestingSep + "Field2"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: clnEv,
-		},
+		CGREvent:        clnEv,
 	}
 	if !reflect.DeepEqual(eRply, rcv) {
 		t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(eRply), utils.ToJSON(rcv))
@@ -2520,16 +2412,14 @@ func TestProcessAttributeValueExponent(t *testing.T) {
 	}
 	ev := &AttrArgsProcessEvent{
 		Context: utils.StringPointer(utils.MetaSessionS),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{ //matching ATTR_VAL_EXP
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     "TestProcessAttributeValueExponent",
-				Event: map[string]interface{}{
-					"Field1":       "Val1",
-					"RandomField":  "1",
-					"RandomField2": "5",
-					utils.Weight:   "20.0",
-				},
+		CGREvent: &utils.CGREvent{ //matching ATTR_VAL_EXP
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     "TestProcessAttributeValueExponent",
+			Event: map[string]interface{}{
+				"Field1":       "Val1",
+				"RandomField":  "1",
+				"RandomField2": "5",
+				utils.Weight:   "20.0",
 			},
 		},
 	}
@@ -2549,9 +2439,7 @@ func TestProcessAttributeValueExponent(t *testing.T) {
 	eRply := &AttrSProcessEventReply{
 		MatchedProfiles: []string{"ATTR_VAL_EXP"},
 		AlteredFields:   []string{utils.MetaReq + utils.NestingSep + "Field2"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: clnEv,
-		},
+		CGREvent:        clnEv,
 	}
 	if !reflect.DeepEqual(eRply, rcv) {
 		t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(eRply), utils.ToJSON(rcv))
@@ -2585,16 +2473,14 @@ func TestProcessAttributeUnixTimeStamp(t *testing.T) {
 	}
 	ev := &AttrArgsProcessEvent{
 		Context: utils.StringPointer(utils.MetaSessionS),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{ //matching ATTR_UNIX_TIMESTAMP
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     "TestProcessAttributeUnixTimeStamp",
-				Event: map[string]interface{}{
-					"Field1":       "Val1",
-					"RandomField":  "1",
-					"RandomField2": "2013-12-30T15:00:01Z",
-					utils.Weight:   "20.0",
-				},
+		CGREvent: &utils.CGREvent{ //matching ATTR_UNIX_TIMESTAMP
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     "TestProcessAttributeUnixTimeStamp",
+			Event: map[string]interface{}{
+				"Field1":       "Val1",
+				"RandomField":  "1",
+				"RandomField2": "2013-12-30T15:00:01Z",
+				utils.Weight:   "20.0",
 			},
 		},
 	}
@@ -2614,9 +2500,7 @@ func TestProcessAttributeUnixTimeStamp(t *testing.T) {
 	eRply := &AttrSProcessEventReply{
 		MatchedProfiles: []string{"ATTR_UNIX_TIMESTAMP"},
 		AlteredFields:   []string{utils.MetaReq + utils.NestingSep + "Field2"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: clnEv,
-		},
+		CGREvent:        clnEv,
 	}
 	if !reflect.DeepEqual(eRply, rcv) {
 		t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(eRply), utils.ToJSON(rcv))
@@ -2650,15 +2534,13 @@ func TestProcessAttributePrefix(t *testing.T) {
 	}
 	ev := &AttrArgsProcessEvent{
 		Context: utils.StringPointer(utils.MetaSessionS),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{ //matching ATTR_VAL_EXP
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     "TestProcessAttributeValueExponent",
-				Event: map[string]interface{}{
-					"ATTR":       "ATTR_PREFIX",
-					"Field2":     "Val2",
-					utils.Weight: "20.0",
-				},
+		CGREvent: &utils.CGREvent{ //matching ATTR_VAL_EXP
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     "TestProcessAttributeValueExponent",
+			Event: map[string]interface{}{
+				"ATTR":       "ATTR_PREFIX",
+				"Field2":     "Val2",
+				utils.Weight: "20.0",
 			},
 		},
 	}
@@ -2678,9 +2560,7 @@ func TestProcessAttributePrefix(t *testing.T) {
 	eRply := &AttrSProcessEventReply{
 		MatchedProfiles: []string{"ATTR_PREFIX"},
 		AlteredFields:   []string{utils.MetaReq + utils.NestingSep + "Field2"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: clnEv,
-		},
+		CGREvent:        clnEv,
 	}
 	if !reflect.DeepEqual(eRply, rcv) {
 		t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(eRply), utils.ToJSON(rcv))
@@ -2714,15 +2594,13 @@ func TestProcessAttributeSuffix(t *testing.T) {
 	}
 	ev := &AttrArgsProcessEvent{
 		Context: utils.StringPointer(utils.MetaSessionS),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{ //matching ATTR_VAL_EXP
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     "TestProcessAttributeValueExponent",
-				Event: map[string]interface{}{
-					"ATTR":       "ATTR_SUFFIX",
-					"Field2":     "Val2",
-					utils.Weight: "20.0",
-				},
+		CGREvent: &utils.CGREvent{ //matching ATTR_VAL_EXP
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     "TestProcessAttributeValueExponent",
+			Event: map[string]interface{}{
+				"ATTR":       "ATTR_SUFFIX",
+				"Field2":     "Val2",
+				utils.Weight: "20.0",
 			},
 		},
 	}
@@ -2742,9 +2620,7 @@ func TestProcessAttributeSuffix(t *testing.T) {
 	eRply := &AttrSProcessEventReply{
 		MatchedProfiles: []string{"ATTR_SUFFIX"},
 		AlteredFields:   []string{utils.MetaReq + utils.NestingSep + "Field2"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: clnEv,
-		},
+		CGREvent:        clnEv,
 	}
 	if !reflect.DeepEqual(eRply, rcv) {
 		t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(eRply), utils.ToJSON(rcv))
@@ -2798,13 +2674,11 @@ func TestAttributeIndexSelectsFalse(t *testing.T) {
 	attrArgs := &AttrArgsProcessEvent{
 		Context:     utils.StringPointer(utils.MetaSessionS),
 		ProcessRuns: utils.IntPointer(1),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"Account": "1007",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"Account": "1007",
 			},
 		},
 	}
@@ -2861,15 +2735,13 @@ func TestProcessAttributeWithSameWeight(t *testing.T) {
 	ev := &AttrArgsProcessEvent{
 		ProcessRuns: utils.IntPointer(2),
 		Context:     utils.StringPointer(utils.MetaSessionS),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{ //matching ATTR_UNIX_TIMESTAMP
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     "TestProcessAttributeUnixTimeStamp",
-				Event: map[string]interface{}{
-					"Field1":      "Val1",
-					"RandomField": "1",
-					utils.Weight:  "20.0",
-				},
+		CGREvent: &utils.CGREvent{ //matching ATTR_UNIX_TIMESTAMP
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     "TestProcessAttributeUnixTimeStamp",
+			Event: map[string]interface{}{
+				"Field1":      "Val1",
+				"RandomField": "1",
+				utils.Weight:  "20.0",
 			},
 		},
 	}
@@ -2883,9 +2755,7 @@ func TestProcessAttributeWithSameWeight(t *testing.T) {
 	eRply := AttrSProcessEventReply{
 		MatchedProfiles: []string{"ATTR_1", "ATTR_2"},
 		AlteredFields:   []string{utils.MetaReq + utils.NestingSep + "Field2", utils.MetaReq + utils.NestingSep + "Field3"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: clnEv,
-		},
+		CGREvent:        clnEv,
 	}
 	sort.Strings(rcv.MatchedProfiles)
 	sort.Strings(rcv.AlteredFields)
@@ -2950,13 +2820,11 @@ func TestAttributeMultipleProcessWithFiltersExists(t *testing.T) {
 	attrArgs := &AttrArgsProcessEvent{
 		Context:     utils.StringPointer(utils.MetaSessionS),
 		ProcessRuns: utils.IntPointer(4),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"InitialField": "InitialValue",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"InitialField": "InitialValue",
 			},
 		},
 	}
@@ -2964,15 +2832,13 @@ func TestAttributeMultipleProcessWithFiltersExists(t *testing.T) {
 		MatchedProfiles: []string{"ATTR_1_EXISTS", "ATTR_2_EXISTS", "ATTR_1_EXISTS", "ATTR_2_EXISTS"},
 		AlteredFields: []string{utils.MetaReq + utils.NestingSep + "Field1",
 			utils.MetaReq + utils.NestingSep + "Field2"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"InitialField": "InitialValue",
-					"Field1":       "Value1",
-					"Field2":       "Value2",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"InitialField": "InitialValue",
+				"Field1":       "Value1",
+				"Field2":       "Value2",
 			},
 		},
 	}
@@ -3048,13 +2914,11 @@ func TestAttributeMultipleProcessWithFiltersNotEmpty(t *testing.T) {
 	attrArgs := &AttrArgsProcessEvent{
 		Context:     utils.StringPointer(utils.MetaSessionS),
 		ProcessRuns: utils.IntPointer(4),
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"InitialField": "InitialValue",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"InitialField": "InitialValue",
 			},
 		},
 	}
@@ -3062,15 +2926,13 @@ func TestAttributeMultipleProcessWithFiltersNotEmpty(t *testing.T) {
 		MatchedProfiles: []string{"ATTR_1_NOTEMPTY", "ATTR_2_NOTEMPTY", "ATTR_1_NOTEMPTY", "ATTR_2_NOTEMPTY"},
 		AlteredFields: []string{utils.MetaReq + utils.NestingSep + "Field1",
 			utils.MetaReq + utils.NestingSep + "Field2"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     utils.GenUUID(),
-				Event: map[string]interface{}{
-					"InitialField": "InitialValue",
-					"Field1":       "Value1",
-					"Field2":       "Value2",
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     utils.GenUUID(),
+			Event: map[string]interface{}{
+				"InitialField": "InitialValue",
+				"Field1":       "Value1",
+				"Field2":       "Value2",
 			},
 		},
 	}
diff --git a/engine/z_resources_test.go b/engine/z_resources_test.go
index 431fdab08..cf60ea443 100644
--- a/engine/z_resources_test.go
+++ b/engine/z_resources_test.go
@@ -97,44 +97,38 @@ var (
 			rPrf:   resprf[2],
 		},
 	}
-	resEvs = []*utils.CGREventWithOpts{
+	resEvs = []*utils.CGREvent{
 		{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     "event1",
-				Event: map[string]interface{}{
-					"Resources":      "ResourceProfile1",
-					utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
-					"UsageInterval":  "1s",
-					"PddInterval":    "1s",
-					utils.Weight:     "20.0",
-					utils.Usage:      135 * time.Second,
-					utils.Cost:       123.0,
-				},
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     "event1",
+			Event: map[string]interface{}{
+				"Resources":      "ResourceProfile1",
+				utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
+				"UsageInterval":  "1s",
+				"PddInterval":    "1s",
+				utils.Weight:     "20.0",
+				utils.Usage:      135 * time.Second,
+				utils.Cost:       123.0,
 			},
 		},
 		{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     "event2",
-				Event: map[string]interface{}{
-					"Resources":      "ResourceProfile2",
-					utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
-					"UsageInterval":  "1s",
-					"PddInterval":    "1s",
-					utils.Weight:     "15.0",
-					utils.Usage:      45 * time.Second,
-				},
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     "event2",
+			Event: map[string]interface{}{
+				"Resources":      "ResourceProfile2",
+				utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC),
+				"UsageInterval":  "1s",
+				"PddInterval":    "1s",
+				utils.Weight:     "15.0",
+				utils.Usage:      45 * time.Second,
 			},
 		},
 		{
-			CGREvent: &utils.CGREvent{
-				Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-				ID:     "event3",
-				Event: map[string]interface{}{
-					"Resources": "ResourceProfilePrefix",
-					utils.Usage: 30 * time.Second,
-				},
+			Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
+			ID:     "event3",
+			Event: map[string]interface{}{
+				"Resources": "ResourceProfilePrefix",
+				utils.Usage: 30 * time.Second,
 			},
 		},
 	}
@@ -385,22 +379,18 @@ func TestResourcePopulateResourceService(t *testing.T) {
 func TestResourceV1AuthorizeResourceMissingStruct(t *testing.T) {
 	var reply *string
 	argsMissingTenant := utils.ArgRSv1ResourceUsage{
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				ID:    "id1",
-				Event: map[string]interface{}{},
-			},
+		CGREvent: &utils.CGREvent{
+			ID:    "id1",
+			Event: map[string]interface{}{},
 		},
 		UsageID: "test1", // ResourceUsage Identifier
 		Units:   20,
 	}
 	argsMissingUsageID := utils.ArgRSv1ResourceUsage{
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: "cgrates.org",
-				ID:     "id1",
-				Event:  map[string]interface{}{},
-			},
+		CGREvent: &utils.CGREvent{
+			Tenant: "cgrates.org",
+			ID:     "id1",
+			Event:  map[string]interface{}{},
 		},
 		Units: 20,
 	}
@@ -773,14 +763,12 @@ func TestResourceCaching(t *testing.T) {
 		t.Errorf("Expecting: nil, received: %s", err)
 	}
 
-	ev := &utils.CGREventWithOpts{
-		CGREvent: &utils.CGREvent{
-			Tenant: "cgrates.org",
-			ID:     utils.UUIDSha1Prefix(),
-			Event: map[string]interface{}{
-				"Account":     "1001",
-				"Destination": "3002"},
-		},
+	ev := &utils.CGREvent{
+		Tenant: "cgrates.org",
+		ID:     utils.UUIDSha1Prefix(),
+		Event: map[string]interface{}{
+			"Account":     "1001",
+			"Destination": "3002"},
 	}
 
 	mres, err := resService.matchingResourcesForEvent(ev.Tenant, ev,
diff --git a/ers/amqp.go b/ers/amqp.go
index 53c36e00d..827d171f7 100644
--- a/ers/amqp.go
+++ b/ers/amqp.go
@@ -200,10 +200,11 @@ func (rdr *AMQPER) processMessage(msg []byte) (err error) {
 	if err = agReq.SetFields(rdr.Config().Fields); err != nil {
 		return
 	}
+	cgrEv := config.NMAsCGREvent(agReq.CGRRequest, agReq.Tenant, utils.NestingSep)
+	cgrEv.Opts = config.NMAsMapInterface(agReq.Opts, utils.NestingSep)
 	rdr.rdrEvents <- &erEvent{
-		cgrEvent: config.NMAsCGREvent(agReq.CGRRequest, agReq.Tenant, utils.NestingSep),
+		cgrEvent: cgrEv,
 		rdrCfg:   rdr.Config(),
-		opts:     config.NMAsMapInterface(agReq.Opts, utils.NestingSep),
 	}
 	return
 }
diff --git a/ers/amqpv1.go b/ers/amqpv1.go
index 0e6159219..514bf5429 100644
--- a/ers/amqpv1.go
+++ b/ers/amqpv1.go
@@ -175,10 +175,11 @@ func (rdr *AMQPv1ER) processMessage(msg []byte) (err error) {
 	if err = agReq.SetFields(rdr.Config().Fields); err != nil {
 		return
 	}
+	cgrEv := config.NMAsCGREvent(agReq.CGRRequest, agReq.Tenant, utils.NestingSep)
+	cgrEv.Opts = config.NMAsMapInterface(agReq.Opts, utils.NestingSep)
 	rdr.rdrEvents <- &erEvent{
-		cgrEvent: config.NMAsCGREvent(agReq.CGRRequest, agReq.Tenant, utils.NestingSep),
+		cgrEvent: cgrEv,
 		rdrCfg:   rdr.Config(),
-		opts:     config.NMAsMapInterface(agReq.Opts, utils.NestingSep),
 	}
 	return
 }
diff --git a/ers/filejson.go b/ers/filejson.go
index 9bcb4bb14..24632ab11 100644
--- a/ers/filejson.go
+++ b/ers/filejson.go
@@ -166,10 +166,11 @@ func (rdr *JSONFileER) processFile(fPath, fName string) (err error) {
 				utils.ERs, absPath, err.Error()))
 		return
 	}
+	cgrEv := config.NMAsCGREvent(agReq.CGRRequest, agReq.Tenant, utils.NestingSep)
+	cgrEv.Opts = config.NMAsMapInterface(agReq.Opts, utils.NestingSep)
 	rdr.rdrEvents <- &erEvent{
-		cgrEvent: config.NMAsCGREvent(agReq.CGRRequest, agReq.Tenant, utils.NestingSep),
+		cgrEvent: cgrEv,
 		rdrCfg:   rdr.Config(),
-		opts:     config.NMAsMapInterface(agReq.Opts, utils.NestingSep),
 	}
 	evsPosted++
 
diff --git a/ers/filexml.go b/ers/filexml.go
index 4590fb9dd..2a1233224 100644
--- a/ers/filexml.go
+++ b/ers/filexml.go
@@ -164,10 +164,11 @@ func (rdr *XMLFileER) processFile(fPath, fName string) (err error) {
 					utils.ERs, absPath, rowNr, err.Error()))
 			continue
 		}
+		cgrEv := config.NMAsCGREvent(agReq.CGRRequest, agReq.Tenant, utils.NestingSep)
+		cgrEv.Opts = config.NMAsMapInterface(agReq.Opts, utils.NestingSep)
 		rdr.rdrEvents <- &erEvent{
-			cgrEvent: config.NMAsCGREvent(agReq.CGRRequest, agReq.Tenant, utils.NestingSep),
+			cgrEvent: cgrEv,
 			rdrCfg:   rdr.Config(),
-			opts:     config.NMAsMapInterface(agReq.Opts, utils.NestingSep),
 		}
 		evsPosted++
 	}
diff --git a/ers/flatstore.go b/ers/flatstore.go
index 62160babc..949175109 100644
--- a/ers/flatstore.go
+++ b/ers/flatstore.go
@@ -214,10 +214,11 @@ func (rdr *FlatstoreER) processFile(fPath, fName string) (err error) {
 			return
 		}
 
+		cgrEv := config.NMAsCGREvent(agReq.CGRRequest, agReq.Tenant, utils.NestingSep)
+		cgrEv.Opts = config.NMAsMapInterface(agReq.Opts, utils.NestingSep)
 		rdr.rdrEvents <- &erEvent{
-			cgrEvent: config.NMAsCGREvent(agReq.CGRRequest, agReq.Tenant, utils.NestingSep),
+			cgrEvent: cgrEv,
 			rdrCfg:   rdr.Config(),
-			opts:     config.NMAsMapInterface(agReq.Opts, utils.NestingSep),
 		}
 		evsPosted++
 	}
diff --git a/ers/kafka.go b/ers/kafka.go
index 449124067..6de521d30 100644
--- a/ers/kafka.go
+++ b/ers/kafka.go
@@ -172,10 +172,11 @@ func (rdr *KafkaER) processMessage(msg []byte) (err error) {
 	if err = agReq.SetFields(rdr.Config().Fields); err != nil {
 		return
 	}
+	cgrEv := config.NMAsCGREvent(agReq.CGRRequest, agReq.Tenant, utils.NestingSep)
+	cgrEv.Opts = config.NMAsMapInterface(agReq.Opts, utils.NestingSep)
 	rdr.rdrEvents <- &erEvent{
-		cgrEvent: config.NMAsCGREvent(agReq.CGRRequest, agReq.Tenant, utils.NestingSep),
+		cgrEvent: cgrEv,
 		rdrCfg:   rdr.Config(),
-		opts:     config.NMAsMapInterface(agReq.Opts, utils.NestingSep),
 	}
 	return
 }
diff --git a/ers/partial_csv.go b/ers/partial_csv.go
index f32abf679..9eedecb3d 100644
--- a/ers/partial_csv.go
+++ b/ers/partial_csv.go
@@ -40,11 +40,6 @@ import (
 	"github.com/cgrates/cgrates/utils"
 )
 
-type cgrEventWithOpts struct {
-	*utils.CGREvent
-	Opts map[string]interface{}
-}
-
 func NewPartialCSVFileER(cfg *config.CGRConfig, cfgIdx int,
 	rdrEvents chan *erEvent, rdrErr chan error,
 	fltrS *engine.FilterS, rdrExit chan struct{}) (er EventReader, err error) {
@@ -222,27 +217,22 @@ func (rdr *PartialCSVFileER) processFile(fPath, fName string) (err error) {
 		cgrID := utils.Sha1(orgID, orgHost)
 		// take Partial field from NavigableMap
 		partial, _ := agReq.CGRRequest.FieldAsString([]string{utils.Partial})
+		cgrEv := config.NMAsCGREvent(agReq.CGRRequest, agReq.Tenant, utils.NestingSep)
+		cgrEv.Opts = config.NMAsMapInterface(agReq.Opts, utils.NestingSep)
 		if val, has := rdr.cache.Get(cgrID); !has {
 			if utils.IsSliceMember([]string{"false", utils.EmptyString}, partial) { // complete CDR
 				rdr.rdrEvents <- &erEvent{
-					cgrEvent: config.NMAsCGREvent(agReq.CGRRequest, agReq.Tenant, utils.NestingSep),
+					cgrEvent: cgrEv,
 					rdrCfg:   rdr.Config(),
-					opts:     config.NMAsMapInterface(agReq.Opts, utils.NestingSep),
 				}
 				evsPosted++
 			} else {
 				rdr.cache.Set(cgrID,
-					[]*cgrEventWithOpts{{
-						CGREvent: config.NMAsCGREvent(agReq.CGRRequest, agReq.Tenant, utils.NestingSep),
-						Opts:     config.NMAsMapInterface(agReq.Opts, utils.NestingSep),
-					}}, nil)
+					[]*utils.CGREvent{cgrEv}, nil)
 			}
 		} else {
-			origCgrEvs := val.([]*cgrEventWithOpts)
-			origCgrEvs = append(origCgrEvs, &cgrEventWithOpts{
-				CGREvent: config.NMAsCGREvent(agReq.CGRRequest, agReq.Tenant, utils.NestingSep),
-				Opts:     config.NMAsMapInterface(agReq.Opts, utils.NestingSep),
-			})
+			origCgrEvs := val.([]*utils.CGREvent)
+			origCgrEvs = append(origCgrEvs, cgrEv)
 			if utils.IsSliceMember([]string{"false", utils.EmptyString}, partial) { // complete CDR
 				//sort CGREvents based on AnswertTime and SetupTime
 				sort.Slice(origCgrEvs, func(i, j int) bool {
@@ -259,7 +249,7 @@ func (rdr *PartialCSVFileER) processFile(fPath, fName string) (err error) {
 				cgrEv := new(utils.CGREvent)
 				cgrEv.ID = utils.UUIDSha1Prefix()
 				cgrEv.Time = utils.TimePointer(time.Now())
-				opts := map[string]interface{}{}
+				cgrEv.Opts = map[string]interface{}{}
 				for i, origCgrEv := range origCgrEvs {
 					if i == 0 {
 						cgrEv.Tenant = origCgrEv.Tenant
@@ -268,13 +258,12 @@ func (rdr *PartialCSVFileER) processFile(fPath, fName string) (err error) {
 						cgrEv.Event[key] = value
 					}
 					for key, val := range origCgrEv.Opts {
-						opts[key] = val
+						cgrEv.Opts[key] = val
 					}
 				}
 				rdr.rdrEvents <- &erEvent{
 					cgrEvent: cgrEv,
 					rdrCfg:   rdr.Config(),
-					opts:     opts,
 				}
 				evsPosted++
 				rdr.cache.Remove(cgrID)
@@ -302,7 +291,7 @@ func (rdr *PartialCSVFileER) processFile(fPath, fName string) (err error) {
 func (rdr *PartialCSVFileER) dumpToFile(itmID string, value interface{}) {
 	tmz := utils.FirstNonEmpty(rdr.Config().Timezone,
 		rdr.cgrCfg.GeneralCfg().DefaultTimezone)
-	origCgrEvs := value.([]*cgrEventWithOpts)
+	origCgrEvs := value.([]*utils.CGREvent)
 	for _, origCgrEv := range origCgrEvs {
 		// complete CDR are handling in processFile function
 		if partial, _ := origCgrEv.FieldAsString(utils.Partial); utils.IsSliceMember([]string{"false", utils.EmptyString}, partial) {
@@ -370,7 +359,7 @@ func (rdr *PartialCSVFileER) dumpToFile(itmID string, value interface{}) {
 func (rdr *PartialCSVFileER) postCDR(itmID string, value interface{}) {
 	tmz := utils.FirstNonEmpty(rdr.Config().Timezone,
 		rdr.cgrCfg.GeneralCfg().DefaultTimezone)
-	origCgrEvs := value.([]*cgrEventWithOpts)
+	origCgrEvs := value.([]*utils.CGREvent)
 	for _, origCgrEv := range origCgrEvs {
 		// complete CDR are handling in processFile function
 		if partial, _ := origCgrEv.FieldAsString(utils.Partial); utils.IsSliceMember([]string{"false", utils.EmptyString}, partial) {
@@ -395,8 +384,8 @@ func (rdr *PartialCSVFileER) postCDR(itmID string, value interface{}) {
 		ID:    utils.UUIDSha1Prefix(),
 		Time:  utils.TimePointer(time.Now()),
 		Event: make(map[string]interface{}),
+		Opts:  make(map[string]interface{}),
 	}
-	opts := map[string]interface{}{}
 	for i, origCgrEv := range origCgrEvs {
 		if i == 0 {
 			cgrEv.Tenant = origCgrEv.Tenant
@@ -405,12 +394,11 @@ func (rdr *PartialCSVFileER) postCDR(itmID string, value interface{}) {
 			cgrEv.Event[key] = value
 		}
 		for key, val := range origCgrEv.Opts {
-			opts[key] = val
+			cgrEv.Opts[key] = val
 		}
 	}
 	rdr.rdrEvents <- &erEvent{
 		cgrEvent: cgrEv,
 		rdrCfg:   rdr.Config(),
-		opts:     opts,
 	}
 }
diff --git a/ers/s3.go b/ers/s3.go
index 43fc8bef4..0e70be233 100644
--- a/ers/s3.go
+++ b/ers/s3.go
@@ -129,10 +129,11 @@ func (rdr *S3ER) processMessage(body []byte) (err error) {
 	if err = agReq.SetFields(rdr.Config().Fields); err != nil {
 		return
 	}
+	cgrEv := config.NMAsCGREvent(agReq.CGRRequest, agReq.Tenant, utils.NestingSep)
+	cgrEv.Opts = config.NMAsMapInterface(agReq.Opts, utils.NestingSep)
 	rdr.rdrEvents <- &erEvent{
-		cgrEvent: config.NMAsCGREvent(agReq.CGRRequest, agReq.Tenant, utils.NestingSep),
+		cgrEvent: cgrEv,
 		rdrCfg:   rdr.Config(),
-		opts:     config.NMAsMapInterface(agReq.Opts, utils.NestingSep),
 	}
 	return
 }
diff --git a/ers/sql.go b/ers/sql.go
index 8fb7fc321..df5ff78f5 100644
--- a/ers/sql.go
+++ b/ers/sql.go
@@ -249,10 +249,11 @@ func (rdr *SQLEventReader) processMessage(msg map[string]interface{}) (err error
 	if err = agReq.SetFields(rdr.Config().Fields); err != nil {
 		return
 	}
+	cgrEv := config.NMAsCGREvent(agReq.CGRRequest, agReq.Tenant, utils.NestingSep)
+	cgrEv.Opts = config.NMAsMapInterface(agReq.Opts, utils.NestingSep)
 	rdr.rdrEvents <- &erEvent{
-		cgrEvent: config.NMAsCGREvent(agReq.CGRRequest, agReq.Tenant, utils.NestingSep),
+		cgrEvent: cgrEv,
 		rdrCfg:   rdr.Config(),
-		opts:     config.NMAsMapInterface(agReq.Opts, utils.NestingSep),
 	}
 	return
 }
diff --git a/ers/sqs.go b/ers/sqs.go
index 3e5a2cba2..4587c00e7 100644
--- a/ers/sqs.go
+++ b/ers/sqs.go
@@ -115,10 +115,11 @@ func (rdr *SQSER) processMessage(body []byte) (err error) {
 	if err = agReq.SetFields(rdr.Config().Fields); err != nil {
 		return
 	}
+	cgrEv := config.NMAsCGREvent(agReq.CGRRequest, agReq.Tenant, utils.NestingSep)
+	cgrEv.Opts = config.NMAsMapInterface(agReq.Opts, utils.NestingSep)
 	rdr.rdrEvents <- &erEvent{
-		cgrEvent: config.NMAsCGREvent(agReq.CGRRequest, agReq.Tenant, utils.NestingSep),
+		cgrEvent: cgrEv,
 		rdrCfg:   rdr.Config(),
-		opts:     config.NMAsMapInterface(agReq.Opts, utils.NestingSep),
 	}
 	return
 }
diff --git a/sessions/libsessions_test.go b/sessions/libsessions_test.go
index a64f7de1c..659625f8f 100644
--- a/sessions/libsessions_test.go
+++ b/sessions/libsessions_test.go
@@ -297,14 +297,14 @@ aa+jqv4dwkr/FLEcN1zC76Y/IniI65fId55hVJvN3ORuzUqYEtzD3irmsw==
 }
 
 func TestGetDerivedEvents(t *testing.T) {
-	events := map[string]*utils.CGREventWithOpts{
+	events := map[string]*utils.CGREvent{
 		utils.MetaRaw: {},
 		"DEFAULT":     {},
 	}
 	if rply := getDerivedEvents(events, true); !reflect.DeepEqual(events, rply) {
 		t.Errorf("Expected %s received %s", utils.ToJSON(events), utils.ToJSON(rply))
 	}
-	exp := map[string]*utils.CGREventWithOpts{
+	exp := map[string]*utils.CGREvent{
 		utils.MetaRaw: events[utils.MetaRaw],
 	}
 	if rply := getDerivedEvents(events, false); !reflect.DeepEqual(exp, rply) {
diff --git a/sessions/sessions_bench_test.go b/sessions/sessions_bench_test.go
index 290e16d8b..36eed1194 100644
--- a/sessions/sessions_bench_test.go
+++ b/sessions/sessions_bench_test.go
@@ -108,18 +108,16 @@ func initSession(i int) {
 	defer func() { maxCps <- oneCps }()
 	initArgs := &V1InitSessionArgs{
 		InitSession: true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: &utils.CGREvent{
-				Tenant: "cgrates.org",
-				ID:     "",
-				Event: map[string]interface{}{
-					utils.EventName:   "TEST_EVENT",
-					utils.ToR:         utils.MetaVoice,
-					utils.Category:    "call",
-					utils.Tenant:      "cgrates.org",
-					utils.RequestType: utils.MetaPrepaid,
-					utils.AnswerTime:  time.Date(2016, time.January, 5, 18, 31, 05, 0, time.UTC),
-				},
+		CGREvent: &utils.CGREvent{
+			Tenant: "cgrates.org",
+			ID:     "",
+			Event: map[string]interface{}{
+				utils.EventName:   "TEST_EVENT",
+				utils.ToR:         utils.MetaVoice,
+				utils.Category:    "call",
+				utils.Tenant:      "cgrates.org",
+				utils.RequestType: utils.MetaPrepaid,
+				utils.AnswerTime:  time.Date(2016, time.January, 5, 18, 31, 05, 0, time.UTC),
 			},
 		},
 	}
diff --git a/sessions/sessions_test.go b/sessions/sessions_test.go
index e72a61bf3..107e42d50 100644
--- a/sessions/sessions_test.go
+++ b/sessions/sessions_test.go
@@ -36,24 +36,22 @@ import (
 var attrs = &engine.AttrSProcessEventReply{
 	MatchedProfiles: []string{"ATTR_ACNT_1001"},
 	AlteredFields:   []string{"*req.OfficeGroup"},
-	CGREventWithOpts: &utils.CGREventWithOpts{
-		CGREvent: &utils.CGREvent{
-			Tenant: "cgrates.org",
-			ID:     "TestSSv1ItAuth",
-			Event: map[string]interface{}{
-				utils.CGRID:        "5668666d6b8e44eb949042f25ce0796ec3592ff9",
-				utils.Tenant:       "cgrates.org",
-				utils.Category:     "call",
-				utils.ToR:          utils.MetaVoice,
-				utils.AccountField: "1001",
-				utils.Subject:      "ANY2CNT",
-				utils.Destination:  "1002",
-				"OfficeGroup":      "Marketing",
-				utils.OriginID:     "TestSSv1It1",
-				utils.RequestType:  utils.MetaPrepaid,
-				utils.SetupTime:    "2018-01-07T17:00:00Z",
-				utils.Usage:        300000000000.0,
-			},
+	CGREvent: &utils.CGREvent{
+		Tenant: "cgrates.org",
+		ID:     "TestSSv1ItAuth",
+		Event: map[string]interface{}{
+			utils.CGRID:        "5668666d6b8e44eb949042f25ce0796ec3592ff9",
+			utils.Tenant:       "cgrates.org",
+			utils.Category:     "call",
+			utils.ToR:          utils.MetaVoice,
+			utils.AccountField: "1001",
+			utils.Subject:      "ANY2CNT",
+			utils.Destination:  "1002",
+			"OfficeGroup":      "Marketing",
+			utils.OriginID:     "TestSSv1It1",
+			utils.RequestType:  utils.MetaPrepaid,
+			utils.SetupTime:    "2018-01-07T17:00:00Z",
+			utils.Usage:        300000000000.0,
 		},
 	},
 }
@@ -857,12 +855,10 @@ func TestSessionSNewV1AuthorizeArgs(t *testing.T) {
 	expected := &V1AuthorizeArgs{
 		AuthorizeResources: true,
 		GetAttributes:      true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: cgrEv,
-		},
-		ForceDuration: true,
+		CGREvent:           cgrEv,
+		ForceDuration:      true,
 	}
-	rply := NewV1AuthorizeArgs(true, nil, false, nil, false, nil, true, false, false, false, false, cgrEv, utils.Paginator{}, true, nil)
+	rply := NewV1AuthorizeArgs(true, nil, false, nil, false, nil, true, false, false, false, false, cgrEv, utils.Paginator{}, true)
 	if !reflect.DeepEqual(expected, rply) {
 		t.Errorf("Expecting %+v, received: %+v", expected, rply)
 	}
@@ -875,12 +871,10 @@ func TestSessionSNewV1AuthorizeArgs(t *testing.T) {
 		GetRoutes:          false,
 		RoutesIgnoreErrors: true,
 		RoutesMaxCost:      utils.MetaRoutesEventCost,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: cgrEv,
-		},
-		ForceDuration: true,
+		CGREvent:           cgrEv,
+		ForceDuration:      true,
 	}
-	rply = NewV1AuthorizeArgs(true, nil, false, nil, true, nil, false, true, false, true, true, cgrEv, utils.Paginator{}, true, nil)
+	rply = NewV1AuthorizeArgs(true, nil, false, nil, true, nil, false, true, false, true, true, cgrEv, utils.Paginator{}, true)
 	if !reflect.DeepEqual(expected, rply) {
 		t.Errorf("Expecting %+v,\n received: %+v", expected, rply)
 	}
@@ -897,15 +891,13 @@ func TestSessionSNewV1AuthorizeArgs(t *testing.T) {
 		GetRoutes:          false,
 		RoutesIgnoreErrors: true,
 		RoutesMaxCost:      utils.MetaRoutesEventCost,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: cgrEv,
-		},
-		AttributeIDs: []string{"ATTR1", "ATTR2"},
-		ThresholdIDs: []string{"ID1", "ID2"},
-		StatIDs:      []string{"test3", "test4"},
+		CGREvent:           cgrEv,
+		AttributeIDs:       []string{"ATTR1", "ATTR2"},
+		ThresholdIDs:       []string{"ID1", "ID2"},
+		StatIDs:            []string{"test3", "test4"},
 	}
 	rply = NewV1AuthorizeArgs(true, attributeIDs, false, thresholdIDs,
-		true, statIDs, false, true, false, true, true, cgrEv, utils.Paginator{}, false, nil)
+		true, statIDs, false, true, false, true, true, cgrEv, utils.Paginator{}, false)
 	if !reflect.DeepEqual(expected, rply) {
 		t.Errorf("Expecting %+v,\n received: %+v", expected, rply)
 	}
@@ -913,9 +905,9 @@ func TestSessionSNewV1AuthorizeArgs(t *testing.T) {
 
 func TestV1AuthorizeArgsParseFlags(t *testing.T) {
 	v1authArgs := new(V1AuthorizeArgs)
-	v1authArgs.CGREventWithOpts = new(utils.CGREventWithOpts)
+	v1authArgs.CGREvent = new(utils.CGREvent)
 	eOut := new(V1AuthorizeArgs)
-	eOut.CGREventWithOpts = new(utils.CGREventWithOpts)
+	eOut.CGREvent = new(utils.CGREvent)
 	//empty check
 	strArg := ""
 	v1authArgs.ParseFlags(strArg)
@@ -937,7 +929,7 @@ func TestV1AuthorizeArgsParseFlags(t *testing.T) {
 		ProcessStats:       true,
 		StatIDs:            []string{"st1", "st2", "st3"},
 		Paginator:          cgrArgs,
-		CGREventWithOpts:   eOut.CGREventWithOpts,
+		CGREvent:           eOut.CGREvent,
 		ForceDuration:      true,
 	}
 
@@ -961,7 +953,7 @@ func TestV1AuthorizeArgsParseFlags(t *testing.T) {
 		ProcessStats:       true,
 		StatIDs:            []string{"st1", "st2", "st3"},
 		Paginator:          cgrArgs,
-		CGREventWithOpts:   eOut.CGREventWithOpts,
+		CGREvent:           eOut.CGREvent,
 		ForceDuration:      true,
 	}
 
@@ -984,30 +976,26 @@ func TestSessionSNewV1UpdateSessionArgs(t *testing.T) {
 	expected := &V1UpdateSessionArgs{
 		GetAttributes: true,
 		UpdateSession: true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: cgrEv,
-		},
+		CGREvent:      cgrEv,
 		ForceDuration: true,
 	}
-	rply := NewV1UpdateSessionArgs(true, nil, true, cgrEv, true, nil)
+	rply := NewV1UpdateSessionArgs(true, nil, true, cgrEv, true)
 	if !reflect.DeepEqual(expected, rply) {
 		t.Errorf("Expecting %+v, received: %+v", expected, rply)
 	}
 	expected = &V1UpdateSessionArgs{
 		GetAttributes: false,
 		UpdateSession: true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: cgrEv,
-		},
+		CGREvent:      cgrEv,
 		ForceDuration: true,
 	}
-	rply = NewV1UpdateSessionArgs(false, nil, true, cgrEv, true, nil)
+	rply = NewV1UpdateSessionArgs(false, nil, true, cgrEv, true)
 	if !reflect.DeepEqual(expected, rply) {
 		t.Errorf("Expecting %+v, received: %+v", expected, rply)
 	}
 	//test with len(AttributeIDs) != 0
 	attributeIDs := []string{"ATTR1", "ATTR2"}
-	rply = NewV1UpdateSessionArgs(false, attributeIDs, true, cgrEv, true, nil)
+	rply = NewV1UpdateSessionArgs(false, attributeIDs, true, cgrEv, true)
 	expected.AttributeIDs = []string{"ATTR1", "ATTR2"}
 	if !reflect.DeepEqual(expected, rply) {
 		t.Errorf("Expecting %+v, received: %+v", expected, rply)
@@ -1026,22 +1014,18 @@ func TestSessionSNewV1TerminateSessionArgs(t *testing.T) {
 	expected := &V1TerminateSessionArgs{
 		TerminateSession:  true,
 		ProcessThresholds: true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: cgrEv,
-		},
-		ForceDuration: true,
+		CGREvent:          cgrEv,
+		ForceDuration:     true,
 	}
-	rply := NewV1TerminateSessionArgs(true, false, true, nil, false, nil, cgrEv, true, nil)
+	rply := NewV1TerminateSessionArgs(true, false, true, nil, false, nil, cgrEv, true)
 	if !reflect.DeepEqual(expected, rply) {
 		t.Errorf("Expecting %+v, received: %+v", expected, rply)
 	}
 	expected = &V1TerminateSessionArgs{
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: cgrEv,
-		},
+		CGREvent:      cgrEv,
 		ForceDuration: true,
 	}
-	rply = NewV1TerminateSessionArgs(false, false, false, nil, false, nil, cgrEv, true, nil)
+	rply = NewV1TerminateSessionArgs(false, false, false, nil, false, nil, cgrEv, true)
 	if !reflect.DeepEqual(expected, rply) {
 		t.Errorf("Expecting %+v, received: %+v", expected, rply)
 	}
@@ -1049,14 +1033,12 @@ func TestSessionSNewV1TerminateSessionArgs(t *testing.T) {
 	thresholdIDs := []string{"ID1", "ID2"}
 	statIDs := []string{"test1", "test2"}
 	expected = &V1TerminateSessionArgs{
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: cgrEv,
-		},
+		CGREvent:      cgrEv,
 		ThresholdIDs:  []string{"ID1", "ID2"},
 		StatIDs:       []string{"test1", "test2"},
 		ForceDuration: true,
 	}
-	rply = NewV1TerminateSessionArgs(false, false, false, thresholdIDs, false, statIDs, cgrEv, true, nil)
+	rply = NewV1TerminateSessionArgs(false, false, false, thresholdIDs, false, statIDs, cgrEv, true)
 	if !reflect.DeepEqual(expected, rply) {
 		t.Errorf("Expecting %+v, received: %+v", expected, rply)
 	}
@@ -1076,30 +1058,26 @@ func TestSessionSNewV1ProcessMessageArgs(t *testing.T) {
 		AllocateResources: true,
 		Debit:             true,
 		GetAttributes:     true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: cgrEv,
-		},
-		GetRoutes:     true,
-		ForceDuration: true,
+		CGREvent:          cgrEv,
+		GetRoutes:         true,
+		ForceDuration:     true,
 	}
 	rply := NewV1ProcessMessageArgs(true, nil, false, nil, false,
-		nil, true, true, true, false, false, cgrEv, utils.Paginator{}, true, nil)
+		nil, true, true, true, false, false, cgrEv, utils.Paginator{}, true)
 	if !reflect.DeepEqual(expected, rply) {
 		t.Errorf("Expecting %+v, received: %+v", expected, rply)
 	}
 	expected = &V1ProcessMessageArgs{
-		AllocateResources: true,
-		GetAttributes:     true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: cgrEv,
-		},
+		AllocateResources:  true,
+		GetAttributes:      true,
+		CGREvent:           cgrEv,
 		GetRoutes:          true,
 		RoutesMaxCost:      utils.MetaRoutesEventCost,
 		RoutesIgnoreErrors: true,
 		ForceDuration:      true,
 	}
 	rply = NewV1ProcessMessageArgs(true, nil, false, nil, false,
-		nil, true, false, true, true, true, cgrEv, utils.Paginator{}, true, nil)
+		nil, true, false, true, true, true, cgrEv, utils.Paginator{}, true)
 	if !reflect.DeepEqual(expected, rply) {
 		t.Errorf("Expecting %+v, received: %+v", expected, rply)
 	}
@@ -1109,11 +1087,9 @@ func TestSessionSNewV1ProcessMessageArgs(t *testing.T) {
 	statIDs := []string{"test3", "test4"}
 
 	expected = &V1ProcessMessageArgs{
-		AllocateResources: true,
-		GetAttributes:     true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: cgrEv,
-		},
+		AllocateResources:  true,
+		GetAttributes:      true,
+		CGREvent:           cgrEv,
 		GetRoutes:          true,
 		RoutesMaxCost:      utils.MetaRoutesEventCost,
 		RoutesIgnoreErrors: true,
@@ -1123,7 +1099,7 @@ func TestSessionSNewV1ProcessMessageArgs(t *testing.T) {
 		ForceDuration:      true,
 	}
 	rply = NewV1ProcessMessageArgs(true, attributeIDs, false, thresholdIDs, false, statIDs,
-		true, false, true, true, true, cgrEv, utils.Paginator{}, true, nil)
+		true, false, true, true, true, cgrEv, utils.Paginator{}, true)
 	if !reflect.DeepEqual(expected, rply) {
 		t.Errorf("Expecting %+v, received: %+v", expected, rply)
 	}
@@ -1152,12 +1128,10 @@ func TestSessionSNewV1InitSessionArgs(t *testing.T) {
 		AttributeIDs:      []string{"ATTR1", "ATTR2"},
 		ThresholdIDs:      []string{"test1", "test2"},
 		StatIDs:           []string{"test3", "test4"},
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: cgrEv,
-		},
-		ForceDuration: true,
+		CGREvent:          cgrEv,
+		ForceDuration:     true,
 	}
-	rply := NewV1InitSessionArgs(true, attributeIDs, true, thresholdIDs, true, statIDs, true, true, cgrEv, true, nil)
+	rply := NewV1InitSessionArgs(true, attributeIDs, true, thresholdIDs, true, statIDs, true, true, cgrEv, true)
 	if !reflect.DeepEqual(expected, rply) {
 		t.Errorf("Expecting %+v, received: %+v", expected, rply)
 	}
@@ -1177,12 +1151,10 @@ func TestSessionSNewV1InitSessionArgs(t *testing.T) {
 		InitSession:       true,
 		ProcessThresholds: true,
 		ProcessStats:      true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: cgrEv,
-		},
-		ForceDuration: true,
+		CGREvent:          cgrEv,
+		ForceDuration:     true,
 	}
-	rply = NewV1InitSessionArgs(true, nil, true, nil, true, nil, true, true, cgrEv, true, nil)
+	rply = NewV1InitSessionArgs(true, nil, true, nil, true, nil, true, true, cgrEv, true)
 	if !reflect.DeepEqual(expected, rply) {
 		t.Errorf("Expecting %+v, received: %+v", expected, rply)
 	}
@@ -1192,12 +1164,10 @@ func TestSessionSNewV1InitSessionArgs(t *testing.T) {
 		InitSession:       true,
 		ProcessThresholds: false,
 		ProcessStats:      true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: cgrEv,
-		},
-		ForceDuration: true,
+		CGREvent:          cgrEv,
+		ForceDuration:     true,
 	}
-	rply = NewV1InitSessionArgs(true, nil, false, nil, true, nil, false, true, cgrEv, true, nil)
+	rply = NewV1InitSessionArgs(true, nil, false, nil, true, nil, false, true, cgrEv, true)
 	if !reflect.DeepEqual(expected, rply) {
 		t.Errorf("Expecting %+v, received: %+v", expected, rply)
 	}
@@ -1513,10 +1483,7 @@ func TestSessionSrelocateSessionS(t *testing.T) {
 }
 
 func TestSessionSNewV1AuthorizeArgsWithOpts(t *testing.T) {
-	opts := map[string]interface{}{
-		utils.OptsAPIKey:  "testkey",
-		utils.OptsRouteID: "testrouteid",
-	}
+
 	cgrEv := &utils.CGREvent{
 		Tenant: "cgrates.org",
 		ID:     "Event",
@@ -1524,19 +1491,20 @@ func TestSessionSNewV1AuthorizeArgsWithOpts(t *testing.T) {
 			utils.AccountField: "1001",
 			utils.Destination:  "1002",
 		},
+		Opts: map[string]interface{}{
+			utils.OptsAPIKey:  "testkey",
+			utils.OptsRouteID: "testrouteid",
+		},
 	}
 	expected := &V1AuthorizeArgs{
 		AuthorizeResources: true,
 		GetAttributes:      true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: cgrEv,
-			Opts:     opts,
-		},
-		ForceDuration: true,
+		CGREvent:           cgrEv,
+		ForceDuration:      true,
 	}
-	cgrArgs, _ := utils.GetRoutePaginatorFromOpts(opts)
+	cgrArgs, _ := utils.GetRoutePaginatorFromOpts(cgrEv.Opts)
 	rply := NewV1AuthorizeArgs(true, nil, false, nil, false, nil, true, false,
-		false, false, false, cgrEv, cgrArgs, true, opts)
+		false, false, false, cgrEv, cgrArgs, true)
 	if !reflect.DeepEqual(expected, rply) {
 		t.Errorf("Expecting %+v, received: %+v", utils.ToJSON(expected), utils.ToJSON(rply))
 	}
@@ -1549,23 +1517,18 @@ func TestSessionSNewV1AuthorizeArgsWithOpts(t *testing.T) {
 		GetRoutes:          false,
 		RoutesIgnoreErrors: true,
 		RoutesMaxCost:      utils.MetaRoutesEventCost,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: cgrEv,
-			Opts:     opts,
-		},
-		ForceDuration: true,
+		CGREvent:           cgrEv,
+		ForceDuration:      true,
 	}
 	rply = NewV1AuthorizeArgs(true, nil, false, nil, true, nil, false, true,
-		false, true, true, cgrEv, cgrArgs, true, opts)
+		false, true, true, cgrEv, cgrArgs, true)
 	if !reflect.DeepEqual(expected, rply) {
 		t.Errorf("Expecting %+v, received: %+v", utils.ToJSON(expected), utils.ToJSON(rply))
 	}
 }
 
 func TestSessionSNewV1AuthorizeArgsWithOpts2(t *testing.T) {
-	opts := map[string]interface{}{
-		utils.OptsRouteID: "testrouteid",
-	}
+
 	cgrEv := &utils.CGREvent{
 		Tenant: "cgrates.org",
 		ID:     "Event",
@@ -1573,19 +1536,19 @@ func TestSessionSNewV1AuthorizeArgsWithOpts2(t *testing.T) {
 			utils.AccountField: "1001",
 			utils.Destination:  "1002",
 		},
+		Opts: map[string]interface{}{
+			utils.OptsRouteID: "testrouteid",
+		},
 	}
 	expected := &V1AuthorizeArgs{
 		AuthorizeResources: true,
 		GetAttributes:      true,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: cgrEv,
-			Opts:     opts,
-		},
-		ForceDuration: true,
+		CGREvent:           cgrEv,
+		ForceDuration:      true,
 	}
-	cgrArgs, _ := utils.GetRoutePaginatorFromOpts(opts)
+	cgrArgs, _ := utils.GetRoutePaginatorFromOpts(cgrEv.Opts)
 	rply := NewV1AuthorizeArgs(true, nil, false, nil, false, nil, true, false, false,
-		false, false, cgrEv, cgrArgs, true, opts)
+		false, false, cgrEv, cgrArgs, true)
 	if !reflect.DeepEqual(expected, rply) {
 		t.Errorf("Expecting %+v, received: %+v", utils.ToJSON(expected), utils.ToJSON(rply))
 	}
@@ -1598,14 +1561,11 @@ func TestSessionSNewV1AuthorizeArgsWithOpts2(t *testing.T) {
 		GetRoutes:          false,
 		RoutesIgnoreErrors: true,
 		RoutesMaxCost:      utils.MetaRoutesEventCost,
-		CGREventWithOpts: &utils.CGREventWithOpts{
-			CGREvent: cgrEv,
-			Opts:     opts,
-		},
-		ForceDuration: true,
+		CGREvent:           cgrEv,
+		ForceDuration:      true,
 	}
 	rply = NewV1AuthorizeArgs(true, nil, false, nil, true, nil, false, true, false,
-		true, true, cgrEv, cgrArgs, true, opts)
+		true, true, cgrEv, cgrArgs, true)
 	if !reflect.DeepEqual(expected, rply) {
 		t.Errorf("Expecting %+v, received: %+v", utils.ToJSON(expected), utils.ToJSON(rply))
 	}
@@ -1888,9 +1848,9 @@ func TestV1TerminateSessionArgsParseFlags(t *testing.T) {
 
 func TestV1ProcessMessageArgsParseFlags(t *testing.T) {
 	v1ProcessMsgArgs := new(V1ProcessMessageArgs)
-	v1ProcessMsgArgs.CGREventWithOpts = new(utils.CGREventWithOpts)
+	v1ProcessMsgArgs.CGREvent = new(utils.CGREvent)
 	eOut := new(V1ProcessMessageArgs)
-	eOut.CGREventWithOpts = new(utils.CGREventWithOpts)
+	eOut.CGREvent = new(utils.CGREvent)
 	//empty check
 	strArg := ""
 	v1ProcessMsgArgs.ParseFlags(strArg)
@@ -1910,7 +1870,7 @@ func TestV1ProcessMessageArgsParseFlags(t *testing.T) {
 		ThresholdIDs:       []string{"tr1", "tr2", "tr3"},
 		ProcessStats:       true,
 		StatIDs:            []string{"st1", "st2", "st3"},
-		CGREventWithOpts:   eOut.CGREventWithOpts,
+		CGREvent:           eOut.CGREvent,
 	}
 
 	strArg = "*accounts,*resources,*routes,*routes_ignore_errors,*routes_event_cost,*attributes:Attr1;Attr2,*thresholds:tr1;tr2;tr3,*stats:st1;st2;st3"
@@ -1932,7 +1892,7 @@ func TestV1ProcessMessageArgsParseFlags(t *testing.T) {
 		ThresholdIDs:       []string{"tr1", "tr2", "tr3"},
 		ProcessStats:       true,
 		StatIDs:            []string{"st1", "st2", "st3"},
-		CGREventWithOpts:   eOut.CGREventWithOpts,
+		CGREvent:           eOut.CGREvent,
 	}
 
 	strArg = "*accounts,*resources,*dispatchers,*routes,*routes_ignore_errors,*routes_event_cost,*attributes:Attr1;Attr2,*thresholds:tr1;tr2;tr3,*stats:st1;st2;st3"
diff --git a/utils/apitpdata_test.go b/utils/apitpdata_test.go
index 89bea9021..8cfb90b41 100644
--- a/utils/apitpdata_test.go
+++ b/utils/apitpdata_test.go
@@ -662,11 +662,9 @@ func TestArgRSv1ResourceUsageCloneCase1(t *testing.T) {
 
 func TestArgRSv1ResourceUsageCloneCase2(t *testing.T) {
 	newArgRSv1 := &ArgRSv1ResourceUsage{
-		CGREventWithOpts: &CGREventWithOpts{
-			Opts: map[string]interface{}{},
-			CGREvent: &CGREvent{
-				Tenant: "*req.CGRID",
-			},
+		CGREvent: &CGREvent{
+			Tenant: "*req.CGRID",
+			Opts:   map[string]interface{}{},
 		},
 		UsageID:  "randomID",
 		UsageTTL: DurationPointer(2),
@@ -681,12 +679,10 @@ func TestArgRSv1ResourceUsageCloneCase2(t *testing.T) {
 
 func TestArgRSv1ResourceUsageCloneCase3(t *testing.T) {
 	newArgRSv1 := &ArgRSv1ResourceUsage{
-		CGREventWithOpts: &CGREventWithOpts{
-			Opts: map[string]interface{}{},
-			CGREvent: &CGREvent{
-				Tenant: "*req.CGRID",
-				Event:  map[string]interface{}{},
-			},
+		CGREvent: &CGREvent{
+			Tenant: "*req.CGRID",
+			Event:  map[string]interface{}{},
+			Opts:   map[string]interface{}{},
 		},
 		UsageID:  "randomID",
 		UsageTTL: DurationPointer(2),
@@ -1062,13 +1058,11 @@ func TestNewAttrReloadCacheWithOpts(t *testing.T) {
 func TestStartTimeNow(t *testing.T) {
 	testCostEventStruct := &ArgsCostForEvent{
 		RateProfileIDs: []string{"123", "456", "789"},
-		CGREventWithOpts: &CGREventWithOpts{
-			Opts: map[string]interface{}{},
-			CGREvent: &CGREvent{
-				Tenant: "*req.CGRID",
-				ID:     "",
-				Event:  map[string]interface{}{},
-			},
+		CGREvent: &CGREvent{
+			Tenant: "*req.CGRID",
+			ID:     "",
+			Event:  map[string]interface{}{},
+			Opts:   map[string]interface{}{},
 		},
 	}
 	timpulet1 := time.Now()
@@ -1085,13 +1079,11 @@ func TestStartTimeNow(t *testing.T) {
 func TestStartTime(t *testing.T) {
 	testCostEventStruct := &ArgsCostForEvent{
 		RateProfileIDs: []string{"123", "456", "789"},
-		CGREventWithOpts: &CGREventWithOpts{
-			Opts: map[string]interface{}{"*ratesStartTime": "2018-01-07T17:00:10Z"},
-			CGREvent: &CGREvent{
-				Tenant: "*req.CGRID",
-				ID:     "",
-				Event:  map[string]interface{}{},
-			},
+		CGREvent: &CGREvent{
+			Tenant: "*req.CGRID",
+			ID:     "",
+			Event:  map[string]interface{}{},
+			Opts:   map[string]interface{}{"*ratesStartTime": "2018-01-07T17:00:10Z"},
 		},
 	}
 	if result, err := testCostEventStruct.StartTime(""); err != nil {
@@ -1104,13 +1096,11 @@ func TestStartTime(t *testing.T) {
 func TestStartTimeError(t *testing.T) {
 	testCostEventStruct := &ArgsCostForEvent{
 		RateProfileIDs: []string{"123", "456", "789"},
-		CGREventWithOpts: &CGREventWithOpts{
-			Opts: map[string]interface{}{"*ratesStartTime": "start"},
-			CGREvent: &CGREvent{
-				Tenant: "*req.CGRID",
-				ID:     "",
-				Event:  map[string]interface{}{},
-			},
+		CGREvent: &CGREvent{
+			Tenant: "*req.CGRID",
+			ID:     "",
+			Event:  map[string]interface{}{},
+			Opts:   map[string]interface{}{"*ratesStartTime": "start"},
 		},
 	}
 	_, err := testCostEventStruct.StartTime("")
@@ -1122,13 +1112,11 @@ func TestStartTimeError(t *testing.T) {
 func TestUsageMinute(t *testing.T) {
 	testCostEventStruct := &ArgsCostForEvent{
 		RateProfileIDs: []string{"123", "456", "789"},
-		CGREventWithOpts: &CGREventWithOpts{
-			Opts: map[string]interface{}{},
-			CGREvent: &CGREvent{
-				Tenant: "*req.CGRID",
-				ID:     "",
-				Event:  map[string]interface{}{},
-			},
+		CGREvent: &CGREvent{
+			Tenant: "*req.CGRID",
+			ID:     "",
+			Event:  map[string]interface{}{},
+			Opts:   map[string]interface{}{},
 		},
 	}
 	if result, err := testCostEventStruct.Usage(); err != nil {
@@ -1141,13 +1129,11 @@ func TestUsageMinute(t *testing.T) {
 func TestUsageError(t *testing.T) {
 	testCostEventStruct := &ArgsCostForEvent{
 		RateProfileIDs: []string{"123", "456", "789"},
-		CGREventWithOpts: &CGREventWithOpts{
-			Opts: map[string]interface{}{"*ratesUsage": "start"},
-			CGREvent: &CGREvent{
-				Tenant: "*req.CGRID",
-				ID:     "",
-				Event:  map[string]interface{}{},
-			},
+		CGREvent: &CGREvent{
+			Tenant: "*req.CGRID",
+			ID:     "",
+			Event:  map[string]interface{}{},
+			Opts:   map[string]interface{}{"*ratesUsage": "start"},
 		},
 	}
 	_, err := testCostEventStruct.Usage()
@@ -1159,13 +1145,11 @@ func TestUsageError(t *testing.T) {
 func TestUsage(t *testing.T) {
 	testCostEventStruct := &ArgsCostForEvent{
 		RateProfileIDs: []string{"123", "456", "789"},
-		CGREventWithOpts: &CGREventWithOpts{
-			Opts: map[string]interface{}{"*ratesUsage": "2m10s"},
-			CGREvent: &CGREvent{
-				Tenant: "*req.CGRID",
-				ID:     "",
-				Event:  map[string]interface{}{},
-			},
+		CGREvent: &CGREvent{
+			Tenant: "*req.CGRID",
+			ID:     "",
+			Event:  map[string]interface{}{},
+			Opts:   map[string]interface{}{"*ratesUsage": "2m10s"},
 		},
 	}
 
diff --git a/utils/cgrevent_test.go b/utils/cgrevent_test.go
index 1b27e6f99..d762c9458 100644
--- a/utils/cgrevent_test.go
+++ b/utils/cgrevent_test.go
@@ -272,6 +272,7 @@ func TestCGREventClone(t *testing.T) {
 			"PddInterval":      "1s",
 			"Weight":           20.0,
 		},
+		Opts: map[string]interface{}{},
 	}
 	cloned := ev.Clone()
 	if !reflect.DeepEqual(ev, cloned) {
@@ -378,48 +379,6 @@ func TestCGREventconsumeRoutePaginatorCase1(t *testing.T) {
 	}
 }
 
-func TestCGREventWithOptsClone(t *testing.T) {
-	//empty check
-	cgrEventWithOpts := new(CGREventWithOpts)
-	rcv := cgrEventWithOpts.Clone()
-	if !reflect.DeepEqual(cgrEventWithOpts, rcv) {
-		t.Errorf("Expecting: %+v, received: %+v", cgrEventWithOpts, rcv)
-	}
-	//nil check
-	cgrEventWithOpts = nil
-	rcv = cgrEventWithOpts.Clone()
-	if !reflect.DeepEqual(cgrEventWithOpts, rcv) {
-		t.Errorf("Expecting: %+v, received: %+v", cgrEventWithOpts, rcv)
-	}
-	//normal check
-	now := time.Now()
-	cgrEventWithOpts = &CGREventWithOpts{
-		CGREvent: &CGREvent{
-			Tenant: "cgrates.org",
-			ID:     "IDtest",
-			Time:   &now,
-			Event: map[string]interface{}{
-				"test1": 1,
-				"test2": 2,
-				"test3": 3,
-			},
-		},
-		Opts: map[string]interface{}{
-			"Context": MetaSessionS,
-		},
-	}
-	rcv = cgrEventWithOpts.Clone()
-	if !reflect.DeepEqual(cgrEventWithOpts, rcv) {
-		t.Errorf("Expecting: %+v, received: %+v", cgrEventWithOpts, rcv)
-	}
-	//check vars
-	rcv.Opts["var"] = 1
-	if reflect.DeepEqual(cgrEventWithOpts.Opts, rcv.Opts) {
-		t.Errorf("Expected to be different")
-	}
-
-}
-
 func TestCGREventFieldAsInt64(t *testing.T) {
 	se := &CGREvent{
 		Tenant: "cgrates.org",
@@ -464,7 +423,7 @@ func TestCGREventFieldAsInt64(t *testing.T) {
 }
 
 func TestCGREventWithOptsCache(t *testing.T) {
-	event := &CGREventWithOpts{}
+	event := &CGREvent{}
 	event.CacheInit()
 	event.CacheSet("testKey", "string_for_test")
 	if rcv, _ := event.CacheGet("testKey"); rcv != "string_for_test" {