private void createRuntimeProps(MemberStateImpl memberState) {
Runtime runtime = Runtime.getRuntime();
ThreadMXBean threadMxBean = ManagementFactory.getThreadMXBean();
RuntimeMXBean runtimeMxBean = ManagementFactory.getRuntimeMXBean();
ClassLoadingMXBean clMxBean = ManagementFactory.getClassLoadingMXBean();
MemoryMXBean memoryMxBean = ManagementFactory.getMemoryMXBean();
MemoryUsage heapMemory = memoryMxBean.getHeapMemoryUsage();
MemoryUsage nonHeapMemory = memoryMxBean.getNonHeapMemoryUsage();
Map<String, Long> map = new HashMap<String, Long>();
map.put(
"runtime.availableProcessors", Integer.valueOf(runtime.availableProcessors()).longValue());
map.put("date.startTime", runtimeMxBean.getStartTime());
map.put("seconds.upTime", runtimeMxBean.getUptime());
map.put("memory.maxMemory", runtime.maxMemory());
map.put("memory.freeMemory", runtime.freeMemory());
map.put("memory.totalMemory", runtime.totalMemory());
map.put("memory.heapMemoryMax", heapMemory.getMax());
map.put("memory.heapMemoryUsed", heapMemory.getUsed());
map.put("memory.nonHeapMemoryMax", nonHeapMemory.getMax());
map.put("memory.nonHeapMemoryUsed", nonHeapMemory.getUsed());
map.put("runtime.totalLoadedClassCount", clMxBean.getTotalLoadedClassCount());
map.put(
"runtime.loadedClassCount", Integer.valueOf(clMxBean.getLoadedClassCount()).longValue());
map.put("runtime.unloadedClassCount", clMxBean.getUnloadedClassCount());
map.put("runtime.totalStartedThreadCount", threadMxBean.getTotalStartedThreadCount());
map.put("runtime.threadCount", Integer.valueOf(threadMxBean.getThreadCount()).longValue());
map.put(
"runtime.peakThreadCount", Integer.valueOf(threadMxBean.getPeakThreadCount()).longValue());
map.put(
"runtime.daemonThreadCount",
Integer.valueOf(threadMxBean.getDaemonThreadCount()).longValue());
memberState.setRuntimeProps(map);
}
public static CharSequence getThreadStats(
boolean lockedMonitors, boolean lockedSynchronizers, boolean stackTrace) {
StringBuilder list = new StringBuilder();
int threadCount = threadMXbean.getThreadCount();
int daemonCount = threadMXbean.getThreadCount();
int nonDaemonCount = threadCount - daemonCount;
int peakCount = threadMXbean.getPeakThreadCount();
long totalCount = threadMXbean.getTotalStartedThreadCount();
list.append("Live: .................... ").append(threadCount).append(" threads").append("\n");
list.append(" Non-Daemon: ......... ")
.append(nonDaemonCount)
.append(" threads")
.append("\n");
list.append(" Daemon: ............. ").append(daemonCount).append(" threads").append("\n");
list.append("Peak: .................... ").append(peakCount).append(" threads").append("\n");
list.append("Total started: ........... ").append(totalCount).append(" threads").append("\n");
list.append("=================================================").append("\n");
for (ThreadInfo info : threadMXbean.dumpAllThreads(lockedMonitors, lockedSynchronizers)) {
list.append("Thread #")
.append(info.getThreadId())
.append(" (")
.append(info.getThreadName())
.append(")")
.append("\n");
list.append("=================================================\n");
list.append("\tgetThreadState: ...... ").append(info.getThreadState()).append("\n");
list.append("\tgetWaitedTime: ....... ").append(info.getWaitedTime()).append("\n");
list.append("\tgetBlockedTime: ...... ").append(info.getBlockedTime()).append("\n");
for (MonitorInfo monitorInfo : info.getLockedMonitors()) {
list.append("\tLocked monitor: ....... ").append(monitorInfo).append("\n");
list.append("\t\t[")
.append(monitorInfo.getLockedStackDepth())
.append(".]: at ")
.append(monitorInfo.getLockedStackFrame())
.append("\n");
}
for (LockInfo lockInfo : info.getLockedSynchronizers()) {
list.append("\tLocked synchronizer: ...").append(lockInfo).append("\n");
}
if (stackTrace) {
list.append("\tgetStackTace: ..........\n");
for (StackTraceElement trace : info.getStackTrace())
list.append("\t\tat ").append(trace).append("\n");
}
list.append("=================================================\n");
}
return list;
}
@Override
public void contributeMeasurements(
Map<String, AScalarDataPoint> data, long timestamp, Map<String, Object> mementos)
throws IOException {
final ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
final long totalStartedThreadCount = threadMXBean.getTotalStartedThreadCount();
data.put(
THREAD_COUNT,
new AScalarDataPoint(timestamp, THREAD_COUNT, threadMXBean.getThreadCount(), 0));
data.put(
DAEMON_THREAD_COUNT,
new AScalarDataPoint(
timestamp, DAEMON_THREAD_COUNT, threadMXBean.getDaemonThreadCount(), 0));
data.put(
THREADS_CREATED,
new AScalarDataPoint(
timestamp,
THREADS_CREATED,
totalStartedThreadCount - formerTotalStartedThreadCount,
0));
formerTotalStartedThreadCount = totalStartedThreadCount;
}
synchronized Result formatSummary() {
Result result = new Result();
ProxyClient proxyClient = vmPanel.getProxyClient();
if (proxyClient.isDead()) {
return null;
}
buf = new StringBuilder();
append("<table cellpadding=1>");
try {
RuntimeMXBean rmBean = proxyClient.getRuntimeMXBean();
CompilationMXBean cmpMBean = proxyClient.getCompilationMXBean();
ThreadMXBean tmBean = proxyClient.getThreadMXBean();
MemoryMXBean memoryBean = proxyClient.getMemoryMXBean();
ClassLoadingMXBean clMBean = proxyClient.getClassLoadingMXBean();
OperatingSystemMXBean osMBean = proxyClient.getOperatingSystemMXBean();
com.sun.management.OperatingSystemMXBean sunOSMBean =
proxyClient.getSunOperatingSystemMXBean();
append("<tr><td colspan=4>");
append("<center><b>" + Messages.SUMMARY_TAB_TAB_NAME + "</b></center>");
String dateTime = headerDateTimeFormat.format(System.currentTimeMillis());
append("<center>" + dateTime + "</center>");
append(newDivider);
{ // VM info
append(newLeftTable);
append(Messages.CONNECTION_NAME, vmPanel.getDisplayName());
append(
Messages.VIRTUAL_MACHINE,
Resources.format(
Messages.SUMMARY_TAB_VM_VERSION, rmBean.getVmName(), rmBean.getVmVersion()));
append(Messages.VENDOR, rmBean.getVmVendor());
append(Messages.NAME, rmBean.getName());
append(endTable);
append(newRightTable);
result.upTime = rmBean.getUptime();
append(Messages.UPTIME, formatTime(result.upTime));
if (sunOSMBean != null) {
result.processCpuTime = sunOSMBean.getProcessCpuTime();
append(Messages.PROCESS_CPU_TIME, formatNanoTime(result.processCpuTime));
}
if (cmpMBean != null) {
append(Messages.JIT_COMPILER, cmpMBean.getName());
append(
Messages.TOTAL_COMPILE_TIME,
cmpMBean.isCompilationTimeMonitoringSupported()
? formatTime(cmpMBean.getTotalCompilationTime())
: Messages.UNAVAILABLE);
} else {
append(Messages.JIT_COMPILER, Messages.UNAVAILABLE);
}
append(endTable);
}
append(newDivider);
{ // Threads and Classes
append(newLeftTable);
int tlCount = tmBean.getThreadCount();
int tdCount = tmBean.getDaemonThreadCount();
int tpCount = tmBean.getPeakThreadCount();
long ttCount = tmBean.getTotalStartedThreadCount();
String[] strings1 =
formatLongs(
tlCount, tpCount,
tdCount, ttCount);
append(Messages.LIVE_THREADS, strings1[0]);
append(Messages.PEAK, strings1[1]);
append(Messages.DAEMON_THREADS, strings1[2]);
append(Messages.TOTAL_THREADS_STARTED, strings1[3]);
append(endTable);
append(newRightTable);
long clCount = clMBean.getLoadedClassCount();
long cuCount = clMBean.getUnloadedClassCount();
long ctCount = clMBean.getTotalLoadedClassCount();
String[] strings2 = formatLongs(clCount, cuCount, ctCount);
append(Messages.CURRENT_CLASSES_LOADED, strings2[0]);
append(Messages.TOTAL_CLASSES_LOADED, strings2[2]);
append(Messages.TOTAL_CLASSES_UNLOADED, strings2[1]);
append(null, "");
append(endTable);
}
append(newDivider);
{ // Memory
MemoryUsage u = memoryBean.getHeapMemoryUsage();
append(newLeftTable);
String[] strings1 = formatKByteStrings(u.getUsed(), u.getMax());
append(Messages.CURRENT_HEAP_SIZE, strings1[0]);
append(Messages.MAXIMUM_HEAP_SIZE, strings1[1]);
append(endTable);
append(newRightTable);
String[] strings2 = formatKByteStrings(u.getCommitted());
append(Messages.COMMITTED_MEMORY, strings2[0]);
append(
Messages.SUMMARY_TAB_PENDING_FINALIZATION_LABEL,
Messages.SUMMARY_TAB_PENDING_FINALIZATION_VALUE,
memoryBean.getObjectPendingFinalizationCount());
append(endTable);
append(newTable);
Collection<GarbageCollectorMXBean> garbageCollectors =
proxyClient.getGarbageCollectorMXBeans();
for (GarbageCollectorMXBean garbageCollectorMBean : garbageCollectors) {
String gcName = garbageCollectorMBean.getName();
long gcCount = garbageCollectorMBean.getCollectionCount();
long gcTime = garbageCollectorMBean.getCollectionTime();
append(
Messages.GARBAGE_COLLECTOR,
Resources.format(
Messages.GC_INFO,
gcName,
gcCount,
(gcTime >= 0) ? formatTime(gcTime) : Messages.UNAVAILABLE),
4);
}
append(endTable);
}
append(newDivider);
{ // Operating System info
append(newLeftTable);
String osName = osMBean.getName();
String osVersion = osMBean.getVersion();
String osArch = osMBean.getArch();
result.nCPUs = osMBean.getAvailableProcessors();
append(Messages.OPERATING_SYSTEM, osName + " " + osVersion);
append(Messages.ARCHITECTURE, osArch);
append(Messages.NUMBER_OF_PROCESSORS, result.nCPUs + "");
if (pathSeparator == null) {
// Must use separator of remote OS, not File.pathSeparator
// from this local VM. In the future, consider using
// RuntimeMXBean to get the remote system property.
pathSeparator = osName.startsWith("Windows ") ? ";" : ":";
}
if (sunOSMBean != null) {
String[] kbStrings1 = formatKByteStrings(sunOSMBean.getCommittedVirtualMemorySize());
String[] kbStrings2 =
formatKByteStrings(
sunOSMBean.getTotalPhysicalMemorySize(),
sunOSMBean.getFreePhysicalMemorySize(),
sunOSMBean.getTotalSwapSpaceSize(),
sunOSMBean.getFreeSwapSpaceSize());
append(Messages.COMMITTED_VIRTUAL_MEMORY, kbStrings1[0]);
append(endTable);
append(newRightTable);
append(Messages.TOTAL_PHYSICAL_MEMORY, kbStrings2[0]);
append(Messages.FREE_PHYSICAL_MEMORY, kbStrings2[1]);
append(Messages.TOTAL_SWAP_SPACE, kbStrings2[2]);
append(Messages.FREE_SWAP_SPACE, kbStrings2[3]);
}
append(endTable);
}
append(newDivider);
{ // VM arguments and paths
append(newTable);
String args = "";
java.util.List<String> inputArguments = rmBean.getInputArguments();
for (String arg : inputArguments) {
args += arg + " ";
}
append(Messages.VM_ARGUMENTS, args, 4);
append(Messages.CLASS_PATH, rmBean.getClassPath(), 4);
append(Messages.LIBRARY_PATH, rmBean.getLibraryPath(), 4);
append(
Messages.BOOT_CLASS_PATH,
rmBean.isBootClassPathSupported() ? rmBean.getBootClassPath() : Messages.UNAVAILABLE,
4);
append(endTable);
}
} catch (IOException e) {
if (JConsole.isDebug()) {
e.printStackTrace();
}
proxyClient.markAsDead();
return null;
} catch (UndeclaredThrowableException e) {
if (JConsole.isDebug()) {
e.printStackTrace();
}
proxyClient.markAsDead();
return null;
}
append("</table>");
result.timeStamp = System.currentTimeMillis();
result.summary = buf.toString();
return result;
}
/**
* Retrieve a JVM information text formatted using the given StringManager.
*
* @param requestedSm the StringManager to use
* @return the formatted JVM information text
*/
private static String getVMInfo(StringManager requestedSm) {
StringBuilder sb = new StringBuilder();
synchronized (timeformat) {
sb.append(timeformat.format(new Date()));
}
sb.append(CRLF);
sb.append(requestedSm.getString("diagnostics.vmInfoRuntime"));
sb.append(":" + CRLF);
sb.append(INDENT1 + "vmName: " + runtimeMXBean.getVmName() + CRLF);
sb.append(INDENT1 + "vmVersion: " + runtimeMXBean.getVmVersion() + CRLF);
sb.append(INDENT1 + "vmVendor: " + runtimeMXBean.getVmVendor() + CRLF);
sb.append(INDENT1 + "specName: " + runtimeMXBean.getSpecName() + CRLF);
sb.append(INDENT1 + "specVersion: " + runtimeMXBean.getSpecVersion() + CRLF);
sb.append(INDENT1 + "specVendor: " + runtimeMXBean.getSpecVendor() + CRLF);
sb.append(
INDENT1 + "managementSpecVersion: " + runtimeMXBean.getManagementSpecVersion() + CRLF);
sb.append(INDENT1 + "name: " + runtimeMXBean.getName() + CRLF);
sb.append(INDENT1 + "startTime: " + runtimeMXBean.getStartTime() + CRLF);
sb.append(INDENT1 + "uptime: " + runtimeMXBean.getUptime() + CRLF);
sb.append(
INDENT1 + "isBootClassPathSupported: " + runtimeMXBean.isBootClassPathSupported() + CRLF);
sb.append(CRLF);
sb.append(requestedSm.getString("diagnostics.vmInfoOs"));
sb.append(":" + CRLF);
sb.append(INDENT1 + "name: " + operatingSystemMXBean.getName() + CRLF);
sb.append(INDENT1 + "version: " + operatingSystemMXBean.getVersion() + CRLF);
sb.append(INDENT1 + "architecture: " + operatingSystemMXBean.getArch() + CRLF);
sb.append(
INDENT1 + "availableProcessors: " + operatingSystemMXBean.getAvailableProcessors() + CRLF);
sb.append(
INDENT1 + "systemLoadAverage: " + operatingSystemMXBean.getSystemLoadAverage() + CRLF);
sb.append(CRLF);
sb.append(requestedSm.getString("diagnostics.vmInfoThreadMxBean"));
sb.append(":" + CRLF);
sb.append(
INDENT1
+ "isCurrentThreadCpuTimeSupported: "
+ threadMXBean.isCurrentThreadCpuTimeSupported()
+ CRLF);
sb.append(
INDENT1 + "isThreadCpuTimeSupported: " + threadMXBean.isThreadCpuTimeSupported() + CRLF);
sb.append(INDENT1 + "isThreadCpuTimeEnabled: " + threadMXBean.isThreadCpuTimeEnabled() + CRLF);
sb.append(
INDENT1
+ "isObjectMonitorUsageSupported: "
+ threadMXBean.isObjectMonitorUsageSupported()
+ CRLF);
sb.append(
INDENT1
+ "isSynchronizerUsageSupported: "
+ threadMXBean.isSynchronizerUsageSupported()
+ CRLF);
sb.append(
INDENT1
+ "isThreadContentionMonitoringSupported: "
+ threadMXBean.isThreadContentionMonitoringSupported()
+ CRLF);
sb.append(
INDENT1
+ "isThreadContentionMonitoringEnabled: "
+ threadMXBean.isThreadContentionMonitoringEnabled()
+ CRLF);
sb.append(CRLF);
sb.append(requestedSm.getString("diagnostics.vmInfoThreadCounts"));
sb.append(":" + CRLF);
sb.append(INDENT1 + "daemon: " + threadMXBean.getDaemonThreadCount() + CRLF);
sb.append(INDENT1 + "total: " + threadMXBean.getThreadCount() + CRLF);
sb.append(INDENT1 + "peak: " + threadMXBean.getPeakThreadCount() + CRLF);
sb.append(INDENT1 + "totalStarted: " + threadMXBean.getTotalStartedThreadCount() + CRLF);
sb.append(CRLF);
sb.append(requestedSm.getString("diagnostics.vmInfoStartup"));
sb.append(":" + CRLF);
for (String arg : runtimeMXBean.getInputArguments()) {
sb.append(INDENT1 + arg + CRLF);
}
sb.append(CRLF);
sb.append(requestedSm.getString("diagnostics.vmInfoPath"));
sb.append(":" + CRLF);
sb.append(INDENT1 + "bootClassPath: " + runtimeMXBean.getBootClassPath() + CRLF);
sb.append(INDENT1 + "classPath: " + runtimeMXBean.getClassPath() + CRLF);
sb.append(INDENT1 + "libraryPath: " + runtimeMXBean.getLibraryPath() + CRLF);
sb.append(CRLF);
sb.append(requestedSm.getString("diagnostics.vmInfoClassLoading"));
sb.append(":" + CRLF);
sb.append(INDENT1 + "loaded: " + classLoadingMXBean.getLoadedClassCount() + CRLF);
sb.append(INDENT1 + "unloaded: " + classLoadingMXBean.getUnloadedClassCount() + CRLF);
sb.append(INDENT1 + "totalLoaded: " + classLoadingMXBean.getTotalLoadedClassCount() + CRLF);
sb.append(INDENT1 + "isVerbose: " + classLoadingMXBean.isVerbose() + CRLF);
sb.append(CRLF);
sb.append(requestedSm.getString("diagnostics.vmInfoClassCompilation"));
sb.append(":" + CRLF);
sb.append(INDENT1 + "name: " + compilationMXBean.getName() + CRLF);
sb.append(
INDENT1 + "totalCompilationTime: " + compilationMXBean.getTotalCompilationTime() + CRLF);
sb.append(
INDENT1
+ "isCompilationTimeMonitoringSupported: "
+ compilationMXBean.isCompilationTimeMonitoringSupported()
+ CRLF);
sb.append(CRLF);
for (MemoryManagerMXBean mbean : memoryManagerMXBeans) {
sb.append(requestedSm.getString("diagnostics.vmInfoMemoryManagers", mbean.getName()));
sb.append(":" + CRLF);
sb.append(INDENT1 + "isValid: " + mbean.isValid() + CRLF);
sb.append(INDENT1 + "mbean.getMemoryPoolNames: " + CRLF);
String[] names = mbean.getMemoryPoolNames();
Arrays.sort(names);
for (String name : names) {
sb.append(INDENT2 + name + CRLF);
}
sb.append(CRLF);
}
for (GarbageCollectorMXBean mbean : garbageCollectorMXBeans) {
sb.append(requestedSm.getString("diagnostics.vmInfoGarbageCollectors", mbean.getName()));
sb.append(":" + CRLF);
sb.append(INDENT1 + "isValid: " + mbean.isValid() + CRLF);
sb.append(INDENT1 + "mbean.getMemoryPoolNames: " + CRLF);
String[] names = mbean.getMemoryPoolNames();
Arrays.sort(names);
for (String name : names) {
sb.append(INDENT2 + name + CRLF);
}
sb.append(INDENT1 + "getCollectionCount: " + mbean.getCollectionCount() + CRLF);
sb.append(INDENT1 + "getCollectionTime: " + mbean.getCollectionTime() + CRLF);
sb.append(CRLF);
}
sb.append(requestedSm.getString("diagnostics.vmInfoMemory"));
sb.append(":" + CRLF);
sb.append(INDENT1 + "isVerbose: " + memoryMXBean.isVerbose() + CRLF);
sb.append(
INDENT1
+ "getObjectPendingFinalizationCount: "
+ memoryMXBean.getObjectPendingFinalizationCount()
+ CRLF);
sb.append(formatMemoryUsage("heap", memoryMXBean.getHeapMemoryUsage()));
sb.append(formatMemoryUsage("non-heap", memoryMXBean.getNonHeapMemoryUsage()));
sb.append(CRLF);
for (MemoryPoolMXBean mbean : memoryPoolMXBeans) {
sb.append(requestedSm.getString("diagnostics.vmInfoMemoryPools", mbean.getName()));
sb.append(":" + CRLF);
sb.append(INDENT1 + "isValid: " + mbean.isValid() + CRLF);
sb.append(INDENT1 + "getType: " + mbean.getType() + CRLF);
sb.append(INDENT1 + "mbean.getMemoryManagerNames: " + CRLF);
String[] names = mbean.getMemoryManagerNames();
Arrays.sort(names);
for (String name : names) {
sb.append(INDENT2 + name + CRLF);
}
sb.append(INDENT1 + "isUsageThresholdSupported: " + mbean.isUsageThresholdSupported() + CRLF);
try {
sb.append(INDENT1 + "isUsageThresholdExceeded: " + mbean.isUsageThresholdExceeded() + CRLF);
} catch (UnsupportedOperationException ex) {
// IGNORE
}
sb.append(
INDENT1
+ "isCollectionUsageThresholdSupported: "
+ mbean.isCollectionUsageThresholdSupported()
+ CRLF);
try {
sb.append(
INDENT1
+ "isCollectionUsageThresholdExceeded: "
+ mbean.isCollectionUsageThresholdExceeded()
+ CRLF);
} catch (UnsupportedOperationException ex) {
// IGNORE
}
try {
sb.append(INDENT1 + "getUsageThreshold: " + mbean.getUsageThreshold() + CRLF);
} catch (UnsupportedOperationException ex) {
// IGNORE
}
try {
sb.append(INDENT1 + "getUsageThresholdCount: " + mbean.getUsageThresholdCount() + CRLF);
} catch (UnsupportedOperationException ex) {
// IGNORE
}
try {
sb.append(
INDENT1 + "getCollectionUsageThreshold: " + mbean.getCollectionUsageThreshold() + CRLF);
} catch (UnsupportedOperationException ex) {
// IGNORE
}
try {
sb.append(
INDENT1
+ "getCollectionUsageThresholdCount: "
+ mbean.getCollectionUsageThresholdCount()
+ CRLF);
} catch (UnsupportedOperationException ex) {
// IGNORE
}
sb.append(formatMemoryUsage("current", mbean.getUsage()));
sb.append(formatMemoryUsage("collection", mbean.getCollectionUsage()));
sb.append(formatMemoryUsage("peak", mbean.getPeakUsage()));
sb.append(CRLF);
}
sb.append(requestedSm.getString("diagnostics.vmInfoSystem"));
sb.append(":" + CRLF);
Map<String, String> props = runtimeMXBean.getSystemProperties();
ArrayList<String> keys = new ArrayList<String>(props.keySet());
Collections.sort(keys);
for (String prop : keys) {
sb.append(INDENT1 + prop + ": " + props.get(prop) + CRLF);
}
sb.append(CRLF);
sb.append(requestedSm.getString("diagnostics.vmInfoLogger"));
sb.append(":" + CRLF);
List<String> loggers = loggingMXBean.getLoggerNames();
Collections.sort(loggers);
for (String logger : loggers) {
sb.append(
INDENT1
+ logger
+ ": level="
+ loggingMXBean.getLoggerLevel(logger)
+ ", parent="
+ loggingMXBean.getParentLoggerName(logger)
+ CRLF);
}
sb.append(CRLF);
return sb.toString();
}
private void writeInfo(PrintStream out) {
StaticConfig staticConfig = StaticConfig.getInstance(getServletContext());
Runtime runtime = Runtime.getRuntime();
ThreadMXBean threads = ManagementFactory.getThreadMXBean();
out.println("****************************************************************");
out.println("****************************************************************");
out.println("****");
out.println("**** Current Time : " + StringHelper.renderTime(new Date()));
out.println("**** Server info : " + getServletContext().getServerInfo());
out.println("**** JAVA_HOME : " + System.getenv("JAVA_HOME"));
out.println("**** System encoding : " + System.getProperty("file.encoding"));
out.println("**** CMS encoding : " + ContentContext.CHARACTER_ENCODING);
out.println("**** VERSION : " + VERSION);
out.println("**** Platform type : " + staticConfig.getPlatformType());
out.println("**** ENV : " + staticConfig.getEnv());
out.println("**** STATIC CONFIG DIR : " + staticConfig.getStaticConfigLocalisation());
out.println("**** PROXY HOST : " + staticConfig.getProxyHost());
out.println("**** PROXY PORT : " + staticConfig.getProxyPort());
out.println("**** DIR RELATIVE : " + staticConfig.isDataFolderRelative());
out.println("**** AUTO CREATION : " + staticConfig.isAutoCreation());
out.println("**** CONTEXT DIR : " + staticConfig.getContextFolder());
out.println("**** DATA DIR : " + staticConfig.getAllDataFolder());
out.println("**** MAILING DIR : " + staticConfig.getMailingFolder());
out.println("**** MAIL HI DIR : " + staticConfig.getMailingHistoryFolder());
out.println("**** TPLT DIR : " + staticConfig.getTemplateFolder());
out.println("**** MAIL TPLT DIR : " + staticConfig.getMailingTemplateFolder());
out.println("**** THREAD DIR : " + staticConfig.getThreadFolder());
out.println("**** EHCACHE FILE : " + staticConfig.getEHCacheConfigFile());
out.println("**** MAIL THREAD : " + staticConfig.isMailingThread());
out.println("**** ALL LOG LVL : " + staticConfig.getAllLogLevel());
out.println("**** ACCESS LOG LVL : " + staticConfig.getAccessLogLevel());
out.println("**** NAV LOG LVL : " + staticConfig.getNavigationLogLevel());
out.println("**** SYNCHRO LOG LVL : " + staticConfig.getSynchroLogLevel());
out.println("**** ALL COMP LOG LVL : " + staticConfig.getAllComponentLogLevel());
out.println("**** ABST COMP LOG LVL : " + staticConfig.getAbstractComponentLogLevel());
out.println("**** BACKUP EXCL. PAT. : " + staticConfig.getBackupExcludePatterns());
out.println("**** BACKUP INCL. PAT. : " + staticConfig.getBackupIncludePatterns());
out.println(
"**** HARD USERS : "
+ StringHelper.collectionToString(staticConfig.getEditUsers().keySet(), ","));
out.println("**** USE EHCACHE : " + staticConfig.useEhCache());
out.println(
"**** TOTAL MEMORY : "
+ runtime.totalMemory()
+ " ("
+ runtime.totalMemory() / 1024
+ " KB)"
+ " ("
+ runtime.totalMemory() / 1024 / 1024
+ " MB)");
out.println(
"**** FREE MEMORY : "
+ runtime.freeMemory()
+ " ("
+ runtime.freeMemory() / 1024
+ " KB)"
+ " ("
+ runtime.freeMemory() / 1024 / 1024
+ " MB)");
out.println("**** THREAD ****");
out.println("**** MODIF. THREAD : " + staticConfig.isNotificationThread());
out.println("**** MAILING THREAD : " + staticConfig.isMailingThread());
out.println("**** THREAD COUNT : " + threads.getThreadCount());
out.println("**** THREAD STR COUNT : " + threads.getTotalStartedThreadCount());
out.println("**** THREAD DMN COUNT : " + threads.getDaemonThreadCount());
out.println("****");
out.println("****************************************************************");
out.println("****************************************************************");
}
@Override
public long getTotalStartedThreadCount() {
ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
return threadMXBean.getTotalStartedThreadCount();
}