Made it doubles and added toMap

src/main/java/org/dataloader/DataLoaderRegistry.java

@@ -1,5 +1,8 @@
 package org.dataloader;
 
+import org.dataloader.stats.Statistics;
+import org.dataloader.stats.StatisticsImpl;
+
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
@@ -91,4 +94,16 @@ public Set<String> getKeys() {
     public void dispatchAll() {
         getDataLoaders().forEach(DataLoader::dispatch);
     }
+
+    /**
+     * @return a combined set of statistics for all data loaders in this registry presented
+     * as the sum of all their statistics
+     */
+    public Statistics getStatistics() {
+        Statistics stats = new StatisticsImpl();
+        for (DataLoader<?, ?> dataLoader : dataLoaders.values()) {
+            stats = stats.combine(dataLoader.getStatistics());
+        }
+        return stats;
+    }
 }

src/main/java/org/dataloader/stats/SimpleStatisticsCollector.java

@@ -42,7 +42,7 @@ public long incrementBatchLoadExceptionCount() {
 
     @Override
     public Statistics getStatistics() {
-        return new StatisticsImpl(loadCount.get(), batchLoadCount.get(), cacheHitCount.get(), batchLoadExceptionCount.get(), loadErrorCount.get());
+        return new StatisticsImpl(loadCount.get(), loadErrorCount.get(), batchLoadCount.get(), batchLoadExceptionCount.get(), cacheHitCount.get());
     }
 
     @Override

src/main/java/org/dataloader/stats/Statistics.java

@@ -1,5 +1,7 @@
 package org.dataloader.stats;
 
+import java.util.Map;
+
 /**
  * A simple set of statistics about {@link org.dataloader.DataLoader} operations
  */
@@ -17,7 +19,7 @@ public interface Statistics {
     /**
      * @return batchLoadCount / loadCount
      */
-    float getBatchLoadRatio();
+    double getBatchLoadRatio();
 
     /**
      * @return the number of times  {@link org.dataloader.DataLoader#load(Object)} resulted in a cache hit
@@ -32,7 +34,7 @@ public interface Statistics {
     /**
      * @return cacheHits / loadCount
      */
-    float getCacheHitRatio();
+    double getCacheHitRatio();
 
     /**
      * @return the number of times the {@link org.dataloader.DataLoader} batch loader function throw an exception when trying to get any values
@@ -42,7 +44,7 @@ public interface Statistics {
     /**
      * @return batchLoadExceptionCount / loadCount
      */
-    float getBatchLoadExceptionRatio();
+    double getBatchLoadExceptionRatio();
 
     /**
      * @return the number of times the {@link org.dataloader.DataLoader} batch loader function return an specific object that was in error
@@ -53,6 +55,20 @@ public interface Statistics {
     /**
      * @return loadErrorCount / loadCount
      */
-    float getLoadErrorRatio();
+    double getLoadErrorRatio();
+
 
+    /**
+     * This will combine this set of statistics with another set of statistics so that they become the combined count of each
+     *
+     * @param statistics the other statistics to combine
+     *
+     * @return a new statistics object of the combined counts
+     */
+    Statistics combine(Statistics statistics);
+
+    /**
+     * @return a map representation of the statistics, perhaps to send over JSON or some such
+     */
+    Map<String, Number> toMap();
 }

src/main/java/org/dataloader/stats/StatisticsImpl.java

@@ -1,38 +1,69 @@
 package org.dataloader.stats;
 
+import java.util.LinkedHashMap;
+import java.util.Map;
+
 public class StatisticsImpl implements Statistics {
 
     private final long loadCount;
+    private final long loadErrorCount;
     private final long batchLoadCount;
-    private final long cacheHitCount;
     private final long batchLoadExceptionCount;
-    private final long loadErrorCount;
+    private final long cacheHitCount;
 
-    public StatisticsImpl(long loadCount, long batchLoadCount, long cacheHitCount, long batchLoadExceptionCount, long loadErrorCount) {
+    /**
+     * Zero statistics
+     */
+    public StatisticsImpl() {
+        this(0, 0, 0, 0, 0);
+    }
+
+    public StatisticsImpl(long loadCount, long loadErrorCount, long batchLoadCount, long batchLoadExceptionCount, long cacheHitCount) {
         this.loadCount = loadCount;
         this.batchLoadCount = batchLoadCount;
         this.cacheHitCount = cacheHitCount;
         this.batchLoadExceptionCount = batchLoadExceptionCount;
         this.loadErrorCount = loadErrorCount;
     }
 
+    private double ratio(long numerator, long denominator) {
+        return denominator == 0 ? 0f : ((double) numerator) / ((double) denominator);
+    }
+
     @Override
     public long getLoadCount() {
         return loadCount;
     }
 
+
+    @Override
+    public long getLoadErrorCount() {
+        return loadErrorCount;
+    }
+
+    @Override
+    public double getLoadErrorRatio() {
+        return ratio(loadErrorCount, loadCount);
+    }
+
     @Override
     public long getBatchLoadCount() {
         return batchLoadCount;
     }
 
     @Override
-    public float getBatchLoadRatio() {
+    public double getBatchLoadRatio() {
         return ratio(batchLoadCount, loadCount);
     }
 
-    private float ratio(long numerator, long denominator) {
-        return denominator == 0 ? 0f : ((float) numerator) / ((float) denominator);
+    @Override
+    public long getBatchLoadExceptionCount() {
+        return batchLoadExceptionCount;
+    }
+
+    @Override
+    public double getBatchLoadExceptionRatio() {
+        return ratio(batchLoadExceptionCount, loadCount);
     }
 
     @Override
@@ -46,38 +77,45 @@ public long getCacheMissCount() {
     }
 
     @Override
-    public float getCacheHitRatio() {
+    public double getCacheHitRatio() {
         return ratio(cacheHitCount, loadCount);
     }
 
-    @Override
-    public long getBatchLoadExceptionCount() {
-        return batchLoadExceptionCount;
-    }
 
     @Override
-    public long getLoadErrorCount() {
-        return loadErrorCount;
+    public Statistics combine(Statistics other) {
+        return new StatisticsImpl(
+                this.loadCount + other.getLoadCount(),
+                this.loadErrorCount + other.getLoadErrorCount(), this.batchLoadCount + other.getBatchLoadCount(),
+                this.batchLoadExceptionCount + other.getBatchLoadExceptionCount(), this.cacheHitCount + other.getCacheHitCount()
+        );
     }
 
     @Override
-    public float getBatchLoadExceptionRatio() {
-        return ratio(batchLoadExceptionCount, loadCount);
-    }
+    public Map<String, Number> toMap() {
+        Map<String, Number> stats = new LinkedHashMap<>();
+        stats.put("loadCount", getLoadCount());
+        stats.put("loadErrorCount", getLoadErrorCount());
+        stats.put("loadErrorRatio", getLoadErrorRatio());
 
-    @Override
-    public float getLoadErrorRatio() {
-        return ratio(loadErrorCount, loadCount);
+        stats.put("batchLoadCount", getBatchLoadCount());
+        stats.put("batchLoadRatio", getBatchLoadRatio());
+        stats.put("batchLoadExceptionCount", getBatchLoadExceptionCount());
+        stats.put("batchLoadExceptionRatio", getBatchLoadExceptionRatio());
+
+        stats.put("cacheHitCount", getCacheHitCount());
+        stats.put("cacheHitRatio", getCacheHitRatio());
+        return stats;
     }
 
     @Override
     public String toString() {
         return "StatisticsImpl{" +
                 "loadCount=" + loadCount +
+                ", loadErrorCount=" + loadErrorCount +
                 ", batchLoadCount=" + batchLoadCount +
-                ", cacheHitCount=" + cacheHitCount +
                 ", batchLoadExceptionCount=" + batchLoadExceptionCount +
-                ", loadErrorCount=" + loadErrorCount +
+                ", cacheHitCount=" + cacheHitCount +
                 '}';
     }
 }

src/test/java/org/dataloader/DataLoaderRegistryTest.java

@@ -1,5 +1,6 @@
 package org.dataloader;
 
+import org.dataloader.stats.Statistics;
 import org.junit.Test;
 
 import java.util.concurrent.CompletableFuture;
@@ -68,4 +69,36 @@ public void registries_can_be_combined() throws Exception {
         assertThat(combinedRegistry.getKeys(), hasItems("a", "b", "c", "d"));
         assertThat(combinedRegistry.getDataLoaders(), hasItems(dlA, dlB, dlC, dlD));
     }
+
+    @Test
+    public void stats_can_be_collected() throws Exception {
+
+        DataLoaderRegistry registry = new DataLoaderRegistry();
+
+        DataLoader<Object, Object> dlA = new DataLoader<>(identityBatchLoader);
+        DataLoader<Object, Object> dlB = new DataLoader<>(identityBatchLoader);
+        DataLoader<Object, Object> dlC = new DataLoader<>(identityBatchLoader);
+
+        registry.register("a", dlA).register("b", dlB).register("c", dlC);
+
+        dlA.load("X");
+        dlB.load("Y");
+        dlC.load("Z");
+
+        registry.dispatchAll();
+
+        dlA.load("X");
+        dlB.load("Y");
+        dlC.load("Z");
+
+        registry.dispatchAll();
+
+        Statistics statistics = registry.getStatistics();
+
+        assertThat(statistics.getLoadCount(), equalTo(6L));
+        assertThat(statistics.getBatchLoadCount(), equalTo(3L));
+        assertThat(statistics.getCacheHitCount(), equalTo(3L));
+        assertThat(statistics.getLoadErrorCount(), equalTo(0L));
+        assertThat(statistics.getBatchLoadExceptionCount(), equalTo(0L));
+    }
 }

src/test/java/org/dataloader/stats/StatisticsCollectorTest.java

@@ -43,8 +43,8 @@ public void ratios_work() throws Exception {
         collector.incrementLoadCount();
 
         Statistics stats = collector.getStatistics();
-        assertThat(stats.getBatchLoadRatio(), equalTo(0f));
-        assertThat(stats.getCacheHitRatio(), equalTo(0f));
+        assertThat(stats.getBatchLoadRatio(), equalTo(0d));
+        assertThat(stats.getCacheHitRatio(), equalTo(0d));
 
 
         collector.incrementLoadCount();
@@ -53,7 +53,7 @@ public void ratios_work() throws Exception {
         collector.incrementBatchLoadCount();
 
         stats = collector.getStatistics();
-        assertThat(stats.getBatchLoadRatio(), equalTo(1f / 4f));
+        assertThat(stats.getBatchLoadRatio(), equalTo(1d / 4d));
 
 
         collector.incrementLoadCount();
@@ -63,7 +63,7 @@ public void ratios_work() throws Exception {
         collector.incrementCacheHitCount();
 
         stats = collector.getStatistics();
-        assertThat(stats.getCacheHitRatio(), equalTo(2f / 7f));
+        assertThat(stats.getCacheHitRatio(), equalTo(2d / 7d));
 
         collector.incrementLoadCount();
         collector.incrementLoadCount();
@@ -72,7 +72,7 @@ public void ratios_work() throws Exception {
         collector.incrementBatchLoadExceptionCount();
 
         stats = collector.getStatistics();
-        assertThat(stats.getBatchLoadExceptionRatio(), equalTo(2f / 10f));
+        assertThat(stats.getBatchLoadExceptionRatio(), equalTo(2d / 10d));
 
         collector.incrementLoadCount();
         collector.incrementLoadCount();
@@ -82,7 +82,7 @@ public void ratios_work() throws Exception {
         collector.incrementLoadErrorCount();
 
         stats = collector.getStatistics();
-        assertThat(stats.getLoadErrorRatio(), equalTo(3f / 13f));
+        assertThat(stats.getLoadErrorRatio(), equalTo(3d / 13d));
     }
 
     @Test

src/test/java/org/dataloader/stats/StatisticsImplTest.java

@@ -0,0 +1,43 @@
+package org.dataloader.stats;
+
+import org.junit.Test;
+
+import java.util.Map;
+
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.Assert.assertThat;
+
+public class StatisticsImplTest {
+
+    @Test
+    public void combine_works() throws Exception {
+        StatisticsImpl one = new StatisticsImpl(1, 5, 2, 4, 3);
+        StatisticsImpl two = new StatisticsImpl(6, 10, 7, 9, 8);
+
+        Statistics combine = one.combine(two);
+
+        assertThat(combine.getLoadCount(), equalTo(7L));
+        assertThat(combine.getBatchLoadCount(), equalTo(9L));
+        assertThat(combine.getCacheHitCount(), equalTo(11L));
+        assertThat(combine.getBatchLoadExceptionCount(), equalTo(13L));
+        assertThat(combine.getLoadErrorCount(), equalTo(15L));
+    }
+
+    @Test
+    public void to_map_works() throws Exception {
+
+        StatisticsImpl one = new StatisticsImpl(10, 2, 3, 4, 5);
+        Map<String, Number> map = one.toMap();
+
+        assertThat(map.get("loadCount"), equalTo(10L));
+        assertThat(map.get("loadErrorCount"), equalTo(2L));
+        assertThat(map.get("loadErrorRatio"), equalTo(0.2d));
+        assertThat(map.get("batchLoadCount"), equalTo(3L));
+        assertThat(map.get("batchLoadRatio"), equalTo(0.3d));
+        assertThat(map.get("batchLoadExceptionCount"), equalTo(4L));
+        assertThat(map.get("batchLoadExceptionRatio"), equalTo(0.4d));
+        assertThat(map.get("cacheHitCount"), equalTo(5L));
+        assertThat(map.get("cacheHitRatio"), equalTo(0.5d));
+
+    }
+}