diff --git a/log4j-redis/pom.xml b/log4j-redis/pom.xml
new file mode 100644
index 0000000..85844eb
--- /dev/null
+++ b/log4j-redis/pom.xml
@@ -0,0 +1,176 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- ~ Licensed to the Apache Software Foundation (ASF) under one or more ~ contributor license agreements. See the NOTICE 
+  file distributed with ~ this work for additional information regarding copyright ownership. ~ The ASF licenses this file 
+  to You 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. -->
+
+<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">
+  <parent>
+    <groupId>org.apache.logging.log4j</groupId>
+    <artifactId>log4j</artifactId>
+    <version>3.0.0-SNAPSHOT</version>
+  </parent>
+  <modelVersion>4.0.0</modelVersion>
+
+  <artifactId>log4j-redis</artifactId>
+  <name>Apache Log4j Redis</name>
+  <description>
+    Apache Log4j Redis.
+  </description>
+  <properties>
+    <log4jParentDir>${basedir}/..</log4jParentDir>
+    <docLabel>Log4j Redis Documentation</docLabel>
+    <projectDir>/log4j-redis</projectDir>
+    <module.name>org.apache.logging.log4j.redis</module.name>
+  </properties>
+
+  <dependencies>
+    <dependency>
+      <groupId>org.apache.logging.log4j</groupId>
+      <artifactId>log4j-core</artifactId>
+    </dependency>
+    <!-- Used for Redis appender -->
+    <dependency>
+      <groupId>redis.clients</groupId>
+      <artifactId>jedis</artifactId>
+      <version>2.9.0</version>
+    </dependency>
+    <!-- Test Dependencies -->
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.logging.log4j</groupId>
+      <artifactId>log4j-api</artifactId>
+      <type>test-jar</type>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.logging.log4j</groupId>
+      <artifactId>log4j-core</artifactId>
+      <type>test-jar</type>
+    </dependency>
+    <!-- Mocking framework for use with JUnit -->
+    <dependency>
+      <groupId>org.mockito</groupId>
+      <artifactId>mockito-core</artifactId>
+      <scope>test</scope>
+    </dependency>
+    <!-- Required for AsyncLoggers -->
+    <dependency>
+      <groupId>com.lmax</groupId>
+      <artifactId>disruptor</artifactId>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.felix</groupId>
+        <artifactId>maven-bundle-plugin</artifactId>
+        <configuration>
+          <instructions>
+            <Fragment-Host>org.apache.logging.log4j.core.appender.mom.redis</Fragment-Host>
+            <Export-Package>*</Export-Package>
+          </instructions>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+  <reporting>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-changes-plugin</artifactId>
+        <version>${changes.plugin.version}</version>
+        <reportSets>
+          <reportSet>
+            <reports>
+              <report>changes-report</report>
+            </reports>
+          </reportSet>
+        </reportSets>
+        <configuration>
+          <issueLinkTemplate>%URL%/show_bug.cgi?id=%ISSUE%</issueLinkTemplate>
+          <useJql>true</useJql>
+        </configuration>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-checkstyle-plugin</artifactId>
+        <version>${checkstyle.plugin.version}</version>
+        <configuration>
+          <!--<propertiesLocation>${vfs.parent.dir}/checkstyle.properties</propertiesLocation> -->
+          <configLocation>${log4jParentDir}/checkstyle.xml</configLocation>
+          <suppressionsLocation>${log4jParentDir}/checkstyle-suppressions.xml</suppressionsLocation>
+          <enableRulesSummary>false</enableRulesSummary>
+          <propertyExpansion>basedir=${basedir}</propertyExpansion>
+          <propertyExpansion>licensedir=${log4jParentDir}/checkstyle-header.txt</propertyExpansion>
+        </configuration>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-javadoc-plugin</artifactId>
+        <version>${javadoc.plugin.version}</version>
+        <configuration>
+          <bottom><![CDATA[<p align="center">Copyright &#169; {inceptionYear}-{currentYear} {organizationName}. All Rights Reserved.<br />
+            Apache Logging, Apache Log4j, Log4j, Apache, the Apache feather logo, the Apache Logging project logo,
+            and the Apache Log4j logo are trademarks of The Apache Software Foundation.</p>]]></bottom>
+          <!-- module link generation is completely broken in the javadoc plugin for a multi-module non-aggregating project -->
+          <detectOfflineLinks>false</detectOfflineLinks>
+          <linksource>true</linksource>
+        </configuration>
+        <reportSets>
+          <reportSet>
+            <id>non-aggregate</id>
+            <reports>
+              <report>javadoc</report>
+            </reports>
+          </reportSet>
+        </reportSets>
+      </plugin>
+      <plugin>
+        <groupId>com.github.spotbugs</groupId>
+        <artifactId>spotbugs-maven-plugin</artifactId>
+        <configuration>
+          <fork>true</fork>
+          <jvmArgs>-Duser.language=en</jvmArgs>
+          <threshold>Normal</threshold>
+          <effort>Default</effort>
+          <excludeFilterFile>${log4jParentDir}/spotbugs-exclude-filter.xml</excludeFilterFile>
+        </configuration>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-jxr-plugin</artifactId>
+        <version>${jxr.plugin.version}</version>
+        <reportSets>
+          <reportSet>
+            <id>non-aggregate</id>
+            <reports>
+              <report>jxr</report>
+            </reports>
+          </reportSet>
+          <reportSet>
+            <id>aggregate</id>
+            <reports>
+              <report>aggregate</report>
+            </reports>
+          </reportSet>
+        </reportSets>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-pmd-plugin</artifactId>
+        <version>${pmd.plugin.version}</version>
+        <configuration>
+          <targetJdk>${maven.compiler.target}</targetJdk>
+        </configuration>
+      </plugin>
+    </plugins>
+  </reporting>
+</project>
diff --git a/log4j-redis/src/main/java/org/apache/logging/log4j/redis/appender/LoggingRedisPoolConfiguration.java b/log4j-redis/src/main/java/org/apache/logging/log4j/redis/appender/LoggingRedisPoolConfiguration.java
new file mode 100644
index 0000000..ba3deac
--- /dev/null
+++ b/log4j-redis/src/main/java/org/apache/logging/log4j/redis/appender/LoggingRedisPoolConfiguration.java
@@ -0,0 +1,148 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.apache.logging.log4j.redis.appender;
+
+import org.apache.logging.log4j.core.Core;
+import org.apache.logging.log4j.core.config.plugins.Plugin;
+import org.apache.logging.log4j.core.config.plugins.PluginBuilderAttribute;
+import org.apache.logging.log4j.core.config.plugins.PluginBuilderFactory;
+import redis.clients.jedis.JedisPoolConfig;
+
+/**
+ * Plugin configuration for {@link redis.clients.jedis.JedisPool} objects, allowing end users to set pool configuration
+ * if desired. If not set, will default to JedisPool defaults.
+ */
+@Plugin(name = "RedisPoolConfiguration", category = Core.CATEGORY_NAME, printObject = true)
+class LoggingRedisPoolConfiguration extends JedisPoolConfig {
+
+    private LoggingRedisPoolConfiguration() {
+        super();
+    }
+
+    static LoggingRedisPoolConfiguration defaultConfiguration() {
+        return LoggingRedisPoolConfiguration.newBuilder().build();
+    }
+
+    /**
+     * Creates a LoggingRedisPoolConfiguration from standard pool parameters.
+     */
+    @PluginBuilderFactory
+    public static Builder newBuilder() {
+        return new LoggingRedisPoolConfiguration.Builder();
+    }
+
+    private static class Builder implements org.apache.logging.log4j.core.util.Builder<LoggingRedisPoolConfiguration> {
+
+        @PluginBuilderAttribute("minIdle")
+        private int minIdle = JedisPoolConfig.DEFAULT_MIN_IDLE;
+
+        @PluginBuilderAttribute("maxIdle")
+        private int maxIdle = JedisPoolConfig.DEFAULT_MAX_IDLE;
+
+        @PluginBuilderAttribute("testOnBorrow")
+        private boolean testOnBorrow = JedisPoolConfig.DEFAULT_TEST_ON_BORROW;
+
+        @PluginBuilderAttribute("testOnReturn")
+        boolean testOnReturn = JedisPoolConfig.DEFAULT_TEST_ON_RETURN;
+
+        @PluginBuilderAttribute("testWhileIdle")
+        boolean testWhileIdle = JedisPoolConfig.DEFAULT_TEST_WHILE_IDLE;
+
+        @PluginBuilderAttribute("testsPerEvictionRun")
+        int testsPerEvictionRun = JedisPoolConfig.DEFAULT_NUM_TESTS_PER_EVICTION_RUN;
+
+        @PluginBuilderAttribute("timeBetweenEvictionRunsMillis")
+        long timeBetweenEvicationRunsMillis = JedisPoolConfig.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS;
+
+        @Override
+        public LoggingRedisPoolConfiguration build() {
+            LoggingRedisPoolConfiguration poolConfig = new LoggingRedisPoolConfiguration();
+            poolConfig.setMaxIdle(maxIdle);
+            poolConfig.setMinIdle(minIdle);
+            poolConfig.setTestOnBorrow(testOnBorrow);
+            poolConfig.setTestOnReturn(testOnReturn);
+            poolConfig.setTestWhileIdle(testWhileIdle);
+            poolConfig.setNumTestsPerEvictionRun(testsPerEvictionRun);
+            poolConfig.setTimeBetweenEvictionRunsMillis(timeBetweenEvicationRunsMillis);
+            return poolConfig;
+        }
+
+        public int getMinIdle() {
+            return minIdle;
+        }
+
+        public Builder setMinIdle(int minIdle) {
+            this.minIdle = minIdle;
+            return this;
+        }
+
+        public int getMaxIdle() {
+            return maxIdle;
+        }
+
+        public Builder setMaxIdle(int maxIdle) {
+            this.maxIdle = maxIdle;
+            return this;
+        }
+
+        public boolean isTestOnBorrow() {
+            return testOnBorrow;
+        }
+
+        public Builder setTestOnBorrow(boolean testOnBorrow) {
+            this.testOnBorrow = testOnBorrow;
+            return this;
+        }
+
+        public boolean isTestOnReturn() {
+            return testOnReturn;
+        }
+
+        public Builder setTestOnReturn(boolean testOnReturn) {
+            this.testOnReturn = testOnReturn;
+            return this;
+        }
+
+        public boolean isTestWhileIdle() {
+            return testWhileIdle;
+        }
+
+        public Builder setTestWhileIdle(boolean testWhileIdle) {
+            this.testWhileIdle = testWhileIdle;
+            return this;
+        }
+
+        public int getTestsPerEvictionRun() {
+            return testsPerEvictionRun;
+        }
+
+        public Builder setTestsPerEvictionRun(int testsPerEvictionRun) {
+            this.testsPerEvictionRun = testsPerEvictionRun;
+            return this;
+        }
+
+        public long getTimeBetweenEvicationRunsMillis() {
+            return timeBetweenEvicationRunsMillis;
+        }
+
+        public Builder setTimeBetweenEvicationRunsMillis(long timeBetweenEvicationRunsMillis) {
+            this.timeBetweenEvicationRunsMillis = timeBetweenEvicationRunsMillis;
+            return this;
+        }
+    }
+}
diff --git a/log4j-redis/src/main/java/org/apache/logging/log4j/redis/appender/RedisAppender.java b/log4j-redis/src/main/java/org/apache/logging/log4j/redis/appender/RedisAppender.java
new file mode 100644
index 0000000..4a19717
--- /dev/null
+++ b/log4j-redis/src/main/java/org/apache/logging/log4j/redis/appender/RedisAppender.java
@@ -0,0 +1,252 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.apache.logging.log4j.redis.appender;
+
+import org.apache.logging.log4j.LoggingException;
+import org.apache.logging.log4j.core.*;
+import org.apache.logging.log4j.core.appender.AbstractAppender;
+import org.apache.logging.log4j.core.appender.AppenderLoggingException;
+import org.apache.logging.log4j.core.config.Node;
+import org.apache.logging.log4j.core.config.plugins.Plugin;
+import org.apache.logging.log4j.core.config.plugins.PluginBuilderAttribute;
+import org.apache.logging.log4j.core.config.plugins.PluginBuilderFactory;
+import org.apache.logging.log4j.core.config.plugins.PluginElement;
+import org.apache.logging.log4j.core.config.plugins.validation.constraints.Required;
+import org.apache.logging.log4j.core.net.ssl.SslConfiguration;
+import org.apache.logging.log4j.spi.AbstractLogger;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Sends log events to a Redis key as a List. All logs are appended to Redis lists via the RPUSH command at keys defined
+ * in the configuration.
+ */
+@Plugin(name = "Redis", category = Node.CATEGORY, elementType = Appender.ELEMENT_TYPE, printObject = true)
+public final class RedisAppender extends AbstractAppender {
+
+    // The default port here is the default port for Redis generally.
+    // For more details, see the full configuration: http://download.redis.io/redis-stable/redis.conf
+    private static final int DEFAULT_REDIS_PORT = 6379;
+    private static final String DEFAULT_REDIS_KEYS = "log-events";
+    private static final int DEFAULT_APPENDER_QUEUE_CAPACITY = 20;
+
+    private final RedisManager manager;
+    private final boolean immediateFlush;
+    private final LinkedBlockingQueue<String> logQueue;
+
+    private RedisAppender(final String name, final Layout<? extends Serializable> layout, final Filter filter,
+                          final boolean ignoreExceptions, boolean immediateFlush, final int queueCapacity, final RedisManager manager) {
+        super(name, filter, layout, ignoreExceptions);
+        this.manager = Objects.requireNonNull(manager, "Redis Manager");
+        this.immediateFlush = immediateFlush;
+        this.logQueue = new LinkedBlockingQueue<>(queueCapacity);
+    }
+
+    /**
+     * Builds RedisAppender instances.
+     * @param <B> The type to build
+     */
+    public static class Builder<B extends Builder<B>> extends AbstractAppender.Builder<B>
+            implements org.apache.logging.log4j.core.util.Builder<RedisAppender> {
+
+        private final String KEY_SEPARATOR = ",";
+
+        @PluginBuilderAttribute("host")
+        @Required(message = "No Redis hostname provided")
+        private String host;
+
+        @PluginBuilderAttribute("keys")
+        private String keys = DEFAULT_REDIS_KEYS;
+
+        @PluginBuilderAttribute("port")
+        private int port = DEFAULT_REDIS_PORT;
+
+        @PluginBuilderAttribute("immediateFlush")
+        private boolean immediateFlush = true;
+
+        @PluginBuilderAttribute("queueCapacity")
+        private int queueCapacity = DEFAULT_APPENDER_QUEUE_CAPACITY;
+
+        @PluginElement("SslConfiguration")
+        private SslConfiguration sslConfiguration;
+
+        @PluginElement("RedisPoolConfiguration")
+        private LoggingRedisPoolConfiguration poolConfiguration = LoggingRedisPoolConfiguration.defaultConfiguration();
+
+        @SuppressWarnings("resource")
+        @Override
+        public RedisAppender build() {
+            return new RedisAppender(
+                    getName(),
+                    getLayout(),
+                    getFilter(),
+                    isIgnoreExceptions(),
+                    isImmediateFlush(),
+                    getQueueCapacity(),
+                    getRedisManager()
+            );
+        }
+
+        String getKeys() {
+            return keys;
+        }
+
+        String getHost() {
+            return host;
+        }
+
+        int getQueueCapacity() {
+            return queueCapacity;
+        }
+
+        boolean isImmediateFlush() {
+            return immediateFlush;
+        }
+
+        SslConfiguration getSslConfiguration() {
+            return sslConfiguration;
+        }
+
+        LoggingRedisPoolConfiguration getPoolConfiguration() {
+            return poolConfiguration;
+        }
+
+        int getPort() {
+            return port;
+        }
+
+        public B setKeys(final String keys) {
+            this.keys = keys;
+            return asBuilder();
+        }
+
+        public B setHost(final String host) {
+            this.host = host;
+            return asBuilder();
+        }
+
+        public B setPort(final int port) {
+            this.port = port;
+            return asBuilder();
+        }
+
+        public B setQueueCapacity(final int queueCapacity) {
+            this.queueCapacity = queueCapacity;
+            return asBuilder();
+        }
+
+        public B setPoolConfiguration(final LoggingRedisPoolConfiguration poolConfiguration) {
+            this.poolConfiguration = poolConfiguration;
+            return asBuilder();
+        }
+
+        public B setSslConfiguration(final SslConfiguration ssl) {
+            this.sslConfiguration = ssl;
+            return asBuilder();
+        }
+
+        public B setImmediateFlush(final boolean immediateFlush) {
+            this.immediateFlush = immediateFlush;
+            return asBuilder();
+        }
+
+        RedisManager getRedisManager() {
+            return new RedisManager(
+                    getConfiguration().getLoggerContext(),
+                    getName(),
+                    getKeys().split(KEY_SEPARATOR),
+                    getHost(),
+                    getPort(),
+                    getSslConfiguration(),
+                    getPoolConfiguration()
+            );
+        }
+    }
+
+    /**
+     * Creates a builder for a RedisAppender.
+     * @return a builder for a RedisAppender.
+     */
+    @PluginBuilderFactory
+    public static <B extends Builder<B>> B newBuilder() {
+        return new Builder<B>().asBuilder();
+    }
+
+    @Override
+    public void append(final LogEvent event) {
+        final Layout<? extends Serializable> layout = getLayout();
+        if (event.getLoggerName() != null && AbstractLogger.getRecursionDepth() > 1) {
+            LOGGER.warn("Recursive logging from [{}] for appender [{}].", event.getLoggerName(), getName());
+        } else if (layout instanceof StringLayout) {
+            String serializedEvent = ((StringLayout)layout).toSerializable(event);
+            while (!logQueue.offer(serializedEvent)) {
+                tryFlushQueue();
+            }
+            if (shouldFlushLogQueue(event.isEndOfBatch())) {
+                tryFlushQueue();
+            }
+        } else {
+            throw new AppenderLoggingException("The Redis appender only supports StringLayouts.");
+        }
+    }
+
+    private boolean shouldFlushLogQueue(boolean endOfBatch) {
+        return immediateFlush || endOfBatch;
+    }
+
+    private void tryFlushQueue() {
+        List<String> logEvents = new ArrayList<>();
+        logQueue.drainTo(logEvents);
+        manager.sendBulk(logEvents);
+    }
+
+    @Override
+    public void start() {
+        setStarting();
+        manager.startup();
+        setStarted();
+    }
+
+    @Override
+    public boolean stop(final long timeout, final TimeUnit timeUnit) {
+        setStopping();
+        if (logQueue.size() > 0) {
+            tryFlushQueue();
+        }
+        boolean stopped = super.stop(timeout, timeUnit, false);
+        stopped &= manager.stop(timeout, timeUnit);
+        setStopped();
+        return stopped;
+    }
+
+    @Override
+    public String toString() {
+        return "RedisAppender{" +
+            "name=" + getName() +
+            ", host=" + manager.getHost() +
+            ", port=" + manager.getPort() +
+            ", keys=" + manager.getKeysAsString() +
+            ", immediateFlush=" + this.immediateFlush +
+            '}';
+    }
+}
diff --git a/log4j-redis/src/main/java/org/apache/logging/log4j/redis/appender/RedisManager.java b/log4j-redis/src/main/java/org/apache/logging/log4j/redis/appender/RedisManager.java
new file mode 100644
index 0000000..84eaadc
--- /dev/null
+++ b/log4j-redis/src/main/java/org/apache/logging/log4j/redis/appender/RedisManager.java
@@ -0,0 +1,123 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.apache.logging.log4j.redis.appender;
+
+import org.apache.logging.log4j.core.LoggerContext;
+import org.apache.logging.log4j.core.appender.AbstractManager;
+import org.apache.logging.log4j.core.net.ssl.SslConfiguration;
+import redis.clients.jedis.Jedis;
+import redis.clients.jedis.JedisPool;
+import redis.clients.jedis.JedisPoolConfig;
+import redis.clients.jedis.exceptions.JedisConnectionException;
+
+import java.net.URI;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * AutoCloseable wrapper class around a Redis client connection.
+ * Enables the transport of data to Redis lists via RPUSH to preconfigured keys.
+ */
+class RedisManager extends AbstractManager {
+
+    private final String[] keys;
+    private final String host;
+    private final int port;
+    private final SslConfiguration sslConfiguration;
+    private final JedisPoolConfig poolConfiguration;
+    private JedisPool jedisPool;
+
+    RedisManager(LoggerContext loggerContext, String name, String[] keys, String host, int port,
+                 SslConfiguration sslConfiguration, LoggingRedisPoolConfiguration poolConfiguration) {
+        super(loggerContext, name);
+        this.keys = keys;
+        this.host = host;
+        this.port = port;
+        this.sslConfiguration = sslConfiguration;
+        if (poolConfiguration == null) {
+            this.poolConfiguration = LoggingRedisPoolConfiguration.defaultConfiguration();
+        } else {
+            this.poolConfiguration = poolConfiguration;
+        }
+    }
+
+    JedisPool createPool(String host, int port, SslConfiguration sslConfiguration) {
+        if (sslConfiguration != null) {
+            return new JedisPool(
+                    poolConfiguration,
+                    URI.create(host + ":" + port),
+                    sslConfiguration.getSslSocketFactory(),
+                    sslConfiguration.getSslContext().getSupportedSSLParameters(),
+                    null
+            );
+        } else {
+            return new JedisPool(poolConfiguration, host, port, false);
+        }
+
+    }
+
+    public void startup() {
+        jedisPool = createPool(host, port, sslConfiguration);
+    }
+
+    public void sendBulk(List<String> logEvents) {
+        try (Jedis jedis = jedisPool.getResource()) {
+            if (!logEvents.isEmpty()) {
+                send(jedis, logEvents.toArray(new String[0]));
+            }
+        } catch (JedisConnectionException e) {
+            LOGGER.error("Unable to connect to redis. Please ensure that it's running on {}:{}", host, port, e);
+        }
+    }
+
+    public void send(String value) {
+        try (Jedis jedis = jedisPool.getResource()) {
+            try {
+                send(jedis, value);
+            } catch (JedisConnectionException e) {
+                LOGGER.error("Unable to connect to redis. Please ensure that it's running on {}:{}", host, port, e);
+            }
+        }
+    }
+
+    private void send(Jedis jedis, String... value) {
+        for (String key: keys) {
+            jedis.rpush(key, value);
+        }
+    }
+
+    @Override
+    protected boolean releaseSub(final long timeout, final TimeUnit timeUnit) {
+        if (jedisPool != null) {
+            jedisPool.destroy();
+        }
+        return true;
+    }
+
+    String getHost() {
+        return host;
+    }
+
+    int getPort() {
+        return port;
+    }
+
+    String getKeysAsString() {
+        return String.join(",", keys);
+    }
+}
diff --git a/log4j-redis/src/site/manual/index.md b/log4j-redis/src/site/manual/index.md
new file mode 100644
index 0000000..e371232
--- /dev/null
+++ b/log4j-redis/src/site/manual/index.md
@@ -0,0 +1,29 @@
+<!-- vim: set syn=markdown : -->
+<!--
+    Licensed to the Apache Software Foundation (ASF) under one or more
+    contributor license agreements.  See the NOTICE file distributed with
+    this work for additional information regarding copyright ownership.
+    The ASF licenses this file to You 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.
+-->
+
+# Apache Log4j Redis module
+
+## Requirements
+
+Some features may require optional
+[dependencies](../runtime-dependencies.html). These dependencies are specified in the
+documentation for those features.
+
+Some Log4j features require external dependencies.
+See the [Dependency Tree](dependencies.html#Dependency_Tree)
+for the exact list of JAR files needed for these features.
diff --git a/log4j-redis/src/site/site.xml b/log4j-redis/src/site/site.xml
new file mode 100644
index 0000000..6d4cddc
--- /dev/null
+++ b/log4j-redis/src/site/site.xml
@@ -0,0 +1,52 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements.  See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You 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.
+
+-->
+<project name="Log4j Core"
+         xmlns="http://maven.apache.org/DECORATION/1.4.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/DECORATION/1.4.0 http://maven.apache.org/xsd/decoration-1.4.0.xsd">
+  <body>
+    <links>
+      <item name="Apache" href="http://www.apache.org/" />
+      <item name="Logging Services" href="http://logging.apache.org/"/>
+      <item name="Log4j" href="../index.html"/>
+    </links>
+
+    <!-- Component-specific reports -->
+    <menu ref="reports"/>
+
+	<!-- Overall Project Info -->
+    <menu name="Log4j Project Information" img="icon-info-sign">
+      <item name="Dependencies" href="../dependencies.html" />
+      <item name="Dependency Convergence" href="../dependency-convergence.html" />
+      <item name="Dependency Management" href="../dependency-management.html" />
+      <item name="Project Team" href="../team-list.html" />
+      <item name="Mailing Lists" href="../mail-lists.html" />
+      <item name="Issue Tracking" href="../issue-tracking.html" />
+      <item name="Project License" href="../license.html" />
+      <item name="Source Repository" href="../source-repository.html" />
+      <item name="Project Summary" href="../project-summary.html" />
+    </menu>
+
+    <menu name="Log4j Project Reports" img="icon-cog">
+      <item name="Changes Report" href="../changes-report.html" />
+      <item name="JIRA Report" href="../jira-report.html" />
+      <item name="Surefire Report" href="../surefire-report.html" />
+      <item name="RAT Report" href="../rat-report.html" />
+    </menu>
+  </body>
+</project>
diff --git a/log4j-redis/src/test/java/org/apache/logging/log4j/redis/appender/RedisAppenderTest.java b/log4j-redis/src/test/java/org/apache/logging/log4j/redis/appender/RedisAppenderTest.java
new file mode 100644
index 0000000..530a192
--- /dev/null
+++ b/log4j-redis/src/test/java/org/apache/logging/log4j/redis/appender/RedisAppenderTest.java
@@ -0,0 +1,192 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.apache.logging.log4j.redis.appender;
+
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.core.LifeCycle;
+import org.apache.logging.log4j.core.impl.Log4jLogEvent;
+import org.apache.logging.log4j.core.layout.PatternLayout;
+import org.apache.logging.log4j.message.SimpleMessage;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+import redis.clients.jedis.JedisPool;
+
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.Mockito.when;
+
+/**
+ * Tests {@link RedisAppender}.
+ */
+public final class RedisAppenderTest {
+
+    private RedisAppender appender;
+    private Log4jLogEvent logEvent;
+    private RedisManager manager;
+
+    private String DESTINATION_KEY = "destination";
+    private String HOST = "localhost";
+    private int PORT = 6379;
+    private String MESSAGE = "Important Message";
+
+    @Before
+    public void setUp() {
+        initMocks();
+
+        appender = new AppenderTestRedisAppenderBuilder()
+                        .withName("RedisAppender")
+                        .setKeys(DESTINATION_KEY)
+                        .setHost(HOST)
+                        .setPort(PORT)
+                        .setImmediateFlush(true)
+                        .withLayout(PatternLayout.createDefaultLayout())
+                        .build();
+        logEvent = createLogEvent();
+    }
+
+    private void initMocks() {
+        manager = Mockito.mock(RedisManager.class);
+        when(manager.createPool(HOST, PORT, null)).thenReturn(Mockito.mock(JedisPool.class));
+    }
+
+    @Test
+    public void testAppenderStartsProperly() {
+        appender.start();
+        Mockito.verify(manager, Mockito.times(1)).startup();
+        assertEquals(appender.getState(), LifeCycle.State.STARTED);
+    }
+
+    @Test
+    public void testAppenderStopsProperly() {
+        appender.stop(500, TimeUnit.HOURS);
+        Mockito.verify(manager, Mockito.times(1)).stop(500, TimeUnit.HOURS);
+        assertEquals(appender.getState(), LifeCycle.State.STOPPED);
+    }
+
+    @Test
+    public void testAppendLogEvent() {
+        appender.append(logEvent);
+        Mockito.verify(manager, Mockito.times(1)).sendBulk(any());
+    }
+
+    @Test
+    public void testQueuesLogEvents() {
+        appender = new AppenderTestRedisAppenderBuilder()
+                .withName("RedisAppender")
+                .setKeys(DESTINATION_KEY)
+                .setHost(HOST)
+                .setPort(PORT)
+                .setQueueCapacity(2)
+                .setImmediateFlush(false)
+                .withLayout(PatternLayout.newBuilder().withPattern("%m").build())
+                .build();
+
+        appender.append(logEvent);
+        Mockito.verify(manager, Mockito.times(0)).sendBulk(any());
+    }
+
+    @Test
+    public void testAttemptsSendWhenQueueReachesCapacity() {
+        appender = new AppenderTestRedisAppenderBuilder()
+                .withName("RedisAppender")
+                .setKeys(DESTINATION_KEY)
+                .setHost(HOST)
+                .setPort(PORT)
+                .setQueueCapacity(1)
+                .setImmediateFlush(false)
+                .withLayout(PatternLayout.newBuilder().withPattern("%m").build())
+                .build();
+
+        appender.append(logEvent);
+        appender.append(logEvent);
+        appender.append(logEvent);
+        Mockito.verify(manager, Mockito.times(2)).sendBulk(anyList());
+    }
+
+    @Test
+    public void testFlushesQueueAtExceededCapacity() {
+        appender = new AppenderTestRedisAppenderBuilder()
+                .withName("RedisAppender")
+                .setKeys(DESTINATION_KEY)
+                .setHost(HOST)
+                .setPort(PORT)
+                .setQueueCapacity(1)
+                .setImmediateFlush(false)
+                .withLayout(PatternLayout.newBuilder().withPattern("%m").build())
+                .build();
+
+        appender.append(logEvent);
+        appender.append(logEvent);
+        Mockito.verify(manager, Mockito.times(1)).sendBulk(any());
+    }
+
+    @Test
+    public void testFlushesQueueAtEndOfBatch() {
+        appender = new AppenderTestRedisAppenderBuilder()
+                .withName("RedisAppender")
+                .setKeys(DESTINATION_KEY)
+                .setHost(HOST)
+                .setPort(PORT)
+                .setImmediateFlush(false)
+                .withLayout(PatternLayout.newBuilder().withPattern("%m").build())
+                .build();
+        logEvent = createPartialLogEvent().setEndOfBatch(true).build();
+
+        appender.append(logEvent);
+        Mockito.verify(manager, Mockito.times(1)).sendBulk(any());
+    }
+
+    @Test
+    public void testFlushesQueueOnAppenderStop() {
+        appender = new AppenderTestRedisAppenderBuilder()
+                .withName("RedisAppender")
+                .setKeys(DESTINATION_KEY)
+                .setHost(HOST)
+                .setPort(PORT)
+                .setImmediateFlush(false)
+                .withLayout(PatternLayout.newBuilder().withPattern("%m").build())
+                .build();
+        appender.append(logEvent);
+        Mockito.verify(manager, Mockito.times(0)).sendBulk(any());
+        appender.stop(100, TimeUnit.DAYS);
+        Mockito.verify(manager, Mockito.times(1)).sendBulk(any());
+    }
+
+    private Log4jLogEvent createLogEvent() {
+        return createPartialLogEvent().build();
+    }
+
+    private Log4jLogEvent.Builder createPartialLogEvent() {
+        return Log4jLogEvent.newBuilder()
+                .setLoggerName(RedisAppenderTest.class.getName())
+                .setLoggerFqcn(RedisAppenderTest.class.getName())
+                .setLevel(Level.INFO)
+                .setMessage(new SimpleMessage(MESSAGE));
+    }
+
+    private class AppenderTestRedisAppenderBuilder extends RedisAppender.Builder<AppenderTestRedisAppenderBuilder> {
+        @Override
+        RedisManager getRedisManager() {
+            return manager;
+        }
+    }
+}
diff --git a/log4j-redis/src/test/java/org/apache/logging/log4j/redis/appender/RedisManagerTest.java b/log4j-redis/src/test/java/org/apache/logging/log4j/redis/appender/RedisManagerTest.java
new file mode 100644
index 0000000..0a68f9c
--- /dev/null
+++ b/log4j-redis/src/test/java/org/apache/logging/log4j/redis/appender/RedisManagerTest.java
@@ -0,0 +1,111 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.apache.logging.log4j.redis.appender;
+
+import org.apache.logging.log4j.core.LoggerContext;
+import org.apache.logging.log4j.core.net.ssl.SslConfiguration;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+import redis.clients.jedis.Jedis;
+import redis.clients.jedis.JedisPool;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
+
+public class RedisManagerTest {
+
+    private JedisPool mockJedisPool;
+    private Jedis mockJedis;
+    private RedisManager manager;
+
+    private String KEYS = "abc,def";
+
+    @Before
+    public void setUp() {
+        initMocks();
+        manager = new ManagerTestRedisAppenderBuilder()
+                .setHost("localhost")
+                .setPort(6379)
+                .setKeys(KEYS)
+                .getRedisManager();
+        manager.startup();
+    }
+
+    private void initMocks() {
+        mockJedisPool = Mockito.mock(JedisPool.class);
+        mockJedis = Mockito.mock(Jedis.class);
+        when(mockJedisPool.getResource()).thenReturn(mockJedis);
+        when(mockJedis.rpush(anyString(), anyString())).thenReturn(1L);
+    }
+
+    @Test
+    public void testSendsValuesToAllKeys() {
+        manager.send("value");
+        Mockito.verify(mockJedisPool).getResource();
+        Mockito.verify(mockJedis, Mockito.times(KEYS.split(",").length)).rpush(anyString(), anyString());
+        for (String k: KEYS.split(",")) {
+            Mockito.verify(mockJedis, Mockito.times(1)).rpush(eq(k), anyString());
+        }
+    }
+
+    @Test
+    public void testReleasePoolResources() {
+        manager.stop(100, TimeUnit.HOURS);
+        Mockito.verify(mockJedisPool).destroy();
+    }
+
+    @Test
+    public void testSendsAllValuesInBulk() {
+        List<String> logs = new ArrayList<>();
+        logs.add("value1");
+        logs.add("value2");
+        manager.sendBulk(logs);
+        Mockito.verify(mockJedis, Mockito.times(KEYS.split(",").length)).rpush(anyString(), eq("value1"), eq("value2"));
+    }
+
+    private class TestRedisManager extends RedisManager {
+
+        TestRedisManager(LoggerContext loggerContext, String name, String keys, String host, int port) {
+            super(loggerContext, name, keys.split(","), host, port, null, null);
+        }
+
+        @Override
+        JedisPool createPool(String host, int port, SslConfiguration ssl) {
+            return mockJedisPool;
+        }
+    }
+
+    private class ManagerTestRedisAppenderBuilder extends RedisAppender.Builder<ManagerTestRedisAppenderBuilder> {
+        @Override
+        RedisManager getRedisManager() {
+            return new TestRedisManager(
+                    LoggerContext.getContext(),
+                    getName(),
+                    getKeys(),
+                    getHost(),
+                    getPort()
+            );
+        }
+    }
+}
diff --git a/pom.xml b/pom.xml
index 04239367..55b372e 100644
--- a/pom.xml
+++ b/pom.xml
@@ -1557,6 +1557,7 @@
     <module>log4j-jeromq</module>
     <module>log4j-jms</module>
     <module>log4j-kafka</module>
+    <module>log4j-redis</module>
     <module>log4j-couchdb</module>
     <module>log4j-mongodb3</module>
     <module>log4j-mongodb4</module>
diff --git a/src/site/asciidoc/manual/appenders.adoc b/src/site/asciidoc/manual/appenders.adoc
index 9476517..5fc0bf3 100644
--- a/src/site/asciidoc/manual/appenders.adoc
+++ b/src/site/asciidoc/manual/appenders.adoc
@@ -2268,6 +2268,97 @@
 </Configuration>
 ----
 
+
+[#RedisAppender]
+== RedisAppender
+
+Log4j2 supports a RedisAppender as part of the `log4j2-redis` module. The RedisAppender logs events to a https://redis.io/[Redis] queue. Each log event is appended via the standard
+https://redis.io/commands/rpush[RPUSH] command.
+
+.RedisAppender Parameters
+[cols=",,",options="header",]
+|=======================================================================
+|Parameter Name |Type |Description
+
+|name |String |The name of the Appender. Required.
+
+|layout |Layout |The Layout to use to format the LogEvent. Required,
+there is no default. _New since 2.9, in previous versions <PatternLayout
+pattern="%m"/> was default._
+
+|filter |Filter |A Filter to determine if the event should be handled by
+this Appender. More than one Filter may be used by using a
+CompositeFilter.
+
+|host |String |The hostname on which Redis is running (required).
+
+|port |int |The port on which Redis is running. Default: 6379.
+
+|keys |String |The keys of the queue to which each log message should be sent, separated by commas (e.g. "key-one,key-two,key-three"). Default: "logEvents".
+
+|ignoreExceptions |boolean |The default is `true`, causing exceptions
+encountered while appending events to be internally logged and then
+ignored. When set to `false` exceptions will be propagated to the
+caller, instead. You must set this to `false` when wrapping this
+Appender in a link:#FailoverAppender[FailoverAppender].
+
+|immediateFlush | boolean | Whether to immediately send logs to redis rather than sending at the end of a batch. Default: true.
+
+|queueCapacity | int | The maximum number of logs to hold in memory before sending to Redis. Default: 20.
+
+|SslConfiguration |SslConfiguration |Contains the configuration for the KeyStore and
+TrustStore. See link:#SSL[SSL].
+
+|RedisPoolConfiguration |LoggingRedisPoolConfiguration |Granular configuration of the resource pool for the Redis
+client connection. Available parameters include maxIdle, minIdle, testOnBorrow, testOnReturn, testWhileIdle, numTestsPerEvictionRun, and timeBetweenEvictionRunsMillis.
+|=======================================================================
+
+Here is a sample RedisAppender configuration snippet in XML:
+
+[source,prettyprint,linenums]
+----
+<?xml version="1.0" encoding="UTF-8"?>
+  ...
+  <Appenders>
+    <Redis name"RedisAppend" host="localhost" port=6379 keys="key-one,key-two" immediateFlush=false>
+      <PatternLayout>
+        <Pattern>%m</Pattern>
+      </PatternLayout>
+    </Redis>
+    <Async name="Async">
+      <AppenderRef ref="RedisAppend"/>
+    </Async>
+  </Appenders>
+----
+You can also configure the appender easily in YML:
+[source,prettyprint,linenums]
+----
+Configuration:
+  Appenders:
+    Redis:
+      name: RedisAppend
+      host: localhost
+      port: 6379
+      Keys: key-one,key-two
+      PatternLayout:
+        pattern: "%m"
+----
+
+
+This appender operates synchronously by default and will block until the record
+has been acknowledged by the Redis server. Wrap with
+http://logging.apache.org/log4j/2.x/manual/appenders.html#AsyncAppender[Async
+appender] and/or set syncSend to `false` to log asynchronously (as in the first example above).
+
+=== Redis vs. Kafka
+
+In a logging context, Redis may play a similar role to Kafka, serving as a message broker
+in logging pipelines. In general, Redis may be preferred to Kafka in situations where
+an in-memory queue is desired. A fairly simple breakdown of the diffferent approaches can be found
+https://stackoverflow.com/questions/37990784/difference-between-redis-and-kafka[on StackOverflow here].
+
+If you prefer to use Kafka, please refer to the supported <<KafkaAppender>>.
+
 [#RewriteAppender]
 == RewriteAppender
 
diff --git a/src/site/asciidoc/runtime-dependencies.adoc b/src/site/asciidoc/runtime-dependencies.adoc
index c0407f7..e13b82c 100644
--- a/src/site/asciidoc/runtime-dependencies.adoc
+++ b/src/site/asciidoc/runtime-dependencies.adoc
@@ -172,7 +172,7 @@
 |http://lmax-exchange.github.io/disruptor/[LMAX Disruptor]
 
 |Kafka Appender
-a|http://kafka.apache.org/[Kafka client library].
+|http://kafka.apache.org/[Kafka client library].
 [NOTE]
 ====
 You need to use a version of the Kafka client library matching the Kafka server used.
@@ -200,6 +200,9 @@
 |NoSQL Appender with Apache CouchDB provider
 |LightCouch CouchDB client library and Log4j CouchDB library
 
+|Redis Appender
+|https://github.com/xetorthio/jedis[Jedis client]
+
 |Cassandra Appender
 |Datastax Cassandra driver and Log4j Cassandra library
 
diff --git a/src/site/site.xml b/src/site/site.xml
index 49437e8..48a6d3e 100644
--- a/src/site/site.xml
+++ b/src/site/site.xml
@@ -181,6 +181,7 @@
         <item name="NoSQL for CouchDB" href="/manual/appenders.html#NoSQLAppenderCouchDB"/>
         <item name="Output Stream" href="/manual/appenders.html#OutputStreamAppender"/>
         <item name="Random Access File" href="/manual/appenders.html#RandomAccessFileAppender"/>
+        <item name="Redis" href="/manual/appenders.html#RedisAppender"/>
         <item name="Rewrite" href="/manual/appenders.html#RewriteAppender"/>
         <item name="Rolling File" href="/manual/appenders.html#RollingFileAppender"/>
         <item name="Rolling Random Access File" href="/manual/appenders.html#RollingRandomAccessFileAppender"/>