Konsep fundamental dan model data untuk tracing - Managed Service for OpenTelemetry

Managed Service for OpenTelemetry menggunakan model data OpenTracing untuk menyediakan distributed tracing pada arsitektur microservice. Topik ini mencakup jejak (traces), rentang (spans), model data, serta metode pelaporan data.

OpenTracing merupakan pendahulu OpenTelemetry. Managed Service for OpenTelemetry mendukung model data OpenTracing yang dijelaskan di sini. Untuk standar OpenTelemetry, lihat dokumentasi OpenTelemetry.

Konsep utama

Konsep	Deskripsi
Distributed tracing	Metode untuk melacak permintaan saat mengalir melalui beberapa layanan dalam sistem terdistribusi.
Trace	Catatan end-to-end dari suatu transaksi atau proses dalam sistem terdistribusi. Jejak merupakan directed acyclic graph (DAG) yang terdiri atas rentang (spans).
Span	Unit kerja bernama dan berdurasi waktu dalam suatu jejak.
SpanContext	Metadata yang mengidentifikasi suatu rentang (trace ID, span ID) dan membawa baggage items melintasi batas proses.
Reference	Hubungan sebab-akibat antara dua rentang. OpenTracing mendefinisikan dua tipe: ChildOf dan FollowsFrom.
Tracer	Antarmuka untuk membuat rentang dan menyebarkan konteks antar layanan.

Mengapa distributed tracing penting

Aplikasi modern menggunakan arsitektur microservice, di mana pengembang menerapkan metode seperti pengembangan agile dan integrasi berkelanjutan. Arsitektur sistem telah berevolusi dari perangkat lunak monolitik menjadi arsitektur berbasis microservice, sehingga satu permintaan dapat melewati puluhan layanan. Layanan-layanan tersebut mungkin ditulis dalam bahasa pemrograman berbeda, dikelola oleh tim yang berbeda, dan dideploy di banyak server. Ketika terjadi kegagalan pada salah satu layanan, puluhan aplikasi dapat mengalami exception, dan menemukan akar masalah tanpa visibilitas end-to-end menjadi tidak praktis.

Sistem distributed tracing mencatat seluruh jalur eksekusi dan durasi setiap permintaan, termasuk proses eksekusi serta waktu yang dikonsumsi oleh panggilan metode remote. Visibilitas ini sangat penting untuk troubleshooting masalah sistem dan mengoptimalkan kinerja sistem.

Jejak (Traces)

Jejak merepresentasikan proses eksekusi suatu transaksi atau proses dalam sistem terdistribusi. Dalam standar OpenTracing, jejak berupa directed acyclic graph (DAG) yang terdiri atas beberapa rentang (spans). Setiap rentang merepresentasikan segmen bernama dan berdurasi yang dieksekusi secara berkelanjutan dalam jejak tersebut.

Sebagai contoh, permintaan dari klien mungkin melewati load balancer, layanan authentication, dan layanan billing sebelum mencapai resource target dan mengembalikan respons.

Sistem tracing biasanya menampilkannya sebagai garis waktu, di mana setiap baris merepresentasikan satu rentang dan sumbu horizontal merepresentasikan waktu.

Rentang (Spans)

Rentang merepresentasikan satu unit kerja tunggal dalam suatu jejak. Setiap rentang berisi data berikut:

Field	Deskripsi
Operation name	Label yang dapat dibaca manusia untuk pekerjaan yang dilakukan (juga disebut nama rentang).
Start timestamp	Waktu dimulainya operasi.
Finish timestamp	Waktu penyelesaian operasi.
Tags	Pasangan kunci-nilai yang menganotasi rentang tersebut. Kunci berupa string; nilai dapat berupa string, boolean, atau angka.
Logs	Pasangan kunci-nilai berstempel waktu yang mencatat event selama masa aktif rentang. Kunci berupa string; nilai dapat berupa tipe apa pun.
SpanContext	Metadata untuk mengidentifikasi rentang dan menyebarkannya melintasi batas proses. Lihat SpanContext.
References	Tautan ke rentang lain yang menetapkan hubungan induk-anak atau hubungan berurutan. Dapat mencakup nol atau beberapa rentang terkait.

