ਸਰਵਿਸ ਟਰੇਸਿੰਗ, ਓਪਨ ਟਰੇਸਿੰਗ ਅਤੇ ਜੈਗਰ

ਅਸੀਂ ਆਪਣੇ ਪ੍ਰੋਜੈਕਟਾਂ ਵਿੱਚ ਮਾਈਕ੍ਰੋਸਰਵਿਸ ਆਰਕੀਟੈਕਚਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ। ਜਦੋਂ ਪ੍ਰਦਰਸ਼ਨ ਦੀਆਂ ਰੁਕਾਵਟਾਂ ਆਉਂਦੀਆਂ ਹਨ, ਬਹੁਤ ਸਾਰਾ ਸਮਾਂ ਲੌਗਸ ਦੀ ਨਿਗਰਾਨੀ ਅਤੇ ਪਾਰਸ ਕਰਨ ਵਿੱਚ ਖਰਚ ਹੁੰਦਾ ਹੈ। ਇੱਕ ਲੌਗ ਫਾਈਲ ਵਿੱਚ ਵਿਅਕਤੀਗਤ ਓਪਰੇਸ਼ਨਾਂ ਦੇ ਸਮੇਂ ਨੂੰ ਲੌਗ ਕਰਨ ਵੇਲੇ, ਇਹ ਸਮਝਣਾ ਆਮ ਤੌਰ 'ਤੇ ਮੁਸ਼ਕਲ ਹੁੰਦਾ ਹੈ ਕਿ ਇਹਨਾਂ ਓਪਰੇਸ਼ਨਾਂ ਦੀ ਮੰਗ ਕਿਸ ਕਾਰਨ ਹੋਈ, ਕਿਰਿਆਵਾਂ ਦੇ ਕ੍ਰਮ ਜਾਂ ਵੱਖ-ਵੱਖ ਸੇਵਾਵਾਂ ਵਿੱਚ ਇੱਕ ਓਪਰੇਸ਼ਨ ਦੇ ਦੂਜੇ ਦੇ ਅਨੁਸਾਰੀ ਸਮੇਂ ਦੀ ਤਬਦੀਲੀ ਨੂੰ ਟਰੈਕ ਕਰਨ ਲਈ।

ਹੱਥੀਂ ਕਿਰਤ ਨੂੰ ਘਟਾਉਣ ਲਈ, ਅਸੀਂ ਟਰੇਸਿੰਗ ਟੂਲ ਵਿੱਚੋਂ ਇੱਕ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਹੈ। ਇਸ ਬਾਰੇ ਕਿ ਤੁਸੀਂ ਟਰੇਸਿੰਗ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਅਤੇ ਕਿਉਂ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਅਸੀਂ ਇਹ ਕਿਵੇਂ ਕੀਤਾ, ਅਤੇ ਇਸ ਲੇਖ ਵਿੱਚ ਚਰਚਾ ਕੀਤੀ ਜਾਵੇਗੀ।

ਟਰੇਸਿੰਗ ਨਾਲ ਕਿਹੜੀਆਂ ਸਮੱਸਿਆਵਾਂ ਹੱਲ ਕੀਤੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ

1. ਇੱਕ ਸਿੰਗਲ ਸੇਵਾ ਦੇ ਅੰਦਰ ਅਤੇ ਸਾਰੀਆਂ ਭਾਗ ਲੈਣ ਵਾਲੀਆਂ ਸੇਵਾਵਾਂ ਦੇ ਵਿਚਕਾਰ ਪੂਰੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਟ੍ਰੀ ਵਿੱਚ ਪ੍ਰਦਰਸ਼ਨ ਦੀਆਂ ਰੁਕਾਵਟਾਂ ਲੱਭੋ। ਉਦਾਹਰਣ ਲਈ:
   • ਸੇਵਾਵਾਂ ਦੇ ਵਿਚਕਾਰ ਕਈ ਛੋਟੀਆਂ ਲਗਾਤਾਰ ਕਾਲਾਂ, ਉਦਾਹਰਨ ਲਈ, ਜੀਓਕੋਡਿੰਗ ਜਾਂ ਡੇਟਾਬੇਸ ਲਈ।
   • ਲੰਬੀ I/O ਉਡੀਕ, ਜਿਵੇਂ ਕਿ ਨੈੱਟਵਰਕ ਟ੍ਰਾਂਸਫਰ ਜਾਂ ਡਿਸਕ ਰੀਡ।
   • ਲੰਮਾ ਡਾਟਾ ਪਾਰਸਿੰਗ।
   • ਲੰਬੇ ਓਪਰੇਸ਼ਨਾਂ ਲਈ cpu ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
   • ਕੋਡ ਦੇ ਭਾਗ ਜਿਨ੍ਹਾਂ ਦੀ ਅੰਤਮ ਨਤੀਜਾ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਲੋੜ ਨਹੀਂ ਹੈ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਹਟਾਇਆ ਜਾ ਸਕਦਾ ਹੈ ਜਾਂ ਦੇਰੀ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।
