Add the option to use JSON rather than GWT RPC in remote logging
Review at http://gwt-code-reviews.appspot.com/830802
Review by: fredsa@google.com
git-svn-id: https://google-web-toolkit.googlecode.com/svn/trunk@8778 8db76d5a-ed1c-0410-87a9-c151d255dfc7
diff --git a/user/src/com/google/gwt/logging/Logging.gwt.xml b/user/src/com/google/gwt/logging/Logging.gwt.xml
index a3cc387..4646c37 100644
--- a/user/src/com/google/gwt/logging/Logging.gwt.xml
+++ b/user/src/com/google/gwt/logging/Logging.gwt.xml
@@ -13,6 +13,7 @@
<!-- limitations under the License. -->
<module>
+ <inherits name='com.google.gwt.json.JSON'/>
<inherits name="com.google.gwt.logging.LogImpl"/>
<source path="client" />
<source path="shared" />
diff --git a/user/src/com/google/gwt/logging/client/JsonLogRecordClientUtil.java b/user/src/com/google/gwt/logging/client/JsonLogRecordClientUtil.java
new file mode 100644
index 0000000..b210533
--- /dev/null
+++ b/user/src/com/google/gwt/logging/client/JsonLogRecordClientUtil.java
@@ -0,0 +1,88 @@
+/*
+ * 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.json.client.JSONArray;
+import com.google.gwt.json.client.JSONObject;
+import com.google.gwt.json.client.JSONString;
+import com.google.gwt.logging.shared.SerializableLogRecord;
+import com.google.gwt.logging.shared.SerializableThrowable;
+
+/**
+ * A set of functions to convert SerializableLogRecords into JSON strings.
+ * The corresponding functions to convert them back are in
+ * JsonLogRecordServerUtil.java. This class should only be used in client
+ * side code since it imports com.google.gwt.json.client classes.
+ * TODO(unnurg) once there is a unified JSON GWT library, combine this with
+ * JsonLogRecordServerUtil.
+ */
+public class JsonLogRecordClientUtil {
+
+ public static String serializableLogRecordAsJson(SerializableLogRecord slr) {
+ return serializableLogRecordAsJsonObject(slr).toString();
+ }
+
+ private static JSONString getJsonString(String s) {
+ if (s == null) {
+ return new JSONString("");
+ }
+ return new JSONString(s);
+ }
+
+ private static JSONObject serializableLogRecordAsJsonObject(
+ SerializableLogRecord slr) {
+ JSONObject obj = new JSONObject();
+ obj.put("level", getJsonString(slr.getLevel()));
+ obj.put("loggerName", getJsonString(slr.getLoggerName()));
+ obj.put("msg", getJsonString(slr.getMsg()));
+ if (slr.getTimestamp() != null) {
+ obj.put("timestamp", new JSONString(slr.getTimestamp().toString()));
+ }
+ obj.put("thrown", serializableThrowableAsJsonObject(slr.getThrown()));
+ return obj;
+ }
+
+ private static JSONObject serializableStackTraceElementAsJsonObject(
+ StackTraceElement e) {
+ JSONObject obj = new JSONObject();
+ if (e != null) {
+ obj.put("className", getJsonString(e.getClassName()));
+ obj.put("fileName", getJsonString(e.getFileName()));
+ obj.put("methodName", getJsonString(e.getMethodName()));
+ obj.put("lineNumber", getJsonString("" + e.getLineNumber()));
+ }
+ return obj;
+ }
+
+ private static JSONObject serializableThrowableAsJsonObject(
+ SerializableThrowable t) {
+ JSONObject obj = new JSONObject();
+ if (t != null) {
+ obj.put("message", getJsonString(t.getMessage()));
+ obj.put("cause", serializableThrowableAsJsonObject(t.getCause()));
+ StackTraceElement[] stackTrace = t.getStackTrace();
+ if (stackTrace != null && stackTrace.length > 0) {
+ JSONArray arr = new JSONArray();
+ for (int i = 0; i < stackTrace.length; i++) {
+ arr.set(i, serializableStackTraceElementAsJsonObject(stackTrace[i]));
+ }
+ obj.put("stackTrace", arr);
+ }
+ }
+ return obj;
+ }
+}
diff --git a/user/src/com/google/gwt/logging/server/JsonLogRecordServerUtil.java b/user/src/com/google/gwt/logging/server/JsonLogRecordServerUtil.java
new file mode 100644
index 0000000..2173ddf
--- /dev/null
+++ b/user/src/com/google/gwt/logging/server/JsonLogRecordServerUtil.java
@@ -0,0 +1,87 @@
+/*
+ * 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.server;
+
+import com.google.gwt.logging.shared.SerializableLogRecord;
+import com.google.gwt.logging.shared.SerializableThrowable;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+
+/**
+ * A set of functions to convert standard JSON strings into
+ * SerializableLogRecords. The corresponding functions to create the JSON
+ * strings are in JsonLogRecordClientUtil.java. This class should only be used
+ * in server side code since it imports org.json classes.
+ * TODO(unnurg) once there is a unified JSON GWT library, combine this with
+ * JsonLogRecordClientUtil.
+ */
+public class JsonLogRecordServerUtil {
+ public static SerializableLogRecord serializableLogRecordFromJson(
+ String jsonString) {
+ try {
+ JSONObject slr = new JSONObject(jsonString);
+ String level = slr.getString("level");
+ String loggerName = slr.getString("loggerName");
+ String msg = slr.getString("msg");
+ long timestamp = Long.parseLong(slr.getString("timestamp"));
+ SerializableThrowable thrown =
+ serializableThrowableFromJson(slr.getString("thrown"));
+ return new SerializableLogRecord(level, loggerName, msg, thrown, timestamp);
+ } catch (JSONException e) {
+ }
+ return null;
+ }
+
+ private static StackTraceElement serializableStackTraceElementFromJson(
+ String jsonString) {
+ try {
+ JSONObject ste = new JSONObject(jsonString);
+ String className = ste.getString("className");
+ String fileName = ste.getString("fileName");
+ String methodName = ste.getString("methodName");
+ int lineNumber = Integer.parseInt(ste.getString("lineNumber"));
+ return new StackTraceElement(className, methodName, fileName,
+ lineNumber);
+ } catch (JSONException e) {
+ }
+ return null;
+ }
+
+ private static SerializableThrowable serializableThrowableFromJson(
+ String jsonString) {
+ try {
+ JSONObject t = new JSONObject(jsonString);
+ String message = t.getString("message");
+ SerializableThrowable cause =
+ serializableThrowableFromJson(t.getString("cause"));
+ StackTraceElement[] stackTrace = null;
+ JSONArray st = t.getJSONArray("stackTrace");
+ if (st.length() > 0) {
+ stackTrace = new StackTraceElement[st.length()];
+ for (int i = 0; i < st.length(); i++) {
+ stackTrace[i] = serializableStackTraceElementFromJson(st.getString(i));
+ }
+ }
+ return new SerializableThrowable(message, cause, stackTrace);
+ } catch (JSONException e) {
+ }
+ return null;
+ }
+}
diff --git a/user/src/com/google/gwt/logging/shared/SerializableLogRecord.java b/user/src/com/google/gwt/logging/shared/SerializableLogRecord.java
index 28b5c65..92816f0 100644
--- a/user/src/com/google/gwt/logging/shared/SerializableLogRecord.java
+++ b/user/src/com/google/gwt/logging/shared/SerializableLogRecord.java
@@ -31,13 +31,9 @@
private String level;
private String loggerName = "";
private String msg;
- private long timestamp;
private SerializableThrowable thrown = null;
+ private long timestamp;
- protected SerializableLogRecord() {
- // for serialization
- }
-
/**
* Create a new SerializableLogRecord from a LogRecord.
*/
@@ -50,7 +46,28 @@
thrown = new SerializableThrowable(lr.getThrown());
}
}
-
+
+ public SerializableLogRecord(String level, String loggerName, String msg,
+ SerializableThrowable thrown, long timestamp) {
+ this.level = level;
+ this.loggerName = loggerName;
+ this.msg = msg;
+ this.timestamp = timestamp;
+ this.thrown = thrown;
+ }
+
+ protected SerializableLogRecord() {
+ // for serialization
+ }
+
+ public String getLevel() {
+ return level;
+ }
+
+ public String getLoggerName() {
+ return loggerName;
+ }
+
/**
* Create a new LogRecord from this SerializableLogRecord.
*/
@@ -63,4 +80,16 @@
}
return lr;
}
+
+ public String getMsg() {
+ return msg;
+ }
+
+ public SerializableThrowable getThrown() {
+ return thrown;
+ }
+
+ public Long getTimestamp() {
+ return timestamp;
+ }
}
diff --git a/user/src/com/google/gwt/logging/shared/SerializableThrowable.java b/user/src/com/google/gwt/logging/shared/SerializableThrowable.java
index 5a90871..ebbe381 100644
--- a/user/src/com/google/gwt/logging/shared/SerializableThrowable.java
+++ b/user/src/com/google/gwt/logging/shared/SerializableThrowable.java
@@ -25,25 +25,44 @@
* subclasses will cause the client side JS to be very big.
*/
public class SerializableThrowable implements IsSerializable {
- private String message;
private SerializableThrowable cause = null;
+ private String message;
private StackTraceElement[] stackTrace;
-
- protected SerializableThrowable() {
- // for serialization
- }
/**
* Create a new SerializableThrowable from a Throwable.
*/
public SerializableThrowable(Throwable t) {
message = t.getMessage();
- stackTrace = t.getStackTrace();
if (t.getCause() != null) {
cause = new SerializableThrowable(t.getCause());
}
+ stackTrace = t.getStackTrace();
+ }
+
+ public SerializableThrowable(String message, SerializableThrowable cause,
+ StackTraceElement[] stackTrace) {
+ this.message = message;
+ this.cause = cause;
+ this.stackTrace = stackTrace;
+ }
+
+ protected SerializableThrowable() {
+ // for serialization
+ }
+
+ public SerializableThrowable getCause() {
+ return cause;
}
+ public String getMessage() {
+ return message;
+ }
+
+ public StackTraceElement[] getStackTrace() {
+ return stackTrace;
+ }
+
/**
* Create a new Throwable from this SerializableThrowable.
*/
diff --git a/user/src/com/google/gwt/requestfactory/client/RequestFactoryLogHandler.java b/user/src/com/google/gwt/requestfactory/client/RequestFactoryLogHandler.java
index 21a7252..7ae3819 100644
--- a/user/src/com/google/gwt/requestfactory/client/RequestFactoryLogHandler.java
+++ b/user/src/com/google/gwt/requestfactory/client/RequestFactoryLogHandler.java
@@ -16,6 +16,8 @@
package com.google.gwt.requestfactory.client;
+import com.google.gwt.logging.client.JsonLogRecordClientUtil;
+import com.google.gwt.logging.shared.SerializableLogRecord;
import com.google.gwt.requestfactory.shared.LoggingRequest;
import com.google.gwt.requestfactory.shared.Receiver;
import com.google.gwt.requestfactory.shared.SyncResult;
@@ -87,16 +89,22 @@
if (closed || !isLoggable(record)) {
return;
}
-
if (record.getLoggerName().contains(ignoredLoggerSubstring)) {
return;
}
-
- Receiver<Long> loggingReceiver = new LoggingReceiver();
- requestProvider.getLoggingRequest().logMessage(
- record.getLevel().toString(),
- record.getLoggerName(),
- record.getMessage()).fire(loggingReceiver);
+ SerializableLogRecord slr = new SerializableLogRecord(record);
+ String json = JsonLogRecordClientUtil.serializableLogRecordAsJson(slr);
+ requestProvider.getLoggingRequest().logMessage(json).fire(
+ new Receiver<Boolean>() {
+ @Override
+ public void onSuccess(Boolean response, Set<SyncResult> syncResults) {
+ if (!response) {
+ // A separate logger for wire activity, which does not get logged
+ // by the remote log handler, so we avoid infinite loops.
+ Logger wireLogger = Logger.getLogger("WireActivityLogger");
+ wireLogger.severe("Remote Logging failed to parse JSON");
+ }
+ }
+ });
}
-
}
diff --git a/user/src/com/google/gwt/requestfactory/server/Logging.java b/user/src/com/google/gwt/requestfactory/server/Logging.java
index 86f490c..fff5ebd 100644
--- a/user/src/com/google/gwt/requestfactory/server/Logging.java
+++ b/user/src/com/google/gwt/requestfactory/server/Logging.java
@@ -16,7 +16,10 @@
package com.google.gwt.requestfactory.server;
-import java.util.logging.Level;
+import com.google.gwt.logging.server.JsonLogRecordServerUtil;
+import com.google.gwt.logging.shared.SerializableLogRecord;
+
+import java.util.logging.LogRecord;
import java.util.logging.Logger;
/**
@@ -25,20 +28,17 @@
*/
public class Logging {
private static Logger logger = Logger.getLogger(Logging.class.getName());
-
- public static Long logMessage(
- String levelString, String loggerName, String originalMessage) {
- Level level = Level.SEVERE;
- try {
- level = Level.parse(levelString);
- } catch (IllegalArgumentException e) {
- return 0L;
+
+ public static Boolean logMessage(String serializedLogRecordString) {
+ SerializableLogRecord slr =
+ JsonLogRecordServerUtil.serializableLogRecordFromJson(
+ serializedLogRecordString);
+ LogRecord lr = slr.getLogRecord();
+ if (lr == null) {
+ return false;
}
- String message = String.format("Client Side Logger: %s Message: %s",
- loggerName, originalMessage);
-
- logger.log(level, message);
- return 1L;
+ logger.log(lr);
+ return true;
}
private Long id = 0L;
diff --git a/user/src/com/google/gwt/requestfactory/shared/LoggingRequest.java b/user/src/com/google/gwt/requestfactory/shared/LoggingRequest.java
index 6455c1b..cf07757 100644
--- a/user/src/com/google/gwt/requestfactory/shared/LoggingRequest.java
+++ b/user/src/com/google/gwt/requestfactory/shared/LoggingRequest.java
@@ -25,11 +25,8 @@
@Service(Logging.class)
public interface LoggingRequest {
- // Should be returning something better than a Long, but that's all that is
- // supported for now, so using it as a boolean.
- // Should also be passing something better than a series of strings, but
- // that's the only possibility for now.
- RequestObject<Long> logMessage(
- String level, String loggerName, String message);
+ // TODO(unnurg): Pass a SerializableLogRecord here rather than it's
+ // serialized string.
+ RequestObject<Boolean> logMessage(String serializedLogRecordString);
}
