Merge lp:~percona-toolkit-dev/percona-toolkit/v-c-update into lp:percona-toolkit/2.1

[Daniel Nichter]

[lp:~percona-toolkit-dev/percona-toolkit/v-c-update]

369. By Daniel Nichter on 2012-08-27

Add code comments. Make Pingback.t tests more explicity. Don't '1 while unlink file'. Remove get_mysql_status() stub.

370. By Daniel Nichter on 2012-08-27

Simplify how Pingback handles MySQL instances. Remove Percona::Toolkit::slurp_file() because it was causing 'sub redefined' errors, probably due to PerconaTest::slurp_file(). Add more PTVCDEBUG statements.

371. By Brian Fraser on 2012-08-28

Update the rest of the modules to use the updated version_check

372. By Daniel Nichter on 2012-08-28

Fix version check instances in pt-config-diff and pt-table-sync.

373. By Daniel Nichter on 2012-08-28

Add back PerconaTest::slurp_file(). Put in scope in pt-index-usage. Sort MySQL instance IDs for testing. Wait for pid file in pt-heartbeat/basics.t.

[Daniel Nichter (daniel-nichter)]

review: Approve

=== modified file 'bin/pt-archiver'
--- bin/pt-archiver	2012-08-24 23:26:04 +0000
+++ bin/pt-archiver	2012-08-28 21:31:19 +0000
@@ -40,6 +40,7 @@
 {
 package Percona::Toolkit;
 our $VERSION = '2.1.3';
+
 1;
 }
 # ###########################################################################
@@ -3910,20 +3911,19 @@
       die "I need a $arg arugment" unless $args{$arg};
    }
    my ($items) = @args{@required_args};
-   my $dbh     = $args{dbh}; # optional
 
    my %versions;
    foreach my $item ( values %$items ) {
       next unless $self->valid_item($item);
-      
+
       eval {
          my $func    = 'get_' . $item->{type};
          my $version = $self->$func(
-            item => $item,
-            dbh  => $dbh,
+            item      => $item,
+            instances => $args{instances},
          );
          if ( $version ) {
-            chomp $version;
+            chomp $version unless ref($version);
             $versions{$item->{item}} = $version;
          }
       };
@@ -4048,28 +4048,42 @@
    );
 }
 
-
 sub _get_from_mysql {
    my ($self, %args) = @_;
-   my $show = $args{show};
-   my $item = $args{item};
-   my $dbh  = $args{dbh};
-   return unless $show && $item && $dbh;
+   my $show      = $args{show};
+   my $item      = $args{item};
+   my $instances = $args{instances};
+   return unless $show && $item;
 
-   local $dbh->{FetchHashKeyName} = 'NAME_lc';
-   my $sql = qq/SHOW $show/;
-   PTDEBUG && _d($sql);
-   my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+   if ( !$instances || !@$instances ) {
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Cannot check', $item, 'because there are no MySQL instances');
+      }
+      return;
+   }
 
    my @versions;
-   foreach my $var ( @{$item->{vars}} ) {
-      $var = lc($var);
-      my $version = $rows->{$var}->{value};
-      PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version);
-      push @versions, $version;
+   my %version_for;
+   foreach my $instance ( @$instances ) {
+      my $dbh = $instance->{dbh};
+      local $dbh->{FetchHashKeyName} = 'NAME_lc';
+      my $sql = qq/SHOW $show/;
+      PTDEBUG && _d($sql);
+      my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+
+      my @versions;
+      foreach my $var ( @{$item->{vars}} ) {
+         $var = lc($var);
+         my $version = $rows->{$var}->{value};
+         PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version,
+            'on', $instance->{name});
+         push @versions, $version;
+      }
+
+      $version_for{ $instance->{id} } = join(' ', @versions);
    }
 
-   return join(' ', @versions);
+   return \%version_for;
 }
 
 sub get_bin_version {
@@ -4567,14 +4581,15 @@
 
 use constant PTDEBUG => $ENV{PTDEBUG} || 0;
 
-use File::Basename qw();
 use Data::Dumper   qw();
+use Digest::MD5    qw(md5_hex);
+use Sys::Hostname  qw(hostname);
 use Fcntl          qw(:DEFAULT);
-
+use File::Basename qw();
 use File::Spec;
 
-my $dir = File::Spec->tmpdir();
-my $check_time_file = File::Spec->catfile($dir,'percona-toolkit-version-check');
+my $dir              = File::Spec->tmpdir();
+my $check_time_file  = File::Spec->catfile($dir,'percona-toolkit-version-check');
 my $check_time_limit = 60 * 60 * 24;  # one day
 
 sub Dumper {
@@ -4587,11 +4602,13 @@
 
 local $EVAL_ERROR;
 eval {
+   require Percona::Toolkit;
    require HTTPMicro;
    require VersionCheck;
 };
 
 sub version_check {
+   my @instances = @_;
    eval {
       if (exists $ENV{PERCONA_VERSION_CHECK} && !$ENV{PERCONA_VERSION_CHECK}) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
@@ -4601,19 +4618,26 @@
          return;
       } 
 
-      if ( !time_to_check($check_time_file) ) {
+      foreach my $instance ( @instances ) {
+         my ($name, $id) = _generate_identifier($instance);
+         $instance->{name} = $name;
+         $instance->{id}   = $id;
+      }
+
+      my ($time_to_check, $instances_to_check)
+         = time_to_check($check_time_file, \@instances);
+      if ( !$time_to_check ) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
-            _d('It is not time to --version-checka again;',
+            _d('It is not time to --version-check again;',
                'only 1 check per', $check_time_limit, 'seconds, and the last',
                'check was performed on the modified time of', $check_time_file);
          }
          return;
       }
 
-      my $dbh = shift;  # optional
       my $advice = pingback(
-         url => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
-         dbh => $dbh,
+         url       => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
+         instances => $instances_to_check,
       );
       if ( $advice ) {
          print "# Percona suggests these upgrades:\n";
@@ -4641,7 +4665,7 @@
    }
    my ($url) = @args{@required_args};
 
-   my ($dbh, $ua, $vc) = @args{qw(dbh ua VersionCheck)};
+   my ($instances, $ua, $vc) = @args{qw(instances ua VersionCheck)};
 
    $ua ||= HTTPMicro->new( timeout => 2 );
    $vc ||= VersionCheck->new();
@@ -4660,24 +4684,27 @@
    );
    die "Failed to parse server requested programs: $response->{content}"
       if !scalar keys %$items;
-
+      
    my $versions = $vc->get_versions(
-      items => $items,
-      dbh   => $dbh,
+      items     => $items,
+      instances => $instances,
    );
    die "Failed to get any program versions; should have at least gotten Perl"
       if !scalar keys %$versions;
 
    my $client_content = encode_client_response(
-      items    => $items,
-      versions => $versions,
+      items      => $items,
+      versions   => $versions,
+      general_id => md5_hex( hostname() ),
    );
 
    my $client_response = {
       headers => { "X-Percona-Toolkit-Tool" => File::Basename::basename($0) },
       content => $client_content,
    };
-   PTDEBUG && _d('Client response:', Dumper($client_response));
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Client response:', Dumper($client_response));
+   }
 
    $response = $ua->request('POST', $url, $client_response);
    PTDEBUG && _d('Server suggestions:', Dumper($response));
@@ -4702,22 +4729,35 @@
 }
 
 sub time_to_check {
-   my ($file) = @_;
+   my ($file, $instances) = @_;
    die "I need a file argument" unless $file;
 
+   my $created_file = 0;
    if ( !-f $file ) {
-      PTDEBUG && _d('Creating', $file);
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Creating time limit file', $file);
+      }
       _touch($file);
-      return 1;
-   }
+      $created_file = 1;
+   }
+   elsif ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Time limit file already exists:', $file);
+   }
+
+   my $time = int(time());  # current time
+
+   if ( @$instances ) {
+      my $instances_to_check = instances_to_check($file, $instances, $time);
+      return scalar @$instances_to_check, $instances_to_check;
+   }
+
+   return 1 if $created_file;
 
    my $mtime  = (stat $file)[9];
    if ( !defined $mtime ) {
       PTDEBUG && _d('Error getting modified time of', $file);
       return 0;
    }
-
-   my $time = int(time());
    PTDEBUG && _d('time=', $time, 'mtime=', $mtime);
    if ( ($time - $mtime) > $check_time_limit ) {
       _touch($file);
@@ -4727,6 +4767,36 @@
    return 0;
 }
 
+sub instances_to_check {
+   my ($file, $instances, $time) = @_;
+
+   open my $fh, '<', $file or die "Cannot open $file: $OS_ERROR";
+   my $file_contents = do { local $/ = undef; <$fh> };
+   close $fh;
+   chomp($file_contents);
+   my %cached_instances = $file_contents =~ /^([^,]+),(.+)$/mg;
+
+   my @instances_to_check;
+   foreach my $instance ( @$instances ) {
+      my $mtime = $cached_instances{ $instance->{id} };
+      if ( !$mtime || (($time - $mtime) > $check_time_limit) ) {
+         if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+            _d('Time to check MySQL instance', $instance->{name});
+         }
+         push @instances_to_check, $instance;
+         $cached_instances{ $instance->{id} } = $time;
+      }
+   }
+
+   open $fh, '>', $file or die "Cannot open $file for writing: $OS_ERROR";
+   while ( my ($id, $time) = each %cached_instances ) {
+      print { $fh } "$id,$time\n";
+   }
+   close $fh or die "Cannot close $file: $OS_ERROR";
+
+   return \@instances_to_check;
+}
+
 sub _touch {
    my ($file) = @_;
    sysopen my $fh, $file, O_WRONLY|O_CREAT|O_NONBLOCK
@@ -4735,22 +4805,48 @@
    utime(undef, undef, $file);
 }
 
+sub _generate_identifier {
+   my $instance = shift;
+   my $dbh      = $instance->{dbh};
+   my $dsn      = $instance->{dsn};
+
+   my $sql    = q{SELECT CONCAT(@@hostname, @@port)};
+   my ($name) = eval { $dbh->selectrow_array($sql) };
+   if ( $EVAL_ERROR ) { # assume that it's MySQL 4.x
+      $name = ($dsn->{h} || 'localhost') . ($dsn->{P} || 3306);
+   }
+   my $id = md5_hex($name);
+
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('MySQL instance', $name, 'is', $id);
+   }
+
+   return $name, $id;
+}
+
 sub encode_client_response {
    my (%args) = @_;
-   my @required_args = qw(items versions);
+   my @required_args = qw(items versions general_id);
    foreach my $arg ( @required_args ) {
       die "I need a $arg arugment" unless $args{$arg};
    }
-   my ($items, $versions) = @args{@required_args};
+   my ($items, $versions, $general_id) = @args{@required_args};
 
    my @lines;
    foreach my $item ( sort keys %$items ) {
       next unless exists $versions->{$item};
-      push @lines, join(';', $item, $versions->{$item});
+      if ( ref($versions->{$item}) eq 'HASH' ) {
+         my $mysql_versions = $versions->{$item};
+         for my $id ( keys %$mysql_versions ) {
+            push @lines, join(';', $id, $item, $mysql_versions->{$id});
+         }
+      }
+      else {
+         push @lines, join(';', $general_id, $item, $versions->{$item});
+      }
    }
 
    my $client_response = join("\n", @lines) . "\n";
-   PTDEBUG && _d('Client response:', $client_response);
    return $client_response;
 }
 
@@ -5296,7 +5392,10 @@
    # Do the version-check
    # ########################################################################
    if ( $o->get('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
-      Pingback::version_check($src->{dbh});
+      Pingback::version_check(
+         { dbh => $src->{dbh}, dsn => $src->{dsn} },
+         ( $dst ? { dbh => $dst->{dbh}, dsn => $dst->{dsn} } : () ),
+      );
    }
 
    # ########################################################################

=== modified file 'bin/pt-config-diff'
--- bin/pt-config-diff	2012-08-23 16:22:43 +0000
+++ bin/pt-config-diff	2012-08-28 21:31:19 +0000
@@ -39,6 +39,7 @@
 {
 package Percona::Toolkit;
 our $VERSION = '2.1.3';
+
 1;
 }
 # ###########################################################################
@@ -3011,20 +3012,19 @@
       die "I need a $arg arugment" unless $args{$arg};
    }
    my ($items) = @args{@required_args};
-   my $dbh     = $args{dbh}; # optional
 
    my %versions;
    foreach my $item ( values %$items ) {
       next unless $self->valid_item($item);
-      
+
       eval {
          my $func    = 'get_' . $item->{type};
          my $version = $self->$func(
-            item => $item,
-            dbh  => $dbh,
+            item      => $item,
+            instances => $args{instances},
          );
          if ( $version ) {
-            chomp $version;
+            chomp $version unless ref($version);
             $versions{$item->{item}} = $version;
          }
       };
@@ -3149,28 +3149,42 @@
    );
 }
 
-
 sub _get_from_mysql {
    my ($self, %args) = @_;
-   my $show = $args{show};
-   my $item = $args{item};
-   my $dbh  = $args{dbh};
-   return unless $show && $item && $dbh;
+   my $show      = $args{show};
+   my $item      = $args{item};
+   my $instances = $args{instances};
+   return unless $show && $item;
 
-   local $dbh->{FetchHashKeyName} = 'NAME_lc';
-   my $sql = qq/SHOW $show/;
-   PTDEBUG && _d($sql);
-   my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+   if ( !$instances || !@$instances ) {
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Cannot check', $item, 'because there are no MySQL instances');
+      }
+      return;
+   }
 
    my @versions;
-   foreach my $var ( @{$item->{vars}} ) {
-      $var = lc($var);
-      my $version = $rows->{$var}->{value};
-      PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version);
-      push @versions, $version;
+   my %version_for;
+   foreach my $instance ( @$instances ) {
+      my $dbh = $instance->{dbh};
+      local $dbh->{FetchHashKeyName} = 'NAME_lc';
+      my $sql = qq/SHOW $show/;
+      PTDEBUG && _d($sql);
+      my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+
+      my @versions;
+      foreach my $var ( @{$item->{vars}} ) {
+         $var = lc($var);
+         my $version = $rows->{$var}->{value};
+         PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version,
+            'on', $instance->{name});
+         push @versions, $version;
+      }
+
+      $version_for{ $instance->{id} } = join(' ', @versions);
    }
 
-   return join(' ', @versions);
+   return \%version_for;
 }
 
 sub get_bin_version {
@@ -3668,14 +3682,15 @@
 
 use constant PTDEBUG => $ENV{PTDEBUG} || 0;
 
-use File::Basename qw();
 use Data::Dumper   qw();
+use Digest::MD5    qw(md5_hex);
+use Sys::Hostname  qw(hostname);
 use Fcntl          qw(:DEFAULT);
-
+use File::Basename qw();
 use File::Spec;
 
-my $dir = File::Spec->tmpdir();
-my $check_time_file = File::Spec->catfile($dir,'percona-toolkit-version-check');
+my $dir              = File::Spec->tmpdir();
+my $check_time_file  = File::Spec->catfile($dir,'percona-toolkit-version-check');
 my $check_time_limit = 60 * 60 * 24;  # one day
 
 sub Dumper {
@@ -3688,11 +3703,13 @@
 
 local $EVAL_ERROR;
 eval {
+   require Percona::Toolkit;
    require HTTPMicro;
    require VersionCheck;
 };
 
 sub version_check {
+   my @instances = @_;
    eval {
       if (exists $ENV{PERCONA_VERSION_CHECK} && !$ENV{PERCONA_VERSION_CHECK}) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
@@ -3702,19 +3719,26 @@
          return;
       } 
 
-      if ( !time_to_check($check_time_file) ) {
+      foreach my $instance ( @instances ) {
+         my ($name, $id) = _generate_identifier($instance);
+         $instance->{name} = $name;
+         $instance->{id}   = $id;
+      }
+
+      my ($time_to_check, $instances_to_check)
+         = time_to_check($check_time_file, \@instances);
+      if ( !$time_to_check ) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
-            _d('It is not time to --version-checka again;',
+            _d('It is not time to --version-check again;',
                'only 1 check per', $check_time_limit, 'seconds, and the last',
                'check was performed on the modified time of', $check_time_file);
          }
          return;
       }
 
-      my $dbh = shift;  # optional
       my $advice = pingback(
-         url => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
-         dbh => $dbh,
+         url       => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
+         instances => $instances_to_check,
       );
       if ( $advice ) {
          print "# Percona suggests these upgrades:\n";
@@ -3742,7 +3766,7 @@
    }
    my ($url) = @args{@required_args};
 
-   my ($dbh, $ua, $vc) = @args{qw(dbh ua VersionCheck)};
+   my ($instances, $ua, $vc) = @args{qw(instances ua VersionCheck)};
 
    $ua ||= HTTPMicro->new( timeout => 2 );
    $vc ||= VersionCheck->new();
@@ -3761,24 +3785,27 @@
    );
    die "Failed to parse server requested programs: $response->{content}"
       if !scalar keys %$items;
-
+      
    my $versions = $vc->get_versions(
-      items => $items,
-      dbh   => $dbh,
+      items     => $items,
+      instances => $instances,
    );
    die "Failed to get any program versions; should have at least gotten Perl"
       if !scalar keys %$versions;
 
    my $client_content = encode_client_response(
-      items    => $items,
-      versions => $versions,
+      items      => $items,
+      versions   => $versions,
+      general_id => md5_hex( hostname() ),
    );
 
    my $client_response = {
       headers => { "X-Percona-Toolkit-Tool" => File::Basename::basename($0) },
       content => $client_content,
    };
-   PTDEBUG && _d('Client response:', Dumper($client_response));
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Client response:', Dumper($client_response));
+   }
 
    $response = $ua->request('POST', $url, $client_response);
    PTDEBUG && _d('Server suggestions:', Dumper($response));
@@ -3803,22 +3830,35 @@
 }
 
 sub time_to_check {
-   my ($file) = @_;
+   my ($file, $instances) = @_;
    die "I need a file argument" unless $file;
 
+   my $created_file = 0;
    if ( !-f $file ) {
-      PTDEBUG && _d('Creating', $file);
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Creating time limit file', $file);
+      }
       _touch($file);
-      return 1;
-   }
+      $created_file = 1;
+   }
+   elsif ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Time limit file already exists:', $file);
+   }
+
+   my $time = int(time());  # current time
+
+   if ( @$instances ) {
+      my $instances_to_check = instances_to_check($file, $instances, $time);
+      return scalar @$instances_to_check, $instances_to_check;
+   }
+
+   return 1 if $created_file;
 
    my $mtime  = (stat $file)[9];
    if ( !defined $mtime ) {
       PTDEBUG && _d('Error getting modified time of', $file);
       return 0;
    }
-
-   my $time = int(time());
    PTDEBUG && _d('time=', $time, 'mtime=', $mtime);
    if ( ($time - $mtime) > $check_time_limit ) {
       _touch($file);
@@ -3828,6 +3868,36 @@
    return 0;
 }
 
+sub instances_to_check {
+   my ($file, $instances, $time) = @_;
+
+   open my $fh, '<', $file or die "Cannot open $file: $OS_ERROR";
+   my $file_contents = do { local $/ = undef; <$fh> };
+   close $fh;
+   chomp($file_contents);
+   my %cached_instances = $file_contents =~ /^([^,]+),(.+)$/mg;
+
+   my @instances_to_check;
+   foreach my $instance ( @$instances ) {
+      my $mtime = $cached_instances{ $instance->{id} };
+      if ( !$mtime || (($time - $mtime) > $check_time_limit) ) {
+         if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+            _d('Time to check MySQL instance', $instance->{name});
+         }
+         push @instances_to_check, $instance;
+         $cached_instances{ $instance->{id} } = $time;
+      }
+   }
+
+   open $fh, '>', $file or die "Cannot open $file for writing: $OS_ERROR";
+   while ( my ($id, $time) = each %cached_instances ) {
+      print { $fh } "$id,$time\n";
+   }
+   close $fh or die "Cannot close $file: $OS_ERROR";
+
+   return \@instances_to_check;
+}
+
 sub _touch {
    my ($file) = @_;
    sysopen my $fh, $file, O_WRONLY|O_CREAT|O_NONBLOCK
@@ -3836,22 +3906,48 @@
    utime(undef, undef, $file);
 }
 
+sub _generate_identifier {
+   my $instance = shift;
+   my $dbh      = $instance->{dbh};
+   my $dsn      = $instance->{dsn};
+
+   my $sql    = q{SELECT CONCAT(@@hostname, @@port)};
+   my ($name) = eval { $dbh->selectrow_array($sql) };
+   if ( $EVAL_ERROR ) { # assume that it's MySQL 4.x
+      $name = ($dsn->{h} || 'localhost') . ($dsn->{P} || 3306);
+   }
+   my $id = md5_hex($name);
+
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('MySQL instance', $name, 'is', $id);
+   }
+
+   return $name, $id;
+}
+
 sub encode_client_response {
    my (%args) = @_;
-   my @required_args = qw(items versions);
+   my @required_args = qw(items versions general_id);
    foreach my $arg ( @required_args ) {
       die "I need a $arg arugment" unless $args{$arg};
    }
-   my ($items, $versions) = @args{@required_args};
+   my ($items, $versions, $general_id) = @args{@required_args};
 
    my @lines;
    foreach my $item ( sort keys %$items ) {
       next unless exists $versions->{$item};
-      push @lines, join(';', $item, $versions->{$item});
+      if ( ref($versions->{$item}) eq 'HASH' ) {
+         my $mysql_versions = $versions->{$item};
+         for my $id ( keys %$mysql_versions ) {
+            push @lines, join(';', $id, $item, $mysql_versions->{$id});
+         }
+      }
+      else {
+         push @lines, join(';', $general_id, $item, $versions->{$item});
+      }
    }
 
    my $client_response = join("\n", @lines) . "\n";
-   PTDEBUG && _d('Client response:', $client_response);
    return $client_response;
 }
 
@@ -3932,6 +4028,7 @@
    my $last_dsn;
    my @configs;       # MySQLConfig objects
    my @config_names;  # Human-readable names for those ^ objs
+   my @cxn;
    foreach my $config_src ( @ARGV ) {
       if ( -f $config_src ) {
          PTDEBUG && _d('Config source', $config_src, 'is a file');
@@ -3954,9 +4051,11 @@
 
          push @configs, new MySQLConfig(
             dbh => $cxn->dbh(),
+            dsn => $cxn->dsn(),
             %common_modules,
          );
          push @config_names, $cxn->name();
+         push @cxn, $cxn;
       }
    }
 
@@ -3979,7 +4078,9 @@
    # Do the version-check
    # ########################################################################
    if ( $o->get('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
-      Pingback::version_check($configs[0]->{dbh});
+      Pingback::version_check(
+         map  { +{ dbh => $_->dbh, dsn => $_->dsn } } @cxn
+      );
    }
 
    # #########################################################################

=== modified file 'bin/pt-deadlock-logger'
--- bin/pt-deadlock-logger	2012-08-24 23:26:04 +0000
+++ bin/pt-deadlock-logger	2012-08-28 21:31:19 +0000
@@ -37,6 +37,7 @@
 {
 package Percona::Toolkit;
 our $VERSION = '2.1.3';
+
 1;
 }
 # ###########################################################################
@@ -2469,20 +2470,19 @@
       die "I need a $arg arugment" unless $args{$arg};
    }
    my ($items) = @args{@required_args};
-   my $dbh     = $args{dbh}; # optional
 
    my %versions;
    foreach my $item ( values %$items ) {
       next unless $self->valid_item($item);
-      
+
       eval {
          my $func    = 'get_' . $item->{type};
          my $version = $self->$func(
-            item => $item,
-            dbh  => $dbh,
+            item      => $item,
+            instances => $args{instances},
          );
          if ( $version ) {
-            chomp $version;
+            chomp $version unless ref($version);
             $versions{$item->{item}} = $version;
          }
       };
@@ -2607,28 +2607,42 @@
    );
 }
 
-
 sub _get_from_mysql {
    my ($self, %args) = @_;
-   my $show = $args{show};
-   my $item = $args{item};
-   my $dbh  = $args{dbh};
-   return unless $show && $item && $dbh;
+   my $show      = $args{show};
+   my $item      = $args{item};
+   my $instances = $args{instances};
+   return unless $show && $item;
 
-   local $dbh->{FetchHashKeyName} = 'NAME_lc';
-   my $sql = qq/SHOW $show/;
-   PTDEBUG && _d($sql);
-   my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+   if ( !$instances || !@$instances ) {
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Cannot check', $item, 'because there are no MySQL instances');
+      }
+      return;
+   }
 
    my @versions;
-   foreach my $var ( @{$item->{vars}} ) {
-      $var = lc($var);
-      my $version = $rows->{$var}->{value};
-      PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version);
-      push @versions, $version;
+   my %version_for;
+   foreach my $instance ( @$instances ) {
+      my $dbh = $instance->{dbh};
+      local $dbh->{FetchHashKeyName} = 'NAME_lc';
+      my $sql = qq/SHOW $show/;
+      PTDEBUG && _d($sql);
+      my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+
+      my @versions;
+      foreach my $var ( @{$item->{vars}} ) {
+         $var = lc($var);
+         my $version = $rows->{$var}->{value};
+         PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version,
+            'on', $instance->{name});
+         push @versions, $version;
+      }
+
+      $version_for{ $instance->{id} } = join(' ', @versions);
    }
 
-   return join(' ', @versions);
+   return \%version_for;
 }
 
 sub get_bin_version {
@@ -3126,14 +3140,15 @@
 
 use constant PTDEBUG => $ENV{PTDEBUG} || 0;
 
-use File::Basename qw();
 use Data::Dumper   qw();
+use Digest::MD5    qw(md5_hex);
+use Sys::Hostname  qw(hostname);
 use Fcntl          qw(:DEFAULT);
-
+use File::Basename qw();
 use File::Spec;
 
-my $dir = File::Spec->tmpdir();
-my $check_time_file = File::Spec->catfile($dir,'percona-toolkit-version-check');
+my $dir              = File::Spec->tmpdir();
+my $check_time_file  = File::Spec->catfile($dir,'percona-toolkit-version-check');
 my $check_time_limit = 60 * 60 * 24;  # one day
 
 sub Dumper {
@@ -3146,11 +3161,13 @@
 
 local $EVAL_ERROR;
 eval {
+   require Percona::Toolkit;
    require HTTPMicro;
    require VersionCheck;
 };
 
 sub version_check {
+   my @instances = @_;
    eval {
       if (exists $ENV{PERCONA_VERSION_CHECK} && !$ENV{PERCONA_VERSION_CHECK}) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
@@ -3160,19 +3177,26 @@
          return;
       } 
 
-      if ( !time_to_check($check_time_file) ) {
+      foreach my $instance ( @instances ) {
+         my ($name, $id) = _generate_identifier($instance);
+         $instance->{name} = $name;
+         $instance->{id}   = $id;
+      }
+
+      my ($time_to_check, $instances_to_check)
+         = time_to_check($check_time_file, \@instances);
+      if ( !$time_to_check ) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
-            _d('It is not time to --version-checka again;',
+            _d('It is not time to --version-check again;',
                'only 1 check per', $check_time_limit, 'seconds, and the last',
                'check was performed on the modified time of', $check_time_file);
          }
          return;
       }
 
-      my $dbh = shift;  # optional
       my $advice = pingback(
-         url => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
-         dbh => $dbh,
+         url       => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
+         instances => $instances_to_check,
       );
       if ( $advice ) {
          print "# Percona suggests these upgrades:\n";
@@ -3200,7 +3224,7 @@
    }
    my ($url) = @args{@required_args};
 
-   my ($dbh, $ua, $vc) = @args{qw(dbh ua VersionCheck)};
+   my ($instances, $ua, $vc) = @args{qw(instances ua VersionCheck)};
 
    $ua ||= HTTPMicro->new( timeout => 2 );
    $vc ||= VersionCheck->new();
@@ -3219,24 +3243,27 @@
    );
    die "Failed to parse server requested programs: $response->{content}"
       if !scalar keys %$items;
-
+      
    my $versions = $vc->get_versions(
-      items => $items,
-      dbh   => $dbh,
+      items     => $items,
+      instances => $instances,
    );
    die "Failed to get any program versions; should have at least gotten Perl"
       if !scalar keys %$versions;
 
    my $client_content = encode_client_response(
-      items    => $items,
-      versions => $versions,
+      items      => $items,
+      versions   => $versions,
+      general_id => md5_hex( hostname() ),
    );
 
    my $client_response = {
       headers => { "X-Percona-Toolkit-Tool" => File::Basename::basename($0) },
       content => $client_content,
    };
-   PTDEBUG && _d('Client response:', Dumper($client_response));
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Client response:', Dumper($client_response));
+   }
 
    $response = $ua->request('POST', $url, $client_response);
    PTDEBUG && _d('Server suggestions:', Dumper($response));
@@ -3261,22 +3288,35 @@
 }
 
 sub time_to_check {
-   my ($file) = @_;
+   my ($file, $instances) = @_;
    die "I need a file argument" unless $file;
 
+   my $created_file = 0;
    if ( !-f $file ) {
-      PTDEBUG && _d('Creating', $file);
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Creating time limit file', $file);
+      }
       _touch($file);
-      return 1;
-   }
+      $created_file = 1;
+   }
+   elsif ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Time limit file already exists:', $file);
+   }
+
+   my $time = int(time());  # current time
+
+   if ( @$instances ) {
+      my $instances_to_check = instances_to_check($file, $instances, $time);
+      return scalar @$instances_to_check, $instances_to_check;
+   }
+
+   return 1 if $created_file;
 
    my $mtime  = (stat $file)[9];
    if ( !defined $mtime ) {
       PTDEBUG && _d('Error getting modified time of', $file);
       return 0;
    }
-
-   my $time = int(time());
    PTDEBUG && _d('time=', $time, 'mtime=', $mtime);
    if ( ($time - $mtime) > $check_time_limit ) {
       _touch($file);
@@ -3286,6 +3326,36 @@
    return 0;
 }
 
+sub instances_to_check {
+   my ($file, $instances, $time) = @_;
+
+   open my $fh, '<', $file or die "Cannot open $file: $OS_ERROR";
+   my $file_contents = do { local $/ = undef; <$fh> };
+   close $fh;
+   chomp($file_contents);
+   my %cached_instances = $file_contents =~ /^([^,]+),(.+)$/mg;
+
+   my @instances_to_check;
+   foreach my $instance ( @$instances ) {
+      my $mtime = $cached_instances{ $instance->{id} };
+      if ( !$mtime || (($time - $mtime) > $check_time_limit) ) {
+         if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+            _d('Time to check MySQL instance', $instance->{name});
+         }
+         push @instances_to_check, $instance;
+         $cached_instances{ $instance->{id} } = $time;
+      }
+   }
+
+   open $fh, '>', $file or die "Cannot open $file for writing: $OS_ERROR";
+   while ( my ($id, $time) = each %cached_instances ) {
+      print { $fh } "$id,$time\n";
+   }
+   close $fh or die "Cannot close $file: $OS_ERROR";
+
+   return \@instances_to_check;
+}
+
 sub _touch {
    my ($file) = @_;
    sysopen my $fh, $file, O_WRONLY|O_CREAT|O_NONBLOCK
@@ -3294,22 +3364,48 @@
    utime(undef, undef, $file);
 }
 
+sub _generate_identifier {
+   my $instance = shift;
+   my $dbh      = $instance->{dbh};
+   my $dsn      = $instance->{dsn};
+
+   my $sql    = q{SELECT CONCAT(@@hostname, @@port)};
+   my ($name) = eval { $dbh->selectrow_array($sql) };
+   if ( $EVAL_ERROR ) { # assume that it's MySQL 4.x
+      $name = ($dsn->{h} || 'localhost') . ($dsn->{P} || 3306);
+   }
+   my $id = md5_hex($name);
+
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('MySQL instance', $name, 'is', $id);
+   }
+
+   return $name, $id;
+}
+
 sub encode_client_response {
    my (%args) = @_;
-   my @required_args = qw(items versions);
+   my @required_args = qw(items versions general_id);
    foreach my $arg ( @required_args ) {
       die "I need a $arg arugment" unless $args{$arg};
    }
-   my ($items, $versions) = @args{@required_args};
+   my ($items, $versions, $general_id) = @args{@required_args};
 
    my @lines;
    foreach my $item ( sort keys %$items ) {
       next unless exists $versions->{$item};
-      push @lines, join(';', $item, $versions->{$item});
+      if ( ref($versions->{$item}) eq 'HASH' ) {
+         my $mysql_versions = $versions->{$item};
+         for my $id ( keys %$mysql_versions ) {
+            push @lines, join(';', $id, $item, $mysql_versions->{$id});
+         }
+      }
+      else {
+         push @lines, join(';', $general_id, $item, $versions->{$item});
+      }
    }
 
    my $client_response = join("\n", @lines) . "\n";
-   PTDEBUG && _d('Client response:', $client_response);
    return $client_response;
 }
 
@@ -3505,7 +3601,10 @@
    # Do the version-check
    # ########################################################################
    if ( $o->get('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
-      Pingback::version_check($dbh);
+      Pingback::version_check(
+         { dbh => $dbh, dsn => $source_dsn },
+         ($dest_dsn ? { dbh => $dest_dsn, dsn => $dest_dsn } : ()),
+      );
    }
 
    # ########################################################################

=== modified file 'bin/pt-diskstats'
--- bin/pt-diskstats	2012-08-24 22:57:01 +0000
+++ bin/pt-diskstats	2012-08-28 21:31:19 +0000
@@ -39,6 +39,7 @@
 {
 package Percona::Toolkit;
 our $VERSION = '2.1.3';
+
 1;
 }
 # ###########################################################################
@@ -3580,20 +3581,19 @@
       die "I need a $arg arugment" unless $args{$arg};
    }
    my ($items) = @args{@required_args};
-   my $dbh     = $args{dbh}; # optional
 
    my %versions;
    foreach my $item ( values %$items ) {
       next unless $self->valid_item($item);
-      
+
       eval {
          my $func    = 'get_' . $item->{type};
          my $version = $self->$func(
-            item => $item,
-            dbh  => $dbh,
+            item      => $item,
+            instances => $args{instances},
          );
          if ( $version ) {
-            chomp $version;
+            chomp $version unless ref($version);
             $versions{$item->{item}} = $version;
          }
       };
@@ -3718,28 +3718,42 @@
    );
 }
 
-
 sub _get_from_mysql {
    my ($self, %args) = @_;
-   my $show = $args{show};
-   my $item = $args{item};
-   my $dbh  = $args{dbh};
-   return unless $show && $item && $dbh;
+   my $show      = $args{show};
+   my $item      = $args{item};
+   my $instances = $args{instances};
+   return unless $show && $item;
 
-   local $dbh->{FetchHashKeyName} = 'NAME_lc';
-   my $sql = qq/SHOW $show/;
-   PTDEBUG && _d($sql);
-   my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+   if ( !$instances || !@$instances ) {
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Cannot check', $item, 'because there are no MySQL instances');
+      }
+      return;
+   }
 
    my @versions;
-   foreach my $var ( @{$item->{vars}} ) {
-      $var = lc($var);
-      my $version = $rows->{$var}->{value};
-      PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version);
-      push @versions, $version;
+   my %version_for;
+   foreach my $instance ( @$instances ) {
+      my $dbh = $instance->{dbh};
+      local $dbh->{FetchHashKeyName} = 'NAME_lc';
+      my $sql = qq/SHOW $show/;
+      PTDEBUG && _d($sql);
+      my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+
+      my @versions;
+      foreach my $var ( @{$item->{vars}} ) {
+         $var = lc($var);
+         my $version = $rows->{$var}->{value};
+         PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version,
+            'on', $instance->{name});
+         push @versions, $version;
+      }
+
+      $version_for{ $instance->{id} } = join(' ', @versions);
    }
 
-   return join(' ', @versions);
+   return \%version_for;
 }
 
 sub get_bin_version {
@@ -4237,14 +4251,15 @@
 
 use constant PTDEBUG => $ENV{PTDEBUG} || 0;
 
-use File::Basename qw();
 use Data::Dumper   qw();
+use Digest::MD5    qw(md5_hex);
+use Sys::Hostname  qw(hostname);
 use Fcntl          qw(:DEFAULT);
-
+use File::Basename qw();
 use File::Spec;
 
-my $dir = File::Spec->tmpdir();
-my $check_time_file = File::Spec->catfile($dir,'percona-toolkit-version-check');
+my $dir              = File::Spec->tmpdir();
+my $check_time_file  = File::Spec->catfile($dir,'percona-toolkit-version-check');
 my $check_time_limit = 60 * 60 * 24;  # one day
 
 sub Dumper {
@@ -4257,11 +4272,13 @@
 
 local $EVAL_ERROR;
 eval {
+   require Percona::Toolkit;
    require HTTPMicro;
    require VersionCheck;
 };
 
 sub version_check {
+   my @instances = @_;
    eval {
       if (exists $ENV{PERCONA_VERSION_CHECK} && !$ENV{PERCONA_VERSION_CHECK}) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
@@ -4271,19 +4288,26 @@
          return;
       } 
 
-      if ( !time_to_check($check_time_file) ) {
+      foreach my $instance ( @instances ) {
+         my ($name, $id) = _generate_identifier($instance);
+         $instance->{name} = $name;
+         $instance->{id}   = $id;
+      }
+
+      my ($time_to_check, $instances_to_check)
+         = time_to_check($check_time_file, \@instances);
+      if ( !$time_to_check ) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
-            _d('It is not time to --version-checka again;',
+            _d('It is not time to --version-check again;',
                'only 1 check per', $check_time_limit, 'seconds, and the last',
                'check was performed on the modified time of', $check_time_file);
          }
          return;
       }
 
-      my $dbh = shift;  # optional
       my $advice = pingback(
-         url => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
-         dbh => $dbh,
+         url       => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
+         instances => $instances_to_check,
       );
       if ( $advice ) {
          print "# Percona suggests these upgrades:\n";
@@ -4311,7 +4335,7 @@
    }
    my ($url) = @args{@required_args};
 
-   my ($dbh, $ua, $vc) = @args{qw(dbh ua VersionCheck)};
+   my ($instances, $ua, $vc) = @args{qw(instances ua VersionCheck)};
 
    $ua ||= HTTPMicro->new( timeout => 2 );
    $vc ||= VersionCheck->new();
@@ -4330,24 +4354,27 @@
    );
    die "Failed to parse server requested programs: $response->{content}"
       if !scalar keys %$items;
-
+      
    my $versions = $vc->get_versions(
-      items => $items,
-      dbh   => $dbh,
+      items     => $items,
+      instances => $instances,
    );
    die "Failed to get any program versions; should have at least gotten Perl"
       if !scalar keys %$versions;
 
    my $client_content = encode_client_response(
-      items    => $items,
-      versions => $versions,
+      items      => $items,
+      versions   => $versions,
+      general_id => md5_hex( hostname() ),
    );
 
    my $client_response = {
       headers => { "X-Percona-Toolkit-Tool" => File::Basename::basename($0) },
       content => $client_content,
    };
-   PTDEBUG && _d('Client response:', Dumper($client_response));
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Client response:', Dumper($client_response));
+   }
 
    $response = $ua->request('POST', $url, $client_response);
    PTDEBUG && _d('Server suggestions:', Dumper($response));
@@ -4372,22 +4399,35 @@
 }
 
 sub time_to_check {
-   my ($file) = @_;
+   my ($file, $instances) = @_;
    die "I need a file argument" unless $file;
 
+   my $created_file = 0;
    if ( !-f $file ) {
-      PTDEBUG && _d('Creating', $file);
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Creating time limit file', $file);
+      }
       _touch($file);
-      return 1;
-   }
+      $created_file = 1;
+   }
+   elsif ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Time limit file already exists:', $file);
+   }
+
+   my $time = int(time());  # current time
+
+   if ( @$instances ) {
+      my $instances_to_check = instances_to_check($file, $instances, $time);
+      return scalar @$instances_to_check, $instances_to_check;
+   }
+
+   return 1 if $created_file;
 
    my $mtime  = (stat $file)[9];
    if ( !defined $mtime ) {
       PTDEBUG && _d('Error getting modified time of', $file);
       return 0;
    }
