Graphite 1.1

Functions




graphite

Functions

फ़ंक्शंस का उपयोग series डेटा पर रूपांतरण, संयोजन और गणना करने के लिए किया जाता है। रेंडर एपीआई में target पैरामीटर्स में फेरबदल करके या कंपोजर इंटरफेस का उपयोग करके फंक्शंस लागू किए जाते हैं।

प्रयोग

अधिकांश फ़ंक्शन एक श्रृंखला सूची में लागू होते हैं। पैरामीटर के साथ कार्य *seriesLists श्रृंखला सूची श्रृंखला सूची का एक मनमाना संख्या ले सकते हैं। एक फ़ंक्शन में कई श्रृंखला सूचियों को पास करने के लिए जो केवल एक लेता है, group() फ़ंक्शन का उपयोग करें।

कार्यों की सूची

निरपेक्ष (seriesList)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखलासूची लेता है और गणितीय डेटा फ़ंक्शन को प्रत्येक डेटापॉइंट पर लागू करता है जो इसे इसके पूर्ण मूल्य में बदल देता है।

उदाहरण:

&target=absolute(Server.instance01.threads.busy)
&target=absolute(Server.instance*.threads.busy)
समुच्चय (श्रृंखलाकार, कवक, xFilesFactor = कोई नहीं)

निर्दिष्ट फ़ंक्शन का उपयोग करके श्रृंखला को अलग करें।

उदाहरण:

&target=aggregate(host.cpu-[0-7].cpu-{user,system}.value, "sum")

यह इसके बराबर होगा

&target=sumSeries(host.cpu-[0-7].cpu-{user,system}.value)

इस फ़ंक्शन का उपयोग एकत्रीकरण कार्यों के average , median , sum , min , max , diff , stddev , count , range , multiply और last

एग्रीगेटलाइन (सीरीज़लिस्ट, फ़ंक = 'औसत', कीपस्टेप = गलत)

एक मीट्रिक या वाइल्डकार्ड श्रृंखला सूची लेता है और प्रत्येक श्रृंखला के लिए लागू फ़ंक्शन के आधार पर एक क्षैतिज रेखा खींचता है।

यदि वैकल्पिक KeepStep पैरामीटर True पर सेट है, तो परिणाम में समयावधि और स्रोत श्रृंखला के समान चरण होगा।

नोट: डिफ़ॉल्ट रूप से, ग्रेफाइट रेंडरर समय के साथ औसत डेटा बिंदुओं द्वारा डेटा बिंदुओं को समेकित करता है। यदि आप समुच्चय के लिए 'मिनट' या 'अधिकतम' फ़ंक्शन का उपयोग कर रहे हैं, तो यह इस फ़ंक्शन द्वारा खींची गई रेखा और डेटा में एक असामान्य अंतर पैदा कर सकता है। इसे ठीक करने के लिए, आपको समेकित कार्य () फ़ंक्शन को उसी फ़ंक्शन तर्क के साथ उपयोग करना चाहिए जिसे आप कुल एकत्रित कर रहे हैं। यह सुनिश्चित करेगा कि उचित डेटा बिंदुओं को बरकरार रखा जाए और ग्राफ को सही ढंग से पंक्तिबद्ध किया जाए।

उदाहरण:

&target=aggregateLine(server01.connections.total, 'avg')
&target=aggregateLine(server*.connections.total, 'avg')
एग्रीगेटविल्डवार्डकार्ड (सीरिज़लिस्ट, फंक, * पोज़िशन)

दी गई स्थिति में वाइल्डकार्ड डालने के बाद एग्रीगेटर को बुलाएं।

उदाहरण:

&target=aggregateWithWildcards(host.cpu-[0-7].cpu-{user,system}.value, "sum", 1)

यह इसके बराबर होगा

&target=sumSeries(host.cpu-[0-7].cpu-user.value)&target=sumSeries(host.cpu-[0-7].cpu-system.value)
# or
&target=aggregate(host.cpu-[0-7].cpu-user.value,"sum")&target=aggregate(host.cpu-[0-7].cpu-system.value,"sum")

इस फ़ंक्शन का उपयोग एग्रीगेट द्वारा समर्थित सभी एकत्रीकरण कार्यों के साथ किया जा सकता है: average , median , sum , min , max , diff , stddev , range और multiply

यह groupByNodes पूरक groupByNodes जो प्रत्येक समूह में मेल खाने वाले नोड्स की एक सूची लेता है।

उर्फ (श्रृंखलाकार, नया नाम)

एक मीट्रिक या वाइल्डकार्ड श्रृंखला सूची और उद्धरण में एक स्ट्रिंग लेता है। किंवदंती में मीट्रिक नाम के बजाय स्ट्रिंग प्रिंट करता है।

&target=alias(Sales.widgets.largeBlue,"Large Blue Widgets")
aliasByMetric (seriesList)

एक श्रृंखला सूची लेता है और बेस मेट्रिक नाम से प्राप्त एक उपनाम लागू करता है।

&target=aliasByMetric(carbon.agents.graphite.creates)
अलियासबोडे (श्रृंखलावादी, * नोड्स)

श्रृंखलाबद्ध बनाता है और लक्ष्य नाम या टैग के एक या अधिक "नोड" भाग / s से प्राप्त एक उपनाम लागू करता है। नोड इंडेक्स 0 अनुक्रमित हैं।

&target=aliasByNode(ganglia.*.cpu.load5,1)

प्रत्येक नोड श्रृंखला नाम में एक नोड या एक टैग की पहचान करने वाले स्ट्रिंग का संदर्भ देने वाला पूर्णांक हो सकता है।

&target=seriesByTag("name=~cpu.load.*", "server=~server[1-9]+", "datacenter=dc1")|aliasByNode("datacenter", "server", 1)

# will produce output series like
# dc1.server1.load5, dc1.server2.load5, dc1.server1.load10, dc1.server2.load10
अलियासटैग्स (श्रृंखलावादी, * टैग)

एक श्रृंखला सूची लेता है और एक या एक से अधिक टैग और / या नोड से व्युत्पन्न उपनाम लागू करता है

&target=seriesByTag("name=cpu")|aliasByTags("server","name")

यह उपनाम के लिए एक उपनाम है।

aliasQuery (सीरीज़लिस्ट, खोज, प्रतिस्थापित, नया नाम)

श्रृंखलावाद में मैट्रिक्स को उर्फ ​​करने के लिए एक क्वेरी करता है।

&target=aliasQuery(channel.power.*,"channel\.power\.([0-9]+)","channel.frequency.\1", "Channel %d MHz")

सीरीज़लिस्ट में श्रृंखला पहले खोज और प्रतिस्थापन मापदंडों का उपयोग करके श्रृंखला के नामों का अनुवाद करके, फिर परिणामी श्रृंखला के अंतिम मूल्य का उपयोग करके स्प्रिंट-स्टाइल सिंटैक्स का उपयोग करके उपनाम बनाने के लिए किया जाएगा।

अलियासुब (श्रृंखलावादी, खोज, बदलें)

रेगेक्स खोज / बदलें के माध्यम से श्रृंखला नाम चलाता है।

&target=aliasSub(ip.*TCP*,"^.*TCP(\d+)","\1")
अल्फा (श्रृंखलावादी, अल्फा)

दिए गए अल्फा पारदर्शिता सेटिंग को श्रृंखला में असाइन करता है। 0 और 1 के बीच एक फ्लोट मान लेता है।

लागू करेंबायोड (श्रृंखलावादी, नोडनम, टेम्पलेटफंक्शन, नया नाम = कोई नहीं)

एक श्रृंखला सूची लेता है और कुछ जटिल फ़ंक्शन (एक स्ट्रिंग द्वारा वर्णित) को लागू करता है, श्रृंखलासूची से कुंजियों के अनूठे उपसर्गों के साथ टेम्पलेट्स की जगह लेता है (कुंजी नोड नोड के रूप में दिए गए सूचकांक तक सभी नोड्स है)।

यदि नया नाम पैरामीटर प्रदान किया जाता है, तो परिणामी श्रृंखला का नाम उस पैरामीटर द्वारा दिया जाएगा, जिसमें कोई भी "%" अक्षर अद्वितीय उपसर्ग द्वारा प्रतिस्थापित किया जाएगा।

उदाहरण:

&target=applyByNode(servers.*.disk.bytes_free,1,"divideSeries(%.disk.bytes_free,sumSeries(%.disk.bytes_*))")

सभी श्रंखलाएँ मिलेंगी जो सर्वरों से मेल खाती हैं। *। Disk.bytes_free , फिर उन्हें नोडनम द्वारा दिए गए नोड तक अद्वितीय श्रृंखला के लिए ट्रिम करें, फिर उन्हें प्रदान किए गए टेम्पलेट फ़ंक्शन (उपसर्गों द्वारा% की जगह) में भरें।

अतिरिक्त उदाहरण:

की चाबी दी

  • stats.counts.haproxy.web.2XX
  • stats.counts.haproxy.web.3XX
  • stats.counts.haproxy.web.5XX
  • stats.counts.haproxy.microservice.2XX
  • stats.counts.haproxy.microservice.3XX
  • stats.counts.haproxy.microservice.5XX

निम्नलिखित 5XX प्रति सेवा की दर लौटाएगा:

applyByNode(stats.counts.haproxy.*.*XX, 3, "asPercent(%.5XX, sumSeries(%.*XX))", "%.pct_5XX")

आउटपुट सीरीज़ में कुंजियाँ होंगी आँकड़े काउंट्स .haproxy.web.pct_5XX और ysts.counts.haproxy.microservice.pct_5XX

areaBetween (seriesList)

सीरीज़लिस्ट में दो श्रृंखलाओं के बीच लंबवत क्षेत्र को खींचता है। किसी सेवा के लिए न्यूनतम और अधिकतम विलंबता जैसे श्रेणी की कल्पना करने के लिए उपयोगी है।

एरियाबेटीन को ठीक एक तर्क की उम्मीद है, जिसके परिणामस्वरूप दो श्रृंखलाएं होती हैं (नीचे उदाहरण देखें)। निचले और उच्च मूल्यों की श्रृंखला का क्रम मायने नहीं रखता है। विज़ुअलाइज़ेशन केवल तब काम करता है जब areaMode=stacked के साथ संयोजन में उपयोग किया जाता है areaMode=stacked

सबसे अधिक संभावना उपयोग मामला एक बैंड प्रदान करना है जिसके भीतर एक और मीट्रिक को स्थानांतरित करना चाहिए। ऐसे मामले में एक alpha() लागू करना, दूसरे उदाहरण के रूप में, सबसे अच्छा दृश्य परिणाम देता है।

उदाहरण:

&target=areaBetween(service.latency.{min,max})&areaMode=stacked

&target=alpha(areaBetween(service.latency.{min,max}),0.3)&areaMode=stacked

यदि उदाहरण के लिए, आपको एक श्रृंखला बनाने की आवश्यकता है, तो आपको group फ़ंक्शन का उपयोग करना चाहिए, जैसे:

&target=areaBetween(group(minSeries(a.*.min),maxSeries(a.*.max)))
asPercent (श्रृंखलावादी, कुल = कोई नहीं, * नोड्स)

वाइल्डकार्ड श्रृंखला की कुल संख्या का एक प्रतिशत की गणना करता है। यदि कुल निर्दिष्ट किया जाता है, तो प्रत्येक श्रृंखला की गणना उस कुल के प्रतिशत के रूप में की जाएगी। यदि कुल निर्दिष्ट नहीं है, तो वाइल्डकार्ड श्रृंखला में सभी बिंदुओं का योग इसके बजाय उपयोग किया जाएगा।

नोड्स की एक सूची वैकल्पिक रूप से प्रदान की जा सकती है, यदि उनका उपयोग groupByNodes के समान तर्क के बाद अपने संबंधित योगों के साथ श्रृंखला से मेल खाने के लिए किया जाएगा।

नोड्स पास करते समय कुल पैरामीटर एक श्रृंखला सूची या कोई भी नहीं हो सकता है। यदि यह कोई नहीं है तो श्रृंखला में प्रत्येक श्रृंखला के लिए उस समूह में श्रृंखला के योग का प्रतिशत वापस आ जाएगा।

जब नोड्स नहीं गुजरते हैं , तो कुल पैरामीटर एक एकल श्रृंखला हो सकती है, श्रृंखला की समान संख्या को श्रृंखलासूची के रूप में संदर्भित करें या एक संख्यात्मक मान हो।

उदाहरण:

# Server01 connections failed and succeeded as a percentage of Server01 connections attempted
&target=asPercent(Server01.connections.{failed,succeeded}, Server01.connections.attempted)

# For each server, its connections failed as a percentage of its connections attempted
&target=asPercent(Server*.connections.failed, Server*.connections.attempted)

# For each server, its connections failed and succeeded as a percentage of its connections attemped
&target=asPercent(Server*.connections.{failed,succeeded}, Server*.connections.attempted, 0)

# apache01.threads.busy as a percentage of 1500
&target=asPercent(apache01.threads.busy,1500)

# Server01 cpu stats as a percentage of its total
&target=asPercent(Server01.cpu.*.jiffies)

