connection-start和 探测包含来自客户端 的connection-done连接，无论该连接是通过套接字连接还是网络连接。

connection-start(connectionid, user, host)
connection-done(status, connectionid)

以下 D 脚本量化并总结了单个连接的平均持续时间，并提供了一个计数，每 60 秒转储一次信息：

#!/usr/sbin/dtrace -s


mysql*:::connection-start
{
  self->start = timestamp;
}

mysql*:::connection-done
/self->start/
{
  @ = quantize(((timestamp - self->start)/1000000));
  self->start = 0;
}

tick-60s
{
  printa(@);
}

在具有大量客户端的服务器上执行时，您可能会看到类似于以下内容的输出：

  1  57413                        :tick-60s

           value  ------------- Distribution ------------- count
              -1 |                                         0
               0 |@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ 30011
               1 |                                         59
               2 |                                         5
               4 |                                         20
               8 |                                         29
              16 |                                         18
              32 |                                         27
              64 |                                         30
             128 |                                         11
             256 |                                         10
             512 |                                         1
            1024 |                                         6
            2048 |                                         8
            4096 |                                         9
            8192 |                                         8
           16384 |                                         2
           32768 |                                         1
           65536 |                                         1
          131072 |                                         0
          262144 |                                         1
524288 |                                         0

命令探测在执行客户端命令之前和之后执行，包括在此期间可能执行的任何 SQL 语句。命令包括DB的初始化、 COM_CHANGE_USER操作的使用（MySQL协议支持）、prepared statements的操作等操作。其中许多命令仅由来自各种连接器（如 PHP 和 Java）的 MySQL 客户端 API 使用。

command-start(connectionid, command, user, host)
command-done(status)

和探测器最好command-start与 command-done语句探测器结合使用，以了解总体执行时间。

当服务器接收到特定查询并且查询已完成并且信息已成功发送到客户端时，将触发 query-start和 探测器。query-done

query-start(query, connectionid, database, user, host)
query-done(status)

您可以使用以下 D 脚本获取每个查询的执行时间的简单报告：

#!/usr/sbin/dtrace -s

#pragma D option quiet

dtrace:::BEGIN
{
   printf("%-20s %-20s %-40s %-9s\n", "Who", "Database", "Query", "Time(ms)");
}

mysql*:::query-start
{
   self->query = copyinstr(arg0);
   self->connid = arg1;
   self->db    = copyinstr(arg2);
   self->who   = strjoin(copyinstr(arg3),strjoin("@",copyinstr(arg4)));
   self->querystart = timestamp;
}

mysql*:::query-done
{
   printf("%-20s %-20s %-40s %-9d\n",self->who,self->db,self->query,
          (timestamp - self->querystart) / 1000000);
}

执行上述脚本时，您应该对查询的执行时间有一个基本的了解：

$> ./query.d
Who                  Database             Query                                    Time(ms)
root@localhost       test                 select * from t1 order by i limit 10     0
root@localhost       test                 set global query_cache_size=0            0
root@localhost       test                 select * from t1 order by i limit 10     776
root@localhost       test                 select * from t1 order by i limit 10     773
root@localhost       test                 select * from t1 order by i desc limit 10 795

query parsing probes在原始SQL语句被解析之前，当语句的解析和处理语句所需的执行模型的确定已经完成时触发：

query-parse-start(query)
query-parse-done(status)

例如，您可以使用以下 D 脚本监视解析给定查询的执行时间：

#!/usr/sbin/dtrace -s

#pragma D option quiet

mysql*:::query-parse-start
{
   self->parsestart = timestamp;
   self->parsequery = copyinstr(arg0);
}

mysql*:::query-parse-done
/arg0 == 0/
{
   printf("Parsing %s: %d microseconds\n", self->parsequery,((timestamp - self->parsestart)/1000));
}

mysql*:::query-parse-done
/arg0 != 0/
{
   printf("Error parsing %s: %d microseconds\n", self->parsequery,((timestamp - self->parsestart)/1000));
}

