throw new FessSystemException("Failed to access log files: logFilePath=" + logFilePath, e);
            }
        }
        return logFileItems;
    }

    /**
     * Checks if the given filename is a log file.
     *
     * @param name the filename to check
     * @return true if the filename ends with .log or .log.gz, false otherwise
     */
    public static boolean isLogFilename(final String name) {

     * Filters can modify, validate, or enhance queries before they are executed.
     */
    public interface Filter {
        /**
         * Executes the filter logic on the given query.
         *
         * @param context the query context containing search parameters and state
         * @param query the Lucene query to be processed
         * @param boost the boost factor to apply to the query

    public ClassDocExtensionsBuilder(DslDocModel model, GenerationListener listener) {
        this.model = model;
        this.listener = listener;
    }

    /**
     * Builds the extension meta-data for the given class.
     */
    public void build(ClassDoc classDoc) {
        Map<String, ClassExtensionDoc> plugins = new HashMap<String, ClassExtensionDoc>();

import org.gradle.api.GradleException
import org.gradle.api.tasks.CacheableTask
import org.gradle.api.tasks.TaskAction
import java.io.File


/**
 * This [Task][org.gradle.api.Task] checks that the contents of a given accepted API changes files
 * are present in alphabetical order (by type, then member), and throws an exception and reports
 * any changes that are not.
 */
@CacheableTask

        }

        if (isApiPath) {
            sendApiResponse(httpResponse);
        } else {
            httpResponse.sendError(429);
        }
    }

    /**
     * Checks if the given path should be excluded from load control.
     * @param path the request path
     * @return true if the path should be excluded
     */
    protected boolean isExcludedPath(final String path) {

        }
        crawlingConfigCache = CacheBuilder.newBuilder().maximumSize(100).expireAfterWrite(10, TimeUnit.MINUTES).build();
    }

    /**
     * Determines the configuration type from a given config ID.
     * The config type is identified by the first character of the config ID.
     *
     * @param configId the configuration ID to analyze

        return new SearchLogContext(fessConfig, roles, userCode, userId, request, clientIp, virtualHostKey);
    }

    /**
     * Builds a SearchLog from the given parameters and context, then adds it to the queue.
     *
     * @param params The search request parameters.
     * @param requestedTime The time the search was requested.
     * @param queryId The ID of the search query.

            saveError(messages -> messages.addErrorsNotLoadFromServer(GLOBAL, targetUrl));
            return redirect(ErrorAction.class);
        }
    }

    /**
     * Checks if the given URL represents a file system path.
     * Determines if the URL uses file system protocols that may require
     * special handling for content serving.
     *
     * @param url the URL to check

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.it;

import static io.restassured.RestAssured.given;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.startsWith;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;

        if (logger.isDebugEnabled()) {
            logger.debug("WebApiManager added. totalManagers={}", webApiManagers.length);
        }
    }

    /**
     * Gets the appropriate web API manager for the given request.
     *
     * @param request The HTTP servlet request
     * @return The matching web API manager, or null if no match found
     */
    public WebApiManager get(final HttpServletRequest request) {