Kapacitor ਵਿੱਚ ਮੈਟ੍ਰਿਕਸ ਨੂੰ ਪ੍ਰੋਸੈਸ ਕਰਨ ਲਈ ਟ੍ਰਿਕਸ

ਜ਼ਿਆਦਾਤਰ ਸੰਭਾਵਨਾ ਹੈ, ਅੱਜ ਕੋਈ ਨਹੀਂ ਪੁੱਛਦਾ ਕਿ ਸੇਵਾ ਮੈਟ੍ਰਿਕਸ ਨੂੰ ਇਕੱਠਾ ਕਰਨਾ ਕਿਉਂ ਜ਼ਰੂਰੀ ਹੈ. ਅਗਲਾ ਲਾਜ਼ੀਕਲ ਕਦਮ ਹੈ ਇਕੱਠੀ ਕੀਤੀ ਗਈ ਮੈਟ੍ਰਿਕਸ ਲਈ ਇੱਕ ਚੇਤਾਵਨੀ ਸੈਟ ਅਪ ਕਰਨਾ, ਜੋ ਤੁਹਾਡੇ ਲਈ ਸੁਵਿਧਾਜਨਕ ਚੈਨਲਾਂ (ਮੇਲ, ਸਲੈਕ, ਟੈਲੀਗ੍ਰਾਮ) ਵਿੱਚ ਡੇਟਾ ਵਿੱਚ ਕਿਸੇ ਵੀ ਵਿਵਹਾਰ ਬਾਰੇ ਸੂਚਿਤ ਕਰੇਗਾ। ਔਨਲਾਈਨ ਹੋਟਲ ਬੁਕਿੰਗ ਸੇਵਾ ਵਿੱਚ Ostrovok.ru ਸਾਡੀਆਂ ਸੇਵਾਵਾਂ ਦੇ ਸਾਰੇ ਮੈਟ੍ਰਿਕਸ InfluxDB ਵਿੱਚ ਪਾ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ ਅਤੇ Grafana ਵਿੱਚ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਅਤੇ ਬੁਨਿਆਦੀ ਚੇਤਾਵਨੀ ਵੀ ਉੱਥੇ ਕੌਂਫਿਗਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। "ਤੁਹਾਨੂੰ ਕਿਸੇ ਚੀਜ਼ ਦੀ ਗਣਨਾ ਕਰਨ ਅਤੇ ਇਸ ਨਾਲ ਤੁਲਨਾ ਕਰਨ ਦੀ ਲੋੜ ਹੈ" ਵਰਗੇ ਕਾਰਜਾਂ ਲਈ, ਅਸੀਂ ਕਾਪੈਸੀਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ।

Kapacitor 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) ਖਾਲੀ ਹੈ, ਤਾਂ ਨਤੀਜੇ ਵਜੋਂ ਲੜੀ (ਡੇਟਾ) ਵੀ ਖਾਲੀ ਹੋਵੇਗੀ। 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ਹੇਠਾਂ ਕੁਝ ਅਕਸਰ ਆਈਆਂ ਪਹੇਲੀਆਂ ਹਨ।

ਜੇ-ਹੋਰ

ਅਸੀਂ ਚੀਜ਼ਾਂ ਨੂੰ ਕ੍ਰਮਬੱਧ ਕਰਦੇ ਹਾਂ ਅਤੇ ਲੋਕਾਂ ਨੂੰ ਇੱਕ ਵਾਰ ਦੁਬਾਰਾ ਟੈਕਸਟ ਨਾਲ ਟਰਿੱਗਰ ਨਹੀਂ ਕਰਦੇ ਹਾਂ:

|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 ਨੂੰ ਡੇਟਾ ਲਿਖ ਦੇਵੇਗਾ।

ਡੌਕਰ, ਬਿਲਡ ਅਤੇ ਡਿਪਲਾਇਮੈਂਟ

ਸ਼ੁਰੂਆਤੀ ਸਮੇਂ, kapacitor [load] ਬਲਾਕ ਵਿੱਚ ਸੰਰਚਨਾ ਵਿੱਚ ਨਿਰਧਾਰਿਤ ਡਾਇਰੈਕਟਰੀ ਤੋਂ ਟਾਸਕ, ਟੈਂਪਲੇਟ ਅਤੇ ਹੈਂਡਲਰ ਲੋਡ ਕਰ ਸਕਦਾ ਹੈ।

ਇੱਕ ਕੰਮ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਬਣਾਉਣ ਲਈ, ਤੁਹਾਨੂੰ ਹੇਠ ਲਿਖੀਆਂ ਚੀਜ਼ਾਂ ਦੀ ਲੋੜ ਹੈ:

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)

ਸਿੱਟਾ ਕੀ ਹੈ?

Kapacitor ਸਮੂਹਾਂ ਦੇ ਇੱਕ ਸਮੂਹ ਦੇ ਨਾਲ ਨਿਗਰਾਨੀ-ਸੁਚੇਤਨਾ ਕਰਨ, ਪਹਿਲਾਂ ਤੋਂ ਰਿਕਾਰਡ ਕੀਤੇ ਮੈਟ੍ਰਿਕਸ ਦੇ ਅਧਾਰ ਤੇ ਵਾਧੂ ਗਣਨਾ ਕਰਨ, ਕਸਟਮ ਐਕਸ਼ਨ ਕਰਨ ਅਤੇ ਸਕ੍ਰਿਪਟਾਂ (udf) ਚਲਾਉਣ ਵਿੱਚ ਬਹੁਤ ਵਧੀਆ ਹੈ।

ਦਾਖਲੇ ਲਈ ਰੁਕਾਵਟ ਬਹੁਤ ਜ਼ਿਆਦਾ ਨਹੀਂ ਹੈ - ਇਸਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ ਜੇਕਰ ਗ੍ਰਾਫਾਨਾ ਜਾਂ ਹੋਰ ਸਾਧਨ ਤੁਹਾਡੀਆਂ ਇੱਛਾਵਾਂ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਪੂਰਾ ਨਹੀਂ ਕਰਦੇ ਹਨ.

ਸਰੋਤ: www.habr.com