ipaste / logback-kafka-appender Goto Github PK

#logback-kafka-appender

This appender provides a way for applications to publish their application logs to Apache Kafka. This is ideal for applications within immutable containers without a writable filesystem.

Logback incompatibility Warning

Due to a bug in logback-core (LOGBACK-1158), logback-kafka-appender does not work with logback 1.1.7. This bug will be fixed in the upcoming logback 1.1.8. Until 1.1.8 is released, we recommend to use logback 1.1.6.

Full configuration example

Add logback-kafka-appender and logback-classic as library dependencies to your project.

[maven pom.xml]
<dependency>
    <groupId>com.github.danielwegener</groupId>
    <artifactId>logback-kafka-appender</artifactId>
    <version>0.1.0</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.1.2</version>
    <scope>runtime</scope>
</dependency>

// [build.sbt]
libraryDependencies += "com.github.danielwegener" % "logback-kafka-appender" % "0.1.0"
libraryDependencies += "ch.qos.logback" % "logback-classic" % "1.1.7"

This is an example logback.xml that uses a common PatternLayout to encode a log message as a string.

[src/main/resources/logback.xml]
<configuration>

    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- This is the kafkaAppender -->
    <appender name="kafkaAppender" class="com.github.danielwegener.logback.kafka.KafkaAppender">
            <!-- This is the default encoder that encodes every log message to an utf8-encoded string  -->
            <encoder class="com.github.danielwegener.logback.kafka.encoding.LayoutKafkaMessageEncoder">
                <layout class="ch.qos.logback.classic.PatternLayout">
                    <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
                </layout>
            </encoder>
            <topic>logs</topic>
            <keyingStrategy class="com.github.danielwegener.logback.kafka.keying.RoundRobinKeyingStrategy" />
            <deliveryStrategy class="com.github.danielwegener.logback.kafka.delivery.AsynchronousDeliveryStrategy" />

            <!-- each <producerConfig> translates to regular kafka-client config (format: key=value) -->
            <!-- producer configs are documented here: https://kafka.apache.org/documentation.html#newproducerconfigs -->
            <!-- bootstrap.servers is the only mandatory producerConfig -->
            <producerConfig>bootstrap.servers=localhost:9092</producerConfig>

            <!-- this is the fallback appender if kafka is not available. -->
            <appender-ref ref="STDOUT" />
        </appender>

    <root level="info">
        <appender-ref ref="kafkaAppender" />
    </root>
</configuration>

You may also look at the complete configuration examples

Compatibility

logback-kafka-appender depends on org.apache.kafka:kafka-clients:0.9.0.0:jar. It can append logs to a kafka broker with version 0.9.0.0 or higher.

The dependency to kafka-clients is not shadowed and may be upgraded to a higher, binary compatible, version through dependency resolution.

Delivery strategies

Direct logging over the network is not a trivial thing because it might be much less reliable than the local file system and has a much bigger impact on the application performance if the transport has hiccups.

You need make a essential decision: Is it more important to deliver all logs to the remote Kafka or is it more important to keep the application running smoothly? Either of this decisions allows you to tune this appender for throughput.

Note on Broker outages

