gzipResponse is true, the response content will
* be gzipped prior to being written into the response.
*
- * @param servletContext servlet context for this response
* @param response response instance
* @param responseContent a string containing the response content
* @param gzipResponse if true the response content will be gzip
@@ -332,9 +347,8 @@ public static boolean shouldGzipResponseContent(HttpServletRequest request,
* @throws IOException if reading, writing, or closing the response's output
* stream fails
*/
- public static void writeResponse(ServletContext servletContext,
- HttpServletResponse response, String responseContent, boolean gzipResponse)
- throws IOException {
+ public static void writeResponse(HttpServletResponse response, String responseContent,
+ boolean gzipResponse) throws IOException {
byte[] responseBytes = responseContent.getBytes(StandardCharsets.UTF_8);
if (gzipResponse) {
@@ -363,7 +377,7 @@ public static void writeResponse(ServletContext servletContext,
}
if (caught != null) {
- servletContext.log("Unable to compress response", caught);
+ logger.error("Unable to compress response", caught);
response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
return;
}
@@ -378,18 +392,26 @@ public static void writeResponse(ServletContext servletContext,
response.getOutputStream().write(responseBytes);
}
+ /**
+ * @deprecated Use {@link #writeResponseForUnexpectedFailure(HttpServletResponse, Throwable)}
+ * instead; the servlet context is no longer needed.
+ */
+ @Deprecated
+ public static void writeResponseForUnexpectedFailure(ServletContext ignored,
+ HttpServletResponse response, Throwable failure) {
+ writeResponseForUnexpectedFailure(response, failure);
+ }
+
/**
* Called when the servlet itself has a problem, rather than the invoked
* third-party method. It writes a simple 500 message back to the client.
*
- * @param servletContext
* @param response
* @param failure
*/
- public static void writeResponseForUnexpectedFailure(
- ServletContext servletContext, HttpServletResponse response,
+ public static void writeResponseForUnexpectedFailure(HttpServletResponse response,
Throwable failure) {
- servletContext.log("Exception while dispatching incoming RPC call", failure);
+ logger.error("Exception while dispatching incoming RPC call", failure);
// Send GENERIC_FAILURE_MSG with 500 status.
//
@@ -403,7 +425,7 @@ public static void writeResponseForUnexpectedFailure(
response.getWriter().write(GENERIC_FAILURE_MSG);
}
} catch (IOException ex) {
- servletContext.log(
+ logger.error(
"respondWithUnexpectedFailure failed while sending the previous failure to the client",
ex);
}
@@ -431,7 +453,8 @@ private static void checkCharacterEncodingIgnoreCase(
* properly parsed character encoding string if we decide to make this
* change.
*/
- if (characterEncoding.toLowerCase(Locale.ROOT).contains(expectedCharSet.toLowerCase(Locale.ROOT))) {
+ if (characterEncoding.toLowerCase(Locale.ROOT)
+ .contains(expectedCharSet.toLowerCase(Locale.ROOT))) {
encodingOkay = true;
}
}
diff --git a/user/src/com/google/gwt/user/server/rpc/RemoteServiceServlet.java b/user/src/com/google/gwt/user/server/rpc/RemoteServiceServlet.java
index 1bd73e142ef..28ff67d5ea1 100644
--- a/user/src/com/google/gwt/user/server/rpc/RemoteServiceServlet.java
+++ b/user/src/com/google/gwt/user/server/rpc/RemoteServiceServlet.java
@@ -22,6 +22,8 @@
import com.google.gwt.user.client.rpc.IncompatibleRemoteServiceException;
import com.google.gwt.user.client.rpc.RpcTokenException;
import com.google.gwt.user.client.rpc.SerializationException;
+import com.google.gwt.user.server.rpc.logging.RpcLogManager;
+import com.google.gwt.user.server.rpc.logging.RpcLogger;
import java.io.IOException;
import java.io.InputStream;
@@ -45,6 +47,8 @@
public class RemoteServiceServlet extends AbstractRemoteServiceServlet
implements SerializationPolicyProvider {
+ private static final RpcLogger logger = RpcLogManager.getLogger(RemoteServiceServlet.class);
+
/**
* Loads a serialization policy stored as a servlet resource in the same
* ServletContext as this servlet. Returns null if not found.
@@ -62,7 +66,7 @@ static SerializationPolicy loadSerializationPolicy(HttpServlet servlet,
modulePath = new URL(moduleBaseURL).getPath();
} catch (MalformedURLException ex) {
// log the information, we will default
- servlet.log("Malformed moduleBaseURL: " + moduleBaseURL, ex);
+ logger.error("Malformed moduleBaseURL: " + moduleBaseURL, ex);
}
}
@@ -74,19 +78,20 @@ static SerializationPolicy loadSerializationPolicy(HttpServlet servlet,
* this method.
*/
if (modulePath == null || !modulePath.startsWith(contextPath)) {
- String message = "ERROR: The module path requested, "
+ String message = "The module path requested, "
+ modulePath
+ ", is not in the same web application as this servlet, "
+ contextPath
- + ". Your module may not be properly configured or your client and server code maybe out of date.";
- servlet.log(message);
+ + ". Your module may not be properly configured " +
+ "or your client and server code maybe out of date.";
+ logger.error(message);
} else {
// Strip off the context path from the module base URL. It should be a
// strict prefix.
String contextRelativePath = modulePath.substring(contextPath.length());
- String serializationPolicyFilePath = SerializationPolicyLoader.getSerializationPolicyFileName(contextRelativePath
- + strongName);
+ String serializationPolicyFilePath = SerializationPolicyLoader.getSerializationPolicyFileName(
+ contextRelativePath + strongName);
// Open the RPC resource file and read its contents.
InputStream is = servlet.getServletContext().getResourceAsStream(
@@ -98,30 +103,30 @@ static SerializationPolicy loadSerializationPolicy(HttpServlet servlet,
null);
if (serializationPolicy.hasClientFields()) {
if (ENABLE_ENHANCED_CLASSES) {
- servlet.log("WARNING: Service deserializes enhanced JPA/JDO classes, which is " +
- "unsafe. See https://github.com/gwtproject/gwt/issues/9709 for more " +
- "detail on the vulnerability that this presents.");
+ logger.warn("Service deserializes enhanced JPA/JDO classes, which is " +
+ "unsafe. See https://github.com/gwtproject/gwt/issues/9709 for more " +
+ "detail on the vulnerability that this presents.");
} else {
- servlet.log("ERROR: Service deserializes enhanced JPA/JDO classes, which is " +
- "unsafe. Review build logs to see which classes are affected, or set " +
- ENABLE_GWT_ENHANCED_CLASSES_PROPERTY + " to true to allow using this " +
- "service. See https://github.com/gwtproject/gwt/issues/9709 for more " +
- "detail.");
+ logger.error("Service deserializes enhanced JPA/JDO classes, which is " +
+ "unsafe. Review build logs to see which classes are affected, or set " +
+ ENABLE_GWT_ENHANCED_CLASSES_PROPERTY + " to true to allow using this " +
+ "service. See https://github.com/gwtproject/gwt/issues/9709 for more " +
+ "detail.");
serializationPolicy = null;
}
}
} catch (ParseException e) {
- servlet.log("ERROR: Failed to parse the policy file '"
+ logger.error("Failed to parse the policy file '"
+ serializationPolicyFilePath + "'", e);
} catch (IOException e) {
- servlet.log("ERROR: Could not read the policy file '"
+ logger.error("Could not read the policy file '"
+ serializationPolicyFilePath + "'", e);
}
} else {
- String message = "ERROR: The serialization policy file '"
+ String message = "The serialization policy file '"
+ serializationPolicyFilePath
+ "' was not found; did you forget to include it in this deployment?";
- servlet.log(message);
+ logger.error(message);
}
} finally {
if (is != null) {
@@ -144,7 +149,8 @@ static SerializationPolicy loadSerializationPolicy(HttpServlet servlet,
* A cache of moduleBaseURL and serialization policy strong name to
* {@link SerializationPolicy}.
*/
- private final Map+ * The provider is chosen in this order: + *
gwt.rpc.logging)truetrue. If none found, returns a
+ * {@link ServletContextLoggerProvider} as a fallback.
+ *
+ * @return a logger provider
+ */
+ private static RpcLoggerProvider loadProvider() {
+ String providerClassName = System.getProperty(PROVIDER_PROPERTY_KEY);
+ ServiceLoader+ * Instances can be obtained from {@link RpcLogManager#getLogger(Class)}. The logging system that + * this delegates to is selected by {@link RpcLogManager} at class-initialization. + * + * @see RpcLogManager + * @see RpcLoggerProvider + */ +public interface RpcLogger { + + void info(String message); + + void warn(String message); + + void error(String message); + + void error(String message, Throwable throwable); + +} diff --git a/user/src/com/google/gwt/user/server/rpc/logging/RpcLoggerProvider.java b/user/src/com/google/gwt/user/server/rpc/logging/RpcLoggerProvider.java new file mode 100644 index 00000000000..51c9de5ac0e --- /dev/null +++ b/user/src/com/google/gwt/user/server/rpc/logging/RpcLoggerProvider.java @@ -0,0 +1,46 @@ +/* + * Copyright 2025 GWT Project Authors + * + * 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.user.server.rpc.logging; + +/** + * Service provider interface for obtaining {@link RpcLogger} instances. + *
+ * This is not intended to be used directly, but through {@link RpcLogManager#getLogger(Class)}, + * which discovers implementations with a service loader + * + * @see RpcLogManager + */ +public interface RpcLoggerProvider { + + /** + * Creates or retrieves a logger with the given name. + * + * @param name the name of the logger to create or retrieve + * @return the created or retrieved logger + */ + RpcLogger createLogger(String name); + + /** + * Indicates whether this provider should be used as the default in the absence of a provider + * explicitly selected with the {@link RpcLogManager#PROVIDER_PROPERTY_KEY} system property. + * + * @return true if this provider should be used when no named provider is found + */ + default boolean isDefault() { + return false; + } + +} diff --git a/user/src/com/google/gwt/user/server/rpc/logging/ServletContextLoggerProvider.java b/user/src/com/google/gwt/user/server/rpc/logging/ServletContextLoggerProvider.java new file mode 100644 index 00000000000..8fee64ddce0 --- /dev/null +++ b/user/src/com/google/gwt/user/server/rpc/logging/ServletContextLoggerProvider.java @@ -0,0 +1,102 @@ +/* + * Copyright 2025 GWT Project Authors + * + * 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.user.server.rpc.logging; + +import javax.servlet.ServletContext; + +/** + * An {@link RpcLoggerProvider} that delegates to the servlet context's logging. Used as the + * fallback if no other logger provider is found. + *
+ * Servlet context logging does not support separate named loggers, so this reuses the same logger + * instance. This reuse allows the servlet context to be easily set after the provider is + * initialized, and normally the provider will be initialized before the servlet context is even + * available. Logs are written to {@link System#out} and {@link System#err} until the servlet + * context is set. + * + * @see RpcLogManager + */ +public class ServletContextLoggerProvider implements RpcLoggerProvider { + + private final ServletContextLogger logger = new ServletContextLogger(); + + /** + * Public for {@link java.util.ServiceLoader}; not intended for direct use outside this package. + */ + public ServletContextLoggerProvider() { + } + + /** + * Sets the {@link ServletContext} to which log messages will be written. + * + * @param servletContext the servlet context to use + */ + void setServletContext(ServletContext servletContext) { + if (servletContext != null) { + logger.servletContext = servletContext; + } + } + + @Override + public RpcLogger createLogger(String ignored) { + return logger; + } + + private static final class ServletContextLogger implements RpcLogger { + + private volatile ServletContext servletContext; + + private ServletContextLogger() { } + + @Override + public void info(String message) { + if (servletContext != null) { + servletContext.log("INFO: " + message); + } else { + System.out.println("INFO: " + message); + } + } + + @Override + public void warn(String message) { + if (servletContext != null) { + servletContext.log("WARNING: " + message); + } else { + System.out.println("WARNING: " + message); + } + } + + @Override + public void error(String message) { + if (servletContext != null) { + servletContext.log("ERROR: " + message); + } else { + System.err.println("ERROR: " + message); + } + } + + @Override + public void error(String message, Throwable throwable) { + if (servletContext != null) { + servletContext.log("ERROR: " + message, throwable); + } else { + System.err.println("ERROR: " + message); + throwable.printStackTrace(); + } + } + } + +}