if (logger.isDebugEnabled()) {
            logger.debug("[{}] {}", errorCode, stacktraceString.get().replace("\n", "\\n"));
        } else {
            logger.warn("[{}] {}", errorCode, cause.getMessage());
        }
        return "error_code:" + errorCode;
    }

            t.printStackTrace(pw);
            pw.flush();
            return systemHelper.abbreviateLongText(sw.toString());
        } catch (final IOException e) {
            logger.warn("Failed to print the stack trace {}", t.getMessage(), e);
        }
        return StringUtil.EMPTY;
    }

                if (paramValue == null) {
                    return defaultValue;
                }

                return convertObj(paramValue, clazz);
            } catch (final Exception e) {
                logger.warn("Could not load init parameters: " + key + " from " + initParamMap, e);
            }
        }
        return defaultValue;
    }

    @SuppressWarnings("unchecked")

        } finally {
            if (dfos != null && !dfos.isInMemory()) {
                final File file = dfos.getFile();
                if (!file.delete()) {
                    logger.warn("Failed to delete {}.", file.getAbsolutePath());
                }
            }
        }

    }

    protected String getMimeType(final DeferredFileOutputStream out) throws IOException {

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">

	<Properties>
		<Property name="domain.name" value="${sys:fess.log.name:-fess}" />
		<Property name="log.level" value="${sys:fess.log.level:-debug}" />
		<Property name="root.log.level" value="${sys:fess.log.level:-info}" />
		<Property name="log.pattern" value="%d [%t] %-5p %msg%n" />
		<Property name="log.file.basedir" value="${sys:fess.log.path:-target/logs}" />

        if (bulkRequestBuilder != null) {
            final BulkResponse response = bulkRequestBuilder.execute().actionGet(requestTimeout);
            if (response.hasFailures()) {
                logger.warn("Failed to update scores: {}", response.buildFailureMessage());
            }
            bulkRequestBuilder = null;
        }
    }

    public int getPriority() {
        return priority;
    }

                logger.warn("Failed to access to Web API.", e);
                message = e.getMessage();
            } else {
                final String errorCode = UUID.randomUUID().toString();
                message = "[" + errorCode + "] Failed to access to Web API.";
                logger.warn(message, e);
            }
            response.sendError(e.getStatusCode(), message);

        forEachJavaProcess { pid, _ ->
            suspiciousDaemons.forEach { (suite, pids) ->
                if (pid in pids && pid !in alreadyKilled) {
                    logger.warn("A process was created in $suite but wasn't shutdown properly. Killing PID $pid")
                    KillLeakingJavaProcesses.pkill(pid)
                }
            }
        }
    }

    private

        try {
            userService.changePassword(username, form.password);
            saveInfo(messages -> messages.addSuccessChangedPassword(GLOBAL));
        } catch (final Exception e) {
            logger.warn("Failed to change newPassword for {}", username, e);
            throwValidationError(messages -> messages.addErrorsFailedToChangePassword(GLOBAL), toIndexPage);
        }

                + artifact.getScope() + " wins)");

        // TODO better way than static? this might hide messages in a reactor
        if (!ignoredArtifacts.contains(artifact)) {
            logger.warn("\n\tArtifact " + artifact + " retains local artifactScope '" + artifact.getScope()
                    + "' overriding broader artifactScope '" + ignoredScope + "'\n"