2. ਸਪਸ਼ਟ ਤੌਰ ਤੇ ਸਮਝੋ ਕਿ ਕਿਸ ਕ੍ਰਮ ਵਿੱਚ ਕੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਜਦੋਂ ਓਪਰੇਸ਼ਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਤਾਂ ਕੀ ਹੁੰਦਾ ਹੈ।
   
   ਇਹ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ ਕਿ, ਉਦਾਹਰਨ ਲਈ, WS ਸੇਵਾ ਨੂੰ ਬੇਨਤੀ ਆਈ -> WS ਸੇਵਾ ਨੇ R ਸੇਵਾ ਦੁਆਰਾ ਡੇਟਾ ਦੀ ਪੂਰਤੀ ਕੀਤੀ -> ਫਿਰ V ਸੇਵਾ ਨੂੰ ਇੱਕ ਬੇਨਤੀ ਭੇਜੀ -> V ਸੇਵਾ ਨੇ ਬਹੁਤ ਸਾਰਾ ਡਾਟਾ ਲੋਡ ਕੀਤਾ R ਸੇਵਾ -> P ਸੇਵਾ 'ਤੇ ਗਈ -> P ਸੇਵਾ ਦੁਬਾਰਾ ਸੇਵਾ 'ਤੇ ਗਈ R -> ਸੇਵਾ V ਨੇ ਨਤੀਜੇ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕੀਤਾ ਅਤੇ J -> ਸੇਵਾ 'ਤੇ ਗਿਆ ਅਤੇ ਫਿਰ ਹੀ ਸੇਵਾ WS ਨੂੰ ਜਵਾਬ ਵਾਪਸ ਕਰ ਦਿੱਤਾ, ਜਦੋਂ ਕਿ ਕਿਸੇ ਹੋਰ ਚੀਜ਼ ਦੀ ਗਣਨਾ ਕਰਨਾ ਜਾਰੀ ਰੱਖਿਆ। ਪਿਛੋਕੜ.
   ਪੂਰੀ ਪ੍ਰਕਿਰਿਆ ਲਈ ਅਜਿਹੇ ਟਰੇਸ ਜਾਂ ਵਿਸਤ੍ਰਿਤ ਦਸਤਾਵੇਜ਼ਾਂ ਦੇ ਬਿਨਾਂ, ਇਹ ਸਮਝਣਾ ਬਹੁਤ ਮੁਸ਼ਕਲ ਹੈ ਕਿ ਕੋਡ ਨੂੰ ਪਹਿਲੀ ਵਾਰ ਦੇਖਦੇ ਸਮੇਂ ਕੀ ਹੋ ਰਿਹਾ ਹੈ, ਅਤੇ ਕੋਡ ਵੱਖ-ਵੱਖ ਸੇਵਾਵਾਂ ਵਿੱਚ ਖਿੰਡਿਆ ਹੋਇਆ ਹੈ ਅਤੇ ਬਿੰਨਾਂ ਅਤੇ ਇੰਟਰਫੇਸਾਂ ਦੇ ਝੁੰਡ ਦੇ ਪਿੱਛੇ ਲੁਕਿਆ ਹੋਇਆ ਹੈ।
