Urmărire distribuită: OpenTelemetry

Urmărire distribuită: OpenTelemetry

1) De ce OTel și ce oferă

• Vizibilitatea end-to-end a căilor de solicitare (gateway → servicii → DB/cache/cozi).
• Rapid RCA/depanare degradare și eliberează (canari/albastru-verde).
• Legătura cu SLO și auto-rollback-uri (soluții operaționale bazate pe date).
• Furnizor-agnostic: export în orice backend, fără legare la un APM.

Principii de referință: standardizați, eșantionați inteligent, securizați în mod implicit, corelați totul.

2) Elemente de bază: context, deschideri, atribute

Trace - call tree/graph; Span - operație (RPC, SQL, apel de coadă).
Span Kind: 'SERVER', 'CLIENT', 'PRODUCATOR', 'CONSUMATOR', 'INTERN'.
W3C Trace Context: anteturi „traceparente”, „tracestate”; contextul este purtat interservicii.
Atribute - valoare-cheie (cardinalitate scăzută!), Evenimente - ștampile de timp, Stare - cod de eroare/descriere.
Link-uri - link se întinde în afara unei ierarhii stricte (important pentru async/fan-out/fan-in).

• HTTP: 'HTTP {METHOD}' ('GET/retrage' ca atribut)
• DB: 'DB SELECT '/' DB INSERT'
• Coada: 'QUEUE publica topic = X '/' QUEUE consuma topic = X'

3) Convenții semantice (semconv)

• HTTP/GRPC: 'http. metoda „,” http. ruta ',' http. status_code', url. complet ".
• DB: 'db. system = postgresql ',' db. declarație „(numai stoarce în condiții de siguranță!),” db. nume ".
• Mesagerie: "mesagerie. system = kafka ',' mesagerie. operation = receive ',' messaging. destinaţie ".
• Cloud/K8s/Host: 'nor. Regiunea ',' k8s. pod. nume „,” container. id'.
• Atribute de resurse (necesare): "serviciu. nume „,” serviciu. versiune ',' implementare. mediu ".

Specificați stabilitatea schemei prin "schemaUrl' în resursele SDK/Colector.

4) Prelevare de probe: cap, coadă, adaptiv

Head-based (în SDK): decide în avans, ieftin; bun pentru high-QPS, dar poate dor de piese „interesante”.
pe bază de coadă (în colector): decide după finalizarea pistei; permite reguli după stare, latență, atribute.
Adaptive/Dynamic: crește cota de eșantion pentru erorile p95/creștere.

Rețeta nivelului de producție: Cap 1-5% la nivel global + Selectarea cozii de „important”: „stare = EROARE”, „latență> p95”, „rute de bani”, erori PSP/KYC.

5) Corelație: valori, busteni, trasee

Exemplare: etichete cu 'trace _ id' în histograme metrice (salt rapid pe pistă).
Jurnale: Adăugați 'trace _ id'/' span _ id' și treceți de la jurnale la urme.
SpanMetrics (procesor) agregate din metrica RED („cereri, erori, durată”) urme pentru SLO/alerte.

6) Arhitectura de implementare

Agent (DaemonSet) pe fiecare nod colectează de la aplicații (OTLP) și înainte.
Gateway (Cluster/Region) - Central Collector (multe replici) cu conducte de rutare/eșantionare/îmbogățire.
OTLP: gRPC „4317”, HTTP „4318”; Activați TLS/mTLS.

Argumente pro de „agent + gateway”: izolare, tamponare, backpressure local, rețea simplificată.

7) OpenTelemetry Collector - șablon de bază (gateway)

yaml receivers:
otlp:
protocols:
grpc: { endpoint: 0. 0. 0. 0:4317 }
http: { endpoint: 0. 0. 0. 0:4318 }

processors:
memory_limiter: { check_interval: 5s, limit_percentage: 75 }
batch: { timeout: 2s, send_batch_size: 8192 }
attributes:
actions:
- key: deployment. environment action: upsert value: prod resource:
attributes:
- key: service. namespace action: upsert value: core tail_sampling:
decision_wait: 5s policies:
- name: errors type: status_code status_code: { status_codes: [ERROR] }
- name: slow_traces type: latency latency: { threshold_ms: 800 }
- name: important_routes type: string_attribute string_attribute:
key: http. route values: ["/withdraw", "/deposit"]
- name: baseline_prob type: probabilistic probabilistic: { sampling_percentage: 5 }

exporters:
otlp/apm:
endpoint: apm-backend:4317 tls: { insecure: true }
prometheus:
endpoint: 0. 0. 0. 0:9464

