AlertNode

stream
    .groupBy('service')
  |alert()
    .id('kapacitor/{{ index .Tags "service" }}')
    .message('{{ .ID }} is {{ .Level }} value:{{ index .Fields "value" }}')
    .info(lambda: "value" > 10)
    .warn(lambda: "value" > 20)
    .crit(lambda: "value" > 30)
    .post("http://example.com/api/alert")
    .post("http://another.example.com/api/alert")
    .tcp("exampleendpoint.com:5678")
    .email('oncall@example.com')

stream
  |from()
    .measurement('cpu')
    .where(lambda: "host" == 'serverA')
    .groupBy('host')
  |alert()
    .info(lambda: "value" > 60)
    .infoReset(lambda: "value" < 50)
    .warn(lambda: "value" > 70)
    .warnReset(lambda: "value" < 60)
    .crit(lambda: "value" > 80)
    .critReset(lambda: "value" < 70)

[alerta]
  enabled = true
  url = "https://alerta.yourdomain"
  token = "9hiWoDOZ9IbmHsOTeST123ABciWTIqXQVFDo63h9"
  environment = "Production"
  origin = "Kapacitor"

stream
  |alert()
    .alerta()
      .resource('Hostname or service')
      .event('Something went wrong')

alert.all()

[bigpanda]
  enabled = true
  url = "https://api.bigpanda.io/data/v2/alerts"
  token = "BigPanda-API-auth-bearer-token"
  app-key = "BigPanda-integration-app-key"

stream
  |alert()
    .bigPanda()
      .appKey('fc39458f98e91eb0310258c3b725d643')
      .primaryProperty('device')
      .secondaryProperty('sensor_name')
      .topic('bigpanda-topic')

alert.category(value string)

alert.crit(value ast.LambdaNode)

alert.critReset(value ast.LambdaNode)

|alert()
  .id('{{ .Name }}')
  .details('''
<h1>{{ .ID }}</h1>
<b>{{ .Message }}</b>
Value: {{ index .Fields "value" }}
''')
  .email()

alert.details(value string)

[discord]
  enabled = true
  url = "https://discordapp.com/api/webhooks/xxxxxxxxxxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

stream
  |alert()
    .discord()
      .embedTitle('Alert!')

alert.durationField(value string)

[smtp]
  enabled = true
  host = "localhost"
  port = 25
  username = "xxxx"
  password = "xxxx"
  from = "kapacitor@example.com"
  to = ["oncall@example.com"]
  global = true
  state-changes-only = true

|alert()
  .id('{{ .Name }}')
  // Email subject
  .message('{{ .ID }}:{{ .Level }}')
  // Email body as HTML
  .details('''
<h1>{{ .ID }}</h1>
<b>{{ .Message }}</b>
Value: {{ index .Fields "value" }}
''')
  .email()

// Pattern
alert.exec(executable string, args ...string)

// Example
alert.exec('/usr/bin/python', 'myscript.py')

// Pattern
alert.flapping(low float64, high float64)

// Example
alert.flapping(0.25, 0.5)

[[kafka]]
  enabled = true
  id = "localhost"
  timeout = 10s

stream
  |alert()
    .kafka()
      .cluster('kafka-cluster')
      .kafkaTopic('kafka-topic-name')

// Pattern
alert.history(value int64)

// Example
alert.history(21)

[hipchat]
  enabled = true
  url = "https://orgname.hipchat.com/v2/room"
  room = "4189212"
  token = "9hiWoDOZ9IbmHsOTeST123ABciWTIqXQVFDo63h9"

stream
  |alert()
    .hipChat()
      .room('Kapacitor')

// Pattern
alert.id(value string)

// Example
alert.id('{{ .Name }}:{{ .Group }}')

stream
  |from()
    .measurement('cpu')
    .groupBy('cpu')
  |alert()
    .id('kapacitor/{{ .Name }}/{{ .Group }}')

stream
  |from()
    .measurement('cpu')
    .groupBy('service')
  |alert()
    .id('kapacitor/{{ index .Tags "service" }}')

stream
  |from()
    .measurement('cpu')
    .groupBy('service', 'host')
  |alert()
    .id('kapacitor/{{ index .Tags "service" }}/{{ index .Tags "host" }}')

