சர்வீஸ் டிரேசிங், ஓபன் ட்ரேசிங் மற்றும் ஜெகர்

எங்கள் திட்டங்களில் மைக்ரோ சர்வீஸ் கட்டமைப்பைப் பயன்படுத்துகிறோம். செயல்திறன் தடைகள் ஏற்படும் போது, ​​பதிவுகளை கண்காணிக்கவும் பாகுபடுத்தவும் நிறைய நேரம் செலவிடப்படுகிறது. ஒரு பதிவுக் கோப்பில் தனிப்பட்ட செயல்பாடுகளின் நேரத்தைப் பதிவு செய்யும் போது, ​​வெவ்வேறு சேவைகளில் செயல்களின் வரிசை அல்லது ஒரு செயல்பாட்டின் நேர மாற்றத்தைக் கண்காணிப்பது, இந்த செயல்பாடுகளின் தூண்டுதலுக்கு என்ன வழிவகுத்தது என்பதைப் புரிந்துகொள்வது பொதுவாக கடினம்.

உடல் உழைப்பைக் குறைக்க, டிரேசிங் கருவிகளில் ஒன்றைப் பயன்படுத்த முடிவு செய்தோம். எப்படி, ஏன் நீங்கள் ட்ரேசிங்கைப் பயன்படுத்தலாம் மற்றும் நாங்கள் அதை எப்படிச் செய்தோம் என்பது பற்றி, இந்த கட்டுரையில் விவாதிக்கப்படும்.

டிரேசிங் மூலம் என்னென்ன பிரச்சனைகளை தீர்க்க முடியும்

1. ஒரே சேவையில் மற்றும் அனைத்துப் பங்குபெறும் சேவைகளுக்கு இடையேயான முழு செயலாக்க மரத்திலும் செயல்திறன் இடையூறுகளைக் கண்டறியவும். உதாரணத்திற்கு:
   • சேவைகளுக்கு இடையே பல குறுகிய தொடர்ச்சியான அழைப்புகள், எடுத்துக்காட்டாக, புவிசார் குறியீடு அல்லது தரவுத்தளத்திற்கு.
   • நெட்வொர்க் இடமாற்றங்கள் அல்லது வட்டு வாசிப்புகள் போன்ற நீண்ட I/O காத்திருக்கிறது.
   • நீண்ட தரவு பாகுபடுத்துதல்.
   • cpu தேவைப்படும் நீண்ட செயல்பாடுகள்.
   • இறுதி முடிவைப் பெறத் தேவையில்லாத குறியீட்டின் பிரிவுகள் அகற்றப்படலாம் அல்லது தாமதப்படுத்தலாம்.
2. எந்த வரிசையில் என்ன அழைக்கப்படுகிறது மற்றும் அறுவை சிகிச்சை செய்யும்போது என்ன நடக்கும் என்பதை தெளிவாக புரிந்து கொள்ளுங்கள்.
   
   எடுத்துக்காட்டாக, WS சேவைக்கு கோரிக்கை வந்தது -> WS சேவை R சேவை மூலம் தரவைச் சேர்த்தது -> பின்னர் V சேவைக்கு ஒரு கோரிக்கையை அனுப்பியது -> V சேவை R இலிருந்து நிறைய தரவை ஏற்றியது. சேவை -> P சேவைக்குச் சென்றது -> P சேவை மீண்டும் சேவைக்கு சென்றது -> சேவை V முடிவைப் புறக்கணித்து, சேவை J -> க்குச் சென்றது, அதன் பிறகுதான் சேவை WS க்கு பதிலைத் திருப்பி அனுப்பியது. பின்னணி.
   முழு செயல்முறைக்கும் இதுபோன்ற தடயங்கள் அல்லது விரிவான ஆவணங்கள் இல்லாமல், முதல் முறையாக குறியீட்டைப் பார்க்கும்போது என்ன நடக்கிறது என்பதைப் புரிந்துகொள்வது மிகவும் கடினம், மேலும் குறியீடு வெவ்வேறு சேவைகளில் சிதறி, பின் மற்றும் இடைமுகங்களின் கொத்துகளுக்குப் பின்னால் மறைக்கப்பட்டுள்ளது.
