搜狗搜索日志传输与分析

日志在四台不同主机上模拟实际生产环境，hive并不适合在线服务，因为调用mapreduce任务比较慢。

出现的坑

1.如何把gbk转换成utf-8，解决方法是在flume配置文件中inputcharset=gbk，outputcharset=utf-8

2.kafka partition ：为了均衡数据的压力，会将一个topic分为多个partition，分给不同的机器处理。consumer里面可以多线程消费topic，线程同时运行的最大数量与partition数量相同

3.识别新文件的产生：flume的source识别 SpoolDirectorySource

4.流程的自动化：文件的产生，flume读取新文件，flume到kafka（kafkasink），kafka到hdfs，hdfs中的文件load到hive中，以上则几个过程都是自动化执行的。

5.flume 的event分为header和body，将文件名放到header中，保留文件名的日期信息。

6.在kafka中，一个topic的数据能否均衡传输到不同的partition是不一定的。

a.传到kafka的消息没有key的时候，kafaka会自己算出一个key，而这个key的更新时间默认是10分钟，所以在数据量比较小的时候，数据可能都传到同一个partition中去了，没有达到想要的负载均衡的效果。

b.在有key的时候,partitioner就会根据key来决定分到哪个partition.

hdfs中的数据自动化load数据到hive中,hive有分区,看最后一部分.

flume-->kafka:三种信息 topic key body,key就是文件名信息,在flume中配置的,可以保证kafka的partition负载均衡

1.项目框架

　　实现了flume->Kafka->HDFS->Hive，后面还没有实现。

2.用户搜索日志的数据结构

访问时间 用户ID [查询词] 该URL在返回结果中的排名 用户点击的顺序号 用户点击的URL

3.功能

      topN搜索词查询

　　日/周/月topN搜索词详情查询

　　搜索量topN的用户个人搜索词查询

4.模块承担角色及开发功能

 　　Flume：日志收集，从源端机器磁盘文件，将数据传入Kafka。开发功能：Flume到kafka数据录入

　　 Kafka：日志传输及加载，将数据加载到HDFS。开发功能：Kafka HDFS consumer。

　　 HDFS：数据存储，存储Kafka传入的数据。

　　 Hive：日/周/月topN搜索词查询及搜索词详情查询，开发功能：模块查询需求，制定partition及bucket定义方式及源数据存储方法，保证查询高性能。

5.表结构及查询语句

describe sogouqueryfish;
time varchar(8)
userid varchar(30)
query string
pagerank int
clickrank int
site string

搜索量topN的用户个人搜索词查询
– select sf.userid, sf.query, count(sf.query) sco, tt.co from (select userid, count(3) co from sogouqueryfish group by userid order by co desc) as tt join sogouqueryfish as sf on tt.userid = sf.userid group by sf.userid,sf.query,tt.co order by tt.co desc,sco desc limit 10;

选出查询数量最多的查询词及次数 top10

select query，count(query) from sogouqueryfish group by query order by count(query) desc limit 10;

6.产生日志文件脚本

每隔五秒钟产生一个文件，给每个文件加上一个时间戳，产生的文件放到generated目录。

7.文件到Kafka

7.1Flume配置文件

 7.2读取自动产生的文件配置项SpoolDirectorySource

 

 7.3 编解码问题：日志文件中含有中文字符，如果不处理的话会出现乱码
　　– 读入：InputCharset
　　　　• ReliableSpoolingFileEventReader

　　

　　• SpoolDirectorySourceConfigurationConstants
　　　　– public static final String INPUT_CHARSET = "inputCharset"; 
　　　　– public static final String DEFAULT_INPUT_CHARSET = "UTF-8";

源代码给出了设置编码的参数是"inputCharset"，并且默认的编码方式是"UTF-8"，所以我们在Flume的配置文件中手动设置输入编码为GBK

　　 

输出部分

 – 输出
• 需要：utf-8

flume配置项设置输出为UTF-8

7.4文件名转为目录

 文件名是类似于temp20161221.txt的，要求做到文件名信息可以传递到Kafka并由其依据名称生成目标目录2016/12/21这种按年月日分级的目录形式。

