🥇ដោះស្រាយបញ្ហាជាក់ស្តែងនៅក្នុង Zabbix ដោយប្រើ JavaScript

Tikhon Uskov, វិស្វករក្រុមសមាហរណកម្ម Zabbix

Zabbix គឺជាវេទិកាដែលអាចប្ដូរតាមបំណងដែលត្រូវបានប្រើដើម្បីតាមដានទិន្នន័យប្រភេទណាមួយ។ ចាប់តាំងពីកំណែដំបូងបំផុតរបស់ Zabbix អ្នកគ្រប់គ្រងត្រួតពិនិត្យមានសមត្ថភាពក្នុងការដំណើរការស្គ្រីបផ្សេងៗតាមរយៈ សកម្មភាព សម្រាប់ការត្រួតពិនិត្យលើថ្នាំងបណ្តាញគោលដៅ។ ទន្ទឹមនឹងនេះ ការបើកដំណើរការស្គ្រីបបាននាំឱ្យមានការលំបាកមួយចំនួន រួមមានដូចជា តម្រូវការគាំទ្រស្គ្រីប ការចែកចាយរបស់ពួកគេទៅកាន់ថ្នាំងទំនាក់ទំនង និងប្រូកស៊ី ក៏ដូចជាការគាំទ្រសម្រាប់កំណែផ្សេងៗគ្នា។

JavaScript សម្រាប់ Zabbix

នៅក្នុងខែមេសា ឆ្នាំ 2019 Zabbix 4.2 ត្រូវបានណែនាំជាមួយនឹងការដំណើរការ JavaScript ជាមុន។ មនុស្សជាច្រើនមានការរំភើបចំពោះគំនិតនៃការបោះបង់ចោលការសរសេរស្គ្រីបដែលយកទិន្នន័យនៅកន្លែងណាមួយ រំលាយវា និងផ្តល់វាក្នុងទម្រង់ដែល Zabbix យល់ ហើយធ្វើការត្រួតពិនិត្យសាមញ្ញដែលនឹងទទួលបានទិន្នន័យដែលមិនទាន់រួចរាល់សម្រាប់ការផ្ទុក និងដំណើរការដោយ Zabbix និង បន្ទាប់មកដំណើរការស្ទ្រីមទិន្នន័យនេះដោយប្រើឧបករណ៍ Zabbix និង JavaScript ។ ដោយភ្ជាប់ជាមួយនឹងការរកឃើញកម្រិតទាប និងធាតុអាស្រ័យដែលបានបង្ហាញខ្លួននៅក្នុង Zabbix 3.4 យើងទទួលបានគំនិតដែលអាចបត់បែនបានសម្រាប់តម្រៀប និងគ្រប់គ្រងទិន្នន័យដែលទទួលបាន។

នៅក្នុង Zabbix 4.4 ជាការបន្តឡូជីខលនៃការដំណើរការមុននៅក្នុង JavaScript វិធីសាស្ត្រជូនដំណឹងថ្មីមួយបានបង្ហាញខ្លួន - Webhook ដែលអាចត្រូវបានប្រើដើម្បីរួមបញ្ចូលការជូនដំណឹង Zabbix យ៉ាងងាយស្រួលជាមួយកម្មវិធីភាគីទីបី។

JavaScript និង Duktapes

ហេតុអ្វីបានជា JavaScript និង Duktape ត្រូវបានជ្រើសរើស? ជម្រើសផ្សេងៗសម្រាប់ភាសា និងម៉ាស៊ីនត្រូវបានពិចារណា៖

លូ - Lua 5.1
លូ - LuaJIT
Javascript - Duktape
Javascript - JerryScript
បានបង្កប់ Python
បង្កប់ Perl

លក្ខណៈវិនិច្ឆ័យជ្រើសរើសចម្បងគឺ អត្រាប្រេវ៉ាឡង់ ភាពងាយស្រួលនៃការរួមបញ្ចូលម៉ាស៊ីនទៅក្នុងផលិតផល ការប្រើប្រាស់ធនធានទាប និងដំណើរការទូទៅរបស់ម៉ាស៊ីន និងសុវត្ថិភាពនៃការណែនាំកូដជាភាសានេះទៅក្នុងការត្រួតពិនិត្យ។ ដោយផ្អែកលើការរួមបញ្ចូលគ្នានៃសូចនាករ JavaScript បានឈ្នះលើម៉ាស៊ីន Duktape ។

