Factory like provider?

[joesonw]

Is your feature request related to a problem? Please describe.
current I have this kind of scenario, I have mutiple endpoints registers into fx and wil be mounted to a service

type Endpoint1 struct {
    fx.In
    Logger *zap.Logger // prefer to be automatically provided as logger.Named('Endpoint1')
}

type Endpoint2 struct {
    fx.In
    Logger *zap.Logger   // prefer to be automatically provided as logger.Named('Endpoint2')
}

But all the endpoints receives the same logger. I would like it to invoke some kind of factory method that is aware of what and where an dependency is injected, thus each logger can be named one.

Describe the solution you'd like
A clear and concise description of what you want to happen.

fx.ProvideFactory((*zap.Logger)(nil), func (logger *zap.Logger) {
  return func (contextInfo *fx.FactoryDenepdencyContext) fx.Option {
     in, ok := contextInfo.Target.(interface { GetPath() string })
     if ok {
       return logger.Named(in.GetPath())
     }
     return logger
  }
})

Describe alternatives you've considered
Currently, it's being managed by hard coding.

Is this a breaking change?
No, This will be an additional feature

Additional context
.

[alexisvisco]

Same concerns for us :)

[abhinav]

This is an interesting feature idea. I'll let the maintainers decide their route there, but until then, one thing you can do is this:

Namespace your endpoints into their own Fx modules.
That is, instead of fx.Provide(NewEndpoint1), do:

fx.Module("endpoint1",
  fx.Provide(NewEndpoint1),
)

Once they're in their own modules, you can decorate the logger they receive with fx.Decorate:

fx.Module("endpoint1",
  fx.Provide(..),
  fx.Decorate(func(log *zap.Logger) *zap.Logger {
    return log.With(zap.String("endpoint", "endpoint1"))
  }),
)

The fx.Module will limit the scope of that decoration to just that endpoint.
You can also create a helper to do this for you:

func EndpointLogger(name string) fx.Option {
  fx.Decorate(func(log *zap.Logger) *zap.Logger {
    return log.With(zap.String("endpoint", name))
  })
}

// or even

func ProvideEndpoint(name string, ctor interface{}) fx.Option {
  return fx.Module(name,
    fx.Provide(ctor),
    fx.Decorate(func(log *zap.Logger) *zap.Logger {
      return log.With(zap.String("endpoint", name))
    }),
  )
}

Hope this helps!

[abhinav]

Something with a smaller surface area that might be worth exploring here is some sort of module information struct passed to decorators. Strawman:

type ModuleInfo struct {
  Name string
  Location Location
  // other metadata about the module
}

If a decorator has a ModuleInfo dependency, it will be invoked with information about the module scope where it's being applied.

(This is just a strawman suggestion; not a real feature request.)

[yavor-lulchev]

My way of achieving this up until now:

type Dependency struct{}

type Endpoint struct {
	dep    Dependency
	logger *zap.Logger
}

type EndpointParams struct {
	fx.In

	Dep    Dependency
	Logger *zap.Logger
}

func NewEndpoint(deps EndpointParams) (*Endpoint, error) {
	return &Endpoint{
		dep:    deps.Dep,
		logger: deps.Logger.With(zap.String("ref", "endpoint")),
	}, nil
}