Add SimpLogging and use o.s.messaging.simp classes

Issue: SPR-17012

Author: rstoyanchev

spring-messaging/src/main/java/org/springframework/messaging/handler/HandlerMethod.java

@@ -50,8 +50,11 @@
  */
 public class HandlerMethod {
 
-	/** Logger that is available to subclasses. */
-	protected final Log logger = LogFactory.getLog(getClass());
+	/** Public for wrapping with fallback logger. */
+	public static final Log defaultLogger = LogFactory.getLog(HandlerMethod.class);
+
+
+	protected Log logger = defaultLogger;
 
 	private final Object bean;
 
@@ -161,6 +164,24 @@ private MethodParameter[] initMethodParameters() {
 		return result;
 	}
 
+
+	/**
+	 * Set an alternative logger to use than the one based on the class name.
+	 * @param logger the logger to use
+	 * @since 5.1
+	 */
+	public void setLogger(Log logger) {
+		this.logger = logger;
+	}
+
+	/**
+	 * Return the currently configured Logger.
+	 * @since 5.1
+	 */
+	public Log getLogger() {
+		return logger;
+	}
+
 	/**
 	 * Return the bean for this handler method.
 	 */

spring-messaging/src/main/java/org/springframework/messaging/handler/invocation/AbstractMethodMessageHandler.java

@@ -85,6 +85,10 @@ public abstract class AbstractMethodMessageHandler<T>
 
 	protected final Log logger = LogFactory.getLog(getClass());
 
+	@Nullable
+	private Log handlerMethodLogger;
+
+
 	private final List<String> destinationPrefixes = new ArrayList<>();
 
 	private final List<HandlerMethodArgumentResolver> customArgumentResolvers = new ArrayList<>(4);
@@ -232,6 +236,12 @@ public void afterPropertiesSet() {
 		if (this.returnValueHandlers.getReturnValueHandlers().isEmpty()) {
 			this.returnValueHandlers.addHandlers(initReturnValueHandlers());
 		}
+		Log returnValueLogger = getReturnValueHandlerLogger();
+		if (returnValueLogger != null) {
+			this.returnValueHandlers.setLogger(returnValueLogger);
+		}
+
+		this.handlerMethodLogger = getHandlerMethodLogger();
 
 		ApplicationContext context = getApplicationContext();
 		if (context == null) {
@@ -367,6 +377,24 @@ protected HandlerMethod createHandlerMethod(Object handler, Method method) {
 	 */
 	protected abstract Set<String> getDirectLookupDestinations(T mapping);
 
+	/**
+	 * Return a logger to set on {@link HandlerMethodReturnValueHandlerComposite}.
+	 * @since 5.1
+	 */
+	@Nullable
+	protected Log getReturnValueHandlerLogger() {
+		return null;
+	}
+
+	/**
+	 * Return a logger to set on {@link InvocableHandlerMethod}.
+	 * @since 5.1
+	 */
+	@Nullable
+	protected Log getHandlerMethodLogger() {
+		return null;
+	}
+
 	/**
 	 * Subclasses can invoke this method to populate the MessagingAdviceBean cache
 	 * (e.g. to support "global" {@code @MessageExceptionHandler}).
@@ -514,6 +542,9 @@ protected void handleMatch(T mapping, HandlerMethod handlerMethod, String lookup
 		}
 		handlerMethod = handlerMethod.createWithResolvedBean();
 		InvocableHandlerMethod invocable = new InvocableHandlerMethod(handlerMethod);
+		if (this.handlerMethodLogger != null) {
+			invocable.setLogger(this.handlerMethodLogger);
+		}
 		invocable.setMessageMethodArgumentResolvers(this.argumentResolvers);
 		try {
 			Object returnValue = invocable.invoke(message);

spring-messaging/src/main/java/org/springframework/messaging/handler/invocation/HandlerMethodReturnValueHandlerComposite.java

@@ -37,11 +37,32 @@
  */
 public class HandlerMethodReturnValueHandlerComposite implements AsyncHandlerMethodReturnValueHandler {
 
-	private static final Log logger = LogFactory.getLog(HandlerMethodReturnValueHandlerComposite.class);
+	/** Public for wrapping with fallback logger. */
+	public static final Log defaultLogger = LogFactory.getLog(HandlerMethodReturnValueHandlerComposite.class);
+
+
+	private Log logger = defaultLogger;
 
 	private final List<HandlerMethodReturnValueHandler> returnValueHandlers = new ArrayList<>();
 
 
+	/**
+	 * Set an alternative logger to use than the one based on the class name.
+	 * @param logger the logger to use
+	 * @since 5.1
+	 */
+	public void setLogger(Log logger) {
+		this.logger = logger;
+	}
+
+	/**
+	 * Return the currently configured Logger.
+	 * @since 5.1
+	 */
+	public Log getLogger() {
+		return logger;
+	}
+
 	/**
 	 * Return a read-only list with the configured handlers.
 	 */

spring-messaging/src/main/java/org/springframework/messaging/simp/SimpAttributes.java

@@ -19,7 +19,6 @@
 import java.util.Map;
 
 import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
 
 import org.springframework.lang.Nullable;
 import org.springframework.messaging.Message;
@@ -46,7 +45,7 @@ public class SimpAttributes {
 	public static final String DESTRUCTION_CALLBACK_NAME_PREFIX =
 			SimpAttributes.class.getName() + ".DESTRUCTION_CALLBACK.";
 
-	private static final Log logger = LogFactory.getLog(SimpAttributes.class);
+	private static final Log logger = SimpLogging.forLogName(SimpAttributes.class);
 
 
 	private final String sessionId;

spring-messaging/src/main/java/org/springframework/messaging/simp/SimpLogging.java

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2002-2018 the original author or 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 org.springframework.messaging.simp;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import org.springframework.util.log.LogUtils;
+
+/**
+ * Holds the shared logger named "org.springframework.web.SimpLogging" to use
+ * for STOMP over WebSocket messaging when logging for
+ * "org.springframework.messaging.simp" is off but logging for
+ * "org.springframework.web" is on.
+ *
+ * <p>This makes it possible to enable all web related logging via
+ * "org.springframework.web" including logging from lower-level packages such as
+ * "org.springframework.messaging.simp".
+ *
+ * <p>To see logging from the primary classes where log messages originate from,
+ * simply enable logging for "org.springframework.messaging".
+ *
+ * @author Rossen Stoyanchev
+ * @since 5.1
+ */
+public abstract class SimpLogging {
+
+	private static final Log fallbackLogger =
+			LogFactory.getLog("org.springframework.web." + SimpLogging.class.getSimpleName());
+
+
+	/**
+	 * Create a primary logger for the given class and wrap it with a composite
+	 * that delegates to it or to the fallback logger named
+	 * "org.springframework.web.SimpLogging", if the primary is not enabled.
+	 * @param primaryLoggerClass the class for the name of the primary logger
+	 * @return the resulting composite logger
+	 */
+	public static Log forLogName(Class<?> primaryLoggerClass) {
+		Log primaryLogger = LogFactory.getLog(primaryLoggerClass);
+		return forLog(primaryLogger);
+	}
+
+	/**
+	 * Wrap the given primary logger with a composite logger that delegates to
+	 * either the primary or to the shared fallback logger
+	 * "org.springframework.web.HttpLogging", if the primary is not enabled.
+	 * @param primaryLogger the primary logger to use
+	 * @return the resulting composite logger
+	 */
+	public static Log forLog(Log primaryLogger) {
+		return LogUtils.getCompositeLog(primaryLogger, fallbackLogger);
+	}
+
+}

spring-messaging/src/main/java/org/springframework/messaging/simp/annotation/support/SimpAnnotationMethodMessageHandler.java

@@ -25,6 +25,8 @@
 import java.util.Map;
 import java.util.Set;
 
+import org.apache.commons.logging.Log;
+
 import org.springframework.beans.factory.config.ConfigurableBeanFactory;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ConfigurableApplicationContext;
@@ -56,8 +58,10 @@
 import org.springframework.messaging.handler.invocation.CompletableFutureReturnValueHandler;
 import org.springframework.messaging.handler.invocation.HandlerMethodArgumentResolver;
 import org.springframework.messaging.handler.invocation.HandlerMethodReturnValueHandler;
+import org.springframework.messaging.handler.invocation.HandlerMethodReturnValueHandlerComposite;
 import org.springframework.messaging.handler.invocation.ListenableFutureReturnValueHandler;
 import org.springframework.messaging.simp.SimpAttributesContextHolder;
+import org.springframework.messaging.simp.SimpLogging;
 import org.springframework.messaging.simp.SimpMessageHeaderAccessor;
 import org.springframework.messaging.simp.SimpMessageMappingInfo;
 import org.springframework.messaging.simp.SimpMessageSendingOperations;
@@ -357,6 +361,16 @@ protected List<? extends HandlerMethodReturnValueHandler> initReturnValueHandler
 		return handlers;
 	}
 
+	@Override
+	protected Log getReturnValueHandlerLogger() {
+		return SimpLogging.forLog(HandlerMethodReturnValueHandlerComposite.defaultLogger);
+	}
+
+	@Override
+	protected Log getHandlerMethodLogger() {
+		return SimpLogging.forLog(HandlerMethod.defaultLogger);
+	}
+
 
 	@Override
 	protected boolean isHandler(Class<?> beanType) {

spring-messaging/src/main/java/org/springframework/messaging/simp/annotation/support/SubscriptionMethodReturnValueHandler.java

@@ -17,7 +17,6 @@
 package org.springframework.messaging.simp.annotation.support;
 
 import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
 
 import org.springframework.core.MethodParameter;
 import org.springframework.lang.Nullable;
@@ -26,6 +25,7 @@
 import org.springframework.messaging.core.MessageSendingOperations;
 import org.springframework.messaging.handler.annotation.SendTo;
 import org.springframework.messaging.handler.invocation.HandlerMethodReturnValueHandler;
+import org.springframework.messaging.simp.SimpLogging;
 import org.springframework.messaging.simp.SimpMessageHeaderAccessor;
 import org.springframework.messaging.simp.SimpMessageType;
 import org.springframework.messaging.simp.SimpMessagingTemplate;
@@ -58,7 +58,7 @@
  */
 public class SubscriptionMethodReturnValueHandler implements HandlerMethodReturnValueHandler {
 
-	private static final Log logger = LogFactory.getLog(SubscriptionMethodReturnValueHandler.class);
+	private static final Log logger = SimpLogging.forLogName(SubscriptionMethodReturnValueHandler.class);
 
 
 	private final MessageSendingOperations<String> messagingTemplate;

spring-messaging/src/main/java/org/springframework/messaging/simp/broker/AbstractBrokerMessageHandler.java

@@ -21,7 +21,6 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
 
 import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.context.ApplicationEventPublisherAware;
@@ -31,6 +30,7 @@
 import org.springframework.messaging.MessageChannel;
 import org.springframework.messaging.MessageHandler;
 import org.springframework.messaging.SubscribableChannel;
+import org.springframework.messaging.simp.SimpLogging;
 import org.springframework.messaging.simp.SimpMessageHeaderAccessor;
 import org.springframework.messaging.simp.SimpMessageType;
 import org.springframework.messaging.support.ChannelInterceptor;
@@ -48,7 +48,7 @@
 public abstract class AbstractBrokerMessageHandler
 		implements MessageHandler, ApplicationEventPublisherAware, SmartLifecycle {
 
-	protected final Log logger = LogFactory.getLog(getClass());
+	protected final Log logger = SimpLogging.forLogName(getClass());
 
 	private final SubscribableChannel clientInboundChannel;
 

spring-messaging/src/main/java/org/springframework/messaging/simp/broker/AbstractSubscriptionRegistry.java

@@ -17,10 +17,10 @@
 package org.springframework.messaging.simp.broker;
 
 import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
 
 import org.springframework.messaging.Message;
 import org.springframework.messaging.MessageHeaders;
+import org.springframework.messaging.simp.SimpLogging;
 import org.springframework.messaging.simp.SimpMessageHeaderAccessor;
 import org.springframework.messaging.simp.SimpMessageType;
 import org.springframework.util.CollectionUtils;
@@ -40,7 +40,7 @@ public abstract class AbstractSubscriptionRegistry implements SubscriptionRegist
 	private static final MultiValueMap<String, String> EMPTY_MAP =
 			CollectionUtils.unmodifiableMultiValueMap(new LinkedMultiValueMap<>(0));
 
-	protected final Log logger = LogFactory.getLog(getClass());
+	protected final Log logger = SimpLogging.forLogName(getClass());
 
 
 	@Override

spring-messaging/src/main/java/org/springframework/messaging/simp/config/AbstractMessageBrokerConfiguration.java

@@ -37,6 +37,7 @@
 import org.springframework.messaging.converter.StringMessageConverter;
 import org.springframework.messaging.handler.invocation.HandlerMethodArgumentResolver;
 import org.springframework.messaging.handler.invocation.HandlerMethodReturnValueHandler;
+import org.springframework.messaging.simp.SimpLogging;
 import org.springframework.messaging.simp.SimpMessagingTemplate;
 import org.springframework.messaging.simp.annotation.support.SimpAnnotationMethodMessageHandler;
 import org.springframework.messaging.simp.broker.AbstractBrokerMessageHandler;
@@ -125,6 +126,7 @@ public ApplicationContext getApplicationContext() {
 	@Bean
 	public AbstractSubscribableChannel clientInboundChannel() {
 		ExecutorSubscribableChannel channel = new ExecutorSubscribableChannel(clientInboundChannelExecutor());
+		channel.setLogger(SimpLogging.forLog(channel.getLogger()));
 		ChannelRegistration reg = getClientInboundChannelRegistration();
 		if (reg.hasInterceptors()) {
 			channel.setInterceptors(reg.getInterceptors());
@@ -160,6 +162,7 @@ protected void configureClientInboundChannel(ChannelRegistration registration) {
 	@Bean
 	public AbstractSubscribableChannel clientOutboundChannel() {
 		ExecutorSubscribableChannel channel = new ExecutorSubscribableChannel(clientOutboundChannelExecutor());
+		channel.setLogger(SimpLogging.forLog(channel.getLogger()));
 		ChannelRegistration reg = getClientOutboundChannelRegistration();
 		if (reg.hasInterceptors()) {
 			channel.setInterceptors(reg.getInterceptors());
@@ -198,6 +201,7 @@ public AbstractSubscribableChannel brokerChannel() {
 		ExecutorSubscribableChannel channel = (reg.hasTaskExecutor() ?
 				new ExecutorSubscribableChannel(brokerChannelExecutor()) : new ExecutorSubscribableChannel());
 		reg.interceptors(new ImmutableMessageChannelInterceptor());
+		channel.setLogger(SimpLogging.forLog(channel.getLogger()));
 		channel.setInterceptors(reg.getInterceptors());
 		return channel;
 	}

spring-messaging/src/main/java/org/springframework/messaging/simp/stomp/DefaultStompSession.java

@@ -29,7 +29,6 @@
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
 
 import org.springframework.core.ResolvableType;
 import org.springframework.lang.Nullable;
@@ -38,6 +37,7 @@
 import org.springframework.messaging.converter.MessageConversionException;
 import org.springframework.messaging.converter.MessageConverter;
 import org.springframework.messaging.converter.SimpleMessageConverter;
+import org.springframework.messaging.simp.SimpLogging;
 import org.springframework.messaging.support.MessageBuilder;
 import org.springframework.messaging.support.MessageHeaderAccessor;
 import org.springframework.messaging.tcp.TcpConnection;
@@ -58,7 +58,7 @@
  */
 public class DefaultStompSession implements ConnectionHandlingStompSession {
 
-	private static final Log logger = LogFactory.getLog(DefaultStompSession.class);
+	private static final Log logger = SimpLogging.forLogName(DefaultStompSession.class);
 
 	private static final IdGenerator idGenerator = new AlternativeJdkIdGenerator();