return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
            } catch (final DateTimeParseException e) {
                logger.debug("Invalid date format: {}", value, e);
            }
        }
        return DfTypeUtil.toLocalDateTime(value);
    }

                    if (values.length == 2) {
                        mimetypeMap.put(values[0], values[1]);
                    }
                }));
        if (logger.isDebugEnabled()) {
            logger.debug("loaded filetype: {}", mimetypeMap);
        }
    }

    public void add(final String mimetype, final String filetype) {
        mimetypeMap.put(mimetype, filetype);
    }

    public QueryBuilder execute(final QueryContext context, final Query query, final float boost) {
        if (query instanceof final TermRangeQuery termRangeQuery) {
            if (logger.isDebugEnabled()) {
                logger.debug("{}:{}", query, boost);
            }
            return convertTermRangeQuery(context, termRangeQuery, boost);
        }

<?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 (name == null || dataStore == null) {
            throw new IllegalArgumentException("name or dataStore is null.");
        }
        if (logger.isDebugEnabled()) {
            logger.debug("Loaded {}", name);
        }
        dataStoreMap.put(name.toLowerCase(Locale.ROOT), dataStore);
        dataStoreMap.put(dataStore.getClass().getSimpleName().toLowerCase(Locale.ROOT), dataStore);
    }

            return stacktraceString.get();
        }

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

    protected Cache<String, List<String>> cache;

    protected FessConfig fessConfig;

    @PostConstruct
    public void init() {
        if (logger.isDebugEnabled()) {
            logger.debug("Initialize {}", this.getClass().getSimpleName());
        }
        fessConfig = ComponentUtil.getFessConfig();
        cache = CacheBuilder.newBuilder().maximumSize(fessConfig.getSuggestPopularWordCacheSizeAsInteger().longValue())

                    if (tempFile.exists() && !tempFile.delete()) {
                        logger.warn("Failed to delete {}.", tempFile.getAbsolutePath());
                    }
                    logger.debug("Failed to copy {}", filename, e);
                    throwValidationError(messages -> messages.addErrorsFailedToInstallPlugin(GLOBAL, filename), this::asListHtml);
                }
                new Thread(() -> {

    public QueryBuilder execute(final QueryContext context, final Query query, final float boost) {
        if (query instanceof final TermQuery termQuery) {
            if (logger.isDebugEnabled()) {
                logger.debug("{}:{}", query, boost);
            }
            return convertTermQuery(context, termQuery, boost);
        }

    }

    public synchronized void putToInfoMap(final String key, final String value) {
        if (infoMap == null) {
            infoMap = Collections.synchronizedMap(new LinkedHashMap<>());
        }
        logger.debug("infoMap: {}={} => {}", key, value, infoMap);
        infoMap.put(key, value);
    }

    public void updateParams(final String sessionId, final String name, final int dayForCleanup) {