The AsynchronousDeliveryStrategy does not prevent you from being blocked by the Kafka metadata exchange. That means: If all brokers are not reachable when the logging context starts, or all brokers become unreachable for a longer time period (> metadata.max.age.ms), your appender will eventually block. This behavior is undesirable in general and can be migitated with kafka-clients 0.9 (see #16). Until then, you can wrap the KafkaAppender with logback's own AsyncAppender.

An example configuration could look like this:

<configuration>

    <!-- This is the kafkaAppender -->
    <appender name="kafkaAppender" class="com.github.danielwegener.logback.kafka.KafkaAppender">
    <!-- Kafka Appender configuration -->
    </appender>

    <appender name="ASYNC" class="ch.qos.logback.classic.AsyncAppender">
        <appender-ref ref="kafkaAppender" />
    </appender>

    <root level="info">
        <appender-ref ref="ASYNC" />
    </root>
</configuration>

Custom delivery strategies

You may also roll your own delivery strategy. Just extend com.github.danielwegener.logback.kafka.delivery.DeliveryStrategy.

Fallback-Appender

If, for whatever reason, the kafka-producer decides that it cannot publish a log message, the message could still be logged to a fallback appender (a ConsoleAppender on STDOUT or STDERR would be a reasonable choice for that).

Just add your fallback appender(s) as logback appender-ref to the KafkaAppender section in your logback.xml. Every message that cannot be delivered to kafka will be written to all defined appender-ref's.

Example: <appender-ref ref="STDOUT"> while STDOUT is an defined appender.

Note that the AsynchronousDeliveryStrategy will reuse the kafka producers io thread to write the message to the fallback appenders. Thus all fallback appenders should be reasonable fast so they do not slow down or break the kafka producer.

Producer tuning

This appender uses the kafka producer introduced in kafka-0.8.2. It uses the producer default configuration.

You may override any known kafka producer config with an <producerConfig>Name=Value</producerConfig> block (note that the boostrap.servers config is mandatory). This allows a lot of fine tuning potential (eg. with batch.size, compression.type and linger.ms).

Serialization

This module provides a LayoutKafkaMessageEncoder that works like a common logback LayoutWrappingEncoder (with the distinction that it creates byte-arrays instead of appending them to a synchronous OutputStream).

The LayoutKafkaMessageEncoder uses a regular ch.qos.logback.core.Layout as layout-parameter.

This allows you to use any layout that is capable of laying out an ILoggingEvent or IAccessEvent like a well-known PatternLayout or for example the logstash-logback-encoder's LogstashLayout.

Custom Serialization

If you want to write something different than string on your kafka logging topic, you may roll your encoding mechanism. A use case would be to to smaller message sizes and/or better serialization/deserialization performance on the producing or consuming side. Useful formats could be BSON, Avro or others.

Just roll your own KafkaMessageEncoder. The interface is quite simple:

package com.github.danielwegener.logback.kafka.encoding;
public interface KafkaMessageEncoder<E> {
    byte[] doEncode(E event);
}

Your encoder should be type-parameterized for any subtype of the type of event you want to support (typically ILoggingEvent) like in

public class MyEncoder extends KafkaMessageEncoderBase<ILoggingEvent> { //...

You may also extend The KafkaMessageEncoderBase class that already implements the ContextAware and Lifecycle interfaces and thus allows accessing the appender configuration and work with its lifecycle.

Keying strategies / Partitioning

Kafka's scalability and ordering guarantees heavily rely on the concepts of partitions (more details here). For application logging this means that we need to decide how we want to distribute our log messages over multiple kafka topic partitions. One implication of this decision is how messages are ordered when they are consumed from a arbitrary multi-partition consumer since kafka only provides a guaranteed read order only on each single partition. Another implication is how evenly our log messages are distributed across all available partitions and therefore balanced between multiple brokers.

The order of log messages may or may not be important, depending on the intended consumer-audience (e.g. a logstash indexer will reorder all message by its timestamp anyway). The kafka producer client uses a message key as partitioner. Thus logback-kafka-appender supports the following partitioning strategies:

Custom keying strategies

If none of the above partitioners satisfies your requirements, you can easily implement your own partitioner by implementing a custom KeyingStrategy:

package foo;
import com.github.danielwegener.logback.kafka.keying.KeyingStrategy;

public class LevelKeyingStrategy implements KeyingStrategy<ILoggingEvent> {
    @Override
    public byte[] createKey(ILoggingEvent e) {
        return ByteBuffer.allocate(4).putInt(e.getLevel()).array();
    }
}

As most custom logback component, your custom partitioning strategy may implement the ch.qos.logback.core.spi.ContextAware and ch.qos.logback.core.spi.LifeCycle interfaces.

A custom keying strategy may especially become handy when you want to use kafka's log compactation facility.

FAQ

• Q: I want to log to different/multiple topics!
  A: No problem, create an appender for each topic.

• Q: I want my logs in the logstash json format!
  A: Use the LogstashLayout from logstash-logback-encoder
  Example:

<encoder class="com.github.danielwegener.logback.kafka.encoding.PatternLayoutKafkaMessageEncoder">
  <layout class="net.logstash.logback.layout.LogstashLayout" />
</encoder>

License

This project is licensed under the Apache License Version 2.0.