🥇JavaScript ಅನ್ನು ಬಳಸಿಕೊಂಡು Zabbix ನಲ್ಲಿ ಪ್ರಾಯೋಗಿಕ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಿ

ಟಿಖೋನ್ ಉಸ್ಕೋವ್, ಜಬ್ಬಿಕ್ಸ್ ಏಕೀಕರಣ ತಂಡದ ಎಂಜಿನಿಯರ್

Zabbix ಯಾವುದೇ ರೀತಿಯ ಡೇಟಾವನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲು ಬಳಸಲಾಗುವ ಗ್ರಾಹಕೀಯಗೊಳಿಸಬಹುದಾದ ವೇದಿಕೆಯಾಗಿದೆ. ಜಬ್ಬಿಕ್ಸ್‌ನ ಆರಂಭಿಕ ಆವೃತ್ತಿಗಳಿಂದ, ಮೇಲ್ವಿಚಾರಣಾ ನಿರ್ವಾಹಕರು ವಿವಿಧ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಚಲಾಯಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಹೊಂದಿದ್ದಾರೆ ಕ್ರಿಯೆಗಳು ಗುರಿ ನೆಟ್‌ವರ್ಕ್ ನೋಡ್‌ಗಳಲ್ಲಿ ತಪಾಸಣೆಗಾಗಿ. ಅದೇ ಸಮಯದಲ್ಲಿ, ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳ ಉಡಾವಣೆಯು ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸುವ ಅಗತ್ಯತೆ, ಸಂವಹನ ನೋಡ್‌ಗಳು ಮತ್ತು ಪ್ರಾಕ್ಸಿಗಳಿಗೆ ಅವುಗಳ ವಿತರಣೆ ಮತ್ತು ವಿವಿಧ ಆವೃತ್ತಿಗಳಿಗೆ ಬೆಂಬಲವನ್ನು ಒಳಗೊಂಡಂತೆ ಹಲವಾರು ತೊಂದರೆಗಳಿಗೆ ಕಾರಣವಾಯಿತು.

Zabbix ಗಾಗಿ JavaScript

ಏಪ್ರಿಲ್ 2019 ರಲ್ಲಿ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಿಪ್ರೊಸೆಸಿಂಗ್‌ನೊಂದಿಗೆ Zabbix 4.2 ಅನ್ನು ಪರಿಚಯಿಸಲಾಯಿತು. ಡೇಟಾವನ್ನು ಎಲ್ಲೋ ತೆಗೆದುಕೊಂಡು ಹೋಗುವ, ಅದನ್ನು ಜೀರ್ಣಿಸಿಕೊಳ್ಳುವ ಮತ್ತು Zabbix ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ರೂಪದಲ್ಲಿ ಒದಗಿಸುವ ಮತ್ತು Zabbix ಮೂಲಕ ಸಂಗ್ರಹಣೆ ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗೆ ಸಿದ್ಧವಾಗಿಲ್ಲದ ಡೇಟಾವನ್ನು ಸ್ವೀಕರಿಸುವ ಸರಳ ಪರಿಶೀಲನೆಗಳನ್ನು ಮಾಡುವ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ತ್ಯಜಿಸುವ ಕಲ್ಪನೆಯ ಬಗ್ಗೆ ಅನೇಕ ಜನರು ಉತ್ಸುಕರಾಗಿದ್ದಾರೆ. ನಂತರ Zabbix ಮತ್ತು JavaScript ಪರಿಕರಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಈ ಡೇಟಾ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿ. Zabbix 3.4 ನಲ್ಲಿ ಕಾಣಿಸಿಕೊಂಡ ಕಡಿಮೆ-ಮಟ್ಟದ ಅನ್ವೇಷಣೆ ಮತ್ತು ಅವಲಂಬಿತ ಐಟಂಗಳ ಜೊತೆಯಲ್ಲಿ, ಸ್ವೀಕರಿಸಿದ ಡೇಟಾವನ್ನು ವಿಂಗಡಿಸಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ನಾವು ಸಾಕಷ್ಟು ಹೊಂದಿಕೊಳ್ಳುವ ಪರಿಕಲ್ಪನೆಯನ್ನು ಪಡೆದುಕೊಂಡಿದ್ದೇವೆ.

Zabbix 4.4 ರಲ್ಲಿ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಪೂರ್ವ-ಸಂಸ್ಕರಣೆಯ ತಾರ್ಕಿಕ ಮುಂದುವರಿಕೆಯಾಗಿ, ಹೊಸ ಅಧಿಸೂಚನೆ ವಿಧಾನವು ಕಾಣಿಸಿಕೊಂಡಿದೆ - ವೆಬ್‌ಹೂಕ್, ಇದನ್ನು ಮೂರನೇ ವ್ಯಕ್ತಿಯ ಅಪ್ಲಿಕೇಶನ್‌ಗಳೊಂದಿಗೆ ಸುಲಭವಾಗಿ ಜಬ್ಬಿಕ್ಸ್ ಅಧಿಸೂಚನೆಗಳನ್ನು ಸಂಯೋಜಿಸಲು ಬಳಸಬಹುದು.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು ಡಕ್ಟೇಪ್ಸ್

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು ಡಕ್ಟೇಪ್ ಅನ್ನು ಏಕೆ ಆಯ್ಕೆ ಮಾಡಲಾಗಿದೆ? ಭಾಷೆಗಳು ಮತ್ತು ಎಂಜಿನ್ಗಳಿಗಾಗಿ ವಿವಿಧ ಆಯ್ಕೆಗಳನ್ನು ಪರಿಗಣಿಸಲಾಗಿದೆ:

