可觀測性:日誌、指標、追蹤
Observability in Go: Logs, Metrics and Tracing
從 log/slog 結構化日誌與請求 ID 開始,接著用 RED/USE 方法設計 Prometheus 指標,再以 OpenTelemetry 把一次請求跨服務串成追蹤,最後讓三者用同一個 trace ID 互相對照。
這篇的步驟
上一篇〈分散式交易:Saga 與 Outbox〉我們用 Saga 與 Outbox 讓 order、payment、inventory 三個服務在沒有全域交易的情況下維持最終一致;這篇接著進入「上線與維運」:服務真的跑起來之後,要怎麼看見它在做什麼。
這篇要解決什麼
到這裡,網路商店的訂單服務已經長成 api-gateway、order、payment、inventory 四個服務,也處理了逾時、重試、冪等、Saga 與 Outbox。程式寫好、測試通過之後,真正的考驗才開始:服務上線以後,你要怎麼知道它「現在」是好是壞?使用者回報「下單很慢」時,你要怎麼在四個服務、十幾個執行個體之中,找出是哪一段變慢?
單體程式時代,打開一份日誌檔往下捲,多半就能找到線索;拆成微服務以後,一次下單會經過 api-gateway、訂單服務、庫存服務、付款服務,還可能經過訊息佇列,每一段的日誌散落在不同的機器上,彼此之間沒有任何關聯。這時候光靠「多印一點 log」已經不夠了,需要的是一套有系統的可觀測性(observability):讓系統從外部就能回答「現在發生了什麼、為什麼」。
可觀測性通常拆成三根支柱:
| 支柱 | 回答的問題 | 典型工具 | 成本特性 |
|---|---|---|---|
| 日誌(logs) | 某一件事的細節是什麼? | log/slog、Loki、Elasticsearch | 量大,跟請求數成正比 |
| 指標(metrics) | 整體趨勢好不好?有沒有超過門檻? | Prometheus、Grafana | 量小,跟標籤組合數成正比 |
| 追蹤(traces) | 一次請求在各服務花了多少時間? | OpenTelemetry、Jaeger、Tempo | 中等,通常會抽樣 |
這篇會一步一步把三根支柱都蓋起來,最後再讓它們用同一個 trace ID 串在一起:從告警的指標跳到對應的追蹤,再從追蹤跳到那一段的日誌。
第 1 步:用 log/slog 寫結構化日誌
Go 1.21 起標準函式庫內建了 log/slog,不需要再為了結構化日誌引入第三方套件。所謂結構化,是指每一筆日誌不是一段給人讀的句子,而是一組「鍵=值」的欄位,輸出成 JSON 之後,日誌系統可以直接用欄位查詢,例如「找出 order_id=A123 的所有紀錄」或「統計 level=ERROR 且 route=/orders 的數量」。
傳統寫法像 log.Printf("order %s failed: %v", id, err),人看得懂,機器卻得用正規表示式去拆字串,格式一改查詢就壞。改成 slog 之後,同一件事會寫成 logger.Error("建立訂單失敗", "order_id", id, "err", err),訊息固定、變動的部分都放在欄位裡。這個習慣很重要:訊息文字要固定,變數放欄位,這樣才能把同一類事件聚合起來計數。
設計日誌欄位時,有幾個原則值得一開始就定下來:
- 欄位名稱全系統統一,例如一律用
order_id,不要這個服務叫orderId、那個服務叫oid。 - 等級要有意義:
DEBUG給開發時追細節,INFO記錄重要的狀態變化,WARN是可以自動恢復的異常,ERROR是需要有人關注的失敗。正式環境通常只輸出INFO以上。 - 不要把密碼、存取權杖、完整信用卡號寫進日誌。可以實作
slog.LogValuer介面,讓敏感型別自己決定要輸出什麼(例如只留末四碼)。 - 同一個錯誤只在「處理它」的那一層記一次。如果每一層都
log再return err,一個失敗會在日誌裡出現五次,反而難以判讀。這點在〈錯誤處理:包裝、哨兵、自訂型別〉已經談過,到了上線階段影響會更明顯。
第 2 步:用請求 ID 把同一次請求的日誌串起來
結構化之後,下一個問題是:同一時間有上百個請求在跑,日誌是交錯輸出的,你怎麼知道哪幾行屬於同一次請求?答案是在請求一進來時就給它一個 ID,之後這個請求路徑上所有的日誌都帶著這個欄位。
在 Go 裡,承載「這次請求專屬的資料」最自然的地方就是 context.Context,〈context:取消、逾時與資料傳遞〉提過,context 適合放跨 API 邊界、跟請求生命週期一致的值。做法是:中介層從標頭 X-Request-ID 取得 ID(上游沒給就自己產生一個),放進 context;再寫一個包裝過的 slog.Handler,在每一筆日誌輸出前從 context 取出 ID 加到欄位上。這樣業務程式碼只要記得使用 logger.InfoContext(ctx, ...) 這類帶 context 的方法,完全不用自己傳 ID。
下面是一個只用標準函式庫、可以直接執行的完整範例,同時示範了請求 ID 中介層、記錄狀態碼與耗時的存取日誌,以及一個最陽春的指標端點(第 4 步會說明為什麼正式環境應該改用 Prometheus 用戶端套件):
package main
import (
"context"
"crypto/rand"
"encoding/hex"
"fmt"
"log/slog"
"net/http"
"os"
"sync"
"time"
)
type ctxKey struct{}
// ctxHandler 包裝任何 slog.Handler,輸出前自動補上 context 裡的 request_id。
type ctxHandler struct{ slog.Handler }
func (h ctxHandler) Handle(ctx context.Context, r slog.Record) error {
if id, ok := ctx.Value(ctxKey{}).(string); ok {
r.AddAttrs(slog.String("request_id", id))
}
return h.Handler.Handle(ctx, r)
}
func (h ctxHandler) WithAttrs(as []slog.Attr) slog.Handler {
return ctxHandler{h.Handler.WithAttrs(as)}
}
func (h ctxHandler) WithGroup(name string) slog.Handler {
return ctxHandler{h.Handler.WithGroup(name)}
}
func newID() string {
b := make([]byte, 8)
_, _ = rand.Read(b)
return hex.EncodeToString(b)
}
// statusRecorder 記下實際寫出的狀態碼。
type statusRecorder struct {
http.ResponseWriter
code int
}
func (s *statusRecorder) WriteHeader(code int) {
s.code = code
s.ResponseWriter.WriteHeader(code)
}
// counters 是極簡的請求計數器,鍵為 "路由 狀態碼"。
type counters struct {
mu sync.Mutex
m map[string]int
}
func (c *counters) inc(key string) {
c.mu.Lock()
c.m[key]++
c.mu.Unlock()
}
func (c *counters) ServeHTTP(w http.ResponseWriter, _ *http.Request) {
c.mu.Lock()
defer c.mu.Unlock()
w.Header().Set("Content-Type", "text/plain; version=0.0.4")
fmt.Fprintln(w, "# TYPE http_requests_total counter")
for k, v := range c.m {
var route, code string
fmt.Sscanf(k, "%s %s", &route, &code)
fmt.Fprintf(w, "http_requests_total{route=%q,code=%q} %d\n", route, code, v)
}
}
func observe(logger *slog.Logger, cnt *counters, next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
id := r.Header.Get("X-Request-ID")
if id == "" {
id = newID()
}
ctx := context.WithValue(r.Context(), ctxKey{}, id)
w.Header().Set("X-Request-ID", id)
rec := &statusRecorder{ResponseWriter: w, code: http.StatusOK}
start := time.Now()
next.ServeHTTP(rec, r.WithContext(ctx))
route := r.Pattern // Go 1.23+:比對到的路由樣式,不是實際路徑
if route == "" {
route = "unmatched"
}
cnt.inc(fmt.Sprintf("%s %d", route, rec.code))
logger.InfoContext(ctx, "request done",
"method", r.Method,
"route", route,
"status", rec.code,
"duration_ms", time.Since(start).Milliseconds(),
)
})
}
func main() {
logger := slog.New(ctxHandler{slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo})})
slog.SetDefault(logger)
cnt := &counters{m: map[string]int{}}
mux := http.NewServeMux()
mux.HandleFunc("GET /orders/{id}", func(w http.ResponseWriter, r *http.Request) {
slog.InfoContext(r.Context(), "load order", "order_id", r.PathValue("id"))
fmt.Fprintf(w, `{"id":%q,"status":"paid"}`, r.PathValue("id"))
})
root := http.NewServeMux()
root.Handle("GET /metrics", cnt)
root.Handle("/", observe(logger, cnt, mux))
logger.Info("listening", "addr", ":8080")
if err := http.ListenAndServe(":8080", root); err != nil {
logger.Error("server stopped", "err", err)
os.Exit(1)
}
}這裡有一個容易忽略的細節:route 取的是 r.Pattern(Go 1.23 起由 ServeMux 填入,例如 GET /orders/{id}),而不是 r.URL.Path(例如 /orders/A123)。前者的值是有限的,後者每一筆訂單都不一樣。日誌裡放實際路徑沒問題,但只要拿去當指標的標籤,就會造成第 4 步要談的「標籤爆量」。
請求 ID 只解決了「單一服務內」的串接。訂單服務呼叫庫存服務時,還得把 X-Request-ID 放進對外請求的標頭裡傳下去,庫存服務的中介層才會沿用同一個 ID。這件事在第 6 步會由 OpenTelemetry 的傳遞機制以標準的方式接手。
第 3 步:決定要量什麼——RED 與 USE
日誌適合查細節,卻不適合回答「過去一小時錯誤率是多少」這種整體問題:要從數百萬行日誌即時算出比例,成本很高。這種問題該交給指標:在程式裡維護一些數字(計數器、量表、分布),定期被收集起來存成時間序列,查詢與告警都很便宜。
指標最大的難題不是怎麼寫,而是「量什麼」。兩套經典方法可以當成清單:
| 方法 | 適用對象 | 三個指標 | 在訂單服務的例子 |
|---|---|---|---|
| RED | 處理請求的服務 | Rate 每秒請求數、Errors 失敗數、Duration 耗時分布 | POST /orders 每秒幾次、5xx 幾次、P99 耗時 |
| USE | 資源(CPU、連線池、佇列) | Utilization 使用率、Saturation 飽和度、Errors 錯誤 | 資料庫連線池使用中比例、等待取得連線的數量、取得逾時次數 |
RED 是從使用者角度看服務:只要這三個數字正常,使用者通常就沒感覺。USE 是從資源角度看瓶頸:當 RED 顯示變慢時,USE 幫你回答「卡在哪個資源」。以〈database/sql、交易與連線池〉介紹的連線池為例,sql.DB.Stats() 已經提供了 InUse、WaitCount、WaitDuration 等數值,把它們定期匯出成指標,就是現成的 USE。
在 Go 服務裡,還有幾個「執行環境」層級的指標幾乎一定要有:goroutine 數量、堆積記憶體大小、GC 暫停時間。goroutine 數量持續上升往往代表洩漏(例如某個 channel 永遠沒人讀),這是〈Goroutine、Channel 與並發模式〉提到的典型問題,在指標上會呈現為一條只升不降的線。
圖:三根支柱各自回答不同問題,靠請求 ID 與 trace ID 串成一條從告警到根因的路徑。
第 4 步:用 Prometheus 匯出指標
Prometheus 是目前最常見的指標系統,它採用「拉」的模式:服務開一個 /metrics 端點,以純文字格式列出當下所有指標,Prometheus 每隔一段時間(例如 15 秒)來抓一次。第 2 步的範例手寫了這個格式,但正式環境請使用官方的 github.com/prometheus/client_golang,它處理了並行安全、直方圖分桶、執行環境指標等細節。
Prometheus 有四種指標型別:Counter(只增不減,例如請求總數)、Gauge(可增可減,例如目前排隊數)、Histogram(把觀測值落進預先定義的區間,可在伺服器端算百分位數)、Summary(在用戶端算百分位數,無法跨執行個體合併,一般較少用)。RED 的 Duration 幾乎都用 Histogram,因為多個執行個體的直方圖可以相加,再算整體的 P99。
// 片段:使用 github.com/prometheus/client_golang
import (
"net/http"
"strconv"
"time"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/client_golang/prometheus/promauto"
"github.com/prometheus/client_golang/prometheus/promhttp"
)
var reqDuration = promauto.NewHistogramVec(prometheus.HistogramOpts{
Name: "http_request_duration_seconds",
Help: "HTTP 請求耗時(秒)",
Buckets: []float64{0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5},
}, []string{"method", "route", "code"})
func metricsMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
rec := &statusRecorder{ResponseWriter: w, code: http.StatusOK}
start := time.Now()
next.ServeHTTP(rec, r)
reqDuration.WithLabelValues(r.Method, r.Pattern, strconv.Itoa(rec.code)).
Observe(time.Since(start).Seconds())
})
}
// main 裡:/metrics 交給 promhttp,預設會一併輸出 go_goroutines、go_memstats_* 等執行環境指標。
// mux.Handle("GET /metrics", promhttp.Handler())Prometheus 抓到的文字大致長這樣,每一行是一條時間序列,{} 裡的鍵值就是標籤:
# HELP http_request_duration_seconds HTTP 請求耗時(秒)
# TYPE http_request_duration_seconds histogram
http_request_duration_seconds_bucket{code="201",method="POST",route="POST /orders",le="0.1"} 940
http_request_duration_seconds_bucket{code="201",method="POST",route="POST /orders",le="0.25"} 990
http_request_duration_seconds_bucket{code="201",method="POST",route="POST /orders",le="+Inf"} 1000
http_request_duration_seconds_sum{code="201",method="POST",route="POST /orders"} 61.2
http_request_duration_seconds_count{code="201",method="POST",route="POST /orders"} 1000
go_goroutines 42(數字僅為示意。)有了這些序列,就能用 PromQL 寫出 RED:每秒請求數是 rate(http_request_duration_seconds_count[5m]),錯誤率是 5xx 的 rate 除以全部的 rate,P99 是 histogram_quantile(0.99, sum by (le, route) (rate(http_request_duration_seconds_bucket[5m])))。
提示:每一組不同的標籤值都是一條獨立的時間序列。標籤只能放「值的種類有限」的東西,例如方法、路由樣式、狀態碼;使用者 ID、訂單編號、完整 URL、錯誤訊息全文都不該當標籤。這類高基數資料放日誌或追蹤。
告警建議以「症狀」為主而不是「原因」:與其對「CPU 超過 80%」告警,不如對「POST /orders 錯誤率連續五分鐘超過門檻」或「P99 超過服務目標」告警。CPU 高但使用者沒感覺,半夜叫醒人並沒有意義;反過來,錯誤率升高時一定需要有人處理。這也是 SLO(服務等級目標)的基本思路:先定義使用者在意的目標,再用指標去追蹤是否偏離。
第 5 步:分散式追蹤的基本觀念
指標告訴你「POST /orders 的 P99 變慢了」,卻不會告訴你慢在哪裡。一次下單可能是:訂單服務先寫資料庫,再同步呼叫庫存服務預留庫存,再呼叫付款服務授權,最後送出事件到訊息佇列。到底是哪一段變慢?這就是分散式追蹤要回答的問題。
追蹤有幾個核心名詞:
- Trace:一次完整的請求旅程,有一個全域唯一的 trace ID。
- Span:旅程中的一段工作,例如「處理 HTTP 請求」「執行一條 SQL」「呼叫庫存服務」。每個 span 有自己的 span ID、開始與結束時間、屬性(attributes),以及父 span 的 ID。
- Context propagation:服務 A 呼叫服務 B 時,把 trace ID 與目前的 span ID 放在請求標頭裡傳過去,B 建立的 span 就會掛在 A 的 span 底下。W3C 制定的
traceparent標頭是目前通用的格式,長得像00-<32 位 trace id>-<16 位 parent span id>-01。
把同一個 trace ID 的所有 span 依時間排開,就是一張「瀑布圖」,哪一段最長一目了然:
圖:同一個 trace 底下的 span 依父子關係與時間排列,最長的那一段就是優先調查的對象。
OpenTelemetry(簡稱 OTel)是 CNCF 的開放標準,統一了追蹤、指標、日誌的 API、SDK 與傳輸協定 OTLP。程式只依賴 OTel 的 API,資料要送到 Jaeger、Tempo 或商用平台,都只是設定的差別,不用改程式。
第 6 步:在 Go 裡接上 OpenTelemetry 並傳遞 context
接上 OTel 通常分三塊:啟動時建立 TracerProvider 並設定匯出器;在 HTTP/gRPC 的伺服端與用戶端加上自動儀表化(instrumentation),讓 span 自動建立、traceparent 自動注入與解析;在關鍵的業務步驟手動建立 span。
// 片段:使用 go.opentelemetry.io/otel 與 contrib 的 otelhttp
import (
"context"
"net/http"
"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
"go.opentelemetry.io/otel/propagation"
"go.opentelemetry.io/otel/sdk/resource"
sdktrace "go.opentelemetry.io/otel/sdk/trace"
semconv "go.opentelemetry.io/otel/semconv/v1.26.0"
)
func setupTracing(ctx context.Context) (func(context.Context) error, error) {
exp, err := otlptracegrpc.New(ctx) // 端點由 OTEL_EXPORTER_OTLP_ENDPOINT 設定
if err != nil {
return nil, err
}
tp := sdktrace.NewTracerProvider(
sdktrace.WithBatcher(exp),
sdktrace.WithSampler(sdktrace.ParentBased(sdktrace.TraceIDRatioBased(0.1))),
sdktrace.WithResource(resource.NewWithAttributes(semconv.SchemaURL,
semconv.ServiceName("order"))),
)
otel.SetTracerProvider(tp)
otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(
propagation.TraceContext{}, propagation.Baggage{}))
return tp.Shutdown, nil // 關閉時要呼叫,才會把緩衝中的 span 送出
}
// 伺服端:每個請求自動建立 span,並從 traceparent 標頭接上上游的 trace。
// handler := otelhttp.NewHandler(mux, "order")
// 用戶端:呼叫庫存服務時自動把 traceparent 寫進標頭。
var client = &http.Client{Transport: otelhttp.NewTransport(http.DefaultTransport)}
func reserveStock(ctx context.Context, orderID string) error {
ctx, span := otel.Tracer("order").Start(ctx, "reserve-stock")
defer span.End()
span.SetAttributes(attribute.String("order.id", orderID))
req, err := http.NewRequestWithContext(ctx, http.MethodPost, "http://inventory/reservations", nil)
if err != nil {
return err
}
resp, err := client.Do(req)
if err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, "reserve failed")
return err
}
defer resp.Body.Close()
return nil
}這段程式的關鍵是 context 一路往下傳。otelhttp.NewHandler 把 span 放進請求的 context;reserveStock 從這個 context 開子 span;http.NewRequestWithContext 再把子 span 帶進對外請求,otelhttp.NewTransport 從中取出並寫進標頭。只要中間任何一層改用 context.Background(),追蹤就會從那裡斷成兩截。這正是〈context:取消、逾時與資料傳遞〉一再強調「context 要當第一個參數往下傳」的實際回報。
非同步的路徑也一樣要傳。訂單服務透過訊息佇列送出「訂單已建立」事件時,應該把 traceparent 寫進訊息的標頭(Kafka header 或 AMQP properties),消費端取出後用 propagator.Extract 還原 context,再開 span。這樣〈訊息佇列與事件驅動〉與〈分散式交易:Saga 與 Outbox〉裡的非同步流程,也能出現在同一張瀑布圖上。若使用 Outbox,記得把 traceparent 跟事件內容一起存進 outbox 資料表,轉送程式送出時才拿得到。
抽樣是追蹤的另一個重點。每個請求都記錄完整追蹤,資料量與成本都很可觀,所以通常只保留一部分。上面的 ParentBased(TraceIDRatioBased(0.1)) 表示:如果上游已經決定要不要抽樣,就照上游的決定(確保同一個 trace 不會只記到一半);自己是起點時,依 trace ID 保留大約一成。更進階的做法是在 OTel Collector 做「尾端抽樣」,等整個 trace 結束後,再決定保留所有出錯或特別慢的 trace。
第 7 步:讓三根支柱互相對照
三根支柱各自建好之後,真正的價值在於能互相跳轉。做法有三個:
- 日誌帶上 trace ID 與 span ID。 把第 2 步的
ctxHandler擴充一下:除了 request_id,也從 context 用trace.SpanContextFromContext(ctx)取出TraceID()與SpanID(),有效時寫成trace_id、span_id欄位。日誌平台就能從一筆錯誤日誌直接開啟對應的追蹤。也可以使用 OTel 的 slog 橋接套件,把日誌直接以 OTLP 送出,自動帶上這些欄位。 - 指標帶上 exemplar。 Prometheus 的直方圖支援 exemplar:在某個分桶旁邊附上一個代表性請求的 trace ID。Grafana 會在延遲圖上畫出這些點,點下去就跳到那一筆慢請求的追蹤,從「P99 變高」一步走到「就是這一次、慢在這一段」。
- span 帶上業務屬性。 在 span 上加
order.id這類屬性,就能反過來用業務資料找追蹤:客服說「訂單 A123 卡住」,你可以直接搜尋這個屬性。
一份典型的排查流程因此變成:告警通知 POST /orders 的 P99 超標 → 在儀表板上點一個 exemplar → 瀑布圖顯示 inventory: reserve 這一段占了大部分時間 → 跳到庫存服務在這個 trace ID 底下的日誌 → 看到「等待資料庫連線逾時」 → 回到 USE 指標確認連線池已經飽和。從症狀到根因,每一步都有線索可循,而不是在幾台機器上各自翻檔案。
圖:從症狀指標出發,經由 exemplar、追蹤與日誌,一步步收斂到具體的資源瓶頸。
常見陷阱
- 標籤爆量。 把使用者 ID、訂單編號或原始 URL 當成指標標籤,時間序列數量會無限增長,Prometheus 記憶體跟著暴增。標籤只放有限集合,路由用
r.Pattern這類樣式。 - context 中斷。 在 goroutine 裡、背景工作或佇列消費者裡改用
context.Background(),追蹤就斷了。需要脫離請求取消、卻要保留追蹤資訊時,可以用 Go 1.21 起的context.WithoutCancel(ctx)。 - 忘了關閉 TracerProvider。 SDK 會批次緩衝 span,程式結束前沒有呼叫
Shutdown,最後一批資料就會遺失,而且偏偏是出事前最關鍵的那一段。下一篇〈設定與優雅關閉〉會把它放進關閉流程。 - 日誌量失控。 在迴圈裡、在每一次重試都印
INFO,或把整個請求與回應的內容寫進日誌,成本和雜訊都會急速增加。用等級控制,必要時對重複的訊息做抽樣。 - 只看平均值。 平均耗時會被大量的快請求稀釋,掩蓋少數非常慢的請求。延遲一律看分布與高百分位數(P95、P99)。
- 健康檢查與指標端點本身被記錄。
/healthz與/metrics每隔幾秒就被呼叫一次,若也寫進存取日誌與 RED 指標,會讓數字失真。通常把它們掛在中介層之外。 - 把敏感資料送進可觀測性系統。 日誌、span 屬性、baggage 都可能被很多人看到,也可能被送到第三方平台。個資與密鑰要在寫入前就遮蔽。
重點整理
- 可觀測性三根支柱:日誌回答細節、指標回答趨勢與告警、追蹤回答跨服務的耗時分布,三者互補而不是互相取代。
- 用
log/slog輸出 JSON 結構化日誌,訊息固定、變數放欄位;以中介層產生請求 ID 放進 context,再用自訂 Handler 自動加到每一筆日誌。 - 指標用 RED 看服務、用 USE 看資源;延遲用 Histogram,告警以使用者感受得到的症狀為主。
- Prometheus 標籤只能放有限集合,高基數資料留給日誌與追蹤。
- OpenTelemetry 以
traceparent在服務之間傳遞追蹤,Go 程式的前提是 context 一路往下傳,連訊息佇列也要帶上。 - 抽樣要以父決定為主,避免半截追蹤;程式結束前呼叫 TracerProvider 的
Shutdown。 - 日誌帶 trace ID、指標帶 exemplar、span 帶業務屬性,讓三者能互相跳轉,從告警一路追到根因。
下一篇
看得見服務之後,還缺兩件跟生命週期有關的事:設定從哪裡來、怎麼驗證,以及部署或縮容時怎麼結束才不會掉請求、丟追蹤資料。〈設定與優雅關閉〉會把 TracerProvider 的 Shutdown 一起放進關閉流程。