លក្ខណៈវិនិច្ឆ័យជ្រើសរើស និងការធ្វើតេស្តការអនុវត្ត

លក្ខណៈពិសេសរបស់ Duktape៖

- ស្តង់ដារ ECMAScript E5/E5.1
- ម៉ូឌុល Zabbix សម្រាប់ Duktape៖

Zabbix.log() - អនុញ្ញាតឱ្យអ្នកសរសេរសារដែលមានកម្រិតខុសៗគ្នានៃព័ត៌មានលម្អិតដោយផ្ទាល់ទៅក្នុងកំណត់ហេតុម៉ាស៊ីនមេ Zabbix ដែលធ្វើឱ្យវាអាចធ្វើទៅបានដើម្បីកែតម្រូវកំហុសឧទាហរណ៍នៅក្នុង Webhook ជាមួយនឹងស្ថានភាពម៉ាស៊ីនមេ។
CurlHttpRequest() - អនុញ្ញាតឱ្យអ្នកធ្វើសំណើ HTTP ទៅកាន់បណ្តាញ ដែលការប្រើប្រាស់ Webhook មានមូលដ្ឋាន។
atob() និង btoa() - អនុញ្ញាតឱ្យអ្នកអ៊ិនកូដ និងឌិកូដខ្សែអក្សរក្នុងទម្រង់ Base64 ។

ចំណាំ។. Duktape អនុលោមតាមស្តង់ដារ ACME ។ Zabbix ប្រើកំណែ 2015 នៃស្គ្រីប។ ការផ្លាស់ប្តូរជាបន្តបន្ទាប់គឺតូចតាច ដូច្នេះពួកគេអាចត្រូវបានគេមិនអើពើ។.

JavaScript Magic

វេទមន្តទាំងអស់នៃ JavaScript ស្ថិតនៅក្នុងការវាយអក្សរ និងវាយអក្សរថាមវន្ត៖ ខ្សែអក្សរ លេខ និងប៊ូលីន។

នេះមានន័យថា វាមិនចាំបាច់ក្នុងការប្រកាសជាមុននូវអ្វីដែលប្រភេទអថេរគួរតែត្រឡប់តម្លៃនោះទេ។

ក្នុងប្រតិបត្តិការគណិតវិទ្យា តម្លៃត្រឡប់ដោយអនុគមន៍ត្រូវបានបំប្លែងទៅជាលេខ។ ការលើកលែងចំពោះប្រតិបត្តិការបែបនេះគឺជាការបន្ថែម ពីព្រោះប្រសិនបើយ៉ាងហោចណាស់លក្ខខណ្ឌមួយគឺជាខ្សែអក្សរ ការបំប្លែងខ្សែអក្សរត្រូវបានអនុវត្តចំពោះលក្ខខណ្ឌទាំងអស់។

ចំណាំ។. វិធីសាស្រ្តដែលទទួលខុសត្រូវចំពោះការបំប្លែងបែបនេះជាធម្មតាត្រូវបានអនុវត្តនៅក្នុងគំរូមេរបស់វត្ថុ តំលៃនៃ и ខ្សែអក្សរ. តំលៃនៃ បានហៅក្នុងអំឡុងពេលបំប្លែងជាលេខ ហើយតែងតែមុនវិធីសាស្ត្រ ខ្សែអក្សរ. វិធីសាស្រ្ត តំលៃនៃ ត្រូវតែត្រឡប់តម្លៃបឋម បើមិនដូច្នេះទេលទ្ធផលរបស់វាមិនត្រូវបានគេអើពើ។

វិធីសាស្រ្តមួយត្រូវបានហៅនៅលើវត្ថុមួយ។ តំលៃនៃ. ប្រសិនបើវាមិនត្រូវបានរកឃើញ ឬមិនត្រឡប់តម្លៃបឋមទេ វិធីសាស្ត្រត្រូវបានគេហៅថា ខ្សែអក្សរ. ប្រសិនបើវិធីសាស្រ្ត ខ្សែអក្សរ រកមិនឃើញ, ស្វែងរក តំលៃនៃ នៅក្នុងគំរូវត្ថុ ហើយអ្វីគ្រប់យ៉ាងត្រូវបានធ្វើឡើងវិញរហូតដល់ដំណើរការនៃតម្លៃត្រូវបានបញ្ចប់ ហើយតម្លៃទាំងអស់ក្នុងកន្សោមត្រូវបានបោះទៅប្រភេទដូចគ្នា. ប្រសិនបើវត្ថុអនុវត្តវិធីសាស្ត្រ ខ្សែអក្សរដែលត្រឡប់តម្លៃបឋម បន្ទាប់មកវាគឺជាវាដែលត្រូវបានប្រើសម្រាប់ការបំប្លែងខ្សែអក្សរ។ ទោះជាយ៉ាងណាក៏ដោយលទ្ធផលនៃការអនុវត្តវិធីសាស្រ្តនេះមិនចាំបាច់ជាខ្សែអក្សរទេ។

