Question

I have an interesting problem and would appreciate your thoughts for the best solution. I need to parse a set of logs. The logs are produced by a multi-threaded program and a single process cycle produces several lines of logs.

When parsing these logs I need to pull out specific pieces of information from each process – naturally this information is across the multiple lines (I want to compress these pieces of data into a single line). Due to the application being multi-threaded, the block of lines belonging to a process can be fragmented as other processes at written to the same log file at the same time.

Fortunately, each line gives a process ID so I’m able to distinguish what logs belong to what process.

Now, there are already several parsers which all extend the same class but were designed to read logs from a single threaded application (no fragmentation – from original system) and use a readLine() method in the super class. These parsers will keep reading lines until all regular expressions have been matched for a block of lines (i.e. lines written in a single process cycle).

So, what can I do with the super class so that it can manage the fragmented logs, and ensure change to the existing implemented parsers is minimal?

Answer 1

It sounds like there are some existing parser classes already in use that you wish to leverage. In this scenario, I would write a decorator for the parser which strips out lines not associated with the process you are monitoring.

It sounds like your classes might look like this:

abstract class Parser {     public abstract void parse( ... );     protected String readLine() { ... } }  class SpecialPurposeParser extends Parser {     public void parse( ... ) {          // ... special stuff         readLine();         // ... more stuff     } } 

And I would write something like:

class SingleProcessReadingDecorator extends Parser {     private Parser parser;     private String processId;     public SingleProcessReadingDecorator( Parser parser, String processId ) {         this.parser = parser;         this.processId = processId;     }      public void parse( ... ) { parser.parse( ... ); }      public String readLine() {         String text = super.readLine();         if( /*text is for processId */ ) {              return text;          }         else {             //keep readLine'ing until you find the next line and then return it             return this.readLine();         }     } 

Then any occurrence you want to modify would be used like this:

//old way Parser parser = new SpecialPurposeParser(); //changes to Parser parser = new SingleProcessReadingDecorator( new SpecialPurposeParser(), 'process1234' ); 

This code snippet is simple and incomplete, but gives you the idea of how the decorator pattern could work here.