અમે JavaScript નો ઉપયોગ કરીને Zabbix માં વ્યવહારુ સમસ્યાઓ હલ કરીએ છીએ

ટીખોન ઉસ્કોવ, Zabbix એકીકરણ ટીમ એન્જિનિયર

Zabbix એક કસ્ટમાઇઝ પ્લેટફોર્મ છે જેનો ઉપયોગ કોઈપણ પ્રકારના ડેટાને મોનિટર કરવા માટે થાય છે. Zabbix ના પ્રારંભિક સંસ્કરણોથી, મોનિટરિંગ એડમિનિસ્ટ્રેટરો પાસે વિવિધ સ્ક્રિપ્ટો દ્વારા ચલાવવાની ક્ષમતા છે. ક્રિયાઓ લક્ષ્ય નેટવર્ક નોડ્સ પર તપાસ માટે. તે જ સમયે, સ્ક્રિપ્ટના લોન્ચિંગથી ઘણી મુશ્કેલીઓ આવી, જેમાં સ્ક્રિપ્ટ્સને સપોર્ટ કરવાની જરૂરિયાત, કોમ્યુનિકેશન નોડ્સ અને પ્રોક્સીઝને તેમની ડિલિવરી તેમજ વિવિધ વર્ઝન માટે સપોર્ટ સહિતનો સમાવેશ થાય છે.

Zabbix માટે JavaScript

એપ્રિલ 2019 માં, Zabbix 4.2 ને JavaScript પ્રીપ્રોસેસિંગ સાથે રજૂ કરવામાં આવ્યું હતું. ઘણા લોકો એવી સ્ક્રિપ્ટો લખવાને છોડી દેવાના વિચારથી ઉત્સાહિત થયા કે જે ડેટા ક્યાંક લે છે, તેને ડાયજેસ્ટ કરે છે અને તેને Zabbix સમજે તેવા ફોર્મેટમાં પ્રદાન કરે છે, અને Zabbix દ્વારા સ્ટોરેજ અને પ્રોસેસિંગ માટે તૈયાર ન હોય તેવા ડેટા પ્રાપ્ત થશે તેવી સરળ તપાસ કરે છે, અને પછી Zabbix અને JavaScript ટૂલ્સનો ઉપયોગ કરીને આ ડેટા સ્ટ્રીમ પર પ્રક્રિયા કરો. Zabbix 3.4 માં દેખાતી નિમ્ન-સ્તરની શોધ અને આશ્રિત વસ્તુઓ સાથે જોડાણમાં, અમને પ્રાપ્ત ડેટાને સૉર્ટ કરવા અને મેનેજ કરવા માટે એકદમ લવચીક ખ્યાલ મળ્યો.

Zabbix 4.4 માં, JavaScript માં પ્રી-પ્રોસેસિંગના તાર્કિક ચાલુ તરીકે, એક નવી સૂચના પદ્ધતિ દેખાઈ છે - Webhook, જેનો ઉપયોગ તૃતીય-પક્ષ એપ્લિકેશનો સાથે Zabbix સૂચનાઓને સરળતાથી સંકલિત કરવા માટે થઈ શકે છે.

JavaScript અને Duktapes

JavaScript અને Duktape શા માટે પસંદ કરવામાં આવ્યા? ભાષાઓ અને એન્જિન માટેના વિવિધ વિકલ્પો ધ્યાનમાં લેવામાં આવ્યા હતા:

• લુઆ - લુઆ 5.1
• લુઆ - LuaJIT
• Javascript - Duktape
• જાવાસ્ક્રિપ્ટ - જેરીસ્ક્રિપ્ટ
• એમ્બેડેડ પાયથોન
• એમ્બેડેડ પર્લ

