| /* |
| * Copyright 2010 Google Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| * use this file except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| * License for the specific language governing permissions and limitations under |
| * the License. |
| */ |
| |
| package com.google.gwt.logging.client; |
| |
| import com.google.gwt.core.client.EntryPoint; |
| import com.google.gwt.core.client.GWT; |
| import com.google.gwt.core.client.GWT.UncaughtExceptionHandler; |
| import com.google.gwt.user.client.Window.Location; |
| |
| import java.util.logging.Handler; |
| import java.util.logging.Level; |
| import java.util.logging.Logger; |
| |
| /** |
| * Configures client-side logging using the query params and gwt.xml settings. |
| */ |
| public class LogConfiguration implements EntryPoint { |
| |
| private interface LogConfigurationImpl { |
| void configureClientSideLogging(); |
| boolean loggingIsEnabled(); |
| boolean loggingIsEnabled(Level level); |
| } |
| |
| /** |
| * Implementation which does nothing and compiles out if logging is disabled. |
| */ |
| private static class LogConfigurationImplNull implements LogConfigurationImpl { |
| public void configureClientSideLogging() { } |
| |
| public boolean loggingIsEnabled() { |
| return false; |
| } |
| |
| public boolean loggingIsEnabled(Level level) { |
| return false; |
| } |
| } |
| |
| /** |
| * Implementation which is used when logging is enabled. |
| */ |
| private static class LogConfigurationImplRegular implements LogConfigurationImpl { |
| // Keep a reference to the root logger after we configure it because |
| // if we don't, the JRE implementation of LogManager (which is used in |
| // Dev Mode) will sometimes garbage collect it, since they only keep |
| // weak references to the loggers that are created. |
| private Logger root; |
| |
| public void configureClientSideLogging() { |
| assert GWT.isClient(); |
| |
| root = Logger.getLogger(""); |
| // In DevMode, this root logger will have a parent and we do not want this |
| // root logger to pass messages to it's parent, so we set |
| // useParentHandlers to false here. |
| root.setUseParentHandlers(false); |
| setLevels(root); |
| setDefaultHandlers(root); |
| } |
| |
| public boolean loggingIsEnabled() { |
| return true; |
| } |
| |
| /** |
| * Returns whether logging enabled for the passed in level. |
| */ |
| public boolean loggingIsEnabled(Level level) { |
| return true; |
| } |
| |
| private void addHandlerIfNotNull(Logger l, Handler h) { |
| if (!(h instanceof NullLogHandler)) { |
| l.addHandler(h); |
| } |
| } |
| |
| private void setDefaultHandlers(Logger l) { |
| // Add the default handlers. If users want some of these disabled, they |
| // will specify that in the gwt.xml file, which will replace the handler |
| // with an instance of NullLogHandler, effectively disabling it. |
| Handler console = GWT.create(ConsoleLogHandler.class); |
| addHandlerIfNotNull(l, console); |
| Handler dev = GWT.create(DevelopmentModeLogHandler.class); |
| addHandlerIfNotNull(l, dev); |
| Handler system = GWT.create(SystemLogHandler.class); |
| addHandlerIfNotNull(l, system); |
| Handler remote = GWT.create(SimpleRemoteLogHandler.class); |
| addHandlerIfNotNull(l, remote); |
| Handler loggingWidget = GWT.create(HasWidgetsLogHandler.class); |
| addHandlerIfNotNull(l, loggingWidget); |
| } |
| |
| private void setLevels(Logger l) { |
| // try to pull the log level from the query param |
| String levelParam = Location.getParameter("logLevel"); |
| Level level = levelParam == null ? null : Level.parse(levelParam); |
| if (level != null) { |
| l.setLevel(level); |
| } else { |
| // if it isn't there, then pull it from the gwt.xml file |
| DefaultLevel defaultLevel = GWT.create(DefaultLevel.class); |
| l.setLevel(defaultLevel.getLevel()); |
| } |
| } |
| } |
| |
| /** |
| * Implementation which is used when logging.enabled is set to SEVERE. |
| */ |
| private static class LogConfigurationImplSevere extends LogConfigurationImplRegular { |
| @Override |
| public boolean loggingIsEnabled(Level level) { |
| return level.intValue() >= 1000; |
| } |
| } |
| |
| /** |
| * Implementation which is used when logging.enabled is set to WARNING. |
| */ |
| private static class LogConfigurationImplWarning extends LogConfigurationImplRegular { |
| @Override |
| public boolean loggingIsEnabled(Level level) { |
| return level.intValue() >= 900; |
| } |
| } |
| |
| private static LogConfigurationImpl impl = GWT.create(LogConfigurationImplNull.class); |
| |
| public static boolean loggingIsEnabled() { |
| if (impl == null) { |
| // case when GWTMockUtilities.disarm(); should be optimized out when compiled to JS |
| return true; |
| } |
| return impl.loggingIsEnabled(); |
| } |
| |
| public static boolean loggingIsEnabled(Level level) { |
| if (impl == null) { |
| // case when GWTMockUtilities.disarm(); should be optimized out when compiled to JS |
| return true; |
| } |
| return impl.loggingIsEnabled(level); |
| } |
| |
| public void onModuleLoad() { |
| impl.configureClientSideLogging(); |
| |
| if (impl.loggingIsEnabled()) { |
| if (GWT.getUncaughtExceptionHandler() == null) { |
| final Logger log = Logger.getLogger(LogConfiguration.class.getName()); |
| GWT.setUncaughtExceptionHandler(new UncaughtExceptionHandler() { |
| public void onUncaughtException(Throwable e) { |
| log.log(Level.SEVERE, e.getMessage(), e); |
| } |
| }); |
| } |
| } |
| } |
| } |