* @return {@link Logger}
     */
    public static synchronized Logger getLogger(final Class<?> clazz) {
        assertArgumentNotNull("clazz", clazz);

        if (!initialized) {
            initialize();
        }
        Logger logger = loggers.get(clazz);
        if (logger == null) {
            logger = new Logger(clazz);
            loggers.put(clazz, logger);
        }

public class ErrorToWarnRewritePolicy implements RewritePolicy {

    /** Array of logger name prefixes to apply the ERROR to WARN conversion */
    private final String[] loggerNames;

    /**
     * Constructs a new ErrorToWarnRewritePolicy with the specified logger names.
     *
     * @param loggerNames array of logger name prefixes to convert ERROR to WARN
     */
    public ErrorToWarnRewritePolicy(final String[] loggerNames) {

 * governing permissions and limitations under the License.
 */
package org.codelibs.core.log;

import org.apache.commons.logging.LogFactory;

/**
 * Factory for creating adapters that use (Jakarta) Commons Logging loggers.
 *
 * @author koichik
 */
class JclLoggerAdapterFactory implements LoggerAdapterFactory {

    @Override
    public LoggerAdapter getLoggerAdapter(final Class<?> clazz) {

 * governing permissions and limitations under the License.
 */
package org.codelibs.core.log;

/**
 * Factory for creating adapters that use java.util.logging loggers.
 *
 * @author koichik
 */
class JulLoggerAdapterFactory implements LoggerAdapterFactory {

    @Override
    public LoggerAdapter getLoggerAdapter(final Class<?> clazz) {

/**
 * Adapter that uses java.util.logging loggers.
 *
 * @author koichik
 */
class JulLoggerAdapter implements LoggerAdapter {

    protected final String sourceClass;

    protected final java.util.logging.Logger logger;

    public JulLoggerAdapter(final Class<?> clazz) {
        sourceClass = clazz.getName();
        logger = java.util.logging.Logger.getLogger(clazz.getName());
    }

    @Override

      re.printStackTrace()
    }
  }

  private fun enableLogging(
    logger: String,
    tag: String,
  ) {
    val logger = Logger.getLogger(logger)
    if (configuredLoggers.add(logger)) {
      logger.useParentHandlers = false
      // log based on levels at startup to avoid logging each frame
      logger.level =
        when {
          Log.isLoggable(tag, Log.DEBUG) -> Level.FINE

 * collected, and this class can detect when the main class loader has been garbage collected and
 * stop itself.
 */
public class Finalizer implements Runnable {

  private static final Logger logger = Logger.getLogger(Finalizer.class.getName());

  /** Name of FinalizableReference.class. */
  private static final String FINALIZABLE_REFERENCE = "com.google.common.base.FinalizableReference";

  /**

            if (ssoManager.available()) {
                if (logger.isDebugEnabled()) {
                    logger.debug("SSO is available but no user found.");
                }
                saveError(messages -> messages.addErrorsSsoLoginError(GLOBAL));
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Redirecting to login page.");
            }

 *
 * <pre>
 *   TestLogHandler handler;
 *
 *   protected void setUp() throws Exception {
 *     super.setUp();
 *     handler = new TestLogHandler();
 *     SomeClass.logger.addHandler(handler);
 *     addTearDown(new TearDown() {
 *       public void tearDown() throws Exception {
 *         SomeClass.logger.removeHandler(handler);
 *       }

     */
    protected CloseableUtil() {
    }

    private static final Logger logger = Logger.getLogger(CloseableUtil.class);

    /**
     * Closes a {@link Closeable}.
     * <p>
     * If an exception is thrown by {@link Closeable#close()}, an error message is logged. The exception is not rethrown. This prevents the original exception from being lost in situations like the following:
     * </p>
     * <pre>