values, boolean entityEscapeAmpersand) {
+ String encoding = (String) values.get("WOURLEncoding");
+
+ if (encoding == null) {
+ encoding = urlEncoding();
+ }
+
+ return encoder().encodeAsCGIFormValues(values, encoding, entityEscapeAmpersand);
+ }
+
+ public NSDictionary decodeCGIFormValues(String value) {
+ return decodeCGIFormValues(value, getWOURLEncoding(value));
+ }
+
+ public NSDictionary decodeCGIFormValues(String value, String encoding) {
+ return decoder().decodeCGIFormValues(value, encoding);
+ }
+
+ public NSDictionary decodeDataFormValues(String value, String encoding) {
+ return decoder().decodeCGIFormValues(value, encoding);
+ }
+
+ public String getWOURLEncoding(String value) {
+ int i = value.indexOf("WOURLEncoding=");
+
+ if (i >= 0) {
+ int j = i + "WOURLEncoding".length() + 1;
+ int k = value.indexOf('&', j + 1);
+
+ if (k >= 0) {
+ return value.substring(j, k);
+ }
+
+ return value.substring(j);
+ }
+
+ return urlEncoding();
+ }
+
+ public void setUrlEncoding(String value) {
+ this._woURLEncoding = value;
+ }
+
+ public String urlEncoding() {
+ return (this._woURLEncoding != null) ? this._woURLEncoding : "UTF-8";
+ }
+}
\ No newline at end of file
diff --git a/Frameworks/Core/ERExtensions/Sources/er/extensions/ERXExtensions.java b/Frameworks/Core/ERExtensions/Sources/er/extensions/ERXExtensions.java
index fe62e5634e9..7fa06edbd54 100644
--- a/Frameworks/Core/ERExtensions/Sources/er/extensions/ERXExtensions.java
+++ b/Frameworks/Core/ERExtensions/Sources/er/extensions/ERXExtensions.java
@@ -21,8 +21,10 @@
import java.util.regex.Matcher;
import java.util.regex.Pattern;
+import er.extensions.logging.ERXLoggingUtilities;
import org.apache.commons.lang3.StringUtils;
-import org.apache.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import com.webobjects.appserver.WOApplication;
import com.webobjects.appserver.WOSession;
@@ -202,12 +204,12 @@ public void bundleDidLoad(NSNotification n) {
String className = ERXProperties.stringForKey("er.extensions.erxloggerclass");
if (className != null) {
Class loggerClass = Class.forName(className);
- Method method = loggerClass.getDeclaredMethod(ERXLogger.CONFIGURE_LOGGING_WITH_SYSTEM_PROPERTIES, (Class[]) null);
+ Method method = loggerClass.getDeclaredMethod(ERXLoggingUtilities.CONFIGURE_LOGGING_WITH_SYSTEM_PROPERTIES, (Class[]) null);
method.invoke(loggerClass, (Object[]) null);
}
else {
// default behaviour:
- ERXLogger.configureLoggingWithSystemProperties();
+ ERXLoggingUtilities.configureLoggingWithSystemProperties();
}
ERXArrayUtilities.initialize();
@@ -267,7 +269,7 @@ public void finishInitialization() {
// name and port are resolved via WOApplication.application()
// ERXLogger.configureLoggingWithSystemProperties();
- _log = Logger.getLogger(ERXExtensions.class);
+ _log = LoggerFactory.getLogger(ERXExtensions.class);
ERXProperties.pathsForUserAndBundleProperties(true);
try {
@@ -722,9 +724,9 @@ public void sharedEditingContextWasInitialized(NSNotification n) {
public static void configureAdaptorContextRapidTurnAround(Object anObserver) {
if (!_isConfigureAdaptorContextRapidTurnAround) {
// This allows enabling from the log4j system.
- adaptorLogger = Logger.getLogger("er.transaction.adaptor.EOAdaptorDebugEnabled");
+ adaptorLogger = LoggerFactory.getLogger("er.transaction.adaptor.EOAdaptorDebugEnabled");
- sharedEOadaptorLogger = Logger.getLogger("er.transaction.adaptor.EOSharedEOAdaptorDebugEnabled");
+ sharedEOadaptorLogger = LoggerFactory.getLogger("er.transaction.adaptor.EOSharedEOAdaptorDebugEnabled");
if ((adaptorLogger.isDebugEnabled()
&& !NSLog.debugLoggingAllowedForGroups(NSLog.DebugGroupSQLGeneration|NSLog.DebugGroupDatabaseAccess))
|| ERXProperties.booleanForKey("EOAdaptorDebugEnabled")) {
diff --git a/Frameworks/Core/ERExtensions/Sources/er/extensions/ERXFrameworkPrincipal.java b/Frameworks/Core/ERExtensions/Sources/er/extensions/ERXFrameworkPrincipal.java
index 786d79fa634..5062246c34a 100644
--- a/Frameworks/Core/ERExtensions/Sources/er/extensions/ERXFrameworkPrincipal.java
+++ b/Frameworks/Core/ERExtensions/Sources/er/extensions/ERXFrameworkPrincipal.java
@@ -8,7 +8,8 @@
import java.lang.reflect.Field;
-import org.apache.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import com.webobjects.foundation.NSForwardException;
import com.webobjects.foundation.NSMutableArray;
@@ -43,7 +44,7 @@
* Here is an example:
* public class ExampleFrameworkPrincipal extends ERXFrameworkPrincipal {
*
- * public static final Logger log = Logger.getLogger(ExampleFrameworkPrincipal.class);
+ * public static final Logger log = LoggerFactory.getLogger(ExampleFrameworkPrincipal.class);
*
* protected static ExampleFrameworkPrincipal sharedInstance;
*
@@ -77,7 +78,7 @@
public abstract class ERXFrameworkPrincipal {
/** logging support */
- protected final Logger log = Logger.getLogger(getClass());
+ protected final Logger log = LoggerFactory.getLogger(getClass());
/** holds the mapping between framework principals classes and ERXFrameworkPrincipal objects */
protected static final NSMutableDictionary initializedFrameworks = new NSMutableDictionary<>();
diff --git a/Frameworks/Core/ERExtensions/Sources/er/extensions/appserver/ERXApplication.java b/Frameworks/Core/ERExtensions/Sources/er/extensions/appserver/ERXApplication.java
index 156e5d3cd2e..05cc5222df5 100644
--- a/Frameworks/Core/ERExtensions/Sources/er/extensions/appserver/ERXApplication.java
+++ b/Frameworks/Core/ERExtensions/Sources/er/extensions/appserver/ERXApplication.java
@@ -38,9 +38,8 @@
import javax.xml.parsers.DocumentBuilderFactory;
import org.apache.commons.lang3.CharEncoding;
-import org.apache.log4j.Appender;
-import org.apache.log4j.ConsoleAppender;
-import org.apache.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
@@ -113,6 +112,7 @@
import er.extensions.foundation.ERXThreadStorage;
import er.extensions.foundation.ERXTimestampUtilities;
import er.extensions.localization.ERXLocalizer;
+import er.extensions.logging.ERXLoggingUtilities;
import er.extensions.migration.ERXMigrator;
import er.extensions.statistics.ERXStats;
@@ -159,16 +159,16 @@
*/
public abstract class ERXApplication extends ERXAjaxApplication implements ERXGracefulShutdown.GracefulApplication {
/** logging support */
- public static final Logger log = Logger.getLogger(ERXApplication.class);
+ public static final Logger log = LoggerFactory.getLogger(ERXApplication.class);
/** request logging support */
- public static final Logger requestHandlingLog = Logger.getLogger("er.extensions.ERXApplication.RequestHandling");
+ public static final Logger requestHandlingLog = LoggerFactory.getLogger("er.extensions.ERXApplication.RequestHandling");
/** statistic logging support */
- public static final Logger statsLog = Logger.getLogger("er.extensions.ERXApplication.Statistics");
+ public static final Logger statsLog = LoggerFactory.getLogger("er.extensions.ERXApplication.Statistics");
/** startup logging support */
- public static final Logger startupLog = Logger.getLogger("er.extensions.ERXApplication.Startup");
+ public static final Logger startupLog = LoggerFactory.getLogger("er.extensions.ERXApplication.Startup");
private static boolean wasERXApplicationMainInvoked = false;
@@ -1177,15 +1177,9 @@ public ERXApplication() {
if ("JavaFoundation".equals(NSBundle.mainBundle().name())) {
throw new RuntimeException("Your main bundle is \"JavaFoundation\". You are not launching this WO application properly. If you are using Eclipse, most likely you launched your WOA as a \"Java Application\" instead of a \"WO Application\".");
}
- // ak: telling Log4J to re-init the Console appenders so we get logging
- // into WOOutputPath again
- for (Enumeration e = Logger.getRootLogger().getAllAppenders(); e.hasMoreElements();) {
- Appender appender = (Appender) e.nextElement();
- if (appender instanceof ConsoleAppender) {
- ConsoleAppender app = (ConsoleAppender) appender;
- app.activateOptions();
- }
- }
+
+ ERXLoggingUtilities.resetLoggingAdapter();
+
if(_loader != null) {
_loader._checker.reportErrors();
_loader._checker = null;
@@ -1626,16 +1620,16 @@ public synchronized void refuseNewSessions(boolean value) {
success = true;
}
catch (SecurityException e) {
- log.error(e, e);
+ log.error(e.getMessage(), e);
}
catch (NoSuchFieldException e) {
- log.error(e, e);
+ log.error(e.getMessage(), e);
}
catch (IllegalArgumentException e) {
- log.error(e, e);
+ log.error(e.getMessage(), e);
}
catch (IllegalAccessException e) {
- log.error(e, e);
+ log.error(e.getMessage(), e);
}
if(!success) {
super.refuseNewSessions(value);
@@ -1924,8 +1918,8 @@ public void handlePotentiallyFatalException(Exception exception) {
// state.
if (shouldQuit) {
NSLog.err.appendln("Ran out of memory, killing this instance");
- log.fatal("Ran out of memory, killing this instance");
- log.fatal("Ran out of memory, killing this instance", throwable);
+ log.error("Ran out of memory, killing this instance");
+ log.error("Ran out of memory, killing this instance", throwable);
}
}
else {
@@ -2066,7 +2060,7 @@ public WOResponse dispatchRequest(WORequest request) {
public WOResponse dispatchRequestImmediately(WORequest request) {
WOResponse response;
if (ERXApplication.requestHandlingLog.isDebugEnabled()) {
- ERXApplication.requestHandlingLog.debug(request);
+ ERXApplication.requestHandlingLog.debug(request.toString());
}
try {
diff --git a/Frameworks/Core/ERExtensions/Sources/er/extensions/appserver/ERXComponentActionRedirector.java b/Frameworks/Core/ERExtensions/Sources/er/extensions/appserver/ERXComponentActionRedirector.java
index c6d0879cd48..67b74e05c44 100644
--- a/Frameworks/Core/ERExtensions/Sources/er/extensions/appserver/ERXComponentActionRedirector.java
+++ b/Frameworks/Core/ERExtensions/Sources/er/extensions/appserver/ERXComponentActionRedirector.java
@@ -36,7 +36,7 @@
* then Main could be implemented something like this:
*
* public class Main extends WOComponent implements ERXComponentActionRedirector.Restorable {
- * static Logger log = Logger.getLogger(Main.class);
+ * static Logger log = LoggerFactory.getLogger(Main.class);
*
* public Integer someValue = Integer.valueOf(10);
*
diff --git a/Frameworks/Core/ERExtensions/Sources/er/extensions/appserver/ERXDirectAction.java b/Frameworks/Core/ERExtensions/Sources/er/extensions/appserver/ERXDirectAction.java
index 62d4a3cc751..174c91ebf4c 100644
--- a/Frameworks/Core/ERExtensions/Sources/er/extensions/appserver/ERXDirectAction.java
+++ b/Frameworks/Core/ERExtensions/Sources/er/extensions/appserver/ERXDirectAction.java
@@ -11,6 +11,7 @@
import java.io.StringWriter;
import java.util.Properties;
+import er.extensions.logging.ERXLoggingUtilities;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -436,7 +437,7 @@ public WOActionResults systemPropertyAction() {
java.util.Properties p = System.getProperties();
p.put(key, value);
System.setProperties(p);
- ERXLogger.configureLoggingWithSystemProperties();
+ ERXLoggingUtilities.configureLoggingWithSystemProperties();
for (java.util.Enumeration e = p.keys(); e.hasMoreElements();) {
Object k = e.nextElement();
if (k.equals(key)) {
diff --git a/Frameworks/Core/ERExtensions/Sources/er/extensions/components/ERXDynamicElement.java b/Frameworks/Core/ERExtensions/Sources/er/extensions/components/ERXDynamicElement.java
index 42cc5d1df3e..6ef414255a5 100644
--- a/Frameworks/Core/ERExtensions/Sources/er/extensions/components/ERXDynamicElement.java
+++ b/Frameworks/Core/ERExtensions/Sources/er/extensions/components/ERXDynamicElement.java
@@ -2,7 +2,8 @@
import java.util.Stack;
-import org.apache.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import com.webobjects.appserver.WOAssociation;
import com.webobjects.appserver.WOComponent;
@@ -30,7 +31,7 @@
* @author jw
*/
public abstract class ERXDynamicElement extends WODynamicGroup {
- protected Logger log = Logger.getLogger(getClass());
+ protected Logger log = LoggerFactory.getLogger(getClass());
private final NSDictionary _associations;
public ERXDynamicElement(String name, NSDictionary associations, WOElement template) {
diff --git a/Frameworks/Core/ERExtensions/Sources/er/extensions/concurrency/ERXLongResponseTask.java b/Frameworks/Core/ERExtensions/Sources/er/extensions/concurrency/ERXLongResponseTask.java
index de82b81b297..60c872d7747 100644
--- a/Frameworks/Core/ERExtensions/Sources/er/extensions/concurrency/ERXLongResponseTask.java
+++ b/Frameworks/Core/ERExtensions/Sources/er/extensions/concurrency/ERXLongResponseTask.java
@@ -3,7 +3,8 @@
*/
package er.extensions.concurrency;
-import org.apache.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import com.webobjects.appserver.WOApplication;
import com.webobjects.appserver.WOComponent;
@@ -94,7 +95,7 @@ public abstract class DefaultImplementation implements Runnable, ERXLongResponse
/** logging support */
- public Logger log = Logger.getLogger(ERXUtilities.class);
+ public Logger log = LoggerFactory.getLogger(ERXUtilities.class);
/** Refresh page that controls this task */
protected ERXLongResponse _longResponse;
@@ -122,7 +123,7 @@ public abstract class DefaultImplementation implements Runnable, ERXLongResponse
*/
public DefaultImplementation() {
_finishInitialization();
- log = Logger.getLogger(getClass().getName());
+ log = LoggerFactory.getLogger(getClass().getName());
_thread = null;
}
diff --git a/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXCustomObject.java b/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXCustomObject.java
index d96317f82bb..dc09c1a5a96 100644
--- a/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXCustomObject.java
+++ b/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXCustomObject.java
@@ -8,7 +8,8 @@
import java.util.Enumeration;
-import org.apache.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import com.webobjects.eoaccess.EOEntity;
import com.webobjects.eoaccess.EOUtilities;
@@ -108,7 +109,7 @@ public Logger getClassLog() {
Logger classLog = classLogs.objectForKey(getClass());
if ( classLog == null) {
synchronized(classLogs) {
- classLog = Logger.getLogger(getClass());
+ classLog = LoggerFactory.getLogger(getClass());
classLogs.setObjectForKey(classLog, getClass());
}
}
diff --git a/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXDatabaseContextDelegate.java b/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXDatabaseContextDelegate.java
index 94a88b0dd9e..7f44f80d89e 100644
--- a/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXDatabaseContextDelegate.java
+++ b/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXDatabaseContextDelegate.java
@@ -9,7 +9,8 @@
import java.util.Enumeration;
import java.util.concurrent.CopyOnWriteArrayList;
-import org.apache.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import com.webobjects.eoaccess.EOAccessArrayFaultHandler;
import com.webobjects.eoaccess.EOAdaptor;
@@ -95,13 +96,13 @@ public EOGlobalID globalID() {
}
/** Basic logging support */
- public final static Logger log = Logger.getLogger(ERXDatabaseContextDelegate.class);
+ public final static Logger log = LoggerFactory.getLogger(ERXDatabaseContextDelegate.class);
/** Faulting logging support, logging category: er.transaction.adaptor.FaultFiring */
- public final static Logger dbLog = Logger.getLogger("er.transaction.adaptor.FaultFiring");
+ public final static Logger dbLog = LoggerFactory.getLogger("er.transaction.adaptor.FaultFiring");
/** Faulting logging support, logging category: er.transaction.adaptor.Exceptions */
- public final static Logger exLog = Logger.getLogger("er.transaction.adaptor.Exceptions");
+ public final static Logger exLog = LoggerFactory.getLogger("er.transaction.adaptor.Exceptions");
/** Faulting logging support, logging category: er.transaction.adaptor.Batching */
- public final static Logger batchLog = Logger.getLogger("er.transaction.adaptor.Batching");
+ public final static Logger batchLog = LoggerFactory.getLogger("er.transaction.adaptor.Batching");
/** Holds onto the singleton of the default delegate */
private static ERXDatabaseContextDelegate _defaultDelegate = new ERXDatabaseContextDelegate();
@@ -252,9 +253,9 @@ public boolean databaseContextShouldHandleDatabaseException(EODatabaseContext db
EOAdaptor adaptor=dbc.adaptorContext().adaptor();
boolean shouldHandleConnection = false;
if(e instanceof EOGeneralAdaptorException)
- log.error(((EOGeneralAdaptorException)e).userInfo());
+ log.error(((EOGeneralAdaptorException)e).userInfo().toString());
else
- log.error(e);
+ log.error(e.getMessage(), e);
if (adaptor.isDroppedConnectionException(e))
shouldHandleConnection = true;
// FIXME: Should provide api to extend the list of bad exceptions.
@@ -265,7 +266,7 @@ else if (e.toString().indexOf("ORA-01041")!=-1) {
shouldHandleConnection = false;
} else {
if(e instanceof EOGeneralAdaptorException)
- log.info(((EOGeneralAdaptorException)e).userInfo());
+ log.info(((EOGeneralAdaptorException)e).userInfo().toString());
throw e;
}
return shouldHandleConnection;
diff --git a/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXEOAccessUtilities.java b/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXEOAccessUtilities.java
index 5e0c779bb76..498f4131314 100644
--- a/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXEOAccessUtilities.java
+++ b/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXEOAccessUtilities.java
@@ -13,8 +13,8 @@
import java.util.Set;
import java.util.concurrent.atomic.AtomicReference;
-import org.apache.log4j.Level;
-import org.apache.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import com.webobjects.appserver.WOSession;
import com.webobjects.eoaccess.EOAdaptorChannel;
@@ -83,8 +83,8 @@
*/
public class ERXEOAccessUtilities {
/** logging support */
- public static final Logger log = Logger.getLogger(ERXEOAccessUtilities.class);
-
+ public static final Logger log = LoggerFactory.getLogger(ERXEOAccessUtilities.class);
+
/** SQL logger */
private static Logger sqlLoggingLogger = null;
@@ -170,8 +170,8 @@ public static EOEntity entityUsingTable(EOEditingContext ec, String tableName) {
if (possibleEntities.count() > 0) {
result = (EOEntity) possibleEntities.lastObject();
}
-
- if (log.isEnabledFor(Level.WARN) && possibleEntities.count() > 1)
+
+ if (log.isWarnEnabled() && possibleEntities.count() > 1)
log.warn("Found multiple entities: " + possibleEntities.valueForKey("name") + " for table name: " + tableName);
if (log.isDebugEnabled())
@@ -1248,7 +1248,7 @@ public static EOEntity rootEntityForEntityNamed(String entityName) {
public static void logExpression(EOAdaptorChannel channel, EOSQLExpression expression, long startTime) {
if (sqlLoggingLogger == null) {
- sqlLoggingLogger = Logger.getLogger("er.extensions.ERXAdaptorChannelDelegate.sqlLogging");
+ sqlLoggingLogger = LoggerFactory.getLogger("er.extensions.ERXAdaptorChannelDelegate.sqlLogging");
}
// sqlLoggingLogger.setLevel(Level.DEBUG);
String entityMatchPattern = ERXProperties.stringForKeyWithDefault(
@@ -2056,7 +2056,7 @@ public static void makeEditableSharedEntityNamed(String entityName) {
e.removeSharedObjectFetchSpecificationByName((String)fetchSpecNameObjectEnumerator.nextElement());
}
} else if (e == null) {
- log.warn("makeEditableSharedEntityNamed: unable to find entity named: " + entityName);
+ log.warn("makeEditableSharedEntityNamed: unable to find entity named: " + entityName);
} else {
log.warn("makeEditableSharedEntityNamed: entity already editable: " + entityName);
}
@@ -2110,7 +2110,7 @@ public static EORelationship createRelationship(String relationshipName, String
sourceEntity.setClassProperties(classProperties);
}
if(log.isDebugEnabled())
- log.debug(relationship);
+ log.debug(relationship.toString());
return relationship;
}
diff --git a/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXEnterpriseObject.java b/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXEnterpriseObject.java
index cabd68f8f00..7e113cb4afd 100644
--- a/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXEnterpriseObject.java
+++ b/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXEnterpriseObject.java
@@ -2,7 +2,8 @@
import java.util.Enumeration;
-import org.apache.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import com.webobjects.eocontrol.EOEditingContext;
import com.webobjects.eocontrol.EOEnterpriseObject;
@@ -23,7 +24,7 @@
public interface ERXEnterpriseObject extends EOEnterpriseObject {
/** logging support for modified objects */
- public static final Logger logMod = Logger.getLogger("er.transaction.delegate.EREditingContextDelegate.modifiedObjects");
+ public static final Logger logMod = LoggerFactory.getLogger("er.transaction.delegate.EREditingContextDelegate.modifiedObjects");
public static final boolean applyRestrictingQualifierOnInsert = ERXProperties.booleanForKey("er.extensions.ERXEnterpriseObject.applyRestrictingQualifierOnInsert");
@@ -234,55 +235,55 @@ protected void perform(EOEditingContext ec, ERXEnterpriseObject eo) {
};
/** logging support. Called after an object is successfully inserted */
- public static final Logger tranLogDidInsert = Logger
+ public static final Logger tranLogDidInsert = LoggerFactory
.getLogger("er.transaction.eo.did.insert.ERXGenericRecord");
/** logging support. Called after an object is successfully deleted */
- public static final Logger tranLogDidDelete = Logger
+ public static final Logger tranLogDidDelete = LoggerFactory
.getLogger("er.transaction.eo.did.delete.ERXGenericRecord");
/** logging support. Called after an object is successfully updated */
- public static final Logger tranLogDidUpdate = Logger
+ public static final Logger tranLogDidUpdate = LoggerFactory
.getLogger("er.transaction.eo.did.update.ERXGenericRecord");
/** logging support. Called after an object is reverted. **/
- public static final Logger tranLogDidRevert = Logger
+ public static final Logger tranLogDidRevert = LoggerFactory
.getLogger("er.transaction.eo.did.revert.ERXGenericRecord");
/** logging support. Called before an object is deleted */
- public static final Logger tranLogMightDelete = Logger
+ public static final Logger tranLogMightDelete = LoggerFactory
.getLogger("er.transaction.eo.might.delete.ERXGenericRecord");
/** logging support. Called before an object is inserted */
- public static final Logger tranLogWillInsert = Logger
+ public static final Logger tranLogWillInsert = LoggerFactory
.getLogger("er.transaction.eo.will.insert.ERXGenericRecord");
/** logging support. Called before an object is deleted */
- public static final Logger tranLogWillDelete = Logger
+ public static final Logger tranLogWillDelete = LoggerFactory
.getLogger("er.transaction.eo.will.delete.ERXGenericRecord");
/** logging support. Called before an object is updated */
- public static final Logger tranLogWillUpdate = Logger
+ public static final Logger tranLogWillUpdate = LoggerFactory
.getLogger("er.transaction.eo.will.update.ERXGenericRecord");
/** logging support. Called before an object is reverted. **/
- public static final Logger tranLogWillRevert = Logger
+ public static final Logger tranLogWillRevert = LoggerFactory
.getLogger("er.transaction.eo.will.revert.ERXGenericRecord");
/** logging support for validation information */
- public static final Logger validation = Logger
+ public static final Logger validation = LoggerFactory
.getLogger("er.eo.validation.ERXGenericRecord");
/** logging support for validation exceptions */
- public static final Logger validationException = Logger
+ public static final Logger validationException = LoggerFactory
.getLogger("er.eo.validationException.ERXGenericRecord");
/** logging support for insertion tracking */
- public static final Logger insertionTrackingLog = Logger
+ public static final Logger insertionTrackingLog = LoggerFactory
.getLogger("er.extensions.ERXGenericRecord.insertion");
/** general logging support */
- public static final Logger log = Logger
+ public static final Logger log = LoggerFactory
.getLogger("er.eo.ERXGenericRecord");
// DELETEME: Once we get rid of the half baked rule validation here, we can delete this.
diff --git a/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXGenericRecord.java b/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXGenericRecord.java
index d37f32002d8..1b19bc2ed38 100644
--- a/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXGenericRecord.java
+++ b/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXGenericRecord.java
@@ -8,7 +8,8 @@
import java.util.Objects;
-import org.apache.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import com.webobjects.eoaccess.EOAttribute;
import com.webobjects.eoaccess.EOEntity;
@@ -258,7 +259,7 @@ public Logger getClassLog() {
Logger classLog = classLogs.objectForKey(getClass());
if (classLog == null) {
synchronized (classLogs) {
- classLog = Logger.getLogger(getClass());
+ classLog = LoggerFactory.getLogger(getClass());
classLogs.setObjectForKey(classLog, getClass());
}
}
diff --git a/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXObjectStoreCoordinator.java b/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXObjectStoreCoordinator.java
index fd22b19682e..8df7a2cd6c8 100644
--- a/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXObjectStoreCoordinator.java
+++ b/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXObjectStoreCoordinator.java
@@ -8,7 +8,8 @@
import java.util.WeakHashMap;
import org.apache.commons.lang3.builder.ToStringBuilder;
-import org.apache.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import sun.misc.Signal;
import sun.misc.SignalHandler;
@@ -26,7 +27,7 @@
*/
public class ERXObjectStoreCoordinator extends EOObjectStoreCoordinator {
- public static final Logger log = Logger.getLogger(ERXObjectStoreCoordinator.class);
+ public static final Logger log = LoggerFactory.getLogger(ERXObjectStoreCoordinator.class);
NSMutableDictionary> openLockTraces;
@@ -130,16 +131,16 @@ public void lock() {
public void unlock() {
boolean tracing = ERXEC.markOpenLocks();
if (lockingThread != null && lockingThread != Thread.currentThread()) {
- log.fatal("Unlocking thread is not locking thread: LOCKING " + lockingThread + " vs UNLOCKING " + Thread.currentThread(), new RuntimeException("UnlockingTrace"));
+ log.error("Unlocking thread is not locking thread: LOCKING " + lockingThread + " vs UNLOCKING " + Thread.currentThread(), new RuntimeException("UnlockingTrace"));
if (tracing) {
NSMutableArray traces = openLockTraces.objectForKey(lockingThread);
if (traces != null) {
for (Exception trace : traces) {
- log.fatal("Currenty locking threads: " + lockingThread, trace);
+ log.error("Currenty locking threads: " + lockingThread, trace);
}
}
else {
- log.fatal("Trace for locking thread is MISSING");
+ log.error("Trace for locking thread is MISSING");
}
}
}
diff --git a/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXObjectStoreCoordinatorPool.java b/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXObjectStoreCoordinatorPool.java
index 95d69bb3309..042bb9a1313 100644
--- a/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXObjectStoreCoordinatorPool.java
+++ b/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXObjectStoreCoordinatorPool.java
@@ -7,7 +7,8 @@
import java.util.List;
import java.util.Map;
-import org.apache.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import com.webobjects.appserver.WOSession;
import com.webobjects.eocontrol.EOEditingContext;
@@ -38,7 +39,7 @@
* @author David Teran, Frank Caputo @ cluster9
*/
public class ERXObjectStoreCoordinatorPool {
- private static final Logger log = Logger.getLogger(ERXObjectStoreCoordinatorPool.class);
+ private static final Logger log = LoggerFactory.getLogger(ERXObjectStoreCoordinatorPool.class);
private static final String THREAD_OSC_KEY = "er.extensions.ERXObjectStoreCoordinatorPool.threadOSC";
private Map _oscForSession;
diff --git a/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXObjectStoreCoordinatorSynchronizer.java b/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXObjectStoreCoordinatorSynchronizer.java
index 0a4a5fd1527..91f3fb2e1d2 100644
--- a/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXObjectStoreCoordinatorSynchronizer.java
+++ b/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXObjectStoreCoordinatorSynchronizer.java
@@ -10,7 +10,8 @@
import java.util.LinkedList;
import java.util.List;
-import org.apache.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import com.webobjects.appserver.WOApplication;
import com.webobjects.eoaccess.EODatabase;
@@ -46,7 +47,7 @@
* manually.
*/
public class ERXObjectStoreCoordinatorSynchronizer {
- public static final Logger log = Logger.getLogger(ERXObjectStoreCoordinatorSynchronizer.class);
+ public static final Logger log = LoggerFactory.getLogger(ERXObjectStoreCoordinatorSynchronizer.class);
public static final String SYNCHRONIZER_KEY = "_synchronizer";
@@ -630,7 +631,7 @@ else if (changes instanceof RemoteChange) {
}
}
} catch (Throwable e) {
- log.error(e, e);
+ log.error(e.getMessage(), e);
}
}
diff --git a/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXSequence.java b/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXSequence.java
index 8d19f1c5a6e..4d9a93634d7 100644
--- a/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXSequence.java
+++ b/Frameworks/Core/ERExtensions/Sources/er/extensions/eof/ERXSequence.java
@@ -7,7 +7,8 @@
import java.util.HashMap;
import java.util.Map;
-import org.apache.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import com.webobjects.eoaccess.EOAdaptor;
import com.webobjects.eoaccess.EOEntity;
@@ -37,7 +38,7 @@ public class ERXSequence {
public ERXSequence(String name) {
_name = name;
- log = Logger.getLogger(name);
+ log = LoggerFactory.getLogger(name);
}
public ERXSequence(String name, long initialValue) {
@@ -207,7 +208,7 @@ protected long increasedMaxValue(long increment) {
con.setReadOnly(false);
}
} catch (SQLException e) {
- log.error(e, e);
+ log.error(e.getMessage(), e);
}
for(int tries = 0; tries < 5; tries++) {
diff --git a/Frameworks/Core/ERExtensions/Sources/er/extensions/foundation/ERXConfigurationManager.java b/Frameworks/Core/ERExtensions/Sources/er/extensions/foundation/ERXConfigurationManager.java
index 6cc2b3a6804..eabeb42e0e2 100644
--- a/Frameworks/Core/ERExtensions/Sources/er/extensions/foundation/ERXConfigurationManager.java
+++ b/Frameworks/Core/ERExtensions/Sources/er/extensions/foundation/ERXConfigurationManager.java
@@ -9,6 +9,7 @@
import java.util.Enumeration;
import java.util.Properties;
+import er.extensions.logging.ERXLoggingUtilities;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -289,7 +290,7 @@ public void loadConfiguration() {
ERXSystem.updateProperties();
}
- ERXLogger.configureLoggingWithSystemProperties();
+ ERXLoggingUtilities.configureLoggingWithSystemProperties();
}
/**
@@ -303,8 +304,8 @@ public Properties applyConfiguration(Properties systemProperties) {
/**
* Updates the configuration from the current configuration and
* posts {@link #ConfigurationDidChangeNotification}. It also
- * calls {@link er.extensions.logging.ERXLogger#configureLoggingWithSystemProperties()} to reconfigure
- * the logging system.
+ * calls {@link er.extensions.logging.ERXLoggingUtilities#configureLoggingWithSystemProperties()}
+ * to reconfigure the logging system.
*
* The configuration files: Properties and WebObjects.properties
* files are reloaded to the Java system properties by the same
diff --git a/Frameworks/Core/ERExtensions/Sources/er/extensions/logging/ERXLog4j1LoggingAdapter.java b/Frameworks/Core/ERExtensions/Sources/er/extensions/logging/ERXLog4j1LoggingAdapter.java
new file mode 100644
index 00000000000..d5809867af2
--- /dev/null
+++ b/Frameworks/Core/ERExtensions/Sources/er/extensions/logging/ERXLog4j1LoggingAdapter.java
@@ -0,0 +1,75 @@
+package er.extensions.logging;
+
+import org.apache.log4j.*;
+import org.apache.log4j.config.PropertyPrinter;
+
+import java.io.PrintWriter;
+import java.util.Enumeration;
+import java.util.Properties;
+
+class ERXLog4j1LoggingAdapter implements ERXLoggingAdapter {
+ private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(ERXLogger.class);
+
+ public void setLevel(org.slf4j.Logger aLogger, org.slf4j.event.Level level) {
+ Logger log4jLogger = ERXLoggingUtilities.toUnderlyingLoggerOfType(aLogger, Logger.class);
+ Level log4jLevel = toLog4j1Level(level);
+
+ log4jLogger.setLevel(log4jLevel);
+ }
+
+ public void reset() {
+ // ak: telling Log4J to re-init the Console appenders, so we get logging into WOOutputPath again
+ for (Enumeration e = Logger.getRootLogger().getAllAppenders(); e.hasMoreElements(); ) {
+ Appender appender = (Appender) e.nextElement();
+
+ if (appender instanceof ConsoleAppender) {
+ ConsoleAppender app = (ConsoleAppender) appender;
+ app.activateOptions();
+ }
+ }
+ }
+
+ public void configureLogging(Properties properties) {
+ LogManager.resetConfiguration();
+ BasicConfigurator.configure();
+
+ // AK: we re-configure the logging a few lines later from the properties,
+ // but in case no config is set, we set the root level to info, install the brigde
+ // which sets its own logging level to DEBUG and the output should be pretty
+ // much the same as with plain WO
+ Logger.getRootLogger().setLevel(Level.INFO);
+
+ PropertyConfigurator.configure(properties);
+
+ // AK: if the root logger has no appenders, something is really broken
+ // most likely the properties didn't read correctly.
+ if (!Logger.getRootLogger().getAllAppenders().hasMoreElements()) {
+ Appender appender = new ConsoleAppender(new ERXPatternLayout("%-5p %d{HH:mm:ss} (%-20c:%L): %m%n"), "System.out");
+ Logger.getRootLogger().addAppender(appender);
+ Logger.getRootLogger().setLevel(Level.DEBUG);
+ Logger.getRootLogger().error("Logging prefs couldn't get read from properties, using defaults");
+ }
+
+ log.info("Updated the logging configuration with the current system properties.");
+
+ PropertyPrinter printer = new PropertyPrinter(new PrintWriter(System.out));
+ printer.print(new PrintWriter(System.out));
+ }
+
+ private Level toLog4j1Level(org.slf4j.event.Level level) {
+ switch (level) {
+ case TRACE:
+ return Level.TRACE;
+ case DEBUG:
+ return Level.DEBUG;
+ case INFO:
+ return Level.INFO;
+ case WARN:
+ return Level.WARN;
+ case ERROR:
+ return Level.ERROR;
+ default:
+ throw new IllegalStateException("Level " + level + " cannot be converted to " + Level.class.getName());
+ }
+ }
+}
diff --git a/Frameworks/Core/ERExtensions/Sources/er/extensions/logging/ERXLog4j2LoggingAdapter.java b/Frameworks/Core/ERExtensions/Sources/er/extensions/logging/ERXLog4j2LoggingAdapter.java
new file mode 100644
index 00000000000..bd52855747e
--- /dev/null
+++ b/Frameworks/Core/ERExtensions/Sources/er/extensions/logging/ERXLog4j2LoggingAdapter.java
@@ -0,0 +1,44 @@
+package er.extensions.logging;
+
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.core.config.Configurator;
+
+import java.util.Properties;
+
+class ERXLog4j2LoggingAdapter implements ERXLoggingAdapter {
+ @Override
+ public void setLevel(org.slf4j.Logger aLogger, org.slf4j.event.Level level) {
+ Logger log4j2Logger = ERXLoggingUtilities.toUnderlyingLoggerOfType(aLogger, Logger.class);
+ Level log4j2Level = toLog4j2Level(level);
+
+ Configurator.setLevel(log4j2Logger.getName(), log4j2Level);
+ }
+
+ @Override
+ public void reset() {
+ // Not supported
+ }
+
+ @Override
+ public void configureLogging(Properties properties) {
+ // Not supported
+ }
+
+ private Level toLog4j2Level(org.slf4j.event.Level level) {
+ switch (level) {
+ case TRACE:
+ return Level.TRACE;
+ case DEBUG:
+ return Level.DEBUG;
+ case INFO:
+ return Level.INFO;
+ case WARN:
+ return Level.WARN;
+ case ERROR:
+ return Level.ERROR;
+ default:
+ throw new IllegalStateException("Level " + level + " cannot be converted to " + Level.class.getName());
+ }
+ }
+}
diff --git a/Frameworks/Core/ERExtensions/Sources/er/extensions/logging/ERXLogbackLoggingAdapter.java b/Frameworks/Core/ERExtensions/Sources/er/extensions/logging/ERXLogbackLoggingAdapter.java
new file mode 100644
index 00000000000..162b1e26998
--- /dev/null
+++ b/Frameworks/Core/ERExtensions/Sources/er/extensions/logging/ERXLogbackLoggingAdapter.java
@@ -0,0 +1,43 @@
+package er.extensions.logging;
+
+import ch.qos.logback.classic.Level;
+import ch.qos.logback.classic.Logger;
+
+import java.util.Properties;
+
+class ERXLogbackLoggingAdapter implements ERXLoggingAdapter {
+ @Override
+ public void setLevel(org.slf4j.Logger aLogger, org.slf4j.event.Level level) {
+ Logger logbackLogger = (Logger) aLogger;
+ Level logbackLevel = toLogbackLevel(level);
+
+ logbackLogger.setLevel(logbackLevel);
+ }
+
+ @Override
+ public void reset() {
+ // Not supported
+ }
+
+ @Override
+ public void configureLogging(Properties properties) {
+ // Not supported
+ }
+
+ private Level toLogbackLevel(org.slf4j.event.Level level) {
+ switch (level) {
+ case TRACE:
+ return Level.TRACE;
+ case DEBUG:
+ return Level.DEBUG;
+ case INFO:
+ return Level.INFO;
+ case WARN:
+ return Level.WARN;
+ case ERROR:
+ return Level.ERROR;
+ default:
+ throw new IllegalStateException("Level " + level + " cannot be converted to " + Level.class.getName());
+ }
+ }
+}
diff --git a/Frameworks/Core/ERExtensions/Sources/er/extensions/logging/ERXLogger.java b/Frameworks/Core/ERExtensions/Sources/er/extensions/logging/ERXLogger.java
index 3e62e9a90f2..f2dd683c783 100644
--- a/Frameworks/Core/ERExtensions/Sources/er/extensions/logging/ERXLogger.java
+++ b/Frameworks/Core/ERExtensions/Sources/er/extensions/logging/ERXLogger.java
@@ -1,20 +1,11 @@
package er.extensions.logging;
-import java.util.Properties;
-
-import org.apache.log4j.Appender;
-import org.apache.log4j.BasicConfigurator;
-import org.apache.log4j.ConsoleAppender;
-import org.apache.log4j.Level;
-import org.apache.log4j.LogManager;
-import org.apache.log4j.Logger;
-import org.apache.log4j.PropertyConfigurator;
-
-import com.webobjects.foundation.NSLog;
-import com.webobjects.foundation.NSNotificationCenter;
-
-import er.extensions.foundation.ERXConfigurationManager;
import er.extensions.foundation.ERXSystem;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.slf4j.Marker;
+
+import java.util.Properties;
/**
* Custom subclass of Logger. The main reason for this class is to isolate the
@@ -22,213 +13,404 @@
* to switch logging systems and this should be the only effected class .. in
* theory.
*/
-public class ERXLogger extends org.apache.log4j.Logger {
-
- public static final String CONFIGURE_LOGGING_WITH_SYSTEM_PROPERTIES = "configureLoggingWithSystemProperties";
-
- /** logging supprt */
- public static Logger log;
- public static Factory factory = null;
- static {
- String factoryClassName = System.getProperty("log4j.loggerFactory");
- if (factoryClassName == null) {
- factoryClassName = ERXLogger.Factory.class.getName();
- }
- if (factoryClassName.indexOf("ERXLogger$Factory") >= 0) {
- System.getProperties().remove("log4j.loggerFactory");
- factoryClassName = null;
- }
- if (factoryClassName != null) {
- try {
- ERXLogger.factory = (Factory) Class.forName(factoryClassName).newInstance();
- }
- catch (Exception ex) {
- System.err.println("Exception while creating logger factory of class " + factoryClassName + ": " + ex);
- }
- } else {
- ERXLogger.factory = new Factory();
- }
- }
-
- /**
- * LoggerFactory subclass that creates ERXLogger objects instead of the
- * default Logger classes.
- */
- public static class Factory implements org.apache.log4j.spi.LoggerFactory {
-
- /**
- * Overriden method used to create new Logger classes.
- *
- * @param name
- * to create the new Logger instance for
- * @return new Logger object for the given name
- */
- public Logger makeNewLoggerInstance(String name) {
- if (ERXLogger.log != null && ERXLogger.log.isDebugEnabled()) {
- ERXLogger.log.debug("makeNewLoggerInstance: " + name);
- }
- return new ERXLogger(name);
- }
-
- /**
- * Override this in your own subclass to do somthing after the logging
- * config did change.
- *
- */
- public void loggingConfigurationDidChange() {
- // default is to do nothing
- }
- }
-
- /**
- * Main entry point for getting an Logger for a given name. Calls getLogger
- * to return the instance of Logger from our custom Factory.
- *
- * Note that if the log4j system has not been setup correctly, meaning the
- * LoggerFactory subclass has not been correctly put in place, then
- * RuntimeException will be thrown.
- *
- * @param name
- * to create the logger for
- * @return Logger for the given name.
- */
- public static ERXLogger getERXLogger(String name) {
- Logger logger = ERXLogger.getLogger(name);
- if (logger != null && !(logger instanceof ERXLogger)) {
- ERXLogger.configureLoggingWithSystemProperties();
- logger = ERXLogger.getLogger(name);
- }
- if (logger != null && !(logger instanceof ERXLogger)) {
- throw new RuntimeException("Can't load Logger for \"" + name + "\" because it is not of class ERXLogger but \"" + logger.getClass().getName() + "\". Let your Application class inherit from ERXApplication or call ERXLog4j.configureLogging() statically the first thing in your app. \nAlso check if there is a \"log4j.loggerFactory=er.extensions.Logger$Factory\" line in your properties.");
- }
- return (ERXLogger) logger;
- }
-
- /**
- * Overrides method of superclass to return a logger using our custom
- * Logger$Factory class. This works identical to
- * {@link org.apache.log4j.Logger#getLogger log4.Logger.getLogger}
- *
- * @param name
- * to create the logger for
- * @return Logger for the given name.
- */
- public static Logger getLogger(String name) {
- return Logger.getLogger(name, ERXLogger.factory);
- }
-
- /**
- * Creates a logger for a given class object. Gets a logger for the fully
- * qualified class name of the given class.
- *
- * @param clazz
- * Class object to create the logger for
- * @return logger for the given class name
- */
- public static ERXLogger getERXLogger(Class clazz) {
- return ERXLogger.getERXLogger(clazz.getName());
- }
-
- public static Logger getLogger(Class clazz) {
- return ERXLogger.getERXLogger(clazz);
- }
-
- /**
- * Creates a logger for the given class object plus a restricting subtopic.
- * For instance if you had the class a.b.Foo and you wanted to
- * create a logger for the subtopic 'utilities' for the class Foo then the
- * created logging logger would have the path:
- * a.b.Foo.utilities.
- *
- * @param clazz
- * Class object to create the logger for
- * @param subTopic
- * to restrict the current logger to
- * @return logger for the given class and subtopic
- */
- // ENHANCEME: We could do something more useful here...
- public static ERXLogger getERXLogger(Class clazz, String subTopic) {
- return ERXLogger.getERXLogger(clazz.getName() + (subTopic != null && subTopic.length() > 0 ? "." + subTopic : null));
- }
-
- /**
- * Default constructor. Constructs a logger for the given name.
- *
- * @param name
- * of the logging logger
- */
- public ERXLogger(String name) {
- super(name);
- }
-
- public static synchronized void configureLoggingWithSystemProperties() {
- ERXLogger.configureLogging(ERXSystem.getProperties());
- }
-
- /**
- * Sets up the logging system with the given configuration in
- * {@link java.util.Properties} format.
- *
- * @param properties
- * with the logging configuration
- */
- public static synchronized void configureLogging(Properties properties) {
- LogManager.resetConfiguration();
- BasicConfigurator.configure();
- // AK: we re-configure the logging a few lines later from the
- // properties, but in case
- // no config is set, we set the root level to info, install the brigde
- // which sets it's own logging level to DEBUG
- // and the output should be pretty much the same as with plain WO
- Logger.getRootLogger().setLevel(Level.INFO);
- int allowedLevel = NSLog.debug.allowedDebugLevel();
- if (!(NSLog.debug instanceof ERXNSLogLog4jBridge)) {
- NSLog.setOut(new ERXNSLogLog4jBridge(ERXNSLogLog4jBridge.OUT));
- NSLog.setErr(new ERXNSLogLog4jBridge(ERXNSLogLog4jBridge.ERR));
- NSLog.setDebug(new ERXNSLogLog4jBridge(ERXNSLogLog4jBridge.DEBUG));
- }
- NSLog.debug.setAllowedDebugLevel(allowedLevel);
- PropertyConfigurator.configure(properties);
- // AK: if the root logger has no appenders, something is really broken
- // most likely the properties didn't read correctly.
- if (!Logger.getRootLogger().getAllAppenders().hasMoreElements()) {
- Appender appender = new ConsoleAppender(new ERXPatternLayout("%-5p %d{HH:mm:ss} (%-20c:%L): %m%n"), "System.out");
- Logger.getRootLogger().addAppender(appender);
- Logger.getRootLogger().setLevel(Level.DEBUG);
- Logger.getRootLogger().error("Logging prefs couldn't get read from properties, using defaults");
- }
- if (ERXLogger.log == null) {
- ERXLogger.log = Logger.getLogger(Logger.class);
- }
- ERXLogger.log.info("Updated the logging configuration with the current system properties.");
- if (ERXLogger.log.isDebugEnabled()) {
- ERXLogger.log.debug("log4j.loggerFactory: " + System.getProperty("log4j.loggerFactory"));
- ERXLogger.log.debug("Factory: " + ERXLogger.factory);
- // MS: This just trips everyone up, and it really seems to only be
- // used by PW developers, so I say we just turn it on when we need it.
- // log.debug("", new RuntimeException(
- // "This is not a real exception. It is just to show you where logging was initialized."
- // ));
- }
- // PropertyPrinter printer = new PropertyPrinter(new
- // PrintWriter(System.out));
- // printer.print(new PrintWriter(System.out));
- if (ERXLogger.factory != null) {
- ERXLogger.factory.loggingConfigurationDidChange();
- }
-
- NSNotificationCenter.defaultCenter().postNotification(ERXConfigurationManager.ConfigurationDidChangeNotification, null);
- }
-
- /**
- * Dumps an Throwable's Stack trace on the appender if debugging is enabled.
- *
- * @param throwable
- * throwable to dump
- */
- public void debugStackTrace(Throwable throwable) {
- if (isDebugEnabled()) {
- throwable.printStackTrace();
- }
- }
+public class ERXLogger implements org.slf4j.Logger {
+
+ public static final String CONFIGURE_LOGGING_WITH_SYSTEM_PROPERTIES = "configureLoggingWithSystemProperties";
+
+ /**
+ * Main entry point for getting a Logger for a given name. Calls getLogger
+ * to return the instance of Logger.
+ *
+ * @param name to create the logger for
+ * @return Logger for the given name.
+ */
+ public static ERXLogger getERXLogger(String name) {
+ ERXLogger logger = new ERXLogger(name);
+ ERXLoggingUtilities.configureLoggingWithSystemProperties();
+
+ return logger;
+ }
+
+ /**
+ * Overrides method of superclass to return a logger using the {@code org.slf4j.LoggerFactory} class.
+ * This works identical to {@link org.slf4j.LoggerFactory#getLogger(String)}
+ *
+ * @param name to create the logger for
+ * @return Logger for the given name.
+ */
+ public static Logger getLogger(String name) {
+ return ERXLogger.getERXLogger(name);
+ }
+
+ /**
+ * Creates a logger for a given class object. Gets a logger for the fully
+ * qualified class name of the given class.
+ *
+ * @param clazz Class object to create the logger for
+ * @return logger for the given class name
+ */
+ public static ERXLogger getERXLogger(Class clazz) {
+ return ERXLogger.getERXLogger(clazz.getName());
+ }
+
+ public static Logger getLogger(Class clazz) {
+ return ERXLogger.getERXLogger(clazz);
+ }
+
+ /**
+ * Creates a logger for the given class object plus a restricting subtopic.
+ * For instance if you had the class a.b.Foo and you wanted to
+ * create a logger for the subtopic 'utilities' for the class Foo then the
+ * created logging logger would have the path:
+ * a.b.Foo.utilities.
+ *
+ * @param clazz Class object to create the logger for
+ * @param subTopic to restrict the current logger to
+ * @return logger for the given class and subtopic
+ */
+ // ENHANCEME: We could do something more useful here...
+ public static ERXLogger getERXLogger(Class clazz, String subTopic) {
+ return ERXLogger.getERXLogger(clazz.getName() + (subTopic != null && subTopic.length() > 0 ? "." + subTopic : null));
+ }
+
+ public static void configureLoggingWithSystemProperties() {
+ ERXLoggingUtilities.configureLogging(ERXSystem.getProperties());
+ }
+
+ /**
+ * Sets up the logging system with the given configuration in
+ * {@link java.util.Properties} format.
+ *
+ * @param properties with the logging configuration
+ */
+ public static void configureLogging(Properties properties) {
+ ERXLoggingUtilities.configureLogging(properties);
+ }
+
+ private final Logger logger;
+
+ /**
+ * Default constructor. Constructs a logger for the given name.
+ *
+ * @param name of the logging logger
+ */
+ public ERXLogger(String name) {
+ logger = LoggerFactory.getLogger(name);
+ }
+
+ @Override
+ public String getName() {
+ return logger.getName();
+ }
+
+ @Override
+ public boolean isTraceEnabled() {
+ return logger.isTraceEnabled();
+ }
+
+ @Override
+ public void trace(String msg) {
+ logger.trace(msg);
+ }
+
+ @Override
+ public void trace(String format, Object arg) {
+ logger.trace(format, arg);
+ }
+
+ @Override
+ public void trace(String format, Object arg1, Object arg2) {
+ logger.trace(format, arg1, arg2);
+ }
+
+ @Override
+ public void trace(String format, Object... arguments) {
+ logger.trace(format, arguments);
+ }
+
+ @Override
+ public void trace(String msg, Throwable t) {
+ logger.trace(msg, t);
+ }
+
+ @Override
+ public boolean isTraceEnabled(Marker marker) {
+ return logger.isTraceEnabled(marker);
+ }
+
+ @Override
+ public void trace(Marker marker, String msg) {
+ logger.trace(marker, msg);
+ }
+
+ @Override
+ public void trace(Marker marker, String format, Object arg) {
+ logger.trace(marker, format, arg);
+ }
+
+ @Override
+ public void trace(Marker marker, String format, Object arg1, Object arg2) {
+ logger.trace(marker, format, arg1, arg2);
+ }
+
+ @Override
+ public void trace(Marker marker, String format, Object... argArray) {
+ logger.trace(marker, format, argArray);
+ }
+
+ @Override
+ public void trace(Marker marker, String msg, Throwable t) {
+ logger.trace(marker, msg, t);
+ }
+
+ @Override
+ public boolean isDebugEnabled() {
+ return logger.isDebugEnabled();
+ }
+
+ @Override
+ public void debug(String msg) {
+ logger.debug(msg);
+ }
+
+ @Override
+ public void debug(String format, Object arg) {
+ logger.debug(format, arg);
+ }
+
+ @Override
+ public void debug(String format, Object arg1, Object arg2) {
+ logger.debug(format, arg1, arg2);
+ }
+
+ @Override
+ public void debug(String format, Object... arguments) {
+ logger.debug(format, arguments);
+ }
+
+ @Override
+ public void debug(String msg, Throwable t) {
+ logger.debug(msg, t);
+ }
+
+ @Override
+ public boolean isDebugEnabled(Marker marker) {
+ return logger.isDebugEnabled(marker);
+ }
+
+ @Override
+ public void debug(Marker marker, String msg) {
+ logger.debug(marker, msg);
+ }
+
+ @Override
+ public void debug(Marker marker, String format, Object arg) {
+ logger.debug(marker, format, arg);
+ }
+
+ @Override
+ public void debug(Marker marker, String format, Object arg1, Object arg2) {
+ logger.debug(marker, format, arg1, arg2);
+ }
+
+ @Override
+ public void debug(Marker marker, String format, Object... arguments) {
+ logger.debug(marker, format, arguments);
+ }
+
+ @Override
+ public void debug(Marker marker, String msg, Throwable t) {
+ logger.debug(marker, msg, t);
+ }
+
+ @Override
+ public boolean isInfoEnabled() {
+ return logger.isInfoEnabled();
+ }
+
+ @Override
+ public void info(String msg) {
+ logger.info(msg);
+ }
+
+ @Override
+ public void info(String format, Object arg) {
+ logger.info(format, arg);
+ }
+
+ @Override
+ public void info(String format, Object arg1, Object arg2) {
+ logger.info(format, arg1, arg2);
+ }
+
+ @Override
+ public void info(String format, Object... arguments) {
+ logger.info(format, arguments);
+ }
+
+ @Override
+ public void info(String msg, Throwable t) {
+ logger.info(msg, t);
+ }
+
+ @Override
+ public boolean isInfoEnabled(Marker marker) {
+ return logger.isInfoEnabled(marker);
+ }
+
+ @Override
+ public void info(Marker marker, String msg) {
+ logger.info(marker, msg);
+ }
+
+ @Override
+ public void info(Marker marker, String format, Object arg) {
+ logger.info(marker, format, arg);
+ }
+
+ @Override
+ public void info(Marker marker, String format, Object arg1, Object arg2) {
+ logger.info(marker, format, arg1, arg2);
+ }
+
+ @Override
+ public void info(Marker marker, String format, Object... arguments) {
+ logger.info(marker, format, arguments);
+ }
+
+ @Override
+ public void info(Marker marker, String msg, Throwable t) {
+ logger.info(marker, msg, t);
+ }
+
+ @Override
+ public boolean isWarnEnabled() {
+ return logger.isWarnEnabled();
+ }
+
+ @Override
+ public void warn(String msg) {
+ logger.warn(msg);
+ }
+
+ @Override
+ public void warn(String format, Object arg) {
+ logger.warn(format, arg);
+ }
+
+ @Override
+ public void warn(String format, Object... arguments) {
+ logger.warn(format, arguments);
+ }
+
+ @Override
+ public void warn(String format, Object arg1, Object arg2) {
+ logger.warn(format, arg1, arg2);
+ }
+
+ @Override
+ public void warn(String msg, Throwable t) {
+ logger.warn(msg, t);
+ }
+
+ @Override
+ public boolean isWarnEnabled(Marker marker) {
+ return logger.isWarnEnabled(marker);
+ }
+
+ @Override
+ public void warn(Marker marker, String msg) {
+ logger.warn(marker, msg);
+ }
+
+ @Override
+ public void warn(Marker marker, String format, Object arg) {
+ logger.warn(marker, format, arg);
+ }
+
+ @Override
+ public void warn(Marker marker, String format, Object arg1, Object arg2) {
+ logger.warn(marker, format, arg1, arg2);
+ }
+
+ @Override
+ public void warn(Marker marker, String format, Object... arguments) {
+ logger.warn(marker, format, arguments);
+ }
+
+ @Override
+ public void warn(Marker marker, String msg, Throwable t) {
+ logger.warn(marker, msg, t);
+ }
+
+ @Override
+ public boolean isErrorEnabled() {
+ return logger.isErrorEnabled();
+ }
+
+ @Override
+ public void error(String msg) {
+ logger.error(msg);
+ }
+
+ @Override
+ public void error(String format, Object arg) {
+ logger.error(format, arg);
+ }
+
+ @Override
+ public void error(String format, Object arg1, Object arg2) {
+ logger.error(format, arg1, arg2);
+ }
+
+ @Override
+ public void error(String format, Object... arguments) {
+ logger.error(format, arguments);
+ }
+
+ @Override
+ public void error(String msg, Throwable t) {
+ logger.error(msg, t);
+ }
+
+ @Override
+ public boolean isErrorEnabled(Marker marker) {
+ return logger.isErrorEnabled(marker);
+ }
+
+ @Override
+ public void error(Marker marker, String msg) {
+ logger.error(marker, msg);
+ }
+
+ @Override
+ public void error(Marker marker, String format, Object arg) {
+ logger.error(marker, format, arg);
+ }
+
+ @Override
+ public void error(Marker marker, String format, Object arg1, Object arg2) {
+ logger.error(marker, format, arg1, arg2);
+ }
+
+ @Override
+ public void error(Marker marker, String format, Object... arguments) {
+ logger.error(marker, format, arguments);
+ }
+
+ @Override
+ public void error(Marker marker, String msg, Throwable t) {
+ logger.error(marker, msg, t);
+ }
+
+ /**
+ * Dumps a Throwable's Stack trace on the appender if debugging is enabled.
+ *
+ * @param throwable throwable to dump
+ */
+ public void debugStackTrace(Throwable throwable) {
+ if (isDebugEnabled()) {
+ logger.debug("", throwable);
+ }
+ }
}
diff --git a/Frameworks/Core/ERExtensions/Sources/er/extensions/logging/ERXLoggingAdapter.java b/Frameworks/Core/ERExtensions/Sources/er/extensions/logging/ERXLoggingAdapter.java
new file mode 100644
index 00000000000..70f6b5c33e4
--- /dev/null
+++ b/Frameworks/Core/ERExtensions/Sources/er/extensions/logging/ERXLoggingAdapter.java
@@ -0,0 +1,14 @@
+package er.extensions.logging;
+
+import org.slf4j.Logger;
+import org.slf4j.event.Level;
+
+import java.util.Properties;
+
+interface ERXLoggingAdapter {
+ void setLevel(Logger aLogger, Level level);
+
+ void reset();
+
+ void configureLogging(Properties properties);
+}
\ No newline at end of file
diff --git a/Frameworks/Core/ERExtensions/Sources/er/extensions/logging/ERXLoggingUtilities.java b/Frameworks/Core/ERExtensions/Sources/er/extensions/logging/ERXLoggingUtilities.java
new file mode 100644
index 00000000000..436b1e6a140
--- /dev/null
+++ b/Frameworks/Core/ERExtensions/Sources/er/extensions/logging/ERXLoggingUtilities.java
@@ -0,0 +1,123 @@
+package er.extensions.logging;
+
+import com.webobjects.foundation.NSLog;
+import com.webobjects.foundation.NSNotificationCenter;
+import er.extensions.foundation.ERXSystem;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.slf4j.event.Level;
+import org.slf4j.impl.StaticLoggerBinder;
+
+import java.lang.reflect.Field;
+import java.util.Properties;
+
+import er.extensions.foundation.ERXConfigurationManager;
+
+public class ERXLoggingUtilities {
+ private enum Slf4jBinding {
+ LOG4J_1, LOG4J_2, LOGBACK, RELOAD4J, UNKNOWN;
+
+ public static Slf4jBinding currentBinding() {
+ String loggerBinderName;
+
+ try {
+ loggerBinderName = StaticLoggerBinder.getSingleton().getLoggerFactory().getClass().getName();
+ } catch (NoClassDefFoundError exception) {
+ // If no binding is found on the class path, then slf4j will default to a no-operation implementation.
+ return UNKNOWN;
+ }
+
+ switch (loggerBinderName) {
+ case "org.slf4j.impl.Log4jLoggerFactory":
+ return LOG4J_1;
+ case "org.apache.logging.slf4j.Log4jLoggerFactory":
+ return LOG4J_2;
+ case "ch.qos.logback.classic.LoggerContext":
+ return LOGBACK;
+ case "org.slf4j.impl.Reload4jLoggerFactory":
+ return RELOAD4J;
+ default:
+ return UNKNOWN;
+ }
+ }
+ }
+
+ public static final String CONFIGURE_LOGGING_WITH_SYSTEM_PROPERTIES = "configureLoggingWithSystemProperties";
+
+ private static final ERXLoggingAdapter loggingAdapter = createLoggingAdapterFor(Slf4jBinding.currentBinding());
+
+ private static final Logger log = LoggerFactory.getLogger(ERXLoggingUtilities.class);
+
+ public static void setLevel(Logger aLogger, Level level) {
+ loggingAdapter.setLevel(aLogger, level);
+ }
+
+ public static void configureLoggingWithSystemProperties() {
+ configureLogging(ERXSystem.getProperties());
+ }
+
+ /**
+ * Sets up the logging system with the given configuration in
+ * {@link java.util.Properties} format.
+ *
+ * @param properties with the logging configuration
+ */
+ public static synchronized void configureLogging(Properties properties) {
+ int allowedLevel = NSLog.debug.allowedDebugLevel();
+
+ if (!(NSLog.debug instanceof ERXNSLogSlf4jBridge)) {
+ NSLog.setOut(new ERXNSLogSlf4jBridge(ERXNSLogSlf4jBridge.OUT));
+ NSLog.setErr(new ERXNSLogSlf4jBridge(ERXNSLogSlf4jBridge.ERR));
+ NSLog.setDebug(new ERXNSLogSlf4jBridge(ERXNSLogSlf4jBridge.DEBUG));
+ }
+
+ NSLog.debug.setAllowedDebugLevel(allowedLevel);
+
+ loggingAdapter.configureLogging(properties);
+
+ NSNotificationCenter.defaultCenter().postNotification(ERXConfigurationManager.ConfigurationDidChangeNotification, null);
+ }
+
+ public static void resetLoggingAdapter() {
+ loggingAdapter.reset();
+ }
+
+ static T toUnderlyingLoggerOfType(Logger logger, Class loggerClass) {
+ try {
+ Class loggerType = logger.getClass();
+ Field fields[] = loggerType.getDeclaredFields();
+
+ for (int i = 0; i < fields.length; i++) {
+ String fieldName = fields[i].getName();
+
+ if (fieldName.equals("logger")) {
+ fields[i].setAccessible(true);
+
+ return loggerClass.cast(fields[i].get(logger));
+ }
+ }
+ } catch (Exception exception) {
+ log.error("Cannot extract a " + loggerClass.getName() + " from " + Logger.class.getName(), exception);
+ }
+
+ return null;
+ }
+
+ private static ERXLoggingAdapter createLoggingAdapterFor(Slf4jBinding binding) {
+ switch (binding) {
+ case LOG4J_1:
+ case RELOAD4J:
+ return new ERXLog4j1LoggingAdapter();
+ case LOG4J_2:
+ return new ERXLog4j2LoggingAdapter();
+ case LOGBACK:
+ return new ERXLogbackLoggingAdapter();
+ default:
+ return new ERXNoopLoggingAdapter();
+ }
+ }
+
+ private ERXLoggingUtilities() {
+ throw new UnsupportedOperationException("Cannot create an instance of " + getClass().getName());
+ }
+}
diff --git a/Frameworks/Core/ERExtensions/Sources/er/extensions/logging/ERXNSLogSlf4jBridge.java b/Frameworks/Core/ERExtensions/Sources/er/extensions/logging/ERXNSLogSlf4jBridge.java
new file mode 100644
index 00000000000..6d5c8962146
--- /dev/null
+++ b/Frameworks/Core/ERExtensions/Sources/er/extensions/logging/ERXNSLogSlf4jBridge.java
@@ -0,0 +1,75 @@
+package er.extensions.logging;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.slf4j.event.Level;
+
+import com.webobjects.foundation.NSLog;
+
+import er.extensions.foundation.ERXProperties;
+
+public class ERXNSLogSlf4jBridge extends NSLog.PrintStreamLogger {
+ public static final Logger log = LoggerFactory.getLogger("NSLog");
+ public static final int OUT = 1;
+ public static final int ERR = 2;
+ public static final int DEBUG = 3;
+ private final int type;
+
+ public ERXNSLogSlf4jBridge(int type) {
+ super();
+
+ this.type = type;
+ }
+
+ @Override
+ public void appendln(Object obj) {
+ if (obj == null) {
+ obj = "";
+ }
+
+ if (isEnabled()) {
+ switch (type) {
+ case OUT:
+ log.info(obj.toString());
+ break;
+ case ERR:
+ log.error(obj.toString());
+ break;
+ case DEBUG:
+ log.debug(obj.toString());
+ break;
+ }
+ }
+ else {
+ if (type == ERR)
+ log.error(obj.toString());
+ }
+ }
+
+ @Override
+ public void setIsEnabled(boolean enabled) {
+ super.setIsEnabled(enabled);
+
+ if (type == DEBUG && !ERXProperties.booleanForKeyWithDefault("er.extensions.ERXNSLogSlf4jBridge.ignoreNSLogSettings", false)) {
+ ERXLoggingUtilities.setLevel(log, enabled ? Level.DEBUG : Level.INFO);
+ }
+ }
+
+ @Override
+ public void setAllowedDebugLevel(int debugLevel) {
+ super.setAllowedDebugLevel(debugLevel);
+
+ if (type == DEBUG && !ERXProperties.booleanForKeyWithDefault("er.extensions.ERXNSLogSlf4jBridge.ignoreNSLogSettings", false)) {
+ ERXLoggingUtilities.setLevel(log, debugLevel != NSLog.DebugLevelOff ? Level.DEBUG : Level.INFO);
+ }
+ }
+
+ @Override
+ public void appendln() {
+ appendln(""); // Assuming people will always put "%n" at the end of the layout pattern.
+ }
+
+ @Override
+ public void flush() {
+ }
+}
diff --git a/Frameworks/Core/ERExtensions/Sources/er/extensions/logging/ERXNoopLoggingAdapter.java b/Frameworks/Core/ERExtensions/Sources/er/extensions/logging/ERXNoopLoggingAdapter.java
new file mode 100644
index 00000000000..c88889a3600
--- /dev/null
+++ b/Frameworks/Core/ERExtensions/Sources/er/extensions/logging/ERXNoopLoggingAdapter.java
@@ -0,0 +1,23 @@
+package er.extensions.logging;
+
+import org.slf4j.Logger;
+import org.slf4j.event.Level;
+
+import java.util.Properties;
+
+class ERXNoopLoggingAdapter implements ERXLoggingAdapter {
+ @Override
+ public void setLevel(Logger aLogger, Level level) {
+ // Do nothing
+ }
+
+ @Override
+ public void reset() {
+ // Do nothing
+ }
+
+ @Override
+ public void configureLogging(Properties properties) {
+ // Do nothing
+ }
+}
diff --git a/Frameworks/Core/ERExtensions/Sources/er/extensions/statistics/ERXStats.java b/Frameworks/Core/ERExtensions/Sources/er/extensions/statistics/ERXStats.java
index 40368b3e36b..4ae1d669dae 100644
--- a/Frameworks/Core/ERExtensions/Sources/er/extensions/statistics/ERXStats.java
+++ b/Frameworks/Core/ERExtensions/Sources/er/extensions/statistics/ERXStats.java
@@ -7,7 +7,8 @@
import java.util.HashSet;
import java.util.Set;
-import org.apache.log4j.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import com.webobjects.foundation.NSArray;
import com.webobjects.foundation.NSMutableArray;
@@ -66,7 +67,7 @@ public class ERXStats {
public static final String STATS_ENABLED_KEY = "er.extensions.erxStats.enabled";
public static final String STATS_TRACE_COLLECTING_ENABLED_KEY = "er.extensions.erxStats.traceCollectingEnabled";
- public static final Logger log = Logger.getLogger(ERXStats.class);
+ public static final Logger log = LoggerFactory.getLogger(ERXStats.class);
public interface Group {
public String Default = " ";
diff --git a/Frameworks/Core/ERExtensions/pom.xml b/Frameworks/Core/ERExtensions/pom.xml
index 9a1a3fc1a7f..b3728ee03a2 100644
--- a/Frameworks/Core/ERExtensions/pom.xml
+++ b/Frameworks/Core/ERExtensions/pom.xml
@@ -49,10 +49,6 @@
com.webobjects
JavaFoundation