src/main/java/org/apache/log4j/spi/LoggingEventFieldResolver.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.log4j.spi;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Locale;

import org.apache.log4j.rule.InFixToPostFix;


/**
 * A singleton helper utility which accepts a field name
 * and a LoggingEvent and returns the value of that field.
 *
 * This class defines a grammar used in creation of an expression-based Rule.
 *
 * The only available method is
 * Object getField(String fieldName, LoggingEvent event).
 *
 * Here is a description of the mapping of field names in the grammar
 * to fields on the logging event.  While the getField method returns an Object,
 * the individual types returned per field are described here:
 *
 * Field Name    Field value (String representation        Return type
 * LOGGER        category name (logger)                    String
 * LEVEL         level                                     Level
 * CLASS         locationInformation's class name          String
 * FILE          locationInformation's file name           String
 * LINE          locationInformation's line number         String
 * METHOD        locationInformation's method name         String
 * MSG           message                                   Object
 * NDC           NDC                                       String
 * EXCEPTION     throwable string representation           ThrowableInformation
 * TIMESTAMP     timestamp                                 Long
 * THREAD        thread                                    String
 * PROP.keyName  entry in the Property hashtable           String
 *               mapped to the key [keyName]

 * NOTE:  the values for the 'keyName' portion of the MDC and PROP mappings must
 * be an exact match to the key in the hashTable (case sensitive).
 *
 * If the passed-in field is null or doesn't match an entry
 * in the above-described mapping, an exception is thrown.
 *
 * @author Scott Deboy (sdeboy@apache.org)
 * @author Paul Smith (psmith@apache.org)
 *
 */
public final class LoggingEventFieldResolver {
    /**
     * Keyword list.
     */
  public static final List KEYWORD_LIST = new ArrayList();
    /**
     * LOGGER string literal.
     */
  public static final String LOGGER_FIELD = "LOGGER";
    /**
     * LEVEL string literal.
     */
  public static final String LEVEL_FIELD = "LEVEL";
    /**
     * CLASS string literal.
     */
  public static final String CLASS_FIELD = "CLASS";
    /**
     * FILE string literal.
     */
  public static final String FILE_FIELD = "FILE";
    /**
     * LINE string literal.
     */
  public static final String LINE_FIELD = "LINE";
    /**
     * METHOD string literal.
     */
  public static final String METHOD_FIELD = "METHOD";
    /**
     * MSG string literal.
     */
  public static final String MSG_FIELD = "MSG";
    /**
     * NDC string literal.
     */
  public static final String NDC_FIELD = "NDC";
    /**
     * EXCEPTION string literal.
     */
  public static final String EXCEPTION_FIELD = "EXCEPTION";
    /**
     * TIMESTAMP string literal.
     */
  public static final String TIMESTAMP_FIELD = "TIMESTAMP";
    /**
     * THREAD string literal.
     */
  public static final String THREAD_FIELD = "THREAD";
    /**
     * PROP. string literal.
     */
  public static final String PROP_FIELD = "PROP.";
    /**
     * empty string literal.
     */
  public static final String EMPTY_STRING = "";
    /**
     * LOGGER string literal.
     */
  private static final LoggingEventFieldResolver RESOLVER =
    new LoggingEventFieldResolver();

    /**
     * Create new instance.
     */
  private LoggingEventFieldResolver() {
    super();
    KEYWORD_LIST.add(LOGGER_FIELD);
    KEYWORD_LIST.add(LEVEL_FIELD);
    KEYWORD_LIST.add(CLASS_FIELD);
    KEYWORD_LIST.add(FILE_FIELD);
    KEYWORD_LIST.add(LINE_FIELD);
    KEYWORD_LIST.add(METHOD_FIELD);
    KEYWORD_LIST.add(MSG_FIELD);
    KEYWORD_LIST.add(NDC_FIELD);
    KEYWORD_LIST.add(EXCEPTION_FIELD);
    KEYWORD_LIST.add(TIMESTAMP_FIELD);
    KEYWORD_LIST.add(THREAD_FIELD);
    KEYWORD_LIST.add(PROP_FIELD);
  }