-
-   my $time = int(time());
    PTDEBUG && _d('time=', $time, 'mtime=', $mtime);
    if ( ($time - $mtime) > $check_time_limit ) {
       _touch($file);
@@ -4397,6 +4437,36 @@
    return 0;
 }
 
+sub instances_to_check {
+   my ($file, $instances, $time) = @_;
+
+   open my $fh, '<', $file or die "Cannot open $file: $OS_ERROR";
+   my $file_contents = do { local $/ = undef; <$fh> };
+   close $fh;
+   chomp($file_contents);
+   my %cached_instances = $file_contents =~ /^([^,]+),(.+)$/mg;
+
+   my @instances_to_check;
+   foreach my $instance ( @$instances ) {
+      my $mtime = $cached_instances{ $instance->{id} };
+      if ( !$mtime || (($time - $mtime) > $check_time_limit) ) {
+         if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+            _d('Time to check MySQL instance', $instance->{name});
+         }
+         push @instances_to_check, $instance;
+         $cached_instances{ $instance->{id} } = $time;
+      }
+   }
+
+   open $fh, '>', $file or die "Cannot open $file for writing: $OS_ERROR";
+   while ( my ($id, $time) = each %cached_instances ) {
+      print { $fh } "$id,$time\n";
+   }
+   close $fh or die "Cannot close $file: $OS_ERROR";
+
+   return \@instances_to_check;
+}
+
 sub _touch {
    my ($file) = @_;
    sysopen my $fh, $file, O_WRONLY|O_CREAT|O_NONBLOCK
@@ -4405,22 +4475,48 @@
    utime(undef, undef, $file);
 }
 
+sub _generate_identifier {
+   my $instance = shift;
+   my $dbh      = $instance->{dbh};
+   my $dsn      = $instance->{dsn};
+
+   my $sql    = q{SELECT CONCAT(@@hostname, @@port)};
+   my ($name) = eval { $dbh->selectrow_array($sql) };
+   if ( $EVAL_ERROR ) { # assume that it's MySQL 4.x
+      $name = ($dsn->{h} || 'localhost') . ($dsn->{P} || 3306);
+   }
+   my $id = md5_hex($name);
+
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('MySQL instance', $name, 'is', $id);
+   }
+
+   return $name, $id;
+}
+
 sub encode_client_response {
    my (%args) = @_;
-   my @required_args = qw(items versions);
+   my @required_args = qw(items versions general_id);
    foreach my $arg ( @required_args ) {
       die "I need a $arg arugment" unless $args{$arg};
    }
-   my ($items, $versions) = @args{@required_args};
+   my ($items, $versions, $general_id) = @args{@required_args};
 
    my @lines;
    foreach my $item ( sort keys %$items ) {
       next unless exists $versions->{$item};
-      push @lines, join(';', $item, $versions->{$item});
+      if ( ref($versions->{$item}) eq 'HASH' ) {
+         my $mysql_versions = $versions->{$item};
+         for my $id ( keys %$mysql_versions ) {
+            push @lines, join(';', $id, $item, $mysql_versions->{$id});
+         }
+      }
+      else {
+         push @lines, join(';', $general_id, $item, $versions->{$item});
+      }
    }
 
    my $client_response = join("\n", @lines) . "\n";
-   PTDEBUG && _d('Client response:', $client_response);
    return $client_response;
 }
 

=== modified file 'bin/pt-duplicate-key-checker'
--- bin/pt-duplicate-key-checker	2012-08-24 23:26:04 +0000
+++ bin/pt-duplicate-key-checker	2012-08-28 21:31:19 +0000
@@ -40,6 +40,7 @@
 {
 package Percona::Toolkit;
 our $VERSION = '2.1.3';
+
 1;
 }
 # ###########################################################################
@@ -3426,20 +3427,19 @@
       die "I need a $arg arugment" unless $args{$arg};
    }
    my ($items) = @args{@required_args};
-   my $dbh     = $args{dbh}; # optional
 
    my %versions;
    foreach my $item ( values %$items ) {
       next unless $self->valid_item($item);
-      
+
       eval {
          my $func    = 'get_' . $item->{type};
          my $version = $self->$func(
-            item => $item,
-            dbh  => $dbh,
+            item      => $item,
+            instances => $args{instances},
          );
          if ( $version ) {
-            chomp $version;
+            chomp $version unless ref($version);
             $versions{$item->{item}} = $version;
          }
       };
@@ -3564,28 +3564,42 @@
    );
 }
 
-
 sub _get_from_mysql {
    my ($self, %args) = @_;
-   my $show = $args{show};
-   my $item = $args{item};
-   my $dbh  = $args{dbh};
-   return unless $show && $item && $dbh;
+   my $show      = $args{show};
+   my $item      = $args{item};
+   my $instances = $args{instances};
+   return unless $show && $item;
 
-   local $dbh->{FetchHashKeyName} = 'NAME_lc';
-   my $sql = qq/SHOW $show/;
-   PTDEBUG && _d($sql);
-   my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+   if ( !$instances || !@$instances ) {
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Cannot check', $item, 'because there are no MySQL instances');
+      }
+      return;
+   }
 
    my @versions;
-   foreach my $var ( @{$item->{vars}} ) {
-      $var = lc($var);
-      my $version = $rows->{$var}->{value};
-      PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version);
-      push @versions, $version;
+   my %version_for;
+   foreach my $instance ( @$instances ) {
+      my $dbh = $instance->{dbh};
+      local $dbh->{FetchHashKeyName} = 'NAME_lc';
+      my $sql = qq/SHOW $show/;
+      PTDEBUG && _d($sql);
+      my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+
+      my @versions;
+      foreach my $var ( @{$item->{vars}} ) {
+         $var = lc($var);
+         my $version = $rows->{$var}->{value};
+         PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version,
+            'on', $instance->{name});
+         push @versions, $version;
+      }
+
+      $version_for{ $instance->{id} } = join(' ', @versions);
    }
 
-   return join(' ', @versions);
+   return \%version_for;
 }
 
 sub get_bin_version {
@@ -4083,14 +4097,15 @@
 
 use constant PTDEBUG => $ENV{PTDEBUG} || 0;
 
-use File::Basename qw();
 use Data::Dumper   qw();
+use Digest::MD5    qw(md5_hex);
+use Sys::Hostname  qw(hostname);
 use Fcntl          qw(:DEFAULT);
-
+use File::Basename qw();
 use File::Spec;
 
-my $dir = File::Spec->tmpdir();
-my $check_time_file = File::Spec->catfile($dir,'percona-toolkit-version-check');
+my $dir              = File::Spec->tmpdir();
+my $check_time_file  = File::Spec->catfile($dir,'percona-toolkit-version-check');
 my $check_time_limit = 60 * 60 * 24;  # one day
 
 sub Dumper {
@@ -4103,11 +4118,13 @@
 
 local $EVAL_ERROR;
 eval {
+   require Percona::Toolkit;
    require HTTPMicro;
    require VersionCheck;
 };
 
 sub version_check {
+   my @instances = @_;
    eval {
       if (exists $ENV{PERCONA_VERSION_CHECK} && !$ENV{PERCONA_VERSION_CHECK}) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
@@ -4117,19 +4134,26 @@
          return;
       } 
 
-      if ( !time_to_check($check_time_file) ) {
+      foreach my $instance ( @instances ) {
+         my ($name, $id) = _generate_identifier($instance);
+         $instance->{name} = $name;
+         $instance->{id}   = $id;
+      }
+
+      my ($time_to_check, $instances_to_check)
+         = time_to_check($check_time_file, \@instances);
+      if ( !$time_to_check ) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
-            _d('It is not time to --version-checka again;',
+            _d('It is not time to --version-check again;',
                'only 1 check per', $check_time_limit, 'seconds, and the last',
                'check was performed on the modified time of', $check_time_file);
          }
          return;
       }
 
-      my $dbh = shift;  # optional
       my $advice = pingback(
-         url => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
-         dbh => $dbh,
+         url       => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
+         instances => $instances_to_check,
       );
       if ( $advice ) {
          print "# Percona suggests these upgrades:\n";
@@ -4157,7 +4181,7 @@
    }
    my ($url) = @args{@required_args};
 
-   my ($dbh, $ua, $vc) = @args{qw(dbh ua VersionCheck)};
+   my ($instances, $ua, $vc) = @args{qw(instances ua VersionCheck)};
 
    $ua ||= HTTPMicro->new( timeout => 2 );
    $vc ||= VersionCheck->new();
@@ -4176,24 +4200,27 @@
    );
    die "Failed to parse server requested programs: $response->{content}"
       if !scalar keys %$items;
-
+      
    my $versions = $vc->get_versions(
-      items => $items,
-      dbh   => $dbh,
+      items     => $items,
+      instances => $instances,
    );
    die "Failed to get any program versions; should have at least gotten Perl"
       if !scalar keys %$versions;
 
    my $client_content = encode_client_response(
-      items    => $items,
-      versions => $versions,
+      items      => $items,
+      versions   => $versions,
+      general_id => md5_hex( hostname() ),
    );
 
    my $client_response = {
       headers => { "X-Percona-Toolkit-Tool" => File::Basename::basename($0) },
       content => $client_content,
    };
-   PTDEBUG && _d('Client response:', Dumper($client_response));
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Client response:', Dumper($client_response));
+   }
 
    $response = $ua->request('POST', $url, $client_response);
    PTDEBUG && _d('Server suggestions:', Dumper($response));
@@ -4218,22 +4245,35 @@
 }
 
 sub time_to_check {
-   my ($file) = @_;
+   my ($file, $instances) = @_;
    die "I need a file argument" unless $file;
 
+   my $created_file = 0;
    if ( !-f $file ) {
-      PTDEBUG && _d('Creating', $file);
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Creating time limit file', $file);
+      }
       _touch($file);
-      return 1;
-   }
+      $created_file = 1;
+   }
+   elsif ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Time limit file already exists:', $file);
+   }
+
+   my $time = int(time());  # current time
+
+   if ( @$instances ) {
+      my $instances_to_check = instances_to_check($file, $instances, $time);
+      return scalar @$instances_to_check, $instances_to_check;
+   }
+
+   return 1 if $created_file;
 
    my $mtime  = (stat $file)[9];
    if ( !defined $mtime ) {
       PTDEBUG && _d('Error getting modified time of', $file);
       return 0;
    }
-
-   my $time = int(time());
    PTDEBUG && _d('time=', $time, 'mtime=', $mtime);
    if ( ($time - $mtime) > $check_time_limit ) {
       _touch($file);
@@ -4243,6 +4283,36 @@
    return 0;
 }
 
+sub instances_to_check {
+   my ($file, $instances, $time) = @_;
+
+   open my $fh, '<', $file or die "Cannot open $file: $OS_ERROR";
+   my $file_contents = do { local $/ = undef; <$fh> };
+   close $fh;
+   chomp($file_contents);
+   my %cached_instances = $file_contents =~ /^([^,]+),(.+)$/mg;
+
+   my @instances_to_check;
+   foreach my $instance ( @$instances ) {
+      my $mtime = $cached_instances{ $instance->{id} };
+      if ( !$mtime || (($time - $mtime) > $check_time_limit) ) {
+         if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+            _d('Time to check MySQL instance', $instance->{name});
+         }
+         push @instances_to_check, $instance;
+         $cached_instances{ $instance->{id} } = $time;
+      }
+   }
+
+   open $fh, '>', $file or die "Cannot open $file for writing: $OS_ERROR";
+   while ( my ($id, $time) = each %cached_instances ) {
+      print { $fh } "$id,$time\n";
+   }
+   close $fh or die "Cannot close $file: $OS_ERROR";
+
+   return \@instances_to_check;
+}
+
 sub _touch {
    my ($file) = @_;
    sysopen my $fh, $file, O_WRONLY|O_CREAT|O_NONBLOCK
@@ -4251,22 +4321,48 @@
    utime(undef, undef, $file);
 }
 
+sub _generate_identifier {
+   my $instance = shift;
+   my $dbh      = $instance->{dbh};
+   my $dsn      = $instance->{dsn};
+
+   my $sql    = q{SELECT CONCAT(@@hostname, @@port)};
+   my ($name) = eval { $dbh->selectrow_array($sql) };
+   if ( $EVAL_ERROR ) { # assume that it's MySQL 4.x
+      $name = ($dsn->{h} || 'localhost') . ($dsn->{P} || 3306);
+   }
+   my $id = md5_hex($name);
+
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('MySQL instance', $name, 'is', $id);
+   }
+
+   return $name, $id;
+}
+
 sub encode_client_response {
    my (%args) = @_;
-   my @required_args = qw(items versions);
+   my @required_args = qw(items versions general_id);
    foreach my $arg ( @required_args ) {
       die "I need a $arg arugment" unless $args{$arg};
    }
-   my ($items, $versions) = @args{@required_args};
+   my ($items, $versions, $general_id) = @args{@required_args};
 
    my @lines;
    foreach my $item ( sort keys %$items ) {
       next unless exists $versions->{$item};
-      push @lines, join(';', $item, $versions->{$item});
+      if ( ref($versions->{$item}) eq 'HASH' ) {
+         my $mysql_versions = $versions->{$item};
+         for my $id ( keys %$mysql_versions ) {
+            push @lines, join(';', $id, $item, $mysql_versions->{$id});
+         }
+      }
+      else {
+         push @lines, join(';', $general_id, $item, $versions->{$item});
+      }
    }
 
    my $client_response = join("\n", @lines) . "\n";
-   PTDEBUG && _d('Client response:', $client_response);
    return $client_response;
 }
 
@@ -4358,7 +4454,7 @@
    # Do the version-check
    # ########################################################################
    if ( $o->get('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
-      Pingback::version_check($dbh);
+      Pingback::version_check({dbh => $dbh, dsn => $dsn});
    }
 
    # #######################################################################

=== modified file 'bin/pt-find'
--- bin/pt-find	2012-08-24 23:26:04 +0000
+++ bin/pt-find	2012-08-28 21:31:19 +0000
@@ -36,6 +36,7 @@
 {
 package Percona::Toolkit;
 our $VERSION = '2.1.3';
+
 1;
 }
 # ###########################################################################
@@ -2266,20 +2267,19 @@
       die "I need a $arg arugment" unless $args{$arg};
    }
    my ($items) = @args{@required_args};
-   my $dbh     = $args{dbh}; # optional
 
    my %versions;
    foreach my $item ( values %$items ) {
       next unless $self->valid_item($item);
-      
+
       eval {
          my $func    = 'get_' . $item->{type};
          my $version = $self->$func(
-            item => $item,
-            dbh  => $dbh,
+            item      => $item,
+            instances => $args{instances},
          );
          if ( $version ) {
-            chomp $version;
+            chomp $version unless ref($version);
             $versions{$item->{item}} = $version;
          }
       };
@@ -2404,28 +2404,42 @@
    );
 }
 
-
 sub _get_from_mysql {
    my ($self, %args) = @_;
-   my $show = $args{show};
-   my $item = $args{item};
-   my $dbh  = $args{dbh};
-   return unless $show && $item && $dbh;
+   my $show      = $args{show};
+   my $item      = $args{item};
+   my $instances = $args{instances};
+   return unless $show && $item;
 
-   local $dbh->{FetchHashKeyName} = 'NAME_lc';
-   my $sql = qq/SHOW $show/;
-   PTDEBUG && _d($sql);
-   my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+   if ( !$instances || !@$instances ) {
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Cannot check', $item, 'because there are no MySQL instances');
+      }
+      return;
+   }
 
    my @versions;
-   foreach my $var ( @{$item->{vars}} ) {
-      $var = lc($var);
-      my $version = $rows->{$var}->{value};
-      PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version);
-      push @versions, $version;
+   my %version_for;
+   foreach my $instance ( @$instances ) {
+      my $dbh = $instance->{dbh};
+      local $dbh->{FetchHashKeyName} = 'NAME_lc';
+      my $sql = qq/SHOW $show/;
+      PTDEBUG && _d($sql);
+      my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+
+      my @versions;
+      foreach my $var ( @{$item->{vars}} ) {
+         $var = lc($var);
+         my $version = $rows->{$var}->{value};
+         PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version,
+            'on', $instance->{name});
+         push @versions, $version;
+      }
+
+      $version_for{ $instance->{id} } = join(' ', @versions);
    }
 
