diff --git a/cmd/cgr-console/cgr-console.go b/cmd/cgr-console/cgr-console.go
index 81c1e3aad..36fdf70fd 100644
--- a/cmd/cgr-console/cgr-console.go
+++ b/cmd/cgr-console/cgr-console.go
@@ -36,15 +36,16 @@ import (
 )
 
 var (
+	cgrConsoleFlags = flag.NewFlagSet("cgr-console", flag.ContinueOnError)
 	historyFN       = os.Getenv("HOME") + "/.cgr_history"
-	version         = flag.Bool("version", false, "Prints the application version.")
-	verbose         = flag.Bool("verbose", false, "Show extra info about command execution.")
-	server          = flag.String("server", "127.0.0.1:2012", "server address host:port")
-	rpcEncoding     = flag.String("rpc_encoding", "*json", "RPC encoding used <*gob|*json>")
-	certificatePath = flag.String("crt_path", "", "path to certificate for tls connection")
-	keyPath         = flag.String("key_path", "", "path to key for tls connection")
-	caPath          = flag.String("ca_path", "", "path to CA for tls connection(only for self sign certificate)")
-	tls             = flag.Bool("tls", false, "Tls connection")
+	version         = cgrConsoleFlags.Bool("version", false, "Prints the application version.")
+	verbose         = cgrConsoleFlags.Bool("verbose", false, "Show extra info about command execution.")
+	server          = cgrConsoleFlags.String("server", "127.0.0.1:2012", "server address host:port")
+	rpcEncoding     = cgrConsoleFlags.String("rpc_encoding", "*json", "RPC encoding used <*gob|*json>")
+	certificatePath = cgrConsoleFlags.String("crt_path", "", "path to certificate for tls connection")
+	keyPath         = cgrConsoleFlags.String("key_path", "", "path to key for tls connection")
+	caPath          = cgrConsoleFlags.String("ca_path", "", "path to CA for tls connection(only for self sign certificate)")
+	tls             = cgrConsoleFlags.Bool("tls", false, "Tls connection")
 	client          *rpcclient.RpcClient
 )
 
