Global and database local transaction statistics.

Introduce possibility to track transaction statistic per database, while
keeping possibility to get aggregated number for whole server.

Change local database counters from using AtomicLong to LongAdder.

community/community-it/cypher-it/src/test/scala/org/neo4j/cypher/GraphIcing.scala

@@ -35,7 +35,7 @@ import org.neo4j.kernel.impl.coreapi.{InternalTransaction, PropertyContainerLock
 import org.neo4j.kernel.impl.factory.GraphDatabaseFacade
 import org.neo4j.kernel.impl.query._
 import org.neo4j.kernel.impl.query.clientconnection.ClientConnectionInfo
-import org.neo4j.kernel.impl.transaction.TransactionStats
+import org.neo4j.kernel.impl.transaction.stats.DatabaseTransactionStats
 import org.neo4j.kernel.impl.util.ValueUtils.asMapValue
 
 import scala.collection.JavaConverters._
@@ -151,7 +151,7 @@ trait GraphIcing {
 
     def txCounts = TxCounts(txMonitor.getNumberOfCommittedTransactions, txMonitor.getNumberOfRolledBackTransactions, txMonitor.getNumberOfActiveTransactions)
 
-    private def txMonitor: TransactionStats = graph.getDependencyResolver.resolveDependency(classOf[TransactionStats])
+    private def txMonitor: DatabaseTransactionStats = graph.getDependencyResolver.resolveDependency(classOf[DatabaseTransactionStats])
 
     private def txBridge: ThreadToStatementContextBridge = graph.getDependencyResolver.resolveDependency(classOf[ThreadToStatementContextBridge])
   }

community/community-it/kernel-it/src/test/java/org/neo4j/kernel/impl/transaction/CommitContentionTest.java

@@ -24,7 +24,6 @@
 import org.junit.Rule;
 import org.junit.Test;
 
-import java.io.File;
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.atomic.AtomicReference;
 
@@ -33,9 +32,9 @@
 import org.neo4j.graphdb.facade.GraphDatabaseFacadeFactory;
 import org.neo4j.graphdb.factory.GraphDatabaseFactoryState;
 import org.neo4j.graphdb.factory.module.CommunityEditionModule;
-import org.neo4j.graphdb.factory.module.PlatformModule;
 import org.neo4j.kernel.configuration.Config;
 import org.neo4j.kernel.impl.factory.DatabaseInfo;
+import org.neo4j.kernel.impl.transaction.stats.DatabaseTransactionStats;
 import org.neo4j.test.rule.TestDirectory;
 
 import static java.util.concurrent.TimeUnit.SECONDS;
@@ -118,45 +117,14 @@ private Thread startFirstTransactionWhichBlocksDuringPushUntilSecondTransactionF
     private GraphDatabaseService createDb()
     {
         GraphDatabaseFactoryState state = new GraphDatabaseFactoryState();
-        //noinspection deprecation
-        return new GraphDatabaseFacadeFactory( DatabaseInfo.COMMUNITY, CommunityEditionModule::new )
+        return new GraphDatabaseFacadeFactory( DatabaseInfo.COMMUNITY, platformModule -> new CommunityEditionModule( platformModule )
         {
             @Override
-            protected PlatformModule createPlatform( File storeDir, Config config, Dependencies dependencies )
+            public DatabaseTransactionStats createTransactionMonitor()
             {
-                return new PlatformModule( storeDir, config, databaseInfo, dependencies )
-                {
-                    @Override
-                    protected TransactionStats createTransactionStats()
-                    {
-                        return new TransactionStats()
-                        {
-                            public boolean skip;
-
-                            @Override
-                            public void transactionFinished( boolean committed, boolean write )
-                            {
-                                super.transactionFinished( committed, write );
-
-                                if ( committed )
-                                {
-                                    // skip signal and waiting for second transaction
-                                    if ( skip )
-                                    {
-                                        return;
-                                    }
-                                    skip = true;
-
-                                    signalFirstTransactionStartedPushing();
-
-                                    waitForSecondTransactionToFinish();
-                                }
-                            }
-                        };
-                    }
-                };
+                return new SkipTransactionDatabaseStats();
             }
-        }.newFacade( storeLocation.storeDir(), Config.defaults(), state.databaseDependencies() );
+        } ).newFacade( storeLocation.storeDir(), Config.defaults(), state.databaseDependencies() );
     }
 
     private void waitForFirstTransactionToStartPushing() throws InterruptedException
