Clojure 日志、指标与可观测性：Timbre、OpenTelemetry 与采样

;; 非结构化：只能人看，机器难解析
(println "user 42 login failed from 10.0.0.1")

;; 结构化：可查询、可聚合、可告警
(log/info :user-login-failed {:user-id 42 :ip "10.0.0.1" :reason :bad-password})

;; deps.edn
{:deps {com.taoensso/timbre {:mvn/version "6.6.1"}}}

(require '[taoensso.timbre :as log])

(log/info "服务启动" {:port 8080})
(log/warn "连接池接近上限" {:active 95 :max 100})
(log/error (ex-info "支付失败" {:order-id 7}) "处理订单出错")

;; 推荐：事件名 + map，字段可被索引
(log/info :order-created
          {:order-id 1234
           :user-id  42
           :amount   199.00
           :currency :cny})

(log/set-min-level! :debug)          ;; 全局
(log/merge-config!
  {:min-level [[#{"app.db.*"} :debug]
               [#{"*"} :info]]
   :output-fn :inherit})

(require '[taoensso.timbre :as log])

(defn with-context [f ctx]
  (log/with-context+ ctx (f)))

;; 用法
(with-context handle-request
  {:request-id (str (random-uuid))
   :user-id    42
   :path       "/api/orders"})

(defn wrap-request-context [handler]
  (fn [req]
    (let [ctx {:request-id (or (get-in req [:headers "x-request-id"])
                               (str (random-uuid)))
               :method     (:request-method req)
               :path       (:uri req)}]
      (log/with-context+ ctx
        (handler (assoc req :request-context ctx))))))

(require '[taoensso.timbre :as log]
         '[cheshire.core :as json])

(log/merge-config!
  {:output-fn
   (fn [{:keys [level msg_ context timestamp]}]
     (json/generate-string
       {:ts      (str timestamp)
        :level   (name level)
        :message (force msg_)
        :ctx     @context}))})

;; deps.edn
{:deps {io.dropwizard.metrics/metrics-core {:mvn/version "4.2.25"}}}

(require '[metrics.core :as m]
         '[metrics.timers :as timers])

(def registry (m/new-registry))
(def req-timer (timers/timer registry "http.requests"))

;; 记录一次请求耗时
(timers/time! req-timer
  (handle-request req))

;; 计数器
(def login-counter (m/counter registry "auth.logins"))
(m/inc! login-counter)

;; 用 prometheus 客户端暴露 /metrics
(require '[io.prometheus.client :as prom]
         '[io.prometheus.client.exporter.common :as common])

(def req-duration
  (prom/histogram "http_request_duration_seconds" "请求耗时"
                  ["method" "path" "status"]))

(defn instrument [handler]
  (fn [req]
    (let [t (prom/start-timer req-duration
                              (name (:request-method req))
                              (:uri req))]
      (let [resp (handler req)]
        (prom/observe-duration! t (str (:status resp)))
        resp))))

;; deps.edn
{:deps {io.opentelemetry/opentelemetry-api       {:mvn/version "1.40.0"}
        io.opentelemetry/opentelemetry-sdk         {:mvn/version "1.40.0"}
        io.opentelemetry/opentelemetry-exporter-otlp {:mvn/version "1.40.0"}}}

(require '[clojure.java.io :as io])
(import '[io.opentelemetry.sdk OpenTelemetrySdk]
        '[io.opentelemetry.sdk.trace SdkTracerProvider]
        '[io.opentelemetry.exporter.otlp.trace OtlpGrpcSpanExporter])

(def tracer-provider
  (-> (SdkTracerProvider/builder)
      (.addSpanProcessor
        (-> (io.opentelemetry.sdk.trace.export.BatchSpanProcessor/builder
              (OtlpGrpcSpanExporter/builder
                (.setEndpoint "http://collector:4317") (.build)))
            (.build)))
      (.build)))

(def open-telemetry
  (-> (OpenTelemetrySdk/builder)
      (.setTracerProvider tracer-provider)
      (.build)))

(def tracer (.get (.getTracerProvider open-telemetry) "my-service" "1.0.0"))

(defn process-order [order]
  (let [span (.spanBuilder tracer "process-order")
        _    (.setAttribute span "order.id" (str (:id order)))
        _    (.setAttribute span "order.amount" (double (:amount order)))
        span (.startSpan span)]
    (try
      (let [result (do-work order)]
        (.setStatus span io.opentelemetry.api.trace.StatusCode/OK)
        result)
      (catch Exception e
        (.recordException span e)
        (.setStatus span io.opentelemetry.api.trace.StatusCode/ERROR)
        (throw e))
      (finally
        (.end span)))))

(require '[io.opentelemetry.api.trace :as trace])
(import '[io.opentelemetry.context Context]
        '[io.opentelemetry.api.trace.propagation W3CTraceContextPropagator])

(def propagator (W3CTraceContextPropagator/getInstance))

(defn extract-context [req]
  (let [getter (reify io.opentelemetry.context.propagation.TextMapGetter
                 (get [_ carrier key] (get-in carrier [:headers key]))
                 (keys [_ carrier] (keys (:headers carrier))))]
    (.extract propagator Context/root req getter)))

(defn inject-headers [ctx]
  (let [setter (reify io.opentelemetry.context.propagation.TextMapSetter
                 (set [_ carrier key value] (assoc-in carrier [:headers key] value)))]
    (.inject propagator ctx {} setter)))

;; 出站请求带上 traceparent
(defn call-downstream [req url]
  (let [ctx     (:otel-context req)
        headers (inject-headers ctx)]
    (http/get url {:headers (merge {"content-type" "application/json"}
                                   (:headers headers))})))

;; 按比例采样（父级无决策时）
(def sampler
  (io.opentelemetry.sdk.trace.samplers.Sampler/traceIdRatioBased 0.1))

;; 尾部采样：始终保留有错误的 trace
;; 由 collector 侧配置（如 otel-collector 的 tail_sampling）