Menguasai Analisis Surih dengan Pautan Span menggunakan OpenTelemetry dan Signoz (Panduan Praktikal)

Tujuan Tutorial Ini

Tujuan Tutorial ini adalah untuk menyediakan panduan yang praktikal dan mudah difahami tentang pautan span dalam OpenTelemetry.

Ia bertujuan untuk membantu pembangun, terutamanya mereka yang bekerja dengan sistem yang kompleks dan tak segerak, memahami apa itu pautan span, bagaimana ia berbeza daripada hubungan ibu bapa-anak tradisional dalam pengesanan, dan sebab ia bernilai untuk korelasi jejak yang lebih baik.

Menjelang penghujung panduan ini, anda akan memperoleh kemahiran yang diperlukan untuk menggunakan pautan span dengan berkesan untuk menjejak interaksi dalam sistem teragih, yang membawa kepada kebolehmerhatian dan penyahpepijatan yang lebih baik.

Pengenalan Ringkas kepada Pengesanan Teragih

Pada masa lalu, Aplikasi biasanya bersifat monolitik, bermakna setiap proses atau ciri dilaksanakan sebagai satu unit pada satu pelayan. Pemantauan aplikasi sedemikian adalah mudah.

Sebagai Contoh: jika berlaku kesilapan, anda boleh melihat log daripada pelayan itu untuk mengenal pasti masalah tersebut. Walau bagaimanapun, peningkatan perkhidmatan mikro mengubah kesederhanaan ini.

Kini, aplikasi moden selalunya terdiri daripada berpuluh-puluh atau bahkan ratusan perkhidmatan bebas yang lebih kecil yang berfungsi bersama. Contohnya: apabila anda menggunakan apl mudah alih untuk membuat pesanan, mungkin terdapat perkhidmatan berasingan untuk mengendalikan pengesahan pengguna, memproses pembayaran, mengurus inventori dan menghantar e-mel pengesahan.

Perkhidmatan ini tidak selalu hidup pada pelayan yang sama malah boleh berkomunikasi melalui Internet, yang menambahkan kerumitan untuk menjejaki perkara yang berlaku apabila anda berinteraksi dengan aplikasi.

Di sinilah penjejakan teragih masuk. Fikirkan pengesanan teragih sebagai cara untuk mengikuti satu permintaan semasa ia bergerak melalui pelbagai perkhidmatan dalam aplikasi yang kompleks. Ia menjejaki perjalanan permintaan melalui sistem yang kompleks.

Dalam aplikasi moden, permintaan sering melalui pelbagai perkhidmatan, setiap satu dijalankan pada mesin yang berbeza. Pengesanan yang diedarkan membantu kami menggambarkan perjalanan ini, menjadikannya lebih mudah untuk mengenal pasti kesesakan dan ralat.

Ia seperti peta detektif yang menghubungkan titik-titik antara setiap langkah proses, menunjukkan kepada anda tempoh masa setiap bahagian diambil dan tempat sebarang isu berlaku. Apabila anda melihat jejak, anda melihat garis masa tentang cara permintaan anda bergerak melalui perkhidmatan yang berbeza, menjadikannya lebih mudah untuk mengenal pasti kelembapan, ralat atau kegagalan.

Repo Kod