મુખ્ય પસંદગીના માપદંડોમાં પ્રચલિતતા, ઉત્પાદનમાં એન્જિનના એકીકરણની સરળતા, ઓછા સંસાધનનો વપરાશ અને એન્જિનનું એકંદર પ્રદર્શન અને મોનિટરિંગમાં આ ભાષામાં કોડ દાખલ કરવાની સલામતી હતી. સૂચકોના સંયોજનના આધારે, JavaScript ડુક્ટેપ એન્જિન પર જીત્યું.

પસંદગી માપદંડ અને પ્રદર્શન પરીક્ષણ

ડક્ટેપની વિશેષતાઓ:

- ધોરણ ECMAScript E5/E5.1
— ડક્ટેપ માટે ઝબ્બીક્સ મોડ્યુલો:

• Zabbix.log() - તમને Zabbix સર્વર લોગમાં સીધા જ વિગતોના વિવિધ સ્તરો સાથે સંદેશાઓ લખવાની મંજૂરી આપે છે, જે ભૂલોને સહસંબંધિત કરવાનું શક્ય બનાવે છે, ઉદાહરણ તરીકે, વેબહૂકમાં, સર્વર સ્થિતિ સાથે.
• CurlHttpRequest() - તમને નેટવર્ક પર HTTP વિનંતીઓ કરવાની મંજૂરી આપે છે, જેના પર Webhook નો ઉપયોગ આધારિત છે.
• atob() અને btoa() - તમને બેઝ 64 ફોર્મેટમાં સ્ટ્રિંગ્સને એન્કોડ અને ડીકોડ કરવાની મંજૂરી આપે છે.

નોંધ. Duktape ACME ધોરણોનું પાલન કરે છે. Zabbix સ્ક્રિપ્ટના 2015 વર્ઝનનો ઉપયોગ કરે છે. અનુગામી ફેરફારો નાના છે, તેથી તેમને અવગણી શકાય છે..

જાવાસ્ક્રિપ્ટ મેજિક

જાવાસ્ક્રિપ્ટનો તમામ જાદુ ડાયનેમિક ટાઇપિંગ અને ટાઇપ કાસ્ટિંગમાં રહેલો છે: સ્ટ્રિંગ, ન્યુમેરિક અને બુલિયન.

આનો અર્થ એ છે કે અગાઉથી જાહેર કરવું જરૂરી નથી કે વેરીએબલ કયા પ્રકારનું મૂલ્ય પરત કરે.

ગાણિતિક કામગીરીમાં, ફંક્શન ઓપરેટરો દ્વારા પરત કરવામાં આવેલ મૂલ્યોને સંખ્યામાં રૂપાંતરિત કરવામાં આવે છે. આવી કામગીરી માટે અપવાદ એ ઉમેરણ છે, કારણ કે જો ઓછામાં ઓછી એક શબ્દમાળા હોય, તો સ્ટ્રિંગ કન્વર્ઝન તમામ શરતો પર લાગુ થાય છે.

નોંધ. આવા પરિવર્તન માટે જવાબદાર પદ્ધતિઓ સામાન્ય રીતે ઑબ્જેક્ટના પેરેન્ટ પ્રોટોટાઇપ્સમાં લાગુ કરવામાં આવે છે, મૂલ્ય и શબ્દમાળા. મૂલ્ય સંખ્યાત્મક રૂપાંતરણ દરમિયાન અને હંમેશા પદ્ધતિ પહેલાં બોલાવવામાં આવે છે શબ્દમાળા. પદ્ધતિ મૂલ્ય આદિમ મૂલ્યો પરત કરવા જોઈએ, અન્યથા તેનું પરિણામ અવગણવામાં આવશે.