@@ -193,4 +161,29 @@ private void waitForSecondTransactionToFinish()
             reference.set( e );
         }
     }
+
+    private class SkipTransactionDatabaseStats extends DatabaseTransactionStats
+    {
+        boolean skip;
+
+        @Override
+        public void transactionFinished( boolean committed, boolean write )
+        {
+            super.transactionFinished( committed, write );
+
+            if ( committed )
+            {
+                // skip signal and waiting for second transaction
+                if ( skip )
+                {
+                    return;
+                }
+                skip = true;
+
+                signalFirstTransactionStartedPushing();
+
+                waitForSecondTransactionToFinish();
+            }
+        }
+    }
 }

community/community-it/kernel-it/src/test/java/org/neo4j/kernel/impl/transaction/TransactionMonitorTest.java

@@ -29,6 +29,7 @@
 import org.neo4j.function.ThrowingConsumer;
 import org.neo4j.graphdb.GraphDatabaseService;
 import org.neo4j.graphdb.Transaction;
+import org.neo4j.kernel.impl.transaction.stats.TransactionCounters;
 import org.neo4j.kernel.internal.GraphDatabaseAPI;
 import org.neo4j.test.TestGraphDatabaseFactory;
 

community/kernel/src/main/java/org/neo4j/kernel/DatabaseAvailability.java

@@ -21,9 +21,8 @@
 
 import java.time.Clock;
 
-import org.neo4j.kernel.impl.transaction.TransactionStats;
+import org.neo4j.kernel.impl.transaction.stats.TransactionCounters;
 import org.neo4j.kernel.lifecycle.LifecycleAdapter;