-   return join(' ', @versions);
+   return \%version_for;
 }
 
 sub get_bin_version {
@@ -2923,14 +2937,15 @@
 
 use constant PTDEBUG => $ENV{PTDEBUG} || 0;
 
-use File::Basename qw();
 use Data::Dumper   qw();
+use Digest::MD5    qw(md5_hex);
+use Sys::Hostname  qw(hostname);
 use Fcntl          qw(:DEFAULT);
-
+use File::Basename qw();
 use File::Spec;
 
-my $dir = File::Spec->tmpdir();
-my $check_time_file = File::Spec->catfile($dir,'percona-toolkit-version-check');
+my $dir              = File::Spec->tmpdir();
+my $check_time_file  = File::Spec->catfile($dir,'percona-toolkit-version-check');
 my $check_time_limit = 60 * 60 * 24;  # one day
 
 sub Dumper {
@@ -2943,11 +2958,13 @@
 
 local $EVAL_ERROR;
 eval {
+   require Percona::Toolkit;
    require HTTPMicro;
    require VersionCheck;
 };
 
 sub version_check {
+   my @instances = @_;
    eval {
       if (exists $ENV{PERCONA_VERSION_CHECK} && !$ENV{PERCONA_VERSION_CHECK}) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
@@ -2957,19 +2974,26 @@
          return;
       } 
 
-      if ( !time_to_check($check_time_file) ) {
+      foreach my $instance ( @instances ) {
+         my ($name, $id) = _generate_identifier($instance);
+         $instance->{name} = $name;
+         $instance->{id}   = $id;
+      }
+
+      my ($time_to_check, $instances_to_check)
+         = time_to_check($check_time_file, \@instances);
+      if ( !$time_to_check ) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
-            _d('It is not time to --version-checka again;',
+            _d('It is not time to --version-check again;',
                'only 1 check per', $check_time_limit, 'seconds, and the last',
                'check was performed on the modified time of', $check_time_file);
          }
          return;
       }
 
-      my $dbh = shift;  # optional
       my $advice = pingback(
-         url => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
-         dbh => $dbh,
+         url       => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
+         instances => $instances_to_check,
       );
       if ( $advice ) {
          print "# Percona suggests these upgrades:\n";
@@ -2997,7 +3021,7 @@
    }
    my ($url) = @args{@required_args};
 
-   my ($dbh, $ua, $vc) = @args{qw(dbh ua VersionCheck)};
+   my ($instances, $ua, $vc) = @args{qw(instances ua VersionCheck)};
 
    $ua ||= HTTPMicro->new( timeout => 2 );
    $vc ||= VersionCheck->new();
@@ -3016,24 +3040,27 @@
    );
    die "Failed to parse server requested programs: $response->{content}"
       if !scalar keys %$items;
-
+      
    my $versions = $vc->get_versions(
-      items => $items,
-      dbh   => $dbh,
+      items     => $items,
+      instances => $instances,
    );
    die "Failed to get any program versions; should have at least gotten Perl"
       if !scalar keys %$versions;
 
    my $client_content = encode_client_response(
-      items    => $items,
-      versions => $versions,
+      items      => $items,
+      versions   => $versions,
+      general_id => md5_hex( hostname() ),
    );
 
    my $client_response = {
       headers => { "X-Percona-Toolkit-Tool" => File::Basename::basename($0) },
       content => $client_content,
    };
-   PTDEBUG && _d('Client response:', Dumper($client_response));
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Client response:', Dumper($client_response));
+   }
 
    $response = $ua->request('POST', $url, $client_response);
    PTDEBUG && _d('Server suggestions:', Dumper($response));
@@ -3058,22 +3085,35 @@
 }
 
 sub time_to_check {
-   my ($file) = @_;
+   my ($file, $instances) = @_;
    die "I need a file argument" unless $file;
 
+   my $created_file = 0;
    if ( !-f $file ) {
-      PTDEBUG && _d('Creating', $file);
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Creating time limit file', $file);
+      }
       _touch($file);
-      return 1;
-   }
+      $created_file = 1;
+   }
+   elsif ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Time limit file already exists:', $file);
+   }
+
+   my $time = int(time());  # current time
+
+   if ( @$instances ) {
+      my $instances_to_check = instances_to_check($file, $instances, $time);
+      return scalar @$instances_to_check, $instances_to_check;
+   }
+
+   return 1 if $created_file;
 
    my $mtime  = (stat $file)[9];
    if ( !defined $mtime ) {
       PTDEBUG && _d('Error getting modified time of', $file);
       return 0;
    }
-
-   my $time = int(time());
    PTDEBUG && _d('time=', $time, 'mtime=', $mtime);
    if ( ($time - $mtime) > $check_time_limit ) {
       _touch($file);
@@ -3083,6 +3123,36 @@
    return 0;
 }
 
+sub instances_to_check {
+   my ($file, $instances, $time) = @_;
+
+   open my $fh, '<', $file or die "Cannot open $file: $OS_ERROR";
+   my $file_contents = do { local $/ = undef; <$fh> };
+   close $fh;
+   chomp($file_contents);
+   my %cached_instances = $file_contents =~ /^([^,]+),(.+)$/mg;
+
+   my @instances_to_check;
+   foreach my $instance ( @$instances ) {
+      my $mtime = $cached_instances{ $instance->{id} };
+      if ( !$mtime || (($time - $mtime) > $check_time_limit) ) {
+         if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+            _d('Time to check MySQL instance', $instance->{name});
+         }
+         push @instances_to_check, $instance;
+         $cached_instances{ $instance->{id} } = $time;
+      }
+   }
+
+   open $fh, '>', $file or die "Cannot open $file for writing: $OS_ERROR";
+   while ( my ($id, $time) = each %cached_instances ) {
+      print { $fh } "$id,$time\n";
+   }
+   close $fh or die "Cannot close $file: $OS_ERROR";
+
+   return \@instances_to_check;
+}
+
 sub _touch {
    my ($file) = @_;
    sysopen my $fh, $file, O_WRONLY|O_CREAT|O_NONBLOCK
@@ -3091,22 +3161,48 @@
    utime(undef, undef, $file);
 }
 
+sub _generate_identifier {
+   my $instance = shift;
+   my $dbh      = $instance->{dbh};
+   my $dsn      = $instance->{dsn};
+
+   my $sql    = q{SELECT CONCAT(@@hostname, @@port)};
+   my ($name) = eval { $dbh->selectrow_array($sql) };
+   if ( $EVAL_ERROR ) { # assume that it's MySQL 4.x
+      $name = ($dsn->{h} || 'localhost') . ($dsn->{P} || 3306);
+   }
+   my $id = md5_hex($name);
+
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('MySQL instance', $name, 'is', $id);
+   }
+
+   return $name, $id;
+}
+
 sub encode_client_response {
    my (%args) = @_;
-   my @required_args = qw(items versions);
+   my @required_args = qw(items versions general_id);
    foreach my $arg ( @required_args ) {
       die "I need a $arg arugment" unless $args{$arg};
    }
-   my ($items, $versions) = @args{@required_args};
+   my ($items, $versions, $general_id) = @args{@required_args};
 
    my @lines;
    foreach my $item ( sort keys %$items ) {
       next unless exists $versions->{$item};
-      push @lines, join(';', $item, $versions->{$item});
+      if ( ref($versions->{$item}) eq 'HASH' ) {
+         my $mysql_versions = $versions->{$item};
+         for my $id ( keys %$mysql_versions ) {
+            push @lines, join(';', $id, $item, $mysql_versions->{$id});
+         }
+      }
+      else {
+         push @lines, join(';', $general_id, $item, $versions->{$item});
+      }
    }
 
    my $client_response = join("\n", @lines) . "\n";
-   PTDEBUG && _d('Client response:', $client_response);
    return $client_response;
 }
 
@@ -3526,7 +3622,7 @@
    # Do the version-check
    # ########################################################################
    if ( $o->get('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
-      Pingback::version_check($dbh);
+      Pingback::version_check({dbh => $dbh, dsn => $dsn});
    }
 
    # ########################################################################

=== modified file 'bin/pt-fk-error-logger'
--- bin/pt-fk-error-logger	2012-08-24 23:26:04 +0000
+++ bin/pt-fk-error-logger	2012-08-28 21:31:19 +0000
@@ -36,6 +36,7 @@
 {
 package Percona::Toolkit;
 our $VERSION = '2.1.3';
+
 1;
 }
 # ###########################################################################
@@ -2173,20 +2174,19 @@
       die "I need a $arg arugment" unless $args{$arg};
    }
    my ($items) = @args{@required_args};
-   my $dbh     = $args{dbh}; # optional
 
    my %versions;
    foreach my $item ( values %$items ) {
       next unless $self->valid_item($item);
-      
+
       eval {
          my $func    = 'get_' . $item->{type};
          my $version = $self->$func(
-            item => $item,
-            dbh  => $dbh,
+            item      => $item,
+            instances => $args{instances},
          );
          if ( $version ) {
-            chomp $version;
+            chomp $version unless ref($version);
             $versions{$item->{item}} = $version;
          }
       };
@@ -2311,28 +2311,42 @@
    );
 }
 
-
 sub _get_from_mysql {
    my ($self, %args) = @_;
-   my $show = $args{show};
-   my $item = $args{item};
-   my $dbh  = $args{dbh};
-   return unless $show && $item && $dbh;
+   my $show      = $args{show};
+   my $item      = $args{item};
+   my $instances = $args{instances};
+   return unless $show && $item;
 
-   local $dbh->{FetchHashKeyName} = 'NAME_lc';
-   my $sql = qq/SHOW $show/;
-   PTDEBUG && _d($sql);
-   my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+   if ( !$instances || !@$instances ) {
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Cannot check', $item, 'because there are no MySQL instances');
+      }
+      return;
+   }
 
    my @versions;
-   foreach my $var ( @{$item->{vars}} ) {
-      $var = lc($var);
-      my $version = $rows->{$var}->{value};
-      PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version);
-      push @versions, $version;
+   my %version_for;
+   foreach my $instance ( @$instances ) {
+      my $dbh = $instance->{dbh};
+      local $dbh->{FetchHashKeyName} = 'NAME_lc';
+      my $sql = qq/SHOW $show/;
+      PTDEBUG && _d($sql);
+      my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+
+      my @versions;
+      foreach my $var ( @{$item->{vars}} ) {
+         $var = lc($var);
+         my $version = $rows->{$var}->{value};
+         PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version,
+            'on', $instance->{name});
+         push @versions, $version;
+      }
+
+      $version_for{ $instance->{id} } = join(' ', @versions);
    }
 
-   return join(' ', @versions);
+   return \%version_for;
 }
 
 sub get_bin_version {
@@ -2830,14 +2844,15 @@
 
 use constant PTDEBUG => $ENV{PTDEBUG} || 0;
 
-use File::Basename qw();
 use Data::Dumper   qw();
+use Digest::MD5    qw(md5_hex);
+use Sys::Hostname  qw(hostname);
 use Fcntl          qw(:DEFAULT);
-
+use File::Basename qw();
 use File::Spec;
 
-my $dir = File::Spec->tmpdir();
-my $check_time_file = File::Spec->catfile($dir,'percona-toolkit-version-check');
+my $dir              = File::Spec->tmpdir();
+my $check_time_file  = File::Spec->catfile($dir,'percona-toolkit-version-check');
 my $check_time_limit = 60 * 60 * 24;  # one day
 
 sub Dumper {
@@ -2850,11 +2865,13 @@
 
 local $EVAL_ERROR;
 eval {
+   require Percona::Toolkit;
    require HTTPMicro;
    require VersionCheck;
 };
 
 sub version_check {
+   my @instances = @_;
    eval {
       if (exists $ENV{PERCONA_VERSION_CHECK} && !$ENV{PERCONA_VERSION_CHECK}) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
@@ -2864,19 +2881,26 @@
          return;
       } 
 
-      if ( !time_to_check($check_time_file) ) {
+      foreach my $instance ( @instances ) {
+         my ($name, $id) = _generate_identifier($instance);
+         $instance->{name} = $name;
+         $instance->{id}   = $id;
+      }
+
+      my ($time_to_check, $instances_to_check)
+         = time_to_check($check_time_file, \@instances);
+      if ( !$time_to_check ) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
-            _d('It is not time to --version-checka again;',
+            _d('It is not time to --version-check again;',
                'only 1 check per', $check_time_limit, 'seconds, and the last',
                'check was performed on the modified time of', $check_time_file);
          }
          return;
       }
 
-      my $dbh = shift;  # optional
       my $advice = pingback(
-         url => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
-         dbh => $dbh,
+         url       => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
+         instances => $instances_to_check,
       );
       if ( $advice ) {
          print "# Percona suggests these upgrades:\n";
@@ -2904,7 +2928,7 @@
    }
    my ($url) = @args{@required_args};
 
-   my ($dbh, $ua, $vc) = @args{qw(dbh ua VersionCheck)};
+   my ($instances, $ua, $vc) = @args{qw(instances ua VersionCheck)};
 
    $ua ||= HTTPMicro->new( timeout => 2 );
    $vc ||= VersionCheck->new();
@@ -2923,24 +2947,27 @@
    );
    die "Failed to parse server requested programs: $response->{content}"
       if !scalar keys %$items;
-
+      
    my $versions = $vc->get_versions(
-      items => $items,
-      dbh   => $dbh,
+      items     => $items,
+      instances => $instances,
    );
    die "Failed to get any program versions; should have at least gotten Perl"
       if !scalar keys %$versions;
 
    my $client_content = encode_client_response(
-      items    => $items,
-      versions => $versions,
+      items      => $items,
+      versions   => $versions,
+      general_id => md5_hex( hostname() ),
    );
 
    my $client_response = {
       headers => { "X-Percona-Toolkit-Tool" => File::Basename::basename($0) },
       content => $client_content,
    };
-   PTDEBUG && _d('Client response:', Dumper($client_response));
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Client response:', Dumper($client_response));
+   }
 
    $response = $ua->request('POST', $url, $client_response);
    PTDEBUG && _d('Server suggestions:', Dumper($response));
@@ -2965,22 +2992,35 @@
 }
 
 sub time_to_check {
-   my ($file) = @_;
+   my ($file, $instances) = @_;
    die "I need a file argument" unless $file;
 
+   my $created_file = 0;
    if ( !-f $file ) {
-      PTDEBUG && _d('Creating', $file);
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Creating time limit file', $file);
+      }
       _touch($file);
-      return 1;
-   }
+      $created_file = 1;
+   }
+   elsif ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Time limit file already exists:', $file);
+   }
+
+   my $time = int(time());  # current time
+
+   if ( @$instances ) {
+      my $instances_to_check = instances_to_check($file, $instances, $time);
+      return scalar @$instances_to_check, $instances_to_check;
+   }
+
+   return 1 if $created_file;
 
    my $mtime  = (stat $file)[9];
    if ( !defined $mtime ) {
       PTDEBUG && _d('Error getting modified time of', $file);
       return 0;
    }
-
-   my $time = int(time());
    PTDEBUG && _d('time=', $time, 'mtime=', $mtime);
    if ( ($time - $mtime) > $check_time_limit ) {
       _touch($file);
@@ -2990,6 +3030,36 @@
    return 0;
 }
 
+sub instances_to_check {
+   my ($file, $instances, $time) = @_;
+
+   open my $fh, '<', $file or die "Cannot open $file: $OS_ERROR";
+   my $file_contents = do { local $/ = undef; <$fh> };
+   close $fh;
+   chomp($file_contents);
+   my %cached_instances = $file_contents =~ /^([^,]+),(.+)$/mg;
+
+   my @instances_to_check;
+   foreach my $instance ( @$instances ) {
+      my $mtime = $cached_instances{ $instance->{id} };
+      if ( !$mtime || (($time - $mtime) > $check_time_limit) ) {
+         if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+            _d('Time to check MySQL instance', $instance->{name});
+         }
+         push @instances_to_check, $instance;
+         $cached_instances{ $instance->{id} } = $time;
+      }
+   }
+
+   open $fh, '>', $file or die "Cannot open $file for writing: $OS_ERROR";
+   while ( my ($id, $time) = each %cached_instances ) {
+      print { $fh } "$id,$time\n";
+   }
+   close $fh or die "Cannot close $file: $OS_ERROR";
+
+   return \@instances_to_check;
+}
+
 sub _touch {
    my ($file) = @_;
    sysopen my $fh, $file, O_WRONLY|O_CREAT|O_NONBLOCK
@@ -2998,22 +3068,48 @@
    utime(undef, undef, $file);
 }
 
+sub _generate_identifier {
+   my $instance = shift;
+   my $dbh      = $instance->{dbh};
+   my $dsn      = $instance->{dsn};
+
+   my $sql    = q{SELECT CONCAT(@@hostname, @@port)};
+   my ($name) = eval { $dbh->selectrow_array($sql) };
+   if ( $EVAL_ERROR ) { # assume that it's MySQL 4.x
+      $name = ($dsn->{h} || 'localhost') . ($dsn->{P} || 3306);
+   }
+   my $id = md5_hex($name);
+
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('MySQL instance', $name, 'is', $id);
+   }
+
+   return $name, $id;
+}
+
 sub encode_client_response {
    my (%args) = @_;
-   my @required_args = qw(items versions);
+   my @required_args = qw(items versions general_id);
    foreach my $arg ( @required_args ) {
       die "I need a $arg arugment" unless $args{$arg};
    }
-   my ($items, $versions) = @args{@required_args};
+   my ($items, $versions, $general_id) = @args{@required_args};
 
    my @lines;
    foreach my $item ( sort keys %$items ) {
       next unless exists $versions->{$item};
-      push @lines, join(';', $item, $versions->{$item});
+      if ( ref($versions->{$item}) eq 'HASH' ) {
+         my $mysql_versions = $versions->{$item};
+         for my $id ( keys %$mysql_versions ) {
+            push @lines, join(';', $id, $item, $mysql_versions->{$id});
+         }
+      }
+      else {
+         push @lines, join(';', $general_id, $item, $versions->{$item});
+      }
    }
 
    my $client_response = join("\n", @lines) . "\n";
-   PTDEBUG && _d('Client response:', $client_response);
    return $client_response;
 }
 
@@ -3150,7 +3246,10 @@
    # Do the version-check
    # ########################################################################
    if ( $o->get('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
-      Pingback::version_check($dbh);
+      Pingback::version_check(
+         { dbh => $dbh, dsn => $src_dsn },
+         ($dst_dbh ? { dbh => $dst_dbh, dsn => $dst_dsn } : ()),
+      );
    }
 
    # ########################################################################

=== modified file 'bin/pt-heartbeat'
--- bin/pt-heartbeat	2012-08-24 23:26:04 +0000
+++ bin/pt-heartbeat	2012-08-28 21:31:19 +0000
@@ -38,6 +38,7 @@
 {
 package Percona::Toolkit;
 our $VERSION = '2.1.3';
+
 1;
 }
 # ###########################################################################
@@ -3350,20 +3351,19 @@
       die "I need a $arg arugment" unless $args{$arg};
    }
    my ($items) = @args{@required_args};
-   my $dbh     = $args{dbh}; # optional
 
    my %versions;
    foreach my $item ( values %$items ) {
       next unless $self->valid_item($item);
-      
+
       eval {
          my $func    = 'get_' . $item->{type};
          my $version = $self->$func(
-            item => $item,
-            dbh  => $dbh,
+            item      => $item,
+            instances => $args{instances},
          );
          if ( $version ) {
-            chomp $version;
+            chomp $version unless ref($version);
             $versions{$item->{item}} = $version;
          }
       };
@@ -3488,28 +3488,42 @@
    );
 }
 
-
 sub _get_from_mysql {
    my ($self, %args) = @_;
-   my $show = $args{show};
-   my $item = $args{item};
-   my $dbh  = $args{dbh};
-   return unless $show && $item && $dbh;
+   my $show      = $args{show};
+   my $item      = $args{item};
+   my $instances = $args{instances};
+   return unless $show && $item;
 
-   local $dbh->{FetchHashKeyName} = 'NAME_lc';
-   my $sql = qq/SHOW $show/;
-   PTDEBUG && _d($sql);
-   my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+   if ( !$instances || !@$instances ) {
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Cannot check', $item, 'because there are no MySQL instances');
+      }
+      return;
+   }
 
    my @versions;
