diff --git a/engine/libstats.go b/engine/libstats.go
index d316aacd8..90bab7754 100644
--- a/engine/libstats.go
+++ b/engine/libstats.go
@@ -174,14 +174,14 @@ func (sq *StatQueue) TenantID() string {
 }
 
 // ProcessEvent processes a utils.CGREvent, returns true if processed
-func (sq *StatQueue) ProcessEvent(ev *utils.CGREvent, filterS *FilterS) (err error) {
+func (sq *StatQueue) ProcessEvent(ev *utils.CGREvent, filterS *FilterS, evNm utils.MapStorage) (err error) {
 	if err = sq.remExpired(); err != nil {
 		return
 	}
 	if err = sq.remOnQueueLength(); err != nil {
 		return
 	}
-	return sq.addStatEvent(ev, filterS)
+	return sq.addStatEvent(ev, filterS, evNm)
 }
 
 // remStatEvent removes an event from metrics
@@ -237,7 +237,7 @@ func (sq *StatQueue) remOnQueueLength() (err error) {
 }
 
 // addStatEvent computes metrics for an event
-func (sq *StatQueue) addStatEvent(ev *utils.CGREvent, filterS *FilterS) (err error) {
+func (sq *StatQueue) addStatEvent(ev *utils.CGREvent, filterS *FilterS, evNm utils.MapStorage) (err error) {
 	var expTime *time.Time
 	if sq.ttl != nil {
 		expTime = utils.TimePointer(time.Now().Add(*sq.ttl))
@@ -248,7 +248,8 @@ func (sq *StatQueue) addStatEvent(ev *utils.CGREvent, filterS *FilterS) (err err
 			ExpiryTime *time.Time
 		}{ev.ID, expTime})
 	var pass bool
-	evNm := utils.MapStorage{utils.MetaReq: ev.Event}
+	// recreate the request without *opts
+	req := utils.MapStorage{utils.MetaReq: ev.Event}
 	for metricID, metric := range sq.SQMetrics {
 		if pass, err = filterS.Pass(ev.Tenant, metric.GetFilterIDs(),
 			evNm); err != nil {
@@ -256,7 +257,7 @@ func (sq *StatQueue) addStatEvent(ev *utils.CGREvent, filterS *FilterS) (err err
 		} else if !pass {
 			continue
 		}
-		if err = metric.AddEvent(ev); err != nil {
+		if err = metric.AddEvent(ev.ID, req); err != nil {
 			utils.Logger.Warning(fmt.Sprintf("<StatQueue> metricID: %s, add eventID: %s, error: %s",
 				metricID, ev.ID, err.Error()))
 			return
diff --git a/engine/libstats_test.go b/engine/libstats_test.go
index d92c8752b..d730dcf37 100644
--- a/engine/libstats_test.go
+++ b/engine/libstats_test.go
@@ -220,7 +220,7 @@ func TestStatAddStatEvent(t *testing.T) {
 		t.Errorf("received ASR: %v", asr)
 	}
 	ev1 := &utils.CGREvent{Tenant: "cgrates.org", ID: "TestStatAddStatEvent_1"}
-	sq.addStatEvent(ev1, nil)
+	sq.addStatEvent(ev1, nil, nil)
 	if asr := asrMetric.GetFloat64Value(); asr != 50 {
 		t.Errorf("received ASR: %v", asr)
 	} else if asrMetric.Answered != 1 || asrMetric.Count != 2 {
@@ -228,7 +228,7 @@ func TestStatAddStatEvent(t *testing.T) {
 	}
 	ev1.Event = map[string]interface{}{
 		utils.AnswerTime: time.Now()}
-	sq.addStatEvent(ev1, nil)
+	sq.addStatEvent(ev1, nil, nil)
 	if asr := asrMetric.GetFloat64Value(); asr != 66.66667 {
 		t.Errorf("received ASR: %v", asr)
 	} else if asrMetric.Answered != 2 || asrMetric.Count != 3 {
@@ -634,7 +634,7 @@ func TestStatRemoveExpiredTTL(t *testing.T) {
 
 	//add ev1 with ttl 100ms (after 100ms the event should be removed)
 	ev1 := &utils.CGREvent{Tenant: "cgrates.org", ID: "TestStatAddStatEvent_1"}
-	sq.ProcessEvent(ev1, nil)
+	sq.ProcessEvent(ev1, nil, utils.MapStorage{utils.MetaReq: ev1.Event})
 
 	if len(sq.SQItems) != 1 && sq.SQItems[0].EventID != "TestStatAddStatEvent_1" {
 		t.Errorf("Expecting: 1, received: %+v", len(sq.SQItems))
@@ -644,7 +644,7 @@ func TestStatRemoveExpiredTTL(t *testing.T) {
 
 	//processing a new event should clean the expired events and add the new one
 	ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "TestStatAddStatEvent_2"}
-	sq.ProcessEvent(ev2, nil)
+	sq.ProcessEvent(ev2, nil, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if len(sq.SQItems) != 1 && sq.SQItems[0].EventID != "TestStatAddStatEvent_2" {
 		t.Errorf("Expecting: 1, received: %+v", len(sq.SQItems))
 	}
@@ -668,7 +668,7 @@ func TestStatRemoveExpiredQueue(t *testing.T) {
 
 	//add ev1 with ttl 100ms (after 100ms the event should be removed)
 	ev1 := &utils.CGREvent{Tenant: "cgrates.org", ID: "TestStatAddStatEvent_1"}
-	sq.ProcessEvent(ev1, nil)
+	sq.ProcessEvent(ev1, nil, utils.MapStorage{utils.MetaReq: ev1.Event})
 
 	if len(sq.SQItems) != 1 && sq.SQItems[0].EventID != "TestStatAddStatEvent_1" {
 		t.Errorf("Expecting: 1, received: %+v", len(sq.SQItems))
@@ -678,7 +678,7 @@ func TestStatRemoveExpiredQueue(t *testing.T) {
 
 	//processing a new event should clean the expired events and add the new one
 	ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "TestStatAddStatEvent_2"}
-	sq.ProcessEvent(ev2, nil)
+	sq.ProcessEvent(ev2, nil, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if len(sq.SQItems) != 2 && sq.SQItems[0].EventID != "TestStatAddStatEvent_1" &&
 		sq.SQItems[1].EventID != "TestStatAddStatEvent_2" {
 		t.Errorf("Expecting: 2, received: %+v", len(sq.SQItems))
@@ -686,7 +686,7 @@ func TestStatRemoveExpiredQueue(t *testing.T) {
 
 	//processing a new event should clean the expired events and add the new one
 	ev3 := &utils.CGREvent{Tenant: "cgrates.org", ID: "TestStatAddStatEvent_3"}
-	sq.ProcessEvent(ev3, nil)
+	sq.ProcessEvent(ev3, nil, utils.MapStorage{utils.MetaReq: ev3.Event})
 	if len(sq.SQItems) != 2 && sq.SQItems[0].EventID != "TestStatAddStatEvent_2" &&
 		sq.SQItems[1].EventID != "TestStatAddStatEvent_3" {
 		t.Errorf("Expecting: 2, received: %+v", len(sq.SQItems))
diff --git a/engine/statmetrics.go b/engine/statmetrics.go
index 01e06967d..082ad62e3 100644
--- a/engine/statmetrics.go
+++ b/engine/statmetrics.go
@@ -76,7 +76,7 @@ type StatMetric interface {
 	GetValue() interface{}
 	GetStringValue(fmtOpts string) (val string)
 	GetFloat64Value() (val float64)
-	AddEvent(ev *utils.CGREvent) error
+	AddEvent(evID string, ev utils.DataProvider) error
 	RemEvent(evTenantID string) error
 	Marshal(ms Marshaler) (marshaled []byte, err error)
 	LoadMarshaled(ms Marshaler, marshaled []byte) (err error)
@@ -133,25 +133,28 @@ func (asr *StatASR) GetFloat64Value() (val float64) {
 }
 
 // AddEvent is part of StatMetric interface
-func (asr *StatASR) AddEvent(ev *utils.CGREvent) (err error) {
+func (asr *StatASR) AddEvent(evID string, ev utils.DataProvider) (err error) {
 	var answered int
-	if at, err := ev.FieldAsTime(utils.AnswerTime,
-		config.CgrConfig().GeneralCfg().DefaultTimezone); err != nil &&
-		err != utils.ErrNotFound {
+	if val, err := ev.FieldAsInterface([]string{utils.MetaReq, utils.AnswerTime}); err != nil {
+		if err != utils.ErrNotFound {
+			return err
+		}
+	} else if at, err := utils.IfaceAsTime(val,
+		config.CgrConfig().GeneralCfg().DefaultTimezone); err != nil {
 		return err
 	} else if !at.IsZero() {
 		answered = 1
 	}
 
-	if val, has := asr.Events[ev.ID]; !has {
-		asr.Events[ev.ID] = &StatWithCompress{Stat: float64(answered), CompressFactor: 1}
+	if val, has := asr.Events[evID]; !has {
+		asr.Events[evID] = &StatWithCompress{Stat: float64(answered), CompressFactor: 1}
 	} else {
 		val.Stat = (val.Stat*float64(val.CompressFactor) + float64(answered)) / float64(val.CompressFactor+1)
 		val.CompressFactor = val.CompressFactor + 1
 	}
-	asr.Count += 1
+	asr.Count++
 	if answered == 1 {
-		asr.Answered += 1
+		asr.Answered++
 	}
 	asr.val = nil
 	return
@@ -165,9 +168,9 @@ func (asr *StatASR) RemEvent(evID string) (err error) {
 	ans := 0
 	if val.Stat > 0.5 {
 		ans = 1
-		asr.Answered -= 1
+		asr.Answered--
 	}
-	asr.Count -= 1
+	asr.Count--
 	if val.CompressFactor <= 1 {
 		delete(asr.Events, evID)
 	} else {
@@ -196,7 +199,7 @@ func (asr *StatASR) GetFilterIDs() []string {
 // Compress is part of StatMetric interface
 func (asr *StatASR) Compress(queueLen int64, defaultID string) (eventIDs []string) {
 	if asr.Count < queueLen {
-		for id, _ := range asr.Events {
+		for id := range asr.Events {
 			eventIDs = append(eventIDs, id)
 		}
 		return
@@ -273,22 +276,25 @@ func (acd *StatACD) GetFloat64Value() (v float64) {
 	return
 }
 
-func (acd *StatACD) AddEvent(ev *utils.CGREvent) (err error) {
+func (acd *StatACD) AddEvent(evID string, ev utils.DataProvider) (err error) {
 	var dur time.Duration
-	if dur, err = ev.FieldAsDuration(utils.Usage); err != nil {
+	var val interface{}
+	if val, err = ev.FieldAsInterface([]string{utils.MetaReq, utils.Usage}); err != nil {
 		if err == utils.ErrNotFound {
 			err = utils.ErrPrefix(err, utils.Usage)
 		}
 		return
+	} else if dur, err = utils.IfaceAsDuration(val); err != nil {
+		return
 	}
 	acd.Sum += dur
-	if val, has := acd.Events[ev.ID]; !has {
-		acd.Events[ev.ID] = &DurationWithCompress{Duration: dur, CompressFactor: 1}
+	if val, has := acd.Events[evID]; !has {
+		acd.Events[evID] = &DurationWithCompress{Duration: dur, CompressFactor: 1}
 	} else {
 		val.Duration = time.Duration((float64(val.Duration.Nanoseconds())*float64(val.CompressFactor) + float64(dur.Nanoseconds())) / float64(val.CompressFactor+1))
 		val.CompressFactor = val.CompressFactor + 1
 	}
-	acd.Count += 1
+	acd.Count++
 	acd.val = nil
 	return
 }
@@ -301,7 +307,7 @@ func (acd *StatACD) RemEvent(evID string) (err error) {
 	if val.Duration != 0 {
 		acd.Sum -= val.Duration
 	}
-	acd.Count -= 1
+	acd.Count--
 	if val.CompressFactor <= 1 {
 		delete(acd.Events, evID)
 	} else {
@@ -326,7 +332,7 @@ func (acd *StatACD) GetFilterIDs() []string {
 // Compress is part of StatMetric interface
 func (acd *StatACD) Compress(queueLen int64, defaultID string) (eventIDs []string) {
 	if acd.Count < queueLen {
-		for id, _ := range acd.Events {
+		for id := range acd.Events {
 			eventIDs = append(eventIDs, id)
 		}
 		return
@@ -404,22 +410,25 @@ func (tcd *StatTCD) GetFloat64Value() (v float64) {
 	return
 }
 
-func (tcd *StatTCD) AddEvent(ev *utils.CGREvent) (err error) {
+func (tcd *StatTCD) AddEvent(evID string, ev utils.DataProvider) (err error) {
 	var dur time.Duration
-	if dur, err = ev.FieldAsDuration(utils.Usage); err != nil {
+	var val interface{}
+	if val, err = ev.FieldAsInterface([]string{utils.MetaReq, utils.Usage}); err != nil {
 		if err == utils.ErrNotFound {
 			err = utils.ErrPrefix(err, utils.Usage)
 		}
 		return
+	} else if dur, err = utils.IfaceAsDuration(val); err != nil {
+		return
 	}
 	tcd.Sum += dur
-	if val, has := tcd.Events[ev.ID]; !has {
-		tcd.Events[ev.ID] = &DurationWithCompress{Duration: dur, CompressFactor: 1}
+	if val, has := tcd.Events[evID]; !has {
+		tcd.Events[evID] = &DurationWithCompress{Duration: dur, CompressFactor: 1}
 	} else {
 		val.Duration = time.Duration((float64(val.Duration.Nanoseconds())*float64(val.CompressFactor) + float64(dur.Nanoseconds())) / float64(val.CompressFactor+1))
 		val.CompressFactor = val.CompressFactor + 1
 	}
-	tcd.Count += 1
+	tcd.Count++
 	tcd.val = nil
 	return
 }
@@ -432,7 +441,7 @@ func (tcd *StatTCD) RemEvent(evID string) (err error) {
 	if val.Duration != 0 {
 		tcd.Sum -= val.Duration
 	}
-	tcd.Count -= 1
+	tcd.Count--
 	if val.CompressFactor <= 1 {
 		delete(tcd.Events, evID)
 	} else {
@@ -458,7 +467,7 @@ func (tcd *StatTCD) GetFilterIDs() []string {
 // Compress is part of StatMetric interface
 func (tcd *StatTCD) Compress(queueLen int64, defaultID string) (eventIDs []string) {
 	if tcd.Count < queueLen {
-		for id, _ := range tcd.Events {
+		for id := range tcd.Events {
 			eventIDs = append(eventIDs, id)
 		}
 		return
@@ -530,22 +539,25 @@ func (acc *StatACC) GetFloat64Value() (v float64) {
 	return acc.getValue()
 }
 
-func (acc *StatACC) AddEvent(ev *utils.CGREvent) (err error) {
+func (acc *StatACC) AddEvent(evID string, ev utils.DataProvider) (err error) {
 	var cost float64
-	if cost, err = ev.FieldAsFloat64(utils.COST); err != nil {
+	var val interface{}
+	if val, err = ev.FieldAsInterface([]string{utils.MetaReq, utils.COST}); err != nil {
 		if err == utils.ErrNotFound {
 			err = utils.ErrPrefix(err, utils.COST)
 		}
 		return
+	} else if cost, err = utils.IfaceAsFloat64(val); err != nil {
+		return
 	}
 	acc.Sum += cost
-	if val, has := acc.Events[ev.ID]; !has {
-		acc.Events[ev.ID] = &StatWithCompress{Stat: cost, CompressFactor: 1}
+	if val, has := acc.Events[evID]; !has {
+		acc.Events[evID] = &StatWithCompress{Stat: cost, CompressFactor: 1}
 	} else {
 		val.Stat = (val.Stat*float64(val.CompressFactor) + cost) / float64(val.CompressFactor+1)
 		val.CompressFactor = val.CompressFactor + 1
 	}
-	acc.Count += 1
+	acc.Count++
 	acc.val = nil
 	return
 }
@@ -556,7 +568,7 @@ func (acc *StatACC) RemEvent(evID string) (err error) {
 		return utils.ErrNotFound
 	}
 	acc.Sum -= cost.Stat
-	acc.Count -= 1
+	acc.Count--
 	if cost.CompressFactor <= 1 {
 		delete(acc.Events, evID)
 	} else {
@@ -582,7 +594,7 @@ func (acc *StatACC) GetFilterIDs() []string {
 // Compress is part of StatMetric interface
 func (acc *StatACC) Compress(queueLen int64, defaultID string) (eventIDs []string) {
 	if acc.Count < queueLen {
-		for id, _ := range acc.Events {
+		for id := range acc.Events {
 			eventIDs = append(eventIDs, id)
 		}
 		return
@@ -654,22 +666,25 @@ func (tcc *StatTCC) GetFloat64Value() (v float64) {
 	return tcc.getValue()
 }
 
-func (tcc *StatTCC) AddEvent(ev *utils.CGREvent) (err error) {
+func (tcc *StatTCC) AddEvent(evID string, ev utils.DataProvider) (err error) {
 	var cost float64
-	if cost, err = ev.FieldAsFloat64(utils.COST); err != nil {
+	var val interface{}
+	if val, err = ev.FieldAsInterface([]string{utils.MetaReq, utils.COST}); err != nil {
 		if err == utils.ErrNotFound {
 			err = utils.ErrPrefix(err, utils.COST)
 		}
 		return
+	} else if cost, err = utils.IfaceAsFloat64(val); err != nil {
+		return
 	}
 	tcc.Sum += cost
-	if val, has := tcc.Events[ev.ID]; !has {
-		tcc.Events[ev.ID] = &StatWithCompress{Stat: cost, CompressFactor: 1}
+	if val, has := tcc.Events[evID]; !has {
+		tcc.Events[evID] = &StatWithCompress{Stat: cost, CompressFactor: 1}
 	} else {
 		val.Stat = (val.Stat*float64(val.CompressFactor) + cost) / float64(val.CompressFactor+1)
 		val.CompressFactor = val.CompressFactor + 1
 	}
-	tcc.Count += 1
+	tcc.Count++
 	tcc.val = nil
 	return
 }
@@ -682,7 +697,7 @@ func (tcc *StatTCC) RemEvent(evID string) (err error) {
 	if cost.Stat != 0 {
 		tcc.Sum -= cost.Stat
 	}
-	tcc.Count -= 1
+	tcc.Count--
 	if cost.CompressFactor <= 1 {
 		delete(tcc.Events, evID)
 	} else {
@@ -708,7 +723,7 @@ func (tcc *StatTCC) GetFilterIDs() []string {
 // Compress is part of StatMetric interface
 func (tcc *StatTCC) Compress(queueLen int64, defaultID string) (eventIDs []string) {
 	if tcc.Count < queueLen {
-		for id, _ := range tcc.Events {
+		for id := range tcc.Events {
 			eventIDs = append(eventIDs, id)
 		}
 		return
@@ -785,22 +800,25 @@ func (pdd *StatPDD) GetFloat64Value() (v float64) {
 	return
 }
 
-func (pdd *StatPDD) AddEvent(ev *utils.CGREvent) (err error) {
+func (pdd *StatPDD) AddEvent(evID string, ev utils.DataProvider) (err error) {
 	var dur time.Duration
-	if dur, err = ev.FieldAsDuration(utils.PDD); err != nil {
+	var val interface{}
+	if val, err = ev.FieldAsInterface([]string{utils.MetaReq, utils.PDD}); err != nil {
 		if err == utils.ErrNotFound {
 			err = utils.ErrPrefix(err, utils.PDD)
 		}
 		return
+	} else if dur, err = utils.IfaceAsDuration(val); err != nil {
+		return
 	}
 	pdd.Sum += dur
-	if val, has := pdd.Events[ev.ID]; !has {
-		pdd.Events[ev.ID] = &DurationWithCompress{Duration: dur, CompressFactor: 1}
+	if val, has := pdd.Events[evID]; !has {
+		pdd.Events[evID] = &DurationWithCompress{Duration: dur, CompressFactor: 1}
 	} else {
 		val.Duration = time.Duration((float64(val.Duration.Nanoseconds())*float64(val.CompressFactor) + float64(dur.Nanoseconds())) / float64(val.CompressFactor+1))
 		val.CompressFactor = val.CompressFactor + 1
 	}
-	pdd.Count += 1
+	pdd.Count++
 	pdd.val = nil
 	return
 }
@@ -813,7 +831,7 @@ func (pdd *StatPDD) RemEvent(evID string) (err error) {
 	if val.Duration != 0 {
 		pdd.Sum -= val.Duration
 	}
-	pdd.Count -= 1
+	pdd.Count--
 	if val.CompressFactor <= 1 {
 		delete(pdd.Events, evID)
 	} else {
@@ -838,7 +856,7 @@ func (pdd *StatPDD) GetFilterIDs() []string {
 // Compress is part of StatMetric interface
 func (pdd *StatPDD) Compress(queueLen int64, defaultID string) (eventIDs []string) {
 	if pdd.Count < queueLen {
-		for id, _ := range pdd.Events {
+		for id := range pdd.Events {
 			eventIDs = append(eventIDs, id)
 		}
 		return
@@ -903,28 +921,31 @@ func (ddc *StatDDC) GetFloat64Value() (v float64) {
 	return ddc.getValue()
 }
 
-func (ddc *StatDDC) AddEvent(ev *utils.CGREvent) (err error) {
+func (ddc *StatDDC) AddEvent(evID string, ev utils.DataProvider) (err error) {
 	var fieldValue string
-	if fieldValue, err = ev.FieldAsString(utils.Destination); err != nil {
-		return err
+	if fieldValue, err = ev.FieldAsString([]string{utils.MetaReq, utils.Destination}); err != nil {
+		if err == utils.ErrNotFound {
+			err = utils.ErrPrefix(err, utils.Destination)
+		}
+		return
 	}
 
 	// add to fieldValues
 	if _, has := ddc.FieldValues[fieldValue]; !has {
 		ddc.FieldValues[fieldValue] = make(map[string]struct{})
 	}
-	ddc.FieldValues[fieldValue][ev.ID] = struct{}{}
+	ddc.FieldValues[fieldValue][evID] = struct{}{}
 
 	// add to events
-	if _, has := ddc.Events[ev.ID]; !has {
-		ddc.Events[ev.ID] = make(map[string]int64)
+	if _, has := ddc.Events[evID]; !has {
+		ddc.Events[evID] = make(map[string]int64)
 	}
-	ddc.Count += 1
-	if _, has := ddc.Events[ev.ID][fieldValue]; !has {
-		ddc.Events[ev.ID][fieldValue] = 1
+	ddc.Count++
+	if _, has := ddc.Events[evID][fieldValue]; !has {
+		ddc.Events[evID][fieldValue] = 1
 		return
 	}
-	ddc.Events[ev.ID][fieldValue] = ddc.Events[ev.ID][fieldValue] + 1
+	ddc.Events[evID][fieldValue] = ddc.Events[evID][fieldValue] + 1
 	return
 }
 
@@ -940,11 +961,11 @@ func (ddc *StatDDC) RemEvent(evID string) (err error) {
 
 	// decrement events
 	var fieldValue string
-	for k, _ := range fieldValues {
+	for k := range fieldValues {
 		fieldValue = k
 		break
 	}
-	ddc.Count -= 1
+	ddc.Count--
 	if fieldValues[fieldValue] > 1 {
 		ddc.Events[evID][fieldValue] = ddc.Events[evID][fieldValue] - 1
 		return // do not delete the reference until it reaches 0
@@ -976,7 +997,7 @@ func (ddc *StatDDC) GetFilterIDs() []string {
 }
 
 func (ddc *StatDDC) Compress(queueLen int64, defaultID string) (eventIDs []string) {
-	for id, _ := range ddc.Events {
+	for id := range ddc.Events {
 		eventIDs = append(eventIDs, id)
 	}
 	return
@@ -1045,32 +1066,25 @@ func (sum *StatSum) GetFloat64Value() (v float64) {
 	return sum.getValue()
 }
 
-func (sum *StatSum) AddEvent(ev *utils.CGREvent) (err error) {
+func (sum *StatSum) AddEvent(evID string, ev utils.DataProvider) (err error) {
 	var val float64
-	switch {
-	case strings.HasPrefix(sum.FieldName, utils.DynamicDataPrefix+utils.MetaReq+utils.NestingSep): // ~*req.
-		//Remove the dynamic prefix and check in event for field
-		field := sum.FieldName[6:]
-		if val, err = ev.FieldAsFloat64(field); err != nil {
-			if err == utils.ErrNotFound {
-				err = utils.ErrPrefix(err, field)
-			}
-			return
-		}
-	default:
-		val, err = utils.IfaceAsFloat64(sum.FieldName)
-		if err != nil {
-			return
+	var ival interface{}
+	if ival, err = utils.DPDynamicInterface(sum.FieldName, ev); err != nil {
+		if err == utils.ErrNotFound {
+			err = utils.ErrPrefix(err, sum.FieldName)
 		}
+		return
+	} else if val, err = utils.IfaceAsFloat64(ival); err != nil {
+		return
 	}
 	sum.Sum += val
-	if v, has := sum.Events[ev.ID]; !has {
-		sum.Events[ev.ID] = &StatWithCompress{Stat: val, CompressFactor: 1}
+	if v, has := sum.Events[evID]; !has {
+		sum.Events[evID] = &StatWithCompress{Stat: val, CompressFactor: 1}
 	} else {
 		v.Stat = (v.Stat*float64(v.CompressFactor) + val) / float64(v.CompressFactor+1)
 		v.CompressFactor = v.CompressFactor + 1
 	}
-	sum.Count += 1
+	sum.Count++
 	sum.val = nil
 	return
 }
@@ -1083,7 +1097,7 @@ func (sum *StatSum) RemEvent(evID string) (err error) {
 	if val.Stat != 0 {
 		sum.Sum -= val.Stat
 	}
-	sum.Count -= 1
+	sum.Count--
 	if val.CompressFactor <= 1 {
 		delete(sum.Events, evID)
 	} else {
@@ -1109,7 +1123,7 @@ func (sum *StatSum) GetFilterIDs() []string {
 // Compress is part of StatMetric interface
 func (sum *StatSum) Compress(queueLen int64, defaultID string) (eventIDs []string) {
 	if sum.Count < queueLen {
-		for id, _ := range sum.Events {
+		for id := range sum.Events {
 			eventIDs = append(eventIDs, id)
 		}
 		return
@@ -1183,32 +1197,25 @@ func (avg *StatAverage) GetFloat64Value() (v float64) {
 	return avg.getValue()
 }
 
-func (avg *StatAverage) AddEvent(ev *utils.CGREvent) (err error) {
+func (avg *StatAverage) AddEvent(evID string, ev utils.DataProvider) (err error) {
 	var val float64
-	switch {
-	case strings.HasPrefix(avg.FieldName, utils.DynamicDataPrefix+utils.MetaReq+utils.NestingSep): // ~*req.
-		//Remove the dynamic prefix and check in event for field
-		field := avg.FieldName[6:]
-		if val, err = ev.FieldAsFloat64(field); err != nil {
-			if err == utils.ErrNotFound {
-				err = utils.ErrPrefix(err, field)
-			}
-			return
-		}
-	default:
-		val, err = utils.IfaceAsFloat64(avg.FieldName)
-		if err != nil {
-			return
+	var ival interface{}
+	if ival, err = utils.DPDynamicInterface(avg.FieldName, ev); err != nil {
+		if err == utils.ErrNotFound {
+			err = utils.ErrPrefix(err, avg.FieldName)
 		}
+		return
+	} else if val, err = utils.IfaceAsFloat64(ival); err != nil {
+		return
 	}
 	avg.Sum += val
-	if v, has := avg.Events[ev.ID]; !has {
-		avg.Events[ev.ID] = &StatWithCompress{Stat: val, CompressFactor: 1}
+	if v, has := avg.Events[evID]; !has {
+		avg.Events[evID] = &StatWithCompress{Stat: val, CompressFactor: 1}
 	} else {
 		v.Stat = (v.Stat*float64(v.CompressFactor) + val) / float64(v.CompressFactor+1)
 		v.CompressFactor = v.CompressFactor + 1
 	}
-	avg.Count += 1
+	avg.Count++
 	avg.val = nil
 	return
 }
@@ -1221,7 +1228,7 @@ func (avg *StatAverage) RemEvent(evID string) (err error) {
 	if val.Stat >= 0 {
 		avg.Sum -= val.Stat
 	}
-	avg.Count -= 1
+	avg.Count--
 	if val.CompressFactor <= 1 {
 		delete(avg.Events, evID)
 	} else {
@@ -1247,7 +1254,7 @@ func (avg *StatAverage) GetFilterIDs() []string {
 // Compress is part of StatMetric interface
 func (avg *StatAverage) Compress(queueLen int64, defaultID string) (eventIDs []string) {
 	if avg.Count < queueLen {
-		for id, _ := range avg.Events {
+		for id := range avg.Events {
 			eventIDs = append(eventIDs, id)
 		}
 		return
@@ -1313,33 +1320,36 @@ func (dst *StatDistinct) GetFloat64Value() (v float64) {
 	return dst.getValue()
 }
 
-func (dst *StatDistinct) AddEvent(ev *utils.CGREvent) (err error) {
+func (dst *StatDistinct) AddEvent(evID string, ev utils.DataProvider) (err error) {
 	var fieldValue string
 	// simply remove the ~*req. prefix and do normal process
 	if !strings.HasPrefix(dst.FieldName, utils.DynamicDataPrefix+utils.MetaReq+utils.NestingSep) {
 		return fmt.Errorf("Invalid format for field <%s>", dst.FieldName)
 	}
-	field := dst.FieldName[6:]
-	if fieldValue, err = ev.FieldAsString(field); err != nil {
-		return err
+
+	if fieldValue, err = utils.DPDynamicString(dst.FieldName, ev); err != nil {
+		if err == utils.ErrNotFound {
+			err = utils.ErrPrefix(err, dst.FieldName)
+		}
+		return
 	}
 
 	// add to fieldValues
 	if _, has := dst.FieldValues[fieldValue]; !has {
 		dst.FieldValues[fieldValue] = make(map[string]struct{})
 	}
-	dst.FieldValues[fieldValue][ev.ID] = struct{}{}
+	dst.FieldValues[fieldValue][evID] = struct{}{}
 
 	// add to events
-	if _, has := dst.Events[ev.ID]; !has {
-		dst.Events[ev.ID] = make(map[string]int64)
+	if _, has := dst.Events[evID]; !has {
+		dst.Events[evID] = make(map[string]int64)
 	}
-	dst.Count += 1
-	if _, has := dst.Events[ev.ID][fieldValue]; !has {
-		dst.Events[ev.ID][fieldValue] = 1
+	dst.Count++
+	if _, has := dst.Events[evID][fieldValue]; !has {
+		dst.Events[evID][fieldValue] = 1
 		return
 	}
-	dst.Events[ev.ID][fieldValue] = dst.Events[ev.ID][fieldValue] + 1
+	dst.Events[evID][fieldValue] = dst.Events[evID][fieldValue] + 1
 	return
 }
 
@@ -1355,11 +1365,11 @@ func (dst *StatDistinct) RemEvent(evID string) (err error) {
 
 	// decrement events
 	var fieldValue string
-	for k, _ := range fieldValues {
+	for k := range fieldValues {
 		fieldValue = k
 		break
 	}
-	dst.Count -= 1
+	dst.Count--
 	if fieldValues[fieldValue] > 1 {
 		dst.Events[evID][fieldValue] = dst.Events[evID][fieldValue] - 1
 		return // do not delete the reference until it reaches 0
@@ -1391,7 +1401,7 @@ func (dst *StatDistinct) GetFilterIDs() []string {
 }
 
 func (dst *StatDistinct) Compress(queueLen int64, defaultID string) (eventIDs []string) {
-	for id, _ := range dst.Events {
+	for id := range dst.Events {
 		eventIDs = append(eventIDs, id)
 	}
 	return
diff --git a/engine/statmetrics_test.go b/engine/statmetrics_test.go
index 0105bccdf..0bb7594a1 100644
--- a/engine/statmetrics_test.go
+++ b/engine/statmetrics_test.go
@@ -36,17 +36,17 @@ func TestASRGetStringValue(t *testing.T) {
 	if strVal := asr.GetStringValue(""); strVal != utils.NOT_AVAILABLE {
 		t.Errorf("wrong asr value: %s", strVal)
 	}
-	asr.AddEvent(ev)
+	asr.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	if strVal := asr.GetStringValue(""); strVal != utils.NOT_AVAILABLE {
 		t.Errorf("wrong asr value: %s", strVal)
 	}
 	ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2"}
 	ev3 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_3"}
-	asr.AddEvent(ev2)
+	asr.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if strVal := asr.GetStringValue(""); strVal != "50%" {
 		t.Errorf("wrong asr value: %s", strVal)
 	}
-	asr.AddEvent(ev3)
+	asr.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event})
 	if strVal := asr.GetStringValue(""); strVal != "33.33333%" {
 		t.Errorf("wrong asr value: %s", strVal)
 	}
@@ -60,8 +60,8 @@ func TestASRGetStringValue(t *testing.T) {
 	ev5 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_5",
 		Event: map[string]interface{}{
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC)}}
-	asr.AddEvent(ev4)
-	asr.AddEvent(ev5)
+	asr.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
+	asr.AddEvent(ev5.ID, utils.MapStorage{utils.MetaReq: ev5.Event})
 	asr.RemEvent(ev.ID)
 	if strVal := asr.GetStringValue(""); strVal != "66.66667%" {
 		t.Errorf("wrong asr value: %s", strVal)
@@ -84,16 +84,16 @@ func TestASRGetStringValue2(t *testing.T) {
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC)}}
 	ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2"}
 	ev4 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_1"}
-	asr.AddEvent(ev)
-	asr.AddEvent(ev2)
+	asr.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
+	asr.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if strVal := asr.GetStringValue(""); strVal != "50%" {
 		t.Errorf("wrong asr value: %s", strVal)
 	}
-	asr.AddEvent(ev2)
+	asr.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if strVal := asr.GetStringValue(""); strVal != "33.33333%" {
 		t.Errorf("wrong asr value: %s", strVal)
 	}
-	asr.AddEvent(ev4)
+	asr.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
 	if strVal := asr.GetStringValue(""); strVal != "25%" {
 		t.Errorf("wrong asr value: %s", strVal)
 	}
@@ -103,7 +103,7 @@ func TestASRGetStringValue2(t *testing.T) {
 		t.Errorf("wrong asr value: %s", strVal)
 	}
 	asr.RemEvent(ev2.ID)
-	asr.AddEvent(ev)
+	asr.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	if strVal := asr.GetStringValue(""); strVal != "100%" {
 		t.Errorf("wrong asr value: %s", strVal)
 	}
@@ -128,16 +128,16 @@ func TestASRGetStringValue3(t *testing.T) {
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC)}}
 	ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2"}
 	ev4 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_1"}
-	asr.AddEvent(ev)
-	asr.AddEvent(ev2)
+	asr.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
+	asr.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if strVal := asr.GetStringValue(""); strVal != "50%" {
 		t.Errorf("wrong asr value: %s", strVal)
 	}
 	if !reflect.DeepEqual(*expected, *asr) {
 		t.Errorf("Expected: %s , received: %s", utils.ToJSON(expected), utils.ToJSON(asr))
 	}
-	asr.AddEvent(ev2)
-	asr.AddEvent(ev4)
+	asr.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	asr.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
 	v := expected.Events["EVENT_1"]
 	v.Stat = 0.5
 	v.CompressFactor = 2
@@ -177,14 +177,14 @@ func TestASRGetValue(t *testing.T) {
 	ev := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_1",
 		Event: map[string]interface{}{
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC)}}
-	asr.AddEvent(ev)
+	asr.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	if v := asr.GetValue(); v != -1.0 {
 		t.Errorf("wrong asr value: %f", v)
 	}
 	ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2"}
 	ev3 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_3"}
-	asr.AddEvent(ev2)
-	asr.AddEvent(ev3)
+	asr.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	asr.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event})
 	if v := asr.GetValue(); v != 33.33333 {
 		t.Errorf("wrong asr value: %f", v)
 	}
@@ -198,8 +198,8 @@ func TestASRGetValue(t *testing.T) {
 	ev5 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_5",
 		Event: map[string]interface{}{
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC)}}
-	asr.AddEvent(ev4)
-	asr.AddEvent(ev5)
+	asr.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
+	asr.AddEvent(ev5.ID, utils.MapStorage{utils.MetaReq: ev5.Event})
 	asr.RemEvent(ev.ID)
 	if v := asr.GetValue(); v != 66.666670 {
 		t.Errorf("wrong asr value: %f", v)
@@ -237,8 +237,8 @@ func TestASRCompress(t *testing.T) {
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC)}}
 	ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2"}
 	ev4 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_1"}
-	asr.AddEvent(ev)
-	asr.AddEvent(ev2)
+	asr.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
+	asr.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	expIDs := []string{"EVENT_1", "EVENT_2"}
 	rply := asr.Compress(10, "EVENT_3")
 	sort.Strings(rply)
@@ -271,8 +271,8 @@ func TestASRCompress(t *testing.T) {
 	if !reflect.DeepEqual(*expected, *asr) {
 		t.Errorf("Expected: %s , received: %s", utils.ToJSON(expected), utils.ToJSON(asr))
 	}
-	asr.AddEvent(ev2)
-	asr.AddEvent(ev4)
+	asr.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	asr.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
 	v := expected.Events["EVENT_3"]
 	v.Stat = 0.25
 	v.CompressFactor = 4
@@ -302,17 +302,17 @@ func TestASRGetCompressFactor(t *testing.T) {
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC)}}
 	ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2"}
 	ev4 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_1"}
-	asr.AddEvent(ev)
-	asr.AddEvent(ev2)
+	asr.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
+	asr.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if CF = asr.GetCompressFactor(make(map[string]int)); !reflect.DeepEqual(expectedCF, CF) {
 		t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedCF), utils.ToJSON(CF))
 	}
-	asr.AddEvent(ev2)
+	asr.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	expectedCF["EVENT_2"] = 2
 	if CF = asr.GetCompressFactor(make(map[string]int)); !reflect.DeepEqual(expectedCF, CF) {
 		t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedCF), utils.ToJSON(CF))
 	}
-	asr.AddEvent(ev4)
+	asr.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
 	expectedCF["EVENT_2"] = 3
 	expectedCF["EVENT_1"] = 2
 	CF["EVENT_2"] = 3
@@ -331,7 +331,7 @@ func TestACDGetStringValue(t *testing.T) {
 	if strVal := acd.GetStringValue(""); strVal != utils.NOT_AVAILABLE {
 		t.Errorf("wrong acd value: %s", strVal)
 	}
-	if err := acd.AddEvent(ev); err != nil {
+	if err := acd.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event}); err != nil {
 		t.Error(err)
 	}
 	if strVal := acd.GetStringValue(""); strVal != utils.NOT_AVAILABLE {
@@ -339,10 +339,10 @@ func TestACDGetStringValue(t *testing.T) {
 	}
 	ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2"}
 	ev3 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_3"}
-	if err := acd.AddEvent(ev2); err == nil || err.Error() != "NOT_FOUND:Usage" {
+	if err := acd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event}); err == nil || err.Error() != "NOT_FOUND:Usage" {
 		t.Error(err)
 	}
-	if err := acd.AddEvent(ev3); err == nil || err.Error() != "NOT_FOUND:Usage" {
+	if err := acd.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event}); err == nil || err.Error() != "NOT_FOUND:Usage" {
 		t.Error(err)
 	}
 	if strVal := acd.GetStringValue(""); strVal != utils.NOT_AVAILABLE {
@@ -367,11 +367,11 @@ func TestACDGetStringValue(t *testing.T) {
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 		},
 	}
-	acd.AddEvent(ev4)
+	acd.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
 	if strVal := acd.GetStringValue(""); strVal != utils.NOT_AVAILABLE {
 		t.Errorf("wrong acd value: %s", strVal)
 	}
-	acd.AddEvent(ev5)
+	acd.AddEvent(ev5.ID, utils.MapStorage{utils.MetaReq: ev5.Event})
 	if strVal := acd.GetStringValue(""); strVal != "15.73043s" {
 		t.Errorf("wrong acd value: %s", strVal)
 	}
@@ -391,17 +391,17 @@ func TestACDGetStringValue2(t *testing.T) {
 	acd, _ := NewACD(2, "", []string{})
 	ev1 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_1",
 		Event: map[string]interface{}{utils.Usage: time.Duration(2 * time.Minute)}}
-	if err := acd.AddEvent(ev1); err != nil {
+	if err := acd.AddEvent(ev1.ID, utils.MapStorage{utils.MetaReq: ev1.Event}); err != nil {
 		t.Error(err)
 	}
 	ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2",
 		Event: map[string]interface{}{"Usage": time.Duration(1 * time.Minute)}}
-	acd.AddEvent(ev2)
+	acd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if strVal := acd.GetStringValue(""); strVal != "1m30s" {
 		t.Errorf("wrong acd value: %s", strVal)
 	}
-	acd.AddEvent(ev2)
-	acd.AddEvent(ev2)
+	acd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	acd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if strVal := acd.GetStringValue(""); strVal != "1m15s" {
 		t.Errorf("wrong acd value: %s", strVal)
 	}
@@ -430,13 +430,13 @@ func TestACDGetStringValue3(t *testing.T) {
 		Event: map[string]interface{}{utils.Usage: time.Duration(3 * time.Minute)}}
 	ev3 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_3",
 		Event: map[string]interface{}{"Usage": time.Duration(1 * time.Minute)}}
-	if err := acd.AddEvent(ev1); err != nil {
+	if err := acd.AddEvent(ev1.ID, utils.MapStorage{utils.MetaReq: ev1.Event}); err != nil {
 		t.Error(err)
 	}
-	if err := acd.AddEvent(ev2); err != nil {
+	if err := acd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event}); err != nil {
 		t.Error(err)
 	}
-	if err := acd.AddEvent(ev3); err != nil {
+	if err := acd.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event}); err != nil {
 		t.Error(err)
 	}
 	acd.GetStringValue("")
@@ -475,9 +475,9 @@ func TestACDCompress(t *testing.T) {
 		Event: map[string]interface{}{utils.Usage: time.Duration(3 * time.Minute)}}
 	ev3 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_3",
 		Event: map[string]interface{}{"Usage": time.Duration(1 * time.Minute)}}
-	acd.AddEvent(ev1)
-	acd.AddEvent(ev2)
-	acd.AddEvent(ev3)
+	acd.AddEvent(ev1.ID, utils.MapStorage{utils.MetaReq: ev1.Event})
+	acd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	acd.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event})
 	expIDs := []string{"EVENT_1", "EVENT_3"}
 	rply := acd.Compress(10, "EVENT_3")
 	sort.Strings(rply)
@@ -524,17 +524,17 @@ func TestACDGetCompressFactor(t *testing.T) {
 	ev4 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2",
 		Event: map[string]interface{}{utils.Usage: time.Duration(2 * time.Minute)}}
 
-	acd.AddEvent(ev)
-	acd.AddEvent(ev2)
+	acd.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
+	acd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if CF = acd.GetCompressFactor(make(map[string]int)); !reflect.DeepEqual(expectedCF, CF) {
 		t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedCF), utils.ToJSON(CF))
 	}
-	acd.AddEvent(ev2)
+	acd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	expectedCF["EVENT_2"] = 2
 	if CF = acd.GetCompressFactor(make(map[string]int)); !reflect.DeepEqual(expectedCF, CF) {
 		t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedCF), utils.ToJSON(CF))
 	}
-	acd.AddEvent(ev4)
+	acd.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
 	expectedCF["EVENT_2"] = 3
 	CF["EVENT_2"] = 3
 	if CF = acd.GetCompressFactor(CF); !reflect.DeepEqual(expectedCF, CF) {
@@ -548,12 +548,12 @@ func TestACDGetFloat64Value(t *testing.T) {
 		Event: map[string]interface{}{
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 			"Usage":      time.Duration(10 * time.Second)}}
-	acd.AddEvent(ev)
+	acd.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	if v := acd.GetFloat64Value(); v != -1.0 {
 		t.Errorf("wrong acd value: %v", v)
 	}
 	ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2"}
-	acd.AddEvent(ev2)
+	acd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if v := acd.GetFloat64Value(); v != -1.0 {
 		t.Errorf("wrong acd value: %v", v)
 	}
@@ -569,11 +569,11 @@ func TestACDGetFloat64Value(t *testing.T) {
 			"AnswerTime": time.Date(2015, 7, 14, 14, 25, 0, 0, time.UTC),
 		},
 	}
-	acd.AddEvent(ev4)
+	acd.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
 	if strVal := acd.GetFloat64Value(); strVal != 35.0 {
 		t.Errorf("wrong acd value: %v", strVal)
 	}
-	acd.AddEvent(ev5)
+	acd.AddEvent(ev5.ID, utils.MapStorage{utils.MetaReq: ev5.Event})
 	// by default rounding decimal is 5
 	if strVal := acd.GetFloat64Value(); strVal != 53.33333 {
 		t.Errorf("wrong acd value: %v", strVal)
@@ -626,7 +626,7 @@ func TestACDGetValue(t *testing.T) {
 		Event: map[string]interface{}{
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 			"Usage":      time.Duration(10 * time.Second)}}
-	acd.AddEvent(ev)
+	acd.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	if v := acd.GetValue(); v != time.Duration((-1)*time.Nanosecond) {
 		t.Errorf("wrong acd value: %+v", v)
 	}
@@ -635,8 +635,8 @@ func TestACDGetValue(t *testing.T) {
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 			"Usage":      time.Duration(8 * time.Second)}}
 	ev3 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_3"}
-	acd.AddEvent(ev2)
-	acd.AddEvent(ev3)
+	acd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	acd.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event})
 	if v := acd.GetValue(); v != time.Duration(9*time.Second) {
 		t.Errorf("wrong acd value: %+v", v)
 	}
@@ -660,8 +660,8 @@ func TestACDGetValue(t *testing.T) {
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 		},
 	}
-	acd.AddEvent(ev4)
-	acd.AddEvent(ev5)
+	acd.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
+	acd.AddEvent(ev5.ID, utils.MapStorage{utils.MetaReq: ev5.Event})
 	if v := acd.GetValue(); v != time.Duration(2*time.Minute+45*time.Second) {
 		t.Errorf("wrong acd value: %+v", v)
 	}
@@ -686,7 +686,7 @@ func TestTCDGetStringValue(t *testing.T) {
 	if strVal := tcd.GetStringValue(""); strVal != utils.NOT_AVAILABLE {
 		t.Errorf("wrong tcd value: %s", strVal)
 	}
-	tcd.AddEvent(ev)
+	tcd.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	if strVal := tcd.GetStringValue(""); strVal != utils.NOT_AVAILABLE {
 		t.Errorf("wrong tcd value: %s", strVal)
 	}
@@ -696,8 +696,8 @@ func TestTCDGetStringValue(t *testing.T) {
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 		}}
 	ev3 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_3"}
-	tcd.AddEvent(ev2)
-	tcd.AddEvent(ev3)
+	tcd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	tcd.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event})
 	if strVal := tcd.GetStringValue(""); strVal != "20s" {
 		t.Errorf("wrong tcd value: %s", strVal)
 	}
@@ -721,8 +721,8 @@ func TestTCDGetStringValue(t *testing.T) {
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 		},
 	}
-	tcd.AddEvent(ev4)
-	tcd.AddEvent(ev5)
+	tcd.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
+	tcd.AddEvent(ev5.ID, utils.MapStorage{utils.MetaReq: ev5.Event})
 	if strVal := tcd.GetStringValue(""); strVal != "2m30s" {
 		t.Errorf("wrong tcd value: %s", strVal)
 	}
@@ -741,17 +741,17 @@ func TestTCDGetStringValue2(t *testing.T) {
 	tcd, _ := NewTCD(2, "", []string{})
 	ev1 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_1",
 		Event: map[string]interface{}{utils.Usage: time.Duration(2 * time.Minute)}}
-	if err := tcd.AddEvent(ev1); err != nil {
+	if err := tcd.AddEvent(ev1.ID, utils.MapStorage{utils.MetaReq: ev1.Event}); err != nil {
 		t.Error(err)
 	}
 	ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2",
 		Event: map[string]interface{}{"Usage": time.Duration(1 * time.Minute)}}
-	tcd.AddEvent(ev2)
+	tcd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if strVal := tcd.GetStringValue(""); strVal != "3m0s" {
 		t.Errorf("wrong tcd value: %s", strVal)
 	}
-	tcd.AddEvent(ev2)
-	tcd.AddEvent(ev2)
+	tcd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	tcd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if strVal := tcd.GetStringValue(""); strVal != "5m0s" {
 		t.Errorf("wrong tcd value: %s", strVal)
 	}
@@ -780,13 +780,13 @@ func TestTCDGetStringValue3(t *testing.T) {
 		Event: map[string]interface{}{utils.Usage: time.Duration(3 * time.Minute)}}
 	ev3 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_3",
 		Event: map[string]interface{}{"Usage": time.Duration(1 * time.Minute)}}
-	if err := tcd.AddEvent(ev1); err != nil {
+	if err := tcd.AddEvent(ev1.ID, utils.MapStorage{utils.MetaReq: ev1.Event}); err != nil {
 		t.Error(err)
 	}
-	if err := tcd.AddEvent(ev2); err != nil {
+	if err := tcd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event}); err != nil {
 		t.Error(err)
 	}
-	if err := tcd.AddEvent(ev3); err != nil {
+	if err := tcd.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event}); err != nil {
 		t.Error(err)
 	}
 	tcd.GetStringValue("")
@@ -812,12 +812,12 @@ func TestTCDGetFloat64Value(t *testing.T) {
 		Event: map[string]interface{}{
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 			"Usage":      time.Duration(10 * time.Second)}}
-	tcd.AddEvent(ev)
+	tcd.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	if v := tcd.GetFloat64Value(); v != -1.0 {
 		t.Errorf("wrong tcd value: %f", v)
 	}
 	ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2"}
-	tcd.AddEvent(ev2)
+	tcd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if v := tcd.GetFloat64Value(); v != -1.0 {
 		t.Errorf("wrong tcd value: %f", v)
 	}
@@ -833,11 +833,11 @@ func TestTCDGetFloat64Value(t *testing.T) {
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 		},
 	}
-	tcd.AddEvent(ev4)
+	tcd.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
 	if strVal := tcd.GetFloat64Value(); strVal != 70.0 {
 		t.Errorf("wrong tcd value: %f", strVal)
 	}
-	tcd.AddEvent(ev5)
+	tcd.AddEvent(ev5.ID, utils.MapStorage{utils.MetaReq: ev5.Event})
 	if strVal := tcd.GetFloat64Value(); strVal != 160.0 {
 		t.Errorf("wrong tcd value: %f", strVal)
 	}
@@ -865,7 +865,7 @@ func TestTCDGetValue(t *testing.T) {
 		Event: map[string]interface{}{
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 			"Usage":      time.Duration(10 * time.Second)}}
-	tcd.AddEvent(ev)
+	tcd.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	if v := tcd.GetValue(); v != time.Duration((-1)*time.Nanosecond) {
 		t.Errorf("wrong tcd value: %+v", v)
 	}
@@ -874,8 +874,8 @@ func TestTCDGetValue(t *testing.T) {
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 			"Usage":      time.Duration(5 * time.Second)}}
 	ev3 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_3"}
-	tcd.AddEvent(ev2)
-	tcd.AddEvent(ev3)
+	tcd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	tcd.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event})
 	if v := tcd.GetValue(); v != time.Duration(15*time.Second) {
 		t.Errorf("wrong tcd value: %+v", v)
 	}
@@ -899,8 +899,8 @@ func TestTCDGetValue(t *testing.T) {
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 		},
 	}
-	tcd.AddEvent(ev4)
-	tcd.AddEvent(ev5)
+	tcd.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
+	tcd.AddEvent(ev5.ID, utils.MapStorage{utils.MetaReq: ev5.Event})
 	if v := tcd.GetValue(); v != time.Duration(2*time.Minute+30*time.Second) {
 		t.Errorf("wrong tcd value: %+v", v)
 	}
@@ -934,9 +934,9 @@ func TestTCDCompress(t *testing.T) {
 		Event: map[string]interface{}{utils.Usage: time.Duration(3 * time.Minute)}}
 	ev3 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_3",
 		Event: map[string]interface{}{"Usage": time.Duration(1 * time.Minute)}}
-	tcd.AddEvent(ev1)
-	tcd.AddEvent(ev2)
-	tcd.AddEvent(ev3)
+	tcd.AddEvent(ev1.ID, utils.MapStorage{utils.MetaReq: ev1.Event})
+	tcd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	tcd.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event})
 	expIDs := []string{"EVENT_1", "EVENT_3"}
 	rply := tcd.Compress(10, "EVENT_3")
 	sort.Strings(rply)
@@ -983,17 +983,17 @@ func TestTCDGetCompressFactor(t *testing.T) {
 	ev4 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2",
 		Event: map[string]interface{}{utils.Usage: time.Duration(2 * time.Minute)}}
 
-	tcd.AddEvent(ev)
-	tcd.AddEvent(ev2)
+	tcd.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
+	tcd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if CF = tcd.GetCompressFactor(make(map[string]int)); !reflect.DeepEqual(expectedCF, CF) {
 		t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedCF), utils.ToJSON(CF))
 	}
-	tcd.AddEvent(ev2)
+	tcd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	expectedCF["EVENT_2"] = 2
 	if CF = tcd.GetCompressFactor(make(map[string]int)); !reflect.DeepEqual(expectedCF, CF) {
 		t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedCF), utils.ToJSON(CF))
 	}
-	tcd.AddEvent(ev4)
+	tcd.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
 	expectedCF["EVENT_2"] = 3
 	CF["EVENT_2"] = 3
 	if CF = tcd.GetCompressFactor(CF); !reflect.DeepEqual(expectedCF, CF) {
@@ -1010,7 +1010,7 @@ func TestACCGetStringValue(t *testing.T) {
 	if strVal := acc.GetStringValue(""); strVal != utils.NOT_AVAILABLE {
 		t.Errorf("wrong acc value: %s", strVal)
 	}
-	acc.AddEvent(ev)
+	acc.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	if strVal := acc.GetStringValue(""); strVal != utils.NOT_AVAILABLE {
 		t.Errorf("wrong acc value: %s", strVal)
 	}
@@ -1019,8 +1019,8 @@ func TestACCGetStringValue(t *testing.T) {
 		Event: map[string]interface{}{
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 			"Cost":       12.3}}
-	acc.AddEvent(ev2)
-	acc.AddEvent(ev3)
+	acc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	acc.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event})
 	if strVal := acc.GetStringValue(""); strVal != "12.3" {
 		t.Errorf("wrong acc value: %s", strVal)
 	}
@@ -1036,8 +1036,8 @@ func TestACCGetStringValue(t *testing.T) {
 		Event: map[string]interface{}{
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 			"Cost":       1.2}}
-	acc.AddEvent(ev4)
-	acc.AddEvent(ev5)
+	acc.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
+	acc.AddEvent(ev5.ID, utils.MapStorage{utils.MetaReq: ev5.Event})
 	acc.RemEvent(ev.ID)
 	if strVal := acc.GetStringValue(""); strVal != "3.4" {
 		t.Errorf("wrong acc value: %s", strVal)
@@ -1057,17 +1057,17 @@ func TestACCGetStringValue2(t *testing.T) {
 	acc, _ := NewACC(2, "", []string{})
 	ev1 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_1",
 		Event: map[string]interface{}{"Cost": 12.3}}
-	if err := acc.AddEvent(ev1); err != nil {
+	if err := acc.AddEvent(ev1.ID, utils.MapStorage{utils.MetaReq: ev1.Event}); err != nil {
 		t.Error(err)
 	}
 	ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2",
 		Event: map[string]interface{}{"Cost": 18.3}}
-	acc.AddEvent(ev2)
+	acc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if strVal := acc.GetStringValue(""); strVal != "15.3" {
 		t.Errorf("wrong acc value: %s", strVal)
 	}
-	acc.AddEvent(ev2)
-	acc.AddEvent(ev2)
+	acc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	acc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if strVal := acc.GetStringValue(""); strVal != "16.8" {
 		t.Errorf("wrong acc value: %s", strVal)
 	}
@@ -1096,13 +1096,13 @@ func TestACCGetStringValue3(t *testing.T) {
 		Event: map[string]interface{}{"Cost": 6.2}}
 	ev3 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_3",
 		Event: map[string]interface{}{"Cost": 18.3}}
-	if err := acc.AddEvent(ev1); err != nil {
+	if err := acc.AddEvent(ev1.ID, utils.MapStorage{utils.MetaReq: ev1.Event}); err != nil {
 		t.Error(err)
 	}
-	if err := acc.AddEvent(ev2); err != nil {
+	if err := acc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event}); err != nil {
 		t.Error(err)
 	}
-	if err := acc.AddEvent(ev3); err != nil {
+	if err := acc.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event}); err != nil {
 		t.Error(err)
 	}
 	acc.GetStringValue("")
@@ -1131,14 +1131,14 @@ func TestACCGetValue(t *testing.T) {
 	if strVal := acc.GetValue(); strVal != -1.0 {
 		t.Errorf("wrong acc value: %v", strVal)
 	}
-	acc.AddEvent(ev)
+	acc.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	if strVal := acc.GetValue(); strVal != -1.0 {
 		t.Errorf("wrong acc value: %v", strVal)
 	}
 	ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2"}
 	ev3 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_3"}
-	acc.AddEvent(ev2)
-	acc.AddEvent(ev3)
+	acc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	acc.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event})
 	if strVal := acc.GetValue(); strVal != -1.0 {
 		t.Errorf("wrong acc value: %v", strVal)
 	}
@@ -1154,8 +1154,8 @@ func TestACCGetValue(t *testing.T) {
 		Event: map[string]interface{}{
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 			"Cost":       "1.2"}}
-	acc.AddEvent(ev4)
-	acc.AddEvent(ev5)
+	acc.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
+	acc.AddEvent(ev5.ID, utils.MapStorage{utils.MetaReq: ev5.Event})
 	acc.RemEvent(ev.ID)
 	if strVal := acc.GetValue(); strVal != 3.4 {
 		t.Errorf("wrong acc value: %v", strVal)
@@ -1191,8 +1191,8 @@ func TestACCCompress(t *testing.T) {
 		Event: map[string]interface{}{"Cost": 6.2}}
 	ev4 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_1",
 		Event: map[string]interface{}{"Cost": 18.3}}
-	acc.AddEvent(ev)
-	acc.AddEvent(ev2)
+	acc.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
+	acc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	expIDs := []string{"EVENT_1", "EVENT_2"}
 	rply := acc.Compress(10, "EVENT_3")
 	sort.Strings(rply)
@@ -1221,8 +1221,8 @@ func TestACCCompress(t *testing.T) {
 	if !reflect.DeepEqual(*expected, *acc) {
 		t.Errorf("Expected: %s , received: %s", utils.ToJSON(expected), utils.ToJSON(acc))
 	}
-	acc.AddEvent(ev2)
-	acc.AddEvent(ev4)
+	acc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	acc.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
 	v := expected.Events["EVENT_3"]
 	v.Stat = 12.225
 	v.CompressFactor = 4
@@ -1252,17 +1252,17 @@ func TestACCGetCompressFactor(t *testing.T) {
 		Event: map[string]interface{}{"Cost": 18.2}}
 	ev4 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_1",
 		Event: map[string]interface{}{"Cost": 18.2}}
-	acc.AddEvent(ev)
-	acc.AddEvent(ev2)
+	acc.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
+	acc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if CF = acc.GetCompressFactor(make(map[string]int)); !reflect.DeepEqual(expectedCF, CF) {
 		t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedCF), utils.ToJSON(CF))
 	}
-	acc.AddEvent(ev2)
+	acc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	expectedCF["EVENT_2"] = 2
 	if CF = acc.GetCompressFactor(make(map[string]int)); !reflect.DeepEqual(expectedCF, CF) {
 		t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedCF), utils.ToJSON(CF))
 	}
-	acc.AddEvent(ev4)
+	acc.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
 	expectedCF["EVENT_2"] = 3
 	expectedCF["EVENT_1"] = 2
 	CF["EVENT_2"] = 3
@@ -1280,7 +1280,7 @@ func TestTCCGetStringValue(t *testing.T) {
 	if strVal := tcc.GetStringValue(""); strVal != utils.NOT_AVAILABLE {
 		t.Errorf("wrong tcc value: %s", strVal)
 	}
-	tcc.AddEvent(ev)
+	tcc.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	if strVal := tcc.GetStringValue(""); strVal != utils.NOT_AVAILABLE {
 		t.Errorf("wrong tcc value: %s", strVal)
 	}
@@ -1289,8 +1289,8 @@ func TestTCCGetStringValue(t *testing.T) {
 		Event: map[string]interface{}{
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 			"Cost":       5.7}}
-	tcc.AddEvent(ev2)
-	tcc.AddEvent(ev3)
+	tcc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	tcc.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event})
 	if strVal := tcc.GetStringValue(""); strVal != "18" {
 		t.Errorf("wrong tcc value: %s", strVal)
 	}
@@ -1306,8 +1306,8 @@ func TestTCCGetStringValue(t *testing.T) {
 		Event: map[string]interface{}{
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 			"Cost":       1.2}}
-	tcc.AddEvent(ev4)
-	tcc.AddEvent(ev5)
+	tcc.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
+	tcc.AddEvent(ev5.ID, utils.MapStorage{utils.MetaReq: ev5.Event})
 	tcc.RemEvent(ev.ID)
 	if strVal := tcc.GetStringValue(""); strVal != "6.8" {
 		t.Errorf("wrong tcc value: %s", strVal)
@@ -1327,17 +1327,17 @@ func TestTCCGetStringValue2(t *testing.T) {
 	tcc, _ := NewTCC(2, "", []string{})
 	ev1 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_1",
 		Event: map[string]interface{}{"Cost": 12.3}}
-	if err := tcc.AddEvent(ev1); err != nil {
+	if err := tcc.AddEvent(ev1.ID, utils.MapStorage{utils.MetaReq: ev1.Event}); err != nil {
 		t.Error(err)
 	}
 	ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2",
 		Event: map[string]interface{}{"Cost": 18.3}}
-	tcc.AddEvent(ev2)
+	tcc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if strVal := tcc.GetStringValue(""); strVal != "30.6" {
 		t.Errorf("wrong tcc value: %s", strVal)
 	}
-	tcc.AddEvent(ev2)
-	tcc.AddEvent(ev2)
+	tcc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	tcc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if strVal := tcc.GetStringValue(""); strVal != "67.2" {
 		t.Errorf("wrong tcc value: %s", strVal)
 	}
@@ -1366,13 +1366,13 @@ func TestTCCGetStringValue3(t *testing.T) {
 		Event: map[string]interface{}{"Cost": 6.2}}
 	ev3 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_3",
 		Event: map[string]interface{}{"Cost": 18.3}}
-	if err := tcc.AddEvent(ev1); err != nil {
+	if err := tcc.AddEvent(ev1.ID, utils.MapStorage{utils.MetaReq: ev1.Event}); err != nil {
 		t.Error(err)
 	}
-	if err := tcc.AddEvent(ev2); err != nil {
+	if err := tcc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event}); err != nil {
 		t.Error(err)
 	}
-	if err := tcc.AddEvent(ev3); err != nil {
+	if err := tcc.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event}); err != nil {
 		t.Error(err)
 	}
 	tcc.GetStringValue("")
@@ -1401,7 +1401,7 @@ func TestTCCGetValue(t *testing.T) {
 	if strVal := tcc.GetValue(); strVal != -1.0 {
 		t.Errorf("wrong tcc value: %v", strVal)
 	}
-	tcc.AddEvent(ev)
+	tcc.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	if strVal := tcc.GetValue(); strVal != -1.0 {
 		t.Errorf("wrong tcc value: %v", strVal)
 	}
@@ -1410,8 +1410,8 @@ func TestTCCGetValue(t *testing.T) {
 		Event: map[string]interface{}{
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 			"Cost":       1.2}}
-	tcc.AddEvent(ev2)
-	tcc.AddEvent(ev3)
+	tcc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	tcc.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event})
 	if strVal := tcc.GetValue(); strVal != 13.5 {
 		t.Errorf("wrong tcc value: %v", strVal)
 	}
@@ -1427,8 +1427,8 @@ func TestTCCGetValue(t *testing.T) {
 		Event: map[string]interface{}{
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 			"Cost":       "1.2"}}
-	tcc.AddEvent(ev4)
-	tcc.AddEvent(ev5)
+	tcc.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
+	tcc.AddEvent(ev5.ID, utils.MapStorage{utils.MetaReq: ev5.Event})
 	tcc.RemEvent(ev.ID)
 	if strVal := tcc.GetValue(); strVal != 6.8 {
 		t.Errorf("wrong tcc value: %v", strVal)
@@ -1464,8 +1464,8 @@ func TestTCCCompress(t *testing.T) {
 		Event: map[string]interface{}{"Cost": 6.2}}
 	ev4 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_1",
 		Event: map[string]interface{}{"Cost": 18.3}}
-	tcc.AddEvent(ev)
-	tcc.AddEvent(ev2)
+	tcc.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
+	tcc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	expIDs := []string{"EVENT_1", "EVENT_2"}
 	rply := tcc.Compress(10, "EVENT_3")
 	sort.Strings(rply)
@@ -1494,8 +1494,8 @@ func TestTCCCompress(t *testing.T) {
 	if !reflect.DeepEqual(*expected, *tcc) {
 		t.Errorf("Expected: %s , received: %s", utils.ToJSON(expected), utils.ToJSON(tcc))
 	}
-	tcc.AddEvent(ev2)
-	tcc.AddEvent(ev4)
+	tcc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	tcc.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
 	v := expected.Events["EVENT_3"]
 	v.Stat = 12.225
 	v.CompressFactor = 4
@@ -1525,17 +1525,17 @@ func TestTCCGetCompressFactor(t *testing.T) {
 		Event: map[string]interface{}{"Cost": 18.2}}
 	ev4 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_1",
 		Event: map[string]interface{}{"Cost": 18.2}}
-	tcc.AddEvent(ev)
-	tcc.AddEvent(ev2)
+	tcc.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
+	tcc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if CF = tcc.GetCompressFactor(make(map[string]int)); !reflect.DeepEqual(expectedCF, CF) {
 		t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedCF), utils.ToJSON(CF))
 	}
-	tcc.AddEvent(ev2)
+	tcc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	expectedCF["EVENT_2"] = 2
 	if CF = tcc.GetCompressFactor(make(map[string]int)); !reflect.DeepEqual(expectedCF, CF) {
 		t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedCF), utils.ToJSON(CF))
 	}
-	tcc.AddEvent(ev4)
+	tcc.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
 	expectedCF["EVENT_2"] = 3
 	expectedCF["EVENT_1"] = 2
 	CF["EVENT_2"] = 3
@@ -1555,14 +1555,14 @@ func TestPDDGetStringValue(t *testing.T) {
 	if strVal := pdd.GetStringValue(""); strVal != utils.NOT_AVAILABLE {
 		t.Errorf("wrong pdd value: %s", strVal)
 	}
-	pdd.AddEvent(ev)
+	pdd.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	if strVal := pdd.GetStringValue(""); strVal != utils.NOT_AVAILABLE {
 		t.Errorf("wrong pdd value: %s", strVal)
 	}
 	ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2"}
 	ev3 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_3"}
-	pdd.AddEvent(ev2)
-	pdd.AddEvent(ev3)
+	pdd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	pdd.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event})
 	if strVal := pdd.GetStringValue(""); strVal != utils.NOT_AVAILABLE {
 		t.Errorf("wrong pdd value: %s", strVal)
 	}
@@ -1586,11 +1586,11 @@ func TestPDDGetStringValue(t *testing.T) {
 			utils.PDD: time.Duration(10 * time.Second),
 		},
 	}
-	pdd.AddEvent(ev4)
+	pdd.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
 	if strVal := pdd.GetStringValue(""); strVal != utils.NOT_AVAILABLE {
 		t.Errorf("wrong pdd value: %s", strVal)
 	}
-	pdd.AddEvent(ev5)
+	pdd.AddEvent(ev5.ID, utils.MapStorage{utils.MetaReq: ev5.Event})
 	if strVal := pdd.GetStringValue(""); strVal != "10s" {
 		t.Errorf("wrong pdd value: %s", strVal)
 	}
@@ -1610,17 +1610,17 @@ func TestPDDGetStringValue2(t *testing.T) {
 	pdd, _ := NewPDD(2, "", []string{})
 	ev1 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_1",
 		Event: map[string]interface{}{utils.PDD: time.Duration(2 * time.Minute)}}
-	if err := pdd.AddEvent(ev1); err != nil {
+	if err := pdd.AddEvent(ev1.ID, utils.MapStorage{utils.MetaReq: ev1.Event}); err != nil {
 		t.Error(err)
 	}
 	ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2",
 		Event: map[string]interface{}{utils.PDD: time.Duration(1 * time.Minute)}}
-	pdd.AddEvent(ev2)
+	pdd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if strVal := pdd.GetStringValue(""); strVal != "1m30s" {
 		t.Errorf("wrong pdd value: %s", strVal)
 	}
-	pdd.AddEvent(ev2)
-	pdd.AddEvent(ev2)
+	pdd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	pdd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if strVal := pdd.GetStringValue(""); strVal != "1m15s" {
 		t.Errorf("wrong pdd value: %s", strVal)
 	}
@@ -1649,13 +1649,13 @@ func TestPDDGetStringValue3(t *testing.T) {
 		Event: map[string]interface{}{utils.PDD: time.Duration(3 * time.Minute)}}
 	ev3 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_3",
 		Event: map[string]interface{}{utils.PDD: time.Duration(1 * time.Minute)}}
-	if err := pdd.AddEvent(ev1); err != nil {
+	if err := pdd.AddEvent(ev1.ID, utils.MapStorage{utils.MetaReq: ev1.Event}); err != nil {
 		t.Error(err)
 	}
-	if err := pdd.AddEvent(ev2); err != nil {
+	if err := pdd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event}); err != nil {
 		t.Error(err)
 	}
-	if err := pdd.AddEvent(ev3); err != nil {
+	if err := pdd.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event}); err != nil {
 		t.Error(err)
 	}
 	pdd.GetStringValue("")
@@ -1682,12 +1682,12 @@ func TestPDDGetFloat64Value(t *testing.T) {
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 			"Usage":      time.Duration(10 * time.Second),
 			utils.PDD:    time.Duration(5 * time.Second)}}
-	pdd.AddEvent(ev)
+	pdd.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	if v := pdd.GetFloat64Value(); v != -1.0 {
 		t.Errorf("wrong pdd value: %v", v)
 	}
 	ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2"}
-	pdd.AddEvent(ev2)
+	pdd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if v := pdd.GetFloat64Value(); v != -1.0 {
 		t.Errorf("wrong pdd value: %v", v)
 	}
@@ -1704,11 +1704,11 @@ func TestPDDGetFloat64Value(t *testing.T) {
 			"AnswerTime": time.Date(2015, 7, 14, 14, 25, 0, 0, time.UTC),
 		},
 	}
-	pdd.AddEvent(ev4)
+	pdd.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
 	if strVal := pdd.GetFloat64Value(); strVal != 7.5 {
 		t.Errorf("wrong pdd value: %v", strVal)
 	}
-	pdd.AddEvent(ev5)
+	pdd.AddEvent(ev5.ID, utils.MapStorage{utils.MetaReq: ev5.Event})
 	if strVal := pdd.GetFloat64Value(); strVal != 7.5 {
 		t.Errorf("wrong pdd value: %v", strVal)
 	}
@@ -1737,7 +1737,7 @@ func TestPDDGetValue(t *testing.T) {
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 			"Usage":      time.Duration(10 * time.Second),
 			utils.PDD:    time.Duration(9 * time.Second)}}
-	pdd.AddEvent(ev)
+	pdd.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	if v := pdd.GetValue(); v != time.Duration((-1)*time.Nanosecond) {
 		t.Errorf("wrong pdd value: %+v", v)
 	}
@@ -1747,10 +1747,10 @@ func TestPDDGetValue(t *testing.T) {
 			"Usage":      time.Duration(8 * time.Second),
 			utils.PDD:    time.Duration(10 * time.Second)}}
 	ev3 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_3"}
-	if err := pdd.AddEvent(ev2); err != nil {
+	if err := pdd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event}); err != nil {
 		t.Error(err)
 	}
-	if err := pdd.AddEvent(ev3); err == nil || err.Error() != "NOT_FOUND:PDD" {
+	if err := pdd.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event}); err == nil || err.Error() != "NOT_FOUND:PDD" {
 		t.Error(err)
 	}
 	if v := pdd.GetValue(); v != time.Duration(9*time.Second+500*time.Millisecond) {
@@ -1781,10 +1781,10 @@ func TestPDDGetValue(t *testing.T) {
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 		},
 	}
-	if err := pdd.AddEvent(ev4); err != nil {
+	if err := pdd.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event}); err != nil {
 		t.Error(err)
 	}
-	if err := pdd.AddEvent(ev5); err == nil || err.Error() != "NOT_FOUND:PDD" {
+	if err := pdd.AddEvent(ev5.ID, utils.MapStorage{utils.MetaReq: ev5.Event}); err == nil || err.Error() != "NOT_FOUND:PDD" {
 		t.Error(err)
 	}
 	if v := pdd.GetValue(); v != time.Duration((-1)*time.Nanosecond) {
@@ -1820,9 +1820,9 @@ func TestPDDCompress(t *testing.T) {
 		Event: map[string]interface{}{utils.PDD: time.Duration(3 * time.Minute)}}
 	ev3 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_3",
 		Event: map[string]interface{}{utils.PDD: time.Duration(1 * time.Minute)}}
-	pdd.AddEvent(ev1)
-	pdd.AddEvent(ev2)
-	pdd.AddEvent(ev3)
+	pdd.AddEvent(ev1.ID, utils.MapStorage{utils.MetaReq: ev1.Event})
+	pdd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	pdd.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event})
 	expIDs := []string{"EVENT_1", "EVENT_3"}
 	rply := pdd.Compress(10, "EVENT_3")
 	sort.Strings(rply)
@@ -1869,17 +1869,17 @@ func TestPDDGetCompressFactor(t *testing.T) {
 	ev4 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2",
 		Event: map[string]interface{}{utils.PDD: time.Duration(2 * time.Minute)}}
 
-	pdd.AddEvent(ev)
-	pdd.AddEvent(ev2)
+	pdd.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
+	pdd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if CF = pdd.GetCompressFactor(make(map[string]int)); !reflect.DeepEqual(expectedCF, CF) {
 		t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedCF), utils.ToJSON(CF))
 	}
-	pdd.AddEvent(ev2)
+	pdd.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	expectedCF["EVENT_2"] = 2
 	if CF = pdd.GetCompressFactor(make(map[string]int)); !reflect.DeepEqual(expectedCF, CF) {
 		t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedCF), utils.ToJSON(CF))
 	}
-	pdd.AddEvent(ev4)
+	pdd.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
 	expectedCF["EVENT_2"] = 3
 	CF["EVENT_2"] = 3
 	if CF = pdd.GetCompressFactor(CF); !reflect.DeepEqual(expectedCF, CF) {
@@ -1897,7 +1897,7 @@ func TestDDCGetStringValue(t *testing.T) {
 		t.Errorf("wrong ddc value: %s", strVal)
 	}
 
-	ddc.AddEvent(ev)
+	ddc.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	if strVal := ddc.GetStringValue(""); strVal != utils.NOT_AVAILABLE {
 		t.Errorf("wrong ddc value: %s", strVal)
 	}
@@ -1910,8 +1910,8 @@ func TestDDCGetStringValue(t *testing.T) {
 		Event: map[string]interface{}{
 			"AnswerTime":      time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 			utils.Destination: "1001"}}
-	ddc.AddEvent(ev2)
-	ddc.AddEvent(ev3)
+	ddc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	ddc.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event})
 	if strVal := ddc.GetStringValue(""); strVal != "2" {
 		t.Errorf("wrong ddc value: %s", strVal)
 	}
@@ -1937,12 +1937,12 @@ func TestDDCGetFloat64Value(t *testing.T) {
 			"Usage":           time.Duration(10 * time.Second),
 			utils.PDD:         time.Duration(5 * time.Second),
 			utils.Destination: "1002"}}
-	ddc.AddEvent(ev)
+	ddc.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	if v := ddc.GetFloat64Value(); v != -1.0 {
 		t.Errorf("wrong ddc value: %v", v)
 	}
 	ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2"}
-	ddc.AddEvent(ev2)
+	ddc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if v := ddc.GetFloat64Value(); v != -1.0 {
 		t.Errorf("wrong ddc value: %v", v)
 	}
@@ -1961,11 +1961,11 @@ func TestDDCGetFloat64Value(t *testing.T) {
 			utils.Destination: "1003",
 		},
 	}
-	ddc.AddEvent(ev4)
+	ddc.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
 	if strVal := ddc.GetFloat64Value(); strVal != 2 {
 		t.Errorf("wrong ddc value: %v", strVal)
 	}
-	ddc.AddEvent(ev5)
+	ddc.AddEvent(ev5.ID, utils.MapStorage{utils.MetaReq: ev5.Event})
 	if strVal := ddc.GetFloat64Value(); strVal != 3 {
 		t.Errorf("wrong ddc value: %v", strVal)
 	}
@@ -1995,13 +1995,13 @@ func TestDDCGetStringValue2(t *testing.T) {
 		t.Errorf("wrong statDistinct value: %s", strVal)
 	}
 
-	statDistinct.AddEvent(ev)
+	statDistinct.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	if strVal := statDistinct.GetStringValue(""); strVal != utils.NOT_AVAILABLE {
 		t.Errorf("wrong statDistinct value: %s", strVal)
 	}
 	ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_1",
 		Event: map[string]interface{}{utils.Destination: "1002"}}
-	statDistinct.AddEvent(ev2)
+	statDistinct.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if strVal := statDistinct.GetStringValue(""); strVal != "2" {
 		t.Errorf("wrong statDistinct value: %s", strVal)
 	}
@@ -2046,9 +2046,9 @@ func TestDDCCompress(t *testing.T) {
 		Event: map[string]interface{}{utils.Destination: "1001"}}
 	ev3 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_3",
 		Event: map[string]interface{}{utils.Destination: "1002"}}
-	ddc.AddEvent(ev1)
-	ddc.AddEvent(ev2)
-	ddc.AddEvent(ev3)
+	ddc.AddEvent(ev1.ID, utils.MapStorage{utils.MetaReq: ev1.Event})
+	ddc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	ddc.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event})
 	expIDs := []string{"EVENT_1", "EVENT_3"}
 	rply := ddc.Compress(10, "EVENT_3")
 	sort.Strings(rply)
@@ -2085,17 +2085,17 @@ func TestDDCGetCompressFactor(t *testing.T) {
 	ev4 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2",
 		Event: map[string]interface{}{utils.Destination: "1001"}}
 
-	ddc.AddEvent(ev)
-	ddc.AddEvent(ev2)
+	ddc.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
+	ddc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if CF = ddc.GetCompressFactor(make(map[string]int)); !reflect.DeepEqual(expectedCF, CF) {
 		t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedCF), utils.ToJSON(CF))
 	}
-	ddc.AddEvent(ev2)
+	ddc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	expectedCF["EVENT_2"] = 2
 	if CF = ddc.GetCompressFactor(make(map[string]int)); !reflect.DeepEqual(expectedCF, CF) {
 		t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedCF), utils.ToJSON(CF))
 	}
-	ddc.AddEvent(ev4)
+	ddc.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
 	expectedCF["EVENT_2"] = 3
 	CF["EVENT_2"] = 3
 	if CF = ddc.GetCompressFactor(CF); !reflect.DeepEqual(expectedCF, CF) {
@@ -2112,12 +2112,12 @@ func TestStatSumGetFloat64Value(t *testing.T) {
 			"Usage":           time.Duration(10 * time.Second),
 			utils.PDD:         time.Duration(5 * time.Second),
 			utils.Destination: "1002"}}
-	statSum.AddEvent(ev)
+	statSum.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	if v := statSum.GetFloat64Value(); v != -1.0 {
 		t.Errorf("wrong statSum value: %v", v)
 	}
 	ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2"}
-	if err := statSum.AddEvent(ev2); err == nil || err.Error() != "NOT_FOUND:Cost" {
+	if err := statSum.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event}); err == nil || err.Error() != "NOT_FOUND:~*req.Cost" {
 		t.Error(err)
 	}
 	if v := statSum.GetFloat64Value(); v != -1.0 {
@@ -2140,11 +2140,11 @@ func TestStatSumGetFloat64Value(t *testing.T) {
 			utils.Destination: "1003",
 		},
 	}
-	statSum.AddEvent(ev4)
+	statSum.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
 	if strVal := statSum.GetFloat64Value(); strVal != 40 {
 		t.Errorf("wrong statSum value: %v", strVal)
 	}
-	statSum.AddEvent(ev5)
+	statSum.AddEvent(ev5.ID, utils.MapStorage{utils.MetaReq: ev5.Event})
 	if strVal := statSum.GetFloat64Value(); strVal != 60 {
 		t.Errorf("wrong statSum value: %v", strVal)
 	}
@@ -2177,7 +2177,7 @@ func TestStatSumGetStringValue(t *testing.T) {
 		t.Errorf("wrong ddc value: %s", strVal)
 	}
 
-	statSum.AddEvent(ev)
+	statSum.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	if strVal := statSum.GetStringValue(""); strVal != utils.NOT_AVAILABLE {
 		t.Errorf("wrong statSum value: %s", strVal)
 	}
@@ -2192,8 +2192,8 @@ func TestStatSumGetStringValue(t *testing.T) {
 			"Cost":            "20",
 			"AnswerTime":      time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 			utils.Destination: "1001"}}
-	statSum.AddEvent(ev2)
-	statSum.AddEvent(ev3)
+	statSum.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	statSum.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event})
 	if strVal := statSum.GetStringValue(""); strVal != "60" {
 		t.Errorf("wrong statSum value: %s", strVal)
 	}
@@ -2215,17 +2215,17 @@ func TestStatSumGetStringValue2(t *testing.T) {
 	statSum, _ := NewStatSum(2, "~*req.Cost", []string{})
 	ev1 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_1",
 		Event: map[string]interface{}{"Cost": 12.3}}
-	if err := statSum.AddEvent(ev1); err != nil {
+	if err := statSum.AddEvent(ev1.ID, utils.MapStorage{utils.MetaReq: ev1.Event}); err != nil {
 		t.Error(err)
 	}
 	ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2",
 		Event: map[string]interface{}{"Cost": 18.3}}
-	statSum.AddEvent(ev2)
+	statSum.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if strVal := statSum.GetStringValue(""); strVal != "30.6" {
 		t.Errorf("wrong statSum value: %s", strVal)
 	}
-	statSum.AddEvent(ev2)
-	statSum.AddEvent(ev2)
+	statSum.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	statSum.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if strVal := statSum.GetStringValue(""); strVal != "67.2" {
 		t.Errorf("wrong statSum value: %s", strVal)
 	}
@@ -2255,13 +2255,13 @@ func TestStatSumGetStringValue3(t *testing.T) {
 		Event: map[string]interface{}{"Cost": 6.2}}
 	ev3 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_3",
 		Event: map[string]interface{}{"Cost": 18.3}}
-	if err := statSum.AddEvent(ev1); err != nil {
+	if err := statSum.AddEvent(ev1.ID, utils.MapStorage{utils.MetaReq: ev1.Event}); err != nil {
 		t.Error(err)
 	}
-	if err := statSum.AddEvent(ev2); err != nil {
+	if err := statSum.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event}); err != nil {
 		t.Error(err)
 	}
-	if err := statSum.AddEvent(ev3); err != nil {
+	if err := statSum.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event}); err != nil {
 		t.Error(err)
 	}
 	statSum.GetStringValue("")
@@ -2302,8 +2302,8 @@ func TestStatSumCompress(t *testing.T) {
 		Event: map[string]interface{}{"Cost": 6.2}}
 	ev4 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_1",
 		Event: map[string]interface{}{"Cost": 18.3}}
-	sum.AddEvent(ev)
-	sum.AddEvent(ev2)
+	sum.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
+	sum.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	expIDs := []string{"EVENT_1", "EVENT_2"}
 	rply := sum.Compress(10, "EVENT_3")
 	sort.Strings(rply)
@@ -2333,8 +2333,8 @@ func TestStatSumCompress(t *testing.T) {
 	if !reflect.DeepEqual(*expected, *sum) {
 		t.Errorf("Expected: %s , received: %s", utils.ToJSON(expected), utils.ToJSON(sum))
 	}
-	sum.AddEvent(ev2)
-	sum.AddEvent(ev4)
+	sum.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	sum.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
 	v := expected.Events["EVENT_3"]
 	v.Stat = 12.225
 	v.CompressFactor = 4
@@ -2364,17 +2364,17 @@ func TestStatSumGetCompressFactor(t *testing.T) {
 		Event: map[string]interface{}{"Cost": 18.2}}
 	ev4 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_1",
 		Event: map[string]interface{}{"Cost": 18.2}}
-	sum.AddEvent(ev)
-	sum.AddEvent(ev2)
+	sum.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
+	sum.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if CF = sum.GetCompressFactor(make(map[string]int)); !reflect.DeepEqual(expectedCF, CF) {
 		t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedCF), utils.ToJSON(CF))
 	}
-	sum.AddEvent(ev2)
+	sum.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	expectedCF["EVENT_2"] = 2
 	if CF = sum.GetCompressFactor(make(map[string]int)); !reflect.DeepEqual(expectedCF, CF) {
 		t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedCF), utils.ToJSON(CF))
 	}
-	sum.AddEvent(ev4)
+	sum.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
 	expectedCF["EVENT_2"] = 3
 	expectedCF["EVENT_1"] = 2
 	CF["EVENT_2"] = 3
@@ -2392,12 +2392,12 @@ func TestStatAverageGetFloat64Value(t *testing.T) {
 			"Usage":           time.Duration(10 * time.Second),
 			utils.PDD:         time.Duration(5 * time.Second),
 			utils.Destination: "1002"}}
-	statAvg.AddEvent(ev)
+	statAvg.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	if v := statAvg.GetFloat64Value(); v != -1.0 {
 		t.Errorf("wrong statAvg value: %v", v)
 	}
 	ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2"}
-	statAvg.AddEvent(ev2)
+	statAvg.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if v := statAvg.GetFloat64Value(); v != -1.0 {
 		t.Errorf("wrong statAvg value: %v", v)
 	}
@@ -2418,11 +2418,11 @@ func TestStatAverageGetFloat64Value(t *testing.T) {
 			utils.Destination: "1003",
 		},
 	}
-	statAvg.AddEvent(ev4)
+	statAvg.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
 	if strVal := statAvg.GetFloat64Value(); strVal != 25 {
 		t.Errorf("wrong statAvg value: %v", strVal)
 	}
-	statAvg.AddEvent(ev5)
+	statAvg.AddEvent(ev5.ID, utils.MapStorage{utils.MetaReq: ev5.Event})
 	if strVal := statAvg.GetFloat64Value(); strVal != 23.33333 {
 		t.Errorf("wrong statAvg value: %v", strVal)
 	}
@@ -2455,7 +2455,7 @@ func TestStatAverageGetStringValue(t *testing.T) {
 		t.Errorf("wrong ddc value: %s", strVal)
 	}
 
-	statAvg.AddEvent(ev)
+	statAvg.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	if strVal := statAvg.GetStringValue(""); strVal != utils.NOT_AVAILABLE {
 		t.Errorf("wrong statAvg value: %s", strVal)
 	}
@@ -2470,8 +2470,8 @@ func TestStatAverageGetStringValue(t *testing.T) {
 			"Cost":            "20",
 			"AnswerTime":      time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 			utils.Destination: "1001"}}
-	statAvg.AddEvent(ev2)
-	statAvg.AddEvent(ev3)
+	statAvg.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	statAvg.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event})
 	if strVal := statAvg.GetStringValue(""); strVal != "20" {
 		t.Errorf("wrong statAvg value: %s", strVal)
 	}
@@ -2493,17 +2493,17 @@ func TestStatAverageGetStringValue2(t *testing.T) {
 	statAvg, _ := NewStatAverage(2, "~*req.Cost", []string{})
 	ev1 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_1",
 		Event: map[string]interface{}{"Cost": 12.3}}
-	if err := statAvg.AddEvent(ev1); err != nil {
+	if err := statAvg.AddEvent(ev1.ID, utils.MapStorage{utils.MetaReq: ev1.Event}); err != nil {
 		t.Error(err)
 	}
 	ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2",
 		Event: map[string]interface{}{"Cost": 18.3}}
-	statAvg.AddEvent(ev2)
+	statAvg.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if strVal := statAvg.GetStringValue(""); strVal != "15.3" {
 		t.Errorf("wrong statAvg value: %s", strVal)
 	}
-	statAvg.AddEvent(ev2)
-	statAvg.AddEvent(ev2)
+	statAvg.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	statAvg.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if strVal := statAvg.GetStringValue(""); strVal != "16.8" {
 		t.Errorf("wrong statAvg value: %s", strVal)
 	}
@@ -2534,13 +2534,13 @@ func TestStatAverageGetStringValue3(t *testing.T) {
 		Event: map[string]interface{}{"Cost": 6.2}}
 	ev3 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_3",
 		Event: map[string]interface{}{"Cost": 18.3}}
-	if err := statAvg.AddEvent(ev1); err != nil {
+	if err := statAvg.AddEvent(ev1.ID, utils.MapStorage{utils.MetaReq: ev1.Event}); err != nil {
 		t.Error(err)
 	}
-	if err := statAvg.AddEvent(ev2); err != nil {
+	if err := statAvg.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event}); err != nil {
 		t.Error(err)
 	}
-	if err := statAvg.AddEvent(ev3); err != nil {
+	if err := statAvg.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event}); err != nil {
 		t.Error(err)
 	}
 	statAvg.GetStringValue("")
@@ -2581,8 +2581,8 @@ func TestStatAverageCompress(t *testing.T) {
 		Event: map[string]interface{}{"Cost": 6.2}}
 	ev4 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_1",
 		Event: map[string]interface{}{"Cost": 18.3}}
-	avg.AddEvent(ev)
-	avg.AddEvent(ev2)
+	avg.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
+	avg.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	expIDs := []string{"EVENT_1", "EVENT_2"}
 	rply := avg.Compress(10, "EVENT_3")
 	sort.Strings(rply)
@@ -2612,8 +2612,8 @@ func TestStatAverageCompress(t *testing.T) {
 	if !reflect.DeepEqual(*expected, *avg) {
 		t.Errorf("Expected: %s , received: %s", utils.ToJSON(expected), utils.ToJSON(avg))
 	}
-	avg.AddEvent(ev2)
-	avg.AddEvent(ev4)
+	avg.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	avg.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
 	v := expected.Events["EVENT_3"]
 	v.Stat = 12.225
 	v.CompressFactor = 4
@@ -2643,17 +2643,17 @@ func TestStatAverageGetCompressFactor(t *testing.T) {
 		Event: map[string]interface{}{"Cost": 18.2}}
 	ev4 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_1",
 		Event: map[string]interface{}{"Cost": 18.2}}
-	avg.AddEvent(ev)
-	avg.AddEvent(ev2)
+	avg.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
+	avg.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if CF = avg.GetCompressFactor(make(map[string]int)); !reflect.DeepEqual(expectedCF, CF) {
 		t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedCF), utils.ToJSON(CF))
 	}
-	avg.AddEvent(ev2)
+	avg.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	expectedCF["EVENT_2"] = 2
 	if CF = avg.GetCompressFactor(make(map[string]int)); !reflect.DeepEqual(expectedCF, CF) {
 		t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedCF), utils.ToJSON(CF))
 	}
-	avg.AddEvent(ev4)
+	avg.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
 	expectedCF["EVENT_2"] = 3
 	expectedCF["EVENT_1"] = 2
 	CF["EVENT_2"] = 3
@@ -2666,12 +2666,12 @@ func TestStatDistinctGetFloat64Value(t *testing.T) {
 	statDistinct, _ := NewStatDistinct(2, "~*req.Usage", []string{})
 	ev := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_1",
 		Event: map[string]interface{}{"Usage": time.Duration(10 * time.Second)}}
-	statDistinct.AddEvent(ev)
+	statDistinct.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	if v := statDistinct.GetFloat64Value(); v != -1.0 {
 		t.Errorf("wrong statDistinct value: %v", v)
 	}
 	ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2"}
-	statDistinct.AddEvent(ev2)
+	statDistinct.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if v := statDistinct.GetFloat64Value(); v != -1.0 {
 		t.Errorf("wrong statDistinct value: %v", v)
 	}
@@ -2685,13 +2685,13 @@ func TestStatDistinctGetFloat64Value(t *testing.T) {
 			"Usage": time.Duration(1*time.Minute + 30*time.Second),
 		},
 	}
-	if err := statDistinct.AddEvent(ev4); err != nil {
+	if err := statDistinct.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event}); err != nil {
 		t.Error(err)
 	}
 	if strVal := statDistinct.GetFloat64Value(); strVal != 2 {
 		t.Errorf("wrong statDistinct value: %v", strVal)
 	}
-	statDistinct.AddEvent(ev5)
+	statDistinct.AddEvent(ev5.ID, utils.MapStorage{utils.MetaReq: ev5.Event})
 	if strVal := statDistinct.GetFloat64Value(); strVal != 3 {
 		t.Errorf("wrong statDistinct value: %v", strVal)
 	}
@@ -2721,7 +2721,7 @@ func TestStatDistinctGetStringValue(t *testing.T) {
 		t.Errorf("wrong statDistinct value: %s", strVal)
 	}
 
-	statDistinct.AddEvent(ev)
+	statDistinct.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	if strVal := statDistinct.GetStringValue(""); strVal != utils.NOT_AVAILABLE {
 		t.Errorf("wrong statDistinct value: %s", strVal)
 	}
@@ -2729,8 +2729,8 @@ func TestStatDistinctGetStringValue(t *testing.T) {
 		Event: map[string]interface{}{"Cost": "20"}}
 	ev3 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_3",
 		Event: map[string]interface{}{"Cost": "40"}}