3. ਬਾਅਦ ਦੇ ਮੁਲਤਵੀ ਵਿਸ਼ਲੇਸ਼ਣ ਲਈ ਫਾਂਸੀ ਦੇ ਰੁੱਖ ਬਾਰੇ ਜਾਣਕਾਰੀ ਦਾ ਸੰਗ੍ਰਹਿ। ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦੇ ਹਰੇਕ ਪੜਾਅ 'ਤੇ, ਤੁਸੀਂ ਇਸ ਪੜਾਅ 'ਤੇ ਉਪਲਬਧ ਟਰੇਸ ਵਿੱਚ ਜਾਣਕਾਰੀ ਸ਼ਾਮਲ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਫਿਰ ਇਹ ਪਤਾ ਲਗਾ ਸਕਦੇ ਹੋ ਕਿ ਕਿਹੜਾ ਇਨਪੁਟ ਡੇਟਾ ਇੱਕ ਸਮਾਨ ਦ੍ਰਿਸ਼ ਵੱਲ ਲੈ ਗਿਆ ਹੈ। ਉਦਾਹਰਣ ਲਈ:
   • ਯੂਜਰ ਆਈਡੀ
   • ਹੱਕ
   • ਚੁਣੀ ਗਈ ਵਿਧੀ ਦੀ ਕਿਸਮ
   • ਲੌਗ ਜਾਂ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਗਲਤੀ
4. ਟਰੇਸ ਨੂੰ ਮੈਟ੍ਰਿਕਸ ਦੇ ਸਬਸੈੱਟ ਵਿੱਚ ਬਦਲਣਾ ਅਤੇ ਮੈਟ੍ਰਿਕਸ ਦੇ ਰੂਪ ਵਿੱਚ ਪਹਿਲਾਂ ਤੋਂ ਹੀ ਹੋਰ ਵਿਸ਼ਲੇਸ਼ਣ।

ਕੀ ਟਰੇਸ ਲਾਗ ਕਰ ਸਕਦਾ ਹੈ. ਸਪੈਨ

ਟਰੇਸਿੰਗ ਵਿੱਚ ਇੱਕ ਸਪੈਨ ਦੀ ਧਾਰਨਾ ਹੈ, ਇਹ ਕੰਸੋਲ ਲਈ ਇੱਕ ਲੌਗ ਦਾ ਐਨਾਲਾਗ ਹੈ। ਸਪਾ ਵਿੱਚ ਹੈ:

• ਨਾਮ, ਆਮ ਤੌਰ 'ਤੇ ਉਸ ਵਿਧੀ ਦਾ ਨਾਮ ਜੋ ਚਲਾਇਆ ਗਿਆ ਸੀ
• ਸੇਵਾ ਦਾ ਨਾਮ ਜਿਸ ਵਿੱਚ ਸਪੈਨ ਬਣਾਇਆ ਗਿਆ ਸੀ
• ਆਪਣੀ ਵਿਲੱਖਣ ਆਈ.ਡੀ
• ਕੁੰਜੀ/ਮੁੱਲ ਦੇ ਰੂਪ ਵਿੱਚ ਕੁਝ ਕਿਸਮ ਦੀ ਮੈਟਾ ਜਾਣਕਾਰੀ ਜੋ ਇਸ ਵਿੱਚ ਲੌਗਇਨ ਕੀਤੀ ਗਈ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਵਿਧੀ ਪੈਰਾਮੀਟਰ ਜਾਂ ਵਿਧੀ ਇੱਕ ਗਲਤੀ ਨਾਲ ਖਤਮ ਹੋਈ ਜਾਂ ਨਹੀਂ
• ਇਸ ਮਿਆਦ ਲਈ ਸ਼ੁਰੂਆਤੀ ਅਤੇ ਸਮਾਪਤੀ ਸਮਾਂ
• ਪੇਰੈਂਟ ਸਪੈਨ ਆਈ.ਡੀ

