@Override public void handleError(Throwable t) { if (logger.isErrorEnabled()) { logger.error("Unexpected error occurred in scheduled task.", t); } } }
@Override public boolean isEnabled(final Level level) { switch (level) { case TRACE: return logger.isTraceEnabled(); case DEBUG: return logger.isDebugEnabled(); case INFO: return logger.isInfoEnabled(); case WARN: return logger.isWarnEnabled(); case ERROR: return logger.isErrorEnabled(); default: throw new IllegalArgumentException(); } }
@Override public String executeInfoRequest(URI infoUrl, @Nullable HttpHeaders headers) { if (logger.isDebugEnabled()) { logger.debug("Executing SockJS Info request, url=" + infoUrl); } HttpHeaders infoRequestHeaders = new HttpHeaders(); if (headers != null) { infoRequestHeaders.putAll(headers); } ResponseEntity<String> response = executeInfoRequestInternal(infoUrl, infoRequestHeaders); if (response.getStatusCode() != HttpStatus.OK) { if (logger.isErrorEnabled()) { logger.error("SockJS Info request (url=" + infoUrl + ") failed: " + response); } throw new HttpServerErrorException(response.getStatusCode()); } if (logger.isTraceEnabled()) { logger.trace("SockJS Info request (url=" + infoUrl + ") response: " + response); } String result = response.getBody(); return (result != null ? result : ""); }
this.log.debug("User credentials not available"); return; request.addHeader(authScheme.authenticate(creds, request)); } catch (AuthenticationException ex) { if (this.log.isErrorEnabled()) { this.log.error("Authentication error: " + ex.getMessage());
public void handleMessageToClient(WebSocketSession session, Message<?> message) { if (!(message.getPayload() instanceof byte[])) { if (logger.isErrorEnabled()) { logger.error("Expected byte[] payload. Ignoring " + message + "."); if (accessor.getSubscriptionId() == null && logger.isWarnEnabled()) { logger.warn("No STOMP \"subscription\" header in " + message);
private void validateAuthenticationInfo(HttpServletRequest request, Map<String, List> contentMap) throws OAuthClientAuthnException { if (isBasicAuthorizationHeaderExists(request)) { if (log.isErrorEnabled()) { log.debug("Authorization header exists. Hence validating whether body params also present"); } validateDuplicatedBasicAuthInfo(request, contentMap); } }
@Test public void testWarnWithEx() { Log theLogger = mock(Log.class); LogIfLevelEnabled logger = new LogIfLevelEnabled(theLogger, LogIfLevelEnabled.Level.WARN); given(theLogger.isFatalEnabled()).willReturn(true); given(theLogger.isErrorEnabled()).willReturn(true); given(theLogger.isWarnEnabled()).willReturn(true); logger.log(() -> "foo", rte); verify(theLogger).isWarnEnabled(); verify(theLogger).warn(any(), any()); verifyNoMoreInteractions(theLogger); }
byte[] transformed = this.classTransformer.transform( loader, className, classBeingRedefined, protectionDomain, classfileBuffer); if (transformed != null && logger.isDebugEnabled()) { logger.debug("Transformer of class [" + this.classTransformer.getClass().getName() + "] transformed class [" + className + "]; bytes in=" + classfileBuffer.length + "; bytes out=" + transformed.length); if (logger.isErrorEnabled()) { logger.error("Circularity error while weaving class [" + className + "] with " + "transformer of class [" + this.classTransformer.getClass().getName() + "]", ex); if (logger.isWarnEnabled()) { logger.warn("Error weaving class [" + className + "] with transformer of class [" + this.classTransformer.getClass().getName() + "]", ex);
@Override public void handleUncaughtException(Throwable ex, Method method, Object... params) { if (logger.isErrorEnabled()) { logger.error("Unexpected exception occurred invoking async method: " + method, ex); } }
if(log.isErrorEnabled()) if(log.isWarnEnabled()) if(log.isDebugEnabled())
this.log.debug("User credentials not available"); return; request.addHeader(authScheme.authenticate(creds, request)); } catch (AuthenticationException ex) { if (this.log.isErrorEnabled()) { this.log.error("Proxy authentication error: " + ex.getMessage());
if (logger.isWarnEnabled()) { logger.warn("Error message was not delivered.", errorDeliveryError); if (!sent && logger.isErrorEnabled()) { Message<?> failedMessage = throwable instanceof MessagingException : null; if (failedMessage != null) { logger.error("failure occurred in messaging task with message: " + failedMessage, throwable); logger.error("failure occurred in messaging task", throwable);
@Test public void testWarnNoEx() { Log theLogger = mock(Log.class); LogIfLevelEnabled logger = new LogIfLevelEnabled(theLogger, LogIfLevelEnabled.Level.WARN); given(theLogger.isFatalEnabled()).willReturn(true); given(theLogger.isErrorEnabled()).willReturn(true); given(theLogger.isWarnEnabled()).willReturn(true); logger.log(() -> "foo"); verify(theLogger).isWarnEnabled(); verify(theLogger).warn(any()); verifyNoMoreInteractions(theLogger); }
/** * Run all {@link BeforeTransaction @BeforeTransaction} methods for the * specified {@linkplain TestContext test context}. If one of the methods * fails, however, the caught exception will be rethrown in a wrapped * {@link RuntimeException}, and the remaining methods will <strong>not</strong> * be given a chance to execute. * @param testContext the current test context */ protected void runBeforeTransactionMethods(TestContext testContext) throws Exception { try { List<Method> methods = getAnnotatedMethods(testContext.getTestClass(), BeforeTransaction.class); Collections.reverse(methods); for (Method method : methods) { if (logger.isDebugEnabled()) { logger.debug("Executing @BeforeTransaction method [" + method + "] for test context " + testContext); } ReflectionUtils.makeAccessible(method); method.invoke(testContext.getTestInstance()); } } catch (InvocationTargetException ex) { if (logger.isErrorEnabled()) { logger.error("Exception encountered while executing @BeforeTransaction methods for test context " + testContext + ".", ex.getTargetException()); } ReflectionUtils.rethrowException(ex.getTargetException()); } }
private void publishEvent(ApplicationEventPublisher publisher, ApplicationEvent event) { try { publisher.publishEvent(event); } catch (Throwable ex) { if (logger.isErrorEnabled()) { logger.error("Error publishing " + event, ex); } } }
/** Returns the level for this logger. */ public Level getLevel() { if (logger.isTraceEnabled()) return Level.FINEST; if (logger.isDebugEnabled()) return Level.FINE; if (logger.isInfoEnabled()) return Level.CONFIG; if (logger.isWarnEnabled()) return Level.WARNING; if (logger.isErrorEnabled()) return Level.SEVERE; if (logger.isFatalEnabled()) return Level.SEVERE; return Level.OFF; }
@Override public final void handleError(Throwable t) { MessageChannel errorChannel = resolveErrorChannel(t); boolean sent = false; if (errorChannel != null) { try { getMessagingTemplate().send(errorChannel, getErrorMessageStrategy().buildErrorMessage(t, null)); sent = true; } catch (Throwable errorDeliveryError) { //NOSONAR // message will be logged only if (this.logger.isWarnEnabled()) { this.logger.warn("Error message was not delivered.", errorDeliveryError); } if (errorDeliveryError instanceof Error) { throw ((Error) errorDeliveryError); } } } if (!sent && this.logger.isErrorEnabled()) { Message<?> failedMessage = (t instanceof MessagingException) ? ((MessagingException) t).getFailedMessage() : null; if (failedMessage != null) { this.logger.error("failure occurred in messaging task with message: " + failedMessage, t); } else { this.logger.error("failure occurred in messaging task", t); } } }
@Test public void testInfoWithEx() { Log theLogger = mock(Log.class); LogIfLevelEnabled logger = new LogIfLevelEnabled(theLogger, LogIfLevelEnabled.Level.INFO); given(theLogger.isFatalEnabled()).willReturn(true); given(theLogger.isErrorEnabled()).willReturn(true); given(theLogger.isWarnEnabled()).willReturn(true); given(theLogger.isInfoEnabled()).willReturn(true); logger.log(() -> "foo", rte); verify(theLogger).isInfoEnabled(); verify(theLogger).info(any(), any()); verifyNoMoreInteractions(theLogger); }
private void handleOpenFrame() { if (logger.isDebugEnabled()) { logger.debug("Processing SockJS open frame in " + this); } if (this.state == State.NEW) { this.state = State.OPEN; try { this.webSocketHandler.afterConnectionEstablished(this); this.connectFuture.set(this); } catch (Throwable ex) { if (logger.isErrorEnabled()) { logger.error("WebSocketHandler.afterConnectionEstablished threw exception in " + this, ex); } } } else { if (logger.isDebugEnabled()) { logger.debug("Open frame received in " + getId() + " but we're not connecting (current state " + this.state + "). The server might have been restarted and lost track of the session."); } silentClose(new CloseStatus(1006, "Server lost session")); } }
@Override public void handleError(Throwable t) { if (logger.isErrorEnabled()) { logger.error("Unexpected error occurred in scheduled task.", t); } } }