Class Logger

java.lang.Object
java.util.logging.Logger
org.jboss.logmanager.Logger
All Implemented Interfaces:
Serializable
public final class Logger extends Logger implements Serializable
An actual logger instance. This is the end-user interface into the logging system.
See Also:

  • Field Details

    • serialVersionUID

      private static final long serialVersionUID
      See Also:

    • loggerNode

      private final LoggerNode loggerNode
      The named logger tree node.

    • LOGGER_CLASS_NAME

      private static final String LOGGER_CLASS_NAME

    • OFF_INT

      static final int OFF_INT

    • SEVERE_INT

      static final int SEVERE_INT

    • WARNING_INT

      static final int WARNING_INT

    • INFO_INT

      static final int INFO_INT

    • CONFIG_INT

      static final int CONFIG_INT

    • FINE_INT

      static final int FINE_INT

    • FINER_INT

      static final int FINER_INT

    • FINEST_INT

      static final int FINEST_INT

  • Constructor Details

    • Logger

      Logger(LoggerNode loggerNode, String name)
      Construct a new instance of an actual logger.
      Parameters:
      loggerNode - the node in the named logger tree
      name - the fully-qualified name of this node

  • Method Details

    • getLogger

      public static Logger getLogger(String name)
      Static logger factory method which returns a JBoss LogManager logger.
      Parameters:
      name - the logger name
      Returns:
      the logger

    • getLogger

      public static Logger getLogger(String name, String bundleName)
      Static logger factory method which returns a JBoss LogManager logger.
      Parameters:
      name - the logger name
      bundleName - the bundle name
      Returns:
      the logger

    • writeReplace

      protected final Object writeReplace() throws ObjectStreamException
      Throws:
      ObjectStreamException

    • setFilter

      public void setFilter(Filter filter) throws SecurityException
      Overrides:
      setFilter in class Logger
      Throws:
      SecurityException

    • getFilter

      public Filter getFilter()
      Overrides:
      getFilter in class Logger

    • setLevel

      public void setLevel(Level newLevel) throws SecurityException
      This implementation grabs a lock, so that only one thread may update the log level of any logger at a time, in order to allow readers to never block (though there is a window where retrieving the log level reflects an older effective level than the actual level).
      Overrides:
      setLevel in class Logger
      Throws:
      SecurityException

    • setLevelName

      public void setLevelName(String newLevelName) throws SecurityException
      Set the log level by name. Uses the parent logging context's name registry; otherwise behaves identically to setLevel(Level).
      Parameters:
      newLevelName - the name of the level to set
      Throws:
      SecurityException - if a security manager exists and if the caller does not have LoggingPermission("control")

    • getEffectiveLevel

      public int getEffectiveLevel()
      Get the effective numerical log level, inherited from the parent.
      Returns:
      the effective level

    • getLevel

      public Level getLevel()
      Overrides:
      getLevel in class Logger

    • isLoggable

      public boolean isLoggable(Level level)
      Overrides:
      isLoggable in class Logger

    • getAttachment

      public <V> V getAttachment(Logger.AttachmentKey<V> key)
      Get the attachment value for a given key, or null if there is no such attachment.
      Type Parameters:
      V - the attachment value type
      Parameters:
      key - the key
      Returns:
      the attachment, or null if there is none for this key

    • attach

      public <V> V attach(Logger.AttachmentKey<V> key, V value) throws SecurityException
      Attach an object to this logger under a given key. A strong reference is maintained to the key and value for as long as this logger exists.
      Type Parameters:
      V - the attachment value type
      Parameters:
      key - the attachment key
      value - the attachment value
      Returns:
      the old attachment, if there was one
      Throws:
      SecurityException - if a security manager exists and if the caller does not have LoggingPermission(control)

    • attachIfAbsent

      public <V> V attachIfAbsent(Logger.AttachmentKey<V> key, V value) throws SecurityException
      Attach an object to this logger under a given key, if such an attachment does not already exist. A strong reference is maintained to the key and value for as long as this logger exists.
      Type Parameters:
      V - the attachment value type
      Parameters:
      key - the attachment key
      value - the attachment value
      Returns:
      the current attachment, if there is one, or null if the value was successfully attached
      Throws:
      SecurityException - if a security manager exists and if the caller does not have LoggingPermission(control)

    • detach

      public <V> V detach(Logger.AttachmentKey<V> key) throws SecurityException
      Remove an attachment.
      Type Parameters:
      V - the attachment value type
      Parameters:
      key - the attachment key
      Returns:
      the old value, or null if there was none
      Throws:
      SecurityException - if a security manager exists and if the caller does not have LoggingPermission(control)

    • addHandler

      public void addHandler(Handler handler) throws SecurityException
      Overrides:
      addHandler in class Logger
      Throws:
      SecurityException

    • removeHandler

      public void removeHandler(Handler handler) throws SecurityException
      Overrides:
      removeHandler in class Logger
      Throws:
      SecurityException

    • getHandlers

      public Handler[] getHandlers()
      Overrides:
      getHandlers in class Logger

    • setHandlers

      public void setHandlers(Handler[] handlers) throws SecurityException
      A convenience method to atomically replace the handler list for this logger.
      Parameters:
      handlers - the new handlers
      Throws:
      SecurityException - if a security manager exists and if the caller does not have LoggingPermission(control)

    • getAndSetHandlers

      public Handler[] getAndSetHandlers(Handler[] handlers) throws SecurityException
      Atomically get and set the handler list for this logger.
      Parameters:
      handlers - the new handler set
      Returns:
      the old handler set
      Throws:
      SecurityException - if a security manager exists and if the caller does not have LoggingPermission(control)

    • compareAndSetHandlers

      public boolean compareAndSetHandlers(Handler[] expected, Handler[] newHandlers) throws SecurityException
      Atomically compare and set the handler list for this logger.
      Parameters:
      expected - the expected list of handlers
      newHandlers - the replacement list of handlers
      Returns:
      true if the handler list was updated or false if the current handlers did not match the expected handlers list
      Throws:
      SecurityException - if a security manager exists and if the caller does not have LoggingPermission(control)

    • clearHandlers

      public Handler[] clearHandlers() throws SecurityException
      A convenience method to atomically get and clear all handlers.
      Throws:
      SecurityException - if a security manager exists and if the caller does not have LoggingPermission(control)

    • setUseParentHandlers

      public void setUseParentHandlers(boolean useParentHandlers)
      Overrides:
      setUseParentHandlers in class Logger

    • getUseParentHandlers

      public boolean getUseParentHandlers()
      Overrides:
      getUseParentHandlers in class Logger

    • setUseParentFilters

      public void setUseParentFilters(boolean useParentFilter)
      Specify whether or not filters should be inherited from parent loggers.

      Setting this value to false has the same behaviour as Logger.

      Parameters:
      useParentFilter - true to inherit a parents filter, otherwise false

    • getUseParentFilters

      public boolean getUseParentFilters()
      Indicates whether or not this logger inherits filters from it's parent logger.
      Returns:
      true if filters are inherited, otherwise false

    • getParent

      public Logger getParent()
      Overrides:
      getParent in class Logger

    • setParent

      public void setParent(Logger parent)
      Not allowed. This method may never be called.
      Overrides:
      setParent in class Logger
      Throws:
      SecurityException - always

    • getLogContext

      public LogContext getLogContext()
      Get the log context to which this logger belongs.
      Returns:
      the log context

    • log

      public void log(LogRecord record)
      Overrides:
      log in class Logger

    • entering

      public void entering(String sourceClass, String sourceMethod)
      Overrides:
      entering in class Logger

    • entering

      public void entering(String sourceClass, String sourceMethod, Object param1)
      Overrides:
      entering in class Logger

    • entering

      public void entering(String sourceClass, String sourceMethod, Object[] params)
      Overrides:
      entering in class Logger

    • exiting

      public void exiting(String sourceClass, String sourceMethod)
      Overrides:
      exiting in class Logger

    • exiting

      public void exiting(String sourceClass, String sourceMethod, Object result)
      Overrides:
      exiting in class Logger

    • throwing

      public void throwing(String sourceClass, String sourceMethod, Throwable thrown)
      Overrides:
      throwing in class Logger

    • severe

      public void severe(String msg)
      Overrides:
      severe in class Logger

    • warning

      public void warning(String msg)
      Overrides:
      warning in class Logger

    • info

      public void info(String msg)
      Overrides:
      info in class Logger

    • config

      public void config(String msg)
      Overrides:
      config in class Logger

    • fine

      public void fine(String msg)
      Overrides:
      fine in class Logger

    • finer

      public void finer(String msg)
      Overrides:
      finer in class Logger

    • finest

      public void finest(String msg)
      Overrides:
      finest in class Logger

    • log

      public void log(Level level, String msg)
      Overrides:
      log in class Logger

    • log

      public void log(Level level, String msg, Object param1)
      Overrides:
      log in class Logger

    • log

      public void log(Level level, String msg, Object[] params)
      Overrides:
      log in class Logger

    • log

      public void log(Level level, String msg, Throwable thrown)
      Overrides:
      log in class Logger

    • logp

      public void logp(Level level, String sourceClass, String sourceMethod, String msg)
      Overrides:
      logp in class Logger

    • logp

      public void logp(Level level, String sourceClass, String sourceMethod, String msg, Object param1)
      Overrides:
      logp in class Logger

    • logp

      public void logp(Level level, String sourceClass, String sourceMethod, String msg, Object[] params)
      Overrides:
      logp in class Logger

    • logp

      public void logp(Level level, String sourceClass, String sourceMethod, String msg, Throwable thrown)
      Overrides:
      logp in class Logger

    • logrb

      public void logrb(Level level, String sourceClass, String sourceMethod, String bundleName, String msg)
      Overrides:
      logrb in class Logger

    • logrb

      public void logrb(Level level, String sourceClass, String sourceMethod, String bundleName, String msg, Object param1)
      Overrides:
      logrb in class Logger

    • logrb

      public void logrb(Level level, String sourceClass, String sourceMethod, String bundleName, String msg, Object[] params)
      Overrides:
      logrb in class Logger

    • logrb

      public void logrb(Level level, String sourceClass, String sourceMethod, String bundleName, String msg, Throwable thrown)
      Overrides:
      logrb in class Logger

    • log

      public void log(String fqcn, Level level, String message, String bundleName, ExtLogRecord.FormatStyle style, Object[] params, Throwable t)
      SPI interface method to log a message at a given level, with a specific resource bundle.
      Parameters:
      fqcn - the fully qualified class name of the first logger class
      level - the level to log at
      message - the message
      bundleName - the resource bundle name
      style - the message format style
      params - the log parameters
      t - the throwable, if any

    • log

      public void log(String fqcn, Level level, String message, ExtLogRecord.FormatStyle style, Object[] params, Throwable t)
      SPI interface method to log a message at a given level.
      Parameters:
      fqcn - the fully qualified class name of the first logger class
      level - the level to log at
      message - the message
      style - the message format style
      params - the log parameters
      t - the throwable, if any

    • log

      public void log(String fqcn, Level level, String message, Throwable t)
      SPI interface method to log a message at a given level.
      Parameters:
      fqcn - the fully qualified class name of the first logger class
      level - the level to log at
      message - the message
      t - the throwable, if any

    • logRaw

      public void logRaw(ExtLogRecord record)
      Do the logging with no level checks (they've already been done).
      Parameters:
      record - the extended log record

    • logRaw

      public void logRaw(LogRecord record)
      Do the logging with no level checks (they've already been done). Creates an extended log record if the provided record is not one.
      Parameters:
      record - the log record

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • finalize

      protected void finalize() throws Throwable
      Overrides:
      finalize in class Object
      Throws:
      Throwable