diff --git a/rw_core/config/config.go b/rw_core/config/config.go
index 68dca2c..5ba2f3c 100644
--- a/rw_core/config/config.go
+++ b/rw_core/config/config.go
@@ -13,52 +13,55 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package config
 
 import (
 	"flag"
 	"fmt"
-	"github.com/opencord/voltha-lib-go/v2/pkg/log"
+
 	"time"
+
+	"github.com/opencord/voltha-lib-go/v2/pkg/log"
 )
 
 // RW Core service default constants
 const (
-	ConsulStoreName                   = "consul"
-	EtcdStoreName                     = "etcd"
-	default_GrpcPort                  = 50057
-	default_GrpcHost                  = ""
-	default_KafkaAdapterHost          = "127.0.0.1"
-	default_KafkaAdapterPort          = 9092
-	default_KafkaClusterHost          = "127.0.0.1"
-	default_KafkaClusterPort          = 9094
-	default_KVStoreType               = EtcdStoreName
-	default_KVStoreTimeout            = 5 //in seconds
-	default_KVStoreHost               = "127.0.0.1"
-	default_KVStorePort               = 2379 // Consul = 8500; Etcd = 2379
-	default_KVTxnKeyDelTime           = 60
-	default_KVStoreDataPrefix         = "service/voltha"
-	default_LogLevel                  = 0
-	default_Banner                    = false
-	default_DisplayVersionOnly        = false
-	default_CoreTopic                 = "rwcore"
-	default_RWCoreEndpoint            = "rwcore"
-	default_RWCoreKey                 = "pki/voltha.key"
-	default_RWCoreCert                = "pki/voltha.crt"
-	default_RWCoreCA                  = "pki/voltha-CA.pem"
-	default_AffinityRouterTopic       = "affinityRouter"
-	default_InCompetingMode           = true
-	default_LongRunningRequestTimeout = int64(2000)
-	default_DefaultRequestTimeout     = int64(500)
-	default_CoreTimeout               = int64(500)
-	default_CoreBindingKey            = "voltha_backend_name"
-	default_CorePairTopic             = "rwcore_1"
-	default_MaxConnectionRetries      = -1 // retries forever
-	default_ConnectionRetryInterval   = 2 * time.Second
-	default_LiveProbeInterval         = 60 * time.Second
-	default_NotLiveProbeInterval      = 5 * time.Second // Probe more frequently when not alive
-	default_ProbeHost                 = ""
-	default_ProbePort                 = 8080
+	ConsulStoreName                  = "consul"
+	EtcdStoreName                    = "etcd"
+	defaultGrpcPort                  = 50057
+	defaultGrpcHost                  = ""
+	defaultKafkaAdapterHost          = "127.0.0.1"
+	defaultKafkaAdapterPort          = 9092
+	defaultKafkaClusterHost          = "127.0.0.1"
+	defaultKafkaClusterPort          = 9094
+	defaultKVStoreType               = EtcdStoreName
+	defaultKVStoreTimeout            = 5 //in seconds
+	defaultKVStoreHost               = "127.0.0.1"
+	defaultKVStorePort               = 2379 // Consul = 8500; Etcd = 2379
+	defaultKVTxnKeyDelTime           = 60
+	defaultKVStoreDataPrefix         = "service/voltha"
+	defaultLogLevel                  = 0
+	defaultBanner                    = false
+	defaultDisplayVersionOnly        = false
+	defaultCoreTopic                 = "rwcore"
+	defaultRWCoreEndpoint            = "rwcore"
+	defaultRWCoreKey                 = "pki/voltha.key"
+	defaultRWCoreCert                = "pki/voltha.crt"
+	defaultRWCoreCA                  = "pki/voltha-CA.pem"
+	defaultAffinityRouterTopic       = "affinityRouter"
+	defaultInCompetingMode           = true
+	defaultLongRunningRequestTimeout = int64(2000)
+	defaultDefaultRequestTimeout     = int64(500)
+	defaultCoreTimeout               = int64(500)
+	defaultCoreBindingKey            = "voltha_backend_name"
+	defaultCorePairTopic             = "rwcore_1"
+	defaultMaxConnectionRetries      = -1 // retries forever
+	defaultConnectionRetryInterval   = 2 * time.Second
+	defaultLiveProbeInterval         = 60 * time.Second
+	defaultNotLiveProbeInterval      = 5 * time.Second // Probe more frequently when not alive
+	defaultProbeHost                 = ""
+	defaultProbePort                 = 8080
 )
 
 // RWCoreFlags represents the set of configurations used by the read-write core service
