സർവീസ് ട്രേസിംഗ്, ഓപ്പൺ ട്രേസിംഗ്, ജെയ്ഗർ

ഞങ്ങളുടെ പ്രോജക്ടുകളിൽ ഞങ്ങൾ മൈക്രോ സർവീസ് ആർക്കിടെക്ചർ ഉപയോഗിക്കുന്നു. പ്രകടന തടസ്സങ്ങൾ ഉണ്ടാകുമ്പോൾ, ലോഗുകൾ നിരീക്ഷിക്കുന്നതിനും പാഴ്‌സിംഗ് ചെയ്യുന്നതിനും ധാരാളം സമയം ചെലവഴിക്കുന്നു. ഒരു ലോഗ് ഫയലിലേക്ക് വ്യക്തിഗത പ്രവർത്തനങ്ങളുടെ സമയക്രമം ലോഗിൻ ചെയ്യുമ്പോൾ, ഈ പ്രവർത്തനങ്ങളുടെ കോളിംഗിലേക്ക് നയിച്ചത് എന്താണെന്ന് മനസിലാക്കാൻ സാധാരണയായി ബുദ്ധിമുട്ടാണ്, വ്യത്യസ്ത സേവനങ്ങളിലെ പ്രവർത്തനങ്ങളുടെ ക്രമം അല്ലെങ്കിൽ ഒരു പ്രവർത്തനത്തിന്റെ സമയ ഷിഫ്റ്റ് ട്രാക്ക് ചെയ്യുക.

സ്വമേധയാലുള്ള അധ്വാനം കുറയ്ക്കുന്നതിന്, ട്രെയ്‌സിംഗ് ടൂളുകളിൽ ഒന്ന് ഉപയോഗിക്കാൻ ഞങ്ങൾ തീരുമാനിച്ചു. എങ്ങനെ, എന്തിനുവേണ്ടി നിങ്ങൾക്ക് ട്രെയ്‌സിംഗ് ഉപയോഗിക്കാം, ഞങ്ങൾ അത് എങ്ങനെ ചെയ്തു എന്നതിനെ ഈ ലേഖനത്തിൽ ചർച്ച ചെയ്യും.

ട്രേസിംഗ് ഉപയോഗിച്ച് എന്ത് പ്രശ്നങ്ങൾ പരിഹരിക്കാനാകും?

1. ഒരു സേവനത്തിനുള്ളിലും പങ്കെടുക്കുന്ന എല്ലാ സേവനങ്ങൾക്കിടയിലും മുഴുവൻ എക്സിക്യൂഷൻ ട്രീയിലും പ്രകടന തടസ്സങ്ങൾ കണ്ടെത്തുക. ഉദാഹരണത്തിന്:
   • സേവനങ്ങൾക്കിടയിൽ നിരവധി ചെറിയ തുടർച്ചയായ കോളുകൾ, ഉദാഹരണത്തിന്, ജിയോകോഡിംഗിലേക്കോ ഡാറ്റാബേസിലേക്കോ.
   • ഒരു നെറ്റ്‌വർക്കിലൂടെ ഡാറ്റ കൈമാറ്റം ചെയ്യുന്നതോ ഡിസ്കിൽ നിന്ന് വായിക്കുന്നതോ പോലുള്ള നീണ്ട I/O കാത്തിരിപ്പുകൾ.
   • ദൈർഘ്യമേറിയ ഡാറ്റ പാഴ്‌സിംഗ്.
   • സിപിയു ആവശ്യമുള്ള ദൈർഘ്യമേറിയ പ്രവർത്തനങ്ങൾ.
   • അന്തിമ ഫലം ലഭിക്കുന്നതിന് ആവശ്യമില്ലാത്തതും നീക്കം ചെയ്യാനോ മാറ്റിവയ്ക്കാനോ കഴിയുന്ന കോഡിന്റെ വിഭാഗങ്ങൾ.
