for (final Ingester ingester : ingestFactory.getIngesters()) {
            try {
                target = ingester.process(target, paramMap);
            } catch (final Exception e) {
                logger.warn("[{}] Failed to process ingester", ingester.getClass().getSimpleName(), e);
            }
        }
        return target;
    }

    /**
     * Commits any remaining documents in the cache to the index.

                }
            }
        } catch (final SocketTimeoutException ste) {
            log.trace("Socket timeout", ste);
        } catch (final Exception ex) {
            log.warn("Uncaught exception in NameServiceClient", ex);
        } finally {
            tryClose();
        }
    }

        final CrawlingInfo crawlingInfo = getCrawlingInfoService().getLast(sessionId);
        if (crawlingInfo == null) {
            logger.warn("No crawling session: {}", sessionId);
            return;
        }
        if (StringUtil.isNotBlank(name)) {
            crawlingInfo.setName(name);
        } else {

            log.debug("Transient SMB error: {} (attempt {}/{})", getMessage(), attemptNumber, retryPolicy.getMaxAttempts());
        } else if (isRetryable()) {
            log.warn("Retryable SMB error: {} in operation '{}' (attempt {}/{})", getMessage(), operationName, attemptNumber,
                    retryPolicy.getMaxAttempts());
        } else {

            }

            final String id = deriveId(values);
            final boolean excluded = getLinuxExclusionList().contains(id);

            if (excluded) {
                LOGGER.warn("Linux OS id [{}] is present in the Docker exclude list. Tasks requiring Docker will be disabled.", id);
            }

            return excluded;
        }

        return false;
    }

                    .selectByPK(scheduledJob.getId())
                    .ifPresent(e -> params.put(Constants.SCHEDULED_JOB, e))
                    .orElse(() -> {
                        logger.warn("Job {} is not found.", scheduledJob.getId());
                    });
            return params;
        };
        findJobByUniqueOf(LaJobUnique.of(id)).ifPresent(job -> {
            if (!job.isUnscheduled()) {

            try (InputStream inputStream = form.stopwordsFile.getInputStream()) {
                file.update(inputStream);
            } catch (final IOException e) {
                logger.warn("Failed to process a request.", e);
                throwValidationError(messages -> messages.addErrorsFailedToUploadStopwordsFile(GLOBAL),
                        () -> redirectWith(getClass(), moreUrl("uploadpage/" + form.dictId)));

        }
    }

    @Override
    public void mojoSkipped(ExecutionEvent event) {
        if (logger.isWarnEnabled()) {
            init();
            logger.warn(
                    "Goal '{}' requires online mode for execution but Maven is currently offline, skipping",
                    event.getMojoExecution().getGoal());
        }
    }

    /**

            // mimic plexus: discard any strings containing nested XML
            while (parser.getEventType() == XmlPullParser.START_TAG) {
                final String pos = parser.getPositionDescription();
                Logs.warn("Expected TEXT, not XML: {}", pos, new Throwable());
                parser.skipSubTree();
                parser.nextTag();
            }
            return "";
        }

                    // ensure connected
                    trans.ensureConnected();
                    refServerName = trans.getRemoteHostName();
                } catch (final IOException e) {
                    log.warn("Failed to connect to domain controller", e);
                }
                dr = getReferral(tf, trans, domain, domain, refServerName, root, null);
            }
        }

        if (log.isTraceEnabled()) {