JavaScript ഉപയോഗിച്ച് Zabbix-ലെ പ്രായോഗിക പ്രശ്നങ്ങൾ ഞങ്ങൾ പരിഹരിക്കുന്നു

ടിഖോൺ ഉസ്കോവ്, Zabbix ഇന്റഗ്രേഷൻ ടീം എഞ്ചിനീയർ

ഏത് തരത്തിലുള്ള ഡാറ്റയും നിരീക്ഷിക്കാൻ ഉപയോഗിക്കുന്ന ഒരു ഇഷ്‌ടാനുസൃതമാക്കാവുന്ന പ്ലാറ്റ്‌ഫോമാണ് Zabbix. Zabbix-ന്റെ ആദ്യകാല പതിപ്പുകൾ മുതൽ, മോണിറ്ററിംഗ് അഡ്മിനിസ്ട്രേറ്റർമാർക്ക് വിവിധ സ്ക്രിപ്റ്റുകൾ പ്രവർത്തിപ്പിക്കാനുള്ള കഴിവുണ്ട്. പ്രവർത്തനങ്ങൾ ടാർഗെറ്റ് നെറ്റ്‌വർക്ക് നോഡുകളിലെ പരിശോധനകൾക്കായി. അതേ സമയം, സ്ക്രിപ്റ്റുകളുടെ സമാരംഭം സ്ക്രിപ്റ്റുകളെ പിന്തുണയ്‌ക്കേണ്ടതിന്റെ ആവശ്യകത, ആശയവിനിമയ നോഡുകളിലേക്കും പ്രോക്‌സികളിലേക്കും അവയുടെ ഡെലിവറി, അതുപോലെ വ്യത്യസ്ത പതിപ്പുകൾക്കുള്ള പിന്തുണ എന്നിവ ഉൾപ്പെടെ നിരവധി ബുദ്ധിമുട്ടുകൾക്ക് കാരണമായി.

Zabbix-നുള്ള JavaScript

2019 ഏപ്രിലിൽ, ജാവാസ്ക്രിപ്റ്റ് പ്രീപ്രോസസിംഗിനൊപ്പം Zabbix 4.2 അവതരിപ്പിച്ചു. ഡാറ്റ എവിടേക്കോ കൊണ്ടുപോകുന്ന, ദഹിപ്പിച്ച് Zabbix മനസ്സിലാക്കുന്ന ഒരു ഫോർമാറ്റിൽ നൽകുന്ന സ്ക്രിപ്റ്റുകൾ എഴുതുന്നത് ഉപേക്ഷിക്കുക എന്ന ആശയത്തെക്കുറിച്ച് പലരും ആവേശഭരിതരായി തുടർന്ന് Zabbix, JavaScript ടൂളുകൾ ഉപയോഗിച്ച് ഈ ഡാറ്റ സ്ട്രീം പ്രോസസ്സ് ചെയ്യുക. Zabbix 3.4-ൽ പ്രത്യക്ഷപ്പെട്ട താഴ്ന്ന നിലയിലുള്ള കണ്ടെത്തലും ആശ്രിത ഇനങ്ങളുമായി സംയോജിച്ച്, ലഭിച്ച ഡാറ്റ തരംതിരിക്കാനും കൈകാര്യം ചെയ്യാനും ഞങ്ങൾക്ക് തികച്ചും വഴക്കമുള്ള ഒരു ആശയം ലഭിച്ചു.

Zabbix 4.4-ൽ, ജാവാസ്ക്രിപ്റ്റിലെ പ്രീ-പ്രോസസ്സിംഗിന്റെ ലോജിക്കൽ തുടർച്ച എന്ന നിലയിൽ, ഒരു പുതിയ അറിയിപ്പ് രീതി പ്രത്യക്ഷപ്പെട്ടു - Webhook, മൂന്നാം കക്ഷി ആപ്ലിക്കേഷനുകളുമായി Zabbix അറിയിപ്പുകൾ എളുപ്പത്തിൽ സംയോജിപ്പിക്കാൻ ഇത് ഉപയോഗിക്കാം.

ജാവാസ്ക്രിപ്റ്റും ഡക്‌ടേപ്പുകളും

