logrotate | logrotate utility is designed to simplify

You should replace the RandomAccessFileAppender with a simple FileAppender.

Your issue is not caused by the use of asynchronous loggers, but by the appender you use:

• Java's RandomAccessFile, which is used by the RandomAccessFileAppender opens files in read/write mode without the O_APPEND option (cf. open(2)),
• FileOutputStream, which is used by the usual FileAppender, opens files in write only mode with the O_APPEND option.

The presence or the absence of this option influences how writes are performed:

O_APPEND The file is opened in append mode. Before each write(2), the file offset is positioned at the end of the file, as if with lseek(2). The modification of the file offset and the write operation are performed as a single atomic step.

(from man open(2)).

When you truncate your log file a FileAppenders offset will be reset to 0, while a RandomAccessFileAppender will continue writing at the previous position.

Remark: Log4j also provides a RollingFileAppender, which will remove the need to use logrotate at all.

Edit: the exact options used to create the objects used by the managers can be found:

• for the FileManager in FileManagerFactory#createManager,
• for the RandomAccessFileManager in RandomAccessFileManagerFactory#createManager.

It seems that Ansible Issue #902 wasn't implemented in that way.

However, as of Ansible v3.0.0, with filesize_module, a simple wrapper around dd to create, extend or truncate a file, given its size, was introduced.

It can be used to manage swap files (that require contiguous blocks) or alternatively, huge sparse files.

See filesize.py under /ansible-collections/community.general/blob/main/plugins/modules/files/ for more information.

slogger2 (and it's predecessor slogger) provide a low-latency in-memory log system. slogger2 is closer conceptually to the Linux kernel log service (eg. slog2f() is approximately equivalent to printk()), but runs as a user-space daemon independent of the kernel as QNX uses a microkernel architecture.

Like the Linux kernel log, slogger2 does not write messages to disk by itself; if you want to store messages in a file, you are required to run another process to manage that (ie. slog2info is analogous to klogd). It is possible to route syslog into slogger2, to have a single source of message traffic; it is also possible to route slogger2 to syslog, to leverage syslogd's better tools for writing files to disk.

You also need to expose the bolt port from the docker container. The default bolt port is 7687.

To fix this problem I had to migrate gitlab-secrets.json from /etc/gitlab too, because this file contains the database encryption key, CI/CD variables, and variables used for two-factor authentication.
If you fail to restore this encryption key file along with the application data backup, users with two-factor authentication enabled and GitLab Runner lose access to your GitLab server.

Problem solved.

It relied on the order in which the operations were performed. Lgrotate does a 'postrotate' section before compressing to .gz. The solution to the problem was to change the name from 'postrotate' to 'lastaction'.

You may use Socket's inet_aton

I think this is the way to get the keys of the hash sorted by the ip:

EDIT: Changed <=> in the sort to cmp as per HugoBoss's remarks below.

I think you should redefine the _sourcedir macro this way:

This is common behavior for processes that open file descriptors to write; logrotate does not deal with these open handles, as such they will 'follow' along to the newly rotated file. Hence the behavior your seeing.

I assume that you have to either reload or restart the pure-ftpd daemon itself after rotating the file, e.g. assuming systemd: