TaildirSource文件监控原理探究

已于 2023-12-17 17:27:57 修改
阅读量228 收藏
点赞数
分类专栏： 大数据 文章标签： flume
于 2023-12-17 17:25:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Moonlightxiang/article/details/135047242
版权

TaildirSource源码分析及自定义配置

TaildirSource的用途

TaildirSource 是 Apache Flume 中的一个源（Source）类型，用于监视指定目录下的文件，并将文件的内容作为事件发送到 Flume 的通道（Channel）。

TaildirSource 的作用是实时监控指定目录中新增文件的变化，并将这些新增文件的内容发送给 Flume 的后续处理组件，如拦截器、转换器和接收器等。它的主要用途是用于日志收集和实时数据传输场景，特别适用于处理流式数据。

以下是 TaildirSource 的一些关键功能和特点：

  1. 实时监控：TaildirSource 实时监控指定目录中新增文件的变化。当有新文件创建或既有文件发生变化（如追加内容）时，TaildirSource 可以立即检测到并开始读取文件内容。
  2. 多文件支持：TaildirSource 可以同时监视多个文件，而不仅仅是单个文件。您可以通过配置文件路径模式来指定要监视的文件集合，例如通配符或正则表达式。
  3. 文件位置追踪：TaildirSource 会跟踪每个被监视文件的位置，以保证在断电或重启后能够继续从上次读取的位置开始。它会记录文件的偏移量，以便在下次启动时继续读取文件的新增内容。
  4. 可定制化配置：TaildirSource 提供了丰富的配置选项，允许您根据需要进行灵活的配置和调整。您可以设置文件编码、忽略特定文件、添加头部信息等。

版本介绍：示例及本文下述的环境均使用flume:1.7和jdk8

TaildirSource的使用示例

这里笔者提供一个TaildirSource的使用示例，其配置文件如下所示

a1.sources = s1  
a1.channels = c1  
a1.sinks = k1  
  
# describe/configure s1  
a1.sources.s1.type = TAILDIR
a1.sources.s1.channels = c1
a1.sources.s1.channels.skipToEnd = True
# throught JSON format to record the inode, the absolute path and the last position of each tailing file.For to continual work
a1.sources.s1.positionFile = ./taildir/taildir_position.json
# throught Space-separated list file dir which will been tail
a1.sources.s1.filegroups = f1
# define f1 info.
a1.sources.s1.filegroups.f1 = ./test/.*log.*
a1.sources.s1.headers.f1.headerKey1 = value1
# a1.sources.s1.filegroups.f2 = ./test/*.txt.*
# a1.sources.s1.headers.f2.headerKey1 = value2
# a1.sources.s1.headers.f2.headerKey2 = value2-2
# a1.sources.s1.fileHeader = true
  
# use a channel which buffers events in memory  
# type:memory or file is to temporary to save buffer data which is sink using  
a1.channels.c1.type = memory
a1.channels.c1.capacity = 1000
a1.channels.c1.transactionCapacity = 1000
​
a1.sinks.k1.type = logger
a1.sinks.k1.channel = c1

这个简单的示例主要作用是监视工作目录下test目录里面所有包含log的文件，变化事件将会使用loggerSink进行打印输出

效果很简单，我们在test目录下写入一个log文件

$ echo 'hello' > test/1.log
​
# flume端控制台打印
2023-12-16 23:35:50,351 (SinkRunner-PollingRunner-DefaultSinkProcessor) [INFO - org.apache.flume.sink.LoggerSink.process(LoggerSink.java:95)] Event: { headers:{headerKey1=value1} body: 68 65 6C 6C 6F                                  hello }

但是这里flume会有一个问题，就是我们使用mv命令将文件重命名为另外一个log文件后，会重复发送消息，如下所示

$ mv test/1.log test/2.log
​
# flume端控制台重复打印
2023-12-16 23:40:07,614 (SinkRunner-PollingRunner-DefaultSinkProcessor) [INFO - org.apache.flume.sink.LoggerSink.process(LoggerSink.java:95)] Event: { headers:{headerKey1=value1} body: 68 65 6C 6C 6F                                  hello }

为什么会出现这个问题，俗话讲知其然知其所以然，这里就需要我们来扒源码了解其中的缘由！

