diff --git a/src/java/voldemort/store/bdb/BdbStorageEngine.java b/src/java/voldemort/store/bdb/BdbStorageEngine.java
index 055ed51afe..f3d4d9b18c 100644
--- a/src/java/voldemort/store/bdb/BdbStorageEngine.java
+++ b/src/java/voldemort/store/bdb/BdbStorageEngine.java
@@ -38,6 +38,7 @@
 import voldemort.store.Store;
 import voldemort.store.StoreCapabilityType;
 import voldemort.store.StoreUtils;
+import voldemort.store.bdb.stats.BdbEnvironmentStats;
 import voldemort.utils.ByteArray;
 import voldemort.utils.ByteUtils;
 import voldemort.utils.CachedCallable;
@@ -76,7 +77,6 @@ public class BdbStorageEngine implements StorageEngine<ByteArray, byte[], byte[]
     // TODO: Make this configurable
     private static final long STATS_CACHE_TTL_MS = 5 * 1000;
 
-
     private final String name;
     private Database bdbDatabase;
     private final Environment environment;
@@ -85,8 +85,8 @@ public class BdbStorageEngine implements StorageEngine<ByteArray, byte[], byte[]
     private final boolean cursorPreload;
     private final LockMode readLockMode;
     private final Serializer<Version> versionSerializer;
+    private final BdbEnvironmentStats bdbEnvironmentStats;
     private final AtomicBoolean isTruncating = new AtomicBoolean(false);