Hubungan antar rentang

OpenTracing mendefinisikan dua tipe referensi antar rentang:

ChildOf: Hubungan induk-anak. Misalnya, Span C adalah node anak dari Span A.
FollowsFrom: Hubungan berurutan. Misalnya, Span G dipanggil setelah Span F.

Diagram berikut menunjukkan delapan rentang dan hubungan di antara mereka dalam satu jejak:

Hubungan sebab-akibat antar rentang dalam satu jejak


        [Span A]  <-- root span
            |
     +------+------+
     |             |
 [Span B]      [Span C]   (ChildOf: Span C adalah anak dari Span A)
     |             |
 [Span D]      +---+-------+
               |           |
           [Span E]    [Span F] >>> [Span G] >>> [Span H]
                                       ^
                                       |
                         (FollowsFrom: Span G mengikuti Span F)

Jejak yang sama ditampilkan sebagai garis waktu:

Hubungan waktu antar rentang dalam satu jejak


--|-------|-------|-------|-------|-------|-------|-------|-> time

 [Span A..........................................................]
   [Span B...................................................]
      [Span D................................................]
    [Span C...............................................]
         [Span E.......]        [Span F..] [Span G..] [Span H..]

SpanContext

SpanContext membawa metadata yang diperlukan untuk mengidentifikasi suatu rentang dan menyebarkannya melintasi batas proses. SpanContext berisi:

Trace ID: Pengidentifikasi unik untuk seluruh jejak.
Span ID: Pengidentifikasi unik untuk rentang individual.
Baggage items: Pasangan kunci-nilai yang ikut dikirim bersama jejak melintasi batas layanan. Pasangan kunci-nilai ini juga harus ditransmisikan melintasi batas proses.

Antarmuka Tracer

Tracer merupakan titik masuk untuk membuat rentang dan menyebarkan konteks antar layanan. Tracer menyediakan metode StartSpan untuk membuat rentang, metode Extract untuk mengekstrak konteks, dan metode Inject untuk menyuntikkan konteks.

Membuat rentang

Gunakan metode StartSpan untuk membuat dan memulai rentang baru. Metode ini mengembalikan rentang dengan nama operasi dan opsi yang ditentukan.

// Signature metode:
// StartSpan(operationName string, opts ...StartSpanOption) Span

// Membuat root span (tanpa induk).
sp := tracer.StartSpan("GetFeed")

// Membuat child span.
sp := tracer.StartSpan(
    "GetFeed",
    opentracing.ChildOf(parentSpan.Context()),
)

Menyebarkan konteks antar layanan

Untuk meneruskan trace context antar layanan, Tracer menyediakan dua metode komplementer:

Inject: Melakukan serialisasi SpanContext (termasuk trace ID, span ID, dan baggage items) ke dalam carrier (seperti Header HTTP) sebelum mengirim permintaan ke layanan lain.

   // Signature metode:
   // Inject(sm SpanContext, format interface{}, carrier interface{}) error

   carrier := opentracing.HTTPHeadersCarrier(httpReq.Header)
   err := tracer.Inject(
       span.Context(),
       opentracing.HTTPHeaders,
       carrier,
   )

Extract: Melakukan deserialisasi SpanContext (termasuk trace ID, span ID, dan baggage items) dari carrier saat menerima permintaan dari layanan lain.

   // Signature metode:
   // Extract(format interface{}, carrier interface{}) (SpanContext, error)

   carrier := opentracing.HTTPHeadersCarrier(httpReq.Header)
   clientContext, err := tracer.Extract(
       opentracing.HTTPHeaders,
       carrier,
   )

Bersama-sama, Inject dan Extract memungkinkan pelacakan end-to-end melintasi batas proses dan jaringan.

Pelaporan data

Managed Service for OpenTelemetry mendukung dua metode untuk melaporkan data jejak:

Pelaporan langsung

Aplikasi mengirim data jejak langsung ke tracing backend tanpa perantara.

Laporkan melalui agent

Aplikasi mengirim data jejak ke agent lokal (seperti Jaeger Agent), yang kemudian meneruskan data tersebut ke tracing backend.