3. அடுத்தடுத்த ஒத்திவைக்கப்பட்ட பகுப்பாய்விற்காக மரணதண்டனை மரம் பற்றிய தகவல் சேகரிப்பு. செயல்பாட்டின் ஒவ்வொரு கட்டத்திலும், இந்த கட்டத்தில் கிடைக்கும் ட்ரேஸில் தகவலைச் சேர்க்கலாம், பின்னர் இதேபோன்ற சூழ்நிலைக்கு என்ன உள்ளீட்டு தரவு வழிவகுத்தது என்பதைக் கண்டறியலாம். உதாரணத்திற்கு:
   • பயனர் ஐடி
   • உரிமைகள்
   • தேர்ந்தெடுக்கப்பட்ட முறையின் வகை
   • பதிவு அல்லது செயல்படுத்துவதில் பிழை
4. தடயங்களை அளவீடுகளின் துணைக்குழுவாக மாற்றுதல் மற்றும் ஏற்கனவே அளவீடுகளின் வடிவத்தில் மேலும் பகுப்பாய்வு.

என்ன சுவடு பதிவு செய்யலாம். இடைவெளி

ட்ரேஸ் செய்வதில் ஒரு ஸ்பான் என்ற கருத்து உள்ளது, இது கன்சோலுக்கு ஒரு பதிவின் அனலாக் ஆகும். ஸ்பா கொண்டுள்ளது:

• பெயர், பொதுவாக செயல்படுத்தப்பட்ட முறையின் பெயர்
• ஸ்பான் உருவாக்கப்பட்ட சேவையின் பெயர்
• சொந்த தனிப்பட்ட ஐடி
• ஒரு விசை/மதிப்பு வடிவத்தில் சில வகையான மெட்டா தகவல்கள் அதில் உள்நுழைந்துள்ளன. எடுத்துக்காட்டாக, முறை அளவுருக்கள் அல்லது முறை பிழையுடன் முடிந்தது அல்லது இல்லை
• இந்த இடைவெளிக்கான தொடக்க மற்றும் இறுதி நேரங்கள்
• பெற்றோர் இடைவெளி ஐடி

ஒவ்வொரு இடைவெளியும் அதன் செயலாக்கத்தை முடித்தவுடன் தரவுத்தளத்தில் பின்னர் மதிப்பாய்வு செய்ய ஸ்பான் சேகரிப்பாளருக்கு அனுப்பப்படும். எதிர்காலத்தில், பெற்றோர் ஐடி மூலம் இணைப்பதன் மூலம் அனைத்து இடைவெளிகளிலும் ஒரு மரத்தை உருவாக்கலாம். பகுப்பாய்வு செய்யும் போது, ​​எடுத்துக்காட்டாக, சில சேவைகளில் உள்ள அனைத்து இடைவெளிகளையும் நீங்கள் காணலாம். மேலும், ஒரு குறிப்பிட்ட இடைவெளிக்குச் செல்வதன் மூலம், இந்த இடைவெளிக்கு மேலேயும் கீழேயும் உள்ள முழு மரத்தையும் பார்க்கவும்.

ஓபன்ட்ரேஸ், ஜாகர் மற்றும் எங்கள் திட்டங்களுக்கு அதை எவ்வாறு செயல்படுத்தினோம்

ஒரு பொதுவான தரநிலை உள்ளது திறந்தவெளி, எந்த மொழியிலும் குறிப்பிட்ட செயலாக்கத்துடன் இணைக்கப்படாமல், எப்படி, எதைச் சேகரிக்க வேண்டும் என்பதை விவரிக்கிறது. எடுத்துக்காட்டாக, ஜாவாவில், தடயங்களுடனான அனைத்து வேலைகளும் பொதுவான Opentrace API மூலம் மேற்கொள்ளப்படுகின்றன, எடுத்துக்காட்டாக, Jaeger அல்லது எதுவும் செய்யாத ஒரு வெற்று இயல்புநிலை செயலாக்கத்தை மறைக்க முடியாது.
பயன்படுத்தி வருகிறோம் ஜேகர் Opentrace இன் செயலாக்கமாக. இது பல கூறுகளைக் கொண்டுள்ளது:

• Jaeger-agent என்பது ஒரு உள்ளூர் முகவர், இது வழக்கமாக ஒவ்வொரு கணினியிலும் நிறுவப்படும் மற்றும் சேவைகள் உள்ளூர் இயல்புநிலை போர்ட்டில் உள்நுழைந்திருக்கும். முகவர் இல்லை என்றால், இந்த கணினியில் உள்ள அனைத்து சேவைகளின் தடயங்களும் பொதுவாக முடக்கப்படும்
• ஜெய்கர்-சேகரிப்பான் - அனைத்து முகவர்களும் சேகரிக்கப்பட்ட தடயங்களை அதற்கு அனுப்புகிறார்கள், மேலும் அது அவற்றை தேர்ந்தெடுத்த தரவுத்தளத்தில் வைக்கிறது.
• தரவுத்தளமானது அவர்களின் விருப்பமான கசாண்ட்ரா ஆகும், ஆனால் நாங்கள் மீள் தேடலைப் பயன்படுத்துகிறோம், மேலும் இரண்டு தரவுத்தளங்களுக்கான செயலாக்கங்கள் மற்றும் வட்டில் எதையும் சேமிக்காத நினைவகத்தில் செயலாக்கம் உள்ளது.
• Jaeger-query என்பது தரவுத்தளத்திற்குச் சென்று ஏற்கனவே சேகரிக்கப்பட்ட தடயங்களை பகுப்பாய்வுக்காக வழங்கும் ஒரு சேவையாகும்
• Jaeger-ui என்பது தடயங்களைத் தேடுவதற்கும் பார்ப்பதற்கும் ஒரு இணைய இடைமுகம், இது jaeger-queryக்கு செல்கிறது.

குறிப்பிட்ட மொழிகளுக்கான ஓப்பன்ட்ரேஸ் ஜெகரின் செயலாக்கம் என்று ஒரு தனி கூறு அழைக்கப்படலாம், இதன் மூலம் ஸ்பான்கள் ஜெகர்-ஏஜெண்டிற்கு அனுப்பப்படுகின்றன.
ஜாவாவில் ஜாகரை இணைக்கிறது io.opentracing.Tracer இடைமுகத்தை செயல்படுத்துவதற்கு கீழே வருகிறது, அதன் மூலம் அனைத்து தடயங்களும் உண்மையான முகவருக்கு பறக்கும்.

மேலும் வசந்த கூறுக்காக, நீங்கள் இணைக்க முடியும் opentracing-spring-Cloud-starter மற்றும் ஜெகரிடமிருந்து செயல்படுத்தல் opentracing-spring-jaeger-Cloud-starter இந்த கூறுகள் வழியாக செல்லும் அனைத்திற்கும் டிரேஸிங்கை தானாகவே கட்டமைக்கும், எடுத்துக்காட்டாக, கட்டுப்படுத்திகளுக்கான http கோரிக்கைகள், jdbc மூலம் தரவுத்தளத்திற்கான கோரிக்கைகள் போன்றவை.

ஜாவாவில் உள்நுழைந்ததற்கான தடயங்கள்

எங்காவது மேல் மட்டத்தில், முதல் ஸ்பான் உருவாக்கப்பட வேண்டும், இது தானாகவே செய்யப்படலாம், எடுத்துக்காட்டாக, ஒரு கோரிக்கையைப் பெறும்போது ஸ்பிரிங் கன்ட்ரோலரால் அல்லது எதுவும் இல்லை என்றால் கைமுறையாக. பின்னர் அது கீழே உள்ள ஸ்கோப் மூலம் கடத்தப்படுகிறது. கீழே உள்ள ஏதேனும் முறைகள் ஸ்பானைச் சேர்க்க விரும்பினால், அது தற்போதைய ஆக்டிவ்ஸ்பானை ஸ்கோப்பில் இருந்து எடுத்து, புதிய ஸ்பானை உருவாக்கி, அதன் பெற்றோர் விளைவான ஆக்டிவ்ஸ்பான் எனக் கூறி, புதிய ஸ்பானைச் செயலில் ஆக்குகிறது. வெளிப்புற சேவைகளை அழைக்கும் போது, ​​தற்போதைய செயலில் உள்ள இடைவெளி அவர்களுக்கு அனுப்பப்படுகிறது, மேலும் அந்த சேவைகள் இந்த இடைவெளியைக் குறிக்கும் வகையில் புதிய இடைவெளிகளை உருவாக்குகின்றன.
அனைத்து வேலைகளும் ட்ரேசர் நிகழ்வின் வழியாகச் செல்கின்றன, DI மெக்கானிசம் அல்லது GlobalTracer.get () மூலம் DI மெக்கானிசம் வேலை செய்யவில்லை என்றால், உலகளாவிய மாறியாகப் பெறலாம். முன்னிருப்பாக, ட்ரேசர் துவக்கப்படவில்லை எனில், 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();

