Java Code Examples for org.slf4j.Logger#warn()

private void releaseConnection() {
    if (connection != null) {
        try {
            connection.getContext().reset();
            connection.getParentConnectionPool().returnConnection(connection);
            if (pipelineEx.get() != null) {
                connPool.getHealthTracker().trackConnectionError(connection.getParentConnectionPool(),
                        pipelineEx.get());
                pipelineEx.set(null);
            }
            connection = null;
        } catch (Exception e) {
            Logger.warn(String.format("Failed to return connection in Dyno Jedis Pipeline, %s", getHostInfo()), e);
        }
    }
}
 

@Around("logPointCut()")
public Object methodAround(ProceedingJoinPoint point) throws Throwable {
    Instant startTime = Instant.now();
    Class targetClass = point.getTarget().getClass();
    MethodSignature methodSignature = (MethodSignature) point.getSignature();
    String methodName = methodSignature.getName();
    Object[] args = point.getArgs();
    Logger logger = LoggerManager.getLogger(targetClass);
    // log args of param in controller
    // if args contains BindingResult(recursive of request entity and itself), stack over flow
    logger.debug("startTime:{} methodName:{} args:{}", startTime, methodName,
        JsonUtils.toJSONString(this.excludeBindingResult(args)));
    Object result = null;
    try {
        result = point.proceed();
    } catch (Throwable throwable) {
        logger.warn("fail request. methodName:{} ", methodName, throwable);
        throw throwable;
    }

    String resultStr = Optional.ofNullable(result).map(JsonUtils::toJSONString).orElse(null);
    logger.debug("methodName:{} usedTime:{} result:{}", methodName,
        Duration.between(startTime, Instant.now()), resultStr);
    return result;
}
 

/**
 * Override this to easily change the logging level etc.
 */
protected void performLogging(Logger log, Marker marker, String logMessage) {
    if (loggingLevel == Level.INFO) {
        log.info(marker, logMessage);
    } else if (loggingLevel == Level.DEBUG) {
        log.debug(marker, logMessage);
    } else if (loggingLevel == Level.ERROR) {
        log.error(marker, logMessage);
    } else if (loggingLevel == Level.TRACE) {
        log.trace(marker, logMessage);
    } else if (loggingLevel == Level.WARN) {
        log.warn(marker, logMessage);
    } else {
        log.info(marker, logMessage);
    }
}
 

@Override
public <T extends Exception> void warnAndThrow(String loggerName,
                                               Class<T> cls, Exception e, String eInfo, String format,
                                               Object... values) throws RuntimeException {
    Logger logger = getLogger(loggerName);
    if (null == logger)
        return;
    if (logger.isWarnEnabled()) {
        String id = AlbianServiceRouter.getLogIdService().makeLoggerId();
        String msg = getWarnMsg(e, format, values);
        String tMsg = String.format("%s | %s.", id, msg);
        logger.warn(tMsg);
        Class[] clss = new Class[]{String.class};
        Object[] vars = new Object[]{"Warn:" + id + "," + eInfo};
        T throwObject = null;
        try {
            throwObject = (T) AlbianReflect.newInstance(cls, clss, vars);
        } catch (Exception e1) {
            throw new RuntimeException(e);
        }
        if (null != throwObject)
            throw new RuntimeException(throwObject);
    }
}
 

static void handleException(
    Exception e,
    ImportWizard importWizard,
    BindingResult result,
    Logger logger,
    String dataImportOption) {
  File file = importWizard.getFile();

  if (logger.isWarnEnabled()) {
    logger.warn(
        format(
            "Import of file [%s] failed for action [%s]",
            Optional.ofNullable(file).map(File::getName).orElse("UNKNOWN"), dataImportOption),
        e);
  }

  result.addError(
      new ObjectError("wizard", "<b>Your import failed:</b><br />" + e.getLocalizedMessage()));
}
 

@Test
public void addAndRemoveAppender() {
	String testString = "Hello";
	Logger logger = LoggerFactory.getLogger(LogbackListAppenderTest.class);
	LogbackListAppender appender = new LogbackListAppender();
	// class
	appender.addToLogger(LogbackListAppenderTest.class);
	logger.warn(testString);
	assertThat(appender.getFirstLog()).isNotNull();

	appender.clearLogs();
	appender.removeFromLogger(LogbackListAppenderTest.class);
	logger.warn(testString);
	assertThat(appender.getFirstLog()).isNull();

	// name
	appender.clearLogs();
	appender.addToLogger("com.vip.vjtools.test.log");
	logger.warn(testString);
	assertThat(appender.getFirstLog()).isNotNull();

	appender.clearLogs();
	appender.removeFromLogger("com.vip.vjtools.test.log");
	logger.warn(testString);
	assertThat(appender.getFirstLog()).isNull();
}
 