@@ -117,7 +118,9 @@ func executeCommand(command string) {
 }
 
 func main() {
-	flag.Parse()
+	if err := cgrConsoleFlags.Parse(os.Args[1:]); err != nil {
+		return
+	}
 	if *version {
 		fmt.Println(utils.GetCGRVersion())
 		return
diff --git a/cmd/cgr-engine/cgr-engine.go b/cmd/cgr-engine/cgr-engine.go
index 8626ca8e1..f220bc0de 100644
--- a/cmd/cgr-engine/cgr-engine.go
+++ b/cmd/cgr-engine/cgr-engine.go
@@ -61,19 +61,20 @@ const (
 )
 
 var (
-	cfgPath           = flag.String("config_path", utils.CONFIG_PATH, "Configuration directory path.")
-	version           = flag.Bool("version", false, "Prints the application version.")
-	pidFile           = flag.String("pid", "", "Write pid file")
-	httpPprofPath     = flag.String("httprof_path", "", "http address used for program profiling")
-	cpuProfDir        = flag.String("cpuprof_dir", "", "write cpu profile to files")
-	memProfDir        = flag.String("memprof_dir", "", "write memory profile to file")
-	memProfInterval   = flag.Duration("memprof_interval", 5*time.Second, "Time betwen memory profile saves")
-	memProfNrFiles    = flag.Int("memprof_nrfiles", 1, "Number of memory profile to write")
-	scheduledShutdown = flag.String("scheduled_shutdown", "", "shutdown the engine after this duration")
-	singlecpu         = flag.Bool("singlecpu", false, "Run on single CPU core")
-	syslogger         = flag.String("logger", "", "logger <*syslog|*stdout>")
-	nodeID            = flag.String("node_id", "", "The node ID of the engine")
-	logLevel          = flag.Int("log_level", -1, "Log level (0-emergency to 7-debug)")
+	cgrEngineFlags    = flag.NewFlagSet("cgr-engine", flag.ContinueOnError)
+	cfgPath           = cgrEngineFlags.String("config_path", utils.CONFIG_PATH, "Configuration directory path.")
+	version           = cgrEngineFlags.Bool("version", false, "Prints the application version.")
+	pidFile           = cgrEngineFlags.String("pid", "", "Write pid file")
+	httpPprofPath     = cgrEngineFlags.String("httprof_path", "", "http address used for program profiling")
+	cpuProfDir        = cgrEngineFlags.String("cpuprof_dir", "", "write cpu profile to files")
+	memProfDir        = cgrEngineFlags.String("memprof_dir", "", "write memory profile to file")
+	memProfInterval   = cgrEngineFlags.Duration("memprof_interval", 5*time.Second, "Time betwen memory profile saves")
+	memProfNrFiles    = cgrEngineFlags.Int("memprof_nrfiles", 1, "Number of memory profile to write")
+	scheduledShutdown = cgrEngineFlags.String("scheduled_shutdown", "", "shutdown the engine after this duration")
+	singlecpu         = cgrEngineFlags.Bool("singlecpu", false, "Run on single CPU core")
+	syslogger         = cgrEngineFlags.String("logger", "", "logger <*syslog|*stdout>")
+	nodeID            = cgrEngineFlags.String("node_id", "", "The node ID of the engine")
+	logLevel          = cgrEngineFlags.Int("log_level", -1, "Log level (0-emergency to 7-debug)")
 
 	cfg *config.CGRConfig
 )
@@ -1209,7 +1210,9 @@ func shutdownSingnalHandler(exitChan chan bool) {
 }
 
 func main() {
-	flag.Parse()
+	if err := cgrEngineFlags.Parse(os.Args[1:]); err != nil {
+		return
+	}
 	vers := utils.GetCGRVersion()
 	if *version {
 		fmt.Println(vers)
diff --git a/cmd/cgr-loader/cgr-loader.go b/cmd/cgr-loader/cgr-loader.go
index 49642e733..60560e888 100755
--- a/cmd/cgr-loader/cgr-loader.go
+++ b/cmd/cgr-loader/cgr-loader.go
@@ -22,6 +22,7 @@ import (
 	"flag"
 	"fmt"
 	"log"
+	"os"
 	"path"
 	"strings"
 	"time"
@@ -33,67 +34,68 @@ import (
 )
 
 var (
-	dfltCfg = config.CgrConfig()
-	cfgPath = flag.String("config_path", "",
+	cgrLoaderFlags = flag.NewFlagSet("cgr-loader", flag.ContinueOnError)
+	dfltCfg        = config.CgrConfig()
+	cfgPath        = cgrLoaderFlags.String("config_path", "",
 		"Configuration directory path.")
 
-	dataDBType = flag.String("datadb_type", dfltCfg.DataDbCfg().DataDbType,
+	dataDBType = cgrLoaderFlags.String("datadb_type", dfltCfg.DataDbCfg().DataDbType,
 		"The type of the DataDB database <*redis|*mongo>")
-	dataDBHost = flag.String("datadb_host", dfltCfg.DataDbCfg().DataDbHost,
+	dataDBHost = cgrLoaderFlags.String("datadb_host", dfltCfg.DataDbCfg().DataDbHost,
 		"The DataDb host to connect to.")
-	dataDBPort = flag.String("datadb_port", dfltCfg.DataDbCfg().DataDbPort,
+	dataDBPort = cgrLoaderFlags.String("datadb_port", dfltCfg.DataDbCfg().DataDbPort,
 		"The DataDb port to bind to.")
-	dataDBName = flag.String("datadb_name", dfltCfg.DataDbCfg().DataDbName,
+	dataDBName = cgrLoaderFlags.String("datadb_name", dfltCfg.DataDbCfg().DataDbName,
 		"The name/number of the DataDb to connect to.")
-	dataDBUser = flag.String("datadb_user", dfltCfg.DataDbCfg().DataDbUser,
+	dataDBUser = cgrLoaderFlags.String("datadb_user", dfltCfg.DataDbCfg().DataDbUser,
 		"The DataDb user to sign in as.")
-	dataDBPasswd = flag.String("datadb_passwd", dfltCfg.DataDbCfg().DataDbPass,
+	dataDBPasswd = cgrLoaderFlags.String("datadb_passwd", dfltCfg.DataDbCfg().DataDbPass,
 		"The DataDb user's password.")
-	dbDataEncoding = flag.String("dbdata_encoding", dfltCfg.GeneralCfg().DBDataEncoding,
+	dbDataEncoding = cgrLoaderFlags.String("dbdata_encoding", dfltCfg.GeneralCfg().DBDataEncoding,
 		"The encoding used to store object data in strings")
-	dbRedisSentinel = flag.String("redis_sentinel", dfltCfg.DataDbCfg().DataDbSentinelName,
+	dbRedisSentinel = cgrLoaderFlags.String("redis_sentinel", dfltCfg.DataDbCfg().DataDbSentinelName,
 		"The name of redis sentinel")
 
-	storDBType = flag.String("stordb_type", dfltCfg.StorDbCfg().StorDBType,
+	storDBType = cgrLoaderFlags.String("stordb_type", dfltCfg.StorDbCfg().StorDBType,
 		"The type of the storDb database <*mysql|*postgres|*mongo>")
-	storDBHost = flag.String("stordb_host", dfltCfg.StorDbCfg().StorDBHost,
+	storDBHost = cgrLoaderFlags.String("stordb_host", dfltCfg.StorDbCfg().StorDBHost,
 		"The storDb host to connect to.")
-	storDBPort = flag.String("stordb_port", dfltCfg.StorDbCfg().StorDBPort,
+	storDBPort = cgrLoaderFlags.String("stordb_port", dfltCfg.StorDbCfg().StorDBPort,
 		"The storDb port to bind to.")
-	storDBName = flag.String("stordb_name", dfltCfg.StorDbCfg().StorDBName,
+	storDBName = cgrLoaderFlags.String("stordb_name", dfltCfg.StorDbCfg().StorDBName,
 		"The name/number of the storDb to connect to.")
-	storDBUser = flag.String("stordb_user", dfltCfg.StorDbCfg().StorDBUser,
+	storDBUser = cgrLoaderFlags.String("stordb_user", dfltCfg.StorDbCfg().StorDBUser,
 		"The storDb user to sign in as.")
-	storDBPasswd = flag.String("stordb_passwd", dfltCfg.StorDbCfg().StorDBPass,
+	storDBPasswd = cgrLoaderFlags.String("stordb_passwd", dfltCfg.StorDbCfg().StorDBPass,
 		"The storDb user's password.")
 
-	flush = flag.Bool("flushdb", false,
+	flush = cgrLoaderFlags.Bool("flushdb", false,
 		"Flush the database before importing")
-	tpid = flag.String("tpid", dfltCfg.LoaderCgrCfg().TpID,
+	tpid = cgrLoaderFlags.String("tpid", dfltCfg.LoaderCgrCfg().TpID,
 		"The tariff plan ID from the database")
-	dataPath = flag.String("path", dfltCfg.LoaderCgrCfg().DataPath,
+	dataPath = cgrLoaderFlags.String("path", dfltCfg.LoaderCgrCfg().DataPath,
 		"The path to folder containing the data files")
-	version = flag.Bool("version", false,
+	version = cgrLoaderFlags.Bool("version", false,
 		"Prints the application version.")
-	verbose = flag.Bool("verbose", false,
+	verbose = cgrLoaderFlags.Bool("verbose", false,
 		"Enable detailed verbose logging output")
-	dryRun = flag.Bool("dry_run", false,
+	dryRun = cgrLoaderFlags.Bool("dry_run", false,
 		"When true will not save loaded data to dataDb but just parse it for consistency and errors.")
-	fieldSep = flag.String("field_sep", ",",
+	fieldSep = cgrLoaderFlags.String("field_sep", ",",
 		`Separator for csv file (by default "," is used)`)
 
-	fromStorDB    = flag.Bool("from_stordb", false, "Load the tariff plan from storDb to dataDb")
-	toStorDB      = flag.Bool("to_stordb", false, "Import the tariff plan from files to storDb")
-	rpcEncoding   = flag.String("rpc_encoding", utils.MetaJSONrpc, "RPC encoding used <*gob|*json>")
-	cacheSAddress = flag.String("caches_address", dfltCfg.LoaderCgrCfg().CachesConns[0].Address,
+	fromStorDB    = cgrLoaderFlags.Bool("from_stordb", false, "Load the tariff plan from storDb to dataDb")
+	toStorDB      = cgrLoaderFlags.Bool("to_stordb", false, "Import the tariff plan from files to storDb")
+	rpcEncoding   = cgrLoaderFlags.String("rpc_encoding", utils.MetaJSONrpc, "RPC encoding used <*gob|*json>")
+	cacheSAddress = cgrLoaderFlags.String("caches_address", dfltCfg.LoaderCgrCfg().CachesConns[0].Address,
 		"CacheS component to contact for cache reloads, empty to disable automatic cache reloads")
-	schedulerAddress = flag.String("scheduler_address", dfltCfg.LoaderCgrCfg().SchedulerConns[0].Address, "")
+	schedulerAddress = cgrLoaderFlags.String("scheduler_address", dfltCfg.LoaderCgrCfg().SchedulerConns[0].Address, "")
 
-	importID       = flag.String("import_id", "", "Uniquely identify an import/load, postpended to some automatic fields")
-	timezone       = flag.String("timezone", "", `Timezone for timestamps where not specified <""|UTC|Local|$IANA_TZ_DB>`)
-	disableReverse = flag.Bool("disable_reverse_mappings", false, "Will disable reverse mappings rebuilding")
-	flushStorDB    = flag.Bool("flush_stordb", false, "Remove tariff plan data for id from the database")
-	remove         = flag.Bool("remove", false, "Will remove instead of adding data from DB")
+	importID       = cgrLoaderFlags.String("import_id", "", "Uniquely identify an import/load, postpended to some automatic fields")
+	timezone       = cgrLoaderFlags.String("timezone", "", `Timezone for timestamps where not specified <""|UTC|Local|$IANA_TZ_DB>`)
+	disableReverse = cgrLoaderFlags.Bool("disable_reverse_mappings", false, "Will disable reverse mappings rebuilding")
+	flushStorDB    = cgrLoaderFlags.Bool("flush_stordb", false, "Remove tariff plan data for id from the database")
+	remove         = cgrLoaderFlags.Bool("remove", false, "Will remove instead of adding data from DB")
 
 	err    error
 	dm     *engine.DataManager
@@ -103,7 +105,9 @@ var (
 )
 
 func main() {
-	flag.Parse()
+	if err := cgrLoaderFlags.Parse(os.Args[1:]); err != nil {
+		return
+	}
 	if *version {
 		fmt.Println(utils.GetCGRVersion())
 		return
diff --git a/cmd/cgr-migrator/cgr-migrator.go b/cmd/cgr-migrator/cgr-migrator.go
index 000ebbffe..4e6ee0fc0 100755
--- a/cmd/cgr-migrator/cgr-migrator.go
+++ b/cmd/cgr-migrator/cgr-migrator.go
@@ -22,6 +22,7 @@ import (
 	"flag"
 	"fmt"
 	"log"
+	"os"
 	"strings"
 
 	"github.com/cgrates/cgrates/config"
@@ -30,85 +31,89 @@ import (
 )
 
 var (
+	cgrMigratorFlags = flag.NewFlagSet("cgr-migrator", flag.ContinueOnError)
+
 	sameDataDB, sameStorDB bool
 	dmIN, dmOUT            migrator.MigratorDataDB
 	storDBIn, storDBOut    migrator.MigratorStorDB
 	err                    error
 	dfltCfg, _             = config.NewDefaultCGRConfig()
-	cfgDir                 = flag.String("config_dir", "",
+	cfgDir                 = cgrMigratorFlags.String("config_dir", "",
 		"Configuration directory path.")
 
-	migrate = flag.String("migrate", "", "fire up automatic migration "+
+	migrate = cgrMigratorFlags.String("migrate", "", "fire up automatic migration "+
 		"\n <*set_versions|*cost_details|*accounts|*actions|*action_triggers|*action_plans|*shared_groups|*stordb|*datadb>")
-	version = flag.Bool("version", false, "prints the application version")
+	version = cgrMigratorFlags.Bool("version", false, "prints the application version")
 
-	inDataDBType = flag.String("datadb_type", dfltCfg.DataDbCfg().DataDbType,
+	inDataDBType = cgrMigratorFlags.String("datadb_type", dfltCfg.DataDbCfg().DataDbType,
 		"the type of the DataDB Database <*redis|*mongo>")
-	inDataDBHost = flag.String("datadb_host", dfltCfg.DataDbCfg().DataDbHost,
+	inDataDBHost = cgrMigratorFlags.String("datadb_host", dfltCfg.DataDbCfg().DataDbHost,
 		"the DataDB host")
-	inDataDBPort = flag.String("datadb_port", dfltCfg.DataDbCfg().DataDbPort,
+	inDataDBPort = cgrMigratorFlags.String("datadb_port", dfltCfg.DataDbCfg().DataDbPort,
 		"the DataDB port")
-	inDataDBName = flag.String("datadb_name", dfltCfg.DataDbCfg().DataDbName,
+	inDataDBName = cgrMigratorFlags.String("datadb_name", dfltCfg.DataDbCfg().DataDbName,
 		"the name/number of the DataDB")
-	inDataDBUser = flag.String("datadb_user", dfltCfg.DataDbCfg().DataDbUser,
+	inDataDBUser = cgrMigratorFlags.String("datadb_user", dfltCfg.DataDbCfg().DataDbUser,
 		"the DataDB user")
-	inDataDBPass = flag.String("datadb_passwd", dfltCfg.DataDbCfg().DataDbPass,
+	inDataDBPass = cgrMigratorFlags.String("datadb_passwd", dfltCfg.DataDbCfg().DataDbPass,
 		"the DataDB password")
-	inDBDataEncoding = flag.String("dbdata_encoding", dfltCfg.GeneralCfg().DBDataEncoding,
+	inDBDataEncoding = cgrMigratorFlags.String("dbdata_encoding", dfltCfg.GeneralCfg().DBDataEncoding,
 		"the encoding used to store object Data in strings")
-	inDataDBRedisSentinel = flag.String("redis_sentinel", dfltCfg.DataDbCfg().DataDbSentinelName,
+	inDataDBRedisSentinel = cgrMigratorFlags.String("redis_sentinel", dfltCfg.DataDbCfg().DataDbSentinelName,
 		"the name of redis sentinel")
 
-	outDataDBType = flag.String("out_datadb_type", utils.MetaDataDB,
+	outDataDBType = cgrMigratorFlags.String("out_datadb_type", utils.MetaDataDB,
 		"output DataDB type <*redis|*mongo>")
-	outDataDBHost = flag.String("out_datadb_host", utils.MetaDataDB,
+	outDataDBHost = cgrMigratorFlags.String("out_datadb_host", utils.MetaDataDB,
 		"output DataDB host to connect to")
-	outDataDBPort = flag.String("out_datadb_port", utils.MetaDataDB,
+	outDataDBPort = cgrMigratorFlags.String("out_datadb_port", utils.MetaDataDB,
 		"output DataDB port")
-	outDataDBName = flag.String("out_datadb_name", utils.MetaDataDB,
+	outDataDBName = cgrMigratorFlags.String("out_datadb_name", utils.MetaDataDB,
 		"output DataDB name/number")
-	outDataDBUser = flag.String("out_datadb_user", utils.MetaDataDB,
+	outDataDBUser = cgrMigratorFlags.String("out_datadb_user", utils.MetaDataDB,
 		"output DataDB user")
-	outDataDBPass = flag.String("out_datadb_passwd", utils.MetaDataDB,
+	outDataDBPass = cgrMigratorFlags.String("out_datadb_passwd", utils.MetaDataDB,
 		"output DataDB password")
-	outDBDataEncoding = flag.String("out_dbdata_encoding", utils.MetaDataDB,
+	outDBDataEncoding = cgrMigratorFlags.String("out_dbdata_encoding", utils.MetaDataDB,
 		"the encoding used to store object Data in strings in move mode")
-	outDataDBRedisSentinel = flag.String("out_redis_sentinel", utils.MetaDataDB,
+	outDataDBRedisSentinel = cgrMigratorFlags.String("out_redis_sentinel", utils.MetaDataDB,
 		"the name of redis sentinel")
 
-	inStorDBType = flag.String("stordb_type", dfltCfg.StorDbCfg().StorDBType,
+	inStorDBType = cgrMigratorFlags.String("stordb_type", dfltCfg.StorDbCfg().StorDBType,
 		"the type of the StorDB Database <*mysql|*postgres|*mongo>")
-	inStorDBHost = flag.String("stordb_host", dfltCfg.StorDbCfg().StorDBHost,
+	inStorDBHost = cgrMigratorFlags.String("stordb_host", dfltCfg.StorDbCfg().StorDBHost,
 		"the StorDB host")
-	inStorDBPort = flag.String("stordb_port", dfltCfg.StorDbCfg().StorDBPort,
+	inStorDBPort = cgrMigratorFlags.String("stordb_port", dfltCfg.StorDbCfg().StorDBPort,
 		"the StorDB port")
-	inStorDBName = flag.String("stordb_name", dfltCfg.StorDbCfg().StorDBName,
+	inStorDBName = cgrMigratorFlags.String("stordb_name", dfltCfg.StorDbCfg().StorDBName,
 		"the name/number of the StorDB")
-	inStorDBUser = flag.String("stordb_user", dfltCfg.StorDbCfg().StorDBUser,
+	inStorDBUser = cgrMigratorFlags.String("stordb_user", dfltCfg.StorDbCfg().StorDBUser,
 		"the StorDB user")
-	inStorDBPass = flag.String("stordb_passwd", dfltCfg.StorDbCfg().StorDBPass,
+	inStorDBPass = cgrMigratorFlags.String("stordb_passwd", dfltCfg.StorDbCfg().StorDBPass,
 		"the StorDB password")
 
-	outStorDBType = flag.String("out_stordb_type", utils.MetaStorDB,
+	outStorDBType = cgrMigratorFlags.String("out_stordb_type", utils.MetaStorDB,
 		"output StorDB type for move mode <*mysql|*postgres|*mongo>")
-	outStorDBHost = flag.String("out_stordb_host", utils.MetaStorDB,
+	outStorDBHost = cgrMigratorFlags.String("out_stordb_host", utils.MetaStorDB,
 		"output StorDB host")
-	outStorDBPort = flag.String("out_stordb_port", utils.MetaStorDB,
+	outStorDBPort = cgrMigratorFlags.String("out_stordb_port", utils.MetaStorDB,
 		"output StorDB port")
-	outStorDBName = flag.String("out_stordb_name", utils.MetaStorDB,
+	outStorDBName = cgrMigratorFlags.String("out_stordb_name", utils.MetaStorDB,
 		"output StorDB name/number")
-	outStorDBUser = flag.String("out_stordb_user", utils.MetaStorDB,
+	outStorDBUser = cgrMigratorFlags.String("out_stordb_user", utils.MetaStorDB,
 		"output StorDB user")
-	outStorDBPass = flag.String("out_stordb_passwd", utils.MetaStorDB,
+	outStorDBPass = cgrMigratorFlags.String("out_stordb_passwd", utils.MetaStorDB,
 		"output StorDB password")
 
-	dryRun = flag.Bool("dry_run", false,
+	dryRun = cgrMigratorFlags.Bool("dry_run", false,
 		"parse loaded data for consistency and errors, without storing it")
-	verbose = flag.Bool("verbose", false, "enable detailed verbose logging output")
+	verbose = cgrMigratorFlags.Bool("verbose", false, "enable detailed verbose logging output")
 )
 
 func main() {
-	flag.Parse()
+	if err := cgrMigratorFlags.Parse(os.Args[1:]); err != nil {
+		return
+	}
 	if *version {
 		fmt.Println(utils.GetCGRVersion())
 		return
diff --git a/cmd/cgr-tester/cgr-tester.go b/cmd/cgr-tester/cgr-tester.go
index e10fe85a4..1991b6458 100644
--- a/cmd/cgr-tester/cgr-tester.go
+++ b/cmd/cgr-tester/cgr-tester.go
@@ -35,36 +35,37 @@ import (
 )
 
 var (
-	cgrConfig, _ = config.NewDefaultCGRConfig()
-	tstCfg       = config.CgrConfig()
-	cpuprofile   = flag.String("cpuprofile", "", "write cpu profile to file")
-	memprofile   = flag.String("memprofile", "", "write memory profile to this file")
-	runs         = flag.Int("runs", 10000, "stress cycle number")
+	cgrTesterFlags = flag.NewFlagSet("cgr-tester", flag.ContinueOnError)
+	cgrConfig, _   = config.NewDefaultCGRConfig()
+	tstCfg         = config.CgrConfig()
+	cpuprofile     = cgrTesterFlags.String("cpuprofile", "", "write cpu profile to file")
+	memprofile     = cgrTesterFlags.String("memprofile", "", "write memory profile to this file")
+	runs           = cgrTesterFlags.Int("runs", 10000, "stress cycle number")
 
-	cfgPath = flag.String("config_path", "",
+	cfgPath = cgrTesterFlags.String("config_path", "",
 		"Configuration directory path.")
 
-	parallel        = flag.Int("parallel", 0, "run n requests in parallel")
-	datadb_type     = flag.String("datadb_type", cgrConfig.DataDbCfg().DataDbType, "The type of the DataDb database <redis>")
-	datadb_host     = flag.String("datadb_host", cgrConfig.DataDbCfg().DataDbHost, "The DataDb host to connect to.")
-	datadb_port     = flag.String("datadb_port", cgrConfig.DataDbCfg().DataDbPort, "The DataDb port to bind to.")
-	datadb_name     = flag.String("datadb_name", cgrConfig.DataDbCfg().DataDbName, "The name/number of the DataDb to connect to.")
-	datadb_user     = flag.String("datadb_user", cgrConfig.DataDbCfg().DataDbUser, "The DataDb user to sign in as.")
-	datadb_pass     = flag.String("datadb_pass", cgrConfig.DataDbCfg().DataDbPass, "The DataDb user's password.")
-	dbdata_encoding = flag.String("dbdata_encoding", cgrConfig.GeneralCfg().DBDataEncoding, "The encoding used to store object data in strings.")
-	redis_sentinel  = flag.String("redis_sentinel", cgrConfig.DataDbCfg().DataDbSentinelName, "The name of redis sentinel")
-	raterAddress    = flag.String("rater_address", "", "Rater address for remote tests. Empty for internal rater.")
-	tor             = flag.String("tor", utils.VOICE, "The type of record to use in queries.")
-	category        = flag.String("category", "call", "The Record category to test.")
-	tenant          = flag.String("tenant", "cgrates.org", "The type of record to use in queries.")
-	subject         = flag.String("subject", "1001", "The rating subject to use in queries.")
-	destination     = flag.String("destination", "1002", "The destination to use in queries.")
-	json            = flag.Bool("json", false, "Use JSON RPC")
-	version         = flag.Bool("version", false, "Prints the application version.")
+	parallel        = cgrTesterFlags.Int("parallel", 0, "run n requests in parallel")
+	datadb_type     = cgrTesterFlags.String("datadb_type", cgrConfig.DataDbCfg().DataDbType, "The type of the DataDb database <redis>")
+	datadb_host     = cgrTesterFlags.String("datadb_host", cgrConfig.DataDbCfg().DataDbHost, "The DataDb host to connect to.")
+	datadb_port     = cgrTesterFlags.String("datadb_port", cgrConfig.DataDbCfg().DataDbPort, "The DataDb port to bind to.")
+	datadb_name     = cgrTesterFlags.String("datadb_name", cgrConfig.DataDbCfg().DataDbName, "The name/number of the DataDb to connect to.")
+	datadb_user     = cgrTesterFlags.String("datadb_user", cgrConfig.DataDbCfg().DataDbUser, "The DataDb user to sign in as.")
+	datadb_pass     = cgrTesterFlags.String("datadb_pass", cgrConfig.DataDbCfg().DataDbPass, "The DataDb user's password.")
+	dbdata_encoding = cgrTesterFlags.String("dbdata_encoding", cgrConfig.GeneralCfg().DBDataEncoding, "The encoding used to store object data in strings.")
+	redis_sentinel  = cgrTesterFlags.String("redis_sentinel", cgrConfig.DataDbCfg().DataDbSentinelName, "The name of redis sentinel")
+	raterAddress    = cgrTesterFlags.String("rater_address", "", "Rater address for remote tests. Empty for internal rater.")
+	tor             = cgrTesterFlags.String("tor", utils.VOICE, "The type of record to use in queries.")
+	category        = cgrTesterFlags.String("category", "call", "The Record category to test.")
+	tenant          = cgrTesterFlags.String("tenant", "cgrates.org", "The type of record to use in queries.")
+	subject         = cgrTesterFlags.String("subject", "1001", "The rating subject to use in queries.")
+	destination     = cgrTesterFlags.String("destination", "1002", "The destination to use in queries.")
+	json            = cgrTesterFlags.Bool("json", false, "Use JSON RPC")
+	version         = cgrTesterFlags.Bool("version", false, "Prints the application version.")
 	nilDuration     = time.Duration(0)
-	usage           = flag.String("usage", "1m", "The duration to use in call simulation.")
-	fPath           = flag.String("file_path", "", "read requests from file with path")
-	reqSep          = flag.String("req_separator", "\n\n", "separator for requests in file")
+	usage           = cgrTesterFlags.String("usage", "1m", "The duration to use in call simulation.")
+	fPath           = cgrTesterFlags.String("file_path", "", "read requests from file with path")
+	reqSep          = cgrTesterFlags.String("req_separator", "\n\n", "separator for requests in file")
 
 	err error
 )
@@ -154,7 +155,9 @@ func durRemoteRater(cd *engine.CallDescriptor) (time.Duration, error) {
 }
 
 func main() {
-	flag.Parse()
+	if err := cgrTesterFlags.Parse(os.Args[1:]); err != nil {
+		return
+	}
 	if *version {
 		fmt.Println(utils.GetCGRVersion())
 		return