diff --git a/src/bunker.go b/src/bunker.go
index a562df6..a1e15aa 100644
--- a/src/bunker.go
+++ b/src/bunker.go
@@ -444,6 +444,7 @@ func setupDB(dbPtr *string, masterKeyPtr *string, customRootToken string) (*dbco
 		//log.Panic("error %s", err.Error())
 		fmt.Printf("error %s", err.Error())
 	}
+	log.Println("Creating default entities: core-send-email-on-login and core-send-sms-on-login");
 	db.createLegalBasis("core-send-email-on-login", "", "login", "Send email on login",
 	    "Confirm to allow sending access code using 3rd party email gateway", "consent",
 	    "This consent is required to give you our service.", "active", true, true);
diff --git a/src/bunker_test.go b/src/bunker_test.go
index c15b765..be068da 100644
--- a/src/bunker_test.go
+++ b/src/bunker_test.go
@@ -28,7 +28,7 @@ func helpServe0(request *http.Request) ([]byte, error) {
 	if rr.Code != 200 {
 		return rr.Body.Bytes(), fmt.Errorf("wrong status: %d", rr.Code)
 	}
-	//fmt.Printf("Got: %s\n", rr.Body.Bytes())
+	//fmt.Printf("Response: %s\n", rr.Body.Bytes())
 	return rr.Body.Bytes(), nil
 }
 
