System Observability: Logging, Metrics & Tracing (ELK + OpenTelemetry) · บทเรียน

กลยุทธ์การสุ่มตัวอย่างสำหรับร่องรอย

ทำความเข้าใจว่าเหตุใดจึงต้องสุ่มตัวอย่างร่องรอย ความแตกต่างระหว่างการสุ่มตัวอย่างจากต้นทางและปลายทาง และวิธีสร้างสมดุลระหว่างการมองเห็นกับต้นทุน

บทเรียน 4 จาก 413 ขั้นตอน

กลยุทธ์การสุ่มตัวอย่างสำหรับร่องรอย เป็นบทเรียน System Observability: Logging, Metrics & Tracing (ELK + OpenTelemetry) ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน System Observability: Logging, Metrics & Tracing (ELK + OpenTelemetry) และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส System Observability: Logging, Metrics & Tracing (ELK + OpenTelemetry) มีบทเรียนทั้งหมด 4 บทเรียน

บางส่วนของบทเรียนนี้ยังไม่ได้รับการแปล และแสดงเป็นภาษาอังกฤษ

Why Sample Traces?

Capturing every trace in a busy system produces enormous data volumes. Sampling keeps a representative subset to control storage and processing cost while preserving useful insight.

The Cost of Full Tracing

A service handling thousands of requests per second can emit millions of spans per minute. Storing all of them is expensive and rarely necessary for diagnosis.

  • Network overhead
  • Backend storage
  • Query latency

Head-Based Sampling

Head-based sampling decides at the start of a trace whether to keep it, before the outcome is known. It is cheap and simple.

sampler: traceidratio
ratio: 0.10  // keep 10% of traces

Probabilistic Sampling

A common head-based form keeps a fixed percentage. The decision is made on the trace ID so all spans in a trace agree.

if hash(trace_id) % 100 < 10:
    keep()
else:
    drop()

Tail-Based Sampling

Tail-based sampling waits until a trace finishes, then decides using the full picture. It can prioritize errors and slow requests.

if trace.has_error or trace.duration > 2s:
    keep()
else:
    sample(0.05)

Trade-Offs

Each approach has costs.

  • Head-based: cheap, but may drop the rare error you needed
  • Tail-based: keeps interesting traces, but buffers spans and uses more memory

Consistent Sampling

The sampling decision must be consistent across services so a trace is kept whole, not in fragments. The decision propagates via the trace context.

traceparent: 00-<trace-id>-<span-id>-01
// the 01 flag marks the trace as sampled

Rate Limiting

Rate-limiting samplers cap traces per second, protecting the backend during traffic spikes regardless of percentage.

sampler: rate_limiting
max_traces_per_second: 100

Sampling in the Collector

The OpenTelemetry Collector can apply tail sampling centrally, freeing apps from the decision.

processors:
  tail_sampling:
    policies:
      - name: errors
        type: status_code
        status_codes: [ERROR]

Choosing a Strategy

Start with head-based probabilistic sampling for simplicity. Move to tail-based when you must guarantee that errors and slow traces are always captured.

Always Keep the Important

Combine strategies: sample normal traffic lightly but keep 100% of errors and high-latency traces. This maximizes signal per stored byte.

Quick Check

Pick the strategy that guarantees error traces are kept.

Recap

You learned why traces are sampled, how head-based sampling decides up front cheaply while tail-based waits for the full trace to keep errors and slow requests, and that decisions must propagate consistently. Combining light sampling of normal traffic with full capture of important traces gives the best signal for the cost.

เริ่มต้นได้ฟรี

เรียนรู้ System Observability: Logging, Metrics & Tracing (ELK + OpenTelemetry) ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส
12
บทเรียน
48

คำถามที่พบบ่อย

บทเรียน “กลยุทธ์การสุ่มตัวอย่างสำหรับร่องรอย” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “กลยุทธ์การสุ่มตัวอย่างสำหรับร่องรอย” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส System Observability: Logging, Metrics & Tracing (ELK + OpenTelemetry) ให้อัปเกรดเป็น CoddyKit PRO คอร์ส System Observability: Logging, Metrics & Tracing (ELK + OpenTelemetry) มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “กลยุทธ์การสุ่มตัวอย่างสำหรับร่องรอย”

ทำความเข้าใจว่าเหตุใดจึงต้องสุ่มตัวอย่างร่องรอย ความแตกต่างระหว่างการสุ่มตัวอย่างจากต้นทางและปลายทาง และวิธีสร้างสมดุลระหว่างการมองเห็นกับต้นทุน คุณปฏิบัติ System Observability: Logging, Metrics & Tracing (ELK + OpenTelemetry) ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน System Observability: Logging, Metrics & Tracing (ELK + OpenTelemetry) หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน System Observability: Logging, Metrics & Tracing (ELK + OpenTelemetry) บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “กลยุทธ์การสุ่มตัวอย่างสำหรับร่องรอย” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน System Observability: Logging, Metrics & Tracing (ELK + OpenTelemetry) นี้ได้ไหม

ได้ บทเรียน System Observability: Logging, Metrics & Tracing (ELK + OpenTelemetry) ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. ทำความเข้าใจสแปนและรหัสประจำแทรซ
  2. การทำงานของการติดตามแบบกระจาย
  3. การติดตามเทียบกับการบันทึกล็อกและตัวชี้วัด
  4. กลยุทธ์การสุ่มตัวอย่างสำหรับร่องรอย
← กลับไปที่ System Observability: Logging, Metrics & Tracing (ELK + OpenTelemetry)