extensions:
health_check: {}
pprof: { endpoint: 0. 0. 0. 0:1777 }
zpages: { endpoint: 0. 0. 0. 0:55679 }

service:
extensions: [health_check, pprof, zpages]
pipelines:
traces:  { receivers: [otlp], processors: [memory_limiter,attributes,resource,batch,tail_sampling], exporters: [otlp/apm] }
metrics: { receivers: [otlp], processors: [batch], exporters: [prometheus] }
logs:   { receivers: [otlp], processors: [batch], exporters: [] }

8) SpanMetrics și RED pentru SLO

yaml processors:
spanmetrics:
metrics_exporter: prometheus histogram:
explicit:
buckets: [50ms,100ms,200ms,400ms,800ms,1600ms,3200ms]
service:
pipelines:
traces: { receivers: [otlp], processors: [spanmetrics,batch,tail_sampling], exporters: [otlp/apm] }
metrics: { receivers: [otlp], processors: [batch], exporters: [prometheus] }

Acum există 'traces _ spanmetrics _ calls {service, route, code}' și 'duration _ bucket' pentru SLO/alerts.

9) K8s: implementarea colectorului (DaemonSet + implementare)

yaml apiVersion: apps/v1 kind: DaemonSet metadata: { name: otel-agent, namespace: observability }
spec:
template:
spec:
containers:
- name: otelcol image: otel/opentelemetry-collector:latest args: ["--config=/conf/agent. yaml"]
ports:
- { containerPort: 4317, name: otlp-grpc }
- { containerPort: 4318, name: otlp-http }

Gateway (Implementare) - mai multe replici, Service ClusterIP/Ingress, HPA de CPU/QPS.

10) Securitate și confidențialitate

TLS/mTLS SDK Agent Gateway Backend.
Autentificare (Basic/OAuth/Headers) la intrarea Gateway; limitează originile.
Revizuire PII: atribute filtru/mască ('utilizator. e-mail ',' card. ") în procesorul Colector.
Limite: În SDK, limitați dimensiunea evenimentului/numărul de atribute (protecția cardinalității).
RBAC în backend + nume individuale de proiect/chiriaș.

yaml processors:
attributes/redact:
actions:
- key: user. email action: delete
- key: payment. card action: delete

11) Instrumentație: Porniri rapide

Nod. js

js import { NodeSDK } from "@opentelemetry/sdk-node";
import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-grpc";
import { Resource } from "@opentelemetry/resources";
import { SemanticResourceAttributes as R } from "@opentelemetry/semantic-conventions";

const sdk = new NodeSDK({
traceExporter: new OTLPTraceExporter({ url: "http://otel-agent. observability:4317" }),
resource: new Resource({
[R.SERVICE_NAME]: "payments-api",
[R.SERVICE_VERSION]: "1. 14. 2",
[R.DEPLOYMENT_ENVIRONMENT]: "prod"
}),
instrumentations: [getNodeAutoInstrumentations()],
});
sdk. start();

Java (primăvară)

java
// Gradle: io. opentelemetry. instrumentation:opentelemetry-spring-boot-starter
// application. yml otel:
service:
name: orders-api exporter:
otlp:
endpoint: http://otel-agent. observability:4317 traces:
sampler: parentbased_traceidratio sampler-arg: 0. 05

Python (FastAPI)

python from opentelemetry import trace from opentelemetry. sdk. resources import Resource from opentelemetry. exporter. otlp. proto. grpc. trace_exporter import OTLPSpanExporter from opentelemetry. sdk. trace import TracerProvider from opentelemetry. sdk. trace. export import BatchSpanProcessor

provider = TracerProvider(resource=Resource. create({"service. name":"fraud-scoring","deployment. environment":"prod"}))
provider. add_span_processor(BatchSpanProcessor(OTLPSpanExporter(endpoint="http://otel-agent. observability:4317", insecure=True)))
trace. set_tracer_provider(provider)

Du-te

go exp, _:= otlptracegrpc. New(ctx, otlptracegrpc. WithEndpoint("otel-agent. observability:4317"), otlptracegrpc. WithInsecure())
res:= resource. NewWithAttributes(semconv. SchemaURL, semconv. ServiceNameKey. String("gateway"), semconv. DeploymentEnvironmentKey. String("prod"))
tp:= sdktrace. NewTracerProvider(sdktrace. WithBatcher(exp), sdktrace. WithResource(res), sdktrace. WithSampler(sdktrace. ParentBased(sdktrace. TraceIDRatioBased(0. 05))))
otel. SetTracerProvider(tp)

12) Asincron: cozi, autobuze, cron

