DataFetchingEnvironment getDataLoader Performance issues

[niallo-tyro]

I am having major performance issues with getDataLoader method on the DataFetchingEnvironment. Each request for dfe.getDataLoader("child") seems quick in isolation but if we have 1000 parent objects we end up with a lot of calls to this method. this can turn a 60ms request into a 300ms request

this is an example of the code

  // this method gets called 1000 times. 
   @DgsData(parentType = "parent")
    public CompletableFuture<Child> child(DataFetchingEnvironment dfe) {
        DataLoader<Long, Child> dataLoader = dfe.getDataLoader("child");
        Parent source = dfe.getSource();
        return dataLoader.load(source.getId());
    }

Solutions tired:

 1 -> statically cache the data fetchers. This worked very well but caused issues as i believe the scope of the data loader should be per request. This resulted in our application hanging under moderate load

 2 -> Cache the results of the getDataLoader on thread local. This had similar performance issues. 

My question is,has any one else experienced this and have any solutions?

My next thoughts are Is it possible to define @DgsData or something similar at a context that gives you access to all of the parent object in one go, meaning we only have to call getDataLoader once. some thing like this for example

@DgsData(parentType = "parent")
    public CompletableFuture<Child> child(DataFetchingEnvironment dfe) {
        DataLoader<Long, Child> dataLoader = dfe.getDataLoader("child");
        List<Parent> source = dfe.getSource();
        return dataLoader.load(source.stream().map(Parent::getId).toList());
    }

[Br1tBreaker]

Yes, you are right that the DataLoader should be scoped to a single request, and caching it statically or on a thread local can cause issues under moderate to high load.

One solution to this problem is to batch the data fetching requests, which means instead of making a separate request for each parent object, you can group the parent objects and make a single request to fetch all the child objects related to them. This can significantly reduce the number of calls to the getDataLoader method and improve the performance of your application.

To implement batching, you can create a custom BatchLoader for your data loader that can accept a list of parent IDs and return a list of child objects. Here's an example:
dataLoaderRegistry.register("child", DataLoader.newDataLoader((List parentIds) ->
CompletableFuture.supplyAsync(() -> {
// fetch all child objects for the given parent IDs
List children = childRepository.findByParentIds(parentIds);

// group the child objects by parent ID
Map<Long, List<Child>> childMap = children.stream()
  .collect(Collectors.groupingBy(Child::getParentId));

// create a list of child objects for each parent ID, in the order of the parent IDs
List<List<Child>> result = parentIds.stream()
  .map(childMap::getOrDefault)
  .collect(Collectors.toList());
  
return result;

})
));

In your data fetcher method, you can then retrieve the data loader and call its load method with a list of parent IDs instead of a single parent ID:

@DgsData(parentType = "parent")
public CompletableFuture<List> child(DataFetchingEnvironment dfe) {
DataLoader<Long, List> dataLoader = dfe.getDataLoader("child");
Parent source = dfe.getSource();
return dataLoader.load(Collections.singletonList(source.getId())).thenApply(childLists -> childLists.get(0));
}

This will fetch all the child objects related to the given parent ID and return them as a list.

By batching the data fetching requests, you can reduce the number of calls to the getDataLoader method and improve the performance of your application.

[niallo-tyro]

Thanks, will try this out and let you know