સર્વિસ ટ્રેસિંગ, ઓપનટ્રેસિંગ અને જેગર

અમે અમારા પ્રોજેક્ટ્સમાં માઇક્રોસર્વિસ આર્કિટેક્ચરનો ઉપયોગ કરીએ છીએ. જ્યારે કામગીરીમાં અડચણો આવે છે, ત્યારે લોગની દેખરેખ અને પાર્સિંગમાં ઘણો સમય પસાર થાય છે. લૉગ ફાઇલમાં વ્યક્તિગત ઑપરેશનના સમયને લૉગ કરતી વખતે, સામાન્ય રીતે એ સમજવું મુશ્કેલ હોય છે કે આ ઑપરેશનના આહવાનનું કારણ શું છે, ક્રિયાઓના ક્રમને ટ્રૅક કરવા અથવા વિવિધ સેવાઓમાં એક ઑપરેશનના બીજા ઑપરેશનના સમયની પાળીને ટ્રૅક કરવી.

મેન્યુઅલ લેબર ઘટાડવા માટે, અમે ટ્રેસિંગ ટૂલ્સમાંથી એકનો ઉપયોગ કરવાનું નક્કી કર્યું. તમે કેવી રીતે અને શા માટે ટ્રેસિંગનો ઉપયોગ કરી શકો છો અને અમે તે કેવી રીતે કર્યું તે વિશે અને આ લેખમાં ચર્ચા કરવામાં આવશે.

ટ્રેસિંગ સાથે કઈ સમસ્યાઓ હલ કરી શકાય છે

1. એક જ સેવાની અંદર અને તમામ સહભાગી સેવાઓ વચ્ચેના સમગ્ર અમલના વૃક્ષમાં કામગીરીની અડચણો શોધો. દાખ્લા તરીકે:
   • સેવાઓ વચ્ચે ઘણા ટૂંકા સળંગ કૉલ્સ, ઉદાહરણ તરીકે, જીઓકોડિંગ અથવા ડેટાબેઝ માટે.
   • લાંબી I/O રાહ જુએ છે, જેમ કે નેટવર્ક ટ્રાન્સફર અથવા ડિસ્ક રીડ.
   • લાંબો ડેટા પાર્સિંગ.
   • લાંબી કામગીરી માટે સીપીયુની જરૂર પડે છે.
   • કોડના વિભાગો કે જે અંતિમ પરિણામ મેળવવા માટે જરૂરી નથી અને દૂર કરી શકાય છે અથવા વિલંબિત થઈ શકે છે.
2. જ્યારે ઓપરેશન કરવામાં આવે ત્યારે શું કહેવાય છે અને શું થાય છે તે ક્રમમાં સ્પષ્ટપણે સમજો.
   
   તે જોઇ શકાય છે કે, ઉદાહરણ તરીકે, વિનંતી ડબ્લ્યુએસ સેવા પર આવી -> ડબ્લ્યુએસ સેવાએ આર સેવા દ્વારા ડેટા ઉમેર્યો -> પછી વી સર્વિસને વિનંતી મોકલી -> વી સર્વિસએ આર સર્વિસમાંથી ઘણા બધા ડેટા લોડ કર્યા -> પી સર્વિસ પર ગયા -> પી સર્વિસ ફરીથી આર સર્વિસ પર ગઈ -> વી સર્વિસને જે સર્વિસ પર પાછા ફર્યા અને તે પછીની સેવા ચાલુ રાખતી હતી.
   આખી પ્રક્રિયા માટે આવા ટ્રેસ અથવા વિગતવાર દસ્તાવેજીકરણ વિના, કોડને પહેલીવાર જોતી વખતે શું થઈ રહ્યું છે તે સમજવું ખૂબ જ મુશ્કેલ છે, અને કોડ વિવિધ સેવાઓમાં પથરાયેલો છે અને ડબ્બા અને ઇન્ટરફેસના સમૂહની પાછળ છુપાયેલ છે.
