Simplify creation of StoreLogService

And remove need to inject some dependencies when unrequired

community/import-tool/src/main/java/org/neo4j/tooling/ImportTool.java

@@ -306,10 +306,7 @@ idType, csvConfiguration( args, defaultSettingsSuitableForTests ),
 
         LifeSupport life = new LifeSupport();
 
-        JobScheduler jobScheduler = life.add( new Neo4jJobScheduler() );
-        NullLogProvider logProvider = NullLogProvider.getInstance();
-        Config config = new Config();
-        LogService logService = life.add( new StoreLogService( logProvider, fs, storeDir, config, jobScheduler ) );
+        LogService logService = life.add( StoreLogService.inStoreDirectory( fs, storeDir ) );
 
         life.start();
         org.neo4j.unsafe.impl.batchimport.Configuration configuration =

community/kernel/src/main/java/org/neo4j/graphdb/factory/GraphDatabaseSettings.java

@@ -129,6 +129,10 @@ public abstract class GraphDatabaseSettings
     public static final Setting<Long> transaction_start_timeout =
             setting( "transaction_start_timeout", DURATION, "1s" );
 
+    @Description("The location of the internal diagnostics log.")
+    @Internal
+    public static final Setting<File> store_internal_log_location = setting("store.internal_log.location", PATH, NO_DEFAULT );
+
     @Description( "Threshold for rotation of the internal log." )
     public static final Setting<Long> store_internal_log_rotation_threshold = setting("store.internal_log.rotation_threshold", BYTES, "20m", min(0L), max( Long.MAX_VALUE ) );
 
@@ -384,10 +388,6 @@ private static String defaultPageCacheMemory()
     @Obsoleted( "Write batching can no longer be turned off" )
     public static final Setting<Boolean> batched_writes = setting( "batched_writes", BOOLEAN, Boolean.TRUE.toString() );
 
-    @Description("The location of the internal diagnostics log.")
-    @Internal
-    public static final Setting<File> internal_log_location = setting("store.internal_log.location", PATH, NO_DEFAULT );
-
     @Description( "Log executed queries that takes longer than the configured threshold." )
     public static final Setting<Boolean> log_queries = setting("dbms.querylog.enabled", BOOLEAN, FALSE );
 

community/kernel/src/main/java/org/neo4j/kernel/impl/factory/PlatformModule.java

@@ -58,7 +58,6 @@
 import org.neo4j.kernel.monitoring.tracing.Tracers;
 import org.neo4j.logging.Log;
 import org.neo4j.logging.LogProvider;
-import org.neo4j.logging.NullLogProvider;
 import org.neo4j.udc.UsageData;
 import org.neo4j.udc.UsageDataKeys;
 
