કેપેસિટરમાં મેટ્રિક્સની પ્રક્રિયા કરવા માટેની યુક્તિઓ

મોટે ભાગે, આજે કોઈ પૂછતું નથી કે સેવા મેટ્રિક્સ એકત્રિત કરવા શા માટે જરૂરી છે. આગળનું તાર્કિક પગલું એ એકત્રિત મેટ્રિક્સ માટે ચેતવણી સેટ કરવાનું છે, જે તમારા માટે અનુકૂળ ચેનલો (મેલ, સ્લેક, ટેલિગ્રામ) માં ડેટામાં કોઈપણ વિચલનો વિશે સૂચિત કરશે. ઓનલાઈન હોટેલ બુકિંગ સેવામાં 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)

જોડાઓ ભરો (આંતરિક વિ બાહ્ય)

ડિફૉલ્ટ રૂપે, જોડાવું તે બિંદુઓને કાઢી નાખશે જ્યાં કોઈ ડેટા (આંતરિક) નથી.
ફિલ('નલ') સાથે, બાહ્ય જોડાણ કરવામાં આવશે, જેના પછી તમારે ડિફોલ્ટ() કરવાની જરૂર છે અને ખાલી કિંમતો ભરવાની જરૂર છે:

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

અહીં હજુ પણ એક સૂક્ષ્મતા છે. ઉપરના ઉદાહરણમાં, જો શ્રેણીમાંથી એક (res1 અથવા res2) ખાલી છે, તો પરિણામી શ્રેણી (ડેટા) પણ ખાલી હશે. ગીથબ પર આ વિષય પર ઘણી ટિકિટો છે (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નીચે કેટલીક વારંવાર આવતી કોયડાઓ છે.

જો બીજુ

અમે વસ્તુઓને વ્યવસ્થિત રાખીએ છીએ અને લોકોને ફરી એકવાર ટેક્સ્ટ સાથે ટ્રિગર કરતા નથી:

|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) સાથે તમારી સ્ક્રિપ્ટ ચલાવવાની મંજૂરી આપે છે - સર્જનાત્મકતા અને વધુ કંઈ નહીં!

અમારા રિવાજોમાંથી એક સ્લેક પર સૂચનાઓ મોકલવા માટે એક નાની પાયથોન સ્ક્રિપ્ટ છે.
શરૂઆતમાં, અમે સંદેશમાં અધિકૃતતા-સંરક્ષિત ગ્રાફના ચિત્ર મોકલવા માગતા હતા. પછીથી, સમાન જૂથમાંથી અગાઉની ચેતવણી પર થ્રેડમાં OK લખો, અલગ સંદેશ તરીકે નહીં. થોડી વાર પછી - છેલ્લા 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=error

httpOut સાથે વિકલ્પ

વર્તમાન પાઇપલાઇનમાં ડેટા બતાવે છે:

|httpOut('something')

જુઓ (મેળવો): હોસ્ટ-અથવા-આઈપી:9092/kapacitor/v1/tasks/task_name/something

અમલ યોજના

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

તમે રેક ક્યાંથી મેળવી શકો છો?

રાઇટબેક પર influxdb માં ટાઇમસ્ટેમ્પ

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

influxDBOut() ચેતવણીથી ટાઈમસ્ટેમ્પ પર સમય મૂલ્ય લખશે; તે મુજબ, ચાર્ટ પરનો મુદ્દો ચેતવણી આવ્યા કરતાં વહેલો/પછીથી લખવામાં આવશે.

જ્યારે ચોકસાઈની આવશ્યકતા હોય ત્યારે: અમે કસ્ટમ હેન્ડલરને કૉલ કરીને આ સમસ્યાનું સમાધાન કરીએ છીએ, જે વર્તમાન ટાઈમસ્ટેમ્પ સાથે influxdb પર ડેટા લખશે.

ડોકર, બિલ્ડ અને જમાવટ

સ્ટાર્ટઅપ વખતે, કેપેસિટર [લોડ] બ્લોકમાં રૂપરેખામાં ઉલ્લેખિત ડિરેક્ટરીમાંથી કાર્યો, નમૂનાઓ અને હેન્ડલર્સ લોડ કરી શકે છે.

કાર્યને યોગ્ય રીતે બનાવવા માટે, તમારે નીચેની વસ્તુઓની જરૂર છે:

1. ફાઇલનું નામ - સ્ક્રિપ્ટ આઈડી/નામમાં વિસ્તૃત
2. પ્રકાર - સ્ટ્રીમ/બેચ
3. dbrp – સ્ક્રિપ્ટ કયા ડેટાબેઝ + પોલિસીમાં ચાલે છે તે દર્શાવવા માટેનો કીવર્ડ (dbrp “સપ્લાયર.” “ઓટોજન”)

જો કેટલાક બેચ કાર્યમાં dbrp સાથેની લાઇન શામેલ નથી, તો સમગ્ર સેવા શરૂ થવાનો ઇનકાર કરશે અને લોગમાં પ્રમાણિકપણે તેના વિશે લખશે.

ક્રોનોગ્રાફમાં, તેનાથી વિપરીત, આ રેખા અસ્તિત્વમાં હોવી જોઈએ નહીં; તે ઇન્ટરફેસ દ્વારા સ્વીકારવામાં આવતી નથી અને ભૂલ પેદા કરે છે.