3. અનુગામી વિલંબિત વિશ્લેષણ માટે અમલના વૃક્ષ વિશેની માહિતીનો સંગ્રહ. એક્ઝેક્યુશનના દરેક તબક્કે, તમે આ તબક્કે ઉપલબ્ધ ટ્રેસમાં માહિતી ઉમેરી શકો છો અને પછી આકૃતિ શોધી શકો છો કે કયો ઇનપુટ ડેટા સમાન દૃશ્ય તરફ દોરી ગયો. દાખ્લા તરીકે:
   • વપરાશકર્તા ID
   • અધિકાર
   • પસંદ કરેલ પદ્ધતિનો પ્રકાર
   • લોગ અથવા એક્ઝેક્યુશન ભૂલ
4. ટ્રેસને મેટ્રિક્સના સબસેટમાં ફેરવવું અને મેટ્રિક્સના સ્વરૂપમાં પહેલાથી જ વધુ વિશ્લેષણ.

શું ટ્રેસ લોગ કરી શકો છો. સ્પેન

ટ્રેસીંગમાં સ્પાનનો ખ્યાલ છે, આ કન્સોલ માટે એક લોગનું એનાલોગ છે. સ્પામાં છે:

• નામ, સામાન્ય રીતે ચલાવવામાં આવતી પદ્ધતિનું નામ
• સેવાનું નામ જેમાં સ્પાન જનરેટ કરવામાં આવ્યો હતો
• પોતાની અનન્ય ID
• કી/મૂલ્યના રૂપમાં અમુક પ્રકારની મેટા માહિતી જે તેમાં લૉગ ઇન કરવામાં આવી છે. ઉદાહરણ તરીકે, પદ્ધતિ પરિમાણો અથવા પદ્ધતિ ભૂલ સાથે સમાપ્ત થાય છે કે નહીં
• આ સમયગાળા માટે પ્રારંભ અને સમાપ્તિ સમય
• પિતૃ સ્પાન ID

દરેક સ્પાન તેના અમલીકરણને પૂર્ણ કર્યા પછી પછીની સમીક્ષા માટે ડેટાબેઝમાં સંગ્રહિત કરવા માટે સ્પાન કલેક્ટરને મોકલવામાં આવે છે. ભવિષ્યમાં, તમે પેરેન્ટ આઈડી દ્વારા કનેક્ટ કરીને તમામ સ્પાન્સનું એક વૃક્ષ બનાવી શકો છો. વિશ્લેષણ કરતી વખતે, તમે શોધી શકો છો, ઉદાહરણ તરીકે, અમુક સેવામાંના તમામ સ્પાન્સ કે જેમાં અમુક સમય કરતાં વધુ સમય લાગ્યો હતો. આગળ, ચોક્કસ સ્પાન પર જઈને, આ સ્પાનની ઉપર અને નીચે આખું વૃક્ષ જુઓ.

ઓપનટ્રેસ, જેગર અને અમે અમારા પ્રોજેક્ટ્સ માટે તેને કેવી રીતે અમલમાં મૂક્યું

એક સામાન્ય ધોરણ છે ઓપનટ્રેસ, જે વર્ણવે છે કે કેવી રીતે અને શું એકત્રિત કરવું જોઈએ, કોઈપણ ભાષામાં ચોક્કસ અમલીકરણ સાથે ટ્રેસ કર્યા વિના. ઉદાહરણ તરીકે, જાવામાં, ટ્રેસ સાથેનું તમામ કાર્ય સામાન્ય ઓપનટ્રેસ API દ્વારા હાથ ધરવામાં આવે છે, અને તેના હેઠળ, ઉદાહરણ તરીકે, જેગર અથવા ખાલી ડિફોલ્ટ અમલીકરણ જે કંઈ કરતું નથી તે છુપાવી શકાતું નથી.
અમે ઉપયોગ કરી રહ્યા છીએ જાગર ઓપનટ્રેસના અમલીકરણ તરીકે. તે ઘણા ઘટકો સમાવે છે:

