LogMonitorAdapter xref

View Javadoc

    1   /*
    2    * Licensed to the Apache Software Foundation (ASF) under one or more
    3    * contributor license agreements.  See the NOTICE file distributed with
    4    * this work for additional information regarding copyright ownership.
    5    * The ASF licenses this file to You under the Apache License, Version 2.0
    6    * (the "License"); you may not use this file except in compliance with
    7    * the License.  You may obtain a copy of the License at
    8    *
    9    *      http://www.apache.org/licenses/LICENSE-2.0
    10   *
    11   * Unless required by applicable law or agreed to in writing, software
    12   * distributed under the License is distributed on an "AS IS" BASIS,
    13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14   * See the License for the specific language governing permissions and
    15   * limitations under the License.
    16   */
    17  package org.apache.log4j.lf5.util;
    18
    19  import java.awt.Toolkit;
    20  import java.util.Arrays;
    21  import java.util.List;
    22
    23  import org.apache.log4j.lf5.LogLevel;
    24  import org.apache.log4j.lf5.LogRecord;
    25  import org.apache.log4j.lf5.viewer.LogBrokerMonitor;
    26
    27  /**
    28   * <p>LogMonitorAdapter facilitates the usage of the LogMonitor</p>
    29   *
    30   * @author Richard Hurst
    31   */
    32
    33  // Contributed by ThoughtWorks Inc.
    34
    35  public class LogMonitorAdapter {
    36    //--------------------------------------------------------------------------
    37    //   Constants:
    38    //--------------------------------------------------------------------------
    39    public static final int LOG4J_LOG_LEVELS = 0;
    40    public static final int JDK14_LOG_LEVELS = 1;
    41    //--------------------------------------------------------------------------
    42    //   Protected Variables:
    43    //--------------------------------------------------------------------------
    44
    45    //--------------------------------------------------------------------------
    46    //   Private Variables:
    47    //--------------------------------------------------------------------------
    48    private LogBrokerMonitor _logMonitor;
    49    private LogLevel _defaultLevel = null;
    50
    51    //--------------------------------------------------------------------------
    52    //   Constructors:
    53    //--------------------------------------------------------------------------
    54    private LogMonitorAdapter(List userDefinedLevels) {
    55      super();
    56      // set the default level to be the first entry in the list
    57      _defaultLevel = (LogLevel) userDefinedLevels.get(0);
    58      _logMonitor = new LogBrokerMonitor(userDefinedLevels);
    59
    60      _logMonitor.setFrameSize(getDefaultMonitorWidth(),
    61          getDefaultMonitorHeight());
    62      _logMonitor.setFontSize(12);
    63      _logMonitor.show();
    64    }
    65    //--------------------------------------------------------------------------
    66    //   Public Methods:
    67    //--------------------------------------------------------------------------
    68    /**
    69     * <p>Creates an instance of LogMonitorAdapter using the
    70     * log levels inticated by the parameter. Log4J and JDK1.4 both have default
    71     * LogLevels which are set but these levels can be overriden.<p>
    72     *
    73     * @param loglevels An integer representing either Log4J or JDK1.4 logging levels
    74     * @return LogMonitorAdapter
    75     */
    76    public static LogMonitorAdapter newInstance(int loglevels) {
    77      LogMonitorAdapter adapter;
    78      if (loglevels == JDK14_LOG_LEVELS) {
    79        adapter = newInstance(LogLevel.getJdk14Levels());
    80        adapter.setDefaultLevel(LogLevel.FINEST);
    81        adapter.setSevereLevel(LogLevel.SEVERE);
    82      } else {
    83        adapter = newInstance(LogLevel.getLog4JLevels());
    84        adapter.setDefaultLevel(LogLevel.DEBUG);
    85        adapter.setSevereLevel(LogLevel.FATAL);
    86      }
    87      return adapter;
    88    }
    89
    90    /**
    91     * <p>Creates an instance of LogMonitorAdapter using the specified LogLevels.
    92     * The first LogLevel in the array is used as the default LogLevel unless
    93     * changed using the setDefaultLevel method.<p>
    94     *
    95     * @param userDefined An array of user defined LogLevel objects.
    96     * @return LogMonitorAdapter
    97     */
    98    public static LogMonitorAdapter newInstance(LogLevel[] userDefined) {
    99      if (userDefined == null) {
    100       return null;
    101     }
    102     return newInstance(Arrays.asList(userDefined));
    103   }
    104
    105   /**
    106    * <p>Creates an instance of LogMonitorAdapter using the specified LogLevels.
    107    * The first LogLevel in the List is used as the default LogLevel unless
    108    * changed using the setDefaultLevel method.<p>
    109    *
    110    * @param userDefinedLevels A list of user defined LogLevel objects.
    111    * @return LogMonitorAdapter
    112    */
    113   public static LogMonitorAdapter newInstance(List userDefinedLevels) {
    114     return new LogMonitorAdapter(userDefinedLevels);
    115   }
    116
    117   /**
    118    * <p>Adds a LogRecord to the LogMonitor.<p>
    119    *
    120    * @param record The LogRecord object to be logged in the logging monitor.
    121    */
    122   public void addMessage(LogRecord record) {
    123     _logMonitor.addMessage(record);
    124   }
    125
    126   /**
    127    * <p>Set the maximum number of records to be displayed in the monitor<p>
    128    *
    129    * @param maxNumberOfRecords
    130    */
    131   public void setMaxNumberOfRecords(int maxNumberOfRecords) {
    132     _logMonitor.setMaxNumberOfLogRecords(maxNumberOfRecords);
    133   }
    134
    135   /**
    136    * <p>Set the default log level to be used when logging messages without
    137    * specifying a LogLevel.<p>
    138    *
    139    * @param level
    140    */
    141   public void setDefaultLevel(LogLevel level) {
    142     _defaultLevel = level;
    143   }
    144
    145   /**
    146    * <p>Gets the default LogLevel for the Adapter.<p>
    147    *
    148    * @return LogLevel
    149    */
    150   public LogLevel getDefaultLevel() {
    151     return _defaultLevel;
    152   }
    153
    154   /**
    155    * <p>Sets the Severe LogLevel.</p>
    156    *
    157    * @param level
    158    */
    159   public void setSevereLevel(LogLevel level) {
    160     AdapterLogRecord.setSevereLevel(level);
    161   }
    162
    163   /**
    164    * <p>Gets the current Severe LogLevel <p>
    165    *
    166    * @return LogLevel
    167    */
    168   public LogLevel getSevereLevel() {
    169     return AdapterLogRecord.getSevereLevel();
    170   }
    171
    172   /**
    173    * <p>Log a complete message to the Monitor.<p>
    174    *
    175    * @param category The category to be used
    176    * @param level The log level to apply to the message
    177    * @param message The message
    178    * @param t The throwable content of the message
    179    * @param NDC The NDC really only applies to Log4J and the parameter can
    180    *            usually be ignored.
    181    */
    182   public void log(String category, LogLevel level, String message,
    183       Throwable t, String NDC) {
    184     AdapterLogRecord record = new AdapterLogRecord();
    185     record.setCategory(category);
    186     record.setMessage(message);
    187     record.setNDC(NDC);
    188     record.setThrown(t);
    189
    190     if (level == null) {
    191       record.setLevel(getDefaultLevel());
    192     } else {
    193       record.setLevel(level);
    194     }
    195
    196     addMessage(record);
    197   }
    198
    199   /**
    200    * <p>Log a message to the Monitor and use the default LogLevel.<p>
    201    *
    202    * @param category The category to be used
    203    * @param message The message
    204    */
    205   public void log(String category, String message) {
    206     log(category, null, message);
    207   }
    208
    209   /**
    210    * <p>Log a message to the Monitor.<p>
    211    *
    212    * @param category The category to be used
    213    * @param level The log level to apply to the message
    214    * @param message The message
    215    * @param NDC
    216    */
    217   public void log(String category, LogLevel level, String message, String NDC) {
    218     log(category, level, message, null, NDC);
    219   }
    220
    221   /**
    222    * <p>Log a message to the Monitor.<p>
    223    *
    224    * @param category The category to be used
    225    * @param level The log level to apply to the message
    226    * @param message The message
    227    * @param t The throwable content of the message
    228    */
    229   public void log(String category, LogLevel level, String message,
    230       Throwable t) {
    231     log(category, level, message, t, null);
    232   }
    233
    234   /**
    235    * <p>Log a message to the Monitor.<p>
    236    *
    237    * @param category The category to be used
    238    * @param level The log level to apply to the message
    239    * @param message The message
    240    */
    241   public void log(String category, LogLevel level, String message) {
    242     log(category, level, message, null, null);
    243   }
    244
    245   //--------------------------------------------------------------------------
    246   //   Protected Methods:
    247   //--------------------------------------------------------------------------
    248   /**
    249    * @return the screen width from Toolkit.getScreenSize()
    250    * if possible, otherwise returns 800
    251    * @see java.awt.Toolkit
    252    */
    253   protected static int getScreenWidth() {
    254     try {
    255       return Toolkit.getDefaultToolkit().getScreenSize().width;
    256     } catch (Throwable t) {
    257       return 800;
    258     }
    259   }
    260
    261   /**
    262    * @return the screen height from Toolkit.getScreenSize()
    263    * if possible, otherwise returns 600
    264    * @see java.awt.Toolkit
    265    */
    266   protected static int getScreenHeight() {
    267     try {
    268       return Toolkit.getDefaultToolkit().getScreenSize().height;
    269     } catch (Throwable t) {
    270       return 600;
    271     }
    272   }
    273
    274   protected static int getDefaultMonitorWidth() {
    275     return (3 * getScreenWidth()) / 4;
    276   }
    277
    278   protected static int getDefaultMonitorHeight() {
    279     return (3 * getScreenHeight()) / 4;
    280   }
    281   //--------------------------------------------------------------------------
    282   //   Private Methods:
    283   //--------------------------------------------------------------------------
    284
    285   //--------------------------------------------------------------------------
    286   //   Nested Top-Level Classes or Interfaces
    287   //--------------------------------------------------------------------------
    288 }
    289