Qfyilyi

I'm working on a log file to parse the read/written/rejected records using scala and convert them into a Map. The values are present in different lines - "read" followed by "written" in next line and then "rejected"..

The snippet of the code I'm using is

val log_text =

  """

    |server.net|Wed Apr  8 05:44:24 2018|acct_reformat.000||finish|

    |            120 records (              7200 bytes) read

    |            100 records (              6000 bytes) written

    |             20 records (              1200 bytes) rejected|

    |server.net|Wed Apr  8 05:44:24 2018|acct_reformat_rfm_logs

  """.stripMargin



val read_pat = """(d+) (records) (.*)""".r

val write_pat = """(?s)records .*? (d+) (records)(.*)""".r

val reject_pat = """(?s).* (d+) (records)""".r



val read_recs  = read_pat.findAllIn(log_text).matchData.map( m=> m.subgroups(0) ).take(1).mkString

val write_recs = write_pat.findAllIn(log_text).matchData.map( m=> m.subgroups(0) ).take(1).mkString

val reject_recs = reject_pat.findAllIn(log_text).matchData.map( m=> m.subgroups(0) ).take(1).mkString



val log_summ = List("Read",read_recs,"Write",write_recs,"Reject",reject_recs).sliding(2,2).map( p => p match { case List(x,y) => (x,y)}).toMap

which results in

log_summ: scala.collection.immutable.Map[String,String] = Map(Read -> 120, Write -> 100, Reject -> 20)

Somehow I feel, I'm doing it in a roundabout/redundant way.. Is there a better way to accomplish this?.

Given the similarity of the read/write/reject text, you could simplify the multiple Regex matching patterns into a generic one and use zip to generate your Map, as shown below:

val pattern = """(d+) records .*""".r



val keys = List("Read", "Write", "Reject")



val values = pattern.findAllIn(log_text).matchData.map(_.subgroups(0)).toList

// values: List[String] = List(120, 100, 20)



val log_summ = (keys zip values).toMap

// log_summ: scala.collection.immutable.Map[String,String] =

//   Map(Read -> 120, Write -> 100, Reject -> 20)

Looks fine to me. Just three things to improve:

1) IntelliJ is your friend. It gives you two intentions immediately:

• 
  m.subgroups(0) -> m.subgroups.head
  


• 
  map(p => p match { case List(x, y) => (x, y) }) -> map { case List(x, y) => (x, y) }
  

2) DRY. Don't repeat read/write/reject related code three times. Just keep it somewhere once. E.g.:

case class Processor(name: String, patternString: String) {

  lazy val pattern: Regex = patternString.r

}



val processors = Seq(

  Processor("Read", """(d+) (records) (.*)"""),

  Processor("Write", """(?s)records .*? (d+) (records)(.*)"""),

  Processor("Reject", """(?s).* (d+) (records)"""),

)



def read_recs(processor: Processor) = processor.pattern.findAllIn(log_text).matchData.map(m => m.subgroups.head).take(1).mkString

3) List[Tuple2] can be converted to a Map with a simple toMap

val log_summ = processors.map(processor => processor.name -> read_recs(processor)).toMap

It can be done in a single pass if you're willing to use the log's wording for the Map keys.

val Pattern = raw"(d+) records .*) ([^|]+)".r.unanchored



log_text.split("n").flatMap{

  case Pattern(num, typ) => Some(typ -> num)

  case _ => None

}.toMap

//res0: immutable.Map[String,String] = Map(read -> 120, written -> 100, rejected -> 20)