ಲುವಾ - ಲುವಾ 5.1
ಲುವಾ - LuaJIT
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ - ಡಕ್ಟೇಪ್
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ - ಜೆರ್ರಿಸ್ಕ್ರಿಪ್ಟ್
ಎಂಬೆಡೆಡ್ ಪೈಥಾನ್
ಎಂಬೆಡೆಡ್ ಪರ್ಲ್

ಮುಖ್ಯ ಆಯ್ಕೆ ಮಾನದಂಡಗಳೆಂದರೆ ಪ್ರಭುತ್ವ, ಉತ್ಪನ್ನಕ್ಕೆ ಎಂಜಿನ್‌ನ ಏಕೀಕರಣದ ಸುಲಭತೆ, ಕಡಿಮೆ ಸಂಪನ್ಮೂಲ ಬಳಕೆ ಮತ್ತು ಎಂಜಿನ್‌ನ ಒಟ್ಟಾರೆ ಕಾರ್ಯಕ್ಷಮತೆ ಮತ್ತು ಮೇಲ್ವಿಚಾರಣೆಯಲ್ಲಿ ಈ ಭಾಷೆಯಲ್ಲಿ ಕೋಡ್ ಅನ್ನು ಪರಿಚಯಿಸುವ ಸುರಕ್ಷತೆ. ಸೂಚಕಗಳ ಸಂಯೋಜನೆಯ ಆಧಾರದ ಮೇಲೆ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡಕ್ಟೇಪ್ ಎಂಜಿನ್ನಲ್ಲಿ ಗೆದ್ದಿದೆ.

ಆಯ್ಕೆ ಮಾನದಂಡಗಳು ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆ ಪರೀಕ್ಷೆ

ಡಕ್ಟೇಪ್ ವೈಶಿಷ್ಟ್ಯಗಳು:

- ಪ್ರಮಾಣಿತ ECMAScript E5/E5.1
- Duktape ಗಾಗಿ Zabbix ಮಾಡ್ಯೂಲ್‌ಗಳು:

Zabbix.log() - ಜಬ್ಬಿಕ್ಸ್ ಸರ್ವರ್ ಲಾಗ್‌ಗೆ ನೇರವಾಗಿ ವಿವಿಧ ಹಂತದ ವಿವರಗಳೊಂದಿಗೆ ಸಂದೇಶಗಳನ್ನು ಬರೆಯಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಇದು ದೋಷಗಳನ್ನು ಪರಸ್ಪರ ಸಂಬಂಧಿಸಲು ಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ, ವೆಬ್‌ಹೂಕ್‌ನಲ್ಲಿ, ಸರ್ವರ್ ಸ್ಥಿತಿಯೊಂದಿಗೆ.
CurlHttpRequest() - ವೆಬ್‌ಹೂಕ್ ಬಳಕೆಯನ್ನು ಆಧರಿಸಿದ ನೆಟ್‌ವರ್ಕ್‌ಗೆ HTTP ವಿನಂತಿಗಳನ್ನು ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
atob() ಮತ್ತು btoa() - ನೀವು Base64 ಫಾರ್ಮ್ಯಾಟ್‌ನಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಎನ್‌ಕೋಡ್ ಮಾಡಲು ಮತ್ತು ಡಿಕೋಡ್ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ.

ಸೂಚನೆ. Duktape ACME ಮಾನದಂಡಗಳನ್ನು ಅನುಸರಿಸುತ್ತದೆ. Zabbix ಸ್ಕ್ರಿಪ್ಟ್‌ನ 2015 ಆವೃತ್ತಿಯನ್ನು ಬಳಸುತ್ತದೆ. ನಂತರದ ಬದಲಾವಣೆಗಳು ಚಿಕ್ಕದಾಗಿರುತ್ತವೆ, ಆದ್ದರಿಂದ ಅವುಗಳನ್ನು ನಿರ್ಲಕ್ಷಿಸಬಹುದು..

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮ್ಯಾಜಿಕ್

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಎಲ್ಲಾ ಮ್ಯಾಜಿಕ್ ಡೈನಾಮಿಕ್ ಟೈಪಿಂಗ್ ಮತ್ತು ಟೈಪ್ ಕ್ಯಾಸ್ಟಿಂಗ್‌ನಲ್ಲಿದೆ: ಸ್ಟ್ರಿಂಗ್, ಸಂಖ್ಯಾತ್ಮಕ ಮತ್ತು ಬೂಲಿಯನ್.

ಇದರರ್ಥ ವೇರಿಯಬಲ್ ಯಾವ ಪ್ರಕಾರದ ಮೌಲ್ಯವನ್ನು ಹಿಂದಿರುಗಿಸಬೇಕು ಎಂಬುದನ್ನು ಮುಂಚಿತವಾಗಿ ಘೋಷಿಸುವ ಅಗತ್ಯವಿಲ್ಲ.