ਹਰ ਇੱਕ ਸਪੈਨ ਨੂੰ ਸਪੈਨ ਕੁਲੈਕਟਰ ਨੂੰ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ ਤਾਂ ਜੋ ਇਸ ਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਪੂਰਾ ਕਰਦੇ ਹੀ ਬਾਅਦ ਵਿੱਚ ਸਮੀਖਿਆ ਲਈ ਡੇਟਾਬੇਸ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਜਾ ਸਕੇ। ਭਵਿੱਖ ਵਿੱਚ, ਤੁਸੀਂ ਪੇਰੈਂਟ ਆਈਡੀ ਦੁਆਰਾ ਕਨੈਕਟ ਕਰਕੇ ਸਾਰੇ ਸਪੈਨ ਦਾ ਇੱਕ ਰੁੱਖ ਬਣਾ ਸਕਦੇ ਹੋ। ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਦੇ ਸਮੇਂ, ਤੁਸੀਂ ਲੱਭ ਸਕਦੇ ਹੋ, ਉਦਾਹਰਨ ਲਈ, ਕੁਝ ਸੇਵਾ ਵਿੱਚ ਸਾਰੇ ਸਪੈਨ ਜੋ ਕੁਝ ਸਮੇਂ ਤੋਂ ਵੱਧ ਲੈਂਦੇ ਹਨ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇੱਕ ਖਾਸ ਸਪੈਨ 'ਤੇ ਜਾ ਕੇ, ਇਸ ਸਪੈਨ ਦੇ ਉੱਪਰ ਅਤੇ ਹੇਠਾਂ ਸਾਰਾ ਰੁੱਖ ਵੇਖੋ।

ਓਪਨਟਰੇਸ, ਜੈਗਰ ਅਤੇ ਅਸੀਂ ਇਸਨੂੰ ਆਪਣੇ ਪ੍ਰੋਜੈਕਟਾਂ ਲਈ ਕਿਵੇਂ ਲਾਗੂ ਕੀਤਾ

ਇੱਕ ਆਮ ਮਿਆਰ ਹੈ ਓਪਨਟਰੇਸ, ਜੋ ਵਰਣਨ ਕਰਦਾ ਹੈ ਕਿ ਕਿਸੇ ਵੀ ਭਾਸ਼ਾ ਵਿੱਚ ਕਿਸੇ ਖਾਸ ਲਾਗੂਕਰਨ ਨਾਲ ਬੰਨ੍ਹੇ ਬਿਨਾਂ, ਕਿਵੇਂ ਅਤੇ ਕੀ ਇਕੱਠਾ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਜਾਵਾ ਵਿੱਚ, ਟਰੇਸ ਦੇ ਨਾਲ ਸਾਰੇ ਕੰਮ ਆਮ ਓਪਨਟਰੇਸ API ਦੁਆਰਾ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਅਤੇ ਇਸਦੇ ਅਧੀਨ, ਉਦਾਹਰਨ ਲਈ, ਜੈਗਰ ਜਾਂ ਇੱਕ ਖਾਲੀ ਡਿਫੌਲਟ ਲਾਗੂਕਰਨ ਜੋ ਕੁਝ ਨਹੀਂ ਕਰਦਾ, ਨੂੰ ਲੁਕਾਇਆ ਨਹੀਂ ਜਾ ਸਕਦਾ।
ਅਸੀਂ ਵਰਤ ਰਹੇ ਹਾਂ ਜਗੇਰ ਓਪਨਟਰੇਸ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੇ ਰੂਪ ਵਿੱਚ। ਇਸ ਵਿੱਚ ਕਈ ਭਾਗ ਹੁੰਦੇ ਹਨ:

