diff --git a/community/io/src/main/java/org/neo4j/io/pagecache/impl/muninn/MuninnPageCursor.java b/community/io/src/main/java/org/neo4j/io/pagecache/impl/muninn/MuninnPageCursor.java
index b5ee5543933b0..bdaead75aaf7b 100644
--- a/community/io/src/main/java/org/neo4j/io/pagecache/impl/muninn/MuninnPageCursor.java
+++ b/community/io/src/main/java/org/neo4j/io/pagecache/impl/muninn/MuninnPageCursor.java
@@ -27,9 +27,9 @@
 import org.neo4j.io.pagecache.CursorException;
 import org.neo4j.io.pagecache.PageCursor;
 import org.neo4j.io.pagecache.PageSwapper;
-import org.neo4j.io.pagecache.tracing.PageCacheTracer;
 import org.neo4j.io.pagecache.tracing.PageFaultEvent;
 import org.neo4j.io.pagecache.tracing.PinEvent;
+import org.neo4j.io.pagecache.tracing.cursor.DefaultPageCursorTracer;
 import org.neo4j.unsafe.impl.internal.dragons.UnsafeUtil;
 
 import static org.neo4j.io.pagecache.PagedFile.PF_SHARED_WRITE_LOCK;
@@ -54,7 +54,6 @@ abstract class MuninnPageCursor extends PageCursor
     private final long victimPage;
     protected MuninnPagedFile pagedFile;
     protected PageSwapper swapper;
-    protected PageCacheTracer tracer;
     protected MuninnPage page;
     protected PinEvent pinEvent;
     protected long pageId;
@@ -72,6 +71,8 @@ abstract class MuninnPageCursor extends PageCursor
     // offending code.
     private Object cursorException;
 
