การสังเกตการณ์ (Observability)
คุณอาจเคยเจอกับสถานการณ์ที่มีอะไรบางอย่างพังบน production แล้วคุณต้องมานั่งจ้องกำแพงของ log ที่แทบไม่ได้ช่วยอะไรเลย พยายามปะติดปะต่อว่าเกิดอะไรขึ้นกันแน่ ผมเองก็เคยผ่านจุดนั้นมาแล้ว นี่คือสิ่งที่ Observability จะเข้ามาช่วยป้องกัน เพราะมันคือแนวทางที่ทำให้เรารู้ว่าแอปพลิเคชันของเรากำลังทำอะไรอยู่จริงๆ เมื่อถูกรันอยู่ในโลกความเป็นจริง โดยไม่จำเป็นต้องพยายามจำลองปัญหานั้นขึ้นมาใหม่บนเครื่องของเรา
ecosystem ของ Rust ได้เลือกให้ crate tracing เป็นมาตรฐานหลักสำหรับการบันทึกข้อมูลแบบมีโครงสร้างพร้อมบริบท (structured, contextual logging) เมื่อคุณนำมันมาผสานเข้ากับ OpenTelemetry สำหรับการทำ distributed tracing และการเก็บ metrics คุณก็จะได้ observability stack ที่แข็งแกร่งและครอบคลุมเกือบทุกอย่างที่เราจำเป็นต้องใช้
การบันทึกข้อมูลแบบมีโครงสร้างด้วย tracing
หากคุณเคยใช้ log หรือ env_logger มาก่อน tracing อาจดูคุ้นเคยในแวบแรก แต่มันทำงานแตกต่างกันอย่างสิ้นเชิงภายใต้ฝากระโปรง: แทนที่จะปล่อยข้อความสตริงแบบแบนๆ ออกมา มันจะส่งเหตุการณ์แบบมีโครงสร้าง (structured events) พร้อม typed fields ออกมาแทน นั่นหมายความว่าเครื่องมือวิเคราะห์ log ของคุณจะสามารถกรอง รวมกลุ่ม และ query ตามฟิลด์เฉพาะเจาะจงได้จริงๆ แทนที่จะต้องมานั่งเขียน regex แกะข้อมูลออกจากสตริง นอกจากนี้ยังรองรับ Span ซึ่งใช้แทนช่วงเวลาของการทำงาน (เช่น ระยะเวลาของ HTTP request หรือ database query) และคอยเก็บ context ที่จะถูกแนบไปกับทุกๆ เหตุการณ์ที่เกิดขึ้นภายใน span นั้นโดยอัตโนมัติ
การตั้งค่าซับสไครเบอร์
Subscriber ของ tracing ทำหน้าที่ควบคุมว่าเหตุการณ์ต่างๆ จะถูกจัดรูปแบบอย่างไรและถูกส่งไปที่ปลายทางไหน ในระหว่างการพัฒนา เราย่อมต้องการ output ที่มนุษย์อ่านเข้าใจง่ายพร้อมสีสัน เพื่อให้เราอ่านสิ่งที่เกิดขึ้นใน terminal ได้สะดวก ส่วนใน production เราต้องการ output แบบ JSON ที่ระบบรวบรวม log สามารถ parse ประมวลผลต่อได้
#![allow(unused)]
fn main() {
use tracing_subscriber::{
fmt, layer::SubscriberExt, util::SubscriberInitExt, EnvFilter,
};
pub fn init_tracing(log_level: &str) {
let env_filter = EnvFilter::try_from_default_env()
.unwrap_or_else(|_| EnvFilter::new(log_level));
// Use runtime configuration rather than build profile to control
// log format. A release build in staging should still be readable,
// and a debug build against production data should still emit JSON.
let json_output = std::env::var("LOG_JSON")
.map(|v| v == "true" || v == "1")
.unwrap_or(false);
let fmt_layer = if json_output {
fmt::layer().json().boxed()
} else {
fmt::layer().pretty().boxed()
};
tracing_subscriber::registry()
.with(env_filter)
.with(fmt_layer)
.init();
}
}
EnvFilter ช่วยให้เราควบคุมระดับ log level ได้ตอนรันไทม์ผ่าน environment variable RUST_LOG คุณสามารถตั้งระดับที่ต่างกันแยกเป็นรายโมดูลได้ ซึ่งช่วยได้มากเวลาที่เราต้องการเพิ่มความละเอียดเฉพาะบางคอมโพเนนต์โดยไม่ต้องจมอยู่ใน log จากส่วนอื่นไปทั้งหมด:
RUST_LOG=info,my_app::infra=debug,sqlx=warn
การเทรซคำขอด้วย TraceLayer
TraceLayer จาก tower-http จะสร้าง span ให้กับแต่ละ HTTP request โดยอัตโนมัติ พร้อมทั้งบันทึกเมธอด, URI, status code และระยะเวลาที่ใช้ เมื่อเรานำมันมาจับคู่กับ request ID เราก็จะสามารถตามรอยคำขอหนึ่งคำขอผ่านรายการ log ทั้งหมดที่มันสร้างขึ้นได้ มาดูกันว่าหน้าตาเป็นแบบไหน:
#![allow(unused)]
fn main() {
use tower_http::trace::TraceLayer;
let trace_layer = TraceLayer::new_for_http()
.make_span_with(|request: &http::Request<_>| {
let request_id = request
.headers()
.get("x-request-id")
.and_then(|v| v.to_str().ok())
.unwrap_or("unknown");
// Prefer the matched route pattern (e.g., "/api/v1/users/{id}")
// over the raw URI (e.g., "/api/v1/users/550e8400-...").
// Raw URIs create high-cardinality span fields that can overwhelm
// metrics backends and make aggregation impossible.
let matched_path = request.extensions()
.get::<axum::extract::MatchedPath>()
.map(|p| p.as_str().to_string())
.unwrap_or_else(|| request.uri().path().to_string());
tracing::info_span!(
"http_request",
method = %request.method(),
path = %matched_path,
request_id = %request_id,
)
});
}
ทุก log event ที่เกิดขึ้นระหว่างการประมวลผลคำขอนั้นจะถูกแนบฟิลด์ method, path และ request_id ไปด้วยโดยอัตโนมัติ เพราะ span จะทำหน้าที่เป็น ambient context ครอบคลุมการทำงานทั้งหมดที่เกิดขึ้นภายใน นี่คือหนึ่งในรายละเอียดที่ดูเหมือนเล็กน้อยแต่สร้างความแตกต่างอย่างมหาศาล เพราะเมื่อแอปพลิเคชันต้องรองรับคำขอพร้อมกันหลายร้อยรายการ คุณจะยังคงค้นหา log ทุกบรรทัดที่เกี่ยวข้องกับคำขอเฉพาะเจาะจงนั้นได้ในทันที เพียงแค่กรองด้วย request ID
การใส่เครื่องมือวัดให้แฮนด์เลอร์และเซอร์วิส
เราสามารถใช้ attribute #[tracing::instrument] เพื่อสร้าง span ให้กับแต่ละฟังก์ชันโดยอัตโนมัติ ซึ่งผมพบว่ามีประโยชน์อย่างยิ่งเมื่อนำไปใช้กับ service method และ repository call เพราะช่วยให้เราเห็น timeline และภาพรวมการทำงานได้อย่างชัดเจนโดยไม่ต้องมานั่งเขียนโค้ดสร้าง span ด้วยตัวเองในทุกๆ ที่
#![allow(unused)]
fn main() {
#[tracing::instrument(
skip(state, payload),
)]
async fn create_user(
State(state): State<AppState>,
ValidatedJson(payload): ValidatedJson<CreateUserDto>,
) -> AppResult<(StatusCode, Json<UserResponse>)> {
tracing::info!("creating new user");
let user = state.user_service.register(payload).await?;
tracing::info!(user_id = %user.id().as_uuid(), "user created successfully");
Ok((StatusCode::CREATED, Json(user.into())))
}
}
คำสั่ง skip(state, payload) จะบอกให้ macro ไม่ต้องนำ state หรือ request payload เข้าไปรวมไว้ในฟิลด์ของ span และเมื่อ service ทำงานสำเร็จ เราจึงค่อยบันทึก user_id เป็น structured field สังเกตว่าเราเลือกใช้ user_id ที่เป็นค่ารหัสสุ่ม (opaque ID) แทนที่จะบันทึก user.email ลงใน span ซึ่งนี่คือความตั้งใจในการออกแบบ จากประสบการณ์จริง การเลือกใช้ identifier ที่มีความเสี่ยงต่ำต่อข้อมูลส่วนบุคคล (เช่น user ID, tenant ID, request ID) ย่อมปลอดภัยกว่าการใส่ข้อมูลระบุตัวตนบุคคล (PII เช่น email หรือชื่อจริง) ลงใน trace output โดยตรง หากคุณจำเป็นต้องเชื่อมโยง trace เข้ากับ email เพื่อการ debug คุณก็สามารถนำ user ID ไปค้นหาต่อในฐานข้อมูลได้ คุณคงไม่อยากให้ log ทุกบรรทัดในระบบจัดเก็บ log กลายเป็นแหล่งรวมข้อมูลส่วนบุคคลที่เสี่ยงต่อการละเมิดความเป็นส่วนตัว
แนวปฏิบัติที่ดีที่สุดในการบันทึกข้อมูล
ใช้ Structured Fields แทนการต่อสตริง แทนที่จะเขียน tracing::info!("Created user {}", user_id) ให้เปลี่ยนมาเขียน tracing::info!(user_id = %user_id, "user created") รูปแบบที่มีโครงสร้างเช่นนี้จะทำให้ระบบ log aggregation สามารถทำ index และ filter ตามฟิลด์ user_id ได้ทันที ซึ่งมีประโยชน์ในการค้นหามากกว่าการพยายามแกะข้อความสตริงธรรมดาหลายเท่า
เลือกระดับ Log Level ให้ถูกต้องและเหมาะสม แม้จะฟังดูเป็นเรื่องพื้นฐาน แต่ก็คุ้มค่าที่จะย้ำให้ชัดเจน: ใช้ error กับปัญหาที่บ่งชี้ถึงบั๊กหรือความล้มเหลวของระบบที่ต้องมีคนเข้ามาตรวจสอบแก้ไข, ใช้ warn กับเหตุการณ์ผิดปกติแต่ระบบยังจัดการได้เอง (เช่น request โดน rate limit หรือเกิด cache miss), ใช้ info กับเหตุการณ์ทางธุรกิจที่สำคัญ (เช่น สร้างผู้ใช้สำเร็จ, มีการสั่งซื้อสินค้า), และใช้ debug กับข้อมูลการทำงานเชิงลึกที่เป็นประโยชน์ในระหว่างการพัฒนาหรือไล่หาสาเหตุของปัญหา การแยกระดับให้ชัดเจนมีความสำคัญอย่างยิ่ง เพราะเมื่อเกิดเหตุการณ์ฉุกเฉินตอนตีสอง คุณย่อมต้องการให้ระบบ alert แจ้งเตือนเฉพาะเรื่องที่วิกฤตจริงๆ เท่านั้น
ห้ามบันทึกความลับ (Secrets) ลงใน Log โดยเด็ดขาด หากคุณใช้ crate secrecy ในการจัดการ config (ตามที่อธิบายไว้ในบท การตั้งค่า) implementation ของ Debug จะช่วยซ่อนค่า sensitive ให้โดยอัตโนมัติ แต่คุณยังต้องระมัดระวังเป็นพิเศษกับ request body, header และข้อมูลอื่นๆ ที่อาจมี token, รหัสผ่าน หรือข้อมูลส่วนบุคคลแนบมาด้วย
OpenTelemetry
เมื่อแอปพลิเคชันเติบโตขึ้นจนกลายเป็น Distributed System ที่คำขอหนึ่งรายการอาจต้องเดินทางผ่านหลายไมโครเซอร์วิส เราจึงจำเป็นต้องมีวิธีติดตามเส้นทางของคำขอนั้นข้ามขอบเขตของเซอร์วิสต่างๆ ซึ่งนี่คือบทบาทของ OpenTelemetry ที่เข้ามามอบมาตรฐานกลางในการทำ context propagation และเก็บรวบรวมข้อมูล telemetry
เครตหลักๆ คือ:
- opentelemetry และ opentelemetry_sdk สำหรับคอร์ API และ SDK
- opentelemetry-otlp สำหรับส่งออกเทรซไปยังแบ็กเอนด์ที่รองรับ OTLP (Jaeger, Tempo, Datadog ฯลฯ)
- tracing-opentelemetry สำหรับเชื่อมสแปนของเครต
tracingเข้ากับสแปนของ OpenTelemetry - axum-tracing-opentelemetry สำหรับการแพร่กระจายบริบทเทรซอัตโนมัติใน Axum
ด้วยสแตกนี้ ทุกคำขอจะได้รับเทรซ ID ที่ติดตามมันข้ามพรมแดนระหว่างเซอร์วิส เมื่อผู้ใช้รายงานปัญหา เราสามารถค้นเทรซด้วย ID แล้วเห็นภาพทั้งหมด: มีเซอร์วิสใดเกี่ยวข้องบ้าง แต่ละขั้นตอนใช้เวลานานเท่าไร และมีอะไรผิดพลาดตรงไหน
เมตริก
เมตริกให้เลนส์ที่ต่างจากล็อกและเทรซ ในขณะที่รายการล็อกบอกเราเกี่ยวกับคำขอหนึ่งคำขอที่เฉพาะเจาะจง เมตริกให้ข้อมูลอนุกรมเวลาแบบรวมว่าแอปพลิเคชันของเราทำงานโดยรวมอย่างไร เมตริกตอบคำถามเช่น: ความหน่วงที่เปอร์เซ็นไทล์ที่ 99 เริ่มไต่ขึ้นเรื่อยๆ หรือเปล่า? อัตราข้อผิดพลาดเพิ่มเป็นสองเท่าในห้านาทีที่ผ่านมาหรือไม่? พูลการเชื่อมต่อฐานข้อมูลกำลังรับภาระหนักเกินไปหรือเปล่า?
- axum-otel-metrics ให้เมตริกแบบ OpenTelemetry พร้อมการส่งออกไปยัง Prometheus
- axum-prometheus ให้เมตริก HTTP ที่เข้ากันได้กับนิเวศของ metrics.rs
การตั้งค่าทั่วไปจะเปิดเผยเอนด์พอยต์ /metrics ให้ Prometheus เข้าไปเก็บข้อมูลเป็นช่วงเวลาปกติ จากประสบการณ์ของผม เมตริกที่มีประโยชน์ที่สุดสำหรับเว็บแอปพลิเคชันคือจำนวนคำขอ (แยกตามเมธอด เส้นทาง และรหัสสถานะ) ฮิสโทแกรมของระยะเวลาคำขอ และอัตราข้อผิดพลาด คุณอาจสงสัยว่าจำเป็นต้องมีทั้งสามอย่างตั้งแต่วันแรกหรือไม่ พูดตรงๆ ว่าแค่ระยะเวลาคำขอและอัตราข้อผิดพลาดก็จับปัญหาส่วนใหญ่ได้ก่อนที่ผู้ใช้จะสังเกตเห็นแล้ว
การรวมทุกอย่างเข้าด้วยกัน
การตั้งค่าการสังเกตการณ์ที่พร้อมใช้ใน production ผสานทั้งสามอย่างนี้เข้าด้วยกัน ล็อกแบบมีโครงสร้างให้ข้อมูลละเอียดเกี่ยวกับเหตุการณ์แต่ละเหตุการณ์ เทรซให้เราเดินตามคำขอผ่านหลายเซอร์วิสเพื่อหาคอขวด และเมตริกให้ภาพรวมของสุขภาพระบบและแนวโน้มประสิทธิภาพ
การตั้งค่าทั้งหมดนี้อาจดูเหมือนงานใหญ่ที่ต้องทำล่วงหน้า และมันก็เป็นงานพอสมควรจริงๆ แต่มันคืนทุนให้ตัวเองตั้งแต่วันแรกที่คุณต้องดีบักปัญหาใน production แทนที่จะเดาว่าเกิดอะไรขึ้นแล้วดีพลอยต์แพตช์ลองผิดลองถูก คุณดูที่ข้อมูลแล้วเห็นสิ่งที่เกิดขึ้นจริงๆ ซึ่งเป็นจุดที่คุณอยากอยู่มากกว่า
เมื่อเรามีรากฐานด้านการสังเกตการณ์ที่มั่นคงแล้ว ลำดับถัดไปมาดูกันว่าเราจะจัดการข้อผิดพลาดและสื่อสารกับผู้ใช้งาน API ของเราอย่างชัดเจนได้อย่างไร