Modified code to adapt with latest paas-lager (#179)

config-center/config_center.go

@@ -75,7 +75,7 @@ func InitConfigCenter() error {
 		return err
 	}
 
-	lager.Logger.Warnf(nil, "config center init success")
+	lager.Logger.Warnf("config center init success")
 	return nil
 }
 
@@ -115,7 +115,7 @@ func getTLSForClient(configCenterURL string) (*tls.Config, error) {
 		}
 		return nil, err
 	}
-	lager.Logger.Warnf(nil, "%s TLS mode, verify peer: %t, cipher plugin: %s.",
+	lager.Logger.Warnf("%s TLS mode, verify peer: %t, cipher plugin: %s.",
 		sslTag, sslConfig.VerifyPeer, sslConfig.CipherPlugin)
 
 	return tlsConfig, nil

config-center/config_center_test.go

@@ -110,7 +110,7 @@ func TestInitConfigCenterWithInvalidName(t *testing.T) {
 
 func TestEvent(t *testing.T) {
 	t.Log("Testing EventListener function")
-	factoryObj, _ := goarchaius.NewConfigFactory()
+	factoryObj, _ := goarchaius.NewConfigFactory(nil)
 
 	factoryObj.Init()
 

core/archaius/archaius.go

@@ -25,7 +25,7 @@ var DefaultConf *Config
 // NewConfig is gives the object of Config(it is having configuration files, and configuration factory)
 func NewConfig(essentialfiles, commonfiles []string) (*Config, error) {
 	// created config factory object
-	factory, err := goarchaius.NewConfigFactory()
+	factory, err := goarchaius.NewConfigFactory(lager.Logger)
 	if err != nil {
 		return nil, err
 	}

core/client/client_manager.go

@@ -38,7 +38,7 @@ func CreateClient(protocol, service string) (ProtocolClient, error) {
 			return nil, err
 		}
 	} else {
-		lager.Logger.Warnf(nil, "%s %s TLS mode, verify peer: %t, cipher plugin: %s.",
+		lager.Logger.Warnf("%s %s TLS mode, verify peer: %t, cipher plugin: %s.",
 			protocol, service, sslConfig.VerifyPeer, sslConfig.CipherPlugin)
 	}
 	p := GetProtocolSpec(protocol)

core/config/config.go

@@ -231,7 +231,7 @@ func readMicroserviceConfigFiles() error {
 		}
 		msName := microserviceNames[0]
 		msDefPath := fileutil.MicroserviceDefinition(msName)
-		lager.Logger.Warnf(nil, fmt.Sprintf("Try to find microservice description file in [%s]", msDefPath))
+		lager.Logger.Warnf(fmt.Sprintf("Try to find microservice description file in [%s]", msDefPath))
 		data, err := ioutil.ReadFile(msDefPath)
 		if err != nil {
 			return fmt.Errorf("Missing microservice description file: %s", err.Error())

core/handler/fault_inject_handler.go

@@ -49,7 +49,7 @@ func (rl *FaultHandler) Handle(chain *Chain, inv *invocation.Invocation, cb invo
 	faultInject, ok := fault.FaultInjectors[inv.Protocol]
 	r := &invocation.InvocationResponse{}
 	if !ok {
-		lager.Logger.Warn("fault injection doesn't support for protocol ", errors.New(inv.Protocol))
+		lager.Logger.Warnf("fault injection doesn't support for protocol ", errors.New(inv.Protocol))
 		r.Err = nil
 		cb(r)
 		return

core/handler/handler_chain.go

@@ -106,7 +106,7 @@ func CreateChain(serviceType string, chainName string, handlerNames ...string) (
 	}
 
 	if len(c.Handlers) == 0 {
-		lager.Logger.Warn("Chain "+chainName+" is Empty", errEmptyChain)
+		lager.Logger.Warnf("Chain "+chainName+" is Empty", errEmptyChain)
 		return c, nil
 	}
 	return c, nil

core/lager/lager.go

@@ -8,7 +8,7 @@ import (
 
 	"github.com/ServiceComb/go-chassis/core/common"
 
-	"github.com/ServiceComb/paas-lager"
+	paaslager "github.com/ServiceComb/paas-lager"
 	"github.com/ServiceComb/paas-lager/third_party/forked/cloudfoundry/lager"
 )
 
@@ -72,14 +72,14 @@ func newLog(lag *Lager) lager.Logger {
 	if len(strings.TrimSpace(lag.Writers)) == 0 {
 		writers = []string{"stdout"}
 	}
-	stlager.Init(stlager.Config{
+	paaslager.Init(paaslager.Config{
 		Writers:       writers,
 		LoggerLevel:   lag.LoggerLevel,
 		LoggerFile:    logFilePath,
 		LogFormatText: lag.LogFormatText,
 	})
 
-	logger := stlager.NewLogger(lag.LoggerFile)
+	logger := paaslager.NewLogger(lag.LoggerFile)
 	return logger
 }
 

core/provider/default_provider.go

@@ -167,21 +167,21 @@ func suitableMethods(typ reflect.Type, reportErr bool) map[string]*operation {
 		// Method must be exported.
 		if method.PkgPath != "" {
 			if reportErr {
-				lager.Logger.Warnf(nil, "Method must be exported")
+				lager.Logger.Warnf("Method must be exported")
 			}
 			continue
 		}
 		// Method needs three ins: receiver, *anyArg, *request.
 		if mtype.NumIn() != 3 {
-			lager.Logger.Warnf(nil, "method has wrong number of ins, method:%s, nujm:%d", mname, mtype.NumIn())
+			lager.Logger.Warnf("method has wrong number of ins, method:%s, nujm:%d", mname, mtype.NumIn())
 			continue
 		}
 
 		// second arg need not be a pointer.
 		any := mtype.In(1)
 		if !isExportedOrBuiltinType(any) {
 			if reportErr {
-				lager.Logger.Warnf(nil, "argument type not exported, method:%s, nujm:%s", mname, any)
+				lager.Logger.Warnf("argument type not exported, method:%s, nujm:%s", mname, any)
 			}
 			continue
 		}
@@ -190,35 +190,35 @@ func suitableMethods(typ reflect.Type, reportErr bool) map[string]*operation {
 		requestType := mtype.In(2)
 		if requestType.Kind() != reflect.Ptr {
 			if reportErr {
-				lager.Logger.Warnf(nil, "method reply type not a pointer, method:%s, requestType:%s", mname, requestType)
+				lager.Logger.Warnf("method reply type not a pointer, method:%s, requestType:%s", mname, requestType)
 			}
 			continue
 		}
 		// request type must be exported.
 		if !isExportedOrBuiltinType(requestType) {
 			if reportErr {
-				lager.Logger.Warnf(nil, "method reply type not exported, method:%s, requestType:%s", mname, requestType)
+				lager.Logger.Warnf("method reply type not exported, method:%s, requestType:%s", mname, requestType)
 			}
 			continue
 		}
 		var in = []reflect.Type{any, requestType}
 		// Method needs 2 out.
 		// response must be a pointer.
 		if mtype.NumOut() != 2 {
-			lager.Logger.Warnf(nil, "method has wrong number of outs, method:%s, requestType:%d", mname, mtype.NumOut())
+			lager.Logger.Warnf("method has wrong number of outs, method:%s, requestType:%d", mname, mtype.NumOut())
 			continue
 		}
 		reponseType := mtype.Out(0)
 		if reponseType.Kind() != reflect.Ptr {
-			lager.Logger.Warnf(nil, "method reply type not a pointe, method:%s, reponseType:%s", mname, reponseType)
+			lager.Logger.Warnf("method reply type not a pointe, method:%s, reponseType:%s", mname, reponseType)
 			continue
 		}
 
 		// The second return type of the method must be error.
 		returnType := mtype.Out(1)
 		if returnType != typeOfError {
 			if reportErr {
-				lager.Logger.Warnf(nil, "method returns method:%s, returnType.String():%s", mname, returnType.String())
+				lager.Logger.Warnf("method returns method:%s, returnType.String():%s", mname, returnType.String())
 			}
 			continue
 		}

core/provider/provider_manager.go

@@ -41,7 +41,7 @@ func RegisterProvider(pluginName string, microserviceName string) Provider {
 // RegisterCustomProvider register customer provider
 func RegisterCustomProvider(microserviceName string, p Provider) {
 	if providers[microserviceName] != nil {
-		lager.Logger.Warnf(nil, "Can not replace Provider,since it is not nil")
+		lager.Logger.Warnf("Can not replace Provider,since it is not nil")
 		return
 	}
 	providers[microserviceName] = p

core/qpslimiter/qps_limiter.go

@@ -125,12 +125,12 @@ func (qpsL *QPSLimiterMap) UpdateRateLimit(key string, value interface{}) {
 	case string:
 		convertedIntValue, err := strconv.Atoi(value.(string))
 		if err != nil {
-			lager.Logger.Warnf(err, "Invalid Value type received for QPSLateLimiter: %v", v)
+			lager.Logger.Warnf("Invalid Value type received for QPSLateLimiter: %v", v, err)
 		} else {
 			qpsL.ProcessDefaultRateRpsTokenReq(key, convertedIntValue)
 		}
 	default:
-		lager.Logger.Warnf(nil, "Invalid Value type received for QPSLateLimiter: %v", v)
+		lager.Logger.Warnf("Invalid Value type received for QPSLateLimiter: %v", v)
 	}
 }
 

core/registry/bootstrap.go

@@ -27,7 +27,7 @@ func RegisterMicroservice() error {
 	microServiceDependencies = &MicroServiceDependency{}
 	schemas, err := schema.GetSchemaIDs(service.ServiceDescription.Name)
 	if err != nil {
-		lager.Logger.Warnf(err, "Get schemas failed, microservice = %s.", service.ServiceDescription.Name)
+		lager.Logger.Warnf("Get schemas failed, microservice = %s.", service.ServiceDescription.Name)
 		schemas = make([]string, 0)
 	}
 	if service.ServiceDescription.Level == "" {
@@ -58,7 +58,7 @@ func RegisterMicroservice() error {
 		lager.Logger.Errorf(err, "Register microservice [%s] failed", microservice.ServiceName)
 		return err
 	}
-	lager.Logger.Warnf(nil, "Register microservice [%s] success", microservice.ServiceName)
+	lager.Logger.Warnf("Register microservice [%s] success", microservice.ServiceName)
 
 	for _, schemaID := range schemas {
 		schemaInfo := schema.DefaultSchemaIDsMap[schemaID]
@@ -170,6 +170,6 @@ func RegisterMicroserviceInstances() error {
 		instanceIDs = append(instanceIDs, instanceID)
 	}
 	SelfInstancesCache.Set(sid, instanceIDs, 0)
-	lager.Logger.Warnf(nil, "Register instance success, serviceID/instanceID: %s/%s.", sid, instanceID)
+	lager.Logger.Warnf("Register instance success, serviceID/instanceID: %s/%s.", sid, instanceID)
 	return nil
 }

core/registry/file/file_client.go

@@ -81,18 +81,18 @@ func (f *fileClient) getInstanceDataFromFile() *serviceData {
 
 	file, err := os.Open(path)
 	if err != nil {
-		lager.Logger.Warnf(err, "failed to open a file")
+		lager.Logger.Warnf("failed to open a file", err)
 	}
 	defer file.Close()
 
 	plan, err := ioutil.ReadFile(path)
 	if err != nil {
-		lager.Logger.Warnf(err, "failed to do readfile operation")
+		lager.Logger.Warnf("failed to do readfile operation", err)
 	}
 
 	err = json.Unmarshal(plan, &data)
 	if err != nil {
-		lager.Logger.Warnf(err, "failed to do unmarshall")
+		lager.Logger.Warnf("failed to do unmarshall", err)
 	}
 
 	return data

core/registry/heartbeat.go

@@ -181,11 +181,11 @@ func reRegisterSelfMSI(sid string) error {
 
 	value, ok := SelfInstancesCache.Get(microServiceInstance.ServiceID)
 	if !ok {
-		lager.Logger.Warnf(nil, "RegisterMicroServiceInstance get SelfInstancesCache failed, Mid/Sid: %s/%s", microServiceInstance.ServiceID, instanceID)
+		lager.Logger.Warnf("RegisterMicroServiceInstance get SelfInstancesCache failed, Mid/Sid: %s/%s", microServiceInstance.ServiceID, instanceID)
 	}
 	instanceIDs, ok := value.([]string)
 	if !ok {
-		lager.Logger.Warnf(nil, "RegisterMicroServiceInstance type asserts failed,  Mid/Sid: %s/%s", microServiceInstance.ServiceID, instanceID)
+		lager.Logger.Warnf("RegisterMicroServiceInstance type asserts failed,  Mid/Sid: %s/%s", microServiceInstance.ServiceID, instanceID)
 	}
 	var isRepeat bool
 	for _, va := range instanceIDs {
@@ -197,7 +197,7 @@ func reRegisterSelfMSI(sid string) error {
 		instanceIDs = append(instanceIDs, instanceID)
 	}
 	SelfInstancesCache.Set(microServiceInstance.ServiceID, instanceIDs, 0)
-	lager.Logger.Warnf(nil, "RegisterMicroServiceInstance success, microServiceID/instanceID: %s/%s.", microServiceInstance.ServiceID, instanceID)
+	lager.Logger.Warnf("RegisterMicroServiceInstance success, microServiceID/instanceID: %s/%s.", microServiceInstance.ServiceID, instanceID)
 
 	return nil
 }

core/registry/pilot/pilot.go

@@ -82,7 +82,7 @@ func (r *ServiceDiscovery) GetMicroServiceInstances(consumerID, providerID strin
 func (r *ServiceDiscovery) FindMicroServiceInstances(consumerID, appID, microServiceName, version, env string) ([]*registry.MicroServiceInstance, error) {
 	value, boo := registry.MicroserviceInstanceCache.Get(microServiceName)
 	if !boo || value == nil {
-		lager.Logger.Warnf(nil, "%s Get instances from remote, key: %s", consumerID, microServiceName)
+		lager.Logger.Warnf("%s Get instances from remote, key: %s", consumerID, microServiceName)
 		hs, err := r.registryClient.GetServiceHosts(microServiceName)
 		if err != nil {
 			return nil, fmt.Errorf("FindMicroServiceInstances failed, ProviderID: %s, err: %s",

core/registry/registrator.go

@@ -80,7 +80,7 @@ func enableRegistrator(opts Options) {
 	}
 	go HBService.Start()
 
-	lager.Logger.Warnf(nil, "Enable %s registry.", DefaultRegistrator)
+	lager.Logger.Warnf("Enable %s registry.", DefaultRegistrator)
 }
 
 // InstallRegistrator install registrator plugin

core/registry/servicecenter/cache.go

@@ -309,10 +309,10 @@ func watch(response *model.MicroServiceInstanceChangedEvent) {
 		updateAction(response)
 		break
 	case model.EventError:
-		lager.Logger.Warnf(nil, "MicroServiceInstanceChangedEvent action is error, MicroServiceInstanceChangedEvent = %s", response)
+		lager.Logger.Warnf("MicroServiceInstanceChangedEvent action is error, MicroServiceInstanceChangedEvent = %s", response)
 		break
 	default:
-		lager.Logger.Warnf(nil, "Do not support this Action = %s", response.Action)
+		lager.Logger.Warnf("Do not support this Action = %s", response.Action)
 		return
 	}
 }
@@ -331,7 +331,7 @@ func createAction(response *model.MicroServiceInstanceChangedEvent) {
 		return
 	}
 	if response.Instance.Status != model.MSInstanceUP {
-		lager.Logger.Warnf(nil, "createAction failed,MicroServiceInstance status is not MSI_UP,MicroServiceInstanceChangedEvent = %s", response)
+		lager.Logger.Warnf("createAction failed,MicroServiceInstance status is not MSI_UP,MicroServiceInstanceChangedEvent = %s", response)
 		return
 	}
 	msi := ToMicroServiceInstance(response.Instance)
@@ -377,7 +377,7 @@ func updateAction(response *model.MicroServiceInstanceChangedEvent) {
 		return
 	}
 	if response.Instance.Status != model.MSInstanceUP {
-		lager.Logger.Warnf(nil, "updateAction failed,MicroServiceInstance status is not MSI_UP,MicroServiceInstanceChangedEvent = %s", response)
+		lager.Logger.Warnf("updateAction failed,MicroServiceInstance status is not MSI_UP,MicroServiceInstanceChangedEvent = %s", response)
 		return
 	}
 	msi := ToMicroServiceInstance(response.Instance)
@@ -397,7 +397,7 @@ func updateAction(response *model.MicroServiceInstanceChangedEvent) {
 		microServiceInstances = append(microServiceInstances, msi)
 		break
 	default:
-		lager.Logger.Warnf(nil, "updateAction error, iid:%s", response.Instance.InstanceID)
+		lager.Logger.Warnf("updateAction error, iid:%s", response.Instance.InstanceID)
 	}
 	registry.MicroserviceInstanceCache.Set(key, microServiceInstances, 0)
 	lager.Logger.Debugf("Cached Instances,action is EVT_UPDATE,sid = %s,instances length = %d", response.Instance.ServiceID, len(microServiceInstances))

core/registry/servicecenter/servicecenter.go

@@ -28,17 +28,17 @@ func (r *Registrator) RegisterService(ms *registry.MicroService) (string, error)
 	microservice := ToSCService(ms)
 	sid, err := r.registryClient.GetMicroServiceID(microservice.AppID, microservice.ServiceName, microservice.Version, microservice.Environment)
 	if err != nil {
-		lager.Logger.Warnf(err, "Get microservice [%s] failed", serviceKey)
+		lager.Logger.Warnf("Get microservice [%s] failed", serviceKey, err)
 	}
 	if sid == "" {
-		lager.Logger.Warnf(err, "Microservice [%s] not exists in registry, register it", serviceKey)
+		lager.Logger.Warnf("Microservice [%s] not exists in registry, register it", serviceKey, err)
 		sid, err = r.registryClient.RegisterService(microservice)
 		if err != nil {
 			lager.Logger.Errorf(err, "Register microservice [%s] failed", serviceKey)
 			return "", err
 		}
 	} else {
-		lager.Logger.Warnf(err, "Microservice [%s] exists in registry, no need register", serviceKey)
+		lager.Logger.Warnf("Microservice [%s] exists in registry, no need register", serviceKey, err)
 	}
 
 	return sid, nil
@@ -55,11 +55,11 @@ func (r *Registrator) RegisterServiceInstance(sid string, cIns *registry.MicroSe
 	}
 	value, ok := registry.SelfInstancesCache.Get(instance.ServiceID)
 	if !ok {
-		lager.Logger.Warnf(nil, "RegisterMicroServiceInstance get SelfInstancesCache failed, Mid/Sid: %s/%s", instance.ServiceID, instanceID)
+		lager.Logger.Warnf("RegisterMicroServiceInstance get SelfInstancesCache failed, Mid/Sid: %s/%s", instance.ServiceID, instanceID)
 	}
 	instanceIDs, ok := value.([]string)
 	if !ok {
-		lager.Logger.Warnf(nil, "RegisterMicroServiceInstance type asserts failed,  Mid/Sid: %s/%s", instance.ServiceID, instanceID)
+		lager.Logger.Warnf("RegisterMicroServiceInstance type asserts failed,  Mid/Sid: %s/%s", instance.ServiceID, instanceID)
 	}
 	var isRepeat bool
 	for _, va := range instanceIDs {
@@ -103,11 +103,11 @@ func (r *Registrator) RegisterServiceAndInstance(cMicroService *registry.MicroSe
 
 	value, ok := registry.SelfInstancesCache.Get(instance.ServiceID)
 	if !ok {
-		lager.Logger.Warnf(nil, "RegisterMicroServiceInstance get SelfInstancesCache failed, Mid/Sid: %s/%s", instance.ServiceID, instanceID)
+		lager.Logger.Warnf("RegisterMicroServiceInstance get SelfInstancesCache failed, Mid/Sid: %s/%s", instance.ServiceID, instanceID)
 	}
 	instanceIDs, ok := value.([]string)
 	if !ok {
-		lager.Logger.Warnf(nil, "RegisterMicroServiceInstance type asserts failed,  Mid/Sid: %s/%s", instance.ServiceID, instanceID)
+		lager.Logger.Warnf("RegisterMicroServiceInstance type asserts failed,  Mid/Sid: %s/%s", instance.ServiceID, instanceID)
 	}
 	var isRepeat bool
 	for _, va := range instanceIDs {
@@ -139,11 +139,11 @@ func (r *Registrator) UnRegisterMicroServiceInstance(microServiceID, microServic
 
 	value, ok := registry.SelfInstancesCache.Get(microServiceID)
 	if !ok {
-		lager.Logger.Warnf(nil, "UnregisterMicroServiceInstance get SelfInstancesCache failed, Mid/Sid: %s/%s", microServiceID, microServiceInstanceID)
+		lager.Logger.Warnf("UnregisterMicroServiceInstance get SelfInstancesCache failed, Mid/Sid: %s/%s", microServiceID, microServiceInstanceID)
 	}
 	instanceIDs, ok := value.([]string)
 	if !ok {
-		lager.Logger.Warnf(nil, "UnregisterMicroServiceInstance type asserts failed, Mid/Sid: %s/%s", microServiceID, microServiceInstanceID)
+		lager.Logger.Warnf("UnregisterMicroServiceInstance type asserts failed, Mid/Sid: %s/%s", microServiceID, microServiceInstanceID)
 	}
 	var newInstanceIDs = make([]string, 0)
 	for _, v := range instanceIDs {
@@ -315,7 +315,7 @@ func (r *ServiceDiscovery) FindMicroServiceInstances(consumerID, appID, microSer
 
 	value, boo := registry.MicroserviceInstanceCache.Get(key)
 	if !boo || value == nil {
-		lager.Logger.Warnf(nil, "%s Get instances from remote, key: %s", consumerID, key)
+		lager.Logger.Warnf("%s Get instances from remote, key: %s", consumerID, key)
 		providerInstances, err := r.registryClient.FindMicroServiceInstances(consumerID, appID, microServiceName,
 			findVersionRule(microServiceName))
 		if err != nil {