കപ്പാസിറ്ററിൽ മെട്രിക്‌സ് പ്രോസസ്സ് ചെയ്യുന്നതിനുള്ള തന്ത്രങ്ങൾ

മിക്കവാറും, സേവന അളവുകൾ ശേഖരിക്കേണ്ടത് എന്തുകൊണ്ടാണെന്ന് ഇന്ന് ആരും ചോദിക്കുന്നില്ല. അടുത്ത ലോജിക്കൽ ഘട്ടം, ശേഖരിച്ച അളവുകൾക്കായി ഒരു അലേർട്ട് സജ്ജീകരിക്കുക എന്നതാണ്, അത് നിങ്ങൾക്ക് സൗകര്യപ്രദമായ ചാനലുകളിലെ (മെയിൽ, സ്ലാക്ക്, ടെലിഗ്രാം) ഡാറ്റയിലെ ഏതെങ്കിലും വ്യതിയാനങ്ങളെക്കുറിച്ച് അറിയിക്കും. ഓൺലൈൻ ഹോട്ടൽ ബുക്കിംഗ് സേവനത്തിൽ Ostrovok.ru ഞങ്ങളുടെ സേവനങ്ങളുടെ എല്ലാ അളവുകളും InfluxDB-യിലേക്ക് പകരുകയും ഗ്രാഫാനയിൽ പ്രദർശിപ്പിക്കുകയും ചെയ്യുന്നു, കൂടാതെ അടിസ്ഥാന അലേർട്ടിംഗും അവിടെ ക്രമീകരിച്ചിരിക്കുന്നു. "നിങ്ങൾ എന്തെങ്കിലും കണക്കാക്കുകയും അതുമായി താരതമ്യം ചെയ്യുകയും വേണം" എന്നതുപോലുള്ള ജോലികൾക്കായി ഞങ്ങൾ കപ്പാസിറ്റർ ഉപയോഗിക്കുന്നു.

InfluxDB-ൽ നിന്നുള്ള മെട്രിക്‌സ് പ്രോസസ്സ് ചെയ്യാൻ കഴിയുന്ന TICK സ്റ്റാക്കിൻ്റെ ഭാഗമാണ് Kapacitor. ഇതിന് നിരവധി അളവുകൾ ഒരുമിച്ച് ബന്ധിപ്പിക്കാൻ കഴിയും (ചേരുക), ലഭിച്ച ഡാറ്റയിൽ നിന്ന് ഉപയോഗപ്രദമായ എന്തെങ്കിലും കണക്കാക്കുക, ഫലം InfluxDB-യിലേക്ക് തിരികെ എഴുതുക, സ്ലാക്ക്/ടെലിഗ്രാം/മെയിലിലേക്ക് ഒരു അലേർട്ട് അയയ്ക്കുക.

മുഴുവൻ സ്റ്റാക്കും തണുത്തതും വിശദവുമാണ് പ്രമാണീകരണം, എന്നാൽ മാനുവലുകളിൽ വ്യക്തമായി സൂചിപ്പിക്കാത്ത ഉപയോഗപ്രദമായ കാര്യങ്ങൾ എപ്പോഴും ഉണ്ടാകും. ഈ ലേഖനത്തിൽ, അത്തരം ഉപയോഗപ്രദവും വ്യക്തമല്ലാത്തതുമായ നിരവധി നുറുങ്ങുകൾ ശേഖരിക്കാൻ ഞാൻ തീരുമാനിച്ചു (TICKscipt-ൻ്റെ അടിസ്ഥാന വാക്യഘടന വിവരിച്ചിരിക്കുന്നു ഇവിടെ) കൂടാതെ ഞങ്ങളുടെ പ്രശ്‌നങ്ങളിലൊന്ന് പരിഹരിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം ഉപയോഗിച്ച് അവ എങ്ങനെ പ്രയോഗിക്കാമെന്ന് കാണിക്കുക.

പോകാം!

float & int, കണക്കുകൂട്ടൽ പിശകുകൾ

തികച്ചും സ്റ്റാൻഡേർഡ് പ്രശ്നം, ജാതികളിലൂടെ പരിഹരിക്കുന്നു:

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)

ജോയിൻ പൂരിപ്പിക്കുക (അകത്തെ vs പുറം)

സ്ഥിരസ്ഥിതിയായി, ചേരുന്നത് ഡാറ്റ ഇല്ലാത്ത പോയിൻ്റുകൾ (അകത്തെ) നിരാകരിക്കും.
പൂരിപ്പിക്കൽ ('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)

സന്ദേശത്തിൽ Go ടെംപ്ലേറ്റുകൾ ഉപയോഗിക്കുന്നതിൻ്റെ ഉദാഹരണങ്ങൾ

ടെംപ്ലേറ്റുകൾ പാക്കേജിൽ നിന്നുള്ള ഫോർമാറ്റുമായി പൊരുത്തപ്പെടുന്നു 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" }}')

കസ്റ്റം ഹാൻഡ്‌ലറുടെ

ഹാൻഡ്‌ലറുകളുടെ വലിയ ലിസ്റ്റിൽ എക്‌സിക് ഉൾപ്പെടുന്നു, അത് പാസ്സായ പാരാമീറ്ററുകൾ (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=error

httpOut ഉള്ള ഓപ്ഷൻ

നിലവിലെ പൈപ്പ്ലൈനിലെ ഡാറ്റ കാണിക്കുന്നു:

|httpOut('something')

കാണുക (നേടുക): ഹോസ്റ്റ്-ഓർ-ഐപി:9092/kapacitor/v1/tasks/task_name/എന്തെങ്കിലും

എക്സിക്യൂഷൻ ഡയഗ്രം

• ഓരോ ജോലിയും ഫോർമാറ്റിൽ ഉപയോഗപ്രദമായ നമ്പറുകളുള്ള ഒരു എക്സിക്യൂഷൻ ട്രീ നൽകുന്നു ഗ്രാഫ്‌വിസ്.
• ഒരു ബ്ലോക്ക് എടുക്കുക ഡോട്ട്.
• വ്യൂവറിൽ ഒട്ടിക്കുക, ആസ്വദിക്കൂ.

നിങ്ങൾക്ക് മറ്റെവിടെ നിന്ന് ഒരു റേക്ക് ലഭിക്കും?

റൈറ്റ്ബാക്കിൽ influxdb-ൽ ടൈംസ്റ്റാമ്പ്

ഉദാഹരണത്തിന്, ഞങ്ങൾ ഒരു മണിക്കൂറിലെ അഭ്യർത്ഥനകളുടെ ആകെത്തുക (groupBy(1h)) ഒരു അലേർട്ട് സജ്ജീകരിക്കുകയും influxdb-യിൽ സംഭവിച്ച അലേർട്ട് റെക്കോർഡ് ചെയ്യാൻ ആഗ്രഹിക്കുകയും ചെയ്യുന്നു (ഗ്രാഫാനയിലെ ഗ്രാഫിൽ പ്രശ്നത്തിൻ്റെ വസ്തുത മനോഹരമായി കാണിക്കാൻ).

influxDBOut() അലേർട്ടിൽ നിന്ന് ടൈംസ്റ്റാമ്പിലേക്ക് സമയ മൂല്യം എഴുതും, ചാർട്ടിലെ പോയിൻ്റ് അലേർട്ട് വന്നതിനേക്കാൾ മുമ്പ് / പിന്നീട് എഴുതപ്പെടും.

കൃത്യത ആവശ്യമുള്ളപ്പോൾ: ഒരു ഇഷ്‌ടാനുസൃത ഹാൻഡ്‌ലറെ വിളിച്ച് ഞങ്ങൾ ഈ പ്രശ്‌നം പരിഹരിക്കുന്നു, അത് നിലവിലെ ടൈംസ്റ്റാമ്പ് ഉപയോഗിച്ച് influxdb-യിലേക്ക് ഡാറ്റ എഴുതും.

ഡോക്കർ, നിർമ്മാണം, വിന്യാസം

ആരംഭത്തിൽ, [ലോഡ്] ബ്ലോക്കിലെ കോൺഫിഗറിൽ വ്യക്തമാക്കിയ ഡയറക്ടറിയിൽ നിന്ന് കപാസിറ്ററിന് ടാസ്‌ക്കുകളും ടെംപ്ലേറ്റുകളും ഹാൻഡ്‌ലറുകളും ലോഡ് ചെയ്യാൻ കഴിയും.

ഒരു ടാസ്ക് ശരിയായി സൃഷ്ടിക്കുന്നതിന്, നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന കാര്യങ്ങൾ ആവശ്യമാണ്:

1. ഫയലിൻ്റെ പേര് - സ്ക്രിപ്റ്റ് ഐഡി/പേരിലേക്ക് വികസിപ്പിച്ചു
2. തരം - സ്ട്രീം/ബാച്ച്
3. dbrp - ഏത് ഡാറ്റാബേസ് + പോളിസിയിലാണ് സ്ക്രിപ്റ്റ് പ്രവർത്തിക്കുന്നതെന്ന് സൂചിപ്പിക്കാനുള്ള കീവേഡ് (dbrp "വിതരണക്കാരൻ." "ഓട്ടോജെൻ")

ചില ബാച്ച് ടാസ്‌ക്കുകളിൽ dbrp ഉള്ള ഒരു ലൈൻ ഇല്ലെങ്കിൽ, മുഴുവൻ സേവനവും ആരംഭിക്കാൻ വിസമ്മതിക്കുകയും സത്യസന്ധമായി ലോഗിൽ അതിനെക്കുറിച്ച് എഴുതുകയും ചെയ്യും.

ക്രോണോഗ്രാഫിൽ, നേരെമറിച്ച്, ഈ ലൈൻ നിലവിലില്ല, ഇത് ഇൻ്റർഫേസിലൂടെ അംഗീകരിക്കപ്പെടുകയും ഒരു പിശക് സൃഷ്ടിക്കുകയും ചെയ്യുന്നു.

ഒരു കണ്ടെയ്‌നർ നിർമ്മിക്കുമ്പോൾ ഹാക്ക് ചെയ്യുക: //.+dbrp ഉള്ള ലൈനുകൾ ഉണ്ടെങ്കിൽ -1 ഉപയോഗിച്ച് ഡോക്കർഫിൽ പുറത്തുകടക്കുന്നു, ഇത് ബിൽഡ് അസംബിൾ ചെയ്യുമ്പോൾ പരാജയത്തിൻ്റെ കാരണം പെട്ടെന്ന് മനസ്സിലാക്കാൻ നിങ്ങളെ അനുവദിക്കും.

ഒന്നിൽ പലതും ചേരുക

ഉദാഹരണ ടാസ്‌ക്: സേവനത്തിൻ്റെ പ്രവർത്തന സമയത്തിൻ്റെ 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)

എന്താണ് നിഗമനം?

ഒരു കൂട്ടം ഗ്രൂപ്പിംഗുകൾ ഉപയോഗിച്ച് മോണിറ്ററിംഗ്-അലേർട്ടുകൾ നടത്തുന്നതിനും ഇതിനകം റെക്കോർഡുചെയ്‌ത മെട്രിക്‌സിനെ അടിസ്ഥാനമാക്കി അധിക കണക്കുകൂട്ടലുകൾ നടത്തുന്നതിനും ഇഷ്‌ടാനുസൃത പ്രവർത്തനങ്ങൾ നടത്തുന്നതിനും സ്‌ക്രിപ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുന്നതിനും (udf) Kapacitor മികച്ചതാണ്.

പ്രവേശനത്തിനുള്ള തടസ്സം വളരെ ഉയർന്നതല്ല - ഗ്രാഫാനയോ മറ്റ് ഉപകരണങ്ങളോ നിങ്ങളുടെ ആഗ്രഹങ്ങളെ പൂർണ്ണമായി തൃപ്തിപ്പെടുത്തുന്നില്ലെങ്കിൽ ഇത് പരീക്ഷിക്കുക.

അവലംബം: www.habr.com