logger.warn("The metadata {} {}{}", metadata, errorType, msg, exception);
        } else {
            logger.warn("The metadata {} {}{}", metadata, errorType, msg);
        }
    }

    @Override
    public void artifactDescriptorInvalid(RepositoryEvent event) {
        // The exception stack trace is not really interesting here
        logger.warn(

            log.warn("Response buffer too small: {} < {}", buffer.length, expectedSize);
            throw new SmbException("Response buffer too small: " + buffer.length + " < " + expectedSize);
        }

        if (buffer.length > maxSize) {
            failedValidations.incrementAndGet();
            bufferOverflowsPrevented.incrementAndGet();

                if (executeCommand(thumbnailId, cmdList) != 0) {
                    logger.warn("Failed to execute command for thumbnail ID: {}", thumbnailId);
                    try {
                        Files.deleteIfExists(outputPath2);
                    } catch (final IOException e) {
                        logger.warn("Failed to delete output file: {}", outputFile.getAbsolutePath(), e);
                    }

        }
    }

    /**
     * Outputs WARN information.
     *
     * @param message
     *            Message
     * @param throwable
     *            Exception
     */
    public void warn(final Object message, final Throwable throwable) {
        log.warn(toString(message), throwable);
    }

    /**
     * Outputs WARN information.
     *
     * @param message

                        logger.warn("  " + unsafeGoal.getId());
                    }
                } else {
                    logger.warn("The following plugins are not marked as thread-safe in " + project.getName() + ":");
                    for (Plugin unsafePlugin : unsafePlugins) {
                        logger.warn("  " + unsafePlugin.getId());
                    }
                    logger.warn("");

    /** 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) {

}

// FilterTargetArns returns a slice of distinct target arns in the config
func (c Config) FilterTargetArns(obj ObjectOpts) []string {
	var arns []string

	tgtsMap := make(map[string]struct{})
	rules := c.FilterActionableRules(obj)
	for _, rule := range rules {
		if rule.Status == Disabled {
			continue
		}
		if c.RoleArn != "" {
			arns = append(arns, c.RoleArn) // use legacy RoleArn if present
			return arns

    /**
     * @return true if the <b>warn</b> error level is enabled
     */
    boolean isWarnEnabled();

    /**
     * Send a message to the user in the <b>warn</b> error level.
     *
     * @param content
     */
    void warn(CharSequence content);

    /**
     * Send a message (and accompanying exception) to the user in the <b>warn</b> error level.<br>

        if (filesToDelete.isEmpty()) {
            LOGGER.warn("No files need to be deleted.");
            return;
        }

        LOGGER.warn("The following changelog files {} be deleted:", dryRun ? "can" : "will");
        LOGGER.warn("");
        filesToDelete.forEach(file -> LOGGER.warn("\t{}", rootDir.relativize(file.toPath())));

        if (dryRun == false) {

        final LogEvent event = createLogEvent(Level.WARN, "org.codelibs.fess.test", "test warn message");
        warnAppender.append(event);

        final List<LogNotificationEvent> events = ComponentUtil.getLogNotificationHelper().drainAll();
        assertEquals(1, events.size());
        assertEquals("WARN", events.get(0).getLevel());