-	statDistinct.AddEvent(ev2)
-	statDistinct.AddEvent(ev3)
+	statDistinct.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	statDistinct.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event})
 	if strVal := statDistinct.GetStringValue(""); strVal != "2" {
 		t.Errorf("wrong statDistinct value: %s", strVal)
 	}
@@ -2756,13 +2756,13 @@ func TestStatDistinctGetStringValue2(t *testing.T) {
 		t.Errorf("wrong statDistinct value: %s", strVal)
 	}
 
-	statDistinct.AddEvent(ev)
+	statDistinct.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	if strVal := statDistinct.GetStringValue(""); strVal != utils.NOT_AVAILABLE {
 		t.Errorf("wrong statDistinct value: %s", strVal)
 	}
 	ev2 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_1",
 		Event: map[string]interface{}{"Cost": "40"}}
-	statDistinct.AddEvent(ev2)
+	statDistinct.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if strVal := statDistinct.GetStringValue(""); strVal != "2" {
 		t.Errorf("wrong statDistinct value: %s", strVal)
 	}
@@ -2809,9 +2809,9 @@ func TestStatDistinctCompress(t *testing.T) {
 		Event: map[string]interface{}{utils.Destination: "1001"}}
 	ev3 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_3",
 		Event: map[string]interface{}{utils.Destination: "1002"}}
