Gunakan Jaeger untuk menginstrumentasi aplikasi Python dan mengirimkan data jejak - Application Real-Time Monitoring Service

Instrumentasikan aplikasi Python dengan klien Jaeger untuk mengirimkan data jejak ke Managed Service for OpenTelemetry. Setelah terhubung, konsol ARMS akan menampilkan topologi aplikasi, jejak, transaksi abnormal dan lambat, serta analisis SQL.

Penting

Untuk fitur lanjutan dan kemampuan tracing, kami merekomendasikan menghubungkan aplikasi Anda ke Managed Service for OpenTelemetry menggunakan protokol OpenTelemetry.

Panduan integrasi OpenTelemetry yang mendetail dan praktik terbaik kami membantu Anda memulai dengan Managed Service for OpenTelemetry. Untuk informasi selengkapnya, lihat Connect an application.

Cara kerja

Jaeger mendukung dua arsitektur pelaporan data:

Tanpa agen Jaeger: Klien Jaeger mengirimkan data jejak langsung ke backend Managed Service for OpenTelemetry.

Dengan agen Jaeger: Klien Jaeger mengirimkan data jejak ke agen Jaeger yang berjalan secara lokal, yang kemudian meneruskannya ke backend melalui gRPC.

Batasan

Klien Jaeger Python (v1.25) hanya dapat mengirimkan data jejak melalui agen Jaeger, bukan melalui HTTP. Lihat Client Library Features.
Klien berkomunikasi dengan agen melalui UDP, yang tidak menjamin pengiriman. Untuk meminimalkan kehilangan data, jalankan keduanya pada host yang sama.

Langkah 1: Mulai agen Jaeger

Ambil image agen Jaeger:

   docker pull jaegertracing/jaeger-agent:1.25

Jalankan kontainer agen Jaeger: Ganti placeholder berikut dengan nilai dari halaman Cluster Configurations:

Placeholder	Deskripsi
`<endpoint>`	Titik akhir gRPC Managed Service for OpenTelemetry
`<auth>`	Token otentikasi

   docker run -d --name jaeger-agent \
     -p 5775:5775/udp \
     -p 6831:6831/udp \
     -p 6832:6832/udp \
     -p 5778:5778/tcp \
     jaegertracing/jaeger-agent:1.25 \
     --reporter.type=grpc \
     --reporter.grpc.host-port=<endpoint> \
     --agent.tags=<auth>

Verifikasi agen sedang berjalan: Status Up menunjukkan agen telah dimulai. Jika kontainer tidak berjalan, periksa log:
```
   docker ps --filter name=jaeger-agent
```
```
   docker logs jaeger-agent
```

Langkah 2: Instrumentasi aplikasi Python

Instal paket yang diperlukan. Simpan berikut ini ke dalam file requirements.txt, lalu instal paket-paket tersebut:

   certifi==2021.5.30
   charset-normalizer==2.0.4
   idna==3.2
   jaeger-client==4.6.0
   opentracing==2.4.0
   requests==2.26.0
   six==1.16.0
   threadloop==1.0.2
   thrift==0.13.0
   tornado==6.1
   urllib3==1.26.6

   pip install -r requirements.txt

Buat file Python (misalnya, tracing_demo.py) dengan kode berikut: Parameter konfigurasi utama:

Parameter	Nilai	Deskripsi
`sampler.type`	`const`	Mensampel setiap jejak. Untuk produksi, gunakan `probabilistic` dengan nilai `param` yang lebih rendah.
`sampler.param`	`1`	Dengan tipe `const`, nilai `1` berarti mensampel semua jejak, `0` berarti tidak mensampel sama sekali.
`reporting_host`	`127.0.0.1`	Alamat agen Jaeger. Gunakan `127.0.0.1` saat dijalankan pada host yang sama.
`reporting_port`	`6831`	Port UDP tempat agen Jaeger mendengarkan rentang.
`service_name`	`mytest3`	Nama yang mengidentifikasi aplikasi Anda di konsol ARMS.

   import logging
   import time
   from jaeger_client import Config


   def construct_span(tracer):
       with tracer.start_span('AliyunTestSpan') as span:
           span.log_kv({'event': 'test message', 'life': 42})
           print("tracer.tags: ", tracer.tags)
           with tracer.start_span('AliyunTestChildSpan', child_of=span) as child_span:
               span.log_kv({'event': 'down below'})
           return span


   if __name__ == "__main__":
       log_level = logging.DEBUG
       logging.getLogger('').handlers = []
       logging.basicConfig(format='%(asctime)s %(message)s', level=log_level)

       config = Config(
           config={
               'sampler': {
                   'type': 'const',  # Sampel setiap jejak. Gunakan 'probabilistic' di produksi.
                   'param': 1,
               },
               'local_agent': {
                   # Alamat agen Jaeger. Tetap gunakan 127.0.0.1 jika agen
                   # berjalan pada host yang sama, yang direkomendasikan untuk keandalan UDP.
                   'reporting_host': '127.0.0.1',
                   'reporting_port': 6831,
               },
               'logging': True,
           },
           service_name="mytest3",  # Ganti dengan nama aplikasi Anda.
           validate=True
       )

       # Inisialisasi tracer. Ini juga mengatur opentracing.tracer.
       tracer = config.initialize_tracer()

       span = construct_span(tracer)

       # Beri waktu bagi IOLoop untuk mengosongkan rentang yang dibuffer sebelum ditutup.
       # Lihat: https://github.com/jaegertracing/jaeger-client-python/issues/50
       time.sleep(2)
       tracer.close()

