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

[Daniel Nichter]

[lp:~percona-toolkit-dev/percona-toolkit/simplify-pqd]

509. By Daniel Nichter on 2013-01-17

Fix util/update-modules so it doesn't leave tmp files lying around.

510. By Daniel Nichter on 2013-01-17

Make t/pt-archiver/file.t clean up after itself.

511. By Daniel Nichter on 2013-01-19

Add df -h and w to jenkins-test just in case.

512. By Daniel Nichter on 2013-01-19

Remove t/lib/TimeSeriesTrender.t

513. By Daniel Nichter on 2013-01-22

Add env to jenkins-test.

514. By Brian Fraser on 2013-01-31

Merged simplify-pqd

=== modified file 'bin/pt-query-digest'
--- bin/pt-query-digest	2013-01-03 00:54:18 +0000
+++ bin/pt-query-digest	2013-01-30 20:58:23 +0000
@@ -14,6 +14,7 @@
 BEGIN {
    $INC{$_} = __FILE__ for map { (my $pkg = "$_.pm") =~ s!::!/!g; $pkg } (qw(
       Percona::Toolkit
+      Mo
       DSNParser
       Quoter
       OptionParser
@@ -29,6 +30,7 @@
       EventAggregator
       ReportFormatter
       QueryReportFormatter
+      JSONReportFormatter
       EventTimeline
       QueryParser
       TableParser
@@ -41,11 +43,9 @@
       RawLogParser
       ProtocolParser
       HTTPProtocolParser
-      ExecutionThrottler
       MasterSlave
       Progress
       FileIterator
-      ExplainAnalyzer
       Runtime
       Pipeline
       VersionCheck
@@ -73,6 +73,468 @@
 # ###########################################################################
 
 # ###########################################################################
+# Mo 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/Mo.pm
+#   t/lib/Mo.t
+# See https://launchpad.net/percona-toolkit for more information.
+# ###########################################################################
+{
+BEGIN {
+$INC{"Mo.pm"} = __FILE__;
+package Mo;
+our $VERSION = '0.30_Percona'; # Forked from 0.30 of Mo.
+
+{
+   no strict 'refs';
+   sub _glob_for {
+      return \*{shift()}
+   }
+
+   sub _stash_for {
+      return \%{ shift() . "::" };
+   }
+}
+
+use strict;
+use warnings qw( FATAL all );
+
+use Carp ();
+use Scalar::Util qw(looks_like_number blessed);
+
+
+our %TYPES = (
+   Bool   => sub { !$_[0] || (defined $_[0] && looks_like_number($_[0]) && $_[0] == 1) },
+   Num    => sub { defined $_[0] && looks_like_number($_[0]) },
+   Int    => sub { defined $_[0] && looks_like_number($_[0]) && $_[0] == int($_[0]) },
+   Str    => sub { defined $_[0] },
+   Object => sub { defined $_[0] && blessed($_[0]) },
+   FileHandle => sub { local $@; require IO::Handle; fileno($_[0]) && $_[0]->opened },
+
+   map {
+      my $type = /R/ ? $_ : uc $_;
+      $_ . "Ref" => sub { ref $_[0] eq $type }
+   } qw(Array Code Hash Regexp Glob Scalar)
+);
+
+our %metadata_for;
+{
+   package Mo::Object;
+
+   sub new {
+      my $class = shift;
+      my $args  = $class->BUILDARGS(@_);
+
+      my @args_to_delete;
+      while ( my ($attr, $meta) = each %{$metadata_for{$class}} ) {
+         next unless exists $meta->{init_arg};
+         my $init_arg = $meta->{init_arg};
+
+         if ( defined $init_arg ) {
+            $args->{$attr} = delete $args->{$init_arg};
+         }
+         else {
+            push @args_to_delete, $attr;
+         }
+      }
+
+      delete $args->{$_} for @args_to_delete;
+
+      for my $attribute ( keys %$args ) {
+         if ( my $coerce = $metadata_for{$class}{$attribute}{coerce} ) {
+            $args->{$attribute} = $coerce->($args->{$attribute});
+         }
+         if ( my $I = $metadata_for{$class}{$attribute}{isa} ) {
+            ( (my $I_name), $I ) = @{$I};
+            Mo::_check_type_constaints($attribute, $I, $I_name, $args->{$attribute});
+         }
+      }
+
+      while ( my ($attribute, $meta) = each %{$metadata_for{$class}} ) {
+         next unless $meta->{required};
+         Carp::confess("Attribute ($attribute) is required for $class")
+            if ! exists $args->{$attribute}
+      }
+
+      @_ = %$args;
+      my $self = bless $args, $class;
+
+      my @build_subs;
+      my $linearized_isa = mro::get_linear_isa($class);
+
+      for my $isa_class ( @$linearized_isa ) {
+         unshift @build_subs, *{ Mo::_glob_for "${isa_class}::BUILD" }{CODE};
+      }
+      exists &$_ && $_->( $self, @_ ) for grep { defined } @build_subs;
+      return $self;
+   }
+
+   sub BUILDARGS {
+      shift;
+      my $ref;
+      if ( @_ == 1 && ref($_[0]) ) {
+         Carp::confess("Single parameters to new() must be a HASH ref")
+            unless ref($_[0]) eq ref({});
+         $ref = {%{$_[0]}} # We want a new reference, always
+      }
+      else {
+         $ref = { @_ };
+      }
+      return $ref;
+   }
+}
+
+my %export_for;
+sub Mo::import {
+    warnings->import(qw(FATAL all));
+    strict->import();
+    
+    my $caller     = scalar caller(); # Caller's package
+    my $caller_pkg = $caller . "::"; # Caller's package with :: at the end
+    my (%exports, %options);
+
+    my (undef, @features) = @_;
+    my %ignore = ( map { $_ => 1 } qw( is isa init_arg builder buildargs clearer predicate build handles default required ) );
+    for my $feature (grep { !$ignore{$_} } @features) {
+      { local $@; require "Mo/$feature.pm"; }
+      {
+         no strict 'refs';
+         &{"Mo::${feature}::e"}(
+                  $caller_pkg,
+                  \%exports,
+                  \%options,
+                  \@_
+            );
+      }
+    }
+
+    return if $exports{M}; 
+
+    %exports = (
+        extends => sub {
+            for my $class ( map { "$_" } @_ ) {
+               $class =~ s{::|'}{/}g;
+               { local $@; eval { require "$class.pm" } } # or warn $@;
+            }
+            _set_package_isa($caller, @_);
+            _set_inherited_metadata($caller);
+        },
+        override => \&override,
+        has => sub {
+            my $names = shift;
+            for my $attribute ( ref $names ? @$names : $names ) {
+               my %args   = @_;
+               my $method = ($args{is} || '') eq 'ro'
+                  ? sub {
+                     Carp::confess("Cannot assign a value to a read-only accessor at reader ${caller_pkg}${attribute}")
+                        if $#_;
+                     return $_[0]{$attribute};
+                  }
+                  : sub {
+                     return $#_
+                           ? $_[0]{$attribute} = $_[1]
+                           : $_[0]{$attribute};
+                  };
+
+               $metadata_for{$caller}{$attribute} = ();
+
+               if ( my $I = $args{isa} ) {
+                  my $orig_I = $I;
+                  my $type;
+                  if ( $I =~ /\A(ArrayRef|Maybe)\[(.*)\]\z/ ) {
+                     $I = _nested_constraints($attribute, $1, $2);
+                  }
+                  $metadata_for{$caller}{$attribute}{isa} = [$orig_I, $I];
+                  my $orig_method = $method;
+                  $method = sub {
+                     if ( $#_ ) {
+                        Mo::_check_type_constaints($attribute, $I, $orig_I, $_[1]);
+                     }
+                     goto &$orig_method;
+                  };
+               }
+
+               if ( my $builder = $args{builder} ) {
+                  my $original_method = $method;
+                  $method = sub {
+                        $#_
+                           ? goto &$original_method
+                           : ! exists $_[0]{$attribute}
+                              ? $_[0]{$attribute} = $_[0]->$builder
+                              : goto &$original_method
+                  };
+               }
+
+               if ( my $code = $args{default} ) {
+                  Carp::confess("${caller}::${attribute}'s default is $code, but should be a coderef")
+                        unless ref($code) eq 'CODE';
+                  my $original_method = $method;
+                  $method = sub {
+                        $#_
+                           ? goto &$original_method
+                           : ! exists $_[0]{$attribute}
+                              ? $_[0]{$attribute} = $_[0]->$code
+                              : goto &$original_method
+                  };
+               }
+
+               if ( my $role = $args{does} ) {
+                  my $original_method = $method;
+                  $method = sub {
+                     if ( $#_ ) {
+                        Carp::confess(qq<Attribute ($attribute) doesn't consume a '$role' role">)
+                           unless Scalar::Util::blessed($_[1]) && eval { $_[1]->does($role) }
+                     }
+                     goto &$original_method
+                  };
+               }
+
+               if ( my $coercion = $args{coerce} ) {
+                  $metadata_for{$caller}{$attribute}{coerce} = $coercion;
+                  my $original_method = $method;
+                  $method = sub {
+                     if ( $#_ ) {
+                        return $original_method->($_[0], $coercion->($_[1]))
+                     }
+                     goto &$original_method;
+                  }
+               }
+
+               $method = $options{$_}->($method, $attribute, @_)
+                  for sort keys %options;
+
+               *{ _glob_for "${caller}::$attribute" } = $method;
+
+               if ( $args{required} ) {
+                  $metadata_for{$caller}{$attribute}{required} = 1;
+               }
+
+               if ($args{clearer}) {
+                  *{ _glob_for "${caller}::$args{clearer}" }
+                     = sub { delete shift->{$attribute} }
+               }
+
+               if ($args{predicate}) {
+                  *{ _glob_for "${caller}::$args{predicate}" }
+                     = sub { exists shift->{$attribute} }
+               }
+
+               if ($args{handles}) {
+                  _has_handles($caller, $attribute, \%args);
+               }
+
+               if (exists $args{init_arg}) {
+                  $metadata_for{$caller}{$attribute}{init_arg} = $args{init_arg};
+               }
+            }
+        },
+        %exports,
+    );
+
+    $export_for{$caller} = [ keys %exports ];
+
+    for my $keyword ( keys %exports ) {
+      *{ _glob_for "${caller}::$keyword" } = $exports{$keyword}
+    }
+    *{ _glob_for "${caller}::extends" }{CODE}->( "Mo::Object" )
+      unless @{ *{ _glob_for "${caller}::ISA" }{ARRAY} || [] };
+};
+
+sub _check_type_constaints {
+   my ($attribute, $I, $I_name, $val) = @_;
+   ( ref($I) eq 'CODE'
+      ? $I->($val)
+      : (ref $val eq $I
+         || ($val && $val eq $I)
+         || (exists $TYPES{$I} && $TYPES{$I}->($val)))
+   )
+   || Carp::confess(
+         qq<Attribute ($attribute) does not pass the type constraint because: >
+      . qq<Validation failed for '$I_name' with value >
+      . (defined $val ? Mo::Dumper($val) : 'undef') )
+}
+
+sub _has_handles {
+   my ($caller, $attribute, $args) = @_;
+   my $handles = $args->{handles};
+
+   my $ref = ref $handles;
+   my $kv;
+   if ( $ref eq ref [] ) {
+         $kv = { map { $_,$_ } @{$handles} };
+   }
+   elsif ( $ref eq ref {} ) {
+         $kv = $handles;
+   }
+   elsif ( $ref eq ref qr// ) {
+         Carp::confess("Cannot delegate methods based on a Regexp without a type constraint (isa)")
+            unless $args->{isa};
+         my $target_class = $args->{isa};
+         $kv = {
+            map   { $_, $_     }
+            grep  { $_ =~ $handles }
+            grep  { !exists $Mo::Object::{$_} && $target_class->can($_) }
+            grep  { $_ ne 'has' && $_ ne 'extends' }
+            keys %{ _stash_for $target_class }
+         };
+   }
+   else {
+         Carp::confess("handles for $ref not yet implemented");
+   }
+
+   while ( my ($method, $target) = each %{$kv} ) {
+         my $name = _glob_for "${caller}::$method";
+         Carp::confess("You cannot overwrite a locally defined method ($method) with a delegation")
+            if defined &$name;
+
+         my ($target, @curried_args) = ref($target) ? @$target : $target;
+         *$name = sub {
+            my $self        = shift;
+            my $delegate_to = $self->$attribute();
+            my $error = "Cannot delegate $method to $target because the value of $attribute";
+            Carp::confess("$error is not defined") unless $delegate_to;
+            Carp::confess("$error is not an object (got '$delegate_to')")
+               unless Scalar::Util::blessed($delegate_to) || (!ref($delegate_to) && $delegate_to->can($target));
+            return $delegate_to->$target(@curried_args, @_);
+         }
+   }
+}
+
+sub _nested_constraints {
+   my ($attribute, $aggregate_type, $type) = @_;
+
+   my $inner_types;
+   if ( $type =~ /\A(ArrayRef|Maybe)\[(.*)\]\z/ ) {
+      $inner_types = _nested_constraints($1, $2);
+   }
+   else {
+      $inner_types = $TYPES{$type};
+   }
+
+   if ( $aggregate_type eq 'ArrayRef' ) {
+      return sub {
+         my ($val) = @_;
+         return unless ref($val) eq ref([]);
+
+         if ($inner_types) {
+            for my $value ( @{$val} ) {
+               return unless $inner_types->($value) 
+            }
+         }
+         else {
+            for my $value ( @{$val} ) {
+               return unless $value && ($value eq $type
+                        || (Scalar::Util::blessed($value) && $value->isa($type)));
+            }
+         }
+         return 1;
+      };
+   }
+   elsif ( $aggregate_type eq 'Maybe' ) {
+      return sub {
+         my ($value) = @_;
+         return 1 if ! defined($value);
+         if ($inner_types) {
+            return unless $inner_types->($value) 
+         }
+         else {
+            return unless $value eq $type
+                        || (Scalar::Util::blessed($value) && $value->isa($type));
+         }
+         return 1;
+      }
+   }
+   else {
+      Carp::confess("Nested aggregate types are only implemented for ArrayRefs and Maybe");
+   }
+}
+
+sub _set_package_isa {
+   my ($package, @new_isa) = @_;
+
+   *{ _glob_for "${package}::ISA" } = [@new_isa];
+}
+
+sub _set_inherited_metadata {
+   my $class = shift;
+   my $linearized_isa = mro::get_linear_isa($class);
+   my %new_metadata;
+
+   for my $isa_class (reverse @$linearized_isa) {
+      %new_metadata = (
+         %new_metadata,
+         %{ $metadata_for{$isa_class} || {} },
+      );
+   }
+   $metadata_for{$class} = \%new_metadata;
+}
+
+sub unimport {
+   my $caller = scalar caller();
+   my $stash  = _stash_for( $caller );
+
+   delete $stash->{$_} for @{$export_for{$caller}};
+}
+
+sub Dumper {
+   require Data::Dumper;
+   local $Data::Dumper::Indent    = 0;
+   local $Data::Dumper::Sortkeys  = 0;
+   local $Data::Dumper::Quotekeys = 0;
+   local $Data::Dumper::Terse     = 1;
+
+   Data::Dumper::Dumper(@_)
+}
+
+BEGIN {
+   if ($] >= 5.010) {
+      { local $@; require mro; }
+   }
+   else {
+      local $@;
+      eval {
+         require MRO::Compat;
+      } or do {
+         *mro::get_linear_isa = *mro::get_linear_isa_dfs = sub {
+            no strict 'refs';
+
+            my $classname = shift;
+
+            my @lin = ($classname);
+            my %stored;
+            foreach my $parent (@{"$classname\::ISA"}) {
+               my $plin = mro::get_linear_isa_dfs($parent);
+               foreach (@$plin) {
+                     next if exists $stored{$_};
+                     push(@lin, $_);
+                     $stored{$_} = 1;
+               }
+            }
+            return \@lin;
+         };
+      }
+   }
+}
+
+sub override {
+   my ($methods, $code) = @_;
+   my $caller          = scalar caller;
+
+   for my $method ( ref($methods) ? @$methods : $methods ) {
+      my $full_method     = "${caller}::${method}";
+      *{_glob_for $full_method} = $code;
+   }
+}
+
+}
+1;
+}
+# ###########################################################################
+# End Mo package
+# ###########################################################################
+
+# ###########################################################################
 # DSNParser 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,
@@ -1620,24 +2082,26 @@
 use Digest::MD5 qw(md5_hex);
 use B qw();
 
-require Exporter;
-our @ISA         = qw(Exporter);
-our %EXPORT_TAGS = ();
-our @EXPORT      = ();
-our @EXPORT_OK   = qw(
-   micro_t
-   percentage_of
-   secs_to_time
-   time_to_secs
-   shorten
-   ts
-   parse_timestamp
-   unix_timestamp
-   any_unix_timestamp
-   make_checksum
-   crc32
-   encode_json
-);
+BEGIN {
+   require Exporter;
+   our @ISA         = qw(Exporter);
+   our %EXPORT_TAGS = ();
+   our @EXPORT      = ();
+   our @EXPORT_OK   = qw(
+      micro_t
+      percentage_of
+      secs_to_time
+      time_to_secs
+      shorten
+      ts
+      parse_timestamp
+      unix_timestamp
+      any_unix_timestamp
+      make_checksum
+      crc32
+      encode_json
+   );
+}
 
 our $mysql_ts  = qr/(\d\d)(\d\d)(\d\d) +(\d+):(\d+):(\d+)(\.\d+)?/;
 our $proper_ts = qr/(\d\d\d\d)-(\d\d)-(\d\d)[T ](\d\d):(\d\d):(\d\d)(\.\d+)?/;
@@ -5448,15 +5912,6 @@
                   $classes->{$class}->{$attrib}->{all},
                   $classes->{$class}->{$attrib}
                );
-
-            if ( $args{apdex_t} && $attrib eq 'Query_time' ) {
-               $class_metrics->{$class}->{$attrib}->{apdex_t} = $args{apdex_t};
-               $class_metrics->{$class}->{$attrib}->{apdex}
-                  = $self->calculate_apdex(
-                     t       => $args{apdex_t},
-                     samples => $classes->{$class}->{$attrib}->{all},
-                  );
-            }
          }
       }
    }
@@ -5581,9 +6036,6 @@
       median => $metrics->{classes}->{$where}->{$attrib}->{median} || 0,
       pct_95 => $metrics->{classes}->{$where}->{$attrib}->{pct_95} || 0,
       stddev => $metrics->{classes}->{$where}->{$attrib}->{stddev} || 0,
-
-      apdex_t => $metrics->{classes}->{$where}->{$attrib}->{apdex_t},
-      apdex   => $metrics->{classes}->{$where}->{$attrib}->{apdex},
    };
 }
 
@@ -5899,51 +6351,6 @@
    return $copy;
 }
 
