Class JsonBuffer

java.lang.Object
io.jstach.rainbowgum.json.JsonBuffer
All Implemented Interfaces:
LogEncoder.Buffer, AutoCloseable

public final class JsonBuffer extends Object implements LogEncoder.Buffer
A buffer designed for encoding JSON efficiently.
  • Field Details

  • Constructor Details

    • JsonBuffer

      public JsonBuffer(boolean prettyPrint, JsonBuffer.ExtendedFieldPrefix extendedFieldPrefix, int maxBufferSize)
      Create a JSON buffer.
      Parameters:
      prettyPrint - whether or not to pretty print the JSON.
      extendedFieldPrefix - prefix for extended fields.
      maxBufferSize - a negative value disables isOversized() entirely. Applied, for simplicity, as a single combined threshold across both the raw JSON byte buffer and getFormattedMessageBuilder() rather than tracked separately per buffer.
  • Method Details

    • drain

      public void drain(LogOutput output, LogEvent event)
      Description copied from interface: LogEncoder.Buffer
      The appender will call this usually within a lock to transfer content from the buffer to the output.
      Specified by:
      drain in interface LogEncoder.Buffer
      Parameters:
      output - output to receive content.
      event - log event.
    • clear

      public void clear()
      Description copied from interface: LogEncoder.Buffer
      Prepare the buffer for reuse.

      An appender may not call clear before being passed to the encoder so the encoder should do its own clearing.

      Built-in implementations also shrink their own backing storage back down here if LogEncoder.Buffer.isOversized() - see that method - so a single unusually large event does not permanently bloat a buffer that gets reused for many more events after it.

      Specified by:
      clear in interface LogEncoder.Buffer
    • isOversized

      public boolean isOversized()
      Description copied from interface: LogEncoder.Buffer
      Whether this buffer has grown large enough (its capacity, not how much of that capacity the last event actually used) that its backing storage is worth shrinking back down rather than kept at its grown size indefinitely - reused buffers only grow on their own, they never shrink back down without deliberate help. This is a soft ceiling checked between events, not a hard cap enforced during one: nothing here stops a single event from growing the buffer past whatever threshold it was configured with while that event is being encoded. Built-in implementations consult this themselves inside LogEncoder.Buffer.clear() to decide whether to shrink their own backing storage in place (e.g. StringBuilder.trimToSize(), or reallocating a smaller ByteBuffer) - most callers do not need to call this directly; it remains here mainly for tests/observability and for a custom LogEncoder.Buffer implementation that wants the same self-shrinking behavior.

      What "large enough" means, and whether it means anything at all, is entirely up to the buffer/encoder - the same way charset is an encoder concern rather than something an appender configures (see LogEncoder.builder(LogFormatter)). The default implementation returns false - a buffer implementation that does not override this, or an encoder that never configured a threshold, never shrinks.

      Specified by:
      isOversized in interface LogEncoder.Buffer
      Returns:
      true if this buffer's backing storage has grown past whatever threshold it was configured with.
    • getFormattedMessageBuilder

      Reusable String buffer for formatted messages.
      Returns:
      buffer.
    • write

      public final void write(JsonBuffer.JSONToken token)
      Writes a JSON token.
      Parameters:
      token - token not null.
    • writeLineFeed

      public final void writeLineFeed()
      Efficiently writes a line feed.
    • write

      public final int write(String k, @Nullable String v, int index)
      Writes a string field.
      Parameters:
      k - field name
      v - value
      index - the current index for comma determination
      Returns:
      index + 1
    • write

      public final int write(String k, @Nullable String v, int index, int flag)
      Writes a string field.
      Parameters:
      k - field name
      v - value
      index - the current index for comma determination
      flag - see EXTENDED_F
      Returns:
      index + 1
    • writeDouble

      public final int writeDouble(String k, double v, int index, int flag)
      Writes a double field.
      Parameters:
      k - field name
      v - value
      index - the current index for comma determination
      flag - see EXTENDED_F
      Returns:
      index + 1
    • writeInt

      public final int writeInt(String k, int v, int index, int flag)
      Writes a string field.
      Parameters:
      k - field name
      v - value
      index - the current index for comma determination
      flag - see EXTENDED_F
      Returns:
      index + 1
    • writeLong

      public final int writeLong(String k, long v, int index, int flag)
      Writes a long field.
      Parameters:
      k - field name
      v - value
      index - the current index for comma determination
      flag - see EXTENDED_F
      Returns:
      index + 1
    • writeObjectStart

      public final int writeObjectStart(String k, int index, int flag)
      Starts a nested JSON object as a field value, e.g. "key":{. Fields written after this and before the matching writeObjectEnd() should use the returned index (a fresh comma-counter local to the nested object) rather than the outer index.
      Parameters:
      k - field name
      index - the current index (of the enclosing object) for comma determination
      flag - see EXTENDED_F
      Returns:
      0, the starting index for fields inside the nested object
    • writeObjectEnd

      public final void writeObjectEnd()
      Ends a nested JSON object previously started with writeObjectStart(String, int, int).
    • writeArrayStart

      public final int writeArrayStart(String k, int index, int flag)
      Starts a nested JSON array as a field value, e.g. "key":[. Elements written after this and before the matching writeArrayEnd() should use writeArrayElementObjectStart(int) (with a fresh, local index) rather than the outer index.
      Parameters:
      k - field name
      index - the current index (of the enclosing object) for comma determination
      flag - see EXTENDED_F
      Returns:
      0, the starting index for elements inside the nested array
    • writeArrayEnd

      public final void writeArrayEnd()
      Ends a nested JSON array previously started with writeArrayStart(String, int, int).
    • writeArrayElementObjectStart

      public final int writeArrayElementObjectStart(int index)
      Starts an anonymous JSON object as an array element (no field name), e.g. the { in [{...},{...}].
      Parameters:
      index - the current index (within the array) for comma determination
      Returns:
      0, the starting index for fields inside the element object
    • writeArrayElementObjectEnd

      public final void writeArrayElementObjectEnd()
      Ends an array element object previously started with writeArrayElementObjectStart(int).