diff --git a/src/main/java/org/dataloader/DataLoader.java b/src/main/java/org/dataloader/DataLoader.java
index d03e5ac..7a50619 100644
--- a/src/main/java/org/dataloader/DataLoader.java
+++ b/src/main/java/org/dataloader/DataLoader.java
@@ -58,7 +58,7 @@
  * <p>
  * A call to the batch loader might result in individual exception failures for item with the returned list.  if
  * you want to capture these specific item failures then use {@link org.dataloader.Try} as a return value and
- * create the data loader with {@link #newDataLoaderWithTry(BatchLoader)} form.  The Try values will be interpreted
+ * create the data loader with {@link DataLoaderFactory#newDataLoaderWithTry(BatchLoader)} form.  The Try values will be interpreted
  * as either success values or cause the {@link #load(Object)} promise to complete exceptionally.
  *
  * @param <K> type parameter indicating the type of the data load keys
@@ -70,6 +70,7 @@
 @NullMarked
 public class DataLoader<K, V> {
 
+    private final @Nullable String name;
     private final DataLoaderHelper<K, V> helper;
     private final StatisticsCollector stats;
     private final CacheMap<Object, V> futureCache;
@@ -77,317 +78,13 @@ public class DataLoader<K, V> {
     private final DataLoaderOptions options;
     private final Object batchLoadFunction;
 
-    /**
-     * Creates new DataLoader with the specified batch loader function and default options
-     * (batching, caching and unlimited batch size).
-     *
-     * @param batchLoadFunction the batch load function to use
-     * @param <K>               the key type
-     * @param <V>               the value type
-     * @return a new DataLoader
-     * @deprecated use {@link DataLoaderFactory} instead
-     */
-    @Deprecated
-    public static <K, V> DataLoader<K, V> newDataLoader(BatchLoader<K, V> batchLoadFunction) {
-        return newDataLoader(batchLoadFunction, null);
-    }
-
-    /**
-     * Creates new DataLoader with the specified batch loader function with the provided options
-     *
-     * @param batchLoadFunction the batch load function to use
-     * @param options           the options to use
-     * @param <K>               the key type
-     * @param <V>               the value type
-     * @return a new DataLoader
-     * @deprecated use {@link DataLoaderFactory} instead
-     */
-    @Deprecated
-    public static <K, V> DataLoader<K, V> newDataLoader(BatchLoader<K, V> batchLoadFunction, @Nullable DataLoaderOptions options) {
-        return DataLoaderFactory.mkDataLoader(batchLoadFunction, options);
-    }
-
-    /**
-     * Creates new DataLoader with the specified batch loader function and default options
-     * (batching, caching and unlimited batch size) where the batch loader function returns a list of
-     * {@link org.dataloader.Try} objects.
-     * <p>
-     * If it's important you to know the exact status of each item in a batch call and whether it threw exceptions then
-     * you can use this form to create the data loader.
-     * <p>
-     * Using Try objects allows you to capture a value returned or an exception that might
-     * have occurred trying to get a value. .
-     *
-     * @param batchLoadFunction the batch load function to use that uses {@link org.dataloader.Try} objects
-     * @param <K>               the key type
-     * @param <V>               the value type
-     * @return a new DataLoader
-     * @deprecated use {@link DataLoaderFactory} instead
-     */
-    @Deprecated
-    public static <K, V> DataLoader<K, V> newDataLoaderWithTry(BatchLoader<K, Try<V>> batchLoadFunction) {
-        return newDataLoaderWithTry(batchLoadFunction, null);
-    }
-
-    /**
-     * Creates new DataLoader with the specified batch loader function and with the provided options
-     * where the batch loader function returns a list of
-     * {@link org.dataloader.Try} objects.
-     *
-     * @param batchLoadFunction the batch load function to use that uses {@link org.dataloader.Try} objects
-     * @param options           the options to use
-     * @param <K>               the key type
-     * @param <V>               the value type
-     * @return a new DataLoader
-     * @see DataLoaderFactory#newDataLoaderWithTry(BatchLoader)
-     * @deprecated use {@link DataLoaderFactory} instead
-     */
-    @Deprecated
-    public static <K, V> DataLoader<K, V> newDataLoaderWithTry(BatchLoader<K, Try<V>> batchLoadFunction, @Nullable DataLoaderOptions options) {
-        return DataLoaderFactory.mkDataLoader(batchLoadFunction, options);
-    }
-
-    /**
-     * Creates new DataLoader with the specified batch loader function and default options
-     * (batching, caching and unlimited batch size).
-     *
-     * @param batchLoadFunction the batch load function to use
-     * @param <K>               the key type
-     * @param <V>               the value type
-     * @return a new DataLoader
-     * @deprecated use {@link DataLoaderFactory} instead
-     */
-    @Deprecated
-    public static <K, V> DataLoader<K, V> newDataLoader(BatchLoaderWithContext<K, V> batchLoadFunction) {
-        return newDataLoader(batchLoadFunction, null);
-    }
-
-    /**
-     * Creates new DataLoader with the specified batch loader function with the provided options
-     *
-     * @param batchLoadFunction the batch load function to use
-     * @param options           the options to use
-     * @param <K>               the key type
-     * @param <V>               the value type
-     * @return a new DataLoader
-     * @deprecated use {@link DataLoaderFactory} instead
-     */
-    @Deprecated
-    public static <K, V> DataLoader<K, V> newDataLoader(BatchLoaderWithContext<K, V> batchLoadFunction, @Nullable DataLoaderOptions options) {
-        return DataLoaderFactory.mkDataLoader(batchLoadFunction, options);
-    }
-
-    /**
-     * Creates new DataLoader with the specified batch loader function and default options
-     * (batching, caching and unlimited batch size) where the batch loader function returns a list of
-     * {@link org.dataloader.Try} objects.
-     * <p>
-     * If it's important you to know the exact status of each item in a batch call and whether it threw exceptions then
-     * you can use this form to create the data loader.
-     * <p>
-     * Using Try objects allows you to capture a value returned or an exception that might
-     * have occurred trying to get a value. .
-     *
-     * @param batchLoadFunction the batch load function to use that uses {@link org.dataloader.Try} objects
-     * @param <K>               the key type
-     * @param <V>               the value type
-     * @return a new DataLoader
-     * @deprecated use {@link DataLoaderFactory} instead
-     */
-    @Deprecated
-    public static <K, V> DataLoader<K, V> newDataLoaderWithTry(BatchLoaderWithContext<K, Try<V>> batchLoadFunction) {
-        return newDataLoaderWithTry(batchLoadFunction, null);
-    }
-
-    /**
-     * Creates new DataLoader with the specified batch loader function and with the provided options
-     * where the batch loader function returns a list of
-     * {@link org.dataloader.Try} objects.
-     *
-     * @param batchLoadFunction the batch load function to use that uses {@link org.dataloader.Try} objects
-     * @param options           the options to use
-     * @param <K>               the key type
-     * @param <V>               the value type
-     * @return a new DataLoader
-     * @see DataLoaderFactory#newDataLoaderWithTry(BatchLoader)
-     * @deprecated use {@link DataLoaderFactory} instead
-     */
-    @Deprecated
-    public static <K, V> DataLoader<K, V> newDataLoaderWithTry(BatchLoaderWithContext<K, Try<V>> batchLoadFunction, @Nullable DataLoaderOptions options) {
-        return DataLoaderFactory.mkDataLoader(batchLoadFunction, options);
-    }
-
-    /**
-     * Creates new DataLoader with the specified batch loader function and default options
-     * (batching, caching and unlimited batch size).
-     *
-     * @param batchLoadFunction the batch load function to use
-     * @param <K>               the key type
-     * @param <V>               the value type
-     * @return a new DataLoader
-     * @deprecated use {@link DataLoaderFactory} instead
-     */
-    @Deprecated
-    public static <K, V> DataLoader<K, V> newMappedDataLoader(MappedBatchLoader<K, V> batchLoadFunction) {
-        return newMappedDataLoader(batchLoadFunction, null);
-    }
-
-    /**
-     * Creates new DataLoader with the specified batch loader function with the provided options
-     *
-     * @param batchLoadFunction the batch load function to use
-     * @param options           the options to use
-     * @param <K>               the key type
-     * @param <V>               the value type
-     * @return a new DataLoader
-     * @deprecated use {@link DataLoaderFactory} instead
-     */
-    @Deprecated
-    public static <K, V> DataLoader<K, V> newMappedDataLoader(MappedBatchLoader<K, V> batchLoadFunction, @Nullable DataLoaderOptions options) {
-        return DataLoaderFactory.mkDataLoader(batchLoadFunction, options);
-    }
-
-    /**
-     * Creates new DataLoader with the specified batch loader function and default options
-     * (batching, caching and unlimited batch size) where the batch loader function returns a list of
-     * {@link org.dataloader.Try} objects.
-     * <p>
-     * If it's important you to know the exact status of each item in a batch call and whether it threw exceptions then
-     * you can use this form to create the data loader.
-     * <p>
-     * Using Try objects allows you to capture a value returned or an exception that might
-     * have occurred trying to get a value. .
-     * <p>
-     *
-     * @param batchLoadFunction the batch load function to use that uses {@link org.dataloader.Try} objects
-     * @param <K>               the key type
-     * @param <V>               the value type
-     * @return a new DataLoader
-     * @deprecated use {@link DataLoaderFactory} instead
-     */
-    @Deprecated
-    public static <K, V> DataLoader<K, V> newMappedDataLoaderWithTry(MappedBatchLoader<K, Try<V>> batchLoadFunction) {
-        return newMappedDataLoaderWithTry(batchLoadFunction, null);
-    }
-
-    /**
-     * Creates new DataLoader with the specified batch loader function and with the provided options
-     * where the batch loader function returns a list of
-     * {@link org.dataloader.Try} objects.
-     *
-     * @param batchLoadFunction the batch load function to use that uses {@link org.dataloader.Try} objects
-     * @param options           the options to use
-     * @param <K>               the key type
-     * @param <V>               the value type
-     * @return a new DataLoader
-     * @see DataLoaderFactory#newDataLoaderWithTry(BatchLoader)
-     * @deprecated use {@link DataLoaderFactory} instead
-     */
-    @Deprecated
-    public static <K, V> DataLoader<K, V> newMappedDataLoaderWithTry(MappedBatchLoader<K, Try<V>> batchLoadFunction, @Nullable DataLoaderOptions options) {
-        return DataLoaderFactory.mkDataLoader(batchLoadFunction, options);
-    }
-
-    /**
-     * Creates new DataLoader with the specified mapped batch loader function and default options
-     * (batching, caching and unlimited batch size).
-     *
-     * @param batchLoadFunction the batch load function to use
-     * @param <K>               the key type
-     * @param <V>               the value type
-     * @return a new DataLoader
-     * @deprecated use {@link DataLoaderFactory} instead
-     */
-    @Deprecated
-    public static <K, V> DataLoader<K, V> newMappedDataLoader(MappedBatchLoaderWithContext<K, V> batchLoadFunction) {
-        return newMappedDataLoader(batchLoadFunction, null);
-    }
-
-    /**
-     * Creates new DataLoader with the specified batch loader function with the provided options
-     *
-     * @param batchLoadFunction the batch load function to use
-     * @param options           the options to use
-     * @param <K>               the key type
-     * @param <V>               the value type
-     * @return a new DataLoader
-     * @deprecated use {@link DataLoaderFactory} instead
-     */
-    @Deprecated
-    public static <K, V> DataLoader<K, V> newMappedDataLoader(MappedBatchLoaderWithContext<K, V> batchLoadFunction, @Nullable DataLoaderOptions options) {
-        return DataLoaderFactory.mkDataLoader(batchLoadFunction, options);
-    }
-
-    /**
-     * Creates new DataLoader with the specified batch loader function and default options
-     * (batching, caching and unlimited batch size) where the batch loader function returns a list of
-     * {@link org.dataloader.Try} objects.
-     * <p>
-     * If it's important you to know the exact status of each item in a batch call and whether it threw exceptions then
-     * you can use this form to create the data loader.
-     * <p>
-     * Using Try objects allows you to capture a value returned or an exception that might
-     * have occurred trying to get a value. .
-     *
-     * @param batchLoadFunction the batch load function to use that uses {@link org.dataloader.Try} objects
-     * @param <K>               the key type
-     * @param <V>               the value type
-     * @return a new DataLoader
-     * @deprecated use {@link DataLoaderFactory} instead
-     */
-    @Deprecated
-    public static <K, V> DataLoader<K, V> newMappedDataLoaderWithTry(MappedBatchLoaderWithContext<K, Try<V>> batchLoadFunction) {
-        return newMappedDataLoaderWithTry(batchLoadFunction, null);
-    }
-
-    /**
-     * Creates new DataLoader with the specified batch loader function and with the provided options
-     * where the batch loader function returns a list of
-     * {@link org.dataloader.Try} objects.
-     *
-     * @param batchLoadFunction the batch load function to use that uses {@link org.dataloader.Try} objects
-     * @param options           the options to use
-     * @param <K>               the key type
-     * @param <V>               the value type
-     * @return a new DataLoader
-     * @see DataLoaderFactory#newDataLoaderWithTry(BatchLoader)
-     * @deprecated use {@link DataLoaderFactory} instead
-     */
-    @Deprecated
-    public static <K, V> DataLoader<K, V> newMappedDataLoaderWithTry(MappedBatchLoaderWithContext<K, Try<V>> batchLoadFunction, @Nullable DataLoaderOptions options) {
-        return DataLoaderFactory.mkDataLoader(batchLoadFunction, options);
-    }
-
-    /**
-     * Creates a new data loader with the provided batch load function, and default options.
-     *
-     * @param batchLoadFunction the batch load function to use
-     * @deprecated use {@link DataLoaderFactory} instead
-     */
-    @Deprecated
-    public DataLoader(BatchLoader<K, V> batchLoadFunction) {
-        this((Object) batchLoadFunction, null);
-    }
-
-    /**
-     * Creates a new data loader with the provided batch load function and options.
-     *
-     * @param batchLoadFunction the batch load function to use
-     * @param options           the batch load options
-     * @deprecated use {@link DataLoaderFactory} instead
-     */
-    @Deprecated
-    public DataLoader(BatchLoader<K, V> batchLoadFunction, @Nullable DataLoaderOptions options) {
-        this((Object) batchLoadFunction, options);
-    }
-
     @VisibleForTesting
-    DataLoader(Object batchLoadFunction, @Nullable DataLoaderOptions options) {
-        this(batchLoadFunction, options, Clock.systemUTC());
+    DataLoader(@Nullable String name, Object batchLoadFunction, @Nullable DataLoaderOptions options) {
+        this(name, batchLoadFunction, options, Clock.systemUTC());
     }
 
     @VisibleForTesting
-    DataLoader(Object batchLoadFunction, @Nullable DataLoaderOptions options, Clock clock) {
+    DataLoader(@Nullable String name, Object batchLoadFunction, @Nullable DataLoaderOptions options, Clock clock) {
         DataLoaderOptions loaderOptions = options == null ? new DataLoaderOptions() : options;
         this.futureCache = determineFutureCache(loaderOptions);
         this.valueCache = determineValueCache(loaderOptions);
@@ -395,6 +92,7 @@ public DataLoader(BatchLoader<K, V> batchLoadFunction, @Nullable DataLoaderOptio
         this.stats = nonNull(loaderOptions.getStatisticsCollector());
         this.batchLoadFunction = nonNull(batchLoadFunction);
         this.options = loaderOptions;
+        this.name = name;
 
         this.helper = new DataLoaderHelper<>(this, batchLoadFunction, loaderOptions, this.futureCache, this.valueCache, this.stats, clock);
     }
@@ -410,6 +108,13 @@ private ValueCache<K, V> determineValueCache(DataLoaderOptions loaderOptions) {
         return (ValueCache<K, V>) loaderOptions.valueCache().orElseGet(ValueCache::defaultValueCache);
     }
 
+    /**
+     * @return the name of the DataLoader which can be null
+     */
+    public @Nullable String getName() {
+        return name;
+    }
+
     /**
      * @return the options used to build this {@link DataLoader}
      */
@@ -787,4 +492,11 @@ public ValueCache<K, V> getValueCache() {
         return valueCache;
     }
 
+    @Override
+    public String toString() {
+        return "DataLoader{" +
+                "name='" + name + '\'' +
+                ", stats=" + stats +
+                '}';
+    }
 }
diff --git a/src/main/java/org/dataloader/DataLoaderFactory.java b/src/main/java/org/dataloader/DataLoaderFactory.java
index ef1a287..a95e158 100644
--- a/src/main/java/org/dataloader/DataLoaderFactory.java
+++ b/src/main/java/org/dataloader/DataLoaderFactory.java
@@ -3,6 +3,8 @@
 import org.dataloader.annotations.PublicApi;
 import org.jspecify.annotations.Nullable;
 
+import static org.dataloader.impl.Assertions.nonNull;
+
 /**
  * A factory class to create {@link DataLoader}s
  */
@@ -23,6 +25,20 @@ public static <K, V> DataLoader<K, V> newDataLoader(BatchLoader<K, V> batchLoadF
         return newDataLoader(batchLoadFunction, null);
     }
 
+    /**
+     * Creates new DataLoader with the specified batch loader function and default options
+     * (batching, caching and unlimited batch size).
+     *
+     * @param name              the name to use
+     * @param batchLoadFunction the batch load function to use
+     * @param <K>               the key type
+     * @param <V>               the value type
+     * @return a new DataLoader
+     */
+    public static <K, V> DataLoader<K, V> newDataLoader(String name, BatchLoader<K, V> batchLoadFunction) {
+        return newDataLoader(name, batchLoadFunction, null);
+    }
+
     /**
      * Creates new DataLoader with the specified batch loader function with the provided options
      *
@@ -33,7 +49,21 @@ public static <K, V> DataLoader<K, V> newDataLoader(BatchLoader<K, V> batchLoadF
      * @return a new DataLoader
      */
     public static <K, V> DataLoader<K, V> newDataLoader(BatchLoader<K, V> batchLoadFunction, DataLoaderOptions options) {
-        return mkDataLoader(batchLoadFunction, options);
+        return mkDataLoader(null, batchLoadFunction, options);
+    }
+
+    /**
+     * Creates new DataLoader with the specified batch loader function with the provided options
+     *
+     * @param name              the name to use
+     * @param batchLoadFunction the batch load function to use
+     * @param options           the options to use
+     * @param <K>               the key type
+     * @param <V>               the value type
+     * @return a new DataLoader
+     */
+    public static <K, V> DataLoader<K, V> newDataLoader(String name, BatchLoader<K, V> batchLoadFunction, DataLoaderOptions options) {
+        return mkDataLoader(nonNull(name), batchLoadFunction, options);
     }
 
     /**
@@ -69,7 +99,24 @@ public static <K, V> DataLoader<K, V> newDataLoaderWithTry(BatchLoader<K, Try<V>
      * @see #newDataLoaderWithTry(BatchLoader)
      */
     public static <K, V> DataLoader<K, V> newDataLoaderWithTry(BatchLoader<K, Try<V>> batchLoadFunction, DataLoaderOptions options) {
-        return mkDataLoader(batchLoadFunction, options);
+        return mkDataLoader(null, batchLoadFunction, options);
+    }
+
+    /**
+     * Creates new DataLoader with the specified batch loader function and with the provided options
+     * where the batch loader function returns a list of
+     * {@link org.dataloader.Try} objects.
+     *
+     * @param name              the name to use
+     * @param batchLoadFunction the batch load function to use that uses {@link org.dataloader.Try} objects
+     * @param options           the options to use
+     * @param <K>               the key type
+     * @param <V>               the value type
+     * @return a new DataLoader
+     * @see #newDataLoaderWithTry(BatchLoader)
+     */
+    public static <K, V> DataLoader<K, V> newDataLoaderWithTry(String name, BatchLoader<K, Try<V>> batchLoadFunction, DataLoaderOptions options) {
+        return mkDataLoader(nonNull(name), batchLoadFunction, options);
     }
 
     /**
@@ -95,7 +142,21 @@ public static <K, V> DataLoader<K, V> newDataLoader(BatchLoaderWithContext<K, V>
      * @return a new DataLoader
      */
     public static <K, V> DataLoader<K, V> newDataLoader(BatchLoaderWithContext<K, V> batchLoadFunction, DataLoaderOptions options) {
-        return mkDataLoader(batchLoadFunction, options);
+        return mkDataLoader(null, batchLoadFunction, options);
+    }
+
+    /**
+     * Creates new DataLoader with the specified batch loader function with the provided options
+     *
+     * @param name              the name to use
+     * @param batchLoadFunction the batch load function to use
+     * @param options           the options to use
+     * @param <K>               the key type
+     * @param <V>               the value type
+     * @return a new DataLoader
+     */
+    public static <K, V> DataLoader<K, V> newDataLoader(String name, BatchLoaderWithContext<K, V> batchLoadFunction, DataLoaderOptions options) {
+        return mkDataLoader(nonNull(name), batchLoadFunction, options);
     }
 
     /**
@@ -131,7 +192,24 @@ public static <K, V> DataLoader<K, V> newDataLoaderWithTry(BatchLoaderWithContex
      * @see #newDataLoaderWithTry(BatchLoader)
      */
     public static <K, V> DataLoader<K, V> newDataLoaderWithTry(BatchLoaderWithContext<K, Try<V>> batchLoadFunction, DataLoaderOptions options) {
-        return mkDataLoader(batchLoadFunction, options);
+        return mkDataLoader(null, batchLoadFunction, options);
+    }
+
+    /**
+     * Creates new DataLoader with the specified batch loader function and with the provided options
+     * where the batch loader function returns a list of
+     * {@link org.dataloader.Try} objects.
+     *
+     * @param name              the name to use
+     * @param batchLoadFunction the batch load function to use that uses {@link org.dataloader.Try} objects
+     * @param options           the options to use
+     * @param <K>               the key type
+     * @param <V>               the value type
+     * @return a new DataLoader
+     * @see #newDataLoaderWithTry(BatchLoader)
+     */
+    public static <K, V> DataLoader<K, V> newDataLoaderWithTry(String name, BatchLoaderWithContext<K, Try<V>> batchLoadFunction, DataLoaderOptions options) {
+        return mkDataLoader(nonNull(name), batchLoadFunction, options);
     }
 
     /**
@@ -157,7 +235,20 @@ public static <K, V> DataLoader<K, V> newMappedDataLoader(MappedBatchLoader<K, V
      * @return a new DataLoader
      */
     public static <K, V> DataLoader<K, V> newMappedDataLoader(MappedBatchLoader<K, V> batchLoadFunction, @Nullable DataLoaderOptions options) {
-        return mkDataLoader(batchLoadFunction, options);
+        return mkDataLoader(null, batchLoadFunction, options);
+    }
+
+    /**
+     * Creates new DataLoader with the specified batch loader function with the provided options
+     *
+     * @param batchLoadFunction the batch load function to use
+     * @param options           the options to use
+     * @param <K>               the key type
+     * @param <V>               the value type
+     * @return a new DataLoader
+     */
+    public static <K, V> DataLoader<K, V> newMappedDataLoader(String name, MappedBatchLoader<K, V> batchLoadFunction, @Nullable DataLoaderOptions options) {
+        return mkDataLoader(nonNull(name), batchLoadFunction, options);
     }
 
     /**
@@ -194,7 +285,24 @@ public static <K, V> DataLoader<K, V> newMappedDataLoaderWithTry(MappedBatchLoad
      * @see #newDataLoaderWithTry(BatchLoader)
      */
     public static <K, V> DataLoader<K, V> newMappedDataLoaderWithTry(MappedBatchLoader<K, Try<V>> batchLoadFunction, DataLoaderOptions options) {
-        return mkDataLoader(batchLoadFunction, options);
+        return mkDataLoader(null, batchLoadFunction, options);
+    }
+
+    /**
+     * Creates new DataLoader with the specified batch loader function and with the provided options
+     * where the batch loader function returns a list of
+     * {@link org.dataloader.Try} objects.
+     *
+     * @param name              the name to use
+     * @param batchLoadFunction the batch load function to use that uses {@link org.dataloader.Try} objects
+     * @param options           the options to use
+     * @param <K>               the key type
+     * @param <V>               the value type
+     * @return a new DataLoader
+     * @see #newDataLoaderWithTry(BatchLoader)
+     */
+    public static <K, V> DataLoader<K, V> newMappedDataLoaderWithTry(String name, MappedBatchLoader<K, Try<V>> batchLoadFunction, DataLoaderOptions options) {
+        return mkDataLoader(nonNull(name), batchLoadFunction, options);
     }
 
     /**
@@ -220,7 +328,21 @@ public static <K, V> DataLoader<K, V> newMappedDataLoader(MappedBatchLoaderWithC
      * @return a new DataLoader
      */
     public static <K, V> DataLoader<K, V> newMappedDataLoader(MappedBatchLoaderWithContext<K, V> batchLoadFunction, DataLoaderOptions options) {
-        return mkDataLoader(batchLoadFunction, options);
+        return mkDataLoader(null, batchLoadFunction, options);
+    }
+
+    /**
+     * Creates new DataLoader with the specified batch loader function with the provided options
+     *
+     * @param name              the name to use
+     * @param batchLoadFunction the batch load function to use
+     * @param options           the options to use
+     * @param <K>               the key type
+     * @param <V>               the value type
+     * @return a new DataLoader
+     */
+    public static <K, V> DataLoader<K, V> newMappedDataLoader(String name, MappedBatchLoaderWithContext<K, V> batchLoadFunction, DataLoaderOptions options) {
+        return mkDataLoader(nonNull(name), batchLoadFunction, options);
     }
 
     /**
@@ -256,7 +378,24 @@ public static <K, V> DataLoader<K, V> newMappedDataLoaderWithTry(MappedBatchLoad
      * @see #newDataLoaderWithTry(BatchLoader)
      */
     public static <K, V> DataLoader<K, V> newMappedDataLoaderWithTry(MappedBatchLoaderWithContext<K, Try<V>> batchLoadFunction, DataLoaderOptions options) {
-        return mkDataLoader(batchLoadFunction, options);
+        return mkDataLoader(null, batchLoadFunction, options);
+    }
+
+    /**
+     * Creates new DataLoader with the specified batch loader function and with the provided options
+     * where the batch loader function returns a list of
+     * {@link org.dataloader.Try} objects.
+     *
+     * @param name              the name to use
+     * @param batchLoadFunction the batch load function to use that uses {@link org.dataloader.Try} objects
+     * @param options           the options to use
+     * @param <K>               the key type
+     * @param <V>               the value type
+     * @return a new DataLoader
+     * @see #newDataLoaderWithTry(BatchLoader)
+     */
+    public static <K, V> DataLoader<K, V> newMappedDataLoaderWithTry(String name, MappedBatchLoaderWithContext<K, Try<V>> batchLoadFunction, DataLoaderOptions options) {
+        return mkDataLoader(nonNull(name), batchLoadFunction, options);
     }
 
     /**
@@ -282,7 +421,21 @@ public static <K, V> DataLoader<K, V> newPublisherDataLoader(BatchPublisher<K, V
      * @return a new DataLoader
      */
     public static <K, V> DataLoader<K, V> newPublisherDataLoader(BatchPublisher<K, V> batchLoadFunction, DataLoaderOptions options) {
-        return mkDataLoader(batchLoadFunction, options);
+        return mkDataLoader(null, batchLoadFunction, options);
+    }
+
+    /**
+     * Creates new DataLoader with the specified batch loader function with the provided options
+     *
+     * @param name              the name to use
+     * @param batchLoadFunction the batch load function to use
+     * @param options           the options to use
+     * @param <K>               the key type
+     * @param <V>               the value type
+     * @return a new DataLoader
+     */
+    public static <K, V> DataLoader<K, V> newPublisherDataLoader(String name, BatchPublisher<K, V> batchLoadFunction, DataLoaderOptions options) {
+        return mkDataLoader(nonNull(name), batchLoadFunction, options);
     }
 
     /**
@@ -318,7 +471,24 @@ public static <K, V> DataLoader<K, V> newPublisherDataLoaderWithTry(BatchPublish
      * @see #newDataLoaderWithTry(BatchLoader)
      */
     public static <K, V> DataLoader<K, V> newPublisherDataLoaderWithTry(BatchPublisher<K, Try<V>> batchLoadFunction, DataLoaderOptions options) {
-        return mkDataLoader(batchLoadFunction, options);
+        return mkDataLoader(null, batchLoadFunction, options);
+    }
+
+    /**
+     * Creates new DataLoader with the specified batch loader function and with the provided options
+     * where the batch loader function returns a list of
+     * {@link org.dataloader.Try} objects.
+     *
+     * @param name              the name to use
+     * @param batchLoadFunction the batch load function to use that uses {@link org.dataloader.Try} objects
+     * @param options           the options to use
+     * @param <K>               the key type
+     * @param <V>               the value type
+     * @return a new DataLoader
+     * @see #newDataLoaderWithTry(BatchLoader)
+     */
+    public static <K, V> DataLoader<K, V> newPublisherDataLoaderWithTry(String name, BatchPublisher<K, Try<V>> batchLoadFunction, DataLoaderOptions options) {
+        return mkDataLoader(nonNull(name), batchLoadFunction, options);
     }
 
     /**
@@ -344,7 +514,21 @@ public static <K, V> DataLoader<K, V> newPublisherDataLoader(BatchPublisherWithC
      * @return a new DataLoader
      */
     public static <K, V> DataLoader<K, V> newPublisherDataLoader(BatchPublisherWithContext<K, V> batchLoadFunction, DataLoaderOptions options) {
-        return mkDataLoader(batchLoadFunction, options);
+        return mkDataLoader(null, batchLoadFunction, options);
+    }
+
+    /**
+     * Creates new DataLoader with the specified batch loader function with the provided options
+     *
+     * @param name              the name to use
+     * @param batchLoadFunction the batch load function to use
+     * @param options           the options to use
+     * @param <K>               the key type
+     * @param <V>               the value type
+     * @return a new DataLoader
+     */
+    public static <K, V> DataLoader<K, V> newPublisherDataLoader(String name, BatchPublisherWithContext<K, V> batchLoadFunction, DataLoaderOptions options) {
+        return mkDataLoader(nonNull(name), batchLoadFunction, options);
     }
 
     /**
@@ -380,7 +564,24 @@ public static <K, V> DataLoader<K, V> newPublisherDataLoaderWithTry(BatchPublish
      * @see #newPublisherDataLoaderWithTry(BatchPublisher)
      */
     public static <K, V> DataLoader<K, V> newPublisherDataLoaderWithTry(BatchPublisherWithContext<K, Try<V>> batchLoadFunction, DataLoaderOptions options) {
-        return mkDataLoader(batchLoadFunction, options);
+        return mkDataLoader(null, batchLoadFunction, options);
+    }
+
+    /**
+     * Creates new DataLoader with the specified batch loader function and with the provided options
+     * where the batch loader function returns a list of
+     * {@link org.dataloader.Try} objects.
+     *
+     * @param name              the name to use
+     * @param batchLoadFunction the batch load function to use that uses {@link org.dataloader.Try} objects
+     * @param options           the options to use
+     * @param <K>               the key type
+     * @param <V>               the value type
+     * @return a new DataLoader
+     * @see #newPublisherDataLoaderWithTry(BatchPublisher)
+     */
+    public static <K, V> DataLoader<K, V> newPublisherDataLoaderWithTry(String name, BatchPublisherWithContext<K, Try<V>> batchLoadFunction, DataLoaderOptions options) {
+        return mkDataLoader(nonNull(name), batchLoadFunction, options);
     }
 
     /**
@@ -406,7 +607,21 @@ public static <K, V> DataLoader<K, V> newMappedPublisherDataLoader(MappedBatchPu
      * @return a new DataLoader
      */
     public static <K, V> DataLoader<K, V> newMappedPublisherDataLoader(MappedBatchPublisher<K, V> batchLoadFunction, DataLoaderOptions options) {
-        return mkDataLoader(batchLoadFunction, options);
+        return mkDataLoader(null, batchLoadFunction, options);
+    }
+
+    /**
+     * Creates new DataLoader with the specified batch loader function with the provided options
+     *
+     * @param name              the name to use
+     * @param batchLoadFunction the batch load function to use
+     * @param options           the options to use
+     * @param <K>               the key type
+     * @param <V>               the value type
+     * @return a new DataLoader
+     */
+    public static <K, V> DataLoader<K, V> newMappedPublisherDataLoader(String name, MappedBatchPublisher<K, V> batchLoadFunction, DataLoaderOptions options) {
+        return mkDataLoader(nonNull(name), batchLoadFunction, options);
     }
 
     /**
@@ -442,7 +657,24 @@ public static <K, V> DataLoader<K, V> newMappedPublisherDataLoaderWithTry(Mapped
      * @see #newDataLoaderWithTry(BatchLoader)
      */
     public static <K, V> DataLoader<K, V> newMappedPublisherDataLoaderWithTry(MappedBatchPublisher<K, Try<V>> batchLoadFunction, DataLoaderOptions options) {
-        return mkDataLoader(batchLoadFunction, options);
+        return mkDataLoader(null, batchLoadFunction, options);
+    }
+
+    /**
+     * Creates new DataLoader with the specified batch loader function and with the provided options
+     * where the batch loader function returns a list of
+     * {@link org.dataloader.Try} objects.
+     *
+     * @param name              the name to use
+     * @param batchLoadFunction the batch load function to use that uses {@link org.dataloader.Try} objects
+     * @param options           the options to use
+     * @param <K>               the key type
+     * @param <V>               the value type
+     * @return a new DataLoader
+     * @see #newDataLoaderWithTry(BatchLoader)
+     */
+    public static <K, V> DataLoader<K, V> newMappedPublisherDataLoaderWithTry(String name, MappedBatchPublisher<K, Try<V>> batchLoadFunction, DataLoaderOptions options) {
+        return mkDataLoader(nonNull(name), batchLoadFunction, options);
     }
 
     /**
@@ -468,7 +700,21 @@ public static <K, V> DataLoader<K, V> newMappedPublisherDataLoader(MappedBatchPu
      * @return a new DataLoader
      */
     public static <K, V> DataLoader<K, V> newMappedPublisherDataLoader(MappedBatchPublisherWithContext<K, V> batchLoadFunction, DataLoaderOptions options) {
-        return mkDataLoader(batchLoadFunction, options);
+        return mkDataLoader(null, batchLoadFunction, options);
+    }
+
+    /**
+     * Creates new DataLoader with the specified batch loader function with the provided options
+     *
+     * @param name              the name to use
+     * @param batchLoadFunction the batch load function to use
+     * @param options           the options to use
+     * @param <K>               the key type
+     * @param <V>               the value type
+     * @return a new DataLoader
+     */
+    public static <K, V> DataLoader<K, V> newMappedPublisherDataLoader(String name, MappedBatchPublisherWithContext<K, V> batchLoadFunction, DataLoaderOptions options) {
+        return mkDataLoader(nonNull(name), batchLoadFunction, options);
     }
 
     /**
@@ -504,11 +750,28 @@ public static <K, V> DataLoader<K, V> newMappedPublisherDataLoaderWithTry(Mapped
      * @see #newMappedPublisherDataLoaderWithTry(MappedBatchPublisher)
      */
     public static <K, V> DataLoader<K, V> newMappedPublisherDataLoaderWithTry(MappedBatchPublisherWithContext<K, Try<V>> batchLoadFunction, DataLoaderOptions options) {
-        return mkDataLoader(batchLoadFunction, options);
+        return mkDataLoader(null, batchLoadFunction, options);
     }
 
-    static <K, V> DataLoader<K, V> mkDataLoader(Object batchLoadFunction, DataLoaderOptions options) {
-        return new DataLoader<>(batchLoadFunction, options);
+    /**
+     * Creates new DataLoader with the specified batch loader function and with the provided options
+     * where the batch loader function returns a list of
+     * {@link org.dataloader.Try} objects.
+     *
+     * @param name              the name to use
+     * @param batchLoadFunction the batch load function to use that uses {@link org.dataloader.Try} objects
+     * @param options           the options to use
+     * @param <K>               the key type
+     * @param <V>               the value type
+     * @return a new DataLoader
+     * @see #newMappedPublisherDataLoaderWithTry(MappedBatchPublisher)
+     */
+    public static <K, V> DataLoader<K, V> newMappedPublisherDataLoaderWithTry(String name, MappedBatchPublisherWithContext<K, Try<V>> batchLoadFunction, DataLoaderOptions options) {
+        return mkDataLoader(nonNull(name), batchLoadFunction, options);
+    }
+
+    static <K, V> DataLoader<K, V> mkDataLoader(@Nullable String name, Object batchLoadFunction, @Nullable DataLoaderOptions options) {
+        return new DataLoader<>(name, batchLoadFunction, options);
     }
 
     /**
@@ -541,6 +804,7 @@ public static <K, V> Builder<K, V> builder(DataLoader<K, V> dataLoader) {
      * @param <V> the value type
      */
     public static class Builder<K, V> {
+        String name;
         Object batchLoadFunction;
         DataLoaderOptions options = DataLoaderOptions.newOptions();
 
@@ -548,12 +812,13 @@ public static class Builder<K, V> {
         }
 
         Builder(DataLoader<?, ?> dataLoader) {
+            this.name = dataLoader.getName();
             this.batchLoadFunction = dataLoader.getBatchLoadFunction();
             this.options = dataLoader.getOptions();
         }
 
-        public Builder<K, V> batchLoadFunction(Object batchLoadFunction) {
-            this.batchLoadFunction = batchLoadFunction;
+        public Builder<K, V> name(String name) {
+            this.name = name;
             return this;
         }
 
@@ -562,8 +827,53 @@ public Builder<K, V> options(DataLoaderOptions options) {
             return this;
         }
 
+        public Builder<K, V> batchLoadFunction(Object batchLoadFunction) {
+            this.batchLoadFunction = batchLoadFunction;
+            return this;
+        }
+
+        public Builder<K, V> batchLoader(BatchLoader<K, V> batchLoadFunction) {
+            this.batchLoadFunction = batchLoadFunction;
+            return this;
+        }
+
+        public Builder<K, V> batchLoader(BatchLoaderWithContext<K, V> batchLoadFunction) {
+            this.batchLoadFunction = batchLoadFunction;
+            return this;
+        }
+
+        public Builder<K, V> mappedBatchLoader(MappedBatchLoader<K, V> batchLoadFunction) {
+            this.batchLoadFunction = batchLoadFunction;
+            return this;
+        }
+
+        public Builder<K, V> mappedBatchLoader(MappedBatchLoaderWithContext<K, V> batchLoadFunction) {
+            this.batchLoadFunction = batchLoadFunction;
+            return this;
+        }
+
+        public Builder<K, V> publisherBatchLoader(BatchPublisher<K, V> batchLoadFunction) {
+            this.batchLoadFunction = batchLoadFunction;
+            return this;
+        }
+
+        public Builder<K, V> publisherBatchLoader(BatchPublisherWithContext<K, V> batchLoadFunction) {
+            this.batchLoadFunction = batchLoadFunction;
+            return this;
+        }
+
+        public Builder<K, V> mappedPublisherBatchLoader(MappedBatchPublisher<K, V> batchLoadFunction) {
+            this.batchLoadFunction = batchLoadFunction;
+            return this;
+        }
+
+        public Builder<K, V> mappedPublisherBatchLoader(MappedBatchPublisherWithContext<K, V> batchLoadFunction) {
+            this.batchLoadFunction = batchLoadFunction;
+            return this;
+        }
+
         public DataLoader<K, V> build() {
-            return mkDataLoader(batchLoadFunction, options);
+            return mkDataLoader(name, batchLoadFunction, options);
         }
     }
 }
diff --git a/src/main/java/org/dataloader/DataLoaderRegistry.java b/src/main/java/org/dataloader/DataLoaderRegistry.java
index 06c93c4..0988697 100644
--- a/src/main/java/org/dataloader/DataLoaderRegistry.java
+++ b/src/main/java/org/dataloader/DataLoaderRegistry.java
@@ -5,6 +5,8 @@
 import org.dataloader.instrumentation.DataLoaderInstrumentation;
 import org.dataloader.instrumentation.DataLoaderInstrumentationHelper;
 import org.dataloader.stats.Statistics;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -16,6 +18,8 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Function;
 
+import static org.dataloader.impl.Assertions.assertState;
+
 /**
  * This allows data loaders to be registered together into a single place, so
  * they can be dispatched as one.  It also allows you to retrieve data loaders by
@@ -35,9 +39,10 @@
  * are the same object, then nothing is changed, since the same instrumentation code is being run.
  */
 @PublicApi
+@NullMarked
 public class DataLoaderRegistry {
     protected final Map<String, DataLoader<?, ?>> dataLoaders;
-    protected final DataLoaderInstrumentation instrumentation;
+    protected final @Nullable DataLoaderInstrumentation instrumentation;
 
 
     public DataLoaderRegistry() {
@@ -48,15 +53,15 @@ private DataLoaderRegistry(Builder builder) {
         this(builder.dataLoaders, builder.instrumentation);
     }
 
-    protected DataLoaderRegistry(Map<String, DataLoader<?, ?>> dataLoaders, DataLoaderInstrumentation instrumentation) {
+    protected DataLoaderRegistry(Map<String, DataLoader<?, ?>> dataLoaders, @Nullable DataLoaderInstrumentation instrumentation) {
         this.dataLoaders = instrumentDLs(dataLoaders, instrumentation);
         this.instrumentation = instrumentation;
     }
 
-    private Map<String, DataLoader<?, ?>> instrumentDLs(Map<String, DataLoader<?, ?>> incomingDataLoaders, DataLoaderInstrumentation registryInstrumentation) {
+    private Map<String, DataLoader<?, ?>> instrumentDLs(Map<String, DataLoader<?, ?>> incomingDataLoaders, @Nullable DataLoaderInstrumentation registryInstrumentation) {
         Map<String, DataLoader<?, ?>> dataLoaders = new ConcurrentHashMap<>(incomingDataLoaders);
         if (registryInstrumentation != null) {
-            dataLoaders.replaceAll((k, existingDL) -> instrumentDL(registryInstrumentation, existingDL));
+            dataLoaders.replaceAll((k, existingDL) -> nameAndInstrumentDL(k, registryInstrumentation, existingDL));
         }
         return dataLoaders;
     }
@@ -64,11 +69,14 @@ protected DataLoaderRegistry(Map<String, DataLoader<?, ?>> dataLoaders, DataLoad
     /**
      * Can be called to tweak a {@link DataLoader} so that it has the registry {@link DataLoaderInstrumentation} added as the first one.
      *
+     * @param key                     the key used to register the data loader
      * @param registryInstrumentation the common registry {@link DataLoaderInstrumentation}
      * @param existingDL              the existing data loader
      * @return a new {@link DataLoader} or the same one if there is nothing to change
      */
-    private static DataLoader<?, ?> instrumentDL(DataLoaderInstrumentation registryInstrumentation, DataLoader<?, ?> existingDL) {
+    private static DataLoader<?, ?> nameAndInstrumentDL(String key, @Nullable DataLoaderInstrumentation registryInstrumentation, DataLoader<?, ?> existingDL) {
+        existingDL = checkAndSetName(key, existingDL);
+
         if (registryInstrumentation == null) {
             return existingDL;
         }
@@ -97,6 +105,15 @@ protected DataLoaderRegistry(Map<String, DataLoader<?, ?>> dataLoaders, DataLoad
         }
     }
 
+    private static DataLoader<?, ?> checkAndSetName(String key, DataLoader<?, ?> dataLoader) {
+        if (dataLoader.getName() == null) {
+            return dataLoader.transform(b -> b.name(key));
+        }
+        assertState(key.equals(dataLoader.getName()),
+                () -> String.format("Data loader name '%s' is not the same as registered key '%s'", dataLoader.getName(), key));
+        return dataLoader;
+    }
+
     private static DataLoader<?, ?> mkInstrumentedDataLoader(DataLoader<?, ?> existingDL, DataLoaderOptions options, DataLoaderInstrumentation newInstrumentation) {
         return existingDL.transform(builder -> builder.options(setInInstrumentation(options, newInstrumentation)));
     }
@@ -108,28 +125,70 @@ private static DataLoaderOptions setInInstrumentation(DataLoaderOptions options,
     /**
      * @return the {@link DataLoaderInstrumentation} associated with this registry which can be null
      */
-    public DataLoaderInstrumentation getInstrumentation() {
+    public @Nullable DataLoaderInstrumentation getInstrumentation() {
         return instrumentation;
     }
 
     /**
-     * This will register a new dataloader
+     * This will register a new named dataloader.  The {@link DataLoader} must be named something and
+     * cannot have a null name.
+     * <p>
+     * Note: Registration can change the data loader instance since it might get an {@link DataLoaderInstrumentation} applied to
+     * it.  So the {@link DataLoader} instance your read via {@link DataLoaderRegistry#getDataLoader(String)} might not be the same
+     * object that was registered.
+     *
+     * @param dataLoader the named data loader to register
+     * @return this registry
+     */
+    public DataLoaderRegistry register(DataLoader<?, ?> dataLoader) {
+        String name = dataLoader.getName();
+        assertState(name != null, () -> "The DataLoader must have a non null name");
+        dataLoaders.put(name, nameAndInstrumentDL(name, instrumentation, dataLoader));
+        return this;
+    }
+
+    /**
+     * This will register a new {@link DataLoader}
+     * <p>
+     * Note: Registration can change the data loader instance since it might get an {@link DataLoaderInstrumentation} applied to
+     * it.  So the {@link DataLoader} instance your read via {@link DataLoaderRegistry#getDataLoader(String)} might not be the same
+     * object that was registered.
      *
      * @param key        the key to put the data loader under
      * @param dataLoader the data loader to register
      * @return this registry
      */
     public DataLoaderRegistry register(String key, DataLoader<?, ?> dataLoader) {
-        dataLoaders.put(key, instrumentDL(instrumentation, dataLoader));
+        dataLoaders.put(key, nameAndInstrumentDL(key, instrumentation, dataLoader));
         return this;
     }
 
+    /**
+     * This will register a new {@link DataLoader} and then return it.
+     * <p>
+     * Note: Registration can change the data loader instance since it might get an {@link DataLoaderInstrumentation} applied to
+     * it.  So the {@link DataLoader} instance your read via {@link DataLoaderRegistry#getDataLoader(String)} might not be the same
+     * object that was registered.
+     *
+     * @param key        the key to put the data loader under
+     * @param dataLoader the data loader to register
+     * @return the data loader instance that was registered
+     */
+    public <K, V> DataLoader<K, V> registerAndGet(String key, DataLoader<?, ?> dataLoader) {
+        dataLoaders.put(key, nameAndInstrumentDL(key, instrumentation, dataLoader));
+        return getDataLoader(key);
+    }
+
     /**
      * Computes a data loader if absent or return it if it was
      * already registered at that key.
      * <p>
      * Note: The entire method invocation is performed atomically,
      * so the function is applied at most once per key.
+     * <p>
+     * Note: Registration can change the data loader instance since it might get an {@link DataLoaderInstrumentation} applied to
+     * it.  So the {@link DataLoader} instance your read via {@link DataLoaderRegistry#getDataLoader(String)} might not be the same
+     * object that was registered.
      *
      * @param key             the key of the data loader
      * @param mappingFunction the function to compute a data loader
@@ -142,7 +201,7 @@ public <K, V> DataLoader<K, V> computeIfAbsent(final String key,
                                                    final Function<String, DataLoader<?, ?>> mappingFunction) {
         return (DataLoader<K, V>) dataLoaders.computeIfAbsent(key, (k) -> {
             DataLoader<?, ?> dl = mappingFunction.apply(k);
-            return instrumentDL(instrumentation, dl);
+            return nameAndInstrumentDL(key, instrumentation, dl);
         });
     }
 
@@ -262,7 +321,7 @@ public static Builder newRegistry() {
     public static class Builder {
 
         private final Map<String, DataLoader<?, ?>> dataLoaders = new HashMap<>();
-        private DataLoaderInstrumentation instrumentation;
+        private @Nullable DataLoaderInstrumentation instrumentation;
 
         /**
          * This will register a new dataloader
diff --git a/src/main/java/org/dataloader/DelegatingDataLoader.java b/src/main/java/org/dataloader/DelegatingDataLoader.java
index c54a731..7cffced 100644
--- a/src/main/java/org/dataloader/DelegatingDataLoader.java
+++ b/src/main/java/org/dataloader/DelegatingDataLoader.java
@@ -29,8 +29,8 @@
  *       CompletableFuture<String> cf = super.load(key, keyContext);
  *       return cf.thenApply(v -> "|" + v + "|");
  *    }
- *};
- *}</pre>
+ * };
+ * }</pre>
  *
  * @param <K> type parameter indicating the type of the data load keys
  * @param <V> type parameter indicating the type of the data that is returned
@@ -58,7 +58,7 @@ public static <K, V> DataLoader<K, V> unwrap(DataLoader<K, V> dataLoader) {
     }
 
     public DelegatingDataLoader(DataLoader<K, V> delegate) {
-        super(delegate.getBatchLoadFunction(), delegate.getOptions());
+        super(delegate.getName(), delegate.getBatchLoadFunction(), delegate.getOptions());
         this.delegate = delegate;
     }
 
diff --git a/src/main/java/org/dataloader/registries/ScheduledDataLoaderRegistry.java b/src/main/java/org/dataloader/registries/ScheduledDataLoaderRegistry.java
index b6bc257..4f62378 100644
--- a/src/main/java/org/dataloader/registries/ScheduledDataLoaderRegistry.java
+++ b/src/main/java/org/dataloader/registries/ScheduledDataLoaderRegistry.java
@@ -3,7 +3,10 @@
 import org.dataloader.DataLoader;
 import org.dataloader.DataLoaderRegistry;
 import org.dataloader.annotations.ExperimentalApi;
+import org.dataloader.impl.Assertions;
 import org.dataloader.instrumentation.DataLoaderInstrumentation;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.time.Duration;
 import java.util.LinkedHashMap;
@@ -54,6 +57,7 @@
  * This code is currently marked as {@link ExperimentalApi}
  */
 @ExperimentalApi
+@NullMarked
 public class ScheduledDataLoaderRegistry extends DataLoaderRegistry implements AutoCloseable {
 
     private final Map<DataLoader<?, ?>, DispatchPredicate> dataLoaderPredicates = new ConcurrentHashMap<>();
@@ -66,7 +70,7 @@ public class ScheduledDataLoaderRegistry extends DataLoaderRegistry implements A
 
     private ScheduledDataLoaderRegistry(Builder builder) {
         super(builder.dataLoaders, builder.instrumentation);
-        this.scheduledExecutorService = builder.scheduledExecutorService;
+        this.scheduledExecutorService = Assertions.nonNull(builder.scheduledExecutorService);
         this.defaultExecutorUsed = builder.defaultExecutorUsed;
         this.schedule = builder.schedule;
         this.tickerMode = builder.tickerMode;
@@ -112,7 +116,6 @@ public boolean isTickerMode() {
      * and return a new combined registry
      *
      * @param registry the registry to combine into this registry
-     *
      * @return a new combined registry
      */
     public ScheduledDataLoaderRegistry combine(DataLoaderRegistry registry) {
@@ -128,7 +131,6 @@ public ScheduledDataLoaderRegistry combine(DataLoaderRegistry registry) {
      * This will unregister a new dataloader
      *
      * @param key the key of the data loader to unregister
-     *
      * @return this registry
      */
     public ScheduledDataLoaderRegistry unregister(String key) {
@@ -161,7 +163,6 @@ public DispatchPredicate getDispatchPredicate() {
      * @param key               the key to put the data loader under
      * @param dataLoader        the data loader to register
      * @param dispatchPredicate the dispatch predicate to associate with this data loader
-     *
      * @return this registry
      */
     public ScheduledDataLoaderRegistry register(String key, DataLoader<?, ?> dataLoader, DispatchPredicate dispatchPredicate) {
@@ -222,7 +223,6 @@ public void rescheduleNow() {
      *
      * @param dataLoaderKey the key in the dataloader map
      * @param dataLoader    the dataloader
-     *
      * @return true if it should dispatch
      */
     private boolean shouldDispatch(String dataLoaderKey, DataLoader<?, ?> dataLoader) {
@@ -267,11 +267,11 @@ public static class Builder {
         private final Map<String, DataLoader<?, ?>> dataLoaders = new LinkedHashMap<>();
         private final Map<DataLoader<?, ?>, DispatchPredicate> dataLoaderPredicates = new LinkedHashMap<>();
         private DispatchPredicate dispatchPredicate = DispatchPredicate.DISPATCH_ALWAYS;
-        private ScheduledExecutorService scheduledExecutorService;
+        private @Nullable ScheduledExecutorService scheduledExecutorService;
         private boolean defaultExecutorUsed = false;
         private Duration schedule = Duration.ofMillis(10);
         private boolean tickerMode = false;
-        private DataLoaderInstrumentation instrumentation;
+        private @Nullable DataLoaderInstrumentation instrumentation;
 
 
         /**
@@ -279,7 +279,6 @@ public static class Builder {
          * {@link ScheduledDataLoaderRegistry#close()} is called.  This is left to the code that made this setup code
          *
          * @param executorService the executor service to run the ticker on
-         *
          * @return this builder for a fluent pattern
          */
         public Builder scheduledExecutorService(ScheduledExecutorService executorService) {
@@ -297,7 +296,6 @@ public Builder schedule(Duration schedule) {
          *
          * @param key        the key to put the data loader under
          * @param dataLoader the data loader to register
-         *
          * @return this builder for a fluent pattern
          */
         public Builder register(String key, DataLoader<?, ?> dataLoader) {
@@ -312,7 +310,6 @@ public Builder register(String key, DataLoader<?, ?> dataLoader) {
          * @param key               the key to put the data loader under
          * @param dataLoader        the data loader to register
          * @param dispatchPredicate the dispatch predicate
-         *
          * @return this builder for a fluent pattern
          */
         public Builder register(String key, DataLoader<?, ?> dataLoader, DispatchPredicate dispatchPredicate) {
@@ -326,7 +323,6 @@ public Builder register(String key, DataLoader<?, ?> dataLoader, DispatchPredica
          * from a previous {@link DataLoaderRegistry}
          *
          * @param otherRegistry the previous {@link DataLoaderRegistry}
-         *
          * @return this builder for a fluent pattern
          */
         public Builder registerAll(DataLoaderRegistry otherRegistry) {
@@ -343,7 +339,6 @@ public Builder registerAll(DataLoaderRegistry otherRegistry) {
          * whether all {@link DataLoader}s in the {@link DataLoaderRegistry }should be dispatched.
          *
          * @param dispatchPredicate the predicate
-         *
          * @return this builder for a fluent pattern
          */
         public Builder dispatchPredicate(DispatchPredicate dispatchPredicate) {
@@ -357,7 +352,6 @@ public Builder dispatchPredicate(DispatchPredicate dispatchPredicate) {
          * to dispatchAll.
          *
          * @param tickerMode true or false
-         *
          * @return this builder for a fluent pattern
          */
         public Builder tickerMode(boolean tickerMode) {
diff --git a/src/test/java/org/dataloader/ClockDataLoader.java b/src/test/java/org/dataloader/ClockDataLoader.java
index 21faeea..0c83316 100644
--- a/src/test/java/org/dataloader/ClockDataLoader.java
+++ b/src/test/java/org/dataloader/ClockDataLoader.java
@@ -9,7 +9,7 @@ public ClockDataLoader(Object batchLoadFunction, Clock clock) {
     }
 
     public ClockDataLoader(Object batchLoadFunction, DataLoaderOptions options, Clock clock) {
-        super(batchLoadFunction, options, clock);
+        super(null, batchLoadFunction, options, clock);
     }
 
 }
diff --git a/src/test/java/org/dataloader/DataLoaderFactoryTest.java b/src/test/java/org/dataloader/DataLoaderFactoryTest.java
new file mode 100644
index 0000000..265aa62
--- /dev/null
+++ b/src/test/java/org/dataloader/DataLoaderFactoryTest.java
@@ -0,0 +1,51 @@
+package org.dataloader;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+class DataLoaderFactoryTest {
+
+    @Test
+    void can_create_via_builder() {
+        BatchLoaderWithContext<String, String> loader = (keys, environment) -> CompletableFuture.completedFuture(keys);
+        DataLoaderOptions options = DataLoaderOptions.newOptionsBuilder().setBatchingEnabled(true).build();
+
+        DataLoader<String, String> dl = DataLoaderFactory.<String, String>builder()
+                .name("x").batchLoader(loader).options(options).build();
+
+        assertNotNull(dl.getName());
+        assertThat(dl.getName(), equalTo("x"));
+        assertThat(dl.getBatchLoadFunction(), equalTo(loader));
+        assertThat(dl.getOptions(), equalTo(options));
+
+        BatchLoaderWithContext<String, Try<String>> loaderTry = (keys, environment)
+                -> CompletableFuture.completedFuture(keys.stream().map(Try::succeeded).collect(Collectors.toList()));
+
+        DataLoader<String, Try<String>> dlTry = DataLoaderFactory.<String, Try<String>>builder()
+                .name("try").batchLoader(loaderTry).options(options).build();
+
+        assertNotNull(dlTry.getName());
+        assertThat(dlTry.getName(), equalTo("try"));
+        assertThat(dlTry.getBatchLoadFunction(), equalTo(loaderTry));
+        assertThat(dlTry.getOptions(), equalTo(options));
+
+        MappedBatchLoader<String, Try<String>> mappedLoaderTry = (keys)
+                -> CompletableFuture.completedFuture(
+                keys.stream().collect(Collectors.toMap(k -> k, Try::succeeded))
+        );
+
+        DataLoader<String, Try<String>> dlTry2 = DataLoaderFactory.<String, Try<String>>builder()
+                .name("try2").mappedBatchLoader(mappedLoaderTry).options(options).build();
+
+        assertNotNull(dlTry2.getName());
+        assertThat(dlTry2.getName(), equalTo("try2"));
+        assertThat(dlTry2.getBatchLoadFunction(), equalTo(mappedLoaderTry));
+        assertThat(dlTry2.getOptions(), equalTo(options));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/org/dataloader/DataLoaderRegistryTest.java b/src/test/java/org/dataloader/DataLoaderRegistryTest.java
index bd1534d..c97c087 100644
--- a/src/test/java/org/dataloader/DataLoaderRegistryTest.java
+++ b/src/test/java/org/dataloader/DataLoaderRegistryTest.java
@@ -1,9 +1,12 @@
 package org.dataloader;
 
+import org.dataloader.impl.DataLoaderAssertionException;
 import org.dataloader.stats.SimpleStatisticsCollector;
 import org.dataloader.stats.Statistics;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
+import java.util.List;
 import java.util.concurrent.CompletableFuture;
 
 import static java.util.Arrays.asList;
@@ -18,9 +21,10 @@ public class DataLoaderRegistryTest {
 
     @Test
     public void registration_works() {
-        DataLoader<Object, Object> dlA = newDataLoader(identityBatchLoader);
-        DataLoader<Object, Object> dlB = newDataLoader(identityBatchLoader);
-        DataLoader<Object, Object> dlC = newDataLoader(identityBatchLoader);
+        DataLoader<Object, Object> dlA = newDataLoader("a", identityBatchLoader);
+        DataLoader<Object, Object> dlB = newDataLoader("b", identityBatchLoader);
+        DataLoader<Object, Object> dlC = newDataLoader("c", identityBatchLoader);
+        DataLoader<Object, Object> dlUnnamed = newDataLoader(identityBatchLoader);
 
         DataLoaderRegistry registry = new DataLoaderRegistry();
 
@@ -40,7 +44,7 @@ public void registration_works() {
 
         // and unregister (fluently)
         DataLoaderRegistry dlR = registry.unregister("c");
-        assertThat(dlR,equalTo(registry));
+        assertThat(dlR, equalTo(registry));
 
         assertThat(registry.getDataLoaders(), equalTo(asList(dlA, dlB)));
 
@@ -49,15 +53,27 @@ public void registration_works() {
         assertThat(readDL, sameInstance(dlA));
 
         assertThat(registry.getKeys(), hasItems("a", "b"));
+
+
+        // named registry
+        registry = new DataLoaderRegistry();
+        registry.register(dlA);
+        assertThat(registry.getDataLoaders(), equalTo(List.of(dlA)));
+
+        try {
+            registry.register(dlUnnamed);
+            Assertions.fail("Should have thrown an exception");
+        } catch (DataLoaderAssertionException ignored) {
+        }
     }
 
     @Test
     public void registries_can_be_combined() {
 
-        DataLoader<Object, Object> dlA = newDataLoader(identityBatchLoader);
-        DataLoader<Object, Object> dlB = newDataLoader(identityBatchLoader);
-        DataLoader<Object, Object> dlC = newDataLoader(identityBatchLoader);
-        DataLoader<Object, Object> dlD = newDataLoader(identityBatchLoader);
+        DataLoader<Object, Object> dlA = newDataLoader("a", identityBatchLoader);
+        DataLoader<Object, Object> dlB = newDataLoader("b", identityBatchLoader);
+        DataLoader<Object, Object> dlC = newDataLoader("c", identityBatchLoader);
+        DataLoader<Object, Object> dlD = newDataLoader("d", identityBatchLoader);
 
         DataLoaderRegistry registry1 = new DataLoaderRegistry();
 
@@ -90,6 +106,10 @@ public void stats_can_be_collected() {
 
         registry.register("a", dlA).register("b", dlB).register("c", dlC);
 
+        dlA = registry.getDataLoader("a");
+        dlB = registry.getDataLoader("b");
+        dlC = registry.getDataLoader("b");
+
         dlA.load("X");
         dlB.load("Y");
         dlC.load("Z");
@@ -116,7 +136,7 @@ public void computeIfAbsent_creates_a_data_loader_if_there_was_no_value_at_key()
 
         DataLoaderRegistry registry = new DataLoaderRegistry();
 
-        DataLoader<Object, Object> dlA = newDataLoader(identityBatchLoader);
+        DataLoader<Object, Object> dlA = newDataLoader("a", identityBatchLoader);
         DataLoader<Object, Object> registered = registry.computeIfAbsent("a", (key) -> dlA);
 
         assertThat(registered, equalTo(dlA));
@@ -129,11 +149,11 @@ public void computeIfAbsent_returns_an_existing_data_loader_if_there_was_a_value
 
         DataLoaderRegistry registry = new DataLoaderRegistry();
 
-        DataLoader<Object, Object> dlA = newDataLoader(identityBatchLoader);
+        DataLoader<Object, Object> dlA = newDataLoader("a", identityBatchLoader);
         registry.computeIfAbsent("a", (key) -> dlA);
 
         // register again at same key
-        DataLoader<Object, Object> dlA2 = newDataLoader(identityBatchLoader);
+        DataLoader<Object, Object> dlA2 = newDataLoader("a", identityBatchLoader);
         DataLoader<Object, Object> registered = registry.computeIfAbsent("a", (key) -> dlA2);
 
         assertThat(registered, equalTo(dlA));
@@ -149,8 +169,8 @@ public void dispatch_counts_are_maintained() {
         DataLoader<Object, Object> dlA = newDataLoader(identityBatchLoader);
         DataLoader<Object, Object> dlB = newDataLoader(identityBatchLoader);
 
-        registry.register("a", dlA);
-        registry.register("b", dlB);
+        dlA = registry.registerAndGet("a", dlA);
+        dlB = registry.registerAndGet("b", dlB);
 
         dlA.load("av1");
         dlA.load("av2");
diff --git a/src/test/java/org/dataloader/DataLoaderTest.java b/src/test/java/org/dataloader/DataLoaderTest.java
index 069d390..630dd18 100644
--- a/src/test/java/org/dataloader/DataLoaderTest.java
+++ b/src/test/java/org/dataloader/DataLoaderTest.java
@@ -33,7 +33,13 @@
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
 import java.util.concurrent.ExecutionException;
@@ -43,8 +49,12 @@
 import java.util.stream.Collectors;
 
 import static java.util.Arrays.asList;
-import static java.util.Collections.*;
-import static java.util.concurrent.CompletableFuture.*;
+import static java.util.Collections.emptyList;
+import static java.util.Collections.emptyMap;
+import static java.util.Collections.singletonList;
+import static java.util.concurrent.CompletableFuture.allOf;
+import static java.util.concurrent.CompletableFuture.completedFuture;
+import static java.util.concurrent.CompletableFuture.supplyAsync;
 import static org.awaitility.Awaitility.await;
 import static org.dataloader.DataLoaderFactory.newDataLoader;
 import static org.dataloader.DataLoaderOptions.newOptions;
@@ -52,8 +62,13 @@
 import static org.dataloader.fixtures.TestKit.listFrom;
 import static org.dataloader.impl.CompletableFutureKit.cause;
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.*;
+import static org.hamcrest.Matchers.anEmptyMap;
+import static org.hamcrest.Matchers.empty;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.is;
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 /**
  * Tests for {@link DataLoader}.
@@ -82,6 +97,20 @@ public void should_Build_a_really_really_simple_data_loader() {
         await().untilAtomic(success, is(true));
     }
 
+    @Test
+    public void should_Build_a_named_data_loader() {
+        BatchLoader<Integer, Integer> loadFunction = CompletableFuture::completedFuture;
+        DataLoader<Integer, Integer> dl = newDataLoader("name", loadFunction, DataLoaderOptions.newOptions());
+
+        assertNotNull(dl.getName());
+        assertThat(dl.getName(), equalTo("name"));
+
+        DataLoader<Integer, Integer> dl2 = DataLoaderFactory.<Integer, Integer>builder().name("name2").batchLoader(loadFunction).build();
+
+        assertNotNull(dl2.getName());
+        assertThat(dl2.getName(), equalTo("name2"));
+    }
+
     @Test
     public void basic_map_batch_loading() {
         MappedBatchLoader<String, String> evensOnlyMappedBatchLoader = (keys) -> {
diff --git a/src/test/java/org/dataloader/DelegatingDataLoaderTest.java b/src/test/java/org/dataloader/DelegatingDataLoaderTest.java
index 9103eca..f1aec2d 100644
--- a/src/test/java/org/dataloader/DelegatingDataLoaderTest.java
+++ b/src/test/java/org/dataloader/DelegatingDataLoaderTest.java
@@ -4,6 +4,7 @@
 import org.dataloader.fixtures.parameterized.DelegatingDataLoaderFactory;
 import org.jspecify.annotations.NonNull;
 import org.jspecify.annotations.Nullable;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 import java.util.List;
@@ -13,6 +14,7 @@
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.*;
 
 /**
  * There are WAY more tests via the {@link DelegatingDataLoaderFactory}
@@ -61,4 +63,18 @@ public CompletableFuture<String> load(@NonNull String key, @Nullable Object keyC
         assertThat(delegatingDataLoader.getIfCompleted("A").isEmpty(), equalTo(false));
         assertThat(delegatingDataLoader.getIfCompleted("X").isEmpty(), equalTo(true));
     }
+
+    @Test
+    void can_delegate_simple_properties() {
+        DataLoaderOptions options = DataLoaderOptions.newOptions();
+        BatchLoader<String, String> loadFunction = CompletableFuture::completedFuture;
+
+        DataLoader<String, String> rawLoader = DataLoaderFactory.newDataLoader("name", loadFunction, options);
+        DelegatingDataLoader<String, String> delegate = new DelegatingDataLoader<>(rawLoader);
+
+        assertNotNull(delegate.getName());
+        assertThat(delegate.getName(),equalTo("name"));
+        assertThat(delegate.getOptions(),equalTo(options));
+        assertThat(delegate.getBatchLoadFunction(),equalTo(loadFunction));
+    }
 }
\ No newline at end of file
diff --git a/src/test/java/org/dataloader/fixtures/TestKit.java b/src/test/java/org/dataloader/fixtures/TestKit.java
index 04ec5e5..e6ba319 100644
--- a/src/test/java/org/dataloader/fixtures/TestKit.java
+++ b/src/test/java/org/dataloader/fixtures/TestKit.java
@@ -11,8 +11,8 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
-import java.util.LinkedHashSet;
 import java.util.HashMap;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -64,10 +64,18 @@ public static <K, V> DataLoader<K, V> idLoader() {
         return idLoader(null, new ArrayList<>());
     }
 
+    public static <K, V> DataLoader<K, V> idLoader(String name) {
+        return idLoader(name, null, new ArrayList<>());
+    }
+
     public static <K, V> DataLoader<K, V> idLoader(DataLoaderOptions options, List<List<K>> loadCalls) {
         return DataLoaderFactory.newDataLoader(keysAsValues(loadCalls), options);
     }
 
+    public static <K, V> DataLoader<K, V> idLoader(String name, DataLoaderOptions options, List<List<K>> loadCalls) {
+        return DataLoaderFactory.newDataLoader(name, keysAsValues(loadCalls), options);
+    }
+
     public static Collection<Integer> listFrom(int i, int max) {
         List<Integer> ints = new ArrayList<>();
         for (int j = i; j < max; j++) {
@@ -104,7 +112,7 @@ public static <T> Set<T> asSet(Collection<T> elements) {
 
     public static boolean areAllDone(CompletableFuture<?>... cfs) {
         for (CompletableFuture<?> cf : cfs) {
-            if (! cf.isDone()) {
+            if (!cf.isDone()) {
                 return false;
             }
         }
diff --git a/src/test/java/org/dataloader/instrumentation/DataLoaderRegistryInstrumentationTest.java b/src/test/java/org/dataloader/instrumentation/DataLoaderRegistryInstrumentationTest.java
index 49ccf0e..b091c39 100644
--- a/src/test/java/org/dataloader/instrumentation/DataLoaderRegistryInstrumentationTest.java
+++ b/src/test/java/org/dataloader/instrumentation/DataLoaderRegistryInstrumentationTest.java
@@ -32,9 +32,9 @@ public class DataLoaderRegistryInstrumentationTest {
 
     @BeforeEach
     void setUp() {
-        dlX = TestKit.idLoader();
-        dlY = TestKit.idLoader();
-        dlZ = TestKit.idLoader();
+        dlX = TestKit.idLoader("X");
+        dlY = TestKit.idLoader("Y");
+        dlZ = TestKit.idLoader("Z");
         instrA = new CapturingInstrumentation("A");
         instrB = new CapturingInstrumentation("B");
         chainedInstrA = new ChainedDataLoaderInstrumentation().add(instrA);
@@ -121,8 +121,8 @@ void wontDoAnyThingIfThereIsNoRegistryInstrumentation() {
     @Test
     void wontDoAnyThingIfThereTheyAreTheSameInstrumentationAlready() {
         DataLoader<String, String> newX = dlX.transform(builder -> builder.options(dlX.getOptions().setInstrumentation(instrA)));
-        DataLoader<String, String> newY = dlX.transform(builder ->  builder.options(dlY.getOptions().setInstrumentation(instrA)));
-        DataLoader<String, String> newZ = dlX.transform(builder ->  builder.options(dlZ.getOptions().setInstrumentation(instrA)));
+        DataLoader<String, String> newY = dlY.transform(builder ->  builder.options(dlY.getOptions().setInstrumentation(instrA)));
+        DataLoader<String, String> newZ = dlZ.transform(builder ->  builder.options(dlZ.getOptions().setInstrumentation(instrA)));
         DataLoaderRegistry registry = DataLoaderRegistry.newRegistry()
                 .instrumentation(instrA)
                 .register("X", newX)