-sub calculate_apdex {
-   my ( $self, %args ) = @_;
-   my @required_args = qw(t samples);
-   foreach my $arg ( @required_args ) {
-      die "I need a $arg argument" unless $args{$arg};
-   }
-   my ($t, $samples) = @args{@required_args};
-
-   if ( $t <= 0 ) {
-      die "Invalid target threshold (T): $t.  T must be greater than zero";
-   }
-
-   my $f = 4 * $t;
-   PTDEBUG && _d("Apdex T =", $t, "F =", $f);
-
-   my $satisfied  = 0;
-   my $tolerating = 0;
-   my $frustrated = 0;  # just for debug output
-   my $n_samples  = 0;
-   BUCKET:
-   for my $bucket ( keys %$samples ) {
-      my $n_responses   = $samples->{$bucket};
-      my $response_time = $buck_vals[$bucket];
-
-      if ( $response_time <= $t ) {
-         $satisfied += $n_responses;
-      }
-      elsif ( $response_time <= $f ) {
-         $tolerating += $n_responses;
-      }
-      else {
-         $frustrated += $n_responses;
-      }
-
-      $n_samples += $n_responses;
-   }
-
-   my $apdex = sprintf('%.2f', ($satisfied + ($tolerating / 2)) / $n_samples);
-   PTDEBUG && _d($n_samples, "samples,", $satisfied, "satisfied,",
-      $tolerating, "tolerating,", $frustrated, "frustrated, Apdex score:",
-      $apdex);
-
-   return $apdex;
-}
-
 sub _get_value {
    my ( $self, %args ) = @_;
    my ($event, $attrib, $alts) = @args{qw(event attribute alternates)};
@@ -5997,8 +6404,7 @@
 {
 package ReportFormatter;
 
-use strict;
-use warnings FATAL => 'all';
+use Mo;
 use English qw(-no_match_vars);
 use constant PTDEBUG => $ENV{PTDEBUG} || 0;
 
@@ -6008,40 +6414,102 @@
 eval { require Term::ReadKey };
 my $have_term = $EVAL_ERROR ? 0 : 1;
 
-sub new {
-   my ( $class, %args ) = @_;
-   my @required_args = qw();
-   foreach my $arg ( @required_args ) {
-      die "I need a $arg argument" unless $args{$arg};
-   }
-   my $self = {
-      underline_header     => 1,
-      line_prefix          => '# ',
-      line_width           => 78,
-      column_spacing       => ' ',
-      extend_right         => 0,
-      truncate_line_mark   => '...',
-      column_errors        => 'warn',
-      truncate_header_side => 'left',
-      strip_whitespace     => 1,
-      %args,              # args above can be overriden, args below cannot
-      n_cols              => 0,
-   };
-
-   if ( ($self->{line_width} || '') eq 'auto' ) {
+
+has underline_header => (
+   is      => 'ro',
+   isa     => 'Bool',
+   default => sub { 1 },
+);
+has line_prefix => (
+   is      => 'ro',
+   isa     => 'Str',
+   default => sub { '# ' },
+);
+has line_width => (
+   is      => 'ro',
+   isa     => 'Int',
+   default => sub { 78 },
+);
+has column_spacing => (
+   is      => 'ro',
+   isa     => 'Str',
+   default => sub { ' ' },
+);
+has extend_right => (
+   is      => 'ro',
+   isa     => 'Bool',
+   default => sub { '' },
+);
+has truncate_line_mark => (
+   is      => 'ro',
+   isa     => 'Str',
+   default => sub { '...' },
+);
+has column_errors => (
+   is      => 'ro',
+   isa     => 'Str',
+   default => sub { 'warn' },
+);
+has truncate_header_side => (
+   is      => 'ro',
+   isa     => 'Str',
+   default => sub { 'left' },
+);
+has strip_whitespace => (
+   is      => 'ro',
+   isa     => 'Bool',
+   default => sub { 1 },
+);
+has title => (
+   is        => 'rw',
+   isa       => 'Str',
+   predicate => 'has_title',
+);
+
+
+has n_cols => (
+   is      => 'rw',
+   isa     => 'Int',
+   default => sub { 0 },
+   init_arg => undef,
+);
+
+has cols => (
+   is       => 'ro',
+   isa      => 'ArrayRef',
+   init_arg => undef,
+   default  => sub { [] },
+   clearer  => 'clear_cols',
+);
+
+has lines => (
+   is       => 'ro',
+   isa      => 'ArrayRef',
+   init_arg => undef,
+   default  => sub { [] },
+   clearer  => 'clear_lines',
+);
+
+has truncate_headers => (
+   is       => 'rw',
+   isa      => 'Bool',
+   default  => sub { undef },
+   init_arg => undef,
+   clearer  => 'clear_truncate_headers',
+);
+
+sub BUILDARGS {
+   my $class = shift;
+   my $args  = $class->SUPER::BUILDARGS(@_);
+
+   if ( ($args->{line_width} || '') eq 'auto' ) {
       die "Cannot auto-detect line width because the Term::ReadKey module "
          . "is not installed" unless $have_term;
-      ($self->{line_width}) = GetTerminalSize();
+      ($args->{line_width}) = GetTerminalSize();
+      PTDEBUG && _d('Line width:', $args->{line_width});
    }
-   PTDEBUG && _d('Line width:', $self->{line_width});
-
-   return bless $self, $class;
-}
-
-sub set_title {
-   my ( $self, $title ) = @_;
-   $self->{title} = $title;
-   return;
+
+   return $args;
 }
 
 sub set_columns {
@@ -6057,7 +6525,7 @@
       die "Column does not have a name" unless defined $col_name;
 
       if ( $col->{width} ) {
-         $col->{width_pct} = ceil(($col->{width} * 100) / $self->{line_width});
+         $col->{width_pct} = ceil(($col->{width} * 100) / $self->line_width());
          PTDEBUG && _d('col:', $col_name, 'width:', $col->{width}, 'chars =',
             $col->{width_pct}, '%');
       }
@@ -6084,10 +6552,10 @@
 
       $col->{right_most} = 1 if $i == $#cols;
 
-      push @{$self->{cols}}, $col;
+      push @{$self->cols}, $col;
    }
 
-   $self->{n_cols} = scalar @cols;
+   $self->n_cols( scalar @cols );
 
    if ( ($used_width || 0) > 100 ) {
       die "Total width_pct for all columns is >100%";
@@ -6097,15 +6565,15 @@
       my $wid_per_col = int((100 - $used_width) / scalar @auto_width_cols);
       PTDEBUG && _d('Line width left:', (100-$used_width), '%;',
          'each auto width col:', $wid_per_col, '%');
-      map { $self->{cols}->[$_]->{width_pct} = $wid_per_col } @auto_width_cols;
+      map { $self->cols->[$_]->{width_pct} = $wid_per_col } @auto_width_cols;
    }
 
-   $min_hdr_wid += ($self->{n_cols} - 1) * length $self->{column_spacing};
+   $min_hdr_wid += ($self->n_cols() - 1) * length $self->column_spacing();
    PTDEBUG && _d('min header width:', $min_hdr_wid);
-   if ( $min_hdr_wid > $self->{line_width} ) {
+   if ( $min_hdr_wid > $self->line_width() ) {
       PTDEBUG && _d('Will truncate headers because min header width',
-         $min_hdr_wid, '> line width', $self->{line_width});
-      $self->{truncate_headers} = 1;
+         $min_hdr_wid, '> line width', $self->line_width());
+      $self->truncate_headers(1);
    }
 
    return;
@@ -6114,14 +6582,14 @@
 sub add_line {
    my ( $self, @vals ) = @_;
    my $n_vals = scalar @vals;
-   if ( $n_vals != $self->{n_cols} ) {
+   if ( $n_vals != $self->n_cols() ) {
       $self->_column_error("Number of values $n_vals does not match "
-         . "number of columns $self->{n_cols}");
+         . "number of columns " . $self->n_cols());
    }
    for my $i ( 0..($n_vals-1) ) {
-      my $col   = $self->{cols}->[$i];
+      my $col   = $self->cols->[$i];
       my $val   = defined $vals[$i] ? $vals[$i] : $col->{undef_value};
-      if ( $self->{strip_whitespace} ) {
+      if ( $self->strip_whitespace() ) {
          $val =~ s/^\s+//g;
          $val =~ s/\s+$//;
          $vals[$i] = $val;
@@ -6130,7 +6598,7 @@
       $col->{min_val} = min($width, ($col->{min_val} || $width));
       $col->{max_val} = max($width, ($col->{max_val} || $width));
    }
-   push @{$self->{lines}}, \@vals;
+   push @{$self->lines}, \@vals;
    return;
 }
 
@@ -6138,26 +6606,28 @@
    my ( $self, %args ) = @_;
 
    $self->_calculate_column_widths();
-   $self->_truncate_headers() if $self->{truncate_headers};
+   if ( $self->truncate_headers() ) {
+      $self->_truncate_headers();
+   }
    $self->_truncate_line_values(%args);
 
    my @col_fmts = $self->_make_column_formats();
-   my $fmt      = ($self->{line_prefix} || '')
-                . join($self->{column_spacing}, @col_fmts);
+   my $fmt      = $self->line_prefix()
+                . join($self->column_spacing(), @col_fmts);
    PTDEBUG && _d('Format:', $fmt);
 
    (my $hdr_fmt = $fmt) =~ s/%([^-])/%-$1/g;
 
    my @lines;
-   push @lines, sprintf "$self->{line_prefix}$self->{title}" if $self->{title};
+   push @lines, $self->line_prefix() . $self->title() if $self->has_title();
    push @lines, $self->_truncate_line(
-         sprintf($hdr_fmt, map { $_->{name} } @{$self->{cols}}),
+         sprintf($hdr_fmt, map { $_->{name} } @{$self->cols}),
          strip => 1,
          mark  => '',
    );
 
-   if ( $self->{underline_header} ) {
-      my @underlines = map { '=' x $_->{print_width} } @{$self->{cols}};
+   if ( $self->underline_header() ) {
+      my @underlines = map { '=' x $_->{print_width} } @{$self->cols};
       push @lines, $self->_truncate_line(
          sprintf($fmt, map { $_ || '' } @underlines),
          mark  => '',
@@ -6168,19 +6638,23 @@
       my $vals = $_;
       my $i    = 0;
       my @vals = map {
-            my $val = defined $_ ? $_ : $self->{cols}->[$i++]->{undef_value};
+            my $val = defined $_ ? $_ : $self->cols->[$i++]->{undef_value};
             $val = '' if !defined $val;
             $val =~ s/\n/ /g;
             $val;
       } @$vals;
       my $line = sprintf($fmt, @vals);
-      if ( $self->{extend_right} ) {
+      if ( $self->extend_right() ) {
          $line;
       }
       else {
          $self->_truncate_line($line);
       }
-   } @{$self->{lines}};
+   } @{$self->lines};
+
+   $self->clear_cols();
+   $self->clear_lines();
+   $self->clear_truncate_headers();
 
    return join("\n", @lines) . "\n";
 }
@@ -6188,7 +6662,7 @@
 sub truncate_value {
    my ( $self, $col, $val, $width, $side ) = @_;
    return $val if length $val <= $width;
-   return $val if $col->{right_most} && $self->{extend_right};
+   return $val if $col->{right_most} && $self->extend_right();
    $side  ||= $col->{truncate_side};
    my $mark = $col->{truncate_mark};
    if ( $side eq 'right' ) {
@@ -6208,8 +6682,8 @@
    my ( $self ) = @_;
 
    my $extra_space = 0;
-   foreach my $col ( @{$self->{cols}} ) {
-      my $print_width = int($self->{line_width} * ($col->{width_pct} / 100));
+   foreach my $col ( @{$self->cols} ) {
+      my $print_width = int($self->line_width() * ($col->{width_pct} / 100));
 
       PTDEBUG && _d('col:', $col->{name}, 'width pct:', $col->{width_pct},
          'char width:', $print_width,
@@ -6233,7 +6707,7 @@
 
    PTDEBUG && _d('Extra space:', $extra_space);
    while ( $extra_space-- ) {
-      foreach my $col ( @{$self->{cols}} ) {
+      foreach my $col ( @{$self->cols} ) {
          if (    $col->{auto_width}
               && (    $col->{print_width} < $col->{max_val}
                    || $col->{print_width} < $col->{header_width})
@@ -6248,8 +6722,8 @@
 
 sub _truncate_headers {
    my ( $self, $col ) = @_;
-   my $side = $self->{truncate_header_side};
-   foreach my $col ( @{$self->{cols}} ) {
+   my $side = $self->truncate_header_side();
+   foreach my $col ( @{$self->cols} ) {
       my $col_name    = $col->{name};
       my $print_width = $col->{print_width};
       next if length $col_name <= $print_width;
@@ -6262,10 +6736,10 @@
 
 sub _truncate_line_values {
    my ( $self, %args ) = @_;
-   my $n_vals = $self->{n_cols} - 1;
-   foreach my $vals ( @{$self->{lines}} ) {
+   my $n_vals = $self->n_cols() - 1;
+   foreach my $vals ( @{$self->lines} ) {
       for my $i ( 0..$n_vals ) {
-         my $col   = $self->{cols}->[$i];
+         my $col   = $self->cols->[$i];
          my $val   = defined $vals->[$i] ? $vals->[$i] : $col->{undef_value};
          my $width = length $val;
 
@@ -6291,9 +6765,9 @@
 sub _make_column_formats {
    my ( $self ) = @_;
    my @col_fmts;
-   my $n_cols = $self->{n_cols} - 1;
+   my $n_cols = $self->n_cols() - 1;
    for my $i ( 0..$n_cols ) {
-      my $col = $self->{cols}->[$i];
+      my $col = $self->cols->[$i];
 
       my $width = $col->{right_most} && !$col->{right_justify} ? ''
                 : $col->{print_width};
@@ -6306,12 +6780,12 @@
 
 sub _truncate_line {
    my ( $self, $line, %args ) = @_;
-   my $mark = defined $args{mark} ? $args{mark} : $self->{truncate_line_mark};
+   my $mark = defined $args{mark} ? $args{mark} : $self->truncate_line_mark();
    if ( $line ) {
       $line =~ s/\s+$// if $args{strip};
       my $len  = length($line);
-      if ( $len > $self->{line_width} ) {
-         $line  = substr($line, 0, $self->{line_width} - length $mark);
+      if ( $len > $self->line_width() ) {
+         $line  = substr($line, 0, $self->line_width() - length $mark);
          $line .= $mark if $mark;
       }
    }
@@ -6321,7 +6795,7 @@
 sub _column_error {
    my ( $self, $err ) = @_;
    my $msg = "Column error: $err";
-   $self->{column_errors} eq 'die' ? die $msg : warn $msg;
+   $self->column_errors() eq 'die' ? die $msg : warn $msg;
    return;
 }
 
@@ -6350,8 +6824,7 @@
 {
 package QueryReportFormatter;
 
-use strict;
-use warnings FATAL => 'all';
+use Mo;
 use English qw(-no_match_vars);
 use POSIX qw(floor);
 
@@ -6364,25 +6837,68 @@
 use constant LINE_LENGTH       => 74;
 use constant MAX_STRING_LENGTH => 10;
 
-sub new {
-   my ( $class, %args ) = @_;
-   foreach my $arg ( qw(OptionParser QueryRewriter Quoter) ) {
-      die "I need a $arg argument" unless $args{$arg};
+{ local $EVAL_ERROR; eval { require Quoter } };
+{ local $EVAL_ERROR; eval { require ReportFormatter } };
+
+has Quoter => (
+   is      => 'ro',
+   isa     => 'Quoter',
+   default => sub { Quoter->new() },
+);
+
+has label_width => (
+   is      => 'ro',
+   isa     => 'Int',
+);
+
+has global_headers => (
+   is      => 'ro',
+   isa     => 'ArrayRef',
+   default => sub { [qw(    total min max avg 95% stddev median)] },
+);
+
+has event_headers => (
+   is      => 'ro',
+   isa     => 'ArrayRef',
+   default => sub { [qw(pct total min max avg 95% stddev median)] },
+);
+
+has ReportFormatter => (
+   is      => 'ro',
+   isa     => 'ReportFormatter',
+   builder => '_build_report_formatter',
+);
+
+sub _build_report_formatter {
+   return ReportFormatter->new(
+      line_width       => LINE_LENGTH,
+      extend_right     => 1,
+   );
+}
+
+sub BUILDARGS {
+   my $class = shift;
+   my $args  = $class->SUPER::BUILDARGS(@_);
+
+   foreach my $arg ( qw(OptionParser QueryRewriter) ) {
+      die "I need a $arg argument" unless $args->{$arg};
    }
 
-   my $label_width = $args{label_width} || 12;
+   my $label_width = $args->{label_width} ||= 12;
    PTDEBUG && _d('Label width:', $label_width);
 
-   my $cheat_width = $label_width + 1;
-
+   my $o = delete $args->{OptionParser};
    my $self = {
-      %args,
-      label_width    => $label_width,
+      %$args,
+      options        => {
+         show_all         => $o->get('show-all'),
+         shorten          => $o->get('shorten'),
+         report_all       => $o->get('report-all'),
+         report_histogram => $o->get('report-histogram'),
+      },
       num_format     => "# %-${label_width}s %3s %7s %7s %7s %7s %7s %7s %7s",
       bool_format    => "# %-${label_width}s %3d%% yes, %3d%% no",
       string_format  => "# %-${label_width}s %s",
-      global_headers => [qw(    total min max avg 95% stddev median)],
-      event_headers  => [qw(pct total min max avg 95% stddev median)],
       hidden_attrib  => {   # Don't sort/print these attribs in the reports.
          arg         => 1, # They're usually handled specially, or not
          fingerprint => 1, # printed at all.
@@ -6390,18 +6906,7 @@
          ts          => 1,
       },
    };
-   return bless $self, $class;
-}
-
-sub set_report_formatter {
-   my ( $self, %args ) = @_;
-   my @required_args = qw(report formatter);
-   foreach my $arg ( @required_args ) {
-      die "I need a $arg argument" unless exists $args{$arg};
-   }
-   my ($report, $formatter) = @args{@required_args};
-   $self->{formatter_for}->{$report} = $formatter;
-   return;
+   return $self;
 }
 
 sub print_reports {
@@ -6507,7 +7012,7 @@
       shorten(scalar keys %{$results->{classes}}, d=>1_000),
       shorten($qps  || 0, d=>1_000),
       shorten($conc || 0, d=>1_000));
-   $line .= ('_' x (LINE_LENGTH - length($line) + $self->{label_width} - 12));
+   $line .= ('_' x (LINE_LENGTH - length($line) + $self->label_width() - 12));
    push @result, $line;
 
    if ( my $ts = $results->{globals}->{ts} ) {
@@ -6568,18 +7073,70 @@
    return join("\n", map { s/\s+$//; $_ } @result) . "\n";
 }
 
+sub query_report_values {
+   my ($self, %args) = @_;
+   foreach my $arg ( qw(ea worst orderby groupby) ) {
+      die "I need a $arg argument" unless defined $arg;
+   }
+   my $ea      = $args{ea};
+   my $groupby = $args{groupby};
+   my $worst   = $args{worst};
+
+   my $q   = $self->Quoter;
+   my $qv  = $self->{QueryReview};
+   my $qr  = $self->{QueryRewriter};
+
+   my @values;
+   ITEM:
+   foreach my $top_event ( @$worst ) {
+      my $item       = $top_event->[0];
+      my $reason     = $args{explain_why} ? $top_event->[1] : '';
+      my $rank       = $top_event->[2];
+      my $stats      = $ea->results->{classes}->{$item};
+      my $sample     = $ea->results->{samples}->{$item};
+      my $samp_query = $sample->{arg} || '';
+
+      my %item_vals = (
+         item       => $item,
+         samp_query => $samp_query,
+         rank       => ($rank || 0),
+         reason     => $reason,
+      );
+
+      my $review_vals;
+      if ( $qv ) {
+         $review_vals = $qv->get_review_info($item);
+         next ITEM if $review_vals->{reviewed_by} && !$self->{options}->{report_all};
+         for my $col ( $qv->review_cols() ) {
+            push @{$item_vals{review_vals}}, [$col, $review_vals->{$col}];
+         }
+      }
+
+      $item_vals{default_db} = $sample->{db}       ? $sample->{db}
+                              : $stats->{db}->{unq} ? keys %{$stats->{db}->{unq}}
+                              :                       undef;
+      $item_vals{tables} = [$self->{QueryParser}->extract_tables(
+            query      => $samp_query,
+            default_db => $item_vals{default_db},
+            Quoter     => $self->Quoter,
+         )];
+
+      if ( $samp_query && ($args{variations} && @{$args{variations}}) ) {
+         $item_vals{crc} = crc32($samp_query);
+      }
+
+      push @values, \%item_vals;
+   }
+   return \@values;
+}
+
 sub query_report {
    my ( $self, %args ) = @_;
-   foreach my $arg ( qw(ea worst orderby groupby) ) {
-      die "I need a $arg argument" unless defined $arg;
-   }
+
    my $ea      = $args{ea};
    my $groupby = $args{groupby};
-   my $worst   = $args{worst};
+   my $report_values = $self->query_report_values(%args);
 
-   my $o   = $self->{OptionParser};
-   my $q   = $self->{Quoter};
-   my $qv  = $self->{QueryReview};
    my $qr  = $self->{QueryRewriter};
 
    my $report = '';
@@ -6596,55 +7153,31 @@
    );
 
    ITEM:
-   foreach my $top_event ( @$worst ) {
-      my $item       = $top_event->[0];
-      my $reason     = $args{explain_why} ? $top_event->[1] : '';
-      my $rank       = $top_event->[2];
-      my $stats      = $ea->results->{classes}->{$item};
-      my $sample     = $ea->results->{samples}->{$item};
-      my $samp_query = $sample->{arg} || '';
-
-      my $review_vals;
-      if ( $qv ) {
-         $review_vals = $qv->get_review_info($item);
-         next ITEM if $review_vals->{reviewed_by} && !$o->get('report-all');
-      }
-
-      my ($default_db) = $sample->{db}       ? $sample->{db}
-                       : $stats->{db}->{unq} ? keys %{$stats->{db}->{unq}}
-                       :                       undef;
-      my @tables;
-      if ( $o->get('for-explain') ) {
-         @tables = $self->{QueryParser}->extract_tables(
-            query      => $samp_query,
-            default_db => $default_db,
-            Quoter     => $self->{Quoter},
-         );
-      }
-
-      $report .= "\n" if $rank > 1;  # space between each event report
+   foreach my $vals ( @$report_values ) {
+      my $item = $vals->{item};
+      $report .= "\n" if $vals->{rank} > 1;  # space between each event report
       $report .= $self->event_report(
          %args,
          item    => $item,
-         sample  => $sample,
-         rank    => $rank,
-         reason  => $reason,
+         sample  => $ea->results->{samples}->{$item},
+         rank    => $vals->{rank},
+         reason  => $vals->{reason},
          attribs => $attribs,
-         db      => $default_db,
+         db      => $vals->{default_db},
       );
 
-      if ( $o->get('report-histogram') ) {
+      if ( $self->{options}->{report_histogram} ) {
          $report .= $self->chart_distro(
             %args,
-            attrib => $o->get('report-histogram'),
-            item   => $item,
+            attrib => $self->{options}->{report_histogram},
+            item   => $vals->{item},
          );
       }
 
-      if ( $qv && $review_vals ) {
+      if ( $vals->{review_vals} ) {
          $report .= "# Review information\n";
-         foreach my $col ( $qv->review_cols() ) {
-            my $val = $review_vals->{$col};
+         foreach my $elem ( @{$vals->{review_vals}} ) {
+            my ($col, $val) = @$elem;
             if ( !$val || $val ne '0000-00-00 00:00:00' ) { # issue 202
                $report .= sprintf "# %13s: %-s\n", $col, ($val ? $val : '');
             }
@@ -6652,18 +7185,15 @@
       }
 
       if ( $groupby eq 'fingerprint' ) {
-         $samp_query = $qr->shorten($samp_query, $o->get('shorten'))
-            if $o->get('shorten');
-
-         $report .= "# Fingerprint\n#    $item\n"
-            if $o->get('fingerprints');
-
-         $report .= $self->tables_report(@tables)
-            if $o->get('for-explain');
-
-         if ( $samp_query && ($args{variations} && @{$args{variations}}) ) {
-            my $crc = crc32($samp_query);
-            $report.= "# CRC " . ($crc ? $crc % 1_000 : "") . "\n";
+         my $samp_query = $qr->shorten($vals->{samp_query}, $self->{options}->{shorten})
+            if $self->{options}->{shorten};
+
+         PTDEBUG && _d("Fingerprint\n#    $vals->{item}\n");
+
+         $report .= $self->tables_report(@{$vals->{tables}});
+
+         if ( $vals->{crc} ) {
+            $report.= "# CRC " . ($vals->{crc} % 1_000) . "\n";
          }
 
          my $log_type = $args{log_type} || '';
@@ -6677,14 +7207,13 @@
             }
             else {
                $report .= "# EXPLAIN /*!50100 PARTITIONS*/\n$samp_query${mark}\n"; 
-               $report .= $self->explain_report($samp_query, $default_db);
+               $report .= $self->explain_report($samp_query, $vals->{default_db});
             }
          }
          else {
             $report .= "$samp_query${mark}\n"; 
             my $converted = $qr->convert_to_select($samp_query);
-            if ( $o->get('for-explain')
-                 && $converted
+            if ( $converted
                  && $converted =~ m/^[\(\s]*select/i ) {
                $report .= "# Converted for EXPLAIN\n# EXPLAIN /*!50100 PARTITIONS*/\n$converted${mark}\n";
             }
@@ -6692,7 +7221,7 @@
       }
       else {
          if ( $groupby eq 'tables' ) {
-            my ( $db, $tbl ) = $q->split_unquote($item);
+            my ( $db, $tbl ) = $self->Quoter->split_unquote($item);
             $report .= $self->tables_report([$db, $tbl]);
          }
          $report .= "$item\n";
@@ -6702,20 +7231,19 @@
    return $report;
 }
 
-sub event_report {
-   my ( $self, %args ) = @_;
-   foreach my $arg ( qw(ea item orderby) ) {
-      die "I need a $arg argument" unless defined $args{$arg};
-   }
-   my $ea      = $args{ea};
-   my $item    = $args{item};
+sub event_report_values {
+   my ($self, %args) = @_;
+
+   my $ea   = $args{ea};
+   my $item = $args{item};
    my $orderby = $args{orderby};
    my $results = $ea->results();
-   my $o       = $self->{OptionParser};
-   my @result;
+
+   my %vals;
 
    my $store = $results->{classes}->{$item};
-   return "# No such event $item\n" unless $store;
+
+   return unless $store;
 
    my $global_cnt = $results->{globals}->{$orderby}->{cnt};
    my $class_cnt  = $store->{$orderby}->{cnt};
@@ -6734,67 +7262,25 @@
       };
    }
 
-   my $line = sprintf(
-      '# %s %d: %s QPS, %sx concurrency, ID 0x%s at byte %.f ',
-      ($ea->{groupby} eq 'fingerprint' ? 'Query' : 'Item'),
-      $args{rank} || 0,
-      shorten($qps  || 0, d=>1_000),
-      shorten($conc || 0, d=>1_000),
-      make_checksum($item),
-      $results->{samples}->{$item}->{pos_in_log} || 0,
-   );
-   $line .= ('_' x (LINE_LENGTH - length($line) + $self->{label_width} - 12));
-   push @result, $line;
-
-   if ( $args{reason} ) {
-      push @result,
-         "# This item is included in the report because it matches "
-            . ($args{reason} eq 'top' ? '--limit.' : '--outliers.');
-   }
-
-   {
+   $vals{groupby}     = $ea->{groupby};
+   $vals{qps}         = $qps  || 0;
+   $vals{concurrency} = $conc || 0;
+   $vals{checksum}    = make_checksum($item);
+   $vals{pos_in_log}  = $results->{samples}->{$item}->{pos_in_log} || 0;
+   $vals{reason}      = $args{reason};
+   $vals{variance_to_mean} = do {
       my $query_time = $ea->metrics(where => $item, attrib => 'Query_time');
-      push @result,
-         sprintf("# Scores: Apdex = %s [%3.1f]%s, V/M = %.2f",
-            (defined $query_time->{apdex} ? "$query_time->{apdex}" : "NS"),
-            ($query_time->{apdex_t} || 0),
-            ($query_time->{cnt} < 100 ? "*" : ""),
-            ($query_time->{stddev}**2 / ($query_time->{avg} || 1)),
-         );
-   }
-
-   if ( $o->get('explain') && $results->{samples}->{$item}->{arg} ) {
-      eval {
-         my $sparkline = $self->explain_sparkline(
-            $results->{samples}->{$item}->{arg}, $args{db});
-         push @result, "# EXPLAIN sparkline: $sparkline\n";
-      };
-      if ( $EVAL_ERROR ) {
-         PTDEBUG && _d("Failed to get EXPLAIN sparkline:", $EVAL_ERROR);
-      }
-   }
-
-   if ( my $attrib = $o->get('report-histogram') ) {
-      my $sparkline = $self->distro_sparkline(
-         %args,
-         attrib => $attrib,
-         item   => $item,
-      );
-      if ( $sparkline ) {
-         push @result, "# $attrib sparkline: |$sparkline|";
-      }
-   }
-
-   if ( my $ts = $store->{ts} ) {
-      my $time_range = $self->format_time_range($ts) || "unknown";
-      push @result, "# Time range: $time_range";
-   }
-
-   push @result, $self->make_event_header();
-
-   push @result,
-      sprintf $self->{num_format}, 'Count',
-         percentage_of($class_cnt, $global_cnt), $class_cnt, map { '' } (1..8);
+      $query_time->{stddev}**2 / ($query_time->{avg} || 1)
+   };
+
+   $vals{counts} = {
+      class_cnt        => $class_cnt,
+      global_cnt       => $global_cnt,
+   };
+
+   if ( my $ts = $store->{ts}) {
+      $vals{time_range} = $self->format_time_range($ts) || "unknown";
+   }
 
    my $attribs = $args{attribs};
    if ( !$attribs ) {
@@ -6804,10 +7290,9 @@
       );
    }
 
+   $vals{attributes} = { map { $_ => [] } qw(num innodb bool string) };
+
    foreach my $type ( qw(num innodb) ) {
-      if ( $type eq 'innodb' && @{$attribs->{$type}} ) {
-         push @result, "# InnoDB:";
-      };
 
       NUM_ATTRIB:
       foreach my $attrib ( @{$attribs->{$type}} ) {
@@ -6827,15 +7312,12 @@
          $pct   = percentage_of(
             $vals->{sum}, $results->{globals}->{$attrib}->{sum});
 
-         push @result,
-            sprintf $self->{num_format},
-               $self->make_label($attrib), $pct, @values;
+         push @{$vals{attributes}{$type}},
+               [ $attrib, $pct, @values ];
       }
    }
 
    if ( @{$attribs->{bool}} ) {
-      push @result, "# Boolean:";
-      my $printed_bools = 0;
       BOOL_ATTRIB:
       foreach my $attrib ( @{$attribs->{bool}} ) {
          next BOOL_ATTRIB unless exists $store->{$attrib};
@@ -6843,33 +7325,115 @@
          next unless scalar %$vals;
 
          if ( $vals->{sum} > 0 ) {
-            push @result,
-               sprintf $self->{bool_format},
-                  $self->make_label($attrib), $self->bool_percents($vals);
-            $printed_bools = 1;
+            push @{$vals{attributes}{bool}},
+                  [ $attrib, $self->bool_percents($vals) ];
          }
       }
-      pop @result unless $printed_bools;
+   }
+
+   if ( @{$attribs->{string}} ) {
+      STRING_ATTRIB:
+      foreach my $attrib ( @{$attribs->{string}} ) {
+         next STRING_ATTRIB unless exists $store->{$attrib};
+         my $vals = $store->{$attrib};
+         next unless scalar %$vals;
+
+         push @{$vals{attributes}{string}},
+               [ $attrib, $vals ];
+      }
+   }
+
+
+   return \%vals;
+}
+
+
+sub event_report {
+   my ( $self, %args ) = @_;
+   foreach my $arg ( qw(ea item orderby) ) {
+      die "I need a $arg argument" unless defined $args{$arg};
+   }
+
+   my $item = $args{item};
+   my $val  = $self->event_report_values(%args);
+   my @result;
+
+   return "# No such event $item\n" unless $val;
+
+   my $line = sprintf(
+      '# %s %d: %s QPS, %sx concurrency, ID 0x%s at byte %.f ',
+      ($val->{groupby} eq 'fingerprint' ? 'Query' : 'Item'),
+      $args{rank} || 0,
+      shorten($val->{qps}, d=>1_000),
+      shorten($val->{concurrency}, d=>1_000),
+      $val->{checksum},
+      $val->{pos_in_log},
+   );
+   $line .= ('_' x (LINE_LENGTH - length($line) + $self->label_width() - 12));
+   push @result, $line;
+
+   if ( $val->{reason} ) {
+      push @result,
+         "# This item is included in the report because it matches "
+            . ($val->{reason} eq 'top' ? '--limit.' : '--outliers.');
+   }
+
+   push @result,
+      sprintf("# Scores: V/M = %.2f", $val->{variance_to_mean} );
+
+   if ( $val->{time_range} ) {
+      push @result, "# Time range: $val->{time_range}";
+   }
+
+   push @result, $self->make_event_header();
+
+   push @result,
+      sprintf $self->{num_format}, 'Count',
+         percentage_of($val->{counts}{class_cnt}, $val->{counts}{global_cnt}),
+         $val->{counts}{class_cnt},
+         map { '' } (1..8);
+
+
+   my $attribs = $val->{attributes};
+
+   foreach my $type ( qw(num innodb) ) {
+      if ( $type eq 'innodb' && @{$attribs->{$type}} ) {
+         push @result, "# InnoDB:";
+      };
+
+      NUM_ATTRIB:
+      foreach my $attrib ( @{$attribs->{$type}} ) {
+         my ($attrib_name, @vals) = @$attrib;
+         push @result,
+            sprintf $self->{num_format},
+               $self->make_label($attrib_name), @vals;
+      }
+   }
+
+   if ( @{$attribs->{bool}} ) {
+      push @result, "# Boolean:";
+      BOOL_ATTRIB:
+      foreach my $attrib ( @{$attribs->{bool}} ) {
+         my ($attrib_name, @vals) = @$attrib;
+         push @result,
+            sprintf $self->{bool_format},
+               $self->make_label($attrib_name), @vals;
+      }
    }
 
    if ( @{$attribs->{string}} ) {
       push @result, "# String:";
-      my $printed_strings = 0;
       STRING_ATTRIB:
       foreach my $attrib ( @{$attribs->{string}} ) {
-         next STRING_ATTRIB unless exists $store->{$attrib};
-         my $vals = $store->{$attrib};
-         next unless scalar %$vals;
-
+         my ($attrib_name, $vals) = @$attrib;
          push @result,
             sprintf $self->{string_format},
-               $self->make_label($attrib),
-               $self->format_string_list($attrib, $vals, $class_cnt);
-         $printed_strings = 1;
+               $self->make_label($attrib_name),
+               $self->format_string_list($attrib_name, $vals, $val->{counts}{class_cnt});
       }
-      pop @result unless $printed_strings;
    }
 
+
    return join("\n", map { s/\s+$//; $_ } @result) . "\n";
 }
 
@@ -6921,73 +7485,6 @@
    return join("\n", @results) . "\n";
 }
 
-
-sub distro_sparkline {
-   my ( $self, %args ) = @_;
-   foreach my $arg ( qw(ea item attrib) ) {
-      die "I need a $arg argument" unless defined $args{$arg};
-   }
-   my $ea     = $args{ea};
-   my $item   = $args{item};
-   my $attrib = $args{attrib};
-
-   my $results = $ea->results();
-   my $store   = $results->{classes}->{$item}->{$attrib};
-   my $vals    = $store->{all};
-
-   my $all_zeros_sparkline = " " x 8;
-
-   return $all_zeros_sparkline unless defined $vals && scalar %$vals;
-
-   my @buck_tens      = $ea->buckets_of(10);
-   my @distro         = map { 0 } (0 .. 7);
-   my @buckets        = map { 0 } (0..999);
-   map { $buckets[$_] = $vals->{$_} } keys %$vals;
-   $vals = \@buckets;
-   map { $distro[$buck_tens[$_]] += $vals->[$_] } (1 .. @$vals - 1);
-
-   my $vals_per_mark;
-   my $max_val        = 0;
-   my $max_disp_width = 64;
-   foreach my $n_vals ( @distro ) {
-      $max_val = $n_vals if $n_vals > $max_val;
-   }
-   $vals_per_mark = $max_val / $max_disp_width;
-
-   my ($min, $max);
-   foreach my $i ( 0 .. $#distro ) {
-      my $n_vals  = $distro[$i];
-      my $n_marks = $n_vals / ($vals_per_mark || 1);
-      $n_marks    = 1 if $n_marks < 1 && $n_vals > 0;
-
-      $min = $n_marks if $n_marks && (!$min || $n_marks < $min);
-      $max = $n_marks if !$max || $n_marks > $max;
-   }
-   return $all_zeros_sparkline unless $min && $max;
-
-
-   $min = 0 if $min == $max;
-   my @range_min;
-   my $d = floor((($max+0.00001)-$min) / 4);
-   for my $x ( 1..4 ) {
-      push @range_min, $min + ($d * $x);
-   }
-
-   my $sparkline = ""; 
-   foreach my $i ( 0 .. $#distro ) {
-      my $n_vals  = $distro[$i];
-      my $n_marks = $n_vals / ($vals_per_mark || 1);
-      $n_marks    = 1 if $n_marks < 1 && $n_vals > 0;
-      $sparkline .= $n_marks <= 0             ? ' '
-                  : $n_marks <= $range_min[0] ? '_'
-                  : $n_marks <= $range_min[1] ? '.'
-                  : $n_marks <= $range_min[2] ? '-'
-                  :                             '^';
-   }
-
-   return $sparkline;
-}
-
 sub profile {
    my ( $self, %args ) = @_;
    foreach my $arg ( qw(ea worst groupby) ) {
@@ -6999,7 +7496,6 @@
    my $groupby = $args{groupby};
 
    my $qr  = $self->{QueryRewriter};
-   my $o   = $self->{OptionParser};
 
    my $results = $ea->results();
    my $total_r = $results->{globals}->{Query_time}->{sum} || 0;
@@ -7021,40 +7517,20 @@
                     $qr->distill($samp_query, %{$args{distill_args}}) : $item,
          id     => $groupby eq 'fingerprint' ? make_checksum($item)   : '',
          vmr    => ($query_time->{stddev}**2) / ($query_time->{avg} || 1),
-         apdex  => defined $query_time->{apdex} ? $query_time->{apdex} : "NS",
       ); 
 
-      if ( $o->get('explain') && $samp_query ) {
-         my ($default_db) = $sample->{db}       ? $sample->{db}
-                          : $stats->{db}->{unq} ? keys %{$stats->{db}->{unq}}
-                          :                       undef;
-         eval {
-            $profile{explain_sparkline} = $self->explain_sparkline(
-               $samp_query, $default_db);
-         };
-         if ( $EVAL_ERROR ) {
-            PTDEBUG && _d("Failed to get EXPLAIN sparkline:", $EVAL_ERROR);
-         }
-      }
-
       push @profiles, \%profile;
    }
 
-   my $report = $self->{formatter_for}->{profile} || new ReportFormatter(
-      line_width       => LINE_LENGTH,
-      long_last_column => 1,
-      extend_right     => 1,
-   );
-   $report->set_title('Profile');
+   my $report = $self->ReportFormatter();
+   $report->title('Profile');
    my @cols = (
       { name => 'Rank',          right_justify => 1,             },
       { name => 'Query ID',                                      },
       { name => 'Response time', right_justify => 1,             },
       { name => 'Calls',         right_justify => 1,             },
       { name => 'R/Call',        right_justify => 1,             },
-      { name => 'Apdx',          right_justify => 1, width => 4, },
       { name => 'V/M',           right_justify => 1, width => 5, },
-      ( $o->get('explain') ? { name => 'EXPLAIN' } : () ),
       { name => 'Item',                                          },
    );
    $report->set_columns(@cols);
@@ -7070,9 +7546,7 @@
          "$rt $rtp",
          $item->{cnt},
          $rc,
-         $item->{apdex},
          $vmr,
-         ( $o->get('explain') ? $item->{explain_sparkline} || "" : () ),
          $item->{sample},
       );
       $report->add_line(@vals);
@@ -7098,9 +7572,7 @@
          "$rt $rtp",
          $misc->{cnt},
          $rc,
-         'NS',   # Apdex is not meaningful here
          '0.0',  # variance-to-mean ratio is not meaningful here
-         ( $o->get('explain') ? "MISC" : () ),
          "<".scalar @$other." ITEMS>",
       );
    }
@@ -7185,12 +7657,8 @@
 
    return unless scalar @prepared;
 
-   my $report = $self->{formatter_for}->{prepared} || new ReportFormatter(
-      line_width       => LINE_LENGTH,
-      long_last_column => 1,
-      extend_right     => 1,     
-   );
-   $report->set_title('Prepared statements');
+   my $report = $self->ReportFormatter();
+   $report->title('Prepared statements');
    $report->set_columns(
       { name => 'Rank',          right_justify => 1, },
       { name => 'Query ID',                          },
@@ -7224,11 +7692,11 @@
    my @lines;
 
    push @lines,
-      sprintf $self->{num_format}, "Attribute", '', @{$self->{global_headers}};
+      sprintf $self->{num_format}, "Attribute", '', @{$self->global_headers()};
 
    push @lines,
       sprintf $self->{num_format},
-         (map { "=" x $_ } $self->{label_width}),
+         (map { "=" x $_ } $self->label_width()),
          (map { " " x $_ } qw(3)),  # no pct column in global header
          (map { "=" x $_ } qw(7 7 7 7 7 7 7));
 
@@ -7242,11 +7710,11 @@
 
    my @lines;
    push @lines,
-      sprintf $self->{num_format}, "Attribute", @{$self->{event_headers}};
+      sprintf $self->{num_format}, "Attribute", @{$self->event_headers()};
 
    push @lines,
       sprintf $self->{num_format},
-         map { "=" x $_ } ($self->{label_width}, qw(3 7 7 7 7 7 7 7));
+         map { "=" x $_ } ($self->label_width(), qw(3 7 7 7 7 7 7 7));
 
    $self->{event_header_lines} = \@lines;
    return @lines;
@@ -7261,7 +7729,7 @@
    if ( $val =~ m/^InnoDB/ ) {
       $val =~ s/^InnoDB //;
       $val = $val eq 'trx id' ? "InnoDB trxID"
-           : substr($val, 0, $self->{label_width});
+           : substr($val, 0, $self->label_width());
    }
 
    $val = $val eq 'user'            ? 'Users'
@@ -7272,7 +7740,7 @@
         : $val eq 'bytes'           ? 'Query size'
         : $val eq 'Tmp disk tables' ? 'Tmp disk tbl'
         : $val eq 'Tmp table sizes' ? 'Tmp tbl size'
-        : substr($val, 0, $self->{label_width});
+        : substr($val, 0, $self->label_width);
 
    return $val;
 }
@@ -7286,8 +7754,7 @@
 
 sub format_string_list {
    my ( $self, $attrib, $vals, $class_cnt ) = @_;
-   my $o        = $self->{OptionParser};
-   my $show_all = $o->get('show-all');
+   my $show_all = $self->{options}->{show_all};
 
    if ( !exists $vals->{unq} ) {
       return ($vals->{cnt});
@@ -7417,7 +7884,7 @@
 sub tables_report {
    my ( $self, @tables ) = @_;
    return '' unless @tables;
-   my $q      = $self->{Quoter};
+   my $q      = $self->Quoter();
    my $tables = "";
    foreach my $db_tbl ( @tables ) {
       my ( $db, $tbl ) = @$db_tbl;
@@ -7436,7 +7903,7 @@
    return '' unless $query;
 
    my $dbh = $self->{dbh};
-   my $q   = $self->{Quoter};
+   my $q   = $self->Quoter();
    my $qp  = $self->{QueryParser};
    return '' unless $dbh && $q && $qp;
 
@@ -7485,34 +7952,6 @@
    return $min && $max ? "$min to $max" : '';
 }
 
-sub explain_sparkline {
-   my ( $self, $query, $db ) = @_;
-   return unless $query;
-
-   my $q   = $self->{Quoter};
-   my $dbh = $self->{dbh};
-   my $ex  = $self->{ExplainAnalyzer};
-   return unless $dbh && $ex;
-
-   if ( $db ) {
-      PTDEBUG && _d($dbh, "USE", $db);
-      $dbh->do("USE " . $q->quote($db));
-   }
-   my $res = $ex->normalize(
-      $ex->explain_query(
-         dbh   => $dbh,
-         query => $query,
-      )
-   );
-
-   my $sparkline;
-   if ( $res ) {
-      $sparkline = $ex->sparkline(explain => $res);
-   }
-
-   return $sparkline;
-}
-
 sub _d {
    my ($package, undef, $line) = caller 0;
    @_ = map { (my $temp = $_) =~ s/\n/\n# /g; $temp; }
@@ -7528,6 +7967,139 @@
 # ###########################################################################
 
 # ###########################################################################
+# JSONReportFormatter 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/JSONReportFormatter.pm
+#   t/lib/JSONReportFormatter.t
+# See https://launchpad.net/percona-toolkit for more information.
+# ###########################################################################
+{
+package JSONReportFormatter;
+use Mo;
+
+use List::Util   qw(sum);
+use Transformers qw(make_checksum parse_timestamp);
+
+use constant PTDEBUG => $ENV{PTDEBUG} || 0;
+
+my $have_json = eval { require JSON };
+
+our $pretty_json = undef;
+our $sorted_json = undef;
+
+extends qw(QueryReportFormatter);
+
+has _json => (
+   is       => 'ro',
+   init_arg => undef,
+   builder  => '_build_json',
+);
+
+sub _build_json {
+   return unless $have_json;
+   return JSON->new->utf8
+                   ->pretty($pretty_json)
+                   ->canonical($sorted_json);
+}
+
+sub encode_json {
+   my ($self, $encode) = @_;
+   if ( my $json = $self->_json ) {
+      return $json->encode($encode);
+   }
+   else {
+      return Transformers::encode_json($encode);
+   }
+}
+
+override [qw(rusage date hostname files header profile prepared)] => sub {
+   return;
+};
+
+override event_report => sub {
+   my ($self, %args) = @_;
+   return $self->event_report_values(%args);
+};
+
+override query_report => sub {
+   my ($self, %args) = @_;
+   foreach my $arg ( qw(ea worst orderby groupby) ) {
+      die "I need a $arg argument" unless defined $arg;
+   }
+
+   my $ea    = $args{ea};
+   my $worst = $args{worst};
+
+   my @attribs = @{$ea->get_attributes()};
+   
+   my @queries;
+   foreach my $worst_info ( @$worst ) {
+      my $item   = $worst_info->[0];
+      my $stats  = $ea->results->{classes}->{$item};
+      my $sample = $ea->results->{samples}->{$item};
+
+      my $all_log_pos = $ea->{result_classes}->{$item}->{pos_in_log}->{all};
+      my $times_seen  = sum values %$all_log_pos;
+      
+      my %class = (
+         sample      => $sample->{arg},
+         fingerprint => $item,
+         checksum    => make_checksum($item),
+         cnt         => $times_seen,
+      );
+      
+      my %metrics;
+      foreach my $attrib ( @attribs ) {
+         $metrics{$attrib} = $ea->metrics(
+            attrib => $attrib,
+            where  => $item,
+         );
+      }
+
+      foreach my $attrib ( keys %metrics ) {
+         if ( ! grep { $_ } values %{$metrics{$attrib}} ) {
+            delete $metrics{$attrib};
+            next;
+         }
+
+         if ($attrib eq 'ts') {
+            my $ts = delete $metrics{ts};
+            foreach my $thing ( qw(min max) ) {
+               next unless defined $ts && defined $ts->{$thing};
+               $ts->{$thing} = parse_timestamp($ts->{$thing});
+            }
+            $class{ts_min} = $ts->{min};
+            $class{ts_max} = $ts->{max};
+         }
+         elsif ( ($ea->{type_for}->{$attrib} || '') eq 'num' ) {
+            for my $value ( values %{$metrics{$attrib}} ) {
+               next unless $value;
+               $value = sprintf '%.6f', $value;
+            }
+            if ( my $pct = $metrics{$attrib}->{pct} ) {
+               $metrics{$attrib}->{pct} = sprintf('%.2f', $pct);
+            }
+         }
+      }
+      push @queries, {
+         class       => \%class,
+         attributes  => \%metrics,
+      };
+   }
+
+   my $json = $self->encode_json(\@queries);
+   $json .= "\n" if $json !~ /\n\Z/;
+   return $json . "\n";
+};
+
+1;
+}
+# ###########################################################################
+# End JSONReportFormatter package
+# ###########################################################################
+
+# ###########################################################################
 # EventTimeline 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,
@@ -8588,7 +9160,7 @@
 
 sub set_history_options {
    my ( $self, %args ) = @_;
-   foreach my $arg ( qw(table dbh tbl_struct col_pat) ) {
+   foreach my $arg ( qw(table tbl_struct col_pat) ) {
       die "I need a $arg argument" unless $args{$arg};
    }
 
@@ -8622,7 +9194,7 @@
         } @cols) . ')';
    PTDEBUG && _d($sql);
 
-   $self->{history_sth}     = $args{dbh}->prepare($sql);
+   $self->{history_sth}     = $self->{dbh}->prepare($sql);
    $self->{history_metrics} = \@metrics;
 
    return;
@@ -10350,143 +10922,6 @@
 # ###########################################################################
 
 # ###########################################################################
-# ExecutionThrottler 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/ExecutionThrottler.pm
-#   t/lib/ExecutionThrottler.t
-# See https://launchpad.net/percona-toolkit for more information.
-# ###########################################################################
-{
-package ExecutionThrottler;
-
-use strict;
-use warnings FATAL => 'all';
-use English qw(-no_match_vars);
-use constant PTDEBUG => $ENV{PTDEBUG} || 0;
-
-use List::Util qw(sum min max);
-use Time::HiRes qw(time);
-use Data::Dumper;
-$Data::Dumper::Indent    = 1;
-$Data::Dumper::Sortkeys  = 1;
-$Data::Dumper::Quotekeys = 0;
-
-sub new {
-   my ( $class, %args ) = @_;
-   my @required_args = qw(rate_max get_rate check_int step);
-   foreach my $arg ( @required_args ) {
-      die "I need a $arg argument" unless defined $args{$arg};
-   }
-   my $self = {
-      step       => 0.05,  # default
-      %args, 
-      rate_ok    => undef,
-      last_check => undef,
-      stats      => {
-         rate_avg     => 0,
-         rate_samples => [],
-      },
-      int_rates  => [],
-      skip_prob  => 0.0,
-   };
-
-   return bless $self, $class;
-}
-
-sub throttle {
-   my ( $self, %args ) = @_;
-   my $time = $args{misc}->{time} || time;
-   if ( $self->_time_to_check($time) ) {
-      my $rate_avg = (sum(@{$self->{int_rates}})   || 0)
-                   / (scalar @{$self->{int_rates}} || 1);
-      my $running_avg = $self->_save_rate_avg($rate_avg);
-      PTDEBUG && _d('Average rate for last interval:', $rate_avg);
-
-      if ( $args{stats} ) {
-         $args{stats}->{throttle_checked_rate}++;
-         $args{stats}->{throttle_rate_avg} = sprintf '%.2f', $running_avg;
-      }
-
-      @{$self->{int_rates}} = ();
-
-      if ( $rate_avg > $self->{rate_max} ) {
-         $self->{skip_prob} += $self->{step};
-         $self->{skip_prob}  = 1.0 if $self->{skip_prob} > 1.0;
-         PTDEBUG && _d('Rate max exceeded');
-         $args{stats}->{throttle_rate_max_exceeded}++ if $args{stats};
-      }
-      else {
-         $self->{skip_prob} -= $self->{step};
-         $self->{skip_prob} = 0.0 if $self->{skip_prob} < 0.0;
-         $args{stats}->{throttle_rate_ok}++ if $args{stats};
-      }
-
-      PTDEBUG && _d('Skip probability:', $self->{skip_prob});
-      $self->{last_check} = $time;
-   }
-   else {
-      my $current_rate = $self->{get_rate}->();
-      push @{$self->{int_rates}}, $current_rate;
-      if ( $args{stats} ) {
-         $args{stats}->{throttle_rate_min} = min(
-            ($args{stats}->{throttle_rate_min} || ()), $current_rate);
-         $args{stats}->{throttle_rate_max} = max(
-            ($args{stats}->{throttle_rate_max} || ()), $current_rate);
-      }
-      PTDEBUG && _d('Current rate:', $current_rate);
-   } 
-
-   if ( $args{event} ) {
-      $args{event}->{Skip_exec} = $self->{skip_prob} <= rand() ? 'No' : 'Yes';
-   }
-
-   return $args{event};
-}
-
-sub _time_to_check {
-   my ( $self, $time ) = @_;
-   if ( !$self->{last_check} ) {
-      $self->{last_check} = $time;
-      return 0;
-   }
-   return $time - $self->{last_check} >= $self->{check_int} ? 1 : 0;
-}
-
-sub rate_avg {
-   my ( $self ) = @_;
-   return $self->{stats}->{rate_avg} || 0;
-}
-
-sub skip_probability {
-   my ( $self ) = @_;
-   return $self->{skip_prob};
-}
-
-sub _save_rate_avg {
-   my ( $self, $rate ) = @_;
-   my $samples  = $self->{stats}->{rate_samples};
-   push @$samples, $rate;
-   shift @$samples if @$samples > 1_000;
-   $self->{stats}->{rate_avg} = sum(@$samples) / (scalar @$samples);
-   return $self->{stats}->{rate_avg} || 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 ExecutionThrottler 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,
@@ -11448,226 +11883,6 @@
 # ###########################################################################
 
 # ###########################################################################
-# ExplainAnalyzer 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/ExplainAnalyzer.pm
-#   t/lib/ExplainAnalyzer.t
-# See https://launchpad.net/percona-toolkit for more information.
-# ###########################################################################
-{
-package ExplainAnalyzer;
-
-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;
-
-sub new {
-   my ( $class, %args ) = @_;
-   foreach my $arg ( qw(QueryRewriter QueryParser) ) {
-      die "I need a $arg argument" unless defined $args{$arg};
-   }
-   my $self = {
-      %args,
-   };
-   return bless $self, $class;
-}
-
-sub explain_query {
-   my ( $self, %args ) = @_;
-   foreach my $arg ( qw(dbh query) ) {
-      die "I need a $arg argument" unless defined $args{$arg};
-   }
-   my ($query, $dbh) = @args{qw(query dbh)};
-   $query = $self->{QueryRewriter}->convert_to_select($query);
-   if ( $query !~ m/^\s*select/i ) {
-      PTDEBUG && _d("Cannot EXPLAIN non-SELECT query:",
-         (length $query <= 100 ? $query : substr($query, 0, 100) . "..."));
-      return;
-   }
-   my $sql = "EXPLAIN $query";
-   PTDEBUG && _d($dbh, $sql);
-   my $explain = $dbh->selectall_arrayref($sql, { Slice => {} });
-   PTDEBUG && _d("Result of EXPLAIN:", Dumper($explain));
-   return $explain;
-}
-
-sub normalize {
-   my ( $self, $explain ) = @_;
-   my @result; # Don't modify the input.
-
-   foreach my $row ( @$explain ) {
-      $row = { %$row }; # Make a copy -- don't modify the input.
-
-      foreach my $col ( qw(key possible_keys key_len ref) ) {
-         $row->{$col} = [ split(/,/, $row->{$col} || '') ];
-      }
-
-      $row->{Extra} = {
-         map {
-            my $var = $_;
-
-            if ( my ($key, $vals) = $var =~ m/(Using union)\(([^)]+)\)/ ) {
-               $key => [ split(/,/, $vals) ];
-            }
-
-            else {
-               $var => 1;
-            }
-         }
-         split(/; /, $row->{Extra} || '') # Split on semicolons.
-      };
-
-      push @result, $row;
-   }
-
-   return \@result;
-}
-
-sub get_alternate_indexes {
-   my ( $self, $keys, $possible_keys ) = @_;
-   my %used = map { $_ => 1 } @$keys;
-   return [ grep { !$used{$_} } @$possible_keys ];
-}
-
-sub get_index_usage {
-   my ( $self, %args ) = @_;
-   foreach my $arg ( qw(query explain) ) {
-      die "I need a $arg argument" unless defined $args{$arg};
-   }
-   my ($query, $explain) = @args{qw(query explain)};
-   my @result;
-
-   my $lookup = $self->{QueryParser}->get_aliases($query);
-
-   foreach my $row ( @$explain ) {
-
-      next if !defined $row->{table}
-         || $row->{table} =~ m/^<(derived|union)\d/;
-
-      my $table = $lookup->{TABLE}->{$row->{table}} || $row->{table};
-      my $db    = $lookup->{DATABASE}->{$table}     || $args{db};
-      push @result, {
-         db  => $db,
-         tbl => $table,
-         idx => $row->{key},
-         alt => $self->get_alternate_indexes(
-                  $row->{key}, $row->{possible_keys}),
-      };
-   }
-
-   PTDEBUG && _d("Index usage for",
-      (length $query <= 100 ? $query : substr($query, 0, 100) . "..."),
-      ":", Dumper(\@result));
-   return \@result;
-}
-
-sub get_usage_for {
-   my ( $self, $checksum, $db ) = @_;
-   die "I need a checksum and db" unless defined $checksum && defined $db;
-   my $usage;
-   if ( exists $self->{usage}->{$db} # Don't auto-vivify
-     && exists $self->{usage}->{$db}->{$checksum} )
-   {
-      $usage = $self->{usage}->{$db}->{$checksum};
-   }
-   PTDEBUG && _d("Usage for",
-      (length $checksum <= 100 ? $checksum : substr($checksum, 0, 100) . "..."),
-      "on", $db, ":", Dumper($usage));
-   return $usage;
-}
-
-sub save_usage_for {
-   my ( $self, $checksum, $db, $usage ) = @_;
-   die "I need a checksum and db" unless defined $checksum && defined $db;
-   $self->{usage}->{$db}->{$checksum} = $usage;
-}
-
-sub fingerprint {
-   my ( $self, %args ) = @_;
-   my @required_args = qw(explain);
-   foreach my $arg ( @required_args ) {
-      die "I need a $arg argument" unless defined $args{$arg};
-   }
-   my ($explain) = @args{@required_args};
-}
-
-sub sparkline {
-   my ( $self, %args ) = @_;
-   my @required_args = qw(explain);
-   foreach my $arg ( @required_args ) {
-      die "I need a $arg argument" unless defined $args{$arg};
-   }
-   my ($explain) = @args{@required_args};
-   PTDEBUG && _d("Making sparkline for", Dumper($explain));
-
-   my $access_code = {
-      'ALL'             => 'a',
-      'const'           => 'c',
-      'eq_ref'          => 'e',
-      'fulltext'        => 'f',
-      'index'           => 'i',
-      'index_merge'     => 'm',
-      'range'           => 'n',
-      'ref_or_null'     => 'o',
-      'ref'             => 'r',
-      'system'          => 's',
-      'unique_subquery' => 'u',
-   };
-
-   my $sparkline = '';
-   my ($T, $F);  # Using temporary, Using filesort
-
-   foreach my $tbl ( @$explain ) {
-      my $code;
-      if ( defined $tbl->{type} ) {
-         $code = $access_code->{$tbl->{type}} || "?";
-         $code = uc $code if $tbl->{Extra}->{'Using index'};
-      }
-      else {
-         $code = '-'
-      };
-      $sparkline .= $code;
-
-      $T = 1 if $tbl->{Extra}->{'Using temporary'};
-      $F = 1 if $tbl->{Extra}->{'Using filesort'};
-   }
-
-   if ( $T || $F ) {
-      if (    $explain->[-1]->{Extra}->{'Using temporary'}
-           || $explain->[-1]->{Extra}->{'Using filesort'} ) {
-         $sparkline .= ">" . ($T ? "T" : "") . ($F ? "F" : "");
-      }
-      else {
-         $sparkline = ($T ? "T" : "") . ($F ? "F" : "") . ">$sparkline";
-      }
-   }
-
-   PTDEBUG && _d("sparkline:", $sparkline);
-   return $sparkline;
-}
-
-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 ExplainAnalyzer package
-# ###########################################################################
-
-# ###########################################################################
 # Runtime 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,
@@ -11825,7 +12040,7 @@
    }
 
    my $self = {
-      instrument        => 0,
+      instrument        => PTDEBUG,
       continue_on_error => 0,
 
       %args,
@@ -11852,9 +12067,7 @@
 
    push @{$self->{procs}}, $process;
    push @{$self->{names}}, $name;
-   if ( my $n = $args{retry_on_error} ) {
-      $self->{retries}->{$name} = $n;
-   }
+   $self->{retries}->{$name} = $args{retry_on_error} || 100;
    if ( $self->{instrument} ) {
       $self->{instrumentation}->{$name} = { time => 0, calls => 0 };
    }
@@ -11923,7 +12136,11 @@
          my $msg  = "Pipeline process " . ($procno + 1)
                   . " ($name) caused an error: "
                   . $EVAL_ERROR;
-         if ( defined $self->{retries}->{$name} ) {
+         if ( !$self->{continue_on_error} ) {
+            die $msg . "Terminating pipeline because --continue-on-error "
+               . "is false.\n";
+         }
+         elsif ( defined $self->{retries}->{$name} ) {
             my $n = $self->{retries}->{$name};
             if ( $n ) {
                warn $msg . "Will retry pipeline process $procno ($name) "
@@ -11935,9 +12152,6 @@
                   . "($name) caused too many errors.\n";
             }
          }
-         elsif ( !$self->{continue_on_error} ) {
-            die $msg;
-         }
          else {
             warn $msg;
          }
@@ -13296,33 +13510,57 @@
 # ###########################################################################
 package pt_query_digest;
 
+use strict;
+use warnings FATAL => 'all';
 use English qw(-no_match_vars);
-use Time::Local qw(timelocal);
-use Time::HiRes qw(time usleep);
-use List::Util qw(max);
-use POSIX qw(signal_h);
+use constant PTDEBUG => $ENV{PTDEBUG} || 0;
+
+use Time::Local  qw(timelocal);
+use Time::HiRes  qw(time usleep);
+use List::Util   qw(max);
+use Scalar::Util qw(looks_like_number);
+use POSIX        qw(signal_h);
 use Data::Dumper;
-$Data::Dumper::Indent = 1;
-$OUTPUT_AUTOFLUSH     = 1;
-
-Transformers->import(qw(shorten micro_t percentage_of ts make_checksum
-   any_unix_timestamp parse_timestamp unix_timestamp crc32));
 
 use Percona::Toolkit;
-use constant PTDEBUG => $ENV{PTDEBUG} || 0;
+
+$Data::Dumper::Indent    = 1;
+$Data::Dumper::Sortkeys  = 1;
+$Data::Dumper::Quotekeys = 0;
+
+$OUTPUT_AUTOFLUSH = 1;
+
+Transformers->import(qw(
+   shorten
+   micro_t
+   percentage_of
+   ts
+   make_checksum
+   any_unix_timestamp
+   parse_timestamp
+   unix_timestamp
+   crc32
+));
 
 use sigtrap 'handler', \&sig_int, 'normal-signals';
 
 # Global variables.  Only really essential variables should be here.
 my $oktorun = 1;
-my $ex_dbh;  # For --execute
 my $ep_dbh;  # For --explain
 my $ps_dbh;  # For Processlist
 my $aux_dbh; # For --aux-dsn (--since/--until "MySQL expression")
 
+my $resume_file;
+my $offset;
+
+(my $tool = __PACKAGE__) =~ tr/_/-/;
+
 sub main {
-   local @ARGV = @_;  # set global ARGV for this package
-   $oktorun    = 1;   # reset between tests else pipeline won't run
+   # Reset global vars, else tests will fail.
+   local @ARGV  = @_;
+   $oktorun     = 1;
+   $resume_file = undef;
+   $offset      = undef;
 
    # ##########################################################################
    # Get configuration information.
@@ -13347,31 +13585,11 @@
    }
 
    if ( !$o->get('help') ) {
-      if ( $review_dsn
-           && (!defined $review_dsn->{D} || !defined $review_dsn->{t}) ) {
-         $o->save_error('The --review DSN requires a D (database) and t'
-            . ' (table) part specifying the query review table');
-      }
-      if ( $o->get('mirror')
-           && (!$o->get('execute') || !$o->get('processlist')) ) {
-         $o->save_error('--mirror requires --execute and --processlist');
-      }
       if ( $o->get('outliers')
          && grep { $_ !~ m/^\w+:[0-9.]+(?::[0-9.]+)?$/ } @{$o->get('outliers')}
       ) {
          $o->save_error('--outliers requires two or three colon-separated fields');
       }
-      if ( $o->get('execute-throttle') ) {
-         my ($rate_max, $int, $step) = @{$o->get('execute-throttle')};
-         $o->save_error("--execute-throttle max time must be between 1 and 100")
-            unless $rate_max && $rate_max > 0 && $rate_max <= 100;
-         $o->save_error("No check interval value for --execute-throttle")
-            unless $int;
-         $o->save_error("--execute-throttle check interval must be an integer")
-            if $int =~ m/[^\d]/;
-         $o->save_error("--execute-throttle step must be between 1 and 100")
-            if $step && ($step < 1 || $step > 100);
-      }
       if ( $o->get('progress') ) {
          eval { Progress->validate_spec($o->get('progress')) };
          if ( $EVAL_ERROR ) {
@@ -13380,9 +13598,20 @@
          }
       }
 
-      if ( $o->get('apdex-threshold') <= 0 ) {
-         $o->save_error("Apdex threshold must be a positive decimal value");
-      }
+      if ( my $review_dsn = $o->get('review') ) {
+         $o->save_error('--review does not accept a t option. Perhaps you meant '
+                      . 'to use --review-table or --history-table?')
+            if defined $review_dsn->{t};
+      }
+
+      for my $tables ('review-table', 'history-table') {
+         my $got = $o->get($tables);
+         if ( grep !defined, Quoter->split_unquote($got) ) {
+            $o->save_error("--$tables should be passed a "
+                         . "fully-qualified table name, got $got");
+         }
+      }
+
       if ( my $patterns = $o->get('embedded-attributes') ) {
          $o->save_error("--embedded-attributes should be passed two "
            . "comma-separated patterns, got " . scalar(@$patterns) )
@@ -13440,7 +13669,6 @@
    # ########################################################################
    # Set up for --explain
    # ########################################################################
-   my $exa;
    if ( my $ep_dsn = $o->get('explain') ) {
       $ep_dbh = get_cxn(
          for          => '--explain',
@@ -13450,19 +13678,13 @@
          opts         => { AutoCommit => 1 },
       );
       $ep_dbh->{InactiveDestroy}  = 1;  # Don't die on fork().
-
-      $exa = new ExplainAnalyzer(
-         QueryRewriter => $qr,
-         QueryParser   => $qp,
-      );
    }
 
    # ########################################################################
-   # Set up for --review and --review-history.
+   # Set up for --review.
    # ########################################################################
    my $qv;      # QueryReview
    my $qv_dbh;  # For QueryReview
-   my $qv_dbh2; # For QueryReview and --review-history
    if ( $review_dsn ) {
       my $tp  = new TableParser(Quoter => $q);
       $qv_dbh = get_cxn(
@@ -13473,28 +13695,33 @@
          opts         => { AutoCommit => 1 },
       );
       $qv_dbh->{InactiveDestroy}  = 1;  # Don't die on fork().
-      my @db_tbl = @{$review_dsn}{qw(D t)};
-      my $db_tbl = $q->quote(@db_tbl);
-
-      # Create the review table if desired
-      if ( $o->get('create-review-table') ) {
-         my $sql = $o->read_para_after(
-            __FILE__, qr/MAGIC_create_review/);
-         $sql =~ s/query_review/IF NOT EXISTS $db_tbl/;
-         PTDEBUG && _d($sql);
-         $qv_dbh->do($sql);
-      }
-
-      # Check for the existence of the table.
-      if ( !$tp->check_table(
-            dbh => $qv_dbh,
-            db  => $db_tbl[0],
-            tbl => $db_tbl[1]) )
-      {
-         die "The query review table $db_tbl does not exist.  "
-            . "Specify --create-review-table to create it, "
-            . "and ensure that the MySQL user has privileges to create "
-            . "and update the table.\n";
+
+      my @db_tbl  = Quoter->split_unquote($o->get('review-table'));
+      my @hdb_tbl = Quoter->split_unquote($o->get('history-table'));
+
+      my $db_tbl  = $q->quote(@db_tbl);
+      my $hdb_tbl = $q->quote(@hdb_tbl);
+
+      my $create_review_sql = $o->read_para_after(
+         __FILE__, qr/MAGIC_create_review/);
+      $create_review_sql =~ s/query_review/IF NOT EXISTS $db_tbl/;
+
+      my $create_history_sql = $o->read_para_after(
+         __FILE__, qr/MAGIC_create_review_history/);
+      $create_history_sql =~ s/query_review_history/IF NOT EXISTS $hdb_tbl/;
+
+      for my $create (
+         [ $db_tbl,  $create_review_sql  ],
+         [ $hdb_tbl, $create_history_sql ],
+      ) {
+         my ($tbl_name, $sql) = @$create;
+         create_review_tables(
+            dbh              => $qv_dbh,
+            full_table       => $tbl_name,
+            create_table_sql => $sql,
+            create_table     => $o->get('create-review-tables'),
+            TableParser      => $tp,
+         );
       }
 
       # Set up the new QueryReview object.
@@ -13506,79 +13733,43 @@
          quoter      => $q,
       );
 
-      # Set up the review-history table
-      if ( my $review_history_dsn = $o->get('review-history') ) {
-         $qv_dbh2 = get_cxn(
-            for          => '--review-history',
-            dsn          => $review_history_dsn,
-            OptionParser => $o,
-            DSNParser    => $dp,
-            opts         => { AutoCommit => 1 },
-         );
-         $qv_dbh2->{InactiveDestroy}  = 1;  # Don't die on fork().
-         my @hdb_tbl = @{$o->get('review-history')}{qw(D t)};
-         my $hdb_tbl = $q->quote(@hdb_tbl);
-
-         # Create the review-history table if desired
-         if ( $o->get('create-review-history-table') ) {
-            my $sql = $o->read_para_after(
-               __FILE__, qr/MAGIC_create_review_history/);
-            $sql =~ s/query_review_history/IF NOT EXISTS $hdb_tbl/;
-            PTDEBUG && _d($sql);
-            $qv_dbh2->do($sql);
-         }
-
-         # Check for the existence of the table.
-         if ( !$tp->check_table(
-               dbh       => $qv_dbh2,
-               db        => $hdb_tbl[0],
-               tbl       => $hdb_tbl[1]) )
-         {
-            die "The query review history table $hdb_tbl does not exist.  "
-               . "Specify --create-review-history-table to create it, "
-               . "and ensure that the MySQL user has privileges to create "
-               . "and update the table.\n";
-         }
-
-         # Inspect for MAGIC_history_cols.  Add them to the --select list
-         # only if an explicit --select list was given.  Otherwise, leave
-         # --select undef which will cause EventAggregator to aggregate every
-         # attribute available which will include the history columns.
-         # If no --select list was given and we make one by adding the history
-         # columsn to it, then EventAggregator will only aggregate the
-         # history columns and nothing else--we don't want this.
-         my $tbl = $tp->parse($tp->get_create_table($qv_dbh2, @hdb_tbl));
-         my $pat = $o->read_para_after(__FILE__, qr/MAGIC_history_cols/);
-         $pat    =~ s/\s+//g;
-         $pat    = qr/^(.*?)_($pat)$/;
-         # Get original --select values.
-         my %select = map { $_ => 1 } @{$o->get('select')};
-         foreach my $col ( @{$tbl->{cols}} ) {
-            my ( $attr, $metric ) = $col =~ m/$pat/;
-            next unless $attr && $metric;
-            $attr = ucfirst $attr if $attr =~ m/_/; # TableParser lowercases
-            # Add history table values to original select values.
-            $select{$attr}++;
-         }
-
-         if ( $o->got('select') ) {
-            # Re-set --select with its original values plus the history
-            # table values.
-            $o->set('select', [keys %select]);
-            PTDEBUG && _d("--select after parsing --review-history table:", 
-               @{$o->get('select')});
-         }
-
-         # And tell the QueryReview that it has more work to do.
-         $qv->set_history_options(
-            table      => $hdb_tbl,
-            dbh        => $qv_dbh2,
-            tbl_struct => $tbl,
-            col_pat    => $pat,
-         );
-      }
+      # Inspect for MAGIC_history_cols.  Add them to the --select list
+      # only if an explicit --select list was given.  Otherwise, leave
+      # --select undef which will cause EventAggregator to aggregate every
+      # attribute available which will include the history columns.
+      # If no --select list was given and we make one by adding the history
+      # columsn to it, then EventAggregator will only aggregate the
+      # history columns and nothing else--we don't want this.
+      my $tbl = $tp->parse($tp->get_create_table($qv_dbh, @hdb_tbl));
+      my $pat = $o->read_para_after(__FILE__, qr/MAGIC_history_cols/);
+      $pat    =~ s/\s+//g;
+      $pat    = qr/^(.*?)_($pat)$/;
+      # Get original --select values.
+      my %select = map { $_ => 1 } @{$o->get('select')};
+      foreach my $col ( @{$tbl->{cols}} ) {
+         my ( $attr, $metric ) = $col =~ $pat;
+         next unless $attr && $metric;
+         $attr = ucfirst $attr if $attr =~ m/_/; # TableParser lowercases
+         # Add history table values to original select values.
+         $select{$attr}++;
+      }
+
+      if ( $o->got('select') ) {
+         # Re-set --select with its original values plus the history
+         # table values.
+         $o->set('select', [sort keys %select]);
+         PTDEBUG && _d("--select after parsing the history table:", 
+            @{$o->get('select')});
+      }
+
+      # And tell the QueryReview that it has more work to do.
+      $qv->set_history_options(
+         table      => $hdb_tbl,
+         tbl_struct => $tbl,
+         col_pat    => $pat,
+      );
    }
-   
+
    # ########################################################################
    # Create all the pipeline processes that do all the work: get input,
    # parse events, manage runtime, switch iterations, aggregate, etc.
@@ -13599,13 +13790,7 @@
       stats => \%stats,
    };
 
-   # Enable timings to instrument code for either of these two opts.
-   # Else, don't instrument to avoid cost of measurement.
-   my $instrument = $o->get('pipeline-profile') || $o->get('execute-throttle');
-   PTDEBUG && _d('Instrument:', $instrument);
-
    my $pipeline = new Pipeline(
-      instrument        => $instrument,
       continue_on_error => $o->get('continue-on-error'),
    );
 
@@ -13633,7 +13818,7 @@
    } # prep
 
    { # input
-      my $fi        = new FileIterator();
+      my $fi        = FileIterator->new();
       my $next_file = $fi->get_file_itr(@ARGV);
       my $input_fh; # the current input fh
       my $pr;       # Progress obj for ^
@@ -13642,20 +13827,51 @@
          name    => 'input',
          process => sub {
             my ( $args ) = @_;
+
             # Only get the next file when there's no fh or no more events in
             # the current fh.  This allows us to do collect-and-report cycles
             # (i.e. iterations) on huge files.  This doesn't apply to infinite
             # inputs because they don't set more_events false.
             if ( !$args->{input_fh} || !$args->{more_events} ) {
+
+               # Close the current file.
                if ( $args->{input_fh} ) {
                   close $args->{input_fh}
                      or die "Cannot close input fh: $OS_ERROR";
                }
+
+               # Open the next file.
                my ($fh, $filename, $filesize) = $next_file->();
                if ( $fh ) {
                   PTDEBUG && _d('Reading', $filename);
+                  PTDEBUG && _d('File size:', $filesize);
                   push @read_files, $filename || "STDIN";
 
+                  # Read the file offset for --resume.
+                  if ( ($resume_file = $o->get('resume')) && $filename ) {
+                     if ( -s $resume_file ) {
+                        open my $resume_fh, '<', $resume_file
+                           or die "Error opening $resume_file: $OS_ERROR";
+                        chomp(my $resume_offset = <$resume_fh>);
+                        close $resume_fh
+                           or die "Error close $resume_file: $OS_ERROR";
+                        if ( !looks_like_number($resume_offset) ) {
+                           die "Offset $resume_offset in $resume_file "
+                             . "does not look like a number.\n";
+                        }
+                        PTDEBUG && _d('Resuming at offset', $resume_offset);
+                        seek $fh, $resume_offset, 0
+                           or die "Error seeking to $resume_offset in "
+                                . "$resume_file: $OS_ERROR";
+                        warn "Resuming $filename from offset $resume_offset "
+                           . "(file size: $filesize)...\n";
+                     }
+                     else {
+                        PTDEBUG && _d('Not resuming', $filename, 'because',
+                           $resume_file, 'does not exist');
+                     }
+                  }
+
                   # Create callback to read next event.  Some inputs, like
                   # Processlist, may use something else but most next_event.
                   if ( my $read_time = $o->get('read-timeout') ) {
@@ -13665,8 +13881,15 @@
                   else {
                      $args->{next_event} = sub { return <$fh>; };
                   }
+                  $args->{filename}    = $filename;
                   $args->{input_fh}    = $fh;
-                  $args->{tell}        = sub { return tell $fh; };
+                  $args->{tell}        = sub {
+                     $offset = tell $fh;  # update global $offset
+                     if ( $args->{filename} ) {
+                        $args->{pos_for}->{$args->{filename}} = $offset;
+                     }
+                     return $offset;  # legacy: return global $offset
+                  };
                   $args->{more_events} = 1;
 
                   # Reset in case we read two logs out of order by time.
@@ -13725,14 +13948,12 @@
                $err = $EVAL_ERROR;
                if ( $err ) { # Try to reconnect when there's an error.
                   eval {
-                     ($cur_server, $ps_dbh) = find_role(
-                        OptionParser => $o,
-                        DSNParser    => $dp,
-                        dbh          => $ps_dbh,
-                        current      => $cur_server,
-                        read_only    => 0,
-                        comment      => 'for --processlist'
-                     );
+                     if ( !$ps_dbh || !$ps_dbh->ping ) {
+                        PTDEBUG && _d('Getting a dbh from', $cur_server);
+                        $ps_dbh = $dp->get_dbh(
+                           $dp->get_cxn_params($o->get($cur_server)), {AutoCommit => 1});
+                        $ps_dbh->{InactiveDestroy}  = 1;  # Don't die on fork().
+                     }
                      $cur_time = time();
                      $sth      = $ps_dbh->prepare('SHOW FULL PROCESSLIST');
                      $cxn      = $ps_dbh->{mysql_thread_id};
@@ -13745,18 +13966,6 @@
                   }
                }
             } until ( $sth && !$err );
-            if ( $o->get('mirror')
-                 && time() - $cur_time > $o->get('mirror')) {
-               ($cur_server, $ps_dbh) = find_role(
-                  OptionParser => $o,
-                  DSNParser    => $dp,
-                  dbh          => $ps_dbh,
-                  current      => $cur_server,
-                  read_only    => 0,
-                  comment      => 'for --processlist'
-               );
-               $cur_time = time();
-            }
 
             return [ grep { $_->[0] != $cxn } @{ $sth->fetchall_arrayref(); } ];
          };
@@ -13949,7 +14158,7 @@
          );
          $aux_dbh->{InactiveDestroy}  = 1;  # Don't die on fork().
       }
-      $aux_dbh ||= $qv_dbh || $qv_dbh2 || $ex_dbh || $ps_dbh || $ep_dbh;
+      $aux_dbh ||= $qv_dbh || $ps_dbh || $ep_dbh;
       PTDEBUG && _d('aux dbh:', $aux_dbh);
 
       my $time_callback = sub {
@@ -14081,7 +14290,6 @@
                      files           => \@read_files,
                      Pipeline        => $pipeline,
                      QueryReview     => $qv,
-                     ExplainAnalyzer => $exa,
                      %common_modules,
                   );
                }
@@ -14089,7 +14297,38 @@
                   print "\n# No events processed.\n";
                }
 
-               if ( $o->get('statistics') ) {
+               if ( PTDEBUG ) {
+                  # Print statistics about internal counters.  This option is mostly for
+                  # development and debugging.  The statistics report is printed for each
+                  # iteration after all other reports, even if no events are processed or
+                  # C<--no-report> is specified.  The statistics report looks like:
+
+                     # No events processed.
+
+                     # Statistic                                        Count  %/Events
+                     # ================================================ ====== ========
+                     # events_read                                      142030   100.00
+                     # events_parsed                                     50430    35.51
+                     # events_aggregated                                     0     0.00
+                     # ignored_midstream_server_response                 18111    12.75
+                     # no_tcp_data                                       91600    64.49
+                     # pipeline_restarted_after_MemcachedProtocolParser 142030   100.00
+                     # pipeline_restarted_after_TcpdumpParser                1     0.00
+                     # unknown_client_command                                1     0.00
+                     # unknown_client_data                               32318    22.75
+
+                  # The first column is the internal counter name; the second column is counter's
+                  # count; and the third column is the count as a percentage of C<events_read>.
+
+                  # In this case, it shows why no events were processed/aggregated: 100% of events
+                  # were rejected by the C<MemcachedProtocolParser>.  Of those, 35.51% were data
+                  # packets, but of these 12.75% of ignored mid-stream server response, one was
+                  # an unknown client command, and 22.75% were unknown client data.  The other
+                  # 64.49% were TCP control packets (probably most ACKs).
+
+                  # Since pt-query-digest is complex, you will probably need someone familiar
+                  # with its code to decipher the statistics report.
+
                   if ( keys %stats ) {
                      my $report = new ReportFormatter(
                         line_width => 74,
@@ -14395,139 +14634,6 @@
       }
    } # sample
 
-   my $ex_dsn;
-   { # execute throttle and execute
-      my $et;
-      if ( my $et_args = $o->get('execute-throttle') ) {
-         # These were check earlier; no need to check them again.
-         my ($rate_max, $int, $step) = @{$o->get('execute-throttle')};
-         $step ||= 5;
-         $step  /= 100; # step specified as percent but $et expect 0.1=10%, etc.
-         PTDEBUG && _d('Execute throttle:', $rate_max, $int, $step);
-
-         my $get_rate = sub {
-            my $instrument = $pipeline->instrumentation;
-            return percentage_of(
-               $instrument->{execute}->{time}   || 0,
-               $instrument->{Pipeline}->{time}  || 0,
-            );
-         };
-
-         $et = new ExecutionThrottler(
-            rate_max  => $rate_max,
-            get_rate  => $get_rate,
-            check_int => $int,
-            step      => $step,
-         );
-         
-         $pipeline->add(
-            name    => 'execute throttle',
-            process => sub {
-               my ( $args ) = @_;
-               $args->{event} = $et->throttle(
-                  event => $args->{event},
-                  stats => \%stats,
-                  misc  => $args->{misc},
-               );
-               return $args;
-            },
-         );
-      } # execute throttle
-
-      if ( $ex_dsn = $o->get('execute') ) {
-         if ( $o->get('ask-pass') ) {
-            $ex_dsn->{p} = OptionParser::prompt_noecho("Enter password for "
-               . "--execute: ");
-            $o->set('execute', $ex_dsn);
-         }
-
-         my $cur_server = 'execute';
-         ($cur_server, $ex_dbh) = find_role(
-            OptionParser => $o,
-            DSNParser    => $dp,
-            dbh          => $ex_dbh,
-            current      => $cur_server,
-            read_only    => 1,
-            comment      => 'for --execute'
-         );
-         my $cur_time = time();
-         my $curdb;
-         my $default_db = $o->get('execute')->{D};
-         PTDEBUG && _d('Default db:', $default_db);
-         
-         $pipeline->add(
-            name    => 'execute',
-            process => sub {
-               my ( $args ) = @_;
-               my $event = $args->{event};
-               $event->{Exec_orig_time} = $event->{Query_time};
-               if ( ($event->{Skip_exec} || '') eq 'Yes' ) {
-                  PTDEBUG && _d('Not executing event because of ',
-                     '--execute-throttle');
-                  # Zero Query_time to 'Exec time' will show the real time
-                  # spent executing queries.
-                  $event->{Query_time} = 0;
-                  $stats{execute_skipped}++;
-                  return $args;
-               }
-               $stats{execute_executed}++;
-               my $db = $event->{db} || $default_db;
-               eval {
-                  if ( $db && (!$curdb || $db ne $curdb) ) {
-                     $ex_dbh->do("USE $db");
-                     $curdb = $db;
-                  } 
-                  my $start = time();
-                  $ex_dbh->do($event->{arg});
-                  my $end = time();
-                  $event->{Query_time} = $end - $start;
-                  $event->{Exec_diff_time}
-                     = $event->{Query_time} - $event->{Exec_orig_time};
-                  if ($o->get('mirror') && $end-$cur_time > $o->get('mirror')) {
-                     ($cur_server, $ex_dbh) = find_role(
-                        OptionParser => $o,
-                        DSNParser    => $dp,
-                        dbh          => $ex_dbh,
-                        current      => $cur_server,
-                        read_only    => 1,
-                        comment      => 'for --execute'
-                     );
-                     $cur_time = $end;
-                  }
-               };
-               if ( $EVAL_ERROR ) {
-                  PTDEBUG && _d($EVAL_ERROR);
-                  $stats{execute_error}++;
-                  # Don't try to re-execute the statement.  Just skip it.
-                  if ( $EVAL_ERROR =~ m/server has gone away/ ) {
-                     print STDERR $EVAL_ERROR;
-                     eval {
-                        ($cur_server, $ex_dbh) = find_role(
-                           OptionParser => $o,
-                           DSNParser    => $dp,
-                           dbh          => $ex_dbh,
-                           current      => $cur_server,
-                           read_only    => 1,
-                           comment      => 'for --execute'
-                        );
-                        $cur_time = time();
-                     };
-                     if ( $EVAL_ERROR ) {
-                        print STDERR $EVAL_ERROR;
-                        sleep 1;
-                     }
-                     return;
-                  }
-                  if ( $EVAL_ERROR =~ m/No database/ ) {
-                     $stats{execute_no_database}++;
-                  }
-               }
-               return $args;
-            },
-         );
-      } # execute
-   } # execute throttle and execute
-
    if ( $o->get('print') ) {
       my $w = new SlowLogWriter();
       $pipeline->add(
@@ -14636,7 +14742,6 @@
          instances => [
             ($qv_dbh ? { dbh => $qv_dbh, dsn => $review_dsn } : ()),
             ($ps_dbh ? { dbh => $ps_dbh, dsn => $ps_dsn     } : ()),
-            ($ex_dbh ? { dbh => $ex_dbh, dsn => $ex_dsn     } : ())
          ],
          protocol => $o->get('version-check'),
       );
@@ -14661,13 +14766,15 @@
    }
    PTDEBUG && _d("Pipeline data:", Dumper($pipeline_data));
 
+   save_resume_offset();
+
    # Disconnect all open $dbh's
    map {
       $dp->disconnect($_);
       PTDEBUG && _d('Disconnected dbh', $_);
    }
    grep { $_ }
-   ($qv_dbh, $qv_dbh2, $ex_dbh, $ps_dbh, $ep_dbh, $aux_dbh);
+   ($qv_dbh, $ps_dbh, $ep_dbh, $aux_dbh);
 
    return 0;
 } # End main()
@@ -14676,6 +14783,77 @@
 # Subroutines.
 # ############################################################################
 
+sub create_review_tables {
+   my ( %args ) = @_;
+   my @required_args = qw(dbh full_table TableParser);
+   foreach my $arg ( @required_args ) {
+      die "I need a $arg argument" unless $args{$arg};
+   }
+   my $create_table_sql = $args{create_table_sql};
+   my ($dbh, $full_table, $tp) = @args{@required_args};
+
+   PTDEBUG && _d('Checking --review table', $full_table);
+
+   # If the repl db doesn't exit, auto-create it, maybe.
+   my ($db, $tbl)  = Quoter->split_unquote($full_table);
+   my $show_db_sql = qq{SHOW DATABASES LIKE '$db'};
+   PTDEBUG && _d($show_db_sql);
+   my @db_exists = $dbh->selectrow_array($show_db_sql);
+   if ( !@db_exists && !$args{create_table} ) {
+      die "--review database $db does not exist and "
+        . "--no-create-review-tables was specified.  You need "
+        . "to create the database.\n";
+   }
+   else {
+      # Even if the db already exists, do this in case it does not exist
+      # on a slave.
+      my $create_db_sql
+         = "CREATE DATABASE IF NOT EXISTS "
+         . Quoter->quote($db)
+         . " /* $tool */";
+      PTDEBUG && _d($create_db_sql);
+      eval {
+         $dbh->do($create_db_sql);
+      };
+      if ( $EVAL_ERROR && !@db_exists ) {
+         warn $EVAL_ERROR;
+         die "--review database $db does not exist and it cannot be "
+            . "created automatically.  You need to create the database.\n";
+      }
+   }
+   
+   # USE the correct db
+   my $sql = "USE " . Quoter->quote($db);
+   PTDEBUG && _d($sql);
+   $dbh->do($sql);
+
+   # Check if the table exists; if not, create it, maybe.
+   my $tbl_exists = $tp->check_table(
+      dbh => $dbh,
+      db  => $db,
+      tbl => $tbl,
+   );
+
+   PTDEBUG && _d('Table exists: ', $tbl_exists ? 'yes' : 'no');
+
+   if ( !$tbl_exists && !$args{create_table} ) {
+      die "Table $full_table does not exist and "
+        . "--no-create-review-tables was specified.  "
+        . "You need to create the table.\n";
+   }
+   else {
+      PTDEBUG && _d($dbh, $create_table_sql);
+      eval {
+         $dbh->do($create_table_sql);
+      };
+      if ( $EVAL_ERROR && !$args{create_table} ) {
+         warn $EVAL_ERROR;
+         die "--review history table $full_table does not exist and it cannot be "
+           . "created automatically.  You need to create the table.\n"
+      }
+   }
+}
+
 # TODO: This sub is poorly named since it does more than print reports:
 # it aggregates, reports, does QueryReview stuff, etc.
 sub print_reports {
@@ -14694,9 +14872,7 @@
 
    for my $i ( 0..$#groupby ) {
       if ( $o->get('report') || $qv ) {
-         $eas->[$i]->calculate_statistical_metrics(
-            apdex_t => $o->get('apdex-threshold'),
-         );
+         $eas->[$i]->calculate_statistical_metrics();
       }
 
       my ($orderby_attrib, $orderby_func) = split(/:/, $orderby[$i]);
@@ -14734,19 +14910,18 @@
             $print_header = 1;
          }
 
-         my $qrf = new QueryReportFormatter(
-            dbh             => $ep_dbh,
-            %args,
-         );
-         # http://code.google.com/p/maatkit/issues/detail?id=1141
-         $qrf->set_report_formatter(
-            report    => 'profile',
-            formatter => new ReportFormatter (
-               line_width       => $o->get('explain') ? 82 : 74,
-               long_last_column => 1,
-               extend_right     => 1,
-            ),
-         );
+         my $report_class = $o->get('output') =~ m/\Ajson\z/i
+                          ? 'JSONReportFormatter'
+                          : 'QueryReportFormatter';
+         my $qrf = $report_class->new(
+            dbh           => $ep_dbh,
+            QueryReview   => $args{QueryReview},
+            QueryRewriter => $args{QueryRewriter},
+            OptionParser  => $args{OptionParser},
+            QueryParser   => $args{QueryParser},
+            Quoter        => $args{Quoter},
+         );
+
          $qrf->print_reports(
             reports      => \@reports,
             ea           => $eas->[$i],
@@ -14777,14 +14952,6 @@
          $tls->[$i]->reset_aggregated_data();
       }
 
-      if ( $o->get('table-access') ) {  # --table-access
-         print_table_access_report(
-            ea    => $eas->[$i],
-            worst => $worst,
-            %args,
-         );
-      }
-
       $eas->[$i]->reset_aggregated_data();  # Reset for next iteration.
 
       # Print header report only once.  So remove it from the
@@ -14795,7 +14962,7 @@
 
    } # Each groupby
 
-   if ( $o->get('pipeline-profile') ) {
+   if ( PTDEBUG ) {
       my $report = new ReportFormatter(
          line_width => 74,
       );
@@ -14804,7 +14971,7 @@
          { name => 'Time',  right_justify => 1 },
          { name => 'Count', right_justify => 1 },
       );
-      $report->set_title('Pipeline profile');
+      $report->title('Pipeline profile');
       my $instrument = $pipeline->instrumentation;
       my $total_time = $instrument->{Pipeline};
       foreach my $process_name ( $pipeline->processes() ) {
@@ -14816,51 +14983,12 @@
       # Reset profile for next iteration.
       $pipeline->reset();
 
-      print "\n" . $report->get_report();
+      _d($report->get_report());
    }
 
    return;
 }
 
-# Pass in the currently open $dbh (if any), where $current points to ('execute'
-# or 'processlist') and whether you want to be connected to the read_only
-# server.  Get back which server you're looking at, and the $dbh.  Assumes that
-# one of the servers is ALWAYS read only and the other is ALWAYS not!  If
-# there's some transition period where this isn't true, maybe both will end up
-# pointing to the same place, but that should resolve shortly.
-# The magic switching functionality only works if --mirror is given!  Otherwise
-# it just returns the correct $dbh.  $comment is some descriptive text for
-# debuggin, like 'for --execute'.
-sub find_role { 
-   my ( %args ) = @_;
-   my $o         = $args{OptionParser};
-   my $dp        = $args{DSNParser};
-   my $dbh       = $args{dbh};
-   my $current   = $args{current};
-   my $read_only = $args{read_only};
-   my $comment   = $args{comment};
-
-   if ( !$dbh || !$dbh->ping ) {
-      PTDEBUG && _d('Getting a dbh from', $current, $comment);
-      $dbh = $dp->get_dbh(
-         $dp->get_cxn_params($o->get($current)), {AutoCommit => 1});
-      $dbh->{InactiveDestroy}  = 1;  # Don't die on fork().
-   }
-   if ( $o->get('mirror') ) {
-      my ( $is_read_only ) = $dbh->selectrow_array('SELECT @@global.read_only');
-      PTDEBUG && _d("read_only on", $current, $comment, ':',
-                    $is_read_only, '(want', $read_only, ')');
-      if ( $is_read_only != $read_only ) {
-         $current = $current eq 'execute' ? 'processlist' : 'execute';
-         PTDEBUG && _d("read_only wrong", $comment, "getting a dbh from", $current);
-         $dbh = $dp->get_dbh(
-            $dp->get_cxn_params($o->get($current)), {AutoCommit => 1});
-         $dbh->{InactiveDestroy}  = 1;  # Don't die on fork().
-      }
-   }
-   return ($current, $dbh);
-}
-
 # Catches signals so we can exit gracefully.
 sub sig_int {
    my ( $signal ) = @_;
@@ -14870,6 +14998,7 @@
    }
    else {
       print STDERR "# Exiting on SIG$signal.\n";
+      save_resume_offset();
       exit(1);
    }
 }
@@ -15009,54 +15138,6 @@
    return $ea->top_events(%top_spec);
 }
 
-sub print_table_access_report {
-   my ( %args ) = @_;
-   my @required_args = qw(ea worst QueryParser QueryRewriter OptionParser Quoter);
-   foreach my $arg ( @required_args ) {
-      die "I need a $arg argument" unless $args{$arg};
-   }
-   my ($ea, $worst, $qp, $qr, $o, $q) = @args{@required_args};
-
-   my %seen;
-   PTDEBUG && _d('Doing table access report');
-
-   foreach my $worst_info ( @$worst ) {
-      my $item         = $worst_info->[0];
-      my $stats        = $ea->results->{classes}->{$item};
-      my $sample       = $ea->results->{samples}->{$item};
-      my $samp_query   = $sample->{arg} || '';
-      my ($default_db) = $sample->{db}       ? $sample->{db}
-                       : $stats->{db}->{unq} ? keys %{$stats->{db}->{unq}}
-                       :                       undef;
-      eval {
-         QUERY:
-         foreach my $query ( $qp->split($samp_query) ) {
-            my $rw = $qp->query_type($query, $qr)->{rw};
-            next QUERY unless $rw;
-            my @tables = $qp->extract_tables(
-               query      => $query,
-               default_db => $default_db,
-               Quoter     => $args{Quoter},
-            );
-            next QUERY unless scalar @tables;
-            DB_TBL:
-            foreach my $tbl_info ( @tables ) {
-               my ($db, $tbl) = @$tbl_info;
-               $db            = $db ? "`$db`."  : '';
-               next DB_TBL if $seen{"$db$tbl"}++; # Unique-ify for issue 337.
-               print "$rw $db`$tbl`\n";
-            }
-         }
-      };
-      if ( $EVAL_ERROR ) {
-         PTDEBUG && _d($EVAL_ERROR);
-         warn "Cannot get table access for query $_";
-      }
-   }
-
-   return;
-}
-
 sub update_query_review_tables {
    my ( %args ) = @_;
    foreach my $arg ( qw(ea worst QueryReview OptionParser) ) {
@@ -15082,17 +15163,15 @@
          first_seen  => $stats->{ts}->{min},
          last_seen   => $stats->{ts}->{max}
       );
-      if ( $o->get('review-history') ) {
-         my %history;
-         foreach my $attrib ( @$attribs ) {
-            $history{$attrib} = $ea->metrics(
-               attrib => $attrib,
-               where  => $item,
-            );
-         }
-         $qv->set_review_history(
-            $item, $sample->{arg} || '', %history);
+      my %history;
+      foreach my $attrib ( @$attribs ) {
+         $history{$attrib} = $ea->metrics(
+            attrib => $attrib,
+            where  => $item,
+         );
       }
+      $qv->set_review_history(
+         $item, $sample->{arg} || '', %history);
    }
 
    return;
@@ -15163,6 +15242,23 @@
    return $boundary;
 }
 
+sub save_resume_offset {
+   if ( !$resume_file || !$offset ) {
+      PTDEBUG && _d('Not saving resume offset because there is no '
+         . 'resume file or offset:', $resume_file, $offset);
+      return;
+   }
+
+   PTDEBUG && _d('Saving resume at offset', $offset, 'to', $resume_file);
+   open my $resume_fh, '>', $resume_file
+      or die "Error opening $resume_file: $OS_ERROR";
+   print { $resume_fh } $offset, "\n";
+   close $resume_fh
+      or die "Error close $resume_file: $OS_ERROR";
+   warn "\n# Saved resume file offset $offset to $resume_file\n";
+   return;
+}
+
 sub _d {
    my ($package, undef, $line) = caller 0;
    @_ = map { (my $temp = $_) =~ s/\n/\n# /g; $temp; }
@@ -15202,13 +15298,8 @@
 Review a slow log, saving results to the test.query_review table in a MySQL
 server running on host1.  See L<"--review"> for more on reviewing queries:
 
- pt-query-digest --review h=host1,D=test,t=query_review /path/to/slow.log
-
-Filter out everything but SELECT queries, replay the queries against another
-server, then use the timings from replaying them to analyze their performance:
-
- pt-query-digest /path/to/slow.log --execute h=another_server \
-   --filter '$event->{fingerprint} =~ m/^select/'
+ pt-query-digest --review h=host1 --review-table test.query_review
+   --history-table test.query_history /path/to/slow.log
 
 Print the structure of events so you can construct a complex L<"--filter">:
 
@@ -15238,8 +15329,7 @@
 until you are satisfied that the input you give it does not cause undue load.
 
 Various options will cause pt-query-digest to insert data into tables, execute
-SQL queries, and so on.  These include the L<"--execute"> option and
-L<"--review">.
+SQL queries, and so on.  These include the L<"--review"> option.
 
 At the time of this release, we know of no bugs that could cause serious harm
 to users.
@@ -15348,9 +15438,7 @@
  Response time The total response time, and percentage of overall total
  Calls         The number of times this query was executed
  R/Call        The mean response time per execution
- Apdx          The Apdex score; see --apdex-threshold for details
  V/M           The Variance-to-mean ratio of response time
- EXPLAIN       If --explain was specified, a sparkline; see --explain
  Item          The distilled query
 
 A final line whose rank is shown as MISC contains aggregate statistics on the
@@ -15464,12 +15552,6 @@
 
 See also L<"--report-format">.
 
-=head2 SPARKLINES
-
-The output also contains sparklines.  Sparklines are "data-intense,
-design-simple, word-sized graphics" (L<http://en.wikipedia.org/wiki/Sparkline>).There is a sparkline for L<"--report-histogram"> and for L<"--explain">.
-See each of those options for details about interpreting their sparklines.
-
 =head1 QUERY REVIEWS
 
 A "query review" is the process of storing all the query fingerprints analyzed.
@@ -15534,9 +15616,9 @@
 You can see how useful this meta-data is -- as you analyze your queries, you get
 your comments integrated right into the report.
 
-If you add the L<"--review-history"> option, it will also store information into
-a separate database table, so you can keep historical trending information on
-classes of queries.
+The tool will also store information into a separate database table specified
+by the L<"--history-table"> option, so you can keep historical trending information
+on classes of queries.
 
 =back
 
@@ -15640,27 +15722,11 @@
 
 =head1 OPTIONS
 
-DSN values in L<"--review-history"> default to values in L<"--review"> if COPY
-is yes.
-
 This tool accepts additional command-line arguments.  Refer to the
 L<"SYNOPSIS"> and usage information for details.
 
 =over
 
-=item --apdex-threshold
-
-type: float; default: 1.0
-
-Set Apdex target threshold (T) for query response time.  The Application
-Performance Index (Apdex) Technical Specification V1.1 defines T as "a
-positive decimal value in seconds, having no more than two significant digits
-of granularity."  This value only applies to query response time (Query_time).
-
-Options can be abbreviated so specifying C<--apdex-t> also works.
-
-See L<http://www.apdex.org/>.
-
 =item --ask-pass
 
 Prompt for a password when connecting to MySQL.
@@ -15740,21 +15806,19 @@
 
 default: yes
 
-Continue parsing even if there is an error.
-
-=item --create-review-history-table
-
-Create the L<"--review-history"> table if it does not exist.
-
-This option causes the table specified by L<"--review-history"> to be created
-with the default structure shown in the documentation for that option.
-
-=item --create-review-table
-
-Create the L<"--review"> table if it does not exist.
-
-This option causes the table specified by L<"--review"> to be created with the
-default structure shown in the documentation for that option.
+Continue parsing even if there is an error.  The tool will not continue
+forever: it stops once any process causes 100 errors, in which case there
+is probably a bug in the tool or the input is invalid.
+
+=item --[no]create-review-tables
+
+default: yes
+
+Create the L<"--review"> tables if they do not exist.
+
+This option causes the tables specified by L<"--review-table"> and
+L<"--history-table"> to be created with the default structures shown
+in the documentation for L<"--review">.
 
 =item --daemonize
 
@@ -15800,50 +15864,6 @@
 B<NOTE>: All commas in the regex patterns must be escaped with \ otherwise
 the pattern will break.
 
-=item --execute
-
-type: DSN
-
-Execute queries on this DSN.
-
-Adds a callback into the chain, after filters but before the reports.  Events
-are executed on this DSN.  If they are successful, the time they take to execute
-overwrites the event's Query_time attribute and the original Query_time value
-(from the log) is saved as the Exec_orig_time attribute.  If unsuccessful,
-the callback returns false and terminates the chain.
-
-If the connection fails, pt-query-digest tries to reconnect once per second.
-
-See also L<"--mirror"> and L<"--execute-throttle">.
-
-=item --execute-throttle
-
-type: array
-
-Throttle values for L<"--execute">.
-
-By default L<"--execute"> runs without any limitations or concerns for the
-amount of time that it takes to execute the events.  The L<"--execute-throttle">
-allows you to limit the amount of time spent doing L<"--execute"> relative
-to the other processes that handle events.  This works by marking some events
-with a C<Skip_exec> attribute when L<"--execute"> begins to take too much time.
-L<"--execute"> will not execute an event if this attribute is true.  This
-indirectly decreases the time spent doing L<"--execute">.
-
-The L<"--execute-throttle"> option takes at least two comma-separated values:
-max allowed L<"--execute"> time as a percentage and a check interval time.  An
-optional third value is a percentage step for increasing and decreasing the
-probability that an event will be marked C<Skip_exec> true.  5 (percent) is
-the default step.
-
-For example: L<"--execute-throttle"> C<70,60,10>.  This will limit
-L<"--execute"> to 70% of total event processing time, checked every minute
-(60 seconds) and probability stepped up and down by 10%.  When L<"--execute">
-exceeds 70%, the probability that events will be marked C<Skip_exec> true
-increases by 10%. L<"--execute"> time is checked again after another minute.
-If it's still above 70%, then the probability will increase another 10%.
-Or, if it's dropped below 70%, then the probability will decrease by 10%.
-
 =item --expected-range
 
 type: array; default: 5,10
@@ -15868,41 +15888,10 @@
 
   select ... from ( select .... ) der;
 
-The EXPLAIN results are printed in three places: a sparkline in the event
-header, a full vertical format in the event report, and a sparkline in the
-profile.
-
-The full format appears at the end of each event report in vertical style
+The EXPLAIN results are printed as a full vertical format in the event report,
+which appears at the end of each event report in vertical style
 (C<\G>) just like MySQL prints it.
 
-The sparklines (see L<"SPARKLINES">) are compact representations of the
-access type for each table and whether or not "Using temporary" or "Using
-filesort" appear in EXPLAIN.  The sparklines look like:
-
-  nr>TF
-
-That sparkline means that there are two tables, the first uses a range (n)
-access, the second uses a ref access, and both "Using temporary" (T) and
-"Using filesort" (F) appear.  The greater-than character just separates table
-access codes from T and/or F.
-
-The abbreviated table access codes are:
-
-  a  ALL
-  c  const
-  e  eq_ref
-  f  fulltext
-  i  index
-  m  index_merge
-  n  range
-  o  ref_or_null
-  r  ref
-  s  system
-  u  unique_subquery
-
-A capitalized access code means that "Using index" appears in EXPLAIN for
-that table.
-
 =item --filter
 
 type: string
@@ -15992,22 +15981,6 @@
 Since L<"--filter"> allows you to alter C<$event>, you can use it to do other
 things, like create new attributes.  See L<"ATTRIBUTES"> for an example.
 
-=item --fingerprints
-
-Add query fingerprints to the standard query analysis report.  This is mostly
-useful for debugging purposes.
-
-=item --[no]for-explain
-
-default: yes
-
-Print extra information to make analysis easy.
-
-This option adds code snippets to make it easy to run SHOW CREATE TABLE and SHOW
-TABLE STATUS for the query's tables.  It also rewrites non-SELECT queries into a
-SELECT that might be helpful for determining the non-SELECT statement's index
-usage.
-
 =item --group-by
 
 type: Array; default: fingerprint
@@ -16063,6 +16036,12 @@
 
 Show help and exit.
 
+=item --history-table
+
+type: string; default: percona_schema.query_history
+
+Where to save the historical data produced by L<"--review">.
+
 =item --host
 
 short form: -h; type: string
@@ -16092,10 +16071,6 @@
 to "foo", but the next event doesn't have the db attribute, then it inherits
 "foo" for its db attribute.
 
-Inheritance is usually desirable, but in some cases it might confuse things.
-If a query inherits a database that it doesn't actually use, then this could
-confuse L<"--execute">.
-
 =item --interval
 
 type: float; default: .1
@@ -16138,20 +16113,6 @@
 
 Print all output to this file when daemonized.
 
-=item --mirror
-
-type: float
-
-How often to check whether connections should be moved, depending on
-C<read_only>.  Requires L<"--processlist"> and L<"--execute">.
-
-This option causes pt-query-digest to check every N seconds whether it is reading
-from a read-write server and executing against a read-only server, which is a
-sensible way to set up two servers if you're doing something like master-master
-replication.  The L<http://code.google.com/p/mysql-master-master/> master-master
-toolkit does this. The aim is to keep the passive server ready for failover,
-which is impossible without putting it under a realistic workload.
-
 =item --order-by
 
 type: Array; default: Query_time:sum
@@ -16211,6 +16172,13 @@
 
 You can specify an --outliers option for each value in L<"--group-by">.
 
+
+=item --output
+
+type: string; default: query
+
+Type of report to use. Accepted values are C<"query"> and C<"json">.
+
 =item --password
 
 short form: -p; type: string
@@ -16227,10 +16195,6 @@
 PID file when starting; if it exists and the process with the matching PID
 exists, the program exits.
 
-=item --pipeline-profile
-
-Print a profile of the pipeline processes.
-
 =item --port
 
 short form: -P; type: int
@@ -16259,8 +16223,7 @@
 
 Poll this DSN's processlist for queries, with L<"--interval"> sleep between.
 
-If the connection fails, pt-query-digest tries to reopen it once per second. See
-also L<"--mirror">.
+If the connection fails, pt-query-digest tries to reopen it once per second.
 
 =item --progress
 
@@ -16341,36 +16304,35 @@
   #    1s  ########
   #  10s+
 
-A sparkline (see L<"SPARKLINES">) of the full chart is also printed in the
-header for each query event.  The sparkline of that full chart is:
-
-  # Query_time sparkline: |    .^_ |
-
-The sparkline itself is the 8 characters between the pipes (C<|>), one character
-for each of the 8 buckets (1us, 10us, etc.)  Four character codes are used
-to represent the approximate relation between each bucket's value:
-
-  _ . - ^
-
-The caret C<^> represents peaks (buckets with the most values), and
-the underscore C<_> represents lows (buckets with the least or at least
-one value).  The period C<.> and the hyphen C<-> represent buckets with values
-between these two extremes.  If a bucket has no values, a space is printed.
-So in the example above, the period represents the 10ms bucket, the caret
-the 100ms bucket, and the underscore the 1s bucket.
-
 See L<"OUTPUT"> for more information.
 
+=item --resume
+
+type: string
+
+If specified, the tool writes the last file offset, if there is one,
+to the given filename. When ran again with the same value for this option,
+the tool reads the last file offset from the file, seeks to that position
+in the log, and resumes parsing events from that point onward.
+
 =item --review
 
 type: DSN
 
-Store a sample of each class of query in this DSN.
-
-The argument specifies a table to store all unique query fingerprints in.  The
-table must have at least the following columns.  You can add more columns for
-your own special purposes, but they won't be used by pt-query-digest.  The
-following CREATE TABLE definition is also used for L<"--create-review-table">.
+Store a sample of each class of query in this DSN, plus historical values
+for review trend analysis
+
+The argument specifies a host to store all unique query fingerprints in; the
+databases and tables were this data is stored can be specified with the
+L<"--review-table"> and L<"--history-table"> options.
+By default, if the table doesn't exist the tool mtries creating it; This
+behavior can bhe controlled with the L<"--[no]create-review-tables"> option.
+If the table was created manually, it must have at least the following columns.
+You can add more columns for your own special purposes, but they won't be used
+by pt-query-digest.  The following CREATE TABLE definition is also used by
+L<"--no-create-review-tables">.
+
+=for comment ignore-pt-internal-value
 MAGIC_create_review:
 
   CREATE TABLE query_review (
@@ -16405,23 +16367,12 @@
 fingerprint.  This option depends on C<--group-by fingerprint> (which is the
 default).  It will not work otherwise.
 
-=item --review-history
-
-type: DSN
-
-The table in which to store historical values for review trend analysis.
-
-Each time you review queries with L<"--review">, pt-query-digest will save
-information into this table so you can see how classes of queries have changed
-over time.
-
-This DSN inherits unspecified values from L<"--review">.  It should mention a
-table in which to store statistics about each class of queries.  pt-query-digest
-verifies the existence of the table, and your privileges to insert, delete and
-update on that table.
-
-pt-query-digest then inspects the columns in the table.  The table must have at
-least the following columns:
+
+Additionally, pt-query-digest will save historical information into a review table,
+so you can see how classes of queries have changed over time.  You can
+change the destination table with the L<"--history-table">
+
+The table must have at least the following columns:
 
   CREATE TABLE query_review_history (
     checksum     BIGINT UNSIGNED NOT NULL,
@@ -16430,7 +16381,10 @@
 
 Any columns not mentioned above are inspected to see if they follow a certain
 naming convention.  The column is special if the name ends with an underscore
-followed by any of these MAGIC_history_cols values:
+followed by any of these values:
+
+=for comment ignore-pt-internal-value
+MAGIC_history_cols
 
   pct|avt|cnt|sum|min|max|pct_95|stddev|median|rank
 
@@ -16446,8 +16400,11 @@
 you could also just add a ts_min column and make it a DATE type, so you'd get
 one row per class of queries per day.
 
-The default table structure follows.  The following MAGIC_create_review_history
-table definition is used for L<"--create-review-history-table">:
+The default table structure follows.  The following table definition is used
+for L<"--[no]create-review-tables">:
+
+=for comment ignore-pt-internal-value
+MAGIC_create_review_history
 
  CREATE TABLE query_review_history (
    checksum             BIGINT UNSIGNED NOT NULL,
@@ -16553,6 +16510,12 @@
 Note that we store the count (cnt) for the ts attribute only; it will be
 redundant to store this for other attributes.
 
+=item --review-table
+
+type: string; default: percona_schema.query_review
+
+Where to save the samples produced by L<"--review">.
+
 =item --run-time
 
 type: time
@@ -16655,7 +16618,7 @@
 
   Query_time,Lock_time,Rows_sent,Rows_examined,user,db:Schema,ts
 
-Attributes specified in the L<"--review-history"> table will always be selected 
+Attributes in the table specified by L<"--history-table"> will always be selected 
 even if you do not specify L<"--select">.
 
 See also L<"--ignore-attributes"> and L<"ATTRIBUTES">.
@@ -16717,9 +16680,9 @@
     CURRENT_DATE - INTERVAL 7 DAY
 
 If you give a MySQL time expression, then you must also specify a DSN
-so that pt-query-digest can connect to MySQL to evaluate the expression.  If you
-specify L<"--execute">, L<"--explain">, L<"--processlist">, L<"--review">
-or L<"--review-history">, then one of these DSNs will be used automatically.
+so that pt-query-digest can connect to MySQL to evaluate the expression.
+If you specify L<"--explain">, L<"--processlist">, L<"--review">, then
+one of these DSNs will be used automatically.
 Otherwise, you must specify an L<"--aux-dsn"> or pt-query-digest will die
 saying that the value is invalid.
 
@@ -16742,59 +16705,6 @@
 
 Socket file to use for connection.
 
-=item --statistics
-
-Print statistics about internal counters.  This option is mostly for
-development and debugging.  The statistics report is printed for each
-iteration after all other reports, even if no events are processed or
-C<--no-report> is specified.  The statistics report looks like:
-
-   # No events processed.
-
-   # Statistic                                        Count  %/Events
-   # ================================================ ====== ========
-   # events_read                                      142030   100.00
-   # events_parsed                                     50430    35.51
-   # events_aggregated                                     0     0.00
-   # ignored_midstream_server_response                 18111    12.75
-   # no_tcp_data                                       91600    64.49
-   # pipeline_restarted_after_MemcachedProtocolParser 142030   100.00
-   # pipeline_restarted_after_TcpdumpParser                1     0.00
-   # unknown_client_command                                1     0.00
-   # unknown_client_data                               32318    22.75
-
-The first column is the internal counter name; the second column is counter's
-count; and the third column is the count as a percentage of C<events_read>.
-
-In this case, it shows why no events were processed/aggregated: 100% of events
-were rejected by the C<MemcachedProtocolParser>.  Of those, 35.51% were data
-packets, but of these 12.75% of ignored mid-stream server response, one was
-an unknown client command, and 22.75% were unknown client data.  The other
-64.49% were TCP control packets (probably most ACKs).
-
-Since pt-query-digest is complex, you will probably need someone familiar
-with its code to decipher the statistics report.
-
-=item --table-access
-
-Print a table access report.
-
-The table access report shows which tables are accessed by all the queries
-and if the access is a read or write.  The report looks like:
-
-  write `baz`.`tbl`
-  read `baz`.`new_tbl`
-  write `baz`.`tbl3`
-  write `db6`.`tbl6`
-
-If you pipe the output to L<sort>, the read and write tables will be grouped
-together and sorted alphabetically:
-
-  read `baz`.`new_tbl`
-  write `baz`.`tbl`
-  write `baz`.`tbl3`
-  write `db6`.`tbl6`
-
 =item --tcpdump-errors
 
 type: string
@@ -17092,7 +17002,8 @@
 
 dsn: database; copy: yes
 
-Database that contains the query review table.
+Default database for the review option. Only useful if there are replication
+filters set up.
 
 =item * F
 
@@ -17126,7 +17037,7 @@
 
 =item * t
 
-Table to use as the query review table.
+Not used.
 
 =item * u
 

=== modified file 'bin/pt-table-usage'
--- bin/pt-table-usage	2013-01-03 00:54:18 +0000
+++ bin/pt-table-usage	2013-01-30 20:58:23 +0000
@@ -5345,7 +5345,7 @@
    }
 
    my $self = {
-      instrument        => 0,
+      instrument        => PTDEBUG,
       continue_on_error => 0,
 
       %args,
@@ -5372,9 +5372,7 @@
 
    push @{$self->{procs}}, $process;
    push @{$self->{names}}, $name;
-   if ( my $n = $args{retry_on_error} ) {
-      $self->{retries}->{$name} = $n;
-   }
+   $self->{retries}->{$name} = $args{retry_on_error} || 100;
    if ( $self->{instrument} ) {
       $self->{instrumentation}->{$name} = { time => 0, calls => 0 };
    }
@@ -5443,7 +5441,11 @@
          my $msg  = "Pipeline process " . ($procno + 1)
                   . " ($name) caused an error: "
                   . $EVAL_ERROR;
-         if ( defined $self->{retries}->{$name} ) {
+         if ( !$self->{continue_on_error} ) {
+            die $msg . "Terminating pipeline because --continue-on-error "
+               . "is false.\n";
+         }
+         elsif ( defined $self->{retries}->{$name} ) {
             my $n = $self->{retries}->{$name};
             if ( $n ) {
                warn $msg . "Will retry pipeline process $procno ($name) "
@@ -5455,9 +5457,6 @@
                   . "($name) caused too many errors.\n";
             }
          }
-         elsif ( !$self->{continue_on_error} ) {
-            die $msg;
-         }
          else {
             warn $msg;
          }

=== modified file 'lib/EventAggregator.pm'
--- lib/EventAggregator.pm	2013-01-03 00:19:16 +0000
+++ lib/EventAggregator.pm	2013-01-30 20:58:23 +0000
@@ -619,16 +619,6 @@
                   $classes->{$class}->{$attrib}->{all},
                   $classes->{$class}->{$attrib}
                );
-
-            # Apdex (http://code.google.com/p/maatkit/issues/detail?id=1054)
-            if ( $args{apdex_t} && $attrib eq 'Query_time' ) {
-               $class_metrics->{$class}->{$attrib}->{apdex_t} = $args{apdex_t};
-               $class_metrics->{$class}->{$attrib}->{apdex}
-                  = $self->calculate_apdex(
-                     t       => $args{apdex_t},
-                     samples => $classes->{$class}->{$attrib}->{all},
-                  );
-            }
          }
       }
    }
@@ -784,9 +774,6 @@
       median => $metrics->{classes}->{$where}->{$attrib}->{median} || 0,
       pct_95 => $metrics->{classes}->{$where}->{$attrib}->{pct_95} || 0,
       stddev => $metrics->{classes}->{$where}->{$attrib}->{stddev} || 0,
-
-      apdex_t => $metrics->{classes}->{$where}->{$attrib}->{apdex_t},
-      apdex   => $metrics->{classes}->{$where}->{$attrib}->{apdex},
    };
 }
 
@@ -1164,70 +1151,6 @@
    return $copy;
 }
 
-# Sub: calculate_apdex
-#   Calculate the Apdex score for the given T and response times.
-#   <http://www.apdex.org/documents/ApdexTechnicalSpecificationV11_000.pdf>
-#
-# Parameters:
-#   %args - Arguments
-#
-# Required Arguments:
-#   t       - Target threshold
-#   samples - Hashref with bucketized response time values,
-#             i.e. { bucket_number => n_responses, }
-#
-# Returns:
-#   Apdex score
-sub calculate_apdex {
-   my ( $self, %args ) = @_;
-   my @required_args = qw(t samples);
-   foreach my $arg ( @required_args ) {
-      die "I need a $arg argument" unless $args{$arg};
-   }
-   my ($t, $samples) = @args{@required_args};
-
-   if ( $t <= 0 ) {
-      die "Invalid target threshold (T): $t.  T must be greater than zero";
-   }
-
-   my $f = 4 * $t;
-   PTDEBUG && _d("Apdex T =", $t, "F =", $f);
-
-   my $satisfied  = 0;
-   my $tolerating = 0;
-   my $frustrated = 0;  # just for debug output
-   my $n_samples  = 0;
-   BUCKET:
-   for my $bucket ( keys %$samples ) {
-      my $n_responses   = $samples->{$bucket};
-      my $response_time = $buck_vals[$bucket];
-
-      # Response time increases from 0 to F.
-      # 0 --- T --- F
-      #    ^     ^-- tolerating zone
-      #    |
-      #    +-------- satisfied zone
-      if ( $response_time <= $t ) {
-         $satisfied += $n_responses;
-      }
-      elsif ( $response_time <= $f ) {
-         $tolerating += $n_responses;
-      }
-      else {
-         $frustrated += $n_responses;
-      }
-
-      $n_samples += $n_responses;
-   }
-
-   my $apdex = sprintf('%.2f', ($satisfied + ($tolerating / 2)) / $n_samples);
-   PTDEBUG && _d($n_samples, "samples,", $satisfied, "satisfied,",
-      $tolerating, "tolerating,", $frustrated, "frustrated, Apdex score:",
-      $apdex);
-
-   return $apdex;
-}
-
 # Sub: _get_value
 #   Get the value of the attribute (or one of its alternatives) from the event.
 #   Undef is a valid value.  If the attrib or none of its alternatives exist

=== modified file 'lib/ExplainAnalyzer.pm'
--- lib/ExplainAnalyzer.pm	2013-01-03 00:19:16 +0000
+++ lib/ExplainAnalyzer.pm	2013-01-30 20:58:23 +0000
@@ -215,7 +215,7 @@
 #   explain - Hashref of normalized EXPLAIN data
 #
 # Returns:
-#   Fingerprint/sparkline string
+#   Fingerprint string
 sub fingerprint {
    my ( $self, %args ) = @_;
    my @required_args = qw(explain);
@@ -225,92 +225,6 @@
    my ($explain) = @args{@required_args};
 }
 
-# Sub: sparkline
-#   Create a sparkline of EXPLAIN data from <normalize()>.  A spark line
-#   is a very compact, terse fingerprint that represents just the following.
-#   See <issue 1141 at http://code.google.com/p/maatkit/issues/detail?id=1141>.
-#
-#   access (for each table):
-#     - a: ALL
-#     - c: const
-#     - e: eq_ref
-#     - f: fulltext
-#     - i: index
-#     - m: index_merge
-#     - n: range
-#     - o: ref_or_null
-#     - r: ref
-#     - s: system
-#     - u: unique_subquery
-#
-#   Extra:
-#     - uppsercaes access code: Using extra
-#     - T: Using temprary
-#     - F: Using filesort
-#
-# Parameters:
-#   %args - Arguments
-#
-# Required Arguments:
-#   explain - Hashref of normalized EXPLAIN data
-#
-# Returns:
-#   Sparkline string like (start code)TF>Ree(end code)
-sub sparkline {
-   my ( $self, %args ) = @_;
-   my @required_args = qw(explain);
-   foreach my $arg ( @required_args ) {
-      die "I need a $arg argument" unless defined $args{$arg};
-   }
-   my ($explain) = @args{@required_args};
-   PTDEBUG && _d("Making sparkline for", Dumper($explain));
-
-   my $access_code = {
-      'ALL'             => 'a',
-      'const'           => 'c',
-      'eq_ref'          => 'e',
-      'fulltext'        => 'f',
-      'index'           => 'i',
-      'index_merge'     => 'm',
-      'range'           => 'n',
-      'ref_or_null'     => 'o',
-      'ref'             => 'r',
-      'system'          => 's',
-      'unique_subquery' => 'u',
-   };
-
-   my $sparkline = '';
-   my ($T, $F);  # Using temporary, Using filesort
-
-   foreach my $tbl ( @$explain ) {
-      my $code;
-      if ( defined $tbl->{type} ) {
-         $code = $access_code->{$tbl->{type}} || "?";
-         $code = uc $code if $tbl->{Extra}->{'Using index'};
-      }
-      else {
-         $code = '-'
-      };
-      $sparkline .= $code;
-
-      $T = 1 if $tbl->{Extra}->{'Using temporary'};
-      $F = 1 if $tbl->{Extra}->{'Using filesort'};
-   }
-
-   if ( $T || $F ) {
-      if (    $explain->[-1]->{Extra}->{'Using temporary'}
-           || $explain->[-1]->{Extra}->{'Using filesort'} ) {
-         $sparkline .= ">" . ($T ? "T" : "") . ($F ? "F" : "");
-      }
-      else {
-         $sparkline = ($T ? "T" : "") . ($F ? "F" : "") . ">$sparkline";
-      }
-   }
-
-   PTDEBUG && _d("sparkline:", $sparkline);
-   return $sparkline;
-}
-
 sub _d {
    my ($package, undef, $line) = caller 0;
    @_ = map { (my $temp = $_) =~ s/\n/\n# /g; $temp; }

=== added file 'lib/JSONReportFormatter.pm'
--- lib/JSONReportFormatter.pm	1970-01-01 00:00:00 +0000
+++ lib/JSONReportFormatter.pm	2013-01-30 20:58:23 +0000
@@ -0,0 +1,124 @@
+{
+package JSONReportFormatter;
+use Mo;
+
+use List::Util   qw(sum);
+use Transformers qw(make_checksum parse_timestamp);
+
+use constant PTDEBUG => $ENV{PTDEBUG} || 0;
+
+my $have_json = eval { require JSON };
+
+our $pretty_json = undef;
+our $sorted_json = undef;
+
+extends qw(QueryReportFormatter);
+
+has _json => (
+   is       => 'ro',
+   init_arg => undef,
+   builder  => '_build_json',
+);
+
+sub _build_json {
+   return unless $have_json;
+   return JSON->new->utf8
+                   ->pretty($pretty_json)
+                   ->canonical($sorted_json);
+}
+
+sub encode_json {
+   my ($self, $encode) = @_;
+   if ( my $json = $self->_json ) {
+      return $json->encode($encode);
+   }
+   else {
+      return Transformers::encode_json($encode);
+   }
+}
+
+override [qw(rusage date hostname files header profile prepared)] => sub {
+   return;
+};
+
+override event_report => sub {
+   my ($self, %args) = @_;
+   return $self->event_report_values(%args);
+};
+
+override query_report => sub {
+   my ($self, %args) = @_;
+   foreach my $arg ( qw(ea worst orderby groupby) ) {
+      die "I need a $arg argument" unless defined $arg;
+   }
+
+   my $ea    = $args{ea};
+   my $worst = $args{worst};
+
+   my @attribs = @{$ea->get_attributes()};
+   
+   my @queries;
+   foreach my $worst_info ( @$worst ) {
+      my $item   = $worst_info->[0];
+      my $stats  = $ea->results->{classes}->{$item};
+      my $sample = $ea->results->{samples}->{$item};
+
+      my $all_log_pos = $ea->{result_classes}->{$item}->{pos_in_log}->{all};
+      my $times_seen  = sum values %$all_log_pos;
+      
+      my %class = (
+         sample      => $sample->{arg},
+         fingerprint => $item,
+         checksum    => make_checksum($item),
+         cnt         => $times_seen,
+      );
+      
+      my %metrics;
+      foreach my $attrib ( @attribs ) {
+         $metrics{$attrib} = $ea->metrics(
+            attrib => $attrib,
+            where  => $item,
+         );
+      }
+
+      foreach my $attrib ( keys %metrics ) {
+         if ( ! grep { $_ } values %{$metrics{$attrib}} ) {
+            delete $metrics{$attrib};
+            next;
+         }
+
+         if ($attrib eq 'ts') {
+            my $ts = delete $metrics{ts};
+            foreach my $thing ( qw(min max) ) {
+               next unless defined $ts && defined $ts->{$thing};
+               $ts->{$thing} = parse_timestamp($ts->{$thing});
+            }
+            $class{ts_min} = $ts->{min};
+            $class{ts_max} = $ts->{max};
+         }
+         elsif ( ($ea->{type_for}->{$attrib} || '') eq 'num' ) {
+            # Avoid scientific notation in the metrics by forcing it to use
+            # six decimal places.
+            for my $value ( values %{$metrics{$attrib}} ) {
+               next unless $value;
+               $value = sprintf '%.6f', $value;
+            }
+            # ..except for the percentage, which only needs two
+            if ( my $pct = $metrics{$attrib}->{pct} ) {
+               $metrics{$attrib}->{pct} = sprintf('%.2f', $pct);
+            }
+         }
+      }
+      push @queries, {
+         class       => \%class,
+         attributes  => \%metrics,
+      };
+   }
+
+   my $json = $self->encode_json(\@queries);
+   $json .= "\n" if $json !~ /\n\Z/;
+   return $json . "\n";
+};
+
+1;
+}

=== modified file 'lib/Mo.pm'
--- lib/Mo.pm	2013-01-03 00:19:16 +0000
+++ lib/Mo.pm	2013-01-30 20:58:23 +0000
@@ -177,6 +177,7 @@
             _set_package_isa($caller, @_);
             _set_inherited_metadata($caller);
         },
+        override => \&override,
         has => sub {
             my $names = shift;
             for my $attribute ( ref $names ? @$names : $names ) {
@@ -512,6 +513,16 @@
    }
 }
 
+sub override {
+   my ($methods, $code) = @_;
+   my $caller          = scalar caller;
+
+   for my $method ( ref($methods) ? @$methods : $methods ) {
+      my $full_method     = "${caller}::${method}";
+      *{_glob_for $full_method} = $code;
+   }
+}
+
 }
 1;
 # ###########################################################################

=== modified file 'lib/Pipeline.pm'
--- lib/Pipeline.pm	2013-01-03 00:19:16 +0000
+++ lib/Pipeline.pm	2013-01-30 20:58:23 +0000
@@ -42,7 +42,7 @@
 
    my $self = {
       # default values for optional args
-      instrument        => 0,
+      instrument        => PTDEBUG,
       continue_on_error => 0,
 
       # specified arg values override defaults
@@ -71,9 +71,7 @@
 
    push @{$self->{procs}}, $process;
    push @{$self->{names}}, $name;
-   if ( my $n = $args{retry_on_error} ) {
-      $self->{retries}->{$name} = $n;
-   }
+   $self->{retries}->{$name} = $args{retry_on_error} || 100;
    if ( $self->{instrument} ) {
       $self->{instrumentation}->{$name} = { time => 0, calls => 0 };
    }
@@ -163,7 +161,11 @@
          my $msg  = "Pipeline process " . ($procno + 1)
                   . " ($name) caused an error: "
                   . $EVAL_ERROR;
-         if ( defined $self->{retries}->{$name} ) {
+         if ( !$self->{continue_on_error} ) {
+            die $msg . "Terminating pipeline because --continue-on-error "
+               . "is false.\n";
+         }
+         elsif ( defined $self->{retries}->{$name} ) {
             my $n = $self->{retries}->{$name};
             if ( $n ) {
                warn $msg . "Will retry pipeline process $procno ($name) "
@@ -175,9 +177,6 @@
                   . "($name) caused too many errors.\n";
             }
          }
-         elsif ( !$self->{continue_on_error} ) {
-            die $msg;
-         }
          else {
             warn $msg;
          }

=== modified file 'lib/QueryReportFormatter.pm'
--- lib/QueryReportFormatter.pm	2013-01-03 00:19:16 +0000
+++ lib/QueryReportFormatter.pm	2013-01-30 20:58:23 +0000
@@ -29,8 +29,7 @@
 # which is also in mk-query-digest.
 package QueryReportFormatter;
 
-use strict;
-use warnings FATAL => 'all';
+use Mo;
 use English qw(-no_match_vars);
 use POSIX qw(floor);
 
@@ -43,6 +42,9 @@
 use constant LINE_LENGTH       => 74;
 use constant MAX_STRING_LENGTH => 10;
 
+{ local $EVAL_ERROR; eval { require Quoter } };
+{ local $EVAL_ERROR; eval { require ReportFormatter } };
+
 # Sub: new
 # 
 # Parameters:
@@ -56,31 +58,69 @@
 # Optional arguments:
 #   QueryReview     - <QueryReview> object used in <query_report()>
 #   dbh             - dbh used in <explain_report()>
-#   ExplainAnalyzer - <ExplainAnalyzer> object used in <explain_report()>.
-#                     This causes a sparkline to be printed (issue 1141).
 #
 # Returns:
 #   QueryReportFormatter object
-sub new {
-   my ( $class, %args ) = @_;
-   foreach my $arg ( qw(OptionParser QueryRewriter Quoter) ) {
-      die "I need a $arg argument" unless $args{$arg};
+has Quoter => (
+   is      => 'ro',
+   isa     => 'Quoter',
+   default => sub { Quoter->new() },
+);
+
+has label_width => (
+   is      => 'ro',
+   isa     => 'Int',
+);
+
+has global_headers => (
+   is      => 'ro',
+   isa     => 'ArrayRef',
+   default => sub { [qw(    total min max avg 95% stddev median)] },
+);
+
+has event_headers => (
+   is      => 'ro',
+   isa     => 'ArrayRef',
+   default => sub { [qw(pct total min max avg 95% stddev median)] },
+);
+
+has ReportFormatter => (
+   is      => 'ro',
+   isa     => 'ReportFormatter',
+   builder => '_build_report_formatter',
+);
+
+sub _build_report_formatter {
+   return ReportFormatter->new(
+      line_width       => LINE_LENGTH,
+      extend_right     => 1,
+   );
+}
+
+sub BUILDARGS {
+   my $class = shift;
+   my $args  = $class->SUPER::BUILDARGS(@_);
+
+   foreach my $arg ( qw(OptionParser QueryRewriter) ) {
+      die "I need a $arg argument" unless $args->{$arg};
    }
 
    # If ever someone wishes for a wider label width.
-   my $label_width = $args{label_width} || 12;
+   my $label_width = $args->{label_width} ||= 12;
    PTDEBUG && _d('Label width:', $label_width);
 
-   my $cheat_width = $label_width + 1;
-
+   my $o = delete $args->{OptionParser};
    my $self = {
-      %args,
-      label_width    => $label_width,
+      %$args,
+      options        => {
+         show_all         => $o->get('show-all'),
+         shorten          => $o->get('shorten'),
+         report_all       => $o->get('report-all'),
+         report_histogram => $o->get('report-histogram'),
+      },
       num_format     => "# %-${label_width}s %3s %7s %7s %7s %7s %7s %7s %7s",
       bool_format    => "# %-${label_width}s %3d%% yes, %3d%% no",
       string_format  => "# %-${label_width}s %s",
-      global_headers => [qw(    total min max avg 95% stddev median)],
-      event_headers  => [qw(pct total min max avg 95% stddev median)],
       hidden_attrib  => {   # Don't sort/print these attribs in the reports.
          arg         => 1, # They're usually handled specially, or not
          fingerprint => 1, # printed at all.
@@ -88,32 +128,7 @@
          ts          => 1,
       },
    };
-   return bless $self, $class;
-}
-
-# Sub: set_report_formatter
-#   Set a report formatter object for a report.  By default this package will
-#   instantiate ReportFormatter objects to format columnized reports (e.g.
-#   for profile and prepared reports).  Setting a caller-created formatter
-#   object (usually a <ReportFormatter> obj) is used for tested and also by
-#   <mk-query-digest> to extend the profile report line width to 82 for
-#   the --explain sparkline.
-#
-# Parameters:
-#   %args - Arguments
-#
-# Required Arguments:
-#   report    - Report name, e.g. profile, prepared, etc.
-#   formatter - Formatter object, usually a <ReportFormatter> obj
-sub set_report_formatter {
-   my ( $self, %args ) = @_;
-   my @required_args = qw(report formatter);
-   foreach my $arg ( @required_args ) {
-      die "I need a $arg argument" unless exists $args{$arg};
-   }
-   my ($report, $formatter) = @args{@required_args};
-   $self->{formatter_for}->{$report} = $formatter;
-   return;
+   return $self;
 }
 
 # Arguments:
@@ -243,7 +258,7 @@
       shorten(scalar keys %{$results->{classes}}, d=>1_000),
       shorten($qps  || 0, d=>1_000),
       shorten($conc || 0, d=>1_000));
-   $line .= ('_' x (LINE_LENGTH - length($line) + $self->{label_width} - 12));
+   $line .= ('_' x (LINE_LENGTH - length($line) + $self->label_width() - 12));
    push @result, $line;
 
    # Second line: time range
@@ -308,6 +323,70 @@
    return join("\n", map { s/\s+$//; $_ } @result) . "\n";
 }
 
+sub query_report_values {
+   my ($self, %args) = @_;
+   foreach my $arg ( qw(ea worst orderby groupby) ) {
+      die "I need a $arg argument" unless defined $arg;
+   }
+   my $ea      = $args{ea};
+   my $groupby = $args{groupby};
+   my $worst   = $args{worst};
+
+   my $q   = $self->Quoter;
+   my $qv  = $self->{QueryReview};
+   my $qr  = $self->{QueryRewriter};
+
+   my @values;
+   # Print each worst item: its stats/metrics (sum/min/max/95%/etc.),
+   # Query_time distro chart, tables, EXPLAIN, fingerprint, etc.
+   # Items are usually unique queries/fingerprints--depends on how
+   # the events were grouped.
+   ITEM:
+   foreach my $top_event ( @$worst ) {
+      my $item       = $top_event->[0];
+      my $reason     = $args{explain_why} ? $top_event->[1] : '';
+      my $rank       = $top_event->[2];
+      my $stats      = $ea->results->{classes}->{$item};
+      my $sample     = $ea->results->{samples}->{$item};
+      my $samp_query = $sample->{arg} || '';
+
+      my %item_vals = (
+         item       => $item,
+         samp_query => $samp_query,
+         rank       => ($rank || 0),
+         reason     => $reason,
+      );
+
+      # ###############################################################
+      # Possibly skip item for --review.
+      # ###############################################################
+      my $review_vals;
+      if ( $qv ) {
+         $review_vals = $qv->get_review_info($item);
+         next ITEM if $review_vals->{reviewed_by} && !$self->{options}->{report_all};
+         for my $col ( $qv->review_cols() ) {
+            push @{$item_vals{review_vals}}, [$col, $review_vals->{$col}];
+         }
+      }
+
+      $item_vals{default_db} = $sample->{db}       ? $sample->{db}
+                              : $stats->{db}->{unq} ? keys %{$stats->{db}->{unq}}
+                              :                       undef;
+      $item_vals{tables} = [$self->{QueryParser}->extract_tables(
+            query      => $samp_query,
+            default_db => $item_vals{default_db},
+            Quoter     => $self->Quoter,
+         )];
+
+      if ( $samp_query && ($args{variations} && @{$args{variations}}) ) {
+         $item_vals{crc} = crc32($samp_query);
+      }
+
+      push @values, \%item_vals;
+   }
+   return \@values;
+}
+
 # Arguments:
 #   * ea       obj: EventAggregator
 #   * worst    arrayref: worst items
@@ -319,16 +398,11 @@
 #   * print_header  bool: "Report grouped by" header
 sub query_report {
    my ( $self, %args ) = @_;
-   foreach my $arg ( qw(ea worst orderby groupby) ) {
-      die "I need a $arg argument" unless defined $arg;
-   }
+
    my $ea      = $args{ea};
    my $groupby = $args{groupby};
-   my $worst   = $args{worst};
+   my $report_values = $self->query_report_values(%args);
 
-   my $o   = $self->{OptionParser};
-   my $q   = $self->{Quoter};
-   my $qv  = $self->{QueryReview};
    my $qr  = $self->{QueryRewriter};
 
    my $report = '';
@@ -350,66 +424,36 @@
    # Items are usually unique queries/fingerprints--depends on how
    # the events were grouped.
    ITEM:
-   foreach my $top_event ( @$worst ) {
-      my $item       = $top_event->[0];
-      my $reason     = $args{explain_why} ? $top_event->[1] : '';
-      my $rank       = $top_event->[2];
-      my $stats      = $ea->results->{classes}->{$item};
-      my $sample     = $ea->results->{samples}->{$item};
-      my $samp_query = $sample->{arg} || '';
-
-      # ###############################################################
-      # Possibly skip item for --review.
-      # ###############################################################
-      my $review_vals;
-      if ( $qv ) {
-         $review_vals = $qv->get_review_info($item);
-         next ITEM if $review_vals->{reviewed_by} && !$o->get('report-all');
-      }
-
-      # ###############################################################
-      # Get tables for --for-explain.
-      # ###############################################################
-      my ($default_db) = $sample->{db}       ? $sample->{db}
-                       : $stats->{db}->{unq} ? keys %{$stats->{db}->{unq}}
-                       :                       undef;
-      my @tables;
-      if ( $o->get('for-explain') ) {
-         @tables = $self->{QueryParser}->extract_tables(
-            query      => $samp_query,
-            default_db => $default_db,
-            Quoter     => $self->{Quoter},
-         );
-      }
-
+   foreach my $vals ( @$report_values ) {
+      my $item = $vals->{item};
       # ###############################################################
       # Print the standard query analysis report.
       # ###############################################################
-      $report .= "\n" if $rank > 1;  # space between each event report
+      $report .= "\n" if $vals->{rank} > 1;  # space between each event report
       $report .= $self->event_report(
          %args,
          item    => $item,
-         sample  => $sample,
-         rank    => $rank,
-         reason  => $reason,
+         sample  => $ea->results->{samples}->{$item},
+         rank    => $vals->{rank},
+         reason  => $vals->{reason},
          attribs => $attribs,
-         db      => $default_db,
+         db      => $vals->{default_db},
       );
 
-      if ( $o->get('report-histogram') ) {
+      if ( $self->{options}->{report_histogram} ) {
          $report .= $self->chart_distro(
             %args,
-            attrib => $o->get('report-histogram'),
-            item   => $item,
+            attrib => $self->{options}->{report_histogram},
+            item   => $vals->{item},
          );
       }
 
-      if ( $qv && $review_vals ) {
+      if ( $vals->{review_vals} ) {
          # Print the review information that is already in the table
          # before putting anything new into the table.
          $report .= "# Review information\n";
-         foreach my $col ( $qv->review_cols() ) {
-            my $val = $review_vals->{$col};
+         foreach my $elem ( @{$vals->{review_vals}} ) {
+            my ($col, $val) = @$elem;
             if ( !$val || $val ne '0000-00-00 00:00:00' ) { # issue 202
                $report .= sprintf "# %13s: %-s\n", $col, ($val ? $val : '');
             }
@@ -418,25 +462,22 @@
 
       if ( $groupby eq 'fingerprint' ) {
          # Shorten it if necessary (issue 216 and 292).           
-         $samp_query = $qr->shorten($samp_query, $o->get('shorten'))
-            if $o->get('shorten');
+         my $samp_query = $qr->shorten($vals->{samp_query}, $self->{options}->{shorten})
+            if $self->{options}->{shorten};
 
          # Print query fingerprint.
-         $report .= "# Fingerprint\n#    $item\n"
-            if $o->get('fingerprints');
+         PTDEBUG && _d("Fingerprint\n#    $vals->{item}\n");
 
          # Print tables used by query.
-         $report .= $self->tables_report(@tables)
-            if $o->get('for-explain');
+         $report .= $self->tables_report(@{$vals->{tables}});
 
          # Print sample (worst) query's CRC % 1_000.  We mod 1_000 because
          # that's actually the value stored in the ea, not the full checksum.
          # So the report will print something like,
          #   # arg crc      685 (2/66%), 159 (1/33%)
          # Thus we want our "CRC" line to be 685 and not 18547302820.
-         if ( $samp_query && ($args{variations} && @{$args{variations}}) ) {
-            my $crc = crc32($samp_query);
-            $report.= "# CRC " . ($crc ? $crc % 1_000 : "") . "\n";
+         if ( $vals->{crc} ) {
+            $report.= "# CRC " . ($vals->{crc} % 1_000) . "\n";
          }
 
          my $log_type = $args{log_type} || '';
@@ -450,14 +491,13 @@
             }
             else {
                $report .= "# EXPLAIN /*!50100 PARTITIONS*/\n$samp_query${mark}\n"; 
-               $report .= $self->explain_report($samp_query, $default_db);
+               $report .= $self->explain_report($samp_query, $vals->{default_db});
             }
          }
          else {
             $report .= "$samp_query${mark}\n"; 
             my $converted = $qr->convert_to_select($samp_query);
-            if ( $o->get('for-explain')
-                 && $converted
+            if ( $converted
                  && $converted =~ m/^[\(\s]*select/i ) {
                # It converted OK to a SELECT
                $report .= "# Converted for EXPLAIN\n# EXPLAIN /*!50100 PARTITIONS*/\n$converted${mark}\n";
@@ -466,7 +506,7 @@
       }
       else {
          if ( $groupby eq 'tables' ) {
-            my ( $db, $tbl ) = $q->split_unquote($item);
+            my ( $db, $tbl ) = $self->Quoter->split_unquote($item);
             $report .= $self->tables_report([$db, $tbl]);
          }
          $report .= "$item\n";
@@ -486,21 +526,20 @@
 #   * rank        scalar: item rank among the worst
 # Print a report about the statistics in the EventAggregator.
 # Called by query_report().
-sub event_report {
-   my ( $self, %args ) = @_;
-   foreach my $arg ( qw(ea item orderby) ) {
-      die "I need a $arg argument" unless defined $args{$arg};
-   }
-   my $ea      = $args{ea};
-   my $item    = $args{item};
+sub event_report_values {
+   my ($self, %args) = @_;
+
+   my $ea   = $args{ea};
+   my $item = $args{item};
    my $orderby = $args{orderby};
    my $results = $ea->results();
-   my $o       = $self->{OptionParser};
-   my @result;
+
+   my %vals;
 
    # Return unless the item exists in the results (it should).
    my $store = $results->{classes}->{$item};
-   return "# No such event $item\n" unless $store;
+
+   return unless $store;
 
    # Pick the first attribute to get counts
    my $global_cnt = $results->{globals}->{$orderby}->{cnt};
@@ -521,79 +560,25 @@
       };
    }
 
-   # First line like:
-   # Query 1: 9 QPS, 0x concurrency, ID 0x7F7D57ACDD8A346E at byte 5 ________
-   my $line = sprintf(
-      '# %s %d: %s QPS, %sx concurrency, ID 0x%s at byte %.f ',
-      ($ea->{groupby} eq 'fingerprint' ? 'Query' : 'Item'),
-      $args{rank} || 0,
-      shorten($qps  || 0, d=>1_000),
-      shorten($conc || 0, d=>1_000),
-      make_checksum($item),
-      $results->{samples}->{$item}->{pos_in_log} || 0,
-   );
-   $line .= ('_' x (LINE_LENGTH - length($line) + $self->{label_width} - 12));
-   push @result, $line;
-
-   # Second line: reason why this class is being reported.
-   if ( $args{reason} ) {
-      push @result,
-         "# This item is included in the report because it matches "
-            . ($args{reason} eq 'top' ? '--limit.' : '--outliers.');
-   }
-
-   # Third line: Apdex and variance-to-mean (V/M) ratio, like:
-   # Scores: Apdex = 0.93 [1.0], V/M = 1.5
-   {
+   $vals{groupby}     = $ea->{groupby};
+   $vals{qps}         = $qps  || 0;
+   $vals{concurrency} = $conc || 0;
+   $vals{checksum}    = make_checksum($item);
+   $vals{pos_in_log}  = $results->{samples}->{$item}->{pos_in_log} || 0;
+   $vals{reason}      = $args{reason};
+   $vals{variance_to_mean} = do {
       my $query_time = $ea->metrics(where => $item, attrib => 'Query_time');
-      push @result,
-         sprintf("# Scores: Apdex = %s [%3.1f]%s, V/M = %.2f",
-            (defined $query_time->{apdex} ? "$query_time->{apdex}" : "NS"),
-            ($query_time->{apdex_t} || 0),
-            ($query_time->{cnt} < 100 ? "*" : ""),
-            ($query_time->{stddev}**2 / ($query_time->{avg} || 1)),
-         );
-   }
-
-   # Fourth line: EXPLAIN sparkline if --explain.
-   if ( $o->get('explain') && $results->{samples}->{$item}->{arg} ) {
-      eval {
-         my $sparkline = $self->explain_sparkline(
-            $results->{samples}->{$item}->{arg}, $args{db});
-         push @result, "# EXPLAIN sparkline: $sparkline\n";
-      };
-      if ( $EVAL_ERROR ) {
-         PTDEBUG && _d("Failed to get EXPLAIN sparkline:", $EVAL_ERROR);
-      }
-   }
-
-   if ( my $attrib = $o->get('report-histogram') ) {
-      my $sparkline = $self->distro_sparkline(
-         %args,
-         attrib => $attrib,
-         item   => $item,
-      );
-      if ( $sparkline ) {
-         # I find the | | bookends help make the sparkchart graph more clear.
-         # Else with just   .^-   it's difficult to tell where the chart beings
-         # or ends.
-         push @result, "# $attrib sparkline: |$sparkline|";
-      }
-   }
-
-   # Last line before column headers: time range
-   if ( my $ts = $store->{ts} ) {
-      my $time_range = $self->format_time_range($ts) || "unknown";
-      push @result, "# Time range: $time_range";
-   }
-
-   # Column header line
-   push @result, $self->make_event_header();
-
-   # Count line
-   push @result,
-      sprintf $self->{num_format}, 'Count',
-         percentage_of($class_cnt, $global_cnt), $class_cnt, map { '' } (1..8);
+      $query_time->{stddev}**2 / ($query_time->{avg} || 1)
+   };
+
+   $vals{counts} = {
+      class_cnt        => $class_cnt,
+      global_cnt       => $global_cnt,
+   };
+
+   if ( my $ts = $store->{ts}) {
+      $vals{time_range} = $self->format_time_range($ts) || "unknown";
+   }
 
    # Sort the attributes, removing any hidden attributes, if they're not
    # already given to us.  In mk-query-digest, this sub is called from
@@ -607,11 +592,10 @@
       );
    }
 
+   $vals{attributes} = { map { $_ => [] } qw(num innodb bool string) };
+
    foreach my $type ( qw(num innodb) ) {
       # Add "InnoDB:" sub-header before grouped InnoDB_* attributes.
-      if ( $type eq 'innodb' && @{$attribs->{$type}} ) {
-         push @result, "# InnoDB:";
-      };
 
       NUM_ATTRIB:
       foreach my $attrib ( @{$attribs->{$type}} ) {
@@ -631,15 +615,12 @@
          $pct   = percentage_of(
             $vals->{sum}, $results->{globals}->{$attrib}->{sum});
 
-         push @result,
-            sprintf $self->{num_format},
-               $self->make_label($attrib), $pct, @values;
+         push @{$vals{attributes}{$type}},
+               [ $attrib, $pct, @values ];
       }
    }
 
    if ( @{$attribs->{bool}} ) {
-      push @result, "# Boolean:";
-      my $printed_bools = 0;
       BOOL_ATTRIB:
       foreach my $attrib ( @{$attribs->{bool}} ) {
          next BOOL_ATTRIB unless exists $store->{$attrib};
@@ -647,33 +628,125 @@
          next unless scalar %$vals;
 
          if ( $vals->{sum} > 0 ) {
-            push @result,
-               sprintf $self->{bool_format},
-                  $self->make_label($attrib), $self->bool_percents($vals);
-            $printed_bools = 1;
+            push @{$vals{attributes}{bool}},
+                  [ $attrib, $self->bool_percents($vals) ];
          }
       }
-      pop @result unless $printed_bools;
+   }
+
+   if ( @{$attribs->{string}} ) {