added delegating stats collector

Author: bbakerman

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

@@ -0,0 +1,55 @@
+package org.dataloader.stats;
+
+import static org.dataloader.impl.Assertions.nonNull;
+
+/**
+ * This statistics collector keeps dataloader statistics AND also calls the delegate
+ * collector at the same time.  This allows you to keep a specific set of statistics
+ * and also delegate the calls onto another collector.
+ */
+public class DelegatingStatisticsCollector implements StatisticsCollector {
+
+    private final StatisticsCollector collector = new SimpleStatisticsCollector();
+    private final StatisticsCollector delegateCollector;
+
+    /**
+     * @param delegateCollector a non null delegate collector
+     */
+    public DelegatingStatisticsCollector(StatisticsCollector delegateCollector) {
+        this.delegateCollector = nonNull(delegateCollector);
+    }
+
+    @Override
+    public long incrementLoadCount() {
+        delegateCollector.incrementLoadCount();
+        return collector.incrementLoadCount();
+    }
+
+    @Override
+    public long incrementBatchLoadCount() {
+        delegateCollector.incrementBatchLoadCount();
+        return collector.incrementBatchLoadCount();
+    }
+
+    @Override
+    public long incrementCacheHitCount() {
+        delegateCollector.incrementCacheHitCount();
+        return collector.incrementCacheHitCount();
+    }
+
+    /**
+     * @return the statistics of the this collector (and not its delegate)
+     */
+    @Override
+    public Statistics getStatistics() {
+        return collector.getStatistics();
+    }
+
+    /**
+     * @return the statistics of the delegate
+     */
+    public Statistics getDelegateStatistics() {
+        return delegateCollector.getStatistics();
+    }
+
+}

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

@@ -4,7 +4,10 @@
  * This can collect statistics per thread as well as in an overall sense.  This allows you to snapshot stats for a web request say
  * as well as all requests.
  *
- * You will want to call {@link #resetThread()} to clean up the thread local aspects of this object per request thread
+ * You will want to call {@link #resetThread()} to clean up the thread local aspects of this object per request thread.
+ *
+ * ThreadLocals have their place in the Java world but be careful on how you use them.  If you don't clean them up on "request boundaries"
+ * then you WILL have misleading statistics.
  *
  * @see org.dataloader.stats.StatisticsCollector
  */

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

@@ -131,4 +131,36 @@ public void thread_local_collection() throws Exception {
         assertThat(collector.getOverallStatistics().getBatchLoadCount(), equalTo(3L));
         assertThat(collector.getOverallStatistics().getCacheHitCount(), equalTo(3L));
     }
+
+    @Test
+    public void delegating_collector_works() throws Exception {
+        SimpleStatisticsCollector delegate = new SimpleStatisticsCollector();
+        DelegatingStatisticsCollector collector = new DelegatingStatisticsCollector(delegate);
+
+        assertThat(collector.getStatistics().getLoadCount(), equalTo(0L));
+        assertThat(collector.getStatistics().getBatchLoadCount(), equalTo(0L));
+        assertThat(collector.getStatistics().getCacheHitCount(), equalTo(0L));
+        assertThat(collector.getStatistics().getCacheMissCount(), equalTo(0L));
+
+
+        collector.incrementLoadCount();
+        collector.incrementBatchLoadCount();
+        collector.incrementCacheHitCount();
+
+        assertThat(collector.getStatistics().getLoadCount(), equalTo(1L));
+        assertThat(collector.getStatistics().getBatchLoadCount(), equalTo(1L));
+        assertThat(collector.getStatistics().getCacheHitCount(), equalTo(1L));
+        assertThat(collector.getStatistics().getCacheMissCount(), equalTo(0L));
+
+        assertThat(collector.getDelegateStatistics().getLoadCount(), equalTo(1L));
+        assertThat(collector.getDelegateStatistics().getBatchLoadCount(), equalTo(1L));
+        assertThat(collector.getDelegateStatistics().getCacheHitCount(), equalTo(1L));
+        assertThat(collector.getDelegateStatistics().getCacheMissCount(), equalTo(0L));
+
+        assertThat(delegate.getStatistics().getLoadCount(), equalTo(1L));
+        assertThat(delegate.getStatistics().getBatchLoadCount(), equalTo(1L));
+        assertThat(delegate.getStatistics().getCacheHitCount(), equalTo(1L));
+        assertThat(delegate.getStatistics().getCacheMissCount(), equalTo(0L));
+
+    }
 }