# cpu stats for each server as a percentage of its total
&target=asPercent(Server*.cpu.*.jiffies, None, 0)

नोड्स का उपयोग करते समय, किसी भी श्रृंखला या योगों का मिलान नहीं किया जा सकता है asPercent(someSeries,MISSING) जैसे कि asPercent(someSeries,MISSING) या asPercent(MISSING,someTotalSeries) जैसे नामों के साथ आउटपुट श्रृंखला asPercent(MISSING,someTotalSeries) और सभी मान किसी भी पर सेट नहीं होंगे। यदि वांछित है तो इन श्रृंखलाओं को परिणाम के माध्यम से पाइपिंग द्वारा फ़िल्टर किया जा सकता है। नीचे दिए गए अनुसार |exclude("MISSING") :

&target=asPercent(Server{1,2}.memory.used,Server{1,3}.memory.total,0)

# will produce 3 output series:
# asPercent(Server1.memory.used,Server1.memory.total) [values will be as expected]
# asPercent(Server2.memory.used,MISSING) [all values will be None]
# asPercent(MISSING,Server3.memory.total) [all values will be None]

&target=asPercent(Server{1,2}.memory.used,Server{1,3}.memory.total,0)|exclude("MISSING")

# will produce 1 output series:
# asPercent(Server1.memory.used,Server1.memory.total) [values will be as expected]

प्रत्येक नोड श्रृंखला नाम में एक नोड या एक टैग की पहचान करने वाले स्ट्रिंग का संदर्भ देने वाला पूर्णांक हो सकता है।

ध्यान दें

जब कुल एक श्रृंखलावादी होता है, तो कुल श्रृंखला के साथ श्रृंखला के मिलान के लिए नोड्स निर्दिष्ट करने से विश्वसनीयता बढ़ेगी।

औसतबॉव (श्रृंखलाकार, एन)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला लेता है, जिसके बाद एक पूर्णांक N होता है। पास की गई सभी मीट्रिक में से, केवल एक मैट्रिक्स होता है, जिसमें निर्दिष्ट समय अवधि के लिए N से ऊपर का औसत मान होता है।

उदाहरण:

&target=averageAbove(server*.instance*.threads.busy,25)

25 से ऊपर औसत मूल्यों वाले सर्वरों को खींचता है।

औसतबेलो (श्रृंखलावादी, एन)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला लेता है, जिसके बाद एक पूर्णांक N होता है। पास की गई सभी मीट्रिक में से, केवल एक मैट्रिक्स होता है, जिसमें निर्दिष्ट समय अवधि के लिए N से नीचे का औसत मान होता है।

उदाहरण:

&target=averageBelow(server*.instance*.threads.busy,25)

25 से नीचे के औसत मान वाले सर्वरों को खींचता है।

औसतन्यूपरसेंसेन्टाइल (श्रृंखलावादी, एन)

एक औसत प्रतिशत अंतराल के अंदर पड़ी श्रृंखला को निकालता है

averageSeries (* seriesLists)

संक्षिप्त उपनाम: avg ()

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला सूची लेता है। हर बार पास की गई सभी मीट्रिक का औसत मूल्य निकालता है।

उदाहरण:

&target=averageSeries(company.server.*.threads.busy)

यह एकत्रीकरण average साथ कुल के लिए एक उपनाम है।

औसतश्राद्धविशेषज्ञ (श्रृंखलावादी, * पद)

दिए गए स्थान पर वाइल्डकार्ड डालने के बाद औसत कॉल करें।

उदाहरण:

&target=averageSeriesWithWildcards(host.cpu-[0-7].cpu-{user,system}.value, 1)

यह इसके बराबर होगा

&target=averageSeries(host.*.cpu-user.value)&target=averageSeries(host.*.cpu-system.value)

यह एकत्रीकरण average साथ एग्रीगेटविल्डवाल्डकार्ड के लिए एक उपनाम है।

cactiStyle (सीरीज़लिस्ट, सिस्टम = कोई नहीं, इकाइयाँ = कोई नहीं)

एक श्रृंखला सूची लेता है और कैक्टि की शैली में वर्तमान, अधिकतम और न्यूनतम मूल्यों के साथ कॉलम संरेखित आउटपुट प्रदान करने के लिए उपनामों को संशोधित करता है। वैकल्पिक रूप से Y- अक्ष, या एक "यूनिट" स्ट्रिंग के रूप में एक ही शैली में यूनिट स्वरूपण लागू करने के लिए एक "सिस्टम" मान लेता है ताकि एक मनमाना इकाई प्रत्यय संलग्न किया जा सके।

&target=cactiStyle(ganglia.*.net.bytes_out,"si")
&target=cactiStyle(ganglia.*.net.bytes_out,"si","b")

system लिए एक संभावित मूल्य si , जो एक हजार के गुणकों में आपके मूल्यों को व्यक्त करेगा। एक दूसरा विकल्प binary का उपयोग करना है जो बदले में 1024 के गुणकों (नेटवर्क उपकरणों के लिए उपयोगी) में आपके मूल्यों को व्यक्त करेगा।

वर्तमान, अधिकतम, न्यूनतम मानों का कॉलम संरेखण दो शर्तों के तहत काम करता है: आप एक मोनोपेस फ़ॉन्ट का उपयोग करते हैं जैसे कि टर्मिनस और एकल कैक्टिसेटल कॉल का उपयोग करते हैं, क्योंकि अलग-अलग कैक्टिसेटल कॉल एक दूसरे के बारे में नहीं जानते हैं। यदि आपके पास अलग-अलग लक्ष्य हैं, जिसके लिए आप लाइन में लगने के लिए कैक्टिस स्टाइल को पसंद करेंगे, तो आप कैक्टिस स्टाइल लागू करने से पहले उन्हें संयोजित करने के लिए group() का उपयोग कर सकते हैं, जैसे:

&target=cactiStyle(group(metricA,metricB))
बदली हुई (seriesList)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला सूची लेता है। आउटपुट 1 जब मूल्य बदल गया, 0 जब शून्य या समान

उदाहरण:

&target=changed(Server01.connections.handled)
रंग (श्रृंखलावादी, रंग)

श्रृंखलाकार को दिए गए रंग को निर्दिष्ट करता है

उदाहरण:

&target=color(collectd.hostname.cpu.0.user, 'green')
&target=color(collectd.hostname.cpu.0.system, 'ff0000')
&target=color(collectd.hostname.cpu.0.idle, 'gray')
&target=color(collectd.hostname.cpu.0.idle, '6464ffaa')
समेकनशील (श्रृंखलावादी, समेकनफंक)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला सूची और एक समेकन फ़ंक्शन नाम लेता है।

मान्य फ़ंक्शन नाम 'योग', 'औसत', 'न्यूनतम', 'अधिकतम', 'पहला' और 'अंतिम' हैं।

जब एक ग्राफ खींचा जाता है जहां पिक्सल में ग्राफ आकार की चौड़ाई रेखांकन किए जाने वाले डेटापॉइंट की संख्या से छोटी होती है, तो ग्रेफाइट लाइन ओवरलैप को रोकने के लिए मूल्यों को समेकित करता है। समेकित करें () फ़ंक्शन 'औसत' के डिफ़ॉल्ट से समेकन फ़ंक्शन को 'योग', 'अधिकतम', 'मिनट', 'प्रथम', या 'अंतिम' में बदलता है। यह बिक्री के ग्राफ में विशेष रूप से उपयोगी है, जहां भिन्नात्मक मूल्यों का कोई मतलब नहीं है और समेकित मूल्यों का एक 'योग' उपयुक्त है।

&target=consolidateBy(Sales.widgets.largeBlue, 'sum')
&target=consolidateBy(Servers.web01.sda1.free_space, 'max')
constantLine (मान)

एक फ्लोट F लेता है।

ग्राफ पर F पर एक क्षैतिज रेखा खींचता है।

उदाहरण:

&target=constantLine(123.456)
countSeries (* seriesLists)

श्रृंखलाबद्धता में पाए जाने वाले नोड्स की संख्या का प्रतिनिधित्व करने वाली एक क्षैतिज रेखा खींचता है।

&target=countSeries(carbon.agents.*.*)
संचयी (seriesList)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला सूची लेता है।

जब एक ग्राफ खींचा जाता है जहां पिक्सल में ग्राफ आकार की चौड़ाई रेखांकन किए जाने वाले डेटापॉइंट की संख्या से छोटी होती है, तो ग्रेफाइट लाइन ओवरलैप को रोकने के लिए मूल्यों को समेकित करता है। संचयी () फ़ंक्शन समेकन फ़ंक्शन को 'औसत' के डिफ़ॉल्ट से 'योग' में बदलता है। यह बिक्री के ग्राफ में विशेष रूप से उपयोगी है, जहां भिन्नात्मक मूल्यों का कोई मतलब नहीं है और समेकित मूल्यों का एक 'योग' उपयुक्त है।

consolidateBy(series, 'sum') लिए उपनाम consolidateBy(series, 'sum')

&target=cumulative(Sales.widgets.largeBlue)
currentAbove (सीरीज़लिस्ट, एन)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला लेता है, जिसके बाद एक पूर्णांक N होता है। पास की गई सभी मीट्रिक में से केवल वह मीट्रिक खींचता है जिसका मान निर्दिष्ट समय अवधि के अंत में N से ऊपर होता है।

उदाहरण:

&target=currentAbove(server*.instance*.threads.busy,50)

50 से अधिक व्यस्त थ्रेड्स वाले सर्वरों को खींचता है।

वर्तमानबेलो (श्रृंखलावादी, एन)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला लेता है, जिसके बाद एक पूर्णांक N होता है। पास की गई सभी मीट्रिक में से, केवल वह मीट्रिक निकालता है जिसका मान निर्दिष्ट समय अवधि के अंत में N से नीचे होता है।

उदाहरण:

&target=currentBelow(server*.instance*.threads.busy,3)

3 से कम व्यस्त थ्रेड वाले सर्वरों को खींचता है।

धराशायी (श्रृंखलावादी, डैशलेस = 5)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखलावादी लेता है, उसके बाद एक फ्लोट एफ।

चयनित मेट्रिक्स को लंबाई के खंडों के साथ डॉटेड रेखा के साथ ड्रा करें यदि छोड़ा गया है, तो खंडों की डिफ़ॉल्ट लंबाई 5.0 है

उदाहरण:

&target=dashed(server01.instance01.memory.free,2.5)
देरी (श्रृंखलावादी, कदम)

यह सभी नमूनों को बाद में एक पूर्णांक संख्या द्वारा स्थानांतरित करता है। यह अन्य चीजों के अलावा, कस्टम व्युत्पन्न गणनाओं के लिए उपयोग किया जा सकता है। ध्यान दें: यह डेटा के शुरुआती छोर को हर चरण में स्थानांतरित किए गए किसी के साथ नहीं रखेगा।

यह अन्य समय-विस्थापन कार्यों जैसे टाइमशिफ्ट और टाइमस्लाइज़ का अनुपालन करता है, जिसमें यह फ़ंक्शन चरण अंतराल को स्थानांतरित करने के बारे में उदासीन है।

उदाहरण:

&target=divideSeries(server.FreeSpace,delay(server.FreeSpace,1))

यह पिछले मुक्त स्थान के प्रतिशत के रूप में सर्वर मुक्त स्थान में परिवर्तन की गणना करता है।

व्युत्पन्न (seriesList)

यह अभिन्न कार्य के विपरीत है। यह चल रहे कुल मीट्रिक लेने और बाद के डेटा बिंदुओं के बीच डेल्टा की गणना करने के लिए उपयोगी है।

यह कार्य समय के लिए सामान्य नहीं होता है, जैसा कि एक वास्तविक व्युत्पन्न होता है। इसके बजाय समय के साथ परिवर्तन की दर की गणना करने के लिए perSecond () फ़ंक्शन देखें।

उदाहरण:

&target=derivative(company.server.application01.ifconfig.TXPackets)

हर बार जब आप ifconfig चलाते हैं, तो RX और TXPackets अधिक होते हैं (यह मानते हुए कि नेटवर्क ट्रैफ़िक है।) व्युत्पन्न फ़ंक्शन को लागू करके, आप प्रति मिनट पैकेट का एक विचार प्राप्त या प्राप्त कर सकते हैं, भले ही आप केवल कुल रिकॉर्डिंग कर रहे हों।

diffSeries (* seriesLists)

श्रृंखला 1 से n के माध्यम से श्रृंखला 2 घटाना।

उदाहरण:

&target=diffSeries(service.connections.total,service.connections.failed)

एक श्रृंखला और एक स्थिरांक को अलग करने के लिए, व्यक्ति को अंतर के बजाय (या इसके अलावा) ऑफसेट का उपयोग करना चाहिए

उदाहरण:

&target=offset(service.connections.total,-5)

&target=offset(diffSeries(service.connections.total,service.connections.failed),-4)

यह एकत्रीकरण diff साथ कुल के लिए एक उपनाम है।

डिवाइडरीज़ (डिविडेंडरीसिस्ट, डिविज़रीरीज़)

