@Override protected int extractLink(int index, String content, SortedSet<ContentChunkInfo> linksToAdd) { if (content.substring(index, index + 4).equals("url(")) { // Ignore, UrlLinkParser will take care } else if (logger.isTraceEnabled()) { logger.trace("Unexpected syntax for @import link at index " + index); } return index; } }
private void logRouterFunctions(List<RouterFunction<?>> routerFunctions) { if (logger.isDebugEnabled()) { int total = routerFunctions.size(); String message = total + " RouterFunction(s) in " + formatMappingName(); if (logger.isTraceEnabled()) { if (total > 0) { routerFunctions.forEach(routerFunction -> logger.trace("Mapped " + routerFunction)); } else { logger.trace(message); } } else if (total > 0) { logger.debug(message); } } }
@Override public BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException { BeanDefinition bd = this.beanDefinitionMap.get(beanName); if (bd == null) { if (logger.isTraceEnabled()) { logger.trace("No bean named '" + beanName + "' found in " + this); } throw new NoSuchBeanDefinitionException(beanName); } return bd; }
BufferingStompDecoder decoder = this.decoders.get(session.getId()); if (decoder == null) { throw new IllegalStateException("No decoder for session id '" + session.getId() + "'"); if (logger.isTraceEnabled()) { logger.trace("Incomplete STOMP frame content received in session " + session + ", bufferSize=" + decoder.getBufferSize() + ", bufferSizeLimit=" + decoder.getBufferSizeLimit() + "."); logger.error("Failed to parse " + webSocketMessage + " in session " + session.getId() + ". Sending STOMP ERROR to client.", ex); if (logger.isTraceEnabled()) { logger.trace("From client: " + headerAccessor.getShortLogMessage(message.getPayload())); logger.error("Failed to send client message to application via MessageChannel" + " in session " + session.getId() + ". Sending STOMP ERROR to client.", ex);
@Override public void executeSendRequest(URI url, HttpHeaders headers, TextMessage message) { if (logger.isTraceEnabled()) { logger.trace("Starting XHR send, url=" + url); } ResponseEntity<String> response = executeSendRequestInternal(url, headers, message); if (response.getStatusCode() != HttpStatus.NO_CONTENT) { if (logger.isErrorEnabled()) { logger.error("XHR send request (url=" + url + ") failed: " + response); } throw new HttpServerErrorException(response.getStatusCode()); } if (logger.isTraceEnabled()) { logger.trace("XHR send request (url=" + url + ") response: " + response); } }
/** * Releases the connection. If the connection is locked or does not have a connection * manager associated with it, this method has no effect. Note that it is completely safe * to call this method multiple times. */ public void releaseConnection() { LOG.trace("enter HttpConnection.releaseConnection()"); if (locked) { LOG.debug("Connection is locked. Call to releaseConnection() ignored."); } else if (httpConnectionManager != null) { LOG.debug("Releasing connection back to connection manager."); httpConnectionManager.releaseConnection(this); } else { LOG.warn("HttpConnectionManager is null. Connection cannot be released."); } }
@Override public void onMessage(javax.jms.Message jmsMessage, @Nullable Session session) throws JMSException { Message<?> message = toMessagingMessage(jmsMessage); if (logger.isDebugEnabled()) { logger.debug("Processing [" + message + "]"); } Object result = invokeHandler(jmsMessage, session, message); if (result != null) { handleResult(result, jmsMessage, session); } else { logger.trace("No result object given - no result to handle"); } }
protected int update(final PreparedStatementCreator psc, @Nullable final PreparedStatementSetter pss) throws DataAccessException { logger.debug("Executing prepared SQL update"); return updateCount(execute(psc, ps -> { try { if (pss != null) { pss.setValues(ps); } int rows = ps.executeUpdate(); if (logger.isTraceEnabled()) { logger.trace("SQL update affected " + rows + " rows"); } return rows; } finally { if (pss instanceof ParameterDisposer) { ((ParameterDisposer) pss).cleanupParameters(); } } })); }
@Override public void onError(Throwable ex) { logger.trace(this.logPrefix + "Failed to complete: " + ex.getMessage()); if (this.exchange.isResponseStarted()) { try { logger.debug(this.logPrefix + "Closing connection"); this.exchange.getConnection().close(); } catch (IOException ex2) { // ignore } } else { logger.debug(this.logPrefix + "Setting HttpServerExchange status to 500 Server Error"); this.exchange.setStatusCode(500); this.exchange.endExchange(); } }
@Override public void close() { if (log.isTraceEnabled()) { log.trace("Closing HTTP transport to " + httpInfo); } HttpConnectionManager manager = client.getHttpConnectionManager(); if (manager instanceof SocketTrackingConnectionManager) { try { ((SocketTrackingConnectionManager) manager).close(); } catch (NullPointerException npe) { // ignore } catch (Exception ex) { // log - not much else to do log.warn("Exception closing underlying HTTP manager", ex); } } }
@Override public void setServletContext(ServletContext servletContext) { if (this.attributes != null) { for (Map.Entry<String, Object> entry : this.attributes.entrySet()) { String attributeName = entry.getKey(); if (logger.isDebugEnabled()) { if (servletContext.getAttribute(attributeName) != null) { logger.debug("Replacing existing ServletContext attribute with name '" + attributeName + "'"); } } servletContext.setAttribute(attributeName, entry.getValue()); if (logger.isTraceEnabled()) { logger.trace("Exported ServletContext attribute with name '" + attributeName + "'"); } } } }
/** * Determine the exception handle method for the given exception. * @param exception the exception thrown * @return a handler for the given exception type, or {@code null} if none found */ @Nullable private Method getExceptionHandler(Throwable exception) { Class<?> exceptionClass = exception.getClass(); if (logger.isTraceEnabled()) { logger.trace("Trying to find handler for exception of type [" + exceptionClass.getName() + "]"); } Method handler = this.exceptionHandlerMap.get(exceptionClass); while (handler == null && exceptionClass != Throwable.class) { exceptionClass = exceptionClass.getSuperclass(); handler = this.exceptionHandlerMap.get(exceptionClass); } if (handler != null && logger.isTraceEnabled()) { logger.trace("Found handler for exception of type [" + exceptionClass.getName() + "]: " + handler); } return handler; }
@Override public void log(final Level level, final String message, final Throwable throwable) { switch (level) { case TRACE: logger.trace(message, throwable); break; case DEBUG: logger.debug(message, throwable); break; case INFO: logger.info(message, throwable); break; case WARN: logger.warn(message, throwable); break; case ERROR: logger.error(message, throwable); break; } }
protected void logTraceInformation(Resource bundle) { if (LOG.isTraceEnabled()) { if (bundle == null) { LOG.trace("Resolving bundle, bundle is null"); } else { LOG.trace("Resolving bundle, bundle is not null, bundle.exists() == " + bundle.exists() + " ,filename = " + bundle.getFilename()); try { LOG.trace("Resolving bundle - File Path" + bundle.getFile().getAbsolutePath()); } catch (IOException e) { LOG.error("IOException debugging bundle code", e); } } } }
@Override public Mono<Void> apply(HttpServerRequest reactorRequest, HttpServerResponse reactorResponse) { NettyDataBufferFactory bufferFactory = new NettyDataBufferFactory(reactorResponse.alloc()); try { ReactorServerHttpRequest request = new ReactorServerHttpRequest(reactorRequest, bufferFactory); ServerHttpResponse response = new ReactorServerHttpResponse(reactorResponse, bufferFactory); if (request.getMethod() == HttpMethod.HEAD) { response = new HttpHeadResponseDecorator(response); } return this.httpHandler.handle(request, response) .doOnError(ex -> logger.trace(request.getLogPrefix() + "Failed to complete: " + ex.getMessage())) .doOnSuccess(aVoid -> logger.trace(request.getLogPrefix() + "Handling completed")); } catch (URISyntaxException ex) { if (logger.isDebugEnabled()) { logger.debug("Failed to get request URI: " + ex.getMessage()); } reactorResponse.status(HttpResponseStatus.BAD_REQUEST); return Mono.empty(); } }
@Override protected int extractUnquotedLink(int position, String content, Set<ContentChunkInfo> result) { if (content.substring(position, position + 4).equals("url(")) { // Ignore, UrlFunctionContentParser will take care } else if (logger.isTraceEnabled()) { logger.trace("Unexpected syntax for @import link at index " + position); } return position; } }
@Override public Resource minify(Resource originalResource) { if (!getEnabled()) { LOG.trace(MINIFICATION_IS_DISABLED_RETURNING_ORIGINAL_RESOURCE); return originalResource; } if (originalResource.getFilename() == null) { LOG.warn("Attempted to modify resource without a filename, returning non-minified resource"); return originalResource; } return minify(originalResource, originalResource.getFilename()); }
/** * Initialize the MultipartResolver used by this class. * <p>If no bean is defined with the given name in the BeanFactory for this namespace, * no multipart handling is provided. */ private void initMultipartResolver(ApplicationContext context) { try { this.multipartResolver = context.getBean(MULTIPART_RESOLVER_BEAN_NAME, MultipartResolver.class); if (logger.isTraceEnabled()) { logger.trace("Detected " + this.multipartResolver); } else if (logger.isDebugEnabled()) { logger.debug("Detected " + this.multipartResolver.getClass().getSimpleName()); } } catch (NoSuchBeanDefinitionException ex) { // Default is no multipart resolver. this.multipartResolver = null; if (logger.isTraceEnabled()) { logger.trace("No MultipartResolver '" + MULTIPART_RESOLVER_BEAN_NAME + "' declared"); } } }