+    private DefaultPageCursorTracer pageCursorTracer = new DefaultPageCursorTracer();
+
     MuninnPageCursor( long victimPage )
     {
         this.victimPage = victimPage;
@@ -81,7 +82,7 @@ abstract class MuninnPageCursor extends PageCursor
     final void initialiseFile( MuninnPagedFile pagedFile )
     {
         this.swapper = pagedFile.swapper;
-        this.tracer = pagedFile.tracer;
+        this.pageCursorTracer.init( pagedFile.tracer );
     }
 
     final void initialiseFlags( MuninnPagedFile pagedFile, long pageId, int pf_flags )
@@ -131,6 +132,7 @@ public final void close()
             if ( cursor.pagedFile != null )
             {
                 cursor.unpinCurrentPage();
+                cursor.pageCursorTracer.reportEvents();
                 cursor.releaseCursor();
                 // We null out the pagedFile field to allow it and its (potentially big) translation table to be garbage
                 // collected when the file is unmapped, since the cursors can stick around in thread local caches, etc.
@@ -209,7 +211,7 @@ public final File getCurrentFile()
      */
     protected void pin( long filePageId, boolean writeLock ) throws IOException
     {
-        pinEvent = tracer.beginPin( writeLock, filePageId, swapper );
+        pinEvent = pageCursorTracer.beginPin( writeLock, filePageId, swapper );
         int chunkId = MuninnPagedFile.computeChunkId( filePageId );
         // The chunkOffset is the addressing offset into the chunk array object for the relevant array slot. Using
         // this, we can access the array slot with Unsafe.
diff --git a/community/io/src/main/java/org/neo4j/io/pagecache/tracing/AutoCloseablePageCacheTracerEvent.java b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/AutoCloseablePageCacheTracerEvent.java
index f9a47a9e8651a..769ef6f16d51d 100644
--- a/community/io/src/main/java/org/neo4j/io/pagecache/tracing/AutoCloseablePageCacheTracerEvent.java
+++ b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/AutoCloseablePageCacheTracerEvent.java
@@ -27,5 +27,5 @@
 public interface AutoCloseablePageCacheTracerEvent extends AutoCloseable
 {
     @Override
-    public void close();
+    void close();
 }
diff --git a/community/io/src/main/java/org/neo4j/io/pagecache/tracing/DefaultPageCacheTracer.java b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/DefaultPageCacheTracer.java
index 62e09cadeb1c5..8b95b9549d955 100644
--- a/community/io/src/main/java/org/neo4j/io/pagecache/tracing/DefaultPageCacheTracer.java
+++ b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/DefaultPageCacheTracer.java
@@ -36,52 +36,6 @@
  */
 public class DefaultPageCacheTracer implements PageCacheTracer
 {
-    private static final MethodHandle beginPinMH;
-    private static final SwitchPoint beginPinSwitchPoint;
-    static
-    {
-        try
-        {
-            // A hidden setting to have pin/unpin monitoring enabled from the start by default.
-            // NOTE: This flag is documented in jmx.asciidoc
-            boolean alwaysEnabled = packageFlag( DefaultPageCacheTracer.class, "tracePinUnpin", false );
-
-            MethodType type = MethodType.methodType( PinEvent.class );
-            MethodHandles.Lookup lookup = MethodHandles.lookup();
-            MethodHandle monitoredPinMH = lookup.findVirtual( DefaultPageCacheTracer.class, "beginTracingPin", type );
-            if ( alwaysEnabled )
-            {
-                beginPinMH = monitoredPinMH;
-                beginPinSwitchPoint = null;
-            }
-            else
-            {
-                MethodHandle nullPinMH = lookup.findVirtual( DefaultPageCacheTracer.class, "beginNullPin", type );
-                beginPinSwitchPoint = new SwitchPoint();
-                beginPinMH = beginPinSwitchPoint.guardWithTest( nullPinMH, monitoredPinMH );
-            }
-        }
-        catch ( Exception e )
-        {
-            throw new AssertionError( "Unexpected MethodHandle initiation error", e );
-        }
-    }
-
-    /**
-     * Enable monitoring of page pins and unpins, which is disabled by default for
-     * performance reasons.
-     *
-     * This is a one-way operation; once monitoring of pinning and unpinning has been
-     * enabled, it cannot be disabled again without restarting the JVM.
-     */
-    public static void enablePinUnpinTracing()
-    {
-        if ( beginPinSwitchPoint != null && !beginPinSwitchPoint.hasBeenInvalidated() )
-        {
-            SwitchPoint.invalidateAll( new SwitchPoint[]{ beginPinSwitchPoint } );
-        }
-    }
-
     protected final AtomicLong faults = new AtomicLong();
     protected final AtomicLong evictions = new AtomicLong();
     protected final AtomicLong pins = new AtomicLong();
@@ -178,77 +132,6 @@ public void close()
         }
     };
 
-    private final PageFaultEvent pageFaultEvent = new PageFaultEvent()
-    {
-        @Override
-        public void addBytesRead( long bytes )
-        {
-            bytesRead.getAndAdd( bytes );
-        }
-
-        @Override
-        public void done()
-        {
-            faults.getAndIncrement();
-        }
-
-        @Override
-        public void done( Throwable throwable )
-        {
-            done();
-        }
-
-        @Override
-        public EvictionEvent beginEviction()
-        {
-            return evictionEvent;
-        }
-
-        @Override
-        public void setCachePageId( int cachePageId )
-        {
-        }
-    };
-
-    private final PinEvent pinTracingEvent = new PinEvent()
-    {
-        @Override
-        public void setCachePageId( int cachePageId )
-        {
-        }
-
-        @Override
-        public PageFaultEvent beginPageFault()
-        {
-            return pageFaultEvent;
-        }
-
-        @Override
-        public void done()
-        {
-            unpins.getAndIncrement();
-        }
-    };
-
-    private final PinEvent nullPinEvent = new PinEvent()
-    {
-        @Override
-        public void setCachePageId( int cachePageId )
-        {
-        }
-
-        @Override
-        public PageFaultEvent beginPageFault()
-        {
-            return pageFaultEvent;
-        }
-
-        @Override
-        public void done()
-        {
-        }
-    };
-
     private final MajorFlushEvent majorFlushEvent = new MajorFlushEvent()
     {
         @Override
@@ -281,38 +164,6 @@ public EvictionRunEvent beginPageEvictions( int pageCountToEvict )
         return evictionRunEvent;
     }
 
-    @Override
-    public PinEvent beginPin( boolean writeLock, long filePageId, PageSwapper swapper )
-    {
-        try
-        {
-            return (PinEvent) beginPinMH.invokeExact( this );
-        }
-        catch ( Throwable throwable )
-        {
-            throw new AssertionError( "Unexpected MethodHandle error", throwable );
-        }
-    }
-
-    /**
-     * Invoked through beginPinMH.
-     */
-    @SuppressWarnings( "UnusedDeclaration" )
-    private PinEvent beginNullPin()
-    {
-        return nullPinEvent;
-    }
-
-    /**
-     * Invoked through beginPinMH.
-     */
-    @SuppressWarnings( "UnusedDeclaration" )
-    private PinEvent beginTracingPin()
-    {
-        pins.getAndIncrement();
-        return pinTracingEvent;
-    }
-
     @Override
     public MajorFlushEvent beginFileFlush( PageSwapper swapper )
     {
@@ -384,4 +235,28 @@ public long evictionExceptions()
     {
         return evictionExceptions.get();
     }
+
+    @Override
+    public void pins( long pins )
+    {
+        this.pins.getAndAdd( pins );
+    }
+
+    @Override
+    public void unpins( long unpins )
+    {
+        this.unpins.getAndAdd( unpins );
+    }
+
+    @Override
+    public void faults( long faults )
+    {
+        this.faults.getAndAdd( faults );
+    }
+
+    @Override
+    public void bytesRead( long bytesRead )
+    {
+        this.bytesRead.getAndAdd( bytesRead );
+    }
 }
diff --git a/community/io/src/main/java/org/neo4j/io/pagecache/tracing/EvictionEvent.java b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/EvictionEvent.java
index e7401f9acace6..890ef0425a1f9 100644
--- a/community/io/src/main/java/org/neo4j/io/pagecache/tracing/EvictionEvent.java
+++ b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/EvictionEvent.java
@@ -68,26 +68,26 @@ public void close()
     /**
      * The file page id the evicted page was bound to.
      */
-    public void setFilePageId( long filePageId );
+    void setFilePageId( long filePageId );
 
     /**
      * The swapper the evicted page was bound to.
      */
-    public void setSwapper( PageSwapper swapper );
+    void setSwapper( PageSwapper swapper );
 
     /**
      * Eviction implies an opportunity to flush.
      */
-    public FlushEventOpportunity flushEventOpportunity();
+    FlushEventOpportunity flushEventOpportunity();
 
     /**
      * Indicates that the eviction caused an exception to be thrown.
      * This can happen if some kind of IO error occurs.
      */
-    public void threwException( IOException exception );
+    void threwException( IOException exception );
 
     /**
      * The cache page id of the evicted page.
      */
-    public void setCachePageId( int cachePageId );
+    void setCachePageId( int cachePageId );
 }
diff --git a/community/io/src/main/java/org/neo4j/io/pagecache/tracing/EvictionRunEvent.java b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/EvictionRunEvent.java
index c4dd1d1f48e4f..3c51e2d805c76 100644
--- a/community/io/src/main/java/org/neo4j/io/pagecache/tracing/EvictionRunEvent.java
+++ b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/EvictionRunEvent.java
@@ -47,5 +47,5 @@ public void close()
     /**
      * An eviction is started as part of this eviction run.
      */
-    public EvictionEvent beginEviction();
+    EvictionEvent beginEviction();
 }
diff --git a/community/io/src/main/java/org/neo4j/io/pagecache/tracing/FlushEventOpportunity.java b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/FlushEventOpportunity.java
index 79ce760f7a4a5..95f269a302757 100644
--- a/community/io/src/main/java/org/neo4j/io/pagecache/tracing/FlushEventOpportunity.java
+++ b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/FlushEventOpportunity.java
@@ -31,17 +31,10 @@ public interface FlushEventOpportunity
     /**
      * A FlushEventOpportunity that only returns the FlushEvent.NULL.
      */
-    FlushEventOpportunity NULL = new FlushEventOpportunity()
-    {
-        @Override
-        public FlushEvent beginFlush( long filePageId, int cachePageId, PageSwapper swapper )
-        {
-            return FlushEvent.NULL;
-        }
-    };
+    FlushEventOpportunity NULL = ( filePageId, cachePageId, swapper ) -> FlushEvent.NULL;
 
     /**
      * Begin flushing the given page.
      */
