diff --git a/engine/mapevent.go b/engine/mapevent.go
index 2d1a94426..c32babc8d 100644
--- a/engine/mapevent.go
+++ b/engine/mapevent.go
@@ -121,7 +121,7 @@ func (me MapEvent) AsMapStringIgnoreErrors(ignoredFlds utils.StringMap) (mp map[
 		if ignoredFlds.HasKey(k) {
 			continue
 		}
-		if out, can := utils.CastFieldIfToString(v); can {
+		if out, err := utils.IfaceAsString(v); err == nil {
 			mp[k] = out
 		}
 	}
diff --git a/engine/safevent_test.go b/engine/safevent_test.go
index e91b8772b..065ebab65 100644
--- a/engine/safevent_test.go
+++ b/engine/safevent_test.go
@@ -53,487 +53,561 @@ func TestSafEventMapEvent(t *testing.T) {
 }
 
 func TestSafEventClone(t *testing.T) {
-	var rply *SafEvent
-	safEv = safEv.Clone()
-	t.Run("clone1", func(t *testing.T) {
-		t.Parallel()
-		rply = safEv.Clone()
-		if !reflect.DeepEqual(safEv, rply) {
-			t.Errorf("Expecting %+v, received: %+v", safEv, rply)
-		}
-	})
-	t.Run("clone2", func(t *testing.T) {
-		t.Parallel()
-		safEv.Set("test4", false)
-		if reflect.DeepEqual(safEv, rply) {
-			t.Errorf("Expecting %+v, received: %+v", safEv, rply)
-		}
-	})
+	for i := 0; i < 10; i++ {
+		t.Run("clone", func(t *testing.T) {
+			t.Parallel()
+			safEv.Clone()
+		})
+		t.Run("set", func(t *testing.T) {
+			t.Parallel()
+			safEv.Set("test4", true)
+		})
+	}
+	rply := safEv.Clone()
+	if !reflect.DeepEqual(safEv, rply) {
+		t.Errorf("Expecting %+v, received: %+v", safEv, rply)
+	}
+	rply.Set("test4", false)
+	if reflect.DeepEqual(safEv, rply) {
+		t.Errorf("Expecting %+v, received: %+v", safEv, rply)
+	}
 }
 
 func TestSafEventString(t *testing.T) {
-	var rply string
 	expected := safEv.Me.String()
-	t.Run("string1", func(t *testing.T) {
-		t.Parallel()
-		rply = safEv.String()
-		if !reflect.DeepEqual(expected, rply) {
-			t.Errorf("Expecting %+v, received: %+v", expected, rply)
-		}
-	})
-	t.Run("string2", func(t *testing.T) {
-		t.Parallel()
-		safEv.Set("test4", false)
-		rply = safEv.String()
-		safEv.RLock()
-		expected = safEv.Me.String()
-		safEv.RUnlock()
-		if !reflect.DeepEqual(expected, rply) {
-			t.Errorf("Expecting %+v, received: %+v", safEv, rply)
-		}
-	})
-	t.Run("string3", func(t *testing.T) {
-		t.Parallel()
-		safEv.Set("test4", true)
-		rply = safEv.String()
-		safEv.RLock()
-		expected = safEv.Me.String()
-		safEv.RUnlock()
-		if !reflect.DeepEqual(expected, rply) {
-			t.Errorf("Expecting %+v, received: %+v", safEv, rply)
-		}
-	})
+	if rply := safEv.String(); !reflect.DeepEqual(expected, rply) {
+		t.Errorf("Expecting %+v, received: %+v", expected, rply)
+	}
+	se := safEv.Clone()
+	for i := 0; i < 10; i++ {
+		t.Run("string", func(t *testing.T) {
+			t.Parallel()
+			se.String()
+		})
+		t.Run("remove", func(t *testing.T) {
+			t.Parallel()
+			se.Remove("test4")
+		})
+	}
+	se.Remove("test5")
+	expected = se.Me.String()
+	if rply := se.String(); !reflect.DeepEqual(expected, rply) {
+		t.Errorf("Expecting %+v, received: %+v", expected, rply)
+	}
 }
 
 func TestSafEventHasField(t *testing.T) {
-	t.Run("field1", func(t *testing.T) {
-		t.Parallel()
-		if rply := safEv.HasField("test4"); !rply {
-			t.Errorf("Expecting true, received: %+v", rply)
-		}
-	})
-	t.Run("field2", func(t *testing.T) {
-		t.Parallel()
-		safEv.Remove("test4")
-		if rply := safEv.HasField("test4"); rply {
-			t.Errorf("Expecting false, received: %+v", rply)
-		}
-	})
-	t.Run("field3", func(t *testing.T) {
-		t.Parallel()
-		safEv.Set("test4", true)
-		if rply := safEv.HasField("test4"); !rply {
-			t.Errorf("Expecting true, received: %+v", rply)
-		}
-	})
+	if rply := safEv.HasField("test4"); !rply {
+		t.Errorf("Expecting true, received: %+v", rply)
+	}
+	se := safEv.Clone()
+	for i := 0; i < 10; i++ {
+		t.Run("field", func(t *testing.T) {
+			t.Parallel()
+			se.HasField("test4")
+		})
+		t.Run("remove", func(t *testing.T) {
+			t.Parallel()
+			se.Remove("test4")
+		})
+	}
+	se.Remove("test5")
+	if rply := se.HasField("test5"); rply {
+		t.Errorf("Expecting false, received: %+v", rply)
+	}
 }
 
 func TestSafEventGet(t *testing.T) {
-	t.Run("get1", func(t *testing.T) {
-		t.Parallel()
-		if rply, has := safEv.Get("test5"); !has {
-			t.Errorf("Expecting 'test5' to be a field")
-		} else if rply != "test" {
-			t.Errorf("Expecting test, received: %+v", rply)
-		}
-	})
-	t.Run("get2", func(t *testing.T) {
-		t.Parallel()
-		safEv.Remove("test5")
-		if rply, has := safEv.Get("test5"); has {
-			t.Errorf("Expecting 'test5' to not be a field, recived %+v", rply)
-		}
-	})
-	t.Run("get3", func(t *testing.T) {
-		t.Parallel()
-		safEv.Set("test5", false)
-		if rply, has := safEv.Get("test5"); !has {
-			t.Errorf("Expecting 'test5' to be a field")
-		} else if rply != false {
-			t.Errorf("Expecting false, received: %+v", rply)
-		}
-	})
+	for i := 0; i < 10; i++ {
+		t.Run("get", func(t *testing.T) {
+			t.Parallel()
+			safEv.Get("test4")
+		})
+		t.Run("set", func(t *testing.T) {
+			t.Parallel()
+			safEv.Set("test4", true)
+		})
+	}
+	safEv.Remove("test4")
+	if rply, has := safEv.Get("test4"); has {
+		t.Errorf("Expecting 'test4' to not be a field, recived: %+v", rply)
+	}
+	safEv.Set("test4", false)
+	if rply, has := safEv.Get("test4"); !has {
+		t.Errorf("Expecting 'test4' to be a field")
+	} else if rply != false {
+		t.Errorf("Expecting false, received: %+v", rply)
+	}
+	safEv.Set("test4", true)
+	if rply, has := safEv.Get("test4"); !has {
+		t.Errorf("Expecting 'test4' to be a field")
+	} else if rply != true {
+		t.Errorf("Expecting true, received: %+v", rply)
+	}
 }
 
 func TestSafEventGetIgnoreErrors(t *testing.T) {
-	t.Run("getIgnore1", func(t *testing.T) {
-		t.Parallel()
-		if rply := safEv.GetIgnoreErrors("test2"); rply != 42 {
-			t.Errorf("Expecting 42, received: %+v", rply)
-		}
-	})
-	t.Run("getIgnore2", func(t *testing.T) {
-		t.Parallel()
-		safEv.Remove("test2")
-		if rply := safEv.GetIgnoreErrors("test2"); rply != nil {
-			t.Errorf("Expecting null, received: %+v", rply)
-		}
-	})
-	t.Run("getIgnore3", func(t *testing.T) {
-		t.Parallel()
-		safEv.Set("test2", 43)
-		if rply := safEv.GetIgnoreErrors("test2"); rply != 43 {
-			t.Errorf("Expecting 43, received: %+v", rply)
-		}
-	})
+	for i := 0; i < 10; i++ {
+		t.Run("getIgnore", func(t *testing.T) {
+			t.Parallel()
+			safEv.GetIgnoreErrors("test4")
+		})
+		t.Run("set", func(t *testing.T) {
+			t.Parallel()
+			safEv.Set("test4", true)
+		})
+		t.Run("remove", func(t *testing.T) {
+			t.Parallel()
+			safEv.Remove("test4")
+		})
+	}
+	safEv.Remove("test4")
+	if rply := safEv.GetIgnoreErrors("test4"); rply != nil {
+		t.Errorf("Expecting: null, recived: %+v", rply)
+	}
+	safEv.Set("test4", false)
+	if rply := safEv.GetIgnoreErrors("test4"); rply != false {
+		t.Errorf("Expecting false, received: %+v", rply)
+	}
+	safEv.Set("test4", true)
+	if rply := safEv.GetIgnoreErrors("test4"); rply != true {
+		t.Errorf("Expecting true, received: %+v", rply)
+	}
 }
 
 func TestSafEventGetString(t *testing.T) {
-	t.Run("getString1", func(t *testing.T) {
-		t.Parallel()
-		if rply, err := safEv.GetString("test6"); err != nil {
-			t.Error(err)
-		} else if rply != "10s" {
-			t.Errorf("Expecting 10s, received: %+v", rply)
-		}
-	})
-	t.Run("getString2", func(t *testing.T) {
-		t.Parallel()
-		if rply, err := safEv.GetString("test"); err == nil {
-			t.Errorf("Expecting 'test' to not be a field, recived %+v", rply)
-		}
-	})
-	t.Run("getString3", func(t *testing.T) {
-		t.Parallel()
-		safEv.Set("test7", "43s")
-		if rply, err := safEv.GetString("test7"); err != nil {
-			t.Error(err)
-		} else if rply != "43s" {
-			t.Errorf("Expecting 43s, received: %+v", rply)
-		}
-	})
+	for i := 0; i < 10; i++ {
+		t.Run("getString", func(t *testing.T) {
+			t.Parallel()
+			if _, err := safEv.GetString("test4"); err != nil && err != utils.ErrNotFound {
+				t.Error(err)
+			}
+		})
+		t.Run("set", func(t *testing.T) {
+			t.Parallel()
+			safEv.Set("test4", true)
+		})
+		t.Run("remove", func(t *testing.T) {
+			t.Parallel()
+			safEv.Remove("test4")
+		})
+	}
+	safEv.Remove("test2")
+	if _, err := safEv.GetString("test2"); err != utils.ErrNotFound {
+		t.Errorf("Expecting: %+v ,recived: %+v", utils.ErrNotFound, err)
+	}
+	safEv.Set("test2", 42.3)
+	if rply, err := safEv.GetString("test2"); err != nil {
+		t.Error(err)
+	} else if rply != "42.3" {
+		t.Errorf("Expecting 42.3, received: %+v", rply)
+	}
+	safEv.Set("test2", 42)
+	if rply, err := safEv.GetString("test2"); err != nil {
+		t.Error(err)
+	} else if rply != "42" {
+		t.Errorf("Expecting 42, received: %+v", rply)
+	}
 }
 
 func TestSafEventGetStringIgnoreErrors(t *testing.T) {
-	t.Run("getStringIgnore1", func(t *testing.T) {
-		t.Parallel()
-		safEv.Set("test1", nil)
-		if rply := safEv.GetStringIgnoreErrors("test1"); rply != "" {
-			t.Errorf("Expecting , received: %+v", rply)
-		}
-	})
-	t.Run("getStringIgnore2", func(t *testing.T) {
-		t.Parallel()
-		safEv.Remove("test2")
-		if rply := safEv.GetStringIgnoreErrors("test2"); rply != "" {
-			t.Errorf("Expecting null, received: %+v", rply)
-		}
-	})
-	t.Run("getStringIgnore3", func(t *testing.T) {
-		t.Parallel()
-		safEv.Set("test1", 43)
-		if rply := safEv.GetStringIgnoreErrors("test1"); rply != "43" {
-			t.Errorf("Expecting 43, received: %+v", rply)
-		}
-	})
+	for i := 0; i < 10; i++ {
+		t.Run("getStringIgn", func(t *testing.T) {
+			t.Parallel()
+			safEv.GetStringIgnoreErrors("test4")
+		})
+		t.Run("set", func(t *testing.T) {
+			t.Parallel()
+			safEv.Set("test4", true)
+		})
+		t.Run("remove", func(t *testing.T) {
+			t.Parallel()
+			safEv.Remove("test4")
+		})
+	}
+	safEv.Remove("test2")
+	if rply := safEv.GetStringIgnoreErrors("test2"); rply != "" {
+		t.Errorf("Expecting: ,recived: %+v", err)
+	}
+	safEv.Set("test2", 42.3)
+	if rply := safEv.GetStringIgnoreErrors("test2"); rply != "42.3" {
+		t.Errorf("Expecting 42.3, received: %+v", rply)
+	}
+	safEv.Set("test2", 42)
+	if rply := safEv.GetStringIgnoreErrors("test2"); rply != "42" {
+		t.Errorf("Expecting 42, received: %+v", rply)
+	}
 }
 
 func TestSafEventGetDuration(t *testing.T) {
-	t.Run("getDuration1", func(t *testing.T) {
-		t.Parallel()
-		expected := time.Duration(43 * time.Second)
-		if rply, err := safEv.GetDuration("test7"); err != nil {
-			t.Error(err)
-		} else if !reflect.DeepEqual(expected, rply) {
-			t.Errorf("Expecting %+v, received: %+v", expected, rply)
-		}
-	})
-	t.Run("getDuration2", func(t *testing.T) {
-		t.Parallel()
-		if rply, err := safEv.GetDuration("test"); err == nil {
-			t.Errorf("Expecting 'test' to not be a field, recived %+v", rply)
-		}
-	})
-	t.Run("getDuration3", func(t *testing.T) {
-		t.Parallel()
-		expected := time.Duration(10 * time.Second)
-		if rply, err := safEv.GetDuration("test6"); err != nil {
-			t.Error(err)
-		} else if !reflect.DeepEqual(expected, rply) {
-			t.Errorf("Expecting %+v, received: %+v", expected, rply)
-		}
-	})
+	for i := 0; i < 10; i++ {
+		t.Run("getDuration", func(t *testing.T) {
+			t.Parallel()
+			if _, err := safEv.GetDuration("test6"); err != nil && err != utils.ErrNotFound {
+				t.Error(err)
+			}
+		})
+		t.Run("set", func(t *testing.T) {
+			t.Parallel()
+			safEv.Set("test6", time.Duration(10*time.Second))
+		})
+		t.Run("remove", func(t *testing.T) {
+			t.Parallel()
+			safEv.Remove("test6")
+		})
+	}
+	safEv.Remove("test7")
+	if _, err := safEv.GetDuration("test7"); err != utils.ErrNotFound {
+		t.Errorf("Expecting: %+v ,recived: %+v", utils.ErrNotFound, err)
+	}
+	if rply, err := safEv.GetDuration("test5"); err == nil {
+		t.Errorf("Expecting: error,recived: %+v", rply)
+	}
+	safEv.Set("test7", "42s")
+	expected := time.Duration(42 * time.Second)
+	if rply, err := safEv.GetDuration("test7"); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(expected, rply) {
+		t.Errorf("Expecting %+v, received: %+v", expected, rply)
+	}
+	expected = time.Duration(10 * time.Second)
+	safEv.Set("test6", expected)
+	if rply, err := safEv.GetDuration("test6"); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(expected, rply) {
+		t.Errorf("Expecting %+v, received: %+v", expected, rply)
+	}
 }
 
 func TestSafEventGetDurationIgnoreErrors(t *testing.T) {
-	t.Run("getDurationIgnore1", func(t *testing.T) {
-		t.Parallel()
-		expected := time.Duration(43 * time.Second)
-		if rply := safEv.GetDurationIgnoreErrors("test7"); !reflect.DeepEqual(expected, rply) {
-			t.Errorf("Expecting %+v, received: %+v", expected, rply)
-		}
-	})
-	t.Run("getDurationIgnore2", func(t *testing.T) {
-		t.Parallel()
-		expected := time.Duration(0)
-		if rply := safEv.GetDurationIgnoreErrors("test"); !reflect.DeepEqual(expected, rply) {
-			t.Errorf("Expecting %+v, received: %+v", expected, rply)
-		}
-	})
-	t.Run("getDurationIgnore3", func(t *testing.T) {
-		t.Parallel()
-		expected := time.Duration(10 * time.Second)
-		if rply := safEv.GetDurationIgnoreErrors("test6"); !reflect.DeepEqual(expected, rply) {
-			t.Errorf("Expecting %+v, received: %+v", expected, rply)
-		}
-	})
+	for i := 0; i < 10; i++ {
+		t.Run("getDurationIgn", func(t *testing.T) {
+			t.Parallel()
+			safEv.GetDurationIgnoreErrors("test6")
+		})
+		t.Run("set", func(t *testing.T) {
+			t.Parallel()
+			safEv.Set("test6", time.Duration(10*time.Second))
+		})
+		t.Run("remove", func(t *testing.T) {
+			t.Parallel()
+			safEv.Remove("test6")
+		})
+	}
+	safEv.Remove("test7")
+	if rply := safEv.GetDurationIgnoreErrors("test7"); rply != time.Duration(0) {
+		t.Errorf("Expecting: %+v ,recived: %+v", time.Duration(0), rply)
+	}
+	safEv.Set("test7", "42s")
+	expected := time.Duration(42 * time.Second)
+	if rply := safEv.GetDurationIgnoreErrors("test7"); !reflect.DeepEqual(expected, rply) {
+		t.Errorf("Expecting %+v, received: %+v", expected, rply)
+	}
+	expected = time.Duration(10 * time.Second)
+	safEv.Set("test6", expected)
+	if rply := safEv.GetDurationIgnoreErrors("test6"); !reflect.DeepEqual(expected, rply) {
+		t.Errorf("Expecting %+v, received: %+v", expected, rply)
+	}
 }
 
 func TestSafEventGetDurationPtr(t *testing.T) {
-	t.Run("getDurationPtr1", func(t *testing.T) {
-		t.Parallel()
-		expected := time.Duration(43 * time.Second)
-		if rply, err := safEv.GetDurationPtr("test7"); err != nil {
-			t.Error(err)
-		} else if !reflect.DeepEqual(&expected, rply) {
-			t.Errorf("Expecting %+v, received: %+v", expected, rply)
-		}
-	})
-	t.Run("getDurationPtr2", func(t *testing.T) {
-		t.Parallel()
-		if _, err := safEv.GetDurationPtr("test"); err != utils.ErrNotFound {
-			t.Errorf("Expecting %+v, recived %+v", utils.ErrNotFound, err)
-		}
-	})
-	t.Run("getDurationPtr3", func(t *testing.T) {
-		t.Parallel()
-		expected := time.Duration(11 * time.Second)
-		safEv.Set("test6", expected)
-		if rply, err := safEv.GetDurationPtr("test6"); err != nil {
-			t.Error(err)
-		} else if !reflect.DeepEqual(&expected, rply) {
-			t.Errorf("Expecting %+v, received: %+v", expected, rply)
-		}
-	})
+	for i := 0; i < 10; i++ {
+		t.Run("getDurationPtr", func(t *testing.T) {
+			t.Parallel()
+			if _, err := safEv.GetDurationPtr("test6"); err != nil && err != utils.ErrNotFound {
+				t.Error(err)
+			}
+		})
+		t.Run("set", func(t *testing.T) {
+			t.Parallel()
+			safEv.Set("test6", time.Duration(10*time.Second))
+		})
+		t.Run("remove", func(t *testing.T) {
+			t.Parallel()
+			safEv.Remove("test6")
+		})
+	}
+	safEv.Remove("test7")
+	if _, err := safEv.GetDurationPtr("test7"); err != utils.ErrNotFound {
+		t.Errorf("Expecting: %+v ,recived: %+v", utils.ErrNotFound, err)
+	}
+	if rply, err := safEv.GetDurationPtr("test5"); err == nil {
+		t.Errorf("Expecting: error,recived: %+v", rply)
+	}
+	safEv.Set("test7", "42s")
+	expected := time.Duration(42 * time.Second)
+	if rply, err := safEv.GetDurationPtr("test7"); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(&expected, rply) {
+		t.Errorf("Expecting %+v, received: %+v", expected, rply)
+	}
+	expected = time.Duration(10 * time.Second)
+	safEv.Set("test6", expected)
+	if rply, err := safEv.GetDurationPtr("test6"); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(&expected, rply) {
+		t.Errorf("Expecting %+v, received: %+v", expected, rply)
+	}
 }
 
 func TestSafEventGetDurationPtrOrDefault(t *testing.T) {
 	def := time.Duration(450)
-	safEv = NewSafEvent(sMap)
-	t.Run("getDurationPtrDef1", func(t *testing.T) {
-		t.Parallel()
-		expected := time.Duration(42 * time.Second)
-		if rply, err := safEv.GetDurationPtrOrDefault("test7", &def); err != nil {
-			t.Error(err)
-		} else if !reflect.DeepEqual(&expected, rply) {
-			t.Errorf("Expecting %+v, received: %+v", expected, rply)
-		}
-	})
-	t.Run("getDurationPtrDef2", func(t *testing.T) {
-		t.Parallel()
-		expected := time.Duration(12 * time.Second)
-		if rply, err := safEv.GetDurationPtrOrDefault("othertest", &expected); err != nil {
-			t.Error(err)
-		} else if !reflect.DeepEqual(&expected, rply) {
-			t.Errorf("Expecting %+v, received: %+v", expected, rply)
-		}
-	})
-	t.Run("getDurationPtrDef3", func(t *testing.T) {
-		t.Parallel()
-		if rply, err := safEv.GetDurationPtrOrDefault("test5", &def); err == nil {
-			t.Errorf("Expecting error, recived %+v", rply)
-		}
-	})
+	for i := 0; i < 10; i++ {
+		t.Run("getDurationPtrDef", func(t *testing.T) {
+			t.Parallel()
+			if _, err := safEv.GetDurationPtrOrDefault("test6", &def); err != nil {
+				t.Error(err)
+			}
+		})
+		t.Run("set", func(t *testing.T) {
+			t.Parallel()
+			safEv.Set("test6", time.Duration(10*time.Second))
+		})
+		t.Run("remove", func(t *testing.T) {
+			t.Parallel()
+			safEv.Remove("test6")
+		})
+	}
+	safEv.Remove("test7")
+	if rply, err := safEv.GetDurationPtrOrDefault("test7", &def); err != nil {
+		t.Errorf("Expecting: %+v ,recived: %+v", utils.ErrNotFound, err)
+	} else if !reflect.DeepEqual(&def, rply) {
+		t.Errorf("Expecting %+v, received: %+v", def, rply)
+	}
+	if rply, err := safEv.GetDurationPtrOrDefault("test5", &def); err == nil {
+		t.Errorf("Expecting: error,recived: %+v", rply)
+	}
+	safEv.Set("test7", "42s")
+	expected := time.Duration(42 * time.Second)
+	if rply, err := safEv.GetDurationPtrOrDefault("test7", &def); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(&expected, rply) {
+		t.Errorf("Expecting %+v, received: %+v", expected, rply)
+	}
+	expected = time.Duration(10 * time.Second)
+	safEv.Set("test6", expected)
+	if rply, err := safEv.GetDurationPtrOrDefault("test6", &def); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(&expected, rply) {
+		t.Errorf("Expecting %+v, received: %+v", expected, rply)
+	}
 }
 
-func TestSafEventGetGetTime(t *testing.T) {
-	t.Run("getTime1", func(t *testing.T) {
-		t.Parallel()
-		expected := time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC)
-		if rply, err := safEv.GetTime("test8", ""); err != nil {
-			t.Error(err)
-		} else if !reflect.DeepEqual(expected, rply) {
-			t.Errorf("Expecting %+v, received: %+v", expected, rply)
-		}
-	})
-	t.Run("getTime2", func(t *testing.T) {
-		t.Parallel()
-		if rply, err := safEv.GetTime("test", ""); err == nil {
-			t.Errorf("Expecting 'test' to not be a field, recived %+v", rply)
-		}
-		if rply, err := safEv.GetTime("test4", ""); err == nil {
-			t.Errorf("Expecting 'test' to not be a field, recived %+v", rply)
-		}
-	})
-	t.Run("getTime3", func(t *testing.T) {
-		t.Parallel()
-		expected := time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC)
-		if rply, err := safEv.GetTime("test9", ""); err != nil {
-			t.Error(err)
-		} else if !reflect.DeepEqual(expected, rply) {
-			t.Errorf("Expecting %+v, received: %+v", expected, rply)
-		}
-	})
+func TestSafEventGetTime(t *testing.T) {
+	for i := 0; i < 10; i++ {
+		t.Run("getTime", func(t *testing.T) {
+			t.Parallel()
+			if _, err := safEv.GetTime("test8", ""); err != nil && err != utils.ErrNotFound {
+				t.Error(err)
+			}
+		})
+		t.Run("set", func(t *testing.T) {
+			t.Parallel()
+			safEv.Set("test8", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC))
+		})
+		t.Run("remove", func(t *testing.T) {
+			t.Parallel()
+			safEv.Remove("test8")
+		})
+	}
+	safEv.Remove("test9")
+	if _, err := safEv.GetTime("test9", ""); err != utils.ErrNotFound {
+		t.Errorf("Expecting: %+v ,recived: %+v", utils.ErrNotFound, err)
+	}
+	if rply, err := safEv.GetTime("test5", ""); err == nil {
+		t.Errorf("Expecting: error,recived: %+v", rply)
+	}
+	safEv.Set("test9", "2010-11-10T23:00:00Z")
+	expected := time.Date(2010, 11, 10, 23, 0, 0, 0, time.UTC)
+	if rply, err := safEv.GetTime("test9", ""); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(expected, rply) {
+		t.Errorf("Expecting %+v, received: %+v", expected, rply)
+	}
+	expected = time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC)
+	safEv.Set("test8", expected)
+	if rply, err := safEv.GetTime("test8", ""); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(expected, rply) {
+		t.Errorf("Expecting %+v, received: %+v", expected, rply)
+	}
 }
 
 func TestSafEventGetTimeIgnoreErrors(t *testing.T) {
-	t.Run("getTimeIgnore1", func(t *testing.T) {
-		t.Parallel()
-		expected := time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC)
-		if rply := safEv.GetTimeIgnoreErrors("test8", ""); !reflect.DeepEqual(expected, rply) {
-			t.Errorf("Expecting %+v, received: %+v", expected, rply)
-		}
-	})
-	t.Run("getTimeIgnore2", func(t *testing.T) {
-		t.Parallel()
-		safEv.Set("test8", nil)
-		if rply := safEv.GetTimeIgnoreErrors("test", ""); !rply.IsZero() {
-			t.Errorf("Expecting January 1, year 1, 00:00:00.000000000 UTC, received: %+v", rply)
-		}
-	})
-	t.Run("getTimeIgnore3", func(t *testing.T) {
-		t.Parallel()
-		expected := time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC)
-		if rply := safEv.GetTimeIgnoreErrors("test9", ""); !reflect.DeepEqual(expected, rply) {
-			t.Errorf("Expecting %+v, received: %+v", expected, rply)
-		}
-	})
+	for i := 0; i < 10; i++ {
+		t.Run("getTimeIgn", func(t *testing.T) {
+			t.Parallel()
+			safEv.GetTimeIgnoreErrors("test8", "")
+		})
+		t.Run("set", func(t *testing.T) {
+			t.Parallel()
+			safEv.Set("test8", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC))
+		})
+		t.Run("remove", func(t *testing.T) {
+			t.Parallel()
+			safEv.Remove("test8")
+		})
+	}
+	safEv.Remove("test9")
+	if rply := safEv.GetTimeIgnoreErrors("test9", ""); !rply.IsZero() {
+		t.Errorf("Expecting January 1, year 1, 00:00:00.000000000 UTC, received: %+v", rply)
+	}
+	if rply := safEv.GetTimeIgnoreErrors("test5", ""); !rply.IsZero() {
+		t.Errorf("Expecting January 1, year 1, 00:00:00.000000000 UTC, received: %+v", rply)
+	}
+	safEv.Set("test9", "2010-11-10T23:00:00Z")
+	expected := time.Date(2010, 11, 10, 23, 0, 0, 0, time.UTC)
+	if rply := safEv.GetTimeIgnoreErrors("test9", ""); !reflect.DeepEqual(expected, rply) {
+		t.Errorf("Expecting %+v, received: %+v", expected, rply)
+	}
+	expected = time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC)
+	safEv.Set("test8", expected)
+	if rply := safEv.GetTimeIgnoreErrors("test8", ""); !reflect.DeepEqual(expected, rply) {
+		t.Errorf("Expecting %+v, received: %+v", expected, rply)
+	}
 }
 
 func TestSafEventGetSetString(t *testing.T) {
-	t.Run("getSetString1", func(t *testing.T) {
-		t.Parallel()
-		var expected string
-		if expected, err = safEv.GetString("test1"); err != nil {
-			t.Error(err)
-		}
-		if rply, err := safEv.GetSetString("test1", "test"); err != nil {
-			t.Error(err)
-		} else if !reflect.DeepEqual(expected, rply) {
-			t.Errorf("Expecting %+v, received: %+v", expected, rply)
-		}
-		safEv.Remove("test1")
-		safEv.Remove("test2")
-		expected = "test"
-		if rply, err := safEv.GetSetString("test1", expected); err != nil {
-			t.Error(err)
-		} else if !reflect.DeepEqual(expected, rply) {
-			t.Errorf("Expecting %+v, received: %+v", expected, rply)
-		}
-		if rply, err := safEv.GetString("test1"); err != nil {
-			t.Error(err)
-		} else if !reflect.DeepEqual(expected, rply) {
-			t.Errorf("Expecting %+v, received: %+v", expected, rply)
-		}
-	})
-	t.Run("getSetString2", func(t *testing.T) {
-		t.Parallel()
-		expected := "test"
-		if rply, err := safEv.GetSetString("test2", "test"); err != nil {
-			t.Error(err)
-		} else if !reflect.DeepEqual(expected, rply) {
-			t.Errorf("Expecting %+v, received: %+v", expected, rply)
-		}
-	})
+	for i := 0; i < 10; i++ {
+		t.Run("getSetString", func(t *testing.T) {
+			t.Parallel()
+			safEv.GetSetString("test4", "true")
+		})
+		t.Run("remove", func(t *testing.T) {
+			t.Parallel()
+			safEv.Remove("test4")
+		})
+	}
+	safEv.Remove("test2")
+	expected := "test2"
+	if rply, err := safEv.GetSetString("test2", expected); err != nil {
+		t.Error(err)
+	} else if rply != expected {
+		t.Errorf("Expecting: %+v ,recived: %+v", expected, rply)
+	}
+	safEv.Set("test2", 42.3)
+	if rply, err := safEv.GetSetString("test2", ""); err != nil {
+		t.Error(err)
+	} else if rply != "42.3" {
+		t.Errorf("Expecting 42.3, received: %+v", rply)
+	}
+	safEv.Set("test2", 42)
+	if rply, err := safEv.GetSetString("test2", "test"); err != nil {
+		t.Error(err)
+	} else if rply != "42" {
+		t.Errorf("Expecting 42, received: %+v", rply)
+	}
 }
 
 func TestSafEventGetMapInterface(t *testing.T) {
-	t.Run("getMapInt1", func(t *testing.T) {
-		t.Parallel()
-		if rply := safEv.GetMapInterface(); !reflect.DeepEqual(sMap, rply) {
-			t.Errorf("Expecting %+v, received: %+v", sMap, rply)
-		}
-	})
-	t.Run("getMapInt2", func(t *testing.T) {
-		t.Parallel()
-		sMap["test10"] = true
-		safEv.Set("test10", true)
-	})
-	t.Run("getMapInt3", func(t *testing.T) {
-		t.Parallel()
-		sMap["test12"] = "time"
-		safEv.Set("test12", "time")
-		if rply := safEv.GetMapInterface(); !reflect.DeepEqual(sMap, rply) {
-			t.Errorf("Expecting %+v, received: %+v", sMap, rply)
-		} else if rply["test12"] = 12; !reflect.DeepEqual(sMap, rply) {
-			t.Errorf("Expecting %+v, received: %+v", sMap, rply)
-		}
-	})
+	for i := 0; i < 10; i++ {
+		t.Run("getMapInt", func(t *testing.T) {
+			t.Parallel()
+			safEv.GetMapInterface()
+		})
+		t.Run("set", func(t *testing.T) {
+			t.Parallel()
+			safEv.Set("test8", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC))
+		})
+		t.Run("remove", func(t *testing.T) {
+			t.Parallel()
+			safEv.Remove("test8")
+		})
+	}
+	safEv.Remove("test8")
+	if rply := safEv.GetMapInterface(); !reflect.DeepEqual(sMap, rply) {
+		t.Errorf("Expecting %+v, received: %+v", sMap, rply)
+	}
+	safEv.Set("test8", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC))
+	if rply := safEv.GetMapInterface(); !reflect.DeepEqual(sMap, rply) {
+		t.Errorf("Expecting %+v, received: %+v", sMap, rply)
+	}
 }