ಗಣಿತದ ಕಾರ್ಯಾಚರಣೆಗಳಲ್ಲಿ, ಕಾರ್ಯ ನಿರ್ವಾಹಕರು ಹಿಂತಿರುಗಿಸಿದ ಮೌಲ್ಯಗಳನ್ನು ಸಂಖ್ಯೆಗಳಾಗಿ ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ. ಅಂತಹ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ವಿನಾಯಿತಿಯು ಸೇರ್ಪಡೆಯಾಗಿದೆ, ಏಕೆಂದರೆ ಕನಿಷ್ಠ ಒಂದು ಪದವು ಸ್ಟ್ರಿಂಗ್ ಆಗಿದ್ದರೆ, ಎಲ್ಲಾ ನಿಯಮಗಳಿಗೆ ಸ್ಟ್ರಿಂಗ್ ಪರಿವರ್ತನೆಯನ್ನು ಅನ್ವಯಿಸಲಾಗುತ್ತದೆ.

ಸೂಚನೆ. ಅಂತಹ ರೂಪಾಂತರಗಳಿಗೆ ಕಾರಣವಾದ ವಿಧಾನಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ವಸ್ತುವಿನ ಮೂಲ ಮಾದರಿಗಳಲ್ಲಿ ಅಳವಡಿಸಲಾಗಿದೆ, ಮೌಲ್ಯಆಫ್ и ಸ್ಟ್ರಿಂಗ್ ಗೆ. ಮೌಲ್ಯಆಫ್ ಸಂಖ್ಯಾತ್ಮಕ ಪರಿವರ್ತನೆಯ ಸಮಯದಲ್ಲಿ ಮತ್ತು ಯಾವಾಗಲೂ ವಿಧಾನದ ಮೊದಲು ಕರೆಯಲಾಗುತ್ತದೆ ಸ್ಟ್ರಿಂಗ್ ಗೆ. ವಿಧಾನ ಮೌಲ್ಯಆಫ್ ಪ್ರಾಚೀನ ಮೌಲ್ಯಗಳನ್ನು ಹಿಂತಿರುಗಿಸಬೇಕು, ಇಲ್ಲದಿದ್ದರೆ ಅದರ ಫಲಿತಾಂಶವನ್ನು ನಿರ್ಲಕ್ಷಿಸಲಾಗುತ್ತದೆ.

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

ಉದಾಹರಣೆಗೆ, ವಸ್ತುವಿಗಾಗಿ ವೇಳೆ 'ಆಬ್ಜೆಕ್ಟ್' ವಿಧಾನವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಸ್ಟ್ರಿಂಗ್ ಗೆ,

`var obj = { toString() { return "200" }}`

ವಿಧಾನ ಸ್ಟ್ರಿಂಗ್ ಗೆ ನಿಖರವಾಗಿ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಮತ್ತು ಸಂಖ್ಯೆಯೊಂದಿಗೆ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಸೇರಿಸಿದಾಗ, ನಾವು ಅಂಟಿಕೊಂಡಿರುವ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಪಡೆಯುತ್ತೇವೆ:

`obj + 1 // '2001'` 

`obj + 'a' // ‘200a'`

ಆದರೆ ನೀವು ಪುನಃ ಬರೆದರೆ ಸ್ಟ್ರಿಂಗ್ ಗೆ, ಆದ್ದರಿಂದ ವಿಧಾನವು ಸಂಖ್ಯೆಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ವಸ್ತುವನ್ನು ಸೇರಿಸಿದಾಗ, ಸಂಖ್ಯಾ ಪರಿವರ್ತನೆಯೊಂದಿಗೆ ಗಣಿತದ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ನಡೆಸಲಾಗುತ್ತದೆ ಮತ್ತು ಗಣಿತದ ಸೇರ್ಪಡೆಯ ಫಲಿತಾಂಶವನ್ನು ಪಡೆಯಲಾಗುತ್ತದೆ.

`var obj = { toString() { return 200 }}` 

`obj + 1 // '2001'`

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಸ್ಟ್ರಿಂಗ್ನೊಂದಿಗೆ ಸೇರ್ಪಡೆ ಮಾಡಿದರೆ, ಸ್ಟ್ರಿಂಗ್ ಪರಿವರ್ತನೆಯನ್ನು ನಡೆಸಲಾಗುತ್ತದೆ, ಮತ್ತು ನಾವು ಅಂಟಿಕೊಂಡಿರುವ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಪಡೆಯುತ್ತೇವೆ.

`obj + 'a' // ‘200a'`

ಅನನುಭವಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಬಳಕೆದಾರರಿಂದ ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ತಪ್ಪುಗಳಿಗೆ ಇದು ಕಾರಣವಾಗಿದೆ.

ವಿಧಾನ ಸ್ಟ್ರಿಂಗ್ ಗೆ ವಸ್ತುವಿನ ಪ್ರಸ್ತುತ ಮೌಲ್ಯವನ್ನು 1 ರಿಂದ ಹೆಚ್ಚಿಸುವ ಕಾರ್ಯವನ್ನು ನೀವು ಬರೆಯಬಹುದು.

ವೇರಿಯೇಬಲ್ 3 ಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆ ಮತ್ತು ಅದು 4 ಕ್ಕೆ ಸಮಾನವಾಗಿರುತ್ತದೆ ಎಂದು ಒದಗಿಸಿದ ಸ್ಕ್ರಿಪ್ಟ್ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆ.