-    public FlushEvent beginFlush( long filePageId, int cachePageId, PageSwapper swapper );
+    FlushEvent beginFlush( long filePageId, int cachePageId, PageSwapper swapper );
 }
diff --git a/community/io/src/main/java/org/neo4j/io/pagecache/tracing/MajorFlushEvent.java b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/MajorFlushEvent.java
index edf9ead47ca0a..6fb8c6d8d4c06 100644
--- a/community/io/src/main/java/org/neo4j/io/pagecache/tracing/MajorFlushEvent.java
+++ b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/MajorFlushEvent.java
@@ -44,5 +44,5 @@ public void close()
     /**
      * Mass-flushing obviously imply flushing opportunities.
      */
-    public FlushEventOpportunity flushEventOpportunity();
+    FlushEventOpportunity flushEventOpportunity();
 }
diff --git a/community/io/src/main/java/org/neo4j/io/pagecache/tracing/PageCacheTracer.java b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/PageCacheTracer.java
index 6eec51a012bb4..527f1bc5af363 100644
--- a/community/io/src/main/java/org/neo4j/io/pagecache/tracing/PageCacheTracer.java
+++ b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/PageCacheTracer.java
@@ -52,12 +52,6 @@ public EvictionRunEvent beginPageEvictions( int pageCountToEvict )
             return EvictionRunEvent.NULL;
         }
 
-        @Override
-        public PinEvent beginPin( boolean writeLock, long filePageId, PageSwapper swapper )
-        {
-            return PinEvent.NULL;
-        }
-
         @Override
         public MajorFlushEvent beginFileFlush( PageSwapper swapper )
         {
@@ -130,6 +124,26 @@ public long evictionExceptions()
             return 0;
         }
 
+        @Override
+        public void pins( long pins )
+        {
+        }
+
+        @Override
+        public void unpins( long unpins )
+        {
+        }
+
+        @Override
+        public void faults( long faults )
+        {
+        }
+
+        @Override
+        public void bytesRead( long bytesRead )
+        {
+        }
+
         @Override
         public String toString()
         {
@@ -156,11 +170,6 @@ public String toString()
      **/
     EvictionRunEvent beginPageEvictions( int pageCountToEvict );
 
-    /**
-     * A page is to be pinned.
-     */
-    PinEvent beginPin( boolean writeLock, long filePageId, PageSwapper swapper );
-
     /**
      * A PagedFile wants to flush all its bound pages.
      */
@@ -170,4 +179,12 @@ public String toString()
      * The PageCache wants to flush all its bound pages.
      */
     MajorFlushEvent beginCacheFlush();
+
+    void pins( long pins );
+
+    void unpins( long unpins );
+
+    void faults( long faults );
+
+    void bytesRead( long bytesRead );
 }
diff --git a/community/io/src/main/java/org/neo4j/io/pagecache/tracing/PinEvent.java b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/PinEvent.java
index 7d2ee2c04b4f3..32ff6b55c26db 100644
--- a/community/io/src/main/java/org/neo4j/io/pagecache/tracing/PinEvent.java
+++ b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/PinEvent.java
@@ -49,15 +49,15 @@ public void done()
     /**
      * The id of the cache page that holds the file page we pinned.
      */
-    public void setCachePageId( int cachePageId );
+    void setCachePageId( int cachePageId );
 
     /**
      * The page we want to pin is not in memory, so being a page fault to load it in.
      */
-    public PageFaultEvent beginPageFault();
+    PageFaultEvent beginPageFault();
 
     /**
      * The pinning has completed and the page is now unpinned.
      */
-    public void done();
+    void done();
 }