+
 func TestSafEventAsMapInterface(t *testing.T) {
-	t.Run("asMapInt1", func(t *testing.T) {
-		t.Parallel()
-		if rply := safEv.AsMapInterface(); !reflect.DeepEqual(sMap, rply) {
-			t.Errorf("Expecting %+v, received: %+v", sMap, rply)
-		}
-	})
-	t.Run("asMapInt2", func(t *testing.T) {
-		t.Parallel()
-		safEv.Set("test10", true)
-	})
-	t.Run("asMapInt3", func(t *testing.T) {
-		t.Parallel()
-		safEv.Set("test12", "time")
-		expected := safEv.GetMapInterface()
-		if rply := safEv.AsMapInterface(); !reflect.DeepEqual(expected, rply) {
-			t.Errorf("Expecting %+v, received: %+v", expected, rply)
-		} else if rply["test12"] = 12; reflect.DeepEqual(expected, rply) {
-			t.Errorf("Expecting %+v, received: %+v", expected, rply)
-		}
-	})
+	for i := 0; i < 10; i++ {
+		t.Run("asMapInt", func(t *testing.T) {
+			t.Parallel()
+			safEv.AsMapInterface()
+		})
+		t.Run("set", func(t *testing.T) {
+			t.Parallel()
+			safEv.Set("test8", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC))
+		})
+		t.Run("remove", func(t *testing.T) {
+			t.Parallel()
+			safEv.Remove("test8")
+		})
+	}
+	rply := safEv.AsMapInterface()
+	if !reflect.DeepEqual(sMap, rply) {
+		t.Errorf("Expecting %+v, received: %+v", sMap, rply)
+	}
+	safEv.Remove("test8")
+	if reflect.DeepEqual(sMap, rply) {
+		t.Errorf("Expecting not be %+v, received: %+v", sMap, rply)
+	}
+	safEv.Set("test8", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC))
 }
 
 func TestSafEventAsMapString(t *testing.T) {
-	t.Run("asMapStr1", func(t *testing.T) {
-		t.Parallel()
-		var expected map[string]string
-		if expected, err = safEv.Me.AsMapString(nil); err != nil {
-			t.Error(err)
-		}
-		if rply, err := safEv.AsMapString(nil); err != nil {
-			t.Error(err)
-		} else if !reflect.DeepEqual(expected, rply) {
-			t.Errorf("Expecting %+v, received: %+v", expected, rply)
-		}
-	})
-	t.Run("asMapStr2", func(t *testing.T) {
-		t.Parallel()
-		safEv.Remove("test10")
-	})
-	t.Run("asMapStr3", func(t *testing.T) {
-		t.Parallel()
-		safEv.Remove("test12")
-		var expected map[string]string
-		if expected, err = safEv.Me.AsMapString(nil); err != nil {
-			t.Error(err)
-		}
-		delete(expected, "test2")
-		if rply, err := safEv.AsMapString(utils.StringMap{"test2": true}); err != nil {
-			t.Error(err)
-		} else if !reflect.DeepEqual(expected, rply) {
-			t.Errorf("Expecting %+v, received: %+v", expected, rply)
-		}
-	})
+	for i := 0; i < 10; i++ {
+		t.Run("asMapStr", func(t *testing.T) {
+			t.Parallel()
+			safEv.AsMapString(nil)
+		})
+		t.Run("set", func(t *testing.T) {
+			t.Parallel()
+			safEv.Set("test9", true)
+		})
+		t.Run("remove", func(t *testing.T) {
+			t.Parallel()
+			safEv.Remove("test9")
+		})
+	}
+	var expected map[string]string
+	if expected, err = safEv.Me.AsMapString(nil); err != nil {
+		t.Error(err)
+	}
+	if rply, err := safEv.AsMapString(nil); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(expected, rply) {
+		t.Errorf("Expecting %+v, received: %+v", expected, rply)
+	}
+	delete(expected, "test1")
+	if rply, err := safEv.AsMapString(utils.StringMap{"test1": true}); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(expected, rply) {
+		t.Errorf("Expecting %+v, received: %+v", expected, rply)
+	}
 }
 
 func TestSafEventAsMapStringIgnoreErrors(t *testing.T) {
-	t.Run("asMapStrIgn1", func(t *testing.T) {
-		t.Parallel()
-		var expected map[string]string
-		safEv.RLock()
-		if expected, err = safEv.Me.AsMapString(nil); err != nil {
-			t.Error(err)
-		}
-		safEv.RUnlock()
-		if rply := safEv.AsMapStringIgnoreErrors(nil); !reflect.DeepEqual(expected, rply) {
-			t.Errorf("Expecting %+v, received: %+v", expected, rply)
-		}
-	})
-	t.Run("asMapStrIgn2", func(t *testing.T) {
-		t.Parallel()
-		safEv.Set("test10", "test3")
-	})
-	t.Run("asMapStrIgn3", func(t *testing.T) {
-		t.Parallel()
-		safEv.Set("test12", 42)
-		var expected map[string]string
-		if expected, err = safEv.Me.AsMapString(utils.StringMap{"test12": true}); err != nil {
-			t.Error(err)
-		}
-		if rply := safEv.AsMapStringIgnoreErrors(utils.StringMap{"test12": true}); !reflect.DeepEqual(expected, rply) {
-			t.Errorf("Expecting %+v, received: %+v", expected, rply)
-		}
-	})
+	for i := 0; i < 10; i++ {
+		t.Run("asMapStr", func(t *testing.T) {
+			t.Parallel()
+			safEv.AsMapStringIgnoreErrors(nil)
+		})
+		t.Run("set", func(t *testing.T) {
+			t.Parallel()
+			safEv.Set("test9", true)
+		})
+		t.Run("remove", func(t *testing.T) {
+			t.Parallel()
+			safEv.Remove("test9")
+		})
+	}
+	var expected map[string]string
+	if expected, err = safEv.Me.AsMapString(nil); err != nil {
+		t.Error(err)
+	}
+	if rply := safEv.AsMapStringIgnoreErrors(nil); !reflect.DeepEqual(expected, rply) {
+		t.Errorf("Expecting %+v, received: %+v", expected["test8"], rply["test8"])
+	}
+	delete(expected, "test1")
+	if rply := safEv.AsMapStringIgnoreErrors(utils.StringMap{"test1": true}); !reflect.DeepEqual(expected, rply) {
+		t.Errorf("Expecting %+v, received: %+v", expected, rply)
+	}
 }
 
 func TestSafEventAsCDR(t *testing.T) {