ಕೆಪಾಸಿಟರ್‌ನಲ್ಲಿ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ತಂತ್ರಗಳು

ಹೆಚ್ಚಾಗಿ, ಸೇವಾ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸುವುದು ಏಕೆ ಅಗತ್ಯ ಎಂದು ಇಂದು ಯಾರೂ ಕೇಳುವುದಿಲ್ಲ. ಸಂಗ್ರಹಿಸಿದ ಮೆಟ್ರಿಕ್‌ಗಳಿಗೆ ಎಚ್ಚರಿಕೆಯನ್ನು ಹೊಂದಿಸುವುದು ಮುಂದಿನ ತಾರ್ಕಿಕ ಹಂತವಾಗಿದೆ, ಇದು ನಿಮಗೆ ಅನುಕೂಲಕರವಾದ ಚಾನಲ್‌ಗಳಲ್ಲಿನ ಡೇಟಾದಲ್ಲಿನ ಯಾವುದೇ ವಿಚಲನಗಳ ಬಗ್ಗೆ ತಿಳಿಸುತ್ತದೆ (ಮೇಲ್, ಸ್ಲಾಕ್, ಟೆಲಿಗ್ರಾಮ್). ಆನ್‌ಲೈನ್ ಹೋಟೆಲ್ ಬುಕಿಂಗ್ ಸೇವೆಯಲ್ಲಿ Ostrovok.ru ನಮ್ಮ ಸೇವೆಗಳ ಎಲ್ಲಾ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು InfluxDB ಗೆ ಸುರಿಯಲಾಗುತ್ತದೆ ಮತ್ತು ಗ್ರಾಫಾನಾದಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಮೂಲ ಎಚ್ಚರಿಕೆಯನ್ನು ಸಹ ಅಲ್ಲಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗಿದೆ. "ನೀವು ಏನನ್ನಾದರೂ ಲೆಕ್ಕ ಹಾಕಬೇಕು ಮತ್ತು ಅದರೊಂದಿಗೆ ಹೋಲಿಸಬೇಕು" ನಂತಹ ಕಾರ್ಯಗಳಿಗಾಗಿ ನಾವು ಕಪಾಸಿಟರ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ.

ಕೆಪಾಸಿಟರ್ ಟಿಕ್ ಸ್ಟಾಕ್‌ನ ಭಾಗವಾಗಿದ್ದು ಅದು InfluxDB ಯಿಂದ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬಹುದು. ಇದು ಹಲವಾರು ಅಳತೆಗಳನ್ನು ಒಟ್ಟಿಗೆ ಸಂಪರ್ಕಿಸಬಹುದು (ಸೇರಬಹುದು), ಸ್ವೀಕರಿಸಿದ ಡೇಟಾದಿಂದ ಉಪಯುಕ್ತವಾದದ್ದನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಬಹುದು, ಫಲಿತಾಂಶವನ್ನು ಇನ್‌ಫ್ಲುಕ್ಸ್‌ಡಿಬಿಗೆ ಹಿಂತಿರುಗಿ ಬರೆಯಬಹುದು, ಸ್ಲಾಕ್/ಟೆಲಿಗ್ರಾಮ್/ಮೇಲ್‌ಗೆ ಎಚ್ಚರಿಕೆಯನ್ನು ಕಳುಹಿಸಬಹುದು.

ಸಂಪೂರ್ಣ ಸ್ಟಾಕ್ ತಂಪಾಗಿದೆ ಮತ್ತು ವಿವರವಾಗಿದೆ ದಸ್ತಾವೇಜನ್ನು, ಆದರೆ ಕೈಪಿಡಿಗಳಲ್ಲಿ ಸ್ಪಷ್ಟವಾಗಿ ಸೂಚಿಸದ ಉಪಯುಕ್ತ ವಿಷಯಗಳು ಯಾವಾಗಲೂ ಇರುತ್ತವೆ. ಈ ಲೇಖನದಲ್ಲಿ, ನಾನು ಅಂತಹ ಹಲವಾರು ಉಪಯುಕ್ತ, ಸ್ಪಷ್ಟವಲ್ಲದ ಸಲಹೆಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ನಿರ್ಧರಿಸಿದೆ (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)

ಸಂದೇಶದಲ್ಲಿ 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): ಕೆಪಾಸಿಟರ್ -url ಹೋಸ್ಟ್-ಅಥವಾ-ಐಪಿ:9092 ದಾಖಲೆಗಳು lvl=ದೋಷ