ಎರಕಹೊಯ್ದ (==) ನೊಂದಿಗೆ ಹೋಲಿಸಿದಾಗ, ವಿಧಾನವನ್ನು ಪ್ರತಿ ಬಾರಿಯೂ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ ಸ್ಟ್ರಿಂಗ್ ಗೆ ಮೌಲ್ಯ ಹೆಚ್ಚಳ ಕಾರ್ಯದೊಂದಿಗೆ. ಅಂತೆಯೇ, ಪ್ರತಿ ನಂತರದ ಹೋಲಿಕೆಯೊಂದಿಗೆ, ಮೌಲ್ಯವು ಹೆಚ್ಚಾಗುತ್ತದೆ. ಎರಕಹೊಯ್ದ ಹೋಲಿಕೆಯನ್ನು (===) ಬಳಸುವ ಮೂಲಕ ಇದನ್ನು ತಪ್ಪಿಸಬಹುದು.

ಟೈಪ್ ಕಾಸ್ಟಿಂಗ್ ಇಲ್ಲದೆ ಹೋಲಿಕೆ

ಸೂಚನೆ. ಎರಕಹೊಯ್ದ ಹೋಲಿಕೆಯನ್ನು ಅನಗತ್ಯವಾಗಿ ಬಳಸಬೇಡಿ.

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

ವೆಬ್‌ಹೂಕ್ ಮಾಧ್ಯಮ

2019 ರ ಕೊನೆಯಲ್ಲಿ ಮತ್ತು 2020 ರ ಆರಂಭದಲ್ಲಿ, Zabbix ಏಕೀಕರಣ ತಂಡವು ವೆಬ್‌ಹೂಕ್ಸ್ ಮತ್ತು ಜಬ್ಬಿಕ್ಸ್ ವಿತರಣೆಯೊಂದಿಗೆ ಬರುವ ಔಟ್-ಆಫ್-ದಿ-ಬಾಕ್ಸ್ ಏಕೀಕರಣಗಳನ್ನು ಸಕ್ರಿಯವಾಗಿ ಅಭಿವೃದ್ಧಿಪಡಿಸುತ್ತಿದೆ.

ಇದಕ್ಕೆ ಲಿಂಕ್ ಮಾಡಿ ದಸ್ತಾವೇಜನ್ನು

ಪ್ರಿಪ್ರೊಸೆಸಿಂಗ್

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಪೂರ್ವ ಸಂಸ್ಕರಣೆಯ ಆಗಮನವು ಹೆಚ್ಚಿನ ಬಾಹ್ಯ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ತ್ಯಜಿಸಲು ಸಾಧ್ಯವಾಗಿಸಿತು, ಮತ್ತು ಪ್ರಸ್ತುತ Zabbix ನಲ್ಲಿ ನೀವು ಯಾವುದೇ ಮೌಲ್ಯವನ್ನು ಪಡೆಯಬಹುದು ಮತ್ತು ಅದನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ವಿಭಿನ್ನ ಮೌಲ್ಯಕ್ಕೆ ಪರಿವರ್ತಿಸಬಹುದು.
Zabbix ನಲ್ಲಿ ಪೂರ್ವ ಸಂಸ್ಕರಣೆಯನ್ನು JavaScript ಕೋಡ್‌ನಿಂದ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ, ಇದು ಬೈಟ್‌ಕೋಡ್‌ಗೆ ಕಂಪೈಲ್ ಮಾಡಿದಾಗ, ಒಂದೇ ಮೌಲ್ಯವನ್ನು ನಿಯತಾಂಕವಾಗಿ ತೆಗೆದುಕೊಳ್ಳುವ ಕಾರ್ಯವಾಗಿ ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ. ಮೌಲ್ಯ ಸ್ಟ್ರಿಂಗ್ ಆಗಿ (ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಅಂಕೆ ಮತ್ತು ಸಂಖ್ಯೆ ಎರಡನ್ನೂ ಒಳಗೊಂಡಿರಬಹುದು).
ಔಟ್‌ಪುಟ್ ಒಂದು ಕಾರ್ಯವಾಗಿರುವುದರಿಂದ, ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಕೊನೆಯಲ್ಲಿ ಅಗತ್ಯವಿದೆ ರಿಟರ್ನ್.
ಕೋಡ್‌ನಲ್ಲಿ ಕಸ್ಟಮ್ ಮ್ಯಾಕ್ರೋಗಳನ್ನು ಬಳಸಲು ಸಾಧ್ಯವಿದೆ.
ಸಂಪನ್ಮೂಲಗಳನ್ನು ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಮಟ್ಟದಲ್ಲಿ ಮಾತ್ರ ಸೀಮಿತಗೊಳಿಸಬಹುದು, ಆದರೆ ಪ್ರೋಗ್ರಾಮಿಕ್ ಆಗಿಯೂ ಸಹ. ಪ್ರಿಪ್ರೊಸೆಸಿಂಗ್ ಹಂತವು ಗರಿಷ್ಠ 10 ಮೆಗಾಬೈಟ್ RAM ಮತ್ತು 10 ಸೆಕೆಂಡುಗಳ ರನ್ ಸಮಯದ ಮಿತಿಯನ್ನು ನಿಗದಿಪಡಿಸಲಾಗಿದೆ.