എന്തുകൊണ്ടാണ് ജാവാസ്ക്രിപ്റ്റും ഡക്‌ടേപ്പും തിരഞ്ഞെടുത്തത്? ഭാഷകൾക്കും എഞ്ചിനുകൾക്കുമുള്ള വിവിധ ഓപ്ഷനുകൾ പരിഗണിച്ചു:

• ലുവാ - ലുവാ 5.1
• ലുവാ - LuaJIT
• Javascript - Duktape
• ജാവാസ്ക്രിപ്റ്റ് - ജെറിസ്ക്രിപ്റ്റ്
• ഉൾച്ചേർത്ത പൈത്തൺ
• ഉൾച്ചേർത്ത പേൾ

വ്യാപനം, ഉൽപന്നവുമായി എഞ്ചിൻ സംയോജിപ്പിക്കുന്നതിനുള്ള എളുപ്പം, കുറഞ്ഞ വിഭവ ഉപഭോഗം, എഞ്ചിന്റെ മൊത്തത്തിലുള്ള പ്രകടനം, നിരീക്ഷണത്തിൽ ഈ ഭാഷയിൽ കോഡ് അവതരിപ്പിക്കുന്നതിന്റെ സുരക്ഷ എന്നിവയായിരുന്നു പ്രധാന തിരഞ്ഞെടുപ്പ് മാനദണ്ഡം. സൂചകങ്ങളുടെ സംയോജനത്തെ അടിസ്ഥാനമാക്കി, Duktape എഞ്ചിനിൽ JavaScript വിജയിച്ചു.

തിരഞ്ഞെടുക്കൽ മാനദണ്ഡവും പ്രകടന പരിശോധനയും

ഡക്‌ടേപ്പിന്റെ സവിശേഷതകൾ:

- സ്റ്റാൻഡേർഡ് ECMAScript E5/E5.1
- Duktape-നുള്ള Zabbix മൊഡ്യൂളുകൾ:

• Zabbix.log() - Zabbix സെർവർ ലോഗിലേക്ക് നേരിട്ട് വ്യത്യസ്ത തലത്തിലുള്ള വിശദാംശങ്ങളുള്ള സന്ദേശങ്ങൾ എഴുതാൻ നിങ്ങളെ അനുവദിക്കുന്നു, ഇത് പിശകുകൾ പരസ്പരബന്ധിതമാക്കുന്നത് സാധ്യമാക്കുന്നു, ഉദാഹരണത്തിന്, ഒരു Webhook-ൽ, സെർവർ നിലയുമായി.
• CurlHttpRequest() - Webhook-ന്റെ ഉപയോഗം അടിസ്ഥാനമാക്കിയുള്ള നെറ്റ്‌വർക്കിലേക്ക് HTTP അഭ്യർത്ഥനകൾ നടത്താൻ നിങ്ങളെ അനുവദിക്കുന്നു.
• atob() കൂടാതെ btoa() - സ്ട്രിംഗുകൾ Base64 ഫോർമാറ്റിൽ എൻകോഡ് ചെയ്യാനും ഡീകോഡ് ചെയ്യാനും നിങ്ങളെ അനുവദിക്കുന്നു.

ശ്രദ്ധിക്കുക. Duktape ACME മാനദണ്ഡങ്ങൾ പാലിക്കുന്നു. Zabbix സ്ക്രിപ്റ്റിന്റെ 2015 പതിപ്പ് ഉപയോഗിക്കുന്നു. തുടർന്നുള്ള മാറ്റങ്ങൾ നിസ്സാരമാണ്, അതിനാൽ അവ അവഗണിക്കാം..

ജാവാസ്ക്രിപ്റ്റ് മാജിക്

ജാവാസ്ക്രിപ്റ്റിന്റെ എല്ലാ മാന്ത്രികതയും ഡൈനാമിക് ടൈപ്പിംഗിലും ടൈപ്പ് കാസ്റ്റിംഗിലുമാണ്: സ്ട്രിംഗ്, ന്യൂമെറിക്, ബൂളിയൻ.

ഇതിനർത്ഥം, ഏത് തരം വേരിയബിൾ ഒരു മൂല്യം നൽകണമെന്ന് മുൻകൂട്ടി പ്രഖ്യാപിക്കേണ്ടതില്ല എന്നാണ്.