在上面的脚本中，使用了一个谓词， query-parse-done以便根据探测器的状态值生成不同的输出。

运行脚本并监视执行时：

$> ./query-parsing.d
Error parsing select from t1 join (t2) on (t1.i = t2.i) order by t1.s,t1.i limit 10: 36 ms
Parsing select * from t1 join (t2) on (t1.i = t2.i) order by t1.s,t1.i limit 10: 176 ms

执行任何查询时都会触发查询缓存探测器。当 query-cache-hit查询缓存中存在查询时触发查询，可用于返回查询缓存信息。参数包含原始查询文本和从查询缓存返回的查询行数。如果查询不在查询缓存中，或者未启用查询缓存，则会 query-cache-miss触发探测。

query-cache-hit(query, rows)
query-cache-miss(query)

查询缓存探测器最好与主查询上的探测器结合使用，以便您可以确定对指定查询使用或不使用查询缓存之间的时间差异。例如下面的D脚本中，在监控时将查询和查询缓存信息合并为信息输出：

#!/usr/sbin/dtrace -s

#pragma D option quiet

dtrace:::BEGIN
{
   printf("%-20s %-20s %-40s %2s %-9s\n", "Who", "Database", "Query", "QC", "Time(ms)");
}

mysql*:::query-start
{
   self->query = copyinstr(arg0);
   self->connid = arg1;
   self->db    = copyinstr(arg2);
   self->who   = strjoin(copyinstr(arg3),strjoin("@",copyinstr(arg4)));
   self->querystart = timestamp;
   self->qc = 0;
}

mysql*:::query-cache-hit
{
   self->qc = 1;
}

mysql*:::query-cache-miss
{
   self->qc = 0;
}

mysql*:::query-done
{
   printf("%-20s %-20s %-40s %-2s %-9d\n",self->who,self->db,self->query,(self->qc ? "Y" : "N"),
          (timestamp - self->querystart) / 1000000);
}

执行脚本时，您可以看到查询缓存的效果。最初禁用查询缓存。如果您设置查询缓存大小然后多次执行查询，您应该会看到查询缓存被用于返回查询数据：

$> ./query-cache.d
root@localhost       test                 select * from t1 order by i limit 10     N  1072
root@localhost                            set global query_cache_size=262144       N  0
root@localhost       test                 select * from t1 order by i limit 10     N  781
root@localhost       test                 select * from t1 order by i limit 10     Y  0

查询执行探测器在查询实际执行开始时触发，在解析和检查查询缓存之后但在任何特权检查或优化之前。通过比较开始和完成探测之间的差异，您可以监控实际花费在查询服务上的时间（而不是仅仅处理查询的解析和其他元素）。

query-exec-start(query, connectionid, database, user, host, exec_type)
query-exec-done(status)

每次将*row-{start,done}行操作下推到存储引擎时都会触发探测器。例如，如果您执行一条 INSERT包含 100 行数据的语句，那么对于每行插入， insert-row-start和 探测将分别触发 100 次。insert-row-done

insert-row-start(database, table)
insert-row-done(status)

update-row-start(database, table)
update-row-done(status)

delete-row-start(database, table)
delete-row-done(status)

探针支持的参数对于每种情况下 的对应start和 探针是一致的：done

因为行级探测是针对每个单独的行访问触发的，这些探测每秒可能被触发数千次，这可能对监控脚本和 MySQL 都产生不利影响。DTrace 环境应限制对这些探测器的触发，以防止性能受到不利影响。要么谨慎使用探测器，要么使用计数器或聚合函数来报告这些探测器，然后在脚本终止时或作为query-doneor query-exec-done探测器的一部分提供摘要。

以下示例脚本总结了较大查询中每行操作的持续时间：

#!/usr/sbin/dtrace -s

#pragma D option quiet

dtrace:::BEGIN
{
   printf("%-2s %-10s %-10s %9s %9s %-s \n",
          "St", "Who", "DB", "ConnID", "Dur ms", "Query");
}

