Page History

/**
 * LogActor the entity that is requesting the log stored as in a ThreadLocal and used to beperform performedlogging.
 *
 * The actor is responsible for providingformatting theits formatteddisplay name for the log entry.
 *
 */
public interface LogActor
{
    /**
 The actor  performs * Return the String that this actor wishes to be entered into the logfile.
     *
     * @return String
     */requested logging.
 */
public interface LogActor
{
    public String getLogFormattedName();
}

/**
 * Message Status messages are logged via this interface.
 *
 *Logs Eachthe Entityspecified thatLogMessage wishesabout to be logged will implement this to provide theirthe LogSubject
 * own display representation.
 *
 * The MSLogger will be created by a Factory {@see MessageStatusLoggerFactory}.
 *
 * Currently logging has a global setting however this will later be revised and
     * as such the LogActor will need to betake taken ininto to consideration asany well as the
 * status of this Logger.
 *
 * A detailed and published list of messages that will be logged will be
 * provided so that monitoring systems can know what to expect.
 */
public interface MessageStatusLogger
{

    /**
     * This method should be used as a guard against expensive message
     * construction prior to calling message().
     *
     * It should not be called if there is no construction required.
     *
     * This will perform validation that the log message should be performed
     * based on the provided Actor and the Entity this Logger represents.
     * This may be done via delegation to the RootMessageStatusLogger.
     *
     * @param actor The actor that is requesting to perform logging
     *
     * @return if this log message should take place
     */
    public boolean isMessageEnabled(LogActor actor);

    /**
     * Logs the message as provided by String.valueOf(message).
     *
     * The call to message() will first check if #isMessageEnabled() allows
     * the logging to be performed. This means for simple messages it is not
     * necessary to guard this call with isMessageEnabled() as it will be called
     * internally.
     *
     * If any complex construction is required then it MUST BE guarded so that
     * the log message is not needlessly generated.
     *
     * @param actor   The actor that is requesting the logging
     * @param message The message to log
     */
    public void message(LogActor actor, Object message);

    /**
     * Logs the message as provided by String.valueOf(message)new configuration 
     * as a means of enabling the logging of LogActors and LogSubjects.
     *
     * The call to message() will first check if #isMessageEnabled() allows
     * the logging to be performed. This means for simple messages it is not
     * necessary to guard this call with isMessageEnabled() as it will be called
     * internally.
     *
     * If any complex construction is required then it MUST BE guarded so that
     * the log message is not needlessly generated.
     *
     * If the provided Throwable is non-null then the stack trace will also be
     * logged.
     *
     * @param actor   The actor that is requesting the logging
     * @param message The message to log
     * @param throwable The throwable that should be used to generate a trace.
     */
    public void message(LogActorLogSubject actorsubject, ObjectLogMessage message, Throwable throwable);
}