ഗണിതശാസ്ത്ര പ്രവർത്തനങ്ങളിൽ, ഫംഗ്ഷൻ ഓപ്പറേറ്റർമാർ നൽകുന്ന മൂല്യങ്ങൾ അക്കങ്ങളായി പരിവർത്തനം ചെയ്യപ്പെടുന്നു. അത്തരം പ്രവർത്തനങ്ങൾക്കുള്ള ഒഴിവാക്കൽ കൂട്ടിച്ചേർക്കലാണ്, കാരണം നിബന്ധനകളിൽ ഒരെണ്ണമെങ്കിലും ഒരു സ്ട്രിംഗ് ആണെങ്കിൽ, എല്ലാ നിബന്ധനകൾക്കും സ്ട്രിംഗ് പരിവർത്തനം ബാധകമാണ്.

ശ്രദ്ധിക്കുക. അത്തരം പരിവർത്തനങ്ങൾക്ക് ഉത്തരവാദികളായ രീതികൾ സാധാരണയായി വസ്തുവിന്റെ പാരന്റ് പ്രോട്ടോടൈപ്പുകളിൽ നടപ്പിലാക്കുന്നു, മൂല്യംഓഫ് и സ്ട്രിംഗിലേക്ക്. മൂല്യംഓഫ് സംഖ്യാ പരിവർത്തന സമയത്തും എല്ലായ്പ്പോഴും രീതിക്ക് മുമ്പും വിളിക്കുന്നു സ്ട്രിംഗിലേക്ക്. രീതി മൂല്യംഓഫ് പ്രാകൃത മൂല്യങ്ങൾ നൽകണം, അല്ലാത്തപക്ഷം അതിന്റെ ഫലം അവഗണിക്കപ്പെടും.

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

ഉദാഹരണത്തിന്, ഒബ്ജക്റ്റിനാണെങ്കിൽ 'ഒബ്ജക്റ്റ്' രീതി നിർവചിച്ചിരിക്കുന്നു സ്ട്രിംഗിലേക്ക്,