    /**
     * Apply fields.
     * @param replaceText replacement text.
     * @param event logging event.
     * @return evaluted expression
     */
  public String applyFields(final String replaceText,
                            final LoggingEvent event) {
      if (replaceText == null) {
        return null;
      }
      InFixToPostFix.CustomTokenizer tokenizer = new InFixToPostFix.CustomTokenizer(replaceText);
      StringBuffer result = new StringBuffer();
      boolean found = false;

      while (tokenizer.hasMoreTokens()) {
          String token = tokenizer.nextToken();
          if (isField(token) || token.toUpperCase(Locale.US).startsWith(PROP_FIELD)) {
              result.append(getValue(token, event).toString());
              found = true;
          } else {
              result.append(token);
          }
      }
      if (found) {
        return result.toString();
      }
      return null;
  }

    /**
     * Get singleton instance.
     * @return singleton instance
     */
  public static LoggingEventFieldResolver getInstance() {
    return RESOLVER;
  }

    /**
     * Determines if specified string is a recognized field.
     * @param fieldName field name
     * @return true if recognized field.
     */
  public boolean isField(final String fieldName) {
    if (fieldName != null) {
        return (KEYWORD_LIST.contains(
                fieldName.toUpperCase(Locale.US))
                || fieldName.toUpperCase().startsWith(PROP_FIELD));
    }
    return false;
  }

    /**
     * Get value of field.
     * @param fieldName field
     * @param event event
     * @return value of field
     */
  public Object getValue(final String fieldName,
                         final LoggingEvent event) {
    String upperField = fieldName.toUpperCase(Locale.US);
    if (LOGGER_FIELD.equals(upperField)) {
      return event.getLoggerName();
    } else if (LEVEL_FIELD.equals(upperField)) {
      return event.getLevel();
    } else if (MSG_FIELD.equals(upperField)) {
      return event.getMessage();
    } else if (NDC_FIELD.equals(upperField)) {
      String ndcValue = event.getNDC();
      return ((ndcValue == null) ? EMPTY_STRING : ndcValue);
    } else if (EXCEPTION_FIELD.equals(upperField)) {
        String[] throwableRep = event.getThrowableStrRep();
        if (throwableRep == null) {
            return EMPTY_STRING;
        } else {
            return getExceptionMessage(throwableRep);
        }
    } else if (TIMESTAMP_FIELD.equals(upperField)) {
      return new Long(event.timeStamp);
    } else if (THREAD_FIELD.equals(upperField)) {
      return event.getThreadName();
    } else if (upperField.startsWith(PROP_FIELD)) {
      //note: need to use actual fieldname since case matters
      Object propValue = event.getMDC(fieldName.substring(5));
      if (propValue == null) {
          //case-specific match didn't work, try case insensitive match
          String lowerPropKey = fieldName.substring(5).toLowerCase();
          Set entrySet = event.getProperties().entrySet();
          for (Iterator iter = entrySet.iterator();iter.hasNext();) {
              Map.Entry thisEntry = (Map.Entry) iter.next();
              if (thisEntry.getKey().toString().equalsIgnoreCase(lowerPropKey)) {
                  propValue = thisEntry.getValue();
              }
          }
      }
      return ((propValue == null) ? EMPTY_STRING : propValue.toString());
    } else {
        LocationInfo info = event.getLocationInformation();
        if (CLASS_FIELD.equals(upperField)) {
            return ((info == null) ? EMPTY_STRING : info.getClassName());
        } else if (FILE_FIELD.equals(upperField)) {
            return ((info == null) ? EMPTY_STRING : info.getFileName());
        } else if (LINE_FIELD.equals(upperField)) {
            return ((info == null) ? EMPTY_STRING : info.getLineNumber());
        } else if (METHOD_FIELD.equals(upperField)) {
            return ((info == null) ? EMPTY_STRING : info.getMethodName());
        }
    }

    //there wasn't a match, so throw a runtime exception
    throw new IllegalArgumentException("Unsupported field name: " + fieldName);
  }

    /**
     * Get message from throwable representation.
     * @param exception exception
     * @return message
     */
    private static String getExceptionMessage(final String[] exception) {
        StringBuffer buff = new StringBuffer();
        for (int i = 0; i < exception.length; i++) {
            buff.append(exception[i]);
        }
        return buff.toString();
    }
}