一、
在使用flume采集日志时,可以通过flume进行监控某一个文件把生产的数据传输给指定的sink,但是如果某段时间flume所在机器宕机了,那么当重新启动后,在去监控时,会导致有数据丢失,不是接着上一次的数据继续进行读取,因此针对这种情况时可能需要我们自定义一个source,记录偏移量,每次都是接着上次继续读
二、
下面就是具体实现的代码
再写代码时可以参照官方给的source的源码进行编写,比如ExecSource
flume的生命周期: 先执行构造器,再执行 config方法 --> start方法 --> processor.process–> stop
读取配置文件:(配置读取的文件内容:读取那个文件,编码及、偏移量写到那个文件,多长时间检测一下文件是否有新内容
import org.apache.commons.io.FileUtils;
import org.apache.flume.Context;
import org.apache.flume.EventDrivenSource;
import org.apache.flume.channel.ChannelProcessor;
import org.apache.flume.conf.Configurable;
import org.apache.flume.event.EventBuilder;
import org.apache.flume.source.AbstractSource;
import org.apache.flume.source.ExecSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.charset.Charset;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
//自定义source,记录偏移量
/*
flume的生命周期: 先执行构造器,再执行 config方法 -> start方法-》 processor.process
1、读取配置文件:(配置读取的文件内容:读取那个文件,编码及、偏移量写到那个文件,多长时间检测一下文件是否有新内容
)
*/
public class TailFileSource extends AbstractSource implements EventDrivenSource, Configurable {
//记录日志
private static final Logger logger = LoggerFactory.getLogger(ExecSource.class);
private String filePath;
private String charset;
private String positionFile;
private long interval;
private ExecutorService executor;
private FileRunnable fileRunnable;
//读取配置文件(flume在执行一次job时定义的配置文件)
@Override
public void configure(Context context) {
//(如果在flume的job的配置文件中不修改,就是用这些默认的配置)
//读取哪个文件
filePath = context.getString("filePath");
//默认使用utf-8
charset = context.getString("charset","UTF-8");
//把偏移量写到哪
positionFile = context.getString("positionFile");
//指定默认每个一秒 去查看一次是否有新的内容
interval = context.getLong("interval", 1000L);
}
/*
*1、创建一个线程来监听一个文件
*/
@Override
public synchronized void start() {
//创建一个单线程的线程池
executor = Executors.newSingleThreadExecutor();
//获取一个ChannelProcessor
final ChannelProcessor channelProcessor = getChannelProcessor();
fileRunnable = new FileRunnable(filePath,charset,positionFile,interval,channelProcessor);
//提交到线程池中
executor.submit(fileRunnable);
//调用父类的方法
super.start();
}
@Override
public synchronized void stop() {
//停止
fileRunnable.setFlag(false);
//停止线程池
executor.shutdown();
while (!executor.isTerminated()){
logger.debug("Waiting for filer exec executor service to stop");
try {
//等500秒在停
executor.awaitTermination(500, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
logger.debug("InterutedExecption while waiting for exec executor service" +
" to stop . Just exiting");
e.printStackTrace();
}
}
super.stop();
}
private static class FileRunnable implements Runnable{
private String charset;
private long interval;
private long offset = 0L;
private ChannelProcessor channelProcessor;
private RandomAccessFile raf;
private boolean flag = true;
private File posFile;
/*
先于run方法执行,构造器只执行一次
先看看有没有偏移量,如果有就接着读,如果没有就从头开始读
*/
public FileRunnable(String filePath, String charset, String positionFile, long interval, ChannelProcessor channelProcessor) {
this.charset = charset;
this.interval = interval;
this.channelProcessor = channelProcessor;
//读取偏移量, 在postionFile文件
posFile = new File(positionFile);
if(!posFile.exists()){
//如果不存在就创建一个文件
try {
posFile.createNewFile();
} catch (IOException e) {
e.printStackTrace();
logger.error("创建保存偏移量的文件失败:",e);
}
}
try {
//读取文件的偏移量
String offsetString = FileUtils.readFileToString(posFile);
//以前读取过
if(!offsetString.isEmpty()&&null!=offsetString&&!"".equals(offsetString)){
//把偏移量穿换成long类型
offset = Long.parseLong(offsetString);
}
//按照指定的偏移量读取数据
raf = new RandomAccessFile(filePath,"r");
//按照指定的偏移量读取
raf.seek(offset);
} catch (IOException e) {
logger.error("读取保存偏移量文件时发生错误",e);
e.printStackTrace();
}
}
@Override
public void run() {
while (flag){
//读取文件中的新数据
try {
String line = raf.readLine();
if(line!=null){
//有数据进行处理,避免出现乱码
line = new String(line.getBytes("iso8859-1"),charset);
channelProcessor.processEvent(EventBuilder.withBody(line.getBytes()));
//获取偏移量,更新偏移量
offset = raf.getFilePointer();
//将偏移量写入到位置文件中
FileUtils.writeStringToFile(posFile,offset+"");
}else{
//没读到谁一会儿
Thread.sleep(interval);
}
//发给channle
//更新偏移量
//每个时间间隔读取一次
} catch (InterruptedException e) {
e.printStackTrace();
logger.error("read filethread Interrupted",e);
}catch (IOException e){
logger.error("read log file error",e);
}
}
}
public void setFlag(boolean flag) {
this.flag = flag;
}
}
}
三、
编写完以后,打成jar包,放到flume的lib下,conf的配置如下
#bin/flume-ng agent -n a1 -f /home/hadoop/a1.conf -c conf -Dflume.root.logger=INFO,console
#定义agent名, source、channel、sink的名称
a1.sources = r1
a1.channels = c1
a1.sinks = k1
#具体定义source,这里的type是自定义的source的类的全路径
a1.sources.r1.type = com.yt.flume.source.TailFileSource
#这里的参数名都和自定义类的参数一直
#读取哪个文件
a1.sources.r1.filePath = /didi/data/logs/access.txt
#偏移量保存的文件
a1.sources.r1.positionFile = /didi/data/logs/posi.txt
#时间间隔,每隔多久读取一次
a1.sources.r1.interval = 2000
#编码
a1.sources.r1.charset = UTF-8
#具体定义channel
a1.channels.c1.type = memory
a1.channels.c1.capacity = 1000
a1.channels.c1.transactionCapacity = 100
#具体定义sink
a1.sinks.k1.type = file_roll
a1.sinks.k1.sink.directory = /didi/data/logs/sinks
#组装source、channel、sink
a1.sources.r1.channels = c1
a1.sinks.k1.channel = c1
执行:
./bin/flume-ng
agent --conf ./conf/ --name a1 --conf-file
./job/tailFile.conf
-Dflume.root.logger==INFO,console