ઑબ્જેક્ટ પર પદ્ધતિ કહેવામાં આવે છે મૂલ્યઓએફ. જો તે મળ્યું નથી અથવા આદિમ મૂલ્ય પરત કરતું નથી, તો પદ્ધતિ કહેવામાં આવે છે શબ્દમાળા. જો પદ્ધતિ શબ્દમાળા શોધવું, મળ્યું નથી મૂલ્ય ઑબ્જેક્ટના પ્રોટોટાઇપમાં, અને જ્યાં સુધી મૂલ્યની પ્રક્રિયા પૂર્ણ ન થાય ત્યાં સુધી બધું જ પુનરાવર્તિત થાય છે અને અભિવ્યક્તિમાંના તમામ મૂલ્યો સમાન પ્રકારમાં નાખવામાં આવે છે.. જો ઑબ્જેક્ટ પદ્ધતિ લાગુ કરે છે શબ્દમાળા, જે એક આદિમ મૂલ્ય પરત કરે છે, તો તે તે છે જેનો ઉપયોગ સ્ટ્રિંગ રૂપાંતરણ માટે થાય છે. જો કે, આ પદ્ધતિ લાગુ કરવાનું પરિણામ એ જરૂરી નથી કે સ્ટ્રિંગ હોય.

ઉદાહરણ તરીકે, જો પદાર્થ માટે 'obj' પદ્ધતિ વ્યાખ્યાયિત કરવામાં આવી છે શબ્દમાળા,

`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 એકીકરણ ટીમ સક્રિયપણે Webhooks અને આઉટ-ઓફ-ધ-બોક્સ એકીકરણ વિકસાવી રહી છે જે Zabbix વિતરણ સાથે આવે છે.

• વિરામ
• Jira
• જીરા સર્વિસ ડેસ્ક
• મેટરમોસ્ટ
• માઈક્રોસોફ્ટ ટીમ્સ
• ઓપ્સજેની
• અન્ય
• પેજરડ્યુટી
• પુશઓવર
• રેડમાઇન
• સેવા હવે
• SINGL4
• સ્લેક
• Telegram
• ઝમ્મદ
• ઝેડેડેસ્ક

લિંક કરો દસ્તાવેજીકરણ

પૂર્વપ્રોસેસિંગ

• JavaScript માં પ્રીપ્રોસેસિંગના આગમનથી મોટાભાગની બાહ્ય સ્ક્રિપ્ટોને છોડી દેવાનું શક્ય બન્યું છે અને હાલમાં Zabbix માં તમે કોઈપણ મૂલ્ય મેળવી શકો છો અને તેને સંપૂર્ણપણે અલગ મૂલ્યમાં રૂપાંતરિત કરી શકો છો.
• Zabbix માં પ્રીપ્રોસેસિંગ જાવાસ્ક્રિપ્ટ કોડ દ્વારા અમલમાં મૂકવામાં આવે છે, જે, જ્યારે બાઈટકોડમાં કમ્પાઈલ કરવામાં આવે છે, ત્યારે તે ફંક્શનમાં રૂપાંતરિત થાય છે જે એક પરિમાણ તરીકે એક મૂલ્ય લે છે કિંમત શબ્દમાળા તરીકે (સ્ટ્રિંગમાં અંક અને સંખ્યા બંને હોઈ શકે છે).
• આઉટપુટ એક કાર્ય હોવાથી, સ્ક્રિપ્ટના અંતે આવશ્યક છે વળતર.
• કોડમાં કસ્ટમ મેક્રોનો ઉપયોગ કરવો શક્ય છે.
• સંસાધનો માત્ર ઓપરેટિંગ સિસ્ટમ સ્તરે જ નહીં, પણ પ્રોગ્રામેટિકલી પણ મર્યાદિત હોઈ શકે છે. પ્રીપ્રોસેસિંગ સ્ટેપને મહત્તમ 10 મેગાબાઇટ્સ RAM અને 10 સેકન્ડની રન ટાઇમ લિમિટ ફાળવવામાં આવી છે.

નોંધ. 10 સેકન્ડનું સમયસમાપ્તિ મૂલ્ય ઘણું ઘણું છે, કારણ કે "ભારે" પ્રીપ્રોસેસિંગ દૃશ્ય અનુસાર 1 સેકન્ડમાં શરતી હજારો ડેટા આઇટમ્સ એકત્રિત કરવાથી ઝબ્બિક્સ ધીમું થઈ શકે છે. તેથી, કહેવાતા શેડો ડેટા એલિમેન્ટ્સ (ડમી આઇટમ્સ) દ્વારા સંપૂર્ણ સુવિધાયુક્ત જાવાસ્ક્રિપ્ટ સ્ક્રિપ્ટ ચલાવવા માટે પ્રીપ્રોસેસિંગનો ઉપયોગ કરવાની ભલામણ કરવામાં આવતી નથી, જે ફક્ત પ્રીપ્રોસેસિંગ કરવા માટે ચલાવવામાં આવે છે..

તમે પ્રીપ્રોસેસિંગ ટેસ્ટ દ્વારા અથવા ઉપયોગિતાનો ઉપયોગ કરીને તમારો કોડ ચકાસી શકો છો 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}");`

