ಸರ್ವಿಸ್ ಟ್ರೇಸಿಂಗ್, ಓಪನ್ ಟ್ರೇಸಿಂಗ್ ಮತ್ತು ಜೇಗರ್

ನಾವು ನಮ್ಮ ಯೋಜನೆಗಳಲ್ಲಿ ಮೈಕ್ರೋ ಸರ್ವೀಸ್ ಆರ್ಕಿಟೆಕ್ಚರ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ. ಕಾರ್ಯಕ್ಷಮತೆಯ ಅಡಚಣೆಗಳು ಸಂಭವಿಸಿದಾಗ, ಲಾಗ್‌ಗಳನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲು ಮತ್ತು ಪಾರ್ಸಿಂಗ್ ಮಾಡಲು ಸಾಕಷ್ಟು ಸಮಯವನ್ನು ಕಳೆಯಲಾಗುತ್ತದೆ. ಲಾಗ್ ಫೈಲ್‌ಗೆ ವೈಯಕ್ತಿಕ ಕಾರ್ಯಾಚರಣೆಗಳ ಸಮಯವನ್ನು ಲಾಗ್ ಮಾಡುವಾಗ, ಈ ಕಾರ್ಯಾಚರಣೆಗಳ ಆವಾಹನೆಗೆ ಕಾರಣವೇನು ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಸಾಮಾನ್ಯವಾಗಿ ಕಷ್ಟಕರವಾಗಿರುತ್ತದೆ, ಕ್ರಿಯೆಗಳ ಅನುಕ್ರಮವನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುವುದು ಅಥವಾ ವಿಭಿನ್ನ ಸೇವೆಗಳಲ್ಲಿ ಇನ್ನೊಂದಕ್ಕೆ ಹೋಲಿಸಿದರೆ ಒಂದು ಕಾರ್ಯಾಚರಣೆಯ ಸಮಯ ಬದಲಾವಣೆ.

ಹಸ್ತಚಾಲಿತ ಶ್ರಮವನ್ನು ಕಡಿಮೆ ಮಾಡಲು, ನಾವು ಪತ್ತೆಹಚ್ಚುವ ಸಾಧನಗಳಲ್ಲಿ ಒಂದನ್ನು ಬಳಸಲು ನಿರ್ಧರಿಸಿದ್ದೇವೆ. ಹೇಗೆ ಮತ್ತು ಏಕೆ ನೀವು ಟ್ರೇಸಿಂಗ್ ಅನ್ನು ಬಳಸಬಹುದು ಮತ್ತು ನಾವು ಅದನ್ನು ಹೇಗೆ ಮಾಡಿದ್ದೇವೆ ಎಂಬುದರ ಕುರಿತು ಮತ್ತು ಈ ಲೇಖನದಲ್ಲಿ ಚರ್ಚಿಸಲಾಗುವುದು.

ಟ್ರೇಸಿಂಗ್ ಮೂಲಕ ಯಾವ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಬಹುದು

1. ಒಂದೇ ಸೇವೆಯೊಳಗೆ ಮತ್ತು ಎಲ್ಲಾ ಭಾಗವಹಿಸುವ ಸೇವೆಗಳ ನಡುವೆ ಸಂಪೂರ್ಣ ಕಾರ್ಯಗತಗೊಳಿಸುವ ವೃಕ್ಷದಲ್ಲಿ ಕಾರ್ಯಕ್ಷಮತೆಯ ಅಡಚಣೆಗಳನ್ನು ಹುಡುಕಿ. ಉದಾಹರಣೆಗೆ:
   • ಸೇವೆಗಳ ನಡುವೆ ಹಲವಾರು ಸಣ್ಣ ಸತತ ಕರೆಗಳು, ಉದಾಹರಣೆಗೆ, ಜಿಯೋಕೋಡಿಂಗ್ ಅಥವಾ ಡೇಟಾಬೇಸ್‌ಗೆ.
   • ನೆಟ್‌ವರ್ಕ್ ವರ್ಗಾವಣೆಗಳು ಅಥವಾ ಡಿಸ್ಕ್ ರೀಡ್‌ಗಳಂತಹ ದೀರ್ಘ I/O ಕಾಯುವಿಕೆಗಳು.
   • ದೀರ್ಘ ಡೇಟಾ ಪಾರ್ಸಿಂಗ್.
   • ಸಿಪಿಯು ಅಗತ್ಯವಿರುವ ದೀರ್ಘ ಕಾರ್ಯಾಚರಣೆಗಳು.
   • ಅಂತಿಮ ಫಲಿತಾಂಶವನ್ನು ಪಡೆಯಲು ಅಗತ್ಯವಿಲ್ಲದ ಮತ್ತು ತೆಗೆದುಹಾಕಬಹುದಾದ ಅಥವಾ ವಿಳಂಬಗೊಳಿಸಬಹುದಾದ ಕೋಡ್‌ನ ವಿಭಾಗಗಳು.