• Jaeger-agent એ સ્થાનિક એજન્ટ છે જે સામાન્ય રીતે દરેક મશીન પર ઇન્સ્ટોલ કરવામાં આવે છે અને સેવાઓ સ્થાનિક ડિફોલ્ટ પોર્ટ પર લોગ ઇન થાય છે. જો ત્યાં કોઈ એજન્ટ ન હોય, તો આ મશીન પરની તમામ સેવાઓના નિશાન સામાન્ય રીતે અક્ષમ હોય છે
• જેગર-કલેક્ટર - બધા એજન્ટો તેને એકત્રિત કરેલા નિશાન મોકલે છે, અને તે તેને પસંદ કરેલા ડેટાબેઝમાં મૂકે છે
• ડેટાબેઝ એ તેમની પસંદગીની કેસન્ડ્રા છે, પરંતુ અમે ઇલાસ્ટિકસર્ચનો ઉપયોગ કરીએ છીએ, અન્ય કેટલાક ડેટાબેસેસ માટે અમલીકરણો અને ઇન-મેમરી અમલીકરણ છે જે ડિસ્ક પર કંઈપણ સાચવતું નથી.
• Jaeger-query એ એવી સેવા છે જે ડેટાબેઝ પર જાય છે અને વિશ્લેષણ માટે પહેલાથી જ એકત્રિત કરેલા નિશાન પરત કરે છે.
• Jaeger-ui એ ટ્રેસ શોધવા અને જોવા માટેનું વેબ ઈન્ટરફેસ છે, તે jaeger-query પર જાય છે

એક અલગ ઘટકને વિશિષ્ટ ભાષાઓ માટે ઓપનટ્રેસ જેગરનું અમલીકરણ કહી શકાય, જેના દ્વારા જેગર-એજન્ટને સ્પાન્સ મોકલવામાં આવે છે.
જાવામાં જેગરને કનેક્ટ કરી રહ્યું છે io.opentracing.Tracer ઈન્ટરફેસને અમલમાં મૂકવા માટે નીચે આવે છે, જે પછી તેમાંથી તમામ નિશાનો વાસ્તવિક એજન્ટ તરફ જશે.

વસંત ઘટક માટે પણ, તમે કનેક્ટ કરી શકો છો ઓપનટ્રેસિંગ-સ્પ્રિંગ-ક્લાઉડ-સ્ટાર્ટર અને જેગર તરફથી અમલીકરણ ઓપનટ્રેસિંગ-સ્પ્રિંગ-જેગર-ક્લાઉડ-સ્ટાર્ટર જે આ ઘટકોમાંથી પસાર થતી દરેક વસ્તુ માટે ટ્રેસિંગને આપમેળે ગોઠવશે, ઉદાહરણ તરીકે નિયંત્રકોને HTTP વિનંતીઓ, jdbc દ્વારા ડેટાબેઝને વિનંતીઓ, વગેરે.

જાવા માં લૉગીંગ ટ્રેસ કરે છે

