public JBossLogSink() 
{
      // populate the dispatch map...
      // don't necessarily use just  _log.debug() for Jetty debug:
      // Jetty guards it's debug output to it's log sinks, so it will
      // only get here if Jetty has debugging enabled. However,
      // enabling debugging in Jetty (eg via the CodeMBean) may not
      // result in log output because JBoss has it's log level set to
      // INFO.To reduce confusion, if Jetty debug is enabled, but not
      // on JBoss, we will still output it to the JBoss log sink as
      // category INFO.
      _dispatch.put(Log.DEBUG,
                    new MyLogger()
                    {
                        public void log(String s)
                        {
                            if (_log.isDebugEnabled())
                                _log.debug(s);
                            else
                                _log.info("DEBUG: "+s);
                        }
                    });
    _dispatch.put(Log.EVENT,  new MyLogger(){public void log(String s){_log.info(s);}});
    _dispatch.put(Log.WARN,   new MyLogger(){public void log(String s){_log.warn("WARNING: "+s);}});
    _dispatch.put(Log.ASSERT, new MyLogger(){public void log(String s){_log.error(s);}});
    _dispatch.put(Log.FAIL,   new MyLogger(){public void log(String s){_log.error(s);}});
}

 public  void destroy() 
{
    _log = null;
}

 public String getOptions() 
{
    //     return
    //       (_logTimeStamps?"t":"")+
    //       (_logLabels?"L":"")+
    //       (_logTags?"T":"")+
    //       (_logStackSize?"s":"")+
    //       (_logStackTrace?"S":"")+
    //       (_logOneLine?"O":"");
    return "";
}

 public  void initialize(Object log) throws InterruptedException 
{
    _log = (Logger) log;
}

 public boolean isDestroyed() 
{
    return (_log==null);
}

 public boolean isStarted() 
{
    return _started;
}

 public synchronized  void log(String formattedLog) 
{
    _log.info(formattedLog);
}

Log a message. The formatted log string is written to the log sink. The default implementation writes the message to a PrintWriter.

 public  void log(String tag,
    Object msg,
    Frame frame,
    long time) 
{
    boolean debugging=Code.debug();
    MyLogger logger=(MyLogger)_dispatch.get(tag);
    if (logger!=null)
    {
      logger.log(msg+(debugging?", "+frame:""));
    }
    else
    {
      log(msg+" - "+tag+(debugging?", "+frame:""));
      _log.warn("JBossLogSink doesn't understand tag: '"+tag+"'");
    }
}

Log a message. This method formats the log information as a string and calls log(String). It should only be specialized by a derived implementation if the format of the logged messages is to be changed.

 public  void setOptions(String logOptions) 
{
    //     setOptions((logOptions.indexOf(OPT_TIMESTAMP)  >= 0),
    // 	       (logOptions.indexOf(OPT_LABEL)  >= 0),
    // 	       (logOptions.indexOf(OPT_TAG)  >= 0),
    // 	       (logOptions.indexOf(OPT_STACKSIZE)  >= 0),
    // 	       (logOptions.indexOf(OPT_STACKTRACE)  >= 0),
    // 	       (logOptions.indexOf(OPT_ONELINE)  >= 0));
}

 public  void setOptions(String dateFormat,
    String timezone,
    boolean logTimeStamps,
    boolean logLabels,
    boolean logTags,
    boolean logStackSize,
    boolean logStackTrace,
    boolean logOneLine) 
{
    // is it possible to translate these into JBoss logging options...?
}

 public  void start() 
{
    _started = true;
}

 public  void stop() throws InterruptedException 
{
    _started = false;
    //_log=null;
}