2. ಕಾರ್ಯಾಚರಣೆಯನ್ನು ನಡೆಸಿದಾಗ ಯಾವ ಅನುಕ್ರಮದಲ್ಲಿ ಕರೆಯಲಾಗುತ್ತದೆ ಮತ್ತು ಏನಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ.
   
   ಉದಾಹರಣೆಗೆ, ವಿನಂತಿಯು WS ಸೇವೆಗೆ ಬಂದಿದೆ ಎಂದು ನೋಡಬಹುದು -> WS ಸೇವೆಯು R ಸೇವೆಯ ಮೂಲಕ ಡೇಟಾವನ್ನು ಸೇರಿಸಿತು -> ನಂತರ V ಸೇವೆಗೆ ವಿನಂತಿಯನ್ನು ಕಳುಹಿಸಲಾಗಿದೆ -> V ಸೇವೆಯು R ನಿಂದ ಬಹಳಷ್ಟು ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡಿದೆ ಸೇವೆ -> P ಸೇವೆಗೆ ಹೋಯಿತು -> P ಸೇವೆ ಮತ್ತೆ ಸೇವೆಗೆ ಹೋಯಿತು R -> ಸೇವೆ V ಫಲಿತಾಂಶವನ್ನು ನಿರ್ಲಕ್ಷಿಸಿ ಮತ್ತು ಸೇವೆ J -> ಗೆ ಹೋಯಿತು ಮತ್ತು ನಂತರ ಮಾತ್ರ WS ಸೇವೆಗೆ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸಿತು, ಆದರೆ ಬೇರೆ ಯಾವುದನ್ನಾದರೂ ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದನ್ನು ಮುಂದುವರೆಸಿದೆ ಹಿನ್ನೆಲೆ.
   ಸಂಪೂರ್ಣ ಪ್ರಕ್ರಿಯೆಗೆ ಅಂತಹ ಜಾಡಿನ ಅಥವಾ ವಿವರವಾದ ದಾಖಲಾತಿ ಇಲ್ಲದೆ, ನೀವು ಮೊದಲ ಬಾರಿಗೆ ಕೋಡ್ ಅನ್ನು ನೋಡಿದಾಗ ಏನಾಗುತ್ತಿದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ತುಂಬಾ ಕಷ್ಟ, ಮತ್ತು ಕೋಡ್ ವಿವಿಧ ಸೇವೆಗಳಲ್ಲಿ ಹರಡಿರುತ್ತದೆ ಮತ್ತು ಬಿನ್‌ಗಳು ಮತ್ತು ಇಂಟರ್ಫೇಸ್‌ಗಳ ಗುಂಪಿನ ಹಿಂದೆ ಮರೆಮಾಡಲಾಗಿದೆ.
3. ನಂತರದ ಮುಂದೂಡಲ್ಪಟ್ಟ ವಿಶ್ಲೇಷಣೆಗಾಗಿ ಮರಣದಂಡನೆಯ ಮರದ ಬಗ್ಗೆ ಮಾಹಿತಿಯ ಸಂಗ್ರಹ. ಮರಣದಂಡನೆಯ ಪ್ರತಿ ಹಂತದಲ್ಲಿ, ಈ ಹಂತದಲ್ಲಿ ಲಭ್ಯವಿರುವ ಜಾಡಿನ ಮಾಹಿತಿಯನ್ನು ನೀವು ಸೇರಿಸಬಹುದು ಮತ್ತು ನಂತರ ಯಾವ ಇನ್ಪುಟ್ ಡೇಟಾ ಇದೇ ರೀತಿಯ ಸನ್ನಿವೇಶಕ್ಕೆ ಕಾರಣವಾಯಿತು ಎಂಬುದನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಬಹುದು. ಉದಾಹರಣೆಗೆ:
   • ಬಳಕೆದಾರರ ಗುರುತು
   • ಹಕ್ಕುಗಳು
   • ಆಯ್ದ ವಿಧಾನದ ಪ್ರಕಾರ
   • ಲಾಗ್ ಅಥವಾ ಎಕ್ಸಿಕ್ಯೂಶನ್ ದೋಷ