ક્યાંક ટોચના સ્તરે, પ્રથમ સ્પાન બનાવવો આવશ્યક છે, આ આપમેળે થઈ શકે છે, ઉદાહરણ તરીકે, જ્યારે વિનંતી પ્રાપ્ત થાય ત્યારે સ્પ્રિંગ કંટ્રોલર દ્વારા અથવા જો કોઈ ન હોય તો મેન્યુઅલી. તે પછી નીચેના સ્કોપ દ્વારા પ્રસારિત થાય છે. જો નીચેની કોઈપણ પદ્ધતિઓ સ્પાન ઉમેરવા માંગે છે, તો તે સ્કોપમાંથી વર્તમાન એક્ટિવસ્પાન લે છે, એક નવો સ્પાન બનાવે છે અને કહે છે કે તેના પિતૃ પરિણામી સક્રિય સ્પાન છે અને નવા સ્પાનને સક્રિય બનાવે છે. બાહ્ય સેવાઓને કૉલ કરતી વખતે, વર્તમાન સક્રિય સ્પાન તેમને પસાર કરવામાં આવે છે, અને તે સેવાઓ આ સ્પાનના સંદર્ભમાં નવા સ્પાન્સ બનાવે છે.
તમામ કામ ટ્રેસર ઇન્સ્ટન્સ દ્વારા થાય છે, જો DI મિકેનિઝમ કામ ન કરતું હોય તો તમે તેને DI મિકેનિઝમ દ્વારા અથવા GlobalTracer.get () વૈશ્વિક ચલ તરીકે મેળવી શકો છો. ડિફૉલ્ટ રૂપે, જો ટ્રેસર શરૂ કરવામાં આવ્યું ન હોય, તો NoopTracer પાછા આવશે જે કંઈ કરતું નથી.
આગળ, વર્તમાન સ્કોપ સ્કોપ મેનેજર દ્વારા ટ્રેસરમાંથી મેળવવામાં આવે છે, નવા સ્પેનના બંધન સાથે વર્તમાનમાંથી એક નવો સ્કોપ બનાવવામાં આવે છે, અને પછી બનાવેલ સ્કોપ બંધ થાય છે, જે બનાવેલ સ્પેનને બંધ કરે છે અને અગાઉના સ્કોપને સક્રિય સ્થિતિમાં પરત કરે છે. સ્કોપ એક થ્રેડ સાથે જોડાયેલો છે, તેથી જ્યારે મલ્ટી-થ્રેડેડ પ્રોગ્રામિંગ હોય, ત્યારે તમારે આ સ્પાનના સંદર્ભમાં અન્ય થ્રેડના સ્કોપને વધુ સક્રિય કરવા માટે, સક્રિય સ્પાનને બીજા થ્રેડમાં સ્થાનાંતરિત કરવાનું ભૂલવું જોઈએ નહીં.

io.opentracing.Tracer tracer = ...; // GlobalTracer.get()

void DoSmth () {
   try (Scope scope = tracer.buildSpan("DoSmth").startActive(true)) {
      ...
   }
}
void DoOther () {
    Span span = tracer.buildSpan("someWork").start();
    try (Scope scope = tracer.scopeManager().activate(span, false)) {
        // Do things.
    } catch(Exception ex) {
        Tags.ERROR.set(span, true);
        span.log(Map.of(Fields.EVENT, "error", Fields.ERROR_OBJECT, ex, Fields.MESSAGE, ex.getMessage()));
    } finally {
        span.finish();
    }
}

void DoAsync () {
    try (Scope scope = tracer.buildSpan("ServiceHandlerSpan").startActive(false)) {
        ...
        final Span span = scope.span();
        doAsyncWork(() -> {
            // STEP 2 ABOVE: reactivate the Span in the callback, passing true to
            // startActive() if/when the Span must be finished.
            try (Scope scope = tracer.scopeManager().activate(span, false)) {
                ...
            }
        });
    }
}

મલ્ટિ-થ્રેડેડ પ્રોગ્રામિંગ માટે, TracedExecutorService અને સમાન રેપર્સ પણ છે જે જ્યારે અસુમેળ કાર્યો શરૂ કરવામાં આવે ત્યારે વર્તમાન ગાળાને આપમેળે થ્રેડ પર ફોરવર્ડ કરે છે:

private ExecutorService executor = new TracedExecutorService(
    Executors.newFixedThreadPool(10), GlobalTracer.get()
);

બાહ્ય http વિનંતીઓ માટે ત્યાં છે TracingHttpClient

HttpClient httpClient = new TracingHttpClientBuilder().build();

સમસ્યાઓનો અમે સામનો કર્યો