நாங்கள் எதிர்கொண்ட பிரச்சனைகள்

• ஒரு சேவை அல்லது கூறுகளில் ட்ரேசர் பயன்படுத்தப்படாவிட்டால் பீன்ஸ் மற்றும் DI எப்போதும் வேலை செய்யாது தானியங்கி ட்ரேசர் வேலை செய்யாமல் போகலாம் மற்றும் நீங்கள் GlobalTracer.get() ஐப் பயன்படுத்த வேண்டும்.
• இது ஒரு கூறு அல்லது சேவையாக இல்லாவிட்டால் அல்லது அதே வகுப்பின் அண்டை முறையிலிருந்து முறை அழைக்கப்பட்டால் சிறுகுறிப்புகள் வேலை செய்யாது. என்ன வேலை செய்கிறது என்பதைச் சரிபார்த்து, @Traced வேலை செய்யவில்லை என்றால், கைமுறையாக டிரேஸ் உருவாக்கத்தைப் பயன்படுத்தவும். ஜாவா சிறுகுறிப்புகளுக்கான கூடுதல் கம்பைலரை நீங்கள் இணைக்கலாம், பின்னர் அவை எல்லா இடங்களிலும் வேலை செய்ய வேண்டும்.
• பழைய ஸ்பிரிங் மற்றும் ஸ்பிரிங் பூட்டில், DIயில் உள்ள பிழைகள் காரணமாக opentraing spring cloud autoconfiguration வேலை செய்யாது, பிறகு ஸ்பிரிங் கூறுகளில் உள்ள தடயங்கள் தானாக வேலை செய்ய வேண்டுமெனில், நீங்கள் அதை ஒப்புமை மூலம் செய்யலாம் 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 இருக்க வேண்டும், அதன் கீழ் தடயங்கள் பதிவு செய்யப்படும். விற்பனை மற்றும் சோதனைக்கு ஒரு தனி பெயர் என்ன, அதனால் அவர்கள் ஒன்றாக தலையிட முடியாது.
• நீங்கள் GlobalTracer மற்றும் tomcat ஐப் பயன்படுத்தினால், இந்த tomcat இல் இயங்கும் அனைத்து சேவைகளுக்கும் GlobalTracer ஒன்று இருக்கும், எனவே அவை அனைத்தும் ஒரே சேவைப் பெயரைக் கொண்டிருக்கும்.
• ஒரு முறைக்கு தடயங்களைச் சேர்க்கும்போது, ​​​​அது ஒரு சுழற்சியில் பல முறை அழைக்கப்படவில்லை என்பதை உறுதிப்படுத்த வேண்டும். அனைத்து அழைப்புகளுக்கும் ஒரு பொதுவான தடத்தை சேர்க்க வேண்டியது அவசியம், இது மொத்த வேலை நேரத்திற்கு உத்தரவாதம் அளிக்கிறது. இல்லையெனில், அதிகப்படியான சுமை உருவாக்கப்படும்.
• ஒருமுறை jaeger-ui இல், அதிக எண்ணிக்கையிலான தடயங்களுக்கு மிகப் பெரிய கோரிக்கைகள் வைக்கப்பட்டன, மேலும் அவர்கள் பதிலுக்காக காத்திருக்காததால், அவர்கள் அதை மீண்டும் செய்தனர். இதன் விளைவாக, ஜெகர்-கேரி நிறைய நினைவகத்தை உண்ணத் தொடங்கினார் மற்றும் மீள்தன்மையை மெதுவாக்கினார். jaeger-query ஐ மறுதொடக்கம் செய்வதன் மூலம் உதவியது

