func TestHickwallCollector(t *testing.T) {
sub := newcore.Subscribe(MustNewHickwallCollector("500ms"), nil)
time.AfterFunc(time.Second*1, func() {
sub.Close()
})
timeout := time.After(time.Second * time.Duration(2))
main_loop:
for {
select {
case md, openning := <-sub.Updates():
if openning {
if md == nil {
fmt.Println("md is nil")
} else {
for _, dp := range md {
fmt.Println("dp: ---> ", dp)
if !strings.HasPrefix(dp.Metric.Clean(), "hickwall.client.") {
t.Error("metric wrong")
return
}
}
}
} else {
break main_loop
}
case <-timeout:
t.Error("timed out! something is blocking")
break main_loop
}
}
}
func TestHeartBeat(t *testing.T) {
sub := newcore.Subscribe(NewHeartBeat("1s"), nil)
time.AfterFunc(time.Second*3, func() {
sub.Close()
})
timeout := time.After(time.Second * time.Duration(5))
main_loop:
for {
select {
case md, openning := <-sub.Updates():
if openning {
if md == nil {
fmt.Println("md is nil")
} else {
for _, dp := range md {
fmt.Println("dp: ---> ", dp)
if dp.Value != 1 || dp.Metric != "hickwall.client.alive" {
t.Error("heartbeat is broken")
return
}
}
}
} else {
break main_loop
}
case <-timeout:
t.Error("timed out! something is blocking")
break main_loop
}
}
}
func TestPing(t *testing.T) {
_ = fmt.Sprintf("")
conf := config.Config_single_pinger{
Interval: "200ms",
Metric: "ping",
Timeout: "100ms",
Target: "www.baidu.com",
Packets: 5,
}
sub := newcore.Subscribe(NewSinglePingCollector("p1", "prefix", conf), nil)
time.AfterFunc(time.Second*3, func() {
sub.Close()
})
timeout := time.After(time.Second * time.Duration(5))
main_loop:
for {
select {
case md, openning := <-sub.Updates():
if openning {
if md == nil {
fmt.Println("md is nil")
} else {
for _, dp := range md {
fmt.Println("dp: ---> ", dp)
if _, ok := dp.Tags["host"]; ok == false {
t.Error("host is not in tags")
return
}
if _, ok := dp.Tags["target"]; ok == false {
t.Error("target is not in tags")
return
}
if !strings.HasPrefix(dp.Metric.Clean(), "prefix.ping.") {
t.Error("metric wrong")
return
}
}
}
} else {
break main_loop
}
case <-timeout:
t.Error("timed out! something is blocking")
break main_loop
}
}
// panic("")
}
func TestInfluxdbBackend(t *testing.T) {
logging.SetLevel("debug")
conf := &config.Transport_influxdb{
Version: "0.9.0",
URL: "http://10.3.6.225:8086/",
Username: "******",
Password: "******",
Database: "mydb",
RetentionPolicy: "test",
}
merge := newcore.Merge(
newcore.Subscribe(newcore.NewDummyCollector("c1", time.Millisecond*100, 1), nil),
newcore.Subscribe(newcore.NewDummyCollector("c2", time.Millisecond*100, 1), nil),
)
b1, _ := NewInfluxdbBackend("b1", conf)
fset := newcore.FanOut(merge, b1)
fset_closed_chan := make(chan error)
time.AfterFunc(time.Second*time.Duration(2), func() {
// merge will be closed within FanOut
fset_closed_chan <- fset.Close()
})
timeout := time.After(time.Second * time.Duration(3))
main_loop:
for {
select {
case <-fset_closed_chan:
fmt.Println("fset closed")
break main_loop
case <-timeout:
t.Error("timed out! something is blocking")
break main_loop
}
}
}
func TestWinPdhCollector(t *testing.T) {
opts := config.Config_win_pdh_collector{
Interval: "100ms",
Queries: []config.Config_win_pdh_query{
{
Query: "\\System\\Processes",
Metric: "processes.1",
}, {
Query: "\\System\\Processes",
Metric: "processes.2",
}},
}
sub := newcore.Subscribe(MustNewWinPdhCollector("c1", "prefix", opts), nil)
time.AfterFunc(time.Second*1, func() {
sub.Close()
})
timeout := time.After(time.Second * time.Duration(2))
main_loop:
for {
select {
case md, openning := <-sub.Updates():
if openning {
if md == nil {
fmt.Println("md is nil")
} else {
for _, dp := range md {
fmt.Println("dp: ---> ", dp)
if _, ok := dp.Tags["host"]; ok == false {
t.Error("host is not in tags")
return
}
if !strings.HasPrefix(dp.Metric.Clean(), "prefix.processes.") {
t.Error("metric wrong")
return
}
if dp.Value.(float64) < 10 {
t.Error("processes count less than 10 ?")
return
}
}
}
} else {
break main_loop
}
case <-timeout:
t.Error("timed out! something is blocking")
break main_loop
}
}
}
func TestElasticsearchBackend(t *testing.T) {
logging.SetLevel("debug")
conf := &config.Transport_elasticsearch{
URL: "http://192.168.81.129:9200",
Index: "test",
Type: "test",
}
merge := newcore.Merge(
newcore.Subscribe(newcore.NewDummyCollector("c1", time.Millisecond*100, 1), nil),
newcore.Subscribe(newcore.NewDummyCollector("c2", time.Millisecond*100, 1), nil),
)
b1, _ := NewElasticsearchBackend("b1", conf)
fset := newcore.FanOut(merge, b1)
fset_closed_chan := make(chan error)
time.AfterFunc(time.Second*time.Duration(2), func() {
// merge will be closed within FanOut
fset_closed_chan <- fset.Close()
})
timeout := time.After(time.Second * time.Duration(3))
main_loop:
for {
select {
case <-fset_closed_chan:
fmt.Println("fset closed")
break main_loop
case <-timeout:
t.Error("timed out! something is blocking")
break main_loop
}
}
}
// create the topology of our running core.
//
// (collector -> subscription)s -> merged subscription -> fanout -> publications(backends)
//
func create_running_core_hooked(rconf *config.RuntimeConfig, ishook bool) (newcore.PublicationSet, *newcore.HookBackend, error) {
var hook *newcore.HookBackend
var subs []newcore.Subscription
var heartbeat_exists bool
if rconf == nil {
return nil, nil, fmt.Errorf("RuntimeConfig is nil")
}
// create backends --------------------------------------------------------------------
bks, err := backends.UseConfigCreateBackends(rconf)
if err != nil {
return nil, nil, err
}
if len(bks) <= 0 {
return nil, nil, fmt.Errorf("no backends configured. program will do nothing.")
}
for _, bk := range bks {
logging.Debugf("loaded backend: %s", bk.Name())
logging.Tracef("loaded backend: %s -> %+v", bk.Name(), bk)
}
// create collectors ------------------------------------------------------------------
clrs, err := collectors.UseConfigCreateCollectors(rconf)
if err != nil {
return nil, nil, err
}
// make sure heartbeat collector always created.
for _, c := range clrs {
if c.Name() == "heartbeat" {
heartbeat_exists = true
}
}
if heartbeat_exists == false {
clrs = append(clrs, collectors.NewHeartBeat(rconf.Client.HeartBeat_Interval))
}
// create collector subscriptions.
for _, c := range clrs {
subs = append(subs, newcore.Subscribe(c, nil))
}
// create other subscriptions, such as kafka consumer
_subs, err := collectors.UseConfigCreateSubscription(rconf)
if err != nil {
return nil, nil, err
}
subs = append(subs, _subs...)
for _, s := range subs {
logging.Debugf("loaded subscription: %s", s.Name())
logging.Tracef("loaded subscription: %s -> %+v", s.Name(), s)
}
merged := newcore.Merge(subs...)
if ishook == true {
// the only reason to create a hooked running core is to do unittesting. it's not a good idea though.
hook = newcore.NewHookBackend()
bks = append(bks, hook)
fset := newcore.FanOut(merged, bks...)
return fset, hook, nil
} else {
fset := newcore.FanOut(merged, bks...)
return fset, nil, nil
}
}
func TestFileBackend(t *testing.T) {
os.Remove(test_file_path)
conf := &config.Transport_file{
Enabled: true,
Path: test_file_path,
}
merge := newcore.Merge(
newcore.Subscribe(newcore.NewDummyCollector("c1", time.Millisecond*100, 1), nil),
newcore.Subscribe(newcore.NewDummyCollector("c2", time.Millisecond*100, 1), nil),
)
b1, _ := NewFileBackend("b1", conf)
hook := newcore.NewHookBackend()
bks := []newcore.Publication{b1, hook}
fset := newcore.FanOut(merge, bks...)
fset_closed_chan := make(chan error)
time.AfterFunc(time.Second*time.Duration(1), func() {
// merge will be closed within FanOut
fset_closed_chan <- fset.Close()
})
timeout := time.After(time.Second * time.Duration(3))
expected := 0
main_loop:
for {
select {
case md, ok := <-hook.Hook():
if ok != false {
expected += len(md)
} else {
break main_loop
}
case <-fset_closed_chan:
fmt.Println("fset closed")
break main_loop
case <-timeout:
t.Error("timed out! something is blocking")
break main_loop
}
}
// check how many data we collected.
lines, err := fileLines(test_file_path)
if err != nil {
t.Error("failed counting lines", err)
return
}
// on windows this may fail!
os.Remove(test_file_path)
t.Logf("expected: %d, got: %d", expected, lines)
// 1s / 100 ms = 10 batch x 1 for each x 2 collectors = 20
// expected := 20
if lines != expected {
t.Error("lines mismatch: lines: %d, expected: %d", lines, expected)
}
}
func TestWinWmiCollectorViper1(t *testing.T) {
opts_str := []byte(`
interval: 1s
queries:
-
query: "select Name, FileSystem, FreeSpace, Size from Win32_LogicalDisk where MediaType=11 or mediatype=12"
metrics:
-
value_from: "Size"
metric: "win.wmi.fs.size.bytes"
tags: {
"mount": "{{.Name}}",
}
-
value_from: "FreeSpace"
metric: "win.wmi.fs.freespace.bytes"
tags: {
"mount": "{{.Name}}",
}
`)
vp := viper.New()
var opts config.Config_win_wmi
vp.SetConfigType("yaml")
vp.ReadConfig(bytes.NewBuffer(opts_str))
vp.Marshal(&opts)
fmt.Printf("opts loaded from viper: %+v \n", opts)
sub := newcore.Subscribe(MustNewWinWmiCollector("c1", "prefix", opts), nil)
time.AfterFunc(time.Second*1, func() {
sub.Close()
})
timeout := time.After(time.Second * time.Duration(2))
main_loop:
for {
select {
case md, openning := <-sub.Updates():
if openning {
if md == nil {
fmt.Println("md is nil")
} else {
is_mount_c_exists := false
for _, dp := range md {
fmt.Println("dp: ---> ", dp)
if _, ok := dp.Tags["host"]; ok == false {
t.Error("host is not in tags")
return
}
if !strings.HasPrefix(dp.Metric.Clean(), "prefix.win.wmi.") {
t.Error("metric wrong")
return
}
m, ok := dp.Tags["mount"]
if ok && strings.ToLower(m) == "c" {
is_mount_c_exists = true
}
}
if is_mount_c_exists == false {
t.Error("mount c is not exists")
}
}
} else {
break main_loop
}
case <-timeout:
t.Error("timed out! something is blocking")
break main_loop
}
}
}
func TestWinWmiCollector(t *testing.T) {
opts := config.Config_win_wmi{
Interval: "1s",
Queries: []config.Config_win_wmi_query{
{Query: "select Name, FileSystem, FreeSpace, Size from Win32_LogicalDisk where MediaType=11 or mediatype=12",
Metrics: []config.Config_win_wmi_query_metric{
{Value_from: "Size",
Metric: "win.wmi.fs.size.bytes",
Tags: newcore.TagSet{
"mount": "{{.Name}}",
},
},
}},
},
}
sub := newcore.Subscribe(MustNewWinWmiCollector("c1", "prefix", opts), nil)
time.AfterFunc(time.Second*1, func() {
sub.Close()
})
timeout := time.After(time.Second * time.Duration(2))
main_loop:
for {
select {
case md, openning := <-sub.Updates():
if openning {
if md == nil {
fmt.Println("md is nil")
} else {
is_mount_c_exists := false
for _, dp := range md {
fmt.Println("dp: ---> ", dp)
if _, ok := dp.Tags["host"]; ok == false {
t.Error("host is not in tags")
return
}
if !strings.HasPrefix(dp.Metric.Clean(), "prefix.win.wmi.") {
t.Error("metric wrong")
return
}
m, ok := dp.Tags["mount"]
if ok && strings.ToLower(m) == "c" {
is_mount_c_exists = true
}
}
if is_mount_c_exists == false {
t.Error("mount c is not exists")
}
}
} else {
break main_loop
}
case <-timeout:
t.Error("timed out! something is blocking")
break main_loop
}
}
}