4. ಕುರುಹುಗಳನ್ನು ಮೆಟ್ರಿಕ್‌ಗಳ ಉಪವಿಭಾಗವಾಗಿ ಪರಿವರ್ತಿಸುವುದು ಮತ್ತು ಈಗಾಗಲೇ ಮೆಟ್ರಿಕ್‌ಗಳ ರೂಪದಲ್ಲಿ ಮತ್ತಷ್ಟು ವಿಶ್ಲೇಷಣೆ.

ಯಾವ ಟ್ರೇಸ್ ಲಾಗ್ ಮಾಡಬಹುದು. ಸ್ಪ್ಯಾನ್

ಟ್ರೇಸಿಂಗ್‌ನಲ್ಲಿ ಸ್ಪ್ಯಾನ್‌ನ ಪರಿಕಲ್ಪನೆ ಇದೆ, ಇದು ಕನ್ಸೋಲ್‌ಗೆ ಒಂದು ಲಾಗ್‌ನ ಅನಲಾಗ್ ಆಗಿದೆ. ಸ್ಪಾ ಹೊಂದಿದೆ:

• ಹೆಸರು, ಸಾಮಾನ್ಯವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಿದ ವಿಧಾನದ ಹೆಸರು
• ಸ್ಪ್ಯಾನ್ ಅನ್ನು ರಚಿಸಲಾದ ಸೇವೆಯ ಹೆಸರು
• ಸ್ವಂತ ಅನನ್ಯ ID
• ಅದರಲ್ಲಿ ಲಾಗ್ ಇನ್ ಆಗಿರುವ ಕೀ/ಮೌಲ್ಯದ ರೂಪದಲ್ಲಿ ಕೆಲವು ರೀತಿಯ ಮೆಟಾ ಮಾಹಿತಿ. ಉದಾಹರಣೆಗೆ, ವಿಧಾನದ ನಿಯತಾಂಕಗಳು ಅಥವಾ ವಿಧಾನವು ದೋಷದೊಂದಿಗೆ ಕೊನೆಗೊಂಡಿದೆ ಅಥವಾ ಇಲ್ಲ
• ಈ ಅವಧಿಗೆ ಪ್ರಾರಂಭ ಮತ್ತು ಅಂತಿಮ ಸಮಯ
• ಪೋಷಕ ಸ್ಪ್ಯಾನ್ ಐಡಿ

ಪ್ರತಿ ಸ್ಪ್ಯಾನ್ ಅನ್ನು ಅದರ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ ತಕ್ಷಣ ನಂತರದ ಪರಿಶೀಲನೆಗಾಗಿ ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲು ಸ್ಪ್ಯಾನ್ ಕಲೆಕ್ಟರ್‌ಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ. ಭವಿಷ್ಯದಲ್ಲಿ, ಪೋಷಕ ಐಡಿ ಮೂಲಕ ಸಂಪರ್ಕಿಸುವ ಮೂಲಕ ನೀವು ಎಲ್ಲಾ ವ್ಯಾಪ್ತಿಯ ಮರವನ್ನು ನಿರ್ಮಿಸಬಹುದು. ವಿಶ್ಲೇಷಿಸುವಾಗ, ನೀವು ಕೆಲವು ಸೇವೆಯಲ್ಲಿನ ಎಲ್ಲಾ ವ್ಯಾಪ್ತಿಯನ್ನು ಕಂಡುಹಿಡಿಯಬಹುದು, ಅದು ಸ್ವಲ್ಪ ಸಮಯಕ್ಕಿಂತ ಹೆಚ್ಚು ಸಮಯ ತೆಗೆದುಕೊಂಡಿತು. ಮುಂದೆ, ನಿರ್ದಿಷ್ಟ ಸ್ಪ್ಯಾನ್‌ಗೆ ಹೋಗುವ ಮೂಲಕ, ಈ ಸ್ಪ್ಯಾನ್‌ನ ಮೇಲೆ ಮತ್ತು ಕೆಳಗಿನ ಸಂಪೂರ್ಣ ಮರವನ್ನು ನೋಡಿ.

ಓಪನ್‌ಟ್ರೇಸ್, ಜಾಗರ್ ಮತ್ತು ನಮ್ಮ ಯೋಜನೆಗಳಿಗಾಗಿ ನಾವು ಅದನ್ನು ಹೇಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಿದ್ದೇವೆ

