聊聊reactor-netty的AccessLog

本文主要研究一下reactor-netty的AccessLog

开启

  • 对于使用tomcat的spring boot应用,可以server.tomcat.accesslog.enabled=true来开启
  • 对于使用jetty的spring boot应用,可以server.jetty.accesslog.enabled=true来开启
  • 对于使用undertow的spring boot应用,可以server.undertow.accesslog.enabled=true来开启

对于使用webflux的应用,没有这么对应的配置,但是可以通过-Dreactor.netty.http.server.accessLogEnabled=true来开启

ReactorNetty

reactor-netty-0.8.5.RELEASE-sources.jar!/reactor/netty/ReactorNetty.java

/**
 * Internal helpers for reactor-netty contracts
 *
 * @author Stephane Maldini
 */
public final class ReactorNetty {
    //......

    // System properties names

    /**
     * Default worker thread count, fallback to available processor
     * (but with a minimum value of 4)
     */
    public static final String IO_WORKER_COUNT = "reactor.netty.ioWorkerCount";
    /**
     * Default selector thread count, fallback to -1 (no selector thread)
     */
    public static final String IO_SELECT_COUNT = "reactor.netty.ioSelectCount";
    /**
     * Default worker thread count for UDP, fallback to available processor
     * (but with a minimum value of 4)
     */
    public static final String UDP_IO_THREAD_COUNT = "reactor.netty.udp.ioThreadCount";


    /**
     * Default value whether the native transport (epoll, kqueue) will be preferred,
     * fallback it will be preferred when available
     */
    public static final String NATIVE = "reactor.netty.native";


    /**
     * Default max connections, if -1 will never wait to acquire before opening a new
     * connection in an unbounded fashion. Fallback to
     * available number of processors (but with a minimum value of 16)
     */
    public static final String POOL_MAX_CONNECTIONS = "reactor.netty.pool.maxConnections";
    /**
     * Default acquisition timeout (milliseconds) before error. If -1 will never wait to
     * acquire before opening a new
     * connection in an unbounded fashion. Fallback 45 seconds
     */
    public static final String POOL_ACQUIRE_TIMEOUT = "reactor.netty.pool.acquireTimeout";


    /**
     * Default SSL handshake timeout (milliseconds), fallback to 10 seconds
     */
    public static final String SSL_HANDSHAKE_TIMEOUT = "reactor.netty.tcp.sslHandshakeTimeout";
    /**
     * Default value whether the SSL debugging on the client side will be enabled/disabled,
     * fallback to SSL debugging disabled
     */
    public static final String SSL_CLIENT_DEBUG = "reactor.netty.tcp.ssl.client.debug";
    /**
     * Default value whether the SSL debugging on the server side will be enabled/disabled,
     * fallback to SSL debugging disabled
     */
    public static final String SSL_SERVER_DEBUG = "reactor.netty.tcp.ssl.server.debug";


    /**
     * Specifies whether the Http Server access log will be enabled.
     * By default it is disabled.
     */
    public static final String ACCESS_LOG_ENABLED = "reactor.netty.http.server.accessLogEnabled";

    //......
}
  • ReactorNetty定义了ACCESS_LOG_ENABLED常量,其值为reactor.netty.http.server.accessLogEnabled

HttpServerBind

reactor-netty-0.8.5.RELEASE-sources.jar!/reactor/netty/http/server/HttpServerBind.java