TaildirSource源码分析

TaildirSource

public class TaildirSource extends AbstractSource implements  
        PollableSource, Configurable {  // 注意点1
  // 缓存监控中文件的inode值
  private List<Long> existingInodes = new CopyOnWriteArrayList<Long>();
  // 注意点2
  @Override
    public synchronized void configure(Context context) {
        logger.info("{} TaildirSource source 开始执行自定义装配过程", getName());
        String fileGroups = context.getString(FILE_GROUPS);
        Preconditions.checkState(fileGroups != null, "Missing param: " + FILE_GROUPS);
​
        filePaths = selectByKeys(context.getSubProperties(FILE_GROUPS_PREFIX),
                fileGroups.split("\s+"));
        Preconditions.checkState(!filePaths.isEmpty(),
                "Mapping for tailing files is empty or invalid: '" + FILE_GROUPS_PREFIX + "'");
​
        String homePath = System.getProperty("user.home").replace('\', '/');
        positionFilePath = context.getString(POSITION_FILE, homePath + DEFAULT_POSITION_FILE);
        Path positionFile = Paths.get(positionFilePath);
        try {
            Files.createDirectories(positionFile.getParent());
        } catch (IOException e) {
            throw new FlumeException("Error creating positionFile parent directories", e);
        }
        headerTable = getTable(context, HEADERS_PREFIX);
        batchSize = context.getInteger(BATCH_SIZE, DEFAULT_BATCH_SIZE);
        skipToEnd = context.getBoolean(SKIP_TO_END, DEFAULT_SKIP_TO_END);
        byteOffsetHeader = context.getBoolean(BYTE_OFFSET_HEADER, DEFAULT_BYTE_OFFSET_HEADER);
        idleTimeout = context.getInteger(IDLE_TIMEOUT, DEFAULT_IDLE_TIMEOUT);
        writePosInterval = context.getInteger(WRITE_POS_INTERVAL, DEFAULT_WRITE_POS_INTERVAL);
        cachePatternMatching = context.getBoolean(CACHE_PATTERN_MATCHING,
                DEFAULT_CACHE_PATTERN_MATCHING);
​
        backoffSleepIncrement = context.getLong(PollableSourceConstants.BACKOFF_SLEEP_INCREMENT,
                PollableSourceConstants.DEFAULT_BACKOFF_SLEEP_INCREMENT);
        maxBackOffSleepInterval = context.getLong(PollableSourceConstants.MAX_BACKOFF_SLEEP,
                PollableSourceConstants.DEFAULT_MAX_BACKOFF_SLEEP);
        fileHeader = context.getBoolean(FILENAME_HEADER,
                DEFAULT_FILE_HEADER);
        fileHeaderKey = context.getString(FILENAME_HEADER_KEY,
                DEFAULT_FILENAME_HEADER_KEY);
        openLevel = context.getBoolean("openLevel");
​
        if (sourceCounter == null) {
            sourceCounter = new SourceCounter(getName());
        }
    }
  
  @Override
    public synchronized void start() {
        logger.info("{} TaildirSource source starting with directory: {}", getName(), filePaths);
        try {
            // 注意点3
            reader = new ReliableTaildirEventReader.Builder()
                    .filePaths(filePaths)
                    .headerTable(headerTable)
                    .positionFilePath(positionFilePath)
                    .skipToEnd(skipToEnd)
                    .addByteOffset(byteOffsetHeader)
                    .cachePatternMatching(cachePatternMatching)
                    .annotateFileName(fileHeader)
                    .fileNameHeader(fileHeaderKey)
                    .openLevel(openLevel)
                    .build();
        } catch (IOException e) {
            throw new FlumeException("Error instantiating ReliableTaildirEventReader", e);
        }
        idleFileChecker = Executors.newSingleThreadScheduledExecutor(
                new ThreadFactoryBuilder().setNameFormat("idleFileChecker").build());
        idleFileChecker.scheduleWithFixedDelay(new idleFileCheckerRunnable(),
                idleTimeout, checkIdleInterval, TimeUnit.MILLISECONDS);
​
        positionWriter = Executors.newSingleThreadScheduledExecutor(
                new ThreadFactoryBuilder().setNameFormat("positionWriter").build());
        positionWriter.scheduleWithFixedDelay(new PositionWriterRunnable(),
                writePosInitDelay, writePosInterval, TimeUnit.MILLISECONDS);
​
        super.start();
        logger.debug("TaildirSource started");
        sourceCounter.start();
    }
  
  @Override
    public Status process() {
        // 轮询状态
        Status status = Status.READY;
        try {
            // 注意点4
            existingInodes.clear();
            existingInodes.addAll(reader.updateTailFiles());
            for (long inode : existingInodes) {
                TailFile tf = reader.getTailFiles().get(inode);
                if (tf.needTail()) {
                    tailFileProcess(tf, true);
                }
            }
            closeTailFiles();
            try {
                TimeUnit.MILLISECONDS.sleep(retryInterval);
            } catch (InterruptedException e) {
                logger.info("Interrupted while sleeping");
            }
        } catch (Throwable t) {
            logger.error("Unable to tail files", t);
            status = Status.BACKOFF;
        }
        return status;
    }
}

TaildirSource我们主要需要关注以上方法，这里笔者逐一介绍：

  • 注意点1：TaildirSource实现了PollableSource接口，具体来说这个接口是代码底层类PollableSourceRunner轮询调用该类中的process方法

    • // PollableSourceRunner子类PollingRunner
@Override
public void run() {
  logger.debug("Polling runner starting. Source:{}", source);
  // 轮询状态是否满足
  while (!shouldStop.get()) {
    counterGroup.incrementAndGet("runner.polls");
    try {
      // 调用source类中的process方法
      if (source.process().equals(PollableSource.Status.BACKOFF)) {
        counterGroup.incrementAndGet("runner.backoffs");
​
        Thread.sleep(Math.min(
          counterGroup.incrementAndGet("runner.backoffs.consecutive")
          * source.getBackOffSleepIncrement(), source.getMaxBackOffSleepInterval()));
      } else {
        counterGroup.set("runner.backoffs.consecutive", 0L);
      }
    }
    // 省略...
  }
​
  logger.debug("Polling runner exiting. Metrics:{}", counterGroup);
}

  • 注意点2：类加载时最先调用的是config方法，其主要作用是解析我们的example.conf配置文件里面参数，并保存到类中的静态变量里

  • 注意点3：config方法调用完毕后，再被调用的是start方法，核心在于构造了一个ReliableTaildirEventReader对象，这个对象我们放在后面分析，接着开启两个单线程的延时调度线程池，分别用来检查文件是否更新和回写断点续传文件positionFile.json

  • 注意点4：existingInodes实际保存的是所有正在监控文件的inode值，这个值同时用来回写断点续传文件线程使用

    • private class PositionWriterRunnable implements Runnable {
  @Override
  public void run() {
    writePosition();
  }
}
​
private void writePosition() {
  File file = new File(positionFilePath);
  FileWriter writer = null;
  try {
    writer = new FileWriter(file);
    // 根据existingInodes回写positionFile
    if (!existingInodes.isEmpty()) {
      String json = toPosInfoJson();
      writer.write(json);
    }
  } catch (Throwable t) {
    logger.error("Failed writing positionFile", t);
  } finally {
    try {
      if (writer != null) writer.close();
    } catch (IOException e) {
      logger.error("Error: " + e.getMessage(), e);
    }
  }
}

    • 这里每次的process方法调用时都会将existingInodes清空，同时调用reader.updateTailFiles()方法重新获取待监控的文件inode，而这块就引出了ReliableTaildirEventReader对象，对于这个对象，我们只需要关心其中一个方法

      • /**
     * Update tailFiles mapping if a new file is created or appends are detected
     * to the existing file.
     */
public List<Long> updateTailFiles(boolean skipToEnd) throws IOException {
  updateTime = System.currentTimeMillis();
  List<Long> updatedInodes = Lists.newArrayList();
  // 这里的TaildirMatcher实际上是我们配置文件中配置的监控组的文件匹配条件
  // 我们配置示例中的 a1.sources.s1.filegroups = f1 就只对应了一个TaildirMatcher
  for (TaildirMatcher taildir : taildirCache) {
    Map<String, String> headers = headerTable.row(taildir.getFileGroup());
​
    for (File f : taildir.getMatchingFiles()) {
      long inode = getInode(f);
      // tailFiles对象保存的是当前正处于监控的文件
      TailFile tf = tailFiles.get(inode);
      if (tf == null || !tf.getPath().equals(f.getAbsolutePath())) {
        long startPos = skipToEnd ? f.length() : 0;
        tf = openFile(f, headers, inode, startPos);
      } else {
        boolean updated = tf.getLastUpdated() < f.lastModified() || tf.getPos() != f.length();
        if (updated) {
          // 注意点5
          if (tf == null || !tf.getPath().equals(f.getAbsolutePath())) {
            tf = openFile(f, headers, inode, tf.getPos());
          }
          if (f.length() < tf.getPos()) {
            logger.info("Pos " + tf.getPos() + " is larger than file size! "
                        + "Restarting from pos 0, file: " + tf.getPath() + ", inode: " + inode);
            tf.updatePos(tf.getPath(), inode, 0);
          }
        }
        tf.setNeedTail(updated);
      }
      tailFiles.put(inode, tf);
      updatedInodes.add(inode);
    }
  }
  return updatedInodes;
}

这块代码中我们着重了解taildir.getMatchingFiles()这个方法，作用是根据我们的监控文件组匹配上需要监控的文件集合，我们点入这个方法进去一探究竟

// 构造方法
TaildirMatcher(String fileGroup, String filePattern, boolean cachePatternMatching) {
  this.fileGroup = fileGroup;
  this.filePattern = filePattern;
  this.cachePatternMatching = cachePatternMatching;
​
  File f = new File(filePattern);
  this.parentDir = f.getParentFile();
  String regex = f.getName();
  final PathMatcher matcher = FS.getPathMatcher("regex:" + regex);
  // 注意点4-1
  this.fileFilter = new DirectoryStream.Filter<Path>() {
    @Override
    public boolean accept(Path entry) throws IOException {
      return matcher.matches(entry.getFileName()) && !Files.isDirectory(entry);
    }
  };
​
  Preconditions.checkState(parentDir.exists(),
                           "Directory does not exist: " + parentDir.getAbsolutePath());
}
​
// 获取待监控的文件
List<File> getMatchingFiles() {
  long now = TimeUnit.SECONDS.toMillis(
    TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis()));
  // 注意点4-2
  long currentParentDirMTime = parentDir.lastModified();
  List<File> result;
​
  if (!cachePatternMatching ||
      lastSeenParentDirMTime < currentParentDirMTime ||
      !(currentParentDirMTime < lastCheckedTime)) {
    lastMatchedFiles = sortByLastModifiedTime(getMatchingFilesNoCache());
    lastSeenParentDirMTime = currentParentDirMTime;
    lastCheckedTime = now;
  }
​
  return lastMatchedFiles;
}
​
// 将所有匹配上文件作为集合返回
private List<File> getMatchingFilesNoCache() {
  List<File> result = Lists.newArrayList();
  try (DirectoryStream<Path> stream = Files.newDirectoryStream(parentDir.toPath(), fileFilter)) {
    for (Path entry : stream) {
      result.add(entry.toFile());
    }
  } catch (IOException e) {
    logger.error("I/O exception occurred while listing parent directory. " +
                 "Files already matched will be returned. " + parentDir.toPath(), e);
  }
  return result;
}
  • 注意点4-2：这里使用了一个过滤器，用于过滤没有被我们filegroups规则匹配上的文件和所有的目录
  • 注意点4-3：这里获取最后修改时间的方法是取当前监控文件的父目录，也就是示例中工程目录下的test目录的最后修改时间
  • 注意点5：继续回到ReliableTaildirEventReader的updateTailFiles方法，在获取到所有待监控的文件后，会判断inode是否在监控文件缓存中，判断成功之后判断待监控的文件的文件路径是否和该缓存中的文件一致，如果不一致，则认为这是一个新监控文件来处理，这也是我们解决当前问题最核心的地方；