mysql*:::query-start
{
   self->query = copyinstr(arg0);
   self->who   = strjoin(copyinstr(arg3),strjoin("@",copyinstr(arg4)));
   self->db    = copyinstr(arg2);
   self->connid = arg1;
   self->querystart = timestamp;
   self->rowdur = 0;
}

mysql*:::query-done
{
   this->elapsed = (timestamp - self->querystart) /1000000;
   printf("%2d %-10s %-10s %9d %9d %s\n",
          arg0, self->who, self->db,
          self->connid, this->elapsed, self->query);
}

mysql*:::query-done
/ self->rowdur /
{
   printf("%34s %9d %s\n", "", (self->rowdur/1000000), "-> Row ops");
}

mysql*:::insert-row-start
{
   self->rowstart = timestamp;
}

mysql*:::delete-row-start
{
   self->rowstart = timestamp;
}

mysql*:::update-row-start
{
   self->rowstart = timestamp;
}

mysql*:::insert-row-done
{
   self->rowdur += (timestamp-self->rowstart);
}

mysql*:::delete-row-done
{
   self->rowdur += (timestamp-self->rowstart);
}

mysql*:::update-row-done
{
   self->rowdur += (timestamp-self->rowstart);
}

使用将数据插入表的查询运行上述脚本，您可以监控执行原始行插入所花费的确切时间：

St Who        DB            ConnID    Dur ms Query
 0 @localhost test              13     20767 insert into t1(select * from t2)
                                        4827 -> Row ops

每次发生行读取操作时，都会在存储引擎级别触发读取行探测。这些探测器在每个存储引擎中指定（ *row-start与存储引擎接口中的探测器相反）。因此，这些探测器可用于监视单个存储引擎行级操作和性能。因为这些探测是围绕存储引擎行读取接口触发的，所以在基本查询期间它们可能会被命中很多次。

read-row-start(database, table, scan_flag)
read-row-done(status)

每次使用指定表的索引之一读取一行时，都会触发索引探测。探测器在表的相应存储引擎中触发。

index-read-row-start(database, table)
index-read-row-done(status)

每当 MySQL 使用由表的引擎类型定义的表上的相应锁定机制为表请求外部锁定时，将调用锁定探测器。有三种不同类型的锁，读锁、写锁和解锁操作。使用探针，您可以确定外部锁定例程的持续时间（即存储引擎实现锁定所花费的时间，包括等待另一个锁变为空闲的任何时间）和锁定/解锁过程的总持续时间.

handler-rdlock-start(database, table)
handler-rdlock-done(status)

handler-wrlock-start(database, table)
handler-wrlock-done(status)

handler-unlock-start(database, table)
handler-unlock-done(status)

您可以使用数组来监视单个表的锁定和解锁，然后使用以下脚本计算整个表锁定的持续时间：

#!/usr/sbin/dtrace -s

#pragma D option quiet

mysql*:::handler-rdlock-start
{
   self->rdlockstart = timestamp;
   this->lockref = strjoin(copyinstr(arg0),strjoin("@",copyinstr(arg1)));
   self->lockmap[this->lockref] = self->rdlockstart;
   printf("Start: Lock->Read   %s.%s\n",copyinstr(arg0),copyinstr(arg1));
}

mysql*:::handler-wrlock-start
{
   self->wrlockstart = timestamp;
   this->lockref = strjoin(copyinstr(arg0),strjoin("@",copyinstr(arg1)));
   self->lockmap[this->lockref] = self->rdlockstart;
   printf("Start: Lock->Write  %s.%s\n",copyinstr(arg0),copyinstr(arg1));
}

mysql*:::handler-unlock-start
{
   self->unlockstart = timestamp;
   this->lockref = strjoin(copyinstr(arg0),strjoin("@",copyinstr(arg1)));
   printf("Start: Lock->Unlock %s.%s (%d ms lock duration)\n",
          copyinstr(arg0),copyinstr(arg1),
          (timestamp - self->lockmap[this->lockref])/1000000);
}