• બીન્સ અને ડીઆઈ હંમેશા કામ કરતા નથી જો ટ્રેસરનો ઉપયોગ સેવા અથવા ઘટકમાં ન થાય, તો ઓટોવાયર્ડ ટ્રેસર કદાચ કામ ન કરે અને તમારે GlobalTracer.ge() નો ઉપયોગ કરવો પડશે.
• જો તે ઘટક અથવા સેવા ન હોય, અથવા જો પદ્ધતિ સમાન વર્ગની પડોશી પદ્ધતિમાંથી બોલાવવામાં આવે તો ટીકા કામ કરતી નથી. શું કામ કરે છે તે તપાસવા માટે તમારે સાવચેત રહેવું પડશે અને જો @Traced કામ ન કરે તો મેન્યુઅલ ટ્રેસ બનાવટનો ઉપયોગ કરો. તમે જાવા એનોટેશન માટે વધારાનું કમ્પાઈલર પણ જોડી શકો છો, પછી તે દરેક જગ્યાએ કામ કરવું જોઈએ.
• જૂના સ્પ્રિંગ અને સ્પ્રિંગ બૂટમાં, ઓપનટ્રેઈંગ સ્પ્રિંગ ક્લાઉડ ઓટોકોન્ફિગરેશન ડીઆઈમાં બગ્સને કારણે કામ કરતું નથી, પછી જો તમે ઈચ્છો છો કે સ્પ્રિંગ કમ્પોનન્ટમાંના નિશાન આપોઆપ કામ કરે, તો તમે તેને સાદ્રશ્ય દ્વારા કરી શકો છો. github.com/opentracing-contrib/java-spring-jaeger/blob/master/opentracing-spring-jaeger-starter/src/main/java/io/opentracing/contrib/java/spring/jaeger/starter/JaegerAutoConfiguration.java
• સંસાધનો સાથે પ્રયાસ કરો ગ્રુવીમાં કામ કરતું નથી, તમારે છેલ્લે પ્રયાસ કરવાનો ઉપયોગ કરવો જ જોઇએ.
• દરેક સેવાનું પોતાનું spring.application.name હોવું આવશ્યક છે જેના હેઠળ ટ્રેસ લૉગ કરવામાં આવશે. વેચાણ અને પરીક્ષણ માટે અલગ નામ શું છે, જેથી તેમની સાથે એકસાથે દખલ ન થાય.
• જો તમે ગ્લોબલટ્રેસર અને ટોમકેટનો ઉપયોગ કરો છો, તો આ ટોમકેટમાં ચાલતી બધી સેવાઓ એક જ ગ્લોબલટ્રેસર ધરાવે છે, તેથી તે બધાની સેવાનું નામ સમાન હશે.
• પદ્ધતિમાં ટ્રેસ ઉમેરતી વખતે, તમારે ખાતરી કરવાની જરૂર છે કે તેને લૂપમાં ઘણી વખત બોલાવવામાં ન આવે. બધા કૉલ્સ માટે એક સામાન્ય ટ્રેસ ઉમેરવું જરૂરી છે, જે કામના કુલ સમયની ખાતરી આપે છે. નહિંતર, વધારાનો ભાર બનાવવામાં આવશે.
• એકવાર jaeger-ui માં, મોટી સંખ્યામાં ટ્રેસ માટે ખૂબ મોટી વિનંતીઓ કરવામાં આવી હતી, અને કારણ કે તેઓ પ્રતિસાદની રાહ જોતા ન હતા, તેઓએ તે ફરીથી કર્યું. પરિણામે, જેગર-ક્વેરી ઘણી બધી મેમરી ખાવાનું શરૂ કરે છે અને સ્થિતિસ્થાપકતા ધીમું કરે છે. jaeger-query પુનઃપ્રારંભ કરીને મદદ કરી

સેમ્પલિંગ, સંગ્રહ અને નિશાન જોવા

ત્રણ પ્રકાર છે નમૂનાના નિશાન:

1. Const જે તમામ નિશાન મોકલે છે અને સાચવે છે.
2. સંભવિત જે અમુક આપેલ સંભાવના સાથે ટ્રેસને ફિલ્ટર કરે છે.
3. રેટ લિમિટિંગ જે પ્રતિ સેકન્ડ ટ્રેસની સંખ્યાને મર્યાદિત કરે છે. તમે ક્લાયન્ટ પર, જેગર-એજન્ટ અથવા કલેક્ટર પર આ સેટિંગ્સને ગોઠવી શકો છો. હવે આપણે વેલ્યુએટર સ્ટેકમાં કોન્સ્ટ 1 નો ઉપયોગ કરીએ છીએ, કારણ કે ત્યાં ઘણી બધી વિનંતીઓ નથી, પરંતુ તે ઘણો સમય લે છે. ભવિષ્યમાં, જો આ સિસ્ટમ પર વધુ પડતો ભાર નાખશે, તો તમે તેને મર્યાદિત કરી શકો છો.

