diff --git a/assembly/src/main/resources/features.xml b/assembly/src/main/resources/features.xml
index f4889d5..24634e1 100644
--- a/assembly/src/main/resources/features.xml
+++ b/assembly/src/main/resources/features.xml
@@ -127,5 +127,11 @@
         <bundle>mvn:org.apache.karaf.cellar.http/org.apache.karaf.cellar.http.balancer/${project.version}</bundle>
     </feature>
 
+    <feature name="cellar-log" description="Cellar central log support" version="${project.version}">
+        <feature>log</feature>
+        <feature>cellar-hazelcast</feature>
+        <bundle>mvn:org.apache.karaf.cellar/org.apache.karaf.cellar.log/${project.version}</bundle>
+    </feature>
+
 </features>
 
diff --git a/assembly/src/main/resources/hazelcast.xml b/assembly/src/main/resources/hazelcast.xml
index 43634e1..eb23a04 100644
--- a/assembly/src/main/resources/hazelcast.xml
+++ b/assembly/src/main/resources/hazelcast.xml
@@ -160,6 +160,14 @@
         -->
         <hz:merge-policy>com.hazelcast.map.merge.PassThroughMergePolicy</hz:merge-policy>
     </hz:map>
+    <hz:map name="org.apache.karaf.cellar.log">
+        <hz:time-to-live-seconds>0</hz:time-to-live-seconds>
+        <hz:max-idle-seconds>0</hz:max-idle-seconds>
+        <hz:eviction-policy>LRU</hz:eviction-policy>
+        <hz:max-size policy="PER_PARTITION">5000</hz:max-size>
+        <hz:eviction-percentage>25</hz:eviction-percentage>
+        <hz:backup-count>0</hz:backup-count>
+    </hz:map>
 
     <hz:multimap name="default">
         <hz:backup-count>1</hz:backup-count>