// Pattern
alert.idField(value string)

// Example
alert.idField('id')

// Pattern
alert.idTag(value string)

// Example
alert.idTag('alertID')

// Pattern
alert.info(value ast.LambdaNode)

// Example
alert.info(lambda: 'usage_idle' < 60)

// Pattern
alert.infoReset(value ast.LambdaNode)

// Example
alert.infoReset(lambda: 'usage_idle' > 60)

    //cpu_alert.tick
stream
  |from()
    .measurement('cpu')
    .groupBy('host')
  |alert()
    .category('system_alerts')
    .crit(lambda: "usage_idle" < 10.0)

//host_alert.tick
stream
  |from()
    .measurement('uptime')
    .groupBy('host')
  |deadman(0.0, 1m)
    .inhibit('system_alerts', 'host')

alert.inhibit(category string, equalTags ...string)

[[kafka]]
  enabled = true
  id = "default"
  brokers = ["localhost:9092"]

stream
 |alert()
    .kafka()
      .cluster('default')
      .kafkaTopic('alerts')

// Pattern
alert.levelField(value string)

// Example
alert.levelField('INFO')

// Pattern
alert.levelTag(value string)

// Example
alert.levelTag('level')

stream
  |alert()
    .log('/tmp/alert')
      .mode(0644)

stream
  |from()
    .measurement('cpu')
    .groupBy('service', 'host')
  |alert()
    .id('{{ index .Tags "service" }}/{{ index .Tags "host" }}')
    .message('{{ .ID }} is {{ .Level}} value: {{ index .Fields "value" }}')

// Pattern
alert.messageField(value string)

// Example
alert.messageField('message')

[[mqtt]]
  enabled = true
  name = "localhost"
  default = true
  url = "tcp://localhost:1883"
  client-id = "kapacitor"
  username = "myusername"
  password = "mysupersecretpassw0rd"

stream
  |alert()
    .mqtt('topic')
      .brokerName('localhost')

alert.noRecoveries()

[opsgenie]
  enabled = true
  api-key = "xxxxx"
  teams = ["everyone"]
  recipients = ["jim", "bob"]

stream
  |alert()
    .opsGenie()

[opsgenie2]
  enabled = true
  api-key = "xxxxx"
  teams = ["everyone"]
  recipients = ["jim", "bob"]

stream
  |alert()
    .opsGenie2()

[pagerduty]
  enabled = true
  service-key = "xxxx"
  url = "https://events.pagerduty.com/generic/2010-04-15/create_event.json"

stream
  |alert()
    .pagerDuty()

[pagerduty2]
  enabled = true
  routing-key = "xxxx"
  url = "https://events.pagerduty.com/v2/enqueue"

stream
  |alert()
    .pagerDuty2()

stream
  |alert()
    .post('http://example.com')
      .captureResponse()

[pushover]
  enabled = true
  token = "9hiWoDOZ9IbmHsOTeST123ABciWTIqXQVFDo63h9"
  user_key = "Pushover"

stream
  |alert()
    .pushover()
      .sound('siren')
      .user_key('other user')
      .device('mydev')
      .title('mytitle')
      .uRL('myurl')
      .URLTitle('mytitle')

alert.quiet()

[sensu]
  enabled = true
  url = "http://sensu:3030"
  source = "Kapacitor"
  handlers = ["sns","slack"]

stream
  |alert()
    .sensu()
      .handlers('sns','slack')

[slack]
  enabled = true
  url = "https://hooks.slack.com/services/xxxxxxxxx/xxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxxxx"
  channel = "#general"

stream
  |alert()
    .slack()
      .channel('#alerts')
      .channel('@jsmith')

[snmptrap]
  enabled = true
  addr = "127.0.0.1:9162"
  community = "public"

stream
  |alert()
    .snmpTrap('1.3.6.1.2.1.1')
      .data('1.3.6.1.2.1.1.6', 'i', '{{ index .Field "value" }}')
      .data('1.3.6.1.2.1.1.7', 's', '{{ .Message }}')

stream
  |from()
    .measurement('cpu')
  |window()
    .period(10s)
    .every(10s)
  |alert()
    .crit(lambda: "value" > 10)
    .stateChangesOnly()
    .slack()

