storj/pkg/server/interceptors.go
Ivan Fraixedes d7d6e23a3e
pkg/server: Don't use Sugared logger (#2935)
Replace the usage of the Sugared logger by the normal one.
2019-09-03 11:39:26 +02:00

118 lines
4.0 KiB
Go

// Copyright (C) 2019 Storj Labs, Inc.
// See LICENSE for copying information.
package server
import (
"context"
"encoding/json"
"fmt"
"io"
"go.uber.org/zap"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/peer"
"google.golang.org/grpc/status"
"storj.io/storj/pkg/identity"
"storj.io/storj/storage"
)
func (server *Server) logOnErrorStreamInterceptor(srv interface{}, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) (err error) {
err = handler(srv, ss)
if err != nil {
// no zap errors for canceled or wrong file downloads
if storage.ErrKeyNotFound.Has(err) ||
status.Code(err) == codes.Canceled ||
status.Code(err) == codes.Unavailable ||
err == io.EOF {
return err
}
server.log.Error("gRPC stream error response", zap.Error(err))
}
return err
}
func (server *Server) logOnErrorUnaryInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) {
resp, err = handler(ctx, req)
if err != nil {
// no zap errors for wrong file downloads
if status.Code(err) == codes.NotFound {
return resp, err
}
server.log.Error("gRPC unary error response", zap.Error(err))
}
return resp, err
}
// CombineInterceptors combines two UnaryServerInterceptors so they act as one
// (because grpc only allows you to pass one in).
func CombineInterceptors(a, b grpc.UnaryServerInterceptor) grpc.UnaryServerInterceptor {
return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
return a(ctx, req, info, func(actx context.Context, areq interface{}) (interface{}, error) {
return b(actx, areq, info, func(bctx context.Context, breq interface{}) (interface{}, error) {
return handler(bctx, breq)
})
})
}
}
type nodeRequestLog struct {
GRPCService string `json:"grpc_service"`
GRPCMethod string `json:"grpc_method"`
PeerAddress string `json:"peer_address"`
PeerNodeID string `json:"peer_node_id"`
Msg interface{} `json:"msg"`
}
func prepareRequestLog(ctx context.Context, req, server interface{}, methodName string) ([]byte, error) {
reqLog := nodeRequestLog{
GRPCService: fmt.Sprintf("%T", server),
GRPCMethod: methodName,
PeerAddress: "<no peer???>",
Msg: req,
}
if peer, ok := peer.FromContext(ctx); ok {
reqLog.PeerAddress = peer.Addr.String()
if peerIdentity, err := identity.PeerIdentityFromPeer(peer); err == nil {
reqLog.PeerNodeID = peerIdentity.ID.String()
} else {
reqLog.PeerNodeID = fmt.Sprintf("<no peer id: %v>", err)
}
}
return json.Marshal(reqLog)
}
// UnaryMessageLoggingInterceptor creates a UnaryServerInterceptor which
// logs the full contents of incoming unary requests.
func UnaryMessageLoggingInterceptor(log *zap.Logger) grpc.UnaryServerInterceptor {
return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) {
if jsonReq, err := prepareRequestLog(ctx, req, info.Server, info.FullMethod); err == nil {
log.Info(string(jsonReq))
} else {
log.Error("Failed to marshal request to JSON.",
zap.String("method", info.FullMethod), zap.Error(err),
)
}
return handler(ctx, req)
}
}
// StreamMessageLoggingInterceptor creates a StreamServerInterceptor which
// logs the full contents of incoming streaming requests.
func StreamMessageLoggingInterceptor(log *zap.Logger) grpc.StreamServerInterceptor {
return func(srv interface{}, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
// Are we even using any of these yet? I'm only guessing at how best to pass in things
// so that they make sense.
if jsonReq, err := prepareRequestLog(ss.Context(), srv, nil, info.FullMethod); err == nil {
log.Info(string(jsonReq))
} else {
log.Error("Failed to marshal request to JSON.",
zap.String("method", info.FullMethod), zap.Error(err),
)
}
return handler(srv, ss)
}
}