mysql*:::handler-rdlock-done
{
   printf("End:   Lock->Read   %d ms\n",
          (timestamp - self->rdlockstart)/1000000);
}

mysql*:::handler-wrlock-done
{
   printf("End:   Lock->Write  %d ms\n",
          (timestamp - self->wrlockstart)/1000000);
}

mysql*:::handler-unlock-done
{
   printf("End:   Lock->Unlock %d ms\n",
          (timestamp - self->unlockstart)/1000000);
}

执行时，您应该获得有关锁定过程本身的持续时间以及特定表上的锁的信息：

Start: Lock->Read   test.t2
End:   Lock->Read   0 ms
Start: Lock->Unlock test.t2 (25743 ms lock duration)
End:   Lock->Unlock 0 ms
Start: Lock->Read   test.t2
End:   Lock->Read   0 ms
Start: Lock->Unlock test.t2 (1 ms lock duration)
End:   Lock->Unlock 0 ms
Start: Lock->Read   test.t2
End:   Lock->Read   0 ms
Start: Lock->Unlock test.t2 (1 ms lock duration)
End:   Lock->Unlock 0 ms
Start: Lock->Read   test.t2
End:   Lock->Read   0 ms

只要将文件排序操作应用于表，就会触发文件排序探测器。有关文件排序及其发生条件的更多信息，请参阅 第 8.2.1.14 节，“ORDER BY 优化”。

filesort-start(database, table)
filesort-done(status, rows)

下面的脚本就是一个例子，除了主查询的持续时间之外，它还跟踪文件排序过程的持续时间：

#!/usr/sbin/dtrace -s

#pragma D option quiet

dtrace:::BEGIN
{
   printf("%-2s %-10s %-10s %9s %18s %-s \n",
          "St", "Who", "DB", "ConnID", "Dur microsec", "Query");
}

mysql*:::query-start
{
   self->query = copyinstr(arg0);
   self->who   = strjoin(copyinstr(arg3),strjoin("@",copyinstr(arg4)));
   self->db    = copyinstr(arg2);
   self->connid = arg1;
   self->querystart = timestamp;
   self->filesort = 0;
   self->fsdb = "";
   self->fstable = "";
}

mysql*:::filesort-start
{
  self->filesort = timestamp;
  self->fsdb = copyinstr(arg0);
  self->fstable = copyinstr(arg1);
}

mysql*:::filesort-done
{
   this->elapsed = (timestamp - self->filesort) /1000;
   printf("%2d %-10s %-10s %9d %18d Filesort on %s\n",
          arg0, self->who, self->fsdb,
          self->connid, this->elapsed, self->fstable);
}

mysql*:::query-done
{
   this->elapsed = (timestamp - self->querystart) /1000;
   printf("%2d %-10s %-10s %9d %18d %s\n",
          arg0, self->who, self->db,
          self->connid, this->elapsed, self->query);
}

ORDER BY使用触发文件排序的子句 对大表执行查询，然后在表上创建索引，然后重复相同的查询，您可以看到执行速度的差异：

St Who        DB            ConnID       Dur microsec Query
 0 @localhost test              14           11335469 Filesort on t1
 0 @localhost test              14           11335787 select * from t1 order by i limit 100
 0 @localhost test              14          466734378 create index t1a on t1 (i)
 0 @localhost test              14              26472 select * from t1 order by i limit 100

提供了单独的语句探测器以提供有关不同语句类型的特定信息。对于开始探测，查询字符串作为唯一参数提供。根据语句类型，相应的完成探测提供的信息可能会有所不同。对于所有完成的探测，提供了操作的状态（0 成功、>0失败）。对于SELECT、 INSERT、 INSERT ... (SELECT FROM ...)、DELETE和DELETE FROM t1,t2操作，返回受影响的行数。