-    private final CachedCallable<EnvironmentStats> fastStatsCallable;
 
     public BdbStorageEngine(String name,
                             Environment environment,
@@ -117,14 +117,7 @@ public Version toObject(byte[] bytes) {
         this.isOpen = new AtomicBoolean(true);
         this.cursorPreload = cursorPreload;
         this.readLockMode = readLockMode;
-        Callable<EnvironmentStats> statsCallable = new Callable<EnvironmentStats>() {
-
-            public EnvironmentStats call() throws Exception {
-                return getEnvironmentStats(true);
-            }
-        };
-        this.fastStatsCallable = new CachedCallable<EnvironmentStats>(statsCallable,
-                                                                      STATS_CACHE_TTL_MS);
+        this.bdbEnvironmentStats = new BdbEnvironmentStats(environment, STATS_CACHE_TTL_MS);
     }
 
     public String getName() {
@@ -461,24 +454,6 @@ public DatabaseStats getStats(boolean setFast) {
         }
     }
 
-    private Environment getEnvironment() {
-        return bdbDatabase.getEnvironment();
-    }
-
-    private EnvironmentStats getEnvironmentStats(boolean fast) {
-        StatsConfig config = new StatsConfig();
-        config.setFast(fast);
-        return getEnvironment().getStats(config);
-    }
-
-    private EnvironmentStats getFastStats() {
-        try {
-            return fastStatsCallable.call();
-        } catch(Exception e) {
-            throw new VoldemortException(e);
-        }
-    }
-
     @JmxOperation(description = "A variety of quickly computable stats about the BDB for this store.")
     public String getBdbStats() {
         return getBdbStats(true);
@@ -491,44 +466,8 @@ public String getBdbStats(boolean fast) {
         return dbStats;
     }
 
-    @JmxGetter(name = "cleanerBackLog", description="The number of files to be cleaned to reach the target utilization.")
-    public long getCleanerBacklog() {
-        try {
-            return getFastStats().getCleanerBacklog();
-        } catch(VoldemortException e) {
-            logger.error(e, e);
-        }
-        return -1;
-    }
-
-    @JmxGetter(name = "numCleanerDeletions", description="The number of cleaner file deletions this session.")
-    public long getNumCleanerDeletions() {
-        try {
-            return getFastStats().getNCleanerDeletions();
-        } catch(VoldemortException e) {
-            logger.error(e, e);
-        }
-        return -1;
-    }
-
-    @JmxGetter(name = "numCleanerEntriesRead", description="The number of cleaner file deletions this session.")
-    public long getNumCleanerEntriesRead() {
-        try {
-            return getFastStats().getNCleanerEntriesRead();
-        } catch(VoldemortException e) {
-            logger.error(e, e);
-        }
-        return -1;
-    }
-
-    @JmxGetter(name = "numCleanerRuns", description="The number of cleaner runs this session.")
-    public long getNumCleanerRuns() {
-        try {
-            return getFastStats().getNCleanerRuns();
-        } catch(VoldemortException e) {
-            logger.error(e, e);
-        }
-        return -1;
+    public BdbEnvironmentStats getBdbEnvironmentStats() {
+        return bdbEnvironmentStats;
     }
 
     private static abstract class BdbIterator<T> implements ClosableIterator<T> {
diff --git a/src/java/voldemort/store/bdb/stats/BdbEnvironmentStats.java b/src/java/voldemort/store/bdb/stats/BdbEnvironmentStats.java
new file mode 100644
index 0000000000..e5b99ca7d7
--- /dev/null
+++ b/src/java/voldemort/store/bdb/stats/BdbEnvironmentStats.java
@@ -0,0 +1,150 @@
+package voldemort.store.bdb.stats;
+
+
+import com.sleepycat.je.Environment;
+import com.sleepycat.je.EnvironmentConfig;
+import com.sleepycat.je.EnvironmentStats;
+import com.sleepycat.je.StatsConfig;
+import voldemort.VoldemortException;
+import voldemort.utils.CachedCallable;
+
+import java.util.concurrent.Callable;
+
+// TODO: pass this to a script to add JMX annotations and generate BdbEnvironmentStatsJmx
+public class BdbEnvironmentStats {
+
+    private final Environment environment;
+    private final CachedCallable<EnvironmentStats> fastStats;
+
+    public BdbEnvironmentStats(Environment environment, long ttlMs) {
+        this.environment = environment;
+        Callable<EnvironmentStats> fastStatsCallable = new Callable<EnvironmentStats>() {
+
+            public EnvironmentStats call() throws Exception {
+                return getEnvironmentStats(true);
+            }
+        };
+        fastStats = new CachedCallable<EnvironmentStats>(fastStatsCallable, ttlMs);
+    }
+
+    private EnvironmentStats getEnvironmentStats(boolean fast) {
+        StatsConfig config = new StatsConfig();
+        config.setFast(fast);
+        return environment.getStats(config);
+    }
+
+    private EnvironmentStats getFastStats() {
+        try {
+            return fastStats.call();
+        } catch(Exception e) {
+            throw new VoldemortException(e);
+        }
+    }
+
+    public String getFastStatsAsString() {
+        return getFastStats().toString();
+    }
+
+    public long getNumNotResident() {
+        return getFastStats().getNNotResident();
+    }
+
+    public long getNumRandomWrites() {
+        return getFastStats().getNRandomWrites();
+    }
+
+    public long getNumRandomWriteBytes() {
+        return getFastStats().getNRandomWriteBytes();
+    }
+
+    public long getNumRandomReads() {
+        return getFastStats().getNRandomReads();
+    }
+
+    public long getNumRandomReadBytes() {
+        return getFastStats().getNRandomReadBytes();
+    }
+
+    public long getNumSequentialWrites() {
+        return getFastStats().getNSequentialWrites();
+    }
+
+    public long getNumSequentialWriteBytes() {
+        return getFastStats().getNSequentialWriteBytes();
+    }
+
+    public long getNumSequentialReads() {
+        return getFastStats().getNSequentialReads();
+    }
+
+    public long getNumSequentialReadBytes() {
+        return getFastStats().getNSequentialReadBytes();
+    }
+
+    public long getFileDeletionBacklog() {
+        return getFastStats().getFileDeletionBacklog();
+    }
+
+    public long getFileDeletionBacklogBytes() {
+        String logFileMaxStr = environment.getConfig()
+                                          .getConfigParam(EnvironmentConfig.LOG_FILE_MAX);
+        long logFileMax = Long.parseLong(logFileMaxStr);
+        return getFileDeletionBacklog() * logFileMax;
+    }
+
+    public long getCleanerBacklog() {
+        return getFastStats().getCleanerBacklog();
+    }
+
+    public long getNumAcquiredWithContention() {
+        return getFastStats().getNAcquiresWithContention();
+    }
+
+    public long getNumAcquireNoWaiters() {
+        return getFastStats().getNAcquiresNoWaiters();
+    }
+
+    public long getNumCheckpoints() {
+        return getFastStats().getNCheckpoints();
+    }
+
+    public long getNumCleanerEntriesRead() {
+        return getFastStats().getNCleanerEntriesRead();
+    }
+
+    public long getNumFSyncs() {
+        return getFastStats().getNFSyncs();
+    }
+
+    public long getNumCleanerRuns() {
+        return getFastStats().getNCleanerRuns();
+    }
+
+    public long getNumCleanerDeletions() {
+        return getFastStats().getNCleanerRuns();
+    }
+
+    // Compound statistics
+
+    public double getPercentRandomWrites() {
+       return safeGetPercentage(getNumRandomWrites(), getNumRandomWrites() + getNumSequentialWrites());
+    }
+
+    public double getPercentageRandomWriteBytes() {
+        return safeGetPercentage(getNumRandomWriteBytes(), getNumRandomWriteBytes() +
+                                                           getNumSequentialWriteBytes());
+    }
+
+    public double getPercentageRandomReads() {
+        return safeGetPercentage(getNumRandomReads(), getNumRandomReads() + getNumSequentialReads());
+    }
+
+    public double getPercentageRandomReadBytes() {
+        return safeGetPercentage(getNumRandomWriteBytes(), getNumRandomReadBytes() +
+                                                           getNumSequentialReadBytes());
+    }
+
+    public static double safeGetPercentage(long rawNum, long total) {
+        return total == 0 ? 0.0d : rawNum / (float)total;
+    }
+}