/*
    * $HeadURL: $
    * $Date: $
    * $Revision: $
    * $Author: $
    * 
    * Copyright (c) 2005 MindTree Consulting Ltd. 
    * 
    * This file is part of Insight.
   * 
   * Insight is free software: you can redistribute it and/or modify it under the 
   * terms of the GNU General Public License as published by the Free Software 
   * Foundation, either version 3 of the License, or (at your option) any later 
   * version.
   * 
   * Insight is distributed in the hope that it will be useful, but 
   * WITHOUT ANY WARRANTY; without even the implied warranty of 
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General 
   * Public License for more details.
   * 
   * You should have received a copy of the GNU General Public License along with 
   * Insight.  If not, see <http://www.gnu.org/licenses/>.
   */
  package com.mindtree.techworks.insight.receiver;
  
  import java.text.SimpleDateFormat;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Hashtable;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.TreeMap;
  
  import org.apache.log4j.Level;
  import org.apache.log4j.Logger;
  import org.apache.log4j.helpers.Constants;
  import org.apache.log4j.rule.ExpressionRule;
  import org.apache.log4j.rule.Rule;
  import org.apache.log4j.spi.ThrowableInformation;
  import org.apache.log4j.spi.LocationInfo;
  import org.apache.oro.text.perl.Perl5Util;
  import org.apache.oro.text.regex.MalformedPatternException;
  import org.apache.oro.text.regex.MatchResult;
  import org.apache.oro.text.regex.Pattern;
  import org.apache.oro.text.regex.Perl5Compiler;
  import org.apache.oro.text.regex.Perl5Matcher;
  
  import com.mindtree.techworks.insight.model.ReceiverFormat;
  import com.mindtree.techworks.insight.spi.LogEvent;
  import com.mindtree.techworks.insight.spi.LogNamespace;
  
  /**
   * The <code>LogInterpreter</code> class is an abstraction of functionality
   * which is used for creating log events out of the given resource.
   * 
   * @author Shailesh Sinha
   * @version $Revision: 27 $ $Date: 2007-12-16 04:58:03 -0700 (Sun, 16 Dec 2007) $
   */
  
  public class LogInterpreter {
  
  	// /**
  	// * Pattern used to split a URL and encode parts of it
  	// */
  	// private static final java.util.regex.Pattern URL_SPLIT_PATTERN =
  	// java.util.regex.Pattern.compile("^([a-zA-Z]+:[/]+)(.*)$");
  
  	/**
  	 * Log event attribute identifiers - logger
  	 */
  	private static final String LOGGER = "LOGGER";
  
  	/**
  	 * Log event attribute identifiers - message
  	 */
  	private static final String MESSAGE = "MESSAGE";
  
  	/**
  	 * Log event attribute identifiers - timestamp
  	 */
  	private static final String TIMESTAMP = "TIMESTAMP";
  
  	/**
  	 * Log event attribute identifiers - NDC
  	 */
  	private static final String NDC = "NDC";
  
  	/**
  	 * Log event attribute identifiers - log level
  	 */
  	private static final String LEVEL = "LEVEL";
  
  	/**
  	 * Log event attribute identifiers - thread
  	 */
  	private static final String THREAD = "THREAD";
 
 	/**
 	 * Log event attribute identifiers - class
 	 */
 	private static final String CLASS = "CLASS";
 
 	/**
 	 * Log event attribute identifiers - file
 	 */
 	private static final String FILE = "FILE";
 
 	/**
 	 * Log event attribute identifiers - line in code
 	 */
 	private static final String LINE = "LINE";
 
 	/**
 	 * Log event attribute identifiers - method
 	 */
 	private static final String METHOD = "METHOD";
 
 	/**
 	 * Log event attribute identifiers - relative time
 	 */
 	private static final String RELATIVETIME = "RELATIVETIME";
 
 	/**
 	 * The default timestamp format
 	 */
 	private static final String TIMESTAMP_FORMAT = "yyyy-MM-dd HH:mm:ss,SSS";
 
 	/**
 	 * The default level if none is specified
 	 */
 	private static final String DEFAULT_LEVEL = "INFO";
 
 	/**
 	 * Pattern matching constants - exception pattern
 	 */
 	private static final String EXCEPTION_PATTERN = "\tat.*";
 
 	/**
 	 * Pattern matching constants - wildcard
 	 */
 	private static final String REGEXP_DEFAULT_WILDCARD = ".*?";
 
 	/**
 	 * Pattern matching constants - wildcard
 	 */
 	private static final String REGEXP_GREEDY_WILDCARD = ".+";
 
 	/**
 	 * Pattern matching constants - wildcard
 	 */
 	private static final String PATTERN_WILDCARD = "*";
 
 	/**
 	 * Pattern matching constants - group
 	 */
 	private static final String DEFAULT_GROUP = "(" + REGEXP_DEFAULT_WILDCARD
 			+ ")";
 
 	/**
 	 * Pattern matching constants - group
 	 */
 	private static final String GREEDY_GROUP = "(" + REGEXP_GREEDY_WILDCARD
 			+ ")";
 
 	/**
 	 * Hostname
 	 */
 	private static final String HOSTNAME_PROPERTY_VALUE = "file";
 
 	/**
 	 * Date format
 	 */
 	private static final String VALID_DATEFORMAT_CHAR_PATTERN = "[GyMwWDdFEaHkKhmsSzZ]";
 
 	/**
 	 * Property start
 	 */
 	private static final String PROP_START = "PROP(";
 
 	/**
 	 * Property end
 	 */
 	private static final String PROP_END = ")";
 
 	/**
 	 * Maximum size of unmatched lines. Needed to prevent
 	 * java.lang.OutOfMemoryError in case pattern doesnot match a very large log
 	 * file
 	 */
 	private static final int MAX_UNMATCHED_LINE_COUNT = 1000;
 
 	/**
 	 * Variables used for pattern matching and interpretation
 	 */
 	private final Set keywords = new HashSet();
 
 	/**
 	 * Matching keywords
 	 */
 	private List[] matchingKeywords = null;
 
 	/**
 	 * Newline character
 	 */
 	private final String newLine = System.getProperty("line.separator");
 
 	/**
 	 * Empty exception
 	 */
 	private final String[] emptyException = new String[] { "" };
 
 	/**
 	 * Date format
 	 */
 	private SimpleDateFormat[] dateFormat;
 
 	/**
 	 * Filter expression
 	 */
 	private String filterExpression;
 
 	/**
 	 * Perl 5 util
 	 */
 	private final Perl5Util util = new Perl5Util();
 
 	/**
 	 * Perl 5 compiler
 	 */
 	private final Perl5Compiler exceptionCompiler = new Perl5Compiler();
 
 	/**
 	 * Perl 5 matcher
 	 */
 	private final Perl5Matcher exceptionMatcher = new Perl5Matcher();
 
 	/**
 	 * Perl 5 compiler
 	 */
 	private Perl5Compiler compiler = new Perl5Compiler();
 
 	/**
 	 * Regular expression pattern
 	 */
 	private Pattern[] regexpPattern = null;
 
 	/**
 	 * Perl 5 matcher
 	 */
 	private Perl5Matcher eventMatcher = new Perl5Matcher();
 
 	/**
 	 * Expression rule
 	 */
 	private Rule expressionRule;
 
 	/**
 	 * Map of current events
 	 */
 	private final Map currentMap = new HashMap();
 
 	/**
 	 * List of additional lines
 	 */
 	private final List additionalLines = new ArrayList();
 
 	/**
 	 * Regular expression to match
 	 */
 	private String regexp;
 
 	/**
 	 * Greedy keywords
 	 */
 	private Set greedyKeywords = new HashSet();
 
 	/**
 	 * Time stamp pattern
 	 */
 	private String timestampPatternText;
 
 	/**
 	 * ReceiverFormat which will be used for parsing the data.
 	 */
 	private ReceiverFormat[] receiverFormat = null;
 
 	/**
 	 * Source path of the Local File.
 	 */
 	private String sourceString = null;
 
 	/**
 	 * The namespace to be associated to events generated by this class
 	 */
 	private LogNamespace logNamespace = null;
 	
 	/**
 	 * Index of the last valid receiver format. Useful when processing the final log entry, if any
 	 */
 	private int lastValidReceiverFormatIndex = -1;
 
 	/**
 	 * Creates an Instace of this class using the specified ReceiverFormat and
 	 * Source String
 	 * 
 	 * @param logNamespace
 	 *            The namespace to use for this interpreter
 	 */
 	public LogInterpreter(LogNamespace logNamespace) {
 
 		this.receiverFormat = logNamespace.getReceiverFormat();
 		this.regexpPattern = new Pattern[receiverFormat.length];
 		this.sourceString = logNamespace.getSourceString();
 		this.logNamespace = logNamespace;
 		this.matchingKeywords = new List[receiverFormat.length];
 		this.dateFormat = new SimpleDateFormat[receiverFormat.length];
 
 		keywords.add(TIMESTAMP);
 		keywords.add(LOGGER);
 		keywords.add(LEVEL);
 		keywords.add(THREAD);
 		keywords.add(CLASS);
 		keywords.add(FILE);
 		keywords.add(LINE);
 		keywords.add(METHOD);
 		keywords.add(MESSAGE);
 		keywords.add(NDC);
 		keywords.add(RELATIVETIME);
 
 		greedyKeywords.add(MESSAGE);
 
 		initializePatternParsing();
 
 	}
 
 	/**
 	 * This method tries to convert a line to Log event. A single line can be
 	 * interpreted as multiple log events , so it returns an array of Log
 	 * Events.
 	 * 
 	 * @param line
 	 *            Line which needs to be converted to LogEvent.
 	 * @return Array of Log Events.
 	 */
 	public LogEvent[] parseLogMessage(String line) {
 
 		if (line == null) {
 			// process last event if one exists
 			LogEvent event = buildEvent(lastValidReceiverFormatIndex);
 			if (event != null) {
 				if (passesExpression(event)) {
 					LogEvent[] lastEvent = new LogEvent[1];
 					lastEvent[0] = event;
 					return lastEvent;
 				}
 			} 
 			return new LogEvent[0];
 		}
 		// LoggingEvent[] events = null;
 		ArrayList eventsList = new ArrayList();
 		// variable for identifying the receiver format that matches the line
 		// from logfile
 		int validReceiverFormat = -1;
 		boolean isValidRegexpPattern = false;
 		for (int i = 0; i < regexpPattern.length; i++) {
 			if (eventMatcher.matches(line, regexpPattern[i])) {
 				validReceiverFormat = i;
 				this.lastValidReceiverFormatIndex = validReceiverFormat;
 				LogEvent event = buildEvent(validReceiverFormat);
 				if (event != null) {
 					if (passesExpression(event)) {
 						eventsList.add(event);
 					}
 				} 
 				currentMap.putAll(processEvent(eventMatcher.getMatch(),
 						validReceiverFormat));
 				isValidRegexpPattern = true;
 				break;
 			}
 			validReceiverFormat = -1;
 		}
 		if (!isValidRegexpPattern) {
 			// may be an exception or additional message lines
 			additionalLines.add(line);
 			// if unmatched line count exceeds the specified max, clear the list
 			// to avoid
 			// a java.lang.OutOfMemoryError
 			if (additionalLines.size() > MAX_UNMATCHED_LINE_COUNT) {
 				additionalLines.clear();
 			}
 		}		
 		return (LogEvent[]) eventsList.toArray(new LogEvent[0]);
 	}
 
 	/**
 	 * Walk the additionalLines list, looking for the EXCEPTION_PATTERN.
 	 * <p>
 	 * Return the index of the first matched line minus 1 (the match is the 2nd
 	 * line of an exception)
 	 * <p>
 	 * Assumptions: <br> - the additionalLines list may contain both message and
 	 * exception lines<br> - message lines are added to the additionalLines
 	 * list and then exception lines (all message lines occur in the list prior
 	 * to all exception lines)
 	 * 
 	 * @return -1 if no exception line exists, line number otherwise
 	 */
 	private int getExceptionLine() {
 
 		try {
 			Pattern exceptionPattern = exceptionCompiler
 					.compile(EXCEPTION_PATTERN);
 			for (int i = 0; i < additionalLines.size(); i++) {
 				if (exceptionMatcher.matches((String) additionalLines.get(i),
 						exceptionPattern)) {
 					return i - 1;
 				}
 			}
 		} catch (MalformedPatternException mpe) {
 			mpe.printStackTrace();
 		}
 		return -1;
 	}
 
 	/**
 	 * Combine all message lines occuring in the additionalLines list, adding a
 	 * newline character between each line
 	 * <p>
 	 * the event will already have a message - combine this message with the
 	 * message lines in the additionalLines list (all entries prior to the
 	 * exceptionLine index)
 	 * 
 	 * @param firstMessageLine
 	 *            primary message line
 	 * @param exceptionLine
 	 *            index of first exception line
 	 * @return message
 	 */
 	private String buildMessage(String firstMessageLine, int exceptionLine) {
 
 		if (additionalLines.size() == 0 || exceptionLine == 0) {
 			return firstMessageLine;
 		}
 		StringBuffer message = new StringBuffer(firstMessageLine);
 		int linesToProcess = (exceptionLine == -1 ? additionalLines.size()
 				: exceptionLine);
 
 		for (int i = 0; i < linesToProcess; i++) {
 			message.append(newLine);
 			message.append(additionalLines.get(i));
 		}
 		return message.toString();
 	}
 
 	/**
 	 * Combine all exception lines occuring in the additionalLines list into a
 	 * String array
 	 * <p>
 	 * (all entries equal to or greater than the exceptionLine index)
 	 * 
 	 * @param exceptionLine
 	 *            index of first exception line
 	 * @return exception
 	 */
 	private String[] buildException(int exceptionLine) {
 
 		if (exceptionLine == -1) {
 			return emptyException;
 		}
 		String[] exception = new String[additionalLines.size() - exceptionLine];
 		for (int i = 0; i < additionalLines.size() - exceptionLine; i++) {
 			exception[i] = (String) additionalLines.get(i + exceptionLine);
 		}
 		return exception;
 	}
 
 	/**
 	 * Construct a logging event from currentMap and additionalLines
 	 * (additionalLines contains multiple message lines and any exception lines)
 	 * <p>
 	 * CurrentMap and additionalLines are cleared in the process
 	 * 
 	 * @param validReceiverFormat
 	 *            The receiverFormat from which the event has to be made.
 	 * @return event
 	 */
 	private LogEvent buildEvent(int validReceiverFormat) {
 
 		LogEvent event = null;
 
 		if (currentMap.size() == 0) {
 			return event;
 		}
 		int exceptionLine = getExceptionLine();
 		String[] exception = buildException(exceptionLine);
 
 		// messages are listed before exceptions in additionallines
 		if (additionalLines.size() > 0 && exceptionLine != 0) {
 			currentMap.put(MESSAGE, buildMessage((String) currentMap
 					.get(MESSAGE), exceptionLine));
 		}
 
 		if (currentMap.size() > 0) {
 			event = convertToEvent(currentMap, exception, validReceiverFormat);
 		}
 		this.currentMap.clear();
 		this.additionalLines.clear();
 
 		return event;
 	}
 
 	/**
 	 * Helper method that supports the evaluation of the expression
 	 * 
 	 * @param event
 	 * @return true if expression isn't set, or the result of the evaluation
 	 *         otherwise
 	 */
 	private boolean passesExpression(LogEvent event) {
 
 		if (event != null) {
 			if (expressionRule != null) {
 				return (expressionRule.evaluate(event));
 			}
 		}
 		return true;
 	}
 
 	/**
 	 * Convert the ORO match into a map.
 	 * <p>
 	 * Relies on the fact that the matchingKeywords list is in the same order as
 	 * the groups in the regular expression
 	 * 
 	 * @param result
 	 * @param validReceiverFormat
 	 *            The receiverFormat that matches the parsed line.
 	 * @return map
 	 */
 	private Map processEvent(MatchResult result, int validReceiverFormat) {
 
 		Map map = new HashMap();
 		// group zero is the entire match - process all other groups
 		for (int i = 1; i < result.groups(); i++) {
 			map.put(matchingKeywords[validReceiverFormat].get(i - 1), result
 					.group(i));
 		}
 		return map;
 	}
 
 	/**
 	 * Helper method that will convert timestamp format to a pattern
 	 * 
 	 * @return string
 	 */
 	private String convertTimestamp(ReceiverFormat receiverFormat) {
 
 		String timestampFormat = receiverFormat.getTimeStampPattern() == null ? TIMESTAMP_FORMAT
 				: receiverFormat.getTimeStampPattern();
 		return util.substitute("s/" + VALID_DATEFORMAT_CHAR_PATTERN
 				+ "/\\\\w/g", timestampFormat);
 	}
 
 	/**
 	 * Build the regular expression needed to parse log entries
 	 */
 	private void initializePatternParsing() {
 		ReceiverFormat[] receiverFormat = this.getReceiverFormat();
 		for (int i = 0; i < receiverFormat.length; i++) {
 			String timestampFormat = receiverFormat[i].getTimeStampPattern() == null ? TIMESTAMP_FORMAT
 					: receiverFormat[i].getTimeStampPattern();
 			if (timestampFormat != null) {
 				dateFormat[i] = new SimpleDateFormat(timestampFormat);
 				timestampPatternText = convertTimestamp(receiverFormat[i]);
 			}
 			// this.interpretedEventCount = 0L;
 			try {
 				if (filterExpression != null) {
 					expressionRule = ExpressionRule.getRule(filterExpression);
 				}
 			} catch (Exception e) {
 				e.printStackTrace();
 			}
 
 			Map keywordMap = new TreeMap();
 
 			String newPattern = receiverFormat[i].getLogPattern();
 
 			/*
 			 * examine pattern, adding properties to an index-based map.
 			 * Replaces PROP(X) definitions in the pattern with the short
 			 * version X, so that the name can be used as the event property
 			 * later
 			 */
 			int index = 0;
 			String current = newPattern;
 			while (index > -1) {
 				index = current.indexOf(PROP_START);
 				if (index > -1) {
 					String currentProp = current.substring(current
 							.indexOf(PROP_START));
 					String prop = currentProp.substring(0, currentProp
 							.indexOf(PROP_END) + 1);
 					current = current
 							.substring(current.indexOf(currentProp) + 1);
 					String shortProp = prop.substring(PROP_START.length(), prop
 							.length() - 1);
 					keywordMap.put(new Integer(index), shortProp);
 					newPattern = replace(prop, shortProp, newPattern);
 				}
 			}
 
 			newPattern = replaceMetaChars(newPattern);
 			newPattern = replace(PATTERN_WILDCARD, REGEXP_DEFAULT_WILDCARD,
 					newPattern);
 
 			/*
 			 * we're using a treemap, so the index will be used as the key to
 			 * ensure keywords are ordered correctly examine pattern, adding
 			 * keywords to an index-based map patterns can contain only one of
 			 * these per entry...properties are the only 'keyword' that can
 			 * occur multiple times in an entry
 			 */
 			Iterator iter = keywords.iterator();
 			while (iter.hasNext()) {
 				String keyword = (String) iter.next();
 				int index2 = newPattern.indexOf(keyword);
 				if (index2 > -1) {
 					keywordMap.put(new Integer(index2), keyword);
 				}
 			}
 
 			// keywordMap should be ordered by index..add all values to a list
 			matchingKeywords[i] = new ArrayList();
 			matchingKeywords[i].addAll(keywordMap.values());
 
 			/*
 			 * iterate over the keywords found in the pattern and replace with
 			 * regexp group
 			 */
 			String currentPattern = newPattern;
 			Iterator iter2 = matchingKeywords[i].iterator();
 			while (iter2.hasNext()) {
 				String keyword = (String) iter2.next();
 				if (TIMESTAMP.equals(keyword)) {
 					currentPattern = replace(keyword, "("
 							+ timestampPatternText + ")", currentPattern);
 				} else {
 					currentPattern = replace(keyword, greedyKeywords
 							.contains(keyword) ? GREEDY_GROUP : DEFAULT_GROUP,
 							currentPattern);
 				}
 			}
 			this.regexp = currentPattern;
 			try {
 				this.regexpPattern[i] = compiler.compile(regexp);
 			} catch (MalformedPatternException mpe) {
 				throw new RuntimeException("Bad pattern: " + regexp);
 			}
 		}
 	}
 
 	/**
 	 * Helper method that will globally replace a section of text
 	 * 
 	 * @param pattern
 	 * @param replacement
 	 * @param input
 	 * @return string
 	 */
 	private String replace(String pattern, String replacement, String input) {
 
 		return util.substitute("s/" + Perl5Compiler.quotemeta(pattern) + "/"
 				+ Perl5Compiler.quotemeta(replacement) + "/g", input);
 	}
 
 	/**
 	 * Some perl5 characters may occur in the log file format. Escape these
 	 * characters to prevent parsing errors.
 	 * 
 	 * @param input
 	 * @return string
 	 */
 	private String replaceMetaChars(String input) {
 
 		input = replace("(", "\\(", input);
 		input = replace(")", "\\)", input);
 		input = replace("[", "\\[", input);
 		input = replace("]", "\\]", input);
 		input = replace("{", "\\{", input);
 		input = replace("}", "\\}", input);
 		input = replace("#", "\\#", input);
 		return input;
 	}
 
 	/**
 	 * Convert a keyword-to-values map to a LoggingEvent
 	 * 
 	 * @param fieldMap
 	 * @param exception
 	 * @param validReceiverFormat
 	 *            The receiver format that matches the parsed line
 	 * @return logging event
 	 */
 	private LogEvent convertToEvent(Map fieldMap, String[] exception,
 			int validReceiverFormat) {
 
 		if (fieldMap == null) {
 			return null;
 		}
 
 		// a logger must exist at a minimum for the event to be processed
 		if (!fieldMap.containsKey(LOGGER)) {
 			fieldMap.put(LOGGER, "Unknown");
 		}
 		if (exception == null) {
 			exception = emptyException;
 		}
 
 		Logger logger = null;
 		long timeStamp = 0L;
 		long relativeTime = 0L;
 		String level = null;
 		String threadName = null;
 		Object message = null;
 		String ndc = null;
 		String className = null;
 		String methodName = null;
 		String eventFileName = null;
 		String lineNumber = null;
 		Hashtable properties = new Hashtable();
 
 		logger = Logger.getLogger((String) fieldMap.remove(LOGGER));
 
 		if ((dateFormat != null) && fieldMap.containsKey(TIMESTAMP)) {
 			try {
 				// trim the timestamp string to avoid errors because of spaces
 				timeStamp = dateFormat[validReceiverFormat].parse(
 						((String) fieldMap.remove(TIMESTAMP)).trim()).getTime();
 			} catch (Exception e) {
 				e.printStackTrace();
 			}
 		}
 
 		if (fieldMap.containsKey(RELATIVETIME)) {
 			// trim the relativetime string to avoid errors because of spaces
 			relativeTime = Long.parseLong(((String) fieldMap
 					.remove(RELATIVETIME)).trim());
 		}
 
 		if (fieldMap.containsKey(LEVEL)) {
 			level = (String) fieldMap.remove(LEVEL);
 			// trim the level string to avoid errors because of spaces
 		} else {
 			level = DEFAULT_LEVEL;
 		}
 		Level levelImpl = Level.toLevel(level.trim());
 
 		threadName = (String) fieldMap.remove(THREAD);
 		message = (String) fieldMap.remove(MESSAGE);
 		ndc = (String) fieldMap.remove(NDC);
 		className = (String) fieldMap.remove(CLASS);
 		methodName = (String) fieldMap.remove(METHOD);
 		eventFileName = (String) fieldMap.remove(FILE);
 		lineNumber = (String) fieldMap.remove(LINE);
 
 		properties.put(Constants.HOSTNAME_KEY, HOSTNAME_PROPERTY_VALUE);
 		properties.put(Constants.APPLICATION_KEY, this.getSourceString());
 
 		// all remaining entries in fieldmap are properties
 		properties.putAll(fieldMap);
 
 		LocationInfo info = null;
 
 		if ((eventFileName != null) || (className != null)
 				|| (methodName != null) || (lineNumber != null)) {
 			info = new LocationInfo(eventFileName, className, methodName,
 					lineNumber);
 		} else {
 			info = LocationInfo.NA_LOCATION_INFO;
 		}
 
 		/*
 		 * Construct the enhanced LogEvent object instead of the Apache
 		 * LoggingEvent in order to accomodate fields that were introduced later
 		 */
 
 		LogEvent event = new LogEvent();
 		event.setLogger(logger);
 		event.setTimeStamp(timeStamp);
 		event.setRelativeTime(relativeTime);
 		event.setLevel(levelImpl);
 		event.setMessage(message);
 		event.setThreadName(threadName);
 		event.setThrowableInformation(new ThrowableInformation(exception));
 		event.setLocationInformation(info);
 		event.setNDC(ndc);
 		event.setProperties(properties);
 		event.setNamespace(logNamespace);
 		return event;
 	}
 
 	/**
 	 * Sets the log namespace. This method is added to help the
 	 * <code>RemoteProtocolStreamReceiver</code> as it might receive the
 	 * startup message later than the first message from a source.
 	 * 
 	 * @param logNamespace
 	 */
 	public void setLogNamespace(LogNamespace logNamespace) {
 
 		this.logNamespace = logNamespace;
 	}
 
 	/**
 	 * @return Returns the receiverFormat.
 	 */
 	public ReceiverFormat[] getReceiverFormat() {
 
 		return receiverFormat;
 	}
 
 	/**
 	 * @return Returns the sourceString.
 	 */
 	public String getSourceString() {
 
 		return sourceString;
 	}
 		
 }