एक लाभांश मीट्रिक और एक भाजक मीट्रिक लेता है और विभाजन परिणाम निकालता है। एक निरंतर पारित नहीं किया जा सकता है। एक स्थिर से विभाजित करने के लिए, स्केल () फ़ंक्शन (जो अनिवार्य रूप से एक गुणा ऑपरेशन है) का उपयोग करें और लाभांश के व्युत्क्रम का उपयोग करें। (8 से गुणा = 1/8 या 0.125 से गुणा)

उदाहरण:

&target=divideSeries(Series.dividends,Series.divisors)
divideSeriesLists (डिविडेंडरीसिस्ट, divisorSeriesList)

एक दो सूचियों में परिवर्तन करता है और सूची 2 [0], सूची 1 [1] द्वारा सूची 2 [1] और इसी तरह सूची 1 को विभाजित करता है। सूचियों की लंबाई समान होनी चाहिए

drawAsInfinite (seriesList)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला सूची लेता है। यदि मान शून्य है, तो रेखा को 0. पर खींचें। यदि मान शून्य से ऊपर है, तो रेखा को अनंत पर खींचें। यदि मान शून्य या शून्य से कम है, तो रेखा न खींचें।

निकास कोड जैसे मेट्रिक्स पर / बंद प्रदर्शित करने के लिए उपयोगी है। (0 = सफलता, कुछ और = विफलता।)

उदाहरण:

drawAsInfinite(Testing.script.exitCode)
घटनाओं (* टैग)

इस समय घटनाओं की संख्या लौटाता है। DrawAsInfinite के साथ प्रयोग करने योग्य।

उदाहरण:

&target=events("tag-one", "tag-two")
&target=events("*")

"टैग-एक" और "टैग-दो" के रूप में टैग की गई सभी घटनाओं को लौटाता है और दूसरा सभी घटनाओं को लौटाता है।

बहिष्कृत (श्रृंखलावादी, पैटर्न)

एक मीट्रिक या वाइल्डकार्ड श्रृंखलावादी होता है, जिसके बाद दोहरे उद्धरण चिह्नों में एक नियमित अभिव्यक्ति होती है। नियमित अभिव्यक्ति से मेल खाने वाले मैट्रिक्स को छोड़ देता है।

उदाहरण:

&target=exclude(servers*.instance*.threads.busy,"server02")
एक्सपोनेंशियलमॉविंग एवरेज (सीरीज़लिस्ट, विंडोसाइज़)

मूल्यों की एक श्रृंखला और एक खिड़की का आकार लेता है और निम्न सूत्र का उपयोग करते हुए एक घातीय चलती औसत पैदा करता है:

ema(current) = constant * (Current Value) + (1 - constant) * ema(previous)

कॉन्स्टेंट की गणना इस प्रकार की जाती है:

constant = 2 / (windowSize + 1)

पहली अवधि ईएमए अपने मूल्य के लिए एक सरल चलती औसत का उपयोग करता है।

उदाहरण:

&target=exponentialMovingAverage(*.transactions.count, 10)
&target=exponentialMovingAverage(*.transactions.count, '-10s')
फॉलबैक सीरीज़ (श्रृंखलावादी, फालबैक)

एक वाइल्डकार्ड श्रृंखलावादी, और एक दूसरा कमबैक मीट्रिक लेता है। यदि वाइल्डकार्ड किसी भी श्रृंखला से मेल नहीं खाता है, तो फॉलबैक मीट्रिक खींचता है।

उदाहरण:

&target=fallbackSeries(server*.requests_per_second, constantLine(0))

जब सर्वर मीट्रिक मौजूद नहीं है, तो एक 0 रेखा खींचता है।

फ़िल्टरश्रृंखला (श्रृंखलाकार, कवक, ऑपरेटर, दहलीज)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला सूची लेता है, जिसके बाद एक समेकन फ़ंक्शन, एक ऑपरेटर और एक सीमा होती है। केवल मैट्रिक्स खींचता है जो फ़िल्टर अभिव्यक्ति से मेल खाता है।

उदाहरण:

&target=filterSeries(system.interface.eth*.packetsSent, 'max', '>', 1000)

यह केवल उन इंटरफेस को प्रदर्शित करेगा जिनमें 1000 पैकेट / मिनट से अधिक शिखर थ्रूपुट है।

समर्थित एकत्रीकरण कार्य: average , median , sum , min , max , diff , stddev , range , multiply और last

समर्थित ऑपरेटर: = ; = != > , >= , < & <=

grep (श्रृंखलावादी, पैटर्न)

एक मीट्रिक या वाइल्डकार्ड श्रृंखलावादी होता है, जिसके बाद दोहरे उद्धरण चिह्नों में एक नियमित अभिव्यक्ति होती है। ऐसे मेट्रिक्स को छोड़ दें जो नियमित अभिव्यक्ति से मेल नहीं खाते हैं।

उदाहरण:

&target=grep(servers*.instance*.threads.busy,"server02")
समूह (* seriesLists)

श्रृंखलावादियों की एक मनमानी संख्या लेता है और उन्हें एक एकल श्रृंखलासूची में जोड़ता है। इसका उपयोग कई श्रृंखलाओं को एक फ़ंक्शन में पास करने के लिए किया जाता है जो केवल एक लेता है

GroupBNNode (सीरीज़लिस्ट, नोडनम, कॉलबैक = 'औसत')

एक सीरीज़ लेता है और एक सामान्य नोड द्वारा परिभाषित के रूप में उपसमूहों को कॉलबैक मैप करता है

&target=groupByNode(ganglia.by-function.*.*.cpu.load5,2,"sumSeries")

दूसरी श्रृंखला (0 अनुक्रमित) में शामिल समूहों के लिए "सारांश" फ़ंक्शन को लागू करने के परिणामस्वरूप कई श्रृंखलाएं लौटाएंगे, जैसे कि लक्ष्य की सूची

sumSeries(ganglia.by-function.server1.*.cpu.load5),sumSeries(ganglia.by-function.server2.*.cpu.load5),...

नोड एक पूर्णांक हो सकता है जो श्रृंखला नाम में एक नोड या एक टैग की पहचान करने वाले स्ट्रिंग को संदर्भित करता है।

यह एक एकल नोड के साथ groupByNodes का उपयोग करने के लिए एक उपनाम है।

groupByNodes (सीरीज़लिस्ट, कॉलबैक, * नोड्स)

एक श्रृंखला सूची लेता है और कई नोड्स द्वारा परिभाषित के रूप में उपसमूहों को कॉलबैक मैप करता है

&target=groupByNodes(ganglia.server*.*.cpu.load*,"sum",1,4)

कई सीरीज़ लौटाएंगे, जो नोड्स की सूची में शामिल समूहों के लिए "योग" एकत्रीकरण को लागू करने का परिणाम हैं (0 अनुक्रमित) जैसे कि लक्ष्य की सूची में

sumSeries(ganglia.server1.*.cpu.load5),sumSeries(ganglia.server1.*.cpu.load10),sumSeries(ganglia.server1.*.cpu.load15),sumSeries(ganglia.server2.*.cpu.load5),sumSeries(ganglia.server2.*.cpu.load10),sumSeries(ganglia.server2.*.cpu.load15),...

इस फ़ंक्शन का उपयोग एग्रीगेट द्वारा समर्थित सभी एकत्रीकरण कार्यों के साथ किया जा सकता है: average , median , sum , min , max , diff , stddev , range और multiply

प्रत्येक नोड श्रृंखला नाम में एक नोड या एक टैग की पहचान करने वाले स्ट्रिंग का संदर्भ देने वाला पूर्णांक हो सकता है।

&target=seriesByTag("name=~cpu.load.*", "server=~server[1-9]+", "datacenter=~dc[1-9]+")|groupByNodes("average", "datacenter", 1)

# will produce output series like
# dc1.load5, dc2.load5, dc1.load10, dc2.load10

यह aggregateWithWildcards पूरक aggregateWithWildcards जो वाइल्डकार्ड नोड्स की एक सूची लेता है।

groupByTags (सीरीज़लिस्ट, कॉलबैक, * टैग)

एक श्रृंखला सूची लेता है और कई टैग द्वारा परिभाषित के रूप में उपसमूहों को कॉलबैक मैप करता है

&target=seriesByTag("name=cpu")|groupByTags("average","dc")

कई सीरीज़ लौटाएगा, जो कि निर्धारित औसत टैग्स में शामिल किए गए समूहों के लिए "एवरेजरीज़" फंक्शन लागू करने का परिणाम है जैसे कि लक्ष्य की सूची में

averageSeries(seriesByTag("name=cpu","dc=dc1")),averageSeries(seriesByTag("name=cpu","dc=dc2")),...

इस फ़ंक्शन का उपयोग एग्रीगेट द्वारा समर्थित सभी एकत्रीकरण कार्यों के साथ किया जा सकता है: average , median , sum , min , max , diff , stddev , range और multiply

उच्चतम (श्रृंखलावादी, n = 1, func = 'औसत')

एक मैट्रिक या वाइल्डकार्ड श्रृंखला लेता है, जिसके बाद एक पूर्णांक N और एक एकत्रीकरण फ़ंक्शन होता है। पास की गई सभी मीट्रिक में से, केवल N मेट्रिक्स को निर्दिष्ट समयावधि में उच्चतम एकत्रित मूल्य के साथ खींचती है।

उदाहरण:

&target=highest(server*.instance*.threads.busy,5,'max')

5 सर्वरों को सबसे अधिक व्यस्त थ्रेड्स के साथ खींचता है।

उच्चतम लाभ (श्रृंखलावादी, एन)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला लेता है, जिसके बाद एक पूर्णांक एन होता है। पास की गई सभी मीट्रिक में से, केवल निर्दिष्ट अवधि के लिए उच्चतम औसत मान के साथ केवल शीर्ष एन मैट्रिक्स खींचता है।

उदाहरण:

&target=highestAverage(server*.instance*.threads.busy,5)

उच्चतम औसत मूल्य के साथ शीर्ष 5 सर्वरों को खींचता है।

यह एकत्रीकरण average साथ highest लिए एक उपनाम है।

उच्चतम श्रेणी (श्रृंखलाकार, n)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला लेता है, जिसके बाद एक पूर्णांक N होता है। पास की गई सभी मीट्रिक में से, केवल N मीट्रिक को निर्दिष्ट समय अवधि के अंत में उच्चतम मान के साथ खींचती है।

उदाहरण:

&target=highestCurrent(server*.instance*.threads.busy,5)

उच्चतम व्यस्त थ्रेड्स के साथ 5 सर्वर खींचता है।

यह एकत्रीकरण current साथ highest लिए एक उपनाम है।

उच्चतम मोम (श्रृंखलावादी, एन)

एक मीट्रिक या वाइल्डकार्ड श्रृंखला लेता है, जिसके बाद एक पूर्णांक N होता है।

पारित किए गए सभी मैट्रिक्स में से, केवल निर्दिष्ट अवधि में उच्चतम अधिकतम मूल्य वाले केवल एन मेट्रिक्स को खींचता है।

उदाहरण:

&target=highestMax(server*.instance*.threads.busy,5)

निर्दिष्ट समय अवधि के दौरान सबसे अधिक व्यस्त धागे रखने वाले शीर्ष 5 सर्वरों को खींचता है।

यह एकत्रीकरण max साथ highest लिए एक उपनाम है।

हिटकाउंट (सीरीज़लिस्ट, इंटरवलस्टृंग, अलाइन्टोइंटरवल = गलत)

समय श्रृंखला की सूची से अनुमानित हिट मायने रखता है।

यह फ़ंक्शन मान लेता है कि प्रत्येक समय श्रृंखला प्रति सेकंड हिट का प्रतिनिधित्व करती है। यह प्रति दिन या प्रति घंटे के रूप में कुछ बड़े अंतराल पर हिट की गणना करता है। यह फ़ंक्शन सारांशित () की तरह है, सिवाय इसके कि यह अलग-अलग समय के तराजू के लिए स्वचालित रूप से क्षतिपूर्ति करता है (ताकि एक समान ग्राफ या तो बारीक-बारीक या मोटे दाने वाले रिकॉर्ड का उपयोग करके) और शायद ही कभी घटने वाली घटनाओं को इनायत से संभालता है।

holtWintersAberration (सीरीज़लिस्ट, डेल्टा = 3, बूटस्ट्रैप इन्टरवल = '7 डी', सीज़निटी = '1 डी')

इनपुट डेटा के रूप में श्रृंखला का उपयोग करके होल्ट-विंटर्स पूर्वानुमान का प्रदर्शन करता है और पूर्वानुमान से श्रृंखला डेटा के सकारात्मक या नकारात्मक विचलन को प्लॉट करता है।

holtWintersConfidenceArea (सीरीज़लिस्ट, डेल्टा = 3, बूटस्ट्रैपइंटरवल = '7 डी', सीज़निटी = '1 डी')

इनपुट डेटा के रूप में श्रृंखला का उपयोग करके एक होल्ट-विंटर्स पूर्वानुमान का प्रदर्शन करता है और पूर्वानुमानित पूर्वानुमान विचलन के ऊपरी और निचले बैंड के बीच के क्षेत्र को प्लॉट करता है।

