apiVersion: influxdata.com/v2alpha1
kind: Label
metadata:
    name: amusing-pasteur-94d001
spec:
    color: '#67d74e'
    name: fail2ban
---
apiVersion: influxdata.com/v2alpha1
kind: Variable
metadata:
    name: gracious-montalcini-94d009
spec:
    associations:
      - kind: Label
        name: amusing-pasteur-94d001
    language: flux
    name: jail
    query: |-
        import "influxdata/influxdb/v1"

        all_data = buckets() |> limit(n:1) |> set(key: "_value", value: "*") |> keep(columns:["_value"])
        jails = v1.measurementTagValues(bucket: v.bucket, measurement: "fail2ban", tag: "jail")

        union(tables: [all_data, jails]) |> sort()
    type: query
---
apiVersion: influxdata.com/v2alpha1
kind: Variable
metadata:
    name: kind-shtern-94d00d
spec:
    associations:
      - kind: Label
        name: amusing-pasteur-94d001
    language: flux
    name: host
    query: |-
        import "influxdata/influxdb/v1"

        all_data = buckets() |> limit(n:1) |> set(key: "_value", value: "*") |> keep(columns:["_value"])
        hosts = v1.measurementTagValues(bucket: v.bucket, measurement: "fail2ban", tag: "host")

        union(tables: [all_data, hosts]) |> sort()
    type: query
---
apiVersion: influxdata.com/v2alpha1
kind: Variable
metadata:
    name: rightful-wing-94d005
spec:
    associations:
      - kind: Label
        name: amusing-pasteur-94d001
    language: flux
    name: bucket
    query: |-
        buckets()
          |> filter(fn: (r) => r.name !~ /^_/)
          |> rename(columns: {name: "_value"})
          |> keep(columns: ["_value"])
    type: query
---
apiVersion: influxdata.com/v2alpha1
kind: Dashboard
metadata:
    name: epic-perlman-94d001