• ਜੈਗਰ-ਏਜੰਟ ਇੱਕ ਸਥਾਨਕ ਏਜੰਟ ਹੈ ਜੋ ਆਮ ਤੌਰ 'ਤੇ ਹਰੇਕ ਮਸ਼ੀਨ 'ਤੇ ਸਥਾਪਤ ਹੁੰਦਾ ਹੈ ਅਤੇ ਸੇਵਾਵਾਂ ਸਥਾਨਕ ਡਿਫੌਲਟ ਪੋਰਟ 'ਤੇ ਇਸ ਵਿੱਚ ਲੌਗਇਨ ਹੁੰਦੀਆਂ ਹਨ। ਜੇਕਰ ਕੋਈ ਏਜੰਟ ਨਹੀਂ ਹੈ, ਤਾਂ ਇਸ ਮਸ਼ੀਨ 'ਤੇ ਸਾਰੀਆਂ ਸੇਵਾਵਾਂ ਦੇ ਟਰੇਸ ਆਮ ਤੌਰ 'ਤੇ ਅਸਮਰੱਥ ਹੁੰਦੇ ਹਨ
• ਜੈਗਰ-ਕੁਲੈਕਟਰ - ਸਾਰੇ ਏਜੰਟ ਇਸ ਨੂੰ ਇਕੱਠੇ ਕੀਤੇ ਟਰੇਸ ਭੇਜਦੇ ਹਨ, ਅਤੇ ਇਹ ਉਹਨਾਂ ਨੂੰ ਚੁਣੇ ਹੋਏ ਡੇਟਾਬੇਸ ਵਿੱਚ ਰੱਖਦਾ ਹੈ
• ਡੇਟਾਬੇਸ ਉਹਨਾਂ ਦੀ ਪਸੰਦੀਦਾ ਕੈਸੈਂਡਰਾ ਹੈ, ਪਰ ਅਸੀਂ elasticsearch ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ, ਇੱਥੇ ਕੁਝ ਹੋਰ ਡੇਟਾਬੇਸ ਅਤੇ ਇੱਕ ਇਨ-ਮੈਮੋਰੀ ਲਾਗੂਕਰਨ ਲਈ ਲਾਗੂਕਰਨ ਹਨ ਜੋ ਡਿਸਕ ਵਿੱਚ ਕੁਝ ਵੀ ਸੁਰੱਖਿਅਤ ਨਹੀਂ ਕਰਦੇ ਹਨ
• Jaeger-query ਇੱਕ ਅਜਿਹੀ ਸੇਵਾ ਹੈ ਜੋ ਡੇਟਾਬੇਸ ਵਿੱਚ ਜਾਂਦੀ ਹੈ ਅਤੇ ਵਿਸ਼ਲੇਸ਼ਣ ਲਈ ਪਹਿਲਾਂ ਤੋਂ ਇਕੱਠੇ ਕੀਤੇ ਟਰੇਸ ਵਾਪਸ ਕਰਦੀ ਹੈ।
• Jaeger-ui ਟਰੇਸ ਖੋਜਣ ਅਤੇ ਦੇਖਣ ਲਈ ਇੱਕ ਵੈੱਬ ਇੰਟਰਫੇਸ ਹੈ, ਇਹ jaeger-query ਤੇ ਜਾਂਦਾ ਹੈ

ਇੱਕ ਵੱਖਰੇ ਹਿੱਸੇ ਨੂੰ ਖਾਸ ਭਾਸ਼ਾਵਾਂ ਲਈ ਓਪਨਟਰੇਸ ਜੈਗਰ ਦੀ ਸਥਾਪਨਾ ਕਿਹਾ ਜਾ ਸਕਦਾ ਹੈ, ਜਿਸ ਰਾਹੀਂ ਸਪੈਨ ਜੈਗਰ-ਏਜੰਟ ਨੂੰ ਭੇਜੇ ਜਾਂਦੇ ਹਨ।
ਜਾਵਾ ਵਿੱਚ ਜੈਗਰ ਨੂੰ ਜੋੜਨਾ io.opentracing.Tracer ਇੰਟਰਫੇਸ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਹੇਠਾਂ ਆਉਂਦਾ ਹੈ, ਜਿਸ ਤੋਂ ਬਾਅਦ ਇਸ ਰਾਹੀਂ ਸਾਰੇ ਟਰੇਸ ਅਸਲ ਏਜੰਟ ਤੱਕ ਪਹੁੰਚ ਜਾਣਗੇ।

