Merge lp:~percona-toolkit-dev/percona-toolkit/simplify-pqd into lp:percona-toolkit/2.2

[Brian Fraser]

[Daniel Nichter (daniel-nichter)]

The changes will be/are so extensive as to be beyond the point of pointed review. Just test on all platforms, and when tests are passing, merge.

review: Approve

[Daniel Nichter (daniel-nichter)]

Somehow https://code.launchpad.net/~percona-toolkit-dev/percona-toolkit/simplify-pqd/+merge/146196 became the actual MP.

=== modified file 'bin/pt-query-digest'
--- bin/pt-query-digest	2013-01-31 17:52:34 +0000
+++ bin/pt-query-digest	2013-02-01 18:19:34 +0000
@@ -23,8 +23,6 @@
       Processlist
       TcpdumpParser
       MySQLProtocolParser
-      SysLogParser
-      PgLogParser
       SlowLogParser
       SlowLogWriter
       EventAggregator
@@ -36,13 +34,10 @@
       TableParser
       QueryReview
       Daemon
-      MemcachedProtocolParser
-      MemcachedEvent
       BinaryLogParser
       GeneralLogParser
       RawLogParser
       ProtocolParser
-      HTTPProtocolParser
       MasterSlave
       Progress
       FileIterator
@@ -3283,10 +3278,7 @@
 sub port_number {
    my ( $self, $port ) = @_;
    return unless $port;
-   return $port eq 'memcached' ? 11211
-        : $port eq 'http'      ? 80
-        : $port eq 'mysql'     ? 3306
-        :                        $port; 
+   return $port eq 'mysql' ? 3306 : $port; 
 }
 
 sub _d {
@@ -4587,617 +4579,6 @@
 # ###########################################################################
 
 # ###########################################################################
-# SysLogParser package
-# This package is a copy without comments from the original.  The original
-# with comments and its test file can be found in the Bazaar repository at,
-#   lib/SysLogParser.pm
-#   t/lib/SysLogParser.t
-# See https://launchpad.net/percona-toolkit for more information.
-# ###########################################################################
-{
-package SysLogParser;
-
-use strict;
-use warnings FATAL => 'all';
-use English qw(-no_match_vars);
-use constant PTDEBUG => $ENV{PTDEBUG} || 0;
-
-my $syslog_regex = qr{\A.*\w+\[\d+\]: \[(\d+)-(\d+)\] (.*)\Z};
-
-sub new {
-   my ( $class ) = @_;
-   my $self = {};
-   return bless $self, $class;
-}
-
-sub parse_event {
-   my ( $self, %args ) = @_;
-   my ( $next_event, $tell, $is_syslog ) = $self->generate_wrappers(%args);
-   return $next_event->();
-}
-
-sub generate_wrappers {
-   my ( $self, %args ) = @_;
-
-   if ( ($self->{sanity} || '') ne "$args{next_event}" ){
-      PTDEBUG && _d("Clearing and recreating internal state");
-      @{$self}{qw(next_event tell is_syslog)} = $self->make_closures(%args);
-      $self->{sanity} = "$args{next_event}";
-   }
-
-   return @{$self}{qw(next_event tell is_syslog)};
-}
-
-sub make_closures {
-   my ( $self, %args ) = @_;
-
-   my $next_event     = $args{'next_event'};
-   my $tell           = $args{'tell'};
-   my $new_event_test = $args{'misc'}->{'new_event_test'};
-   my $line_filter    = $args{'misc'}->{'line_filter'};
-
-   my $test_line = $next_event->();
-   PTDEBUG && _d('Read first sample/test line:', $test_line);
-
-   if ( defined $test_line && $test_line =~ m/$syslog_regex/o ) {
-
-      PTDEBUG && _d('This looks like a syslog line, PTDEBUG prefix=LLSP');
-
-      my ($msg_nr, $line_nr, $content) = $test_line =~ m/$syslog_regex/o;
-      my @pending = ($test_line);
-      my $last_msg_nr = $msg_nr;
-      my $pos_in_log  = 0;
-
-      my $new_next_event = sub {
-         PTDEBUG && _d('LLSP: next_event()');
-
-         PTDEBUG && _d('LLSP: Current virtual $fh position:', $pos_in_log);
-         my $new_pos = 0;
-
-         my @arg_lines;
-
-         my $line;
-         LINE:
-         while (
-            defined($line = shift @pending)
-            || do {
-               eval { $new_pos = -1; $new_pos = $tell->() };
-               defined($line = $next_event->());
-            }
-         ) {
-            PTDEBUG && _d('LLSP: Line:', $line);
-
-            ($msg_nr, $line_nr, $content) = $line =~ m/$syslog_regex/o;
-            if ( !$msg_nr ) {
-               die "Can't parse line: $line";
-            }
-
-            elsif ( $msg_nr != $last_msg_nr ) {
-               PTDEBUG && _d('LLSP: $msg_nr', $last_msg_nr, '=>', $msg_nr);
-               $last_msg_nr = $msg_nr;
-               last LINE;
-            }
-
-            elsif ( @arg_lines && $new_event_test && $new_event_test->($content) ) {
-               PTDEBUG && _d('LLSP: $new_event_test matches');
-               last LINE;
-            }
-
-            $content =~ s/#(\d{3})/chr(oct($1))/ge;
-            $content =~ s/\^I/\t/g;
-            if ( $line_filter ) {
-               PTDEBUG && _d('LLSP: applying $line_filter');
-               $content = $line_filter->($content);
-            }
-
-            push @arg_lines, $content;
-         }
-         PTDEBUG && _d('LLSP: Exited while-loop after finding a complete entry');
-
-         my $psql_log_event = @arg_lines ? join('', @arg_lines) : undef;
-         PTDEBUG && _d('LLSP: Final log entry:', $psql_log_event);
-
-         if ( defined $line ) {
-            PTDEBUG && _d('LLSP: Saving $line:', $line);
-            @pending = $line;
-            PTDEBUG && _d('LLSP: $pos_in_log:', $pos_in_log, '=>', $new_pos);
-            $pos_in_log = $new_pos;
-         }
-         else {
-            PTDEBUG && _d('LLSP: EOF reached');
-            @pending     = ();
-            $last_msg_nr = 0;
-         }
-
-         return $psql_log_event;
-      };
-
-      my $new_tell = sub {
-         PTDEBUG && _d('LLSP: tell()', $pos_in_log);
-         return $pos_in_log;
-      };
-
-      return ($new_next_event, $new_tell, 1);
-   }
-
-   else {
-
-      PTDEBUG && _d('Plain log, or we are at EOF; PTDEBUG prefix=PLAIN');
-
-      my @pending = defined $test_line ? ($test_line) : ();
-
-      my $new_next_event = sub {
-         PTDEBUG && _d('PLAIN: next_event(); @pending:', scalar @pending);
-         return @pending ? shift @pending : $next_event->();
-      };
-      my $new_tell = sub {
-         PTDEBUG && _d('PLAIN: tell(); @pending:', scalar @pending);
-         return @pending ? 0 : $tell->();
-      };
-      return ($new_next_event, $new_tell, 0);
-   }
-}
-
-sub _d {
-   my ($package, undef, $line) = caller 0;
-   @_ = map { (my $temp = $_) =~ s/\n/\n# /g; $temp; }
-        map { defined $_ ? $_ : 'undef' }
-        @_;
-   print STDERR "# $package:$line $PID ", join(' ', @_), "\n";
-}
-
-1;
-}
-# ###########################################################################
-# End SysLogParser package
-# ###########################################################################
-
-# ###########################################################################
-# PgLogParser package
-# This package is a copy without comments from the original.  The original
-# with comments and its test file can be found in the Bazaar repository at,
-#   lib/PgLogParser.pm
-#   t/lib/PgLogParser.t
-# See https://launchpad.net/percona-toolkit for more information.
-# ###########################################################################
-{
-package PgLogParser;
-
-use strict;
-use warnings FATAL => 'all';
-use English qw(-no_match_vars);
-use constant PTDEBUG => $ENV{PTDEBUG} || 0;
-
-use Data::Dumper;
-$Data::Dumper::Indent    = 1;
-$Data::Dumper::Sortkeys  = 1;
-$Data::Dumper::Quotekeys = 0;
-
-my $log_line_regex = qr{
-   (LOG|DEBUG|CONTEXT|WARNING|ERROR|FATAL|PANIC|HINT
-    |DETAIL|NOTICE|STATEMENT|INFO|LOCATION)
-   :\s\s+
-   }x;
-
-my %attrib_name_for = (
-   u => 'user',
-   d => 'db',
-   r => 'host', # With port
-   h => 'host',
-   p => 'Process_id',
-   t => 'ts',
-   m => 'ts',   # With milliseconds
-   i => 'Query_type',
-   c => 'Session_id',
-   l => 'Line_no',
-   s => 'Session_id',
-   v => 'Vrt_trx_id',
-   x => 'Trx_id',
-);
-
-sub new {
-   my ( $class ) = @_;
-   my $self = {
-      pending    => [],
-      is_syslog  => undef,
-      next_event => undef,
-      'tell'     => undef,
-   };
-   return bless $self, $class;
-}
-
-sub parse_event {
-   my ( $self, %args ) = @_;
-   my @required_args = qw(next_event tell);
-   foreach my $arg ( @required_args ) {
-      die "I need a $arg argument" unless $args{$arg};
-   }
-
-   my ( $next_event, $tell, $is_syslog ) = $self->generate_wrappers(%args);
-
-   my @properties = ();
-
-   my ($pos_in_log, $line, $was_pending) = $self->get_line();
-   my $new_pos;
-
-   my @arg_lines;
-
-   my $done;
-
-   my $got_duration;
-
-   if ( !$was_pending && (!defined $line || $line !~ m/$log_line_regex/o) ) {
-      PTDEBUG && _d('Skipping lines until I find a header');
-      my $found_header;
-      LINE:
-      while (
-         eval {
-            ($new_pos, $line) = $self->get_line();
-            defined $line;
-         }
-      ) {
-         if ( $line =~ m/$log_line_regex/o ) {
-            $pos_in_log = $new_pos;
-            last LINE;
-         }
-         else {
-            PTDEBUG && _d('Line was not a header, will fetch another');
-         }
-      }
-      PTDEBUG && _d('Found a header line, now at pos_in_line', $pos_in_log);
-   }
-
-   my $first_line;
-
-   my $line_type;
-
-   LINE:
-   while ( !$done && defined $line ) {
-
-      chomp $line unless $is_syslog;
-
-      if ( (($line_type) = $line =~ m/$log_line_regex/o) && $line_type ne 'LOG' ) {
-
-         if ( @arg_lines ) {
-            PTDEBUG && _d('Found a non-LOG line, exiting loop');
-            last LINE;
-         }
-
-         else {
-            $first_line ||= $line;
-
-            if ( my ($e) = $line =~ m/ERROR:\s+(\S.*)\Z/s ) {
-               push @properties, 'Error_msg', $e;
-               PTDEBUG && _d('Found an error msg, saving and continuing');
-               ($new_pos, $line) = $self->get_line();
-               next LINE;
-            }
-
-            elsif ( my ($s) = $line =~ m/STATEMENT:\s+(\S.*)\Z/s ) {
-               push @properties, 'arg', $s, 'cmd', 'Query';
-               PTDEBUG && _d('Found a statement, finishing up event');
-               $done = 1;
-               last LINE;
-            }
-
-            else {
-               PTDEBUG && _d("I don't know what to do with this line");
-            }
-         }
-
-      }
-
-      if (
-         $line =~ m{
-            Address\sfamily\snot\ssupported\sby\sprotocol
-            |archived\stransaction\slog\sfile
-            |autovacuum:\sprocessing\sdatabase
-            |checkpoint\srecord\sis\sat
-            |checkpoints\sare\soccurring\stoo\sfrequently\s\(
-            |could\snot\sreceive\sdata\sfrom\sclient
-            |database\ssystem\sis\sready
-            |database\ssystem\sis\sshut\sdown
-            |database\ssystem\swas\sshut\sdown
-            |incomplete\sstartup\spacket
-            |invalid\slength\sof\sstartup\spacket
-            |next\sMultiXactId:
-            |next\stransaction\sID:
-            |received\ssmart\sshutdown\srequest
-            |recycled\stransaction\slog\sfile
-            |redo\srecord\sis\sat
-            |removing\sfile\s"
-            |removing\stransaction\slog\sfile\s"
-            |shutting\sdown
-            |transaction\sID\swrap\slimit\sis
-         }x
-      ) {
-         PTDEBUG && _d('Skipping this line because it matches skip-pattern');
-         ($new_pos, $line) = $self->get_line();
-         next LINE;
-      }
-
-      $first_line ||= $line;
-
-      if ( $line !~ m/$log_line_regex/o && @arg_lines ) {
-
-         if ( !$is_syslog ) {
-            $line =~ s/\A\t?/\n/;
-         }
-
-         push @arg_lines, $line;
-         PTDEBUG && _d('This was a continuation line');
-      }
-
-      elsif (
-         my ( $sev, $label, $rest )
-            = $line =~ m/$log_line_regex(.+?):\s+(.*)\Z/so
-      ) {
-         PTDEBUG && _d('Line is case 1 or case 3');
-
-         if ( @arg_lines ) {
-            $done = 1;
-            PTDEBUG && _d('There are saved @arg_lines, we are done');
-
-            if ( $label eq 'duration' && $rest =~ m/[0-9.]+\s+\S+\Z/ ) {
-               if ( $got_duration ) {
-                  PTDEBUG && _d('Discarding line, duration already found');
-               }
-               else {
-                  push @properties, 'Query_time', $self->duration_to_secs($rest);
-                  PTDEBUG && _d("Line's duration is for previous event:", $rest);
-               }
-            }
-            else {
-               $self->pending($new_pos, $line);
-               PTDEBUG && _d('Deferred line');
-            }
-         }
-
-         elsif ( $label =~ m/\A(?:duration|statement|query)\Z/ ) {
-            PTDEBUG && _d('Case 1: start a multi-line event');
-
-            if ( $label eq 'duration' ) {
-
-               if (
-                  (my ($dur, $stmt)
-                     = $rest =~ m/([0-9.]+ \S+)\s+(?:statement|query): *(.*)\Z/s)
-               ) {
-                  push @properties, 'Query_time', $self->duration_to_secs($dur);
-                  $got_duration = 1;
-                  push @arg_lines, $stmt;
-                  PTDEBUG && _d('Duration + statement');
-               }
-
-               else {
-                  $first_line = undef;
-                  ($pos_in_log, $line) = $self->get_line();
-                  PTDEBUG && _d('Line applies to event we never saw, discarding');
-                  next LINE;
-               }
-            }
-            else {
-               push @arg_lines, $rest;
-               PTDEBUG && _d('Putting onto @arg_lines');
-            }
-         }
-
-         else {
-            $done = 1;
-            PTDEBUG && _d('Line is case 3, event is done');
-
-            if ( @arg_lines ) {
-               $self->pending($new_pos, $line);
-               PTDEBUG && _d('There was @arg_lines, putting line to pending');
-            }
-
-            else {
-               PTDEBUG && _d('No need to defer, process event from this line now');
-               push @properties, 'cmd', 'Admin', 'arg', $label;
-
-               if ( $label =~ m/\A(?:dis)?connection(?: received| authorized)?\Z/ ) {
-                  push @properties, $self->get_meta($rest);
-               }
-
-               else {
-                  die "I don't understand line $line";
-               }
-
-            }
-         }
-
-      }
-
-      else {
-         die "I don't understand line $line";
-      }
-
-      if ( !$done ) {
-         ($new_pos, $line) = $self->get_line();
-      }
-   } # LINE
-
-   if ( !defined $line ) {
-      PTDEBUG && _d('Line not defined, at EOF; calling oktorun(0) if exists');
-      $args{oktorun}->(0) if $args{oktorun};
-      if ( !@arg_lines ) {
-         PTDEBUG && _d('No saved @arg_lines either, we are all done');
-         return undef;
-      }
-   }
-
-   if ( $line_type && $line_type ne 'LOG' ) {
-      PTDEBUG && _d('Line is not a LOG line');
-
-      if ( $line_type eq 'ERROR' ) {
-         PTDEBUG && _d('Line is ERROR');
-
-         if ( @arg_lines ) {
-            PTDEBUG && _d('There is @arg_lines, will peek ahead one line');
-            my ( $temp_pos, $temp_line ) = $self->get_line();
-            my ( $type, $msg );
-            if (
-               defined $temp_line
-               && ( ($type, $msg) = $temp_line =~ m/$log_line_regex(.*)/o )
-               && ( $type ne 'STATEMENT' || $msg eq $arg_lines[-1] )
-            ) {
-               PTDEBUG && _d('Error/statement line pertain to current event');
-               push @properties, 'Error_msg', $line =~ m/ERROR:\s*(\S.*)\Z/s;
-               if ( $type ne 'STATEMENT' ) {
-                  PTDEBUG && _d('Must save peeked line, it is a', $type);
-                  $self->pending($temp_pos, $temp_line);
-               }
-            }
-            elsif ( defined $temp_line && defined $type ) {
-               PTDEBUG && _d('Error/statement line are a new event');
-               $self->pending($new_pos, $line);
-               $self->pending($temp_pos, $temp_line);
-            }
-            else {
-               PTDEBUG && _d("Unknown line", $line);
-            }
-         }
-      }
-      else {
-         PTDEBUG && _d("Unknown line", $line);
-      }
-   }
-
-   if ( $done || @arg_lines ) {
-      PTDEBUG && _d('Making event');
-
-      push @properties, 'pos_in_log', $pos_in_log;
-
-      if ( @arg_lines ) {
-         PTDEBUG && _d('Assembling @arg_lines: ', scalar @arg_lines);
-         push @properties, 'arg', join('', @arg_lines), 'cmd', 'Query';
-      }
-
-      if ( $first_line ) {
-         if ( my ($ts) = $first_line =~ m/([0-9-]{10} [0-9:.]{8,12})/ ) {
-            PTDEBUG && _d('Getting timestamp', $ts);
-            push @properties, 'ts', $ts;
-         }
-
-         if ( my ($meta) = $first_line =~ m/(.*?)[A-Z]{3,}:  / ) {
-            PTDEBUG && _d('Found a meta-data chunk:', $meta);
-            push @properties, $self->get_meta($meta);
-         }
-      }
-
-      PTDEBUG && _d('Properties of event:', Dumper(\@properties));
-      my $event = { @properties };
-      $event->{bytes} = length($event->{arg} || '');
-      return $event;
-   }
-
-}
-
-sub get_meta {
-   my ( $self, $meta ) = @_;
-   my @properties;
-   foreach my $set ( $meta =~ m/(\w+=[^, ]+)/g ) {
-      my ($key, $val) = split(/=/, $set);
-      if ( $key && $val ) {
-         if ( my $prop = $attrib_name_for{lc substr($key, 0, 1)} ) {
-            push @properties, $prop, $val;
-         }
-         else {
-            PTDEBUG && _d('Bad meta key', $set);
-         }
-      }
-      else {
-         PTDEBUG && _d("Can't figure out meta from", $set);
-      }
-   }
-   return @properties;
-}
-
-sub get_line {
-   my ( $self ) = @_;
-   my ($pos, $line, $was_pending) = $self->pending;
-   if ( ! defined $line ) {
-      PTDEBUG && _d('Got nothing from pending, trying the $fh');
-      my ( $next_event, $tell) = @{$self}{qw(next_event tell)};
-      eval {
-         $pos  = $tell->();
-         $line = $next_event->();
-      };
-      if ( PTDEBUG && $EVAL_ERROR ) {
-         _d($EVAL_ERROR);
-      }
-   }
-
-   PTDEBUG && _d('Got pos/line:', $pos, $line);
-   return ($pos, $line);
-}
-
-sub pending {
-   my ( $self, $val, $pos_in_log ) = @_;
-   my $was_pending;
-   PTDEBUG && _d('In sub pending, val:', $val);
-   if ( $val ) {
-      push @{$self->{pending}}, [$val, $pos_in_log];
-   }
-   elsif ( @{$self->{pending}} ) {
-      ($val, $pos_in_log) = @{ shift @{$self->{pending}} };
-      $was_pending = 1;
-   }
-   PTDEBUG && _d('Return from pending:', $val, $pos_in_log);
-   return ($val, $pos_in_log, $was_pending);
-}
-
-sub generate_wrappers {
-   my ( $self, %args ) = @_;
-
-   if ( ($self->{sanity} || '') ne "$args{next_event}" ){
-      PTDEBUG && _d("Clearing and recreating internal state");
-      eval { require SysLogParser; }; # Required for tests to work.
-      my $sl = new SysLogParser();
-
-      $args{misc}->{new_event_test} = sub {
-         my ( $content ) = @_;
-         return unless defined $content;
-         return $content =~ m/$log_line_regex/o;
-      };
-
-      $args{misc}->{line_filter} = sub {
-         my ( $content ) = @_;
-         $content =~ s/\A\t/\n/;
-         return $content;
-      };
-
-      @{$self}{qw(next_event tell is_syslog)} = $sl->make_closures(%args);
-      $self->{sanity} = "$args{next_event}";
-   }
-
-   return @{$self}{qw(next_event tell is_syslog)};
-}
-
-sub duration_to_secs {
-   my ( $self, $str ) = @_;
-   PTDEBUG && _d('Duration:', $str);
-   my ( $num, $suf ) = split(/\s+/, $str);
-   my $factor = $suf eq 'ms'  ? 1000
-              : $suf eq 'sec' ? 1
-              :                 die("Unknown suffix '$suf'");
-   return $num / $factor;
-}
-
-sub _d {
-   my ($package, undef, $line) = caller 0;
-   @_ = map { (my $temp = $_) =~ s/\n/\n# /g; $temp; }
-        map { defined $_ ? $_ : 'undef' }
-        @_;
-   print STDERR "# $package:$line $PID ", join(' ', @_), "\n";
-}
-
-1;
-}
-# ###########################################################################
-# End PgLogParser package
-# ###########################################################################
-
-# ###########################################################################
 # SlowLogParser package
 # This package is a copy without comments from the original.  The original
 # with comments and its test file can be found in the Bazaar repository at,
@@ -7197,9 +6578,7 @@
          }
 
          my $log_type = $args{log_type} || '';
-         my $mark     = $log_type eq 'memcached'
-                     || $log_type eq 'http'
-                     || $log_type eq 'pglog' ? '' : '\G';
+         my $mark     = '\G';
 
          if ( $item =~ m/^(?:[\(\s]*select|insert|replace)/ ) {
             if ( $item =~ m/^(?:insert|replace)/ ) { # No EXPLAIN
@@ -9453,522 +8832,6 @@
 # ###########################################################################
 
 # ###########################################################################
-# MemcachedProtocolParser package
-# This package is a copy without comments from the original.  The original
-# with comments and its test file can be found in the Bazaar repository at,
-#   lib/MemcachedProtocolParser.pm
-#   t/lib/MemcachedProtocolParser.t
-# See https://launchpad.net/percona-toolkit for more information.
-# ###########################################################################
-{
-package MemcachedProtocolParser;
-
-use strict;
-use warnings FATAL => 'all';
-use English qw(-no_match_vars);
-
-use Data::Dumper;
-$Data::Dumper::Indent    = 1;
-$Data::Dumper::Sortkeys  = 1;
-$Data::Dumper::Quotekeys = 0;
-
-use constant PTDEBUG => $ENV{PTDEBUG} || 0;
-
-sub new {
-   my ( $class, %args ) = @_;
-
-   my $self = {
-      server      => $args{server},
-      port        => $args{port} || '11211',
-      sessions    => {},
-      o           => $args{o},
-   };
-   return bless $self, $class;
-}
-
-sub parse_event {
-   my ( $self, %args ) = @_;
-   my @required_args = qw(event);
-   foreach my $arg ( @required_args ) {
-      die "I need a $arg argument" unless $args{$arg};
-   }
-   my $packet = @args{@required_args};
-
-   if ( $packet->{data_len} == 0 ) {
-      PTDEBUG && _d('No TCP data');
-      $args{stats}->{no_tcp_data}++ if $args{stats};
-      return;
-   }
-
-   my $src_host = "$packet->{src_host}:$packet->{src_port}";
-   my $dst_host = "$packet->{dst_host}:$packet->{dst_port}";
-
-   if ( my $server = $self->{server} ) {  # Watch only the given server.
-      $server .= ":$self->{port}";
-      if ( $src_host ne $server && $dst_host ne $server ) {
-         PTDEBUG && _d('Packet is not to or from', $server);
-         $args{stats}->{not_watched_server}++ if $args{stats};
-         return;
-      }
-   }
-
-   my $packet_from;
-   my $client;
-   if ( $src_host =~ m/:$self->{port}$/ ) {
-      $packet_from = 'server';
-      $client      = $dst_host;
-   }
-   elsif ( $dst_host =~ m/:$self->{port}$/ ) {
-      $packet_from = 'client';
-      $client      = $src_host;
-   }
-   else {
-      warn 'Packet is not to or from memcached server: ', Dumper($packet);
-      return;
-   }
-   PTDEBUG && _d('Client:', $client);
-
-   if ( !exists $self->{sessions}->{$client} ) {
-      PTDEBUG && _d('New session');
-      $self->{sessions}->{$client} = {
-         client      => $client,
-         state       => undef,
-         raw_packets => [],
-      };
-   };
-   my $session = $self->{sessions}->{$client};
-
-   push @{$session->{raw_packets}}, $packet->{raw_packet};
-
-   $packet->{data} = pack('H*', $packet->{data});
-   my $event;
-   if ( $packet_from eq 'server' ) {
-      $event = $self->_packet_from_server($packet, $session, %args);
-   }
-   elsif ( $packet_from eq 'client' ) {
-      $event = $self->_packet_from_client($packet, $session, %args);
-   }
-   else {
-      $args{stats}->{unknown_packet_origin}++ if $args{stats};
-      die 'Packet origin unknown';
-   }
-
-   PTDEBUG && _d('Done with packet; event:', Dumper($event));
-   $args{stats}->{events_parsed}++ if $args{stats};
-   return $event;
-}
-
-sub _packet_from_server {
-   my ( $self, $packet, $session, %args ) = @_;
-   die "I need a packet"  unless $packet;
-   die "I need a session" unless $session;
-
-   PTDEBUG && _d('Packet is from server; client state:', $session->{state}); 
-
-   my $data = $packet->{data};
-
-   if ( !$session->{state} ) {
-      PTDEBUG && _d('Ignoring mid-stream server response');
-      $args{stats}->{ignored_midstream_server_response}++ if $args{stats};
-      return;
-   }
-
-   if ( $session->{state} eq 'awaiting reply' ) {
-      PTDEBUG && _d('State is awaiting reply');
-      my ($line1, $rest) = $packet->{data} =~ m/\A(.*?)\r\n(.*)?/s;
-      if ( !$line1 ) {
-         $args{stats}->{unknown_server_data}++ if $args{stats};
-         die "Unknown memcached data from server";
-      }
-
-      my @vals = $line1 =~ m/(\S+)/g;
-      $session->{res} = shift @vals;
-      PTDEBUG && _d('Result of last', $session->{cmd}, 'cmd:', $session->{res});
-
-      if ( $session->{cmd} eq 'incr' || $session->{cmd} eq 'decr' ) {
-         PTDEBUG && _d('It is an incr or decr');
-         if ( $session->{res} !~ m/\D/ ) { # It's an integer, not an error
-            PTDEBUG && _d('Got a value for the incr/decr');
-            $session->{val} = $session->{res};
-            $session->{res} = '';
-         }
-      }
-      elsif ( $session->{res} eq 'VALUE' ) {
-         PTDEBUG && _d('It is the result of a "get"');
-         my ($key, $flags, $bytes) = @vals;
-         defined $session->{flags} or $session->{flags} = $flags;
-         defined $session->{bytes} or $session->{bytes} = $bytes;
-
-         if ( $rest && $bytes ) {
-            PTDEBUG && _d('There is a value');
-            if ( length($rest) > $bytes ) {
-               PTDEBUG && _d('Got complete response');
-               $session->{val} = substr($rest, 0, $bytes);
-            }
-            else {
-               PTDEBUG && _d('Got partial response, saving for later');
-               push @{$session->{partial}}, [ $packet->{seq}, $rest ];
-               $session->{gathered} += length($rest);
-               $session->{state} = 'partial recv';
-               return; # Prevent firing an event.
-            }
-         }
-      }
-      elsif ( $session->{res} eq 'END' ) {
-         PTDEBUG && _d('Got an END without any data, firing NOT_FOUND');
-         $session->{res} = 'NOT_FOUND';
-      }
-      elsif ( $session->{res} !~ m/STORED|DELETED|NOT_FOUND/ ) {
-         PTDEBUG && _d('Unknown result');
-      }
-      else {
-         $args{stats}->{unknown_server_response}++ if $args{stats};
-      }
-   }
-   else { # Should be 'partial recv'
-      PTDEBUG && _d('Session state: ', $session->{state});
-      push @{$session->{partial}}, [ $packet->{seq}, $data ];
-      $session->{gathered} += length($data);
-      PTDEBUG && _d('Gathered', $session->{gathered}, 'bytes in',
-         scalar(@{$session->{partial}}), 'packets from server');
-      if ( $session->{gathered} >= $session->{bytes} + 2 ) { # Done.
-         PTDEBUG && _d('End of partial response, preparing event');
-         my $val = join('',
-            map  { $_->[1] }
-            sort { $a->[0] <=> $b->[0] }
-                 @{$session->{partial}});
-         $session->{val} = substr($val, 0, $session->{bytes});
-      }
-      else {
-         PTDEBUG && _d('Partial response continues, no action');
-         return; # Prevent firing event.
-      }
-   }
-
-   PTDEBUG && _d('Creating event, deleting session');
-   my $event = make_event($session, $packet);
-   delete $self->{sessions}->{$session->{client}}; # memcached is stateless!
-   $session->{raw_packets} = []; # Avoid keeping forever
-   return $event;
-}
-
-sub _packet_from_client {
-   my ( $self, $packet, $session, %args ) = @_;
-   die "I need a packet"  unless $packet;
-   die "I need a session" unless $session;
-
-   PTDEBUG && _d('Packet is from client; state:', $session->{state});
-
-   my $event;
-   if ( ($session->{state} || '') =~m/awaiting reply|partial recv/ ) {
-      PTDEBUG && _d("Expected data from the client, looks like interrupted");
-      $session->{res} = 'INTERRUPTED';
-      $event = make_event($session, $packet);
-      my $client = $session->{client};
-      delete @{$session}{keys %$session};
-      $session->{client} = $client;
-   }
-
-   my ($line1, $val);
-   my ($cmd, $key, $flags, $exptime, $bytes);
-   
-   if ( !$session->{state} ) {
-      PTDEBUG && _d('Session state: ', $session->{state});
-      ($line1, $val) = $packet->{data} =~ m/\A(.*?)\r\n(.+)?/s;
-      if ( !$line1 ) {
-         PTDEBUG && _d('Unknown memcached data from client, skipping packet');
-         $args{stats}->{unknown_client_data}++ if $args{stats};
-         return;
-      }
-
-      my @vals = $line1 =~ m/(\S+)/g;
-      $cmd = lc shift @vals;
-      PTDEBUG && _d('$cmd is a ', $cmd);
-      if ( $cmd eq 'set' || $cmd eq 'add' || $cmd eq 'replace' ) {
-         ($key, $flags, $exptime, $bytes) = @vals;
-         $session->{bytes} = $bytes;
-      }
-      elsif ( $cmd eq 'get' ) {
-         ($key) = @vals;
-         if ( $val ) {
-            PTDEBUG && _d('Multiple cmds:', $val);
-            $val = undef;
-         }
-      }
-      elsif ( $cmd eq 'delete' ) {
-         ($key) = @vals; # TODO: handle the <queue_time>
-         if ( $val ) {
-            PTDEBUG && _d('Multiple cmds:', $val);
-            $val = undef;
-         }
-      }
-      elsif ( $cmd eq 'incr' || $cmd eq 'decr' ) {
-         ($key) = @vals;
-      }
-      else {
-         PTDEBUG && _d("Don't know how to handle", $cmd, "command");
-         $args{stats}->{unknown_client_command}++ if $args{stats};
-         return;
-      }
-
-      @{$session}{qw(cmd key flags exptime)}
-         = ($cmd, $key, $flags, $exptime);
-      $session->{host}       = $packet->{src_host};
-      $session->{pos_in_log} = $packet->{pos_in_log};
-      $session->{ts}         = $packet->{ts};
-   }
-   else {
-      PTDEBUG && _d('Session state: ', $session->{state});
-      $val = $packet->{data};
-   }
-
-   $session->{state} = 'awaiting reply'; # Assume we got the whole packet
-   if ( $val ) {
-      if ( $session->{bytes} + 2 == length($val) ) { # +2 for the \r\n
-         PTDEBUG && _d('Complete send');
-         $val =~ s/\r\n\Z//; # We got the whole thing.
-         $session->{val} = $val;
-      }
-      else { # We apparently did NOT get the whole thing.
-         PTDEBUG && _d('Partial send, saving for later');
-         push @{$session->{partial}},
-            [ $packet->{seq}, $val ];
-         $session->{gathered} += length($val);
-         PTDEBUG && _d('Gathered', $session->{gathered}, 'bytes in',
-            scalar(@{$session->{partial}}), 'packets from client');
-         if ( $session->{gathered} >= $session->{bytes} + 2 ) { # Done.
-            PTDEBUG && _d('Message looks complete now, saving value');
-            $val = join('',
-               map  { $_->[1] }
-               sort { $a->[0] <=> $b->[0] }
-                    @{$session->{partial}});
-            $val =~ s/\r\n\Z//;
-            $session->{val} = $val;
-         }
-         else {
-            PTDEBUG && _d('Message not complete');
-            $val = '[INCOMPLETE]';
-            $session->{state} = 'partial send';
-         }
-      }
-   }
-
-   return $event;
-}
-
-sub make_event {
-   my ( $session, $packet ) = @_;
-   my $event = {
-      cmd        => $session->{cmd},
-      key        => $session->{key},
-      val        => $session->{val} || '',
-      res        => $session->{res},
-      ts         => $session->{ts},
-      host       => $session->{host},
-      flags      => $session->{flags}   || 0,
-      exptime    => $session->{exptime} || 0,
-      bytes      => $session->{bytes}   || 0,
-      Query_time => timestamp_diff($session->{ts}, $packet->{ts}),
-      pos_in_log => $session->{pos_in_log},
-   };
-   return $event;
-}
-
-sub _get_errors_fh {
-   my ( $self ) = @_;
-   my $errors_fh = $self->{errors_fh};
-   return $errors_fh if $errors_fh;
-
-   my $o = $self->{o};
-   if ( $o && $o->has('tcpdump-errors') && $o->got('tcpdump-errors') ) {
-      my $errors_file = $o->get('tcpdump-errors');
-      PTDEBUG && _d('tcpdump-errors file:', $errors_file);
-      open $errors_fh, '>>', $errors_file
-         or die "Cannot open tcpdump-errors file $errors_file: $OS_ERROR";
-   }
-
-   $self->{errors_fh} = $errors_fh;
-   return $errors_fh;
-}
-
-sub _d {
-   my ($package, undef, $line) = caller 0;
-   @_ = map { (my $temp = $_) =~ s/\n/\n# /g; $temp; }
-        map { defined $_ ? $_ : 'undef' }
-        @_;
-   print STDERR "# $package:$line $PID ", join(' ', @_), "\n";
-}
-
-sub timestamp_diff {
-   my ( $start, $end ) = @_;
-   my $sd = substr($start, 0, 11, '');
-   my $ed = substr($end,   0, 11, '');
-   my ( $sh, $sm, $ss ) = split(/:/, $start);
-   my ( $eh, $em, $es ) = split(/:/, $end);
-   my $esecs = ($eh * 3600 + $em * 60 + $es);
-   my $ssecs = ($sh * 3600 + $sm * 60 + $ss);
-   if ( $sd eq $ed ) {
-      return sprintf '%.6f', $esecs - $ssecs;
-   }
-   else { # Assume only one day boundary has been crossed, no DST, etc
-      return sprintf '%.6f', ( 86_400 - $ssecs ) + $esecs;
-   }
-}
-
-1;
-}
-# ###########################################################################
-# End MemcachedProtocolParser package
-# ###########################################################################
-
-# ###########################################################################
-# MemcachedEvent package
-# This package is a copy without comments from the original.  The original
-# with comments and its test file can be found in the Bazaar repository at,
-#   lib/MemcachedEvent.pm
-#   t/lib/MemcachedEvent.t
-# See https://launchpad.net/percona-toolkit for more information.
-# ###########################################################################
-{
-package MemcachedEvent;
-
-use strict;
-use warnings FATAL => 'all';
-use English qw(-no_match_vars);
-use constant PTDEBUG => $ENV{PTDEBUG} || 0;
-
-use Data::Dumper;
-$Data::Dumper::Indent    = 1;
-$Data::Dumper::Sortkeys  = 1;
-$Data::Dumper::Quotekeys = 0;
-
-my %cmds = map { $_ => 1 } qw(
-   set
-   add
-   replace
-   append
-   prepend
-   cas
-   get
-   gets
-   delete
-   incr
-   decr
-);
-
-my %cmd_handler_for = (
-   set      => \&handle_storage_cmd,
-   add      => \&handle_storage_cmd,
-   replace  => \&handle_storage_cmd,
-   append   => \&handle_storage_cmd,
-   prepend  => \&handle_storage_cmd,
-   cas      => \&handle_storage_cmd,
-   get      => \&handle_retr_cmd,
-   gets     => \&handle_retr_cmd,
-);
-
-sub new {
-   my ( $class, %args ) = @_;
-   my $self = {};
-   return bless $self, $class;
-}
-
-sub parse_event {
-   my ( $self, %args ) = @_;
-   my $event = $args{event};
-   return unless $event;
-
-   if ( !$event->{cmd} || !$event->{key} ) {
-      PTDEBUG && _d('Event has no cmd or key:', Dumper($event));
-      return;
-   }
-
-   if ( !$cmds{$event->{cmd}} ) {
-      PTDEBUG && _d("Don't know how to handle cmd:", $event->{cmd});
-      return;
-   }
-
-   $event->{arg}         = "$event->{cmd} $event->{key}";
-   $event->{fingerprint} = $self->fingerprint($event->{arg});
-   $event->{key_print}   = $self->fingerprint($event->{key});
-
-   map { $event->{"Memc_$_"} = 'No' } keys %cmds;
-   $event->{"Memc_$event->{cmd}"} = 'Yes';  # Got this cmd.
-   $event->{Memc_error}           = 'No';  # A handler may change this.
-   $event->{Memc_miss}            = 'No';
-   if ( $event->{res} ) {
-      $event->{Memc_miss}         = 'Yes' if $event->{res} eq 'NOT_FOUND';
-   }
-   else {
-      PTDEBUG && _d('Event has no res:', Dumper($event));
-   }
-
-   if ( $cmd_handler_for{$event->{cmd}} ) {
-      return $cmd_handler_for{$event->{cmd}}->($event);
-   }
-
-   return $event;
-}
-
-sub fingerprint {
-   my ( $self, $val ) = @_;
-   $val =~ s/[0-9A-Fa-f]{16,}|\d+/?/g;
-   return $val;
-}
-
-sub handle_storage_cmd {
-   my ( $event ) = @_;
-
-   if ( !$event->{res} ) {
-      PTDEBUG && _d('No result for event:', Dumper($event));
-      return;
-   }
-
-   $event->{'Memc_Not_Stored'} = $event->{res} eq 'NOT_STORED' ? 'Yes' : 'No';
-   $event->{'Memc_Exists'}     = $event->{res} eq 'EXISTS'     ? 'Yes' : 'No';
-
-   return $event;
-}
-
-sub handle_retr_cmd {
-   my ( $event ) = @_;
-
-   if ( !$event->{res} ) {
-      PTDEBUG && _d('No result for event:', Dumper($event));
-      return;
-   }
-
-   $event->{'Memc_error'} = $event->{res} eq 'INTERRUPTED' ? 'Yes' : 'No';
-
-   return $event;
-}
-
-
-sub handle_delete {
-   my ( $event ) = @_;
-   return $event;
-}
-
-sub handle_incr_decr_cmd {
-   my ( $event ) = @_;
-   return $event;
-}
-
-sub _d {
-   my ($package, undef, $line) = caller 0;
-   @_ = map { (my $temp = $_) =~ s/\n/\n# /g; $temp; }
-        map { defined $_ ? $_ : 'undef' }
-        @_;
-   print STDERR "# $package:$line $PID ", join(' ', @_), "\n";
-}
-
-1;
-}
-# ###########################################################################
-# End MemcachedEvent package
-# ###########################################################################
-
-# ###########################################################################
 # BinaryLogParser package
 # This package is a copy without comments from the original.  The original
 # with comments and its test file can be found in the Bazaar repository at,
@@ -10719,209 +9582,6 @@
 # ###########################################################################
 
 # ###########################################################################
-# HTTPProtocolParser package
-# This package is a copy without comments from the original.  The original
-# with comments and its test file can be found in the Bazaar repository at,
-#   lib/HTTPProtocolParser.pm
-#   t/lib/HTTPProtocolParser.t
-# See https://launchpad.net/percona-toolkit for more information.
-# ###########################################################################
-{
-package HTTPProtocolParser;
-use base 'ProtocolParser';
-
-use strict;
-use warnings FATAL => 'all';
-use English qw(-no_match_vars);
-use constant PTDEBUG => $ENV{PTDEBUG} || 0;
-
-sub new {
-   my ( $class, %args ) = @_;
-   my $self = $class->SUPER::new(
-      %args,
-      port => 80,
-   );
-   return $self;
-}
-
-sub _packet_from_server {
-   my ( $self, $packet, $session, $misc ) = @_;
-   die "I need a packet"  unless $packet;
-   die "I need a session" unless $session;
-
-   PTDEBUG && _d('Packet is from server; client state:', $session->{state}); 
-
-   if ( !$session->{state} ) {
-      PTDEBUG && _d('Ignoring mid-stream server response');
-      return;
-   }
-
-   if ( $session->{out_of_order} ) {
-      my ($line1, $content);
-      if ( !$session->{have_header} ) {
-         ($line1, $content) = $self->_parse_header(
-            $session, $packet->{data}, $packet->{data_len});
-      }
-      if ( $line1 ) {
-         $session->{have_header} = 1;
-         $packet->{content_len}  = length $content;
-         PTDEBUG && _d('Got out of order header with',
-            $packet->{content_len}, 'bytes of content');
-      }
-      my $have_len = $packet->{content_len} || $packet->{data_len};
-      map { $have_len += $_->{data_len} }
-         @{$session->{packets}};
-      $session->{have_all_packets}
-         = 1 if $session->{attribs}->{bytes}
-                && $have_len >= $session->{attribs}->{bytes};
-      PTDEBUG && _d('Have', $have_len, 'of', $session->{attribs}->{bytes});
-      return;
-   }
-
-   if ( $session->{state} eq 'awaiting reply' ) {
-
-      $session->{start_reply} = $packet->{ts} unless $session->{start_reply};
-
-      my ($line1, $content) = $self->_parse_header($session, $packet->{data},
-            $packet->{data_len});
-
-      if ( !$line1 ) {
-         $session->{out_of_order}     = 1;  # alert parent
-         $session->{have_all_packets} = 0;
-         return;
-      }
-
-      my ($version, $code, $phrase) = $line1 =~ m/(\S+)/g;
-      $session->{attribs}->{Status_code} = $code;
-      PTDEBUG && _d('Status code for last', $session->{attribs}->{arg},
-         'request:', $session->{attribs}->{Status_code});
-
-      my $content_len = $content ? length $content : 0;
-      PTDEBUG && _d('Got', $content_len, 'bytes of content');
-      if ( $session->{attribs}->{bytes}
-           && $content_len < $session->{attribs}->{bytes} ) {
-         $session->{data_len}  = $session->{attribs}->{bytes};
-         $session->{buff}      = $content;
-         $session->{buff_left} = $session->{attribs}->{bytes} - $content_len;
-         PTDEBUG && _d('Contents not complete,', $session->{buff_left},
-            'bytes left');
-         $session->{state} = 'recving content';
-         return;
-      }
-   }
-   elsif ( $session->{state} eq 'recving content' ) {
-      if ( $session->{buff} ) {
-         PTDEBUG && _d('Receiving content,', $session->{buff_left},
-            'bytes left');
-         return;
-      }
-      PTDEBUG && _d('Contents received');
-   }
-   else {
-      warn "Server response in unknown state"; 
-      return;
-   }
-
-   PTDEBUG && _d('Creating event, deleting session');
-   $session->{end_reply} = $session->{ts_max} || $packet->{ts};
-   my $event = $self->make_event($session, $packet);
-   delete $self->{sessions}->{$session->{client}}; # http is stateless!
-   return $event;
-}
-
-sub _packet_from_client {
-   my ( $self, $packet, $session, $misc ) = @_;
-   die "I need a packet"  unless $packet;
-   die "I need a session" unless $session;
-
-   PTDEBUG && _d('Packet is from client; state:', $session->{state});
-
-   my $event;
-   if ( ($session->{state} || '') =~ m/awaiting / ) {
-      PTDEBUG && _d('More client headers:', $packet->{data});
-      return;
-   }
-
-   if ( !$session->{state} ) {
-      $session->{state} = 'awaiting reply';
-      my ($line1, undef) = $self->_parse_header($session, $packet->{data}, $packet->{data_len});
-      my ($request, $page, $version) = $line1 =~ m/(\S+)/g;
-      if ( !$request || !$page ) {
-         PTDEBUG && _d("Didn't get a request or page:", $request, $page);
-         return;
-      }
-      $request = lc $request;
-      my $vh   = $session->{attribs}->{Virtual_host} || '';
-      my $arg = "$request $vh$page";
-      PTDEBUG && _d('arg:', $arg);
-
-      if ( $request eq 'get' || $request eq 'post' ) {
-         @{$session->{attribs}}{qw(arg)} = ($arg);
-      }
-      else {
-         PTDEBUG && _d("Don't know how to handle a", $request, "request");
-         return;
-      }
-
-      $session->{start_request}         = $packet->{ts};
-      $session->{attribs}->{host}       = $packet->{src_host};
-      $session->{attribs}->{pos_in_log} = $packet->{pos_in_log};
-      $session->{attribs}->{ts}         = $packet->{ts};
-   }
-   else {
-      die "Probably multiple GETs from client before a server response?"; 
-   }
-
-   return $event;
-}
-
-sub _parse_header {
-   my ( $self, $session, $data, $len, $no_recurse ) = @_;
-   die "I need data" unless $data;
-   my ($header, $content)    = split(/\r\n\r\n/, $data);
-   my ($line1, $header_vals) = $header  =~ m/\A(\S+ \S+ .+?)\r\n(.+)?/s;
-   PTDEBUG && _d('HTTP header:', $line1);
-   return unless $line1;
-
-   if ( !$header_vals ) {
-      PTDEBUG && _d('No header vals');
-      return $line1, undef;
-   }
-   my @headers;
-   foreach my $val ( split(/\r\n/, $header_vals) ) {
-      last unless $val;
-      PTDEBUG && _d('HTTP header:', $val);
-      if ( $val =~ m/^Content-Length/i ) {
-         ($session->{attribs}->{bytes}) = $val =~ /: (\d+)/;
-         PTDEBUG && _d('Saved Content-Length:', $session->{attribs}->{bytes});
-      }
-      if ( $val =~ m/Content-Encoding/i ) {
-         ($session->{compressed}) = $val =~ /: (\w+)/;
-         PTDEBUG && _d('Saved Content-Encoding:', $session->{compressed});
-      }
-      if ( $val =~ m/^Host/i ) {
-         ($session->{attribs}->{Virtual_host}) = $val =~ /: (\S+)/;
-         PTDEBUG && _d('Saved Host:', ($session->{attribs}->{Virtual_host}));
-      }
-   }
-   return $line1, $content;
-}
-
-sub _d {
-   my ($package, undef, $line) = caller 0;
-   @_ = map { (my $temp = $_) =~ s/\n/\n# /g; $temp; }
-        map { defined $_ ? $_ : 'undef' }
-        @_;
-   print STDERR "# $package:$line $PID ", join(' ', @_), "\n";
-}
-
-1;
-}
-# ###########################################################################
-# End HTTPProtocolParser package
-# ###########################################################################
-
-# ###########################################################################
 # MasterSlave package
 # This package is a copy without comments from the original.  The original
 # with comments and its test file can be found in the Bazaar repository at,
@@ -13986,10 +12646,6 @@
             binlog    => ['BinaryLogParser'],
             genlog    => ['GeneralLogParser'],
             tcpdump   => ['TcpdumpParser','MySQLProtocolParser'],
-            memcached => ['TcpdumpParser','MemcachedProtocolParser',
-                          'MemcachedEvent'],
-            http      => ['TcpdumpParser','HTTPProtocolParser'],
-            pglog     => ['PgLogParser'],
             rawlog    => ['RawLogParser'],
          );
          my $type = $o->get('type');
@@ -14543,17 +13199,6 @@
 
    { # distill
       my %distill_args;
-      if ( $o->get('type') eq 'memcached' || $o->get('type') eq 'http' ) {
-         $distill_args{generic} = 1;
-         if ( $o->get('type') eq 'http' ) {
-            # Remove stuff after url.
-            $distill_args{trf} = sub {
-               my ( $query ) = @_;
-               $query =~ s/(\S+ \S+?)(?:[?;].+)/$1/;
-               return $query;
-            };
-         }
-      }
       if ( grep { $_ eq 'distill' } @groupby ) {
          $pipeline->add(
             name    => 'distill',
@@ -15282,7 +13927,7 @@
 
 =head1 NAME
 
-pt-query-digest - Analyze query execution logs and generate a query report, filter, replay, or transform queries for MySQL, PostgreSQL, memcached, and more.
+pt-query-digest - Analyze query execution logs and generate a query report, filter, replay, or transform queries for MySQL.
 
 =head1 SYNOPSIS
 
@@ -15387,19 +14032,6 @@
 Attributes created this way can be specified for L<"--order-by"> or any
 option that requires an attribute.
 
-=head2 memcached
-
-memcached events have additional attributes related to the memcached protocol:
-cmd, key, res (result) and val.  Also, boolean attributes are created for
-the various commands, misses and errors: Memc_CMD where CMD is a memcached
-command (get, set, delete, etc.), Memc_error and Memc_miss.
-
-These attributes are no different from slow log attributes, so you can use them
-with L<"--[no]report">, L<"--group-by">, in a L<"--filter">, etc.
-
-See the memcached section of L<"ATTRIBUTES REFERENCE"> for a list of
-memcached-specific attributes.
-
 =head1 OUTPUT
 
 The default output is a query analysis report.  The L<"--[no]report"> option
@@ -15657,12 +14289,6 @@
 You can also use the value C<distill>, which is a kind of super-fingerprint.
 See L<"--group-by"> for more.
 
-When parsing memcached input (L<"--type"> memcached), the fingerprint is an
-abstracted version of the command and key, with placeholders removed.  For
-example, C<get user_123_preferences> fingerprints to C<get user_?_preferences>.
-There is also a C<key_print> which a fingerprinted version of the key.  This
-example's key_print is C<user_?_preferences>.
-
 Query fingerprinting accommodates a great many special cases, which have proven
 necessary in the real world.  For example, an IN list with 5 literals is really
 equivalent to one with 4 literals, so lists of literals are collapsed to a
@@ -16027,11 +14653,6 @@
 
 =back
 
-If parsing memcached input (L<"--type"> memcached), there are other
-attributes which you can group by: key_print (see memcached section in
-L<"FINGERPRINTS">), cmd, key, res and val (see memcached section in
-L<"ATTRIBUTES">).
-
 =item --help
 
 Show help and exit.
@@ -16761,52 +15382,6 @@
 notably C<Query_time>.  The default L<"--order-by"> for general logs
 changes to C<Query_time:cnt>.
 
-=item http
-
-Parse HTTP traffic from tcpdump.
-
-=item pglog
-
-Parse a log file in PostgreSQL format.  The parser will automatically recognize
-logs sent to syslog and transparently parse the syslog format, too.  The
-recommended configuration for logging in your postgresql.conf is as follows.
-
-The log_destination setting can be set to either syslog or stderr.  Syslog has
-the added benefit of not interleaving log messages from several sessions
-concurrently, which the parser cannot handle, so this might be better than
-stderr.  CSV-formatted logs are not supported at this time.
-
-The log_min_duration_statement setting should be set to 0 to capture all
-statements with their durations.  Alternatively, the parser will also recognize
-and handle various combinations of log_duration and log_statement.
-
-You may enable log_connections and log_disconnections, but this is optional.
-
-It is highly recommended to set your log_line_prefix to the following:
-
-  log_line_prefix = '%m c=%c,u=%u,D=%d '
-
-This lets the parser find timestamps with milliseconds, session IDs, users, and
-databases from the log.  If these items are missing, you'll simply get less
-information to analyze.  For compatibility with other log analysis tools such as
-PQA and pgfouine, various log line prefix formats are supported.  The general
-format is as follows: a timestamp can be detected and extracted (the syslog
-timestamp is NOT parsed), and a name=value list of properties can also.
-Although the suggested format is as shown above, any name=value list will be
-captured and interpreted by using the first letter of the 'name' part,
-lowercased, to determine the meaning of the item.  The lowercased first letter
-is interpreted to mean the same thing as PostgreSQL's built-in %-codes for the
-log_line_prefix format string.  For example, u means user, so unicorn=fred
-will be interpreted as user=fred; d means database, so D=john will be
-interpreted as database=john.  The pgfouine-suggested formatting is user=%u and
-db=%d, so it should Just Work regardless of which format you choose.  The main
-thing is to add as much information as possible into the log_line_prefix to
-permit richer analysis.
-
-Currently, only English locale messages are supported, so if your server's
-locale is set to something else, the log won't be parsed properly.  (Log
-messages with "duration:" and "statement:" won't be recognized.)
-
 =item slowlog
 
 Parse a log file in any variation of MySQL slow-log format.
@@ -16872,17 +15447,6 @@
 Server-side prepared statements are supported.  SSL-encrypted traffic cannot be
 inspected and decoded.
 
-=item memcached
-
-Similar to tcpdump, but the expected input is memcached packets
-instead of MySQL packets.  For example:
-
-  tcpdump -i any port 11211 -s 65535 -x -nn -q -tttt \
-    > memcached.tcp.txt
-  pt-query-digest --type memcached memcached.tcp.txt
-
-memcached uses port 11211 by default.
-
 =back
 
 =item --until
@@ -16962,8 +15526,8 @@
 type: string
 
 This option tells pt-query-digest which server IP address and port (like
-"10.0.0.1:3306") to watch when parsing tcpdump (for L<"--type"> tcpdump and
-memcached); all other servers are ignored.  If you don't specify it,
+"10.0.0.1:3306") to watch when parsing tcpdump (for L<"--type"> tcpdump);
+all other servers are ignored.  If you don't specify it,
 pt-query-digest watches all servers by looking for any IP address using port
 3306 or "mysql".  If you're watching a server with a non-standard port, this
 won't work, so you must specify the IP address and port to watch.
@@ -17156,13 +15720,12 @@
 
 =item cmd
 
-"Query" or "Admin" for all except memcached. For memcached it's
-the memcached command: get, set, etc.
+"Query" or "Admin".
 
 =item db
 
-The current database, except for memcached.  The value comes from USE
-database statements.  By default, C<Schema> is an alias which is automatically
+The current database.  The value comes from USE database statements.  
+By default, C<Schema> is an alias which is automatically
 changed to C<db>; see L<"--attribute-aliases">.
 
 =item fingerprint 
@@ -17235,75 +15798,6 @@
 If using L<"--processlist">, an C<id> attribute is available for
 the process ID, in addition to the common attributes.
 
-=head2 MEMCACHED
-
-These attributes are available when parsing L<"--type"> memcached.
-
-=over
-
-=item exptime
-
-Expiration time.
-
-=item key
-
-The key used by cmd.
-
-=item key_print
-
-An abstracted form of the key.
-
-=item Memc_add
-
-Yes/No if the command is add.
-
-=item Memc_append
-
-Yes/No if the command is append.
-
-=item Memc_cas
-
-Yes/No if the command is cas.
-
-=item Memc_error
-
-Yes/No if command caused an error. Currently, the only error is when
-a retrieval command is interrupted.
-
-=item Memc_get
-
-Yes/No if the command is get.
-
-=item Memc_gets
-
-Yes/No if the command is gets.
-
-=item Memc_miss
-
-Yes/No if the command tried to access a nonexistent key.
-
-=item Memc_prepend
-
-Yes/No if the command is prepend.
-
-=item Memc_replace
-
-Yes/No if the command is replace.
-
-=item Memc_set
-
-Yes/No if the command is set.
-
-=item res
-
-Result of cmd.
-
-=item val
-
-The return value of cmd, if any.
-
-=back
-
 =head1 AUTHORS
 
 Baron Schwartz and Daniel Nichter

=== removed file 'lib/HTTPProtocolParser.pm'
--- lib/HTTPProtocolParser.pm	2013-01-03 00:19:16 +0000
+++ lib/HTTPProtocolParser.pm	1970-01-01 00:00:00 +0000
@@ -1,242 +0,0 @@
-# This program is copyright 2009-2011 Percona Ireland Ltd.
-# Feedback and improvements are welcome.
-#
-# THIS PROGRAM IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
-# WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
-# MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU General Public License as published by the Free Software
-# Foundation, version 2; OR the Perl Artistic License.  On UNIX and similar
-# systems, you can issue `man perlgpl' or `man perlartistic' to read these
-# licenses.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc., 59 Temple
-# Place, Suite 330, Boston, MA  02111-1307  USA.
-# ###########################################################################
-# HTTPProtocolParser package
-# ###########################################################################
-{
-# Package: HTTPProtocolParser
-# HTTPProtocolParser parses HTTP traffic from tcpdump files.
-package HTTPProtocolParser;
-use base 'ProtocolParser';
-
-use strict;
-use warnings FATAL => 'all';
-use English qw(-no_match_vars);
-use constant PTDEBUG => $ENV{PTDEBUG} || 0;
-
-# server is the "host:port" of the sever being watched.  It's auto-guessed if
-# not specified.
-sub new {
-   my ( $class, %args ) = @_;
-   my $self = $class->SUPER::new(
-      %args,
-      port => 80,
-   );
-   return $self;
-}
-
-# Handles a packet from the server given the state of the session.  Returns an
-# event if one was ready to be created, otherwise returns nothing.
-sub _packet_from_server {
-   my ( $self, $packet, $session, $misc ) = @_;
-   die "I need a packet"  unless $packet;
-   die "I need a session" unless $session;
-
-   PTDEBUG && _d('Packet is from server; client state:', $session->{state}); 
-
-   # If there's no session state, then we're catching a server response
-   # mid-stream.
-   if ( !$session->{state} ) {
-      PTDEBUG && _d('Ignoring mid-stream server response');
-      return;
-   }
-
-   if ( $session->{out_of_order} ) {
-      # We're waiting for the header so we can get the content length.
-      # Once we know this, we can determine how many out of order packets
-      # we need to complete the request, then order them and re-process.
-      my ($line1, $content);
-      if ( !$session->{have_header} ) {
-         ($line1, $content) = $self->_parse_header(
-            $session, $packet->{data}, $packet->{data_len});
-      }
-      if ( $line1 ) {
-         $session->{have_header} = 1;
-         $packet->{content_len}  = length $content;
-         PTDEBUG && _d('Got out of order header with',
-            $packet->{content_len}, 'bytes of content');
-      }
-      my $have_len = $packet->{content_len} || $packet->{data_len};
-      map { $have_len += $_->{data_len} }
-         @{$session->{packets}};
-      $session->{have_all_packets}
-         = 1 if $session->{attribs}->{bytes}
-                && $have_len >= $session->{attribs}->{bytes};
-      PTDEBUG && _d('Have', $have_len, 'of', $session->{attribs}->{bytes});
-      return;
-   }
-
-   # Assume that the server is returning only one value. 
-   # TODO: make it handle multiple.
-   if ( $session->{state} eq 'awaiting reply' ) {
-
-      # Save this early because we may return early if the packets
-      # are being received out of order.  Also, save it only once
-      # in case we re-process packets if they're out of order.
-      $session->{start_reply} = $packet->{ts} unless $session->{start_reply};
-
-      # Get first line of header and first chunk of contents/data.
-      my ($line1, $content) = $self->_parse_header($session, $packet->{data},
-            $packet->{data_len});
-
-      # The reponse, when in order, is text header followed by data.
-      # If there's no line1, then we didn't get the text header first
-      # which means we're getting the response in out of order packets.
-      if ( !$line1 ) {
-         $session->{out_of_order}     = 1;  # alert parent
-         $session->{have_all_packets} = 0;
-         return;
-      }
-
-      # First line should be: version  code phrase
-      # E.g.:                 HTTP/1.1  200 OK
-      my ($version, $code, $phrase) = $line1 =~ m/(\S+)/g;
-      $session->{attribs}->{Status_code} = $code;
-      PTDEBUG && _d('Status code for last', $session->{attribs}->{arg},
-         'request:', $session->{attribs}->{Status_code});
-
-      my $content_len = $content ? length $content : 0;
-      PTDEBUG && _d('Got', $content_len, 'bytes of content');
-      if ( $session->{attribs}->{bytes}
-           && $content_len < $session->{attribs}->{bytes} ) {
-         $session->{data_len}  = $session->{attribs}->{bytes};
-         $session->{buff}      = $content;
-         $session->{buff_left} = $session->{attribs}->{bytes} - $content_len;
-         PTDEBUG && _d('Contents not complete,', $session->{buff_left},
-            'bytes left');
-         $session->{state} = 'recving content';
-         return;
-      }
-   }
-   elsif ( $session->{state} eq 'recving content' ) {
-      if ( $session->{buff} ) {
-         PTDEBUG && _d('Receiving content,', $session->{buff_left},
-            'bytes left');
-         return;
-      }
-      PTDEBUG && _d('Contents received');
-   }
-   else {
-      # TODO:
-      warn "Server response in unknown state"; 
-      return;
-   }
-
-   PTDEBUG && _d('Creating event, deleting session');
-   $session->{end_reply} = $session->{ts_max} || $packet->{ts};
-   my $event = $self->make_event($session, $packet);
-   delete $self->{sessions}->{$session->{client}}; # http is stateless!
-   return $event;
-}
-
-# Handles a packet from the client given the state of the session.
-sub _packet_from_client {
-   my ( $self, $packet, $session, $misc ) = @_;
-   die "I need a packet"  unless $packet;
-   die "I need a session" unless $session;
-
-   PTDEBUG && _d('Packet is from client; state:', $session->{state});
-
-   my $event;
-   if ( ($session->{state} || '') =~ m/awaiting / ) {
-      PTDEBUG && _d('More client headers:', $packet->{data});
-      return;
-   }
-
-   if ( !$session->{state} ) {
-      $session->{state} = 'awaiting reply';
-      my ($line1, undef) = $self->_parse_header($session, $packet->{data}, $packet->{data_len});
-      # First line should be: request page      version
-      # E.g.:                 GET     /foo.html HTTP/1.1
-      my ($request, $page, $version) = $line1 =~ m/(\S+)/g;
-      if ( !$request || !$page ) {
-         PTDEBUG && _d("Didn't get a request or page:", $request, $page);
-         return;
-      }
-      $request = lc $request;
-      my $vh   = $session->{attribs}->{Virtual_host} || '';
-      my $arg = "$request $vh$page";
-      PTDEBUG && _d('arg:', $arg);
-
-      if ( $request eq 'get' || $request eq 'post' ) {
-         @{$session->{attribs}}{qw(arg)} = ($arg);
-      }
-      else {
-         PTDEBUG && _d("Don't know how to handle a", $request, "request");
-         return;
-      }
-
-      $session->{start_request}         = $packet->{ts};
-      $session->{attribs}->{host}       = $packet->{src_host};
-      $session->{attribs}->{pos_in_log} = $packet->{pos_in_log};
-      $session->{attribs}->{ts}         = $packet->{ts};
-   }
-   else {
-      # TODO:
-      die "Probably multiple GETs from client before a server response?"; 
-   }
-
-   return $event;
-}
-
-sub _parse_header {
-   my ( $self, $session, $data, $len, $no_recurse ) = @_;
-   die "I need data" unless $data;
-   my ($header, $content)    = split(/\r\n\r\n/, $data);
-   my ($line1, $header_vals) = $header  =~ m/\A(\S+ \S+ .+?)\r\n(.+)?/s;
-   PTDEBUG && _d('HTTP header:', $line1);
-   return unless $line1;
-
-   if ( !$header_vals ) {
-      PTDEBUG && _d('No header vals');
-      return $line1, undef;
-   }
-   my @headers;
-   foreach my $val ( split(/\r\n/, $header_vals) ) {
-      last unless $val;
-      # Capture and save any useful header values.
-      PTDEBUG && _d('HTTP header:', $val);
-      if ( $val =~ m/^Content-Length/i ) {
-         ($session->{attribs}->{bytes}) = $val =~ /: (\d+)/;
-         PTDEBUG && _d('Saved Content-Length:', $session->{attribs}->{bytes});
-      }
-      if ( $val =~ m/Content-Encoding/i ) {
-         ($session->{compressed}) = $val =~ /: (\w+)/;
-         PTDEBUG && _d('Saved Content-Encoding:', $session->{compressed});
-      }
-      if ( $val =~ m/^Host/i ) {
-         # The "host" attribute is already taken, so we call this "domain".
-         ($session->{attribs}->{Virtual_host}) = $val =~ /: (\S+)/;
-         PTDEBUG && _d('Saved Host:', ($session->{attribs}->{Virtual_host}));
-      }
-   }
-   return $line1, $content;
-}
-
-sub _d {
-   my ($package, undef, $line) = caller 0;
-   @_ = map { (my $temp = $_) =~ s/\n/\n# /g; $temp; }
-        map { defined $_ ? $_ : 'undef' }
-        @_;
-   print STDERR "# $package:$line $PID ", join(' ', @_), "\n";
-}
-
-1;
-}
-# ###########################################################################
-# End HTTPProtocolParser package
-# ###########################################################################

=== removed file 'lib/MemcachedEvent.pm'
--- lib/MemcachedEvent.pm	2013-01-03 00:19:16 +0000
+++ lib/MemcachedEvent.pm	1970-01-01 00:00:00 +0000
@@ -1,216 +0,0 @@
-# This program is copyright 2009-2011 Percona Ireland Ltd.
-# Feedback and improvements are welcome.
-#
-# THIS PROGRAM IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
-# WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
-# MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU General Public License as published by the Free Software
-# Foundation, version 2; OR the Perl Artistic License.  On UNIX and similar
-# systems, you can issue `man perlgpl' or `man perlartistic' to read these
-# licenses.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc., 59 Temple
-# Place, Suite 330, Boston, MA  02111-1307  USA.
-# ###########################################################################
-# MemcachedEvent package
-# ###########################################################################
-{
-# Package: MemcachedEvent
-# MemcachedEvent creates events from <MemcachedProtocolParser> data.
-# Since memcached is not strictly MySQL stuff, we have to
-# fabricate MySQL-like query events from memcached.
-# 
-# See http://code.sixapart.com/svn/memcached/trunk/server/doc/protocol.txt
-# for information about the memcached protocol.
-package MemcachedEvent;
-
-use strict;
-use warnings FATAL => 'all';
-use English qw(-no_match_vars);
-use constant PTDEBUG => $ENV{PTDEBUG} || 0;
-
-use Data::Dumper;
-$Data::Dumper::Indent    = 1;
-$Data::Dumper::Sortkeys  = 1;
-$Data::Dumper::Quotekeys = 0;
-
-# cmds that we know how to handle.
-my %cmds = map { $_ => 1 } qw(
-   set
-   add
-   replace
-   append
-   prepend
-   cas
-   get
-   gets
-   delete
-   incr
-   decr
-);
-
-my %cmd_handler_for = (
-   set      => \&handle_storage_cmd,
-   add      => \&handle_storage_cmd,
-   replace  => \&handle_storage_cmd,
-   append   => \&handle_storage_cmd,
-   prepend  => \&handle_storage_cmd,
-   cas      => \&handle_storage_cmd,
-   get      => \&handle_retr_cmd,
-   gets     => \&handle_retr_cmd,
-);
-
-sub new {
-   my ( $class, %args ) = @_;
-   my $self = {};
-   return bless $self, $class;
-}
-
-# Given an event from MemcachedProtocolParser, returns an event
-# more suitable for mk-query-digest.
-sub parse_event {
-   my ( $self, %args ) = @_;
-   my $event = $args{event};
-   return unless $event;
-
-   if ( !$event->{cmd} || !$event->{key} ) {
-      PTDEBUG && _d('Event has no cmd or key:', Dumper($event));
-      return;
-   }
-
-   if ( !$cmds{$event->{cmd}} ) {
-      PTDEBUG && _d("Don't know how to handle cmd:", $event->{cmd});
-      return;
-   }
-
-   # For a normal event, arg is the query.  For memcached, the "query" is
-   # essentially the cmd and key, so this becomes arg.  E.g.: "set mk_key".
-   $event->{arg}         = "$event->{cmd} $event->{key}";
-   $event->{fingerprint} = $self->fingerprint($event->{arg});
-   $event->{key_print}   = $self->fingerprint($event->{key});
-
-   # Set every cmd so that aggregated totals will be correct.  If we only
-   # set cmd that we get, then all cmds will show as 100% in the report.
-   # This will create a lot of 0% cmds, but --[no]zero-bool will remove them.
-   # Think of events in a Percona-patched log: the attribs like Full_scan are
-   # present for every event.
-   map { $event->{"Memc_$_"} = 'No' } keys %cmds;
-   $event->{"Memc_$event->{cmd}"} = 'Yes';  # Got this cmd.
-   $event->{Memc_error}           = 'No';  # A handler may change this.
-   $event->{Memc_miss}            = 'No';
-   if ( $event->{res} ) {
-      $event->{Memc_miss}         = 'Yes' if $event->{res} eq 'NOT_FOUND';
-   }
-   else {
-      # This normally happens with incr and decr cmds.
-      PTDEBUG && _d('Event has no res:', Dumper($event));
-   }
-
-   # Handle special results, errors, etc.  The handler should return the
-   # event on success, or nothing on failure.
-   if ( $cmd_handler_for{$event->{cmd}} ) {
-      return $cmd_handler_for{$event->{cmd}}->($event);
-   }
-
-   return $event;
-}
-
-# Replace things that look like placeholders with a ?
-sub fingerprint {
-   my ( $self, $val ) = @_;
-   $val =~ s/[0-9A-Fa-f]{16,}|\d+/?/g;
-   return $val;
-}
-
-# Possible results for storage cmds:
-# - "STORED\r\n", to indicate success.
-#
-# - "NOT_STORED\r\n" to indicate the data was not stored, but not
-#   because of an error. This normally means that either that the
-#   condition for an "add" or a "replace" command wasn't met, or that the
-#   item is in a delete queue (see the "delete" command below).
-#
-# - "EXISTS\r\n" to indicate that the item you are trying to store with
-#   a "cas" command has been modified since you last fetched it.
-#
-# - "NOT_FOUND\r\n" to indicate that the item you are trying to store
-#   with a "cas" command did not exist or has been deleted.
-sub handle_storage_cmd {
-   my ( $event ) = @_;
-
-   # There should be a result for any storage cmd.   
-   if ( !$event->{res} ) {
-      PTDEBUG && _d('No result for event:', Dumper($event));
-      return;
-   }
-
-   $event->{'Memc_Not_Stored'} = $event->{res} eq 'NOT_STORED' ? 'Yes' : 'No';
-   $event->{'Memc_Exists'}     = $event->{res} eq 'EXISTS'     ? 'Yes' : 'No';
-
-   return $event;
-}
-
-# Technically, the only results for a retrieval cmd are the values requested.
-#  "If some of the keys appearing in a retrieval request are not sent back
-#   by the server in the item list this means that the server does not
-#   hold items with such keys (because they were never stored, or stored
-#   but deleted to make space for more items, or expired, or explicitly
-#   deleted by a client)."
-# Contrary to this, MemcacedProtocolParser will set res='VALUE' on
-# success, res='NOT_FOUND' on failure, or res='INTERRUPTED' if the get
-# didn't finish.
-sub handle_retr_cmd {
-   my ( $event ) = @_;
-
-   # There should be a result for any retr cmd.   
-   if ( !$event->{res} ) {
-      PTDEBUG && _d('No result for event:', Dumper($event));
-      return;
-   }
-
-   $event->{'Memc_error'} = $event->{res} eq 'INTERRUPTED' ? 'Yes' : 'No';
-
-   return $event;
-}
-
-# handle_delete() and handle_incr_decr_cmd() are stub subs in case we
-# need them later.
-
-# Possible results for a delete cmd:
-# - "DELETED\r\n" to indicate success
-#
-# - "NOT_FOUND\r\n" to indicate that the item with this key was not
-#   found.
-sub handle_delete {
-   my ( $event ) = @_;
-   return $event;
-}
-
-# Possible results for an incr or decr cmd:
-# - "NOT_FOUND\r\n" to indicate the item with this value was not found
-#
-# - <value>\r\n , where <value> is the new value of the item's data,
-#   after the increment/decrement operation was carried out.
-# On success, MemcachedProtocolParser sets res='' and val=the new val.
-# On failure, res=the result and val=''.
-sub handle_incr_decr_cmd {
-   my ( $event ) = @_;
-   return $event;
-}
-
-sub _d {
-   my ($package, undef, $line) = caller 0;
-   @_ = map { (my $temp = $_) =~ s/\n/\n# /g; $temp; }
-        map { defined $_ ? $_ : 'undef' }
-        @_;
-   print STDERR "# $package:$line $PID ", join(' ', @_), "\n";
-}
-
-1;
-}
-# ###########################################################################
-# End MemcachedEvent package
-# ###########################################################################

=== removed file 'lib/MemcachedProtocolParser.pm'
--- lib/MemcachedProtocolParser.pm	2013-01-03 00:19:16 +0000
+++ lib/MemcachedProtocolParser.pm	1970-01-01 00:00:00 +0000
@@ -1,424 +0,0 @@
-# This program is copyright 2007-2011 Percona Ireland Ltd.
-# Feedback and improvements are welcome.
-#
-# THIS PROGRAM IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
-# WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
-# MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU General Public License as published by the Free Software
-# Foundation, version 2; OR the Perl Artistic License.  On UNIX and similar
-# systems, you can issue `man perlgpl' or `man perlartistic' to read these
-# licenses.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc., 59 Temple
-# Place, Suite 330, Boston, MA  02111-1307  USA.
-# ###########################################################################
-# MemcachedProtocolParser package
-# ###########################################################################
-{
-# Package: MemcachedProtocolParser
-# MemcachedProtocolParser parses memcached events from tcpdump files.
-package MemcachedProtocolParser;
-
-use strict;
-use warnings FATAL => 'all';
-use English qw(-no_match_vars);
-
-use Data::Dumper;
-$Data::Dumper::Indent    = 1;
-$Data::Dumper::Sortkeys  = 1;
-$Data::Dumper::Quotekeys = 0;
-
-use constant PTDEBUG => $ENV{PTDEBUG} || 0;
-
-sub new {
-   my ( $class, %args ) = @_;
-
-   my $self = {
-      server      => $args{server},
-      port        => $args{port} || '11211',
-      sessions    => {},
-      o           => $args{o},
-   };
-   return bless $self, $class;
-}
-
-# The packet arg should be a hashref from TcpdumpParser::parse_event().
-# misc is a placeholder for future features.
-sub parse_event {
-   my ( $self, %args ) = @_;
-   my @required_args = qw(event);
-   foreach my $arg ( @required_args ) {
-      die "I need a $arg argument" unless $args{$arg};
-   }
-   my $packet = @args{@required_args};
-
-   # Return early if there's no TCP data.  These are usually ACK packets, but
-   # they could also be FINs in which case, we should close and delete the
-   # client's session.
-   # TODO: It seems we don't handle FIN here?  So I moved this code block here.
-   if ( $packet->{data_len} == 0 ) {
-      PTDEBUG && _d('No TCP data');
-      $args{stats}->{no_tcp_data}++ if $args{stats};
-      return;
-   }
-
-   my $src_host = "$packet->{src_host}:$packet->{src_port}";
-   my $dst_host = "$packet->{dst_host}:$packet->{dst_port}";
-
-   if ( my $server = $self->{server} ) {  # Watch only the given server.
-      $server .= ":$self->{port}";
-      if ( $src_host ne $server && $dst_host ne $server ) {
-         PTDEBUG && _d('Packet is not to or from', $server);
-         $args{stats}->{not_watched_server}++ if $args{stats};
-         return;
-      }
-   }
-
-   # Auto-detect the server by looking for port 11211
-   my $packet_from;
-   my $client;
-   if ( $src_host =~ m/:$self->{port}$/ ) {
-      $packet_from = 'server';
-      $client      = $dst_host;
-   }
-   elsif ( $dst_host =~ m/:$self->{port}$/ ) {
-      $packet_from = 'client';
-      $client      = $src_host;
-   }
-   else {
-      warn 'Packet is not to or from memcached server: ', Dumper($packet);
-      return;
-   }
-   PTDEBUG && _d('Client:', $client);
-
-   # Get the client's session info or create a new session if the
-   # client hasn't been seen before.
-   if ( !exists $self->{sessions}->{$client} ) {
-      PTDEBUG && _d('New session');
-      $self->{sessions}->{$client} = {
-         client      => $client,
-         state       => undef,
-         raw_packets => [],
-         # ts -- wait for ts later.
-      };
-   };
-   my $session = $self->{sessions}->{$client};
-
-   # Save raw packets to dump later in case something fails.
-   push @{$session->{raw_packets}}, $packet->{raw_packet};
-
-   # Finally, parse the packet and maybe create an event.
-   $packet->{data} = pack('H*', $packet->{data});
-   my $event;
-   if ( $packet_from eq 'server' ) {
-      $event = $self->_packet_from_server($packet, $session, %args);
-   }
-   elsif ( $packet_from eq 'client' ) {
-      $event = $self->_packet_from_client($packet, $session, %args);
-   }
-   else {
-      # Should not get here.
-      $args{stats}->{unknown_packet_origin}++ if $args{stats};
-      die 'Packet origin unknown';
-   }
-
-   PTDEBUG && _d('Done with packet; event:', Dumper($event));
-   $args{stats}->{events_parsed}++ if $args{stats};
-   return $event;
-}
-
-# Handles a packet from the server given the state of the session.  Returns an
-# event if one was ready to be created, otherwise returns nothing.
-sub _packet_from_server {
-   my ( $self, $packet, $session, %args ) = @_;
-   die "I need a packet"  unless $packet;
-   die "I need a session" unless $session;
-
-   PTDEBUG && _d('Packet is from server; client state:', $session->{state}); 
-
-   my $data = $packet->{data};
-
-   # If there's no session state, then we're catching a server response
-   # mid-stream.
-   if ( !$session->{state} ) {
-      PTDEBUG && _d('Ignoring mid-stream server response');
-      $args{stats}->{ignored_midstream_server_response}++ if $args{stats};
-      return;
-   }
-
-   # Assume that the server is returning only one value.  TODO: make it
-   # handle multi-gets.
-   if ( $session->{state} eq 'awaiting reply' ) {
-      PTDEBUG && _d('State is awaiting reply');
-      # \r\n == 0d0a
-      my ($line1, $rest) = $packet->{data} =~ m/\A(.*?)\r\n(.*)?/s;
-      if ( !$line1 ) {
-         $args{stats}->{unknown_server_data}++ if $args{stats};
-         die "Unknown memcached data from server";
-      }
-
-      # Split up the first line into its parts.
-      my @vals = $line1 =~ m/(\S+)/g;
-      $session->{res} = shift @vals;
-      PTDEBUG && _d('Result of last', $session->{cmd}, 'cmd:', $session->{res});
-
-      if ( $session->{cmd} eq 'incr' || $session->{cmd} eq 'decr' ) {
-         PTDEBUG && _d('It is an incr or decr');
-         if ( $session->{res} !~ m/\D/ ) { # It's an integer, not an error
-            PTDEBUG && _d('Got a value for the incr/decr');
-            $session->{val} = $session->{res};
-            $session->{res} = '';
-         }
-      }
-      elsif ( $session->{res} eq 'VALUE' ) {
-         PTDEBUG && _d('It is the result of a "get"');
-         my ($key, $flags, $bytes) = @vals;
-         defined $session->{flags} or $session->{flags} = $flags;
-         defined $session->{bytes} or $session->{bytes} = $bytes;
-
-         # Get the value from the $rest.
-         # TODO: there might be multiple responses
-         if ( $rest && $bytes ) {
-            PTDEBUG && _d('There is a value');
-            if ( length($rest) > $bytes ) {
-               PTDEBUG && _d('Got complete response');
-               $session->{val} = substr($rest, 0, $bytes);
-            }
-            else {
-               PTDEBUG && _d('Got partial response, saving for later');
-               push @{$session->{partial}}, [ $packet->{seq}, $rest ];
-               $session->{gathered} += length($rest);
-               $session->{state} = 'partial recv';
-               return; # Prevent firing an event.
-            }
-         }
-      }
-      elsif ( $session->{res} eq 'END' ) {
-         # Technically NOT_FOUND is an error, and this isn't an error it's just
-         # a NULL, but what it really means is the value isn't found.
-         PTDEBUG && _d('Got an END without any data, firing NOT_FOUND');
-         $session->{res} = 'NOT_FOUND';
-      }
-      elsif ( $session->{res} !~ m/STORED|DELETED|NOT_FOUND/ ) {
-         # Not really sure what else would get us here... want to make a note
-         # and not have an uncaught condition.
-         PTDEBUG && _d('Unknown result');
-      }
-      else {
-         $args{stats}->{unknown_server_response}++ if $args{stats};
-      }
-   }
-   else { # Should be 'partial recv'
-      PTDEBUG && _d('Session state: ', $session->{state});
-      push @{$session->{partial}}, [ $packet->{seq}, $data ];
-      $session->{gathered} += length($data);
-      PTDEBUG && _d('Gathered', $session->{gathered}, 'bytes in',
-         scalar(@{$session->{partial}}), 'packets from server');
-      if ( $session->{gathered} >= $session->{bytes} + 2 ) { # Done.
-         PTDEBUG && _d('End of partial response, preparing event');
-         my $val = join('',
-            map  { $_->[1] }
-            # Sort in proper sequence because TCP might reorder them.
-            sort { $a->[0] <=> $b->[0] }
-                 @{$session->{partial}});
-         $session->{val} = substr($val, 0, $session->{bytes});
-      }
-      else {
-         PTDEBUG && _d('Partial response continues, no action');
-         return; # Prevent firing event.
-      }
-   }
-
-   PTDEBUG && _d('Creating event, deleting session');
-   my $event = make_event($session, $packet);
-   delete $self->{sessions}->{$session->{client}}; # memcached is stateless!
-   $session->{raw_packets} = []; # Avoid keeping forever
-   return $event;
-}
-
-# Handles a packet from the client given the state of the session.
-sub _packet_from_client {
-   my ( $self, $packet, $session, %args ) = @_;
-   die "I need a packet"  unless $packet;
-   die "I need a session" unless $session;
-
-   PTDEBUG && _d('Packet is from client; state:', $session->{state});
-
-   my $event;
-   if ( ($session->{state} || '') =~m/awaiting reply|partial recv/ ) {
-      # Whoa, we expected something from the server, not the client.  Fire an
-      # INTERRUPTED with what we've got, and create a new session.
-      PTDEBUG && _d("Expected data from the client, looks like interrupted");
-      $session->{res} = 'INTERRUPTED';
-      $event = make_event($session, $packet);
-      my $client = $session->{client};
-      delete @{$session}{keys %$session};
-      $session->{client} = $client;
-   }
-
-   my ($line1, $val);
-   my ($cmd, $key, $flags, $exptime, $bytes);
-   
-   if ( !$session->{state} ) {
-      PTDEBUG && _d('Session state: ', $session->{state});
-      # Split up the first line into its parts.
-      ($line1, $val) = $packet->{data} =~ m/\A(.*?)\r\n(.+)?/s;
-      if ( !$line1 ) {
-         PTDEBUG && _d('Unknown memcached data from client, skipping packet');
-         $args{stats}->{unknown_client_data}++ if $args{stats};
-         return;
-      }
-
-      # TODO: handle <cas unique> and [noreply]
-      my @vals = $line1 =~ m/(\S+)/g;
-      $cmd = lc shift @vals;
-      PTDEBUG && _d('$cmd is a ', $cmd);
-      if ( $cmd eq 'set' || $cmd eq 'add' || $cmd eq 'replace' ) {
-         ($key, $flags, $exptime, $bytes) = @vals;
-         $session->{bytes} = $bytes;
-      }
-      elsif ( $cmd eq 'get' ) {
-         ($key) = @vals;
-         if ( $val ) {
-            PTDEBUG && _d('Multiple cmds:', $val);
-            $val = undef;
-         }
-      }
-      elsif ( $cmd eq 'delete' ) {
-         ($key) = @vals; # TODO: handle the <queue_time>
-         if ( $val ) {
-            PTDEBUG && _d('Multiple cmds:', $val);
-            $val = undef;
-         }
-      }
-      elsif ( $cmd eq 'incr' || $cmd eq 'decr' ) {
-         ($key) = @vals;
-      }
-      else {
-         PTDEBUG && _d("Don't know how to handle", $cmd, "command");
-         $args{stats}->{unknown_client_command}++ if $args{stats};
-         return;
-      }
-
-      @{$session}{qw(cmd key flags exptime)}
-         = ($cmd, $key, $flags, $exptime);
-      $session->{host}       = $packet->{src_host};
-      $session->{pos_in_log} = $packet->{pos_in_log};
-      $session->{ts}         = $packet->{ts};
-   }
-   else {
-      PTDEBUG && _d('Session state: ', $session->{state});
-      $val = $packet->{data};
-   }
-
-   # Handle the rest of the packet.  It might not be the whole value that was
-   # sent, for example for a big set().  We need to look at the number of bytes
-   # and see if we got it all.
-   $session->{state} = 'awaiting reply'; # Assume we got the whole packet
-   if ( $val ) {
-      if ( $session->{bytes} + 2 == length($val) ) { # +2 for the \r\n
-         PTDEBUG && _d('Complete send');
-         $val =~ s/\r\n\Z//; # We got the whole thing.
-         $session->{val} = $val;
-      }
-      else { # We apparently did NOT get the whole thing.
-         PTDEBUG && _d('Partial send, saving for later');
-         push @{$session->{partial}},
-            [ $packet->{seq}, $val ];
-         $session->{gathered} += length($val);
-         PTDEBUG && _d('Gathered', $session->{gathered}, 'bytes in',
-            scalar(@{$session->{partial}}), 'packets from client');
-         if ( $session->{gathered} >= $session->{bytes} + 2 ) { # Done.
-            PTDEBUG && _d('Message looks complete now, saving value');
-            $val = join('',
-               map  { $_->[1] }
-               # Sort in proper sequence because TCP might reorder them.
-               sort { $a->[0] <=> $b->[0] }
-                    @{$session->{partial}});
-            $val =~ s/\r\n\Z//;
-            $session->{val} = $val;
-         }
-         else {
-            PTDEBUG && _d('Message not complete');
-            $val = '[INCOMPLETE]';
-            $session->{state} = 'partial send';
-         }
-      }
-   }
-
-   return $event;
-}
-
-# The event is not yet suitable for mk-query-digest.  It lacks, for example,
-# an arg and fingerprint attribute.  The event should be passed to
-# MemcachedEvent::make_event() to transform it.
-sub make_event {
-   my ( $session, $packet ) = @_;
-   my $event = {
-      cmd        => $session->{cmd},
-      key        => $session->{key},
-      val        => $session->{val} || '',
-      res        => $session->{res},
-      ts         => $session->{ts},
-      host       => $session->{host},
-      flags      => $session->{flags}   || 0,
-      exptime    => $session->{exptime} || 0,
-      bytes      => $session->{bytes}   || 0,
-      Query_time => timestamp_diff($session->{ts}, $packet->{ts}),
-      pos_in_log => $session->{pos_in_log},
-   };
-   return $event;
-}
-
-sub _get_errors_fh {
-   my ( $self ) = @_;
-   my $errors_fh = $self->{errors_fh};
-   return $errors_fh if $errors_fh;
-
-   # Errors file isn't open yet; try to open it.
-   my $o = $self->{o};
-   if ( $o && $o->has('tcpdump-errors') && $o->got('tcpdump-errors') ) {
-      my $errors_file = $o->get('tcpdump-errors');
-      PTDEBUG && _d('tcpdump-errors file:', $errors_file);
-      open $errors_fh, '>>', $errors_file
-         or die "Cannot open tcpdump-errors file $errors_file: $OS_ERROR";
-   }
-
-   $self->{errors_fh} = $errors_fh;
-   return $errors_fh;
-}
-
-sub _d {
-   my ($package, undef, $line) = caller 0;
-   @_ = map { (my $temp = $_) =~ s/\n/\n# /g; $temp; }
-        map { defined $_ ? $_ : 'undef' }
-        @_;
-   print STDERR "# $package:$line $PID ", join(' ', @_), "\n";
-}
-
-# Returns the difference between two tcpdump timestamps.  TODO: this is in
-# MySQLProtocolParser too, best to factor it out somewhere common.
-sub timestamp_diff {
-   my ( $start, $end ) = @_;
-   my $sd = substr($start, 0, 11, '');
-   my $ed = substr($end,   0, 11, '');
-   my ( $sh, $sm, $ss ) = split(/:/, $start);
-   my ( $eh, $em, $es ) = split(/:/, $end);
-   my $esecs = ($eh * 3600 + $em * 60 + $es);
-   my $ssecs = ($sh * 3600 + $sm * 60 + $ss);
-   if ( $sd eq $ed ) {
-      return sprintf '%.6f', $esecs - $ssecs;
-   }
-   else { # Assume only one day boundary has been crossed, no DST, etc
-      return sprintf '%.6f', ( 86_400 - $ssecs ) + $esecs;
-   }
-}
-
-1;
-}
-# ###########################################################################
-# End MemcachedProtocolParser package
-# ###########################################################################

=== removed file 'lib/PgLogParser.pm'
--- lib/PgLogParser.pm	2013-01-03 00:19:16 +0000
+++ lib/PgLogParser.pm	1970-01-01 00:00:00 +0000
@@ -1,669 +0,0 @@
-# This program is copyright 2010-2011 Baron Schwartz, 2011 Percona Ireland Ltd.
-# Feedback and improvements are welcome.
-#
-# THIS PROGRAM IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
-# WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
-# MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU General Public License as published by the Free Software
-# Foundation, version 2; OR the Perl Artistic License.  On UNIX and similar
-# systems, you can issue `man perlgpl' or `man perlartistic' to read these
-# licenses.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc., 59 Temple
-# Place, Suite 330, Boston, MA  02111-1307  USA.
-# ###########################################################################
-# PgLogParser package
-# ###########################################################################
-{
-# Package: PgLogParser
-# PgLogParser parses Postgres logs.
-package PgLogParser;
-
-use strict;
-use warnings FATAL => 'all';
-use English qw(-no_match_vars);
-use constant PTDEBUG => $ENV{PTDEBUG} || 0;
-
-use Data::Dumper;
-$Data::Dumper::Indent    = 1;
-$Data::Dumper::Sortkeys  = 1;
-$Data::Dumper::Quotekeys = 0;
-
-# This regex is partially inspired by one from pgfouine.  But there is no
-# documentation on the last capture in that regex, so I omit that.  (TODO: that
-# actually seems to be for CSV logging.)
-#     (?:[0-9XPFDBLA]{2}[0-9A-Z]{3}:[\s]+)?
-# Here I constrain to match at least two spaces after the severity level,
-# because the source code tells me to.  I believe this is controlled in elog.c:
-# appendStringInfo(&buf, "%s:  ", error_severity(edata->elevel));
-my $log_line_regex = qr{
-   (LOG|DEBUG|CONTEXT|WARNING|ERROR|FATAL|PANIC|HINT
-    |DETAIL|NOTICE|STATEMENT|INFO|LOCATION)
-   :\s\s+
-   }x;
-
-# The following are taken right from the comments in postgresql.conf for
-# log_line_prefix.
-my %attrib_name_for = (
-   u => 'user',
-   d => 'db',
-   r => 'host', # With port
-   h => 'host',
-   p => 'Process_id',
-   t => 'ts',
-   m => 'ts',   # With milliseconds
-   i => 'Query_type',
-   c => 'Session_id',
-   l => 'Line_no',
-   s => 'Session_id',
-   v => 'Vrt_trx_id',
-   x => 'Trx_id',
-);
-
-# This class's data structure is a hashref with some statefulness: pending
-# lines.  This is necessary because we sometimes don't know whether the event is
-# complete until we read the next line or even several lines, so we store these.
-#
-# Another bit of data that's stored in $self is some code to automatically
-# translate syslog into plain log format.
-sub new {
-   my ( $class ) = @_;
-   my $self = {
-      pending    => [],
-      is_syslog  => undef,
-      next_event => undef,
-      'tell'     => undef,
-   };
-   return bless $self, $class;
-}
-
-# This method accepts an iterator that contains an open log filehandle.  It
-# reads events from the filehandle by calling the iterator, and returns the
-# events.
-#
-# Each event is a hashref of attribute => value pairs like:
-#  my $event = {
-#     ts  => '',    # Timestamp
-#     arg => '',    # Argument to the command
-#     other attributes...
-#  };
-#
-# The log format is ideally prefixed with the following:
-#
-#  * timestamp with microseconds
-#  * session ID, user, database
-#
-# The format I'd like to see is something like this:
-#
-# 2010-02-08 15:31:48.685 EST c=4b7074b4.985,u=user,D=database LOG:
-#
-# However, pgfouine supports user=user, db=database format.  And I think
-# it should be reasonable to grab pretty much any name=value properties out, and
-# handle them based on the lower-cased first character of $name, to match the
-# special values that are possible to give for log_line_prefix. For example, %u
-# = user, so anything starting with a 'u' should be interpreted as a user.
-#
-# In general the log format is rather flexible, and we don't know by looking at
-# any given line whether it's the last line in the event.  So we often have to
-# read a line and then decide what to do with the previous line we saw.  Thus we
-# use 'pending' when necessary but we try to do it as little as possible,
-# because it's double work to defer and re-parse lines; and we try to defer as
-# soon as possible so we don't have to do as much work.
-#
-# There are 3 categories of lines in a log file, referred to in the code as case
-# 1/2/3:
-#
-# - Those that start a possibly multi-line event
-# - Those that can continue one
-# - Those that are neither the start nor the continuation, and thus must be the
-#   end.
-#
-# In cases 1 and 3, we have to check whether information from previous lines has
-# been accumulated.  If it has, we defer the current line and create the event.
-# Otherwise we keep going, looking for more lines for the event that begins with
-# the current line.  Processing the lines is easiest if we arrange the cases in
-# this order: 2, 1, 3.
-#
-# The term "line" is to be interpreted loosely here.  Logs that are in syslog
-# format might have multi-line "lines" that are handled by the generated
-# $next_event closure and given back to the main while-loop with newlines in
-# them.  Therefore, regexes that match "the rest of the line" generally need the
-# /s flag.
-sub parse_event {
-   my ( $self, %args ) = @_;
-   my @required_args = qw(next_event tell);
-   foreach my $arg ( @required_args ) {
-      die "I need a $arg argument" unless $args{$arg};
-   }
-
-   # The subroutine references that wrap the filehandle operations.
-   my ( $next_event, $tell, $is_syslog ) = $self->generate_wrappers(%args);
-
-   # These are the properties for the log event, which will later be used to
-   # create an event hash ref.
-   my @properties = ();
-
-   # Holds the current line being processed, and its position in the log as a
-   # byte offset from the beginning.  In some cases we'll have to reset this
-   # position later.  We'll also have to take a wait-and-see attitude towards
-   # the $pos_in_log, so we use $new_pos to record where we're working in the
-   # log, and $pos_in_log to record where the beginning of the current event
-   # started.
-   my ($pos_in_log, $line, $was_pending) = $self->get_line();
-   my $new_pos;
-
-   # Sometimes we need to accumulate some lines and then join them together.
-   # This is used for that.
-   my @arg_lines;
-
-   # This is used to signal that an entire event has been found, and thus exit
-   # the while loop.
-   my $done;
-
-   # This is used to signal that an event's duration has already been found.
-   # See the sample file pg-syslog-001.txt and the test for it.
-   my $got_duration;
-
-   # Before we start, we read and discard lines until we get one with a header.
-   # The only thing we can really count on is that a header line should have
-   # the header in it.  But, we only do this if we aren't in the middle of an
-   # ongoing event, whose first line was pending.
-   if ( !$was_pending && (!defined $line || $line !~ m/$log_line_regex/o) ) {
-      PTDEBUG && _d('Skipping lines until I find a header');
-      my $found_header;
-      LINE:
-      while (
-         eval {
-            ($new_pos, $line) = $self->get_line();
-            defined $line;
-         }
-      ) {
-         if ( $line =~ m/$log_line_regex/o ) {
-            $pos_in_log = $new_pos;
-            last LINE;
-         }
-         else {
-            PTDEBUG && _d('Line was not a header, will fetch another');
-         }
-      }
-      PTDEBUG && _d('Found a header line, now at pos_in_line', $pos_in_log);
-   }
-
-   # We need to keep the line that begins the event we're parsing.
-   my $first_line;
-
-   # This is for holding the type of the log line, which is important for
-   # choosing the right code to run.
-   my $line_type;
-
-   # Parse each line.
-   LINE:
-   while ( !$done && defined $line ) {
-
-      # Throw away the newline ending.
-      chomp $line unless $is_syslog;
-
-      # This while loop works with LOG lines.  Other lines, such as ERROR and
-      # so forth, need to be handled outside this loop.  The exception is when
-      # there's nothing in progress in @arg_lines, and the non-LOG line might
-      # just be something we can get relevant info from.
-      if ( (($line_type) = $line =~ m/$log_line_regex/o) && $line_type ne 'LOG' ) {
-
-         # There's something in progress, so we abort the loop and let it be
-         # handled specially.
-         if ( @arg_lines ) {
-            PTDEBUG && _d('Found a non-LOG line, exiting loop');
-            last LINE;
-         }
-
-         # There's nothing in @arg_lines, so we save what info we can and keep
-         # on going.
-         else {
-            $first_line ||= $line;
-
-            # Handle ERROR and STATEMENT lines...
-            if ( my ($e) = $line =~ m/ERROR:\s+(\S.*)\Z/s ) {
-               push @properties, 'Error_msg', $e;
-               PTDEBUG && _d('Found an error msg, saving and continuing');
-               ($new_pos, $line) = $self->get_line();
-               next LINE;
-            }
-
-            elsif ( my ($s) = $line =~ m/STATEMENT:\s+(\S.*)\Z/s ) {
-               push @properties, 'arg', $s, 'cmd', 'Query';
-               PTDEBUG && _d('Found a statement, finishing up event');
-               $done = 1;
-               last LINE;
-            }
-
-            else {
-               PTDEBUG && _d("I don't know what to do with this line");
-            }
-         }
-
-      }
-
-      # The log isn't just queries.  It also has status and informational lines
-      # in it.  We ignore these, but if we see one that's not recognized, we
-      # warn.  These types of things are better off in mk-error-log.
-      if (
-         $line =~ m{
-            Address\sfamily\snot\ssupported\sby\sprotocol
-            |archived\stransaction\slog\sfile
-            |autovacuum:\sprocessing\sdatabase
-            |checkpoint\srecord\sis\sat
-            |checkpoints\sare\soccurring\stoo\sfrequently\s\(
-            |could\snot\sreceive\sdata\sfrom\sclient
-            |database\ssystem\sis\sready
-            |database\ssystem\sis\sshut\sdown
-            |database\ssystem\swas\sshut\sdown
-            |incomplete\sstartup\spacket
-            |invalid\slength\sof\sstartup\spacket
-            |next\sMultiXactId:
-            |next\stransaction\sID:
-            |received\ssmart\sshutdown\srequest
-            |recycled\stransaction\slog\sfile
-            |redo\srecord\sis\sat
-            |removing\sfile\s"
-            |removing\stransaction\slog\sfile\s"
-            |shutting\sdown
-            |transaction\sID\swrap\slimit\sis
-         }x
-      ) {
-         # We get the next line to process and skip the rest of the loop.
-         PTDEBUG && _d('Skipping this line because it matches skip-pattern');
-         ($new_pos, $line) = $self->get_line();
-         next LINE;
-      }
-
-      # Possibly reset $first_line, depending on whether it was determined to be
-      # junk and unset.
-      $first_line ||= $line;
-
-      # Case 2: non-header lines, optionally starting with a TAB, are a
-      # continuation of the previous line.
-      if ( $line !~ m/$log_line_regex/o && @arg_lines ) {
-
-         if ( !$is_syslog ) {
-            # We need to translate tabs to newlines.  Weirdly, some logs (see
-            # samples/pg-log-005.txt) have newlines without a leading tab.
-            # Maybe it's an older log format.
-            $line =~ s/\A\t?/\n/;
-         }
-
-         # Save the remainder.
-         push @arg_lines, $line;
-         PTDEBUG && _d('This was a continuation line');
-      }
-
-      # Cases 1 and 3: These lines start with some optional meta-data, and then
-      # the $log_line_regex followed by the line's log message.  The message can be
-      # of the form "label: text....".  Examples:
-      # LOG:  duration: 1.565 ms
-      # LOG:  statement: SELECT ....
-      # LOG:  duration: 1.565 ms  statement: SELECT ....
-      # In the above examples, the $label is duration, statement, and duration.
-      elsif (
-         my ( $sev, $label, $rest )
-            = $line =~ m/$log_line_regex(.+?):\s+(.*)\Z/so
-      ) {
-         PTDEBUG && _d('Line is case 1 or case 3');
-
-         # This is either a case 1 or case 3.  If there's previously gathered
-         # data in @arg_lines, it doesn't matter which -- we have to create an
-         # event (a Query event), and we're $done.  This is case 0xdeadbeef.
-         if ( @arg_lines ) {
-            $done = 1;
-            PTDEBUG && _d('There are saved @arg_lines, we are done');
-
-            # We shouldn't modify @properties based on $line, because $line
-            # doesn't have anything to do with the stuff in @properties, which
-            # is all related to the previous line(s).  However, there is one
-            # case in which the line could be part of the event: when it's a
-            # plain 'duration' line.  This happens when the statement is logged
-            # on one line, and then the duration is logged afterwards.  If this
-            # is true, then we alter @properties, and we do NOT defer the current
-            # line.
-            if ( $label eq 'duration' && $rest =~ m/[0-9.]+\s+\S+\Z/ ) {
-               if ( $got_duration ) {
-                  # Just discard the line.
-                  PTDEBUG && _d('Discarding line, duration already found');
-               }
-               else {
-                  push @properties, 'Query_time', $self->duration_to_secs($rest);
-                  PTDEBUG && _d("Line's duration is for previous event:", $rest);
-               }
-            }
-            else {
-               # We'll come back to this line later.
-               $self->pending($new_pos, $line);
-               PTDEBUG && _d('Deferred line');
-            }
-         }
-
-         # Here we test for case 1, lines that can start a multi-line event.
-         elsif ( $label =~ m/\A(?:duration|statement|query)\Z/ ) {
-            PTDEBUG && _d('Case 1: start a multi-line event');
-
-            # If it's a duration, then there might be a statement later on the
-            # same line and the duration applies to that.
-            if ( $label eq 'duration' ) {
-
-               if (
-                  (my ($dur, $stmt)
-                     = $rest =~ m/([0-9.]+ \S+)\s+(?:statement|query): *(.*)\Z/s)
-               ) {
-                  # It does, so we'll pull out the Query_time etc now, rather
-                  # than doing it later, when we might end up in the case above
-                  # (case 0xdeadbeef).
-                  push @properties, 'Query_time', $self->duration_to_secs($dur);
-                  $got_duration = 1;
-                  push @arg_lines, $stmt;
-                  PTDEBUG && _d('Duration + statement');
-               }
-
-               else {
-                  # The duration line is just junk.  It's the line after a
-                  # statement, but we never saw the statement (else we'd have
-                  # fallen into 0xdeadbeef above).  Discard this line and adjust
-                  # pos_in_log.  See t/samples/pg-log-002.txt for an example.
-                  $first_line = undef;
-                  ($pos_in_log, $line) = $self->get_line();
-                  PTDEBUG && _d('Line applies to event we never saw, discarding');
-                  next LINE;
-               }
-            }
-            else {
-               # This isn't a duration line, it's a statement or query.  Put it
-               # onto @arg_lines for later and keep going.
-               push @arg_lines, $rest;
-               PTDEBUG && _d('Putting onto @arg_lines');
-            }
-         }
-
-         # Here is case 3, lines that can't be in case 1 or 2.  These surely
-         # terminate any event that's been accumulated, and if there isn't any
-         # such, then we just create an event without the overhead of deferring.
-         else {
-            $done = 1;
-            PTDEBUG && _d('Line is case 3, event is done');
-
-            # Again, if there's previously gathered data in @arg_lines, we have
-            # to defer the current line (not touching @properties) and revisit it.
-            if ( @arg_lines ) {
-               $self->pending($new_pos, $line);
-               PTDEBUG && _d('There was @arg_lines, putting line to pending');
-            }
-
-            # Otherwise we can parse the line and put it into @properties.
-            else {
-               PTDEBUG && _d('No need to defer, process event from this line now');
-               push @properties, 'cmd', 'Admin', 'arg', $label;
-
-               # For some kinds of log lines, we can grab extra meta-data out of
-               # the end of the line.
-               # LOG:  connection received: host=[local]
-               if ( $label =~ m/\A(?:dis)?connection(?: received| authorized)?\Z/ ) {
-                  push @properties, $self->get_meta($rest);
-               }
-
-               else {
-                  die "I don't understand line $line";
-               }
-
-            }
-         }
-
-      }
-
-      # If the line isn't case 1, 2, or 3 I don't know what it is.
-      else {
-         die "I don't understand line $line";
-      }
-
-      # We get the next line to process.
-      if ( !$done ) {
-         ($new_pos, $line) = $self->get_line();
-      }
-   } # LINE
-
-   # If we're at the end of the file, we finish and tell the caller we're done.
-   if ( !defined $line ) {
-      PTDEBUG && _d('Line not defined, at EOF; calling oktorun(0) if exists');
-      $args{oktorun}->(0) if $args{oktorun};
-      if ( !@arg_lines ) {
-         PTDEBUG && _d('No saved @arg_lines either, we are all done');
-         return undef;
-      }
-   }
-
-   # If we got kicked out of the while loop because of a non-LOG line, we handle
-   # that line here.
-   if ( $line_type && $line_type ne 'LOG' ) {
-      PTDEBUG && _d('Line is not a LOG line');
-
-      # ERROR lines come in a few flavors.  See t/samples/pg-log-006.txt,
-      # t/samples/pg-syslog-002.txt, and t/samples/pg-syslog-007.txt for some
-      # examples.  The rules seem to be this: if the ERROR is followed by a
-      # STATEMENT, and the STATEMENT's statement matches the query in
-      # @arg_lines, then the STATEMENT message is redundant.  (This can be
-      # caused by various combos of configuration options in postgresql.conf).
-      # However, if the ERROR's STATEMENT line doesn't match what's in
-      # @arg_lines, then the ERROR actually starts a new event.  If the ERROR is
-      # followed by another LOG event, then the ERROR also starts a new event.
-      if ( $line_type eq 'ERROR' ) {
-         PTDEBUG && _d('Line is ERROR');
-
-         # If there's already a statement in processing, then put aside the
-         # current line, and peek ahead.
-         if ( @arg_lines ) {
-            PTDEBUG && _d('There is @arg_lines, will peek ahead one line');
-            my ( $temp_pos, $temp_line ) = $self->get_line();
-            my ( $type, $msg );
-            if (
-               defined $temp_line
-               && ( ($type, $msg) = $temp_line =~ m/$log_line_regex(.*)/o )
-               && ( $type ne 'STATEMENT' || $msg eq $arg_lines[-1] )
-            ) {
-               # Looks like the whole thing is pertaining to the current event
-               # in progress.  Add the error message to the event.
-               PTDEBUG && _d('Error/statement line pertain to current event');
-               push @properties, 'Error_msg', $line =~ m/ERROR:\s*(\S.*)\Z/s;
-               if ( $type ne 'STATEMENT' ) {
-                  PTDEBUG && _d('Must save peeked line, it is a', $type);
-                  $self->pending($temp_pos, $temp_line);
-               }
-            }
-            elsif ( defined $temp_line && defined $type ) {
-               # Looks like the current and next line are about a new event.
-               # Put them into pending.
-               PTDEBUG && _d('Error/statement line are a new event');
-               $self->pending($new_pos, $line);
-               $self->pending($temp_pos, $temp_line);
-            }
-            else {
-               PTDEBUG && _d("Unknown line", $line);
-            }
-         }
-      }
-      else {
-         PTDEBUG && _d("Unknown line", $line);
-      }
-   }
-
-   # If $done is true, then some of the above code decided that the full
-   # event has been found.  If we reached the end of the file, then we might
-   # also have something in @arg_lines, although we didn't find the "line after"
-   # that signals the event was done.  In either case we return an event.  This
-   # should be the only 'return' statement in this block of code.
-   if ( $done || @arg_lines ) {
-      PTDEBUG && _d('Making event');
-
-      # Finish building the event.
-      push @properties, 'pos_in_log', $pos_in_log;
-
-      # Statement/query lines will be in @arg_lines.
-      if ( @arg_lines ) {
-         PTDEBUG && _d('Assembling @arg_lines: ', scalar @arg_lines);
-         push @properties, 'arg', join('', @arg_lines), 'cmd', 'Query';
-      }
-
-      if ( $first_line ) {
-         # Handle some meta-data: a timestamp, with optional milliseconds.
-         if ( my ($ts) = $first_line =~ m/([0-9-]{10} [0-9:.]{8,12})/ ) {
-            PTDEBUG && _d('Getting timestamp', $ts);
-            push @properties, 'ts', $ts;
-         }
-
-         # Find meta-data embedded in the log line prefix, in name=value format.
-         if ( my ($meta) = $first_line =~ m/(.*?)[A-Z]{3,}:  / ) {
-            PTDEBUG && _d('Found a meta-data chunk:', $meta);
-            push @properties, $self->get_meta($meta);
-         }
-      }
-
-      # Dump info about what we've found, but don't dump $event; want to see
-      # full dump of all properties, and after it's been cast into a hash,
-      # duplicated keys will be gone.
-      PTDEBUG && _d('Properties of event:', Dumper(\@properties));
-      my $event = { @properties };
-      $event->{bytes} = length($event->{arg} || '');
-      return $event;
-   }
-
-}
-
-# Parses key=value meta-data from the $meta string, and returns a list of event
-# attribute names and values.
-sub get_meta {
-   my ( $self, $meta ) = @_;
-   my @properties;
-   foreach my $set ( $meta =~ m/(\w+=[^, ]+)/g ) {
-      my ($key, $val) = split(/=/, $set);
-      if ( $key && $val ) {
-         # The first letter of the name, lowercased, determines the
-         # meaning of the item.
-         if ( my $prop = $attrib_name_for{lc substr($key, 0, 1)} ) {
-            push @properties, $prop, $val;
-         }
-         else {
-            PTDEBUG && _d('Bad meta key', $set);
-         }
-      }
-      else {
-         PTDEBUG && _d("Can't figure out meta from", $set);
-      }
-   }
-   return @properties;
-}
-
-# This subroutine abstracts the process and source of getting a line of text and
-# its position in the log file.  It might get the line of text from the log; it
-# might get it from the @pending array.  It also does infinite loop checking
-# TODO.
-sub get_line {
-   my ( $self ) = @_;
-   my ($pos, $line, $was_pending) = $self->pending;
-   if ( ! defined $line ) {
-      PTDEBUG && _d('Got nothing from pending, trying the $fh');
-      my ( $next_event, $tell) = @{$self}{qw(next_event tell)};
-      eval {
-         $pos  = $tell->();
-         $line = $next_event->();
-      };
-      if ( PTDEBUG && $EVAL_ERROR ) {
-         _d($EVAL_ERROR);
-      }
-   }
-
-   PTDEBUG && _d('Got pos/line:', $pos, $line);
-   return ($pos, $line);
-}
-
-# This subroutine defers and retrieves a line/pos pair.  If you give it an
-# argument it'll set the stored value.  If not, it'll get one if there is one
-# and return it.
-sub pending {
-   my ( $self, $val, $pos_in_log ) = @_;
-   my $was_pending;
-   PTDEBUG && _d('In sub pending, val:', $val);
-   if ( $val ) {
-      push @{$self->{pending}}, [$val, $pos_in_log];
-   }
-   elsif ( @{$self->{pending}} ) {
-      ($val, $pos_in_log) = @{ shift @{$self->{pending}} };
-      $was_pending = 1;
-   }
-   PTDEBUG && _d('Return from pending:', $val, $pos_in_log);
-   return ($val, $pos_in_log, $was_pending);
-}
-
-# This subroutine manufactures subroutines to automatically translate incoming
-# syslog format into standard log format, to keep the main parse_event free from
-# having to think about that.  For documentation on how this works, see
-# SysLogParser.pm.
-sub generate_wrappers {
-   my ( $self, %args ) = @_;
-
-   # Reset everything, just in case some cruft was left over from a previous use
-   # of this object.  The object has stateful closures.  If this isn't done,
-   # then they'll keep reading from old filehandles.  The sanity check is based
-   # on the memory address of the closure!
-   if ( ($self->{sanity} || '') ne "$args{next_event}" ){
-      PTDEBUG && _d("Clearing and recreating internal state");
-      eval { require SysLogParser; }; # Required for tests to work.
-      my $sl = new SysLogParser();
-
-      # We need a special item in %args for syslog parsing.  (This might not be
-      # a syslog log file...)  See the test for t/samples/pg-syslog-002.txt for
-      # an example of when this is needed.
-      $args{misc}->{new_event_test} = sub {
-         my ( $content ) = @_;
-         return unless defined $content;
-         return $content =~ m/$log_line_regex/o;
-      };
-
-      # The TAB at the beginning of the line indicates that there's a newline
-      # at the end of the previous line.
-      $args{misc}->{line_filter} = sub {
-         my ( $content ) = @_;
-         $content =~ s/\A\t/\n/;
-         return $content;
-      };
-
-      @{$self}{qw(next_event tell is_syslog)} = $sl->make_closures(%args);
-      $self->{sanity} = "$args{next_event}";
-   }
-
-   # Return the wrapper functions!
-   return @{$self}{qw(next_event tell is_syslog)};
-}
-
-# This subroutine converts various formats to seconds.  Examples:
-# 10.870 ms
-sub duration_to_secs {
-   my ( $self, $str ) = @_;
-   PTDEBUG && _d('Duration:', $str);
-   my ( $num, $suf ) = split(/\s+/, $str);
-   my $factor = $suf eq 'ms'  ? 1000
-              : $suf eq 'sec' ? 1
-              :                 die("Unknown suffix '$suf'");
-   return $num / $factor;
-}
-
-sub _d {
-   my ($package, undef, $line) = caller 0;
-   @_ = map { (my $temp = $_) =~ s/\n/\n# /g; $temp; }
-        map { defined $_ ? $_ : 'undef' }
-        @_;
-   print STDERR "# $package:$line $PID ", join(' ', @_), "\n";
-}
-
-1;
-}
-# ###########################################################################
-# End PgLogParser package
-# ###########################################################################

=== modified file 'lib/QueryReportFormatter.pm'
--- lib/QueryReportFormatter.pm	2013-01-31 17:52:34 +0000
+++ lib/QueryReportFormatter.pm	2013-02-01 18:19:34 +0000
@@ -481,9 +481,7 @@
          }
 
          my $log_type = $args{log_type} || '';
-         my $mark     = $log_type eq 'memcached'
-                     || $log_type eq 'http'
-                     || $log_type eq 'pglog' ? '' : '\G';
+         my $mark     = '\G';
 
          if ( $item =~ m/^(?:[\(\s]*select|insert|replace)/ ) {
             if ( $item =~ m/^(?:insert|replace)/ ) { # No EXPLAIN

=== removed file 'lib/SysLogParser.pm'
--- lib/SysLogParser.pm	2013-01-03 00:19:16 +0000
+++ lib/SysLogParser.pm	1970-01-01 00:00:00 +0000
@@ -1,259 +0,0 @@
-# This program is copyright 2010-2011 Baron Schwartz, 2011 Percona Ireland Ltd.
-# Feedback and improvements are welcome.
-#
-# THIS PROGRAM IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
-# WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
-# MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU General Public License as published by the Free Software
-# Foundation, version 2; OR the Perl Artistic License.  On UNIX and similar
-# systems, you can issue `man perlgpl' or `man perlartistic' to read these
-# licenses.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc., 59 Temple
-# Place, Suite 330, Boston, MA  02111-1307  USA.
-# ###########################################################################
-# SysLogParser package
-# ###########################################################################
-{
-# Package: SysLogParser
-# SysLogParser parses events from syslogs.
-package SysLogParser;
-
-use strict;
-use warnings FATAL => 'all';
-use English qw(-no_match_vars);
-use constant PTDEBUG => $ENV{PTDEBUG} || 0;
-
-# This regex matches the message number, line number, and content of a syslog
-# message:
-# 2008 Jan  9 16:16:34 hostname postgres[30059]: [13-2] ...content...
-my $syslog_regex = qr{\A.*\w+\[\d+\]: \[(\d+)-(\d+)\] (.*)\Z};
-
-# This class generates currying functions that wrap around a standard
-# log-parser's next_event() and tell() function pointers.  The wrappers behave
-# the same way, except that they'll return entire syslog events, instead of
-# lines at a time.  To use it, do the following:
-#
-# sub parse_event {
-#    my ($self, %args) = @_;
-#    my ($next_event, $tell, $is_syslog) = SysLogParser::make_closures(%args);
-#    # ... write your code to use the $next_event and $tell here...
-# }
-#
-# If the log isn't in syslog format, $is_syslog will be false and you'll get
-# back simple wrappers around the $next_event and $tell functions.  (They still
-# have to be wrapped, because to find out whether the log is in syslog format,
-# the first line has to be examined.)
-sub new {
-   my ( $class ) = @_;
-   my $self = {};
-   return bless $self, $class;
-}
-
-# This method is here so that SysLogParser can be used and tested in its own
-# right.  However, its ability to generate wrapper functions probably means that
-# it should be used as a translation layer, not directly.  You can use this code
-# as an example of how to integrate this into other packages.
-sub parse_event {
-   my ( $self, %args ) = @_;
-   my ( $next_event, $tell, $is_syslog ) = $self->generate_wrappers(%args);
-   return $next_event->();
-}
-
-# This is an example of how a class can seamlessly put a syslog translation
-# layer underneath itself.
-sub generate_wrappers {
-   my ( $self, %args ) = @_;
-
-   # Reset everything, just in case some cruft was left over from a previous use
-   # of this object.  The object has stateful closures.  If this isn't done,
-   # then they'll keep reading from old filehandles.  The sanity check is based
-   # on the memory address of the closure!
-   if ( ($self->{sanity} || '') ne "$args{next_event}" ){
-      PTDEBUG && _d("Clearing and recreating internal state");
-      @{$self}{qw(next_event tell is_syslog)} = $self->make_closures(%args);
-      $self->{sanity} = "$args{next_event}";
-   }
-
-   # Return the wrapper functions!
-   return @{$self}{qw(next_event tell is_syslog)};
-}
-
-# Make the closures!  The $args{misc}->{new_event_test} is an optional
-# subroutine reference, which tells the wrapper when to consider a line part of
-# a new event, in syslog format, even when it's technically the same syslog
-# event.  See the test for samples/pg-syslog-002.txt for an example.  This
-# argument should be passed in via the call to parse_event().  Ditto for
-# 'line_filter', which is some processing code to run on every line of content
-# in an event.
-sub make_closures {
-   my ( $self, %args ) = @_;
-
-   # The following variables will be referred to in the manufactured
-   # subroutines, making them proper closures.
-   my $next_event     = $args{'next_event'};
-   my $tell           = $args{'tell'};
-   my $new_event_test = $args{'misc'}->{'new_event_test'};
-   my $line_filter    = $args{'misc'}->{'line_filter'};
-
-   # The first thing to do is get a line from the log and see if it's from
-   # syslog.
-   my $test_line = $next_event->();
-   PTDEBUG && _d('Read first sample/test line:', $test_line);
-
-   # If it's syslog, we have to generate a moderately elaborate wrapper
-   # function.
-   if ( defined $test_line && $test_line =~ m/$syslog_regex/o ) {
-
-      # Within syslog-parsing subroutines, we'll use LLSP (low-level syslog
-      # parser) as a PTDEBUG line prefix.
-      PTDEBUG && _d('This looks like a syslog line, PTDEBUG prefix=LLSP');
-
-      # Grab the interesting bits out of the test line, and save the result.
-      my ($msg_nr, $line_nr, $content) = $test_line =~ m/$syslog_regex/o;
-      my @pending = ($test_line);
-      my $last_msg_nr = $msg_nr;
-      my $pos_in_log  = 0;
-
-      # Generate the subroutine for getting a full log message without syslog
-      # breaking it across multiple lines.
-      my $new_next_event = sub {
-         PTDEBUG && _d('LLSP: next_event()');
-
-         # Keeping the pos_in_log variable right is a bit tricky!  In general,
-         # we have to tell() the filehandle before trying to read from it,
-         # getting the position before the data we've just read.  The simple
-         # rule is that when we push something onto @pending, which we almost
-         # always do, then $pos_in_log should point to the beginning of that
-         # saved content in the file.
-         PTDEBUG && _d('LLSP: Current virtual $fh position:', $pos_in_log);
-         my $new_pos = 0;
-
-         # @arg_lines is where we store up the content we're about to return.
-         # It contains $content; @pending contains a single saved $line.
-         my @arg_lines;
-
-         # Here we actually examine lines until we have found a complete event.
-         my $line;
-         LINE:
-         while (
-            defined($line = shift @pending)
-            || do {
-               # Save $new_pos, because when we hit EOF we can't $tell->()
-               # anymore.
-               eval { $new_pos = -1; $new_pos = $tell->() };
-               defined($line = $next_event->());
-            }
-         ) {
-            PTDEBUG && _d('LLSP: Line:', $line);
-
-            # Parse the line.
-            ($msg_nr, $line_nr, $content) = $line =~ m/$syslog_regex/o;
-            if ( !$msg_nr ) {
-               die "Can't parse line: $line";
-            }
-
-            # The message number has changed -- thus, new message.
-            elsif ( $msg_nr != $last_msg_nr ) {
-               PTDEBUG && _d('LLSP: $msg_nr', $last_msg_nr, '=>', $msg_nr);
-               $last_msg_nr = $msg_nr;
-               last LINE;
-            }
-
-            # Or, the caller gave us a custom new_event_test and it is true --
-            # thus, also new message.
-            elsif ( @arg_lines && $new_event_test && $new_event_test->($content) ) {
-               PTDEBUG && _d('LLSP: $new_event_test matches');
-               last LINE;
-            }
-
-            # Otherwise it's part of the current message; put it onto the list
-            # of lines pending.  We have to translate characters that syslog has
-            # munged.  Some translate TAB into the literal characters '^I' and
-            # some, rsyslog on Debian anyway, seem to translate all whitespace
-            # control characters into an octal string representing the character
-            # code.
-            # Example: #011FROM pg_catalog.pg_class c
-            $content =~ s/#(\d{3})/chr(oct($1))/ge;
-            $content =~ s/\^I/\t/g;
-            if ( $line_filter ) {
-               PTDEBUG && _d('LLSP: applying $line_filter');
-               $content = $line_filter->($content);
-            }
-
-            push @arg_lines, $content;
-         }
-         PTDEBUG && _d('LLSP: Exited while-loop after finding a complete entry');
-
-         # Mash the pending stuff together to return it.
-         my $psql_log_event = @arg_lines ? join('', @arg_lines) : undef;
-         PTDEBUG && _d('LLSP: Final log entry:', $psql_log_event);
-
-         # Save the new content into @pending for the next time.  $pos_in_log
-         # must also be updated to whatever $new_pos is.
-         if ( defined $line ) {
-            PTDEBUG && _d('LLSP: Saving $line:', $line);
-            @pending = $line;
-            PTDEBUG && _d('LLSP: $pos_in_log:', $pos_in_log, '=>', $new_pos);
-            $pos_in_log = $new_pos;
-         }
-         else {
-            # We hit the end of the file.
-            PTDEBUG && _d('LLSP: EOF reached');
-            @pending     = ();
-            $last_msg_nr = 0;
-         }
-
-         return $psql_log_event;
-      };
-
-      # Create the closure for $tell->();
-      my $new_tell = sub {
-         PTDEBUG && _d('LLSP: tell()', $pos_in_log);
-         return $pos_in_log;
-      };
-
-      return ($new_next_event, $new_tell, 1);
-   }
-
-   # This is either at EOF already, or it's not syslog format.
-   else {
-
-      # Within plain-log-parsing subroutines, we'll use PLAIN as a PTDEBUG
-      # line prefix.
-      PTDEBUG && _d('Plain log, or we are at EOF; PTDEBUG prefix=PLAIN');
-
-      # The @pending array is really only needed to return the one line we
-      # already read as a test.  Too bad we can't just push it back onto the
-      # log.  TODO: maybe we can test whether the filehandle is seekable and
-      # seek back to the start, then just return the unwrapped functions?
-      my @pending = defined $test_line ? ($test_line) : ();
-
-      my $new_next_event = sub {
-         PTDEBUG && _d('PLAIN: next_event(); @pending:', scalar @pending);
-         return @pending ? shift @pending : $next_event->();
-      };
-      my $new_tell = sub {
-         PTDEBUG && _d('PLAIN: tell(); @pending:', scalar @pending);
-         return @pending ? 0 : $tell->();
-      };
-      return ($new_next_event, $new_tell, 0);
-   }
-}
-
-sub _d {
-   my ($package, undef, $line) = caller 0;
-   @_ = map { (my $temp = $_) =~ s/\n/\n# /g; $temp; }
-        map { defined $_ ? $_ : 'undef' }
-        @_;
-   print STDERR "# $package:$line $PID ", join(' ', @_), "\n";
-}
-
-1;
-}
-# ###########################################################################
-# End SysLogParser package
-# ###########################################################################

=== modified file 'lib/TcpdumpParser.pm'
--- lib/TcpdumpParser.pm	2013-01-03 00:19:16 +0000
+++ lib/TcpdumpParser.pm	2013-02-01 18:19:34 +0000
@@ -172,10 +172,7 @@
 sub port_number {
    my ( $self, $port ) = @_;
    return unless $port;
-   return $port eq 'memcached' ? 11211
-        : $port eq 'http'      ? 80
-        : $port eq 'mysql'     ? 3306
-        :                        $port; 
+   return $port eq 'mysql' ? 3306 : $port;
 }
 
 sub _d {

=== removed file 't/lib/HTTPProtocolParser.t'
--- t/lib/HTTPProtocolParser.t	2012-03-06 13:56:08 +0000
+++ t/lib/HTTPProtocolParser.t	1970-01-01 00:00:00 +0000
@@ -1,286 +0,0 @@
-#!/usr/bin/perl
-
-BEGIN {
-   die "The PERCONA_TOOLKIT_BRANCH environment variable is not set.\n"
-      unless $ENV{PERCONA_TOOLKIT_BRANCH} && -d $ENV{PERCONA_TOOLKIT_BRANCH};
-   unshift @INC, "$ENV{PERCONA_TOOLKIT_BRANCH}/lib";
-};
-
-use strict;
-use warnings FATAL => 'all';
-use English qw(-no_match_vars);
-use Test::More tests => 16;
-
-use TcpdumpParser;
-use ProtocolParser;
-use HTTPProtocolParser;
-use PerconaTest;
-
-my $tcpdump  = new TcpdumpParser();
-my $protocol; # Create a new HTTPProtocolParser for each test.
-
-# GET a very simple page.
-$protocol = new HTTPProtocolParser();
-test_protocol_parser(
-   parser   => $tcpdump,
-   protocol => $protocol,
-   file     => 't/lib/samples/http/http_tcpdump001.txt',
-   result   => [
-      { ts              => '2009-11-09 11:31:52.341907',
-        bytes           => '715',
-        host            => '10.112.2.144',
-        pos_in_log      => 0,
-        Virtual_host    => 'hackmysql.com',
-        arg             => 'get hackmysql.com/contact',
-        Status_code     => '200',
-        Query_time      => '0.651419',
-        Transmit_time   => '0.000000',
-      },
-   ],
-);
-
-# Get http://www.percona.com/about-us.html
-$protocol = new HTTPProtocolParser();
-test_protocol_parser(
-   parser   => $tcpdump,
-   protocol => $protocol,
-   file     => 't/lib/samples/http/http_tcpdump002.txt',
-   result   => [
-      {
-         ts             => '2009-11-09 15:31:09.074855',
-         Query_time     => '0.070097',
-         Status_code    => '200',
-         Transmit_time  => '0.000720',
-         Virtual_host   => 'www.percona.com',
-         arg            => 'get www.percona.com/about-us.html',
-         bytes          => 3832,
-         host           => '10.112.2.144',
-         pos_in_log     => 206,
-      },
-      {
-         ts             => '2009-11-09 15:31:09.157215',
-         Query_time     => '0.068558',
-         Status_code    => '200',
-         Transmit_time  => '0.066490',
-         Virtual_host   => 'www.percona.com',
-         arg            => 'get www.percona.com/js/jquery.js',
-         bytes          => 9921,
-         host           => '10.112.2.144',
-         pos_in_log     => 16362,
-      },
-      {
-         ts             => '2009-11-09 15:31:09.346763',
-         Query_time     => '0.066506',
-         Status_code    => '200',
-         Transmit_time  => '0.000000',
-         Virtual_host   => 'www.percona.com',
-         arg            => 'get www.percona.com/images/menu_team.gif',
-         bytes          => 344,
-         host           => '10.112.2.144',
-         pos_in_log     => 53100,
-      },
-      {
-         ts             => '2009-11-09 15:31:09.373800',
-         Query_time     => '0.045442',
-         Status_code    => '200',
-         Transmit_time  => '0.000000',
-         Virtual_host   => 'www.google-analytics.com',
-         arg            => 'get www.google-analytics.com/__utm.gif?utmwv=1.3&utmn=1710381507&utmcs=UTF-8&utmsr=1280x800&utmsc=24-bit&utmul=en-us&utmje=1&utmfl=10.0%20r22&utmdt=About%20Percona&utmhn=www.percona.com&utmhid=1947703805&utmr=0&utmp=/about-us.html&utmac=UA-343802-3&utmcc=__utma%3D154442809.1969570579.1256593671.1256825719.1257805869.3%3B%2B__utmz%3D154442809.1256593671.1.1.utmccn%3D(direct)%7Cutmcsr%3D(direct)%7Cutmcmd%3D(none)%3B%2B',
-         bytes          => 35,
-         host           => '10.112.2.144',
-         pos_in_log     => 55942,
-      },
-      {
-         ts             => '2009-11-09 15:31:09.411349',
-         Query_time     => '0.073882',
-         Status_code    => '200',
-         Transmit_time  => '0.000000',
-         Virtual_host   => 'www.percona.com',
-         arg            => 'get www.percona.com/images/menu_our-vision.gif',
-         bytes          => 414,
-         host           => '10.112.2.144',
-         pos_in_log     => 59213,
-      },
-      {
-         ts             => '2009-11-09 15:31:09.420851',
-         Query_time     => '0.067669',
-         Status_code    => '200',
-         Transmit_time  => '0.000000',
-         Virtual_host   => 'www.percona.com',
-         arg            => 'get www.percona.com/images/bg-gray-corner-top.gif',
-         bytes          => 170,
-         host           => '10.112.2.144',
-         pos_in_log     => 65644,
-      },
-      {
-         ts             => '2009-11-09 15:31:09.420996',
-         Query_time     => '0.067345',
-         Status_code    => '200',
-         Transmit_time  => '0.134909',
-         Virtual_host   => 'www.percona.com',
-         arg            => 'get www.percona.com/images/handshake.jpg',
-         bytes          => 20017,
-         host           => '10.112.2.144',
-         pos_in_log     => 67956,
-      },
-      {
-         ts             => '2009-11-09 15:31:14.536149',
-         Query_time     => '0.061528',
-         Status_code    => '200',
-         Transmit_time  => '0.059577',
-         Virtual_host   => 'hit.clickaider.com',
-         arg            => 'get hit.clickaider.com/clickaider.js',
-         bytes          => 4009,
-         host           => '10.112.2.144',
-         pos_in_log     => 147447,
-      },
-      {
-         ts             => '2009-11-09 15:31:14.678713',
-         Query_time     => '0.060436',
-         Status_code    => '200',
-         Transmit_time  => '0.000000',
-         Virtual_host   => 'hit.clickaider.com',
-         arg            => 'get hit.clickaider.com/pv?lng=140&&lnks=&t=About%20Percona&c=73a41b95-2926&r=http%3A%2F%2Fwww.percona.com%2F&tz=-420&loc=http%3A%2F%2Fwww.percona.com%2Fabout-us.html&rnd=3688',
-         bytes          => 43,
-         host           => '10.112.2.144',
-         pos_in_log     => 167245,
-      },
-      {
-         ts             => '2009-11-09 15:31:14.737890',
-         Query_time     => '0.061937',
-         Status_code    => '200',
-         Transmit_time  => '0.000000',
-         Virtual_host   => 'hit.clickaider.com',
-         arg            => 'get hit.clickaider.com/s/forms.js',
-         bytes          => 822,
-         host           => '10.112.2.144',
-         pos_in_log     => 170117,
-      },
-   ],
-);
-
-# A reponse received in out of order packet.
-$protocol = new HTTPProtocolParser();
-test_protocol_parser(
-   parser   => $tcpdump,
-   protocol => $protocol,
-   file     => 't/lib/samples/http/http_tcpdump004.txt',
-   result   => [
-      {  ts             => '2009-11-12 11:27:10.757573',
-         Query_time     => '0.327356',
-         Status_code    => '200',
-         Transmit_time  => '0.549501',
-         Virtual_host   => 'dev.mysql.com',
-         arg            => 'get dev.mysql.com/common/css/mysql.css',
-         bytes          => 11283,
-         host           => '10.67.237.92',
-         pos_in_log     => 776,
-      },
-   ],
-);
-
-# A client request broken over 2 packets.
-$protocol = new HTTPProtocolParser();
-test_protocol_parser(
-   parser   => $tcpdump,
-   protocol => $protocol,
-   file     => 't/lib/samples/http/http_tcpdump005.txt',
-   result   => [
-      {  ts             => '2009-11-13 09:20:31.041924',
-         Query_time     => '0.342166',
-         Status_code    => '200',
-         Transmit_time  => '0.012780',
-         Virtual_host   => 'dev.mysql.com',
-         arg            => 'get dev.mysql.com/doc/refman/5.0/fr/retrieving-data.html',
-         bytes          => 4382,
-         host           => '192.168.200.110',
-         pos_in_log     => 785, 
-      },
-   ],
-);
-
-# Out of order header that might look like the text header
-# but is really data; text header arrives last.
-$protocol = new HTTPProtocolParser();
-test_protocol_parser(
-   parser   => $tcpdump,
-   protocol => $protocol,
-   file     => 't/lib/samples/http/http_tcpdump006.txt',
-   result   => [
-      {  ts             => '2009-11-13 09:50:44.432099',
-         Query_time     => '0.140878',
-         Status_code    => '200',
-         Transmit_time  => '0.237153',
-         Virtual_host   => '247wallst.files.wordpress.com',
-         arg            => 'get 247wallst.files.wordpress.com/2009/11/airplane4.jpg?w=139&h=93',
-         bytes          => 3391,
-         host           => '192.168.200.110',
-         pos_in_log     => 782,
-      },
-   ],
-);
-
-# One 2.6M image that took almost a minute to load (very slow wifi).
-$protocol = new HTTPProtocolParser();
-test_protocol_parser(
-   parser   => $tcpdump,
-   protocol => $protocol,
-   file     => 't/lib/samples/http/http_tcpdump007.txt',
-   result   => [
-      {  ts             => '2009-11-13 10:09:53.251620',
-         Query_time     => '0.121971',
-         Status_code    => '200',
-         Transmit_time  => '40.311228',
-         Virtual_host   => 'apod.nasa.gov',
-         arg            => 'get apod.nasa.gov/apod/image/0911/Ophcloud_spitzer.jpg',
-         bytes          => 2706737,
-         host           => '192.168.200.110',
-         pos_in_log     => 640,
-      }
-   ],
-);
-
-# A simple POST.
-$protocol = new HTTPProtocolParser();
-test_protocol_parser(
-   parser   => $tcpdump,
-   protocol => $protocol,
-   file     => 't/lib/samples/http/http_tcpdump008.txt',
-   result   => [
-      {  ts             => '2009-11-13 10:53:48.349465',
-         Query_time     => '0.030740',
-         Status_code    => '200',
-         Transmit_time  => '0.000000',
-         Virtual_host   => 'www.google.com',
-         arg            => 'post www.google.com/finance/qs/channel?VER=6&RID=481&CVER=1&zx=5xccsz-eg9chk&t=1',
-         bytes          => 54,
-         host           => '192.168.200.110',
-         pos_in_log     => 0,
-      }
-   ],
-);
-
-# .http instead of .80
-$protocol = new HTTPProtocolParser();
-test_protocol_parser(
-   parser   => $tcpdump,
-   protocol => $protocol,
-   file     => 't/lib/samples/http/http_tcpdump009.txt',
-   result   => [
-      { ts              => '2009-11-09 11:31:52.341907',
-        bytes           => '715',
-        host            => '10.112.2.144',
-        pos_in_log      => 0,
-        Virtual_host    => 'hackmysql.com',
-        arg             => 'get hackmysql.com/contact',
-        Status_code     => '200',
-        Query_time      => '0.651419',
-        Transmit_time   => '0.000000',
-      },
-   ],
-);
-
-# #############################################################################
-# Done.
-# #############################################################################
-exit;

=== removed file 't/lib/MemcachedEvent.t'
--- t/lib/MemcachedEvent.t	2012-03-06 13:56:08 +0000
+++ t/lib/MemcachedEvent.t	1970-01-01 00:00:00 +0000
@@ -1,766 +0,0 @@
-#!/usr/bin/perl
-
-BEGIN {
-   die "The PERCONA_TOOLKIT_BRANCH environment variable is not set.\n"
-      unless $ENV{PERCONA_TOOLKIT_BRANCH} && -d $ENV{PERCONA_TOOLKIT_BRANCH};
-   unshift @INC, "$ENV{PERCONA_TOOLKIT_BRANCH}/lib";
-};
-
-use strict;
-use warnings FATAL => 'all';
-use English qw(-no_match_vars);
-use Test::More tests => 15;
-
-use MemcachedEvent;
-use PerconaTest;
-
-my $memce = new MemcachedEvent();
-isa_ok($memce, 'MemcachedEvent');
-
-sub make_events {
-   my ( @memc_events ) = @_;
-   my @events;
-   push @events, map { $memce->parse_event(event=>$_) } @memc_events;
-   return \@events;
-}
-
-# #############################################################################
-# Sanity tests.
-# #############################################################################
-my $events = make_events(
-   {
-      key           => 'my_key',
-      val           => 'Some value',
-      res           => 'STORED',
-      Query_time    => 1,
-   },
-);
-is_deeply(
-   $events,
-   [],
-   "Doesn't die when there's no cmd"
-);
-
-$events = make_events(
-   {
-      cmd           => 'unknown_cmd',
-      val           => 'Some value',
-      res           => 'STORED',
-      Query_time    => 1,
-   },
-);
-is_deeply(
-   $events,
-   [],
-   "Doesn't die when there's no key"
-);
-
-$events = make_events(
-   {
-      val           => 'Some value',
-      res           => 'STORED',
-      Query_time    => 1,
-   },
-);
-is_deeply(
-   $events,
-   [],
-   "Doesn't die when there's no cmd or key"
-);
-
-$events = make_events(
-   {
-      cmd           => 'unknown_cmd',
-      key           => 'my_key',
-      val           => 'Some value',
-      res           => 'STORED',
-      Query_time    => 1,
-   },
-);
-is_deeply(
-   $events,
-   [],
-   "Doesn't handle unknown cmd"
-);
-
-# #############################################################################
-# These events are copied straight from the expected results in
-# MemcachedProtocolParser.t.
-# #############################################################################
-
-# A session with a simple set().
-$events = make_events(
-   {  ts            => '2009-07-04 21:33:39.229179',
-      host          => '127.0.0.1',
-      cmd           => 'set',
-      key           => 'my_key',
-      val           => 'Some value',
-      flags         => '0',
-      exptime       => '0',
-      bytes         => '10',
-      res           => 'STORED',
-      Query_time    => sprintf('%.6f', .229299 - .229179),
-      pos_in_log    => 0,
-   },
-);
-is_deeply(
-   $events,
-   [
-      {
-         arg         => 'set my_key',
-         fingerprint => 'set my_key',
-         key_print   => 'my_key',
-         cmd         => 'set',
-         key         => 'my_key',
-         res         => 'STORED',
-         Memc_add => 'No',
-         Memc_append => 'No',
-         Memc_cas => 'No',
-         Memc_decr => 'No',
-         Memc_delete => 'No',
-         Memc_error => 'No',
-         Memc_get => 'No',
-         Memc_gets => 'No',
-         Memc_incr => 'No',
-         Memc_miss => 'No',
-         Memc_prepend => 'No',
-         Memc_replace => 'No',
-         Memc_set => 'Yes',
-         Memc_miss   => 'No',
-         Memc_error  => 'No',
-         Memc_Not_Stored => 'No',
-         Memc_Exists     => 'No',
-         Query_time => '0.000120',
-         bytes => '10',
-         exptime => '0',
-         fingerprint => 'set my_key',
-         flags => '0',
-         host => '127.0.0.1',
-         pos_in_log => 0,
-         ts => '2009-07-04 21:33:39.229179',
-         val => 'Some value'
-      },
-   ],
-   'samples/memc_tcpdump001.txt: simple set'
-);
-
-# A session with a simple get().
-$events = make_events(
-   {  Query_time => '0.000067',
-      cmd        => 'get',
-      key        => 'my_key',
-      val        => 'Some value',
-      bytes      => 10,
-      exptime    => undef,
-      flags      => 0,
-      host       => '127.0.0.1',
-      pos_in_log => '0',
-      res        => 'VALUE',
-      ts         => '2009-07-04 22:12:06.174390'
-   }
-);
-is_deeply(
-   $events,
-   [
-      {
-         arg         => 'get my_key',
-         fingerprint => 'get my_key',
-         key_print   => 'my_key',
-         cmd         => 'get',
-         key         => 'my_key',
-         res         => 'VALUE',
-         Memc_add => 'No',
-         Memc_append => 'No',
-         Memc_cas => 'No',
-         Memc_decr => 'No',
-         Memc_delete => 'No',
-         Memc_error => 'No',
-         Memc_get => 'Yes',
-         Memc_gets => 'No',
-         Memc_incr => 'No',
-         Memc_miss => 'No',
-         Memc_prepend => 'No',
-         Memc_replace => 'No',
-         Memc_set => 'No',
-         Memc_miss   => 'No',
-         Memc_error  => 'No',
-         Query_time => '0.000067',
-         val        => 'Some value',
-         bytes      => 10,
-         exptime    => undef,
-         flags      => 0,
-         host       => '127.0.0.1',
-         pos_in_log => '0',
-         ts         => '2009-07-04 22:12:06.174390'
-      },
-   ],
-   'samples/memc_tcpdump002.txt: simple get',
-);
-
-# A session with a simple incr() and decr().
-$events = make_events(
-   {  Query_time => '0.000073',
-      cmd        => 'incr',
-      key        => 'key',
-      val        => '8',
-      bytes      => undef,
-      exptime    => undef,
-      flags      => undef,
-      host       => '127.0.0.1',
-      pos_in_log => '0',
-      res        => '',
-      ts         => '2009-07-04 22:12:06.175734',
-   },
-   {  Query_time => '0.000068',
-      cmd        => 'decr',
-      bytes      => undef,
-      exptime    => undef,
-      flags      => undef,
-      host       => '127.0.0.1',
-      key        => 'key',
-      pos_in_log => 522,
-      res        => '',
-      ts         => '2009-07-04 22:12:06.176181',
-      val        => '7',
-   },
-);
-is_deeply(
-   $events,
-   [
-      {
-         arg         => 'incr key',
-         fingerprint => 'incr key',
-         key_print   => 'key',
-         cmd         => 'incr',
-         key         => 'key',
-         res         => '',
-         Memc_add => 'No',
-         Memc_append => 'No',
-         Memc_cas => 'No',
-         Memc_decr => 'No',
-         Memc_delete => 'No',
-         Memc_error => 'No',
-         Memc_get => 'No',
-         Memc_gets => 'No',
-         Memc_incr => 'Yes',
-         Memc_miss => 'No',
-         Memc_prepend => 'No',
-         Memc_replace => 'No',
-         Memc_set => 'No',
-         Memc_miss   => 'No',
-         Memc_error  => 'No',
-         Query_time => '0.000073',
-         val        => '8',
-         bytes      => undef,
-         exptime    => undef,
-         flags      => undef,
-         host       => '127.0.0.1',
-         pos_in_log => '0',
-         ts         => '2009-07-04 22:12:06.175734',
-      },
-      {  
-         arg         => 'decr key',
-         fingerprint => 'decr key',
-         key_print   => 'key',
-         cmd         => 'decr',
-         key         => 'key',
-         res         => '',
-         Memc_add => 'No',
-         Memc_append => 'No',
-         Memc_cas => 'No',
-         Memc_decr => 'Yes',
-         Memc_delete => 'No',
-         Memc_error => 'No',
-         Memc_get => 'No',
-         Memc_gets => 'No',
-         Memc_incr => 'No',
-         Memc_miss => 'No',
-         Memc_prepend => 'No',
-         Memc_replace => 'No',
-         Memc_set => 'No',
-         Memc_miss   => 'No',
-         Memc_error  => 'No',
-         Query_time => '0.000068',
-         bytes      => undef,
-         exptime    => undef,
-         flags      => undef,
-         host       => '127.0.0.1',
-         pos_in_log => 522,
-         ts         => '2009-07-04 22:12:06.176181',
-         val        => '7',
-      },
-   ],
-   'samples/memc_tcpdump003.txt: incr and decr'
-);
-
-# A session with a simple incr() and decr(), but the value doesn't exist.
-$events = make_events(
-   {  Query_time => '0.000131',
-      bytes      => undef,
-      cmd        => 'incr',
-      exptime    => undef,
-      flags      => undef,
-      host       => '127.0.0.1',
-      key        => 'key',
-      pos_in_log => 764,
-      res        => 'NOT_FOUND',
-      ts         => '2009-07-06 10:37:21.668469',
-      val        => '',
-   },
-   {
-      Query_time => '0.000055',
-      bytes      => undef,
-      cmd        => 'decr',
-      exptime    => undef,
-      flags      => undef,
-      host       => '127.0.0.1',
-      key        => 'key',
-      pos_in_log => 1788,
-      res        => 'NOT_FOUND',
-      ts         => '2009-07-06 10:37:21.668851',
-      val        => '',
-   },
-);
-is_deeply(
-   $events,
-   [
-      {  
-         arg         => 'incr key',
-         fingerprint => 'incr key',
-         key_print   => 'key',
-         cmd         => 'incr',
-         key         => 'key',
-         res         => 'NOT_FOUND',
-         Memc_add => 'No',
-         Memc_append => 'No',
-         Memc_cas => 'No',
-         Memc_decr => 'No',
-         Memc_delete => 'No',
-         Memc_error => 'No',
-         Memc_get => 'No',
-         Memc_gets => 'No',
-         Memc_incr => 'Yes',
-         Memc_miss => 'No',
-         Memc_prepend => 'No',
-         Memc_replace => 'No',
-         Memc_set => 'No',
-         Memc_miss   => 'Yes',
-         Memc_error  => 'No',
-         Query_time => '0.000131',
-         bytes      => undef,
-         exptime    => undef,
-         flags      => undef,
-         host       => '127.0.0.1',
-         pos_in_log => 764,
-         ts         => '2009-07-06 10:37:21.668469',
-         val        => '',
-      },
-      {
-         arg         => 'decr key',
-         fingerprint => 'decr key',
-         key_print   => 'key',
-         cmd         => 'decr',
-         key         => 'key',
-         res         => 'NOT_FOUND',
-         Memc_add => 'No',
-         Memc_append => 'No',
-         Memc_cas => 'No',
-         Memc_decr => 'Yes',
-         Memc_delete => 'No',
-         Memc_error => 'No',
-         Memc_get => 'No',
-         Memc_gets => 'No',
-         Memc_incr => 'No',
-         Memc_miss => 'No',
-         Memc_prepend => 'No',
-         Memc_replace => 'No',
-         Memc_set => 'No',
-         Memc_miss   => 'Yes',
-         Memc_error  => 'No',
-         Query_time => '0.000055',
-         bytes      => undef,
-         exptime    => undef,
-         flags      => undef,
-         host       => '127.0.0.1',
-         pos_in_log => 1788,
-         ts         => '2009-07-06 10:37:21.668851',
-         val        => '',
-      },
-   ],
-   'samples/memc_tcpdump004.txt: incr and decr nonexistent key'
-);
-
-# A session with a huge set() that will not fit into a single TCP packet.
-$events = make_events(
-   {  Query_time => '0.003928',
-      bytes      => 17946,
-      cmd        => 'set',
-      exptime    => 0,
-      flags      => 0,
-      host       => '127.0.0.1',
-      key        => 'my_key',
-      pos_in_log => 764,
-      res        => 'STORED',
-      ts         => '2009-07-06 22:07:14.406827',
-      val        => ('lorem ipsum dolor sit amet' x 690) . ' fini!',
-   },
-);
-is_deeply(
-   $events,
-   [
-      {  
-         arg         => 'set my_key',
-         fingerprint => 'set my_key',
-         key_print   => 'my_key',
-         cmd         => 'set',
-         key         => 'my_key',
-         res         => 'STORED',
-         Memc_add => 'No',
-         Memc_append => 'No',
-         Memc_cas => 'No',
-         Memc_decr => 'No',
-         Memc_delete => 'No',
-         Memc_error => 'No',
-         Memc_get => 'No',
-         Memc_gets => 'No',
-         Memc_incr => 'No',
-         Memc_miss => 'No',
-         Memc_prepend => 'No',
-         Memc_replace => 'No',
-         Memc_set => 'Yes',
-         Memc_miss  => 'No',
-         Memc_error => 'No',
-         Memc_Not_Stored => 'No',
-         Memc_Exists     => 'No',
-         Query_time => '0.003928',
-         bytes      => 17946,
-         exptime    => 0,
-         flags      => 0,
-         host       => '127.0.0.1',
-         pos_in_log => 764,
-         ts         => '2009-07-06 22:07:14.406827',
-         val        => ('lorem ipsum dolor sit amet' x 690) . ' fini!',
-      },
-   ],
-   'samples/memc_tcpdump005.txt: huge set'
-);
-
-# A session with a huge get() that will not fit into a single TCP packet.
-$events = make_events(
-   {
-      Query_time => '0.000196',
-      bytes      => 17946,
-      cmd        => 'get',
-      exptime    => undef,
-      flags      => 0,
-      host       => '127.0.0.1',
-      key        => 'my_key',
-      pos_in_log => 0,
-      res        => 'VALUE',
-      ts         => '2009-07-06 22:07:14.411331',
-      val        => ('lorem ipsum dolor sit amet' x 690) . ' fini!',
-   },
-);
-is_deeply(
-   $events,
-   [
-      {
-         arg         => 'get my_key',
-         fingerprint => 'get my_key',
-         key_print   => 'my_key',
-         cmd         => 'get',
-         key         => 'my_key',
-         res         => 'VALUE',
-         Memc_add => 'No',
-         Memc_append => 'No',
-         Memc_cas => 'No',
-         Memc_decr => 'No',
-         Memc_delete => 'No',
-         Memc_error => 'No',
-         Memc_get => 'Yes',
-         Memc_gets => 'No',
-         Memc_incr => 'No',
-         Memc_miss => 'No',
-         Memc_prepend => 'No',
-         Memc_replace => 'No',
-         Memc_set => 'No',
-         Memc_miss   => 'No',
-         Memc_error  => 'No',
-         Query_time => '0.000196',
-         bytes      => 17946,
-         exptime    => undef,
-         flags      => 0,
-         host       => '127.0.0.1',
-         pos_in_log => 0,
-         ts         => '2009-07-06 22:07:14.411331',
-         val        => ('lorem ipsum dolor sit amet' x 690) . ' fini!',
-      },
-   ],
-   'samples/memc_tcpdump006.txt: huge get'
-);
-
-# A session with a get() that doesn't exist.
-$events = make_events(
-   {
-      Query_time => '0.000016',
-      bytes      => undef,
-      cmd        => 'get',
-      exptime    => undef,
-      flags      => undef,
-      host       => '127.0.0.1',
-      key        => 'comment_v3_482685',
-      pos_in_log => 0,
-      res        => 'NOT_FOUND',
-      ts         => '2009-06-11 21:54:49.059144',
-      val        => '',
-   },
-);
-is_deeply(
-   $events,
-   [
-      {
-         arg         => 'get comment_v3_482685',
-         fingerprint => 'get comment_v?_?',
-         key_print   => 'comment_v?_?',
-         cmd         => 'get',
-         key         => 'comment_v3_482685',
-         res         => 'NOT_FOUND',
-         Memc_add => 'No',
-         Memc_append => 'No',
-         Memc_cas => 'No',
-         Memc_decr => 'No',
-         Memc_delete => 'No',
-         Memc_error => 'No',
-         Memc_get => 'Yes',
-         Memc_gets => 'No',
-         Memc_incr => 'No',
-         Memc_miss => 'No',
-         Memc_prepend => 'No',
-         Memc_replace => 'No',
-         Memc_set => 'No',
-         Memc_miss   => 'Yes',
-         Memc_error  => 'No',
-         Query_time => '0.000016',
-         bytes      => undef,
-         exptime    => undef,
-         flags      => undef,
-         host       => '127.0.0.1',
-         pos_in_log => 0,
-         ts         => '2009-06-11 21:54:49.059144',
-         val        => '',
-      },
-   ],
-   'samples/memc_tcpdump007.txt: get nonexistent key'
-);
-
-# A session with a huge get() that will not fit into a single TCP packet, but
-# the connection seems to be broken in the middle of the receive and then the
-# new client picks up and asks for something different.
-$events = make_events(
-   {
-      Query_time => '0.000003',
-      bytes      => 17946,
-      cmd        => 'get',
-      exptime    => undef,
-      flags      => 0,
-      host       => '127.0.0.1',
-      key        => 'my_key',
-      pos_in_log => 0,
-      res        => 'INTERRUPTED',
-      ts         => '2009-07-06 22:07:14.411331',
-      val        => '',
-   },
-   {  Query_time => '0.000001',
-      cmd        => 'get',
-      key        => 'my_key',
-      val        => 'Some value',
-      bytes      => 10,
-      exptime    => undef,
-      flags      => 0,
-      host       => '127.0.0.1',
-      pos_in_log => 5382,
-      res        => 'VALUE',
-      ts         => '2009-07-06 22:07:14.411334',
-   },
-);
-is_deeply(
-   $events,
-   [
-      {
-         arg         => 'get my_key',
-         fingerprint => 'get my_key',
-         key_print   => 'my_key',
-         cmd         => 'get',
-         key         => 'my_key',
-         res         => 'INTERRUPTED',
-         Memc_add => 'No',
-         Memc_append => 'No',
-         Memc_cas => 'No',
-         Memc_decr => 'No',
-         Memc_delete => 'No',
-         Memc_error => 'No',
-         Memc_get => 'Yes',
-         Memc_gets => 'No',
-         Memc_incr => 'No',
-         Memc_miss => 'No',
-         Memc_prepend => 'No',
-         Memc_replace => 'No',
-         Memc_set => 'No',
-         Memc_miss   => 'No',
-         Memc_error  => 'Yes',
-         Query_time => '0.000003',
-         bytes      => 17946,
-         exptime    => undef,
-         flags      => 0,
-         host       => '127.0.0.1',
-         pos_in_log => 0,
-         ts         => '2009-07-06 22:07:14.411331',
-         val        => '',
-      },
-      {
-         arg         => 'get my_key',
-         fingerprint => 'get my_key',
-         key_print   => 'my_key',
-         cmd         => 'get',
-         key         => 'my_key',
-         res         => 'VALUE',
-         Memc_add => 'No',
-         Memc_append => 'No',
-         Memc_cas => 'No',
-         Memc_decr => 'No',
-         Memc_delete => 'No',
-         Memc_error => 'No',
-         Memc_get => 'Yes',
-         Memc_gets => 'No',
-         Memc_incr => 'No',
-         Memc_miss => 'No',
-         Memc_prepend => 'No',
-         Memc_replace => 'No',
-         Memc_set => 'No',
-         Memc_miss   => 'No',
-         Memc_error  => 'No',
-         Query_time => '0.000001',
-         val        => 'Some value',
-         bytes      => 10,
-         exptime    => undef,
-         flags      => 0,
-         host       => '127.0.0.1',
-         pos_in_log => 5382,
-         ts         => '2009-07-06 22:07:14.411334',
-      },
-   ],
-   'samples/memc_tcpdump008.txt: interrupted huge get'
-);
-
-# A session with a delete() that doesn't exist. TODO: delete takes a queue_time.
-$events = make_events(
-   {
-      Query_time => '0.000022',
-      bytes      => undef,
-      cmd        => 'delete',
-      exptime    => undef,
-      flags      => undef,
-      host       => '127.0.0.1',
-      key        => 'comment_1873527',
-      pos_in_log => 0,
-      res        => 'NOT_FOUND',
-      ts         => '2009-06-11 21:54:52.244534',
-      val        => '',
-   },
-);
-is_deeply(
-   $events,
-   [
-      {
-         arg         => 'delete comment_1873527',
-         fingerprint => 'delete comment_?',
-         key_print   => 'comment_?',
-         cmd         => 'delete',
-         key         => 'comment_1873527',
-         res         => 'NOT_FOUND',
-         Memc_add => 'No',
-         Memc_append => 'No',
-         Memc_cas => 'No',
-         Memc_decr => 'No',
-         Memc_delete => 'Yes',
-         Memc_error => 'No',
-         Memc_get => 'No',
-         Memc_gets => 'No',
-         Memc_incr => 'No',
-         Memc_miss => 'No',
-         Memc_prepend => 'No',
-         Memc_replace => 'No',
-         Memc_set => 'No',
-         Memc_miss   => 'Yes',
-         Memc_error  => 'No',
-         Query_time => '0.000022',
-         bytes      => undef,
-         exptime    => undef,
-         flags      => undef,
-         host       => '127.0.0.1',
-         pos_in_log => 0,
-         ts         => '2009-06-11 21:54:52.244534',
-         val        => '',
-      },
-   ],
-   'samples/memc_tcpdump009.txt: delete nonexistent key'
-);
-
-# A session with a delete() that does exist.
-$events = make_events(
-   {
-      Query_time => '0.000120',
-      bytes      => undef,
-      cmd        => 'delete',
-      exptime    => undef,
-      flags      => undef,
-      host       => '127.0.0.1',
-      key        => 'my_key',
-      pos_in_log => 0,
-      res        => 'DELETED',
-      ts         => '2009-07-09 22:00:29.066476',
-      val        => '',
-   },
-);
-is_deeply(
-   $events,
-   [
-      {
-         arg         => 'delete my_key',
-         fingerprint => 'delete my_key',
-         key_print   => 'my_key',
-         cmd         => 'delete',
-         key         => 'my_key',
-         res         => 'DELETED',
-         Memc_add => 'No',
-         Memc_append => 'No',
-         Memc_cas => 'No',
-         Memc_decr => 'No',
-         Memc_delete => 'Yes',
-         Memc_error => 'No',
-         Memc_get => 'No',
-         Memc_gets => 'No',
-         Memc_incr => 'No',
-         Memc_miss => 'No',
-         Memc_prepend => 'No',
-         Memc_replace => 'No',
-         Memc_set => 'No',
-         Memc_miss   => 'No',
-         Memc_error  => 'No',
-         Query_time => '0.000120',
-         bytes      => undef,
-         exptime    => undef,
-         flags      => undef,
-         host       => '127.0.0.1',
-         pos_in_log => 0,
-         ts         => '2009-07-09 22:00:29.066476',
-         val        => '',
-      },
-   ],
-   'samples/memc_tcpdump010.txt: simple delete'
-);
-
-# #############################################################################
-# Done.
-# #############################################################################
-exit;

=== removed file 't/lib/MemcachedProtocolParser.t'
--- t/lib/MemcachedProtocolParser.t	2012-03-06 13:56:08 +0000
+++ t/lib/MemcachedProtocolParser.t	1970-01-01 00:00:00 +0000
@@ -1,414 +0,0 @@
-#!/usr/bin/perl
-
-BEGIN {
-   die "The PERCONA_TOOLKIT_BRANCH environment variable is not set.\n"
-      unless $ENV{PERCONA_TOOLKIT_BRANCH} && -d $ENV{PERCONA_TOOLKIT_BRANCH};
-   unshift @INC, "$ENV{PERCONA_TOOLKIT_BRANCH}/lib";
-};
-
-use strict;
-use warnings FATAL => 'all';
-use English qw(-no_match_vars);
-use Test::More tests => 28;
-
-use MemcachedProtocolParser;
-use TcpdumpParser;
-use PerconaTest;
-
-my $tcpdump  = new TcpdumpParser();
-my $protocol; # Create a new MemcachedProtocolParser for each test.
-
-# A session with a simple set().
-$protocol = new MemcachedProtocolParser();
-test_protocol_parser(
-   parser   => $tcpdump,
-   protocol => $protocol,
-   file     => 't/lib/samples/memcached/memc_tcpdump001.txt',
-   result   => [
-      {  ts            => '2009-07-04 21:33:39.229179',
-         host          => '127.0.0.1',
-         cmd           => 'set',
-         key           => 'my_key',
-         val           => 'Some value',
-         flags         => '0',
-         exptime       => '0',
-         bytes         => '10',
-         res           => 'STORED',
-         Query_time    => sprintf('%.6f', .229299 - .229179),
-         pos_in_log    => 0,
-      },
-   ],
-);
-
-# A session with a simple get().
-$protocol = new MemcachedProtocolParser();
-test_protocol_parser(
-   parser   => $tcpdump,
-   protocol => $protocol,
-   file     => 't/lib/samples/memcached/memc_tcpdump002.txt',
-   result   => [
-      {  Query_time => '0.000067',
-         cmd        => 'get',
-         key        => 'my_key',
-         val        => 'Some value',
-         bytes      => 10,
-         exptime    => 0,
-         flags      => 0,
-         host       => '127.0.0.1',
-         pos_in_log => '0',
-         res        => 'VALUE',
-         ts         => '2009-07-04 22:12:06.174390'
-      },
-   ],
-);
-
-# A session with a simple incr() and decr().
-$protocol = new MemcachedProtocolParser();
-test_protocol_parser(
-   parser   => $tcpdump,
-   protocol => $protocol,
-   file     => 't/lib/samples/memcached/memc_tcpdump003.txt',
-   result   => [
-      {  Query_time => '0.000073',
-         cmd        => 'incr',
-         key        => 'key',
-         val        => '8',
-         bytes      => 0,
-         exptime    => 0,
-         flags      => 0,
-         host       => '127.0.0.1',
-         pos_in_log => '0',
-         res        => '',
-         ts         => '2009-07-04 22:12:06.175734',
-      },
-      {  Query_time => '0.000068',
-         cmd        => 'decr',
-         bytes      => 0,
-         exptime    => 0,
-         flags      => 0,
-         host       => '127.0.0.1',
-         key        => 'key',
-         pos_in_log => 522,
-         res        => '',
-         ts         => '2009-07-04 22:12:06.176181',
-         val => '7',
-      },
-   ],
-);
-
-# A session with a simple incr() and decr(), but the value doesn't exist.
-$protocol = new MemcachedProtocolParser();
-test_protocol_parser(
-   parser   => $tcpdump,
-   protocol => $protocol,
-   file     => 't/lib/samples/memcached/memc_tcpdump004.txt',
-   result   => [
-      {  Query_time => '0.000131',
-         bytes      => 0,
-         cmd        => 'incr',
-         exptime    => 0,
-         flags      => 0,
-         host       => '127.0.0.1',
-         key        => 'key',
-         pos_in_log => 764,
-         res        => 'NOT_FOUND',
-         ts         => '2009-07-06 10:37:21.668469',
-         val        => '',
-      },
-      {
-         Query_time => '0.000055',
-         bytes      => 0,
-         cmd        => 'decr',
-         exptime    => 0,
-         flags      => 0,
-         host       => '127.0.0.1',
-         key        => 'key',
-         pos_in_log => 1788,
-         res        => 'NOT_FOUND',
-         ts         => '2009-07-06 10:37:21.668851',
-         val        => '',
-      },
-   ],
-);
-
-# A session with a huge set() that will not fit into a single TCP packet.
-$protocol = new MemcachedProtocolParser();
-test_protocol_parser(
-   parser   => $tcpdump,
-   protocol => $protocol,
-   file     => 't/lib/samples/memcached/memc_tcpdump005.txt',
-   result   => [
-      {  Query_time => '0.003928',
-         bytes      => 17946,
-         cmd        => 'set',
-         exptime    => 0,
-         flags      => 0,
-         host       => '127.0.0.1',
-         key        => 'my_key',
-         pos_in_log => 764,
-         res        => 'STORED',
-         ts         => '2009-07-06 22:07:14.406827',
-         val        => ('lorem ipsum dolor sit amet' x 690) . ' fini!',
-      },
-   ],
-);
-
-# A session with a huge get() that will not fit into a single TCP packet.
-$protocol = new MemcachedProtocolParser();
-test_protocol_parser(
-   parser   => $tcpdump,
-   protocol => $protocol,
-   file     => 't/lib/samples/memcached/memc_tcpdump006.txt',
-   result   => [
-      {
-         Query_time => '0.000196',
-         bytes      => 17946,
-         cmd        => 'get',
-         exptime    => 0,
-         flags      => 0,
-         host       => '127.0.0.1',
-         key        => 'my_key',
-         pos_in_log => 0,
-         res        => 'VALUE',
-         ts         => '2009-07-06 22:07:14.411331',
-         val        => ('lorem ipsum dolor sit amet' x 690) . ' fini!',
-      },
-   ],
-);
-
-# A session with a get() that doesn't exist.
-$protocol = new MemcachedProtocolParser();
-test_protocol_parser(
-   parser   => $tcpdump,
-   protocol => $protocol,
-   file     => 't/lib/samples/memcached/memc_tcpdump007.txt',
-   result   => [
-      {
-         Query_time => '0.000016',
-         bytes      => 0,
-         cmd        => 'get',
-         exptime    => 0,
-         flags      => 0,
-         host       => '127.0.0.1',
-         key        => 'comment_v3_482685',
-         pos_in_log => 0,
-         res        => 'NOT_FOUND',
-         ts         => '2009-06-11 21:54:49.059144',
-         val        => '',
-      },
-   ],
-);
-
-# A session with a huge get() that will not fit into a single TCP packet, but
-# the connection seems to be broken in the middle of the receive and then the
-# new client picks up and asks for something different.
-$protocol = new MemcachedProtocolParser();
-test_protocol_parser(
-   parser   => $tcpdump,
-   protocol => $protocol,
-   file     => 't/lib/samples/memcached/memc_tcpdump008.txt',
-   result   => [
-      {
-         Query_time => '0.000003',
-         bytes      => 17946,
-         cmd        => 'get',
-         exptime    => 0,
-         flags      => 0,
-         host       => '127.0.0.1',
-         key        => 'my_key',
-         pos_in_log => 0,
-         res        => 'INTERRUPTED',
-         ts         => '2009-07-06 22:07:14.411331',
-         val        => '',
-      },
-      {  Query_time => '0.000001',
-         cmd        => 'get',
-         key        => 'my_key',
-         val        => 'Some value',
-         bytes      => 10,
-         exptime    => 0,
-         flags      => 0,
-         host       => '127.0.0.1',
-         pos_in_log => 5382,
-         res        => 'VALUE',
-         ts         => '2009-07-06 22:07:14.411334',
-      },
-   ],
-);
-
-# A session with a delete() that doesn't exist. TODO: delete takes a queue_time.
-$protocol = new MemcachedProtocolParser();
-test_protocol_parser(
-   parser   => $tcpdump,
-   protocol => $protocol,
-   file     => 't/lib/samples/memcached/memc_tcpdump009.txt',
-   result   => [
-      {
-         Query_time => '0.000022',
-         bytes      => 0,
-         cmd        => 'delete',
-         exptime    => 0,
-         flags      => 0,
-         host       => '127.0.0.1',
-         key        => 'comment_1873527',
-         pos_in_log => 0,
-         res        => 'NOT_FOUND',
-         ts         => '2009-06-11 21:54:52.244534',
-         val        => '',
-      },
-   ],
-);
-
-# A session with a delete() that does exist.
-$protocol = new MemcachedProtocolParser();
-test_protocol_parser(
-   parser   => $tcpdump,
-   protocol => $protocol,
-   file     => 't/lib/samples/memcached/memc_tcpdump010.txt',
-   result   => [
-      {
-         Query_time => '0.000120',
-         bytes      => 0,
-         cmd        => 'delete',
-         exptime    => 0,
-         flags      => 0,
-         host       => '127.0.0.1',
-         key        => 'my_key',
-         pos_in_log => 0,
-         res        => 'DELETED',
-         ts         => '2009-07-09 22:00:29.066476',
-         val        => '',
-      },
-   ],
-);
-
-# #############################################################################
-# Issue 537: MySQLProtocolParser and MemcachedProtocolParser do not handle
-# multiple servers.
-# #############################################################################
-$protocol = new MemcachedProtocolParser();
-test_protocol_parser(
-   parser   => $tcpdump,
-   protocol => $protocol,
-   file     => 't/lib/samples/memcached/memc_tcpdump011.txt',
-   result   => [
-      {  Query_time => '0.000067',
-         cmd        => 'get',
-         key        => 'my_key',
-         val        => 'Some value',
-         bytes      => 10,
-         exptime    => 0,
-         flags      => 0,
-         host       => '127.0.0.8',
-         pos_in_log => '0',
-         res        => 'VALUE',
-         ts         => '2009-07-04 22:12:06.174390'
-      },
-      {  ts            => '2009-07-04 21:33:39.229179',
-         host          => '127.0.0.9',
-         cmd           => 'set',
-         key           => 'my_key',
-         val           => 'Some value',
-         flags         => '0',
-         exptime       => '0',
-         bytes         => '10',
-         res           => 'STORED',
-         Query_time    => sprintf('%.6f', .229299 - .229179),
-         pos_in_log    => 638,
-      },
-   ],
-);
-
-# #############################################################################
-# Issue 544: memcached parse error
-# #############################################################################
-
-# Multiple delete in one packet.
-$protocol = new MemcachedProtocolParser();
-test_protocol_parser(
-   parser   => $tcpdump,
-   protocol => $protocol,
-   file     => 't/lib/samples/memcached/memc_tcpdump014.txt',
-   result   => [
-      {  ts          => '2009-10-06 10:31:56.323538',
-         Query_time  => '0.000024',
-         bytes       => 0,
-         cmd         => 'delete',
-         exptime     => 0,
-         flags       => 0,
-         host        => '10.0.0.5',
-         key         => 'ABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBC',
-         pos_in_log  => 0,
-         res         => 'NOT_FOUND',
-         val         => ''
-      },
-   ],
-);
-
-# Multiple mixed commands: get delete delete
-$protocol = new MemcachedProtocolParser();
-test_protocol_parser(
-   parser   => $tcpdump,
-   protocol => $protocol,
-   file     => 't/lib/samples/memcached/memc_tcpdump015.txt',
-   result   => [
-      {  ts          => '2009-10-06 10:31:56.330709',
-         Query_time  => '0.000013',
-         bytes       => 0,
-         cmd         => 'get',
-         exptime     => 0,
-         flags       => 0,
-         host        => '10.0.0.5',
-         key         => 'ABBBBBBBBBBBBBBBBBBBBBC',
-         pos_in_log  => 0,
-         res         => 'NOT_FOUND',
-         
-         val => ''
-      },
-   ],
-);
-
-
-# #############################################################################
-# Issue 818: mk-query-digest: error parsing memcached dump - use of
-# uninitialized value in addition
-# #############################################################################
-
-# A replace command.
-$protocol = new MemcachedProtocolParser();
-test_protocol_parser(
-   parser   => $tcpdump,
-   protocol => $protocol,
-   file     => 't/lib/samples/memcached/memc_tcpdump016.txt',
-   result   => [
-      {  ts         => '2010-01-20 10:27:18.510727',
-         Query_time => '0.000030',
-         bytes      => 56,
-         cmd        => 'replace',
-         exptime    => '43200',
-         flags      => '1',
-         host       => '192.168.0.3',
-         key        => 'BD_Uk_cms__20100120_095702tab_containerId_410',
-         pos_in_log => 0,
-         res        => 'STORED',
-         val        => 'a:3:{i:0;s:6:"a:0:{}";i:1;i:1263983238;i:2;s:5:"43200";}'
-      },
-      {  ts         => '2010-01-20 10:27:18.510876',
-         Query_time => '0.000066',
-         bytes      => '56',
-         cmd        => 'get',
-         exptime    => 0,
-         flags      => '1',
-         host       => '192.168.0.3',
-         key        => 'BD_Uk_cms__20100120_095702tab_containerId_410',
-         pos_in_log => 893,
-         res        => 'VALUE',
-         val        => 'a:3:{i:0;s:6:"a:0:{}";i:1;i:1263983238;i:2;s:5:"43200";}'
-      }
-   ],
-);