024 关于spark中日志分析案例

1.四个需求

　　需求一：求contentsize的平均值、最小值、最大值

　　需求二：请各个不同返回值的出现的数据 ===> wordCount程序

　　需求三：获取访问次数超过N次的IP地址

　　需求四：获取访问次数最多的前K个endpoint的值 ==> TopN

2.主程序LogAnalyzer.scala

package com.ibeifeng.bigdata.spark.core.log

import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

/**
  * Apache日志分析
  * Created by ibf on 01/15.
  */
object LogAnalyzer {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
      .setAppName("log-analyzer")
      .setMaster("local[*]")
      .set("spark.eventLog.enabled", "true")
      .set("spark.eventLog.dir", "hdfs://hadoop-senior01:8020/spark-history")
    val sc = SparkContext.getOrCreate(conf)

    // ================日志分析具体代码==================
    // HDFS上日志存储路径
    val path = "/beifeng/spark/access/access.log"

    // 创建rdd
    val rdd = sc.textFile(path)

    // rdd转换，返回进行后续操作
    val apacheAccessLog: RDD[ApacheAccessLog] = rdd
      // 过滤数据
      .filter(line => ApacheAccessLog.isValidateLogLine(line))
      .map(line => {
        // 对line数据进行转换操作
        ApacheAccessLog.parseLogLine(line)
      })

    // 对多次时候用的rdd进行cache
    apacheAccessLog.cache()

    // 需求一：求contentsize的平均值、最小值、最大值
    /*
    * The average, min, and max content size of responses returned from the server.
    * */
    val contentSizeRDD: RDD[Long] = apacheAccessLog
      // 提取计算需要的字段数据
      .map(log => (log.contentSize))

    // 对重复使用的RDD进行cache
    contentSizeRDD.cache()

    // 开始计算平均值、最小值、最大值
    val totalContentSize = contentSizeRDD.sum()
    val totalCount = contentSizeRDD.count()
    val avgSize = 1.0 * totalContentSize / totalCount
    val minSize = contentSizeRDD.min()
    val maxSize = contentSizeRDD.max()

    // 当RDD不使用的时候，进行unpersist
    contentSizeRDD.unpersist()

    // 结果输出
    println(s"ContentSize Avg：${avgSize}, Min: ${minSize}, Max: ${maxSize}")

    // 需求二：请各个不同返回值的出现的数据 ===> wordCount程序
    /*
    * A count of response code's returned.
    * */
    val responseCodeResultRDD = apacheAccessLog
      // 提取需要的字段数据, 转换为key/value键值对，方便进行reduceByKey操作
      // 当连续出现map或者flatMap的时候，将多个map/flatMap进行合并
      .map(log => (log.responseCode, 1))
      // 使用reduceByKey函数，按照key进行分组后，计算每个key出现的次数
      .reduceByKey(_ + _)

    // 结果输出
    println(s"""ResponseCode :${responseCodeResultRDD.collect().mkString(",")}""")

    // 需求三：获取访问次数超过N次的IP地址
    // 需求三额外：对IP地址进行限制，部分黑名单IP地址不统计
    /*
    * All IPAddresses that have accessed this server more than N times.
    * 1. 计算IP地址出现的次数 ===> WordCount程序
    * 2. 数据过滤
    * */
    val blackIP = Array("200-55-104-193.dsl.prima.net.ar", "10.0.0.153", "208-38-57-205.ip.cal.radiant.net")
    // 由于集合比较大，将集合的内容广播出去
    val broadCastIP = sc.broadcast(blackIP)
    val N = 10
    val ipAddressRDD = apacheAccessLog
      // 过滤IP地址在黑名单中的数据
      .filter(log => !broadCastIP.value.contains(log.ipAddress))
      // 获取计算需要的IP地址数据，并将返回值转换为Key/Value键值对类型
      .map(log => (log.ipAddress, 1L))
      // 使用reduceByKey函数进行聚合操作
      .reduceByKey(_ + _)
      // 过滤数据，要求IP地址必须出现N次以上
      .filter(tuple => tuple._2 > N)
    // 获取满足条件IP地址, 为了展示方便，将下面这行代码注释
    //      .map(tuple => tuple._1)

