Package org.apache.jmeter.protocol.http.util.accesslog

Class TCLogParser

  • All Implemented Interfaces:
    org.apache.jmeter.protocol.http.util.accesslog.LogParser 
    @AutoService(value = LogParser.class) 
public class TCLogParser
 implements LogParser

    Description: Currently the parser only handles GET/POST requests. It's easy enough to add support for other request methods by changing checkMethod. The is a complete rewrite of a tool I wrote for myself earlier. The older algorithm was basic and did not provide the same level of flexibility I want, so I wrote a new one using a totally new algorithm. This implementation reads one line at a time using BufferedReader. When it gets to the end of the file and the sampler needs to get more requests, the parser will re-initialize the BufferedReader. The implementation uses StringTokenizer to create tokens.

    The parse algorithm is the following:

    • cleans the entry by looking for backslash "\"
    • looks to see if GET or POST is in the line
    • tokenizes using quotes "
    • finds the token with the request method
    • gets the string of the token and tokenizes it using space
    • finds the first token beginning with slash character
    • tokenizes the string using question mark "?"
    • get the path from the first token
    • returns the second token and checks it for parameters
    • tokenizes the string using ampersand "&"
    • parses each token to name/value pairs

    Extending this class is fairly simple. Most access logs use the same format starting from the request method. Therefore, changing the implementation of cleanURL(string) method should be sufficient to support new log formats. Tomcat uses common log format, so any webserver that uses the format should work with this parser. Servers that are known to use non standard formats are IIS and Netscape.

    • Nested Class Summary

      Nested Classes 
      Modifier and Type Class Description

    • Field Summary

      Fields 
      Modifier and Type Field Description
      public final static String GET
      public final static String POST
      public final static String HEAD

    • Enum Constant Summary

      Enum Constants 
      Enum Constant Description

    • Constructor Detail

      • TCLogParser

        TCLogParser()

      • TCLogParser

        TCLogParser(String source)
        Parameters:
        source - name of the source file

    • Method Detail

      • setDecodeParameterValues

         void setDecodeParameterValues(boolean decodeparams)

        by default decode is set to true. if the parameters shouldn't be decoded, call the method with false

        Parameters:
        decodeparams - flag whether parameters should be decoded

      • decodeParameterValue

         boolean decodeParameterValue()

        decode the parameter values is to true by default

        Returns:

        true if parameter values should be decoded, false otherwise

      • setUseParsedFile

         void setUseParsedFile(boolean file)

        Calls this method to set whether or not to use the path in the log. We may want to provide the ability to filter the log file later on. By default, the parser uses the file in the log.

        Parameters:
        file - flag whether to use the path from the log

      • setFilter

         void setFilter(Filter filter)

        Use the filter to include/exclude files in the access logs. This is provided as a convenience and reduce the need to spend hours cleaning up log files.

        Parameters:
        filter - Filter to be used while reading the log lines

      • setSourceFile

         void setSourceFile(String source)

        Sets the source file.

        Parameters:
        source - name of the source file

      • parse

         int parse(TestElement el, int parseCount)

        parse the entire file.

        Parameters:
        el - TestElement to read the lines into
        parseCount - number of max lines to read
        Returns:

        number of read lines, or -1 if an error occurred while reading

      • parseAndConfigure

         int parseAndConfigure(int count, TestElement el)

        parse a set number of lines from the access log. Keep in mind the number of lines parsed will depend on the filter and number of lines in the log. The method returns the actual number of lines parsed.

        Parameters:
        count - number of lines to read
        el - TestElement to read lines into
        Returns:

        lines parsed

      • cleanURL

         String cleanURL(String entry)

        The method cleans the URL using the following algorithm.

        • check for double quotes
        • check the request method
        • tokenize using double quotes
        • find first token containing request method
        • tokenize string using space
        • find first token that begins with "/"
        Example Tomcat log entry:

        127.0.0.1 - - [08/Jan/2003:07:03:54 -0500] "GET /addrbook/ HTTP/1.1" 200 1981

        would result in the extracted url /addrbook/

        Parameters:
        entry - line from which the url is to be extracted
        Returns:

        cleaned url

      • checkMethod

         boolean checkMethod(String text)

        The method checks for POST, GET and HEAD methods currently. The other methods aren't supported yet.

        Parameters:
        text - text to be checked for HTTP method
        Returns:

        true if method is supported, false otherwise

      • stripFile

         String stripFile(String url, TestElement el)

        Tokenize the URL into two tokens. If the URL has more than one "?", the parse may fail. Only the first two tokens are used. The first token is automatically parsed and set at TCLogParser#URL_PATH.

        Parameters:
        url - url which should be stripped from parameters
        el - TestElement to parse url into
        Returns:

        String presenting the parameters, or null when none where found

      • checkURL

         boolean checkURL(String url)

        Checks the string to make sure it has /path/file?name=value format. If the string doesn't contains a "?", it will return false.

        Parameters:
        url - url to check for parameters
        Returns:

        true if url contains a ?, false otherwise

      • checkParamFormat

         boolean checkParamFormat(String text)

        Checks the string to see if it contains "&" and "=". If it does, return true, so that it can be parsed.

        Parameters:
        text - text to be checked for & and =
        Returns:

        true if text contains both & and =, false otherwise

      • convertStringtoNVPair

         Array<NVPair> convertStringtoNVPair(String stringparams)

        Parse the string parameters into NVPair[] array. Once they are parsed, it is returned. The method uses parseOneParameter(string) to convert each pair.

        Parameters:
        stringparams - String with parameters to be parsed
        Returns:

        array of NVPairs

      • tokenize

         StringTokenizer tokenize(String line, String delim)

        Parses the line using java.util.StringTokenizer.

        Parameters:
        line - line to be parsed
        delim - delimiter
        Returns:

        StringTokenizer constructed with line and delim

      • close

         void close()

        close the any streams or readers.