ಸಾಮಾನ್ಯ ಮಾನದಂಡವಿದೆ ತೆರೆದ ಜಾಡು, ಯಾವುದೇ ಭಾಷೆಯಲ್ಲಿನ ನಿರ್ದಿಷ್ಟ ಅನುಷ್ಠಾನವನ್ನು ಪತ್ತೆಹಚ್ಚುವ ಮೂಲಕ ಹೇಗೆ ಮತ್ತು ಏನನ್ನು ಸಂಗ್ರಹಿಸಬೇಕು ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಜಾವಾದಲ್ಲಿ, ಜಾವಾದಲ್ಲಿ, ಸಾಮಾನ್ಯ ಓಪನ್ಟ್ರೇಸ್ API ಮೂಲಕ ಎಲ್ಲಾ ಕೆಲಸಗಳನ್ನು ಕೈಗೊಳ್ಳಲಾಗುತ್ತದೆ ಮತ್ತು ಅದರ ಅಡಿಯಲ್ಲಿ, ಉದಾಹರಣೆಗೆ, ಜೇಗರ್ ಅಥವಾ ಏನನ್ನೂ ಮಾಡದ ಖಾಲಿ ಡೀಫಾಲ್ಟ್ ಅನುಷ್ಠಾನವನ್ನು ಮರೆಮಾಡಬಹುದು.
ನಾವು ಬಳಸುತ್ತಿದ್ದೇವೆ ಜೇಗರ್ ಓಪನ್‌ಟ್ರೇಸ್‌ನ ಅಳವಡಿಕೆಯಾಗಿ. ಇದು ಹಲವಾರು ಘಟಕಗಳನ್ನು ಒಳಗೊಂಡಿದೆ:

• ಜೇಗರ್-ಏಜೆಂಟ್ ಸ್ಥಳೀಯ ಏಜೆಂಟ್ ಆಗಿದ್ದು, ಇದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಪ್ರತಿ ಗಣಕದಲ್ಲಿ ಸ್ಥಾಪಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಸೇವೆಗಳನ್ನು ಸ್ಥಳೀಯ ಡೀಫಾಲ್ಟ್ ಪೋರ್ಟ್‌ನಲ್ಲಿ ಲಾಗ್ ಇನ್ ಮಾಡಲಾಗುತ್ತದೆ. ಯಾವುದೇ ಏಜೆಂಟ್ ಇಲ್ಲದಿದ್ದರೆ, ಈ ಯಂತ್ರದಲ್ಲಿನ ಎಲ್ಲಾ ಸೇವೆಗಳ ಕುರುಹುಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಲಾಗುತ್ತದೆ
• ಜೇಗರ್-ಸಂಗ್ರಾಹಕ - ಎಲ್ಲಾ ಏಜೆಂಟ್‌ಗಳು ಅದಕ್ಕೆ ಸಂಗ್ರಹಿಸಿದ ಕುರುಹುಗಳನ್ನು ಕಳುಹಿಸುತ್ತಾರೆ ಮತ್ತು ಅದು ಅವುಗಳನ್ನು ಆಯ್ದ ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಇರಿಸುತ್ತದೆ
• ಡೇಟಾಬೇಸ್ ಅವರ ಆದ್ಯತೆಯ ಕಸ್ಸಂದ್ರವಾಗಿದೆ, ಆದರೆ ನಾವು ಸ್ಥಿತಿಸ್ಥಾಪಕ ಹುಡುಕಾಟವನ್ನು ಬಳಸುತ್ತೇವೆ, ಒಂದೆರಡು ಇತರ ಡೇಟಾಬೇಸ್‌ಗಳಿಗೆ ಅಳವಡಿಕೆಗಳು ಮತ್ತು ಡಿಸ್ಕ್‌ಗೆ ಏನನ್ನೂ ಉಳಿಸದ ಇನ್-ಮೆಮೊರಿ ಅನುಷ್ಠಾನವಿದೆ.
• ಜೇಗರ್-ಕ್ವೆರಿ ಎಂಬುದು ಡೇಟಾಬೇಸ್‌ಗೆ ಹೋಗುವ ಸೇವೆಯಾಗಿದೆ ಮತ್ತು ವಿಶ್ಲೇಷಣೆಗಾಗಿ ಈಗಾಗಲೇ ಸಂಗ್ರಹಿಸಿದ ಕುರುಹುಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ
• Jaeger-ui ಜಾಡುಗಳನ್ನು ಹುಡುಕಲು ಮತ್ತು ವೀಕ್ಷಿಸಲು ವೆಬ್ ಇಂಟರ್ಫೇಸ್ ಆಗಿದೆ, ಇದು jaeger-query ಗೆ ಹೋಗುತ್ತದೆ

