dep:upgrade polaris-go version (#66)

balancer.go

@@ -33,7 +33,6 @@ import (
  "google.golang.org/grpc/balancer"
  "google.golang.org/grpc/balancer/base"
  "google.golang.org/grpc/connectivity"
- "google.golang.org/grpc/grpclog"
  "google.golang.org/grpc/metadata"
  "google.golang.org/grpc/resolver"
  "google.golang.org/grpc/serviceconfig"
@@ -72,11 +71,11 @@ type (
 
 // Build creates polaris balancer.Balancer implement
 func (bb *balancerBuilder) Build(cc balancer.ClientConn, opts balancer.BuildOptions) balancer.Balancer {
- grpclog.Infof("[Polaris][Balancer] start to build polaris balancer")
+ GetLogger().Info("[Polaris][Balancer] start to build polaris balancer")
  target := opts.Target
  host, _, err := parseHost(target.URL.Host)
  if err != nil {
- grpclog.Errorln("[Polaris][Balancer] failed to create balancer: " + err.Error())
+ GetLogger().Error("[Polaris][Balancer] failed to create balancer: " + err.Error())
  return nil
  }
  return &polarisNamingBalancer{
@@ -174,7 +173,7 @@ func (p *polarisNamingBalancer) createSubConnection(addr resolver.Address) {
  // is a new address (not existing in b.subConns).
  sc, err := p.cc.NewSubConn([]resolver.Address{addr}, balancer.NewSubConnOptions{HealthCheckEnabled: true})
  if err != nil {
- grpclog.Warningf("[Polaris][Balancer] failed to create new SubConn: %v", err)
+ GetLogger().Warn("[Polaris][Balancer] failed to create new SubConn: %v", err)
  return
  }
  p.subConns[key] = sc
@@ -198,9 +197,7 @@ func (p *polarisNamingBalancer) UpdateClientConnState(state balancer.ClientConnS
  if state.BalancerConfig != nil {
  p.lbCfg = state.BalancerConfig.(*LBConfig)
  }
- if grpclog.V(2) {
- grpclog.Infoln("[Polaris][Balancer] got new ClientConn state: ", state)
- }
+ GetLogger().Debug("[Polaris][Balancer] got new ClientConn state: ", state)
  if len(state.ResolverState.Addresses) == 0 {
  p.ResolverError(errors.New("produced zero addresses"))
  return balancer.ErrBadResolverState
@@ -257,17 +254,13 @@ func (p *polarisNamingBalancer) ResolverError(err error) {
 // UpdateSubConnState is called by gRPC when the state of a SubConn changes.
 func (p *polarisNamingBalancer) UpdateSubConnState(sc balancer.SubConn, state balancer.SubConnState) {
  s := state.ConnectivityState
- if grpclog.V(2) {
- grpclog.Infof("[Polaris][Balancer] handle SubConn state change: %p, %v", sc, s)
- }
+ GetLogger().Info("[Polaris][Balancer] handle SubConn state change: %p, %v", sc, s)
  oldS, quit := func() (connectivity.State, bool) {
  p.rwMutex.Lock()
  defer p.rwMutex.Unlock()
  oldS, ok := p.scStates[sc]
  if !ok {
- if grpclog.V(2) {
- grpclog.Infof("[Polaris][Balancer] got state changes for an unknown SubConn: %p, %v", sc, s)
- }
+ GetLogger().Info("[Polaris][Balancer] got state changes for an unknown SubConn: %p, %v", sc, s)
  return connectivity.TransientFailure, true
  }
  if oldS == connectivity.TransientFailure && s == connectivity.Connecting {
@@ -420,13 +413,11 @@ func (pnp *polarisNamingPicker) Pick(info balancer.PickInfo) (balancer.PickResul
  request.SourceService = *sourceService
  } else {
  if err := pnp.addTrafficLabels(info, request); err != nil {
- grpclog.Errorf("[Polaris][Balancer] fetch traffic labels fail : %+v", err)
+ GetLogger().Error("[Polaris][Balancer] fetch traffic labels fail : %+v", err)
  }
  }
 
- if grpclog.V(2) {
- grpclog.Infof("[Polaris][Balancer] get one instance request : %+v", request)
- }
+ GetLogger().Debug("[Polaris][Balancer] get one instance request : %+v", request)
  var err error
  resp, err = pnp.balancer.routerAPI.ProcessRouters(request)
  if err != nil {
@@ -500,13 +491,13 @@ func (pnp *polarisNamingPicker) addTrafficLabels(info balancer.PickInfo, insReq
  engine := pnp.balancer.consumerAPI.SDKContext().GetEngine()
  resp, err := engine.SyncGetServiceRule(model.EventRouting, req)
  if err != nil {
- grpclog.Errorf("[Polaris][Balancer] ns:%s svc:%s get route rule fail : %+v",
+ GetLogger().Error("[Polaris][Balancer] ns:%s svc:%s get route rule fail : %+v",
  req.GetNamespace(), req.GetService(), err)
  return err
  }
 
  if resp == nil || resp.GetValue() == nil {
- grpclog.Errorf("[Polaris][Balancer] ns:%s svc:%s get route rule empty", req.GetNamespace(), req.GetService())
+ GetLogger().Error("[Polaris][Balancer] ns:%s svc:%s get route rule empty", req.GetNamespace(), req.GetService())
  return ErrorPolarisServiceRouteRuleEmpty
  }
 
@@ -573,6 +564,6 @@ func (r *resultReporter) report(info balancer.DoneInfo) {
  callResult.SetDelay(time.Since(r.startTime))
  callResult.SetRetCode(int32(code))
  if err := r.consumerAPI.UpdateServiceCallResult(callResult); err != nil {
- grpclog.Errorf("[Polaris][Balancer] report grpc call info fail : %+v", err)
+ GetLogger().Error("[Polaris][Balancer] report grpc call info fail : %+v", err)
  }
 }

go.mod

@@ -8,6 +8,7 @@ require (
  github.com/golang/protobuf v1.5.4
  github.com/google/uuid v1.6.0
  github.com/hashicorp/errwrap v1.1.0 // indirect
+ github.com/natefinch/lumberjack v2.0.0+incompatible
  github.com/polarismesh/polaris-go v1.6.0-beta.5
  github.com/polarismesh/specification v1.5.1
  github.com/prometheus/client_golang v1.19.1 // indirect

logger.go

@@ -18,8 +18,10 @@
 package grpcpolaris
 
 import (
- "io"
+ "log"
  "sync/atomic"
+
+ "github.com/natefinch/lumberjack"
 )
 
 type LogLevel int
@@ -32,40 +34,72 @@ const (
  LogError
 )
 
+var _log Logger = newDefaultLogger()
+
+func SetLogger(logger Logger) {
+ _log = logger
+}
+
+func GetLogger() Logger {
+ return _log
+}
+
 type Logger interface {
- SetWriter(io.WriteCloser)
- SetLevel()
- Debug(format string, args interface{})
- Info(format string, args interface{})
- Warn(format string, args interface{})
- Error(format string, args interface{})
+ SetLevel(LogLevel)
+ Debug(format string, args ...interface{})
+ Info(format string, args ...interface{})
+ Warn(format string, args ...interface{})
+ Error(format string, args ...interface{})
 }
 
 type defaultLogger struct {
- writerRef atomic.Value
- levelRef  atomic.Value
+ writer *log.Logger
+ levelRef atomic.Value
 }
 
-func (l *defaultLogger) SetWriter(writer io.WriteCloser) {
- l.writerRef.Store(writer)
+func newDefaultLogger() *defaultLogger {
+ lumberJackLogger := &lumberjack.Logger{
+ Filename: "./logs/grpc-go-polaris.log", // 文件位置
+ MaxSize: 100, // 进行切割之前,日志文件的最大大小(MB为单位)
+ MaxAge: 7, // 保留旧文件的最大天数
+ MaxBackups: 100, // 保留旧文件的最大个数
+ Compress: true, // 是否压缩/归档旧文件
+ }
+
+ levelRef := atomic.Value{}
+
+ levelRef.Store(LogInfo)
+ return &defaultLogger{
+ writer: log.New(lumberJackLogger, "", log.Llongfile|log.Ldate|log.Ltime),
+ levelRef: levelRef,
+ }
 }
 
 func (l *defaultLogger) SetLevel(level LogLevel) {
  l.levelRef.Store(level)
 }
 
-func (l *defaultLogger) Debug(format string, args interface{}) {
-
+func (l *defaultLogger) Debug(format string, args ...interface{}) {
+ l.printf(LogDebug, format, args...)
 }
 
-func (l *defaultLogger) Info(format string, args interface{}) {
+func (l *defaultLogger) Info(format string, args ...interface{}) {
+ l.printf(LogInfo, format, args...)
 
 }
 
-func (l *defaultLogger) Warn(format string, args interface{}) {
-
+func (l *defaultLogger) Warn(format string, args ...interface{}) {
+ l.printf(LogWarn, format, args...)
 }
 
-func (l *defaultLogger) Error(format string, args interface{}) {
+func (l *defaultLogger) Error(format string, args ...interface{}) {
+ l.printf(LogError, format, args...)
+}
 
+func (l *defaultLogger) printf(expectLevel LogLevel, format string, args ...interface{}) {
+ curLevel := l.levelRef.Load().(LogLevel)
+ if curLevel > expectLevel {
+ return
+ }
+ l.writer.Printf(format, args...)
 }

ratelimit.go

@@ -29,7 +29,6 @@ import (
  "github.com/polarismesh/specification/source/go/api/v1/traffic_manage"
  "google.golang.org/grpc"
  "google.golang.org/grpc/codes"
- "google.golang.org/grpc/grpclog"
  "google.golang.org/grpc/metadata"
  "google.golang.org/grpc/peer"
  "google.golang.org/grpc/status"
@@ -80,7 +79,7 @@ func (p *RateLimitInterceptor) UnaryInterceptor(ctx context.Context, req interfa
 
  future, err := p.limitAPI.GetQuota(quotaReq)
  if nil != err {
- grpclog.Errorf("[Polaris][RateLimit] fail to get quota %#v: %v", quotaReq, err)
+ GetLogger().Error("[Polaris][RateLimit] fail to get quota %#v: %v", quotaReq, err)
  return handler(ctx, req)
  }
 
@@ -167,21 +166,21 @@ func (p *RateLimitInterceptor) fetchArguments(req *model.QuotaRequestImpl) ([]*t
  }
 
  if err := engine.SyncGetResources(getRuleReq); err != nil {
- grpclog.Errorf("[Polaris][RateLimit] ns:%s svc:%s get RateLimit Rule fail : %+v",
+ GetLogger().Error("[Polaris][RateLimit] ns:%s svc:%s get RateLimit Rule fail : %+v",
  req.GetNamespace(), req.GetService(), err)
  return nil, false
  }
 
  svcRule := getRuleReq.RateLimitRule
  if svcRule == nil || svcRule.GetValue() == nil {
- grpclog.Warningf("[Polaris][RateLimit] ns:%s svc:%s get RateLimit Rule is nil",
+ GetLogger().Warn("[Polaris][RateLimit] ns:%s svc:%s get RateLimit Rule is nil",
  req.GetNamespace(), req.GetService())
  return nil, false
  }
 
  rules, ok := svcRule.GetValue().(*traffic_manage.RateLimit)
  if !ok {
- grpclog.Errorf("[Polaris][RateLimit] ns:%s svc:%s get RateLimit Rule invalid",
+ GetLogger().Error("[Polaris][RateLimit] ns:%s svc:%s get RateLimit Rule invalid",
  req.GetNamespace(), req.GetService())
  return nil, false
  }

resolver.go

@@ -31,7 +31,6 @@ import (
  "github.com/polarismesh/polaris-go/api"
  "github.com/polarismesh/polaris-go/pkg/model"
  "google.golang.org/grpc/attributes"
- "google.golang.org/grpc/grpclog"
  "google.golang.org/grpc/resolver"
 )
 
@@ -280,12 +279,12 @@ func (pr *polarisNamingResolver) watcher() {
  continue
  }
  if err = pr.cc.UpdateState(*state); nil != err {
- grpclog.Errorf("fail to do update service %s: %v", pr.target.URL.Host, err)
+ GetLogger().Error("fail to do update service %s: %v", pr.target.URL.Host, err)
  }
  var svcKey model.ServiceKey
  svcKey, eventChan, err = pr.doWatch(consumerAPI)
  if nil != err {
- grpclog.Errorf("fail to do watch for service %s: %v", svcKey, err)
+ GetLogger().Error("fail to do watch for service %s: %v", svcKey, err)
  }
  }
 }

server.go

@@ -20,7 +20,6 @@ package grpcpolaris
 import (
  "context"
  "fmt"
- "log"
  "net"
  "os"
  "os/signal"
@@ -99,11 +98,13 @@ func (srv *Server) doRegister(lis net.Listener) error {
  }
  srv.serverOptions.host = host
  }
- port, err := parsePort(lis.Addr().String())
- if nil != err {
- return fmt.Errorf("error occur while parsing port from listener: %w", err)
+ if srv.serverOptions.port == 0 {
+ port, err := parsePort(lis.Addr().String())
+ if nil != err {
+ return fmt.Errorf("error occur while parsing port from listener: %w", err)
+ }
+ srv.serverOptions.port = port
  }
- srv.serverOptions.port = port
  svcInfos := buildServiceNames(srv.Server, srv)
 
  for _, name := range svcInfos {
@@ -130,7 +131,7 @@ func (srv *Server) Serve(lis net.Listener) error {
  c := make(chan os.Signal, 1)
  signal.Notify(c, syscall.SIGSEGV, syscall.SIGINT, syscall.SIGTERM)
  s := <-c
- log.Printf("[Polaris][Naming] receive quit signal: %v", s)
+ GetLogger().Info("[Polaris][Naming] receive quit signal: %v", s)
  signal.Stop(c)
  srv.Stop()
  }()
@@ -170,14 +171,14 @@ func (srv *Server) Deregister() {
 func Serve(gSrv *grpc.Server, lis net.Listener, opts ...ServerOption) error {
  pSrv, err := Register(gSrv, lis, opts...)
  if err != nil {
- log.Fatalf("polaris register err: %v", err)
+ GetLogger().Error("polaris register err: %v", err)
  }
 
  go func() {
  c := make(chan os.Signal, 1)
  signal.Notify(c, syscall.SIGINT, syscall.SIGTERM)
  s := <-c
- log.Printf("[Polaris][Naming] receive quit signal: %v", s)
+ GetLogger().Info("[Polaris][Naming] receive quit signal: %v", s)
  signal.Stop(c)
  pSrv.Stop()
  }()