diff --git a/community/io/src/main/java/org/neo4j/io/pagecache/tracing/cursor/DefaultPageCursorTracer.java b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/cursor/DefaultPageCursorTracer.java
new file mode 100644
index 0000000000000..3711ad63f7cd2
--- /dev/null
+++ b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/cursor/DefaultPageCursorTracer.java
@@ -0,0 +1,218 @@
+/*
+ * Copyright (c) 2002-2017 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.io.pagecache.tracing.cursor;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.lang.invoke.SwitchPoint;
+import java.util.Objects;
+
+import org.neo4j.io.pagecache.PageSwapper;
+import org.neo4j.io.pagecache.tracing.EvictionEvent;
+import org.neo4j.io.pagecache.tracing.PageCacheTracer;
+import org.neo4j.io.pagecache.tracing.PageFaultEvent;
+import org.neo4j.io.pagecache.tracing.PinEvent;
+
+import static org.neo4j.unsafe.impl.internal.dragons.FeatureToggles.packageFlag;
+
+public class DefaultPageCursorTracer implements PageCursorTracer
+{
+    private long pins = 0L;
+    private long unpins = 0L;
+    private long faults = 0L;
+    private long bytesRead = 0L;
+
+    private PageCacheTracer pageCacheTracer;
+
+    private static final MethodHandle beginPinMH;
+    private static final SwitchPoint beginPinSwitchPoint;
+    static
+    {
+        try
+        {
+            // A hidden setting to have pin/unpin monitoring enabled from the start by default.
+            // NOTE: This flag is documented in jmx.asciidoc
+            boolean alwaysEnabled = packageFlag( DefaultPageCursorTracer.class, "tracePinUnpin", true );
+
+            MethodType type = MethodType.methodType( PinEvent.class );
+            MethodHandles.Lookup lookup = MethodHandles.lookup();
+            MethodHandle monitoredPinMH = lookup.findVirtual( DefaultPageCursorTracer.class, "beginTracingPin", type );
+            if ( alwaysEnabled )
+            {
+                beginPinMH = monitoredPinMH;
+                beginPinSwitchPoint = null;
+            }
+            else
+            {
+                MethodHandle nullPinMH = lookup.findVirtual( DefaultPageCursorTracer.class, "beginNullPin", type );
+                beginPinSwitchPoint = new SwitchPoint();
+                beginPinMH = beginPinSwitchPoint.guardWithTest( nullPinMH, monitoredPinMH );
+            }
+        }
+        catch ( Exception e )
+        {
+            throw new AssertionError( "Unexpected MethodHandle initiation error", e );
+        }
+    }
+
+    /**
+     * Enable monitoring of page pins and unpins, which is disabled by default for
+     * performance reasons.
+     *
+     * This is a one-way operation; once monitoring of pinning and unpinning has been
+     * enabled, it cannot be disabled again without restarting the JVM.
+     */
+    public static void enablePinUnpinTracing()
+    {
+        if ( beginPinSwitchPoint != null && !beginPinSwitchPoint.hasBeenInvalidated() )
+        {
+            SwitchPoint.invalidateAll( new SwitchPoint[]{ beginPinSwitchPoint } );
+        }
+    }
+
+    public void init( PageCacheTracer pageCacheTracer )
+    {
+        this.pageCacheTracer = pageCacheTracer;
+        reset();
+    }
+
+    private void reset()
+    {
+        pins = 0;
+        unpins = 0;
+        faults = 0;
+        bytesRead = 0;
+    }
+
+    public void reportEvents()
+    {
+        Objects.nonNull( pageCacheTracer );
+        pageCacheTracer.pins( pins );
+        pageCacheTracer.unpins( unpins );
+        pageCacheTracer.faults( faults );
+        pageCacheTracer.bytesRead( bytesRead );
+    }
+
+    @Override
+    public PinEvent beginPin( boolean writeLock, long filePageId, PageSwapper swapper )
+    {
+        try
+        {
+            return (PinEvent) beginPinMH.invokeExact( this );
+        }
+        catch ( Throwable throwable )
+        {
+            throw new AssertionError( "Unexpected MethodHandle error", throwable );
+        }
+    }
+
+    /**
+     * Invoked through beginPinMH.
+     */
+    @SuppressWarnings( "UnusedDeclaration" )
+    private PinEvent beginNullPin()
+    {
+        return nullPinEvent;
+    }
+
+    /**
+     * Invoked through beginPinMH.
+     */
+    @SuppressWarnings( "UnusedDeclaration" )
+    private PinEvent beginTracingPin()
+    {
+        pins++;
+        return pinTracingEvent;
+    }
+
+    private final PinEvent pinTracingEvent = new PinEvent()
+    {
+        @Override
+        public void setCachePageId( int cachePageId )
+        {
+        }
+
+        @Override
+        public PageFaultEvent beginPageFault()
+        {
+            return pageFaultEvent;
+        }
+
+        @Override
+        public void done()
+        {
+            unpins++;
+        }
+    };
+
+    private final PinEvent nullPinEvent = new PinEvent()
+    {
+        @Override
+        public void setCachePageId( int cachePageId )
+        {
+        }
+
+        @Override
+        public PageFaultEvent beginPageFault()
+        {
+            return pageFaultEvent;
+        }
+
+        @Override
+        public void done()
+        {
+        }
+    };
+
+    private final PageFaultEvent pageFaultEvent = new PageFaultEvent()
+    {
+        @Override
+        public void addBytesRead( long bytes )
+        {
+            bytesRead = +bytes;
+        }
+
+        @Override
+        public void done()
+        {
+            faults++;
+        }
+
+        @Override
+        public void done( Throwable throwable )
+        {
+            done();
+        }
+
+        @Override
+        public EvictionEvent beginEviction()
+        {
+            //TODO: is that correct to assume that it will never be the case and can be ignored?
+            return EvictionEvent.NULL;
+        }
+
+        @Override
+        public void setCachePageId( int cachePageId )
+        {
+        }
+    };
+
+}
diff --git a/community/io/src/main/java/org/neo4j/io/pagecache/tracing/cursor/PageCursorTracer.java b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/cursor/PageCursorTracer.java
new file mode 100644
index 0000000000000..a915fd56847fb
--- /dev/null
+++ b/community/io/src/main/java/org/neo4j/io/pagecache/tracing/cursor/PageCursorTracer.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2002-2017 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.io.pagecache.tracing.cursor;
+
+import org.neo4j.io.pagecache.PageSwapper;
+import org.neo4j.io.pagecache.tracing.PinEvent;
+
+public interface PageCursorTracer
+{
+
+    PageCursorTracer NULL = ( writeLock, filePageId, swapper ) -> PinEvent.NULL;
+
+    PinEvent beginPin( boolean writeLock, long filePageId, PageSwapper swapper );
+
+}
diff --git a/community/io/src/test/java/org/neo4j/io/pagecache/PageCacheTest.java b/community/io/src/test/java/org/neo4j/io/pagecache/PageCacheTest.java
index 23a6640b4b28a..3860434b1def4 100644
--- a/community/io/src/test/java/org/neo4j/io/pagecache/PageCacheTest.java
+++ b/community/io/src/test/java/org/neo4j/io/pagecache/PageCacheTest.java
@@ -73,6 +73,7 @@
 import org.neo4j.io.pagecache.tracing.PageCacheTracer;
 import org.neo4j.io.pagecache.tracing.PinEvent;
 import org.neo4j.test.rule.RepeatRule;
+import org.neo4j.io.pagecache.tracing.cursor.DefaultPageCursorTracer;
 
 import static java.lang.Long.toHexString;
 import static java.lang.System.currentTimeMillis;
@@ -111,7 +112,7 @@ public abstract class PageCacheTest<T extends PageCache> extends PageCacheTestSu
     @BeforeClass
     public static void enablePinUnpinMonitoring()
     {
-        DefaultPageCacheTracer.enablePinUnpinTracing();
+        DefaultPageCursorTracer.enablePinUnpinTracing();
     }
 
     @Test
@@ -2230,12 +2231,13 @@ public void tracerMustBeNotifiedOfReadAndWritePins() throws Exception
 
         DefaultPageCacheTracer tracer = new DefaultPageCacheTracer()
         {
-            @Override
-            public PinEvent beginPin( boolean writeLock, long filePageId, PageSwapper swapper )
-            {
-                (writeLock? writeCount : readCount).getAndIncrement();
-                return super.beginPin( writeLock, filePageId, swapper );
-            }
+            //TODO::
+//            @Override
+//            public PinEvent beginPin( boolean writeLock, long filePageId, PageSwapper swapper )
+//            {
+//                (writeLock? writeCount : readCount).getAndIncrement();
+//                return super.beginPin( writeLock, filePageId, swapper );
+//            }
         };
         generateFileWithRecords( file( "a" ), recordCount, recordSize );
 