Berikut ialah repo kod untuk tutorial ini:
[https://github.com/Noibisjunior/Span-Links-in-OpenTelemetry]

Peranan OpenTelemetry dalam Kebolehcerapan Moden

OpenTelemetry ialah pemain utama dalam membolehkan keterlihatan jenis ini. Ia merupakan rangka kerja pemerhatian sumber terbuka yang membolehkan pembangun mengumpul data seperti log, metrik dan surih daripada aplikasi mereka. Ia berfungsi sebagai set alat untuk menangkap maklumat terperinci tentang perkara yang berlaku dalam perkhidmatan anda.

Dalam dunia pemerhatian moden, OpenTelemetry membantu anda memahami prestasi dan kesihatan aplikasi yang diedarkan anda. Ia bertindak seperti jambatan yang mengumpulkan data daripada pelbagai perkhidmatan dan menghantarnya ke alatan seperti SigNoz, di mana anda boleh memvisualisasikan perkara yang sedang berlaku. Ini menjadikan OpenTelemetry tidak ternilai untuk mengenal pasti kesesakan, menjejak ralat dan memastikan aplikasi anda berjalan lancar.

Dengan menggunakan OpenTelemetry dengan pengesanan teragih, anda boleh mendapatkan gambaran penuh tentang bagaimana aplikasi anda berkelakuan, menjadikannya lebih mudah untuk mendiagnosis isu dan meningkatkan pengalaman pengguna.

Kepentingan rentang sebagai blok bangunan untuk mengesan dalam OpenTelemetry

Memandangkan perisian, terutamanya sistem teragih berkembang dalam kerumitan, memahami kerja dalaman mereka menjadi satu tugas yang mencabar. Di situlah peluang OpenTelemetry masuk untuk menyelesaikan cabaran dengan mudah.

Apakah Span?

Span ialah unit kerja asas dalam sistem pengesanan OpenTelemetry. Ia ialah satu operasi atau peristiwa yang berlaku dalam aplikasi anda.

Ia menangkap apa yang berlaku semasa operasi itu, tempoh masa yang diambil dan sebarang butiran yang berkaitan, seperti sama ada ia berjaya atau gagal.

Sebagai contoh, bayangkan aplikasi anda memproses permintaan pengguna:

• Apabila permintaan masuk, OpenTelemetry mencipta rentang yang mewakili permintaan yang diterima.
• Jika permintaan itu kemudian mencetuskan pertanyaan pangkalan data, rentang lain dibuat untuk mewakili interaksi pangkalan data tersebut.
• Jika apl memanggil perkhidmatan lain, rentang lain menjejakinya.

Atribut utama rentang:

1. Nama: Label deskriptif untuk operasi (cth., "Dapatkan Data Pengguna").
2. Cap Masa Mula dan Tamat: Masa operasi bermula dan tamat.
3. Span Induk: Span yang memulakan operasi ini.
4. Teg: Metadata tambahan (cth., kod status HTTP, mesej ralat).

Cara Span Bekerja Bersama untuk Mencipta Jejak

Secara individu, rentang berguna, tetapi ia berkesan apabila ia bekerjasama untuk membentuk jejak.

Jejak ialah koleksi rentang yang mewakili keseluruhan perjalanan permintaan atau operasi semasa ia mengalir melalui sistem anda.

Mari kita kembali kepada contoh permintaan pengguna kami:

Jejak bermula apabila permintaan memasuki sistem, dan rentang akar dibuat. Apabila permintaan mencetuskan pertanyaan pangkalan data, rentang interaksi pangkalan data dipautkan ke rentang akar, menunjukkan bahawa ia adalah sebahagian daripada proses yang sama.

Jangka tambahan untuk memanggil perkhidmatan lain ditambahkan pada jejak. Dengan melihat jejak ini, anda boleh melihat gambaran besar tentang cara permintaan itu melalui bahagian sistem anda yang berlainan. Ia membantu anda memahami bukan sahaja perkara yang berlaku, tetapi cara bahagian aplikasi anda yang berlainan disambungkan.

Mengapa Span Penting?

1. Menunjukkan Masalah: Span membantu anda mengezum masuk apabila berlaku masalah. Jika permintaan lambat, span boleh memberitahu anda sama ada pertanyaan pangkalan data, panggilan rangkaian atau bahagian lain proses yang menyebabkan kelewatan. Anda boleh melihat rentang mana yang mengambil masa lebih lama daripada jangkaan, menjadikannya lebih mudah untuk mencari kesesakan.

2. Konteks Binaan: Setiap rentang mengandungi maklumat kontekstual seperti masa mula, masa tamat dan label tersuai (atribut). Data ini memberikan cerapan tentang perkara yang berlaku pada masa tertentu dalam sistem anda, seperti ID pengguna khusus yang terlibat dalam permintaan atau pertanyaan yang telah dilaksanakan.

3. Mewujudkan Perhubungan: Span mempunyai hubungan antara satu sama lain, selalunya dalam struktur ibu bapa-anak. Rentang akar ialah induk, dan rentang seterusnya ialah anak-anaknya. Struktur ini membantu anda melihat susunan peristiwa berlaku dan cara ia bergantung antara satu sama lain. Ia seperti melihat salasilah keluarga operasi dalam apl anda.

4. Menyahpepijat Sistem Teragih: Untuk aplikasi dengan perkhidmatan mikro (di mana perkhidmatan berbeza mengendalikan bahagian permintaan yang berbeza), rentang amat penting. Ia membantu anda menjejaki permintaan semasa ia bergerak antara perkhidmatan, walaupun perkhidmatan tersebut dijalankan pada pelayan yang berbeza atau di pusat data yang berbeza. Ini adalah kunci untuk memahami interaksi kompleks antara perkhidmatan.

Memahami Pautan Span dalam OpenTelemetry

Apakah Pautan Span?

Dalam dunia sistem teragih, di mana pelbagai perkhidmatan bekerjasama untuk mengendalikan permintaan pengguna, pengesanan adalah seperti peta detektif, ia menunjukkan laluan yang diambil oleh permintaan semasa ia bergerak melalui perkhidmatan ini. Setiap aktiviti dalam perjalanan ini dipanggil span, dan perjalanan yang lengkap dipanggil jejak.

Secara tradisinya, rentang disambungkan menggunakan hubungan ibu bapa-anak. Bayangkan ini seperti salasilah keluarga: rentang ibu bapa memulakan proses (seperti membuat permintaan kepada perkhidmatan lain), dan rentang anak mewakili aktiviti yang berlaku akibatnya (seperti perkhidmatan memproses permintaan). Ini ialah cara yang mudah untuk mewakili aliran permintaan.

Tetapi apa yang berlaku apabila dua rentang adalah berkaitan, namun ia tidak sesuai dengan sempurna dalam hierarki ibu bapa-anak itu? Di sinilah pautan span masuk.

Satu pautan rentang membolehkan anda menyambungkan dua rentang yang berkaitan tetapi tidak mempunyai hubungan langsung ibu bapa-anak. Ia seperti "rujukan" atau "jalan pintas" antara dua aktiviti dalam sistem teragih.

Sebagai contoh, katakan anda mempunyai pengguna yang membuat permintaan yang mencetuskan berbilang proses bebas, seperti menghantar e-mel dan menulis ke pangkalan data. Proses ini bukan aktiviti kanak-kanak antara satu sama lain; mereka berlaku sebelah menyebelah. Menggunakan pautan span, anda boleh menunjukkan bahawa jangka masa penghantaran e-mel dan jangka masa penulisan pangkalan data adalah berkaitan dengan permintaan pengguna awal yang sama, walaupun ia tidak disambungkan secara langsung dalam konsep ibu bapa-anak.

Bagaimana Pautan Span Berbeza daripada Hubungan Ibu Bapa-Anak

Hubungan Ibu Bapa-Anak: ia adalah rangkaian acara yang mudah. Seorang pengguna menghantar permintaan (ibu bapa), yang mencetuskan penciptaan rekod dalam pangkalan data (anak). Jangka masa kanak-kanak tidak akan wujud tanpa rentang ibu bapa, menjadikannya akibat langsung.

Pautan Span: Ini lebih seperti melukis garis putus-putus antara aktiviti yang berkaitan dalam sesetengah konteks tetapi tidak mengikut rantaian tindakan langsung. Mereka menyediakan cara untuk mengatakan, "Perkara ini berkaitan, walaupun satu tidak secara langsung menyebabkan yang lain." Pautan span sesuai untuk mewakili aktiviti atau acara selari yang berinteraksi tetapi tidak mengikut hierarki sepenuhnya.

Kepentingan Pautan Span dalam Sistem Kompleks dan Asynchronous

Pautan span amat berharga dalam sistem yang kompleks dan tak segerak, di mana aliran peristiwa tidak selalu mengikut laluan ibu bapa-anak yang jelas. Berikut ialah beberapa senario bagaimana ia boleh digunakan secara praktikal;

Aliran Kerja Tak Segerak:

Bayangkan permintaan pengguna yang bermula dengan kerja latar belakang (seperti menjana laporan). Permintaan awal selesai, tetapi penjanaan laporan diteruskan di latar belakang.

Dengan pelaksanaan pautan span, anda boleh mengaitkan rentang permintaan awal dengan rentang kerja latar belakang, walaupun ia tidak mengikut corak ibu bapa-anak secara langsung.

Komunikasi Perkhidmatan Mikro:

Dalam seni bina perkhidmatan mikro, perkhidmatan sering berkomunikasi antara satu sama lain dengan cara yang tidak mengikut hierarki.

Sebagai contoh, tindakan pengguna boleh mencetuskan berbilang perkhidmatan untuk memproses bahagian data yang berbeza secara serentak. Pautan span membolehkan anda menjejak span bebas dan berkaitan ini sebagai sebahagian daripada aliran kerja yang lebih luas.

Pemprosesan Kelompok: Jika anda sedang memproses kumpulan data di mana setiap item dalam kumpulan menjana rentangnya sendiri, anda boleh menggunakan pautan rentang untuk menyambungkan rentang ini kembali kepada proses kumpulan asal.

Ini menjadikannya lebih mudah untuk mengesan keseluruhan kitaran hayat satu kelompok dan memahami cara item individu berkaitan kembali dengan proses utama.

Prasyarat: Alat dan Perpustakaan diperlukan untuk Mengkonfigurasi Pautan Span menggunakan OpenTelemetry dan Signoz

1. SDK OpenTelemetry: SDK OpenTelemetry (Kit Pembangunan Perisian) ialah kit alat anda untuk mengumpulkan data kebolehmerhatian seperti surih, metrik dan log daripada aplikasi anda.

• Ia bertindak sebagai jambatan antara kod dan sistem kebolehmerhatian anda, membolehkan anda mengumpul maklumat terperinci tentang cara aplikasi anda berjalan.

• Bayangkan OpenTelemetry sebagai “kamera” yang menangkap gambar operasi aplikasi anda. Dengan menyepadukan SDK ke dalam apl anda, anda meletakkan kamera ini untuk merakam perkara yang berlaku di sebalik tabir.

• Anda perlu memasang SDK dalam bahasa pengaturcaraan aplikasi anda (cth., Python, Java, JavaScript).

(2) Persediaan SigNoz: SigNoz ialah alat pemerhatian sumber terbuka yang membolehkan anda memvisualisasikan dan menganalisis data yang anda kumpulkan dengan OpenTelemetry.

• Fikirkan SigNoz sebagai "bilik kawalan" tempat anda melihat rakaman yang ditangkap oleh persediaan OpenTelemetry anda. Di sinilah anda mempunyai gambaran yang jelas tentang kesan dan metrik dalam aplikasi anda.

• Anda perlu menyediakan tika SigNoz, yang melibatkan penggunaannya pada mesin tempatan anda atau pada pelayan, biasanya menggunakan Docker atau Kubernetes.

• SigNoz membantu mengubah data mentah menjadi visualisasi, seperti graf dan carta, menjadikannya lebih mudah untuk memahami perkara yang berlaku dalam aplikasi anda.

Pengetahuan Asas Jejak, Span dan Kod Instrumen:

Jejak:

Dalam istilah mudah, jejak adalah seperti "cerita" tentang perkara yang berlaku apabila pengguna atau permintaan berinteraksi dengan aplikasi anda. Ia menangkap semua tindakan yang berlaku akibat interaksi itu, daripada permintaan awal kepada semua perkhidmatan dan pangkalan data yang mungkin terlibat.

Bayangkan pengguna mengklik butang di tapak web anda. Jejak akan merekodkan setiap langkah apa yang berlaku seterusnya.

Span:

Span ialah "bab" dalam cerita jejak. Setiap rentang mewakili operasi atau tugas tertentu yang berlaku sebagai sebahagian daripada jejak.

Sebagai contoh, jika jejak menangkap keseluruhan proses permintaan pengguna, rentang boleh mewakili satu langkah, seperti menanyakan pangkalan data atau memanggil API luaran.

Setiap rentang mempunyai masa mula dan tamat, memberikan anda butiran tepat tentang tempoh setiap langkah diambil. Ini memudahkan untuk menentukan sebarang kelembapan atau ralat.

Kod Instrumen dengan OpenTelemetry:

Instrumentasi ialah proses menambahkan kod pada aplikasi anda untuk mengumpul data kebolehmerhatian. Dengan memperalatkan kod anda dengan OpenTelemetry, ini biasanya melibatkan penambahan beberapa baris kod di mana anda ingin mencipta jejak dan rentang.

Sebagai contoh, anda mungkin menggunakan pertanyaan pangkalan data untuk melihat tempoh masa yang diambil atau menggunakan proses log masuk pengguna untuk menjejak prestasinya.

SDK OpenTelemetry menjadikannya lebih mudah dengan menyediakan perpustakaan dan fungsi yang boleh anda sepadukan terus ke dalam kod anda. Fikirkan ia seperti melampirkan penjejak pada bahagian mesin untuk memantau cara ia berfungsi bersama.

Mencipta Pautan Span dalam Python: Contoh Langkah demi Langkah

Mari kita lihat contoh asas dalam Python. Kami akan menggunakan OpenTelemetry SDK untuk mencipta dua rentang dan memautkannya bersama-sama.

from opentelemetry import trace
from opentelemetry.trace import Link
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor, ConsoleSpanExporter

# Set up the tracer provider and span exporter

trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)
span_processor = SimpleSpanProcessor(ConsoleSpanExporter())
trace.get_tracer_provider().add_span_processor(span_processor)