httpOut ಜೊತೆಗೆ ಆಯ್ಕೆ

ಪ್ರಸ್ತುತ ಪೈಪ್‌ಲೈನ್‌ನಲ್ಲಿ ಡೇಟಾವನ್ನು ತೋರಿಸುತ್ತದೆ:

|httpOut('something')

ವೀಕ್ಷಿಸಿ (ಪಡೆಯಿರಿ): ಹೋಸ್ಟ್-ಅಥವಾ-ಐಪಿ:9092/kapacitor/v1/tasks/task_name/ಏನೋ

ಮರಣದಂಡನೆ ಯೋಜನೆ

• ಪ್ರತಿಯೊಂದು ಕಾರ್ಯವು ಫಾರ್ಮ್ಯಾಟ್‌ನಲ್ಲಿ ಉಪಯುಕ್ತ ಸಂಖ್ಯೆಗಳೊಂದಿಗೆ ಮರಣದಂಡನೆ ಮರವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಗ್ರಾಫ್ವಿಜ್.
• ಒಂದು ಬ್ಲಾಕ್ ತೆಗೆದುಕೊಳ್ಳಿ ಡಾಟ್.
• ಅದನ್ನು ವೀಕ್ಷಕರಿಗೆ ಅಂಟಿಸಿ, ಆನಂದಿಸಿ.

ಕುಂಟೆ ಬೇರೆ ಎಲ್ಲಿ ಸಿಗುತ್ತದೆ?

ರೈಟ್‌ಬ್ಯಾಕ್‌ನಲ್ಲಿ ಇನ್‌ಫ್ಲಕ್ಸ್‌ಡಿಬಿಯಲ್ಲಿ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್

ಉದಾಹರಣೆಗೆ, ನಾವು ಪ್ರತಿ ಗಂಟೆಗೆ ವಿನಂತಿಗಳ ಮೊತ್ತಕ್ಕೆ ಎಚ್ಚರಿಕೆಯನ್ನು ಹೊಂದಿಸುತ್ತೇವೆ (groupBy(1h)) ಮತ್ತು influxdb ನಲ್ಲಿ ಸಂಭವಿಸಿದ ಎಚ್ಚರಿಕೆಯನ್ನು ರೆಕಾರ್ಡ್ ಮಾಡಲು ಬಯಸುತ್ತೇವೆ (ಗ್ರಾಫನಾದಲ್ಲಿನ ಗ್ರಾಫ್‌ನಲ್ಲಿ ಸಮಸ್ಯೆಯ ಸತ್ಯವನ್ನು ಸುಂದರವಾಗಿ ತೋರಿಸಲು).

influxDBOut() ಎಚ್ಚರಿಕೆಯಿಂದ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗೆ ಸಮಯದ ಮೌಲ್ಯವನ್ನು ಬರೆಯುತ್ತದೆ; ಅದರ ಪ್ರಕಾರ, ಚಾರ್ಟ್‌ನಲ್ಲಿನ ಬಿಂದುವನ್ನು ಎಚ್ಚರಿಕೆ ಬಂದಕ್ಕಿಂತ ಮುಂಚಿತವಾಗಿ / ನಂತರ ಬರೆಯಲಾಗುತ್ತದೆ.

ನಿಖರತೆ ಅಗತ್ಯವಿದ್ದಾಗ: ಕಸ್ಟಮ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗೆ ಕರೆ ಮಾಡುವ ಮೂಲಕ ನಾವು ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುತ್ತೇವೆ, ಇದು ಪ್ರಸ್ತುತ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ನೊಂದಿಗೆ influxdb ಗೆ ಡೇಟಾವನ್ನು ಬರೆಯುತ್ತದೆ.

ಡಾಕರ್, ನಿರ್ಮಾಣ ಮತ್ತು ನಿಯೋಜನೆ

ಪ್ರಾರಂಭದಲ್ಲಿ, ಕೆಪಾಸಿಟರ್ [ಲೋಡ್] ಬ್ಲಾಕ್‌ನಲ್ಲಿನ ಸಂರಚನೆಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಡೈರೆಕ್ಟರಿಯಿಂದ ಕಾರ್ಯಗಳು, ಟೆಂಪ್ಲೇಟ್‌ಗಳು ಮತ್ತು ಹ್ಯಾಂಡ್ಲರ್‌ಗಳನ್ನು ಲೋಡ್ ಮಾಡಬಹುದು.