ਬਸੰਤ ਕੰਪੋਨੈਂਟ ਲਈ ਵੀ, ਤੁਸੀਂ ਕਨੈਕਟ ਕਰ ਸਕਦੇ ਹੋ ਓਪਨਟਰੇਸਿੰਗ-ਸਪਰਿੰਗ-ਕਲਾਊਡ-ਸਟਾਰਟਰ ਅਤੇ ਜੈਗਰ ਤੋਂ ਲਾਗੂ ਕਰਨਾ opentracing-spring-jaeger-Cloud-starter ਜੋ ਇਹਨਾਂ ਭਾਗਾਂ ਵਿੱਚੋਂ ਲੰਘਣ ਵਾਲੀ ਹਰ ਚੀਜ਼ ਲਈ ਟਰੇਸਿੰਗ ਨੂੰ ਆਪਣੇ ਆਪ ਸੰਰਚਿਤ ਕਰੇਗਾ, ਉਦਾਹਰਨ ਲਈ ਕੰਟਰੋਲਰਾਂ ਨੂੰ HTTP ਬੇਨਤੀਆਂ, jdbc ਰਾਹੀਂ ਡੇਟਾਬੇਸ ਨੂੰ ਬੇਨਤੀਆਂ, ਆਦਿ।

ਜਾਵਾ ਵਿੱਚ ਲੌਗਿੰਗ ਨੂੰ ਟਰੇਸ ਕਰਦਾ ਹੈ