ឧទាហរណ៍ ប្រសិនបើសម្រាប់វត្ថុ 'objវិធីសាស្រ្តត្រូវបានកំណត់ ខ្សែអក្សរ,

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

វិធីសាស្រ្ត ខ្សែអក្សរ ត្រឡប់ខ្សែពិតប្រាកដមួយ ហើយពេលបន្ថែមខ្សែអក្សរជាមួយលេខ យើងទទួលបានខ្សែដែលស្អិតជាប់៖

`obj + 1 // '2001'` 

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

ប៉ុន្តែប្រសិនបើអ្នកសរសេរឡើងវិញ ខ្សែអក្សរដូច្នេះវិធីសាស្ត្រត្រឡប់លេខវិញ នៅពេលវត្ថុត្រូវបានបន្ថែម ប្រតិបត្តិការគណិតវិទ្យាជាមួយការបំប្លែងលេខនឹងត្រូវបានអនុវត្ត ហើយលទ្ធផលនៃការបន្ថែមគណិតវិទ្យានឹងត្រូវបានទទួល។

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

`obj + 1 // '2001'`

ក្នុងករណីនេះ ប្រសិនបើយើងធ្វើការបន្ថែមជាមួយខ្សែអក្សរ ការបំប្លែងខ្សែមួយត្រូវបានអនុវត្ត ហើយយើងទទួលបានខ្សែដែលស្អិតជាប់។

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

នេះជាហេតុផលសម្រាប់កំហុសមួយចំនួនធំដោយអ្នកប្រើប្រាស់ JavaScript ថ្មីថ្មោង។

វិធីសាស្រ្ត ខ្សែអក្សរ អ្នកអាចសរសេរមុខងារដែលនឹងបង្កើនតម្លៃបច្ចុប្បន្នរបស់វត្ថុដោយ 1 ។

ការប្រតិបត្តិនៃស្គ្រីបដែលផ្តល់ថាអថេរស្មើនឹង 3 ហើយវាក៏ស្មើនឹង 4 ផងដែរ។

នៅពេលប្រៀបធៀបជាមួយតួ (==) វិធីសាស្ត្រត្រូវបានប្រតិបត្តិរាល់ពេល ខ្សែអក្សរ ជាមួយនឹងមុខងារបង្កើនតម្លៃ។ ដូច្នោះហើយជាមួយនឹងការប្រៀបធៀបជាបន្តបន្ទាប់នីមួយៗតម្លៃកើនឡើង។ នេះអាចត្រូវបានជៀសវាងដោយប្រើការប្រៀបធៀបមិនខាស (===) ។

ការប្រៀបធៀបដោយគ្មានប្រភេទ

ចំណាំ។. កុំប្រើការប្រៀបធៀបខាសដោយមិនចាំបាច់.

សម្រាប់ស្គ្រីបស្មុគ្រស្មាញ ដូចជា Webhooks ដែលមានតក្កវិជ្ជាស្មុគ្រស្មាញ ដែលទាមទារឱ្យមានការប្រៀបធៀបជាមួយនឹងការបញ្ជូនប្រភេទ វាត្រូវបានណែនាំឱ្យសរសេរការត្រួតពិនិត្យជាមុនសម្រាប់តម្លៃដែលត្រឡប់អថេរ និងដោះស្រាយភាពមិនស៊ីសង្វាក់គ្នា និងកំហុស។

ប្រព័ន្ធផ្សព្វផ្សាយ Webhook

នៅចុងឆ្នាំ 2019 និងដើមឆ្នាំ 2020 ក្រុមសមាហរណកម្ម Zabbix បាននិងកំពុងអភិវឌ្ឍយ៉ាងសកម្មនូវ Webhooks និងការរួមបញ្ចូលក្រៅប្រអប់ដែលភ្ជាប់មកជាមួយការចែកចាយ Zabbix ។

ភ្ជាប់ទៅ ឯកសារ

កំពុងដំណើរការ