@@ -204,27 +203,39 @@ protected FileSystemAbstraction createFileSystemAbstraction()
 
     protected LogService createLogService( LogProvider userLogProvider )
     {
-        if ( userLogProvider == null )
-        {
-            userLogProvider = NullLogProvider.getInstance();
-        }
-
         long internalLogRotationThreshold = config.get( GraphDatabaseSettings.store_internal_log_rotation_threshold );
         int internalLogRotationDelay = config.get( GraphDatabaseSettings.store_internal_log_rotation_delay );
         int internalLogMaxArchives = config.get( GraphDatabaseSettings.store_internal_log_max_archives );
+
+        final StoreLogService.Builder builder =
+                StoreLogService.withRotation( internalLogRotationThreshold, internalLogRotationDelay, internalLogMaxArchives, jobScheduler );
+
+        if ( userLogProvider != null )
+        {
+            builder.withUserLogProvider( userLogProvider );
+        }
+
+        builder.withRotationListener( new Consumer<LogProvider>()
+        {
+            @Override
+            public void accept( LogProvider logProvider )
+            {
+                diagnosticsManager.dumpAll( logProvider.getLog( DiagnosticsManager.class ) );
+            }
+        } );
+
+        File internalLog = config.get( GraphDatabaseSettings.store_internal_log_location );
         LogService logService;
         try
         {
-            logService = new StoreLogService( userLogProvider, fileSystem, storeDir, config,
-                    internalLogRotationThreshold, internalLogRotationDelay, internalLogMaxArchives,
-                    jobScheduler, new Consumer<LogProvider>()
+            if ( internalLog == null )
+            {
+                logService = builder.inStoreDirectory( fileSystem, storeDir );
+            }
+            else
             {
-                @Override
-                public void accept( LogProvider logProvider )
-                {
-                    diagnosticsManager.dumpAll( logProvider.getLog( DiagnosticsManager.class ) );
-                }
-            } );
+                logService = builder.toFile( fileSystem, internalLog );
+            }
         }
         catch ( IOException ex )
         {

community/kernel/src/main/java/org/neo4j/kernel/impl/logging/StoreLogService.java

@@ -27,13 +27,12 @@
 
 import org.neo4j.function.Consumer;
 import org.neo4j.function.Consumers;
-import org.neo4j.graphdb.factory.GraphDatabaseSettings;
 import org.neo4j.io.fs.FileSystemAbstraction;
-import org.neo4j.kernel.configuration.Config;
 import org.neo4j.kernel.impl.util.JobScheduler;
 import org.neo4j.kernel.lifecycle.Lifecycle;
 import org.neo4j.logging.FormattedLogProvider;
 import org.neo4j.logging.LogProvider;
+import org.neo4j.logging.NullLogProvider;
 import org.neo4j.logging.RotatingFileOutputStreamSupplier;
 
 import static org.neo4j.io.file.Files.createOrOpenAsOuputStream;
@@ -42,51 +41,96 @@ public class StoreLogService extends AbstractLogService implements Lifecycle
 {
     public static final String INTERNAL_LOG_NAME = "messages.log";
 
-    private final Closeable closeable;
-    private final SimpleLogService logService;
+    public static class Builder
+    {
+        private LogProvider userLogProvider = NullLogProvider.getInstance();
+        private Executor rotationExecutor;
+        private long internalLogRotationThreshold = 0L;
+        private int internalLogRotationDelay = 0;
+        private int maxInternalLogArchives = 0;
+        private Consumer<LogProvider> rotationListener = Consumers.noop();
+
+        public Builder withUserLogProvider( LogProvider userLogProvider )
+        {
+            this.userLogProvider = userLogProvider;
+            return this;
+        }
+
+        public Builder withRotation( long internalLogRotationThreshold, int internalLogRotationDelay, int maxInternalLogArchives,
+                JobScheduler jobScheduler )
+        {
+            return withRotation( internalLogRotationThreshold, internalLogRotationDelay, maxInternalLogArchives,
+                    jobScheduler.executor( JobScheduler.Groups.internalLogRotation ) );
+        }
+
+        public Builder withRotation( long internalLogRotationThreshold, int internalLogRotationDelay, int maxInternalLogArchives,
+                Executor rotationExecutor )
+        {
+            this.internalLogRotationThreshold = internalLogRotationThreshold;
+            this.internalLogRotationDelay = internalLogRotationDelay;
+            this.maxInternalLogArchives = maxInternalLogArchives;
+            this.rotationExecutor = rotationExecutor;
+            return this;
+        }
+
+        public Builder withRotationListener( Consumer<LogProvider> rotationListener )
+        {
+            this.rotationListener = rotationListener;
+            return this;
+        }
+
+        public StoreLogService inStoreDirectory( FileSystemAbstraction fileSystem, File storeDir ) throws IOException
+        {
+            return toFile( fileSystem, new File( storeDir, INTERNAL_LOG_NAME ) );
+        }
+
+        public StoreLogService toFile( FileSystemAbstraction fileSystem, File internalLogPath ) throws IOException
+        {
+            return new StoreLogService(
+                    userLogProvider,
+                    fileSystem, internalLogPath,
+                    internalLogRotationThreshold, internalLogRotationDelay, maxInternalLogArchives, rotationExecutor, rotationListener );
+        }
+    }
 
-    public StoreLogService( LogProvider userLogProvider, FileSystemAbstraction fileSystem, File storeDir, Config config, JobScheduler jobScheduler ) throws IOException
+    public static Builder withUserLogProvider( LogProvider userLogProvider )
     {
-        this( userLogProvider, fileSystem, storeDir, config, 0L, 0, 0, jobScheduler, Consumers.<LogProvider>noop() );
+        return new Builder().withUserLogProvider( userLogProvider );
     }
 
-    public StoreLogService( LogProvider userLogProvider, FileSystemAbstraction fileSystem, File storeDir, Config config,
-                            long internalLogRotationThreshold, int internalLogRotationDelay, int maxInternalLogArchives,
-                            JobScheduler jobScheduler, final Consumer<LogProvider> rotationListener ) throws IOException
+    public static Builder withRotation( long internalLogRotationThreshold, int internalLogRotationDelay, int maxInternalLogArchives, JobScheduler jobScheduler )
     {
-        this( userLogProvider, fileSystem, storeDir, config, internalLogRotationThreshold, internalLogRotationDelay, maxInternalLogArchives,
-                jobScheduler.executor( JobScheduler.Groups.internalLogRotation ), rotationListener );
+        return new Builder().withRotation( internalLogRotationThreshold, internalLogRotationDelay, maxInternalLogArchives, jobScheduler );
     }
 
-    public StoreLogService( LogProvider userLogProvider, FileSystemAbstraction fileSystem, File storeDir, Config config,
-                            long internalLogRotationThreshold, int internalLogRotationDelay, int maxInternalLogArchives,
-                            Executor rotationExecutor, final Consumer<LogProvider> rotationListener ) throws IOException
+    public static StoreLogService inStoreDirectory( FileSystemAbstraction fileSystem, File storeDir ) throws IOException
     {
-        File internalLogLocation = config.get( GraphDatabaseSettings.internal_log_location );
-        final File logFile;
-        if ( internalLogLocation != null )
-        {
-            logFile = internalLogLocation;
-            if ( !logFile.getParentFile().exists() )
-            {
-                logFile.getParentFile().mkdirs();
-            }
-        }
-        else
+        return new Builder().inStoreDirectory( fileSystem, storeDir );
+    }
+
+    private final Closeable closeable;
+    private final SimpleLogService logService;
+
+    private StoreLogService( LogProvider userLogProvider, FileSystemAbstraction fileSystem, File internalLog,
+            long internalLogRotationThreshold, int internalLogRotationDelay, int maxInternalLogArchives,
+            Executor rotationExecutor, final Consumer<LogProvider> rotationListener ) throws IOException
+    {
+        if ( !internalLog.getParentFile().exists() )
         {
-            logFile = new File( storeDir, StoreLogService.INTERNAL_LOG_NAME );
+            internalLog.getParentFile().mkdirs();
         }
 
         FormattedLogProvider internalLogProvider;
         if ( internalLogRotationThreshold == 0 )
         {
-            OutputStream outputStream = createOrOpenAsOuputStream( fileSystem, logFile, true );
+            OutputStream outputStream = createOrOpenAsOuputStream( fileSystem, internalLog, true );
             internalLogProvider = FormattedLogProvider.withUTCTimeZone().toOutputStream( outputStream );
             rotationListener.accept( internalLogProvider );
             this.closeable = outputStream;
-        } else
+        }
+        else
         {
-            RotatingFileOutputStreamSupplier rotatingSupplier = new RotatingFileOutputStreamSupplier( fileSystem, logFile,
+            RotatingFileOutputStreamSupplier rotatingSupplier = new RotatingFileOutputStreamSupplier( fileSystem, internalLog,
                     internalLogRotationThreshold, internalLogRotationDelay, maxInternalLogArchives,
                     rotationExecutor, new RotatingFileOutputStreamSupplier.RotationListener()
             {

community/kernel/src/main/java/org/neo4j/kernel/impl/storemigration/StoreMigrationTool.java

@@ -92,8 +92,7 @@ public File storeDir()
                 kernelContext, GraphDatabaseDependencies.newDependencies().kernelExtensions(),
                 deps, ignore() ) );
 
-        JobScheduler jobScheduler = life.add( new Neo4jJobScheduler() );
-        LogService logService = new StoreLogService( userLogProvider, fs, legacyStoreDirectory, config, jobScheduler );
+        LogService logService = StoreLogService.withUserLogProvider( userLogProvider ).inStoreDirectory( fs, legacyStoreDirectory );
 
         // Add the kernel store migrator
         life.start();

community/kernel/src/main/java/org/neo4j/unsafe/batchinsert/BatchInserterImpl.java

@@ -128,14 +128,11 @@
 import org.neo4j.kernel.impl.transaction.state.RelationshipCreator;
 import org.neo4j.kernel.impl.transaction.state.RelationshipGroupGetter;
 import org.neo4j.kernel.impl.transaction.state.RelationshipLocker;
-import org.neo4j.kernel.impl.util.JobScheduler;
 import org.neo4j.kernel.impl.util.Dependencies;
 import org.neo4j.kernel.impl.util.Listener;
-import org.neo4j.kernel.impl.util.Neo4jJobScheduler;
 import org.neo4j.kernel.lifecycle.LifeSupport;
 import org.neo4j.logging.Log;
 import org.neo4j.logging.NullLog;
-import org.neo4j.logging.NullLogProvider;
 import org.neo4j.kernel.monitoring.Monitors;
 
 import static java.lang.Boolean.parseBoolean;
@@ -244,9 +241,7 @@ public Label apply( long from )
                 fileSystem, config, PageCacheTracer.NULL, NullLog.getInstance() );
         PageCache pageCache = pageCacheFactory.getOrCreatePageCache();
 
-        JobScheduler jobScheduler = life.add( new Neo4jJobScheduler() );
-        NullLogProvider logProvider = NullLogProvider.getInstance();
-        logService = life.add( new StoreLogService( logProvider, fileSystem, this.storeDir, this.config, jobScheduler ) );
+        logService = life.add( StoreLogService.inStoreDirectory( fileSystem, this.storeDir ) );
         msgLog = logService.getInternalLog( getClass() );
         storeLocker = new StoreLocker( fileSystem );
         storeLocker.checkLock( this.storeDir );

community/kernel/src/test/java/org/neo4j/test/ImpermanentGraphDatabase.java

@@ -20,7 +20,6 @@
 package org.neo4j.test;
 
 import java.io.File;
-import java.io.IOException;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
@@ -36,7 +35,7 @@
 import org.neo4j.kernel.impl.factory.GraphDatabaseFacadeFactory;
 import org.neo4j.kernel.impl.factory.PlatformModule;
 import org.neo4j.kernel.impl.logging.LogService;
-import org.neo4j.kernel.impl.logging.StoreLogService;
+import org.neo4j.kernel.impl.logging.SimpleLogService;
 import org.neo4j.logging.LogProvider;
 import org.neo4j.logging.NullLogProvider;
 
@@ -206,15 +205,7 @@ protected FileSystemAbstraction createFileSystemAbstraction()
         @Override
         protected LogService createLogService( LogProvider userLogProvider )
         {
-            StoreLogService logService;
-            try
-            {
-                logService = new StoreLogService( NullLogProvider.getInstance(), fileSystem, storeDir, config, jobScheduler );
-            } catch ( IOException e )
-            {
-                throw new RuntimeException( e );
-            }
-            return logService;
+            return new SimpleLogService( NullLogProvider.getInstance(), NullLogProvider.getInstance() );
         }
     }
 }

enterprise/server-enterprise/src/main/java/org/neo4j/server/enterprise/StandaloneClusterClient.java

@@ -109,7 +109,7 @@ public static void main( String[] args ) throws IOException
         try
         {
             JobScheduler jobScheduler = new Neo4jJobScheduler();
-            LogService logService = logService( new DefaultFileSystemAbstraction(), jobScheduler );
+            LogService logService = logService( new DefaultFileSystemAbstraction() );
             ObjectStreamFactory objectStreamFactory = new ObjectStreamFactory();
             new StandaloneClusterClient( jobScheduler, new ClusterClient( new Monitors(), adapt( new Config( config ) ),
                     logService, new NotElectableElectionCredentialsProvider(), objectStreamFactory,
@@ -172,13 +172,13 @@ private static void moveOver( Map<String, String> from, Map<String, String> to,
         }
     }
 
-    private static LogService logService( FileSystemAbstraction fileSystem, JobScheduler jobScheduler ) throws IOException
+    private static LogService logService( FileSystemAbstraction fileSystem ) throws IOException
     {
         File home = new File( System.getProperty( "neo4j.home" ) );
         String logDir = System.getProperty( "org.neo4j.cluster.logdirectory",
                 new File( new File( new File( home, "data" ), "log" ), "arbiter" ).getAbsolutePath() );
-        return new StoreLogService( FormattedLogProvider.toOutputStream( System.out ), fileSystem,
-                new File( logDir ), new Config(), jobScheduler );
+        return StoreLogService.withUserLogProvider( FormattedLogProvider.toOutputStream( System.out ) )
+                .inStoreDirectory( fileSystem, new File( logDir ) );
     }
 
     private static File extractDbTuningProperties( String propertiesFile )