try (Stream<Path> stream = Files.list(logDirPath)) {
                stream.filter(entry -> isLogFilename(entry.getFileName().toString())).sorted().forEach(filePath -> {
                    final Map<String, Object> map = new HashMap<>();
                    final String name = filePath.getFileName().toString();
                    map.put("id", Base64.getUrlEncoder().encodeToString(name.getBytes(StandardCharsets.UTF_8)));

        }
        try {
            final Path filePath = Paths.get(path).normalize();
            final String normalizedPath = filePath.toString();
            if (normalizedPath.contains("..")) {
                throw new IllegalArgumentException("Invalid file path");
            }
            final File file = filePath.toFile();
            final String canonicalPath = file.getCanonicalPath();

        @DisplayName("Should handle partial data buffer correctly")
        void testPartialDataBuffer() {
            byte[] fullData = new byte[200];
            new Random().nextBytes(fullData);

            int offset = 50;
            int length = 100;
            request.setData(fullData, offset, length);

            byte[] buffer = new byte[512];
            int bytesWritten = request.writeBytesWireFormat(buffer, 0);

            throw new CrawlerSystemException("Storage URI is empty. Please provide a valid storage URI (storage://...).");
        }

        String filePath = uri;
        if (!filePath.startsWith("storage:")) {
            filePath = "storage://" + filePath;
        }

        return filePath;
    }

    /**
     * Returns the character set used for content encoding.
     * @return the charset
     */

            if (settings.getAsBoolean("dynamic_reload", false)) {
                final String filePath = settings.get("synonyms_path", null);

                if (filePath == null) {
                    throw new IllegalArgumentException("synonyms_path is not found.");
                }

                final Path path = env.configDir().resolve(filePath);

                try {
                    final File file = path.toFile();

     */

    @Override
    public String getName() {
        final String urlpath = getURLPath();
        final String shr = getShare();
        if (urlpath.length() > 1) {
            int i = urlpath.length() - 2;
            while (urlpath.charAt(i) != '/') {
                i--;
            }
            return urlpath.substring(i + 1);
        }
        if (shr != null) {
            return shr + '/';

                stream.filter(entry -> isLogFilename(entry.getFileName().toString())).forEach(filePath -> {
                    final ZipEntry entry = new ZipEntry(id + "/" + filePath.getFileName().toString());
                    try {
                        zos.putNextEntry(entry);
                        final long len = Files.copy(filePath, zos);
                        if (logger.isDebugEnabled()) {

      url: HttpUrl,
      path: String,
    ): Boolean {
      val urlPath = url.encodedPath

      if (urlPath == path) {
        return true // As in '/foo' matching '/foo'.
      }

      if (urlPath.startsWith(path)) {
        if (path.endsWith("/")) return true // As in '/' matching '/foo'.
        if (urlPath[path.length] == '/') return true // As in '/foo' matching '/foo/bar'.
      }

                    final String filePath = fileMap.get("path") != null ? fileMap.get("path").toString() : "unknown";
                    final String fileTimestamp = fileMap.get("@timestamp") != null ? fileMap.get("@timestamp").toString() : "unknown";
                    logger.warn("Failed to load dictionary file: path={}, timestamp={}, error={}", filePath, fileTimestamp, e.getMessage(),
                            e);

        return sb.toString();
      }
    },
    // It really seems like this should be faster than TO_BYTE_ARRAY_NEW_STRING.  But it just isn't
    // my best guess is that the jdk authors have spent more time optimizing that callpath than this
    // one. (StringCoding$StringDecoder vs. StreamDecoder).  StringCoding has a ton of special cases
    // theoretically we could duplicate all that logic here to try to beat 'new String' or at least
    // come close.