static void initialize() {
	Logger log = LoggerFactory.getLogger(WindowLayout.class);
	try {
		File dir = getDir();
		File xmi = new File(dir, "workbench.xmi");
		if (!xmi.exists()) {
			copyXmi();
			return;
		}
		File resetFlag = new File(dir, "_reset_layout");
		if (!resetFlag.exists()) {
			log.trace("window layout file exists {}", xmi);
			return;
		}

		log.info("reset window layout");
		copyXmi();
		if (!resetFlag.delete()) {
			log.warn("failed to delete reset flag; "
					+ "adding shutdown hook: " + resetFlag);
			resetFlag.deleteOnExit();
		}
	} catch (Exception e) {
		log.error("failed to initialize workbench layout", e);
	}
}
 

@Test
public void testMethodLogger() throws Exception {
    final ListAppender app = ctx.getListAppender("Method").clear();
    final Logger logger = LoggerFactory.getLogger("MethodLogger");
    logger.info("More messages.");
    logger.warn("CATASTROPHE INCOMING!");
    logger.error("ZOMBIES!!!");
    logger.warn("brains~~~");
    logger.info("Itchy. Tasty.");
    final List<String> messages = app.getMessages();
    assertEquals("Incorrect number of messages.", 5, messages.size());
    for (final String message : messages) {
        assertEquals("Incorrect caller method name.", "testMethodLogger", message);
    }
}
 

/**
 * Convenience method to encode the given string to UTF-8 compliant URL string.
 * @param toEncode the string to encode
 * @param log the logger to log exceptions to
 * @return the encoded string
 */
public static String urlEncode( String toEncode, Logger log )
{
    try
    {
        return URLEncoder.encode( toEncode, "UTF-8" );
    }
    catch( UnsupportedEncodingException ex )
    {
        log.warn( "Unable to encode string to UTF-8 URL: " + toEncode, ex );
        return null;
    }
}
 

public void init( @Service Iterable<ServiceReference<RequestReader>> requestReaderReferences )
{
    Logger logger = LoggerFactory.getLogger( getClass() );
    Identity requestreaderdelegator = StringIdentity.identityOf( "requestreaderdelegator" );

    // Add custom readers first
    for( ServiceReference<RequestReader> requestReader : requestReaderReferences )
    {
        if( !requestReader.identity().equals(requestreaderdelegator) )
        {
            logger.info( "Registered request reader:" + requestReader.identity() );
            registerRequestReader( requestReader.get() );
        }
    }

    // Add defaults
    ResourceBundle defaultRequestReaders = ResourceBundle.getBundle( "org.apache.polygene.library.rest.server.rest-server" );

    String requestReaderClasses = defaultRequestReaders.getString( "requestreaders" );
    logger.info( "Using request readers:" + requestReaderClasses );
    for( String className : requestReaderClasses.split( "," ) )
    {
        try
        {
            Class readerClass = module.descriptor().classLoader().loadClass( className.trim() );
            RequestReader writer = (RequestReader) module.newObject( readerClass );
            registerRequestReader( writer );
        }
        catch( ClassNotFoundException e )
        {
            logger.warn( "Could not register request reader " + className, e );
        }
    }
}
 

/**
 * Loads the given resource and returns a new ImageView instance.
 * @param resourceName specifying image
 * @return image view with associated resource.
 */
private static ImageView getImageByName(String resourceName) {
	try (InputStream in = SynchronizationUtils.class.getResourceAsStream(resourceName)) {
		if (in != null) {
			return new ImageView(new Image(in));
		}
	} catch (IOException e) {
		Logger logger = LoggerFactory.getLogger(SynchronizationUtils.class);
		logger.warn("Could not load icon '{}'.", resourceName, e);
	}
	return new ImageView();
}
 

public DockerClient build() {
    if (dockerHttpClient != null) {
        return DockerClientImpl.getInstance(
            dockerClientConfig,
            dockerHttpClient
        );
    } else if (dockerCmdExecFactory != null) {
        return DockerClientImpl.getInstance(dockerClientConfig)
            .withDockerCmdExecFactory(dockerCmdExecFactory);
    } else {
        Logger log = LoggerFactory.getLogger(DockerClientBuilder.class);
        log.warn(
            "'dockerHttpClient' should be set." +
                "Falling back to Jersey, will be an error in future releases."
        );

        return DockerClientImpl.getInstance(
            dockerClientConfig,
            new JerseyDockerHttpClient.Builder()
                .dockerHost(dockerClientConfig.getDockerHost())
                .sslConfig(dockerClientConfig.getSSLConfig())
                .build()
        );
    }
}
 