ಒಂದು ಪ್ರತ್ಯೇಕ ಘಟಕವನ್ನು ನಿರ್ದಿಷ್ಟ ಭಾಷೆಗಳಿಗೆ ಓಪನ್‌ಟ್ರೇಸ್ ಜೇಗರ್‌ನ ಅನುಷ್ಠಾನ ಎಂದು ಕರೆಯಬಹುದು, ಅದರ ಮೂಲಕ ಸ್ಪ್ಯಾನ್‌ಗಳನ್ನು ಜೇಗರ್-ಏಜೆಂಟ್‌ಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ.
ಜಾವಾದಲ್ಲಿ ಜಾಗರ್ ಅನ್ನು ಸಂಪರ್ಕಿಸಲಾಗುತ್ತಿದೆ io.opentracing.Tracer ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಕೆಳಗೆ ಬರುತ್ತದೆ, ಅದರ ಮೂಲಕ ಎಲ್ಲಾ ಕುರುಹುಗಳು ನಿಜವಾದ ಏಜೆಂಟ್ಗೆ ಹಾರುತ್ತವೆ.

ವಸಂತ ಘಟಕಕ್ಕಾಗಿ, ನೀವು ಸಂಪರ್ಕಿಸಬಹುದು ಓಪನ್ಟ್ರೇಸಿಂಗ್-ಸ್ಪ್ರಿಂಗ್-ಕ್ಲೌಡ್-ಸ್ಟಾರ್ಟರ್ ಮತ್ತು ಜೇಗರ್ ಅವರಿಂದ ಅನುಷ್ಠಾನ ಓಪನ್ಟ್ರೇಸಿಂಗ್-ಸ್ಪ್ರಿಂಗ್-ಜೇಗರ್-ಕ್ಲೌಡ್-ಸ್ಟಾರ್ಟರ್ ಈ ಘಟಕಗಳ ಮೂಲಕ ಹಾದುಹೋಗುವ ಎಲ್ಲದಕ್ಕೂ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪತ್ತೆಹಚ್ಚುವಿಕೆಯನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುತ್ತದೆ, ಉದಾಹರಣೆಗೆ ನಿಯಂತ್ರಕಗಳಿಗೆ http ವಿನಂತಿಗಳು, jdbc ಮೂಲಕ ಡೇಟಾಬೇಸ್‌ಗೆ ವಿನಂತಿಗಳು, ಇತ್ಯಾದಿ.

ಜಾವಾದಲ್ಲಿ ಟ್ರೇಸ್ ಲಾಗಿಂಗ್