જો તમે કેસન્ડ્રાનો ઉપયોગ કરો છો, તો પછી ડિફૉલ્ટ રૂપે તે ફક્ત બે દિવસ માટે ટ્રેસ સ્ટોર કરે છે. અમે ઉપયોગ કરી રહ્યા છીએ સ્થિતિસ્થાપક અને નિશાનો બધા સમય માટે સંગ્રહિત થાય છે અને કાઢી નાખવામાં આવતા નથી. દરેક દિવસ માટે એક અલગ ઇન્ડેક્સ બનાવવામાં આવે છે, ઉદાહરણ તરીકે jaeger-service-2019-03-04. ભવિષ્યમાં, તમારે જૂના નિશાનોની સ્વચાલિત સફાઈને ગોઠવવાની જરૂર છે.

તમને જરૂરી નિશાનો જોવા માટે:

• તે સેવા પસંદ કરો કે જેના દ્વારા તમે ટ્રેસ ફિલ્ટર કરવા માંગો છો, ઉદાહરણ તરીકે, ટોમકેટમાં ચાલી રહેલી સેવા માટે tomcat7-default અને તેનું પોતાનું નામ ન હોઈ શકે.
• પછી ઓપરેશન, સમય અંતરાલ અને ન્યૂનતમ ઑપરેશન સમય પસંદ કરો, ઉદાહરણ તરીકે 10 સેકન્ડથી, માત્ર લાંબા એક્ઝેક્યુશન લેવા માટે.
  
• એક નિશાન પર જાઓ અને જુઓ કે ત્યાં શું ધીમું હતું.
  

ઉપરાંત, જો કોઈ વિનંતી આઈડી જાણીતી હોય, તો તમે ટૅગ શોધ દ્વારા આ આઈડી દ્વારા ટ્રેસ શોધી શકો છો, જો આ આઈડી ટ્રેસ સ્પાનમાં લોગ થયેલ હોય.

Документация

• ઓપનટ્રેસિંગ દસ્તાવેજીકરણ opentracing.io/docs/overview/what-is-tracing
• jaeger દસ્તાવેજીકરણ www.jaegertracing.io/docs/1.10
• જેગર જાવા કનેક્શન github.com/jaegertracing/jaeger-client-java
• વસંત ઓપન ટ્રેસિંગ કનેક્શન
  github.com/jaegertracing/jaeger-client-java
  github.com/opentracing-contrib/java-spring-cloud

લેખ

• habr.com/ru/company/carprice/blog/340946 વાસ્તવિક PHP અને ગોલાંગ પ્રોજેક્ટમાં Jaeger Opentracing અને Microservices
• www.uber.com/distributed-tracing ઉબેર એન્જિનિયરિંગમાં વિતરિત ટ્રેસિંગ વિકસિત કરવું
• opentracing.io/guides/java
• medium.com/jaegertracing/running-jaeger-agent-on-bare-metal-d1fc47d31fab એકદમ મેટલ પર જેગર એજન્ટ ચલાવી રહ્યું છે

વિડિઓ

• www.youtube.com/watch?v=qg0ENOdP1Lo લાઈટનિંગ-ફાસ્ટ યુઝર ક્વેરી પહોંચાડવા માટે અમે જેગર અને પ્રોમિથિયસનો ઉપયોગ કેવી રીતે કર્યો - બ્રાયન બોરહેમ
• www.youtube.com/watch?v=WRntQsUajow પ્રસ્તાવના: જેગર - યુરી શ્કુરો, ઉબેર અને પાવોલ લોફે, રેડ હેટ
• www.youtube.com/watch?v=fsHb0qK37bc સેર્ગેઈ યાકોવલેવ, "એક મોટી જીતની નાની વાર્તા: ઓપનટ્રેસિંગ, AWS અને જેગર"

સોર્સ: www.habr.com