On Dec 18, 2019, at 11:01 PM, Remko Popma <remko.popma@gmail.com> wrote:

I am guessing you are asking how one could go one step further and
make the actual logger implementation completely garbage-free.
For text-based loggers, one idea is to extract the text from the specified
domain Object (it may not be a CharSequence, but it may implement
some other interface that allows creating a text representation), and to
copy this text representation into a StringBuilder owned by the Logger.

The next step is to turn the text representation into bytes which can be
written to disk or sent over a network. For this, the logging
implementation needs to do some work with java.nio.CharBuffer, ByteBuffer
and CharsetEncoders (and making this thread-safe can be quite involved).

Or maybe the
StringBuilder is provided by the logging back-end and only borrowed by
the client?

That is a very good point!
(And that is one of the reasons why focusing too much on just
CharBuilder would be a mistake in my opinion.)

A SLF4J implementation could provide its own interface that applications
could implement on objects that need to be logged without allocations.
For example:

interface StringBuilderFormattable {
   /**
    * Writes a text representation of this object into the specified
    * StringBuilder, ideally without allocating temporary objects.
    *
    * @param buffer the StringBuilder to write into
    */
   void formatTo(StringBuilder buffer);
}

The SLF4J implementation detects that the logged Object implements
this interface, then calls the formatTo(StringBuilder) method on it with
the StringBuilder owned by the logger. This has the advantage that the
application no longer needs to manage any StringBuilders, and it
reduces copying between various buffers. For example: