कपॅसिटरमध्ये मेट्रिक्सवर प्रक्रिया करण्यासाठी युक्त्या

बहुधा, आज कोणीही विचारत नाही की सेवा मेट्रिक्स गोळा करणे का आवश्यक आहे. पुढील तार्किक पायरी म्हणजे गोळा केलेल्या मेट्रिक्ससाठी अलर्ट सेट करणे, जे तुमच्यासाठी (मेल, स्लॅक, टेलिग्राम) सोयीस्कर चॅनेलमधील डेटामधील कोणत्याही विचलनाबद्दल सूचित करेल. ऑनलाइन हॉटेल बुकिंग सेवेमध्ये Ostrovok.ru आमच्या सेवांचे सर्व मेट्रिक्स InfluxDB मध्ये ओतले जातात आणि Grafana मध्ये प्रदर्शित केले जातात आणि तेथे मूलभूत सूचना देखील कॉन्फिगर केल्या जातात. “तुम्हाला काहीतरी मोजणे आणि त्याच्याशी तुलना करणे आवश्यक आहे” यासारख्या कामांसाठी आम्ही कॅपेसिटर वापरतो.

कपॅसिटर हा TICK स्टॅकचा भाग आहे जो InfluxDB वरून मेट्रिक्सवर प्रक्रिया करू शकतो. हे अनेक मोजमाप एकत्र जोडू शकते (सामील होऊ शकते), प्राप्त डेटामधून काहीतरी उपयुक्त गणना करू शकते, परिणाम परत InfluxDB वर लिहू शकते, Slack/Telegram/mail वर अलर्ट पाठवू शकते.

संपूर्ण स्टॅक छान आणि तपशीलवार आहे दस्तऐवजीकरण, परंतु नेहमी उपयुक्त गोष्टी असतील ज्या मॅन्युअलमध्ये स्पष्टपणे दर्शविल्या जात नाहीत. या लेखात, मी अशा अनेक उपयुक्त, स्पष्ट नसलेल्या टिप्स गोळा करण्याचा निर्णय घेतला (TICKscipt चे मूळ वाक्यरचना वर्णन केले आहे. येथे) आणि आमच्या समस्यांपैकी एक सोडवण्याचे उदाहरण वापरून ते कसे लागू केले जाऊ शकतात ते दर्शवा.

चला जाऊया!

फ्लोट आणि इंट, गणना त्रुटी

जातींद्वारे सोडवलेली एक पूर्णपणे मानक समस्या:

var alert_float = 5.0
var alert_int = 10
data|eval(lambda: float("value") > alert_float OR float("value") < float("alert_int"))

डीफॉल्ट () वापरणे

टॅग/फील्ड भरले नसल्यास, गणना त्रुटी उद्भवतील:

|default()
        .tag('status', 'empty')
        .field('value', 0)

जॉईन भरा (आतील विरुद्ध बाह्य)

डीफॉल्टनुसार, जॉइन बिंदू टाकून देईल जेथे डेटा नाही (आतील).
fill('null') सह, एक बाह्य जोडणी केली जाईल, त्यानंतर तुम्हाला डीफॉल्ट() करावे लागेल आणि रिक्त मूल्ये भरा:

var data = res1
    |join(res2)
        .as('res1', 'res2)
        .fill('null')
    |default()
        .field('res1.value', 0.0)
        .field('res2.value', 100.0)

येथे अजूनही एक सूक्ष्मता आहे. वरील उदाहरणात, मालिकेपैकी एक (res1 किंवा res2) रिकामी असल्यास, परिणामी मालिका (डेटा) देखील रिक्त असेल. Github वर या विषयावर अनेक तिकिटे आहेत (1633, 1871, 6967) – आम्ही निराकरणाची वाट पाहत आहोत आणि थोडा त्रास सहन करत आहोत.

गणनामध्ये परिस्थिती वापरणे (लॅम्बडामध्ये असल्यास)

|eval(lambda: if("value" > 0, true, false)

कालावधीसाठी पाइपलाइनपासून शेवटची पाच मिनिटे

उदाहरणार्थ, तुम्हाला शेवटच्या पाच मिनिटांच्या मूल्यांची मागील आठवड्याशी तुलना करणे आवश्यक आहे. तुम्ही दोन स्वतंत्र बॅचमध्ये डेटाच्या दोन बॅच घेऊ शकता किंवा मोठ्या कालावधीतील डेटाचा काही भाग काढू शकता:

 |where(lambda: duration((unixNano(now()) - unixNano("time"))/1000, 1u) < 5m)

शेवटच्या पाच मिनिटांसाठी एक पर्याय म्हणजे बॅरियरनोड वापरणे, जे निर्दिष्ट वेळेपूर्वी डेटा कापून टाकते:

|barrier()
        .period(5m)

संदेशात गो टेम्पलेट्स वापरण्याची उदाहरणे

टेम्पलेट्स पॅकेजमधील स्वरूपाशी संबंधित आहेत text.templateखाली काही वारंवार समोर येणारी कोडी आहेत.

if-other

आम्ही गोष्टी व्यवस्थित ठेवतो आणि लोकांना पुन्हा एकदा मजकूर देऊन ट्रिगर करत नाही:

|alert()
    ...
    .message(
        '{{ if eq .Level "OK" }}It is ok now{{ else }}Chief, everything is broken{{end}}'
    )

संदेशातील दशांश बिंदूनंतरचे दोन अंक

संदेशाची वाचनीयता सुधारणे:

|alert()
    ...
    .message(
        'now value is {{ index .Fields "value" | printf "%0.2f" }}'
    )

संदेशामध्ये व्हेरिएबल्सचा विस्तार करणे

“तो का ओरडत आहे” या प्रश्नाचे उत्तर देण्यासाठी आम्ही संदेशामध्ये अधिक माहिती प्रदर्शित करतो?

var warnAlert = 10
  |alert()
    ...
    .message(
       'Today value less then '+string(warnAlert)+'%'
    )

युनिक अलर्ट आयडेंटिफायर

जेव्हा डेटामध्ये एकापेक्षा जास्त गट असतात तेव्हा ही एक आवश्यक गोष्ट असते, अन्यथा फक्त एक सूचना व्युत्पन्न केली जाईल:

|alert()
      ...
      .id('{{ index .Tags "myname" }}/{{ index .Tags "myfield" }}')

सानुकूल हँडलरचे

हँडलर्सच्या मोठ्या सूचीमध्ये exec समाविष्ट आहे, जे तुम्हाला तुमची स्क्रिप्ट पास केलेल्या पॅरामीटर्ससह कार्यान्वित करण्याची परवानगी देते (stdin) - सर्जनशीलता आणि आणखी काही नाही!

आमच्या रीतिरिवाजांपैकी एक म्हणजे स्लॅकला सूचना पाठवण्यासाठी एक लहान पायथन स्क्रिप्ट.
सुरुवातीला, आम्हाला संदेशात अधिकृतता-संरक्षित ग्राफना चित्र पाठवायचे होते. त्यानंतर, थ्रेडमध्ये समान गटातील मागील सूचनांवर ओके लिहा, आणि स्वतंत्र संदेश म्हणून नाही. थोड्या वेळाने - शेवटच्या X मिनिटांमधील सर्वात सामान्य चूक संदेशात जोडा.

एक वेगळा विषय म्हणजे इतर सेवांशी संप्रेषण आणि अलर्टद्वारे सुरू केलेल्या कोणत्याही कृती (केवळ तुमचे निरीक्षण पुरेसे कार्य करत असल्यास).
हँडलर वर्णनाचे उदाहरण, जिथे slack_handler.py ही आमची स्व-लिखित स्क्रिप्ट आहे:

topic: slack_graph
id: slack_graph.alert
match: level() != INFO AND changed() == TRUE
kind: exec
options:
  prog: /sbin/slack_handler.py
  args: ["-c", "CHANNELID", "--graph", "--search"]

डीबग कसे करायचे?

लॉग आउटपुटसह पर्याय

|log()
      .level("error")
      .prefix("something")

पहा (cli): kapacitor -url होस्ट-किंवा-आयपी:9092 लॉग lvl=त्रुटी

httpOut सह पर्याय

वर्तमान पाइपलाइनमधील डेटा दर्शवितो:

|httpOut('something')

पहा (मिळवा): होस्ट-किंवा-आयपी:9092/kapacitor/v1/tasks/task_name/something

अंमलबजावणी आकृती

• प्रत्येक टास्क फॉरमॅटमध्ये उपयुक्त क्रमांकांसह एक एक्झिक्यूशन ट्री मिळवते आलेख.
• एक ब्लॉक घ्या एकूण.
• दर्शकामध्ये पेस्ट करा, आनंद घ्या.

अजून कुठे रेक मिळेल?

राइटबॅकवर influxdb मध्ये टाइमस्टॅम्प

उदाहरणार्थ, आम्ही प्रति तास (groupBy(1h)) विनंत्यांच्या बेरीजसाठी एक अलर्ट सेट करतो आणि influxdb मध्ये आलेला इशारा रेकॉर्ड करू इच्छितो (ग्राफनामधील आलेखावर समस्येची वस्तुस्थिती सुंदरपणे दर्शवण्यासाठी).

influxDBOut() चेतावणीपासून टाइमस्टॅम्पवर वेळ मूल्य लिहेल; त्यानुसार, चार्टवरील बिंदू अलर्ट आल्याच्या आधी/नंतर लिहिला जाईल.

जेव्हा अचूकता आवश्यक असते: आम्ही कस्टम हँडलरला कॉल करून या समस्येवर काम करतो, जो वर्तमान टाइमस्टॅम्पसह influxdb वर डेटा लिहितो.

डॉकर, बिल्ड आणि डिप्लॉयमेंट

स्टार्टअपवर, कॅपेसिटर [लोड] ब्लॉकमधील कॉन्फिगरेशनमध्ये निर्दिष्ट केलेल्या निर्देशिकेतून कार्ये, टेम्पलेट्स आणि हँडलर लोड करू शकतो.

कार्य योग्यरित्या तयार करण्यासाठी, आपल्याला खालील गोष्टींची आवश्यकता आहे:

1. फाइल नाव - स्क्रिप्ट आयडी/नावामध्ये विस्तारित
2. प्रकार - प्रवाह/बॅच
3. dbrp – स्क्रिप्ट कोणत्या डेटाबेस + पॉलिसीमध्ये चालते हे सूचित करण्यासाठी कीवर्ड (dbrp “पुरवठादार.” “ऑटोजेन”)

जर काही बॅच टास्कमध्ये dbrp सह ओळ नसेल, तर संपूर्ण सेवा सुरू होण्यास नकार देईल आणि लॉगमध्ये त्याबद्दल प्रामाणिकपणे लिहेल.

क्रोनोग्राफमध्ये, याउलट, ही ओळ अस्तित्वात नसावी; ती इंटरफेसद्वारे स्वीकारली जात नाही आणि त्रुटी निर्माण करते.

कंटेनर तयार करताना हॅक: डॉकरफाइल //.+dbrp सह ओळी असल्यास -1 सह बाहेर पडते, ज्यामुळे बिल्ड असेंबल करताना बिघाडाचे कारण त्वरित समजू शकेल.

एक ते अनेक सामील व्हा

उदाहरण कार्य: तुम्हाला एका आठवड्यासाठी सेवेच्या ऑपरेटिंग वेळेचा 95 वा पर्सेंटाइल घेणे आवश्यक आहे, शेवटच्या 10 च्या प्रत्येक मिनिटाची या मूल्याशी तुलना करा.

तुम्ही एक-ते-अनेक सामील होऊ शकत नाही, पॉइंट्सच्या गटावर शेवटचे/मध्य/मध्यम नोडला प्रवाहात बदलते, त्रुटी "चाइल्ड न जुळलेल्या कडा जोडू शकत नाही: बॅच -> प्रवाह" परत केली जाईल.

बॅचचा परिणाम, लॅम्बडा अभिव्यक्तीमध्ये व्हेरिएबल म्हणून, देखील बदलला जात नाही.

पहिल्या बॅचमधील आवश्यक संख्या udf द्वारे फाइलमध्ये सेव्ह करण्याचा आणि ही फाइल साइडलोडद्वारे लोड करण्याचा पर्याय आहे.

हे आम्ही काय सोडवले?

आमच्याकडे सुमारे 100 हॉटेल पुरवठादार आहेत, त्यांच्यापैकी प्रत्येकाचे अनेक कनेक्शन असू शकतात, चला याला चॅनेल म्हणूया. यापैकी अंदाजे 300 चॅनेल आहेत, प्रत्येक चॅनेल बंद पडू शकतात. सर्व रेकॉर्ड केलेल्या मेट्रिक्सपैकी, आम्ही त्रुटी दर (विनंत्या आणि त्रुटी) चे निरीक्षण करू.

ग्राफना का नाही?

Grafana मध्ये कॉन्फिगर केलेल्या त्रुटी सूचनांचे अनेक तोटे आहेत. काही गंभीर आहेत, काही परिस्थितीनुसार तुम्ही डोळे बंद करू शकता.

ग्राफानाला मोजमाप + अलर्टिंग दरम्यान गणना कशी करायची हे माहित नाही, परंतु आम्हाला दर (विनंत्या-त्रुटी)/विनंती आवश्यक आहेत.

त्रुटी वाईट दिसतात:

आणि यशस्वी विनंत्यांसह पाहिल्यास कमी वाईट:

ठीक आहे, आम्ही ग्राफनापूर्वी सेवेतील दराची पूर्व-गणना करू शकतो आणि काही प्रकरणांमध्ये हे कार्य करेल. पण आपल्यात नाही, कारण... प्रत्येक चॅनेलसाठी त्याचे स्वतःचे गुणोत्तर "सामान्य" मानले जाते आणि अॅलर्ट स्थिर मूल्यांनुसार कार्य करतात (आम्ही ते आमच्या डोळ्यांनी शोधतो, वारंवार अलर्ट असल्यास ते बदलू).

ही भिन्न चॅनेलसाठी "सामान्य" ची उदाहरणे आहेत:

आम्ही मागील मुद्द्याकडे दुर्लक्ष करतो आणि असे गृहीत धरतो की सर्व पुरवठादारांसाठी "सामान्य" चित्र समान आहे. आता सर्व काही ठीक आहे, आणि आम्ही ग्राफनामध्ये अलर्टसह मिळवू शकतो?
आम्ही करू शकतो, परंतु आम्हाला खरोखर करायचे नाही, कारण आम्हाला पर्यायांपैकी एक निवडावा लागेल:
अ) प्रत्येक चॅनेलसाठी स्वतंत्रपणे बरेच आलेख बनवा (आणि वेदनादायकपणे त्यांच्यासोबत)
b) सर्व चॅनेलसह एक चार्ट सोडा (आणि रंगीबेरंगी ओळी आणि सानुकूलित सूचनांमध्ये हरवून जा)

आपण ते कसे केले?

पुन्हा, दस्तऐवजीकरणात एक चांगले प्रारंभिक उदाहरण आहे (सामील झालेल्या मालिकेतील दरांची गणना करत आहे), तत्सम समस्यांमध्ये डोकावून किंवा आधार म्हणून घेतले जाऊ शकते.

आम्ही शेवटी काय केले:

• काही तासांत दोन मालिका सामील व्हा, चॅनेलद्वारे गटबद्ध करा;
• डेटा नसल्यास गटानुसार मालिका भरा;
• मागील डेटासह शेवटच्या 10 मिनिटांच्या मध्याची तुलना करा;
• आम्हाला काही सापडले तर आम्ही ओरडतो;
• आम्ही influxdb मध्ये आलेले गणना केलेले दर आणि सूचना लिहितो;
• स्लॅकला उपयुक्त संदेश पाठवा.

माझ्या मते, आम्हाला जे काही मिळवायचे होते ते सर्व (आणि सानुकूल हँडलर्ससह थोडे अधिक) शक्य तितक्या सुंदरपणे आम्ही साध्य केले.

तुम्ही github.com वर पाहू शकता कोड उदाहरण и किमान सर्किट (ग्राफविझ) परिणामी स्क्रिप्ट.

परिणामी कोडचे उदाहरण:

dbrp "supplier"."autogen"
var name = 'requests.rate'
var grafana_dash = 'pczpmYZWU/mydashboard'
var grafana_panel = '26'
var period = 8h
var todayPeriod = 10m
var every = 1m
var warnAlert = 15
var warnReset = 5
var reqQuery = 'SELECT sum("count") AS value FROM "supplier"."autogen"."requests"'
var errQuery = 'SELECT sum("count") AS value FROM "supplier"."autogen"."errors"'

var prevErr = batch
    |query(errQuery)
        .period(period)
        .every(every)
        .groupBy(1m, 'channel', 'supplier')

var prevReq = batch
    |query(reqQuery)
        .period(period)
        .every(every)
        .groupBy(1m, 'channel', 'supplier')

var rates = prevReq
    |join(prevErr)
        .as('req', 'err')
        .tolerance(1m)
        .fill('null')
    // заполняем значения нулями, если их не было
    |default()
        .field('err.value', 0.0)
        .field('req.value', 0.0)
    // if в lambda: считаем рейт, только если ошибки были
    |eval(lambda: if("err.value" > 0, 100.0 * (float("req.value") - float("err.value")) / float("req.value"), 100.0))
        .as('rate')

// записываем посчитанные значения в инфлюкс
rates
    |influxDBOut()
        .quiet()
        .create()
        .database('kapacitor')
        .retentionPolicy('autogen')
        .measurement('rates')

// выбираем данные за последние 10 минут, считаем медиану
var todayRate = rates
    |where(lambda: duration((unixNano(now()) - unixNano("time")) / 1000, 1u) < todayPeriod)
    |median('rate')
        .as('median')

var prevRate = rates
    |median('rate')
        .as('median')

var joined = todayRate
    |join(prevRate)
        .as('today', 'prev')
    |httpOut('join')

var trigger = joined
    |alert()
        .warn(lambda: ("prev.median" - "today.median") > warnAlert)
        .warnReset(lambda: ("prev.median" - "today.median") < warnReset)
        .flapping(0.25, 0.5)
        .stateChangesOnly()
        // собираем в message ссылку на график дашборда графаны
        .message(
            '{{ .Level }}: {{ index .Tags "channel" }} err/req ratio ({{ index .Tags "supplier" }})
{{ if eq .Level "OK" }}It is ok now{{ else }}
'+string(todayPeriod)+' median is {{ index .Fields "today.median" | printf "%0.2f" }}%, by previous '+string(period)+' is {{ index .Fields "prev.median" | printf "%0.2f" }}%{{ end }}
http://grafana.ostrovok.in/d/'+string(grafana_dash)+
'?var-supplier={{ index .Tags "supplier" }}&var-channel={{ index .Tags "channel" }}&panelId='+string(grafana_panel)+'&fullscreen&tz=UTC%2B03%3A00'
        )
        .id('{{ index .Tags "name" }}/{{ index .Tags "channel" }}')
        .levelTag('level')
        .messageField('message')
        .durationField('duration')
        .topic('slack_graph')

// "today.median" дублируем как "value", также пишем в инфлюкс остальные филды алерта (keep)
trigger
    |eval(lambda: "today.median")
        .as('value')
        .keep()
    |influxDBOut()
        .quiet()
        .create()
        .database('kapacitor')
        .retentionPolicy('autogen')
        .measurement('alerts')
        .tag('alertName', name)

निष्कर्ष काय आहे?

कॅपेसिटर अनेक गटांसह मॉनिटरिंग-अॅलर्ट्स करणे, आधीच रेकॉर्ड केलेल्या मेट्रिक्सवर आधारित अतिरिक्त गणना करणे, सानुकूल क्रिया करणे आणि स्क्रिप्ट्स (udf) चालवणे यासाठी उत्कृष्ट आहे.

प्रवेशाचा अडथळा फार जास्त नाही - जर ग्राफना किंवा इतर साधने तुमच्या इच्छा पूर्ण करत नाहीत तर ते वापरून पहा.

स्त्रोत: www.habr.com