func TestReadTimeout(t *testing.T) {
l, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
t.Fatalf("net.Listen returned %v", err)
}
defer l.Close()
go func() {
for {
c, err := l.Accept()
if err != nil {
return
}
go func() {
time.Sleep(time.Second)
c.Write([]byte("+OK\r\n"))
c.Close()
}()
}
}()
// Do
c1, err := redis.Dial(l.Addr().Network(), l.Addr().String(), redis.DialReadTimeout(time.Millisecond))
if err != nil {
t.Fatalf("redis.Dial returned %v", err)
}
defer c1.Close()
_, err = c1.Do("PING")
if err == nil {
t.Fatalf("c1.Do() returned nil, expect error")
}
if c1.Err() == nil {
t.Fatalf("c1.Err() = nil, expect error")
}
// Send/Flush/Receive
c2, err := redis.Dial(l.Addr().Network(), l.Addr().String(), redis.DialReadTimeout(time.Millisecond))
if err != nil {
t.Fatalf("redis.Dial returned %v", err)
}
defer c2.Close()
c2.Send("PING")
c2.Flush()
_, err = c2.Receive()
if err == nil {
t.Fatalf("c2.Receive() returned nil, expect error")
}
if c2.Err() == nil {
t.Fatalf("c2.Err() = nil, expect error")
}
}
func newPool(server, password string, database int, isRedis bool, maxActive int, wait bool) *redis.Pool {
return &redis.Pool{
MaxIdle: 50,
MaxActive: maxActive,
Wait: wait,
IdleTimeout: 240 * time.Second,
Dial: func() (redis.Conn, error) {
c, err := redis.Dial("tcp", server, redis.DialDatabase(database))
if err != nil {
return nil, err
}
if password != "" {
if _, err := c.Do("AUTH", password); err != nil {
c.Close()
return nil, err
}
}
if isRedis {
if _, err := c.Do("CLIENT", "SETNAME", "bosun"); err != nil {
c.Close()
return nil, err
}
}
return c, err
},
}
}
// Connect to local instance of Redis running on the default port.
func ExampleDial(x int) {
c, err := redis.Dial("tcp", ":6379")
if err != nil {
// handle error
}
defer c.Close()
}
func newPool(server, password string, database int, isRedis bool) *redis.Pool {
return &redis.Pool{
MaxIdle: 3,
IdleTimeout: 240 * time.Second,
Dial: func() (redis.Conn, error) {
c, err := redis.Dial("tcp", server, redis.DialDatabase(database))
if err != nil {
return nil, err
}
if password != "" {
if _, err := c.Do("AUTH", password); err != nil {
c.Close()
return nil, err
}
}
if isRedis {
if _, err := c.Do("CLIENT", "SETNAME", "bosun"); err != nil {
c.Close()
return nil, err
}
}
return c, err
},
TestOnBorrow: func(c redis.Conn, t time.Time) error {
defer collect.StartTimer("redis", opentsdb.TagSet{"op": "Ping"})()
_, err := c.Do("PING")
return err
},
}
}
func c_redis_counters(server string, db int) (opentsdb.MultiDataPoint, error) {
var md opentsdb.MultiDataPoint
conn, err := redis.Dial("tcp", server, redis.DialDatabase(db))
if err != nil {
return md, err
}
defer conn.Close()
if _, err := conn.Do("CLIENT", "SETNAME", "scollector"); err != nil {
return md, err
}
cursor := 0
for {
vals, err := redis.Values(conn.Do("HSCAN", collect.RedisCountersKey, cursor))
if err != nil {
return md, err
}
if len(vals) != 2 {
return md, fmt.Errorf("Unexpected number of values")
}
cursor, err = redis.Int(vals[0], nil)
if err != nil {
return md, err
}
pairs, err := redis.StringMap(vals[1], nil)
if err != nil {
return md, err
}
for mts, val := range pairs {
parts := strings.Split(mts, ":")
if len(parts) != 2 {
slog.Errorf("Invalid metric tag set counter: %s", mts)
continue
}
metric := parts[0]
tags, err := opentsdb.ParseTags(parts[1])
if err != nil {
slog.Errorf("Invalid tags: %s", parts[1])
continue
}
v, err := strconv.Atoi(val)
if err != nil {
slog.Errorf("Invalid counter value: %s", val)
continue
}
Add(&md, metric, v, tags, metadata.Counter, metadata.Count, "")
}
if cursor == 0 {
break
}
}
return md, nil
}
func TestWrite(t *testing.T) {
for _, tt := range writeTests {
var buf bytes.Buffer
c, _ := redis.Dial("", "", dialTestConn(nil, &buf))
err := c.Send(tt.args[0].(string), tt.args[1:]...)
if err != nil {
t.Errorf("Send(%v) returned error %v", tt.args, err)
continue
}
c.Flush()
actual := buf.String()
if actual != tt.expected {
t.Errorf("Send(%v) = %q, want %q", tt.args, actual, tt.expected)
}
}
}
func newRedisPool(server string, database int) *redis.Pool {
return &redis.Pool{
MaxIdle: 10,
MaxActive: 10,
Wait: true,
IdleTimeout: 240 * time.Second,
Dial: func() (redis.Conn, error) {
c, err := redis.Dial("tcp", server, redis.DialDatabase(database))
if err != nil {
return nil, err
}
if _, err := c.Do("CLIENT", "SETNAME", metricRoot+"_counters"); err != nil {
c.Close()
return nil, err
}
return c, err
},
}
}
func TestRead(t *testing.T) {
for _, tt := range readTests {
c, _ := redis.Dial("", "", dialTestConn(strings.NewReader(tt.reply), nil))
actual, err := c.Receive()
if tt.expected == errorSentinel {
if err == nil {
t.Errorf("Receive(%q) did not return expected error", tt.reply)
}
} else {
if err != nil {
t.Errorf("Receive(%q) returned error %v", tt.reply, err)
continue
}
if !reflect.DeepEqual(actual, tt.expected) {
t.Errorf("Receive(%q) = %v, want %v", tt.reply, actual, tt.expected)
}
}
}
}
func c_redis() (opentsdb.MultiDataPoint, error) {
var md opentsdb.MultiDataPoint
var Error error
for _, instance := range redisInstances {
c, err := redis.Dial("tcp", fmt.Sprintf(":%s", instance["port"]))
if err != nil {
Error = err
continue
}
defer c.Close()
info, err := c.Do("info", "all")
if err != nil {
Error = err
continue
}
tags := instance.Copy()
infoSplit := strings.Split(string(info.([]uint8)), "\n")
for _, line := range infoSplit {
line = strings.TrimSpace(line)
sp := strings.Split(line, ":")
if len(sp) < 2 || sp[0] != "config_file" {
continue
}
if sp[1] != "" {
m := redisScollectorTags(sp[1])
tags.Merge(m)
break
}
}
var keyspace bool
var keys int64
for _, line := range infoSplit {
line = strings.TrimSpace(line)
if line == "" {
continue
}
if line == "# Keyspace" {
keyspace = true
continue
}
if keyspace {
k, err := redisKeyCount(line)
if err != nil {
return nil, err
}
keys += k
continue
}
sp := strings.Split(line, ":")
if len(sp) < 2 || !(redisFields[sp[0]] || strings.HasPrefix(sp[0], "cmdstat_")) {
continue
}
if sp[0] == "master_link_status" {
Add(&md, "redis."+sp[0], redisMlsMap[sp[1]], tags, metadata.Unknown, metadata.None, "")
continue
}
if sp[0] == "role" {
Add(&md, "redis.is_slave", slave(sp[1]), tags, metadata.Gauge, metadata.Bool, "")
continue
}
if sp[0] == "aof_last_bgrewrite_status" || sp[0] == "rdb_last_bgsave_status" {
Add(&md, "redis."+sp[0], status(sp[1]), tags, metadata.Unknown, metadata.None, "")
continue
}
if strings.HasPrefix(sp[0], "cmdstat_") {
cmdStats := strings.Split(sp[1], ",")
if len(cmdStats) < 3 {
continue
}
cmdStatsCalls := strings.Split(cmdStats[0], "=")
if len(cmdStatsCalls) < 2 {
continue
}
cmdStatsUsec := strings.Split(cmdStats[1], "=")
if len(cmdStatsUsec) < 2 {
continue
}
var cmdStatsMsec, cmdStatsMsecPc float64
microsec, err := strconv.ParseFloat(cmdStatsUsec[1], 64)
if err != nil {
continue
}
cmdStatsMsec = microsec / 1000
cmdStatsUsecPc := strings.Split(cmdStats[2], "=")
if len(cmdStatsUsecPc) < 2 {
continue
}
microsec, err = strconv.ParseFloat(cmdStatsUsecPc[1], 64)
if err != nil {
continue
}
cmdStatsMsecPc = microsec / 1000
if shortTag := strings.Split(sp[0], "_"); len(shortTag) == 2 {
tags["cmd"] = shortTag[1]
}
Add(&md, "redis.cmdstats_msec_pc", cmdStatsMsecPc, tags, metadata.Gauge, metadata.MilliSecond, descRedisCmdMsecPc)
Add(&md, "redis.cmdstats_msec", cmdStatsMsec, tags, metadata.Counter, metadata.MilliSecond, descRedisCmdMsec)
Add(&md, "redis.cmdstats_calls", cmdStatsCalls[1], tags, metadata.Counter, metadata.Operation, descRedisCmdCalls)
continue
}
Add(&md, "redis."+sp[0], sp[1], tags, metadata.Unknown, metadata.None, "")
}
Add(&md, "redis.key_count", keys, tags, metadata.Gauge, metadata.Key, descRedisKeyCount)
}
return md, Error
}