แแแขแแ แแแ: แขแแ แแแแแ, แแ แแขแแ แจแแฐแ แแ แขแแฅแแแแฃแ แ แกแแแชแแคแแแแชแแแแแก แแแแแขแแขแ (แแแ แแแก แแแแแ แขแ, แแแแแแ แแ แฃแขแฃ, แกแแ แแแ แแแแแแแแแ แแ แแฃแ แ แจแแฃแ แ).
แแ แแแแแแแแ แแ แแแฅแขแแ แแแแฆแ แกแแฎแแแ:
แซแแแแแ, แซแแแแแ แแแแแแ:
- แฉแแแ แแฅแแแแ แแแแแแแแแแแแแกแ แแ แกแแแชแแคแแแแชแแแแแก แแฎแแ แแ แแแแแแแแแก แขแแแแแแขแ แแฃแแ แแแแแขแแ แแแแแก แจแแกแแซแแแแแแแแแแกแแแแก. แแก แแแแแ แแแแแแแก OpenTracing แแ OpenCensus แแ แแแฅแขแแแก แแ แฃแแ แฃแแแแแงแแคแก แแแแ แแชแแแก แแฎแแ แแแญแแ แแ แแแแก.
- Java-แจแ แกแแชแแแแแ แ แแแแแแแแแขแแชแแ แฎแแแแแกแแฌแแแแแ แแฅแแแแ 24 แแแ แแแก, แฎแแแ แกแฎแแ แแแแแแ แแแแแ แแแแแ แแฃแจแแแแ แกแ แฃแแแ แแแแฌแงแแแ 8 แฌแแแก 2019 แแแแกแก. แแฎแแแแ แแแแ แแแ
แแฅ แแ แแก แจแแกแแซแแแแแแ . - 2019 แฌแแแก แกแแฅแขแแแแ แแกแแแแก แแแแแแแแแแ แแแ แแขแแขแ แแ แกแแแฃแ แแ แแแฅแขแแแแแ C#, Golang, Java, NodeJS แแ Python-แแกแแแแก. แฌแแ แแแแ แ แกแแแฃแจแแ แแแแแแก, แแแแ แแ แแแ แแแแแฃแ แแ แแฃ แแแแฃแจแแแแแ, แแแแฃแแแแแแแแแแ. แแฃ แแฅแแแ แแแแแขแแ แแกแแแฃแแ แฎแแ แ แแ แแ แแแฅแขแจแ แแแแแฌแแแแแแแ, แแแฎแแแ แแแ แแแแกแขแ แแ แแแ แแ แจแแแแแขแงแแแแแแ, แแฃ แ แแแแ แแกแฃแ แ แฌแแแแแ แจแแแขแแแแ.
- แแแก แจแแแแแ, แ แแช แแแแแแฃแ แแแแแ แแแแแ แแแ แแแแฌแแคแแแแ, แจแแกแแแแแแกแ OpenTracing แแ OpenCensus แแ แแแฅแขแแแ แแแแฎแฃแ แแแ. แแก แแแจแแแแก, แ แแ แซแแแแ แแ แแแฅแขแแแ แแแงแแแฃแแ แแฅแแแแ แแ แแฎแแแ แแ แแแฅแขแ แแแแแ แซแแแแแก แแ แกแแแฃแแ แแแกแขแ แฃแแแแขแแแแก แแฎแแ แแแญแแ แแก แแ แ แฌแแแก แแแแแแแแแแแจแ แฃแแแแแแแ แฃแแแแฃแแ แแแแกแแแแแแแแก แแแแแงแแแแแแ.
แแ แแแฅแขแแก แแแแแฎแแแแ
แฉแแแ แแแแแแแแ แแแแ แแแแแแแแก! แกแแแแแแ แแแแแแแ OpenTracing แแ OpenCensus แแ แแแฅแขแแแแก แแแแ แแแแแแแ แแ แ แกแแแ แแ แแ แแแฅแขแแ.
แแฎแแแ แแ แแแฅแขแแก แแแ แแแ แแฅแแแแ แกแฃแคแแ แแ แแแแแ แแแฃแแ แแแขแแ แคแแแกแแแแก แแแแ แแแ, แแแ แจแแ แแก แแแแแแแแแแแแแก แขแ แแแแชแแฃแแ แแกแแแแแแ, แ แแแแแแช แแ แแแขแแ แคแแแกแแแก แแฎแแ แชแแแแแแก แ.แฌ. SDK. แแแแชแฎแแแ แ แแฅแแแแ แ แแแแแแแแแ แแแฃแแ แกแขแแแแแ แขแแแ แแแแแชแแแแ แแ แแแแแฃแแแก แแ แแขแแแแแแแแกแแแแก, แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แกแแแ แแ แแแฌแแแแแแก แฉแแแแแแ.
แจแแแแแ แแฅแแแแ แกแ แฃแแ แขแแแแแแขแ แแฃแแ แกแแกแขแแแ, แ แแแแแแช แจแแกแแคแแ แแกแแ แแแแ แแกแแ แแแกแแแแก แแ แกแฎแแ แขแแแแก แแแแแแแแ แแแ แแแแแฌแแแแแฃแแ แกแแกแขแแแแแแก แแแแแขแแ แแแแแกแแแแก, แแแแกแแแแแ แงแแแแแแ แซแแ แแแแ OSS-แแแ แแ แแแแแ แชแแฃแ แแ แแแ แแแฃแ แฃแแ แฃแแแแแงแแคแแกแแแ.
แแแแแแ แ แแแแแแแแแ
24.04/XNUMX โ แแแแกแแฎแแแแแแแ แฌแแ แแแแแแแ แ แแคแแ แแแข แแแแแแแแขแ.
8.05 โ แแฅแแแแแ แแฃแแแ แแ แแฌแงแแแก แแฃแจแแแแแก แงแแแแ แแแแแ.
20.05 โ แแ แแแฅแขแแก แแคแแชแแแแฃแ แ แแแฌแงแแแ แแฃแแแแแ แแแ แกแแแแแแจแ.
6.09 - แแแแแ แแแ C#-แจแ, Golang-แจแ, Java-แจแ, NodeJS-แกแ แแ Python-แจแ แแแแแกแฌแแ แแแแก แแฆแฌแแแก แแแ แแแแแแแแแแ.
6.11 - OpenTracing แแ OpenCensus แแ แแแฅแขแแแแก แแคแแชแแแแฃแ แ แแแกแ แฃแแแแ.
20.11 โ แแแแแกแแแจแแแแแแแแแแ แฌแแแฃแแแแ แแ แแแฅแขแแแแก แแแกแ แฃแแแแแก แกแแแแขแแแชแแแฃแแแ แแแแแแ แแแแแแแแแก แกแแแแขแแ, แแฃแแแแแ แกแแ แแแแแ.
แแแแแแ แแแแชแแแก แแแแแแ
แแแแแแฃแแ แแแแก แแแแ แแชแแ แแแแชแแแก แฌแแ แแแแแแกแแแแก แแแ SDK-แก, แฎแแแกแแฌแงแแแแก แแแแฃแแแ แฃแแ แแแแแแแแแแแแแกแแแแก, แแแแฃแแแแขแแชแแ, CI, แฃแแแแ แแแแกแแแแแแแแก แฎแแแกแแฌแงแแแแ แแ แแแแแแจแแ แแแฃแแ OpenCensus แแ OpenTracing แแ แแแฅแขแแแแก แแแฎแฃแ แแ (โแแแแก แฉแแกแแแโ). แฉแแแ แแแแกแแฎแแ แแแแแชแแฃแ แ แแแแแแ 2019 แฌแแแก แกแแฅแขแแแแ แแกแแแแก - แแแแแฆแฌแแแ แแแ แแขแแขแก C#, Golang, Java, NodeJS แแ Python แแแแแแกแแแแก. แฉแแแ แแแแแแแขแแแ แแแแก แฉแแกแแแแก แแแ แแฆแก, แกแแแแ แงแแแแ แแแ แแแแ แแ แแฅแแแแ. แแแแ แแ แกแแกแฃแ แแแแแ แแแแก แแแแแแแ แแชแแแแแ.
แแแแแแแแก แแแฎแแแกแแก, แแแฎแแแ, แแแแแแแแแกแฌแแแแ แแฅแแแแ แแแ แแแ แฉแแ แแฃแแแแ, แจแแแแแขแงแแแแแแ แจแแแกแแแแ
แแแแแแ: แแแแแแจแแ แแกแ แกแแแชแแคแแแแชแแแก แแแ แแแแ แแ แแแฅแขแ (แแแกแ แฃแแแแ 8 แแแแกแแแแ)
แแแแจแแแแแแแแแแ แจแแแ แฃแแ แแฃแจแแแแ, แแฃแแแแช แกแฎแแแแแกแฎแแ แแแแแ แแแ แแแแแฃแ แแ แแฃแจแแแแแกแแก. แแแแแแจแแ แแกแ แกแแแชแแคแแแแชแแ แแซแแแแ แฎแแแแซแฆแแแแแแแแแก แแ แแแฅแขแแกแแแแก. แแก แแ แแแแฃแแแ แแฆแแ แก, แแแแ แแ แแก แฃแแ แฃแแแแแงแแคแก แแแแแแแแแแ แฃแแ แกแแกแขแแแแก แแฎแแ แแแญแแ แแก, แ แแแแแแช แแ แแแ แแแแ แแแแก แแแแก แแแฃแฎแแแแแแ แแแชแแแแแ แแแ แซแแแแ.
แกแแแแแแแแฃแแ แแแแฎแแแแแแ แแแ แแแแ แแ แแแฅแขแแก แกแแแชแแคแแแแชแแแกแแแแก X แแแแกแแแแก:
- แแแแแแ แขแแ แแแแแแแแแแก แแแแแแ แขแแแแแ.
- แแแแแฌแแแแแฃแแ แขแ แแแแแฅแชแแแแแก, แกแขแแขแแกแขแแแแกแ แแ แแแขแ แแแแก แแฆแฌแแ แแก แแแแแแ.
- แแแแฎแแ แชแแแแแแแก แแ แแก แฌแแ แแแฅแแแแ แแแแจแแแแแแแแ แกแแแแแฎแแแแ แแแแแแ แขแแแแแ.
แแก แแแแแแ แแแแแแแก แแแแแ แฉแแ แกแแแฃแจแแแแแก, แแแ แแแแ แแ แแแฅแขแ 8 แแแแกแแแแ แฃแแแ แแแกแ แฃแแแแก.
แแแแแแ: แแแแแชแแแแ แแแแฃแกแขแแแแก แแแ แแแแ แแ แแแฅแขแ (แแแกแ แฃแแแแ 6 แแแแแกแแแแ)
แแแแแชแแแแ แกแแแชแแคแแแแชแแ แแแแกแแแฆแแ แแแก แแแแแชแแแแ แกแแแ แแ แคแแ แแแขแก แแแแแแกแ แแ แแแขแ แแแแแแกแแแแก แแกแ, แ แแ แงแแแแ แแ แแชแแกแแ แแฅแกแแแ แขแแ แแแฃแแ แแแแแชแแแแแ แจแแแซแแแแ แแแแฃแจแแแแแก แแแแแ แขแแแแแแขแ แแฃแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแ, แแแแแชแแแแ แแแแแ แแ แแแแก แแ แแชแแกแแก แแแฃแฎแแแแแแ. แแก แแแแชแแแก แแแแแชแแแแ แกแฅแแแแก แแแแแแก แแแแแแแกแแแแก, แ แแแแแแช แแฆแฌแแ แแแแ แแแแแ แแแ แกแแแชแแคแแแแชแแแจแ. แแกแแแ แจแแแแก แแแขแแแแแแชแแแแแแก แแแแแแ แขแแแแแ แกแแแ แแ แแแแ แแชแแแแแกแแแแก, แ แแแแแแกแแช แแแแแ แแงแแแแแก แแฆแกแแแแญแแแ, แ แแแแ แแชแแ HTTP แแแแฎแแแแแแ, แจแแชแแแแแแ แแ แแแแแชแแแแ แแแแแก แแแแฎแแแแแแ. แแกแแแ
แแแ แแแแ แแ แแแฅแขแ แแแคแฃแซแแแแฃแแแ OpenCensus แแแแแชแแแแ แแแแแแแแ แ แคแแ แแแขแแ แแ แจแแแชแแแก แจแแแแแแก:
- แแแแแชแแแแ แกแฅแแแ, แ แแแแแแช แแฎแแ แชแแแแแแก แแแแแแจแแ แแก แกแแแชแแคแแแแชแแแก.
- แแแขแแแแแแชแแแแแแก แแแแแแ แขแแแแแ แกแแแ แแ แแแแ แแชแแแแแกแแแแก.
- JSON แแ Protobuf แแแแแแ แขแแแแแ.
- แกแแชแแแแแ แ แแแแแแขแแแแก แแแแฎแแ แชแแแแแแ.
แแแฎแแแ แแแแแแแแแกแฌแแแแ, แ แแ แแกแแแ แแ แกแแแแแก แแแแแฃแแแก แแ แแขแแแแแ, แ แแแแแแช แแแแฌแแแแแก แแแแแก แแแแจแ, แ แแแแแก แกแขแแแแแ แขแแแแชแแแช แแแกแฃแ แก. แแแแแฌแแแแแแก แคแแ แแแขแ
แแแแแแ: แแแแแกแฌแแ แแแ แงแแแแ แซแแ แแแแ แแฎแแ แแแญแแ แแ แแแแแ (แแแกแ แฃแแแแ 6 แกแแฅแขแแแแ แแแแ)
แฉแแแ แฃแแแ แแแแแฆแฌแแแ แแแแแกแฌแแ แแแแก แแฆแแแแแแแแ แแแแแ แแแ แแแแกแแกแขแแแแกแแแแก แซแแแแ แแ แแแฅแขแแแแก แแฎแแแ แฉแแแแชแแแแแแ.
- แแแขแแ แคแแแกแแก แแแแแแ แขแแแแแ แขแ แแกแแแแแก, แแแขแ แแแแกแ แแ แแแแขแแฅแกแขแแก แแแแ แชแแแแแแกแแแแก, แแแแแ แแแ แกแแแชแแคแแแแชแแแก แกแแคแฃแซแแแแแ.
- แแแ แแแแแกแแงแแแแแแแ SDK, แ แแแแแแช แแฎแแ แชแแแแแแก แแ แแแขแแ แคแแแกแแแก แแ แแฎแแ แชแแแแแแก Trace-Data-แก แแฅแกแแแ แขแก. แกแแแแช แจแแกแแซแแแแแแแ, SDK แจแแแฅแแแแแ OpenCensus-แแแ แแ แกแแแฃแแ แแแแฎแแ แชแแแแแแแก แแแ แขแแ แแแแ.
- แฎแแแกแแฌแงแแแแแก แแแแ แแแ แแแแฃแแแ แฃแแ แแแแแแแแแแแแแกแแแแก, แ แแแแแแแช แแแแแแแ แแแคแแ แฃแแแ OpenTracing-แกแ แแ OpenCensus-แจแ.
แฉแแแ แแกแแแ แแแคแแกแแแ แฉแแแแ แฉแแแแ แแแแกแแแแแแแแก แแ แแแแแแ แฃแแ แฃแแแแแแงแแ แแแฃแแ แแแแแกแแแ แแ แกแแแฃแแ แแ แแแฅแขแแแแแแ.
- แแฎแแแ SDK แแฅแแแแ แฃแแฃแแแแกแแแแแ OpenTracing-แแก แแแแแแแแ แ แแแขแแ แคแแแกแแแแแ. แแกแแแ แกแแจแฃแแแแแแก แแแกแชแแแก แแแแแแแแ แแแแแ OpenTracing แแแกแขแ แฃแแแแขแแแก แแแฃแจแแแ แแฎแแ แแแกแขแ แฃแแแแขแแแแแ แแ แแแ แแแแแ แแ แแชแแกแจแ, แ แแช แแแแฎแแแ แแแแแแก แกแแจแฃแแแแแแก แแแกแชแแแก แแ แแแ แแแแแแแแแแแจแ แแแแแแขแแแแ แแแแแแแแ แกแแแฃแจแแ.
- แ แแแแกแแช แแฎแแแ SDK แแแแ แแฅแแแแ, แแแแแฎแแแแแก แแแแแ แจแแแฅแแแแแ OpenCensus-แแก แแแแแแแแ แ แแแแฎแแแ แแแแแแแกแแแแก. แ แแแแ แช OpenTracing-แแก แจแแแแฎแแแแแจแ, แแแแแแแแ แแแแแแ แฎแแแกแแฌแงแแแแ แจแแซแแแแแ แแแแแ แซแแแแ แแฃแจแแแแ แแฎแแแแแแแ แแ แแแ.
- แแแแแแ แแกแแแแก, OpenTracing แแ OpenCensus แแแฎแฃแ แฃแแ แแฅแแแแ แชแแแแแแแแแแก แแแกแแฆแแแแ. แแแซแแแแแแฃแ แแแกแขแ แฃแแแแขแแแแแ แฃแแแแ แแแแกแแแแแแแ แแฎแแ แแแญแแ แแแ แแฅแแแแ แแ แ แฌแแแก แแแแแแแแแแแจแ.
แงแแแแ แแแแกแแแแก แกแแฃแแแแแกแ แแแแกแแก SDK-แแก แจแแฅแแแ แแแ แจแ แแแแก แแแแแฎแแแก แแ แแก แแ แแก แแก, แ แแช แงแแแแแแ แแแขแแ แแแญแแ แแแแ.
แแแแแแ: แซแแ แแแแแ แแแแฃแแแแขแแชแแ (แแแกแ แฃแแแแ 6 แกแแฅแขแแแแ แแแแ)
แแแแแกแแแแ แ แฆแแ แแแแแก แแ แแแฅแขแแก แฌแแ แแแขแแแแก แแ แแขแแแฃแแ แคแแฅแขแแ แแ แแแแฃแแแแขแแชแแ. แฉแแแ แแแแแแ แฃแแแฆแแแกแ แแแแแก แแแแฃแแแแขแแชแแ แแ แกแแกแฌแแแแ แแแกแขแ แฃแแแแขแแแ แแ แฉแแแแ แขแแฅแแแแฃแ แ แแฌแแ แแแแ แแ แแแ แงแแแแแแ แแฅแขแแฃแ แ แแแแแแแแแ แแแ แแ แแแฅแขแจแ. แแแแแแแแแ แแแแกแแแแก แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แกแฌแแ แแ แแแแแขแแ แแแแแก แกแฌแแแแแแ แแ แแก แแ แ-แแ แแ แงแแแแแแ แแแแจแแแแแแแแแ แแแแแแแ, แ แแช แแแแแแ, แ แแ แฐแฅแแแแแก แแกแแคแแแแจแ.
แจแแแแแแ แแแแฃแแแแขแแชแแ แแ แแก แแแแแแแแฃแ แ แกแแญแแ แ แแแกแแฌแงแแแแ:
- แแ แแแฅแขแแก แแ แแแแขแแชแแ.
- แแแแแแ แแแแแแแแ 101.
- แแแฌแงแแแ.
- แแแแก แกแแฎแแแแซแฆแแแแแแ (แแแแแแฃแแ แชแแ-แชแแแแ).
แแแกแแกแแแแแแแแแ แงแแแแ แแแแแก แแฌแแ แแแแ! แฉแแแแ แแฎแแแ แกแแแขแ แแแคแฃแซแแแแฃแแแ Hugo-แแ แแ แแงแแแแแก แ แแแฃแแแ แฃแ แแแ แแแ แแแแก, แแกแ แ แแ, แแแกแ แฌแแแแแ แจแแแขแแแแก แกแแแแแแ แแแ แขแแแแ.
แแแแแแ: Registry v1.0 (แแแกแ แฃแแแแ 6 แแแแแกแแแแ)
แ แแแกแขแ แ - แแแแแ แแ แแ แแแแจแแแแแแแแแ แแแแแแแแแขแ, แแแฃแแฏแแแแกแแแฃแแ แแแ แกแแ
- แแแแแแแ แแแแแแแแแแแแแก, แแแแแแแขแแแแก, แแแกแขแแแแขแแ แแแแก แแ แกแฎแแ แแแแแแแแแขแแแแก แแแแแ.
- แ แแแกแขแ แแก แแแแแแแแแขแแแแก แแแ แขแแแ แแแ แแแ.
- แจแแแแซแแแแ แแแแแแ, แ แแแแแ SDK แคแฃแแฅแชแแแแแ แฎแแแแแกแแฌแแแแแ แแแแแแฃแ แแแแแ.
แแฃ แแแแแขแแ แแกแแแ แแแแแแแ, แแแขแแ แคแแแกแ แแ UX, แฉแแแ แแแแฅแแก แจแแกแแแแจแแแแ แแ แแแฅแขแ แแแ แแแ แแแแแฌแแแแแแแกแแแแก.
แแแแแแ: แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แขแแกแขแแ แแแแกแ แแ แแแแแจแแแแแก แแแคแ แแกแขแ แฃแฅแขแฃแ แ (แแแกแ แฃแแแแ 6 แกแแฅแขแแแแ แแแแ)
แแแแก แฃแแ แฃแแแแแกแแงแแคแแ, แ แแ แฉแแแ แแแแแแ แซแแแแแ แฃแกแแคแ แแฎแ แแแแแก แแแฌแแแแแแก, แ แแแแแกแแช แแฅแแแ แจแแแแซแแแแ แแแแงแ แแแแ, แฉแแแ แแแแฅแแก แแแแแแแแก แแแแแแแฃแแแแ แแแแจแแแแ แฎแแ แแกแฎแแก แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แขแแกแขแแ แแแ แแ แแแแแจแแแแแก แแแแกแแแแแแแ. แแแฎแแแ, แจแแแแแขแงแแแแแแ, แจแแแแซแแแแ แแฃ แแ แ แแแ แฃแแแ แแแแกแแแแแแแแ แขแแกแขแแ แแแแก, แแแฎแแกแแแแแแแกแ แแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแแแแจแแแแแกแแแแก. แฉแแแ แแแแแแ แแแแฃแแแแแแ แกแแฌแแ แแแ แแแแแงแแคแแแก แแแแแก แแ แฉแแแแแแแก แแแแแแ แ แแแแแแฌแงแแแขแ แคแแฅแขแแ แ แแฅแแแแ แขแแกแขแแ แแแแก แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แกแแแฌแแคแ.
แแแแแแ: OpenTracing แแ OpenCensus แแ แแแฅแขแแแแก แแแฎแฃแ แแ (แแแกแ แฃแแแแ 6 แแแแแแ แแแแ)
แฉแแแ แแแแแแแแ แซแแแแ แแ แแแฅแขแแแแก แแแฎแฃแ แแแก 6 แกแแฅแขแแแแแ แก, แแฃ แแฎแแแ แแ แแแฅแขแ แแแแแแ แแแแแกแฌแแ แแแแก แแแแฆแฌแแแก. 2 แแแแก แจแแแแแ, แงแแแแ แแแแก แแแ แแขแแขแแ, แฉแแแ แแแแแแแแ OpenTracing แแ OpenCensus แแ แแแฅแขแแแแก แแแฎแฃแ แแแก. แแก แแกแ แฃแแแ แแแแแแแ:
- แกแแชแแแ แแแแงแแแแแ แแ แจแแแแแแแ แชแแแแแแแแแ แแ แแแแฎแแ แชแแแแแแแ.
- แแแแแแแแแแแ แแแกแขแ แฃแแแแขแแ แแฃแแแก แแแแแแแแแแ แแ แฌแแแแแ แแฎแแ แแแญแแ แแก แแแ แแแแ.
- แแแแฎแแแ แแแแแแก แจแแแซแแแแแ แแแแแฎแแแแก แแฎแแ SDK-แแ แแแแแ แฎแแแกแแฌแงแแแแแก แแแแแงแแแแแแ.
- แแขแแแแแ แแแ แแแแแฎแแแแ แจแแกแแซแแแแแแ แแฅแแแแ.
แจแแแแแแแแ แแแแ แแฎแแ
แฉแแแ แแแแแกแแแแแแแ แแแแแกแแแแ แแแฎแแแ แแแแก, แ แแแแแ แแก แแ แแก แฃแแแ แแแแแ แ แแ แแแฅแขแ. แแฃ แแแแแขแแ แแกแแแ แแแแแแ แแแแแแแแแก แกแฌแแแแ, แแฎแแ แแ แแ!
- แจแแแแกแแ
แกแแ แแแแกแขแ แแชแแ แคแแ แแ แแแ แแแแแ แ แแแแแฌแแแแแแแกแแแแก แแ แแฃแแแจแ แจแแกแแแแกแแแแก. - แแแแแแแแแจแแ แแแ แแ แฎแแแแ
OpenTracing ะธแฆแแ แแฆแฌแแ แ แแแขแแ แ. - แจแแแแแฌแแ
แฏแแแแก แแแแแแแแแก แแแแฎแแ แชแแแแแแ , แ แแแแแแช แแแแฃแจแแแแแแก แแ แแชแแกแจแแ.
แฌแงแแ แ: www.habr.com