diff --git a/log/NOTICE.txt b/log/NOTICE.txt
new file mode 100644
index 0000000..64cb235
--- /dev/null
+++ b/log/NOTICE.txt
@@ -0,0 +1,39 @@
+Apache Karaf Cellar
+Copyright 2011-2015 The Apache Software Foundation
+
+I. Used Software
+
+This product includes software developed at
+The Apache Software Foundation (http://www.apache.org/).
+Licensed under the Apache License 2.0.
+
+This product uses software developed at
+The OSGi Alliance (http://www.osgi.org/).
+Licensed under the Apache License 2.0.
+
+This product uses software developed at
+Hazelcast (http://www.hazelcast.com/).
+Licensed under the Apache License 2.0.
+
+This product uses software developed at
+OPS4J (http://www.ops4j.org/).
+Licensed under the Apache License 2.0.
+
+This product uses software developed at
+FUSE Source (http://www.fusesource.org/).
+Licensed under the Apache License 2.0.
+
+This product uses software developed at
+JClouds (http://www.jclouds.org/).
+Licensed under the Apache License 2.0.
+
+This product uses software developed at
+SLF4J (http://www.slf4j.org/).
+Licensed under the MIT License.
+
+This product includes software from http://www.json.org.
+Copyright (c) 2002 JSON.org
+
+II. License Summary
+- Apache License 2.0
+- MIT License
diff --git a/log/pom.xml b/log/pom.xml
new file mode 100644
index 0000000..1675f79
--- /dev/null
+++ b/log/pom.xml
@@ -0,0 +1,107 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<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">
+
+    <!--
+
+        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.
+    -->
+
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>org.apache.karaf</groupId>
+        <artifactId>cellar</artifactId>
+        <version>4.0.1-SNAPSHOT</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+
+    <groupId>org.apache.karaf.cellar</groupId>
+    <artifactId>org.apache.karaf.cellar.log</artifactId>
+    <packaging>bundle</packaging>
+    <name>Apache Karaf :: Cellar :: Log</name>
+
+    <dependencies>
+        <!-- Core dependencies -->
+        <dependency>
+            <groupId>org.apache.karaf.cellar</groupId>
+            <artifactId>org.apache.karaf.cellar.core</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.osgi</groupId>
+            <artifactId>org.osgi.core</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.osgi</groupId>
+            <artifactId>org.osgi.compendium</artifactId>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.ops4j.pax.logging</groupId>
+            <artifactId>pax-logging-service</artifactId>
+            <version>1.7.3</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.karaf.log</groupId>
+            <artifactId>org.apache.karaf.log.core</artifactId>
+            <version>${karaf.version}</version>
+        </dependency>
+
+        <!-- Logging dependencies -->
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.karaf.tooling</groupId>
+                <artifactId>karaf-services-maven-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.felix</groupId>
+                <artifactId>maven-bundle-plugin</artifactId>
+                <configuration>
+                    <instructions>
+                        <Export-Package>
+                            !org.apache.karaf.cellar.log.internal.osgi,
+                            !org.apache.karaf.cellar.log.management.internal,
+                            org.apache.karaf.cellar.log*
+                        </Export-Package>
+                        <Import-Package>
+                            org.slf4j;version="[1.6,2)";resolution:=optional,
+                            *
+                        </Import-Package>
+                        <Private-Package>
+                            org.apache.karaf.cellar.log.internal.osgi,
+                            org.apache.karaf.cellar.log.management.internal,
+                            org.apache.karaf.util.tracker;-split-package:=merge-first
+                        </Private-Package>
+                    </instructions>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>
\ No newline at end of file
diff --git a/log/src/main/java/org/apache/karaf/cellar/log/ClusterLogKey.java b/log/src/main/java/org/apache/karaf/cellar/log/ClusterLogKey.java
new file mode 100644
index 0000000..095655e
--- /dev/null
+++ b/log/src/main/java/org/apache/karaf/cellar/log/ClusterLogKey.java
@@ -0,0 +1,51 @@
+/*
+ * 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.karaf.cellar.log;
+
+import java.io.Serializable;
+
+public class ClusterLogKey implements Serializable {
+
+    private String nodeId;
+    private long timeStamp;
+    private String id;
+
+    public String getNodeId() {
+        return nodeId;
+    }
+
+    public void setNodeId(String nodeId) {
+        this.nodeId = nodeId;
+    }
+
+    public long getTimeStamp() {
+        return timeStamp;
+    }
+
+    public void setTimeStamp(long timeStamp) {
+        this.timeStamp = timeStamp;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+}
diff --git a/log/src/main/java/org/apache/karaf/cellar/log/ClusterLogRecord.java b/log/src/main/java/org/apache/karaf/cellar/log/ClusterLogRecord.java
new file mode 100644
index 0000000..9cca581
--- /dev/null
+++ b/log/src/main/java/org/apache/karaf/cellar/log/ClusterLogRecord.java
@@ -0,0 +1,87 @@
+/*
+ * 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.karaf.cellar.log;
+
+import java.io.Serializable;
+
+public class ClusterLogRecord implements Serializable {
+
+    private String level;
+    private String loggerName;
+    private String message;
+    private String renderedMessage;
+    private String threadName;
+    private String FQNOfLoggerClass;
+    private String[] throwableStringRep;
+
+    public String getLevel() {
+        return level;
+    }
+
+    public void setLevel(String level) {
+        this.level = level;
+    }
+
+    public String getLoggerName() {
+        return loggerName;
+    }
+
+    public void setLoggerName(String loggerName) {
+        this.loggerName = loggerName;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+
+    public String getRenderedMessage() {
+        return renderedMessage;
+    }
+
+    public void setRenderedMessage(String renderedMessage) {
+        this.renderedMessage = renderedMessage;
+    }
+
+    public String getThreadName() {
+        return threadName;
+    }
+
+    public void setThreadName(String threadName) {
+        this.threadName = threadName;
+    }
+
+    public String getFQNOfLoggerClass() {
+        return FQNOfLoggerClass;
+    }
+
+    public void setFQNOfLoggerClass(String FQNOfLoggerClass) {
+        this.FQNOfLoggerClass = FQNOfLoggerClass;
+    }
+
+    public String[] getThrowableStringRep() {
+        return throwableStringRep;
+    }
+
+    public void setThrowableStringRep(String[] throwableStringRep) {
+        this.throwableStringRep = throwableStringRep;
+    }
+
+}
diff --git a/log/src/main/java/org/apache/karaf/cellar/log/GetLogCommand.java b/log/src/main/java/org/apache/karaf/cellar/log/GetLogCommand.java
new file mode 100644
index 0000000..5aea23a
--- /dev/null
+++ b/log/src/main/java/org/apache/karaf/cellar/log/GetLogCommand.java
@@ -0,0 +1,39 @@
+/*
+ * 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.apache.karaf.cellar.log;
+
+import org.apache.karaf.cellar.core.command.Command;
+
+public class GetLogCommand extends Command<GetLogResult> {
+
+    protected String logger;
+
+    public GetLogCommand(String id) {
+        super(id);
+    }
+
+    public GetLogCommand(String id, String logger) {
+        super(id);
+        this.logger = logger;
+    }
+
+    public String getLogger() {
+        return logger;
+    }
+
+    public void setLogger(String logger) {
+        this.logger = logger;
+    }
+
+}
diff --git a/log/src/main/java/org/apache/karaf/cellar/log/GetLogCommandHandler.java b/log/src/main/java/org/apache/karaf/cellar/log/GetLogCommandHandler.java
new file mode 100644
index 0000000..98dfa57
--- /dev/null
+++ b/log/src/main/java/org/apache/karaf/cellar/log/GetLogCommandHandler.java
@@ -0,0 +1,55 @@
+/*
+ * 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.apache.karaf.cellar.log;
+
+import org.apache.karaf.cellar.core.command.CommandHandler;
+import org.apache.karaf.cellar.core.control.BasicSwitch;
+import org.apache.karaf.cellar.core.control.Switch;
+import org.apache.karaf.log.core.LogService;
+
+import java.util.Map;
+
+public class GetLogCommandHandler extends CommandHandler<GetLogCommand, GetLogResult> {
+
+    public static final String SWITCH_ID = "org.apache.karaf.cellar.log.get.switch";
+    private final Switch commandSwitch = new BasicSwitch(SWITCH_ID);
+
+    private LogService logService;
+
+    @Override
+    public GetLogResult execute(GetLogCommand command) {
+        Map<String, String> levels = logService.getLevel(command.getLogger());
+        GetLogResult result = new GetLogResult(command.getId(), levels);
+        return result;
+    }
+
+    @Override
+    public Class<GetLogCommand> getType() {
+        return GetLogCommand.class;
+    }
+
+    @Override
+    public Switch getSwitch() {
+        return commandSwitch;
+    }
+
+    public LogService getLogService() {
+        return logService;
+    }
+
+    public void setLogService(LogService logService) {
+        this.logService = logService;
+    }
+
+}
diff --git a/log/src/main/java/org/apache/karaf/cellar/log/GetLogResult.java b/log/src/main/java/org/apache/karaf/cellar/log/GetLogResult.java
new file mode 100644
index 0000000..96e570e
--- /dev/null
+++ b/log/src/main/java/org/apache/karaf/cellar/log/GetLogResult.java
@@ -0,0 +1,41 @@
+/*
+ * 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.apache.karaf.cellar.log;
+
+import org.apache.karaf.cellar.core.command.Result;
+
+import java.util.Map;
+
+public class GetLogResult extends Result {
+
+    protected Map<String, String> loggers;
+
+    public GetLogResult(String id) {
+        super(id);
+    }
+
+    public GetLogResult(String id, Map<String, String> loggers) {
+        super(id);
+        this.loggers = loggers;
+    }
+
+    public Map<String, String> getLoggers() {
+        return loggers;
+    }
+
+    public void setLoggers(Map<String, String> loggers) {
+        this.loggers = loggers;
+    }
+
+}
diff --git a/log/src/main/java/org/apache/karaf/cellar/log/GetLogResultHandler.java b/log/src/main/java/org/apache/karaf/cellar/log/GetLogResultHandler.java
new file mode 100644
index 0000000..9c73f96
--- /dev/null
+++ b/log/src/main/java/org/apache/karaf/cellar/log/GetLogResultHandler.java
@@ -0,0 +1,25 @@
+/*
+ * 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.apache.karaf.cellar.log;
+
+import org.apache.karaf.cellar.core.command.ResultHandler;
+
+public class GetLogResultHandler extends ResultHandler<GetLogResult> {
+
+    @Override
+    public Class<GetLogResult> getType() {
+        return GetLogResult.class;
+    }
+
+}
diff --git a/log/src/main/java/org/apache/karaf/cellar/log/LogAppender.java b/log/src/main/java/org/apache/karaf/cellar/log/LogAppender.java
new file mode 100644
index 0000000..8c59769
--- /dev/null
+++ b/log/src/main/java/org/apache/karaf/cellar/log/LogAppender.java
@@ -0,0 +1,66 @@
+/*
+ * 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.karaf.cellar.log;
+
+import org.apache.karaf.cellar.core.ClusterManager;
+import org.apache.karaf.cellar.core.Node;
+import org.ops4j.pax.logging.spi.PaxAppender;
+import org.ops4j.pax.logging.spi.PaxLoggingEvent;
+
+import java.util.Map;
+
+public class LogAppender implements PaxAppender {
+
+    public static final String LOG_MAP = "org.apache.karaf.cellar.log";
+
+    private ClusterManager clusterManager;
+
+    @Override
+    public void doAppend(PaxLoggingEvent event) {
+
+        Map<ClusterLogKey, ClusterLogRecord> clusterLog = clusterManager.getMap(LOG_MAP);
+
+        ClusterLogRecord record = new ClusterLogRecord();
+        ClusterLogKey key = new ClusterLogKey();
+
+        Node node = clusterManager.getNode();
+        String nodeId = node.getId();
+
+        key.setNodeId(nodeId);
+        key.setTimeStamp(event.getTimeStamp());
+        key.setId(clusterManager.generateId());
+
+        record.setFQNOfLoggerClass(event.getFQNOfLoggerClass());
+        record.setLevel(event.getLevel().toString());
+        record.setLoggerName(event.getLoggerName());
+        record.setMessage(event.getMessage());
+        record.setRenderedMessage(event.getRenderedMessage());
+        record.setThreadName(event.getThreadName());
+        record.setThrowableStringRep(event.getThrowableStrRep());
+
+        clusterLog.put(key, record);
+    }
+
+    public ClusterManager getClusterManager() {
+        return clusterManager;
+    }
+
+    public void setClusterManager(ClusterManager clusterManager) {
+        this.clusterManager = clusterManager;
+    }
+
+}
diff --git a/log/src/main/java/org/apache/karaf/cellar/log/SetLogCommand.java b/log/src/main/java/org/apache/karaf/cellar/log/SetLogCommand.java
new file mode 100644
index 0000000..6b171b2
--- /dev/null
+++ b/log/src/main/java/org/apache/karaf/cellar/log/SetLogCommand.java
@@ -0,0 +1,49 @@
+/*
+ * 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.apache.karaf.cellar.log;
+
+import org.apache.karaf.cellar.core.command.Command;
+
+public class SetLogCommand extends Command<SetLogResult> {
+
+    protected String logger;
+    protected String level;
+
+    public SetLogCommand(String id) {
+        super(id);
+    }
+
+    public SetLogCommand(String id, String logger, String level) {
+        super(id);
+        this.logger = logger;
+        this.level = level;
+    }
+
+    public String getLogger() {
+        return logger;
+    }
+
+    public void setLogger(String logger) {
+        this.logger = logger;
+    }
+
+    public String getLevel() {
+        return level;
+    }
+
+    public void setLevel(String level) {
+        this.level = level;
+    }
+
+}
diff --git a/log/src/main/java/org/apache/karaf/cellar/log/SetLogCommandHandler.java b/log/src/main/java/org/apache/karaf/cellar/log/SetLogCommandHandler.java
new file mode 100644
index 0000000..6a97ceb
--- /dev/null
+++ b/log/src/main/java/org/apache/karaf/cellar/log/SetLogCommandHandler.java
@@ -0,0 +1,55 @@
+/*
+ * 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.apache.karaf.cellar.log;
+
+import org.apache.karaf.cellar.core.command.CommandHandler;
+import org.apache.karaf.cellar.core.control.BasicSwitch;
+import org.apache.karaf.cellar.core.control.Switch;
+import org.apache.karaf.log.core.LogService;
+
+import java.util.Map;
+
+public class SetLogCommandHandler extends CommandHandler<SetLogCommand, SetLogResult> {
+
+    public static final String SWITCH_ID = "org.apache.karaf.cellar.log.set.switch";
+    private final Switch commandSwitch = new BasicSwitch(SWITCH_ID);
+
+    private LogService logService;
+
+    @Override
+    public SetLogResult execute(SetLogCommand command) {
+        logService.setLevel(command.getLogger(), command.getLevel());
+        SetLogResult result = new SetLogResult(command.getId());
+        return result;
+    }
+
+    @Override
+    public Class<SetLogCommand> getType() {
+        return SetLogCommand.class;
+    }
+
+    @Override
+    public Switch getSwitch() {
+        return commandSwitch;
+    }
+
+    public LogService getLogService() {
+        return logService;
+    }
+
+    public void setLogService(LogService logService) {
+        this.logService = logService;
+    }
+
+}
diff --git a/log/src/main/java/org/apache/karaf/cellar/log/SetLogResult.java b/log/src/main/java/org/apache/karaf/cellar/log/SetLogResult.java
new file mode 100644
index 0000000..5b49cae
--- /dev/null
+++ b/log/src/main/java/org/apache/karaf/cellar/log/SetLogResult.java
@@ -0,0 +1,24 @@
+/*
+ * 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.apache.karaf.cellar.log;
+
+import org.apache.karaf.cellar.core.command.Result;
+
+public class SetLogResult extends Result {
+
+    public SetLogResult(String id) {
+        super(id);
+    }
+
+}
diff --git a/log/src/main/java/org/apache/karaf/cellar/log/SetLogResultHandler.java b/log/src/main/java/org/apache/karaf/cellar/log/SetLogResultHandler.java
new file mode 100644
index 0000000..ebef243
--- /dev/null
+++ b/log/src/main/java/org/apache/karaf/cellar/log/SetLogResultHandler.java
@@ -0,0 +1,25 @@
+/*
+ * 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.apache.karaf.cellar.log;
+
+import org.apache.karaf.cellar.core.command.ResultHandler;
+
+public class SetLogResultHandler extends ResultHandler<SetLogResult> {
+
+    @Override
+    public Class<SetLogResult> getType() {
+        return SetLogResult.class;
+    }
+
+}
diff --git a/log/src/main/java/org/apache/karaf/cellar/log/internal/osgi/Activator.java b/log/src/main/java/org/apache/karaf/cellar/log/internal/osgi/Activator.java
new file mode 100644
index 0000000..95a0d6f
--- /dev/null
+++ b/log/src/main/java/org/apache/karaf/cellar/log/internal/osgi/Activator.java
@@ -0,0 +1,145 @@
+/*
+ * 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.apache.karaf.cellar.log.internal.osgi;
+
+import org.apache.karaf.cellar.core.ClusterManager;
+import org.apache.karaf.cellar.core.Producer;
+import org.apache.karaf.cellar.core.command.CommandStore;
+import org.apache.karaf.cellar.core.command.ExecutionContext;
+import org.apache.karaf.cellar.core.event.EventHandler;
+import org.apache.karaf.cellar.core.event.EventProducer;
+import org.apache.karaf.cellar.log.*;
+import org.apache.karaf.cellar.log.management.internal.CellarLogMBeanImpl;
+import org.apache.karaf.log.core.LogService;
+import org.apache.karaf.util.tracker.BaseActivator;
+import org.apache.karaf.util.tracker.annotation.ProvideService;
+import org.apache.karaf.util.tracker.annotation.RequireService;
+import org.apache.karaf.util.tracker.annotation.Services;
+import org.ops4j.pax.logging.spi.PaxAppender;
+import org.osgi.framework.ServiceRegistration;
+import org.osgi.service.cm.ConfigurationAdmin;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Hashtable;
+
+@Services(
+        provides = {
+                @ProvideService(PaxAppender.class),
+                @ProvideService(EventHandler.class)
+        },
+        requires = {
+                @RequireService(ClusterManager.class),
+                @RequireService(EventProducer.class),
+                @RequireService(CommandStore.class),
+                @RequireService(ExecutionContext.class),
+                @RequireService(ConfigurationAdmin.class),
+                @RequireService(LogService.class)
+        }
+)
+public class Activator extends BaseActivator {
+
+    private final static Logger LOGGER = LoggerFactory.getLogger(Activator.class);
+
+    private ServiceRegistration mbeanRegistration;
+
+    @Override
+    public void doStart() throws Exception {
+        LOGGER.debug("CELLAR LOG: retrieve cluster manager service");
+        ClusterManager clusterManager = getTrackedService(ClusterManager.class);
+        if (clusterManager == null) {
+            return;
+        }
+
+        LOGGER.debug("CELLAR LOG: retrieve producer service");
+        EventProducer producer = getTrackedService(EventProducer.class);
+        if (producer == null) {
+            return;
+        }
+
+        LOGGER.debug("CELLAR LOG: retrieve command store service");
+        CommandStore commandStore = getTrackedService(CommandStore.class);
+        if (commandStore == null) {
+            return;
+        }
+
+        LOGGER.debug("CELLAR LOG: retrieve execution context service");
+        ExecutionContext executionContext = getTrackedService(ExecutionContext.class);
+        if (executionContext == null) {
+            return;
+        }
+
+        LOGGER.debug("CELLAR LOG: retrieve configuration admin service");
+        ConfigurationAdmin configurationAdmin = getTrackedService(ConfigurationAdmin.class);
+        if (configurationAdmin == null) {
+            return;
+        }
+
+        LOGGER.debug("CELLAR LOG: retrieve log service");
+        LogService logService = getTrackedService(LogService.class);
+        if (logService == null) {
+            return;
+        }
+
+        LOGGER.debug("CELLAR LOG: init PaxAppender");
+        LogAppender paxAppender = new LogAppender();
+        paxAppender.setClusterManager(clusterManager);
+        Hashtable props = new Hashtable();
+        props.put("org.ops4j.pax.logging.appender.name", "CellarLogAppender");
+        register(PaxAppender.class, paxAppender, props);
+
+        LOGGER.debug("CELLAR LOG: register get log command handler");
+        GetLogCommandHandler getLogCommandHandler = new GetLogCommandHandler();
+        getLogCommandHandler.setProducer(producer);
+        getLogCommandHandler.setConfigurationAdmin(configurationAdmin);
+        getLogCommandHandler.setLogService(logService);
+        register(EventHandler.class, getLogCommandHandler);
+
+        LOGGER.debug("CELLAR LOG: register get log result handler");
+        GetLogResultHandler getLogResultHandler = new GetLogResultHandler();
+        getLogResultHandler.setCommandStore(commandStore);
+        register(EventHandler.class, getLogResultHandler);
+
+        LOGGER.debug("CELLAR LOG: register set log command handler");
+        SetLogCommandHandler setLogCommandHandler = new SetLogCommandHandler();
+        setLogCommandHandler.setProducer(producer);
+        setLogCommandHandler.setConfigurationAdmin(configurationAdmin);
+        setLogCommandHandler.setLogService(logService);
+        register(EventHandler.class, setLogCommandHandler);
+
+        LOGGER.debug("CELLAR LOG: register set log result handler");
+        SetLogResultHandler setLogResultHandler = new SetLogResultHandler();
+        setLogResultHandler.setCommandStore(commandStore);
+        register(EventHandler.class, setLogResultHandler);
+
+        LOGGER.debug("CELLAR LOG: registre MBean");
+        CellarLogMBeanImpl mbean = new CellarLogMBeanImpl();
+        mbean.setClusterManager(clusterManager);
+        mbean.setExecutionContext(executionContext);
+        props = new Hashtable();
+        props.put("jmx.objectname", "org.apache.karaf.cellar:type=log,name=" + System.getProperty("karaf.name"));
+        mbeanRegistration = bundleContext.registerService(getInterfaceNames(mbean), mbean, props);
+    }
+
+    @Override
+    public void doStop() {
+        super.doStop();
+
+        if (mbeanRegistration != null) {
+            mbeanRegistration.unregister();
+            mbeanRegistration = null;
+        }
+    }
+
+}
diff --git a/log/src/main/java/org/apache/karaf/cellar/log/management/CellarLogMBean.java b/log/src/main/java/org/apache/karaf/cellar/log/management/CellarLogMBean.java
new file mode 100644
index 0000000..8d6fcf2
--- /dev/null
+++ b/log/src/main/java/org/apache/karaf/cellar/log/management/CellarLogMBean.java
@@ -0,0 +1,61 @@
+/*
+ * 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.apache.karaf.cellar.log.management;
+
+import javax.management.openmbean.TabularData;
+import java.util.List;
+
+/**
+ * Describe the operations and attributes on the CellarLogMBean.
+ */
+public interface CellarLogMBean {
+
+    /**
+     * Display the cluster log messages.
+     *
+     * @param logger The logger name to filter or null.
+     * @param nodeId The node ID or alias to filter or null for all nodes.
+     * @param entries The number of entries to display limit (0 means no limit).
+     * @return The list of log messages.
+     */
+    List<String> displayLog(String logger, String nodeId, int entries);
+
+    /**
+     * Add a log message on the cluster.
+     *
+     * @param message The message to log.
+     * @param level The log message level (default is INFO when null).
+     * @param nodeId The node ID or alias or null for all nodes.
+     */
+    void logMessage(String message, String level, String nodeId);
+
+    /**
+     * Set the log level on the cluster.
+     *
+     * @param logger The logger to set the level or null for the root logger.
+     * @param level The level to set.
+     * @param nodeId The node ID or alias or null for all nodes.
+     */
+    void setLevel(String level, String logger, String nodeId) throws Exception;
+
+    /**
+     * Get the log level on the cluster.
+     *
+     * @param logger The logger to filter or null for all loggers.
+     * @param nodeId The node ID or alias or null for all nodes.
+     * @return A tabular data reprepsenting the levels.
+     */
+    TabularData getLevel(String logger, String nodeId) throws Exception;
+
+}
diff --git a/log/src/main/java/org/apache/karaf/cellar/log/management/internal/CellarLogMBeanImpl.java b/log/src/main/java/org/apache/karaf/cellar/log/management/internal/CellarLogMBeanImpl.java
new file mode 100644
index 0000000..c5c2e2a
--- /dev/null
+++ b/log/src/main/java/org/apache/karaf/cellar/log/management/internal/CellarLogMBeanImpl.java
@@ -0,0 +1,208 @@
+/*
+ * 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.apache.karaf.cellar.log.management.internal;
+
+import org.apache.karaf.cellar.core.ClusterManager;
+import org.apache.karaf.cellar.core.Node;
+import org.apache.karaf.cellar.core.command.ExecutionContext;
+import org.apache.karaf.cellar.log.*;
+import org.apache.karaf.cellar.log.management.CellarLogMBean;
+
+import javax.management.NotCompliantMBeanException;
+import javax.management.StandardMBean;
+import javax.management.openmbean.*;
+import java.text.SimpleDateFormat;
+import java.util.*;
+
+public class CellarLogMBeanImpl extends StandardMBean implements CellarLogMBean {
+
+    private ClusterManager clusterManager;
+    private ExecutionContext executionContext;
+
+    public CellarLogMBeanImpl() throws NotCompliantMBeanException {
+        super(CellarLogMBean.class);
+    }
+
+    public ClusterManager getClusterManager() {
+        return clusterManager;
+    }
+
+    public void setClusterManager(ClusterManager clusterManager) {
+        this.clusterManager = clusterManager;
+    }
+
+    public ExecutionContext getExecutionContext() {
+        return executionContext;
+    }
+
+    public void setExecutionContext(ExecutionContext executionContext) {
+        this.executionContext = executionContext;
+    }
+
+    @Override
+    public List<String> displayLog(String logger, String nodeId, int entries) {
+        List<String> result = new ArrayList<String>();
+
+        String node = null;
+        if (nodeId != null && clusterManager.findNodeByIdOrAlias(nodeId) == null) {
+            throw new IllegalArgumentException("Node " + nodeId + " doesn't exist");
+        }
+        if (nodeId != null && clusterManager.findNodeByIdOrAlias(nodeId) != null) {
+            node = clusterManager.findNodeByIdOrAlias(nodeId).getId();
+        }
+        ClassLoader originalClassLoader = Thread.currentThread().getContextClassLoader();
+        Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
+        try {
+            Map<ClusterLogKey, ClusterLogRecord> clusterLog = clusterManager.getMap(LogAppender.LOG_MAP);
+            int index = 0;
+            for (ClusterLogKey key : clusterLog.keySet()) {
+                if (entries == 0 || (entries != 0 && index < entries)) {
+                    ClusterLogRecord record = clusterLog.get(key);
+                    if (node == null || (node != null && key.getNodeId().equals(node))) {
+                        if (logger == null || (logger != null && logger.equals("ALL")) || (logger != null && record.getLoggerName() != null && record.getLoggerName().contains(logger))) {
+                            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ");
+                            String message = key.getNodeId() + " | "
+                                    + dateFormat.format(new Date(key.getTimeStamp())) + " | "
+                                    + record.getLevel() + " | "
+                                    + record.getThreadName() + " | "
+                                    + record.getLoggerName() + " | "
+                                    + record.getMessage();
+                            result.add(message);
+                            index++;
+                        }
+                    }
+                }
+            }
+        } finally {
+            Thread.currentThread().setContextClassLoader(originalClassLoader);
+        }
+
+        return result;
+    }
+
+    @Override
+    public void logMessage(String message, String nodeId, String level) {
+        if (message == null) {
+            throw new IllegalArgumentException("Message is required");
+        }
+        if (level != null && !level.equalsIgnoreCase("INFO") && !level.equalsIgnoreCase("DEBUG")
+                && !level.equalsIgnoreCase("WARN") && !level.equalsIgnoreCase("ERROR")) {
+            throw new IllegalArgumentException("Incorrect level value");
+        }
+        if (level == null) {
+            level = "INFO";
+        }
+        if (nodeId != null && clusterManager.findNodeByIdOrAlias(nodeId) == null) {
+            throw new IllegalArgumentException("Node " + nodeId + " doesn't exist");
+        }
+        long timestamp = System.currentTimeMillis();
+        String id = clusterManager.generateId();
+
+        ClusterLogKey key = new ClusterLogKey();
+        key.setNodeId(nodeId);
+        key.setTimeStamp(timestamp);
+        key.setId(id);
+
+        ClusterLogRecord record = new ClusterLogRecord();
+        record.setMessage(message);
+        record.setLevel(level);
+
+        ClassLoader originalClassLoader = Thread.currentThread().getContextClassLoader();
+        Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
+        try {
+            Map<ClusterLogKey, ClusterLogRecord> clusterLog = clusterManager.getMap(LogAppender.LOG_MAP);
+            clusterLog.put(key, record);
+        } finally {
+            Thread.currentThread().setContextClassLoader(originalClassLoader);
+        }
+    }
+
+    @Override
+    public void setLevel(String level, String logger, String nodeId) throws Exception {
+        SetLogCommand command = new SetLogCommand(clusterManager.generateId());
+        command.setTimeout(30 * 1000);
+
+        Set<Node> recipientList = new HashSet<Node>();
+        if (nodeId != null && clusterManager.findNodeByIdOrAlias(nodeId) == null) {
+            throw new IllegalArgumentException("Node " + nodeId + " doesn't exist");
+        }
+        if (nodeId == null) {
+            recipientList = clusterManager.listNodes();
+        } else {
+            recipientList.add(clusterManager.findNodeByIdOrAlias(nodeId));
+        }
+
+        if (recipientList.size() < 1)
+            throw new IllegalArgumentException("No recipient list");
+
+        command.setDestination(recipientList);
+        command.setLogger(logger);
+        command.setLevel(level);
+
+        Map<Node, SetLogResult> results = executionContext.execute(command);
+        if (results == null || results.isEmpty()) {
+            throw new IllegalStateException("No result received within given timeout");
+        }
+    }
+
+    @Override
+    public TabularData getLevel(String logger, String nodeId) throws Exception {
+        if (nodeId != null && clusterManager.findNodeByIdOrAlias(nodeId) == null) {
+            throw new IllegalArgumentException("Node " + nodeId + " doesn't exist");
+        }
+
+        Set<Node> recipientList = new HashSet<Node>();
+        if (nodeId == null) {
+            recipientList = clusterManager.listNodes();
+        } else {
+            recipientList.add(clusterManager.findNodeByIdOrAlias(nodeId));
+        }
+
+        CompositeType levelType = new CompositeType("Level", "Log Levels",
+                new String[]{ "node", "logger", "level" },
+                new String[]{ "Node ID", "Logger name", "Log level"},
+                new OpenType[]{ SimpleType.STRING, SimpleType.STRING, SimpleType.STRING });
+
+        TabularType tabularType = new TabularType("Levels", "Table of all log levels",
+                levelType, new String[]{ "node", "logger" });
+        TabularData tabularData = new TabularDataSupport(tabularType);
+
+        if (recipientList.size() < 1)
+            return null;
+
+        GetLogCommand command = new GetLogCommand(clusterManager.generateId());
+        command.setTimeout(30 * 1000);
+        command.setDestination(recipientList);
+        command.setLogger(logger);
+
+        Map<Node, GetLogResult> results = executionContext.execute(command);
+        if (results == null || results.isEmpty()) {
+            throw new IllegalStateException("No result received within given timeout");
+        } else {
+            for (Node node : results.keySet()) {
+                GetLogResult result = results.get(node);
+                Map<String, String> loggers = result.getLoggers();
+                for (String l : loggers.keySet()) {
+                    CompositeData data = new CompositeDataSupport(levelType,
+                            new String[]{ "node", "logger", "level" },
+                            new Object[]{ node.getId(), l, loggers.get(l) });
+                    tabularData.put(data);
+                }
+            }
+        }
+
+        return tabularData;
+    }
+
+}
diff --git a/log/src/main/java/org/apache/karaf/cellar/log/shell/GetLog.java b/log/src/main/java/org/apache/karaf/cellar/log/shell/GetLog.java
new file mode 100644
index 0000000..3b9129a
--- /dev/null
+++ b/log/src/main/java/org/apache/karaf/cellar/log/shell/GetLog.java
@@ -0,0 +1,112 @@
+/*
+ * 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.apache.karaf.cellar.log.shell;
+
+import org.apache.karaf.cellar.core.Node;
+import org.apache.karaf.cellar.core.command.ExecutionContext;
+import org.apache.karaf.cellar.core.shell.CellarCommandSupport;
+import org.apache.karaf.cellar.core.shell.completer.AllNodeCompleter;
+import org.apache.karaf.cellar.log.GetLogCommand;
+import org.apache.karaf.cellar.log.GetLogResult;
+import org.apache.karaf.shell.api.action.Argument;
+import org.apache.karaf.shell.api.action.Command;
+import org.apache.karaf.shell.api.action.Completion;
+import org.apache.karaf.shell.api.action.Option;
+import org.apache.karaf.shell.api.action.lifecycle.Reference;
+import org.apache.karaf.shell.api.action.lifecycle.Service;
+import org.apache.karaf.shell.support.table.ShellTable;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+@Command(scope = "cluster", name = "log-get", description = "Show the current set log loggers")
+@Service
+public class GetLog extends CellarCommandSupport {
+
+    @Argument(index = 0, name = "logger", description = "The name of the logger, ALL or ROOT (default)", required = false, multiValued = false)
+    String logger;
+
+    @Argument(index = 1, name = "node", description = "The node(s) ID or alias", required = false, multiValued = true)
+    @Completion(AllNodeCompleter.class)
+    List<String> nodes;
+
+    @Option(name = "-t", aliases = { "--timeout" }, description = "Consumer command timeout (in seconds)", required = false, multiValued = false)
+    protected long timeout = 30;
+
+    @Reference
+    protected ExecutionContext executionContext;
+
+    public ExecutionContext getExecutionContext() {
+        return executionContext;
+    }
+
+    public void setExecutionContext(ExecutionContext executionContext) {
+        this.executionContext = executionContext;
+    }
+
+    @Override
+    public Object doExecute() throws Exception {
+        GetLogCommand command = new GetLogCommand(clusterManager.generateId());
+        command.setTimeout(timeout * 1000);
+
+        ShellTable table = new ShellTable();
+        table.column(" ");
+        table.column("Node");
+        table.column("Logger");
+        table.column("Level");
+
+        Set<Node> recipientList = new HashSet<Node>();
+        if (nodes != null && !nodes.isEmpty()) {
+            for (String nodeId : nodes) {
+                Node node = clusterManager.findNodeByIdOrAlias(nodeId);
+                if (node == null) {
+                    System.err.println("Node " + nodeId + " doesn't exist");
+                } else {
+                    recipientList.add(node);
+                }
+            }
+        } else {
+            recipientList = clusterManager.listNodes();
+        }
+
+        if (recipientList.size() < 1)
+            return null;
+
+        command.setDestination(recipientList);
+        command.setLogger(logger);
+
+        Map<Node, GetLogResult> results = executionContext.execute(command);
+        if (results == null || results.isEmpty()) {
+            System.err.println("No result received within given timeout");
+        } else {
+            for (Node node : results.keySet()) {
+                String local = "";
+                if (node.equals(clusterManager.getNode()))
+                    local = "x";
+                GetLogResult result = results.get(node);
+                Map<String, String> loggers = result.getLoggers();
+                for (String logger : loggers.keySet()) {
+                    table.addRow().addContent(local, node.getId(), logger, loggers.get(logger));
+                }
+            }
+        }
+
+        table.print(System.out);
+
+        return null;
+    }
+
+}
diff --git a/log/src/main/java/org/apache/karaf/cellar/log/shell/LogClear.java b/log/src/main/java/org/apache/karaf/cellar/log/shell/LogClear.java
new file mode 100644
index 0000000..0a746c1
--- /dev/null
+++ b/log/src/main/java/org/apache/karaf/cellar/log/shell/LogClear.java
@@ -0,0 +1,63 @@
+/*
+ * 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.apache.karaf.cellar.log.shell;
+
+import org.apache.karaf.cellar.core.Node;
+import org.apache.karaf.cellar.core.shell.CellarCommandSupport;
+import org.apache.karaf.cellar.core.shell.completer.AllNodeCompleter;
+import org.apache.karaf.cellar.log.ClusterLogKey;
+import org.apache.karaf.cellar.log.ClusterLogRecord;
+import org.apache.karaf.cellar.log.LogAppender;
+import org.apache.karaf.shell.api.action.Argument;
+import org.apache.karaf.shell.api.action.Command;
+import org.apache.karaf.shell.api.action.Completion;
+import org.apache.karaf.shell.api.action.lifecycle.Service;
+
+import java.util.Map;
+
+@Command(scope = "cluster", name = "log-clear", description = "Clean the cluster log messages")
+@Service
+public class LogClear extends CellarCommandSupport {
+
+    @Argument(index = 0, name = "nodeIdOrAlias", description = "The node ID or alias", required = false, multiValued = false)
+    @Completion(AllNodeCompleter.class)
+    String nodeIdOrAlias;
+
+    @Override
+    public Object doExecute() throws Exception {
+        ClassLoader originalClassLoader = Thread.currentThread().getContextClassLoader();
+        Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
+        try {
+            Map<ClusterLogKey, ClusterLogRecord> clusterLog = clusterManager.getMap(LogAppender.LOG_MAP);
+            if (nodeIdOrAlias == null) {
+                clusterLog.clear();
+            } else {
+                Node node = clusterManager.findNodeByIdOrAlias(nodeIdOrAlias);
+                if (node == null) {
+                    System.err.println("Node " + nodeIdOrAlias + " doesn't exist");
+                    return null;
+                }
+                for (ClusterLogKey key : clusterLog.keySet()) {
+                    if (key.getNodeId().equals(node.getId())) {
+                        clusterLog.remove(key);
+                    }
+                }
+            }
+        } finally {
+            Thread.currentThread().setContextClassLoader(originalClassLoader);
+        }
+        return null;
+    }
+
+}
diff --git a/log/src/main/java/org/apache/karaf/cellar/log/shell/LogDisplay.java b/log/src/main/java/org/apache/karaf/cellar/log/shell/LogDisplay.java
new file mode 100644
index 0000000..a4bc432
--- /dev/null
+++ b/log/src/main/java/org/apache/karaf/cellar/log/shell/LogDisplay.java
@@ -0,0 +1,83 @@
+/*
+ * 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.apache.karaf.cellar.log.shell;
+
+import org.apache.karaf.cellar.core.shell.CellarCommandSupport;
+import org.apache.karaf.cellar.core.shell.completer.AllNodeCompleter;
+import org.apache.karaf.cellar.log.ClusterLogKey;
+import org.apache.karaf.cellar.log.ClusterLogRecord;
+import org.apache.karaf.cellar.log.LogAppender;
+import org.apache.karaf.shell.api.action.Argument;
+import org.apache.karaf.shell.api.action.Command;
+import org.apache.karaf.shell.api.action.Completion;
+import org.apache.karaf.shell.api.action.Option;
+import org.apache.karaf.shell.api.action.lifecycle.Service;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Map;
+
+@Command(scope = "cluster", name = "log-display", description = "Display the cluster log messages")
+@Service
+public class LogDisplay extends CellarCommandSupport {
+
+    @Argument(index = 0, name = "logger", description = "The logger name", required = false, multiValued = false)
+    String logger;
+
+    @Argument(index = 1, name = "node", description = "The node ID or alias", required = false, multiValued = false)
+    @Completion(AllNodeCompleter.class)
+    String nodeIdOrAlias;
+
+    @Option(name = "-n", description = "Number of entries to display", required = false, multiValued = false)
+    int entries;
+
+    @Override
+    public Object doExecute() throws Exception {
+        String nodeId = null;
+        if (nodeIdOrAlias != null && clusterManager.findNodeByIdOrAlias(nodeIdOrAlias) == null) {
+            System.err.println("Node " + nodeIdOrAlias + " doesn't exist");
+            return null;
+        }
+        if (nodeIdOrAlias != null && clusterManager.findNodeByIdOrAlias(nodeIdOrAlias) != null) {
+            nodeId = clusterManager.findNodeByIdOrAlias(nodeIdOrAlias).getId();
+        }
+        ClassLoader originalClassLoader = Thread.currentThread().getContextClassLoader();
+        Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
+        try {
+            Map<ClusterLogKey, ClusterLogRecord> clusterLog = clusterManager.getMap(LogAppender.LOG_MAP);
+            int index = 0;
+            for (ClusterLogKey key : clusterLog.keySet()) {
+                if (entries == 0 || (entries != 0 && index < entries)) {
+                    ClusterLogRecord record = clusterLog.get(key);
+                    if (nodeId == null || (nodeId != null && key.getNodeId().equals(nodeId))) {
+                        if (logger == null || (logger != null && logger.equals("ALL")) || (logger != null && record.getLoggerName() != null && record.getLoggerName().contains(logger))) {
+                            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ");
+                            System.out.println(key.getNodeId() + " | "
+                                    + dateFormat.format(new Date(key.getTimeStamp())) + " | "
+                                    + record.getLevel() + " | "
+                                    + record.getThreadName() + " | "
+                                    + record.getLoggerName() + " | "
+                                    + record.getMessage());
+                            index++;
+                        }
+                    }
+                }
+            }
+        } finally {
+            Thread.currentThread().setContextClassLoader(originalClassLoader);
+        }
+        return null;
+    }
+
+}
diff --git a/log/src/main/java/org/apache/karaf/cellar/log/shell/LogDisplayException.java b/log/src/main/java/org/apache/karaf/cellar/log/shell/LogDisplayException.java
new file mode 100644
index 0000000..9468c89
--- /dev/null
+++ b/log/src/main/java/org/apache/karaf/cellar/log/shell/LogDisplayException.java
@@ -0,0 +1,74 @@
+/*
+ * 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.apache.karaf.cellar.log.shell;
+
+import org.apache.karaf.cellar.core.Node;
+import org.apache.karaf.cellar.core.shell.CellarCommandSupport;
+import org.apache.karaf.cellar.core.shell.completer.AllNodeCompleter;
+import org.apache.karaf.cellar.log.ClusterLogKey;
+import org.apache.karaf.cellar.log.ClusterLogRecord;
+import org.apache.karaf.cellar.log.LogAppender;
+import org.apache.karaf.shell.api.action.Argument;
+import org.apache.karaf.shell.api.action.Command;
+import org.apache.karaf.shell.api.action.Completion;
+import org.apache.karaf.shell.api.action.lifecycle.Service;
+
+import java.util.Map;
+
+@Command(scope = "cluster", name = "log-exception-display", description = "Display the last occurred exception from the cluster log")
+@Service
+public class LogDisplayException extends CellarCommandSupport {
+
+    @Argument(index = 0, name = "logger", description = "The name of the logger. This can be ROOT, ALL, or specific logger", required = false, multiValued = false)
+    String logger;
+
+    @Argument(index = 1, name = "node", description = "The node ID or alias", required = false, multiValued = false)
+    @Completion(AllNodeCompleter.class)
+    String nodeIdOrAlias;
+
+    @Override
+    public Object doExecute() throws Exception {
+        String nodeId = null;
+        if (nodeIdOrAlias != null) {
+            Node node = clusterManager.findNodeByIdOrAlias(nodeIdOrAlias);
+            if (node == null) {
+                System.err.println("Node " + nodeIdOrAlias + " doesn't exist");
+                return null;
+            }
+            nodeId = node.getId();
+        }
+        ClassLoader originalClassLoader = Thread.currentThread().getContextClassLoader();
+        Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
+        try {
+            Map<ClusterLogKey, ClusterLogRecord> clusterLog = clusterManager.getMap(LogAppender.LOG_MAP);
+            for (ClusterLogKey key : clusterLog.keySet()) {
+                ClusterLogRecord record = clusterLog.get(key);
+                if (record.getThrowableStringRep() != null && record.getThrowableStringRep().length > 0) {
+                    if (nodeId == null || (nodeId != null && key.getNodeId().equals(nodeId))) {
+                        if (logger == null || (logger != null && record.getLoggerName().contains(logger))) {
+                            for (String throwable : record.getThrowableStringRep()) {
+                                System.out.println(throwable);
+                            }
+                            System.out.println();
+                        }
+                    }
+                }
+            }
+        } finally {
+            Thread.currentThread().setContextClassLoader(originalClassLoader);
+        }
+        return null;
+    }
+
+}
diff --git a/log/src/main/java/org/apache/karaf/cellar/log/shell/LogMessage.java b/log/src/main/java/org/apache/karaf/cellar/log/shell/LogMessage.java
new file mode 100644
index 0000000..d0cdafb
--- /dev/null
+++ b/log/src/main/java/org/apache/karaf/cellar/log/shell/LogMessage.java
@@ -0,0 +1,78 @@
+/*
+ * 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.apache.karaf.cellar.log.shell;
+
+import org.apache.karaf.cellar.core.shell.CellarCommandSupport;
+import org.apache.karaf.cellar.core.shell.completer.AllNodeCompleter;
+import org.apache.karaf.cellar.log.ClusterLogKey;
+import org.apache.karaf.cellar.log.ClusterLogRecord;
+import org.apache.karaf.cellar.log.LogAppender;
+import org.apache.karaf.shell.api.action.Argument;
+import org.apache.karaf.shell.api.action.Command;
+import org.apache.karaf.shell.api.action.Completion;
+import org.apache.karaf.shell.api.action.Option;
+import org.apache.karaf.shell.api.action.lifecycle.Service;
+import org.apache.karaf.shell.support.completers.StringsCompleter;
+
+import java.util.Map;
+
+@Command(scope = "cluster", name = "log-log", description = "Add a message in the cluster log")
+@Service
+public class LogMessage extends CellarCommandSupport {
+
+    @Argument(index = 0, name = "message", description = "The message to log", required = true, multiValued = false)
+    String message;
+
+    @Argument(index = 1, name = "node", description = "The node ID or alias", required = false, multiValued = false)
+    @Completion(AllNodeCompleter.class)
+    String nodeId;
+
+    @Option(name = "--level", aliases = { "-l" }, description = "The level the message will be logged at", required = false, multiValued = false)
+    @Completion(value = StringsCompleter.class, values = { "DEBUG", "INFO", "WARN", "ERROR" })
+    String level = "INFO";
+
+    public Object doExecute() throws Exception {
+        if (nodeId != null && clusterManager.findNodeByIdOrAlias(nodeId) == null) {
+            System.err.println("Node " + nodeId + " doesn't exist");
+            return null;
+        }
+
+        if (nodeId == null) {
+            nodeId = clusterManager.getNode().getId();
+        }
+        long timestamp = System.currentTimeMillis();
+        String id = clusterManager.generateId();
+
+        ClusterLogKey key = new ClusterLogKey();
+        key.setNodeId(nodeId);
+        key.setTimeStamp(timestamp);
+        key.setId(id);
+
+        ClusterLogRecord record = new ClusterLogRecord();
+        record.setMessage(message);
+        record.setLevel(level);
+
+        ClassLoader originalClassLoader = Thread.currentThread().getContextClassLoader();
+        Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
+        try {
+            Map<ClusterLogKey, ClusterLogRecord> clusterLog = clusterManager.getMap(LogAppender.LOG_MAP);
+            clusterLog.put(key, record);
+        } finally {
+            Thread.currentThread().setContextClassLoader(originalClassLoader);
+        }
+
+        return null;
+    }
+
+}
diff --git a/log/src/main/java/org/apache/karaf/cellar/log/shell/SetLog.java b/log/src/main/java/org/apache/karaf/cellar/log/shell/SetLog.java
new file mode 100644
index 0000000..5a5eb70
--- /dev/null
+++ b/log/src/main/java/org/apache/karaf/cellar/log/shell/SetLog.java
@@ -0,0 +1,97 @@
+/*
+ * 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.apache.karaf.cellar.log.shell;
+
+import org.apache.karaf.cellar.core.Node;
+import org.apache.karaf.cellar.core.command.ExecutionContext;
+import org.apache.karaf.cellar.core.shell.CellarCommandSupport;
+import org.apache.karaf.cellar.core.shell.completer.AllNodeCompleter;
+import org.apache.karaf.cellar.log.SetLogCommand;
+import org.apache.karaf.cellar.log.SetLogResult;
+import org.apache.karaf.shell.api.action.Argument;
+import org.apache.karaf.shell.api.action.Command;
+import org.apache.karaf.shell.api.action.Completion;
+import org.apache.karaf.shell.api.action.Option;
+import org.apache.karaf.shell.api.action.lifecycle.Reference;
+import org.apache.karaf.shell.api.action.lifecycle.Service;
+import org.apache.karaf.shell.support.completers.StringsCompleter;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+@Command(scope = "cluster", name = "log-set", description = "Set the log level")
+@Service
+public class SetLog extends CellarCommandSupport {
+
+    @Argument(index = 0, name = "level", description = "The log level to set (TRACE, DEBUG, INFO, WARN, ERROR) or DEFAULT to unset", required = true, multiValued = false)
+    @Completion(value = StringsCompleter.class, values = { "TRACE", "DEBUG", "INFO", "WARN", "ERROR", "DEFAULT" })
+    String level;
+
+    @Argument(index = 1, name = "logger", description = "Logger name or ROOT (default)", required = false, multiValued = false)
+    String logger;
+
+    @Argument(index = 2, name = "node", description = "The node(s) ID or alias", required = false, multiValued = true)
+    @Completion(AllNodeCompleter.class)
+    List<String> nodes;
+
+    @Option(name = "-t", aliases = { "--timeout" }, description = "Consumer command timeout (in seconds)", required = false, multiValued = false)
+    protected long timeout = 30;
+
+    @Reference
+    protected ExecutionContext executionContext;
+
+    public ExecutionContext getExecutionContext() {
+        return executionContext;
+    }
+
+    public void setExecutionContext(ExecutionContext executionContext) {
+        this.executionContext = executionContext;
+    }
+
+    @Override
+    public Object doExecute() throws Exception {
+        SetLogCommand command = new SetLogCommand(clusterManager.generateId());
+        command.setTimeout(timeout * 1000);
+
+        Set<Node> recipientList = new HashSet<Node>();
+        if (nodes != null && !nodes.isEmpty()) {
+            for (String nodeId : nodes) {
+                Node node = clusterManager.findNodeByIdOrAlias(nodeId);
+                if (node == null) {
+                    System.err.println("Node " + nodeId + " doesn't exist");
+                } else {
+                    recipientList.add(node);
+                }
+            }
+        } else {
+            recipientList = clusterManager.listNodes();
+        }
+
+        if (recipientList.size() < 1)
+            return null;
+
+        command.setDestination(recipientList);
+        command.setLogger(logger);
+        command.setLevel(level);
+
+        Map<Node, SetLogResult> results = executionContext.execute(command);
+        if (results == null || results.isEmpty()) {
+            System.err.println("No result received within given timeout");
+        }
+
+        return null;
+    }
+
+}
diff --git a/manual/src/main/asciidoc/index.adoc b/manual/src/main/asciidoc/index.adoc
index c8200ae..a098d79 100644
--- a/manual/src/main/asciidoc/index.adoc
+++ b/manual/src/main/asciidoc/index.adoc
@@ -40,6 +40,8 @@
 
 include::user-guide/event.adoc[]
 
+include::user-guide/log.adoc[]
+
 include::user-guide/http-balancer.adoc[]
 
 include::user-guide/http-session.adoc[]
diff --git a/manual/src/main/asciidoc/user-guide/deploy.adoc b/manual/src/main/asciidoc/user-guide/deploy.adoc
index c98be09..a04b1e2 100644
--- a/manual/src/main/asciidoc/user-guide/deploy.adoc
+++ b/manual/src/main/asciidoc/user-guide/deploy.adoc
@@ -81,4 +81,16 @@
 karaf@root()> feature:install cellar-cloud
 ----
 
+The cellar-http feature adds HTTP support:
+
+----
+karaf@root()> feature:install cellar-http
+----
+
+The cellar-log feature adds centralized log support:
+
+----
+karaf@root()> feature:install cellar-log
+----
+
 Please, see the sections dedicated to these features for details.
diff --git a/manual/src/main/asciidoc/user-guide/log.adoc b/manual/src/main/asciidoc/user-guide/log.adoc
new file mode 100644
index 0000000..06ad183
--- /dev/null
+++ b/manual/src/main/asciidoc/user-guide/log.adoc
@@ -0,0 +1,122 @@
+//
+// 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.
+//
+
+=== Centralized Log
+
+Apache Karaf Cellar is able to centralize and manage log service on each node.
+
+==== Enable Cellar log
+
+Centralized log support is an optionnal feature that you can install using:
+
+----
+karaf@root()> feature:install cellar-log
+----
+
+==== Display log messages and exceptions
+
+The `cluster:log-display` command allows you to display all log messages on the cluster or on a specific node in the
+cluster.
+
+Without argument, `cluster:log-display` command will display log messages from all nodes in the cluster:
+
+----
+karaf@node1()> cluster:log-display
+172.17.42.1:5701 | 2016-07-09T22:21:34+0200 | INFO | pool-52-thread-1 | org.apache.karaf.shell.impl.action.osgi.CommandExtension | Registering commands for bundle org.apache.karaf.cellar.log/4.0.1.SNAPSHOT
+172.17.42.1:5701 | 2016-07-09T22:21:34+0200 | INFO | pool-52-thread-1 | org.apache.karaf.features.internal.service.FeaturesServiceImpl | Done.
+----
+
+You can also specify a node (ID or alias) to display only log messages for this specific node:
+
+----
+karaf@node1()> cluster:log-display ALL 172.17.42.1:5701
+172.17.42.1:5701 | 2016-07-09T22:21:34+0200 | INFO | pool-52-thread-1 | org.apache.karaf.shell.impl.action.osgi.CommandExtension | Registering commands for bundle org.apache.karaf.cellar.log/4.0.1.SNAPSHOT
+172.17.42.1:5701 | 2016-07-09T22:21:34+0200 | INFO | pool-52-thread-1 | org.apache.karaf.features.internal.service.FeaturesServiceImpl | Done.
+----
+
+`ALL` keyword means log messages for any logger.
+
+It's also possible to display the log message only for a specific logger:
+
+----
+karaf@node1()> cluster:log-display org.apache.karaf.features
+172.17.42.1:5701 | 2016-07-09T22:21:34+0200 | INFO | pool-52-thread-1 | org.apache.karaf.features.internal.service.FeaturesServiceImpl | Done.
+----
+
+The `cluster:log-exception-display` displays the last occurred exception.
+
+Like the `cluster:log-display` command, you can also filter by logger and node.
+
+==== Log a message
+
+At any time, you can log a message of your choice using `cluster:log-log` command, from the local node and any node
+in the cluster:
+
+----
+karaf@root()> cluster:log-log "My own message"
+karaf@root()> cluster:log-log "My own message" 172.17.42.1:5701
+----
+
+==== Clear log messages
+
+The `cluster:log-clear` command cleans the log messages.
+
+Without argument, the command cleans all log messages on the cluster:
+
+----
+karaf@root()> cluster:log-clear
+----
+
+You can specify the node (ID or alias) for which we remove only the log message:
+
+----
+karaf@root()> cluster:log-clear
+----
+
+===== Get and set log levels
+
+You can change the log level for any logger on all nodes in the cluster or on a specific node using the
+`cluster:log-set` command.
+
+----
+karaf@root()> cluster:log-set DEBUG
+----
+
+You can specify the logger to change:
+
+----
+karaf@root()> cluster:log-set DEBUG org.apache.karaf.cellar
+----
+
+And you can also change on a specific node in the cluster instead of all nodes:
+
+----
+karaf@root()> cluster:log-set DEBUG ROOT 172.17.42.1:5701
+----
+
+On the other hand, you can display the current log level on all nodes, for each logger using the `cluster:log-set`
+command:
+
+----
+karaf@node1()> cluster:log-get
+Node 172.17.42.1:5701 (x)
+Logger | Level
+--------------
+ROOT   | INFO
+...
+----
+
+==== JMX MBeans
+
+All actions you can do using the shell commands can be done with the `CellarLogMBean`.
\ No newline at end of file
diff --git a/manual/src/main/asciidoc/user-guide/nodes.adoc b/manual/src/main/asciidoc/user-guide/nodes.adoc
index b0f6558..bda3b75 100644
--- a/manual/src/main/asciidoc/user-guide/nodes.adoc
+++ b/manual/src/main/asciidoc/user-guide/nodes.adoc
@@ -25,10 +25,10 @@
 
 ----
 karaf@root()> cluster:node-list
-  | Id             | Host Name | Port
--------------------------------------
-x | node2:5702     | node2 | 5702
-  | node1:5701     | node1 | 5701
+  | Id             | Alias | Host Name | Port
+----------------------------------------------
+x | node2:5702     |       | node2 | 5702
+  | node1:5701     |       | node1 | 5701
 ----
 
 The starting 'x' indicates that it's the Karaf instance on which you are logged on (the local node).
@@ -48,6 +48,9 @@
 See link:hazelcast[Core Configuration section] for details.
 ====
 
+The `cluster:node-alias` command allows you to define an alias to a node. Any Cellar command using a node as argument
+or option can use either node ID or node alias.
+
 ==== Testing nodes
 
 You can ping a node to test it:
diff --git a/pom.xml b/pom.xml
index c5c281a..f2ffabf 100644
--- a/pom.xml
+++ b/pom.xml
@@ -65,6 +65,7 @@
         <module>shell</module>
         <module>hazelcast</module>
         <module>utils</module>
+        <module>log</module>
         <module>http</module>
         <module>cloud</module>
         <module>kubernetes</module>