`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 വിതരണത്തോടൊപ്പം വരുന്ന Webhooks ഉം ഔട്ട്-ഓഫ്-ദി-ബോക്‌സ് ഇന്റഗ്രേഷനുകളും സജീവമായി വികസിപ്പിക്കുന്നു.

• നിരസിക്കുക
• ജിര
• ജിറ സർവീസ് ഡെസ്ക്
• പ്രധാനം
• മൈക്രോസോഫ്റ്റ് ടീമുകൾ
• ഒപ്സ്ജെനിഎ
• OTR
• പേജർഡ്യൂട്ടി
• പുഷ്ഓവർ
• റെഡ്മിൻ
• സർവീസ് ഇപ്പോൾ
• SINGL4
• മടിയുള്ള
• കന്വിസന്ദേശം
• സമ്മാദ്
• Zendesk

ഇതിലേക്കുള്ള ലിങ്ക് പ്രമാണീകരണം

പ്രീപ്രൊസസ്സിംഗ്

• ജാവാസ്ക്രിപ്റ്റിലെ പ്രീപ്രോസസിംഗിന്റെ വരവ് മിക്ക ബാഹ്യ സ്ക്രിപ്റ്റുകളും ഉപേക്ഷിക്കുന്നത് സാധ്യമാക്കി, നിലവിൽ Zabbix-ൽ നിങ്ങൾക്ക് ഏത് മൂല്യവും നേടാനും അത് തികച്ചും വ്യത്യസ്തമായ മൂല്യത്തിലേക്ക് പരിവർത്തനം ചെയ്യാനും കഴിയും.
• Zabbix-ൽ പ്രീപ്രോസസിംഗ് നടത്തുന്നത് JavaScript കോഡ് ഉപയോഗിച്ചാണ്, അത് ബൈറ്റ്കോഡിലേക്ക് കംപൈൽ ചെയ്യുമ്പോൾ, ഒരൊറ്റ മൂല്യത്തെ ഒരു പാരാമീറ്ററായി എടുക്കുന്ന ഒരു ഫംഗ്‌ഷനായി പരിവർത്തനം ചെയ്യപ്പെടുന്നു. മൂല്യം ഒരു സ്ട്രിംഗായി (ഒരു സ്ട്രിംഗിൽ ഒരു അക്കവും അക്കവും അടങ്ങിയിരിക്കാം).
• ഔട്ട്പുട്ട് ഒരു ഫംഗ്ഷൻ ആയതിനാൽ, സ്ക്രിപ്റ്റിന്റെ അവസാനം ആവശ്യമാണ് മടക്കം.
• കോഡിൽ ഇഷ്‌ടാനുസൃത മാക്രോകൾ ഉപയോഗിക്കാൻ കഴിയും.
• ഉറവിടങ്ങൾ ഓപ്പറേറ്റിംഗ് സിസ്റ്റം തലത്തിൽ മാത്രമല്ല, പ്രോഗ്രാമാറ്റിക് തലത്തിലും പരിമിതപ്പെടുത്താം. പ്രീപ്രോസസിംഗ് ഘട്ടത്തിന് പരമാവധി 10 മെഗാബൈറ്റ് റാമും 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 സെക്കൻഡിലും ഒരിക്കൽ ചെക്ക് നടത്തുന്നു, Zabbix 29 സെക്കൻഡ് "ഹാക്ക്" ചെയ്യുന്നു, അവസാന സെക്കൻഡിൽ അത് പരിശോധിക്കാനും കണക്കുകൂട്ടാനും തുടങ്ങുന്നു. ഇത് ഒരു ക്യൂ സൃഷ്ടിക്കുകയും പ്രകടനത്തെ ബാധിക്കുകയും ചെയ്യുന്നു. അതിനാൽ, അത് ശരിക്കും ആവശ്യമെങ്കിൽ മാത്രം നിശ്ചിത ഇടവേളകൾ ഉപയോഗിക്കാൻ ശുപാർശ ചെയ്യുന്നു.

ഈ പ്രശ്‌നത്തിൽ, ഡിഗ്രി ഫാരൻഹീറ്റിനെ ഡിഗ്രി സെൽഷ്യസിലേക്ക് പരിവർത്തനം ചെയ്യുന്ന ഒരു-വരി ജാവാസ്ക്രിപ്റ്റ് പ്രീപ്രോസസ്സിംഗ് ആണ് ഒപ്റ്റിമൽ പരിഹാരം:

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

ഇത് വേഗതയേറിയതും എളുപ്പവുമാണ്, നിങ്ങൾക്ക് അനാവശ്യ ഡാറ്റ ഇനങ്ങൾ സൃഷ്‌ടിക്കുകയും അവയിൽ ഒരു ചരിത്രം സൂക്ഷിക്കുകയും ചെയ്യേണ്ടതില്ല, കൂടാതെ പരിശോധനകൾക്കായി നിങ്ങൾക്ക് വഴക്കമുള്ള ഇടവേളകളും ഉപയോഗിക്കാം.

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

പക്ഷേ, ഒരു സാങ്കൽപ്പിക സാഹചര്യത്തിൽ സ്വീകരിച്ച ഡാറ്റ ഘടകം ചേർക്കേണ്ടത് ആവശ്യമാണെങ്കിൽ, ഉദാഹരണത്തിന്, മാക്രോയിൽ നിർവചിച്ചിരിക്കുന്ന ഏതെങ്കിലും സ്ഥിരതയോടൊപ്പം, അത് കണക്കിലെടുക്കേണ്ടതാണ് പരാമീറ്റർ മൂല്യം ഒരു സ്ട്രിംഗായി വികസിക്കുന്നു. ഒരു സ്ട്രിംഗ് അഡീഷൻ ഓപ്പറേഷനിൽ, രണ്ട് സ്ട്രിംഗുകൾ ഒന്നായി കൂട്ടിച്ചേർക്കുന്നു.

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

ഒരു ഗണിത പ്രവർത്തനത്തിന്റെ ഫലം ലഭിക്കുന്നതിന്, ലഭിച്ച മൂല്യങ്ങളുടെ തരങ്ങൾ ഒരു സംഖ്യാ ഫോർമാറ്റിലേക്ക് പരിവർത്തനം ചെയ്യേണ്ടത് ആവശ്യമാണ്. ഇതിനായി നിങ്ങൾക്ക് ഫംഗ്ഷൻ ഉപയോഗിക്കാം parseInt(), ഒരു പൂർണ്ണസംഖ്യ, ഒരു ഫംഗ്ഷൻ ഉത്പാദിപ്പിക്കുന്നു parseFloat(), ഇത് ഒരു ദശാംശം അല്ലെങ്കിൽ ഒരു ഫംഗ്ഷൻ ഉണ്ടാക്കുന്നു അക്കം, ഇത് ഒരു പൂർണ്ണസംഖ്യ അല്ലെങ്കിൽ ദശാംശം നൽകുന്നു.

ടാസ്ക് 2

സർട്ടിഫിക്കറ്റിന്റെ അവസാനം വരെ നിമിഷങ്ങൾക്കുള്ളിൽ സമയം നേടുക.

അവസ്ഥ: ഒരു സേവനം "ഫെബ്രുവരി 12 12:33:56 2022 GMT" ഫോർമാറ്റിൽ ഒരു സർട്ടിഫിക്കറ്റ് കാലഹരണ തീയതി നൽകുന്നു.

ECMAScript5-ൽ 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 മുതൽ ഭാവിയിലെ ചില ഘട്ടങ്ങൾ വരെയുള്ള സെക്കൻഡുകളുടെ എണ്ണമാണ്. ട്രിഗറുകളിൽ സ്വീകരിച്ച ഫോർമാറ്റിൽ ഡാറ്റ ഉപയോഗിക്കുന്നത് മിക്കവാറും അസാധ്യമാണ്, കാരണം Macros ഉപയോഗിച്ച് മാത്രം പ്രവർത്തിക്കാൻ Zabbix നിങ്ങളെ അനുവദിക്കുന്നു {തീയതി} и {സമയം}, ഒരു ഉപയോക്തൃ-സൗഹൃദ ഫോർമാറ്റിൽ തീയതിയും സമയവും നൽകുന്നു.

• അതിനുശേഷം നമുക്ക് ജാവാസ്ക്രിപ്റ്റിൽ നിലവിലുള്ള തീയതി യുണിക്സ് ടൈംസ്റ്റാമ്പ് ഫോർമാറ്റിൽ നേടുകയും ഫലമായുണ്ടാകുന്ന സർട്ടിഫിക്കറ്റ് കാലഹരണപ്പെടൽ തീയതിയിൽ നിന്ന് അത് കുറയ്ക്കുകയും, ഇപ്പോൾ മുതൽ സർട്ടിഫിക്കറ്റ് കാലഹരണപ്പെടുന്നതുവരെയുള്ള മില്ലിസെക്കൻഡുകളുടെ എണ്ണം നേടുകയും ചെയ്യാം.

`now = Date.now();`

• Zabbix-ൽ സെക്കൻഡ് ലഭിക്കുന്നതിന് ലഭിച്ച മൂല്യത്തെ ആയിരം കൊണ്ട് ഹരിക്കുന്നു.

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

ട്രിഗറിൽ, നിങ്ങൾക്ക് ' എന്ന പദപ്രയോഗം വ്യക്തമാക്കാംഅവസാനത്തെ' നിങ്ങൾ പ്രതികരിക്കാൻ ആഗ്രഹിക്കുന്ന കാലയളവിലെ സെക്കൻഡുകളുടെ എണ്ണവുമായി പൊരുത്തപ്പെടുന്ന ഒരു കൂട്ടം അക്കങ്ങൾ പിന്തുടരുന്നു, ഉദാഹരണത്തിന്, ആഴ്ചകളിൽ. അങ്ങനെ, സർട്ടിഫിക്കറ്റ് ഒരാഴ്ചയ്ക്കുള്ളിൽ കാലഹരണപ്പെടുമെന്ന് ട്രിഗർ അറിയിക്കും.

ശ്രദ്ധിക്കുക. ഉപയോഗത്തിൽ ശ്രദ്ധിക്കുക parseInt() പ്രവർത്തനത്തിൽ മടക്കംമില്ലിസെക്കൻഡുകളുടെ വിഭജനത്തിന്റെ ഫലമായുണ്ടാകുന്ന ഭിന്നസംഖ്യയെ ഒരു പൂർണ്ണസംഖ്യയാക്കി മാറ്റുന്നതിന്. നിങ്ങൾക്ക് ഉപയോഗിക്കാനും കഴിയും parseFloat() ഫ്രാക്ഷണൽ ഡാറ്റ സംഭരിക്കുകയും.

റിപ്പോർട്ട് കാണുക

അവലംബം: www.habr.com