Penggunaan fungsi DTRACE pada PHP

#!/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));
}

DTrace is an always-available, low overhead, tracing framework available on a number of platforms including Solaris, macOS, Oracle Linux and BSD. DTrace can trace operating system behavior and user program execution. It can display argument values and be used to infer performance statistics. Probes are monitored by user created scripts written in the DTrace D scripting language. This allows efficient analysis of data points.

PHP probes that are not being actively monitored by a user's DTrace D script do not contain instrumented code so there is no performance degradation during normal application execution. Probes that are being monitored incur an overhead low enough to generally allow DTrace monitoring on live production systems.

PHP incorporates "User-level Statically Defined Tracing" (USDT) probes that are triggered at runtime. For example, when a D script is monitoring PHP's function-entry probe, then, every time a PHP script function is called, this probe is fired and the associated D script action code is executed. This action code could, for example, print probe arguments such as the source file location of the PHP function. Or the action could aggregate data such as the number of times each function is called.

Only the PHP USDT probes are described here. Refer to external general and operating system-specific DTrace literature to see how DTrace can be used to trace arbitrary functions, and how it can be used to trace operating system behavior. Note not all DTrace features are available in all DTrace implementations.

DTrace static probes are included in PHP 5.4. Prior to this they were available via a » PECL extension, which is now obsolete.

The static DTrace probes in PHP can alternatively be used with the SystemTap facility on some Linux distributions.

DTrace atau Dynamic tracing framework merupakan sebuah fitur sistem operasi yang diperkenalkan bersama Sun’s Solaris akhir tahun 2003. Dengan DTrace programmer dan systems administrator dapat melakukan \’trace\’ atau menelusuri kernel dan aplikasi di sistem yang sedang jalan (produktif) dalam upaya menemukan kekliruan.

Dengan demikian DTrace memiliki kemampuan yang memadai dalam untuk tracking daripada solusi yang ada sebelumnya. Setelah Sun Microsystems membebaskan kode sumbernya awal 2005, alat ini kemudian menjadi platform software yang kemudian diadopsi sistem operasi lain termasuk OpenSolaris, Mac OSX dan FreeBSD.

DTrace adalah Infrastruktur atau alat yang dilengkapi dengan AD Trace language dan interpreter (penerjemah). DTrace menjadi infrastruktur yang tangguh dan membolehkan developers untuk diagnosa system and tingkah laku applikasi.

Ada beberapa istilah yang berkaitan dengan DTrace yakni Probe, Aggregasi, Predikat dan Features. Berikut beberapa penjelasan singkat dari beberapa istilah tersebut.

Probe mengacu dari instrumentation dengan dengan namespace schema -Provider: Module: Function : Name.

• Provider – merepresentasikan sebuah metodologi untuk melakukan instrumentasi terhadap system

• Module – Nama dari DTrace kernel module atau user library.

• Function – Nama dari program fungsi

• Name – Nama dari probe contoh: “fbt:zfs:arc_read:entry”

Aggregasi.

Sintaks Aggregasi Dtrace adalah @name[ keys ] = aggfunc ( args ). Sintaks ini dapat didefenisikan sebagai berikut :

• name – Name variabel aggregasi yang didahului oleh karakter @.

• keys – Kumpulan ekspresi D yang dipisahkan oleh simbol koma

• aggfunc – Salah satu fungsi-fungsi aggregasi DTrace

• args – Kumpulan argumen yang sesuai dengan fungsi aggregasi dipisahkan oleh simbol koma

Predikat.

Program D terdiri dari sekumpulan klausa-klausa probe. Klausa probe memiliki bentuk umum sebagai berikut:

probe descriptions

/ predicate /

{

action statements

}

Berikutnya adalah

Features

• Dynamic instrumentation Zero probe effect ketika disable

• Instrumentationnya disatukan atau sekaligus Instrument kernel dan applications yang dapat menelusuri flow-control melintas tanpa batas.

• Kernel instrumentation. Instrumen terdapat di-kernel subsystems seperti virtual memory, synchronization, scheduler