对于UPDATEand UPDATE t1,t2 ...语句，提供匹配的行数和实际更改的行数。这是因为相应 WHERE子句实际匹配的行数和更改的行数可能不同。如果值已经与新设置匹配，MySQL 不会更新行的值。

select-start(query)
select-done(status,rows)

insert-start(query)
insert-done(status,rows)

insert-select-start(query)
insert-select-done(status,rows)

update-start(query)
update-done(status,rowsmatched,rowschanged)

multi-update-start(query)
multi-update-done(status,rowsmatched,rowschanged)

delete-start(query)
delete-done(status,rows)

multi-delete-start(query)
multi-delete-done(status,rows)

语句探测的参数是：

您可以使用这些探测器来监视这些语句类型的执行，而不必监视执行这些语句的用户或客户端。一个简单的例子是跟踪执行时间：

#!/usr/sbin/dtrace -s

#pragma D option quiet

dtrace:::BEGIN
{
   printf("%-60s %-8s %-8s %-8s\n", "Query", "RowsU", "RowsM", "Dur (ms)");
}

mysql*:::update-start, mysql*:::insert-start,
mysql*:::delete-start, mysql*:::multi-delete-start,
mysql*:::multi-delete-done, mysql*:::select-start,
mysql*:::insert-select-start, mysql*:::multi-update-start
{
    self->query = copyinstr(arg0);
    self->querystart = timestamp;
}

mysql*:::insert-done, mysql*:::select-done,
mysql*:::delete-done, mysql*:::multi-delete-done, mysql*:::insert-select-done
/ self->querystart /
{
    this->elapsed = ((timestamp - self->querystart)/1000000);
    printf("%-60s %-8d %-8d %d\n",
           self->query,
           0,
           arg1,
           this->elapsed);
    self->querystart = 0;
}

mysql*:::update-done, mysql*:::multi-update-done
/ self->querystart /
{
    this->elapsed = ((timestamp - self->querystart)/1000000);
    printf("%-60s %-8d %-8d %d\n",
           self->query,
           arg1,
           arg2,
           this->elapsed);
    self->querystart = 0;
}

执行时，您可以看到基本的执行时间和行匹配：

Query                                                        RowsU    RowsM    Dur (ms)
select * from t2                                             0        275      0
insert into t2 (select * from t2)                            0        275      9
update t2 set i=5 where i > 75                               110      110      8
update t2 set i=5 where i < 25                               254      134      12
delete from t2 where i < 5                                   0        0        0

另一种方法是使用 DTrace 中的聚合函数将各个语句的执行时间聚合在一起：

#!/usr/sbin/dtrace -s

#pragma D option quiet


mysql*:::update-start, mysql*:::insert-start,
mysql*:::delete-start, mysql*:::multi-delete-start,
mysql*:::multi-delete-done, mysql*:::select-start,
mysql*:::insert-select-start, mysql*:::multi-update-start
{
    self->querystart = timestamp;
}

mysql*:::select-done
{
        @statements["select"] = sum(((timestamp - self->querystart)/1000000));
}

mysql*:::insert-done, mysql*:::insert-select-done
{
        @statements["insert"] = sum(((timestamp - self->querystart)/1000000));
}

mysql*:::update-done, mysql*:::multi-update-done
{
        @statements["update"] = sum(((timestamp - self->querystart)/1000000));
}

mysql*:::delete-done, mysql*:::multi-delete-done
{
        @statements["delete"] = sum(((timestamp - self->querystart)/1000000));
}

tick-30s
{
        printa(@statements);
}

刚刚显示的脚本汇总了执行每个操作所花费的时间，可用于帮助对标准测试套件进行基准测试。

 delete                                                            0
  update                                                            0
  insert                                                           23
  select                                                         2484

  delete                                                            0
  update                                                            0
  insert                                                           39
  select                                                        10744

  delete                                                            0
  update                                                           26
  insert                                                           56
  select                                                        10944

  delete                                                            0
  update                                                           26
  insert                                                         2287
  select                                                        15985

