Function Server

grpc/server.go:71–155

(ab AuthBackend, logger grpc_logging.Logger)

}

func Server(ab AuthBackend, logger grpc_logging.Logger) *grpc.Server {
	serverMetrics := grpc_prometheus.NewServerMetrics()

	myServer := grpc.NewServer(
		grpc.ChainStreamInterceptor(
			grpc_sentry.StreamServerInterceptor(),
			grpc_logging.StreamServerInterceptor(logger),
			serverMetrics.StreamServerInterceptor(),
			func(srv interface{}, stream grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
				ctx := stream.Context()
				ctx, md := prepareContext(ctx)

				wrappedStream := grpc_middleware.WrapServerStream(stream)
				wrappedStream.WrappedContext = ctx
				var addr string
				if p, ok := peer.FromContext(ctx); ok {
					addr = p.Addr.String()
				}

				start := time.Now()
				err := handler(srv, wrappedStream)

				if err := addExternalDependencyToTrailer(ctx); err != nil {
					log.Ctx(ctx).Warn().Err(err).Msg("unable to add external dependencies to trailer")
				}

				log.Ctx(ctx).Info().Str("method", info.FullMethod).
					Dur("duration", time.Since(start)).
					Str("type", "stream").
					Str("ip", addr).
					Interface("md", md).
					Str("user_agent", strings.Join(md.Get("user-agent"), ",")).
					Err(err).
					Msg("GRPC completed Stream")
				return err
			},
			func(srv interface{}, stream grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) (err error) {
				defer errors.HandleWithCtx(stream.Context(), "GRPC "+info.FullMethod)
				err = InternalServerError // default in case of a panic
				err = handler(srv, stream)
				return err
			},
			grpc_auth.StreamServerInterceptor(ab.AuthorizeStream),
		),
		grpc.ChainUnaryInterceptor(
			grpc_sentry.UnaryServerInterceptor(),
			grpc_logging.UnaryServerInterceptor(logger),
			serverMetrics.UnaryServerInterceptor(),
			func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) {
				ctx, md := prepareContext(ctx)

				var addr string
				if p, ok := peer.FromContext(ctx); ok {
					addr = p.Addr.String()
				}

				start := time.Now()
				resp, err = handler(ctx, req)