diff --git a/driver/src/main/java/org/neo4j/driver/internal/DriverFactory.java b/driver/src/main/java/org/neo4j/driver/internal/DriverFactory.java index a37cc00d34..0d3a964d4e 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/DriverFactory.java +++ b/driver/src/main/java/org/neo4j/driver/internal/DriverFactory.java @@ -20,6 +20,7 @@ import io.netty.bootstrap.Bootstrap; import io.netty.util.concurrent.EventExecutorGroup; +import io.netty.util.internal.logging.InternalLoggerFactory; import java.io.IOException; import java.net.URI; @@ -36,6 +37,7 @@ import org.neo4j.driver.internal.cluster.loadbalancing.LoadBalancer; import org.neo4j.driver.internal.cluster.loadbalancing.LoadBalancingStrategy; import org.neo4j.driver.internal.cluster.loadbalancing.RoundRobinLoadBalancingStrategy; +import org.neo4j.driver.internal.logging.NettyLogging; import org.neo4j.driver.internal.retry.ExponentialBackoffRetryLogic; import org.neo4j.driver.internal.retry.RetryLogic; import org.neo4j.driver.internal.retry.RetrySettings; @@ -69,6 +71,7 @@ public final Driver newInstance( URI uri, AuthToken authToken, RoutingSettings r RoutingSettings newRoutingSettings = routingSettings.withRoutingContext( new RoutingContext( uri ) ); SecurityPlan securityPlan = createSecurityPlan( address, config ); + InternalLoggerFactory.setDefaultFactory( new NettyLogging( config.logging() ) ); Bootstrap bootstrap = createBootstrap(); EventExecutorGroup eventExecutorGroup = bootstrap.config().group(); RetryLogic retryLogic = createRetryLogic( retrySettings, eventExecutorGroup, config.logging() ); diff --git a/driver/src/main/java/org/neo4j/driver/internal/InternalDriver.java b/driver/src/main/java/org/neo4j/driver/internal/InternalDriver.java index 0d8ea6e255..af141d98a5 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/InternalDriver.java +++ b/driver/src/main/java/org/neo4j/driver/internal/InternalDriver.java @@ -44,6 +44,7 @@ public class InternalDriver implements Driver this.securityPlan = securityPlan; this.sessionFactory = sessionFactory; this.log = logging.getLog( Driver.class.getSimpleName() ); + log.info( "Driver instance %s created", this ); } @Override @@ -112,7 +113,7 @@ public CompletionStage closeAsync() { if ( closed.compareAndSet( false, true ) ) { - log.info( "Driver instance is closing" ); + log.info( "Closing driver instance %s", this ); return sessionFactory.close(); } return completedFuture( null ); diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/ProtocolUtil.java b/driver/src/main/java/org/neo4j/driver/internal/async/BoltProtocolV1Util.java similarity index 82% rename from driver/src/main/java/org/neo4j/driver/internal/async/ProtocolUtil.java rename to driver/src/main/java/org/neo4j/driver/internal/async/BoltProtocolV1Util.java index c0a8569c5c..a75c0cfc2c 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/ProtocolUtil.java +++ b/driver/src/main/java/org/neo4j/driver/internal/async/BoltProtocolV1Util.java @@ -24,7 +24,7 @@ import static io.netty.buffer.Unpooled.copyShort; import static io.netty.buffer.Unpooled.unreleasableBuffer; -public final class ProtocolUtil +public final class BoltProtocolV1Util { public static final int HTTP = 1213486160; //== 0x48545450 == "HTTP" @@ -36,24 +36,30 @@ public final class ProtocolUtil public static final int DEFAULT_MAX_OUTBOUND_CHUNK_SIZE_BYTES = Short.MAX_VALUE / 2; - private static final ByteBuf HANDSHAKE_BUF = unreleasableBuffer( copyInt( + private static final ByteBuf BOLT_V1_HANDSHAKE_BUF = unreleasableBuffer( copyInt( BOLT_MAGIC_PREAMBLE, PROTOCOL_VERSION_1, NO_PROTOCOL_VERSION, NO_PROTOCOL_VERSION, - NO_PROTOCOL_VERSION ) ).asReadOnly(); + NO_PROTOCOL_VERSION ) ) + .asReadOnly(); private static final ByteBuf MESSAGE_BOUNDARY_BUF = unreleasableBuffer( copyShort( 0 ) ).asReadOnly(); private static final ByteBuf CHUNK_HEADER_PLACEHOLDER_BUF = unreleasableBuffer( copyShort( 0 ) ).asReadOnly(); - private ProtocolUtil() + private BoltProtocolV1Util() { } - public static ByteBuf handshake() + public static ByteBuf handshakeBuf() { - return HANDSHAKE_BUF.duplicate(); + return BOLT_V1_HANDSHAKE_BUF.duplicate(); + } + + public static String handshakeString() + { + return "[0x6060B017, 1, 0, 0, 0]"; } public static ByteBuf messageBoundary() diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/ChannelConnectedListener.java b/driver/src/main/java/org/neo4j/driver/internal/async/ChannelConnectedListener.java index d5997d3c17..efb9eec554 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/ChannelConnectedListener.java +++ b/driver/src/main/java/org/neo4j/driver/internal/async/ChannelConnectedListener.java @@ -25,12 +25,14 @@ import io.netty.channel.ChannelPromise; import org.neo4j.driver.internal.BoltServerAddress; +import org.neo4j.driver.internal.logging.ChannelActivityLogger; import org.neo4j.driver.v1.Logger; import org.neo4j.driver.v1.Logging; import org.neo4j.driver.v1.exceptions.ServiceUnavailableException; import static java.lang.String.format; -import static org.neo4j.driver.internal.async.ProtocolUtil.handshake; +import static org.neo4j.driver.internal.async.BoltProtocolV1Util.handshakeBuf; +import static org.neo4j.driver.internal.async.BoltProtocolV1Util.handshakeString; public class ChannelConnectedListener implements ChannelFutureListener { @@ -38,7 +40,6 @@ public class ChannelConnectedListener implements ChannelFutureListener private final ChannelPipelineBuilder pipelineBuilder; private final ChannelPromise handshakeCompletedPromise; private final Logging logging; - private final Logger log; public ChannelConnectedListener( BoltServerAddress address, ChannelPipelineBuilder pipelineBuilder, ChannelPromise handshakeCompletedPromise, Logging logging ) @@ -47,21 +48,22 @@ public ChannelConnectedListener( BoltServerAddress address, ChannelPipelineBuild this.pipelineBuilder = pipelineBuilder; this.handshakeCompletedPromise = handshakeCompletedPromise; this.logging = logging; - this.log = logging.getLog( getClass().getSimpleName() ); } @Override public void operationComplete( ChannelFuture future ) { Channel channel = future.channel(); + Logger log = new ChannelActivityLogger( channel, logging, getClass() ); if ( future.isSuccess() ) { - log.trace( "Channel %s connected, running bolt handshake", channel ); + log.trace( "Channel %s connected, initiating bolt handshake", channel ); ChannelPipeline pipeline = channel.pipeline(); pipeline.addLast( new HandshakeHandler( pipelineBuilder, handshakeCompletedPromise, logging ) ); - ChannelFuture handshakeFuture = channel.writeAndFlush( handshake() ); + log.debug( "C: [Bolt Handshake] %s", handshakeString() ); + ChannelFuture handshakeFuture = channel.writeAndFlush( handshakeBuf() ); handshakeFuture.addListener( channelFuture -> { diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/ChannelConnectorImpl.java b/driver/src/main/java/org/neo4j/driver/internal/async/ChannelConnectorImpl.java index bf44514d37..5f7b244288 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/ChannelConnectorImpl.java +++ b/driver/src/main/java/org/neo4j/driver/internal/async/ChannelConnectorImpl.java @@ -71,7 +71,7 @@ public ChannelConnectorImpl( ConnectionSettings connectionSettings, SecurityPlan public ChannelFuture connect( BoltServerAddress address, Bootstrap bootstrap ) { bootstrap.option( ChannelOption.CONNECT_TIMEOUT_MILLIS, connectTimeoutMillis ); - bootstrap.handler( new NettyChannelInitializer( address, securityPlan, clock ) ); + bootstrap.handler( new NettyChannelInitializer( address, securityPlan, clock, logging ) ); ChannelFuture channelConnected = bootstrap.connect( address.toSocketAddress() ); diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/HandshakeHandler.java b/driver/src/main/java/org/neo4j/driver/internal/async/HandshakeHandler.java index 91f1fe9fa3..c02fbb0e6c 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/HandshakeHandler.java +++ b/driver/src/main/java/org/neo4j/driver/internal/async/HandshakeHandler.java @@ -28,7 +28,7 @@ import java.util.List; import javax.net.ssl.SSLHandshakeException; -import org.neo4j.driver.internal.logging.PrefixedLogger; +import org.neo4j.driver.internal.logging.ChannelActivityLogger; import org.neo4j.driver.internal.messaging.MessageFormat; import org.neo4j.driver.internal.messaging.PackStreamMessageFormatV1; import org.neo4j.driver.internal.util.ErrorUtil; @@ -38,9 +38,9 @@ import org.neo4j.driver.v1.exceptions.SecurityException; import org.neo4j.driver.v1.exceptions.ServiceUnavailableException; -import static org.neo4j.driver.internal.async.ProtocolUtil.HTTP; -import static org.neo4j.driver.internal.async.ProtocolUtil.NO_PROTOCOL_VERSION; -import static org.neo4j.driver.internal.async.ProtocolUtil.PROTOCOL_VERSION_1; +import static org.neo4j.driver.internal.async.BoltProtocolV1Util.HTTP; +import static org.neo4j.driver.internal.async.BoltProtocolV1Util.NO_PROTOCOL_VERSION; +import static org.neo4j.driver.internal.async.BoltProtocolV1Util.PROTOCOL_VERSION_1; public class HandshakeHandler extends ReplayingDecoder { @@ -62,7 +62,7 @@ public HandshakeHandler( ChannelPipelineBuilder pipelineBuilder, ChannelPromise @Override public void handlerAdded( ChannelHandlerContext ctx ) { - log = new PrefixedLogger( ctx.channel().toString(), logging, getClass() ); + log = new ChannelActivityLogger( ctx.channel(), logging, getClass() ); } @Override @@ -112,7 +112,7 @@ public void exceptionCaught( ChannelHandlerContext ctx, Throwable error ) protected void decode( ChannelHandlerContext ctx, ByteBuf in, List out ) { int serverSuggestedVersion = in.readInt(); - log.debug( "Server suggested protocol version %s during handshake", serverSuggestedVersion ); + log.debug( "S: [Bolt Handshake] %d", serverSuggestedVersion ); ChannelPipeline pipeline = ctx.pipeline(); // this is a one-time handler, remove it when protocol version has been read diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/NettyChannelInitializer.java b/driver/src/main/java/org/neo4j/driver/internal/async/NettyChannelInitializer.java index 64c0c7a433..c025cb0ba5 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/NettyChannelInitializer.java +++ b/driver/src/main/java/org/neo4j/driver/internal/async/NettyChannelInitializer.java @@ -29,23 +29,25 @@ import org.neo4j.driver.internal.async.inbound.InboundMessageDispatcher; import org.neo4j.driver.internal.security.SecurityPlan; import org.neo4j.driver.internal.util.Clock; +import org.neo4j.driver.v1.Logging; import static org.neo4j.driver.internal.async.ChannelAttributes.setCreationTimestamp; import static org.neo4j.driver.internal.async.ChannelAttributes.setMessageDispatcher; import static org.neo4j.driver.internal.async.ChannelAttributes.setServerAddress; -import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; public class NettyChannelInitializer extends ChannelInitializer { private final BoltServerAddress address; private final SecurityPlan securityPlan; private final Clock clock; + private final Logging logging; - public NettyChannelInitializer( BoltServerAddress address, SecurityPlan securityPlan, Clock clock ) + public NettyChannelInitializer( BoltServerAddress address, SecurityPlan securityPlan, Clock clock, Logging logging ) { this.address = address; this.securityPlan = securityPlan; this.clock = clock; + this.logging = logging; } @Override @@ -78,6 +80,6 @@ private void updateChannelAttributes( Channel channel ) { setServerAddress( channel, address ); setCreationTimestamp( channel, clock.millis() ); - setMessageDispatcher( channel, new InboundMessageDispatcher( channel, DEV_NULL_LOGGING ) ); + setMessageDispatcher( channel, new InboundMessageDispatcher( channel, logging ) ); } } diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/inbound/ChannelErrorHandler.java b/driver/src/main/java/org/neo4j/driver/internal/async/inbound/ChannelErrorHandler.java index 283ffc0e80..7f5a7ab7c7 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/inbound/ChannelErrorHandler.java +++ b/driver/src/main/java/org/neo4j/driver/internal/async/inbound/ChannelErrorHandler.java @@ -24,7 +24,7 @@ import java.io.IOException; -import org.neo4j.driver.internal.logging.PrefixedLogger; +import org.neo4j.driver.internal.logging.ChannelActivityLogger; import org.neo4j.driver.internal.util.ErrorUtil; import org.neo4j.driver.v1.Logger; import org.neo4j.driver.v1.Logging; @@ -50,7 +50,7 @@ public ChannelErrorHandler( Logging logging ) public void handlerAdded( ChannelHandlerContext ctx ) { messageDispatcher = requireNonNull( messageDispatcher( ctx.channel() ) ); - log = new PrefixedLogger( ctx.channel().toString(), logging, getClass() ); + log = new ChannelActivityLogger( ctx.channel(), logging, getClass() ); } @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/inbound/ChunkDecoder.java b/driver/src/main/java/org/neo4j/driver/internal/async/inbound/ChunkDecoder.java index 7bd0821860..d6b410cea5 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/inbound/ChunkDecoder.java +++ b/driver/src/main/java/org/neo4j/driver/internal/async/inbound/ChunkDecoder.java @@ -19,15 +19,14 @@ package org.neo4j.driver.internal.async.inbound; import io.netty.buffer.ByteBuf; +import io.netty.buffer.ByteBufUtil; import io.netty.channel.ChannelHandlerContext; import io.netty.handler.codec.LengthFieldBasedFrameDecoder; -import org.neo4j.driver.internal.logging.PrefixedLogger; +import org.neo4j.driver.internal.logging.ChannelActivityLogger; import org.neo4j.driver.v1.Logger; import org.neo4j.driver.v1.Logging; -import static io.netty.buffer.ByteBufUtil.prettyHexDump; - public class ChunkDecoder extends LengthFieldBasedFrameDecoder { private static final int MAX_FRAME_LENGTH = Short.MAX_VALUE; @@ -48,7 +47,7 @@ public ChunkDecoder( Logging logging ) @Override public void handlerAdded( ChannelHandlerContext ctx ) { - log = new PrefixedLogger( ctx.channel().toString(), logging, getClass() ); + log = new ChannelActivityLogger( ctx.channel(), logging, getClass() ); } @Override @@ -65,8 +64,8 @@ protected ByteBuf extractFrame( ChannelHandlerContext ctx, ByteBuf buffer, int i int originalReaderIndex = buffer.readerIndex(); int readerIndexWithChunkHeader = originalReaderIndex - INITIAL_BYTES_TO_STRIP; int lengthWithChunkHeader = INITIAL_BYTES_TO_STRIP + buffer.readableBytes(); - String hexDump = prettyHexDump( buffer, readerIndexWithChunkHeader, lengthWithChunkHeader ); - log.trace( "S:\n%s", hexDump ); + String hexDump = ByteBufUtil.hexDump( buffer, readerIndexWithChunkHeader, lengthWithChunkHeader ); + log.trace( "S: %s", hexDump ); } return super.extractFrame( ctx, buffer, index, length ); } diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/inbound/InboundMessageDispatcher.java b/driver/src/main/java/org/neo4j/driver/internal/async/inbound/InboundMessageDispatcher.java index 0549ba09b7..4c5e462183 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/inbound/InboundMessageDispatcher.java +++ b/driver/src/main/java/org/neo4j/driver/internal/async/inbound/InboundMessageDispatcher.java @@ -26,7 +26,7 @@ import java.util.Queue; import org.neo4j.driver.internal.handlers.AckFailureResponseHandler; -import org.neo4j.driver.internal.logging.PrefixedLogger; +import org.neo4j.driver.internal.logging.ChannelActivityLogger; import org.neo4j.driver.internal.messaging.MessageHandler; import org.neo4j.driver.internal.spi.ResponseHandler; import org.neo4j.driver.internal.util.ErrorUtil; @@ -50,7 +50,7 @@ public class InboundMessageDispatcher implements MessageHandler public InboundMessageDispatcher( Channel channel, Logging logging ) { this.channel = requireNonNull( channel ); - this.log = new PrefixedLogger( channel.toString(), logging, getClass() ); + this.log = new ChannelActivityLogger( channel, logging, getClass() ); } public void queue( ResponseHandler handler ) diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/inbound/InboundMessageHandler.java b/driver/src/main/java/org/neo4j/driver/internal/async/inbound/InboundMessageHandler.java index 8bab421666..885a9bd4f3 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/inbound/InboundMessageHandler.java +++ b/driver/src/main/java/org/neo4j/driver/internal/async/inbound/InboundMessageHandler.java @@ -23,12 +23,12 @@ import io.netty.channel.SimpleChannelInboundHandler; import io.netty.handler.codec.DecoderException; -import org.neo4j.driver.internal.logging.PrefixedLogger; +import org.neo4j.driver.internal.logging.ChannelActivityLogger; import org.neo4j.driver.internal.messaging.MessageFormat; import org.neo4j.driver.v1.Logger; import org.neo4j.driver.v1.Logging; -import static io.netty.buffer.ByteBufUtil.prettyHexDump; +import static io.netty.buffer.ByteBufUtil.hexDump; import static java.util.Objects.requireNonNull; import static org.neo4j.driver.internal.async.ChannelAttributes.messageDispatcher; @@ -52,7 +52,7 @@ public InboundMessageHandler( MessageFormat messageFormat, Logging logging ) public void handlerAdded( ChannelHandlerContext ctx ) { messageDispatcher = requireNonNull( messageDispatcher( ctx.channel() ) ); - log = new PrefixedLogger( ctx.channel().toString(), logging, getClass() ); + log = new ChannelActivityLogger( ctx.channel(), logging, getClass() ); } @Override @@ -68,13 +68,13 @@ protected void channelRead0( ChannelHandlerContext ctx, ByteBuf msg ) if ( messageDispatcher.fatalErrorOccurred() ) { log.warn( "Message ignored because of the previous fatal error. Channel will be closed. Message:\n%s", - prettyHexDump( msg ) ); + hexDump( msg ) ); return; } if ( log.isTraceEnabled() ) { - log.trace( "S:\n%s", prettyHexDump( msg ) ); + log.trace( "S: %s", hexDump( msg ) ); } input.start( msg ); @@ -84,7 +84,7 @@ protected void channelRead0( ChannelHandlerContext ctx, ByteBuf msg ) } catch ( Throwable error ) { - throw new DecoderException( "Failed to read inbound message:\n" + prettyHexDump( msg ) + "\n", error ); + throw new DecoderException( "Failed to read inbound message:\n" + hexDump( msg ) + "\n", error ); } finally { diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/outbound/ChunkAwareByteBufOutput.java b/driver/src/main/java/org/neo4j/driver/internal/async/outbound/ChunkAwareByteBufOutput.java index 10e24a4044..7b1c5562de 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/outbound/ChunkAwareByteBufOutput.java +++ b/driver/src/main/java/org/neo4j/driver/internal/async/outbound/ChunkAwareByteBufOutput.java @@ -23,9 +23,9 @@ import org.neo4j.driver.internal.packstream.PackOutput; import static java.util.Objects.requireNonNull; -import static org.neo4j.driver.internal.async.ProtocolUtil.CHUNK_HEADER_SIZE_BYTES; -import static org.neo4j.driver.internal.async.ProtocolUtil.DEFAULT_MAX_OUTBOUND_CHUNK_SIZE_BYTES; -import static org.neo4j.driver.internal.async.ProtocolUtil.chunkHeaderPlaceholder; +import static org.neo4j.driver.internal.async.BoltProtocolV1Util.CHUNK_HEADER_SIZE_BYTES; +import static org.neo4j.driver.internal.async.BoltProtocolV1Util.DEFAULT_MAX_OUTBOUND_CHUNK_SIZE_BYTES; +import static org.neo4j.driver.internal.async.BoltProtocolV1Util.chunkHeaderPlaceholder; public class ChunkAwareByteBufOutput implements PackOutput { diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/outbound/OutboundMessageHandler.java b/driver/src/main/java/org/neo4j/driver/internal/async/outbound/OutboundMessageHandler.java index 70018c2b38..3f0771e7b8 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/outbound/OutboundMessageHandler.java +++ b/driver/src/main/java/org/neo4j/driver/internal/async/outbound/OutboundMessageHandler.java @@ -25,14 +25,14 @@ import java.util.List; -import org.neo4j.driver.internal.logging.PrefixedLogger; +import org.neo4j.driver.internal.logging.ChannelActivityLogger; import org.neo4j.driver.internal.messaging.Message; import org.neo4j.driver.internal.messaging.MessageFormat; import org.neo4j.driver.v1.Logger; import org.neo4j.driver.v1.Logging; -import static io.netty.buffer.ByteBufUtil.prettyHexDump; -import static org.neo4j.driver.internal.async.ProtocolUtil.messageBoundary; +import static io.netty.buffer.ByteBufUtil.hexDump; +import static org.neo4j.driver.internal.async.BoltProtocolV1Util.messageBoundary; public class OutboundMessageHandler extends MessageToMessageEncoder { @@ -61,7 +61,7 @@ private OutboundMessageHandler( MessageFormat messageFormat, boolean byteArraySu @Override public void handlerAdded( ChannelHandlerContext ctx ) { - log = new PrefixedLogger( ctx.channel().toString(), logging, getClass() ); + log = new ChannelActivityLogger( ctx.channel(), logging, getClass() ); } @Override @@ -92,7 +92,7 @@ protected void encode( ChannelHandlerContext ctx, Message msg, List out if ( log.isTraceEnabled() ) { - log.trace( "C:\n%s", prettyHexDump( messageBuf ) ); + log.trace( "C: %s", hexDump( messageBuf ) ); } out.add( messageBuf ); diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/pool/ConnectionPoolImpl.java b/driver/src/main/java/org/neo4j/driver/internal/async/pool/ConnectionPoolImpl.java index 52d99ae0b3..d328113077 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/pool/ConnectionPoolImpl.java +++ b/driver/src/main/java/org/neo4j/driver/internal/async/pool/ConnectionPoolImpl.java @@ -78,7 +78,7 @@ public ConnectionPoolImpl( ChannelConnector connector, Bootstrap bootstrap, Pool @Override public CompletionStage acquire( BoltServerAddress address ) { - log.debug( "Acquiring connection from pool towards %s", address ); + log.trace( "Acquiring a connection from pool towards %s", address ); assertNotClosed(); ChannelPool pool = getOrCreatePool( address ); diff --git a/driver/src/main/java/org/neo4j/driver/internal/async/pool/NettyChannelHealthChecker.java b/driver/src/main/java/org/neo4j/driver/internal/async/pool/NettyChannelHealthChecker.java index c324c59f08..b58c2609ae 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/async/pool/NettyChannelHealthChecker.java +++ b/driver/src/main/java/org/neo4j/driver/internal/async/pool/NettyChannelHealthChecker.java @@ -71,9 +71,11 @@ private boolean isTooOld( Channel channel ) long maxAgeMillis = poolSettings.maxConnectionLifetime(); boolean tooOld = ageMillis > maxAgeMillis; - - log.trace( "Can't acquire channel %s from the pool because it is too old: %s > %s", - channel, ageMillis, maxAgeMillis ); + if ( tooOld ) + { + log.trace( "Failed acquire channel %s from the pool because it is too old: %s > %s", + channel, ageMillis, maxAgeMillis ); + } return tooOld; } diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureClusterCompositionProvider.java b/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureClusterCompositionProvider.java index 75c9fa71bc..87edc623f6 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureClusterCompositionProvider.java +++ b/driver/src/main/java/org/neo4j/driver/internal/cluster/RoutingProcedureClusterCompositionProvider.java @@ -72,7 +72,6 @@ private ClusterCompositionResponse processRoutingResponse( RoutingProcedureRespo } List records = response.records(); - log.info( "Received response from %s procedure: %s", invokedProcedureString( response ), records ); long now = clock.millis(); diff --git a/driver/src/main/java/org/neo4j/driver/internal/cluster/loadbalancing/LoadBalancer.java b/driver/src/main/java/org/neo4j/driver/internal/cluster/loadbalancing/LoadBalancer.java index 5b4a50f4e4..d78db828a1 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/cluster/loadbalancing/LoadBalancer.java +++ b/driver/src/main/java/org/neo4j/driver/internal/cluster/loadbalancing/LoadBalancer.java @@ -138,7 +138,7 @@ private synchronized CompletionStage freshRoutingTable( AccessMode else if ( routingTable.isStaleFor( mode ) ) { // existing routing table is not fresh and should be updated - log.info( "Routing information is stale. %s", routingTable ); + log.info( "Routing table is stale. %s", routingTable ); CompletableFuture resultFuture = new CompletableFuture<>(); refreshRoutingTableFuture = resultFuture; @@ -173,7 +173,7 @@ private synchronized void freshClusterCompositionFetched( ClusterComposition com routingTable.update( composition ); connectionPool.retainAll( routingTable.servers() ); - log.info( "Refreshed routing information. %s", routingTable ); + log.info( "Updated routing table. %s", routingTable ); CompletableFuture routingTableFuture = refreshRoutingTableFuture; refreshRoutingTableFuture = null; diff --git a/driver/src/main/java/org/neo4j/driver/internal/logging/ChannelActivityLogger.java b/driver/src/main/java/org/neo4j/driver/internal/logging/ChannelActivityLogger.java new file mode 100644 index 0000000000..2a8950f7d5 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/logging/ChannelActivityLogger.java @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2002-2017 "Neo Technology," + * Network Engine for Objects in Lund AB [http://neotechnology.com] + * + * This file is part of Neo4j. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.neo4j.driver.internal.logging; + +import io.netty.channel.Channel; + +import org.neo4j.driver.v1.Logger; +import org.neo4j.driver.v1.Logging; + +import static java.lang.String.format; + +public class ChannelActivityLogger extends ReformattedLogger +{ + private final Channel channel; + + public ChannelActivityLogger( Channel channel, Logging logging, Class owner ) + { + this( channel, logging.getLog( owner.getSimpleName() ) ); + } + + private ChannelActivityLogger( Channel channel, Logger delegate ) + { + super( delegate ); + this.channel = channel; + } + + @Override + protected String reformat( String message ) + { + if ( channel == null ) + { + return message; + } + return format( "[0x%s] %s", channel.id(), message ); + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/logging/ConsoleLogging.java b/driver/src/main/java/org/neo4j/driver/internal/logging/ConsoleLogging.java index c79ab1c94e..1b01f328c5 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/logging/ConsoleLogging.java +++ b/driver/src/main/java/org/neo4j/driver/internal/logging/ConsoleLogging.java @@ -94,10 +94,10 @@ public String format( LogRecord record ) StringBuilder builder = new StringBuilder( 1000 ); builder.append( dateFormat.format( new Date( record.getMillis() ) ) ); builder.append(" "); - builder.append("[").append(record.getLoggerName()).append("] "); - // builder.append( "[" ).append( record.getSourceClassName() ).append( "." ); - // builder.append( record.getSourceMethodName() ).append( "] - " ); - // builder.append( "[" ).append( record.getLevel() ).append( "] - " ); +// builder.append("[").append(record.getLoggerName()).append("] "); +// builder.append( "[" ).append( record.getSourceClassName() ).append( "." ); +// builder.append( record.getSourceMethodName() ).append( "] - " ); +// builder.append( "[" ).append( record.getLevel() ).append( "] - " ); builder.append( formatMessage( record ) ); builder.append( "\n" ); return builder.toString(); diff --git a/driver/src/main/java/org/neo4j/driver/internal/logging/NettyLogger.java b/driver/src/main/java/org/neo4j/driver/internal/logging/NettyLogger.java new file mode 100644 index 0000000000..771c4d856f --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/logging/NettyLogger.java @@ -0,0 +1,238 @@ +/* + * Copyright (c) 2002-2017 "Neo Technology," + * Network Engine for Objects in Lund AB [http://neotechnology.com] + * + * This file is part of Neo4j. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.neo4j.driver.internal.logging; + +import io.netty.util.internal.logging.AbstractInternalLogger; + +import java.util.regex.Pattern; + +import org.neo4j.driver.v1.Logger; + +import static java.lang.String.format; + + +public class NettyLogger extends AbstractInternalLogger +{ + private Logger log; + private static final Pattern PLACE_HOLDER_PATTERN = Pattern.compile("\\{\\}"); + + public NettyLogger( String name, Logger log ) + { + super( name ); + this.log = log; + } + + @Override + public boolean isTraceEnabled() + { + return log.isTraceEnabled(); + } + + @Override + public void trace( String msg ) + { + log.trace( msg ); + } + + @Override + public void trace( String format, Object arg ) + { + log.trace( toDriverLoggerFormat( format ), arg ); + } + + @Override + public void trace( String format, Object argA, Object argB ) + { + log.trace( toDriverLoggerFormat( format ), argA, argB ); + } + + @Override + public void trace( String format, Object... arguments ) + { + log.trace( toDriverLoggerFormat( format ), arguments ); + } + + @Override + public void trace( String msg, Throwable t ) + { + log.trace( "%s%n%s", msg, t ); + } + + @Override + public boolean isDebugEnabled() + { + return log.isDebugEnabled(); + } + + @Override + public void debug( String msg ) + { + log.debug( msg ); + } + + @Override + public void debug( String format, Object arg ) + { + log.debug( toDriverLoggerFormat( format ), arg ); + } + + @Override + public void debug( String format, Object argA, Object argB ) + { + log.debug( toDriverLoggerFormat( format ), argA, argB ); + } + + @Override + public void debug( String format, Object... arguments ) + { + log.debug( toDriverLoggerFormat( format ), arguments ); + } + + @Override + public void debug( String msg, Throwable t ) + { + log.debug( "%s%n%s", msg, t ); + } + + @Override + public boolean isInfoEnabled() + { + return true; + } + + @Override + public void info( String msg ) + { + log.info( msg ); + } + + @Override + public void info( String format, Object arg ) + { + log.info( toDriverLoggerFormat( format ), arg ); + } + + @Override + public void info( String format, Object argA, Object argB ) + { + log.info( toDriverLoggerFormat( format ), argA, argB ); + } + + @Override + public void info( String format, Object... arguments ) + { + log.info( toDriverLoggerFormat( format ), arguments ); + } + + @Override + public void info( String msg, Throwable t ) + { + log.info( "%s%n%s", msg, t ); + } + + @Override + public boolean isWarnEnabled() + { + return true; + } + + @Override + public void warn( String msg ) + { + log.warn( msg ); + } + + @Override + public void warn( String format, Object arg ) + { + log.warn( toDriverLoggerFormat( format ), arg ); + } + + @Override + public void warn( String format, Object... arguments ) + { + log.warn( toDriverLoggerFormat( format ), arguments ); + } + + @Override + public void warn( String format, Object argA, Object argB ) + { + log.warn( toDriverLoggerFormat( format ), argA, argB ); + } + + @Override + public void warn( String msg, Throwable t ) + { + log.warn( "%s%n%s", msg, t ); + } + + @Override + public boolean isErrorEnabled() + { + return true; + } + + @Override + public void error( String msg ) + { + log.error( msg, null ); + } + + @Override + public void error( String format, Object arg ) + { + error( format, new Object[]{arg} ); + } + + @Override + public void error( String format, Object argA, Object argB ) + { + error( format, new Object[]{argA, argB} ); + } + + @Override + public void error( String format, Object... arguments ) + { + format = toDriverLoggerFormat( format ); + if ( arguments.length == 0 ) + { + log.error( format, null ); + return; + } + + Object arg = arguments[arguments.length - 1]; + if ( arg instanceof Throwable ) + { + // still give all arguments to string format, + // for the worst case, the redundant parameter will be ignored. + log.error( format( format, arguments ), (Throwable) arg ); + } + } + + @Override + public void error( String msg, Throwable t ) + { + log.error( msg, t ); + } + + private String toDriverLoggerFormat( String format ) + { + return PLACE_HOLDER_PATTERN.matcher( format ).replaceAll( "%s" ); + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/logging/NettyLogging.java b/driver/src/main/java/org/neo4j/driver/internal/logging/NettyLogging.java new file mode 100644 index 0000000000..128447d382 --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/logging/NettyLogging.java @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2002-2017 "Neo Technology," + * Network Engine for Objects in Lund AB [http://neotechnology.com] + * + * This file is part of Neo4j. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.neo4j.driver.internal.logging; + +import io.netty.util.internal.logging.InternalLogger; +import io.netty.util.internal.logging.InternalLoggerFactory; + +import org.neo4j.driver.v1.Logging; + +/** + * This is the logging factory to delegate netty's logging to our logging system + */ +public class NettyLogging extends InternalLoggerFactory +{ + private Logging logging; + + public NettyLogging( Logging logging ) + { + this.logging = logging; + } + + @Override + protected InternalLogger newInstance( String name ) + { + return new NettyLogger( name, logging.getLog( name ) ); + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/logging/PrefixedLogger.java b/driver/src/main/java/org/neo4j/driver/internal/logging/PrefixedLogger.java index 540df9df1e..25b8d48271 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/logging/PrefixedLogger.java +++ b/driver/src/main/java/org/neo4j/driver/internal/logging/PrefixedLogger.java @@ -19,13 +19,9 @@ package org.neo4j.driver.internal.logging; import org.neo4j.driver.v1.Logger; -import org.neo4j.driver.v1.Logging; -import static java.util.Objects.requireNonNull; - -public class PrefixedLogger implements Logger +public class PrefixedLogger extends ReformattedLogger { - private final Logger delegate; private final String messagePrefix; public PrefixedLogger( Logger delegate ) @@ -33,72 +29,14 @@ public PrefixedLogger( Logger delegate ) this( null, delegate ); } - public PrefixedLogger( String messagePrefix, Logging logging, Class owner ) - { - this( messagePrefix, logging.getLog( owner.getSimpleName() ) ); - } - public PrefixedLogger( String messagePrefix, Logger delegate ) { - this.delegate = requireNonNull( delegate ); + super(delegate); this.messagePrefix = messagePrefix; } @Override - public void error( String message, Throwable cause ) - { - delegate.error( messageWithPrefix( message ), cause ); - } - - @Override - public void info( String message, Object... params ) - { - delegate.info( messageWithPrefix( message ), params ); - } - - @Override - public void warn( String message, Object... params ) - { - delegate.warn( messageWithPrefix( message ), params ); - } - - @Override - public void warn( String message, Throwable cause ) - { - delegate.warn( messageWithPrefix( message ), cause ); - } - - @Override - public void debug( String message, Object... params ) - { - if ( isDebugEnabled() ) - { - delegate.debug( messageWithPrefix( message ), params ); - } - } - - @Override - public void trace( String message, Object... params ) - { - if ( isTraceEnabled() ) - { - delegate.trace( messageWithPrefix( message ), params ); - } - } - - @Override - public boolean isTraceEnabled() - { - return delegate.isTraceEnabled(); - } - - @Override - public boolean isDebugEnabled() - { - return delegate.isDebugEnabled(); - } - - private String messageWithPrefix( String message ) + protected String reformat( String message ) { if ( messagePrefix == null ) { diff --git a/driver/src/main/java/org/neo4j/driver/internal/logging/ReformattedLogger.java b/driver/src/main/java/org/neo4j/driver/internal/logging/ReformattedLogger.java new file mode 100644 index 0000000000..381edd7e1f --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/logging/ReformattedLogger.java @@ -0,0 +1,89 @@ +/* + * Copyright (c) 2002-2017 "Neo Technology," + * Network Engine for Objects in Lund AB [http://neotechnology.com] + * + * This file is part of Neo4j. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.neo4j.driver.internal.logging; + +import org.neo4j.driver.v1.Logger; + +import static java.util.Objects.requireNonNull; + +public abstract class ReformattedLogger implements Logger +{ + private final Logger delegate; + + protected ReformattedLogger(Logger delegate) + { + this.delegate = requireNonNull( delegate ); + } + + @Override + public void error( String message, Throwable cause ) + { + delegate.error( reformat( message ), cause ); + } + + @Override + public void info( String message, Object... params ) + { + delegate.info( reformat( message ), params ); + } + + @Override + public void warn( String message, Object... params ) + { + delegate.warn( reformat( message ), params ); + } + + @Override + public void warn( String message, Throwable cause ) + { + delegate.warn( reformat( message ), cause ); + } + + @Override + public void debug( String message, Object... params ) + { + if ( isDebugEnabled() ) + { + delegate.debug( reformat( message ), params ); + } + } + + @Override + public void trace( String message, Object... params ) + { + if ( isTraceEnabled() ) + { + delegate.trace( reformat( message ), params ); + } + } + + @Override + public boolean isTraceEnabled() + { + return delegate.isTraceEnabled(); + } + + @Override + public boolean isDebugEnabled() + { + return delegate.isDebugEnabled(); + } + + protected abstract String reformat( String message ); +} diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/ChannelConnectedListenerTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/ChannelConnectedListenerTest.java index c7a23de0d9..06ccd1c7e3 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/ChannelConnectedListenerTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/async/ChannelConnectedListenerTest.java @@ -34,7 +34,7 @@ import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; import static org.neo4j.driver.internal.BoltServerAddress.LOCAL_DEFAULT; -import static org.neo4j.driver.internal.async.ProtocolUtil.handshake; +import static org.neo4j.driver.internal.async.BoltProtocolV1Util.handshakeBuf; import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; import static org.neo4j.driver.v1.util.TestUtil.await; @@ -85,7 +85,7 @@ public void shouldWriteHandshakeWhenChannelConnected() assertNotNull( channel.pipeline().get( HandshakeHandler.class ) ); assertTrue( channel.finish() ); - assertEquals( handshake(), channel.readOutbound() ); + assertEquals( handshakeBuf(), channel.readOutbound() ); } private static ChannelConnectedListener newListener( ChannelPromise handshakeCompletedPromise ) diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/HandshakeHandlerTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/HandshakeHandlerTest.java index f05f16026a..a36d15440e 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/HandshakeHandlerTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/async/HandshakeHandlerTest.java @@ -47,9 +47,9 @@ import static org.junit.Assert.assertThat; import static org.junit.Assert.fail; import static org.neo4j.driver.internal.async.ChannelAttributes.setMessageDispatcher; -import static org.neo4j.driver.internal.async.ProtocolUtil.HTTP; -import static org.neo4j.driver.internal.async.ProtocolUtil.NO_PROTOCOL_VERSION; -import static org.neo4j.driver.internal.async.ProtocolUtil.PROTOCOL_VERSION_1; +import static org.neo4j.driver.internal.async.BoltProtocolV1Util.HTTP; +import static org.neo4j.driver.internal.async.BoltProtocolV1Util.NO_PROTOCOL_VERSION; +import static org.neo4j.driver.internal.async.BoltProtocolV1Util.PROTOCOL_VERSION_1; import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; import static org.neo4j.driver.v1.util.TestUtil.await; diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/NettyChannelInitializerTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/NettyChannelInitializerTest.java index 3c6491d317..0bd4ee8b8f 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/NettyChannelInitializerTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/async/NettyChannelInitializerTest.java @@ -36,6 +36,7 @@ import static org.neo4j.driver.internal.async.ChannelAttributes.creationTimestamp; import static org.neo4j.driver.internal.async.ChannelAttributes.messageDispatcher; import static org.neo4j.driver.internal.async.ChannelAttributes.serverAddress; +import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; public class NettyChannelInitializerTest { @@ -51,7 +52,8 @@ public void tearDown() public void shouldAddSslHandlerWhenRequiresEncryption() throws Exception { SecurityPlan security = SecurityPlan.forAllCertificates(); - NettyChannelInitializer initializer = new NettyChannelInitializer( LOCAL_DEFAULT, security, new FakeClock() ); + NettyChannelInitializer initializer = new NettyChannelInitializer( LOCAL_DEFAULT, security, new FakeClock(), + DEV_NULL_LOGGING ); initializer.initChannel( channel ); @@ -62,7 +64,8 @@ public void shouldAddSslHandlerWhenRequiresEncryption() throws Exception public void shouldNotAddSslHandlerWhenDoesNotRequireEncryption() { SecurityPlan security = SecurityPlan.insecure(); - NettyChannelInitializer initializer = new NettyChannelInitializer( LOCAL_DEFAULT, security, new FakeClock() ); + NettyChannelInitializer initializer = new NettyChannelInitializer( LOCAL_DEFAULT, security, new FakeClock(), + DEV_NULL_LOGGING ); initializer.initChannel( channel ); @@ -75,7 +78,7 @@ public void shouldUpdateChannelAttributes() Clock clock = mock( Clock.class ); when( clock.millis() ).thenReturn( 42L ); SecurityPlan security = SecurityPlan.insecure(); - NettyChannelInitializer initializer = new NettyChannelInitializer( LOCAL_DEFAULT, security, clock ); + NettyChannelInitializer initializer = new NettyChannelInitializer( LOCAL_DEFAULT, security, clock, DEV_NULL_LOGGING ); initializer.initChannel( channel ); diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/inbound/ChunkDecoderTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/inbound/ChunkDecoderTest.java index c59b5c365e..27c431d400 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/inbound/ChunkDecoderTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/async/inbound/ChunkDecoderTest.java @@ -27,7 +27,7 @@ import org.neo4j.driver.v1.Logger; import org.neo4j.driver.v1.Logging; -import static io.netty.buffer.ByteBufUtil.prettyHexDump; +import static io.netty.buffer.ByteBufUtil.hexDump; import static io.netty.buffer.Unpooled.buffer; import static io.netty.buffer.Unpooled.copyShort; import static io.netty.buffer.Unpooled.wrappedBuffer; @@ -152,7 +152,7 @@ public void shouldLogEmptyChunkOnTraceLevel() verify( logger ).trace( anyString(), messageCaptor.capture() ); // pretty hex dump should be logged - assertEquals( prettyHexDump( buffer ), messageCaptor.getValue() ); + assertEquals( hexDump( buffer ), messageCaptor.getValue() ); // single empty chunk should be available for reading assertEquals( 1, channel.inboundMessages().size() ); assertByteBufEquals( wrappedBuffer( new byte[0] ), channel.readInbound() ); @@ -176,7 +176,7 @@ public void shouldLogNonEmptyChunkOnTraceLevel() verify( logger ).trace( anyString(), messageCaptor.capture() ); // pretty hex dump should be logged - assertEquals( prettyHexDump( buffer ), messageCaptor.getValue() ); + assertEquals( hexDump( buffer ), messageCaptor.getValue() ); // single chunk should be available for reading assertEquals( 1, channel.inboundMessages().size() ); assertByteBufEquals( wrappedBuffer( bytes ), channel.readInbound() ); diff --git a/driver/src/test/java/org/neo4j/driver/internal/async/outbound/OutboundMessageHandlerTest.java b/driver/src/test/java/org/neo4j/driver/internal/async/outbound/OutboundMessageHandlerTest.java index 8acca7d8aa..8c7fd046dd 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/async/outbound/OutboundMessageHandlerTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/async/outbound/OutboundMessageHandlerTest.java @@ -50,7 +50,7 @@ import static org.mockito.Mockito.doAnswer; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; -import static org.neo4j.driver.internal.async.ProtocolUtil.messageBoundary; +import static org.neo4j.driver.internal.async.BoltProtocolV1Util.messageBoundary; import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; import static org.neo4j.driver.internal.messaging.MessageFormat.Writer; import static org.neo4j.driver.internal.messaging.PullAllMessage.PULL_ALL; diff --git a/driver/src/test/java/org/neo4j/driver/internal/messaging/MessageFormatTest.java b/driver/src/test/java/org/neo4j/driver/internal/messaging/MessageFormatTest.java index 062bfb724d..03118b959b 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/messaging/MessageFormatTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/messaging/MessageFormatTest.java @@ -45,7 +45,7 @@ import static org.junit.Assert.assertTrue; import static org.neo4j.driver.internal.async.ChannelAttributes.messageDispatcher; import static org.neo4j.driver.internal.async.ChannelAttributes.setMessageDispatcher; -import static org.neo4j.driver.internal.async.ProtocolUtil.messageBoundary; +import static org.neo4j.driver.internal.async.BoltProtocolV1Util.messageBoundary; import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING; import static org.neo4j.driver.v1.Values.EmptyMap; import static org.neo4j.driver.v1.Values.ofValue; diff --git a/driver/src/test/java/org/neo4j/driver/v1/util/Neo4jRunner.java b/driver/src/test/java/org/neo4j/driver/v1/util/Neo4jRunner.java index 5f758646e2..ac1ad1665b 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/util/Neo4jRunner.java +++ b/driver/src/test/java/org/neo4j/driver/v1/util/Neo4jRunner.java @@ -26,9 +26,12 @@ import java.util.ArrayList; import java.util.List; import java.util.Map; +import java.util.logging.Level; import org.neo4j.driver.internal.BoltServerAddress; +import org.neo4j.driver.internal.logging.ConsoleLogging; import org.neo4j.driver.v1.AuthToken; +import org.neo4j.driver.v1.Config; import org.neo4j.driver.v1.Driver; import org.neo4j.driver.v1.GraphDatabase; @@ -55,6 +58,8 @@ public class Neo4jRunner public static final String NEOCTRL_ARGS = System.getProperty( "neoctrl.args", DEFAULT_NEOCTRL_ARGS ); public static final URI DEFAULT_URI = URI.create( "bolt://localhost:7687" ); public static final BoltServerAddress DEFAULT_ADDRESS = new BoltServerAddress( DEFAULT_URI ); + public static final Config DEFAULT_CONFIG = Config.build().withLogging( new ConsoleLogging( Level.INFO ) ) + .toConfig(); public static final String USER = "neo4j"; public static final String PASSWORD = "password"; @@ -128,7 +133,7 @@ public Driver driver() if ( driver == null ) { - driver = GraphDatabase.driver( DEFAULT_URI, DEFAULT_AUTH_TOKEN ); + driver = GraphDatabase.driver( DEFAULT_URI, DEFAULT_AUTH_TOKEN, DEFAULT_CONFIG ); } return driver; }