ਕਿਤੇ ਉੱਪਰਲੇ ਪੱਧਰ 'ਤੇ, ਪਹਿਲਾ ਸਪੈਨ ਬਣਾਇਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ, ਇਹ ਸਵੈਚਲਿਤ ਤੌਰ 'ਤੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਉਦਾਹਰਨ ਲਈ, ਬੇਨਤੀ ਪ੍ਰਾਪਤ ਹੋਣ 'ਤੇ ਸਪਰਿੰਗ ਕੰਟਰੋਲਰ ਦੁਆਰਾ, ਜਾਂ ਹੱਥੀਂ ਜੇਕਰ ਕੋਈ ਨਹੀਂ ਹੈ। ਇਹ ਫਿਰ ਹੇਠਾਂ ਦਿੱਤੇ ਸਕੋਪ ਦੁਆਰਾ ਪ੍ਰਸਾਰਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਜੇਕਰ ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਵਿਧੀਆਂ ਵਿੱਚੋਂ ਕੋਈ ਵੀ ਸਪੈਨ ਜੋੜਨਾ ਚਾਹੁੰਦੀ ਹੈ, ਤਾਂ ਇਹ ਸਕੋਪ ਤੋਂ ਮੌਜੂਦਾ ਐਕਟਿਵ ਸਪੈਨ ਲੈਂਦਾ ਹੈ, ਇੱਕ ਨਵਾਂ ਸਪੈਨ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਕਹਿੰਦਾ ਹੈ ਕਿ ਇਸਦਾ ਪੇਰੈਂਟ ਨਤੀਜਾ ਐਕਟਿਵ ਸਪੈਨ ਹੈ, ਅਤੇ ਨਵੇਂ ਸਪੈਨ ਨੂੰ ਕਿਰਿਆਸ਼ੀਲ ਬਣਾਉਂਦਾ ਹੈ। ਬਾਹਰੀ ਸੇਵਾਵਾਂ ਨੂੰ ਕਾਲ ਕਰਨ ਵੇਲੇ, ਮੌਜੂਦਾ ਕਿਰਿਆਸ਼ੀਲ ਸਪੈਨ ਉਹਨਾਂ ਨੂੰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਉਹ ਸੇਵਾਵਾਂ ਇਸ ਸਪੈਨ ਦੇ ਸੰਦਰਭ ਵਿੱਚ ਨਵੇਂ ਸਪੈਨ ਬਣਾਉਂਦੀਆਂ ਹਨ।
ਸਾਰਾ ਕੰਮ ਟਰੇਸਰ ਉਦਾਹਰਨ ਰਾਹੀਂ ਹੁੰਦਾ ਹੈ, ਤੁਸੀਂ ਇਸਨੂੰ DI ਵਿਧੀ ਰਾਹੀਂ ਜਾਂ GlobalTracer.get () ਨੂੰ ਇੱਕ ਗਲੋਬਲ ਵੇਰੀਏਬਲ ਵਜੋਂ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ ਜੇਕਰ DI ਵਿਧੀ ਕੰਮ ਨਹੀਂ ਕਰਦੀ ਹੈ। ਮੂਲ ਰੂਪ ਵਿੱਚ, ਜੇਕਰ ਟਰੇਸਰ ਸ਼ੁਰੂ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ NoopTracer ਵਾਪਸ ਆ ਜਾਵੇਗਾ ਜੋ ਕੁਝ ਨਹੀਂ ਕਰਦਾ।
ਇਸ ਤੋਂ ਇਲਾਵਾ, ਮੌਜੂਦਾ ਸਕੋਪ ਨੂੰ ਟ੍ਰੇਸਰ ਤੋਂ ScopeManager ਦੁਆਰਾ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਨਵੇਂ ਸਪੈਨ ਦੀ ਬਾਈਡਿੰਗ ਨਾਲ ਮੌਜੂਦਾ ਸਕੋਪ ਤੋਂ ਇੱਕ ਨਵਾਂ ਸਕੋਪ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਫਿਰ ਬਣਾਇਆ ਗਿਆ ਸਕੋਪ ਬੰਦ ਹੋ ਜਾਂਦਾ ਹੈ, ਜੋ ਬਣਾਏ ਗਏ ਸਪੈਨ ਨੂੰ ਬੰਦ ਕਰਦਾ ਹੈ ਅਤੇ ਪਿਛਲੇ ਸਕੋਪ ਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਸਰਗਰਮ ਰਾਜ. ਸਕੋਪ ਇੱਕ ਥ੍ਰੈਡ ਨਾਲ ਬੰਨ੍ਹਿਆ ਹੋਇਆ ਹੈ, ਇਸ ਲਈ ਜਦੋਂ ਮਲਟੀ-ਥ੍ਰੈਡਡ ਪ੍ਰੋਗਰਾਮਿੰਗ, ਤੁਹਾਨੂੰ ਇਸ ਸਪੈਨ ਦੇ ਸੰਦਰਭ ਵਿੱਚ ਕਿਸੇ ਹੋਰ ਥ੍ਰੈਡ ਦੇ ਸਕੋਪ ਨੂੰ ਹੋਰ ਸਰਗਰਮ ਕਰਨ ਲਈ, ਕਿਰਿਆਸ਼ੀਲ ਸਪੈਨ ਨੂੰ ਕਿਸੇ ਹੋਰ ਥ੍ਰੈਡ ਵਿੱਚ ਤਬਦੀਲ ਕਰਨਾ ਨਹੀਂ ਭੁੱਲਣਾ ਚਾਹੀਦਾ ਹੈ।

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 ਕੰਮ ਨਹੀਂ ਕਰਦਾ ਹੈ ਤਾਂ ਮੈਨੁਅਲ ਟਰੇਸ ਬਣਾਉਣ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਤੁਸੀਂ ਜਾਵਾ ਐਨੋਟੇਸ਼ਨਾਂ ਲਈ ਇੱਕ ਵਾਧੂ ਕੰਪਾਈਲਰ ਵੀ ਜੋੜ ਸਕਦੇ ਹੋ, ਫਿਰ ਉਹਨਾਂ ਨੂੰ ਹਰ ਜਗ੍ਹਾ ਕੰਮ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।
• ਪੁਰਾਣੇ ਸਪਰਿੰਗ ਅਤੇ ਸਪਰਿੰਗ ਬੂਟ ਵਿੱਚ, 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. Const ਜੋ ਸਾਰੇ ਟਰੇਸ ਭੇਜਦਾ ਅਤੇ ਸੁਰੱਖਿਅਤ ਕਰਦਾ ਹੈ।
2. ਸੰਭਾਵੀ ਜੋ ਕੁਝ ਦਿੱਤੀ ਗਈ ਸੰਭਾਵਨਾ ਨਾਲ ਟਰੇਸ ਨੂੰ ਫਿਲਟਰ ਕਰਦਾ ਹੈ।
3. ਰੇਟ ਸੀਮਿਤ ਕਰਨਾ ਜੋ ਪ੍ਰਤੀ ਸਕਿੰਟ ਟਰੇਸ ਦੀ ਸੰਖਿਆ ਨੂੰ ਸੀਮਿਤ ਕਰਦਾ ਹੈ। ਤੁਸੀਂ ਇਹਨਾਂ ਸੈਟਿੰਗਾਂ ਨੂੰ ਕਲਾਇੰਟ 'ਤੇ ਕੌਂਫਿਗਰ ਕਰ ਸਕਦੇ ਹੋ, ਜਾਂ ਤਾਂ ਜੈਗਰ-ਏਜੰਟ ਜਾਂ ਕੁਲੈਕਟਰ 'ਤੇ। ਹੁਣ ਅਸੀਂ ਵੈਲਯੂਏਟਰ ਸਟੈਕ ਵਿੱਚ const 1 ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ, ਕਿਉਂਕਿ ਇੱਥੇ ਬਹੁਤ ਸਾਰੀਆਂ ਬੇਨਤੀਆਂ ਨਹੀਂ ਹਨ, ਪਰ ਉਹਨਾਂ ਨੂੰ ਬਹੁਤ ਸਮਾਂ ਲੱਗਦਾ ਹੈ। ਭਵਿੱਖ ਵਿੱਚ, ਜੇਕਰ ਇਹ ਸਿਸਟਮ ਉੱਤੇ ਬਹੁਤ ਜ਼ਿਆਦਾ ਲੋਡ ਕਰੇਗਾ, ਤਾਂ ਤੁਸੀਂ ਇਸਨੂੰ ਸੀਮਤ ਕਰ ਸਕਦੇ ਹੋ।