ការមកដល់នៃដំណើរការមុននៅក្នុង JavaScript បានធ្វើឱ្យវាអាចធ្វើទៅបានដើម្បីបោះបង់ចោលស្គ្រីបខាងក្រៅភាគច្រើន ហើយបច្ចុប្បន្ននៅក្នុង Zabbix អ្នកអាចទទួលបានតម្លៃណាមួយ ហើយបម្លែងវាទៅជាតម្លៃខុសគ្នាទាំងស្រុង។
ការដំណើរការជាមុននៅក្នុង Zabbix ត្រូវបានអនុវត្តដោយកូដ JavaScript ដែលនៅពេលចងក្រងជា bytecode ត្រូវបានបំប្លែងទៅជាមុខងារដែលយកតម្លៃតែមួយជាប៉ារ៉ាម៉ែត្រ តម្លៃ ជាខ្សែអក្សរ (ខ្សែអក្សរអាចមានទាំងលេខ និងលេខ)។
ដោយសារលទ្ធផលគឺជាមុខងារមួយ នៅចុងបញ្ចប់នៃស្គ្រីបគឺត្រូវបានទាមទារ ត្រឡប់មកវិញ.
វាអាចទៅរួចក្នុងការប្រើម៉ាក្រូផ្ទាល់ខ្លួននៅក្នុងកូដ។
ធនធានអាចត្រូវបានកំណត់មិនត្រឹមតែនៅកម្រិតប្រព័ន្ធប្រតិបត្តិការប៉ុណ្ណោះទេ ប៉ុន្តែក៏មានកម្មវិធីផងដែរ។ ជំហានដំណើរការមុនត្រូវបានបែងចែក RAM អតិបរមា 10 មេហ្គាបៃ និងកំណត់ពេលវេលាដំណើរការ 10 វិនាទី។

ចំណាំ។. តម្លៃអស់ពេល 10 វិនាទីគឺច្រើនណាស់ ពីព្រោះការប្រមូលធាតុទិន្នន័យរាប់ពាន់តាមលក្ខខណ្ឌក្នុងរយៈពេល 1 វិនាទី យោងទៅតាមសេណារីយ៉ូដែលដំណើរការមុន "ធ្ងន់" អាចបន្ថយ Zabbix ។ ដូច្នេះ វាមិនត្រូវបានណែនាំអោយប្រើការដំណើរការជាមុនដើម្បីប្រតិបត្តិស្គ្រីប JavaScript ពេញលេញតាមរយៈអ្វីដែលគេហៅថា ធាតុទិន្នន័យស្រមោល (ធាតុអត់ចេះសោះ) ដែលដំណើរការសម្រាប់តែដំណើរការមុនប៉ុណ្ណោះ។.

អ្នកអាចពិនិត្យលេខកូដរបស់អ្នកតាមរយៈការធ្វើតេស្តដំណើរការមុន ឬដោយប្រើឧបករណ៍ប្រើប្រាស់ 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

ជំនួសធាតុដែលបានគណនាដោយដំណើរការមុន។

លក្ខខណ្ឌ៖ ទទួលបានសីតុណ្ហភាពក្នុង Fahrenheit ពីឧបករណ៍ចាប់សញ្ញា ដើម្បីរក្សាទុកក្នុងអង្សាសេ។

ពីមុន យើងនឹងបង្កើតធាតុដែលប្រមូលសីតុណ្ហភាពជាដឺក្រេហ្វារិនហៃ។ បន្ទាប់ពីនោះ ធាតុទិន្នន័យមួយទៀត (គណនា) ដែលនឹងបំប្លែង Fahrenheit ទៅអង្សាសេ ដោយប្រើរូបមន្តមួយ។

បញ្ហា:

វាចាំបាច់ក្នុងការចម្លងធាតុទិន្នន័យ និងរក្សាទុកតម្លៃទាំងអស់នៅក្នុងមូលដ្ឋានទិន្នន័យ។
អ្នកត្រូវតែយល់ព្រមលើចន្លោះពេលសម្រាប់ធាតុទិន្នន័យ "មេ" ដែលត្រូវបានគណនា និងប្រើក្នុងរូបមន្ត និងសម្រាប់ធាតុទិន្នន័យដែលបានគណនា។ បើមិនដូច្នោះទេ ធាតុដែលបានគណនាអាចចូលទៅក្នុងស្ថានភាពដែលមិនគាំទ្រ ឬគណនាតម្លៃពីមុន ដែលនឹងប៉ះពាល់ដល់ភាពជឿជាក់នៃលទ្ធផលត្រួតពិនិត្យ។

