firehol/netdata

// SPDX-License-Identifier: GPL-3.0-or-later

package memcached

import (
    "bufio"
    "bytes"
    "errors"
    "strconv"
    "strings"
)

// https://github.com/memcached/memcached/blob/b1aefcdf8a265f8a5126e8aa107a50988fa1ec35/doc/protocol.txt#L1267
var statsMetrics = map[string]bool{
    "limit_maxbytes":       true,
    "bytes":                true,
    "bytes_read":           true,
    "bytes_written":        true,
    "cas_badval":           true,
    "cas_hits":             true,
    "cas_misses":           true,
    "cmd_get":              true,
    "cmd_set":              true,
    "cmd_touch":            true,
    "curr_connections":     true,
    "curr_items":           true,
    "decr_hits":            true,
    "decr_misses":          true,
    "delete_hits":          true,
    "delete_misses":        true,
    "evictions":            true,
    "get_hits":             true,
    "get_misses":           true,
    "incr_hits":            true,
    "incr_misses":          true,
    "reclaimed":            true,
    "rejected_connections": true,
    "total_connections":    true,
    "total_items":          true,
    "touch_hits":           true,
    "touch_misses":         true,
}

func (m *Memcached) collect() (map[string]int64, error) {
    if m.conn == nil {
        conn, err := m.establishConn()
        if err != nil {
            return nil, err
        }
        m.conn = conn
    }

    stats, err := m.conn.queryStats()
    if err != nil {
        m.conn.disconnect()
        m.conn = nil
        return nil, err
    }

    mx := make(map[string]int64)

    if err := m.collectStats(mx, stats); err != nil {
        return nil, err
    }

    return mx, nil
}

func (m *Memcached) collectStats(mx map[string]int64, stats []byte) error {
    if len(stats) == 0 {
        return errors.New("empty stats response")
    }

    var n int
    sc := bufio.NewScanner(bytes.NewReader(stats))

    for sc.Scan() {
        line := strings.TrimSpace(sc.Text())

        switch {
        case strings.HasPrefix(line, "STAT"):
            key, value := getStatKeyValue(line)
            if !statsMetrics[key] {
                continue
            }
            if v, err := strconv.ParseInt(value, 10, 64); err == nil {
                mx[key] = v
                n++
            }
        case strings.HasPrefix(line, "ERROR"):
            return errors.New("received ERROR response")
        }
    }

    if n == 0 {
        return errors.New("unexpected memcached response")
    }

    mx["avail"] = mx["limit_maxbytes"] - mx["bytes"]

    return nil
}

func (m *Memcached) establishConn() (memcachedConn, error) {
    conn := m.newMemcachedConn(m.Config)

    if err := conn.connect(); err != nil {
        return nil, err
    }

    return conn, nil
}

func getStatKeyValue(line string) (string, string) {
    line = strings.TrimPrefix(line, "STAT ")
    i := strings.IndexByte(line, ' ')
    if i < 0 {
        return "", ""
    }
    return line[:i], line[i+1:]
}