For SO question 9852473 on http://stackoverflow.com/questions/9852473/how-to-configure-netty-logger-factory-in-order-to-see-the-output-of-logginghandl

logback.xml

<configuration>

  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
    <!-- encoders are assigned the type
         ch.qos.logback.classic.encoder.PatternLayoutEncoder by default -->
    <encoder>
      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
    </encoder>
  </appender>

  <root level="debug">
    <appender-ref ref="STDOUT" />
  </root>
</configuration>

NettyLoggingHandlerTest.java

import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.charset.Charset;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

import org.jboss.netty.bootstrap.ClientBootstrap;
import org.jboss.netty.bootstrap.ServerBootstrap;
import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.buffer.ChannelBuffers;
import org.jboss.netty.channel.Channel;
import org.jboss.netty.channel.ChannelHandlerContext;
import org.jboss.netty.channel.ChannelPipeline;
import org.jboss.netty.channel.ChannelPipelineFactory;
import org.jboss.netty.channel.Channels;
import org.jboss.netty.channel.ExceptionEvent;
import org.jboss.netty.channel.MessageEvent;
import org.jboss.netty.channel.SimpleChannelUpstreamHandler;
import org.jboss.netty.channel.socket.nio.NioClientSocketChannelFactory;
import org.jboss.netty.channel.socket.nio.NioServerSocketChannelFactory;
import org.jboss.netty.handler.codec.http.DefaultHttpRequest;
import org.jboss.netty.handler.codec.http.DefaultHttpResponse;
import org.jboss.netty.handler.codec.http.HttpChunkAggregator;
import org.jboss.netty.handler.codec.http.HttpClientCodec;
import org.jboss.netty.handler.codec.http.HttpHeaders;
import org.jboss.netty.handler.codec.http.HttpMethod;
import org.jboss.netty.handler.codec.http.HttpRequest;
import org.jboss.netty.handler.codec.http.HttpRequestDecoder;
import org.jboss.netty.handler.codec.http.HttpResponse;
import org.jboss.netty.handler.codec.http.HttpResponseEncoder;
import org.jboss.netty.handler.codec.http.HttpResponseStatus;
import org.jboss.netty.handler.codec.http.HttpVersion;
import org.jboss.netty.handler.logging.LoggingHandler;
import org.jboss.netty.logging.InternalLogLevel;
import org.jboss.netty.logging.InternalLoggerFactory;
import org.jboss.netty.logging.Slf4JLoggerFactory;
import org.jboss.netty.util.CharsetUtil;

public class NettyLoggingHandlerTest {

  private static final int PORT = 10000;

	private static final SocketAddress ADRESS = new InetSocketAddress("127.0.0.1", PORT);

	public static void main(String[] args) throws Exception {
		InternalLoggerFactory.setDefaultFactory(new Slf4JLoggerFactory());
		// Server
		ServerBootstrap server = new ServerBootstrap(new NioServerSocketChannelFactory(Executors.newCachedThreadPool(),
				Executors.newCachedThreadPool()));

		server.setPipelineFactory(new ServerPipelineFactory());
		server.bind(new InetSocketAddress(PORT));

		// Clients
		ClientBootstrap client = new ClientBootstrap(new NioClientSocketChannelFactory(Executors.newCachedThreadPool(),
				Executors.newCachedThreadPool()));

		// This is used instead of normal lock here since I need to learn
		// concurency
		FutureTask<Void> lock = new FutureTask<Void>(new Callable<Void>() {

			@Override
			public Void call() throws Exception {
				return null;
			}
		});

		client.setPipelineFactory(new ClientPipelineFactory(lock));

		testCommunication(client, lock);

		// closing clients and servers
		client.releaseExternalResources();
		server.releaseExternalResources();

	}