解决方案：我们在使用mv命令的时候文件路径肯定会变动，但是文件的inode却不会变动，我们只需将绝对路径的判断去掉就能够达到目的

public List<Long> updateTailFiles(boolean skipToEnd) throws IOException {
  updateTime = System.currentTimeMillis();
  List<Long> updatedInodes = Lists.newArrayList();
​
  for (TaildirMatcher taildir : taildirCache) {
    Map<String, String> headers = headerTable.row(taildir.getFileGroup());
​
    for (File f : taildir.getMatchingFiles()) {
      long inode = getInode(f);
      TailFile tf = tailFiles.get(inode);
      if (tf == null) {
        long startPos = skipToEnd ? f.length() : 0;
        tf = openFile(f, headers, inode, startPos);
      } else {
        boolean updated = tf.getLastUpdated() < f.lastModified() || tf.getPos() != f.length();
        if (updated) {
          // 不再校验变更前后的文件绝对路径是否变更，只校验inode值
          if (tf.getRaf() == null) {
            tf = openFile(f, headers, inode, tf.getPos());
          }
          if (f.length() < tf.getPos()) {
            logger.info("Pos " + tf.getPos() + " is larger than file size! "
                        + "Restarting from pos 0, file: " + tf.getPath() + ", inode: " + inode);
            tf.updatePos(tf.getPath(), inode, 0);
          }
        }
        tf.setNeedTail(updated);
      }
      tailFiles.put(inode, tf);
      updatedInodes.add(inode);
    }
  }
  return updatedInodes;
}