ಎಲ್ಲೋ ಉನ್ನತ ಮಟ್ಟದಲ್ಲಿ, ಮೊದಲ ಸ್ಪ್ಯಾನ್ ಅನ್ನು ರಚಿಸಬೇಕು, ಇದನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮಾಡಬಹುದು, ಉದಾಹರಣೆಗೆ, ವಿನಂತಿಯನ್ನು ಸ್ವೀಕರಿಸಿದಾಗ ಸ್ಪ್ರಿಂಗ್ ನಿಯಂತ್ರಕದಿಂದ ಅಥವಾ ಯಾವುದೂ ಇಲ್ಲದಿದ್ದರೆ ಹಸ್ತಚಾಲಿತವಾಗಿ. ನಂತರ ಕೆಳಗಿನ ಸ್ಕೋಪ್ ಮೂಲಕ ಹರಡುತ್ತದೆ. ಕೆಳಗಿನ ಯಾವುದೇ ವಿಧಾನಗಳು ಸ್ಪ್ಯಾನ್ ಅನ್ನು ಸೇರಿಸಲು ಬಯಸಿದರೆ, ಇದು ಸ್ಕೋಪ್‌ನಿಂದ ಪ್ರಸ್ತುತ ಆಕ್ಟೀವ್‌ಸ್ಪ್ಯಾನ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಹೊಸ ಸ್ಪ್ಯಾನ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ ಮತ್ತು ಅದರ ಮೂಲವು ಆಕ್ಟಿವ್‌ಸ್ಪ್ಯಾನ್ ಎಂದು ಹೇಳುತ್ತದೆ ಮತ್ತು ಹೊಸ ಸ್ಪ್ಯಾನ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. ಬಾಹ್ಯ ಸೇವೆಗಳಿಗೆ ಕರೆ ಮಾಡುವಾಗ, ಪ್ರಸ್ತುತ ಸಕ್ರಿಯ ವ್ಯಾಪ್ತಿಯನ್ನು ಅವರಿಗೆ ರವಾನಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಆ ಸೇವೆಗಳು ಈ ವ್ಯಾಪ್ತಿಯನ್ನು ಉಲ್ಲೇಖಿಸಿ ಹೊಸ ವ್ಯಾಪ್ತಿಯನ್ನು ರಚಿಸುತ್ತವೆ.
ಎಲ್ಲಾ ಕೆಲಸಗಳು ಟ್ರೇಸರ್ ನಿದರ್ಶನದ ಮೂಲಕ ಹೋಗುತ್ತದೆ, ನೀವು ಅದನ್ನು DI ಕಾರ್ಯವಿಧಾನದ ಮೂಲಕ ಪಡೆಯಬಹುದು ಅಥವಾ DI ಕಾರ್ಯವಿಧಾನವು ಕಾರ್ಯನಿರ್ವಹಿಸದಿದ್ದರೆ GlobalTracer.get () ಅನ್ನು ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಆಗಿ ಪಡೆಯಬಹುದು. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಟ್ರೇಸರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸದಿದ್ದರೆ, ನೂಪ್ಟ್ರೇಸರ್ ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಅದು ಏನನ್ನೂ ಮಾಡುವುದಿಲ್ಲ.
ಇದಲ್ಲದೆ, ಸ್ಕೋಪ್‌ಮ್ಯಾನೇಜರ್ ಮೂಲಕ ಟ್ರೇಸರ್‌ನಿಂದ ಪ್ರಸ್ತುತ ವ್ಯಾಪ್ತಿಯನ್ನು ಪಡೆಯಲಾಗುತ್ತದೆ, ಹೊಸ ಸ್ಪ್ಯಾನ್‌ನ ಬೈಂಡಿಂಗ್‌ನೊಂದಿಗೆ ಪ್ರಸ್ತುತದಿಂದ ಹೊಸ ಸ್ಕೋಪ್ ಅನ್ನು ರಚಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ನಂತರ ರಚಿಸಿದ ಸ್ಕೋಪ್ ಅನ್ನು ಮುಚ್ಚಲಾಗುತ್ತದೆ, ಅದು ರಚಿಸಿದ ವ್ಯಾಪ್ತಿಯನ್ನು ಮುಚ್ಚುತ್ತದೆ ಮತ್ತು ಹಿಂದಿನ ಸ್ಕೋಪ್ ಅನ್ನು ಸಕ್ರಿಯ ಸ್ಥಿತಿಗೆ ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಸ್ಕೋಪ್ ಅನ್ನು ಥ್ರೆಡ್‌ಗೆ ಕಟ್ಟಲಾಗಿದೆ, ಆದ್ದರಿಂದ ಮಲ್ಟಿ-ಥ್ರೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮಾಡುವಾಗ, ಈ ಸ್ಪ್ಯಾನ್ ಅನ್ನು ಉಲ್ಲೇಖಿಸಿ ಮತ್ತೊಂದು ಥ್ರೆಡ್‌ನ ಸ್ಕೋಪ್ ಅನ್ನು ಮತ್ತಷ್ಟು ಸಕ್ರಿಯಗೊಳಿಸಲು ಸಕ್ರಿಯ ಸ್ಪ್ಯಾನ್ ಅನ್ನು ಮತ್ತೊಂದು ಥ್ರೆಡ್‌ಗೆ ವರ್ಗಾಯಿಸಲು ನೀವು ಮರೆಯಬಾರದು.

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)) {
                ...
            }
        });
    }
}

ಬಹು-ಥ್ರೆಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ಗಾಗಿ, ಅಸಮಕಾಲಿಕ ಕಾರ್ಯಗಳನ್ನು ಪ್ರಾರಂಭಿಸಿದಾಗ ಥ್ರೆಡ್‌ಗೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪ್ರಸ್ತುತ ಸ್ಪ್ಯಾನ್ ಅನ್ನು ರವಾನಿಸುವ ಟ್ರೇಸ್ಡ್ ಎಕ್ಸಿಕ್ಯೂಟರ್ ಸರ್ವಿಸ್ ಮತ್ತು ಅಂತಹುದೇ ಹೊದಿಕೆಗಳು ಸಹ ಇವೆ:

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

ಬಾಹ್ಯ http ವಿನಂತಿಗಳಿಗಾಗಿ ಇದೆ TracingHttpClient

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

ನಾವು ಎದುರಿಸಿದ ಸಮಸ್ಯೆಗಳು