# Create the first span, simulating some work being done 

with tracer.start_as_current_span("span_one") as span_one:
    span_one.add_event("Processing order")
 order_id = "12345" # Imagine this as an order ID we're processing

# Create a second span with a link to the first span 

with tracer.start_as_current_span("span_two", links=[Link(span_one.get_span_context())]) as span_two:
        span_two.add_event("Updating order status")

# Simulate some additional work here

  print("Order ID: {order_id} has been updated.")

print("Tracing complete")

Penjelasan Coretan Kod Python Di Atas

• Sediakan Pembekal Pengesan:
  Coretan kod di atas bermula dengan pembekal pengesan, yang menguruskan penciptaan rentang.

• Ini penting untuk OpenTelemetry mengetahui cara mengendalikan rentang. Kami juga mengkonfigurasi SimpleSpanProcessor dan ConsoleSpanExporter untuk mencetak data span ke konsol. Ini membantu kami melihat jenis rentang yang sedang dibuat dan cara ia dipautkan
  .

(2) Buat Span Pertama (span_one):

Menggunakan kaedah tracer.start_as_current_span, kami mencipta span yang dipanggil span_one. Ini boleh mewakili sebarang tindakan, seperti memproses pesanan.

Dalam tempoh ini, kami menambah urutan Pemprosesan acara untuk menunjukkan perkara yang berlaku pada masa tertentu itu.