કન્ટેનર બનાવતી વખતે હેક કરો: ડોકરફાઈલ -1 સાથે બહાર નીકળે છે જો ત્યાં //.+dbrp સાથે રેખાઓ હોય, જે તમને બિલ્ડ એસેમ્બલ કરતી વખતે નિષ્ફળતાનું કારણ તરત જ સમજવાની મંજૂરી આપશે.

એકથી ઘણામાં જોડાઓ

ઉદાહરણ કાર્ય: તમારે એક અઠવાડિયા માટે સેવાના કાર્યકારી સમયની 95મી ટકાવારી લેવાની જરૂર છે, આ મૂલ્ય સાથે છેલ્લા 10 ની દરેક મિનિટની તુલના કરો.

તમે એક-થી-ઘણા જોડાઈ શકતા નથી, પોઈન્ટ્સના જૂથ પર છેલ્લું/મધ્યમ/મધ્યમ નોડને સ્ટ્રીમમાં ફેરવે છે, ભૂલ "ચાઈલ્ડ મેળ ન ખાતી કિનારીઓ ઉમેરી શકાતી નથી: બેચ -> સ્ટ્રીમ" પરત કરવામાં આવશે.

બેચનું પરિણામ, લેમ્બડા અભિવ્યક્તિમાં ચલ તરીકે, પણ અવેજી કરવામાં આવતું નથી.

પ્રથમ બેચમાંથી જરૂરી નંબરોને udf દ્વારા ફાઇલમાં સેવ કરવાનો અને આ ફાઇલને સાઇડલોડ દ્વારા લોડ કરવાનો વિકલ્પ છે.

અમે આ સાથે શું ઉકેલ્યું?

અમારી પાસે લગભગ 100 હોટેલ સપ્લાયર્સ છે, તેમાંથી દરેક પાસે અનેક જોડાણો હોઈ શકે છે, ચાલો તેને ચેનલ કહીએ. આમાંની લગભગ 300 ચેનલો છે, દરેક ચેનલો પડી શકે છે. તમામ રેકોર્ડ કરેલ મેટ્રિક્સમાંથી, અમે ભૂલ દર (વિનંતિઓ અને ભૂલો) પર નજર રાખીશું.

શા માટે ગ્રાફના નથી?

ગ્રાફનામાં રૂપરેખાંકિત ભૂલ ચેતવણીઓમાં ઘણા ગેરફાયદા છે. કેટલીક જટિલ છે, કેટલીક તમે પરિસ્થિતિના આધારે તમારી આંખો બંધ કરી શકો છો.

ગ્રાફનાને માપ + ચેતવણી વચ્ચે કેવી રીતે ગણતરી કરવી તે ખબર નથી, પરંતુ અમને દર (વિનંતી-ભૂલો)/વિનંતીઓની જરૂર છે.

ભૂલો ખરાબ લાગે છે:

અને જ્યારે સફળ વિનંતીઓ સાથે જોવામાં આવે ત્યારે ઓછું દુષ્ટ:

ઠીક છે, અમે ગ્રાફના પહેલાં સેવામાં દરની પૂર્વ-ગણતરી કરી શકીએ છીએ, અને કેટલાક કિસ્સાઓમાં આ કામ કરશે. પણ આપણામાં નથી, કારણ કે... દરેક ચેનલ માટે તેનો પોતાનો ગુણોત્તર "સામાન્ય" માનવામાં આવે છે, અને ચેતવણીઓ સ્થિર મૂલ્યો અનુસાર કાર્ય કરે છે (અમે તેમને અમારી આંખોથી શોધીએ છીએ, જો વારંવાર ચેતવણીઓ હોય તો તેમને બદલીએ છીએ).

આ વિવિધ ચેનલો માટે "સામાન્ય" ના ઉદાહરણો છે:

અમે પાછલા મુદ્દાને અવગણીએ છીએ અને ધારીએ છીએ કે "સામાન્ય" ચિત્ર બધા સપ્લાયર્સ માટે સમાન છે. હવે બધું સારું છે, અને આપણે ગ્રાફનામાં ચેતવણીઓ સાથે મેળવી શકીએ?
અમે કરી શકીએ છીએ, પરંતુ અમે ખરેખર ઇચ્છતા નથી, કારણ કે આપણે વિકલ્પોમાંથી એક પસંદ કરવાનો છે:
a) દરેક ચેનલ માટે અલગથી ઘણા બધા ગ્રાફ બનાવો (અને પીડાદાયક રીતે તેમની સાથે)
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)

શું છે તારણ?

કેપેસિટર જૂથોના સમૂહ સાથે મોનિટરિંગ-અલર્ટ કરવા, પહેલેથી જ રેકોર્ડ કરેલ મેટ્રિક્સના આધારે વધારાની ગણતરીઓ કરવા, કસ્ટમ ક્રિયાઓ કરવા અને સ્ક્રિપ્ટ્સ (યુડીએફ) ચલાવવામાં ઉત્તમ છે.

પ્રવેશ માટેનો અવરોધ ખૂબ વધારે નથી - જો ગ્રાફના અથવા અન્ય સાધનો તમારી ઇચ્છાઓને પૂર્ણપણે સંતોષતા નથી, તો તેનો પ્રયાસ કરો.

સોર્સ: www.habr.com