ਜੇ ਤੁਸੀਂ ਕੈਸੈਂਡਰਾ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਤਾਂ ਮੂਲ ਰੂਪ ਵਿੱਚ ਇਹ ਸਿਰਫ ਦੋ ਦਿਨਾਂ ਲਈ ਟਰੇਸ ਸਟੋਰ ਕਰਦਾ ਹੈ. ਅਸੀਂ ਵਰਤ ਰਹੇ ਹਾਂ ਲਚਕੀਲਾ ਅਤੇ ਟਰੇਸ ਹਰ ਸਮੇਂ ਲਈ ਸਟੋਰ ਕੀਤੇ ਜਾਂਦੇ ਹਨ ਅਤੇ ਮਿਟਾਏ ਨਹੀਂ ਜਾਂਦੇ। ਹਰ ਦਿਨ ਲਈ ਇੱਕ ਵੱਖਰਾ ਸੂਚਕਾਂਕ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ, ਉਦਾਹਰਨ ਲਈ jaeger-service-2019-03-04। ਭਵਿੱਖ ਵਿੱਚ, ਤੁਹਾਨੂੰ ਪੁਰਾਣੇ ਟਰੇਸ ਦੀ ਆਟੋਮੈਟਿਕ ਸਫਾਈ ਦੀ ਸੰਰਚਨਾ ਕਰਨ ਦੀ ਲੋੜ ਹੈ.

ਤੁਹਾਨੂੰ ਲੋੜੀਂਦੇ ਨਿਸ਼ਾਨਾਂ ਨੂੰ ਵੇਖਣ ਲਈ:

• ਉਹ ਸੇਵਾ ਚੁਣੋ ਜਿਸ ਦੁਆਰਾ ਤੁਸੀਂ ਟਰੇਸ ਨੂੰ ਫਿਲਟਰ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਉਦਾਹਰਨ ਲਈ, tomcat7-ਡਿਫਾਲਟ ਅਜਿਹੀ ਸੇਵਾ ਲਈ ਜੋ ਟੋਮਕੈਟ ਵਿੱਚ ਚੱਲ ਰਹੀ ਹੈ ਅਤੇ ਇਸਦਾ ਆਪਣਾ ਨਾਮ ਨਹੀਂ ਹੈ।
• ਫਿਰ ਓਪਰੇਸ਼ਨ, ਸਮਾਂ ਅੰਤਰਾਲ ਅਤੇ ਘੱਟੋ-ਘੱਟ ਓਪਰੇਸ਼ਨ ਸਮਾਂ ਚੁਣੋ, ਉਦਾਹਰਨ ਲਈ 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 ਅਤੇ ਗੋਲੰਗ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਜੈਗਰ ਓਪਨਟਰੇਸਿੰਗ ਅਤੇ ਮਾਈਕ੍ਰੋ ਸਰਵਿਸਿਜ਼
• 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