holtWintersConfidenceBands (सीरीज़लिस्ट, डेल्टा = 3, बूटस्ट्रैपइंटरवल = '7 डी', सीज़निटी = '1 डी')

पूर्वानुमानित पूर्वानुमान विचलन के साथ इनपुट डेटा और भूखंडों के ऊपरी और निचले बैंड के रूप में श्रृंखला का उपयोग करके होल्ट-विंटर्स पूर्वानुमान का प्रदर्शन करता है।

holtWintersForecast (सीरीज़लिस्ट, बूटस्ट्रैप इन्टरवल = '7 डी', सीज़निटी = '1 डी')

इनपुट डेटा के रूप में श्रृंखला का उपयोग करके होल्ट-विंटर्स पूर्वानुमान का प्रदर्शन करता है। श्रृंखला के पहले बूटस्ट्रैपइंटरवल (एक सप्ताह डिफ़ॉल्ट रूप से) का डेटा प्रारंभिक पूर्वानुमान बूटस्ट्रैप करने के लिए उपयोग किया जाता है।

पहचान (नाम)

आइडेंटिटी फंक्शन: रिटर्न डाटापॉइंट्स जहां वैल्यू डाटापॉइंट के टाइमस्टैम्प के बराबर होती है। उपयोगी जब आपके पास एक और श्रृंखला होती है जहां मूल्य एक टाइमस्टैम्प होता है, और आप इसे एक उम्र प्रदान करने के लिए डेटापॉइंट के समय से तुलना करना चाहते हैं।

उदाहरण:

&target=identity("The.time.series")

यह "The.time.series" नामक एक श्रृंखला बनाएगा जिसमें ऐसे बिंदु हों जहां x (t) == t हो।

अभिन्न (seriesList)

यह समय के साथ योग दिखाएगा, एक निरंतर जोड़ फ़ंक्शन की तरह। प्रति मिनट एकत्र किए गए मैट्रिक्स में योग या रुझान खोजने के लिए उपयोगी है।

उदाहरण:

&target=integral(company.sales.perMinute)

