All Classes and Interfaces
Class
Description
A base class for
LoggerDecoratorService implementations that need to filter or
enrich log calls without depending on AbstractLogger's
internal dispatch, whose stack depth to the real caller is an unversioned SLF4J
implementation detail rather than something Rainbow Gum controls or tests.An abstract formatter where the actual full layout of the event is not a concern of the
user and by default usually has the semi-standard layout of TTLL - Time,
Thread, Level, Logger.
Abstract TTLL Builder.
Detects whether the current process is attached to an ANSI capable terminal so that
formatters (e.g. the pattern module's color keywords) can decide whether to emit ANSI
escape codes in the first place instead of emitting and later stripping them.
Makes avaje provide properties to RainbowGum.
API documentation marker that the enum or sealed type may add new case values on
feature release and thus external API consumers desiring backward compatibility should
have a
default case.Registers
DisruptorLogPublisher to the default
LogPublisherRegistry.ASYNC_SCHEME which makes it the default async publisher
provider.Builder to create
LogPublisher.PublisherFactory.Disruptor async publisher.
A JSON encoder in
Elastic
Common Schema (ECS) logging format.
Builder to create
EcsEncoder.Adds
Elastic
Common Schema (ECS) JSON Encoder to encoder registry with
"ecs" URI scheme.
An output that is designed for writing to a file.
Builder to create
LogProvider<FileOutput>.A logger that forwards calls to the
ForwardingLogger.delegate() logger.A JSON encoder in
GELF JSON
format.
Builder to create
GelfEncoder.JAnsi Configurator which will install JAnsi.
Jansi TTLL formater.
Jansi log formatter builder.
A buffer designed for encoding JSON efficiently.
Extended fields are just fields that have some special prefix for things like GELF
and ECS.
JSON tokens.
Will install the JUL handler if the
java.logging module is available and
is not alreadyi installed.Key Value Pairs similar to a
Map<String,String> but optimized for memory and
less garbage (no iterators).A special consumer that avoids lambda garbage.
KeyValues that can be updated.
Resolves levels from logger names.
Abstract level resolver builder.
Level resolver builder.
A special resolver that has direct mappings of logger name to level via
LevelResolver.LevelConfig.levelOrNull(String).An output for debugging.
Alerts (sometimes called errors or status events elsewhere) are for reporting problems
with the logging system itself rather than application logging - for example an
appender failing to write, or an async publisher's queue overflowing.
Notified of alerts as they happen.
Stats about alerts recorded.
What
LogLifecycle.start(LogConfig) does if, at that moment, at least one alert has been
recorded and still zero LogAlerts.Listeners are registered - the situation Logback's
StatusManager calls an unobserved status: nothing is watching, so whatever
went wrong during property loading or a
RainbowGumServiceProvider.Configurator would
otherwise only ever have reached the individual, easy to miss stderr lines each
LogAlerts.error(LogEvent) call already produces.Appenders are guaranteed to be written synchronously much like an actor in actor
concurrency.
Boolean like flags for appender that can be set with
LogAppender.APPENDER_FLAGS_PROPERTY.Provides appenders safely to the publisher.
The buffer/locking strategy an appender uses.
Builder for creating standard appenders.
A JSON encoder resembling
Logback's own
opinionated
ch.qos.logback.classic.encoder.JsonEncoder.Builder to create
LogbackJsonEncoder.Adds a Logback style
JSON encoder to encoder registry with "logback"
URI scheme.
A marker interface for custom or generated builders.
The configuration of a RainbowGum.
Builder for LogConfig.
Config Change Publisher.
Caller info levels, resolved from "logging.caller".
Changing type options.
Mixin for config support.
Used to generate Rainbow Gum config builder objects that once built will call the
method annotated with the properties from the generated builder on build.
Wall call a static method on the factory class (the class that contains the
annotated
LogConfigurable method) with the property value as a string to be
converted.Use to set static defaults to parameters.
Use as parameter to property keys with parameters.
A parameter not to be configured with properties that will just pass through to the
build method.
Encodes a
LogEvent into a buffer of its choosing.Abstract encoder that will cast the buffer to the desired implementation.
Encoders buffer.
Hints the output can pass to the encoder for creating buffers like max size and
storage style of the buffer etc.
Builds a
LogEncoder out of a LogFormatter.Finds output based on URI.
Encoder registry.
A LogEvent is a container for a single call to a logger.
Caller info usually derived from Stack walking.
A dynamic version of
LogEvent's static "of" factory methods - same
method shapes (level, message, ...), but LogEventFactory.timestamp(), LogEventFactory.threadName(),
LogEventFactory.threadId() and LogEventFactory.loggerName() are resolved through overridable methods
instead of being passed in on every call/pulled from
Instant.now()/Thread.currentThread() inline the way those static
methods do.Logs events.
Formats a log event using a
StringBuilder.Log formatter builder that is composed of other formatters.
Generic event formatting that is lambda friendly.
Controls how a
null key value is handled by formatters that print a
selected subset of keys (e.g.Formats a
System.Logger.Level.A special formatter that will do nothing.
A special formatter that will append static text.
Formats a throwable.
Builds a configurable
LogFormatter.ThrowableFormatter.Formats event timestamps.
EXPERIMENTAL: this rainbowgum service provider allows wrapping slf4j
loggers created from the logger factory.
Because wrapping can change the depth of the logger in the callstack this interface
allows implementations to change the depth of the event builder.
Because wrapping can change the depth of the logger in the callstack this interface
allows loggers to recreate themselves with the proper depth if they support it.
A component that has a start and stop.
Formats a LogEvent message.
Built-in message formatters.
Metrics are cheap, numeric counters about the logging system itself - for example how
many events an appender has dropped, or how often a reused encoder buffer had to shrink
itself back down.
A single named counter's current value, as returned by
LogMetrics.counters().The fixed, well known set of counters RainbowGum itself records - as opposed to the
open ended, per logger name counters
LogAlerts.error(LogEvent) also drives
into LogMetrics.errorCounter(String, long).A resource that can be written to usually in binary.
Abstract output on output stream.
The content type of the binary data passed to the output from an encoder.
Builtin content types.
Finds output based on URI.
Output type useful for defaults and categorization.
Marker interface that the output is thread safe.
The preferred write style of an output.
Register output providers by URI scheme.
Provides String based properties like
System.getProperty(String) for default
configuration of logging levels and output.Abstract log properties builder.
Builder for properties.
A log properties that can be mutated like a map.
Mutable Log properties builder.
Common static log properties such as System properties ane environment variables.
Describes a key (or several fallback keys) resolved against a
LogProperties
instance - start with LogProperties.forKey(String) - and also serves as the
namespace for the shared property machinery: LogProperty.Result, LogProperty.Validator, and the
property-specific exceptions.Thrown if an error happens while converting a property.
An error friendly
Function for converting properties.Throw if property is missing.
Parent interface for property exceptions.
Property helper mixin.
A result that is not missing and will either be an error or success.
The result of a property fetched from properties.
A property that was present but failed conversion.
A property that is missing (
null).A property that is present.
A
LogProperty.Result that is safe to pull a value out of - either because it can never
actually be missing (LogProperty.RequiredResult: a LogProperty.Result.Success or an
LogProperty.Result.Error, both already resolved one way or the other) or because a
caller has explicitly acknowledged the possibility of a still-LogProperty.Result.Missing
result by running it through LogProperty.Result.validate(Validator),
LogProperty.Result.validateIfError(Validator), or LogProperty.Result.validateNow(Class).Thrown by
LogProperty.Validator.validate() when one or more of the accumulated
LogProperty.Results failed, reporting every failure in a single message instead of just
the first one encountered.Accumulates
LogProperty.Results from one or more property lookups and validates them
together, so that a caller resolving several properties in sequence can report
every failure at once instead of failing fast on the first bad property.A factory that may need config to provide.
Thrown if a provider fails and a description needs to be added.
Log LogProvider Source.
Thrown if a provider could not be found for the ref.
Publishers push logs to appenders either synchronously or asynchronously.
Abstract publisher builder.
Async publisher.
Async publisher builder.
A factory for a publisher from config and appenders.
SPI for custom publishers.
Synchronous publisher.
Synchronous publisher builder.
Registry of publishers.
A container for the response of some sort of request or action.
Log component status check.
Error status.
Standard status.
Routes messages to a publisher by providing a
LogRouter.Route from a logger name and
level.A user supplied router usually for filtering or transforming purposes.
Root router is a router that has child routers.
A route is similar to a SLF4J Logger or System Logger but has a much simpler
contract.
Route singletons and utilities.
Router flags for adhoc router customization.
Router routes messages to a publisher.
Router builder.
Creates a router.
A JSON encoder in the format produced by
logstash-logback-encoder's
LogstashEncoder.Builder to create
LogstashEncoder.Adds a logstash-logback-encoder
style JSON Encoder to encoder registry with "logstash"
URI scheme.
FormattingInfo instances contain the information obtained when parsing formatting
modifiers in conversion modifiers.
Compiles a pattern into a formatter.
Builder for
PatternCompiler.Pattern Config needed for pattern keywords that is generally platform specific.
Builder to create
PatternConfig.Configures Logback style pattern encoders and offers provision with the URI scheme
"pattern".
Factory for pattern encoders.
Builder to create
LogProvider<LogEncoder>.Creates formatters from pattern keywords and are registered to a
PatternRegistry.A composite formatter factory expects possible children.
A keyword formatter factory expects keywords and option list.
A pattern keyword instance is the content of percent encoded keywords in a pattern.
Extend for a service provider that will register custom keywords.
Pattern registry to register custom keywords.
Built-in supported color pattern keys.
Built-in supported pattern keys.
Pattern keywords.
Implement this interface along with the formatter for easier registration.
Spring Boot patterns.
Writes and parses properties.
The main entry point and configuration of RainbowGum logging.
RainbowGum Builder.
Provides an Avaje logger to use RainbowGum global queue to avoid initialization issues.
RainbowGum SPI.
Called after
LogConfig has been loaded to do various custom initialization
like registering LogOutput.OutputProviders.Providers sometimes need multiple passes to support dependencies without using true
dependency injection.
Provides properties and or register services.
This is a marker interface that indicates that a facade implementation will do the
eager loading of RainbowGum.
Implement to create a custom RainbowGum.
SLF4J provider using RainbowGum.
Rainbow Gum System Logger implementation.
Abstract System Logger Finder to allow users to create their own custom
System.LoggerFinder.
Values (case is ignored) for "logging.systemlogger.initialize".
Provides the version information of Rainbow Gum as static literals.
Registers the two URI schemes
rainbowgum-file provides:
"file" (so file:///path/to/app.log resolves to a
FileOutput - core on its own has no such registration) and
"rolling" (so rolling:///path/to/app.log
resolves to a RollingFileOutput).A
FileOutput that rolls (renames the active file to a numbered archive and
starts a fresh one) once it grows past maxFileSize, retaining at most
maxHistory archives.Builder to create
LogProvider<RollingFileOutput>.A simple service locator for initialization purposes and external services provided by
plugins.
Resolves
LogProperties from up to three layers, highest priority first:
System properties
(LogProperties.StandardProperties.SYSTEM_PROPERTIES).
Environment variables, using "RAINBOWGUM_" (configurable) in
place of the "logging." lead segment of the key, remaining .s
replaced with _, and casing left exactly as-is - see
SimpleProperties.Builder.envPrefix(String).
A classpath resource (default "classpath:/logging.properties", configurable)
parsed the same way LogProperties.Builder.fromProperties(String) parses any
other properties text - if the resource is not found this layer contributes
nothing.
Create one with SimpleProperties.builder(), or just rely on SimplePropertiesProvider
picking up the defaults automatically via ServiceLoader.Builds a
SimpleProperties.Makes
SimpleProperties provide properties to RainbowGum.Provides a custom Spring Boot aware RainbowGum through
META-INF/spring.factories.A TTLL formatter that has the layout of TTLL - Time, Thread,
Level, Logger but allows changing the format of time, thread, level, logger,
etc.
Builder for
StandardEventFormatter aka TTLL formatter.A marker interface to check if it is a logger that is decorating.