2. ഏത് ക്രമത്തിലാണ് എന്താണ് വിളിക്കുന്നത്, ഓപ്പറേഷൻ നടത്തുമ്പോൾ എന്താണ് സംഭവിക്കുന്നതെന്ന് വ്യക്തമായി മനസ്സിലാക്കുക.
   
   ഉദാഹരണത്തിന്, WS സേവനത്തിലേക്ക് അഭ്യർത്ഥന വന്നതായി കാണാൻ കഴിയും -> WS സേവനം R സേവനത്തിലൂടെ ഡാറ്റ സപ്ലിമെന്റ് ചെയ്തു -> തുടർന്ന് V സേവനത്തിലേക്ക് അഭ്യർത്ഥന അയച്ചു -> V സേവനം ഇതിൽ നിന്ന് ധാരാളം ഡാറ്റ ഡൗൺലോഡ് ചെയ്തു. R സേവനം -> P സേവനത്തിലേക്ക് പോയി -> P സേവനം വീണ്ടും സേവനത്തിലേക്ക് പോയി -> സേവനം V ഫലം അവഗണിച്ച് J -> എന്ന സേവനത്തിലേക്ക് പോയി, അതിനുശേഷം മാത്രമേ മറ്റെന്തെങ്കിലും കണക്കാക്കുന്നത് തുടരുന്നതിനിടയിൽ സേവന WS-ലേക്ക് ഉത്തരം തിരികെ നൽകി. പശ്ചാത്തലം.
   മുഴുവൻ പ്രക്രിയയ്‌ക്കും അത്തരം ഒരു ട്രെയ്‌സോ വിശദമായ ഡോക്യുമെന്റേഷനോ ഇല്ലാതെ, ആദ്യമായി കോഡ് നോക്കിയതിന് ശേഷം എന്താണ് സംഭവിക്കുന്നതെന്ന് മനസിലാക്കാൻ വളരെ ബുദ്ധിമുട്ടാണ്, കൂടാതെ കോഡ് വിവിധ സേവനങ്ങളിൽ ചിതറിക്കിടക്കുകയും ഒരു കൂട്ടം ബീൻസുകളുടെയും ഇന്റർഫേസുകളുടെയും പിന്നിൽ മറയ്ക്കുകയും ചെയ്യുന്നു.
3. തുടർന്നുള്ള മാറ്റിവെച്ച വിശകലനത്തിനായി എക്സിക്യൂഷൻ ട്രീയെക്കുറിച്ചുള്ള വിവരങ്ങളുടെ ശേഖരണം. നിർവ്വഹണത്തിന്റെ ഓരോ ഘട്ടത്തിലും, ഈ ഘട്ടത്തിൽ ലഭ്യമായ വിവരങ്ങൾ നിങ്ങൾക്ക് ട്രെയ്സിലേക്ക് ചേർക്കാം, തുടർന്ന് അത്തരം ഒരു സാഹചര്യത്തിലേക്ക് നയിച്ച ഇൻപുട്ട് ഡാറ്റ എന്താണെന്ന് കണ്ടെത്താനാകും. ഉദാഹരണത്തിന്:
   • ഉപയോക്തൃ ഐഡി
   • അവകാശങ്ങൾ
   • തിരഞ്ഞെടുത്ത രീതിയുടെ തരം
   • ലോഗ് അല്ലെങ്കിൽ എക്സിക്യൂഷൻ പിശക്
4. ട്രെയ്‌സുകളെ മെട്രിക്‌സിന്റെ ഉപവിഭാഗമാക്കി മാറ്റുകയും മെട്രിക്‌സിന്റെ രൂപത്തിൽ കൂടുതൽ വിശകലനം നടത്തുകയും ചെയ്യുന്നു.

എന്ത് ട്രെയ്‌സിംഗ് ലോഗ് ചെയ്യാൻ കഴിയും. സ്പാൻ

ട്രെയ്‌സിംഗിൽ സ്പാൻ എന്ന ആശയം ഉണ്ട്, ഇത് കൺസോളിലേക്കുള്ള ഒരു ലോഗിന്റെ അനലോഗ് ആണ്. സ്പാൻ ഉണ്ട്:

• പേര്, സാധാരണയായി എക്സിക്യൂട്ട് ചെയ്ത രീതിയുടെ പേര്
• സ്പാൻ സൃഷ്ടിച്ച സേവനത്തിന്റെ പേര്
• സ്വന്തം അദ്വിതീയ ഐഡി
• അതിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന കീ/മൂല്യത്തിന്റെ രൂപത്തിലുള്ള ചില മെറ്റാ വിവരങ്ങൾ. ഉദാഹരണത്തിന്, രീതി പാരാമീറ്ററുകൾ അല്ലെങ്കിൽ രീതി ഒരു പിശകിൽ അവസാനിച്ചോ ഇല്ലയോ
• ഈ സ്പാൻ എക്സിക്യൂഷന്റെ ആരംഭ സമയവും അവസാന സമയവും
• പേരന്റ് സ്പാൻ ഐഡി

ഓരോ സ്പാനും അതിന്റെ എക്സിക്യൂഷൻ പൂർത്തിയാക്കിയ ഉടൻ തന്നെ പിന്നീട് കാണുന്നതിനായി ഡാറ്റാബേസിൽ സേവ് ചെയ്യുന്നതിനായി സ്പാൻ കളക്ടറിലേക്ക് അയയ്ക്കുന്നു. ഭാവിയിൽ, പാരന്റ് ഐഡി ഉപയോഗിച്ച് അവയെ ബന്ധിപ്പിച്ച് നിങ്ങൾക്ക് എല്ലാ സ്പാനുകളുടെയും ഒരു ട്രീ നിർമ്മിക്കാൻ കഴിയും. വിശകലനം ചെയ്യുമ്പോൾ, നിങ്ങൾക്ക് കണ്ടെത്താനാകും, ഉദാഹരണത്തിന്, കുറച്ച് സമയമെടുത്ത ചില സേവനങ്ങളിലെ എല്ലാ സ്പാനുകളും. തുടർന്ന്, ഒരു നിർദ്ദിഷ്ട സ്പാനിലേക്ക് പോകുമ്പോൾ, ഈ സ്പാനിന് മുകളിലും താഴെയുമുള്ള മുഴുവൻ വൃക്ഷവും കാണുക.

ഓപ്പൺട്രേസ്, ജാഗർ എന്നിവയും ഞങ്ങളുടെ പ്രോജക്‌റ്റുകൾക്കായി ഞങ്ങൾ അത് എങ്ങനെ നടപ്പിലാക്കി

ഒരു പൊതു മാനദണ്ഡമുണ്ട് ഓപ്പൺട്രേസ്, ഏത് ഭാഷയിലും ഒരു നിർദ്ദിഷ്‌ട നടപ്പാക്കലുമായി ബന്ധിപ്പിക്കാതെ, എങ്ങനെ, എന്തൊക്കെ ശേഖരിക്കണം എന്ന് വിവരിക്കുന്നു. ഉദാഹരണത്തിന്, ജാവയിൽ, ട്രെയ്‌സുകളുള്ള എല്ലാ പ്രവർത്തനങ്ങളും പൊതുവായ ഓപ്പൺട്രേസ് എപിഐ വഴിയാണ് നടത്തുന്നത്, കൂടാതെ അതിന്റെ അടിയിൽ മറയ്ക്കാൻ കഴിയും, ഉദാഹരണത്തിന്, ജെയ്‌ഗർ അല്ലെങ്കിൽ ഒന്നും ചെയ്യാത്ത ഒരു ശൂന്യമായ ഡിഫോൾട്ട് നടപ്പിലാക്കൽ.
ഞങ്ങൾ ഉപയോഗിക്കുന്നു ജെയ്‌ഗർ ഓപ്പൺട്രേസിന്റെ ഒരു നടപ്പാക്കലായി. ഇതിൽ നിരവധി ഘടകങ്ങൾ അടങ്ങിയിരിക്കുന്നു:

• ജെയ്ഗർ-ഏജന്റ് എന്നത് സാധാരണയായി ഓരോ മെഷീനിലും ഇൻസ്റ്റാൾ ചെയ്യപ്പെടുന്ന ഒരു പ്രാദേശിക ഏജന്റാണ്, കൂടാതെ പ്രാദേശിക ഡിഫോൾട്ട് പോർട്ടിൽ സേവനങ്ങൾ ലോഗിൻ ചെയ്യപ്പെടുകയും ചെയ്യുന്നു. ഏജന്റ് ഇല്ലെങ്കിൽ, ഈ മെഷീനിലെ എല്ലാ സേവനങ്ങളുടെയും ട്രെയ്‌സുകൾ സാധാരണയായി ഓഫാകും
• ജെയ്‌ഗർ-കളക്ടർ - എല്ലാ ഏജന്റുമാരും അതിലേക്ക് ശേഖരിച്ച ട്രെയ്‌സുകൾ അയയ്‌ക്കുകയും അത് തിരഞ്ഞെടുത്ത ഡാറ്റാബേസിൽ ഇടുകയും ചെയ്യുന്നു.
• ഡാറ്റാബേസ് - അവർ ഇഷ്ടപ്പെടുന്നത് കസാന്ദ്രയാണ്, പക്ഷേ ഞങ്ങൾ ഇലാസ്റ്റിക് സെർച്ച് ഉപയോഗിക്കുന്നു, മറ്റ് രണ്ട് ഡാറ്റാബേസുകൾക്കായി നടപ്പാക്കലുകളും ഡിസ്കിലേക്ക് ഒന്നും സംരക്ഷിക്കാത്ത ഇൻ-മെമ്മറി ഇംപ്ലിമെന്റേഷനും ഉണ്ട്.
• Jaeger-query എന്നത് ഡാറ്റാബേസിലേക്ക് പോകുകയും വിശകലനത്തിനായി ഇതിനകം ശേഖരിച്ച ട്രെയ്‌സുകൾ നൽകുകയും ചെയ്യുന്ന ഒരു സേവനമാണ്
• ട്രെയ്‌സുകൾ തിരയുന്നതിനും കാണുന്നതിനുമുള്ള ഒരു വെബ് ഇന്റർഫേസാണ് ജെയ്ഗർ-യുഐ, ഇത് ജെയ്ഗർ-ക്വറിയിൽ പ്രവർത്തിക്കുന്നു

ഒരു പ്രത്യേക ഘടകത്തെ നിർദ്ദിഷ്ട ഭാഷകൾക്കുള്ള ഓപ്പൺട്രേസ് ജെയ്ഗർ നടപ്പിലാക്കൽ എന്ന് വിളിക്കാം, അതിലൂടെ സ്പാനുകൾ ജെയ്ഗർ-ഏജന്റിലേക്ക് അയയ്ക്കുന്നു.
ജാവയിൽ ജാഗറിനെ ബന്ധിപ്പിക്കുന്നു io.opentracing.Tracer ഇന്റർഫേസ് നടപ്പിലാക്കുന്നതിലേക്ക് വരുന്നു, അതിനുശേഷം അതിലൂടെയുള്ള എല്ലാ ട്രെയ്‌സുകളും യഥാർത്ഥ ഏജന്റിലേക്ക് പറക്കും.

