This resume is also available in English.

五、上線與維運第 1 / 4 篇 · 全部目錄

專欄 › 五、上線與維運 › 第 17 篇

可觀測性:日誌、指標、追蹤

Observability in Go: Logs, Metrics and Tracing

從 log/slog 結構化日誌與請求 ID 開始,接著用 RED/USE 方法設計 Prometheus 指標,再以 OpenTelemetry 把一次請求跨服務串成追蹤,最後讓三者用同一個 trace ID 互相對照。

  • Go
  • Observability
  • OpenTelemetry
  • Prometheus
這篇的步驟
  1. 這篇要解決什麼
  2. 第 1 步:用 log/slog 寫結構化日誌
  3. 第 2 步:用請求 ID 把同一次請求的日誌串起來
  4. 第 3 步:決定要量什麼——RED 與 USE
  5. 第 4 步:用 Prometheus 匯出指標
  6. 第 5 步:分散式追蹤的基本觀念
  7. 第 6 步:在 Go 裡接上 OpenTelemetry 並傳遞 context
  8. 第 7 步:讓三根支柱互相對照
  9. 常見陷阱
  10. 重點整理
  11. 下一篇

上一篇〈分散式交易: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 與並發模式〉提到的典型問題,在指標上會呈現為一條只升不降的線。

指標 趨勢與告警 RED/USE、Prometheus 追蹤 跨服務耗時 span、OpenTelemetry 日誌 單一事件細節 log/slog、JSON trace ID / request ID 由 context 一路往下傳 exemplar span 屬性 trace_id 欄位

圖:三根支柱各自回答不同問題,靠請求 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 依時間排開,就是一張「瀑布圖」,哪一段最長一目了然:

span 0 ms 時間 → gateway:POST /orders order:建立訂單 SQL:寫入 orders inventory:預留庫存 SQL:等待連線 payment:授權 最長的一段

圖:同一個 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 步:讓三根支柱互相對照

三根支柱各自建好之後,真正的價值在於能互相跳轉。做法有三個:

  1. 日誌帶上 trace ID 與 span ID。 把第 2 步的 ctxHandler 擴充一下:除了 request_id,也從 context 用 trace.SpanContextFromContext(ctx) 取出 TraceID() 與 SpanID(),有效時寫成 trace_id、span_id 欄位。日誌平台就能從一筆錯誤日誌直接開啟對應的追蹤。也可以使用 OTel 的 slog 橋接套件,把日誌直接以 OTLP 送出,自動帶上這些欄位。
  2. 指標帶上 exemplar。 Prometheus 的直方圖支援 exemplar:在某個分桶旁邊附上一個代表性請求的 trace ID。Grafana 會在延遲圖上畫出這些點,點下去就跳到那一筆慢請求的追蹤,從「P99 變高」一步走到「就是這一次、慢在這一段」。
  3. span 帶上業務屬性。 在 span 上加 order.id 這類屬性,就能反過來用業務資料找追蹤:客服說「訂單 A123 卡住」,你可以直接搜尋這個屬性。

一份典型的排查流程因此變成:告警通知 POST /orders 的 P99 超標 → 在儀表板上點一個 exemplar → 瀑布圖顯示 inventory: reserve 這一段占了大部分時間 → 跳到庫存服務在這個 trace ID 底下的日誌 → 看到「等待資料庫連線逾時」 → 回到 USE 指標確認連線池已經飽和。從症狀到根因,每一步都有線索可循,而不是在幾台機器上各自翻檔案。

告警 P99 超過目標 exemplar 挑一筆慢請求 追蹤瀑布圖 找出最長 span 日誌 同 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 一起放進關閉流程。