PRODUCATOR/CONSUMATOR cu comunicare prin „link-uri” (mesajele au propriul lor ciclu de viata).
Propagarea contextului în anteturile de mesaje („traceparent ”/„ bagaj”).
Când consumaţi un lot, creaţi un interval per mesaj sau agregaţi cu atributul 'messaging. lot. dimensiune ".
Pentru cron/jobs: urme noi pentru a rula + link-uri către evenimente primare (dacă există).

13) Bagaje și direcționare

Depozitați un minim de chei stabile ('chiriaș _ id',' regiune ',' vip _ tier ') în bagaj; interzice PII.
Împingeți prin gateway/gateway logger pentru agregarea ulterioară a metricii pe segment.

14) Integrarea cu versiuni și SLO gating

Pașii canari → verifica "urme _ spanmetrica _' pe trasee/sub-segmente.
În timpul degradării (5xx/p95) - auto-stop și rollback (Argo Rollouts AnalysisTemplate + PromQL).
Instanțele din măsurători duc direct la urmele „rele” ale intervalului de eliberare.

15) Limite și performanță

Ограничивайте: 'OTEL _ SPAN _ ATTRIBUTE _ COUNT _ LIMIT', 'OTEL _ SPAN _ EVENT _ COUNT _ LIMIT', 'OTEL _ ATTRIBUTE _ VALUE _ LENGTH _ LIMIT'.
Excepții de probă/stacktrace după probabilitate/frecvență.
Procesor de lot în SDK și colector; păstrați cozi pentru a evita pierderea pieselor atunci când apar explozii.

16) Interoperabilitatea și migrațiile

Propagatoare: utilizați W3C; Suportă dubla propagare B3/X-Ray citire.
Export: OTLP → APM (Jaeger/Tempo/Elastic/X-Ray, etc.).
Versiuni stabile de semconv - fixați "schemaUrl' și upgrade-urile planului.

17) Anti-modele

Cardinalitate ridicată a atributelor ('user _ id' în etichetă, chei dinamice).
Jurnalele fără trace _ id → nici o corelație.
Exportați direct din aplicații în Internet APM (fără gateway, fără TLS/mTLS).
Colectarea „numai” 100% în vânzări este costisitoare și inutilă.
Dumps de interogări SQL cu datele utilizatorului în 'db. declarație ".
Serviciul inconsistent/numele versiunii - valorile sunt „fărâmițare”.

18) Lista de verificare a implementării (0-45 zile)

0-10 zile

Activați SDK/auto-instrumentare pe 2-3 servicii critice.
Configurați Agent (DaemonSet) + Gateway (Implementare), OTLP 4317/4318 cu TLS.
Add' service. nume „,” serviciu. versiune ',' implementare. mediu "peste tot.

11-25 zile

Prelevarea de probe prin erori/latență/rute de” bani”.
SpanMetrics → Prometheus, includ exemplare și tablouri de bord RED/SLO.
Propagarea W3C prin gateway-ul API/NGINX/mesh; corelează jurnalele.

26-45 zile

Cozi de acoperire/DB/cache; link-uri pentru async.
Politici PII-ediție în Colector; limitele atributelor în SDK.
Integrați SLO gating de versiuni și auto-rollback.

19) Valorile maturității

Acoperirea cererii de intrare cu urmărire ≥ 95% (inclusiv cap de eșantionare/coadă).
Ponderea măsurătorilor cu exemplare ≥ de 80%.
Timp RCA „de la metric la trace” ≤ 2 min (p50).
0 scurgeri PII în atribute/evenimente (scanner).
Toate serviciile au serviciu. nume/versiune/mediu "și semantică consistentă.

20) Apendice: fragmente utile

nginx proxy_set_header traceparent $http_traceparent;
proxy_set_header tracestate $http_tracestate;
proxy_set_header baggage   $http_baggage;

histogram_quantile(0. 95, sum(rate(traces_spanmetrics_duration_bucket{route="/withdraw"}[5m])) by (le))

Politică: interzicerea atributelor PII (pseudo-linter)

yaml forbid_attributes:
- user. email
- payment. card
- personal.

21) Concluzie

OpenTelemetry transformă observabilitatea într-un circuit standardizat, ușor de gestionat: semantică unificată, propagare sigură, eșantionare inteligentă și corelație puternică cu metrica și jurnalele. Construiți un agent + gateway, adăugați prelevarea de probe, spanmetrica și Examplars, monitorizați PII și cardinalitatea - iar urmărirea va deveni un instrument nu numai pentru depanare, ci și pentru soluții automate SRE/Release, reducând MTTR și riscurile cu fiecare versiune.