/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can obtain
* a copy of the License at https://glassfish.dev.java.net/public/CDDL+GPL.html
* or glassfish/bootstrap/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at glassfish/bootstrap/legal/LICENSE.txt.
* Sun designates this particular file as subject to the "Classpath" exception
* as provided by Sun in the GPL Version 2 section of the License file that
* accompanied this code. If applicable, add the following below the License
* Header, with the fields enclosed by brackets [] replaced by your own
* identifying information: "Portions Copyrighted [year]
* [name of copyright owner]"
*
* Contributor(s):
*
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*/
package com.sun.enterprise.util;
import java.util.StringTokenizer;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.PrintStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;
import java.io.PrintWriter;
/*
** Printing/Debug Utilities
**
** This Module contains replacements for various types of print statements used for
** debugging purposes.
** Example:
** Replace this
** System.out.println("test message");
** With this
** Print.println("test message");
** or
** Print.dprintln("test message");
** The advantage of using Print.println is that the message ("test message") can be
** pre-pended with the actual location of the print statement itself. For instance,
** Issuing a call to 'Print.dprintln("hello world")' may print a console message
** similar to the following:
** [MyCustomClass.doSomething:291] hello world
** This indicates that the 'Print.dprintln' is located in the method 'doSomething'
** in the class 'MyCustomClass' at source file line number 291. This will help
** show the precise location of various debug message print statements that should
** be removed prior to FCS. (Note: the package is remove from the class before
** printing the stack frame to avoid creating a print line which is excessively long)
**
** Difference between 'println' and 'dprintln':
** Each 'printXXX' method in this module has a corresponding 'dprintXXX' method.
** The 'dprintXXX' methods will only print their specified message if the System
** property "ri.debugMode" is true. Additionally, 'dprintXXX' methods will always
** prepend the location (stackframe) of the 'Print.dprintXXX' call.
** The 'printXXX' methods always print their specified message to the console.
** However, the default is to _not_ include the location (stackframe) of the print
** statement unless the System property "ri.print.showStackFrame" is true. The
** location of all print statements can then be exposed by setting this system
** property to true.
**
** Replacements:
** Old method New Method
** System.out.println("hello") => Print.println("hello")
** <Throwable>.printStackTrace() => Print.printStackTrace("Error", <Throwable>)
** Thread.dumpStack() => Print.printStackTrace("Stack Trace");
** if (debug) System.out.println("x") => Print.dprintln("x"); // not optimized
** if (debug) System.out.println("x") => if (debug) Print.println("x");
**
** To turn on debug mode (to allow 'dprintXXX' to print), include system property:
** -Dri.debugMode=true
**
** To turn have 'printXXX' methods print the stack frame location, include system property:
** -Dri.print.showStackFrame=true
**
** -----------------------------------------------------------------------------
** @author Martin D. Flynn
*/
public class Print
{
/* -------------------------------------------------------------------------
*/
/* System property keys */
public static final String SYSTEM_DEBUG_MODE = "ri.debugMode";
public static final String SYSTEM_STACK_FRAME = "ri.print.showStackFrame";
/* Throwable instance used to obtain stack information */
private static Throwable stackTrace = null;
/* by default the source file name is not printed in the location */
private static boolean showStackFrameSource = false;
/* -------------------------------------------------------------------------
*/
/* Set the debug mode
** @param specified debug state
*/
public static void setDebugMode(boolean state)
{
System.setProperty(SYSTEM_DEBUG_MODE, String.valueOf(state));
}
/* Return the current debug mode state
** @return debug state
*/
public static boolean isDebugMode()
{
return Boolean.getBoolean(SYSTEM_DEBUG_MODE);
}
/* -------------------------------------------------------------------------
*/
/* Set the state to force prepending the stack frame to 'print' statements
** @param specified printStackFrame state
*/
public static void setPrintStackFrame(boolean state)
{
System.setProperty(SYSTEM_STACK_FRAME, String.valueOf(state));
}
/* return the current state of including the stack frame in 'print' statements
** @return printStackFrame state
*/
public static boolean printStackFrame()
{
return Boolean.getBoolean(SYSTEM_STACK_FRAME);
}
/* -------------------------------------------------------------------------
*/
/* Set the state to include the module source file rather than the normal stack frame
** @param specified showStackFrameSource state
*/
public static void setShowStackFrameSource(boolean flag)
{
showStackFrameSource = flag;
}
/* -------------------------------------------------------------------------
*/
/* Return the specified StackTraceElement
** @return the @see java.lang.StackTraceElement for the specified stack frame
** @param the specified stack frame to retrieve.
*/
public static StackTraceElement getStackFrame(int frameNum)
{
if (stackTrace == null) { stackTrace = new Throwable(); }
stackTrace.fillInStackTrace();
return stackTrace.getStackTrace()[frameNum + 1];
}
/* Return the String form of the current StackTraceElement
** @return the @see java.lang.String version of the specified stack frame
** @param the specified stack frame to retrieve.
*/
public static String getStackFrameString(int frameNum)
{
return getStackFrameString(frameNum + 1, showStackFrameSource);
}
/* Return the String form of the current StackTraceElement
** @return the @see java.lang.String version of the specified stack frame
** @param the StackTraceElement to convert to a string.
*/
public static String getStackFrameString(StackTraceElement stackFrame)
{
return getStackFrameString(stackFrame, showStackFrameSource);
}
/* Return the String form of the current StackTraceElement
** @return the @see java.lang.String version of the specified stack frame
** @param the specified stack frame to retrieve.
** @param indicator whether the String should include the module source file name
*/
public static String getStackFrameString(int frameNum, boolean showSrc)
{
return getStackFrameString(getStackFrame(frameNum + 1), showSrc);
}
/* Return the String form of the current StackTraceElement
** @return the @see java.lang.String version of the specified stack frame
** @param the StackTraceElement to convert to a string.
** @param indicator whether the String should include the module source file name
*/
public static String getStackFrameString(StackTraceElement stackFrame, boolean showSrc)
{
StringBuffer sb = new StringBuffer();
if (showSrc) {
String s = stackFrame.getFileName();
if (s != null) {
int p = s.lastIndexOf(File.separator);
sb.append((p >= 0)? s.substring(p + 1) : s);
} else {
String c = stackFrame.getClassName();
int p = c.lastIndexOf(".");
sb.append("<").append((p >= 0)? c.substring(p + 1) : c).append(">");
}
} else {
String c = stackFrame.getClassName();
int p = c.lastIndexOf(".");
sb.append((p >= 0)? c.substring(p + 1) : c);
}
sb.append(".").append(stackFrame.getMethodName());
if (stackFrame.getLineNumber() >= 0) {
sb.append(":").append(stackFrame.getLineNumber());
}
return sb.toString();
}
/* -------------------------------------------------------------------------
*/
/* Internal print statement
** @param output @see java.io.PrintStream
** @param the stack frame location of the real 'print' statement.
** @param the message to print.
*/
protected static void _println(PrintStream out, int frameNum, String msg)
{
String m = (frameNum >= 0)? "[" + getStackFrameString(frameNum + 1) + "] " + msg : msg;
print(out, m + "\n");
}
/* -------------------------------------------------------------------------
*/
/* Print message to specified PrintStream (default to System.out)
** Does not include a linefeed at the end of the message.
** @param output @see java.io.PrintStream
** @param the message to print.
*/
public static void print(PrintStream out, String msg)
{
((out != null)? out : System.out).print(msg);
}
/* Print message to specified PrintStream (default to System.out)
** Prints message only if debugMode system property is true.
** Does not include a linefeed at the end of the message.
** @param output @see java.io.PrintStream
** @param the message to print.
*/
public static void dprint(PrintStream out, String msg)
{
if (isDebugMode()) {
print(out, msg);
}
}
/* Print message to specified System.out
** Does not include a linefeed at the end of the message.
** @param the message to print.
*/
public static void print(String msg)
{
print(null, msg);
}
/* Print message to specified System.out
** Prints message only if debugMode system property is true.
** Does not include a linefeed at the end of the message.
** @param the message to print.
*/
public static void dprint(String msg)
{
if (isDebugMode()) {
print(null, msg);
}
}
/* Print message to specified PrintStream (default to System.out)
** StackFrame information is included if the specified frame is >= 0, or if
** the showStackFrame system property is true. To force the stack frame info to
** print, set the frameNum to '0' [eg.' Print.println(null, 0, "This location");']
** Message is terminated with a linefeed
** @param output @see java.io.PrintStream
** @param the stack frame location of the real 'print' statement.
** @param the message to print.
*/
public static void println(PrintStream out, int frameNum, String msg)
{
int f = (frameNum >= 0)? (frameNum + 1) : (printStackFrame()? Math.abs(frameNum) : -1);
_println(out, f, msg);
}
/* Print message to specified PrintStream (default to System.out)
** Prints message only if debugMode system property is true.
** StackFrame information is included.
** Message is terminated with a linefeed
** @param output @see java.io.PrintStream
** @param the stack frame location of the real 'print' statement.
** @param the message to print.
*/
public static void dprintln(PrintStream out, int frameNum, String msg)
{
if (isDebugMode()) {
int f = (frameNum >= 0)? (frameNum + 1) : Math.abs(frameNum);
_println(out, f, msg);
}
}
/* Print message to System.out
** StackFrame information is included if the specified frame is >= 0, or if
** the showStackFrame system property is true. To force the stack frame info to
** print, set the frameNum to '0' [eg.' Print.println(0, "This location");']
** Message is terminated with a linefeed
** @param the stack frame location of the real 'print' statement.
** @param the message to print.
*/
public static void println(int frameNum, String msg)
{
int f = (frameNum >= 0)? (frameNum + 1) : (printStackFrame()? Math.abs(frameNum) : -1);
_println(null, f, msg);
}
/* Print message to System.out
** Prints message only if debugMode system property is true.
** StackFrame information is included.
** Message is terminated with a linefeed
** @param the stack frame location of the real 'print' statement.
** @param the message to print.
*/
public static void dprintln(int frameNum, String msg)
{
if (isDebugMode()) {
int f = (frameNum >= 0)? (frameNum + 1) : Math.abs(frameNum);
_println(null, f, msg);
}
}
/* Print message to specified PrintStream (default to System.out)
** StackFrame information is included if the showStackFrame system property is true.
** Message is terminated with a linefeed
** @param output @see java.io.PrintStream
** @param the message to print.
*/
public static void println(PrintStream out, String msg)
{
_println(out, (printStackFrame()? 1 : -1), msg);
}
/* Print message to specified PrintStream (default to System.out)
** Prints message only if debugMode system property is true.
** StackFrame information is included.
** Message is terminated with a linefeed
** @param output @see java.io.PrintStream
** @param the message to print.
*/
public static void dprintln(PrintStream out, String msg)
{
if (isDebugMode()) {
_println(out, 1, msg);
}
}
/* Print message to System.out
** StackFrame information is included if the showStackFrame system property is true.
** Message is terminated with a linefeed
** @param the message to print.
*/
public static void println(String msg)
{
_println(null, (printStackFrame()? 1 : -1), msg);
}
/* Print message to System.out
** Prints message only if debugMode system property is true.
** StackFrame information is included.
** Message is terminated with a linefeed
** @param the message to print.
*/
public static void dprintln(String msg)
{
if (isDebugMode()) {
_println(null, 1, msg);
}
}
/* -------------------------------------------------------------------------
*/
private static PrintStream printStackTrace_Stream = null;
private static File printStackTrace_LogFile = null;
/* Set default output file for logging stack traces (logging defaults to System.out)
** @param the output file to log stack traces
*/
public static void setStackTraceLogFile(File logFile)
{
/* close old log file */
if (printStackTrace_Stream != null) {
printStackTrace_Stream.close();
printStackTrace_Stream = null;
printStackTrace_LogFile = null;
}
/* open new log file */
if ((logFile != null) && logFile.isAbsolute()) {
try {
printStackTrace_Stream = new PrintStream(new FileOutputStream(logFile), true);
printStackTrace_LogFile = logFile;
} catch (IOException ioe) {
Print.println(0, "Unable to open StackTrace log file: " + logFile);
}
}
}
/* Format and print stack trace information
** @param output @see java.io.PrintStream
** @param the stack frame location of the real 'print' statement.
** @param the title of the stack trace.
** @param the message to print.
** @param the Throwable containing the stack trace to print.
*/
private static void _printStackTrace(PrintStream out, int frame, String title, String msg, Throwable excp)
{
/* header vars */
final String _dash = "----------------------------------------"; // 40
final String dashLine = _dash + _dash + "\n"; // 80
final String _ttl = " " + title + " ";
final String errTitle = dashLine.substring(0, 16) + _ttl + dashLine.substring(16 + _ttl.length());
/* default PrintStream */
if (out == null) {
out = System.out;
}
/* header */
Print.print(out, "\n");
Print.print(out, dashLine + errTitle);
Print.print(out, "[" + Print.getStackFrameString(frame + 1) + "]\n");
if ((msg != null) && !msg.equals("")) { Print.print(out, msg + "\n"); }
/* stack trace */
if (excp != null) {
Print.print(out, excp.toString() + "\n");
Print.print(out, dashLine);
excp.printStackTrace(out);
} else {
Print.print(out, dashLine);
Print.print(out, "Stack Trace:\n");
Throwable t = new Throwable();
t.fillInStackTrace();
ByteArrayOutputStream bos = new ByteArrayOutputStream();
PrintStream ps = new PrintStream(bos);
t.printStackTrace(ps);
StringTokenizer st = new StringTokenizer(bos.toString(), "\n");
st.nextToken(); // "java.lang.Throwable"
for (int i = 0; i < frame + 1; i++) { st.nextToken(); } // discard superfluous stack frames
for (;st.hasMoreTokens();) { Print.println(out, st.nextToken()); }
}
/* final dashed line */
Print.print(out, dashLine);
Print.print(out, "\n");
}
/* Print stack trace information to specified PrintStream.
** @param output @see java.io.PrintStream
** @param the stack frame location of the real 'print' statement.
** @param the title of the stack trace.
** @param the message to print.
** @param the Throwable containing the stack trace to print.
*/
public static void printStackTrace(PrintStream out, int frame, String title, String msg, Throwable excp)
{
if (out == null) { out = printStackTrace_Stream; }
if ((out != null) && (out != System.out) && (out != System.err)) {
Print.print("\n");
if (excp != null) {
String m = ((msg != null) && !msg.equals(""))? (msg + " - ") : "";
Print.println(null, frame + 1, "Error: " + m + excp + "");
StackTraceElement ste[] = excp.getStackTrace();
if (ste.length > 0) {
Print.print(" ==> at " + getStackFrameString(ste[0]) + "\n");
}
} else {
Print.println(null, frame + 1, msg);
}
if (printStackTrace_LogFile != null) {
Print.print("(Stack trace logged to '" + printStackTrace_LogFile + "')\n");
}
Print.print("\n");
}
_printStackTrace(out, frame + 1, title, msg, excp);
}
/* Print stack trace information to specified PrintStream.
** Prints stack trace only if debugMode system property is true.
** @param output @see java.io.PrintStream
** @param the stack frame location of the real 'print' statement.
** @param the title of the stack trace.
** @param the message to print.
** @param the Throwable containing the stack trace to print.
*/
public static void dprintStackTrace(PrintStream out, int frame, String title, String msg, Throwable excp)
{
if (isDebugMode()) {
if (out == null) { out = printStackTrace_Stream; }
if ((out != null) && (out != System.out) && (out != System.err)) {
String m = (excp != null)? (msg + " (" + excp + ")") : msg;
Print.println(null, frame + 1, "{log} " + m);
}
_printStackTrace(out, frame + 1, title, msg, excp);
}
}
/* Print stack trace information to default PrintStream.
** @param the title of the stack trace.
** @param the message to print.
** @param the Throwable containing the stack trace to print.
*/
public static void printStackTrace(String title, String msg, Throwable excp)
{
printStackTrace(null, 1, title, msg, excp);
}
/* Print stack trace information to default PrintStream.
** Prints stack trace only if debugMode system property is true.
** @param the title of the stack trace.
** @param the message to print.
** @param the Throwable containing the stack trace to print.
*/
public static void dprintStackTrace(String title, String msg, Throwable excp)
{
if (isDebugMode()) {
dprintStackTrace(null, 1, title, msg, excp);
}
}
/* Print stack trace information to default PrintStream.
** Use this method instead of '<Throwable>.printStackTrace'
** @param the message to print.
** @param the Throwable containing the stack trace to print.
*/
public static void printStackTrace(String msg, Throwable excp)
{
String title = (excp != null)? "Exception" : "StackTrace";
printStackTrace(null, 1, title, msg, excp);
}
/* Print stack trace information to default PrintStream.
** Prints stack trace only if debugMode system property is true.
** Use this method instead of '<Throwable>.printStackTrace'
** @param the message to print.
** @param the Throwable containing the stack trace to print.
*/
public static void dprintStackTrace(String msg, Throwable excp)
{
if (isDebugMode()) {
String title = (excp != null)? "(DEBUG) Exception" : "(DEBUG) StackTrace";
dprintStackTrace(null, 1, title, msg, excp);
}
}
/* Print stack trace information to default PrintStream.
** Use this method instead of 'Thread.dumpStack'
** @param the message to print.
*/
public static void printStackTrace(String msg)
{
printStackTrace(null, 1, "StackTrace", msg, null);
}
/* Print stack trace information to default PrintStream.
** Prints stack trace only if debugMode system property is true.
** Use this method instead of 'Thread.dumpStack'
** @param the message to print.
*/
public static void dprintStackTrace(String msg)
{
if (isDebugMode()) {
dprintStackTrace(null, 1, "(DEBUG) StackTrace", msg, null);
}
}
/* Print stack trace information to default PrintStream.
** Allows specifying frame
** @param the stack frame to print.
** @param the message to print.
*/
public static void printStackTrace(int frame, String msg)
{
printStackTrace(null, frame + 1, "StackTrace", msg, null);
}
/* Print stack trace information to default PrintStream.
** Prints stack trace only if debugMode system property is true.
** Allows specifying frame
** @param the stack frame to print.
** @param the message to print.
*/
public static void dprintStackTrace(int frame, String msg)
{
if (isDebugMode()) {
dprintStackTrace(null, frame + 1, "(DEBUG) StackTrace", msg, null);
}
}
public static String printStackTraceToString()
{
Throwable t = new Throwable("printStackTraceToString");
t.fillInStackTrace();
StringWriter stringWriter = new StringWriter();
PrintWriter printWriter = new PrintWriter(stringWriter);
t.printStackTrace(printWriter);
String stackTrace = stringWriter.toString();
printWriter.close();
return stackTrace;
}
}
|