ಸೂಚನೆ. 10 ಸೆಕೆಂಡುಗಳ ಕಾಲಾವಧಿಯ ಮೌಲ್ಯವು ಸಾಕಷ್ಟು ಹೆಚ್ಚು, ಏಕೆಂದರೆ "ಭಾರೀ" ಪೂರ್ವ ಸಂಸ್ಕರಣೆಯ ಸನ್ನಿವೇಶದ ಪ್ರಕಾರ 1 ಸೆಕೆಂಡಿನಲ್ಲಿ ಷರತ್ತುಬದ್ಧ ಸಾವಿರಾರು ಡೇಟಾ ಐಟಂಗಳನ್ನು ಸಂಗ್ರಹಿಸುವುದು Zabbix ಅನ್ನು ನಿಧಾನಗೊಳಿಸುತ್ತದೆ. ಆದ್ದರಿಂದ, ಪೂರ್ವ ಸಂಸ್ಕರಣೆಯನ್ನು ನಿರ್ವಹಿಸಲು ಮಾತ್ರ ಚಾಲನೆಯಲ್ಲಿರುವ ನೆರಳು ಡೇಟಾ ಅಂಶಗಳು (ಡಮ್ಮಿ ಐಟಂಗಳು) ಎಂದು ಕರೆಯಲ್ಪಡುವ ಮೂಲಕ ಪೂರ್ಣ-ಪ್ರಮಾಣದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸ್ಕ್ರಿಪ್ಟ್ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಪೂರ್ವ ಸಂಸ್ಕರಣೆಯನ್ನು ಬಳಸಲು ಶಿಫಾರಸು ಮಾಡುವುದಿಲ್ಲ..

ಪ್ರಿಪ್ರೊಸೆಸಿಂಗ್ ಪರೀಕ್ಷೆಯ ಮೂಲಕ ಅಥವಾ ಉಪಯುಕ್ತತೆಯನ್ನು ಬಳಸಿಕೊಂಡು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ನೀವು ಪರಿಶೀಲಿಸಬಹುದು zabbix_js:

`zabbix_js -s *script-file -p *input-param* [-l log-level] [-t timeout]`

`zabbix_js -s script-file -i input-file [-l log-level] [-t timeout]`

`zabbix_js -h`

`zabbix_js -V`

ಪ್ರಾಯೋಗಿಕ ಕಾರ್ಯಗಳು

ಉದ್ದೇಶ 1

ಲೆಕ್ಕಹಾಕಿದ ಐಟಂ ಅನ್ನು ಪೂರ್ವ ಸಂಸ್ಕರಣೆಯೊಂದಿಗೆ ಬದಲಾಯಿಸಿ.

ಸ್ಥಿತಿ: ಸೆಲ್ಸಿಯಸ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲು ಸೆನ್ಸರ್‌ನಿಂದ ಫ್ಯಾರನ್‌ಹೀಟ್‌ನಲ್ಲಿ ತಾಪಮಾನವನ್ನು ಪಡೆಯಿರಿ.

ಹಿಂದೆ, ನಾವು ಡಿಗ್ರಿ ಫ್ಯಾರನ್‌ಹೀಟ್‌ನಲ್ಲಿ ತಾಪಮಾನವನ್ನು ಸಂಗ್ರಹಿಸುವ ಐಟಂ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ. ಅದರ ನಂತರ, ಫಾರ್ಮುಲಾವನ್ನು ಬಳಸಿಕೊಂಡು ಫ್ಯಾರನ್‌ಹೀಟ್ ಅನ್ನು ಸೆಲ್ಸಿಯಸ್‌ಗೆ ಪರಿವರ್ತಿಸುವ ಮತ್ತೊಂದು ಡೇಟಾ ಐಟಂ (ಲೆಕ್ಕ ಹಾಕಲಾಗಿದೆ).

ತೊಂದರೆಗಳು:

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

ದತ್ತಾಂಶವನ್ನು ಸ್ವೀಕರಿಸುವ ಐಟಂ (ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ಡಿಗ್ರಿ ಫ್ಯಾರನ್‌ಹೀಟ್‌ನಲ್ಲಿನ ತಾಪಮಾನ) ನಂತರ ಕಂಪ್ಯೂಟೆಡ್ ಐಟಂ ಅನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲಾಗುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಸ್ಥಿರ ಮಧ್ಯಂತರಗಳ ಪರವಾಗಿ ಹೊಂದಿಕೊಳ್ಳುವ ಚೆಕ್ ಮಧ್ಯಂತರಗಳಿಂದ ದೂರ ಸರಿಯುವುದು ಒಂದು ಪರಿಹಾರವಾಗಿದೆ.