final class HttpServerBind extends HttpServer
        implements Function<ServerBootstrap, ServerBootstrap> {

    static final HttpServerBind INSTANCE = new HttpServerBind();

    static final Function<DisposableServer, DisposableServer> CLEANUP_GLOBAL_RESOURCE = DisposableBind::new;

    static final boolean ACCESS_LOG =
            Boolean.parseBoolean(System.getProperty(ACCESS_LOG_ENABLED, "false"));

    //......

    static final class Http1Initializer
            implements BiConsumer<ConnectionObserver, Channel>  {

        final int                                                line;
        final int                                                header;
        final int                                                chunk;
        final boolean                                            validate;
        final int                                                buffer;
        final int                                                minCompressionSize;
        final BiPredicate<HttpServerRequest, HttpServerResponse> compressPredicate;
        final boolean                                            forwarded;
        final ServerCookieEncoder                                cookieEncoder;
        final ServerCookieDecoder                                cookieDecoder;

        Http1Initializer(int line,
                int header,
                int chunk,
                boolean validate,
                int buffer,
                int minCompressionSize,
                @Nullable BiPredicate<HttpServerRequest, HttpServerResponse> compressPredicate,
                boolean forwarded,
                ServerCookieEncoder encoder,
                ServerCookieDecoder decoder) {
            this.line = line;
            this.header = header;
            this.chunk = chunk;
            this.validate = validate;
            this.buffer = buffer;
            this.minCompressionSize = minCompressionSize;
            this.compressPredicate = compressPredicate;
            this.forwarded = forwarded;
            this.cookieEncoder = encoder;
            this.cookieDecoder = decoder;
        }

        @Override
        public void accept(ConnectionObserver listener, Channel channel) {
            ChannelPipeline p = channel.pipeline();

            p.addLast(NettyPipeline.HttpCodec, new HttpServerCodec(line, header, chunk, validate, buffer));

            if (ACCESS_LOG) {
                p.addLast(NettyPipeline.AccessLogHandler, new AccessLogHandler());
            }

            boolean alwaysCompress = compressPredicate == null && minCompressionSize == 0;

            if (alwaysCompress) {
                p.addLast(NettyPipeline.CompressionHandler,
                        new SimpleCompressionHandler());
            }

            p.addLast(NettyPipeline.HttpTrafficHandler,
                    new HttpTrafficHandler(listener, forwarded, compressPredicate, cookieEncoder, cookieDecoder));
        }
    }

    //......
}
  • HttpServerBind有个ACCESS_LOG属性,它读取ReactorNetty的ACCESS_LOG_ENABLED( reactor.netty.http.server.accessLogEnabled
    )的属性,读取不到默认为false;HttpServerBind有个Http1Initializer类,它的accept方法会判断ACCESS_LOG是否为true,如果为true则会往Channel的pipeline添加名为accessLogHandler( NettyPipeline.AccessLogHandler
    )的AccessLogHandler

AccessLogHandler

reactor-netty-0.8.5.RELEASE-sources.jar!/reactor/netty/http/server/AccessLogHandler.java

final class AccessLogHandler extends ChannelDuplexHandler {

    AccessLog accessLog = new AccessLog();

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        if (msg instanceof HttpRequest) {
            final HttpRequest request = (HttpRequest) msg;
            final SocketChannel channel = (SocketChannel) ctx.channel();

            accessLog = new AccessLog()
                    .address(channel.remoteAddress().getHostString())
                    .port(channel.localAddress().getPort())
                    .method(request.method().name())
                    .uri(request.uri())
                    .protocol(request.protocolVersion().text());
        }
        super.channelRead(ctx, msg);
    }

    @Override
    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) {
        if (msg instanceof HttpResponse) {
            final HttpResponse response = (HttpResponse) msg;
            final HttpResponseStatus status = response.status();

            if (status.equals(HttpResponseStatus.CONTINUE)) {
                ctx.write(msg, promise);
                return;
            }

            final boolean chunked = HttpUtil.isTransferEncodingChunked(response);
            accessLog.status(status.codeAsText())
                     .chunked(chunked);
            if (!chunked) {
                accessLog.contentLength(HttpUtil.getContentLength(response, -1));
            }
        }
        if (msg instanceof LastHttpContent) {
            accessLog.increaseContentLength(((LastHttpContent) msg).content().readableBytes());
            ctx.write(msg, promise)
               .addListener(future -> {
                   if (future.isSuccess()) {
                       accessLog.log();
                   }
               });
            return;
        }
        if (msg instanceof ByteBuf) {
            accessLog.increaseContentLength(((ByteBuf) msg).readableBytes());
        }
        if (msg instanceof ByteBufHolder) {
            accessLog.increaseContentLength(((ByteBufHolder) msg).content().readableBytes());
        }
        ctx.write(msg, promise);
    }
}
  • AccessLogHandler继承了ChannelDuplexHandler;在channelRead的时候创建了AccessLog对象,在write的时候更新AccessLog对象;当msg为LastHttpContent时,则添加了一个listener,在成功回调时执行accessLog.log()