ដំណោះស្រាយមួយគឺត្រូវផ្លាស់ទីឆ្ងាយពីចន្លោះពេលត្រួតពិនិត្យដែលអាចបត់បែនបាន នៅក្នុងការពេញចិត្តនៃចន្លោះពេលថេរ ដើម្បីធានាថាធាតុដែលបានគណនាត្រូវបានវាយតម្លៃបន្ទាប់ពីធាតុដែលទទួលបានទិន្នន័យ (ក្នុងករណីរបស់យើង សីតុណ្ហភាពគិតជាដឺក្រេហ្វារិនហៃ)។

ប៉ុន្តែប្រសិនបើឧទាហរណ៍យើងប្រើគំរូដើម្បីពិនិត្យមើលឧបករណ៍មួយចំនួនធំហើយការត្រួតពិនិត្យត្រូវបានអនុវត្តម្តងរៀងរាល់ 30 វិនាទី Zabbix "hack" រយៈពេល 29 វិនាទីហើយនៅវិនាទីចុងក្រោយវាចាប់ផ្តើមពិនិត្យនិងគណនា។ វាបង្កើតជាជួរ និងប៉ះពាល់ដល់ដំណើរការ។ ដូច្នេះវាត្រូវបានផ្ដល់អនុសាសន៍ឱ្យប្រើចន្លោះពេលថេរលុះត្រាតែវាពិតជាចាំបាច់។

ក្នុងបញ្ហានេះ ដំណោះស្រាយដ៏ល្អប្រសើរគឺការដំណើរការ JavaScript មុនមួយជួរដែលបំប្លែងដឺក្រេហ្វារិនហៃទៅអង្សាសេ៖

`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 ដល់ចំណុចមួយចំនួននាពេលអនាគត។ វាស្ទើរតែមិនអាចទៅរួចទេក្នុងការប្រើទិន្នន័យក្នុងទម្រង់ដែលបានទទួលនៅក្នុងកេះ ពីព្រោះ Zabbix អនុញ្ញាតឱ្យអ្នកដំណើរការតែជាមួយម៉ាក្រូប៉ុណ្ណោះ។ {កាលបរិច្ឆេទ} и {ពេលវេលា}ដែលត្រឡប់កាលបរិច្ឆេទ និងពេលវេលាក្នុងទម្រង់ដែលងាយស្រួលប្រើ។

បន្ទាប់មកយើងអាចទទួលបានកាលបរិច្ឆេទបច្ចុប្បន្នជា JavaScript ក្នុងទម្រង់ Unix Timestamp ហើយដកវាចេញពីកាលបរិច្ឆេទផុតកំណត់វិញ្ញាបនបត្រលទ្ធផល ដើម្បីទទួលបានចំនួនមីលីវិនាទីចាប់ពីពេលនេះរហូតដល់វិញ្ញាបនបត្រផុតកំណត់។

`now = Date.now();`

យើងបែងចែកតម្លៃដែលទទួលបានដោយមួយពាន់ដើម្បីទទួលបានវិនាទីនៅក្នុង Zabbix ។

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

នៅក្នុងគន្លឹះ អ្នកអាចបញ្ជាក់កន្សោម 'ចុងក្រោយ' តាមពីក្រោយដោយសំណុំនៃខ្ទង់ដែលត្រូវគ្នានឹងចំនួនវិនាទីនៅក្នុងរយៈពេលដែលអ្នកចង់ឆ្លើយតប ឧទាហរណ៍ក្នុងសប្តាហ៍។ ដូច្នេះ គន្លឹះនឹងជូនដំណឹងថាវិញ្ញាបនបត្រផុតកំណត់ក្នុងរយៈពេលមួយសប្តាហ៍។

ចំណាំ។. យកចិត្តទុកដាក់ចំពោះការប្រើប្រាស់ parseInt() នៅក្នុងមុខងារ ត្រឡប់មកវិញដើម្បីបំប្លែងចំនួនប្រភាគដែលកើតចេញពីការបែងចែកមីលីវិនាទីទៅជាចំនួនគត់។ អ្នកក៏អាចប្រើផងដែរ។ parseFloat() និងរក្សាទុកទិន្នន័យប្រភាគ.

មើលរបាយការណ៍

ប្រភព: www.habr.com

យើងដោះស្រាយបញ្ហាជាក់ស្តែងនៅក្នុង Zabbix ដោយប្រើ JavaScript