-   foreach my $var ( @{$item->{vars}} ) {
-      $var = lc($var);
-      my $version = $rows->{$var}->{value};
-      PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version);
-      push @versions, $version;
+   my %version_for;
+   foreach my $instance ( @$instances ) {
+      my $dbh = $instance->{dbh};
+      local $dbh->{FetchHashKeyName} = 'NAME_lc';
+      my $sql = qq/SHOW $show/;
+      PTDEBUG && _d($sql);
+      my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+
+      my @versions;
+      foreach my $var ( @{$item->{vars}} ) {
+         $var = lc($var);
+         my $version = $rows->{$var}->{value};
+         PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version,
+            'on', $instance->{name});
+         push @versions, $version;
+      }
+
+      $version_for{ $instance->{id} } = join(' ', @versions);
    }
 
-   return join(' ', @versions);
+   return \%version_for;
 }
 
 sub get_bin_version {
@@ -4007,14 +4021,15 @@
 
 use constant PTDEBUG => $ENV{PTDEBUG} || 0;
 
-use File::Basename qw();
 use Data::Dumper   qw();
+use Digest::MD5    qw(md5_hex);
+use Sys::Hostname  qw(hostname);
 use Fcntl          qw(:DEFAULT);
-
+use File::Basename qw();
 use File::Spec;
 
-my $dir = File::Spec->tmpdir();
-my $check_time_file = File::Spec->catfile($dir,'percona-toolkit-version-check');
+my $dir              = File::Spec->tmpdir();
+my $check_time_file  = File::Spec->catfile($dir,'percona-toolkit-version-check');
 my $check_time_limit = 60 * 60 * 24;  # one day
 
 sub Dumper {
@@ -4027,11 +4042,13 @@
 
 local $EVAL_ERROR;
 eval {
+   require Percona::Toolkit;
    require HTTPMicro;
    require VersionCheck;
 };
 
 sub version_check {
+   my @instances = @_;
    eval {
       if (exists $ENV{PERCONA_VERSION_CHECK} && !$ENV{PERCONA_VERSION_CHECK}) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
@@ -4041,19 +4058,26 @@
          return;
       } 
 
-      if ( !time_to_check($check_time_file) ) {
+      foreach my $instance ( @instances ) {
+         my ($name, $id) = _generate_identifier($instance);
+         $instance->{name} = $name;
+         $instance->{id}   = $id;
+      }
+
+      my ($time_to_check, $instances_to_check)
+         = time_to_check($check_time_file, \@instances);
+      if ( !$time_to_check ) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
-            _d('It is not time to --version-checka again;',
+            _d('It is not time to --version-check again;',
                'only 1 check per', $check_time_limit, 'seconds, and the last',
                'check was performed on the modified time of', $check_time_file);
          }
          return;
       }
 
-      my $dbh = shift;  # optional
       my $advice = pingback(
-         url => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
-         dbh => $dbh,
+         url       => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
+         instances => $instances_to_check,
       );
       if ( $advice ) {
          print "# Percona suggests these upgrades:\n";
@@ -4081,7 +4105,7 @@
    }
    my ($url) = @args{@required_args};
 
-   my ($dbh, $ua, $vc) = @args{qw(dbh ua VersionCheck)};
+   my ($instances, $ua, $vc) = @args{qw(instances ua VersionCheck)};
 
    $ua ||= HTTPMicro->new( timeout => 2 );
    $vc ||= VersionCheck->new();
@@ -4100,24 +4124,27 @@
    );
    die "Failed to parse server requested programs: $response->{content}"
       if !scalar keys %$items;
-
+      
    my $versions = $vc->get_versions(
-      items => $items,
-      dbh   => $dbh,
+      items     => $items,
+      instances => $instances,
    );
    die "Failed to get any program versions; should have at least gotten Perl"
       if !scalar keys %$versions;
 
    my $client_content = encode_client_response(
-      items    => $items,
-      versions => $versions,
+      items      => $items,
+      versions   => $versions,
+      general_id => md5_hex( hostname() ),
    );
 
    my $client_response = {
       headers => { "X-Percona-Toolkit-Tool" => File::Basename::basename($0) },
       content => $client_content,
    };
-   PTDEBUG && _d('Client response:', Dumper($client_response));
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Client response:', Dumper($client_response));
+   }
 
    $response = $ua->request('POST', $url, $client_response);
    PTDEBUG && _d('Server suggestions:', Dumper($response));
@@ -4142,22 +4169,35 @@
 }
 
 sub time_to_check {
-   my ($file) = @_;
+   my ($file, $instances) = @_;
    die "I need a file argument" unless $file;
 
+   my $created_file = 0;
    if ( !-f $file ) {
-      PTDEBUG && _d('Creating', $file);
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Creating time limit file', $file);
+      }
       _touch($file);
-      return 1;
-   }
+      $created_file = 1;
+   }
+   elsif ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Time limit file already exists:', $file);
+   }
+
+   my $time = int(time());  # current time
+
+   if ( @$instances ) {
+      my $instances_to_check = instances_to_check($file, $instances, $time);
+      return scalar @$instances_to_check, $instances_to_check;
+   }
+
+   return 1 if $created_file;
 
    my $mtime  = (stat $file)[9];
    if ( !defined $mtime ) {
       PTDEBUG && _d('Error getting modified time of', $file);
       return 0;
    }
-
-   my $time = int(time());
    PTDEBUG && _d('time=', $time, 'mtime=', $mtime);
    if ( ($time - $mtime) > $check_time_limit ) {
       _touch($file);
@@ -4167,6 +4207,36 @@
    return 0;
 }
 
+sub instances_to_check {
+   my ($file, $instances, $time) = @_;
+
+   open my $fh, '<', $file or die "Cannot open $file: $OS_ERROR";
+   my $file_contents = do { local $/ = undef; <$fh> };
+   close $fh;
+   chomp($file_contents);
+   my %cached_instances = $file_contents =~ /^([^,]+),(.+)$/mg;
+
+   my @instances_to_check;
+   foreach my $instance ( @$instances ) {
+      my $mtime = $cached_instances{ $instance->{id} };
+      if ( !$mtime || (($time - $mtime) > $check_time_limit) ) {
+         if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+            _d('Time to check MySQL instance', $instance->{name});
+         }
+         push @instances_to_check, $instance;
+         $cached_instances{ $instance->{id} } = $time;
+      }
+   }
+
+   open $fh, '>', $file or die "Cannot open $file for writing: $OS_ERROR";
+   while ( my ($id, $time) = each %cached_instances ) {
+      print { $fh } "$id,$time\n";
+   }
+   close $fh or die "Cannot close $file: $OS_ERROR";
+
+   return \@instances_to_check;
+}
+
 sub _touch {
    my ($file) = @_;
    sysopen my $fh, $file, O_WRONLY|O_CREAT|O_NONBLOCK
@@ -4175,22 +4245,48 @@
    utime(undef, undef, $file);
 }
 
+sub _generate_identifier {
+   my $instance = shift;
+   my $dbh      = $instance->{dbh};
+   my $dsn      = $instance->{dsn};
+
+   my $sql    = q{SELECT CONCAT(@@hostname, @@port)};
+   my ($name) = eval { $dbh->selectrow_array($sql) };
+   if ( $EVAL_ERROR ) { # assume that it's MySQL 4.x
+      $name = ($dsn->{h} || 'localhost') . ($dsn->{P} || 3306);
+   }
+   my $id = md5_hex($name);
+
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('MySQL instance', $name, 'is', $id);
+   }
+
+   return $name, $id;
+}
+
 sub encode_client_response {
    my (%args) = @_;
-   my @required_args = qw(items versions);
+   my @required_args = qw(items versions general_id);
    foreach my $arg ( @required_args ) {
       die "I need a $arg arugment" unless $args{$arg};
    }
-   my ($items, $versions) = @args{@required_args};
+   my ($items, $versions, $general_id) = @args{@required_args};
 
    my @lines;
    foreach my $item ( sort keys %$items ) {
       next unless exists $versions->{$item};
-      push @lines, join(';', $item, $versions->{$item});
+      if ( ref($versions->{$item}) eq 'HASH' ) {
+         my $mysql_versions = $versions->{$item};
+         for my $id ( keys %$mysql_versions ) {
+            push @lines, join(';', $id, $item, $mysql_versions->{$id});
+         }
+      }
+      else {
+         push @lines, join(';', $general_id, $item, $versions->{$item});
+      }
    }
 
    my $client_response = join("\n", @lines) . "\n";
-   PTDEBUG && _d('Client response:', $client_response);
    return $client_response;
 }
 
@@ -4646,7 +4742,7 @@
    # Do the version-check
    # ########################################################################
    if ( $o->get('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
-      Pingback::version_check($dbh);
+      Pingback::version_check({dbh => $dbh, dsn => $dsn});
    }
 
    # ########################################################################

=== modified file 'bin/pt-index-usage'
--- bin/pt-index-usage	2012-08-24 23:26:04 +0000
+++ bin/pt-index-usage	2012-08-28 21:31:19 +0000
@@ -46,6 +46,7 @@
 {
 package Percona::Toolkit;
 our $VERSION = '2.1.3';
+
 1;
 }
 # ###########################################################################
@@ -4932,20 +4933,19 @@
       die "I need a $arg arugment" unless $args{$arg};
    }
    my ($items) = @args{@required_args};
-   my $dbh     = $args{dbh}; # optional
 
    my %versions;
    foreach my $item ( values %$items ) {
       next unless $self->valid_item($item);
-      
+
       eval {
          my $func    = 'get_' . $item->{type};
          my $version = $self->$func(
-            item => $item,
-            dbh  => $dbh,
+            item      => $item,
+            instances => $args{instances},
          );
          if ( $version ) {
-            chomp $version;
+            chomp $version unless ref($version);
             $versions{$item->{item}} = $version;
          }
       };
@@ -5070,28 +5070,42 @@
    );
 }
 
-
 sub _get_from_mysql {
    my ($self, %args) = @_;
-   my $show = $args{show};
-   my $item = $args{item};
-   my $dbh  = $args{dbh};
-   return unless $show && $item && $dbh;
+   my $show      = $args{show};
+   my $item      = $args{item};
+   my $instances = $args{instances};
+   return unless $show && $item;
 
-   local $dbh->{FetchHashKeyName} = 'NAME_lc';
-   my $sql = qq/SHOW $show/;
-   PTDEBUG && _d($sql);
-   my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+   if ( !$instances || !@$instances ) {
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Cannot check', $item, 'because there are no MySQL instances');
+      }
+      return;
+   }
 
    my @versions;
-   foreach my $var ( @{$item->{vars}} ) {
-      $var = lc($var);
-      my $version = $rows->{$var}->{value};
-      PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version);
-      push @versions, $version;
+   my %version_for;
+   foreach my $instance ( @$instances ) {
+      my $dbh = $instance->{dbh};
+      local $dbh->{FetchHashKeyName} = 'NAME_lc';
+      my $sql = qq/SHOW $show/;
+      PTDEBUG && _d($sql);
+      my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+
+      my @versions;
+      foreach my $var ( @{$item->{vars}} ) {
+         $var = lc($var);
+         my $version = $rows->{$var}->{value};
+         PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version,
+            'on', $instance->{name});
+         push @versions, $version;
+      }
+
+      $version_for{ $instance->{id} } = join(' ', @versions);
    }
 
-   return join(' ', @versions);
+   return \%version_for;
 }
 
 sub get_bin_version {
@@ -5589,14 +5603,15 @@
 
 use constant PTDEBUG => $ENV{PTDEBUG} || 0;
 
-use File::Basename qw();
 use Data::Dumper   qw();
+use Digest::MD5    qw(md5_hex);
+use Sys::Hostname  qw(hostname);
 use Fcntl          qw(:DEFAULT);
-
+use File::Basename qw();
 use File::Spec;
 
-my $dir = File::Spec->tmpdir();
-my $check_time_file = File::Spec->catfile($dir,'percona-toolkit-version-check');
+my $dir              = File::Spec->tmpdir();
+my $check_time_file  = File::Spec->catfile($dir,'percona-toolkit-version-check');
 my $check_time_limit = 60 * 60 * 24;  # one day
 
 sub Dumper {
@@ -5609,11 +5624,13 @@
 
 local $EVAL_ERROR;
 eval {
+   require Percona::Toolkit;
    require HTTPMicro;
    require VersionCheck;
 };
 
 sub version_check {
+   my @instances = @_;
    eval {
       if (exists $ENV{PERCONA_VERSION_CHECK} && !$ENV{PERCONA_VERSION_CHECK}) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
@@ -5623,19 +5640,26 @@
          return;
       } 
 
-      if ( !time_to_check($check_time_file) ) {
+      foreach my $instance ( @instances ) {
+         my ($name, $id) = _generate_identifier($instance);
+         $instance->{name} = $name;
+         $instance->{id}   = $id;
+      }
+
+      my ($time_to_check, $instances_to_check)
+         = time_to_check($check_time_file, \@instances);
+      if ( !$time_to_check ) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
-            _d('It is not time to --version-checka again;',
+            _d('It is not time to --version-check again;',
                'only 1 check per', $check_time_limit, 'seconds, and the last',
                'check was performed on the modified time of', $check_time_file);
          }
          return;
       }
 
-      my $dbh = shift;  # optional
       my $advice = pingback(
-         url => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
-         dbh => $dbh,
+         url       => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
+         instances => $instances_to_check,
       );
       if ( $advice ) {
          print "# Percona suggests these upgrades:\n";
@@ -5663,7 +5687,7 @@
    }
    my ($url) = @args{@required_args};
 
-   my ($dbh, $ua, $vc) = @args{qw(dbh ua VersionCheck)};
+   my ($instances, $ua, $vc) = @args{qw(instances ua VersionCheck)};
 
    $ua ||= HTTPMicro->new( timeout => 2 );
    $vc ||= VersionCheck->new();
@@ -5682,24 +5706,27 @@
    );
    die "Failed to parse server requested programs: $response->{content}"
       if !scalar keys %$items;
-
+      
    my $versions = $vc->get_versions(
-      items => $items,
-      dbh   => $dbh,
+      items     => $items,
+      instances => $instances,
    );
    die "Failed to get any program versions; should have at least gotten Perl"
       if !scalar keys %$versions;
 
    my $client_content = encode_client_response(
-      items    => $items,
-      versions => $versions,
+      items      => $items,
+      versions   => $versions,
+      general_id => md5_hex( hostname() ),
    );
 
    my $client_response = {
       headers => { "X-Percona-Toolkit-Tool" => File::Basename::basename($0) },
       content => $client_content,
    };
-   PTDEBUG && _d('Client response:', Dumper($client_response));
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Client response:', Dumper($client_response));
+   }
 
    $response = $ua->request('POST', $url, $client_response);
    PTDEBUG && _d('Server suggestions:', Dumper($response));
@@ -5724,22 +5751,35 @@
 }
 
 sub time_to_check {
-   my ($file) = @_;
+   my ($file, $instances) = @_;
    die "I need a file argument" unless $file;
 
+   my $created_file = 0;
    if ( !-f $file ) {
-      PTDEBUG && _d('Creating', $file);
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Creating time limit file', $file);
+      }
       _touch($file);
-      return 1;
-   }
+      $created_file = 1;
+   }
+   elsif ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Time limit file already exists:', $file);
+   }
+
+   my $time = int(time());  # current time
+
+   if ( @$instances ) {
+      my $instances_to_check = instances_to_check($file, $instances, $time);
+      return scalar @$instances_to_check, $instances_to_check;
+   }
+
+   return 1 if $created_file;
 
    my $mtime  = (stat $file)[9];
    if ( !defined $mtime ) {
       PTDEBUG && _d('Error getting modified time of', $file);
       return 0;
    }
-
-   my $time = int(time());
    PTDEBUG && _d('time=', $time, 'mtime=', $mtime);
    if ( ($time - $mtime) > $check_time_limit ) {
       _touch($file);
@@ -5749,6 +5789,36 @@
    return 0;
 }
 
+sub instances_to_check {
+   my ($file, $instances, $time) = @_;
+
+   open my $fh, '<', $file or die "Cannot open $file: $OS_ERROR";
+   my $file_contents = do { local $/ = undef; <$fh> };
+   close $fh;
+   chomp($file_contents);
+   my %cached_instances = $file_contents =~ /^([^,]+),(.+)$/mg;
+
+   my @instances_to_check;
+   foreach my $instance ( @$instances ) {
+      my $mtime = $cached_instances{ $instance->{id} };
+      if ( !$mtime || (($time - $mtime) > $check_time_limit) ) {
+         if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+            _d('Time to check MySQL instance', $instance->{name});
+         }
+         push @instances_to_check, $instance;
+         $cached_instances{ $instance->{id} } = $time;
+      }
+   }
+
+   open $fh, '>', $file or die "Cannot open $file for writing: $OS_ERROR";
+   while ( my ($id, $time) = each %cached_instances ) {
+      print { $fh } "$id,$time\n";
+   }
+   close $fh or die "Cannot close $file: $OS_ERROR";
+
+   return \@instances_to_check;
+}
+
 sub _touch {
    my ($file) = @_;
    sysopen my $fh, $file, O_WRONLY|O_CREAT|O_NONBLOCK
@@ -5757,22 +5827,48 @@
    utime(undef, undef, $file);
 }
 
+sub _generate_identifier {
+   my $instance = shift;
+   my $dbh      = $instance->{dbh};
+   my $dsn      = $instance->{dsn};
+
+   my $sql    = q{SELECT CONCAT(@@hostname, @@port)};
+   my ($name) = eval { $dbh->selectrow_array($sql) };
+   if ( $EVAL_ERROR ) { # assume that it's MySQL 4.x
+      $name = ($dsn->{h} || 'localhost') . ($dsn->{P} || 3306);
+   }
+   my $id = md5_hex($name);
+
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('MySQL instance', $name, 'is', $id);
+   }
+
+   return $name, $id;
+}
+
 sub encode_client_response {
    my (%args) = @_;
-   my @required_args = qw(items versions);
+   my @required_args = qw(items versions general_id);
    foreach my $arg ( @required_args ) {
       die "I need a $arg arugment" unless $args{$arg};
    }
-   my ($items, $versions) = @args{@required_args};
+   my ($items, $versions, $general_id) = @args{@required_args};
 
    my @lines;
    foreach my $item ( sort keys %$items ) {
       next unless exists $versions->{$item};
-      push @lines, join(';', $item, $versions->{$item});
+      if ( ref($versions->{$item}) eq 'HASH' ) {
+         my $mysql_versions = $versions->{$item};
+         for my $id ( keys %$mysql_versions ) {
+            push @lines, join(';', $id, $item, $mysql_versions->{$id});
+         }
+      }
+      else {
+         push @lines, join(';', $general_id, $item, $versions->{$item});
+      }
    }
 
    my $client_response = join("\n", @lines) . "\n";
-   PTDEBUG && _d('Client response:', $client_response);
    return $client_response;
 }
 
@@ -5854,10 +5950,11 @@
    # are given on the cmd line then parse_options() will return undef,
    # but get_cxn() required a defined dsn arg so use an empty hashref.
    # ########################################################################## 