• Data Integrity dalam arti setiap error system atau program selalu dilaporkan

Sebagai fitur yang paling digemborkan dalam Solaris versi 10, DTrace dapat digunakan sebagai:

• DebuggingUntuk mengetahui rutin-rutin apa yang sedang dipanggil, argumen dan nilai balik dari setiap fungsi-fungsinya

• Analisa KinerjaDapat diamati dimana aplikasi banyak menggunakan waktunya dan berapa lama. Digunakan untuk menggali lebih dalam dan menemukan penyebab utama masalah kinerja

• ObservabilitasDTrace membantu pemahaman terhadap sistem. Dapat diketahui siapa yang memanggil sebuah fungsi dan fungsi-fungsi lain apa yang dipanggil oleh satu fungsi tertentu yang sedang dipanggil

• Jangkauan Kode (Code Coverage)Sebagai piranti pengetes, DTrace digunakan untuk mengetahui apakah sebuah fungsi dipanggil dan dimana

Dengan Tools yang ada DTrace dapat membolehkan user untuk :

1. Enable probes dengan cara : #dtrace -n BEGIN

2. Run D-language scripts dengan cara : # dtrace -s scriptQu.d

3. Mengamati properties dari DTrace framework di system yang bersangkutan dengan cara : #dtrace –l

DTrace dapat digunakan pada saat kita ingin melakukan monitoring system, isalnya ketika hendak menyelidiki kernel subsystem. Di sini kita dapat memantau

file systems, networks, zones, dan sebagaiya. Selain itu dapat Mengumpulkan information dari seluruh system melalui DExplorer tool serta melakukan

Tuning system dan aplikasi

Oiya, DTrace juga dapat digunakan untuk Web-development. Baik dengan Server-side (Ruby, Java,PHP,Groovy,Perl,Python) maupun dengan Client-side (Java-script); Tools (Apache, Glassfish, MySQL, PostgreSQL). Di samping itu, untuk kebutuhan software development, DTrace dapat digunakan untuk Debugging, Profiling, Memory leaks,Lost CPU cycles, Function calls, dan sebaganya.

Gimana, masih mutuh info lebih lanjut? Open Solaris User Group Jogja siap membantu Anda

Contoh Perintah Dtrace

Program DTrace yang makin kompleks akan sulit jika dituliskan langsung di perintah baris. Perintah dtrace(1M) mendukung penggunaan skrip yang dispesifikasikan dengan opsi -s. Cara lain adalah dengan membuat file interpreter DTrace yang dapat dieksekusi langsung. File interpreter selalu diawali dengan baris:

#!/usr/sbin/dtrace -s

Contoh berikut adalah sebuah skrip yang merunut nama file-terksekusi pada saat terjadi titik-masuk setiap panggilan sistem:

# cat syscall.d

syscall:::entry

{

trace(execname);

}

Berdasarkan konvensi, skrip DTrace diberikan akhiran .d suffix. Berikutnya skrip ini dapat dijalankan dengan cara berikut ini:

# dtrace -s sycall.d

Jika file syscall.d ditambahkan izin-akses eksekusi dan tambahkan baris pertama-nya pathname ke interpreter dtrace maka selanjutnya skrip ini dapat dieksekusi secara langsung:

#cat syscall.d

#!/usr/sbin/dtrace -s

syscall:entry

{

trace(execname);

}

# chmod +x syscall.d

# ./syscall.d

Predikat

Program D terdiri dari sekumpulan klausa-klausa probe. Klausa probe memiliki bentuk umum sebagai berikut:

probe descriptions

/ predicate /

{

action statements

}

Predikat (predicate) adalah ekspresi D yang terletak diantara simbol garis-miring / /. Predikat dievaluasi saat probe memicu untuk menentukan apakah aksi-aksi terkaitnya akan dieksekusi. Jika ekspresi D dievaluasi dengan nilai nol maka berarti false; jika dievaluasi dengan nilai bukan-nol maka berarti true. Penggunaan predikat bersifat opsional. Predikat selalu ditempatkan diantara deskripsi probe dan pernyataan aksi.