మా ప్రాజెక్ట్‌లలో మేము మైక్రోసర్వీస్ ఆర్కిటెక్చర్‌ని ఉపయోగిస్తాము. పనితీరు అడ్డంకులు ఏర్పడినప్పుడు, లాగ్‌లను పర్యవేక్షించడం మరియు అన్వయించడం కోసం చాలా సమయం వెచ్చిస్తారు. వ్యక్తిగత కార్యకలాపాల సమయాలను లాగ్ ఫైల్‌లోకి లాగిన్ చేస్తున్నప్పుడు, ఈ కార్యకలాపాలకు కాల్ చేయడానికి దారితీసిన వాటిని అర్థం చేసుకోవడం, వివిధ సేవలలో చర్యల క్రమాన్ని లేదా ఒక ఆపరేషన్ యొక్క సమయ మార్పును ట్రాక్ చేయడం సాధారణంగా కష్టం.
మాన్యువల్ లేబర్‌ను తగ్గించడానికి, మేము ట్రేసింగ్ టూల్స్‌లో ఒకదాన్ని ఉపయోగించాలని నిర్ణయించుకున్నాము. మీరు ట్రేసింగ్‌ను ఎలా మరియు దేని కోసం ఉపయోగించవచ్చు మరియు మేము దానిని ఎలా చేసాము అనేది ఈ వ్యాసంలో చర్చించబడుతుంది.
ట్రేసింగ్ ఉపయోగించి ఏ సమస్యలను పరిష్కరించవచ్చు?
- ఒకే సేవలో మరియు అన్ని భాగస్వామ్య సేవల మధ్య మొత్తం అమలు ట్రీలో పనితీరు అడ్డంకులను కనుగొనండి. ఉదాహరణకి:
- సేవల మధ్య అనేక చిన్న సీక్వెన్షియల్ కాల్‌లు, ఉదాహరణకు, జియోకోడింగ్ లేదా డేటాబేస్‌కు.
- నెట్‌వర్క్ ద్వారా డేటాను బదిలీ చేయడం లేదా డిస్క్ నుండి చదవడం వంటి లాంగ్ I/O నిరీక్షణలు.
- సుదీర్ఘ డేటా పార్సింగ్.
- CPU అవసరమయ్యే సుదీర్ఘ కార్యకలాపాలు.
- తుది ఫలితాన్ని పొందేందుకు అవసరం లేని కోడ్ యొక్క విభాగాలు మరియు తీసివేయబడతాయి లేదా వాయిదా వేయబడతాయి.
- ఏ క్రమంలో పిలుస్తారు మరియు ఆపరేషన్ చేసినప్పుడు ఏమి జరుగుతుందో స్పష్టంగా అర్థం చేసుకోండి.
ఉదాహరణకు, WS సేవకు అభ్యర్థన వచ్చిందని చూడవచ్చు -> WS సేవ R సేవ ద్వారా డేటాను భర్తీ చేసింది -> తర్వాత V సేవకు అభ్యర్థనను పంపింది -> V సేవ నుండి చాలా డేటాను డౌన్‌లోడ్ చేసింది R సేవ -> P సేవకు వెళ్లింది -> P సేవ మళ్లీ సేవకు వెళ్లింది R -> సర్వీస్ V ఫలితాన్ని విస్మరించి, సర్వీస్ J ->కి వెళ్లింది మరియు ఆ తర్వాత మాత్రమే సర్వీస్ WSకి సమాధానాన్ని అందించింది, అయితే దీనిలో వేరేదాన్ని లెక్కించడం కొనసాగుతుంది నేపథ్యం.
మొత్తం ప్రక్రియ కోసం అటువంటి ట్రేస్ లేదా వివరణాత్మక డాక్యుమెంటేషన్ లేకుండా, మొదటిసారి కోడ్‌ని చూసిన తర్వాత ఏమి జరుగుతుందో అర్థం చేసుకోవడం చాలా కష్టం, మరియు కోడ్ వివిధ సేవలలో చెల్లాచెదురుగా ఉంటుంది మరియు బీన్స్ మరియు ఇంటర్‌ఫేస్‌ల సమూహం వెనుక దాచబడుతుంది. - తదుపరి వాయిదా విశ్లేషణ కోసం ఎగ్జిక్యూషన్ ట్రీ గురించి సమాచార సేకరణ. అమలు యొక్క ప్రతి దశలో, మీరు ఈ దశలో అందుబాటులో ఉన్న సమాచారాన్ని ట్రేస్‌కు జోడించవచ్చు మరియు అటువంటి దృష్టాంతానికి దారితీసిన ఇన్‌పుట్ డేటా ఏమిటో గుర్తించవచ్చు. ఉదాహరణకి:
- వినియోగదారుని గుర్తింపు
- హక్కుల
- ఎంచుకున్న పద్ధతి రకం
- లాగ్ లేదా ఎగ్జిక్యూషన్ లోపం
- జాడలను మెట్రిక్‌ల ఉపసమితిగా మార్చడం మరియు కొలమానాల రూపంలో తదుపరి విశ్లేషణ.
ఏ ట్రేసింగ్ లాగ్ చేయగలదు. వ్యవధి
ట్రేసింగ్‌లో స్పాన్ అనే భావన ఉంది, ఇది కన్సోల్‌కు ఒక లాగ్ యొక్క అనలాగ్. Span కలిగి ఉంది:
- పేరు, సాధారణంగా అమలు చేయబడిన పద్ధతి పేరు
- స్పాన్ ఉత్పత్తి చేయబడిన సేవ పేరు
- స్వంత ప్రత్యేక ID
- అందులో చేర్చబడిన కీ/విలువ రూపంలో కొంత మెటా సమాచారం. ఉదాహరణకు, పద్ధతి పారామితులు లేదా పద్ధతి లోపంతో ముగిసిందా లేదా
- ఈ స్పాన్ ఎగ్జిక్యూషన్ ప్రారంభ మరియు ముగింపు సమయాలు
- పేరెంట్ స్పాన్ ID
ప్రతి స్పాన్ దాని అమలును పూర్తి చేసిన వెంటనే తదుపరి వీక్షణ కోసం డేటాబేస్‌లో సేవ్ చేయడానికి స్పాన్ కలెక్టర్‌కు పంపబడుతుంది. భవిష్యత్తులో, పేరెంట్ ఐడి ద్వారా వాటిని కనెక్ట్ చేయడం ద్వారా మీరు అన్ని స్పాన్‌ల ట్రీని నిర్మించవచ్చు. విశ్లేషించేటప్పుడు, మీరు కొంత సమయం కంటే ఎక్కువ సమయం తీసుకున్న కొన్ని సేవలోని అన్ని పరిధులను కనుగొనవచ్చు. అప్పుడు, ఒక నిర్దిష్ట వ్యవధికి వెళ్లి, ఈ స్పాన్ పైన మరియు క్రింద మొత్తం చెట్టును చూడండి.
ఓపెన్ట్రేస్, జాగర్ మరియు మేము దానిని మా ప్రాజెక్ట్‌ల కోసం ఎలా అమలు చేసాము
ఒక సాధారణ ప్రమాణం ఉంది , ఏ భాషలోనైనా నిర్దిష్ట అమలుతో ముడిపెట్టకుండా, ఎలా మరియు ఏమి సేకరించాలో వివరిస్తుంది. ఉదాహరణకు, జావాలో, జావాతో కూడిన అన్ని పనులు సాధారణ ఓపెన్ట్రేస్ API ద్వారా నిర్వహించబడతాయి మరియు దాని కింద దాచవచ్చు, ఉదాహరణకు, జైగర్ లేదా ఏమీ చేయని ఖాళీ డిఫాల్ట్ అమలు.
మేము ఉపయోగిస్తాము Opentrace యొక్క అమలుగా. ఇది అనేక భాగాలను కలిగి ఉంటుంది:
- Jaeger-agent అనేది సాధారణంగా ప్రతి మెషీన్‌లో ఇన్‌స్టాల్ చేయబడిన స్థానిక ఏజెంట్ మరియు సేవలు స్థానిక డిఫాల్ట్ పోర్ట్‌లో లాగిన్ చేయబడతాయి. ఏజెంట్ లేకుంటే, ఈ మెషీన్‌లోని అన్ని సేవల జాడలు సాధారణంగా ఆఫ్ చేయబడతాయి
- జేగర్-కలెక్టర్ - అన్ని ఏజెంట్లు సేకరించిన జాడలను దానికి పంపుతారు మరియు అది వాటిని ఎంచుకున్న డేటాబేస్‌లో ఉంచుతుంది
- డేటాబేస్ - వారు ఇష్టపడేది కాసాండ్రా, కానీ మేము సాగే శోధనను ఉపయోగిస్తాము, కొన్ని ఇతర డేటాబేస్‌ల కోసం అమలులు మరియు డిస్క్‌లో దేనినీ సేవ్ చేయని ఇన్-మెమరీ ఇంప్లిమెంటేషన్ ఉన్నాయి.
- Jaeger-query అనేది డేటాబేస్‌లోకి వెళ్లి విశ్లేషణ కోసం ఇప్పటికే సేకరించిన జాడలను అందించే సేవ
- Jaeger-ui అనేది జాడలను శోధించడానికి మరియు వీక్షించడానికి ఒక వెబ్ ఇంటర్‌ఫేస్, ఇది jaeger-queryలో నడుస్తుంది
ఒక ప్రత్యేక భాగాన్ని నిర్దిష్ట భాషల కోసం ఓపెన్ట్రేస్ జేగర్ ఇంప్లిమెంటేషన్ అని పిలుస్తారు, దీని ద్వారా స్పాన్‌లు జేగర్-ఏజెంట్‌కి పంపబడతాయి.
io.opentracing.Tracer ఇంటర్‌ఫేస్‌ను అమలు చేయడానికి క్రిందికి వస్తుంది, దాని ద్వారా అన్ని జాడలు నిజమైన ఏజెంట్‌కి ఎగురతాయి.
మీరు వసంత భాగాలను కూడా కనెక్ట్ చేయవచ్చు మరియు జైగర్ నుండి అమలు ఇది స్వయంచాలకంగా ఈ భాగాల గుండా వెళ్ళే ప్రతిదానికీ ట్రేసింగ్‌ని కాన్ఫిగర్ చేస్తుంది, ఉదాహరణకు కంట్రోలర్‌లకు http అభ్యర్థనలు, jdbc ద్వారా డేటాబేస్‌కు అభ్యర్థనలు మొదలైనవి.
జావాలో జాడలను లాగ్ చేయడం
ఎక్కడో ఉన్నత స్థాయిలో మొదటి స్పాన్ సృష్టించబడాలి, ఇది స్వయంచాలకంగా చేయబడుతుంది, ఉదాహరణకు ఒక అభ్యర్థనను స్వీకరించినప్పుడు స్ప్రింగ్ కంట్రోలర్ ద్వారా లేదా ఏదీ లేనట్లయితే మానవీయంగా. ఇది క్రింది స్కోప్ ద్వారా ప్రసారం చేయబడుతుంది. దిగువన ఉన్న ఏదైనా పద్ధతి Spanని జోడించాలనుకుంటే, అది స్కోప్ నుండి ప్రస్తుత యాక్టివ్‌స్పాన్‌ని తీసుకుంటుంది, కొత్త స్పాన్‌ని సృష్టిస్తుంది మరియు దాని పేరెంట్ యాక్టివ్‌స్పాన్‌ని పొందిందని చెబుతుంది మరియు కొత్త స్పాన్‌ను యాక్టివ్ చేస్తుంది. బాహ్య సేవలను పిలిచినప్పుడు, ప్రస్తుత యాక్టివ్ స్పాన్ వారికి పంపబడుతుంది మరియు ఆ సేవలు ఈ స్పాన్‌కి లింక్ చేయబడిన కొత్త స్పాన్‌లను సృష్టిస్తాయి.
అన్ని పని ట్రేసర్ ఉదాహరణ ద్వారా జరుగుతుంది; 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 అభ్యర్థనల కోసం ఉంది
HttpClient httpClient = new TracingHttpClientBuilder().build();మేము ఎదుర్కొన్న సమస్యలు
- ట్రేసర్‌ను సర్వీస్ లేదా కాంపోనెంట్‌లో ఉపయోగించకపోతే బీన్స్ మరియు DI ఎల్లప్పుడూ పని చేయవు ట్రేసర్ పని చేయకపోవచ్చు మరియు మీరు GlobalTracer.get()ని ఉపయోగించాల్సి ఉంటుంది.
- ఇది ఒక కాంపోనెంట్ లేదా సర్వీస్ కాకపోతే లేదా మెథడ్ కాల్ అదే తరగతికి చెందిన పొరుగు పద్ధతి నుండి వచ్చినట్లయితే ఉల్లేఖనాలు పని చేయవు. మీరు జాగ్రత్తగా ఉండాలి, ఏమి పనిచేస్తుందో తనిఖీ చేయండి మరియు @Traced పని చేయకపోతే మాన్యువల్ ట్రేస్ క్రియేషన్‌ని ఉపయోగించండి. మీరు జావా ఉల్లేఖనాల కోసం అదనపు కంపైలర్‌ను కూడా జోడించవచ్చు, అప్పుడు అది ప్రతిచోటా పని చేయాలి.
- పాత స్ప్రింగ్ మరియు స్ప్రింగ్ బూట్‌లో, DIలోని బగ్‌ల కారణంగా ఓపెన్‌ట్రేయింగ్ స్ప్రింగ్ క్లౌడ్ ఆటో-కాన్ఫిగరేషన్ పనిచేయదు, అప్పుడు మీరు స్ప్రింగ్ కాంపోనెంట్‌లలో ట్రేస్‌లు ఆటోమేటిక్‌గా పని చేయాలనుకుంటే, మీరు దీన్ని సారూప్యతతో చేయవచ్చు
- వనరులతో ప్రయత్నించండి గ్రూవీలో పని చేయదు; మీరు ఉపయోగించాలి చివరగా ప్రయత్నించండి.
- ప్రతి సేవ తప్పనిసరిగా దాని స్వంత spring.application.nameని కలిగి ఉండాలి, దీని కింద ట్రేస్‌లు లాగ్ చేయబడతాయి. విక్రయాలు మరియు పరీక్షల కోసం ప్రత్యేక పేరు ఎలా ఉంటుంది, తద్వారా వాటిని కలపకూడదు.
- మీరు గ్లోబల్‌ట్రేసర్ మరియు టామ్‌క్యాట్‌ని ఉపయోగిస్తుంటే, ఈ టామ్‌క్యాట్‌లో నడుస్తున్న అన్ని సర్వీస్‌లు ఒక గ్లోబల్‌ట్రేసర్‌ని కలిగి ఉంటాయి, కాబట్టి అవన్నీ ఒకే సర్వీస్ పేరును కలిగి ఉంటాయి.
- ఒక పద్ధతికి ట్రేస్‌లను జోడించేటప్పుడు, అది చాలాసార్లు లూప్‌లో పిలవబడలేదని మీరు నిర్ధారించుకోవాలి. మీరు అన్ని కాల్‌ల కోసం ఒక సాధారణ ట్రేస్‌ను జోడించాలి, ఇది మొత్తం ఆపరేటింగ్ సమయాన్ని రికార్డ్ చేస్తుంది. లేకపోతే, అదనపు లోడ్ సృష్టించబడుతుంది.
- ఒకసారి jaeger-uiలో వారు పెద్ద సంఖ్యలో జాడల కోసం చాలా పెద్ద అభ్యర్థనలు చేసారు మరియు వారు ప్రతిస్పందన కోసం వేచి ఉండనందున, వారు దానిని మళ్లీ చేసారు. ఫలితంగా, జేగర్-క్వెరీ చాలా జ్ఞాపకశక్తిని తినడం ప్రారంభించింది మరియు సాగే వేగాన్ని తగ్గించింది. jaeger-queryని పునఃప్రారంభించడం ద్వారా సహాయపడింది
జాడలను నమూనా చేయడం, నిల్వ చేయడం మరియు వీక్షించడం
మూడు రకాలు ఉన్నాయి :
- అన్ని ట్రేస్‌లను పంపే మరియు సేవ్ చేసే కాన్స్ట్.
- ఒక నిర్దిష్ట సంభావ్యతతో ట్రేస్‌లను ఫిల్టర్ చేసే సంభావ్యత.
- సెకనుకు ట్రేస్‌ల సంఖ్యను పరిమితం చేసే రేటింగ్. మీరు ఈ సెట్టింగ్‌లను క్లయింట్‌లో, జేగర్-ఏజెంట్‌లో లేదా కలెక్టర్‌లో కాన్ఫిగర్ చేయవచ్చు. చాలా ఎక్కువ అభ్యర్థనలు లేనందున ఇప్పుడు మేము వాల్యుయేటర్ స్టాక్‌లో const 1ని ఉపయోగిస్తాము, కానీ వాటికి చాలా సమయం పడుతుంది. భవిష్యత్తులో, ఇది సిస్టమ్‌పై అనవసరమైన లోడ్‌ను ఉంచినట్లయితే, మీరు దానిని పరిమితం చేయవచ్చు.
మీరు కాసాండ్రాను ఉపయోగిస్తే, డిఫాల్ట్‌గా ఇది రెండు రోజులు మాత్రమే ట్రేస్‌లను నిల్వ చేస్తుంది. మేము ఉపయోగిస్తాము మరియు జాడలు మొత్తం సమయం కోసం నిల్వ చేయబడతాయి మరియు తొలగించబడవు. ప్రతి రోజు కోసం ఒక ప్రత్యేక సూచిక సృష్టించబడుతుంది, ఉదాహరణకు jaeger-service-2019-03-04. భవిష్యత్తులో, మీరు పాత జాడల యొక్క ఆటోమేటిక్ క్లీనప్‌ను కాన్ఫిగర్ చేయాలి.
జాడలను వీక్షించడానికి మీరు వీటిని చేయాలి:
- మీరు ట్రేస్‌లను ఫిల్టర్ చేయాలనుకుంటున్న సేవను ఎంచుకోండి, ఉదాహరణకు టామ్‌క్యాట్‌లో నడుస్తున్న మరియు దాని స్వంత పేరు లేని సేవ కోసం tomcat7-డిఫాల్ట్.
- తరువాత, ఆపరేషన్, సమయ వ్యవధి మరియు కనిష్ట ఆపరేషన్ సమయాన్ని ఎంచుకోండి, ఉదాహరణకు 10 సెకన్ల నుండి, సుదీర్ఘమైన అమలులను మాత్రమే తీసుకోవడానికి.
- ట్రేస్‌లలో ఒకదానికి వెళ్లి అక్కడ ఏమి తగ్గుతోందో చూడండి.
అలాగే, ఏదైనా అభ్యర్థన ఐడి తెలిసినట్లయితే, ఈ ఐడి ట్రేస్ వ్యవధిలో లాగిన్ అయినట్లయితే, ట్యాగ్ శోధన ద్వారా మీరు ఈ ఐడి ద్వారా ట్రేస్‌ను కనుగొనవచ్చు.
డాక్యుమెంటేషన్
- ఓపెన్‌ట్రేసింగ్ డాక్యుమెంటేషన్
- జేగర్ డాక్యుమెంటేషన్
- జేగర్ జావాను కనెక్ట్ చేస్తోంది
- స్ప్రింగ్ ఓపెన్ ట్రేసింగ్ కనెక్షన్
వ్యాసాలు
- PHP మరియు గోలాంగ్‌లో నిజమైన ప్రాజెక్ట్‌లో జేగర్ ఓపెన్‌ట్రేసింగ్ మరియు మైక్రోసర్వీసెస్
- ఉబెర్ ఇంజనీరింగ్‌లో డిస్ట్రిబ్యూటెడ్ ట్రేసింగ్‌ను అభివృద్ధి చేస్తోంది
- బేర్ మెటల్‌పై జేగర్ ఏజెంట్‌ను నడుపుతోంది
వీడియో
- మెరుపు-వేగవంతమైన వినియోగదారు ప్రశ్నలను అందించడానికి మేము జేగర్ మరియు ప్రోమేతియస్‌లను ఎలా ఉపయోగించాము - బ్రయాన్ బోరెహామ్
- పరిచయం: జేగర్ - యూరి ష్కురో, ఉబెర్ & పావోల్ లోఫే, రెడ్ హ్యాట్
- సెర్గీ ఇయాకోవ్లెవ్, "ఎ స్మాల్ స్టోరీ ఆఫ్ ఎ ఎ బిగ్ విక్టరీ: ఓపెన్‌ట్రేసింగ్, AWS మరియు జేగర్"
మూలం: www.habr.com