-   my ($dbh, $si_dbh, $res_dbh);
+   my ($dsn, $dbh, $si_dbh, $res_dbh);
+   my $res_dsn;
    my $res_db;
    eval {
-      my $dsn = $dp->parse_options($o) || {};
+      $dsn = $dp->parse_options($o) || {};
 
       # dbh for EXPLAIN-ing.
       $dbh = get_cxn(
@@ -5875,7 +5972,7 @@
       );
 
       # dbh for --save-results-database
-      if ( my $res_dsn = $o->get('save-results-database') ) {
+      if ( $res_dsn = $o->get('save-results-database') ) {
          
          # To make --create-save-results-database work we have to
          # temporarily remove the D from the DSN to avoid the error
@@ -5988,7 +6085,10 @@
    # Do the version-check
    # ########################################################################
    if ( $o->get('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
-      Pingback::version_check($dbh);
+      Pingback::version_check(
+         { dbh => $dbh, dsn => $dsn },
+         ($res_dbh ? { dbh => $res_dbh, dsn => $res_dsn } : ()),
+      );
    }
 
    # ########################################################################

=== modified file 'bin/pt-kill'
--- bin/pt-kill	2012-08-24 23:26:04 +0000
+++ bin/pt-kill	2012-08-28 21:31:19 +0000
@@ -44,6 +44,7 @@
 {
 package Percona::Toolkit;
 our $VERSION = '2.1.3';
+
 1;
 }
 # ###########################################################################
@@ -4927,20 +4928,19 @@
       die "I need a $arg arugment" unless $args{$arg};
    }
    my ($items) = @args{@required_args};
-   my $dbh     = $args{dbh}; # optional
 
    my %versions;
    foreach my $item ( values %$items ) {
       next unless $self->valid_item($item);
-      
+
       eval {
          my $func    = 'get_' . $item->{type};
          my $version = $self->$func(
-            item => $item,
-            dbh  => $dbh,
+            item      => $item,
+            instances => $args{instances},
          );
          if ( $version ) {
-            chomp $version;
+            chomp $version unless ref($version);
             $versions{$item->{item}} = $version;
          }
       };
@@ -5065,28 +5065,42 @@
    );
 }
 
-
 sub _get_from_mysql {
    my ($self, %args) = @_;
-   my $show = $args{show};
-   my $item = $args{item};
-   my $dbh  = $args{dbh};
-   return unless $show && $item && $dbh;
+   my $show      = $args{show};
+   my $item      = $args{item};
+   my $instances = $args{instances};
+   return unless $show && $item;
 
-   local $dbh->{FetchHashKeyName} = 'NAME_lc';
-   my $sql = qq/SHOW $show/;
-   PTDEBUG && _d($sql);
-   my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+   if ( !$instances || !@$instances ) {
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Cannot check', $item, 'because there are no MySQL instances');
+      }
+      return;
+   }
 
    my @versions;
-   foreach my $var ( @{$item->{vars}} ) {
-      $var = lc($var);
-      my $version = $rows->{$var}->{value};
-      PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version);
-      push @versions, $version;
+   my %version_for;
+   foreach my $instance ( @$instances ) {
+      my $dbh = $instance->{dbh};
+      local $dbh->{FetchHashKeyName} = 'NAME_lc';
+      my $sql = qq/SHOW $show/;
+      PTDEBUG && _d($sql);
+      my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+
+      my @versions;
+      foreach my $var ( @{$item->{vars}} ) {
+         $var = lc($var);
+         my $version = $rows->{$var}->{value};
+         PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version,
+            'on', $instance->{name});
+         push @versions, $version;
+      }
+
+      $version_for{ $instance->{id} } = join(' ', @versions);
    }
 
-   return join(' ', @versions);
+   return \%version_for;
 }
 
 sub get_bin_version {
@@ -5584,14 +5598,15 @@
 
 use constant PTDEBUG => $ENV{PTDEBUG} || 0;
 
-use File::Basename qw();
 use Data::Dumper   qw();
+use Digest::MD5    qw(md5_hex);
+use Sys::Hostname  qw(hostname);
 use Fcntl          qw(:DEFAULT);
-
+use File::Basename qw();
 use File::Spec;
 
-my $dir = File::Spec->tmpdir();
-my $check_time_file = File::Spec->catfile($dir,'percona-toolkit-version-check');
+my $dir              = File::Spec->tmpdir();
+my $check_time_file  = File::Spec->catfile($dir,'percona-toolkit-version-check');
 my $check_time_limit = 60 * 60 * 24;  # one day
 
 sub Dumper {
@@ -5604,11 +5619,13 @@
 
 local $EVAL_ERROR;
 eval {
+   require Percona::Toolkit;
    require HTTPMicro;
    require VersionCheck;
 };
 
 sub version_check {
+   my @instances = @_;
    eval {
       if (exists $ENV{PERCONA_VERSION_CHECK} && !$ENV{PERCONA_VERSION_CHECK}) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
@@ -5618,19 +5635,26 @@
          return;
       } 
 
-      if ( !time_to_check($check_time_file) ) {
+      foreach my $instance ( @instances ) {
+         my ($name, $id) = _generate_identifier($instance);
+         $instance->{name} = $name;
+         $instance->{id}   = $id;
+      }
+
+      my ($time_to_check, $instances_to_check)
+         = time_to_check($check_time_file, \@instances);
+      if ( !$time_to_check ) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
-            _d('It is not time to --version-checka again;',
+            _d('It is not time to --version-check again;',
                'only 1 check per', $check_time_limit, 'seconds, and the last',
                'check was performed on the modified time of', $check_time_file);
          }
          return;
       }
 
-      my $dbh = shift;  # optional
       my $advice = pingback(
-         url => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
-         dbh => $dbh,
+         url       => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
+         instances => $instances_to_check,
       );
       if ( $advice ) {
          print "# Percona suggests these upgrades:\n";
@@ -5658,7 +5682,7 @@
    }
    my ($url) = @args{@required_args};
 
-   my ($dbh, $ua, $vc) = @args{qw(dbh ua VersionCheck)};
+   my ($instances, $ua, $vc) = @args{qw(instances ua VersionCheck)};
 
    $ua ||= HTTPMicro->new( timeout => 2 );
    $vc ||= VersionCheck->new();
@@ -5677,24 +5701,27 @@
    );
    die "Failed to parse server requested programs: $response->{content}"
       if !scalar keys %$items;
-
+      
    my $versions = $vc->get_versions(
-      items => $items,
-      dbh   => $dbh,
+      items     => $items,
+      instances => $instances,
    );
    die "Failed to get any program versions; should have at least gotten Perl"
       if !scalar keys %$versions;
 
    my $client_content = encode_client_response(
-      items    => $items,
-      versions => $versions,
+      items      => $items,
+      versions   => $versions,
+      general_id => md5_hex( hostname() ),
    );
 
    my $client_response = {
       headers => { "X-Percona-Toolkit-Tool" => File::Basename::basename($0) },
       content => $client_content,
    };
-   PTDEBUG && _d('Client response:', Dumper($client_response));
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Client response:', Dumper($client_response));
+   }
 
    $response = $ua->request('POST', $url, $client_response);
    PTDEBUG && _d('Server suggestions:', Dumper($response));
@@ -5719,22 +5746,35 @@
 }
 
 sub time_to_check {
-   my ($file) = @_;
+   my ($file, $instances) = @_;
    die "I need a file argument" unless $file;
 
+   my $created_file = 0;
    if ( !-f $file ) {
-      PTDEBUG && _d('Creating', $file);
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Creating time limit file', $file);
+      }
       _touch($file);
-      return 1;
-   }
+      $created_file = 1;
+   }
+   elsif ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Time limit file already exists:', $file);
+   }
+
+   my $time = int(time());  # current time
+
+   if ( @$instances ) {
+      my $instances_to_check = instances_to_check($file, $instances, $time);
+      return scalar @$instances_to_check, $instances_to_check;
+   }
+
+   return 1 if $created_file;
 
    my $mtime  = (stat $file)[9];
    if ( !defined $mtime ) {
       PTDEBUG && _d('Error getting modified time of', $file);
       return 0;
    }
-
-   my $time = int(time());
    PTDEBUG && _d('time=', $time, 'mtime=', $mtime);
    if ( ($time - $mtime) > $check_time_limit ) {
       _touch($file);
@@ -5744,6 +5784,36 @@
    return 0;
 }
 
+sub instances_to_check {
+   my ($file, $instances, $time) = @_;
+
+   open my $fh, '<', $file or die "Cannot open $file: $OS_ERROR";
+   my $file_contents = do { local $/ = undef; <$fh> };
+   close $fh;
+   chomp($file_contents);
+   my %cached_instances = $file_contents =~ /^([^,]+),(.+)$/mg;
+
+   my @instances_to_check;
+   foreach my $instance ( @$instances ) {
+      my $mtime = $cached_instances{ $instance->{id} };
+      if ( !$mtime || (($time - $mtime) > $check_time_limit) ) {
+         if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+            _d('Time to check MySQL instance', $instance->{name});
+         }
+         push @instances_to_check, $instance;
+         $cached_instances{ $instance->{id} } = $time;
+      }
+   }
+
+   open $fh, '>', $file or die "Cannot open $file for writing: $OS_ERROR";
+   while ( my ($id, $time) = each %cached_instances ) {
+      print { $fh } "$id,$time\n";
+   }
+   close $fh or die "Cannot close $file: $OS_ERROR";
+
+   return \@instances_to_check;
+}
+
 sub _touch {
    my ($file) = @_;
    sysopen my $fh, $file, O_WRONLY|O_CREAT|O_NONBLOCK
@@ -5752,22 +5822,48 @@
    utime(undef, undef, $file);
 }
 
+sub _generate_identifier {
+   my $instance = shift;
+   my $dbh      = $instance->{dbh};
+   my $dsn      = $instance->{dsn};
+
+   my $sql    = q{SELECT CONCAT(@@hostname, @@port)};
+   my ($name) = eval { $dbh->selectrow_array($sql) };
+   if ( $EVAL_ERROR ) { # assume that it's MySQL 4.x
+      $name = ($dsn->{h} || 'localhost') . ($dsn->{P} || 3306);
+   }
+   my $id = md5_hex($name);
+
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('MySQL instance', $name, 'is', $id);
+   }
+
+   return $name, $id;
+}
+
 sub encode_client_response {
    my (%args) = @_;
-   my @required_args = qw(items versions);
+   my @required_args = qw(items versions general_id);
    foreach my $arg ( @required_args ) {
       die "I need a $arg arugment" unless $args{$arg};
    }
-   my ($items, $versions) = @args{@required_args};
+   my ($items, $versions, $general_id) = @args{@required_args};
 
    my @lines;
    foreach my $item ( sort keys %$items ) {
       next unless exists $versions->{$item};
-      push @lines, join(';', $item, $versions->{$item});
+      if ( ref($versions->{$item}) eq 'HASH' ) {
+         my $mysql_versions = $versions->{$item};
+         for my $id ( keys %$mysql_versions ) {
+            push @lines, join(';', $id, $item, $mysql_versions->{$id});
+         }
+      }
+      else {
+         push @lines, join(';', $general_id, $item, $versions->{$item});
+      }
    }
 
    my $client_response = join("\n", @lines) . "\n";
-   PTDEBUG && _d('Client response:', $client_response);
    return $client_response;
 }
 
@@ -6135,7 +6231,9 @@
    # Do the version-check
    # ########################################################################
    if ( $o->get('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
-      Pingback::version_check($dbh);
+      Pingback::version_check(
+         ($dbh ? { dbh => $dbh, dsn => $cxn->dsn() } : ())
+      );
    }
 
    # ########################################################################

=== modified file 'bin/pt-online-schema-change'
--- bin/pt-online-schema-change	2012-08-24 23:26:04 +0000
+++ bin/pt-online-schema-change	2012-08-28 21:31:19 +0000
@@ -50,6 +50,7 @@
 {
 package Percona::Toolkit;
 our $VERSION = '2.1.3';
+
 1;
 }
 # ###########################################################################
@@ -5952,20 +5953,19 @@
       die "I need a $arg arugment" unless $args{$arg};
    }
    my ($items) = @args{@required_args};
-   my $dbh     = $args{dbh}; # optional
 
    my %versions;
    foreach my $item ( values %$items ) {
       next unless $self->valid_item($item);
-      
+
       eval {
          my $func    = 'get_' . $item->{type};
          my $version = $self->$func(
-            item => $item,
-            dbh  => $dbh,
+            item      => $item,
+            instances => $args{instances},
          );
          if ( $version ) {
-            chomp $version;
+            chomp $version unless ref($version);
             $versions{$item->{item}} = $version;
          }
       };
@@ -6090,28 +6090,42 @@
    );
 }
 
-
 sub _get_from_mysql {
    my ($self, %args) = @_;
-   my $show = $args{show};
-   my $item = $args{item};
-   my $dbh  = $args{dbh};
-   return unless $show && $item && $dbh;
+   my $show      = $args{show};
+   my $item      = $args{item};
+   my $instances = $args{instances};
+   return unless $show && $item;
 
-   local $dbh->{FetchHashKeyName} = 'NAME_lc';
-   my $sql = qq/SHOW $show/;
-   PTDEBUG && _d($sql);
-   my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+   if ( !$instances || !@$instances ) {
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Cannot check', $item, 'because there are no MySQL instances');
+      }
+      return;
+   }
 
    my @versions;
-   foreach my $var ( @{$item->{vars}} ) {
-      $var = lc($var);
-      my $version = $rows->{$var}->{value};
-      PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version);
-      push @versions, $version;
+   my %version_for;
+   foreach my $instance ( @$instances ) {
+      my $dbh = $instance->{dbh};
+      local $dbh->{FetchHashKeyName} = 'NAME_lc';
+      my $sql = qq/SHOW $show/;
+      PTDEBUG && _d($sql);
+      my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+
+      my @versions;
+      foreach my $var ( @{$item->{vars}} ) {
+         $var = lc($var);
+         my $version = $rows->{$var}->{value};
+         PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version,
+            'on', $instance->{name});
+         push @versions, $version;
+      }
+
+      $version_for{ $instance->{id} } = join(' ', @versions);
    }
 
-   return join(' ', @versions);
+   return \%version_for;
 }
 
 sub get_bin_version {
@@ -6609,14 +6623,15 @@
 
 use constant PTDEBUG => $ENV{PTDEBUG} || 0;
 
-use File::Basename qw();
 use Data::Dumper   qw();
+use Digest::MD5    qw(md5_hex);
+use Sys::Hostname  qw(hostname);
 use Fcntl          qw(:DEFAULT);
-
+use File::Basename qw();
 use File::Spec;
 
-my $dir = File::Spec->tmpdir();
-my $check_time_file = File::Spec->catfile($dir,'percona-toolkit-version-check');
+my $dir              = File::Spec->tmpdir();
+my $check_time_file  = File::Spec->catfile($dir,'percona-toolkit-version-check');
 my $check_time_limit = 60 * 60 * 24;  # one day
 
 sub Dumper {
@@ -6629,11 +6644,13 @@
 
 local $EVAL_ERROR;
 eval {
+   require Percona::Toolkit;
    require HTTPMicro;
    require VersionCheck;
 };
 
 sub version_check {
+   my @instances = @_;
    eval {
       if (exists $ENV{PERCONA_VERSION_CHECK} && !$ENV{PERCONA_VERSION_CHECK}) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
@@ -6643,19 +6660,26 @@
          return;
       } 
 
-      if ( !time_to_check($check_time_file) ) {
+      foreach my $instance ( @instances ) {
+         my ($name, $id) = _generate_identifier($instance);
+         $instance->{name} = $name;
+         $instance->{id}   = $id;
+      }
+
+      my ($time_to_check, $instances_to_check)
+         = time_to_check($check_time_file, \@instances);
+      if ( !$time_to_check ) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
-            _d('It is not time to --version-checka again;',
+            _d('It is not time to --version-check again;',
                'only 1 check per', $check_time_limit, 'seconds, and the last',
                'check was performed on the modified time of', $check_time_file);
          }
          return;
       }
 
-      my $dbh = shift;  # optional
       my $advice = pingback(
-         url => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
-         dbh => $dbh,
+         url       => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
+         instances => $instances_to_check,
       );
       if ( $advice ) {
          print "# Percona suggests these upgrades:\n";
@@ -6683,7 +6707,7 @@
    }
    my ($url) = @args{@required_args};
 
-   my ($dbh, $ua, $vc) = @args{qw(dbh ua VersionCheck)};
+   my ($instances, $ua, $vc) = @args{qw(instances ua VersionCheck)};
 
    $ua ||= HTTPMicro->new( timeout => 2 );
    $vc ||= VersionCheck->new();
@@ -6702,24 +6726,27 @@
    );
    die "Failed to parse server requested programs: $response->{content}"
       if !scalar keys %$items;
-
+      
    my $versions = $vc->get_versions(
-      items => $items,
-      dbh   => $dbh,
+      items     => $items,
+      instances => $instances,
    );
    die "Failed to get any program versions; should have at least gotten Perl"
       if !scalar keys %$versions;
 
    my $client_content = encode_client_response(
-      items    => $items,
-      versions => $versions,
+      items      => $items,
+      versions   => $versions,
+      general_id => md5_hex( hostname() ),
    );
 
    my $client_response = {
       headers => { "X-Percona-Toolkit-Tool" => File::Basename::basename($0) },
       content => $client_content,
    };
-   PTDEBUG && _d('Client response:', Dumper($client_response));
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Client response:', Dumper($client_response));
+   }
 
    $response = $ua->request('POST', $url, $client_response);
    PTDEBUG && _d('Server suggestions:', Dumper($response));
@@ -6744,22 +6771,35 @@
 }
 
 sub time_to_check {
-   my ($file) = @_;
+   my ($file, $instances) = @_;
    die "I need a file argument" unless $file;
 
+   my $created_file = 0;
    if ( !-f $file ) {
-      PTDEBUG && _d('Creating', $file);
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Creating time limit file', $file);
+      }
       _touch($file);
-      return 1;
-   }
+      $created_file = 1;
+   }
+   elsif ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Time limit file already exists:', $file);
+   }
+
+   my $time = int(time());  # current time
+
+   if ( @$instances ) {
+      my $instances_to_check = instances_to_check($file, $instances, $time);
+      return scalar @$instances_to_check, $instances_to_check;
+   }
+
+   return 1 if $created_file;
 
    my $mtime  = (stat $file)[9];
    if ( !defined $mtime ) {
       PTDEBUG && _d('Error getting modified time of', $file);
       return 0;
    }
-
-   my $time = int(time());
    PTDEBUG && _d('time=', $time, 'mtime=', $mtime);
    if ( ($time - $mtime) > $check_time_limit ) {
       _touch($file);
@@ -6769,6 +6809,36 @@
    return 0;
 }
 