网络探测器监视通过网络从 MySQL 服务器和所有类型的客户端传输的信息。探针定义如下：

net-read-start()
net-read-done(status, bytes)
net-write-start(bytes)
net-write-done(status)

您可以使用网络探测来监视在执行期间读取和写入网络客户端所花费的时间。下面的 D 脚本提供了一个例子。计算读取或写入的累积时间和字节数。请注意，动态变量大小已增加（使用dynvarsize选项）以应对网络读/写的单个探测器的快速触发。

#!/usr/sbin/dtrace -s

#pragma D option quiet
#pragma D option dynvarsize=4m

dtrace:::BEGIN
{
   printf("%-2s %-30s %-10s %9s %18s %-s \n",
          "St", "Who", "DB", "ConnID", "Dur microsec", "Query");
}

mysql*:::query-start
{
   self->query = copyinstr(arg0);
   self->who   = strjoin(copyinstr(arg3),strjoin("@",copyinstr(arg4)));
   self->db    = copyinstr(arg2);
   self->connid = arg1;
   self->querystart = timestamp;
   self->netwrite = 0;
   self->netwritecum = 0;
   self->netwritebase = 0;
   self->netread = 0;
   self->netreadcum = 0;
   self->netreadbase = 0;
}

mysql*:::net-write-start
{
   self->netwrite += arg0;
   self->netwritebase = timestamp;
}

mysql*:::net-write-done
{
   self->netwritecum += (timestamp - self->netwritebase);
   self->netwritebase = 0;
}

mysql*:::net-read-start
{
   self->netreadbase = timestamp;
}

mysql*:::net-read-done
{
   self->netread += arg1;
   self->netreadcum += (timestamp - self->netreadbase);
   self->netreadbase = 0;
}

mysql*:::query-done
{
   this->elapsed = (timestamp - self->querystart) /1000000;
   printf("%2d %-30s %-10s %9d %18d %s\n",
          arg0, self->who, self->db,
          self->connid, this->elapsed, self->query);
   printf("Net read: %d bytes (%d ms) write: %d bytes (%d ms)\n",
               self->netread, (self->netreadcum/1000000),
               self->netwrite, (self->netwritecum/1000000));
}

在带有远程客户端的机器上执行上述脚本时，您可以看到执行查询所花费的大约三分之一的时间与将查询结果写回客户端有关。

St Who                            DB            ConnID       Dur microsec Query
 0 root@::ffff:198.51.100.108      test              31               3495 select * from t1 limit 1000000
Net read: 0 bytes (0 ms) write: 10000075 bytes (1220 ms)

当使用与 MyISAM 存储引擎一起使用的索引键缓存时，将触发键缓存探测。存在探针以监视何时将数据读入 keycache，缓存的 key 数据从缓存写入缓存文件，或何时访问 keycache。

Keycache 使用情况指示何时从索引文件读取数据或将数据写入缓存，并且可用于监视分配给 keycache 的内存的使用效率。在一系列查询中读取大量 keycache 可能表明 keycache 太小而无法访问数据大小。

keycache-read-start(filepath, bytes, mem_used, mem_free)
keycache-read-block(bytes)
keycache-read-hit()
keycache-read-miss()
keycache-read-done(mem_used, mem_free)
keycache-write-start(filepath, bytes, mem_used, mem_free)
keycache-write-block(bytes)
keycache-write-done(mem_used, mem_free)

当从索引文件中读取数据 到keycache时，进程首先初始化读取操作 keycache-read-start（用读 ( )。读取操作完成后，读取将停止并显示 。 keycache-read-blockkeycache-read-hitkeycache-read-misskeycache-read-done

只有当指定的键不在键缓存中时，才能将数据从索引文件读入键缓存。

INSERT当在、 UPDATE或操作 期间更新索引信息时，将发生 Keycache 写入DELETE ，并且缓存的密钥信息被刷新回索引文件。