-import org.neo4j.time.Clocks;
 
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import static java.util.concurrent.locks.LockSupport.parkNanos;
@@ -39,16 +38,18 @@ public class DatabaseAvailability extends LifecycleAdapter
 {
     private static final AvailabilityRequirement AVAILABILITY_REQUIREMENT = availabilityRequirement( "Database available" );
     private final AvailabilityGuard availabilityGuard;
-    private final TransactionStats transactionMonitor;
+    private final TransactionCounters transactionCounters;
+    private final Clock clock;
     private final long awaitActiveTransactionDeadlineMillis;
     private volatile boolean started;
 
-    public DatabaseAvailability( AvailabilityGuard availabilityGuard, TransactionStats transactionMonitor,
+    public DatabaseAvailability( AvailabilityGuard availabilityGuard, TransactionCounters transactionCounters, Clock clock,
             long awaitActiveTransactionDeadlineMillis )
     {
         this.availabilityGuard = availabilityGuard;
-        this.transactionMonitor = transactionMonitor;
+        this.transactionCounters = transactionCounters;
         this.awaitActiveTransactionDeadlineMillis = awaitActiveTransactionDeadlineMillis;
+        this.clock = clock;
 
         // On initial setup, deny availability
         availabilityGuard.require( AVAILABILITY_REQUIREMENT );
@@ -80,9 +81,8 @@ public boolean isStarted()
 
     private void awaitTransactionsClosedWithinTimeout()
     {
-        Clock clock = Clocks.systemClock();
         long deadline = clock.millis() + awaitActiveTransactionDeadlineMillis;
-        while ( transactionMonitor.getNumberOfActiveTransactions() > 0 && clock.millis() < deadline )
+        while ( transactionCounters.getNumberOfActiveTransactions() > 0 && clock.millis() < deadline )
         {
             parkNanos( MILLISECONDS.toNanos( 10 ) );
         }

community/kernel/src/main/java/org/neo4j/kernel/impl/transaction/TransactionMonitor.java

@@ -21,8 +21,6 @@
 
 /**
  * This monitor is used to track transaction management. It is called when client code starts, finishes, or terminates transactions.
- *
- * In HA this refers only to what the local instance is doing, not what is happening globally in the whole cluster.
  */
 public interface TransactionMonitor
 {

community/kernel/src/main/java/org/neo4j/kernel/impl/transaction/TransactionStats.java → community/kernel/src/main/java/org/neo4j/kernel/impl/transaction/stats/DatabaseTransactionStats.java

@@ -17,27 +17,30 @@
  * 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.kernel.impl.transaction;
+package org.neo4j.kernel.impl.transaction.stats;
 
 import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.LongAdder;
 
-public class TransactionStats implements TransactionMonitor, TransactionCounters
+import org.neo4j.kernel.impl.transaction.TransactionMonitor;
+
+public class DatabaseTransactionStats implements TransactionMonitor, TransactionCounters
 {
-    private final AtomicLong startedTransactionCount = new AtomicLong();
     private final AtomicLong activeReadTransactionCount = new AtomicLong();
-    private final AtomicLong activeWriteTransactionCount = new AtomicLong();
-    private final AtomicLong committedReadTransactionCount = new AtomicLong();
-    private final AtomicLong committedWriteTransactionCount = new AtomicLong();
-    private final AtomicLong rolledBackReadTransactionCount = new AtomicLong();
-    private final AtomicLong rolledBackWriteTransactionCount = new AtomicLong();
-    private final AtomicLong terminatedReadTransactionCount = new AtomicLong();
-    private final AtomicLong terminatedWriteTransactionCount = new AtomicLong();
+    private final LongAdder startedTransactionCount = new LongAdder();
+    private final LongAdder activeWriteTransactionCount = new LongAdder();
+    private final LongAdder committedReadTransactionCount = new LongAdder();
+    private final LongAdder committedWriteTransactionCount = new LongAdder();
+    private final LongAdder rolledBackReadTransactionCount = new LongAdder();
+    private final LongAdder rolledBackWriteTransactionCount = new LongAdder();
+    private final LongAdder terminatedReadTransactionCount = new LongAdder();
+    private final LongAdder terminatedWriteTransactionCount = new LongAdder();
     private volatile long peakTransactionCount;
 
     @Override
     public void transactionStarted()
     {
-        startedTransactionCount.incrementAndGet();
+        startedTransactionCount.increment();
         long active = activeReadTransactionCount.incrementAndGet();
         peakTransactionCount = Math.max( peakTransactionCount, active );
     }
@@ -66,7 +69,7 @@ public void transactionTerminated( boolean write )
     public void upgradeToWriteTransaction()
     {
         decrementCounter( activeReadTransactionCount, activeWriteTransactionCount, false );
-        incrementCounter( activeReadTransactionCount, activeWriteTransactionCount, true );
+        activeWriteTransactionCount.increment();
     }
 
     @Override
@@ -78,7 +81,7 @@ public long getPeakConcurrentNumberOfTransactions()
     @Override
     public long getNumberOfStartedTransactions()
     {
-        return startedTransactionCount.get();
+        return startedTransactionCount.longValue();
     }
 
     @Override
@@ -90,13 +93,13 @@ public long getNumberOfCommittedTransactions()
     @Override
     public long getNumberOfCommittedReadTransactions()
     {
-        return committedReadTransactionCount.get();
+        return committedReadTransactionCount.longValue();
     }
 
     @Override
     public long getNumberOfCommittedWriteTransactions()
     {
-        return committedWriteTransactionCount.get();
+        return committedWriteTransactionCount.longValue();
     }
 
     @Override
@@ -108,13 +111,13 @@ public long getNumberOfActiveTransactions()
     @Override
     public long getNumberOfActiveReadTransactions()
     {
-        return activeReadTransactionCount.get();
+        return activeReadTransactionCount.longValue();
     }
 
     @Override
     public long getNumberOfActiveWriteTransactions()
     {
-        return activeWriteTransactionCount.get();
+        return activeWriteTransactionCount.longValue();
     }
 
     @Override
@@ -126,13 +129,13 @@ public long getNumberOfTerminatedTransactions()
     @Override
     public long getNumberOfTerminatedReadTransactions()
     {
-        return terminatedReadTransactionCount.get();
+        return terminatedReadTransactionCount.longValue();
     }
 
     @Override
     public long getNumberOfTerminatedWriteTransactions()
     {
-        return terminatedWriteTransactionCount.get();
+        return terminatedWriteTransactionCount.longValue();
     }
 
     @Override
@@ -144,24 +147,36 @@ public long getNumberOfRolledBackTransactions()
     @Override
     public long getNumberOfRolledBackReadTransactions()
     {
-        return rolledBackReadTransactionCount.get();
+        return rolledBackReadTransactionCount.longValue();
     }
 
     @Override
     public long getNumberOfRolledBackWriteTransactions()
     {
-        return rolledBackWriteTransactionCount.get();
+        return rolledBackWriteTransactionCount.longValue();
     }
 
-    private void incrementCounter( AtomicLong readCount, AtomicLong writeCount, boolean write )
+    private static void incrementCounter( LongAdder readCount, LongAdder writeCount, boolean write )
     {
-        long count = write ? writeCount.incrementAndGet() : readCount.incrementAndGet();
-        assert count > 0;
+        if ( write )
+        {
+            writeCount.increment();
+        }
+        else
+        {
+            readCount.increment();
+        }
     }
 
-    private void decrementCounter( AtomicLong readCount, AtomicLong writeCount, boolean write )
+    private static void decrementCounter( AtomicLong readCount, LongAdder writeCount, boolean write )
     {
-        long count = write ? writeCount.decrementAndGet() : readCount.decrementAndGet();
-        assert count >= 0;
+        if ( write )
+        {
+            writeCount.decrement();
+        }
+        else
+        {
+            readCount.decrementAndGet();
+        }
     }
 }

community/kernel/src/main/java/org/neo4j/kernel/impl/transaction/TransactionCounters.java → community/kernel/src/main/java/org/neo4j/kernel/impl/transaction/stats/TransactionCounters.java

@@ -17,7 +17,7 @@
  * 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.kernel.impl.transaction;
+package org.neo4j.kernel.impl.transaction.stats;
 
 public interface TransactionCounters
 {

community/kernel/src/test/java/org/neo4j/kernel/impl/transaction/TransactionCountersChecker.java

@@ -19,6 +19,8 @@
  */
 package org.neo4j.kernel.impl.transaction;
 
+import org.neo4j.kernel.impl.transaction.stats.TransactionCounters;
+
 import static org.junit.Assert.assertEquals;
 
 class TransactionCountersChecker

community/kernel/src/test/java/org/neo4j/test/rule/NeoStoreDataSourceRule.java

@@ -73,9 +73,9 @@
 import org.neo4j.kernel.impl.store.id.configuration.IdTypeConfigurationProvider;
 import org.neo4j.kernel.impl.transaction.TransactionHeaderInformationFactory;
 import org.neo4j.kernel.impl.transaction.TransactionMonitor;
-import org.neo4j.kernel.impl.transaction.TransactionStats;
 import org.neo4j.kernel.impl.transaction.log.checkpoint.StoreCopyCheckPointMutex;
 import org.neo4j.kernel.impl.transaction.log.files.LogFileCreationMonitor;
+import org.neo4j.kernel.impl.transaction.stats.DatabaseTransactionStats;
 import org.neo4j.kernel.impl.util.Dependencies;
 import org.neo4j.kernel.impl.util.UnsatisfiedDependencyException;
 import org.neo4j.kernel.impl.util.collection.CollectionsFactorySupplier;
@@ -135,7 +135,7 @@ public NeoStoreDataSource getDataSource( File storeDir, FileSystemAbstraction fs
                 deps -> new DatabaseHealth( mock( DatabasePanicEventGenerator.class ), NullLog.getInstance() ) );
         SystemNanoClock clock = dependency( mutableDependencies, SystemNanoClock.class, deps -> Clocks.nanoClock() );
         TransactionMonitor transactionMonitor = dependency( mutableDependencies, TransactionMonitor.class,
-                deps -> new TransactionStats() );
+                deps -> new DatabaseTransactionStats() );
         AvailabilityGuard availabilityGuard = dependency( mutableDependencies, AvailabilityGuard.class,
                 deps -> new AvailabilityGuard( deps.resolveDependency( SystemNanoClock.class ), NullLog.getInstance() ) );
         dependency( mutableDependencies, DiagnosticsManager.class,

community/neo4j/src/main/java/org/neo4j/graphdb/facade/GraphDatabaseFacadeFactory.java

@@ -177,8 +177,9 @@ public GraphDatabaseFacade initFacade( File storeDir, Config config, final Depen
         platform.life.add( platform.globalKernelExtensions );
         platform.life.add( createBoltServer( platform, edition, databaseManager ) );
         platform.life.add( new VmPauseMonitorComponent( config, platform.logging.getInternalLog( VmPauseMonitorComponent.class ), platform.jobScheduler ) );
+        platform.dependencies.satisfyDependency( edition.globalTransactionCounter() );
         platform.life.add( new PublishPageCacheTracerMetricsAfterStart( platform.tracers.pageCursorTracerSupplier ) );
-        DatabaseAvailability databaseAvailability = new DatabaseAvailability( platform.availabilityGuard, platform.transactionMonitor,
+        DatabaseAvailability databaseAvailability = new DatabaseAvailability( platform.availabilityGuard, edition.globalTransactionCounter(), platform.clock,
                 config.get( GraphDatabaseSettings.shutdown_transaction_end_timeout ).toMillis() );
         platform.dependencies.satisfyDependency( databaseAvailability );
         platform.life.add( databaseAvailability );