Kami juga mensimulasikan ID pesanan (order_id = "12345") yang akan digunakan dalam tempoh seterusnya.

(3) Buat Span Kedua dengan Pautan (span_two):

Di sini, kami memulakan rentang lain yang dipanggil span_two untuk mewakili tindakan yang berbeza tetapi berkaitan—seperti mengemas kini status pesanan.
Perhatikan parameter pautan. Kami menggunakan Pautan(span_one.get_span_context()) untuk membuat pautan antara span_two dan span_one.

Ini memberitahu OpenTelemetry, "Walaupun tindakan ini bukan ibu bapa-anak, ia berkaitan."

Di dalam span_two, kami menambahkan acara lain, Mengemas kini status pesanan dan mensimulasikan beberapa kerja seperti mengemas kini status pesanan dalam pangkalan data.

(4) Output:

Apabila anda menjalankan kod ini, anda akan melihat output dalam konsol daripada ConsoleSpanExporter yang menunjukkan kedua-dua rentang, bersama-sama dengan pautan antara mereka. Ini membantu menggambarkan cara kedua-dua rentang ini berkait antara satu sama lain dalam satu jejak.

Ralat Biasa yang perlu diberi perhatian dan Cara Menyelesaikan Masalah Ralat.

(1) Konteks Span Tiada:

Ralat: Jika anda cuba mencipta pautan tanpa memanggil span_one.get_span_context(), anda akan mendapat ralat kerana OpenTelemetry memerlukan konteks span yang sah untuk membuat pautan.

Penyelesaian: Sentiasa pastikan anda melepasi konteks rentang semasa membuat pautan. Gunakan kaedah .get_span_context() bagi rentang aktif.

(2) Memautkan Rentang yang Belum Bermula atau Berakhir:

Ralat: Jika anda cuba membuat pautan ke rentang yang belum dimulakan atau telah tamat, anda mungkin menghadapi masalah di mana pautan tidak dikenali.

Penyelesaian: Pastikan tempoh yang anda pautkan aktif apabila anda membuat pautan. Mencipta pautan dengan rentang yang telah tamat boleh menyebabkan tingkah laku yang tidak dijangka dalam cara jejak dipaparkan.

(3) Pertimbangan Prestasi:

Isu Prestasi: Memautkan terlalu banyak rentang boleh meningkatkan overhed data surih, yang membawa kepada kemerosotan prestasi dalam sistem trafik tinggi.

Penyelesaian: Gunakan pautan secara terpilih. Hanya pautan menjangkau apabila terdapat hubungan bermakna yang anda perlukan untuk menggambarkan atau menganalisis. Untuk persekitaran trafik tinggi, anda boleh menggunakan pilihan pensampelan OpenTelemetry untuk mengurangkan jumlah data surih yang ditangkap.

