public static String DES_DEBUG;
public static String DES_ALL;
-
static {
// initialize resource bundle
NLS.initializeMessages( BUNDLE_NAME, Messages.class );
package org.tizen.common.ui.page.preference;
+import org.apache.log4j.Logger;
+import org.apache.log4j.MDC;
+import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.jface.preference.BooleanFieldEditor;
import org.eclipse.jface.preference.DirectoryFieldEditor;
import org.eclipse.jface.preference.FieldEditorPreferencePage;
import org.eclipse.jface.preference.IPreferenceStore;
+import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseListener;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPreferencePage;
import org.tizen.common.CommonPlugin;
+import org.tizen.common.core.application.InstallPathConfig;
import org.tizen.common.util.SWTUtil;
import org.tizen.common.util.StringUtil;
+import org.tizen.common.util.log.FileAppender;
import org.tizen.common.util.log.Level;
import org.tizen.common.util.log.LoggerConstants;
public static final String VALUE_SDKLOCATION_DEFAULT = null;;
public static final boolean VALUE_SDKUPDATE_DEFAULT = false;
+ private boolean applyOk = true;
/**
* Option id for getting logger level from preference store
*/
public static final String OPTION_ID_PERFORM = "org.tizen.common.logger.perform";
- private static final String DEFAULT_LOG_LOCATION = "%X{" + LoggerConstants.KEY_WORKSPACE + "}/.metadata/log.%d";
-
private static final int DEFAULT_LEVEL = 1;
- private static final Level[] LEVELS = {Level.OFF, Level.ERROR, Level.WARNING, Level.INFO, Level.DEBUG, Level.ALL};
+ private static final Level[] LEVELS = {Level.OFF, Level.FATAL, Level.ERROR, Level.WARNING, Level.INFO, Level.DEBUG, Level.TRACE, Level.ALL};
private Text loggerCP;
private Text loggerLocText;
String loggerPath = prefStore.getString(OPTION_ID_LOCATION);
if(StringUtil.isEmpty(loggerPath)) {
- loggerPath = DEFAULT_LOG_LOCATION;
+ loggerPath = LoggerConstants.DEFAULT_LOG_LOCATION;
}
return loggerPath;
levelScale.setSelection(DEFAULT_LEVEL);
levelDesLabel.setText(LEVELS[DEFAULT_LEVEL].getDescription());
- loggerLocText.setText(DEFAULT_LOG_LOCATION);
+ loggerLocText.setText(LoggerConstants.DEFAULT_LOG_LOCATION);
loggerCP.setText(LoggerConstants.DEFAULT_CONVERSION_PATTERN);
reportButton.setSelection(false);
checkLoggerButton();
*/
@Override
protected void performApply() {
-
Level loggerLevel = LEVELS[levelScale.getSelection()];
+ String loggerLoc = loggerLocText.getText();
+
+ MDC.put(LoggerConstants.KEY_WORKSPACE, ResourcesPlugin.getWorkspace().getRoot().getLocation().toString());
+ MDC.put(LoggerConstants.KEY_SDK_HOME, InstallPathConfig.getSDKPath());
+ Logger rootLogger = Logger.getRootLogger();
+ FileAppender fileAppender = (FileAppender) rootLogger.getAppender(LoggerConstants.NAME_FILE_APPENDER);
+ String result = fileAppender.setFilePath(loggerLoc);
+ MDC.remove(LoggerConstants.KEY_SDK_HOME);
+ MDC.remove(LoggerConstants.KEY_WORKSPACE);
+
+ if(!StringUtil.isEmpty(result)) {
+ setErrorMessage(result);
+ applyOk = false;
+ return;
+ }
+
prefStore.setValue(OPTION_ID_LOCATION, loggerLocText.getText());
prefStore.setValue(OPTION_ID_LEVEL, loggerLevel.toString());
prefStore.setValue(OPTION_ID_REPORT, reportButton.getSelection());
prefStore.setValue(OPTION_ID_USAGE, usageButton.getSelection());
prefStore.setValue(OPTION_ID_PERFORM, performButton.getSelection());
prefStore.setValue(OPTION_ID_CP, loggerCP.getText());
+ setErrorMessage(null);
+ applyOk = true;
}
/**
@Override
public boolean performOk() {
performApply();
+
+ if(!applyOk) {
+ return false;
+ }
+
return super.performOk();
}
package org.tizen.common.util.log;
+import java.text.MessageFormat;
+
import org.apache.log4j.AppenderSkeleton;
import org.apache.log4j.EnhancedPatternLayout;
import org.apache.log4j.Layout;
import org.apache.log4j.Level;
+import org.apache.log4j.helpers.LogLog;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.spi.ThrowableInformation;
*/
public EclipseAppender(Layout layout) {
super();
- setLayout(layout);
+ this.setName(LoggerConstants.NAME_ECLIPSE_APPENDER);
+ setLayout(layout);
}
@Override
*/
@Override
protected void append(LoggingEvent arg0) {
- int level = arg0.getLevel().toInt();
- ThrowableInformation tI = arg0.getThrowableInformation();
- Throwable t = null;
- if(tI != null) {
- t = tI.getThrowable();
+ try {
+ int level = arg0.getLevel().toInt();
+ ThrowableInformation tI = arg0.getThrowableInformation();
+ Throwable t = null;
+ if(tI != null) {
+ t = tI.getThrowable();
+ }
+
+ String message = getLayout().format(arg0);
+
+ switch (level) {
+ case Level.ERROR_INT:
+ Logger.error(message, t);
+ break;
+ case Level.WARN_INT:
+ Logger.warning(message, t);
+ break;
+ case Level.DEBUG_INT:
+ Logger.debug(message, t);
+ break;
+ case Level.FATAL_INT:
+ Logger.error(message, t);
+ break;
+ case Level.INFO_INT:
+ Logger.info(message, t);
+ break;
+ default:
+ break;
+ }
}
-
- String message = arg0.getMessage().toString();
-
- switch (level) {
- case Level.ERROR_INT:
- Logger.error(message, t);
- break;
- case Level.WARN_INT:
- Logger.warning(message, t);
- break;
- case Level.DEBUG_INT:
- Logger.debug(message, t);
- break;
- case Level.FATAL_INT:
- Logger.error(message, t);
- break;
- case Level.INFO_INT:
- Logger.info(message, t);
- break;
- default:
- break;
+ catch(Throwable t) {
+ LogLog.error(MessageFormat.format("Exception occurred while logging message: {0}", arg0.getMessage()), t);
}
}
}
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
+import java.text.MessageFormat;
import java.util.Timer;
import java.util.TimerTask;
}
};
- private OutputStream FILE_OUTPUT_STREAM;
+ OutputStream FILE_OUTPUT_STREAM;
private FileAppenderScheduler SCHEDULER;
private static final Timer TIMER = new Timer("File appender timer", true);
protected String logPath;
*/
public FileAppender(String logPath, Layout layout, int bufferSize) {
super();
+ this.setName(LoggerConstants.NAME_FILE_APPENDER);
this.logPath = new EnhancedPatternLayout(logPath).format(dummy);
this.bufferSize = bufferSize;
setLayout(layout);
*
* @author Ho Namkoong {@literal <ho.namkoong@samsung.com>} (S-Core)
*/
- synchronized public void setFilePath( final String path ) {
+ synchronized public String setFilePath( final String path ) {
IOUtil.tryFlush(FILE_OUTPUT_STREAM);
IOUtil.tryClose(FILE_OUTPUT_STREAM);
EnhancedPatternLayout layout = new EnhancedPatternLayout(path);
this.logPath = layout.format(dummy);
- initializeAppender();
+ return initializeAppender();
}
/**
*/
@Override
synchronized protected void append(LoggingEvent arg0) {
-
try {
- FILE_OUTPUT_STREAM.write(layout.format(arg0).getBytes());
-
- if(getLayout().ignoresThrowable()) {
- String[] tss = arg0.getThrowableStrRep();
- if(tss != null) {
- for(String ts: tss) {
- FILE_OUTPUT_STREAM.write((ts + "\n").getBytes());
+ try {
+ FILE_OUTPUT_STREAM.write(layout.format(arg0).getBytes());
+
+ if(getLayout().ignoresThrowable()) {
+ String[] tss = arg0.getThrowableStrRep();
+ if(tss != null) {
+ for(String ts: tss) {
+ FILE_OUTPUT_STREAM.write((ts + "\n").getBytes());
+ }
}
}
+ } catch (IOException e) {
+ LogLog.error(Messages.FileAppender_EXCEPTION_WRITING_LOG, e); //$NON-NLS-1$
}
- } catch (IOException e) {
- LogLog.error(Messages.FileAppender_EXCEPTION_WRITING_LOG, e); //$NON-NLS-1$
+
+ SCHEDULER.cancel();
+ SCHEDULER = new FileAppenderScheduler();
+ TIMER.scheduleAtFixedRate(SCHEDULER, LoggerConstants.DEFAULT_TIMER_PERIOD, LoggerConstants.DEFAULT_TIMER_PERIOD);
+ }
+ catch(Throwable t) {
+ LogLog.error(MessageFormat.format("Exception occurred while logging message: {0}", arg0.getMessage()), t);
}
-
- SCHEDULER.cancel();
- SCHEDULER = new FileAppenderScheduler();
- TIMER.scheduleAtFixedRate(SCHEDULER, LoggerConstants.DEFAULT_TIMER_PERIOD, LoggerConstants.DEFAULT_TIMER_PERIOD);
}
- synchronized private void initializeAppender() {
+ synchronized private String initializeAppender() {
+ createLogFile(logPath);
File logFile = new File(logPath);
+ String message = StringUtil.EMPTY_STRING;
if(!logFile.exists()) {
logFile.getAbsoluteFile().getParentFile().mkdirs();
} catch (IOException e) {
FILE_OUTPUT_STREAM = NOOP_OUTPUT_STREAM;
SCHEDULER = NOOP_SCHEDULER;
+ message = NLS.bind(Messages.FileAppender_EXCEPTION_CREATING_LOGFILE, logPath);
LogLog.error(NLS.bind(Messages.FileAppender_EXCEPTION_CREATING_LOGFILE, logPath), e); //$NON-NLS-1$
- return;
+ return message;
}
}
else if(logFile.isDirectory()) {
FILE_OUTPUT_STREAM = NOOP_OUTPUT_STREAM;
SCHEDULER = NOOP_SCHEDULER;
+ message = NLS.bind(Messages.FileAppender_EXCEPTION_DIRECTORY_EXISTING, logPath);
LogLog.error(NLS.bind(Messages.FileAppender_EXCEPTION_DIRECTORY_EXISTING, logPath));
- return;
+ return message;
}
IOUtil.tryFlush(FILE_OUTPUT_STREAM);
} catch (IOException e) {
FILE_OUTPUT_STREAM = NOOP_OUTPUT_STREAM;
SCHEDULER = NOOP_SCHEDULER;
+ message = Messages.FileAppender_EXCEPTION_CREATING_BUFFER;
LogLog.error(Messages.FileAppender_EXCEPTION_CREATING_BUFFER, e); //$NON-NLS-1$
- return;
+ return message;
}
SCHEDULER = new FileAppenderScheduler();
TIMER.scheduleAtFixedRate(SCHEDULER, LoggerConstants.DEFAULT_TIMER_PERIOD, LoggerConstants.DEFAULT_TIMER_PERIOD);
+ return message;
+ }
+
+ private void createLogFile(String logPath2) {
+ // TODO Auto-generated method stub
+
}
/**
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLEncoder;
+import java.text.MessageFormat;
import java.util.ArrayList;
import org.apache.log4j.AppenderSkeleton;
*/
public GoogleAnalyticAppender(boolean isUsage, boolean isPerform, Layout layout) {
super();
+ this.setName(LoggerConstants.NAME_GOOGLE_APPENDER);
this.isUsage = isUsage;
this.isPerform = isPerform;
setLayout(layout);
final LoggingEvent event
)
{
- rc = 0;
- ArrayList<String> result = new ArrayList<String>();
try {
- if(!assembleString(result, event)) {
+ rc = 0;
+ ArrayList<String> result = new ArrayList<String>();
+ try {
+ if(!assembleString(result, event)) {
+ return;
+ }
+ } catch (UnsupportedEncodingException e) {
+ LogLog.error("Exception occurred while creating google analytic message", e);
return;
}
- } catch (UnsupportedEncodingException e) {
- LogLog.error("Exception occurred while creating google analytic message", e);
- return;
- }
-
- final String resultData = join(result.toArray(new String[result.size()]));
-
- try
- {
- final URL u = new URL( URL_GOOGLE_ANALYTIC );
- final HttpURLConnection con = (HttpURLConnection) u.openConnection();
+
+ final String resultData = join(result.toArray(new String[result.size()]));
+
try
{
- con.setDoOutput( true );
- final OutputStream out = con.getOutputStream();
- final OutputStreamWriter writer = new OutputStreamWriter( out );
- writer.write( resultData );
- writer.flush();
-
- rc = con.getResponseCode();
- if ( 200 <= rc && rc < 300 )
+ final URL u = new URL( URL_GOOGLE_ANALYTIC );
+ final HttpURLConnection con = (HttpURLConnection) u.openConnection();
+ try
+ {
+ con.setDoOutput( true );
+ final OutputStream out = con.getOutputStream();
+ final OutputStreamWriter writer = new OutputStreamWriter( out );
+ writer.write( resultData );
+ writer.flush();
+
+ rc = con.getResponseCode();
+ if ( 200 <= rc && rc < 300 )
+ {
+ System.out.println("OK");
+ }
+ }
+ finally
{
- System.out.println("OK");
+ con.disconnect();
}
- }
- finally
+ } catch (MalformedURLException e)
{
- con.disconnect();
+ LogLog.debug( String.format("Malformed URL: %s", URL_GOOGLE_ANALYTIC), e );
+ } catch (IOException e)
+ {
+ e.printStackTrace();
+ LogLog.debug( "Exception occurred while transmitting google analytic data.", e );
}
- } catch (MalformedURLException e)
- {
- LogLog.debug( String.format("Malformed URL: %s", URL_GOOGLE_ANALYTIC), e );
- } catch (IOException e)
- {
- e.printStackTrace();
- LogLog.debug( "Exception occurred while transmitting google analytic data.", e );
+ }
+ catch(Throwable t) {
+ LogLog.error(MessageFormat.format("Exception occurred while logging message: {0}", event.getMessage()), t);
}
}
public static final Level OFF = new Level(org.apache.log4j.Level.OFF, Messages.LOGGER_OFF_DES);
/**
+ * Logging level fatal
+ */
+ public static final Level FATAL = new Level(org.apache.log4j.Level.FATAL, Messages.LOGGER_FATAL_DES);
+
+ /**
* Logging level error
*/
public static final Level ERROR = new Level(org.apache.log4j.Level.ERROR, Messages.LOGGER_ERROR_DES);
public static final Level DEBUG = new Level(org.apache.log4j.Level.DEBUG, Messages.LOGGER_DEBUG_DES);
/**
+ * Logging level trace
+ */
+ public static final Level TRACE = new Level(org.apache.log4j.Level.TRACE, Messages.LOGGER_TRACE_DES);
+
+ /**
* Logging level all
*/
public static final Level ALL = new Level(org.apache.log4j.Level.ALL, Messages.LOGGER_ALL_DES);
/**
* Default conversion pattern
*/
- public static final String DEFAULT_CONVERSION_PATTERN = "[%p] %F(%L) - %m%n";
+ public static final String DEFAULT_CONVERSION_PATTERN = "[%-5p] %F(%L) - %m%n";
/**
* Default buffer size
* Default sdk home key which will be used in {@link Layout}
*/
public static final String KEY_SDK_HOME = "tizensdk";
+
+ /**
+ * File appender name
+ */
+ public static final String NAME_FILE_APPENDER = "TIZEN_FILE_APPENDER";
+
+ /**
+ * Eclipse appender name
+ */
+ public static final String NAME_ECLIPSE_APPENDER = "TIZEN_ECLIPSE_APPENDER";
+
+ /**
+ * Google appender name
+ */
+ public static final String NAME_GOOGLE_APPENDER = "TIZEN_GOOGLE_APPENDER";
+ /**
+ * Async appender name
+ */
+ public static final String NAME_ASYNC_APPENDER = "TIZEN_ASYNC_APPENDER";
+
+ /**
+ * User logger name
+ */
+ public static final String NAME_USER_LOGGER = "UserLogger";
+
+ /**
+ * Default log file location
+ */
+ public static final String DEFAULT_LOG_LOCATION = "%X{" + LoggerConstants.KEY_WORKSPACE + "}/.metadata/log.%d{yyyy-MM-dd HH-mm-ss}";
+
}
public static String LOGGER_INFO_DES;
public static String LOGGER_DEBUG_DES;
public static String LOGGER_ALL_DES;
+ public static String LOGGER_FATAL_DES;
+ public static String LOGGER_TRACE_DES;
static {
NLS.initializeMessages(BUNDLE_NAME, Messages.class);
import java.io.InputStream;
import java.net.URL;
-
import org.apache.log4j.AsyncAppender;
import org.apache.log4j.EnhancedPatternLayout;
import org.apache.log4j.Logger;
*/
public class TizenLog4jConfigurator extends DOMConfigurator implements IPropertyChangeListener {
- private static Logger rootLogger;
- private static Logger userLogger;
- private static FileAppender fileAppender;
- private static AsyncAppender asyncAppender;
- private static GoogleAnalyticAppender googleAppender;
- private static EclipseAppender eclipseAppender;
-
private static final EnhancedPatternLayout layout = new EnhancedPatternLayout();
@Override
}
private void configUserLogger() {
- userLogger = Logger.getLogger(UserLogger.NAME_USER_LOGGER);
- asyncAppender = new AsyncAppender();
- googleAppender = new GoogleAnalyticAppender(TizenBasePreferencePage.isUsage(), TizenBasePreferencePage.isPerform(), layout);
+ Logger userLogger = Logger.getLogger(LoggerConstants.NAME_USER_LOGGER);
+ AsyncAppender asyncAppender = new AsyncAppender();
+ asyncAppender.setName(LoggerConstants.NAME_ASYNC_APPENDER);
+ GoogleAnalyticAppender googleAppender = new GoogleAnalyticAppender(TizenBasePreferencePage.isUsage(), TizenBasePreferencePage.isPerform(), layout);
asyncAppender.addAppender(googleAppender);
userLogger.addAppender(asyncAppender);
+ userLogger.setLevel(Level.ALL);
}
private void configRootLogger(LoggerRepository arg1) {
- Logger _rootLogger = arg1.getRootLogger();
- rootLogger = _rootLogger;
+ Logger rootLogger = arg1.getRootLogger();
rootLogger.removeAllAppenders();
rootLogger.setLevel(TizenBasePreferencePage.getLoggerLevel());
MDC.put(LoggerConstants.KEY_WORKSPACE, ResourcesPlugin.getWorkspace().getRoot().getLocation().toString());
MDC.put(LoggerConstants.KEY_SDK_HOME, InstallPathConfig.getSDKPath());
- fileAppender = new FileAppender(TizenBasePreferencePage.getLogLocation(), layout);
+ FileAppender fileAppender = new FileAppender(TizenBasePreferencePage.getLogLocation(), layout);
rootLogger.addAppender(fileAppender);
MDC.remove(LoggerConstants.KEY_WORKSPACE);
MDC.remove(LoggerConstants.KEY_SDK_HOME);
- eclipseAppender = new EclipseAppender(layout);
+ EclipseAppender eclipseAppender = new EclipseAppender(layout);
rootLogger.addAppender(eclipseAppender);
}
- private void setLogFilePath(String name) {
- MDC.put(LoggerConstants.KEY_WORKSPACE, ResourcesPlugin.getWorkspace().getRoot().getLocation().toString());
- MDC.put(LoggerConstants.KEY_SDK_HOME, InstallPathConfig.getSDKPath());
- fileAppender.setFilePath(name);
- MDC.remove(LoggerConstants.KEY_WORKSPACE);
- MDC.remove(LoggerConstants.KEY_SDK_HOME);
- }
-
/**
* {@inheritDoc}
*
public void propertyChange(PropertyChangeEvent event) {
String property = event.getProperty();
- if(property.equals(TizenBasePreferencePage.OPTION_ID_LOCATION)) {
- String newPath = (String) event.getNewValue();
-
- setLogFilePath(newPath);
- }
- else if(property.equals(TizenBasePreferencePage.OPTION_ID_LEVEL)) {
+ Logger rootLogger = Logger.getRootLogger();
+ Logger userLogger = Logger.getLogger(LoggerConstants.NAME_USER_LOGGER);
+ AsyncAppender asyncAppender = (AsyncAppender) userLogger.getAppender(LoggerConstants.NAME_ASYNC_APPENDER);
+ GoogleAnalyticAppender googleAppender = (GoogleAnalyticAppender) asyncAppender.getAppender(LoggerConstants.NAME_GOOGLE_APPENDER);
+ if(property.equals(TizenBasePreferencePage.OPTION_ID_LEVEL)) {
String loggerLevel = (String) event.getNewValue();
Level level = TizenBasePreferencePage.getLoggerLevel(loggerLevel);
rootLogger.setLevel(level);
- userLogger.setLevel(level);
}
else if(property.equals(TizenBasePreferencePage.OPTION_ID_REPORT)) {
- boolean isReport = (Boolean) event.getNewValue();
- if(isReport) {
- asyncAppender.addAppender(googleAppender);
- }
- else {
- asyncAppender.removeAppender(googleAppender);
+ if(asyncAppender != null && googleAppender != null) {
+ boolean isReport = (Boolean) event.getNewValue();
+ if(isReport) {
+ asyncAppender.addAppender(googleAppender);
+ }
+ else {
+ asyncAppender.removeAppender(googleAppender);
+ }
}
}
else if(property.equals(TizenBasePreferencePage.OPTION_ID_USAGE)) {
- boolean isUsage = (Boolean) event.getNewValue();
- googleAppender.setUsage(isUsage);
+ if(googleAppender != null) {
+ boolean isUsage = (Boolean) event.getNewValue();
+ googleAppender.setUsage(isUsage);
+ }
}
else if(property.equals(TizenBasePreferencePage.OPTION_ID_PERFORM)) {
- boolean isPerform = (Boolean) event.getNewValue();
- googleAppender.setUsage(isPerform);
+ if(googleAppender != null) {
+ boolean isPerform = (Boolean) event.getNewValue();
+ googleAppender.setUsage(isPerform);
+ }
}
else if(property.equals(TizenBasePreferencePage.OPTION_ID_CP)) {
String cp = (String) event.getNewValue();
protected static ThreadLocalMap<String, Long> id2perform = new ThreadLocalMap<String, Long>();
private static final String FQCN = UserLogger.class.getName();
- public static final String NAME_USER_LOGGER = "UserLogger";
private static final SimpleDateFormat logDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
- private static Logger logger = Logger.getLogger(NAME_USER_LOGGER);
+ private static Logger logger = Logger.getLogger(LoggerConstants.NAME_USER_LOGGER);
/**
* Report page information with a category
* @author Ho Namkoong {@literal <ho.namkoong@samsung.com>} (S-Core)
*/
public static void page(String category, Throwable t) {
- if (Level.PAGE.isGreaterOrEqual(logger.getEffectiveLevel())) {
- Page message = new Page(category);
- System.out.println("LOGGING IN");
- logger.log(FQCN, Level.PAGE, message, t);
- }
+ Page message = new Page(category);
+ logger.log(FQCN, Level.PAGE, message, t);
}
/**
* @author Ho Namkoong {@literal <ho.namkoong@samsung.com>} (S-Core)
*/
public static void event(String category, String action, Throwable t) {
- if (Level.EVENT.isGreaterOrEqual(logger.getEffectiveLevel())) {
- Event message = new Event(category, action);
- logger.log(FQCN, Level.EVENT, message, t);
- }
+ Event message = new Event(category, action);
+ logger.log(FQCN, Level.EVENT, message, t);
}
/**
* @author Ho Namkoong {@literal <ho.namkoong@samsung.com>} (S-Core)
*/
public static void start(String category, String variableName) {
- if(Level.PERFORM_START.isGreaterOrEqual(logger.getEffectiveLevel())) {
-
- long start = System.currentTimeMillis();
- id2perform.put( category + variableName, start );
- PerformanceInfo message = new PerformanceInfo(category, start, 0, variableName);
- logger.log(FQCN, Level.PERFORM_START, message, null);
- }
+ long start = System.currentTimeMillis();
+ id2perform.put( category + variableName, start );
+ PerformanceInfo message = new PerformanceInfo(category, start, 0, variableName);
+ logger.log(FQCN, Level.PERFORM_START, message, null);
}
/**
* @author Ho Namkoong {@literal <ho.namkoong@samsung.com>} (S-Core)
*/
public static void end(String category, String variableName) {
- if (Level.PERFORM_END.isGreaterOrEqual(logger.getEffectiveLevel())) {
- long end = System.currentTimeMillis();
- Long start = id2perform.remove(category + variableName);
- if (null == start) {
- return;
- }
-
- PerformanceInfo message = new PerformanceInfo(category, start, end, variableName);
- logger.log(FQCN, Level.PERFORM_END, message, null);
+ long end = System.currentTimeMillis();
+ Long start = id2perform.remove(category + variableName);
+ if (null == start) {
+ return;
}
+
+ PerformanceInfo message = new PerformanceInfo(category, start, end, variableName);
+ logger.log(FQCN, Level.PERFORM_END, message, null);
}
/**
FileAppender_EXCEPTION_FLUSHING_BUFFER=Exception occurred while flushing buffer.
FileAppender_EXCEPTION_WRITING_LOG=Exception occurred while writing log message.
FileAppender_EXCEPTION_DIRECTORY_EXISTING=Log File {0} already exists as a directory.
-LOGGER_OFF_DES=off
-LOGGER_ERROR_DES=error
-LOGGER_WARNING_DES=warning
-LOGGER_INFO_DES=info
-LOGGER_DEBUG_DES=debug
-LOGGER_ALL_DES=all
-UserLogger_EVENT_STRING=Category: {0}\tAction: {1}
+LOGGER_FATAL_DES=FATAL: very severe error events that will presumably lead the application to abort
+LOGGER_TRACE_DES=TRACE: finer-grained informational events than the DEBUG
+LOGGER_OFF_DES=OFF: the highest possible rank and is intended to turn off logging
+LOGGER_ERROR_DES=ERROR: error events that might still allow the application to continue running
+LOGGER_WARNING_DES=WARNING: events that are potentially harmful situations
+LOGGER_INFO_DES=INFO: informational messages that highlight the progress of the application at coarse-grained level
+LOGGER_DEBUG_DES=DEBUG: fine-grained informational events that are most useful to debug an application
+LOGGER_ALL_DES=ALL: the lowest possible rank and is intended to turn on all logging
+UserLogger_EVENT_STRING=Category: {0}\tAction: {1}
\ No newline at end of file
public class FileAppenderTest {
- private static final String TEST_LOG_FILE_FIRST = "test1.txt";
+ private static final String TEST_LOG_FILE_FIRST = "log.2013-04-15 13'16'11";
private static final String TEST_LOG_FILE_SECOND = "test2.txt";
private static final String TEST_LOG_FILE_NOOP = "noop.txt";
private static final String RESULT = "A";
}
TEST_LAYOUT.setConversionPattern("%m");
+ appender.FILE_OUTPUT_STREAM.close();
appender = null;
}
projects / sdk / ide / common-eplugin.git / commitdiff