func TestCollectorPrefix(t *testing.T) {
logrus.SetLevel(logrus.ErrorLevel)
c := make(map[string]interface{})
c["interval"] = 1
c["prefix"] = "px."
collector := collector.New("Test")
collector.SetInterval(1)
collector.Configure(c)
collectorChannel := map[string]chan metric.Metric{
"Test": make(chan metric.Metric),
}
testHandler := handler.New("Log")
testHandler.SetCollectorChannels(collectorChannel)
var wg sync.WaitGroup
wg.Add(2)
go func() {
defer wg.Done()
collector.Channel() <- metric.New("hello")
close(collector.Channel())
}()
go func() {
defer wg.Done()
testMetric := <-collectorChannel["Test"]
assert.Equal(t, "px.hello", testMetric.Name)
}()
readFromCollector(collector, []handler.Handler{testHandler})
wg.Wait()
}
func TestReadFromCollector(t *testing.T) {
logrus.SetLevel(logrus.ErrorLevel)
c := make(map[string]interface{})
c["interval"] = 1
collector := collector.New("Test")
collector.SetInterval(1)
collector.Configure(c)
var wg sync.WaitGroup
wg.Add(2)
collectorStatChannel := make(chan metric.CollectorEmission)
go func() {
defer wg.Done()
collector.Channel() <- metric.New("hello")
time.Sleep(time.Duration(2) * time.Second)
m2 := metric.New("world")
m2.AddDimension("collectorCanonicalName", "Foobar")
collector.Channel() <- m2
time.Sleep(time.Duration(2) * time.Second)
m2.AddDimension("collectorCanonicalName", "Foobar")
collector.Channel() <- m2
close(collector.Channel())
}()
collectorMetrics := map[string]uint64{}
go func() {
defer wg.Done()
for collectorMetric := range collectorStatChannel {
collectorMetrics[collectorMetric.Name] = collectorMetric.EmissionCount
}
}()
readFromCollector(collector, []handler.Handler{}, collectorStatChannel)
wg.Wait()
assert.Equal(t, uint64(1), collectorMetrics["Test"])
assert.Equal(t, uint64(2), collectorMetrics["Foobar"])
}
func TestCollectorBlacklist(t *testing.T) {
logrus.SetLevel(logrus.ErrorLevel)
c := make(map[string]interface{})
c["interval"] = 1
c["metrics_blacklist"] = []string{"m[0-9]+$"}
col := collector.New("Test")
col.SetInterval(1)
col.Configure(c)
var wg sync.WaitGroup
wg.Add(2)
collectorStatChannel := make(chan metric.CollectorEmission)
go func() {
defer wg.Done()
col.Channel() <- metric.New("m1")
time.Sleep(time.Duration(2) * time.Second)
col.Channel() <- metric.New("m2")
time.Sleep(time.Duration(2) * time.Second)
col.Channel() <- metric.New("metric3")
close(col.Channel())
}()
collectorMetrics := map[string]uint64{}
go func() {
defer wg.Done()
for collectorMetric := range collectorStatChannel {
collectorMetrics[collectorMetric.Name] = collectorMetric.EmissionCount
}
}()
readFromCollector(col, []handler.Handler{}, collectorStatChannel)
wg.Wait()
assert.Equal(t, uint64(1), collectorMetrics["Test"])
}
func startCollector(name string) collector.Collector {
log.Debug("Starting collector ", name)
collector := collector.New(name)
readCollectorConfig(collector)
go runCollector(collector)
return collector
}
func startCollector(name string, config map[string]interface{}) collector.Collector {
log.Debug("Starting collector ", name)
collector := collector.New(name)
collector.Configure(config)
go runCollector(collector)
return collector
}
func startCollector(name string, globalConfig config.Config, instanceConfig map[string]interface{}) collector.Collector {
log.Debug("Starting collector ", name)
collectorInst := collector.New(name)
if collectorInst == nil {
return nil
}
// apply the global configs
collectorInst.SetInterval(config.GetAsInt(globalConfig.Interval, collector.DefaultCollectionInterval))
// apply the instance configs
collectorInst.Configure(instanceConfig)
go runCollector(collectorInst)
return collectorInst
}