Using PHP and DTrace
Använda PHP och DTrace
PHP kan konfigureras med DTrace statiska prober på plattformar som stöder DTrace Dynamisk Spårning.
Konfigurera PHP för DTrace statiska prober
Referera till extern plattformspecifik dokumentation för att aktivera operativsystemets DTrace-stöd. Till exempel, på Oracle Linux starta en UEK3-kärna och gör:
<code># modprobe fasttrap # chmod 666 /dev/dtrace/helper </code>
Istället för att använda `chmod` kan du istället använda en ACL-paketregel för att begränsa enhetsåtkomst till en specifik användare.
Bygg PHP med konfigurationsparametern `--enable-dtrace`:
<code># ./configure --enable-dtrace ... # make # make install </code>
Detta aktiverar de statiska probarna i kärn-PHP. Alla PHP-tillägg som tillhandahåller egna prober bör byggas separat som delade tillägg.
DTrace statiska prober i kärn-PHP
Följande statiska prober är tillgängliga i PHP:
| Probe Namn | Probe Beskrivning | Probe Argument |
|---|---|---|
| request-startup | Avfyras när en förfrågan startar. | char *file, char *request_uri, char *request_method |
| request-shutdown | Avfyras när en förfrågan avslutas. | char *file, char *request_uri, char *request_method |
| compile-file-entry | Avfyras när kompileringen av ett skript börjar. | char *compile_file, char *compile_file_translated |
| compile-file-return | Avfyras när kompileringen av ett skript slutförs. | char *compile_file, char *compile_file_translated |
| execute-entry | Avfyras när en opcode-array ska köras. Till exempel, avfyras vid funktionsanrop, includes och generatoråterupptaganden. | char *request_file, int lineno |
| execute-return | Avfyras efter körning av en opcode-array. | char *request_file, int lineno |
| function-entry | Avfyras när PHP-motorn går in i ett PHP-funktions- eller metodanrop. | char *function_name, char *request_file, int lineno, char *classname, char *scope |
| function-return | Avfyras när PHP-motorn återvänder från ett PHP-funktions- eller metodanrop. | char *function_name, char *request_file, int lineno, char *classname, char *scope |
| exception-thrown | Avfyras när ett undantag kastas. | char *classname |
| exception-caught | Avfyras när ett undantag fångas. | char *classname |
| error | Avfyras när ett fel uppstår, oavsett nivå för `error_reporting`. | char *errormsg, char *request_file, int lineno |
PHP-tillägg kan också ha ytterligare statiska prober.
Lista DTrace statiska prober i PHP
För att lista tillgängliga prober, starta en PHP-process och kör sedan:
<code># dtrace -l </code>
Utskriften kommer att likna:
<code> ID PROVIDER MODULE FUNCTION NAME
[ . . . ]
4 php15271 php dtrace_compile_file compile-file-entry
5 php15271 php dtrace_compile_file compile-file-return
6 php15271 php zend_error error
7 php15271 php ZEND_CATCH_SPEC_CONST_CV_HANDLER exception-caught
8 php15271 php zend_throw_exception_internal exception-thrown
9 php15271 php dtrace_execute_ex execute-entry
10 php15271 php dtrace_execute_internal execute-entry
11 php15271 php dtrace_execute_ex execute-return
12 php15271 php dtrace_execute_internal execute-return
13 php15271 php dtrace_execute_ex function-entry
14 php15271 php dtrace_execute_ex function-return
15 php15271 php php_request_shutdown request-shutdown
16 php15271 php php_request_startup request-startup
</code>
Värdena i kolumnen Provider består av `php` och process-ID för den för närvarande körande PHP-processen.
Om Apache-webbservern körs, kan modulnamnet till exempel vara `libphp5.so`, och det skulle finnas flera block med listningar, ett per körande Apache-process.
Kolumnen Function hänvisar till PHP:s interna C-implementationsfunktioner där varje provider är lokaliserad.
Om en PHP-process inte körs, visas inga PHP-prober.
DTrace med PHP Exempel
Detta exempel visar grunderna i DTrace D-skriptsspråket.
Exempel #1 all_probes.d för att spåra alla PHP statiska prober med DTrace
<code>#!/usr/sbin/dtrace -Zs
#pragma D option quiet
php*:::compile-file-entry
{
printf("PHP compile-file-entry\n");
printf(" compile_file %s\n", copyinstr(arg0));
printf(" compile_file_translated %s\n", copyinstr(arg1));
}
php*:::compile-file-return
{
printf("PHP compile-file-return\n");
printf(" compile_file %s\n", copyinstr(arg0));
printf(" compile_file_translated %s\n", copyinstr(arg1));
}
php*:::error
{
printf("PHP error\n");
printf(" errormsg %s\n", copyinstr(arg0));
printf(" request_file %s\n", copyinstr(arg1));
printf(" lineno %d\n", (int)arg2);
}
php*:::exception-caught
{
printf("PHP exception-caught\n");
printf(" classname %s\n", copyinstr(arg0));
}
php*:::exception-thrown
{
printf("PHP exception-thrown\n");
printf(" classname %s\n", copyinstr(arg0));
}
php*:::execute-entry
{
printf("PHP execute-entry\n");
printf(" request_file %s\n", copyinstr(arg0));
printf(" lineno %d\n", (int)arg1);
}
php*:::execute-return
{
printf("PHP execute-return\n");
printf(" request_file %s\n", copyinstr(arg0));
printf(" lineno %d\n", (int)arg1);
}
php*:::function-entry
{
printf("PHP function-entry\n");
printf(" function_name %s\n", copyinstr(arg0));
printf(" request_file %s\n", copyinstr(arg1));
printf(" lineno %d\n", (int)arg2);
printf(" classname %s\n", copyinstr(arg3));
printf(" scope %s\n", copyinstr(arg4));
}
php*:::function-return
{
printf("PHP function-return\n");
printf(" function_name %s\n", copyinstr(arg0));
printf(" request_file %s\n", copyinstr(arg1));
printf(" lineno %d\n", (int)arg2);
printf(" classname %s\n", copyinstr(arg3));
printf(" scope %s\n", copyinstr(arg4));
}
php*:::request-shutdown
{
printf("PHP request-shutdown\n");
printf(" file %s\n", copyinstr(arg0));
printf(" request_uri %s\n", copyinstr(arg1));
printf(" request_method %s\n", copyinstr(arg2));
}
php*:::request-startup
{
printf("PHP request-startup\n");
printf(" file %s\n", copyinstr(arg0));
printf(" request_uri %s\n", copyinstr(arg1));
printf(" request_method %s\n", copyinstr(arg2));
}
</code>
Detta skript använder `-Z`-alternativet till `dtrace`, vilket tillåter det att köras även när det inte finns någon PHP-process som körs. Om detta alternativ utelämnades skulle skriptet omedelbart avslutas eftersom det vet att ingen av de prober som ska övervakas existerar.
Skriptet spårar alla kärn-PHP statiska probepunkter under hela körningen av ett PHP-skript. Kör D-skriptet:
<code># ./all_probes.d </code>
Kör ett PHP-skript eller en applikation. Det övervakande D-skriptet kommer att skriva ut varje probes argument när den avfyras.
När övervakningen är klar kan D-skriptet avslutas med CTRL+C.
På maskiner med flera CPU:er kan probeordningen verka icke-sekventiell. Detta beror på vilken CPU som behandlade proberna och hur trådar migrerar över CPU:erna. Att visa probens tidsstämplar hjälper till att minska förvirringen, till exempel:
<code>php*:::function-entry
{
printf("%lld: PHP function-entry ", walltimestamp);
[ . . .]
}
</code>
Jämförbara ämnen
Sidslut
Orginalhemsidan på Engelska :https://www.php.net/manual/en/features.dtrace.dtrace.php
Det här är en maskinöversättning av PHP-manualen till svenska. Om du hittar fel är vi tacksamma om du rapporterar dem via formuläret som finns på
https://www.linux.se/kontaka-linux-se/
Tack till Datorhjälp.se som har sponsrat Linux.se med webserver.