From 80461746d9bbe8ee1070d455e2b32f8ef2b907c3 Mon Sep 17 00:00:00 2001 From: Vlad Rozov Date: Thu, 25 Aug 2016 13:33:19 -0700 Subject: [PATCH 1/2] APEXCORE-169 - instantiating DTLoggerFactory during test causes incorrect logging behavior --- .../stram/LaunchContainerRunnable.java | 5 ++--- .../com/datatorrent/stram/StramClient.java | 5 ++--- .../com/datatorrent/stram/StramUtils.java | 19 +++++++++++++++++-- .../stram/client/StramClientUtils.java | 4 ++-- .../stram/engine/StreamingContainer.java | 4 ++-- .../datatorrent/stram/util/LoggerUtil.java} | 0 .../stram/webapp/StramWebServices.java | 8 ++++---- .../stram/util/LoggerUtilTest.java} | 0 8 files changed, 29 insertions(+), 16 deletions(-) rename engine/src/main/java/{org/apache/log4j/DTLoggerFactory.java => com/datatorrent/stram/util/LoggerUtil.java} (100%) rename engine/src/test/java/{org/apache/log4j/DTLoggerFactoryTest.java => com/datatorrent/stram/util/LoggerUtilTest.java} (100%) diff --git a/engine/src/main/java/com/datatorrent/stram/LaunchContainerRunnable.java b/engine/src/main/java/com/datatorrent/stram/LaunchContainerRunnable.java index e9dd72bb8e..76c1407535 100644 --- a/engine/src/main/java/com/datatorrent/stram/LaunchContainerRunnable.java +++ b/engine/src/main/java/com/datatorrent/stram/LaunchContainerRunnable.java @@ -53,7 +53,6 @@ import org.apache.hadoop.yarn.security.AMRMTokenIdentifier; import org.apache.hadoop.yarn.util.ConverterUtils; import org.apache.hadoop.yarn.util.Records; -import org.apache.log4j.DTLoggerFactory; import com.google.common.collect.Lists; @@ -250,9 +249,9 @@ public List getChildVMCommand(String jvmID) vargs.add("-Dhadoop.root.logger=" + (dag.isDebug() ? "DEBUG" : "INFO") + ",RFA"); vargs.add("-Dhadoop.log.dir=" + ApplicationConstants.LOG_DIR_EXPANSION_VAR); - String loggersLevel = System.getProperty(DTLoggerFactory.DT_LOGGERS_LEVEL); + String loggersLevel = System.getProperty(StramUtils.DT_LOGGERS_LEVEL); if (loggersLevel != null) { - vargs.add(String.format("-D%s=%s", DTLoggerFactory.DT_LOGGERS_LEVEL, loggersLevel)); + vargs.add(String.format("-D%s=%s", StramUtils.DT_LOGGERS_LEVEL, loggersLevel)); } // Add main class and its arguments vargs.add(StreamingContainer.class.getName()); // main of Child diff --git a/engine/src/main/java/com/datatorrent/stram/StramClient.java b/engine/src/main/java/com/datatorrent/stram/StramClient.java index b95770f1c6..5854ec89c0 100644 --- a/engine/src/main/java/com/datatorrent/stram/StramClient.java +++ b/engine/src/main/java/com/datatorrent/stram/StramClient.java @@ -69,7 +69,6 @@ import org.apache.hadoop.yarn.exceptions.YarnException; import org.apache.hadoop.yarn.util.ConverterUtils; import org.apache.hadoop.yarn.util.Records; -import org.apache.log4j.DTLoggerFactory; import com.google.common.base.Objects; import com.google.common.collect.Lists; @@ -570,9 +569,9 @@ public void startApplication() throws YarnException, IOException vargs.add("-Dlog4j.debug=true"); } - String loggersLevel = conf.get(DTLoggerFactory.DT_LOGGERS_LEVEL); + String loggersLevel = conf.get(StramUtils.DT_LOGGERS_LEVEL); if (loggersLevel != null) { - vargs.add(String.format("-D%s=%s", DTLoggerFactory.DT_LOGGERS_LEVEL, loggersLevel)); + vargs.add(String.format("-D%s=%s", StramUtils.DT_LOGGERS_LEVEL, loggersLevel)); } vargs.add(StreamingAppMaster.class.getName()); vargs.add("1>" + ApplicationConstants.LOG_DIR_EXPANSION_VAR + "/AppMaster.stdout"); diff --git a/engine/src/main/java/com/datatorrent/stram/StramUtils.java b/engine/src/main/java/com/datatorrent/stram/StramUtils.java index a931253706..2b2baa69d3 100644 --- a/engine/src/main/java/com/datatorrent/stram/StramUtils.java +++ b/engine/src/main/java/com/datatorrent/stram/StramUtils.java @@ -28,9 +28,12 @@ import org.slf4j.LoggerFactory; import org.apache.hadoop.yarn.api.ApplicationConstants.Environment; -import org.apache.log4j.DTLoggerFactory; + +import com.google.common.base.Strings; +import com.google.common.collect.Maps; import com.datatorrent.api.StreamingApplication; +import com.datatorrent.stram.util.LoggerUtil; /** * @@ -42,6 +45,7 @@ public abstract class StramUtils { private static final Logger LOG = LoggerFactory.getLogger(StramUtils.class); + public static final String DT_LOGGERS_LEVEL = "dt.loggers.level"; public static Class classForName(String className, Class superClass) { @@ -85,7 +89,18 @@ public abstract static class YarnContainerMain } } } - DTLoggerFactory.getInstance().initialize(); + + String loggersLevel = System.getProperty(DT_LOGGERS_LEVEL); + if (!Strings.isNullOrEmpty(loggersLevel)) { + Map targetChanges = Maps.newHashMap(); + String[] targets = loggersLevel.split(","); + for (String target : targets) { + String[] parts = target.split(":"); + targetChanges.put(parts[0], parts[1]); + } + LoggerUtil.changeLoggersLevel(targetChanges); + } + } } diff --git a/engine/src/main/java/com/datatorrent/stram/client/StramClientUtils.java b/engine/src/main/java/com/datatorrent/stram/client/StramClientUtils.java index fc60961bf4..02f2629729 100644 --- a/engine/src/main/java/com/datatorrent/stram/client/StramClientUtils.java +++ b/engine/src/main/java/com/datatorrent/stram/client/StramClientUtils.java @@ -75,7 +75,6 @@ import org.apache.hadoop.yarn.ipc.YarnRPC; import org.apache.hadoop.yarn.security.client.RMDelegationTokenIdentifier; import org.apache.hadoop.yarn.util.ConverterUtils; -import org.apache.log4j.DTLoggerFactory; import com.google.common.base.Joiner; import com.google.common.base.Preconditions; @@ -83,6 +82,7 @@ import com.datatorrent.api.StreamingApplication; import com.datatorrent.stram.StramClient; +import com.datatorrent.stram.StramUtils; import com.datatorrent.stram.security.StramUserLogin; import com.datatorrent.stram.util.ConfigUtils; import com.datatorrent.stram.util.ConfigValidator; @@ -414,7 +414,7 @@ public static Configuration addDTSiteResources(Configuration conf) } //Validate loggers-level settings - String loggersLevel = conf.get(DTLoggerFactory.DT_LOGGERS_LEVEL); + String loggersLevel = conf.get(StramUtils.DT_LOGGERS_LEVEL); if (loggersLevel != null) { String[] targets = loggersLevel.split(","); Preconditions.checkArgument(targets.length > 0, "zero loggers level"); diff --git a/engine/src/main/java/com/datatorrent/stram/engine/StreamingContainer.java b/engine/src/main/java/com/datatorrent/stram/engine/StreamingContainer.java index 27688e370c..756fec265e 100644 --- a/engine/src/main/java/com/datatorrent/stram/engine/StreamingContainer.java +++ b/engine/src/main/java/com/datatorrent/stram/engine/StreamingContainer.java @@ -53,7 +53,6 @@ import org.apache.hadoop.security.UserGroupInformation; import org.apache.hadoop.security.token.Token; import org.apache.hadoop.yarn.conf.YarnConfiguration; -import org.apache.log4j.DTLoggerFactory; import org.apache.log4j.LogManager; import com.datatorrent.api.Attribute; @@ -118,6 +117,7 @@ import com.datatorrent.stram.stream.OiOStream; import com.datatorrent.stram.stream.PartitionAwareSink; import com.datatorrent.stram.stream.PartitionAwareSinkForPersistence; +import com.datatorrent.stram.util.LoggerUtil; import net.engio.mbassy.bus.MBassador; import net.engio.mbassy.bus.config.BusConfiguration; @@ -1623,7 +1623,7 @@ private T getValue(Attribute key, OperatorDeployInfo deployInfo) private void handleChangeLoggersRequest(StramToNodeChangeLoggersRequest request) { logger.debug("handle change logger request"); - DTLoggerFactory.getInstance().changeLoggersLevel(request.getTargetChanges()); + LoggerUtil.changeLoggersLevel(request.getTargetChanges()); } private final StreamCodec nonSerializingStreamCodec = new StreamCodec() diff --git a/engine/src/main/java/org/apache/log4j/DTLoggerFactory.java b/engine/src/main/java/com/datatorrent/stram/util/LoggerUtil.java similarity index 100% rename from engine/src/main/java/org/apache/log4j/DTLoggerFactory.java rename to engine/src/main/java/com/datatorrent/stram/util/LoggerUtil.java diff --git a/engine/src/main/java/com/datatorrent/stram/webapp/StramWebServices.java b/engine/src/main/java/com/datatorrent/stram/webapp/StramWebServices.java index f09a53e109..16b7ed7d6c 100644 --- a/engine/src/main/java/com/datatorrent/stram/webapp/StramWebServices.java +++ b/engine/src/main/java/com/datatorrent/stram/webapp/StramWebServices.java @@ -70,7 +70,6 @@ import org.apache.hadoop.security.UserGroupInformation; import org.apache.hadoop.yarn.api.ApplicationConstants; import org.apache.hadoop.yarn.webapp.NotFoundException; -import org.apache.log4j.DTLoggerFactory; import com.google.common.collect.Maps; import com.google.inject.Inject; @@ -93,6 +92,7 @@ import com.datatorrent.stram.plan.logical.requests.LogicalPlanRequest; import com.datatorrent.stram.util.ConfigValidator; import com.datatorrent.stram.util.JSONSerializationProvider; +import com.datatorrent.stram.util.LoggerUtil; /** * @@ -966,7 +966,7 @@ public JSONObject setLoggersLevel(JSONObject request) if (!targetChanges.isEmpty()) { dagManager.setLoggersLevel(Collections.unmodifiableMap(targetChanges)); //Changing the levels on Stram after sending the message to all containers. - DTLoggerFactory.getInstance().changeLoggersLevel(targetChanges); + LoggerUtil.changeLoggersLevel(targetChanges); } } catch (JSONException ex) { throw new RuntimeException(ex); @@ -984,7 +984,7 @@ public JSONObject searchLoggersLevel(@QueryParam("pattern") String pattern) JSONArray loggersArray = new JSONArray(); try { if (pattern != null) { - Map matches = DTLoggerFactory.getInstance().getClassesMatching(pattern); + Map matches = LoggerUtil.getClassesMatching(pattern); for (Map.Entry match : matches.entrySet()) { JSONObject node = new JSONObject(); node.put("name", match.getKey()); @@ -1007,7 +1007,7 @@ public JSONObject getLoggerLevels() throws JSONException init(); JSONObject response = new JSONObject(); JSONArray levelsArray = new JSONArray(); - Map currentLevels = DTLoggerFactory.getInstance().getPatternLevels(); + Map currentLevels = LoggerUtil.getPatternLevels(); for (Map.Entry lvl : currentLevels.entrySet()) { JSONObject node = new JSONObject(); node.put("target", lvl.getKey()); diff --git a/engine/src/test/java/org/apache/log4j/DTLoggerFactoryTest.java b/engine/src/test/java/com/datatorrent/stram/util/LoggerUtilTest.java similarity index 100% rename from engine/src/test/java/org/apache/log4j/DTLoggerFactoryTest.java rename to engine/src/test/java/com/datatorrent/stram/util/LoggerUtilTest.java From 9c48c41e989b917a9e6c59e3fb284432cd1664d3 Mon Sep 17 00:00:00 2001 From: Vlad Rozov Date: Thu, 25 Aug 2016 13:34:33 -0700 Subject: [PATCH 2/2] APEXCORE-169 - instantiating DTLoggerFactory during test causes incorrect logging behavior --- .../datatorrent/stram/util/LoggerUtil.java | 298 ++++++++++-------- .../stram/util/LoggerUtilTest.java | 173 ++++++---- 2 files changed, 282 insertions(+), 189 deletions(-) diff --git a/engine/src/main/java/com/datatorrent/stram/util/LoggerUtil.java b/engine/src/main/java/com/datatorrent/stram/util/LoggerUtil.java index 04e6856b53..e774bea7a5 100644 --- a/engine/src/main/java/com/datatorrent/stram/util/LoggerUtil.java +++ b/engine/src/main/java/com/datatorrent/stram/util/LoggerUtil.java @@ -16,95 +16,202 @@ * specific language governing permissions and limitations * under the License. */ -package org.apache.log4j; +package com.datatorrent.stram.util; import java.util.Enumeration; import java.util.Iterator; import java.util.Map; -import java.util.concurrent.ConcurrentMap; import java.util.regex.Pattern; import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import org.apache.log4j.Appender; +import org.apache.log4j.Category; +import org.apache.log4j.Level; +import org.apache.log4j.LogManager; +import org.apache.log4j.Logger; +import org.apache.log4j.spi.DefaultRepositorySelector; +import org.apache.log4j.spi.HierarchyEventListener; import org.apache.log4j.spi.LoggerFactory; import org.apache.log4j.spi.LoggerRepository; -import org.apache.log4j.spi.RepositorySelector; import com.google.common.base.Function; -import com.google.common.base.Strings; import com.google.common.collect.ImmutableMap; import com.google.common.collect.Maps; -/** - * An implementation of {@link LoggerFactory} - * - * @since 1.0.2 - */ -public class DTLoggerFactory implements LoggerFactory +public class LoggerUtil { - public static final String DT_LOGGERS_LEVEL = "dt.loggers.level"; - private static DTLoggerFactory SINGLETON; + private static final org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger(LoggerUtil.class); - public static synchronized DTLoggerFactory getInstance() + private static final Map patternLevel = Maps.newHashMap(); + private static final Map patterns = Maps.newHashMap(); + private static final Function levelToString = new Function() { - if (SINGLETON == null) { - SINGLETON = new DTLoggerFactory(); + @Override + public String apply(@Nullable Level input) + { + return input == null ? "" : input.toString(); } - return SINGLETON; - } - - private final ConcurrentMap loggerMap; - private final Map patternLevel; + }; - public ImmutableMap getPatternLevels() + private static class DelegatingLoggerRepository implements LoggerRepository { - return ImmutableMap.copyOf(Maps.transformValues(patternLevel, new Function() + private static class DefaultLoggerFactory implements LoggerFactory { + private static class DefaultLogger extends Logger + { + public DefaultLogger(String name) + { + super(name); + } + } + @Override - public String apply(Level input) + public Logger makeNewLoggerInstance(String name) { - return input == null ? "" : input.toString(); + Logger logger = new DefaultLogger(name); + Level level = getLevelFor(name); + if (level != null) { + logger.setLevel(level); + } + return logger; } - })); - } + } - private final Map patterns; - private boolean initialized = false; + private final LoggerFactory loggerFactory = new DefaultLoggerFactory(); + private final LoggerRepository loggerRepository; - private DTLoggerFactory() - { - loggerMap = Maps.newConcurrentMap(); - patternLevel = Maps.newHashMap(); - patterns = Maps.newHashMap(); + private DelegatingLoggerRepository(LoggerRepository loggerRepository) + { + this.loggerRepository = loggerRepository; + } + + @Override + public void addHierarchyEventListener(HierarchyEventListener listener) + { + loggerRepository.addHierarchyEventListener(listener); + } + + @Override + public boolean isDisabled(int level) + { + return loggerRepository.isDisabled(level); + } + + @Override + public void setThreshold(Level level) + { + loggerRepository.setThreshold(level); + } + + @Override + public void setThreshold(String val) + { + loggerRepository.setThreshold(val); + } + + @Override + public void emitNoAppenderWarning(Category cat) + { + loggerRepository.emitNoAppenderWarning(cat); + } + + @Override + public Level getThreshold() + { + return loggerRepository.getThreshold(); + } + + @Override + public Logger getLogger(String name) + { + return loggerRepository.getLogger(name, loggerFactory); + } + + @Override + public Logger getLogger(String name, LoggerFactory factory) + { + return loggerRepository.getLogger(name, factory); + } + + @Override + public Logger getRootLogger() + { + return loggerRepository.getRootLogger(); + } + + @Override + public Logger exists(String name) + { + return loggerRepository.exists(name); + } + + @Override + public void shutdown() + { + loggerRepository.shutdown(); + } + + @Override + public Enumeration getCurrentLoggers() + { + return loggerRepository.getCurrentLoggers(); + } + + @Override + public Enumeration getCurrentCategories() + { + return loggerRepository.getCurrentCategories(); + } + + @Override + public void fireAddAppenderEvent(Category logger, Appender appender) + { + loggerRepository.fireAddAppenderEvent(logger, appender); + } + + @Override + public void resetConfiguration() + { + loggerRepository.resetConfiguration(); + } } - public synchronized void initialize() + static { + logger.debug("initializing LoggerUtil"); + LogManager.setRepositorySelector(new DefaultRepositorySelector(new DelegatingLoggerRepository(LogManager.getLoggerRepository())), null); + } + + private static synchronized Level getLevelFor(String name) { - if (!initialized) { - LOG.debug("initializing DT Logger Factory"); - new RepositorySelectorImpl().initialize(); - String loggersLevel = System.getProperty(DT_LOGGERS_LEVEL); - if (!Strings.isNullOrEmpty(loggersLevel)) { - Map targetChanges = Maps.newHashMap(); - String[] targets = loggersLevel.split(","); - for (String target : targets) { - String[] parts = target.split(":"); - targetChanges.put(parts[0], parts[1]); - } - changeLoggersLevel(targetChanges); + if (patternLevel.isEmpty()) { + return null; + } + String longestPatternKey = null; + for (String patternKey : patternLevel.keySet()) { + Pattern pattern = patterns.get(patternKey); + if (pattern.matcher(name).matches() && (longestPatternKey == null || longestPatternKey.length() < patternKey.length())) { + longestPatternKey = patternKey; } - initialized = true; - } else { - LOG.warn("DT Logger Factory already initialized."); } + if (longestPatternKey != null) { + return patternLevel.get(longestPatternKey); + } + return null; } - public synchronized void changeLoggersLevel(@Nonnull Map targetChanges) + public static ImmutableMap getPatternLevels() { - /*remove existing patterns which are subsets of new patterns. for eg. if x.y.z.* will be removed if - there is x.y.* in the target changes. - */ + return ImmutableMap.copyOf(Maps.transformValues(patternLevel, levelToString)); + } + + public static synchronized void changeLoggersLevel(@Nonnull Map targetChanges) + { + /* remove existing patterns which are subsets of new patterns. for eg. if x.y.z.* will be removed if + * there is x.y.* in the target changes. + */ for (Map.Entry changeEntry : targetChanges.entrySet()) { Iterator> patternsIterator = patterns.entrySet().iterator(); while ((patternsIterator.hasNext())) { @@ -146,44 +253,14 @@ public synchronized void changeLoggersLevel(@Nonnull Map targetC Level oldLevel = classLogger.getLevel(); Level newLevel = getLevelFor(classLogger.getName()); if (newLevel != null && (oldLevel == null || !newLevel.equals(oldLevel))) { - LOG.info("changing level of " + classLogger.getName() + " to " + newLevel); + logger.info("changing level of {} to {}", classLogger.getName(), newLevel); classLogger.setLevel(newLevel); } } } } - @Override - public Logger makeNewLoggerInstance(String name) - { - Logger newInstance = new Logger(name); - Level level = getLevelFor(name); - if (level != null) { - newInstance.setLevel(level); - } - loggerMap.put(name, newInstance); - return newInstance; - } - - private synchronized Level getLevelFor(String name) - { - if (patternLevel.isEmpty()) { - return null; - } - String longestPatternKey = null; - for (String partternKey : patternLevel.keySet()) { - Pattern pattern = patterns.get(partternKey); - if (pattern.matcher(name).matches() && (longestPatternKey == null || longestPatternKey.length() < partternKey.length())) { - longestPatternKey = partternKey; - } - } - if (longestPatternKey != null) { - return patternLevel.get(longestPatternKey); - } - return null; - } - - public synchronized ImmutableMap getClassesMatching(@Nonnull String searchKey) + public static synchronized ImmutableMap getClassesMatching(@Nonnull String searchKey) { Pattern searchPattern = Pattern.compile(searchKey); Map matchedClasses = Maps.newHashMap(); @@ -198,55 +275,4 @@ public synchronized ImmutableMap getClassesMatching(@Nonnull Str } return ImmutableMap.copyOf(matchedClasses); } - - private static class RepositorySelectorImpl implements RepositorySelector - { - - private boolean initialized; - private Logger guard; - private Hierarchy hierarchy; - - private RepositorySelectorImpl() - { - initialized = false; - } - - private void initialize() - { - if (!initialized) { - LOG.debug("initializing logger repository selector impl"); - guard = LogManager.getRootLogger(); - LogManager.setRepositorySelector(this, guard); - hierarchy = new LoggerRepositoryImpl(guard); - initialized = true; - } - } - - @Override - public LoggerRepository getLoggerRepository() - { - return hierarchy; - } - } - - private static class LoggerRepositoryImpl extends Hierarchy - { - /** - * Create a new logger hierarchy. - * - * @param root The root of the new hierarchy. - */ - private LoggerRepositoryImpl(Logger root) - { - super(root); - } - - @Override - public Logger getLogger(String name) - { - return super.getLogger(name, DTLoggerFactory.getInstance()); - } - } - - private static final Logger LOG = LogManager.getLogger(DTLoggerFactory.class); } diff --git a/engine/src/test/java/com/datatorrent/stram/util/LoggerUtilTest.java b/engine/src/test/java/com/datatorrent/stram/util/LoggerUtilTest.java index 5ec5af8f17..2ad3f4a281 100644 --- a/engine/src/test/java/com/datatorrent/stram/util/LoggerUtilTest.java +++ b/engine/src/test/java/com/datatorrent/stram/util/LoggerUtilTest.java @@ -16,86 +16,153 @@ * specific language governing permissions and limitations * under the License. */ -package org.apache.log4j; +package com.datatorrent.stram.util; -import java.lang.reflect.Field; import java.util.Map; -import org.junit.Assert; import org.junit.BeforeClass; +import org.junit.FixMethodOrder; import org.junit.Test; +import org.junit.runners.MethodSorters; import org.slf4j.LoggerFactory; +import org.apache.log4j.Category; +import org.apache.log4j.Level; +import org.apache.log4j.LogManager; + import com.google.common.collect.Maps; -import com.datatorrent.stram.StreamingAppMaster; -import com.datatorrent.stram.api.StramEvent; -import com.datatorrent.stram.client.DTConfiguration; -import com.datatorrent.stram.engine.StreamingContainer; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertSame; +import static org.junit.Assert.assertTrue; -public class DTLoggerFactoryTest +@FixMethodOrder(MethodSorters.NAME_ASCENDING) +public class LoggerUtilTest { + private static final org.slf4j.Logger logger = LoggerFactory.getLogger(LoggerUtilTest.class); @BeforeClass public static void setup() throws Exception { - System.setProperty(DTLoggerFactory.DT_LOGGERS_LEVEL, "com.datatorrent.stram.client.*:INFO,com.datatorrent.stram.api.*:DEBUG"); - Field f = DTLoggerFactory.class.getDeclaredField("initialized"); - f.setAccessible(true); - f.set(DTLoggerFactory.getInstance(), false); - DTLoggerFactory.getInstance().initialize(); + logger.debug("Logger repository before LoggerUtil.changeLoggersLevel() {}", LogManager.getLoggerRepository()); + LoggerUtil.changeLoggersLevel(Maps.newHashMap()); + logger.debug("Logger repository after LoggerUtil.changeLoggersLevel() {}", LogManager.getLoggerRepository()); } @Test - public void test() + public void testGetPatternLevels() { - LoggerFactory.getLogger(DTConfiguration.class); - LoggerFactory.getLogger(StramEvent.class); - LoggerFactory.getLogger(StreamingAppMaster.class); - - org.apache.log4j.Logger dtConfigLogger = LogManager.getLogger(DTConfiguration.class); - Assert.assertEquals(dtConfigLogger.getLevel(), Level.INFO); - - org.apache.log4j.Logger stramEventLogger = LogManager.getLogger(StramEvent.class); - Assert.assertEquals(stramEventLogger.getLevel(), Level.DEBUG); - - org.apache.log4j.Logger streamingAppMasterLogger = LogManager.getLogger(StreamingAppMaster.class); - Assert.assertNull(streamingAppMasterLogger.getLevel()); + Map changes = Maps.newHashMap(); + changes.put("_.org.apache.*", "WARN"); + changes.put("_.com.datatorrent.io.fs.*", "DEBUG"); + changes.put("_.com.datatorrent.io.*", "ERROR"); + LoggerUtil.changeLoggersLevel(changes); + + Map levels = LoggerUtil.getPatternLevels(); + + assertEquals(3, levels.size()); + assertEquals(levels.get("_.org.apache.*"), "WARN"); + assertEquals(levels.get("_.com.datatorrent.io.fs.*"), "DEBUG"); + assertEquals(levels.get("_.com.datatorrent.io.*"), "ERROR"); + + changes.clear(); + changes.put("_.com.datatorrent.*", "WARN"); + LoggerUtil.changeLoggersLevel(changes); + + levels = LoggerUtil.getPatternLevels(); + assertEquals(2, levels.size()); + assertEquals(levels.get("_.org.apache.*"), "WARN"); + assertNull(levels.get("_.com.datatorrent.io.fs.*")); + assertNull(levels.get("_.com.datatorrent.io.*")); + assertEquals(levels.get("_.com.datatorrent.*"), "WARN"); } @Test - public void test1() + public void testLoggerLevels() { - Map changes = Maps.newHashMap(); - changes.put("com.datatorrent.*", "DEBUG"); - changes.put("com.datatorrent.stram.engine.*", "ERROR"); - DTLoggerFactory.getInstance().changeLoggersLevel(changes); - - LoggerFactory.getLogger(DTConfiguration.class); - LoggerFactory.getLogger(StramEvent.class); + org.slf4j.Logger sl4jLogger; + org.apache.log4j.Logger log4jLogger; - org.apache.log4j.Logger dtConfigLogger = LogManager.getLogger(DTConfiguration.class); - Assert.assertEquals(dtConfigLogger.getLevel(), Level.DEBUG); - - org.apache.log4j.Logger stramEventLogger = LogManager.getLogger(StramEvent.class); - Assert.assertEquals(stramEventLogger.getLevel(), Level.DEBUG); - - LoggerFactory.getLogger(StreamingContainer.class); - org.apache.log4j.Logger stramChildLogger = LogManager.getLogger(StreamingContainer.class); - Assert.assertEquals(stramChildLogger.getLevel(), Level.ERROR); + Map changes = Maps.newHashMap(); + changes.put("_.org.apache.*", "WARN"); + changes.put("_.com.datatorrent.*", "WARN"); + changes.put("_.com.datatorrent.stram.client.*", "INFO"); + changes.put("_.com.datatorrent.stram.api.*", "DEBUG"); + LoggerUtil.changeLoggersLevel(changes); + + sl4jLogger = LoggerFactory.getLogger("_.com.datatorrent.stram.client.DTConfiguration"); + assertTrue(sl4jLogger.isInfoEnabled()); + assertFalse(sl4jLogger.isDebugEnabled()); + + sl4jLogger = LoggerFactory.getLogger("_.com.datatorrent.stram.api.StramEvent"); + assertTrue(sl4jLogger.isInfoEnabled()); + assertTrue(sl4jLogger.isDebugEnabled()); + + sl4jLogger = LoggerFactory.getLogger("_.com.datatorrent.stram.StreamingAppMaster"); + assertFalse(sl4jLogger.isInfoEnabled()); + assertFalse(sl4jLogger.isDebugEnabled()); + + log4jLogger = LogManager.getLogger("_.com.datatorrent.stram.client.DTConfiguration"); + assertSame(log4jLogger.getLevel(), Level.INFO); + assertSame(log4jLogger.getEffectiveLevel(), Level.INFO); + + org.apache.log4j.Logger stramEventLogger = LogManager.getLogger("_.com.datatorrent.stram.api.StramEvent"); + assertSame(stramEventLogger.getLevel(), Level.DEBUG); + assertSame(stramEventLogger.getEffectiveLevel(), Level.DEBUG); + + org.apache.log4j.Logger streamingAppMasterLogger = LogManager.getLogger("_.com.datatorrent.stram.StreamingAppMaster"); + assertSame(streamingAppMasterLogger.getLevel(), Level.WARN); + assertSame(streamingAppMasterLogger.getEffectiveLevel(), Level.WARN); + + changes.clear(); + changes.put("_.com.datatorrent.*", "DEBUG"); + changes.put("_.com.datatorrent.stram.engine.*", "ERROR"); + LoggerUtil.changeLoggersLevel(changes); + + sl4jLogger = LoggerFactory.getLogger("_.com.datatorrent.stram.client.DTConfiguration"); + assertTrue(sl4jLogger.isInfoEnabled()); + assertTrue(sl4jLogger.isDebugEnabled()); + + sl4jLogger = LoggerFactory.getLogger("_.com.datatorrent.stram.api.StramEvent"); + assertTrue(sl4jLogger.isInfoEnabled()); + assertTrue(sl4jLogger.isDebugEnabled()); + + sl4jLogger = LoggerFactory.getLogger("_.com.datatorrent.stram.StreamingAppMaster"); + assertTrue(sl4jLogger.isInfoEnabled()); + assertTrue(sl4jLogger.isDebugEnabled()); + + sl4jLogger = LoggerFactory.getLogger("_.com.datatorrent.stram.engine.StreamingContainer"); + assertFalse(sl4jLogger.isInfoEnabled()); + assertFalse(sl4jLogger.isDebugEnabled()); + + log4jLogger = LogManager.getLogger("_.com.datatorrent.stram.client.DTConfiguration"); + assertSame(log4jLogger.getLevel(), Level.DEBUG); + assertSame(log4jLogger.getEffectiveLevel(), Level.DEBUG); + + log4jLogger = LogManager.getLogger("_.com.datatorrent.stram.api.StramEvent"); + assertSame(log4jLogger.getLevel(), Level.DEBUG); + assertSame(log4jLogger.getEffectiveLevel(), Level.DEBUG); + + log4jLogger = LogManager.getLogger("_.com.datatorrent.stram.StreamingAppMaster"); + assertSame(log4jLogger.getLevel(), Level.DEBUG); + assertSame(log4jLogger.getEffectiveLevel(), Level.DEBUG); + + log4jLogger = LogManager.getLogger("_.com.datatorrent.stram.engine.StreamingContainer"); + assertSame(log4jLogger.getLevel(), Level.ERROR); + assertSame(log4jLogger.getEffectiveLevel(), Level.ERROR); } @Test - public void testGetPatternLevels() + public void testParentLevel() { - Map changes = Maps.newHashMap(); - changes.put("com.datatorrent.io.fs.*", "DEBUG"); - changes.put("com.datatorrent.io.*", "ERROR"); - DTLoggerFactory.getInstance().changeLoggersLevel(changes); - - Map levels = DTLoggerFactory.getInstance().getPatternLevels(); - - Assert.assertEquals(levels.get("com.datatorrent.io.fs.*"), "DEBUG"); - Assert.assertEquals(levels.get("com.datatorrent.io.*"), "ERROR"); + org.apache.log4j.Logger log4jLogger = LogManager.getLogger("com.datatorrent.stram.util.Unknown"); + assertNull(log4jLogger.getLevel()); + Category parent = log4jLogger.getParent(); + while (parent.getLevel() == null) { + parent = parent.getParent(); + } + assertSame(log4jLogger.getEffectiveLevel(), parent.getLevel()); } }