ಕಾರ್ಯವನ್ನು ಸರಿಯಾಗಿ ರಚಿಸಲು, ನಿಮಗೆ ಈ ಕೆಳಗಿನ ಅಂಶಗಳು ಬೇಕಾಗುತ್ತವೆ:

1. ಫೈಲ್ ಹೆಸರು - ಸ್ಕ್ರಿಪ್ಟ್ ಐಡಿ/ಹೆಸರಿಗೆ ವಿಸ್ತರಿಸಲಾಗಿದೆ
2. ಪ್ರಕಾರ - ಸ್ಟ್ರೀಮ್ / ಬ್ಯಾಚ್
3. dbrp – ಯಾವ ಡೇಟಾಬೇಸ್ + ನೀತಿಯಲ್ಲಿ ಸ್ಕ್ರಿಪ್ಟ್ ಚಲಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಸೂಚಿಸಲು ಕೀವರ್ಡ್ (dbrp “ಪೂರೈಕೆದಾರ.” “ಆಟೋಜೆನ್”)

ಕೆಲವು ಬ್ಯಾಚ್ ಕಾರ್ಯವು dbrp ಯೊಂದಿಗೆ ಸಾಲನ್ನು ಹೊಂದಿಲ್ಲದಿದ್ದರೆ, ಸಂಪೂರ್ಣ ಸೇವೆಯು ಪ್ರಾರಂಭಿಸಲು ನಿರಾಕರಿಸುತ್ತದೆ ಮತ್ತು ಲಾಗ್‌ನಲ್ಲಿ ಅದರ ಬಗ್ಗೆ ಪ್ರಾಮಾಣಿಕವಾಗಿ ಬರೆಯುತ್ತದೆ.

ಕ್ರೊನೊಗ್ರಾಫ್ನಲ್ಲಿ, ಇದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿ, ಈ ಸಾಲು ಅಸ್ತಿತ್ವದಲ್ಲಿರಬಾರದು; ಇದು ಇಂಟರ್ಫೇಸ್ ಮೂಲಕ ಸ್ವೀಕರಿಸಲ್ಪಡುವುದಿಲ್ಲ ಮತ್ತು ದೋಷವನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ.

ಕಂಟೇನರ್ ಅನ್ನು ನಿರ್ಮಿಸುವಾಗ ಹ್ಯಾಕ್ ಮಾಡಿ: //.+dbrp ನೊಂದಿಗೆ ಸಾಲುಗಳಿದ್ದರೆ ಡಾಕರ್‌ಫೈಲ್ -1 ನೊಂದಿಗೆ ನಿರ್ಗಮಿಸುತ್ತದೆ, ಇದು ಬಿಲ್ಡ್ ಅನ್ನು ಜೋಡಿಸುವಾಗ ವೈಫಲ್ಯದ ಕಾರಣವನ್ನು ತಕ್ಷಣವೇ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಒಂದರಿಂದ ಹಲವರಿಗೆ ಸೇರಿಕೊಳ್ಳಿ

ಉದಾಹರಣೆ ಕಾರ್ಯ: ನೀವು ಒಂದು ವಾರದವರೆಗೆ ಸೇವೆಯ ಕಾರ್ಯಾಚರಣೆಯ ಸಮಯದ 95 ನೇ ಶೇಕಡಾವನ್ನು ತೆಗೆದುಕೊಳ್ಳಬೇಕಾಗುತ್ತದೆ, ಈ ಮೌಲ್ಯದೊಂದಿಗೆ ಕೊನೆಯ 10 ರ ಪ್ರತಿ ನಿಮಿಷವನ್ನು ಹೋಲಿಕೆ ಮಾಡಿ.

ನೀವು ಒಂದರಿಂದ ಹಲವು ಸೇರಲು ಸಾಧ್ಯವಿಲ್ಲ, ಪಾಯಿಂಟ್‌ಗಳ ಗುಂಪಿನ ಮೇಲೆ ಕೊನೆಯ/ಸರಾಸರಿ/ಮಧ್ಯಮವು ನೋಡ್ ಅನ್ನು ಸ್ಟ್ರೀಮ್ ಆಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ, "ಮಕ್ಕಳ ಹೊಂದಾಣಿಕೆಯಾಗದ ಅಂಚುಗಳನ್ನು ಸೇರಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ: ಬ್ಯಾಚ್ -> ಸ್ಟ್ರೀಮ್" ದೋಷವನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ.

