diff --git a/agents/dmtagent_it_test.go b/agents/dmtagent_it_test.go
index b080fe393..1d7b93ed1 100644
--- a/agents/dmtagent_it_test.go
+++ b/agents/dmtagent_it_test.go
@@ -486,7 +486,7 @@ func TestDmtAgentSendCCRSMS(t *testing.T) {
 	} else if len(cdrs) != 1 {
 		t.Error("Unexpected number of CDRs returned: ", len(cdrs))
 	} else {
-		if cdrs[0].Usage != "1" {
+		if cdrs[0].Usage != "60000000000" { // should be 1 but maxUsage returns rounded version
 			t.Errorf("Unexpected CDR Usage received, cdr: %+v ", cdrs[0])
 		}
 		if cdrs[0].Cost != 0.6 {
diff --git a/sessions/sessions.go b/sessions/sessions.go
index 4e612ea3e..c1df01720 100644
--- a/sessions/sessions.go
+++ b/sessions/sessions.go
@@ -717,13 +717,15 @@ func (smg *SMGeneric) GetMaxUsage(gev SMGenericEvent) (maxUsage time.Duration, e
 }
 
 // Called on session start
-func (smg *SMGeneric) InitiateSession(gev SMGenericEvent, clnt rpcclient.RpcClientConnection) (maxUsage time.Duration, err error) {
+func (smg *SMGeneric) InitiateSession(gev SMGenericEvent,
+	clnt rpcclient.RpcClientConnection) (maxUsage time.Duration, err error) {
 	cgrID := gev.GetCGRID(utils.META_DEFAULT)
 	cacheKey := "InitiateSession" + cgrID
 	if item, err := smg.responseCache.Get(cacheKey); err == nil && item != nil {
 		return item.Value.(time.Duration), item.Err
 	}
-	defer smg.responseCache.Cache(cacheKey, &utils.ResponseCacheItem{Value: maxUsage, Err: err}) // schedule response caching
+	defer smg.responseCache.Cache(cacheKey,
+		&utils.ResponseCacheItem{Value: maxUsage, Err: err}) // schedule response caching
 	smg.deletePassiveSessions(cgrID)
 	if err = smg.sessionStart(gev, clnt); err != nil {
 		smg.sessionEnd(cgrID, 0)
@@ -741,20 +743,23 @@ func (smg *SMGeneric) InitiateSession(gev SMGenericEvent, clnt rpcclient.RpcClie
 }
 
 // Execute debits for usage/maxUsage
-func (smg *SMGeneric) UpdateSession(gev SMGenericEvent, clnt rpcclient.RpcClientConnection) (maxUsage time.Duration, err error) {
+func (smg *SMGeneric) UpdateSession(gev SMGenericEvent,
+	clnt rpcclient.RpcClientConnection) (maxUsage time.Duration, err error) {
 	cgrID := gev.GetCGRID(utils.META_DEFAULT)
 	cacheKey := "UpdateSession" + cgrID
 	if item, err := smg.responseCache.Get(cacheKey); err == nil && item != nil {
 		return item.Value.(time.Duration), item.Err
 	}
-	defer smg.responseCache.Cache(cacheKey, &utils.ResponseCacheItem{Value: maxUsage, Err: err})
+	defer smg.responseCache.Cache(cacheKey,
+		&utils.ResponseCacheItem{Value: maxUsage, Err: err})
 	if smg.cgrCfg.SessionSCfg().DebitInterval != 0 { // Not possible to update a session with debit loop active
 		err = errors.New("ACTIVE_DEBIT_LOOP")
 		return
 	}
 	if gev.HasField(utils.InitialOriginID) {
 		initialCGRID := gev.GetCGRID(utils.InitialOriginID)
-		err = smg.sessionRelocate(initialCGRID, cgrID, gev.GetOriginID(utils.META_DEFAULT))
+		err = smg.sessionRelocate(initialCGRID,
+			cgrID, gev.GetOriginID(utils.META_DEFAULT))
 		if err == utils.ErrNotFound { // Session was already relocated, create a new  session with this update
 			err = smg.sessionStart(gev, clnt)
 		}
@@ -785,12 +790,15 @@ func (smg *SMGeneric) UpdateSession(gev SMGenericEvent, clnt rpcclient.RpcClient
 	aSessions := smg.getSessions(cgrID, false)
 	if len(aSessions) == 0 {
 		if aSessions = smg.passiveToActive(cgrID); len(aSessions) == 0 {
-			utils.Logger.Err(fmt.Sprintf("<%s> SessionUpdate with no active sessions for event: <%s>", utils.SessionS, cgrID))
+			utils.Logger.Err(
+				fmt.Sprintf("<%s> SessionUpdate with no active sessions for event: <%s>",
+					utils.SessionS, cgrID))
 			err = rpcclient.ErrSessionNotFound
 			return
 		}
 	}
-	defer smg.replicateSessionsWithID(gev.GetCGRID(utils.META_DEFAULT), false, smg.smgReplConns)
+	defer smg.replicateSessionsWithID(gev.GetCGRID(utils.META_DEFAULT),
+		false, smg.smgReplConns)
 	for _, s := range aSessions[cgrID] {
 		if s.RunID == utils.META_NONE {
 			maxUsage = time.Duration(-1)
@@ -807,7 +815,8 @@ func (smg *SMGeneric) UpdateSession(gev SMGenericEvent, clnt rpcclient.RpcClient
 }
 
 // Called on session end, should stop debit loop
-func (smg *SMGeneric) TerminateSession(gev SMGenericEvent, clnt rpcclient.RpcClientConnection) (err error) {
+func (smg *SMGeneric) TerminateSession(gev SMGenericEvent,
+	clnt rpcclient.RpcClientConnection) (err error) {
 	cgrID := gev.GetCGRID(utils.META_DEFAULT)
 	cacheKey := "TerminateSession" + cgrID
 	if item, err := smg.responseCache.Get(cacheKey); err == nil && item != nil {
@@ -816,7 +825,8 @@ func (smg *SMGeneric) TerminateSession(gev SMGenericEvent, clnt rpcclient.RpcCli
 	defer smg.responseCache.Cache(cacheKey, &utils.ResponseCacheItem{Err: err})
 	if gev.HasField(utils.InitialOriginID) {
 		initialCGRID := gev.GetCGRID(utils.InitialOriginID)
-		err = smg.sessionRelocate(initialCGRID, cgrID, gev.GetOriginID(utils.META_DEFAULT))
+		err = smg.sessionRelocate(initialCGRID, cgrID,
+			gev.GetOriginID(utils.META_DEFAULT))
 		if err == utils.ErrNotFound { // Session was already relocated, create a new  session with this update
 			err = smg.sessionStart(gev, clnt)
 		}
diff --git a/sessions/sevent.go b/sessions/sevent.go
index 75e9f9247..8951806b1 100644
--- a/sessions/sevent.go
+++ b/sessions/sevent.go
@@ -418,15 +418,20 @@ func (self SMGenericEvent) PassesFieldFilter(*utils.RSRField) (bool, string) {
 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
+	storCdr.ToR = utils.FirstNonEmpty(self.GetTOR(utils.META_DEFAULT),
+		storCdr.ToR) // Keep default if none in the event
 	storCdr.OriginID = self.GetOriginID(utils.META_DEFAULT)
 	storCdr.OriginHost = self.GetOriginatorIP(utils.META_DEFAULT)
 	storCdr.Source = self.GetCdrSource()
-	storCdr.RequestType = utils.FirstNonEmpty(self.GetReqType(utils.META_DEFAULT), storCdr.RequestType)
-	storCdr.Tenant = utils.FirstNonEmpty(self.GetTenant(utils.META_DEFAULT), storCdr.Tenant)
-	storCdr.Category = utils.FirstNonEmpty(self.GetCategory(utils.META_DEFAULT), storCdr.Category)
+	storCdr.RequestType = utils.FirstNonEmpty(self.GetReqType(utils.META_DEFAULT),
+		storCdr.RequestType)
+	storCdr.Tenant = utils.FirstNonEmpty(self.GetTenant(utils.META_DEFAULT),
+		storCdr.Tenant)
+	storCdr.Category = utils.FirstNonEmpty(self.GetCategory(utils.META_DEFAULT),
+		storCdr.Category)
 	storCdr.Account = self.GetAccount(utils.META_DEFAULT)
-	storCdr.Subject = self.GetSubject(utils.META_DEFAULT)
+	storCdr.Subject = utils.FirstNonEmpty(self.GetSubject(utils.META_DEFAULT),
+		self.GetAccount(utils.META_DEFAULT))
 	storCdr.Destination = self.GetDestination(utils.META_DEFAULT)
 	storCdr.SetupTime, _ = self.GetSetupTime(utils.META_DEFAULT, timezone)
 	storCdr.AnswerTime, _ = self.GetAnswerTime(utils.META_DEFAULT, timezone)
diff --git a/utils/reflect.go b/utils/reflect.go
index d1b3587d9..f18a4e539 100644
--- a/utils/reflect.go
+++ b/utils/reflect.go
@@ -27,6 +27,9 @@ import (
 )
 
 func CastFieldIfToString(fld interface{}) (string, bool) {
+	if fld == nil {
+		return "", true
+	}
 	var strVal string
 	var converted bool
 	switch fld.(type) {
diff --git a/utils/reflect_test.go b/utils/reflect_test.go
index 16c4777df..40ee23498 100644
--- a/utils/reflect_test.go
+++ b/utils/reflect_test.go
@@ -245,6 +245,9 @@ func TestCastFieldIfToString(t *testing.T) {
 	} else if strVal != "1s" {
 		t.Errorf("received: %s", strVal)
 	}
+	if resVal, converted := CastIfToString(nil); converted || resVal != "" {
+		t.Errorf("received: %s", resVal)
+	}
 }
 
 func TestIfaceAsTime(t *testing.T) {