यह ग्राफ के बाईं ओर शून्य से शुरू होता है, प्रत्येक मिनट में बिक्री को जोड़ता है, और दाईं ओर चयनित समय अवधि के लिए कुल बिक्री दिखाता है, (अब समय, या 'और' = 'द्वारा निर्दिष्ट समय)।

इंटीग्रलबीइंटरवल (सीरीज़लिस्ट, इंटरवलयूनिट)

यह इंटीग्रल () फंकशन के समान होगा, पैरामीटर को दिए गए समय में कुल 0 को रीसेट करने के अलावा "प्रति घंटे / दिन / सप्ताह / प्रति दिन योग खोजने के लिए उपयोगी" से।

उदाहरण:

&target=integralByInterval(company.sales.perMinute, "1d")&from=midnight-10days

यह ग्राफ के बाईं ओर शून्य से शुरू होगा, प्रत्येक मिनट बिक्री को जोड़ देगा, और पिछले 10 दिनों के दौरान प्रति दिन बिक्री का विकास दिखाएगा।

इंटरपोलेट (सीरीज़लिस्ट, लिमिट = इनफ)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला सूची लेता है, और वैकल्पिक रूप से छोड़ देने के लिए 'कोई नहीं' मानों की संख्या के लिए एक सीमा होती है। जब आपके लाइन को तोड़ने के बजाय आपके डेटा में अंतराल ('कोई नहीं') दिखाई देते हैं, तो अंतिम प्राप्त मूल्य के साथ लाइन जारी रखता है।

उदाहरण:

&target=interpolate(Server01.connections.handled)
&target=interpolate(Server01.connections.handled, 10)
उलटने (seriesList)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला सूची लेता है, और प्रत्येक डेटापॉइंट (अर्थात 1 / x) को सम्मिलित करता है।

उदाहरण:

&target=invert(Server.instance01.threads.busy)
isNonNull (seriesList)

एक मीट्रिक या वाइल्डकार्ड श्रृंखला सूची लेता है और गैर-शून्य मानों की संख्या को गिनता है। यह उन मैट्रिक्स की संख्या को समझने के लिए उपयोगी है जिनके पास किसी दिए गए बिंदु पर डेटा है (यानी यह गणना करने के लिए कि कौन से सर्वर जीवित हैं)।

उदाहरण:

&target=isNonNull(webapp.pages.*.views)

एक श्रंखला देता है जहाँ 1 को गैर-शून्य मानों के लिए निर्दिष्ट किया जाता है, और 0 शून्य मानों के लिए निर्दिष्ट किया जाता है।

KeepLastValue (श्रृंखलासूची, सीमा = inf)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला सूची लेता है, और वैकल्पिक रूप से छोड़ देने के लिए 'कोई नहीं' मानों की संख्या के लिए एक सीमा होती है। जब आपके लाइन को तोड़ने के बजाय आपके डेटा में अंतराल ('कोई नहीं') दिखाई देते हैं, तो अंतिम प्राप्त मूल्य के साथ लाइन जारी रखता है।

उदाहरण:

&target=keepLastValue(Server01.connections.handled)
&target=keepLastValue(Server01.connections.handled, 10)
लेजेंडवैल्यू (सीरीज़लिस्ट, * वैल्यूटेप्स)

एक मीट्रिक या वाइल्डकार्ड श्रृंखला सूची और उद्धरण में एक स्ट्रिंग लेता है। किंवदंती में मीट्रिक नाम का मान जोड़ता है। वर्तमान में एक या कई: अंतिम , औसत , कुल , न्यूनतम , अधिकतम । अंतिम तर्क सी (डिफ़ॉल्ट) या बाइनरी हो सकता है, उस स्थिति में मूल्यों को संबंधित सिस्टम में स्वरूपित किया जाएगा।

&target=legendValue(Sales.widgets.largeBlue, 'avg', 'max', 'si')
सीमा (श्रृंखलावादी, एन)

एक मीट्रिक या वाइल्डकार्ड श्रृंखला लेता है, जिसके बाद एक पूर्णांक N होता है।

केवल पहले N मैट्रिक्स को ड्रा करें। मीट्रिक में वाइल्डकार्ड का परीक्षण करते समय उपयोगी।

उदाहरण:

&target=limit(server*.instance*.memory.free,5)

केवल पहले 5 इंस्टेंस की मेमोरी को ड्रॉ करता है।

लाइनविद (श्रृंखलाकार, चौड़ाई)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखलावादी लेता है, उसके बाद एक फ्लोट एफ।

F की लाइन चौड़ाई के साथ चयनित मेट्रिक्स ड्रा करें, 1 के डिफ़ॉल्ट मान को ओवरराइड करके, या लाइनविद = XX पैरामीटर।

एक से कई मीट्रिक को हाइलाइट करने के लिए उपयोगी है, या एक ग्राफ में कई लाइन चौड़ाई है।

उदाहरण:

&target=lineWidth(server01.instance01.memory.free,5)
लीनियर रीजनेशन (सीरीज़लिस्ट, स्टार्टसोर्सएट = कोई नहीं, एंडसोर्सएट = कोई नहीं)

रेखीय प्रतिगमन फ़ंक्शन को कम से कम वर्ग विधि से रेखांकन करता है।

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखलावादी होता है, जिसके बाद लाइन शुरू करने के लिए समय के साथ एक उद्धृत स्ट्रिंग और लाइन समाप्त करने के लिए समय के साथ एक और उद्धृत स्ट्रिंग होता है। प्रारंभ और अंत समय समावेशी हैं (डिफ़ॉल्ट सीमा तक है)। समय प्रारूपों के उदाहरणों के लिए रेंडर एपीआई में from / until देखें। श्रेणी में डेटा पॉइंट्स का उपयोग प्रतिगमन के लिए किया जाता है।

उदाहरण:

&target=linearRegression(Server.instance01.threads.busy, '-1d')
&target=linearRegression(Server.instance*.threads.busy, "00:00 20140101","11:59 20140630")
linearRegressionAnalysis (श्रृंखला)

कम से कम वर्गों विधि द्वारा रैखिक प्रतिगमन समारोह के कारक और ऑफसेट।

लघुगणक (श्रृंखलावादी, आधार = 10)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखलासूची, एक आधार लेता है, और लघुगणकीय प्रारूप में y- अक्ष खींचता है। यदि बेस को छोड़ दिया जाता है, तो फ़ंक्शन बेस 10 तक डिफॉल्ट करता है।

उदाहरण:

&target=log(carbon.agents.hostname.avgUpdateTime,2)
सबसे कम (श्रृंखलावादी, n = 1, func = 'औसत')

एक मैट्रिक या वाइल्डकार्ड श्रृंखला लेता है, जिसके बाद एक पूर्णांक N और एक एकत्रीकरण फ़ंक्शन होता है। पारित किए गए सभी मीट्रिक में से, केवल एन मेट्रिक्स को निर्दिष्ट समयावधि में सबसे कम कुल मूल्य के साथ खींचता है।

उदाहरण:

&target=lowest(server*.instance*.threads.busy,5,'min')

सबसे कम संख्या में व्यस्त धागे के साथ 5 सर्वरों को खींचता है।

निम्नतम लाभ (सीरीज़लिस्ट, एन)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखलावादी होता है, जिसके बाद एक पूर्णांक N होता है। पास की गई सभी मीट्रिक में से, नीचे दी गई समयावधि के लिए सबसे कम औसत मान के साथ केवल नीचे N मैट्रिक्स खींचता है।

उदाहरण:

&target=lowestAverage(server*.instance*.threads.busy,5)

सबसे कम औसत मूल्य वाले निचले 5 सर्वरों को खींचता है।

यह एकत्रीकरण average साथ lowest लिए एक उपनाम है।

निम्नतम (श्रृंखलाबद्ध, n)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला लेता है, जिसके बाद एक पूर्णांक N होता है। पास की गई सभी मीट्रिक में से, केवल N मेट्रिक्स को निर्दिष्ट समय अवधि के अंत में सबसे कम मूल्य के साथ खींचता है।

उदाहरण:

&target=lowestCurrent(server*.instance*.threads.busy,5)

अभी कम से कम व्यस्त थ्रेड्स के साथ 5 सर्वर खींचता है।

यह एकत्रीकरण current साथ lowest लिए एक उपनाम है।

मैप्सरीज़ (सीरीज़लिस्ट, * मैपकोड्स)

संक्षिप्त रूप: map()

एक श्रृंखला सूची लेता है और इसे श्रृंखलासूची की सूची में मैप करता है। प्रत्येक सीरीज़लिस्ट में दिए गए मैपनोड्स आम हैं।

ध्यान दें

यह फ़ंक्शन अकेले बहुत उपयोगी नहीं है। इसके साथ इस्तेमाल किया जाना चाहिए reduceSeries()

mapSeries(servers.*.cpu.*,1) =>

  [
    servers.server1.cpu.*,
    servers.server2.cpu.*,
    ...
    servers.serverN.cpu.*
  ]

प्रत्येक नोड श्रृंखला नाम में एक नोड या एक टैग की पहचान करने वाले स्ट्रिंग का संदर्भ देने वाला पूर्णांक हो सकता है।

maxSeries (* seriesLists)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला सूची लेता है। में पारित प्रत्येक मीट्रिक से प्रत्येक डेटापॉइंट के लिए, अधिकतम मूल्य चुनें और इसे ग्राफ़ करें।

उदाहरण:

&target=maxSeries(Server*.connections.total)

यह aggregate एकत्रीकरण के लिए एक उपनाम है max

अधिकतमअबोव (श्रृंखलावादी, एन)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला लेता है, जिसके बाद एक निरंतर n होता है। N के ऊपर अधिकतम मान वाले केवल मैट्रिक्स को खींचता है।

उदाहरण:

&target=maximumAbove(system.interface.eth*.packetsSent,1000)

यह केवल उन इंटरफेस को प्रदर्शित करेगा जो 1000 से अधिक पैकेट / मिनट भेजते हैं।

अधिकतमबेलो (श्रृंखलाकार, एन)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला लेता है, जिसके बाद एक निरंतर n होता है। N के नीचे अधिकतम मान वाले केवल मैट्रिक्स खींचता है।

उदाहरण:

&target=maximumBelow(system.interface.eth*.packetsSent,1000)

यह केवल उन इंटरफेस को प्रदर्शित करेगा जो 1000 पैकेट / मिनट से कम भेजते हैं।

minMax (seriesList)

लोकप्रिय न्यूनतम अधिकतम सामान्यीकरण तकनीक को लागू करता है, जो प्रत्येक बिंदु को लेता है और इसके लिए निम्न सामान्यीकरण परिवर्तन लागू करता है: सामान्यीकृत = (बिंदु - मिनट) / (अधिकतम - मिनट)।

उदाहरण:

&target=minMax(Server.instance01.threads.busy)
minSeries (* seriesLists)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला सूची लेता है। में पारित प्रत्येक मीट्रिक से प्रत्येक डेटापॉइंट के लिए, न्यूनतम मान चुनें और इसे ग्राफ़ करें।

उदाहरण:

&target=minSeries(Server*.connections.total)

यह aggregate एकत्रीकरण के लिए एक उपनाम है min

न्यूनतमAove (श्रृंखलाकार, n)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला लेता है, जिसके बाद एक निरंतर n होता है। एन के ऊपर केवल एक न्यूनतम मूल्य के साथ केवल मैट्रिक्स खींचता है।

उदाहरण:

&target=minimumAbove(system.interface.eth*.packetsSent,1000)

यह केवल उन इंटरफेस को प्रदर्शित करेगा जो 1000 से अधिक पैकेट / मिनट भेजते हैं।

न्यूनतमबेलो (श्रृंखलावादी, एन)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला लेता है, जिसके बाद एक निरंतर n होता है। एन के नीचे एक न्यूनतम मूल्य के साथ केवल मैट्रिक्स खींचता है।

उदाहरण:

&target=minimumBelow(system.interface.eth*.packetsSent,1000)

यह केवल उन इंटरफेस को प्रदर्शित करेगा जो एक बिंदु पर 1000 पैकेट / मिनट से कम भेजते हैं।

मोस्ट डिवियेंट (सीरीज़िस्ट, एन)

एक मैट्रिक या वाइल्डकार्ड श्रृंखला लेता है, जिसके बाद एक पूर्णांक एन होता है। एन सबसे विचलित मैट्रिक्स खींचता है। देवियों को खोजने के लिए, प्रत्येक श्रृंखला के मानक विचलन (सिग्मा) को लिया और रैंक किया गया है। शीर्ष एन मानक विचलन वापस आ गए हैं।

उदाहरण:
&target=mostDeviant(server*.instance*.memory.free, 5)

औसत स्मृति मुक्त से 5 उदाहरणों को दूर खींचता है।

मूविंग एवरेज (सीरीज़लिस्ट, विंडोसाइज़, xFilesFactor = कोई नहीं)

पिछले अंकों की एक निश्चित संख्या, या एक समय अंतराल पर एक मीट्रिक (या मीट्रिक) की चलती औसत को रेखांकन करता है।

एक मीट्रिक या एक वाइल्डकार्ड सीरीज़ ले जाता है, जिसके बाद नंबर 1 के डेटापॉइंट्स या एक उद्धृत स्ट्रिंग होती है, जैसे '1 घंटे' या '5 मिनट' की लंबाई ( समय प्रारूपों के उदाहरणों के लिए रेंडर एपीआई में देखें ), और निर्दिष्ट करने के लिए xFilesFactor मान आउटपुट को वैध मानने के लिए विंडो में कितने बिंदु गैर-शून्य होने चाहिए। ग्राफ़ पर प्रत्येक बिंदु के लिए पूर्ववर्ती डेटा पॉइंट्स का औसत रेखांकन करता है। from / until

उदाहरण:

&target=movingAverage(Server.instance01.threads.busy,10)
&target=movingAverage(Server.instance*.threads.idle,'5min')
मूविंगमैक्स (सीरीज़लिस्ट, विंडोसाइज़, xFilesFactor = कोई नहीं)

पिछले अंकों की एक निश्चित संख्या, या एक समय अंतराल पर एक मीट्रिक (या मीट्रिक) की चलती अधिकतम रेखांकन।

एक मीट्रिक या एक वाइल्डकार्ड सीरीज़ ले जाता है, जिसके बाद नंबर 1 के डेटापॉइंट्स या एक उद्धृत स्ट्रिंग होती है, जैसे '1 घंटे' या '5 मिनट' की लंबाई ( समय प्रारूपों के उदाहरणों के लिए रेंडर एपीआई में देखें ), और निर्दिष्ट करने के लिए xFilesFactor मान आउटपुट को वैध मानने के लिए विंडो में कितने बिंदु गैर-शून्य होने चाहिए। ग्राफ़ पर प्रत्येक बिंदु के लिए पूर्ववर्ती डेटापॉइंट्स का अधिकतम रेखांकन करता है। from / until

उदाहरण:

&target=movingMax(Server.instance01.requests,10)
&target=movingMax(Server.instance*.errors,'5min')
मूविंगमेडियन (सीरीज़लिस्ट, विंडोसाइज़, xFilesFactor = कोई नहीं)

पिछले अंकों की एक निश्चित संख्या, या एक समय अंतराल पर एक मीट्रिक (या मीट्रिक) के मूविंग माध्य को रेखांकन करता है।

एक मीट्रिक या एक वाइल्डकार्ड सीरीज़ ले जाता है, जिसके बाद नंबर 1 के डेटापॉइंट्स या एक उद्धृत स्ट्रिंग होती है, जैसे '1 घंटे' या '5 मिनट' की लंबाई ( समय प्रारूपों के उदाहरणों के लिए रेंडर एपीआई में देखें ), और निर्दिष्ट करने के लिए xFilesFactor मान आउटपुट को वैध मानने के लिए विंडो में कितने बिंदु गैर-शून्य होने चाहिए। ग्राफ़ पर प्रत्येक बिंदु के लिए पूर्ववर्ती डेटा पॉइंट्स के माध्य को रेखांकन करता है। from / until

उदाहरण:

&target=movingMedian(Server.instance01.threads.busy,10)
&target=movingMedian(Server.instance*.threads.idle,'5min')
मूविंगमिन (सीरीज़लिस्ट, विंडोसाइज़, xFilesFactor = कोई नहीं)

पिछले अंकों की एक निश्चित संख्या, या एक समय अंतराल पर एक मीट्रिक (या मीट्रिक) की चलती न्यूनतम को रेखांकन करता है।

एक मीट्रिक या एक वाइल्डकार्ड सीरीज़ ले जाता है, जिसके बाद नंबर 1 के डेटापॉइंट्स या एक उद्धृत स्ट्रिंग होती है, जैसे '1 घंटे' या '5 मिनट' की लंबाई ( समय प्रारूपों के उदाहरणों के लिए रेंडर एपीआई में देखें ), और निर्दिष्ट करने के लिए xFilesFactor मान आउटपुट को वैध मानने के लिए विंडो में कितने बिंदु गैर-शून्य होने चाहिए। ग्राफ़ पर प्रत्येक बिंदु के लिए पूर्ववर्ती डेटापॉइंट का न्यूनतम ग्राफ़। from / until

उदाहरण:

&target=movingMin(Server.instance01.requests,10)
&target=movingMin(Server.instance*.errors,'5min')
मूविंगसम (सीरिज़लिस्ट, विंडोसाइज़, xFilesFactor = कोई नहीं)

पिछले अंकों की एक निश्चित संख्या, या एक समय अंतराल पर एक मीट्रिक (या मीट्रिक) की चलती राशि को रेखांकन करता है।

एक मीट्रिक या एक वाइल्डकार्ड सीरीज़ ले जाता है, जिसके बाद नंबर 1 के डेटापॉइंट्स या एक उद्धृत स्ट्रिंग होती है, जैसे '1 घंटे' या '5 मिनट' की लंबाई ( समय प्रारूपों के उदाहरणों के लिए रेंडर एपीआई में देखें ), और निर्दिष्ट करने के लिए xFilesFactor मान आउटपुट को वैध मानने के लिए विंडो में कितने बिंदु गैर-शून्य होने चाहिए। ग्राफ़ पर प्रत्येक बिंदु के लिए पूर्ववर्ती डेटा पॉइंट्स का योग रेखांकन करता है। from / until

उदाहरण:

&target=movingSum(Server.instance01.requests,10)
&target=movingSum(Server.instance*.errors,'5min')
मूविंगविंडो (सीरीज़लिस्ट, विंडोसाइज़, फ़ंक = 'औसत', xFilesFactor = कोई नहीं)

पिछले बिंदुओं की एक निश्चित संख्या, या एक समय अंतराल पर एक मीट्रिक (या मीट्रिक) की एक चलती हुई विंडो फ़ंक्शन को रेखांकन करता है।

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखलावादी, डेटापॉइंट्स की संख्या N या '1hour' या '5min' जैसी लंबाई के साथ एक उद्धृत स्ट्रिंग लेता है ( समय प्रारूपों के उदाहरण के लिए रेंडर एपीआई में देखें ), अंक पर लागू करने के लिए एक फ़ंक्शन विंडो में आउटपुट का उत्पादन करने के लिए, और xFilesFactor मान को निर्दिष्ट करने के लिए कि विंडो में कितने बिंदु गैर-शून्य होने चाहिए, आउटपुट को वैध माना जाए। ग्राफ़ पर प्रत्येक बिंदु के लिए पूर्ववर्ती डेटा पॉइंट्स के लिए फ़ंक्शन का आउटपुट रेखांकन करता है। from / until

उदाहरण:

&target=movingWindow(Server.instance01.threads.busy,10)
&target=movingWindow(Server.instance*.threads.idle,'5min','median',0.5)

ध्यान दें

xFilesFactor व्हिसपर स्टोरेज स्कीमा के समान शब्दार्थ का अनुसरण करता है। इसे 0 पर सेट करना (डिफ़ॉल्ट) का अर्थ है कि किसी दिए गए अंतराल में केवल एक मान को गैर-शून्य होना चाहिए, इसे 1 पर सेट करने का मतलब है कि अंतराल में सभी मान गैर-शून्य होना चाहिए। 0.5 की सेटिंग का मतलब है कि अंतराल में कम से कम आधे मान गैर-शून्य होना चाहिए।

multiplySeries (* seriesLists)

दो या अधिक श्रृंखला लेता है और उनके बिंदुओं को गुणा करता है। एक निरंतर उपयोग नहीं किया जा सकता है। किसी स्थिरांक से गुणा करने के लिए, स्केल () फ़ंक्शन का उपयोग करें।

उदाहरण:

&target=multiplySeries(Series.dividends,Series.divisors)

यह aggregate एकत्रीकरण के लिए एक उपनाम है multiply

मल्टीप्लेयर्सविथ वीलकार्ड्स (सीरीज़लिस्ट, * स्थिति)

दिए गए स्थान पर वाइल्डकार्ड डालने के बाद मल्टीप्लेरी को कॉल करें।

उदाहरण:

&target=multiplySeriesWithWildcards(web.host-[0-7].{avg-response,total-request}.value, 2)

यह इसके बराबर होगा

&target=multiplySeries(web.host-0.{avg-response,total-request}.value)&target=multiplySeries(web.host-1.{avg-response,total-request}.value)...

यह aggregateWithWildcards एकत्रीकरण के लिए एक उपनाम है multiply

nPercentile (सीरीज़लिस्ट, एन)

सीरीज़लिस्ट में प्रत्येक श्रृंखला का एन-प्रतिशत लौटाता है।

नॉन-नेटिवडेरिवेटिव (सीरीज़लिस्ट, मैक्सवेल = कोई नहीं)

उपर्युक्त व्युत्पन्न कार्य के रूप में भी, लेकिन नीचे की ओर जाने वाले डेटा बिंदुओं को अनदेखा करता है। काउंटरों के लिए उपयोगी जो लंबे समय तक बढ़ते हैं, फिर लपेटो या रीसेट करें। (जैसे कि यदि कोई नेटवर्क इंटरफ़ेस नष्ट हो जाता है और एक कर्नेल मॉड्यूल को अनलोड और री-लोड करके पुनः बनाया जाता है, तो USB / WiFi कार्ड के साथ आम है।

उदाहरण:

&target=nonNegativederivative(company.server.application01.ifconfig.TXPackets)
ऑफसेट (श्रृंखलावादी, कारक)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला के बाद एक निरंतरता लेता है, और प्रत्येक डेटापॉइंट में निरंतर जोड़ता है।

उदाहरण:

&target=offset(Server.instance01.threads.busy,10)
offsetToZero (seriesList)

प्रत्येक डेटापॉइंट से श्रृंखला में न्यूनतम मूल्य को घटाकर एक मीट्रिक या वाइल्डकार्ड श्रृंखलासूची को ऑफ़सेट करता है।

विभिन्न श्रृंखलाओं की तुलना करने के लिए उपयोगी जहां प्रत्येक श्रृंखला में मूल्य औसत से अधिक या कम हो सकते हैं लेकिन आप केवल सापेक्ष अंतर में रुचि रखते हैं।

एक उदाहरण उपयोग मामला विभिन्न दौर यात्रा समय परिणामों की तुलना करने के लिए है। जब RTT (एक सर्वर को पिंग करना) को मापते हैं, तो अलग-अलग डिवाइस नेटवर्क विलंबता के कारण लगातार अलग-अलग परिणामों के साथ वापस आ सकते हैं जो कि जांच और डिवाइस के बीच कितने नेटवर्क हॉप्स के आधार पर अलग-अलग होंगे। एक ही ग्राफ में विभिन्न उपकरणों की तुलना करने के लिए, प्रत्येक के लिए नेटवर्क विलंबता परिणाम से बाहर फैक्टर किया जाना है। यह एक शॉर्टकट है जो सबसे तेज़ प्रतिक्रिया (श्रृंखला में सबसे कम संख्या) लेता है और सेट करता है कि शून्य तक और फिर उस श्रृंखला के अन्य सभी डेटा पॉइंट्स को ऑफ़सेट करता है। यह धारणा बनाता है कि सबसे कम प्रतिक्रिया सबसे तेज़ उपकरण है जो प्रतिक्रिया दे सकता है, निश्चित रूप से श्रृंखला में जितने अधिक डेटा पॉइंट हैं, यह धारणा उतनी ही सटीक है।

उदाहरण:

&target=offsetToZero(Server.instance01.responseTime)
&target=offsetToZero(Server.instance*.responseTime)
प्रति सेकंड (श्रृंखलाकार, अधिकतम विचलन = कोई नहीं)

NonNegativeDerivative को श्रृंखला समय अंतराल के लिए समायोजित किया गया है यह एक रनिंग कुल मीट्रिक लेने के लिए उपयोगी है और यह दर्शाता है कि प्रति सेकंड कितने अनुरोधों को संभाला गया था।

उदाहरण:

&target=perSecond(company.server.application01.ifconfig.TXPackets)

हर बार जब आप ifconfig चलाते हैं, तो RX और TXPackets अधिक होते हैं (यह मानते हुए कि नेटवर्क ट्रैफ़िक है।) perececond फ़ंक्शन को लागू करने से, आप प्रति सेकंड पैकेट का एक विचार प्राप्त कर सकते हैं या प्राप्त कर सकते हैं, भले ही आप केवल कुल रिकॉर्डिंग कर रहे हों।

प्रतिशतिलेओफ़रीज़ (सीरीज़लिस्ट, एन, इंटरपोलेट = गलत)

centileOfSeries एक एकल श्रृंखला लौटाती है जो प्रत्येक बिंदु पर वाइल्डकार्ड श्रृंखला में लिए गए एन-प्रतिशताइल मूल्यों से बनी होती है। जब तक इंटरपोल को सही पर सेट नहीं किया जाता है, तब तक आपूर्ति की गई श्रृंखलाओं में एक प्रतिशत में निहित प्रतिशत मान वास्तविक होते हैं।

pieAverage (श्रृंखला)

औसत लौटाएं

pieMaximum (श्रृंखला)

अधिकतम वापस करें

pieMinimum (श्रृंखला)

न्यूनतम वापस करें

पाव (श्रृंखलाकार, कारक)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखलावादी का अनुसरण करता है, जिसके बाद एक स्थिरांक होता है, और प्रत्येक बिंदु पर प्रदान की गई स्थिरांक की शक्ति से डेटापॉइंट उठाता है।

उदाहरण:

&target=pow(Server.instance01.threads.busy,10)
&target=pow(Server.instance*.threads.busy,10)
powSeries (* seriesLists)

दो या दो से अधिक श्रृंखला लेता है और उनके बिंदुओं को रोकता है। एक निरंतर रेखा का उपयोग किया जा सकता है।

उदाहरण:

&target=powSeries(Server.instance01.app.requests, Server.instance01.app.replies)
randomWalkFunction (नाम, चरण = 60)

लघु उपनाम: यादृच्छिकवॉक ()

0. पर शुरू होने वाला एक यादृच्छिक चलना लौटाता है यह परीक्षण के लिए बहुत अच्छा है जब कानाफूसी में कोई वास्तविक डेटा नहीं है।

उदाहरण:

&target=randomWalk("The.time.series")

यह "The.time.series" नामक एक श्रृंखला बनाएगा जिसमें ऐसे बिंदु हों जहां x (t) == x (t-1) + यादृच्छिक () - 0.5, और x (0) == 0. वैकल्पिक दूसरा तर्क स्वीकार करता है 'स्टेप' पैरामीटर (डिफ़ॉल्ट स्टेप 60 सेकंड है)

rangeOfSeries (* seriesLists)

एक वाइल्डकार्ड श्रृंखलावादी बनाता है। श्रृंखला की श्रेणी में इनपुट का एक सेट डिस्टिल्ड करता है

उदाहरण:

&target=rangeOfSeries(Server*.connections.total)

यह aggregate एकत्रीकरण के लिए एक उपनाम है rangeOf

कमियां (सीरीज़लिस्ट, कम करना, कम करना, * कम करना)

संक्षिप्त रूप: reduce()

श्रृंखला सूची की सूची बनाता है और इसे कम करने के माध्यम से श्रृंखला की सूची में घटाता है।

रिडक्शन को कम किया जाता है कम करने के लिए प्रत्येक श्रृंखला में न्यूमॉड को मैचमेकरों की सूची के खिलाफ किया जाता है। फिर प्रत्येक श्रृंखला को कम करने के लिए पारित किया जाता है ताकि कम करने वालों द्वारा दिए गए आदेश में तर्क दिए जा सकें। कम करने के लिए एकल श्रृंखला निकलना चाहिए।

श्रृंखला की परिणामी सूची को अलियास किया जाता है ताकि उन्हें अन्य कार्यों में आसानी से घोंसला बनाया जा सके।

उदाहरण : प्रत्येक सर्वर के लिए मैप / कम करेंPercent (bytes_used, total_bytes)

मान लें कि नीचे दिए गए फ़ॉर्म में मीट्रिक मौजूद हैं:

servers.server1.disk.bytes_used
servers.server1.disk.total_bytes
servers.server2.disk.bytes_used
servers.server2.disk.total_bytes
servers.server3.disk.bytes_used
servers.server3.disk.total_bytes
...
servers.serverN.disk.bytes_used
servers.serverN.disk.total_bytes

प्रत्येक सर्वर के लिए प्रयुक्त डिस्क का प्रतिशत प्राप्त करने के लिए:

reduceSeries(mapSeries(servers.*.disk.*,1),"asPercent",3,"bytes_used","total_bytes") =>

  alias(asPercent(servers.server1.disk.bytes_used,servers.server1.disk.total_bytes),"servers.server1.disk.reduce.asPercent"),
  alias(asPercent(servers.server2.disk.bytes_used,servers.server2.disk.total_bytes),"servers.server2.disk.reduce.asPercent"),
  alias(asPercent(servers.server3.disk.bytes_used,servers.server3.disk.total_bytes),"servers.server3.disk.reduce.asPercent"),
  ...
  alias(asPercent(servers.serverN.disk.bytes_used,servers.serverN.disk.total_bytes),"servers.serverN.disk.reduce.asPercent")

दूसरे शब्दों में, हम निम्नलिखित मैट्रिक्स वापस प्राप्त करेंगे:

servers.server1.disk.reduce.asPercent
servers.server2.disk.reduce.asPercent
servers.server3.disk.reduce.asPercent
...
servers.serverN.disk.reduce.asPercent

यह भी देखें

mapSeries()

RemoveAbovePercentile (सीरीज़लिस्ट, एन)

श्रृंखला या प्रदान की गई श्रृंखला की सूची से nth प्रतिशतक के ऊपर डेटा निकालता है। इस प्रतिशत से ऊपर के मूल्यों को कोई नहीं का मूल्य दिया जाता है।

निष्कासनविभाजन (श्रृंखलावादी, एन)

प्रदान की गई श्रृंखला या दी गई श्रृंखला की सूची से दिए गए सीमा से ऊपर के डेटा को निकालता है। इस सीमा से ऊपर के मानों को किसी का मान नहीं दिया जाता है।

निष्कासन करें

श्रृंखला या प्रदान की गई श्रृंखला की सूची से nth प्रतिशतक के नीचे डेटा को निकालता है। इस प्रतिशत के नीचे मानों को किसी का मान नहीं दिया जाता है।

निष्कासनबेलवू (सीरीज़लिस्ट, एन)

प्रदान की गई श्रृंखला या दी गई श्रृंखला की सूची से नीचे दिए गए डेटा को निकालता है। इस सीमा से नीचे के मानों को किसी का मान नहीं दिया जाता है।

निष्कासनपत्रिका (श्रृंखलासूची, n)

उन श्रृंखलाओं को हटा देता है, जिनका मूल्य एक पल में सभी मानों के x-centile में पड़ा नहीं होता है

RemoveEmptySeries (सीरीज़लिस्ट, xFilesFactor = कोई नहीं)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला सूची लेता है। पारित किए गए सभी मीट्रिक में से, खाली डेटा नहीं वाले केवल मीट्रिक खींचता है

उदाहरण:

&target=removeEmptySeries(server*.instance*.threads.busy)

खाली डेटा नहीं के साथ केवल लाइव सर्वर बनाता है।

xFilesFactor व्हिसपर स्टोरेज स्कीमा के समान शब्दार्थ का अनुसरण करता है। इसे 0 पर सेट करना (डिफ़ॉल्ट) का मतलब है कि श्रृंखला में केवल एक ही मूल्य को गैर-शून्य होना चाहिए, इसे गैर-रिक्त माना जाएगा, इसे 1 पर सेट करने का मतलब है कि श्रृंखला में सभी मान गैर-शून्य होना चाहिए। 0.5 की सेटिंग का मतलब है कि श्रृंखला में कम से कम आधे मान गैर-शून्य होने चाहिए।

राउंडफंक्शन (श्रृंखलावादी, सटीक = कोई नहीं)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला लेता है वैकल्पिक रूप से एक सटीक द्वारा पीछा किया जाता है, और प्रत्येक डेटापॉइंट को निर्दिष्ट परिशुद्धता के लिए गोल करता है।

उदाहरण:

&target=round(Server.instance01.threads.busy)
&target=round(Server.instance01.threads.busy,2)
स्केल (श्रृंखलाकार, कारक)

एक मैट्रिक या एक वाइल्डकार्ड श्रृंखला के बाद एक निरंतरता लेता है, और प्रत्येक बिंदु पर प्रदान की गई स्थिरांक से डेटापॉइंट को गुणा करता है।

उदाहरण:

&target=scale(Server.instance01.threads.busy,10)
&target=scale(Server.instance*.threads.busy,10)
स्केल-सेकंड (श्रृंखलावादी, सेकंड)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला सूची लेता है और "सेकंड प्रति मान" देता है, जहां सेकंड इस फ़ंक्शन के लिए एक अंतिम तर्क है।

व्युत्पन्न या अभिन्न कार्य के साथ संयोजन के रूप में उपयोगी यदि आप मनमाने प्रतिधारण के लिए एक ज्ञात संकल्प के लिए इसके परिणाम को सामान्य करना चाहते हैं

secondYAxis (seriesList)

द्वितीयक Y अक्ष पर श्रृंखला को ग्राफित करें।

seriesByTag (* tagExpressions)

सभी निर्दिष्ट टैग अभिव्यक्तियों से मेल खाते श्रृंखला का एक श्रृंखलावादी लौटाता है।

उदाहरण:

&target=seriesByTag("tag1=value1","tag2!=value2")

सभी श्रृंखलाओं की एक श्रंखला देता है, जिनके पास tag1 का मान 1 पर सेट है, और value2 के लिए tag2 सेट नहीं है।

टैग विनिर्देशक तार हैं, और निम्न प्रारूप हो सकते हैं:

tag=spec    tag value exactly matches spec
tag!=spec   tag value does not exactly match spec
tag=~value  tag value matches the regular expression spec
tag!=~spec  tag value does not match the regular expression spec

कोई भी टैग युक्ति जो किसी रिक्त मान से मेल खाती है श्रृंखला से मेल खाने के लिए माना जाता है जिसमें वह टैग नहीं है।

कम से कम एक टैग युक्ति को एक गैर-रिक्त मान की आवश्यकता होगी।

मूल्य की शुरुआत में नियमित अभिव्यक्ति की स्थिति को एंकर माना जाता है।

अधिक विवरण के लिए क्वेरी टैग की गई श्रृंखला देखें ।

setXFilesFactor (सीरीज़लिस्ट, xFilesFactor)

संक्षिप्त रूप: xFilesFactor ()

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखलावादी और 0 और 1 के बीच xFilesFactor मान लेता है

जब एक श्रृंखला को समेकित करने की आवश्यकता होती है, तो यह एक अंतराल में मूल्यों का अंश निर्धारित करता है जिसे समेकन के लिए वैध नहीं माना जाना चाहिए। यदि पर्याप्त मूल्य नहीं हैं, तो उस अंतराल के लिए कोई भी वापस नहीं किया जाएगा।

&target=xFilesFactor(Sales.widgets.largeBlue, 0.5)
&target=Servers.web01.sda1.free_space|consolidateBy('max')|xFilesFactor(0.5)

XFilesFactor इस समारोह के माध्यम से सेट सभी कार्यों है कि एक को स्वीकार करने के लिए डिफ़ॉल्ट के रूप में प्रयोग किया जाता है xFilesFactor पैरामीटर, सभी कार्यों कि कई श्रृंखला और / या अंतराल, और भर में डेटा को समेकित maxDataPoints समेकन।

संपूर्ण रेंडर अनुरोध के लिए एक डिफ़ॉल्ट भी xFilesFactor क्वेरी पैरामीटर का उपयोग करके सेट किया जा सकता है ।

ध्यान दें

xFilesFactor व्हिसपर स्टोरेज स्कीमा के समान शब्दार्थ का अनुसरण करता है। इसे 0 पर सेट करना (डिफ़ॉल्ट) का अर्थ है कि किसी दिए गए अंतराल में केवल एक मान को गैर-शून्य होना चाहिए, इसे 1 पर सेट करने का मतलब है कि अंतराल में सभी मान गैर-शून्य होना चाहिए। 0.5 की सेटिंग का मतलब है कि अंतराल में कम से कम आधे मान गैर-शून्य होना चाहिए।

sinFunction (नाम, आयाम = 1, चरण = 60)

लघु उपनाम: पाप ()

बस वर्तमान समय की साइन लौटाता है। वैकल्पिक आयाम पैरामीटर तरंग के आयाम को बदलता है।

उदाहरण:

&target=sin("The.time.series", 2)

यह "The.time.series" नामक एक श्रृंखला बनाएगा जिसमें पाप (x) * 2 होगा। वैकल्पिक दूसरे तर्क को 'आयाम' पैरामीटर के रूप में स्वीकार करता है (डिफ़ॉल्ट आयाम 1 है) वैकल्पिक तीसरे तर्क को 'चरण' पैरामीटर के रूप में स्वीकार करता है (डिफ़ॉल्ट कदम 60 सेकंड है)

smartSummarize (सीरीज़लिस्ट, इंटरवलस्ट्रिंग, फंक = 'सम', अलाइन्टो = कोई नहीं)

संक्षेप का लघु संस्करण।

AlignToFrom बूलियन पैरामीटर को alignTo से बदल दिया गया है और अब इसका कोई प्रभाव नहीं है। संरेखण साल, महीने, सप्ताह, दिन, घंटे और मिनट के लिए हो सकता है।

इस समारोह एकत्रीकरण कार्यों के साथ इस्तेमाल किया जा सकता average , median , sum , min , max , diff , stddev , count , range , multiply और last

सॉर्टबी (श्रृंखलावादी, फंक = 'औसत', रिवर्स = गलत)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखलासूची लेता है जिसके बाद एक एकत्रीकरण फ़ंक्शन और एक वैकल्पिक reverse पैरामीटर होता है।

निर्दिष्ट फ़ंक्शन के अनुसार सॉर्ट किए गए रिटर्न देता है।

उदाहरण:

&target=sortBy(server*.instance*.threads.busy,'max')

अधिकतम द्वारा सर्वर को आरोही क्रम में खींचता है।

sortByMaxima (seriesList)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला सूची लेता है।

निर्दिष्ट समय अवधि के दौरान अधिकतम मूल्य द्वारा अवरोही क्रम में मीट्रिक की सूची तैयार करता है। न्यूनतम मान रेखाओं को दृश्यमान रखने के लिए & areaMode = सभी पैरामीटर के साथ उपयोगी।

उदाहरण:

&target=sortByMaxima(server*.instance*.memory.free)
sortByMinima (seriesList)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला सूची लेता है।

निर्दिष्ट की गई समयावधि में सबसे कम मान द्वारा मीट्रिक की सूची को केवल श्रृंखला सहित अधिकतम मान 0 से अधिक है।

उदाहरण:

&target=sortByMinima(server*.instance*.memory.free)
सॉर्टनाम (श्रृंखलासूची, प्राकृतिक = गलत, उल्टा = गलत)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला सूची लेता है। वर्णमाला क्रम या प्राकृतिक छँटाई का उपयोग करके मीट्रिक नाम से मीट्रिक की सूची तैयार करता है। प्राकृतिक छँटाई नामों की संख्या को अधिक स्वाभाविक रूप से क्रमबद्ध करने की अनुमति देता है, जैसे: - वर्णानुक्रमिक छँटाई: सर्वर 1, सर्वर 11, सर्वर 12, सर्वर 2 - प्राकृतिक छँटाई: सर्वर 1, सर्वर 2, सर्वर 11, सर्वर 12

sortByTotal (seriesList)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला सूची लेता है।

निर्दिष्ट समय अवधि के दौरान मूल्यों के योग से अवरोही क्रम में मीट्रिक की सूची तैयार करता है।

वर्गमूल (seriesList)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला सूची लेता है, और प्रत्येक डेटा पॉइंट के वर्गमूल की गणना करता है।

उदाहरण:

&target=squareRoot(Server.instance01.threads.busy)
स्टैक किया गया (सीरीज़लिस्ट, स्टैकनाम = '__ DEFAULT__')

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला सूची लेता है और उन्हें बदल देता है ताकि वे ढेर हो जाएं। यह स्टैक्ड एरिया मोड (जो सब कुछ ढेर करता है) का उपयोग किए बिना सिर्फ कुछ जोड़े मैट्रिक्स को स्टैक करने का एक तरीका है। इसके माध्यम से एक मिश्रित स्टैक्ड और गैर स्टैक्ड ग्राफ बनाया जा सकता है

यह स्टैक के नाम के साथ एक वैकल्पिक तर्क भी ले सकता है, अगर इनपुट और आउटपुट मेट्रिक्स के लिए एक से अधिक उदाहरण हैं।

उदाहरण:

&target=stacked(company.server.application01.ifconfig.TXPackets, 'tx')
stddevSeries (* seriesLists)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखला सूची लेता है। प्रत्येक समय में उत्तीर्ण सभी मैट्रिक्स के मानक विचलन को खींचता है।

उदाहरण:

&target=stddevSeries(company.server.*.threads.busy)

यह aggregate एकत्रीकरण के लिए एक उपनाम है stddev

stdev (सीरीज़लिस्ट, पॉइंट्स, विंडोटॉलरेंस = 0.1)

एक मैट्रिक या वाइल्डकार्ड श्रृंखला लेता है, जिसके बाद एक पूर्णांक एन होता है। पिछले एन डेटापॉइंट के लिए पारित सभी मैट्रिक्स का मानक विचलन खींचें। यदि विंडो में अशक्त बिंदुओं का अनुपात विंडोटॉलरेंस से अधिक है, तो गणना को छोड़ दें। WindowTolerance का डिफ़ॉल्ट 0.1 है (विंडो में 10% तक पॉइंट गायब हो सकते हैं)। ध्यान दें कि यदि यह 0.0 पर सेट है, तो यह आउटपुट में बड़े अंतराल का कारण बन जाएगा कहीं भी एक बिंदु गायब है।

उदाहरण:

&target=stdev(server*.instance*.threads.busy,30)
&target=stdev(server*.instance*.cpu.system,30,0.0)
पदार्थ (श्रृंखलावादी, प्रारंभ = 0, रोक = 0)

1 या 2 पूर्णांकों के बाद एक मीट्रिक या वाइल्डकार्ड श्रृंखला सूची लेता है। मान लें कि मीट्रिक नाम एक सूची या सरणी है, जिसके प्रत्येक तत्व को डॉट्स द्वारा अलग किया गया है। प्रिंट की n - लंबाई तत्व (यदि केवल एक पूर्णांक n पास है) या n - सरणी के तत्व (यदि दो पूर्णांक n और m पास हैं)। सूची तत्व 0 से शुरू होती है और तत्व (लंबाई - 1) के साथ समाप्त होती है।

उदाहरण:

&target=substr(carbon.agents.hostname.avgUpdateTime,2,4)

लेबल "hostname.avgUpdateTime" के रूप में मुद्रित किया जाएगा।

sumSeries (* seriesLists)

संक्षिप्त रूप: योग ()

यह मैट्रिक्स को एक साथ जोड़ देगा और प्रत्येक डेटा पॉइंट पर राशि लौटा देगा। (समय के साथ एक राशि के लिए अभिन्न देखें)

उदाहरण:

&target=sum(company.server.application*.requestsHandled)

यह प्रति मिनट हैंडल किए गए सभी अनुरोधों का योग दिखाएगा (बशर्ते अनुरोध मिनट एक बार एकत्र किए गए हों)। यदि अलग-अलग अवधारण दरों के साथ मैट्रिक्स संयुक्त होते हैं, तो सबसे बड़ी मीट्रिक को रेखांकन किया जाता है, और अन्य मैट्रिक्स का योग महीन प्रतिधारण दरों के साथ मैट्रिक्स के लिए औसत होता है।

यह aggregate एकत्रीकरण के लिए एक उपनाम है sum

समसरिविथवॉल्डकार्ड्स (श्रृंखलाकार, * स्थिति)

दिए गए स्थान पर वाइल्डकार्ड सम्मिलित करने के बाद कॉल करें।

उदाहरण:

&target=sumSeriesWithWildcards(host.cpu-[0-7].cpu-{user,system}.value, 1)

यह इसके बराबर होगा

&target=sumSeries(host.cpu-[0-7].cpu-user.value)&target=sumSeries(host.cpu-[0-7].cpu-system.value)

यह aggregateWithWildcards एकत्रीकरण के लिए एक उपनाम है sum

सारांशित करें (श्रृंखलावादी, अंतरालवादी, कवक = 'योग', संरेखित करें = गलत)

एक निश्चित आकार के अंतराल में डेटा को संक्षेप करें।

डिफ़ॉल्ट रूप से, प्रत्येक अंतराल बाल्टी की सामग्री को एक साथ सम्‍मिलित किया जाता है। यह उन काउंटरों के लिए उपयोगी है जहां प्रत्येक वृद्धि एक असतत घटना का प्रतिनिधित्व करती है और "प्रति X" मान प्राप्त करने के लिए उस अंतराल में सभी घटनाओं को समेटने की आवश्यकता होती है।

इसके बजाय 'औसत' को निर्दिष्ट करना प्रत्येक बाल्टी के लिए माध्य लौटाएगा, जो तब अधिक उपयोगी हो सकता है जब मूल्य एक गेज है जो समय में एक निश्चित मूल्य का प्रतिनिधित्व करता है।

इस समारोह एकत्रीकरण कार्यों के साथ इस्तेमाल किया जा सकता average , median , sum , min , max , diff , stddev , count , range , multiply और last

डिफ़ॉल्ट रूप से, बाल्टी की गणना निकटतम अंतराल पर गोल करके की जाती है। यह एक दिन से छोटे अंतराल के लिए अच्छी तरह से काम करता है। उदाहरण के लिए, 22:32 बाल्टी में समाप्त हो जाएगा 22: 00-23: 00 जब अंतराल = 1 घंटे।

Passing alignToFrom = सत्य इसके बजाय समय से शुरू होने वाली बाल्टियाँ बनाएगा। इस मामले में, 22:32 के लिए बाल्टी समय से निर्भर करती है। अगर = 6: 30 से, तो 22:32 के लिए 1 हर्ट बाल्टी 22: 30-23: 30 है।

उदाहरण:

&target=summarize(counter.errors, "1hour") # total errors per hour
&target=summarize(nonNegativeDerivative(gauge.num_users), "1week") # new users per week
&target=summarize(queue.size, "1hour", "avg") # average queue size per hour
&target=summarize(queue.size, "1hour", "max") # maximum queue size during each hour
&target=summarize(metric, "13week", "avg", true)&from=midnight+20100101 # 2010 Q1-4
दहलीज (मान, लेबल = कोई नहीं, रंग = कोई नहीं)

एक फ्लोट F लेता है, उसके बाद एक लेबल (डबल कोट्स में) और एक रंग होता है। ( मान्य रंग नामों और प्रारूपों के लिए रेंडर एपीआई bgcolor में देखें ।)

ग्राफ पर F पर एक क्षैतिज रेखा खींचता है।

उदाहरण:

&target=threshold(123.456, "omgwtfbbq", "red")
समय-सीमा (नाम, चरण = ६०)

लघु उपनाम: समय ()

बस प्रत्येक X मान के लिए टाइमस्टैम्प लौटाता है। टी

उदाहरण:

&target=time("The.time.series")

इससे "The.time.series" नाम की एक श्रृंखला बनाई जाएगी जिसमें Y में समान मूल्य (सेकंड में) होता है क्योंकि X. 'स्टेप' पैरामीटर के रूप में वैकल्पिक दूसरा तर्क स्वीकार करता है (डिफ़ॉल्ट कदम 60 सेकंड है)

टाइमशिफ्ट (सीरीज़लिस्ट, टाइमशिफ्ट, रिसेटइंड = ट्रू, अलाइनस्ट = फॉल्स)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखलावादी होता है, जिसके बाद एक लंबी अवधि के साथ एक उद्धृत स्ट्रिंग होता है ( समय प्रारूपों के उदाहरण के लिए रेंडर एपीआई में देखें )। from / until

चयनित मेट्रिक्स को समय पर स्थानांतरित कर दिया। यदि कोई संकेत नहीं दिया गया है, तो एक ऋण चिह्न (-) निहित है जो समय में मीट्रिक को वापस स्थानांतरित कर देगा। यदि एक प्लस चिह्न (+) दिया जाता है, तो मीट्रिक को समय में आगे स्थानांतरित कर दिया जाएगा।

जब तक रीसेट गलत न हो, आधार तिथि के अंत तक स्वचालित रूप से अंतिम तिथि सीमा रीसेट कर देगा। उदाहरण का मामला यह है कि जब आप पिछले सप्ताह के लिए टाइमशिफ्ट करते हैं और भविष्य में एक समय को शामिल करने के लिए ग्राफ़ की तिथि सीमा निर्धारित करते हैं, तो इस समयसीमा को वर्तमान समय में समाप्त होने का दिखावा करने के लिए सीमित किया जाएगा। यदि रीसेट करें गलत है, तो इसके बजाय भविष्य के समय सहित पूरी श्रृंखला आकर्षित करेंगे।

क्योंकि समय को सेकंड की एक निश्चित संख्या द्वारा स्थानांतरित किया जाता है, DST के साथ समय अवधि को DST के बिना एक समय अवधि की तुलना में, और इसके विपरीत, एक स्पष्ट मिसलिग्न्मेंट में परिणाम होगा। उदाहरण के लिए, 8am को 7am के साथ ओवरलैड किया जा सकता है। इसकी भरपाई के लिए, alignDST विकल्प का उपयोग करें।

एक पिछली अवधि में खुद के खिलाफ एक मीट्रिक की तुलना करने या एक ऑफसेट पर संग्रहीत डेटा को सही करने के लिए उपयोगी है।

उदाहरण:

&target=timeShift(Sales.widgets.largeBlue,"7d")
&target=timeShift(Sales.widgets.largeBlue,"-7d")
&target=timeShift(Sales.widgets.largeBlue,"+1h")
timeSlice (श्रृंखलाकार, startSliceAt, endSliceAt = 'now')

एक मीट्रिक या वाइल्डकार्ड मीट्रिक लेता है, उसके बाद लाइन शुरू करने के लिए समय के साथ एक उद्धृत स्ट्रिंग और लाइन समाप्त करने के लिए समय के साथ एक और उद्धृत स्ट्रिंग। आरंभ और अंत समय समावेशी हैं। समय प्रारूपों के उदाहरण के लिए रेंडर एपीआई में देखें । from / until

डेटा की एक विस्तृत श्रृंखला से डेटा की एक श्रृंखला का एक हिस्सा छानने के लिए उपयोगी है।

उदाहरण:

&target=timeSlice(network.core.port1,"00:00 20140101","11:59 20140630")
&target=timeSlice(network.core.port1,"12:00 20140630","now")
टाइमस्टैक (सीरीज़लिस्ट, टाइमशिफ्ट यूनीट = '1 डी', टाइमशिफ्टस्टार्ट = 0, टाइमशिफ्टईंड = 7)

एक मीट्रिक या एक वाइल्डकार्ड श्रृंखलावादी होता है, जिसके बाद एक लंबी अवधि के साथ एक उद्धृत स्ट्रिंग होता है ( समय प्रारूपों के उदाहरण के लिए रेंडर एपीआई में देखें )। समय की लंबाई के लिए एक शुरुआत गुणक और अंत गुणक भी लेता है from / until

एक श्रृंखला बनाएँ, जो मूल मीट्रिक श्रृंखला से बना है, जो समय पारियों के साथ शुरू हुई समय की पाली के साथ अंत गुणक के माध्यम से शुरू होती है।

इतिहास को देखने के लिए, या औसतन या stddevSeries में खिलाने के लिए उपयोगी है।

उदाहरण:

&target=timeStack(Sales.widgets.largeBlue,"1d",0,7)    # create a series for today and each of the previous 7 days
ट्रांसफॉर्मनल (सीरीज़लिस्ट, डिफ़ॉल्ट = 0, संदर्भश्रेणी = कोई नहीं)

एक मीट्रिक या वाइल्डकार्ड श्रृंखलाबद्धता लेता है और डिफ़ॉल्ट रूप से निर्दिष्ट मूल्य के साथ अशक्त मूल्यों को प्रतिस्थापित करता है । मान 0 का उपयोग यदि निर्दिष्ट नहीं है। वैकल्पिक सन्दर्भ, यदि निर्दिष्ट किया गया है, तो एक मीट्रिक या वाइल्डकार्ड श्रृंखला सूची है जो यह नियंत्रित करती है कि किस समय अंतराल नल को बदला जाना चाहिए। यदि निर्दिष्ट किया गया है, तो नल को केवल उन अंतरालों में प्रतिस्थापित किया जाता है जहां किसी भी संदर्भ में समान अंतराल के लिए एक गैर-नल पाया जाता है। यह विधि चित्रमय मोड में drawNullAsZero फ़ंक्शन की सराहना करती है, लेकिन पाठ-केवल मोड में भी काम करती है।

उदाहरण:

&target=transformNull(webapp.pages.*.views,-1)

यह कोई भी ऐसा पृष्ठ लेगा जिसमें मान न हों और डिफ़ॉल्ट 1 के रूप में नकारात्मक 1 की आपूर्ति हो। किसी अन्य संख्यात्मक मान का भी उपयोग किया जा सकता है।

अद्वितीय (* seriesLists)

श्रृंखलावादियों की एक मनमानी संख्या लेता है और नाम से फ़िल्टर की गई अद्वितीय श्रृंखला लौटाता है।

उदाहरण:

&target=unique(mostDeviant(server.*.disk_free,5),lowestCurrent(server.*.disk_free,5))

कम डिस्क स्थान के साथ सर्वर खींचता है, और अत्यधिक विचलित डिस्क स्थान वाले सर्वर, लेकिन कभी भी एक ही श्रृंखला दो बार नहीं होती है।

उपयोगशरीर कबूतर (श्रृंखलासूची, मूल्य, खोज, बदलें)

दिए गए मूल्य के खिलाफ प्रत्येक श्रृंखला की अधिकतम तुलना करता है । यदि श्रृंखला अधिकतम मान से अधिक है , तो संबंधित मीट्रिक की साजिश रचने के लिए नियमित नाम खोज और प्रतिस्थापित श्रृंखला नाम के खिलाफ लागू किया जाता है

उदाहरण के लिए दिए गए उपयोगसैब एवोव (गैन्ग्लिया.मेट्रिक 1। क्रेक्स, 10, 'रीक्स', 'टाइम'), रिस्पांस टाइम मेट्रिक केवल तभी दिया जाएगा जब संबंधित अनुरोध / एस मेट्रिक का अधिकतम मूल्य 10 हो।

&target=useSeriesAbove(ganglia.metric1.reqs,10,"reqs","time")
ऊर्ध्वाधर (ts, लेबल = कोई नहीं, रंग = कोई नहीं)

टाइमस्टैम्प स्ट्रिंग ts लेता है।

वैकल्पिक 'लेबल' और 'रंग' के साथ निर्दिष्ट टाइमस्टैम्प पर एक ऊर्ध्वाधर रेखा खींचता है। समर्थित टाइमस्टैम्प स्वरूपों में सापेक्ष (जैसे -3 h) और निरपेक्ष (जैसे 16: 00_20110501) तार शामिल हैं, जैसे कि उन from और until मापदंडों के साथ उपयोग किए गए । जब सेट किया जाता है, तो ग्राफ लेबल में 'लेबल' दिखाई देगा।

नोट: अनुरोधित सीमा के बाहर परिभाषित कोई भी टाइमस्टैम्प 'ValueError' अपवाद को बढ़ाएगा।

उदाहरण:

&target=verticalLine("12:3420131108","event","blue")
&target=verticalLine("16:00_20110501","event")
&target=verticalLine("-5mins")
भारित लाभ (seriesListAvg, seriesListWeight, * nodes)

औसत मूल्यों की एक श्रृंखला और वजन की एक श्रृंखला लेता है और सभी मूल्यों के लिए एक भारित औसत पैदा करता है। संबंधित मानों को एक या अधिक शून्य-अनुक्रमित नोड्स और / या टैग साझा करना चाहिए।

उदाहरण:

&target=weightedAverage(*.transactions.mean,*.transactions.count,0)

प्रत्येक नोड श्रृंखला नाम में एक नोड या एक टैग की पहचान करने वाले स्ट्रिंग का संदर्भ देने वाला पूर्णांक हो सकता है।

फंक्शन प्लगिन

फ़ंक्शन प्लगइन्स रेंडर कॉल में उपयोग के लिए अतिरिक्त कार्यों को परिभाषित कर सकते हैं।

एक फंक्शन प्लगिन एक फाइल है जो एक या अधिक फ़ंक्शन को परिभाषित करता है SeriesFunctions और / और / या के शब्दकोशों का निर्यात करता है PieFunctions । जब ग्रेफाइट प्लगइन को लोड करता है, तो यह उपलब्ध कार्यों की सूची में SeriesFunctions और / या कार्यों को जोड़ देगा PieFunctions

प्रत्येक उजागर फ़ंक्शन को कम से कम एक requestContext और seriesList पैरामीटर को स्वीकार करना चाहिए , और आवश्यकतानुसार अतिरिक्त पैरामीटर स्वीकार कर सकते हैं।

requestContext के रूप में परिभाषित एक शब्दकोश होगा graphite.render.views.renderView() , वस्तुओं seriesList की एक सूची होगी TimeSeries

from graphite.functions.params import Param, ParamTypes

def toUpperCase(requestContext, seriesList):
  """Custom function that changes series names to UPPERCASE"""
  for series in seriesList:
    series.name = series.name.upper()
  return seriesList

# optionally set the group attribute
toUpperCase.group = 'Custom'
toUpperCase.params = [
  Param('seriesList', ParamTypes.seriesList, required=True),
]

SeriesFunctions = {
  'upper': toUpperCase,
}

प्रत्येक फ़ंक्शन में एक डॉकस्ट्रिंग हो सकता है .group , और .params परिभाषित विशेषताएं, ये फ़ंक्शन API आउटपुट में क्वेरी बिल्डरों के लिए संकेत के रूप में उपयोग की जाती हैं।

.group विशेषता स्ट्रिंग के रूप समूह का नाम है, .params विशेषता पैरामीटर परिभाषाओं की एक सूची है।

प्रत्येक पैरामीटर की परिभाषा Param वस्तु है, Param निर्माता निम्न तर्क स्वीकार करता है (ध्यान दें कि अनुरोध पैरामीटर पैरामीटर की सूची में शामिल नहीं है:

  • नाम : पैरामीटर का नाम
  • paramtype : पैरामीटर प्रकार, में से एक:
    • ParamTypes.aggFunc : एक एकत्रीकरण फ़ंक्शन नाम
    • ParamTypes.boolean : सच / गलत
    • ParamTypes.date : एक तिथि विवरण
    • ParamTypes.float : एक फ्लोट मान
    • ParamTypes.integer : पूर्णांक मान
    • ParamTypes.interval : एक अंतराल विनिर्देशक की तरह 1h , 1d , आदि
    • ParamTypes.intOrInterval : एक पूर्णांक या अंतराल विनिर्देशक
    • ParamTypes.node : एक नोड संख्या
    • ParamTypes.nodeOrTag : एक नोड संख्या या टैग नाम
    • ParamTypes.series : एक एकल श्रृंखला
    • ParamTypes.seriesList : श्रृंखला की एक सूची
    • ParamTypes.seriesLists : SeriesLists की एक सूची
    • ParamTypes.string : एक स्ट्रिंग मान
    • ParamTypes.tag : एक टैग नाम
  • आवश्यक : True आवश्यक मापदंडों के लिए सेट करें
  • डिफ़ॉल्ट : वैकल्पिक मापदंडों के लिए डिफ़ॉल्ट मान
  • एकाधिक : True कई उदाहरणों को स्वीकार करने वाले मापदंडों के लिए सेट करें ( * पायथन में परिभाषित )
  • विकल्प : मापदंडों के लिए उपलब्ध मूल्यों की एक सूची जो केवल एक परिभाषित सूची को स्वीकार करती है
  • सुझाव : मापदंडों के लिए सुझाए गए मूल्यों की एक सूची जो मुक्त रूप मूल्यों को स्वीकार करते हैं

कस्टम प्लगइन फ़ाइलों को /opt/graphite/webapp/graphite/functions/custom फ़ोल्डर में रखा जा सकता है और ग्रेफाइट शुरू होने पर स्वचालित रूप से लोड किया जाएगा।

पैक किए गए फ़ंक्शन प्लगइन मॉड्यूल को लोड करने के लिए, इसे FUNCTION_PLUGINS सेटिंग में जोड़ें :

FUNCTION_PLUGINS = [
  'some.function_plugin',
]

फंक्शन एपीआई

उपलब्ध कार्यों की सूची, या किसी विशिष्ट फ़ंक्शन के विवरण प्राप्त करने के लिए आप HTTP एपीआई का उपयोग कर सकते हैं।

उपलब्ध कार्यों की सूची प्राप्त करने के लिए:

$ curl -s "http://graphite/functions?pretty=1"

{
  "absolute": {
    "description": "<function description>",
    "function": "absolute(seriesList)",
    "group": "Transform",
    "module": "graphite.render.functions",
    "name": "absolute",
    "params": [
      {
        "name": "seriesList",
        "required": true,
        "type": "seriesList"
      }
    ]
  },
  <more functions...>
}

यदि पैरामीटर grouped=1 पारित हो जाता है, तो समूह द्वारा लौटी सूची का आयोजन किया जाएगा:

$ curl -s "http://graphite/functions?pretty=1&grouped=1"

{
  "Alias": {
    <alias functions...>
  },
  <more groups...>
}

किसी विशिष्ट फ़ंक्शन की परिभाषा प्राप्त करने के लिए:

$ curl -s "http://graphite/functions/absolute?pretty=1"

{
  "description": "<function description>",
  "function": "absolute(seriesList)",
  "group": "Transform",
  "module": "graphite.render.functions",
  "name": "absolute",
  "params": [
    {
      "name": "seriesList",
      "required": true,
      "type": "seriesList"
    }
  ]
}

Original text