public static ConnectionProvider createConnectionProvider(final ConfiguredObject<?> parent,
                                                          final JDBCSettings settings,
                                                          final Logger logger)
        throws SQLException
{
    String connectionPoolType = settings.getConnectionPoolType() == null
            ? DefaultConnectionProviderFactory.TYPE
            : settings.getConnectionPoolType();

    JDBCConnectionProviderFactory connectionProviderFactory =
            JDBCConnectionProviderFactory.FACTORIES.get(connectionPoolType);
    if (connectionProviderFactory == null)
    {
        logger.warn("Unknown connection pool type: {}.  No connection pooling will be used", connectionPoolType);
        connectionProviderFactory = new DefaultConnectionProviderFactory();
    }

    Map<String, String> providerAttributes = new HashMap<>();
    Set<String> providerAttributeNames = new HashSet<>(connectionProviderFactory.getProviderAttributeNames());
    providerAttributeNames.retainAll(parent.getContextKeys(false));
    for (String attr : providerAttributeNames)
    {
        providerAttributes.put(attr, parent.getContextValue(String.class, attr));
    }

    return connectionProviderFactory.getConnectionProvider(settings.getConnectionUrl(),
                                                           settings.getUsername(),
                                                           settings.getPassword(),
                                                           providerAttributes);
}
 

public static void close(final Closeable closeable, final Logger logger) {
	try {
		closeable.close();
	} catch (final IOException e) {
		logger.warn("Caught exception while closing '{}'.", closeable.getClass(), e);
	}
}
 

public static void logWarning(String sqlType, Logger log, Metric metric, String errorCode, String sql, Object[] args,
                        Options options, Throwable t) {
  if (log.isWarnEnabled()) {
    String msg = logMiddle(' ', sqlType, metric, errorCode, sql, args, options);
    log.warn(msg, t);
  }
}
 

public static void warn(String message, Object... params) {
    Logger log = getLogger(getClassName());
    log.warn(message, params);
}
 

public static void warn(Logger logger, String message, Map<String, String> tags) {
    logger.warn(messageWithTag(message, tags));
}
 

/**
 * Moves the temporary <tt>incomingFile</tt> to its permanent location where it is available for
 * use (not thread-safe!).
 *
 * @param incomingFile
 * 		temporary file created during transfer
 * @param jobId
 * 		ID of the job this blob belongs to or <tt>null</tt> if job-unrelated
 * @param blobKey
 * 		BLOB key identifying the file
 * @param storageFile
 *      (local) file where the blob is/should be stored
 * @param log
 *      logger for debug information
 * @param blobStore
 *      HA store (or <tt>null</tt> if unavailable)
 *
 * @throws IOException
 * 		thrown if an I/O error occurs while moving the file or uploading it to the HA store
 */
static void moveTempFileToStore(
		File incomingFile, @Nullable JobID jobId, BlobKey blobKey, File storageFile,
		Logger log, @Nullable BlobStore blobStore) throws IOException {

	try {
		// first check whether the file already exists
		if (!storageFile.exists()) {
			try {
				// only move the file if it does not yet exist
				Files.move(incomingFile.toPath(), storageFile.toPath());

				incomingFile = null;

			} catch (FileAlreadyExistsException ignored) {
				log.warn("Detected concurrent file modifications. This should only happen if multiple" +
					"BlobServer use the same storage directory.");
				// we cannot be sure at this point whether the file has already been uploaded to the blob
				// store or not. Even if the blobStore might shortly be in an inconsistent state, we have
				// to persist the blob. Otherwise we might not be able to recover the job.
			}

			if (blobStore != null) {
				// only the one moving the incoming file to its final destination is allowed to upload the
				// file to the blob store
				blobStore.put(storageFile, jobId, blobKey);
			}
		} else {
			log.warn("File upload for an existing file with key {} for job {}. This may indicate a duplicate upload or a hash collision. Ignoring newest upload.", blobKey, jobId);
		}
		storageFile = null;
	} finally {
		// we failed to either create the local storage file or to upload it --> try to delete the local file
		// while still having the write lock
		if (storageFile != null && !storageFile.delete() && storageFile.exists()) {
			log.warn("Could not delete the storage file {}.", storageFile);
		}
		if (incomingFile != null && !incomingFile.delete() && incomingFile.exists()) {
			log.warn("Could not delete the staging file {} for blob key {} and job {}.", incomingFile, blobKey, jobId);
		}
	}
}
 

/**
 * Warn.
 *
 * @param logger   the logger
 * @param supplier the supplier
 */
public static void warn(Logger logger, Supplier<Object> supplier) {
    if (logger.isWarnEnabled()) {
        logger.warn(Objects.toString(supplier.get()));
    }
}
 

/**
 * Warn.
 *
 * @param logger   the logger
 * @param format   the format
 * @param supplier the supplier
 */
public static void warn(Logger logger, String format, Supplier<Object> supplier) {
    if (logger.isWarnEnabled()) {
        logger.warn(format, supplier.get());
    }
}