diff --git a/community/io/src/test/java/org/neo4j/io/pagecache/RecordingPageCacheTracer.java b/community/io/src/test/java/org/neo4j/io/pagecache/RecordingPageCacheTracer.java
index 0011cd6159a08..8a94b4215b70c 100644
--- a/community/io/src/test/java/org/neo4j/io/pagecache/RecordingPageCacheTracer.java
+++ b/community/io/src/test/java/org/neo4j/io/pagecache/RecordingPageCacheTracer.java
@@ -56,21 +56,11 @@ public RecordingPageCacheTracer( Class<? extends Event>... eventTypesToTrace )
         Collections.addAll( this.eventTypesToTrace, eventTypesToTrace );
     }
 
-    private void pageFaulted( long filePageId, PageSwapper swapper )
-    {
-        record( new Fault( swapper, filePageId ) );
-    }
-
     private void evicted( long filePageId, PageSwapper swapper )
     {
         record( new Evict( swapper, filePageId ) );
     }
 
-    private void pinned( long filePageId, PageSwapper swapper )
-    {
-        record( new Pin( swapper, filePageId ) );
-    }
-
     private void record( Event event )
     {
         if ( eventTypesToTrace.contains( event.getClass() ) )
@@ -110,58 +100,6 @@ public void close()
         };
     }
 
-    @Override
-    public PinEvent beginPin( boolean writeLock, final long filePageId, final PageSwapper swapper )
-    {
-        return new PinEvent()
-        {
-            @Override
-            public void setCachePageId( int cachePageId )
-            {
-            }
-
-            @Override
-            public PageFaultEvent beginPageFault()
-            {
-                return new PageFaultEvent()
-                {
-                    @Override
-                    public void addBytesRead( long bytes )
-                    {
-                    }
-
-                    @Override
-                    public void done()
-                    {
-                        pageFaulted( filePageId, swapper );
-                    }
-
-                    @Override
-                    public void done( Throwable throwable )
-                    {
-                    }
-
-                    @Override
-                    public EvictionEvent beginEviction()
-                    {
-                        return new RecordingEvictionEvent();
-                    }
-
-                    @Override
-                    public void setCachePageId( int cachePageId )
-                    {
-                    }
-                };
-            }
-
-            @Override
-            public void done()
-            {
-                pinned( filePageId, swapper );
-            }
-        };
-    }
-
     @Override
     public MajorFlushEvent beginFileFlush( PageSwapper swapper )
     {
@@ -234,6 +172,26 @@ public long evictionExceptions()
         return 0;
     }
 