-	ddc.AddEvent(ev1)
-	ddc.AddEvent(ev2)
-	ddc.AddEvent(ev3)
+	ddc.AddEvent(ev1.ID, utils.MapStorage{utils.MetaReq: ev1.Event})
+	ddc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
+	ddc.AddEvent(ev3.ID, utils.MapStorage{utils.MetaReq: ev3.Event})
 	expIDs := []string{"EVENT_1", "EVENT_3"}
 	rply := ddc.Compress(10, "EVENT_3")
 	sort.Strings(rply)
@@ -2848,17 +2848,17 @@ func TestStatDistinctGetCompressFactor(t *testing.T) {
 	ev4 := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_2",
 		Event: map[string]interface{}{utils.Destination: "1001"}}
 
-	ddc.AddEvent(ev)
-	ddc.AddEvent(ev2)
+	ddc.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
+	ddc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	if CF = ddc.GetCompressFactor(make(map[string]int)); !reflect.DeepEqual(expectedCF, CF) {
 		t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedCF), utils.ToJSON(CF))
 	}
-	ddc.AddEvent(ev2)
+	ddc.AddEvent(ev2.ID, utils.MapStorage{utils.MetaReq: ev2.Event})
 	expectedCF["EVENT_2"] = 2
 	if CF = ddc.GetCompressFactor(make(map[string]int)); !reflect.DeepEqual(expectedCF, CF) {
 		t.Errorf("Expected: %s , received: %s", utils.ToJSON(expectedCF), utils.ToJSON(CF))
 	}
