Package com.pnfsoftware.jeb.util.logging

Class GlobalLog

java.lang.Object
com.pnfsoftware.jeb.util.logging.GlobalLog
public class GlobalLog extends Object
Global logging facility used by JEB. This class offers methods to create per-class loggers. Upon initialization, a JEB client should add destination streams and buffers.

Implementation note: The official RCP client implementation provided with JEB registers stdout as well as the UI console window as destinations.

This class is thread-safe. However, ILogger instances returned by getLogger() are not thread-safe.

How to use: 

 import com.pnfsoftware.jeb.util.logging.ILogger;
 import com.pnfsoftware.jeb.util.logging.GlobalLog;

 class Xyz {
     private static final ILogger logger = GlobalLog.getLogger(Xyz.class);
     ...
 }

  • Field Details

    • LEVEL_NAMES

      public static final List<String> LEVEL_NAMES
      Log level names, ordered from least to most severe regular level.

    • LEVEL_ALL

      public static final int LEVEL_ALL
      Log level allowing all messages.
      See Also:

    • LEVEL_DISABLED

      public static final int LEVEL_DISABLED
      Log level disabling regular messages.
      See Also:

    • LEVEL_ALWAYS_ON

      public static final int LEVEL_ALWAYS_ON
      Threshold for messages that bypass regular level filtering.
      See Also:

    • LEVEL_TRACE

      public static final int LEVEL_TRACE
      Trace log level.
      See Also:

    • LEVEL_DEBUG

      public static final int LEVEL_DEBUG
      Debug log level.
      See Also:

    • LEVEL_INFO

      public static final int LEVEL_INFO
      Information log level.
      See Also:

    • LEVEL_WARN

      public static final int LEVEL_WARN
      Warning log level.
      See Also:

    • LEVEL_ERROR

      public static final int LEVEL_ERROR
      Error log level.
      See Also:

    • LEVEL_INTERNAL

      public static final int LEVEL_INTERNAL
      Reserved for internal use
      See Also:

    • LEVEL_CATCHING

      public static final int LEVEL_CATCHING
      Special level used to log exception related data such as stack traces. Messages above or equal to this level are never neutered. Eg, disabling a logger will not disable CATCHING messages to go through.
      See Also:

    • LEVEL_STATUS

      public static final int LEVEL_STATUS
      special log level indicating a status message; logs with that status will not be directed to the regular sinks
      See Also:

    • STANDARD_CUTOFF_LEVEL

      public static final int STANDARD_CUTOFF_LEVEL
      Standard global cutoff level for the current build type.

    • prefixWithLevel

      public static boolean prefixWithLevel
      True to prefix regular log messages with their level letter.

  • Constructor Details

    • GlobalLog

      public GlobalLog()

  • Method Details

    • addDestinationStream

      public static StreamSink addDestinationStream(OutputStream out)
      Add a destination stream to the list of log message recipients.
      Parameters:
      out - a destination stream
      Returns:
      the sink

    • removeDestinationStream

      public static StreamSink removeDestinationStream(OutputStream out)
      Remove a destination stream.
      Parameters:
      out - the destination stream
      Returns:
      the sink

    • getDestinationStreams

      public static List<StreamSink> getDestinationStreams()
      Get the list of registered stream sinks.
      Returns:
      the list of stream sinks

    • addDestinationBuffer

      public static BufferSink addDestinationBuffer(List<CharSequence> buffer)
      Add a destination buffer to the list of log message recipients. The list implementation must be thread-safe: it should be an object returned by Collections.synchronizedList()
      Parameters:
      buffer - the thread-safe buffer
      Returns:
      the sink

    • removeDestinationBuffer

      public static BufferSink removeDestinationBuffer(List<CharSequence> buffer)
      Remove a destination buffer.
      Parameters:
      buffer - the destination buffer
      Returns:
      the sink

    • getDestinationBuffers

      public static List<BufferSink> getDestinationBuffers()
      Get the list of registered buffer sinks.
      Returns:
      the list of buffer sinks

    • getRegularSinks

      public static List<Sink<?>> getRegularSinks()
      Get a list of the regular (= non status) sinks.
      Returns:
      a new list containing all regular sinks

    • addStatusSink

      public static void addStatusSink(LogStatusSink sink)
      Register a status sink. Those sinks receive only logs having the special level LEVEL_STATUS.
      Parameters:
      sink - status sink to add

    • removeStatusSink

      public static void removeStatusSink(LogStatusSink sink)
      Unregister a status sink.
      Parameters:
      sink - status sink to remove

    • getStatusSinks

      public static List<LogStatusSink> getStatusSinks()
      Get the registered status sinks.
      Returns:
      the list of status sinks

    • setCutoffLevel

      public static int setCutoffLevel(int cutoffLevel)
      Set the global cutoff level.
      Parameters:
      cutoffLevel - new level
      Returns:
      the previous level

    • getCutoffLevel

      public static int getCutoffLevel()
      Get the global cutoff level.
      Returns:
      the global cutoff level

    • setLevelForNewLoggers

      public static int setLevelForNewLoggers(int level)
      Set the default logging level.
      Parameters:
      level - the default logging level
      Returns:
      the previous default logging level

    • setLevelForNewLoggers

      public static int setLevelForNewLoggers(int level, boolean updateExistingLoggers)
      Set the default logging level for newly created loggers.
      Parameters:
      level - the default logging level
      updateExistingLoggers - true to update already-created loggers as well
      Returns:
      the previous default logging level

    • setGlobalFilter

      public static void setGlobalFilter(boolean mute)
      Enable or disable a global mute filter.
      Parameters:
      mute - true to mute all regular loggers

    • addGlobalFilter

      public static void addGlobalFilter(String pattern, int requiredLevel)
      Add or replace a global filter.
      Parameters:
      pattern - logger name or package prefix to filter; empty string matches all loggers
      requiredLevel - minimum level required for matching loggers

    • removeGlobalFilter

      public static void removeGlobalFilter(String pattern)
      Remove a global filter.
      Parameters:
      pattern - logger name or package prefix

    • clearGlobalFilters

      public static void clearGlobalFilters()
      Remove all global filters.

    • isGloballyDisabled

      @Deprecated public static boolean isGloballyDisabled(ILogger logger)
      Deprecated.
      use isFilteredOut(ILogger, int) instead

    • isFilteredOut

      public static boolean isFilteredOut(ILogger logger, int messageLevel)
      Determine whether a message at a given level sent to a logger should be processed or ignored, based on global filters.
      Parameters:
      logger - the logger
      messageLevel - the level of the message we want to verify
      Returns:
      true if the message should be ignored

    • getEnabledLevel

      public static int getEnabledLevel()
      Get the default logging level.
      Returns:
      the default logging level

    • getLogger

      public static ILogger getLogger()
      Create or retrieve the anonymous logger. If created, the logging level is set to the default global logging level.
      Returns:
      the anonymous logger

    • status

      public static void status(String format, Object... params)
      Convenience method for getLogger().status(...).
      Parameters:
      format - format string if parameters are provided, else standard string
      params - parameters

    • getLogger

      public static ILogger getLogger(Class<?> clazz)
      Create or retrieve a logger attached to and named after a given class. If created, the logging level is set to the default global logging level.
      Parameters:
      clazz - class reference
      Returns:
      the logger

    • getLogger

      public static ILogger getLogger(Class<?> clazz, int level)
      Create or retrieve a logger attached to and named after a given class.
      Parameters:
      clazz - class reference
      level - the cut-off level
      Returns:
      the logger

    • getLogger

      public static ILogger getLogger(String name, int level)
      Create or retrieve a named logger.
      Parameters:
      name - logger name
      level - the cut-off level
      Returns:
      the logger

    • getInternalLogger

      public static ILogger getInternalLogger(Class<?> clazz)
      Create or retrieve an internal logger. INTERNAL USAGE ONLY.
      Parameters:
      clazz - class reference
      Returns:
      the internal logger

    • catching

      public static void catching(ILogger logger, Throwable t)
      Log an exception's stack trace.
      Parameters:
      logger - destination logger
      t - throwable to log

    • catching

      public static void catching(ILogger logger, Throwable t, String message)
      Log an exception's stack trace with an optional message.
      Parameters:
      logger - destination logger
      t - throwable to log
      message - optional message prefix

    • catchingDebug

      public static void catchingDebug(ILogger logger, Throwable t)
      Log an exception's stack trace at debug level.
      Parameters:
      logger - destination logger
      t - throwable to log

    • catchingDebug

      public static void catchingDebug(ILogger logger, Throwable t, String message)
      Log an exception's stack trace at debug level with an optional message.
      Parameters:
      logger - destination logger
      t - throwable to log
      message - optional message prefix

    • parseLevel

      public static int parseLevel(String s)
      Parse a log level name (or number) to a log level integer usable by Logger objects. On error, this method returns a negative value. Negative values are illegal log levels.
      Parameters:
      s - a log level name or integer as a string
      Returns:
      integer log level, a negative value on error

    • levelToString

      public static String levelToString(int level)
      Convert a log level to a display string.
      Parameters:
      level - log level
      Returns:
      a level name

    • getPrefixLetterForLevel

      public static char getPrefixLetterForLevel(int level)
      Retrieve the prefix letter associated to the provided log level.
      Parameters:
      level - log level
      Returns:
      a letter describing the level; 0 on failure

    • getLevelFromPrefixLetter

      public static int getLevelFromPrefixLetter(char ch)
      Retrieve the log level associated to the provided prefix letter.
      Parameters:
      ch - prefix letter
      Returns:
      log level matching the prefix character; negative value on error