ಆದರೆ, ಉದಾಹರಣೆಗೆ, ನಾವು ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ಸಾಧನಗಳನ್ನು ಪರಿಶೀಲಿಸಲು ಟೆಂಪ್ಲೇಟ್ ಅನ್ನು ಬಳಸಿದರೆ ಮತ್ತು ಪ್ರತಿ 30 ಸೆಕೆಂಡುಗಳಿಗೊಮ್ಮೆ ಚೆಕ್ ಅನ್ನು ನಿರ್ವಹಿಸಿದರೆ, ಝಬ್ಬಿಕ್ಸ್ 29 ಸೆಕೆಂಡುಗಳ ಕಾಲ "ಹ್ಯಾಕ್" ಮಾಡುತ್ತದೆ ಮತ್ತು ಕೊನೆಯ ಸೆಕೆಂಡಿನಲ್ಲಿ ಅದು ಪರಿಶೀಲಿಸಲು ಮತ್ತು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ. ಇದು ಕ್ಯೂ ಅನ್ನು ರಚಿಸುತ್ತದೆ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುತ್ತದೆ. ಆದ್ದರಿಂದ, ಇದು ನಿಜವಾಗಿಯೂ ಅಗತ್ಯವಿದ್ದರೆ ಮಾತ್ರ ಸ್ಥಿರ ಮಧ್ಯಂತರಗಳನ್ನು ಬಳಸಲು ಸೂಚಿಸಲಾಗುತ್ತದೆ.

ಈ ಸಮಸ್ಯೆಯಲ್ಲಿ, ಸೂಕ್ತವಾದ ಪರಿಹಾರವೆಂದರೆ ಒಂದು ಸಾಲಿನ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಿಪ್ರೊಸೆಸಿಂಗ್ ಆಗಿದ್ದು ಅದು ಡಿಗ್ರಿ ಫ್ಯಾರನ್‌ಹೀಟ್ ಅನ್ನು ಡಿಗ್ರಿ ಸೆಲ್ಸಿಯಸ್‌ಗೆ ಪರಿವರ್ತಿಸುತ್ತದೆ:

`return (value - 32) * 5 / 9;`

ಇದು ವೇಗವಾಗಿ ಮತ್ತು ಸುಲಭವಾಗಿದೆ, ನೀವು ಅನಗತ್ಯ ಡೇಟಾ ಐಟಂಗಳನ್ನು ರಚಿಸುವ ಅಗತ್ಯವಿಲ್ಲ ಮತ್ತು ಅವುಗಳ ಮೇಲೆ ಇತಿಹಾಸವನ್ನು ಇರಿಸಿಕೊಳ್ಳಿ, ಮತ್ತು ನೀವು ಚೆಕ್‌ಗಳಿಗೆ ಹೊಂದಿಕೊಳ್ಳುವ ಮಧ್ಯಂತರಗಳನ್ನು ಸಹ ಬಳಸಬಹುದು.

`return (parseInt(value) + parseInt("{$EXAMPLE.MACRO}"));`

ಆದರೆ, ಒಂದು ಕಾಲ್ಪನಿಕ ಪರಿಸ್ಥಿತಿಯಲ್ಲಿ ಸ್ವೀಕರಿಸಿದ ಡೇಟಾ ಅಂಶವನ್ನು ಸೇರಿಸಲು ಅಗತ್ಯವಿದ್ದರೆ, ಉದಾಹರಣೆಗೆ, ಮ್ಯಾಕ್ರೋದಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಯಾವುದೇ ಸ್ಥಿರತೆಯೊಂದಿಗೆ, ನಿಯತಾಂಕವನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳಬೇಕು ಮೌಲ್ಯ ಸ್ಟ್ರಿಂಗ್ ಆಗಿ ವಿಸ್ತರಿಸುತ್ತದೆ. ಸ್ಟ್ರಿಂಗ್ ಸೇರ್ಪಡೆ ಕಾರ್ಯಾಚರಣೆಯಲ್ಲಿ, ಎರಡು ತಂತಿಗಳನ್ನು ಸರಳವಾಗಿ ಒಂದಾಗಿ ಸಂಯೋಜಿಸಲಾಗುತ್ತದೆ.

`return (value + "{$EXAMPLE.MACRO}");`

ಗಣಿತದ ಕಾರ್ಯಾಚರಣೆಯ ಫಲಿತಾಂಶವನ್ನು ಪಡೆಯಲು, ಪಡೆದ ಮೌಲ್ಯಗಳ ಪ್ರಕಾರಗಳನ್ನು ಸಂಖ್ಯಾ ಸ್ವರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸುವುದು ಅವಶ್ಯಕ. ಇದಕ್ಕಾಗಿ ನೀವು ಕಾರ್ಯವನ್ನು ಬಳಸಬಹುದು ಪಾರ್ಸ್ಇಂಟ್(), ಇದು ಪೂರ್ಣಾಂಕವನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ, ಒಂದು ಕಾರ್ಯ ಪಾರ್ಸ್ಫ್ಲೋಟ್(), ಇದು ದಶಮಾಂಶ ಅಥವಾ ಕಾರ್ಯವನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ ಸಂಖ್ಯೆ, ಇದು ಪೂರ್ಣಾಂಕ ಅಥವಾ ದಶಮಾಂಶವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

ಕಾರ್ಯ 2

ಪ್ರಮಾಣಪತ್ರದ ಅಂತ್ಯದವರೆಗೆ ಸೆಕೆಂಡುಗಳಲ್ಲಿ ಸಮಯವನ್ನು ಪಡೆಯಿರಿ.

ಸ್ಥಿತಿ: ಸೇವೆಯು "ಫೆಬ್ರವರಿ 12 12:33:56 2022 GMT" ಸ್ವರೂಪದಲ್ಲಿ ಪ್ರಮಾಣಪತ್ರದ ಮುಕ್ತಾಯ ದಿನಾಂಕವನ್ನು ನೀಡುತ್ತದೆ.