	private static long testCommunication(ClientBootstrap client, FutureTask<Void> lock) throws InterruptedException,
			ExecutionException {
		long start = System.nanoTime();
		Channel channel = client.connect(ADRESS).awaitUninterruptibly().getChannel();

		HttpRequest request = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.POST, "test");
		ChannelBuffer buffer = ChannelBuffers.copiedBuffer("ping", Charset.defaultCharset());
		request.addHeader(HttpHeaders.Names.CONTENT_LENGTH, buffer.readableBytes());
		request.setContent(buffer);
		HttpHeaders.setKeepAlive(request, true);
		channel.write(request);

		// will wait for end of writing here
		lock.get();

		channel.close().awaitUninterruptibly();

		return System.nanoTime() - start;

	}

	private static class RequestHandler extends SimpleChannelUpstreamHandler {

		@Override
		public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {

			HttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
			ChannelBuffer buffer = ChannelBuffers.copiedBuffer("pong", CharsetUtil.UTF_8);
			response.setContent(buffer);
			response.setHeader(HttpHeaders.Names.CONTENT_TYPE, "text/plain; charset=UTF-8");
			response.addHeader(HttpHeaders.Names.CONTENT_LENGTH, buffer.readableBytes());
			HttpHeaders.setKeepAlive(response, true);
			e.getChannel().write(response);

		}

		@Override
		public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) throws Exception {
			e.getCause().printStackTrace();
			super.exceptionCaught(ctx, e);
		}
	}

	private static class ServerPipelineFactory implements ChannelPipelineFactory {

		@Override
		public ChannelPipeline getPipeline() throws Exception {
			ChannelPipeline pipeline = Channels.pipeline();
			pipeline.addLast("logger", new LoggingHandler(InternalLogLevel.DEBUG));
			pipeline.addLast("decoder", new HttpRequestDecoder());
			pipeline.addLast("aggregator", new HttpChunkAggregator(1048576));
			pipeline.addLast("encoder", new HttpResponseEncoder());
			pipeline.addLast("handler", new RequestHandler());

			return pipeline;
		}

	}

	private static class ClientPipelineFactory implements ChannelPipelineFactory {
		private final FutureTask<Void> lock;

		public ClientPipelineFactory(FutureTask<Void> lock) {
			this.lock = lock;
		}

		@Override
		public ChannelPipeline getPipeline() throws Exception {
			ChannelPipeline pipeline = Channels.pipeline();

			pipeline.addLast("codec", new HttpClientCodec());

			pipeline.addLast("aggregator", new HttpChunkAggregator(1048576));

			pipeline.addLast("handler", new ResponseHandler(lock));
			return pipeline;
		}
	}

	private static class ResponseHandler extends SimpleChannelUpstreamHandler {
		private final FutureTask<Void> lock;

		public ResponseHandler(FutureTask<Void> lock) {
			this.lock = lock;
		}

		@Override
		public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
			lock.run();
		}
	}
}

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.sopovs.moradanen</groupId>
	<artifactId>netty-debug-test</artifactId>
	<version>1.0-SNAPSHOT</version>
	<packaging>jar</packaging>

	<dependencies>
		<dependency>
			<groupId>io.netty</groupId>
			<artifactId>netty</artifactId>
			<version>3.6.0.Final</version>
		</dependency>

		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>1.7.2</version>
		</dependency>

		<dependency>
			<groupId>ch.qos.logback</groupId>
			<artifactId>logback-classic</artifactId>
			<version>1.0.9</version>
		</dependency>

	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.0</version>
				<configuration>
					<source>1.6</source>
					<target>1.6</target>
				</configuration>
			</plugin>

			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-enforcer-plugin</artifactId>
				<version>1.1.1</version>
				<executions>
					<execution>
						<id>enforce-versions</id>
						<goals>
							<goal>enforce</goal>
						</goals>
						<configuration>
							<rules>
								<DependencyConvergence />
								<bannedDependencies>
									<excludes>
										<exclude>log4j</exclude>
										<exclude>commons-logging</exclude>
										<exclude>slf4j-simple</exclude>
									</excludes>
								</bannedDependencies>
							</rules>
						</configuration>
					</execution>
				</executions>
			</plugin>
		</plugins>
	</build>


</project>