Package org.jboss.logmanager

Class ExtHandler

java.lang.Object
java.util.logging.Handler
org.jboss.logmanager.ExtHandler
All Implemented Interfaces:
Flushable, AutoCloseable
Direct Known Subclasses:
AsyncHandler, DelayedHandler, QueueHandler, SocketHandler, SyslogHandler, WriterHandler
public abstract class ExtHandler extends Handler implements AutoCloseable, Flushable
An extended logger handler. Use this class as a base class for log handlers which require ExtLogRecord instances.

  • Field Details

    • lock

      protected final ReentrantLock lock

    • handlers

      protected volatile Handler[] handlers
      The sub-handlers for this handler. May only be updated using the handlersUpdater atomic updater. The array instance should not be modified (treat as immutable).

    • handlersUpdater

      protected static final org.jboss.logmanager.AtomicArray<ExtHandler,Handler> handlersUpdater
      The atomic updater for the handlers field.

  • Constructor Details

    • ExtHandler

      protected ExtHandler()
      Construct a new instance.

  • Method Details

    • publish

      public void publish(LogRecord record)
      Specified by:
      publish in class Handler

    • publish

      public void publish(ExtLogRecord record)
      Publish an ExtLogRecord.

      The logging request was made initially to a Logger object, which initialized the LogRecord and forwarded it here.

      The ExtHandler is responsible for formatting the message, when and if necessary. The formatting should include localization.

      Parameters:
      record - the log record to publish

    • publishToNestedHandlers

      protected void publishToNestedHandlers(ExtLogRecord record)
      Publish a log record to each nested handler.
      Parameters:
      record - the log record to publish

    • doPublish

      protected void doPublish(ExtLogRecord record)
      Do the actual work of publication; the record will have been filtered already. The default implementation does nothing except to flush if the autoFlush property is set to true; if this behavior is to be preserved in a subclass then this method should be called after the record is physically written.
      Parameters:
      record - the log record to publish

    • addHandler

      public void addHandler(Handler handler) throws SecurityException
      Add a sub-handler to this handler. Some handler types do not utilize sub-handlers.
      Parameters:
      handler - the handler to add
      Throws:
      SecurityException - if a security manager exists and if the caller does not have LoggingPermission(control)

    • removeHandler

      public void removeHandler(Handler handler) throws SecurityException
      Remove a sub-handler from this handler. Some handler types do not utilize sub-handlers.
      Parameters:
      handler - the handler to remove
      Throws:
      SecurityException - if a security manager exists and if the caller does not have LoggingPermission(control)

    • getHandlers

      public Handler[] getHandlers()
      Get a copy of the sub-handlers array. Since the returned value is a copy, it may be freely modified.
      Returns:
      a copy of the sub-handlers array

    • clearHandlers

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

    • setHandlers

      public Handler[] setHandlers(Handler[] newHandlers) throws SecurityException
      A convenience method to atomically get and replace the sub-handler array.
      Parameters:
      newHandlers - the new sub-handlers
      Returns:
      the old sub-handler array
      Throws:
      SecurityException - if a security manager exists and if the caller does not have LoggingPermission(control)

    • isAutoFlush

      public boolean isAutoFlush()
      Determine if this handler will auto-flush.
      Returns:
      true if auto-flush is enabled

    • setAutoFlush

      public void setAutoFlush(boolean autoFlush) throws SecurityException
      Change the autoflush setting for this handler.
      Parameters:
      autoFlush - true to automatically flush after each write; false otherwise
      Throws:
      SecurityException - if a security manager exists and if the caller does not have LoggingPermission(control)

    • setEnabled

      public final void setEnabled(boolean enabled) throws SecurityException
      Enables or disables the handler based on the value passed in.
      Parameters:
      enabled - true to enable the handler or false to disable the handler.
      Throws:
      SecurityException - if a security manager exists and if the caller does not have LoggingPermission(control)

    • isEnabled

      public final boolean isEnabled()
      Determine if the handler is enabled.
      Returns:
      true if the handler is enabled, otherwise false.

    • isCloseChildren

      public boolean isCloseChildren()
      Indicates whether or not children handlers should be closed when this handler is closed.
      Returns:
      true if the children handlers should be closed when this handler is closed, false if children handlers should not be closed when this handler is closed

    • setCloseChildren

      public void setCloseChildren(boolean closeChildren)
      Sets whether or not children handlers should be closed when this handler is closed.
      Parameters:
      closeChildren - true if all children handlers should be closed when this handler is closed, false if children handlers will not be closed when this handler is closed

    • checkAccess

      protected static void checkAccess() throws SecurityException
      Check access.
      Throws:
      SecurityException - if a security manager is installed and the caller does not have the "control" LoggingPermission

    • checkAccess

      @Deprecated protected static void checkAccess(ExtHandler handler) throws SecurityException
      Deprecated.
      Check access.
      Parameters:
      handler - the handler to check access on.
      Throws:
      SecurityException - if a security manager exists and if the caller does not have LoggingPermission(control)

    • flush

      public void flush()
      Flush all child handlers.
      Specified by:
      flush in interface Flushable
      Specified by:
      flush in class Handler

    • close

      public void close() throws SecurityException
      Close all child handlers.
      Specified by:
      close in interface AutoCloseable
      Specified by:
      close in class Handler
      Throws:
      SecurityException

    • setFormatter

      public void setFormatter(Formatter newFormatter) throws SecurityException
      Overrides:
      setFormatter in class Handler
      Throws:
      SecurityException

    • getFormatter

      public Formatter getFormatter()
      Overrides:
      getFormatter in class Handler

    • setFilter

      public void setFilter(Filter newFilter) throws SecurityException
      Overrides:
      setFilter in class Handler
      Throws:
      SecurityException

    • getFilter

      public Filter getFilter()
      Overrides:
      getFilter in class Handler

    • setEncoding

      public void setEncoding(String encoding) throws SecurityException, UnsupportedEncodingException
      Set the handler's character set by name. This is roughly equivalent to calling setCharset(Charset) with the results of Charset.forName(String).
      Overrides:
      setEncoding in class Handler
      Parameters:
      encoding - the name of the encoding
      Throws:
      SecurityException - if a security manager is installed and the caller does not have the "control" LoggingPermission
      UnsupportedEncodingException - if no character set could be found for the encoding name

    • getEncoding

      public String getEncoding()
      Get the name of the handler's character set.
      Overrides:
      getEncoding in class Handler
      Returns:
      the handler character set name

    • setCharset

      public void setCharset(Charset charset) throws SecurityException
      Set the handler's character set. If not set, the handler's character set is initialized to the platform default character set.
      Parameters:
      charset - the character set (must not be null)
      Throws:
      SecurityException - if a security manager is installed and the caller does not have the "control" LoggingPermission

    • setCharsetPrivate

      protected void setCharsetPrivate(Charset charset) throws SecurityException
      Set the handler's character set from within this handler. If not set, the handler's character set is initialized to the platform default character set.
      Parameters:
      charset - the character set (must not be null)
      Throws:
      SecurityException

    • getCharset

      public Charset getCharset()
      Get the handler's character set.
      Returns:
      the character set in use (not null)

    • setErrorManager

      public void setErrorManager(ErrorManager em)
      Overrides:
      setErrorManager in class Handler

    • getErrorManager

      public ErrorManager getErrorManager()
      Overrides:
      getErrorManager in class Handler

    • setLevel

      public void setLevel(Level newLevel) throws SecurityException
      Overrides:
      setLevel in class Handler
      Throws:
      SecurityException

    • getLevel

      public Level getLevel()
      Overrides:
      getLevel in class Handler

    • isCallerCalculationRequired

      public boolean isCallerCalculationRequired()
      Indicates whether or not the formatter associated with this handler or a formatter from a child handler requires the caller to be calculated.

      Calculating the caller on a log record can be an expensive operation. Some handlers may be required to copy some data from the log record, but may not need the caller information. If the formatter is a ExtFormatter the ExtFormatter.isCallerCalculationRequired() is used to determine if calculation of the caller is required.

      Returns:
      true if the caller should be calculated, otherwise false if it can be skipped
      See Also:

    • reportError

      protected void reportError(String msg, Exception ex, int code)
      Overrides:
      reportError in class Handler

    • reportError

      public static void reportError(Handler handler, String msg, Exception ex, int code)
      Report an error using a handler's specific error manager, if any.
      Parameters:
      handler - the handler
      msg - the error message
      ex - the exception
      code - the error code