+    @Override
+    public void pins( long pins )
+    {
+    }
+
+    @Override
+    public void unpins( long unpins )
+    {
+    }
+
+    @Override
+    public void faults( long faults )
+    {
+    }
+
+    @Override
+    public void bytesRead( long bytesRead )
+    {
+    }
+
     public <T extends Event> T observe( Class<T> type ) throws InterruptedException
     {
         return type.cast( record.take() );
diff --git a/community/io/src/test/java/org/neo4j/io/pagecache/RecordingPageCursorTracer.java b/community/io/src/test/java/org/neo4j/io/pagecache/RecordingPageCursorTracer.java
new file mode 100644
index 0000000000000..5632f4cb82e6b
--- /dev/null
+++ b/community/io/src/test/java/org/neo4j/io/pagecache/RecordingPageCursorTracer.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2002-2017 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.io.pagecache;
+
+import org.neo4j.io.pagecache.tracing.EvictionEvent;
+import org.neo4j.io.pagecache.tracing.PageFaultEvent;
+import org.neo4j.io.pagecache.tracing.PinEvent;
+import org.neo4j.io.pagecache.tracing.cursor.PageCursorTracer;
+
+public class RecordingPageCursorTracer implements PageCursorTracer
+{
+    @Override
+    public PinEvent beginPin( boolean writeLock, final long filePageId, final PageSwapper swapper )
+    {
+        return new PinEvent()
+        {
+            @Override
+            public void setCachePageId( int cachePageId )
+            {
+            }
+
+            @Override
+            public PageFaultEvent beginPageFault()
+            {
+                return new PageFaultEvent()
+                {
+                    @Override
+                    public void addBytesRead( long bytes )
+                    {
+                    }
+
+                    @Override
+                    public void done()
+                    {
+                        pageFaulted( filePageId, swapper );
+                    }
+
+                    @Override
+                    public void done( Throwable throwable )
+                    {
+                    }
+
+                    @Override
+                    public EvictionEvent beginEviction()
+                    {
+                        return EvictionEvent.NULL;
+                    }
+
+                    @Override
+                    public void setCachePageId( int cachePageId )
+                    {
+                    }
+                };
+            }
+
+            @Override
+            public void done()
+            {
+                pinned( filePageId, swapper );
+            }
+        };
+    }
+
+    //TODO:
+    private void pageFaulted( long filePageId, PageSwapper swapper )
+    {
+//        record( new Fault( swapper, filePageId ) );
+    }
+
+    private void pinned( long filePageId, PageSwapper swapper )
+    {
+//        record( new Pin( swapper, filePageId ) );
+    }
+}
diff --git a/community/io/src/test/java/org/neo4j/io/pagecache/tracing/DefaultPageCacheTracerTest.java b/community/io/src/test/java/org/neo4j/io/pagecache/tracing/DefaultPageCacheTracerTest.java
index 7d433a944baf7..77a87e0ed83b9 100644
--- a/community/io/src/test/java/org/neo4j/io/pagecache/tracing/DefaultPageCacheTracerTest.java
+++ b/community/io/src/test/java/org/neo4j/io/pagecache/tracing/DefaultPageCacheTracerTest.java
@@ -19,12 +19,109 @@
  */
 package org.neo4j.io.pagecache.tracing;
 
-public class DefaultPageCacheTracerTest extends PageCacheTracerTest
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.IOException;
+
+import org.neo4j.io.pagecache.PageSwapper;
+
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+
+public class DefaultPageCacheTracerTest
 {
-    @Override
-    protected DefaultPageCacheTracer createTracer()
+    private PageCacheTracer tracer;
+    private PageSwapper swapper;
+
+    @Before
+    public void setUp()
+    {
+        tracer = new DefaultPageCacheTracer();
+        swapper = new DummyPageSwapper( "filename" );
+    }
+
+    private void assertCounts( long pins, long unpins, long faults, long evictions, long evictionExceptions,
+                               long flushes, long bytesRead, long bytesWritten, long filesMapped, long filesUnmapped )
+    {
+        assertThat( "pins", tracer.pins(), is( pins ) );
+        assertThat( "unpins", tracer.unpins(), is( unpins ) );
+        assertThat( "faults", tracer.faults(), is( faults ) );
+        assertThat( "evictions", tracer.evictions(), is( evictions ) );
+        assertThat( "evictionExceptions", tracer.evictionExceptions(), is( evictionExceptions ) );
+        assertThat( "flushes", tracer.flushes(), is( flushes ) );
+        assertThat( "bytesRead", tracer.bytesRead(), is( bytesRead ) );
+        assertThat( "bytesWritten", tracer.bytesWritten(), is( bytesWritten ) );
+        assertThat( "filesMapped", tracer.filesMapped(), is( filesMapped ) );
+        assertThat( "filesUnmapped", tracer.filesUnmapped(), is( filesUnmapped ) );
+    }
+
+    @Test
+    public void mustCountEvictions()
     {
-        DefaultPageCacheTracer.enablePinUnpinTracing();
-        return new DefaultPageCacheTracer();
+        try ( EvictionRunEvent evictionRunEvent = tracer.beginPageEvictions( 2 ) )
+        {
+            try ( EvictionEvent evictionEvent = evictionRunEvent.beginEviction() )
+            {
+                FlushEvent flushEvent = evictionEvent.flushEventOpportunity().beginFlush( 0, 0, swapper );
+                flushEvent.addBytesWritten( 12 );
+                flushEvent.done();
+            }
+
+            try ( EvictionEvent evictionEvent = evictionRunEvent.beginEviction() )
+            {
+                FlushEvent flushEvent = evictionEvent.flushEventOpportunity().beginFlush( 0, 0, swapper );
+                flushEvent.addBytesWritten( 12 );
+                flushEvent.done();
+                evictionEvent.threwException( new IOException() );
+            }
+
+            try ( EvictionEvent evictionEvent = evictionRunEvent.beginEviction() )
+            {
+                FlushEvent flushEvent = evictionEvent.flushEventOpportunity().beginFlush( 0, 0, swapper );
+                flushEvent.addBytesWritten( 12 );
+                flushEvent.done();
+                evictionEvent.threwException( new IOException() );
+            }
+
+            evictionRunEvent.beginEviction().close();
+        }
+
+        assertCounts( 0, 0, 0, 4, 2, 3, 0, 36, 0, 0 );
+    }
+
+    @Test
+    public void mustCountFileMappingAndUnmapping()
+    {
+        tracer.mappedFile( new File( "a" ) );
+
+        assertCounts( 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 );
+
+        tracer.unmappedFile( new File( "a" ) );
+
+        assertCounts( 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 );
+    }
+
+    @Test
+    public void mustCountFlushes()
+    {
+        try ( MajorFlushEvent cacheFlush = tracer.beginCacheFlush() )
+        {
+            cacheFlush.flushEventOpportunity().beginFlush( 0, 0, swapper ).done();
+            cacheFlush.flushEventOpportunity().beginFlush( 0, 0, swapper ).done();
+            cacheFlush.flushEventOpportunity().beginFlush( 0, 0, swapper ).done();
+        }
+
+        assertCounts( 0, 0, 0, 0, 0, 3, 0, 0, 0, 0 );
+
+        try ( MajorFlushEvent fileFlush = tracer.beginFileFlush( swapper ) )
+        {
+            fileFlush.flushEventOpportunity().beginFlush( 0, 0, swapper ).done();
+            fileFlush.flushEventOpportunity().beginFlush( 0, 0, swapper ).done();
+            fileFlush.flushEventOpportunity().beginFlush( 0, 0, swapper ).done();
+        }
+
+        assertCounts( 0, 0, 0, 0, 0, 6, 0, 0, 0, 0 );
     }
 }
diff --git a/community/io/src/test/java/org/neo4j/io/pagecache/tracing/DefaultPageCursorTracerTest.java b/community/io/src/test/java/org/neo4j/io/pagecache/tracing/DefaultPageCursorTracerTest.java
new file mode 100644
index 0000000000000..8905a3ac76e56
--- /dev/null
+++ b/community/io/src/test/java/org/neo4j/io/pagecache/tracing/DefaultPageCursorTracerTest.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2002-2017 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.io.pagecache.tracing;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import org.neo4j.io.pagecache.PageSwapper;
+import org.neo4j.io.pagecache.tracing.cursor.DefaultPageCursorTracer;
+import org.neo4j.io.pagecache.tracing.cursor.PageCursorTracer;
+
+public class DefaultPageCursorTracerTest
+{
+//TODO:
+    private PageSwapper swapper;
+    private PageCursorTracer tracer;
+
+    @Before
+    public void setUp()
+    {
+        tracer = createTracer();
+        swapper = new DummyPageSwapper( "filename" );
+    }
+
+    @Test
+    public void mustCountPinsAndUnpins()
+    {
+        PinEvent pinEvent = tracer.beginPin( true, 0, swapper );
+        pinEvent.done();
+
+        // We don't particularly care whether the counts are incremented on begin or close
+    }
+
+    @Test
+    public void mustCountPageFaults()
+    {
+        PinEvent pinEvent = tracer.beginPin( true, 0, swapper );
+        PageFaultEvent pageFaultEvent = pinEvent.beginPageFault();
+        pageFaultEvent.addBytesRead( 42 );
+        pageFaultEvent.done();
+        pageFaultEvent = pinEvent.beginPageFault();
+        pageFaultEvent.addBytesRead( 42 );
+        pageFaultEvent.done();
+        pinEvent.done();
+
+    }
+
+    private PageCursorTracer createTracer()
+    {
+        DefaultPageCursorTracer.enablePinUnpinTracing();
+        return new DefaultPageCursorTracer();
+    }
+
+}
diff --git a/community/io/src/test/java/org/neo4j/io/pagecache/tracing/DelegatingPageCacheTracer.java b/community/io/src/test/java/org/neo4j/io/pagecache/tracing/DelegatingPageCacheTracer.java
index 980c7c1a28405..eb78cce1032ac 100644
--- a/community/io/src/test/java/org/neo4j/io/pagecache/tracing/DelegatingPageCacheTracer.java
+++ b/community/io/src/test/java/org/neo4j/io/pagecache/tracing/DelegatingPageCacheTracer.java
@@ -82,11 +82,6 @@ public long filesUnmapped()
         return delegate.filesUnmapped();
     }
 