spec:
    associations:
      - kind: Label
        name: amusing-pasteur-94d001
    charts:
      - height: 1
        kind: Markdown
        name: Name this Cell
        note: This dashboard gives you an overview of metrics  from `fail2ban` `system`,
            `mem`, `diskio`, and `net` measurements. See the [Fail2Ban Template Documentation](https://github.com/influxdata/community-templates/tree/master/fail2ban)
            for help configuring these plugins.
        width: 12
      - axes:
          - base: "10"
            name: x
            scale: linear
          - base: "10"
            name: y
            scale: linear
        colors:
          - hex: '#31C0F6'
            name: Nineteen Eighty Four
            type: scale
          - hex: '#A500A5'
            name: Nineteen Eighty Four
            type: scale
          - hex: '#FF7E27'
            name: Nineteen Eighty Four
            type: scale
        geom: line
        height: 3
        kind: Xy
        name: Failed
        position: overlaid
        queries:
          - query: |-
                from(bucket: v.bucket)
                  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
                  |> filter(fn: (r) => r["_measurement"] == "fail2ban")
                  |> filter(fn: (r) => r["_field"] == "failed")
                  |> filter(fn: (r) => (if v.host == "*" then true else r["host"] == v.host))
                  |> filter(fn: (r) => (if v.jail == "*" then true else r["jail"] == v.jail))
                  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)
                  |> yield(name: "mean")
        width: 6
        xCol: _time
        yCol: _value
        yPos: 1
      - axes:
          - base: "10"
            name: x
            scale: linear
          - base: "10"
            name: y
            scale: linear
            suffix: '%'
          - base: "10"
            name: y2
            scale: linear
        geom: line
        height: 4
        kind: Xy
        name: Disk Usage
        queries:
          - query: |-
                from(bucket: v.bucket)
                  |> range(start: v.timeRangeStart)
                  |> filter(fn: (r) => r._measurement == "disk")
                  |> filter(fn: (r) => (if v.host == "*" then true else r["host"] == v.host))
                  |> filter(fn: (r) => r._field == "used_percent")
                  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)
                  |> yield(name: "mean")
        width: 4
        yPos: 4
      - axes:
          - base: "10"
            name: x
            scale: linear
          - base: "2"
            label: Bytes
            name: y
            scale: linear
          - base: "10"
            name: y2
            scale: linear
        geom: line
        height: 3
        kind: Xy
        name: Network
        queries:
          - query: |-
                from(bucket: v.bucket)
                  |> range(start: v.timeRangeStart)
                  |> filter(fn: (r) => r._measurement == "net")
                  |> filter(fn: (r) => (if v.host == "*" then true else r["host"] == v.host))
                  |> filter(fn: (r) => r._field == "bytes_recv" or r._field == "bytes_sent")
                  |> aggregateWindow(every: v.windowPeriod, fn: last, createEmpty: false)
                  |> derivative(unit: 1s, nonNegative: false)
                  |> yield(name: "derivative")
        width: 6
        xCol: _time
        yCol: _value
        yPos: 8
      - colors:
          - hex: '#00C9FF'
            name: laser
            type: text
        decimalPlaces: 2
        height: 1
        kind: Single_Stat
        name: nCPUs
        queries:
          - query: |-
                from(bucket: v.bucket)
                  |> range(start: v.timeRangeStart)
                  |> filter(fn: (r) => (if v.host == "*" then true else r["host"] == v.host))
                  |> filter(fn: (r) => r._measurement == "system")
                  |> filter(fn: (r) => r._field == "n_cpus")
                  |> last()
                  |> yield(name: "last")
        suffix: ' cpus'
        width: 2
        xPos: 4
        yPos: 4
      - colors:
          - hex: '#00C9FF'
            name: laser
            type: text
        decimalPlaces: 2
        height: 1
        kind: Single_Stat
        name: Total Memory
        queries:
          - query: |-
                from(bucket: v.bucket)
                  |> range(start: v.timeRangeStart)
                  |> filter(fn: (r) => r._measurement == "mem")
                  |> filter(fn: (r) => (if v.host == "*" then true else r["host"] == v.host))
                  |> filter(fn: (r) => r._field == "total")
                  |> last()
                  |> map(fn: (r) => ({r with _value: float(v: r._value) / 1024.0 / 1024.0 / 1024.0}))
                  |> yield(name: "last")
        suffix: ' GB'
        width: 2
        xPos: 4
        yPos: 5
      - colors:
          - hex: '#00C9FF'
            name: laser
            type: text
        decimalPlaces: 2
        height: 2
        kind: Single_Stat
        name: System Load
        queries:
          - query: |-
                from(bucket: v.bucket)
                  |> range(start: v.timeRangeStart)
                  |> filter(fn: (r) => r._measurement == "system")
                  |> filter(fn: (r) => (if v.host == "*" then true else r["host"] == v.host))
                  |> filter(fn: (r) => r._field == "load1")
                  |> last()
                  |> yield(name: "mean")
        width: 2
        xPos: 4
        yPos: 6
      - axes:
          - base: "10"
            name: x
            scale: linear
          - base: "10"
            name: y
            scale: linear
        colors:
          - hex: '#31C0F6'
            name: Nineteen Eighty Four
            type: scale
          - hex: '#A500A5'
            name: Nineteen Eighty Four
            type: scale
          - hex: '#FF7E27'
            name: Nineteen Eighty Four
            type: scale
        geom: line
        height: 3
        kind: Xy
        name: Banned IPs
        position: overlaid
        queries:
          - query: |-
                from(bucket: v.bucket)
                  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
                  |> filter(fn: (r) => r["_measurement"] == "fail2ban")
                  |> filter(fn: (r) => r["_field"] == "banned")
                  |> filter(fn: (r) => (if v.host == "*" then true else r["host"] == v.host))
                  |> filter(fn: (r) => (if v.jail == "*" then true else r["jail"] == v.jail))
                  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)
                  |> yield(name: "mean")
        width: 6
        xCol: _time
        xPos: 6
        yCol: _value
        yPos: 1
      - axes:
          - base: "10"
            name: x
            scale: linear
          - base: "10"
            name: y
            scale: linear
            suffix: '%'
          - base: "10"
            name: y2
            scale: linear
        geom: line
        height: 3
        kind: Xy
        name: CPU Usage
        queries:
          - query: |-
                from(bucket: v.bucket)
                  |> range(start: v.timeRangeStart)
                  |> filter(fn: (r) => r._measurement == "cpu")
                  |> filter(fn: (r) => (if v.host == "*" then true else r["host"] == v.host))
                  |> filter(fn: (r) => r._field == "usage_user" or r._field == "usage_system" or r._field == "usage_idle")
                  |> filter(fn: (r) => r.cpu == "cpu-total")
                  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)
                  |> yield(name: "mean")
        width: 3
        xCol: _time
        xPos: 6
        yCol: _value
        yPos: 4
      - axes:
          - base: "10"
            name: x
            scale: linear
          - base: "10"
            name: y
            scale: linear
          - base: "10"
            name: y2
            scale: linear
        geom: line
        height: 4
        kind: Xy
        name: Processes
        queries:
          - query: |-
                from(bucket: v.bucket)
                  |> range(start: v.timeRangeStart)
                  |> filter(fn: (r) => r._measurement == "processes")
                  |> filter(fn: (r) => (if v.host == "*" then true else r["host"] == v.host))
                  |> filter(fn: (r) => r._field == "running" or r._field == "blocked" or r._field == "idle" or r._field == "unknown")
                  |> aggregateWindow(every: v.windowPeriod, fn: max)
                  |> yield(name: "max")
        width: 3
        xCol: _time
        xPos: 6
        yCol: _value
        yPos: 7
      - axes:
          - base: "10"
            name: x
            scale: linear
          - base: "10"
            label: Load
            name: y
            scale: linear
          - base: "10"
            name: y2
            scale: linear
        geom: line
        height: 3
        kind: Xy
        name: System Load
        queries:
          - query: |-
                from(bucket: v.bucket)
                  |> range(start: v.timeRangeStart)
                  |> filter(fn: (r) => r._measurement == "system")
                  |> filter(fn: (r) => (if v.host == "*" then true else r["host"] == v.host))
                  |> filter(fn: (r) => r._field == "load1" or r._field == "load5" or r._field == "load15")
                  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)
                  |> yield(name: "mean")
        width: 3
        xCol: _time
        xPos: 9
        yCol: _value
        yPos: 4
      - axes:
          - base: "10"
            name: x
            scale: linear
          - base: "10"
            name: y
            scale: linear
            suffix: '%'
          - base: "10"
            name: y2
            scale: linear
        colors:
          - hex: '#00C9FF'
            name: laser
            type: text
          - hex: '#8F8AF4'
            name: Do Androids Dream of Electric Sheep?
            type: scale
          - hex: '#A51414'
            name: Do Androids Dream of Electric Sheep?
            type: scale
          - hex: '#F4CF31'
            name: Do Androids Dream of Electric Sheep?
            type: scale
        decimalPlaces: 1
        height: 4
        kind: Single_Stat_Plus_Line
        name: Memory Usage
        queries:
          - query: |-
                from(bucket: v.bucket)
                  |> range(start: v.timeRangeStart)
                  |> filter(fn: (r) => r._measurement == "mem")
                  |> filter(fn: (r) => (if v.host == "*" then true else r["host"] == v.host))
                  |> filter(fn: (r) => r._field == "used_percent")
                  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)
                  |> yield(name: "mean")
        suffix: '%'
        width: 3
        xCol: _time
        xPos: 9
        yCol: _value
        yPos: 7
    description: A collection of useful visualizations for monitoring your system
        stats
    name: Fail2Ban