ಲ್ಯಾಂಬ್ಡಾ ಅಭಿವ್ಯಕ್ತಿಯಲ್ಲಿ ವೇರಿಯೇಬಲ್ ಆಗಿ ಬ್ಯಾಚ್‌ನ ಫಲಿತಾಂಶವನ್ನು ಸಹ ಬದಲಿಸಲಾಗುವುದಿಲ್ಲ.

ಮೊದಲ ಬ್ಯಾಚ್‌ನಿಂದ ಅಗತ್ಯ ಸಂಖ್ಯೆಗಳನ್ನು ಯುಡಿಎಫ್ ಮೂಲಕ ಫೈಲ್‌ಗೆ ಉಳಿಸಲು ಮತ್ತು ಸೈಡ್‌ಲೋಡ್ ಮೂಲಕ ಈ ಫೈಲ್ ಅನ್ನು ಲೋಡ್ ಮಾಡಲು ಆಯ್ಕೆ ಇದೆ.

ಇದರೊಂದಿಗೆ ನಾವು ಏನು ಪರಿಹರಿಸಿದ್ದೇವೆ?

ನಾವು ಸುಮಾರು 100 ಹೋಟೆಲ್ ಪೂರೈಕೆದಾರರನ್ನು ಹೊಂದಿದ್ದೇವೆ, ಪ್ರತಿಯೊಬ್ಬರೂ ಹಲವಾರು ಸಂಪರ್ಕಗಳನ್ನು ಹೊಂದಬಹುದು, ಅದನ್ನು ಚಾನಲ್ ಎಂದು ಕರೆಯೋಣ. ಈ ಚಾನಲ್‌ಗಳಲ್ಲಿ ಸರಿಸುಮಾರು 300 ಇವೆ, ಪ್ರತಿಯೊಂದು ಚಾನಲ್‌ಗಳು ಬೀಳಬಹುದು. ರೆಕಾರ್ಡ್ ಮಾಡಲಾದ ಎಲ್ಲಾ ಮೆಟ್ರಿಕ್‌ಗಳಲ್ಲಿ, ನಾವು ದೋಷ ದರವನ್ನು (ವಿನಂತಿಗಳು ಮತ್ತು ದೋಷಗಳು) ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುತ್ತೇವೆ.

ಏಕೆ ಗ್ರಾಫನಾ ಇಲ್ಲ?

ಗ್ರಾಫನಾದಲ್ಲಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾದ ದೋಷ ಎಚ್ಚರಿಕೆಗಳು ಹಲವಾರು ಅನಾನುಕೂಲಗಳನ್ನು ಹೊಂದಿವೆ. ಕೆಲವು ನಿರ್ಣಾಯಕವಾಗಿವೆ, ಕೆಲವು ಪರಿಸ್ಥಿತಿಗೆ ಅನುಗುಣವಾಗಿ ನಿಮ್ಮ ಕಣ್ಣುಗಳನ್ನು ಮುಚ್ಚಬಹುದು.

ಮಾಪನಗಳು + ಎಚ್ಚರಿಕೆಯ ನಡುವೆ ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು ಹೇಗೆ ಎಂದು ಗ್ರಾಫಾನಾಗೆ ತಿಳಿದಿಲ್ಲ, ಆದರೆ ನಮಗೆ ದರ (ವಿನಂತಿಗಳು-ದೋಷಗಳು)/ವಿನಂತಿಗಳು ಬೇಕು.

ದೋಷಗಳು ಅಸಹ್ಯವಾಗಿ ಕಾಣುತ್ತವೆ:

ಮತ್ತು ಯಶಸ್ವಿ ವಿನಂತಿಗಳೊಂದಿಗೆ ವೀಕ್ಷಿಸಿದಾಗ ಕಡಿಮೆ ದುಷ್ಟ:

ಸರಿ, ಗ್ರಾಫನಾ ಮೊದಲು ಸೇವೆಯಲ್ಲಿನ ದರವನ್ನು ನಾವು ಮೊದಲೇ ಲೆಕ್ಕ ಹಾಕಬಹುದು ಮತ್ತು ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ ಇದು ಕೆಲಸ ಮಾಡುತ್ತದೆ. ಆದರೆ ನಮ್ಮಲ್ಲಿ ಅಲ್ಲ, ಏಕೆಂದರೆ ... ಪ್ರತಿ ಚಾನಲ್‌ಗೆ ತನ್ನದೇ ಆದ ಅನುಪಾತವನ್ನು "ಸಾಮಾನ್ಯ" ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಎಚ್ಚರಿಕೆಗಳು ಸ್ಥಿರ ಮೌಲ್ಯಗಳಿಗೆ ಅನುಗುಣವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ (ನಾವು ಅವುಗಳನ್ನು ನಮ್ಮ ಕಣ್ಣುಗಳಿಂದ ಹುಡುಕುತ್ತೇವೆ, ಆಗಾಗ್ಗೆ ಎಚ್ಚರಿಕೆಗಳು ಇದ್ದಲ್ಲಿ ಅವುಗಳನ್ನು ಬದಲಾಯಿಸಬಹುದು).