方便起见，笔者将已经编译好的jar包提供出来供大家下载，替换掉lib/目录下的原jar包即可使用

jar包路径: http://yunmiao-bucket.oss-cn-beijing.aliyuncs.com/jar/flume-taildir-source-1.8.0.jar。

taildirSource没法递归监控的思考

通过分析，由于注意点4-1中过滤器只会保留监控路径下的匹配条件的文件，如果我们想要TaildirSource能够递归监控下层目录的文件，那我们可以怎么做呢？

这里笔者提供部分代码，可以供大家参考参考

TaildirMatcher

// 根据配置文件的openLevel作为是否开启递归的开关，默认关闭
private final boolean openLevel;
​
TaildirMatcher(String fileGroup, String filePattern, boolean cachePatternMatching, boolean openLevel) {
  this.fileGroup = fileGroup;
  this.filePattern = filePattern;
  this.cachePatternMatching = cachePatternMatching;
  this.openLevel = openLevel;
​
  File f = new File(filePattern);
  this.parentDir = f.getParentFile();
  String regex = f.getName();
  final PathMatcher matcher = FS.getPathMatcher("regex:" + regex);
  this.fileFilter = new DirectoryStream.Filter<Path>() {
    @Override
    public boolean accept(Path entry) throws IOException {
      // 根据开关判断，如果递归则不过滤子目录
      return openLevel ? Files.isDirectory(entry) || matcher.matches(entry.getFileName())
        : matcher.matches(entry.getFileName()) && !Files.isDirectory(entry);
    }
  };
​
  Preconditions.checkState(parentDir.exists(),
                           "Directory does not exist: " + parentDir.getAbsolutePath());
}
​
List<File> getMatchingFiles() {
  long now = TimeUnit.SECONDS.toMillis(
    TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis()));
  AtomicLong currentParentDirMTime = new AtomicLong(parentDir.lastModified());
  if (openLevel) {
    // 如果递归则向下取所有有过变更时间的文件目录，如果修改的是子目录则修改时间一定大于父目录的修改时间
    try {
      Files.walk(Paths.get(parentDir.toURI())).forEach(path -> {
        if (Files.isDirectory(path)) {
          currentParentDirMTime.getAndSet(Math.max(currentParentDirMTime.get(), path.toFile().lastModified()));
        }
      });
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }
  List<File> result;
  if (!cachePatternMatching ||
      lastSeenParentDirMTime < currentParentDirMTime.get() ||
      !(currentParentDirMTime.get() < lastCheckedTime)) {
    lastMatchedFiles = sortByLastModifiedTime(getMatchingFilesNoCache());
    lastSeenParentDirMTime = currentParentDirMTime.get();
    lastCheckedTime = now;
  }
​
  return lastMatchedFiles;
}
​
private List<File> getMatchingFilesNoCache() {
  List<File> result = Lists.newArrayList();
  try (DirectoryStream<Path> stream = Files.newDirectoryStream(parentDir.toPath(), fileFilter)) {
    for (Path entry : stream) {
      if (Files.isDirectory(entry) && openLevel) {
        // 如果是目录则递归匹配该目录下的文件
        addDirectoryFile(result, entry);
      } else {
        result.add(entry.toFile());
      }
    }
  } catch (IOException e) {
    logger.error("I/O exception occurred while listing parent directory. " +
                 "Files already matched will be returned. " + parentDir.toPath(), e);
  }
  return result;
}
​
private void addDirectoryFile(List<File> result, Path path) {
  try {
    Files.walk(path).forEach(sonPath -> {
      try {
        // 要注意Files.walk()方法会在子目录中放入当前目录路径，这里需要甄别一下
        if (Files.isDirectory(sonPath) && !Files.isSameFile(path, sonPath)) {
          addDirectoryFile(result, sonPath);
        } else if (!Files.isDirectory(sonPath)) {
          // 如果还有子目录则继续递归
          result.add(sonPath.toFile());
        }
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
    });
  } catch (IOException e) {
    throw new RuntimeException(e);
  }
}

代码调整完毕，打包上传到lib目录下，我们通过配置文件对openLevel参数进行配置后，即可对监控路径下目录递归监控文件变化 （这一块已经放入上面提供的jar包中）

a1.sources.s1.openLevel = true

附上源码地址：https://github.com/moonlight2893267956/–flume1.7.git

雲Miao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
十一：Flume常用Source配置-taildir-source
weizhonggui的博客
01-27 1858
一：Flume概述： Apache Flume is a distributed, reliable, and available system for efficiently collecting, aggregating and moving large amounts of log data from many different sources to a centralized data ...
03_Flume之TaildirSource参数解析
weixin_40727028的博客
04-15 606
TaildirSource是一种常用的数据源类型，可以实时监控指定目录下新增或修改的文件，并将其发送到Flume的Channel中供后续处理或转发。TaildirSource最大的优点在于兼容多种格式和编码的日志文件，非常适合用于实时采集和分析系统日志和应用日志等场景。
flume学习05---Taildir Source
chbxw
03-21 1490
Taildir SourceNote This source is provided as a preview feature. It does not work on Windows.监视指定的一些文件， 将近实时的tail 这些文件获取这些文件的新追加的行， 如果这些行正在写入的话， 它会等待写入操作完成。 这个source是可靠的 and will not miss data even w
Flume中的TaildirSource
iie_libi的博客
04-07 2925
Flume中的TaildirSource   关键字：Flume、TaildirSource、TailFile、Source 在通过Flume收集日志的业务场景中，一般都会遇到下面的情况，在日志收集服务器的某个目录下，会按照一段时间生成一个日志文件，并且日志会不断的追加到这个文件中，比如，每小时一个命名规则为log_20151015_10.log的日志文件，所有10点产生的日志都会追加到这个
TailDirSource
手提青灯觅佳人的博客
03-29 633
特点： 1、TailDirSource以接近实时的所读监控文件中写入的新行 2、TailDirSource检测文件中写入的新行，并且将每个文件tail的位置记录在一个JSON的文件中 3、即使agent挂了，重启后，source从上次记录的位置继续执行tail操作 4、用户可以 修改Position文件的参数，来改变source继续读取的位置，如果postion文件丢失了，那么sourc...
02-taildir source
weixin_46787788的博客
07-14 103
------------------------------------taildir source ------------------------------------ 1、内容查询 ==================================== [root@singlelucky flume]# head -10000 prolog.log>tail01/prologhead10000.log [root@singlelucky flume]# ls tail01 prologhea
Flume-1.7.0之 Taildir Source & logger Sink
shufangreal的博客
06-20 402
Flume-1.7.0之TAILDIR Source Taildir Source简介 Taildir Source可以监控指定文件，而且一旦有数据追加到每个文件，这种source都能实时的跟踪并发现文件的数据追加，这个source会等待数据写完，然后尝试接着读取这些文件。 Taildir Source是可靠的，它不会丢失数据即使监控的文件进行滚动并产生新数据，因为它会周期性的将每个文件的每次读取的最后的position位置以json的格式写入到文件，就算flume停止或者down掉，重启之后还是从每个文件
flume-taildir-source-1.9.0.jar
05-24
flume断点续传覆盖jar，使用组件flume-taildir-source-1.9.0覆盖flume/bin目录下的jar即可
xmen-taildir-source:在官方flume-taildir-source的基础上修改和优化，适用于以rsync、scp等同步日志导致同一文件inode会变化的场景
05-08
xmen-taildir-source在官方flume-taildir-source的基础上修改和优化，适用于以rsync、scp等同步日志导致同一文件iNode会变化的场景主要修改以下几点：修改使用文件全路径替换inode作为TailFiles的key，避免同一文件...
flume1.7的taildir支持windows.rar
06-10
flume1.7的taildir支持windows,flume1.7的taildir支持windows
离线数仓串讲文字版.doc
05-08
我们选择使用 taildirSource，因为它支持断点续传和多目录，非常适合我们的场景。 但是，我们也发现了 flume 的一个问题，是由于它读取数据跟保存 offset 不是一个原子性的操作。这可能出现数据采集到了还没来得及...
kafka flume 整合
06-11
flume skin 直连kafka，kafka安装过程和flume配置样例，下载下来即可安装一个生产可用的日志采集系统
flume--tailDir Source组件
weixin_43191162的博客
05-25 252
简介 假如当下有个需求 要采集服务器的/root/logs/test1/a.log文件中的内容以及/root/logs/test2文件夹中的所有的*.log*文件的内容,该如何实现(同时采集文件以及文件夹的内容) 在flume1.6以及之前,我们在配置文件中只要设置两个source即可,一个spooldir source和一个exec source,在flume1.6之后,考虑到这种情况,flume的开发人员新增了一种全新的组件tailDir Source. 该组件的作用就是可以只指定一个sourc
flume的TaildirSource介绍及升级改造
小强签名设计 的博客
06-09 4442
flume 1.7.0推出了taildirSource组件。tail监控目录下匹配上正则表达式的的所有文件，实现断点续传。 但是我后来发现cdh版的flume-1.6.0也已经有这个组件了，而官方的Apache版的apache-flume-1.6.0-bin却没有这个组件。并且Apache版的flume1.7.0比cdh版的flume1.6.0的org.apache.flume.source.t
flume使用Taildir Source采集文件夹数据到hdfs
hyj
04-21 2172
一、说明 1、此方式适合生产环境； 2、Taildir Source 是Apache flume1.7新推出的，但是CDH Flume1.6做了集成； 3、Taildir Source是高可靠（reliable）的source，他会实时的将文件偏移量写到json文件中并保存到磁盘。下次重启Flume时会读取Json文件获取文件O偏移量，然后从之前的位置读取数据，保证数据零丢失； 4、tai...
flume使用（四）：taildirSource多文件监控实时采集
热门推荐
maoyuanming0806的博客
02-27 1万+
flume使用（一）：入门demo flume使用（二）：采集远程日志数据到MySql数据库 ...
【Flume】TailDirSource源码理解
weixin_33862993的博客
12-14 863
TaildirSource类图如下（列出主要类） TailDirSource类TailDirSource继承了AbstractSource类，而AbstractSource类中channelProcessor属性负责将Source中的Event提交给Channel组件TailDirSource类通过配置参数匹配日志文件，获取日志文件更新内容并且将已经读取的偏移量记录到特定的文件当中(positi...
Flume -Taildir Source
qq1010234991的博客
03-13 415
Taildir Source可实时监控一批文件，并记录每个文件最新消费位置，agent进程重启后不会重复消费的问题 , 使用时建议1.8版本flume(1.8b版本解决了Taildir source的bug) 功能：支持目录变化的文件，如果遇到中断，并以json数据记录目录下的每个文件的收集状态 重点： a1.sources.r1.type = TAILDIR a1.sources.r1.c...
flume配置----a1.sources.r1.positionFile=xxxx.json
最新发布
limenghao2002的博客
06-13 384
flume中positionFile的配置
flume的taildirsource怎么配置
04-07
可以在 flume.conf 文件中配置 taildirsource，具体配置方法可以参考以下示例： ``` agent.sources = taildirsource agent.sources.taildirsource.type = TAILDIR agent.sources.taildirsource.positionFile = /var...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值