diff --git a/apier/v1/auth.go b/apier/v1/auth.go
index b952f3011..1d2b4ac85 100644
--- a/apier/v1/auth.go
+++ b/apier/v1/auth.go
@@ -56,7 +56,7 @@ func (self *ApierV1) GetMaxUsage(usageRecord engine.UsageRecord, maxUsage *float
 	if usageRecord.Usage == "" {
 		usageRecord.Usage = strconv.FormatFloat(self.Config.MaxCallDuration.Seconds(), 'f', -1, 64)
 	}
-	storedCdr, err := usageRecord.AsStoredCdr(self.Config.DefaultTimezone)
+	storedCdr, err := usageRecord.AsCDR(self.Config.DefaultTimezone)
 	if err != nil {
 		return utils.NewErrServerError(err)
 	}
diff --git a/engine/cdr.go b/engine/cdr.go
index 6b225777d..89b11668b 100644
--- a/engine/cdr.go
+++ b/engine/cdr.go
@@ -285,7 +285,7 @@ func (cdr *CDR) FieldsAsString(rsrFlds utils.RSRFields) string {
 	return fldVal
 }
 
-func (cdr *CDR) AsStoredCdr(timezone string) *CDR {
+func (cdr *CDR) AsCDR(timezone string) *CDR {
 	return cdr
 }
 
@@ -913,7 +913,7 @@ type UsageRecord struct {
 	ExtraFields map[string]string
 }
 
-func (self *UsageRecord) AsStoredCdr(timezone string) (*CDR, error) {
+func (self *UsageRecord) AsCDR(timezone string) (*CDR, error) {
 	var err error
 	cdr := &CDR{CGRID: self.GetId(), ToR: self.ToR, RequestType: self.RequestType, Direction: self.Direction,
 		Tenant: self.Tenant, Category: self.Category, Account: self.Account, Subject: self.Subject, Destination: self.Destination}
diff --git a/engine/cdr_test.go b/engine/cdr_test.go
index d76058532..c016609f0 100644
--- a/engine/cdr_test.go
+++ b/engine/cdr_test.go
@@ -461,7 +461,7 @@ func TesUsageReqAsCDR(t *testing.T) {
 	eStorCdr := &CDR{ToR: utils.VOICE, RequestType: utils.META_RATED, Direction: "*out",
 		Tenant: "cgrates.org", Category: "call", Account: "1001", Subject: "1001", Destination: "1002",
 		SetupTime: time.Date(2013, 11, 7, 8, 42, 20, 0, time.UTC), AnswerTime: time.Date(2013, 11, 7, 8, 42, 26, 0, time.UTC), Usage: time.Duration(10)}
-	if CDR, err := setupReq.AsStoredCdr(""); err != nil {
+	if CDR, err := setupReq.AsCDR(""); err != nil {
 		t.Error(err)
 	} else if !reflect.DeepEqual(eStorCdr, CDR) {
 		t.Errorf("Expected: %+v, received: %+v", eStorCdr, CDR)
diff --git a/engine/cdrs.go b/engine/cdrs.go
index 953160bee..4d01ef3e3 100644
--- a/engine/cdrs.go
+++ b/engine/cdrs.go
@@ -51,7 +51,7 @@ func cgrCdrHandler(w http.ResponseWriter, r *http.Request) {
 		utils.Logger.Err(fmt.Sprintf("<CDRS> Could not create CDR entry: %s", err.Error()))
 		return
 	}
-	if err := cdrServer.processCdr(cgrCdr.AsStoredCdr(cdrServer.cgrCfg.DefaultTimezone)); err != nil {
+	if err := cdrServer.processCdr(cgrCdr.AsCDR(cdrServer.cgrCfg.DefaultTimezone)); err != nil {
 		utils.Logger.Err(fmt.Sprintf("<CDRS> Errors when storing CDR entry: %s", err.Error()))
 	}
 }
@@ -64,7 +64,7 @@ func fsCdrHandler(w http.ResponseWriter, r *http.Request) {
 		utils.Logger.Err(fmt.Sprintf("<CDRS> Could not create CDR entry: %s", err.Error()))
 		return
 	}
-	if err := cdrServer.processCdr(fsCdr.AsStoredCdr(cdrServer.Timezone())); err != nil {
+	if err := cdrServer.processCdr(fsCdr.AsCDR(cdrServer.Timezone())); err != nil {
 		utils.Logger.Err(fmt.Sprintf("<CDRS> Errors when storing CDR entry: %s", err.Error()))
 	}
 }
diff --git a/engine/cgrcdr.go b/engine/cgrcdr.go
index 54e0af8e6..41eabd4da 100644
--- a/engine/cgrcdr.go
+++ b/engine/cgrcdr.go
@@ -58,7 +58,7 @@ func (cgrCdr CgrCdr) getExtraFields() map[string]string {
 	return extraFields
 }
 
-func (cgrCdr CgrCdr) AsStoredCdr(timezone string) *CDR {
+func (cgrCdr CgrCdr) AsCDR(timezone string) *CDR {
 	storCdr := new(CDR)
 	storCdr.CGRID = cgrCdr.getCGRID(timezone)
 	storCdr.ToR = cgrCdr[utils.TOR]
diff --git a/engine/cgrcdr_test.go b/engine/cgrcdr_test.go
index bcf267b12..1d9e94cff 100644
--- a/engine/cgrcdr_test.go
+++ b/engine/cgrcdr_test.go
@@ -46,7 +46,7 @@ func TestCgrCdrAsCDR(t *testing.T) {
 		Destination: cgrCdr[utils.DESTINATION], SetupTime: time.Date(2013, 11, 7, 8, 42, 20, 0, time.UTC), AnswerTime: time.Date(2013, 11, 7, 8, 42, 26, 0, time.UTC),
 		Usage: time.Duration(10) * time.Second, Supplier: "SUPPL1",
 		ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"}, Cost: -1}
-	if CDR := cgrCdr.AsStoredCdr(""); !reflect.DeepEqual(expctRtCdr, CDR) {
+	if CDR := cgrCdr.AsCDR(""); !reflect.DeepEqual(expctRtCdr, CDR) {
 		t.Errorf("Expecting %v, received: %v", expctRtCdr, CDR)
 	}
 }
@@ -80,7 +80,7 @@ func TestReplicatedCgrCdrAsCDR(t *testing.T) {
 		Cost:            0.12,
 		Rated:           true,
 	}
-	if CDR := cgrCdr.AsStoredCdr(""); !reflect.DeepEqual(expctRtCdr, CDR) {
+	if CDR := cgrCdr.AsCDR(""); !reflect.DeepEqual(expctRtCdr, CDR) {
 		t.Errorf("Expecting %v, received: %v", expctRtCdr, CDR)
 	}
 }
diff --git a/engine/event.go b/engine/event.go
index 1c5ca5ad5..d4558c410 100644
--- a/engine/event.go
+++ b/engine/event.go
@@ -47,7 +47,7 @@ type Event interface {
 	GetExtraFields() map[string]string
 	MissingParameter(string) bool
 	ParseEventValue(*utils.RSRField, string) string
-	AsStoredCdr(timezone string) *CDR
+	AsCDR(timezone string) *CDR
 	String() string
 	AsEvent(string) Event
 	ComputeLcr() bool
diff --git a/engine/fscdr.go b/engine/fscdr.go
index a6aee5816..1181eb7b2 100644
--- a/engine/fscdr.go
+++ b/engine/fscdr.go
@@ -123,7 +123,7 @@ func (fsCdr FSCdr) searchExtraField(field string, body map[string]interface{}) (
 	return
 }
 
-func (fsCdr FSCdr) AsStoredCdr(timezone string) *CDR {
+func (fsCdr FSCdr) AsCDR(timezone string) *CDR {
 	storCdr := new(CDR)
 	storCdr.CGRID = fsCdr.getCGRID(timezone)
 	storCdr.ToR = utils.VOICE
diff --git a/engine/fscdr_test.go b/engine/fscdr_test.go
index 64c90e303..7e7db0801 100644
--- a/engine/fscdr_test.go
+++ b/engine/fscdr_test.go
@@ -57,7 +57,7 @@ func TestCDRFields(t *testing.T) {
 		OriginHost: "127.0.0.1", Source: "freeswitch_json", Direction: utils.OUT, Category: "call", RequestType: utils.META_PREPAID, Tenant: "cgrates.org", Account: "1001", Subject: "1001",
 		Destination: "1003", SetupTime: setupTime, PDD: time.Duration(28) * time.Millisecond, AnswerTime: answerTime, Usage: time.Duration(66) * time.Second, Supplier: "supplier1",
 		DisconnectCause: "NORMAL_CLEARING", ExtraFields: map[string]string{"sip_user_agent": "PJSUA v2.3 Linux-3.2.0.4/x86_64/glibc-2.13"}, Cost: -1}
-	if CDR := fsCdr.AsStoredCdr(""); !reflect.DeepEqual(expctCDR, CDR) {
+	if CDR := fsCdr.AsCDR(""); !reflect.DeepEqual(expctCDR, CDR) {
 		t.Errorf("Expecting: %v, received: %v", expctCDR, CDR)
 	}
 }
diff --git a/engine/rawcdr.go b/engine/rawcdr.go
index cbb3f1d68..e72d4e676 100644
--- a/engine/rawcdr.go
+++ b/engine/rawcdr.go
@@ -20,5 +20,5 @@ package engine
 
 // RawCDR is the original CDR received from external sources (eg: FreeSWITCH)
 type RawCdr interface {
-	AsStoredCdr(string) *CDR // Convert the inbound Cdr into internally used one, CgrCdr
+	AsCDR(string) *CDR // Convert the inbound Cdr into internally used one, CgrCdr
 }
diff --git a/general_tests/fsevcorelate_test.go b/general_tests/fsevcorelate_test.go
index 448c88703..915dbeee1 100644
--- a/general_tests/fsevcorelate_test.go
+++ b/general_tests/fsevcorelate_test.go
@@ -221,11 +221,11 @@ func TestEvCorelate(t *testing.T) {
 	cdrEv, err := engine.NewFSCdr(jsonCdr, cfg)
 	if err != nil {
 		t.Errorf("Error loading cdr: %v", err.Error())
-	} else if cdrEv.AsStoredCdr("").OriginID != "86cfd6e2-dbda-45a3-b59d-f683ec368e8b" {
-		t.Error("Unexpected acntId received", cdrEv.AsStoredCdr("").OriginID)
+	} else if cdrEv.AsCDR("").OriginID != "86cfd6e2-dbda-45a3-b59d-f683ec368e8b" {
+		t.Error("Unexpected acntId received", cdrEv.AsCDR("").OriginID)
 	}
-	if answerEv.GetCgrId("") != cdrEv.AsStoredCdr("").CGRID {
-		t.Error("CGRIDs do not match", answerEv.GetCgrId(""), cdrEv.AsStoredCdr("").CGRID)
+	if answerEv.GetCgrId("") != cdrEv.AsCDR("").CGRID {
+		t.Error("CGRIDs do not match", answerEv.GetCgrId(""), cdrEv.AsCDR("").CGRID)
 	}
 
 }
@@ -549,14 +549,14 @@ func TestEvCdrCorelate(t *testing.T) {
 	}
 	cfg, _ := config.NewDefaultCGRConfig()
 	config.SetCgrConfig(cfg)
-	evStoredCdr := hangupEv.AsStoredCdr("")
+	evStoredCdr := hangupEv.AsCDR("")
 	cdrEv, err := engine.NewFSCdr(jsonCdr2, cfg)
 	if err != nil {
 		t.Errorf("Error loading cdr: %v", err.Error())
-	} else if cdrEv.AsStoredCdr("").OriginID != "e3133bf7-dcde-4daf-9663-9a79ffcef5ad" {
-		t.Error("Unexpected acntId received", cdrEv.AsStoredCdr("").OriginID)
+	} else if cdrEv.AsCDR("").OriginID != "e3133bf7-dcde-4daf-9663-9a79ffcef5ad" {
+		t.Error("Unexpected acntId received", cdrEv.AsCDR("").OriginID)
 	}
-	jsnStoredCdr := cdrEv.AsStoredCdr("")
+	jsnStoredCdr := cdrEv.AsCDR("")
 	if evStoredCdr.CGRID != jsnStoredCdr.CGRID {
 		t.Errorf("evStoredCdr.CGRID: %s, jsnStoredCdr.CGRID: %s", evStoredCdr.CGRID, jsnStoredCdr.CGRID)
 	}
diff --git a/sessionmanager/fsevent.go b/sessionmanager/fsevent.go
index 790b76d18..389fec573 100644
--- a/sessionmanager/fsevent.go
+++ b/sessionmanager/fsevent.go
@@ -339,7 +339,7 @@ func (fsev FSEvent) PassesFieldFilter(fieldFilter *utils.RSRField) (bool, string
 }
 */
 
-func (fsev FSEvent) AsStoredCdr(timezone string) *engine.CDR {
+func (fsev FSEvent) AsCDR(timezone string) *engine.CDR {
 	storCdr := new(engine.CDR)
 	storCdr.CGRID = fsev.GetCgrId(timezone)
 	storCdr.ToR = utils.VOICE
diff --git a/sessionmanager/fsevent_test.go b/sessionmanager/fsevent_test.go
index 8bdd1a6be..1ef75c074 100644
--- a/sessionmanager/fsevent_test.go
+++ b/sessionmanager/fsevent_test.go
@@ -628,7 +628,7 @@ Caller-Username: 04021292812`
 }
 */
 
-func TestFsEvAsStoredCdr(t *testing.T) {
+func TestFsEvAsCDR(t *testing.T) {
 	cfg, _ := config.NewDefaultCGRConfig()
 	config.SetCgrConfig(cfg)
 	ev := new(FSEvent).AsEvent(hangupEv)
@@ -640,7 +640,7 @@ func TestFsEvAsStoredCdr(t *testing.T) {
 		Destination: "1003", SetupTime: setupTime, AnswerTime: aTime,
 		Usage: time.Duration(66) * time.Second, PDD: time.Duration(28) * time.Millisecond, Supplier: "supplier1",
 		DisconnectCause: "NORMAL_CLEARING", ExtraFields: make(map[string]string), Cost: -1}
-	if storedCdr := ev.AsStoredCdr(""); !reflect.DeepEqual(eStoredCdr, storedCdr) {
+	if storedCdr := ev.AsCDR(""); !reflect.DeepEqual(eStoredCdr, storedCdr) {
 		t.Errorf("Expecting: %+v, received: %+v", eStoredCdr, storedCdr)
 	}
 }
diff --git a/sessionmanager/fssessionmanager.go b/sessionmanager/fssessionmanager.go
index f68ef9eb9..25fa269db 100644
--- a/sessionmanager/fssessionmanager.go
+++ b/sessionmanager/fssessionmanager.go
@@ -163,7 +163,7 @@ func (sm *FSSessionManager) onChannelPark(ev engine.Event, connId string) {
 	if ev.GetReqType(utils.META_DEFAULT) != utils.META_NONE { // Do not process this request
 		var maxCallDuration float64 // This will be the maximum duration this channel will be allowed to last
 		if err := sm.rater.Call("Responder.GetDerivedMaxSessionTime",
-			ev.AsStoredCdr(config.CgrConfig().DefaultTimezone), &maxCallDuration); err != nil {
+			ev.AsCDR(config.CgrConfig().DefaultTimezone), &maxCallDuration); err != nil {
 			utils.Logger.Err(fmt.Sprintf("<SM-FreeSWITCH> Could not get max session time for %s, error: %s",
 				ev.GetUUID(), err.Error()))
 		}
@@ -276,7 +276,7 @@ func (sm *FSSessionManager) onChannelHangupComplete(ev engine.Event) {
 		}
 	}
 	if sm.cfg.CreateCdr {
-		sm.ProcessCdr(ev.AsStoredCdr(config.CgrConfig().DefaultTimezone))
+		sm.ProcessCdr(ev.AsCDR(config.CgrConfig().DefaultTimezone))
 	}
 	var reply string
 	attrRU := utils.ArgRSv1ResourceUsage{
diff --git a/sessionmanager/kamailiosm.go b/sessionmanager/kamailiosm.go
index 7ffdfd67f..83147ac88 100644
--- a/sessionmanager/kamailiosm.go
+++ b/sessionmanager/kamailiosm.go
@@ -110,7 +110,7 @@ func (self *KamailioSessionManager) onCgrAuth(evData []byte, connId string) {
 	var remainingDuration float64
 	var errReply error
 	if errReply = self.rater.Call("Responder.GetDerivedMaxSessionTime",
-		kev.AsStoredCdr(self.timezone), &remainingDuration); errReply != nil {
+		kev.AsCDR(self.timezone), &remainingDuration); errReply != nil {
 		utils.Logger.Err(fmt.Sprintf("<SM-Kamailio> Could not get max session time, error: %s", errReply.Error()))
 	}
 	var supplStr string
@@ -205,7 +205,7 @@ func (self *KamailioSessionManager) onCallEnd(evData []byte, connId string) {
 	if kev.MissingParameter(self.timezone) {
 		utils.Logger.Err(fmt.Sprintf("<SM-Kamailio> Mandatory IE missing out of event: %+v", kev))
 	}
-	go self.ProcessCdr(kev.AsStoredCdr(self.Timezone()))
+	go self.ProcessCdr(kev.AsCDR(self.Timezone()))
 	if self.rlS != nil { // Release RLs resource
 		go func() {
 			ev, err := kev.AsMapStringIface()
diff --git a/sessionmanager/kamevent.go b/sessionmanager/kamevent.go
index 6556ae507..47ebd22d7 100644
--- a/sessionmanager/kamevent.go
+++ b/sessionmanager/kamevent.go
@@ -320,7 +320,7 @@ func (kev KamEvent) PassesFieldFilter(*utils.RSRField) (bool, string) {
 	return false, ""
 }
 
-func (kev KamEvent) AsStoredCdr(timezone string) *engine.CDR {
+func (kev KamEvent) AsCDR(timezone string) *engine.CDR {
 	storCdr := new(engine.CDR)
 	storCdr.CGRID = kev.GetCgrId(timezone)
 	storCdr.ToR = utils.VOICE
diff --git a/sessionmanager/osipsevent.go b/sessionmanager/osipsevent.go
index 4057d2eea..61e1d3552 100644
--- a/sessionmanager/osipsevent.go
+++ b/sessionmanager/osipsevent.go
@@ -264,7 +264,7 @@ func (osipsev *OsipsEvent) DialogId() string {
 	return osipsev.osipsEvent.AttrValues[OSIPS_DIALOG_ID]
 }
 
-func (osipsEv *OsipsEvent) AsStoredCdr(timezone string) *engine.CDR {
+func (osipsEv *OsipsEvent) AsCDR(timezone string) *engine.CDR {
 	storCdr := new(engine.CDR)
 	storCdr.CGRID = osipsEv.GetCgrId(timezone)
 	storCdr.ToR = utils.VOICE
diff --git a/sessionmanager/osipsevent_test.go b/sessionmanager/osipsevent_test.go
index 31b0e4e8f..fc990d5c0 100644
--- a/sessionmanager/osipsevent_test.go
+++ b/sessionmanager/osipsevent_test.go
@@ -139,7 +139,7 @@ func TestOsipsEventMissingParameter(t *testing.T) {
 	}
 }
 
-func TestOsipsEventAsStoredCdr(t *testing.T) {
+func TestOsipsEventAsCDR(t *testing.T) {
 	setupTime, _ := utils.ParseTimeDetectLayout("1406370492", "")
 	answerTime, _ := utils.ParseTimeDetectLayout("1406370499", "")
 	eStoredCdr := &engine.CDR{CGRID: utils.Sha1("ODVkMDI2Mzc2MDY5N2EzODhjNTAzNTdlODhiZjRlYWQ", setupTime.UTC().String()),
@@ -148,7 +148,7 @@ func TestOsipsEventAsStoredCdr(t *testing.T) {
 		Direction:   utils.OUT, Tenant: "itsyscom.com", Category: "call", Account: "dan", Subject: "dan",
 		Destination: "+4986517174963", SetupTime: setupTime, AnswerTime: answerTime,
 		Usage: time.Duration(20) * time.Second, PDD: time.Duration(3) * time.Second, Supplier: "supplier3", DisconnectCause: "200", ExtraFields: map[string]string{"extra1": "val1", "extra2": "val2"}, Cost: -1}
-	if storedCdr := osipsEv.AsStoredCdr(""); !reflect.DeepEqual(eStoredCdr, storedCdr) {
+	if storedCdr := osipsEv.AsCDR(""); !reflect.DeepEqual(eStoredCdr, storedCdr) {
 		t.Errorf("Expecting: %+v, received: %+v", eStoredCdr, storedCdr)
 	}
 }
@@ -166,7 +166,7 @@ func TestOsipsAccMissedToStoredCdr(t *testing.T) {
 		RequestType: utils.META_PSEUDOPREPAID, Direction: utils.OUT, Tenant: "cgrates.org", Category: "call", Account: "1001", Subject: "1001", Supplier: "supplier1",
 		DisconnectCause: "404", Destination: "1002", SetupTime: setupTime, AnswerTime: setupTime,
 		Usage: time.Duration(0), ExtraFields: map[string]string{"extra1": "val1", "extra2": "val2"}, Cost: -1}
-	if storedCdr := osipsEv.AsStoredCdr(""); !reflect.DeepEqual(eStoredCdr, storedCdr) {
+	if storedCdr := osipsEv.AsCDR(""); !reflect.DeepEqual(eStoredCdr, storedCdr) {
 		t.Errorf("Expecting: %+v, received: %+v", eStoredCdr, storedCdr)
 	}
 
diff --git a/sessionmanager/osipssm.go b/sessionmanager/osipssm.go
index f6965c7dd..b82213ee4 100644
--- a/sessionmanager/osipssm.go
+++ b/sessionmanager/osipssm.go
@@ -232,7 +232,7 @@ func (osm *OsipsSessionManager) onOpensipsStart(cdrDagram *osipsdagram.OsipsEven
 // Triggered by CDR event
 func (osm *OsipsSessionManager) onCdr(cdrDagram *osipsdagram.OsipsEvent) {
 	osipsEv, _ := NewOsipsEvent(cdrDagram)
-	if err := osm.ProcessCdr(osipsEv.AsStoredCdr(osm.timezone)); err != nil {
+	if err := osm.ProcessCdr(osipsEv.AsCDR(osm.timezone)); err != nil {
 		utils.Logger.Err(fmt.Sprintf("<SM-OpenSIPS> Failed processing CDR, cgrid: %s, accid: %s, error: <%s>", osipsEv.GetCgrId(osm.timezone), osipsEv.GetUUID(), err.Error()))
 	}
 }
@@ -334,7 +334,7 @@ func (osm *OsipsSessionManager) processCdrStop(osipsEv *OsipsEvent) error {
 	if err := osipsEvStart.updateDurationFromEvent(osipsEv); err != nil {
 		return err
 	}
-	return osm.ProcessCdr(osipsEvStart.AsStoredCdr(osm.timezone))
+	return osm.ProcessCdr(osipsEvStart.AsCDR(osm.timezone))
 }
 
 func (osm *OsipsSessionManager) Sessions() []*Session {
diff --git a/sessionmanager/session.go b/sessionmanager/session.go
index 4e528a546..e4dbbbe34 100644
--- a/sessionmanager/session.go
+++ b/sessionmanager/session.go
@@ -59,7 +59,7 @@ func NewSession(ev engine.Event, connId string, sm SessionManager) *Session {
 		sessionManager: sm,
 		connId:         connId,
 	}
-	if err := sm.Rater().Call("Responder.GetSessionRuns", ev.AsStoredCdr(s.sessionManager.Timezone()), &s.sessionRuns); err != nil || len(s.sessionRuns) == 0 {
+	if err := sm.Rater().Call("Responder.GetSessionRuns", ev.AsCDR(s.sessionManager.Timezone()), &s.sessionRuns); err != nil || len(s.sessionRuns) == 0 {
 		return nil
 	}
 	for runIdx := range s.sessionRuns {
diff --git a/sessionmanager/smg_event.go b/sessionmanager/smg_event.go
index 0f6091ebe..44a65af6a 100644
--- a/sessionmanager/smg_event.go
+++ b/sessionmanager/smg_event.go
@@ -416,7 +416,7 @@ func (self SMGenericEvent) PassesFieldFilter(*utils.RSRField) (bool, string) {
 	return true, ""
 }
 
-func (self SMGenericEvent) AsStoredCdr(cfg *config.CGRConfig, timezone string) *engine.CDR {
+func (self SMGenericEvent) AsCDR(cfg *config.CGRConfig, timezone string) *engine.CDR {
 	storCdr := engine.NewCDRWithDefaults(cfg)
 	storCdr.CGRID = self.GetCGRID(utils.META_DEFAULT)
 	storCdr.ToR = utils.FirstNonEmpty(self.GetTOR(utils.META_DEFAULT), storCdr.ToR) // Keep default if none in the event
diff --git a/sessionmanager/smg_event_test.go b/sessionmanager/smg_event_test.go
index 103c2eac3..9b17c07c7 100644
--- a/sessionmanager/smg_event_test.go
+++ b/sessionmanager/smg_event_test.go
@@ -150,7 +150,7 @@ func TestSMGenericEventGetSessionTTL(t *testing.T) {
 	}
 }
 
-func TestSMGenericEventAsStoredCdr(t *testing.T) {
+func TestSMGenericEventAsCDR(t *testing.T) {
 	smGev := SMGenericEvent{}
 	smGev[utils.EVENT_NAME] = "TEST_EVENT"
 	smGev[utils.TOR] = utils.SMS
@@ -177,7 +177,7 @@ func TestSMGenericEventAsStoredCdr(t *testing.T) {
 		Destination: "+4986517174963", SetupTime: time.Date(2015, 11, 9, 14, 21, 24, 0, time.UTC), AnswerTime: time.Date(2015, 11, 9, 14, 22, 2, 0, time.UTC),
 		Usage: time.Duration(83) * time.Second, PDD: time.Duration(300) * time.Millisecond, Supplier: "supplier1", DisconnectCause: "NORMAL_DISCONNECT",
 		ExtraFields: map[string]string{"Extra1": "Value1", "Extra2": "5"}, Cost: -1}
-	if storedCdr := smGev.AsStoredCdr(cfg, "UTC"); !reflect.DeepEqual(eStoredCdr, storedCdr) {
+	if storedCdr := smGev.AsCDR(cfg, "UTC"); !reflect.DeepEqual(eStoredCdr, storedCdr) {
 		t.Errorf("Expecting: %+v, received: %+v", eStoredCdr, storedCdr)
 	}
 }
diff --git a/sessionmanager/smgeneric.go b/sessionmanager/smgeneric.go
index d3002af30..911fbfb49 100644
--- a/sessionmanager/smgeneric.go
+++ b/sessionmanager/smgeneric.go
@@ -185,7 +185,7 @@ func (smg *SMGeneric) ttlTerminate(s *SMGSession, tmtr *smgSessionTerminator) {
 		s.debit(debitUsage, tmtr.ttlLastUsed)
 	}
 	smg.sessionEnd(s.CGRID, s.TotalUsage)
-	cdr := s.EventStart.AsStoredCdr(smg.cgrCfg, smg.Timezone)
+	cdr := s.EventStart.AsCDR(smg.cgrCfg, smg.Timezone)
 	cdr.Usage = s.TotalUsage
 	var reply string
 	smg.cdrsrv.Call("CdrsV1.ProcessCDR", cdr, &reply)
@@ -368,7 +368,7 @@ func (smg *SMGeneric) sessionStart(evStart SMGenericEvent, clntConn rpcclient.Rp
 			return nil, nil // ToDo: handle here also debits
 		}
 		var sessionRuns []*engine.SessionRun
-		if err := smg.rals.Call("Responder.GetSessionRuns", evStart.AsStoredCdr(smg.cgrCfg, smg.Timezone), &sessionRuns); err != nil {
+		if err := smg.rals.Call("Responder.GetSessionRuns", evStart.AsCDR(smg.cgrCfg, smg.Timezone), &sessionRuns); err != nil {
 			return nil, err
 		} else if len(sessionRuns) == 0 {
 			return nil, nil
@@ -655,7 +655,7 @@ func (smg *SMGeneric) GetMaxUsage(gev SMGenericEvent) (maxUsage time.Duration, e
 	}
 	defer smg.responseCache.Cache(cacheKey, &cache.CacheItem{Value: maxUsage, Err: err})
 	gev[utils.EVENT_NAME] = utils.CGR_AUTHORIZATION
-	storedCdr := gev.AsStoredCdr(config.CgrConfig(), smg.Timezone)
+	storedCdr := gev.AsCDR(config.CgrConfig(), smg.Timezone)
 	var maxDur float64
 	if err = smg.rals.Call("Responder.GetDerivedMaxSessionTime", storedCdr, &maxDur); err != nil {
 		return
@@ -857,7 +857,7 @@ func (smg *SMGeneric) ChargeEvent(gev SMGenericEvent) (maxUsage time.Duration, e
 	}
 	defer smg.responseCache.Cache(cacheKey, &cache.CacheItem{Value: maxUsage, Err: err})
 	var sessionRuns []*engine.SessionRun
-	if err = smg.rals.Call("Responder.GetSessionRuns", gev.AsStoredCdr(smg.cgrCfg, smg.Timezone), &sessionRuns); err != nil {
+	if err = smg.rals.Call("Responder.GetSessionRuns", gev.AsCDR(smg.cgrCfg, smg.Timezone), &sessionRuns); err != nil {
 		return
 	} else if len(sessionRuns) == 0 {
 		return
@@ -961,7 +961,7 @@ func (smg *SMGeneric) ProcessCDR(gev SMGenericEvent) (err error) {
 	}
 	defer smg.responseCache.Cache(cacheKey, &cache.CacheItem{Err: err})
 	var reply string
-	if err = smg.cdrsrv.Call("CdrsV1.ProcessCDR", gev.AsStoredCdr(smg.cgrCfg, smg.Timezone), &reply); err != nil {
+	if err = smg.cdrsrv.Call("CdrsV1.ProcessCDR", gev.AsCDR(smg.cgrCfg, smg.Timezone), &reply); err != nil {
 		return
 	}
 	return