ECMAScript 5 ರಲ್ಲಿ date.parse() ISO 8601 ಸ್ವರೂಪದಲ್ಲಿ ದಿನಾಂಕವನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ (YYYY-MM-DDTHH:mm:ss.sssZ). MMM DD YYYY HH:mm:ss ZZ ಸ್ವರೂಪದಲ್ಲಿ ಇದಕ್ಕೆ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಬಿತ್ತರಿಸುವುದು ಅವಶ್ಯಕ

ಸಮಸ್ಯೆಯನ್ನು: ತಿಂಗಳ ಮೌಲ್ಯವನ್ನು ಪಠ್ಯವಾಗಿ ವ್ಯಕ್ತಪಡಿಸಲಾಗುತ್ತದೆ, ಸಂಖ್ಯೆಯಾಗಿ ಅಲ್ಲ. ಈ ಸ್ವರೂಪದಲ್ಲಿನ ಡೇಟಾವನ್ನು Duktape ಸ್ವೀಕರಿಸುವುದಿಲ್ಲ.

ಪರಿಹಾರ ಉದಾಹರಣೆ:

ಮೊದಲನೆಯದಾಗಿ, ಒಂದು ಮೌಲ್ಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಘೋಷಿಸಲಾಗುತ್ತದೆ (ಸಂಪೂರ್ಣ ಸ್ಕ್ರಿಪ್ಟ್ ಅಲ್ಪವಿರಾಮದಿಂದ ಪ್ರತ್ಯೇಕಿಸಲಾದ ಅಸ್ಥಿರಗಳ ಘೋಷಣೆಯಾಗಿದೆ).
ಮೊದಲ ಸಾಲಿನಲ್ಲಿ ನಾವು ಪ್ಯಾರಾಮೀಟರ್ನಲ್ಲಿ ದಿನಾಂಕವನ್ನು ಪಡೆಯುತ್ತೇವೆ ಮೌಲ್ಯ ಮತ್ತು ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಜಾಗಗಳೊಂದಿಗೆ ಅದನ್ನು ಪ್ರತ್ಯೇಕಿಸಿ ವಿಭಜನೆ. ಹೀಗಾಗಿ, ನಾವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಪಡೆಯುತ್ತೇವೆ, ಅಲ್ಲಿ ರಚನೆಯ ಪ್ರತಿಯೊಂದು ಅಂಶವು ಸೂಚ್ಯಂಕ 0 ರಿಂದ ಪ್ರಾರಂಭವಾಗಿ, ಒಂದು ಸ್ಥಳದ ಮೊದಲು ಮತ್ತು ನಂತರದ ಒಂದು ದಿನಾಂಕದ ಅಂಶಕ್ಕೆ ಅನುರೂಪವಾಗಿದೆ. ವಿಭಜನೆ(0) - ತಿಂಗಳು, ವಿಭಜನೆ(1) - ಸಂಖ್ಯೆ, ವಿಭಜನೆ(2) - ಸಮಯದೊಂದಿಗೆ ಸ್ಟ್ರಿಂಗ್, ಇತ್ಯಾದಿ. ಅದರ ನಂತರ, ದಿನಾಂಕದ ಪ್ರತಿಯೊಂದು ಅಂಶವನ್ನು ಶ್ರೇಣಿಯಲ್ಲಿನ ಸೂಚ್ಯಂಕದಿಂದ ಪ್ರವೇಶಿಸಬಹುದು.

`var split = value.split(' '),`

ಪ್ರತಿ ತಿಂಗಳು (ಕಾಲಾನುಕ್ರಮದಲ್ಲಿ) ರಚನೆಯಲ್ಲಿ ಅದರ ಸ್ಥಾನದ ಸೂಚ್ಯಂಕಕ್ಕೆ ಅನುರೂಪವಾಗಿದೆ (0 ರಿಂದ 11 ರವರೆಗೆ). ಪಠ್ಯ ಮೌಲ್ಯವನ್ನು ಸಂಖ್ಯಾ ಮೌಲ್ಯಕ್ಕೆ ಪರಿವರ್ತಿಸಲು, ತಿಂಗಳ ಸೂಚ್ಯಂಕಕ್ಕೆ ಒಂದನ್ನು ಸೇರಿಸಲಾಗುತ್ತದೆ (ಏಕೆಂದರೆ ತಿಂಗಳುಗಳು 1 ರಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತವೆ). ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಒಂದರ ಸೇರ್ಪಡೆಯೊಂದಿಗೆ ಅಭಿವ್ಯಕ್ತಿಯನ್ನು ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿ ತೆಗೆದುಕೊಳ್ಳಲಾಗುತ್ತದೆ, ಇಲ್ಲದಿದ್ದರೆ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಪಡೆಯಲಾಗುತ್ತದೆ, ಸಂಖ್ಯೆ ಅಲ್ಲ. ಕೊನೆಯಲ್ಲಿ ನಾವು ಮಾಡುತ್ತೇವೆ ಸ್ಲೈಸ್ () - ಕೇವಲ ಎರಡು ಅಕ್ಷರಗಳನ್ನು ಬಿಡಲು ಸರಣಿಯನ್ನು ಕೊನೆಯಿಂದ ಕತ್ತರಿಸಿ (ಇದು ಎರಡು-ಅಂಕಿಯ ಸಂಖ್ಯೆಯೊಂದಿಗೆ ತಿಂಗಳುಗಳವರೆಗೆ ಮುಖ್ಯವಾಗಿದೆ).

