Publish failed event in both cases: when transaction was marked as fa…

…iled and when it was terminated.

Restore previous behaviour. Add test for this specific case.

community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactionImplementation.java

@@ -426,7 +426,7 @@ public long closeTransaction() throws TransactionFailureException
             try
             {
                 transactionEvent.setSuccess( success );
-                transactionEvent.setFailure( failure );
+                transactionEvent.setFailure( failure || isTerminated() );
                 transactionEvent.setTransactionType( writeState.name() );
                 transactionEvent.setReadOnly( txState == null || !txState.hasChanges() );
                 transactionEvent.close();

community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionImplementationTest.java

@@ -47,6 +47,8 @@
 import org.neo4j.kernel.impl.locking.SimpleStatementLocks;
 import org.neo4j.kernel.impl.transaction.TransactionMonitor;
 import org.neo4j.kernel.impl.transaction.command.Command;
+import org.neo4j.kernel.impl.transaction.tracing.CommitEvent;
+import org.neo4j.kernel.impl.transaction.tracing.TransactionEvent;
 import org.neo4j.storageengine.api.StorageCommand;
 import org.neo4j.storageengine.api.StorageStatement;
 import org.neo4j.storageengine.api.StoreReadLayer;
@@ -809,6 +811,21 @@ public void returnTransactionToPoolWhenLocksCloseFailOrRelease() throws Transact
         assertTrue( transaction.isClosed() );
     }
 
+    @Test
+    public void postFailedtransactionEventWhenClosingTerminatedTransaction() throws TransactionFailureException
+    {
+        TrackingTransactionEvent transactionEvent = new TrackingTransactionEvent();
+        KernelTransactionImplementation transaction = newNotInitializedTransaction( () -> transactionEvent );
+        SimpleStatementLocks statementLocks = new SimpleStatementLocks( new NoOpClient() );
+
+        transaction.initialize( 1L, 2L, statementLocks,
+                KernelTransaction.Type.explicit, SecurityContext.AUTH_DISABLED, 3L );
+        transaction.markForTermination( Status.Transaction.Terminated );
+        transaction.close();
+
+        assertTrue( transactionEvent.isFailure() );
+    }
+
     private SecurityContext securityContext()
     {
         return isWriteTx ? AnonymousContext.write() : AnonymousContext.read();
@@ -853,4 +870,50 @@ public void afterRollback( ReadableTransactionState state, KernelTransaction tra
 
         }
     }
+
+    private static class TrackingTransactionEvent implements TransactionEvent
+    {
+        private boolean failure;
+
+        @Override
+        public void setSuccess( boolean success )
+        {
+
+        }
+
+        @Override
+        public void setFailure( boolean failure )
+        {
+            this.failure = failure;
+        }
+
+        @Override
+        public CommitEvent beginCommitEvent()
+        {
+            return null;
+        }
+
+        @Override
+        public void close()
+        {
+
+        }
+
+        @Override
+        public void setTransactionType( String transactionTypeName )
+        {
+
+        }
+
+        @Override
+        public void setReadOnly( boolean wasReadOnly )
+        {
+
+        }
+
+        public boolean isFailure()
+        {
+            return failure;
+        }
+    }
 }

community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionTestBase.java

@@ -104,6 +104,11 @@ public KernelTransactionImplementation newTransaction( long transactionTimeoutMi
         return newTransaction( 0, AUTH_DISABLED, transactionTimeoutMillis );
     }
 
+    public KernelTransactionImplementation newTransaction( long transactionTimeoutMillis, TransactionTracer transactionTracer )
+    {
+        return newTransaction( 0, AUTH_DISABLED, transactionTimeoutMillis );
+    }
+
     public KernelTransactionImplementation newTransaction( SecurityContext securityContext )
     {
         return newTransaction( 0, securityContext );
@@ -136,10 +141,15 @@ public KernelTransactionImplementation newTransaction( long lastTransactionIdWhe
     }
 
     public KernelTransactionImplementation newNotInitializedTransaction()
+    {
+        return newNotInitializedTransaction( TransactionTracer.NULL );
+    }
+
+    public KernelTransactionImplementation newNotInitializedTransaction( TransactionTracer transactionTracer )
     {
         return new KernelTransactionImplementation( operationContainer, schemaWriteGuard,
                 hooks, null, null, headerInformationFactory, commitProcess, transactionMonitor, legacyIndexStateSupplier,
-                txPool, clock, TransactionTracer.NULL, LockTracer.NONE, storageEngine, new CanWrite() );
+                txPool, clock, transactionTracer, LockTracer.NONE, storageEngine, new CanWrite() );
     }
 
     public class CapturingCommitProcess implements TransactionCommitProcess