Mengkonfigurasi SigNoz untuk Visualisasi Pautan Span

Apabila bekerja dengan sistem teragih, memahami cara bahagian sistem anda yang berbeza berkomunikasi adalah penting. Span pautan dalam OpenTelemetry memainkan peranan penting dalam menghubungkan jejak yang mungkin tidak mempunyai hubungan ibu bapa-anak secara langsung, memberikan gambaran yang lebih jelas tentang cara permintaan mengalir melalui perkhidmatan anda.

Mengapa Menggambarkan Pautan Span Penting

Bayangkan aplikasi anda mempunyai perkhidmatan pembayaran yang mencetuskan perkhidmatan pemberitahuan apabila pembayaran berjaya. Walaupun perkhidmatan ini berinteraksi, mereka mungkin tidak berkongsi hubungan ibu bapa dan anak secara langsung.

Pautan span membolehkan anda mengaitkan interaksi ini, menunjukkan bahawa pembayaran telah mencetuskan pemberitahuan. Memvisualisasikan pautan ini membantu anda melihat gambaran yang lebih besar tentang cara perkhidmatan bebas berkait dalam masa nyata.

Dengan menyediakan SigNoz untuk memvisualisasikan pautan span ini, anda boleh mendapatkan cerapan yang lebih mendalam tentang gelagat aplikasi anda.

Begini cara anda boleh mengkonfigurasi SigNoz untuk Tangkap dan Lihat Pautan Span

Langkah 1: Pastikan SigNoz Dipasang Dengan Betul

• Untuk bermula, pastikan anda telah memasang dan menjalankan SigNoz pada persekitaran setempat anda atau dalam persediaan awan. SigNoz boleh digunakan menggunakan Docker untuk persediaan mudah.
• Jika anda belum melakukannya lagi, ikut panduan pemasangan SigNoz rasmi untuk sistem pengendalian anda [https://signoz.io/docs/introduction]
• Setelah dipasang, akses UI SigNoz dengan menavigasi ke http://localhost:3301 dalam pelayar web anda. Antara muka ini ialah tempat anda akan mengkonfigurasi tetapan dan menggambarkan data surih anda, termasuk pautan span.

Langkah 2: Konfigurasikan OpenTelemetry SDK untuk memasukkan Pautan Span anda

Langkah seterusnya ialah memastikan OpenTelemetry SDK anda dikonfigurasikan untuk menghantar data pautan span ke SigNoz. Dalam kod aplikasi anda, anda perlu menambah pautan span sebagai sebahagian daripada logik pengesanan anda.

Berikut ialah coretan kod dalam bahasa pengaturcaraan Python:

from opentelemetry import trace
from opentelemetry.trace import Link
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor, ConsoleSpanExporter

# Set up the tracer provider and span exporter

trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)
span_processor = SimpleSpanProcessor(ConsoleSpanExporter())
trace.get_tracer_provider().add_span_processor(span_processor)

# Create the first span, simulating some work being done 

with tracer.start_as_current_span("span_one") as span_one:
    span_one.add_event("Processing order")
 order_id = "12345" # Imagine this as an order ID we're processing

# Create a second span with a link to the first span 

with tracer.start_as_current_span("span_two", links=[Link(span_one.get_span_context())]) as span_two:
        span_two.add_event("Updating order status")

# Simulate some additional work here

  print("Order ID: {order_id} has been updated.")

print("Tracing complete")

Penjelasan coretan kod python di atas

Kami bermula dengan mengkonfigurasi TracerProvider untuk mengendalikan pengesanan dalam aplikasi kami dan menyediakan pemproses span.

OTLPSpanExporter digunakan untuk menghantar rentang ke bahagian belakang SigNoz menggunakan protokol OTLP.

Ganti http://localhost:4317 dengan titik akhir SigNoz yang sesuai jika anda tidak menjalankan SigNoz secara setempat.

Kedua, Mencipta Span dan Pautan:

