/*******************************************************************************
* Copyright (c) 2009, 2010 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.osgi.framework.debug;
import java.io.*;
import java.security.AccessController;
import java.text.MessageFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.eclipse.osgi.framework.util.SecureAction;
import org.eclipse.osgi.service.debug.DebugTrace;
/**
* The DebugTrace implementation for Eclipse.
*/
class EclipseDebugTrace implements DebugTrace {
/** The system property used to specify size a trace file can grow before it is rotated */
private static final String PROP_TRACE_SIZE_MAX = "eclipse.trace.size.max"; //$NON-NLS-1$
/** The system property used to specify the maximum number of backup trace files to use */
private static final String PROP_TRACE_FILE_MAX = "eclipse.trace.backup.max"; //$NON-NLS-1$
/** The trace message for a thread stack dump */
private final static String MESSAGE_THREAD_DUMP = "Thread Stack dump: "; //$NON-NLS-1$
/** The trace message for a method completing with a return value */
private final static String MESSAGE_EXIT_METHOD_WITH_RESULTS = "Exiting method {0}with result: "; //$NON-NLS-1$
/** The trace message for a method completing with no return value */
private final static String MESSAGE_EXIT_METHOD_NO_RESULTS = "Exiting method {0}with a void return"; //$NON-NLS-1$
/** The trace message for a method starting with a set of arguments */
private final static String MESSAGE_ENTER_METHOD_WITH_PARAMS = "Entering method {0}with parameters: ("; //$NON-NLS-1$
/** The trace message for a method starting with no arguments */
private final static String MESSAGE_ENTER_METHOD_NO_PARAMS = "Entering method {0}with no parameters"; //$NON-NLS-1$
/** The version attribute written in the header of a new session */
private final static String TRACE_FILE_VERSION_COMMENT = "version: "; //$NON-NLS-1$
/** The verbose attribute written in the header of a new session */
private final static String TRACE_FILE_VERBOSE_COMMENT = "verbose: "; //$NON-NLS-1$
/** The version value written in the header of a new session */
private final static String TRACE_FILE_VERSION = "1.1"; //$NON-NLS-1$
/** The new session identifier to be written whenever a new session starts */
private final static String TRACE_NEW_SESSION = "!SESSION "; //$NON-NLS-1$
/** The date attribute written to the header of the trace file to show when this file was created */
private final static String TRACE_FILE_DATE = "Time of creation: "; //$NON-NLS-1$
/** Trace date formatter using the pattern: yyyy-MM-dd HH:mm:ss.SSS */
private final static SimpleDateFormat TRACE_FILE_DATE_FORMATTER = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS"); //$NON-NLS-1$
/** The comment character used by the trace file */
private final static String TRACE_COMMENT = "#"; //$NON-NLS-1$
/** The delimiter used to separate trace elements such as the time stamp, message, etc */
private final static String TRACE_ELEMENT_DELIMITER = "|"; //$NON-NLS-1$
/** The string written in place of the {@link EclipseDebugTrace#TRACE_TRACE_ELEMENT_DELIMITER} in entries */
private final static String TRACE_ELEMENT_DELIMITER_ENCODED = "|"; //$NON-NLS-1$
/** OS-specific line separator */
private static final String LINE_SEPARATOR;
static {
String s = System.getProperty("line.separator"); //$NON-NLS-1$
LINE_SEPARATOR = s == null ? "\n" : s; //$NON-NLS-1$
}
/** The value written to the trace file if a null object is being traced */
private final static String NULL_VALUE = "<null>"; //$NON-NLS-1$
/** */
private final static SecureAction secureAction = AccessController.doPrivileged(SecureAction.createSecureAction());
/** A lock object used to synchronize access to the trace file */
private final static Object writeLock = new Object();
/******************* Tracing file attributes **************************/
/** The default size a trace file can grow before it is rotated */
private static final int DEFAULT_TRACE_FILE_SIZE = 1000; // The value is in KB.
/** The default number of backup trace files */
private static final int DEFAULT_TRACE_FILES = 10;
/** The minimum size limit for trace file rotation */
private static final int DEFAULT_TRACE_FILE_MIN_SIZE = 10;
/** The extension used for log files */
private static final String TRACE_FILE_EXTENSION = ".trace"; //$NON-NLS-1$
/** The extension markup to use for backup log files*/
private static final String BACKUP_MARK = ".bak_"; //$NON-NLS-1$
/** The maximum size that a trace file should grow (0 = unlimited) */
private int maxTraceFileSize = DEFAULT_TRACE_FILE_SIZE; // The value is in KB.
/** The maximum number of trace files that should be saved */
private int maxTraceFiles = DEFAULT_TRACE_FILES;
/** The index of the currently backed-up trace file */
private int backupTraceFileIndex = 0;
/** An optional argument to specify the name of the class used by clients to trace messages. If no trace class is specified
* then the class calling this API is assumed to be the class being traced.
*/
private String traceClass = null;
/** The symbolic name of the bundle being traced */
private String bundleSymbolicName = null;
/** A flag to determine if the message being written is done to a new file (i.e. should the header information be written) */
static boolean newSession = true;
/** DebugOptions are used to determine if the specified bundle symbolic name + option-path has debugging enabled */
private FrameworkDebugOptions debugOptions = null;
/**
* Construct a new EclipseDebugTrace for the specified bundle symbolic name and write messages to the specified
* trace file. The DebugOptions object will be used to determine if tracing should occur.
*
* @param bundleSymbolicName The symbolic name of the bundle being traced
* @param debugOptions Used to determine if the specified bundle symbolic name + option-path has tracing enabled
*/
EclipseDebugTrace(final String bundleSymbolicName, final FrameworkDebugOptions debugOptions) {
this(bundleSymbolicName, debugOptions, null);
}
/**
* Construct a new EclipseDebugTrace for the specified bundle symbolic name and write messages to the specified
* trace file.
*
* @param bundleSymbolicName The symbolic name of the bundle being traced
* @param debugOptions Used to determine if the specified bundle symbolic name + option-path has tracing enabled
* @param traceClass The class that the client is using to perform trace API calls
*/
EclipseDebugTrace(final String bundleSymbolicName, final FrameworkDebugOptions debugOptions, final Class<?> traceClass) {
this.traceClass = traceClass != null ? traceClass.getName() : null;
this.debugOptions = debugOptions;
this.bundleSymbolicName = bundleSymbolicName;
readLogProperties();
}
/**
* Is debugging enabled for the specified option-path
*
* @param optionPath The <i>option-path</i>
* @return Returns true if debugging is enabled for the specified option-path on this bundle; Otherwise false.
*/
private final boolean isDebuggingEnabled(final String optionPath) {
if (optionPath == null)
return true;
boolean debugEnabled = false;
if (debugOptions.isDebugEnabled()) {
final String option = bundleSymbolicName + optionPath;
debugEnabled = debugOptions.getBooleanOption(option, false);
}
return debugEnabled;
}
/*
* (non-Javadoc)
* @see org.eclipse.osgi.framework.debug.FrameworkDebugTrace#trace(java.lang.String, java.lang.String)
*/
public void trace(final String optionPath, final String message) {
if (isDebuggingEnabled(optionPath)) {
final FrameworkDebugTraceEntry record = new FrameworkDebugTraceEntry(bundleSymbolicName, optionPath, message, traceClass);
writeRecord(record);
}
}
/*
* (non-Javadoc)
* @see org.eclipse.osgi.framework.debug.FrameworkDebugTrace#trace(java.lang.String, java.lang.String, java.lang.Throwable)
*/
public void trace(final String optionPath, final String message, final Throwable error) {
if (isDebuggingEnabled(optionPath)) {
final FrameworkDebugTraceEntry record = new FrameworkDebugTraceEntry(bundleSymbolicName, optionPath, message, error, traceClass);
writeRecord(record);
}
}
/*
* (non-Javadoc)
* @see org.eclipse.osgi.framework.debug.FrameworkDebugTrace#traceEntry(java.lang.String)
*/
public void traceEntry(final String optionPath) {
if (isDebuggingEnabled(optionPath)) {
final FrameworkDebugTraceEntry record = new FrameworkDebugTraceEntry(bundleSymbolicName, optionPath, null, traceClass);
setMessage(record, EclipseDebugTrace.MESSAGE_ENTER_METHOD_NO_PARAMS);
writeRecord(record);
}
}
/*
* (non-Javadoc)
* @see org.eclipse.osgi.framework.debug.FrameworkDebugTrace#traceEntry(java.lang.String, java.lang.Object)
*/
public void traceEntry(final String optionPath, final Object methodArgument) {
if (isDebuggingEnabled(optionPath)) {
traceEntry(optionPath, new Object[] {methodArgument});
}
}
/*
* (non-Javadoc)
* @see org.eclipse.osgi.framework.debug.FrameworkDebugTrace#traceEntry(java.lang.String, java.lang.Object[])
*/
public void traceEntry(final String optionPath, final Object[] methodArguments) {
if (isDebuggingEnabled(optionPath)) {
final StringBuffer messageBuffer = new StringBuffer(EclipseDebugTrace.MESSAGE_ENTER_METHOD_WITH_PARAMS);
if (methodArguments != null) {
int i = 0;
while (i < methodArguments.length) {
if (methodArguments[i] != null) {
messageBuffer.append(methodArguments[i].toString());
} else {
messageBuffer.append(EclipseDebugTrace.NULL_VALUE);
}
i++;
if (i < methodArguments.length) {
messageBuffer.append(" "); //$NON-NLS-1$
}
}
messageBuffer.append(")"); //$NON-NLS-1$
}
final FrameworkDebugTraceEntry record = new FrameworkDebugTraceEntry(bundleSymbolicName, optionPath, null, traceClass);
setMessage(record, messageBuffer.toString());
writeRecord(record);
}
}
/*
* (non-Javadoc)
* @see org.eclipse.osgi.framework.debug.FrameworkDebugTrace#traceExit(java.lang.String)
*/
public void traceExit(final String optionPath) {
if (isDebuggingEnabled(optionPath)) {
final FrameworkDebugTraceEntry record = new FrameworkDebugTraceEntry(bundleSymbolicName, optionPath, null, traceClass);
setMessage(record, EclipseDebugTrace.MESSAGE_EXIT_METHOD_NO_RESULTS);
writeRecord(record);
}
}
/*
* (non-Javadoc)
* @see org.eclipse.osgi.framework.debug.FrameworkDebugTrace#traceExit(java.lang.String, java.lang.Object)
*/
public void traceExit(final String optionPath, final Object result) {
if (isDebuggingEnabled(optionPath)) {
final StringBuffer messageBuffer = new StringBuffer(EclipseDebugTrace.MESSAGE_EXIT_METHOD_WITH_RESULTS);
if (result == null) {
messageBuffer.append(EclipseDebugTrace.NULL_VALUE);
} else {
messageBuffer.append(result.toString());
}
final FrameworkDebugTraceEntry record = new FrameworkDebugTraceEntry(bundleSymbolicName, optionPath, null, traceClass);
setMessage(record, messageBuffer.toString());
writeRecord(record);
}
}
/*
* (non-Javadoc)
* @see org.eclipse.osgi.framework.debug.FrameworkDebugTrace#traceDumpStack(java.lang.String)
*/
public void traceDumpStack(final String optionPath) {
if (isDebuggingEnabled(optionPath)) {
final StringBuffer messageBuffer = new StringBuffer(EclipseDebugTrace.MESSAGE_THREAD_DUMP);
StackTraceElement[] elements = new Exception().getStackTrace();
// the first element in this stack trace is going to be this class, so ignore it
// the second element in this stack trace is going to either be the caller or the trace class. Ignore it only if a traceClass is defined
// the rest of the elements should be included in the file array
int firstIndex = (traceClass == null) ? 1 : 2;
int endIndex = elements.length - firstIndex;
final StackTraceElement[] newElements = new StackTraceElement[endIndex];
int i = 0;
while (i < endIndex) {
newElements[i] = elements[firstIndex];
i++;
firstIndex++;
}
messageBuffer.append(convertStackTraceElementsToString(newElements));
final FrameworkDebugTraceEntry record = new FrameworkDebugTraceEntry(bundleSymbolicName, optionPath, messageBuffer.toString(), traceClass);
writeRecord(record);
}
}
/**
* Set the trace message for the specified record to include class and method information
* if verbose debugging is disabled.
*
* @param record The {@link FrameworkDebugTraceEntry} containing the information to persist to the trace file.
* @param originalMessage The original tracing message
*/
private final void setMessage(final FrameworkDebugTraceEntry record, final String originalMessage) {
String argument = null;
if (!debugOptions.isVerbose()) {
final StringBuffer classMethodName = new StringBuffer(record.getClassName());
classMethodName.append("#"); //$NON-NLS-1$
classMethodName.append(record.getMethodName());
classMethodName.append(" "); //$NON-NLS-1$
argument = classMethodName.toString();
} else {
argument = ""; //$NON-NLS-1$
}
String newMessage = MessageFormat.format(originalMessage, new Object[] {argument});
record.setMessage(newMessage);
}
/**
* Utility method to convert an array of StackTraceElement objects to form a String representation of a stack dump
*
* @param elements
* The array of StackTraceElement objects
* @return A String of the stack dump produced by the list of elements
*/
private final String convertStackTraceElementsToString(final StackTraceElement[] elements) {
final StringBuffer buffer = new StringBuffer();
if (elements != null) {
buffer.append("java.lang.Throwable: "); //$NON-NLS-1$
buffer.append(EclipseDebugTrace.LINE_SEPARATOR);
int i = 0;
while (i < elements.length) {
if (elements[i] != null) {
buffer.append("\tat "); //$NON-NLS-1$
buffer.append(elements[i].toString());
buffer.append(EclipseDebugTrace.LINE_SEPARATOR);
}
i++;
}
}
return buffer.toString();
}
/**
* Write the specified FrameworkTraceEntry to trace file
*
* @param entry The FrameworkTraceEntry to write to the log file.
*/
private void writeRecord(final FrameworkDebugTraceEntry entry) {
if (entry != null) {
synchronized (EclipseDebugTrace.writeLock) {
final File tracingFile = debugOptions.getFile(); // the tracing file may be null if it has not been set
Writer traceWriter = null;
try {
// check to see if the file should be rotated
checkTraceFileSize(tracingFile, entry.getTimestamp());
// open the trace file
traceWriter = openWriter(tracingFile);
if (EclipseDebugTrace.newSession) {
writeSession(traceWriter, entry.getTimestamp());
EclipseDebugTrace.newSession = false;
}
writeMessage(traceWriter, entry);
// flush the writer
traceWriter.flush();
} catch (Exception ex) {
// any exceptions during tracing should be caught
System.err.println("An exception occurred while writing to the platform trace file: ");//$NON-NLS-1$
ex.printStackTrace(System.err);
} finally {
// close the trace writer
if (tracingFile != null) {
closeWriter(traceWriter);
}
}
}
}
}
/**
* Reads the PROP_TRACE_SIZE_MAX and PROP_TRACE_FILE_MAX properties.
*/
private void readLogProperties() {
String newMaxTraceFileSize = secureAction.getProperty(PROP_TRACE_SIZE_MAX);
if (newMaxTraceFileSize != null) {
maxTraceFileSize = Integer.parseInt(newMaxTraceFileSize);
if (maxTraceFileSize != 0 && maxTraceFileSize < DEFAULT_TRACE_FILE_MIN_SIZE) {
// If the value is '0', then it means no size limitation.
// Also, make sure no inappropriate(too small) assigned value.
maxTraceFileSize = DEFAULT_TRACE_FILE_MIN_SIZE;
}
}
String newMaxLogFiles = secureAction.getProperty(PROP_TRACE_FILE_MAX);
if (newMaxLogFiles != null) {
maxTraceFiles = Integer.parseInt(newMaxLogFiles);
if (maxTraceFiles < 1) {
// Make sure no invalid assigned value. (at least >= 1)
maxTraceFiles = DEFAULT_TRACE_FILES;
}
}
}
/**
* Checks the trace file size. If the file size reaches the limit then the trace file is rotated.
*
* @param traceFile The tracing file
* @param timestamp the timestamp for the session; this is the same timestamp as the first entry
* @return false if an error occurred trying to rotate the trace file
*/
private boolean checkTraceFileSize(final File traceFile, long timestamp) {
// 0 file size means there is no size limit
boolean isBackupOK = true;
if (maxTraceFileSize > 0) {
if ((traceFile != null) && traceFile.exists()) {
if ((traceFile.length() >> 10) > maxTraceFileSize) { // Use KB as file size unit.
final String traceFileName = traceFile.getAbsolutePath();
// Delete old backup file that will be replaced.
String backupFilename = ""; //$NON-NLS-1$
if (traceFileName.toLowerCase().endsWith(TRACE_FILE_EXTENSION)) {
backupFilename = traceFileName.substring(0, traceFileName.length() - TRACE_FILE_EXTENSION.length()) + BACKUP_MARK + backupTraceFileIndex + TRACE_FILE_EXTENSION;
} else {
backupFilename = traceFileName + BACKUP_MARK + backupTraceFileIndex;
}
final File backupFile = new File(backupFilename);
if (backupFile.exists()) {
if (!backupFile.delete()) {
System.err.println("Error when trying to delete old trace file: " + backupFile.getName());//$NON-NLS-1$
if (backupFile.renameTo(new File(backupFile.getAbsolutePath() + System.currentTimeMillis()))) {
System.err.println("So we rename it to filename: " + backupFile.getName()); //$NON-NLS-1$
} else {
System.err.println("And we also cannot rename it!"); //$NON-NLS-1$
isBackupOK = false;
}
}
}
// Rename current log file to backup one.
boolean isRenameOK = traceFile.renameTo(backupFile);
if (!isRenameOK) {
System.err.println("Error when trying to rename trace file to backup one."); //$NON-NLS-1$
isBackupOK = false;
}
/*
* Write a header to new log file stating that this new file is a continuation file.
* This method should already be called with the file lock set so we should be safe
* to update it here.
*/
Writer traceWriter = null;
try {
traceWriter = openWriter(traceFile);
writeComment(traceWriter, "This is a continuation of trace file " + backupFile.getAbsolutePath()); //$NON-NLS-1$
writeComment(traceWriter, EclipseDebugTrace.TRACE_FILE_VERSION_COMMENT + EclipseDebugTrace.TRACE_FILE_VERSION);
writeComment(traceWriter, EclipseDebugTrace.TRACE_FILE_VERBOSE_COMMENT + debugOptions.isVerbose());
writeComment(traceWriter, EclipseDebugTrace.TRACE_FILE_DATE + getFormattedDate(timestamp));
traceWriter.flush();
} catch (IOException ioEx) {
ioEx.printStackTrace();
} finally {
if (traceFile != null) {
closeWriter(traceWriter);
}
}
backupTraceFileIndex = (++backupTraceFileIndex) % maxTraceFiles;
}
}
}
return isBackupOK;
}
/**
* Writes a comment to the trace file
*
* @param traceWriter the trace writer
* @param comment the comment to be written to the trace file
* @throws IOException If an error occurs while writing the comment
*/
private void writeComment(final Writer traceWriter, final String comment) throws IOException {
StringBuffer commentText = new StringBuffer(EclipseDebugTrace.TRACE_COMMENT);
commentText.append(" "); //$NON-NLS-1$
commentText.append(comment);
commentText.append(EclipseDebugTrace.LINE_SEPARATOR);
traceWriter.write(commentText.toString());
}
/**
* Accessor to retrieve the time stamp in a formatted manner.
*
* @return A formatted time stamp based on the {@link EclipseDebugTrace#TRACE_FILE_DATE_FORMATTER} formatter
*/
private final String getFormattedDate(long timestamp) {
return EclipseDebugTrace.TRACE_FILE_DATE_FORMATTER.format(new Date(timestamp));
}
/**
* Accessor to retrieve the text of a {@link Throwable} in a formatted manner so that it can be written to the
* trace file.
*
* @param error The {@lnk Throwable} to format
* @return The complete text of a {@link Throwable} as a {@link String} or null if the input error is null.
*/
private final String getFormattedThrowable(Throwable error) {
String result = null;
if (error != null) {
PrintStream throwableStream = null;
try {
ByteArrayOutputStream throwableByteOutputStream = new ByteArrayOutputStream();
throwableStream = new PrintStream(throwableByteOutputStream, false);
error.printStackTrace(throwableStream);
result = encodeText(throwableByteOutputStream.toString());
} finally {
if (throwableStream != null) {
throwableStream.close();
}
}
}
return result;
}
/**
* Writes header information to a new trace file
*
* @param traceWriter the trace writer
* @param timestamp the timestamp for the session; this is the same timestamp as the first entry
* @throws IOException If an error occurs while writing this session information
*/
private void writeSession(final Writer traceWriter, long timestamp) throws IOException {
writeComment(traceWriter, EclipseDebugTrace.TRACE_NEW_SESSION + this.getFormattedDate(timestamp));
writeComment(traceWriter, EclipseDebugTrace.TRACE_FILE_VERSION_COMMENT + EclipseDebugTrace.TRACE_FILE_VERSION);
writeComment(traceWriter, EclipseDebugTrace.TRACE_FILE_VERBOSE_COMMENT + debugOptions.isVerbose());
writeComment(traceWriter, "The following option strings are specified for this debug session:"); //$NON-NLS-1$
final String[] allOptions = FrameworkDebugOptions.getDefault().getAllOptions();
for (int i = 0; i < allOptions.length; i++) {
writeComment(traceWriter, "\t" + allOptions[i]); //$NON-NLS-1$
}
}
/**
* Writes the specified trace entry object to the trace file using the
* {@link EclipseDebugTrace#TRACE_ELEMENT_DELIMITER} as the delimiter between
* each element of the entry.
*
* @param traceWriter the trace writer
* @param entry The trace entry object to write to the trace file
* @throws IOException If an error occurs while writing this message
*/
private void writeMessage(final Writer traceWriter, final FrameworkDebugTraceEntry entry) throws IOException {
final StringBuffer message = new StringBuffer(EclipseDebugTrace.TRACE_ELEMENT_DELIMITER);
message.append(" "); //$NON-NLS-1$
message.append(encodeText(entry.getThreadName()));
message.append(" "); //$NON-NLS-1$
message.append(EclipseDebugTrace.TRACE_ELEMENT_DELIMITER);
message.append(" "); //$NON-NLS-1$
message.append(this.getFormattedDate(entry.getTimestamp()));
message.append(" "); //$NON-NLS-1$
message.append(EclipseDebugTrace.TRACE_ELEMENT_DELIMITER);
message.append(" "); //$NON-NLS-1$
if (!debugOptions.isVerbose()) {
// format the trace entry for quiet tracing: only the thread name, timestamp, trace message, and exception (if necessary)
message.append(encodeText(entry.getMessage()));
} else {
// format the trace entry for verbose tracing
message.append(entry.getBundleSymbolicName());
message.append(" "); //$NON-NLS-1$
message.append(EclipseDebugTrace.TRACE_ELEMENT_DELIMITER);
message.append(" "); //$NON-NLS-1$
message.append(encodeText(entry.getOptionPath()));
message.append(" "); //$NON-NLS-1$
message.append(EclipseDebugTrace.TRACE_ELEMENT_DELIMITER);
message.append(" "); //$NON-NLS-1$
message.append(entry.getClassName());
message.append(" "); //$NON-NLS-1$
message.append(EclipseDebugTrace.TRACE_ELEMENT_DELIMITER);
message.append(" "); //$NON-NLS-1$
message.append(entry.getMethodName());
message.append(" "); //$NON-NLS-1$
message.append(EclipseDebugTrace.TRACE_ELEMENT_DELIMITER);
message.append(" "); //$NON-NLS-1$
message.append(entry.getLineNumber());
message.append(" "); //$NON-NLS-1$
message.append(EclipseDebugTrace.TRACE_ELEMENT_DELIMITER);
message.append(" "); //$NON-NLS-1$
message.append(encodeText(entry.getMessage()));
}
if (entry.getThrowable() != null) {
message.append(" "); //$NON-NLS-1$
message.append(EclipseDebugTrace.TRACE_ELEMENT_DELIMITER);
message.append(" "); //$NON-NLS-1$
message.append(this.getFormattedThrowable(entry.getThrowable()));
}
message.append(" "); //$NON-NLS-1$
message.append(EclipseDebugTrace.TRACE_ELEMENT_DELIMITER);
message.append(EclipseDebugTrace.LINE_SEPARATOR);
// write the message
if ((traceWriter != null) && (message != null)) {
traceWriter.write(message.toString());
}
}
/**
* Encodes the specified string to replace any occurrence of the {@link EclipseDebugTrace#TRACE_ELEMENT_DELIMITER}
* string with the {@link EclipseDebugTrace#TRACE_ELEMENT_DELIMITER_ENCODED}
* string. This can be used to ensure that the delimiter character does not break parsing when
* the entry text contains the delimiter character.
*
* @param inputString The original string to be written to the trace file.
* @return The original input string with all occurrences of
* {@link EclipseDebugTrace#TRACE_ELEMENT_DELIMITER} replaced with
* {@link EclipseDebugTrace#TRACE_ELEMENT_DELIMITER_ENCODED}. A <code>null</code> value will be
* returned if the input string is <code>null</code>.
*/
private static String encodeText(final String inputString) {
if (inputString == null || inputString.indexOf(TRACE_ELEMENT_DELIMITER) < 0)
return inputString;
final StringBuffer tempBuffer = new StringBuffer(inputString);
int currentIndex = tempBuffer.indexOf(TRACE_ELEMENT_DELIMITER);
while (currentIndex >= 0) {
tempBuffer.replace(currentIndex, currentIndex + TRACE_ELEMENT_DELIMITER.length(), TRACE_ELEMENT_DELIMITER_ENCODED);
currentIndex = tempBuffer.indexOf(TRACE_ELEMENT_DELIMITER);
}
return tempBuffer.toString();
}
/**
* Returns a Writer for the given OutputStream
* @param output an OutputStream to use for the Writer
* @return A Writer for the given OutputStream
*/
private Writer logForStream(OutputStream output) {
try {
return new BufferedWriter(new OutputStreamWriter(output, "UTF-8")); //$NON-NLS-1$
} catch (UnsupportedEncodingException e) {
return new BufferedWriter(new OutputStreamWriter(output));
}
}
/**
* Creates the trace writer.
* If the tracing file is null then the writer will use System.out to print any messages.
*
* @param traceFile The tracing file
* @return Returns a new Writer object
*/
private Writer openWriter(final File traceFile) {
Writer traceWriter = null;
if (traceFile != null) {
try {
traceWriter = logForStream(secureAction.getFileOutputStream(traceFile, true));
} catch (IOException ioEx) {
traceWriter = logForStream(System.out);
}
} else {
traceWriter = logForStream(System.out);
}
return traceWriter;
}
/**
* Close the trace writer
*
* @param traceWriter The trace writer
*/
private void closeWriter(Writer traceWriter) {
if (traceWriter != null) {
try {
traceWriter.close();
} catch (IOException ioEx) {
// we cannot log here; just print the stacktrace.
ioEx.printStackTrace();
}
traceWriter = null;
}
}
}