stream
  // ...
  |alert()
    .crit(lambda: "value" > 10)
    .stateChangesOnly(10m)
    .slack()

// Pattern
alert.tcp(address string)

// Example
alert.tcp('127.0.0.1:7777')

[telegram]
  enabled = true
  token = "123456789:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
  chat-id = "xxxxxxxxx"
  parse-mode = "Markdown"
	disable-web-page-preview = true
	disable-notification = false

stream
  |alert()
    .telegram()
      .chatId('xxxxxxx')

// Pattern
alert.topic(value string)

// Example
alert.topic('cpu')

[victorops]
  enabled = true
  api-key = "xxxxx"
  routing-key = "everyone"

stream
  |alert()
    .victorOps()
      .routingKey('team_rocket')

// Pattern
alert.warn(value ast.LambdaNode)

// Example
alert.warn(lambda: 'usage_idle' < 20)

// Pattern
alert.warnReset(value ast.LambdaNode)

// Example
alert.warnReset(lambda: 'usage_idle' > 20)

alert|alert()

alert|barrier()

alert|bottom(num int64, field string, fieldsAndTags ...string)

alert|changeDetect(field string)

alert|combine(expressions ...ast.LambdaNode)

alert|count(field string)

alert|cumulativeSum(field string)

    var data = stream
        |from()...
    // Trigger critical alert if the throughput drops below 100 points per 10s and checked every 10s.
    data
        |deadman(100.0, 10s)
    //Do normal processing of data
    data...

    var data = stream
        |from()...
    // Trigger critical alert if the throughput drops below 100 points per 10s and checked every 10s.
    data
        |stats(10s)
            .align()
        |derivative('emitted')
            .unit(10s)
            .nonNegative()
        |alert()
            .id('node \'stream0\' in task \'{{ .TaskName }}\'')
            .message('{{ .ID }} is {{ if eq .Level "OK" }}alive{{ else }}dead{{ end }}: {{ index .Fields "emitted" | printf "%0.3f" }} points/10s.')
            .crit(lambda: "emitted" <= 100.0)
    //Do normal processing of data
    data...

    var data = stream
        |from()...
    // Trigger critical alert if the throughput drops below 100 points per 10s and checked every 10s.
    data
        |deadman(100.0, 10s)
            .slack()
            .channel('#dead_tasks')
    //Do normal processing of data
    data...

    var data = stream
        |from()...
    // Trigger critical alert if the throughput drops below 100 points per 10s and checked every 10s.
    // Only trigger the alert if the time of day is between 8am-5pm.
    data
        |deadman(100.0, 10s, lambda: hour("time") >= 8 AND hour("time") <= 17)
    //Do normal processing of data
    data...

alert|deadman(threshold float64, interval time.Duration, expr ...ast.LambdaNode)

alert|default()

alert|delete()

alert|derivative(field string)

alert|difference(field string)

alert|distinct(field string)

alert|ec2Autoscale()

alert|elapsed(field string, unit time.Duration)

alert|eval(expressions ...ast.LambdaNode)

alert|first(field string)

alert|flatten()

    |groupBy(*)

alert|groupBy(tag ...interface{})

alert|holtWinters(field string, h int64, m int64, interval time.Duration)

alert|holtWintersWithFit(field string, h int64, m int64, interval time.Duration)

alert|httpOut(endpoint string)

alert|httpPost(url ...string)

alert|influxDBOut()

alert|join(others ...Node)

alert|k8sAutoscale()

alert|kapacitorLoopback()

alert|last(field string)

alert|max(field string)

alert|mean(field string)

alert|median(field string)

alert|min(field string)

alert|mode(field string)

alert|movingAverage(field string, window int64)

alert|percentile(field string, percentile float64)

alert|sample(rate interface{})

alert|shift(shift time.Duration)

alert|sideload()

alert|spread(field string)

alert|stateCount(expression ast.LambdaNode)

alert|stateDuration(expression ast.LambdaNode)

alert|stats(interval time.Duration)

alert|stddev(field string)

alert|sum(field string)

alert|swarmAutoscale()

alert|top(num int64, field string, fieldsAndTags ...string)

alert|trickle()

alert|union(node ...Node)

alert|where(expression ast.LambdaNode)

alert|window()