    // 结果输出
    println(s"""IP Address :${ipAddressRDD.collect().mkString(",")}""")

    // 需求四：获取访问次数最多的前K个endpoint的值 ==> TopN
    /*
    * The top endpoints requested by count.
    * 1. 先计算出每个endpoint的出现次数
    * 2. 再进行topK的一个获取操作，获取出现次数最多的前K个值
    * */
    val K = 10
    val topKValues = apacheAccessLog
      // 获取计算需要的字段信息，并返回key/value键值对
      .map(log => (log.endpoint, 1))
      // 获取每个endpoint对应的出现次数
      .reduceByKey(_ + _)
      // 获取前10个元素, 而且使用我们自定义的排序类
      .top(K)(LogSortingUtil.TupleOrdering)
    // 如果只需要endpoint的值，不需要出现的次数，那么可以通过map函数进行转换
    //      .map(_._1)

    // 结果输出
    println(s"""TopK values:${topKValues.mkString(",")}""")


    // 对不在使用的rdd，去除cache
    apacheAccessLog.unpersist()

    // ================日志分析具体代码==================

    sc.stop()
  }
}

3.需要的辅助类一（返回匹配的日志）

package com.ibeifeng.bigdata.spark.core.log

import scala.util.matching.Regex

/**
  * 64.242.88.10 - - [07/Mar/2004:16:05:49 -0800] "GET /twiki/bin/edit/Main/Double_bounce_sender?topicparent=Main.ConfigurationVariables HTTP/1.1" 401 12846
  * Created by ibf on 01/15.
  */
case class ApacheAccessLog(
                            ipAddress: String, // IP地址
                            clientId: String, // 客户端唯一标识符
                            userId: String, // 用户唯一标识符
                            serverTime: String, // 服务器时间
                            method: String, // 请求类型/方式
                            endpoint: String, // 请求的资源
                            protocol: String, // 请求的协议名称
                            responseCode: Int, // 请求返回值：比如：200、401
                            contentSize: Long // 返回的结果数据大小
                          )

/**
  * 64.242.88.10 - - [07/Mar/2004:16:05:49 -0800] "GET /twiki/bin/edit/Main/Double_bounce_sender?topicparent=Main.ConfigurationVariables HTTP/1.1" 401 12846
  * on 01/15.
  * 提供一些操作Apache Log的工具类供SparkCore使用
  */
object ApacheAccessLog {
  // Apache日志的正则
  val PARTTERN: Regex =
  """^(S+) (S+) (S+) [([w:/]+s[+-]d{4})] "(S+) (S+) (S+)" (d{3}) (d+)""".r

  /**
    * 验证一下输入的数据是否符合给定的日志正则，如果符合返回true；否则返回false
    *
    * @param line
    * @return
    */
  def isValidateLogLine(line: String): Boolean = {
    val options = PARTTERN.findFirstMatchIn(line)

    if (options.isEmpty) {
      false
    } else {
      true
    }
  }

  /**
    * 解析输入的日志数据
    *
    * @param line
    * @return
    */
  def parseLogLine(line: String): ApacheAccessLog = {
    if (!isValidateLogLine(line)) {
      throw new IllegalArgumentException("参数格式异常")
    }

    // 从line中获取匹配的数据
    val options = PARTTERN.findFirstMatchIn(line)

    // 获取matcher
    val matcher = options.get

    // 构建返回值
    ApacheAccessLog(
      matcher.group(1), // 获取匹配字符串中第一个小括号中的值
      matcher.group(2),
      matcher.group(3),
      matcher.group(4),
      matcher.group(5),
      matcher.group(6),
      matcher.group(7),
      matcher.group(8).toInt,
      matcher.group(9).toLong
    )
  }
}

4.需要的辅助类二（自定义的一个二元组的比较器，方便进行TopN）

package com.ibeifeng.bigdata.spark.core.log

/**
  * Created by ibf on 01/15.
  */
object LogSortingUtil {

  /**
    * 自定义的一个二元组的比较器
    */
  object TupleOrdering extends scala.math.Ordering[(String, Int)] {
    override def compare(x: (String, Int), y: (String, Int)): Int = {
      // 按照出现的次数进行比较，也就是按照二元组的第二个元素进行比较
      x._2.compare(y._2)
    }
  }

}