---
apiVersion: influxdata.com/v2alpha1
kind: Telegraf
metadata:
    name: intelligent-kalam-94d005
spec:
    associations:
      - kind: Label
        name: amusing-pasteur-94d001
    config: |
        [agent]

        interval = "10s"
        round_interval = true
        metric_batch_size = 1000
        metric_buffer_limit = 1000
        collection_jitter = "0s"
        flush_interval = "10s"
        flush_jitter = "0s"

        # Outputs
        [[outputs.influxdb_v2]]

        urls = ["$INFLUX_HOST"]
        token = "$INFLUX_TOKEN"
        organization = "$INFLUX_ORG"
        bucket = "$INFLUX_BUCKET"

        ###############################################################################
        #                            INPUT PLUGINS                                    #
        ###############################################################################

        # for more info on input plugins: https://github.com/influxdata/telegraf/tree/master/plugins/inputs

        # Read system metrics
        [[inputs.cpu]]
        [[inputs.system]]
        [[inputs.kernel]]
        [[inputs.mem]]
        [[inputs.net]]
        [[inputs.processes]]
        [[inputs.disk]]
            ignore_fs = ["tmpfs", "devtmpfs", "devfs", "iso9660", "overlay", "aufs", "squashfs"]
        [[inputs.diskio]]


        # Read metrics from fail2ban.
        [[inputs.fail2ban]]
          ## Use sudo to run fail2ban-client
          use_sudo = false


        ## Timeout for metric collections from all servers.  Minimum timeout is "1s".
        # timeout = "5s"

        ## Optional TLS Config
        # enable_tls = true
        # tls_ca = "/etc/telegraf/ca.pem"
        # tls_cert = "/etc/telegraf/cert.pem"
        # tls_key = "/etc/telegraf/key.pem"
        ## If false, skip chain & host verification
        # insecure_skip_verify = true
    description: This is telegraf config for Fail2Ban template.
    name: Fail2Ban Telegraf config