AccessLog

reactor-netty-0.8.5.RELEASE-sources.jar!/reactor/netty/http/server/AccessLog.java

final class AccessLog {
    static final Logger log = Loggers.getLogger("reactor.netty.http.server.AccessLog");
    static final DateTimeFormatter DATE_TIME_FORMATTER =
            DateTimeFormatter.ofPattern("dd/MMM/yyyy:HH:mm:ss Z", Locale.US);
    static final String COMMON_LOG_FORMAT =
            "{} - {} [{}] /"{} {} {}/" {} {} {} {} ms";
    static final String MISSING = "-";

    final String zonedDateTime;

    String address;
    CharSequence method;
    CharSequence uri;
    String protocol;
    String user = MISSING;
    CharSequence status;
    long contentLength;
    boolean chunked;
    long startTime = System.currentTimeMillis();
    int port;

    AccessLog() {
        this.zonedDateTime = ZonedDateTime.now().format(DATE_TIME_FORMATTER);
    }

    AccessLog address(String address) {
        this.address = Objects.requireNonNull(address, "address");
        return this;
    }

    AccessLog port(int port) {
        this.port = port;
        return this;
    }

    AccessLog method(CharSequence method) {
        this.method = Objects.requireNonNull(method, "method");
        return this;
    }

    AccessLog uri(CharSequence uri) {
        this.uri = Objects.requireNonNull(uri, "uri");
        return this;
    }

    AccessLog protocol(String protocol) {
        this.protocol = Objects.requireNonNull(protocol, "protocol");
        return this;
    }

    AccessLog status(CharSequence status) {
        this.status = Objects.requireNonNull(status, "status");
        return this;
    }

    AccessLog contentLength(long contentLength) {
        this.contentLength = contentLength;
        return this;
    }

    AccessLog increaseContentLength(long contentLength) {
        if (chunked) {
            this.contentLength += contentLength;
        }
        return this;
    }

    AccessLog chunked(boolean chunked) {
        this.chunked = chunked;
        return this;
    }

    long duration() {
        return System.currentTimeMillis() - startTime;
    }

    void log() {
        if (log.isInfoEnabled()) {
            log.info(COMMON_LOG_FORMAT, address, user, zonedDateTime,
                    method, uri, protocol, status, (contentLength > -1 ? contentLength : MISSING), port, duration());
        }
    }
}
  • AccessLog的log方法直接通过logger输出日志,其日志格式为COMMON_LOG_FORMAT( {} - {} [{}] "{} {} {}" {} {} {} {} ms
    ),分别是address, user, zonedDateTime, method, uri, protocol, status, contentLength, port, duration

小结

  • 对于使用webflux的应用,可以通过-Dreactor.netty.http.server.accessLogEnabled=true来开启access log
  • HttpServerBind有个ACCESS_LOG属性,它读取ReactorNetty的ACCESS_LOG_ENABLED( reactor.netty.http.server.accessLogEnabled
    )的属性,读取不到默认为false;HttpServerBind有个Http1Initializer类,它的accept方法会判断ACCESS_LOG是否为true,如果为true则会往Channel的pipeline添加名为accessLogHandler( NettyPipeline.AccessLogHandler
    )的AccessLogHandler
  • AccessLogHandler继承了ChannelDuplexHandler;在channelRead的时候创建了AccessLog对象,在write的时候更新AccessLog对象;当msg为LastHttpContent时,则添加了一个listener,在成功回调时执行accessLog.log();AccessLog的log方法直接通过logger输出日志,其日志格式为COMMON_LOG_FORMAT( {} - {} [{}] "{} {} {}" {} {} {} {} ms
    ),分别是address, user, zonedDateTime, method, uri, protocol, status, contentLength, port, duration

doc

  • Spring Boot Reactor Netty Configuration

原文 

https://segmentfault.com/a/1190000018769708

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » 聊聊reactor-netty的AccessLog

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址