解决办法是利用Flume的event中的header传递文件名信息

• SpoolDirectorySource源代码

• ReliableSpoolingFileEventReader

对应flume中的配置为

– Flume event中的header将形如
• key=/a/b/c
– fileHeaderKey默认值为file，为何改为key
• 与下面将提到的Kafka sink有关

8.Kafka到HDFS

主要分为三步：

• 主循环中提取数据
• 依据消息key将数据存入相应位置，文件传输完毕后重命名为.Done结尾,这里在转换文件名为目录的时候并不是像前面所说的key=/a/b/c，而是字符串处理成为了/a/b/c形式，key好像还是abc的形式，看代码就知道了。
• 独立线程完成文件刷写

完整代码：

package cn.chinahadoop.kafka.hadoop_consumer;

import java.io.IOException;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.Executors;
import org.apache.hadoop.fs.FSDataOutputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;

import kafka.consumer.ConsumerIterator;
import kafka.consumer.KafkaStream;

public class SubTaskConsumer implements Runnable {
    private KafkaStream m_stream;
    private int m_threadNumber;
    String m_destDir = "/user/wwx/kafka2hdfs";
    String outputFileName = null;
    FSDataOutputStream dos = null;
    FileSystem hdfs;
    public SubTaskConsumer(KafkaStream a_stream, int a_threadNumber,FileSystem fs) {
        m_threadNumber = a_threadNumber;
        m_stream = a_stream;
        hdfs = fs;
        try {
            init();
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("come in 11111111");        
    }
    class refreshThread implements Runnable {
        @Override
        public void run() {
            //refresh the contents to hdfs
            try {
                synchronized (this) {
                    if (dos != null) {
                        dos.hsync();
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    private void init() throws IOException{
        ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
        refreshThread refresher = new refreshThread();
        scheduler.scheduleAtFixedRate(refresher, 0, 1000, TimeUnit.MILLISECONDS);
    }
    private void dumpToFile(String dateString, byte[] message) {
        String year = dataString.substring(0, 4);
        String month = dateString.substring(4, 6);
        String day = dateString.substring(6);
        String pathString = m_destDir + "/" + year + "/" + month + "/" + day + "/kafkadata" + m_threadNumber;
        Path path = new Path(pathString);
        if (outputFileName == null || dos == null || !pathString.equals(outputFileName)) {
            if (dos != null) {
                synchronized (this) {
                    dos.flush();
                    dos.close();
                }
                //mark the old one as done
                hdfs.rename(new Path(outputFileName), new Path(outputFileName + "." + System.currentTimeMillis() + ".Done"));
            }
            if (hdfs.exists(path)) {
                synchronized (this) {
                    dos = hdfs.append(path);
                }
                System.out.println("Open the output in the append mode: " + path);
            } else {
                synchronized (this) {
                    dos = hdfs.create(path);
                }
                System.out.println("create the new output file: " + path);
            }
            outputFileName = pathString;
        }
        dos.write(message);
        dos.write("
".getBytes());
    }
    public void run() {
        //Path path = new Path("/user/shen/tt/test.txt");
        // writing
        try {
            //FSDataOutputStream dos = hdfs.create(path);
            ConsumerIterator<byte[], byte[]> it = m_stream.iterator();
            while (it.hasNext()){
                byte[] message = it.next().message();
                byte[] decodedKeyBytes = mam.key();
                String dateString = "20160101"; //default value
                if (decodedKeyBytes != null) {
                    String sourceFileName = new String(decodedKeyBytes);
                    int lastDotIndex = sourceFileName.lastIndexOf(".");
                    dateString = sourceFileName.substring(lastDotIndex + 1);
                }
                dumpToFile(dateString, message);                
            }            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            System.out.println("Shutting down Thread: " + m_threadNumber);
            try {
                if (dos != null) {
                    dos.flush();
                    dos.close();
                }
                hdfs.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }            
    }
}

9.HDFS到Hive

这里采用了自动化的脚本来执行数据的load,新数据会自动load到hive中,hive中进行了分区 year,month,day的分区.