നിങ്ങൾക്ക് സ്പ്രിംഗ് ഘടകങ്ങളും ബന്ധിപ്പിക്കാൻ കഴിയും ഓപ്പൺട്രേസിംഗ്-സ്പ്രിംഗ്-ക്ലൗഡ്-സ്റ്റാർട്ടർ ജെയ്ഗറിൽ നിന്ന് നടപ്പാക്കലും opentracing-spring-jaeger-Cloud-starter ഇത് ഈ ഘടകങ്ങളിലൂടെ കടന്നുപോകുന്ന എല്ലാത്തിനും സ്വയമേവ ട്രെയ്‌സിംഗ് കോൺഫിഗർ ചെയ്യും, ഉദാഹരണത്തിന് കൺട്രോളറുകളിലേക്കുള്ള 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.get() ഉപയോഗിക്കേണ്ടിവരും.
• ഇത് ഒരു ഘടകമോ സേവനമോ അല്ലെങ്കിലോ അതേ ക്ലാസിലെ അയൽപക്ക രീതിയിൽ നിന്നാണ് മെത്തേഡ് കോൾ വരുന്നതെങ്കിലോ വ്യാഖ്യാനങ്ങൾ പ്രവർത്തിക്കില്ല. നിങ്ങൾ ശ്രദ്ധിക്കേണ്ടതുണ്ട്, എന്താണ് പ്രവർത്തിക്കുന്നതെന്ന് പരിശോധിക്കുക, @ട്രേസ്ഡ് പ്രവർത്തിക്കുന്നില്ലെങ്കിൽ മാനുവൽ ട്രെയ്സ് ക്രിയേഷൻ ഉപയോഗിക്കുക. ജാവ വ്യാഖ്യാനങ്ങൾക്കായി നിങ്ങൾക്ക് ഒരു അധിക കമ്പൈലർ അറ്റാച്ചുചെയ്യാനും കഴിയും, തുടർന്ന് അത് എല്ലായിടത്തും പ്രവർത്തിക്കും.
• പഴയ സ്പ്രിംഗ്, സ്പ്രിംഗ് ബൂട്ട് എന്നിവയിൽ, ഓപ്പൺട്രെയിംഗ് സ്പ്രിംഗ് ക്ലൗഡ് ഓട്ടോ-കോൺഫിഗറേഷൻ DI-യിലെ ബഗുകൾ കാരണം പ്രവർത്തിക്കില്ല, തുടർന്ന് സ്പ്രിംഗ് ഘടകങ്ങളിലെ ട്രെയ്‌സ് സ്വയമേവ പ്രവർത്തിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, നിങ്ങൾക്ക് ഇത് സാമ്യം ഉപയോഗിച്ച് ചെയ്യാം. 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 ഉം ഉപയോഗിക്കുകയാണെങ്കിൽ, ഈ ടോംകാറ്റിൽ പ്രവർത്തിക്കുന്ന എല്ലാ സേവനങ്ങൾക്കും ഒരു GlobalTracer ഉള്ളതിനാൽ അവയ്‌ക്കെല്ലാം ഒരേ സേവന നാമം ഉണ്ടായിരിക്കും.
• ഒരു രീതിയിലേക്ക് ട്രെയ്സ് ചേർക്കുമ്പോൾ, അത് ഒരു ലൂപ്പിൽ പലതവണ വിളിക്കപ്പെടുന്നില്ലെന്ന് നിങ്ങൾ ഉറപ്പാക്കേണ്ടതുണ്ട്. എല്ലാ കോളുകൾക്കും നിങ്ങൾ ഒരു പൊതുവായ ട്രെയ്സ് ചേർക്കേണ്ടതുണ്ട്, അത് മൊത്തം പ്രവർത്തന സമയം രേഖപ്പെടുത്തും. അല്ലെങ്കിൽ, അധിക ലോഡ് സൃഷ്ടിക്കപ്പെടും.
• ഒരിക്കൽ jaeger-ui-യിൽ അവർ ധാരാളം ട്രെയ്‌സുകൾക്കായി വളരെ വലിയ അഭ്യർത്ഥനകൾ നടത്തി, പ്രതികരണത്തിനായി കാത്തിരിക്കാത്തതിനാൽ അവർ അത് വീണ്ടും ചെയ്തു. തൽഫലമായി, ജെയ്ഗർ-ക്വറി ധാരാളം മെമ്മറി കഴിക്കാനും ഇലാസ്റ്റിക് വേഗത കുറയ്ക്കാനും തുടങ്ങി. jaeger-query പുനരാരംഭിക്കുന്നത് സഹായിച്ചു

സാമ്പിളിംഗ്, സംഭരിക്കുക, ട്രെയ്‌സുകൾ കാണുക

മൂന്ന് തരമുണ്ട് ട്രെയ്സ് സാമ്പിൾ:

1. എല്ലാ ട്രെയ്‌സുകളും അയയ്ക്കുകയും സംരക്ഷിക്കുകയും ചെയ്യുന്ന കോൺസ്റ്റ്.
2. ഒരു നിശ്ചിത പ്രോബബിലിറ്റി ഉപയോഗിച്ച് ട്രെയ്‌സുകൾ ഫിൽട്ടർ ചെയ്യുന്ന പ്രോബബിലിസ്റ്റിക്.
3. ഒരു സെക്കൻഡിൽ ട്രെയ്‌സുകളുടെ എണ്ണം പരിമിതപ്പെടുത്തുന്ന റേറ്റിംഗ്. നിങ്ങൾക്ക് ഈ ക്രമീകരണങ്ങൾ ക്ലയന്റിലോ, jaeger-agent-ലോ കളക്ടറിലോ കോൺഫിഗർ ചെയ്യാം. വളരെയധികം അഭ്യർത്ഥനകൾ ഇല്ലാത്തതിനാൽ ഞങ്ങൾ ഇപ്പോൾ മൂല്യനിർണ്ണയ സ്റ്റാക്കിൽ const 1 ഉപയോഗിക്കുന്നു, പക്ഷേ അവയ്ക്ക് വളരെയധികം സമയമെടുക്കും. ഭാവിയിൽ, ഇത് സിസ്റ്റത്തിൽ അനാവശ്യമായ ലോഡ് ഇടുകയാണെങ്കിൽ, നിങ്ങൾക്ക് അത് പരിമിതപ്പെടുത്താം.

നിങ്ങൾ കസാന്ദ്ര ഉപയോഗിക്കുകയാണെങ്കിൽ, സ്ഥിരസ്ഥിതിയായി അത് രണ്ട് ദിവസത്തേക്ക് മാത്രമേ ട്രെയ്‌സ് സംഭരിക്കുന്നുള്ളൂ. ഞങ്ങൾ ഉപയോഗിക്കുന്നു ഇലാസ്റ്റിക് തിരയൽ കൂടാതെ ട്രെയ്‌സുകൾ മുഴുവൻ സമയവും സംഭരിക്കപ്പെടും, അവ ഇല്ലാതാക്കില്ല. ഓരോ ദിവസവും ഒരു പ്രത്യേക സൂചിക സൃഷ്ടിക്കപ്പെടുന്നു, ഉദാഹരണത്തിന് jaeger-service-2019-03-04. ഭാവിയിൽ, നിങ്ങൾ പഴയ ട്രെയ്സുകളുടെ യാന്ത്രിക ക്ലീനപ്പ് കോൺഫിഗർ ചെയ്യേണ്ടതുണ്ട്.

ട്രെയ്‌സുകൾ കാണുന്നതിന് നിങ്ങൾ ചെയ്യേണ്ടത്:

• നിങ്ങൾ ട്രെയ്‌സുകൾ ഫിൽട്ടർ ചെയ്യാൻ ആഗ്രഹിക്കുന്ന സേവനം തിരഞ്ഞെടുക്കുക, ഉദാഹരണത്തിന്, ടോംകാറ്റിൽ പ്രവർത്തിക്കുന്ന ഒരു സേവനത്തിനായി tomcat7-default, അതിന്റെ സ്വന്തം പേര്.
• അടുത്തതായി, പ്രവർത്തനം, സമയ കാലയളവ്, കുറഞ്ഞ പ്രവർത്തന സമയം എന്നിവ തിരഞ്ഞെടുക്കുക, ഉദാഹരണത്തിന് 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 എന്നിവയിലെ ഒരു യഥാർത്ഥ പ്രോജക്റ്റിൽ ജെയ്ഗർ ഓപ്പൺട്രേസിംഗും മൈക്രോ സർവീസസും
• eng.uber.com/distributed-tracing Uber എഞ്ചിനീയറിംഗിൽ ഡിസ്ട്രിബ്യൂട്ടഡ് ട്രേസിംഗ് വികസിപ്പിക്കുന്നു
• 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