parent_span dicipta dahulu, mewakili operasi awal (cth., permintaan pengguna). Kami mengekstrak konteks parent_span menggunakan get_span_context(), yang membolehkan kami memautkan span lain kepadanya.

linked_span kemudian dibuat dan Pautan ditambahkan untuk merujuk konteks parent_span. Ini menandakan bahawa walaupun linked_span bukan anak langsung parent_span, ia berkaitan dengannya.

Akhir sekali, Menghantar Data ke SigNoz:

Data span diproses menggunakan BatchSpanProcessor, yang memastikan data span dihantar ke SigNoz dengan cekap.

trace.get_tracer_provider().shutdown() dipanggil pada penghujung untuk memastikan bahawa mana-mana rentang yang tinggal disiram dan dieksport sebelum program keluar.

Langkah 3: Kemas Kini Konfigurasi SigNoz untuk Mengesan Data

• Untuk memastikan SigNoz menangkap pautan span, anda mungkin perlu menukar beberapa tetapan dalam fail konfigurasi pengumpul SigNoz anda.
• Pengumpul bertindak sebagai orang tengah yang menerima data surih daripada OpenTelemetry dan menghantarnya ke bahagian belakang SigNoz.
• Cari fail konfigurasi OpenTelemetry Collector, selalunya dinamakan otel-collector-config.yaml.
• Tambah atau kemas kini bahagian pemproses dan pengeksport untuk memastikan data surih dimajukan dengan betul. Contohnya:

from opentelemetry import trace
from opentelemetry.trace import SpanKind, Link
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter

# Set up the tracer provider and add a span processor

trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)

# Configure the exporter to send spans to SigNoz using the OTLP exporter

otlp_exporter = OTLPSpanExporter(endpoint="http://localhost:4317", insecure=True)
span_processor = BatchSpanProcessor(otlp_exporter)
trace.get_tracer_provider().add_span_processor(span_processor)

# Create two spans, linking the second span to the context of the first

with tracer.start_as_current_span("parent_span") as parent_span:

# Simulate some logic for the parent_span
    print("Parent span is active")

# Get the context of the parent span
parent_context = parent_span.get_span_context()

# Create a linked span and add a link to the parent span's context

with tracer.start_as_current_span(
        "linked_span",
        links=[Link(parent_context)]
    ) as linked_span:

 # Simulate some logic for the linked_span
        print("Linked span is active")

# Ensure all spans are flushed before exiting the application

trace.get_tracer_provider().shutdown()

Langkah 4: Visualisasikan Pautan Span dalam SigNoz

Setelah aplikasi anda menghantar data surih dengan pautan span ke SigNoz, anda boleh memvisualisasikan pautan ini dengan:

• Membuka Trace Explorer dalam UI SigNoz.
• Cari jejak yang berkaitan dengan perkhidmatan yang anda pantau (cth., perkhidmatan pembayaran dan perkhidmatan pemberitahuan).
• Dalam paparan butiran surih, anda akan melihat perwakilan grafik rentang, termasuk sebarang pautan antara rentang. Rentang terpaut akan muncul sebagai sambungan tambahan antara nod yang tidak berkongsi talian induk-anak langsung.
• Penggambaran ini membantu anda melihat cara permintaan mengalir melalui sistem anda, walaupun perkhidmatan tidak mempunyai hubungan hierarki yang ketat.

Langkah 5: Laraskan Pandangan Anda untuk Kejelasan

Untuk mendapatkan visualisasi yang sempurna, anda perlu mengambil perhatian perkara berikut:

• Gunakan penapis dalam SigNoz untuk mengecilkan data surih kepada perkhidmatan atau tempoh masa tertentu.
• Buat papan pemuka tersuai untuk menjejak pautan span tertentu jika anda kerap memantau interaksi tertentu.
• Sediakan makluman dalam SigNoz untuk memberitahu anda apabila rentang terpaut menunjukkan isu yang berpotensi, seperti kelewatan antara perkhidmatan yang berkaitan.

Langkah Seterusnya
Dalam tutorial ini, kami mempelajari cara menggunakan pautan span untuk menjejak interaksi dalam sistem teragih

Dalam tutorial seterusnya, kita akan mempelajari Amalan Terbaik untuk Menggunakan Pautan Span dan Kes Penggunaan Lanjutan

Atas ialah kandungan terperinci Menguasai Analisis Surih dengan Pautan Span menggunakan OpenTelemetry dan Signoz (Panduan Praktikal). Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!