+sub instances_to_check {
+   my ($file, $instances, $time) = @_;
+
+   open my $fh, '<', $file or die "Cannot open $file: $OS_ERROR";
+   my $file_contents = do { local $/ = undef; <$fh> };
+   close $fh;
+   chomp($file_contents);
+   my %cached_instances = $file_contents =~ /^([^,]+),(.+)$/mg;
+
+   my @instances_to_check;
+   foreach my $instance ( @$instances ) {
+      my $mtime = $cached_instances{ $instance->{id} };
+      if ( !$mtime || (($time - $mtime) > $check_time_limit) ) {
+         if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+            _d('Time to check MySQL instance', $instance->{name});
+         }
+         push @instances_to_check, $instance;
+         $cached_instances{ $instance->{id} } = $time;
+      }
+   }
+
+   open $fh, '>', $file or die "Cannot open $file for writing: $OS_ERROR";
+   while ( my ($id, $time) = each %cached_instances ) {
+      print { $fh } "$id,$time\n";
+   }
+   close $fh or die "Cannot close $file: $OS_ERROR";
+
+   return \@instances_to_check;
+}
+
 sub _touch {
    my ($file) = @_;
    sysopen my $fh, $file, O_WRONLY|O_CREAT|O_NONBLOCK
@@ -6777,22 +6847,48 @@
    utime(undef, undef, $file);
 }
 
+sub _generate_identifier {
+   my $instance = shift;
+   my $dbh      = $instance->{dbh};
+   my $dsn      = $instance->{dsn};
+
+   my $sql    = q{SELECT CONCAT(@@hostname, @@port)};
+   my ($name) = eval { $dbh->selectrow_array($sql) };
+   if ( $EVAL_ERROR ) { # assume that it's MySQL 4.x
+      $name = ($dsn->{h} || 'localhost') . ($dsn->{P} || 3306);
+   }
+   my $id = md5_hex($name);
+
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('MySQL instance', $name, 'is', $id);
+   }
+
+   return $name, $id;
+}
+
 sub encode_client_response {
    my (%args) = @_;
-   my @required_args = qw(items versions);
+   my @required_args = qw(items versions general_id);
    foreach my $arg ( @required_args ) {
       die "I need a $arg arugment" unless $args{$arg};
    }
-   my ($items, $versions) = @args{@required_args};
+   my ($items, $versions, $general_id) = @args{@required_args};
 
    my @lines;
    foreach my $item ( sort keys %$items ) {
       next unless exists $versions->{$item};
-      push @lines, join(';', $item, $versions->{$item});
+      if ( ref($versions->{$item}) eq 'HASH' ) {
+         my $mysql_versions = $versions->{$item};
+         for my $id ( keys %$mysql_versions ) {
+            push @lines, join(';', $id, $item, $mysql_versions->{$id});
+         }
+      }
+      else {
+         push @lines, join(';', $general_id, $item, $versions->{$item});
+      }
    }
 
    my $client_response = join("\n", @lines) . "\n";
-   PTDEBUG && _d('Client response:', $client_response);
    return $client_response;
 }
 
@@ -7029,13 +7125,6 @@
    }
 
    # ########################################################################
-   # Do the version-check
-   # ########################################################################
-   if ( $o->get('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
-      Pingback::version_check($cxn->dbh());
-   }
-
-   # ########################################################################
    # Setup lag and load monitors.
    # ########################################################################   
    my $slaves;         # all slaves that are found or specified
@@ -7203,6 +7292,16 @@
    }
 
    # ########################################################################
+   # Do the version-check
+   # ########################################################################
+   if ( $o->get('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
+      Pingback::version_check(
+         map { +{ dbh => $_->dbh(), dsn => $_->dsn() } }
+            $cxn, ($slaves ? @$slaves : ())
+      );
+   }
+   
+   # ########################################################################
    # Setup and check the original table.
    # ########################################################################
    my $tp = new TableParser(Quoter => $q);

=== modified file 'bin/pt-query-advisor'
--- bin/pt-query-advisor	2012-08-24 23:26:04 +0000
+++ bin/pt-query-advisor	2012-08-28 21:31:19 +0000
@@ -47,6 +47,7 @@
 {
 package Percona::Toolkit;
 our $VERSION = '2.1.3';
+
 1;
 }
 # ###########################################################################
@@ -6114,20 +6115,19 @@
       die "I need a $arg arugment" unless $args{$arg};
    }
    my ($items) = @args{@required_args};
-   my $dbh     = $args{dbh}; # optional
 
    my %versions;
    foreach my $item ( values %$items ) {
       next unless $self->valid_item($item);
-      
+
       eval {
          my $func    = 'get_' . $item->{type};
          my $version = $self->$func(
-            item => $item,
-            dbh  => $dbh,
+            item      => $item,
+            instances => $args{instances},
          );
          if ( $version ) {
-            chomp $version;
+            chomp $version unless ref($version);
             $versions{$item->{item}} = $version;
          }
       };
@@ -6252,28 +6252,42 @@
    );
 }
 
-
 sub _get_from_mysql {
    my ($self, %args) = @_;
-   my $show = $args{show};
-   my $item = $args{item};
-   my $dbh  = $args{dbh};
-   return unless $show && $item && $dbh;
+   my $show      = $args{show};
+   my $item      = $args{item};
+   my $instances = $args{instances};
+   return unless $show && $item;
 
-   local $dbh->{FetchHashKeyName} = 'NAME_lc';
-   my $sql = qq/SHOW $show/;
-   PTDEBUG && _d($sql);
-   my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+   if ( !$instances || !@$instances ) {
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Cannot check', $item, 'because there are no MySQL instances');
+      }
+      return;
+   }
 
    my @versions;
-   foreach my $var ( @{$item->{vars}} ) {
-      $var = lc($var);
-      my $version = $rows->{$var}->{value};
-      PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version);
-      push @versions, $version;
+   my %version_for;
+   foreach my $instance ( @$instances ) {
+      my $dbh = $instance->{dbh};
+      local $dbh->{FetchHashKeyName} = 'NAME_lc';
+      my $sql = qq/SHOW $show/;
+      PTDEBUG && _d($sql);
+      my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+
+      my @versions;
+      foreach my $var ( @{$item->{vars}} ) {
+         $var = lc($var);
+         my $version = $rows->{$var}->{value};
+         PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version,
+            'on', $instance->{name});
+         push @versions, $version;
+      }
+
+      $version_for{ $instance->{id} } = join(' ', @versions);
    }
 
-   return join(' ', @versions);
+   return \%version_for;
 }
 
 sub get_bin_version {
@@ -6771,14 +6785,15 @@
 
 use constant PTDEBUG => $ENV{PTDEBUG} || 0;
 
-use File::Basename qw();
 use Data::Dumper   qw();
+use Digest::MD5    qw(md5_hex);
+use Sys::Hostname  qw(hostname);
 use Fcntl          qw(:DEFAULT);
-
+use File::Basename qw();
 use File::Spec;
 
-my $dir = File::Spec->tmpdir();
-my $check_time_file = File::Spec->catfile($dir,'percona-toolkit-version-check');
+my $dir              = File::Spec->tmpdir();
+my $check_time_file  = File::Spec->catfile($dir,'percona-toolkit-version-check');
 my $check_time_limit = 60 * 60 * 24;  # one day
 
 sub Dumper {
@@ -6791,11 +6806,13 @@
 
 local $EVAL_ERROR;
 eval {
+   require Percona::Toolkit;
    require HTTPMicro;
    require VersionCheck;
 };
 
 sub version_check {
+   my @instances = @_;
    eval {
       if (exists $ENV{PERCONA_VERSION_CHECK} && !$ENV{PERCONA_VERSION_CHECK}) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
@@ -6805,19 +6822,26 @@
          return;
       } 
 
-      if ( !time_to_check($check_time_file) ) {
+      foreach my $instance ( @instances ) {
+         my ($name, $id) = _generate_identifier($instance);
+         $instance->{name} = $name;
+         $instance->{id}   = $id;
+      }
+
+      my ($time_to_check, $instances_to_check)
+         = time_to_check($check_time_file, \@instances);
+      if ( !$time_to_check ) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
-            _d('It is not time to --version-checka again;',
+            _d('It is not time to --version-check again;',
                'only 1 check per', $check_time_limit, 'seconds, and the last',
                'check was performed on the modified time of', $check_time_file);
          }
          return;
       }
 
-      my $dbh = shift;  # optional
       my $advice = pingback(
-         url => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
-         dbh => $dbh,
+         url       => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
+         instances => $instances_to_check,
       );
       if ( $advice ) {
          print "# Percona suggests these upgrades:\n";
@@ -6845,7 +6869,7 @@
    }
    my ($url) = @args{@required_args};
 
-   my ($dbh, $ua, $vc) = @args{qw(dbh ua VersionCheck)};
+   my ($instances, $ua, $vc) = @args{qw(instances ua VersionCheck)};
 
    $ua ||= HTTPMicro->new( timeout => 2 );
    $vc ||= VersionCheck->new();
@@ -6864,24 +6888,27 @@
    );
    die "Failed to parse server requested programs: $response->{content}"
       if !scalar keys %$items;
-
+      
    my $versions = $vc->get_versions(
-      items => $items,
-      dbh   => $dbh,
+      items     => $items,
+      instances => $instances,
    );
    die "Failed to get any program versions; should have at least gotten Perl"
       if !scalar keys %$versions;
 
    my $client_content = encode_client_response(
-      items    => $items,
-      versions => $versions,
+      items      => $items,
+      versions   => $versions,
+      general_id => md5_hex( hostname() ),
    );
 
    my $client_response = {
       headers => { "X-Percona-Toolkit-Tool" => File::Basename::basename($0) },
       content => $client_content,
    };
-   PTDEBUG && _d('Client response:', Dumper($client_response));
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Client response:', Dumper($client_response));
+   }
 
    $response = $ua->request('POST', $url, $client_response);
    PTDEBUG && _d('Server suggestions:', Dumper($response));
@@ -6906,22 +6933,35 @@
 }
 
 sub time_to_check {
-   my ($file) = @_;
+   my ($file, $instances) = @_;
    die "I need a file argument" unless $file;
 
+   my $created_file = 0;
    if ( !-f $file ) {
-      PTDEBUG && _d('Creating', $file);
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Creating time limit file', $file);
+      }
       _touch($file);
-      return 1;
-   }
+      $created_file = 1;
+   }
+   elsif ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Time limit file already exists:', $file);
+   }
+
+   my $time = int(time());  # current time
+
+   if ( @$instances ) {
+      my $instances_to_check = instances_to_check($file, $instances, $time);
+      return scalar @$instances_to_check, $instances_to_check;
+   }
+
+   return 1 if $created_file;
 
    my $mtime  = (stat $file)[9];
    if ( !defined $mtime ) {
       PTDEBUG && _d('Error getting modified time of', $file);
       return 0;
    }
-
-   my $time = int(time());
    PTDEBUG && _d('time=', $time, 'mtime=', $mtime);
    if ( ($time - $mtime) > $check_time_limit ) {
       _touch($file);
@@ -6931,6 +6971,36 @@
    return 0;
 }
 
+sub instances_to_check {
+   my ($file, $instances, $time) = @_;
+
+   open my $fh, '<', $file or die "Cannot open $file: $OS_ERROR";
+   my $file_contents = do { local $/ = undef; <$fh> };
+   close $fh;
+   chomp($file_contents);
+   my %cached_instances = $file_contents =~ /^([^,]+),(.+)$/mg;
+
+   my @instances_to_check;
+   foreach my $instance ( @$instances ) {
+      my $mtime = $cached_instances{ $instance->{id} };
+      if ( !$mtime || (($time - $mtime) > $check_time_limit) ) {
+         if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+            _d('Time to check MySQL instance', $instance->{name});
+         }
+         push @instances_to_check, $instance;
+         $cached_instances{ $instance->{id} } = $time;
+      }
+   }
+
+   open $fh, '>', $file or die "Cannot open $file for writing: $OS_ERROR";
+   while ( my ($id, $time) = each %cached_instances ) {
+      print { $fh } "$id,$time\n";
+   }
+   close $fh or die "Cannot close $file: $OS_ERROR";
+
+   return \@instances_to_check;
+}
+
 sub _touch {
    my ($file) = @_;
    sysopen my $fh, $file, O_WRONLY|O_CREAT|O_NONBLOCK
@@ -6939,22 +7009,48 @@
    utime(undef, undef, $file);
 }
 
+sub _generate_identifier {
+   my $instance = shift;
+   my $dbh      = $instance->{dbh};
+   my $dsn      = $instance->{dsn};
+
+   my $sql    = q{SELECT CONCAT(@@hostname, @@port)};
+   my ($name) = eval { $dbh->selectrow_array($sql) };
+   if ( $EVAL_ERROR ) { # assume that it's MySQL 4.x
+      $name = ($dsn->{h} || 'localhost') . ($dsn->{P} || 3306);
+   }
+   my $id = md5_hex($name);
+
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('MySQL instance', $name, 'is', $id);
+   }
+
+   return $name, $id;
+}
+
 sub encode_client_response {
    my (%args) = @_;
-   my @required_args = qw(items versions);
+   my @required_args = qw(items versions general_id);
    foreach my $arg ( @required_args ) {
       die "I need a $arg arugment" unless $args{$arg};
    }
-   my ($items, $versions) = @args{@required_args};
+   my ($items, $versions, $general_id) = @args{@required_args};
 
    my @lines;
    foreach my $item ( sort keys %$items ) {
       next unless exists $versions->{$item};
-      push @lines, join(';', $item, $versions->{$item});
+      if ( ref($versions->{$item}) eq 'HASH' ) {
+         my $mysql_versions = $versions->{$item};
+         for my $id ( keys %$mysql_versions ) {
+            push @lines, join(';', $id, $item, $mysql_versions->{$id});
+         }
+      }
+      else {
+         push @lines, join(';', $general_id, $item, $versions->{$item});
+      }
    }
 
    my $client_response = join("\n", @lines) . "\n";
-   PTDEBUG && _d('Client response:', $client_response);
    return $client_response;
 }
 
@@ -7091,10 +7187,11 @@
    # #########################################################################
    # Try to connect to MySQL.
    # #########################################################################
-   my $dbh;
+   my ($dbh, $dsn);
    eval {
+      $dsn = $dp->parse_options($o);
       $dbh = get_cxn(
-         dsn => $dp->parse_options($o),
+         dsn => $dsn,
          %common_modules
       );
    };
@@ -7364,7 +7461,10 @@
    # Do the version-check
    # ########################################################################
    if ( $o->get('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
-      Pingback::version_check($dbh);
+      Pingback::version_check(
+         ($review_dbh ? { dbh => $review_dbh, dsn => $review_dsn } : ()),
+         ($dbh        ? { dbh => $dbh,        dsn => $dsn        } : ()),
+      );
    }
 
    # #########################################################################

=== modified file 'bin/pt-query-digest'
--- bin/pt-query-digest	2012-08-24 23:26:04 +0000
+++ bin/pt-query-digest	2012-08-28 21:31:19 +0000
@@ -64,6 +64,7 @@
 {
 package Percona::Toolkit;
 our $VERSION = '2.1.3';
+
 1;
 }
 # ###########################################################################
@@ -11966,20 +11967,19 @@
       die "I need a $arg arugment" unless $args{$arg};
    }
    my ($items) = @args{@required_args};
-   my $dbh     = $args{dbh}; # optional
 
    my %versions;
    foreach my $item ( values %$items ) {
       next unless $self->valid_item($item);
-      
+
       eval {
          my $func    = 'get_' . $item->{type};
          my $version = $self->$func(
-            item => $item,
-            dbh  => $dbh,
+            item      => $item,
+            instances => $args{instances},
          );
          if ( $version ) {
-            chomp $version;
+            chomp $version unless ref($version);
             $versions{$item->{item}} = $version;
          }
       };
@@ -12104,28 +12104,42 @@
    );
 }
 
-
 sub _get_from_mysql {
    my ($self, %args) = @_;
-   my $show = $args{show};
-   my $item = $args{item};
-   my $dbh  = $args{dbh};
-   return unless $show && $item && $dbh;
+   my $show      = $args{show};
+   my $item      = $args{item};
+   my $instances = $args{instances};
+   return unless $show && $item;
 
-   local $dbh->{FetchHashKeyName} = 'NAME_lc';
-   my $sql = qq/SHOW $show/;
-   PTDEBUG && _d($sql);
-   my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+   if ( !$instances || !@$instances ) {
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Cannot check', $item, 'because there are no MySQL instances');
+      }
+      return;
+   }
 
    my @versions;
-   foreach my $var ( @{$item->{vars}} ) {
-      $var = lc($var);
-      my $version = $rows->{$var}->{value};
-      PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version);
-      push @versions, $version;
+   my %version_for;
+   foreach my $instance ( @$instances ) {
+      my $dbh = $instance->{dbh};
+      local $dbh->{FetchHashKeyName} = 'NAME_lc';
+      my $sql = qq/SHOW $show/;
+      PTDEBUG && _d($sql);
+      my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+
+      my @versions;
+      foreach my $var ( @{$item->{vars}} ) {
+         $var = lc($var);
+         my $version = $rows->{$var}->{value};
+         PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version,
+            'on', $instance->{name});
+         push @versions, $version;
+      }
+
+      $version_for{ $instance->{id} } = join(' ', @versions);
    }
 
-   return join(' ', @versions);
+   return \%version_for;
 }
 
 sub get_bin_version {
@@ -12623,14 +12637,15 @@
 
 use constant PTDEBUG => $ENV{PTDEBUG} || 0;
 
-use File::Basename qw();
 use Data::Dumper   qw();
+use Digest::MD5    qw(md5_hex);
+use Sys::Hostname  qw(hostname);
 use Fcntl          qw(:DEFAULT);
-
+use File::Basename qw();
 use File::Spec;
 
-my $dir = File::Spec->tmpdir();
-my $check_time_file = File::Spec->catfile($dir,'percona-toolkit-version-check');
+my $dir              = File::Spec->tmpdir();
+my $check_time_file  = File::Spec->catfile($dir,'percona-toolkit-version-check');
 my $check_time_limit = 60 * 60 * 24;  # one day
 
 sub Dumper {
@@ -12643,11 +12658,13 @@
 
 local $EVAL_ERROR;
 eval {
+   require Percona::Toolkit;
    require HTTPMicro;
    require VersionCheck;
 };
 
 sub version_check {
+   my @instances = @_;
    eval {
       if (exists $ENV{PERCONA_VERSION_CHECK} && !$ENV{PERCONA_VERSION_CHECK}) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
@@ -12657,19 +12674,26 @@
          return;
       } 
 
-      if ( !time_to_check($check_time_file) ) {
+      foreach my $instance ( @instances ) {
+         my ($name, $id) = _generate_identifier($instance);
+         $instance->{name} = $name;
+         $instance->{id}   = $id;
+      }
+
+      my ($time_to_check, $instances_to_check)
+         = time_to_check($check_time_file, \@instances);
+      if ( !$time_to_check ) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
-            _d('It is not time to --version-checka again;',
+            _d('It is not time to --version-check again;',
                'only 1 check per', $check_time_limit, 'seconds, and the last',
                'check was performed on the modified time of', $check_time_file);
          }
          return;
       }
 
-      my $dbh = shift;  # optional
       my $advice = pingback(
-         url => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
-         dbh => $dbh,
+         url       => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
+         instances => $instances_to_check,
       );
       if ( $advice ) {
          print "# Percona suggests these upgrades:\n";
@@ -12697,7 +12721,7 @@
    }
    my ($url) = @args{@required_args};
 
-   my ($dbh, $ua, $vc) = @args{qw(dbh ua VersionCheck)};
+   my ($instances, $ua, $vc) = @args{qw(instances ua VersionCheck)};
 
    $ua ||= HTTPMicro->new( timeout => 2 );
    $vc ||= VersionCheck->new();
@@ -12716,24 +12740,27 @@
    );
    die "Failed to parse server requested programs: $response->{content}"
       if !scalar keys %$items;
-
+      
    my $versions = $vc->get_versions(
-      items => $items,
-      dbh   => $dbh,
+      items     => $items,
+      instances => $instances,
    );
    die "Failed to get any program versions; should have at least gotten Perl"
       if !scalar keys %$versions;
 
    my $client_content = encode_client_response(
-      items    => $items,
-      versions => $versions,
+      items      => $items,
+      versions   => $versions,
+      general_id => md5_hex( hostname() ),
    );
 
    my $client_response = {
       headers => { "X-Percona-Toolkit-Tool" => File::Basename::basename($0) },
       content => $client_content,
    };
-   PTDEBUG && _d('Client response:', Dumper($client_response));
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Client response:', Dumper($client_response));
+   }
 
    $response = $ua->request('POST', $url, $client_response);
    PTDEBUG && _d('Server suggestions:', Dumper($response));
@@ -12758,22 +12785,35 @@
 }
 
 sub time_to_check {
-   my ($file) = @_;
+   my ($file, $instances) = @_;
    die "I need a file argument" unless $file;
 
+   my $created_file = 0;
    if ( !-f $file ) {
-      PTDEBUG && _d('Creating', $file);
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Creating time limit file', $file);
+      }
       _touch($file);
-      return 1;
-   }
+      $created_file = 1;
+   }
+   elsif ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Time limit file already exists:', $file);
+   }
+
+   my $time = int(time());  # current time
+
+   if ( @$instances ) {
+      my $instances_to_check = instances_to_check($file, $instances, $time);
+      return scalar @$instances_to_check, $instances_to_check;
+   }
+
+   return 1 if $created_file;
 
    my $mtime  = (stat $file)[9];
    if ( !defined $mtime ) {
       PTDEBUG && _d('Error getting modified time of', $file);
       return 0;
    }