தடயங்களை மாதிரி எடுத்தல், சேமித்தல் மற்றும் பார்ப்பது

மூன்று வகைகள் உள்ளன மாதிரி தடயங்கள்:

1. அனைத்து தடயங்களையும் அனுப்பும் மற்றும் சேமிக்கும் கான்ஸ்ட்.
2. சில கொடுக்கப்பட்ட நிகழ்தகவுடன் தடயங்களை வடிகட்டக்கூடிய நிகழ்தகவு.
3. ஒரு வினாடிக்கு தடயங்களின் எண்ணிக்கையை வரம்புபடுத்தும் மதிப்பீடு. இந்த அமைப்புகளை கிளையண்டில், ஜெகர்-ஏஜெண்டில் அல்லது சேகரிப்பாளரில் உள்ளமைக்கலாம். இப்போது மதிப்பீட்டாளர் அடுக்கில் const 1 ஐப் பயன்படுத்துகிறோம், ஏனெனில் அதிக கோரிக்கைகள் இல்லை, ஆனால் அவை நீண்ட நேரம் எடுக்கும். எதிர்காலத்தில், இது கணினியில் அதிக சுமையை ஏற்படுத்தினால், நீங்கள் அதை கட்டுப்படுத்தலாம்.

நீங்கள் கசாண்ட்ராவைப் பயன்படுத்தினால், இயல்பாக அது இரண்டு நாட்களுக்கு மட்டுமே தடயங்களைச் சேமிக்கும். பயன்படுத்தி வருகிறோம் elasticsearch மற்றும் தடயங்கள் எல்லா நேரத்திலும் சேமிக்கப்படும் மற்றும் நீக்கப்படாது. ஒவ்வொரு நாளுக்கும் தனித்தனி குறியீடு உருவாக்கப்படுகிறது, உதாரணமாக jaeger-service-2019-03-04. எதிர்காலத்தில், பழைய தடயங்களை தானாக சுத்தம் செய்வதை நீங்கள் கட்டமைக்க வேண்டும்.

தடயங்களைக் காண உங்களுக்குத் தேவை:

• நீங்கள் தடயங்களை வடிகட்ட விரும்பும் சேவையைத் தேர்ந்தெடுக்கவும், எடுத்துக்காட்டாக, tomcat7-இயல்புநிலை tomcat இல் இயங்கும் மற்றும் அதன் சொந்த பெயரைக் கொண்டிருக்க முடியாது.
• பின்னர் செயல்பாடு, நேர இடைவெளி மற்றும் குறைந்தபட்ச இயக்க நேரம் ஆகியவற்றைத் தேர்ந்தெடுக்கவும், உதாரணமாக 10 வினாடிகளில் இருந்து, நீண்ட மரணதண்டனைகளை மட்டுமே எடுக்கவும்.
  
• தடயங்களில் ஒன்றிற்குச் சென்று, அங்கு என்ன வேகம் குறைகிறது என்று பாருங்கள்.
  

மேலும், சில கோரிக்கை ஐடி தெரிந்தால், இந்த ஐடி ட்ரேஸ் ஸ்பேனில் உள்நுழைந்திருந்தால், டேக் தேடலின் மூலம் இந்த ஐடியின் ட்ரேஸைக் காணலாம்.

ஆவணங்கள்

• திறந்தவெளி ஆவணங்கள் opentracing.io/docs/overview/what-is-tracing
• ஜெகர் ஆவணங்கள் 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 மற்றும் Golang திட்டத்தில் 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 செர்ஜி ஐகோவ்லேவ், "ஒரு பெரிய வெற்றியின் சிறிய கதை: ஓபன் டிரேசிங், ஏடபிள்யூஎஸ் மற்றும் ஜெகர்"

ஆதாரம்: www.habr.com