/*
|
* CDDL HEADER START
|
*
|
* The contents of this file are subject to the terms of the
|
* Common Development and Distribution License, Version 1.0 only
|
* (the "License"). You may not use this file except in compliance
|
* with the License.
|
*
|
* You can obtain a copy of the license at
|
* trunk/opends/resource/legal-notices/OpenDS.LICENSE
|
* or https://OpenDS.dev.java.net/OpenDS.LICENSE.
|
* See the License for the specific language governing permissions
|
* and limitations under the License.
|
*
|
* When distributing Covered Code, include this CDDL HEADER in each
|
* file and include the License file at
|
* trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable,
|
* add the following below this CDDL HEADER, with the fields enclosed
|
* by brackets "[]" replaced with your own identifying * information:
|
* Portions Copyright [yyyy] [name of copyright owner]
|
*
|
* CDDL HEADER END
|
*
|
*
|
* Portions Copyright 2006 Sun Microsystems, Inc.
|
*/
|
package org.opends.server.loggers;
|
|
|
|
import java.io.PrintWriter;
|
import java.nio.ByteBuffer;
|
import java.util.HashMap;
|
import java.util.HashSet;
|
import java.util.StringTokenizer;
|
|
import org.opends.server.api.DebugLogger;
|
import org.opends.server.api.ProtocolElement;
|
import org.opends.server.config.ConfigEntry;
|
import org.opends.server.types.DebugLogCategory;
|
import org.opends.server.types.DebugLogSeverity;
|
import org.opends.server.util.TimeThread;
|
|
import static org.opends.server.util.ServerConstants.*;
|
import static org.opends.server.util.StaticUtils.*;
|
|
|
|
/**
|
* This class defines a Directory Server debug logger that will be used only
|
* during startup. It makes it possible for informational, warning, and error
|
* messages to be generated during startup and made available to the user for
|
* things that happen before the configuration can be parsed and all of the
|
* actual debug loggers instantiated and registered. This debug logger will be
|
* taken out of service once the startup is complete.
|
* <BR><BR>
|
* By default, errors and warnings will be logged. This can be modified on a
|
* per-category basis using a "DS_DEBUG_LEVEL" environment variable that should
|
* be a semicolon-delimited list in which each element in that list should
|
* contain the name of the category, an equal sign, and a comma-delimited list
|
* of the severity levels to use for that category.
|
*/
|
public class StartupDebugLogger
|
extends DebugLogger
|
{
|
/**
|
* The name of the environment variable that may be used to alter the kinds of
|
* messages that get logged with this startup debug logger.
|
*/
|
public static final String ENV_VARIABLE_DEBUG_LOG_LEVEL = "DS_DEBUG_LEVEL";
|
|
|
|
// The hash map that will be used to define specific log severities for the
|
// various categories.
|
private HashMap<DebugLogCategory,HashSet<DebugLogSeverity>> definedSeverities;
|
|
// The set of default log severities that will be used if no custom severities
|
// have been defined for the associated category.
|
private HashSet<DebugLogSeverity> defaultSeverities;
|
|
// The writer that will be used to actually write the messages.
|
private PrintWriter writer;
|
|
|
|
/**
|
* Creates a new instance of this startup debug logger. It does not actually
|
* do anything, since all initialization is performed in the
|
* <CODE>initializeDebugLogger</CODE> method.
|
*/
|
public StartupDebugLogger()
|
{
|
super();
|
}
|
|
|
|
/**
|
* Initializes this debug logger based on the information in the provided
|
* configuration entry.
|
*
|
* @param configEntry The configuration entry that contains the information
|
* to use to initialize this debug logger.
|
*/
|
public void initializeDebugLogger(ConfigEntry configEntry)
|
{
|
writer = new PrintWriter(System.err, true);
|
|
defaultSeverities = new HashSet<DebugLogSeverity>();
|
defaultSeverities.add(DebugLogSeverity.ERROR);
|
defaultSeverities.add(DebugLogSeverity.WARNING);
|
|
definedSeverities =
|
new HashMap<DebugLogCategory,HashSet<DebugLogSeverity>>();
|
|
|
String logLevelInfo = System.getenv(ENV_VARIABLE_DEBUG_LOG_LEVEL);
|
if (logLevelInfo != null)
|
{
|
StringTokenizer tokenizer = new StringTokenizer(logLevelInfo, ";");
|
while (tokenizer.hasMoreTokens())
|
{
|
String token = tokenizer.nextToken();
|
int equalPos = token.indexOf('=');
|
if (equalPos < 0)
|
{
|
writer.println("StartupDebugLogger: Token \"" + token +
|
"\" read from environment variable " +
|
ENV_VARIABLE_DEBUG_LOG_LEVEL + " does not contain " +
|
"an equal sign to separate the category from the " +
|
"severity list. It will be ignored");
|
continue;
|
}
|
|
String categoryName = token.substring(0, equalPos);
|
DebugLogCategory category = DebugLogCategory.getByName(categoryName);
|
if (category == null)
|
{
|
writer.println("StartupDebugLogger: Unknown debug log category \"" +
|
categoryName + "\" read from environment variable " +
|
ENV_VARIABLE_DEBUG_LOG_LEVEL + " will be ignored.");
|
continue;
|
}
|
|
HashSet<DebugLogSeverity> severities = new HashSet<DebugLogSeverity>();
|
StringTokenizer sevTokenizer =
|
new StringTokenizer(token.substring(equalPos+1), ",");
|
while (sevTokenizer.hasMoreElements())
|
{
|
String severityName = sevTokenizer.nextToken();
|
DebugLogSeverity severity = DebugLogSeverity.getByName(severityName);
|
if (severity == null)
|
{
|
writer.println("StartupDebugLogger: Unknown debug log severity " +
|
"\"" + severityName + "\" read from environment " +
|
"variable " + ENV_VARIABLE_DEBUG_LOG_LEVEL +
|
" will be ignored.");
|
continue;
|
}
|
else
|
{
|
severities.add(severity);
|
}
|
}
|
|
definedSeverities.put(category, severities);
|
}
|
}
|
}
|
|
|
|
/**
|
* Closes this debug logger and releases any resources it might have held.
|
*/
|
public void closeDebugLogger()
|
{
|
// No action is required, and this logger will remain usable.
|
}
|
|
|
|
/**
|
* Writes a message to the debug logger indicating that the specified raw data
|
* was read.
|
*
|
* @param className The fully-qualified name of the Java class in which the
|
* data was read.
|
* @param methodName The name of the method in which the data was read.
|
* @param buffer The byte buffer containing the data that has been read.
|
* The byte buffer must be in the same state when this
|
* method returns as when it was entered.
|
*/
|
public void debugBytesRead(String className, String methodName,
|
ByteBuffer buffer)
|
{
|
HashSet<DebugLogSeverity> severities =
|
definedSeverities.get(DebugLogCategory.DATA_READ);
|
if (severities == null)
|
{
|
severities = defaultSeverities;
|
}
|
|
if (severities.contains(DebugLogSeverity.COMMUNICATION))
|
{
|
StringBuilder msg = new StringBuilder();
|
|
msg.append('[');
|
msg.append(TimeThread.getLocalTime());
|
msg.append("] category=" + DEBUG_CATEGORY_DATA_READ + ", data:" + EOL);
|
|
byteArrayToHexPlusAscii(msg, buffer, 5);
|
|
writer.println(msg.toString());
|
}
|
}
|
|
|
|
/**
|
* Writes a message to the debug logger indicating that the specified raw data
|
* was written.
|
*
|
* @param className The fully-qualified name of the Java class in which the
|
* data was written.
|
* @param methodName The name of the method in which the data was written.
|
* @param buffer The byte buffer containing the data that has been
|
* written. The byte buffer must be in the same state
|
* when this method returns as when it was entered.
|
*/
|
public void debugBytesWritten(String className, String methodName,
|
ByteBuffer buffer)
|
{
|
HashSet<DebugLogSeverity> severities =
|
definedSeverities.get(DebugLogCategory.DATA_WRITE);
|
if (severities == null)
|
{
|
severities = defaultSeverities;
|
}
|
|
if (severities.contains(DebugLogSeverity.COMMUNICATION))
|
{
|
StringBuilder msg = new StringBuilder();
|
|
msg.append('[');
|
msg.append(TimeThread.getLocalTime());
|
msg.append("] category=" + DEBUG_CATEGORY_DATA_WRITE + ", data:" + EOL);
|
|
byteArrayToHexPlusAscii(msg, buffer, 5);
|
|
writer.println(msg.toString());
|
}
|
}
|
|
|
|
/**
|
* Writes a message to the debug logger indicating that the constructor for
|
* the specified class has been invoked.
|
*
|
* @param className The fully-qualified name of the Java class whose
|
* constructor has been invoked.
|
* @param args The set of arguments provided for the constructor.
|
*/
|
public void debugConstructor(String className, String... args)
|
{
|
HashSet<DebugLogSeverity> severities =
|
definedSeverities.get(DebugLogCategory.CONSTRUCTOR);
|
if (severities == null)
|
{
|
severities = defaultSeverities;
|
}
|
|
if (severities.contains(DebugLogSeverity.INFO))
|
{
|
StringBuilder msg = new StringBuilder();
|
|
msg.append('[');
|
msg.append(TimeThread.getLocalTime());
|
msg.append("] category=" + DEBUG_CATEGORY_CONSTRUCTOR + " - ");
|
msg.append(className);
|
msg.append("(");
|
|
switch (args.length)
|
{
|
case 0:
|
// No action required;
|
break;
|
case 1:
|
msg.append(args[0]);
|
break;
|
default:
|
msg.append(args[0]);
|
|
for (int i=1; i < args.length; i++)
|
{
|
msg.append(",");
|
msg.append(args[i]);
|
}
|
break;
|
}
|
|
msg.append(")");
|
|
writer.println(msg.toString());
|
}
|
}
|
|
|
|
/**
|
* Writes a message to the debug logger indicating that the specified method
|
* has been entered.
|
*
|
* @param className The fully-qualified name of the Java class in which the
|
* specified method resides.
|
* @param methodName The name of the method that has been entered.
|
* @param args The set of arguments provided to the method.
|
*/
|
public void debugEnter(String className, String methodName, String... args)
|
{
|
HashSet<DebugLogSeverity> severities =
|
definedSeverities.get(DebugLogCategory.METHOD_ENTER);
|
if (severities == null)
|
{
|
severities = defaultSeverities;
|
}
|
|
if (severities.contains(DebugLogSeverity.INFO))
|
{
|
StringBuilder msg = new StringBuilder();
|
|
msg.append('[');
|
msg.append(TimeThread.getLocalTime());
|
msg.append("] category=" + DEBUG_CATEGORY_ENTER + " - ");
|
msg.append(className);
|
msg.append(".");
|
msg.append(methodName);
|
msg.append("(");
|
|
switch (args.length)
|
{
|
case 0:
|
// No action required;
|
break;
|
case 1:
|
msg.append(args[0]);
|
break;
|
default:
|
msg.append(args[0]);
|
|
for (int i=1; i < args.length; i++)
|
{
|
msg.append(",");
|
msg.append(args[i]);
|
}
|
break;
|
}
|
|
msg.append(")");
|
|
writer.println(msg.toString());
|
}
|
}
|
|
|
|
/**
|
* Writes a generic message to the debug logger using the provided
|
* information.
|
*
|
* @param category The category associated with this debug message.
|
* @param severity The severity associated with this debug message.
|
* @param className The fully-qualified name of the Java class in which the
|
* debug message was generated.
|
* @param methodName The name of the method in which the debug message was
|
* generated.
|
* @param message The actual contents of the debug message.
|
*/
|
public void debugMessage(DebugLogCategory category, DebugLogSeverity severity,
|
String className, String methodName, String message)
|
{
|
HashSet<DebugLogSeverity> severities = definedSeverities.get(category);
|
if (severities == null)
|
{
|
severities = defaultSeverities;
|
}
|
|
if (severities.contains(severity))
|
{
|
StringBuilder msg = new StringBuilder();
|
|
msg.append('[');
|
msg.append(TimeThread.getLocalTime());
|
msg.append("] category=");
|
msg.append(category.getCategoryName());
|
msg.append(", severity=");
|
msg.append(severity.getSeverityName());
|
msg.append(", class=");
|
msg.append(className);
|
msg.append(", method=");
|
msg.append(methodName);
|
msg.append(", msg=\"");
|
msg.append(message);
|
msg.append("\"");
|
|
writer.println(msg);
|
}
|
}
|
|
|
|
/**
|
* Writes a message to the debug logger containing information from the
|
* provided exception that was thrown.
|
*
|
* @param className The fully-qualified name of the Java class in which the
|
* exception was thrown.
|
* @param methodName The name of the method in which the exception was
|
* thrown.
|
* @param exception The exception that was thrown.
|
*/
|
public void debugException(String className, String methodName,
|
Throwable exception)
|
{
|
HashSet<DebugLogSeverity> severities =
|
definedSeverities.get(DebugLogCategory.EXCEPTION);
|
if (severities == null)
|
{
|
severities = defaultSeverities;
|
}
|
|
if (severities.contains(DebugLogSeverity.ERROR))
|
{
|
StringBuilder msg = new StringBuilder();
|
|
msg.append('[');
|
msg.append(TimeThread.getLocalTime());
|
msg.append("] category=" + DEBUG_CATEGORY_EXCEPTION + ", class=");
|
msg.append(className);
|
msg.append(", method=");
|
msg.append(methodName);
|
msg.append(", trace:" + EOL);
|
|
stackTraceToString(msg, exception);
|
|
writer.println(msg);
|
}
|
}
|
|
|
|
/**
|
* Writes a message to the debug logger indicating that the provided protocol
|
* element has been read.
|
*
|
* @param className The fully-qualified name of the Java class in
|
* which the protocol element was read.
|
* @param methodName The name of the method in which the protocol
|
* element was read.
|
* @param protocolElement The protocol element that was read.
|
*/
|
public void debugProtocolElementRead(String className, String methodName,
|
ProtocolElement protocolElement)
|
{
|
HashSet<DebugLogSeverity> severities =
|
definedSeverities.get(DebugLogCategory.PROTOCOL_READ);
|
if (severities == null)
|
{
|
severities = defaultSeverities;
|
}
|
|
if (severities.contains(DebugLogSeverity.COMMUNICATION))
|
{
|
StringBuilder msg = new StringBuilder();
|
|
msg.append('[');
|
msg.append(TimeThread.getLocalTime());
|
msg.append("] category=" + DEBUG_CATEGORY_PROTOCOL_READ +
|
", element:" + EOL);
|
|
protocolElement.toString(msg, 5);
|
|
writer.println(msg.toString());
|
}
|
}
|
|
|
|
/**
|
* Writes a message to the debug logger indicating that the provided protocol
|
* element has been written.
|
*
|
* @param className The fully-qualified name of the Java class in
|
* which the protocol element was written.
|
* @param methodName The name of the method in which the protocol
|
* element was written.
|
* @param protocolElement The protocol element that was written.
|
*/
|
public void debugProtocolElementWritten(String className, String methodName,
|
ProtocolElement protocolElement)
|
{
|
HashSet<DebugLogSeverity> severities =
|
definedSeverities.get(DebugLogCategory.PROTOCOL_WRITE);
|
if (severities == null)
|
{
|
severities = defaultSeverities;
|
}
|
|
if (severities.contains(DebugLogSeverity.COMMUNICATION))
|
{
|
StringBuilder msg = new StringBuilder();
|
|
msg.append('[');
|
msg.append(TimeThread.getLocalTime());
|
msg.append("] category=" + DEBUG_CATEGORY_PROTOCOL_WRITE+
|
", element:" + EOL);
|
|
protocolElement.toString(msg, 5);
|
|
writer.println(msg.toString());
|
}
|
}
|
|
|
|
/**
|
* Indicates whether the provided object is equal to this debug logger.
|
*
|
* @param o The object for which to make the determination.
|
*
|
* @return <CODE>true</CODE> if the provided object is determined to be equal
|
* to this debug logger, or <CODE>false</CODE> if not.
|
*/
|
public boolean equals(Object o)
|
{
|
if (this == o)
|
{
|
return true;
|
}
|
|
if ((o == null) || (! (o instanceof StartupDebugLogger)))
|
{
|
return false;
|
}
|
|
return true;
|
}
|
|
|
|
/**
|
* Retrieves the hash code for this debug logger.
|
*
|
* @return The hash code for this debug logger.
|
*/
|
public int hashCode()
|
{
|
// Just make one up, since there should never be a need to have more than
|
// one instance of this debug logger.
|
return 12345;
|
}
|
}
|