-
-   my $time = int(time());
    PTDEBUG && _d('time=', $time, 'mtime=', $mtime);
    if ( ($time - $mtime) > $check_time_limit ) {
       _touch($file);
@@ -12783,6 +12823,36 @@
    return 0;
 }
 
+sub instances_to_check {
+   my ($file, $instances, $time) = @_;
+
+   open my $fh, '<', $file or die "Cannot open $file: $OS_ERROR";
+   my $file_contents = do { local $/ = undef; <$fh> };
+   close $fh;
+   chomp($file_contents);
+   my %cached_instances = $file_contents =~ /^([^,]+),(.+)$/mg;
+
+   my @instances_to_check;
+   foreach my $instance ( @$instances ) {
+      my $mtime = $cached_instances{ $instance->{id} };
+      if ( !$mtime || (($time - $mtime) > $check_time_limit) ) {
+         if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+            _d('Time to check MySQL instance', $instance->{name});
+         }
+         push @instances_to_check, $instance;
+         $cached_instances{ $instance->{id} } = $time;
+      }
+   }
+
+   open $fh, '>', $file or die "Cannot open $file for writing: $OS_ERROR";
+   while ( my ($id, $time) = each %cached_instances ) {
+      print { $fh } "$id,$time\n";
+   }
+   close $fh or die "Cannot close $file: $OS_ERROR";
+
+   return \@instances_to_check;
+}
+
 sub _touch {
    my ($file) = @_;
    sysopen my $fh, $file, O_WRONLY|O_CREAT|O_NONBLOCK
@@ -12791,22 +12861,48 @@
    utime(undef, undef, $file);
 }
 
+sub _generate_identifier {
+   my $instance = shift;
+   my $dbh      = $instance->{dbh};
+   my $dsn      = $instance->{dsn};
+
+   my $sql    = q{SELECT CONCAT(@@hostname, @@port)};
+   my ($name) = eval { $dbh->selectrow_array($sql) };
+   if ( $EVAL_ERROR ) { # assume that it's MySQL 4.x
+      $name = ($dsn->{h} || 'localhost') . ($dsn->{P} || 3306);
+   }
+   my $id = md5_hex($name);
+
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('MySQL instance', $name, 'is', $id);
+   }
+
+   return $name, $id;
+}
+
 sub encode_client_response {
    my (%args) = @_;
-   my @required_args = qw(items versions);
+   my @required_args = qw(items versions general_id);
    foreach my $arg ( @required_args ) {
       die "I need a $arg arugment" unless $args{$arg};
    }
-   my ($items, $versions) = @args{@required_args};
+   my ($items, $versions, $general_id) = @args{@required_args};
 
    my @lines;
    foreach my $item ( sort keys %$items ) {
       next unless exists $versions->{$item};
-      push @lines, join(';', $item, $versions->{$item});
+      if ( ref($versions->{$item}) eq 'HASH' ) {
+         my $mysql_versions = $versions->{$item};
+         for my $id ( keys %$mysql_versions ) {
+            push @lines, join(';', $id, $item, $mysql_versions->{$id});
+         }
+      }
+      else {
+         push @lines, join(';', $general_id, $item, $versions->{$item});
+      }
    }
 
    my $client_response = join("\n", @lines) . "\n";
-   PTDEBUG && _d('Client response:', $client_response);
    return $client_response;
 }
 
@@ -13231,9 +13327,10 @@
       );
    } # input
 
+   my $ps_dsn;
    { # event
       my $misc;
-      if ( my $ps_dsn = $o->get('processlist') ) {
+      if ( $ps_dsn = $o->get('processlist') ) {
          my $ms = new MasterSlave(
             OptionParser => $o,
             DSNParser    => $dp,
@@ -13929,6 +14026,7 @@
       }
    } # sample
 
+   my $ex_dsn;
    { # execute throttle and execute
       my $et;
       if ( my $et_args = $o->get('execute-throttle') ) {
@@ -13967,7 +14065,7 @@
          );
       } # execute throttle
 
-      if ( my $ex_dsn = $o->get('execute') ) {
+      if ( $ex_dsn = $o->get('execute') ) {
          if ( $o->get('ask-pass') ) {
             $ex_dsn->{p} = OptionParser::prompt_noecho("Enter password for "
                . "--execute: ");
@@ -14165,7 +14263,11 @@
    # Do the version-check
    # ########################################################################
    if ( $o->get('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
-      Pingback::version_check($qv_dbh || $ps_dbh || $ex_dbh);
+      Pingback::version_check(
+         ($qv_dbh ? { dbh => $qv_dbh, dsn => $review_dsn } : ()),
+         ($ps_dbh ? { dbh => $ps_dbh, dsn => $ps_dsn     } : ()),
+         ($ex_dbh ? { dbh => $ex_dbh, dsn => $ex_dsn     } : ()),
+      );
    }
 
    # ##########################################################################

=== modified file 'bin/pt-slave-delay'
--- bin/pt-slave-delay	2012-08-23 16:22:43 +0000
+++ bin/pt-slave-delay	2012-08-28 21:31:19 +0000
@@ -37,6 +37,7 @@
 {
 package Percona::Toolkit;
 our $VERSION = '2.1.3';
+
 1;
 }
 # ###########################################################################
@@ -2582,20 +2583,19 @@
       die "I need a $arg arugment" unless $args{$arg};
    }
    my ($items) = @args{@required_args};
-   my $dbh     = $args{dbh}; # optional
 
    my %versions;
    foreach my $item ( values %$items ) {
       next unless $self->valid_item($item);
-      
+
       eval {
          my $func    = 'get_' . $item->{type};
          my $version = $self->$func(
-            item => $item,
-            dbh  => $dbh,
+            item      => $item,
+            instances => $args{instances},
          );
          if ( $version ) {
-            chomp $version;
+            chomp $version unless ref($version);
             $versions{$item->{item}} = $version;
          }
       };
@@ -2720,28 +2720,42 @@
    );
 }
 
-
 sub _get_from_mysql {
    my ($self, %args) = @_;
-   my $show = $args{show};
-   my $item = $args{item};
-   my $dbh  = $args{dbh};
-   return unless $show && $item && $dbh;
+   my $show      = $args{show};
+   my $item      = $args{item};
+   my $instances = $args{instances};
+   return unless $show && $item;
 
-   local $dbh->{FetchHashKeyName} = 'NAME_lc';
-   my $sql = qq/SHOW $show/;
-   PTDEBUG && _d($sql);
-   my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+   if ( !$instances || !@$instances ) {
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Cannot check', $item, 'because there are no MySQL instances');
+      }
+      return;
+   }
 
    my @versions;
-   foreach my $var ( @{$item->{vars}} ) {
-      $var = lc($var);
-      my $version = $rows->{$var}->{value};
-      PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version);
-      push @versions, $version;
+   my %version_for;
+   foreach my $instance ( @$instances ) {
+      my $dbh = $instance->{dbh};
+      local $dbh->{FetchHashKeyName} = 'NAME_lc';
+      my $sql = qq/SHOW $show/;
+      PTDEBUG && _d($sql);
+      my $rows = $dbh->selectall_hashref($sql, 'variable_name');
+
+      my @versions;
+      foreach my $var ( @{$item->{vars}} ) {
+         $var = lc($var);
+         my $version = $rows->{$var}->{value};
+         PTDEBUG && _d('MySQL version for', $item->{item}, '=', $version,
+            'on', $instance->{name});
+         push @versions, $version;
+      }
+
+      $version_for{ $instance->{id} } = join(' ', @versions);
    }
 
-   return join(' ', @versions);
+   return \%version_for;
 }
 
 sub get_bin_version {
@@ -3239,14 +3253,15 @@
 
 use constant PTDEBUG => $ENV{PTDEBUG} || 0;
 
-use File::Basename qw();
 use Data::Dumper   qw();
+use Digest::MD5    qw(md5_hex);
+use Sys::Hostname  qw(hostname);
 use Fcntl          qw(:DEFAULT);
-
+use File::Basename qw();
 use File::Spec;
 
-my $dir = File::Spec->tmpdir();
-my $check_time_file = File::Spec->catfile($dir,'percona-toolkit-version-check');
+my $dir              = File::Spec->tmpdir();
+my $check_time_file  = File::Spec->catfile($dir,'percona-toolkit-version-check');
 my $check_time_limit = 60 * 60 * 24;  # one day
 
 sub Dumper {
@@ -3259,11 +3274,13 @@
 
 local $EVAL_ERROR;
 eval {
+   require Percona::Toolkit;
    require HTTPMicro;
    require VersionCheck;
 };
 
 sub version_check {
+   my @instances = @_;
    eval {
       if (exists $ENV{PERCONA_VERSION_CHECK} && !$ENV{PERCONA_VERSION_CHECK}) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
@@ -3273,19 +3290,26 @@
          return;
       } 
 
-      if ( !time_to_check($check_time_file) ) {
+      foreach my $instance ( @instances ) {
+         my ($name, $id) = _generate_identifier($instance);
+         $instance->{name} = $name;
+         $instance->{id}   = $id;
+      }
+
+      my ($time_to_check, $instances_to_check)
+         = time_to_check($check_time_file, \@instances);
+      if ( !$time_to_check ) {
          if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
-            _d('It is not time to --version-checka again;',
+            _d('It is not time to --version-check again;',
                'only 1 check per', $check_time_limit, 'seconds, and the last',
                'check was performed on the modified time of', $check_time_file);
          }
          return;
       }
 
-      my $dbh = shift;  # optional
       my $advice = pingback(
-         url => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
-         dbh => $dbh,
+         url       => $ENV{PERCONA_VERSION_CHECK_URL} || 'http://v.percona.com',
+         instances => $instances_to_check,
       );
       if ( $advice ) {
          print "# Percona suggests these upgrades:\n";
@@ -3313,7 +3337,7 @@
    }
    my ($url) = @args{@required_args};
 
-   my ($dbh, $ua, $vc) = @args{qw(dbh ua VersionCheck)};
+   my ($instances, $ua, $vc) = @args{qw(instances ua VersionCheck)};
 
    $ua ||= HTTPMicro->new( timeout => 2 );
    $vc ||= VersionCheck->new();
@@ -3332,24 +3356,27 @@
    );
    die "Failed to parse server requested programs: $response->{content}"
       if !scalar keys %$items;
-
+      
    my $versions = $vc->get_versions(
-      items => $items,
-      dbh   => $dbh,
+      items     => $items,
+      instances => $instances,
    );
    die "Failed to get any program versions; should have at least gotten Perl"
       if !scalar keys %$versions;
 
    my $client_content = encode_client_response(
-      items    => $items,
-      versions => $versions,
+      items      => $items,
+      versions   => $versions,
+      general_id => md5_hex( hostname() ),
    );
 
    my $client_response = {
       headers => { "X-Percona-Toolkit-Tool" => File::Basename::basename($0) },
       content => $client_content,
    };
-   PTDEBUG && _d('Client response:', Dumper($client_response));
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Client response:', Dumper($client_response));
+   }
 
    $response = $ua->request('POST', $url, $client_response);
    PTDEBUG && _d('Server suggestions:', Dumper($response));
@@ -3374,22 +3401,35 @@
 }
 
 sub time_to_check {
-   my ($file) = @_;
+   my ($file, $instances) = @_;
    die "I need a file argument" unless $file;
 
+   my $created_file = 0;
    if ( !-f $file ) {
-      PTDEBUG && _d('Creating', $file);
+      if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+         _d('Creating time limit file', $file);
+      }
       _touch($file);
-      return 1;
-   }
+      $created_file = 1;
+   }
+   elsif ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('Time limit file already exists:', $file);
+   }
+
+   my $time = int(time());  # current time
+
+   if ( @$instances ) {
+      my $instances_to_check = instances_to_check($file, $instances, $time);
+      return scalar @$instances_to_check, $instances_to_check;
+   }
+
+   return 1 if $created_file;
 
    my $mtime  = (stat $file)[9];
    if ( !defined $mtime ) {
       PTDEBUG && _d('Error getting modified time of', $file);
       return 0;
    }
-
-   my $time = int(time());
    PTDEBUG && _d('time=', $time, 'mtime=', $mtime);
    if ( ($time - $mtime) > $check_time_limit ) {
       _touch($file);
@@ -3399,6 +3439,36 @@
    return 0;
 }
 
+sub instances_to_check {
+   my ($file, $instances, $time) = @_;
+
+   open my $fh, '<', $file or die "Cannot open $file: $OS_ERROR";
+   my $file_contents = do { local $/ = undef; <$fh> };
+   close $fh;
+   chomp($file_contents);
+   my %cached_instances = $file_contents =~ /^([^,]+),(.+)$/mg;
+
+   my @instances_to_check;
+   foreach my $instance ( @$instances ) {
+      my $mtime = $cached_instances{ $instance->{id} };
+      if ( !$mtime || (($time - $mtime) > $check_time_limit) ) {
+         if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+            _d('Time to check MySQL instance', $instance->{name});
+         }
+         push @instances_to_check, $instance;
+         $cached_instances{ $instance->{id} } = $time;
+      }
+   }
+
+   open $fh, '>', $file or die "Cannot open $file for writing: $OS_ERROR";
+   while ( my ($id, $time) = each %cached_instances ) {
+      print { $fh } "$id,$time\n";
+   }
+   close $fh or die "Cannot close $file: $OS_ERROR";
+
+   return \@instances_to_check;
+}
+
 sub _touch {
    my ($file) = @_;
    sysopen my $fh, $file, O_WRONLY|O_CREAT|O_NONBLOCK
@@ -3407,22 +3477,48 @@
    utime(undef, undef, $file);
 }
 
+sub _generate_identifier {
+   my $instance = shift;
+   my $dbh      = $instance->{dbh};
+   my $dsn      = $instance->{dsn};
+
+   my $sql    = q{SELECT CONCAT(@@hostname, @@port)};
+   my ($name) = eval { $dbh->selectrow_array($sql) };
+   if ( $EVAL_ERROR ) { # assume that it's MySQL 4.x
+      $name = ($dsn->{h} || 'localhost') . ($dsn->{P} || 3306);
+   }
+   my $id = md5_hex($name);
+
+   if ( $ENV{PTVCDEBUG} || PTDEBUG ) {
+      _d('MySQL instance', $name, 'is', $id);
+   }
+
+   return $name, $id;
+}
+
 sub encode_client_response {
    my (%args) = @_;
-   my @required_args = qw(items versions);
+   my @required_args = qw(items versions general_id);
    foreach my $arg ( @required_args ) {
       die "I need a $arg arugment" unless $args{$arg};
    }
-   my ($items, $versions) = @args{@required_args};
+   my ($items, $versions, $general_id) = @args{@required_args};
 
    my @lines;
    foreach my $item ( sort keys %$items ) {
       next unless exists $versions->{$item};
-      push @lines, join(';', $item, $versions->{$item});
+      if ( ref($versions->{$item}) eq 'HASH' ) {
+         my $mysql_versions = $versions->{$item};
+         for my $id ( keys %$mysql_versions ) {
+            push @lines, join(';', $id, $item, $mysql_versions->{$id});
+         }
+      }
+      else {
+         push @lines, join(';', $general_id, $item, $versions->{$item});
+      }
    }
 
    my $client_response = join("\n", @lines) . "\n";
-   PTDEBUG && _d('Client response:', $client_response);
    return $client_response;
 }
 
@@ -3543,7 +3639,13 @@
    # Do the version-check
    # ########################################################################
    if ( $o->get('version-check') && (!$o->has('quiet') || !$o->get('quiet')) ) {
-      Pingback::version_check($slave_dbh);
+      my $tmp_master_dsn = $master_dsn
+                         ? $master_dsn
+                         : { h => $status->{master_host}, P => $status->{master_port} };
+      Pingback::version_check(
+         { dbh => $slave_dbh,  dsn => $slave_dsn      },
+         { dbh => $master_dbh, dsn => $tmp_master_dsn },
+      );
    }
 
    # If the I/O thread isn't running when the program starts,

=== modified file 'bin/pt-slave-restart'
--- bin/pt-slave-restart	2012-08-24 23:26:04 +0000
+++ bin/pt-slave-restart	2012-08-28 21:31:19 +0000
@@ -38,6 +38,7 @@
 {
 package Percona::Toolkit;
 our $VERSION = '2.1.3';
+
 1;
 }
 # ###########################################################################
@@ -3205,20 +3206,19 @@
       die "I need a $arg arugment" unless $args{$arg};
    }
    my ($items) = @args{@required_args};
-   my $dbh     = $args{dbh}; # optional
 
    my %versions;
    foreach my $item ( values %$items ) {
       next unless $self->valid_item($item);
-      
+
       eval {
          my $func    = 'get_' . $item->{type};
          my $version = $self->$func(
-            item => $item,
-            dbh  => $dbh,
+            item      => $item,
+            instances => $args{instances},
          );
          if ( $version ) {
-            chomp $version;
+            chomp $version unless ref($version);
             $versions{$item->{item}} = $version;
          }
       };
@@ -3343,28 +3343,42 @@
    );
 }
 
-
 sub _get_from_mysql {