@@ -100,45 +103,48 @@
 }
 
 func init() {
-	log.AddPackage(log.JSON, log.WarnLevel, nil)
+	_, err := log.AddPackage(log.JSON, log.WarnLevel, nil)
+	if err != nil {
+		log.Errorw("unable-to-register-a-package-to-the-log-map", log.Fields{"error": err})
+	}
 }
 
 // NewRWCoreFlags returns a new RWCore config
 func NewRWCoreFlags() *RWCoreFlags {
 	var rwCoreFlag = RWCoreFlags{ // Default values
-		RWCoreEndpoint:            default_RWCoreEndpoint,
-		GrpcHost:                  default_GrpcHost,
-		GrpcPort:                  default_GrpcPort,
-		KafkaAdapterHost:          default_KafkaAdapterHost,
-		KafkaAdapterPort:          default_KafkaAdapterPort,
-		KafkaClusterHost:          default_KafkaClusterHost,
-		KafkaClusterPort:          default_KafkaClusterPort,
-		KVStoreType:               default_KVStoreType,
-		KVStoreTimeout:            default_KVStoreTimeout,
-		KVStoreHost:               default_KVStoreHost,
-		KVStorePort:               default_KVStorePort,
-		KVStoreDataPrefix:         default_KVStoreDataPrefix,
-		KVTxnKeyDelTime:           default_KVTxnKeyDelTime,
-		CoreTopic:                 default_CoreTopic,
-		LogLevel:                  default_LogLevel,
-		Banner:                    default_Banner,
-		DisplayVersionOnly:        default_DisplayVersionOnly,
-		RWCoreKey:                 default_RWCoreKey,
-		RWCoreCert:                default_RWCoreCert,
-		RWCoreCA:                  default_RWCoreCA,
-		AffinityRouterTopic:       default_AffinityRouterTopic,
-		InCompetingMode:           default_InCompetingMode,
-		DefaultRequestTimeout:     default_DefaultRequestTimeout,
-		LongRunningRequestTimeout: default_LongRunningRequestTimeout,
-		DefaultCoreTimeout:        default_CoreTimeout,
-		CoreBindingKey:            default_CoreBindingKey,
-		CorePairTopic:             default_CorePairTopic,
-		MaxConnectionRetries:      default_MaxConnectionRetries,
-		ConnectionRetryInterval:   default_ConnectionRetryInterval,
-		LiveProbeInterval:         default_LiveProbeInterval,
-		NotLiveProbeInterval:      default_NotLiveProbeInterval,
-		ProbeHost:                 default_ProbeHost,
-		ProbePort:                 default_ProbePort,
+		RWCoreEndpoint:            defaultRWCoreEndpoint,
+		GrpcHost:                  defaultGrpcHost,
+		GrpcPort:                  defaultGrpcPort,
+		KafkaAdapterHost:          defaultKafkaAdapterHost,
+		KafkaAdapterPort:          defaultKafkaAdapterPort,
+		KafkaClusterHost:          defaultKafkaClusterHost,
+		KafkaClusterPort:          defaultKafkaClusterPort,
+		KVStoreType:               defaultKVStoreType,
+		KVStoreTimeout:            defaultKVStoreTimeout,
+		KVStoreHost:               defaultKVStoreHost,
+		KVStorePort:               defaultKVStorePort,
+		KVStoreDataPrefix:         defaultKVStoreDataPrefix,
+		KVTxnKeyDelTime:           defaultKVTxnKeyDelTime,
+		CoreTopic:                 defaultCoreTopic,
+		LogLevel:                  defaultLogLevel,
+		Banner:                    defaultBanner,
+		DisplayVersionOnly:        defaultDisplayVersionOnly,
+		RWCoreKey:                 defaultRWCoreKey,
+		RWCoreCert:                defaultRWCoreCert,
+		RWCoreCA:                  defaultRWCoreCA,
+		AffinityRouterTopic:       defaultAffinityRouterTopic,
+		InCompetingMode:           defaultInCompetingMode,
+		DefaultRequestTimeout:     defaultDefaultRequestTimeout,
+		LongRunningRequestTimeout: defaultLongRunningRequestTimeout,
+		DefaultCoreTimeout:        defaultCoreTimeout,
+		CoreBindingKey:            defaultCoreBindingKey,
+		CorePairTopic:             defaultCorePairTopic,
+		MaxConnectionRetries:      defaultMaxConnectionRetries,
+		ConnectionRetryInterval:   defaultConnectionRetryInterval,
+		LiveProbeInterval:         defaultLiveProbeInterval,
+		NotLiveProbeInterval:      defaultNotLiveProbeInterval,
+		ProbeHost:                 defaultProbeHost,
+		ProbePort:                 defaultProbePort,
 	}
 	return &rwCoreFlag
 }
