Logging with Heka
Kolla currently uses Rsyslog for logging. And Change Request
252968  suggests to use ELK (Elasticsearch, Logstash, Kibana) as a way to index all the logs, and visualize them.
This spec suggests using Heka  instead of Logstash, while still using Elasticsearch for indexing and Kibana for visualization. It also discusses the removal of Rsyslog along the way.
What is Heka? Heka is a open-source stream processing software created and maintained by Mozilla.
Using Heka will provide a lightweight and scalable log processing solution for Kolla.
252968  adds an Ansible role named "elk" that enables deploying ELK (Elasticsearch, Logstash, Kibana) on nodes with that role. This spec builds on that work, proposing a scalable log processing architecture based on the Heka  stream processing software.
We think that Heka provides for a lightweight, flexible and powerful solution for processing data streams, including logs.
Using Heka our primary goal is distributing the logs processing load across the OpenStack nodes rather than using a centralized log processing engine that represents a bottleneck and a single-point-of-failure.
We also know from experience that Heka provides all the necessary flexibility for processing other types of data streams than log messages. For example, we already use Heka together with Elasticsearch for logs, but also with collectd and InfluxDB for statistics and metrics.
We propose to build on the ELK infrastructure brought by CR
252968 , and use Heka to collect and process logs in a distributed and scalable way.
This is the proposed architecture:
In this architecture Heka runs on every node of the OpenStack cluster. It runs in a dedicated container, referred to as the Heka container in the rest of this document.
Each Heka instance reads and processes the logs local to the node it runs on, and sends these logs to Elasticsearch for indexing. Elasticsearch may be distributed on multiple nodes for resiliency and scalability, but that part is outside the scope of that specification.
Heka, written in Go, is fast and has a small footprint, making it possible to run it on every node of the cluster. In contrast, Logstash runs in a JVM and is known  to be too heavy to run on every node.
Another important aspect is flow control and avoiding the loss of log messages in case of overload. Heka's filter and output plugins, and the Elasticsearch output plugin in particular, support the use of a disk based message queue. This message queue allows plugins to reprocess messages from the queue when downstream servers (Elasticsearch) are down or cannot keep up with the data flow.
With Logstash it is often recommended  to use Redis as a centralized queue, which introduces some complexity and other points-of-failures.
Kolla currently uses Rsyslog. The Kolla services are configured to write their logs to Syslog. Rsyslog gets the logs from the
/var/lib/kolla/dev/log Unix socket and dispatches them to log files on the local file system. Rsyslog running in a Docker container, the log files are stored in a Docker volume (named
With Rsyslog already running on each cluster node, the question of using two log processing daemons, namely
hekad, has been raised on the mailing list. The spec evaluates the possibility of using
hekad only, based on some prototyping work we have conducted .
Note: Kolla doesn't currently collect logs from RabbitMQ, HAProxy and Keepalived. For RabbitMQ the problem is related to RabbitMQ not having the capability to write its logs to Syslog. HAProxy and Keepalived do have that capability, but the
/var/lib/kolla/dev/log Unix socket file is currently not mounted into the HAProxy and Keepalived containers.
To remove Rsyslog and only use Heka one option would be to make the Kolla services write their logs to
stderr) and rely on Heka's
DockerLogInput plugin  for reading the logs. Our experiments have revealed a number of problems with this option:
DockerLogInputplugin doesn't currently work for containers that have a
ttyallocated. And Kolla currently allocates a tty for all containers (for good reasons).
DockerLogInputis used there is no way to differentiate log messages for containers producing multiple log streams.
neutron-agentsis an example of such a container. (Sam Yaple has raised that issue multiple times.)
- If Heka is stopped and restarted later then log messages will be lost, as the
DockerLogInputplugin doesn't currently have a mechanism for tracking its positions in the log streams. This is in contrast to the
LogstreamerInputplugin  which does include that mechanism.
For these reasons we think that relying on the
DockerLogInput plugin may not be a practical option.
For the note, our experiments have also shown that the OpenStack containers logs written to
stdout are visible to neither Heka nor
docker logs. This problem is not reproducible when
stderr is used rather than
stdout. The cause of this problem is currently unknown. And it looks like other people have come across that issue .
Use local log files
Another option consists of configuring all the Kolla services to log into local files, and using Heka's
LogstreamerInput plugin .
This option involves using a Docker named volume, mounted both into the service containers (in
rw mode) and into the Heka container (in
ro mode). The services write logs into files placed in that volume, and Heka reads logs from the files found in that volume.
This option doesn't present the problems described in the previous section. And it relies on Heka's
LogstreamerInput plugin, which, based on our experience, is efficient and robust.
Keeping file logs locally on the nodes has been established as a requirement by the Kolla developers. With this option, and the Docker volume used, meeting that requirement necessitates no additional mechanism.
For this option to be applicable the services must have the capability of logging into files. Most of the Kolla services have this capability. The exceptions are HAProxy and Keepalived, for which a different mechanism should be used (described further down in the document). Note that this will make it possible to collect logs from RabbitMQ, which does not support logging to Syslog but does support logging to a file.
Also, this option requires that the services have the permission to create files into the Docker volume, and that Heka has the permission to read these files. This means that the Docker named volume will have to have appropriate owner, group and permission bits. With the Heka container running under a specific user (see below) this will mean using an
extend_start.sh script including
sudo chown and possibly
sudo chmod commands. Our prototype  already includes this.
As mentioned already the
LogstreamerInput plugin includes a mechanism for tracking positions in log streams. This works with journal files stored on the file system (in
/var/cache/hekad). A specific volume, private to Heka, will be used for these journal files. In this way no logs will be lost if the Heka container is removed and a new one is created.
Handling HAProxy and Keepalived
As already mentioned HAProxy and Keepalived do not support logging to files. This means that some other mechanism should be used for these two services (and any other services that only suppport logging to Syslog).
Our prototype has demonstrated that we can make Heka act as a Syslog server. This works by using Heka's
UdpInput plugin with its
net option set to
This also requires that a Unix socket is created by Heka, and that socket is mounted into the HAProxy and Keepalived containers. For that we will use the same technique as the one currently used in Kolla with Rsyslog, that is mounting
/var/lib/kolla/dev into the Heka container and mounting
/var/lib/kolla/dev/log into the service containers.
Our prototype already includes some code demonstrating this. See .
Also, to be able to store a copy of the HAProxy and Keepalived logs locally on the node, we will use Heka's
FileOutput plugin. We will possibly create two instances of that plugin, one for HAProxy and one for Keepalived, with specific filters (
Read Python Tracebacks
In case of exceptions the OpenStack services log Python Tracebacks as multiple log messages. If no special care is taken then the Python Tracebacks will be indexed as separate documents in Elasticsearch, and displayed as distinct log entries in Kibana, making them hard to read. To address that issue we will use a custom Heka decoder, which will be responsible for coalescing the log lines making up a Python Traceback into one message. Our prototype includes that decoder .
Collect system logs
In addition to container logs we think it is important to collect system logs as well. For that we propose to mount the host's
/var/log directory into the Heka container, and configure Heka to get logs from standard log files located in that directory (e.g.
messages). The list of system log files will be determined at development time.
Log rotation is an important aspect of the logging system. Currently Kolla doesn't rotate logs. Logs just accumulate in the
rsyslog Docker volume. The work on Heka proposed in this spec isn't directly related to log rotation, but we are suggesting to address this issue for Mitaka. This will mean creating a new container that uses
logrotate to manage the log files created by the Kolla containers.
For security reasons an
heka user will be created in the Heka container and the
hekad daemon will run under that user. The
heka user will be added to the
kolla group, to make sure that Heka can read the log files created by the services.
Heka is a mature product maintained and used in production by Mozilla. So we trust Heka as being secure. We also trust the Heka developers as being serious should security vulnerabilities be found in the Heka code.
As described above we are proposing to use a Docker volume between the service containers and the Heka container. The group of the volume directory and the log files will be
kolla. And the owner of the log files will be the user that executes the service producing logs. But the
gid of the
kolla group and the
uid's of the users executing the services may correspond to a different group and different users on the host system. This means that the permissions may not be right on the host system. This problem is not specific to this specification, and it already exists in Kolla (for the mariadb data volume for example).
hekad daemon will run in a container on each cluster node. But the
rsyslogd will be removed. And we have assessed that Heka is lightweight enough to run on every node. Also, a possible option would be to constrain the Heka container to only use a defined amount of resources.
An alternative to this proposal involves using Logstash in a centralized way as done in .
Another alternative would be to execute Logstash on each cluster node, as this spec proposes with Heka. But this would mean running a JVM on each cluster node, and using Redis as a centralized queue.
Also, as described above, we initially considered relying on services writing their logs to
stdout and use Heka's
DockerLogInput plugin. But our prototyping work has demonstrated the limits of that approach. See the
DockerLogInput section above for more information.
Éric Lemoine (elemoine)
Target Milestone for completion: Mitaka 3 (March 4th, 2016).
- Create an Heka Docker image
- Create an Heka configuration for Kolla
- Develop the necessary Heka decoders (with support for Python Tracebacks)
- Create Ansible deployment files for Heka
- Modify the services' logging configuration when required
- Correctly handle RabbitMQ, HAProxy and Keepalived
- Integrate with Elastichsearch and Kibana
- Assess logs from all the Kolla services are collected
- Make the Heka container upgradable
- Integrate with kolla-mesos (will be done after Mitaka)
We will rely on the existing gate checks.
The location of log files on the host will be mentioned in the documentation.
 <https://review.opendev.org/#/c/252968/>  <http://hekad.readthedocs.org>  <http://blog.sematext.com/2015/09/28/recipe-rsyslog-redis-logstash/>  <https://review.opendev.org/#/c/269745/>  <http://hekad.readthedocs.org/en/latest/config/inputs/docker_log.html>  <http://hekad.readthedocs.org/en/latest/config/inputs/logstreamer.html>  <https://review.opendev.org/#/c/269952/>