• ಟ್ರೇಸರ್ ಅನ್ನು ಸೇವೆ ಅಥವಾ ಘಟಕದಲ್ಲಿ ಬಳಸದಿದ್ದರೆ ಬೀನ್ಸ್ ಮತ್ತು DI ಯಾವಾಗಲೂ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ ಆಟೋವೈರ್ಡ್ ಟ್ರೇಸರ್ ಕೆಲಸ ಮಾಡದಿರಬಹುದು ಮತ್ತು ನೀವು GlobalTracer.get() ಅನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ.
• ಇದು ಒಂದು ಘಟಕ ಅಥವಾ ಸೇವೆಯಾಗಿಲ್ಲದಿದ್ದರೆ ಅಥವಾ ಅದೇ ವರ್ಗದ ನೆರೆಯ ವಿಧಾನದಿಂದ ವಿಧಾನವನ್ನು ಕರೆದರೆ ಟಿಪ್ಪಣಿಗಳು ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ. ಏನು ಕೆಲಸ ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸಲು ನೀವು ಜಾಗರೂಕರಾಗಿರಬೇಕು ಮತ್ತು @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 ಅನ್ನು ಹೊಂದಿರಬೇಕು, ಅದರ ಅಡಿಯಲ್ಲಿ ಟ್ರೇಸ್‌ಗಳನ್ನು ಲಾಗ್ ಮಾಡಲಾಗುತ್ತದೆ. ಮಾರಾಟ ಮತ್ತು ಪರೀಕ್ಷೆಗೆ ಪ್ರತ್ಯೇಕ ಹೆಸರು ಏನು, ಆದ್ದರಿಂದ ಅವುಗಳನ್ನು ಒಟ್ಟಿಗೆ ಹಸ್ತಕ್ಷೇಪ ಮಾಡುವುದಿಲ್ಲ.
• ನೀವು ಗ್ಲೋಬಲ್‌ಟ್ರೇಸರ್ ಮತ್ತು ಟಾಮ್‌ಕ್ಯಾಟ್ ಅನ್ನು ಬಳಸಿದರೆ, ಈ ಟಾಮ್‌ಕ್ಯಾಟ್‌ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಎಲ್ಲಾ ಸೇವೆಗಳು ಒಂದು ಗ್ಲೋಬಲ್‌ಟ್ರೇಸರ್ ಅನ್ನು ಹೊಂದಿರುತ್ತವೆ, ಆದ್ದರಿಂದ ಅವುಗಳು ಒಂದೇ ರೀತಿಯ ಸೇವೆಯ ಹೆಸರನ್ನು ಹೊಂದಿರುತ್ತವೆ.
• ಒಂದು ವಿಧಾನಕ್ಕೆ ಕುರುಹುಗಳನ್ನು ಸೇರಿಸುವಾಗ, ಅದನ್ನು ಲೂಪ್ನಲ್ಲಿ ಹಲವು ಬಾರಿ ಕರೆಯಲಾಗುವುದಿಲ್ಲ ಎಂದು ನೀವು ಖಚಿತವಾಗಿ ತಿಳಿದುಕೊಳ್ಳಬೇಕು. ಎಲ್ಲಾ ಕರೆಗಳಿಗೆ ಒಂದು ಸಾಮಾನ್ಯ ಜಾಡನ್ನು ಸೇರಿಸುವುದು ಅವಶ್ಯಕ, ಇದು ಒಟ್ಟು ಕೆಲಸದ ಸಮಯವನ್ನು ಖಾತರಿಪಡಿಸುತ್ತದೆ. ಇಲ್ಲದಿದ್ದರೆ, ಹೆಚ್ಚುವರಿ ಲೋಡ್ ಅನ್ನು ರಚಿಸಲಾಗುತ್ತದೆ.
• ಒಮ್ಮೆ jaeger-ui ನಲ್ಲಿ, ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ಕುರುಹುಗಳಿಗಾಗಿ ತುಂಬಾ ದೊಡ್ಡ ವಿನಂತಿಗಳನ್ನು ಮಾಡಲಾಯಿತು ಮತ್ತು ಅವರು ಪ್ರತಿಕ್ರಿಯೆಗಾಗಿ ಕಾಯದ ಕಾರಣ, ಅವರು ಅದನ್ನು ಮತ್ತೆ ಮಾಡಿದರು. ಪರಿಣಾಮವಾಗಿ, ಜೇಗರ್-ಕ್ವೆರಿ ಬಹಳಷ್ಟು ಸ್ಮರಣೆಯನ್ನು ತಿನ್ನಲು ಪ್ರಾರಂಭಿಸಿತು ಮತ್ತು ಸ್ಥಿತಿಸ್ಥಾಪಕತ್ವವನ್ನು ನಿಧಾನಗೊಳಿಸಿತು. jaeger-query ಅನ್ನು ಮರುಪ್ರಾರಂಭಿಸುವ ಮೂಲಕ ಸಹಾಯ ಮಾಡಲಾಗಿದೆ

ಕುರುಹುಗಳನ್ನು ಮಾದರಿ ಮಾಡುವುದು, ಸಂಗ್ರಹಿಸುವುದು ಮತ್ತು ವೀಕ್ಷಿಸುವುದು