@@ -146,97 +152,95 @@
 // ParseCommandArguments parses the arguments when running read-write core service
 func (cf *RWCoreFlags) ParseCommandArguments() {
 
-	var help string
-
-	help = fmt.Sprintf("RW core endpoint address")
-	flag.StringVar(&(cf.RWCoreEndpoint), "vcore-endpoint", default_RWCoreEndpoint, help)
+	help := fmt.Sprintf("RW core endpoint address")
+	flag.StringVar(&(cf.RWCoreEndpoint), "vcore-endpoint", defaultRWCoreEndpoint, help)
 
 	help = fmt.Sprintf("GRPC server - host")
-	flag.StringVar(&(cf.GrpcHost), "grpc_host", default_GrpcHost, help)
+	flag.StringVar(&(cf.GrpcHost), "grpc_host", defaultGrpcHost, help)
 
 	help = fmt.Sprintf("GRPC server - port")
-	flag.IntVar(&(cf.GrpcPort), "grpc_port", default_GrpcPort, help)
+	flag.IntVar(&(cf.GrpcPort), "grpc_port", defaultGrpcPort, help)
 
 	help = fmt.Sprintf("Kafka - Adapter messaging host")
-	flag.StringVar(&(cf.KafkaAdapterHost), "kafka_adapter_host", default_KafkaAdapterHost, help)
+	flag.StringVar(&(cf.KafkaAdapterHost), "kafka_adapter_host", defaultKafkaAdapterHost, help)
 
 	help = fmt.Sprintf("Kafka - Adapter messaging port")
-	flag.IntVar(&(cf.KafkaAdapterPort), "kafka_adapter_port", default_KafkaAdapterPort, help)
+	flag.IntVar(&(cf.KafkaAdapterPort), "kafka_adapter_port", defaultKafkaAdapterPort, help)
 
 	help = fmt.Sprintf("Kafka - Cluster messaging host")
-	flag.StringVar(&(cf.KafkaClusterHost), "kafka_cluster_host", default_KafkaClusterHost, help)
+	flag.StringVar(&(cf.KafkaClusterHost), "kafka_cluster_host", defaultKafkaClusterHost, help)
 
 	help = fmt.Sprintf("Kafka - Cluster messaging port")
-	flag.IntVar(&(cf.KafkaClusterPort), "kafka_cluster_port", default_KafkaClusterPort, help)
+	flag.IntVar(&(cf.KafkaClusterPort), "kafka_cluster_port", defaultKafkaClusterPort, help)
 
 	help = fmt.Sprintf("RW Core topic")
-	flag.StringVar(&(cf.CoreTopic), "rw_core_topic", default_CoreTopic, help)
+	flag.StringVar(&(cf.CoreTopic), "rw_core_topic", defaultCoreTopic, help)
 
 	help = fmt.Sprintf("Affinity Router topic")
-	flag.StringVar(&(cf.AffinityRouterTopic), "affinity_router_topic", default_AffinityRouterTopic, help)
+	flag.StringVar(&(cf.AffinityRouterTopic), "affinity_router_topic", defaultAffinityRouterTopic, help)
 
 	help = fmt.Sprintf("In competing Mode - two cores competing to handle a transaction ")
-	flag.BoolVar(&cf.InCompetingMode, "in_competing_mode", default_InCompetingMode, help)
+	flag.BoolVar(&cf.InCompetingMode, "in_competing_mode", defaultInCompetingMode, help)
 
 	help = fmt.Sprintf("KV store type")
-	flag.StringVar(&(cf.KVStoreType), "kv_store_type", default_KVStoreType, help)
+	flag.StringVar(&(cf.KVStoreType), "kv_store_type", defaultKVStoreType, help)
 
 	help = fmt.Sprintf("The default timeout when making a kv store request")
-	flag.IntVar(&(cf.KVStoreTimeout), "kv_store_request_timeout", default_KVStoreTimeout, help)
+	flag.IntVar(&(cf.KVStoreTimeout), "kv_store_request_timeout", defaultKVStoreTimeout, help)
 
 	help = fmt.Sprintf("KV store host")
-	flag.StringVar(&(cf.KVStoreHost), "kv_store_host", default_KVStoreHost, help)
+	flag.StringVar(&(cf.KVStoreHost), "kv_store_host", defaultKVStoreHost, help)
 
 	help = fmt.Sprintf("KV store port")
-	flag.IntVar(&(cf.KVStorePort), "kv_store_port", default_KVStorePort, help)
+	flag.IntVar(&(cf.KVStorePort), "kv_store_port", defaultKVStorePort, help)
 
 	help = fmt.Sprintf("The time to wait before deleting a completed transaction key")
-	flag.IntVar(&(cf.KVTxnKeyDelTime), "kv_txn_delete_time", default_KVTxnKeyDelTime, help)
+	flag.IntVar(&(cf.KVTxnKeyDelTime), "kv_txn_delete_time", defaultKVTxnKeyDelTime, help)
 
 	help = fmt.Sprintf("KV store data prefix")
-	flag.StringVar(&(cf.KVStoreDataPrefix), "kv_store_data_prefix", default_KVStoreDataPrefix, help)
+	flag.StringVar(&(cf.KVStoreDataPrefix), "kv_store_data_prefix", defaultKVStoreDataPrefix, help)
 
 	help = fmt.Sprintf("Log level")
-	flag.IntVar(&(cf.LogLevel), "log_level", default_LogLevel, help)
+	flag.IntVar(&(cf.LogLevel), "log_level", defaultLogLevel, help)
 
 	help = fmt.Sprintf("Timeout for long running request")
-	flag.Int64Var(&(cf.LongRunningRequestTimeout), "timeout_long_request", default_LongRunningRequestTimeout, help)
+	flag.Int64Var(&(cf.LongRunningRequestTimeout), "timeout_long_request", defaultLongRunningRequestTimeout, help)
 
 	help = fmt.Sprintf("Default timeout for regular request")
-	flag.Int64Var(&(cf.DefaultRequestTimeout), "timeout_request", default_DefaultRequestTimeout, help)
+	flag.Int64Var(&(cf.DefaultRequestTimeout), "timeout_request", defaultDefaultRequestTimeout, help)
 
 	help = fmt.Sprintf("Default Core timeout")
-	flag.Int64Var(&(cf.DefaultCoreTimeout), "core_timeout", default_CoreTimeout, help)
+	flag.Int64Var(&(cf.DefaultCoreTimeout), "core_timeout", defaultCoreTimeout, help)
 
 	help = fmt.Sprintf("Show startup banner log lines")
-	flag.BoolVar(&cf.Banner, "banner", default_Banner, help)
+	flag.BoolVar(&cf.Banner, "banner", defaultBanner, help)
 
 	help = fmt.Sprintf("Show version information and exit")
-	flag.BoolVar(&cf.DisplayVersionOnly, "version", default_DisplayVersionOnly, help)
+	flag.BoolVar(&cf.DisplayVersionOnly, "version", defaultDisplayVersionOnly, help)
 
 	help = fmt.Sprintf("The name of the meta-key whose value is the rw-core group to which the ofagent is bound")
-	flag.StringVar(&(cf.CoreBindingKey), "core_binding_key", default_CoreBindingKey, help)
+	flag.StringVar(&(cf.CoreBindingKey), "core_binding_key", defaultCoreBindingKey, help)
 
 	help = fmt.Sprintf("Core pairing group topic")
-	flag.StringVar(&cf.CorePairTopic, "core_pair_topic", default_CorePairTopic, help)
+	flag.StringVar(&cf.CorePairTopic, "core_pair_topic", defaultCorePairTopic, help)
 
 	help = fmt.Sprintf("The number of retries to connect to a dependent component")
-	flag.IntVar(&(cf.MaxConnectionRetries), "max_connection_retries", default_MaxConnectionRetries, help)
+	flag.IntVar(&(cf.MaxConnectionRetries), "max_connection_retries", defaultMaxConnectionRetries, help)
 
 	help = fmt.Sprintf("The number of seconds between each connection retry attempt")
-	flag.DurationVar(&(cf.ConnectionRetryInterval), "connection_retry_interval", default_ConnectionRetryInterval, help)
+	flag.DurationVar(&(cf.ConnectionRetryInterval), "connection_retry_interval", defaultConnectionRetryInterval, help)
 
 	help = fmt.Sprintf("The number of seconds between liveness probes while in a live state")
-	flag.DurationVar(&(cf.LiveProbeInterval), "live_probe_interval", default_LiveProbeInterval, help)
+	flag.DurationVar(&(cf.LiveProbeInterval), "live_probe_interval", defaultLiveProbeInterval, help)
 
 	help = fmt.Sprintf("The number of seconds between liveness probes while in a not live state")
-	flag.DurationVar(&(cf.NotLiveProbeInterval), "not_live_probe_interval", default_NotLiveProbeInterval, help)
+	flag.DurationVar(&(cf.NotLiveProbeInterval), "not_live_probe_interval", defaultNotLiveProbeInterval, help)
 
 	help = fmt.Sprintf("The host on which to listen to answer liveness and readiness probe queries over HTTP.")
-	flag.StringVar(&(cf.ProbeHost), "probe_host", default_ProbeHost, help)
+	flag.StringVar(&(cf.ProbeHost), "probe_host", defaultProbeHost, help)
 
 	help = fmt.Sprintf("The port on which to listen to answer liveness and readiness probe queries over HTTP.")
-	flag.IntVar(&(cf.ProbePort), "probe_port", default_ProbePort, help)
+	flag.IntVar(&(cf.ProbePort), "probe_port", defaultProbePort, help)
 
 	flag.Parse()
 }