ગાણિતિક કામગીરીનું પરિણામ મેળવવા માટે, પ્રાપ્ત મૂલ્યોના પ્રકારોને આંકડાકીય ફોર્મેટમાં રૂપાંતરિત કરવું જરૂરી છે. આ માટે તમે ફંક્શનનો ઉપયોગ કરી શકો છો parseInt(), જે પૂર્ણાંક, એક કાર્ય બનાવે છે પાર્સફ્લોટ(), જે દશાંશ અથવા ફંક્શન બનાવે છે નંબર, જે પૂર્ણાંક અથવા દશાંશ પરત કરે છે.

કાર્ય 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 થી ભવિષ્યમાં અમુક બિંદુ સુધીની સેકંડની સંખ્યા છે. ટ્રિગર્સમાં પ્રાપ્ત ફોર્મેટમાં ડેટાનો ઉપયોગ કરવો લગભગ અશક્ય છે, કારણ કે ઝબ્બીક્સ તમને ફક્ત મેક્રો સાથે કામ કરવાની મંજૂરી આપે છે. {તારીખ и {સમય}, જે વપરાશકર્તા-મૈત્રીપૂર્ણ ફોર્મેટમાં તારીખ અને સમય પરત કરે છે.

• પછી અમે યુનિક્સ ટાઇમસ્ટેમ્પ ફોર્મેટમાં જાવાસ્ક્રિપ્ટમાં વર્તમાન તારીખ મેળવી શકીએ છીએ અને પ્રમાણપત્રની સમયસીમા સમાપ્ત થાય ત્યાં સુધી મિલિસેકન્ડની સંખ્યા મેળવવા માટે પરિણામી પ્રમાણપત્ર સમાપ્તિ તારીખમાંથી તેને બાદ કરી શકીએ છીએ.

`now = Date.now();`

• Zabbix માં સેકન્ડ મેળવવા માટે અમે પ્રાપ્ત મૂલ્યને હજાર વડે વિભાજીત કરીએ છીએ.

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

ટ્રિગરમાં, તમે અભિવ્યક્તિનો ઉલ્લેખ કરી શકો છો 'છેલ્લા' અંકોના સમૂહ દ્વારા અનુસરવામાં આવે છે કે જે સમયગાળામાં તમે પ્રતિસાદ આપવા માંગો છો તે સેકંડની સંખ્યાને અનુરૂપ છે, ઉદાહરણ તરીકે, અઠવાડિયામાં. આમ, ટ્રિગર જાણ કરશે કે પ્રમાણપત્ર એક અઠવાડિયામાં સમાપ્ત થાય છે.

નોંધ. ઉપયોગ પર ધ્યાન આપો parseInt() કાર્યમાં વળતરમિલિસેકંડના વિભાજનથી પરિણમતી અપૂર્ણાંક સંખ્યાને પૂર્ણાંકમાં રૂપાંતરિત કરવા. તમે પણ ઉપયોગ કરી શકો છો પાર્સફ્લોટ() અને અપૂર્ણાંક ડેટા સ્ટોર કરો.

રિપોર્ટ જુઓ

સોર્સ: www.habr.com