Pass init ctx to all reva services (cs3org#3407)

changelog/unreleased/init-log.md

@@ -0,0 +1,3 @@
+Enhancement: Add init time logging to all services
+
+https://github.com/cs3org/reva/pull/3407

cmd/revad/runtime/option.go

@@ -19,6 +19,8 @@
 package runtime
 
 import (
+	"context"
+
 	"github.com/cs3org/reva/pkg/registry"
 	"github.com/rs/zerolog"
 )
@@ -31,13 +33,15 @@ type Options struct {
 	Logger   *zerolog.Logger
 	Registry registry.Registry
 	PidFile  string
+	Ctx      context.Context
 }
 
 // newOptions initializes the available default options.
 func newOptions(opts ...Option) Options {
 	l := zerolog.Nop()
 	opt := Options{
 		Logger: &l,
+		Ctx:    context.TODO(),
 	}
 
 	for _, o := range opts {
@@ -67,3 +71,10 @@ func WithRegistry(r registry.Registry) Option {
 		o.Registry = r
 	}
 }
+
+// WithContext sets the context to use.
+func WithContext(ctx context.Context) Option {
+	return func(o *Options) {
+		o.Ctx = ctx
+	}
+}

cmd/revad/runtime/runtime.go

@@ -19,6 +19,7 @@
 package runtime
 
 import (
+	"context"
 	"fmt"
 	"net"
 	"runtime"
@@ -29,8 +30,10 @@ import (
 
 	"github.com/cs3org/reva/cmd/revad/pkg/config"
 	"github.com/cs3org/reva/cmd/revad/pkg/grace"
+	"github.com/cs3org/reva/pkg/appctx"
 	"github.com/cs3org/reva/pkg/rgrpc"
 	"github.com/cs3org/reva/pkg/rhttp"
+
 	"github.com/cs3org/reva/pkg/rhttp/global"
 	"github.com/cs3org/reva/pkg/rserverless"
 	"github.com/cs3org/reva/pkg/sharedconf"
@@ -44,6 +47,7 @@ import (
 
 // Reva represents a full instance of reva.
 type Reva struct {
+	ctx    context.Context
 	config *config.Config
 
 	servers    []*Server
@@ -73,6 +77,8 @@ func New(config *config.Config, opt ...Option) (*Reva, error) {
 	opts := newOptions(opt...)
 	log := opts.Logger
 
+	ctx := appctx.WithLogger(opts.Ctx, log)
+
 	if err := initCPUCount(config.Core, log); err != nil {
 		return nil, err
 	}
@@ -103,7 +109,7 @@ func New(config *config.Config, opt ...Option) (*Reva, error) {
 
 	grpc := groupGRPCByAddress(config)
 	http := groupHTTPByAddress(config)
-	servers, err := newServers(grpc, http, listeners, log)
+	servers, err := newServers(ctx, grpc, http, listeners, log)
 	if err != nil {
 		watcher.Clean()
 		return nil, err
@@ -116,6 +122,7 @@ func New(config *config.Config, opt ...Option) (*Reva, error) {
 	}
 
 	return &Reva{
+		ctx:        ctx,
 		config:     config,
 		servers:    servers,
 		serverless: serverless,
@@ -357,10 +364,12 @@ func listenerFromAddress(lns map[string]net.Listener, network string, address co
 	panic(fmt.Sprintf("listener not found for address %s:%s", network, address))
 }
 
-func newServers(grpc []*config.GRPC, http []*config.HTTP, lns map[string]net.Listener, log *zerolog.Logger) ([]*Server, error) {
+func newServers(ctx context.Context, grpc []*config.GRPC, http []*config.HTTP, lns map[string]net.Listener, log *zerolog.Logger) ([]*Server, error) {
 	servers := make([]*Server, 0, len(grpc)+len(http))
 	for _, cfg := range grpc {
-		services, err := rgrpc.InitServices(cfg.Services)
+		logger := log.With().Str("pkg", "grpc").Logger()
+		ctx := appctx.WithLogger(ctx, &logger)
+		services, err := rgrpc.InitServices(ctx, cfg.Services)
 		if err != nil {
 			return nil, err
 		}
@@ -371,7 +380,7 @@ func newServers(grpc []*config.GRPC, http []*config.HTTP, lns map[string]net.Lis
 		s, err := rgrpc.NewServer(
 			rgrpc.EnableReflection(cfg.EnableReflection),
 			rgrpc.WithShutdownDeadline(cfg.ShutdownDeadline),
-			rgrpc.WithLogger(log.With().Str("pkg", "grpc").Logger()),
+			rgrpc.WithLogger(logger),
 			rgrpc.WithServices(services),
 			rgrpc.WithUnaryServerInterceptors(unaryChain),
 			rgrpc.WithStreamServerInterceptors(streamChain),
@@ -391,18 +400,19 @@ func newServers(grpc []*config.GRPC, http []*config.HTTP, lns map[string]net.Lis
 		servers = append(servers, server)
 	}
 	for _, cfg := range http {
-		log := log.With().Str("pkg", "http").Logger()
-		services, err := rhttp.InitServices(cfg.Services, &log)
+		logger := log.With().Str("pkg", "http").Logger()
+		ctx := appctx.WithLogger(ctx, &logger)
+		services, err := rhttp.InitServices(ctx, cfg.Services)
 		if err != nil {
 			return nil, err
 		}
-		middlewares, err := initHTTPMiddlewares(cfg.Middlewares, httpUnprotected(services), &log)
+		middlewares, err := initHTTPMiddlewares(cfg.Middlewares, httpUnprotected(services), &logger)
 		if err != nil {
 			return nil, err
 		}
 		s, err := rhttp.New(
 			rhttp.WithServices(services),
-			rhttp.WithLogger(log),
+			rhttp.WithLogger(logger),
 			rhttp.WithCertAndKeyFiles(cfg.CertFile, cfg.KeyFile),
 			rhttp.WithMiddlewares(middlewares),
 		)

internal/grpc/services/applicationauth/applicationauth.go

@@ -56,9 +56,9 @@ func (s *service) Register(ss *grpc.Server) {
 	appauthpb.RegisterApplicationsAPIServer(ss, s)
 }
 
-func getAppAuthManager(c *config) (appauth.Manager, error) {
+func getAppAuthManager(ctx context.Context, c *config) (appauth.Manager, error) {
 	if f, ok := registry.NewFuncs[c.Driver]; ok {
-		return f(c.Drivers[c.Driver])
+		return f(ctx, c.Drivers[c.Driver])
 	}
 	return nil, errtypes.NotFound("driver not found: " + c.Driver)
 }
@@ -73,14 +73,14 @@ func parseConfig(m map[string]interface{}) (*config, error) {
 }
 
 // New creates a app auth provider svc.
-func New(m map[string]interface{}) (rgrpc.Service, error) {
+func New(ctx context.Context, m map[string]interface{}) (rgrpc.Service, error) {
 	c, err := parseConfig(m)
 	if err != nil {
 		return nil, err
 	}
 	c.init()
 
-	am, err := getAppAuthManager(c)
+	am, err := getAppAuthManager(ctx, c)
 	if err != nil {
 		return nil, err
 	}

internal/grpc/services/appprovider/appprovider.go

@@ -32,8 +32,8 @@ import (
 	types "github.com/cs3org/go-cs3apis/cs3/types/v1beta1"
 	"github.com/cs3org/reva/pkg/app"
 	"github.com/cs3org/reva/pkg/app/provider/registry"
+	"github.com/cs3org/reva/pkg/appctx"
 	"github.com/cs3org/reva/pkg/errtypes"
-	"github.com/cs3org/reva/pkg/logger"
 	"github.com/cs3org/reva/pkg/mime"
 	"github.com/cs3org/reva/pkg/rgrpc"
 	"github.com/cs3org/reva/pkg/rgrpc/status"
@@ -82,7 +82,7 @@ func parseConfig(m map[string]interface{}) (*config, error) {
 }
 
 // New creates a new AppProviderService.
-func New(m map[string]interface{}) (rgrpc.Service, error) {
+func New(ctx context.Context, m map[string]interface{}) (rgrpc.Service, error) {
 	c, err := parseConfig(m)
 	if err != nil {
 		return nil, err
@@ -94,7 +94,7 @@ func New(m map[string]interface{}) (rgrpc.Service, error) {
 		return nil, err
 	}
 
-	provider, err := getProvider(c)
+	provider, err := getProvider(ctx, c)
 	if err != nil {
 		return nil, err
 	}
@@ -104,7 +104,7 @@ func New(m map[string]interface{}) (rgrpc.Service, error) {
 		provider: provider,
 	}
 
-	go service.registerProvider()
+	go service.registerProvider(ctx)
 	return service, nil
 }
 
@@ -129,13 +129,12 @@ func registerMimeTypes(mappingFile string) error {
 	return nil
 }
 
-func (s *service) registerProvider() {
+func (s *service) registerProvider(ctx context.Context) {
 	// Give the appregistry service time to come up
 	// TODO(lopresti) we should register the appproviders after all other microservices
 	time.Sleep(3 * time.Second)
 
-	ctx := context.Background()
-	log := logger.New().With().Int("pid", os.Getpid()).Logger()
+	log := appctx.GetLogger(ctx)
 	pInfo, err := s.provider.GetAppProviderInfo(ctx)
 	if err != nil {
 		log.Error().Err(err).Msgf("error registering app provider: could not get provider info")
@@ -195,7 +194,7 @@ func (s *service) Register(ss *grpc.Server) {
 	providerpb.RegisterProviderAPIServer(ss, s)
 }
 
-func getProvider(c *config) (app.Provider, error) {
+func getProvider(ctx context.Context, c *config) (app.Provider, error) {
 	if f, ok := registry.NewFuncs[c.Driver]; ok {
 		driverConf := c.Drivers[c.Driver]
 		if c.MimeTypes != nil {
@@ -205,7 +204,7 @@ func getProvider(c *config) (app.Provider, error) {
 			}
 			driverConf["mime_types"] = c.MimeTypes
 		}
-		return f(driverConf)
+		return f(ctx, driverConf)
 	}
 	return nil, errtypes.NotFound("driver not found: " + c.Driver)
 }

internal/grpc/services/appregistry/appregistry.go

@@ -63,13 +63,13 @@ func (c *config) init() {
 }
 
 // New creates a new StorageRegistryService.
-func New(m map[string]interface{}) (rgrpc.Service, error) {
+func New(ctx context.Context, m map[string]interface{}) (rgrpc.Service, error) {
 	c, err := parseConfig(m)
 	if err != nil {
 		return nil, err
 	}
 
-	reg, err := getRegistry(c)
+	reg, err := getRegistry(ctx, c)
 	if err != nil {
 		return nil, err
 	}
@@ -90,9 +90,9 @@ func parseConfig(m map[string]interface{}) (*config, error) {
 	return c, nil
 }
 
-func getRegistry(c *config) (app.Registry, error) {
+func getRegistry(ctx context.Context, c *config) (app.Registry, error) {
 	if f, ok := registry.NewFuncs[c.Driver]; ok {
-		return f(c.Drivers[c.Driver])
+		return f(ctx, c.Drivers[c.Driver])
 	}
 	return nil, errtypes.NotFound("appregistrysvc: driver not found: " + c.Driver)
 }

internal/grpc/services/appregistry/appregistry_test.go

@@ -122,7 +122,7 @@ func Test_ListAppProviders(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			rr, err := static.New(map[string]interface{}{"providers": tt.providers, "mime_types": tt.mimeTypes})
+			rr, err := static.New(context.Background(), map[string]interface{}{"providers": tt.providers, "mime_types": tt.mimeTypes})
 			if err != nil {
 				t.Errorf("could not create registry error = %v", err)
 				return
@@ -296,7 +296,7 @@ func Test_GetAppProviders(t *testing.T) {
 		},
 	}
 
-	rr, err := static.New(map[string]interface{}{"providers": providers, "mime_types": mimeTypes})
+	rr, err := static.New(context.Background(), map[string]interface{}{"providers": providers, "mime_types": mimeTypes})
 	if err != nil {
 		t.Errorf("could not create registry error = %v", err)
 		return
@@ -355,7 +355,7 @@ func TestNew(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := New(tt.m)
+			got, err := New(context.Background(), tt.m)
 			if err != nil {
 				assert.Equal(t, tt.wantErr, err.Error())
 				assert.Nil(t, got)

internal/grpc/services/authprovider/authprovider.go

@@ -72,7 +72,7 @@ func parseConfig(m map[string]interface{}) (*config, error) {
 	return c, nil
 }
 
-func getAuthManager(manager string, m map[string]map[string]interface{}) (auth.Manager, *plugin.RevaPlugin, error) {
+func getAuthManager(ctx context.Context, manager string, m map[string]map[string]interface{}) (auth.Manager, *plugin.RevaPlugin, error) {
 	if manager == "" {
 		return nil, nil, errtypes.InternalError("authsvc: driver not configured for auth manager")
 	}
@@ -90,7 +90,7 @@ func getAuthManager(manager string, m map[string]map[string]interface{}) (auth.M
 		return authManager, p, nil
 	} else if _, ok := err.(errtypes.NotFound); ok {
 		if f, ok := registry.NewFuncs[manager]; ok {
-			authmgr, err := f(m[manager])
+			authmgr, err := f(ctx, m[manager])
 			return authmgr, nil, err
 		}
 	} else {
@@ -100,13 +100,13 @@ func getAuthManager(manager string, m map[string]map[string]interface{}) (auth.M
 }
 
 // New returns a new AuthProviderServiceServer.
-func New(m map[string]interface{}) (rgrpc.Service, error) {
+func New(ctx context.Context, m map[string]interface{}) (rgrpc.Service, error) {
 	c, err := parseConfig(m)
 	if err != nil {
 		return nil, err
 	}
 
-	authManager, plug, err := getAuthManager(c.AuthManager, c.AuthManagers)
+	authManager, plug, err := getAuthManager(ctx, c.AuthManager, c.AuthManagers)
 	if err != nil {
 		return nil, err
 	}

internal/grpc/services/authregistry/authregistry.go

@@ -66,15 +66,15 @@ func (c *config) init() {
 }
 
 // New creates a new AuthRegistry.
-func New(m map[string]interface{}) (rgrpc.Service, error) {
+func New(ctx context.Context, m map[string]interface{}) (rgrpc.Service, error) {
 	c, err := parseConfig(m)
 	if err != nil {
 		return nil, err
 	}
 
 	c.init()
 
-	reg, err := getRegistry(c)
+	reg, err := getRegistry(ctx, c)
 	if err != nil {
 		return nil, err
 	}
@@ -94,9 +94,9 @@ func parseConfig(m map[string]interface{}) (*config, error) {
 	return c, nil
 }
 
-func getRegistry(c *config) (auth.Registry, error) {
+func getRegistry(ctx context.Context, c *config) (auth.Registry, error) {
 	if f, ok := registry.NewFuncs[c.Driver]; ok {
-		return f(c.Drivers[c.Driver])
+		return f(ctx, c.Drivers[c.Driver])
 	}
 	return nil, errtypes.NotFound("authregistrysvc: driver not found: " + c.Driver)
 }