-	ddc.AddEvent(ev4)
+	ddc.AddEvent(ev4.ID, utils.MapStorage{utils.MetaReq: ev4.Event})
 	expectedCF["EVENT_2"] = 3
 	CF["EVENT_2"] = 3
 	if CF = ddc.GetCompressFactor(CF); !reflect.DeepEqual(expectedCF, CF) {
@@ -2873,7 +2873,7 @@ func TestASRMarshal(t *testing.T) {
 	ev := &utils.CGREvent{Tenant: "cgrates.org", ID: "EVENT_1",
 		Event: map[string]interface{}{
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC)}}
-	asr.AddEvent(ev)
+	asr.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	var nasr StatASR
 	expected := []byte(`{"FilterIDs":["*string:Account:1001"],"Answered":1,"Count":1,"Events":{"EVENT_1":{"Stat":1,"CompressFactor":1}},"MinItems":2}`)
 	if b, err := asr.Marshal(&jMarshaler); err != nil {
@@ -2893,7 +2893,7 @@ func TestACDMarshal(t *testing.T) {
 		Event: map[string]interface{}{
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 			"Usage":      time.Duration(10 * time.Second)}}
-	acd.AddEvent(ev)
+	acd.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	var nacd StatACD
 	expected := []byte(`{"FilterIDs":[],"Sum":10000000000,"Count":1,"Events":{"EVENT_1":{"Duration":10000000000,"CompressFactor":1}},"MinItems":2}`)
 	if b, err := acd.Marshal(&jMarshaler); err != nil {
@@ -2913,7 +2913,7 @@ func TestTCDMarshal(t *testing.T) {
 		Event: map[string]interface{}{
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 			"Usage":      time.Duration(10 * time.Second)}}
-	tcd.AddEvent(ev)
+	tcd.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	var ntcd StatTCD
 	expected := []byte(`{"FilterIDs":[],"Sum":10000000000,"Count":1,"Events":{"EVENT_1":{"Duration":10000000000,"CompressFactor":1}},"MinItems":2}`)
 	if b, err := tcd.Marshal(&jMarshaler); err != nil {
@@ -2933,7 +2933,7 @@ func TestACCMarshal(t *testing.T) {
 		Event: map[string]interface{}{
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 			"Cost":       "12.3"}}
-	acc.AddEvent(ev)
+	acc.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	var nacc StatACC
 	expected := []byte(`{"FilterIDs":[],"Sum":12.3,"Count":1,"Events":{"EVENT_1":{"Stat":12.3,"CompressFactor":1}},"MinItems":2}`)
 	if b, err := acc.Marshal(&jMarshaler); err != nil {
@@ -2953,7 +2953,7 @@ func TestTCCMarshal(t *testing.T) {
 		Event: map[string]interface{}{
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 			"Cost":       "12.3"}}
-	tcc.AddEvent(ev)
+	tcc.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	var ntcc StatTCC
 	expected := []byte(`{"FilterIDs":[],"Sum":12.3,"Count":1,"Events":{"EVENT_1":{"Stat":12.3,"CompressFactor":1}},"MinItems":2}`)
 	if b, err := tcc.Marshal(&jMarshaler); err != nil {
@@ -2974,7 +2974,7 @@ func TestPDDMarshal(t *testing.T) {
 			"AnswerTime": time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
 			"Usage":      time.Duration(10 * time.Second),
 			utils.PDD:    time.Duration(5 * time.Second)}}
-	pdd.AddEvent(ev)
+	pdd.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	var ntdd StatPDD
 	expected := []byte(`{"FilterIDs":[],"Sum":5000000000,"Count":1,"Events":{"EVENT_1":{"Duration":5000000000,"CompressFactor":1}},"MinItems":2}`)
 	if b, err := pdd.Marshal(&jMarshaler); err != nil {
@@ -2996,7 +2996,7 @@ func TestDCCMarshal(t *testing.T) {
 			"Usage":           time.Duration(10 * time.Second),
 			utils.PDD:         time.Duration(5 * time.Second),
 			utils.Destination: "1002"}}
-	ddc.AddEvent(ev)
+	ddc.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	var nddc StatDDC
 	expected := []byte(`{"FilterIDs":[],"FieldValues":{"1002":{"EVENT_1":{}}},"Events":{"EVENT_1":{"1002":1}},"MinItems":2,"Count":1}`)
 	if b, err := ddc.Marshal(&jMarshaler); err != nil {
@@ -3019,7 +3019,7 @@ func TestStatSumMarshal(t *testing.T) {
 			"Usage":           time.Duration(10 * time.Second),
 			utils.PDD:         time.Duration(5 * time.Second),
 			utils.Destination: "1002"}}
-	statSum.AddEvent(ev)
+	statSum.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	var nstatSum StatSum
 	expected := []byte(`{"FilterIDs":[],"Sum":20,"Count":1,"Events":{"EVENT_1":{"Stat":20,"CompressFactor":1}},"MinItems":2,"FieldName":"~*req.Cost"}`)
 	if b, err := statSum.Marshal(&jMarshaler); err != nil {
@@ -3042,7 +3042,7 @@ func TestStatAverageMarshal(t *testing.T) {
 			"Usage":           time.Duration(10 * time.Second),
 			utils.PDD:         time.Duration(5 * time.Second),
 			utils.Destination: "1002"}}
-	statAvg.AddEvent(ev)
+	statAvg.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	var nstatAvg StatAverage
 	expected := []byte(`{"FilterIDs":[],"Sum":20,"Count":1,"Events":{"EVENT_1":{"Stat":20,"CompressFactor":1}},"MinItems":2,"FieldName":"~*req.Cost"}`)
 	if b, err := statAvg.Marshal(&jMarshaler); err != nil {
@@ -3065,7 +3065,7 @@ func TestStatDistrictMarshal(t *testing.T) {
 			"Usage":           time.Duration(10 * time.Second),
 			utils.PDD:         time.Duration(5 * time.Second),
 			utils.Destination: "1002"}}
-	statDistinct.AddEvent(ev)
+	statDistinct.AddEvent(ev.ID, utils.MapStorage{utils.MetaReq: ev.Event})
 	var nStatDistinct StatDistinct
 	expected := []byte(`{"FilterIDs":[],"FieldValues":{"10s":{"EVENT_1":{}}},"Events":{"EVENT_1":{"10s":1}},"MinItems":2,"FieldName":"~*req.Usage","Count":1}`)
 	if b, err := statDistinct.Marshal(&jMarshaler); err != nil {
diff --git a/engine/stats.go b/engine/stats.go
index f4e4cb8a1..b703c2325 100644
--- a/engine/stats.go
+++ b/engine/stats.go
@@ -150,11 +150,7 @@ func (sS *StatService) StoreStatQueue(sq *StatQueue) (err error) {
 }
 
 // matchingStatQueuesForEvent returns ordered list of matching resources which are active by the time of the call
-func (sS *StatService) matchingStatQueuesForEvent(tnt string, args *StatsArgsProcessEvent) (sqs StatQueues, err error) {
-	evNm := utils.MapStorage{
-		utils.MetaReq:  args.Event,
-		utils.MetaOpts: args.Opts,
-	}
+func (sS *StatService) matchingStatQueuesForEvent(tnt string, args *StatsArgsProcessEvent, evNm utils.MapStorage) (sqs StatQueues, err error) {
 	sqIDs := utils.NewStringSet(args.StatIDs)
 	if len(sqIDs) == 0 {
 		sqIDs, err = MatchingItemIDsForEvent(evNm,
@@ -264,7 +260,11 @@ func (attr *StatsArgsProcessEvent) Clone() *StatsArgsProcessEvent {
 // processEvent processes a new event, dispatching to matching queues
 // queues matching are also cached to speed up
 func (sS *StatService) processEvent(tnt string, args *StatsArgsProcessEvent) (statQueueIDs []string, err error) {
-	matchSQs, err := sS.matchingStatQueuesForEvent(tnt, args)
+	evNm := utils.MapStorage{
+		utils.MetaReq:  args.Event,
+		utils.MetaOpts: args.Opts,
+	}
+	matchSQs, err := sS.matchingStatQueuesForEvent(tnt, args, evNm)
 	if err != nil {
 		return nil, err
 	}
@@ -281,7 +281,7 @@ func (sS *StatService) processEvent(tnt string, args *StatsArgsProcessEvent) (st
 		stsIDs = append(stsIDs, sq.ID)
 		lkID := utils.StatQueuePrefix + sq.TenantID()
 		guardian.Guardian.Guard(func() (gRes interface{}, gErr error) {
-			err = sq.ProcessEvent(args.CGREvent, sS.filterS)
+			err = sq.ProcessEvent(args.CGREvent, sS.filterS, evNm)
 			return
 		}, config.CgrConfig().GeneralCfg().LockingTimeout, lkID)
 		if err != nil {
@@ -384,7 +384,10 @@ func (sS *StatService) V1GetStatQueuesForEvent(args *StatsArgsProcessEvent, repl
 		tnt = sS.cgrcfg.GeneralCfg().DefaultTenant
 	}
 	var sQs StatQueues
-	if sQs, err = sS.matchingStatQueuesForEvent(tnt, args); err != nil {
+	if sQs, err = sS.matchingStatQueuesForEvent(tnt, args, utils.MapStorage{
+		utils.MetaReq:  args.Event,
+		utils.MetaOpts: args.Opts,
+	}); err != nil {
 		return
 	}
 	ids := make([]string, len(sQs))
diff --git a/engine/stats_test.go b/engine/stats_test.go
index 26dede3f6..5dffc7a40 100644
--- a/engine/stats_test.go
+++ b/engine/stats_test.go
@@ -250,7 +250,8 @@ func TestStatQueuesPopulateStatsService(t *testing.T) {
 }
 
 func TestStatQueuesMatchingStatQueuesForEvent(t *testing.T) {
-	msq, err := statService.matchingStatQueuesForEvent(statsEvs[0].Tenant, statsEvs[0])
+	msq, err := statService.matchingStatQueuesForEvent(statsEvs[0].Tenant, statsEvs[0],
+		utils.MapStorage{utils.MetaReq: statsEvs[0].Event, utils.MetaOpts: statsEvs[0].Opts})
 	if err != nil {
 		t.Errorf("Error: %+v", err)
 	}
@@ -261,7 +262,8 @@ func TestStatQueuesMatchingStatQueuesForEvent(t *testing.T) {
 	} else if !reflect.DeepEqual(stqs[0].sqPrfl, msq[0].sqPrfl) {
 		t.Errorf("Expecting: %+v, received: %+v", stqs[0].sqPrfl, msq[0].sqPrfl)
 	}
-	msq, err = statService.matchingStatQueuesForEvent(statsEvs[1].Tenant, statsEvs[1])
+	msq, err = statService.matchingStatQueuesForEvent(statsEvs[1].Tenant, statsEvs[1],
+		utils.MapStorage{utils.MetaReq: statsEvs[1].Event, utils.MetaOpts: statsEvs[1].Opts})
 	if err != nil {
 		t.Errorf("Error: %+v", err)
 	}
@@ -272,7 +274,8 @@ func TestStatQueuesMatchingStatQueuesForEvent(t *testing.T) {
 	} else if !reflect.DeepEqual(stqs[1].sqPrfl, msq[0].sqPrfl) {
 		t.Errorf("Expecting: %+v, received: %+v", stqs[1].sqPrfl, msq[0].sqPrfl)
 	}
-	msq, err = statService.matchingStatQueuesForEvent(statsEvs[2].Tenant, statsEvs[2])
+	msq, err = statService.matchingStatQueuesForEvent(statsEvs[2].Tenant, statsEvs[2],
+		utils.MapStorage{utils.MetaReq: statsEvs[2].Event, utils.MetaOpts: statsEvs[2].Opts})
 	if err != nil {
 		t.Errorf("Error: %+v", err)
 	}
@@ -327,7 +330,8 @@ func TestStatQueuesProcessEvent(t *testing.T) {
 
 func TestStatQueuesMatchWithIndexFalse(t *testing.T) {
 	statService.cgrcfg.StatSCfg().IndexedSelects = false
-	msq, err := statService.matchingStatQueuesForEvent(statsEvs[0].Tenant, statsEvs[0])
+	msq, err := statService.matchingStatQueuesForEvent(statsEvs[0].Tenant, statsEvs[0],
+		utils.MapStorage{utils.MetaReq: statsEvs[0].Event, utils.MetaOpts: statsEvs[0].Opts})
 	if err != nil {
 		t.Errorf("Error: %+v", err)
 	}
@@ -338,7 +342,8 @@ func TestStatQueuesMatchWithIndexFalse(t *testing.T) {
 	} else if !reflect.DeepEqual(stqs[0].sqPrfl, msq[0].sqPrfl) {
 		t.Errorf("Expecting: %+v, received: %+v", stqs[0].sqPrfl, msq[0].sqPrfl)
 	}
-	msq, err = statService.matchingStatQueuesForEvent(statsEvs[1].Tenant, statsEvs[1])
+	msq, err = statService.matchingStatQueuesForEvent(statsEvs[1].Tenant, statsEvs[1],
+		utils.MapStorage{utils.MetaReq: statsEvs[1].Event, utils.MetaOpts: statsEvs[1].Opts})
 	if err != nil {
 		t.Errorf("Error: %+v", err)
 	}
@@ -349,7 +354,8 @@ func TestStatQueuesMatchWithIndexFalse(t *testing.T) {
 	} else if !reflect.DeepEqual(stqs[1].sqPrfl, msq[0].sqPrfl) {
 		t.Errorf("Expecting: %+v, received: %+v", stqs[1].sqPrfl, msq[0].sqPrfl)
 	}
-	msq, err = statService.matchingStatQueuesForEvent(statsEvs[2].Tenant, statsEvs[2])
+	msq, err = statService.matchingStatQueuesForEvent(statsEvs[2].Tenant, statsEvs[2],
+		utils.MapStorage{utils.MetaReq: statsEvs[2].Event, utils.MetaOpts: statsEvs[2].Opts})
 	if err != nil {
 		t.Errorf("Error: %+v", err)
 	}
diff --git a/packages/debian/changelog b/packages/debian/changelog
index af28131d3..568f85a09 100644
--- a/packages/debian/changelog
+++ b/packages/debian/changelog
@@ -119,6 +119,7 @@ cgrates (0.11.0~dev) UNRELEASED; urgency=medium
   * [SessionS] Use rals_conns when sending refund rounding
   * [General] Made tenant optional for all API calls
   * [ConfigS] Moved MinCallDuration,MaxCallDuration from sessions config to general config
+  * [StatS] Added support for nested fields in custom metrics 
   
  -- DanB <danb@cgrates.org>  Wed, 19 Feb 2020 13:25:52 +0200