Example #1
0
func TestOccurences(t *testing.T) {
	c := testCondition(test_f(0), nil, nil, 2)
	pipe := testPolicy(c, nil, map[string]string{"host": "test"}, nil)
	p, ta := testPipeline(map[string]*alarm.Policy{"test": pipe})
	defer p.index.Delete()
	e := event.NewEvent()
	e.Host = "test"
	e.Service = "test"
	e.Metric = 1.0

	p.Pass(e)
	e.Wait()

	ta.Do(func(ta *test.TestAlert) {
		if len(ta.Events) != 0 {
			t.Error("occrences hit too early")
		}
	})
	e = event.NewEvent()
	e.Host = "test"
	e.Service = "test"
	e.Metric = 1.0

	p.Pass(e)
	e.Wait()

	ta.Do(func(ta *test.TestAlert) {
		if len(ta.Events) != 1 {
			t.Error("occrences not hit", ta.Events)
		}
	})
}
Example #2
0
func TestProcess(t *testing.T) {
	c := testCondition(test_f(0), nil, nil, 0)
	pipe := testPolicy(c, nil, map[string]string{"host": "test"}, nil)
	p, ta := testPipeline(map[string]*alarm.Policy{"test": pipe})
	defer p.index.Delete()
	e := event.NewEvent()
	e.Host = "test"
	e.Service = "test"
	e.Metric = 1.0

	p.Process(e)
	e.Wait()

	if len(ta.Events) != 1 {
		t.Fatal(ta.Events)
	}

	e = event.NewEvent()
	e.Host = "test"
	e.Service = "test"
	e.Metric = -1.0

	p.Process(e)
	e.Wait()
	if ta.Events[e] != event.OK {
		t.Fatal(ta.Events)
	}

}
Example #3
0
func TestRefresh(t *testing.T) {
	x := runningTestContext()
	x.runTest(func(p *Pipeline) {
		p.PassEvent(event.NewEvent())
		p.Refresh(config.NewDefaultConfig())
		p.PassEvent(event.NewEvent())
	})
}
Example #4
0
func TestKeepAlive(t *testing.T) {
	logrus.SetLevel(logrus.DebugLevel)
	c := testCondition(test_f(0), nil, nil, 1)
	pipe := testPolicy(c, nil, map[string]string{"service": "KeepAlive"}, nil)
	p, ta := testPipeline(map[string]*alarm.Policy{"test": pipe})
	defer p.index.Delete()
	e := event.NewEvent()
	e.Host = "one one"
	e.Service = "exit"
	e.Metric = -1

	p.Pass(e)
	e.Wait()

	p.keepAliveAge = time.Millisecond * 15
	p.keepAliveCheckTime = time.Millisecond * 50
	go p.checkExpired()
	time.Sleep(100 * time.Millisecond)

	ta.Do(func(ta *test.TestAlert) {
		if len(ta.Events) != 1 {
			t.Fatal(ta.Events)
		}
	})

}
Example #5
0
func TestProcessDedupe(t *testing.T) {
	c := testCondition(test_f(0), nil, nil, 0)
	pipe := testPolicy(c, nil, map[string]string{"host": "test"}, nil)
	p, ta := testPipeline(map[string]*alarm.Policy{"test": pipe})
	defer p.index.Delete()

	events := make([]*event.Event, 100)

	for i := 0; i < len(events); i++ {
		e := event.NewEvent()
		e.Host = "test"
		e.Service = "test"
		e.Metric = 1.0
		events[i] = e
	}

	p.Process(events[0])

	for i := 1; i < len(events); i++ {
		p.Process(events[i])
		events[i].Wait()
	}

	if len(ta.Events) != 1 {
		log.Println(ta.Events)
		t.Fail()
	}

}
Example #6
0
func newTestEvent(h, s string, m float64) *event.Event {
	e := event.NewEvent()
	e.Tags.Set("host", h)
	e.Tags.Set("service", s)
	e.Metric = m
	return e
}
Example #7
0
func TestKeepAlive(t *testing.T) {
	x := runningTestContext()
	x.runTest(func(p *Pipeline) {

		u := &config.User{}
		u.Permissions = config.WRITE

		ta := test.NewTestAlert()

		// add a escalation policy that will catch a keep alive
		p.UpdateConfig(func(c *config.AppConfig) error {
			esc := &escalation.EscalationPolicy{}
			esc.Crit = true
			esc.Escalations = []escalation.Escalation{ta}
			esc.Match = event.NewTagset(0)
			esc.Match.Set(INTERNAL_TAG_NAME, ".*")
			c.Escalations["test"] = esc
			esc.Compile()

			// create a condition for the KeepAlive
			pol := &escalation.Policy{}
			pol.Match = event.NewTagset(0)
			pol.Match.Set(INTERNAL_TAG_NAME, KEEP_ALIVE_INTERNAL_TAG)

			cond := &escalation.Condition{}
			cond.Simple = true
			cond.Greater = test_f(0)
			cond.WindowSize = 2
			cond.Occurences = 1
			pol.Crit = cond
			c.Policies["test"] = pol

			return nil

		}, u)

		// create an event
		e := event.NewEvent()
		e.Tags.Set("host", "test")
		p.PassEvent(e)
		e.WaitForState(event.StateComplete, time.Millisecond)

		time.Sleep(20 * time.Millisecond)
		p.checkExpired()
		time.Sleep(50 * time.Millisecond)

		if len(ta.Incidents) != 1 {
			t.Error(ta.Incidents)
		}

		ka := ta.Incidents[0].GetEvent()
		if ka.Get("host") != "test" {
			t.Fail()
		}

		if ka.Get(INTERNAL_TAG_NAME) != KEEP_ALIVE_INTERNAL_TAG {
			t.Fail()
		}
	})
}
Example #8
0
func TestPutIncident(t *testing.T) {
	x := runningTestContext()
	x.runTest(func(p *Pipeline) {
		in := event.NewIncident("test", event.OK, event.NewEvent())
		p.PutIncident(in)
	})
}
Example #9
0
func genEventSlice(size int) []*event.Event {
	e := make([]*event.Event, size)
	for i := range e {
		e[i] = event.NewEvent()
	}
	return e

}
Example #10
0
func TestPauseUnpause(t *testing.T) {
	x := runningTestContext()
	x.runTest(func(p *Pipeline) {
		// make sure events can go in and out
		e := event.NewEvent()
		p.PassEvent(e)
		p.Pause()

		for i := 0; i < 1000; i++ {
			p.PassEvent(event.NewEvent())
		}

		p.Unpause()

		// pass another event
		p.PassEvent(event.NewEvent())
	})
}
Example #11
0
func newTestEvent() *event.Event {
	e := event.NewEvent()
	e.Tags.Set("host", randomString(rand.Int()%50))
	e.Tags.Set("service", randomString(rand.Int()%50))
	e.Tags.Set("sub_service", randomString(rand.Int()%50))
	e.Time = time.Now()
	e.Metric = rand.Float64() * 100
	return e
}
Example #12
0
func TestDedupe(t *testing.T) {
	x := runningTestContext()
	x.runTest(func(p *Pipeline) {
		in := event.NewIncident("test", event.OK, event.NewEvent())
		p.PutIncident(in)

		if p.Dedupe(in) {
			t.Fatal("Incident was not deduped")
		}
	})
}
Example #13
0
func TestListIncidents(t *testing.T) {
	x := runningTestContext()
	x.runTest(func(p *Pipeline) {
		in := event.NewIncident("test", event.OK, event.NewEvent())
		p.PutIncident(in)

		if l := p.ListIncidents(); l[0].Policy != in.Policy {
			t.Fatal("Incident was not added to the index")
		}
	})
}
Example #14
0
func TestPausePipelineCache(t *testing.T) {
	logrus.SetLevel(logrus.DebugLevel)
	c := testCondition(test_f(0), nil, nil, 1)
	pipe := testPolicy(c, nil, map[string]string{"service": "wwoo"}, nil)
	p, _ := testPipeline(map[string]*alarm.Policy{"test": pipe})
	defer p.index.Delete()
	p.Start()
	p.Pause()
	for i := 0; i < 100; i++ {
		p.Pass(event.NewEvent())
	}

	p.Unpause()
}
Example #15
0
func TestPassEvent(t *testing.T) {
	x := baseTestContext()
	x.runTest(func(p *Pipeline) {
		e := event.NewEvent()
		go func() {
			p.PassEvent(e)
		}()

		ne := <-p.in
		if ne != e {
			t.Fatal()
		}
	})
}
Example #16
0
// create keep alive events for each hostname -> time pair
func createKeepAliveEvents(times map[string]time.Time) []*event.Event {
	n := time.Now()
	events := make([]*event.Event, len(times))
	x := 0
	for host, t := range times {
		e := event.NewEvent()
		e.Host = host
		e.Metric = n.Sub(t).Seconds()
		e.Service = KEEP_ALIVE_SERVICE_NAME

		events[x] = e
		x += 1
	}

	return events
}
Example #17
0
func genEvents(hosts, services []string, next chan *event.Event) {
	gen := func() *event.Event {
		e := event.NewEvent()
		e.Metric = rand.Float64() * 100
		e.Time = time.Now()
		e.Tags.Set("host", hosts[rand.Intn(len(hosts)-1)])
		e.Tags.Set("service", services[rand.Intn(len(services)-1)])
		return e
	}

	go func() {
		for {
			next <- gen()
		}
	}()
}
Example #18
0
// create keep alive events for each hostname -> time pair
func createKeepAliveEvents(times map[string]time.Time, tag string) []*event.Event {
	events := make([]*event.Event, len(times))
	i := 0
	now := time.Now()

	// fill out events
	for k, v := range times {
		e := event.NewEvent()
		e.Tags.Set(tag, k)
		e.Tags.Set(INTERNAL_TAG_NAME, KEEP_ALIVE_INTERNAL_TAG)
		e.Metric = now.Sub(v).Seconds()
		events[i] = e
		i++
	}
	return events
}
Example #19
0
func BenchmarkIndex(b *testing.B) {
	c := testCondition(test_f(0), nil, nil, 0)
	pipe := testPolicy(c, nil, map[string]string{"host": "test"}, nil)
	p, _ := testPipeline(map[string]*alarm.Policy{"test": pipe})
	defer p.index.Delete()

	e := event.NewEvent()

	e.Host = "test"
	e.Service = "test"
	e.Metric = -1.0

	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		e.Service = fmt.Sprintf("%d", i%1000)
		p.Process(e)
	}

	e.Wait()
}
Example #20
0
func (t *TCPProvider) consume(c *net.TCPConn, p event.EventPasser) {

	// create a newman connection
	conn := newman.NewConn(c)
	conn.SetWaiter(&newman.Backoff{})

	// drain the connection for ever
	in, _ := conn.Generate(func() newman.Message {
		return event.NewEvent()
	})
	for raw := range in {
		// convert it to an event because we know that is what we are getting
		e := raw.(*event.Event)

		// pass it on to the next step
		p.PassEvent(e)
	}

	// when it is done, close the connection
	c.Close()
}
Example #21
0
func TestMatchPolicy(t *testing.T) {
	c := testCondition(test_f(0), nil, nil, 1)
	pipe := testPolicy(c, nil, map[string]string{"host": "test"}, nil)
	p, ta := testPipeline(map[string]*alarm.Policy{"test": pipe})
	defer p.index.Delete()
	e := event.NewEvent()
	e.Host = "test"
	e.Service = "test"
	e.Metric = 1.0

	p.Process(e)
	e.Wait()
	if len(ta.Events) == 0 {
		t.Fatal()
	}
	ta.Do(func(ta *test.TestAlert) {
		for k, _ := range ta.Events {
			if k.IndexName() != e.IndexName() {
				t.Fatal(k.IndexName(), e.IndexName())
			}
		}
	})
}
Example #22
0
func TestResolve(t *testing.T) {
	x := runningTestContext()
	x.runTest(func(p *Pipeline) {
		u := &config.User{}
		u.Permissions = config.WRITE

		ta := test.NewTestAlert()

		// add a escalation policy that will catch our metrics
		p.UpdateConfig(func(c *config.AppConfig) error {
			esc := &escalation.EscalationPolicy{}
			esc.Crit = true
			esc.Ok = true
			esc.Escalations = []escalation.Escalation{ta}
			esc.Match = event.NewTagset(0)
			esc.Match.Set("host", ".*")
			c.Escalations["test"] = esc
			esc.Compile()

			// create a policy that will match against this host
			pol := &escalation.Policy{}
			pol.Match = event.NewTagset(0)
			pol.Match.Set("host", ".*")

			cond := &escalation.Condition{}
			cond.Simple = true
			cond.Greater = test_f(1)
			cond.WindowSize = 2
			cond.Occurences = 1
			pol.Crit = cond
			c.Policies["test"] = pol

			return nil

		}, u)

		// create an event
		e := event.NewEvent()

		e.Metric = 4
		e.Tags.Set("host", "test")
		p.PassEvent(e)
		e.WaitForState(event.StateComplete, time.Millisecond)

		// TODO get rid of waiting for things to pass through the pipeline
		time.Sleep(20 * time.Millisecond)
		if len(ta.Incidents) != 1 {
			t.Error(ta.Incidents)
		}

		time.Sleep(20 * time.Millisecond)

		e.Metric = 0
		p.PassEvent(e)
		e.WaitForState(event.StateComplete, time.Millisecond)
		time.Sleep(10 * time.Millisecond)
		if len(ta.Incidents) != 2 {
			t.Error(ta.Incidents[0])
		}
	})
}