accesslog parse sample

accesslog-parse-sample.rb

#!/usr/bin/env ruby

require 'net/http'
require 'uri'
require 'json'
require 'date'
require 'find'
require 'erb'
require 'em-synchrony'
require 'em-synchrony/em-http'
require 'em-synchrony/fiber_iterator'

module ApacheLog
  class Entry
    def initialize(args)
      @ip_address     = args[:ip_address]
      @identity_check = args[:identity_check]
      @user           = args[:user]
      @datetime       = args[:datetime]
      @request        = args[:request]
      @status         = args[:status]
      @size           = args[:size]
      @referer        = args[:referer]
      @user_agent     = args[:user_agent]
      @cookie         = args[:cookie]
    end

    attr_reader :ip_address,
      :identity_check,
      :user,
      :datetime,
      :request,
      :status,
      :size,
      :referer,
      :user_agent,
      :cookie

    def self.parse(line)
      match = line.match(log_pattern)
      raise "parse error\n at line: <#{line}> \n" if match.nil?

      captures = match.captures
      self.new({
        :ip_address      => captures[0],
        :identity_check  => captures[1],
        :user            => captures[2],
        :datetime        => parse_datetime(captures[3]),
        :request         => parse_request(captures[4]),
        :status          => captures[5],
        :size            => captures[6],
        :referer         => captures[7],
        :user_agent      => captures[8],
        :cookie          => captures[9],
      })
    end

    # private class methods
    def self.log_pattern
      /
        ^
        (\S+)       # ip_address
        \s+
        (\S+)       # identity_check
        \s+
        (\S+)       # user
        \s+
        \[ (.*?) \] # date
        \s+
        " (.*?) "   # request
        \s+
        (\S+)       # status
        \s+
        (\S+)       # size
        \s+
        " (.*?) "   # referer
        \s+
        " (.*?) "   # user_agent
        \s+
        " (.*?) "   # cookie
        $
      /x
    end

    def self.parse_datetime(str)
      DateTime.strptime( str, '%d/%b/%Y:%T %z')
    end

    def self.parse_request(str)
      method, path, protocol = str.split
      {
        :method   => method,
        :path     => path,
        :protocol => protocol
      }
    end
    private_class_method :log_pattern, :parse_datetime, :parse_request
  end
end