ಇವು ವಿಭಿನ್ನ ಚಾನಲ್‌ಗಳಿಗೆ "ಸಾಮಾನ್ಯ" ಉದಾಹರಣೆಗಳಾಗಿವೆ:

ನಾವು ಹಿಂದಿನ ಬಿಂದುವನ್ನು ನಿರ್ಲಕ್ಷಿಸುತ್ತೇವೆ ಮತ್ತು "ಸಾಮಾನ್ಯ" ಚಿತ್ರವು ಎಲ್ಲಾ ಪೂರೈಕೆದಾರರಿಗೆ ಹೋಲುತ್ತದೆ ಎಂದು ಭಾವಿಸುತ್ತೇವೆ. ಈಗ ಎಲ್ಲವೂ ಉತ್ತಮವಾಗಿದೆ, ಮತ್ತು ನಾವು ಗ್ರಾಫಾನಾದಲ್ಲಿ ಎಚ್ಚರಿಕೆಗಳನ್ನು ಪಡೆಯಬಹುದೇ?
ನಾವು ಮಾಡಬಹುದು, ಆದರೆ ನಾವು ನಿಜವಾಗಿಯೂ ಬಯಸುವುದಿಲ್ಲ, ಏಕೆಂದರೆ ನಾವು ಆಯ್ಕೆಗಳಲ್ಲಿ ಒಂದನ್ನು ಆರಿಸಬೇಕಾಗುತ್ತದೆ:
a) ಪ್ರತಿ ಚಾನಲ್‌ಗೆ ಪ್ರತ್ಯೇಕವಾಗಿ ಸಾಕಷ್ಟು ಗ್ರಾಫ್‌ಗಳನ್ನು ಮಾಡಿ (ಮತ್ತು ನೋವಿನಿಂದ ಅವರೊಂದಿಗೆ)
ಬಿ) ಎಲ್ಲಾ ಚಾನಲ್‌ಗಳೊಂದಿಗೆ ಒಂದು ಚಾರ್ಟ್ ಅನ್ನು ಬಿಡಿ (ಮತ್ತು ವರ್ಣರಂಜಿತ ಸಾಲುಗಳು ಮತ್ತು ಕಸ್ಟಮೈಸ್ ಮಾಡಿದ ಎಚ್ಚರಿಕೆಗಳಲ್ಲಿ ಕಳೆದುಹೋಗಿ)

ನೀನು ಇದನ್ನು ಹೇಗೆ ಮಾಡಿದೆ?

ಮತ್ತೊಮ್ಮೆ, ದಾಖಲಾತಿಯಲ್ಲಿ ಉತ್ತಮ ಆರಂಭದ ಉದಾಹರಣೆ ಇದೆ (ಸೇರಿದ ಸರಣಿಯಾದ್ಯಂತ ದರಗಳನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲಾಗುತ್ತಿದೆ), ಇದೇ ರೀತಿಯ ಸಮಸ್ಯೆಗಳಲ್ಲಿ ಇಣುಕಿ ನೋಡಬಹುದು ಅಥವಾ ಆಧಾರವಾಗಿ ತೆಗೆದುಕೊಳ್ಳಬಹುದು.

ನಾವು ಕೊನೆಯಲ್ಲಿ ಏನು ಮಾಡಿದೆವು:

• ಕೆಲವು ಗಂಟೆಗಳಲ್ಲಿ ಎರಡು ಸರಣಿಗಳನ್ನು ಸೇರಿ, ಚಾನಲ್‌ಗಳ ಮೂಲಕ ಗುಂಪು ಮಾಡುವುದು;
• ಯಾವುದೇ ಡೇಟಾ ಇಲ್ಲದಿದ್ದರೆ ಗುಂಪಿನ ಮೂಲಕ ಸರಣಿಯನ್ನು ಭರ್ತಿ ಮಾಡಿ;
• ಹಿಂದಿನ ಡೇಟಾದೊಂದಿಗೆ ಕೊನೆಯ 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