`MONTHS_LIST = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],`

`month_index = ('0' + (MONTHS_LIST.indexOf(split[0]) + 1)).slice(-2),`

ಸೂಕ್ತವಾದ ಕ್ರಮದಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್‌ಗಳ ಸಾಮಾನ್ಯ ಸೇರ್ಪಡೆಯಿಂದ ಪಡೆದ ಮೌಲ್ಯಗಳಿಂದ ನಾವು ISO ಸ್ವರೂಪದಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ರೂಪಿಸುತ್ತೇವೆ.

`ISOdate = split[3] + '-' + month_index + '-' + split[1] + 'T' + split[2],`

ಫಲಿತಾಂಶದ ಸ್ವರೂಪದಲ್ಲಿನ ಡೇಟಾವು 1970 ರಿಂದ ಭವಿಷ್ಯದ ಕೆಲವು ಹಂತದವರೆಗಿನ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯಾಗಿದೆ. ಟ್ರಿಗ್ಗರ್‌ಗಳಲ್ಲಿ ಸ್ವೀಕರಿಸಿದ ಸ್ವರೂಪದಲ್ಲಿ ಡೇಟಾವನ್ನು ಬಳಸುವುದು ಅಸಾಧ್ಯವಾಗಿದೆ, ಏಕೆಂದರೆ Zabbix ಮ್ಯಾಕ್ರೋಗಳೊಂದಿಗೆ ಮಾತ್ರ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ {ದಿನಾಂಕ} и {ಸಮಯ}, ಇದು ಬಳಕೆದಾರ ಸ್ನೇಹಿ ಸ್ವರೂಪದಲ್ಲಿ ದಿನಾಂಕ ಮತ್ತು ಸಮಯವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

ನಾವು ನಂತರ ಪ್ರಸ್ತುತ ದಿನಾಂಕವನ್ನು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಫಾರ್ಮ್ಯಾಟ್‌ನಲ್ಲಿ ಪಡೆಯಬಹುದು ಮತ್ತು ಪ್ರಮಾಣಪತ್ರದ ಅವಧಿ ಮುಗಿಯುವವರೆಗೆ ಮಿಲಿಸೆಕೆಂಡ್‌ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಪಡೆಯಲು ಫಲಿತಾಂಶದ ಪ್ರಮಾಣಪತ್ರದ ಮುಕ್ತಾಯ ದಿನಾಂಕದಿಂದ ಅದನ್ನು ಕಳೆಯಬಹುದು.

`now = Date.now();`

Zabbix ನಲ್ಲಿ ಸೆಕೆಂಡುಗಳನ್ನು ಪಡೆಯಲು ನಾವು ಸ್ವೀಕರಿಸಿದ ಮೌಲ್ಯವನ್ನು ಸಾವಿರದಿಂದ ಭಾಗಿಸುತ್ತೇವೆ.

`return parseInt((Date.parse(ISOdate) - now) / 1000);`

ಪ್ರಚೋದಕದಲ್ಲಿ, ನೀವು ' ಎಂಬ ಅಭಿವ್ಯಕ್ತಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದುಕೊನೆಯ'ನೀವು ಪ್ರತಿಕ್ರಿಯಿಸಲು ಬಯಸುವ ಅವಧಿಯಲ್ಲಿ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಗೆ ಅನುರೂಪವಾಗಿರುವ ಅಂಕೆಗಳ ಸೆಟ್ ಅನ್ನು ಅನುಸರಿಸಿ, ಉದಾಹರಣೆಗೆ, ವಾರಗಳಲ್ಲಿ. ಹೀಗಾಗಿ, ಪ್ರಮಾಣಪತ್ರವು ಒಂದು ವಾರದಲ್ಲಿ ಮುಕ್ತಾಯಗೊಳ್ಳುತ್ತದೆ ಎಂದು ಪ್ರಚೋದಕವು ತಿಳಿಸುತ್ತದೆ.

ಸೂಚನೆ. ಬಳಕೆಗೆ ಗಮನ ಕೊಡಿ ಪಾರ್ಸ್ಇಂಟ್() ಕಾರ್ಯದಲ್ಲಿ ರಿಟರ್ನ್ಮಿಲಿಸೆಕೆಂಡುಗಳ ವಿಭಜನೆಯಿಂದ ಉಂಟಾಗುವ ಭಾಗಶಃ ಸಂಖ್ಯೆಯನ್ನು ಪೂರ್ಣಾಂಕಕ್ಕೆ ಪರಿವರ್ತಿಸಲು. ನೀವು ಸಹ ಬಳಸಬಹುದು ಪಾರ್ಸ್ಫ್ಲೋಟ್() ಮತ್ತು ಭಾಗಶಃ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಿ.

ವರದಿ ವೀಕ್ಷಿಸಿ

ಮೂಲ: www.habr.com

ನಾವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಬಳಸಿಕೊಂಡು Zabbix ನಲ್ಲಿ ಪ್ರಾಯೋಗಿಕ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುತ್ತೇವೆ