ಮೂರು ವಿಧಗಳಿವೆ ಮಾದರಿ ಕುರುಹುಗಳು:

1. ಎಲ್ಲಾ ಕುರುಹುಗಳನ್ನು ಕಳುಹಿಸುವ ಮತ್ತು ಉಳಿಸುವ ಕಾನ್ಸ್ಟ್.
2. ಕೆಲವು ನಿರ್ದಿಷ್ಟ ಸಂಭವನೀಯತೆಯೊಂದಿಗೆ ಕುರುಹುಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುವ ಸಂಭವನೀಯತೆ.
3. ಪ್ರತಿ ಸೆಕೆಂಡಿಗೆ ಕುರುಹುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಮಿತಿಗೊಳಿಸುವ ರೇಟೆಲಿಮಿಟಿಂಗ್. ನೀವು ಈ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಕ್ಲೈಂಟ್‌ನಲ್ಲಿ, ಜೇಗರ್-ಏಜೆಂಟ್‌ನಲ್ಲಿ ಅಥವಾ ಕಲೆಕ್ಟರ್‌ನಲ್ಲಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದು. ಈಗ ನಾವು ಮೌಲ್ಯಮಾಪಕ ಸ್ಟಾಕ್‌ನಲ್ಲಿ const 1 ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಏಕೆಂದರೆ ಹೆಚ್ಚಿನ ವಿನಂತಿಗಳಿಲ್ಲ, ಆದರೆ ಅವು ಬಹಳ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತವೆ. ಭವಿಷ್ಯದಲ್ಲಿ, ಇದು ಸಿಸ್ಟಮ್ನಲ್ಲಿ ಅತಿಯಾದ ಲೋಡ್ ಅನ್ನು ಉಂಟುಮಾಡಿದರೆ, ನೀವು ಅದನ್ನು ಮಿತಿಗೊಳಿಸಬಹುದು.

ನೀವು ಕಸ್ಸಂದ್ರವನ್ನು ಬಳಸಿದರೆ, ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಅದು ಕೇವಲ ಎರಡು ದಿನಗಳವರೆಗೆ ಕುರುಹುಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ. ನಾವು ಬಳಸುತ್ತಿದ್ದೇವೆ ಸ್ಥಿತಿಸ್ಥಾಪಕ ಹುಡುಕಾಟ ಮತ್ತು ಕುರುಹುಗಳನ್ನು ಎಲ್ಲಾ ಸಮಯದಲ್ಲೂ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಅಳಿಸಲಾಗುವುದಿಲ್ಲ. ಪ್ರತಿ ದಿನಕ್ಕೆ ಪ್ರತ್ಯೇಕ ಸೂಚಿಯನ್ನು ರಚಿಸಲಾಗಿದೆ, ಉದಾಹರಣೆಗೆ jaeger-service-2019-03-04. ಭವಿಷ್ಯದಲ್ಲಿ, ಹಳೆಯ ಕುರುಹುಗಳ ಸ್ವಯಂಚಾಲಿತ ಶುಚಿಗೊಳಿಸುವಿಕೆಯನ್ನು ನೀವು ಕಾನ್ಫಿಗರ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ.

ನಿಮಗೆ ಅಗತ್ಯವಿರುವ ಕುರುಹುಗಳನ್ನು ವೀಕ್ಷಿಸಲು:

• ನೀವು ಟ್ರೇಸ್‌ಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು ಬಯಸುವ ಸೇವೆಯನ್ನು ಆಯ್ಕೆಮಾಡಿ, ಉದಾಹರಣೆಗೆ, ಟಾಮ್‌ಕ್ಯಾಟ್‌ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಮತ್ತು ಅದರ ಸ್ವಂತ ಹೆಸರನ್ನು ಹೊಂದಿರದ ಸೇವೆಗಾಗಿ tomcat7-ಡೀಫಾಲ್ಟ್.
• ನಂತರ ಕಾರ್ಯಾಚರಣೆ, ಸಮಯದ ಮಧ್ಯಂತರ ಮತ್ತು ಕನಿಷ್ಠ ಕಾರ್ಯಾಚರಣೆಯ ಸಮಯವನ್ನು ಆಯ್ಕೆಮಾಡಿ, ಉದಾಹರಣೆಗೆ 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 ಮತ್ತು ಗೋಲಾಂಗ್ ಯೋಜನೆಯಲ್ಲಿ ಜೇಗರ್ ಓಪನ್‌ಟ್ರೇಸಿಂಗ್ ಮತ್ತು ಮೈಕ್ರೋಸರ್ವೀಸಸ್
• 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