org.springframework.cache.interceptor.LoggingCacheErrorHandler Maven / Gradle / Ivy

/*
 * Copyright 2002-2022 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
 *
 *      https://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.cache.interceptor;

import java.util.function.Supplier;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.springframework.cache.Cache;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;

/**
 * A {@link CacheErrorHandler} implementation that logs error messages.
 *
 * Can be used when underlying cache errors should be ignored.
 *
 * @author Adam Ostrožlík
 * @author Stephane Nicoll
 * @author Vedran Pavic
 * @author Sam Brannen
 * @since 5.3.16
 */
public class LoggingCacheErrorHandler implements CacheErrorHandler {

	private final Log logger;

	private final boolean logStackTraces;


	/**
	 * Create a {@code LoggingCacheErrorHandler} that uses the default logging
	 * category and does not log stack traces.
	 * 
The default logging category is
	 * "{@code org.springframework.cache.interceptor.LoggingCacheErrorHandler}".
	 */
	public LoggingCacheErrorHandler() {
		this(false);
	}

	/**
	 * Create a {@code LoggingCacheErrorHandler} that uses the default logging
	 * category and the supplied {@code logStackTraces} flag.
	 * 
The default logging category is
	 * "{@code org.springframework.cache.interceptor.LoggingCacheErrorHandler}".
	 * @param logStackTraces whether to log stack traces
	 * @since 5.3.22
	 */
	public LoggingCacheErrorHandler(boolean logStackTraces) {
		this(LogFactory.getLog(LoggingCacheErrorHandler.class), logStackTraces);
	}

	/**
	 * Create a {@code LoggingCacheErrorHandler} that uses the supplied
	 * {@link Log logger} and {@code logStackTraces} flag.
	 * @param logger the logger to use
	 * @param logStackTraces whether to log stack traces
	 */
	public LoggingCacheErrorHandler(Log logger, boolean logStackTraces) {
		Assert.notNull(logger, "'logger' must not be null");
		this.logger = logger;
		this.logStackTraces = logStackTraces;
	}

	/**
	 * Create a {@code LoggingCacheErrorHandler} that uses the supplied
	 * {@code loggerName} and {@code logStackTraces} flag.
	 * @param loggerName the name of the logger to use. The name will be passed
	 * to the underlying logger implementation through Commons Logging, getting
	 * interpreted as log category according to the logger's configuration.
	 * @param logStackTraces whether to log stack traces
	 * @since 5.3.24
	 * @see org.apache.commons.logging.LogFactory#getLog(String)
	 * @see java.util.logging.Logger#getLogger(String)
	 */
	public LoggingCacheErrorHandler(String loggerName, boolean logStackTraces) {
		Assert.notNull(loggerName, "'loggerName' must not be null");
		this.logger = LogFactory.getLog(loggerName);
		this.logStackTraces = logStackTraces;
	}


	@Override
	public void handleCacheGetError(RuntimeException exception, Cache cache, Object key) {
		logCacheError(
				() -> String.format("Cache '%s' failed to get entry with key '%s'", cache.getName(), key),
				exception);
	}

	@Override
	public void handleCachePutError(RuntimeException exception, Cache cache, Object key, @Nullable Object value) {
		logCacheError(
				() -> String.format("Cache '%s' failed to put entry with key '%s'", cache.getName(), key),
				exception);
	}

	@Override
	public void handleCacheEvictError(RuntimeException exception, Cache cache, Object key) {
		logCacheError(
				() -> String.format("Cache '%s' failed to evict entry with key '%s'", cache.getName(), key),
				exception);
	}

	@Override
	public void handleCacheClearError(RuntimeException exception, Cache cache) {
		logCacheError(
				() -> String.format("Cache '%s' failed to clear entries", cache.getName()),
				exception);
	}


	/**
	 * Get the logger for this {@code LoggingCacheErrorHandler}.
	 * @return the logger
	 * @since 5.3.22
	 */
	protected final Log getLogger() {
		return logger;
	}

	/**
	 * Get the {@code logStackTraces} flag for this {@code LoggingCacheErrorHandler}.
	 * @return {@code true} if this {@code LoggingCacheErrorHandler} logs stack traces
	 * @since 5.3.22
	 */
	protected final boolean isLogStackTraces() {
		return this.logStackTraces;
	}

	/**
	 * Log the cache error message in the given supplier.
	 * 
If {@link #isLogStackTraces()} is {@code true}, the given
	 * {@code exception} will be logged as well.
	 * The default implementation logs the message as a warning.
	 * @param messageSupplier the message supplier
	 * @param exception the exception thrown by the cache provider
	 * @since 5.3.22
	 * @see #isLogStackTraces()
	 * @see #getLogger()
	 */
	protected void logCacheError(Supplier messageSupplier, RuntimeException exception) {
		if (getLogger().isWarnEnabled()) {
			if (isLogStackTraces()) {
				getLogger().warn(messageSupplier.get(), exception);
			}
			else {
				getLogger().warn(messageSupplier.get());
			}
		}
	}

}