Logging With SLF4J

Logging is essential for debugging any program. There are many logging frameworks for Java, Terra uses the SLF4J API for logging.

Obtaining a Logger

Logging is done through a Logger instance. There are two main ways to obtain a Logger in a Terra addon:

Manifest Addon Loader Entry Point

If you are using a logger in an entry point of a Manifest Addon Loader addon, you can use dependency injection to obtain a Logger instance:

private Logger logger;

Using LoggerFactory

If you’re using a logger from elsewhere in your addon, you can use SLF4J’s LoggerFactory to obtain a class-specific Logger instance:

private static final Logger logger = LoggerFactory.getLogger(MyClass.class); // MyClass should be the class you're getting a logger for.


Notice that the Logger field is private static final. This is because

  • The logger instance is class-specific, not instance-specific

  • Other classes should not be accessing your logger

Using a Logger

Using a logger is very simple. Here is an example that prints a message at 4 log levels:

logger.debug("This is a message!")
logger.info("This is a message!")
logger.warn("This is a message!")
logger.error("This is a message!")

Logging Levels

SLF4J supports several logging levels. The logging level shows how important a message is, and most logging frameworks support hiding messages below a certain level.

  • The DEBUG level is the “finest” level. It is usually hidden by default, as it is meant for verbose logging that would only need to be seen for debugging.

  • The INFO level is for informative messages that would be useful for users to see. Info-level messages should not be verbose; they are generally used for coarse-grain information about the state of the program.

  • The WARNING level is for informative messages that indicate something unexpected happened, such as Deprecated API usage.

  • The ERROR level is for situations where the program has encountered an error that it can recover from, but prevents it from functioning normally.

String Formatting in SLF4J

SLF4J supports string formatting for inserting data into log messages. Here is an example of a logging statement you might find in an application:

logger.info("Got " + amount + " " + food + " from grocery store.");

This logging statement uses string concatenation to insert 2 variables into the message. This is not only more verbose code-wise, it also requires the overhead of string concatenation, which will create a performance penalty in hot code.

SLF4J contains a simple way to solve both of these issues, called string formatting:

logger.info("Got {} {} from grocery store", amount, food);

In the message, simply put {} where the variables should be inserted, then add the variables as method parameters in the order they appear in the logging message.

String formatting has 2 main advantages:

  • Less string concatenation boilerplate makes it easier to write and modify the message

  • If the message is not printed (e.g. if it’s a debug message and debugging is disabled), string concatenation is never performed!