-    public PinEvent beginPin( boolean writeLock, long filePageId, PageSwapper swapper )
-    {
-        return delegate.beginPin( writeLock, filePageId, swapper );
-    }
-
     public void unmappedFile( File file )
     {
         delegate.unmappedFile( file );
@@ -97,6 +92,30 @@ public long evictionExceptions()
         return delegate.evictionExceptions();
     }
 
+    @Override
+    public void pins( long pins )
+    {
+        delegate.pins( pins );
+    }
+
+    @Override
+    public void unpins( long unpins )
+    {
+        delegate.unpins( unpins );
+    }
+
+    @Override
+    public void faults( long faults )
+    {
+        delegate.faults( faults );
+    }
+
+    @Override
+    public void bytesRead( long bytesRead )
+    {
+        delegate.bytesRead( bytesRead );
+    }
+
     public long filesMapped()
     {
         return delegate.filesMapped();
diff --git a/community/io/src/test/java/org/neo4j/io/pagecache/tracing/DelegatingPageCursorTracer.java b/community/io/src/test/java/org/neo4j/io/pagecache/tracing/DelegatingPageCursorTracer.java
new file mode 100644
index 0000000000000..c36b43a685256
--- /dev/null
+++ b/community/io/src/test/java/org/neo4j/io/pagecache/tracing/DelegatingPageCursorTracer.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2002-2017 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.io.pagecache.tracing;
+
+import org.neo4j.io.pagecache.PageSwapper;
+import org.neo4j.io.pagecache.tracing.cursor.PageCursorTracer;
+
+public class DelegatingPageCursorTracer implements PageCursorTracer
+{
+
+    private final PageCursorTracer delegate;
+
+    public DelegatingPageCursorTracer( PageCursorTracer delegate )
+    {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public PinEvent beginPin( boolean writeLock, long filePageId, PageSwapper swapper )
+    {
+        return null;
+    }
+}
diff --git a/community/io/src/test/java/org/neo4j/io/pagecache/tracing/PageCacheTracerTest.java b/community/io/src/test/java/org/neo4j/io/pagecache/tracing/PageCacheTracerTest.java
deleted file mode 100644
index bc39936d3e467..0000000000000
--- a/community/io/src/test/java/org/neo4j/io/pagecache/tracing/PageCacheTracerTest.java
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
- * Copyright (c) 2002-2017 "Neo Technology,"
- * Network Engine for Objects in Lund AB [http://neotechnology.com]
- *
- * This file is part of Neo4j.
- *
- * Neo4j is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-package org.neo4j.io.pagecache.tracing;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import java.io.File;
-import java.io.IOException;
-
-import org.neo4j.io.pagecache.PageSwapper;
-
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertThat;
-
-public abstract class PageCacheTracerTest
-{
-    private PageCacheTracer tracer;
-    private PageSwapper swapper;
-
-    @Before
-    public void setUp()
-    {
-        tracer = createTracer();
-        swapper = new DummyPageSwapper( "filename" );
-    }
-
-    protected abstract PageCacheTracer createTracer();
-
-    @Test
-    public void mustCountPinsAndUnpins()
-    {
-        PinEvent pinEvent = tracer.beginPin( true, 0, swapper );
-        pinEvent.done();
-
-        // We don't particularly care whether the counts are incremented on begin or close
-
-        assertCounts( 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 );
-    }
-
-    private void assertCounts( long pins, long unpins, long faults, long evictions, long evictionExceptions,
-                               long flushes, long bytesRead, long bytesWritten, long filesMapped, long filesUnmapped )
-    {
-        assertThat( "pins", tracer.pins(), is( pins ) );
-        assertThat( "unpins", tracer.unpins(), is( unpins ) );
-        assertThat( "faults", tracer.faults(), is( faults ) );
-        assertThat( "evictions", tracer.evictions(), is( evictions ) );
-        assertThat( "evictionExceptions", tracer.evictionExceptions(), is( evictionExceptions ) );
-        assertThat( "flushes", tracer.flushes(), is( flushes ) );
-        assertThat( "bytesRead", tracer.bytesRead(), is( bytesRead ) );
-        assertThat( "bytesWritten", tracer.bytesWritten(), is( bytesWritten ) );
-        assertThat( "filesMapped", tracer.filesMapped(), is( filesMapped ) );
-        assertThat( "filesUnmapped", tracer.filesUnmapped(), is( filesUnmapped ) );
-    }
-
-    @Test
-    public void mustCountPageFaults()
-    {
-        PinEvent pinEvent = tracer.beginPin( true, 0, swapper );
-        PageFaultEvent pageFaultEvent = pinEvent.beginPageFault();
-        pageFaultEvent.addBytesRead( 42 );
-        pageFaultEvent.done();
-        pageFaultEvent = pinEvent.beginPageFault();
-        pageFaultEvent.addBytesRead( 42 );
-        pageFaultEvent.done();
-        pinEvent.done();
-
-        assertCounts( 1, 1, 2, 0, 0, 0, 84, 0, 0, 0 );
-    }
-
-    @Test
-    public void mustCountEvictions()
-    {
-        try ( EvictionRunEvent evictionRunEvent = tracer.beginPageEvictions( 2 ) )
-        {
-            try ( EvictionEvent evictionEvent = evictionRunEvent.beginEviction() )
-            {
-                FlushEvent flushEvent = evictionEvent.flushEventOpportunity().beginFlush( 0, 0, swapper );
-                flushEvent.addBytesWritten( 12 );
-                flushEvent.done();
-            }
-
-            try ( EvictionEvent evictionEvent = evictionRunEvent.beginEviction() )
-            {
-                FlushEvent flushEvent = evictionEvent.flushEventOpportunity().beginFlush( 0, 0, swapper );
-                flushEvent.addBytesWritten( 12 );
-                flushEvent.done();
-                evictionEvent.threwException( new IOException() );
-            }
-
-            try ( EvictionEvent evictionEvent = evictionRunEvent.beginEviction() )
-            {
-                FlushEvent flushEvent = evictionEvent.flushEventOpportunity().beginFlush( 0, 0, swapper );
-                flushEvent.addBytesWritten( 12 );
-                flushEvent.done();
-                evictionEvent.threwException( new IOException() );
-            }
-
-            evictionRunEvent.beginEviction().close();
-        }
-
-        assertCounts( 0, 0, 0, 4, 2, 3, 0, 36, 0, 0 );
-    }
-
-    @Test
-    public void mustCountFileMappingAndUnmapping()
-    {
-        tracer.mappedFile( new File( "a" ) );
-
-        assertCounts( 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 );
-
-        tracer.unmappedFile( new File( "a" ) );
-
-        assertCounts( 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 );
-    }
-
-    @Test
-    public void mustCountFlushes()
-    {
-        try ( MajorFlushEvent cacheFlush = tracer.beginCacheFlush() )
-        {
-            cacheFlush.flushEventOpportunity().beginFlush( 0, 0, swapper ).done();
-            cacheFlush.flushEventOpportunity().beginFlush( 0, 0, swapper ).done();
-            cacheFlush.flushEventOpportunity().beginFlush( 0, 0, swapper ).done();
-        }
-
-        assertCounts( 0, 0, 0, 0, 0, 3, 0, 0, 0, 0 );
-
-        try ( MajorFlushEvent fileFlush = tracer.beginFileFlush( swapper ) )
-        {
-            fileFlush.flushEventOpportunity().beginFlush( 0, 0, swapper ).done();
-            fileFlush.flushEventOpportunity().beginFlush( 0, 0, swapper ).done();
-            fileFlush.flushEventOpportunity().beginFlush( 0, 0, swapper ).done();
-        }
-
-        assertCounts( 0, 0, 0, 0, 0, 6, 0, 0, 0, 0 );
-    }
-}
diff --git a/community/io/src/test/java/org/neo4j/test/LinearHistoryPageCacheTracer.java b/community/io/src/test/java/org/neo4j/test/LinearHistoryPageCacheTracer.java
index ac7254e08208d..9c7143d8460ed 100644
--- a/community/io/src/test/java/org/neo4j/test/LinearHistoryPageCacheTracer.java
+++ b/community/io/src/test/java/org/neo4j/test/LinearHistoryPageCacheTracer.java
@@ -546,12 +546,6 @@ public EvictionRunEvent beginPageEvictions( int pageCountToEvict )
         return add( new EvictionRunHEvent( pageCountToEvict ) );
     }
 
-    @Override
-    public PinEvent beginPin( boolean writeLock, long filePageId, PageSwapper swapper )
-    {
-        return add( new PinHEvent( writeLock, filePageId, swapper ));
-    }
-
     @Override
     public MajorFlushEvent beginFileFlush( PageSwapper swapper )
     {
@@ -624,6 +618,29 @@ public long evictionExceptions()
         return 0;
     }
 
+    @Override
+    public void pins( long pins )
+    {
+    }
+
+    @Override
+    public void unpins( long unpins )
+    {
+
+    }
+
+    @Override
+    public void faults( long faults )
+    {
+
+    }
+
+    @Override
+    public void bytesRead( long bytesRead )
+    {
+
+    }
+
     private class HistoryPrinter implements Consumer<HEvent>
     {
         private final List<HEvent> concurrentIntervals;
diff --git a/community/io/src/test/java/org/neo4j/test/LinearHistoryPageCursorTracer.java b/community/io/src/test/java/org/neo4j/test/LinearHistoryPageCursorTracer.java
new file mode 100644
index 0000000000000..4e38aab16201a
--- /dev/null
+++ b/community/io/src/test/java/org/neo4j/test/LinearHistoryPageCursorTracer.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2002-2017 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.test;
+
+import org.neo4j.io.pagecache.PageSwapper;
+import org.neo4j.io.pagecache.tracing.PinEvent;
+import org.neo4j.io.pagecache.tracing.cursor.PageCursorTracer;
+
+public class LinearHistoryPageCursorTracer implements PageCursorTracer
+{
+
+    //TODO:
+    @Override
+    public PinEvent beginPin( boolean writeLock, long filePageId, PageSwapper swapper )
+    {
+        return PinEvent.NULL;
+    }
+
+}
diff --git a/stresstests/src/test/java/org/neo4j/io/pagecache/stresstests/PageCacheStressTesting.java b/stresstests/src/test/java/org/neo4j/io/pagecache/stresstests/PageCacheStressTesting.java
index c135b31835c5a..9f4301584f301 100644
--- a/stresstests/src/test/java/org/neo4j/io/pagecache/stresstests/PageCacheStressTesting.java
+++ b/stresstests/src/test/java/org/neo4j/io/pagecache/stresstests/PageCacheStressTesting.java
@@ -26,6 +26,7 @@
 import org.neo4j.io.fs.FileUtils;
 import org.neo4j.io.pagecache.stress.PageCacheStressTest;
 import org.neo4j.io.pagecache.tracing.DefaultPageCacheTracer;
+import org.neo4j.io.pagecache.tracing.cursor.DefaultPageCursorTracer;
 
 import static java.lang.Integer.parseInt;
 import static java.lang.System.getProperty;
@@ -43,7 +44,7 @@ public class PageCacheStressTesting
         // Pin/Unpin monitoring is disabled by default for performance reasons,
         // but we have tests that verify that pinned and unpinned are called
         // correctly.
-        DefaultPageCacheTracer.enablePinUnpinTracing();
+        DefaultPageCursorTracer.enablePinUnpinTracing();
     }
 
     @Test