@@ -37,7 +37,7 @@ func helpServe(request *http.Request) (map[string]interface{}, error) {
 	rr := httptest.NewRecorder()
 	router.ServeHTTP(rr, request)
 	fmt.Printf("[%d] %s%s\n", rr.Code, request.Host, request.URL.Path)
-	fmt.Printf("Got: %s\n", rr.Body.Bytes())
+	fmt.Printf("Response: %s\n", rr.Body.Bytes())
 	var raw map[string]interface{}
 	if rr.Body.Bytes()[0] == '{' {
 		json.Unmarshal(rr.Body.Bytes(), &raw)
@@ -53,7 +53,7 @@ func helpServe2(request *http.Request) (map[string]interface{}, error) {
 	rr := httptest.NewRecorder()
 	router.ServeHTTP(rr, request)
 	fmt.Printf("[%d] %s%s\n", rr.Code, request.Host, request.URL.Path)
-	fmt.Printf("Got: %s\n", rr.Body.Bytes())
+	fmt.Printf("Response: %s\n", rr.Body.Bytes())
 	var raw map[string]interface{}
 	if rr.Body.Bytes()[0] == '{' {
 		json.Unmarshal(rr.Body.Bytes(), &raw)
diff --git a/src/storage/mysql-storage.go b/src/storage/mysql-storage.go
index 31cd479..d62a344 100644
--- a/src/storage/mysql-storage.go
+++ b/src/storage/mysql-storage.go
@@ -498,7 +498,6 @@ func (dbobj MySQLDB) getRecordInTableDo(q string, values []interface{}) (bson.M,
 	defer tx.Rollback()
 	rows, err := tx.Query(q, values...)
 	if err == sql.ErrNoRows {
-		fmt.Println("nothing found")
 		return nil, nil
 	} else if err != nil {
 		return nil, err
@@ -560,13 +559,11 @@ func (dbobj MySQLDB) getRecordInTableDo(q string, values []interface{}) (bson.M,
 	}
 	err = rows.Close()
 	if err == sql.ErrNoRows {
-		fmt.Println("nothing found2")
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	if len(recBson) == 0 {
-		fmt.Println("no result!!!")
 		return nil, nil
 	}
 	tx.Commit()
@@ -802,7 +799,6 @@ func (dbobj MySQLDB) getListDo(q string, values []interface{}) ([]bson.M, error)
 	defer tx.Rollback()
 	rows, err := tx.Query(q, values...)
 	if err == sql.ErrNoRows {
-		fmt.Println("nothing found")
 		return nil, nil
 	} else if err != nil {
 		return nil, err
@@ -830,7 +826,6 @@ func (dbobj MySQLDB) getListDo(q string, values []interface{}) ([]bson.M, error)
 
 		err = rows.Scan(columnPointers...)
 		if err == sql.ErrNoRows {
-			fmt.Println("nothing found")
 			return nil, nil
 		}
 		if err != nil {
@@ -857,13 +852,11 @@ func (dbobj MySQLDB) getListDo(q string, values []interface{}) ([]bson.M, error)
 	}
 	err = rows.Close()
 	if err == sql.ErrNoRows {
-		fmt.Println("nothing found2")
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	if len(results) == 0 {
-		fmt.Println("no result!!!")
 		return nil, nil
 	}
 	tx.Commit()
@@ -912,7 +905,7 @@ func (dbobj MySQLDB) execQueries(queries []string) error {
 func (dbobj MySQLDB) IndexNewApp(appName string) {
 	if contains(allTables, appName) == false {
 		// it is a new app, create an index
-		fmt.Printf("This is a new app, creating table & index for: %s\n", appName)
+		log.Printf("This is a new app, creating table & index for: %s\n", appName)
 		queries := []string{
 			`CREATE TABLE IF NOT EXISTS ` + appName + ` (`+
 			`token TINYTEXT,`+
diff --git a/src/storage/sqlite-storage.go b/src/storage/sqlite-storage.go
index e3a02de..07e8257 100644
--- a/src/storage/sqlite-storage.go
+++ b/src/storage/sqlite-storage.go
@@ -124,7 +124,7 @@ func (dbobj *SQLiteDB) OpenDB(filepath *string) error {
 		knownApps = append(knownApps, t)
 	}
 	tx.Commit()
-	fmt.Printf("tables: %s\n", knownApps)
+	log.Printf("List of tables: %s\n", knownApps)
 	return nil
 }
 
@@ -179,7 +179,7 @@ func (dbobj SQLiteDB) BackupDB(w http.ResponseWriter) {
 	err := sqlite3dump.DumpDB(dbobj.db, w)
 	if err != nil {
 		w.WriteHeader(http.StatusInternalServerError)
-		fmt.Printf("error in backup: %s", err)
+		log.Printf("error in backup: %s", err)
 	}
 }
 
@@ -231,7 +231,7 @@ func (dbobj SQLiteDB) decodeFieldsValues(data interface{}) (string, []interface{
 			values = append(values, val)
 		}
 	default:
-		fmt.Printf("XXXXXX wrong type: %T\n", t)
+		log.Printf("XXXXXX wrong type: %T\n", t)
 	}
 	return fields, values
 }
@@ -258,7 +258,7 @@ func (dbobj SQLiteDB) decodeForCleanup(data interface{}) string {
 			}
 		}
 	default:
-		fmt.Printf("decodeForCleanup: wrong type: %s\n", t)
+		log.Printf("decodeForCleanup: wrong type: %s\n", t)
 	}
 
 	return fields
@@ -313,7 +313,7 @@ func (dbobj SQLiteDB) CreateRecordInTable(tbl string, data interface{}) (int, er
 		}
 	}
 	q := "insert into " + tbl + " (" + fields + ") values (" + valuesInQ + ")"
-	fmt.Printf("q: %s\n", q)
+	//fmt.Printf("q: %s\n", q)
 	//fmt.Printf("values: %s\n", values...)
 	tx, err := dbobj.db.Begin()
 	if err != nil {
@@ -492,7 +492,7 @@ func (dbobj SQLiteDB) getRecordInTableDo(q string, values []interface{}) (bson.M
 	defer tx.Rollback()
 	rows, err := tx.Query(q, values...)
 	if err == sql.ErrNoRows {
-		fmt.Println("nothing found")
+		log.Println("nothing found")
 		return nil, nil
 	} else if err != nil {
 		return nil, err
@@ -520,12 +520,10 @@ func (dbobj SQLiteDB) getRecordInTableDo(q string, values []interface{}) (bson.M
 	}
 	err = rows.Scan(columnPointers...)
 	if err == sql.ErrNoRows {
-		fmt.Println("returning empty result")
 		return nil, nil
 	}
 	if err != nil {
 		if strings.Contains(err.Error(), "Rows are closed") {
-			fmt.Println("returning empty result")
 			return nil, nil
 		}
 		return nil, err
@@ -545,18 +543,16 @@ func (dbobj SQLiteDB) getRecordInTableDo(q string, values []interface{}) (bson.M
 		case nil:
 			//fmt.Printf("is nil, not interesting\n")
 		default:
-			fmt.Printf("field: %s - %s, unknown: %s - %T\n", colName, columns[i], t, t)
+			log.Printf("field: %s - %s, unknown: %s - %T\n", colName, columns[i], t, t)
 		}
 	}
 	err = rows.Close()
 	if err == sql.ErrNoRows {
-		fmt.Println("nothing found2")
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	if len(recBson) == 0 {
-		fmt.Println("no result!!!")
 		return nil, nil
 	}
 	tx.Commit()
@@ -572,7 +568,7 @@ func (dbobj SQLiteDB) DeleteRecord(t Tbl, keyName string, keyValue string) (int6
 // DeleteRecordInTable deletes record in database
 func (dbobj SQLiteDB) DeleteRecordInTable(table string, keyName string, keyValue string) (int64, error) {
 	q := "delete from " + table + " WHERE " + dbobj.escapeName(keyName) + "=$1"
-	fmt.Printf("q: %s\n", q)
+	log.Printf("q: %s\n", q)
 
 	tx, err := dbobj.db.Begin()
 	if err != nil {
@@ -599,7 +595,7 @@ func (dbobj SQLiteDB) DeleteRecord2(t Tbl, keyName string, keyValue string, keyN
 func (dbobj SQLiteDB) deleteRecordInTable2(table string, keyName string, keyValue string, keyName2 string, keyValue2 string) (int64, error) {
 	q := "delete from " + table + " WHERE " + dbobj.escapeName(keyName) + "=$1 AND " +
 		dbobj.escapeName(keyName2) + "=$2"
-	fmt.Printf("q: %s\n", q)
+	log.Printf("q: %s\n", q)
 
 	tx, err := dbobj.db.Begin()
 	if err != nil {
@@ -654,7 +650,7 @@ func (dbobj SQLiteDB) DeleteExpired0(t Tbl, expt int32) (int64, error) {
 	table := GetTable(t)
 	now := int32(time.Now().Unix())
 	q := fmt.Sprintf("delete from %s WHERE `when`>0 AND `when`<%d", table, now-expt)
-	fmt.Printf("q: %s\n", q)
+	log.Printf("q: %s\n", q)
 	tx, err := dbobj.db.Begin()
 	if err != nil {
 		return 0, err
@@ -677,7 +673,7 @@ func (dbobj SQLiteDB) DeleteExpired0(t Tbl, expt int32) (int64, error) {
 func (dbobj SQLiteDB) DeleteExpired(t Tbl, keyName string, keyValue string) (int64, error) {
 	table := GetTable(t)
 	q := "delete from " + table + " WHERE endtime>0 AND endtime<$1 AND " + dbobj.escapeName(keyName) + "=$2"
-	fmt.Printf("q: %s\n", q)
+	log.Printf("q: %s\n", q)
 
 	tx, err := dbobj.db.Begin()
 	if err != nil {
@@ -701,7 +697,7 @@ func (dbobj SQLiteDB) CleanupRecord(t Tbl, keyName string, keyValue string, data
 	tbl := GetTable(t)
 	cleanup := dbobj.decodeForCleanup(data)
 	q := "update " + tbl + " SET " + cleanup + " WHERE " + dbobj.escapeName(keyName) + "=$1"
-	fmt.Printf("q: %s\n", q)
+	log.Printf("q: %s\n", q)
 
 	tx, err := dbobj.db.Begin()
 	if err != nil {
@@ -725,7 +721,7 @@ func (dbobj SQLiteDB) GetExpiring(t Tbl, keyName string, keyValue string) ([]bso
 	now := int32(time.Now().Unix())
 	q := fmt.Sprintf("select * from %s WHERE endtime>0 AND endtime<%d AND %s=$1",
 			table, now, dbobj.escapeName(keyName))
-	fmt.Printf("q: %s\n", q)
+	//fmt.Printf("q: %s\n", q)
 	values := make([]interface{}, 0)
 	values = append(values, keyValue)
 	return dbobj.getListDo(q, values)
@@ -794,7 +790,7 @@ func (dbobj SQLiteDB) getListDo(q string, values []interface{}) ([]bson.M, error
 	defer tx.Rollback()
 	rows, err := tx.Query(q, values...)
 	if err == sql.ErrNoRows {
-		fmt.Println("nothing found")
+		log.Println("nothing found")
 		return nil, nil
 	} else if err != nil {
 		return nil, err
@@ -826,11 +822,9 @@ func (dbobj SQLiteDB) getListDo(q string, values []interface{}) ([]bson.M, error
 
 		err = rows.Scan(columnPointers...)
 		if err == sql.ErrNoRows {
-			fmt.Println("nothing found")
 			return nil, nil
 		}
 		if err != nil {
-			fmt.Printf("nothing found: %s\n", err)
 			return nil, nil
 		}
 		for i, colName := range columnNames {
@@ -846,20 +840,18 @@ func (dbobj SQLiteDB) getListDo(q string, values []interface{}) ([]bson.M, error
 			case nil:
 				//fmt.Printf("is nil, not interesting\n")
 			default:
-				fmt.Printf("field: %s - %s, unknown: %s - %T\n", colName, columns[i], t, t)
+				log.Printf("field: %s - %s, unknown: %s - %T\n", colName, columns[i], t, t)
 			}
 		}
 		results = append(results, recBson)
 	}
 	err = rows.Close()
 	if err == sql.ErrNoRows {
-		fmt.Println("nothing found2")
 		return nil, nil
 	} else if err != nil {
 		return nil, err
 	}
 	if len(results) == 0 {
-		fmt.Println("no result!!!")
 		return nil, nil
 	}
 	tx.Commit()
@@ -904,7 +896,7 @@ func (dbobj SQLiteDB) execQueries(queries []string) error {
 func (dbobj SQLiteDB) IndexNewApp(appName string) {
 	if contains(knownApps, appName) == false {
 		// it is a new app, create an index
-		fmt.Printf("This is a new app, creating table & index for: %s\n", appName)
+		log.Printf("This is a new app, creating table & index for: %s\n", appName)
 		queries := []string{"CREATE TABLE IF NOT EXISTS " + appName + ` (
 			token STRING,
 			md5 STRING,
diff --git a/src/userapps_db.go b/src/userapps_db.go
index 0335ad0..fa590c4 100644
--- a/src/userapps_db.go
+++ b/src/userapps_db.go
@@ -5,7 +5,7 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"errors"
-	"fmt"
+	"log"
 	"strings"
 
 	jsonpatch "github.com/evanphx/json-patch"
@@ -31,7 +31,7 @@ func (dbobj dbcon) deleteUserApp(userTOKEN string, appName string) {
 }
 
 func (dbobj dbcon) createAppRecord(jsonData []byte, userTOKEN string, appName string, event *auditEvent) (string, error) {
-	fmt.Printf("createAppRecord app is : %s\n", appName)
+	log.Printf("Going to create app record: %s\n", appName)
 	encodedStr, err := dbobj.userEncrypt(userTOKEN, jsonData)
 	if err != nil {
 		return userTOKEN, err
@@ -94,15 +94,14 @@ func (dbobj dbcon) updateAppRecord(jsonDataPatch []byte, userTOKEN string, appNa
 	if err != nil {
 		return userTOKEN, err
 	}
-
 	// merge
-	fmt.Printf("old json: %s\n", decrypted)
-	fmt.Printf("json patch: %s\n", jsonDataPatch)
+	//fmt.Printf("old json: %s\n", decrypted)
+	//fmt.Printf("json patch: %s\n", jsonDataPatch)
 	newJSON, err := jsonpatch.MergePatch(decrypted, jsonDataPatch)
 	if err != nil {
 		return userTOKEN, err
 	}
-	fmt.Printf("result: %s\n", newJSON)
+	//fmt.Printf("result: %s\n", newJSON)
 	bdoc := bson.M{}
 	encoded, err := encrypt(dbobj.masterKey, recordKey, newJSON)
 	if err != nil {
@@ -117,7 +116,6 @@ func (dbobj dbcon) updateAppRecord(jsonDataPatch []byte, userTOKEN string, appNa
 
 	// here I add md5 of the original record to filter
 	// to make sure this record was not change by other thread
-	fmt.Println("update user app")
 	result, err := dbobj.store.UpdateRecordInTable2("app_"+appName, "token", userTOKEN, "md5", sig, &bdoc, nil)
 	if err != nil {
 		return userTOKEN, err
@@ -159,7 +157,6 @@ func (dbobj dbcon) listUserApps(userTOKEN string) ([]byte, error) {
 			}
 		}
 	}
-	fmt.Printf("returning: %s\n", result)
 	if len(result) == 0 {
 		return []byte("[]"), nil
 	}
diff --git a/src/utils.go b/src/utils.go
index 1676a6b..47451b9 100644
--- a/src/utils.go
+++ b/src/utils.go
@@ -341,9 +341,9 @@ func returnError(w http.ResponseWriter, r *http.Request, message string, code in
 		event.Msg = message
 		if err != nil {
 			event.Debug = err.Error()
-			fmt.Printf("Msg: %s, Error: %s\n", message, err.Error())
+			log.Printf("Generate error reponse: %s, Error: %s\n", message, err.Error())
 		} else {
-			fmt.Printf("Msg: %s\n", message)
+			log.Printf("Generate error reponse: %s\n", message)
 		}
 	}
 	//http.Error(w, http.StatusText(405), 405)
diff --git a/src/xtokens_db.go b/src/xtokens_db.go
index 03a7d5b..8f90870 100644
--- a/src/xtokens_db.go
+++ b/src/xtokens_db.go
@@ -2,7 +2,6 @@ package main
 
 import (
 	"errors"
-	"fmt"
 	"time"
 
 	uuid "github.com/hashicorp/go-uuid"
@@ -79,7 +78,7 @@ func (dbobj dbcon) checkUserAuthXToken(xtokenUUID string) (tokenAuthResult, erro
 	}
 	xtokenHashed := hashString(dbobj.hash, xtokenUUID)
 	if len(rootXTOKEN) > 0 && rootXTOKEN == xtokenHashed {
-		//fmt.Println("It is a root token")
+		//log.Println("It is a root token")
 		result.ttype = "root"
 		result.name = "root"
 		return result, nil
@@ -89,7 +88,7 @@ func (dbobj dbcon) checkUserAuthXToken(xtokenUUID string) (tokenAuthResult, erro
 		return result, errors.New("failed to authenticate")
 	}
 	tokenType := record["type"].(string)
-	fmt.Printf("xtoken type: %s\n", tokenType)
+	//log.Printf("xtoken type: %s\n", tokenType)
 	if tokenType == "root" {
 		// we have this admin user
 		rootXTOKEN = xtokenHashed