Jalankan file tersebut: Saat inisialisasi berhasil, output debug akan menampilkan konfigurasi tracer dan mengonfirmasi bahwa rentang sedang dilaporkan ke agen Jaeger.
```
   python tracing_demo.py
```

Verifikasi data jejak di konsol

Masuk ke konsol ARMS. Di panel navigasi kiri, pilih Application Monitoring > Applications.
Di halaman Applications, pilih wilayah di bilah navigasi atas, lalu klik nama aplikasi Anda.
Catatan
Jika ikon muncul di kolom Language, aplikasi tersebut menggunakan Application Monitoring. Tanda hubung (-) menunjukkan Managed Service for OpenTelemetry.
Di bagian Application Overview, periksa metrik kinerja utama dan topologi.
Tab Overview Analysis pada halaman Application Overview menampilkan metrik inti berikut:
- Total Requests: jumlah permintaan, dengan perubahan minggu-ke-minggu dan hari-ke-hari.
- Average Response Time: waktu respons dan trennya.
- Exceptions: jumlah permintaan abnormal.
- Span Count: jumlah total rentang dalam jejak.
Di bawah metrik ini, area Services Provided dan Dependent Services masing-masing menampilkan grafik garis tren untuk volume permintaan dan waktu respons rata-rata.
Di panel navigasi kiri, klik Application Details. Tab Overview menampilkan ringkasan aplikasi.
Di halaman Application Details, tab Overview ditampilkan secara default. Halaman ini menampilkan topologi aplikasi dan tiga grafik pemantauan: Requests, response time, dan Exceptions. Daftar layanan di sisi kiri menampilkan waktu respons, jumlah permintaan, dan jumlah exception untuk setiap antarmuka.
Klik tab Traces untuk melihat data jejak yang dilaporkan dari aplikasi Anda.

Pemecahan masalah data jejak yang tidak muncul

Jika data jejak tidak muncul di konsol setelah Anda menjalankan aplikasi, periksa hal berikut:

Masalah	Tindakan
Agen Jaeger tidak berjalan	Jalankan `docker ps --filter name=jaeger-agent` dan verifikasi statusnya menunjukkan `Up`. Periksa log agen dengan `docker logs jaeger-agent`.
Titik akhir atau token salah	Verifikasi nilai `<endpoint>` dan `<auth>` sesuai dengan halaman Cluster Configurations. Mulai ulang agen setelah memperbaikinya.
Agen dan klien berada di host berbeda	Klien Jaeger mengirimkan data melalui UDP, yang tidak andal lintas host. Jalankan agen pada host yang sama dengan aplikasi dan atur `reporting_host` menjadi `127.0.0.1`.
Rentang tidak dikosongkan	Pastikan `time.sleep(2)` dipanggil sebelum `tracer.close()` agar IOLoop dapat mengosongkan rentang yang dibuffer.
Konektivitas jaringan	Verifikasi bahwa host dapat mencapai titik akhir Managed Service for OpenTelemetry pada port gRPC yang dikonfigurasi.

Operasi Jaeger umum

Contoh berikut mencakup operasi tracing Jaeger yang umum. Untuk detail selengkapnya, lihat Getting Started.

Buat tracer

from jaeger_client import Config

def init_jaeger_tracer(service_name='your-app-name'):
    config = Config(config={}, service_name=service_name)
    return config.initialize_tracer()

Buat dan akhiri rentang

# Mulai rentang root (tanpa induk).
tracer.start_span('TestSpan')

# Mulai rentang anak.
tracer.start_span('ChildSpan', child_of=span)

# Akhiri rentang.
span.finish()

Sebarkan SpanContext lintas layanan

# Inject: serialisasi SpanContext ke dalam carrier untuk layanan downstream.
tracer.inject(
    span_context=span.context, format=Format.TEXT_MAP, carrier=carrier
)

# Extract: deserialisasi SpanContext dari permintaan masuk.
span_ctx = tracer.extract(format=Format.TEXT_MAP, carrier={})